From 5c3a5caeb861b273144ee87e1690f83ce1859734 Mon Sep 17 00:00:00 2001 From: EZ4Jam1n <“1286884552@qq.com”> Date: Wed, 22 May 2024 10:14:19 +0800 Subject: [PATCH] Initial Commit --- .gitignore | 14 + api/index.js | 61 + app.js | 46 + app.json | 61 + app.wxss | 91 + common/vendor.js | 9436 ++++++++++++++++++++++++++++++ config/index.js | 13 + kongshuju.js | 3 + pages/bluetooth/connect.js | 140 + pages/bluetooth/connect.json | 4 + pages/bluetooth/connect.wxml | 1 + pages/bluetooth/connect.wxss | 117 + pages/bluetooth/device.js | 43 + pages/bluetooth/device.json | 4 + pages/bluetooth/device.wxml | 1 + pages/bluetooth/device.wxss | 67 + pages/bluetooth/index.js | 112 + pages/bluetooth/index.json | 4 + pages/bluetooth/index.wxml | 1 + pages/bluetooth/index.wxss | 109 + pages/call/index.js | 248 + pages/call/index.json | 5 + pages/call/index.wxml | 1 + pages/call/index.wxss | 102 + pages/chat/index.js | 154 + pages/chat/index.json | 4 + pages/chat/index.wxml | 1 + pages/chat/index.wxss | 123 + pages/chatOnline/index.js | 207 + pages/chatOnline/index.json | 4 + pages/chatOnline/index.wxml | 1 + pages/chatOnline/index.wxss | 110 + pages/community/detail.js | 159 + pages/community/detail.json | 4 + pages/community/detail.wxml | 1 + pages/community/detail.wxss | 184 + pages/community/index.js | 135 + pages/community/index.json | 4 + pages/community/index.wxml | 1 + pages/community/index.wxss | 184 + pages/community/release.js | 139 + pages/community/release.json | 4 + pages/community/release.wxml | 1 + pages/community/release.wxss | 154 + pages/cover/index.js | 32 + pages/cover/index.json | 4 + pages/cover/index.wxml | 1 + pages/cover/index.wxss | 11 + pages/index/index.js | 185 + pages/index/index.json | 4 + pages/index/index.wxml | 1 + pages/index/index.wxss | 175 + pages/login/index.js | 54 + pages/login/index.json | 4 + pages/login/index.wxml | 1 + pages/login/index.wxss | 154 + pages/mine/aboutus.js | 8 + pages/mine/aboutus.json | 4 + pages/mine/aboutus.wxml | 1 + pages/mine/aboutus.wxss | 35 + pages/mine/contactus.js | 8 + pages/mine/contactus.json | 4 + pages/mine/contactus.wxml | 1 + pages/mine/contactus.wxss | 25 + pages/mine/index.js | 141 + pages/mine/index.json | 4 + pages/mine/index.wxml | 1 + pages/mine/index.wxss | 129 + project.config.json | 29 + project.private.config.json | 4 + static/icon/chat.png | Bin 0 -> 1237 bytes static/icon/chat_active.png | Bin 0 -> 1073 bytes static/icon/community.png | Bin 0 -> 1449 bytes static/icon/community_active.png | Bin 0 -> 1278 bytes static/icon/guadianhua.png | Bin 0 -> 4768 bytes static/icon/mine.png | Bin 0 -> 1171 bytes static/icon/mine_active.png | Bin 0 -> 1057 bytes static/icon/tianjia.png | Bin 0 -> 4336 bytes static/icon/ufo.png | Bin 0 -> 1217 bytes static/icon/ufo_active.png | Bin 0 -> 1078 bytes static/icon/yangshengqi.png | Bin 0 -> 5051 bytes static/iconfont/iconfont.css | 115 + static/iconfont/iconfont.js | 1 + static/iconfont/iconfont.json | 184 + static/iconfont/iconfont.ttf | Bin 0 -> 8704 bytes static/iconfont/iconfont.woff | Bin 0 -> 5856 bytes static/iconfont/iconfont.woff2 | Bin 0 -> 4924 bytes static/image/kongshuju.png | Bin 0 -> 1388 bytes static/image/loading.svg | 18 + static/image/mine_bg.png | Bin 0 -> 1477317 bytes static/image/toy.png | Bin 0 -> 38906 bytes tianjia.js | 3 + utils/audioUtil.js | 57 + utils/bluetooth.js | 88 + utils/request.js | 134 + utils/wsRequest.js | 122 + 96 files changed, 14000 insertions(+) create mode 100644 .gitignore create mode 100644 api/index.js create mode 100644 app.js create mode 100644 app.json create mode 100644 app.wxss create mode 100644 common/vendor.js create mode 100644 config/index.js create mode 100644 kongshuju.js create mode 100644 pages/bluetooth/connect.js create mode 100644 pages/bluetooth/connect.json create mode 100644 pages/bluetooth/connect.wxml create mode 100644 pages/bluetooth/connect.wxss create mode 100644 pages/bluetooth/device.js create mode 100644 pages/bluetooth/device.json create mode 100644 pages/bluetooth/device.wxml create mode 100644 pages/bluetooth/device.wxss create mode 100644 pages/bluetooth/index.js create mode 100644 pages/bluetooth/index.json create mode 100644 pages/bluetooth/index.wxml create mode 100644 pages/bluetooth/index.wxss create mode 100644 pages/call/index.js create mode 100644 pages/call/index.json create mode 100644 pages/call/index.wxml create mode 100644 pages/call/index.wxss create mode 100644 pages/chat/index.js create mode 100644 pages/chat/index.json create mode 100644 pages/chat/index.wxml create mode 100644 pages/chat/index.wxss create mode 100644 pages/chatOnline/index.js create mode 100644 pages/chatOnline/index.json create mode 100644 pages/chatOnline/index.wxml create mode 100644 pages/chatOnline/index.wxss create mode 100644 pages/community/detail.js create mode 100644 pages/community/detail.json create mode 100644 pages/community/detail.wxml create mode 100644 pages/community/detail.wxss create mode 100644 pages/community/index.js create mode 100644 pages/community/index.json create mode 100644 pages/community/index.wxml create mode 100644 pages/community/index.wxss create mode 100644 pages/community/release.js create mode 100644 pages/community/release.json create mode 100644 pages/community/release.wxml create mode 100644 pages/community/release.wxss create mode 100644 pages/cover/index.js create mode 100644 pages/cover/index.json create mode 100644 pages/cover/index.wxml create mode 100644 pages/cover/index.wxss create mode 100644 pages/index/index.js create mode 100644 pages/index/index.json create mode 100644 pages/index/index.wxml create mode 100644 pages/index/index.wxss create mode 100644 pages/login/index.js create mode 100644 pages/login/index.json create mode 100644 pages/login/index.wxml create mode 100644 pages/login/index.wxss create mode 100644 pages/mine/aboutus.js create mode 100644 pages/mine/aboutus.json create mode 100644 pages/mine/aboutus.wxml create mode 100644 pages/mine/aboutus.wxss create mode 100644 pages/mine/contactus.js create mode 100644 pages/mine/contactus.json create mode 100644 pages/mine/contactus.wxml create mode 100644 pages/mine/contactus.wxss create mode 100644 pages/mine/index.js create mode 100644 pages/mine/index.json create mode 100644 pages/mine/index.wxml create mode 100644 pages/mine/index.wxss create mode 100644 project.config.json create mode 100644 project.private.config.json create mode 100644 static/icon/chat.png create mode 100644 static/icon/chat_active.png create mode 100644 static/icon/community.png create mode 100644 static/icon/community_active.png create mode 100644 static/icon/guadianhua.png create mode 100644 static/icon/mine.png create mode 100644 static/icon/mine_active.png create mode 100644 static/icon/tianjia.png create mode 100644 static/icon/ufo.png create mode 100644 static/icon/ufo_active.png create mode 100644 static/icon/yangshengqi.png create mode 100644 static/iconfont/iconfont.css create mode 100644 static/iconfont/iconfont.js create mode 100644 static/iconfont/iconfont.json create mode 100644 static/iconfont/iconfont.ttf create mode 100644 static/iconfont/iconfont.woff create mode 100644 static/iconfont/iconfont.woff2 create mode 100644 static/image/kongshuju.png create mode 100644 static/image/loading.svg create mode 100644 static/image/mine_bg.png create mode 100644 static/image/toy.png create mode 100644 tianjia.js create mode 100644 utils/audioUtil.js create mode 100644 utils/bluetooth.js create mode 100644 utils/request.js create mode 100644 utils/wsRequest.js diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..14ea590 --- /dev/null +++ b/.gitignore @@ -0,0 +1,14 @@ +# Windows +[Dd]esktop.ini +Thumbs.db +$RECYCLE.BIN/ + +# macOS +.DS_Store +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes + +# Node.js +node_modules/ diff --git a/api/index.js b/api/index.js new file mode 100644 index 0000000..8b31fc2 --- /dev/null +++ b/api/index.js @@ -0,0 +1,61 @@ +"use strict"; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __objRest = (source, exclude) => { + var target = {}; + for (var prop in source) + if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0) + target[prop] = source[prop]; + if (source != null && __getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(source)) { + if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop)) + target[prop] = source[prop]; + } + return target; +}; +var utils_request = require("../utils/request.js"); +var config_index = require("../config/index.js"); +const login = (data) => utils_request.request({ url: "/api/users/wx/login", method: "POST", data }); +const getAllRoles = () => utils_request.request({ url: "/api/roles/all", method: "GET" }); +const getChatExist = (data) => utils_request.request({ url: "/api/chat_records/exists", method: "GET", data }); +const createChat = (data) => utils_request.request({ baseUrl: config_index.base_url_other, url: "/chats", method: "POST", data }); +const getAllRolesMessageRecord = (data) => utils_request.request({ url: "/api/chat_records/all", method: "GET", data }); +const saveMessage = (data) => utils_request.request({ url: "/api/chat_records/", method: "POST", loading: false, data }); +const getHistoryMessage = (data) => utils_request.request({ url: "/api/chat_records/", method: "GET", data }); +const getListOfCommunity = (data) => utils_request.request({ url: "/api/post/", method: "GET", loading: false, data }); +const uploadImage = (file) => utils_request.requestFormData({ url: "/api/files/", method: "POST", file }); +const releaseContent = (data) => utils_request.request({ url: "/api/post/", method: "POST", data }); +const saveDraft = (data) => utils_request.request({ url: "/api/drafts/", method: "POST", data }); +const getDraftData = (data) => utils_request.request({ url: "/api/drafts/", method: "GET", data }); +const getCommunityDetail = (id) => utils_request.request({ url: `/api/post/${id}`, method: "GET" }); +const getCommentData = (id) => utils_request.request({ url: `/api/post/${id}/comments/`, method: "GET", loading: false }); +const submitLike = (id) => utils_request.request({ url: `/api/post/${id}/like`, method: "POST", loading: false }); +const cancelLike = (id) => utils_request.request({ url: `/api/post/${id}/like`, method: "DELETE", loading: false }); +const submitComment = (_a) => { + var _b = _a, { id } = _b, data = __objRest(_b, ["id"]); + return utils_request.request({ url: `/api/post/${id}/comments/`, method: "POST", loading: false, data }); +}; +const deleteComment = ({ id, commentId }) => utils_request.request({ url: `/api/post/${id}/comments/${commentId}`, method: "DELETE", loading: false }); +const saveAvatar = (data) => utils_request.request({ url: "/api/users/avatar_id", method: "PUT", data }); +const saveUserName = (data) => utils_request.request({ url: "/api/users/username", method: "PUT", data }); +exports.cancelLike = cancelLike; +exports.createChat = createChat; +exports.deleteComment = deleteComment; +exports.getAllRoles = getAllRoles; +exports.getAllRolesMessageRecord = getAllRolesMessageRecord; +exports.getChatExist = getChatExist; +exports.getCommentData = getCommentData; +exports.getCommunityDetail = getCommunityDetail; +exports.getDraftData = getDraftData; +exports.getHistoryMessage = getHistoryMessage; +exports.getListOfCommunity = getListOfCommunity; +exports.login = login; +exports.releaseContent = releaseContent; +exports.saveAvatar = saveAvatar; +exports.saveDraft = saveDraft; +exports.saveMessage = saveMessage; +exports.saveUserName = saveUserName; +exports.submitComment = submitComment; +exports.submitLike = submitLike; +exports.uploadImage = uploadImage; diff --git a/app.js b/app.js new file mode 100644 index 0000000..f798d75 --- /dev/null +++ b/app.js @@ -0,0 +1,46 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports[Symbol.toStringTag] = "Module"; +var common_vendor = require("./common/vendor.js"); +if (!Math) { + "./pages/cover/index.js"; + "./pages/login/index.js"; + "./pages/index/index.js"; + "./pages/chat/index.js"; + "./pages/chatOnline/index.js"; + "./pages/community/index.js"; + "./pages/community/release.js"; + "./pages/community/detail.js"; + "./pages/mine/index.js"; + "./pages/mine/aboutus.js"; + "./pages/mine/contactus.js"; + "./pages/call/index.js"; + "./pages/bluetooth/index.js"; + "./pages/bluetooth/device.js"; + "./pages/bluetooth/connect.js"; +} +const _sfc_main = { + onLaunch: function() { + console.log("App Launch"); + }, + onShow: function() { + console.log("App Show"); + }, + onHide: function() { + console.log("App Hide"); + }, + provide() { + return { + chatList: [] + }; + } +}; +var App = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__file", "C:/Users/bzm15/Desktop/ix/mini_web-develop/App.vue"]]); +function createApp() { + const app = common_vendor.createSSRApp(App); + return { + app + }; +} +createApp().app.mount("#app"); +exports.createApp = createApp; diff --git a/app.json b/app.json new file mode 100644 index 0000000..685f165 --- /dev/null +++ b/app.json @@ -0,0 +1,61 @@ +{ + "pages": [ + "pages/cover/index", + "pages/login/index", + "pages/index/index", + "pages/chat/index", + "pages/chatOnline/index", + "pages/community/index", + "pages/community/release", + "pages/community/detail", + "pages/mine/index", + "pages/mine/aboutus", + "pages/mine/contactus", + "pages/call/index", + "pages/bluetooth/index", + "pages/bluetooth/device", + "pages/bluetooth/connect" + ], + "window": { + "navigationBarTextStyle": "black", + "navigationBarTitleText": "uni-app", + "navigationBarBackgroundColor": "#F8F8F8", + "backgroundColor": "#F8F8F8", + "homeButton": false + }, + "tabBar": { + "color": "#999999", + "selectedColor": "#000000", + "backgroundColor": "#ffffff", + "borderStyle": "black", + "position": "bottom", + "list": [ + { + "pagePath": "pages/index/index", + "text": "首页", + "iconPath": "static/icon/ufo.png", + "selectedIconPath": "static/icon/ufo_active.png" + }, + { + "pagePath": "pages/chat/index", + "text": "聊天", + "iconPath": "static/icon/chat.png", + "selectedIconPath": "static/icon/chat_active.png" + }, + { + "pagePath": "pages/community/index", + "text": "社区", + "iconPath": "static/icon/community.png", + "selectedIconPath": "static/icon/community_active.png" + }, + { + "pagePath": "pages/mine/index", + "text": "我的", + "iconPath": "static/icon/mine.png", + "selectedIconPath": "static/icon/mine_active.png" + } + ] + }, + "permission": {}, + "usingComponents": {} +} \ No newline at end of file diff --git a/app.wxss b/app.wxss new file mode 100644 index 0000000..3893fae --- /dev/null +++ b/app.wxss @@ -0,0 +1,91 @@ + + /*每个页面公共css */ +@font-face { + font-family: "iconfont"; /* Project id 4506234 */ + src: url('data:font/woff2;base64,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') format('woff2'), + url('data:font/woff;base64,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') format('woff'), + url('data:font/ttf;base64,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') format('truetype'); +} +.iconfont { + font-family: "iconfont" !important; + font-size: 16px; + font-style: normal; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} +.icon-email-s:before { + content: "\e65e"; +} +.icon-xia:before { + content: "\e651"; +} +.icon-jia:before { + content: "\e623"; +} +.icon-loading:before { + content: "\e60c"; +} +.icon-goToSelect:before { + content: "\e60b"; +} +.icon-wifi1:before { + content: "\e609"; +} +.icon-lock:before { + content: "\e60a"; +} +.icon-like:before { + content: "\e85c"; +} +.icon-aixin:before { + content: "\e83f"; +} +.icon-shanchu:before { + content: "\e66d"; +} +.icon-caogaoxiang:before { + content: "\e650"; +} +.icon-shangchuantupian:before { + content: "\e615"; +} +.icon-zhuanliaotian:before { + content: "\e606"; +} +.icon-yangshengqi:before { + content: "\e608"; +} +.icon-guadianhua:before { + content: "\e605"; +} +.icon-dianji:before { + content: "\e87c"; +} +.icon-weibiaoti--:before { + content: "\e611"; +} +.icon-paperPlane:before { + content: "\e6c1"; +} +.icon-search:before { + content: "\e6c8"; +} +.icon-weixin:before { + content: "\e614"; +} +.icon-gou:before { + content: "\e610"; +} +.icon-yonghu1:before { + content: "\e607"; +} +.icon-yijianfankui:before { + content: "\e662"; +} +.icon-wifi:before { + content: "\e7e0"; +} +.icon-qun:before { + content: "\e64f"; +} +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;} \ No newline at end of file diff --git a/common/vendor.js b/common/vendor.js new file mode 100644 index 0000000..f494d57 --- /dev/null +++ b/common/vendor.js @@ -0,0 +1,9436 @@ +"use strict"; +var _export_sfc = (sfc, props) => { + const target = sfc.__vccOpts || sfc; + for (const [key, val] of props) { + target[key] = val; + } + return target; +}; +function makeMap(str, expectsLowerCase) { + const map2 = /* @__PURE__ */ Object.create(null); + const list = str.split(","); + for (let i = 0; i < list.length; i++) { + map2[list[i]] = true; + } + return expectsLowerCase ? (val) => !!map2[val.toLowerCase()] : (val) => !!map2[val]; +} +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$1(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$1(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]) => { + entries[`${key} =>`] = val2; + return entries; + }, {}) + }; + } else if (isSet(val)) { + return { + [`Set(${val.size})`]: [...val.values()] + }; + } else if (isObject$1(val) && !isArray$1(val) && !isPlainObject(val)) { + return String(val); + } + return val; +}; +const EMPTY_OBJ = Object.freeze({}); +const EMPTY_ARR = Object.freeze([]); +const NOOP = () => { +}; +const NO = () => false; +const onRE = /^on[^a-z]/; +const isOn = (key) => onRE.test(key); +const isModelListener = (key) => key.startsWith("onUpdate:"); +const extend$1 = Object.assign; +const remove = (arr, el) => { + const i = arr.indexOf(el); + if (i > -1) { + arr.splice(i, 1); + } +}; +const hasOwnProperty = Object.prototype.hasOwnProperty; +const hasOwn = (val, key) => hasOwnProperty.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$1 = (val) => val !== null && typeof val === "object"; +const isPromise = (val) => { + return isObject$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(",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) => str.charAt(0).toUpperCase() + str.slice(1)); +const toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``); +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 toNumber = (val) => { + const n2 = parseFloat(val); + return isNaN(n2) ? val : n2; +}; +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)); +} +function getBaseSystemInfo() { + return wx.getSystemInfoSync(); +} +const E = function() { +}; +E.prototype = { + on: function(name, callback, ctx) { + var e2 = this.e || (this.e = {}); + (e2[name] || (e2[name] = [])).push({ + fn: callback, + ctx + }); + return this; + }, + once: function(name, callback, ctx) { + var self = this; + function listener() { + self.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, callback) { + var e2 = this.e || (this.e = {}); + var evts = e2[name]; + var liveEvents = []; + if (evts && callback) { + for (var i = 0, len = evts.length; i < len; i++) { + if (evts[i].fn !== callback && evts[i].fn._ !== callback) + liveEvents.push(evts[i]); + } + } + liveEvents.length ? e2[name] = liveEvents : delete e2[name]; + return this; + } +}; +var E$1 = E; +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 isValid2 = false; + const types = isArray$1(type) ? type : [type]; + const expectedTypes = []; + for (let i = 0; i < types.length && !isValid2; i++) { + const { valid, expectedType } = assertType$1(value, types[i]); + expectedTypes.push(expectedType || ""); + isValid2 = valid; + } + if (!isValid2) { + 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$1(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$1(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$1(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); + } + }; +} +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; +} +const HOOK_SUCCESS = "success"; +const HOOK_FAIL = "fail"; +const HOOK_COMPLETE = "complete"; +const globalInterceptors = {}; +const scopedInterceptors = {}; +function wrapperHook(hook) { + return function(data) { + return hook(data) || data; + }; +} +function queue$1(hooks2, data) { + let promise = false; + for (let i = 0; i < hooks2.length; i++) { + const hook = hooks2[i]; + if (promise) { + promise = Promise.resolve(wrapperHook(hook)); + } else { + const res = hook(data); + if (isPromise(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 hooks2 = interceptors2[name]; + if (!isArray$1(hooks2)) { + return; + } + const oldCallback = options[name]; + options[name] = function callbackInterceptor(res) { + queue$1(hooks2, res).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$1(interceptor.invoke, options); + return res.then((options2) => { + return api(wrapperOptions(interceptor, options2), ...params); + }); + } else { + return api(wrapperOptions(interceptor, options), ...params); + } + } + return api(options, ...params); +} +function handlePromise(promise) { + return promise; +} +function formatApiArgs(args, options) { + const params = args[0]; + if (!options || !isPlainObject(options.formatArgs) && isPlainObject(params)) { + return; + } + const formatArgs = options.formatArgs; + const keys2 = Object.keys(formatArgs); + for (let i = 0; i < keys2.length; i++) { + const name = keys2[i]; + const formatterOrDefaultValue = formatArgs[name]; + if (isFunction$1(formatterOrDefaultValue)) { + const errMsg = formatterOrDefaultValue(args[0][name], params); + if (isString$1(errMsg)) { + return errMsg; + } + } else { + if (!hasOwn(params, name)) { + params[name] = formatterOrDefaultValue; + } + } + } +} +function beforeInvokeApi(name, args, protocol, options) { + { + validateProtocols(name, args, protocol); + } + if (options && options.beforeInvoke) { + const errMsg2 = options.beforeInvoke(args); + if (isString$1(errMsg2)) { + return errMsg2; + } + } + const errMsg = formatApiArgs(args, options); + if (errMsg) { + return errMsg; + } +} +function wrapperSyncApi(name, fn, protocol, options) { + return (...args) => { + const errMsg = beforeInvokeApi(name, args, protocol, options); + if (errMsg) { + throw new Error(errMsg); + } + return fn.apply(null, args); + }; +} +function defineSyncApi(name, fn, protocol, options) { + return wrapperSyncApi(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 hooks2 = interceptors2[name]; + const hook = interceptor[name]; + if (isArray$1(hooks2) && isFunction$1(hook)) { + remove(hooks2, 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(hooks2) { + const res = []; + for (let i = 0; i < hooks2.length; i++) { + if (res.indexOf(hooks2[i]) === -1) { + res.push(hooks2[i]); + } + } + return res; +} +const addInterceptor = defineSyncApi(API_ADD_INTERCEPTOR, (method, interceptor) => { + if (typeof method === "string" && 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 (typeof method === "string") { + 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 + } +]; +const API_EMIT = "$emit"; +const EmitProtocol = [ + { + name: "event", + type: String, + required: true + } +]; +const emitter = new E$1(); +const $on = defineSyncApi(API_ON, (name, callback) => { + emitter.on(name, callback); + return () => emitter.off(name, callback); +}, OnProtocol); +const $once = defineSyncApi(API_ONCE, (name, callback) => { + emitter.once(name, callback); + return () => emitter.off(name, callback); +}, OnceProtocol); +const $off = defineSyncApi(API_OFF, (name, callback) => { + if (!name) { + emitter.e = {}; + return; + } + if (!Array.isArray(name)) + name = [name]; + name.forEach((n2) => emitter.off(n2, callback)); +}, OffProtocol); +const $emit = defineSyncApi(API_EMIT, (name, ...args) => { + emitter.emit(name, ...args); +}, EmitProtocol); +let cid; +let cidErrMsg; +function normalizePushMessage(message) { + try { + return JSON.parse(message); + } catch (e2) { + } + return message; +} +function invokePushCallback(args) { + if (args.type === "clientId") { + cid = args.cid; + cidErrMsg = args.errMsg; + invokeGetPushCidCallbacks(cid, args.errMsg); + } else if (args.type === "pushMsg") { + onPushMessageCallbacks.forEach((callback) => { + callback({ type: "receive", data: normalizePushMessage(args.message) }); + }); + } 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; +} +function getPushCid(args) { + 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); + getPushCidCallbacks.push((cid2, errMsg) => { + let res; + if (cid2) { + res = { errMsg: "getPushCid:ok", cid: cid2 }; + hasSuccess && success(res); + } else { + res = { errMsg: "getPushCid:fail" + (errMsg ? " " + errMsg : "") }; + hasFail && fail(res); + } + hasComplete && complete(res); + }); + if (typeof cid !== "undefined") { + Promise.resolve().then(() => 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/; +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((resolve, reject) => { + invokeApi(name, api, extend$1({}, options, { + success: resolve, + 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(`\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F ${methodName} \u6682\u4E0D\u652F\u6301 ${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(`\u5FAE\u4FE1\u5C0F\u7A0B\u5E8F \u6682\u4E0D\u652F\u6301${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$1 = () => { + const app = getApp({ allowDefault: true }); + if (app && app.$vm) { + return app.$vm.$locale; + } + return wx.getSystemInfoSync().language || "zh-Hans"; +}; +const setLocale = (locale2) => { + const app = getApp(); + if (!app) { + return false; + } + const oldLocale = app.$vm.$locale; + if (oldLocale !== locale2) { + app.$vm.$locale = locale2; + onLocaleChangeCallbacks.forEach((fn) => fn({ locale: locale2 })); + return true; + } + return false; +}; +const onLocaleChangeCallbacks = []; +const onLocaleChange = (fn) => { + if (onLocaleChangeCallbacks.indexOf(fn) === -1) { + onLocaleChangeCallbacks.push(fn); + } +}; +if (typeof global !== "undefined") { + global.getLocale = getLocale$1; +} +const baseApis = { + $on, + $off, + $once, + $emit, + upx2px, + interceptors, + addInterceptor, + removeInterceptor, + onCreateVueApp, + invokeCreateVueAppHook, + getLocale: getLocale$1, + setLocale, + onLocaleChange, + getPushCid, + onPushMessage, + offPushMessage, + invokePushCallback +}; +function initUni(api, protocols2) { + 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, wx[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:\u670D\u52A1[" + service + "]\u4E0D\u5B58\u5728" + }; + isFunction$1(fail) && fail(res); + } + isFunction$1(complete) && complete(res); + }; +} +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.windowHeight - safeArea.bottom + }; + } +} +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; + }; +} +const getSystemInfo = { + returnValue: (fromRes, toRes) => { + addSafeAreaInsets(fromRes, toRes); + useDeviceId()(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 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.createSelectorQuery(); + const oldIn = query.in; + query.in = function newIn(component) { + return oldIn.call(this, initComponentMocks(component)); + }; + return query; +} +var shims = /* @__PURE__ */ Object.freeze({ + __proto__: null, + getProvider, + createSelectorQuery +}); +var protocols = /* @__PURE__ */ Object.freeze({ + __proto__: null, + redirectTo, + previewImage, + getSystemInfo, + getSystemInfoSync, + showActionSheet +}); +var index = initUni(shims, protocols); +const ON_SHOW$1 = "onShow"; +const ON_HIDE$1 = "onHide"; +const ON_LAUNCH$1 = "onLaunch"; +const ON_ERROR$1 = "onError"; +const ON_THEME_CHANGE$1 = "onThemeChange"; +const ON_PAGE_NOT_FOUND$1 = "onPageNotFound"; +const ON_UNHANDLE_REJECTION$1 = "onUnhandledRejection"; +const ON_LOAD$1 = "onLoad"; +const ON_READY$1 = "onReady"; +const ON_UNLOAD$1 = "onUnload"; +const ON_INIT = "onInit"; +const ON_SAVE_EXIT_STATE = "onSaveExitState"; +const ON_RESIZE$1 = "onResize"; +const ON_BACK_PRESS = "onBackPress"; +const ON_PAGE_SCROLL = "onPageScroll"; +const ON_TAB_ITEM_TAP$1 = "onTabItemTap"; +const ON_REACH_BOTTOM$1 = "onReachBottom"; +const ON_PULL_DOWN_REFRESH$1 = "onPullDownRefresh"; +const ON_SHARE_TIMELINE = "onShareTimeline"; +const ON_ADD_TO_FAVORITES$1 = "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 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(".")); +} +const PAGE_HOOKS = [ + ON_INIT, + ON_LOAD$1, + ON_SHOW$1, + ON_HIDE$1, + ON_UNLOAD$1, + ON_BACK_PRESS, + ON_PAGE_SCROLL, + ON_TAB_ITEM_TAP$1, + ON_REACH_BOTTOM$1, + ON_PULL_DOWN_REFRESH$1, + ON_SHARE_TIMELINE, + ON_SHARE_APP_MESSAGE, + ON_ADD_TO_FAVORITES$1, + 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$1, + ON_HIDE$1, + ON_LAUNCH$1, + ON_ERROR$1, + ON_THEME_CHANGE$1, + ON_PAGE_NOT_FOUND$1, + ON_UNHANDLE_REJECTION$1, + ON_INIT, + ON_LOAD$1, + ON_READY$1, + ON_UNLOAD$1, + ON_RESIZE$1, + ON_BACK_PRESS, + ON_PAGE_SCROLL, + ON_TAB_ITEM_TAP$1, + ON_REACH_BOTTOM$1, + ON_PULL_DOWN_REFRESH$1, + ON_SHARE_TIMELINE, + ON_ADD_TO_FAVORITES$1, + ON_SHARE_APP_MESSAGE, + 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 warn$1(msg, ...args) { + console.warn(`[Vue warn] ${msg}`, ...args); +} +let activeEffectScope; +class EffectScope { + constructor(detached = false) { + this.active = true; + this.effects = []; + this.cleanups = []; + if (!detached && activeEffectScope) { + this.parent = activeEffectScope; + this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1; + } + } + run(fn) { + if (this.active) { + const currentEffectScope = activeEffectScope; + try { + activeEffectScope = this; + return fn(); + } finally { + activeEffectScope = currentEffectScope; + } + } else { + warn$1(`cannot run an inactive effect scope.`); + } + } + on() { + activeEffectScope = this; + } + 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.parent && !fromParent) { + const last = this.parent.scopes.pop(); + if (last && last !== this) { + this.parent.scopes[this.index] = last; + last.index = this.index; + } + } + this.active = false; + } + } +} +function recordEffectScope(effect, scope = activeEffectScope) { + if (scope && scope.active) { + scope.effects.push(effect); + } +} +const createDep = (effects) => { + const dep = new Set(effects); + dep.w = 0; + dep.n = 0; + return dep; +}; +const wasTracked = (dep) => (dep.w & trackOpBit) > 0; +const newTracked = (dep) => (dep.n & trackOpBit) > 0; +const initDepMarkers = ({ deps }) => { + if (deps.length) { + for (let i = 0; i < deps.length; i++) { + deps[i].w |= trackOpBit; + } + } +}; +const finalizeDepMarkers = (effect) => { + const { deps } = effect; + if (deps.length) { + let ptr = 0; + for (let i = 0; i < deps.length; i++) { + const dep = deps[i]; + if (wasTracked(dep) && !newTracked(dep)) { + dep.delete(effect); + } else { + deps[ptr++] = dep; + } + dep.w &= ~trackOpBit; + dep.n &= ~trackOpBit; + } + deps.length = ptr; + } +}; +const targetMap = /* @__PURE__ */ new WeakMap(); +let effectTrackDepth = 0; +let trackOpBit = 1; +const maxMarkerBits = 30; +let activeEffect; +const ITERATE_KEY = Symbol("iterate"); +const MAP_KEY_ITERATE_KEY = Symbol("Map key iterate"); +class ReactiveEffect { + constructor(fn, scheduler = null, scope) { + this.fn = fn; + this.scheduler = scheduler; + this.active = true; + this.deps = []; + this.parent = void 0; + recordEffectScope(this, scope); + } + run() { + if (!this.active) { + return this.fn(); + } + let parent = activeEffect; + let lastShouldTrack = shouldTrack; + while (parent) { + if (parent === this) { + return; + } + parent = parent.parent; + } + try { + this.parent = activeEffect; + activeEffect = this; + shouldTrack = true; + trackOpBit = 1 << ++effectTrackDepth; + if (effectTrackDepth <= maxMarkerBits) { + initDepMarkers(this); + } else { + cleanupEffect(this); + } + return this.fn(); + } finally { + if (effectTrackDepth <= maxMarkerBits) { + finalizeDepMarkers(this); + } + trackOpBit = 1 << --effectTrackDepth; + activeEffect = this.parent; + shouldTrack = lastShouldTrack; + this.parent = void 0; + if (this.deferStop) { + this.stop(); + } + } + } + stop() { + if (activeEffect === this) { + this.deferStop = true; + } else if (this.active) { + cleanupEffect(this); + if (this.onStop) { + this.onStop(); + } + this.active = false; + } + } +} +function cleanupEffect(effect) { + const { deps } = effect; + if (deps.length) { + for (let i = 0; i < deps.length; i++) { + deps[i].delete(effect); + } + deps.length = 0; + } +} +let shouldTrack = true; +const trackStack = []; +function pauseTracking() { + trackStack.push(shouldTrack); + shouldTrack = false; +} +function resetTracking() { + const last = trackStack.pop(); + shouldTrack = last === void 0 ? true : last; +} +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()); + } + const eventInfo = { effect: activeEffect, target, type, key }; + trackEffects(dep, eventInfo); + } +} +function trackEffects(dep, debuggerEventExtraInfo) { + let shouldTrack2 = false; + if (effectTrackDepth <= maxMarkerBits) { + if (!newTracked(dep)) { + dep.n |= trackOpBit; + shouldTrack2 = !wasTracked(dep); + } + } else { + shouldTrack2 = !dep.has(activeEffect); + } + if (shouldTrack2) { + dep.add(activeEffect); + activeEffect.deps.push(dep); + if (activeEffect.onTrack) { + activeEffect.onTrack(Object.assign({ effect: activeEffect }, debuggerEventExtraInfo)); + } + } +} +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)) { + depsMap.forEach((dep, key2) => { + if (key2 === "length" || key2 >= newValue) { + 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; + } + } + const eventInfo = { target, type, key, newValue, oldValue, oldTarget }; + if (deps.length === 1) { + if (deps[0]) { + { + triggerEffects(deps[0], eventInfo); + } + } + } else { + const effects = []; + for (const dep of deps) { + if (dep) { + effects.push(...dep); + } + } + { + triggerEffects(createDep(effects), eventInfo); + } + } +} +function triggerEffects(dep, debuggerEventExtraInfo) { + for (const effect of isArray$1(dep) ? dep : [...dep]) { + if (effect !== activeEffect || effect.allowRecurse) { + if (effect.onTrigger) { + effect.onTrigger(extend$1({ effect }, debuggerEventExtraInfo)); + } + if (effect.scheduler) { + effect.scheduler(); + } else { + effect.run(); + } + } + } +} +const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`); +const builtInSymbols = new Set(/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol)); +const get$3 = /* @__PURE__ */ createGetter(); +const shallowGet = /* @__PURE__ */ createGetter(false, true); +const readonlyGet = /* @__PURE__ */ createGetter(true); +const shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true); +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(); + const res = toRaw(this)[key].apply(this, args); + resetTracking(); + return res; + }; + }); + return instrumentations; +} +function createGetter(isReadonly2 = false, shallow = false) { + return function get2(target, key, receiver) { + if (key === "__v_isReactive") { + return !isReadonly2; + } else if (key === "__v_isReadonly") { + return isReadonly2; + } else if (key === "__v_isShallow") { + return shallow; + } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) { + return target; + } + const targetIsArray = isArray$1(target); + if (!isReadonly2 && targetIsArray && hasOwn(arrayInstrumentations, key)) { + return Reflect.get(arrayInstrumentations, key, receiver); + } + const res = Reflect.get(target, key, receiver); + if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { + return res; + } + if (!isReadonly2) { + track(target, "get", key); + } + if (shallow) { + return res; + } + if (isRef(res)) { + const shouldUnwrap = !targetIsArray || !isIntegerKey(key); + return shouldUnwrap ? res.value : res; + } + if (isObject$1(res)) { + return isReadonly2 ? readonly(res) : reactive(res); + } + return res; + }; +} +const set$1$1 = /* @__PURE__ */ createSetter(); +const shallowSet = /* @__PURE__ */ createSetter(true); +function createSetter(shallow = false) { + return function set2(target, key, value, receiver) { + let oldValue = target[key]; + if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) { + return false; + } + if (!shallow && !isReadonly(value)) { + if (!isShallow(value)) { + value = toRaw(value); + oldValue = toRaw(oldValue); + } + if (!isArray$1(target) && isRef(oldValue) && !isRef(value)) { + 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; + }; +} +function 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; +} +function has(target, key) { + const result = Reflect.has(target, key); + if (!isSymbol(key) || !builtInSymbols.has(key)) { + track(target, "has", key); + } + return result; +} +function ownKeys(target) { + track(target, "iterate", isArray$1(target) ? "length" : ITERATE_KEY); + return Reflect.ownKeys(target); +} +const mutableHandlers = { + get: get$3, + set: set$1$1, + deleteProperty, + has, + ownKeys +}; +const readonlyHandlers = { + get: readonlyGet, + set(target, key) { + { + warn$1(`Set operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + }, + deleteProperty(target, key) { + { + warn$1(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + } +}; +const shallowReactiveHandlers = /* @__PURE__ */ extend$1({}, mutableHandlers, { + get: shallowGet, + set: shallowSet +}); +const shallowReadonlyHandlers = /* @__PURE__ */ extend$1({}, readonlyHandlers, { + get: shallowReadonlyGet +}); +const toShallow = (value) => value; +const getProto = (v) => Reflect.getPrototypeOf(v); +function get$1$1(target, key, isReadonly2 = false, isShallow2 = false) { + target = target["__v_raw"]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly2 && track(rawTarget, "get", key); + } + !isReadonly2 && 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$1(key, isReadonly2 = false) { + const target = this["__v_raw"]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly2 && track(rawTarget, "has", key); + } + !isReadonly2 && 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$2(value) { + value = toRaw(value); + const target = toRaw(this); + const proto2 = getProto(target); + const hadKey = proto2.has.call(target, value); + if (!hadKey) { + target.add(value); + trigger(target, "add", value, value); + } + return this; +} +function set$1$1$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 { + next() { + const { value, done } = innerIterator.next(); + return done ? { value, done } : { + value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), + done + }; + }, + [Symbol.iterator]() { + return this; + } + }; + }; +} +function createReadonlyMethod(type) { + return function(...args) { + { + const key = args[0] ? `on key "${args[0]}" ` : ``; + console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this)); + } + return type === "delete" ? false : this; + }; +} +function createInstrumentations() { + const mutableInstrumentations2 = { + get(key) { + return get$1$1(this, key); + }, + get size() { + return size(this); + }, + has: has$1, + add: add$2, + set: set$1$1$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, false) + }; + const shallowInstrumentations2 = { + get(key) { + return get$1$1(this, key, false, true); + }, + get size() { + return size(this); + }, + has: has$1, + add: add$2, + set: set$1$1$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, true) + }; + const readonlyInstrumentations2 = { + get(key) { + return get$1$1(this, key, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has$1.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$1$1(this, key, true, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has$1.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); + console.warn(`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$1(target)) { + { + console.warn(`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) { + def(value, "__v_skip", true); + return value; +} +const toReactive = (value) => isObject$1(value) ? reactive(value) : value; +const toReadonly = (value) => isObject$1(value) ? readonly(value) : value; +function trackRefValue(ref2) { + if (shouldTrack && activeEffect) { + ref2 = toRaw(ref2); + { + trackEffects(ref2.dep || (ref2.dep = createDep()), { + target: ref2, + type: "get", + key: "value" + }); + } + } +} +function triggerRefValue(ref2, newVal) { + ref2 = toRaw(ref2); + if (ref2.dep) { + { + triggerEffects(ref2.dep, { + target: ref2, + type: "set", + key: "value", + newValue: newVal + }); + } + } +} +function isRef(r) { + return !!(r && r.__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) { + newVal = this.__v_isShallow ? newVal : toRaw(newVal); + if (hasChanged(newVal, this._rawValue)) { + this._rawValue = newVal; + this._value = this.__v_isShallow ? newVal : toReactive(newVal); + triggerRefValue(this, 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); +} +function toRefs(object) { + if (!isProxy(object)) { + console.warn(`toRefs() expects a reactive object but received a plain one.`); + } + const ret = isArray$1(object) ? new Array(object.length) : {}; + for (const key in object) { + ret[key] = toRef(object, key); + } + return ret; +} +class ObjectRefImpl { + constructor(_object, _key, _defaultValue) { + this._object = _object; + this._key = _key; + this._defaultValue = _defaultValue; + this.__v_isRef = true; + } + get value() { + const val = this._object[this._key]; + return val === void 0 ? this._defaultValue : val; + } + set value(newVal) { + this._object[this._key] = newVal; + } +} +function toRef(object, key, defaultValue) { + const val = object[key]; + return isRef(val) ? val : new ObjectRefImpl(object, key, defaultValue); +} +class ComputedRefImpl { + constructor(getter, _setter, isReadonly2, isSSR) { + this._setter = _setter; + this.dep = void 0; + this.__v_isRef = true; + this._dirty = true; + this.effect = new ReactiveEffect(getter, () => { + if (!this._dirty) { + this._dirty = true; + triggerRefValue(this); + } + }); + this.effect.computed = this; + this.effect.active = this._cacheable = !isSSR; + this["__v_isReadonly"] = isReadonly2; + } + get value() { + const self = toRaw(this); + trackRefValue(self); + if (self._dirty || !self._cacheable) { + self._dirty = false; + self._value = self.effect.run(); + } + return self._value; + } + set value(newValue) { + this._setter(newValue); + } +} +function computed(getterOrOptions, debugOptions, isSSR = false) { + let getter; + let setter; + const onlyGetter = isFunction$1(getterOrOptions); + if (onlyGetter) { + getter = getterOrOptions; + setter = () => { + console.warn("Write operation failed: computed value is readonly"); + }; + } else { + getter = getterOrOptions.get; + setter = getterOrOptions.set; + } + const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR); + if (debugOptions && !isSSR) { + cRef.effect.onTrack = debugOptions.onTrack; + cRef.effect.onTrigger = debugOptions.onTrigger; + } + return cRef; +} +const stack = []; +function pushWarningContext(vnode) { + stack.push(vnode); +} +function popWarningContext() { + stack.pop(); +} +function warn$1$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.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 && 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 keys2 = Object.keys(props); + keys2.slice(0, 3).forEach((key) => { + res.push(...formatProp(key, props[key])); + }); + if (keys2.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://new-issue.vuejs.org/?repo=vuejs/core" +}; +function callWithErrorHandling(fn, instance, type, args) { + let res; + try { + res = args ? fn(...args) : fn(); + } catch (err) { + handleError(err, instance, type); + } + return res; +} +function callWithAsyncErrorHandling(fn, instance, type, args) { + if (isFunction$1(fn)) { + const res = callWithErrorHandling(fn, instance, type, args); + if (res && isPromise(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$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 pendingPreFlushCbs = []; +let activePreFlushCbs = null; +let preFlushIndex = 0; +const pendingPostFlushCbs = []; +let activePostFlushCbs = null; +let postFlushIndex = 0; +const resolvedPromise = /* @__PURE__ */ Promise.resolve(); +let currentFlushPromise = null; +let currentPreFlushParentJob = null; +const RECURSION_LIMIT = 100; +function nextTick(fn) { + const p = currentFlushPromise || resolvedPromise; + return fn ? p.then(this ? fn.bind(this) : fn) : p; +} +function findInsertionIndex(id) { + let start = flushIndex + 1; + let end = queue.length; + while (start < end) { + const middle = start + end >>> 1; + const middleJobId = getId(queue[middle]); + middleJobId < id ? start = middle + 1 : end = middle; + } + return start; +} +function queueJob(job) { + if ((!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && job !== currentPreFlushParentJob) { + 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 invalidateJob(job) { + const i = queue.indexOf(job); + if (i > flushIndex) { + queue.splice(i, 1); + } + return i; +} +function queueCb(cb, activeQueue, pendingQueue, index2) { + if (!isArray$1(cb)) { + if (!activeQueue || !activeQueue.includes(cb, cb.allowRecurse ? index2 + 1 : index2)) { + pendingQueue.push(cb); + } + } else { + pendingQueue.push(...cb); + } + queueFlush(); +} +function queuePreFlushCb(cb) { + queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); +} +function queuePostFlushCb(cb) { + queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); +} +function flushPreFlushCbs(seen, parentJob = null) { + if (pendingPreFlushCbs.length) { + currentPreFlushParentJob = parentJob; + activePreFlushCbs = [...new Set(pendingPreFlushCbs)]; + pendingPreFlushCbs.length = 0; + { + seen = seen || /* @__PURE__ */ new Map(); + } + for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { + if (checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex])) { + continue; + } + activePreFlushCbs[preFlushIndex](); + } + activePreFlushCbs = null; + preFlushIndex = 0; + currentPreFlushParentJob = null; + flushPreFlushCbs(seen, parentJob); + } +} +function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + const deduped = [...new Set(pendingPostFlushCbs)]; + pendingPostFlushCbs.length = 0; + if (activePostFlushCbs) { + activePostFlushCbs.push(...deduped); + return; + } + activePostFlushCbs = deduped; + { + seen = seen || /* @__PURE__ */ new Map(); + } + activePostFlushCbs.sort((a, b) => getId(a) - getId(b)); + 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; +function flushJobs(seen) { + isFlushPending = false; + isFlushing = true; + { + seen = seen || /* @__PURE__ */ new Map(); + } + flushPreFlushCbs(seen); + queue.sort((a, b) => getId(a) - getId(b)); + 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 || pendingPreFlushCbs.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); + warn$1$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.`); + return true; + } else { + seen.set(fn, count + 1); + } + } +} +function emit(event, ...args) { +} +function devtoolsComponentEmit(component, event, params) { + emit("component:emit", component.appContext.app, component, event, params); +} +function emit$1(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$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 isValid2 = validator(...rawArgs); + if (!isValid2) { + warn$1$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) => a.trim()); + } else if (number) { + args = rawArgs.map(toNumber); + } + } + { + devtoolsComponentEmit(instance, event, args); + } + { + const lowerCaseEvent = event.toLowerCase(); + if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) { + warn$1$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)] || 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$1(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) { + cache.set(comp, null); + return null; + } + if (isArray$1(raw)) { + raw.forEach((key) => normalized[key] = null); + } else { + extend$1(normalized, raw); + } + 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; +} +function provide(key, value) { + if (!currentInstance) { + { + warn$1$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) { + const provides = instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides; + if (provides && key in provides) { + return provides[key]; + } else if (arguments.length > 1) { + return treatDefaultAsFactory && isFunction$1(defaultValue) ? defaultValue.call(instance.proxy) : defaultValue; + } else { + warn$1$1(`injection "${String(key)}" not found.`); + } + } else { + warn$1$1(`inject() can only be used inside setup() or functional components.`); + } +} +const INITIAL_WATCHER_VALUE = {}; +function watch(source, cb, options) { + if (!isFunction$1(cb)) { + warn$1$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, onTrack, onTrigger } = EMPTY_OBJ) { + if (!cb) { + if (immediate !== void 0) { + warn$1$1(`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`); + } + if (deep !== void 0) { + warn$1$1(`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`); + } + } + const warnInvalidSource = (s) => { + warn$1$1(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`); + }; + const instance = currentInstance; + let getter; + let forceTrigger = false; + let isMultiSource = false; + if (isRef(source)) { + getter = () => source.value; + forceTrigger = isShallow(source); + } else if (isReactive(source)) { + getter = () => source; + deep = true; + } else if (isArray$1(source)) { + isMultiSource = true; + forceTrigger = source.some(isReactive); + getter = () => source.map((s) => { + if (isRef(s)) { + return s.value; + } else if (isReactive(s)) { + return traverse(s); + } else if (isFunction$1(s)) { + return callWithErrorHandling(s, instance, 2); + } else { + warnInvalidSource(s); + } + }); + } else if (isFunction$1(source)) { + if (cb) { + getter = () => callWithErrorHandling(source, instance, 2); + } else { + getter = () => { + if (instance && instance.isUnmounted) { + return; + } + 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 = effect.onStop = () => { + callWithErrorHandling(fn, instance, 4); + }; + }; + let oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE; + const job = () => { + if (!effect.active) { + return; + } + if (cb) { + const newValue = effect.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, + oldValue === INITIAL_WATCHER_VALUE ? void 0 : oldValue, + onCleanup + ]); + oldValue = newValue; + } + } else { + effect.run(); + } + }; + job.allowRecurse = !!cb; + let scheduler; + if (flush === "sync") { + scheduler = job; + } else if (flush === "post") { + scheduler = () => queuePostRenderEffect(job, instance && instance.suspense); + } else { + scheduler = () => { + if (!instance || instance.isMounted) { + queuePreFlushCb(job); + } else { + job(); + } + }; + } + const effect = new ReactiveEffect(getter, scheduler); + { + effect.onTrack = onTrack; + effect.onTrigger = onTrigger; + } + if (cb) { + if (immediate) { + job(); + } else { + oldValue = effect.run(); + } + } else if (flush === "post") { + queuePostRenderEffect(effect.run.bind(effect), instance && instance.suspense); + } else { + effect.run(); + } + return () => { + effect.stop(); + if (instance && instance.scope) { + remove(instance.scope.effects, effect); + } + }; +} +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 cur = currentInstance; + setCurrentInstance(this); + const res = doWatch(getter, cb.bind(publicThis), options); + if (cur) { + setCurrentInstance(cur); + } else { + unsetCurrentInstance(); + } + 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, seen) { + if (!isObject$1(value) || value["__v_skip"]) { + return value; + } + seen = seen || /* @__PURE__ */ new Set(); + if (seen.has(value)) { + return value; + } + seen.add(value); + if (isRef(value)) { + traverse(value.value, seen); + } else if (isArray$1(value)) { + for (let i = 0; i < value.length; i++) { + traverse(value[i], seen); + } + } else if (isSet(value) || isMap(value)) { + value.forEach((v) => { + traverse(v, seen); + }); + } else if (isPlainObject(value)) { + for (const key in value) { + traverse(value[key], seen); + } + } + return value; +} +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); + onUnmounted(() => { + remove(keepAliveRoot[type], injected); + }, target); +} +function injectHook(type, hook, target = currentInstance, prepend = false) { + if (target) { + if (isRootHook(type)) { + target = target.root; + } + const hooks2 = target[type] || (target[type] = []); + const wrappedHook = hook.__weh || (hook.__weh = (...args) => { + if (target.isUnmounted) { + return; + } + pauseTracking(); + setCurrentInstance(target); + const res = callWithAsyncErrorHandling(hook, target, type, args); + unsetCurrentInstance(); + resetTracking(); + return res; + }); + if (prepend) { + hooks2.unshift(wrappedHook); + } else { + hooks2.push(wrappedHook); + } + return wrappedHook; + } else { + const apiName = toHandlerKey((ErrorTypeStrings[type] || type.replace(/^on/, "")).replace(/ hook$/, "")); + warn$1$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) => (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, hook, 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); +} +function createDuplicateChecker() { + const cache = /* @__PURE__ */ Object.create(null); + return (type, key) => { + if (cache[key]) { + warn$1$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 { + data: dataOptions, + computed: computedOptions, + methods, + watch: watchOptions, + provide: provideOptions, + inject: injectOptions, + created, + beforeMount, + mounted, + beforeUpdate, + updated, + activated, + deactivated, + beforeDestroy, + beforeUnmount, + destroyed, + unmounted, + render, + renderTracked, + renderTriggered, + errorCaptured, + serverPrefetch, + expose, + inheritAttrs, + components, + directives, + filters + } = options; + const checkDuplicateProperties = createDuplicateChecker(); + { + const [propsOptions] = instance.propsOptions; + if (propsOptions) { + for (const key in propsOptions) { + checkDuplicateProperties("Props", key); + } + } + } + if (injectOptions) { + resolveInjections(injectOptions, ctx, checkDuplicateProperties, instance.appContext.config.unwrapInjectedRef); + } + 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$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$1(`The data option must be a function. Plain object usage is no longer supported.`); + } + const data = dataOptions.call(publicThis, publicThis); + if (isPromise(data)) { + warn$1$1(`data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + .`); + } + if (!isObject$1(data)) { + warn$1$1(`data() should return an object.`); + } else { + instance.data = reactive(data); + { + for (const key in data) { + checkDuplicateProperties("Data", key); + if (key[0] !== "$" && 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$1(`Computed property "${key}" has no getter.`); + } + const set2 = !isFunction$1(opt) && isFunction$1(opt.set) ? opt.set.bind(publicThis) : () => { + warn$1$1(`Write operation failed: computed property "${key}" is readonly.`); + }; + const c = computed$1({ + get: get2, + set: set2 + }); + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => c.value, + set: (v) => c.value = v + }); + { + checkDuplicateProperties("Computed", key); + } + } + } + if (watchOptions) { + for (const key in watchOptions) { + createWatcher(watchOptions[key], ctx, publicThis, key); + } + } + { + if (provideOptions) { + const provides = isFunction$1(provideOptions) ? provideOptions.call(publicThis) : provideOptions; + Reflect.ownKeys(provides).forEach((key) => { + provide(key, provides[key]); + }); + } + } + { + 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, unwrapRef = false) { + if (isArray$1(injectOptions)) { + injectOptions = normalizeInject(injectOptions); + } + for (const key in injectOptions) { + const opt = injectOptions[key]; + let injected; + if (isObject$1(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)) { + if (unwrapRef) { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => injected.value, + set: (v) => injected.value = v + }); + } else { + { + warn$1$1(`injected property "${key}" is a ref and will be auto-unwrapped and no longer needs \`.value\` in the next minor release. To opt-in to the new behavior now, set \`app.config.unwrapInjectedRef = true\` (this config is temporary and will not be needed in the future.)`); + } + ctx[key] = injected; + } + } else { + ctx[key] = injected; + } + { + checkDuplicateProperties("Inject", key); + } + } +} +function callHook$1(hook, instance, type) { + callWithAsyncErrorHandling(isArray$1(hook) ? hook.map((h) => h.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$1(`Invalid watch handler specified by key "${raw}"`, handler); + } + } else if (isFunction$1(raw)) { + watch(getter, raw.bind(publicThis)); + } else if (isObject$1(raw)) { + if (isArray$1(raw)) { + raw.forEach((r) => createWatcher(r, 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$1(`Invalid watch handler specified by key "${raw.handler}"`, handler); + } + } + } else { + warn$1$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((m) => mergeOptions(resolved, m, optionMergeStrategies, true)); + } + mergeOptions(resolved, base, optionMergeStrategies); + } + cache.set(base, resolved); + return resolved; +} +function mergeOptions(to2, from2, strats, asMixin = false) { + const { mixins, extends: extendsOptions } = from2; + if (extendsOptions) { + mergeOptions(to2, extendsOptions, strats, true); + } + if (mixins) { + mixins.forEach((m) => mergeOptions(to2, m, strats, true)); + } + for (const key in from2) { + if (asMixin && key === "expose") { + warn$1$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]; + to2[key] = strat ? strat(to2[key], from2[key]) : from2[key]; + } + } + return to2; +} +const internalOptionMergeStrats = { + data: mergeDataFn, + props: mergeObjectOptions, + emits: mergeObjectOptions, + methods: mergeObjectOptions, + computed: mergeObjectOptions, + 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, + components: mergeObjectOptions, + directives: mergeObjectOptions, + watch: mergeWatchOptions, + provide: mergeDataFn, + inject: mergeInject +}; +function mergeDataFn(to2, from2) { + if (!from2) { + return to2; + } + if (!to2) { + return from2; + } + return function mergedDataFn() { + return extend$1(isFunction$1(to2) ? to2.call(this, this) : to2, isFunction$1(from2) ? from2.call(this, this) : from2); + }; +} +function mergeInject(to2, from2) { + return mergeObjectOptions(normalizeInject(to2), normalizeInject(from2)); +} +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(to2, from2) { + return to2 ? [...new Set([].concat(to2, from2))] : from2; +} +function mergeObjectOptions(to2, from2) { + return to2 ? extend$1(extend$1(/* @__PURE__ */ Object.create(null), to2), from2) : from2; +} +function mergeWatchOptions(to2, from2) { + if (!to2) + return from2; + if (!from2) + return to2; + const merged = extend$1(/* @__PURE__ */ Object.create(null), to2); + for (const key in from2) { + merged[key] = mergeAsArray$1(to2[key], from2[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 updateProps(instance, rawProps, rawPrevProps, optimized) { + const { props, attrs, vnode: { patchFlag } } = instance; + const rawCurrentProps = toRaw(props); + const [options] = instance.propsOptions; + let hasAttrsChanged = false; + if (!(instance.type.__hmrId || instance.parent && instance.parent.type.__hmrId) && (optimized || 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(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 || !hasOwn(rawProps, key) && ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) { + if (options) { + if (rawPrevProps && (rawPrevProps[key] !== void 0 || rawPrevProps[kebabKey] !== void 0)) { + props[key] = resolvePropValue(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(options, rawCurrentProps, key, castValues[key], instance, !hasOwn(castValues, key)); + } + } + return hasAttrsChanged; +} +function resolvePropValue(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 && isFunction$1(defaultValue)) { + const { propsDefaults } = instance; + if (key in propsDefaults) { + value = propsDefaults[key]; + } else { + setCurrentInstance(instance); + value = propsDefaults[key] = defaultValue.call(null, props); + unsetCurrentInstance(); + } + } else { + value = defaultValue; + } + } + if (opt[0]) { + if (isAbsent && !hasDefault) { + value = false; + } else if (opt[1] && (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, keys2] = normalizePropsOptions(raw2, appContext, true); + extend$1(normalized, props); + if (keys2) + needCastKeys.push(...keys2); + }; + 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) { + 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$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$1(raw)) { + warn$1$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 } : opt; + if (prop) { + const booleanIndex = getTypeIndex(Boolean, prop.type); + const stringIndex = getTypeIndex(String, prop.type); + prop[0] = booleanIndex > -1; + prop[1] = stringIndex < 0 || booleanIndex < stringIndex; + if (booleanIndex > -1 || hasOwn(prop, "default")) { + needCastKeys.push(normalizedKey); + } + } + } + } + } + const res = [normalized, needCastKeys]; + cache.set(comp, res); + return res; +} +function validatePropName(key) { + if (key[0] !== "$") { + return true; + } else { + warn$1$1(`Invalid prop name: "${key}" is a reserved property.`); + } + return false; +} +function getType(ctor) { + const match = ctor && ctor.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ctor === null ? "null" : ""; +} +function isSameType(a, b) { + return getType(a) === getType(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, !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key))); + } +} +function validateProp(name, value, prop, isAbsent) { + const { type, required, validator } = prop; + if (required && isAbsent) { + warn$1$1('Missing required prop: "' + name + '"'); + return; + } + if (value == null && !prop.required) { + return; + } + if (type != null && type !== true) { + let isValid2 = false; + const types = isArray$1(type) ? type : [type]; + const expectedTypes = []; + for (let i = 0; i < types.length && !isValid2; i++) { + const { valid, expectedType } = assertType(value, types[i]); + expectedTypes.push(expectedType || ""); + isValid2 = valid; + } + if (!isValid2) { + warn$1$1(getInvalidTypeMessage(name, value, expectedTypes)); + return; + } + } + if (validator && !validator(value)) { + warn$1$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(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$1(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) { + 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"); +} +function validateDirectiveName(name) { + if (isBuiltInDirective(name)) { + warn$1$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 = 0; +function createAppAPI(render, hydrate) { + return function createApp2(rootComponent, rootProps = null) { + if (!isFunction$1(rootComponent)) { + rootComponent = Object.assign({}, rootComponent); + } + if (rootProps != null && !isObject$1(rootProps)) { + warn$1$1(`root props passed to app.mount() must be an object.`); + rootProps = null; + } + const context = createAppContext(); + const installedPlugins = /* @__PURE__ */ new Set(); + const app = context.app = { + _uid: uid++, + _component: rootComponent, + _props: rootProps, + _container: null, + _context: context, + _instance: null, + version, + get config() { + return context.config; + }, + set config(v) { + { + warn$1$1(`app.config cannot be replaced. Modify individual options instead.`); + } + }, + use(plugin2, ...options) { + if (installedPlugins.has(plugin2)) { + warn$1$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$1(`A plugin must either be a function or an object with an "install" function.`); + } + return app; + }, + mixin(mixin) { + { + if (!context.mixins.includes(mixin)) { + context.mixins.push(mixin); + } else { + warn$1$1("Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "")); + } + } + return app; + }, + component(name, component) { + { + validateComponentName(name, context.config); + } + if (!component) { + return context.components[name]; + } + if (context.components[name]) { + warn$1$1(`Component "${name}" has already been registered in target app.`); + } + context.components[name] = component; + return app; + }, + directive(name, directive) { + { + validateDirectiveName(name); + } + if (!directive) { + return context.directives[name]; + } + if (context.directives[name]) { + warn$1$1(`Directive "${name}" has already been registered in target app.`); + } + context.directives[name] = directive; + return app; + }, + mount() { + }, + unmount() { + }, + provide(key, value) { + if (key in context.provides) { + warn$1$1(`App already provides property with key "${String(key)}". It will be overwritten with the new value.`); + } + context.provides[key] = value; + return app; + } + }; + return app; + }; +} +const queuePostRenderEffect = queuePostFlushCb; +function isVNode(value) { + return value ? value.__v_isVNode === true : false; +} +const getPublicInstance = (i) => { + if (!i) + return null; + if (isStatefulComponent(i)) + return getExposeProxy(i) || i.proxy; + return getPublicInstance(i.parent); +}; +const publicPropertiesMap = /* @__PURE__ */ extend$1(/* @__PURE__ */ Object.create(null), { + $: (i) => i, + $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) => () => queueJob(i.update), + $watch: (i) => instanceWatch.bind(i) +}); +const PublicInstanceProxyHandlers = { + get({ _: instance }, key) { + const { ctx, setupState, data, props, accessCache, type, appContext } = instance; + if (key === "__isVue") { + return true; + } + if (setupState !== EMPTY_OBJ && setupState.__isScriptSetup && hasOwn(setupState, key)) { + return setupState[key]; + } + 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 (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + accessCache[key] = 1; + return setupState[key]; + } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + accessCache[key] = 2; + return data[key]; + } else if ((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); + } + return publicGetter(instance); + } else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) { + return cssModule; + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 4; + return ctx[key]; + } else if (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) { + { + return globalProperties[key]; + } + } else if (currentRenderingInstance && (!isString$1(key) || key.indexOf("__v") !== 0)) { + if (data !== EMPTY_OBJ && (key[0] === "$" || key[0] === "_") && hasOwn(data, key)) { + warn$1$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$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 (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + setupState[key] = value; + return true; + } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + data[key] = value; + return true; + } else if (hasOwn(instance.props, key)) { + warn$1$1(`Attempting to mutate prop "${key}". Props are readonly.`, instance); + return false; + } + if (key[0] === "$" && key.slice(1) in instance) { + warn$1$1(`Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`, instance); + 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) || setupState !== EMPTY_OBJ && hasOwn(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$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), + 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 (key[0] === "$" || key[0] === "_") { + warn$1$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 + }); + } + }); +} +const emptyAppContext = createAppContext(); +let uid$1 = 0; +function createComponentInstance(vnode, parent, suspense) { + const type = vnode.type; + const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext; + const instance = { + uid: uid$1++, + vnode, + type, + parent, + appContext, + root: null, + next: null, + subTree: null, + effect: null, + update: null, + scope: new EffectScope(true), + render: null, + proxy: null, + exposed: null, + exposeProxy: null, + withProxy: null, + provides: parent ? parent.provides : Object.create(appContext.provides), + accessCache: null, + renderCache: [], + components: null, + directives: null, + propsOptions: normalizePropsOptions(type, appContext), + emitsOptions: normalizeEmitsOptions(type, appContext), + emit: null, + emitted: null, + propsDefaults: EMPTY_OBJ, + inheritAttrs: type.inheritAttrs, + ctx: EMPTY_OBJ, + data: EMPTY_OBJ, + props: EMPTY_OBJ, + attrs: EMPTY_OBJ, + slots: EMPTY_OBJ, + refs: EMPTY_OBJ, + setupState: EMPTY_OBJ, + setupContext: null, + suspense, + suspenseId: suspense ? suspense.pendingId : 0, + asyncDep: null, + asyncResolved: false, + 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 + }; + { + instance.ctx = createDevRenderContext(instance); + } + instance.root = parent ? parent.root : instance; + instance.emit = emit$1.bind(null, instance); + if (vnode.ce) { + vnode.ce(instance); + } + return instance; +} +let currentInstance = null; +const getCurrentInstance = () => currentInstance || currentRenderingInstance; +const setCurrentInstance = (instance) => { + currentInstance = instance; + instance.scope.on(); +}; +const unsetCurrentInstance = () => { + currentInstance && currentInstance.scope.off(); + currentInstance = null; +}; +const isBuiltInTag = /* @__PURE__ */ makeMap("slot,component"); +function validateComponentName(name, config) { + const appIsNativeTag = config.isNativeTag || NO; + if (isBuiltInTag(name) || appIsNativeTag(name)) { + warn$1$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) { + isInSSRComponentSetup = isSSR; + const { props } = instance.vnode; + const isStateful = isStatefulComponent(instance); + initProps$1(instance, props, isStateful, isSSR); + const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0; + isInSSRComponentSetup = 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$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; + setCurrentInstance(instance); + pauseTracking(); + const setupResult = callWithErrorHandling(setup, instance, 0, [shallowReadonly(instance.props), setupContext]); + resetTracking(); + unsetCurrentInstance(); + if (isPromise(setupResult)) { + setupResult.then(unsetCurrentInstance, unsetCurrentInstance); + { + warn$1$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$1(setupResult)) { + if (isVNode(setupResult)) { + warn$1$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$1(`setup() should return an object. Received: ${setupResult === null ? "null" : typeof setupResult}`); + } + finishComponentSetup(instance, isSSR); +} +let compile; +const isRuntimeOnly = () => !compile; +function finishComponentSetup(instance, isSSR, skipOptions) { + const Component2 = instance.type; + if (!instance.render) { + instance.render = Component2.render || NOOP; + } + { + setCurrentInstance(instance); + pauseTracking(); + applyOptions$1(instance); + resetTracking(); + unsetCurrentInstance(); + } + if (!Component2.render && instance.render === NOOP && !isSSR) { + if (Component2.template) { + warn$1$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$1(`Component is missing template or render function.`); + } + } +} +function createAttrsProxy(instance) { + return new Proxy(instance.attrs, { + get(target, key) { + track(instance, "get", "$attrs"); + return target[key]; + }, + set() { + warn$1$1(`setupContext.attrs is readonly.`); + return false; + }, + deleteProperty() { + warn$1$1(`setupContext.attrs is readonly.`); + return false; + } + }); +} +function createSetupContext(instance) { + const expose = (exposed) => { + if (instance.exposed) { + warn$1$1(`expose() should be called only once per setup().`); + } + instance.exposed = exposed || {}; + }; + let attrs; + { + return Object.freeze({ + get attrs() { + return attrs || (attrs = createAttrsProxy(instance)); + }, + get slots() { + return shallowReadonly(instance.slots); + }, + 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]; + } + })); + } +} +const classifyRE = /(?:^|[-_])(\w)/g; +const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, ""); +function getComponentName(Component2) { + return isFunction$1(Component2) ? Component2.displayName || Component2.name : 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$1 = (getterOrOptions, debugOptions) => { + return computed(getterOrOptions, debugOptions, isInSSRComponentSetup); +}; +const version = "3.2.33"; +function unwrapper(target) { + return unref(target); +} +const ARRAYTYPE = "[object Array]"; +const OBJECTTYPE = "[object Object]"; +function diff$1(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$1(instance, fn) { + const ctx = instance.ctx; + if (!ctx.__next_tick_pending && !hasComponentEffect(instance)) { + return nextTick(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((resolve) => { + _resolve = resolve; + }); +} +function clone$2(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$2(src[i], seen); + } + } else { + copy = {}; + seen.set(src, copy); + for (const name in src) { + if (hasOwn(src, name)) { + copy[name] = clone$2(src[name], seen); + } + } + } + return copy; + } + if (type !== "symbol") { + return src; + } +} +function deepCopy(src) { + return clone$2(src, typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : /* @__PURE__ */ new Map()); +} +function getMPInstanceData(instance, keys2) { + const data = instance.data; + const ret = /* @__PURE__ */ Object.create(null); + keys2.forEach((key) => { + ret[key] = data[key]; + }); + return ret; +} +function patch(instance, data, oldData) { + if (!data) { + return; + } + data = deepCopy(data); + const ctx = instance.ctx; + const mpType = ctx.mpType; + if (mpType === "page" || mpType === "component") { + data.r0 = 1; + const mpInstance = ctx.$scope; + const keys2 = Object.keys(data); + const diffData = diff$1(data, oldData || getMPInstanceData(mpInstance, keys2)); + if (Object.keys(diffData).length) { + ctx.__next_tick_pending = true; + mpInstance.setData(diffData, () => { + ctx.__next_tick_pending = false; + flushCallbacks(instance); + }); + flushPreFlushCbs(void 0, instance.update); + } else { + flushCallbacks(instance); + } + } +} +function initAppConfig(appConfig) { + appConfig.globalProperties.$nextTick = function $nextTick(fn) { + return nextTick$1(this.$, fn); + }; +} +function onApplyOptions(options, instance, publicThis) { + instance.appContext.config.globalProperties.$applyOptions(options, instance, publicThis); + const computedOptions = options.computed; + if (computedOptions) { + const keys2 = Object.keys(computedOptions); + if (keys2.length) { + const ctx = instance.ctx; + if (!ctx.$computedKeys) { + ctx.$computedKeys = []; + } + ctx.$computedKeys.push(...keys2); + } + } + delete instance.ctx.$onApplyOptions; +} +function setRef$1(instance, isUnmount = false) { + const { setupState, $templateRefs, ctx: { $scope, $mpPlatform } } = instance; + if ($mpPlatform === "mp-alipay") { + return; + } + if (!$templateRefs || !$scope) { + return; + } + if (isUnmount) { + return $templateRefs.forEach((templateRef) => setTemplateRef(templateRef, null, setupState)); + } + const doSet = () => { + const mpComponents = $scope.selectAllComponents(".r").concat($scope.selectAllComponents(".r-i-f")); + $templateRefs.forEach((templateRef) => setTemplateRef(templateRef, findComponentPublicInstance(mpComponents, templateRef.i), setupState)); + }; + if ($scope._$setRef) { + $scope._$setRef(doSet); + } else { + nextTick$1(instance, doSet); + } +} +function findComponentPublicInstance(mpComponents, id) { + const mpInstance = mpComponents.find((com) => com && (com.properties || com.props).uI === id); + if (mpInstance) { + const vm = mpInstance.$vm; + return getExposeProxy(vm.$) || vm; + } + return null; +} +function setTemplateRef({ r, f: f2 }, refValue, setupState) { + if (isFunction$1(r)) { + r(refValue, {}); + } else { + const _isString = isString$1(r); + const _isRef = isRef(r); + if (_isString || _isRef) { + if (f2) { + if (!_isRef) { + return; + } + if (!isArray$1(r.value)) { + r.value = []; + } + const existing = r.value; + if (existing.indexOf(refValue) === -1) { + existing.push(refValue); + if (!refValue) { + return; + } + onBeforeUnmount(() => remove(existing, refValue), refValue.$); + } + } else if (_isString) { + if (hasOwn(setupState, r)) { + setupState[r] = refValue; + } + } else if (isRef(r)) { + r.value = refValue; + } else { + warnRef(r); + } + } else { + warnRef(r); + } + } +} +function warnRef(ref2) { + warn$1$1("Invalid template ref type:", ref2, `(${typeof ref2})`); +} +var MPType; +(function(MPType2) { + MPType2["APP"] = "app"; + MPType2["PAGE"] = "page"; + MPType2["COMPONENT"] = "component"; +})(MPType || (MPType = {})); +const queuePostRenderEffect$1 = 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); + } + setupComponent(instance); + { + if (options.parentComponent && instance.proxy) { + options.parentComponent.ctx.$children.push(getExposeProxy(instance) || instance.proxy); + } + } + setupRenderEffect(instance); + { + popWarningContext(); + } + 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.$templateRefs = []; + 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); + } + } 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 keys2 = Object.keys(fallthroughAttrs2).filter((key) => key !== "class" && key !== "style"); + if (!keys2.length) { + return; + } + if (propsOptions && keys2.some(isModelListener)) { + keys2.forEach((key) => { + if (!isModelListener(key) || !(key.slice(9) in propsOptions)) { + props[key] = fallthroughAttrs2[key]; + } + }); + } else { + keys2.forEach((key) => props[key] = fallthroughAttrs2[key]); + } + } +} +const updateComponentPreRender = (instance) => { + pauseTracking(); + flushPreFlushCbs(void 0, instance.update); + 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 = `${path}[${index2}]`; + if (typeof oldScopedSlotData === "undefined" || typeof oldScopedSlotData[index2] === "undefined") { + diffData[diffPath] = data; + } else { + const diffScopedSlotData = diff$1(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, update }, allowed) { + effect.allowRecurse = update.allowRecurse = allowed; +} +function setupRenderEffect(instance) { + const updateScopedSlots = componentUpdateScopedSlotsFn.bind(instance); + instance.$updateScopedSlots = () => nextTick(() => queueJob(updateScopedSlots)); + const componentUpdateFn = () => { + if (!instance.isMounted) { + onBeforeUnmount(() => { + setRef$1(instance, true); + }, instance); + patch(instance, renderComponentRoot(instance)); + } else { + const { bu, u } = instance; + toggleRecurse(instance, false); + updateComponentPreRender(instance); + if (bu) { + invokeArrayFns$1(bu); + } + toggleRecurse(instance, true); + patch(instance, renderComponentRoot(instance)); + if (u) { + queuePostRenderEffect$1(u); + } + } + }; + const effect = instance.effect = new ReactiveEffect(componentUpdateFn, () => queueJob(instance.update), instance.scope); + const update = instance.update = effect.run.bind(effect); + update.id = instance.uid; + toggleRecurse(instance, true); + { + effect.onTrack = instance.rtc ? (e2) => invokeArrayFns$1(instance.rtc, e2) : void 0; + effect.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); + } + scope.stop(); + if (update) { + update.active = false; + } + if (um) { + queuePostRenderEffect$1(um); + } + queuePostRenderEffect$1(() => { + instance.isUnmounted = true; + }); +} +const oldCreateApp = createAppAPI(); +function createVueApp(rootComponent, rootProps = null) { + const app = oldCreateApp(rootComponent, rootProps); + const appContext = app._context; + initAppConfig(appContext.config); + const createVNode = (initialVNode) => { + initialVNode.appContext = appContext; + initialVNode.shapeFlag = 6; + return initialVNode; + }; + const createComponent2 = function createComponent3(initialVNode, options) { + return mountComponent(createVNode(initialVNode), options); + }; + const destroyComponent = function destroyComponent2(component) { + return component && unmountComponent(component.$); + }; + app.mount = function mount() { + rootComponent.render = NOOP; + const instance = mountComponent(createVNode({ type: rootComponent }), { + mpType: MPType.APP, + mpInstance: null, + parentComponent: null, + slots: [], + props: null + }); + instance.$app = app; + instance.$createComponent = createComponent2; + instance.$destroyComponent = destroyComponent; + appContext.$appInstance = instance; + return instance; + }; + app.unmount = function unmount() { + warn$1$1(`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) { + return; + } + Object.keys(options).forEach((name) => { + if (name.indexOf("on") === 0) { + const hooks2 = options[name]; + if (isArray$1(hooks2)) { + hooks2.forEach((hook) => injectLifecycleHook(name, hook, publicThis, instance)); + } else { + injectLifecycleHook(name, hooks2, publicThis, instance); + } + } + }); +} +function applyOptions$2(options, instance, publicThis) { + initHooks$1(options, instance, publicThis); +} +function set$2(target, key, val) { + return target[key] = val; +} +function errorHandler(err, instance, info) { + if (!instance) { + throw err; + } + const app = getApp(); + if (!app || !app.$vm) { + throw err; + } + { + app.$vm.$callHook(ON_ERROR$1, err, info); + } +} +function mergeAsArray(to2, from2) { + return to2 ? [...new Set([].concat(to2, from2))] : from2; +} +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(c) { + return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2); + }).join("")); +} +function getCurrentUserInfo() { + const token2 = index.getStorageSync("uni_id_token") || ""; + const tokenArr = token2.split("."); + if (!token2 || tokenArr.length !== 3) { + return { + uid: null, + role: [], + permission: [], + tokenExpired: 0 + }; + } + let userInfo; + try { + userInfo = JSON.parse(b64DecodeUnicode(tokenArr[1])); + } catch (error) { + throw new Error("\u83B7\u53D6\u5F53\u524D\u7528\u6237\u4FE1\u606F\u51FA\u9519\uFF0C\u8BE6\u7EC6\u9519\u8BEF\u4FE1\u606F\u4E3A\uFF1A" + 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; + if (isFunction$1(app._component.onError)) { + appConfig.errorHandler = errorHandler; + } + initOptionMergeStrategies(appConfig.optionMergeStrategies); + const globalProperties = appConfig.globalProperties; + { + uniIdMixin(globalProperties); + } + { + globalProperties.$set = set$2; + globalProperties.$applyOptions = applyOptions$2; + } + { + index.invokeCreateVueAppHook(app); + } +} +const propsCaches = /* @__PURE__ */ Object.create(null); +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") { + 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") && (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 (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 ? eventTarget.dataset.eventsync === "true" : false : false; + if (bubbles.includes(e2.type) && !eventSync) { + setTimeout(invoke); + } else { + const res = invoke(); + if (e2.type === "input" && isPromise(res)) { + return; + } + return res; + } + }; + invoker.value = initialValue; + return invoker; +} +const bubbles = [ + "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$1({}, 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$1$1(`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$1(source)) { + if (source[Symbol.iterator]) { + ret = Array.from(source, (item, i) => renderItem(item, i, i)); + } else { + const keys2 = Object.keys(source); + ret = new Array(keys2.length); + for (let i = 0, l = keys2.length; i < l; i++) { + const key = keys2[i]; + ret[i] = renderItem(source[key], key, i); + } + } + } else { + ret = []; + } + return ret; +} +const o = (value, key) => vOn(value, key); +const f = (source, renderItem) => vFor(source, renderItem); +const e = (target, ...sources) => extend$1(target, ...sources); +const n = (value) => normalizeClass(value); +const t = (val) => toDisplayString(val); +function createApp$1(rootComponent, rootProps = null) { + rootComponent && (rootComponent.mpType = "app"); + return createVueApp(rootComponent, rootProps).use(plugin); +} +const createSSRApp = createApp$1; +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_LOAD = "onLoad"; +const ON_READY = "onReady"; +const ON_UNLOAD = "onUnload"; +const ON_RESIZE = "onResize"; +const ON_TAB_ITEM_TAP = "onTabItemTap"; +const ON_REACH_BOTTOM = "onReachBottom"; +const ON_PULL_DOWN_REFRESH = "onPullDownRefresh"; +const ON_ADD_TO_FAVORITES = "onAddToFavorites"; +const customizeRE = /:/g; +function customizeEvent(str) { + return camelize(str.replace(customizeRE, "-")); +} +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; + }; +} +const encode = encodeURIComponent; +function stringifyQuery(obj, encodeStr = encode) { + 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 MINI_PROGRAM_PAGE_RUNTIME_HOOKS = /* @__PURE__ */ (() => { + return { + onPageScroll: 1, + onShareAppMessage: 1 << 1, + onShareTimeline: 1 << 2 + }; +})(); +const eventChannels = {}; +const eventChannelStack = []; +function getEventChannel(id) { + if (id) { + const eventChannel = eventChannels[id]; + delete eventChannels[id]; + return eventChannel; + } + return eventChannelStack.shift(); +} +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 hooks2 = this.$[name]; + if (hooks2 && hooks2.length) { + return true; + } + return false; +} +function callHook(name, args) { + if (name === "mounted") { + callHook.call(this, "bm"); + this.$.isMounted = true; + name = "m"; + } else if (name === "onLoad" && args && args.__id__) { + this.__eventChannel__ = getEventChannel(args.__id__); + delete args.__id__; + } + const hooks2 = this.$[name]; + return hooks2 && invokeArrayFns(hooks2, 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 +]; +function findHooks(vueOptions, hooks2 = /* @__PURE__ */ new Set()) { + if (vueOptions) { + Object.keys(vueOptions).forEach((name) => { + if (name.indexOf("on") === 0 && isFunction$1(vueOptions[name])) { + hooks2.add(name); + } + }); + { + const { extends: extendsOptions, mixins } = vueOptions; + if (mixins) { + mixins.forEach((mixin) => findHooks(mixin, hooks2)); + } + if (extendsOptions) { + findHooks(extendsOptions, hooks2); + } + } + } + return hooks2; +} +function initHook$1(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, hooks2, excludes = EXCLUDE_HOOKS) { + hooks2.forEach((hook) => initHook$1(mpOptions, hook, excludes)); +} +function initUnknownHooks(mpOptions, vueOptions, excludes = EXCLUDE_HOOKS) { + findHooks(vueOptions).forEach((hook) => initHook$1(mpOptions, hook, excludes)); +} +function initRuntimeHooks(mpOptions, runtimeHooks) { + if (!runtimeHooks) { + return; + } + const hooks2 = Object.keys(MINI_PROGRAM_PAGE_RUNTIME_HOOKS); + hooks2.forEach((hook) => { + if (runtimeHooks & MINI_PROGRAM_PAGE_RUNTIME_HOOKS[hook]) { + initHook$1(mpOptions, hook, []); + } + }); +} +const findMixinRuntimeHooks = /* @__PURE__ */ once(() => { + const runtimeHooks = []; + const app = getApp({ allowDefault: true }); + if (app && app.$vm && app.$vm.$) { + const mixins = app.$vm.$.appContext.mixins; + if (isArray$1(mixins)) { + const hooks2 = Object.keys(MINI_PROGRAM_PAGE_RUNTIME_HOOKS); + mixins.forEach((mixin) => { + hooks2.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, + onLaunch(options) { + this.$vm = instance; + const ctx = internalInstance.ctx; + if (this.$vm && ctx.$scope) { + return; + } + initBaseInstance(internalInstance, { + mpType: "app", + mpInstance: this, + slots: [] + }); + ctx.globalData = this.globalData; + instance.$callHook(ON_LAUNCH, options); + } + }; + initLocale(instance); + const vueOptions = instance.$.type; + initHooks(appOptions, HOOKS); + initUnknownHooks(appOptions, vueOptions); + { + const methods = vueOptions.methods; + methods && extend$1(appOptions, methods); + } + if (parseAppOptions) { + parseAppOptions.parse(appOptions); + } + return appOptions; +} +function initCreateApp(parseAppOptions) { + return function createApp2(vm) { + return App(parseApp(vm, parseAppOptions)); + }; +} +function initCreateSubpackageApp(parseAppOptions) { + return function createApp2(vm) { + const appOptions = parseApp(vm, parseAppOptions); + const app = getApp({ + allowDefault: true + }); + 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 locale2 = ref(wx.getSystemInfoSync().language || "zh-Hans"); + Object.defineProperty(appVm, "$locale", { + get() { + return locale2.value; + }, + set(v) { + locale2.value = v; + } + }); +} +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]; + } + }); +} +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 builtInProps = [ + "eO", + "uR", + "uRIF", + "uI", + "uT", + "uP", + "uS" +]; +function initDefaultProps(isBehavior = false) { + const properties = {}; + if (!isBehavior) { + builtInProps.forEach((name) => { + properties[name] = { + type: null, + value: "" + }; + }); + properties.uS = { + type: null, + value: [], + observer: function(newVal) { + const $slots = /* @__PURE__ */ Object.create(null); + newVal && newVal.forEach((slotName) => { + $slots[slotName] = true; + }); + this.setData({ + $slots + }); + } + }; + } + return properties; +} +function initProps(mpComponentOptions) { + if (!mpComponentOptions.properties) { + mpComponentOptions.properties = {}; + } + extend$1(mpComponentOptions.properties, initDefaultProps()); +} +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(properties.uP)) || {}; +} +function findPagePropsData(properties) { + const propsData = {}; + if (isPlainObject(properties)) { + Object.keys(properties).forEach((name) => { + if (builtInProps.indexOf(name) === -1) { + propsData[name] = properties[name]; + } + }); + } + return propsData; +} +function initData(_) { + return {}; +} +function initPropsObserver(componentOptions) { + const observe = function observe2() { + const up = this.properties.uP; + if (!up) { + return; + } + if (this.$vm) { + updateComponentProps(up, this.$vm.$); + } else if (this.properties.uT === "m") { + updateMiniProgramComponentProperties(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, false); + 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("value"); + } else { + vueProps.name = { + type: String, + default: "" + }; + vueProps.value = { + 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, + addGlobalClass: true, + pureDataPattern: /^uP$/ + }; + if (vueOptions.options) { + extend$1(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); + 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 = getApp().$vm.$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, parseAppOptions), vm); + }; +} +const MPPage = Page; +const MPComponent = Component; +function initTriggerEvent(mpInstance) { + const oldTriggerEvent = mpInstance.triggerEvent; + mpInstance.triggerEvent = function(event, ...args) { + return oldTriggerEvent.apply(mpInstance, [customizeEvent(event), ...args]); + }; +} +function initHook(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) { + initHook(ON_LOAD, options); + return MPPage(options); +}; +Component = function(options) { + initHook("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 || {}, + parentComponent: relationOptions.parent && relationOptions.parent.$, + onBeforeSetup(instance, options) { + initRefs(instance, mpInstance); + initMocks(instance, mpInstance, mocks2); + initComponentInstance(instance, options); + } + }); + }, + 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, + mocks, + isPage, + initRelation, + handleLink, + initLifetimes +}); +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$1); +const onLoad = /* @__PURE__ */ createHook(ON_LOAD$1); +//! moment.js +//! version : 2.30.1 +//! authors : Tim Wood, Iskren Chernev, Moment.js contributors +//! license : MIT +//! momentjs.com +var hookCallback; +function hooks() { + return hookCallback.apply(null, arguments); +} +function setHookCallback(callback) { + hookCallback = callback; +} +function isArray(input) { + return input instanceof Array || Object.prototype.toString.call(input) === "[object Array]"; +} +function isObject(input) { + return input != null && Object.prototype.toString.call(input) === "[object Object]"; +} +function hasOwnProp(a, b) { + return Object.prototype.hasOwnProperty.call(a, b); +} +function isObjectEmpty(obj) { + if (Object.getOwnPropertyNames) { + return Object.getOwnPropertyNames(obj).length === 0; + } else { + var k; + for (k in obj) { + if (hasOwnProp(obj, k)) { + return false; + } + } + return true; + } +} +function isUndefined(input) { + return input === void 0; +} +function isNumber(input) { + return typeof input === "number" || Object.prototype.toString.call(input) === "[object Number]"; +} +function isDate(input) { + return input instanceof Date || Object.prototype.toString.call(input) === "[object Date]"; +} +function map(arr, fn) { + var res = [], i, arrLen = arr.length; + for (i = 0; i < arrLen; ++i) { + res.push(fn(arr[i], i)); + } + return res; +} +function extend(a, b) { + for (var i in b) { + if (hasOwnProp(b, i)) { + a[i] = b[i]; + } + } + if (hasOwnProp(b, "toString")) { + a.toString = b.toString; + } + if (hasOwnProp(b, "valueOf")) { + a.valueOf = b.valueOf; + } + return a; +} +function createUTC(input, format2, locale2, strict) { + return createLocalOrUTC(input, format2, locale2, strict, true).utc(); +} +function defaultParsingFlags() { + return { + empty: false, + unusedTokens: [], + unusedInput: [], + overflow: -2, + charsLeftOver: 0, + nullInput: false, + invalidEra: null, + invalidMonth: null, + invalidFormat: false, + userInvalidated: false, + iso: false, + parsedDateParts: [], + era: null, + meridiem: null, + rfc2822: false, + weekdayMismatch: false + }; +} +function getParsingFlags(m) { + if (m._pf == null) { + m._pf = defaultParsingFlags(); + } + return m._pf; +} +var some; +if (Array.prototype.some) { + some = Array.prototype.some; +} else { + some = function(fun) { + var t2 = Object(this), len = t2.length >>> 0, i; + for (i = 0; i < len; i++) { + if (i in t2 && fun.call(this, t2[i], i, t2)) { + return true; + } + } + return false; + }; +} +function isValid(m) { + var flags = null, parsedParts = false, isNowValid = m._d && !isNaN(m._d.getTime()); + if (isNowValid) { + flags = getParsingFlags(m); + parsedParts = some.call(flags.parsedDateParts, function(i) { + return i != null; + }); + isNowValid = flags.overflow < 0 && !flags.empty && !flags.invalidEra && !flags.invalidMonth && !flags.invalidWeekday && !flags.weekdayMismatch && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated && (!flags.meridiem || flags.meridiem && parsedParts); + if (m._strict) { + isNowValid = isNowValid && flags.charsLeftOver === 0 && flags.unusedTokens.length === 0 && flags.bigHour === void 0; + } + } + if (Object.isFrozen == null || !Object.isFrozen(m)) { + m._isValid = isNowValid; + } else { + return isNowValid; + } + return m._isValid; +} +function createInvalid(flags) { + var m = createUTC(NaN); + if (flags != null) { + extend(getParsingFlags(m), flags); + } else { + getParsingFlags(m).userInvalidated = true; + } + return m; +} +var momentProperties = hooks.momentProperties = [], updateInProgress = false; +function copyConfig(to2, from2) { + var i, prop, val, momentPropertiesLen = momentProperties.length; + if (!isUndefined(from2._isAMomentObject)) { + to2._isAMomentObject = from2._isAMomentObject; + } + if (!isUndefined(from2._i)) { + to2._i = from2._i; + } + if (!isUndefined(from2._f)) { + to2._f = from2._f; + } + if (!isUndefined(from2._l)) { + to2._l = from2._l; + } + if (!isUndefined(from2._strict)) { + to2._strict = from2._strict; + } + if (!isUndefined(from2._tzm)) { + to2._tzm = from2._tzm; + } + if (!isUndefined(from2._isUTC)) { + to2._isUTC = from2._isUTC; + } + if (!isUndefined(from2._offset)) { + to2._offset = from2._offset; + } + if (!isUndefined(from2._pf)) { + to2._pf = getParsingFlags(from2); + } + if (!isUndefined(from2._locale)) { + to2._locale = from2._locale; + } + if (momentPropertiesLen > 0) { + for (i = 0; i < momentPropertiesLen; i++) { + prop = momentProperties[i]; + val = from2[prop]; + if (!isUndefined(val)) { + to2[prop] = val; + } + } + } + return to2; +} +function Moment(config) { + copyConfig(this, config); + this._d = new Date(config._d != null ? config._d.getTime() : NaN); + if (!this.isValid()) { + this._d = new Date(NaN); + } + if (updateInProgress === false) { + updateInProgress = true; + hooks.updateOffset(this); + updateInProgress = false; + } +} +function isMoment(obj) { + return obj instanceof Moment || obj != null && obj._isAMomentObject != null; +} +function warn(msg) { + if (hooks.suppressDeprecationWarnings === false && typeof console !== "undefined" && console.warn) { + console.warn("Deprecation warning: " + msg); + } +} +function deprecate(msg, fn) { + var firstTime = true; + return extend(function() { + if (hooks.deprecationHandler != null) { + hooks.deprecationHandler(null, msg); + } + if (firstTime) { + var args = [], arg, i, key, argLen = arguments.length; + for (i = 0; i < argLen; i++) { + arg = ""; + if (typeof arguments[i] === "object") { + arg += "\n[" + i + "] "; + for (key in arguments[0]) { + if (hasOwnProp(arguments[0], key)) { + arg += key + ": " + arguments[0][key] + ", "; + } + } + arg = arg.slice(0, -2); + } else { + arg = arguments[i]; + } + args.push(arg); + } + warn(msg + "\nArguments: " + Array.prototype.slice.call(args).join("") + "\n" + new Error().stack); + firstTime = false; + } + return fn.apply(this, arguments); + }, fn); +} +var deprecations = {}; +function deprecateSimple(name, msg) { + if (hooks.deprecationHandler != null) { + hooks.deprecationHandler(name, msg); + } + if (!deprecations[name]) { + warn(msg); + deprecations[name] = true; + } +} +hooks.suppressDeprecationWarnings = false; +hooks.deprecationHandler = null; +function isFunction(input) { + return typeof Function !== "undefined" && input instanceof Function || Object.prototype.toString.call(input) === "[object Function]"; +} +function set(config) { + var prop, i; + for (i in config) { + if (hasOwnProp(config, i)) { + prop = config[i]; + if (isFunction(prop)) { + this[i] = prop; + } else { + this["_" + i] = prop; + } + } + } + this._config = config; + this._dayOfMonthOrdinalParseLenient = new RegExp((this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) + "|" + /\d{1,2}/.source); +} +function mergeConfigs(parentConfig, childConfig) { + var res = extend({}, parentConfig), prop; + for (prop in childConfig) { + if (hasOwnProp(childConfig, prop)) { + if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) { + res[prop] = {}; + extend(res[prop], parentConfig[prop]); + extend(res[prop], childConfig[prop]); + } else if (childConfig[prop] != null) { + res[prop] = childConfig[prop]; + } else { + delete res[prop]; + } + } + } + for (prop in parentConfig) { + if (hasOwnProp(parentConfig, prop) && !hasOwnProp(childConfig, prop) && isObject(parentConfig[prop])) { + res[prop] = extend({}, res[prop]); + } + } + return res; +} +function Locale(config) { + if (config != null) { + this.set(config); + } +} +var keys; +if (Object.keys) { + keys = Object.keys; +} else { + keys = function(obj) { + var i, res = []; + for (i in obj) { + if (hasOwnProp(obj, i)) { + res.push(i); + } + } + return res; + }; +} +var defaultCalendar = { + sameDay: "[Today at] LT", + nextDay: "[Tomorrow at] LT", + nextWeek: "dddd [at] LT", + lastDay: "[Yesterday at] LT", + lastWeek: "[Last] dddd [at] LT", + sameElse: "L" +}; +function calendar(key, mom, now2) { + var output = this._calendar[key] || this._calendar["sameElse"]; + return isFunction(output) ? output.call(mom, now2) : output; +} +function zeroFill(number, targetLength, forceSign) { + var absNumber = "" + Math.abs(number), zerosToFill = targetLength - absNumber.length, sign2 = number >= 0; + return (sign2 ? forceSign ? "+" : "" : "-") + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber; +} +var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|N{1,5}|YYYYYY|YYYYY|YYYY|YY|y{2,4}|yo?|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g, localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g, formatFunctions = {}, formatTokenFunctions = {}; +function addFormatToken(token2, padded, ordinal2, callback) { + var func = callback; + if (typeof callback === "string") { + func = function() { + return this[callback](); + }; + } + if (token2) { + formatTokenFunctions[token2] = func; + } + if (padded) { + formatTokenFunctions[padded[0]] = function() { + return zeroFill(func.apply(this, arguments), padded[1], padded[2]); + }; + } + if (ordinal2) { + formatTokenFunctions[ordinal2] = function() { + return this.localeData().ordinal(func.apply(this, arguments), token2); + }; + } +} +function removeFormattingTokens(input) { + if (input.match(/\[[\s\S]/)) { + return input.replace(/^\[|\]$/g, ""); + } + return input.replace(/\\/g, ""); +} +function makeFormatFunction(format2) { + var array = format2.match(formattingTokens), i, length; + for (i = 0, length = array.length; i < length; i++) { + if (formatTokenFunctions[array[i]]) { + array[i] = formatTokenFunctions[array[i]]; + } else { + array[i] = removeFormattingTokens(array[i]); + } + } + return function(mom) { + var output = "", i2; + for (i2 = 0; i2 < length; i2++) { + output += isFunction(array[i2]) ? array[i2].call(mom, format2) : array[i2]; + } + return output; + }; +} +function formatMoment(m, format2) { + if (!m.isValid()) { + return m.localeData().invalidDate(); + } + format2 = expandFormat(format2, m.localeData()); + formatFunctions[format2] = formatFunctions[format2] || makeFormatFunction(format2); + return formatFunctions[format2](m); +} +function expandFormat(format2, locale2) { + var i = 5; + function replaceLongDateFormatTokens(input) { + return locale2.longDateFormat(input) || input; + } + localFormattingTokens.lastIndex = 0; + while (i >= 0 && localFormattingTokens.test(format2)) { + format2 = format2.replace(localFormattingTokens, replaceLongDateFormatTokens); + localFormattingTokens.lastIndex = 0; + i -= 1; + } + return format2; +} +var defaultLongDateFormat = { + LTS: "h:mm:ss A", + LT: "h:mm A", + L: "MM/DD/YYYY", + LL: "MMMM D, YYYY", + LLL: "MMMM D, YYYY h:mm A", + LLLL: "dddd, MMMM D, YYYY h:mm A" +}; +function longDateFormat(key) { + var format2 = this._longDateFormat[key], formatUpper = this._longDateFormat[key.toUpperCase()]; + if (format2 || !formatUpper) { + return format2; + } + this._longDateFormat[key] = formatUpper.match(formattingTokens).map(function(tok) { + if (tok === "MMMM" || tok === "MM" || tok === "DD" || tok === "dddd") { + return tok.slice(1); + } + return tok; + }).join(""); + return this._longDateFormat[key]; +} +var defaultInvalidDate = "Invalid date"; +function invalidDate() { + return this._invalidDate; +} +var defaultOrdinal = "%d", defaultDayOfMonthOrdinalParse = /\d{1,2}/; +function ordinal(number) { + return this._ordinal.replace("%d", number); +} +var defaultRelativeTime = { + future: "in %s", + past: "%s ago", + s: "a few seconds", + ss: "%d seconds", + m: "a minute", + mm: "%d minutes", + h: "an hour", + hh: "%d hours", + d: "a day", + dd: "%d days", + w: "a week", + ww: "%d weeks", + M: "a month", + MM: "%d months", + y: "a year", + yy: "%d years" +}; +function relativeTime(number, withoutSuffix, string, isFuture) { + var output = this._relativeTime[string]; + return isFunction(output) ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number); +} +function pastFuture(diff2, output) { + var format2 = this._relativeTime[diff2 > 0 ? "future" : "past"]; + return isFunction(format2) ? format2(output) : format2.replace(/%s/i, output); +} +var aliases = { + D: "date", + dates: "date", + date: "date", + d: "day", + days: "day", + day: "day", + e: "weekday", + weekdays: "weekday", + weekday: "weekday", + E: "isoWeekday", + isoweekdays: "isoWeekday", + isoweekday: "isoWeekday", + DDD: "dayOfYear", + dayofyears: "dayOfYear", + dayofyear: "dayOfYear", + h: "hour", + hours: "hour", + hour: "hour", + ms: "millisecond", + milliseconds: "millisecond", + millisecond: "millisecond", + m: "minute", + minutes: "minute", + minute: "minute", + M: "month", + months: "month", + month: "month", + Q: "quarter", + quarters: "quarter", + quarter: "quarter", + s: "second", + seconds: "second", + second: "second", + gg: "weekYear", + weekyears: "weekYear", + weekyear: "weekYear", + GG: "isoWeekYear", + isoweekyears: "isoWeekYear", + isoweekyear: "isoWeekYear", + w: "week", + weeks: "week", + week: "week", + W: "isoWeek", + isoweeks: "isoWeek", + isoweek: "isoWeek", + y: "year", + years: "year", + year: "year" +}; +function normalizeUnits(units) { + return typeof units === "string" ? aliases[units] || aliases[units.toLowerCase()] : void 0; +} +function normalizeObjectUnits(inputObject) { + var normalizedInput = {}, normalizedProp, prop; + for (prop in inputObject) { + if (hasOwnProp(inputObject, prop)) { + normalizedProp = normalizeUnits(prop); + if (normalizedProp) { + normalizedInput[normalizedProp] = inputObject[prop]; + } + } + } + return normalizedInput; +} +var priorities = { + date: 9, + day: 11, + weekday: 11, + isoWeekday: 11, + dayOfYear: 4, + hour: 13, + millisecond: 16, + minute: 14, + month: 8, + quarter: 7, + second: 15, + weekYear: 1, + isoWeekYear: 1, + week: 5, + isoWeek: 5, + year: 1 +}; +function getPrioritizedUnits(unitsObj) { + var units = [], u; + for (u in unitsObj) { + if (hasOwnProp(unitsObj, u)) { + units.push({ unit: u, priority: priorities[u] }); + } + } + units.sort(function(a, b) { + return a.priority - b.priority; + }); + return units; +} +var match1 = /\d/, match2 = /\d\d/, match3 = /\d{3}/, match4 = /\d{4}/, match6 = /[+-]?\d{6}/, match1to2 = /\d\d?/, match3to4 = /\d\d\d\d?/, match5to6 = /\d\d\d\d\d\d?/, match1to3 = /\d{1,3}/, match1to4 = /\d{1,4}/, match1to6 = /[+-]?\d{1,6}/, matchUnsigned = /\d+/, matchSigned = /[+-]?\d+/, matchOffset = /Z|[+-]\d\d:?\d\d/gi, matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi, matchTimestamp = /[+-]?\d+(\.\d{1,3})?/, matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i, match1to2NoLeadingZero = /^[1-9]\d?/, match1to2HasZero = /^([1-9]\d|\d)/, regexes; +regexes = {}; +function addRegexToken(token2, regex, strictRegex) { + regexes[token2] = isFunction(regex) ? regex : function(isStrict, localeData2) { + return isStrict && strictRegex ? strictRegex : regex; + }; +} +function getParseRegexForToken(token2, config) { + if (!hasOwnProp(regexes, token2)) { + return new RegExp(unescapeFormat(token2)); + } + return regexes[token2](config._strict, config._locale); +} +function unescapeFormat(s) { + return regexEscape(s.replace("\\", "").replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function(matched, p1, p2, p3, p4) { + return p1 || p2 || p3 || p4; + })); +} +function regexEscape(s) { + return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"); +} +function absFloor(number) { + if (number < 0) { + return Math.ceil(number) || 0; + } else { + return Math.floor(number); + } +} +function toInt(argumentForCoercion) { + var coercedNumber = +argumentForCoercion, value = 0; + if (coercedNumber !== 0 && isFinite(coercedNumber)) { + value = absFloor(coercedNumber); + } + return value; +} +var tokens = {}; +function addParseToken(token2, callback) { + var i, func = callback, tokenLen; + if (typeof token2 === "string") { + token2 = [token2]; + } + if (isNumber(callback)) { + func = function(input, array) { + array[callback] = toInt(input); + }; + } + tokenLen = token2.length; + for (i = 0; i < tokenLen; i++) { + tokens[token2[i]] = func; + } +} +function addWeekParseToken(token2, callback) { + addParseToken(token2, function(input, array, config, token3) { + config._w = config._w || {}; + callback(input, config._w, config, token3); + }); +} +function addTimeToArrayFromToken(token2, input, config) { + if (input != null && hasOwnProp(tokens, token2)) { + tokens[token2](input, config._a, config, token2); + } +} +function isLeapYear(year) { + return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0; +} +var YEAR = 0, MONTH = 1, DATE = 2, HOUR = 3, MINUTE = 4, SECOND = 5, MILLISECOND = 6, WEEK = 7, WEEKDAY = 8; +addFormatToken("Y", 0, 0, function() { + var y = this.year(); + return y <= 9999 ? zeroFill(y, 4) : "+" + y; +}); +addFormatToken(0, ["YY", 2], 0, function() { + return this.year() % 100; +}); +addFormatToken(0, ["YYYY", 4], 0, "year"); +addFormatToken(0, ["YYYYY", 5], 0, "year"); +addFormatToken(0, ["YYYYYY", 6, true], 0, "year"); +addRegexToken("Y", matchSigned); +addRegexToken("YY", match1to2, match2); +addRegexToken("YYYY", match1to4, match4); +addRegexToken("YYYYY", match1to6, match6); +addRegexToken("YYYYYY", match1to6, match6); +addParseToken(["YYYYY", "YYYYYY"], YEAR); +addParseToken("YYYY", function(input, array) { + array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input); +}); +addParseToken("YY", function(input, array) { + array[YEAR] = hooks.parseTwoDigitYear(input); +}); +addParseToken("Y", function(input, array) { + array[YEAR] = parseInt(input, 10); +}); +function daysInYear(year) { + return isLeapYear(year) ? 366 : 365; +} +hooks.parseTwoDigitYear = function(input) { + return toInt(input) + (toInt(input) > 68 ? 1900 : 2e3); +}; +var getSetYear = makeGetSet("FullYear", true); +function getIsLeapYear() { + return isLeapYear(this.year()); +} +function makeGetSet(unit, keepTime) { + return function(value) { + if (value != null) { + set$1(this, unit, value); + hooks.updateOffset(this, keepTime); + return this; + } else { + return get(this, unit); + } + }; +} +function get(mom, unit) { + if (!mom.isValid()) { + return NaN; + } + var d = mom._d, isUTC = mom._isUTC; + switch (unit) { + case "Milliseconds": + return isUTC ? d.getUTCMilliseconds() : d.getMilliseconds(); + case "Seconds": + return isUTC ? d.getUTCSeconds() : d.getSeconds(); + case "Minutes": + return isUTC ? d.getUTCMinutes() : d.getMinutes(); + case "Hours": + return isUTC ? d.getUTCHours() : d.getHours(); + case "Date": + return isUTC ? d.getUTCDate() : d.getDate(); + case "Day": + return isUTC ? d.getUTCDay() : d.getDay(); + case "Month": + return isUTC ? d.getUTCMonth() : d.getMonth(); + case "FullYear": + return isUTC ? d.getUTCFullYear() : d.getFullYear(); + default: + return NaN; + } +} +function set$1(mom, unit, value) { + var d, isUTC, year, month, date; + if (!mom.isValid() || isNaN(value)) { + return; + } + d = mom._d; + isUTC = mom._isUTC; + switch (unit) { + case "Milliseconds": + return void (isUTC ? d.setUTCMilliseconds(value) : d.setMilliseconds(value)); + case "Seconds": + return void (isUTC ? d.setUTCSeconds(value) : d.setSeconds(value)); + case "Minutes": + return void (isUTC ? d.setUTCMinutes(value) : d.setMinutes(value)); + case "Hours": + return void (isUTC ? d.setUTCHours(value) : d.setHours(value)); + case "Date": + return void (isUTC ? d.setUTCDate(value) : d.setDate(value)); + case "FullYear": + break; + default: + return; + } + year = value; + month = mom.month(); + date = mom.date(); + date = date === 29 && month === 1 && !isLeapYear(year) ? 28 : date; + void (isUTC ? d.setUTCFullYear(year, month, date) : d.setFullYear(year, month, date)); +} +function stringGet(units) { + units = normalizeUnits(units); + if (isFunction(this[units])) { + return this[units](); + } + return this; +} +function stringSet(units, value) { + if (typeof units === "object") { + units = normalizeObjectUnits(units); + var prioritized = getPrioritizedUnits(units), i, prioritizedLen = prioritized.length; + for (i = 0; i < prioritizedLen; i++) { + this[prioritized[i].unit](units[prioritized[i].unit]); + } + } else { + units = normalizeUnits(units); + if (isFunction(this[units])) { + return this[units](value); + } + } + return this; +} +function mod(n2, x) { + return (n2 % x + x) % x; +} +var indexOf; +if (Array.prototype.indexOf) { + indexOf = Array.prototype.indexOf; +} else { + indexOf = function(o2) { + var i; + for (i = 0; i < this.length; ++i) { + if (this[i] === o2) { + return i; + } + } + return -1; + }; +} +function daysInMonth(year, month) { + if (isNaN(year) || isNaN(month)) { + return NaN; + } + var modMonth = mod(month, 12); + year += (month - modMonth) / 12; + return modMonth === 1 ? isLeapYear(year) ? 29 : 28 : 31 - modMonth % 7 % 2; +} +addFormatToken("M", ["MM", 2], "Mo", function() { + return this.month() + 1; +}); +addFormatToken("MMM", 0, 0, function(format2) { + return this.localeData().monthsShort(this, format2); +}); +addFormatToken("MMMM", 0, 0, function(format2) { + return this.localeData().months(this, format2); +}); +addRegexToken("M", match1to2, match1to2NoLeadingZero); +addRegexToken("MM", match1to2, match2); +addRegexToken("MMM", function(isStrict, locale2) { + return locale2.monthsShortRegex(isStrict); +}); +addRegexToken("MMMM", function(isStrict, locale2) { + return locale2.monthsRegex(isStrict); +}); +addParseToken(["M", "MM"], function(input, array) { + array[MONTH] = toInt(input) - 1; +}); +addParseToken(["MMM", "MMMM"], function(input, array, config, token2) { + var month = config._locale.monthsParse(input, token2, config._strict); + if (month != null) { + array[MONTH] = month; + } else { + getParsingFlags(config).invalidMonth = input; + } +}); +var defaultLocaleMonths = "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), defaultLocaleMonthsShort = "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"), MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/, defaultMonthsShortRegex = matchWord, defaultMonthsRegex = matchWord; +function localeMonths(m, format2) { + if (!m) { + return isArray(this._months) ? this._months : this._months["standalone"]; + } + return isArray(this._months) ? this._months[m.month()] : this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format2) ? "format" : "standalone"][m.month()]; +} +function localeMonthsShort(m, format2) { + if (!m) { + return isArray(this._monthsShort) ? this._monthsShort : this._monthsShort["standalone"]; + } + return isArray(this._monthsShort) ? this._monthsShort[m.month()] : this._monthsShort[MONTHS_IN_FORMAT.test(format2) ? "format" : "standalone"][m.month()]; +} +function handleStrictParse(monthName, format2, strict) { + var i, ii, mom, llc = monthName.toLocaleLowerCase(); + if (!this._monthsParse) { + this._monthsParse = []; + this._longMonthsParse = []; + this._shortMonthsParse = []; + for (i = 0; i < 12; ++i) { + mom = createUTC([2e3, i]); + this._shortMonthsParse[i] = this.monthsShort(mom, "").toLocaleLowerCase(); + this._longMonthsParse[i] = this.months(mom, "").toLocaleLowerCase(); + } + } + if (strict) { + if (format2 === "MMM") { + ii = indexOf.call(this._shortMonthsParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._longMonthsParse, llc); + return ii !== -1 ? ii : null; + } + } else { + if (format2 === "MMM") { + ii = indexOf.call(this._shortMonthsParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._longMonthsParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._longMonthsParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._shortMonthsParse, llc); + return ii !== -1 ? ii : null; + } + } +} +function localeMonthsParse(monthName, format2, strict) { + var i, mom, regex; + if (this._monthsParseExact) { + return handleStrictParse.call(this, monthName, format2, strict); + } + if (!this._monthsParse) { + this._monthsParse = []; + this._longMonthsParse = []; + this._shortMonthsParse = []; + } + for (i = 0; i < 12; i++) { + mom = createUTC([2e3, i]); + if (strict && !this._longMonthsParse[i]) { + this._longMonthsParse[i] = new RegExp("^" + this.months(mom, "").replace(".", "") + "$", "i"); + this._shortMonthsParse[i] = new RegExp("^" + this.monthsShort(mom, "").replace(".", "") + "$", "i"); + } + if (!strict && !this._monthsParse[i]) { + regex = "^" + this.months(mom, "") + "|^" + this.monthsShort(mom, ""); + this._monthsParse[i] = new RegExp(regex.replace(".", ""), "i"); + } + if (strict && format2 === "MMMM" && this._longMonthsParse[i].test(monthName)) { + return i; + } else if (strict && format2 === "MMM" && this._shortMonthsParse[i].test(monthName)) { + return i; + } else if (!strict && this._monthsParse[i].test(monthName)) { + return i; + } + } +} +function setMonth(mom, value) { + if (!mom.isValid()) { + return mom; + } + if (typeof value === "string") { + if (/^\d+$/.test(value)) { + value = toInt(value); + } else { + value = mom.localeData().monthsParse(value); + if (!isNumber(value)) { + return mom; + } + } + } + var month = value, date = mom.date(); + date = date < 29 ? date : Math.min(date, daysInMonth(mom.year(), month)); + void (mom._isUTC ? mom._d.setUTCMonth(month, date) : mom._d.setMonth(month, date)); + return mom; +} +function getSetMonth(value) { + if (value != null) { + setMonth(this, value); + hooks.updateOffset(this, true); + return this; + } else { + return get(this, "Month"); + } +} +function getDaysInMonth() { + return daysInMonth(this.year(), this.month()); +} +function monthsShortRegex(isStrict) { + if (this._monthsParseExact) { + if (!hasOwnProp(this, "_monthsRegex")) { + computeMonthsParse.call(this); + } + if (isStrict) { + return this._monthsShortStrictRegex; + } else { + return this._monthsShortRegex; + } + } else { + if (!hasOwnProp(this, "_monthsShortRegex")) { + this._monthsShortRegex = defaultMonthsShortRegex; + } + return this._monthsShortStrictRegex && isStrict ? this._monthsShortStrictRegex : this._monthsShortRegex; + } +} +function monthsRegex(isStrict) { + if (this._monthsParseExact) { + if (!hasOwnProp(this, "_monthsRegex")) { + computeMonthsParse.call(this); + } + if (isStrict) { + return this._monthsStrictRegex; + } else { + return this._monthsRegex; + } + } else { + if (!hasOwnProp(this, "_monthsRegex")) { + this._monthsRegex = defaultMonthsRegex; + } + return this._monthsStrictRegex && isStrict ? this._monthsStrictRegex : this._monthsRegex; + } +} +function computeMonthsParse() { + function cmpLenRev(a, b) { + return b.length - a.length; + } + var shortPieces = [], longPieces = [], mixedPieces = [], i, mom, shortP, longP; + for (i = 0; i < 12; i++) { + mom = createUTC([2e3, i]); + shortP = regexEscape(this.monthsShort(mom, "")); + longP = regexEscape(this.months(mom, "")); + shortPieces.push(shortP); + longPieces.push(longP); + mixedPieces.push(longP); + mixedPieces.push(shortP); + } + shortPieces.sort(cmpLenRev); + longPieces.sort(cmpLenRev); + mixedPieces.sort(cmpLenRev); + this._monthsRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i"); + this._monthsShortRegex = this._monthsRegex; + this._monthsStrictRegex = new RegExp("^(" + longPieces.join("|") + ")", "i"); + this._monthsShortStrictRegex = new RegExp("^(" + shortPieces.join("|") + ")", "i"); +} +function createDate(y, m, d, h, M, s, ms) { + var date; + if (y < 100 && y >= 0) { + date = new Date(y + 400, m, d, h, M, s, ms); + if (isFinite(date.getFullYear())) { + date.setFullYear(y); + } + } else { + date = new Date(y, m, d, h, M, s, ms); + } + return date; +} +function createUTCDate(y) { + var date, args; + if (y < 100 && y >= 0) { + args = Array.prototype.slice.call(arguments); + args[0] = y + 400; + date = new Date(Date.UTC.apply(null, args)); + if (isFinite(date.getUTCFullYear())) { + date.setUTCFullYear(y); + } + } else { + date = new Date(Date.UTC.apply(null, arguments)); + } + return date; +} +function firstWeekOffset(year, dow, doy) { + var fwd = 7 + dow - doy, fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7; + return -fwdlw + fwd - 1; +} +function dayOfYearFromWeeks(year, week, weekday, dow, doy) { + var localWeekday = (7 + weekday - dow) % 7, weekOffset = firstWeekOffset(year, dow, doy), dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, resYear, resDayOfYear; + if (dayOfYear <= 0) { + resYear = year - 1; + resDayOfYear = daysInYear(resYear) + dayOfYear; + } else if (dayOfYear > daysInYear(year)) { + resYear = year + 1; + resDayOfYear = dayOfYear - daysInYear(year); + } else { + resYear = year; + resDayOfYear = dayOfYear; + } + return { + year: resYear, + dayOfYear: resDayOfYear + }; +} +function weekOfYear(mom, dow, doy) { + var weekOffset = firstWeekOffset(mom.year(), dow, doy), week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, resWeek, resYear; + if (week < 1) { + resYear = mom.year() - 1; + resWeek = week + weeksInYear(resYear, dow, doy); + } else if (week > weeksInYear(mom.year(), dow, doy)) { + resWeek = week - weeksInYear(mom.year(), dow, doy); + resYear = mom.year() + 1; + } else { + resYear = mom.year(); + resWeek = week; + } + return { + week: resWeek, + year: resYear + }; +} +function weeksInYear(year, dow, doy) { + var weekOffset = firstWeekOffset(year, dow, doy), weekOffsetNext = firstWeekOffset(year + 1, dow, doy); + return (daysInYear(year) - weekOffset + weekOffsetNext) / 7; +} +addFormatToken("w", ["ww", 2], "wo", "week"); +addFormatToken("W", ["WW", 2], "Wo", "isoWeek"); +addRegexToken("w", match1to2, match1to2NoLeadingZero); +addRegexToken("ww", match1to2, match2); +addRegexToken("W", match1to2, match1to2NoLeadingZero); +addRegexToken("WW", match1to2, match2); +addWeekParseToken(["w", "ww", "W", "WW"], function(input, week, config, token2) { + week[token2.substr(0, 1)] = toInt(input); +}); +function localeWeek(mom) { + return weekOfYear(mom, this._week.dow, this._week.doy).week; +} +var defaultLocaleWeek = { + dow: 0, + doy: 6 +}; +function localeFirstDayOfWeek() { + return this._week.dow; +} +function localeFirstDayOfYear() { + return this._week.doy; +} +function getSetWeek(input) { + var week = this.localeData().week(this); + return input == null ? week : this.add((input - week) * 7, "d"); +} +function getSetISOWeek(input) { + var week = weekOfYear(this, 1, 4).week; + return input == null ? week : this.add((input - week) * 7, "d"); +} +addFormatToken("d", 0, "do", "day"); +addFormatToken("dd", 0, 0, function(format2) { + return this.localeData().weekdaysMin(this, format2); +}); +addFormatToken("ddd", 0, 0, function(format2) { + return this.localeData().weekdaysShort(this, format2); +}); +addFormatToken("dddd", 0, 0, function(format2) { + return this.localeData().weekdays(this, format2); +}); +addFormatToken("e", 0, 0, "weekday"); +addFormatToken("E", 0, 0, "isoWeekday"); +addRegexToken("d", match1to2); +addRegexToken("e", match1to2); +addRegexToken("E", match1to2); +addRegexToken("dd", function(isStrict, locale2) { + return locale2.weekdaysMinRegex(isStrict); +}); +addRegexToken("ddd", function(isStrict, locale2) { + return locale2.weekdaysShortRegex(isStrict); +}); +addRegexToken("dddd", function(isStrict, locale2) { + return locale2.weekdaysRegex(isStrict); +}); +addWeekParseToken(["dd", "ddd", "dddd"], function(input, week, config, token2) { + var weekday = config._locale.weekdaysParse(input, token2, config._strict); + if (weekday != null) { + week.d = weekday; + } else { + getParsingFlags(config).invalidWeekday = input; + } +}); +addWeekParseToken(["d", "e", "E"], function(input, week, config, token2) { + week[token2] = toInt(input); +}); +function parseWeekday(input, locale2) { + if (typeof input !== "string") { + return input; + } + if (!isNaN(input)) { + return parseInt(input, 10); + } + input = locale2.weekdaysParse(input); + if (typeof input === "number") { + return input; + } + return null; +} +function parseIsoWeekday(input, locale2) { + if (typeof input === "string") { + return locale2.weekdaysParse(input) % 7 || 7; + } + return isNaN(input) ? null : input; +} +function shiftWeekdays(ws, n2) { + return ws.slice(n2, 7).concat(ws.slice(0, n2)); +} +var defaultLocaleWeekdays = "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), defaultLocaleWeekdaysShort = "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"), defaultLocaleWeekdaysMin = "Su_Mo_Tu_We_Th_Fr_Sa".split("_"), defaultWeekdaysRegex = matchWord, defaultWeekdaysShortRegex = matchWord, defaultWeekdaysMinRegex = matchWord; +function localeWeekdays(m, format2) { + var weekdays = isArray(this._weekdays) ? this._weekdays : this._weekdays[m && m !== true && this._weekdays.isFormat.test(format2) ? "format" : "standalone"]; + return m === true ? shiftWeekdays(weekdays, this._week.dow) : m ? weekdays[m.day()] : weekdays; +} +function localeWeekdaysShort(m) { + return m === true ? shiftWeekdays(this._weekdaysShort, this._week.dow) : m ? this._weekdaysShort[m.day()] : this._weekdaysShort; +} +function localeWeekdaysMin(m) { + return m === true ? shiftWeekdays(this._weekdaysMin, this._week.dow) : m ? this._weekdaysMin[m.day()] : this._weekdaysMin; +} +function handleStrictParse$1(weekdayName, format2, strict) { + var i, ii, mom, llc = weekdayName.toLocaleLowerCase(); + if (!this._weekdaysParse) { + this._weekdaysParse = []; + this._shortWeekdaysParse = []; + this._minWeekdaysParse = []; + for (i = 0; i < 7; ++i) { + mom = createUTC([2e3, 1]).day(i); + this._minWeekdaysParse[i] = this.weekdaysMin(mom, "").toLocaleLowerCase(); + this._shortWeekdaysParse[i] = this.weekdaysShort(mom, "").toLocaleLowerCase(); + this._weekdaysParse[i] = this.weekdays(mom, "").toLocaleLowerCase(); + } + } + if (strict) { + if (format2 === "dddd") { + ii = indexOf.call(this._weekdaysParse, llc); + return ii !== -1 ? ii : null; + } else if (format2 === "ddd") { + ii = indexOf.call(this._shortWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._minWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } + } else { + if (format2 === "dddd") { + ii = indexOf.call(this._weekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._shortWeekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._minWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } else if (format2 === "ddd") { + ii = indexOf.call(this._shortWeekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._weekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._minWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } else { + ii = indexOf.call(this._minWeekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._weekdaysParse, llc); + if (ii !== -1) { + return ii; + } + ii = indexOf.call(this._shortWeekdaysParse, llc); + return ii !== -1 ? ii : null; + } + } +} +function localeWeekdaysParse(weekdayName, format2, strict) { + var i, mom, regex; + if (this._weekdaysParseExact) { + return handleStrictParse$1.call(this, weekdayName, format2, strict); + } + if (!this._weekdaysParse) { + this._weekdaysParse = []; + this._minWeekdaysParse = []; + this._shortWeekdaysParse = []; + this._fullWeekdaysParse = []; + } + for (i = 0; i < 7; i++) { + mom = createUTC([2e3, 1]).day(i); + if (strict && !this._fullWeekdaysParse[i]) { + this._fullWeekdaysParse[i] = new RegExp("^" + this.weekdays(mom, "").replace(".", "\\.?") + "$", "i"); + this._shortWeekdaysParse[i] = new RegExp("^" + this.weekdaysShort(mom, "").replace(".", "\\.?") + "$", "i"); + this._minWeekdaysParse[i] = new RegExp("^" + this.weekdaysMin(mom, "").replace(".", "\\.?") + "$", "i"); + } + if (!this._weekdaysParse[i]) { + regex = "^" + this.weekdays(mom, "") + "|^" + this.weekdaysShort(mom, "") + "|^" + this.weekdaysMin(mom, ""); + this._weekdaysParse[i] = new RegExp(regex.replace(".", ""), "i"); + } + if (strict && format2 === "dddd" && this._fullWeekdaysParse[i].test(weekdayName)) { + return i; + } else if (strict && format2 === "ddd" && this._shortWeekdaysParse[i].test(weekdayName)) { + return i; + } else if (strict && format2 === "dd" && this._minWeekdaysParse[i].test(weekdayName)) { + return i; + } else if (!strict && this._weekdaysParse[i].test(weekdayName)) { + return i; + } + } +} +function getSetDayOfWeek(input) { + if (!this.isValid()) { + return input != null ? this : NaN; + } + var day = get(this, "Day"); + if (input != null) { + input = parseWeekday(input, this.localeData()); + return this.add(input - day, "d"); + } else { + return day; + } +} +function getSetLocaleDayOfWeek(input) { + if (!this.isValid()) { + return input != null ? this : NaN; + } + var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7; + return input == null ? weekday : this.add(input - weekday, "d"); +} +function getSetISODayOfWeek(input) { + if (!this.isValid()) { + return input != null ? this : NaN; + } + if (input != null) { + var weekday = parseIsoWeekday(input, this.localeData()); + return this.day(this.day() % 7 ? weekday : weekday - 7); + } else { + return this.day() || 7; + } +} +function weekdaysRegex(isStrict) { + if (this._weekdaysParseExact) { + if (!hasOwnProp(this, "_weekdaysRegex")) { + computeWeekdaysParse.call(this); + } + if (isStrict) { + return this._weekdaysStrictRegex; + } else { + return this._weekdaysRegex; + } + } else { + if (!hasOwnProp(this, "_weekdaysRegex")) { + this._weekdaysRegex = defaultWeekdaysRegex; + } + return this._weekdaysStrictRegex && isStrict ? this._weekdaysStrictRegex : this._weekdaysRegex; + } +} +function weekdaysShortRegex(isStrict) { + if (this._weekdaysParseExact) { + if (!hasOwnProp(this, "_weekdaysRegex")) { + computeWeekdaysParse.call(this); + } + if (isStrict) { + return this._weekdaysShortStrictRegex; + } else { + return this._weekdaysShortRegex; + } + } else { + if (!hasOwnProp(this, "_weekdaysShortRegex")) { + this._weekdaysShortRegex = defaultWeekdaysShortRegex; + } + return this._weekdaysShortStrictRegex && isStrict ? this._weekdaysShortStrictRegex : this._weekdaysShortRegex; + } +} +function weekdaysMinRegex(isStrict) { + if (this._weekdaysParseExact) { + if (!hasOwnProp(this, "_weekdaysRegex")) { + computeWeekdaysParse.call(this); + } + if (isStrict) { + return this._weekdaysMinStrictRegex; + } else { + return this._weekdaysMinRegex; + } + } else { + if (!hasOwnProp(this, "_weekdaysMinRegex")) { + this._weekdaysMinRegex = defaultWeekdaysMinRegex; + } + return this._weekdaysMinStrictRegex && isStrict ? this._weekdaysMinStrictRegex : this._weekdaysMinRegex; + } +} +function computeWeekdaysParse() { + function cmpLenRev(a, b) { + return b.length - a.length; + } + var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [], i, mom, minp, shortp, longp; + for (i = 0; i < 7; i++) { + mom = createUTC([2e3, 1]).day(i); + minp = regexEscape(this.weekdaysMin(mom, "")); + shortp = regexEscape(this.weekdaysShort(mom, "")); + longp = regexEscape(this.weekdays(mom, "")); + minPieces.push(minp); + shortPieces.push(shortp); + longPieces.push(longp); + mixedPieces.push(minp); + mixedPieces.push(shortp); + mixedPieces.push(longp); + } + minPieces.sort(cmpLenRev); + shortPieces.sort(cmpLenRev); + longPieces.sort(cmpLenRev); + mixedPieces.sort(cmpLenRev); + this._weekdaysRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i"); + this._weekdaysShortRegex = this._weekdaysRegex; + this._weekdaysMinRegex = this._weekdaysRegex; + this._weekdaysStrictRegex = new RegExp("^(" + longPieces.join("|") + ")", "i"); + this._weekdaysShortStrictRegex = new RegExp("^(" + shortPieces.join("|") + ")", "i"); + this._weekdaysMinStrictRegex = new RegExp("^(" + minPieces.join("|") + ")", "i"); +} +function hFormat() { + return this.hours() % 12 || 12; +} +function kFormat() { + return this.hours() || 24; +} +addFormatToken("H", ["HH", 2], 0, "hour"); +addFormatToken("h", ["hh", 2], 0, hFormat); +addFormatToken("k", ["kk", 2], 0, kFormat); +addFormatToken("hmm", 0, 0, function() { + return "" + hFormat.apply(this) + zeroFill(this.minutes(), 2); +}); +addFormatToken("hmmss", 0, 0, function() { + return "" + hFormat.apply(this) + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2); +}); +addFormatToken("Hmm", 0, 0, function() { + return "" + this.hours() + zeroFill(this.minutes(), 2); +}); +addFormatToken("Hmmss", 0, 0, function() { + return "" + this.hours() + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2); +}); +function meridiem(token2, lowercase) { + addFormatToken(token2, 0, 0, function() { + return this.localeData().meridiem(this.hours(), this.minutes(), lowercase); + }); +} +meridiem("a", true); +meridiem("A", false); +function matchMeridiem(isStrict, locale2) { + return locale2._meridiemParse; +} +addRegexToken("a", matchMeridiem); +addRegexToken("A", matchMeridiem); +addRegexToken("H", match1to2, match1to2HasZero); +addRegexToken("h", match1to2, match1to2NoLeadingZero); +addRegexToken("k", match1to2, match1to2NoLeadingZero); +addRegexToken("HH", match1to2, match2); +addRegexToken("hh", match1to2, match2); +addRegexToken("kk", match1to2, match2); +addRegexToken("hmm", match3to4); +addRegexToken("hmmss", match5to6); +addRegexToken("Hmm", match3to4); +addRegexToken("Hmmss", match5to6); +addParseToken(["H", "HH"], HOUR); +addParseToken(["k", "kk"], function(input, array, config) { + var kInput = toInt(input); + array[HOUR] = kInput === 24 ? 0 : kInput; +}); +addParseToken(["a", "A"], function(input, array, config) { + config._isPm = config._locale.isPM(input); + config._meridiem = input; +}); +addParseToken(["h", "hh"], function(input, array, config) { + array[HOUR] = toInt(input); + getParsingFlags(config).bigHour = true; +}); +addParseToken("hmm", function(input, array, config) { + var pos = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos)); + array[MINUTE] = toInt(input.substr(pos)); + getParsingFlags(config).bigHour = true; +}); +addParseToken("hmmss", function(input, array, config) { + var pos1 = input.length - 4, pos2 = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos1)); + array[MINUTE] = toInt(input.substr(pos1, 2)); + array[SECOND] = toInt(input.substr(pos2)); + getParsingFlags(config).bigHour = true; +}); +addParseToken("Hmm", function(input, array, config) { + var pos = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos)); + array[MINUTE] = toInt(input.substr(pos)); +}); +addParseToken("Hmmss", function(input, array, config) { + var pos1 = input.length - 4, pos2 = input.length - 2; + array[HOUR] = toInt(input.substr(0, pos1)); + array[MINUTE] = toInt(input.substr(pos1, 2)); + array[SECOND] = toInt(input.substr(pos2)); +}); +function localeIsPM(input) { + return (input + "").toLowerCase().charAt(0) === "p"; +} +var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i, getSetHour = makeGetSet("Hours", true); +function localeMeridiem(hours2, minutes2, isLower) { + if (hours2 > 11) { + return isLower ? "pm" : "PM"; + } else { + return isLower ? "am" : "AM"; + } +} +var baseConfig = { + calendar: defaultCalendar, + longDateFormat: defaultLongDateFormat, + invalidDate: defaultInvalidDate, + ordinal: defaultOrdinal, + dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse, + relativeTime: defaultRelativeTime, + months: defaultLocaleMonths, + monthsShort: defaultLocaleMonthsShort, + week: defaultLocaleWeek, + weekdays: defaultLocaleWeekdays, + weekdaysMin: defaultLocaleWeekdaysMin, + weekdaysShort: defaultLocaleWeekdaysShort, + meridiemParse: defaultLocaleMeridiemParse +}; +var locales = {}, localeFamilies = {}, globalLocale; +function commonPrefix(arr1, arr2) { + var i, minl = Math.min(arr1.length, arr2.length); + for (i = 0; i < minl; i += 1) { + if (arr1[i] !== arr2[i]) { + return i; + } + } + return minl; +} +function normalizeLocale(key) { + return key ? key.toLowerCase().replace("_", "-") : key; +} +function chooseLocale(names) { + var i = 0, j, next, locale2, split; + while (i < names.length) { + split = normalizeLocale(names[i]).split("-"); + j = split.length; + next = normalizeLocale(names[i + 1]); + next = next ? next.split("-") : null; + while (j > 0) { + locale2 = loadLocale(split.slice(0, j).join("-")); + if (locale2) { + return locale2; + } + if (next && next.length >= j && commonPrefix(split, next) >= j - 1) { + break; + } + j--; + } + i++; + } + return globalLocale; +} +function isLocaleNameSane(name) { + return !!(name && name.match("^[^/\\\\]*$")); +} +function loadLocale(name) { + var oldLocale = null, aliasedRequire; + if (locales[name] === void 0 && typeof module !== "undefined" && module && module.exports && isLocaleNameSane(name)) { + try { + oldLocale = globalLocale._abbr; + aliasedRequire = require; + aliasedRequire("./locale/" + name); + getSetGlobalLocale(oldLocale); + } catch (e2) { + locales[name] = null; + } + } + return locales[name]; +} +function getSetGlobalLocale(key, values) { + var data; + if (key) { + if (isUndefined(values)) { + data = getLocale(key); + } else { + data = defineLocale(key, values); + } + if (data) { + globalLocale = data; + } else { + if (typeof console !== "undefined" && console.warn) { + console.warn("Locale " + key + " not found. Did you forget to load it?"); + } + } + } + return globalLocale._abbr; +} +function defineLocale(name, config) { + if (config !== null) { + var locale2, parentConfig = baseConfig; + config.abbr = name; + if (locales[name] != null) { + deprecateSimple("defineLocaleOverride", "use moment.updateLocale(localeName, config) to change an existing locale. moment.defineLocale(localeName, config) should only be used for creating a new locale See http://momentjs.com/guides/#/warnings/define-locale/ for more info."); + parentConfig = locales[name]._config; + } else if (config.parentLocale != null) { + if (locales[config.parentLocale] != null) { + parentConfig = locales[config.parentLocale]._config; + } else { + locale2 = loadLocale(config.parentLocale); + if (locale2 != null) { + parentConfig = locale2._config; + } else { + if (!localeFamilies[config.parentLocale]) { + localeFamilies[config.parentLocale] = []; + } + localeFamilies[config.parentLocale].push({ + name, + config + }); + return null; + } + } + } + locales[name] = new Locale(mergeConfigs(parentConfig, config)); + if (localeFamilies[name]) { + localeFamilies[name].forEach(function(x) { + defineLocale(x.name, x.config); + }); + } + getSetGlobalLocale(name); + return locales[name]; + } else { + delete locales[name]; + return null; + } +} +function updateLocale(name, config) { + if (config != null) { + var locale2, tmpLocale, parentConfig = baseConfig; + if (locales[name] != null && locales[name].parentLocale != null) { + locales[name].set(mergeConfigs(locales[name]._config, config)); + } else { + tmpLocale = loadLocale(name); + if (tmpLocale != null) { + parentConfig = tmpLocale._config; + } + config = mergeConfigs(parentConfig, config); + if (tmpLocale == null) { + config.abbr = name; + } + locale2 = new Locale(config); + locale2.parentLocale = locales[name]; + locales[name] = locale2; + } + getSetGlobalLocale(name); + } else { + if (locales[name] != null) { + if (locales[name].parentLocale != null) { + locales[name] = locales[name].parentLocale; + if (name === getSetGlobalLocale()) { + getSetGlobalLocale(name); + } + } else if (locales[name] != null) { + delete locales[name]; + } + } + } + return locales[name]; +} +function getLocale(key) { + var locale2; + if (key && key._locale && key._locale._abbr) { + key = key._locale._abbr; + } + if (!key) { + return globalLocale; + } + if (!isArray(key)) { + locale2 = loadLocale(key); + if (locale2) { + return locale2; + } + key = [key]; + } + return chooseLocale(key); +} +function listLocales() { + return keys(locales); +} +function checkOverflow(m) { + var overflow, a = m._a; + if (a && getParsingFlags(m).overflow === -2) { + overflow = a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : a[HOUR] < 0 || a[HOUR] > 24 || a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0) ? HOUR : a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : -1; + if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) { + overflow = DATE; + } + if (getParsingFlags(m)._overflowWeeks && overflow === -1) { + overflow = WEEK; + } + if (getParsingFlags(m)._overflowWeekday && overflow === -1) { + overflow = WEEKDAY; + } + getParsingFlags(m).overflow = overflow; + } + return m; +} +var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d|))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([+-]\d\d(?::?\d\d)?|\s*Z)?)?$/, tzRegex = /Z|[+-]\d\d(?::?\d\d)?/, isoDates = [ + ["YYYYYY-MM-DD", /[+-]\d{6}-\d\d-\d\d/], + ["YYYY-MM-DD", /\d{4}-\d\d-\d\d/], + ["GGGG-[W]WW-E", /\d{4}-W\d\d-\d/], + ["GGGG-[W]WW", /\d{4}-W\d\d/, false], + ["YYYY-DDD", /\d{4}-\d{3}/], + ["YYYY-MM", /\d{4}-\d\d/, false], + ["YYYYYYMMDD", /[+-]\d{10}/], + ["YYYYMMDD", /\d{8}/], + ["GGGG[W]WWE", /\d{4}W\d{3}/], + ["GGGG[W]WW", /\d{4}W\d{2}/, false], + ["YYYYDDD", /\d{7}/], + ["YYYYMM", /\d{6}/, false], + ["YYYY", /\d{4}/, false] +], isoTimes = [ + ["HH:mm:ss.SSSS", /\d\d:\d\d:\d\d\.\d+/], + ["HH:mm:ss,SSSS", /\d\d:\d\d:\d\d,\d+/], + ["HH:mm:ss", /\d\d:\d\d:\d\d/], + ["HH:mm", /\d\d:\d\d/], + ["HHmmss.SSSS", /\d\d\d\d\d\d\.\d+/], + ["HHmmss,SSSS", /\d\d\d\d\d\d,\d+/], + ["HHmmss", /\d\d\d\d\d\d/], + ["HHmm", /\d\d\d\d/], + ["HH", /\d\d/] +], aspNetJsonRegex = /^\/?Date\((-?\d+)/i, rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/, obsOffsets = { + UT: 0, + GMT: 0, + EDT: -4 * 60, + EST: -5 * 60, + CDT: -5 * 60, + CST: -6 * 60, + MDT: -6 * 60, + MST: -7 * 60, + PDT: -7 * 60, + PST: -8 * 60 +}; +function configFromISO(config) { + var i, l, string = config._i, match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), allowTime, dateFormat, timeFormat, tzFormat, isoDatesLen = isoDates.length, isoTimesLen = isoTimes.length; + if (match) { + getParsingFlags(config).iso = true; + for (i = 0, l = isoDatesLen; i < l; i++) { + if (isoDates[i][1].exec(match[1])) { + dateFormat = isoDates[i][0]; + allowTime = isoDates[i][2] !== false; + break; + } + } + if (dateFormat == null) { + config._isValid = false; + return; + } + if (match[3]) { + for (i = 0, l = isoTimesLen; i < l; i++) { + if (isoTimes[i][1].exec(match[3])) { + timeFormat = (match[2] || " ") + isoTimes[i][0]; + break; + } + } + if (timeFormat == null) { + config._isValid = false; + return; + } + } + if (!allowTime && timeFormat != null) { + config._isValid = false; + return; + } + if (match[4]) { + if (tzRegex.exec(match[4])) { + tzFormat = "Z"; + } else { + config._isValid = false; + return; + } + } + config._f = dateFormat + (timeFormat || "") + (tzFormat || ""); + configFromStringAndFormat(config); + } else { + config._isValid = false; + } +} +function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) { + var result = [ + untruncateYear(yearStr), + defaultLocaleMonthsShort.indexOf(monthStr), + parseInt(dayStr, 10), + parseInt(hourStr, 10), + parseInt(minuteStr, 10) + ]; + if (secondStr) { + result.push(parseInt(secondStr, 10)); + } + return result; +} +function untruncateYear(yearStr) { + var year = parseInt(yearStr, 10); + if (year <= 49) { + return 2e3 + year; + } else if (year <= 999) { + return 1900 + year; + } + return year; +} +function preprocessRFC2822(s) { + return s.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").replace(/^\s\s*/, "").replace(/\s\s*$/, ""); +} +function checkWeekday(weekdayStr, parsedInput, config) { + if (weekdayStr) { + var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr), weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay(); + if (weekdayProvided !== weekdayActual) { + getParsingFlags(config).weekdayMismatch = true; + config._isValid = false; + return false; + } + } + return true; +} +function calculateOffset(obsOffset, militaryOffset, numOffset) { + if (obsOffset) { + return obsOffsets[obsOffset]; + } else if (militaryOffset) { + return 0; + } else { + var hm = parseInt(numOffset, 10), m = hm % 100, h = (hm - m) / 100; + return h * 60 + m; + } +} +function configFromRFC2822(config) { + var match = rfc2822.exec(preprocessRFC2822(config._i)), parsedArray; + if (match) { + parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]); + if (!checkWeekday(match[1], parsedArray, config)) { + return; + } + config._a = parsedArray; + config._tzm = calculateOffset(match[8], match[9], match[10]); + config._d = createUTCDate.apply(null, config._a); + config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); + getParsingFlags(config).rfc2822 = true; + } else { + config._isValid = false; + } +} +function configFromString(config) { + var matched = aspNetJsonRegex.exec(config._i); + if (matched !== null) { + config._d = new Date(+matched[1]); + return; + } + configFromISO(config); + if (config._isValid === false) { + delete config._isValid; + } else { + return; + } + configFromRFC2822(config); + if (config._isValid === false) { + delete config._isValid; + } else { + return; + } + if (config._strict) { + config._isValid = false; + } else { + hooks.createFromInputFallback(config); + } +} +hooks.createFromInputFallback = deprecate("value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are discouraged. Please refer to http://momentjs.com/guides/#/warnings/js-date/ for more info.", function(config) { + config._d = new Date(config._i + (config._useUTC ? " UTC" : "")); +}); +function defaults(a, b, c) { + if (a != null) { + return a; + } + if (b != null) { + return b; + } + return c; +} +function currentDateArray(config) { + var nowValue = new Date(hooks.now()); + if (config._useUTC) { + return [ + nowValue.getUTCFullYear(), + nowValue.getUTCMonth(), + nowValue.getUTCDate() + ]; + } + return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()]; +} +function configFromArray(config) { + var i, date, input = [], currentDate, expectedWeekday, yearToUse; + if (config._d) { + return; + } + currentDate = currentDateArray(config); + if (config._w && config._a[DATE] == null && config._a[MONTH] == null) { + dayOfYearFromWeekInfo(config); + } + if (config._dayOfYear != null) { + yearToUse = defaults(config._a[YEAR], currentDate[YEAR]); + if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) { + getParsingFlags(config)._overflowDayOfYear = true; + } + date = createUTCDate(yearToUse, 0, config._dayOfYear); + config._a[MONTH] = date.getUTCMonth(); + config._a[DATE] = date.getUTCDate(); + } + for (i = 0; i < 3 && config._a[i] == null; ++i) { + config._a[i] = input[i] = currentDate[i]; + } + for (; i < 7; i++) { + config._a[i] = input[i] = config._a[i] == null ? i === 2 ? 1 : 0 : config._a[i]; + } + if (config._a[HOUR] === 24 && config._a[MINUTE] === 0 && config._a[SECOND] === 0 && config._a[MILLISECOND] === 0) { + config._nextDay = true; + config._a[HOUR] = 0; + } + config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input); + expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay(); + if (config._tzm != null) { + config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm); + } + if (config._nextDay) { + config._a[HOUR] = 24; + } + if (config._w && typeof config._w.d !== "undefined" && config._w.d !== expectedWeekday) { + getParsingFlags(config).weekdayMismatch = true; + } +} +function dayOfYearFromWeekInfo(config) { + var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow, curWeek; + w = config._w; + if (w.GG != null || w.W != null || w.E != null) { + dow = 1; + doy = 4; + weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year); + week = defaults(w.W, 1); + weekday = defaults(w.E, 1); + if (weekday < 1 || weekday > 7) { + weekdayOverflow = true; + } + } else { + dow = config._locale._week.dow; + doy = config._locale._week.doy; + curWeek = weekOfYear(createLocal(), dow, doy); + weekYear = defaults(w.gg, config._a[YEAR], curWeek.year); + week = defaults(w.w, curWeek.week); + if (w.d != null) { + weekday = w.d; + if (weekday < 0 || weekday > 6) { + weekdayOverflow = true; + } + } else if (w.e != null) { + weekday = w.e + dow; + if (w.e < 0 || w.e > 6) { + weekdayOverflow = true; + } + } else { + weekday = dow; + } + } + if (week < 1 || week > weeksInYear(weekYear, dow, doy)) { + getParsingFlags(config)._overflowWeeks = true; + } else if (weekdayOverflow != null) { + getParsingFlags(config)._overflowWeekday = true; + } else { + temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy); + config._a[YEAR] = temp.year; + config._dayOfYear = temp.dayOfYear; + } +} +hooks.ISO_8601 = function() { +}; +hooks.RFC_2822 = function() { +}; +function configFromStringAndFormat(config) { + if (config._f === hooks.ISO_8601) { + configFromISO(config); + return; + } + if (config._f === hooks.RFC_2822) { + configFromRFC2822(config); + return; + } + config._a = []; + getParsingFlags(config).empty = true; + var string = "" + config._i, i, parsedInput, tokens2, token2, skipped, stringLength = string.length, totalParsedInputLength = 0, era, tokenLen; + tokens2 = expandFormat(config._f, config._locale).match(formattingTokens) || []; + tokenLen = tokens2.length; + for (i = 0; i < tokenLen; i++) { + token2 = tokens2[i]; + parsedInput = (string.match(getParseRegexForToken(token2, config)) || [])[0]; + if (parsedInput) { + skipped = string.substr(0, string.indexOf(parsedInput)); + if (skipped.length > 0) { + getParsingFlags(config).unusedInput.push(skipped); + } + string = string.slice(string.indexOf(parsedInput) + parsedInput.length); + totalParsedInputLength += parsedInput.length; + } + if (formatTokenFunctions[token2]) { + if (parsedInput) { + getParsingFlags(config).empty = false; + } else { + getParsingFlags(config).unusedTokens.push(token2); + } + addTimeToArrayFromToken(token2, parsedInput, config); + } else if (config._strict && !parsedInput) { + getParsingFlags(config).unusedTokens.push(token2); + } + } + getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength; + if (string.length > 0) { + getParsingFlags(config).unusedInput.push(string); + } + if (config._a[HOUR] <= 12 && getParsingFlags(config).bigHour === true && config._a[HOUR] > 0) { + getParsingFlags(config).bigHour = void 0; + } + getParsingFlags(config).parsedDateParts = config._a.slice(0); + getParsingFlags(config).meridiem = config._meridiem; + config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem); + era = getParsingFlags(config).era; + if (era !== null) { + config._a[YEAR] = config._locale.erasConvertYear(era, config._a[YEAR]); + } + configFromArray(config); + checkOverflow(config); +} +function meridiemFixWrap(locale2, hour, meridiem2) { + var isPm; + if (meridiem2 == null) { + return hour; + } + if (locale2.meridiemHour != null) { + return locale2.meridiemHour(hour, meridiem2); + } else if (locale2.isPM != null) { + isPm = locale2.isPM(meridiem2); + if (isPm && hour < 12) { + hour += 12; + } + if (!isPm && hour === 12) { + hour = 0; + } + return hour; + } else { + return hour; + } +} +function configFromStringAndArray(config) { + var tempConfig, bestMoment, scoreToBeat, i, currentScore, validFormatFound, bestFormatIsValid = false, configfLen = config._f.length; + if (configfLen === 0) { + getParsingFlags(config).invalidFormat = true; + config._d = new Date(NaN); + return; + } + for (i = 0; i < configfLen; i++) { + currentScore = 0; + validFormatFound = false; + tempConfig = copyConfig({}, config); + if (config._useUTC != null) { + tempConfig._useUTC = config._useUTC; + } + tempConfig._f = config._f[i]; + configFromStringAndFormat(tempConfig); + if (isValid(tempConfig)) { + validFormatFound = true; + } + currentScore += getParsingFlags(tempConfig).charsLeftOver; + currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10; + getParsingFlags(tempConfig).score = currentScore; + if (!bestFormatIsValid) { + if (scoreToBeat == null || currentScore < scoreToBeat || validFormatFound) { + scoreToBeat = currentScore; + bestMoment = tempConfig; + if (validFormatFound) { + bestFormatIsValid = true; + } + } + } else { + if (currentScore < scoreToBeat) { + scoreToBeat = currentScore; + bestMoment = tempConfig; + } + } + } + extend(config, bestMoment || tempConfig); +} +function configFromObject(config) { + if (config._d) { + return; + } + var i = normalizeObjectUnits(config._i), dayOrDate = i.day === void 0 ? i.date : i.day; + config._a = map([i.year, i.month, dayOrDate, i.hour, i.minute, i.second, i.millisecond], function(obj) { + return obj && parseInt(obj, 10); + }); + configFromArray(config); +} +function createFromConfig(config) { + var res = new Moment(checkOverflow(prepareConfig(config))); + if (res._nextDay) { + res.add(1, "d"); + res._nextDay = void 0; + } + return res; +} +function prepareConfig(config) { + var input = config._i, format2 = config._f; + config._locale = config._locale || getLocale(config._l); + if (input === null || format2 === void 0 && input === "") { + return createInvalid({ nullInput: true }); + } + if (typeof input === "string") { + config._i = input = config._locale.preparse(input); + } + if (isMoment(input)) { + return new Moment(checkOverflow(input)); + } else if (isDate(input)) { + config._d = input; + } else if (isArray(format2)) { + configFromStringAndArray(config); + } else if (format2) { + configFromStringAndFormat(config); + } else { + configFromInput(config); + } + if (!isValid(config)) { + config._d = null; + } + return config; +} +function configFromInput(config) { + var input = config._i; + if (isUndefined(input)) { + config._d = new Date(hooks.now()); + } else if (isDate(input)) { + config._d = new Date(input.valueOf()); + } else if (typeof input === "string") { + configFromString(config); + } else if (isArray(input)) { + config._a = map(input.slice(0), function(obj) { + return parseInt(obj, 10); + }); + configFromArray(config); + } else if (isObject(input)) { + configFromObject(config); + } else if (isNumber(input)) { + config._d = new Date(input); + } else { + hooks.createFromInputFallback(config); + } +} +function createLocalOrUTC(input, format2, locale2, strict, isUTC) { + var c = {}; + if (format2 === true || format2 === false) { + strict = format2; + format2 = void 0; + } + if (locale2 === true || locale2 === false) { + strict = locale2; + locale2 = void 0; + } + if (isObject(input) && isObjectEmpty(input) || isArray(input) && input.length === 0) { + input = void 0; + } + c._isAMomentObject = true; + c._useUTC = c._isUTC = isUTC; + c._l = locale2; + c._i = input; + c._f = format2; + c._strict = strict; + return createFromConfig(c); +} +function createLocal(input, format2, locale2, strict) { + return createLocalOrUTC(input, format2, locale2, strict, false); +} +var prototypeMin = deprecate("moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/", function() { + var other = createLocal.apply(null, arguments); + if (this.isValid() && other.isValid()) { + return other < this ? this : other; + } else { + return createInvalid(); + } +}), prototypeMax = deprecate("moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/", function() { + var other = createLocal.apply(null, arguments); + if (this.isValid() && other.isValid()) { + return other > this ? this : other; + } else { + return createInvalid(); + } +}); +function pickBy(fn, moments) { + var res, i; + if (moments.length === 1 && isArray(moments[0])) { + moments = moments[0]; + } + if (!moments.length) { + return createLocal(); + } + res = moments[0]; + for (i = 1; i < moments.length; ++i) { + if (!moments[i].isValid() || moments[i][fn](res)) { + res = moments[i]; + } + } + return res; +} +function min() { + var args = [].slice.call(arguments, 0); + return pickBy("isBefore", args); +} +function max() { + var args = [].slice.call(arguments, 0); + return pickBy("isAfter", args); +} +var now = function() { + return Date.now ? Date.now() : +new Date(); +}; +var ordering = [ + "year", + "quarter", + "month", + "week", + "day", + "hour", + "minute", + "second", + "millisecond" +]; +function isDurationValid(m) { + var key, unitHasDecimal = false, i, orderLen = ordering.length; + for (key in m) { + if (hasOwnProp(m, key) && !(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) { + return false; + } + } + for (i = 0; i < orderLen; ++i) { + if (m[ordering[i]]) { + if (unitHasDecimal) { + return false; + } + if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) { + unitHasDecimal = true; + } + } + } + return true; +} +function isValid$1() { + return this._isValid; +} +function createInvalid$1() { + return createDuration(NaN); +} +function Duration(duration) { + var normalizedInput = normalizeObjectUnits(duration), years2 = normalizedInput.year || 0, quarters = normalizedInput.quarter || 0, months2 = normalizedInput.month || 0, weeks2 = normalizedInput.week || normalizedInput.isoWeek || 0, days2 = normalizedInput.day || 0, hours2 = normalizedInput.hour || 0, minutes2 = normalizedInput.minute || 0, seconds2 = normalizedInput.second || 0, milliseconds2 = normalizedInput.millisecond || 0; + this._isValid = isDurationValid(normalizedInput); + this._milliseconds = +milliseconds2 + seconds2 * 1e3 + minutes2 * 6e4 + hours2 * 1e3 * 60 * 60; + this._days = +days2 + weeks2 * 7; + this._months = +months2 + quarters * 3 + years2 * 12; + this._data = {}; + this._locale = getLocale(); + this._bubble(); +} +function isDuration(obj) { + return obj instanceof Duration; +} +function absRound(number) { + if (number < 0) { + return Math.round(-1 * number) * -1; + } else { + return Math.round(number); + } +} +function compareArrays(array1, array2, dontConvert) { + var len = Math.min(array1.length, array2.length), lengthDiff = Math.abs(array1.length - array2.length), diffs = 0, i; + for (i = 0; i < len; i++) { + if (dontConvert && array1[i] !== array2[i] || !dontConvert && toInt(array1[i]) !== toInt(array2[i])) { + diffs++; + } + } + return diffs + lengthDiff; +} +function offset(token2, separator) { + addFormatToken(token2, 0, 0, function() { + var offset2 = this.utcOffset(), sign2 = "+"; + if (offset2 < 0) { + offset2 = -offset2; + sign2 = "-"; + } + return sign2 + zeroFill(~~(offset2 / 60), 2) + separator + zeroFill(~~offset2 % 60, 2); + }); +} +offset("Z", ":"); +offset("ZZ", ""); +addRegexToken("Z", matchShortOffset); +addRegexToken("ZZ", matchShortOffset); +addParseToken(["Z", "ZZ"], function(input, array, config) { + config._useUTC = true; + config._tzm = offsetFromString(matchShortOffset, input); +}); +var chunkOffset = /([\+\-]|\d\d)/gi; +function offsetFromString(matcher, string) { + var matches = (string || "").match(matcher), chunk, parts, minutes2; + if (matches === null) { + return null; + } + chunk = matches[matches.length - 1] || []; + parts = (chunk + "").match(chunkOffset) || ["-", 0, 0]; + minutes2 = +(parts[1] * 60) + toInt(parts[2]); + return minutes2 === 0 ? 0 : parts[0] === "+" ? minutes2 : -minutes2; +} +function cloneWithOffset(input, model) { + var res, diff2; + if (model._isUTC) { + res = model.clone(); + diff2 = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf(); + res._d.setTime(res._d.valueOf() + diff2); + hooks.updateOffset(res, false); + return res; + } else { + return createLocal(input).local(); + } +} +function getDateOffset(m) { + return -Math.round(m._d.getTimezoneOffset()); +} +hooks.updateOffset = function() { +}; +function getSetOffset(input, keepLocalTime, keepMinutes) { + var offset2 = this._offset || 0, localAdjust; + if (!this.isValid()) { + return input != null ? this : NaN; + } + if (input != null) { + if (typeof input === "string") { + input = offsetFromString(matchShortOffset, input); + if (input === null) { + return this; + } + } else if (Math.abs(input) < 16 && !keepMinutes) { + input = input * 60; + } + if (!this._isUTC && keepLocalTime) { + localAdjust = getDateOffset(this); + } + this._offset = input; + this._isUTC = true; + if (localAdjust != null) { + this.add(localAdjust, "m"); + } + if (offset2 !== input) { + if (!keepLocalTime || this._changeInProgress) { + addSubtract(this, createDuration(input - offset2, "m"), 1, false); + } else if (!this._changeInProgress) { + this._changeInProgress = true; + hooks.updateOffset(this, true); + this._changeInProgress = null; + } + } + return this; + } else { + return this._isUTC ? offset2 : getDateOffset(this); + } +} +function getSetZone(input, keepLocalTime) { + if (input != null) { + if (typeof input !== "string") { + input = -input; + } + this.utcOffset(input, keepLocalTime); + return this; + } else { + return -this.utcOffset(); + } +} +function setOffsetToUTC(keepLocalTime) { + return this.utcOffset(0, keepLocalTime); +} +function setOffsetToLocal(keepLocalTime) { + if (this._isUTC) { + this.utcOffset(0, keepLocalTime); + this._isUTC = false; + if (keepLocalTime) { + this.subtract(getDateOffset(this), "m"); + } + } + return this; +} +function setOffsetToParsedOffset() { + if (this._tzm != null) { + this.utcOffset(this._tzm, false, true); + } else if (typeof this._i === "string") { + var tZone = offsetFromString(matchOffset, this._i); + if (tZone != null) { + this.utcOffset(tZone); + } else { + this.utcOffset(0, true); + } + } + return this; +} +function hasAlignedHourOffset(input) { + if (!this.isValid()) { + return false; + } + input = input ? createLocal(input).utcOffset() : 0; + return (this.utcOffset() - input) % 60 === 0; +} +function isDaylightSavingTime() { + return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset(); +} +function isDaylightSavingTimeShifted() { + if (!isUndefined(this._isDSTShifted)) { + return this._isDSTShifted; + } + var c = {}, other; + copyConfig(c, this); + c = prepareConfig(c); + if (c._a) { + other = c._isUTC ? createUTC(c._a) : createLocal(c._a); + this._isDSTShifted = this.isValid() && compareArrays(c._a, other.toArray()) > 0; + } else { + this._isDSTShifted = false; + } + return this._isDSTShifted; +} +function isLocal() { + return this.isValid() ? !this._isUTC : false; +} +function isUtcOffset() { + return this.isValid() ? this._isUTC : false; +} +function isUtc() { + return this.isValid() ? this._isUTC && this._offset === 0 : false; +} +var aspNetRegex = /^(-|\+)?(?:(\d*)[. ])?(\d+):(\d+)(?::(\d+)(\.\d*)?)?$/, isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/; +function createDuration(input, key) { + var duration = input, match = null, sign2, ret, diffRes; + if (isDuration(input)) { + duration = { + ms: input._milliseconds, + d: input._days, + M: input._months + }; + } else if (isNumber(input) || !isNaN(+input)) { + duration = {}; + if (key) { + duration[key] = +input; + } else { + duration.milliseconds = +input; + } + } else if (match = aspNetRegex.exec(input)) { + sign2 = match[1] === "-" ? -1 : 1; + duration = { + y: 0, + d: toInt(match[DATE]) * sign2, + h: toInt(match[HOUR]) * sign2, + m: toInt(match[MINUTE]) * sign2, + s: toInt(match[SECOND]) * sign2, + ms: toInt(absRound(match[MILLISECOND] * 1e3)) * sign2 + }; + } else if (match = isoRegex.exec(input)) { + sign2 = match[1] === "-" ? -1 : 1; + duration = { + y: parseIso(match[2], sign2), + M: parseIso(match[3], sign2), + w: parseIso(match[4], sign2), + d: parseIso(match[5], sign2), + h: parseIso(match[6], sign2), + m: parseIso(match[7], sign2), + s: parseIso(match[8], sign2) + }; + } else if (duration == null) { + duration = {}; + } else if (typeof duration === "object" && ("from" in duration || "to" in duration)) { + diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to)); + duration = {}; + duration.ms = diffRes.milliseconds; + duration.M = diffRes.months; + } + ret = new Duration(duration); + if (isDuration(input) && hasOwnProp(input, "_locale")) { + ret._locale = input._locale; + } + if (isDuration(input) && hasOwnProp(input, "_isValid")) { + ret._isValid = input._isValid; + } + return ret; +} +createDuration.fn = Duration.prototype; +createDuration.invalid = createInvalid$1; +function parseIso(inp, sign2) { + var res = inp && parseFloat(inp.replace(",", ".")); + return (isNaN(res) ? 0 : res) * sign2; +} +function positiveMomentsDifference(base, other) { + var res = {}; + res.months = other.month() - base.month() + (other.year() - base.year()) * 12; + if (base.clone().add(res.months, "M").isAfter(other)) { + --res.months; + } + res.milliseconds = +other - +base.clone().add(res.months, "M"); + return res; +} +function momentsDifference(base, other) { + var res; + if (!(base.isValid() && other.isValid())) { + return { milliseconds: 0, months: 0 }; + } + other = cloneWithOffset(other, base); + if (base.isBefore(other)) { + res = positiveMomentsDifference(base, other); + } else { + res = positiveMomentsDifference(other, base); + res.milliseconds = -res.milliseconds; + res.months = -res.months; + } + return res; +} +function createAdder(direction, name) { + return function(val, period) { + var dur, tmp; + if (period !== null && !isNaN(+period)) { + deprecateSimple(name, "moment()." + name + "(period, number) is deprecated. Please use moment()." + name + "(number, period). See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info."); + tmp = val; + val = period; + period = tmp; + } + dur = createDuration(val, period); + addSubtract(this, dur, direction); + return this; + }; +} +function addSubtract(mom, duration, isAdding, updateOffset) { + var milliseconds2 = duration._milliseconds, days2 = absRound(duration._days), months2 = absRound(duration._months); + if (!mom.isValid()) { + return; + } + updateOffset = updateOffset == null ? true : updateOffset; + if (months2) { + setMonth(mom, get(mom, "Month") + months2 * isAdding); + } + if (days2) { + set$1(mom, "Date", get(mom, "Date") + days2 * isAdding); + } + if (milliseconds2) { + mom._d.setTime(mom._d.valueOf() + milliseconds2 * isAdding); + } + if (updateOffset) { + hooks.updateOffset(mom, days2 || months2); + } +} +var add = createAdder(1, "add"), subtract = createAdder(-1, "subtract"); +function isString(input) { + return typeof input === "string" || input instanceof String; +} +function isMomentInput(input) { + return isMoment(input) || isDate(input) || isString(input) || isNumber(input) || isNumberOrStringArray(input) || isMomentInputObject(input) || input === null || input === void 0; +} +function isMomentInputObject(input) { + var objectTest = isObject(input) && !isObjectEmpty(input), propertyTest = false, properties = [ + "years", + "year", + "y", + "months", + "month", + "M", + "days", + "day", + "d", + "dates", + "date", + "D", + "hours", + "hour", + "h", + "minutes", + "minute", + "m", + "seconds", + "second", + "s", + "milliseconds", + "millisecond", + "ms" + ], i, property, propertyLen = properties.length; + for (i = 0; i < propertyLen; i += 1) { + property = properties[i]; + propertyTest = propertyTest || hasOwnProp(input, property); + } + return objectTest && propertyTest; +} +function isNumberOrStringArray(input) { + var arrayTest = isArray(input), dataTypeTest = false; + if (arrayTest) { + dataTypeTest = input.filter(function(item) { + return !isNumber(item) && isString(input); + }).length === 0; + } + return arrayTest && dataTypeTest; +} +function isCalendarSpec(input) { + var objectTest = isObject(input) && !isObjectEmpty(input), propertyTest = false, properties = [ + "sameDay", + "nextDay", + "lastDay", + "nextWeek", + "lastWeek", + "sameElse" + ], i, property; + for (i = 0; i < properties.length; i += 1) { + property = properties[i]; + propertyTest = propertyTest || hasOwnProp(input, property); + } + return objectTest && propertyTest; +} +function getCalendarFormat(myMoment, now2) { + var diff2 = myMoment.diff(now2, "days", true); + return diff2 < -6 ? "sameElse" : diff2 < -1 ? "lastWeek" : diff2 < 0 ? "lastDay" : diff2 < 1 ? "sameDay" : diff2 < 2 ? "nextDay" : diff2 < 7 ? "nextWeek" : "sameElse"; +} +function calendar$1(time, formats) { + if (arguments.length === 1) { + if (!arguments[0]) { + time = void 0; + formats = void 0; + } else if (isMomentInput(arguments[0])) { + time = arguments[0]; + formats = void 0; + } else if (isCalendarSpec(arguments[0])) { + formats = arguments[0]; + time = void 0; + } + } + var now2 = time || createLocal(), sod = cloneWithOffset(now2, this).startOf("day"), format2 = hooks.calendarFormat(this, sod) || "sameElse", output = formats && (isFunction(formats[format2]) ? formats[format2].call(this, now2) : formats[format2]); + return this.format(output || this.localeData().calendar(format2, this, createLocal(now2))); +} +function clone() { + return new Moment(this); +} +function isAfter(input, units) { + var localInput = isMoment(input) ? input : createLocal(input); + if (!(this.isValid() && localInput.isValid())) { + return false; + } + units = normalizeUnits(units) || "millisecond"; + if (units === "millisecond") { + return this.valueOf() > localInput.valueOf(); + } else { + return localInput.valueOf() < this.clone().startOf(units).valueOf(); + } +} +function isBefore(input, units) { + var localInput = isMoment(input) ? input : createLocal(input); + if (!(this.isValid() && localInput.isValid())) { + return false; + } + units = normalizeUnits(units) || "millisecond"; + if (units === "millisecond") { + return this.valueOf() < localInput.valueOf(); + } else { + return this.clone().endOf(units).valueOf() < localInput.valueOf(); + } +} +function isBetween(from2, to2, units, inclusivity) { + var localFrom = isMoment(from2) ? from2 : createLocal(from2), localTo = isMoment(to2) ? to2 : createLocal(to2); + if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) { + return false; + } + inclusivity = inclusivity || "()"; + return (inclusivity[0] === "(" ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) && (inclusivity[1] === ")" ? this.isBefore(localTo, units) : !this.isAfter(localTo, units)); +} +function isSame(input, units) { + var localInput = isMoment(input) ? input : createLocal(input), inputMs; + if (!(this.isValid() && localInput.isValid())) { + return false; + } + units = normalizeUnits(units) || "millisecond"; + if (units === "millisecond") { + return this.valueOf() === localInput.valueOf(); + } else { + inputMs = localInput.valueOf(); + return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf(); + } +} +function isSameOrAfter(input, units) { + return this.isSame(input, units) || this.isAfter(input, units); +} +function isSameOrBefore(input, units) { + return this.isSame(input, units) || this.isBefore(input, units); +} +function diff(input, units, asFloat) { + var that, zoneDelta, output; + if (!this.isValid()) { + return NaN; + } + that = cloneWithOffset(input, this); + if (!that.isValid()) { + return NaN; + } + zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4; + units = normalizeUnits(units); + switch (units) { + case "year": + output = monthDiff(this, that) / 12; + break; + case "month": + output = monthDiff(this, that); + break; + case "quarter": + output = monthDiff(this, that) / 3; + break; + case "second": + output = (this - that) / 1e3; + break; + case "minute": + output = (this - that) / 6e4; + break; + case "hour": + output = (this - that) / 36e5; + break; + case "day": + output = (this - that - zoneDelta) / 864e5; + break; + case "week": + output = (this - that - zoneDelta) / 6048e5; + break; + default: + output = this - that; + } + return asFloat ? output : absFloor(output); +} +function monthDiff(a, b) { + if (a.date() < b.date()) { + return -monthDiff(b, a); + } + var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()), anchor = a.clone().add(wholeMonthDiff, "months"), anchor2, adjust; + if (b - anchor < 0) { + anchor2 = a.clone().add(wholeMonthDiff - 1, "months"); + adjust = (b - anchor) / (anchor - anchor2); + } else { + anchor2 = a.clone().add(wholeMonthDiff + 1, "months"); + adjust = (b - anchor) / (anchor2 - anchor); + } + return -(wholeMonthDiff + adjust) || 0; +} +hooks.defaultFormat = "YYYY-MM-DDTHH:mm:ssZ"; +hooks.defaultFormatUtc = "YYYY-MM-DDTHH:mm:ss[Z]"; +function toString() { + return this.clone().locale("en").format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ"); +} +function toISOString(keepOffset) { + if (!this.isValid()) { + return null; + } + var utc = keepOffset !== true, m = utc ? this.clone().utc() : this; + if (m.year() < 0 || m.year() > 9999) { + return formatMoment(m, utc ? "YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]" : "YYYYYY-MM-DD[T]HH:mm:ss.SSSZ"); + } + if (isFunction(Date.prototype.toISOString)) { + if (utc) { + return this.toDate().toISOString(); + } else { + return new Date(this.valueOf() + this.utcOffset() * 60 * 1e3).toISOString().replace("Z", formatMoment(m, "Z")); + } + } + return formatMoment(m, utc ? "YYYY-MM-DD[T]HH:mm:ss.SSS[Z]" : "YYYY-MM-DD[T]HH:mm:ss.SSSZ"); +} +function inspect() { + if (!this.isValid()) { + return "moment.invalid(/* " + this._i + " */)"; + } + var func = "moment", zone = "", prefix, year, datetime, suffix; + if (!this.isLocal()) { + func = this.utcOffset() === 0 ? "moment.utc" : "moment.parseZone"; + zone = "Z"; + } + prefix = "[" + func + '("]'; + year = 0 <= this.year() && this.year() <= 9999 ? "YYYY" : "YYYYYY"; + datetime = "-MM-DD[T]HH:mm:ss.SSS"; + suffix = zone + '[")]'; + return this.format(prefix + year + datetime + suffix); +} +function format(inputString) { + if (!inputString) { + inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat; + } + var output = formatMoment(this, inputString); + return this.localeData().postformat(output); +} +function from(time, withoutSuffix) { + if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) { + return createDuration({ to: this, from: time }).locale(this.locale()).humanize(!withoutSuffix); + } else { + return this.localeData().invalidDate(); + } +} +function fromNow(withoutSuffix) { + return this.from(createLocal(), withoutSuffix); +} +function to(time, withoutSuffix) { + if (this.isValid() && (isMoment(time) && time.isValid() || createLocal(time).isValid())) { + return createDuration({ from: this, to: time }).locale(this.locale()).humanize(!withoutSuffix); + } else { + return this.localeData().invalidDate(); + } +} +function toNow(withoutSuffix) { + return this.to(createLocal(), withoutSuffix); +} +function locale(key) { + var newLocaleData; + if (key === void 0) { + return this._locale._abbr; + } else { + newLocaleData = getLocale(key); + if (newLocaleData != null) { + this._locale = newLocaleData; + } + return this; + } +} +var lang = deprecate("moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.", function(key) { + if (key === void 0) { + return this.localeData(); + } else { + return this.locale(key); + } +}); +function localeData() { + return this._locale; +} +var MS_PER_SECOND = 1e3, MS_PER_MINUTE = 60 * MS_PER_SECOND, MS_PER_HOUR = 60 * MS_PER_MINUTE, MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR; +function mod$1(dividend, divisor) { + return (dividend % divisor + divisor) % divisor; +} +function localStartOfDate(y, m, d) { + if (y < 100 && y >= 0) { + return new Date(y + 400, m, d) - MS_PER_400_YEARS; + } else { + return new Date(y, m, d).valueOf(); + } +} +function utcStartOfDate(y, m, d) { + if (y < 100 && y >= 0) { + return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS; + } else { + return Date.UTC(y, m, d); + } +} +function startOf(units) { + var time, startOfDate; + units = normalizeUnits(units); + if (units === void 0 || units === "millisecond" || !this.isValid()) { + return this; + } + startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate; + switch (units) { + case "year": + time = startOfDate(this.year(), 0, 1); + break; + case "quarter": + time = startOfDate(this.year(), this.month() - this.month() % 3, 1); + break; + case "month": + time = startOfDate(this.year(), this.month(), 1); + break; + case "week": + time = startOfDate(this.year(), this.month(), this.date() - this.weekday()); + break; + case "isoWeek": + time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1)); + break; + case "day": + case "date": + time = startOfDate(this.year(), this.month(), this.date()); + break; + case "hour": + time = this._d.valueOf(); + time -= mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR); + break; + case "minute": + time = this._d.valueOf(); + time -= mod$1(time, MS_PER_MINUTE); + break; + case "second": + time = this._d.valueOf(); + time -= mod$1(time, MS_PER_SECOND); + break; + } + this._d.setTime(time); + hooks.updateOffset(this, true); + return this; +} +function endOf(units) { + var time, startOfDate; + units = normalizeUnits(units); + if (units === void 0 || units === "millisecond" || !this.isValid()) { + return this; + } + startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate; + switch (units) { + case "year": + time = startOfDate(this.year() + 1, 0, 1) - 1; + break; + case "quarter": + time = startOfDate(this.year(), this.month() - this.month() % 3 + 3, 1) - 1; + break; + case "month": + time = startOfDate(this.year(), this.month() + 1, 1) - 1; + break; + case "week": + time = startOfDate(this.year(), this.month(), this.date() - this.weekday() + 7) - 1; + break; + case "isoWeek": + time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1) + 7) - 1; + break; + case "day": + case "date": + time = startOfDate(this.year(), this.month(), this.date() + 1) - 1; + break; + case "hour": + time = this._d.valueOf(); + time += MS_PER_HOUR - mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR) - 1; + break; + case "minute": + time = this._d.valueOf(); + time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1; + break; + case "second": + time = this._d.valueOf(); + time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1; + break; + } + this._d.setTime(time); + hooks.updateOffset(this, true); + return this; +} +function valueOf() { + return this._d.valueOf() - (this._offset || 0) * 6e4; +} +function unix() { + return Math.floor(this.valueOf() / 1e3); +} +function toDate() { + return new Date(this.valueOf()); +} +function toArray() { + var m = this; + return [ + m.year(), + m.month(), + m.date(), + m.hour(), + m.minute(), + m.second(), + m.millisecond() + ]; +} +function toObject() { + var m = this; + return { + years: m.year(), + months: m.month(), + date: m.date(), + hours: m.hours(), + minutes: m.minutes(), + seconds: m.seconds(), + milliseconds: m.milliseconds() + }; +} +function toJSON() { + return this.isValid() ? this.toISOString() : null; +} +function isValid$2() { + return isValid(this); +} +function parsingFlags() { + return extend({}, getParsingFlags(this)); +} +function invalidAt() { + return getParsingFlags(this).overflow; +} +function creationData() { + return { + input: this._i, + format: this._f, + locale: this._locale, + isUTC: this._isUTC, + strict: this._strict + }; +} +addFormatToken("N", 0, 0, "eraAbbr"); +addFormatToken("NN", 0, 0, "eraAbbr"); +addFormatToken("NNN", 0, 0, "eraAbbr"); +addFormatToken("NNNN", 0, 0, "eraName"); +addFormatToken("NNNNN", 0, 0, "eraNarrow"); +addFormatToken("y", ["y", 1], "yo", "eraYear"); +addFormatToken("y", ["yy", 2], 0, "eraYear"); +addFormatToken("y", ["yyy", 3], 0, "eraYear"); +addFormatToken("y", ["yyyy", 4], 0, "eraYear"); +addRegexToken("N", matchEraAbbr); +addRegexToken("NN", matchEraAbbr); +addRegexToken("NNN", matchEraAbbr); +addRegexToken("NNNN", matchEraName); +addRegexToken("NNNNN", matchEraNarrow); +addParseToken(["N", "NN", "NNN", "NNNN", "NNNNN"], function(input, array, config, token2) { + var era = config._locale.erasParse(input, token2, config._strict); + if (era) { + getParsingFlags(config).era = era; + } else { + getParsingFlags(config).invalidEra = input; + } +}); +addRegexToken("y", matchUnsigned); +addRegexToken("yy", matchUnsigned); +addRegexToken("yyy", matchUnsigned); +addRegexToken("yyyy", matchUnsigned); +addRegexToken("yo", matchEraYearOrdinal); +addParseToken(["y", "yy", "yyy", "yyyy"], YEAR); +addParseToken(["yo"], function(input, array, config, token2) { + var match; + if (config._locale._eraYearOrdinalRegex) { + match = input.match(config._locale._eraYearOrdinalRegex); + } + if (config._locale.eraYearOrdinalParse) { + array[YEAR] = config._locale.eraYearOrdinalParse(input, match); + } else { + array[YEAR] = parseInt(input, 10); + } +}); +function localeEras(m, format2) { + var i, l, date, eras = this._eras || getLocale("en")._eras; + for (i = 0, l = eras.length; i < l; ++i) { + switch (typeof eras[i].since) { + case "string": + date = hooks(eras[i].since).startOf("day"); + eras[i].since = date.valueOf(); + break; + } + switch (typeof eras[i].until) { + case "undefined": + eras[i].until = Infinity; + break; + case "string": + date = hooks(eras[i].until).startOf("day").valueOf(); + eras[i].until = date.valueOf(); + break; + } + } + return eras; +} +function localeErasParse(eraName, format2, strict) { + var i, l, eras = this.eras(), name, abbr, narrow; + eraName = eraName.toUpperCase(); + for (i = 0, l = eras.length; i < l; ++i) { + name = eras[i].name.toUpperCase(); + abbr = eras[i].abbr.toUpperCase(); + narrow = eras[i].narrow.toUpperCase(); + if (strict) { + switch (format2) { + case "N": + case "NN": + case "NNN": + if (abbr === eraName) { + return eras[i]; + } + break; + case "NNNN": + if (name === eraName) { + return eras[i]; + } + break; + case "NNNNN": + if (narrow === eraName) { + return eras[i]; + } + break; + } + } else if ([name, abbr, narrow].indexOf(eraName) >= 0) { + return eras[i]; + } + } +} +function localeErasConvertYear(era, year) { + var dir = era.since <= era.until ? 1 : -1; + if (year === void 0) { + return hooks(era.since).year(); + } else { + return hooks(era.since).year() + (year - era.offset) * dir; + } +} +function getEraName() { + var i, l, val, eras = this.localeData().eras(); + for (i = 0, l = eras.length; i < l; ++i) { + val = this.clone().startOf("day").valueOf(); + if (eras[i].since <= val && val <= eras[i].until) { + return eras[i].name; + } + if (eras[i].until <= val && val <= eras[i].since) { + return eras[i].name; + } + } + return ""; +} +function getEraNarrow() { + var i, l, val, eras = this.localeData().eras(); + for (i = 0, l = eras.length; i < l; ++i) { + val = this.clone().startOf("day").valueOf(); + if (eras[i].since <= val && val <= eras[i].until) { + return eras[i].narrow; + } + if (eras[i].until <= val && val <= eras[i].since) { + return eras[i].narrow; + } + } + return ""; +} +function getEraAbbr() { + var i, l, val, eras = this.localeData().eras(); + for (i = 0, l = eras.length; i < l; ++i) { + val = this.clone().startOf("day").valueOf(); + if (eras[i].since <= val && val <= eras[i].until) { + return eras[i].abbr; + } + if (eras[i].until <= val && val <= eras[i].since) { + return eras[i].abbr; + } + } + return ""; +} +function getEraYear() { + var i, l, dir, val, eras = this.localeData().eras(); + for (i = 0, l = eras.length; i < l; ++i) { + dir = eras[i].since <= eras[i].until ? 1 : -1; + val = this.clone().startOf("day").valueOf(); + if (eras[i].since <= val && val <= eras[i].until || eras[i].until <= val && val <= eras[i].since) { + return (this.year() - hooks(eras[i].since).year()) * dir + eras[i].offset; + } + } + return this.year(); +} +function erasNameRegex(isStrict) { + if (!hasOwnProp(this, "_erasNameRegex")) { + computeErasParse.call(this); + } + return isStrict ? this._erasNameRegex : this._erasRegex; +} +function erasAbbrRegex(isStrict) { + if (!hasOwnProp(this, "_erasAbbrRegex")) { + computeErasParse.call(this); + } + return isStrict ? this._erasAbbrRegex : this._erasRegex; +} +function erasNarrowRegex(isStrict) { + if (!hasOwnProp(this, "_erasNarrowRegex")) { + computeErasParse.call(this); + } + return isStrict ? this._erasNarrowRegex : this._erasRegex; +} +function matchEraAbbr(isStrict, locale2) { + return locale2.erasAbbrRegex(isStrict); +} +function matchEraName(isStrict, locale2) { + return locale2.erasNameRegex(isStrict); +} +function matchEraNarrow(isStrict, locale2) { + return locale2.erasNarrowRegex(isStrict); +} +function matchEraYearOrdinal(isStrict, locale2) { + return locale2._eraYearOrdinalRegex || matchUnsigned; +} +function computeErasParse() { + var abbrPieces = [], namePieces = [], narrowPieces = [], mixedPieces = [], i, l, erasName, erasAbbr, erasNarrow, eras = this.eras(); + for (i = 0, l = eras.length; i < l; ++i) { + erasName = regexEscape(eras[i].name); + erasAbbr = regexEscape(eras[i].abbr); + erasNarrow = regexEscape(eras[i].narrow); + namePieces.push(erasName); + abbrPieces.push(erasAbbr); + narrowPieces.push(erasNarrow); + mixedPieces.push(erasName); + mixedPieces.push(erasAbbr); + mixedPieces.push(erasNarrow); + } + this._erasRegex = new RegExp("^(" + mixedPieces.join("|") + ")", "i"); + this._erasNameRegex = new RegExp("^(" + namePieces.join("|") + ")", "i"); + this._erasAbbrRegex = new RegExp("^(" + abbrPieces.join("|") + ")", "i"); + this._erasNarrowRegex = new RegExp("^(" + narrowPieces.join("|") + ")", "i"); +} +addFormatToken(0, ["gg", 2], 0, function() { + return this.weekYear() % 100; +}); +addFormatToken(0, ["GG", 2], 0, function() { + return this.isoWeekYear() % 100; +}); +function addWeekYearFormatToken(token2, getter) { + addFormatToken(0, [token2, token2.length], 0, getter); +} +addWeekYearFormatToken("gggg", "weekYear"); +addWeekYearFormatToken("ggggg", "weekYear"); +addWeekYearFormatToken("GGGG", "isoWeekYear"); +addWeekYearFormatToken("GGGGG", "isoWeekYear"); +addRegexToken("G", matchSigned); +addRegexToken("g", matchSigned); +addRegexToken("GG", match1to2, match2); +addRegexToken("gg", match1to2, match2); +addRegexToken("GGGG", match1to4, match4); +addRegexToken("gggg", match1to4, match4); +addRegexToken("GGGGG", match1to6, match6); +addRegexToken("ggggg", match1to6, match6); +addWeekParseToken(["gggg", "ggggg", "GGGG", "GGGGG"], function(input, week, config, token2) { + week[token2.substr(0, 2)] = toInt(input); +}); +addWeekParseToken(["gg", "GG"], function(input, week, config, token2) { + week[token2] = hooks.parseTwoDigitYear(input); +}); +function getSetWeekYear(input) { + return getSetWeekYearHelper.call(this, input, this.week(), this.weekday() + this.localeData()._week.dow, this.localeData()._week.dow, this.localeData()._week.doy); +} +function getSetISOWeekYear(input) { + return getSetWeekYearHelper.call(this, input, this.isoWeek(), this.isoWeekday(), 1, 4); +} +function getISOWeeksInYear() { + return weeksInYear(this.year(), 1, 4); +} +function getISOWeeksInISOWeekYear() { + return weeksInYear(this.isoWeekYear(), 1, 4); +} +function getWeeksInYear() { + var weekInfo = this.localeData()._week; + return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy); +} +function getWeeksInWeekYear() { + var weekInfo = this.localeData()._week; + return weeksInYear(this.weekYear(), weekInfo.dow, weekInfo.doy); +} +function getSetWeekYearHelper(input, week, weekday, dow, doy) { + var weeksTarget; + if (input == null) { + return weekOfYear(this, dow, doy).year; + } else { + weeksTarget = weeksInYear(input, dow, doy); + if (week > weeksTarget) { + week = weeksTarget; + } + return setWeekAll.call(this, input, week, weekday, dow, doy); + } +} +function setWeekAll(weekYear, week, weekday, dow, doy) { + var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear); + this.year(date.getUTCFullYear()); + this.month(date.getUTCMonth()); + this.date(date.getUTCDate()); + return this; +} +addFormatToken("Q", 0, "Qo", "quarter"); +addRegexToken("Q", match1); +addParseToken("Q", function(input, array) { + array[MONTH] = (toInt(input) - 1) * 3; +}); +function getSetQuarter(input) { + return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3); +} +addFormatToken("D", ["DD", 2], "Do", "date"); +addRegexToken("D", match1to2, match1to2NoLeadingZero); +addRegexToken("DD", match1to2, match2); +addRegexToken("Do", function(isStrict, locale2) { + return isStrict ? locale2._dayOfMonthOrdinalParse || locale2._ordinalParse : locale2._dayOfMonthOrdinalParseLenient; +}); +addParseToken(["D", "DD"], DATE); +addParseToken("Do", function(input, array) { + array[DATE] = toInt(input.match(match1to2)[0]); +}); +var getSetDayOfMonth = makeGetSet("Date", true); +addFormatToken("DDD", ["DDDD", 3], "DDDo", "dayOfYear"); +addRegexToken("DDD", match1to3); +addRegexToken("DDDD", match3); +addParseToken(["DDD", "DDDD"], function(input, array, config) { + config._dayOfYear = toInt(input); +}); +function getSetDayOfYear(input) { + var dayOfYear = Math.round((this.clone().startOf("day") - this.clone().startOf("year")) / 864e5) + 1; + return input == null ? dayOfYear : this.add(input - dayOfYear, "d"); +} +addFormatToken("m", ["mm", 2], 0, "minute"); +addRegexToken("m", match1to2, match1to2HasZero); +addRegexToken("mm", match1to2, match2); +addParseToken(["m", "mm"], MINUTE); +var getSetMinute = makeGetSet("Minutes", false); +addFormatToken("s", ["ss", 2], 0, "second"); +addRegexToken("s", match1to2, match1to2HasZero); +addRegexToken("ss", match1to2, match2); +addParseToken(["s", "ss"], SECOND); +var getSetSecond = makeGetSet("Seconds", false); +addFormatToken("S", 0, 0, function() { + return ~~(this.millisecond() / 100); +}); +addFormatToken(0, ["SS", 2], 0, function() { + return ~~(this.millisecond() / 10); +}); +addFormatToken(0, ["SSS", 3], 0, "millisecond"); +addFormatToken(0, ["SSSS", 4], 0, function() { + return this.millisecond() * 10; +}); +addFormatToken(0, ["SSSSS", 5], 0, function() { + return this.millisecond() * 100; +}); +addFormatToken(0, ["SSSSSS", 6], 0, function() { + return this.millisecond() * 1e3; +}); +addFormatToken(0, ["SSSSSSS", 7], 0, function() { + return this.millisecond() * 1e4; +}); +addFormatToken(0, ["SSSSSSSS", 8], 0, function() { + return this.millisecond() * 1e5; +}); +addFormatToken(0, ["SSSSSSSSS", 9], 0, function() { + return this.millisecond() * 1e6; +}); +addRegexToken("S", match1to3, match1); +addRegexToken("SS", match1to3, match2); +addRegexToken("SSS", match1to3, match3); +var token, getSetMillisecond; +for (token = "SSSS"; token.length <= 9; token += "S") { + addRegexToken(token, matchUnsigned); +} +function parseMs(input, array) { + array[MILLISECOND] = toInt(("0." + input) * 1e3); +} +for (token = "S"; token.length <= 9; token += "S") { + addParseToken(token, parseMs); +} +getSetMillisecond = makeGetSet("Milliseconds", false); +addFormatToken("z", 0, 0, "zoneAbbr"); +addFormatToken("zz", 0, 0, "zoneName"); +function getZoneAbbr() { + return this._isUTC ? "UTC" : ""; +} +function getZoneName() { + return this._isUTC ? "Coordinated Universal Time" : ""; +} +var proto = Moment.prototype; +proto.add = add; +proto.calendar = calendar$1; +proto.clone = clone; +proto.diff = diff; +proto.endOf = endOf; +proto.format = format; +proto.from = from; +proto.fromNow = fromNow; +proto.to = to; +proto.toNow = toNow; +proto.get = stringGet; +proto.invalidAt = invalidAt; +proto.isAfter = isAfter; +proto.isBefore = isBefore; +proto.isBetween = isBetween; +proto.isSame = isSame; +proto.isSameOrAfter = isSameOrAfter; +proto.isSameOrBefore = isSameOrBefore; +proto.isValid = isValid$2; +proto.lang = lang; +proto.locale = locale; +proto.localeData = localeData; +proto.max = prototypeMax; +proto.min = prototypeMin; +proto.parsingFlags = parsingFlags; +proto.set = stringSet; +proto.startOf = startOf; +proto.subtract = subtract; +proto.toArray = toArray; +proto.toObject = toObject; +proto.toDate = toDate; +proto.toISOString = toISOString; +proto.inspect = inspect; +if (typeof Symbol !== "undefined" && Symbol.for != null) { + proto[Symbol.for("nodejs.util.inspect.custom")] = function() { + return "Moment<" + this.format() + ">"; + }; +} +proto.toJSON = toJSON; +proto.toString = toString; +proto.unix = unix; +proto.valueOf = valueOf; +proto.creationData = creationData; +proto.eraName = getEraName; +proto.eraNarrow = getEraNarrow; +proto.eraAbbr = getEraAbbr; +proto.eraYear = getEraYear; +proto.year = getSetYear; +proto.isLeapYear = getIsLeapYear; +proto.weekYear = getSetWeekYear; +proto.isoWeekYear = getSetISOWeekYear; +proto.quarter = proto.quarters = getSetQuarter; +proto.month = getSetMonth; +proto.daysInMonth = getDaysInMonth; +proto.week = proto.weeks = getSetWeek; +proto.isoWeek = proto.isoWeeks = getSetISOWeek; +proto.weeksInYear = getWeeksInYear; +proto.weeksInWeekYear = getWeeksInWeekYear; +proto.isoWeeksInYear = getISOWeeksInYear; +proto.isoWeeksInISOWeekYear = getISOWeeksInISOWeekYear; +proto.date = getSetDayOfMonth; +proto.day = proto.days = getSetDayOfWeek; +proto.weekday = getSetLocaleDayOfWeek; +proto.isoWeekday = getSetISODayOfWeek; +proto.dayOfYear = getSetDayOfYear; +proto.hour = proto.hours = getSetHour; +proto.minute = proto.minutes = getSetMinute; +proto.second = proto.seconds = getSetSecond; +proto.millisecond = proto.milliseconds = getSetMillisecond; +proto.utcOffset = getSetOffset; +proto.utc = setOffsetToUTC; +proto.local = setOffsetToLocal; +proto.parseZone = setOffsetToParsedOffset; +proto.hasAlignedHourOffset = hasAlignedHourOffset; +proto.isDST = isDaylightSavingTime; +proto.isLocal = isLocal; +proto.isUtcOffset = isUtcOffset; +proto.isUtc = isUtc; +proto.isUTC = isUtc; +proto.zoneAbbr = getZoneAbbr; +proto.zoneName = getZoneName; +proto.dates = deprecate("dates accessor is deprecated. Use date instead.", getSetDayOfMonth); +proto.months = deprecate("months accessor is deprecated. Use month instead", getSetMonth); +proto.years = deprecate("years accessor is deprecated. Use year instead", getSetYear); +proto.zone = deprecate("moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/", getSetZone); +proto.isDSTShifted = deprecate("isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information", isDaylightSavingTimeShifted); +function createUnix(input) { + return createLocal(input * 1e3); +} +function createInZone() { + return createLocal.apply(null, arguments).parseZone(); +} +function preParsePostFormat(string) { + return string; +} +var proto$1 = Locale.prototype; +proto$1.calendar = calendar; +proto$1.longDateFormat = longDateFormat; +proto$1.invalidDate = invalidDate; +proto$1.ordinal = ordinal; +proto$1.preparse = preParsePostFormat; +proto$1.postformat = preParsePostFormat; +proto$1.relativeTime = relativeTime; +proto$1.pastFuture = pastFuture; +proto$1.set = set; +proto$1.eras = localeEras; +proto$1.erasParse = localeErasParse; +proto$1.erasConvertYear = localeErasConvertYear; +proto$1.erasAbbrRegex = erasAbbrRegex; +proto$1.erasNameRegex = erasNameRegex; +proto$1.erasNarrowRegex = erasNarrowRegex; +proto$1.months = localeMonths; +proto$1.monthsShort = localeMonthsShort; +proto$1.monthsParse = localeMonthsParse; +proto$1.monthsRegex = monthsRegex; +proto$1.monthsShortRegex = monthsShortRegex; +proto$1.week = localeWeek; +proto$1.firstDayOfYear = localeFirstDayOfYear; +proto$1.firstDayOfWeek = localeFirstDayOfWeek; +proto$1.weekdays = localeWeekdays; +proto$1.weekdaysMin = localeWeekdaysMin; +proto$1.weekdaysShort = localeWeekdaysShort; +proto$1.weekdaysParse = localeWeekdaysParse; +proto$1.weekdaysRegex = weekdaysRegex; +proto$1.weekdaysShortRegex = weekdaysShortRegex; +proto$1.weekdaysMinRegex = weekdaysMinRegex; +proto$1.isPM = localeIsPM; +proto$1.meridiem = localeMeridiem; +function get$1(format2, index2, field, setter) { + var locale2 = getLocale(), utc = createUTC().set(setter, index2); + return locale2[field](utc, format2); +} +function listMonthsImpl(format2, index2, field) { + if (isNumber(format2)) { + index2 = format2; + format2 = void 0; + } + format2 = format2 || ""; + if (index2 != null) { + return get$1(format2, index2, field, "month"); + } + var i, out = []; + for (i = 0; i < 12; i++) { + out[i] = get$1(format2, i, field, "month"); + } + return out; +} +function listWeekdaysImpl(localeSorted, format2, index2, field) { + if (typeof localeSorted === "boolean") { + if (isNumber(format2)) { + index2 = format2; + format2 = void 0; + } + format2 = format2 || ""; + } else { + format2 = localeSorted; + index2 = format2; + localeSorted = false; + if (isNumber(format2)) { + index2 = format2; + format2 = void 0; + } + format2 = format2 || ""; + } + var locale2 = getLocale(), shift = localeSorted ? locale2._week.dow : 0, i, out = []; + if (index2 != null) { + return get$1(format2, (index2 + shift) % 7, field, "day"); + } + for (i = 0; i < 7; i++) { + out[i] = get$1(format2, (i + shift) % 7, field, "day"); + } + return out; +} +function listMonths(format2, index2) { + return listMonthsImpl(format2, index2, "months"); +} +function listMonthsShort(format2, index2) { + return listMonthsImpl(format2, index2, "monthsShort"); +} +function listWeekdays(localeSorted, format2, index2) { + return listWeekdaysImpl(localeSorted, format2, index2, "weekdays"); +} +function listWeekdaysShort(localeSorted, format2, index2) { + return listWeekdaysImpl(localeSorted, format2, index2, "weekdaysShort"); +} +function listWeekdaysMin(localeSorted, format2, index2) { + return listWeekdaysImpl(localeSorted, format2, index2, "weekdaysMin"); +} +getSetGlobalLocale("en", { + eras: [ + { + since: "0001-01-01", + until: Infinity, + offset: 1, + name: "Anno Domini", + narrow: "AD", + abbr: "AD" + }, + { + since: "0000-12-31", + until: -Infinity, + offset: 1, + name: "Before Christ", + narrow: "BC", + abbr: "BC" + } + ], + dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/, + ordinal: function(number) { + var b = number % 10, output = toInt(number % 100 / 10) === 1 ? "th" : b === 1 ? "st" : b === 2 ? "nd" : b === 3 ? "rd" : "th"; + return number + output; + } +}); +hooks.lang = deprecate("moment.lang is deprecated. Use moment.locale instead.", getSetGlobalLocale); +hooks.langData = deprecate("moment.langData is deprecated. Use moment.localeData instead.", getLocale); +var mathAbs = Math.abs; +function abs() { + var data = this._data; + this._milliseconds = mathAbs(this._milliseconds); + this._days = mathAbs(this._days); + this._months = mathAbs(this._months); + data.milliseconds = mathAbs(data.milliseconds); + data.seconds = mathAbs(data.seconds); + data.minutes = mathAbs(data.minutes); + data.hours = mathAbs(data.hours); + data.months = mathAbs(data.months); + data.years = mathAbs(data.years); + return this; +} +function addSubtract$1(duration, input, value, direction) { + var other = createDuration(input, value); + duration._milliseconds += direction * other._milliseconds; + duration._days += direction * other._days; + duration._months += direction * other._months; + return duration._bubble(); +} +function add$1(input, value) { + return addSubtract$1(this, input, value, 1); +} +function subtract$1(input, value) { + return addSubtract$1(this, input, value, -1); +} +function absCeil(number) { + if (number < 0) { + return Math.floor(number); + } else { + return Math.ceil(number); + } +} +function bubble() { + var milliseconds2 = this._milliseconds, days2 = this._days, months2 = this._months, data = this._data, seconds2, minutes2, hours2, years2, monthsFromDays; + if (!(milliseconds2 >= 0 && days2 >= 0 && months2 >= 0 || milliseconds2 <= 0 && days2 <= 0 && months2 <= 0)) { + milliseconds2 += absCeil(monthsToDays(months2) + days2) * 864e5; + days2 = 0; + months2 = 0; + } + data.milliseconds = milliseconds2 % 1e3; + seconds2 = absFloor(milliseconds2 / 1e3); + data.seconds = seconds2 % 60; + minutes2 = absFloor(seconds2 / 60); + data.minutes = minutes2 % 60; + hours2 = absFloor(minutes2 / 60); + data.hours = hours2 % 24; + days2 += absFloor(hours2 / 24); + monthsFromDays = absFloor(daysToMonths(days2)); + months2 += monthsFromDays; + days2 -= absCeil(monthsToDays(monthsFromDays)); + years2 = absFloor(months2 / 12); + months2 %= 12; + data.days = days2; + data.months = months2; + data.years = years2; + return this; +} +function daysToMonths(days2) { + return days2 * 4800 / 146097; +} +function monthsToDays(months2) { + return months2 * 146097 / 4800; +} +function as(units) { + if (!this.isValid()) { + return NaN; + } + var days2, months2, milliseconds2 = this._milliseconds; + units = normalizeUnits(units); + if (units === "month" || units === "quarter" || units === "year") { + days2 = this._days + milliseconds2 / 864e5; + months2 = this._months + daysToMonths(days2); + switch (units) { + case "month": + return months2; + case "quarter": + return months2 / 3; + case "year": + return months2 / 12; + } + } else { + days2 = this._days + Math.round(monthsToDays(this._months)); + switch (units) { + case "week": + return days2 / 7 + milliseconds2 / 6048e5; + case "day": + return days2 + milliseconds2 / 864e5; + case "hour": + return days2 * 24 + milliseconds2 / 36e5; + case "minute": + return days2 * 1440 + milliseconds2 / 6e4; + case "second": + return days2 * 86400 + milliseconds2 / 1e3; + case "millisecond": + return Math.floor(days2 * 864e5) + milliseconds2; + default: + throw new Error("Unknown unit " + units); + } + } +} +function makeAs(alias) { + return function() { + return this.as(alias); + }; +} +var asMilliseconds = makeAs("ms"), asSeconds = makeAs("s"), asMinutes = makeAs("m"), asHours = makeAs("h"), asDays = makeAs("d"), asWeeks = makeAs("w"), asMonths = makeAs("M"), asQuarters = makeAs("Q"), asYears = makeAs("y"), valueOf$1 = asMilliseconds; +function clone$1() { + return createDuration(this); +} +function get$2(units) { + units = normalizeUnits(units); + return this.isValid() ? this[units + "s"]() : NaN; +} +function makeGetter(name) { + return function() { + return this.isValid() ? this._data[name] : NaN; + }; +} +var milliseconds = makeGetter("milliseconds"), seconds = makeGetter("seconds"), minutes = makeGetter("minutes"), hours = makeGetter("hours"), days = makeGetter("days"), months = makeGetter("months"), years = makeGetter("years"); +function weeks() { + return absFloor(this.days() / 7); +} +var round = Math.round, thresholds = { + ss: 44, + s: 45, + m: 45, + h: 22, + d: 26, + w: null, + M: 11 +}; +function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale2) { + return locale2.relativeTime(number || 1, !!withoutSuffix, string, isFuture); +} +function relativeTime$1(posNegDuration, withoutSuffix, thresholds2, locale2) { + var duration = createDuration(posNegDuration).abs(), seconds2 = round(duration.as("s")), minutes2 = round(duration.as("m")), hours2 = round(duration.as("h")), days2 = round(duration.as("d")), months2 = round(duration.as("M")), weeks2 = round(duration.as("w")), years2 = round(duration.as("y")), a = seconds2 <= thresholds2.ss && ["s", seconds2] || seconds2 < thresholds2.s && ["ss", seconds2] || minutes2 <= 1 && ["m"] || minutes2 < thresholds2.m && ["mm", minutes2] || hours2 <= 1 && ["h"] || hours2 < thresholds2.h && ["hh", hours2] || days2 <= 1 && ["d"] || days2 < thresholds2.d && ["dd", days2]; + if (thresholds2.w != null) { + a = a || weeks2 <= 1 && ["w"] || weeks2 < thresholds2.w && ["ww", weeks2]; + } + a = a || months2 <= 1 && ["M"] || months2 < thresholds2.M && ["MM", months2] || years2 <= 1 && ["y"] || ["yy", years2]; + a[2] = withoutSuffix; + a[3] = +posNegDuration > 0; + a[4] = locale2; + return substituteTimeAgo.apply(null, a); +} +function getSetRelativeTimeRounding(roundingFunction) { + if (roundingFunction === void 0) { + return round; + } + if (typeof roundingFunction === "function") { + round = roundingFunction; + return true; + } + return false; +} +function getSetRelativeTimeThreshold(threshold, limit) { + if (thresholds[threshold] === void 0) { + return false; + } + if (limit === void 0) { + return thresholds[threshold]; + } + thresholds[threshold] = limit; + if (threshold === "s") { + thresholds.ss = limit - 1; + } + return true; +} +function humanize(argWithSuffix, argThresholds) { + if (!this.isValid()) { + return this.localeData().invalidDate(); + } + var withSuffix = false, th = thresholds, locale2, output; + if (typeof argWithSuffix === "object") { + argThresholds = argWithSuffix; + argWithSuffix = false; + } + if (typeof argWithSuffix === "boolean") { + withSuffix = argWithSuffix; + } + if (typeof argThresholds === "object") { + th = Object.assign({}, thresholds, argThresholds); + if (argThresholds.s != null && argThresholds.ss == null) { + th.ss = argThresholds.s - 1; + } + } + locale2 = this.localeData(); + output = relativeTime$1(this, !withSuffix, th, locale2); + if (withSuffix) { + output = locale2.pastFuture(+this, output); + } + return locale2.postformat(output); +} +var abs$1 = Math.abs; +function sign(x) { + return (x > 0) - (x < 0) || +x; +} +function toISOString$1() { + if (!this.isValid()) { + return this.localeData().invalidDate(); + } + var seconds2 = abs$1(this._milliseconds) / 1e3, days2 = abs$1(this._days), months2 = abs$1(this._months), minutes2, hours2, years2, s, total = this.asSeconds(), totalSign, ymSign, daysSign, hmsSign; + if (!total) { + return "P0D"; + } + minutes2 = absFloor(seconds2 / 60); + hours2 = absFloor(minutes2 / 60); + seconds2 %= 60; + minutes2 %= 60; + years2 = absFloor(months2 / 12); + months2 %= 12; + s = seconds2 ? seconds2.toFixed(3).replace(/\.?0+$/, "") : ""; + totalSign = total < 0 ? "-" : ""; + ymSign = sign(this._months) !== sign(total) ? "-" : ""; + daysSign = sign(this._days) !== sign(total) ? "-" : ""; + hmsSign = sign(this._milliseconds) !== sign(total) ? "-" : ""; + return totalSign + "P" + (years2 ? ymSign + years2 + "Y" : "") + (months2 ? ymSign + months2 + "M" : "") + (days2 ? daysSign + days2 + "D" : "") + (hours2 || minutes2 || seconds2 ? "T" : "") + (hours2 ? hmsSign + hours2 + "H" : "") + (minutes2 ? hmsSign + minutes2 + "M" : "") + (seconds2 ? hmsSign + s + "S" : ""); +} +var proto$2 = Duration.prototype; +proto$2.isValid = isValid$1; +proto$2.abs = abs; +proto$2.add = add$1; +proto$2.subtract = subtract$1; +proto$2.as = as; +proto$2.asMilliseconds = asMilliseconds; +proto$2.asSeconds = asSeconds; +proto$2.asMinutes = asMinutes; +proto$2.asHours = asHours; +proto$2.asDays = asDays; +proto$2.asWeeks = asWeeks; +proto$2.asMonths = asMonths; +proto$2.asQuarters = asQuarters; +proto$2.asYears = asYears; +proto$2.valueOf = valueOf$1; +proto$2._bubble = bubble; +proto$2.clone = clone$1; +proto$2.get = get$2; +proto$2.milliseconds = milliseconds; +proto$2.seconds = seconds; +proto$2.minutes = minutes; +proto$2.hours = hours; +proto$2.days = days; +proto$2.weeks = weeks; +proto$2.months = months; +proto$2.years = years; +proto$2.humanize = humanize; +proto$2.toISOString = toISOString$1; +proto$2.toString = toISOString$1; +proto$2.toJSON = toISOString$1; +proto$2.locale = locale; +proto$2.localeData = localeData; +proto$2.toIsoString = deprecate("toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)", toISOString$1); +proto$2.lang = lang; +addFormatToken("X", 0, 0, "unix"); +addFormatToken("x", 0, 0, "valueOf"); +addRegexToken("x", matchSigned); +addRegexToken("X", matchTimestamp); +addParseToken("X", function(input, array, config) { + config._d = new Date(parseFloat(input) * 1e3); +}); +addParseToken("x", function(input, array, config) { + config._d = new Date(toInt(input)); +}); +//! moment.js +hooks.version = "2.30.1"; +setHookCallback(createLocal); +hooks.fn = proto; +hooks.min = min; +hooks.max = max; +hooks.now = now; +hooks.utc = createUTC; +hooks.unix = createUnix; +hooks.months = listMonths; +hooks.isDate = isDate; +hooks.locale = getSetGlobalLocale; +hooks.invalid = createInvalid; +hooks.duration = createDuration; +hooks.isMoment = isMoment; +hooks.weekdays = listWeekdays; +hooks.parseZone = createInZone; +hooks.localeData = getLocale; +hooks.isDuration = isDuration; +hooks.monthsShort = listMonthsShort; +hooks.weekdaysMin = listWeekdaysMin; +hooks.defineLocale = defineLocale; +hooks.updateLocale = updateLocale; +hooks.locales = listLocales; +hooks.weekdaysShort = listWeekdaysShort; +hooks.normalizeUnits = normalizeUnits; +hooks.relativeTimeRounding = getSetRelativeTimeRounding; +hooks.relativeTimeThreshold = getSetRelativeTimeThreshold; +hooks.calendarFormat = getCalendarFormat; +hooks.prototype = proto; +hooks.HTML5_FMT = { + DATETIME_LOCAL: "YYYY-MM-DDTHH:mm", + DATETIME_LOCAL_SECONDS: "YYYY-MM-DDTHH:mm:ss", + DATETIME_LOCAL_MS: "YYYY-MM-DDTHH:mm:ss.SSS", + DATE: "YYYY-MM-DD", + TIME: "HH:mm", + TIME_SECONDS: "HH:mm:ss", + TIME_MS: "HH:mm:ss.SSS", + WEEK: "GGGG-[W]WW", + MONTH: "YYYY-MM" +}; +exports._export_sfc = _export_sfc; +exports.computed$1 = computed$1; +exports.createSSRApp = createSSRApp; +exports.e = e; +exports.f = f; +exports.hooks = hooks; +exports.index = index; +exports.n = n; +exports.nextTick = nextTick; +exports.o = o; +exports.onLoad = onLoad; +exports.onMounted = onMounted; +exports.onShow = onShow; +exports.onUnmounted = onUnmounted; +exports.reactive = reactive; +exports.ref = ref; +exports.t = t; +exports.toRefs = toRefs; +exports.unref = unref; diff --git a/config/index.js b/config/index.js new file mode 100644 index 0000000..2c78cdb --- /dev/null +++ b/config/index.js @@ -0,0 +1,13 @@ +"use strict"; +const base_url = "https://takway-ai.top:8002"; +const base_url_other = "https://takway-ai.top:8001"; +const filePrefix = "https://takway-ai.top:8002/api/files/"; +const defaultAvatar = "e3672124045f11ef817ba036bc278b4c"; +const wsUrl = "wss://takway-ai.top:8001/chat/streaming/lasting"; +const wsVoiceCallUrl = "wss://takway-ai.top:8001/chat/voice_call"; +exports.base_url = base_url; +exports.base_url_other = base_url_other; +exports.defaultAvatar = defaultAvatar; +exports.filePrefix = filePrefix; +exports.wsUrl = wsUrl; +exports.wsVoiceCallUrl = wsVoiceCallUrl; diff --git a/kongshuju.js b/kongshuju.js new file mode 100644 index 0000000..9c8524f --- /dev/null +++ b/kongshuju.js @@ -0,0 +1,3 @@ +"use strict"; +var _imports_1 = "/static/image/kongshuju.png"; +exports._imports_1 = _imports_1; diff --git a/pages/bluetooth/connect.js b/pages/bluetooth/connect.js new file mode 100644 index 0000000..777fe56 --- /dev/null +++ b/pages/bluetooth/connect.js @@ -0,0 +1,140 @@ +"use strict"; +var common_vendor = require("../../common/vendor.js"); +var utils_bluetooth = require("../../utils/bluetooth.js"); +const _sfc_main = { + setup(__props) { + const deviceId = common_vendor.ref(""); + common_vendor.onLoad((option) => { + deviceId.value = option.deviceId; + }); + const ssid = common_vendor.ref(""); + const rememberWifi = common_vendor.ref(false); + const password = common_vendor.ref(""); + const onCheckboxChange = (event) => { + rememberWifi.value = !rememberWifi.value; + }; + common_vendor.ref(""); + const serviceUUIDSamll = common_vendor.ref(""); + const notifyCharacteristicId = common_vendor.ref(""); + const writeCharacteristicId = common_vendor.ref(""); + const stringToBytes = (str) => { + var array = new Uint8Array(str.length); + for (var i = 0, l = str.length; i < l; i++) { + array[i] = str.charCodeAt(i); + } + console.log(array); + return array.buffer; + }; + const connect = async () => { + ssid.value = ssid.value.trim(); + password.value = password.value.trim(); + if (ssid.value === "") { + wx.showToast({ + title: "WiFi\u4FE1\u606F\u83B7\u53D6\u5931\u8D25", + icon: "none", + duration: 2e3 + }); + return; + } + if (password.value === "") { + wx.showToast({ + title: "\u8BF7\u8F93\u5165\u5BC6\u7801", + icon: "none", + duration: 2e3 + }); + return; + } + if (rememberWifi.value) { + common_vendor.index.setStorage({ + key: ssid.value, + data: password.value + }); + } else { + common_vendor.index.removeStorage({ + key: ssid.value + }); + } + res = await utils_bluetooth.getBLEDeviceServices(that.data.deviceId); + for (let i2 = 0; i2 < res.services.length; i2++) { + if (res.services[i2].uuid.toUpperCase().indexOf(serviceUUIDSamll.value) != -1) { + console.log("\u670D\u52A1\u5DF2\u627E\u5230"); + serviceId.value = res.services[i2].uuid; + break; + } + } + console.log("\u5DF2\u83B7\u53D6\u8FDE\u63A5\u8BBE\u5907\u7684service\u670D\u52A1"); + res = await utils_bluetooth.getBLEDeviceCharacteristics(deviceId.value, serviceId.value); + for (var i = 0; i < res.characteristics.length; i++) { + console.log("\u83B7\u53D6\u5230\u7684\u7279\u5F81\u503Cid:" + res.characteristics[i].uuid); + if (res.characteristics[i].properties.notify) { + console.log("\u5F00\u542Fnotify\u7684characteristicId:" + res.characteristics[i].uuid); + notifyCharacteristicId.value = res.characteristics[i].uuid; + } + if (res.characteristics[i].properties.write) { + console.log("\u5F00\u542Fwrite\u7684characteristicId:" + res.characteristics[i].uuid); + writeCharacteristicId.value = res.characteristics[i].uuid; + } + } + console.log("\u5DF2\u83B7\u53D6\u8FDE\u63A5\u8BBE\u5907\u5177\u6709\u8BFB\u5199\u529F\u80FD\u670D\u52A1\u7684\u6240\u6709\u7279\u5F81\u503C"); + res = await utils_bluetooth.notifyBLECharacteristicValueChange(deviceId.value, serviceId.value, notifyCharacteristicId.value); + console.log("\u5DF2\u542F\u52A8\u84DD\u7259\u7279\u5F81\u503C\u53D8\u5316"); + const data = { + type: 0, + data: { + ssid: ssid.value, + passwd: password.value + } + }; + let buffer = stringToBytes(JSON.stringify(data)); + res = await utils_bluetooth.writeBLECharacteristicValue(deviceId.value, serviceId.value, writeCharacteristicId.value, buffer); + console.log("\u5DF2\u53D1\u9001\u6570\u636E"); + res = await utils_bluetooth.closeBluetoothAdapter(); + }; + common_vendor.onMounted(() => { + wx.startWifi({ + success(res2) { + wx.getConnectedWifi({ + partialInfo: true, + success(res3) { + ssid.value = res3.wifi.SSID; + common_vendor.index.getStorage({ + key: ssid.value, + success: function(res4) { + password.value = res4.data; + } + }); + }, + fail(res3) { + wx.showToast({ + title: "WiFi\u4FE1\u606F\u83B7\u53D6\u5931\u8D25", + icon: "none", + duration: 2e3 + }); + return; + } + }); + }, + fail() { + wx.showToast({ + title: "WiFi\u6A21\u5757\u521D\u59CB\u5316\u5931\u8D25", + icon: "none", + duration: 2e3 + }); + return; + } + }); + }); + return (_ctx, _cache) => { + return { + a: common_vendor.t(ssid.value), + b: password.value, + c: common_vendor.o(($event) => password.value = $event.detail.value), + d: common_vendor.o(onCheckboxChange), + e: common_vendor.n(rememberWifi.value ? "radio iconfont icon-gou" : "radio"), + f: common_vendor.o(connect) + }; + }; + } +}; +var MiniProgramPage = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-1665ba40"], ["__file", "C:/Users/bzm15/Desktop/ix/mini_web-develop/pages/bluetooth/connect.vue"]]); +wx.createPage(MiniProgramPage); diff --git a/pages/bluetooth/connect.json b/pages/bluetooth/connect.json new file mode 100644 index 0000000..a0812ee --- /dev/null +++ b/pages/bluetooth/connect.json @@ -0,0 +1,4 @@ +{ + "navigationBarTitleText": "", + "usingComponents": {} +} \ No newline at end of file diff --git a/pages/bluetooth/connect.wxml b/pages/bluetooth/connect.wxml new file mode 100644 index 0000000..a89fa95 --- /dev/null +++ b/pages/bluetooth/connect.wxml @@ -0,0 +1 @@ +给萌主连网{{a}}记住WiFi密码连接 \ No newline at end of file diff --git a/pages/bluetooth/connect.wxss b/pages/bluetooth/connect.wxss new file mode 100644 index 0000000..2a33acb --- /dev/null +++ b/pages/bluetooth/connect.wxss @@ -0,0 +1,117 @@ + +.container.data-v-1665ba40 { + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; +} +.title.data-v-1665ba40 { + top: 15%; + width: 142.63px; + height: 22.32px; + opacity: 1; + color: rgba(0, 0, 0, 1); + text-align: center; + font-weight: 500; + font-size: 20px; + position: absolute; +} +.uni-picker.data-v-1665ba40 { + margin-bottom: 20px; + padding: 10px; + border: none; + border-radius: 10px; +} +.group-ssid.data-v-1665ba40 { + display: flex; + align-items: center; + justify-content: flex-start; + height: 34px; + width: 200px; + top: 25%; + position: absolute; +} +.group.data-v-1665ba40 { + display: flex; + align-items: center; + justify-content: flex-start; + height: 34px; + width: 150px; + top: 35%; + position: absolute; +} +.group-password.data-v-1665ba40 { + display: flex; + align-items: center; + justify-content: flex-start; + background: rgba(245, 245, 247, 1); + border-radius: 18.5px; + height: 34px; + width: 200px; + top: 30%; + position: absolute; +} +.icon.data-v-1665ba40 { + margin-left: 15px; + margin-right: 15px; +} +.text.data-v-1665ba40 { + margin-right: 5px; +} +.button.data-v-1665ba40 { + width: 70%; + height: 47px; + opacity: 1; + border-radius: 23.5px; + border: 0px; + line-height: 47px; + text-align: center; + position: absolute; + top: 50%; + color: rgba(255, 255, 255, 1); + background: linear-gradient(90deg, rgba(255, 153, 71, 1) 0%, rgba(242, 52, 255, 1) 25.19%, rgba(34, 8, 228, 1) 79.99%, rgba(51, 204, 255, 1) 100%); +} +.checkbox.data-v-1665ba40 { + width: 12px; + /* 设置复选框的宽度 */ + height: 12px; + /* 设置复选框的高度 */ + border: 1px solid rgba(128, 128, 128, 1); + /* 设置复选框的边框 */ + border-radius: 50%; + /* 设置复选框为圆形 */ + display: flex; + justify-content: center; + align-items: center; + font-size: 10px; + /* 根据需要调整勾号大小 */ + margin-left: 10px; + margin-right: 10px; +} +.checkmark.data-v-1665ba40 { + color: rgba(128, 128, 128, 1); + /* 设置勾号的颜色 */ +} +.remember-wifi-label.data-v-1665ba40 { + font-size: 10px; + color: rgba(128, 128, 128, 1); + /* 设置勾号的颜色 */ +} +.group .radio.data-v-1665ba40 { + position: relative; + margin-right: 4px; + display: inline-block; + width: 12px; + height: 12px; + box-sizing: border-box; + border: 1px solid rgba(128, 128, 128, 1); + border-radius: 50%; + font-size: 12px; + text-align: center; + line-height: 12px; + color: rgba(128, 128, 128, 1); + font-size: 10px; + /* 根据需要调整勾号大小 */ + margin-left: 10px; + margin-right: 10px; +} diff --git a/pages/bluetooth/device.js b/pages/bluetooth/device.js new file mode 100644 index 0000000..8d5f57e --- /dev/null +++ b/pages/bluetooth/device.js @@ -0,0 +1,43 @@ +"use strict"; +var common_vendor = require("../../common/vendor.js"); +const _sfc_main = { + setup(__props) { + common_vendor.onLoad((option) => { + console.log(option); + deviceId.value = option.deviceId; + deviceName.value = option.name; + }); + const deviceId = common_vendor.ref(""); + const deviceName = common_vendor.ref(""); + const ignoreTheDevice = () => { + wx.closeBLEConnection({ + deviceId: deviceId.value + }); + common_vendor.index.navigateBack({ + delta: 1 + }); + }; + const startConnect = () => { + common_vendor.index.navigateTo({ + url: "/pages/bluetooth/connect?deviceId=" + deviceId + }); + if (deviceId.value) + ; + }; + const goSelectBluetooth = () => { + common_vendor.index.navigateBack({ + delta: 1 + }); + }; + return (_ctx, _cache) => { + return { + a: common_vendor.t(deviceName.value != "" ? deviceName.value : deviceId.value), + b: common_vendor.o(goSelectBluetooth), + c: common_vendor.o(startConnect), + d: common_vendor.o(ignoreTheDevice) + }; + }; + } +}; +var MiniProgramPage = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-2ad235d0"], ["__file", "C:/Users/bzm15/Desktop/ix/mini_web-develop/pages/bluetooth/device.vue"]]); +wx.createPage(MiniProgramPage); diff --git a/pages/bluetooth/device.json b/pages/bluetooth/device.json new file mode 100644 index 0000000..a0812ee --- /dev/null +++ b/pages/bluetooth/device.json @@ -0,0 +1,4 @@ +{ + "navigationBarTitleText": "", + "usingComponents": {} +} \ No newline at end of file diff --git a/pages/bluetooth/device.wxml b/pages/bluetooth/device.wxml new file mode 100644 index 0000000..7e81bb6 --- /dev/null +++ b/pages/bluetooth/device.wxml @@ -0,0 +1 @@ +发现以下设备{{a}}开始连网忽略该设备 \ No newline at end of file diff --git a/pages/bluetooth/device.wxss b/pages/bluetooth/device.wxss new file mode 100644 index 0000000..c5446a2 --- /dev/null +++ b/pages/bluetooth/device.wxss @@ -0,0 +1,67 @@ + +.container.data-v-2ad235d0 { + display: flex; + flex-direction: column; + align-items: center; + justify-content: center; +} +.title.data-v-2ad235d0 { + top: 15%; + width: 142.63px; + height: 22.32px; + opacity: 1; + color: rgba(0, 0, 0, 1); + text-align: center; + font-weight: 500; + font-size: 20px; + position: absolute; +} +.image.data-v-2ad235d0 { + top: 15%; + opacity: 1; + width: 29%; + position: absolute; +} +.description.data-v-2ad235d0 { + display: flex; + justify-content: space-between; + align-items: center; + top: 42%; + height: 12.98px; + opacity: 1; + color: rgba(0, 0, 0, 1); + font-weight: 600; + position: absolute; +} +.text.data-v-2ad235d0 { + line-height: 10px; + height: 11.27px; + margin-right: 10px; +} +.icon.data-v-2ad235d0 { + font-size: 12px; + color: rgba(0, 0, 0, 1); +} +.button.data-v-2ad235d0 { + width: 70%; + height: 47px; + opacity: 1; + border-radius: 23.5px; + border: 0px; + line-height: 47px; + text-align: center; + position: absolute; +} +.color1.data-v-2ad235d0 { + position: absolute; + top: 50%; + color: rgba(255, 255, 255, 1); + background: linear-gradient(270deg, rgba(255, 153, 71, 1) 0%, rgba(242, 52, 255, 1) 57.29%, rgba(243, 64, 125, 1) 83.14%, rgba(243, 67, 98, 1) 100%); +} +.color2.data-v-2ad235d0 { + position: absolute; + top:58%; + color: rgba(52, 152, 255, 1); + background: rgba(204, 230, 255, 1); + font-size: 12px; +} diff --git a/pages/bluetooth/index.js b/pages/bluetooth/index.js new file mode 100644 index 0000000..5a2b07e --- /dev/null +++ b/pages/bluetooth/index.js @@ -0,0 +1,112 @@ +"use strict"; +var common_vendor = require("../../common/vendor.js"); +const _sfc_main = { + setup(__props) { + common_vendor.onMounted(() => { + openBluetoothAdapter(); + }); + common_vendor.onUnmounted(() => { + if (discoveryStarted.value) { + stopBluetoothDevicesDiscovery(); + } + }); + const bluetoothDevices = common_vendor.reactive([]); + const ignoreDevices = common_vendor.reactive([]); + let discoveryStarted = common_vendor.ref(false); + let showLoading = common_vendor.ref(true); + const openBluetoothAdapter = () => { + wx.openBluetoothAdapter({ + success: (res) => { + console.log("openBluetoothAdapter success", res); + startBluetoothDevicesDiscovery(); + }, + fail: (res) => { + console.log(res); + if (res.errCode === 10001) { + wx.onBluetoothAdapterStateChange(function(res2) { + console.log("onBluetoothAdapterStateChange", res2); + if (res2.available) { + startBluetoothDevicesDiscovery(); + } + }); + } + } + }); + }; + const startBluetoothDevicesDiscovery = () => { + if (discoveryStarted.value) { + return; + } + discoveryStarted.value = true; + wx.startBluetoothDevicesDiscovery({ + success: (res) => { + console.log("startBluetoothDevicesDiscovery success", res); + onBluetoothDeviceFound(); + }, + fail: (err) => { + discoveryStarted.value = false; + wx.showToast({ + title: "\u5F00\u542F\u641C\u7D22\u5931\u8D25", + icon: "none", + duration: 2e3 + }); + console.error("\u5F00\u542F\u84DD\u7259\u8BBE\u5907\u641C\u7D22\u5931\u8D25", err); + } + }); + }; + const onBluetoothDeviceFound = () => { + wx.onBluetoothDeviceFound((res) => { + showLoading.value = false; + res.devices.forEach((device) => { + console.log(device); + if (device.RSSI > -80 && !bluetoothDevices.some((d) => d.deviceId === device.deviceId) && !ignoreDevices.includes(device.deviceId)) { + bluetoothDevices.push(device); + } + }); + }); + }; + const createBLEConnection = (device) => { + stopBluetoothDevicesDiscovery(); + wx.showLoading({ + title: "\u8FDE\u63A5\u4E2D..." + }); + wx.createBLEConnection({ + deviceId: device.deviceId, + success(res) { + wx.hideLoading(); + common_vendor.index.navigateTo({ + url: "/pages/bluetooth/device?deviceId=" + device.deviceId + "&name=" + device.name + }); + }, + fail() { + wx.hideLoading(); + wx.showToast({ + title: "\u84DD\u7259\u8FDE\u63A5\u5931\u8D25", + icon: "none", + duration: 2e3 + }); + return; + } + }); + }; + const stopBluetoothDevicesDiscovery = () => { + wx.stopBluetoothDevicesDiscovery(); + }; + return (_ctx, _cache) => { + return common_vendor.e({ + a: common_vendor.unref(showLoading) + }, common_vendor.unref(showLoading) ? {} : { + b: common_vendor.o(startBluetoothDevicesDiscovery), + c: common_vendor.f(common_vendor.unref(bluetoothDevices), (device, index, i0) => { + return { + a: common_vendor.t(device.name || device.deviceId), + b: index, + c: common_vendor.o(($event) => createBLEConnection(device)) + }; + }) + }); + }; + } +}; +var MiniProgramPage = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-0e0dc370"], ["__file", "C:/Users/bzm15/Desktop/ix/mini_web-develop/pages/bluetooth/index.vue"]]); +wx.createPage(MiniProgramPage); diff --git a/pages/bluetooth/index.json b/pages/bluetooth/index.json new file mode 100644 index 0000000..a0812ee --- /dev/null +++ b/pages/bluetooth/index.json @@ -0,0 +1,4 @@ +{ + "navigationBarTitleText": "", + "usingComponents": {} +} \ No newline at end of file diff --git a/pages/bluetooth/index.wxml b/pages/bluetooth/index.wxml new file mode 100644 index 0000000..3d43c2d --- /dev/null +++ b/pages/bluetooth/index.wxml @@ -0,0 +1 @@ +正在寻找萌主选择附近的蓝牙设备{{device.a}} \ No newline at end of file diff --git a/pages/bluetooth/index.wxss b/pages/bluetooth/index.wxss new file mode 100644 index 0000000..dfea857 --- /dev/null +++ b/pages/bluetooth/index.wxss @@ -0,0 +1,109 @@ + +.container.data-v-0e0dc370 { + padding: 10px; +} +.header.data-v-0e0dc370 { + margin-bottom: 10px; + opacity: 1; + height: 40px; + text-align: center; +} +.header-text.data-v-0e0dc370 { + font-size: 12px; + font-weight: 400; + letter-spacing: 0px; + height: 17.38px; + line-height: 40px; + color: rgba(52, 152, 255, 1); + background: rgba(204, 230, 255, 1); + border-radius: 23.5px; + box-shadow: 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05); + padding: 11.31px; +} +.device-list.data-v-0e0dc370 { + display: flex; + flex-direction: column; +} +.scroll-view.data-v-0e0dc370 { + width: 100%; + height: 100%; + /* 或者设置一个固定高度，例如：300px */ +} +.device-item.data-v-0e0dc370 { + display: flex; + align-items: center; + justify-content: flex-start; + padding: 5px; + margin-bottom: 10px; + border: 1px solid #cccccc; + /* 按钮边框色 */ + border-radius: 20px; + /* 按钮圆角 */ + box-shadow: 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05); + background: rgba(255, 255, 255, 1); + height: 30px; +} +.device-icon.data-v-0e0dc370 { + width: 20px; + /* 图标宽度 */ + height: 20px; + /* 图标高度 */ + margin-right: 10px; + /* 图标与文字之间的间距 */ + opacity: 1; + background: whitesmoke; + border-radius: 25px; + padding: 5px; +} +.device-text.data-v-0e0dc370 { + flex: 1; + /* 让文字占据剩余空间 */ + font-size: 16px; + /* 文字大小 */ + color: #333333; + /* 文字颜色 */ +} +.loading-model.data-v-0e0dc370 { + position: absolute; + z-index: 2000; + top: 0; + left: 0; + width: 100%; + height: 100%; +} +.lm-box.data-v-0e0dc370 { + display: flex; + flex-direction: column; + justify-content: center; + align-items: center; + width: 360rpx; + height: 260rpx; + border-radius: 16rpx; + background-color: rgba(0, 0, 0, 0.7); + position: absolute; + top: 34%; + left: calc(50% - 180rpx); +} +.loading-title.data-v-0e0dc370{ + font-size: 28rpx; + margin-top: 24rpx; + color: rgba(255,255,255,0.8); + font-weight: 500; +} +.loading.data-v-0e0dc370 { + width: 80rpx; + height: 80rpx; + display: inline-block; + vertical-align: middle; + animation: loading-0e0dc370 1s steps(30) infinite; + background: transparent url(data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="61" height="61" viewBox="0 0 61 61" fill="none">
<path d="M30.5 2.85938C32.4062 2.85938 33.3594 3.8125 33.3594 5.71875L33.3594 14.2969C33.3594 16.2031 32.4062 17.1562 30.5 17.1562C28.5938 17.1562 27.6406 16.2031 27.6406 14.2969L27.6406 5.71875C27.6406 3.8125 28.5938 2.85938 30.5 2.85938Z"   fill="#F5F5F5" >
</path>
<path d="M30.5 42.8907C32.4062 42.8907 33.3594 43.8438 33.3594 45.75L33.3594 54.3281C33.3594 56.2344 32.4062 57.1875 30.5 57.1875C28.5938 57.1875 27.6406 56.2344 27.6406 54.3281L27.6406 45.75C27.6406 43.8438 28.5938 42.8907 30.5 42.8907Z"   fill="#BFBFBF" >
</path>
<path d="M57.6641 30.0234C57.6641 30.0702 57.6629 30.117 57.6606 30.1637C57.6583 30.2105 57.6549 30.2571 57.6503 30.3037C57.6457 30.3503 57.6399 30.3967 57.6331 30.443C57.6262 30.4893 57.6182 30.5354 57.6091 30.5813C57.6 30.6272 57.5897 30.6728 57.5783 30.7182C57.567 30.7636 57.5545 30.8087 57.5409 30.8535C57.5273 30.8982 57.5127 30.9427 57.4969 30.9867C57.4811 31.0308 57.4643 31.0744 57.4464 31.1177C57.4285 31.1609 57.4095 31.2037 57.3895 31.246C57.3695 31.2883 57.3485 31.3301 57.3264 31.3713C57.3044 31.4126 57.2813 31.4533 57.2572 31.4935C57.2332 31.5336 57.2082 31.5731 57.1822 31.612C57.1562 31.6509 57.1292 31.6892 57.1014 31.7268C57.0735 31.7644 57.0447 31.8012 57.015 31.8374C56.9853 31.8736 56.9548 31.909 56.9234 31.9437C56.8919 31.9784 56.8596 32.0122 56.8266 32.0453C56.7935 32.0784 56.7596 32.1107 56.7249 32.1421C56.6903 32.1735 56.6548 32.2041 56.6187 32.2337C56.5825 32.2634 56.5456 32.2922 56.508 32.3201C56.4704 32.348 56.4321 32.3749 56.3932 32.4009C56.3543 32.4269 56.3148 32.4519 56.2747 32.476C56.2345 32.5001 56.1939 32.5231 56.1526 32.5452C56.1113 32.5672 56.0695 32.5883 56.0272 32.6082C55.9849 32.6283 55.9421 32.6472 55.8989 32.6651C55.8557 32.6831 55.812 32.6999 55.768 32.7157C55.7239 32.7314 55.6795 32.7461 55.6347 32.7597C55.5899 32.7733 55.5448 32.7858 55.4994 32.7971C55.4541 32.8085 55.4084 32.8188 55.3625 32.8279C55.3166 32.837 55.2705 32.845 55.2242 32.8518C55.1779 32.8587 55.1315 32.8644 55.085 32.869C55.0384 32.8736 54.9917 32.877 54.945 32.8794C54.8982 32.8817 54.8514 32.8828 54.8047 32.8828L46.2266 32.8828C46.1798 32.8828 46.133 32.8817 46.0863 32.8794C46.0395 32.877 45.9929 32.8736 45.9463 32.869C45.8997 32.8644 45.8533 32.8587 45.807 32.8518C45.7607 32.845 45.7146 32.837 45.6687 32.8279C45.6228 32.8188 45.5772 32.8085 45.5318 32.7971C45.4864 32.7858 45.4413 32.7733 45.3965 32.7597C45.3517 32.7461 45.3073 32.7314 45.2632 32.7157C45.2192 32.6999 45.1756 32.6831 45.1323 32.6651C45.0891 32.6472 45.0463 32.6283 45.004 32.6082C44.9617 32.5883 44.9199 32.5672 44.8787 32.5452C44.8374 32.5231 44.7967 32.5001 44.7565 32.476C44.7164 32.4519 44.6769 32.4269 44.638 32.4009C44.5991 32.3749 44.5608 32.348 44.5232 32.3201C44.4856 32.2922 44.4488 32.2634 44.4126 32.2337C44.3764 32.2041 44.341 32.1735 44.3063 32.1421C44.2716 32.1107 44.2378 32.0784 44.2047 32.0453C44.1716 32.0122 44.1393 31.9784 44.1079 31.9437C44.0765 31.909 44.0459 31.8736 44.0163 31.8374C43.9866 31.8012 43.9578 31.7644 43.9299 31.7268C43.902 31.6892 43.8751 31.6509 43.8491 31.612C43.8231 31.5731 43.7981 31.5336 43.774 31.4935C43.7499 31.4533 43.7269 31.4126 43.7048 31.3713C43.6828 31.3301 43.6617 31.2883 43.6417 31.246C43.6217 31.2037 43.6028 31.1609 43.5849 31.1177C43.5669 31.0744 43.5501 31.0308 43.5343 30.9867C43.5186 30.9427 43.5039 30.8982 43.4903 30.8535C43.4767 30.8087 43.4643 30.7636 43.4529 30.7182C43.4415 30.6728 43.4312 30.6272 43.4221 30.5813C43.413 30.5354 43.405 30.4893 43.3982 30.443C43.3913 30.3967 43.3856 30.3503 43.381 30.3037C43.3764 30.2571 43.3729 30.2105 43.3706 30.1637C43.3683 30.117 43.3672 30.0702 43.3672 30.0234C43.3672 29.9767 43.3683 29.9299 43.3706 29.8831C43.3729 29.8364 43.3764 29.7897 43.381 29.7432C43.3856 29.6966 43.3913 29.6502 43.3982 29.6039C43.405 29.5576 43.413 29.5115 43.4221 29.4656C43.4312 29.4197 43.4415 29.3741 43.4529 29.3287C43.4642 29.2833 43.4767 29.2382 43.4903 29.1934C43.5039 29.1486 43.5186 29.1042 43.5343 29.0601C43.5501 29.0161 43.5669 28.9724 43.5849 28.9292C43.6028 28.886 43.6217 28.8432 43.6417 28.8009C43.6617 28.7586 43.6828 28.7168 43.7048 28.6755C43.7269 28.6343 43.7499 28.5936 43.774 28.5534C43.7981 28.5133 43.8231 28.4738 43.8491 28.4349C43.8751 28.396 43.902 28.3577 43.9299 28.3201C43.9578 28.2825 43.9866 28.2456 44.0163 28.2095C44.0459 28.1733 44.0765 28.1379 44.1079 28.1032C44.1393 28.0685 44.1716 28.0346 44.2047 28.0016C44.2378 27.9685 44.2716 27.9362 44.3063 27.9048C44.341 27.8733 44.3764 27.8428 44.4126 27.8131C44.4488 27.7834 44.4856 27.7546 44.5232 27.7268C44.5608 27.6989 44.5991 27.6719 44.638 27.6459C44.6769 27.62 44.7164 27.5949 44.7565 27.5709C44.7967 27.5468 44.8374 27.5237 44.8787 27.5017C44.9199 27.4796 44.9617 27.4586 45.004 27.4386C45.0463 27.4186 45.0891 27.3996 45.1323 27.3817C45.1756 27.3638 45.2192 27.347 45.2632 27.3312C45.3073 27.3154 45.3517 27.3008 45.3965 27.2872C45.4413 27.2736 45.4864 27.2611 45.5318 27.2498C45.5772 27.2384 45.6228 27.2281 45.6687 27.219C45.7146 27.2099 45.7607 27.2019 45.807 27.195C45.8533 27.1882 45.8997 27.1824 45.9463 27.1778C45.9929 27.1733 46.0395 27.1698 46.0863 27.1675C46.133 27.1652 46.1798 27.1641 46.2266 27.1641L54.8047 27.1641C54.8514 27.1641 54.8982 27.1652 54.945 27.1675C54.9917 27.1698 55.0384 27.1733 55.085 27.1778C55.1315 27.1824 55.1779 27.1882 55.2242 27.195C55.2705 27.2019 55.3166 27.2099 55.3625 27.219C55.4084 27.2281 55.4541 27.2384 55.4994 27.2498C55.5448 27.2611 55.5899 27.2736 55.6347 27.2872C55.6795 27.3008 55.7239 27.3154 55.768 27.3312C55.812 27.347 55.8557 27.3638 55.8989 27.3817C55.9421 27.3996 55.9849 27.4186 56.0272 27.4386C56.0695 27.4586 56.1113 27.4796 56.1526 27.5017C56.1939 27.5237 56.2345 27.5468 56.2747 27.5709C56.3148 27.5949 56.3543 27.62 56.3932 27.6459C56.4321 27.6719 56.4704 27.6989 56.508 27.7268C56.5456 27.7546 56.5825 27.7834 56.6187 27.8131C56.6548 27.8428 56.6903 27.8733 56.7249 27.9048C56.7596 27.9362 56.7935 27.9685 56.8266 28.0016C56.8596 28.0346 56.8919 28.0685 56.9234 28.1032C56.9548 28.1379 56.9853 28.1733 57.015 28.2095C57.0447 28.2456 57.0735 28.2825 57.1014 28.3201C57.1292 28.3577 57.1562 28.396 57.1821 28.4349C57.2082 28.4738 57.2332 28.5133 57.2572 28.5534C57.2813 28.5936 57.3044 28.6343 57.3264 28.6755C57.3485 28.7168 57.3695 28.7586 57.3895 28.8009C57.4095 28.8432 57.4285 28.8859 57.4464 28.9292C57.4643 28.9724 57.4811 29.0161 57.4969 29.0601C57.5127 29.1042 57.5273 29.1486 57.5409 29.1934C57.5545 29.2382 57.567 29.2833 57.5783 29.3287C57.5897 29.3741 57.6 29.4197 57.6091 29.4656C57.6182 29.5115 57.6262 29.5576 57.6331 29.6039C57.6399 29.6502 57.6457 29.6966 57.6503 29.7432C57.6549 29.7897 57.6583 29.8364 57.6606 29.8831C57.6629 29.9299 57.6641 29.9767 57.6641 30.0234Z"   fill="#595959" >
</path>
<path d="M17.6328 30.0234C17.6328 30.0702 17.6317 30.117 17.6293 30.1637C17.627 30.2105 17.6236 30.2571 17.619 30.3037C17.6144 30.3503 17.6087 30.3967 17.6018 30.443C17.595 30.4893 17.587 30.5354 17.5779 30.5813C17.5688 30.6272 17.5584 30.6728 17.5471 30.7182C17.5357 30.7636 17.5232 30.8087 17.5097 30.8535C17.4961 30.8982 17.4814 30.9427 17.4656 30.9867C17.4499 31.0308 17.4331 31.0744 17.4151 31.1177C17.3972 31.1609 17.3783 31.2037 17.3582 31.246C17.3383 31.2883 17.3172 31.3301 17.2952 31.3713C17.2731 31.4126 17.2501 31.4533 17.226 31.4935C17.2019 31.5336 17.1769 31.5731 17.1509 31.612C17.1249 31.6509 17.098 31.6892 17.0701 31.7268C17.0422 31.7644 17.0134 31.8012 16.9837 31.8374C16.9541 31.8736 16.9235 31.909 16.8921 31.9437C16.8606 31.9784 16.8284 32.0122 16.7953 32.0453C16.7622 32.0784 16.7283 32.1107 16.6937 32.1421C16.659 32.1735 16.6236 32.2041 16.5874 32.2337C16.5512 32.2634 16.5144 32.2922 16.4768 32.3201C16.4392 32.348 16.4009 32.3749 16.362 32.4009C16.3231 32.4269 16.2836 32.4519 16.2434 32.476C16.2033 32.5001 16.1626 32.5231 16.1213 32.5452C16.08 32.5672 16.0383 32.5883 15.996 32.6082C15.9536 32.6283 15.9109 32.6472 15.8677 32.6651C15.8244 32.6831 15.7808 32.6999 15.7367 32.7157C15.6927 32.7314 15.6482 32.7461 15.6035 32.7597C15.5587 32.7733 15.5136 32.7858 15.4682 32.7971C15.4228 32.8085 15.3772 32.8188 15.3312 32.8279C15.2854 32.837 15.2393 32.845 15.193 32.8518C15.1467 32.8587 15.1003 32.8644 15.0537 32.869C15.0071 32.8736 14.9605 32.877 14.9137 32.8794C14.8669 32.8817 14.8202 32.8828 14.7734 32.8828L6.19531 32.8828C6.14853 32.8828 6.10177 32.8817 6.05502 32.8794C6.00828 32.877 5.96162 32.8736 5.91504 32.869C5.86847 32.8644 5.82204 32.8587 5.77575 32.8518C5.72946 32.845 5.68337 32.837 5.63748 32.8279C5.59158 32.8188 5.54593 32.8085 5.50054 32.7971C5.45514 32.7858 5.41005 32.7733 5.36527 32.7597C5.3205 32.7461 5.27607 32.7314 5.23202 32.7157C5.18795 32.6999 5.14431 32.6831 5.10108 32.6651C5.05784 32.6472 5.01507 32.6283 4.97277 32.6082C4.93047 32.5883 4.88868 32.5672 4.84741 32.5452C4.80614 32.5231 4.76543 32.5001 4.7253 32.476C4.68516 32.4519 4.64564 32.4269 4.60673 32.4009C4.56782 32.3749 4.52957 32.348 4.49198 32.3201C4.4544 32.2922 4.41752 32.2634 4.38134 32.2337C4.34517 32.2041 4.30975 32.1735 4.27507 32.1421C4.2404 32.1107 4.20652 32.0784 4.17343 32.0453C4.14034 32.0122 4.10808 31.9784 4.07665 31.9437C4.04523 31.909 4.01467 31.8736 3.98498 31.8374C3.9553 31.8012 3.92652 31.7644 3.89864 31.7268C3.87076 31.6892 3.84383 31.6509 3.81783 31.612C3.79183 31.5731 3.7668 31.5336 3.74274 31.4935C3.71868 31.4533 3.69563 31.4126 3.67357 31.3713C3.65151 31.3301 3.63047 31.2883 3.61047 31.246C3.59046 31.2037 3.5715 31.1609 3.5536 31.1177C3.53568 31.0744 3.51885 31.0308 3.50309 30.9867C3.48732 30.9427 3.47265 30.8982 3.45906 30.8535C3.44548 30.8087 3.433 30.7636 3.42163 30.7182C3.41026 30.6728 3.40001 30.6272 3.39088 30.5813C3.38175 30.5354 3.37375 30.4893 3.36688 30.443C3.36002 30.3967 3.35429 30.3503 3.3497 30.3037C3.34512 30.2571 3.34168 30.2105 3.33938 30.1637C3.33709 30.117 3.33594 30.0702 3.33594 30.0234C3.33594 29.9767 3.33709 29.9299 3.33938 29.8831C3.34168 29.8364 3.34512 29.7897 3.3497 29.7432C3.35429 29.6966 3.36002 29.6502 3.36688 29.6039C3.37375 29.5576 3.38175 29.5115 3.39088 29.4656C3.40001 29.4197 3.41026 29.3741 3.42163 29.3287C3.433 29.2833 3.44548 29.2382 3.45906 29.1934C3.47265 29.1486 3.48732 29.1042 3.50309 29.0601C3.51885 29.0161 3.53568 28.9724 3.5536 28.9292C3.5715 28.886 3.59046 28.8432 3.61047 28.8009C3.63047 28.7586 3.65151 28.7168 3.67357 28.6755C3.69563 28.6343 3.71868 28.5936 3.74274 28.5534C3.7668 28.5133 3.79183 28.4738 3.81782 28.4349C3.84382 28.396 3.87076 28.3577 3.89864 28.3201C3.92652 28.2825 3.9553 28.2456 3.98498 28.2095C4.01467 28.1733 4.04523 28.1379 4.07665 28.1032C4.10808 28.0685 4.14034 28.0346 4.17343 28.0016C4.20652 27.9685 4.2404 27.9362 4.27507 27.9048C4.30975 27.8733 4.34517 27.8428 4.38134 27.8131C4.41752 27.7834 4.4544 27.7546 4.49198 27.7268C4.52957 27.6989 4.56782 27.6719 4.60673 27.6459C4.64564 27.62 4.68516 27.5949 4.7253 27.5709C4.76543 27.5468 4.80614 27.5237 4.84741 27.5017C4.88868 27.4796 4.93047 27.4586 4.97277 27.4386C5.01507 27.4186 5.05784 27.3996 5.10108 27.3817C5.14431 27.3638 5.18795 27.347 5.23202 27.3312C5.27607 27.3154 5.3205 27.3008 5.36527 27.2872C5.41005 27.2736 5.45514 27.2611 5.50054 27.2498C5.54593 27.2384 5.59158 27.2281 5.63748 27.219C5.68337 27.2099 5.72946 27.2019 5.77575 27.195C5.82204 27.1882 5.86847 27.1824 5.91504 27.1778C5.96162 27.1733 6.00828 27.1698 6.05502 27.1675C6.10177 27.1652 6.14853 27.1641 6.19531 27.1641L14.7734 27.1641C14.8202 27.1641 14.8669 27.1652 14.9137 27.1675C14.9605 27.1698 15.0071 27.1733 15.0537 27.1778C15.1002 27.1824 15.1467 27.1882 15.193 27.195C15.2393 27.2019 15.2854 27.2099 15.3312 27.219C15.3772 27.2281 15.4228 27.2384 15.4682 27.2498C15.5136 27.2611 15.5587 27.2736 15.6035 27.2872C15.6482 27.3008 15.6927 27.3154 15.7367 27.3312C15.7808 27.347 15.8244 27.3638 15.8677 27.3817C15.9109 27.3996 15.9536 27.4186 15.996 27.4386C16.0383 27.4586 16.08 27.4796 16.1213 27.5017C16.1626 27.5237 16.2033 27.5468 16.2434 27.5709C16.2836 27.5949 16.3231 27.62 16.362 27.6459C16.4009 27.6719 16.4392 27.6989 16.4768 27.7268C16.5144 27.7546 16.5512 27.7834 16.5874 27.8131C16.6236 27.8428 16.659 27.8733 16.6937 27.9048C16.7283 27.9362 16.7622 27.9685 16.7953 28.0016C16.8284 28.0346 16.8606 28.0685 16.8921 28.1032C16.9235 28.1379 16.9541 28.1733 16.9837 28.2095C17.0134 28.2456 17.0422 28.2825 17.0701 28.3201C17.098 28.3577 17.1249 28.396 17.1509 28.4349C17.1769 28.4738 17.2019 28.5133 17.226 28.5534C17.2501 28.5936 17.2731 28.6343 17.2952 28.6755C17.3172 28.7168 17.3383 28.7586 17.3582 28.8009C17.3783 28.8432 17.3972 28.8859 17.4151 28.9292C17.4331 28.9724 17.4499 29.0161 17.4656 29.0601C17.4814 29.1042 17.4961 29.1486 17.5097 29.1934C17.5232 29.2382 17.5357 29.2833 17.5471 29.3287C17.5584 29.3741 17.5688 29.4197 17.5779 29.4656C17.587 29.5115 17.595 29.5576 17.6018 29.6039C17.6087 29.6502 17.6144 29.6966 17.619 29.7432C17.6236 29.7897 17.627 29.8364 17.6293 29.8831C17.6317 29.9299 17.6328 29.9767 17.6328 30.0234Z"   fill="#E5E5E5" >
</path>
<path d="M49.7075 10.8161C49.7405 10.8492 49.7727 10.883 49.8041 10.9177C49.8355 10.9524 49.866 10.9878 49.8956 11.0239C49.9253 11.0601 49.954 11.097 49.9818 11.1345C50.0097 11.1721 50.0366 11.2103 50.0626 11.2492C50.0885 11.2881 50.1135 11.3276 50.1375 11.3678C50.1615 11.4079 50.1846 11.4485 50.2066 11.4898C50.2286 11.531 50.2496 11.5728 50.2696 11.6151C50.2895 11.6573 50.3085 11.7001 50.3264 11.7433C50.3443 11.7865 50.3611 11.8301 50.3768 11.8742C50.3926 11.9182 50.4072 11.9625 50.4208 12.0073C50.4343 12.0521 50.4468 12.0971 50.4582 12.1425C50.4695 12.1878 50.4797 12.2334 50.4888 12.2793C50.498 12.3252 50.5059 12.3712 50.5128 12.4174C50.5196 12.4637 50.5254 12.5101 50.5299 12.5567C50.5345 12.6032 50.5379 12.6498 50.5403 12.6965C50.5426 12.7432 50.5437 12.79 50.5437 12.8367C50.5437 12.8834 50.5426 12.9302 50.5403 12.9769C50.5379 13.0236 50.5345 13.0702 50.5299 13.1167C50.5254 13.1633 50.5196 13.2097 50.5128 13.256C50.5059 13.3022 50.498 13.3482 50.4888 13.3941C50.4797 13.44 50.4695 13.4856 50.4581 13.5309C50.4468 13.5763 50.4343 13.6213 50.4208 13.6661C50.4072 13.7109 50.3926 13.7552 50.3768 13.7992C50.3611 13.8433 50.3443 13.8869 50.3264 13.9301C50.3085 13.9733 50.2895 14.0161 50.2696 14.0583C50.2496 14.1006 50.2286 14.1424 50.2066 14.1836C50.1846 14.2249 50.1615 14.2655 50.1375 14.3056C50.1135 14.3458 50.0885 14.3853 50.0626 14.4242C50.0366 14.4631 50.0097 14.5013 49.9818 14.5389C49.954 14.5764 49.9253 14.6133 49.8956 14.6495C49.866 14.6856 49.8355 14.721 49.8041 14.7557C49.7727 14.7904 49.7405 14.8242 49.7075 14.8573L43.6456 20.9268C43.6125 20.9599 43.5786 20.9922 43.5439 21.0237C43.5092 21.0552 43.4738 21.0858 43.4376 21.1155C43.4014 21.1453 43.3645 21.174 43.3269 21.202C43.2893 21.2299 43.251 21.2569 43.2121 21.2829C43.1732 21.309 43.1336 21.334 43.0935 21.3581C43.0533 21.3822 43.0126 21.4053 42.9713 21.4274C42.93 21.4495 42.8882 21.4705 42.8459 21.4906C42.8036 21.5107 42.7608 21.5297 42.7175 21.5476C42.6742 21.5655 42.6306 21.5824 42.5865 21.5982C42.5424 21.614 42.498 21.6287 42.4531 21.6423C42.4083 21.656 42.3632 21.6685 42.3178 21.6798C42.2723 21.6912 42.2267 21.7015 42.1808 21.7107C42.1348 21.7198 42.0887 21.7279 42.0424 21.7348C41.9961 21.7416 41.9496 21.7474 41.903 21.752C41.8564 21.7566 41.8097 21.7601 41.7629 21.7624C41.7161 21.7647 41.6693 21.7659 41.6225 21.7659C41.5757 21.766 41.5288 21.7649 41.4821 21.7625C41.4353 21.7603 41.3886 21.7569 41.342 21.7523C41.2954 21.7477 41.2489 21.742 41.2026 21.7351C41.1563 21.7283 41.1101 21.7203 41.0642 21.7112C41.0183 21.7021 40.9726 21.6919 40.9272 21.6805C40.8817 21.6691 40.8366 21.6567 40.7918 21.6431C40.7469 21.6295 40.7025 21.6149 40.6584 21.5991C40.6143 21.5833 40.5706 21.5665 40.5273 21.5486C40.484 21.5307 40.4412 21.5117 40.3988 21.4917C40.3565 21.4718 40.3147 21.4507 40.2734 21.4286C40.2321 21.4066 40.1913 21.3835 40.1511 21.3595C40.111 21.3354 40.0714 21.3104 40.0324 21.2844C39.9935 21.2584 39.9552 21.2315 39.9176 21.2036C39.8799 21.1757 39.843 21.1469 39.8068 21.1172C39.7706 21.0875 39.7351 21.057 39.7004 21.0255C39.6657 20.9941 39.6317 20.9618 39.5986 20.9287C39.5655 20.8957 39.5332 20.8618 39.5017 20.827C39.4703 20.7924 39.4397 20.7569 39.41 20.7207C39.3802 20.6845 39.3514 20.6476 39.3235 20.61C39.2956 20.5724 39.2686 20.5341 39.2425 20.4952C39.2165 20.4563 39.1914 20.4168 39.1673 20.3766C39.1432 20.3365 39.1201 20.2957 39.0981 20.2545C39.0759 20.2132 39.0549 20.1714 39.0349 20.129C39.0148 20.0867 38.9958 20.0439 38.9778 20.0006C38.9599 19.9574 38.9431 19.9137 38.9273 19.8696C38.9115 19.8255 38.8968 19.7811 38.8831 19.7362C38.8695 19.6915 38.857 19.6464 38.8456 19.6009C38.8342 19.5555 38.8239 19.5098 38.8147 19.4639C38.8056 19.418 38.7976 19.3718 38.7907 19.3255C38.7838 19.2792 38.7781 19.2328 38.7735 19.1861C38.7688 19.1395 38.7653 19.0928 38.763 19.0461C38.7607 18.9993 38.7596 18.9525 38.7595 18.9057C38.7595 18.8588 38.7606 18.812 38.7629 18.7653C38.7652 18.7185 38.7686 18.6718 38.7732 18.6251C38.7777 18.5785 38.7835 18.532 38.7903 18.4858C38.7971 18.4394 38.8051 18.3932 38.8143 18.3473C38.8234 18.3014 38.8336 18.2557 38.8449 18.2103C38.8563 18.1648 38.8688 18.1198 38.8824 18.0749C38.8959 18.03 38.9106 17.9856 38.9263 17.9415C38.9421 17.8974 38.9589 17.8537 38.9768 17.8105C38.9947 17.7672 39.0137 17.7244 39.0337 17.682C39.0537 17.6397 39.0747 17.5978 39.0968 17.5565C39.1188 17.5152 39.1419 17.4745 39.166 17.4343C39.19 17.3941 39.2151 17.3545 39.241 17.3156C39.267 17.2766 39.294 17.2383 39.3219 17.2007C39.3497 17.1631 39.3785 17.1261 39.4082 17.09C39.4379 17.0537 39.4685 17.0182 39.4999 16.9835C39.5313 16.9488 39.5636 16.9149 39.5967 16.8818L45.6624 10.8161C45.6955 10.783 45.7294 10.7507 45.764 10.7192C45.7988 10.6878 45.8342 10.6572 45.8704 10.6275C45.9065 10.5978 45.9434 10.569 45.981 10.5411C46.0186 10.5132 46.0569 10.4862 46.0958 10.4602C46.1347 10.4342 46.1742 10.4092 46.2144 10.3851C46.2545 10.361 46.2952 10.3379 46.3365 10.3159C46.3778 10.2938 46.4196 10.2727 46.4619 10.2527C46.5042 10.2326 46.547 10.2137 46.5903 10.1958C46.6335 10.1779 46.6772 10.161 46.7213 10.1452C46.7653 10.1294 46.8098 10.1148 46.8546 10.1012C46.8994 10.0875 46.9445 10.0751 46.9899 10.0637C47.0353 10.0523 47.0809 10.042 47.1269 10.0329C47.1728 10.0238 47.2189 10.0158 47.2652 10.0089C47.3115 10.002 47.358 9.99631 47.4045 9.99174C47.4511 9.98713 47.4978 9.98368 47.5446 9.98138C47.5913 9.97907 47.6381 9.97792 47.6849 9.97792C47.7318 9.97792 47.7785 9.97907 47.8253 9.98138C47.872 9.98368 47.9187 9.98713 47.9653 9.99174C48.0119 9.99631 48.0584 10.002 48.1047 10.0089C48.151 10.0158 48.1971 10.0238 48.243 10.0329C48.2889 10.042 48.3345 10.0523 48.38 10.0637C48.4254 10.0751 48.4705 10.0875 48.5153 10.1012C48.5601 10.1148 48.6045 10.1294 48.6486 10.1452C48.6927 10.161 48.7363 10.1779 48.7796 10.1958C48.8228 10.2137 48.8656 10.2326 48.9079 10.2527C48.9503 10.2727 48.992 10.2938 49.0333 10.3159C49.0746 10.3379 49.1153 10.361 49.1555 10.3851C49.1956 10.4092 49.2352 10.4342 49.2741 10.4602C49.313 10.4862 49.3512 10.5132 49.3888 10.5411C49.4264 10.569 49.4633 10.5978 49.4995 10.6275C49.5357 10.6572 49.5711 10.6878 49.6058 10.7192C49.6405 10.7507 49.6744 10.783 49.7075 10.8161Z"   fill="#8C8C8C" >
</path>
<path d="M21.4033 39.1201C21.4364 39.1532 21.4687 39.187 21.5002 39.2217C21.5316 39.2564 21.5622 39.2919 21.5919 39.328C21.6216 39.3642 21.6504 39.4011 21.6783 39.4387C21.7062 39.4763 21.7332 39.5145 21.7592 39.5534C21.7852 39.5924 21.8103 39.6319 21.8343 39.6721C21.8584 39.7122 21.8815 39.7529 21.9035 39.7942C21.9256 39.8355 21.9467 39.8773 21.9667 39.9196C21.9867 39.9619 22.0057 40.0047 22.0236 40.0479C22.0415 40.0912 22.0584 40.1349 22.0742 40.1789C22.0899 40.223 22.1046 40.2675 22.1182 40.3123C22.1318 40.3571 22.1443 40.4021 22.1557 40.4475C22.1671 40.493 22.1773 40.5386 22.1865 40.5845C22.1956 40.6305 22.2036 40.6766 22.2105 40.7229C22.2174 40.7692 22.2231 40.8156 22.2277 40.8622C22.2322 40.9088 22.2357 40.9555 22.238 41.0023C22.2403 41.049 22.2415 41.0958 22.2415 41.1426C22.2415 41.1894 22.2403 41.2362 22.238 41.283C22.2357 41.3297 22.2322 41.3764 22.2277 41.423C22.2231 41.4696 22.2174 41.516 22.2105 41.5623C22.2036 41.6086 22.1956 41.6548 22.1865 41.7007C22.1773 41.7466 22.1671 41.7922 22.1557 41.8377C22.1443 41.8831 22.1318 41.9282 22.1182 41.973C22.1046 42.0177 22.0899 42.0622 22.0742 42.1063C22.0584 42.1504 22.0415 42.194 22.0236 42.2373C22.0057 42.2805 21.9867 42.3233 21.9667 42.3656C21.9467 42.4079 21.9256 42.4497 21.9035 42.491C21.8814 42.5323 21.8584 42.573 21.8343 42.6132C21.8103 42.6533 21.7852 42.6928 21.7592 42.7318C21.7332 42.7707 21.7062 42.8089 21.6783 42.8465C21.6504 42.8841 21.6216 42.921 21.5919 42.9572C21.5622 42.9934 21.5316 43.0288 21.5002 43.0634C21.4687 43.0982 21.4364 43.1321 21.4033 43.1651L15.3376 49.2308C15.3048 49.2648 15.2711 49.2981 15.2366 49.3304C15.2021 49.3628 15.1668 49.3943 15.1307 49.425C15.0947 49.4556 15.0579 49.4853 15.0204 49.5141C14.9828 49.5428 14.9445 49.5707 14.9056 49.5976C14.8667 49.6245 14.8272 49.6504 14.787 49.6754C14.7467 49.7003 14.7059 49.7242 14.6645 49.7471C14.6231 49.77 14.5812 49.7919 14.5387 49.8128C14.4962 49.8335 14.4532 49.8533 14.4098 49.872C14.3663 49.8907 14.3224 49.9084 14.2781 49.9249C14.2337 49.9414 14.189 49.9567 14.144 49.971C14.0988 49.9853 14.0534 49.9985 14.0077 50.0105C13.9619 50.0226 13.9159 50.0335 13.8696 50.0432C13.8233 50.053 13.7768 50.0616 13.7301 50.069C13.6833 50.0765 13.6364 50.0828 13.5894 50.0879C13.5424 50.093 13.4952 50.097 13.448 50.0998C13.4008 50.1026 13.3535 50.1041 13.3062 50.1045C13.2589 50.1049 13.2116 50.1042 13.1643 50.1023C13.117 50.1004 13.0698 50.0973 13.0227 50.0931C12.9756 50.0889 12.9286 50.0834 12.8817 50.0768C12.8349 50.0702 12.7883 50.0625 12.7418 50.0535C12.6953 50.0447 12.6491 50.0346 12.6031 50.0234C12.5572 50.0122 12.5115 49.9999 12.4662 49.9864C12.4208 49.9729 12.3758 49.9583 12.3312 49.9427C12.2865 49.927 12.2423 49.9102 12.1985 49.8923C12.1547 49.8744 12.1114 49.8554 12.0685 49.8353C12.0257 49.8153 11.9833 49.7942 11.9415 49.7721C11.8997 49.7499 11.8585 49.7267 11.8178 49.7026C11.7772 49.6784 11.7371 49.6532 11.6977 49.627C11.6583 49.6008 11.6196 49.5736 11.5815 49.5455C11.5434 49.5175 11.5061 49.4884 11.4695 49.4584C11.4329 49.4285 11.397 49.3977 11.3619 49.3659C11.3268 49.3342 11.2926 49.3016 11.2591 49.2682C11.2256 49.2347 11.193 49.2005 11.1612 49.1654C11.1294 49.1303 11.0986 49.0945 11.0686 49.0579C11.0386 49.0213 11.0095 48.984 10.9814 48.946C10.9532 48.9079 10.926 48.8692 10.8998 48.8298C10.8736 48.7905 10.8484 48.7504 10.8242 48.7098C10.7999 48.6692 10.7767 48.628 10.7545 48.5862C10.7323 48.5444 10.7112 48.5021 10.6911 48.4593C10.6711 48.4164 10.652 48.3731 10.6341 48.3293C10.6161 48.2856 10.5993 48.2414 10.5836 48.1967C10.5678 48.1521 10.5532 48.1071 10.5397 48.0617C10.5262 48.0164 10.5138 47.9708 10.5025 47.9248C10.4913 47.8789 10.4812 47.8326 10.4723 47.7862C10.4633 47.7398 10.4555 47.6931 10.4489 47.6462C10.4422 47.5994 10.4368 47.5524 10.4325 47.5053C10.4282 47.4582 10.4251 47.4109 10.4231 47.3637C10.4211 47.3165 10.4204 47.2692 10.4208 47.2218C10.4211 47.1745 10.4227 47.1273 10.4254 47.08C10.4281 47.0328 10.4321 46.9856 10.4371 46.9386C10.4422 46.8915 10.4485 46.8447 10.4558 46.798C10.4633 46.7512 10.4718 46.7047 10.4815 46.6584C10.4912 46.6121 10.5021 46.5661 10.5141 46.5203C10.5261 46.4745 10.5392 46.429 10.5535 46.384C10.5677 46.3389 10.5831 46.2941 10.5995 46.2497C10.616 46.2054 10.6336 46.1615 10.6522 46.118C10.6709 46.0745 10.6906 46.0315 10.7114 45.9891C10.7322 45.9465 10.754 45.9045 10.7769 45.8631C10.7997 45.8217 10.8236 45.7809 10.8485 45.7407C10.8734 45.7004 10.8993 45.6608 10.9261 45.6219C10.953 45.583 10.9809 45.5447 11.0096 45.5071C11.0384 45.4695 11.068 45.4327 11.0986 45.3966C11.1292 45.3605 11.1607 45.3252 11.193 45.2907C11.2254 45.2562 11.2585 45.2225 11.2926 45.1896L17.3545 39.1201C17.3875 39.0869 17.4214 39.0545 17.4561 39.023C17.4908 38.9915 17.5263 38.9608 17.5625 38.9311C17.5987 38.9013 17.6356 38.8725 17.6732 38.8445C17.7108 38.8165 17.7491 38.7895 17.7881 38.7634C17.827 38.7373 17.8666 38.7122 17.9067 38.6881C17.9469 38.664 17.9877 38.6409 18.029 38.6187C18.0703 38.5966 18.1121 38.5755 18.1545 38.5554C18.1968 38.5354 18.2397 38.5163 18.283 38.4983C18.3262 38.4804 18.3699 38.4635 18.4141 38.4477C18.4582 38.4319 18.5027 38.4172 18.5476 38.4036C18.5924 38.3899 18.6375 38.3774 18.6831 38.366C18.7284 38.3546 18.7742 38.3443 18.8202 38.3351C18.8661 38.326 18.9123 38.318 18.9587 38.3111C19.005 38.3042 19.0515 38.2984 19.0982 38.2938C19.1448 38.2892 19.1915 38.2858 19.2384 38.2835C19.2852 38.2812 19.332 38.28 19.3789 38.28C19.4257 38.28 19.4726 38.2812 19.5194 38.2835C19.5662 38.2858 19.6129 38.2892 19.6596 38.2938C19.7062 38.2984 19.7528 38.3042 19.7991 38.3111C19.8454 38.318 19.8916 38.326 19.9376 38.3351C19.9836 38.3443 20.0293 38.3546 20.0747 38.366C20.1202 38.3774 20.1653 38.3899 20.2102 38.4036C20.2551 38.4172 20.2995 38.4319 20.3437 38.4477C20.3878 38.4635 20.4315 38.4804 20.4748 38.4983C20.5181 38.5163 20.5609 38.5354 20.6032 38.5554C20.6456 38.5755 20.6874 38.5966 20.7288 38.6187C20.7701 38.6409 20.8108 38.664 20.8511 38.6881C20.8912 38.7122 20.9308 38.7373 20.9697 38.7634C21.0087 38.7895 21.0469 38.8165 21.0846 38.8445C21.1222 38.8725 21.1591 38.9013 21.1953 38.9311C21.2315 38.9608 21.2669 38.9915 21.3016 39.023C21.3363 39.0545 21.3702 39.0869 21.4033 39.1201Z"   fill="#D9D9D9" >
</path>
<path d="M11.2925 10.8161C11.2595 10.8492 11.2273 10.883 11.1959 10.9177C11.1645 10.9524 11.134 10.9878 11.1044 11.0239C11.0747 11.0601 11.046 11.097 11.0182 11.1345C10.9903 11.1721 10.9634 11.2103 10.9374 11.2492C10.9115 11.2881 10.8865 11.3276 10.8625 11.3678C10.8385 11.4079 10.8154 11.4485 10.7934 11.4898C10.7714 11.531 10.7504 11.5728 10.7304 11.6151C10.7105 11.6573 10.6915 11.7001 10.6736 11.7433C10.6557 11.7865 10.6389 11.8301 10.6232 11.8742C10.6074 11.9182 10.5928 11.9625 10.5793 12.0073C10.5657 12.0521 10.5532 12.0971 10.5418 12.1425C10.5305 12.1878 10.5203 12.2334 10.5112 12.2793C10.5021 12.3252 10.4941 12.3712 10.4872 12.4174C10.4803 12.4637 10.4746 12.5101 10.4701 12.5567C10.4655 12.6032 10.4621 12.6498 10.4598 12.6965C10.4575 12.7432 10.4563 12.79 10.4563 12.8367C10.4563 12.8834 10.4575 12.9302 10.4598 12.9769C10.4621 13.0236 10.4655 13.0702 10.4701 13.1167C10.4746 13.1633 10.4803 13.2097 10.4872 13.256C10.4941 13.3022 10.5021 13.3482 10.5112 13.3941C10.5203 13.44 10.5305 13.4856 10.5418 13.5309C10.5532 13.5763 10.5657 13.6213 10.5793 13.6661C10.5928 13.7109 10.6074 13.7552 10.6232 13.7992C10.6389 13.8433 10.6557 13.8869 10.6736 13.9301C10.6915 13.9733 10.7105 14.0161 10.7304 14.0583C10.7504 14.1006 10.7714 14.1424 10.7934 14.1836C10.8154 14.2249 10.8385 14.2655 10.8625 14.3056C10.8865 14.3458 10.9115 14.3853 10.9374 14.4242C10.9634 14.4631 10.9903 14.5013 11.0182 14.5389C11.046 14.5764 11.0747 14.6133 11.1044 14.6495C11.134 14.6856 11.1645 14.721 11.1959 14.7557C11.2273 14.7904 11.2595 14.8242 11.2925 14.8573L17.3544 20.9268C17.3875 20.9599 17.4214 20.9922 17.4561 21.0237C17.4908 21.0552 17.5262 21.0858 17.5624 21.1155C17.5986 21.1453 17.6355 21.174 17.6731 21.202C17.7107 21.2299 17.749 21.2569 17.7879 21.2829C17.8268 21.309 17.8664 21.334 17.9065 21.3581C17.9467 21.3822 17.9874 21.4053 18.0287 21.4274C18.07 21.4495 18.1118 21.4705 18.1542 21.4906C18.1964 21.5107 18.2392 21.5297 18.2825 21.5476C18.3258 21.5655 18.3694 21.5824 18.4135 21.5982C18.4576 21.614 18.502 21.6287 18.5469 21.6423C18.5917 21.656 18.6368 21.6685 18.6822 21.6799C18.7277 21.6912 18.7733 21.7015 18.8193 21.7107C18.8652 21.7198 18.9113 21.7279 18.9576 21.7348C19.0039 21.7416 19.0504 21.7474 19.097 21.752C19.1436 21.7566 19.1903 21.7601 19.2371 21.7624C19.2838 21.7647 19.3307 21.7659 19.3775 21.7659C19.4244 21.766 19.4712 21.7649 19.518 21.7625C19.5647 21.7603 19.6114 21.7569 19.658 21.7523C19.7046 21.7477 19.7511 21.742 19.7974 21.7351C19.8437 21.7283 19.8899 21.7203 19.9358 21.7112C19.9818 21.7021 20.0274 21.6919 20.0728 21.6805C20.1183 21.6691 20.1634 21.6567 20.2083 21.6431C20.2531 21.6295 20.2975 21.6149 20.3416 21.5991C20.3858 21.5833 20.4294 21.5665 20.4727 21.5486C20.516 21.5307 20.5588 21.5117 20.6011 21.4917C20.6435 21.4718 20.6854 21.4507 20.7266 21.4286C20.7679 21.4066 20.8087 21.3835 20.8489 21.3595C20.8891 21.3354 20.9286 21.3104 20.9676 21.2844C21.0065 21.2584 21.0448 21.2315 21.0824 21.2036C21.1201 21.1757 21.157 21.1469 21.1932 21.1172C21.2294 21.0875 21.2649 21.057 21.2996 21.0255C21.3344 20.9941 21.3683 20.9618 21.4014 20.9287C21.4345 20.8957 21.4668 20.8618 21.4983 20.827C21.5298 20.7924 21.5604 20.7569 21.5901 20.7207C21.6198 20.6846 21.6486 20.6476 21.6765 20.61C21.7045 20.5724 21.7315 20.5341 21.7575 20.4952C21.7835 20.4563 21.8085 20.4168 21.8327 20.3766C21.8568 20.3365 21.8799 20.2957 21.902 20.2545C21.9241 20.2132 21.9451 20.1714 21.9652 20.129C21.9852 20.0867 22.0042 20.0439 22.0222 20.0006C22.0401 19.9574 22.057 19.9137 22.0727 19.8696C22.0885 19.8255 22.1032 19.7811 22.1169 19.7363C22.1305 19.6915 22.143 19.6464 22.1544 19.6009C22.1658 19.5555 22.1761 19.5098 22.1853 19.4639C22.1944 19.418 22.2024 19.3718 22.2093 19.3255C22.2162 19.2792 22.222 19.2328 22.2266 19.1861C22.2312 19.1395 22.2347 19.0928 22.237 19.0461C22.2393 18.9993 22.2404 18.9525 22.2405 18.9057C22.2406 18.8588 22.2394 18.812 22.2371 18.7652C22.2348 18.7184 22.2314 18.6718 22.2269 18.6251C22.2223 18.5785 22.2165 18.532 22.2097 18.4858C22.2028 18.4394 22.1949 18.3932 22.1857 18.3473C22.1766 18.3014 22.1664 18.2557 22.1551 18.2103C22.1437 18.1648 22.1312 18.1198 22.1177 18.0749C22.1041 18.03 22.0894 17.9856 22.0736 17.9415C22.0579 17.8974 22.0411 17.8537 22.0232 17.8105C22.0052 17.7672 21.9863 17.7244 21.9663 17.682C21.9463 17.6397 21.9253 17.5978 21.9032 17.5565C21.8812 17.5152 21.8581 17.4745 21.834 17.4343C21.81 17.3941 21.785 17.3545 21.759 17.3156C21.733 17.2766 21.706 17.2383 21.6782 17.2007C21.6503 17.1631 21.6215 17.1261 21.5918 17.09C21.5621 17.0537 21.5315 17.0182 21.5001 16.9835C21.4687 16.9488 21.4364 16.9149 21.4033 16.8818L15.3376 10.8161C15.3045 10.783 15.2706 10.7507 15.2359 10.7192C15.2013 10.6878 15.1658 10.6572 15.1296 10.6275C15.0935 10.5978 15.0566 10.569 15.019 10.5411C14.9814 10.5132 14.9432 10.4862 14.9042 10.4602C14.8653 10.4342 14.8258 10.4092 14.7856 10.3851C14.7455 10.361 14.7048 10.3379 14.6635 10.3159C14.6222 10.2938 14.5804 10.2727 14.5381 10.2527C14.4958 10.2326 14.453 10.2137 14.4097 10.1958C14.3665 10.1779 14.3228 10.161 14.2787 10.1452C14.2347 10.1294 14.1902 10.1148 14.1454 10.1012C14.1006 10.0875 14.0555 10.0751 14.0101 10.0637C13.9647 10.0523 13.919 10.042 13.8731 10.0329C13.8272 10.0238 13.7811 10.0158 13.7348 10.0089C13.6885 10.002 13.6421 9.99631 13.5955 9.99174C13.5489 9.98713 13.5022 9.98368 13.4554 9.98138C13.4087 9.97907 13.3619 9.97792 13.3151 9.97792C13.2683 9.97792 13.2215 9.97907 13.1747 9.98138C13.1279 9.98368 13.0813 9.98713 13.0347 9.99174C12.9881 9.99631 12.9416 10.002 12.8953 10.0089C12.849 10.0158 12.8029 10.0238 12.757 10.0329C12.7111 10.042 12.6654 10.0523 12.62 10.0637C12.5746 10.0751 12.5295 10.0875 12.4847 10.1012C12.4399 10.1148 12.3955 10.1294 12.3514 10.1452C12.3073 10.161 12.2637 10.1779 12.2204 10.1958C12.1772 10.2137 12.1344 10.2326 12.0921 10.2527C12.0498 10.2727 12.0079 10.2938 11.9666 10.3159C11.9254 10.3379 11.8847 10.361 11.8445 10.3851C11.8044 10.4092 11.7648 10.4342 11.7259 10.4602C11.687 10.4862 11.6487 10.5132 11.6111 10.5411C11.5736 10.569 11.5367 10.5978 11.5005 10.6275C11.4643 10.6572 11.4289 10.6878 11.3942 10.7192C11.3595 10.7507 11.3256 10.783 11.2925 10.8161Z"   fill="#F0F0F0" >
</path>
<path d="M39.5967 39.1201C39.5636 39.1532 39.5313 39.187 39.4998 39.2217C39.4684 39.2564 39.4378 39.2919 39.4081 39.328C39.3784 39.3642 39.3496 39.4011 39.3217 39.4387C39.2938 39.4763 39.2668 39.5145 39.2408 39.5534C39.2148 39.5924 39.1898 39.6319 39.1657 39.6721C39.1416 39.7122 39.1185 39.7529 39.0965 39.7942C39.0744 39.8355 39.0533 39.8773 39.0333 39.9196C39.0133 39.9619 38.9943 40.0047 38.9764 40.0479C38.9585 40.0912 38.9416 40.1349 38.9258 40.1789C38.9101 40.223 38.8954 40.2675 38.8818 40.3123C38.8682 40.3571 38.8557 40.4021 38.8443 40.4475C38.8329 40.493 38.8227 40.5386 38.8135 40.5845C38.8044 40.6305 38.7964 40.6766 38.7895 40.7229C38.7827 40.7692 38.7769 40.8156 38.7724 40.8622C38.7678 40.9088 38.7643 40.9555 38.762 41.0023C38.7597 41.049 38.7585 41.0958 38.7585 41.1426C38.7585 41.1894 38.7597 41.2362 38.762 41.283C38.7643 41.3297 38.7678 41.3764 38.7724 41.423C38.7769 41.4696 38.7827 41.516 38.7895 41.5623C38.7964 41.6086 38.8044 41.6548 38.8135 41.7007C38.8227 41.7466 38.8329 41.7922 38.8443 41.8377C38.8557 41.8831 38.8682 41.9282 38.8818 41.973C38.8954 42.0178 38.9101 42.0622 38.9258 42.1063C38.9416 42.1504 38.9585 42.194 38.9764 42.2373C38.9943 42.2805 39.0133 42.3233 39.0333 42.3656C39.0533 42.4079 39.0744 42.4497 39.0965 42.491C39.1185 42.5323 39.1416 42.573 39.1657 42.6132C39.1898 42.6533 39.2148 42.6928 39.2408 42.7318C39.2668 42.7707 39.2938 42.8089 39.3217 42.8466C39.3496 42.8841 39.3784 42.921 39.4081 42.9572C39.4378 42.9934 39.4684 43.0288 39.4998 43.0634C39.5313 43.0982 39.5636 43.1321 39.5967 43.1651L45.6624 49.2308C45.6952 49.2648 45.7289 49.2981 45.7634 49.3304C45.7979 49.3628 45.8332 49.3943 45.8693 49.425C45.9053 49.4556 45.9421 49.4853 45.9796 49.5141C46.0172 49.5429 46.0555 49.5707 46.0944 49.5976C46.1333 49.6245 46.1728 49.6504 46.213 49.6754C46.2533 49.7004 46.2941 49.7242 46.3355 49.7471C46.3769 49.7701 46.4188 49.7919 46.4613 49.8128C46.5037 49.8336 46.5468 49.8533 46.5902 49.872C46.6337 49.8907 46.6776 49.9084 46.7219 49.9249C46.7663 49.9414 46.811 49.9567 46.856 49.971C46.9011 49.9853 46.9466 49.9985 46.9923 50.0105C47.0381 50.0226 47.0841 50.0335 47.1304 50.0432C47.1767 50.053 47.2232 50.0616 47.27 50.069C47.3167 50.0765 47.3636 50.0828 47.4106 50.0879C47.4576 50.093 47.5048 50.097 47.552 50.0998C47.5992 50.1026 47.6465 50.1042 47.6938 50.1046C47.7411 50.105 47.7884 50.1043 47.8357 50.1023C47.883 50.1004 47.9302 50.0973 47.9773 50.0931C48.0244 50.0889 48.0714 50.0835 48.1183 50.0768C48.1651 50.0702 48.2117 50.0625 48.2582 50.0536C48.3047 50.0447 48.351 50.0347 48.3969 50.0234C48.4429 50.0122 48.4886 49.9999 48.5339 49.9864C48.5792 49.9729 48.6243 49.9584 48.6689 49.9427C48.7135 49.927 48.7577 49.9102 48.8015 49.8923C48.8453 49.8744 48.8886 49.8554 48.9315 49.8354C48.9743 49.8153 49.0167 49.7942 49.0585 49.7721C49.1003 49.7499 49.1415 49.7267 49.1822 49.7026C49.2229 49.6784 49.2629 49.6532 49.3023 49.627C49.3417 49.6008 49.3805 49.5737 49.4185 49.5456C49.4566 49.5175 49.4939 49.4885 49.5305 49.4585C49.5672 49.4285 49.603 49.3977 49.6381 49.3659C49.6732 49.3342 49.7075 49.3016 49.7409 49.2682C49.7744 49.2348 49.807 49.2005 49.8388 49.1654C49.8705 49.1303 49.9015 49.0945 49.9314 49.0579C49.9614 49.0214 49.9905 48.9841 50.0186 48.946C50.0468 48.908 50.074 48.8692 50.1002 48.8299C50.1264 48.7905 50.1516 48.7505 50.1758 48.7098C50.2001 48.6692 50.2233 48.628 50.2455 48.5862C50.2677 48.5444 50.2888 48.5021 50.3089 48.4593C50.329 48.4164 50.348 48.3731 50.3659 48.3293C50.3839 48.2856 50.4007 48.2414 50.4164 48.1967C50.4322 48.1521 50.4468 48.1071 50.4603 48.0618C50.4739 48.0164 50.4862 47.9708 50.4975 47.9248C50.5087 47.8789 50.5188 47.8326 50.5278 47.7862C50.5367 47.7398 50.5445 47.6931 50.5511 47.6463C50.5577 47.5994 50.5632 47.5524 50.5675 47.5053C50.5719 47.4582 50.575 47.411 50.5769 47.3637C50.5789 47.3165 50.5797 47.2692 50.5793 47.2219C50.5789 47.1745 50.5773 47.1273 50.5746 47.08C50.5719 47.0328 50.5679 46.9856 50.5629 46.9386C50.5578 46.8916 50.5515 46.8447 50.5442 46.798C50.5368 46.7512 50.5282 46.7047 50.5185 46.6584C50.5088 46.6121 50.4979 46.5661 50.4859 46.5203C50.4739 46.4745 50.4608 46.4291 50.4465 46.384C50.4323 46.3389 50.417 46.2941 50.4005 46.2497C50.384 46.2054 50.3664 46.1615 50.3478 46.118C50.3291 46.0746 50.3094 46.0315 50.2886 45.989C50.2678 45.9465 50.246 45.9045 50.2231 45.8631C50.2003 45.8217 50.1764 45.7809 50.1515 45.7407C50.1266 45.7004 50.1007 45.6608 50.0739 45.6219C50.047 45.583 50.0192 45.5447 49.9904 45.5071C49.9616 45.4696 49.932 45.4327 49.9014 45.3966C49.8708 45.3605 49.8393 45.3252 49.807 45.2907C49.7746 45.2562 49.7415 45.2225 49.7074 45.1896L43.6456 39.1201C43.6125 39.0869 43.5786 39.0545 43.5439 39.023C43.5092 38.9915 43.4737 38.9608 43.4375 38.9311C43.4013 38.9013 43.3644 38.8725 43.3268 38.8445C43.2892 38.8165 43.2509 38.7895 43.212 38.7634C43.173 38.7373 43.1334 38.7122 43.0933 38.6881C43.0531 38.664 43.0123 38.6409 42.971 38.6187C42.9297 38.5966 42.8879 38.5755 42.8455 38.5554C42.8032 38.5354 42.7603 38.5163 42.717 38.4983C42.6738 38.4804 42.6301 38.4635 42.5859 38.4477C42.5418 38.4319 42.4973 38.4172 42.4524 38.4036C42.4076 38.3899 42.3624 38.3774 42.317 38.366C42.2715 38.3546 42.2258 38.3443 42.1798 38.3351C42.1339 38.326 42.0877 38.318 42.0413 38.3111C41.995 38.3042 41.9485 38.2984 41.9018 38.2938C41.8552 38.2892 41.8085 38.2858 41.7617 38.2835C41.7148 38.2812 41.668 38.28 41.6211 38.28C41.5743 38.28 41.5274 38.2812 41.4806 38.2835C41.4338 38.2858 41.3871 38.2892 41.3404 38.2938C41.2938 38.2984 41.2473 38.3042 41.2009 38.3111C41.1545 38.318 41.1084 38.326 41.0624 38.3351C41.0164 38.3443 40.9707 38.3546 40.9252 38.366C40.8798 38.3774 40.8347 38.3899 40.7898 38.4036C40.7449 38.4172 40.7005 38.4319 40.6563 38.4477C40.6122 38.4635 40.5685 38.4804 40.5252 38.4983C40.4819 38.5163 40.4391 38.5354 40.3967 38.5554C40.3544 38.5755 40.3126 38.5966 40.2712 38.6187C40.2299 38.6409 40.1892 38.664 40.149 38.6881C40.1088 38.7122 40.0692 38.7373 40.0303 38.7634C39.9914 38.7895 39.9531 38.8165 39.9155 38.8445C39.8779 38.8725 39.8409 38.9013 39.8047 38.9311C39.7685 38.9608 39.7331 38.9915 39.6984 39.023C39.6637 39.0545 39.6298 39.0869 39.5967 39.1201Z"   fill="#8C8C8C" >
</path>
</svg>
) no-repeat; + background-size: 100%; +} +@keyframes loading-0e0dc370 { +0% { + transform: rotate(0deg); +} +to { + transform: rotate(1turn); +} +} diff --git a/pages/call/index.js b/pages/call/index.js new file mode 100644 index 0000000..539af7e --- /dev/null +++ b/pages/call/index.js @@ -0,0 +1,248 @@ +"use strict"; +var common_vendor = require("../../common/vendor.js"); +var config_index = require("../../config/index.js"); +var utils_wsRequest = require("../../utils/wsRequest.js"); +var utils_audioUtil = require("../../utils/audioUtil.js"); +var api_index = require("../../api/index.js"); +require("../../utils/request.js"); +const _sfc_main = { + setup(__props) { + const innerAudioContext = wx.createInnerAudioContext({ + useWebAudioImplement: false + }); + common_vendor.reactive([]); + innerAudioContext.playbackRate = 1.3; + const recorderManager = wx.getRecorderManager(); + const ws = common_vendor.ref(null); + const params = { + audio: "", + meta_info: { + session_id: "", + encoding: "raw" + }, + is_close: false + }; + const options = { + duration: 6e5, + sampleRate: 16e3, + numberOfChannels: 1, + encodeBitRate: 96e3, + format: "PCM", + frameSize: 12 + }; + innerAudioContext.onEnded(() => { + playNext(); + }); + const startRecord = () => { + isRecording.value = true; + console.log("\u5F00\u59CB\u5F55\u97F3"); + recorderManager.start(options); + }; + const stopRecord = () => { + if (!isRecording.value) { + console.log("\u6CA1\u6709\u5728\u5F55\u97F3..."); + return; + } + recorderManager.stop(); + isRecording.value = false; + console.log("\u505C\u6B62\u5F55\u97F3"); + }; + const playNext = () => { + if (aiVoices.length > 0) { + isPlaying.value = true; + let first = aiVoices.shift(0); + if (first) { + recorderManager.pause(); + innerAudioContext.src = first; + innerAudioContext.play(); + } + } else { + isPlaying.value = false; + recorderManager.resume(); + } + }; + let aiVoices = common_vendor.reactive([]); + let roleName = common_vendor.ref(""); + let currentRoleId = common_vendor.ref(""); + let status = common_vendor.ref("\u7B49\u5F85\u5BF9\u65B9\u63A5\u6536\u9080\u8BF7..."); + let isRecording = common_vendor.ref(false); + let isPlaying = common_vendor.ref(false); + let isLoudSpeaker = common_vendor.ref(true); + let aiAvatarId = common_vendor.ref(""); + let backGroundList = common_vendor.reactive([]); + const currentBackGroundImage = common_vendor.computed$1(() => { + return backGroundList[0]; + }); + common_vendor.onShow(() => { + common_vendor.index.getStorage({ + key: "chatInfo", + success: ({ + data + }) => { + const { + session_id, + background_ids = "", + role_name, + avatar_id, + role_id + } = data; + roleName.value = role_name; + currentRoleId.value = role_id; + params.meta_info.session_id = session_id; + aiAvatarId.value = avatar_id; + backGroundList.push(...background_ids.split(",")); + } + }); + const pcmToArrayBuffer = (pcmData, sampleRate, channels, sampleBits) => { + var _a; + const chunkSize = 36 + pcmData.byteLength; + const byteRate = sampleRate * channels * (sampleBits / 8); + const blockAlign = channels * (sampleBits / 8); + const wavHeader = new ArrayBuffer(44); + const view = new DataView(wavHeader); + view.setUint32(0, 1380533830, false); + view.setUint32(4, chunkSize, true); + view.setUint32(8, 1463899717, false); + view.setUint32(12, 1718449184, false); + view.setUint32(16, 16, true); + view.setUint16(20, 1, true); + view.setUint16(22, channels, true); + view.setUint32(24, sampleRate, true); + view.setUint32(28, byteRate, true); + view.setUint16(32, blockAlign, true); + view.setUint16(34, sampleBits, true); + view.setUint32(36, 1684108385, false); + view.setUint32(40, pcmData.byteLength, true); + const wavArrayBuffer = new Uint8Array(wavHeader); + const pcmArrayBuffer = new Uint8Array(pcmData); + const combinedArrayBuffer = new Uint8Array(wavArrayBuffer.length + pcmArrayBuffer.length); + combinedArrayBuffer.set(wavArrayBuffer, 0); + combinedArrayBuffer.set(pcmArrayBuffer, wavArrayBuffer.length); + const base64 = wx.arrayBufferToBase64(combinedArrayBuffer); + const data = Object.assign({}, params); + data.audio = base64; + (_a = ws.value) == null ? void 0 : _a.sendMsg(data); + console.log(data); + }; + recorderManager.onFrameRecorded((res) => { + const { + frameBuffer, + isLastFrame + } = res; + pcmToArrayBuffer(frameBuffer, 16e3, 1, 16); + }); + }); + const usermessageIsEnd = common_vendor.ref(false); + const llmmessageIsEnd = common_vendor.ref(false); + const usermsg = common_vendor.reactive([]); + const llmmsg = common_vendor.reactive([]); + common_vendor.onMounted(() => { + var _a; + try { + wx.setKeepScreenOn({ + keepScreenOn: true + }); + ws.value = new utils_wsRequest.webSocketClass(config_index.wsVoiceCallUrl, 60); + (_a = ws.value) == null ? void 0 : _a.initSocket().then((res) => { + status.value = "\u5DF2\u63A5\u901A"; + setTimeout(() => { + status.value = ""; + }, 2e3); + common_vendor.index.$on("message", ({ + type, + data + }) => { + status.value = ""; + console.log("\u6536\u5230\u56DE\u590D", data); + if (data instanceof ArrayBuffer) { + utils_audioUtil.savePCMBuffer(data, aiVoices); + setTimeout(() => { + if (!isPlaying.value) { + playNext(); + } + }, 400); + } else { + const message = JSON.parse(data); + if (message.type === "user_text") { + usermsg.push(message.msg); + } else if (message.type === "llm_text") { + llmmsg.push(message.msg); + } else if (message.type === "end") { + usermessageIsEnd.value = true; + llmmessageIsEnd.value = true; + api_index.saveMessage({ + role_id: currentRoleId.value, + direction: 0, + message: usermsg.join("") + }).then(({ status: status2 }) => { + usermsg.length = 0; + api_index.saveMessage({ + role_id: currentRoleId.value, + direction: 1, + message: llmmsg.join("") + }).then(({ status: status3 }) => { + llmmsg.length = 0; + }); + }); + } + } + }); + startRecord(); + }); + } catch (e) { + } + }); + const finlizer = () => { + var _a, _b; + wx.setKeepScreenOn({ + keepScreenOn: false + }); + innerAudioContext.destroy(); + stopRecord(); + const data = Object.assign({}, params); + data.audio = ""; + data.is_close = true; + (_a = ws.value) == null ? void 0 : _a.sendMsg(data); + (_b = ws.value) == null ? void 0 : _b.closeSocket(); + }; + const endCall = () => { + common_vendor.index.navigateBack({ + delta: 1 + }); + }; + const goToChat = () => { + common_vendor.index.redirectTo({ + url: "/pages/chatOnline/index" + }); + }; + common_vendor.onUnmounted(() => { + finlizer(); + }); + const changeLoudSpeaker = () => { + innerAudioContext.pause(); + wx.setInnerAudioOption({ + speakerOn: !isLoudSpeaker.value + }); + innerAudioContext.play(); + isLoudSpeaker.value = !isLoudSpeaker.value; + }; + return (_ctx, _cache) => { + return { + a: `${common_vendor.unref(config_index.filePrefix)}${common_vendor.unref(currentBackGroundImage)}`, + b: `${common_vendor.unref(config_index.filePrefix)}${common_vendor.unref(aiAvatarId)}`, + c: common_vendor.t(common_vendor.unref(roleName)), + d: common_vendor.t(common_vendor.unref(status)), + e: common_vendor.unref(isRecording), + f: common_vendor.o(($event) => goToChat()), + g: common_vendor.o(($event) => endCall()), + h: common_vendor.o(($event) => changeLoudSpeaker()), + i: common_vendor.o(($event) => goToChat()), + j: common_vendor.o(($event) => endCall()), + k: common_vendor.t(common_vendor.unref(isLoudSpeaker) ? "\u626C\u58F0\u5668\u5DF2\u5F00" : "\u626C\u58F0\u5668\u5DF2\u5173"), + l: common_vendor.o(($event) => changeLoudSpeaker()) + }; + }; + } +}; +var MiniProgramPage = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-07f20a9a"], ["__file", "C:/Users/bzm15/Desktop/ix/mini_web-develop/pages/call/index.vue"]]); +wx.createPage(MiniProgramPage); diff --git a/pages/call/index.json b/pages/call/index.json new file mode 100644 index 0000000..24d2b74 --- /dev/null +++ b/pages/call/index.json @@ -0,0 +1,5 @@ +{ + "navigationBarTitleText": "实时语音", + "navigationStyle": "custom", + "usingComponents": {} +} \ No newline at end of file diff --git a/pages/call/index.wxml b/pages/call/index.wxml new file mode 100644 index 0000000..ee3e7c6 --- /dev/null +++ b/pages/call/index.wxml @@ -0,0 +1 @@ +{{c}}{{d}}转聊天取消{{k}} \ No newline at end of file diff --git a/pages/call/index.wxss b/pages/call/index.wxss new file mode 100644 index 0000000..f21671f --- /dev/null +++ b/pages/call/index.wxss @@ -0,0 +1,102 @@ + +.container.data-v-07f20a9a { + display: flex; + flex-direction: column; + height: 100vh; + /* // 根据你的实际需求调整高度 */ +} +.container .background_image.data-v-07f20a9a { + content: ''; + display: block; + position: absolute; + top: 0; + left: 0; + z-index: -9; + width: 100%; + height: 100vh; + filter: blur(4px); + background-size: cover; +} +.profile-image-container.data-v-07f20a9a { + flex: 1; + /* // 占据上方大部分空间 */ + display: flex; + justify-content: center; + align-items: center; + flex-direction: column; +} +.profile-image.data-v-07f20a9a { + width: 120px; + /* // 根据你的实际需求调整尺寸 */ + height: 120px; + border-radius: 25px; + /* // 圆形头像 */ +} +.name.data-v-07f20a9a { + font-size: 18px; + font-weight: bold; + margin-bottom: 5px; +} +.status.data-v-07f20a9a { + font-size: 14px; +} +.controls.data-v-07f20a9a { + flex: 0 0 70px; + display: flex; + justify-content: space-between; + align-items: center; +} +.controls-label.data-v-07f20a9a { + flex: 0 0 20px; + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 70px; +} +.control-item.data-v-07f20a9a { + flex: 1; + display: flex; + justify-content: center; + align-items: center; +} +.control-icon.data-v-07f20a9a { + width: 70px; + /* // 根据你的实际需求调整尺寸 */ + height: 70px; + border-radius: 35px; + text-align: center; + line-height: 70px; + transition: transform 0.3s; + /* 平滑变换效果 */ +} +.icon-label.data-v-07f20a9a { + font-size: 12px; +} +.control-icon.active.data-v-07f20a9a { + transform: scale(1.1); + /* 放大效果 */ + opacity: 0.7; + /* 透明度变化效果 */ +} +.white.data-v-07f20a9a { + background-color: white; + font-size: 25px; + /* // 挂电话按钮的背景色，根据你的设计调整颜色 */ +} +.voicepopu.data-v-07f20a9a { + position: fixed; + right: 0; + top: 70%; + transform: translateY(-50%); + width: 130rpx; + height: 90rpx; + background-color: white; + border-radius: 75rpx 0 0 75rpx; + overflow: hidden; + z-index: 999; + text-align: center; +} +.voicegif.data-v-07f20a9a { + width: 80rpx; + height: 80rpx; +} diff --git a/pages/chat/index.js b/pages/chat/index.js new file mode 100644 index 0000000..5442ce4 --- /dev/null +++ b/pages/chat/index.js @@ -0,0 +1,154 @@ +"use strict"; +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); +var common_vendor = require("../../common/vendor.js"); +var kongshuju = require("../../kongshuju.js"); +var api_index = require("../../api/index.js"); +var config_index = require("../../config/index.js"); +require("../../utils/request.js"); +const _sfc_main = { + setup(__props) { + const state = common_vendor.reactive({ + initChatList: [], + chatList: [], + finished: false + }); + const { chatList, finished } = common_vendor.toRefs(state); + const getMessageRecord = () => { + api_index.getAllRolesMessageRecord({ + start_time: common_vendor.hooks().subtract(7, "days").startOf().format("YYYY-MM-DD HH:mm:ss"), + stop_time: common_vendor.hooks().endOf().format("YYYY-MM-DD HH:mm:ss") + }).then(({ status, data }) => { + if (Number(status) === 200 && Array.isArray(data.role_list)) { + const list = data.role_list.map((item) => { + var _a; + const [lastMessage] = (_a = item.list) == null ? void 0 : _a.slice(-1); + return __spreadProps(__spreadValues({}, item), { + lastMessage + }); + }); + state.initChatList = list; + state.chatList = list; + } + }).finally(() => { + state.finished = true; + }); + }; + common_vendor.onShow(getMessageRecord); + const onChatOnLine = async ({ role_info }) => { + try { + const { user_info } = common_vendor.index.getStorageSync("userData"); + const { user_id } = user_info || {}; + if (user_id) { + const { status, data } = await api_index.createChat({ + user_id, + character_id: role_info.role_id + }); + if (status === "success") { + common_vendor.index.setStorage({ + key: "chatInfo", + data: __spreadValues({ + userId: user_id, + session_id: data.session_id + }, role_info), + success: () => { + common_vendor.index.navigateTo({ + url: "/pages/chatOnline/index" + }); + } + }); + } else { + common_vendor.index.showToast({ + title: "\u521B\u5EFA\u804A\u5929\u5931\u8D25" + }); + } + } else { + common_vendor.index.showToast({ + title: "\u5F53\u524D\u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55", + icon: "none" + }); + common_vendor.index.clearStorage(); + common_vendor.index.navigateTo({ + url: "/pages/login/index" + }); + } + } catch (e) { + throw new Error(e); + } + }; + const timer = common_vendor.ref(null); + const onInputKeyWords = (e) => { + const keyWord = e.detail.value; + if (timer.value) { + clearTimeout(timer.value); + } + timer.value = setTimeout(() => { + if (keyWord) { + const clonedChatList = JSON.parse(JSON.stringify(state.initChatList)); + const list = clonedChatList.filter((item) => { + const { role_info, list: list2 } = item; + if (role_info.role_name.includes(keyWord)) { + return true; + } + const filterMessageList = list2.filter(({ message }) => message.includes(keyWord)); + if (filterMessageList.length > 0) { + item.lastMessage = filterMessageList[0]; + return true; + } + return false; + }); + state.chatList = list; + } else { + state.chatList = state.initChatList; + } + }, 500); + }; + const sliceMessage = (str) => { + const message = str.replace(/\r\n|\r|\n/g, " "); + if (message.length > 20) { + return `${message.substring(0, 20)}...`; + } + return message; + }; + return (_ctx, _cache) => { + return common_vendor.e({ + a: common_vendor.o(onInputKeyWords), + b: common_vendor.unref(finished) && common_vendor.unref(chatList).length === 0 + }, common_vendor.unref(finished) && common_vendor.unref(chatList).length === 0 ? { + c: kongshuju._imports_1 + } : common_vendor.unref(finished) && common_vendor.unref(chatList).length > 0 ? { + e: common_vendor.f(common_vendor.unref(chatList), (item, index, i0) => { + return { + a: `${common_vendor.unref(config_index.filePrefix)}${item.role_info.avatar_id}`, + b: common_vendor.t(item.role_info.role_name), + c: common_vendor.t(sliceMessage(item.lastMessage.message)), + d: common_vendor.t(item.lastMessage.create_at), + e: index, + f: common_vendor.o(($event) => onChatOnLine(item)) + }; + }) + } : {}, { + d: common_vendor.unref(finished) && common_vendor.unref(chatList).length > 0 + }); + }; + } +}; +var MiniProgramPage = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-3fea99d8"], ["__file", "C:/Users/bzm15/Desktop/ix/mini_web-develop/pages/chat/index.vue"]]); +wx.createPage(MiniProgramPage); diff --git a/pages/chat/index.json b/pages/chat/index.json new file mode 100644 index 0000000..98cd7ac --- /dev/null +++ b/pages/chat/index.json @@ -0,0 +1,4 @@ +{ + "navigationBarTitleText": "聊天", + "usingComponents": {} +} \ No newline at end of file diff --git a/pages/chat/index.wxml b/pages/chat/index.wxml new file mode 100644 index 0000000..d68e156 --- /dev/null +++ b/pages/chat/index.wxml @@ -0,0 +1 @@ +暂无聊天{{item.b}}{{item.c}}{{item.d}} \ No newline at end of file diff --git a/pages/chat/index.wxss b/pages/chat/index.wxss new file mode 100644 index 0000000..01c6a83 --- /dev/null +++ b/pages/chat/index.wxss @@ -0,0 +1,123 @@ + +.search_box.data-v-3fea99d8 { + position: relative; + margin-top: 12px; + height: 28px; + padding: 0 16px; + box-sizing: border-box; +} +.search_box .iconfont.data-v-3fea99d8 { + position: absolute; + top: 50%; + left: 24px; + transform: translateY(-50%); +} +.search_box input.data-v-3fea99d8 { + border-bottom: 1px solid rgba(229, 229, 229, 1); + font-size: 12px; + color: rgba(153, 153, 153, 1); + padding: 0 36px; + box-sizing: border-box; + height: 28px; +} +.no-data.data-v-3fea99d8 { + padding-top: 26vh; +} +.no-data image.data-v-3fea99d8 { + display: block; + margin: 0 auto; + width: 70px; + height: 70px; +} +.no-data text.data-v-3fea99d8 { + margin-top: 12px; + display: block; + font-size: 18px; + color: #999999; + text-align: center; +} +.chat_list.data-v-3fea99d8 { + margin-top: 20px; + padding: 0 16px; + box-sizing: border-box; +} +.chat_item.data-v-3fea99d8 { + position: relative; + display: flex; + align-items: center; + justify-content: space-between; + margin-bottom: 16px; + height: 78px; + border: 1px solid rgba(213, 241, 242, 0.5); + border-radius: 24px; + padding: 16px; + box-sizing: border-box; +} +.chat_item .avatar_box.data-v-3fea99d8 { + position: relative; + margin-right: 12px; +} +.chat_item .avatar.data-v-3fea99d8 { + display: block; + width: 40px; + height: 40px; + border-radius: 50%; + object-fit: cover; +} +.chat_item .state_dot.data-v-3fea99d8 { + position: absolute; + right: 0; + bottom: 0; + width: 12px; + height: 12px; + border-radius: 50%; + background: #fff; +} +.chat_item .state_dot.data-v-3fea99d8::before { + position: absolute; + top: 50%; + left: 50%; + transform: translate(-50%, -50%); + width: 10px; + height: 10px; + border-radius: 50%; + content: ''; +} +.chat_item .online.data-v-3fea99d8 { + background: rgba(93, 214, 77, 1); +} +.chat_item .offline.data-v-3fea99d8 { + background: rgba(255, 109, 51, 1); +} +.chat_item .center_info.data-v-3fea99d8 { + flex-grow: 1; +} +.chat_item .name.data-v-3fea99d8 { + display: block; + font-size: 16px; + font-weight: 500; + color: rgba(11, 41, 89, 1); + line-height: 24px; +} +.chat_item .text.data-v-3fea99d8 { + width: 300px; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + margin-top: 4px; + display: block; + font-size: 12px; + color: rgba(43, 67, 105, 1); + line-height: 18px; +} +.chat_item .right_info.data-v-3fea99d8 { + position: absolute; + top: 12px; + right: 16px; +} +.chat_item .time.data-v-3fea99d8 { + font-size: 12px; + color: rgba(43, 67, 105, 1); + line-height: 22px; +} + diff --git a/pages/chatOnline/index.js b/pages/chatOnline/index.js new file mode 100644 index 0000000..665da79 --- /dev/null +++ b/pages/chatOnline/index.js @@ -0,0 +1,207 @@ +"use strict"; +var common_vendor = require("../../common/vendor.js"); +var config_index = require("../../config/index.js"); +var api_index = require("../../api/index.js"); +var utils_wsRequest = require("../../utils/wsRequest.js"); +require("../../utils/request.js"); +const _sfc_main = { + setup(__props) { + const currentDate = common_vendor.hooks().format("YYYY-MM-DD"); + const currentMessage = common_vendor.ref(""); + const messageList = common_vendor.reactive([]); + const initalMessageLength = common_vendor.ref(0); + const backGroundList = common_vendor.reactive([]); + const currentBackGroundImage = common_vendor.computed$1(() => { + const pageNum = Math.floor((messageList.length - initalMessageLength.value) / 10); + const currentIndex = pageNum % backGroundList.length; + return backGroundList[currentIndex] || ""; + }); + const sessionId = common_vendor.ref(""); + const aiAvatarId = common_vendor.ref(""); + const currentRoleId = common_vendor.ref(""); + const userAvatar = common_vendor.ref(""); + common_vendor.onLoad(() => { + console.log("onLoad"); + const { user_info } = common_vendor.index.getStorageSync("userData"); + userAvatar.value = (user_info == null ? void 0 : user_info.avatar_id) || config_index.defaultAvatar; + common_vendor.index.getStorage({ + key: "chatInfo", + success: ({ data }) => { + const { session_id, avatar_id, role_id, background_ids = "", role_name } = data; + common_vendor.index.setNavigationBarTitle({ + title: role_name || "" + }); + if (sessionId) { + sessionId.value = session_id; + aiAvatarId.value = avatar_id; + currentRoleId.value = role_id; + backGroundList.push(...background_ids.split(",")); + getHistoryMsg(); + } + } + }); + }); + const getHistoryMsg = () => { + api_index.getHistoryMessage({ + role_id: currentRoleId.value, + start_time: common_vendor.hooks().subtract(7, "days").startOf().format("YYYY-MM-DD HH:mm:ss"), + stop_time: common_vendor.hooks().endOf().format("YYYY-MM-DD HH:mm:ss") + }).then(({ status, data }) => { + if (Number(status) === 200 && Array.isArray(data == null ? void 0 : data.list)) { + const msgList = data.list.map(({ create_at, direction, message }) => ({ + from: Number(direction) === 0 ? "me" : "ai", + avatar: Number(direction) === 0 ? userAvatar.value : aiAvatarId.value, + message, + date: create_at.split(" ")[0], + time: create_at.split(" ")[1] + })); + messageList.push(...msgList); + scrollToLastItem(); + } + }).catch((err) => { + }).finally(initChat); + }; + const ws = common_vendor.ref(null); + const messageIsEnd = common_vendor.ref(false); + const initChat = async () => { + var _a; + try { + ws.value = new utils_wsRequest.webSocketClass(config_index.wsUrl, 60); + (_a = ws.value) == null ? void 0 : _a.initSocket().then((res) => { + common_vendor.index.$on("message", ({ data }) => { + if (typeof data === "string") { + const { type, code, msg } = JSON.parse(data); + if (Number(code) === 200 && msg) { + if (messageIsEnd.value) { + messageList.push({ + isSaved: false, + from: "ai", + avatar: aiAvatarId.value, + message: msg, + date: common_vendor.hooks().format("YYYY-MM-DD"), + time: common_vendor.hooks().format("HH:mm:ss") + }); + } else { + const [lastMessageItem] = messageList.slice(-1); + lastMessageItem.message += msg; + } + scrollToLastItem(); + } + if (type === "end") { + onSaveMessage(); + } + messageIsEnd.value = type === "end"; + } + }); + }); + } catch (e) { + throw new Error(e); + } + }; + const toCall = () => { + var _a; + (_a = ws.value) == null ? void 0 : _a.closeSocket(); + common_vendor.index.navigateTo({ + url: "/pages/call/index?avatar_id=" + aiAvatarId.value + }); + }; + const sendMessage = () => { + var _a; + if (currentMessage.value) { + const data = { + text: currentMessage.value, + audio: "", + is_close: false, + meta_info: { + stream: false, + voice_synthesize: false, + is_end: false, + encoding: "", + session_id: sessionId.value + } + }; + (_a = ws.value) == null ? void 0 : _a.sendMsg(data).then((res) => { + if (res) { + messageList.push({ + isSaved: false, + from: "me", + avatar: userAvatar.value, + message: currentMessage.value, + date: common_vendor.hooks().format("YYYY-MM-DD"), + time: common_vendor.hooks().format("HH:mm:ss") + }); + currentMessage.value = ""; + messageIsEnd.value = true; + onSaveMessage(); + } + }).catch(() => { + common_vendor.index.showToast({ + title: "\u53D1\u9001\u6D88\u606F\u5931\u8D25", + icon: "none" + }); + }).finally(scrollToLastItem); + } else { + common_vendor.index.showToast({ + title: "\u8BF7\u8F93\u5165\u5185\u5BB9", + duration: 2e3 + }); + } + }; + const onSaveMessage = () => { + const [item] = messageList.slice(-1); + if (item.isSaved) { + return; + } + api_index.saveMessage({ + role_id: currentRoleId.value, + direction: item.from === "me" ? 0 : 1, + message: item.message + }).then(({ status }) => { + item.isSaved = true; + }); + }; + const lastItemId = common_vendor.ref(""); + const scrollToItem = common_vendor.ref(""); + const scrollToLastItem = () => { + const id = (Math.random() * 1e10).toFixed(0); + lastItemId.value = id; + common_vendor.nextTick(() => { + scrollToItem.value = `item_${id}`; + }); + }; + common_vendor.onUnmounted(() => { + var _a; + console.log("onUnmounted"); + (_a = ws.value) == null ? void 0 : _a.closeSocket(); + common_vendor.index.$off("message"); + }); + return (_ctx, _cache) => { + return common_vendor.e({ + a: common_vendor.unref(currentBackGroundImage) + }, common_vendor.unref(currentBackGroundImage) ? { + b: `${common_vendor.unref(config_index.filePrefix)}${common_vendor.unref(currentBackGroundImage)}` + } : {}, { + c: common_vendor.f(common_vendor.unref(messageList), (item, index, i0) => { + return { + a: common_vendor.t(item.date === common_vendor.unref(currentDate) ? "\u4ECA\u5929" : item.date), + b: common_vendor.t(item.time), + c: `${common_vendor.unref(config_index.filePrefix)}${item.avatar}`, + d: common_vendor.t(item.message), + e: item.message, + f: `item_${index}`, + g: common_vendor.n(item.from === "me" ? "chat_item right" : "chat_item left") + }; + }), + d: `item_${lastItemId.value}`, + e: scrollToItem.value, + f: common_vendor.o(toCall), + g: common_vendor.o(sendMessage), + h: currentMessage.value, + i: common_vendor.o(($event) => currentMessage.value = $event.detail.value), + j: common_vendor.o(sendMessage) + }); + }; + } +}; +var MiniProgramPage = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-725f8307"], ["__file", "C:/Users/bzm15/Desktop/ix/mini_web-develop/pages/chatOnline/index.vue"]]); +wx.createPage(MiniProgramPage); diff --git a/pages/chatOnline/index.json b/pages/chatOnline/index.json new file mode 100644 index 0000000..208a883 --- /dev/null +++ b/pages/chatOnline/index.json @@ -0,0 +1,4 @@ +{ + "navigationBarTitleText": "在线聊天", + "usingComponents": {} +} \ No newline at end of file diff --git a/pages/chatOnline/index.wxml b/pages/chatOnline/index.wxml new file mode 100644 index 0000000..6ad0a31 --- /dev/null +++ b/pages/chatOnline/index.wxml @@ -0,0 +1 @@ +{{item.a}} {{item.b}}{{item.d}} \ No newline at end of file diff --git a/pages/chatOnline/index.wxss b/pages/chatOnline/index.wxss new file mode 100644 index 0000000..f71039b --- /dev/null +++ b/pages/chatOnline/index.wxss @@ -0,0 +1,110 @@ + +.content.data-v-725f8307 { + width: 100%; + height: 100vh; + position: relative; +} +.content .background_image.data-v-725f8307 { + content: ''; + display: block; + position: absolute; + top: 0; + left: 0; + z-index: -9; + width: 100%; + height: 100vh; + filter: blur(4px); + background-size: cover; +} +.scroll_wrapper.data-v-725f8307 { + height: calc(100vh - 80px); +} +.chat_list.data-v-725f8307 { + overflow: hidden; + padding-bottom: 80px; + width: 100%; + padding: 0 10px; + box-sizing: border-box; +} +.chat_item .chat_time.data-v-725f8307 { + margin: 16px 0; + text-align: center; + font-size: 14px; + color: rgba(83, 88, 110, 1); +} +.last_chat_item.data-v-725f8307 { + width: 100%; + margin-top: 20px; +} +.chat_content.data-v-725f8307 { + display: flex; + align-items: flex-start; +} +.left .chat_content.data-v-725f8307 { + flex-direction: row; +} +.right .chat_content.data-v-725f8307 { + flex-direction: row-reverse; +} +.avatar.data-v-725f8307 { + flex-shrink: 0; + display: block; + width: 46px; + height: 46px; + border-radius: 50%; +} +.left .avatar.data-v-725f8307 { + margin-right: 12px; +} +.right .avatar.data-v-725f8307 { + margin-left: 12px; +} +.chat_content .message.data-v-725f8307 { + max-width: calc(100% - 130px); + padding: 8px 12px; + box-sizing: border-box; + border-radius: 10px; + box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2); + font-size: 16px; + color: rgba(63, 72, 112, 1); + background: rgba(204, 230, 255, 1); +} +.right .chat_content .message.data-v-725f8307 { + background: rgba(242, 52, 255, 1); + color: #ffffff; +} +.bottom_bar.data-v-725f8307 { + padding: 0 12px; + box-sizing: border-box; + width: 100%; + height: 80px; + background: #ffffff; + display: flex; + justify-content: space-between; + align-items: center; +} +.icon_wrapper.data-v-725f8307 { + flex-shrink: 0; + width: 48px; + height: 48px; + background: rgb(245, 245, 247); + border-radius: 10px; + text-align: center; +} +.icon_wrapper .iconfont.data-v-725f8307 { + font-size: 26px; + line-height: 48px !important; + text-align: center; +} +.bottom_bar input.data-v-725f8307 { + flex-grow: 1; + margin: 0 10px; + padding: 0 10px; + box-sizing: border-box; + height: 48px; + border-radius: 10px; + box-shadow: 0px 0px 4px rgba(0, 0, 0, 0.1); + font-size: 14px; + color: rgba(35, 42, 53, 1); + text-align: left; +} diff --git a/pages/community/detail.js b/pages/community/detail.js new file mode 100644 index 0000000..598914e --- /dev/null +++ b/pages/community/detail.js @@ -0,0 +1,159 @@ +"use strict"; +var common_vendor = require("../../common/vendor.js"); +var api_index = require("../../api/index.js"); +var config_index = require("../../config/index.js"); +require("../../utils/request.js"); +const _sfc_main = { + setup(__props) { + const userInfo = common_vendor.ref({}); + const detail = common_vendor.reactive({ + id: "", + userId: "", + images: [], + title: "", + text: "", + time: "", + isLike: false, + likeCount: void 0 + }); + const commentList = common_vendor.ref([]); + common_vendor.onLoad((e) => { + const { user_info } = common_vendor.index.getStorageSync("userData"); + userInfo.value = user_info; + getCommunity(e.id); + getComment(e.id); + }); + const getCommunity = (id) => { + api_index.getCommunityDetail(id).then(({ status, data }) => { + if (Number(status) === 200) { + const { post_id, user_id, title, is_like, like_count, content, created_at } = data.post_info; + const detailInfo = typeof content === "string" ? JSON.parse(content) : {}; + detail.title = title || ""; + detail.id = post_id; + detail.userId = user_id; + detail.images = detailInfo.images || []; + detail.text = detailInfo.text || ""; + detail.time = created_at; + detail.isLike = is_like; + detail.likeCount = like_count; + } + }); + }; + const getComment = (id) => { + api_index.getCommentData(id).then(({ status, data }) => { + if (Number(status) === 200 && Array.isArray(data.comment_list)) { + commentList.value = data.comment_list; + } + }); + }; + const commentText = common_vendor.ref(""); + const onSubmitComment = () => { + if (commentText.value) { + api_index.submitComment({ + id: detail.id, + content: commentText.value + }).then(({ status }) => { + if (Number(status) === 200) { + commentText.value = ""; + getComment(detail.id); + } + }); + } else + [ + common_vendor.index.showToast({ + title: "\u8BF7\u8F93\u5165\u8BC4\u8BBA\u5185\u5BB9", + icon: "none" + }) + ]; + }; + const onDeleteComment = (item) => { + api_index.deleteComment({ + id: detail.id, + commentId: item.comment_id + }).then(() => { + getComment(detail.id); + }); + }; + const onSubmitLike = async (type) => { + if (type === "like") { + api_index.submitLike(detail.id).then(({ status }) => { + if (Number(status) === 200) { + detail.isLike = true; + detail.likeCount += 1; + } + }); + } else { + api_index.cancelLike(detail.id).then(({ status }) => { + if (Number(status) === 200) { + detail.isLike = false; + detail.likeCount -= 1; + } + }); + } + }; + const commentTxt = common_vendor.ref(""); + const onInputBlur = () => { + if (commentTxt.value) { + api_index.submitComment({ + id: detail.id, + content: commentTxt.value + }).then(({ status }) => { + if (Number(status) === 200) { + commentTxt.value = ""; + getComment(detail.id); + } + }); + } + }; + return (_ctx, _cache) => { + return common_vendor.e({ + a: common_vendor.unref(detail).images.length > 0 + }, common_vendor.unref(detail).images.length > 0 ? { + b: common_vendor.f(common_vendor.unref(detail).images, (img, k0, i0) => { + return { + a: `${common_vendor.unref(config_index.filePrefix)}${img}`, + b: img + }; + }) + } : {}, { + c: common_vendor.t(common_vendor.unref(detail).title), + d: common_vendor.t(common_vendor.unref(detail).text), + e: common_vendor.t(common_vendor.unref(detail).time), + f: common_vendor.t(commentList.value.length), + g: `${common_vendor.unref(config_index.filePrefix)}${userInfo.value.avatar_id}`, + h: common_vendor.o(onInputBlur), + i: commentTxt.value, + j: common_vendor.o(($event) => commentTxt.value = $event.detail.value), + k: common_vendor.f(commentList.value, (item, k0, i0) => { + return common_vendor.e({ + a: `${common_vendor.unref(config_index.filePrefix)}${item.avatar_id}`, + b: common_vendor.t(item.username), + c: item.user_id === common_vendor.unref(detail).userId + }, item.user_id === common_vendor.unref(detail).userId ? {} : {}, { + d: item.user_id === userInfo.value.user_id + }, item.user_id === userInfo.value.user_id ? { + e: common_vendor.o(($event) => onDeleteComment(item)) + } : {}, { + f: common_vendor.t(item.content), + g: common_vendor.t(item.time), + h: item.comment_id + }); + }), + l: commentText.value, + m: common_vendor.o(($event) => commentText.value = $event.detail.value), + n: common_vendor.unref(detail).isLike + }, common_vendor.unref(detail).isLike ? { + o: common_vendor.o(($event) => onSubmitLike("cancel")) + } : { + p: common_vendor.o(($event) => onSubmitLike("like")) + }, { + q: common_vendor.t(common_vendor.unref(detail).likeCount), + r: commentText.value + }, commentText.value ? { + s: common_vendor.o(onSubmitComment) + } : {}); + }; + } +}; +var MiniProgramPage = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-2f2e4a30"], ["__file", "C:/Users/bzm15/Desktop/ix/mini_web-develop/pages/community/detail.vue"]]); +wx.createPage(MiniProgramPage); diff --git a/pages/community/detail.json b/pages/community/detail.json new file mode 100644 index 0000000..61f0f4a --- /dev/null +++ b/pages/community/detail.json @@ -0,0 +1,4 @@ +{ + "navigationBarTitleText": "详情", + "usingComponents": {} +} \ No newline at end of file diff --git a/pages/community/detail.wxml b/pages/community/detail.wxml new file mode 100644 index 0000000..4fb8fca --- /dev/null +++ b/pages/community/detail.wxml @@ -0,0 +1 @@ +{{c}}{{d}}编辑于{{e}}共{{f}}条评论{{item.b}} 作者 删除{{item.f}}{{item.g}}{{q}} \ No newline at end of file diff --git a/pages/community/detail.wxss b/pages/community/detail.wxss new file mode 100644 index 0000000..87959db --- /dev/null +++ b/pages/community/detail.wxss @@ -0,0 +1,184 @@ + +.content.data-v-2f2e4a30 { + padding-bottom: 80px; +} +swiper.data-v-2f2e4a30 { + height: 500px !important; +} +.banner_item.data-v-2f2e4a30 { + height: 500px; +} +.banner.data-v-2f2e4a30 { + display: block; + width: 100%; + height: 500px; +} +.title.data-v-2f2e4a30 { + margin: 20px 0; + padding: 0 16px; + box-sizing: border-box; + font-size: 18px; + font-weight: 500; + color: #000000; +} +.text.data-v-2f2e4a30 { + padding: 0 16px; + box-sizing: border-box; + font-size: 14px; + color: #000000; +} +.time.data-v-2f2e4a30 { + position: relative; + font-size: 12px; + color: rgba(140, 143, 150, 1); + padding: 10px 16px; + box-sizing: border-box; +} +.time.data-v-2f2e4a30::after { + position: absolute; + left: 50%; + bottom: 0; + transform: translateX(-50%); + content: ''; + width: calc(100% - 32px); + height: 1px; + background: rgba(229, 229, 229, 1); +} +.comment_total.data-v-2f2e4a30 { + padding: 10px 16px; + box-sizing: border-box; + font-size: 12px; + color: rgba(128, 128, 128, 1); +} +.bottom_box.data-v-2f2e4a30 { + position: fixed; + left: 0; + right: 0; + bottom: 0; + padding: 10px 16px; + box-sizing: border-box; + width: 100%; + border-top: 1px solid rgba(229, 229, 229, 1); + display: flex; + justify-content: space-between; + align-items: center; + background-color: #fff; +} +.bottom_box .input.data-v-2f2e4a30 { + padding: 0 10px; + box-sizing: border-box; + flex-grow: 1; + height: 30px; + background-color: rgba(245, 245, 245, 1); + border-radius: 15px; + font-size: 14px; + line-height: 30px; +} +.bottom_box .btn_box.data-v-2f2e4a30 { + flex-shrink: 0; + display: flex; + align-items: center; + font-size: 16px; +} +.bottom_box .btn.data-v-2f2e4a30 { + margin-left: 12px; + display: flex; + align-items: center; +} +.btn .iconfont.data-v-2f2e4a30 { + font-size: 18px; +} +.btn .icon-like.data-v-2f2e4a30 { + color: rgba(243, 67, 98, 1); +} +.btn .count.data-v-2f2e4a30 { + font-size: 16px; +} +.send_btn.data-v-2f2e4a30 { + margin-left: 12px; + height: 30px; + line-height: 30px; + font-size: 14px; + color: #fff; + background: linear-gradient(270deg, rgba(255, 153, 71, 1) 0%, rgba(242, 52, 255, 1) 57.29%, rgba(243, 64, 125, 1) 83.14%, rgba(243, 67, 98, 1) 100%); +} +.comment_input_wrapper.data-v-2f2e4a30 { + padding: 15px 10px 20px; + box-sizing: border-box; + display: flex; + justify-content: space-between; + align-items: center; +} +.comment_input_wrapper .avatar.data-v-2f2e4a30 { + flex-shrink: 0; + margin-right: 16px; + display: block; + width: 34px; + height: 34px; + border-radius: 50%; +} +.comment_input_wrapper .comment_input.data-v-2f2e4a30 { + flex-grow: 1; + font-size: 12px; + padding: 0 14px; + box-sizing: border-box; + height: 28px; + border-radius: 14px; + background: rgba(245, 245, 247, 1); +} +.comment_list.data-v-2f2e4a30 { + padding: 0 10px; + box-sizing: border-box; +} +.comment_item.data-v-2f2e4a30 { + margin-bottom: 20px; + display: flex; + align-items: flex-start; +} +.comment_item .avatar.data-v-2f2e4a30 { + flex-shrink: 0; + margin-right: 16px; + display: block; + width: 34px; + height: 34px; + border-radius: 50%; +} +.comment_item .detail.data-v-2f2e4a30 { + flex-grow: 1; +} +.detail .user.data-v-2f2e4a30 { + position: relative; + display: flex; + align-items: center; + font-size: 12px; + color: rgba(166, 166, 166, 1); +} +.user .tag.data-v-2f2e4a30 { + margin-left: 4px; + width: 20px; + height: 12px; + border-radius: 8px; + background-color: #ddd; + color: #000000; + font-size: 8px; + line-height: 12px; + text-align: center; +} +.user .delete.data-v-2f2e4a30 { + position: absolute; + right: 10px; + top: 0; + font-size: 10px; +} +.detail .content.data-v-2f2e4a30 { + margin: 2px 0; + padding: 0; + font-size: 12px; + line-height: 20px; +} +.detail .com_time.data-v-2f2e4a30 { + padding: 0; + font-size: 10px; + border: none; + color: rgba(140, 143, 150, 1); +} diff --git a/pages/community/index.js b/pages/community/index.js new file mode 100644 index 0000000..47c66c1 --- /dev/null +++ b/pages/community/index.js @@ -0,0 +1,135 @@ +"use strict"; +var __defProp = Object.defineProperty; +var __defProps = Object.defineProperties; +var __getOwnPropDescs = Object.getOwnPropertyDescriptors; +var __getOwnPropSymbols = Object.getOwnPropertySymbols; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __propIsEnum = Object.prototype.propertyIsEnumerable; +var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value; +var __spreadValues = (a, b) => { + for (var prop in b || (b = {})) + if (__hasOwnProp.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + if (__getOwnPropSymbols) + for (var prop of __getOwnPropSymbols(b)) { + if (__propIsEnum.call(b, prop)) + __defNormalProp(a, prop, b[prop]); + } + return a; +}; +var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)); +var common_vendor = require("../../common/vendor.js"); +var tianjia = require("../../tianjia.js"); +var kongshuju = require("../../kongshuju.js"); +var config_index = require("../../config/index.js"); +var api_index = require("../../api/index.js"); +require("../../utils/request.js"); +const _sfc_main = { + setup(__props) { + const openMenu = common_vendor.ref(false); + const finished = common_vendor.ref(false); + const rolesList = common_vendor.ref([]); + const getRoleList = () => { + api_index.getAllRoles().then(({ status, data }) => { + if (Number(status) === 200 && Array.isArray(data)) { + rolesList.value = data; + } + }).finally(getList); + }; + const list = common_vendor.ref([]); + const getList = () => { + api_index.getListOfCommunity({ + start_time: common_vendor.hooks().subtract(7, "days").startOf().format("YYYY-MM-DD HH:mm:ss"), + stop_time: common_vendor.hooks().endOf().format("YYYY-MM-DD HH:mm:ss"), + role_id: curRoleId.value + }).then(({ status, data }) => { + if (Number(status) === 200 && Array.isArray(data.post_list)) { + const array = data.post_list.map((item) => { + var _a; + const content = JSON.parse(item.content); + const cover = (_a = content == null ? void 0 : content.images) == null ? void 0 : _a[0]; + return __spreadProps(__spreadValues({}, item), { + cover + }); + }); + list.value = array; + } + }).finally(() => { + finished.value = true; + }); + }; + const curRoleId = common_vendor.ref(""); + const curRoleName = common_vendor.computed$1(() => { + const roleItem = rolesList.value.find((item) => item.role_id === curRoleId.value); + if (roleItem) { + return roleItem.role_name; + } + return "\u840C\u4E3B\u4EEC"; + }); + const onRoleChange = (item) => { + if (item) { + curRoleId.value = item.role_id; + } else { + curRoleId.value = ""; + } + openMenu.value = false; + getList(); + }; + const toSubmitCommunity = () => { + common_vendor.index.navigateTo({ + url: "/pages/community/release" + }); + }; + const toDetail = (item) => { + common_vendor.index.navigateTo({ + url: `/pages/community/detail?id=${item.post_id}` + }); + }; + common_vendor.onShow(getRoleList); + return (_ctx, _cache) => { + return common_vendor.e({ + a: common_vendor.t(common_vendor.unref(curRoleName)), + b: common_vendor.n(openMenu.value ? "open" : ""), + c: common_vendor.o(($event) => openMenu.value = !openMenu.value), + d: common_vendor.n(curRoleId.value === "" ? "active" : ""), + e: common_vendor.o(($event) => onRoleChange(null)), + f: common_vendor.f(rolesList.value, (item, k0, i0) => { + return { + a: `${common_vendor.unref(config_index.filePrefix)}${item.avatar_id}`, + b: common_vendor.t(item.role_name), + c: item.role_id, + d: common_vendor.n(curRoleId.value === item.role_id ? "active" : ""), + e: common_vendor.o(($event) => onRoleChange(item), item.role_id) + }; + }), + g: common_vendor.n(openMenu.value ? "open" : ""), + h: tianjia._imports_0, + i: common_vendor.o(toSubmitCommunity), + j: finished.value && list.value.length === 0 + }, finished.value && list.value.length === 0 ? { + k: kongshuju._imports_1 + } : finished.value && list.value.length > 0 ? { + m: common_vendor.f(list.value, (item, index, i0) => { + return common_vendor.e({ + a: `${common_vendor.unref(config_index.filePrefix)}${item.cover}`, + b: common_vendor.t(item.title), + c: item.user_avatar_id + }, item.user_avatar_id ? { + d: `${common_vendor.unref(config_index.filePrefix)}${item.user_avatar_id}` + } : {}, { + e: common_vendor.t(item.username), + f: item.is_like + }, item.is_like ? {} : {}, { + g: common_vendor.t(item.like_count), + h: index, + i: common_vendor.o(($event) => toDetail(item)) + }); + }) + } : {}, { + l: finished.value && list.value.length > 0 + }); + }; + } +}; +var MiniProgramPage = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-5fb47dc3"], ["__file", "C:/Users/bzm15/Desktop/ix/mini_web-develop/pages/community/index.vue"]]); +wx.createPage(MiniProgramPage); diff --git a/pages/community/index.json b/pages/community/index.json new file mode 100644 index 0000000..596b9c0 --- /dev/null +++ b/pages/community/index.json @@ -0,0 +1,4 @@ +{ + "navigationBarTitleText": "社区", + "usingComponents": {} +} \ No newline at end of file diff --git a/pages/community/index.wxml b/pages/community/index.wxml new file mode 100644 index 0000000..149e77c --- /dev/null +++ b/pages/community/index.wxml @@ -0,0 +1 @@ +{{a}}萌主们{{item.b}}暂无帖子{{item.b}}{{item.e}}{{item.g}} \ No newline at end of file diff --git a/pages/community/index.wxss b/pages/community/index.wxss new file mode 100644 index 0000000..04da6aa --- /dev/null +++ b/pages/community/index.wxss @@ -0,0 +1,184 @@ + +.ai_picker.data-v-5fb47dc3 { + position: relative; + width: 100%; + height: 48px; + padding: 0 16px; + box-sizing: border-box; + font-size: 16px; + line-height: 48px; + box-shadow: 0px 2px 6px 2px rgba(166, 166, 166, 0.25); +} +.cur_role_item.data-v-5fb47dc3 { + padding: 0 8px; + width: 88px; + height: 32px; + border-radius: 16px; + background-color: #fff; + border: 0.5px solid rgba(151, 151, 151, 0.2); + display: flex; + justify-content: space-between; + align-items: center; + font-size: 16px; + color: #000000; +} +.cur_role_item .select_name.data-v-5fb47dc3 { + font-size: 14px; + line-height: 32px; +} +.cur_role_item .iconfont.data-v-5fb47dc3 { + font-size: 6px; + transition: 300ms; +} +.cur_role_item.open .iconfont.data-v-5fb47dc3 { + transform: rotate(180deg); +} +.role_menu.data-v-5fb47dc3 { + position: absolute; + z-index: 999; + left: 16px; + top: 8px; +} +.role_menu_list.data-v-5fb47dc3 { + max-height: 0; + overflow: hidden; + padding: 0 8px; + margin-top: 4px; + box-sizing: border-box; + border-radius: 8px; + box-shadow: 0px 0px 4px rgba(0, 0, 0, 0.25); + background: rgba(255, 255, 255, 0.93); + transition: max-height 300ms; +} +.role_menu_list.open.data-v-5fb47dc3 { + max-height: 400px; +} +.role_menu_item.data-v-5fb47dc3 { + margin-bottom: 8px; + display: flex; + justify-content: flex-start; + align-items: center; + font-size: 10px; + color: rgba(166, 166, 166, 1); +} +.role_menu_item.data-v-5fb47dc3:first-child { + margin-top: 8px; +} +.role_menu_item .avatar.data-v-5fb47dc3 { + display: block; + margin-right: 8px; + width: 36px; + height: 36px; + border-radius: 50%; +} +.avatar_empty.data-v-5fb47dc3 { + background-color: #ddd; +} +.role_menu_item text.data-v-5fb47dc3 { + height: 36px; + line-height: 36px; +} +.role_menu_item.active.data-v-5fb47dc3 { + color: #000000; +} +.ai_picker .add_icon.data-v-5fb47dc3 { + width: 20px; + height: 20px; + position: absolute; + right: 16px; + top: 50%; + transform: translateY(-50%); +} +.no-data.data-v-5fb47dc3 { + padding-top: 26vh; +} +.no-data image.data-v-5fb47dc3 { + display: block; + margin: 0 auto; + width: 70px; + height: 70px; +} +.no-data text.data-v-5fb47dc3 { + margin-top: 12px; + display: block; + font-size: 18px; + color: #999999; + text-align: center; +} +.scroll_wrapper.data-v-5fb47dc3 { + height: calc(100vh - 48px); +} +.list.data-v-5fb47dc3 { + display: flex; + flex-wrap: wrap; + padding: 8px; + box-sizing: border-box; +} +.list .item.data-v-5fb47dc3 { + overflow: hidden; + margin: 0 4px 6px; + padding-bottom: 10px; + width: calc(50% - 4px); + border-radius: 4px; + box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1); +} +.list .item.data-v-5fb47dc3:nth-child(odd) { + margin-left: 0; +} +.list .item.data-v-5fb47dc3:nth-child(even) { + margin-right: 0; +} +.list .item .cover.data-v-5fb47dc3 { + width: 100%; + height: 224px; +} +.list .item .content.data-v-5fb47dc3 { + margin-bottom: 10px; + display: flex; + align-items: center; + height: 34px; + padding: 0 6px; + box-sizing: border-box; + font-size: 12px; +} +.list .item .info.data-v-5fb47dc3 { + padding: 0 6px; + box-sizing: border-box; + display: flex; + justify-content: space-between; + align-items: center; +} +.info .user.data-v-5fb47dc3 { + flex-grow: 1; + display: flex; + align-items: center; +} +.info .user .avatar.data-v-5fb47dc3 { + display: block; + margin-right: 8px; + width: 20px; + height: 20px; + border-radius: 50%; +} +.info .user .name.data-v-5fb47dc3 { + display: inline-block; + max-width: 100px; + font-size: 12px; + color: #808080; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.info .count.data-v-5fb47dc3 { + flex-shrink: 0; + display: flex; + align-items: center; + font-size: 12px; + color: #808080; +} +.info .count .iconfont.data-v-5fb47dc3 { + margin-right: 4px; +} +.info .count .icon-like.data-v-5fb47dc3 { + color: rgba(243, 67, 98, 1); +} diff --git a/pages/community/release.js b/pages/community/release.js new file mode 100644 index 0000000..19e820f --- /dev/null +++ b/pages/community/release.js @@ -0,0 +1,139 @@ +"use strict"; +var common_vendor = require("../../common/vendor.js"); +var tianjia = require("../../tianjia.js"); +var config_index = require("../../config/index.js"); +var api_index = require("../../api/index.js"); +require("../../utils/request.js"); +const _sfc_main = { + setup(__props) { + const rolesList = common_vendor.reactive([]); + const getRoleList = () => { + api_index.getAllRoles().then(({ status, data }) => { + if (Number(status) === 200 && Array.isArray(data)) { + rolesList.push(...data); + } + }).finally(getDraft); + }; + const getDraft = () => { + api_index.getDraftData().then(({ status, data }) => { + if (Number(status) === 200) { + const { title: tit, content, role_ids } = (data == null ? void 0 : data.draft_info) || {}; + const detail = typeof content === "string" ? JSON.parse(content) : {}; + imageList.push(...detail.images); + title.value = tit; + text.value = detail.text; + const roles = rolesList.filter((role) => role_ids.includes(role.role_id)); + relateRole.push(...roles); + } + }); + }; + common_vendor.onMounted(getRoleList); + const imageList = common_vendor.reactive([]); + const onUploadFile = () => { + common_vendor.index.chooseImage({ + count: 1, + sizeType: ["original", "compressed"], + sourceType: ["album"], + success: ({ tempFilePaths, tempFiles }) => { + const [file] = tempFiles; + const size = file.size / 1024 / 1024; + if (size <= 1) { + api_index.uploadImage(file).then(({ status, data }) => { + if (Number(status) === 200 && data.file_id) { + imageList.push(data.file_id); + } + }); + } else { + common_vendor.index.showToast({ + title: "\u56FE\u7247\u5927\u5C0F\u4E0D\u80FD\u8D85\u8FC71MB", + icon: "none" + }); + } + } + }); + }; + const title = common_vendor.ref(""); + const text = common_vendor.ref(""); + const relateRole = common_vendor.reactive([]); + const onChangeRole = (e) => { + const curIndex = e.detail.value; + const curSelectedRole = rolesList[curIndex]; + const existenceRole = relateRole.find((item) => item.role_id === curSelectedRole.role_id); + if (!existenceRole) { + relateRole.push(curSelectedRole); + } + }; + const onDeleteRole = (role) => { + const filterRoles = relateRole.filter((item) => item.role_id !== role.role_id); + relateRole.splice(0, relateRole.length); + relateRole.push(...filterRoles); + }; + const onSubmit = async (type) => { + let errMessage = ""; + if (imageList.length === 0) { + errMessage = "\u6700\u5C11\u4E0A\u4F20\u4E00\u5F20\u56FE\u7247"; + } else if (title.value === "") { + errMessage = "\u8BF7\u586B\u5199\u6807\u9898"; + } else if (text.value === "") { + errMessage = "\u8BF7\u586B\u5199\u5185\u5BB9"; + } else if (relateRole.length === 0) { + errMessage = "\u8BF7\u9009\u62E9\u76F8\u5173\u89D2\u8272"; + } + if (errMessage) { + common_vendor.index.showToast({ + title: errMessage, + icon: "none" + }); + } else { + const params = { + title: title.value, + role_ids: relateRole.map((role) => role.role_id), + content: JSON.stringify({ + images: imageList, + text: text.value + }) + }; + const { status } = type === "release" ? await api_index.releaseContent(params) : await api_index.saveDraft(params); + if (Number(status) === 200) { + common_vendor.index.showToast({ + title: "\u4FDD\u5B58\u6210\u529F", + icon: "none" + }); + common_vendor.index.navigateBack(); + } + } + }; + return (_ctx, _cache) => { + return common_vendor.e({ + a: common_vendor.f(common_vendor.unref(imageList), (item, k0, i0) => { + return { + a: `${common_vendor.unref(config_index.filePrefix)}${item}`, + b: item + }; + }), + b: common_vendor.unref(imageList).length < 5 + }, common_vendor.unref(imageList).length < 5 ? { + c: common_vendor.o(onUploadFile) + } : {}, { + d: title.value, + e: common_vendor.o(($event) => title.value = $event.detail.value), + f: text.value, + g: common_vendor.o(($event) => text.value = $event.detail.value), + h: common_vendor.f(common_vendor.unref(relateRole), (role, k0, i0) => { + return { + a: common_vendor.t(role.role_name), + b: common_vendor.o(($event) => onDeleteRole(role)), + c: role.role_id + }; + }), + i: tianjia._imports_0, + j: common_vendor.unref(rolesList), + k: common_vendor.o(onChangeRole), + l: common_vendor.o(($event) => onSubmit("draft")), + m: common_vendor.o(($event) => onSubmit("release")) + }); + }; + } +}; +var MiniProgramPage = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-40246838"], ["__file", "C:/Users/bzm15/Desktop/ix/mini_web-develop/pages/community/release.vue"]]); +wx.createPage(MiniProgramPage); diff --git a/pages/community/release.json b/pages/community/release.json new file mode 100644 index 0000000..a6191aa --- /dev/null +++ b/pages/community/release.json @@ -0,0 +1,4 @@ +{ + "navigationBarTitleText": "发布", + "usingComponents": {} +} \ No newline at end of file diff --git a/pages/community/release.wxml b/pages/community/release.wxml new file mode 100644 index 0000000..be766cb --- /dev/null +++ b/pages/community/release.wxml @@ -0,0 +1 @@ +