配置

.gitignore

@@ -0,0 +1 @@
+node_modules

dist/dev/mp-weixin/app.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common_vendor = require("./common/vendor.js");
+if (!Math) {
+  "./pages/index/index.js";
+  "./pages/my/index.js";
+  "./pagesOne/winner/index.js";
+  "./pagesOne/winner/uploadImage.js";
+}
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  __name: "App",
+  setup(__props) {
+    common_vendor.onLaunch(() => {
+      console.log("App Launch");
+    });
+    common_vendor.onShow(() => {
+      console.log("App Show");
+    });
+    common_vendor.onHide(() => {
+      console.log("App Hide");
+    });
+    return () => {
+    };
+  }
+});
+function createApp() {
+  const app = common_vendor.createSSRApp(_sfc_main);
+  app.use(common_vendor.createPinia());
+  return {
+    app
+  };
+}
+createApp().app.mount("#app");
+exports.createApp = createApp;

dist/dev/mp-weixin/app.json

@@ -0,0 +1,42 @@
+{
+  "pages": [
+    "pages/index/index",
+    "pages/my/index"
+  ],
+  "subPackages": [
+    {
+      "root": "pagesOne",
+      "pages": [
+        "winner/index",
+        "winner/uploadImage"
+      ]
+    }
+  ],
+  "window": {
+    "navigationBarTextStyle": "black",
+    "navigationBarTitleText": "uni-app",
+    "navigationBarBackgroundColor": "#F8F8F8",
+    "backgroundColor": "#F8F8F8"
+  },
+  "tabBar": {
+    "color": "#A5AEC1",
+    "selectedColor": "#1D212A",
+    "backgroundColor": "#fff",
+    "borderStyle": "white",
+    "list": [
+      {
+        "text": "首页",
+        "pagePath": "pages/index/index",
+        "iconPath": "static/images/home_default.png",
+        "selectedIconPath": "static/images/home_selected.png"
+      },
+      {
+        "text": "我的",
+        "pagePath": "pages/my/index",
+        "iconPath": "static/images/user_default.png",
+        "selectedIconPath": "static/images/user_selected.png"
+      }
+    ]
+  },
+  "usingComponents": {}
+}

dist/dev/mp-weixin/app.wxss

@@ -0,0 +1 @@
+page{--status-bar-height:25px;--top-window-height:0px;--window-top:0px;--window-bottom:0px;--window-left:0px;--window-right:0px;--window-magin:0px}[data-c-h="true"]{display: none !important;}

dist/dev/mp-weixin/common/assets.js

@@ -0,0 +1,3 @@
+"use strict";
+const _imports_0 = "/static/logo.png";
+exports._imports_0 = _imports_0;

dist/dev/mp-weixin/common/vendor.js

@@ -0,0 +1,9392 @@
+"use strict";
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+/**
+* @vue/shared v3.4.21
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+function makeMap(str, expectsLowerCase) {
+  const set2 = new Set(str.split(","));
+  return (val) => set2.has(val);
+}
+const EMPTY_OBJ = Object.freeze({});
+const EMPTY_ARR = Object.freeze([]);
+const NOOP = () => {
+};
+const NO = () => false;
+const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
+(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
+const isModelListener = (key) => key.startsWith("onUpdate:");
+const extend = Object.assign;
+const remove = (arr, el) => {
+  const i = arr.indexOf(el);
+  if (i > -1) {
+    arr.splice(i, 1);
+  }
+};
+const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
+const isArray$1 = Array.isArray;
+const isMap = (val) => toTypeString(val) === "[object Map]";
+const isSet = (val) => toTypeString(val) === "[object Set]";
+const isFunction$1 = (val) => typeof val === "function";
+const isString$1 = (val) => typeof val === "string";
+const isSymbol = (val) => typeof val === "symbol";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise$1 = (val) => {
+  return (isObject(val) || isFunction$1(val)) && isFunction$1(val.then) && isFunction$1(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+const isPlainObject = (val) => toTypeString(val) === "[object Object]";
+const isIntegerKey = (key) => isString$1(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+const isReservedProp = /* @__PURE__ */ makeMap(
+  // the leading comma is intentional so empty string "" is also included
+  ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
+);
+const isBuiltInDirective = /* @__PURE__ */ makeMap(
+  "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
+);
+const cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+const camelizeRE = /-(\w)/g;
+const camelize = cacheStringFunction((str) => {
+  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction(
+  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+);
+const capitalize = cacheStringFunction((str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+const toHandlerKey = cacheStringFunction((str) => {
+  const s2 = str ? `on${capitalize(str)}` : ``;
+  return s2;
+});
+const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+const invokeArrayFns$1 = (fns, arg) => {
+  for (let i = 0; i < fns.length; i++) {
+    fns[i](arg);
+  }
+};
+const def = (obj, key, value) => {
+  Object.defineProperty(obj, key, {
+    configurable: true,
+    enumerable: false,
+    value
+  });
+};
+const looseToNumber = (val) => {
+  const n2 = parseFloat(val);
+  return isNaN(n2) ? val : n2;
+};
+let _globalThis;
+const getGlobalThis = () => {
+  return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+};
+function normalizeStyle(value) {
+  if (isArray$1(value)) {
+    const res = {};
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      const normalized = isString$1(item) ? parseStringStyle(item) : normalizeStyle(item);
+      if (normalized) {
+        for (const key in normalized) {
+          res[key] = normalized[key];
+        }
+      }
+    }
+    return res;
+  } else if (isString$1(value) || isObject(value)) {
+    return value;
+  }
+}
+const listDelimiterRE = /;(?![^(]*\))/g;
+const propertyDelimiterRE = /:([^]+)/;
+const styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+  const ret = {};
+  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+    if (item) {
+      const tmp = item.split(propertyDelimiterRE);
+      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+    }
+  });
+  return ret;
+}
+function normalizeClass(value) {
+  let res = "";
+  if (isString$1(value)) {
+    res = value;
+  } else if (isArray$1(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const normalized = normalizeClass(value[i]);
+      if (normalized) {
+        res += normalized + " ";
+      }
+    }
+  } else if (isObject(value)) {
+    for (const name in value) {
+      if (value[name]) {
+        res += name + " ";
+      }
+    }
+  }
+  return res.trim();
+}
+const toDisplayString = (val) => {
+  return isString$1(val) ? val : val == null ? "" : isArray$1(val) || isObject(val) && (val.toString === objectToString || !isFunction$1(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
+};
+const replacer = (_key, val) => {
+  if (val && val.__v_isRef) {
+    return replacer(_key, val.value);
+  } else if (isMap(val)) {
+    return {
+      [`Map(${val.size})`]: [...val.entries()].reduce(
+        (entries, [key, val2], i) => {
+          entries[stringifySymbol(key, i) + " =>"] = val2;
+          return entries;
+        },
+        {}
+      )
+    };
+  } else if (isSet(val)) {
+    return {
+      [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
+    };
+  } else if (isSymbol(val)) {
+    return stringifySymbol(val);
+  } else if (isObject(val) && !isArray$1(val) && !isPlainObject(val)) {
+    return String(val);
+  }
+  return val;
+};
+const stringifySymbol = (v, i = "") => {
+  var _a;
+  return isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v;
+};
+const SLOT_DEFAULT_NAME = "d";
+const ON_SHOW = "onShow";
+const ON_HIDE = "onHide";
+const ON_LAUNCH = "onLaunch";
+const ON_ERROR = "onError";
+const ON_THEME_CHANGE = "onThemeChange";
+const ON_PAGE_NOT_FOUND = "onPageNotFound";
+const ON_UNHANDLE_REJECTION = "onUnhandledRejection";
+const ON_EXIT = "onExit";
+const ON_LOAD = "onLoad";
+const ON_READY = "onReady";
+const ON_UNLOAD = "onUnload";
+const ON_INIT = "onInit";
+const ON_SAVE_EXIT_STATE = "onSaveExitState";
+const ON_RESIZE = "onResize";
+const ON_BACK_PRESS = "onBackPress";
+const ON_PAGE_SCROLL = "onPageScroll";
+const ON_TAB_ITEM_TAP = "onTabItemTap";
+const ON_REACH_BOTTOM = "onReachBottom";
+const ON_PULL_DOWN_REFRESH = "onPullDownRefresh";
+const ON_SHARE_TIMELINE = "onShareTimeline";
+const ON_SHARE_CHAT = "onShareChat";
+const ON_ADD_TO_FAVORITES = "onAddToFavorites";
+const ON_SHARE_APP_MESSAGE = "onShareAppMessage";
+const ON_NAVIGATION_BAR_BUTTON_TAP = "onNavigationBarButtonTap";
+const ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED = "onNavigationBarSearchInputClicked";
+const ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED = "onNavigationBarSearchInputChanged";
+const ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED = "onNavigationBarSearchInputConfirmed";
+const ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED = "onNavigationBarSearchInputFocusChanged";
+function hasLeadingSlash(str) {
+  return str.indexOf("/") === 0;
+}
+function addLeadingSlash(str) {
+  return hasLeadingSlash(str) ? str : "/" + str;
+}
+const invokeArrayFns = (fns, arg) => {
+  let ret;
+  for (let i = 0; i < fns.length; i++) {
+    ret = fns[i](arg);
+  }
+  return ret;
+};
+function once(fn, ctx = null) {
+  let res;
+  return (...args) => {
+    if (fn) {
+      res = fn.apply(ctx, args);
+      fn = null;
+    }
+    return res;
+  };
+}
+function getValueByDataPath(obj, path) {
+  if (!isString$1(path)) {
+    return;
+  }
+  path = path.replace(/\[(\d+)\]/g, ".$1");
+  const parts = path.split(".");
+  let key = parts[0];
+  if (!obj) {
+    obj = {};
+  }
+  if (parts.length === 1) {
+    return obj[key];
+  }
+  return getValueByDataPath(obj[key], parts.slice(1).join("."));
+}
+function sortObject(obj) {
+  let sortObj = {};
+  if (isPlainObject(obj)) {
+    Object.keys(obj).sort().forEach((key) => {
+      const _key = key;
+      sortObj[_key] = obj[_key];
+    });
+  }
+  return !Object.keys(sortObj) ? obj : sortObj;
+}
+const customizeRE = /:/g;
+function customizeEvent(str) {
+  return camelize(str.replace(customizeRE, "-"));
+}
+const encode$1 = encodeURIComponent;
+function stringifyQuery(obj, encodeStr = encode$1) {
+  const res = obj ? Object.keys(obj).map((key) => {
+    let val = obj[key];
+    if (typeof val === void 0 || val === null) {
+      val = "";
+    } else if (isPlainObject(val)) {
+      val = JSON.stringify(val);
+    }
+    return encodeStr(key) + "=" + encodeStr(val);
+  }).filter((x) => x.length > 0).join("&") : null;
+  return res ? `?${res}` : "";
+}
+const PAGE_HOOKS = [
+  ON_INIT,
+  ON_LOAD,
+  ON_SHOW,
+  ON_HIDE,
+  ON_UNLOAD,
+  ON_BACK_PRESS,
+  ON_PAGE_SCROLL,
+  ON_TAB_ITEM_TAP,
+  ON_REACH_BOTTOM,
+  ON_PULL_DOWN_REFRESH,
+  ON_SHARE_TIMELINE,
+  ON_SHARE_APP_MESSAGE,
+  ON_SHARE_CHAT,
+  ON_ADD_TO_FAVORITES,
+  ON_SAVE_EXIT_STATE,
+  ON_NAVIGATION_BAR_BUTTON_TAP,
+  ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED,
+  ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED,
+  ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED,
+  ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED
+];
+function isRootHook(name) {
+  return PAGE_HOOKS.indexOf(name) > -1;
+}
+const UniLifecycleHooks = [
+  ON_SHOW,
+  ON_HIDE,
+  ON_LAUNCH,
+  ON_ERROR,
+  ON_THEME_CHANGE,
+  ON_PAGE_NOT_FOUND,
+  ON_UNHANDLE_REJECTION,
+  ON_EXIT,
+  ON_INIT,
+  ON_LOAD,
+  ON_READY,
+  ON_UNLOAD,
+  ON_RESIZE,
+  ON_BACK_PRESS,
+  ON_PAGE_SCROLL,
+  ON_TAB_ITEM_TAP,
+  ON_REACH_BOTTOM,
+  ON_PULL_DOWN_REFRESH,
+  ON_SHARE_TIMELINE,
+  ON_ADD_TO_FAVORITES,
+  ON_SHARE_APP_MESSAGE,
+  ON_SHARE_CHAT,
+  ON_SAVE_EXIT_STATE,
+  ON_NAVIGATION_BAR_BUTTON_TAP,
+  ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED,
+  ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED,
+  ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED,
+  ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED
+];
+const MINI_PROGRAM_PAGE_RUNTIME_HOOKS = /* @__PURE__ */ (() => {
+  return {
+    onPageScroll: 1,
+    onShareAppMessage: 1 << 1,
+    onShareTimeline: 1 << 2
+  };
+})();
+function isUniLifecycleHook(name, value, checkType = true) {
+  if (checkType && !isFunction$1(value)) {
+    return false;
+  }
+  if (UniLifecycleHooks.indexOf(name) > -1) {
+    return true;
+  } else if (name.indexOf("on") === 0) {
+    return true;
+  }
+  return false;
+}
+let vueApp;
+const createVueAppHooks = [];
+function onCreateVueApp(hook) {
+  if (vueApp) {
+    return hook(vueApp);
+  }
+  createVueAppHooks.push(hook);
+}
+function invokeCreateVueAppHook(app) {
+  vueApp = app;
+  createVueAppHooks.forEach((hook) => hook(app));
+}
+const invokeCreateErrorHandler = once((app, createErrorHandler2) => {
+  if (isFunction$1(app._component.onError)) {
+    return createErrorHandler2(app);
+  }
+});
+const E = function() {
+};
+E.prototype = {
+  _id: 1,
+  on: function(name, callback, ctx) {
+    var e2 = this.e || (this.e = {});
+    (e2[name] || (e2[name] = [])).push({
+      fn: callback,
+      ctx,
+      _id: this._id
+    });
+    return this._id++;
+  },
+  once: function(name, callback, ctx) {
+    var self2 = this;
+    function listener() {
+      self2.off(name, listener);
+      callback.apply(ctx, arguments);
+    }
+    listener._ = callback;
+    return this.on(name, listener, ctx);
+  },
+  emit: function(name) {
+    var data = [].slice.call(arguments, 1);
+    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+    var i = 0;
+    var len = evtArr.length;
+    for (i; i < len; i++) {
+      evtArr[i].fn.apply(evtArr[i].ctx, data);
+    }
+    return this;
+  },
+  off: function(name, event) {
+    var e2 = this.e || (this.e = {});
+    var evts = e2[name];
+    var liveEvents = [];
+    if (evts && event) {
+      for (var i = evts.length - 1; i >= 0; i--) {
+        if (evts[i].fn === event || evts[i].fn._ === event || evts[i]._id === event) {
+          evts.splice(i, 1);
+          break;
+        }
+      }
+      liveEvents = evts;
+    }
+    liveEvents.length ? e2[name] = liveEvents : delete e2[name];
+    return this;
+  }
+};
+var E$1 = E;
+const LOCALE_ZH_HANS = "zh-Hans";
+const LOCALE_ZH_HANT = "zh-Hant";
+const LOCALE_EN = "en";
+const LOCALE_FR = "fr";
+const LOCALE_ES = "es";
+function include(str, parts) {
+  return !!parts.find((part) => str.indexOf(part) !== -1);
+}
+function startsWith(str, parts) {
+  return parts.find((part) => str.indexOf(part) === 0);
+}
+function normalizeLocale(locale, messages2) {
+  if (!locale) {
+    return;
+  }
+  locale = locale.trim().replace(/_/g, "-");
+  locale = locale.toLowerCase();
+  if (locale === "chinese") {
+    return LOCALE_ZH_HANS;
+  }
+  if (locale.indexOf("zh") === 0) {
+    if (locale.indexOf("-hans") > -1) {
+      return LOCALE_ZH_HANS;
+    }
+    if (locale.indexOf("-hant") > -1) {
+      return LOCALE_ZH_HANT;
+    }
+    if (include(locale, ["-tw", "-hk", "-mo", "-cht"])) {
+      return LOCALE_ZH_HANT;
+    }
+    return LOCALE_ZH_HANS;
+  }
+  let locales = [LOCALE_EN, LOCALE_FR, LOCALE_ES];
+  const lang2 = startsWith(locale, locales);
+  if (lang2) {
+    return lang2;
+  }
+}
+function getBaseSystemInfo() {
+  return wx.getSystemInfoSync();
+}
+function validateProtocolFail(name, msg) {
+  console.warn(`${name}: ${msg}`);
+}
+function validateProtocol(name, data, protocol, onFail) {
+  if (!onFail) {
+    onFail = validateProtocolFail;
+  }
+  for (const key in protocol) {
+    const errMsg = validateProp$1(key, data[key], protocol[key], !hasOwn(data, key));
+    if (isString$1(errMsg)) {
+      onFail(name, errMsg);
+    }
+  }
+}
+function validateProtocols(name, args, protocol, onFail) {
+  if (!protocol) {
+    return;
+  }
+  if (!isArray$1(protocol)) {
+    return validateProtocol(name, args[0] || /* @__PURE__ */ Object.create(null), protocol, onFail);
+  }
+  const len = protocol.length;
+  const argsLen = args.length;
+  for (let i = 0; i < len; i++) {
+    const opts = protocol[i];
+    const data = /* @__PURE__ */ Object.create(null);
+    if (argsLen > i) {
+      data[opts.name] = args[i];
+    }
+    validateProtocol(name, data, { [opts.name]: opts }, onFail);
+  }
+}
+function validateProp$1(name, value, prop, isAbsent) {
+  if (!isPlainObject(prop)) {
+    prop = { type: prop };
+  }
+  const { type, required, validator } = prop;
+  if (required && isAbsent) {
+    return 'Missing required args: "' + name + '"';
+  }
+  if (value == null && !required) {
+    return;
+  }
+  if (type != null) {
+    let isValid = false;
+    const types = isArray$1(type) ? type : [type];
+    const expectedTypes = [];
+    for (let i = 0; i < types.length && !isValid; i++) {
+      const { valid, expectedType } = assertType$1(value, types[i]);
+      expectedTypes.push(expectedType || "");
+      isValid = valid;
+    }
+    if (!isValid) {
+      return getInvalidTypeMessage$1(name, value, expectedTypes);
+    }
+  }
+  if (validator) {
+    return validator(value);
+  }
+}
+const isSimpleType$1 = /* @__PURE__ */ makeMap("String,Number,Boolean,Function,Symbol");
+function assertType$1(value, type) {
+  let valid;
+  const expectedType = getType$2(type);
+  if (isSimpleType$1(expectedType)) {
+    const t2 = typeof value;
+    valid = t2 === expectedType.toLowerCase();
+    if (!valid && t2 === "object") {
+      valid = value instanceof type;
+    }
+  } else if (expectedType === "Object") {
+    valid = isObject(value);
+  } else if (expectedType === "Array") {
+    valid = isArray$1(value);
+  } else {
+    {
+      valid = value instanceof type;
+    }
+  }
+  return {
+    valid,
+    expectedType
+  };
+}
+function getInvalidTypeMessage$1(name, value, expectedTypes) {
+  let message = `Invalid args: type check failed for args "${name}". Expected ${expectedTypes.map(capitalize).join(", ")}`;
+  const expectedType = expectedTypes[0];
+  const receivedType = toRawType(value);
+  const expectedValue = styleValue$1(value, expectedType);
+  const receivedValue = styleValue$1(value, receivedType);
+  if (expectedTypes.length === 1 && isExplicable$1(expectedType) && !isBoolean$1(expectedType, receivedType)) {
+    message += ` with value ${expectedValue}`;
+  }
+  message += `, got ${receivedType} `;
+  if (isExplicable$1(receivedType)) {
+    message += `with value ${receivedValue}.`;
+  }
+  return message;
+}
+function getType$2(ctor) {
+  const match = ctor && ctor.toString().match(/^\s*function (\w+)/);
+  return match ? match[1] : "";
+}
+function styleValue$1(value, type) {
+  if (type === "String") {
+    return `"${value}"`;
+  } else if (type === "Number") {
+    return `${Number(value)}`;
+  } else {
+    return `${value}`;
+  }
+}
+function isExplicable$1(type) {
+  const explicitTypes = ["string", "number", "boolean"];
+  return explicitTypes.some((elem) => type.toLowerCase() === elem);
+}
+function isBoolean$1(...args) {
+  return args.some((elem) => elem.toLowerCase() === "boolean");
+}
+function tryCatch(fn) {
+  return function() {
+    try {
+      return fn.apply(fn, arguments);
+    } catch (e2) {
+      console.error(e2);
+    }
+  };
+}
+let invokeCallbackId = 1;
+const invokeCallbacks = {};
+function addInvokeCallback(id, name, callback, keepAlive = false) {
+  invokeCallbacks[id] = {
+    name,
+    keepAlive,
+    callback
+  };
+  return id;
+}
+function invokeCallback(id, res, extras) {
+  if (typeof id === "number") {
+    const opts = invokeCallbacks[id];
+    if (opts) {
+      if (!opts.keepAlive) {
+        delete invokeCallbacks[id];
+      }
+      return opts.callback(res, extras);
+    }
+  }
+  return res;
+}
+const API_SUCCESS = "success";
+const API_FAIL = "fail";
+const API_COMPLETE = "complete";
+function getApiCallbacks(args) {
+  const apiCallbacks = {};
+  for (const name in args) {
+    const fn = args[name];
+    if (isFunction$1(fn)) {
+      apiCallbacks[name] = tryCatch(fn);
+      delete args[name];
+    }
+  }
+  return apiCallbacks;
+}
+function normalizeErrMsg(errMsg, name) {
+  if (!errMsg || errMsg.indexOf(":fail") === -1) {
+    return name + ":ok";
+  }
+  return name + errMsg.substring(errMsg.indexOf(":fail"));
+}
+function createAsyncApiCallback(name, args = {}, { beforeAll, beforeSuccess } = {}) {
+  if (!isPlainObject(args)) {
+    args = {};
+  }
+  const { success, fail, complete } = getApiCallbacks(args);
+  const hasSuccess = isFunction$1(success);
+  const hasFail = isFunction$1(fail);
+  const hasComplete = isFunction$1(complete);
+  const callbackId = invokeCallbackId++;
+  addInvokeCallback(callbackId, name, (res) => {
+    res = res || {};
+    res.errMsg = normalizeErrMsg(res.errMsg, name);
+    isFunction$1(beforeAll) && beforeAll(res);
+    if (res.errMsg === name + ":ok") {
+      isFunction$1(beforeSuccess) && beforeSuccess(res, args);
+      hasSuccess && success(res);
+    } else {
+      hasFail && fail(res);
+    }
+    hasComplete && complete(res);
+  });
+  return callbackId;
+}
+const HOOK_SUCCESS = "success";
+const HOOK_FAIL = "fail";
+const HOOK_COMPLETE = "complete";
+const globalInterceptors = {};
+const scopedInterceptors = {};
+function wrapperHook(hook, params) {
+  return function(data) {
+    return hook(data, params) || data;
+  };
+}
+function queue$2(hooks, data, params) {
+  let promise = false;
+  for (let i = 0; i < hooks.length; i++) {
+    const hook = hooks[i];
+    if (promise) {
+      promise = Promise.resolve(wrapperHook(hook, params));
+    } else {
+      const res = hook(data, params);
+      if (isPromise$1(res)) {
+        promise = Promise.resolve(res);
+      }
+      if (res === false) {
+        return {
+          then() {
+          },
+          catch() {
+          }
+        };
+      }
+    }
+  }
+  return promise || {
+    then(callback) {
+      return callback(data);
+    },
+    catch() {
+    }
+  };
+}
+function wrapperOptions(interceptors2, options = {}) {
+  [HOOK_SUCCESS, HOOK_FAIL, HOOK_COMPLETE].forEach((name) => {
+    const hooks = interceptors2[name];
+    if (!isArray$1(hooks)) {
+      return;
+    }
+    const oldCallback = options[name];
+    options[name] = function callbackInterceptor(res) {
+      queue$2(hooks, res, options).then((res2) => {
+        return isFunction$1(oldCallback) && oldCallback(res2) || res2;
+      });
+    };
+  });
+  return options;
+}
+function wrapperReturnValue(method, returnValue) {
+  const returnValueHooks = [];
+  if (isArray$1(globalInterceptors.returnValue)) {
+    returnValueHooks.push(...globalInterceptors.returnValue);
+  }
+  const interceptor = scopedInterceptors[method];
+  if (interceptor && isArray$1(interceptor.returnValue)) {
+    returnValueHooks.push(...interceptor.returnValue);
+  }
+  returnValueHooks.forEach((hook) => {
+    returnValue = hook(returnValue) || returnValue;
+  });
+  return returnValue;
+}
+function getApiInterceptorHooks(method) {
+  const interceptor = /* @__PURE__ */ Object.create(null);
+  Object.keys(globalInterceptors).forEach((hook) => {
+    if (hook !== "returnValue") {
+      interceptor[hook] = globalInterceptors[hook].slice();
+    }
+  });
+  const scopedInterceptor = scopedInterceptors[method];
+  if (scopedInterceptor) {
+    Object.keys(scopedInterceptor).forEach((hook) => {
+      if (hook !== "returnValue") {
+        interceptor[hook] = (interceptor[hook] || []).concat(scopedInterceptor[hook]);
+      }
+    });
+  }
+  return interceptor;
+}
+function invokeApi(method, api, options, params) {
+  const interceptor = getApiInterceptorHooks(method);
+  if (interceptor && Object.keys(interceptor).length) {
+    if (isArray$1(interceptor.invoke)) {
+      const res = queue$2(interceptor.invoke, options);
+      return res.then((options2) => {
+        return api(wrapperOptions(getApiInterceptorHooks(method), options2), ...params);
+      });
+    } else {
+      return api(wrapperOptions(interceptor, options), ...params);
+    }
+  }
+  return api(options, ...params);
+}
+function hasCallback(args) {
+  if (isPlainObject(args) && [API_SUCCESS, API_FAIL, API_COMPLETE].find((cb) => isFunction$1(args[cb]))) {
+    return true;
+  }
+  return false;
+}
+function handlePromise(promise) {
+  return promise;
+}
+function promisify$1(name, fn) {
+  return (args = {}, ...rest) => {
+    if (hasCallback(args)) {
+      return wrapperReturnValue(name, invokeApi(name, fn, args, rest));
+    }
+    return wrapperReturnValue(name, handlePromise(new Promise((resolve2, reject) => {
+      invokeApi(name, fn, extend(args, { success: resolve2, fail: reject }), rest);
+    })));
+  };
+}
+function formatApiArgs(args, options) {
+  args[0];
+  {
+    return;
+  }
+}
+function invokeSuccess(id, name, res) {
+  const result = {
+    errMsg: name + ":ok"
+  };
+  return invokeCallback(id, extend(res || {}, result));
+}
+function invokeFail(id, name, errMsg, errRes = {}) {
+  const errMsgPrefix = name + ":fail";
+  let apiErrMsg = "";
+  if (!errMsg) {
+    apiErrMsg = errMsgPrefix;
+  } else if (errMsg.indexOf(errMsgPrefix) === 0) {
+    apiErrMsg = errMsg;
+  } else {
+    apiErrMsg = errMsgPrefix + " " + errMsg;
+  }
+  {
+    delete errRes.errCode;
+  }
+  let res = extend({ errMsg: apiErrMsg }, errRes);
+  return invokeCallback(id, res);
+}
+function beforeInvokeApi(name, args, protocol, options) {
+  {
+    validateProtocols(name, args, protocol);
+  }
+  const errMsg = formatApiArgs(args);
+  if (errMsg) {
+    return errMsg;
+  }
+}
+function parseErrMsg(errMsg) {
+  if (!errMsg || isString$1(errMsg)) {
+    return errMsg;
+  }
+  if (errMsg.stack) {
+    if (typeof globalThis === "undefined" || !globalThis.harmonyChannel) {
+      console.error(errMsg.message + "\n" + errMsg.stack);
+    }
+    return errMsg.message;
+  }
+  return errMsg;
+}
+function wrapperTaskApi(name, fn, protocol, options) {
+  return (args) => {
+    const id = createAsyncApiCallback(name, args, options);
+    const errMsg = beforeInvokeApi(name, [args], protocol);
+    if (errMsg) {
+      return invokeFail(id, name, errMsg);
+    }
+    return fn(args, {
+      resolve: (res) => invokeSuccess(id, name, res),
+      reject: (errMsg2, errRes) => invokeFail(id, name, parseErrMsg(errMsg2), errRes)
+    });
+  };
+}
+function wrapperSyncApi(name, fn, protocol, options) {
+  return (...args) => {
+    const errMsg = beforeInvokeApi(name, args, protocol);
+    if (errMsg) {
+      throw new Error(errMsg);
+    }
+    return fn.apply(null, args);
+  };
+}
+function wrapperAsyncApi(name, fn, protocol, options) {
+  return wrapperTaskApi(name, fn, protocol, options);
+}
+function defineSyncApi(name, fn, protocol, options) {
+  return wrapperSyncApi(name, fn, protocol);
+}
+function defineAsyncApi(name, fn, protocol, options) {
+  return promisify$1(name, wrapperAsyncApi(name, fn, protocol, options));
+}
+const API_UPX2PX = "upx2px";
+const Upx2pxProtocol = [
+  {
+    name: "upx",
+    type: [Number, String],
+    required: true
+  }
+];
+const EPS = 1e-4;
+const BASE_DEVICE_WIDTH = 750;
+let isIOS = false;
+let deviceWidth = 0;
+let deviceDPR = 0;
+function checkDeviceWidth() {
+  const { platform, pixelRatio, windowWidth } = getBaseSystemInfo();
+  deviceWidth = windowWidth;
+  deviceDPR = pixelRatio;
+  isIOS = platform === "ios";
+}
+const upx2px = defineSyncApi(API_UPX2PX, (number, newDeviceWidth) => {
+  if (deviceWidth === 0) {
+    checkDeviceWidth();
+  }
+  number = Number(number);
+  if (number === 0) {
+    return 0;
+  }
+  let width = newDeviceWidth || deviceWidth;
+  let result = number / BASE_DEVICE_WIDTH * width;
+  if (result < 0) {
+    result = -result;
+  }
+  result = Math.floor(result + EPS);
+  if (result === 0) {
+    if (deviceDPR === 1 || !isIOS) {
+      result = 1;
+    } else {
+      result = 0.5;
+    }
+  }
+  return number < 0 ? -result : result;
+}, Upx2pxProtocol);
+const API_ADD_INTERCEPTOR = "addInterceptor";
+const API_REMOVE_INTERCEPTOR = "removeInterceptor";
+const AddInterceptorProtocol = [
+  {
+    name: "method",
+    type: [String, Object],
+    required: true
+  }
+];
+const RemoveInterceptorProtocol = AddInterceptorProtocol;
+function mergeInterceptorHook(interceptors2, interceptor) {
+  Object.keys(interceptor).forEach((hook) => {
+    if (isFunction$1(interceptor[hook])) {
+      interceptors2[hook] = mergeHook(interceptors2[hook], interceptor[hook]);
+    }
+  });
+}
+function removeInterceptorHook(interceptors2, interceptor) {
+  if (!interceptors2 || !interceptor) {
+    return;
+  }
+  Object.keys(interceptor).forEach((name) => {
+    const hooks = interceptors2[name];
+    const hook = interceptor[name];
+    if (isArray$1(hooks) && isFunction$1(hook)) {
+      remove(hooks, hook);
+    }
+  });
+}
+function mergeHook(parentVal, childVal) {
+  const res = childVal ? parentVal ? parentVal.concat(childVal) : isArray$1(childVal) ? childVal : [childVal] : parentVal;
+  return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+  const res = [];
+  for (let i = 0; i < hooks.length; i++) {
+    if (res.indexOf(hooks[i]) === -1) {
+      res.push(hooks[i]);
+    }
+  }
+  return res;
+}
+const addInterceptor = defineSyncApi(API_ADD_INTERCEPTOR, (method, interceptor) => {
+  if (isString$1(method) && isPlainObject(interceptor)) {
+    mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor);
+  } else if (isPlainObject(method)) {
+    mergeInterceptorHook(globalInterceptors, method);
+  }
+}, AddInterceptorProtocol);
+const removeInterceptor = defineSyncApi(API_REMOVE_INTERCEPTOR, (method, interceptor) => {
+  if (isString$1(method)) {
+    if (isPlainObject(interceptor)) {
+      removeInterceptorHook(scopedInterceptors[method], interceptor);
+    } else {
+      delete scopedInterceptors[method];
+    }
+  } else if (isPlainObject(method)) {
+    removeInterceptorHook(globalInterceptors, method);
+  }
+}, RemoveInterceptorProtocol);
+const interceptors = {};
+const API_ON = "$on";
+const OnProtocol = [
+  {
+    name: "event",
+    type: String,
+    required: true
+  },
+  {
+    name: "callback",
+    type: Function,
+    required: true
+  }
+];
+const API_ONCE = "$once";
+const OnceProtocol = OnProtocol;
+const API_OFF = "$off";
+const OffProtocol = [
+  {
+    name: "event",
+    type: [String, Array]
+  },
+  {
+    name: "callback",
+    type: [Function, Number]
+  }
+];
+const API_EMIT = "$emit";
+const EmitProtocol = [
+  {
+    name: "event",
+    type: String,
+    required: true
+  }
+];
+class EventBus {
+  constructor() {
+    this.$emitter = new E$1();
+  }
+  on(name, callback) {
+    return this.$emitter.on(name, callback);
+  }
+  once(name, callback) {
+    return this.$emitter.once(name, callback);
+  }
+  off(name, callback) {
+    if (!name) {
+      this.$emitter.e = {};
+      return;
+    }
+    this.$emitter.off(name, callback);
+  }
+  emit(name, ...args) {
+    this.$emitter.emit(name, ...args);
+  }
+}
+const eventBus = new EventBus();
+const $on = defineSyncApi(API_ON, (name, callback) => {
+  eventBus.on(name, callback);
+  return () => eventBus.off(name, callback);
+}, OnProtocol);
+const $once = defineSyncApi(API_ONCE, (name, callback) => {
+  eventBus.once(name, callback);
+  return () => eventBus.off(name, callback);
+}, OnceProtocol);
+const $off = defineSyncApi(API_OFF, (name, callback) => {
+  if (!isArray$1(name))
+    name = name ? [name] : [];
+  name.forEach((n2) => eventBus.off(n2, callback));
+}, OffProtocol);
+const $emit = defineSyncApi(API_EMIT, (name, ...args) => {
+  eventBus.emit(name, ...args);
+}, EmitProtocol);
+let cid;
+let cidErrMsg;
+let enabled;
+function normalizePushMessage(message) {
+  try {
+    return JSON.parse(message);
+  } catch (e2) {
+  }
+  return message;
+}
+function invokePushCallback(args) {
+  if (args.type === "enabled") {
+    enabled = true;
+  } else if (args.type === "clientId") {
+    cid = args.cid;
+    cidErrMsg = args.errMsg;
+    invokeGetPushCidCallbacks(cid, args.errMsg);
+  } else if (args.type === "pushMsg") {
+    const message = {
+      type: "receive",
+      data: normalizePushMessage(args.message)
+    };
+    for (let i = 0; i < onPushMessageCallbacks.length; i++) {
+      const callback = onPushMessageCallbacks[i];
+      callback(message);
+      if (message.stopped) {
+        break;
+      }
+    }
+  } else if (args.type === "click") {
+    onPushMessageCallbacks.forEach((callback) => {
+      callback({
+        type: "click",
+        data: normalizePushMessage(args.message)
+      });
+    });
+  }
+}
+const getPushCidCallbacks = [];
+function invokeGetPushCidCallbacks(cid2, errMsg) {
+  getPushCidCallbacks.forEach((callback) => {
+    callback(cid2, errMsg);
+  });
+  getPushCidCallbacks.length = 0;
+}
+const API_GET_PUSH_CLIENT_ID = "getPushClientId";
+const getPushClientId = defineAsyncApi(API_GET_PUSH_CLIENT_ID, (_, { resolve: resolve2, reject }) => {
+  Promise.resolve().then(() => {
+    if (typeof enabled === "undefined") {
+      enabled = false;
+      cid = "";
+      cidErrMsg = "uniPush is not enabled";
+    }
+    getPushCidCallbacks.push((cid2, errMsg) => {
+      if (cid2) {
+        resolve2({ cid: cid2 });
+      } else {
+        reject(errMsg);
+      }
+    });
+    if (typeof cid !== "undefined") {
+      invokeGetPushCidCallbacks(cid, cidErrMsg);
+    }
+  });
+});
+const onPushMessageCallbacks = [];
+const onPushMessage = (fn) => {
+  if (onPushMessageCallbacks.indexOf(fn) === -1) {
+    onPushMessageCallbacks.push(fn);
+  }
+};
+const offPushMessage = (fn) => {
+  if (!fn) {
+    onPushMessageCallbacks.length = 0;
+  } else {
+    const index2 = onPushMessageCallbacks.indexOf(fn);
+    if (index2 > -1) {
+      onPushMessageCallbacks.splice(index2, 1);
+    }
+  }
+};
+const SYNC_API_RE = /^\$|getLocale|setLocale|sendNativeEvent|restoreGlobal|requireGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64|getDeviceInfo|getAppBaseInfo|getWindowInfo|getSystemSetting|getAppAuthorizeSetting/;
+const CONTEXT_API_RE = /^create|Manager$/;
+const CONTEXT_API_RE_EXC = ["createBLEConnection"];
+const ASYNC_API = ["createBLEConnection"];
+const CALLBACK_API_RE = /^on|^off/;
+function isContextApi(name) {
+  return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1;
+}
+function isSyncApi(name) {
+  return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1;
+}
+function isCallbackApi(name) {
+  return CALLBACK_API_RE.test(name) && name !== "onPush";
+}
+function shouldPromise(name) {
+  if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) {
+    return false;
+  }
+  return true;
+}
+if (!Promise.prototype.finally) {
+  Promise.prototype.finally = function(onfinally) {
+    const promise = this.constructor;
+    return this.then((value) => promise.resolve(onfinally && onfinally()).then(() => value), (reason) => promise.resolve(onfinally && onfinally()).then(() => {
+      throw reason;
+    }));
+  };
+}
+function promisify(name, api) {
+  if (!shouldPromise(name)) {
+    return api;
+  }
+  if (!isFunction$1(api)) {
+    return api;
+  }
+  return function promiseApi(options = {}, ...rest) {
+    if (isFunction$1(options.success) || isFunction$1(options.fail) || isFunction$1(options.complete)) {
+      return wrapperReturnValue(name, invokeApi(name, api, options, rest));
+    }
+    return wrapperReturnValue(name, handlePromise(new Promise((resolve2, reject) => {
+      invokeApi(name, api, extend({}, options, {
+        success: resolve2,
+        fail: reject
+      }), rest);
+    })));
+  };
+}
+const CALLBACKS = ["success", "fail", "cancel", "complete"];
+function initWrapper(protocols2) {
+  function processCallback(methodName, method, returnValue) {
+    return function(res) {
+      return method(processReturnValue(methodName, res, returnValue));
+    };
+  }
+  function processArgs(methodName, fromArgs, argsOption = {}, returnValue = {}, keepFromArgs = false) {
+    if (isPlainObject(fromArgs)) {
+      const toArgs = keepFromArgs === true ? fromArgs : {};
+      if (isFunction$1(argsOption)) {
+        argsOption = argsOption(fromArgs, toArgs) || {};
+      }
+      for (const key in fromArgs) {
+        if (hasOwn(argsOption, key)) {
+          let keyOption = argsOption[key];
+          if (isFunction$1(keyOption)) {
+            keyOption = keyOption(fromArgs[key], fromArgs, toArgs);
+          }
+          if (!keyOption) {
+            console.warn(`微信小程序 ${methodName} 暂不支持 ${key}`);
+          } else if (isString$1(keyOption)) {
+            toArgs[keyOption] = fromArgs[key];
+          } else if (isPlainObject(keyOption)) {
+            toArgs[keyOption.name ? keyOption.name : key] = keyOption.value;
+          }
+        } else if (CALLBACKS.indexOf(key) !== -1) {
+          const callback = fromArgs[key];
+          if (isFunction$1(callback)) {
+            toArgs[key] = processCallback(methodName, callback, returnValue);
+          }
+        } else {
+          if (!keepFromArgs && !hasOwn(toArgs, key)) {
+            toArgs[key] = fromArgs[key];
+          }
+        }
+      }
+      return toArgs;
+    } else if (isFunction$1(fromArgs)) {
+      fromArgs = processCallback(methodName, fromArgs, returnValue);
+    }
+    return fromArgs;
+  }
+  function processReturnValue(methodName, res, returnValue, keepReturnValue = false) {
+    if (isFunction$1(protocols2.returnValue)) {
+      res = protocols2.returnValue(methodName, res);
+    }
+    return processArgs(methodName, res, returnValue, {}, keepReturnValue);
+  }
+  return function wrapper(methodName, method) {
+    if (!hasOwn(protocols2, methodName)) {
+      return method;
+    }
+    const protocol = protocols2[methodName];
+    if (!protocol) {
+      return function() {
+        console.error(`微信小程序 暂不支持${methodName}`);
+      };
+    }
+    return function(arg1, arg2) {
+      let options = protocol;
+      if (isFunction$1(protocol)) {
+        options = protocol(arg1);
+      }
+      arg1 = processArgs(methodName, arg1, options.args, options.returnValue);
+      const args = [arg1];
+      if (typeof arg2 !== "undefined") {
+        args.push(arg2);
+      }
+      const returnValue = wx[options.name || methodName].apply(wx, args);
+      if (isSyncApi(methodName)) {
+        return processReturnValue(methodName, returnValue, options.returnValue, isContextApi(methodName));
+      }
+      return returnValue;
+    };
+  };
+}
+const getLocale = () => {
+  const app = isFunction$1(getApp) && getApp({ allowDefault: true });
+  if (app && app.$vm) {
+    return app.$vm.$locale;
+  }
+  return normalizeLocale(wx.getSystemInfoSync().language) || LOCALE_EN;
+};
+const setLocale = (locale) => {
+  const app = isFunction$1(getApp) && getApp();
+  if (!app) {
+    return false;
+  }
+  const oldLocale = app.$vm.$locale;
+  if (oldLocale !== locale) {
+    app.$vm.$locale = locale;
+    onLocaleChangeCallbacks.forEach((fn) => fn({ locale }));
+    return true;
+  }
+  return false;
+};
+const onLocaleChangeCallbacks = [];
+const onLocaleChange = (fn) => {
+  if (onLocaleChangeCallbacks.indexOf(fn) === -1) {
+    onLocaleChangeCallbacks.push(fn);
+  }
+};
+if (typeof global !== "undefined") {
+  global.getLocale = getLocale;
+}
+const UUID_KEY = "__DC_STAT_UUID";
+let deviceId;
+function useDeviceId(global2 = wx) {
+  return function addDeviceId(_, toRes) {
+    deviceId = deviceId || global2.getStorageSync(UUID_KEY);
+    if (!deviceId) {
+      deviceId = Date.now() + "" + Math.floor(Math.random() * 1e7);
+      wx.setStorage({
+        key: UUID_KEY,
+        data: deviceId
+      });
+    }
+    toRes.deviceId = deviceId;
+  };
+}
+function addSafeAreaInsets(fromRes, toRes) {
+  if (fromRes.safeArea) {
+    const safeArea = fromRes.safeArea;
+    toRes.safeAreaInsets = {
+      top: safeArea.top,
+      left: safeArea.left,
+      right: fromRes.windowWidth - safeArea.right,
+      bottom: fromRes.screenHeight - safeArea.bottom
+    };
+  }
+}
+function getOSInfo(system, platform) {
+  let osName = "";
+  let osVersion = "";
+  if (platform && false) {
+    osName = platform;
+    osVersion = system;
+  } else {
+    osName = system.split(" ")[0] || "";
+    osVersion = system.split(" ")[1] || "";
+  }
+  return {
+    osName: osName.toLocaleLowerCase(),
+    osVersion
+  };
+}
+function populateParameters(fromRes, toRes) {
+  const { brand = "", model = "", system = "", language = "", theme, version: version2, platform, fontSizeSetting, SDKVersion, pixelRatio, deviceOrientation } = fromRes;
+  const { osName, osVersion } = getOSInfo(system, platform);
+  let hostVersion = version2;
+  let deviceType = getGetDeviceType(fromRes, model);
+  let deviceBrand = getDeviceBrand(brand);
+  let _hostName = getHostName(fromRes);
+  let _deviceOrientation = deviceOrientation;
+  let _devicePixelRatio = pixelRatio;
+  let _SDKVersion = SDKVersion;
+  const hostLanguage = language.replace(/_/g, "-");
+  const parameters = {
+    appId: "",
+    appName: "",
+    appVersion: "1.0.0",
+    appVersionCode: "100",
+    appLanguage: getAppLanguage(hostLanguage),
+    uniCompileVersion: "4.36",
+    uniCompilerVersion: "4.36",
+    uniRuntimeVersion: "4.36",
+    uniPlatform: "mp-weixin",
+    deviceBrand,
+    deviceModel: model,
+    deviceType,
+    devicePixelRatio: _devicePixelRatio,
+    deviceOrientation: _deviceOrientation,
+    osName,
+    osVersion,
+    hostTheme: theme,
+    hostVersion,
+    hostLanguage,
+    hostName: _hostName,
+    hostSDKVersion: _SDKVersion,
+    hostFontSizeSetting: fontSizeSetting,
+    windowTop: 0,
+    windowBottom: 0,
+    // TODO
+    osLanguage: void 0,
+    osTheme: void 0,
+    ua: void 0,
+    hostPackageName: void 0,
+    browserName: void 0,
+    browserVersion: void 0,
+    isUniAppX: false
+  };
+  extend(toRes, parameters);
+}
+function getGetDeviceType(fromRes, model) {
+  let deviceType = fromRes.deviceType || "phone";
+  {
+    const deviceTypeMaps = {
+      ipad: "pad",
+      windows: "pc",
+      mac: "pc"
+    };
+    const deviceTypeMapsKeys = Object.keys(deviceTypeMaps);
+    const _model = model.toLocaleLowerCase();
+    for (let index2 = 0; index2 < deviceTypeMapsKeys.length; index2++) {
+      const _m = deviceTypeMapsKeys[index2];
+      if (_model.indexOf(_m) !== -1) {
+        deviceType = deviceTypeMaps[_m];
+        break;
+      }
+    }
+  }
+  return deviceType;
+}
+function getDeviceBrand(brand) {
+  let deviceBrand = brand;
+  if (deviceBrand) {
+    deviceBrand = deviceBrand.toLocaleLowerCase();
+  }
+  return deviceBrand;
+}
+function getAppLanguage(defaultLanguage) {
+  return getLocale ? getLocale() : defaultLanguage;
+}
+function getHostName(fromRes) {
+  const _platform = "WeChat";
+  let _hostName = fromRes.hostName || _platform;
+  {
+    if (fromRes.environment) {
+      _hostName = fromRes.environment;
+    } else if (fromRes.host && fromRes.host.env) {
+      _hostName = fromRes.host.env;
+    }
+  }
+  return _hostName;
+}
+const getSystemInfo = {
+  returnValue: (fromRes, toRes) => {
+    addSafeAreaInsets(fromRes, toRes);
+    useDeviceId()(fromRes, toRes);
+    populateParameters(fromRes, toRes);
+  }
+};
+const getSystemInfoSync = getSystemInfo;
+const redirectTo = {};
+const previewImage = {
+  args(fromArgs, toArgs) {
+    let currentIndex = parseInt(fromArgs.current);
+    if (isNaN(currentIndex)) {
+      return;
+    }
+    const urls = fromArgs.urls;
+    if (!isArray$1(urls)) {
+      return;
+    }
+    const len = urls.length;
+    if (!len) {
+      return;
+    }
+    if (currentIndex < 0) {
+      currentIndex = 0;
+    } else if (currentIndex >= len) {
+      currentIndex = len - 1;
+    }
+    if (currentIndex > 0) {
+      toArgs.current = urls[currentIndex];
+      toArgs.urls = urls.filter((item, index2) => index2 < currentIndex ? item !== urls[currentIndex] : true);
+    } else {
+      toArgs.current = urls[0];
+    }
+    return {
+      indicator: false,
+      loop: false
+    };
+  }
+};
+const showActionSheet = {
+  args(fromArgs, toArgs) {
+    toArgs.alertText = fromArgs.title;
+  }
+};
+const getDeviceInfo = {
+  returnValue: (fromRes, toRes) => {
+    const { brand, model, system = "", platform = "" } = fromRes;
+    let deviceType = getGetDeviceType(fromRes, model);
+    let deviceBrand = getDeviceBrand(brand);
+    useDeviceId()(fromRes, toRes);
+    const { osName, osVersion } = getOSInfo(system, platform);
+    toRes = sortObject(extend(toRes, {
+      deviceType,
+      deviceBrand,
+      deviceModel: model,
+      osName,
+      osVersion
+    }));
+  }
+};
+const getAppBaseInfo = {
+  returnValue: (fromRes, toRes) => {
+    const { version: version2, language, SDKVersion, theme } = fromRes;
+    let _hostName = getHostName(fromRes);
+    let hostLanguage = language.replace(/_/g, "-");
+    toRes = sortObject(extend(toRes, {
+      hostVersion: version2,
+      hostLanguage,
+      hostName: _hostName,
+      hostSDKVersion: SDKVersion,
+      hostTheme: theme,
+      appId: "",
+      appName: "",
+      appVersion: "1.0.0",
+      appVersionCode: "100",
+      appLanguage: getAppLanguage(hostLanguage),
+      isUniAppX: false,
+      uniPlatform: "mp-weixin",
+      uniCompileVersion: "4.36",
+      uniCompilerVersion: "4.36",
+      uniRuntimeVersion: "4.36"
+    }));
+  }
+};
+const getWindowInfo = {
+  returnValue: (fromRes, toRes) => {
+    addSafeAreaInsets(fromRes, toRes);
+    toRes = sortObject(extend(toRes, {
+      windowTop: 0,
+      windowBottom: 0
+    }));
+  }
+};
+const getAppAuthorizeSetting = {
+  returnValue: function(fromRes, toRes) {
+    const { locationReducedAccuracy } = fromRes;
+    toRes.locationAccuracy = "unsupported";
+    if (locationReducedAccuracy === true) {
+      toRes.locationAccuracy = "reduced";
+    } else if (locationReducedAccuracy === false) {
+      toRes.locationAccuracy = "full";
+    }
+  }
+};
+const baseApis = {
+  $on,
+  $off,
+  $once,
+  $emit,
+  upx2px,
+  interceptors,
+  addInterceptor,
+  removeInterceptor,
+  onCreateVueApp,
+  invokeCreateVueAppHook,
+  getLocale,
+  setLocale,
+  onLocaleChange,
+  getPushClientId,
+  onPushMessage,
+  offPushMessage,
+  invokePushCallback
+};
+function initUni(api, protocols2, platform = wx) {
+  const wrapper = initWrapper(protocols2);
+  const UniProxyHandlers = {
+    get(target, key) {
+      if (hasOwn(target, key)) {
+        return target[key];
+      }
+      if (hasOwn(api, key)) {
+        return promisify(key, api[key]);
+      }
+      if (hasOwn(baseApis, key)) {
+        return promisify(key, baseApis[key]);
+      }
+      return promisify(key, wrapper(key, platform[key]));
+    }
+  };
+  return new Proxy({}, UniProxyHandlers);
+}
+function initGetProvider(providers) {
+  return function getProvider2({ service, success, fail, complete }) {
+    let res;
+    if (providers[service]) {
+      res = {
+        errMsg: "getProvider:ok",
+        service,
+        provider: providers[service]
+      };
+      isFunction$1(success) && success(res);
+    } else {
+      res = {
+        errMsg: "getProvider:fail:服务[" + service + "]不存在"
+      };
+      isFunction$1(fail) && fail(res);
+    }
+    isFunction$1(complete) && complete(res);
+  };
+}
+const objectKeys = [
+  "qy",
+  "env",
+  "error",
+  "version",
+  "lanDebug",
+  "cloud",
+  "serviceMarket",
+  "router",
+  "worklet",
+  "__webpack_require_UNI_MP_PLUGIN__"
+];
+const singlePageDisableKey = ["lanDebug", "router", "worklet"];
+const launchOption = wx.getLaunchOptionsSync ? wx.getLaunchOptionsSync() : null;
+function isWxKey(key) {
+  if (launchOption && launchOption.scene === 1154 && singlePageDisableKey.includes(key)) {
+    return false;
+  }
+  return objectKeys.indexOf(key) > -1 || typeof wx[key] === "function";
+}
+function initWx() {
+  const newWx = {};
+  for (const key in wx) {
+    if (isWxKey(key)) {
+      newWx[key] = wx[key];
+    }
+  }
+  if (typeof globalThis !== "undefined" && typeof requireMiniProgram === "undefined") {
+    globalThis.wx = newWx;
+  }
+  return newWx;
+}
+const mocks$1 = ["__route__", "__wxExparserNodeId__", "__wxWebviewId__"];
+const getProvider = initGetProvider({
+  oauth: ["weixin"],
+  share: ["weixin"],
+  payment: ["wxpay"],
+  push: ["weixin"]
+});
+function initComponentMocks(component) {
+  const res = /* @__PURE__ */ Object.create(null);
+  mocks$1.forEach((name) => {
+    res[name] = component[name];
+  });
+  return res;
+}
+function createSelectorQuery() {
+  const query = wx$2.createSelectorQuery();
+  const oldIn = query.in;
+  query.in = function newIn(component) {
+    return oldIn.call(this, initComponentMocks(component));
+  };
+  return query;
+}
+const wx$2 = initWx();
+let baseInfo = wx$2.getAppBaseInfo && wx$2.getAppBaseInfo();
+if (!baseInfo) {
+  baseInfo = wx$2.getSystemInfoSync();
+}
+const host = baseInfo ? baseInfo.host : null;
+const shareVideoMessage = host && host.env === "SAAASDK" ? wx$2.miniapp.shareVideoMessage : wx$2.shareVideoMessage;
+var shims = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  createSelectorQuery,
+  getProvider,
+  shareVideoMessage
+});
+const compressImage = {
+  args(fromArgs, toArgs) {
+    if (fromArgs.compressedHeight && !toArgs.compressHeight) {
+      toArgs.compressHeight = fromArgs.compressedHeight;
+    }
+    if (fromArgs.compressedWidth && !toArgs.compressWidth) {
+      toArgs.compressWidth = fromArgs.compressedWidth;
+    }
+  }
+};
+var protocols = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  compressImage,
+  getAppAuthorizeSetting,
+  getAppBaseInfo,
+  getDeviceInfo,
+  getSystemInfo,
+  getSystemInfoSync,
+  getWindowInfo,
+  previewImage,
+  redirectTo,
+  showActionSheet
+});
+const wx$1 = initWx();
+var index = initUni(shims, protocols, wx$1);
+new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
+);
+function toRaw$1(observed) {
+  const raw = observed && observed["__v_raw"];
+  return raw ? toRaw$1(raw) : observed;
+}
+function isRef$1(r2) {
+  return !!(r2 && r2.__v_isRef === true);
+}
+/**
+* @vue/runtime-core v3.4.21
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+const stack$1 = [];
+function pushWarningContext$1(vnode) {
+  stack$1.push(vnode);
+}
+function popWarningContext$1() {
+  stack$1.pop();
+}
+function warn$1$1(msg, ...args) {
+  const instance = stack$1.length ? stack$1[stack$1.length - 1].component : null;
+  const appWarnHandler = instance && instance.appContext.config.warnHandler;
+  const trace = getComponentTrace$1();
+  if (appWarnHandler) {
+    callWithErrorHandling$1(
+      appWarnHandler,
+      instance,
+      11,
+      [
+        msg + args.map((a) => {
+          var _a, _b;
+          return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
+        }).join(""),
+        instance && instance.proxy,
+        trace.map(
+          ({ vnode }) => `at <${formatComponentName$1(instance, vnode.type)}>`
+        ).join("\n"),
+        trace
+      ]
+    );
+  } else {
+    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+    if (trace.length && // avoid spamming console during tests
+    true) {
+      warnArgs.push(`
+`, ...formatTrace$1(trace));
+    }
+    console.warn(...warnArgs);
+  }
+}
+function getComponentTrace$1() {
+  let currentVNode = stack$1[stack$1.length - 1];
+  if (!currentVNode) {
+    return [];
+  }
+  const normalizedStack = [];
+  while (currentVNode) {
+    const last = normalizedStack[0];
+    if (last && last.vnode === currentVNode) {
+      last.recurseCount++;
+    } else {
+      normalizedStack.push({
+        vnode: currentVNode,
+        recurseCount: 0
+      });
+    }
+    const parentInstance = currentVNode.component && currentVNode.component.parent;
+    currentVNode = parentInstance && parentInstance.vnode;
+  }
+  return normalizedStack;
+}
+function formatTrace$1(trace) {
+  const logs = [];
+  trace.forEach((entry, i) => {
+    logs.push(...i === 0 ? [] : [`
+`], ...formatTraceEntry$1(entry));
+  });
+  return logs;
+}
+function formatTraceEntry$1({ vnode, recurseCount }) {
+  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+  const isRoot = vnode.component ? vnode.component.parent == null : false;
+  const open = ` at <${formatComponentName$1(
+    vnode.component,
+    vnode.type,
+    isRoot
+  )}`;
+  const close = `>` + postfix;
+  return vnode.props ? [open, ...formatProps$1(vnode.props), close] : [open + close];
+}
+function formatProps$1(props) {
+  const res = [];
+  const keys = Object.keys(props);
+  keys.slice(0, 3).forEach((key) => {
+    res.push(...formatProp$1(key, props[key]));
+  });
+  if (keys.length > 3) {
+    res.push(` ...`);
+  }
+  return res;
+}
+function formatProp$1(key, value, raw) {
+  if (isString$1(value)) {
+    value = JSON.stringify(value);
+    return raw ? value : [`${key}=${value}`];
+  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+    return raw ? value : [`${key}=${value}`];
+  } else if (isRef$1(value)) {
+    value = formatProp$1(key, toRaw$1(value.value), true);
+    return raw ? value : [`${key}=Ref<`, value, `>`];
+  } else if (isFunction$1(value)) {
+    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+  } else {
+    value = toRaw$1(value);
+    return raw ? value : [`${key}=`, value];
+  }
+}
+const ErrorTypeStrings$1 = {
+  ["sp"]: "serverPrefetch hook",
+  ["bc"]: "beforeCreate hook",
+  ["c"]: "created hook",
+  ["bm"]: "beforeMount hook",
+  ["m"]: "mounted hook",
+  ["bu"]: "beforeUpdate hook",
+  ["u"]: "updated",
+  ["bum"]: "beforeUnmount hook",
+  ["um"]: "unmounted hook",
+  ["a"]: "activated hook",
+  ["da"]: "deactivated hook",
+  ["ec"]: "errorCaptured hook",
+  ["rtc"]: "renderTracked hook",
+  ["rtg"]: "renderTriggered hook",
+  [0]: "setup function",
+  [1]: "render function",
+  [2]: "watcher getter",
+  [3]: "watcher callback",
+  [4]: "watcher cleanup function",
+  [5]: "native event handler",
+  [6]: "component event handler",
+  [7]: "vnode hook",
+  [8]: "directive hook",
+  [9]: "transition hook",
+  [10]: "app errorHandler",
+  [11]: "app warnHandler",
+  [12]: "ref function",
+  [13]: "async component loader",
+  [14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://github.com/vuejs/core ."
+};
+function callWithErrorHandling$1(fn, instance, type, args) {
+  try {
+    return args ? fn(...args) : fn();
+  } catch (err) {
+    handleError$1(err, instance, type);
+  }
+}
+function handleError$1(err, instance, type, throwInDev = true) {
+  const contextVNode = instance ? instance.vnode : null;
+  if (instance) {
+    let cur = instance.parent;
+    const exposedInstance = instance.proxy;
+    const errorInfo = ErrorTypeStrings$1[type];
+    while (cur) {
+      const errorCapturedHooks = cur.ec;
+      if (errorCapturedHooks) {
+        for (let i = 0; i < errorCapturedHooks.length; i++) {
+          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+            return;
+          }
+        }
+      }
+      cur = cur.parent;
+    }
+    const appErrorHandler = instance.appContext.config.errorHandler;
+    if (appErrorHandler) {
+      callWithErrorHandling$1(
+        appErrorHandler,
+        null,
+        10,
+        [err, exposedInstance, errorInfo]
+      );
+      return;
+    }
+  }
+  logError$1(err, type, contextVNode, throwInDev);
+}
+function logError$1(err, type, contextVNode, throwInDev = true) {
+  {
+    const info = ErrorTypeStrings$1[type];
+    if (contextVNode) {
+      pushWarningContext$1(contextVNode);
+    }
+    warn$1$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+    if (contextVNode) {
+      popWarningContext$1();
+    }
+    if (throwInDev) {
+      throw err;
+    } else {
+      console.error(err);
+    }
+  }
+}
+let isFlushing$1 = false;
+let isFlushPending$1 = false;
+const queue$1 = [];
+let flushIndex$1 = 0;
+const pendingPostFlushCbs$1 = [];
+let activePostFlushCbs$1 = null;
+let postFlushIndex$1 = 0;
+const resolvedPromise$1 = /* @__PURE__ */ Promise.resolve();
+const RECURSION_LIMIT$1 = 100;
+function findInsertionIndex$1(id) {
+  let start = flushIndex$1 + 1;
+  let end = queue$1.length;
+  while (start < end) {
+    const middle = start + end >>> 1;
+    const middleJob = queue$1[middle];
+    const middleJobId = getId$1(middleJob);
+    if (middleJobId < id || middleJobId === id && middleJob.pre) {
+      start = middle + 1;
+    } else {
+      end = middle;
+    }
+  }
+  return start;
+}
+function queueJob$1(job) {
+  if (!queue$1.length || !queue$1.includes(
+    job,
+    isFlushing$1 && job.allowRecurse ? flushIndex$1 + 1 : flushIndex$1
+  )) {
+    if (job.id == null) {
+      queue$1.push(job);
+    } else {
+      queue$1.splice(findInsertionIndex$1(job.id), 0, job);
+    }
+    queueFlush$1();
+  }
+}
+function queueFlush$1() {
+  if (!isFlushing$1 && !isFlushPending$1) {
+    isFlushPending$1 = true;
+    resolvedPromise$1.then(flushJobs$1);
+  }
+}
+function queuePostFlushCb$1(cb) {
+  if (!isArray$1(cb)) {
+    if (!activePostFlushCbs$1 || !activePostFlushCbs$1.includes(
+      cb,
+      cb.allowRecurse ? postFlushIndex$1 + 1 : postFlushIndex$1
+    )) {
+      pendingPostFlushCbs$1.push(cb);
+    }
+  } else {
+    pendingPostFlushCbs$1.push(...cb);
+  }
+  queueFlush$1();
+}
+function flushPostFlushCbs$1(seen) {
+  if (pendingPostFlushCbs$1.length) {
+    const deduped = [...new Set(pendingPostFlushCbs$1)].sort(
+      (a, b) => getId$1(a) - getId$1(b)
+    );
+    pendingPostFlushCbs$1.length = 0;
+    if (activePostFlushCbs$1) {
+      activePostFlushCbs$1.push(...deduped);
+      return;
+    }
+    activePostFlushCbs$1 = deduped;
+    {
+      seen = seen || /* @__PURE__ */ new Map();
+    }
+    for (postFlushIndex$1 = 0; postFlushIndex$1 < activePostFlushCbs$1.length; postFlushIndex$1++) {
+      if (checkRecursiveUpdates$1(seen, activePostFlushCbs$1[postFlushIndex$1])) {
+        continue;
+      }
+      activePostFlushCbs$1[postFlushIndex$1]();
+    }
+    activePostFlushCbs$1 = null;
+    postFlushIndex$1 = 0;
+  }
+}
+const getId$1 = (job) => job.id == null ? Infinity : job.id;
+const comparator$1 = (a, b) => {
+  const diff2 = getId$1(a) - getId$1(b);
+  if (diff2 === 0) {
+    if (a.pre && !b.pre)
+      return -1;
+    if (b.pre && !a.pre)
+      return 1;
+  }
+  return diff2;
+};
+function flushJobs$1(seen) {
+  isFlushPending$1 = false;
+  isFlushing$1 = true;
+  {
+    seen = seen || /* @__PURE__ */ new Map();
+  }
+  queue$1.sort(comparator$1);
+  const check = (job) => checkRecursiveUpdates$1(seen, job);
+  try {
+    for (flushIndex$1 = 0; flushIndex$1 < queue$1.length; flushIndex$1++) {
+      const job = queue$1[flushIndex$1];
+      if (job && job.active !== false) {
+        if (check(job)) {
+          continue;
+        }
+        callWithErrorHandling$1(job, null, 14);
+      }
+    }
+  } finally {
+    flushIndex$1 = 0;
+    queue$1.length = 0;
+    flushPostFlushCbs$1(seen);
+    isFlushing$1 = false;
+    if (queue$1.length || pendingPostFlushCbs$1.length) {
+      flushJobs$1(seen);
+    }
+  }
+}
+function checkRecursiveUpdates$1(seen, fn) {
+  if (!seen.has(fn)) {
+    seen.set(fn, 1);
+  } else {
+    const count = seen.get(fn);
+    if (count > RECURSION_LIMIT$1) {
+      const instance = fn.ownerInstance;
+      const componentName = instance && getComponentName$1(instance.type);
+      handleError$1(
+        `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,
+        null,
+        10
+      );
+      return true;
+    } else {
+      seen.set(fn, count + 1);
+    }
+  }
+}
+const hmrDirtyComponents = /* @__PURE__ */ new Set();
+{
+  getGlobalThis().__VUE_HMR_RUNTIME__ = {
+    createRecord: tryWrap(createRecord),
+    rerender: tryWrap(rerender),
+    reload: tryWrap(reload)
+  };
+}
+const map = /* @__PURE__ */ new Map();
+function createRecord(id, initialDef) {
+  if (map.has(id)) {
+    return false;
+  }
+  map.set(id, {
+    initialDef: normalizeClassComponent(initialDef),
+    instances: /* @__PURE__ */ new Set()
+  });
+  return true;
+}
+function normalizeClassComponent(component) {
+  return isClassComponent$1(component) ? component.__vccOpts : component;
+}
+function rerender(id, newRender) {
+  const record = map.get(id);
+  if (!record) {
+    return;
+  }
+  record.initialDef.render = newRender;
+  [...record.instances].forEach((instance) => {
+    if (newRender) {
+      instance.render = newRender;
+      normalizeClassComponent(instance.type).render = newRender;
+    }
+    instance.renderCache = [];
+    instance.effect.dirty = true;
+    instance.update();
+  });
+}
+function reload(id, newComp) {
+  const record = map.get(id);
+  if (!record)
+    return;
+  newComp = normalizeClassComponent(newComp);
+  updateComponentDef(record.initialDef, newComp);
+  const instances = [...record.instances];
+  for (const instance of instances) {
+    const oldComp = normalizeClassComponent(instance.type);
+    if (!hmrDirtyComponents.has(oldComp)) {
+      if (oldComp !== record.initialDef) {
+        updateComponentDef(oldComp, newComp);
+      }
+      hmrDirtyComponents.add(oldComp);
+    }
+    instance.appContext.propsCache.delete(instance.type);
+    instance.appContext.emitsCache.delete(instance.type);
+    instance.appContext.optionsCache.delete(instance.type);
+    if (instance.ceReload) {
+      hmrDirtyComponents.add(oldComp);
+      instance.ceReload(newComp.styles);
+      hmrDirtyComponents.delete(oldComp);
+    } else if (instance.parent) {
+      instance.parent.effect.dirty = true;
+      queueJob$1(instance.parent.update);
+    } else if (instance.appContext.reload) {
+      instance.appContext.reload();
+    } else if (typeof window !== "undefined") {
+      window.location.reload();
+    } else {
+      console.warn(
+        "[HMR] Root or manually mounted instance modified. Full reload required."
+      );
+    }
+  }
+  queuePostFlushCb$1(() => {
+    for (const instance of instances) {
+      hmrDirtyComponents.delete(
+        normalizeClassComponent(instance.type)
+      );
+    }
+  });
+}
+function updateComponentDef(oldComp, newComp) {
+  extend(oldComp, newComp);
+  for (const key in oldComp) {
+    if (key !== "__file" && !(key in newComp)) {
+      delete oldComp[key];
+    }
+  }
+}
+function tryWrap(fn) {
+  return (id, arg) => {
+    try {
+      return fn(id, arg);
+    } catch (e2) {
+      console.error(e2);
+      console.warn(
+        `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
+      );
+    }
+  };
+}
+{
+  const g = getGlobalThis();
+  const registerGlobalSetter = (key, setter) => {
+    let setters;
+    if (!(setters = g[key]))
+      setters = g[key] = [];
+    setters.push(setter);
+    return (v) => {
+      if (setters.length > 1)
+        setters.forEach((set2) => set2(v));
+      else
+        setters[0](v);
+    };
+  };
+  registerGlobalSetter(
+    `__VUE_INSTANCE_SETTERS__`,
+    (v) => v
+  );
+  registerGlobalSetter(
+    `__VUE_SSR_SETTERS__`,
+    (v) => v
+  );
+}
+const classifyRE$1 = /(?:^|[-_])(\w)/g;
+const classify$1 = (str) => str.replace(classifyRE$1, (c2) => c2.toUpperCase()).replace(/[-_]/g, "");
+function getComponentName$1(Component2, includeInferred = true) {
+  return isFunction$1(Component2) ? Component2.displayName || Component2.name : Component2.name || includeInferred && Component2.__name;
+}
+function formatComponentName$1(instance, Component2, isRoot = false) {
+  let name = getComponentName$1(Component2);
+  if (!name && Component2.__file) {
+    const match = Component2.__file.match(/([^/\\]+)\.\w+$/);
+    if (match) {
+      name = match[1];
+    }
+  }
+  if (!name && instance && instance.parent) {
+    const inferFromRegistry = (registry) => {
+      for (const key in registry) {
+        if (registry[key] === Component2) {
+          return key;
+        }
+      }
+    };
+    name = inferFromRegistry(
+      instance.components || instance.parent.type.components
+    ) || inferFromRegistry(instance.appContext.components);
+  }
+  return name ? classify$1(name) : isRoot ? `App` : `Anonymous`;
+}
+function isClassComponent$1(value) {
+  return isFunction$1(value) && "__vccOpts" in value;
+}
+/**
+* @dcloudio/uni-mp-vue v3.4.21
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+function warn$2(msg, ...args) {
+  console.warn(`[Vue warn] ${msg}`, ...args);
+}
+let activeEffectScope;
+class EffectScope {
+  constructor(detached = false) {
+    this.detached = detached;
+    this._active = true;
+    this.effects = [];
+    this.cleanups = [];
+    this.parent = activeEffectScope;
+    if (!detached && activeEffectScope) {
+      this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
+        this
+      ) - 1;
+    }
+  }
+  get active() {
+    return this._active;
+  }
+  run(fn) {
+    if (this._active) {
+      const currentEffectScope = activeEffectScope;
+      try {
+        activeEffectScope = this;
+        return fn();
+      } finally {
+        activeEffectScope = currentEffectScope;
+      }
+    } else {
+      warn$2(`cannot run an inactive effect scope.`);
+    }
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  on() {
+    activeEffectScope = this;
+  }
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  off() {
+    activeEffectScope = this.parent;
+  }
+  stop(fromParent) {
+    if (this._active) {
+      let i, l;
+      for (i = 0, l = this.effects.length; i < l; i++) {
+        this.effects[i].stop();
+      }
+      for (i = 0, l = this.cleanups.length; i < l; i++) {
+        this.cleanups[i]();
+      }
+      if (this.scopes) {
+        for (i = 0, l = this.scopes.length; i < l; i++) {
+          this.scopes[i].stop(true);
+        }
+      }
+      if (!this.detached && this.parent && !fromParent) {
+        const last = this.parent.scopes.pop();
+        if (last && last !== this) {
+          this.parent.scopes[this.index] = last;
+          last.index = this.index;
+        }
+      }
+      this.parent = void 0;
+      this._active = false;
+    }
+  }
+}
+function effectScope(detached) {
+  return new EffectScope(detached);
+}
+function recordEffectScope(effect2, scope = activeEffectScope) {
+  if (scope && scope.active) {
+    scope.effects.push(effect2);
+  }
+}
+function getCurrentScope() {
+  return activeEffectScope;
+}
+let activeEffect;
+class ReactiveEffect2 {
+  constructor(fn, trigger2, scheduler, scope) {
+    this.fn = fn;
+    this.trigger = trigger2;
+    this.scheduler = scheduler;
+    this.active = true;
+    this.deps = [];
+    this._dirtyLevel = 4;
+    this._trackId = 0;
+    this._runnings = 0;
+    this._shouldSchedule = false;
+    this._depsLength = 0;
+    recordEffectScope(this, scope);
+  }
+  get dirty() {
+    if (this._dirtyLevel === 2 || this._dirtyLevel === 3) {
+      this._dirtyLevel = 1;
+      pauseTracking();
+      for (let i = 0; i < this._depsLength; i++) {
+        const dep = this.deps[i];
+        if (dep.computed) {
+          triggerComputed(dep.computed);
+          if (this._dirtyLevel >= 4) {
+            break;
+          }
+        }
+      }
+      if (this._dirtyLevel === 1) {
+        this._dirtyLevel = 0;
+      }
+      resetTracking();
+    }
+    return this._dirtyLevel >= 4;
+  }
+  set dirty(v) {
+    this._dirtyLevel = v ? 4 : 0;
+  }
+  run() {
+    this._dirtyLevel = 0;
+    if (!this.active) {
+      return this.fn();
+    }
+    let lastShouldTrack = shouldTrack;
+    let lastEffect = activeEffect;
+    try {
+      shouldTrack = true;
+      activeEffect = this;
+      this._runnings++;
+      preCleanupEffect(this);
+      return this.fn();
+    } finally {
+      postCleanupEffect(this);
+      this._runnings--;
+      activeEffect = lastEffect;
+      shouldTrack = lastShouldTrack;
+    }
+  }
+  stop() {
+    var _a;
+    if (this.active) {
+      preCleanupEffect(this);
+      postCleanupEffect(this);
+      (_a = this.onStop) == null ? void 0 : _a.call(this);
+      this.active = false;
+    }
+  }
+}
+function triggerComputed(computed2) {
+  return computed2.value;
+}
+function preCleanupEffect(effect2) {
+  effect2._trackId++;
+  effect2._depsLength = 0;
+}
+function postCleanupEffect(effect2) {
+  if (effect2.deps.length > effect2._depsLength) {
+    for (let i = effect2._depsLength; i < effect2.deps.length; i++) {
+      cleanupDepEffect(effect2.deps[i], effect2);
+    }
+    effect2.deps.length = effect2._depsLength;
+  }
+}
+function cleanupDepEffect(dep, effect2) {
+  const trackId = dep.get(effect2);
+  if (trackId !== void 0 && effect2._trackId !== trackId) {
+    dep.delete(effect2);
+    if (dep.size === 0) {
+      dep.cleanup();
+    }
+  }
+}
+let shouldTrack = true;
+let pauseScheduleStack = 0;
+const trackStack = [];
+function pauseTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = false;
+}
+function resetTracking() {
+  const last = trackStack.pop();
+  shouldTrack = last === void 0 ? true : last;
+}
+function pauseScheduling() {
+  pauseScheduleStack++;
+}
+function resetScheduling() {
+  pauseScheduleStack--;
+  while (!pauseScheduleStack && queueEffectSchedulers.length) {
+    queueEffectSchedulers.shift()();
+  }
+}
+function trackEffect(effect2, dep, debuggerEventExtraInfo) {
+  var _a;
+  if (dep.get(effect2) !== effect2._trackId) {
+    dep.set(effect2, effect2._trackId);
+    const oldDep = effect2.deps[effect2._depsLength];
+    if (oldDep !== dep) {
+      if (oldDep) {
+        cleanupDepEffect(oldDep, effect2);
+      }
+      effect2.deps[effect2._depsLength++] = dep;
+    } else {
+      effect2._depsLength++;
+    }
+    {
+      (_a = effect2.onTrack) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
+    }
+  }
+}
+const queueEffectSchedulers = [];
+function triggerEffects(dep, dirtyLevel, debuggerEventExtraInfo) {
+  var _a;
+  pauseScheduling();
+  for (const effect2 of dep.keys()) {
+    let tracking;
+    if (effect2._dirtyLevel < dirtyLevel && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
+      effect2._shouldSchedule || (effect2._shouldSchedule = effect2._dirtyLevel === 0);
+      effect2._dirtyLevel = dirtyLevel;
+    }
+    if (effect2._shouldSchedule && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
+      {
+        (_a = effect2.onTrigger) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
+      }
+      effect2.trigger();
+      if ((!effect2._runnings || effect2.allowRecurse) && effect2._dirtyLevel !== 2) {
+        effect2._shouldSchedule = false;
+        if (effect2.scheduler) {
+          queueEffectSchedulers.push(effect2.scheduler);
+        }
+      }
+    }
+  }
+  resetScheduling();
+}
+const createDep = (cleanup, computed2) => {
+  const dep = /* @__PURE__ */ new Map();
+  dep.cleanup = cleanup;
+  dep.computed = computed2;
+  return dep;
+};
+const targetMap = /* @__PURE__ */ new WeakMap();
+const ITERATE_KEY = Symbol("iterate");
+const MAP_KEY_ITERATE_KEY = Symbol("Map key iterate");
+function track(target, type, key) {
+  if (shouldTrack && activeEffect) {
+    let depsMap = targetMap.get(target);
+    if (!depsMap) {
+      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+    }
+    let dep = depsMap.get(key);
+    if (!dep) {
+      depsMap.set(key, dep = createDep(() => depsMap.delete(key)));
+    }
+    trackEffect(
+      activeEffect,
+      dep,
+      {
+        target,
+        type,
+        key
+      }
+    );
+  }
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) {
+    return;
+  }
+  let deps = [];
+  if (type === "clear") {
+    deps = [...depsMap.values()];
+  } else if (key === "length" && isArray$1(target)) {
+    const newLength = Number(newValue);
+    depsMap.forEach((dep, key2) => {
+      if (key2 === "length" || !isSymbol(key2) && key2 >= newLength) {
+        deps.push(dep);
+      }
+    });
+  } else {
+    if (key !== void 0) {
+      deps.push(depsMap.get(key));
+    }
+    switch (type) {
+      case "add":
+        if (!isArray$1(target)) {
+          deps.push(depsMap.get(ITERATE_KEY));
+          if (isMap(target)) {
+            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+          }
+        } else if (isIntegerKey(key)) {
+          deps.push(depsMap.get("length"));
+        }
+        break;
+      case "delete":
+        if (!isArray$1(target)) {
+          deps.push(depsMap.get(ITERATE_KEY));
+          if (isMap(target)) {
+            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
+          }
+        }
+        break;
+      case "set":
+        if (isMap(target)) {
+          deps.push(depsMap.get(ITERATE_KEY));
+        }
+        break;
+    }
+  }
+  pauseScheduling();
+  for (const dep of deps) {
+    if (dep) {
+      triggerEffects(
+        dep,
+        4,
+        {
+          target,
+          type,
+          key,
+          newValue,
+          oldValue,
+          oldTarget
+        }
+      );
+    }
+  }
+  resetScheduling();
+}
+const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+const builtInSymbols = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
+);
+const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
+function createArrayInstrumentations() {
+  const instrumentations = {};
+  ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
+    instrumentations[key] = function(...args) {
+      const arr = toRaw(this);
+      for (let i = 0, l = this.length; i < l; i++) {
+        track(arr, "get", i + "");
+      }
+      const res = arr[key](...args);
+      if (res === -1 || res === false) {
+        return arr[key](...args.map(toRaw));
+      } else {
+        return res;
+      }
+    };
+  });
+  ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
+    instrumentations[key] = function(...args) {
+      pauseTracking();
+      pauseScheduling();
+      const res = toRaw(this)[key].apply(this, args);
+      resetScheduling();
+      resetTracking();
+      return res;
+    };
+  });
+  return instrumentations;
+}
+function hasOwnProperty(key) {
+  const obj = toRaw(this);
+  track(obj, "has", key);
+  return obj.hasOwnProperty(key);
+}
+class BaseReactiveHandler2 {
+  constructor(_isReadonly = false, _isShallow = false) {
+    this._isReadonly = _isReadonly;
+    this._isShallow = _isShallow;
+  }
+  get(target, key, receiver) {
+    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_isShallow") {
+      return isShallow2;
+    } else if (key === "__v_raw") {
+      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
+      // this means the reciever is a user proxy of the reactive proxy
+      Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
+        return target;
+      }
+      return;
+    }
+    const targetIsArray = isArray$1(target);
+    if (!isReadonly2) {
+      if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
+        return Reflect.get(arrayInstrumentations, key, receiver);
+      }
+      if (key === "hasOwnProperty") {
+        return hasOwnProperty;
+      }
+    }
+    const res = Reflect.get(target, key, receiver);
+    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+      return res;
+    }
+    if (!isReadonly2) {
+      track(target, "get", key);
+    }
+    if (isShallow2) {
+      return res;
+    }
+    if (isRef(res)) {
+      return targetIsArray && isIntegerKey(key) ? res : res.value;
+    }
+    if (isObject(res)) {
+      return isReadonly2 ? readonly(res) : reactive(res);
+    }
+    return res;
+  }
+}
+class MutableReactiveHandler2 extends BaseReactiveHandler2 {
+  constructor(isShallow2 = false) {
+    super(false, isShallow2);
+  }
+  set(target, key, value, receiver) {
+    let oldValue = target[key];
+    if (!this._isShallow) {
+      const isOldValueReadonly = isReadonly(oldValue);
+      if (!isShallow(value) && !isReadonly(value)) {
+        oldValue = toRaw(oldValue);
+        value = toRaw(value);
+      }
+      if (!isArray$1(target) && isRef(oldValue) && !isRef(value)) {
+        if (isOldValueReadonly) {
+          return false;
+        } else {
+          oldValue.value = value;
+          return true;
+        }
+      }
+    }
+    const hadKey = isArray$1(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+    const result = Reflect.set(target, key, value, receiver);
+    if (target === toRaw(receiver)) {
+      if (!hadKey) {
+        trigger(target, "add", key, value);
+      } else if (hasChanged(value, oldValue)) {
+        trigger(target, "set", key, value, oldValue);
+      }
+    }
+    return result;
+  }
+  deleteProperty(target, key) {
+    const hadKey = hasOwn(target, key);
+    const oldValue = target[key];
+    const result = Reflect.deleteProperty(target, key);
+    if (result && hadKey) {
+      trigger(target, "delete", key, void 0, oldValue);
+    }
+    return result;
+  }
+  has(target, key) {
+    const result = Reflect.has(target, key);
+    if (!isSymbol(key) || !builtInSymbols.has(key)) {
+      track(target, "has", key);
+    }
+    return result;
+  }
+  ownKeys(target) {
+    track(
+      target,
+      "iterate",
+      isArray$1(target) ? "length" : ITERATE_KEY
+    );
+    return Reflect.ownKeys(target);
+  }
+}
+class ReadonlyReactiveHandler2 extends BaseReactiveHandler2 {
+  constructor(isShallow2 = false) {
+    super(true, isShallow2);
+  }
+  set(target, key) {
+    {
+      warn$2(
+        `Set operation on key "${String(key)}" failed: target is readonly.`,
+        target
+      );
+    }
+    return true;
+  }
+  deleteProperty(target, key) {
+    {
+      warn$2(
+        `Delete operation on key "${String(key)}" failed: target is readonly.`,
+        target
+      );
+    }
+    return true;
+  }
+}
+const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler2();
+const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler2();
+const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler2(
+  true
+);
+const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler2(true);
+const toShallow = (value) => value;
+const getProto = (v) => Reflect.getPrototypeOf(v);
+function get(target, key, isReadonly2 = false, isShallow2 = false) {
+  target = target["__v_raw"];
+  const rawTarget = toRaw(target);
+  const rawKey = toRaw(key);
+  if (!isReadonly2) {
+    if (hasChanged(key, rawKey)) {
+      track(rawTarget, "get", key);
+    }
+    track(rawTarget, "get", rawKey);
+  }
+  const { has: has2 } = getProto(rawTarget);
+  const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+  if (has2.call(rawTarget, key)) {
+    return wrap(target.get(key));
+  } else if (has2.call(rawTarget, rawKey)) {
+    return wrap(target.get(rawKey));
+  } else if (target !== rawTarget) {
+    target.get(key);
+  }
+}
+function has(key, isReadonly2 = false) {
+  const target = this["__v_raw"];
+  const rawTarget = toRaw(target);
+  const rawKey = toRaw(key);
+  if (!isReadonly2) {
+    if (hasChanged(key, rawKey)) {
+      track(rawTarget, "has", key);
+    }
+    track(rawTarget, "has", rawKey);
+  }
+  return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+}
+function size(target, isReadonly2 = false) {
+  target = target["__v_raw"];
+  !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
+  return Reflect.get(target, "size", target);
+}
+function add(value) {
+  value = toRaw(value);
+  const target = toRaw(this);
+  const proto = getProto(target);
+  const hadKey = proto.has.call(target, value);
+  if (!hadKey) {
+    target.add(value);
+    trigger(target, "add", value, value);
+  }
+  return this;
+}
+function set$1(key, value) {
+  value = toRaw(value);
+  const target = toRaw(this);
+  const { has: has2, get: get2 } = getProto(target);
+  let hadKey = has2.call(target, key);
+  if (!hadKey) {
+    key = toRaw(key);
+    hadKey = has2.call(target, key);
+  } else {
+    checkIdentityKeys(target, has2, key);
+  }
+  const oldValue = get2.call(target, key);
+  target.set(key, value);
+  if (!hadKey) {
+    trigger(target, "add", key, value);
+  } else if (hasChanged(value, oldValue)) {
+    trigger(target, "set", key, value, oldValue);
+  }
+  return this;
+}
+function deleteEntry(key) {
+  const target = toRaw(this);
+  const { has: has2, get: get2 } = getProto(target);
+  let hadKey = has2.call(target, key);
+  if (!hadKey) {
+    key = toRaw(key);
+    hadKey = has2.call(target, key);
+  } else {
+    checkIdentityKeys(target, has2, key);
+  }
+  const oldValue = get2 ? get2.call(target, key) : void 0;
+  const result = target.delete(key);
+  if (hadKey) {
+    trigger(target, "delete", key, void 0, oldValue);
+  }
+  return result;
+}
+function clear() {
+  const target = toRaw(this);
+  const hadItems = target.size !== 0;
+  const oldTarget = isMap(target) ? new Map(target) : new Set(target);
+  const result = target.clear();
+  if (hadItems) {
+    trigger(target, "clear", void 0, void 0, oldTarget);
+  }
+  return result;
+}
+function createForEach(isReadonly2, isShallow2) {
+  return function forEach(callback, thisArg) {
+    const observed = this;
+    const target = observed["__v_raw"];
+    const rawTarget = toRaw(target);
+    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+    !isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
+    return target.forEach((value, key) => {
+      return callback.call(thisArg, wrap(value), wrap(key), observed);
+    });
+  };
+}
+function createIterableMethod(method, isReadonly2, isShallow2) {
+  return function(...args) {
+    const target = this["__v_raw"];
+    const rawTarget = toRaw(target);
+    const targetIsMap = isMap(rawTarget);
+    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+    const isKeyOnly = method === "keys" && targetIsMap;
+    const innerIterator = target[method](...args);
+    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+    !isReadonly2 && track(
+      rawTarget,
+      "iterate",
+      isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
+    );
+    return {
+      // iterator protocol
+      next() {
+        const { value, done } = innerIterator.next();
+        return done ? { value, done } : {
+          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+          done
+        };
+      },
+      // iterable protocol
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function createReadonlyMethod(type) {
+  return function(...args) {
+    {
+      const key = args[0] ? `on key "${args[0]}" ` : ``;
+      warn$2(
+        `${capitalize(type)} operation ${key}failed: target is readonly.`,
+        toRaw(this)
+      );
+    }
+    return type === "delete" ? false : type === "clear" ? void 0 : this;
+  };
+}
+function createInstrumentations() {
+  const mutableInstrumentations2 = {
+    get(key) {
+      return get(this, key);
+    },
+    get size() {
+      return size(this);
+    },
+    has,
+    add,
+    set: set$1,
+    delete: deleteEntry,
+    clear,
+    forEach: createForEach(false, false)
+  };
+  const shallowInstrumentations2 = {
+    get(key) {
+      return get(this, key, false, true);
+    },
+    get size() {
+      return size(this);
+    },
+    has,
+    add,
+    set: set$1,
+    delete: deleteEntry,
+    clear,
+    forEach: createForEach(false, true)
+  };
+  const readonlyInstrumentations2 = {
+    get(key) {
+      return get(this, key, true);
+    },
+    get size() {
+      return size(this, true);
+    },
+    has(key) {
+      return has.call(this, key, true);
+    },
+    add: createReadonlyMethod("add"),
+    set: createReadonlyMethod("set"),
+    delete: createReadonlyMethod("delete"),
+    clear: createReadonlyMethod("clear"),
+    forEach: createForEach(true, false)
+  };
+  const shallowReadonlyInstrumentations2 = {
+    get(key) {
+      return get(this, key, true, true);
+    },
+    get size() {
+      return size(this, true);
+    },
+    has(key) {
+      return has.call(this, key, true);
+    },
+    add: createReadonlyMethod("add"),
+    set: createReadonlyMethod("set"),
+    delete: createReadonlyMethod("delete"),
+    clear: createReadonlyMethod("clear"),
+    forEach: createForEach(true, true)
+  };
+  const iteratorMethods = [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ];
+  iteratorMethods.forEach((method) => {
+    mutableInstrumentations2[method] = createIterableMethod(method, false, false);
+    readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
+    shallowInstrumentations2[method] = createIterableMethod(method, false, true);
+    shallowReadonlyInstrumentations2[method] = createIterableMethod(
+      method,
+      true,
+      true
+    );
+  });
+  return [
+    mutableInstrumentations2,
+    readonlyInstrumentations2,
+    shallowInstrumentations2,
+    shallowReadonlyInstrumentations2
+  ];
+}
+const [
+  mutableInstrumentations,
+  readonlyInstrumentations,
+  shallowInstrumentations,
+  shallowReadonlyInstrumentations
+] = /* @__PURE__ */ createInstrumentations();
+function createInstrumentationGetter(isReadonly2, shallow) {
+  const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
+  return (target, key, receiver) => {
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_raw") {
+      return target;
+    }
+    return Reflect.get(
+      hasOwn(instrumentations, key) && key in target ? instrumentations : target,
+      key,
+      receiver
+    );
+  };
+}
+const mutableCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+};
+const shallowCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(false, true)
+};
+const readonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+};
+const shallowReadonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, true)
+};
+function checkIdentityKeys(target, has2, key) {
+  const rawKey = toRaw(key);
+  if (rawKey !== key && has2.call(target, rawKey)) {
+    const type = toRawType(target);
+    warn$2(
+      `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
+    );
+  }
+}
+const reactiveMap = /* @__PURE__ */ new WeakMap();
+const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+const readonlyMap = /* @__PURE__ */ new WeakMap();
+const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function targetTypeMap(rawType) {
+  switch (rawType) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function getTargetType(value) {
+  return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
+}
+function reactive(target) {
+  if (isReadonly(target)) {
+    return target;
+  }
+  return createReactiveObject(
+    target,
+    false,
+    mutableHandlers,
+    mutableCollectionHandlers,
+    reactiveMap
+  );
+}
+function shallowReactive(target) {
+  return createReactiveObject(
+    target,
+    false,
+    shallowReactiveHandlers,
+    shallowCollectionHandlers,
+    shallowReactiveMap
+  );
+}
+function readonly(target) {
+  return createReactiveObject(
+    target,
+    true,
+    readonlyHandlers,
+    readonlyCollectionHandlers,
+    readonlyMap
+  );
+}
+function shallowReadonly(target) {
+  return createReactiveObject(
+    target,
+    true,
+    shallowReadonlyHandlers,
+    shallowReadonlyCollectionHandlers,
+    shallowReadonlyMap
+  );
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+  if (!isObject(target)) {
+    {
+      warn$2(`value cannot be made reactive: ${String(target)}`);
+    }
+    return target;
+  }
+  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+    return target;
+  }
+  const existingProxy = proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  const targetType = getTargetType(target);
+  if (targetType === 0) {
+    return target;
+  }
+  const proxy = new Proxy(
+    target,
+    targetType === 2 ? collectionHandlers : baseHandlers
+  );
+  proxyMap.set(target, proxy);
+  return proxy;
+}
+function isReactive(value) {
+  if (isReadonly(value)) {
+    return isReactive(value["__v_raw"]);
+  }
+  return !!(value && value["__v_isReactive"]);
+}
+function isReadonly(value) {
+  return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+  return !!(value && value["__v_isShallow"]);
+}
+function isProxy(value) {
+  return isReactive(value) || isReadonly(value);
+}
+function toRaw(observed) {
+  const raw = observed && observed["__v_raw"];
+  return raw ? toRaw(raw) : observed;
+}
+function markRaw(value) {
+  if (Object.isExtensible(value)) {
+    def(value, "__v_skip", true);
+  }
+  return value;
+}
+const toReactive = (value) => isObject(value) ? reactive(value) : value;
+const toReadonly = (value) => isObject(value) ? readonly(value) : value;
+const COMPUTED_SIDE_EFFECT_WARN = `Computed is still dirty after getter evaluation, likely because a computed is mutating its own dependency in its getter. State mutations in computed getters should be avoided.  Check the docs for more details: https://vuejs.org/guide/essentials/computed.html#getters-should-be-side-effect-free`;
+class ComputedRefImpl {
+  constructor(getter, _setter, isReadonly2, isSSR) {
+    this.getter = getter;
+    this._setter = _setter;
+    this.dep = void 0;
+    this.__v_isRef = true;
+    this["__v_isReadonly"] = false;
+    this.effect = new ReactiveEffect2(
+      () => getter(this._value),
+      () => triggerRefValue(
+        this,
+        this.effect._dirtyLevel === 2 ? 2 : 3
+      )
+    );
+    this.effect.computed = this;
+    this.effect.active = this._cacheable = !isSSR;
+    this["__v_isReadonly"] = isReadonly2;
+  }
+  get value() {
+    const self2 = toRaw(this);
+    if ((!self2._cacheable || self2.effect.dirty) && hasChanged(self2._value, self2._value = self2.effect.run())) {
+      triggerRefValue(self2, 4);
+    }
+    trackRefValue(self2);
+    if (self2.effect._dirtyLevel >= 2) {
+      if (this._warnRecursive) {
+        warn$2(COMPUTED_SIDE_EFFECT_WARN, `
+
+getter: `, this.getter);
+      }
+      triggerRefValue(self2, 2);
+    }
+    return self2._value;
+  }
+  set value(newValue) {
+    this._setter(newValue);
+  }
+  // #region polyfill _dirty for backward compatibility third party code for Vue <= 3.3.x
+  get _dirty() {
+    return this.effect.dirty;
+  }
+  set _dirty(v) {
+    this.effect.dirty = v;
+  }
+  // #endregion
+}
+function computed$1(getterOrOptions, debugOptions, isSSR = false) {
+  let getter;
+  let setter;
+  const onlyGetter = isFunction$1(getterOrOptions);
+  if (onlyGetter) {
+    getter = getterOrOptions;
+    setter = () => {
+      warn$2("Write operation failed: computed value is readonly");
+    };
+  } else {
+    getter = getterOrOptions.get;
+    setter = getterOrOptions.set;
+  }
+  const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+  return cRef;
+}
+function trackRefValue(ref2) {
+  var _a;
+  if (shouldTrack && activeEffect) {
+    ref2 = toRaw(ref2);
+    trackEffect(
+      activeEffect,
+      (_a = ref2.dep) != null ? _a : ref2.dep = createDep(
+        () => ref2.dep = void 0,
+        ref2 instanceof ComputedRefImpl ? ref2 : void 0
+      ),
+      {
+        target: ref2,
+        type: "get",
+        key: "value"
+      }
+    );
+  }
+}
+function triggerRefValue(ref2, dirtyLevel = 4, newVal) {
+  ref2 = toRaw(ref2);
+  const dep = ref2.dep;
+  if (dep) {
+    triggerEffects(
+      dep,
+      dirtyLevel,
+      {
+        target: ref2,
+        type: "set",
+        key: "value",
+        newValue: newVal
+      }
+    );
+  }
+}
+function isRef(r2) {
+  return !!(r2 && r2.__v_isRef === true);
+}
+function ref(value) {
+  return createRef(value, false);
+}
+function createRef(rawValue, shallow) {
+  if (isRef(rawValue)) {
+    return rawValue;
+  }
+  return new RefImpl(rawValue, shallow);
+}
+class RefImpl {
+  constructor(value, __v_isShallow) {
+    this.__v_isShallow = __v_isShallow;
+    this.dep = void 0;
+    this.__v_isRef = true;
+    this._rawValue = __v_isShallow ? value : toRaw(value);
+    this._value = __v_isShallow ? value : toReactive(value);
+  }
+  get value() {
+    trackRefValue(this);
+    return this._value;
+  }
+  set value(newVal) {
+    const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
+    newVal = useDirectValue ? newVal : toRaw(newVal);
+    if (hasChanged(newVal, this._rawValue)) {
+      this._rawValue = newVal;
+      this._value = useDirectValue ? newVal : toReactive(newVal);
+      triggerRefValue(this, 4, newVal);
+    }
+  }
+}
+function unref(ref2) {
+  return isRef(ref2) ? ref2.value : ref2;
+}
+const shallowUnwrapHandlers = {
+  get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
+  set: (target, key, value, receiver) => {
+    const oldValue = target[key];
+    if (isRef(oldValue) && !isRef(value)) {
+      oldValue.value = value;
+      return true;
+    } else {
+      return Reflect.set(target, key, value, receiver);
+    }
+  }
+};
+function proxyRefs(objectWithRefs) {
+  return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+}
+const stack = [];
+function pushWarningContext(vnode) {
+  stack.push(vnode);
+}
+function popWarningContext() {
+  stack.pop();
+}
+function warn$1(msg, ...args) {
+  pauseTracking();
+  const instance = stack.length ? stack[stack.length - 1].component : null;
+  const appWarnHandler = instance && instance.appContext.config.warnHandler;
+  const trace = getComponentTrace();
+  if (appWarnHandler) {
+    callWithErrorHandling(
+      appWarnHandler,
+      instance,
+      11,
+      [
+        msg + args.map((a) => {
+          var _a, _b;
+          return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
+        }).join(""),
+        instance && instance.proxy,
+        trace.map(
+          ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
+        ).join("\n"),
+        trace
+      ]
+    );
+  } else {
+    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+    if (trace.length && // avoid spamming console during tests
+    true) {
+      warnArgs.push(`
+`, ...formatTrace(trace));
+    }
+    console.warn(...warnArgs);
+  }
+  resetTracking();
+}
+function getComponentTrace() {
+  let currentVNode = stack[stack.length - 1];
+  if (!currentVNode) {
+    return [];
+  }
+  const normalizedStack = [];
+  while (currentVNode) {
+    const last = normalizedStack[0];
+    if (last && last.vnode === currentVNode) {
+      last.recurseCount++;
+    } else {
+      normalizedStack.push({
+        vnode: currentVNode,
+        recurseCount: 0
+      });
+    }
+    const parentInstance = currentVNode.component && currentVNode.component.parent;
+    currentVNode = parentInstance && parentInstance.vnode;
+  }
+  return normalizedStack;
+}
+function formatTrace(trace) {
+  const logs = [];
+  trace.forEach((entry, i) => {
+    logs.push(...i === 0 ? [] : [`
+`], ...formatTraceEntry(entry));
+  });
+  return logs;
+}
+function formatTraceEntry({ vnode, recurseCount }) {
+  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+  const isRoot = vnode.component ? vnode.component.parent == null : false;
+  const open = ` at <${formatComponentName(
+    vnode.component,
+    vnode.type,
+    isRoot
+  )}`;
+  const close = `>` + postfix;
+  return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
+}
+function formatProps(props) {
+  const res = [];
+  const keys = Object.keys(props);
+  keys.slice(0, 3).forEach((key) => {
+    res.push(...formatProp(key, props[key]));
+  });
+  if (keys.length > 3) {
+    res.push(` ...`);
+  }
+  return res;
+}
+function formatProp(key, value, raw) {
+  if (isString$1(value)) {
+    value = JSON.stringify(value);
+    return raw ? value : [`${key}=${value}`];
+  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+    return raw ? value : [`${key}=${value}`];
+  } else if (isRef(value)) {
+    value = formatProp(key, toRaw(value.value), true);
+    return raw ? value : [`${key}=Ref<`, value, `>`];
+  } else if (isFunction$1(value)) {
+    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+  } else {
+    value = toRaw(value);
+    return raw ? value : [`${key}=`, value];
+  }
+}
+const ErrorTypeStrings = {
+  ["sp"]: "serverPrefetch hook",
+  ["bc"]: "beforeCreate hook",
+  ["c"]: "created hook",
+  ["bm"]: "beforeMount hook",
+  ["m"]: "mounted hook",
+  ["bu"]: "beforeUpdate hook",
+  ["u"]: "updated",
+  ["bum"]: "beforeUnmount hook",
+  ["um"]: "unmounted hook",
+  ["a"]: "activated hook",
+  ["da"]: "deactivated hook",
+  ["ec"]: "errorCaptured hook",
+  ["rtc"]: "renderTracked hook",
+  ["rtg"]: "renderTriggered hook",
+  [0]: "setup function",
+  [1]: "render function",
+  [2]: "watcher getter",
+  [3]: "watcher callback",
+  [4]: "watcher cleanup function",
+  [5]: "native event handler",
+  [6]: "component event handler",
+  [7]: "vnode hook",
+  [8]: "directive hook",
+  [9]: "transition hook",
+  [10]: "app errorHandler",
+  [11]: "app warnHandler",
+  [12]: "ref function",
+  [13]: "async component loader",
+  [14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://github.com/vuejs/core ."
+};
+function callWithErrorHandling(fn, instance, type, args) {
+  try {
+    return args ? fn(...args) : fn();
+  } catch (err) {
+    handleError(err, instance, type);
+  }
+}
+function callWithAsyncErrorHandling(fn, instance, type, args) {
+  if (isFunction$1(fn)) {
+    const res = callWithErrorHandling(fn, instance, type, args);
+    if (res && isPromise$1(res)) {
+      res.catch((err) => {
+        handleError(err, instance, type);
+      });
+    }
+    return res;
+  }
+  const values = [];
+  for (let i = 0; i < fn.length; i++) {
+    values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+  }
+  return values;
+}
+function handleError(err, instance, type, throwInDev = true) {
+  const contextVNode = instance ? instance.vnode : null;
+  if (instance) {
+    let cur = instance.parent;
+    const exposedInstance = instance.proxy;
+    const errorInfo = ErrorTypeStrings[type] || type;
+    while (cur) {
+      const errorCapturedHooks = cur.ec;
+      if (errorCapturedHooks) {
+        for (let i = 0; i < errorCapturedHooks.length; i++) {
+          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+            return;
+          }
+        }
+      }
+      cur = cur.parent;
+    }
+    const appErrorHandler = instance.appContext.config.errorHandler;
+    if (appErrorHandler) {
+      callWithErrorHandling(
+        appErrorHandler,
+        null,
+        10,
+        [err, exposedInstance, errorInfo]
+      );
+      return;
+    }
+  }
+  logError(err, type, contextVNode, throwInDev);
+}
+function logError(err, type, contextVNode, throwInDev = true) {
+  {
+    const info = ErrorTypeStrings[type] || type;
+    if (contextVNode) {
+      pushWarningContext(contextVNode);
+    }
+    warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+    if (contextVNode) {
+      popWarningContext();
+    }
+    if (throwInDev) {
+      console.error(err);
+    } else {
+      console.error(err);
+    }
+  }
+}
+let isFlushing = false;
+let isFlushPending = false;
+const queue = [];
+let flushIndex = 0;
+const pendingPostFlushCbs = [];
+let activePostFlushCbs = null;
+let postFlushIndex = 0;
+const resolvedPromise = /* @__PURE__ */ Promise.resolve();
+let currentFlushPromise = null;
+const RECURSION_LIMIT = 100;
+function nextTick$1(fn) {
+  const p2 = currentFlushPromise || resolvedPromise;
+  return fn ? p2.then(this ? fn.bind(this) : fn) : p2;
+}
+function findInsertionIndex(id) {
+  let start = flushIndex + 1;
+  let end = queue.length;
+  while (start < end) {
+    const middle = start + end >>> 1;
+    const middleJob = queue[middle];
+    const middleJobId = getId(middleJob);
+    if (middleJobId < id || middleJobId === id && middleJob.pre) {
+      start = middle + 1;
+    } else {
+      end = middle;
+    }
+  }
+  return start;
+}
+function queueJob(job) {
+  if (!queue.length || !queue.includes(
+    job,
+    isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
+  )) {
+    if (job.id == null) {
+      queue.push(job);
+    } else {
+      queue.splice(findInsertionIndex(job.id), 0, job);
+    }
+    queueFlush();
+  }
+}
+function queueFlush() {
+  if (!isFlushing && !isFlushPending) {
+    isFlushPending = true;
+    currentFlushPromise = resolvedPromise.then(flushJobs);
+  }
+}
+function hasQueueJob(job) {
+  return queue.indexOf(job) > -1;
+}
+function invalidateJob(job) {
+  const i = queue.indexOf(job);
+  if (i > flushIndex) {
+    queue.splice(i, 1);
+  }
+}
+function queuePostFlushCb(cb) {
+  if (!isArray$1(cb)) {
+    if (!activePostFlushCbs || !activePostFlushCbs.includes(
+      cb,
+      cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex
+    )) {
+      pendingPostFlushCbs.push(cb);
+    }
+  } else {
+    pendingPostFlushCbs.push(...cb);
+  }
+  queueFlush();
+}
+function flushPreFlushCbs(instance, seen, i = isFlushing ? flushIndex + 1 : 0) {
+  {
+    seen = seen || /* @__PURE__ */ new Map();
+  }
+  for (; i < queue.length; i++) {
+    const cb = queue[i];
+    if (cb && cb.pre) {
+      if (checkRecursiveUpdates(seen, cb)) {
+        continue;
+      }
+      queue.splice(i, 1);
+      i--;
+      cb();
+    }
+  }
+}
+function flushPostFlushCbs(seen) {
+  if (pendingPostFlushCbs.length) {
+    const deduped = [...new Set(pendingPostFlushCbs)].sort(
+      (a, b) => getId(a) - getId(b)
+    );
+    pendingPostFlushCbs.length = 0;
+    if (activePostFlushCbs) {
+      activePostFlushCbs.push(...deduped);
+      return;
+    }
+    activePostFlushCbs = deduped;
+    {
+      seen = seen || /* @__PURE__ */ new Map();
+    }
+    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+      if (checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) {
+        continue;
+      }
+      activePostFlushCbs[postFlushIndex]();
+    }
+    activePostFlushCbs = null;
+    postFlushIndex = 0;
+  }
+}
+const getId = (job) => job.id == null ? Infinity : job.id;
+const comparator = (a, b) => {
+  const diff2 = getId(a) - getId(b);
+  if (diff2 === 0) {
+    if (a.pre && !b.pre)
+      return -1;
+    if (b.pre && !a.pre)
+      return 1;
+  }
+  return diff2;
+};
+function flushJobs(seen) {
+  isFlushPending = false;
+  isFlushing = true;
+  {
+    seen = seen || /* @__PURE__ */ new Map();
+  }
+  queue.sort(comparator);
+  const check = (job) => checkRecursiveUpdates(seen, job);
+  try {
+    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+      const job = queue[flushIndex];
+      if (job && job.active !== false) {
+        if (check(job)) {
+          continue;
+        }
+        callWithErrorHandling(job, null, 14);
+      }
+    }
+  } finally {
+    flushIndex = 0;
+    queue.length = 0;
+    flushPostFlushCbs(seen);
+    isFlushing = false;
+    currentFlushPromise = null;
+    if (queue.length || pendingPostFlushCbs.length) {
+      flushJobs(seen);
+    }
+  }
+}
+function checkRecursiveUpdates(seen, fn) {
+  if (!seen.has(fn)) {
+    seen.set(fn, 1);
+  } else {
+    const count = seen.get(fn);
+    if (count > RECURSION_LIMIT) {
+      const instance = fn.ownerInstance;
+      const componentName = instance && getComponentName(instance.type);
+      handleError(
+        `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,
+        null,
+        10
+      );
+      return true;
+    } else {
+      seen.set(fn, count + 1);
+    }
+  }
+}
+let devtools;
+let buffer = [];
+let devtoolsNotInstalled = false;
+function emit$1(event, ...args) {
+  if (devtools) {
+    devtools.emit(event, ...args);
+  } else if (!devtoolsNotInstalled) {
+    buffer.push({ event, args });
+  }
+}
+function setDevtoolsHook(hook, target) {
+  var _a, _b;
+  devtools = hook;
+  if (devtools) {
+    devtools.enabled = true;
+    buffer.forEach(({ event, args }) => devtools.emit(event, ...args));
+    buffer = [];
+  } else if (
+    // handle late devtools injection - only do this if we are in an actual
+    // browser environment to avoid the timer handle stalling test runner exit
+    // (#4815)
+    typeof window !== "undefined" && // some envs mock window but not fully
+    window.HTMLElement && // also exclude jsdom
+    !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
+  ) {
+    const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
+    replay.push((newHook) => {
+      setDevtoolsHook(newHook, target);
+    });
+    setTimeout(() => {
+      if (!devtools) {
+        target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
+        devtoolsNotInstalled = true;
+        buffer = [];
+      }
+    }, 3e3);
+  } else {
+    devtoolsNotInstalled = true;
+    buffer = [];
+  }
+}
+function devtoolsInitApp(app, version2) {
+  emit$1("app:init", app, version2, {
+    Fragment,
+    Text,
+    Comment,
+    Static
+  });
+}
+const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(
+  "component:added"
+  /* COMPONENT_ADDED */
+);
+const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook(
+  "component:updated"
+  /* COMPONENT_UPDATED */
+);
+const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
+  "component:removed"
+  /* COMPONENT_REMOVED */
+);
+const devtoolsComponentRemoved = (component) => {
+  if (devtools && typeof devtools.cleanupBuffer === "function" && // remove the component if it wasn't buffered
+  !devtools.cleanupBuffer(component)) {
+    _devtoolsComponentRemoved(component);
+  }
+};
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function createDevtoolsComponentHook(hook) {
+  return (component) => {
+    emit$1(
+      hook,
+      component.appContext.app,
+      component.uid,
+      // fixed by xxxxxx
+      // 为 0 是 App，无 parent 是 Page 指向 App
+      component.uid === 0 ? void 0 : component.parent ? component.parent.uid : 0,
+      component
+    );
+  };
+}
+const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(
+  "perf:start"
+  /* PERFORMANCE_START */
+);
+const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(
+  "perf:end"
+  /* PERFORMANCE_END */
+);
+function createDevtoolsPerformanceHook(hook) {
+  return (component, type, time) => {
+    emit$1(hook, component.appContext.app, component.uid, component, type, time);
+  };
+}
+function devtoolsComponentEmit(component, event, params) {
+  emit$1(
+    "component:emit",
+    component.appContext.app,
+    component,
+    event,
+    params
+  );
+}
+function emit(instance, event, ...rawArgs) {
+  if (instance.isUnmounted)
+    return;
+  const props = instance.vnode.props || EMPTY_OBJ;
+  {
+    const {
+      emitsOptions,
+      propsOptions: [propsOptions]
+    } = instance;
+    if (emitsOptions) {
+      if (!(event in emitsOptions) && true) {
+        if (!propsOptions || !(toHandlerKey(event) in propsOptions)) {
+          warn$1(
+            `Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(event)}" prop.`
+          );
+        }
+      } else {
+        const validator = emitsOptions[event];
+        if (isFunction$1(validator)) {
+          const isValid = validator(...rawArgs);
+          if (!isValid) {
+            warn$1(
+              `Invalid event arguments: event validation failed for event "${event}".`
+            );
+          }
+        }
+      }
+    }
+  }
+  let args = rawArgs;
+  const isModelListener2 = event.startsWith("update:");
+  const modelArg = isModelListener2 && event.slice(7);
+  if (modelArg && modelArg in props) {
+    const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
+    const { number, trim } = props[modifiersKey] || EMPTY_OBJ;
+    if (trim) {
+      args = rawArgs.map((a) => isString$1(a) ? a.trim() : a);
+    }
+    if (number) {
+      args = rawArgs.map(looseToNumber);
+    }
+  }
+  {
+    devtoolsComponentEmit(instance, event, args);
+  }
+  {
+    const lowerCaseEvent = event.toLowerCase();
+    if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) {
+      warn$1(
+        `Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(
+          instance,
+          instance.type
+        )} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${hyphenate(
+          event
+        )}" instead of "${event}".`
+      );
+    }
+  }
+  let handlerName;
+  let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
+  props[handlerName = toHandlerKey(camelize(event))];
+  if (!handler && isModelListener2) {
+    handler = props[handlerName = toHandlerKey(hyphenate(event))];
+  }
+  if (handler) {
+    callWithAsyncErrorHandling(
+      handler,
+      instance,
+      6,
+      args
+    );
+  }
+  const onceHandler = props[handlerName + `Once`];
+  if (onceHandler) {
+    if (!instance.emitted) {
+      instance.emitted = {};
+    } else if (instance.emitted[handlerName]) {
+      return;
+    }
+    instance.emitted[handlerName] = true;
+    callWithAsyncErrorHandling(
+      onceHandler,
+      instance,
+      6,
+      args
+    );
+  }
+}
+function normalizeEmitsOptions(comp, appContext, asMixin = false) {
+  const cache = appContext.emitsCache;
+  const cached = cache.get(comp);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const raw = comp.emits;
+  let normalized = {};
+  let hasExtends = false;
+  if (!isFunction$1(comp)) {
+    const extendEmits = (raw2) => {
+      const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
+      if (normalizedFromExtend) {
+        hasExtends = true;
+        extend(normalized, normalizedFromExtend);
+      }
+    };
+    if (!asMixin && appContext.mixins.length) {
+      appContext.mixins.forEach(extendEmits);
+    }
+    if (comp.extends) {
+      extendEmits(comp.extends);
+    }
+    if (comp.mixins) {
+      comp.mixins.forEach(extendEmits);
+    }
+  }
+  if (!raw && !hasExtends) {
+    if (isObject(comp)) {
+      cache.set(comp, null);
+    }
+    return null;
+  }
+  if (isArray$1(raw)) {
+    raw.forEach((key) => normalized[key] = null);
+  } else {
+    extend(normalized, raw);
+  }
+  if (isObject(comp)) {
+    cache.set(comp, normalized);
+  }
+  return normalized;
+}
+function isEmitListener(options, key) {
+  if (!options || !isOn(key)) {
+    return false;
+  }
+  key = key.slice(2).replace(/Once$/, "");
+  return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
+}
+let currentRenderingInstance = null;
+function setCurrentRenderingInstance(instance) {
+  const prev = currentRenderingInstance;
+  currentRenderingInstance = instance;
+  instance && instance.type.__scopeId || null;
+  return prev;
+}
+const COMPONENTS = "components";
+function resolveComponent(name, maybeSelfReference) {
+  return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
+}
+function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
+  const instance = currentRenderingInstance || currentInstance;
+  if (instance) {
+    const Component2 = instance.type;
+    {
+      const selfName = getComponentName(
+        Component2,
+        false
+      );
+      if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {
+        return Component2;
+      }
+    }
+    const res = (
+      // local registration
+      // check instance[type] first which is resolved for options API
+      resolve(instance[type] || Component2[type], name) || // global registration
+      resolve(instance.appContext[type], name)
+    );
+    if (!res && maybeSelfReference) {
+      return Component2;
+    }
+    if (warnMissing && !res) {
+      const extra = `
+If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.`;
+      warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
+    }
+    return res;
+  } else {
+    warn$1(
+      `resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`
+    );
+  }
+}
+function resolve(registry, name) {
+  return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
+}
+const INITIAL_WATCHER_VALUE = {};
+function watch(source, cb, options) {
+  if (!isFunction$1(cb)) {
+    warn$1(
+      `\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`
+    );
+  }
+  return doWatch(source, cb, options);
+}
+function doWatch(source, cb, {
+  immediate,
+  deep,
+  flush,
+  once: once2,
+  onTrack,
+  onTrigger
+} = EMPTY_OBJ) {
+  if (cb && once2) {
+    const _cb = cb;
+    cb = (...args) => {
+      _cb(...args);
+      unwatch();
+    };
+  }
+  if (deep !== void 0 && typeof deep === "number") {
+    warn$1(
+      `watch() "deep" option with number value will be used as watch depth in future versions. Please use a boolean instead to avoid potential breakage.`
+    );
+  }
+  if (!cb) {
+    if (immediate !== void 0) {
+      warn$1(
+        `watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`
+      );
+    }
+    if (deep !== void 0) {
+      warn$1(
+        `watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`
+      );
+    }
+    if (once2 !== void 0) {
+      warn$1(
+        `watch() "once" option is only respected when using the watch(source, callback, options?) signature.`
+      );
+    }
+  }
+  const warnInvalidSource = (s2) => {
+    warn$1(
+      `Invalid watch source: `,
+      s2,
+      `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`
+    );
+  };
+  const instance = currentInstance;
+  const reactiveGetter = (source2) => deep === true ? source2 : (
+    // for deep: false, only traverse root-level properties
+    traverse(source2, deep === false ? 1 : void 0)
+  );
+  let getter;
+  let forceTrigger = false;
+  let isMultiSource = false;
+  if (isRef(source)) {
+    getter = () => source.value;
+    forceTrigger = isShallow(source);
+  } else if (isReactive(source)) {
+    getter = () => reactiveGetter(source);
+    forceTrigger = true;
+  } else if (isArray$1(source)) {
+    isMultiSource = true;
+    forceTrigger = source.some((s2) => isReactive(s2) || isShallow(s2));
+    getter = () => source.map((s2) => {
+      if (isRef(s2)) {
+        return s2.value;
+      } else if (isReactive(s2)) {
+        return reactiveGetter(s2);
+      } else if (isFunction$1(s2)) {
+        return callWithErrorHandling(s2, instance, 2);
+      } else {
+        warnInvalidSource(s2);
+      }
+    });
+  } else if (isFunction$1(source)) {
+    if (cb) {
+      getter = () => callWithErrorHandling(source, instance, 2);
+    } else {
+      getter = () => {
+        if (cleanup) {
+          cleanup();
+        }
+        return callWithAsyncErrorHandling(
+          source,
+          instance,
+          3,
+          [onCleanup]
+        );
+      };
+    }
+  } else {
+    getter = NOOP;
+    warnInvalidSource(source);
+  }
+  if (cb && deep) {
+    const baseGetter = getter;
+    getter = () => traverse(baseGetter());
+  }
+  let cleanup;
+  let onCleanup = (fn) => {
+    cleanup = effect2.onStop = () => {
+      callWithErrorHandling(fn, instance, 4);
+      cleanup = effect2.onStop = void 0;
+    };
+  };
+  let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+  const job = () => {
+    if (!effect2.active || !effect2.dirty) {
+      return;
+    }
+    if (cb) {
+      const newValue = effect2.run();
+      if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) {
+        if (cleanup) {
+          cleanup();
+        }
+        callWithAsyncErrorHandling(cb, instance, 3, [
+          newValue,
+          // pass undefined as the old value when it's changed for the first time
+          oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
+          onCleanup
+        ]);
+        oldValue = newValue;
+      }
+    } else {
+      effect2.run();
+    }
+  };
+  job.allowRecurse = !!cb;
+  let scheduler;
+  if (flush === "sync") {
+    scheduler = job;
+  } else if (flush === "post") {
+    scheduler = () => queuePostRenderEffect$1(job, instance && instance.suspense);
+  } else {
+    job.pre = true;
+    if (instance)
+      job.id = instance.uid;
+    scheduler = () => queueJob(job);
+  }
+  const effect2 = new ReactiveEffect2(getter, NOOP, scheduler);
+  const scope = getCurrentScope();
+  const unwatch = () => {
+    effect2.stop();
+    if (scope) {
+      remove(scope.effects, effect2);
+    }
+  };
+  {
+    effect2.onTrack = onTrack;
+    effect2.onTrigger = onTrigger;
+  }
+  if (cb) {
+    if (immediate) {
+      job();
+    } else {
+      oldValue = effect2.run();
+    }
+  } else if (flush === "post") {
+    queuePostRenderEffect$1(
+      effect2.run.bind(effect2),
+      instance && instance.suspense
+    );
+  } else {
+    effect2.run();
+  }
+  return unwatch;
+}
+function instanceWatch(source, value, options) {
+  const publicThis = this.proxy;
+  const getter = isString$1(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+  let cb;
+  if (isFunction$1(value)) {
+    cb = value;
+  } else {
+    cb = value.handler;
+    options = value;
+  }
+  const reset = setCurrentInstance(this);
+  const res = doWatch(getter, cb.bind(publicThis), options);
+  reset();
+  return res;
+}
+function createPathGetter(ctx, path) {
+  const segments = path.split(".");
+  return () => {
+    let cur = ctx;
+    for (let i = 0; i < segments.length && cur; i++) {
+      cur = cur[segments[i]];
+    }
+    return cur;
+  };
+}
+function traverse(value, depth, currentDepth = 0, seen) {
+  if (!isObject(value) || value["__v_skip"]) {
+    return value;
+  }
+  if (depth && depth > 0) {
+    if (currentDepth >= depth) {
+      return value;
+    }
+    currentDepth++;
+  }
+  seen = seen || /* @__PURE__ */ new Set();
+  if (seen.has(value)) {
+    return value;
+  }
+  seen.add(value);
+  if (isRef(value)) {
+    traverse(value.value, depth, currentDepth, seen);
+  } else if (isArray$1(value)) {
+    for (let i = 0; i < value.length; i++) {
+      traverse(value[i], depth, currentDepth, seen);
+    }
+  } else if (isSet(value) || isMap(value)) {
+    value.forEach((v) => {
+      traverse(v, depth, currentDepth, seen);
+    });
+  } else if (isPlainObject(value)) {
+    for (const key in value) {
+      traverse(value[key], depth, currentDepth, seen);
+    }
+  }
+  return value;
+}
+function validateDirectiveName(name) {
+  if (isBuiltInDirective(name)) {
+    warn$1("Do not use built-in directive ids as custom directive id: " + name);
+  }
+}
+function createAppContext() {
+  return {
+    app: null,
+    config: {
+      isNativeTag: NO,
+      performance: false,
+      globalProperties: {},
+      optionMergeStrategies: {},
+      errorHandler: void 0,
+      warnHandler: void 0,
+      compilerOptions: {}
+    },
+    mixins: [],
+    components: {},
+    directives: {},
+    provides: /* @__PURE__ */ Object.create(null),
+    optionsCache: /* @__PURE__ */ new WeakMap(),
+    propsCache: /* @__PURE__ */ new WeakMap(),
+    emitsCache: /* @__PURE__ */ new WeakMap()
+  };
+}
+let uid$1 = 0;
+function createAppAPI(render, hydrate) {
+  return function createApp2(rootComponent, rootProps = null) {
+    if (!isFunction$1(rootComponent)) {
+      rootComponent = extend({}, rootComponent);
+    }
+    if (rootProps != null && !isObject(rootProps)) {
+      warn$1(`root props passed to app.mount() must be an object.`);
+      rootProps = null;
+    }
+    const context2 = createAppContext();
+    const installedPlugins = /* @__PURE__ */ new WeakSet();
+    const app = context2.app = {
+      _uid: uid$1++,
+      _component: rootComponent,
+      _props: rootProps,
+      _container: null,
+      _context: context2,
+      _instance: null,
+      version,
+      get config() {
+        return context2.config;
+      },
+      set config(v) {
+        {
+          warn$1(
+            `app.config cannot be replaced. Modify individual options instead.`
+          );
+        }
+      },
+      use(plugin2, ...options) {
+        if (installedPlugins.has(plugin2)) {
+          warn$1(`Plugin has already been applied to target app.`);
+        } else if (plugin2 && isFunction$1(plugin2.install)) {
+          installedPlugins.add(plugin2);
+          plugin2.install(app, ...options);
+        } else if (isFunction$1(plugin2)) {
+          installedPlugins.add(plugin2);
+          plugin2(app, ...options);
+        } else {
+          warn$1(
+            `A plugin must either be a function or an object with an "install" function.`
+          );
+        }
+        return app;
+      },
+      mixin(mixin) {
+        {
+          if (!context2.mixins.includes(mixin)) {
+            context2.mixins.push(mixin);
+          } else {
+            warn$1(
+              "Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "")
+            );
+          }
+        }
+        return app;
+      },
+      component(name, component) {
+        {
+          validateComponentName(name, context2.config);
+        }
+        if (!component) {
+          return context2.components[name];
+        }
+        if (context2.components[name]) {
+          warn$1(`Component "${name}" has already been registered in target app.`);
+        }
+        context2.components[name] = component;
+        return app;
+      },
+      directive(name, directive) {
+        {
+          validateDirectiveName(name);
+        }
+        if (!directive) {
+          return context2.directives[name];
+        }
+        if (context2.directives[name]) {
+          warn$1(`Directive "${name}" has already been registered in target app.`);
+        }
+        context2.directives[name] = directive;
+        return app;
+      },
+      // fixed by xxxxxx
+      mount() {
+      },
+      // fixed by xxxxxx
+      unmount() {
+      },
+      provide(key, value) {
+        if (key in context2.provides) {
+          warn$1(
+            `App already provides property with key "${String(key)}". It will be overwritten with the new value.`
+          );
+        }
+        context2.provides[key] = value;
+        return app;
+      },
+      runWithContext(fn) {
+        const lastApp = currentApp;
+        currentApp = app;
+        try {
+          return fn();
+        } finally {
+          currentApp = lastApp;
+        }
+      }
+    };
+    return app;
+  };
+}
+let currentApp = null;
+function provide(key, value) {
+  if (!currentInstance) {
+    {
+      warn$1(`provide() can only be used inside setup().`);
+    }
+  } else {
+    let provides = currentInstance.provides;
+    const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+    if (parentProvides === provides) {
+      provides = currentInstance.provides = Object.create(parentProvides);
+    }
+    provides[key] = value;
+    if (currentInstance.type.mpType === "app") {
+      currentInstance.appContext.app.provide(key, value);
+    }
+  }
+}
+function inject(key, defaultValue, treatDefaultAsFactory = false) {
+  const instance = currentInstance || currentRenderingInstance;
+  if (instance || currentApp) {
+    const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : currentApp._context.provides;
+    if (provides && key in provides) {
+      return provides[key];
+    } else if (arguments.length > 1) {
+      return treatDefaultAsFactory && isFunction$1(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+    } else {
+      warn$1(`injection "${String(key)}" not found.`);
+    }
+  } else {
+    warn$1(`inject() can only be used inside setup() or functional components.`);
+  }
+}
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function defineComponent(options, extraOptions) {
+  return isFunction$1(options) ? (
+    // #8326: extend call and options.name access are considered side-effects
+    // by Rollup, so we have to wrap it in a pure-annotated IIFE.
+    /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()
+  ) : options;
+}
+const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
+function onActivated(hook, target) {
+  registerKeepAliveHook(hook, "a", target);
+}
+function onDeactivated(hook, target) {
+  registerKeepAliveHook(hook, "da", target);
+}
+function registerKeepAliveHook(hook, type, target = currentInstance) {
+  const wrappedHook = hook.__wdc || (hook.__wdc = () => {
+    let current = target;
+    while (current) {
+      if (current.isDeactivated) {
+        return;
+      }
+      current = current.parent;
+    }
+    return hook();
+  });
+  injectHook(type, wrappedHook, target);
+  if (target) {
+    let current = target.parent;
+    while (current && current.parent) {
+      if (isKeepAlive(current.parent.vnode)) {
+        injectToKeepAliveRoot(wrappedHook, type, target, current);
+      }
+      current = current.parent;
+    }
+  }
+}
+function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
+  const injected = injectHook(
+    type,
+    hook,
+    keepAliveRoot,
+    true
+    /* prepend */
+  );
+  onUnmounted(() => {
+    remove(keepAliveRoot[type], injected);
+  }, target);
+}
+function injectHook(type, hook, target = currentInstance, prepend = false) {
+  if (target) {
+    if (isRootHook(type)) {
+      target = target.root;
+    }
+    const hooks = target[type] || (target[type] = []);
+    const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
+      if (target.isUnmounted) {
+        return;
+      }
+      pauseTracking();
+      const reset = setCurrentInstance(target);
+      const res = callWithAsyncErrorHandling(hook, target, type, args);
+      reset();
+      resetTracking();
+      return res;
+    });
+    if (prepend) {
+      hooks.unshift(wrappedHook);
+    } else {
+      hooks.push(wrappedHook);
+    }
+    return wrappedHook;
+  } else {
+    const apiName = toHandlerKey(
+      (ErrorTypeStrings[type] || type.replace(/^on/, "")).replace(/ hook$/, "")
+    );
+    warn$1(
+      `${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().`
+    );
+  }
+}
+const createHook$1 = (lifecycle) => (hook, target = currentInstance) => (
+  // post-create lifecycle registrations are noops during SSR (except for serverPrefetch)
+  (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target)
+);
+const onBeforeMount = createHook$1("bm");
+const onMounted = createHook$1("m");
+const onBeforeUpdate = createHook$1("bu");
+const onUpdated = createHook$1("u");
+const onBeforeUnmount = createHook$1("bum");
+const onUnmounted = createHook$1("um");
+const onServerPrefetch = createHook$1("sp");
+const onRenderTriggered = createHook$1(
+  "rtg"
+);
+const onRenderTracked = createHook$1(
+  "rtc"
+);
+function onErrorCaptured(hook, target = currentInstance) {
+  injectHook("ec", hook, target);
+}
+const getPublicInstance = (i) => {
+  if (!i)
+    return null;
+  if (isStatefulComponent(i))
+    return getExposeProxy(i) || i.proxy;
+  return getPublicInstance(i.parent);
+};
+const publicPropertiesMap = (
+  // Move PURE marker to new line to workaround compiler discarding it
+  // due to type annotation
+  /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
+    $: (i) => i,
+    // fixed by xxxxxx vue-i18n 在 dev 模式，访问了 $el，故模拟一个假的
+    // $el: i => i.vnode.el,
+    $el: (i) => i.__$el || (i.__$el = {}),
+    $data: (i) => i.data,
+    $props: (i) => shallowReadonly(i.props),
+    $attrs: (i) => shallowReadonly(i.attrs),
+    $slots: (i) => shallowReadonly(i.slots),
+    $refs: (i) => shallowReadonly(i.refs),
+    $parent: (i) => getPublicInstance(i.parent),
+    $root: (i) => getPublicInstance(i.root),
+    $emit: (i) => i.emit,
+    $options: (i) => resolveMergedOptions(i),
+    $forceUpdate: (i) => i.f || (i.f = () => {
+      i.effect.dirty = true;
+      queueJob(i.update);
+    }),
+    // $nextTick: i => i.n || (i.n = nextTick.bind(i.proxy!)),// fixed by xxxxxx
+    $watch: (i) => instanceWatch.bind(i)
+  })
+);
+const isReservedPrefix = (key) => key === "_" || key === "$";
+const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
+const PublicInstanceProxyHandlers = {
+  get({ _: instance }, key) {
+    const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
+    if (key === "__isVue") {
+      return true;
+    }
+    let normalizedProps;
+    if (key[0] !== "$") {
+      const n2 = accessCache[key];
+      if (n2 !== void 0) {
+        switch (n2) {
+          case 1:
+            return setupState[key];
+          case 2:
+            return data[key];
+          case 4:
+            return ctx[key];
+          case 3:
+            return props[key];
+        }
+      } else if (hasSetupBinding(setupState, key)) {
+        accessCache[key] = 1;
+        return setupState[key];
+      } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+        accessCache[key] = 2;
+        return data[key];
+      } else if (
+        // only cache other properties when instance has declared (thus stable)
+        // props
+        (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)
+      ) {
+        accessCache[key] = 3;
+        return props[key];
+      } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+        accessCache[key] = 4;
+        return ctx[key];
+      } else if (shouldCacheAccess) {
+        accessCache[key] = 0;
+      }
+    }
+    const publicGetter = publicPropertiesMap[key];
+    let cssModule, globalProperties;
+    if (publicGetter) {
+      if (key === "$attrs") {
+        track(instance, "get", key);
+      } else if (key === "$slots") {
+        track(instance, "get", key);
+      }
+      return publicGetter(instance);
+    } else if (
+      // css module (injected by vue-loader)
+      (cssModule = type.__cssModules) && (cssModule = cssModule[key])
+    ) {
+      return cssModule;
+    } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+      accessCache[key] = 4;
+      return ctx[key];
+    } else if (
+      // global properties
+      globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)
+    ) {
+      {
+        return globalProperties[key];
+      }
+    } else if (currentRenderingInstance && (!isString$1(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading
+    // to infinite warning loop
+    key.indexOf("__v") !== 0)) {
+      if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) {
+        warn$1(
+          `Property ${JSON.stringify(
+            key
+          )} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`
+        );
+      } else if (instance === currentRenderingInstance) {
+        warn$1(
+          `Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`
+        );
+      }
+    }
+  },
+  set({ _: instance }, key, value) {
+    const { data, setupState, ctx } = instance;
+    if (hasSetupBinding(setupState, key)) {
+      setupState[key] = value;
+      return true;
+    } else if (setupState.__isScriptSetup && hasOwn(setupState, key)) {
+      warn$1(`Cannot mutate <script setup> binding "${key}" from Options API.`);
+      return false;
+    } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+      data[key] = value;
+      return true;
+    } else if (hasOwn(instance.props, key)) {
+      warn$1(`Attempting to mutate prop "${key}". Props are readonly.`);
+      return false;
+    }
+    if (key[0] === "$" && key.slice(1) in instance) {
+      warn$1(
+        `Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`
+      );
+      return false;
+    } else {
+      if (key in instance.appContext.config.globalProperties) {
+        Object.defineProperty(ctx, key, {
+          enumerable: true,
+          configurable: true,
+          value
+        });
+      } else {
+        ctx[key] = value;
+      }
+    }
+    return true;
+  },
+  has({
+    _: { data, setupState, accessCache, ctx, appContext, propsOptions }
+  }, key) {
+    let normalizedProps;
+    return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
+  },
+  defineProperty(target, key, descriptor) {
+    if (descriptor.get != null) {
+      target._.accessCache[key] = 0;
+    } else if (hasOwn(descriptor, "value")) {
+      this.set(target, key, descriptor.value, null);
+    }
+    return Reflect.defineProperty(target, key, descriptor);
+  }
+};
+{
+  PublicInstanceProxyHandlers.ownKeys = (target) => {
+    warn$1(
+      `Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`
+    );
+    return Reflect.ownKeys(target);
+  };
+}
+function createDevRenderContext(instance) {
+  const target = {};
+  Object.defineProperty(target, `_`, {
+    configurable: true,
+    enumerable: false,
+    get: () => instance
+  });
+  Object.keys(publicPropertiesMap).forEach((key) => {
+    Object.defineProperty(target, key, {
+      configurable: true,
+      enumerable: false,
+      get: () => publicPropertiesMap[key](instance),
+      // intercepted by the proxy so no need for implementation,
+      // but needed to prevent set errors
+      set: NOOP
+    });
+  });
+  return target;
+}
+function exposePropsOnRenderContext(instance) {
+  const {
+    ctx,
+    propsOptions: [propsOptions]
+  } = instance;
+  if (propsOptions) {
+    Object.keys(propsOptions).forEach((key) => {
+      Object.defineProperty(ctx, key, {
+        enumerable: true,
+        configurable: true,
+        get: () => instance.props[key],
+        set: NOOP
+      });
+    });
+  }
+}
+function exposeSetupStateOnRenderContext(instance) {
+  const { ctx, setupState } = instance;
+  Object.keys(toRaw(setupState)).forEach((key) => {
+    if (!setupState.__isScriptSetup) {
+      if (isReservedPrefix(key[0])) {
+        warn$1(
+          `setup() return property ${JSON.stringify(
+            key
+          )} should not start with "$" or "_" which are reserved prefixes for Vue internals.`
+        );
+        return;
+      }
+      Object.defineProperty(ctx, key, {
+        enumerable: true,
+        configurable: true,
+        get: () => setupState[key],
+        set: NOOP
+      });
+    }
+  });
+}
+function normalizePropsOrEmits(props) {
+  return isArray$1(props) ? props.reduce(
+    (normalized, p2) => (normalized[p2] = null, normalized),
+    {}
+  ) : props;
+}
+function createDuplicateChecker() {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (type, key) => {
+    if (cache[key]) {
+      warn$1(`${type} property "${key}" is already defined in ${cache[key]}.`);
+    } else {
+      cache[key] = type;
+    }
+  };
+}
+let shouldCacheAccess = true;
+function applyOptions$1(instance) {
+  const options = resolveMergedOptions(instance);
+  const publicThis = instance.proxy;
+  const ctx = instance.ctx;
+  shouldCacheAccess = false;
+  if (options.beforeCreate) {
+    callHook$1(options.beforeCreate, instance, "bc");
+  }
+  const {
+    // state
+    data: dataOptions,
+    computed: computedOptions,
+    methods,
+    watch: watchOptions,
+    provide: provideOptions,
+    inject: injectOptions,
+    // lifecycle
+    created,
+    beforeMount,
+    mounted,
+    beforeUpdate,
+    updated,
+    activated,
+    deactivated,
+    beforeDestroy,
+    beforeUnmount,
+    destroyed,
+    unmounted,
+    render,
+    renderTracked,
+    renderTriggered,
+    errorCaptured,
+    serverPrefetch,
+    // public API
+    expose,
+    inheritAttrs,
+    // assets
+    components,
+    directives,
+    filters
+  } = options;
+  const checkDuplicateProperties = createDuplicateChecker();
+  {
+    const [propsOptions] = instance.propsOptions;
+    if (propsOptions) {
+      for (const key in propsOptions) {
+        checkDuplicateProperties("Props", key);
+      }
+    }
+  }
+  function initInjections() {
+    if (injectOptions) {
+      resolveInjections(injectOptions, ctx, checkDuplicateProperties);
+    }
+  }
+  {
+    initInjections();
+  }
+  if (methods) {
+    for (const key in methods) {
+      const methodHandler = methods[key];
+      if (isFunction$1(methodHandler)) {
+        {
+          Object.defineProperty(ctx, key, {
+            value: methodHandler.bind(publicThis),
+            configurable: true,
+            enumerable: true,
+            writable: true
+          });
+        }
+        {
+          checkDuplicateProperties("Methods", key);
+        }
+      } else {
+        warn$1(
+          `Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?`
+        );
+      }
+    }
+  }
+  if (dataOptions) {
+    if (!isFunction$1(dataOptions)) {
+      warn$1(
+        `The data option must be a function. Plain object usage is no longer supported.`
+      );
+    }
+    const data = dataOptions.call(publicThis, publicThis);
+    if (isPromise$1(data)) {
+      warn$1(
+        `data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>.`
+      );
+    }
+    if (!isObject(data)) {
+      warn$1(`data() should return an object.`);
+    } else {
+      instance.data = reactive(data);
+      {
+        for (const key in data) {
+          checkDuplicateProperties("Data", key);
+          if (!isReservedPrefix(key[0])) {
+            Object.defineProperty(ctx, key, {
+              configurable: true,
+              enumerable: true,
+              get: () => data[key],
+              set: NOOP
+            });
+          }
+        }
+      }
+    }
+  }
+  shouldCacheAccess = true;
+  if (computedOptions) {
+    for (const key in computedOptions) {
+      const opt = computedOptions[key];
+      const get2 = isFunction$1(opt) ? opt.bind(publicThis, publicThis) : isFunction$1(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
+      if (get2 === NOOP) {
+        warn$1(`Computed property "${key}" has no getter.`);
+      }
+      const set2 = !isFunction$1(opt) && isFunction$1(opt.set) ? opt.set.bind(publicThis) : () => {
+        warn$1(
+          `Write operation failed: computed property "${key}" is readonly.`
+        );
+      };
+      const c2 = computed({
+        get: get2,
+        set: set2
+      });
+      Object.defineProperty(ctx, key, {
+        enumerable: true,
+        configurable: true,
+        get: () => c2.value,
+        set: (v) => c2.value = v
+      });
+      {
+        checkDuplicateProperties("Computed", key);
+      }
+    }
+  }
+  if (watchOptions) {
+    for (const key in watchOptions) {
+      createWatcher(watchOptions[key], ctx, publicThis, key);
+    }
+  }
+  function initProvides() {
+    if (provideOptions) {
+      const provides = isFunction$1(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
+      Reflect.ownKeys(provides).forEach((key) => {
+        provide(key, provides[key]);
+      });
+    }
+  }
+  {
+    initProvides();
+  }
+  {
+    if (created) {
+      callHook$1(created, instance, "c");
+    }
+  }
+  function registerLifecycleHook(register, hook) {
+    if (isArray$1(hook)) {
+      hook.forEach((_hook) => register(_hook.bind(publicThis)));
+    } else if (hook) {
+      register(hook.bind(publicThis));
+    }
+  }
+  registerLifecycleHook(onBeforeMount, beforeMount);
+  registerLifecycleHook(onMounted, mounted);
+  registerLifecycleHook(onBeforeUpdate, beforeUpdate);
+  registerLifecycleHook(onUpdated, updated);
+  registerLifecycleHook(onActivated, activated);
+  registerLifecycleHook(onDeactivated, deactivated);
+  registerLifecycleHook(onErrorCaptured, errorCaptured);
+  registerLifecycleHook(onRenderTracked, renderTracked);
+  registerLifecycleHook(onRenderTriggered, renderTriggered);
+  registerLifecycleHook(onBeforeUnmount, beforeUnmount);
+  registerLifecycleHook(onUnmounted, unmounted);
+  registerLifecycleHook(onServerPrefetch, serverPrefetch);
+  if (isArray$1(expose)) {
+    if (expose.length) {
+      const exposed = instance.exposed || (instance.exposed = {});
+      expose.forEach((key) => {
+        Object.defineProperty(exposed, key, {
+          get: () => publicThis[key],
+          set: (val) => publicThis[key] = val
+        });
+      });
+    } else if (!instance.exposed) {
+      instance.exposed = {};
+    }
+  }
+  if (render && instance.render === NOOP) {
+    instance.render = render;
+  }
+  if (inheritAttrs != null) {
+    instance.inheritAttrs = inheritAttrs;
+  }
+  if (components)
+    instance.components = components;
+  if (directives)
+    instance.directives = directives;
+  if (instance.ctx.$onApplyOptions) {
+    instance.ctx.$onApplyOptions(options, instance, publicThis);
+  }
+}
+function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
+  if (isArray$1(injectOptions)) {
+    injectOptions = normalizeInject(injectOptions);
+  }
+  for (const key in injectOptions) {
+    const opt = injectOptions[key];
+    let injected;
+    if (isObject(opt)) {
+      if ("default" in opt) {
+        injected = inject(
+          opt.from || key,
+          opt.default,
+          true
+        );
+      } else {
+        injected = inject(opt.from || key);
+      }
+    } else {
+      injected = inject(opt);
+    }
+    if (isRef(injected)) {
+      Object.defineProperty(ctx, key, {
+        enumerable: true,
+        configurable: true,
+        get: () => injected.value,
+        set: (v) => injected.value = v
+      });
+    } else {
+      ctx[key] = injected;
+    }
+    {
+      checkDuplicateProperties("Inject", key);
+    }
+  }
+}
+function callHook$1(hook, instance, type) {
+  callWithAsyncErrorHandling(
+    isArray$1(hook) ? hook.map((h2) => h2.bind(instance.proxy)) : hook.bind(instance.proxy),
+    instance,
+    type
+  );
+}
+function createWatcher(raw, ctx, publicThis, key) {
+  const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
+  if (isString$1(raw)) {
+    const handler = ctx[raw];
+    if (isFunction$1(handler)) {
+      watch(getter, handler);
+    } else {
+      warn$1(`Invalid watch handler specified by key "${raw}"`, handler);
+    }
+  } else if (isFunction$1(raw)) {
+    watch(getter, raw.bind(publicThis));
+  } else if (isObject(raw)) {
+    if (isArray$1(raw)) {
+      raw.forEach((r2) => createWatcher(r2, ctx, publicThis, key));
+    } else {
+      const handler = isFunction$1(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
+      if (isFunction$1(handler)) {
+        watch(getter, handler, raw);
+      } else {
+        warn$1(`Invalid watch handler specified by key "${raw.handler}"`, handler);
+      }
+    }
+  } else {
+    warn$1(`Invalid watch option: "${key}"`, raw);
+  }
+}
+function resolveMergedOptions(instance) {
+  const base = instance.type;
+  const { mixins, extends: extendsOptions } = base;
+  const {
+    mixins: globalMixins,
+    optionsCache: cache,
+    config: { optionMergeStrategies }
+  } = instance.appContext;
+  const cached = cache.get(base);
+  let resolved;
+  if (cached) {
+    resolved = cached;
+  } else if (!globalMixins.length && !mixins && !extendsOptions) {
+    {
+      resolved = base;
+    }
+  } else {
+    resolved = {};
+    if (globalMixins.length) {
+      globalMixins.forEach(
+        (m2) => mergeOptions(resolved, m2, optionMergeStrategies, true)
+      );
+    }
+    mergeOptions(resolved, base, optionMergeStrategies);
+  }
+  if (isObject(base)) {
+    cache.set(base, resolved);
+  }
+  return resolved;
+}
+function mergeOptions(to, from, strats, asMixin = false) {
+  const { mixins, extends: extendsOptions } = from;
+  if (extendsOptions) {
+    mergeOptions(to, extendsOptions, strats, true);
+  }
+  if (mixins) {
+    mixins.forEach(
+      (m2) => mergeOptions(to, m2, strats, true)
+    );
+  }
+  for (const key in from) {
+    if (asMixin && key === "expose") {
+      warn$1(
+        `"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`
+      );
+    } else {
+      const strat = internalOptionMergeStrats[key] || strats && strats[key];
+      to[key] = strat ? strat(to[key], from[key]) : from[key];
+    }
+  }
+  return to;
+}
+const internalOptionMergeStrats = {
+  data: mergeDataFn,
+  props: mergeEmitsOrPropsOptions,
+  emits: mergeEmitsOrPropsOptions,
+  // objects
+  methods: mergeObjectOptions,
+  computed: mergeObjectOptions,
+  // lifecycle
+  beforeCreate: mergeAsArray$1,
+  created: mergeAsArray$1,
+  beforeMount: mergeAsArray$1,
+  mounted: mergeAsArray$1,
+  beforeUpdate: mergeAsArray$1,
+  updated: mergeAsArray$1,
+  beforeDestroy: mergeAsArray$1,
+  beforeUnmount: mergeAsArray$1,
+  destroyed: mergeAsArray$1,
+  unmounted: mergeAsArray$1,
+  activated: mergeAsArray$1,
+  deactivated: mergeAsArray$1,
+  errorCaptured: mergeAsArray$1,
+  serverPrefetch: mergeAsArray$1,
+  // assets
+  components: mergeObjectOptions,
+  directives: mergeObjectOptions,
+  // watch
+  watch: mergeWatchOptions,
+  // provide / inject
+  provide: mergeDataFn,
+  inject: mergeInject
+};
+function mergeDataFn(to, from) {
+  if (!from) {
+    return to;
+  }
+  if (!to) {
+    return from;
+  }
+  return function mergedDataFn() {
+    return extend(
+      isFunction$1(to) ? to.call(this, this) : to,
+      isFunction$1(from) ? from.call(this, this) : from
+    );
+  };
+}
+function mergeInject(to, from) {
+  return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
+}
+function normalizeInject(raw) {
+  if (isArray$1(raw)) {
+    const res = {};
+    for (let i = 0; i < raw.length; i++) {
+      res[raw[i]] = raw[i];
+    }
+    return res;
+  }
+  return raw;
+}
+function mergeAsArray$1(to, from) {
+  return to ? [...new Set([].concat(to, from))] : from;
+}
+function mergeObjectOptions(to, from) {
+  return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
+}
+function mergeEmitsOrPropsOptions(to, from) {
+  if (to) {
+    if (isArray$1(to) && isArray$1(from)) {
+      return [.../* @__PURE__ */ new Set([...to, ...from])];
+    }
+    return extend(
+      /* @__PURE__ */ Object.create(null),
+      normalizePropsOrEmits(to),
+      normalizePropsOrEmits(from != null ? from : {})
+    );
+  } else {
+    return from;
+  }
+}
+function mergeWatchOptions(to, from) {
+  if (!to)
+    return from;
+  if (!from)
+    return to;
+  const merged = extend(/* @__PURE__ */ Object.create(null), to);
+  for (const key in from) {
+    merged[key] = mergeAsArray$1(to[key], from[key]);
+  }
+  return merged;
+}
+function initProps$1(instance, rawProps, isStateful, isSSR = false) {
+  const props = {};
+  const attrs = {};
+  instance.propsDefaults = /* @__PURE__ */ Object.create(null);
+  setFullProps(instance, rawProps, props, attrs);
+  for (const key in instance.propsOptions[0]) {
+    if (!(key in props)) {
+      props[key] = void 0;
+    }
+  }
+  {
+    validateProps(rawProps || {}, props, instance);
+  }
+  if (isStateful) {
+    instance.props = isSSR ? props : shallowReactive(props);
+  } else {
+    if (!instance.type.props) {
+      instance.props = attrs;
+    } else {
+      instance.props = props;
+    }
+  }
+  instance.attrs = attrs;
+}
+function isInHmrContext(instance) {
+}
+function updateProps(instance, rawProps, rawPrevProps, optimized) {
+  const {
+    props,
+    attrs,
+    vnode: { patchFlag }
+  } = instance;
+  const rawCurrentProps = toRaw(props);
+  const [options] = instance.propsOptions;
+  let hasAttrsChanged = false;
+  if (
+    // always force full diff in dev
+    // - #1942 if hmr is enabled with sfc component
+    // - vite#872 non-sfc component used by sfc component
+    !isInHmrContext() && patchFlag > 0 && !(patchFlag & 16)
+  ) {
+    if (patchFlag & 8) {
+      const propsToUpdate = instance.vnode.dynamicProps;
+      for (let i = 0; i < propsToUpdate.length; i++) {
+        let key = propsToUpdate[i];
+        if (isEmitListener(instance.emitsOptions, key)) {
+          continue;
+        }
+        const value = rawProps[key];
+        if (options) {
+          if (hasOwn(attrs, key)) {
+            if (value !== attrs[key]) {
+              attrs[key] = value;
+              hasAttrsChanged = true;
+            }
+          } else {
+            const camelizedKey = camelize(key);
+            props[camelizedKey] = resolvePropValue$1(
+              options,
+              rawCurrentProps,
+              camelizedKey,
+              value,
+              instance,
+              false
+            );
+          }
+        } else {
+          if (value !== attrs[key]) {
+            attrs[key] = value;
+            hasAttrsChanged = true;
+          }
+        }
+      }
+    }
+  } else {
+    if (setFullProps(instance, rawProps, props, attrs)) {
+      hasAttrsChanged = true;
+    }
+    let kebabKey;
+    for (const key in rawCurrentProps) {
+      if (!rawProps || // for camelCase
+      !hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
+      // and converted to camelCase (#955)
+      ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
+        if (options) {
+          if (rawPrevProps && // for camelCase
+          (rawPrevProps[key] !== void 0 || // for kebab-case
+          rawPrevProps[kebabKey] !== void 0)) {
+            props[key] = resolvePropValue$1(
+              options,
+              rawCurrentProps,
+              key,
+              void 0,
+              instance,
+              true
+            );
+          }
+        } else {
+          delete props[key];
+        }
+      }
+    }
+    if (attrs !== rawCurrentProps) {
+      for (const key in attrs) {
+        if (!rawProps || !hasOwn(rawProps, key) && true) {
+          delete attrs[key];
+          hasAttrsChanged = true;
+        }
+      }
+    }
+  }
+  if (hasAttrsChanged) {
+    trigger(instance, "set", "$attrs");
+  }
+  {
+    validateProps(rawProps || {}, props, instance);
+  }
+}
+function setFullProps(instance, rawProps, props, attrs) {
+  const [options, needCastKeys] = instance.propsOptions;
+  let hasAttrsChanged = false;
+  let rawCastValues;
+  if (rawProps) {
+    for (let key in rawProps) {
+      if (isReservedProp(key)) {
+        continue;
+      }
+      const value = rawProps[key];
+      let camelKey;
+      if (options && hasOwn(options, camelKey = camelize(key))) {
+        if (!needCastKeys || !needCastKeys.includes(camelKey)) {
+          props[camelKey] = value;
+        } else {
+          (rawCastValues || (rawCastValues = {}))[camelKey] = value;
+        }
+      } else if (!isEmitListener(instance.emitsOptions, key)) {
+        if (!(key in attrs) || value !== attrs[key]) {
+          attrs[key] = value;
+          hasAttrsChanged = true;
+        }
+      }
+    }
+  }
+  if (needCastKeys) {
+    const rawCurrentProps = toRaw(props);
+    const castValues = rawCastValues || EMPTY_OBJ;
+    for (let i = 0; i < needCastKeys.length; i++) {
+      const key = needCastKeys[i];
+      props[key] = resolvePropValue$1(
+        options,
+        rawCurrentProps,
+        key,
+        castValues[key],
+        instance,
+        !hasOwn(castValues, key)
+      );
+    }
+  }
+  return hasAttrsChanged;
+}
+function resolvePropValue$1(options, props, key, value, instance, isAbsent) {
+  const opt = options[key];
+  if (opt != null) {
+    const hasDefault = hasOwn(opt, "default");
+    if (hasDefault && value === void 0) {
+      const defaultValue = opt.default;
+      if (opt.type !== Function && !opt.skipFactory && isFunction$1(defaultValue)) {
+        const { propsDefaults } = instance;
+        if (key in propsDefaults) {
+          value = propsDefaults[key];
+        } else {
+          const reset = setCurrentInstance(instance);
+          value = propsDefaults[key] = defaultValue.call(
+            null,
+            props
+          );
+          reset();
+        }
+      } else {
+        value = defaultValue;
+      }
+    }
+    if (opt[
+      0
+      /* shouldCast */
+    ]) {
+      if (isAbsent && !hasDefault) {
+        value = false;
+      } else if (opt[
+        1
+        /* shouldCastTrue */
+      ] && (value === "" || value === hyphenate(key))) {
+        value = true;
+      }
+    }
+  }
+  return value;
+}
+function normalizePropsOptions(comp, appContext, asMixin = false) {
+  const cache = appContext.propsCache;
+  const cached = cache.get(comp);
+  if (cached) {
+    return cached;
+  }
+  const raw = comp.props;
+  const normalized = {};
+  const needCastKeys = [];
+  let hasExtends = false;
+  if (!isFunction$1(comp)) {
+    const extendProps = (raw2) => {
+      hasExtends = true;
+      const [props, keys] = normalizePropsOptions(raw2, appContext, true);
+      extend(normalized, props);
+      if (keys)
+        needCastKeys.push(...keys);
+    };
+    if (!asMixin && appContext.mixins.length) {
+      appContext.mixins.forEach(extendProps);
+    }
+    if (comp.extends) {
+      extendProps(comp.extends);
+    }
+    if (comp.mixins) {
+      comp.mixins.forEach(extendProps);
+    }
+  }
+  if (!raw && !hasExtends) {
+    if (isObject(comp)) {
+      cache.set(comp, EMPTY_ARR);
+    }
+    return EMPTY_ARR;
+  }
+  if (isArray$1(raw)) {
+    for (let i = 0; i < raw.length; i++) {
+      if (!isString$1(raw[i])) {
+        warn$1(`props must be strings when using array syntax.`, raw[i]);
+      }
+      const normalizedKey = camelize(raw[i]);
+      if (validatePropName(normalizedKey)) {
+        normalized[normalizedKey] = EMPTY_OBJ;
+      }
+    }
+  } else if (raw) {
+    if (!isObject(raw)) {
+      warn$1(`invalid props options`, raw);
+    }
+    for (const key in raw) {
+      const normalizedKey = camelize(key);
+      if (validatePropName(normalizedKey)) {
+        const opt = raw[key];
+        const prop = normalized[normalizedKey] = isArray$1(opt) || isFunction$1(opt) ? { type: opt } : extend({}, opt);
+        if (prop) {
+          const booleanIndex = getTypeIndex(Boolean, prop.type);
+          const stringIndex = getTypeIndex(String, prop.type);
+          prop[
+            0
+            /* shouldCast */
+          ] = booleanIndex > -1;
+          prop[
+            1
+            /* shouldCastTrue */
+          ] = stringIndex < 0 || booleanIndex < stringIndex;
+          if (booleanIndex > -1 || hasOwn(prop, "default")) {
+            needCastKeys.push(normalizedKey);
+          }
+        }
+      }
+    }
+  }
+  const res = [normalized, needCastKeys];
+  if (isObject(comp)) {
+    cache.set(comp, res);
+  }
+  return res;
+}
+function validatePropName(key) {
+  if (key[0] !== "$" && !isReservedProp(key)) {
+    return true;
+  } else {
+    warn$1(`Invalid prop name: "${key}" is a reserved property.`);
+  }
+  return false;
+}
+function getType$1(ctor) {
+  if (ctor === null) {
+    return "null";
+  }
+  if (typeof ctor === "function") {
+    return ctor.name || "";
+  } else if (typeof ctor === "object") {
+    const name = ctor.constructor && ctor.constructor.name;
+    return name || "";
+  }
+  return "";
+}
+function isSameType(a, b) {
+  return getType$1(a) === getType$1(b);
+}
+function getTypeIndex(type, expectedTypes) {
+  if (isArray$1(expectedTypes)) {
+    return expectedTypes.findIndex((t2) => isSameType(t2, type));
+  } else if (isFunction$1(expectedTypes)) {
+    return isSameType(expectedTypes, type) ? 0 : -1;
+  }
+  return -1;
+}
+function validateProps(rawProps, props, instance) {
+  const resolvedValues = toRaw(props);
+  const options = instance.propsOptions[0];
+  for (const key in options) {
+    let opt = options[key];
+    if (opt == null)
+      continue;
+    validateProp(
+      key,
+      resolvedValues[key],
+      opt,
+      shallowReadonly(resolvedValues),
+      !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key))
+    );
+  }
+}
+function validateProp(name, value, prop, props, isAbsent) {
+  const { type, required, validator, skipCheck } = prop;
+  if (required && isAbsent) {
+    warn$1('Missing required prop: "' + name + '"');
+    return;
+  }
+  if (value == null && !required) {
+    return;
+  }
+  if (type != null && type !== true && !skipCheck) {
+    let isValid = false;
+    const types = isArray$1(type) ? type : [type];
+    const expectedTypes = [];
+    for (let i = 0; i < types.length && !isValid; i++) {
+      const { valid, expectedType } = assertType(value, types[i]);
+      expectedTypes.push(expectedType || "");
+      isValid = valid;
+    }
+    if (!isValid) {
+      warn$1(getInvalidTypeMessage(name, value, expectedTypes));
+      return;
+    }
+  }
+  if (validator && !validator(value, props)) {
+    warn$1('Invalid prop: custom validator check failed for prop "' + name + '".');
+  }
+}
+const isSimpleType = /* @__PURE__ */ makeMap(
+  "String,Number,Boolean,Function,Symbol,BigInt"
+);
+function assertType(value, type) {
+  let valid;
+  const expectedType = getType$1(type);
+  if (isSimpleType(expectedType)) {
+    const t2 = typeof value;
+    valid = t2 === expectedType.toLowerCase();
+    if (!valid && t2 === "object") {
+      valid = value instanceof type;
+    }
+  } else if (expectedType === "Object") {
+    valid = isObject(value);
+  } else if (expectedType === "Array") {
+    valid = isArray$1(value);
+  } else if (expectedType === "null") {
+    valid = value === null;
+  } else {
+    valid = value instanceof type;
+  }
+  return {
+    valid,
+    expectedType
+  };
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+  if (expectedTypes.length === 0) {
+    return `Prop type [] for prop "${name}" won't match anything. Did you mean to use type Array instead?`;
+  }
+  let message = `Invalid prop: type check failed for prop "${name}". Expected ${expectedTypes.map(capitalize).join(" | ")}`;
+  const expectedType = expectedTypes[0];
+  const receivedType = toRawType(value);
+  const expectedValue = styleValue(value, expectedType);
+  const receivedValue = styleValue(value, receivedType);
+  if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
+    message += ` with value ${expectedValue}`;
+  }
+  message += `, got ${receivedType} `;
+  if (isExplicable(receivedType)) {
+    message += `with value ${receivedValue}.`;
+  }
+  return message;
+}
+function styleValue(value, type) {
+  if (type === "String") {
+    return `"${value}"`;
+  } else if (type === "Number") {
+    return `${Number(value)}`;
+  } else {
+    return `${value}`;
+  }
+}
+function isExplicable(type) {
+  const explicitTypes = ["string", "number", "boolean"];
+  return explicitTypes.some((elem) => type.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+  return args.some((elem) => elem.toLowerCase() === "boolean");
+}
+let supported;
+let perf;
+function startMeasure(instance, type) {
+  if (instance.appContext.config.performance && isSupported()) {
+    perf.mark(`vue-${type}-${instance.uid}`);
+  }
+  {
+    devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
+  }
+}
+function endMeasure(instance, type) {
+  if (instance.appContext.config.performance && isSupported()) {
+    const startTag = `vue-${type}-${instance.uid}`;
+    const endTag = startTag + `:end`;
+    perf.mark(endTag);
+    perf.measure(
+      `<${formatComponentName(instance, instance.type)}> ${type}`,
+      startTag,
+      endTag
+    );
+    perf.clearMarks(startTag);
+    perf.clearMarks(endTag);
+  }
+  {
+    devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
+  }
+}
+function isSupported() {
+  if (supported !== void 0) {
+    return supported;
+  }
+  if (typeof window !== "undefined" && window.performance) {
+    supported = true;
+    perf = window.performance;
+  } else {
+    supported = false;
+  }
+  return supported;
+}
+const queuePostRenderEffect$1 = queuePostFlushCb;
+const Fragment = Symbol.for("v-fgt");
+const Text = Symbol.for("v-txt");
+const Comment = Symbol.for("v-cmt");
+const Static = Symbol.for("v-stc");
+function isVNode(value) {
+  return value ? value.__v_isVNode === true : false;
+}
+const InternalObjectKey = `__vInternal`;
+function guardReactiveProps(props) {
+  if (!props)
+    return null;
+  return isProxy(props) || InternalObjectKey in props ? extend({}, props) : props;
+}
+const emptyAppContext = createAppContext();
+let uid = 0;
+function createComponentInstance(vnode, parent, suspense) {
+  const type = vnode.type;
+  const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
+  const instance = {
+    uid: uid++,
+    vnode,
+    type,
+    parent,
+    appContext,
+    root: null,
+    // to be immediately set
+    next: null,
+    subTree: null,
+    // will be set synchronously right after creation
+    effect: null,
+    update: null,
+    // will be set synchronously right after creation
+    scope: new EffectScope(
+      true
+      /* detached */
+    ),
+    render: null,
+    proxy: null,
+    exposed: null,
+    exposeProxy: null,
+    withProxy: null,
+    provides: parent ? parent.provides : Object.create(appContext.provides),
+    accessCache: null,
+    renderCache: [],
+    // local resolved assets
+    components: null,
+    directives: null,
+    // resolved props and emits options
+    propsOptions: normalizePropsOptions(type, appContext),
+    emitsOptions: normalizeEmitsOptions(type, appContext),
+    // emit
+    emit: null,
+    // to be set immediately
+    emitted: null,
+    // props default value
+    propsDefaults: EMPTY_OBJ,
+    // inheritAttrs
+    inheritAttrs: type.inheritAttrs,
+    // state
+    ctx: EMPTY_OBJ,
+    data: EMPTY_OBJ,
+    props: EMPTY_OBJ,
+    attrs: EMPTY_OBJ,
+    slots: EMPTY_OBJ,
+    refs: EMPTY_OBJ,
+    setupState: EMPTY_OBJ,
+    setupContext: null,
+    attrsProxy: null,
+    slotsProxy: null,
+    // suspense related
+    suspense,
+    suspenseId: suspense ? suspense.pendingId : 0,
+    asyncDep: null,
+    asyncResolved: false,
+    // lifecycle hooks
+    // not using enums here because it results in computed properties
+    isMounted: false,
+    isUnmounted: false,
+    isDeactivated: false,
+    bc: null,
+    c: null,
+    bm: null,
+    m: null,
+    bu: null,
+    u: null,
+    um: null,
+    bum: null,
+    da: null,
+    a: null,
+    rtg: null,
+    rtc: null,
+    ec: null,
+    sp: null,
+    // fixed by xxxxxx 用于存储uni-app的元素缓存
+    $uniElements: /* @__PURE__ */ new Map(),
+    $templateUniElementRefs: [],
+    $templateUniElementStyles: {},
+    $eS: {}
+  };
+  {
+    instance.ctx = createDevRenderContext(instance);
+  }
+  instance.root = parent ? parent.root : instance;
+  instance.emit = emit.bind(null, instance);
+  if (vnode.ce) {
+    vnode.ce(instance);
+  }
+  return instance;
+}
+let currentInstance = null;
+const getCurrentInstance = () => currentInstance || currentRenderingInstance;
+let internalSetCurrentInstance;
+let setInSSRSetupState;
+{
+  internalSetCurrentInstance = (i) => {
+    currentInstance = i;
+  };
+  setInSSRSetupState = (v) => {
+    isInSSRComponentSetup = v;
+  };
+}
+const setCurrentInstance = (instance) => {
+  const prev = currentInstance;
+  internalSetCurrentInstance(instance);
+  instance.scope.on();
+  return () => {
+    instance.scope.off();
+    internalSetCurrentInstance(prev);
+  };
+};
+const unsetCurrentInstance = () => {
+  currentInstance && currentInstance.scope.off();
+  internalSetCurrentInstance(null);
+};
+const isBuiltInTag = /* @__PURE__ */ makeMap("slot,component");
+function validateComponentName(name, { isNativeTag }) {
+  if (isBuiltInTag(name) || isNativeTag(name)) {
+    warn$1(
+      "Do not use built-in or reserved HTML elements as component id: " + name
+    );
+  }
+}
+function isStatefulComponent(instance) {
+  return instance.vnode.shapeFlag & 4;
+}
+let isInSSRComponentSetup = false;
+function setupComponent(instance, isSSR = false) {
+  isSSR && setInSSRSetupState(isSSR);
+  const {
+    props
+    /*, children*/
+  } = instance.vnode;
+  const isStateful = isStatefulComponent(instance);
+  initProps$1(instance, props, isStateful, isSSR);
+  const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
+  isSSR && setInSSRSetupState(false);
+  return setupResult;
+}
+function setupStatefulComponent(instance, isSSR) {
+  const Component2 = instance.type;
+  {
+    if (Component2.name) {
+      validateComponentName(Component2.name, instance.appContext.config);
+    }
+    if (Component2.components) {
+      const names = Object.keys(Component2.components);
+      for (let i = 0; i < names.length; i++) {
+        validateComponentName(names[i], instance.appContext.config);
+      }
+    }
+    if (Component2.directives) {
+      const names = Object.keys(Component2.directives);
+      for (let i = 0; i < names.length; i++) {
+        validateDirectiveName(names[i]);
+      }
+    }
+    if (Component2.compilerOptions && isRuntimeOnly()) {
+      warn$1(
+        `"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.`
+      );
+    }
+  }
+  instance.accessCache = /* @__PURE__ */ Object.create(null);
+  instance.proxy = markRaw(new Proxy(instance.ctx, PublicInstanceProxyHandlers));
+  {
+    exposePropsOnRenderContext(instance);
+  }
+  const { setup } = Component2;
+  if (setup) {
+    const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
+    const reset = setCurrentInstance(instance);
+    pauseTracking();
+    const setupResult = callWithErrorHandling(
+      setup,
+      instance,
+      0,
+      [
+        shallowReadonly(instance.props),
+        setupContext
+      ]
+    );
+    resetTracking();
+    reset();
+    if (isPromise$1(setupResult)) {
+      setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
+      {
+        warn$1(
+          `setup() returned a Promise, but the version of Vue you are using does not support it yet.`
+        );
+      }
+    } else {
+      handleSetupResult(instance, setupResult, isSSR);
+    }
+  } else {
+    finishComponentSetup(instance, isSSR);
+  }
+}
+function handleSetupResult(instance, setupResult, isSSR) {
+  if (isFunction$1(setupResult)) {
+    {
+      instance.render = setupResult;
+    }
+  } else if (isObject(setupResult)) {
+    if (isVNode(setupResult)) {
+      warn$1(
+        `setup() should not return VNodes directly - return a render function instead.`
+      );
+    }
+    {
+      instance.devtoolsRawSetupState = setupResult;
+    }
+    instance.setupState = proxyRefs(setupResult);
+    {
+      exposeSetupStateOnRenderContext(instance);
+    }
+  } else if (setupResult !== void 0) {
+    warn$1(
+      `setup() should return an object. Received: ${setupResult === null ? "null" : typeof setupResult}`
+    );
+  }
+  finishComponentSetup(instance, isSSR);
+}
+const isRuntimeOnly = () => true;
+function finishComponentSetup(instance, isSSR, skipOptions) {
+  const Component2 = instance.type;
+  if (!instance.render) {
+    instance.render = Component2.render || NOOP;
+  }
+  {
+    const reset = setCurrentInstance(instance);
+    pauseTracking();
+    try {
+      applyOptions$1(instance);
+    } finally {
+      resetTracking();
+      reset();
+    }
+  }
+  if (!Component2.render && instance.render === NOOP && !isSSR) {
+    if (Component2.template) {
+      warn$1(
+        `Component provided template option but runtime compilation is not supported in this build of Vue. Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".`
+      );
+    } else {
+      warn$1(`Component is missing template or render function.`);
+    }
+  }
+}
+function getAttrsProxy(instance) {
+  return instance.attrsProxy || (instance.attrsProxy = new Proxy(
+    instance.attrs,
+    {
+      get(target, key) {
+        track(instance, "get", "$attrs");
+        return target[key];
+      },
+      set() {
+        warn$1(`setupContext.attrs is readonly.`);
+        return false;
+      },
+      deleteProperty() {
+        warn$1(`setupContext.attrs is readonly.`);
+        return false;
+      }
+    }
+  ));
+}
+function getSlotsProxy(instance) {
+  return instance.slotsProxy || (instance.slotsProxy = new Proxy(instance.slots, {
+    get(target, key) {
+      track(instance, "get", "$slots");
+      return target[key];
+    }
+  }));
+}
+function createSetupContext(instance) {
+  const expose = (exposed) => {
+    {
+      if (instance.exposed) {
+        warn$1(`expose() should be called only once per setup().`);
+      }
+      if (exposed != null) {
+        let exposedType = typeof exposed;
+        if (exposedType === "object") {
+          if (isArray$1(exposed)) {
+            exposedType = "array";
+          } else if (isRef(exposed)) {
+            exposedType = "ref";
+          }
+        }
+        if (exposedType !== "object") {
+          warn$1(
+            `expose() should be passed a plain object, received ${exposedType}.`
+          );
+        }
+      }
+    }
+    instance.exposed = exposed || {};
+  };
+  {
+    return Object.freeze({
+      get attrs() {
+        return getAttrsProxy(instance);
+      },
+      get slots() {
+        return getSlotsProxy(instance);
+      },
+      get emit() {
+        return (event, ...args) => instance.emit(event, ...args);
+      },
+      expose
+    });
+  }
+}
+function getExposeProxy(instance) {
+  if (instance.exposed) {
+    return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
+      get(target, key) {
+        if (key in target) {
+          return target[key];
+        }
+        return instance.proxy[key];
+      },
+      has(target, key) {
+        return key in target || key in publicPropertiesMap;
+      }
+    }));
+  }
+}
+const classifyRE = /(?:^|[-_])(\w)/g;
+const classify = (str) => str.replace(classifyRE, (c2) => c2.toUpperCase()).replace(/[-_]/g, "");
+function getComponentName(Component2, includeInferred = true) {
+  return isFunction$1(Component2) ? Component2.displayName || Component2.name : Component2.name || includeInferred && Component2.__name;
+}
+function formatComponentName(instance, Component2, isRoot = false) {
+  let name = getComponentName(Component2);
+  if (!name && Component2.__file) {
+    const match = Component2.__file.match(/([^/\\]+)\.\w+$/);
+    if (match) {
+      name = match[1];
+    }
+  }
+  if (!name && instance && instance.parent) {
+    const inferFromRegistry = (registry) => {
+      for (const key in registry) {
+        if (registry[key] === Component2) {
+          return key;
+        }
+      }
+    };
+    name = inferFromRegistry(
+      instance.components || instance.parent.type.components
+    ) || inferFromRegistry(instance.appContext.components);
+  }
+  return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+const computed = (getterOrOptions, debugOptions) => {
+  const c2 = computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
+  {
+    const i = getCurrentInstance();
+    if (i && i.appContext.config.warnRecursiveComputed) {
+      c2._warnRecursive = true;
+    }
+  }
+  return c2;
+};
+const version = "3.4.21";
+const warn = warn$1;
+function unwrapper(target) {
+  return unref(target);
+}
+const ARRAYTYPE = "[object Array]";
+const OBJECTTYPE = "[object Object]";
+function diff(current, pre) {
+  const result = {};
+  syncKeys(current, pre);
+  _diff(current, pre, "", result);
+  return result;
+}
+function syncKeys(current, pre) {
+  current = unwrapper(current);
+  if (current === pre)
+    return;
+  const rootCurrentType = toTypeString(current);
+  const rootPreType = toTypeString(pre);
+  if (rootCurrentType == OBJECTTYPE && rootPreType == OBJECTTYPE) {
+    for (let key in pre) {
+      const currentValue = current[key];
+      if (currentValue === void 0) {
+        current[key] = null;
+      } else {
+        syncKeys(currentValue, pre[key]);
+      }
+    }
+  } else if (rootCurrentType == ARRAYTYPE && rootPreType == ARRAYTYPE) {
+    if (current.length >= pre.length) {
+      pre.forEach((item, index2) => {
+        syncKeys(current[index2], item);
+      });
+    }
+  }
+}
+function _diff(current, pre, path, result) {
+  current = unwrapper(current);
+  if (current === pre)
+    return;
+  const rootCurrentType = toTypeString(current);
+  const rootPreType = toTypeString(pre);
+  if (rootCurrentType == OBJECTTYPE) {
+    if (rootPreType != OBJECTTYPE || Object.keys(current).length < Object.keys(pre).length) {
+      setResult(result, path, current);
+    } else {
+      for (let key in current) {
+        const currentValue = unwrapper(current[key]);
+        const preValue = pre[key];
+        const currentType = toTypeString(currentValue);
+        const preType = toTypeString(preValue);
+        if (currentType != ARRAYTYPE && currentType != OBJECTTYPE) {
+          if (currentValue != preValue) {
+            setResult(
+              result,
+              (path == "" ? "" : path + ".") + key,
+              currentValue
+            );
+          }
+        } else if (currentType == ARRAYTYPE) {
+          if (preType != ARRAYTYPE) {
+            setResult(
+              result,
+              (path == "" ? "" : path + ".") + key,
+              currentValue
+            );
+          } else {
+            if (currentValue.length < preValue.length) {
+              setResult(
+                result,
+                (path == "" ? "" : path + ".") + key,
+                currentValue
+              );
+            } else {
+              currentValue.forEach((item, index2) => {
+                _diff(
+                  item,
+                  preValue[index2],
+                  (path == "" ? "" : path + ".") + key + "[" + index2 + "]",
+                  result
+                );
+              });
+            }
+          }
+        } else if (currentType == OBJECTTYPE) {
+          if (preType != OBJECTTYPE || Object.keys(currentValue).length < Object.keys(preValue).length) {
+            setResult(
+              result,
+              (path == "" ? "" : path + ".") + key,
+              currentValue
+            );
+          } else {
+            for (let subKey in currentValue) {
+              _diff(
+                currentValue[subKey],
+                preValue[subKey],
+                (path == "" ? "" : path + ".") + key + "." + subKey,
+                result
+              );
+            }
+          }
+        }
+      }
+    }
+  } else if (rootCurrentType == ARRAYTYPE) {
+    if (rootPreType != ARRAYTYPE) {
+      setResult(result, path, current);
+    } else {
+      if (current.length < pre.length) {
+        setResult(result, path, current);
+      } else {
+        current.forEach((item, index2) => {
+          _diff(item, pre[index2], path + "[" + index2 + "]", result);
+        });
+      }
+    }
+  } else {
+    setResult(result, path, current);
+  }
+}
+function setResult(result, k, v) {
+  result[k] = v;
+}
+function hasComponentEffect(instance) {
+  return queue.includes(instance.update);
+}
+function flushCallbacks(instance) {
+  const ctx = instance.ctx;
+  const callbacks = ctx.__next_tick_callbacks;
+  if (callbacks && callbacks.length) {
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+      copies[i]();
+    }
+  }
+}
+function nextTick(instance, fn) {
+  const ctx = instance.ctx;
+  if (!ctx.__next_tick_pending && !hasComponentEffect(instance)) {
+    return nextTick$1(fn && fn.bind(instance.proxy));
+  }
+  let _resolve;
+  if (!ctx.__next_tick_callbacks) {
+    ctx.__next_tick_callbacks = [];
+  }
+  ctx.__next_tick_callbacks.push(() => {
+    if (fn) {
+      callWithErrorHandling(
+        fn.bind(instance.proxy),
+        instance,
+        14
+      );
+    } else if (_resolve) {
+      _resolve(instance.proxy);
+    }
+  });
+  return new Promise((resolve2) => {
+    _resolve = resolve2;
+  });
+}
+function clone(src, seen) {
+  src = unwrapper(src);
+  const type = typeof src;
+  if (type === "object" && src !== null) {
+    let copy = seen.get(src);
+    if (typeof copy !== "undefined") {
+      return copy;
+    }
+    if (isArray$1(src)) {
+      const len = src.length;
+      copy = new Array(len);
+      seen.set(src, copy);
+      for (let i = 0; i < len; i++) {
+        copy[i] = clone(src[i], seen);
+      }
+    } else {
+      copy = {};
+      seen.set(src, copy);
+      for (const name in src) {
+        if (hasOwn(src, name)) {
+          copy[name] = clone(src[name], seen);
+        }
+      }
+    }
+    return copy;
+  }
+  if (type !== "symbol") {
+    return src;
+  }
+}
+function deepCopy(src) {
+  return clone(src, typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : /* @__PURE__ */ new Map());
+}
+function getMPInstanceData(instance, keys) {
+  const data = instance.data;
+  const ret = /* @__PURE__ */ Object.create(null);
+  keys.forEach((key) => {
+    ret[key] = data[key];
+  });
+  return ret;
+}
+function patch(instance, data, oldData) {
+  if (!data) {
+    return;
+  }
+  data = deepCopy(data);
+  data.$eS = instance.$eS || {};
+  const ctx = instance.ctx;
+  const mpType = ctx.mpType;
+  if (mpType === "page" || mpType === "component") {
+    data.r0 = 1;
+    const mpInstance = ctx.$scope;
+    const keys = Object.keys(data);
+    const diffData = diff(data, getMPInstanceData(mpInstance, keys));
+    if (Object.keys(diffData).length) {
+      ctx.__next_tick_pending = true;
+      mpInstance.setData(diffData, () => {
+        ctx.__next_tick_pending = false;
+        flushCallbacks(instance);
+      });
+      flushPreFlushCbs();
+    } else {
+      flushCallbacks(instance);
+    }
+  }
+}
+function initAppConfig(appConfig) {
+  appConfig.globalProperties.$nextTick = function $nextTick(fn) {
+    return nextTick(this.$, fn);
+  };
+}
+function onApplyOptions(options, instance, publicThis) {
+  instance.appContext.config.globalProperties.$applyOptions(
+    options,
+    instance,
+    publicThis
+  );
+  const computedOptions = options.computed;
+  if (computedOptions) {
+    const keys = Object.keys(computedOptions);
+    if (keys.length) {
+      const ctx = instance.ctx;
+      if (!ctx.$computedKeys) {
+        ctx.$computedKeys = [];
+      }
+      ctx.$computedKeys.push(...keys);
+    }
+  }
+  delete instance.ctx.$onApplyOptions;
+}
+function setRef$1(instance, isUnmount = false) {
+  const {
+    setupState,
+    $templateRefs,
+    $templateUniElementRefs,
+    ctx: { $scope, $mpPlatform }
+  } = instance;
+  if ($mpPlatform === "mp-alipay") {
+    return;
+  }
+  if (!$scope || !$templateRefs && !$templateUniElementRefs) {
+    return;
+  }
+  if (isUnmount) {
+    $templateRefs && $templateRefs.forEach(
+      (templateRef) => setTemplateRef(templateRef, null, setupState)
+    );
+    $templateUniElementRefs && $templateUniElementRefs.forEach(
+      (templateRef) => setTemplateRef(templateRef, null, setupState)
+    );
+    return;
+  }
+  const check = $mpPlatform === "mp-baidu" || $mpPlatform === "mp-toutiao";
+  const doSetByRefs = (refs) => {
+    if (refs.length === 0) {
+      return [];
+    }
+    const mpComponents = (
+      // 字节小程序 selectAllComponents 可能返回 null
+      // https://github.com/dcloudio/uni-app/issues/3954
+      ($scope.selectAllComponents(".r") || []).concat(
+        $scope.selectAllComponents(".r-i-f") || []
+      )
+    );
+    return refs.filter((templateRef) => {
+      const refValue = findComponentPublicInstance(mpComponents, templateRef.i);
+      if (check && refValue === null) {
+        return true;
+      }
+      setTemplateRef(templateRef, refValue, setupState);
+      return false;
+    });
+  };
+  const doSet = () => {
+    if ($templateRefs) {
+      const refs = doSetByRefs($templateRefs);
+      if (refs.length && instance.proxy && instance.proxy.$scope) {
+        instance.proxy.$scope.setData({ r1: 1 }, () => {
+          doSetByRefs(refs);
+        });
+      }
+    }
+  };
+  if ($templateUniElementRefs && $templateUniElementRefs.length) {
+    nextTick(instance, () => {
+      $templateUniElementRefs.forEach((templateRef) => {
+        if (isArray$1(templateRef.v)) {
+          templateRef.v.forEach((v) => {
+            setTemplateRef(templateRef, v, setupState);
+          });
+        } else {
+          setTemplateRef(templateRef, templateRef.v, setupState);
+        }
+      });
+    });
+  }
+  if ($scope._$setRef) {
+    $scope._$setRef(doSet);
+  } else {
+    nextTick(instance, doSet);
+  }
+}
+function toSkip(value) {
+  if (isObject(value)) {
+    markRaw(value);
+  }
+  return value;
+}
+function findComponentPublicInstance(mpComponents, id) {
+  const mpInstance = mpComponents.find(
+    (com) => com && (com.properties || com.props).uI === id
+  );
+  if (mpInstance) {
+    const vm = mpInstance.$vm;
+    if (vm) {
+      return getExposeProxy(vm.$) || vm;
+    }
+    return toSkip(mpInstance);
+  }
+  return null;
+}
+function setTemplateRef({ r: r2, f: f2 }, refValue, setupState) {
+  if (isFunction$1(r2)) {
+    r2(refValue, {});
+  } else {
+    const _isString = isString$1(r2);
+    const _isRef = isRef(r2);
+    if (_isString || _isRef) {
+      if (f2) {
+        if (!_isRef) {
+          return;
+        }
+        if (!isArray$1(r2.value)) {
+          r2.value = [];
+        }
+        const existing = r2.value;
+        if (existing.indexOf(refValue) === -1) {
+          existing.push(refValue);
+          if (!refValue) {
+            return;
+          }
+          if (refValue.$) {
+            onBeforeUnmount(() => remove(existing, refValue), refValue.$);
+          }
+        }
+      } else if (_isString) {
+        if (hasOwn(setupState, r2)) {
+          setupState[r2] = refValue;
+        }
+      } else if (isRef(r2)) {
+        r2.value = refValue;
+      } else {
+        warnRef(r2);
+      }
+    } else {
+      warnRef(r2);
+    }
+  }
+}
+function warnRef(ref2) {
+  warn("Invalid template ref type:", ref2, `(${typeof ref2})`);
+}
+const queuePostRenderEffect = queuePostFlushCb;
+function mountComponent(initialVNode, options) {
+  const instance = initialVNode.component = createComponentInstance(initialVNode, options.parentComponent, null);
+  {
+    instance.ctx.$onApplyOptions = onApplyOptions;
+    instance.ctx.$children = [];
+  }
+  if (options.mpType === "app") {
+    instance.render = NOOP;
+  }
+  if (options.onBeforeSetup) {
+    options.onBeforeSetup(instance, options);
+  }
+  {
+    pushWarningContext(initialVNode);
+    startMeasure(instance, `mount`);
+  }
+  {
+    startMeasure(instance, `init`);
+  }
+  setupComponent(instance);
+  {
+    endMeasure(instance, `init`);
+  }
+  {
+    if (options.parentComponent && instance.proxy) {
+      options.parentComponent.ctx.$children.push(getExposeProxy(instance) || instance.proxy);
+    }
+  }
+  setupRenderEffect(instance);
+  {
+    popWarningContext();
+    endMeasure(instance, `mount`);
+  }
+  return instance.proxy;
+}
+const getFunctionalFallthrough = (attrs) => {
+  let res;
+  for (const key in attrs) {
+    if (key === "class" || key === "style" || isOn(key)) {
+      (res || (res = {}))[key] = attrs[key];
+    }
+  }
+  return res;
+};
+function renderComponentRoot(instance) {
+  const {
+    type: Component2,
+    vnode,
+    proxy,
+    withProxy,
+    props,
+    propsOptions: [propsOptions],
+    slots,
+    attrs,
+    emit: emit2,
+    render,
+    renderCache,
+    data,
+    setupState,
+    ctx,
+    uid: uid2,
+    appContext: {
+      app: {
+        config: {
+          globalProperties: { pruneComponentPropsCache: pruneComponentPropsCache2 }
+        }
+      }
+    },
+    inheritAttrs
+  } = instance;
+  instance.$uniElementIds = /* @__PURE__ */ new Map();
+  instance.$templateRefs = [];
+  instance.$templateUniElementRefs = [];
+  instance.$templateUniElementStyles = {};
+  instance.$ei = 0;
+  pruneComponentPropsCache2(uid2);
+  instance.__counter = instance.__counter === 0 ? 1 : 0;
+  let result;
+  const prev = setCurrentRenderingInstance(instance);
+  try {
+    if (vnode.shapeFlag & 4) {
+      fallthroughAttrs(inheritAttrs, props, propsOptions, attrs);
+      const proxyToUse = withProxy || proxy;
+      result = render.call(
+        proxyToUse,
+        proxyToUse,
+        renderCache,
+        props,
+        setupState,
+        data,
+        ctx
+      );
+    } else {
+      fallthroughAttrs(
+        inheritAttrs,
+        props,
+        propsOptions,
+        Component2.props ? attrs : getFunctionalFallthrough(attrs)
+      );
+      const render2 = Component2;
+      result = render2.length > 1 ? render2(props, { attrs, slots, emit: emit2 }) : render2(
+        props,
+        null
+        /* we know it doesn't need it */
+      );
+    }
+  } catch (err) {
+    handleError(err, instance, 1);
+    result = false;
+  }
+  setRef$1(instance);
+  setCurrentRenderingInstance(prev);
+  return result;
+}
+function fallthroughAttrs(inheritAttrs, props, propsOptions, fallthroughAttrs2) {
+  if (props && fallthroughAttrs2 && inheritAttrs !== false) {
+    const keys = Object.keys(fallthroughAttrs2).filter(
+      (key) => key !== "class" && key !== "style"
+    );
+    if (!keys.length) {
+      return;
+    }
+    if (propsOptions && keys.some(isModelListener)) {
+      keys.forEach((key) => {
+        if (!isModelListener(key) || !(key.slice(9) in propsOptions)) {
+          props[key] = fallthroughAttrs2[key];
+        }
+      });
+    } else {
+      keys.forEach((key) => props[key] = fallthroughAttrs2[key]);
+    }
+  }
+}
+const updateComponentPreRender = (instance) => {
+  pauseTracking();
+  flushPreFlushCbs();
+  resetTracking();
+};
+function componentUpdateScopedSlotsFn() {
+  const scopedSlotsData = this.$scopedSlotsData;
+  if (!scopedSlotsData || scopedSlotsData.length === 0) {
+    return;
+  }
+  const mpInstance = this.ctx.$scope;
+  const oldData = mpInstance.data;
+  const diffData = /* @__PURE__ */ Object.create(null);
+  scopedSlotsData.forEach(({ path, index: index2, data }) => {
+    const oldScopedSlotData = getValueByDataPath(oldData, path);
+    const diffPath = isString$1(index2) ? `${path}.${index2}` : `${path}[${index2}]`;
+    if (typeof oldScopedSlotData === "undefined" || typeof oldScopedSlotData[index2] === "undefined") {
+      diffData[diffPath] = data;
+    } else {
+      const diffScopedSlotData = diff(
+        data,
+        oldScopedSlotData[index2]
+      );
+      Object.keys(diffScopedSlotData).forEach((name) => {
+        diffData[diffPath + "." + name] = diffScopedSlotData[name];
+      });
+    }
+  });
+  scopedSlotsData.length = 0;
+  if (Object.keys(diffData).length) {
+    mpInstance.setData(diffData);
+  }
+}
+function toggleRecurse({ effect: effect2, update }, allowed) {
+  effect2.allowRecurse = update.allowRecurse = allowed;
+}
+function setupRenderEffect(instance) {
+  const updateScopedSlots = componentUpdateScopedSlotsFn.bind(
+    instance
+  );
+  instance.$updateScopedSlots = () => nextTick$1(() => queueJob(updateScopedSlots));
+  const componentUpdateFn = () => {
+    if (!instance.isMounted) {
+      onBeforeUnmount(() => {
+        setRef$1(instance, true);
+      }, instance);
+      {
+        startMeasure(instance, `patch`);
+      }
+      patch(instance, renderComponentRoot(instance));
+      {
+        endMeasure(instance, `patch`);
+      }
+      {
+        devtoolsComponentAdded(instance);
+      }
+    } else {
+      const { next, bu, u } = instance;
+      {
+        pushWarningContext(next || instance.vnode);
+      }
+      toggleRecurse(instance, false);
+      updateComponentPreRender();
+      if (bu) {
+        invokeArrayFns$1(bu);
+      }
+      toggleRecurse(instance, true);
+      {
+        startMeasure(instance, `patch`);
+      }
+      patch(instance, renderComponentRoot(instance));
+      {
+        endMeasure(instance, `patch`);
+      }
+      if (u) {
+        queuePostRenderEffect(u);
+      }
+      {
+        devtoolsComponentUpdated(instance);
+      }
+      {
+        popWarningContext();
+      }
+    }
+  };
+  const effect2 = instance.effect = new ReactiveEffect2(
+    componentUpdateFn,
+    NOOP,
+    () => queueJob(update),
+    instance.scope
+    // track it in component's effect scope
+  );
+  const update = instance.update = () => {
+    if (effect2.dirty) {
+      effect2.run();
+    }
+  };
+  update.id = instance.uid;
+  toggleRecurse(instance, true);
+  {
+    effect2.onTrack = instance.rtc ? (e2) => invokeArrayFns$1(instance.rtc, e2) : void 0;
+    effect2.onTrigger = instance.rtg ? (e2) => invokeArrayFns$1(instance.rtg, e2) : void 0;
+    update.ownerInstance = instance;
+  }
+  {
+    update();
+  }
+}
+function unmountComponent(instance) {
+  const { bum, scope, update, um } = instance;
+  if (bum) {
+    invokeArrayFns$1(bum);
+  }
+  {
+    const parentInstance = instance.parent;
+    if (parentInstance) {
+      const $children = parentInstance.ctx.$children;
+      const target = getExposeProxy(instance) || instance.proxy;
+      const index2 = $children.indexOf(target);
+      if (index2 > -1) {
+        $children.splice(index2, 1);
+      }
+    }
+  }
+  scope.stop();
+  if (update) {
+    update.active = false;
+  }
+  if (um) {
+    queuePostRenderEffect(um);
+  }
+  queuePostRenderEffect(() => {
+    instance.isUnmounted = true;
+  });
+  {
+    devtoolsComponentRemoved(instance);
+  }
+}
+const oldCreateApp = createAppAPI();
+function getTarget() {
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  if (typeof my !== "undefined") {
+    return my;
+  }
+}
+function createVueApp(rootComponent, rootProps = null) {
+  const target = getTarget();
+  target.__VUE__ = true;
+  {
+    setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target);
+  }
+  const app = oldCreateApp(rootComponent, rootProps);
+  const appContext = app._context;
+  initAppConfig(appContext.config);
+  const createVNode2 = (initialVNode) => {
+    initialVNode.appContext = appContext;
+    initialVNode.shapeFlag = 6;
+    return initialVNode;
+  };
+  const createComponent2 = function createComponent22(initialVNode, options) {
+    return mountComponent(createVNode2(initialVNode), options);
+  };
+  const destroyComponent = function destroyComponent2(component) {
+    return component && unmountComponent(component.$);
+  };
+  app.mount = function mount() {
+    rootComponent.render = NOOP;
+    const instance = mountComponent(
+      createVNode2({ type: rootComponent }),
+      {
+        mpType: "app",
+        mpInstance: null,
+        parentComponent: null,
+        slots: [],
+        props: null
+      }
+    );
+    app._instance = instance.$;
+    {
+      devtoolsInitApp(app, version);
+    }
+    instance.$app = app;
+    instance.$createComponent = createComponent2;
+    instance.$destroyComponent = destroyComponent;
+    appContext.$appInstance = instance;
+    return instance;
+  };
+  app.unmount = function unmount() {
+    warn(`Cannot unmount an app.`);
+  };
+  return app;
+}
+function injectLifecycleHook(name, hook, publicThis, instance) {
+  if (isFunction$1(hook)) {
+    injectHook(name, hook.bind(publicThis), instance);
+  }
+}
+function initHooks$1(options, instance, publicThis) {
+  const mpType = options.mpType || publicThis.$mpType;
+  if (!mpType || mpType === "component") {
+    return;
+  }
+  Object.keys(options).forEach((name) => {
+    if (isUniLifecycleHook(name, options[name], false)) {
+      const hooks = options[name];
+      if (isArray$1(hooks)) {
+        hooks.forEach((hook) => injectLifecycleHook(name, hook, publicThis, instance));
+      } else {
+        injectLifecycleHook(name, hooks, publicThis, instance);
+      }
+    }
+  });
+}
+function applyOptions$2(options, instance, publicThis) {
+  initHooks$1(options, instance, publicThis);
+}
+function set(target, key, val) {
+  return target[key] = val;
+}
+function $callMethod(method, ...args) {
+  const fn = this[method];
+  if (fn) {
+    return fn(...args);
+  }
+  console.error(`method ${method} not found`);
+  return null;
+}
+function createErrorHandler(app) {
+  return function errorHandler(err, instance, _info) {
+    if (!instance) {
+      throw err;
+    }
+    const appInstance = app._instance;
+    if (!appInstance || !appInstance.proxy) {
+      throw err;
+    }
+    {
+      appInstance.proxy.$callHook(ON_ERROR, err);
+    }
+  };
+}
+function mergeAsArray(to, from) {
+  return to ? [...new Set([].concat(to, from))] : from;
+}
+function initOptionMergeStrategies(optionMergeStrategies) {
+  UniLifecycleHooks.forEach((name) => {
+    optionMergeStrategies[name] = mergeAsArray;
+  });
+}
+let realAtob;
+const b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+const b64re = /^(?:[A-Za-z\d+/]{4})*?(?:[A-Za-z\d+/]{2}(?:==)?|[A-Za-z\d+/]{3}=?)?$/;
+if (typeof atob !== "function") {
+  realAtob = function(str) {
+    str = String(str).replace(/[\t\n\f\r ]+/g, "");
+    if (!b64re.test(str)) {
+      throw new Error("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");
+    }
+    str += "==".slice(2 - (str.length & 3));
+    var bitmap;
+    var result = "";
+    var r1;
+    var r2;
+    var i = 0;
+    for (; i < str.length; ) {
+      bitmap = b64.indexOf(str.charAt(i++)) << 18 | b64.indexOf(str.charAt(i++)) << 12 | (r1 = b64.indexOf(str.charAt(i++))) << 6 | (r2 = b64.indexOf(str.charAt(i++)));
+      result += r1 === 64 ? String.fromCharCode(bitmap >> 16 & 255) : r2 === 64 ? String.fromCharCode(bitmap >> 16 & 255, bitmap >> 8 & 255) : String.fromCharCode(bitmap >> 16 & 255, bitmap >> 8 & 255, bitmap & 255);
+    }
+    return result;
+  };
+} else {
+  realAtob = atob;
+}
+function b64DecodeUnicode(str) {
+  return decodeURIComponent(realAtob(str).split("").map(function(c2) {
+    return "%" + ("00" + c2.charCodeAt(0).toString(16)).slice(-2);
+  }).join(""));
+}
+function getCurrentUserInfo() {
+  const token = index.getStorageSync("uni_id_token") || "";
+  const tokenArr = token.split(".");
+  if (!token || tokenArr.length !== 3) {
+    return {
+      uid: null,
+      role: [],
+      permission: [],
+      tokenExpired: 0
+    };
+  }
+  let userInfo;
+  try {
+    userInfo = JSON.parse(b64DecodeUnicode(tokenArr[1]));
+  } catch (error) {
+    throw new Error("获取当前用户信息出错，详细错误信息为：" + error.message);
+  }
+  userInfo.tokenExpired = userInfo.exp * 1e3;
+  delete userInfo.exp;
+  delete userInfo.iat;
+  return userInfo;
+}
+function uniIdMixin(globalProperties) {
+  globalProperties.uniIDHasRole = function(roleId) {
+    const { role } = getCurrentUserInfo();
+    return role.indexOf(roleId) > -1;
+  };
+  globalProperties.uniIDHasPermission = function(permissionId) {
+    const { permission } = getCurrentUserInfo();
+    return this.uniIDHasRole("admin") || permission.indexOf(permissionId) > -1;
+  };
+  globalProperties.uniIDTokenValid = function() {
+    const { tokenExpired } = getCurrentUserInfo();
+    return tokenExpired > Date.now();
+  };
+}
+function initApp(app) {
+  const appConfig = app._context.config;
+  appConfig.errorHandler = invokeCreateErrorHandler(app, createErrorHandler);
+  initOptionMergeStrategies(appConfig.optionMergeStrategies);
+  const globalProperties = appConfig.globalProperties;
+  {
+    uniIdMixin(globalProperties);
+  }
+  {
+    globalProperties.$set = set;
+    globalProperties.$applyOptions = applyOptions$2;
+    globalProperties.$callMethod = $callMethod;
+  }
+  {
+    index.invokeCreateVueAppHook(app);
+  }
+}
+const propsCaches = /* @__PURE__ */ Object.create(null);
+function renderProps(props) {
+  const { uid: uid2, __counter } = getCurrentInstance();
+  const propsId = (propsCaches[uid2] || (propsCaches[uid2] = [])).push(guardReactiveProps(props)) - 1;
+  return uid2 + "," + propsId + "," + __counter;
+}
+function pruneComponentPropsCache(uid2) {
+  delete propsCaches[uid2];
+}
+function findComponentPropsData(up) {
+  if (!up) {
+    return;
+  }
+  const [uid2, propsId] = up.split(",");
+  if (!propsCaches[uid2]) {
+    return;
+  }
+  return propsCaches[uid2][parseInt(propsId)];
+}
+var plugin = {
+  install(app) {
+    initApp(app);
+    app.config.globalProperties.pruneComponentPropsCache = pruneComponentPropsCache;
+    const oldMount = app.mount;
+    app.mount = function mount(rootContainer) {
+      const instance = oldMount.call(app, rootContainer);
+      const createApp2 = getCreateApp();
+      if (createApp2) {
+        createApp2(instance);
+      } else {
+        if (typeof createMiniProgramApp !== "undefined") {
+          createMiniProgramApp(instance);
+        }
+      }
+      return instance;
+    };
+  }
+};
+function getCreateApp() {
+  const method = "createApp";
+  if (typeof global !== "undefined" && typeof global[method] !== "undefined") {
+    return global[method];
+  } else if (typeof my !== "undefined") {
+    return my[method];
+  }
+}
+function vOn(value, key) {
+  const instance = getCurrentInstance();
+  const ctx = instance.ctx;
+  const extraKey = typeof key !== "undefined" && (ctx.$mpPlatform === "mp-weixin" || ctx.$mpPlatform === "mp-qq" || ctx.$mpPlatform === "mp-xhs") && (isString$1(key) || typeof key === "number") ? "_" + key : "";
+  const name = "e" + instance.$ei++ + extraKey;
+  const mpInstance = ctx.$scope;
+  if (!value) {
+    delete mpInstance[name];
+    return name;
+  }
+  const existingInvoker = mpInstance[name];
+  if (existingInvoker) {
+    existingInvoker.value = value;
+  } else {
+    mpInstance[name] = createInvoker(value, instance);
+  }
+  return name;
+}
+function createInvoker(initialValue, instance) {
+  const invoker = (e2) => {
+    patchMPEvent(e2);
+    let args = [e2];
+    if (instance && instance.ctx.$getTriggerEventDetail) {
+      if (typeof e2.detail === "number") {
+        e2.detail = instance.ctx.$getTriggerEventDetail(e2.detail);
+      }
+    }
+    if (e2.detail && e2.detail.__args__) {
+      args = e2.detail.__args__;
+    }
+    const eventValue = invoker.value;
+    const invoke = () => callWithAsyncErrorHandling(patchStopImmediatePropagation(e2, eventValue), instance, 5, args);
+    const eventTarget = e2.target;
+    const eventSync = eventTarget ? eventTarget.dataset ? String(eventTarget.dataset.eventsync) === "true" : false : false;
+    if (bubbles.includes(e2.type) && !eventSync) {
+      setTimeout(invoke);
+    } else {
+      const res = invoke();
+      if (e2.type === "input" && (isArray$1(res) || isPromise$1(res))) {
+        return;
+      }
+      return res;
+    }
+  };
+  invoker.value = initialValue;
+  return invoker;
+}
+const bubbles = [
+  // touch事件暂不做延迟，否则在 Android 上会影响性能，比如一些拖拽跟手手势等
+  // 'touchstart',
+  // 'touchmove',
+  // 'touchcancel',
+  // 'touchend',
+  "tap",
+  "longpress",
+  "longtap",
+  "transitionend",
+  "animationstart",
+  "animationiteration",
+  "animationend",
+  "touchforcechange"
+];
+function patchMPEvent(event) {
+  if (event.type && event.target) {
+    event.preventDefault = NOOP;
+    event.stopPropagation = NOOP;
+    event.stopImmediatePropagation = NOOP;
+    if (!hasOwn(event, "detail")) {
+      event.detail = {};
+    }
+    if (hasOwn(event, "markerId")) {
+      event.detail = typeof event.detail === "object" ? event.detail : {};
+      event.detail.markerId = event.markerId;
+    }
+    if (isPlainObject(event.detail) && hasOwn(event.detail, "checked") && !hasOwn(event.detail, "value")) {
+      event.detail.value = event.detail.checked;
+    }
+    if (isPlainObject(event.detail)) {
+      event.target = extend({}, event.target, event.detail);
+    }
+  }
+}
+function patchStopImmediatePropagation(e2, value) {
+  if (isArray$1(value)) {
+    const originalStop = e2.stopImmediatePropagation;
+    e2.stopImmediatePropagation = () => {
+      originalStop && originalStop.call(e2);
+      e2._stopped = true;
+    };
+    return value.map((fn) => (e3) => !e3._stopped && fn(e3));
+  } else {
+    return value;
+  }
+}
+function vFor(source, renderItem) {
+  let ret;
+  if (isArray$1(source) || isString$1(source)) {
+    ret = new Array(source.length);
+    for (let i = 0, l = source.length; i < l; i++) {
+      ret[i] = renderItem(source[i], i, i);
+    }
+  } else if (typeof source === "number") {
+    if (!Number.isInteger(source)) {
+      warn(`The v-for range expect an integer value but got ${source}.`);
+      return [];
+    }
+    ret = new Array(source);
+    for (let i = 0; i < source; i++) {
+      ret[i] = renderItem(i + 1, i, i);
+    }
+  } else if (isObject(source)) {
+    if (source[Symbol.iterator]) {
+      ret = Array.from(source, (item, i) => renderItem(item, i, i));
+    } else {
+      const keys = Object.keys(source);
+      ret = new Array(keys.length);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        ret[i] = renderItem(source[key], key, i);
+      }
+    }
+  } else {
+    ret = [];
+  }
+  return ret;
+}
+function renderSlot(name, props = {}, key) {
+  const instance = getCurrentInstance();
+  const { parent, isMounted, ctx: { $scope } } = instance;
+  const vueIds = ($scope.properties || $scope.props).uI;
+  if (!vueIds) {
+    return;
+  }
+  if (!parent && !isMounted) {
+    onMounted(() => {
+      renderSlot(name, props, key);
+    }, instance);
+    return;
+  }
+  const invoker = findScopedSlotInvoker(vueIds, instance);
+  if (invoker) {
+    invoker(name, props, key);
+  }
+}
+function findScopedSlotInvoker(vueId, instance) {
+  let parent = instance.parent;
+  while (parent) {
+    const invokers = parent.$ssi;
+    if (invokers && invokers[vueId]) {
+      return invokers[vueId];
+    }
+    parent = parent.parent;
+  }
+}
+function stringifyStyle(value) {
+  if (isString$1(value)) {
+    return value;
+  }
+  return stringify(normalizeStyle(value));
+}
+function stringify(styles) {
+  let ret = "";
+  if (!styles || isString$1(styles)) {
+    return ret;
+  }
+  for (const key in styles) {
+    ret += `${key.startsWith(`--`) ? key : hyphenate(key)}:${styles[key]};`;
+  }
+  return ret;
+}
+function setRef(ref2, id, opts = {}) {
+  const { $templateRefs } = getCurrentInstance();
+  $templateRefs.push({ i: id, r: ref2, k: opts.k, f: opts.f });
+}
+const o = (value, key) => vOn(value, key);
+const f = (source, renderItem) => vFor(source, renderItem);
+const r = (name, props, key) => renderSlot(name, props, key);
+const s = (value) => stringifyStyle(value);
+const e = (target, ...sources) => extend(target, ...sources);
+const n = (value) => normalizeClass(value);
+const t = (val) => toDisplayString(val);
+const p = (props) => renderProps(props);
+const sr = (ref2, id, opts) => setRef(ref2, id, opts);
+function createApp$1(rootComponent, rootProps = null) {
+  rootComponent && (rootComponent.mpType = "app");
+  return createVueApp(rootComponent, rootProps).use(plugin);
+}
+const createSSRApp = createApp$1;
+function initVueIds(vueIds, mpInstance) {
+  if (!vueIds) {
+    return;
+  }
+  const ids = vueIds.split(",");
+  const len = ids.length;
+  if (len === 1) {
+    mpInstance._$vueId = ids[0];
+  } else if (len === 2) {
+    mpInstance._$vueId = ids[0];
+    mpInstance._$vuePid = ids[1];
+  }
+}
+const EXTRAS = ["externalClasses"];
+function initExtraOptions(miniProgramComponentOptions, vueOptions) {
+  EXTRAS.forEach((name) => {
+    if (hasOwn(vueOptions, name)) {
+      miniProgramComponentOptions[name] = vueOptions[name];
+    }
+  });
+}
+const WORKLET_RE = /_(.*)_worklet_factory_/;
+function initWorkletMethods(mpMethods, vueMethods) {
+  if (vueMethods) {
+    Object.keys(vueMethods).forEach((name) => {
+      const matches = name.match(WORKLET_RE);
+      if (matches) {
+        const workletName = matches[1];
+        mpMethods[name] = vueMethods[name];
+        mpMethods[workletName] = vueMethods[workletName];
+      }
+    });
+  }
+}
+function initWxsCallMethods(methods, wxsCallMethods) {
+  if (!isArray$1(wxsCallMethods)) {
+    return;
+  }
+  wxsCallMethods.forEach((callMethod) => {
+    methods[callMethod] = function(args) {
+      return this.$vm[callMethod](args);
+    };
+  });
+}
+function selectAllComponents(mpInstance, selector, $refs) {
+  const components = mpInstance.selectAllComponents(selector);
+  components.forEach((component) => {
+    const ref2 = component.properties.uR;
+    $refs[ref2] = component.$vm || component;
+  });
+}
+function initRefs(instance, mpInstance) {
+  Object.defineProperty(instance, "refs", {
+    get() {
+      const $refs = {};
+      selectAllComponents(mpInstance, ".r", $refs);
+      const forComponents = mpInstance.selectAllComponents(".r-i-f");
+      forComponents.forEach((component) => {
+        const ref2 = component.properties.uR;
+        if (!ref2) {
+          return;
+        }
+        if (!$refs[ref2]) {
+          $refs[ref2] = [];
+        }
+        $refs[ref2].push(component.$vm || component);
+      });
+      return $refs;
+    }
+  });
+}
+function findVmByVueId(instance, vuePid) {
+  const $children = instance.$children;
+  for (let i = $children.length - 1; i >= 0; i--) {
+    const childVm = $children[i];
+    if (childVm.$scope._$vueId === vuePid) {
+      return childVm;
+    }
+  }
+  let parentVm;
+  for (let i = $children.length - 1; i >= 0; i--) {
+    parentVm = findVmByVueId($children[i], vuePid);
+    if (parentVm) {
+      return parentVm;
+    }
+  }
+}
+const MP_METHODS = [
+  "createSelectorQuery",
+  "createIntersectionObserver",
+  "selectAllComponents",
+  "selectComponent"
+];
+function createEmitFn(oldEmit, ctx) {
+  return function emit2(event, ...args) {
+    const scope = ctx.$scope;
+    if (scope && event) {
+      const detail = { __args__: args };
+      {
+        scope.triggerEvent(event, detail);
+      }
+    }
+    return oldEmit.apply(this, [event, ...args]);
+  };
+}
+function initBaseInstance(instance, options) {
+  const ctx = instance.ctx;
+  ctx.mpType = options.mpType;
+  ctx.$mpType = options.mpType;
+  ctx.$mpPlatform = "mp-weixin";
+  ctx.$scope = options.mpInstance;
+  ctx.$mp = {};
+  {
+    ctx._self = {};
+  }
+  instance.slots = {};
+  if (isArray$1(options.slots) && options.slots.length) {
+    options.slots.forEach((name) => {
+      instance.slots[name] = true;
+    });
+    if (instance.slots[SLOT_DEFAULT_NAME]) {
+      instance.slots.default = true;
+    }
+  }
+  ctx.getOpenerEventChannel = function() {
+    {
+      return options.mpInstance.getOpenerEventChannel();
+    }
+  };
+  ctx.$hasHook = hasHook;
+  ctx.$callHook = callHook;
+  instance.emit = createEmitFn(instance.emit, ctx);
+}
+function initComponentInstance(instance, options) {
+  initBaseInstance(instance, options);
+  const ctx = instance.ctx;
+  MP_METHODS.forEach((method) => {
+    ctx[method] = function(...args) {
+      const mpInstance = ctx.$scope;
+      if (mpInstance && mpInstance[method]) {
+        return mpInstance[method].apply(mpInstance, args);
+      }
+    };
+  });
+}
+function initMocks(instance, mpInstance, mocks2) {
+  const ctx = instance.ctx;
+  mocks2.forEach((mock) => {
+    if (hasOwn(mpInstance, mock)) {
+      instance[mock] = ctx[mock] = mpInstance[mock];
+    }
+  });
+}
+function hasHook(name) {
+  const hooks = this.$[name];
+  if (hooks && hooks.length) {
+    return true;
+  }
+  return false;
+}
+function callHook(name, args) {
+  if (name === "mounted") {
+    callHook.call(this, "bm");
+    this.$.isMounted = true;
+    name = "m";
+  }
+  const hooks = this.$[name];
+  return hooks && invokeArrayFns(hooks, args);
+}
+const PAGE_INIT_HOOKS = [
+  ON_LOAD,
+  ON_SHOW,
+  ON_HIDE,
+  ON_UNLOAD,
+  ON_RESIZE,
+  ON_TAB_ITEM_TAP,
+  ON_REACH_BOTTOM,
+  ON_PULL_DOWN_REFRESH,
+  ON_ADD_TO_FAVORITES
+  // 'onReady', // lifetimes.ready
+  // 'onPageScroll', // 影响性能，开发者手动注册
+  // 'onShareTimeline', // 右上角菜单，开发者手动注册
+  // 'onShareAppMessage' // 右上角菜单，开发者手动注册
+];
+function findHooks(vueOptions, hooks = /* @__PURE__ */ new Set()) {
+  if (vueOptions) {
+    Object.keys(vueOptions).forEach((name) => {
+      if (isUniLifecycleHook(name, vueOptions[name])) {
+        hooks.add(name);
+      }
+    });
+    {
+      const { extends: extendsOptions, mixins } = vueOptions;
+      if (mixins) {
+        mixins.forEach((mixin) => findHooks(mixin, hooks));
+      }
+      if (extendsOptions) {
+        findHooks(extendsOptions, hooks);
+      }
+    }
+  }
+  return hooks;
+}
+function initHook(mpOptions, hook, excludes) {
+  if (excludes.indexOf(hook) === -1 && !hasOwn(mpOptions, hook)) {
+    mpOptions[hook] = function(args) {
+      return this.$vm && this.$vm.$callHook(hook, args);
+    };
+  }
+}
+const EXCLUDE_HOOKS = [ON_READY];
+function initHooks(mpOptions, hooks, excludes = EXCLUDE_HOOKS) {
+  hooks.forEach((hook) => initHook(mpOptions, hook, excludes));
+}
+function initUnknownHooks(mpOptions, vueOptions, excludes = EXCLUDE_HOOKS) {
+  findHooks(vueOptions).forEach((hook) => initHook(mpOptions, hook, excludes));
+}
+function initRuntimeHooks(mpOptions, runtimeHooks) {
+  if (!runtimeHooks) {
+    return;
+  }
+  const hooks = Object.keys(MINI_PROGRAM_PAGE_RUNTIME_HOOKS);
+  hooks.forEach((hook) => {
+    if (runtimeHooks & MINI_PROGRAM_PAGE_RUNTIME_HOOKS[hook]) {
+      initHook(mpOptions, hook, []);
+    }
+  });
+}
+const findMixinRuntimeHooks = /* @__PURE__ */ once(() => {
+  const runtimeHooks = [];
+  const app = isFunction$1(getApp) && getApp({ allowDefault: true });
+  if (app && app.$vm && app.$vm.$) {
+    const mixins = app.$vm.$.appContext.mixins;
+    if (isArray$1(mixins)) {
+      const hooks = Object.keys(MINI_PROGRAM_PAGE_RUNTIME_HOOKS);
+      mixins.forEach((mixin) => {
+        hooks.forEach((hook) => {
+          if (hasOwn(mixin, hook) && !runtimeHooks.includes(hook)) {
+            runtimeHooks.push(hook);
+          }
+        });
+      });
+    }
+  }
+  return runtimeHooks;
+});
+function initMixinRuntimeHooks(mpOptions) {
+  initHooks(mpOptions, findMixinRuntimeHooks());
+}
+const HOOKS = [
+  ON_SHOW,
+  ON_HIDE,
+  ON_ERROR,
+  ON_THEME_CHANGE,
+  ON_PAGE_NOT_FOUND,
+  ON_UNHANDLE_REJECTION
+];
+function parseApp(instance, parseAppOptions) {
+  const internalInstance = instance.$;
+  const appOptions = {
+    globalData: instance.$options && instance.$options.globalData || {},
+    $vm: instance,
+    // mp-alipay 组件 data 初始化比 onLaunch 早，提前挂载
+    onLaunch(options) {
+      this.$vm = instance;
+      const ctx = internalInstance.ctx;
+      if (this.$vm && ctx.$scope && ctx.$callHook) {
+        return;
+      }
+      initBaseInstance(internalInstance, {
+        mpType: "app",
+        mpInstance: this,
+        slots: []
+      });
+      ctx.globalData = this.globalData;
+      instance.$callHook(ON_LAUNCH, options);
+    }
+  };
+  const { onError } = internalInstance;
+  if (onError) {
+    internalInstance.appContext.config.errorHandler = (err) => {
+      instance.$callHook(ON_ERROR, err);
+    };
+  }
+  initLocale(instance);
+  const vueOptions = instance.$.type;
+  initHooks(appOptions, HOOKS);
+  initUnknownHooks(appOptions, vueOptions);
+  {
+    const methods = vueOptions.methods;
+    methods && extend(appOptions, methods);
+  }
+  return appOptions;
+}
+function initCreateApp(parseAppOptions) {
+  return function createApp2(vm) {
+    return App(parseApp(vm));
+  };
+}
+function initCreateSubpackageApp(parseAppOptions) {
+  return function createApp2(vm) {
+    const appOptions = parseApp(vm);
+    const app = isFunction$1(getApp) && getApp({
+      allowDefault: true
+    });
+    if (!app)
+      return;
+    vm.$.ctx.$scope = app;
+    const globalData = app.globalData;
+    if (globalData) {
+      Object.keys(appOptions.globalData).forEach((name) => {
+        if (!hasOwn(globalData, name)) {
+          globalData[name] = appOptions.globalData[name];
+        }
+      });
+    }
+    Object.keys(appOptions).forEach((name) => {
+      if (!hasOwn(app, name)) {
+        app[name] = appOptions[name];
+      }
+    });
+    initAppLifecycle(appOptions, vm);
+  };
+}
+function initAppLifecycle(appOptions, vm) {
+  if (isFunction$1(appOptions.onLaunch)) {
+    const args = wx.getLaunchOptionsSync && wx.getLaunchOptionsSync();
+    appOptions.onLaunch(args);
+  }
+  if (isFunction$1(appOptions.onShow) && wx.onAppShow) {
+    wx.onAppShow((args) => {
+      vm.$callHook("onShow", args);
+    });
+  }
+  if (isFunction$1(appOptions.onHide) && wx.onAppHide) {
+    wx.onAppHide((args) => {
+      vm.$callHook("onHide", args);
+    });
+  }
+}
+function initLocale(appVm) {
+  const locale = ref(normalizeLocale(wx.getSystemInfoSync().language) || LOCALE_EN);
+  Object.defineProperty(appVm, "$locale", {
+    get() {
+      return locale.value;
+    },
+    set(v) {
+      locale.value = v;
+    }
+  });
+}
+const builtInProps = [
+  // 百度小程序,快手小程序自定义组件不支持绑定动态事件，动态dataset，故通过props传递事件信息
+  // event-opts
+  "eO",
+  // 组件 ref
+  "uR",
+  // 组件 ref-in-for
+  "uRIF",
+  // 组件 id
+  "uI",
+  // 组件类型 m: 小程序组件
+  "uT",
+  // 组件 props
+  "uP",
+  // 小程序不能直接定义 $slots 的 props，所以通过 vueSlots 转换到 $slots
+  "uS"
+];
+function initDefaultProps(options, isBehavior = false) {
+  const properties = {};
+  if (!isBehavior) {
+    let observerSlots = function(newVal) {
+      const $slots = /* @__PURE__ */ Object.create(null);
+      newVal && newVal.forEach((slotName) => {
+        $slots[slotName] = true;
+      });
+      this.setData({
+        $slots
+      });
+    };
+    builtInProps.forEach((name) => {
+      properties[name] = {
+        type: null,
+        value: ""
+      };
+    });
+    properties.uS = {
+      type: null,
+      value: []
+    };
+    {
+      properties.uS.observer = observerSlots;
+    }
+  }
+  if (options.behaviors) {
+    if (options.behaviors.includes("wx://form-field")) {
+      if (!options.properties || !options.properties.name) {
+        properties.name = {
+          type: null,
+          value: ""
+        };
+      }
+      if (!options.properties || !options.properties.value) {
+        properties.value = {
+          type: null,
+          value: ""
+        };
+      }
+    }
+  }
+  return properties;
+}
+function initVirtualHostProps(options) {
+  const properties = {};
+  {
+    if (options && options.virtualHost) {
+      properties.virtualHostStyle = {
+        type: null,
+        value: ""
+      };
+      properties.virtualHostClass = {
+        type: null,
+        value: ""
+      };
+    }
+  }
+  return properties;
+}
+function initProps(mpComponentOptions) {
+  if (!mpComponentOptions.properties) {
+    mpComponentOptions.properties = {};
+  }
+  extend(mpComponentOptions.properties, initDefaultProps(mpComponentOptions), initVirtualHostProps(mpComponentOptions.options));
+}
+const PROP_TYPES = [String, Number, Boolean, Object, Array, null];
+function parsePropType(type, defaultValue) {
+  if (isArray$1(type) && type.length === 1) {
+    return type[0];
+  }
+  return type;
+}
+function normalizePropType(type, defaultValue) {
+  const res = parsePropType(type);
+  return PROP_TYPES.indexOf(res) !== -1 ? res : null;
+}
+function initPageProps({ properties }, rawProps) {
+  if (isArray$1(rawProps)) {
+    rawProps.forEach((key) => {
+      properties[key] = {
+        type: String,
+        value: ""
+      };
+    });
+  } else if (isPlainObject(rawProps)) {
+    Object.keys(rawProps).forEach((key) => {
+      const opts = rawProps[key];
+      if (isPlainObject(opts)) {
+        let value = opts.default;
+        if (isFunction$1(value)) {
+          value = value();
+        }
+        const type = opts.type;
+        opts.type = normalizePropType(type);
+        properties[key] = {
+          type: opts.type,
+          value
+        };
+      } else {
+        properties[key] = {
+          type: normalizePropType(opts)
+        };
+      }
+    });
+  }
+}
+function findPropsData(properties, isPage2) {
+  return (isPage2 ? findPagePropsData(properties) : findComponentPropsData(resolvePropValue(properties.uP))) || {};
+}
+function findPagePropsData(properties) {
+  const propsData = {};
+  if (isPlainObject(properties)) {
+    Object.keys(properties).forEach((name) => {
+      if (builtInProps.indexOf(name) === -1) {
+        propsData[name] = resolvePropValue(properties[name]);
+      }
+    });
+  }
+  return propsData;
+}
+function initFormField(vm) {
+  const vueOptions = vm.$options;
+  if (isArray$1(vueOptions.behaviors) && vueOptions.behaviors.includes("uni://form-field")) {
+    vm.$watch("modelValue", () => {
+      vm.$scope && vm.$scope.setData({
+        name: vm.name,
+        value: vm.modelValue
+      });
+    }, {
+      immediate: true
+    });
+  }
+}
+function resolvePropValue(prop) {
+  return prop;
+}
+function initData(_) {
+  return {};
+}
+function initPropsObserver(componentOptions) {
+  const observe = function observe2() {
+    const up = this.properties.uP;
+    if (!up) {
+      return;
+    }
+    if (this.$vm) {
+      updateComponentProps(resolvePropValue(up), this.$vm.$);
+    } else if (resolvePropValue(this.properties.uT) === "m") {
+      updateMiniProgramComponentProperties(resolvePropValue(up), this);
+    }
+  };
+  {
+    if (!componentOptions.observers) {
+      componentOptions.observers = {};
+    }
+    componentOptions.observers.uP = observe;
+  }
+}
+function updateMiniProgramComponentProperties(up, mpInstance) {
+  const prevProps = mpInstance.properties;
+  const nextProps = findComponentPropsData(up) || {};
+  if (hasPropsChanged(prevProps, nextProps, false)) {
+    mpInstance.setData(nextProps);
+  }
+}
+function updateComponentProps(up, instance) {
+  const prevProps = toRaw(instance.props);
+  const nextProps = findComponentPropsData(up) || {};
+  if (hasPropsChanged(prevProps, nextProps)) {
+    updateProps(instance, nextProps, prevProps);
+    if (hasQueueJob(instance.update)) {
+      invalidateJob(instance.update);
+    }
+    {
+      instance.update();
+    }
+  }
+}
+function hasPropsChanged(prevProps, nextProps, checkLen = true) {
+  const nextKeys = Object.keys(nextProps);
+  if (checkLen && nextKeys.length !== Object.keys(prevProps).length) {
+    return true;
+  }
+  for (let i = 0; i < nextKeys.length; i++) {
+    const key = nextKeys[i];
+    if (nextProps[key] !== prevProps[key]) {
+      return true;
+    }
+  }
+  return false;
+}
+function initBehaviors(vueOptions) {
+  const vueBehaviors = vueOptions.behaviors;
+  let vueProps = vueOptions.props;
+  if (!vueProps) {
+    vueOptions.props = vueProps = [];
+  }
+  const behaviors = [];
+  if (isArray$1(vueBehaviors)) {
+    vueBehaviors.forEach((behavior) => {
+      behaviors.push(behavior.replace("uni://", "wx://"));
+      if (behavior === "uni://form-field") {
+        if (isArray$1(vueProps)) {
+          vueProps.push("name");
+          vueProps.push("modelValue");
+        } else {
+          vueProps.name = {
+            type: String,
+            default: ""
+          };
+          vueProps.modelValue = {
+            type: [String, Number, Boolean, Array, Object, Date],
+            default: ""
+          };
+        }
+      }
+    });
+  }
+  return behaviors;
+}
+function applyOptions(componentOptions, vueOptions) {
+  componentOptions.data = initData();
+  componentOptions.behaviors = initBehaviors(vueOptions);
+}
+function parseComponent(vueOptions, { parse, mocks: mocks2, isPage: isPage2, initRelation: initRelation2, handleLink: handleLink2, initLifetimes: initLifetimes2 }) {
+  vueOptions = vueOptions.default || vueOptions;
+  const options = {
+    multipleSlots: true,
+    // styleIsolation: 'apply-shared',
+    addGlobalClass: true,
+    pureDataPattern: /^uP$/
+  };
+  if (isArray$1(vueOptions.mixins)) {
+    vueOptions.mixins.forEach((item) => {
+      if (isObject(item.options)) {
+        extend(options, item.options);
+      }
+    });
+  }
+  if (vueOptions.options) {
+    extend(options, vueOptions.options);
+  }
+  const mpComponentOptions = {
+    options,
+    lifetimes: initLifetimes2({ mocks: mocks2, isPage: isPage2, initRelation: initRelation2, vueOptions }),
+    pageLifetimes: {
+      show() {
+        this.$vm && this.$vm.$callHook("onPageShow");
+      },
+      hide() {
+        this.$vm && this.$vm.$callHook("onPageHide");
+      },
+      resize(size2) {
+        this.$vm && this.$vm.$callHook("onPageResize", size2);
+      }
+    },
+    methods: {
+      __l: handleLink2
+    }
+  };
+  {
+    applyOptions(mpComponentOptions, vueOptions);
+  }
+  initProps(mpComponentOptions);
+  initPropsObserver(mpComponentOptions);
+  initExtraOptions(mpComponentOptions, vueOptions);
+  initWxsCallMethods(mpComponentOptions.methods, vueOptions.wxsCallMethods);
+  {
+    initWorkletMethods(mpComponentOptions.methods, vueOptions.methods);
+  }
+  if (parse) {
+    parse(mpComponentOptions, { handleLink: handleLink2 });
+  }
+  return mpComponentOptions;
+}
+function initCreateComponent(parseOptions2) {
+  return function createComponent2(vueComponentOptions) {
+    return Component(parseComponent(vueComponentOptions, parseOptions2));
+  };
+}
+let $createComponentFn;
+let $destroyComponentFn;
+function getAppVm() {
+  return getApp().$vm;
+}
+function $createComponent(initialVNode, options) {
+  if (!$createComponentFn) {
+    $createComponentFn = getAppVm().$createComponent;
+  }
+  const proxy = $createComponentFn(initialVNode, options);
+  return getExposeProxy(proxy.$) || proxy;
+}
+function $destroyComponent(instance) {
+  if (!$destroyComponentFn) {
+    $destroyComponentFn = getAppVm().$destroyComponent;
+  }
+  return $destroyComponentFn(instance);
+}
+function parsePage(vueOptions, parseOptions2) {
+  const { parse, mocks: mocks2, isPage: isPage2, initRelation: initRelation2, handleLink: handleLink2, initLifetimes: initLifetimes2 } = parseOptions2;
+  const miniProgramPageOptions = parseComponent(vueOptions, {
+    mocks: mocks2,
+    isPage: isPage2,
+    initRelation: initRelation2,
+    handleLink: handleLink2,
+    initLifetimes: initLifetimes2
+  });
+  initPageProps(miniProgramPageOptions, (vueOptions.default || vueOptions).props);
+  const methods = miniProgramPageOptions.methods;
+  methods.onLoad = function(query) {
+    this.options = query;
+    this.$page = {
+      fullPath: addLeadingSlash(this.route + stringifyQuery(query))
+    };
+    return this.$vm && this.$vm.$callHook(ON_LOAD, query);
+  };
+  initHooks(methods, PAGE_INIT_HOOKS);
+  {
+    initUnknownHooks(methods, vueOptions);
+  }
+  initRuntimeHooks(methods, vueOptions.__runtimeHooks);
+  initMixinRuntimeHooks(methods);
+  parse && parse(miniProgramPageOptions, { handleLink: handleLink2 });
+  return miniProgramPageOptions;
+}
+function initCreatePage(parseOptions2) {
+  return function createPage2(vuePageOptions) {
+    return Component(parsePage(vuePageOptions, parseOptions2));
+  };
+}
+function initCreatePluginApp(parseAppOptions) {
+  return function createApp2(vm) {
+    initAppLifecycle(parseApp(vm), vm);
+  };
+}
+const MPPage = Page;
+const MPComponent = Component;
+function initTriggerEvent(mpInstance) {
+  const oldTriggerEvent = mpInstance.triggerEvent;
+  const newTriggerEvent = function(event, ...args) {
+    return oldTriggerEvent.apply(mpInstance, [
+      customizeEvent(event),
+      ...args
+    ]);
+  };
+  try {
+    mpInstance.triggerEvent = newTriggerEvent;
+  } catch (error) {
+    mpInstance._triggerEvent = newTriggerEvent;
+  }
+}
+function initMiniProgramHook(name, options, isComponent) {
+  const oldHook = options[name];
+  if (!oldHook) {
+    options[name] = function() {
+      initTriggerEvent(this);
+    };
+  } else {
+    options[name] = function(...args) {
+      initTriggerEvent(this);
+      return oldHook.apply(this, args);
+    };
+  }
+}
+Page = function(options) {
+  initMiniProgramHook(ON_LOAD, options);
+  return MPPage(options);
+};
+Component = function(options) {
+  initMiniProgramHook("created", options);
+  const isVueComponent = options.properties && options.properties.uP;
+  if (!isVueComponent) {
+    initProps(options);
+    initPropsObserver(options);
+  }
+  return MPComponent(options);
+};
+function initLifetimes({ mocks: mocks2, isPage: isPage2, initRelation: initRelation2, vueOptions }) {
+  return {
+    attached() {
+      let properties = this.properties;
+      initVueIds(properties.uI, this);
+      const relationOptions = {
+        vuePid: this._$vuePid
+      };
+      initRelation2(this, relationOptions);
+      const mpInstance = this;
+      const isMiniProgramPage = isPage2(mpInstance);
+      let propsData = properties;
+      this.$vm = $createComponent({
+        type: vueOptions,
+        props: findPropsData(propsData, isMiniProgramPage)
+      }, {
+        mpType: isMiniProgramPage ? "page" : "component",
+        mpInstance,
+        slots: properties.uS || {},
+        // vueSlots
+        parentComponent: relationOptions.parent && relationOptions.parent.$,
+        onBeforeSetup(instance, options) {
+          initRefs(instance, mpInstance);
+          initMocks(instance, mpInstance, mocks2);
+          initComponentInstance(instance, options);
+        }
+      });
+      if (!isMiniProgramPage) {
+        initFormField(this.$vm);
+      }
+    },
+    ready() {
+      if (this.$vm) {
+        {
+          this.$vm.$callHook("mounted");
+          this.$vm.$callHook(ON_READY);
+        }
+      }
+    },
+    detached() {
+      if (this.$vm) {
+        pruneComponentPropsCache(this.$vm.$.uid);
+        $destroyComponent(this.$vm);
+      }
+    }
+  };
+}
+const mocks = ["__route__", "__wxExparserNodeId__", "__wxWebviewId__"];
+function isPage(mpInstance) {
+  return !!mpInstance.route;
+}
+function initRelation(mpInstance, detail) {
+  mpInstance.triggerEvent("__l", detail);
+}
+function handleLink(event) {
+  const detail = event.detail || event.value;
+  const vuePid = detail.vuePid;
+  let parentVm;
+  if (vuePid) {
+    parentVm = findVmByVueId(this.$vm, vuePid);
+  }
+  if (!parentVm) {
+    parentVm = this.$vm;
+  }
+  detail.parent = parentVm;
+}
+var parseOptions = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  handleLink,
+  initLifetimes,
+  initRelation,
+  isPage,
+  mocks
+});
+const createApp = initCreateApp();
+const createPage = initCreatePage(parseOptions);
+const createComponent = initCreateComponent(parseOptions);
+const createPluginApp = initCreatePluginApp();
+const createSubpackageApp = initCreateSubpackageApp();
+{
+  wx.createApp = global.createApp = createApp;
+  wx.createPage = createPage;
+  wx.createComponent = createComponent;
+  wx.createPluginApp = global.createPluginApp = createPluginApp;
+  wx.createSubpackageApp = global.createSubpackageApp = createSubpackageApp;
+}
+const createHook = (lifecycle) => (hook, target = getCurrentInstance()) => {
+  !isInSSRComponentSetup && injectHook(lifecycle, hook, target);
+};
+const onShow = /* @__PURE__ */ createHook(ON_SHOW);
+const onHide = /* @__PURE__ */ createHook(ON_HIDE);
+const onLaunch = /* @__PURE__ */ createHook(ON_LAUNCH);
+const onLoad = /* @__PURE__ */ createHook(ON_LOAD);
+/*!
+ * pinia v3.0.2
+ * (c) 2025 Eduardo San Martin Morote
+ * @license MIT
+ */
+const piniaSymbol = Symbol("pinia");
+var MutationType;
+(function(MutationType2) {
+  MutationType2["direct"] = "direct";
+  MutationType2["patchObject"] = "patch object";
+  MutationType2["patchFunction"] = "patch function";
+})(MutationType || (MutationType = {}));
+const IS_CLIENT = typeof window !== "undefined";
+const componentStateTypes = [];
+const getStoreType = (id) => "🍍 " + id;
+function addStoreToDevtools(app, store) {
+  if (!componentStateTypes.includes(getStoreType(store.$id))) {
+    componentStateTypes.push(getStoreType(store.$id));
+  }
+}
+function patchActionForGrouping(store, actionNames, wrapWithProxy) {
+  const actions = actionNames.reduce((storeActions, actionName) => {
+    storeActions[actionName] = toRaw(store)[actionName];
+    return storeActions;
+  }, {});
+  for (const actionName in actions) {
+    store[actionName] = function() {
+      const trackedStore = wrapWithProxy ? new Proxy(store, {
+        get(...args) {
+          return Reflect.get(...args);
+        },
+        set(...args) {
+          return Reflect.set(...args);
+        }
+      }) : store;
+      const retValue = actions[actionName].apply(trackedStore, arguments);
+      return retValue;
+    };
+  }
+}
+function devtoolsPlugin({ app, store, options }) {
+  if (store.$id.startsWith("__hot:")) {
+    return;
+  }
+  store._isOptionsAPI = !!options.state;
+  if (!store._p._testing) {
+    patchActionForGrouping(store, Object.keys(options.actions), store._isOptionsAPI);
+    const originalHotUpdate = store._hotUpdate;
+    toRaw(store)._hotUpdate = function(newStore) {
+      originalHotUpdate.apply(this, arguments);
+      patchActionForGrouping(store, Object.keys(newStore._hmrPayload.actions), !!store._isOptionsAPI);
+    };
+  }
+  addStoreToDevtools(
+    app,
+    // FIXME: is there a way to allow the assignment from Store<Id, S, G, A> to StoreGeneric?
+    store
+  );
+}
+function createPinia() {
+  const scope = effectScope(true);
+  const state = scope.run(() => ref({}));
+  let _p = [];
+  let toBeInstalled = [];
+  const pinia = markRaw({
+    install(app) {
+      pinia._a = app;
+      app.provide(piniaSymbol, pinia);
+      app.config.globalProperties.$pinia = pinia;
+      toBeInstalled.forEach((plugin2) => _p.push(plugin2));
+      toBeInstalled = [];
+    },
+    use(plugin2) {
+      if (!this._a) {
+        toBeInstalled.push(plugin2);
+      } else {
+        _p.push(plugin2);
+      }
+      return this;
+    },
+    _p,
+    // it's actually undefined here
+    // @ts-expect-error
+    _a: null,
+    _e: scope,
+    _s: /* @__PURE__ */ new Map(),
+    state
+  });
+  if (IS_CLIENT && typeof Proxy !== "undefined") {
+    pinia.use(devtoolsPlugin);
+  }
+  return pinia;
+}
+class AbortablePromise {
+  constructor(executor) {
+    this._reject = null;
+    this.promise = new Promise((resolve2, reject) => {
+      executor(resolve2, reject);
+      this._reject = reject;
+    });
+  }
+  // 提供abort方法来中止Promise
+  abort(error) {
+    if (this._reject) {
+      this._reject(error);
+    }
+  }
+  then(onfulfilled, onrejected) {
+    return this.promise.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.promise.catch(onrejected);
+  }
+}
+function uuid() {
+  return s4() + s4() + s4() + s4() + s4() + s4() + s4() + s4();
+}
+function s4() {
+  return Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
+}
+function addUnit(num) {
+  return Number.isNaN(Number(num)) ? `${num}` : `${num}px`;
+}
+function isObj(value) {
+  return Object.prototype.toString.call(value) === "[object Object]" || typeof value === "object";
+}
+function getType(target) {
+  const typeStr = Object.prototype.toString.call(target);
+  const match = typeStr.match(/\[object (\w+)\]/);
+  const type = match && match.length ? match[1].toLowerCase() : "";
+  return type;
+}
+const isDef = (value) => value !== void 0 && value !== null;
+function rgbToHex(r2, g, b) {
+  const hex = (r2 << 16 | g << 8 | b).toString(16);
+  const paddedHex = "#" + "0".repeat(Math.max(0, 6 - hex.length)) + hex;
+  return paddedHex;
+}
+function hexToRgb(hex) {
+  const rgb = [];
+  for (let i = 1; i < 7; i += 2) {
+    rgb.push(parseInt("0x" + hex.slice(i, i + 2), 16));
+  }
+  return rgb;
+}
+const gradient = (startColor, endColor, step = 2) => {
+  const sColor = hexToRgb(startColor);
+  const eColor = hexToRgb(endColor);
+  const rStep = (eColor[0] - sColor[0]) / step;
+  const gStep = (eColor[1] - sColor[1]) / step;
+  const bStep = (eColor[2] - sColor[2]) / step;
+  const gradientColorArr = [];
+  for (let i = 0; i < step; i++) {
+    gradientColorArr.push(
+      rgbToHex(parseInt(String(rStep * i + sColor[0])), parseInt(String(gStep * i + sColor[1])), parseInt(String(bStep * i + sColor[2])))
+    );
+  }
+  return gradientColorArr;
+};
+const isEqual = (value1, value2) => {
+  if (value1 === value2) {
+    return true;
+  }
+  if (!Array.isArray(value1) || !Array.isArray(value2)) {
+    return false;
+  }
+  if (value1.length !== value2.length) {
+    return false;
+  }
+  for (let i = 0; i < value1.length; ++i) {
+    if (value1[i] !== value2[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+const context = {
+  id: 1e3
+};
+function kebabCase(word) {
+  const newWord = word.replace(/[A-Z]/g, function(match) {
+    return "-" + match;
+  }).toLowerCase();
+  return newWord;
+}
+function camelCase(word) {
+  return word.replace(/-(\w)/g, (_, c) => c.toUpperCase());
+}
+function isArray(value) {
+  if (typeof Array.isArray === "function") {
+    return Array.isArray(value);
+  }
+  return Object.prototype.toString.call(value) === "[object Array]";
+}
+function isFunction(value) {
+  return getType(value) === "function" || getType(value) === "asyncfunction";
+}
+function isString(value) {
+  return getType(value) === "string";
+}
+function isPromise(value) {
+  if (isObj(value) && isDef(value)) {
+    return isFunction(value.then) && isFunction(value.catch);
+  }
+  return false;
+}
+function objToStyle(styles) {
+  if (isArray(styles)) {
+    const result = styles.filter(function(item) {
+      return item != null && item !== "";
+    }).map(function(item) {
+      return objToStyle(item);
+    }).join(";");
+    return result ? result.endsWith(";") ? result : result + ";" : "";
+  }
+  if (isString(styles)) {
+    return styles ? styles.endsWith(";") ? styles : styles + ";" : "";
+  }
+  if (isObj(styles)) {
+    const result = Object.keys(styles).filter(function(key) {
+      return styles[key] != null && styles[key] !== "";
+    }).map(function(key) {
+      return [kebabCase(key), styles[key]].join(":");
+    }).join(";");
+    return result ? result.endsWith(";") ? result : result + ";" : "";
+  }
+  return "";
+}
+const pause = (ms = 1e3 / 30) => {
+  return new AbortablePromise((resolve2) => {
+    const timer = setTimeout(() => {
+      clearTimeout(timer);
+      resolve2(true);
+    }, ms);
+  });
+};
+function deepClone(obj, cache = /* @__PURE__ */ new Map()) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (isDate(obj)) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (obj instanceof Error) {
+    const errorCopy = new Error(obj.message);
+    errorCopy.stack = obj.stack;
+    return errorCopy;
+  }
+  if (cache.has(obj)) {
+    return cache.get(obj);
+  }
+  const copy = Array.isArray(obj) ? [] : {};
+  cache.set(obj, copy);
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      copy[key] = deepClone(obj[key], cache);
+    }
+  }
+  return copy;
+}
+function deepAssign(target, source) {
+  Object.keys(source).forEach((key) => {
+    const targetValue = target[key];
+    const newObjValue = source[key];
+    if (isObj(targetValue) && isObj(newObjValue)) {
+      deepAssign(targetValue, newObjValue);
+    } else {
+      target[key] = newObjValue;
+    }
+  });
+  return target;
+}
+const getPropByPath = (obj, path) => {
+  const keys = path.split(".");
+  try {
+    return keys.reduce((acc, key) => acc !== void 0 && acc !== null ? acc[key] : void 0, obj);
+  } catch (error) {
+    return void 0;
+  }
+};
+const isDate = (val) => Object.prototype.toString.call(val) === "[object Date]" && !Number.isNaN(val.getTime());
+function isVideoUrl(url) {
+  const videoRegex = /\.(mp4|mpg|mpeg|dat|asf|avi|rm|rmvb|mov|wmv|flv|mkv|video)/i;
+  return videoRegex.test(url);
+}
+function isImageUrl(url) {
+  const imageRegex = /\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg|image)/i;
+  return imageRegex.test(url);
+}
+const numericProp = [Number, String];
+const makeRequiredProp = (type) => ({
+  type,
+  required: true
+});
+const makeArrayProp = () => ({
+  type: Array,
+  default: () => []
+});
+const makeBooleanProp = (defaultVal) => ({
+  type: Boolean,
+  default: defaultVal
+});
+const makeNumberProp = (defaultVal) => ({
+  type: Number,
+  default: defaultVal
+});
+const makeNumericProp = (defaultVal) => ({
+  type: numericProp,
+  default: defaultVal
+});
+const makeStringProp = (defaultVal) => ({
+  type: String,
+  default: defaultVal
+});
+const baseProps = {
+  /**
+   * 自定义根节点样式
+   */
+  customStyle: makeStringProp(""),
+  /**
+   * 自定义根节点样式类
+   */
+  customClass: makeStringProp("")
+};
+const swiperProps = {
+  ...baseProps,
+  /**
+   * 是否自动播放轮播图
+   * 类型：boolean
+   * 默认值：true
+   */
+  autoplay: makeBooleanProp(true),
+  /**
+   * 当前轮播在哪一项（下标）
+   * 类型：number
+   * 默认值：0
+   */
+  current: makeNumberProp(0),
+  /**
+   * 轮播滑动方向，可选值：'horizontal'（水平）或'vertical'（垂直）
+   * 类型：string
+   * 默认值：'horizontal'
+   */
+  direction: makeStringProp("horizontal"),
+  /**
+   * 同时显示的滑块数量
+   * 类型：number
+   * 默认值：1
+   */
+  displayMultipleItems: makeNumberProp(1),
+  /**
+   * 滑动动画时长，单位为毫秒
+   * 类型：number
+   * 默认值：300
+   */
+  duration: makeNumberProp(300),
+  /**
+   * 指定 swiper 切换缓动动画类型
+   * 类型：string
+   * 默认值：'default'
+   */
+  easingFunction: makeStringProp("default"),
+  /**
+   * 轮播的高度
+   * 类型：number 或 string（数字或可转换为数字的字符串）
+   * 默认值：'192'
+   */
+  height: makeNumericProp("192"),
+  /**
+   * 轮播间隔时间，单位为毫秒
+   * 类型：number
+   * 默认值：5000
+   */
+  interval: makeNumberProp(5e3),
+  /**
+   * 图片列表，可以是一个图片对象数组或字符串数组
+   * 类型：array
+   * 默认值：空数组
+   */
+  list: {
+    type: Array,
+    default: () => []
+  },
+  /**
+   * 是否循环播放轮播图
+   * 类型：boolean
+   * 默认值：true
+   */
+  loop: makeBooleanProp(true),
+  /**
+   * 视频是否循环播放
+   * 类型：boolean
+   * 默认值：true
+   */
+  videoLoop: makeBooleanProp(true),
+  /**
+   * 视频是否静音播放
+   * 类型：boolean
+   * 默认值：true
+   */
+  muted: makeBooleanProp(true),
+  /**
+   * 后边距
+   * 类型：number 或 string（数字或可转换为数字的字符串）
+   * 默认值：'0'
+   */
+  nextMargin: makeNumericProp("0"),
+  /**
+   * 页码信息展示位置，可选值：'left' | 'top-left' | 'top' | 'top-right' | 'bottom-left' | 'bottom' | 'bottom-right' | 'right'
+   * 类型：string
+   * 默认值：'bottom'
+   */
+  indicatorPosition: makeStringProp("bottom"),
+  /**
+   * 前边距
+   * 类型：number 或 string（数字或可转换为数字的字符串）
+   * 默认值：'0'
+   */
+  previousMargin: makeNumericProp("0"),
+  /**
+   * 是否应用边距到第一个、最后一个元素
+   * 类型：boolean
+   * 默认值：false
+   */
+  snapToEdge: makeBooleanProp(false),
+  /**
+   * 指示器全部配置，可以是布尔值或指示器配置对象
+   * 类型：boolean 或 object
+   * 默认值：true
+   */
+  indicator: {
+    type: [Boolean, Object],
+    default: true
+  },
+  /**
+   * 图片裁剪、缩放的模式
+   * 类型：string
+   * 默认值：'aspectFill'
+   */
+  imageMode: makeStringProp("aspectFill"),
+  /**
+   * 选项对象中，value 对应的 key
+   */
+  valueKey: makeStringProp("value"),
+  /**
+   * 选项对象中，标题 text 对应的 key
+   */
+  textKey: makeStringProp("text"),
+  /**
+   * 视频是否自动播放
+   * 类型：boolean
+   * 默认值：true
+   */
+  autoplayVideo: makeBooleanProp(true),
+  /**
+   * 切换轮播项时是否停止上一个视频的播放
+   * 类型：boolean
+   * 默认值：true
+   */
+  stopPreviousVideo: makeBooleanProp(true),
+  /**
+   * 视频播放时是否停止自动轮播
+   * 类型：boolean
+   * 默认值：false
+   */
+  stopAutoplayWhenVideoPlay: makeBooleanProp(false),
+  /**
+   * 自动以指定滑块的高度为整个容器的高度。当 vertical 为 true 时，默认不调整
+   * 仅支付宝小程序支持
+   * 类型：'first' | 'current' | 'highest' | 'none'
+   * 默认值：false
+   */
+  adjustHeight: makeStringProp("highest"),
+  /**
+   * vertical 为 true 时强制使 adjust-height 生效。
+   * 仅支付宝小程序支持
+   * 类型：boolean
+   * 默认值：false
+   */
+  adjustVerticalHeight: makeBooleanProp(false),
+  /**
+   * 自定义指示器类名
+   * 类型：string
+   */
+  customIndicatorClass: makeStringProp(""),
+  /**
+   * 自定义图片类名
+   * 类型：string
+   */
+  customImageClass: makeStringProp(""),
+  /**
+   * 自定义上一个图片类名
+   * 类型：string
+   */
+  customPrevImageClass: makeStringProp(""),
+  /**
+   * 自定义下一个图片类名
+   * 类型：string
+   */
+  customNextImageClass: makeStringProp(""),
+  /**
+   * 自定义swiper子项类名
+   * 类型：string
+   */
+  customItemClass: makeStringProp(""),
+  /**
+   * 自定义上一个子项类名
+   * 类型：string
+   */
+  customPrevClass: makeStringProp(""),
+  /**
+   * 自定义下一个子项类名
+   * 类型：string
+   */
+  customNextClass: makeStringProp(""),
+  /**
+   * 自定义文字标题类名
+   * 类型：string
+   */
+  customTextClass: makeStringProp(""),
+  /**
+   * 自定义文字标题样式
+   * 类型：string
+   */
+  customTextStyle: makeStringProp("")
+};
+const _b64chars = [..."ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"];
+const _mkUriSafe = (src) => src.replace(/[+/]/g, (m0) => m0 === "+" ? "-" : "_").replace(/=+\$/m, "");
+const fromUint8Array = (src, rfc4648 = false) => {
+  let b642 = "";
+  for (let i = 0, l = src.length; i < l; i += 3) {
+    const [a0, a1, a2] = [src[i], src[i + 1], src[i + 2]];
+    const ord = a0 << 16 | a1 << 8 | a2;
+    b642 += _b64chars[ord >>> 18];
+    b642 += _b64chars[ord >>> 12 & 63];
+    b642 += typeof a1 !== "undefined" ? _b64chars[ord >>> 6 & 63] : "=";
+    b642 += typeof a2 !== "undefined" ? _b64chars[ord & 63] : "=";
+  }
+  return rfc4648 ? _mkUriSafe(b642) : b642;
+};
+const _btoa = typeof btoa === "function" ? (s2) => btoa(s2) : (s2) => {
+  if (s2.charCodeAt(0) > 255) {
+    throw new RangeError("The string contains invalid characters.");
+  }
+  return fromUint8Array(Uint8Array.from(s2, (c) => c.charCodeAt(0)));
+};
+const utob = (src) => unescape(encodeURIComponent(src));
+function encode(src, rfc4648 = false) {
+  const b642 = _btoa(utob(src));
+  return rfc4648 ? _mkUriSafe(b642) : b642;
+}
+const buttonProps = {
+  ...baseProps,
+  /**
+   * 幽灵按钮
+   */
+  plain: makeBooleanProp(false),
+  /**
+   * 圆角按钮
+   */
+  round: makeBooleanProp(true),
+  /**
+   * 禁用按钮
+   */
+  disabled: makeBooleanProp(false),
+  /**
+   * 是否细边框
+   */
+  hairline: makeBooleanProp(false),
+  /**
+   * 块状按钮
+   */
+  block: makeBooleanProp(false),
+  /**
+   * 按钮类型，可选值：primary / success / info / warning / error / text / icon
+   */
+  type: makeStringProp("primary"),
+  /**
+   * 按钮尺寸，可选值：small / medium / large
+   */
+  size: makeStringProp("medium"),
+  /**
+   * 图标类名
+   */
+  icon: String,
+  /**
+   * 类名前缀，用于使用自定义图标，用法参考Icon组件
+   */
+  classPrefix: makeStringProp("wd-icon"),
+  /**
+   * 加载中按钮
+   */
+  loading: makeBooleanProp(false),
+  /**
+   * 加载图标颜色
+   */
+  loadingColor: String,
+  /**
+   * 开放能力
+   */
+  openType: String,
+  /**
+   * 指定是否阻止本节点的祖先节点出现点击态
+   */
+  hoverStopPropagation: Boolean,
+  /**
+   * 指定返回用户信息的语言，zh_CN 简体中文，zh_TW 繁体中文，en 英文
+   */
+  lang: String,
+  /**
+   * 会话来源，open-type="contact"时有效
+   */
+  sessionFrom: String,
+  /**
+   * 会话内消息卡片标题，open-type="contact"时有效
+   */
+  sendMessageTitle: String,
+  /**
+   * 会话内消息卡片点击跳转小程序路径，open-type="contact"时有效
+   */
+  sendMessagePath: String,
+  /**
+   * 会话内消息卡片图片，open-type="contact"时有效
+   */
+  sendMessageImg: String,
+  /**
+   * 打开 APP 时，向 APP 传递的参数，open-type=launchApp时有效
+   */
+  appParameter: String,
+  /**
+   * 是否显示会话内消息卡片，设置此参数为 true，用户进入客服会话会在右下角显示"可能要发送的小程序"提示，用户点击后可以快速发送小程序消息，open-type="contact"时有效
+   */
+  showMessageCard: Boolean,
+  /**
+   * 按钮的唯一标识，可用于设置隐私同意授权按钮的id
+   */
+  buttonId: String,
+  /**
+   * 支付宝小程序，当 open-type 为 getAuthorize 时有效。
+   * 可选值：'phoneNumber' | 'userInfo'
+   */
+  scope: String
+};
+const gapProps = {
+  ...baseProps,
+  /**
+   * 背景颜色
+   */
+  bgColor: makeStringProp("transparent"),
+  /**
+   * 是否开启底部安全区
+   */
+  safeAreaBottom: makeBooleanProp(false),
+  /**
+   * 高度
+   */
+  height: makeNumericProp(15)
+};
+const zhCN = {
+  calendar: {
+    placeholder: "请选择",
+    title: "选择日期",
+    day: "日",
+    week: "周",
+    month: "月",
+    confirm: "确定",
+    startTime: "开始时间",
+    endTime: "结束时间",
+    to: "至",
+    timeFormat: "YY年MM月DD日 HH:mm:ss",
+    dateFormat: "YYYY年MM月DD日",
+    weekFormat: (year, week) => `${year} 第 ${week} 周`,
+    startWeek: "开始周",
+    endWeek: "结束周",
+    startMonth: "开始月",
+    endMonth: "结束月",
+    monthFormat: "YYYY年MM月"
+  },
+  calendarView: {
+    startTime: "开始",
+    endTime: "结束",
+    weeks: {
+      sun: "日",
+      mon: "一",
+      tue: "二",
+      wed: "三",
+      thu: "四",
+      fri: "五",
+      sat: "六"
+    },
+    rangePrompt: (maxRange) => `选择天数不能超过${maxRange}天`,
+    rangePromptWeek: (maxRange) => `选择周数不能超过${maxRange}周`,
+    rangePromptMonth: (maxRange) => `选择月份不能超过${maxRange}个月`,
+    monthTitle: "YYYY年M月",
+    yearTitle: "YYYY年",
+    month: "M月",
+    hour: (value) => `${value}时`,
+    minute: (value) => `${value}分`,
+    second: (value) => `${value}秒`
+  },
+  collapse: {
+    expand: "展开",
+    retract: "收起"
+  },
+  colPicker: {
+    title: "请选择",
+    placeholder: "请选择",
+    select: "请选择"
+  },
+  datetimePicker: {
+    start: "开始时间",
+    end: "结束时间",
+    to: "至",
+    placeholder: "请选择",
+    confirm: "完成",
+    cancel: "取消"
+  },
+  loadmore: {
+    loading: "正在努力加载中...",
+    finished: "已加载完毕",
+    error: "加载失败",
+    retry: "点击重试"
+  },
+  messageBox: {
+    inputPlaceholder: "请输入",
+    confirm: "确定",
+    cancel: "取消",
+    inputNoValidate: "输入的数据不合法"
+  },
+  numberKeyboard: {
+    confirm: "完成"
+  },
+  pagination: {
+    prev: "上一页",
+    next: "下一页",
+    page: (value) => `当前页：${value}`,
+    total: (total) => `当前数据：${total}条`,
+    size: (size2) => `分页大小：${size2}`
+  },
+  picker: {
+    cancel: "取消",
+    done: "完成",
+    placeholder: "请选择"
+  },
+  imgCropper: {
+    confirm: "完成",
+    cancel: "取消"
+  },
+  search: {
+    search: "搜索",
+    cancel: "取消"
+  },
+  steps: {
+    wait: "未开始",
+    finished: "已完成",
+    process: "进行中",
+    failed: "失败"
+  },
+  tabs: {
+    all: "全部"
+  },
+  upload: {
+    error: "上传失败"
+  },
+  input: {
+    placeholder: "请输入..."
+  },
+  selectPicker: {
+    title: "请选择",
+    placeholder: "请选择",
+    select: "请选择",
+    confirm: "确认",
+    filterPlaceholder: "搜索"
+  },
+  tag: {
+    placeholder: "请输入",
+    add: "新增标签"
+  },
+  textarea: {
+    placeholder: "请输入..."
+  },
+  tableCol: {
+    indexLabel: "序号"
+  },
+  signature: {
+    confirmText: "确认",
+    clearText: "清空",
+    revokeText: "撤销",
+    restoreText: "恢复"
+  }
+};
+const lang = ref("zh-CN");
+const messages = reactive({
+  "zh-CN": zhCN
+});
+const Locale = {
+  messages() {
+    return messages[lang.value];
+  },
+  use(newLang, newMessage) {
+    lang.value = newLang;
+    if (newMessage) {
+      this.add({ [newLang]: newMessage });
+    }
+  },
+  add(newMessages = {}) {
+    deepAssign(messages, newMessages);
+  }
+};
+const useTranslate = (name) => {
+  const prefix = name ? camelCase(name) + "." : "";
+  const translate = (key, ...args) => {
+    const currentMessages = Locale.messages();
+    const message = getPropByPath(currentMessages, prefix + key);
+    return isFunction(message) ? message(...args) : isDef(message) ? message : `${prefix}${key}`;
+  };
+  return { translate };
+};
+const UPLOAD_STATUS = {
+  PENDING: "pending",
+  LOADING: "loading",
+  SUCCESS: "success",
+  FAIL: "fail"
+};
+function useUpload() {
+  let currentTask = null;
+  const abort = (task) => {
+    if (task) {
+      task.abort();
+    } else if (currentTask) {
+      currentTask.abort();
+      currentTask = null;
+    }
+  };
+  const defaultUpload = (file, formData, options) => {
+    if (options.abortPrevious) {
+      abort();
+    }
+    const uploadTask = index.uploadFile({
+      url: options.action,
+      header: options.header,
+      name: options.name,
+      fileName: options.name,
+      fileType: options.fileType,
+      formData,
+      filePath: file.url,
+      success(res) {
+        if (res.statusCode === options.statusCode) {
+          options.onSuccess(res, file, formData);
+        } else {
+          options.onError({ ...res, errMsg: res.errMsg || "" }, file, formData);
+        }
+      },
+      fail(err) {
+        options.onError(err, file, formData);
+      }
+    });
+    currentTask = uploadTask;
+    uploadTask.onProgressUpdate((res) => {
+      options.onProgress(res, file);
+    });
+    return uploadTask;
+  };
+  const startUpload = (file, options) => {
+    const {
+      uploadMethod,
+      formData = {},
+      action,
+      name = "file",
+      header = {},
+      fileType = "image",
+      statusCode = 200,
+      statusKey = "status",
+      abortPrevious = false
+    } = options;
+    file[statusKey] = UPLOAD_STATUS.LOADING;
+    const uploadOptions = {
+      action,
+      header,
+      name,
+      fileName: name,
+      fileType,
+      statusCode,
+      abortPrevious,
+      onSuccess: (res, file2, formData2) => {
+        var _a;
+        file2[statusKey] = UPLOAD_STATUS.SUCCESS;
+        currentTask = null;
+        (_a = options.onSuccess) == null ? void 0 : _a.call(options, res, file2, formData2);
+      },
+      onError: (error, file2, formData2) => {
+        var _a;
+        file2[statusKey] = UPLOAD_STATUS.FAIL;
+        file2.error = error.errMsg;
+        currentTask = null;
+        (_a = options.onError) == null ? void 0 : _a.call(options, error, file2, formData2);
+      },
+      onProgress: (res, file2) => {
+        var _a;
+        file2.percent = res.progress;
+        (_a = options.onProgress) == null ? void 0 : _a.call(options, res, file2);
+      }
+    };
+    if (isFunction(uploadMethod)) {
+      return uploadMethod(file, formData, uploadOptions);
+    } else {
+      return defaultUpload(file, formData, uploadOptions);
+    }
+  };
+  function formatImage(res) {
+    if (isArray(res.tempFiles)) {
+      return res.tempFiles.map((item) => ({
+        path: item.path || "",
+        name: item.name || "",
+        size: item.size,
+        type: "image",
+        thumb: item.path || ""
+      }));
+    }
+    return [
+      {
+        path: res.tempFiles.path || "",
+        name: res.tempFiles.name || "",
+        size: res.tempFiles.size,
+        type: "image",
+        thumb: res.tempFiles.path || ""
+      }
+    ];
+  }
+  function formatVideo(res) {
+    return [
+      {
+        path: res.tempFilePath || res.filePath || "",
+        name: res.name || "",
+        size: res.size,
+        type: "video",
+        thumb: res.thumbTempFilePath || "",
+        duration: res.duration
+      }
+    ];
+  }
+  function formatMedia(res) {
+    return res.tempFiles.map((item) => ({
+      type: item.fileType,
+      path: item.tempFilePath,
+      thumb: item.fileType === "video" ? item.thumbTempFilePath : item.tempFilePath,
+      size: item.size,
+      duration: item.duration
+    }));
+  }
+  function chooseFile({
+    multiple,
+    sizeType,
+    sourceType,
+    maxCount,
+    accept,
+    compressed,
+    maxDuration,
+    camera,
+    extension
+  }) {
+    return new Promise((resolve2, reject) => {
+      switch (accept) {
+        case "image":
+          index.chooseImage({
+            count: multiple ? Math.min(maxCount || 9, 9) : 1,
+            // 默认9,最大9
+            sizeType,
+            sourceType,
+            success: (res) => resolve2(formatImage(res)),
+            fail: reject
+          });
+          break;
+        case "video":
+          index.chooseVideo({
+            sourceType,
+            compressed,
+            maxDuration,
+            camera,
+            success: (res) => resolve2(formatVideo(res)),
+            fail: reject
+          });
+          break;
+        case "media":
+          index.chooseMedia({
+            count: multiple ? Math.min(maxCount || 9, 9) : 1,
+            // 默认9,最大9
+            sourceType,
+            sizeType,
+            camera,
+            maxDuration,
+            success: (res) => resolve2(formatMedia(res)),
+            fail: reject
+          });
+          break;
+        case "file":
+          index.chooseMessageFile({
+            count: multiple ? Math.min(maxCount || 100, 100) : 1,
+            // 默认100,最大100
+            type: accept,
+            extension,
+            success: (res) => resolve2(res.tempFiles),
+            fail: reject
+          });
+          break;
+        case "all":
+          index.chooseMessageFile({
+            count: multiple ? Math.min(maxCount || 100, 100) : 1,
+            // 默认100,最大100
+            type: accept,
+            extension,
+            success: (res) => resolve2(res.tempFiles),
+            fail: reject
+          });
+          break;
+        default:
+          index.chooseImage({
+            count: multiple ? Math.min(maxCount || 9, 9) : 1,
+            // 默认9,最大9
+            sizeType,
+            sourceType,
+            success: (res) => resolve2(formatImage(res)),
+            fail: reject
+          });
+          break;
+      }
+    });
+  }
+  return {
+    startUpload,
+    abort,
+    UPLOAD_STATUS,
+    chooseFile
+  };
+}
+const uploadProps = {
+  ...baseProps,
+  /**
+   * 上传的文件列表,例如:[{name:'food.jpg',url:'https://xxx.cdn.com/xxx.jpg'}]
+   * 类型：array
+   * 默认值：[]
+   */
+  fileList: makeArrayProp(),
+  /**
+   * 必选参数，上传的地址
+   * 类型：string
+   * 默认值：''
+   */
+  action: makeStringProp(""),
+  /**
+   * 设置上传的请求头部
+   * 类型：object
+   * 默认值：{}
+   */
+  header: { type: Object, default: () => ({}) },
+  /**
+   * 是否支持多选文件
+   * 类型：boolean
+   * 默认值：false
+   */
+  multiple: makeBooleanProp(false),
+  /**
+   * 是否禁用
+   * 类型：boolean
+   * 默认值：false
+   */
+  disabled: makeBooleanProp(false),
+  /**
+   * 最大允许上传个数
+   * 类型：number
+   * 默认值：无
+   */
+  limit: Number,
+  /**
+   * 限制上传个数的情况下，是否展示当前上传的个数
+   * 类型：boolean
+   * 默认值：true
+   */
+  showLimitNum: makeBooleanProp(true),
+  /**
+   * 文件大小限制，单位为byte
+   * 类型：number
+   * 默认值：Number.MAX_VALUE
+   */
+  maxSize: makeNumberProp(Number.MAX_VALUE),
+  /**
+   * 选择图片的来源，chooseImage接口详细参数，查看官方手册
+   * 类型：array
+   * 默认值：['album','camera']
+   */
+  sourceType: {
+    type: Array,
+    default: () => ["album", "camera"]
+  },
+  /**
+   * 所选的图片的尺寸，chooseImage接口详细参数，查看官方手册
+   * 类型：array
+   * 默认值：['original','compressed']
+   */
+  sizeType: {
+    type: Array,
+    default: () => ["original", "compressed"]
+  },
+  /**
+   * 文件对应的key，开发者在服务端可以通过这个key获取文件的二进制内容，uploadFile接口详细参数，查看官方手册
+   * 类型：string
+   * 默认值：'file'
+   */
+  name: makeStringProp("file"),
+  /**
+   * HTTP请求中其他额外的formdata，uploadFile接口详细参数，查看官方手册
+   * 类型：object
+   * 默认值：{}
+   */
+  formData: { type: Object, default: () => {
+  } },
+  /**
+   * 预览失败执行操作
+   * 类型：function({index,imgList})
+   * 默认值：-
+   */
+  onPreviewFail: Function,
+  /**
+   * 上传文件之前的钩子，参数为上传的文件和文件列表，若返回false或者返回Promise且被reject，则停止上传。
+   * 类型：function({files,fileList,resolve})
+   * 默认值：-
+   */
+  beforeUpload: Function,
+  /**
+   * 选择图片之前的钩子，参数为文件列表，若返回false或者返回Promise且被reject，则停止上传。
+   * 类型：function({fileList,resolve})
+   * 默认值：-
+   */
+  beforeChoose: Function,
+  /**
+   * 删除文件之前的钩子，参数为要删除的文件和文件列表，若返回false或者返回Promise且被reject，则停止上传。
+   * 类型：function({file,fileList,resolve})
+   * 默认值：-
+   */
+  beforeRemove: Function,
+  /**
+   * 图片预览前的钩子，参数为预览的图片下标和图片列表，若返回false或者返回Promise且被reject，则停止上传。
+   * 类型：function({index,imgList,resolve})
+   * 默认值：-
+   */
+  beforePreview: Function,
+  /**
+   * 构建上传formData的钩子，参数为上传的文件、待处理的formData，返回值为处理后的formData，若返回false或者返回Promise且被reject，则停止上传。
+   * 类型：function({file,formData,resolve})
+   * 默认值：-
+   * 最低版本：0.1.61
+   */
+  buildFormData: Function,
+  /**
+   * 加载中图标类型
+   * 类型：string
+   * 默认值：'ring'
+   */
+  loadingType: makeStringProp("ring"),
+  /**
+   * 加载中图标颜色
+   * 类型：string
+   * 默认值：'#ffffff'
+   */
+  loadingColor: makeStringProp("#ffffff"),
+  /**
+   * 文件类型，可选值：'image' | 'video' | 'media' | 'all' | 'file'
+   * 默认值：image
+   * 描述：'media'表示同时支持'image'和'video'，'file'表示支持除'image'和'video'外的所有文件类型，'all'标识支持全部类型文件
+   * 'media'和'file'仅微信支持，'all'仅微信和H5支持
+   */
+  accept: makeStringProp("image"),
+  /**
+   * file 数据结构中，status 对应的 key
+   * 类型：string
+   * 默认值：'status'
+   */
+  statusKey: makeStringProp("status"),
+  /**
+   * 加载中图标尺寸
+   * 类型：string
+   * 默认值：'24px'
+   */
+  loadingSize: makeStringProp("24px"),
+  /**
+   * 是否压缩视频，当 accept 为 video 时生效。
+   * 类型：boolean
+   * 默认值：true
+   */
+  compressed: makeBooleanProp(true),
+  /**
+   * 拍摄视频最长拍摄时间，当 accept 为 video | media 时生效，单位秒。
+   * 类型：number
+   * 默认值：60
+   */
+  maxDuration: makeNumberProp(60),
+  /**
+   * 使用前置或者后置相机，当 accept 为 video | media 时生效，可选值为：back｜front。
+   * 类型：UploadCameraType
+   * 默认值：'back'
+   */
+  camera: makeStringProp("back"),
+  /**
+   * 预览图片的mode属性
+   */
+  imageMode: makeStringProp("aspectFit"),
+  /**
+   * 接口响应的成功状态（statusCode）值
+   */
+  successStatus: makeNumberProp(200),
+  /**
+   * 自定义上传按钮样式
+   * 类型：string
+   */
+  customEvokeClass: makeStringProp(""),
+  /**
+   * 自定义预览图片列表样式
+   * 类型：string
+   */
+  customPreviewClass: makeStringProp(""),
+  /**
+   * 是否选择文件后自动上传
+   * 类型：boolean
+   */
+  autoUpload: makeBooleanProp(true),
+  /**
+   * 点击已上传时是否可以重新上传
+   * 类型：boolean
+   * 默认值：false
+   */
+  reupload: makeBooleanProp(false),
+  /**
+   * 自定义上传文件的请求方法
+   * 类型：UploadMethod
+   * 默认值：-
+   */
+  uploadMethod: Function,
+  /**
+   * 根据文件拓展名过滤,每一项都不能是空字符串。默认不过滤。
+   * H5支持全部类型过滤。
+   * 微信小程序支持all和file时过滤,其余平台不支持。
+   */
+  extension: Array
+};
+const swiperNavprops = {
+  ...baseProps,
+  /**
+   * 当前轮播在哪一项（下标）
+   */
+  current: makeNumberProp(0),
+  /**
+   * 轮播滑动方向，包括横向滑动和纵向滑动两个方向
+   */
+  direction: makeStringProp("horizontal"),
+  /**
+   * 小于这个数字不会显示导航器
+   */
+  minShowNum: makeNumberProp(2),
+  /**
+   * 指示器位置
+   */
+  indicatorPosition: makeStringProp("bottom"),
+  /**
+   * 是否显示两侧的控制按钮
+   */
+  showControls: makeBooleanProp(false),
+  /**
+   * 总共的项数
+   */
+  total: makeNumberProp(0),
+  /**
+   * 指示器类型，点状(dots)、点条状(dots-bar)、分式(fraction)等
+   */
+  type: makeStringProp("dots")
+};
+const iconProps = {
+  ...baseProps,
+  /**
+   * 使用的图标名字，可以使用链接图片
+   */
+  name: makeRequiredProp(String),
+  /**
+   * 图标的颜色
+   */
+  color: String,
+  /**
+   * 图标的字体大小
+   */
+  size: numericProp,
+  /**
+   * 类名前缀，用于使用自定义图标
+   */
+  classPrefix: makeStringProp("wd-icon")
+};
+const popupProps = {
+  ...baseProps,
+  /**
+   * 动画类型，参见 wd-transition 组件的name
+   * 类型：string
+   * 可选值：fade / fade-up / fade-down / fade-left / fade-right / slide-up / slide-down / slide-left / slide-right / zoom-in
+   */
+  transition: String,
+  /**
+   * 关闭按钮
+   * 类型：boolean
+   * 默认值：false
+   */
+  closable: makeBooleanProp(false),
+  /**
+   * 弹出框的位置
+   * 类型：string
+   * 默认值：center
+   * 可选值：center / top / right / bottom / left
+   */
+  position: makeStringProp("center"),
+  /**
+   * 点击遮罩是否关闭
+   * 类型：boolean
+   * 默认值：true
+   */
+  closeOnClickModal: makeBooleanProp(true),
+  /**
+   * 动画持续时间
+   * 类型：number | boolean
+   * 默认值：300
+   */
+  duration: {
+    type: [Number, Boolean],
+    default: 300
+  },
+  /**
+   * 是否显示遮罩
+   * 类型：boolean
+   * 默认值：true
+   */
+  modal: makeBooleanProp(true),
+  /**
+   * 设置层级
+   * 类型：number
+   * 默认值：10
+   */
+  zIndex: makeNumberProp(10),
+  /**
+   * 是否当关闭时将弹出层隐藏（display: none)
+   * 类型：boolean
+   * 默认值：true
+   */
+  hideWhenClose: makeBooleanProp(true),
+  /**
+   * 遮罩样式
+   * 类型：string
+   * 默认值：''
+   */
+  modalStyle: makeStringProp(""),
+  /**
+   * 弹出面板是否设置底部安全距离（iphone X 类型的机型）
+   * 类型：boolean
+   * 默认值：false
+   */
+  safeAreaInsetBottom: makeBooleanProp(false),
+  /**
+   * 弹出层是否显示
+   */
+  modelValue: makeBooleanProp(false),
+  /**
+   * 弹层内容懒渲染，触发展示时才渲染内容
+   * 类型：boolean
+   * 默认值：true
+   */
+  lazyRender: makeBooleanProp(true),
+  /**
+   * 是否锁定滚动
+   * 类型：boolean
+   * 默认值：true
+   */
+  lockScroll: makeBooleanProp(true)
+};
+const tagProps = {
+  ...baseProps,
+  /**
+   * 是否开启图标插槽
+   * 类型：boolean
+   * 默认值：false
+   */
+  useIconSlot: makeBooleanProp(false),
+  /**
+   * 标签类型
+   * 类型：string
+   * 可选值：'default' / 'primary' / 'danger' / 'warning' / 'success'
+   * 默认值：'default'
+   */
+  type: makeStringProp("default"),
+  /**
+   * 左侧图标
+   * 类型：string
+   * 默认值：空字符串
+   */
+  icon: makeStringProp(""),
+  /**
+   * 是否可关闭（只对圆角类型支持）
+   * 类型：boolean
+   * 默认值：false
+   */
+  closable: makeBooleanProp(false),
+  /**
+   * 幽灵类型
+   * 类型：boolean
+   * 默认值：false
+   */
+  plain: makeBooleanProp(false),
+  /**
+   * 是否为新增标签
+   * 类型：boolean
+   * 默认值：false
+   */
+  dynamic: makeBooleanProp(false),
+  /**
+   * 文字颜色
+   * 类型：string
+   * 默认值：空字符串
+   */
+  color: makeStringProp(""),
+  /**
+   * 背景色和边框色
+   * 类型：string
+   * 默认值：空字符串
+   */
+  bgColor: makeStringProp(""),
+  /**
+   * 圆角类型
+   * 类型：boolean
+   * 默认值：false
+   */
+  round: makeBooleanProp(false),
+  /**
+   * 标记类型
+   * 类型：boolean
+   * 默认值：false
+   */
+  mark: makeBooleanProp(false)
+};
+const videoPreviewProps = {
+  ...baseProps
+};
+const loadingProps = {
+  ...baseProps,
+  /**
+   * 加载指示器类型，可选值：'outline' | 'ring'
+   */
+  type: makeStringProp("ring"),
+  /**
+   * 设置加载指示器颜色
+   */
+  color: makeStringProp("#4D80F0"),
+  /**
+   * 设置加载指示器大小
+   */
+  size: makeNumericProp("")
+};
+const overlayProps = {
+  ...baseProps,
+  /**
+   * 是否展示遮罩层
+   */
+  show: makeBooleanProp(false),
+  /**
+   * 动画时长，单位毫秒
+   */
+  duration: {
+    type: [Object, Number, Boolean],
+    default: 300
+  },
+  /**
+   * 是否锁定滚动
+   */
+  lockScroll: makeBooleanProp(true),
+  /**
+   * 层级
+   */
+  zIndex: makeNumberProp(10)
+};
+const transitionProps = {
+  ...baseProps,
+  /**
+   * 是否展示组件
+   * 类型：boolean
+   * 默认值：false
+   */
+  show: makeBooleanProp(false),
+  /**
+   * 动画执行时间
+   * 类型：number | boolean | Record<string, number>
+   * 默认值：300 (毫秒)
+   */
+  duration: {
+    type: [Object, Number, Boolean],
+    default: 300
+  },
+  /**
+   * 弹层内容懒渲染，触发展示时才渲染内容
+   * 类型：boolean
+   * 默认值：false
+   */
+  lazyRender: makeBooleanProp(false),
+  /**
+   * 动画类型
+   * 类型：string
+   * 可选值：fade / fade-up / fade-down / fade-left / fade-right / slide-up / slide-down / slide-left / slide-right / zoom-in
+   * 默认值：'fade'
+   */
+  name: [String, Array],
+  /**
+   * 是否在动画结束时销毁子节点（display: none)
+   * 类型：boolean
+   * 默认值：false
+   */
+  destroy: makeBooleanProp(true),
+  /**
+   * 进入过渡的开始状态
+   * 类型：string
+   */
+  enterClass: makeStringProp(""),
+  /**
+   * 进入过渡的激活状态
+   * 类型：string
+   */
+  enterActiveClass: makeStringProp(""),
+  /**
+   * 进入过渡的结束状态
+   * 类型：string
+   */
+  enterToClass: makeStringProp(""),
+  /**
+   * 离开过渡的开始状态
+   * 类型：string
+   */
+  leaveClass: makeStringProp(""),
+  /**
+   * 离开过渡的激活状态
+   * 类型：string
+   */
+  leaveActiveClass: makeStringProp(""),
+  /**
+   * 离开过渡的结束状态
+   * 类型：string
+   */
+  leaveToClass: makeStringProp("")
+};
+exports.AbortablePromise = AbortablePromise;
+exports._export_sfc = _export_sfc;
+exports.addUnit = addUnit;
+exports.buttonProps = buttonProps;
+exports.computed = computed;
+exports.context = context;
+exports.createPinia = createPinia;
+exports.createSSRApp = createSSRApp;
+exports.deepClone = deepClone;
+exports.defineComponent = defineComponent;
+exports.e = e;
+exports.encode = encode;
+exports.f = f;
+exports.gapProps = gapProps;
+exports.getCurrentInstance = getCurrentInstance;
+exports.gradient = gradient;
+exports.iconProps = iconProps;
+exports.index = index;
+exports.isDef = isDef;
+exports.isEqual = isEqual;
+exports.isFunction = isFunction;
+exports.isImageUrl = isImageUrl;
+exports.isObj = isObj;
+exports.isPromise = isPromise;
+exports.isRef = isRef;
+exports.isVideoUrl = isVideoUrl;
+exports.loadingProps = loadingProps;
+exports.n = n;
+exports.nextTick$1 = nextTick$1;
+exports.o = o;
+exports.objToStyle = objToStyle;
+exports.onBeforeMount = onBeforeMount;
+exports.onHide = onHide;
+exports.onLaunch = onLaunch;
+exports.onLoad = onLoad;
+exports.onShow = onShow;
+exports.overlayProps = overlayProps;
+exports.p = p;
+exports.pause = pause;
+exports.popupProps = popupProps;
+exports.r = r;
+exports.reactive = reactive;
+exports.ref = ref;
+exports.resolveComponent = resolveComponent;
+exports.s = s;
+exports.sr = sr;
+exports.swiperNavprops = swiperNavprops;
+exports.swiperProps = swiperProps;
+exports.t = t;
+exports.tagProps = tagProps;
+exports.transitionProps = transitionProps;
+exports.unref = unref;
+exports.uploadProps = uploadProps;
+exports.useTranslate = useTranslate;
+exports.useUpload = useUpload;
+exports.uuid = uuid;
+exports.videoPreviewProps = videoPreviewProps;
+exports.watch = watch;
+exports.wx$1 = wx$1;

dist/dev/mp-weixin/hooks/useDraw.js

@@ -0,0 +1,8 @@
+"use strict";
+function useDraw(props, emit) {
+  const handleClose = () => {
+    emit("update:show", false);
+  };
+  return { handleClose };
+}
+exports.useDraw = useDraw;

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-button/wd-button.js

@@ -0,0 +1,164 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+if (!Math) {
+  wdIcon();
+}
+const wdIcon = () => "../wd-icon/wd-icon.js";
+const __default__ = {
+  name: "wd-button",
+  options: {
+    addGlobalClass: true,
+    virtualHost: true,
+    styleIsolation: "shared"
+  }
+};
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  ...__default__,
+  props: common_vendor.buttonProps,
+  emits: [
+    "click",
+    "getuserinfo",
+    "contact",
+    "getphonenumber",
+    "error",
+    "launchapp",
+    "opensetting",
+    "chooseavatar",
+    "agreeprivacyauthorization"
+  ],
+  setup(__props, { emit: __emit }) {
+    const loadingIcon = (color = "#4D80F0", reverse = true) => {
+      return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 42 42"><defs><linearGradient x1="100%" y1="0%" x2="0%" y2="0%" id="a"><stop stop-color="${reverse ? color : "#fff"}" offset="0%" stop-opacity="0"/><stop stop-color="${reverse ? color : "#fff"}" offset="100%"/></linearGradient></defs><g fill="none" fill-rule="evenodd"><path d="M21 1c11.046 0 20 8.954 20 20s-8.954 20-20 20S1 32.046 1 21 9.954 1 21 1zm0 7C13.82 8 8 13.82 8 21s5.82 13 13 13 13-5.82 13-13S28.18 8 21 8z" fill="${reverse ? "#fff" : color}"/><path d="M4.599 21c0 9.044 7.332 16.376 16.376 16.376 9.045 0 16.376-7.332 16.376-16.376" stroke="url(#a)" stroke-width="3.5" stroke-linecap="round"/></g></svg>`;
+    };
+    const props = __props;
+    const emit = __emit;
+    const hoverStartTime = common_vendor.ref(20);
+    const hoverStayTime = common_vendor.ref(70);
+    const loadingIconSvg = common_vendor.ref("");
+    const loadingStyle = common_vendor.computed(() => {
+      return `background-image: url(${loadingIconSvg.value});`;
+    });
+    common_vendor.watch(
+      () => props.loading,
+      () => {
+        buildLoadingSvg();
+      },
+      { deep: true, immediate: true }
+    );
+    function handleClick(event) {
+      if (!props.disabled && !props.loading) {
+        emit("click", event);
+      }
+    }
+    function handleGetAuthorize(event) {
+      if (props.scope === "phoneNumber") {
+        handleGetphonenumber(event);
+      } else if (props.scope === "userInfo") {
+        handleGetuserinfo(event);
+      }
+    }
+    function handleGetuserinfo(event) {
+      emit("getuserinfo", event.detail);
+    }
+    function handleConcat(event) {
+      emit("contact", event.detail);
+    }
+    function handleGetphonenumber(event) {
+      emit("getphonenumber", event.detail);
+    }
+    function handleError(event) {
+      emit("error", event.detail);
+    }
+    function handleLaunchapp(event) {
+      emit("launchapp", event.detail);
+    }
+    function handleOpensetting(event) {
+      emit("opensetting", event.detail);
+    }
+    function handleChooseavatar(event) {
+      emit("chooseavatar", event.detail);
+    }
+    function handleAgreePrivacyAuthorization(event) {
+      emit("agreeprivacyauthorization", event.detail);
+    }
+    function buildLoadingSvg() {
+      const { loadingColor, type, plain } = props;
+      let color = loadingColor;
+      if (!color) {
+        switch (type) {
+          case "primary":
+            color = "#4D80F0";
+            break;
+          case "success":
+            color = "#34d19d";
+            break;
+          case "info":
+            color = "#333";
+            break;
+          case "warning":
+            color = "#f0883a";
+            break;
+          case "error":
+            color = "#fa4350";
+            break;
+          case "default":
+            color = "#333";
+            break;
+        }
+      }
+      const svg = loadingIcon(color, !plain);
+      loadingIconSvg.value = `"data:image/svg+xml;base64,${common_vendor.encode(svg)}"`;
+    }
+    return (_ctx, _cache) => {
+      return common_vendor.e({
+        a: _ctx.loading
+      }, _ctx.loading ? {
+        b: common_vendor.s(loadingStyle.value)
+      } : _ctx.icon ? {
+        d: common_vendor.p({
+          ["custom-class"]: "wd-button__icon",
+          name: _ctx.icon,
+          classPrefix: _ctx.classPrefix
+        })
+      } : {}, {
+        c: _ctx.icon,
+        e: _ctx.buttonId,
+        f: `${_ctx.disabled || _ctx.loading ? "" : "wd-button--active"}`,
+        g: common_vendor.s(_ctx.customStyle),
+        h: common_vendor.n("is-" + _ctx.type),
+        i: common_vendor.n("is-" + _ctx.size),
+        j: common_vendor.n(_ctx.round ? "is-round" : ""),
+        k: common_vendor.n(_ctx.hairline ? "is-hairline" : ""),
+        l: common_vendor.n(_ctx.plain ? "is-plain" : ""),
+        m: common_vendor.n(_ctx.disabled ? "is-disabled" : ""),
+        n: common_vendor.n(_ctx.block ? "is-block" : ""),
+        o: common_vendor.n(_ctx.loading ? "is-loading" : ""),
+        p: common_vendor.n(_ctx.customClass),
+        q: hoverStartTime.value,
+        r: hoverStayTime.value,
+        s: _ctx.disabled || _ctx.loading ? void 0 : _ctx.openType,
+        t: _ctx.sendMessageTitle,
+        v: _ctx.sendMessagePath,
+        w: _ctx.sendMessageImg,
+        x: _ctx.appParameter,
+        y: _ctx.showMessageCard,
+        z: _ctx.sessionFrom,
+        A: _ctx.lang,
+        B: _ctx.hoverStopPropagation,
+        C: _ctx.scope,
+        D: common_vendor.o(handleClick),
+        E: common_vendor.o(handleGetAuthorize),
+        F: common_vendor.o(handleGetuserinfo),
+        G: common_vendor.o(handleConcat),
+        H: common_vendor.o(handleGetphonenumber),
+        I: common_vendor.o(handleError),
+        J: common_vendor.o(handleLaunchapp),
+        K: common_vendor.o(handleOpensetting),
+        L: common_vendor.o(handleChooseavatar),
+        M: common_vendor.o(handleAgreePrivacyAuthorization)
+      });
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-aa3a6253"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-button/wd-button.json

@@ -0,0 +1,6 @@
+{
+  "component": true,
+  "usingComponents": {
+    "wd-icon": "../wd-icon/wd-icon"
+  }
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-button/wd-button.wxml

@@ -0,0 +1 @@
+<button id="{{e}}" hover-class="{{f}}" style="{{g}}" class="{{['data-v-aa3a6253', 'wd-button', h, i, j, k, l, m, n, o, p]}}" hover-start-time="{{q}}" hover-stay-time="{{r}}" open-type="{{s}}" send-message-title="{{t}}" send-message-path="{{v}}" send-message-img="{{w}}" app-parameter="{{x}}" show-message-card="{{y}}" session-from="{{z}}" lang="{{A}}" hover-stop-propagation="{{B}}" scope="{{C}}" bindtap="{{D}}" bindgetAuthorize="{{E}}" bindgetuserinfo="{{F}}" bindcontact="{{G}}" bindgetphonenumber="{{H}}" binderror="{{I}}" bindlaunchapp="{{J}}" bindopensetting="{{K}}" bindchooseavatar="{{L}}" bindagreeprivacyauthorization="{{M}}"><view class="wd-button__content data-v-aa3a6253"><view wx:if="{{a}}" class="wd-button__loading data-v-aa3a6253"><view class="wd-button__loading-svg data-v-aa3a6253" style="{{b}}"></view></view><wd-icon wx:elif="{{c}}" class="data-v-aa3a6253" u-i="aa3a6253-0" bind:__l="__l" u-p="{{d}}"></wd-icon><view class="wd-button__text data-v-aa3a6253"><slot/></view></view></button>

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-button/wd-button.wxss

@@ -0,0 +1,455 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+/**
+ * 混合宏
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+  * BEM，定义块（b)
+  */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 此方法用于生成穿透样式 */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 定义状态（m） */
+/* 定义状态（m） */
+/* 对于需要需要嵌套在 m 底下的 e，调用这个混合宏，一般在切换整个组件的状态，如切换颜色的时候 */
+/* 状态，生成 is-$state 类名 */
+/**
+  * 常用混合宏
+  */
+/* 单行超出隐藏 */
+/* 多行超出隐藏 */
+/* 清除浮动 */
+/* 0.5px 边框 指定方向*/
+/* 0.5px 边框 环绕 */
+/**
+  * 三角形实现尖角样式，适用于背景透明情况
+  * @param $size 三角形高，底边为 $size * 2
+  * @param $bg 三角形背景颜色
+  */
+/**
+  * 正方形实现尖角样式，适用于背景不透明情况
+  * @param $size 正方形边长
+  * @param $bg 正方形背景颜色
+  * @param $z-index z-index属性值，不得大于外部包裹器
+  * @param $box-shadow 阴影
+*/
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+ * UI规范基础变量
+ */
+/*----------------------------------------- Theme color. start ----------------------------------------*/
+/* 主题颜色 */
+/* 辅助色 */
+/* 文字颜色（默认浅色背景下 */
+/* 暗黑模式 */
+/* 图形颜色 */
+/*----------------------------------------- Theme color. end -------------------------------------------*/
+/*-------------------------------- Theme color application size.  start --------------------------------*/
+/* 文字字号 */
+/* 文字字重 */
+/* 尺寸 */
+/*-------------------------------- Theme color application size.  end --------------------------------*/
+/* component var */
+/* action-sheet */
+/* badge */
+/* button */
+/* cell */
+/* calendar */
+/* checkbox */
+/* collapse */
+/* divider */
+/* drop-menu */
+/* input-number */
+/* input */
+/* textarea */
+/* loadmore */
+/* message-box */
+/* notice-bar */
+/* pagination */
+/* picker */
+/* col-picker */
+/* overlay */
+/* popup */
+/* progress */
+/* radio */
+/* search */
+/* slider */
+/* sort-button */
+/* steps */
+/* switch */
+/* tabs */
+/* tag */
+/* toast */
+/* loading */
+/* tooltip */
+/* popover */
+/* grid-item */
+/* statustip */
+/* card */
+/* upload */
+/* curtain */
+/* notify */
+/* skeleton */
+/* circle */
+/* swiper */
+/* swiper-nav */
+/* segmented */
+/* tabbar */
+/* tabbar-item */
+/* navbar */
+/* navbar-capsule */
+/* table */
+/* sidebar */
+/* sidebar-item */
+/* fab */
+/* count-down */
+/* keyboard */
+/* number-keyboard */
+/* passwod-input */
+/* form-item */
+/* backtop */
+/* index-bar */
+/* text */
+/* video-preview */
+/* img-cropper */
+/* floating-panel */
+/* signature */
+.wot-theme-dark .wd-button.is-info.data-v-aa3a6253 {
+  background: var(--wot-dark-background4, #323233);
+  color: var(--wot-dark-color3, rgba(232, 230, 227, 0.8));
+}
+.wot-theme-dark .wd-button.is-plain.data-v-aa3a6253 {
+  background: transparent;
+}
+.wot-theme-dark .wd-button.is-plain.is-info.data-v-aa3a6253 {
+  color: var(--wot-dark-color, var(--wot-color-white, rgb(255, 255, 255)));
+}
+.wot-theme-dark .wd-button.is-plain.is-info.data-v-aa3a6253::after {
+  border-color: var(--wot-dark-background5, #646566);
+}
+.wot-theme-dark .wd-button.is-text.is-disabled.data-v-aa3a6253 {
+  color: var(--wot-dark-color-gray, var(--wot-color-secondary, #595959));
+  background: transparent;
+}
+.wot-theme-dark .wd-button.is-icon.data-v-aa3a6253 {
+  color: var(--wot-dark-color, var(--wot-color-white, rgb(255, 255, 255)));
+}
+.wot-theme-dark .wd-button.is-icon.is-disabled.data-v-aa3a6253 {
+  color: var(--wot-dark-color-gray, var(--wot-color-secondary, #595959));
+  background: transparent;
+}
+.wd-button.data-v-aa3a6253 {
+  margin-left: initial;
+  margin-right: initial;
+  position: relative;
+  display: inline-block;
+  outline: none;
+  -webkit-appearance: none;
+  outline: none;
+  background: transparent;
+  box-sizing: border-box;
+  border: none;
+  border-radius: 0;
+  color: var(--wot-button-normal-color, var(--wot-color-title, var(--wot-color-black, rgb(0, 0, 0))));
+  transition: opacity 0.2s;
+  -webkit-user-select: none;
+     -moz-user-select: none;
+          user-select: none;
+  font-weight: normal;
+}
+.wd-button.data-v-aa3a6253::before {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  width: 100%;
+  height: 100%;
+  background: var(--wot-color-black, rgb(0, 0, 0));
+  border: inherit;
+  border-color: var(--wot-color-black, rgb(0, 0, 0));
+  border-radius: inherit;
+  transform: translate(-50%, -50%);
+  opacity: 0;
+  content: " ";
+}
+.wd-button.data-v-aa3a6253::after {
+  border: none;
+  border-radius: 0;
+}
+.wd-button__content.data-v-aa3a6253 {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  height: 100%;
+}
+.wd-button--active.data-v-aa3a6253:active::before {
+  opacity: 0.15;
+}
+.wd-button.is-disabled.data-v-aa3a6253 {
+  opacity: var(--wot-button-disabled-opacity, 0.6);
+}
+.wd-button__loading.data-v-aa3a6253 {
+  margin-right: 5px;
+  animation: wd-rotate-aa3a6253 0.8s linear infinite;
+  animation-duration: 2s;
+}
+.wd-button__loading-svg.data-v-aa3a6253 {
+  width: 100%;
+  height: 100%;
+  background-size: cover;
+  background-repeat: no-repeat;
+}
+.wd-button.is-primary.data-v-aa3a6253 {
+  background: var(--wot-button-primary-bg-color, var(--wot-color-theme, #4d80f0));
+  color: var(--wot-button-primary-color, var(--wot-color-white, rgb(255, 255, 255)));
+}
+.wd-button.is-success.data-v-aa3a6253 {
+  background: var(--wot-button-success-bg-color, var(--wot-color-success, #34d19d));
+  color: var(--wot-button-success-color, var(--wot-color-white, rgb(255, 255, 255)));
+}
+.wd-button.is-info.data-v-aa3a6253 {
+  background: var(--wot-button-info-bg-color, #f0f0f0);
+  color: var(--wot-button-info-color, var(--wot-color-title, var(--wot-color-black, rgb(0, 0, 0))));
+}
+.wd-button.is-warning.data-v-aa3a6253 {
+  background: var(--wot-button-warning-bg-color, var(--wot-color-warning, #f0883a));
+  color: var(--wot-button-warning-color, var(--wot-color-white, rgb(255, 255, 255)));
+}
+.wd-button.is-error.data-v-aa3a6253 {
+  background: var(--wot-button-error-bg-color, var(--wot-color-danger, #fa4350));
+  color: var(--wot-button-error-color, var(--wot-color-white, rgb(255, 255, 255)));
+}
+.wd-button.is-small.data-v-aa3a6253 {
+  height: var(--wot-button-small-height, 28px);
+  padding: var(--wot-button-small-padding, 0 12px);
+  border-radius: var(--wot-button-small-radius, 2px);
+  font-size: var(--wot-button-small-fs, var(--wot-fs-secondary, 12px));
+  font-weight: normal;
+}
+.wd-button.is-small .wd-button__loading.data-v-aa3a6253 {
+  width: var(--wot-button-small-loading, 14px);
+  height: var(--wot-button-small-loading, 14px);
+}
+.wd-button.is-medium.data-v-aa3a6253 {
+  height: var(--wot-button-medium-height, 36px);
+  padding: var(--wot-button-medium-padding, 0 16px);
+  border-radius: var(--wot-button-medium-radius, 4px);
+  font-size: var(--wot-button-medium-fs, var(--wot-fs-content, 14px));
+  min-width: 120px;
+}
+.wd-button.is-medium.is-round.is-icon.data-v-aa3a6253 {
+  min-width: 0;
+  border-radius: 50%;
+}
+.wd-button.is-medium.is-round.is-text.data-v-aa3a6253 {
+  border-radius: 0;
+  min-width: 0;
+}
+.wd-button.is-medium .wd-button__loading.data-v-aa3a6253 {
+  width: var(--wot-button-medium-loading, 18px);
+  height: var(--wot-button-medium-loading, 18px);
+}
+.wd-button.is-large.data-v-aa3a6253 {
+  height: var(--wot-button-large-height, 44px);
+  padding: var(--wot-button-large-padding, 0 36px);
+  border-radius: var(--wot-button-large-radius, 8px);
+  font-size: var(--wot-button-large-fs, var(--wot-fs-title, 16px));
+}
+.wd-button.is-large.data-v-aa3a6253::after {
+  border-radius: var(--wot-button-large-radius, 8px);
+}
+.wd-button.is-large .wd-button__loading.data-v-aa3a6253 {
+  width: var(--wot-button-large-loading, 24px);
+  height: var(--wot-button-large-loading, 24px);
+}
+.wd-button.is-round.data-v-aa3a6253 {
+  border-radius: 999px;
+}
+.wd-button.is-text.data-v-aa3a6253 {
+  color: var(--wot-button-primary-bg-color, var(--wot-color-theme, #4d80f0));
+  min-width: 0;
+  padding: 4px 0;
+}
+.wd-button.is-text.data-v-aa3a6253::after {
+  display: none;
+}
+.wd-button.is-text.wd-button--active.data-v-aa3a6253 {
+  opacity: var(--wot-button-text-hover-opacity, 0.7);
+}
+.wd-button.is-text.wd-button--active.data-v-aa3a6253:active::before {
+  display: none;
+}
+.wd-button.is-text.is-disabled.data-v-aa3a6253 {
+  color: var(--wot-button-normal-disabled-color, rgba(0, 0, 0, 0.25));
+  background: transparent;
+}
+.wd-button.is-plain.data-v-aa3a6253 {
+  background: var(--wot-button-plain-bg-color, var(--wot-color-white, rgb(255, 255, 255)));
+  border: 1px solid currentColor;
+}
+.wd-button.is-plain.is-primary.data-v-aa3a6253 {
+  color: var(--wot-button-primary-bg-color, var(--wot-color-theme, #4d80f0));
+}
+.wd-button.is-plain.is-success.data-v-aa3a6253 {
+  color: var(--wot-button-success-bg-color, var(--wot-color-success, #34d19d));
+}
+.wd-button.is-plain.is-info.data-v-aa3a6253 {
+  color: var(--wot-button-info-plain-normal-color, rgba(0, 0, 0, 0.85));
+  border-color: var(--wot-button-info-plain-border-color, rgba(0, 0, 0, 0.45));
+}
+.wd-button.is-plain.is-warning.data-v-aa3a6253 {
+  color: var(--wot-button-warning-bg-color, var(--wot-color-warning, #f0883a));
+}
+.wd-button.is-plain.is-error.data-v-aa3a6253 {
+  color: var(--wot-button-error-bg-color, var(--wot-color-danger, #fa4350));
+}
+.wd-button.is-hairline.data-v-aa3a6253 {
+  border-width: 0;
+}
+.wd-button.is-hairline.is-plain.data-v-aa3a6253 {
+  position: relative;
+}
+.wd-button.is-hairline.is-plain.data-v-aa3a6253::after {
+  position: absolute;
+  display: block;
+  content: " ";
+  pointer-events: none;
+  width: 200%;
+  height: 200%;
+  left: 0;
+  top: 0;
+  border: 1px solid var(--wot-color-border-light, #e8e8e8);
+  transform: scale(0.5);
+  box-sizing: border-box;
+  transform-origin: left top;
+}
+.wd-button.is-hairline.is-plain.data-v-aa3a6253::before {
+  border-radius: inherit;
+}
+.wd-button.is-hairline.is-plain.data-v-aa3a6253::after {
+  border-color: inherit;
+}
+.wd-button.is-hairline.is-plain.is-round.data-v-aa3a6253::after {
+  border-radius: inherit !important;
+}
+.wd-button.is-hairline.is-plain.is-large.data-v-aa3a6253::after {
+  border-radius: calc(2 * var(--wot-button-large-radius, 8px));
+}
+.wd-button.is-hairline.is-plain.is-medium.data-v-aa3a6253::after {
+  border-radius: calc(2 * var(--wot-button-medium-radius, 4px));
+}
+.wd-button.is-hairline.is-plain.is-small.data-v-aa3a6253::after {
+  border-radius: calc(2 * var(--wot-button-small-radius, 2px));
+}
+.wd-button.is-block.data-v-aa3a6253 {
+  display: block;
+}
+.wd-button.is-icon.data-v-aa3a6253 {
+  width: var(--wot-button-icon-size, 40px);
+  height: var(--wot-button-icon-size, 40px);
+  padding: 0;
+  border-radius: 50%;
+  color: var(--wot-button-icon-color, rgba(0, 0, 0, 0.65));
+}
+.wd-button.is-icon.data-v-aa3a6253::after {
+  display: none;
+}
+.wd-button.is-icon.data-v-aa3a6253 .wd-button__icon {
+  margin-right: 0;
+}
+.wd-button.is-icon.is-disabled.data-v-aa3a6253 {
+  color: var(--wot-button-icon-disabled-color, var(--wot-color-icon-disabled, #a7a7a7));
+  background: transparent;
+}
+.data-v-aa3a6253  .wd-button__icon {
+  display: block;
+  margin-right: 6px;
+  font-size: var(--wot-button-icon-fs, 1.18em);
+  vertical-align: middle;
+}
+.wd-button__text.data-v-aa3a6253 {
+  -webkit-user-select: none;
+     -moz-user-select: none;
+          user-select: none;
+  white-space: nowrap;
+}
+@keyframes wd-rotate-aa3a6253 {
+from {
+    transform: rotate(0deg);
+}
+to {
+    transform: rotate(360deg);
+}
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-gap/wd-gap.js

@@ -0,0 +1,35 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+const __default__ = {
+  name: "wd-gap",
+  options: {
+    addGlobalClass: true,
+    virtualHost: true,
+    styleIsolation: "shared"
+  }
+};
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  ...__default__,
+  props: common_vendor.gapProps,
+  setup(__props) {
+    const props = __props;
+    const rootStyle = common_vendor.computed(() => {
+      const rootStyle2 = {};
+      if (common_vendor.isDef(props.bgColor)) {
+        rootStyle2["background"] = props.bgColor;
+      }
+      if (common_vendor.isDef(props.height)) {
+        rootStyle2["height"] = common_vendor.addUnit(props.height);
+      }
+      return `${common_vendor.objToStyle(rootStyle2)}${props.customStyle}`;
+    });
+    return (_ctx, _cache) => {
+      return {
+        a: common_vendor.n(`wd-gap ${_ctx.safeAreaBottom ? "wd-gap--safe" : ""} ${_ctx.customClass}`),
+        b: common_vendor.s(rootStyle.value)
+      };
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-a388563b"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-gap/wd-gap.json

@@ -0,0 +1,4 @@
+{
+  "component": true,
+  "usingComponents": {}
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-gap/wd-gap.wxml

@@ -0,0 +1 @@
+<view class="{{['data-v-a388563b', a]}}" style="{{b}}"></view>

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-gap/wd-gap.wxss

@@ -0,0 +1,193 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+ * UI规范基础变量
+ */
+/*----------------------------------------- Theme color. start ----------------------------------------*/
+/* 主题颜色 */
+/* 辅助色 */
+/* 文字颜色（默认浅色背景下 */
+/* 暗黑模式 */
+/* 图形颜色 */
+/*----------------------------------------- Theme color. end -------------------------------------------*/
+/*-------------------------------- Theme color application size.  start --------------------------------*/
+/* 文字字号 */
+/* 文字字重 */
+/* 尺寸 */
+/*-------------------------------- Theme color application size.  end --------------------------------*/
+/* component var */
+/* action-sheet */
+/* badge */
+/* button */
+/* cell */
+/* calendar */
+/* checkbox */
+/* collapse */
+/* divider */
+/* drop-menu */
+/* input-number */
+/* input */
+/* textarea */
+/* loadmore */
+/* message-box */
+/* notice-bar */
+/* pagination */
+/* picker */
+/* col-picker */
+/* overlay */
+/* popup */
+/* progress */
+/* radio */
+/* search */
+/* slider */
+/* sort-button */
+/* steps */
+/* switch */
+/* tabs */
+/* tag */
+/* toast */
+/* loading */
+/* tooltip */
+/* popover */
+/* grid-item */
+/* statustip */
+/* card */
+/* upload */
+/* curtain */
+/* notify */
+/* skeleton */
+/* circle */
+/* swiper */
+/* swiper-nav */
+/* segmented */
+/* tabbar */
+/* tabbar-item */
+/* navbar */
+/* navbar-capsule */
+/* table */
+/* sidebar */
+/* sidebar-item */
+/* fab */
+/* count-down */
+/* keyboard */
+/* number-keyboard */
+/* passwod-input */
+/* form-item */
+/* backtop */
+/* index-bar */
+/* text */
+/* video-preview */
+/* img-cropper */
+/* floating-panel */
+/* signature */
+/**
+ * 混合宏
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+  * BEM，定义块（b)
+  */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 此方法用于生成穿透样式 */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 定义状态（m） */
+/* 定义状态（m） */
+/* 对于需要需要嵌套在 m 底下的 e，调用这个混合宏，一般在切换整个组件的状态，如切换颜色的时候 */
+/* 状态，生成 is-$state 类名 */
+/**
+  * 常用混合宏
+  */
+/* 单行超出隐藏 */
+/* 多行超出隐藏 */
+/* 清除浮动 */
+/* 0.5px 边框 指定方向*/
+/* 0.5px 边框 环绕 */
+/**
+  * 三角形实现尖角样式，适用于背景透明情况
+  * @param $size 三角形高，底边为 $size * 2
+  * @param $bg 三角形背景颜色
+  */
+/**
+  * 正方形实现尖角样式，适用于背景不透明情况
+  * @param $size 正方形边长
+  * @param $bg 正方形背景颜色
+  * @param $z-index z-index属性值，不得大于外部包裹器
+  * @param $box-shadow 阴影
+*/
+.wd-gap--safe.data-v-a388563b {
+  padding-bottom: constant(safe-area-inset-bottom);
+  padding-bottom: env(safe-area-inset-bottom);
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-icon/wd-icon.js

@@ -0,0 +1,52 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+const __default__ = {
+  name: "wd-icon",
+  options: {
+    virtualHost: true,
+    addGlobalClass: true,
+    styleIsolation: "shared"
+  }
+};
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  ...__default__,
+  props: common_vendor.iconProps,
+  emits: ["click", "touch"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const isImage = common_vendor.computed(() => {
+      return common_vendor.isDef(props.name) && props.name.includes("/");
+    });
+    const rootClass = common_vendor.computed(() => {
+      const prefix = props.classPrefix;
+      return `${prefix} ${props.customClass} ${isImage.value ? "wd-icon--image" : prefix + "-" + props.name}`;
+    });
+    const rootStyle = common_vendor.computed(() => {
+      const style = {};
+      if (props.color) {
+        style["color"] = props.color;
+      }
+      if (props.size) {
+        style["font-size"] = common_vendor.addUnit(props.size);
+      }
+      return `${common_vendor.objToStyle(style)} ${props.customStyle}`;
+    });
+    function handleClick(event) {
+      emit("click", event);
+    }
+    return (_ctx, _cache) => {
+      return common_vendor.e({
+        a: isImage.value
+      }, isImage.value ? {
+        b: _ctx.name
+      } : {}, {
+        c: common_vendor.o(handleClick),
+        d: common_vendor.n(rootClass.value),
+        e: common_vendor.s(rootStyle.value)
+      });
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-d4a8410a"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-icon/wd-icon.json

@@ -0,0 +1,4 @@
+{
+  "component": true,
+  "usingComponents": {}
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-icon/wd-icon.wxml

@@ -0,0 +1 @@
+<view bindtap="{{c}}" class="{{['data-v-d4a8410a', d]}}" style="{{e}}"><image wx:if="{{a}}" class="wd-icon__image data-v-d4a8410a" src="{{b}}"></image></view>

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-icon/wd-icon.wxss

@@ -0,0 +1,1099 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+ * UI规范基础变量
+ */
+/*----------------------------------------- Theme color. start ----------------------------------------*/
+/* 主题颜色 */
+/* 辅助色 */
+/* 文字颜色（默认浅色背景下 */
+/* 暗黑模式 */
+/* 图形颜色 */
+/*----------------------------------------- Theme color. end -------------------------------------------*/
+/*-------------------------------- Theme color application size.  start --------------------------------*/
+/* 文字字号 */
+/* 文字字重 */
+/* 尺寸 */
+/*-------------------------------- Theme color application size.  end --------------------------------*/
+/* component var */
+/* action-sheet */
+/* badge */
+/* button */
+/* cell */
+/* calendar */
+/* checkbox */
+/* collapse */
+/* divider */
+/* drop-menu */
+/* input-number */
+/* input */
+/* textarea */
+/* loadmore */
+/* message-box */
+/* notice-bar */
+/* pagination */
+/* picker */
+/* col-picker */
+/* overlay */
+/* popup */
+/* progress */
+/* radio */
+/* search */
+/* slider */
+/* sort-button */
+/* steps */
+/* switch */
+/* tabs */
+/* tag */
+/* toast */
+/* loading */
+/* tooltip */
+/* popover */
+/* grid-item */
+/* statustip */
+/* card */
+/* upload */
+/* curtain */
+/* notify */
+/* skeleton */
+/* circle */
+/* swiper */
+/* swiper-nav */
+/* segmented */
+/* tabbar */
+/* tabbar-item */
+/* navbar */
+/* navbar-capsule */
+/* table */
+/* sidebar */
+/* sidebar-item */
+/* fab */
+/* count-down */
+/* keyboard */
+/* number-keyboard */
+/* passwod-input */
+/* form-item */
+/* backtop */
+/* index-bar */
+/* text */
+/* video-preview */
+/* img-cropper */
+/* floating-panel */
+/* signature */
+/**
+ * 混合宏
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+  * BEM，定义块（b)
+  */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 此方法用于生成穿透样式 */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 定义状态（m） */
+/* 定义状态（m） */
+/* 对于需要需要嵌套在 m 底下的 e，调用这个混合宏，一般在切换整个组件的状态，如切换颜色的时候 */
+/* 状态，生成 is-$state 类名 */
+/**
+  * 常用混合宏
+  */
+/* 单行超出隐藏 */
+/* 多行超出隐藏 */
+/* 清除浮动 */
+/* 0.5px 边框 指定方向*/
+/* 0.5px 边框 环绕 */
+/**
+  * 三角形实现尖角样式，适用于背景透明情况
+  * @param $size 三角形高，底边为 $size * 2
+  * @param $bg 三角形背景颜色
+  */
+/**
+  * 正方形实现尖角样式，适用于背景不透明情况
+  * @param $size 正方形边长
+  * @param $bg 正方形背景颜色
+  * @param $z-index z-index属性值，不得大于外部包裹器
+  * @param $box-shadow 阴影
+*/
+@font-face {
+  font-family: "wd-icons";
+  src: url("https://at.alicdn.com/t/c/font_4245058_s5cpwl25n7o.woff2?t=1696817709651") format("woff2"), url("https://at.alicdn.com/t/c/font_4245058_s5cpwl25n7o.woff?t=1696817709651") format("woff"), url("https://at.alicdn.com/t/c/font_4245058_s5cpwl25n7o.ttf?t=1696817709651") format("truetype");
+  font-weight: normal;
+  font-style: normal;
+}
+.wd-icon.data-v-d4a8410a {
+  display: inline-block;
+  font-family: "wd-icons" !important;
+  font-style: normal;
+  font-weight: normal;
+  font-variant: normal;
+  text-transform: none;
+  /* Better Font Rendering =========== */
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+.wd-icon--image.data-v-d4a8410a {
+  width: 1em;
+  height: 1em;
+}
+.wd-icon__image.data-v-d4a8410a {
+  width: 100%;
+  height: 100%;
+}
+.wd-icon-usergroup-clear.data-v-d4a8410a:before {
+  content: "\e739";
+}
+.wd-icon-user-circle.data-v-d4a8410a:before {
+  content: "\e73a";
+}
+.wd-icon-user-talk.data-v-d4a8410a:before {
+  content: "\e73b";
+}
+.wd-icon-user-clear.data-v-d4a8410a:before {
+  content: "\e73c";
+}
+.wd-icon-user.data-v-d4a8410a:before {
+  content: "\e73d";
+}
+.wd-icon-usergroup-add.data-v-d4a8410a:before {
+  content: "\e73e";
+}
+.wd-icon-usergroup.data-v-d4a8410a:before {
+  content: "\e73f";
+}
+.wd-icon-user-add.data-v-d4a8410a:before {
+  content: "\e740";
+}
+.wd-icon-user-avatar.data-v-d4a8410a:before {
+  content: "\e741";
+}
+.wd-icon-pointing-hand.data-v-d4a8410a:before {
+  content: "\e742";
+}
+.wd-icon-cursor.data-v-d4a8410a:before {
+  content: "\e743";
+}
+.wd-icon-fullsreen.data-v-d4a8410a:before {
+  content: "\e72c";
+}
+.wd-icon-cloud-download.data-v-d4a8410a:before {
+  content: "\e72d";
+}
+.wd-icon-chevron-down-rectangle.data-v-d4a8410a:before {
+  content: "\e72e";
+}
+.wd-icon-edit.data-v-d4a8410a:before {
+  content: "\e72f";
+}
+.wd-icon-fullscreen-exit.data-v-d4a8410a:before {
+  content: "\e730";
+}
+.wd-icon-circle1.data-v-d4a8410a:before {
+  content: "\e731";
+}
+.wd-icon-close-normal.data-v-d4a8410a:before {
+  content: "\e732";
+}
+.wd-icon-browse.data-v-d4a8410a:before {
+  content: "\e733";
+}
+.wd-icon-browse-off.data-v-d4a8410a:before {
+  content: "\e734";
+}
+.wd-icon-chevron-up-rectangle.data-v-d4a8410a:before {
+  content: "\e735";
+}
+.wd-icon-add-rectangle.data-v-d4a8410a:before {
+  content: "\e736";
+}
+.wd-icon-add1.data-v-d4a8410a:before {
+  content: "\e737";
+}
+.wd-icon-add-circle1.data-v-d4a8410a:before {
+  content: "\e738";
+}
+.wd-icon-download1.data-v-d4a8410a:before {
+  content: "\e71c";
+}
+.wd-icon-link.data-v-d4a8410a:before {
+  content: "\e71d";
+}
+.wd-icon-edit-1.data-v-d4a8410a:before {
+  content: "\e71e";
+}
+.wd-icon-jump.data-v-d4a8410a:before {
+  content: "\e71f";
+}
+.wd-icon-chevron-down-circle.data-v-d4a8410a:before {
+  content: "\e720";
+}
+.wd-icon-delete1.data-v-d4a8410a:before {
+  content: "\e721";
+}
+.wd-icon-filter-clear.data-v-d4a8410a:before {
+  content: "\e722";
+}
+.wd-icon-check-rectangle-filled.data-v-d4a8410a:before {
+  content: "\e723";
+}
+.wd-icon-minus-circle-filled.data-v-d4a8410a:before {
+  content: "\e724";
+}
+.wd-icon-play.data-v-d4a8410a:before {
+  content: "\e725";
+}
+.wd-icon-pause-circle-filled.data-v-d4a8410a:before {
+  content: "\e726";
+}
+.wd-icon-filter1.data-v-d4a8410a:before {
+  content: "\e727";
+}
+.wd-icon-move.data-v-d4a8410a:before {
+  content: "\e728";
+}
+.wd-icon-login.data-v-d4a8410a:before {
+  content: "\e729";
+}
+.wd-icon-minus-circle.data-v-d4a8410a:before {
+  content: "\e72a";
+}
+.wd-icon-close-circle.data-v-d4a8410a:before {
+  content: "\e72b";
+}
+.wd-icon-logout.data-v-d4a8410a:before {
+  content: "\e70b";
+}
+.wd-icon-search1.data-v-d4a8410a:before {
+  content: "\e70c";
+}
+.wd-icon-pause-circle.data-v-d4a8410a:before {
+  content: "\e70d";
+}
+.wd-icon-play-circle.data-v-d4a8410a:before {
+  content: "\e70e";
+}
+.wd-icon-more1.data-v-d4a8410a:before {
+  content: "\e70f";
+}
+.wd-icon-minus-rectangle.data-v-d4a8410a:before {
+  content: "\e710";
+}
+.wd-icon-stop.data-v-d4a8410a:before {
+  content: "\e711";
+}
+.wd-icon-scan1.data-v-d4a8410a:before {
+  content: "\e712";
+}
+.wd-icon-close-rectangle.data-v-d4a8410a:before {
+  content: "\e713";
+}
+.wd-icon-rollback.data-v-d4a8410a:before {
+  content: "\e714";
+}
+.wd-icon-a-order-adjustmentcolumn.data-v-d4a8410a:before {
+  content: "\e715";
+}
+.wd-icon-pause.data-v-d4a8410a:before {
+  content: "\e716";
+}
+.wd-icon-ellipsis.data-v-d4a8410a:before {
+  content: "\e717";
+}
+.wd-icon-cloud-upload.data-v-d4a8410a:before {
+  content: "\e718";
+}
+.wd-icon-stop-circle-filled.data-v-d4a8410a:before {
+  content: "\e719";
+}
+.wd-icon-clear.data-v-d4a8410a:before {
+  content: "\e71a";
+}
+.wd-icon-remove.data-v-d4a8410a:before {
+  content: "\e71b";
+}
+.wd-icon-zoom-out.data-v-d4a8410a:before {
+  content: "\e6fb";
+}
+.wd-icon-thumb-down.data-v-d4a8410a:before {
+  content: "\e6fc";
+}
+.wd-icon-setting1.data-v-d4a8410a:before {
+  content: "\e6fd";
+}
+.wd-icon-save.data-v-d4a8410a:before {
+  content: "\e6fe";
+}
+.wd-icon-unfold-more.data-v-d4a8410a:before {
+  content: "\e6ff";
+}
+.wd-icon-zoom-in.data-v-d4a8410a:before {
+  content: "\e700";
+}
+.wd-icon-thumb-up.data-v-d4a8410a:before {
+  content: "\e701";
+}
+.wd-icon-unfold-less.data-v-d4a8410a:before {
+  content: "\e702";
+}
+.wd-icon-play-circle-filled.data-v-d4a8410a:before {
+  content: "\e703";
+}
+.wd-icon-poweroff.data-v-d4a8410a:before {
+  content: "\e704";
+}
+.wd-icon-share.data-v-d4a8410a:before {
+  content: "\e705";
+}
+.wd-icon-refresh1.data-v-d4a8410a:before {
+  content: "\e706";
+}
+.wd-icon-link-unlink.data-v-d4a8410a:before {
+  content: "\e707";
+}
+.wd-icon-upload.data-v-d4a8410a:before {
+  content: "\e708";
+}
+.wd-icon-rectangle.data-v-d4a8410a:before {
+  content: "\e709";
+}
+.wd-icon-stop-circle.data-v-d4a8410a:before {
+  content: "\e70a";
+}
+.wd-icon-backtop-rectangle.data-v-d4a8410a:before {
+  content: "\e6ea";
+}
+.wd-icon-caret-down.data-v-d4a8410a:before {
+  content: "\e6eb";
+}
+.wd-icon-arrow-left1.data-v-d4a8410a:before {
+  content: "\e6ec";
+}
+.wd-icon-help-circle.data-v-d4a8410a:before {
+  content: "\e6ed";
+}
+.wd-icon-help-circle-filled.data-v-d4a8410a:before {
+  content: "\e6ee";
+}
+.wd-icon-time-filled.data-v-d4a8410a:before {
+  content: "\e6ef";
+}
+.wd-icon-close-circle-filled.data-v-d4a8410a:before {
+  content: "\e6f0";
+}
+.wd-icon-info-circle.data-v-d4a8410a:before {
+  content: "\e6f1";
+}
+.wd-icon-info-circle-filled.data-v-d4a8410a:before {
+  content: "\e6f2";
+}
+.wd-icon-check1.data-v-d4a8410a:before {
+  content: "\e6f3";
+}
+.wd-icon-help.data-v-d4a8410a:before {
+  content: "\e6f4";
+}
+.wd-icon-error.data-v-d4a8410a:before {
+  content: "\e6f5";
+}
+.wd-icon-check-circle.data-v-d4a8410a:before {
+  content: "\e6f6";
+}
+.wd-icon-error-circle-filled.data-v-d4a8410a:before {
+  content: "\e6f7";
+}
+.wd-icon-error-circle.data-v-d4a8410a:before {
+  content: "\e6f8";
+}
+.wd-icon-check-rectangle.data-v-d4a8410a:before {
+  content: "\e6f9";
+}
+.wd-icon-check-circle-filled.data-v-d4a8410a:before {
+  content: "\e6fa";
+}
+.wd-icon-chevron-up.data-v-d4a8410a:before {
+  content: "\e6da";
+}
+.wd-icon-chevron-up-circle.data-v-d4a8410a:before {
+  content: "\e6db";
+}
+.wd-icon-chevron-right.data-v-d4a8410a:before {
+  content: "\e6dc";
+}
+.wd-icon-arrow-down-rectangle.data-v-d4a8410a:before {
+  content: "\e6dd";
+}
+.wd-icon-caret-up-small.data-v-d4a8410a:before {
+  content: "\e6de";
+}
+.wd-icon-chevron-right-rectangle.data-v-d4a8410a:before {
+  content: "\e6df";
+}
+.wd-icon-caret-right-small.data-v-d4a8410a:before {
+  content: "\e6e0";
+}
+.wd-icon-arrow-right1.data-v-d4a8410a:before {
+  content: "\e6e1";
+}
+.wd-icon-backtop.data-v-d4a8410a:before {
+  content: "\e6e2";
+}
+.wd-icon-arrow-up1.data-v-d4a8410a:before {
+  content: "\e6e3";
+}
+.wd-icon-caret-up.data-v-d4a8410a:before {
+  content: "\e6e4";
+}
+.wd-icon-backward.data-v-d4a8410a:before {
+  content: "\e6e5";
+}
+.wd-icon-arrow-down1.data-v-d4a8410a:before {
+  content: "\e6e6";
+}
+.wd-icon-chevron-left.data-v-d4a8410a:before {
+  content: "\e6e7";
+}
+.wd-icon-caret-right.data-v-d4a8410a:before {
+  content: "\e6e8";
+}
+.wd-icon-caret-left.data-v-d4a8410a:before {
+  content: "\e6e9";
+}
+.wd-icon-page-last.data-v-d4a8410a:before {
+  content: "\e6c9";
+}
+.wd-icon-next.data-v-d4a8410a:before {
+  content: "\e6ca";
+}
+.wd-icon-swap.data-v-d4a8410a:before {
+  content: "\e6cb";
+}
+.wd-icon-round.data-v-d4a8410a:before {
+  content: "\e6cc";
+}
+.wd-icon-previous.data-v-d4a8410a:before {
+  content: "\e6cd";
+}
+.wd-icon-enter.data-v-d4a8410a:before {
+  content: "\e6ce";
+}
+.wd-icon-chevron-down.data-v-d4a8410a:before {
+  content: "\e6cf";
+}
+.wd-icon-caret-down-small.data-v-d4a8410a:before {
+  content: "\e6d0";
+}
+.wd-icon-swap-right.data-v-d4a8410a:before {
+  content: "\e6d1";
+}
+.wd-icon-chevron-left-circle.data-v-d4a8410a:before {
+  content: "\e6d2";
+}
+.wd-icon-caret-left-small.data-v-d4a8410a:before {
+  content: "\e6d3";
+}
+.wd-icon-chevron-right-circle.data-v-d4a8410a:before {
+  content: "\e6d4";
+}
+.wd-icon-a-chevron-leftdouble.data-v-d4a8410a:before {
+  content: "\e6d5";
+}
+.wd-icon-chevron-left-rectangle.data-v-d4a8410a:before {
+  content: "\e6d6";
+}
+.wd-icon-a-chevron-rightdouble.data-v-d4a8410a:before {
+  content: "\e6d7";
+}
+.wd-icon-page-first.data-v-d4a8410a:before {
+  content: "\e6d8";
+}
+.wd-icon-forward.data-v-d4a8410a:before {
+  content: "\e6d9";
+}
+.wd-icon-view-column.data-v-d4a8410a:before {
+  content: "\e6b9";
+}
+.wd-icon-view-module.data-v-d4a8410a:before {
+  content: "\e6ba";
+}
+.wd-icon-format-vertical-align-right.data-v-d4a8410a:before {
+  content: "\e6bb";
+}
+.wd-icon-view-list.data-v-d4a8410a:before {
+  content: "\e6bc";
+}
+.wd-icon-order-descending.data-v-d4a8410a:before {
+  content: "\e6bd";
+}
+.wd-icon-format-horizontal-align-bottom.data-v-d4a8410a:before {
+  content: "\e6be";
+}
+.wd-icon-queue.data-v-d4a8410a:before {
+  content: "\e6bf";
+}
+.wd-icon-menu-fold.data-v-d4a8410a:before {
+  content: "\e6c0";
+}
+.wd-icon-menu-unfold.data-v-d4a8410a:before {
+  content: "\e6c1";
+}
+.wd-icon-format-horizontal-align-top.data-v-d4a8410a:before {
+  content: "\e6c2";
+}
+.wd-icon-a-rootlist.data-v-d4a8410a:before {
+  content: "\e6c3";
+}
+.wd-icon-order-ascending.data-v-d4a8410a:before {
+  content: "\e6c4";
+}
+.wd-icon-format-vertical-align-left.data-v-d4a8410a:before {
+  content: "\e6c5";
+}
+.wd-icon-format-horizontal-align-center.data-v-d4a8410a:before {
+  content: "\e6c6";
+}
+.wd-icon-format-vertical-align-center.data-v-d4a8410a:before {
+  content: "\e6c7";
+}
+.wd-icon-swap-left.data-v-d4a8410a:before {
+  content: "\e6c8";
+}
+.wd-icon-flag.data-v-d4a8410a:before {
+  content: "\e6aa";
+}
+.wd-icon-code.data-v-d4a8410a:before {
+  content: "\e6ab";
+}
+.wd-icon-cart.data-v-d4a8410a:before {
+  content: "\e6ac";
+}
+.wd-icon-attach.data-v-d4a8410a:before {
+  content: "\e6ad";
+}
+.wd-icon-chart.data-v-d4a8410a:before {
+  content: "\e6ae";
+}
+.wd-icon-creditcard.data-v-d4a8410a:before {
+  content: "\e6af";
+}
+.wd-icon-calendar.data-v-d4a8410a:before {
+  content: "\e6b0";
+}
+.wd-icon-app.data-v-d4a8410a:before {
+  content: "\e6b1";
+}
+.wd-icon-books.data-v-d4a8410a:before {
+  content: "\e6b2";
+}
+.wd-icon-barcode.data-v-d4a8410a:before {
+  content: "\e6b3";
+}
+.wd-icon-chart-pie.data-v-d4a8410a:before {
+  content: "\e6b4";
+}
+.wd-icon-chart-bar.data-v-d4a8410a:before {
+  content: "\e6b5";
+}
+.wd-icon-chart-bubble.data-v-d4a8410a:before {
+  content: "\e6b6";
+}
+.wd-icon-bulletpoint.data-v-d4a8410a:before {
+  content: "\e6b7";
+}
+.wd-icon-bianjiliebiao.data-v-d4a8410a:before {
+  content: "\e6b8";
+}
+.wd-icon-image.data-v-d4a8410a:before {
+  content: "\e69a";
+}
+.wd-icon-laptop.data-v-d4a8410a:before {
+  content: "\e69b";
+}
+.wd-icon-hourglass.data-v-d4a8410a:before {
+  content: "\e69c";
+}
+.wd-icon-call.data-v-d4a8410a:before {
+  content: "\e69d";
+}
+.wd-icon-mobile-vibrate.data-v-d4a8410a:before {
+  content: "\e69e";
+}
+.wd-icon-mail.data-v-d4a8410a:before {
+  content: "\e69f";
+}
+.wd-icon-notification-filled.data-v-d4a8410a:before {
+  content: "\e6a0";
+}
+.wd-icon-desktop.data-v-d4a8410a:before {
+  content: "\e6a1";
+}
+.wd-icon-history.data-v-d4a8410a:before {
+  content: "\e6a2";
+}
+.wd-icon-discount-filled.data-v-d4a8410a:before {
+  content: "\e6a3";
+}
+.wd-icon-dashboard.data-v-d4a8410a:before {
+  content: "\e6a4";
+}
+.wd-icon-discount.data-v-d4a8410a:before {
+  content: "\e6a5";
+}
+.wd-icon-heart-filled.data-v-d4a8410a:before {
+  content: "\e6a6";
+}
+.wd-icon-chat1.data-v-d4a8410a:before {
+  content: "\e6a7";
+}
+.wd-icon-a-controlplatform.data-v-d4a8410a:before {
+  content: "\e6a8";
+}
+.wd-icon-gift.data-v-d4a8410a:before {
+  content: "\e6a9";
+}
+.wd-icon-photo.data-v-d4a8410a:before {
+  content: "\e692";
+}
+.wd-icon-play-circle-stroke.data-v-d4a8410a:before {
+  content: "\e693";
+}
+.wd-icon-notification.data-v-d4a8410a:before {
+  content: "\e694";
+}
+.wd-icon-cloud.data-v-d4a8410a:before {
+  content: "\e695";
+}
+.wd-icon-gender-female.data-v-d4a8410a:before {
+  content: "\e696";
+}
+.wd-icon-fork.data-v-d4a8410a:before {
+  content: "\e697";
+}
+.wd-icon-layers.data-v-d4a8410a:before {
+  content: "\e698";
+}
+.wd-icon-lock-off.data-v-d4a8410a:before {
+  content: "\e699";
+}
+.wd-icon-location.data-v-d4a8410a:before {
+  content: "\e68a";
+}
+.wd-icon-mobile.data-v-d4a8410a:before {
+  content: "\e68b";
+}
+.wd-icon-qrcode.data-v-d4a8410a:before {
+  content: "\e68c";
+}
+.wd-icon-home1.data-v-d4a8410a:before {
+  content: "\e68d";
+}
+.wd-icon-time.data-v-d4a8410a:before {
+  content: "\e68e";
+}
+.wd-icon-heart.data-v-d4a8410a:before {
+  content: "\e68f";
+}
+.wd-icon-lock-on.data-v-d4a8410a:before {
+  content: "\e690";
+}
+.wd-icon-print.data-v-d4a8410a:before {
+  content: "\e691";
+}
+.wd-icon-slash.data-v-d4a8410a:before {
+  content: "\e67a";
+}
+.wd-icon-usb.data-v-d4a8410a:before {
+  content: "\e67b";
+}
+.wd-icon-tools.data-v-d4a8410a:before {
+  content: "\e67c";
+}
+.wd-icon-wifi.data-v-d4a8410a:before {
+  content: "\e67d";
+}
+.wd-icon-star-filled.data-v-d4a8410a:before {
+  content: "\e67e";
+}
+.wd-icon-server.data-v-d4a8410a:before {
+  content: "\e67f";
+}
+.wd-icon-sound.data-v-d4a8410a:before {
+  content: "\e680";
+}
+.wd-icon-a-precisemonitor.data-v-d4a8410a:before {
+  content: "\e681";
+}
+.wd-icon-service.data-v-d4a8410a:before {
+  content: "\e682";
+}
+.wd-icon-tips.data-v-d4a8410a:before {
+  content: "\e683";
+}
+.wd-icon-pin.data-v-d4a8410a:before {
+  content: "\e684";
+}
+.wd-icon-secured.data-v-d4a8410a:before {
+  content: "\e685";
+}
+.wd-icon-star.data-v-d4a8410a:before {
+  content: "\e686";
+}
+.wd-icon-gender-male.data-v-d4a8410a:before {
+  content: "\e687";
+}
+.wd-icon-shop.data-v-d4a8410a:before {
+  content: "\e688";
+}
+.wd-icon-money-circle.data-v-d4a8410a:before {
+  content: "\e689";
+}
+.wd-icon-file-word.data-v-d4a8410a:before {
+  content: "\e66a";
+}
+.wd-icon-file-unknown.data-v-d4a8410a:before {
+  content: "\e66b";
+}
+.wd-icon-folder-open.data-v-d4a8410a:before {
+  content: "\e66c";
+}
+.wd-icon-file-pdf.data-v-d4a8410a:before {
+  content: "\e66d";
+}
+.wd-icon-folder.data-v-d4a8410a:before {
+  content: "\e66e";
+}
+.wd-icon-folder-add.data-v-d4a8410a:before {
+  content: "\e66f";
+}
+.wd-icon-file.data-v-d4a8410a:before {
+  content: "\e670";
+}
+.wd-icon-file-image.data-v-d4a8410a:before {
+  content: "\e671";
+}
+.wd-icon-file-powerpoint.data-v-d4a8410a:before {
+  content: "\e672";
+}
+.wd-icon-file-add.data-v-d4a8410a:before {
+  content: "\e673";
+}
+.wd-icon-file-icon.data-v-d4a8410a:before {
+  content: "\e674";
+}
+.wd-icon-file-paste.data-v-d4a8410a:before {
+  content: "\e675";
+}
+.wd-icon-file-excel.data-v-d4a8410a:before {
+  content: "\e676";
+}
+.wd-icon-file-copy.data-v-d4a8410a:before {
+  content: "\e677";
+}
+.wd-icon-video1.data-v-d4a8410a:before {
+  content: "\e678";
+}
+.wd-icon-wallet.data-v-d4a8410a:before {
+  content: "\e679";
+}
+.wd-icon-ie.data-v-d4a8410a:before {
+  content: "\e65d";
+}
+.wd-icon-logo-codepen.data-v-d4a8410a:before {
+  content: "\e65e";
+}
+.wd-icon-github-filled.data-v-d4a8410a:before {
+  content: "\e65f";
+}
+.wd-icon-ie-filled.data-v-d4a8410a:before {
+  content: "\e660";
+}
+.wd-icon-apple.data-v-d4a8410a:before {
+  content: "\e661";
+}
+.wd-icon-windows-filled.data-v-d4a8410a:before {
+  content: "\e662";
+}
+.wd-icon-internet.data-v-d4a8410a:before {
+  content: "\e663";
+}
+.wd-icon-github.data-v-d4a8410a:before {
+  content: "\e664";
+}
+.wd-icon-windows.data-v-d4a8410a:before {
+  content: "\e665";
+}
+.wd-icon-apple-filled.data-v-d4a8410a:before {
+  content: "\e666";
+}
+.wd-icon-chrome-filled.data-v-d4a8410a:before {
+  content: "\e667";
+}
+.wd-icon-chrome.data-v-d4a8410a:before {
+  content: "\e668";
+}
+.wd-icon-android.data-v-d4a8410a:before {
+  content: "\e669";
+}
+.wd-icon-edit-outline.data-v-d4a8410a:before {
+  content: "\e64a";
+}
+.wd-icon-detection.data-v-d4a8410a:before {
+  content: "\e64b";
+}
+.wd-icon-check-outline.data-v-d4a8410a:before {
+  content: "\e64c";
+}
+.wd-icon-close.data-v-d4a8410a:before {
+  content: "\e64d";
+}
+.wd-icon-check.data-v-d4a8410a:before {
+  content: "\e64e";
+}
+.wd-icon-arrow-left.data-v-d4a8410a:before {
+  content: "\e64f";
+}
+.wd-icon-computer.data-v-d4a8410a:before {
+  content: "\e650";
+}
+.wd-icon-clock.data-v-d4a8410a:before {
+  content: "\e651";
+}
+.wd-icon-check-bold.data-v-d4a8410a:before {
+  content: "\e652";
+}
+.wd-icon-bags.data-v-d4a8410a:before {
+  content: "\e653";
+}
+.wd-icon-arrow-down.data-v-d4a8410a:before {
+  content: "\e654";
+}
+.wd-icon-arrow-right.data-v-d4a8410a:before {
+  content: "\e655";
+}
+.wd-icon-circle.data-v-d4a8410a:before {
+  content: "\e656";
+}
+.wd-icon-arrow-thin-down.data-v-d4a8410a:before {
+  content: "\e657";
+}
+.wd-icon-camera.data-v-d4a8410a:before {
+  content: "\e658";
+}
+.wd-icon-close-bold.data-v-d4a8410a:before {
+  content: "\e659";
+}
+.wd-icon-add-circle.data-v-d4a8410a:before {
+  content: "\e65a";
+}
+.wd-icon-arrow-thin-up.data-v-d4a8410a:before {
+  content: "\e65b";
+}
+.wd-icon-add.data-v-d4a8410a:before {
+  content: "\e65c";
+}
+.wd-icon-keyboard-delete.data-v-d4a8410a:before {
+  content: "\e634";
+}
+.wd-icon-transfer.data-v-d4a8410a:before {
+  content: "\e635";
+}
+.wd-icon-eye-close.data-v-d4a8410a:before {
+  content: "\e61f";
+}
+.wd-icon-delete.data-v-d4a8410a:before {
+  content: "\e61e";
+}
+.wd-icon-download.data-v-d4a8410a:before {
+  content: "\e636";
+}
+.wd-icon-picture.data-v-d4a8410a:before {
+  content: "\e637";
+}
+.wd-icon-refresh.data-v-d4a8410a:before {
+  content: "\e638";
+}
+.wd-icon-read.data-v-d4a8410a:before {
+  content: "\e639";
+}
+.wd-icon-note.data-v-d4a8410a:before {
+  content: "\e63a";
+}
+.wd-icon-phone.data-v-d4a8410a:before {
+  content: "\e63b";
+}
+.wd-icon-lenovo.data-v-d4a8410a:before {
+  content: "\e63c";
+}
+.wd-icon-home.data-v-d4a8410a:before {
+  content: "\e63d";
+}
+.wd-icon-search.data-v-d4a8410a:before {
+  content: "\e63e";
+}
+.wd-icon-fill-camera.data-v-d4a8410a:before {
+  content: "\e63f";
+}
+.wd-icon-fill-arrow-down.data-v-d4a8410a:before {
+  content: "\e640";
+}
+.wd-icon-arrow-up.data-v-d4a8410a:before {
+  content: "\e61d";
+}
+.wd-icon-delete-thin.data-v-d4a8410a:before {
+  content: "\e641";
+}
+.wd-icon-filter.data-v-d4a8410a:before {
+  content: "\e642";
+}
+.wd-icon-evaluation.data-v-d4a8410a:before {
+  content: "\e643";
+}
+.wd-icon-close-outline.data-v-d4a8410a:before {
+  content: "\e644";
+}
+.wd-icon-dong.data-v-d4a8410a:before {
+  content: "\e645";
+}
+.wd-icon-error-fill.data-v-d4a8410a:before {
+  content: "\e646";
+}
+.wd-icon-chat.data-v-d4a8410a:before {
+  content: "\e647";
+}
+.wd-icon-decrease.data-v-d4a8410a:before {
+  content: "\e648";
+}
+.wd-icon-copy.data-v-d4a8410a:before {
+  content: "\e649";
+}
+.wd-icon-setting.data-v-d4a8410a:before {
+  content: "\e621";
+}
+.wd-icon-subscribe.data-v-d4a8410a:before {
+  content: "\e622";
+}
+.wd-icon-jdm.data-v-d4a8410a:before {
+  content: "\e620";
+}
+.wd-icon-spool.data-v-d4a8410a:before {
+  content: "\e623";
+}
+.wd-icon-warning.data-v-d4a8410a:before {
+  content: "\e624";
+}
+.wd-icon-wifi-error.data-v-d4a8410a:before {
+  content: "\e625";
+}
+.wd-icon-star-on.data-v-d4a8410a:before {
+  content: "\e626";
+}
+.wd-icon-rotate.data-v-d4a8410a:before {
+  content: "\e627";
+}
+.wd-icon-translate-bold.data-v-d4a8410a:before {
+  content: "\e628";
+}
+.wd-icon-keyboard-collapse.data-v-d4a8410a:before {
+  content: "\e629";
+}
+.wd-icon-keywords.data-v-d4a8410a:before {
+  content: "\e62a";
+}
+.wd-icon-scan.data-v-d4a8410a:before {
+  content: "\e62b";
+}
+.wd-icon-view.data-v-d4a8410a:before {
+  content: "\e62c";
+}
+.wd-icon-phone-compute.data-v-d4a8410a:before {
+  content: "\e62d";
+}
+.wd-icon-video.data-v-d4a8410a:before {
+  content: "\e62e";
+}
+.wd-icon-thin-arrow-left.data-v-d4a8410a:before {
+  content: "\e62f";
+}
+.wd-icon-goods.data-v-d4a8410a:before {
+  content: "\e630";
+}
+.wd-icon-list.data-v-d4a8410a:before {
+  content: "\e631";
+}
+.wd-icon-warn-bold.data-v-d4a8410a:before {
+  content: "\e632";
+}
+.wd-icon-more.data-v-d4a8410a:before {
+  content: "\e633";
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-loading/wd-loading.js

@@ -0,0 +1,78 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+const __default__ = {
+  name: "wd-loading",
+  options: {
+    virtualHost: true,
+    addGlobalClass: true,
+    styleIsolation: "shared"
+  }
+};
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  ...__default__,
+  props: common_vendor.loadingProps,
+  setup(__props) {
+    const svgDefineId = common_vendor.context.id++;
+    const svgDefineId1 = common_vendor.context.id++;
+    const svgDefineId2 = common_vendor.context.id++;
+    const icon = {
+      outline(color = "#4D80F0") {
+        return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 42 42"><defs><linearGradient x1="100%" y1="0%" x2="0%" y2="0%" id="${svgDefineId}"><stop stop-color="#FFF" offset="0%" stop-opacity="0"/><stop stop-color="#FFF" offset="100%"/></linearGradient></defs><g fill="none" fill-rule="evenodd"><path d="M21 1c11.046 0 20 8.954 20 20s-8.954 20-20 20S1 32.046 1 21 9.954 1 21 1zm0 7C13.82 8 8 13.82 8 21s5.82 13 13 13 13-5.82 13-13S28.18 8 21 8z" fill="${color}"/><path d="M4.599 21c0 9.044 7.332 16.376 16.376 16.376 9.045 0 16.376-7.332 16.376-16.376" stroke="url(#${svgDefineId}) " stroke-width="3.5" stroke-linecap="round"/></g></svg>`;
+      },
+      ring(color = "#4D80F0", intermediateColor2 = "#a6bff7") {
+        return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 200"><linearGradient id="${svgDefineId1}" gradientUnits="userSpaceOnUse" x1="50" x2="50" y2="180"><stop offset="0" stop-color="${color}"></stop> <stop offset="1" stop-color="${intermediateColor2}"></stop></linearGradient> <path fill="url(#${svgDefineId1})" d="M20 100c0-44.1 35.9-80 80-80V0C44.8 0 0 44.8 0 100s44.8 100 100 100v-20c-44.1 0-80-35.9-80-80z"></path> <linearGradient id="${svgDefineId2}" gradientUnits="userSpaceOnUse" x1="150" y1="20" x2="150" y2="180"><stop offset="0" stop-color="#fff" stop-opacity="0"></stop> <stop offset="1" stop-color="${intermediateColor2}"></stop></linearGradient> <path fill="url(#${svgDefineId2})" d="M100 0v20c44.1 0 80 35.9 80 80s-35.9 80-80 80v20c55.2 0 100-44.8 100-100S155.2 0 100 0z"></path> <circle cx="100" cy="10" r="10" fill="${color}"></circle></svg>`;
+      }
+    };
+    const props = __props;
+    const svg = common_vendor.ref("");
+    const intermediateColor = common_vendor.ref("");
+    const iconSize = common_vendor.ref(null);
+    common_vendor.watch(
+      () => props.size,
+      (newVal) => {
+        iconSize.value = common_vendor.addUnit(newVal);
+      },
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    common_vendor.watch(
+      () => props.type,
+      () => {
+        buildSvg();
+      },
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    const rootStyle = common_vendor.computed(() => {
+      const style = {};
+      if (common_vendor.isDef(iconSize.value)) {
+        style.height = common_vendor.addUnit(iconSize.value);
+        style.width = common_vendor.addUnit(iconSize.value);
+      }
+      return `${common_vendor.objToStyle(style)} ${props.customStyle}`;
+    });
+    common_vendor.onBeforeMount(() => {
+      intermediateColor.value = common_vendor.gradient(props.color, "#ffffff", 2)[1];
+      buildSvg();
+    });
+    function buildSvg() {
+      const { type, color } = props;
+      let ringType = common_vendor.isDef(type) ? type : "ring";
+      const svgStr = `"data:image/svg+xml;base64,${common_vendor.encode(ringType === "ring" ? icon[ringType](color, intermediateColor.value) : icon[ringType](color))}"`;
+      svg.value = svgStr;
+    }
+    return (_ctx, _cache) => {
+      return {
+        a: common_vendor.s(`background-image: url(${svg.value});`),
+        b: common_vendor.n(`wd-loading ${props.customClass}`),
+        c: common_vendor.s(rootStyle.value)
+      };
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-eccc123e"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-loading/wd-loading.json

@@ -0,0 +1,4 @@
+{
+  "component": true,
+  "usingComponents": {}
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-loading/wd-loading.wxml

@@ -0,0 +1 @@
+<view class="{{['data-v-eccc123e', b]}}" style="{{c}}"><view class="wd-loading__body data-v-eccc123e"><view class="wd-loading__svg data-v-eccc123e" style="{{a}}"></view></view></view>

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-loading/wd-loading.wxss

@@ -0,0 +1,217 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+/**
+ * 混合宏
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+  * BEM，定义块（b)
+  */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 此方法用于生成穿透样式 */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 定义状态（m） */
+/* 定义状态（m） */
+/* 对于需要需要嵌套在 m 底下的 e，调用这个混合宏，一般在切换整个组件的状态，如切换颜色的时候 */
+/* 状态，生成 is-$state 类名 */
+/**
+  * 常用混合宏
+  */
+/* 单行超出隐藏 */
+/* 多行超出隐藏 */
+/* 清除浮动 */
+/* 0.5px 边框 指定方向*/
+/* 0.5px 边框 环绕 */
+/**
+  * 三角形实现尖角样式，适用于背景透明情况
+  * @param $size 三角形高，底边为 $size * 2
+  * @param $bg 三角形背景颜色
+  */
+/**
+  * 正方形实现尖角样式，适用于背景不透明情况
+  * @param $size 正方形边长
+  * @param $bg 正方形背景颜色
+  * @param $z-index z-index属性值，不得大于外部包裹器
+  * @param $box-shadow 阴影
+*/
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+ * UI规范基础变量
+ */
+/*----------------------------------------- Theme color. start ----------------------------------------*/
+/* 主题颜色 */
+/* 辅助色 */
+/* 文字颜色（默认浅色背景下 */
+/* 暗黑模式 */
+/* 图形颜色 */
+/*----------------------------------------- Theme color. end -------------------------------------------*/
+/*-------------------------------- Theme color application size.  start --------------------------------*/
+/* 文字字号 */
+/* 文字字重 */
+/* 尺寸 */
+/*-------------------------------- Theme color application size.  end --------------------------------*/
+/* component var */
+/* action-sheet */
+/* badge */
+/* button */
+/* cell */
+/* calendar */
+/* checkbox */
+/* collapse */
+/* divider */
+/* drop-menu */
+/* input-number */
+/* input */
+/* textarea */
+/* loadmore */
+/* message-box */
+/* notice-bar */
+/* pagination */
+/* picker */
+/* col-picker */
+/* overlay */
+/* popup */
+/* progress */
+/* radio */
+/* search */
+/* slider */
+/* sort-button */
+/* steps */
+/* switch */
+/* tabs */
+/* tag */
+/* toast */
+/* loading */
+/* tooltip */
+/* popover */
+/* grid-item */
+/* statustip */
+/* card */
+/* upload */
+/* curtain */
+/* notify */
+/* skeleton */
+/* circle */
+/* swiper */
+/* swiper-nav */
+/* segmented */
+/* tabbar */
+/* tabbar-item */
+/* navbar */
+/* navbar-capsule */
+/* table */
+/* sidebar */
+/* sidebar-item */
+/* fab */
+/* count-down */
+/* keyboard */
+/* number-keyboard */
+/* passwod-input */
+/* form-item */
+/* backtop */
+/* index-bar */
+/* text */
+/* video-preview */
+/* img-cropper */
+/* floating-panel */
+/* signature */
+.wd-loading.data-v-eccc123e {
+  font-size: 0;
+  line-height: 0;
+  vertical-align: middle;
+  display: inline-block;
+  width: var(--wot-loading-size, 32px);
+  height: var(--wot-loading-size, 32px);
+}
+.wd-loading__body.data-v-eccc123e {
+  width: 100%;
+  height: 100%;
+  animation: wd-rotate-eccc123e 0.8s linear infinite;
+  animation-duration: 2s;
+}
+.wd-loading__svg.data-v-eccc123e {
+  width: 100%;
+  height: 100%;
+  background-size: cover;
+  background-repeat: no-repeat;
+}
+@keyframes wd-rotate-eccc123e {
+from {
+    transform: rotate(0deg);
+}
+to {
+    transform: rotate(360deg);
+}
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-overlay/wd-overlay.js

@@ -0,0 +1,41 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+if (!Math) {
+  wdTransition();
+}
+const wdTransition = () => "../wd-transition/wd-transition.js";
+const __default__ = {
+  name: "wd-overlay",
+  options: {
+    virtualHost: true,
+    addGlobalClass: true,
+    styleIsolation: "shared"
+  }
+};
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  ...__default__,
+  props: common_vendor.overlayProps,
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    function handleClick() {
+      emit("click");
+    }
+    function noop() {
+    }
+    return (_ctx, _cache) => {
+      return {
+        a: common_vendor.o(handleClick),
+        b: common_vendor.o(($event) => _ctx.lockScroll ? noop : ""),
+        c: common_vendor.p({
+          show: _ctx.show,
+          name: "fade",
+          ["custom-class"]: "wd-overlay",
+          duration: _ctx.duration,
+          ["custom-style"]: `z-index: ${_ctx.zIndex}; ${_ctx.customStyle}`
+        })
+      };
+    };
+  }
+});
+wx.createComponent(_sfc_main);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-overlay/wd-overlay.json

@@ -0,0 +1,6 @@
+{
+  "component": true,
+  "usingComponents": {
+    "wd-transition": "../wd-transition/wd-transition"
+  }
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-overlay/wd-overlay.wxml

@@ -0,0 +1 @@
+<wd-transition wx:if="{{c}}" u-s="{{['d']}}" bindclick="{{a}}" catchtouchmove="{{b}}" u-i="eab434ec-0" bind:__l="__l" u-p="{{c}}"><slot></slot></wd-transition>

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-overlay/wd-overlay.wxss

@@ -0,0 +1,200 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+/**
+ * 混合宏
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+  * BEM，定义块（b)
+  */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 此方法用于生成穿透样式 */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 定义状态（m） */
+/* 定义状态（m） */
+/* 对于需要需要嵌套在 m 底下的 e，调用这个混合宏，一般在切换整个组件的状态，如切换颜色的时候 */
+/* 状态，生成 is-$state 类名 */
+/**
+  * 常用混合宏
+  */
+/* 单行超出隐藏 */
+/* 多行超出隐藏 */
+/* 清除浮动 */
+/* 0.5px 边框 指定方向*/
+/* 0.5px 边框 环绕 */
+/**
+  * 三角形实现尖角样式，适用于背景透明情况
+  * @param $size 三角形高，底边为 $size * 2
+  * @param $bg 三角形背景颜色
+  */
+/**
+  * 正方形实现尖角样式，适用于背景不透明情况
+  * @param $size 正方形边长
+  * @param $bg 正方形背景颜色
+  * @param $z-index z-index属性值，不得大于外部包裹器
+  * @param $box-shadow 阴影
+*/
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+ * UI规范基础变量
+ */
+/*----------------------------------------- Theme color. start ----------------------------------------*/
+/* 主题颜色 */
+/* 辅助色 */
+/* 文字颜色（默认浅色背景下 */
+/* 暗黑模式 */
+/* 图形颜色 */
+/*----------------------------------------- Theme color. end -------------------------------------------*/
+/*-------------------------------- Theme color application size.  start --------------------------------*/
+/* 文字字号 */
+/* 文字字重 */
+/* 尺寸 */
+/*-------------------------------- Theme color application size.  end --------------------------------*/
+/* component var */
+/* action-sheet */
+/* badge */
+/* button */
+/* cell */
+/* calendar */
+/* checkbox */
+/* collapse */
+/* divider */
+/* drop-menu */
+/* input-number */
+/* input */
+/* textarea */
+/* loadmore */
+/* message-box */
+/* notice-bar */
+/* pagination */
+/* picker */
+/* col-picker */
+/* overlay */
+/* popup */
+/* progress */
+/* radio */
+/* search */
+/* slider */
+/* sort-button */
+/* steps */
+/* switch */
+/* tabs */
+/* tag */
+/* toast */
+/* loading */
+/* tooltip */
+/* popover */
+/* grid-item */
+/* statustip */
+/* card */
+/* upload */
+/* curtain */
+/* notify */
+/* skeleton */
+/* circle */
+/* swiper */
+/* swiper-nav */
+/* segmented */
+/* tabbar */
+/* tabbar-item */
+/* navbar */
+/* navbar-capsule */
+/* table */
+/* sidebar */
+/* sidebar-item */
+/* fab */
+/* count-down */
+/* keyboard */
+/* number-keyboard */
+/* passwod-input */
+/* form-item */
+/* backtop */
+/* index-bar */
+/* text */
+/* video-preview */
+/* img-cropper */
+/* floating-panel */
+/* signature */
+.wot-theme-dark .wd-overlay {
+  background: var(--wot-overlay-bg-dark, rgba(0, 0, 0, 0.75));
+}
+.wd-overlay {
+  position: fixed;
+  left: 0;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  background: var(--wot-overlay-bg, rgba(0, 0, 0, 0.65));
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-popup/wd-popup.js

@@ -0,0 +1,126 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+if (!Math) {
+  (wdOverlay + wdIcon + wdTransition)();
+}
+const wdIcon = () => "../wd-icon/wd-icon.js";
+const wdOverlay = () => "../wd-overlay/wd-overlay.js";
+const wdTransition = () => "../wd-transition/wd-transition.js";
+const __default__ = {
+  name: "wd-popup",
+  options: {
+    virtualHost: true,
+    addGlobalClass: true,
+    styleIsolation: "shared"
+  }
+};
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  ...__default__,
+  props: common_vendor.popupProps,
+  emits: [
+    "update:modelValue",
+    "before-enter",
+    "enter",
+    "before-leave",
+    "leave",
+    "after-leave",
+    "after-enter",
+    "click-modal",
+    "close"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const transitionName = common_vendor.computed(() => {
+      if (props.transition) {
+        return props.transition;
+      }
+      if (props.position === "center") {
+        return ["zoom-in", "fade"];
+      }
+      if (props.position === "left") {
+        return "slide-left";
+      }
+      if (props.position === "right") {
+        return "slide-right";
+      }
+      if (props.position === "bottom") {
+        return "slide-up";
+      }
+      if (props.position === "top") {
+        return "slide-down";
+      }
+      return "slide-up";
+    });
+    const safeBottom = common_vendor.ref(0);
+    const style = common_vendor.computed(() => {
+      return `z-index:${props.zIndex}; padding-bottom: ${safeBottom.value}px;${props.customStyle}`;
+    });
+    const rootClass = common_vendor.computed(() => {
+      return `wd-popup wd-popup--${props.position} ${!props.transition && props.position === "center" ? "is-deep" : ""} ${props.customClass || ""}`;
+    });
+    common_vendor.onBeforeMount(() => {
+      if (props.safeAreaInsetBottom) {
+        const { safeArea, screenHeight, safeAreaInsets } = common_vendor.index.getSystemInfoSync();
+        if (safeArea) {
+          safeBottom.value = screenHeight - (safeArea.bottom || 0);
+        } else {
+          safeBottom.value = 0;
+        }
+      }
+    });
+    function handleClickModal() {
+      emit("click-modal");
+      if (props.closeOnClickModal) {
+        close();
+      }
+    }
+    function close() {
+      emit("close");
+      emit("update:modelValue", false);
+    }
+    function noop() {
+    }
+    return (_ctx, _cache) => {
+      return common_vendor.e({
+        a: _ctx.modal
+      }, _ctx.modal ? {
+        b: common_vendor.o(handleClickModal),
+        c: common_vendor.o(noop),
+        d: common_vendor.p({
+          show: _ctx.modelValue,
+          ["z-index"]: _ctx.zIndex,
+          ["lock-scroll"]: _ctx.lockScroll,
+          duration: _ctx.duration,
+          ["custom-style"]: _ctx.modalStyle
+        })
+      } : {}, {
+        e: _ctx.closable
+      }, _ctx.closable ? {
+        f: common_vendor.o(close),
+        g: common_vendor.p({
+          ["custom-class"]: "wd-popup__close",
+          name: "add"
+        })
+      } : {}, {
+        h: common_vendor.o(($event) => emit("before-enter")),
+        i: common_vendor.o(($event) => emit("enter")),
+        j: common_vendor.o(($event) => emit("after-enter")),
+        k: common_vendor.o(($event) => emit("before-leave")),
+        l: common_vendor.o(($event) => emit("leave")),
+        m: common_vendor.o(($event) => emit("after-leave")),
+        n: common_vendor.p({
+          ["lazy-render"]: _ctx.lazyRender,
+          ["custom-class"]: rootClass.value,
+          ["custom-style"]: style.value,
+          duration: _ctx.duration,
+          show: _ctx.modelValue,
+          name: transitionName.value,
+          destroy: _ctx.hideWhenClose
+        })
+      });
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-82a7a455"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-popup/wd-popup.json

@@ -0,0 +1,8 @@
+{
+  "component": true,
+  "usingComponents": {
+    "wd-icon": "../wd-icon/wd-icon",
+    "wd-overlay": "../wd-overlay/wd-overlay",
+    "wd-transition": "../wd-transition/wd-transition"
+  }
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-popup/wd-popup.wxml

@@ -0,0 +1 @@
+<view class="wd-popup-wrapper data-v-82a7a455"><wd-overlay wx:if="{{a}}" class="data-v-82a7a455" bindclick="{{b}}" bindtouchmove="{{c}}" u-i="82a7a455-0" bind:__l="__l" u-p="{{d}}"/><wd-transition wx:if="{{n}}" class="data-v-82a7a455" u-s="{{['d']}}" bindbeforeEnter="{{h}}" bindenter="{{i}}" bindafterEnter="{{j}}" bindbeforeLeave="{{k}}" bindleave="{{l}}" bindafterLeave="{{m}}" u-i="82a7a455-1" bind:__l="__l" u-p="{{n}}"><slot/><wd-icon wx:if="{{e}}" class="data-v-82a7a455" bindclick="{{f}}" u-i="82a7a455-2,82a7a455-1" bind:__l="__l" u-p="{{g}}"/></wd-transition></view>

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-popup/wd-popup.wxss

@@ -0,0 +1,241 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+/**
+ * 混合宏
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+  * BEM，定义块（b)
+  */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 此方法用于生成穿透样式 */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 定义状态（m） */
+/* 定义状态（m） */
+/* 对于需要需要嵌套在 m 底下的 e，调用这个混合宏，一般在切换整个组件的状态，如切换颜色的时候 */
+/* 状态，生成 is-$state 类名 */
+/**
+  * 常用混合宏
+  */
+/* 单行超出隐藏 */
+/* 多行超出隐藏 */
+/* 清除浮动 */
+/* 0.5px 边框 指定方向*/
+/* 0.5px 边框 环绕 */
+/**
+  * 三角形实现尖角样式，适用于背景透明情况
+  * @param $size 三角形高，底边为 $size * 2
+  * @param $bg 三角形背景颜色
+  */
+/**
+  * 正方形实现尖角样式，适用于背景不透明情况
+  * @param $size 正方形边长
+  * @param $bg 正方形背景颜色
+  * @param $z-index z-index属性值，不得大于外部包裹器
+  * @param $box-shadow 阴影
+*/
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+ * UI规范基础变量
+ */
+/*----------------------------------------- Theme color. start ----------------------------------------*/
+/* 主题颜色 */
+/* 辅助色 */
+/* 文字颜色（默认浅色背景下 */
+/* 暗黑模式 */
+/* 图形颜色 */
+/*----------------------------------------- Theme color. end -------------------------------------------*/
+/*-------------------------------- Theme color application size.  start --------------------------------*/
+/* 文字字号 */
+/* 文字字重 */
+/* 尺寸 */
+/*-------------------------------- Theme color application size.  end --------------------------------*/
+/* component var */
+/* action-sheet */
+/* badge */
+/* button */
+/* cell */
+/* calendar */
+/* checkbox */
+/* collapse */
+/* divider */
+/* drop-menu */
+/* input-number */
+/* input */
+/* textarea */
+/* loadmore */
+/* message-box */
+/* notice-bar */
+/* pagination */
+/* picker */
+/* col-picker */
+/* overlay */
+/* popup */
+/* progress */
+/* radio */
+/* search */
+/* slider */
+/* sort-button */
+/* steps */
+/* switch */
+/* tabs */
+/* tag */
+/* toast */
+/* loading */
+/* tooltip */
+/* popover */
+/* grid-item */
+/* statustip */
+/* card */
+/* upload */
+/* curtain */
+/* notify */
+/* skeleton */
+/* circle */
+/* swiper */
+/* swiper-nav */
+/* segmented */
+/* tabbar */
+/* tabbar-item */
+/* navbar */
+/* navbar-capsule */
+/* table */
+/* sidebar */
+/* sidebar-item */
+/* fab */
+/* count-down */
+/* keyboard */
+/* number-keyboard */
+/* passwod-input */
+/* form-item */
+/* backtop */
+/* index-bar */
+/* text */
+/* video-preview */
+/* img-cropper */
+/* floating-panel */
+/* signature */
+.wot-theme-dark .wd-popup-wrapper.data-v-82a7a455  .wd-popup {
+  background: var(--wot-dark-background2, #1b1b1b);
+}
+.wot-theme-dark .wd-popup-wrapper.data-v-82a7a455  .wd-popup__close {
+  color: var(--wot-dark-color, var(--wot-color-white, rgb(255, 255, 255)));
+}
+.wd-popup-wrapper.data-v-82a7a455  .wd-popup {
+  position: fixed;
+  max-height: 100%;
+  overflow-y: auto;
+  background: #fff;
+}
+.data-v-82a7a455  .wd-popup__close {
+  position: absolute;
+  top: 10px;
+  right: 10px;
+  color: var(--wot-popup-close-color, #666);
+  font-size: var(--wot-popup-close-size, 24px);
+  transform: rotate(-45deg);
+}
+.data-v-82a7a455  .wd-popup--center {
+  left: 50%;
+  top: 50%;
+  transform: translate3d(-50%, -50%, 0);
+  transform-origin: 0% 0%;
+}
+.data-v-82a7a455  .wd-popup--center.wd-zoom-in-enter,.data-v-82a7a455  .wd-popup--center.wd-zoom-in-leave-to {
+  transform: scale(0.8) translate3d(-50%, -50%, 0) !important;
+}
+.data-v-82a7a455  .wd-popup--center.is-deep.wd-zoom-in-enter,.data-v-82a7a455  .wd-popup--center.is-deep.wd-zoom-in-leave-to {
+  transform: scale(0.1) translate3d(-50%, -50%, 0) !important;
+}
+.data-v-82a7a455  .wd-popup--left {
+  top: 0;
+  bottom: 0;
+  left: 0;
+}
+.data-v-82a7a455  .wd-popup--right {
+  top: 0;
+  right: 0;
+  bottom: 0;
+}
+.data-v-82a7a455  .wd-popup--top {
+  top: 0;
+  left: 0;
+  right: 0;
+}
+.data-v-82a7a455  .wd-popup--bottom {
+  right: 0;
+  bottom: 0;
+  left: 0;
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-swiper-nav/wd-swiper-nav.js

@@ -0,0 +1,43 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  __name: "wd-swiper-nav",
+  props: common_vendor.swiperNavprops,
+  emits: ["change"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    function handleNav(dir) {
+      const source = "nav";
+      emit("change", { dir, source });
+    }
+    return (_ctx, _cache) => {
+      return common_vendor.e({
+        a: _ctx.showControls
+      }, _ctx.showControls ? {
+        b: common_vendor.o(($event) => handleNav("prev")),
+        c: common_vendor.o(($event) => handleNav("next"))
+      } : {}, {
+        d: _ctx.total >= _ctx.minShowNum
+      }, _ctx.total >= _ctx.minShowNum ? common_vendor.e({
+        e: _ctx.type === "dots" || _ctx.type === "dots-bar"
+      }, _ctx.type === "dots" || _ctx.type === "dots-bar" ? {
+        f: common_vendor.f(_ctx.total, (_, index, i0) => {
+          return {
+            a: index,
+            b: common_vendor.n(`wd-swiper-nav__item--${_ctx.type} ${_ctx.current === index ? "is-active" : ""} is-${_ctx.direction}`)
+          };
+        })
+      } : {}, {
+        g: _ctx.type === "fraction"
+      }, _ctx.type === "fraction" ? {
+        h: common_vendor.t(_ctx.current + 1),
+        i: common_vendor.t(_ctx.total)
+      } : {}, {
+        j: common_vendor.s(_ctx.customStyle),
+        k: common_vendor.n(`wd-swiper-nav wd-swiper-nav--${_ctx.direction} wd-swiper-nav--${_ctx.type} wd-swiper-nav--${_ctx.indicatorPosition} ${_ctx.customClass}`)
+      }) : {});
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-fb3c54f0"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-swiper-nav/wd-swiper-nav.json

@@ -0,0 +1,4 @@
+{
+  "component": true,
+  "usingComponents": {}
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-swiper-nav/wd-swiper-nav.wxml

@@ -0,0 +1 @@
+<view wx:if="{{a}}" class="wd-swiper-nav__btn data-v-fb3c54f0"><view class="wd-swiper-nav__btn--prev data-v-fb3c54f0" bindtap="{{b}}"/><view class="wd-swiper-nav__btn--next data-v-fb3c54f0" bindtap="{{c}}"/></view><view wx:if="{{d}}" style="{{j}}" class="{{['data-v-fb3c54f0', k]}}"><block wx:if="{{e}}"><view wx:for="{{f}}" wx:for-item="_" wx:key="a" class="{{['data-v-fb3c54f0', _.b]}}"></view></block><block wx:if="{{g}}">{{h}}/{{i}}</block></view>

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-swiper-nav/wd-swiper-nav.wxss

@@ -0,0 +1,308 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+ * UI规范基础变量
+ */
+/*----------------------------------------- Theme color. start ----------------------------------------*/
+/* 主题颜色 */
+/* 辅助色 */
+/* 文字颜色（默认浅色背景下 */
+/* 暗黑模式 */
+/* 图形颜色 */
+/*----------------------------------------- Theme color. end -------------------------------------------*/
+/*-------------------------------- Theme color application size.  start --------------------------------*/
+/* 文字字号 */
+/* 文字字重 */
+/* 尺寸 */
+/*-------------------------------- Theme color application size.  end --------------------------------*/
+/* component var */
+/* action-sheet */
+/* badge */
+/* button */
+/* cell */
+/* calendar */
+/* checkbox */
+/* collapse */
+/* divider */
+/* drop-menu */
+/* input-number */
+/* input */
+/* textarea */
+/* loadmore */
+/* message-box */
+/* notice-bar */
+/* pagination */
+/* picker */
+/* col-picker */
+/* overlay */
+/* popup */
+/* progress */
+/* radio */
+/* search */
+/* slider */
+/* sort-button */
+/* steps */
+/* switch */
+/* tabs */
+/* tag */
+/* toast */
+/* loading */
+/* tooltip */
+/* popover */
+/* grid-item */
+/* statustip */
+/* card */
+/* upload */
+/* curtain */
+/* notify */
+/* skeleton */
+/* circle */
+/* swiper */
+/* swiper-nav */
+/* segmented */
+/* tabbar */
+/* tabbar-item */
+/* navbar */
+/* navbar-capsule */
+/* table */
+/* sidebar */
+/* sidebar-item */
+/* fab */
+/* count-down */
+/* keyboard */
+/* number-keyboard */
+/* passwod-input */
+/* form-item */
+/* backtop */
+/* index-bar */
+/* text */
+/* video-preview */
+/* img-cropper */
+/* floating-panel */
+/* signature */
+/**
+ * 混合宏
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+  * BEM，定义块（b)
+  */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 此方法用于生成穿透样式 */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 定义状态（m） */
+/* 定义状态（m） */
+/* 对于需要需要嵌套在 m 底下的 e，调用这个混合宏，一般在切换整个组件的状态，如切换颜色的时候 */
+/* 状态，生成 is-$state 类名 */
+/**
+  * 常用混合宏
+  */
+/* 单行超出隐藏 */
+/* 多行超出隐藏 */
+/* 清除浮动 */
+/* 0.5px 边框 指定方向*/
+/* 0.5px 边框 环绕 */
+/**
+  * 三角形实现尖角样式，适用于背景透明情况
+  * @param $size 三角形高，底边为 $size * 2
+  * @param $bg 三角形背景颜色
+  */
+/**
+  * 正方形实现尖角样式，适用于背景不透明情况
+  * @param $size 正方形边长
+  * @param $bg 正方形背景颜色
+  * @param $z-index z-index属性值，不得大于外部包裹器
+  * @param $box-shadow 阴影
+*/
+.wd-swiper-nav__btn--prev.data-v-fb3c54f0, .wd-swiper-nav__btn--next.data-v-fb3c54f0 {
+  position: absolute;
+  top: 50%;
+  transform: translateY(-50%);
+  width: var(--wot-swiper-nav-btn-size, 48rpx);
+  height: var(--wot-swiper-nav-btn-size, 48rpx);
+  border-radius: 50%;
+  background: var(--wot-swiper-nav-btn-bg-color, var(--wot-font-gray-3, rgba(0, 0, 0, 0.4)));
+}
+.wd-swiper-nav__btn--prev.data-v-fb3c54f0::after, .wd-swiper-nav__btn--next.data-v-fb3c54f0::after {
+  position: absolute;
+  left: 50%;
+  top: 50%;
+  display: block;
+  content: "";
+  width: 12rpx;
+  height: 12rpx;
+  border-color: var(--wot-swiper-nav-btn-color, var(--wot-font-white-1, rgb(255, 255, 255)));
+  border-style: solid;
+}
+.wd-swiper-nav__btn--prev.data-v-fb3c54f0 {
+  left: 30rpx;
+}
+.wd-swiper-nav__btn--prev.data-v-fb3c54f0::after {
+  margin-left: 4rpx;
+  border-width: 2rpx 0 0 2rpx;
+  transform: translate(-50%, -50%) rotateZ(-45deg);
+}
+.wd-swiper-nav__btn--next.data-v-fb3c54f0 {
+  right: 30rpx;
+}
+.wd-swiper-nav__btn--next.data-v-fb3c54f0::after {
+  margin-left: -4rpx;
+  border-width: 2rpx 2rpx 0 0;
+  transform: translate(-50%, -50%) rotateZ(45deg);
+}
+.wd-swiper-nav--dots.data-v-fb3c54f0, .wd-swiper-nav--dots-bar.data-v-fb3c54f0 {
+  display: flex;
+  flex-direction: row;
+}
+.wd-swiper-nav--fraction.data-v-fb3c54f0 {
+  padding: 0 16rpx;
+  height: var(--wot-swiper-nav-fraction-height, 48rpx);
+  line-height: var(--wot-swiper-nav-fraction-height, 48rpx);
+  border-radius: calc(var(--wot-swiper-nav-fraction-height, 48rpx) / 2);
+  background: var(--wot-swiper-nav-fraction-bg-color, var(--wot-font-gray-3, rgba(0, 0, 0, 0.4)));
+  color: var(--wot-swiper-nav-fraction-color, var(--wot-font-white-1, rgb(255, 255, 255)));
+  font-size: var(--wot-swiper-nav-fraction-font-size, 24rpx);
+}
+.wd-swiper-nav__item--dots.data-v-fb3c54f0, .wd-swiper-nav__item--dots-bar.data-v-fb3c54f0 {
+  width: var(--wot-swiper-nav-dot-size, 12rpx);
+  height: var(--wot-swiper-nav-dot-size, 12rpx);
+  background: var(--wot-swiper-nav-dot-color, var(--wot-font-white-2, rgba(255, 255, 255, 0.55)));
+  border-radius: 50%;
+  margin: 0 10rpx;
+  transition: all 0.4s ease-in;
+}
+.wd-swiper-nav__item--dots.is-vertical.data-v-fb3c54f0, .wd-swiper-nav__item--dots-bar.is-vertical.data-v-fb3c54f0 {
+  margin: 10rpx 0;
+}
+.wd-swiper-nav__item--dots.is-active.data-v-fb3c54f0, .wd-swiper-nav__item--dots-bar.is-active.data-v-fb3c54f0 {
+  background-color: var(--wot-swiper-nav-dot-active-color, var(--wot-font-white-1, rgb(255, 255, 255)));
+}
+.wd-swiper-nav__item--dots-bar.is-vertical.is-active.data-v-fb3c54f0 {
+  width: var(--wot-swiper-nav-dot-size, 12rpx);
+  height: var(--wot-swiper-nav-dots-bar-active-width, 40rpx);
+}
+.wd-swiper-nav__item--dots-bar.is-active.data-v-fb3c54f0 {
+  width: var(--wot-swiper-nav-dots-bar-active-width, 40rpx);
+  border-radius: calc(var(--wot-swiper-nav-dot-size, 12rpx) / 2);
+  background-color: var(--wot-swiper-nav-dot-active-color, var(--wot-font-white-1, rgb(255, 255, 255)));
+}
+.wd-swiper-nav--left.data-v-fb3c54f0 {
+  position: absolute;
+  left: 24rpx;
+  top: 50%;
+  transform: translateY(-50%);
+}
+.wd-swiper-nav--right.data-v-fb3c54f0 {
+  position: absolute;
+  right: 24rpx;
+  top: 50%;
+  transform: translateY(-50%);
+}
+.wd-swiper-nav--top-left.data-v-fb3c54f0 {
+  position: absolute;
+  top: 24rpx;
+  left: 24rpx;
+}
+.wd-swiper-nav--top.data-v-fb3c54f0 {
+  position: absolute;
+  left: 50%;
+  top: 24rpx;
+  transform: translateX(-50%);
+}
+.wd-swiper-nav--top-right.data-v-fb3c54f0 {
+  position: absolute;
+  top: 24rpx;
+  right: 24rpx;
+}
+.wd-swiper-nav--bottom-left.data-v-fb3c54f0 {
+  position: absolute;
+  left: 24rpx;
+  bottom: 24rpx;
+}
+.wd-swiper-nav--bottom.data-v-fb3c54f0 {
+  position: absolute;
+  left: 50%;
+  bottom: 24rpx;
+  transform: translateX(-50%);
+}
+.wd-swiper-nav--bottom-right.data-v-fb3c54f0 {
+  position: absolute;
+  right: 24rpx;
+  bottom: 24rpx;
+}
+.wd-swiper-nav--vertical.data-v-fb3c54f0 {
+  flex-direction: column;
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-swiper/wd-swiper.js

@@ -0,0 +1,239 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+if (!Math) {
+  wdSwiperNav();
+}
+const wdSwiperNav = () => "../wd-swiper-nav/wd-swiper-nav.js";
+const __default__ = {
+  name: "wd-swiper",
+  options: {
+    addGlobalClass: true,
+    virtualHost: true,
+    styleIsolation: "shared"
+  }
+};
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  ...__default__,
+  props: common_vendor.swiperProps,
+  emits: ["click", "change", "animationfinish", "update:current"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const navCurrent = common_vendor.ref(props.current);
+    const currentValue = common_vendor.ref(props.current);
+    const updateCurrent = (current, force = false) => {
+      currentValue.value = current;
+      if (force) {
+        navCurrent.value = current;
+      }
+      emit("update:current", current);
+    };
+    const videoPlaying = common_vendor.ref(false);
+    const { proxy } = common_vendor.getCurrentInstance();
+    const uid = common_vendor.ref(common_vendor.uuid());
+    common_vendor.watch(
+      () => props.current,
+      (val) => {
+        if (val < 0) {
+          props.loop ? goToEnd() : goToStart();
+        } else if (val >= props.list.length) {
+          props.loop ? goToStart() : goToEnd();
+        } else {
+          navTo(val);
+        }
+      }
+    );
+    const swiperIndicator = common_vendor.computed(() => {
+      const { list, direction, indicatorPosition, indicator } = props;
+      const swiperIndicator2 = {
+        current: currentValue.value || 0,
+        total: list.length || 0,
+        direction: direction || "horizontal",
+        indicatorPosition: indicatorPosition || "bottom"
+      };
+      if (common_vendor.isObj(indicator)) {
+        swiperIndicator2.type = indicator.type || "dots";
+        swiperIndicator2.minShowNum = indicator.minShowNum || 2;
+        swiperIndicator2.showControls = indicator.showControls || false;
+      }
+      return swiperIndicator2;
+    });
+    const getMediaType = (item, type) => {
+      const checkType = (url) => common_vendor.isVideoUrl(url);
+      if (common_vendor.isObj(item)) {
+        return item.type && ["video", "image"].includes(item.type) ? item.type === type : checkType(item[props.valueKey]);
+      } else {
+        return checkType(item);
+      }
+    };
+    const isVideo = (item) => {
+      return getMediaType(item, "video");
+    };
+    function navTo(index) {
+      if (index === currentValue.value)
+        return;
+      updateCurrent(index, true);
+    }
+    function goToStart() {
+      navTo(0);
+    }
+    function goToEnd() {
+      navTo(props.list.length - 1);
+    }
+    function handleVideoPaly() {
+      props.stopAutoplayWhenVideoPlay && (videoPlaying.value = true);
+    }
+    function handleVideoPause() {
+      videoPlaying.value = false;
+    }
+    function isPrev(current, index, list) {
+      return (current - 1 + list.length) % list.length === index;
+    }
+    function isNext(current, index, list) {
+      return (current + 1 + list.length) % list.length === index;
+    }
+    function getCustomItemClass(current, index, list) {
+      let customItemClass = "";
+      if (isPrev(current, index, list)) {
+        customItemClass = props.customPrevClass || props.customPrevImageClass;
+      }
+      if (isNext(current, index, list)) {
+        customItemClass = props.customNextClass || props.customNextImageClass;
+      }
+      return customItemClass;
+    }
+    function handleChange(e) {
+      const { current, source } = e.detail;
+      const previous = currentValue.value;
+      emit("change", { current, source });
+      if (current !== currentValue.value) {
+        const forceUpdate = source === "autoplay" || source === "touch";
+        updateCurrent(current, forceUpdate);
+      }
+      handleVideoChange(previous, current);
+    }
+    function handleVideoChange(previous, current) {
+      handleStopVideoPaly(previous);
+      handleStartVideoPaly(current);
+    }
+    function handleStartVideoPaly(index) {
+      if (props.autoplayVideo) {
+        const currentItem = props.list[index];
+        if (common_vendor.isDef(currentItem) && isVideo(currentItem)) {
+          const video = common_vendor.index.createVideoContext(`video-${index}-${uid.value}`, proxy);
+          video.play();
+        }
+      }
+    }
+    function handleStopVideoPaly(index) {
+      if (props.stopPreviousVideo) {
+        const previousItem = props.list[index];
+        if (common_vendor.isDef(previousItem) && isVideo(previousItem)) {
+          const video = common_vendor.index.createVideoContext(`video-${index}-${uid.value}`, proxy);
+          video.pause();
+        }
+      } else if (props.stopAutoplayWhenVideoPlay) {
+        handleVideoPause();
+      }
+    }
+    function handleAnimationfinish(e) {
+      const { current, source } = e.detail;
+      if (current !== currentValue.value) {
+        const forceUpdate = source === "autoplay" || source === "touch";
+        updateCurrent(current, forceUpdate);
+      }
+      emit("animationfinish", { current, source });
+    }
+    function handleClick(index, item) {
+      emit("click", { index, item });
+    }
+    function handleIndicatorChange({ dir }) {
+      const { list, loop } = props;
+      const total = list.length;
+      let nextPos = dir === "next" ? currentValue.value + 1 : currentValue.value - 1;
+      if (loop) {
+        nextPos = dir === "next" ? (currentValue.value + 1) % total : (currentValue.value - 1 + total) % total;
+      } else {
+        nextPos = nextPos < 0 || nextPos >= total ? currentValue.value : nextPos;
+      }
+      if (nextPos === currentValue.value)
+        return;
+      navTo(nextPos);
+    }
+    return (_ctx, _cache) => {
+      return common_vendor.e({
+        a: common_vendor.f(_ctx.list, (item, index, i0) => {
+          return common_vendor.e({
+            a: isVideo(item)
+          }, isVideo(item) ? {
+            b: `video-${index}-${uid.value}`,
+            c: common_vendor.unref(common_vendor.addUnit)(_ctx.height),
+            d: common_vendor.unref(common_vendor.isObj)(item) ? item[_ctx.valueKey] : item,
+            e: common_vendor.unref(common_vendor.isObj)(item) ? item.poster : "",
+            f: common_vendor.n(`wd-swiper__video ${_ctx.customItemClass} ${getCustomItemClass(currentValue.value, index, _ctx.list)}`),
+            g: common_vendor.o(handleVideoPaly, index),
+            h: common_vendor.o(handleVideoPause, index),
+            i: _ctx.videoLoop,
+            j: _ctx.muted,
+            k: _ctx.autoplayVideo,
+            l: common_vendor.o(($event) => handleClick(index, item), index)
+          } : {
+            m: common_vendor.unref(common_vendor.isObj)(item) ? item[_ctx.valueKey] : item,
+            n: common_vendor.n(`wd-swiper__image ${_ctx.customImageClass} ${_ctx.customItemClass} ${getCustomItemClass(currentValue.value, index, _ctx.list)}`),
+            o: common_vendor.unref(common_vendor.addUnit)(_ctx.height),
+            p: _ctx.imageMode,
+            q: common_vendor.o(($event) => handleClick(index, item), index)
+          }, {
+            r: common_vendor.unref(common_vendor.isObj)(item) && item[_ctx.textKey]
+          }, common_vendor.unref(common_vendor.isObj)(item) && item[_ctx.textKey] ? {
+            s: common_vendor.t(item[_ctx.textKey]),
+            t: common_vendor.n(`wd-swiper__text ${_ctx.customTextClass}`),
+            v: common_vendor.s(_ctx.customTextStyle)
+          } : {}, {
+            w: index
+          });
+        }),
+        b: _ctx.adjustHeight,
+        c: _ctx.adjustVerticalHeight,
+        d: _ctx.autoplay && !videoPlaying.value,
+        e: navCurrent.value,
+        f: _ctx.interval,
+        g: _ctx.duration,
+        h: _ctx.loop,
+        i: _ctx.direction == "vertical",
+        j: _ctx.easingFunction,
+        k: common_vendor.unref(common_vendor.addUnit)(_ctx.previousMargin),
+        l: common_vendor.unref(common_vendor.addUnit)(_ctx.nextMargin),
+        m: _ctx.snapToEdge,
+        n: _ctx.displayMultipleItems,
+        o: common_vendor.unref(common_vendor.addUnit)(_ctx.height),
+        p: common_vendor.o(handleChange),
+        q: common_vendor.o(handleAnimationfinish),
+        r: _ctx.indicator
+      }, _ctx.indicator ? common_vendor.e({
+        s: common_vendor.r("indicator", {
+          current: currentValue.value,
+          total: _ctx.list.length
+        }),
+        t: !_ctx.$slots.indicator
+      }, !_ctx.$slots.indicator ? {
+        v: common_vendor.o(handleIndicatorChange),
+        w: common_vendor.p({
+          ["custom-class"]: _ctx.customIndicatorClass,
+          type: swiperIndicator.value.type,
+          current: swiperIndicator.value.current,
+          total: swiperIndicator.value.total,
+          direction: swiperIndicator.value.direction,
+          ["indicator-position"]: swiperIndicator.value.indicatorPosition,
+          ["min-show-num"]: swiperIndicator.value.minShowNum,
+          ["show-controls"]: swiperIndicator.value.showControls
+        })
+      } : {}) : {}, {
+        x: common_vendor.n(`wd-swiper ${_ctx.customClass}`),
+        y: common_vendor.s(_ctx.customStyle)
+      });
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-6e972027"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-swiper/wd-swiper.json

@@ -0,0 +1,6 @@
+{
+  "component": true,
+  "usingComponents": {
+    "wd-swiper-nav": "../wd-swiper-nav/wd-swiper-nav"
+  }
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-swiper/wd-swiper.wxml

@@ -0,0 +1 @@
+<view class="{{['data-v-6e972027', x]}}" style="{{y}}"><scroll-view class="data-v-6e972027" scroll-x scroll-y style="width:100%;height:100%"><swiper adjust-height="{{b}}" adjust-vertical-height="{{c}}" class="wd-swiper__track data-v-6e972027" autoplay="{{d}}" current="{{e}}" interval="{{f}}" duration="{{g}}" circular="{{h}}" vertical="{{i}}" easing-function="{{j}}" previous-margin="{{k}}" next-margin="{{l}}" snap-to-edge="{{m}}" display-multiple-items="{{n}}" style="{{'height:' + o}}" bindchange="{{p}}" bindanimationfinish="{{q}}"><swiper-item wx:for="{{a}}" wx:for-item="item" wx:key="w" class="wd-swiper__item data-v-6e972027"><video wx:if="{{item.a}}" id="{{item.b}}" style="{{'height:' + item.c}}" src="{{item.d}}" poster="{{item.e}}" class="{{['data-v-6e972027', item.f]}}" bindplay="{{item.g}}" bindpause="{{item.h}}" enable-progress-gesture="{{false}}" loop="{{item.i}}" muted="{{item.j}}" autoplay="{{item.k}}" objectFit="cover" bindtap="{{item.l}}"/><image wx:else src="{{item.m}}" class="{{['data-v-6e972027', item.n]}}" style="{{'height:' + item.o}}" mode="{{item.p}}" bindtap="{{item.q}}"/><text wx:if="{{item.r}}" class="{{['data-v-6e972027', item.t]}}" style="{{item.v}}">{{item.s}}</text></swiper-item></swiper></scroll-view><block wx:if="{{r}}"><slot name="indicator"></slot><wd-swiper-nav wx:if="{{t}}" class="data-v-6e972027" bindchange="{{v}}" u-i="6e972027-0" bind:__l="__l" u-p="{{w}}"/></block></view>

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-swiper/wd-swiper.wxss

@@ -0,0 +1,214 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+ * UI规范基础变量
+ */
+/*----------------------------------------- Theme color. start ----------------------------------------*/
+/* 主题颜色 */
+/* 辅助色 */
+/* 文字颜色（默认浅色背景下 */
+/* 暗黑模式 */
+/* 图形颜色 */
+/*----------------------------------------- Theme color. end -------------------------------------------*/
+/*-------------------------------- Theme color application size.  start --------------------------------*/
+/* 文字字号 */
+/* 文字字重 */
+/* 尺寸 */
+/*-------------------------------- Theme color application size.  end --------------------------------*/
+/* component var */
+/* action-sheet */
+/* badge */
+/* button */
+/* cell */
+/* calendar */
+/* checkbox */
+/* collapse */
+/* divider */
+/* drop-menu */
+/* input-number */
+/* input */
+/* textarea */
+/* loadmore */
+/* message-box */
+/* notice-bar */
+/* pagination */
+/* picker */
+/* col-picker */
+/* overlay */
+/* popup */
+/* progress */
+/* radio */
+/* search */
+/* slider */
+/* sort-button */
+/* steps */
+/* switch */
+/* tabs */
+/* tag */
+/* toast */
+/* loading */
+/* tooltip */
+/* popover */
+/* grid-item */
+/* statustip */
+/* card */
+/* upload */
+/* curtain */
+/* notify */
+/* skeleton */
+/* circle */
+/* swiper */
+/* swiper-nav */
+/* segmented */
+/* tabbar */
+/* tabbar-item */
+/* navbar */
+/* navbar-capsule */
+/* table */
+/* sidebar */
+/* sidebar-item */
+/* fab */
+/* count-down */
+/* keyboard */
+/* number-keyboard */
+/* passwod-input */
+/* form-item */
+/* backtop */
+/* index-bar */
+/* text */
+/* video-preview */
+/* img-cropper */
+/* floating-panel */
+/* signature */
+/**
+ * 混合宏
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+  * BEM，定义块（b)
+  */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 此方法用于生成穿透样式 */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 定义状态（m） */
+/* 定义状态（m） */
+/* 对于需要需要嵌套在 m 底下的 e，调用这个混合宏，一般在切换整个组件的状态，如切换颜色的时候 */
+/* 状态，生成 is-$state 类名 */
+/**
+  * 常用混合宏
+  */
+/* 单行超出隐藏 */
+/* 多行超出隐藏 */
+/* 清除浮动 */
+/* 0.5px 边框 指定方向*/
+/* 0.5px 边框 环绕 */
+/**
+  * 三角形实现尖角样式，适用于背景透明情况
+  * @param $size 三角形高，底边为 $size * 2
+  * @param $bg 三角形背景颜色
+  */
+/**
+  * 正方形实现尖角样式，适用于背景不透明情况
+  * @param $size 正方形边长
+  * @param $bg 正方形背景颜色
+  * @param $z-index z-index属性值，不得大于外部包裹器
+  * @param $box-shadow 阴影
+*/
+.wd-swiper.data-v-6e972027 {
+  position: relative;
+}
+.wd-swiper__track.data-v-6e972027 {
+  border-radius: var(--wot-swiper-radius, 8px);
+  overflow: hidden;
+  transform: translateY(0);
+}
+.wd-swiper__item.data-v-6e972027 {
+  display: flex;
+  align-items: center;
+  box-sizing: border-box;
+  padding: var(--wot-swiper-item-padding, 0);
+}
+.wd-swiper__image.data-v-6e972027, .wd-swiper__video.data-v-6e972027 {
+  width: 100%;
+  transition: all 0.3s ease;
+}
+.wd-swiper__text.data-v-6e972027 {
+  position: absolute;
+  right: 24rpx;
+  top: 24rpx;
+  color: var(--wot-swiper-item-text-color, #ffffff);
+  font-size: var(--wot-swiper-item-text-fs, var(--wot-fs-title, 16px));
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-tag/wd-tag.js

@@ -0,0 +1,153 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+if (!Math) {
+  wdIcon();
+}
+const wdIcon = () => "../wd-icon/wd-icon.js";
+const __default__ = {
+  name: "wd-tag",
+  options: {
+    addGlobalClass: true,
+    virtualHost: true,
+    styleIsolation: "shared"
+  }
+};
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  ...__default__,
+  props: common_vendor.tagProps,
+  emits: ["click", "close", "confirm"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { translate } = common_vendor.useTranslate("tag");
+    const tagClass = common_vendor.ref("");
+    const dynamicValue = common_vendor.ref("");
+    const dynamicInput = common_vendor.ref(false);
+    common_vendor.watch(
+      [() => props.useIconSlot, () => props.icon, () => props.plain, () => props.dynamic, () => props.round, () => props.mark],
+      () => {
+        computeTagClass();
+      },
+      { deep: true, immediate: true }
+    );
+    common_vendor.watch(
+      () => props.type,
+      (newValue) => {
+        if (!newValue)
+          return;
+        const type = ["primary", "danger", "warning", "success", "default"];
+        if (type.indexOf(newValue) === -1)
+          console.error(`type must be one of ${type.toString()}`);
+        computeTagClass();
+      },
+      { deep: true, immediate: true }
+    );
+    common_vendor.watch(
+      () => dynamicInput.value,
+      () => {
+        computeTagClass();
+      },
+      { deep: true, immediate: true }
+    );
+    const rootClass = common_vendor.computed(() => {
+      return `wd-tag ${props.customClass} ${tagClass.value}`;
+    });
+    const rootStyle = common_vendor.computed(() => {
+      const rootStyle2 = {};
+      if (!props.plain && props.bgColor) {
+        rootStyle2["background"] = props.bgColor;
+      }
+      if (props.bgColor) {
+        rootStyle2["border-color"] = props.bgColor;
+      }
+      return `${common_vendor.objToStyle(rootStyle2)}${props.customStyle}`;
+    });
+    const textStyle = common_vendor.computed(() => {
+      const textStyle2 = {};
+      if (props.color) {
+        textStyle2["color"] = props.color;
+      }
+      return common_vendor.objToStyle(textStyle2);
+    });
+    function computeTagClass() {
+      const { type, plain, round, mark, dynamic, icon, useIconSlot } = props;
+      let tagClassList = [];
+      type && tagClassList.push(`is-${type}`);
+      plain && tagClassList.push("is-plain");
+      round && tagClassList.push("is-round");
+      mark && tagClassList.push("is-mark");
+      dynamic && tagClassList.push("is-dynamic");
+      dynamicInput.value && tagClassList.push("is-dynamic-input");
+      if (icon || useIconSlot)
+        tagClassList.push("is-icon");
+      tagClass.value = tagClassList.join(" ");
+    }
+    function handleClick(event) {
+      emit("click", event);
+    }
+    function handleClose(event) {
+      emit("close", event);
+    }
+    function handleAdd() {
+      dynamicInput.value = true;
+      dynamicValue.value = "";
+    }
+    function handleBlur() {
+      setDynamicInput();
+    }
+    function handleConfirm(event) {
+      setDynamicInput();
+      emit("confirm", {
+        value: event.detail.value
+      });
+    }
+    function setDynamicInput() {
+      dynamicInput.value = false;
+    }
+    return (_ctx, _cache) => {
+      return common_vendor.e({
+        a: _ctx.useIconSlot
+      }, _ctx.useIconSlot ? {} : _ctx.icon ? {
+        c: common_vendor.p({
+          name: _ctx.icon,
+          ["custom-class"]: "wd-tag__icon"
+        })
+      } : {}, {
+        b: _ctx.icon,
+        d: common_vendor.s(textStyle.value),
+        e: _ctx.closable && _ctx.round
+      }, _ctx.closable && _ctx.round ? {
+        f: common_vendor.p({
+          name: "error-fill"
+        }),
+        g: common_vendor.o(handleClose)
+      } : {}, {
+        h: dynamicInput.value && _ctx.dynamic
+      }, dynamicInput.value && _ctx.dynamic ? {
+        i: common_vendor.unref(translate)("placeholder"),
+        j: common_vendor.o(handleBlur),
+        k: common_vendor.o(handleConfirm),
+        l: dynamicValue.value,
+        m: common_vendor.o(($event) => dynamicValue.value = $event.detail.value)
+      } : _ctx.dynamic ? common_vendor.e({
+        o: _ctx.$slots.add
+      }, _ctx.$slots.add ? {} : {
+        p: common_vendor.p({
+          name: "add",
+          ["custom-class"]: "wd-tag__add wd-tag__icon"
+        }),
+        q: common_vendor.t(common_vendor.unref(translate)("add"))
+      }, {
+        r: common_vendor.s(textStyle.value),
+        s: common_vendor.o(handleAdd)
+      }) : {}, {
+        n: _ctx.dynamic,
+        t: common_vendor.n(rootClass.value),
+        v: common_vendor.s(rootStyle.value),
+        w: common_vendor.o(handleClick)
+      });
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-14921b29"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-tag/wd-tag.json

@@ -0,0 +1,6 @@
+{
+  "component": true,
+  "usingComponents": {
+    "wd-icon": "../wd-icon/wd-icon"
+  }
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-tag/wd-tag.wxml

@@ -0,0 +1 @@
+<view class="{{['data-v-14921b29', t]}}" style="{{v}}" bindtap="{{w}}"><view wx:if="{{a}}" class="wd-tag__icon data-v-14921b29"><slot name="icon"/></view><wd-icon wx:elif="{{b}}" class="data-v-14921b29" u-i="14921b29-0" bind:__l="__l" u-p="{{c}}"/><view class="wd-tag__text data-v-14921b29" style="{{d}}"><slot/></view><view wx:if="{{e}}" class="wd-tag__close data-v-14921b29" catchtap="{{g}}"><wd-icon wx:if="{{f}}" class="data-v-14921b29" u-i="14921b29-1" bind:__l="__l" u-p="{{f}}"/></view><input wx:if="{{h}}" class="wd-tag__add-text data-v-14921b29" placeholder="{{i}}" type="text" focus="{{true}}" bindblur="{{j}}" bindconfirm="{{k}}" value="{{l}}" bindinput="{{m}}"/><view wx:elif="{{n}}" class="wd-tag__text data-v-14921b29" style="{{r}}" catchtap="{{s}}"><slot wx:if="{{o}}" name="add"></slot><block wx:else><wd-icon wx:if="{{p}}" class="data-v-14921b29" u-i="14921b29-2" bind:__l="__l" u-p="{{p}}"/><text class="data-v-14921b29">{{q}}</text></block></view></view>

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-tag/wd-tag.wxss

@@ -0,0 +1,397 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+ * UI规范基础变量
+ */
+/*----------------------------------------- Theme color. start ----------------------------------------*/
+/* 主题颜色 */
+/* 辅助色 */
+/* 文字颜色（默认浅色背景下 */
+/* 暗黑模式 */
+/* 图形颜色 */
+/*----------------------------------------- Theme color. end -------------------------------------------*/
+/*-------------------------------- Theme color application size.  start --------------------------------*/
+/* 文字字号 */
+/* 文字字重 */
+/* 尺寸 */
+/*-------------------------------- Theme color application size.  end --------------------------------*/
+/* component var */
+/* action-sheet */
+/* badge */
+/* button */
+/* cell */
+/* calendar */
+/* checkbox */
+/* collapse */
+/* divider */
+/* drop-menu */
+/* input-number */
+/* input */
+/* textarea */
+/* loadmore */
+/* message-box */
+/* notice-bar */
+/* pagination */
+/* picker */
+/* col-picker */
+/* overlay */
+/* popup */
+/* progress */
+/* radio */
+/* search */
+/* slider */
+/* sort-button */
+/* steps */
+/* switch */
+/* tabs */
+/* tag */
+/* toast */
+/* loading */
+/* tooltip */
+/* popover */
+/* grid-item */
+/* statustip */
+/* card */
+/* upload */
+/* curtain */
+/* notify */
+/* skeleton */
+/* circle */
+/* swiper */
+/* swiper-nav */
+/* segmented */
+/* tabbar */
+/* tabbar-item */
+/* navbar */
+/* navbar-capsule */
+/* table */
+/* sidebar */
+/* sidebar-item */
+/* fab */
+/* count-down */
+/* keyboard */
+/* number-keyboard */
+/* passwod-input */
+/* form-item */
+/* backtop */
+/* index-bar */
+/* text */
+/* video-preview */
+/* img-cropper */
+/* floating-panel */
+/* signature */
+/**
+ * 混合宏
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+  * BEM，定义块（b)
+  */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 此方法用于生成穿透样式 */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 定义状态（m） */
+/* 定义状态（m） */
+/* 对于需要需要嵌套在 m 底下的 e，调用这个混合宏，一般在切换整个组件的状态，如切换颜色的时候 */
+/* 状态，生成 is-$state 类名 */
+/**
+  * 常用混合宏
+  */
+/* 单行超出隐藏 */
+/* 多行超出隐藏 */
+/* 清除浮动 */
+/* 0.5px 边框 指定方向*/
+/* 0.5px 边框 环绕 */
+/**
+  * 三角形实现尖角样式，适用于背景透明情况
+  * @param $size 三角形高，底边为 $size * 2
+  * @param $bg 三角形背景颜色
+  */
+/**
+  * 正方形实现尖角样式，适用于背景不透明情况
+  * @param $size 正方形边长
+  * @param $bg 正方形背景颜色
+  * @param $z-index z-index属性值，不得大于外部包裹器
+  * @param $box-shadow 阴影
+*/
+.wd-tag.data-v-14921b29 {
+  font-size: var(--wot-tag-small-fs, var(--wot-fs-aid, 10px));
+  display: inline-block;
+  color: var(--wot-tag-color, var(--wot-color-white, rgb(255, 255, 255)));
+  padding: 0 3px;
+  border-radius: 2px;
+  transition: opacity 0.3s;
+  vertical-align: middle;
+  line-height: initial;
+}
+.wd-tag.is-default.data-v-14921b29 {
+  background: var(--wot-tag-info-bg, linear-gradient(49deg,#808080 0%,#999999 100%));
+}
+.wd-tag.is-default.is-plain.data-v-14921b29 {
+  background: transparent;
+  color: var(--wot-tag-info-color, #585858);
+  border: 1px solid var(--wot-tag-info-color, #585858);
+  padding: 0 4px;
+}
+.wd-tag.is-default.is-round.data-v-14921b29 {
+  line-height: 1.2;
+  font-size: var(--wot-tag-fs, var(--wot-fs-secondary, 12px));
+  padding: 4px 11px;
+  background: transparent;
+  color: var(--wot-tag-round-color, rgb(102, 102, 102));
+  border: 1px solid var(--wot-tag-round-border-color, rgb(225, 225, 225));
+  border-radius: var(--wot-tag-round-radius, 12px);
+}
+.wd-tag.is-default.is-mark.data-v-14921b29 {
+  padding: 1px 6px;
+  border-radius: var(--wot-tag-mark-radius, 6px 2px 6px 2px);
+}
+.wd-tag.is-default.is-mark.is-plain.data-v-14921b29 {
+  padding: 0 6px;
+}
+.wd-tag.is-default.is-active.data-v-14921b29 {
+  color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+  border-color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+}
+.wd-tag.is-primary.data-v-14921b29 {
+  background: var(--wot-tag-primary-bg, var(--wot-color-theme, #4d80f0));
+}
+.wd-tag.is-primary.is-plain.data-v-14921b29 {
+  background: transparent;
+  color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+  border: 1px solid var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+  padding: 0 4px;
+}
+.wd-tag.is-primary.is-round.data-v-14921b29 {
+  line-height: 1.2;
+  font-size: var(--wot-tag-fs, var(--wot-fs-secondary, 12px));
+  padding: 4px 11px;
+  background: transparent;
+  color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+  border: 1px solid var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+  border-radius: var(--wot-tag-round-radius, 12px);
+}
+.wd-tag.is-primary.is-mark.data-v-14921b29 {
+  padding: 1px 6px;
+  border-radius: var(--wot-tag-mark-radius, 6px 2px 6px 2px);
+}
+.wd-tag.is-primary.is-mark.is-plain.data-v-14921b29 {
+  padding: 0 6px;
+}
+.wd-tag.is-primary.is-active.data-v-14921b29 {
+  color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+  border-color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+}
+.wd-tag.is-danger.data-v-14921b29 {
+  background: var(--wot-tag-danger-bg, var(--wot-color-danger, #fa4350));
+}
+.wd-tag.is-danger.is-plain.data-v-14921b29 {
+  background: transparent;
+  color: var(--wot-tag-danger-color, var(--wot-color-danger, #fa4350));
+  border: 1px solid var(--wot-tag-danger-color, var(--wot-color-danger, #fa4350));
+  padding: 0 4px;
+}
+.wd-tag.is-danger.is-round.data-v-14921b29 {
+  line-height: 1.2;
+  font-size: var(--wot-tag-fs, var(--wot-fs-secondary, 12px));
+  padding: 4px 11px;
+  background: transparent;
+  color: var(--wot-tag-danger-color, var(--wot-color-danger, #fa4350));
+  border: 1px solid var(--wot-tag-danger-color, var(--wot-color-danger, #fa4350));
+  border-radius: var(--wot-tag-round-radius, 12px);
+}
+.wd-tag.is-danger.is-mark.data-v-14921b29 {
+  padding: 1px 6px;
+  border-radius: var(--wot-tag-mark-radius, 6px 2px 6px 2px);
+}
+.wd-tag.is-danger.is-mark.is-plain.data-v-14921b29 {
+  padding: 0 6px;
+}
+.wd-tag.is-danger.is-active.data-v-14921b29 {
+  color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+  border-color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+}
+.wd-tag.is-warning.data-v-14921b29 {
+  background: var(--wot-tag-warning-bg, var(--wot-color-warning, #f0883a));
+}
+.wd-tag.is-warning.is-plain.data-v-14921b29 {
+  background: transparent;
+  color: var(--wot-tag-warning-color, var(--wot-color-warning, #f0883a));
+  border: 1px solid var(--wot-tag-warning-color, var(--wot-color-warning, #f0883a));
+  padding: 0 4px;
+}
+.wd-tag.is-warning.is-round.data-v-14921b29 {
+  line-height: 1.2;
+  font-size: var(--wot-tag-fs, var(--wot-fs-secondary, 12px));
+  padding: 4px 11px;
+  background: transparent;
+  color: var(--wot-tag-warning-color, var(--wot-color-warning, #f0883a));
+  border: 1px solid var(--wot-tag-warning-color, var(--wot-color-warning, #f0883a));
+  border-radius: var(--wot-tag-round-radius, 12px);
+}
+.wd-tag.is-warning.is-mark.data-v-14921b29 {
+  padding: 1px 6px;
+  border-radius: var(--wot-tag-mark-radius, 6px 2px 6px 2px);
+}
+.wd-tag.is-warning.is-mark.is-plain.data-v-14921b29 {
+  padding: 0 6px;
+}
+.wd-tag.is-warning.is-active.data-v-14921b29 {
+  color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+  border-color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+}
+.wd-tag.is-success.data-v-14921b29 {
+  background: var(--wot-tag-success-bg, var(--wot-color-success, #34d19d));
+}
+.wd-tag.is-success.is-plain.data-v-14921b29 {
+  background: transparent;
+  color: var(--wot-tag-success-color, var(--wot-color-success, #34d19d));
+  border: 1px solid var(--wot-tag-success-color, var(--wot-color-success, #34d19d));
+  padding: 0 4px;
+}
+.wd-tag.is-success.is-round.data-v-14921b29 {
+  line-height: 1.2;
+  font-size: var(--wot-tag-fs, var(--wot-fs-secondary, 12px));
+  padding: 4px 11px;
+  background: transparent;
+  color: var(--wot-tag-success-color, var(--wot-color-success, #34d19d));
+  border: 1px solid var(--wot-tag-success-color, var(--wot-color-success, #34d19d));
+  border-radius: var(--wot-tag-round-radius, 12px);
+}
+.wd-tag.is-success.is-mark.data-v-14921b29 {
+  padding: 1px 6px;
+  border-radius: var(--wot-tag-mark-radius, 6px 2px 6px 2px);
+}
+.wd-tag.is-success.is-mark.is-plain.data-v-14921b29 {
+  padding: 0 6px;
+}
+.wd-tag.is-success.is-active.data-v-14921b29 {
+  color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+  border-color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+}
+.wd-tag.is-icon.data-v-14921b29 {
+  font-size: var(--wot-tag-fs, var(--wot-fs-secondary, 12px));
+  line-height: 1.2;
+  padding: 2px 5px;
+}
+.wd-tag.is-dynamic.data-v-14921b29 {
+  box-sizing: border-box;
+  width: 88px;
+  transition: 0.3s;
+}
+.wd-tag.is-dynamic.data-v-14921b29:active {
+  color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+  border-color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+}
+.wd-tag.is-dynamic-input.data-v-14921b29 {
+  border-color: var(--wot-tag-primary-color, var(--wot-color-theme, #4d80f0));
+}
+.data-v-14921b29  .wd-tag__icon {
+  display: inline-block;
+  margin-right: 4px;
+  font-size: var(--wot-tag-fs, var(--wot-fs-secondary, 12px));
+  line-height: 1.2;
+  vertical-align: baseline;
+}
+.wd-tag__text.data-v-14921b29 {
+  display: inline-block;
+  vertical-align: text-top;
+}
+.wd-tag__add-text.data-v-14921b29 {
+  width: 60px;
+  height: 14px;
+  min-height: 14px;
+  display: inline-block;
+  font-size: var(--wot-tag-fs, var(--wot-fs-secondary, 12px));
+  vertical-align: middle;
+  padding: 0;
+}
+.wd-tag__close.data-v-14921b29 {
+  display: inline-block;
+  margin-left: 24px;
+  margin-right: -4px;
+  font-size: var(--wot-tag-close-size, 14px);
+  height: 14px;
+  line-height: 1.1;
+  vertical-align: text-bottom;
+  color: var(--wot-tag-close-color, var(--wot-tag-info-color, #585858));
+}
+.wd-tag__close.data-v-14921b29:active {
+  color: var(--wot-tag-close-active-color, rgba(0, 0, 0, 0.45));
+}
+.data-v-14921b29  .wd-tag__add {
+  vertical-align: bottom;
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-transition/wd-transition.js

@@ -0,0 +1,179 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+const __default__ = {
+  name: "wd-transition",
+  options: {
+    addGlobalClass: true,
+    virtualHost: true,
+    styleIsolation: "shared"
+  }
+};
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  ...__default__,
+  props: common_vendor.transitionProps,
+  emits: ["click", "before-enter", "enter", "before-leave", "leave", "after-leave", "after-enter"],
+  setup(__props, { emit: __emit }) {
+    const getClassNames = (name) => {
+      let enter2 = `${props.enterClass} ${props.enterActiveClass}`;
+      let enterTo = `${props.enterToClass} ${props.enterActiveClass}`;
+      let leave2 = `${props.leaveClass} ${props.leaveActiveClass}`;
+      let leaveTo = `${props.leaveToClass} ${props.leaveActiveClass}`;
+      if (Array.isArray(name)) {
+        for (let index = 0; index < name.length; index++) {
+          enter2 = `wd-${name[index]}-enter wd-${name[index]}-enter-active ${enter2}`;
+          enterTo = `wd-${name[index]}-enter-to wd-${name[index]}-enter-active ${enterTo}`;
+          leave2 = `wd-${name[index]}-leave wd-${name[index]}-leave-active ${leave2}`;
+          leaveTo = `wd-${name[index]}-leave-to wd-${name[index]}-leave-active ${leaveTo}`;
+        }
+      } else if (name) {
+        enter2 = `wd-${name}-enter wd-${name}-enter-active ${enter2}`;
+        enterTo = `wd-${name}-enter-to wd-${name}-enter-active ${enterTo}`;
+        leave2 = `wd-${name}-leave wd-${name}-leave-active ${leave2}`;
+        leaveTo = `wd-${name}-leave-to wd-${name}-leave-active ${leaveTo}`;
+      }
+      return {
+        enter: enter2,
+        "enter-to": enterTo,
+        leave: leave2,
+        "leave-to": leaveTo
+      };
+    };
+    const props = __props;
+    const emit = __emit;
+    const inited = common_vendor.ref(false);
+    const display = common_vendor.ref(false);
+    const status = common_vendor.ref("");
+    const transitionEnded = common_vendor.ref(false);
+    const currentDuration = common_vendor.ref(300);
+    const classes = common_vendor.ref("");
+    const enterPromise = common_vendor.ref(null);
+    const enterLifeCyclePromises = common_vendor.ref(null);
+    const leaveLifeCyclePromises = common_vendor.ref(null);
+    const style = common_vendor.computed(() => {
+      return `-webkit-transition-duration:${currentDuration.value}ms;transition-duration:${currentDuration.value}ms;${display.value || !props.destroy ? "" : "display: none;"}${props.customStyle}`;
+    });
+    const rootClass = common_vendor.computed(() => {
+      return `wd-transition ${props.customClass}  ${classes.value}`;
+    });
+    common_vendor.onBeforeMount(() => {
+      if (props.show) {
+        enter();
+      }
+    });
+    common_vendor.watch(
+      () => props.show,
+      (newVal) => {
+        handleShow(newVal);
+      },
+      { deep: true }
+    );
+    function handleClick() {
+      emit("click");
+    }
+    function handleShow(value) {
+      if (value) {
+        handleAbortPromise();
+        enter();
+      } else {
+        leave();
+      }
+    }
+    function handleAbortPromise() {
+      common_vendor.isPromise(enterPromise.value) && enterPromise.value.abort();
+      common_vendor.isPromise(enterLifeCyclePromises.value) && enterLifeCyclePromises.value.abort();
+      common_vendor.isPromise(leaveLifeCyclePromises.value) && leaveLifeCyclePromises.value.abort();
+      enterPromise.value = null;
+      enterLifeCyclePromises.value = null;
+      leaveLifeCyclePromises.value = null;
+    }
+    function enter() {
+      enterPromise.value = new common_vendor.AbortablePromise(async (resolve) => {
+        try {
+          const classNames = getClassNames(props.name);
+          const duration = common_vendor.isObj(props.duration) ? props.duration.enter : props.duration;
+          status.value = "enter";
+          emit("before-enter");
+          enterLifeCyclePromises.value = common_vendor.pause();
+          await enterLifeCyclePromises.value;
+          emit("enter");
+          classes.value = classNames.enter;
+          currentDuration.value = duration;
+          enterLifeCyclePromises.value = common_vendor.pause();
+          await enterLifeCyclePromises.value;
+          inited.value = true;
+          display.value = true;
+          enterLifeCyclePromises.value = common_vendor.pause();
+          await enterLifeCyclePromises.value;
+          enterLifeCyclePromises.value = null;
+          transitionEnded.value = false;
+          classes.value = classNames["enter-to"];
+          resolve();
+        } catch (error) {
+        }
+      });
+    }
+    async function leave() {
+      if (!enterPromise.value) {
+        transitionEnded.value = false;
+        return onTransitionEnd();
+      }
+      try {
+        await enterPromise.value;
+        if (!display.value)
+          return;
+        const classNames = getClassNames(props.name);
+        const duration = common_vendor.isObj(props.duration) ? props.duration.leave : props.duration;
+        status.value = "leave";
+        emit("before-leave");
+        currentDuration.value = duration;
+        leaveLifeCyclePromises.value = common_vendor.pause();
+        await leaveLifeCyclePromises.value;
+        emit("leave");
+        classes.value = classNames.leave;
+        leaveLifeCyclePromises.value = common_vendor.pause();
+        await leaveLifeCyclePromises.value;
+        transitionEnded.value = false;
+        classes.value = classNames["leave-to"];
+        leaveLifeCyclePromises.value = setPromise(currentDuration.value);
+        await leaveLifeCyclePromises.value;
+        leaveLifeCyclePromises.value = null;
+        onTransitionEnd();
+        enterPromise.value = null;
+      } catch (error) {
+      }
+    }
+    function setPromise(duration) {
+      return new common_vendor.AbortablePromise((resolve) => {
+        const timer = setTimeout(() => {
+          clearTimeout(timer);
+          resolve();
+        }, duration);
+      });
+    }
+    function onTransitionEnd() {
+      if (transitionEnded.value)
+        return;
+      transitionEnded.value = true;
+      if (status.value === "leave") {
+        emit("after-leave");
+      } else if (status.value === "enter") {
+        emit("after-enter");
+      }
+      if (!props.show && display.value) {
+        display.value = false;
+      }
+    }
+    return (_ctx, _cache) => {
+      return common_vendor.e({
+        a: !_ctx.lazyRender || inited.value
+      }, !_ctx.lazyRender || inited.value ? {
+        b: common_vendor.n(rootClass.value),
+        c: common_vendor.s(style.value),
+        d: common_vendor.o(onTransitionEnd),
+        e: common_vendor.o(handleClick)
+      } : {});
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-2c25887e"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-transition/wd-transition.json

@@ -0,0 +1,4 @@
+{
+  "component": true,
+  "usingComponents": {}
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-transition/wd-transition.wxml

@@ -0,0 +1 @@
+<view wx:if="{{a}}" class="{{['data-v-2c25887e', b]}}" style="{{c}}" bindtransitionend="{{d}}" bindtap="{{e}}"><slot/></view>

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-transition/wd-transition.wxss

@@ -0,0 +1,106 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+.wd-transition.data-v-2c25887e {
+  transition-timing-function: ease;
+}
+.wd-fade-enter.data-v-2c25887e,
+.wd-fade-leave-to.data-v-2c25887e {
+  opacity: 0;
+}
+.wd-fade-enter-active.data-v-2c25887e,
+.wd-fade-leave-active.data-v-2c25887e {
+  transition-property: opacity;
+}
+.wd-fade-up-enter.data-v-2c25887e,
+.wd-fade-up-leave-to.data-v-2c25887e {
+  transform: translate3d(0, 100%, 0);
+  opacity: 0;
+}
+.wd-fade-down-enter.data-v-2c25887e,
+.wd-fade-down-leave-to.data-v-2c25887e {
+  transform: translate3d(0, -100%, 0);
+  opacity: 0;
+}
+.wd-fade-left-enter.data-v-2c25887e,
+.wd-fade-left-leave-to.data-v-2c25887e {
+  transform: translate3d(-100%, 0, 0);
+  opacity: 0;
+}
+.wd-fade-right-enter.data-v-2c25887e,
+.wd-fade-right-leave-to.data-v-2c25887e {
+  transform: translate3d(100%, 0, 0);
+  opacity: 0;
+}
+.wd-slide-up-enter.data-v-2c25887e,
+.wd-slide-up-leave-to.data-v-2c25887e {
+  transform: translate3d(0, 100%, 0);
+}
+.wd-slide-down-enter.data-v-2c25887e,
+.wd-slide-down-leave-to.data-v-2c25887e {
+  transform: translate3d(0, -100%, 0);
+}
+.wd-slide-left-enter.data-v-2c25887e,
+.wd-slide-left-leave-to.data-v-2c25887e {
+  transform: translate3d(-100%, 0, 0);
+}
+.wd-slide-right-enter.data-v-2c25887e,
+.wd-slide-right-leave-to.data-v-2c25887e {
+  transform: translate3d(100%, 0, 0);
+}
+.wd-zoom-in-enter.data-v-2c25887e,
+.wd-zoom-in-leave-to.data-v-2c25887e {
+  opacity: 0;
+  transform: scale(0.8);
+}
+.wd-zoom-out-enter.data-v-2c25887e,
+.wd-zoom-out-leave-to.data-v-2c25887e {
+  transform: scale(1.2);
+  opacity: 0;
+}
+.wd-zoom-in-enter-active.data-v-2c25887e,
+.wd-zoom-in-leave-active.data-v-2c25887e,
+.wd-zoom-out-enter-active.data-v-2c25887e,
+.wd-zoom-out-leave-active.data-v-2c25887e,
+.wd-fade-up-enter-active.data-v-2c25887e,
+.wd-fade-up-leave-active.data-v-2c25887e,
+.wd-fade-down-enter-active.data-v-2c25887e,
+.wd-fade-down-leave-active.data-v-2c25887e,
+.wd-fade-left-enter-active.data-v-2c25887e,
+.wd-fade-left-leave-active.data-v-2c25887e,
+.wd-fade-right-enter-active.data-v-2c25887e,
+.wd-fade-right-leave-active.data-v-2c25887e {
+  transition-property: opacity, transform;
+}
+.wd-slide-up-enter-active.data-v-2c25887e,
+.wd-slide-up-leave-active.data-v-2c25887e,
+.wd-slide-down-enter-active.data-v-2c25887e,
+.wd-slide-down-leave-active.data-v-2c25887e,
+.wd-slide-left-enter-active.data-v-2c25887e,
+.wd-slide-left-leave-active.data-v-2c25887e,
+.wd-slide-right-enter-active.data-v-2c25887e,
+.wd-slide-right-leave-active.data-v-2c25887e {
+  transition-property: transform;
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-upload/wd-upload.js

@@ -0,0 +1,562 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+if (!Math) {
+  (wdIcon + wdLoading + wdVideoPreview)();
+}
+const wdIcon = () => "../wd-icon/wd-icon.js";
+const wdVideoPreview = () => "../wd-video-preview/wd-video-preview.js";
+const wdLoading = () => "../wd-loading/wd-loading.js";
+const __default__ = {
+  name: "wd-upload",
+  options: {
+    addGlobalClass: true,
+    virtualHost: true,
+    styleIsolation: "shared"
+  }
+};
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  ...__default__,
+  props: common_vendor.uploadProps,
+  emits: ["fail", "change", "success", "progress", "oversize", "chooseerror", "remove", "update:fileList"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    __expose({
+      submit: () => startUploadFiles(),
+      abort: () => abort()
+    });
+    const { translate } = common_vendor.useTranslate("upload");
+    const uploadFiles = common_vendor.ref([]);
+    const showUpload = common_vendor.computed(() => !props.limit || uploadFiles.value.length < props.limit);
+    const videoPreview = common_vendor.ref();
+    const { startUpload, abort, chooseFile, UPLOAD_STATUS } = common_vendor.useUpload();
+    common_vendor.watch(
+      () => props.fileList,
+      (val) => {
+        const { statusKey } = props;
+        if (common_vendor.isEqual(val, uploadFiles.value))
+          return;
+        const uploadFileList = val.map((item) => {
+          item[statusKey] = item[statusKey] || "success";
+          item.response = item.response || "";
+          return { ...item, uid: common_vendor.context.id++ };
+        });
+        uploadFiles.value = uploadFileList;
+      },
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    common_vendor.watch(
+      () => props.limit,
+      (val) => {
+        if (val && val < uploadFiles.value.length) {
+          console.error("[wot-design]Error: props limit must less than fileList.length");
+        }
+      },
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    common_vendor.watch(
+      () => props.beforePreview,
+      (fn) => {
+        if (fn && !common_vendor.isFunction(fn)) {
+          console.error("The type of beforePreview must be Function");
+        }
+      },
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    common_vendor.watch(
+      () => props.onPreviewFail,
+      (fn) => {
+        if (fn && !common_vendor.isFunction(fn)) {
+          console.error("The type of onPreviewFail must be Function");
+        }
+      },
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    common_vendor.watch(
+      () => props.beforeRemove,
+      (fn) => {
+        if (fn && !common_vendor.isFunction(fn)) {
+          console.error("The type of beforeRemove must be Function");
+        }
+      },
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    common_vendor.watch(
+      () => props.beforeUpload,
+      (fn) => {
+        if (fn && !common_vendor.isFunction(fn)) {
+          console.error("The type of beforeUpload must be Function");
+        }
+      },
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    common_vendor.watch(
+      () => props.beforeChoose,
+      (fn) => {
+        if (fn && !common_vendor.isFunction(fn)) {
+          console.error("The type of beforeChoose must be Function");
+        }
+      },
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    common_vendor.watch(
+      () => props.buildFormData,
+      (fn) => {
+        if (fn && !common_vendor.isFunction(fn)) {
+          console.error("The type of buildFormData must be Function");
+        }
+      },
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    function emitFileList() {
+      emit("update:fileList", uploadFiles.value);
+    }
+    function startUploadFiles() {
+      const { buildFormData, formData = {}, statusKey } = props;
+      const { action, name, header = {}, accept, successStatus, uploadMethod } = props;
+      const statusCode = common_vendor.isDef(successStatus) ? successStatus : 200;
+      for (const uploadFile of uploadFiles.value) {
+        if (uploadFile[statusKey] === UPLOAD_STATUS.PENDING) {
+          if (buildFormData) {
+            buildFormData({
+              file: uploadFile,
+              formData,
+              resolve: (formData2) => {
+                formData2 && startUpload(uploadFile, {
+                  action,
+                  header,
+                  name,
+                  formData: formData2,
+                  fileType: accept,
+                  statusCode,
+                  statusKey,
+                  uploadMethod,
+                  onSuccess: handleSuccess,
+                  onError: handleError,
+                  onProgress: handleProgress
+                });
+              }
+            });
+          } else {
+            startUpload(uploadFile, {
+              action,
+              header,
+              name,
+              formData,
+              fileType: accept,
+              statusCode,
+              statusKey,
+              uploadMethod,
+              onSuccess: handleSuccess,
+              onError: handleError,
+              onProgress: handleProgress
+            });
+          }
+        }
+      }
+    }
+    function getImageInfo(img) {
+      return new Promise((resolve, reject) => {
+        common_vendor.index.getImageInfo({
+          src: img,
+          success: (res) => {
+            resolve(res);
+          },
+          fail: (error) => {
+            reject(error);
+          }
+        });
+      });
+    }
+    function initFile(file, currentIndex) {
+      const { statusKey } = props;
+      const initState = {
+        uid: common_vendor.context.id++,
+        // 仅h5支持 name
+        name: file.name || "",
+        thumb: file.thumb || "",
+        [statusKey]: "pending",
+        size: file.size || 0,
+        url: file.path,
+        percent: 0
+      };
+      if (typeof currentIndex === "number") {
+        uploadFiles.value.splice(currentIndex, 1, initState);
+      } else {
+        uploadFiles.value.push(initState);
+      }
+      if (props.autoUpload) {
+        startUploadFiles();
+      }
+    }
+    function handleError(err, file, formData) {
+      const { statusKey } = props;
+      const index = uploadFiles.value.findIndex((item) => item.uid === file.uid);
+      if (index > -1) {
+        uploadFiles.value[index][statusKey] = "fail";
+        uploadFiles.value[index].error = err.message;
+        uploadFiles.value[index].response = err;
+        emit("fail", { error: err, file, formData });
+        emitFileList();
+      }
+    }
+    function handleSuccess(res, file, formData) {
+      const { statusKey } = props;
+      const index = uploadFiles.value.findIndex((item) => item.uid === file.uid);
+      if (index > -1) {
+        uploadFiles.value[index][statusKey] = "success";
+        uploadFiles.value[index].response = res.data;
+        emit("change", { fileList: uploadFiles.value });
+        emit("success", { file, fileList: uploadFiles.value, formData });
+        emitFileList();
+      }
+    }
+    function handleProgress(res, file) {
+      const index = uploadFiles.value.findIndex((item) => item.uid === file.uid);
+      if (index > -1) {
+        uploadFiles.value[index].percent = res.progress;
+        emit("progress", { response: res, file });
+      }
+    }
+    function onChooseFile(currentIndex) {
+      const { multiple, maxSize, accept, sizeType, limit, sourceType, compressed, maxDuration, camera, beforeUpload, extension } = props;
+      chooseFile({
+        multiple,
+        sizeType,
+        sourceType,
+        maxCount: limit ? limit - uploadFiles.value.length : 9,
+        accept,
+        compressed,
+        maxDuration,
+        camera,
+        extension
+      }).then((res) => {
+        let files = res;
+        if (!multiple) {
+          files = files.slice(0, 1);
+        }
+        const mapFiles = async (files2) => {
+          for (let index = 0; index < files2.length; index++) {
+            const file = files2[index];
+            if (file.type === "image" && !file.size) {
+              const imageInfo = await getImageInfo(file.path);
+              file.size = imageInfo.width * imageInfo.height;
+            }
+            Number(file.size) <= maxSize ? initFile(file, currentIndex) : emit("oversize", { file });
+          }
+        };
+        if (beforeUpload) {
+          beforeUpload({
+            files,
+            fileList: uploadFiles.value,
+            resolve: (isPass) => {
+              isPass && mapFiles(files);
+            }
+          });
+        } else {
+          mapFiles(files);
+        }
+      }).catch((error) => {
+        emit("chooseerror", { error });
+      });
+    }
+    function handleChoose(index) {
+      if (props.disabled)
+        return;
+      const { beforeChoose } = props;
+      if (beforeChoose) {
+        beforeChoose({
+          fileList: uploadFiles.value,
+          resolve: (isPass) => {
+            isPass && onChooseFile(index);
+          }
+        });
+      } else {
+        onChooseFile(index);
+      }
+    }
+    function handleRemove(file) {
+      uploadFiles.value.splice(
+        uploadFiles.value.findIndex((item) => item.uid === file.uid),
+        1
+      );
+      emit("change", {
+        fileList: uploadFiles.value
+      });
+      emit("remove", { file });
+      emitFileList();
+    }
+    function removeFile(index) {
+      const { beforeRemove } = props;
+      const intIndex = index;
+      const file = uploadFiles.value[intIndex];
+      if (beforeRemove) {
+        beforeRemove({
+          file,
+          index: intIndex,
+          fileList: uploadFiles.value,
+          resolve: (isPass) => {
+            isPass && handleRemove(file);
+          }
+        });
+      } else {
+        handleRemove(file);
+      }
+    }
+    function handlePreviewFile(file) {
+      common_vendor.index.openDocument({
+        filePath: file.url,
+        showMenu: true
+      });
+    }
+    function handlePreviewImage(index, lists) {
+      const { onPreviewFail } = props;
+      common_vendor.index.previewImage({
+        urls: lists,
+        current: lists[index],
+        fail() {
+          if (onPreviewFail) {
+            onPreviewFail({
+              index,
+              imgList: lists
+            });
+          } else {
+            common_vendor.index.showToast({ title: "预览图片失败", icon: "none" });
+          }
+        }
+      });
+    }
+    function handlePreviewVieo(index, lists) {
+      const { onPreviewFail } = props;
+      common_vendor.index.previewMedia({
+        current: index,
+        sources: lists.map((file) => {
+          return {
+            url: file.url,
+            type: "video",
+            poster: file.thumb
+          };
+        }),
+        fail() {
+          if (onPreviewFail) {
+            onPreviewFail({
+              index,
+              imgList: []
+            });
+          } else {
+            common_vendor.index.showToast({ title: "预览视频失败", icon: "none" });
+          }
+        }
+      });
+    }
+    function onPreviewImage(file) {
+      const { beforePreview, reupload } = props;
+      const fileList = common_vendor.deepClone(uploadFiles.value);
+      const index = fileList.findIndex((item) => item.url === file.url);
+      const imgList = fileList.filter((file2) => isImage(file2)).map((file2) => file2.url);
+      const imgIndex = imgList.findIndex((item) => item === file.url);
+      if (reupload) {
+        handleChoose(index);
+      } else {
+        if (beforePreview) {
+          beforePreview({
+            file,
+            index,
+            fileList,
+            imgList,
+            resolve: (isPass) => {
+              isPass && handlePreviewImage(imgIndex, imgList);
+            }
+          });
+        } else {
+          handlePreviewImage(imgIndex, imgList);
+        }
+      }
+    }
+    function onPreviewVideo(file) {
+      const { beforePreview, reupload } = props;
+      const fileList = common_vendor.deepClone(uploadFiles.value);
+      const index = fileList.findIndex((item) => item.url === file.url);
+      const videoList = fileList.filter((file2) => isVideo(file2));
+      const videoIndex = videoList.findIndex((item) => item.url === file.url);
+      if (reupload) {
+        handleChoose(index);
+      } else {
+        if (beforePreview) {
+          beforePreview({
+            file,
+            index,
+            imgList: [],
+            fileList,
+            resolve: (isPass) => {
+              isPass && handlePreviewVieo(videoIndex, videoList);
+            }
+          });
+        } else {
+          handlePreviewVieo(videoIndex, videoList);
+        }
+      }
+    }
+    function onPreviewFile(file) {
+      const { beforePreview, reupload } = props;
+      const fileList = common_vendor.deepClone(uploadFiles.value);
+      const index = fileList.findIndex((item) => item.url === file.url);
+      if (reupload) {
+        handleChoose(index);
+      } else {
+        if (beforePreview) {
+          beforePreview({
+            file,
+            index,
+            imgList: [],
+            fileList,
+            resolve: (isPass) => {
+              isPass && handlePreviewFile(file);
+            }
+          });
+        } else {
+          handlePreviewFile(file);
+        }
+      }
+    }
+    function isVideo(file) {
+      return file.name && common_vendor.isVideoUrl(file.name) || common_vendor.isVideoUrl(file.url);
+    }
+    function isImage(file) {
+      return file.name && common_vendor.isImageUrl(file.name) || common_vendor.isImageUrl(file.url);
+    }
+    return (_ctx, _cache) => {
+      return common_vendor.e({
+        a: common_vendor.f(uploadFiles.value, (file, index, i0) => {
+          return common_vendor.e({
+            a: isImage(file)
+          }, isImage(file) ? {
+            b: file.url,
+            c: _ctx.imageMode,
+            d: common_vendor.o(($event) => onPreviewImage(file), index)
+          } : isVideo(file) ? common_vendor.e({
+            f: file.thumb
+          }, file.thumb ? {
+            g: file.thumb,
+            h: _ctx.imageMode,
+            i: "7c014dc0-0-" + i0,
+            j: common_vendor.p({
+              name: "play-circle-filled",
+              ["custom-class"]: "wd-upload__video-paly"
+            }),
+            k: common_vendor.o(($event) => onPreviewVideo(file), index)
+          } : {
+            l: file.url,
+            m: file.name || "视频" + index,
+            n: file.thumb,
+            o: "7c014dc0-1-" + i0,
+            p: common_vendor.p({
+              name: "play-circle-filled",
+              ["custom-class"]: "wd-upload__video-paly"
+            }),
+            q: common_vendor.o(($event) => onPreviewVideo(file), index)
+          }) : {
+            r: "7c014dc0-2-" + i0,
+            s: common_vendor.p({
+              name: "file",
+              ["custom-class"]: "wd-upload__file-icon"
+            }),
+            t: common_vendor.t(file.name || file.url),
+            v: common_vendor.o(($event) => onPreviewFile(file), index)
+          }, {
+            e: isVideo(file),
+            w: file[props.statusKey] !== "success"
+          }, file[props.statusKey] !== "success" ? common_vendor.e({
+            x: file[props.statusKey] === "loading"
+          }, file[props.statusKey] === "loading" ? {
+            y: "7c014dc0-3-" + i0,
+            z: common_vendor.p({
+              type: _ctx.loadingType,
+              size: _ctx.loadingSize,
+              color: _ctx.loadingColor
+            }),
+            A: common_vendor.t(file.percent)
+          } : {}, {
+            B: file[props.statusKey] === "fail"
+          }, file[props.statusKey] === "fail" ? {
+            C: "7c014dc0-4-" + i0,
+            D: common_vendor.p({
+              name: "close-outline",
+              ["custom-class"]: "wd-upload__icon"
+            }),
+            E: common_vendor.t(file.error || common_vendor.unref(translate)("error"))
+          } : {}) : {}, {
+            F: file[props.statusKey] !== "loading" && !_ctx.disabled
+          }, file[props.statusKey] !== "loading" && !_ctx.disabled ? {
+            G: common_vendor.o(($event) => removeFile(index), index),
+            H: "7c014dc0-5-" + i0,
+            I: common_vendor.p({
+              name: "error-fill",
+              ["custom-class"]: "wd-upload__close"
+            })
+          } : {}, _ctx.$slots["preview-cover"] ? {
+            J: "preview-cover-" + i0,
+            K: common_vendor.r("preview-cover", {
+              file,
+              index
+            }, i0)
+          } : {}, {
+            L: index
+          });
+        }),
+        b: _ctx.$slots["preview-cover"],
+        c: common_vendor.n(_ctx.customPreviewClass),
+        d: showUpload.value
+      }, showUpload.value ? common_vendor.e({
+        e: _ctx.$slots.default
+      }, _ctx.$slots.default ? {
+        f: common_vendor.n(_ctx.customEvokeClass),
+        g: common_vendor.o(handleChoose)
+      } : common_vendor.e({
+        h: common_vendor.p({
+          name: "fill-camera"
+        }),
+        i: _ctx.limit && _ctx.showLimitNum
+      }, _ctx.limit && _ctx.showLimitNum ? {
+        j: common_vendor.t(uploadFiles.value.length),
+        k: common_vendor.t(_ctx.limit)
+      } : {}, {
+        l: common_vendor.o(handleChoose),
+        m: common_vendor.n(_ctx.disabled ? "is-disabled" : ""),
+        n: common_vendor.n(_ctx.customEvokeClass)
+      })) : {}, {
+        o: common_vendor.n(_ctx.customClass),
+        p: common_vendor.s(_ctx.customStyle),
+        q: common_vendor.sr(videoPreview, "7c014dc0-7", {
+          "k": "videoPreview"
+        })
+      });
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-7c014dc0"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-upload/wd-upload.json

@@ -0,0 +1,8 @@
+{
+  "component": true,
+  "usingComponents": {
+    "wd-icon": "../wd-icon/wd-icon",
+    "wd-video-preview": "../wd-video-preview/wd-video-preview",
+    "wd-loading": "../wd-loading/wd-loading"
+  }
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-upload/wd-upload.wxss

@@ -0,0 +1,335 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+ * UI规范基础变量
+ */
+/*----------------------------------------- Theme color. start ----------------------------------------*/
+/* 主题颜色 */
+/* 辅助色 */
+/* 文字颜色（默认浅色背景下 */
+/* 暗黑模式 */
+/* 图形颜色 */
+/*----------------------------------------- Theme color. end -------------------------------------------*/
+/*-------------------------------- Theme color application size.  start --------------------------------*/
+/* 文字字号 */
+/* 文字字重 */
+/* 尺寸 */
+/*-------------------------------- Theme color application size.  end --------------------------------*/
+/* component var */
+/* action-sheet */
+/* badge */
+/* button */
+/* cell */
+/* calendar */
+/* checkbox */
+/* collapse */
+/* divider */
+/* drop-menu */
+/* input-number */
+/* input */
+/* textarea */
+/* loadmore */
+/* message-box */
+/* notice-bar */
+/* pagination */
+/* picker */
+/* col-picker */
+/* overlay */
+/* popup */
+/* progress */
+/* radio */
+/* search */
+/* slider */
+/* sort-button */
+/* steps */
+/* switch */
+/* tabs */
+/* tag */
+/* toast */
+/* loading */
+/* tooltip */
+/* popover */
+/* grid-item */
+/* statustip */
+/* card */
+/* upload */
+/* curtain */
+/* notify */
+/* skeleton */
+/* circle */
+/* swiper */
+/* swiper-nav */
+/* segmented */
+/* tabbar */
+/* tabbar-item */
+/* navbar */
+/* navbar-capsule */
+/* table */
+/* sidebar */
+/* sidebar-item */
+/* fab */
+/* count-down */
+/* keyboard */
+/* number-keyboard */
+/* passwod-input */
+/* form-item */
+/* backtop */
+/* index-bar */
+/* text */
+/* video-preview */
+/* img-cropper */
+/* floating-panel */
+/* signature */
+/**
+ * 混合宏
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+  * BEM，定义块（b)
+  */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 此方法用于生成穿透样式 */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 定义状态（m） */
+/* 定义状态（m） */
+/* 对于需要需要嵌套在 m 底下的 e，调用这个混合宏，一般在切换整个组件的状态，如切换颜色的时候 */
+/* 状态，生成 is-$state 类名 */
+/**
+  * 常用混合宏
+  */
+/* 单行超出隐藏 */
+/* 多行超出隐藏 */
+/* 清除浮动 */
+/* 0.5px 边框 指定方向*/
+/* 0.5px 边框 环绕 */
+/**
+  * 三角形实现尖角样式，适用于背景透明情况
+  * @param $size 三角形高，底边为 $size * 2
+  * @param $bg 三角形背景颜色
+  */
+/**
+  * 正方形实现尖角样式，适用于背景不透明情况
+  * @param $size 正方形边长
+  * @param $bg 正方形背景颜色
+  * @param $z-index z-index属性值，不得大于外部包裹器
+  * @param $box-shadow 阴影
+*/
+.wot-theme-dark .wd-upload__evoke.data-v-7c014dc0 {
+  background-color: var(--wot-dark-background4, #323233);
+  color: var(--wot-dark-color3, rgba(232, 230, 227, 0.8));
+}
+.wot-theme-dark .wd-upload__evoke.is-disabled.data-v-7c014dc0 {
+  color: var(--wot-dark-color-gray, var(--wot-color-secondary, #595959));
+}
+.wot-theme-dark .wd-upload__file.data-v-7c014dc0 {
+  background-color: var(--wot-dark-background4, #323233);
+}
+.wot-theme-dark .wd-upload__file-name.data-v-7c014dc0 {
+  color: var(--wot-dark-color3, rgba(232, 230, 227, 0.8));
+}
+.wd-upload.data-v-7c014dc0 {
+  position: relative;
+  display: flex;
+  flex-wrap: wrap;
+}
+.wd-upload__evoke.data-v-7c014dc0 {
+  position: relative;
+  display: inline-flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  width: var(--wot-upload-size, 80px);
+  height: var(--wot-upload-size, 80px);
+  font-size: var(--wot-upload-evoke-icon-size, 32px);
+  background-color: var(--wot-upload-evoke-bg, rgba(0, 0, 0, 0.04));
+  color: var(--wot-upload-evoke-color, rgba(0, 0, 0, 0.25));
+  margin-bottom: 12px;
+}
+.wd-upload__evoke.is-disabled.data-v-7c014dc0 {
+  color: var(--wot-upload-evoke-disabled-color, rgba(0, 0, 0, 0.09));
+}
+.wd-upload__evoke-num.data-v-7c014dc0 {
+  font-size: 14px;
+  line-height: 14px;
+  margin-top: 8px;
+}
+.data-v-7c014dc0  .wd-upload__evoke-icon {
+  width: 32px;
+  height: 32px;
+}
+.wd-upload__input.data-v-7c014dc0 {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  opacity: 0;
+}
+.wd-upload__preview.data-v-7c014dc0 {
+  position: relative;
+  width: var(--wot-upload-size, 80px);
+  height: var(--wot-upload-size, 80px);
+  margin: 0 12px 12px 0;
+}
+.wd-upload__preview-list.data-v-7c014dc0 {
+  display: flex;
+}
+.wd-upload__picture.data-v-7c014dc0, .wd-upload__file.data-v-7c014dc0, .wd-upload__video.data-v-7c014dc0 {
+  position: relative;
+  display: block;
+  width: 100%;
+  height: 100%;
+}
+.wd-upload__file.data-v-7c014dc0, .wd-upload__video.data-v-7c014dc0 {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  background-color: var(--wot-upload-evoke-bg, rgba(0, 0, 0, 0.04));
+}
+.wd-upload__video-icon.data-v-7c014dc0, .wd-upload__file-icon.data-v-7c014dc0 {
+  font-size: var(--wot-upload-cover-icon-size, 22px);
+}
+.wd-upload__file-name.data-v-7c014dc0, .wd-upload__video-name.data-v-7c014dc0 {
+  width: 100%;
+  font-size: var(--wot-upload-file-fs, 12px);
+  color: var(--wot-upload-file-color, var(--wot-color-secondary, #595959));
+  box-sizing: border-box;
+  padding: 0 4px;
+  text-align: center;
+  margin-top: 8px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.data-v-7c014dc0  .wd-upload__video-paly {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  font-size: 24px;
+  color: var(--wot-color-white, rgb(255, 255, 255));
+}
+.data-v-7c014dc0  .wd-upload__video-paly::before {
+  background-color: rgba(0, 0, 0, 0.5);
+  border-radius: 50%;
+}
+.data-v-7c014dc0  .wd-upload__close {
+  position: absolute;
+  right: calc(var(--wot-upload-close-icon-size, 16px) / 2 * -1);
+  top: calc(var(--wot-upload-close-icon-size, 16px) / 2 * -1);
+  font-size: var(--wot-upload-close-icon-size, 16px);
+  z-index: 1;
+  color: var(--wot-upload-close-icon-color, rgba(0, 0, 0, 0.65));
+  width: var(--wot-upload-close-icon-size, 16px);
+  height: var(--wot-upload-close-icon-size, 16px);
+  line-height: var(--wot-upload-close-icon-size, 16px);
+}
+.data-v-7c014dc0  .wd-upload__close::after {
+  position: absolute;
+  content: "";
+  width: 100%;
+  height: 100%;
+  border-radius: 50%;
+  background-color: var(--wot-color-white, rgb(255, 255, 255));
+  left: 0;
+  z-index: -1;
+}
+.wd-upload__mask.data-v-7c014dc0 {
+  position: absolute;
+  top: 0;
+  left: 0;
+  background-color: var(--wot-upload-preview-name-bg, rgba(0, 0, 0, 0.6));
+}
+.wd-upload__progress-txt.data-v-7c014dc0 {
+  font-size: var(--wot-upload-progress-fs, 14px);
+  line-height: var(--wot-upload-progress-fs, 14px);
+  margin-top: 9px;
+  color: var(--wot-color-white, rgb(255, 255, 255));
+}
+.data-v-7c014dc0  .wd-upload__icon {
+  font-size: var(--wot-upload-preview-icon-size, 24px);
+  color: var(--wot-color-white, rgb(255, 255, 255));
+}
+.wd-upload__status-content.data-v-7c014dc0 {
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  width: 100%;
+  height: 100%;
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-video-preview/wd-video-preview.js

@@ -0,0 +1,67 @@
+"use strict";
+const common_vendor = require("../../../../common/vendor.js");
+if (!Math) {
+  wdIcon();
+}
+const wdIcon = () => "../wd-icon/wd-icon.js";
+const __default__ = {
+  name: "wd-video-preview",
+  options: {
+    addGlobalClass: true,
+    virtualHost: true,
+    styleIsolation: "shared"
+  }
+};
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  ...__default__,
+  props: common_vendor.videoPreviewProps,
+  setup(__props, { expose: __expose }) {
+    const showPopup = common_vendor.ref(false);
+    const previdewVideo = common_vendor.reactive({ url: "", poster: "", title: "" });
+    function open(video) {
+      showPopup.value = true;
+      previdewVideo.url = video.url;
+      previdewVideo.poster = video.poster;
+      previdewVideo.title = video.title;
+    }
+    function close() {
+      showPopup.value = false;
+      common_vendor.nextTick$1(() => {
+        handleClosed();
+      });
+    }
+    function handleClosed() {
+      previdewVideo.url = "";
+      previdewVideo.poster = "";
+      previdewVideo.title = "";
+    }
+    __expose({
+      open,
+      close
+    });
+    return (_ctx, _cache) => {
+      return common_vendor.e({
+        a: showPopup.value
+      }, showPopup.value ? common_vendor.e({
+        b: previdewVideo.url
+      }, previdewVideo.url ? {
+        c: previdewVideo.poster,
+        d: previdewVideo.title,
+        e: previdewVideo.url
+      } : {}, {
+        f: common_vendor.o(() => {
+        }),
+        g: common_vendor.o(close),
+        h: common_vendor.p({
+          name: "close",
+          ["custom-class"]: `wd-video-preview__close`
+        }),
+        i: common_vendor.n(`wd-video-preview ${_ctx.customClass}`),
+        j: common_vendor.s(_ctx.customStyle),
+        k: common_vendor.o(close)
+      }) : {});
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-81c5af26"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-video-preview/wd-video-preview.json

@@ -0,0 +1,6 @@
+{
+  "component": true,
+  "usingComponents": {
+    "wd-icon": "../wd-icon/wd-icon"
+  }
+}

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-video-preview/wd-video-preview.wxml

@@ -0,0 +1 @@
+<view wx:if="{{a}}" class="{{['data-v-81c5af26', i]}}" style="{{j}}" bindtap="{{k}}"><view class="wd-video-preview__video data-v-81c5af26" catchtap="{{f}}"><video wx:if="{{b}}" class="wd-video-preview__video data-v-81c5af26" controls="{{true}}" poster="{{c}}" title="{{d}}" play-btn-position="center" enableNative="{{true}}" src="{{e}}" enable-progress-gesture="{{false}}"></video></view><wd-icon wx:if="{{h}}" class="data-v-81c5af26" bindclick="{{g}}" u-i="81c5af26-0" bind:__l="__l" u-p="{{h}}"/></view>

dist/dev/mp-weixin/node-modules/wot-design-uni/components/wd-video-preview/wd-video-preview.wxss

@@ -0,0 +1,218 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+ * UI规范基础变量
+ */
+/*----------------------------------------- Theme color. start ----------------------------------------*/
+/* 主题颜色 */
+/* 辅助色 */
+/* 文字颜色（默认浅色背景下 */
+/* 暗黑模式 */
+/* 图形颜色 */
+/*----------------------------------------- Theme color. end -------------------------------------------*/
+/*-------------------------------- Theme color application size.  start --------------------------------*/
+/* 文字字号 */
+/* 文字字重 */
+/* 尺寸 */
+/*-------------------------------- Theme color application size.  end --------------------------------*/
+/* component var */
+/* action-sheet */
+/* badge */
+/* button */
+/* cell */
+/* calendar */
+/* checkbox */
+/* collapse */
+/* divider */
+/* drop-menu */
+/* input-number */
+/* input */
+/* textarea */
+/* loadmore */
+/* message-box */
+/* notice-bar */
+/* pagination */
+/* picker */
+/* col-picker */
+/* overlay */
+/* popup */
+/* progress */
+/* radio */
+/* search */
+/* slider */
+/* sort-button */
+/* steps */
+/* switch */
+/* tabs */
+/* tag */
+/* toast */
+/* loading */
+/* tooltip */
+/* popover */
+/* grid-item */
+/* statustip */
+/* card */
+/* upload */
+/* curtain */
+/* notify */
+/* skeleton */
+/* circle */
+/* swiper */
+/* swiper-nav */
+/* segmented */
+/* tabbar */
+/* tabbar-item */
+/* navbar */
+/* navbar-capsule */
+/* table */
+/* sidebar */
+/* sidebar-item */
+/* fab */
+/* count-down */
+/* keyboard */
+/* number-keyboard */
+/* passwod-input */
+/* form-item */
+/* backtop */
+/* index-bar */
+/* text */
+/* video-preview */
+/* img-cropper */
+/* floating-panel */
+/* signature */
+/**
+ * 混合宏
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/**
+ * 辅助函数
+ */
+/**
+ * SCSS 配置项：命名空间以及BEM
+ */
+/* 转换成字符串 */
+/* 判断是否存在 Modifier */
+/* 判断是否存在伪类 */
+/**
+ * 主题色切换
+ * @params $theme-color 主题色
+ * @params $type 变暗’dark‘ 变亮 'light'
+ * @params $mix-color 自己设置的混色
+ */
+/**
+ * 颜色结果切换， 如果开启线性渐变色 使用渐变色，如果没有开启，那么使用主题色
+ * @params $open-linear 是否开启线性渐变色
+ * @params $deg 渐变色角度
+ * @params $theme-color 当前配色
+ * @params [Array] $set 主题色明暗设置，与 $color-list 数量对应
+ * @params [Array] $color-list 渐变色顺序， $color-list 和 $per-list 数量相同
+ * @params [Array] $per-list 渐变色比例
+ */
+/**
+  * BEM，定义块（b)
+  */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 此方法用于生成穿透样式 */
+/* 定义元素（e），对于伪类，会自动将 e 嵌套在 伪类 底下 */
+/* 定义状态（m） */
+/* 定义状态（m） */
+/* 对于需要需要嵌套在 m 底下的 e，调用这个混合宏，一般在切换整个组件的状态，如切换颜色的时候 */
+/* 状态，生成 is-$state 类名 */
+/**
+  * 常用混合宏
+  */
+/* 单行超出隐藏 */
+/* 多行超出隐藏 */
+/* 清除浮动 */
+/* 0.5px 边框 指定方向*/
+/* 0.5px 边框 环绕 */
+/**
+  * 三角形实现尖角样式，适用于背景透明情况
+  * @param $size 三角形高，底边为 $size * 2
+  * @param $bg 三角形背景颜色
+  */
+/**
+  * 正方形实现尖角样式，适用于背景不透明情况
+  * @param $size 正方形边长
+  * @param $bg 正方形背景颜色
+  * @param $z-index z-index属性值，不得大于外部包裹器
+  * @param $box-shadow 阴影
+*/
+.wd-video-preview.data-v-81c5af26 {
+  position: fixed;
+  top: 0;
+  left: 0;
+  z-index: 999;
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  background: var(--wot-video-preview-bg, rgba(0, 0, 0, 0.8));
+}
+.wd-video-preview__video.data-v-81c5af26 {
+  width: 100%;
+  height: 242px;
+  transition: all 0.3s ease;
+}
+.data-v-81c5af26  .wd-video-preview__close {
+  position: absolute;
+  box-sizing: border-box;
+  top: 0px;
+  right: 0px;
+  padding: 12px;
+  text-align: center;
+  cursor: pointer;
+  font-size: var(--wot-video-preview-close-font-size, 20px);
+  color: var(--wot-video-preview-close-color, #fff);
+}

dist/dev/mp-weixin/pages/index/index.js

@@ -0,0 +1,57 @@
+"use strict";
+const common_vendor = require("../../common/vendor.js");
+if (!Array) {
+  const _easycom_wd_swiper2 = common_vendor.resolveComponent("wd-swiper");
+  _easycom_wd_swiper2();
+}
+const _easycom_wd_swiper = () => "../../node-modules/wot-design-uni/components/wd-swiper/wd-swiper.js";
+if (!Math) {
+  _easycom_wd_swiper();
+}
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  __name: "index",
+  setup(__props) {
+    const current = common_vendor.ref(0);
+    const swiperList = common_vendor.ref([
+      "https://registry.npmmirror.com/wot-design-uni-assets/*/files/redpanda.jpg",
+      "https://registry.npmmirror.com/wot-design-uni-assets/*/files/capybara.jpg",
+      "https://registry.npmmirror.com/wot-design-uni-assets/*/files/panda.jpg",
+      "https://registry.npmmirror.com/wot-design-uni-assets/*/files/moon.jpg",
+      "https://registry.npmmirror.com/wot-design-uni-assets/*/files/meng.jpg"
+    ]);
+    const getuser = () => {
+      common_vendor.index.login({
+        //获取code，
+        success: (res) => {
+          var code = res.code, appId = "wx4f6dc4ac1674547c", secret = "9e0e7fe5161541d9862b8ee2db6da840";
+          console.log("正在登录中...");
+          common_vendor.wx$1.request({
+            url: "https://api.weixin.qq.com/sns/jscode2session?appid=" + appId + "&secret=" + secret + "&js_code=" + code + "&grant_type=authorization_code",
+            data: {},
+            header: {
+              "content-type": "json"
+            },
+            success: (user_res) => {
+              const user_openid = user_res.data.openid;
+              console.log("登录成功", user_openid);
+            }
+          });
+        }
+      });
+    };
+    common_vendor.onLoad(() => {
+      getuser();
+    });
+    return (_ctx, _cache) => {
+      return {
+        a: common_vendor.p({
+          customClass: "customSwiper",
+          list: swiperList.value,
+          autoplay: true,
+          value: current.value
+        })
+      };
+    };
+  }
+});
+wx.createPage(_sfc_main);

dist/dev/mp-weixin/pages/index/index.json

@@ -0,0 +1,6 @@
+{
+  "navigationStyle": "custom",
+  "usingComponents": {
+    "wd-swiper": "../../node-modules/wot-design-uni/components/wd-swiper/wd-swiper"
+  }
+}

dist/dev/mp-weixin/pages/index/index.wxml

@@ -0,0 +1 @@
+<view class="homeContent"><wd-swiper wx:if="{{a}}" u-i="f5f2151a-0" bind:__l="__l" u-p="{{a}}"></wd-swiper><image class="enter-img" src="https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/enter.png" mode="scaleToFill"/></view>

dist/dev/mp-weixin/pages/index/index.wxss

@@ -0,0 +1,50 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+.homeContent .customSwiper {
+  height: 662rpx;
+  width: 100%;
+}
+.homeContent .wd-swiper__track {
+  height: 100% !important;
+  width: 100% !important;
+}
+.homeContent .wd-swiper__image {
+  height: 100% !important;
+  width: 100% !important;
+}
+.homeContent .wd-swiper-nav__item--dots {
+  background: rgba(0, 0, 0, 0.3) !important;
+  height: 16rpx !important;
+  width: 16rpx !important;
+}
+.homeContent .wd-swiper-nav__item--dots.is-active {
+  background: rgba(0, 0, 0, 0.9) !important;
+}
+.homeContent .enter-img {
+  width: 100%;
+  height: 176rpx;
+  margin-top: 24rpx;
+}

dist/dev/mp-weixin/pages/my/index.js

@@ -0,0 +1,53 @@
+"use strict";
+const common_vendor = require("../../common/vendor.js");
+const common_assets = require("../../common/assets.js");
+const services_task = require("../../services/task.js");
+if (!Array) {
+  const _easycom_wd_button2 = common_vendor.resolveComponent("wd-button");
+  _easycom_wd_button2();
+}
+const _easycom_wd_button = () => "../../node-modules/wot-design-uni/components/wd-button/wd-button.js";
+if (!Math) {
+  _easycom_wd_button();
+}
+const _sfc_defineComponent = common_vendor.defineComponent({
+  __name: "index",
+  setup(__props) {
+    const title = common_vendor.ref("Hello");
+    common_vendor.onLoad(() => {
+      common_vendor.index.getUserInfo({
+        success: (success) => {
+          console.log(success);
+        }
+      });
+    });
+    const onLogin = async () => {
+      let form = {
+        mobile: "18927563000",
+        password: "123456"
+      };
+      let res = await services_task.postLoginAPI(form);
+      if (res.code == 200) {
+        console.log("1111111111111111");
+      } else {
+        return common_vendor.index.showToast({
+          title: res.msg,
+          icon: "none"
+        });
+      }
+    };
+    return (_ctx, _cache) => {
+      return {
+        a: common_assets._imports_0,
+        b: common_vendor.t(title.value),
+        c: common_vendor.o(onLogin),
+        d: common_vendor.p({
+          type: "success"
+        })
+      };
+    };
+  }
+});
+_sfc_defineComponent.__runtimeHooks = 1;
+const MiniProgramPage = /* @__PURE__ */ common_vendor._export_sfc(_sfc_defineComponent, [["__scopeId", "data-v-276ac604"]]);
+wx.createPage(MiniProgramPage);

dist/dev/mp-weixin/pages/my/index.json

@@ -0,0 +1,6 @@
+{
+  "navigationBarTitleText": "我的",
+  "usingComponents": {
+    "wd-button": "../../node-modules/wot-design-uni/components/wd-button/wd-button"
+  }
+}

dist/dev/mp-weixin/pages/my/index.wxml

@@ -0,0 +1 @@
+<view class="content data-v-276ac604"><image class="logo data-v-276ac604" src="{{a}}"/><view class="text-area data-v-276ac604"><text class="title data-v-276ac604">{{b}}</text></view><button class="data-v-276ac604" hover-class="button-hover" bindtap="{{c}}">登录</button><wd-button wx:if="{{d}}" class="data-v-276ac604" u-s="{{['d']}}" u-i="276ac604-0" bind:__l="__l" u-p="{{d}}">成功按钮</wd-button></view>

dist/dev/mp-weixin/pages/my/index.wxss

@@ -0,0 +1,47 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+.content.data-v-276ac604 {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+}
+.logo.data-v-276ac604 {
+  height: 200rpx;
+  width: 200rpx;
+  margin-top: 200rpx;
+  margin-left: auto;
+  margin-right: auto;
+  margin-bottom: 50rpx;
+}
+.text-area.data-v-276ac604 {
+  display: flex;
+  justify-content: center;
+}
+.title.data-v-276ac604 {
+  font-size: 36rpx;
+  color: #8f8f94;
+}

dist/dev/mp-weixin/pagesOne/winner/components/photoExamplePopup.js

@@ -0,0 +1,45 @@
+"use strict";
+const common_vendor = require("../../../common/vendor.js");
+const pagesOne_winner_utils_source = require("../utils/source.js");
+const hooks_useDraw = require("../../../hooks/useDraw.js");
+if (!Array) {
+  const _easycom_wd_popup2 = common_vendor.resolveComponent("wd-popup");
+  _easycom_wd_popup2();
+}
+const _easycom_wd_popup = () => "../../../node-modules/wot-design-uni/components/wd-popup/wd-popup.js";
+if (!Math) {
+  _easycom_wd_popup();
+}
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  __name: "photoExamplePopup",
+  props: {
+    show: {
+      type: Boolean,
+      default: true
+    }
+  },
+  emits: ["update:show"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { handleClose } = hooks_useDraw.useDraw(props, emit);
+    return (_ctx, _cache) => {
+      return {
+        a: common_vendor.unref(pagesOne_winner_utils_source.imgObj).photoExp,
+        b: common_vendor.o(
+          //@ts-ignore
+          (...args) => common_vendor.unref(handleClose) && common_vendor.unref(handleClose)(...args)
+        ),
+        c: common_vendor.unref(pagesOne_winner_utils_source.imgObj).close,
+        d: common_vendor.o(($event) => props.show = $event),
+        e: common_vendor.p({
+          ["custom-style"]: "border-radius:10rpx;height:1000rpx; background: transparent;",
+          ["lock-scroll"]: true,
+          modelValue: props.show
+        })
+      };
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-ea8b307a"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/pagesOne/winner/components/photoExamplePopup.json

@@ -0,0 +1,6 @@
+{
+  "component": true,
+  "usingComponents": {
+    "wd-popup": "../../../node-modules/wot-design-uni/components/wd-popup/wd-popup"
+  }
+}

dist/dev/mp-weixin/pagesOne/winner/components/photoExamplePopup.wxml

@@ -0,0 +1 @@
+<wd-popup wx:if="{{e}}" class="data-v-ea8b307a" u-s="{{['d']}}" u-i="ea8b307a-0" bind:__l="__l" bindupdateModelValue="{{d}}" u-p="{{e}}"><view class="exampleContent data-v-ea8b307a"><image class="example data-v-ea8b307a" src="{{a}}" mode="scaleToFill"/><image bindtap="{{b}}" class="closed data-v-ea8b307a" src="{{c}}" mode="scaleToFill"/></view></wd-popup>

dist/dev/mp-weixin/pagesOne/winner/components/photoExamplePopup.wxss

@@ -0,0 +1,41 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+.exampleContent.data-v-ea8b307a {
+  background: transparent;
+}
+.exampleContent .example.data-v-ea8b307a {
+  width: 686rpx;
+  height: 798rpx;
+}
+.exampleContent .closed.data-v-ea8b307a {
+  width: 56rpx;
+  height: 56rpx;
+  position: absolute;
+  top: 824rpx;
+  left: 0;
+  right: 0;
+  margin: auto;
+}

dist/dev/mp-weixin/pagesOne/winner/components/uploadReceptPopop.js

@@ -0,0 +1,67 @@
+"use strict";
+const common_vendor = require("../../../common/vendor.js");
+const pagesOne_winner_utils_source = require("../utils/source.js");
+const hooks_useDraw = require("../../../hooks/useDraw.js");
+if (!Array) {
+  const _easycom_wd_gap2 = common_vendor.resolveComponent("wd-gap");
+  const _easycom_wd_popup2 = common_vendor.resolveComponent("wd-popup");
+  (_easycom_wd_gap2 + _easycom_wd_popup2)();
+}
+const _easycom_wd_gap = () => "../../../node-modules/wot-design-uni/components/wd-gap/wd-gap.js";
+const _easycom_wd_popup = () => "../../../node-modules/wot-design-uni/components/wd-popup/wd-popup.js";
+if (!Math) {
+  (_easycom_wd_gap + _easycom_wd_popup)();
+}
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  __name: "uploadReceptPopop",
+  props: {
+    show: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["update:show"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    common_vendor.ref("1");
+    const list = [
+      { name: "满25返8", id: "1", checked: false },
+      { name: "满25返8", id: "2", checked: false },
+      { name: "满25返8", id: "3", checked: true },
+      { name: "满25返8", id: "1", checked: false },
+      { name: "满25返8", id: "2", checked: false }
+    ];
+    const { handleClose } = hooks_useDraw.useDraw(props, emit);
+    return (_ctx, _cache) => {
+      return {
+        a: common_vendor.f(list, (item, k0, i0) => {
+          return {
+            a: item.id,
+            b: item.checked,
+            c: item.id,
+            d: common_vendor.n(item.checked ? "active" : "static")
+          };
+        }),
+        b: common_vendor.unref(pagesOne_winner_utils_source.imgObj).icon1,
+        c: common_vendor.p({
+          height: "16rpx",
+          ["bg-color"]: "#F7F8F9"
+        }),
+        d: common_vendor.o(
+          //@ts-ignore
+          (...args) => common_vendor.unref(handleClose) && common_vendor.unref(handleClose)(...args)
+        ),
+        e: common_vendor.o(common_vendor.unref(handleClose)),
+        f: common_vendor.o(($event) => props.show = $event),
+        g: common_vendor.p({
+          position: "bottom",
+          ["safe-area-inset-bottom"]: true,
+          ["custom-style"]: "height: 922rpx;border-radius: 40rpx 40rpx 0 0;",
+          modelValue: props.show
+        })
+      };
+    };
+  }
+});
+wx.createComponent(_sfc_main);

dist/dev/mp-weixin/pagesOne/winner/components/uploadReceptPopop.json

@@ -0,0 +1,7 @@
+{
+  "component": true,
+  "usingComponents": {
+    "wd-gap": "../../../node-modules/wot-design-uni/components/wd-gap/wd-gap",
+    "wd-popup": "../../../node-modules/wot-design-uni/components/wd-popup/wd-popup"
+  }
+}

dist/dev/mp-weixin/pagesOne/winner/components/uploadReceptPopop.wxml

@@ -0,0 +1 @@
+<view class="uploadReceptPopup"><wd-popup wx:if="{{g}}" u-s="{{['d']}}" bindclose="{{e}}" u-i="6fe79449-0" bind:__l="__l" bindupdateModelValue="{{f}}" u-p="{{g}}"><view class="topTitle"><text>上传小票</text><text class="tips">（*先选择优惠力度再上传）</text></view><radio-group class="receptBox"><label wx:for="{{a}}" wx:for-item="item" wx:key="c" class="{{['radioItem', item.d]}}"><view class="left"><image class="icon" src="{{b}}" mode="scaleToFill"/><text class="label">满25返8</text></view><radio class="radio" color="#225036" value="{{item.a}}" style="transform:scale(0.9)" checked="{{item.b}}"/></label></radio-group><view class="btnBox"><view class="play">拍摄照片</view><view class="phone">从手机相册选择</view><wd-gap wx:if="{{c}}" u-i="6fe79449-1,6fe79449-0" bind:__l="__l" u-p="{{c}}"></wd-gap><view bindtap="{{d}}">取消</view></view></wd-popup></view>

dist/dev/mp-weixin/pagesOne/winner/components/uploadReceptPopop.wxss

@@ -0,0 +1,81 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+.uploadReceptPopup .topTitle {
+  font-size: 36rpx;
+  color: #1f1f39;
+  height: 80rpx;
+  text-align: center;
+  margin-top: 26rpx;
+}
+.uploadReceptPopup .topTitle .tips {
+  font-size: 20rpx;
+  color: #bfc8db;
+}
+.uploadReceptPopup .receptBox {
+  height: 390rpx;
+  overflow-y: scroll;
+}
+.uploadReceptPopup .radioItem {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 0 60rpx;
+  height: 80rpx;
+  box-sizing: border-box;
+  color: #333;
+  font-size: 28rpx;
+}
+.uploadReceptPopup .radioItem .left {
+  display: flex;
+  align-items: center;
+}
+.uploadReceptPopup .radioItem .icon {
+  width: 36rpx;
+  height: 36rpx;
+  margin-right: 20rpx;
+}
+.uploadReceptPopup .radioItem.active {
+  background-color: #f7f8f9;
+}
+.uploadReceptPopup .radioItem.static {
+  background-color: #fff;
+}
+.uploadReceptPopup .radioItem:focus {
+  background-color: pink;
+}
+.uploadReceptPopup .btnBox {
+  font-size: 36rpx;
+  color: #555d6c;
+  margin-top: 48rpx;
+}
+.uploadReceptPopup .btnBox > view {
+  text-align: center;
+  width: 100%;
+  line-height: 108rpx;
+}
+.uploadReceptPopup .btnBox .play {
+  background: #f7f8f9;
+}

dist/dev/mp-weixin/pagesOne/winner/components/uploadRecordPopup.js

@@ -0,0 +1,57 @@
+"use strict";
+const common_vendor = require("../../../common/vendor.js");
+const pagesOne_winner_utils_source = require("../utils/source.js");
+const hooks_useDraw = require("../../../hooks/useDraw.js");
+if (!Array) {
+  const _easycom_wd_tag2 = common_vendor.resolveComponent("wd-tag");
+  const _easycom_wd_popup2 = common_vendor.resolveComponent("wd-popup");
+  (_easycom_wd_tag2 + _easycom_wd_popup2)();
+}
+const _easycom_wd_tag = () => "../../../node-modules/wot-design-uni/components/wd-tag/wd-tag.js";
+const _easycom_wd_popup = () => "../../../node-modules/wot-design-uni/components/wd-popup/wd-popup.js";
+if (!Math) {
+  (_easycom_wd_tag + _easycom_wd_popup)();
+}
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  __name: "uploadRecordPopup",
+  props: {
+    show: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["update:show"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { handleClose } = hooks_useDraw.useDraw(props, emit);
+    return (_ctx, _cache) => {
+      return {
+        a: common_vendor.f(6, (item, k0, i0) => {
+          return common_vendor.e({
+            a: "5a089942-1-" + i0 + ",5a089942-0",
+            b: common_vendor.p({
+              ["custom-style"]: "padding:8rpx 26rpx;border-radius: 8rpx;font-size:22rpx;",
+              color: "#FF3B1D",
+              ["bg-color"]: "#FF3B1D33"
+            })
+          }, {
+            e: item
+          });
+        }),
+        b: common_vendor.o(
+          //@ts-ignore
+          (...args) => common_vendor.unref(handleClose) && common_vendor.unref(handleClose)(...args)
+        ),
+        c: common_vendor.unref(pagesOne_winner_utils_source.imgObj).close,
+        d: common_vendor.o(($event) => props.show = $event),
+        e: common_vendor.p({
+          ["custom-style"]: "height: 880rpx;width:686rpx;background: transparent;",
+          modelValue: props.show
+        })
+      };
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-5a089942"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/pagesOne/winner/components/uploadRecordPopup.json

@@ -0,0 +1,7 @@
+{
+  "component": true,
+  "usingComponents": {
+    "wd-tag": "../../../node-modules/wot-design-uni/components/wd-tag/wd-tag",
+    "wd-popup": "../../../node-modules/wot-design-uni/components/wd-popup/wd-popup"
+  }
+}

dist/dev/mp-weixin/pagesOne/winner/components/uploadRecordPopup.wxml

@@ -0,0 +1 @@
+<view class="uploadRecordPopup data-v-5a089942"><wd-popup wx:if="{{e}}" class="data-v-5a089942" u-s="{{['d']}}" u-i="5a089942-0" bind:__l="__l" bindupdateModelValue="{{d}}" u-p="{{e}}"><view class="content data-v-5a089942"><view class="list data-v-5a089942"><view wx:for="{{a}}" wx:for-item="item" wx:key="e" class="record data-v-5a089942"><view class="left data-v-5a089942"><text class="data-v-5a089942">活动力度：满26返6</text><wd-tag wx:if="{{true}}" class="data-v-5a089942" u-s="{{['d']}}" u-i="{{item.a}}" bind:__l="__l" u-p="{{item.b}}"> 已拒绝 </wd-tag><wd-tag wx:else class="data-v-5a089942" u-s="{{['d']}}" u-i="{{item.c}}" bind:__l="__l" u-p="{{item.d||''}}"> 已通过 </wd-tag></view><view class="time data-v-5a089942">上传时间：2021-11-21 06:12:31</view></view></view></view><image class="closed data-v-5a089942" bindtap="{{b}}" src="{{c}}" mode="scaleToFill"/></wd-popup></view>

dist/dev/mp-weixin/pagesOne/winner/components/uploadRecordPopup.wxss

@@ -0,0 +1,69 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+.uploadRecordPopup .content.data-v-5a089942 {
+  height: 798rpx;
+  width: 686rpx;
+  background: url("https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/uploadRecord.png") no-repeat center;
+  background-size: 100% 100%;
+  box-sizing: border-box;
+  overflow: hidden;
+}
+.uploadRecordPopup .content .list.data-v-5a089942 {
+  font-size: 28rpx;
+  color: #666666;
+  overflow-y: scroll;
+  height: 70%;
+  box-sizing: border-box;
+  width: 85%;
+  margin: auto;
+  margin-top: 128rpx;
+}
+.uploadRecordPopup .content .list .record.data-v-5a089942 {
+  text-align: center;
+  text-align: left;
+  padding: 32rpx 0;
+  border-bottom: 1rpx solid rgba(191, 200, 219, 0.5);
+}
+.uploadRecordPopup .content .list .record .left text.data-v-5a089942 {
+  margin-right: 44rpx;
+}
+.uploadRecordPopup .content .list .record.data-v-5a089942:last-of-type {
+  border: none;
+}
+.uploadRecordPopup .closed.data-v-5a089942 {
+  width: 56rpx;
+  height: 56rpx;
+  margin: auto;
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  margin: auto;
+}
+.uploadRecordPopup .time.data-v-5a089942 {
+  font-size: 28rpx;
+  color: #666666;
+}

dist/dev/mp-weixin/pagesOne/winner/components/winRecordPopup.js

@@ -0,0 +1,53 @@
+"use strict";
+const common_vendor = require("../../../common/vendor.js");
+const pagesOne_winner_utils_source = require("../utils/source.js");
+const hooks_useDraw = require("../../../hooks/useDraw.js");
+if (!Array) {
+  const _easycom_wd_popup2 = common_vendor.resolveComponent("wd-popup");
+  _easycom_wd_popup2();
+}
+const _easycom_wd_popup = () => "../../../node-modules/wot-design-uni/components/wd-popup/wd-popup.js";
+if (!Math) {
+  _easycom_wd_popup();
+}
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  __name: "winRecordPopup",
+  props: {
+    show: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["update:show"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { handleClose } = hooks_useDraw.useDraw(props, emit);
+    return (_ctx, _cache) => {
+      return {
+        a: common_vendor.f(6, (item, k0, i0) => {
+          return {
+            a: item
+          };
+        }),
+        b: common_vendor.f(2, (item, k0, i0) => {
+          return {
+            a: item
+          };
+        }),
+        c: common_vendor.o(
+          //@ts-ignore
+          (...args) => common_vendor.unref(handleClose) && common_vendor.unref(handleClose)(...args)
+        ),
+        d: common_vendor.unref(pagesOne_winner_utils_source.imgObj).close,
+        e: common_vendor.o(($event) => props.show = $event),
+        f: common_vendor.p({
+          ["custom-style"]: "height: 880rpx;width:686rpx;background: transparent;",
+          modelValue: props.show
+        })
+      };
+    };
+  }
+});
+const Component = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-519d4c6f"]]);
+wx.createComponent(Component);

dist/dev/mp-weixin/pagesOne/winner/components/winRecordPopup.json

@@ -0,0 +1,6 @@
+{
+  "component": true,
+  "usingComponents": {
+    "wd-popup": "../../../node-modules/wot-design-uni/components/wd-popup/wd-popup"
+  }
+}

dist/dev/mp-weixin/pagesOne/winner/components/winRecordPopup.wxml

@@ -0,0 +1 @@
+<view class="winRecordPopup data-v-519d4c6f"><wd-popup wx:if="{{f}}" class="data-v-519d4c6f" u-s="{{['d']}}" u-i="519d4c6f-0" bind:__l="__l" bindupdateModelValue="{{e}}" u-p="{{f}}"><view class="content data-v-519d4c6f"><view class="list data-v-519d4c6f"><view wx:for="{{a}}" wx:for-item="item" wx:key="a" class="record data-v-519d4c6f"><text class="data-v-519d4c6f">活动力度：满26返6</text><text class="data-v-519d4c6f">奖励金额：5元</text></view><view wx:for="{{b}}" wx:for-item="item" wx:key="a" class="record data-v-519d4c6f"><text class="data-v-519d4c6f">活动力度：满26返61</text><text class="data-v-519d4c6f">奖励金额：5111111元</text></view></view></view><image class="closed data-v-519d4c6f" bindtap="{{c}}" src="{{d}}" mode="scaleToFill"/></wd-popup></view>

dist/dev/mp-weixin/pagesOne/winner/components/winRecordPopup.wxss

@@ -0,0 +1,65 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+.winRecordPopup .content.data-v-519d4c6f {
+  height: 798rpx;
+  width: 686rpx;
+  background: url("https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/winRecord.png") no-repeat center;
+  background-size: 100% 100%;
+  box-sizing: border-box;
+  overflow: hidden;
+}
+.winRecordPopup .content .list.data-v-519d4c6f {
+  font-size: 28rpx;
+  color: #666666;
+  overflow-y: scroll;
+  height: 70%;
+  box-sizing: border-box;
+  width: 75%;
+  margin: auto;
+  margin-top: 128rpx;
+}
+.winRecordPopup .content .list .record.data-v-519d4c6f {
+  text-align: center;
+  text-align: left;
+  padding: 32rpx 0;
+  border-bottom: 1rpx solid rgba(191, 200, 219, 0.5);
+}
+.winRecordPopup .content .list .record > text.data-v-519d4c6f:last-of-type {
+  margin-left: 44rpx;
+}
+.winRecordPopup .content .list .record.data-v-519d4c6f:last-of-type {
+  border: none;
+}
+.winRecordPopup .closed.data-v-519d4c6f {
+  width: 56rpx;
+  height: 56rpx;
+  margin: auto;
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  margin: auto;
+}

dist/dev/mp-weixin/pagesOne/winner/index.js

@@ -0,0 +1,64 @@
+"use strict";
+const common_vendor = require("../../common/vendor.js");
+const pagesOne_winner_utils_source = require("./utils/source.js");
+if (!Array) {
+  const _easycom_wd_gap2 = common_vendor.resolveComponent("wd-gap");
+  _easycom_wd_gap2();
+}
+const _easycom_wd_gap = () => "../../node-modules/wot-design-uni/components/wd-gap/wd-gap.js";
+if (!Math) {
+  (_easycom_wd_gap + PhotoExamplePopup + UploadReceptPopop + WinRecordPopup + UploadRecordPopup)();
+}
+const PhotoExamplePopup = () => "./components/photoExamplePopup.js";
+const UploadReceptPopop = () => "./components/uploadReceptPopop.js";
+const WinRecordPopup = () => "./components/winRecordPopup.js";
+const UploadRecordPopup = () => "./components/uploadRecordPopup.js";
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  __name: "index",
+  setup(__props) {
+    let showExample = common_vendor.ref(false);
+    let showUpload = common_vendor.ref(false);
+    let showWiner = common_vendor.ref(false);
+    let showRecord = common_vendor.ref(true);
+    return (_ctx, _cache) => {
+      return {
+        a: common_vendor.unref(pagesOne_winner_utils_source.imgObj).backImg,
+        b: common_vendor.unref(pagesOne_winner_utils_source.imgObj).rule,
+        c: common_vendor.o(($event) => _ctx.showWinner = true),
+        d: common_vendor.unref(pagesOne_winner_utils_source.imgObj).record,
+        e: common_vendor.unref(pagesOne_winner_utils_source.imgObj).photo,
+        f: common_vendor.o(($event) => common_vendor.isRef(showExample) ? showExample.value = true : showExample = true),
+        g: common_vendor.unref(pagesOne_winner_utils_source.imgObj).book,
+        h: common_vendor.o(($event) => common_vendor.isRef(showRecord) ? showRecord.value = true : showRecord = true),
+        i: common_vendor.unref(pagesOne_winner_utils_source.gifObj).pointer,
+        j: common_vendor.o(($event) => common_vendor.isRef(showUpload) ? showUpload.value = true : showUpload = true),
+        k: common_vendor.f(6, (item, k0, i0) => {
+          return {
+            a: item
+          };
+        }),
+        l: common_vendor.p({
+          ["bg-color"]: "transparent"
+        }),
+        m: common_vendor.o(($event) => common_vendor.isRef(showExample) ? showExample.value = $event : showExample = $event),
+        n: common_vendor.p({
+          show: common_vendor.unref(showExample)
+        }),
+        o: common_vendor.o(($event) => common_vendor.isRef(showUpload) ? showUpload.value = $event : showUpload = $event),
+        p: common_vendor.p({
+          show: common_vendor.unref(showUpload)
+        }),
+        q: common_vendor.o(($event) => common_vendor.isRef(showWiner) ? showWiner.value = $event : showWiner = $event),
+        r: common_vendor.p({
+          show: common_vendor.unref(showWiner)
+        }),
+        s: common_vendor.o(($event) => common_vendor.isRef(showRecord) ? showRecord.value = $event : showRecord = $event),
+        t: common_vendor.p({
+          show: common_vendor.unref(showRecord)
+        })
+      };
+    };
+  }
+});
+const MiniProgramPage = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-3457e999"]]);
+wx.createPage(MiniProgramPage);

dist/dev/mp-weixin/pagesOne/winner/index.json

@@ -0,0 +1,10 @@
+{
+  "navigationStyle": "custom",
+  "usingComponents": {
+    "wd-gap": "../../node-modules/wot-design-uni/components/wd-gap/wd-gap",
+    "photo-example-popup": "./components/photoExamplePopup",
+    "upload-recept-popop": "./components/uploadReceptPopop",
+    "win-record-popup": "./components/winRecordPopup",
+    "upload-record-popup": "./components/uploadRecordPopup"
+  }
+}

dist/dev/mp-weixin/pagesOne/winner/index.wxss

@@ -0,0 +1,211 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+.winnerContent.data-v-3457e999 {
+  width: 100%;
+  min-height: 2524rpx;
+  overflow: hidden;
+  box-sizing: border-box;
+  position: relative;
+  font-family: PingFang SC;
+}
+.winnerContent .content.data-v-3457e999 {
+  width: 96%;
+  margin: auto;
+  position: relative;
+}
+.winnerContent .backImage.data-v-3457e999 {
+  width: 100%;
+  height: 100%;
+  position: absolute;
+  z-index: -1;
+}
+.winnerContent .floatWindow.data-v-3457e999 {
+  position: fixed;
+  z-index: 10;
+  right: 0;
+  top: 240rpx;
+  display: flex;
+  flex-direction: column;
+}
+.winnerContent .floatWindow image.data-v-3457e999 {
+  width: 158rpx;
+  height: 48rpx;
+  margin-bottom: 24rpx;
+}
+.winnerContent .recordBox.data-v-3457e999 {
+  height: 192rpx;
+  border-radius: 32rpx;
+  background: linear-gradient(90deg, #225036 0%, #3b8e5e 45.92%, #3d8f5f 100%);
+  padding: 24rpx;
+  display: flex;
+  justify-content: space-between;
+  margin-top: 974rpx;
+  align-items: center;
+  box-sizing: border-box;
+}
+.winnerContent .recordBox > view.data-v-3457e999 {
+  width: 306rpx;
+  height: 144rpx;
+  background: linear-gradient(180deg, #e5fff6 0%, #ffffff 100%);
+  border-radius: 24rpx;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.winnerContent .recordBox image.data-v-3457e999 {
+  width: 92rpx;
+  height: 92rpx;
+  margin-left: 22rpx;
+}
+.winnerContent .uploadBox.data-v-3457e999 {
+  color: #c0630f;
+  margin-top: 32rpx;
+}
+.winnerContent .uploadBox .count.data-v-3457e999 {
+  width: 50%;
+  color: #c0630f;
+  font-size: 24rpx;
+  background: linear-gradient(90deg, #ffcd70 0%, #ffe3b6 45.92%, #fcc761 100%);
+  border-top-left-radius: 16rpx;
+  border-top-right-radius: 16rpx;
+  text-align: center;
+  line-height: 50rpx;
+  margin: auto;
+  margin-bottom: -2rpx;
+}
+.winnerContent .uploadBox .btnBox.data-v-3457e999 {
+  width: 100%;
+  height: 178rpx;
+  background: url("https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/uploadBtn.png") no-repeat center;
+  background-size: 100% 100%;
+  -o-object-fit: cover;
+     object-fit: cover;
+  position: relative;
+}
+.winnerContent .uploadBox .btnBox image.data-v-3457e999 {
+  width: 150rpx;
+  height: 150rpx;
+  position: absolute;
+  right: -20rpx;
+  bottom: 0;
+}
+.winnerContent .uploadBox .tip.data-v-3457e999 {
+  font-size: 24rpx;
+  font-weight: 600;
+  text-align: center;
+  margin-top: 6rpx;
+}
+.winnerContent .bigTitle.data-v-3457e999 {
+  font-size: 44rpx;
+  font-weight: 700;
+  letter-spacing: 12rpx;
+  font-family: Alimama ShuHeiTi;
+  color: transparent;
+  background: linear-gradient(0deg, #fff6d8 0%, #ffffff 100%);
+  -webkit-background-clip: text;
+  display: inline-block;
+  width: 100%;
+  text-align: center;
+  margin-top: 12rpx;
+}
+.winnerContent .activityTimeBox.data-v-3457e999 {
+  width: 100%;
+  height: 210rpx;
+  background: url("https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/activeBg.png") no-repeat center;
+  background-size: 100% 100%;
+  margin-top: 32rpx;
+}
+.winnerContent .activityTimeBox .timeBox.data-v-3457e999 {
+  font-size: 28rpx;
+  color: #333;
+  text-align: center;
+  margin-top: 20rpx;
+  font-size: 28rpx;
+  color: #333;
+}
+.winnerContent .activityTimeBox .timeBox > text.data-v-3457e999 {
+  display: block;
+}
+.winnerContent .goodsListBox.data-v-3457e999 {
+  background: url("https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/goodsBg.png") no-repeat center;
+  background-size: 100% 100%;
+  padding: 100rpx 50rpx;
+  height: 764rpx;
+  position: relative;
+  margin-top: 64rpx;
+  box-sizing: border-box;
+}
+.winnerContent .goodsListBox .square.data-v-3457e999 {
+  width: 59%;
+  height: 88rpx;
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: -68rpx;
+  margin: auto;
+  z-index: 0;
+  background: url("https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/square.png") no-repeat center;
+  background-size: 100% 100%;
+  margin-top: 32rpx;
+}
+.winnerContent .goodsListBox .title.data-v-3457e999 {
+  position: absolute;
+  z-index: 99;
+}
+.winnerContent .goodsListBox .goodsList.data-v-3457e999 {
+  display: flex;
+  justify-content: space-between;
+  flex-wrap: wrap;
+}
+.winnerContent .goodsListBox .goodsItem.data-v-3457e999 {
+  width: 172rpx;
+  height: 204rpx;
+  background: url("https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/redBag.png") no-repeat center;
+  background-size: 100% 100%;
+  position: relative;
+  margin-bottom: 40rpx;
+}
+.winnerContent .goodsListBox .goodsItem > text.data-v-3457e999 {
+  position: absolute;
+  left: 0;
+  right: 0;
+  text-align: center;
+}
+.winnerContent .goodsListBox .goodsItem .money.data-v-3457e999 {
+  color: #c0630f;
+  font-size: 48rpx;
+  top: 20rpx;
+}
+.winnerContent .goodsListBox .goodsItem .content.data-v-3457e999 {
+  color: #224f36;
+  font-size: 24rpx;
+  top: 88rpx;
+}
+.winnerContent .goodsListBox .goodsItem .name.data-v-3457e999 {
+  color: #ffffff;
+  font-size: 28rpx;
+  bottom: 24rpx;
+}

dist/dev/mp-weixin/pagesOne/winner/uploadImage.js

@@ -0,0 +1,35 @@
+"use strict";
+const common_vendor = require("../../common/vendor.js");
+if (!Array) {
+  const _easycom_wd_upload2 = common_vendor.resolveComponent("wd-upload");
+  _easycom_wd_upload2();
+}
+const _easycom_wd_upload = () => "../../node-modules/wot-design-uni/components/wd-upload/wd-upload.js";
+if (!Math) {
+  _easycom_wd_upload();
+}
+const _sfc_main = /* @__PURE__ */ common_vendor.defineComponent({
+  __name: "uploadImage",
+  setup(__props) {
+    const fileList = common_vendor.ref([
+      {
+        url: "https://img12.360buyimg.com//n0/jfs/t1/29118/6/4823/55969/5c35c16bE7c262192/c9fdecec4b419355.jpg"
+      }
+    ]);
+    const handleChange = (file) => {
+      console.log(file);
+    };
+    return (_ctx, _cache) => {
+      return {
+        a: common_vendor.o(handleChange),
+        b: common_vendor.p({
+          ["file-list"]: fileList.value,
+          action: "https://mockapi.eolink.com/zhTuw2P8c29bc981a741931bdd86eb04dc1e8fd64865cb5/upload",
+          multiple: true,
+          limit: 5
+        })
+      };
+    };
+  }
+});
+wx.createPage(_sfc_main);

dist/dev/mp-weixin/pagesOne/winner/uploadImage.json

@@ -0,0 +1,6 @@
+{
+  "navigationBarTitleText": "批量上传照片",
+  "usingComponents": {
+    "wd-upload": "../../node-modules/wot-design-uni/components/wd-upload/wd-upload"
+  }
+}

dist/dev/mp-weixin/pagesOne/winner/uploadImage.wxml

@@ -0,0 +1 @@
+<view class="uploadImageBox"><wd-upload wx:if="{{b}}" u-s="{{['d']}}" bindchange="{{a}}" u-i="fad57140-0" bind:__l="__l" u-p="{{b}}"><image class="upload" src="https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/upload.png" mode="scaleToFill"/></wd-upload><view class="tips">最多上传5张照片</view><view class="btn">立即上传</view></view>

dist/dev/mp-weixin/pagesOne/winner/uploadImage.wxss

@@ -0,0 +1,54 @@
+/**
+ * 这里是uni-app内置的常用样式变量
+ *
+ * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
+ * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
+ *
+ */
+/**
+ * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
+ *
+ * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
+ */
+/* 颜色变量 */
+/* 行为相关颜色 */
+/* 文字基本颜色 */
+/* 背景颜色 */
+/* 边框颜色 */
+/* 尺寸变量 */
+/* 文字尺寸 */
+/* 图片尺寸 */
+/* Border Radius */
+/* 水平间距 */
+/* 垂直间距 */
+/* 透明度 */
+/* 文章场景相关 */
+.uploadImageBox {
+  padding: 40rpx 32rpx;
+}
+.uploadImageBox .wd-upload__picture {
+  width: 196rpx !important;
+  height: 196rpx !important;
+}
+.uploadImageBox .upload {
+  width: 196rpx;
+  height: 196rpx;
+}
+.uploadImageBox .tips {
+  font-size: 20rpx;
+  color: #bfc8db;
+}
+.uploadImageBox .btn {
+  width: 560rpx;
+  background: linear-gradient(90deg, #225036 0%, #3b8e5e 45.92%, #296141 100%);
+  color: #fff;
+  font-size: 32rpx;
+  border-radius: 80rpx;
+  left: 0;
+  right: 0;
+  margin: auto;
+  text-align: center;
+  line-height: 100rpx;
+  position: fixed;
+  bottom: 154rpx;
+}

dist/dev/mp-weixin/pagesOne/winner/utils/source.js

@@ -0,0 +1,21 @@
+"use strict";
+const imgObj = {
+  backImg: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/Group%201.png",
+  rule: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/rule.png",
+  record: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/record.png",
+  photo: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/photo.png",
+  book: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/book.png",
+  redBag: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/redBag.png",
+  uploadBtn: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/uploadBtn.png",
+  activeBg: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/activeBg.png",
+  goodsBg: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/goodsBg.png",
+  square: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/square.png",
+  photoExp: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/photoExp.png",
+  close: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/close.png",
+  icon1: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/images/icon1.png"
+};
+const gifObj = {
+  pointer: "https://qiuyu-daodian.oss-cn-beijing.aliyuncs.com/gifs/pointer.gif"
+};
+exports.gifObj = gifObj;
+exports.imgObj = imgObj;

dist/dev/mp-weixin/project.config.json

@@ -0,0 +1,58 @@
+{
+  "description": "项目配置文件。",
+  "packOptions": {
+    "ignore": [],
+    "include": []
+  },
+  "setting": {
+    "urlCheck": false,
+    "es6": true,
+    "postcss": false,
+    "minified": false,
+    "newFeature": true,
+    "bigPackageSizeSupport": true,
+    "compileWorklet": false,
+    "uglifyFileName": false,
+    "uploadWithSourceMap": true,
+    "enhance": false,
+    "packNpmManually": false,
+    "packNpmRelationList": [],
+    "minifyWXSS": true,
+    "minifyWXML": true,
+    "localPlugins": false,
+    "disableUseStrict": false,
+    "useCompilerPlugins": false,
+    "condition": false,
+    "swc": false,
+    "disableSWC": true,
+    "babelSetting": {
+      "ignore": [],
+      "disablePlugins": [],
+      "outputPath": ""
+    }
+  },
+  "compileType": "miniprogram",
+  "libVersion": "",
+  "appid": "wx4f6dc4ac1674547c",
+  "projectname": "",
+  "condition": {
+    "search": {
+      "current": -1,
+      "list": []
+    },
+    "conversation": {
+      "current": -1,
+      "list": []
+    },
+    "game": {
+      "current": -1,
+      "list": []
+    },
+    "miniprogram": {
+      "current": -1,
+      "list": []
+    }
+  },
+  "simulatorPluginLibVersion": {},
+  "editorSetting": {}
+}

dist/dev/mp-weixin/project.private.config.json

@@ -0,0 +1,35 @@
+{
+  "libVersion": "3.8.3",
+  "projectname": "mp-weixin",
+  "condition": {
+    "miniprogram": {
+      "list": [
+        {
+          "name": "pagesOne/winner/index",
+          "pathName": "pagesOne/winner/index",
+          "query": "",
+          "scene": null,
+          "launchMode": "default"
+        }
+      ]
+    }
+  },
+  "setting": {
+    "urlCheck": false,
+    "coverView": false,
+    "lazyloadPlaceholderEnable": false,
+    "skylineRenderEnable": false,
+    "preloadBackgroundData": false,
+    "autoAudits": false,
+    "useApiHook": true,
+    "useApiHostProcess": true,
+    "showShadowRootInWxmlPanel": false,
+    "useStaticServer": false,
+    "useLanDebug": false,
+    "showES6CompileOption": false,
+    "compileHotReLoad": true,
+    "checkInvalidKey": true,
+    "ignoreDevUnusedFiles": true,
+    "bigPackageSizeSupport": true
+  }
+}

dist/dev/mp-weixin/services/task.js

@@ -0,0 +1,10 @@
+"use strict";
+const utils_http = require("../utils/http.js");
+const postLoginAPI = (data) => {
+  return utils_http.http({
+    method: "POST",
+    url: "/login",
+    data
+  });
+};
+exports.postLoginAPI = postLoginAPI;

dist/dev/mp-weixin/utils/http.js

@@ -0,0 +1,53 @@
+"use strict";
+const common_vendor = require("../common/vendor.js");
+var define_import_meta_env_default = {};
+const baseURL = define_import_meta_env_default.VITE_API_URL;
+const httpInterceptor = {
+  // 拦截前触发
+  invoke(options) {
+    if (!options.url.startsWith("http")) {
+      options.url = baseURL + options.url;
+    }
+    options.timeout = 3e4;
+    options.header = {
+      ...options.header,
+      "source-client": "miniapp"
+    };
+  }
+};
+common_vendor.index.addInterceptor("request", httpInterceptor);
+const http = (options) => {
+  return new Promise((resolve, reject) => {
+    common_vendor.index.request({
+      ...options,
+      // 响应成功
+      success(res) {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          if (res.data.code == 401) {
+            common_vendor.index.redirectTo({ url: "/" });
+          } else {
+            resolve(res.data);
+          }
+        } else if (res.statusCode === 401) {
+          common_vendor.index.redirectTo({ url: "/" });
+          reject(res);
+        } else {
+          common_vendor.index.showToast({
+            icon: "none",
+            title: res.data.msg || "请求错误"
+          });
+          reject(res);
+        }
+      },
+      // 响应失败
+      fail(err) {
+        common_vendor.index.showToast({
+          icon: "none",
+          title: "网络错误，换个网络试试"
+        });
+        reject(err);
+      }
+    });
+  });
+};
+exports.http = http;

src/hooks/useDraw.ts

@@ -0,0 +1,7 @@
+export function useDraw(props: any, emit: any) {
+  const handleClose = () => {
+    emit("update:show", false);
+  };
+
+  return { handleClose };
+}

src/pages/index/index.vue

@@ -22,7 +22,9 @@
 </template>
 
 <script setup lang="ts">
-import { ref, getCurrentInstance } from "vue";
+import { onLoad, onShow } from "@dcloudio/uni-app";
+
+import { ref, getCurrentInstance, on } from "vue";
 const current = ref<number>(0);
 
 const swiperList = ref([
@@ -38,6 +40,42 @@ function handleClick(e: any) {
 function onChange(e: any) {
   console.log(e);
 }
+
+const getuser = () => {
+  uni.login({
+    //获取code，
+    success: (res) => {
+      var code = res.code,
+        appId = "wx4f6dc4ac1674547c",
+        secret = "9e0e7fe5161541d9862b8ee2db6da840";
+      console.log("正在登录中...");
+      //根据获取的code去腾讯服务器，请求用户数据，返回的结果中，包含openid
+      wx.request({
+        url:
+          "https://api.weixin.qq.com/sns/jscode2session?appid=" +
+          appId +
+          "&secret=" +
+          secret +
+          "&js_code=" +
+          code +
+          "&grant_type=authorization_code",
+        data: {},
+        header: {
+          "content-type": "json",
+        },
+        success: (user_res) => {
+          //请求成功获取openid；
+          const user_openid = user_res.data.openid;
+          console.log("登录成功", user_openid);
+        },
+      });
+    },
+  });
+};
+
+onLoad(() => {
+  getuser();
+});
 </script>
 
 <style lang="scss">

src/pagesOne/winner/components/photoExamplePopup.vue

@@ -18,6 +18,7 @@
 
 <script lang="ts" setup>
 import { imgObj } from "../utils/source";
+import { useDraw } from "@/hooks/useDraw";
 
 const props = defineProps({
   show: {
@@ -28,9 +29,7 @@ const props = defineProps({
 
 const emit = defineEmits(["update:show"]);
 
-const handleClose = () => {
-  emit("update:show", false);
-};
+const { handleClose } = useDraw(props, emit);
 </script>
 
 <style lang="scss" scoped>