① 打开一本书的微信读书界面,点击界面右中方“读”字按钮，然后修改相应配置，再打开“自动阅读”到开启即可 ② 如果需要后台刷时长，请一定记得开启 **定时翻页** 开关 ③ Edge 浏览器请关闭TAB休眠或者在休眠配置里面排除 https://weread.qq.com
目前為
// ==UserScript==
// @name 微信读书-WEB端自动阅读插件
// @description ① 打开一本书的微信读书界面,点击界面右中方“读”字按钮，然后修改相应配置，再打开“自动阅读”到开启即可 ② 如果需要后台刷时长，请一定记得开启 **定时翻页** 开关 ③ Edge 浏览器请关闭TAB休眠或者在休眠配置里面排除 https://weread.qq.com
// @version 2025.06.24.01
// @author 纯白约定
// @match https://weread.qq.com/*
// @grant 纯白约定
// @license MIT
// @namespace https://github.com/diduweiwu
// ==/UserScript==
/******/ (function() { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 262:
/***/ (function(__unused_webpack_module, exports) {
"use strict";
var __webpack_unused_export__;
__webpack_unused_export__ = ({ value: true });
// runtime helper for setting properties on components
// in a tree-shakable way
exports.A = (sfc, props) => {
const target = sfc.__vccOpts || sfc;
for (const [key, val] of props) {
target[key] = val;
}
return target;
};
/***/ }),
/***/ 314:
/***/ (function(module) {
"use strict";
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
module.exports = function (cssWithMappingToString) {
var list = [];
// return the list of modules as css string
list.toString = function toString() {
return this.map(function (item) {
var content = "";
var needLayer = typeof item[5] !== "undefined";
if (item[4]) {
content += "@supports (".concat(item[4], ") {");
}
if (item[2]) {
content += "@media ".concat(item[2], " {");
}
if (needLayer) {
content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {");
}
content += cssWithMappingToString(item);
if (needLayer) {
content += "}";
}
if (item[2]) {
content += "}";
}
if (item[4]) {
content += "}";
}
return content;
}).join("");
};
// import a list of modules into the list
list.i = function i(modules, media, dedupe, supports, layer) {
if (typeof modules === "string") {
modules = [[null, modules, undefined]];
}
var alreadyImportedModules = {};
if (dedupe) {
for (var k = 0; k < this.length; k++) {
var id = this[k][0];
if (id != null) {
alreadyImportedModules[id] = true;
}
}
}
for (var _k = 0; _k < modules.length; _k++) {
var item = [].concat(modules[_k]);
if (dedupe && alreadyImportedModules[item[0]]) {
continue;
}
if (typeof layer !== "undefined") {
if (typeof item[5] === "undefined") {
item[5] = layer;
} else {
item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}");
item[5] = layer;
}
}
if (media) {
if (!item[2]) {
item[2] = media;
} else {
item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
item[2] = media;
}
}
if (supports) {
if (!item[4]) {
item[4] = "".concat(supports);
} else {
item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
item[4] = supports;
}
}
list.push(item);
}
};
return list;
};
/***/ }),
/***/ 435:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(992);
if(content.__esModule) content = content.default;
if(typeof content === 'string') content = [[module.id, content, '']];
if(content.locals) module.exports = content.locals;
// add the styles to the DOM
var add = (__webpack_require__(534)/* ["default"] */ .A)
var update = add("77494846", content, true, {});
/***/ }),
/***/ 534:
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
A: function() { return /* binding */ addStylesClient; }
});
;// ./node_modules/vue-style-loader/lib/listToStyles.js
/**
* Translates the list format produced by css-loader into something
* easier to manipulate.
*/
function listToStyles (parentId, list) {
var styles = []
var newStyles = {}
for (var i = 0; i < list.length; i++) {
var item = list[i]
var id = item[0]
var css = item[1]
var media = item[2]
var sourceMap = item[3]
var part = {
id: parentId + ':' + i,
css: css,
media: media,
sourceMap: sourceMap
}
if (!newStyles[id]) {
styles.push(newStyles[id] = { id: id, parts: [part] })
} else {
newStyles[id].parts.push(part)
}
}
return styles
}
;// ./node_modules/vue-style-loader/lib/addStylesClient.js
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
Modified by Evan You @yyx990803
*/
var hasDocument = typeof document !== 'undefined'
if (typeof DEBUG !== 'undefined' && DEBUG) {
if (!hasDocument) {
throw new Error(
'vue-style-loader cannot be used in a non-browser environment. ' +
"Use { target: 'node' } in your Webpack config to indicate a server-rendering environment."
) }
}
/*
type StyleObject = {
id: number;
parts: Array<StyleObjectPart>
}
type StyleObjectPart = {
css: string;
media: string;
sourceMap: ?string
}
*/
var stylesInDom = {/*
[id: number]: {
id: number,
refs: number,
parts: Array<(obj?: StyleObjectPart) => void>
}
*/}
var head = hasDocument && (document.head || document.getElementsByTagName('head')[0])
var singletonElement = null
var singletonCounter = 0
var isProduction = false
var noop = function () {}
var options = null
var ssrIdKey = 'data-vue-ssr-id'
// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
// tags it will allow on a page
var isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\b/.test(navigator.userAgent.toLowerCase())
function addStylesClient (parentId, list, _isProduction, _options) {
isProduction = _isProduction
options = _options || {}
var styles = listToStyles(parentId, list)
addStylesToDom(styles)
return function update (newList) {
var mayRemove = []
for (var i = 0; i < styles.length; i++) {
var item = styles[i]
var domStyle = stylesInDom[item.id]
domStyle.refs--
mayRemove.push(domStyle)
}
if (newList) {
styles = listToStyles(parentId, newList)
addStylesToDom(styles)
} else {
styles = []
}
for (var i = 0; i < mayRemove.length; i++) {
var domStyle = mayRemove[i]
if (domStyle.refs === 0) {
for (var j = 0; j < domStyle.parts.length; j++) {
domStyle.parts[j]()
}
delete stylesInDom[domStyle.id]
}
}
}
}
function addStylesToDom (styles /* Array<StyleObject> */) {
for (var i = 0; i < styles.length; i++) {
var item = styles[i]
var domStyle = stylesInDom[item.id]
if (domStyle) {
domStyle.refs++
for (var j = 0; j < domStyle.parts.length; j++) {
domStyle.parts[j](item.parts[j])
}
for (; j < item.parts.length; j++) {
domStyle.parts.push(addStyle(item.parts[j]))
}
if (domStyle.parts.length > item.parts.length) {
domStyle.parts.length = item.parts.length
}
} else {
var parts = []
for (var j = 0; j < item.parts.length; j++) {
parts.push(addStyle(item.parts[j]))
}
stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts }
}
}
}
function createStyleElement () {
var styleElement = document.createElement('style')
styleElement.type = 'text/css'
head.appendChild(styleElement)
return styleElement
}
function addStyle (obj /* StyleObjectPart */) {
var update, remove
var styleElement = document.querySelector('style[' + ssrIdKey + '~="' + obj.id + '"]')
if (styleElement) {
if (isProduction) {
// has SSR styles and in production mode.
// simply do nothing.
return noop
} else {
// has SSR styles but in dev mode.
// for some reason Chrome can't handle source map in server-rendered
// style tags - source maps in <style> only works if the style tag is
// created and inserted dynamically. So we remove the server rendered
// styles and inject new ones.
styleElement.parentNode.removeChild(styleElement)
}
}
if (isOldIE) {
// use singleton mode for IE9.
var styleIndex = singletonCounter++
styleElement = singletonElement || (singletonElement = createStyleElement())
update = applyToSingletonTag.bind(null, styleElement, styleIndex, false)
remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true)
} else {
// use multi-style-tag mode in all other cases
styleElement = createStyleElement()
update = applyToTag.bind(null, styleElement)
remove = function () {
styleElement.parentNode.removeChild(styleElement)
}
}
update(obj)
return function updateStyle (newObj /* StyleObjectPart */) {
if (newObj) {
if (newObj.css === obj.css &&
newObj.media === obj.media &&
newObj.sourceMap === obj.sourceMap) {
return
}
update(obj = newObj)
} else {
remove()
}
}
}
var replaceText = (function () {
var textStore = []
return function (index, replacement) {
textStore[index] = replacement
return textStore.filter(Boolean).join('\n')
}
})()
function applyToSingletonTag (styleElement, index, remove, obj) {
var css = remove ? '' : obj.css
if (styleElement.styleSheet) {
styleElement.styleSheet.cssText = replaceText(index, css)
} else {
var cssNode = document.createTextNode(css)
var childNodes = styleElement.childNodes
if (childNodes[index]) styleElement.removeChild(childNodes[index])
if (childNodes.length) {
styleElement.insertBefore(cssNode, childNodes[index])
} else {
styleElement.appendChild(cssNode)
}
}
}
function applyToTag (styleElement, obj) {
var css = obj.css
var media = obj.media
var sourceMap = obj.sourceMap
if (media) {
styleElement.setAttribute('media', media)
}
if (options.ssrId) {
styleElement.setAttribute(ssrIdKey, obj.id)
}
if (sourceMap) {
// https://developer.chrome.com/devtools/docs/javascript-debugging
// this makes source maps inside style tags work properly in Chrome
css += '\n/*# sourceURL=' + sourceMap.sources[0] + ' */'
// http://stackoverflow.com/a/26603875
css += '\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */'
}
if (styleElement.styleSheet) {
styleElement.styleSheet.cssText = css
} else {
while (styleElement.firstChild) {
styleElement.removeChild(styleElement.firstChild)
}
styleElement.appendChild(document.createTextNode(css))
}
}
/***/ }),
/***/ 550:
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(601);
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(314);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
// Imports
var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
// Module
___CSS_LOADER_EXPORT___.push([module.id, "\n.config-area[data-v-49770b9d] {\n flex-wrap: wrap;\n position: fixed;\n top: calc(100vh / 2);\n right: 10px;\n z-index: 1024;\n}\n", ""]);
// Exports
/* harmony default export */ __webpack_exports__["default"] = (___CSS_LOADER_EXPORT___);
/***/ }),
/***/ 557:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(550);
if(content.__esModule) content = content.default;
if(typeof content === 'string') content = [[module.id, content, '']];
if(content.locals) module.exports = content.locals;
// add the styles to the DOM
var add = (__webpack_require__(534)/* ["default"] */ .A)
var update = add("0125176c", content, true, {});
/***/ }),
/***/ 601:
/***/ (function(module) {
"use strict";
module.exports = function (i) {
return i[1];
};
/***/ }),
/***/ 657:
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(601);
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(314);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
// Imports
var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
// Module
___CSS_LOADER_EXPORT___.push([module.id, "\n.account-info[data-v-5aabe62b] {\n border: lightgray solid 1px;\n border-radius: 4px;\n padding: 2px 10px;\n}\n.count-number[data-v-5aabe62b] {\n font-size: 25px;\n}\n\n", ""]);
// Exports
/* harmony default export */ __webpack_exports__["default"] = (___CSS_LOADER_EXPORT___);
/***/ }),
/***/ 799:
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(601);
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(314);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
// Imports
var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
// Module
___CSS_LOADER_EXPORT___.push([module.id, "\n.account-info[data-v-1ada3bc7] {\n border: lightgray solid 1px;\n border-radius: 4px;\n padding: 1px 10px;\n height: 100%;\n}\n", ""]);
// Exports
/* harmony default export */ __webpack_exports__["default"] = (___CSS_LOADER_EXPORT___);
/***/ }),
/***/ 820:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(799);
if(content.__esModule) content = content.default;
if(typeof content === 'string') content = [[module.id, content, '']];
if(content.locals) module.exports = content.locals;
// add the styles to the DOM
var add = (__webpack_require__(534)/* ["default"] */ .A)
var update = add("ece79c0e", content, true, {});
/***/ }),
/***/ 848:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
// style-loader: Adds some css to the DOM by adding a <style> tag
// load the styles
var content = __webpack_require__(657);
if(content.__esModule) content = content.default;
if(typeof content === 'string') content = [[module.id, content, '']];
if(content.locals) module.exports = content.locals;
// add the styles to the DOM
var add = (__webpack_require__(534)/* ["default"] */ .A)
var update = add("196832f2", content, true, {});
/***/ }),
/***/ 992:
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(601);
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(314);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
// Imports
var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
// Module
___CSS_LOADER_EXPORT___.push([module.id, "\n.readConfig[data-v-6a0d15e8] {\n width: 100%;\n min-height: 200px;\n}\n.n-input-number[data-v-6a0d15e8] {\n width: 100%;\n}\n", ""]);
// Exports
/* harmony default export */ __webpack_exports__["default"] = (___CSS_LOADER_EXPORT___);
/***/ })
/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ id: moduleId,
/******/ // no module.loaded needed
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/************************************************************************/
/******/ /* webpack/runtime/compat get default export */
/******/ !function() {
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function() { return module['default']; } :
/******/ function() { return module; };
/******/ __webpack_require__.d(getter, { a: getter });
/******/ return getter;
/******/ };
/******/ }();
/******/
/******/ /* webpack/runtime/define property getters */
/******/ !function() {
/******/ // define getter functions for harmony exports
/******/ __webpack_require__.d = function(exports, definition) {
/******/ for(var key in definition) {
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ }
/******/ }
/******/ };
/******/ }();
/******/
/******/ /* webpack/runtime/global */
/******/ !function() {
/******/ __webpack_require__.g = (function() {
/******/ if (typeof globalThis === 'object') return globalThis;
/******/ try {
/******/ return this || new Function('return this')();
/******/ } catch (e) {
/******/ if (typeof window === 'object') return window;
/******/ }
/******/ })();
/******/ }();
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ !function() {
/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
/******/ }();
/******/
/******/ /* webpack/runtime/make namespace object */
/******/ !function() {
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/ }();
/******/
/************************************************************************/
var __webpack_exports__ = {};
// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
!function() {
"use strict";
// NAMESPACE OBJECT: ./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js
var runtime_dom_esm_bundler_namespaceObject = {};
__webpack_require__.r(runtime_dom_esm_bundler_namespaceObject);
__webpack_require__.d(runtime_dom_esm_bundler_namespaceObject, {
BaseTransition: function() { return BaseTransition; },
BaseTransitionPropsValidators: function() { return BaseTransitionPropsValidators; },
Comment: function() { return Comment; },
DeprecationTypes: function() { return DeprecationTypes; },
EffectScope: function() { return EffectScope; },
ErrorCodes: function() { return ErrorCodes; },
ErrorTypeStrings: function() { return ErrorTypeStrings; },
Fragment: function() { return Fragment; },
KeepAlive: function() { return KeepAlive; },
ReactiveEffect: function() { return ReactiveEffect; },
Static: function() { return Static; },
Suspense: function() { return Suspense; },
Teleport: function() { return Teleport; },
Text: function() { return Text; },
TrackOpTypes: function() { return TrackOpTypes; },
Transition: function() { return Transition; },
TransitionGroup: function() { return TransitionGroup; },
TriggerOpTypes: function() { return TriggerOpTypes; },
VueElement: function() { return VueElement; },
assertNumber: function() { return assertNumber; },
callWithAsyncErrorHandling: function() { return callWithAsyncErrorHandling; },
callWithErrorHandling: function() { return callWithErrorHandling; },
camelize: function() { return shared_esm_bundler_camelize; },
capitalize: function() { return shared_esm_bundler_capitalize; },
cloneVNode: function() { return cloneVNode; },
compatUtils: function() { return compatUtils; },
computed: function() { return runtime_core_esm_bundler_computed; },
createApp: function() { return createApp; },
createBlock: function() { return createBlock; },
createCommentVNode: function() { return createCommentVNode; },
createElementBlock: function() { return createElementBlock; },
createElementVNode: function() { return createBaseVNode; },
createHydrationRenderer: function() { return createHydrationRenderer; },
createPropsRestProxy: function() { return createPropsRestProxy; },
createRenderer: function() { return createRenderer; },
createSSRApp: function() { return createSSRApp; },
createSlots: function() { return createSlots; },
createStaticVNode: function() { return createStaticVNode; },
createTextVNode: function() { return createTextVNode; },
createVNode: function() { return createVNode; },
customRef: function() { return customRef; },
defineAsyncComponent: function() { return defineAsyncComponent; },
defineComponent: function() { return defineComponent; },
defineCustomElement: function() { return defineCustomElement; },
defineEmits: function() { return defineEmits; },
defineExpose: function() { return defineExpose; },
defineModel: function() { return defineModel; },
defineOptions: function() { return defineOptions; },
defineProps: function() { return defineProps; },
defineSSRCustomElement: function() { return defineSSRCustomElement; },
defineSlots: function() { return defineSlots; },
devtools: function() { return devtools; },
effect: function() { return effect; },
effectScope: function() { return effectScope; },
getCurrentInstance: function() { return runtime_core_esm_bundler_getCurrentInstance; },
getCurrentScope: function() { return getCurrentScope; },
getCurrentWatcher: function() { return getCurrentWatcher; },
getTransitionRawChildren: function() { return getTransitionRawChildren; },
guardReactiveProps: function() { return guardReactiveProps; },
h: function() { return h; },
handleError: function() { return handleError; },
hasInjectionContext: function() { return hasInjectionContext; },
hydrate: function() { return hydrate; },
hydrateOnIdle: function() { return hydrateOnIdle; },
hydrateOnInteraction: function() { return hydrateOnInteraction; },
hydrateOnMediaQuery: function() { return hydrateOnMediaQuery; },
hydrateOnVisible: function() { return hydrateOnVisible; },
initCustomFormatter: function() { return runtime_core_esm_bundler_initCustomFormatter; },
initDirectivesForSSR: function() { return initDirectivesForSSR; },
inject: function() { return runtime_core_esm_bundler_inject; },
isMemoSame: function() { return isMemoSame; },
isProxy: function() { return isProxy; },
isReactive: function() { return reactivity_esm_bundler_isReactive; },
isReadonly: function() { return reactivity_esm_bundler_isReadonly; },
isRef: function() { return reactivity_esm_bundler_isRef; },
isRuntimeOnly: function() { return runtime_core_esm_bundler_isRuntimeOnly; },
isShallow: function() { return reactivity_esm_bundler_isShallow; },
isVNode: function() { return isVNode; },
markRaw: function() { return markRaw; },
mergeDefaults: function() { return mergeDefaults; },
mergeModels: function() { return mergeModels; },
mergeProps: function() { return mergeProps; },
nextTick: function() { return nextTick; },
normalizeClass: function() { return shared_esm_bundler_normalizeClass; },
normalizeProps: function() { return normalizeProps; },
normalizeStyle: function() { return shared_esm_bundler_normalizeStyle; },
onActivated: function() { return onActivated; },
onBeforeMount: function() { return onBeforeMount; },
onBeforeUnmount: function() { return runtime_core_esm_bundler_onBeforeUnmount; },
onBeforeUpdate: function() { return onBeforeUpdate; },
onDeactivated: function() { return onDeactivated; },
onErrorCaptured: function() { return onErrorCaptured; },
onMounted: function() { return runtime_core_esm_bundler_onMounted; },
onRenderTracked: function() { return onRenderTracked; },
onRenderTriggered: function() { return onRenderTriggered; },
onScopeDispose: function() { return onScopeDispose; },
onServerPrefetch: function() { return onServerPrefetch; },
onUnmounted: function() { return onUnmounted; },
onUpdated: function() { return onUpdated; },
onWatcherCleanup: function() { return onWatcherCleanup; },
openBlock: function() { return openBlock; },
popScopeId: function() { return popScopeId; },
provide: function() { return provide; },
proxyRefs: function() { return proxyRefs; },
pushScopeId: function() { return pushScopeId; },
queuePostFlushCb: function() { return queuePostFlushCb; },
reactive: function() { return reactive; },
readonly: function() { return readonly; },
ref: function() { return ref; },
registerRuntimeCompiler: function() { return registerRuntimeCompiler; },
render: function() { return render; },
renderList: function() { return renderList; },
renderSlot: function() { return renderSlot; },
resolveComponent: function() { return resolveComponent; },
resolveDirective: function() { return resolveDirective; },
resolveDynamicComponent: function() { return resolveDynamicComponent; },
resolveFilter: function() { return resolveFilter; },
resolveTransitionHooks: function() { return resolveTransitionHooks; },
setBlockTracking: function() { return setBlockTracking; },
setDevtoolsHook: function() { return setDevtoolsHook; },
setTransitionHooks: function() { return setTransitionHooks; },
shallowReactive: function() { return shallowReactive; },
shallowReadonly: function() { return shallowReadonly; },
shallowRef: function() { return reactivity_esm_bundler_shallowRef; },
ssrContextKey: function() { return ssrContextKey; },
ssrUtils: function() { return ssrUtils; },
stop: function() { return stop; },
toDisplayString: function() { return toDisplayString; },
toHandlerKey: function() { return toHandlerKey; },
toHandlers: function() { return toHandlers; },
toRaw: function() { return reactivity_esm_bundler_toRaw; },
toRef: function() { return toRef; },
toRefs: function() { return toRefs; },
toValue: function() { return toValue; },
transformVNodeArgs: function() { return transformVNodeArgs; },
triggerRef: function() { return triggerRef; },
unref: function() { return unref; },
useAttrs: function() { return useAttrs; },
useCssModule: function() { return useCssModule; },
useCssVars: function() { return useCssVars; },
useHost: function() { return useHost; },
useId: function() { return useId; },
useModel: function() { return useModel; },
useSSRContext: function() { return useSSRContext; },
useShadowRoot: function() { return useShadowRoot; },
useSlots: function() { return useSlots; },
useTemplateRef: function() { return useTemplateRef; },
useTransitionState: function() { return useTransitionState; },
vModelCheckbox: function() { return vModelCheckbox; },
vModelDynamic: function() { return vModelDynamic; },
vModelRadio: function() { return vModelRadio; },
vModelSelect: function() { return vModelSelect; },
vModelText: function() { return vModelText; },
vShow: function() { return vShow; },
version: function() { return version; },
warn: function() { return runtime_core_esm_bundler_warn; },
watch: function() { return runtime_core_esm_bundler_watch; },
watchEffect: function() { return watchEffect; },
watchPostEffect: function() { return watchPostEffect; },
watchSyncEffect: function() { return watchSyncEffect; },
withAsyncContext: function() { return withAsyncContext; },
withCtx: function() { return withCtx; },
withDefaults: function() { return withDefaults; },
withDirectives: function() { return withDirectives; },
withKeys: function() { return withKeys; },
withMemo: function() { return withMemo; },
withModifiers: function() { return withModifiers; },
withScopeId: function() { return withScopeId; }
});
// NAMESPACE OBJECT: ./node_modules/axios/lib/platform/common/utils.js
var common_utils_namespaceObject = {};
__webpack_require__.r(common_utils_namespaceObject);
__webpack_require__.d(common_utils_namespaceObject, {
hasBrowserEnv: function() { return hasBrowserEnv; },
hasStandardBrowserEnv: function() { return hasStandardBrowserEnv; },
hasStandardBrowserWebWorkerEnv: function() { return hasStandardBrowserWebWorkerEnv; },
navigator: function() { return _navigator; },
origin: function() { return origin; }
});
;// ./node_modules/@vue/shared/dist/shared.esm-bundler.js
/**
* @vue/shared v3.5.13
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function shared_esm_bundler_makeMap(str) {
const map = /* @__PURE__ */ Object.create(null);
for (const key of str.split(",")) map[key] = 1;
return (val) => val in map;
}
const EMPTY_OBJ = false ? 0 : {};
const EMPTY_ARR = false ? 0 : [];
const shared_esm_bundler_NOOP = () => {
};
const NO = () => false;
const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
const isModelListener = (key) => key.startsWith("onUpdate:");
const shared_esm_bundler_extend = Object.assign;
const remove = (arr, el) => {
const i = arr.indexOf(el);
if (i > -1) {
arr.splice(i, 1);
}
};
const shared_esm_bundler_hasOwnProperty = Object.prototype.hasOwnProperty;
const hasOwn = (val, key) => shared_esm_bundler_hasOwnProperty.call(val, key);
const shared_esm_bundler_isArray = Array.isArray;
const isMap = (val) => toTypeString(val) === "[object Map]";
const isSet = (val) => toTypeString(val) === "[object Set]";
const isDate = (val) => toTypeString(val) === "[object Date]";
const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
const shared_esm_bundler_isFunction = (val) => typeof val === "function";
const shared_esm_bundler_isString = (val) => typeof val === "string";
const isSymbol = (val) => typeof val === "symbol";
const shared_esm_bundler_isObject = (val) => val !== null && typeof val === "object";
const isPromise = (val) => {
return (shared_esm_bundler_isObject(val) || shared_esm_bundler_isFunction(val)) && shared_esm_bundler_isFunction(val.then) && shared_esm_bundler_isFunction(val.catch);
};
const objectToString = Object.prototype.toString;
const toTypeString = (value) => objectToString.call(value);
const shared_esm_bundler_toRawType = (value) => {
return toTypeString(value).slice(8, -1);
};
const isPlainObject = (val) => toTypeString(val) === "[object Object]";
const isIntegerKey = (key) => shared_esm_bundler_isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
const isReservedProp = /* @__PURE__ */ shared_esm_bundler_makeMap(
// the leading comma is intentional so empty string "" is also included
",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
);
const shared_esm_bundler_isBuiltInDirective = /* @__PURE__ */ shared_esm_bundler_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 shared_esm_bundler_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 shared_esm_bundler_capitalize = cacheStringFunction((str) => {
return str.charAt(0).toUpperCase() + str.slice(1);
});
const toHandlerKey = cacheStringFunction(
(str) => {
const s = str ? `on${shared_esm_bundler_capitalize(str)}` : ``;
return s;
}
);
const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
const invokeArrayFns = (fns, ...arg) => {
for (let i = 0; i < fns.length; i++) {
fns[i](...arg);
}
};
const def = (obj, key, value, writable = false) => {
Object.defineProperty(obj, key, {
configurable: true,
enumerable: false,
writable,
value
});
};
const looseToNumber = (val) => {
const n = parseFloat(val);
return isNaN(n) ? val : n;
};
const toNumber = (val) => {
const n = shared_esm_bundler_isString(val) ? Number(val) : NaN;
return isNaN(n) ? val : n;
};
let _globalThis;
const getGlobalThis = () => {
return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof __webpack_require__.g !== "undefined" ? __webpack_require__.g : {});
};
const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
function genPropsAccessExp(name) {
return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
}
function genCacheKey(source, options) {
return source + JSON.stringify(
options,
(_, val) => typeof val === "function" ? val.toString() : val
);
}
const PatchFlags = {
"TEXT": 1,
"1": "TEXT",
"CLASS": 2,
"2": "CLASS",
"STYLE": 4,
"4": "STYLE",
"PROPS": 8,
"8": "PROPS",
"FULL_PROPS": 16,
"16": "FULL_PROPS",
"NEED_HYDRATION": 32,
"32": "NEED_HYDRATION",
"STABLE_FRAGMENT": 64,
"64": "STABLE_FRAGMENT",
"KEYED_FRAGMENT": 128,
"128": "KEYED_FRAGMENT",
"UNKEYED_FRAGMENT": 256,
"256": "UNKEYED_FRAGMENT",
"NEED_PATCH": 512,
"512": "NEED_PATCH",
"DYNAMIC_SLOTS": 1024,
"1024": "DYNAMIC_SLOTS",
"DEV_ROOT_FRAGMENT": 2048,
"2048": "DEV_ROOT_FRAGMENT",
"CACHED": -1,
"-1": "CACHED",
"BAIL": -2,
"-2": "BAIL"
};
const PatchFlagNames = {
[1]: `TEXT`,
[2]: `CLASS`,
[4]: `STYLE`,
[8]: `PROPS`,
[16]: `FULL_PROPS`,
[32]: `NEED_HYDRATION`,
[64]: `STABLE_FRAGMENT`,
[128]: `KEYED_FRAGMENT`,
[256]: `UNKEYED_FRAGMENT`,
[512]: `NEED_PATCH`,
[1024]: `DYNAMIC_SLOTS`,
[2048]: `DEV_ROOT_FRAGMENT`,
[-1]: `HOISTED`,
[-2]: `BAIL`
};
const ShapeFlags = {
"ELEMENT": 1,
"1": "ELEMENT",
"FUNCTIONAL_COMPONENT": 2,
"2": "FUNCTIONAL_COMPONENT",
"STATEFUL_COMPONENT": 4,
"4": "STATEFUL_COMPONENT",
"TEXT_CHILDREN": 8,
"8": "TEXT_CHILDREN",
"ARRAY_CHILDREN": 16,
"16": "ARRAY_CHILDREN",
"SLOTS_CHILDREN": 32,
"32": "SLOTS_CHILDREN",
"TELEPORT": 64,
"64": "TELEPORT",
"SUSPENSE": 128,
"128": "SUSPENSE",
"COMPONENT_SHOULD_KEEP_ALIVE": 256,
"256": "COMPONENT_SHOULD_KEEP_ALIVE",
"COMPONENT_KEPT_ALIVE": 512,
"512": "COMPONENT_KEPT_ALIVE",
"COMPONENT": 6,
"6": "COMPONENT"
};
const SlotFlags = {
"STABLE": 1,
"1": "STABLE",
"DYNAMIC": 2,
"2": "DYNAMIC",
"FORWARDED": 3,
"3": "FORWARDED"
};
const slotFlagsText = {
[1]: "STABLE",
[2]: "DYNAMIC",
[3]: "FORWARDED"
};
const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
const isGloballyAllowed = /* @__PURE__ */ shared_esm_bundler_makeMap(GLOBALS_ALLOWED);
const isGloballyWhitelisted = (/* unused pure expression or super */ null && (isGloballyAllowed));
const range = 2;
function generateCodeFrame(source, start = 0, end = source.length) {
start = Math.max(0, Math.min(start, source.length));
end = Math.max(0, Math.min(end, source.length));
if (start > end) return "";
let lines = source.split(/(\r?\n)/);
const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
lines = lines.filter((_, idx) => idx % 2 === 0);
let count = 0;
const res = [];
for (let i = 0; i < lines.length; i++) {
count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
if (count >= start) {
for (let j = i - range; j <= i + range || end > count; j++) {
if (j < 0 || j >= lines.length) continue;
const line = j + 1;
res.push(
`${line}${" ".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`
);
const lineLength = lines[j].length;
const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
if (j === i) {
const pad = start - (count - (lineLength + newLineSeqLength));
const length = Math.max(
1,
end > count ? lineLength - pad : end - start
);
res.push(` | ` + " ".repeat(pad) + "^".repeat(length));
} else if (j > i) {
if (end > count) {
const length = Math.max(Math.min(end - count, lineLength), 1);
res.push(` | ` + "^".repeat(length));
}
count += lineLength + newLineSeqLength;
}
}
break;
}
}
return res.join("\n");
}
function shared_esm_bundler_normalizeStyle(value) {
if (shared_esm_bundler_isArray(value)) {
const res = {};
for (let i = 0; i < value.length; i++) {
const item = value[i];
const normalized = shared_esm_bundler_isString(item) ? parseStringStyle(item) : shared_esm_bundler_normalizeStyle(item);
if (normalized) {
for (const key in normalized) {
res[key] = normalized[key];
}
}
}
return res;
} else if (shared_esm_bundler_isString(value) || shared_esm_bundler_isObject(value)) {
return value;
}
}
const listDelimiterRE = /;(?![^(]*\))/g;
const propertyDelimiterRE = /:([^]+)/;
const styleCommentRE = /\/\*[^]*?\*\//g;
function parseStringStyle(cssText) {
const ret = {};
cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
if (item) {
const tmp = item.split(propertyDelimiterRE);
tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
}
});
return ret;
}
function shared_esm_bundler_stringifyStyle(styles) {
if (!styles) return "";
if (shared_esm_bundler_isString(styles)) return styles;
let ret = "";
for (const key in styles) {
const value = styles[key];
if (shared_esm_bundler_isString(value) || typeof value === "number") {
const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
ret += `${normalizedKey}:${value};`;
}
}
return ret;
}
function shared_esm_bundler_normalizeClass(value) {
let res = "";
if (shared_esm_bundler_isString(value)) {
res = value;
} else if (shared_esm_bundler_isArray(value)) {
for (let i = 0; i < value.length; i++) {
const normalized = shared_esm_bundler_normalizeClass(value[i]);
if (normalized) {
res += normalized + " ";
}
}
} else if (shared_esm_bundler_isObject(value)) {
for (const name in value) {
if (value[name]) {
res += name + " ";
}
}
}
return res.trim();
}
function normalizeProps(props) {
if (!props) return null;
let { class: klass, style } = props;
if (klass && !shared_esm_bundler_isString(klass)) {
props.class = shared_esm_bundler_normalizeClass(klass);
}
if (style) {
props.style = shared_esm_bundler_normalizeStyle(style);
}
return props;
}
const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
const shared_esm_bundler_isHTMLTag = /* @__PURE__ */ shared_esm_bundler_makeMap(HTML_TAGS);
const shared_esm_bundler_isSVGTag = /* @__PURE__ */ shared_esm_bundler_makeMap(SVG_TAGS);
const shared_esm_bundler_isMathMLTag = /* @__PURE__ */ shared_esm_bundler_makeMap(MATH_TAGS);
const isVoidTag = /* @__PURE__ */ shared_esm_bundler_makeMap(VOID_TAGS);
const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
const isSpecialBooleanAttr = /* @__PURE__ */ shared_esm_bundler_makeMap(specialBooleanAttrs);
const shared_esm_bundler_isBooleanAttr = /* @__PURE__ */ shared_esm_bundler_makeMap(
specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
);
function shared_esm_bundler_includeBooleanAttr(value) {
return !!value || value === "";
}
const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
const attrValidationCache = {};
function isSSRSafeAttrName(name) {
if (attrValidationCache.hasOwnProperty(name)) {
return attrValidationCache[name];
}
const isUnsafe = unsafeAttrCharRE.test(name);
if (isUnsafe) {
console.error(`unsafe attribute name: ${name}`);
}
return attrValidationCache[name] = !isUnsafe;
}
const propsToAttrMap = {
acceptCharset: "accept-charset",
className: "class",
htmlFor: "for",
httpEquiv: "http-equiv"
};
const shared_esm_bundler_isKnownHtmlAttr = /* @__PURE__ */ (/* unused pure expression or super */ null && (shared_esm_bundler_makeMap(
`accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`
)));
const shared_esm_bundler_isKnownSvgAttr = /* @__PURE__ */ (/* unused pure expression or super */ null && (shared_esm_bundler_makeMap(
`xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
)));
const isKnownMathMLAttr = /* @__PURE__ */ (/* unused pure expression or super */ null && (shared_esm_bundler_makeMap(
`accent,accentunder,actiontype,align,alignmentscope,altimg,altimg-height,altimg-valign,altimg-width,alttext,bevelled,close,columnsalign,columnlines,columnspan,denomalign,depth,dir,display,displaystyle,encoding,equalcolumns,equalrows,fence,fontstyle,fontweight,form,frame,framespacing,groupalign,height,href,id,indentalign,indentalignfirst,indentalignlast,indentshift,indentshiftfirst,indentshiftlast,indextype,justify,largetop,largeop,lquote,lspace,mathbackground,mathcolor,mathsize,mathvariant,maxsize,minlabelspacing,mode,other,overflow,position,rowalign,rowlines,rowspan,rquote,rspace,scriptlevel,scriptminsize,scriptsizemultiplier,selection,separator,separators,shift,side,src,stackalign,stretchy,subscriptshift,superscriptshift,symmetric,voffset,width,widths,xlink:href,xlink:show,xlink:type,xmlns`
)));
function shared_esm_bundler_isRenderableAttrValue(value) {
if (value == null) {
return false;
}
const type = typeof value;
return type === "string" || type === "number" || type === "boolean";
}
const escapeRE = /["'&<>]/;
function escapeHtml(string) {
const str = "" + string;
const match = escapeRE.exec(str);
if (!match) {
return str;
}
let html = "";
let escaped;
let index;
let lastIndex = 0;
for (index = match.index; index < str.length; index++) {
switch (str.charCodeAt(index)) {
case 34:
escaped = """;
break;
case 38:
escaped = "&";
break;
case 39:
escaped = "'";
break;
case 60:
escaped = "<";
break;
case 62:
escaped = ">";
break;
default:
continue;
}
if (lastIndex !== index) {
html += str.slice(lastIndex, index);
}
lastIndex = index + 1;
html += escaped;
}
return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
}
const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
function escapeHtmlComment(src) {
return src.replace(commentStripRE, "");
}
const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
function shared_esm_bundler_getEscapedCssVarName(key, doubleEscape) {
return key.replace(
cssVarNameEscapeSymbolsRE,
(s) => doubleEscape ? s === '"' ? '\\\\\\"' : `\\\\${s}` : `\\${s}`
);
}
function looseCompareArrays(a, b) {
if (a.length !== b.length) return false;
let equal = true;
for (let i = 0; equal && i < a.length; i++) {
equal = looseEqual(a[i], b[i]);
}
return equal;
}
function looseEqual(a, b) {
if (a === b) return true;
let aValidType = isDate(a);
let bValidType = isDate(b);
if (aValidType || bValidType) {
return aValidType && bValidType ? a.getTime() === b.getTime() : false;
}
aValidType = isSymbol(a);
bValidType = isSymbol(b);
if (aValidType || bValidType) {
return a === b;
}
aValidType = shared_esm_bundler_isArray(a);
bValidType = shared_esm_bundler_isArray(b);
if (aValidType || bValidType) {
return aValidType && bValidType ? looseCompareArrays(a, b) : false;
}
aValidType = shared_esm_bundler_isObject(a);
bValidType = shared_esm_bundler_isObject(b);
if (aValidType || bValidType) {
if (!aValidType || !bValidType) {
return false;
}
const aKeysCount = Object.keys(a).length;
const bKeysCount = Object.keys(b).length;
if (aKeysCount !== bKeysCount) {
return false;
}
for (const key in a) {
const aHasKey = a.hasOwnProperty(key);
const bHasKey = b.hasOwnProperty(key);
if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
return false;
}
}
}
return String(a) === String(b);
}
function looseIndexOf(arr, val) {
return arr.findIndex((item) => looseEqual(item, val));
}
const shared_esm_bundler_isRef = (val) => {
return !!(val && val["__v_isRef"] === true);
};
const toDisplayString = (val) => {
return shared_esm_bundler_isString(val) ? val : val == null ? "" : shared_esm_bundler_isArray(val) || shared_esm_bundler_isObject(val) && (val.toString === objectToString || !shared_esm_bundler_isFunction(val.toString)) ? shared_esm_bundler_isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
};
const replacer = (_key, val) => {
if (shared_esm_bundler_isRef(val)) {
return replacer(_key, val.value);
} else if (isMap(val)) {
return {
[`Map(${val.size})`]: [...val.entries()].reduce(
(entries, [key, val2], i) => {
entries[stringifySymbol(key, i) + " =>"] = val2;
return entries;
},
{}
)
};
} else if (isSet(val)) {
return {
[`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
};
} else if (isSymbol(val)) {
return stringifySymbol(val);
} else if (shared_esm_bundler_isObject(val) && !shared_esm_bundler_isArray(val) && !isPlainObject(val)) {
return String(val);
}
return val;
};
const stringifySymbol = (v, i = "") => {
var _a;
return (
// Symbol.description in es2019+ so we need to cast here to pass
// the lib: es2016 check
isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
);
};
;// ./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
/**
* @vue/reactivity v3.5.13
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
function reactivity_esm_bundler_warn(msg, ...args) {
console.warn(`[Vue warn] ${msg}`, ...args);
}
let activeEffectScope;
class EffectScope {
constructor(detached = false) {
this.detached = detached;
/**
* @internal
*/
this._active = true;
/**
* @internal
*/
this.effects = [];
/**
* @internal
*/
this.cleanups = [];
this._isPaused = false;
this.parent = activeEffectScope;
if (!detached && activeEffectScope) {
this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
this
) - 1;
}
}
get active() {
return this._active;
}
pause() {
if (this._active) {
this._isPaused = true;
let i, l;
if (this.scopes) {
for (i = 0, l = this.scopes.length; i < l; i++) {
this.scopes[i].pause();
}
}
for (i = 0, l = this.effects.length; i < l; i++) {
this.effects[i].pause();
}
}
}
/**
* Resumes the effect scope, including all child scopes and effects.
*/
resume() {
if (this._active) {
if (this._isPaused) {
this._isPaused = false;
let i, l;
if (this.scopes) {
for (i = 0, l = this.scopes.length; i < l; i++) {
this.scopes[i].resume();
}
}
for (i = 0, l = this.effects.length; i < l; i++) {
this.effects[i].resume();
}
}
}
}
run(fn) {
if (this._active) {
const currentEffectScope = activeEffectScope;
try {
activeEffectScope = this;
return fn();
} finally {
activeEffectScope = currentEffectScope;
}
} else if (false) {}
}
/**
* This should only be called on non-detached scopes
* @internal
*/
on() {
activeEffectScope = this;
}
/**
* This should only be called on non-detached scopes
* @internal
*/
off() {
activeEffectScope = this.parent;
}
stop(fromParent) {
if (this._active) {
this._active = false;
let i, l;
for (i = 0, l = this.effects.length; i < l; i++) {
this.effects[i].stop();
}
this.effects.length = 0;
for (i = 0, l = this.cleanups.length; i < l; i++) {
this.cleanups[i]();
}
this.cleanups.length = 0;
if (this.scopes) {
for (i = 0, l = this.scopes.length; i < l; i++) {
this.scopes[i].stop(true);
}
this.scopes.length = 0;
}
if (!this.detached && this.parent && !fromParent) {
const last = this.parent.scopes.pop();
if (last && last !== this) {
this.parent.scopes[this.index] = last;
last.index = this.index;
}
}
this.parent = void 0;
}
}
}
function effectScope(detached) {
return new EffectScope(detached);
}
function getCurrentScope() {
return activeEffectScope;
}
function onScopeDispose(fn, failSilently = false) {
if (activeEffectScope) {
activeEffectScope.cleanups.push(fn);
} else if (false) {}
}
let activeSub;
const EffectFlags = {
"ACTIVE": 1,
"1": "ACTIVE",
"RUNNING": 2,
"2": "RUNNING",
"TRACKING": 4,
"4": "TRACKING",
"NOTIFIED": 8,
"8": "NOTIFIED",
"DIRTY": 16,
"16": "DIRTY",
"ALLOW_RECURSE": 32,
"32": "ALLOW_RECURSE",
"PAUSED": 64,
"64": "PAUSED"
};
const pausedQueueEffects = /* @__PURE__ */ new WeakSet();
class ReactiveEffect {
constructor(fn) {
this.fn = fn;
/**
* @internal
*/
this.deps = void 0;
/**
* @internal
*/
this.depsTail = void 0;
/**
* @internal
*/
this.flags = 1 | 4;
/**
* @internal
*/
this.next = void 0;
/**
* @internal
*/
this.cleanup = void 0;
this.scheduler = void 0;
if (activeEffectScope && activeEffectScope.active) {
activeEffectScope.effects.push(this);
}
}
pause() {
this.flags |= 64;
}
resume() {
if (this.flags & 64) {
this.flags &= ~64;
if (pausedQueueEffects.has(this)) {
pausedQueueEffects.delete(this);
this.trigger();
}
}
}
/**
* @internal
*/
notify() {
if (this.flags & 2 && !(this.flags & 32)) {
return;
}
if (!(this.flags & 8)) {
batch(this);
}
}
run() {
if (!(this.flags & 1)) {
return this.fn();
}
this.flags |= 2;
cleanupEffect(this);
prepareDeps(this);
const prevEffect = activeSub;
const prevShouldTrack = shouldTrack;
activeSub = this;
shouldTrack = true;
try {
return this.fn();
} finally {
if (false) {}
cleanupDeps(this);
activeSub = prevEffect;
shouldTrack = prevShouldTrack;
this.flags &= ~2;
}
}
stop() {
if (this.flags & 1) {
for (let link = this.deps; link; link = link.nextDep) {
removeSub(link);
}
this.deps = this.depsTail = void 0;
cleanupEffect(this);
this.onStop && this.onStop();
this.flags &= ~1;
}
}
trigger() {
if (this.flags & 64) {
pausedQueueEffects.add(this);
} else if (this.scheduler) {
this.scheduler();
} else {
this.runIfDirty();
}
}
/**
* @internal
*/
runIfDirty() {
if (isDirty(this)) {
this.run();
}
}
get dirty() {
return isDirty(this);
}
}
let batchDepth = 0;
let batchedSub;
let batchedComputed;
function batch(sub, isComputed = false) {
sub.flags |= 8;
if (isComputed) {
sub.next = batchedComputed;
batchedComputed = sub;
return;
}
sub.next = batchedSub;
batchedSub = sub;
}
function startBatch() {
batchDepth++;
}
function endBatch() {
if (--batchDepth > 0) {
return;
}
if (batchedComputed) {
let e = batchedComputed;
batchedComputed = void 0;
while (e) {
const next = e.next;
e.next = void 0;
e.flags &= ~8;
e = next;
}
}
let error;
while (batchedSub) {
let e = batchedSub;
batchedSub = void 0;
while (e) {
const next = e.next;
e.next = void 0;
e.flags &= ~8;
if (e.flags & 1) {
try {
;
e.trigger();
} catch (err) {
if (!error) error = err;
}
}
e = next;
}
}
if (error) throw error;
}
function prepareDeps(sub) {
for (let link = sub.deps; link; link = link.nextDep) {
link.version = -1;
link.prevActiveLink = link.dep.activeLink;
link.dep.activeLink = link;
}
}
function cleanupDeps(sub) {
let head;
let tail = sub.depsTail;
let link = tail;
while (link) {
const prev = link.prevDep;
if (link.version === -1) {
if (link === tail) tail = prev;
removeSub(link);
removeDep(link);
} else {
head = link;
}
link.dep.activeLink = link.prevActiveLink;
link.prevActiveLink = void 0;
link = prev;
}
sub.deps = head;
sub.depsTail = tail;
}
function isDirty(sub) {
for (let link = sub.deps; link; link = link.nextDep) {
if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
return true;
}
}
if (sub._dirty) {
return true;
}
return false;
}
function refreshComputed(computed) {
if (computed.flags & 4 && !(computed.flags & 16)) {
return;
}
computed.flags &= ~16;
if (computed.globalVersion === globalVersion) {
return;
}
computed.globalVersion = globalVersion;
const dep = computed.dep;
computed.flags |= 2;
if (dep.version > 0 && !computed.isSSR && computed.deps && !isDirty(computed)) {
computed.flags &= ~2;
return;
}
const prevSub = activeSub;
const prevShouldTrack = shouldTrack;
activeSub = computed;
shouldTrack = true;
try {
prepareDeps(computed);
const value = computed.fn(computed._value);
if (dep.version === 0 || hasChanged(value, computed._value)) {
computed._value = value;
dep.version++;
}
} catch (err) {
dep.version++;
throw err;
} finally {
activeSub = prevSub;
shouldTrack = prevShouldTrack;
cleanupDeps(computed);
computed.flags &= ~2;
}
}
function removeSub(link, soft = false) {
const { dep, prevSub, nextSub } = link;
if (prevSub) {
prevSub.nextSub = nextSub;
link.prevSub = void 0;
}
if (nextSub) {
nextSub.prevSub = prevSub;
link.nextSub = void 0;
}
if (false) {}
if (dep.subs === link) {
dep.subs = prevSub;
if (!prevSub && dep.computed) {
dep.computed.flags &= ~4;
for (let l = dep.computed.deps; l; l = l.nextDep) {
removeSub(l, true);
}
}
}
if (!soft && !--dep.sc && dep.map) {
dep.map.delete(dep.key);
}
}
function removeDep(link) {
const { prevDep, nextDep } = link;
if (prevDep) {
prevDep.nextDep = nextDep;
link.prevDep = void 0;
}
if (nextDep) {
nextDep.prevDep = prevDep;
link.nextDep = void 0;
}
}
function effect(fn, options) {
if (fn.effect instanceof ReactiveEffect) {
fn = fn.effect.fn;
}
const e = new ReactiveEffect(fn);
if (options) {
shared_esm_bundler_extend(e, options);
}
try {
e.run();
} catch (err) {
e.stop();
throw err;
}
const runner = e.run.bind(e);
runner.effect = e;
return runner;
}
function stop(runner) {
runner.effect.stop();
}
let shouldTrack = true;
const trackStack = [];
function reactivity_esm_bundler_pauseTracking() {
trackStack.push(shouldTrack);
shouldTrack = false;
}
function enableTracking() {
trackStack.push(shouldTrack);
shouldTrack = true;
}
function reactivity_esm_bundler_resetTracking() {
const last = trackStack.pop();
shouldTrack = last === void 0 ? true : last;
}
function onEffectCleanup(fn, failSilently = false) {
if (activeSub instanceof ReactiveEffect) {
activeSub.cleanup = fn;
} else if (false) {}
}
function cleanupEffect(e) {
const { cleanup } = e;
e.cleanup = void 0;
if (cleanup) {
const prevSub = activeSub;
activeSub = void 0;
try {
cleanup();
} finally {
activeSub = prevSub;
}
}
}
let globalVersion = 0;
class Link {
constructor(sub, dep) {
this.sub = sub;
this.dep = dep;
this.version = dep.version;
this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
}
}
class Dep {
constructor(computed) {
this.computed = computed;
this.version = 0;
/**
* Link between this dep and the current active effect
*/
this.activeLink = void 0;
/**
* Doubly linked list representing the subscribing effects (tail)
*/
this.subs = void 0;
/**
* For object property deps cleanup
*/
this.map = void 0;
this.key = void 0;
/**
* Subscriber counter
*/
this.sc = 0;
if (false) {}
}
track(debugInfo) {
if (!activeSub || !shouldTrack || activeSub === this.computed) {
return;
}
let link = this.activeLink;
if (link === void 0 || link.sub !== activeSub) {
link = this.activeLink = new Link(activeSub, this);
if (!activeSub.deps) {
activeSub.deps = activeSub.depsTail = link;
} else {
link.prevDep = activeSub.depsTail;
activeSub.depsTail.nextDep = link;
activeSub.depsTail = link;
}
addSub(link);
} else if (link.version === -1) {
link.version = this.version;
if (link.nextDep) {
const next = link.nextDep;
next.prevDep = link.prevDep;
if (link.prevDep) {
link.prevDep.nextDep = next;
}
link.prevDep = activeSub.depsTail;
link.nextDep = void 0;
activeSub.depsTail.nextDep = link;
activeSub.depsTail = link;
if (activeSub.deps === link) {
activeSub.deps = next;
}
}
}
if (false) {}
return link;
}
trigger(debugInfo) {
this.version++;
globalVersion++;
this.notify(debugInfo);
}
notify(debugInfo) {
startBatch();
try {
if (false) {}
for (let link = this.subs; link; link = link.prevSub) {
if (link.sub.notify()) {
;
link.sub.dep.notify();
}
}
} finally {
endBatch();
}
}
}
function addSub(link) {
link.dep.sc++;
if (link.sub.flags & 4) {
const computed = link.dep.computed;
if (computed && !link.dep.subs) {
computed.flags |= 4 | 16;
for (let l = computed.deps; l; l = l.nextDep) {
addSub(l);
}
}
const currentTail = link.dep.subs;
if (currentTail !== link) {
link.prevSub = currentTail;
if (currentTail) currentTail.nextSub = link;
}
if (false) {}
link.dep.subs = link;
}
}
const targetMap = /* @__PURE__ */ new WeakMap();
const ITERATE_KEY = Symbol(
false ? 0 : ""
);
const MAP_KEY_ITERATE_KEY = Symbol(
false ? 0 : ""
);
const ARRAY_ITERATE_KEY = Symbol(
false ? 0 : ""
);
function reactivity_esm_bundler_track(target, type, key) {
if (shouldTrack && activeSub) {
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 = new Dep());
dep.map = depsMap;
dep.key = key;
}
if (false) {} else {
dep.track();
}
}
}
function trigger(target, type, key, newValue, oldValue, oldTarget) {
const depsMap = targetMap.get(target);
if (!depsMap) {
globalVersion++;
return;
}
const run = (dep) => {
if (dep) {
if (false) {} else {
dep.trigger();
}
}
};
startBatch();
if (type === "clear") {
depsMap.forEach(run);
} else {
const targetIsArray = shared_esm_bundler_isArray(target);
const isArrayIndex = targetIsArray && isIntegerKey(key);
if (targetIsArray && key === "length") {
const newLength = Number(newValue);
depsMap.forEach((dep, key2) => {
if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
run(dep);
}
});
} else {
if (key !== void 0 || depsMap.has(void 0)) {
run(depsMap.get(key));
}
if (isArrayIndex) {
run(depsMap.get(ARRAY_ITERATE_KEY));
}
switch (type) {
case "add":
if (!targetIsArray) {
run(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
run(depsMap.get(MAP_KEY_ITERATE_KEY));
}
} else if (isArrayIndex) {
run(depsMap.get("length"));
}
break;
case "delete":
if (!targetIsArray) {
run(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
run(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
break;
case "set":
if (isMap(target)) {
run(depsMap.get(ITERATE_KEY));
}
break;
}
}
}
endBatch();
}
function getDepFromReactive(object, key) {
const depMap = targetMap.get(object);
return depMap && depMap.get(key);
}
function reactiveReadArray(array) {
const raw = reactivity_esm_bundler_toRaw(array);
if (raw === array) return raw;
reactivity_esm_bundler_track(raw, "iterate", ARRAY_ITERATE_KEY);
return reactivity_esm_bundler_isShallow(array) ? raw : raw.map(toReactive);
}
function shallowReadArray(arr) {
reactivity_esm_bundler_track(arr = reactivity_esm_bundler_toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
return arr;
}
const arrayInstrumentations = {
__proto__: null,
[Symbol.iterator]() {
return iterator(this, Symbol.iterator, toReactive);
},
concat(...args) {
return reactiveReadArray(this).concat(
...args.map((x) => shared_esm_bundler_isArray(x) ? reactiveReadArray(x) : x)
);
},
entries() {
return iterator(this, "entries", (value) => {
value[1] = toReactive(value[1]);
return value;
});
},
every(fn, thisArg) {
return apply(this, "every", fn, thisArg, void 0, arguments);
},
filter(fn, thisArg) {
return apply(this, "filter", fn, thisArg, (v) => v.map(toReactive), arguments);
},
find(fn, thisArg) {
return apply(this, "find", fn, thisArg, toReactive, arguments);
},
findIndex(fn, thisArg) {
return apply(this, "findIndex", fn, thisArg, void 0, arguments);
},
findLast(fn, thisArg) {
return apply(this, "findLast", fn, thisArg, toReactive, arguments);
},
findLastIndex(fn, thisArg) {
return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
},
// flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
forEach(fn, thisArg) {
return apply(this, "forEach", fn, thisArg, void 0, arguments);
},
includes(...args) {
return searchProxy(this, "includes", args);
},
indexOf(...args) {
return searchProxy(this, "indexOf", args);
},
join(separator) {
return reactiveReadArray(this).join(separator);
},
// keys() iterator only reads `length`, no optimisation required
lastIndexOf(...args) {
return searchProxy(this, "lastIndexOf", args);
},
map(fn, thisArg) {
return apply(this, "map", fn, thisArg, void 0, arguments);
},
pop() {
return noTracking(this, "pop");
},
push(...args) {
return noTracking(this, "push", args);
},
reduce(fn, ...args) {
return reduce(this, "reduce", fn, args);
},
reduceRight(fn, ...args) {
return reduce(this, "reduceRight", fn, args);
},
shift() {
return noTracking(this, "shift");
},
// slice could use ARRAY_ITERATE but also seems to beg for range tracking
some(fn, thisArg) {
return apply(this, "some", fn, thisArg, void 0, arguments);
},
splice(...args) {
return noTracking(this, "splice", args);
},
toReversed() {
return reactiveReadArray(this).toReversed();
},
toSorted(comparer) {
return reactiveReadArray(this).toSorted(comparer);
},
toSpliced(...args) {
return reactiveReadArray(this).toSpliced(...args);
},
unshift(...args) {
return noTracking(this, "unshift", args);
},
values() {
return iterator(this, "values", toReactive);
}
};
function iterator(self, method, wrapValue) {
const arr = shallowReadArray(self);
const iter = arr[method]();
if (arr !== self && !reactivity_esm_bundler_isShallow(self)) {
iter._next = iter.next;
iter.next = () => {
const result = iter._next();
if (result.value) {
result.value = wrapValue(result.value);
}
return result;
};
}
return iter;
}
const arrayProto = Array.prototype;
function apply(self, method, fn, thisArg, wrappedRetFn, args) {
const arr = shallowReadArray(self);
const needsWrap = arr !== self && !reactivity_esm_bundler_isShallow(self);
const methodFn = arr[method];
if (methodFn !== arrayProto[method]) {
const result2 = methodFn.apply(self, args);
return needsWrap ? toReactive(result2) : result2;
}
let wrappedFn = fn;
if (arr !== self) {
if (needsWrap) {
wrappedFn = function(item, index) {
return fn.call(this, toReactive(item), index, self);
};
} else if (fn.length > 2) {
wrappedFn = function(item, index) {
return fn.call(this, item, index, self);
};
}
}
const result = methodFn.call(arr, wrappedFn, thisArg);
return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
}
function reduce(self, method, fn, args) {
const arr = shallowReadArray(self);
let wrappedFn = fn;
if (arr !== self) {
if (!reactivity_esm_bundler_isShallow(self)) {
wrappedFn = function(acc, item, index) {
return fn.call(this, acc, toReactive(item), index, self);
};
} else if (fn.length > 3) {
wrappedFn = function(acc, item, index) {
return fn.call(this, acc, item, index, self);
};
}
}
return arr[method](wrappedFn, ...args);
}
function searchProxy(self, method, args) {
const arr = reactivity_esm_bundler_toRaw(self);
reactivity_esm_bundler_track(arr, "iterate", ARRAY_ITERATE_KEY);
const res = arr[method](...args);
if ((res === -1 || res === false) && isProxy(args[0])) {
args[0] = reactivity_esm_bundler_toRaw(args[0]);
return arr[method](...args);
}
return res;
}
function noTracking(self, method, args = []) {
reactivity_esm_bundler_pauseTracking();
startBatch();
const res = reactivity_esm_bundler_toRaw(self)[method].apply(self, args);
endBatch();
reactivity_esm_bundler_resetTracking();
return res;
}
const isNonTrackableKeys = /* @__PURE__ */ shared_esm_bundler_makeMap(`__proto__,__v_isRef,__isVue`);
const builtInSymbols = new Set(
/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
);
function reactivity_esm_bundler_hasOwnProperty(key) {
if (!isSymbol(key)) key = String(key);
const obj = reactivity_esm_bundler_toRaw(this);
reactivity_esm_bundler_track(obj, "has", key);
return obj.hasOwnProperty(key);
}
class BaseReactiveHandler {
constructor(_isReadonly = false, _isShallow = false) {
this._isReadonly = _isReadonly;
this._isShallow = _isShallow;
}
get(target, key, receiver) {
if (key === "__v_skip") return target["__v_skip"];
const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
if (key === "__v_isReactive") {
return !isReadonly2;
} else if (key === "__v_isReadonly") {
return isReadonly2;
} else if (key === "__v_isShallow") {
return isShallow2;
} else if (key === "__v_raw") {
if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
// this means the receiver is a user proxy of the reactive proxy
Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
return target;
}
return;
}
const targetIsArray = shared_esm_bundler_isArray(target);
if (!isReadonly2) {
let fn;
if (targetIsArray && (fn = arrayInstrumentations[key])) {
return fn;
}
if (key === "hasOwnProperty") {
return reactivity_esm_bundler_hasOwnProperty;
}
}
const res = Reflect.get(
target,
key,
// if this is a proxy wrapping a ref, return methods using the raw ref
// as receiver so that we don't have to call `toRaw` on the ref in all
// its class methods
reactivity_esm_bundler_isRef(target) ? target : receiver
);
if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
return res;
}
if (!isReadonly2) {
reactivity_esm_bundler_track(target, "get", key);
}
if (isShallow2) {
return res;
}
if (reactivity_esm_bundler_isRef(res)) {
return targetIsArray && isIntegerKey(key) ? res : res.value;
}
if (shared_esm_bundler_isObject(res)) {
return isReadonly2 ? readonly(res) : reactive(res);
}
return res;
}
}
class MutableReactiveHandler extends BaseReactiveHandler {
constructor(isShallow2 = false) {
super(false, isShallow2);
}
set(target, key, value, receiver) {
let oldValue = target[key];
if (!this._isShallow) {
const isOldValueReadonly = reactivity_esm_bundler_isReadonly(oldValue);
if (!reactivity_esm_bundler_isShallow(value) && !reactivity_esm_bundler_isReadonly(value)) {
oldValue = reactivity_esm_bundler_toRaw(oldValue);
value = reactivity_esm_bundler_toRaw(value);
}
if (!shared_esm_bundler_isArray(target) && reactivity_esm_bundler_isRef(oldValue) && !reactivity_esm_bundler_isRef(value)) {
if (isOldValueReadonly) {
return false;
} else {
oldValue.value = value;
return true;
}
}
}
const hadKey = shared_esm_bundler_isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
const result = Reflect.set(
target,
key,
value,
reactivity_esm_bundler_isRef(target) ? target : receiver
);
if (target === reactivity_esm_bundler_toRaw(receiver)) {
if (!hadKey) {
trigger(target, "add", key, value);
} else if (hasChanged(value, oldValue)) {
trigger(target, "set", key, value, oldValue);
}
}
return result;
}
deleteProperty(target, key) {
const hadKey = hasOwn(target, key);
const oldValue = target[key];
const result = Reflect.deleteProperty(target, key);
if (result && hadKey) {
trigger(target, "delete", key, void 0, oldValue);
}
return result;
}
has(target, key) {
const result = Reflect.has(target, key);
if (!isSymbol(key) || !builtInSymbols.has(key)) {
reactivity_esm_bundler_track(target, "has", key);
}
return result;
}
ownKeys(target) {
reactivity_esm_bundler_track(
target,
"iterate",
shared_esm_bundler_isArray(target) ? "length" : ITERATE_KEY
);
return Reflect.ownKeys(target);
}
}
class ReadonlyReactiveHandler extends BaseReactiveHandler {
constructor(isShallow2 = false) {
super(true, isShallow2);
}
set(target, key) {
if (false) {}
return true;
}
deleteProperty(target, key) {
if (false) {}
return true;
}
}
const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function createIterableMethod(method, isReadonly2, isShallow2) {
return function(...args) {
const target = this["__v_raw"];
const rawTarget = reactivity_esm_bundler_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 && reactivity_esm_bundler_track(
rawTarget,
"iterate",
isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
);
return {
// iterator protocol
next() {
const { value, done } = innerIterator.next();
return done ? { value, done } : {
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
done
};
},
// iterable protocol
[Symbol.iterator]() {
return this;
}
};
};
}
function createReadonlyMethod(type) {
return function(...args) {
if (false) {}
return type === "delete" ? false : type === "clear" ? void 0 : this;
};
}
function createInstrumentations(readonly, shallow) {
const instrumentations = {
get(key) {
const target = this["__v_raw"];
const rawTarget = reactivity_esm_bundler_toRaw(target);
const rawKey = reactivity_esm_bundler_toRaw(key);
if (!readonly) {
if (hasChanged(key, rawKey)) {
reactivity_esm_bundler_track(rawTarget, "get", key);
}
reactivity_esm_bundler_track(rawTarget, "get", rawKey);
}
const { has } = getProto(rawTarget);
const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
if (has.call(rawTarget, key)) {
return wrap(target.get(key));
} else if (has.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
} else if (target !== rawTarget) {
target.get(key);
}
},
get size() {
const target = this["__v_raw"];
!readonly && reactivity_esm_bundler_track(reactivity_esm_bundler_toRaw(target), "iterate", ITERATE_KEY);
return Reflect.get(target, "size", target);
},
has(key) {
const target = this["__v_raw"];
const rawTarget = reactivity_esm_bundler_toRaw(target);
const rawKey = reactivity_esm_bundler_toRaw(key);
if (!readonly) {
if (hasChanged(key, rawKey)) {
reactivity_esm_bundler_track(rawTarget, "has", key);
}
reactivity_esm_bundler_track(rawTarget, "has", rawKey);
}
return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
},
forEach(callback, thisArg) {
const observed = this;
const target = observed["__v_raw"];
const rawTarget = reactivity_esm_bundler_toRaw(target);
const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
!readonly && reactivity_esm_bundler_track(rawTarget, "iterate", ITERATE_KEY);
return target.forEach((value, key) => {
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
}
};
shared_esm_bundler_extend(
instrumentations,
readonly ? {
add: createReadonlyMethod("add"),
set: createReadonlyMethod("set"),
delete: createReadonlyMethod("delete"),
clear: createReadonlyMethod("clear")
} : {
add(value) {
if (!shallow && !reactivity_esm_bundler_isShallow(value) && !reactivity_esm_bundler_isReadonly(value)) {
value = reactivity_esm_bundler_toRaw(value);
}
const target = reactivity_esm_bundler_toRaw(this);
const proto = getProto(target);
const hadKey = proto.has.call(target, value);
if (!hadKey) {
target.add(value);
trigger(target, "add", value, value);
}
return this;
},
set(key, value) {
if (!shallow && !reactivity_esm_bundler_isShallow(value) && !reactivity_esm_bundler_isReadonly(value)) {
value = reactivity_esm_bundler_toRaw(value);
}
const target = reactivity_esm_bundler_toRaw(this);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);
if (!hadKey) {
key = reactivity_esm_bundler_toRaw(key);
hadKey = has.call(target, key);
} else if (false) {}
const oldValue = get.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;
},
delete(key) {
const target = reactivity_esm_bundler_toRaw(this);
const { has, get } = getProto(target);
let hadKey = has.call(target, key);
if (!hadKey) {
key = reactivity_esm_bundler_toRaw(key);
hadKey = has.call(target, key);
} else if (false) {}
const oldValue = get ? get.call(target, key) : void 0;
const result = target.delete(key);
if (hadKey) {
trigger(target, "delete", key, void 0, oldValue);
}
return result;
},
clear() {
const target = reactivity_esm_bundler_toRaw(this);
const hadItems = target.size !== 0;
const oldTarget = false ? 0 : void 0;
const result = target.clear();
if (hadItems) {
trigger(
target,
"clear",
void 0,
void 0,
oldTarget
);
}
return result;
}
}
);
const iteratorMethods = [
"keys",
"values",
"entries",
Symbol.iterator
];
iteratorMethods.forEach((method) => {
instrumentations[method] = createIterableMethod(method, readonly, shallow);
});
return instrumentations;
}
function createInstrumentationGetter(isReadonly2, shallow) {
const instrumentations = createInstrumentations(isReadonly2, shallow);
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, has, key) {
const rawKey = reactivity_esm_bundler_toRaw(key);
if (rawKey !== key && has.call(target, rawKey)) {
const type = toRawType(target);
reactivity_esm_bundler_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 /* COMMON */;
case "Map":
case "Set":
case "WeakMap":
case "WeakSet":
return 2 /* COLLECTION */;
default:
return 0 /* INVALID */;
}
}
function getTargetType(value) {
return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(shared_esm_bundler_toRawType(value));
}
function reactive(target) {
if (reactivity_esm_bundler_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 (!shared_esm_bundler_isObject(target)) {
if (false) {}
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 /* INVALID */) {
return target;
}
const proxy = new Proxy(
target,
targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers
);
proxyMap.set(target, proxy);
return proxy;
}
function reactivity_esm_bundler_isReactive(value) {
if (reactivity_esm_bundler_isReadonly(value)) {
return reactivity_esm_bundler_isReactive(value["__v_raw"]);
}
return !!(value && value["__v_isReactive"]);
}
function reactivity_esm_bundler_isReadonly(value) {
return !!(value && value["__v_isReadonly"]);
}
function reactivity_esm_bundler_isShallow(value) {
return !!(value && value["__v_isShallow"]);
}
function isProxy(value) {
return value ? !!value["__v_raw"] : false;
}
function reactivity_esm_bundler_toRaw(observed) {
const raw = observed && observed["__v_raw"];
return raw ? reactivity_esm_bundler_toRaw(raw) : observed;
}
function markRaw(value) {
if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) {
def(value, "__v_skip", true);
}
return value;
}
const toReactive = (value) => shared_esm_bundler_isObject(value) ? reactive(value) : value;
const toReadonly = (value) => shared_esm_bundler_isObject(value) ? readonly(value) : value;
function reactivity_esm_bundler_isRef(r) {
return r ? r["__v_isRef"] === true : false;
}
function ref(value) {
return createRef(value, false);
}
function reactivity_esm_bundler_shallowRef(value) {
return createRef(value, true);
}
function createRef(rawValue, shallow) {
if (reactivity_esm_bundler_isRef(rawValue)) {
return rawValue;
}
return new RefImpl(rawValue, shallow);
}
class RefImpl {
constructor(value, isShallow2) {
this.dep = new Dep();
this["__v_isRef"] = true;
this["__v_isShallow"] = false;
this._rawValue = isShallow2 ? value : reactivity_esm_bundler_toRaw(value);
this._value = isShallow2 ? value : toReactive(value);
this["__v_isShallow"] = isShallow2;
}
get value() {
if (false) {} else {
this.dep.track();
}
return this._value;
}
set value(newValue) {
const oldValue = this._rawValue;
const useDirectValue = this["__v_isShallow"] || reactivity_esm_bundler_isShallow(newValue) || reactivity_esm_bundler_isReadonly(newValue);
newValue = useDirectValue ? newValue : reactivity_esm_bundler_toRaw(newValue);
if (hasChanged(newValue, oldValue)) {
this._rawValue = newValue;
this._value = useDirectValue ? newValue : toReactive(newValue);
if (false) {} else {
this.dep.trigger();
}
}
}
}
function triggerRef(ref2) {
if (ref2.dep) {
if (false) {} else {
ref2.dep.trigger();
}
}
}
function unref(ref2) {
return reactivity_esm_bundler_isRef(ref2) ? ref2.value : ref2;
}
function toValue(source) {
return shared_esm_bundler_isFunction(source) ? source() : unref(source);
}
const shallowUnwrapHandlers = {
get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
set: (target, key, value, receiver) => {
const oldValue = target[key];
if (reactivity_esm_bundler_isRef(oldValue) && !reactivity_esm_bundler_isRef(value)) {
oldValue.value = value;
return true;
} else {
return Reflect.set(target, key, value, receiver);
}
}
};
function proxyRefs(objectWithRefs) {
return reactivity_esm_bundler_isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
}
class CustomRefImpl {
constructor(factory) {
this["__v_isRef"] = true;
this._value = void 0;
const dep = this.dep = new Dep();
const { get, set } = factory(dep.track.bind(dep), dep.trigger.bind(dep));
this._get = get;
this._set = set;
}
get value() {
return this._value = this._get();
}
set value(newVal) {
this._set(newVal);
}
}
function customRef(factory) {
return new CustomRefImpl(factory);
}
function toRefs(object) {
if (false) {}
const ret = shared_esm_bundler_isArray(object) ? new Array(object.length) : {};
for (const key in object) {
ret[key] = propertyToRef(object, key);
}
return ret;
}
class ObjectRefImpl {
constructor(_object, _key, _defaultValue) {
this._object = _object;
this._key = _key;
this._defaultValue = _defaultValue;
this["__v_isRef"] = true;
this._value = void 0;
}
get value() {
const val = this._object[this._key];
return this._value = val === void 0 ? this._defaultValue : val;
}
set value(newVal) {
this._object[this._key] = newVal;
}
get dep() {
return getDepFromReactive(reactivity_esm_bundler_toRaw(this._object), this._key);
}
}
class GetterRefImpl {
constructor(_getter) {
this._getter = _getter;
this["__v_isRef"] = true;
this["__v_isReadonly"] = true;
this._value = void 0;
}
get value() {
return this._value = this._getter();
}
}
function toRef(source, key, defaultValue) {
if (reactivity_esm_bundler_isRef(source)) {
return source;
} else if (shared_esm_bundler_isFunction(source)) {
return new GetterRefImpl(source);
} else if (shared_esm_bundler_isObject(source) && arguments.length > 1) {
return propertyToRef(source, key, defaultValue);
} else {
return ref(source);
}
}
function propertyToRef(source, key, defaultValue) {
const val = source[key];
return reactivity_esm_bundler_isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
}
class ComputedRefImpl {
constructor(fn, setter, isSSR) {
this.fn = fn;
this.setter = setter;
/**
* @internal
*/
this._value = void 0;
/**
* @internal
*/
this.dep = new Dep(this);
/**
* @internal
*/
this.__v_isRef = true;
// TODO isolatedDeclarations "__v_isReadonly"
// A computed is also a subscriber that tracks other deps
/**
* @internal
*/
this.deps = void 0;
/**
* @internal
*/
this.depsTail = void 0;
/**
* @internal
*/
this.flags = 16;
/**
* @internal
*/
this.globalVersion = globalVersion - 1;
/**
* @internal
*/
this.next = void 0;
// for backwards compat
this.effect = this;
this["__v_isReadonly"] = !setter;
this.isSSR = isSSR;
}
/**
* @internal
*/
notify() {
this.flags |= 16;
if (!(this.flags & 8) && // avoid infinite self recursion
activeSub !== this) {
batch(this, true);
return true;
} else if (false) {}
}
get value() {
const link = false ? 0 : this.dep.track();
refreshComputed(this);
if (link) {
link.version = this.dep.version;
}
return this._value;
}
set value(newValue) {
if (this.setter) {
this.setter(newValue);
} else if (false) {}
}
}
function computed(getterOrOptions, debugOptions, isSSR = false) {
let getter;
let setter;
if (shared_esm_bundler_isFunction(getterOrOptions)) {
getter = getterOrOptions;
} else {
getter = getterOrOptions.get;
setter = getterOrOptions.set;
}
const cRef = new ComputedRefImpl(getter, setter, isSSR);
if (false) {}
return cRef;
}
const TrackOpTypes = {
"GET": "get",
"HAS": "has",
"ITERATE": "iterate"
};
const TriggerOpTypes = {
"SET": "set",
"ADD": "add",
"DELETE": "delete",
"CLEAR": "clear"
};
const ReactiveFlags = {
"SKIP": "__v_skip",
"IS_REACTIVE": "__v_isReactive",
"IS_READONLY": "__v_isReadonly",
"IS_SHALLOW": "__v_isShallow",
"RAW": "__v_raw",
"IS_REF": "__v_isRef"
};
const WatchErrorCodes = {
"WATCH_GETTER": 2,
"2": "WATCH_GETTER",
"WATCH_CALLBACK": 3,
"3": "WATCH_CALLBACK",
"WATCH_CLEANUP": 4,
"4": "WATCH_CLEANUP"
};
const INITIAL_WATCHER_VALUE = {};
const cleanupMap = /* @__PURE__ */ new WeakMap();
let activeWatcher = void 0;
function getCurrentWatcher() {
return activeWatcher;
}
function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
if (owner) {
let cleanups = cleanupMap.get(owner);
if (!cleanups) cleanupMap.set(owner, cleanups = []);
cleanups.push(cleanupFn);
} else if (false) {}
}
function reactivity_esm_bundler_watch(source, cb, options = EMPTY_OBJ) {
const { immediate, deep, once, scheduler, augmentJob, call } = options;
const warnInvalidSource = (s) => {
(options.onWarn || reactivity_esm_bundler_warn)(
`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 reactiveGetter = (source2) => {
if (deep) return source2;
if (reactivity_esm_bundler_isShallow(source2) || deep === false || deep === 0)
return traverse(source2, 1);
return traverse(source2);
};
let effect;
let getter;
let cleanup;
let boundCleanup;
let forceTrigger = false;
let isMultiSource = false;
if (reactivity_esm_bundler_isRef(source)) {
getter = () => source.value;
forceTrigger = reactivity_esm_bundler_isShallow(source);
} else if (reactivity_esm_bundler_isReactive(source)) {
getter = () => reactiveGetter(source);
forceTrigger = true;
} else if (shared_esm_bundler_isArray(source)) {
isMultiSource = true;
forceTrigger = source.some((s) => reactivity_esm_bundler_isReactive(s) || reactivity_esm_bundler_isShallow(s));
getter = () => source.map((s) => {
if (reactivity_esm_bundler_isRef(s)) {
return s.value;
} else if (reactivity_esm_bundler_isReactive(s)) {
return reactiveGetter(s);
} else if (shared_esm_bundler_isFunction(s)) {
return call ? call(s, 2) : s();
} else {
false && 0;
}
});
} else if (shared_esm_bundler_isFunction(source)) {
if (cb) {
getter = call ? () => call(source, 2) : source;
} else {
getter = () => {
if (cleanup) {
reactivity_esm_bundler_pauseTracking();
try {
cleanup();
} finally {
reactivity_esm_bundler_resetTracking();
}
}
const currentEffect = activeWatcher;
activeWatcher = effect;
try {
return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
} finally {
activeWatcher = currentEffect;
}
};
}
} else {
getter = shared_esm_bundler_NOOP;
false && 0;
}
if (cb && deep) {
const baseGetter = getter;
const depth = deep === true ? Infinity : deep;
getter = () => traverse(baseGetter(), depth);
}
const scope = getCurrentScope();
const watchHandle = () => {
effect.stop();
if (scope && scope.active) {
remove(scope.effects, effect);
}
};
if (once && cb) {
const _cb = cb;
cb = (...args) => {
_cb(...args);
watchHandle();
};
}
let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
const job = (immediateFirstRun) => {
if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) {
return;
}
if (cb) {
const newValue = effect.run();
if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
if (cleanup) {
cleanup();
}
const currentWatcher = activeWatcher;
activeWatcher = effect;
try {
const args = [
newValue,
// pass undefined as the old value when it's changed for the first time
oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
boundCleanup
];
call ? call(cb, 3, args) : (
// @ts-expect-error
cb(...args)
);
oldValue = newValue;
} finally {
activeWatcher = currentWatcher;
}
}
} else {
effect.run();
}
};
if (augmentJob) {
augmentJob(job);
}
effect = new ReactiveEffect(getter);
effect.scheduler = scheduler ? () => scheduler(job, false) : job;
boundCleanup = (fn) => onWatcherCleanup(fn, false, effect);
cleanup = effect.onStop = () => {
const cleanups = cleanupMap.get(effect);
if (cleanups) {
if (call) {
call(cleanups, 4);
} else {
for (const cleanup2 of cleanups) cleanup2();
}
cleanupMap.delete(effect);
}
};
if (false) {}
if (cb) {
if (immediate) {
job(true);
} else {
oldValue = effect.run();
}
} else if (scheduler) {
scheduler(job.bind(null, true), true);
} else {
effect.run();
}
watchHandle.pause = effect.pause.bind(effect);
watchHandle.resume = effect.resume.bind(effect);
watchHandle.stop = watchHandle;
return watchHandle;
}
function traverse(value, depth = Infinity, seen) {
if (depth <= 0 || !shared_esm_bundler_isObject(value) || value["__v_skip"]) {
return value;
}
seen = seen || /* @__PURE__ */ new Set();
if (seen.has(value)) {
return value;
}
seen.add(value);
depth--;
if (reactivity_esm_bundler_isRef(value)) {
traverse(value.value, depth, seen);
} else if (shared_esm_bundler_isArray(value)) {
for (let i = 0; i < value.length; i++) {
traverse(value[i], depth, seen);
}
} else if (isSet(value) || isMap(value)) {
value.forEach((v) => {
traverse(v, depth, seen);
});
} else if (isPlainObject(value)) {
for (const key in value) {
traverse(value[key], depth, seen);
}
for (const key of Object.getOwnPropertySymbols(value)) {
if (Object.prototype.propertyIsEnumerable.call(value, key)) {
traverse(value[key], depth, seen);
}
}
}
return value;
}
;// ./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
/**
* @vue/runtime-core v3.5.13
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
const stack = [];
function pushWarningContext(vnode) {
stack.push(vnode);
}
function popWarningContext() {
stack.pop();
}
let isWarning = false;
function warn$1(msg, ...args) {
if (isWarning) return;
isWarning = true;
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,
[
// eslint-disable-next-line no-restricted-syntax
msg + args.map((a) => {
var _a, _b;
return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
}).join(""),
instance && instance.proxy,
trace.map(
({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
).join("\n"),
trace
]
);
} else {
const warnArgs = [`[Vue warn]: ${msg}`, ...args];
if (trace.length && // avoid spamming console during tests
true) {
warnArgs.push(`
`, ...formatTrace(trace));
}
console.warn(...warnArgs);
}
resetTracking();
isWarning = false;
}
function getComponentTrace() {
let currentVNode = stack[stack.length - 1];
if (!currentVNode) {
return [];
}
const normalizedStack = [];
while (currentVNode) {
const last = normalizedStack[0];
if (last && last.vnode === currentVNode) {
last.recurseCount++;
} else {
normalizedStack.push({
vnode: currentVNode,
recurseCount: 0
});
}
const parentInstance = currentVNode.component && currentVNode.component.parent;
currentVNode = parentInstance && parentInstance.vnode;
}
return normalizedStack;
}
function formatTrace(trace) {
const logs = [];
trace.forEach((entry, i) => {
logs.push(...i === 0 ? [] : [`
`], ...formatTraceEntry(entry));
});
return logs;
}
function formatTraceEntry({ vnode, recurseCount }) {
const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
const isRoot = vnode.component ? vnode.component.parent == null : false;
const open = ` at <${formatComponentName(
vnode.component,
vnode.type,
isRoot
)}`;
const close = `>` + postfix;
return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
}
function formatProps(props) {
const res = [];
const keys = Object.keys(props);
keys.slice(0, 3).forEach((key) => {
res.push(...formatProp(key, props[key]));
});
if (keys.length > 3) {
res.push(` ...`);
}
return res;
}
function formatProp(key, value, raw) {
if (isString(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(value)) {
return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
} else {
value = toRaw(value);
return raw ? value : [`${key}=`, value];
}
}
function assertNumber(val, type) {
if (true) return;
if (val === void 0) {
return;
} else if (typeof val !== "number") {
warn$1(`${type} is not a valid number - got ${JSON.stringify(val)}.`);
} else if (isNaN(val)) {
warn$1(`${type} is NaN - the duration expression might be incorrect.`);
}
}
const ErrorCodes = {
"SETUP_FUNCTION": 0,
"0": "SETUP_FUNCTION",
"RENDER_FUNCTION": 1,
"1": "RENDER_FUNCTION",
"NATIVE_EVENT_HANDLER": 5,
"5": "NATIVE_EVENT_HANDLER",
"COMPONENT_EVENT_HANDLER": 6,
"6": "COMPONENT_EVENT_HANDLER",
"VNODE_HOOK": 7,
"7": "VNODE_HOOK",
"DIRECTIVE_HOOK": 8,
"8": "DIRECTIVE_HOOK",
"TRANSITION_HOOK": 9,
"9": "TRANSITION_HOOK",
"APP_ERROR_HANDLER": 10,
"10": "APP_ERROR_HANDLER",
"APP_WARN_HANDLER": 11,
"11": "APP_WARN_HANDLER",
"FUNCTION_REF": 12,
"12": "FUNCTION_REF",
"ASYNC_COMPONENT_LOADER": 13,
"13": "ASYNC_COMPONENT_LOADER",
"SCHEDULER": 14,
"14": "SCHEDULER",
"COMPONENT_UPDATE": 15,
"15": "COMPONENT_UPDATE",
"APP_UNMOUNT_CLEANUP": 16,
"16": "APP_UNMOUNT_CLEANUP"
};
const ErrorTypeStrings$1 = {
["sp"]: "serverPrefetch hook",
["bc"]: "beforeCreate hook",
["c"]: "created hook",
["bm"]: "beforeMount hook",
["m"]: "mounted hook",
["bu"]: "beforeUpdate hook",
["u"]: "updated",
["bum"]: "beforeUnmount hook",
["um"]: "unmounted hook",
["a"]: "activated hook",
["da"]: "deactivated hook",
["ec"]: "errorCaptured hook",
["rtc"]: "renderTracked hook",
["rtg"]: "renderTriggered hook",
[0]: "setup function",
[1]: "render function",
[2]: "watcher getter",
[3]: "watcher callback",
[4]: "watcher cleanup function",
[5]: "native event handler",
[6]: "component event handler",
[7]: "vnode hook",
[8]: "directive hook",
[9]: "transition hook",
[10]: "app errorHandler",
[11]: "app warnHandler",
[12]: "ref function",
[13]: "async component loader",
[14]: "scheduler flush",
[15]: "component update",
[16]: "app unmount cleanup function"
};
function callWithErrorHandling(fn, instance, type, args) {
try {
return args ? fn(...args) : fn();
} catch (err) {
handleError(err, instance, type);
}
}
function callWithAsyncErrorHandling(fn, instance, type, args) {
if (shared_esm_bundler_isFunction(fn)) {
const res = callWithErrorHandling(fn, instance, type, args);
if (res && isPromise(res)) {
res.catch((err) => {
handleError(err, instance, type);
});
}
return res;
}
if (shared_esm_bundler_isArray(fn)) {
const values = [];
for (let i = 0; i < fn.length; i++) {
values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
}
return values;
} else if (false) {}
}
function handleError(err, instance, type, throwInDev = true) {
const contextVNode = instance ? instance.vnode : null;
const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
if (instance) {
let cur = instance.parent;
const exposedInstance = instance.proxy;
const errorInfo = false ? 0 : `https://vuejs.org/error-reference/#runtime-${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;
}
if (errorHandler) {
reactivity_esm_bundler_pauseTracking();
callWithErrorHandling(errorHandler, null, 10, [
err,
exposedInstance,
errorInfo
]);
reactivity_esm_bundler_resetTracking();
return;
}
}
logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
}
function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
if (false) {} else if (throwInProd) {
throw err;
} else {
console.error(err);
}
}
const queue = [];
let flushIndex = -1;
const pendingPostFlushCbs = [];
let activePostFlushCbs = null;
let postFlushIndex = 0;
const resolvedPromise = /* @__PURE__ */ Promise.resolve();
let currentFlushPromise = 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 middleJob = queue[middle];
const middleJobId = getId(middleJob);
if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
start = middle + 1;
} else {
end = middle;
}
}
return start;
}
function queueJob(job) {
if (!(job.flags & 1)) {
const jobId = getId(job);
const lastJob = queue[queue.length - 1];
if (!lastJob || // fast path when the job id is larger than the tail
!(job.flags & 2) && jobId >= getId(lastJob)) {
queue.push(job);
} else {
queue.splice(findInsertionIndex(jobId), 0, job);
}
job.flags |= 1;
queueFlush();
}
}
function queueFlush() {
if (!currentFlushPromise) {
currentFlushPromise = resolvedPromise.then(flushJobs);
}
}
function queuePostFlushCb(cb) {
if (!shared_esm_bundler_isArray(cb)) {
if (activePostFlushCbs && cb.id === -1) {
activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
} else if (!(cb.flags & 1)) {
pendingPostFlushCbs.push(cb);
cb.flags |= 1;
}
} else {
pendingPostFlushCbs.push(...cb);
}
queueFlush();
}
function flushPreFlushCbs(instance, seen, i = flushIndex + 1) {
if (false) {}
for (; i < queue.length; i++) {
const cb = queue[i];
if (cb && cb.flags & 2) {
if (instance && cb.id !== instance.uid) {
continue;
}
if (false) {}
queue.splice(i, 1);
i--;
if (cb.flags & 4) {
cb.flags &= ~1;
}
cb();
if (!(cb.flags & 4)) {
cb.flags &= ~1;
}
}
}
}
function flushPostFlushCbs(seen) {
if (pendingPostFlushCbs.length) {
const deduped = [...new Set(pendingPostFlushCbs)].sort(
(a, b) => getId(a) - getId(b)
);
pendingPostFlushCbs.length = 0;
if (activePostFlushCbs) {
activePostFlushCbs.push(...deduped);
return;
}
activePostFlushCbs = deduped;
if (false) {}
for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
const cb = activePostFlushCbs[postFlushIndex];
if (false) {}
if (cb.flags & 4) {
cb.flags &= ~1;
}
if (!(cb.flags & 8)) cb();
cb.flags &= ~1;
}
activePostFlushCbs = null;
postFlushIndex = 0;
}
}
const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
function flushJobs(seen) {
if (false) {}
const check = false ? 0 : shared_esm_bundler_NOOP;
try {
for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex];
if (job && !(job.flags & 8)) {
if (false) {}
if (job.flags & 4) {
job.flags &= ~1;
}
callWithErrorHandling(
job,
job.i,
job.i ? 15 : 14
);
if (!(job.flags & 4)) {
job.flags &= ~1;
}
}
}
} finally {
for (; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex];
if (job) {
job.flags &= ~1;
}
}
flushIndex = -1;
queue.length = 0;
flushPostFlushCbs(seen);
currentFlushPromise = null;
if (queue.length || pendingPostFlushCbs.length) {
flushJobs(seen);
}
}
}
function checkRecursiveUpdates(seen, fn) {
const count = seen.get(fn) || 0;
if (count > RECURSION_LIMIT) {
const instance = fn.i;
const componentName = instance && getComponentName(instance.type);
handleError(
`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,
null,
10
);
return true;
}
seen.set(fn, count + 1);
return false;
}
let isHmrUpdating = false;
const hmrDirtyComponents = /* @__PURE__ */ new Map();
if (false) {}
const map = /* @__PURE__ */ new Map();
function registerHMR(instance) {
const id = instance.type.__hmrId;
let record = map.get(id);
if (!record) {
createRecord(id, instance.type);
record = map.get(id);
}
record.instances.add(instance);
}
function unregisterHMR(instance) {
map.get(instance.type.__hmrId).instances.delete(instance);
}
function createRecord(id, initialDef) {
if (map.has(id)) {
return false;
}
map.set(id, {
initialDef: normalizeClassComponent(initialDef),
instances: /* @__PURE__ */ new Set()
});
return true;
}
function normalizeClassComponent(component) {
return isClassComponent(component) ? component.__vccOpts : component;
}
function rerender(id, newRender) {
const record = map.get(id);
if (!record) {
return;
}
record.initialDef.render = newRender;
[...record.instances].forEach((instance) => {
if (newRender) {
instance.render = newRender;
normalizeClassComponent(instance.type).render = newRender;
}
instance.renderCache = [];
isHmrUpdating = true;
instance.update();
isHmrUpdating = false;
});
}
function reload(id, newComp) {
const record = map.get(id);
if (!record) return;
newComp = normalizeClassComponent(newComp);
updateComponentDef(record.initialDef, newComp);
const instances = [...record.instances];
for (let i = 0; i < instances.length; i++) {
const instance = instances[i];
const oldComp = normalizeClassComponent(instance.type);
let dirtyInstances = hmrDirtyComponents.get(oldComp);
if (!dirtyInstances) {
if (oldComp !== record.initialDef) {
updateComponentDef(oldComp, newComp);
}
hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
}
dirtyInstances.add(instance);
instance.appContext.propsCache.delete(instance.type);
instance.appContext.emitsCache.delete(instance.type);
instance.appContext.optionsCache.delete(instance.type);
if (instance.ceReload) {
dirtyInstances.add(instance);
instance.ceReload(newComp.styles);
dirtyInstances.delete(instance);
} else if (instance.parent) {
queueJob(() => {
isHmrUpdating = true;
instance.parent.update();
isHmrUpdating = false;
dirtyInstances.delete(instance);
});
} else if (instance.appContext.reload) {
instance.appContext.reload();
} else if (typeof window !== "undefined") {
window.location.reload();
} else {
console.warn(
"[HMR] Root or manually mounted instance modified. Full reload required."
);
}
if (instance.root.ce && instance !== instance.root) {
instance.root.ce._removeChildStyle(oldComp);
}
}
queuePostFlushCb(() => {
hmrDirtyComponents.clear();
});
}
function updateComponentDef(oldComp, newComp) {
extend(oldComp, newComp);
for (const key in oldComp) {
if (key !== "__file" && !(key in newComp)) {
delete oldComp[key];
}
}
}
function tryWrap(fn) {
return (id, arg) => {
try {
return fn(id, arg);
} catch (e) {
console.error(e);
console.warn(
`[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
);
}
};
}
let devtools$1;
let buffer = [];
let devtoolsNotInstalled = false;
function emit$1(event, ...args) {
if (devtools$1) {
devtools$1.emit(event, ...args);
} else if (!devtoolsNotInstalled) {
buffer.push({ event, args });
}
}
function setDevtoolsHook$1(hook, target) {
var _a, _b;
devtools$1 = hook;
if (devtools$1) {
devtools$1.enabled = true;
buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args));
buffer = [];
} else if (
// handle late devtools injection - only do this if we are in an actual
// browser environment to avoid the timer handle stalling test runner exit
// (#4815)
typeof window !== "undefined" && // some envs mock window but not fully
window.HTMLElement && // also exclude jsdom
// eslint-disable-next-line no-restricted-syntax
!((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
) {
const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
replay.push((newHook) => {
setDevtoolsHook$1(newHook, target);
});
setTimeout(() => {
if (!devtools$1) {
target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
devtoolsNotInstalled = true;
buffer = [];
}
}, 3e3);
} else {
devtoolsNotInstalled = true;
buffer = [];
}
}
function devtoolsInitApp(app, version) {
emit$1("app:init" /* APP_INIT */, app, version, {
Fragment,
Text,
Comment,
Static
});
}
function devtoolsUnmountApp(app) {
emit$1("app:unmount" /* APP_UNMOUNT */, app);
}
const devtoolsComponentAdded = /* @__PURE__ */ (/* unused pure expression or super */ null && (createDevtoolsComponentHook("component:added" /* COMPONENT_ADDED */)));
const devtoolsComponentUpdated = /* @__PURE__ */ (/* unused pure expression or super */ null && (createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */)));
const _devtoolsComponentRemoved = /* @__PURE__ */ (/* unused pure expression or super */ null && (createDevtoolsComponentHook(
"component:removed" /* COMPONENT_REMOVED */
)));
const devtoolsComponentRemoved = (component) => {
if (devtools$1 && typeof devtools$1.cleanupBuffer === "function" && // remove the component if it wasn't buffered
!devtools$1.cleanupBuffer(component)) {
_devtoolsComponentRemoved(component);
}
};
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function createDevtoolsComponentHook(hook) {
return (component) => {
emit$1(
hook,
component.appContext.app,
component.uid,
component.parent ? component.parent.uid : void 0,
component
);
};
}
const devtoolsPerfStart = /* @__PURE__ */ (/* unused pure expression or super */ null && (createDevtoolsPerformanceHook("perf:start" /* PERFORMANCE_START */)));
const devtoolsPerfEnd = /* @__PURE__ */ (/* unused pure expression or super */ null && (createDevtoolsPerformanceHook("perf:end" /* PERFORMANCE_END */)));
function createDevtoolsPerformanceHook(hook) {
return (component, type, time) => {
emit$1(hook, component.appContext.app, component.uid, component, type, time);
};
}
function devtoolsComponentEmit(component, event, params) {
emit$1(
"component:emit" /* COMPONENT_EMIT */,
component.appContext.app,
component,
event,
params
);
}
let currentRenderingInstance = null;
let currentScopeId = null;
function setCurrentRenderingInstance(instance) {
const prev = currentRenderingInstance;
currentRenderingInstance = instance;
currentScopeId = instance && instance.type.__scopeId || null;
return prev;
}
function pushScopeId(id) {
currentScopeId = id;
}
function popScopeId() {
currentScopeId = null;
}
const withScopeId = (_id) => withCtx;
function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
if (!ctx) return fn;
if (fn._n) {
return fn;
}
const renderFnWithContext = (...args) => {
if (renderFnWithContext._d) {
setBlockTracking(-1);
}
const prevInstance = setCurrentRenderingInstance(ctx);
let res;
try {
res = fn(...args);
} finally {
setCurrentRenderingInstance(prevInstance);
if (renderFnWithContext._d) {
setBlockTracking(1);
}
}
if (false) {}
return res;
};
renderFnWithContext._n = true;
renderFnWithContext._c = true;
renderFnWithContext._d = true;
return renderFnWithContext;
}
function validateDirectiveName(name) {
if (isBuiltInDirective(name)) {
warn$1("Do not use built-in directive ids as custom directive id: " + name);
}
}
function withDirectives(vnode, directives) {
if (currentRenderingInstance === null) {
false && 0;
return vnode;
}
const instance = getComponentPublicInstance(currentRenderingInstance);
const bindings = vnode.dirs || (vnode.dirs = []);
for (let i = 0; i < directives.length; i++) {
let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
if (dir) {
if (shared_esm_bundler_isFunction(dir)) {
dir = {
mounted: dir,
updated: dir
};
}
if (dir.deep) {
traverse(value);
}
bindings.push({
dir,
instance,
value,
oldValue: void 0,
arg,
modifiers
});
}
}
return vnode;
}
function invokeDirectiveHook(vnode, prevVNode, instance, name) {
const bindings = vnode.dirs;
const oldBindings = prevVNode && prevVNode.dirs;
for (let i = 0; i < bindings.length; i++) {
const binding = bindings[i];
if (oldBindings) {
binding.oldValue = oldBindings[i].value;
}
let hook = binding.dir[name];
if (hook) {
reactivity_esm_bundler_pauseTracking();
callWithAsyncErrorHandling(hook, instance, 8, [
vnode.el,
binding,
vnode,
prevVNode
]);
reactivity_esm_bundler_resetTracking();
}
}
}
const TeleportEndKey = Symbol("_vte");
const isTeleport = (type) => type.__isTeleport;
const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
const isTeleportDeferred = (props) => props && (props.defer || props.defer === "");
const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
const isTargetMathML = (target) => typeof MathMLElement === "function" && target instanceof MathMLElement;
const resolveTarget = (props, select) => {
const targetSelector = props && props.to;
if (shared_esm_bundler_isString(targetSelector)) {
if (!select) {
false && 0;
return null;
} else {
const target = select(targetSelector);
if (false) {}
return target;
}
} else {
if (false) {}
return targetSelector;
}
};
const TeleportImpl = {
name: "Teleport",
__isTeleport: true,
process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals) {
const {
mc: mountChildren,
pc: patchChildren,
pbc: patchBlockChildren,
o: { insert, querySelector, createText, createComment }
} = internals;
const disabled = isTeleportDisabled(n2.props);
let { shapeFlag, children, dynamicChildren } = n2;
if (false) {}
if (n1 == null) {
const placeholder = n2.el = false ? 0 : createText("");
const mainAnchor = n2.anchor = false ? 0 : createText("");
insert(placeholder, container, anchor);
insert(mainAnchor, container, anchor);
const mount = (container2, anchor2) => {
if (shapeFlag & 16) {
if (parentComponent && parentComponent.isCE) {
parentComponent.ce._teleportTarget = container2;
}
mountChildren(
children,
container2,
anchor2,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
};
const mountToTarget = () => {
const target = n2.target = resolveTarget(n2.props, querySelector);
const targetAnchor = prepareAnchor(target, n2, createText, insert);
if (target) {
if (namespace !== "svg" && isTargetSVG(target)) {
namespace = "svg";
} else if (namespace !== "mathml" && isTargetMathML(target)) {
namespace = "mathml";
}
if (!disabled) {
mount(target, targetAnchor);
updateCssVars(n2, false);
}
} else if (false) {}
};
if (disabled) {
mount(container, mainAnchor);
updateCssVars(n2, true);
}
if (isTeleportDeferred(n2.props)) {
queuePostRenderEffect(() => {
mountToTarget();
n2.el.__isMounted = true;
}, parentSuspense);
} else {
mountToTarget();
}
} else {
if (isTeleportDeferred(n2.props) && !n1.el.__isMounted) {
queuePostRenderEffect(() => {
TeleportImpl.process(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized,
internals
);
delete n1.el.__isMounted;
}, parentSuspense);
return;
}
n2.el = n1.el;
n2.targetStart = n1.targetStart;
const mainAnchor = n2.anchor = n1.anchor;
const target = n2.target = n1.target;
const targetAnchor = n2.targetAnchor = n1.targetAnchor;
const wasDisabled = isTeleportDisabled(n1.props);
const currentContainer = wasDisabled ? container : target;
const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
if (namespace === "svg" || isTargetSVG(target)) {
namespace = "svg";
} else if (namespace === "mathml" || isTargetMathML(target)) {
namespace = "mathml";
}
if (dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
currentContainer,
parentComponent,
parentSuspense,
namespace,
slotScopeIds
);
traverseStaticChildren(n1, n2, true);
} else if (!optimized) {
patchChildren(
n1,
n2,
currentContainer,
currentAnchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
false
);
}
if (disabled) {
if (!wasDisabled) {
moveTeleport(
n2,
container,
mainAnchor,
internals,
1
);
} else {
if (n2.props && n1.props && n2.props.to !== n1.props.to) {
n2.props.to = n1.props.to;
}
}
} else {
if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
const nextTarget = n2.target = resolveTarget(
n2.props,
querySelector
);
if (nextTarget) {
moveTeleport(
n2,
nextTarget,
null,
internals,
0
);
} else if (false) {}
} else if (wasDisabled) {
moveTeleport(
n2,
target,
targetAnchor,
internals,
1
);
}
}
updateCssVars(n2, disabled);
}
},
remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) {
const {
shapeFlag,
children,
anchor,
targetStart,
targetAnchor,
target,
props
} = vnode;
if (target) {
hostRemove(targetStart);
hostRemove(targetAnchor);
}
doRemove && hostRemove(anchor);
if (shapeFlag & 16) {
const shouldRemove = doRemove || !isTeleportDisabled(props);
for (let i = 0; i < children.length; i++) {
const child = children[i];
unmount(
child,
parentComponent,
parentSuspense,
shouldRemove,
!!child.dynamicChildren
);
}
}
},
move: moveTeleport,
hydrate: hydrateTeleport
};
function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
if (moveType === 0) {
insert(vnode.targetAnchor, container, parentAnchor);
}
const { el, anchor, shapeFlag, children, props } = vnode;
const isReorder = moveType === 2;
if (isReorder) {
insert(el, container, parentAnchor);
}
if (!isReorder || isTeleportDisabled(props)) {
if (shapeFlag & 16) {
for (let i = 0; i < children.length; i++) {
move(
children[i],
container,
parentAnchor,
2
);
}
}
}
if (isReorder) {
insert(anchor, container, parentAnchor);
}
}
function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
o: { nextSibling, parentNode, querySelector, insert, createText }
}, hydrateChildren) {
const target = vnode.target = resolveTarget(
vnode.props,
querySelector
);
if (target) {
const disabled = isTeleportDisabled(vnode.props);
const targetNode = target._lpa || target.firstChild;
if (vnode.shapeFlag & 16) {
if (disabled) {
vnode.anchor = hydrateChildren(
nextSibling(node),
vnode,
parentNode(node),
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
vnode.targetStart = targetNode;
vnode.targetAnchor = targetNode && nextSibling(targetNode);
} else {
vnode.anchor = nextSibling(node);
let targetAnchor = targetNode;
while (targetAnchor) {
if (targetAnchor && targetAnchor.nodeType === 8) {
if (targetAnchor.data === "teleport start anchor") {
vnode.targetStart = targetAnchor;
} else if (targetAnchor.data === "teleport anchor") {
vnode.targetAnchor = targetAnchor;
target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
break;
}
}
targetAnchor = nextSibling(targetAnchor);
}
if (!vnode.targetAnchor) {
prepareAnchor(target, vnode, createText, insert);
}
hydrateChildren(
targetNode && nextSibling(targetNode),
vnode,
target,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
}
}
updateCssVars(vnode, disabled);
}
return vnode.anchor && nextSibling(vnode.anchor);
}
const Teleport = TeleportImpl;
function updateCssVars(vnode, isDisabled) {
const ctx = vnode.ctx;
if (ctx && ctx.ut) {
let node, anchor;
if (isDisabled) {
node = vnode.el;
anchor = vnode.anchor;
} else {
node = vnode.targetStart;
anchor = vnode.targetAnchor;
}
while (node && node !== anchor) {
if (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid);
node = node.nextSibling;
}
ctx.ut();
}
}
function prepareAnchor(target, vnode, createText, insert) {
const targetStart = vnode.targetStart = createText("");
const targetAnchor = vnode.targetAnchor = createText("");
targetStart[TeleportEndKey] = targetAnchor;
if (target) {
insert(targetStart, target);
insert(targetAnchor, target);
}
return targetAnchor;
}
const leaveCbKey = Symbol("_leaveCb");
const enterCbKey = Symbol("_enterCb");
function useTransitionState() {
const state = {
isMounted: false,
isLeaving: false,
isUnmounting: false,
leavingVNodes: /* @__PURE__ */ new Map()
};
runtime_core_esm_bundler_onMounted(() => {
state.isMounted = true;
});
runtime_core_esm_bundler_onBeforeUnmount(() => {
state.isUnmounting = true;
});
return state;
}
const TransitionHookValidator = [Function, Array];
const BaseTransitionPropsValidators = {
mode: String,
appear: Boolean,
persisted: Boolean,
// enter
onBeforeEnter: TransitionHookValidator,
onEnter: TransitionHookValidator,
onAfterEnter: TransitionHookValidator,
onEnterCancelled: TransitionHookValidator,
// leave
onBeforeLeave: TransitionHookValidator,
onLeave: TransitionHookValidator,
onAfterLeave: TransitionHookValidator,
onLeaveCancelled: TransitionHookValidator,
// appear
onBeforeAppear: TransitionHookValidator,
onAppear: TransitionHookValidator,
onAfterAppear: TransitionHookValidator,
onAppearCancelled: TransitionHookValidator
};
const recursiveGetSubtree = (instance) => {
const subTree = instance.subTree;
return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
};
const BaseTransitionImpl = {
name: `BaseTransition`,
props: BaseTransitionPropsValidators,
setup(props, { slots }) {
const instance = runtime_core_esm_bundler_getCurrentInstance();
const state = useTransitionState();
return () => {
const children = slots.default && getTransitionRawChildren(slots.default(), true);
if (!children || !children.length) {
return;
}
const child = findNonCommentChild(children);
const rawProps = reactivity_esm_bundler_toRaw(props);
const { mode } = rawProps;
if (false) {}
if (state.isLeaving) {
return emptyPlaceholder(child);
}
const innerChild = getInnerChild$1(child);
if (!innerChild) {
return emptyPlaceholder(child);
}
let enterHooks = resolveTransitionHooks(
innerChild,
rawProps,
state,
instance,
// #11061, ensure enterHooks is fresh after clone
(hooks) => enterHooks = hooks
);
if (innerChild.type !== Comment) {
setTransitionHooks(innerChild, enterHooks);
}
let oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree);
if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(innerChild, oldInnerChild) && recursiveGetSubtree(instance).type !== Comment) {
let leavingHooks = resolveTransitionHooks(
oldInnerChild,
rawProps,
state,
instance
);
setTransitionHooks(oldInnerChild, leavingHooks);
if (mode === "out-in" && innerChild.type !== Comment) {
state.isLeaving = true;
leavingHooks.afterLeave = () => {
state.isLeaving = false;
if (!(instance.job.flags & 8)) {
instance.update();
}
delete leavingHooks.afterLeave;
oldInnerChild = void 0;
};
return emptyPlaceholder(child);
} else if (mode === "in-out" && innerChild.type !== Comment) {
leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
const leavingVNodesCache = getLeavingNodesForType(
state,
oldInnerChild
);
leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
el[leaveCbKey] = () => {
earlyRemove();
el[leaveCbKey] = void 0;
delete enterHooks.delayedLeave;
oldInnerChild = void 0;
};
enterHooks.delayedLeave = () => {
delayedLeave();
delete enterHooks.delayedLeave;
oldInnerChild = void 0;
};
};
} else {
oldInnerChild = void 0;
}
} else if (oldInnerChild) {
oldInnerChild = void 0;
}
return child;
};
}
};
function findNonCommentChild(children) {
let child = children[0];
if (children.length > 1) {
let hasFound = false;
for (const c of children) {
if (c.type !== Comment) {
if (false) {}
child = c;
hasFound = true;
if (true) break;
}
}
}
return child;
}
const BaseTransition = BaseTransitionImpl;
function getLeavingNodesForType(state, vnode) {
const { leavingVNodes } = state;
let leavingVNodesCache = leavingVNodes.get(vnode.type);
if (!leavingVNodesCache) {
leavingVNodesCache = /* @__PURE__ */ Object.create(null);
leavingVNodes.set(vnode.type, leavingVNodesCache);
}
return leavingVNodesCache;
}
function resolveTransitionHooks(vnode, props, state, instance, postClone) {
const {
appear,
mode,
persisted = false,
onBeforeEnter,
onEnter,
onAfterEnter,
onEnterCancelled,
onBeforeLeave,
onLeave,
onAfterLeave,
onLeaveCancelled,
onBeforeAppear,
onAppear,
onAfterAppear,
onAppearCancelled
} = props;
const key = String(vnode.key);
const leavingVNodesCache = getLeavingNodesForType(state, vnode);
const callHook = (hook, args) => {
hook && callWithAsyncErrorHandling(
hook,
instance,
9,
args
);
};
const callAsyncHook = (hook, args) => {
const done = args[1];
callHook(hook, args);
if (shared_esm_bundler_isArray(hook)) {
if (hook.every((hook2) => hook2.length <= 1)) done();
} else if (hook.length <= 1) {
done();
}
};
const hooks = {
mode,
persisted,
beforeEnter(el) {
let hook = onBeforeEnter;
if (!state.isMounted) {
if (appear) {
hook = onBeforeAppear || onBeforeEnter;
} else {
return;
}
}
if (el[leaveCbKey]) {
el[leaveCbKey](
true
/* cancelled */
);
}
const leavingVNode = leavingVNodesCache[key];
if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
leavingVNode.el[leaveCbKey]();
}
callHook(hook, [el]);
},
enter(el) {
let hook = onEnter;
let afterHook = onAfterEnter;
let cancelHook = onEnterCancelled;
if (!state.isMounted) {
if (appear) {
hook = onAppear || onEnter;
afterHook = onAfterAppear || onAfterEnter;
cancelHook = onAppearCancelled || onEnterCancelled;
} else {
return;
}
}
let called = false;
const done = el[enterCbKey] = (cancelled) => {
if (called) return;
called = true;
if (cancelled) {
callHook(cancelHook, [el]);
} else {
callHook(afterHook, [el]);
}
if (hooks.delayedLeave) {
hooks.delayedLeave();
}
el[enterCbKey] = void 0;
};
if (hook) {
callAsyncHook(hook, [el, done]);
} else {
done();
}
},
leave(el, remove) {
const key2 = String(vnode.key);
if (el[enterCbKey]) {
el[enterCbKey](
true
/* cancelled */
);
}
if (state.isUnmounting) {
return remove();
}
callHook(onBeforeLeave, [el]);
let called = false;
const done = el[leaveCbKey] = (cancelled) => {
if (called) return;
called = true;
remove();
if (cancelled) {
callHook(onLeaveCancelled, [el]);
} else {
callHook(onAfterLeave, [el]);
}
el[leaveCbKey] = void 0;
if (leavingVNodesCache[key2] === vnode) {
delete leavingVNodesCache[key2];
}
};
leavingVNodesCache[key2] = vnode;
if (onLeave) {
callAsyncHook(onLeave, [el, done]);
} else {
done();
}
},
clone(vnode2) {
const hooks2 = resolveTransitionHooks(
vnode2,
props,
state,
instance,
postClone
);
if (postClone) postClone(hooks2);
return hooks2;
}
};
return hooks;
}
function emptyPlaceholder(vnode) {
if (isKeepAlive(vnode)) {
vnode = cloneVNode(vnode);
vnode.children = null;
return vnode;
}
}
function getInnerChild$1(vnode) {
if (!isKeepAlive(vnode)) {
if (isTeleport(vnode.type) && vnode.children) {
return findNonCommentChild(vnode.children);
}
return vnode;
}
if (false) {}
const { shapeFlag, children } = vnode;
if (children) {
if (shapeFlag & 16) {
return children[0];
}
if (shapeFlag & 32 && shared_esm_bundler_isFunction(children.default)) {
return children.default();
}
}
}
function setTransitionHooks(vnode, hooks) {
if (vnode.shapeFlag & 6 && vnode.component) {
vnode.transition = hooks;
setTransitionHooks(vnode.component.subTree, hooks);
} else if (vnode.shapeFlag & 128) {
vnode.ssContent.transition = hooks.clone(vnode.ssContent);
vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
} else {
vnode.transition = hooks;
}
}
function getTransitionRawChildren(children, keepComment = false, parentKey) {
let ret = [];
let keyedFragmentCount = 0;
for (let i = 0; i < children.length; i++) {
let child = children[i];
const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
if (child.type === Fragment) {
if (child.patchFlag & 128) keyedFragmentCount++;
ret = ret.concat(
getTransitionRawChildren(child.children, keepComment, key)
);
} else if (keepComment || child.type !== Comment) {
ret.push(key != null ? cloneVNode(child, { key }) : child);
}
}
if (keyedFragmentCount > 1) {
for (let i = 0; i < ret.length; i++) {
ret[i].patchFlag = -2;
}
}
return ret;
}
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function defineComponent(options, extraOptions) {
return shared_esm_bundler_isFunction(options) ? (
// #8236: extend call and options.name access are considered side-effects
// by Rollup, so we have to wrap it in a pure-annotated IIFE.
/* @__PURE__ */ (() => shared_esm_bundler_extend({ name: options.name }, extraOptions, { setup: options }))()
) : options;
}
function useId() {
const i = runtime_core_esm_bundler_getCurrentInstance();
if (i) {
return (i.appContext.config.idPrefix || "v") + "-" + i.ids[0] + i.ids[1]++;
} else if (false) {}
return "";
}
function markAsyncBoundary(instance) {
instance.ids = [instance.ids[0] + instance.ids[2]++ + "-", 0, 0];
}
const knownTemplateRefs = /* @__PURE__ */ new WeakSet();
function useTemplateRef(key) {
const i = runtime_core_esm_bundler_getCurrentInstance();
const r = reactivity_esm_bundler_shallowRef(null);
if (i) {
const refs = i.refs === EMPTY_OBJ ? i.refs = {} : i.refs;
let desc;
if (false) {} else {
Object.defineProperty(refs, key, {
enumerable: true,
get: () => r.value,
set: (val) => r.value = val
});
}
} else if (false) {}
const ret = false ? 0 : r;
if (false) {}
return ret;
}
function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
if (shared_esm_bundler_isArray(rawRef)) {
rawRef.forEach(
(r, i) => setRef(
r,
oldRawRef && (shared_esm_bundler_isArray(oldRawRef) ? oldRawRef[i] : oldRawRef),
parentSuspense,
vnode,
isUnmount
)
);
return;
}
if (isAsyncWrapper(vnode) && !isUnmount) {
if (vnode.shapeFlag & 512 && vnode.type.__asyncResolved && vnode.component.subTree.component) {
setRef(rawRef, oldRawRef, parentSuspense, vnode.component.subTree);
}
return;
}
const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el;
const value = isUnmount ? null : refValue;
const { i: owner, r: ref } = rawRef;
if (false) {}
const oldRef = oldRawRef && oldRawRef.r;
const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
const setupState = owner.setupState;
const rawSetupState = reactivity_esm_bundler_toRaw(setupState);
const canSetSetupRef = setupState === EMPTY_OBJ ? () => false : (key) => {
if (false) {}
return hasOwn(rawSetupState, key);
};
if (oldRef != null && oldRef !== ref) {
if (shared_esm_bundler_isString(oldRef)) {
refs[oldRef] = null;
if (canSetSetupRef(oldRef)) {
setupState[oldRef] = null;
}
} else if (reactivity_esm_bundler_isRef(oldRef)) {
oldRef.value = null;
}
}
if (shared_esm_bundler_isFunction(ref)) {
callWithErrorHandling(ref, owner, 12, [value, refs]);
} else {
const _isString = shared_esm_bundler_isString(ref);
const _isRef = reactivity_esm_bundler_isRef(ref);
if (_isString || _isRef) {
const doSet = () => {
if (rawRef.f) {
const existing = _isString ? canSetSetupRef(ref) ? setupState[ref] : refs[ref] : ref.value;
if (isUnmount) {
shared_esm_bundler_isArray(existing) && remove(existing, refValue);
} else {
if (!shared_esm_bundler_isArray(existing)) {
if (_isString) {
refs[ref] = [refValue];
if (canSetSetupRef(ref)) {
setupState[ref] = refs[ref];
}
} else {
ref.value = [refValue];
if (rawRef.k) refs[rawRef.k] = ref.value;
}
} else if (!existing.includes(refValue)) {
existing.push(refValue);
}
}
} else if (_isString) {
refs[ref] = value;
if (canSetSetupRef(ref)) {
setupState[ref] = value;
}
} else if (_isRef) {
ref.value = value;
if (rawRef.k) refs[rawRef.k] = value;
} else if (false) {}
};
if (value) {
doSet.id = -1;
queuePostRenderEffect(doSet, parentSuspense);
} else {
doSet();
}
} else if (false) {}
}
}
let hasLoggedMismatchError = false;
const logMismatchError = () => {
if (hasLoggedMismatchError) {
return;
}
console.error("Hydration completed but contains mismatches.");
hasLoggedMismatchError = true;
};
const isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject";
const isMathMLContainer = (container) => container.namespaceURI.includes("MathML");
const getContainerType = (container) => {
if (container.nodeType !== 1) return void 0;
if (isSVGContainer(container)) return "svg";
if (isMathMLContainer(container)) return "mathml";
return void 0;
};
const isComment = (node) => node.nodeType === 8;
function createHydrationFunctions(rendererInternals) {
const {
mt: mountComponent,
p: patch,
o: {
patchProp,
createText,
nextSibling,
parentNode,
remove,
insert,
createComment
}
} = rendererInternals;
const hydrate = (vnode, container) => {
if (!container.hasChildNodes()) {
( false) && 0;
patch(null, vnode, container);
flushPostFlushCbs();
container._vnode = vnode;
return;
}
hydrateNode(container.firstChild, vnode, null, null, null);
flushPostFlushCbs();
container._vnode = vnode;
};
const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
optimized = optimized || !!vnode.dynamicChildren;
const isFragmentStart = isComment(node) && node.data === "[";
const onMismatch = () => handleMismatch(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
isFragmentStart
);
const { type, ref, shapeFlag, patchFlag } = vnode;
let domType = node.nodeType;
vnode.el = node;
if (false) {}
if (patchFlag === -2) {
optimized = false;
vnode.dynamicChildren = null;
}
let nextNode = null;
switch (type) {
case Text:
if (domType !== 3) {
if (vnode.children === "") {
insert(vnode.el = createText(""), parentNode(node), node);
nextNode = node;
} else {
nextNode = onMismatch();
}
} else {
if (node.data !== vnode.children) {
( false) && 0;
logMismatchError();
node.data = vnode.children;
}
nextNode = nextSibling(node);
}
break;
case Comment:
if (isTemplateNode(node)) {
nextNode = nextSibling(node);
replaceNode(
vnode.el = node.content.firstChild,
node,
parentComponent
);
} else if (domType !== 8 || isFragmentStart) {
nextNode = onMismatch();
} else {
nextNode = nextSibling(node);
}
break;
case Static:
if (isFragmentStart) {
node = nextSibling(node);
domType = node.nodeType;
}
if (domType === 1 || domType === 3) {
nextNode = node;
const needToAdoptContent = !vnode.children.length;
for (let i = 0; i < vnode.staticCount; i++) {
if (needToAdoptContent)
vnode.children += nextNode.nodeType === 1 ? nextNode.outerHTML : nextNode.data;
if (i === vnode.staticCount - 1) {
vnode.anchor = nextNode;
}
nextNode = nextSibling(nextNode);
}
return isFragmentStart ? nextSibling(nextNode) : nextNode;
} else {
onMismatch();
}
break;
case Fragment:
if (!isFragmentStart) {
nextNode = onMismatch();
} else {
nextNode = hydrateFragment(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
}
break;
default:
if (shapeFlag & 1) {
if ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) {
nextNode = onMismatch();
} else {
nextNode = hydrateElement(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
}
} else if (shapeFlag & 6) {
vnode.slotScopeIds = slotScopeIds;
const container = parentNode(node);
if (isFragmentStart) {
nextNode = locateClosingAnchor(node);
} else if (isComment(node) && node.data === "teleport start") {
nextNode = locateClosingAnchor(node, node.data, "teleport end");
} else {
nextNode = nextSibling(node);
}
mountComponent(
vnode,
container,
null,
parentComponent,
parentSuspense,
getContainerType(container),
optimized
);
if (isAsyncWrapper(vnode) && !vnode.type.__asyncResolved) {
let subTree;
if (isFragmentStart) {
subTree = createVNode(Fragment);
subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
} else {
subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
}
subTree.el = node;
vnode.component.subTree = subTree;
}
} else if (shapeFlag & 64) {
if (domType !== 8) {
nextNode = onMismatch();
} else {
nextNode = vnode.type.hydrate(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized,
rendererInternals,
hydrateChildren
);
}
} else if (shapeFlag & 128) {
nextNode = vnode.type.hydrate(
node,
vnode,
parentComponent,
parentSuspense,
getContainerType(parentNode(node)),
slotScopeIds,
optimized,
rendererInternals,
hydrateNode
);
} else if (false) {}
}
if (ref != null) {
setRef(ref, null, parentSuspense, vnode);
}
return nextNode;
};
const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
optimized = optimized || !!vnode.dynamicChildren;
const { type, props, patchFlag, shapeFlag, dirs, transition } = vnode;
const forcePatch = type === "input" || type === "option";
if ( false || forcePatch || patchFlag !== -1) {
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "created");
}
let needCallTransitionHooks = false;
if (isTemplateNode(el)) {
needCallTransitionHooks = needTransition(
null,
// no need check parentSuspense in hydration
transition
) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear;
const content = el.content.firstChild;
if (needCallTransitionHooks) {
transition.beforeEnter(content);
}
replaceNode(content, el, parentComponent);
vnode.el = el = content;
}
if (shapeFlag & 16 && // skip if element has innerHTML / textContent
!(props && (props.innerHTML || props.textContent))) {
let next = hydrateChildren(
el.firstChild,
vnode,
el,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
let hasWarned = false;
while (next) {
if (!isMismatchAllowed(el, 1 /* CHILDREN */)) {
if (false) {}
logMismatchError();
}
const cur = next;
next = next.nextSibling;
remove(cur);
}
} else if (shapeFlag & 8) {
let clientText = vnode.children;
if (clientText[0] === "\n" && (el.tagName === "PRE" || el.tagName === "TEXTAREA")) {
clientText = clientText.slice(1);
}
if (el.textContent !== clientText) {
if (!isMismatchAllowed(el, 0 /* TEXT */)) {
( false) && 0;
logMismatchError();
}
el.textContent = vnode.children;
}
}
if (props) {
if ( false || forcePatch || !optimized || patchFlag & (16 | 32)) {
const isCustomElement = el.tagName.includes("-");
for (const key in props) {
if (false) {}
if (forcePatch && (key.endsWith("value") || key === "indeterminate") || isOn(key) && !isReservedProp(key) || // force hydrate v-bind with .prop modifiers
key[0] === "." || isCustomElement) {
patchProp(el, key, null, props[key], void 0, parentComponent);
}
}
} else if (props.onClick) {
patchProp(
el,
"onClick",
null,
props.onClick,
void 0,
parentComponent
);
} else if (patchFlag & 4 && reactivity_esm_bundler_isReactive(props.style)) {
for (const key in props.style) props.style[key];
}
}
let vnodeHooks;
if (vnodeHooks = props && props.onVnodeBeforeMount) {
invokeVNodeHook(vnodeHooks, parentComponent, vnode);
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
}
if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) {
queueEffectWithSuspense(() => {
vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
needCallTransitionHooks && transition.enter(el);
dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
}, parentSuspense);
}
}
return el.nextSibling;
};
const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
optimized = optimized || !!parentVNode.dynamicChildren;
const children = parentVNode.children;
const l = children.length;
let hasWarned = false;
for (let i = 0; i < l; i++) {
const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
const isText = vnode.type === Text;
if (node) {
if (isText && !optimized) {
if (i + 1 < l && normalizeVNode(children[i + 1]).type === Text) {
insert(
createText(
node.data.slice(vnode.children.length)
),
container,
nextSibling(node)
);
node.data = vnode.children;
}
}
node = hydrateNode(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
} else if (isText && !vnode.children) {
insert(vnode.el = createText(""), container);
} else {
if (!isMismatchAllowed(container, 1 /* CHILDREN */)) {
if (false) {}
logMismatchError();
}
patch(
null,
vnode,
container,
null,
parentComponent,
parentSuspense,
getContainerType(container),
slotScopeIds
);
}
}
return node;
};
const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
const { slotScopeIds: fragmentSlotScopeIds } = vnode;
if (fragmentSlotScopeIds) {
slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
}
const container = parentNode(node);
const next = hydrateChildren(
nextSibling(node),
vnode,
container,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
if (next && isComment(next) && next.data === "]") {
return nextSibling(vnode.anchor = next);
} else {
logMismatchError();
insert(vnode.anchor = createComment(`]`), container, next);
return next;
}
};
const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
if (!isMismatchAllowed(node.parentElement, 1 /* CHILDREN */)) {
( false) && 0;
logMismatchError();
}
vnode.el = null;
if (isFragment) {
const end = locateClosingAnchor(node);
while (true) {
const next2 = nextSibling(node);
if (next2 && next2 !== end) {
remove(next2);
} else {
break;
}
}
}
const next = nextSibling(node);
const container = parentNode(node);
remove(node);
patch(
null,
vnode,
container,
next,
parentComponent,
parentSuspense,
getContainerType(container),
slotScopeIds
);
if (parentComponent) {
parentComponent.vnode.el = vnode.el;
updateHOCHostEl(parentComponent, vnode.el);
}
return next;
};
const locateClosingAnchor = (node, open = "[", close = "]") => {
let match = 0;
while (node) {
node = nextSibling(node);
if (node && isComment(node)) {
if (node.data === open) match++;
if (node.data === close) {
if (match === 0) {
return nextSibling(node);
} else {
match--;
}
}
}
}
return node;
};
const replaceNode = (newNode, oldNode, parentComponent) => {
const parentNode2 = oldNode.parentNode;
if (parentNode2) {
parentNode2.replaceChild(newNode, oldNode);
}
let parent = parentComponent;
while (parent) {
if (parent.vnode.el === oldNode) {
parent.vnode.el = parent.subTree.el = newNode;
}
parent = parent.parent;
}
};
const isTemplateNode = (node) => {
return node.nodeType === 1 && node.tagName === "TEMPLATE";
};
return [hydrate, hydrateNode];
}
function propHasMismatch(el, key, clientValue, vnode, instance) {
let mismatchType;
let mismatchKey;
let actual;
let expected;
if (key === "class") {
actual = el.getAttribute("class");
expected = normalizeClass(clientValue);
if (!isSetEqual(toClassSet(actual || ""), toClassSet(expected))) {
mismatchType = 2 /* CLASS */;
mismatchKey = `class`;
}
} else if (key === "style") {
actual = el.getAttribute("style") || "";
expected = isString(clientValue) ? clientValue : stringifyStyle(normalizeStyle(clientValue));
const actualMap = toStyleMap(actual);
const expectedMap = toStyleMap(expected);
if (vnode.dirs) {
for (const { dir, value } of vnode.dirs) {
if (dir.name === "show" && !value) {
expectedMap.set("display", "none");
}
}
}
if (instance) {
resolveCssVars(instance, vnode, expectedMap);
}
if (!isMapEqual(actualMap, expectedMap)) {
mismatchType = 3 /* STYLE */;
mismatchKey = "style";
}
} else if (el instanceof SVGElement && isKnownSvgAttr(key) || el instanceof HTMLElement && (isBooleanAttr(key) || isKnownHtmlAttr(key))) {
if (isBooleanAttr(key)) {
actual = el.hasAttribute(key);
expected = includeBooleanAttr(clientValue);
} else if (clientValue == null) {
actual = el.hasAttribute(key);
expected = false;
} else {
if (el.hasAttribute(key)) {
actual = el.getAttribute(key);
} else if (key === "value" && el.tagName === "TEXTAREA") {
actual = el.value;
} else {
actual = false;
}
expected = isRenderableAttrValue(clientValue) ? String(clientValue) : false;
}
if (actual !== expected) {
mismatchType = 4 /* ATTRIBUTE */;
mismatchKey = key;
}
}
if (mismatchType != null && !isMismatchAllowed(el, mismatchType)) {
const format = (v) => v === false ? `(not rendered)` : `${mismatchKey}="${v}"`;
const preSegment = `Hydration ${MismatchTypeString[mismatchType]} mismatch on`;
const postSegment = `
- rendered on server: ${format(actual)}
- expected on client: ${format(expected)}
Note: this mismatch is check-only. The DOM will not be rectified in production due to performance overhead.
You should fix the source of the mismatch.`;
{
warn$1(preSegment, el, postSegment);
}
return true;
}
return false;
}
function toClassSet(str) {
return new Set(str.trim().split(/\s+/));
}
function isSetEqual(a, b) {
if (a.size !== b.size) {
return false;
}
for (const s of a) {
if (!b.has(s)) {
return false;
}
}
return true;
}
function toStyleMap(str) {
const styleMap = /* @__PURE__ */ new Map();
for (const item of str.split(";")) {
let [key, value] = item.split(":");
key = key.trim();
value = value && value.trim();
if (key && value) {
styleMap.set(key, value);
}
}
return styleMap;
}
function isMapEqual(a, b) {
if (a.size !== b.size) {
return false;
}
for (const [key, value] of a) {
if (value !== b.get(key)) {
return false;
}
}
return true;
}
function resolveCssVars(instance, vnode, expectedMap) {
const root = instance.subTree;
if (instance.getCssVars && (vnode === root || root && root.type === Fragment && root.children.includes(vnode))) {
const cssVars = instance.getCssVars();
for (const key in cssVars) {
expectedMap.set(
`--${getEscapedCssVarName(key, false)}`,
String(cssVars[key])
);
}
}
if (vnode === root && instance.parent) {
resolveCssVars(instance.parent, instance.vnode, expectedMap);
}
}
const allowMismatchAttr = "data-allow-mismatch";
const MismatchTypeString = {
[0 /* TEXT */]: "text",
[1 /* CHILDREN */]: "children",
[2 /* CLASS */]: "class",
[3 /* STYLE */]: "style",
[4 /* ATTRIBUTE */]: "attribute"
};
function isMismatchAllowed(el, allowedType) {
if (allowedType === 0 /* TEXT */ || allowedType === 1 /* CHILDREN */) {
while (el && !el.hasAttribute(allowMismatchAttr)) {
el = el.parentElement;
}
}
const allowedAttr = el && el.getAttribute(allowMismatchAttr);
if (allowedAttr == null) {
return false;
} else if (allowedAttr === "") {
return true;
} else {
const list = allowedAttr.split(",");
if (allowedType === 0 /* TEXT */ && list.includes("children")) {
return true;
}
return allowedAttr.split(",").includes(MismatchTypeString[allowedType]);
}
}
const requestIdleCallback = getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
const cancelIdleCallback = getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
const hydrateOnIdle = (timeout = 1e4) => (hydrate) => {
const id = requestIdleCallback(hydrate, { timeout });
return () => cancelIdleCallback(id);
};
function elementIsVisibleInViewport(el) {
const { top, left, bottom, right } = el.getBoundingClientRect();
const { innerHeight, innerWidth } = window;
return (top > 0 && top < innerHeight || bottom > 0 && bottom < innerHeight) && (left > 0 && left < innerWidth || right > 0 && right < innerWidth);
}
const hydrateOnVisible = (opts) => (hydrate, forEach) => {
const ob = new IntersectionObserver((entries) => {
for (const e of entries) {
if (!e.isIntersecting) continue;
ob.disconnect();
hydrate();
break;
}
}, opts);
forEach((el) => {
if (!(el instanceof Element)) return;
if (elementIsVisibleInViewport(el)) {
hydrate();
ob.disconnect();
return false;
}
ob.observe(el);
});
return () => ob.disconnect();
};
const hydrateOnMediaQuery = (query) => (hydrate) => {
if (query) {
const mql = matchMedia(query);
if (mql.matches) {
hydrate();
} else {
mql.addEventListener("change", hydrate, { once: true });
return () => mql.removeEventListener("change", hydrate);
}
}
};
const hydrateOnInteraction = (interactions = []) => (hydrate, forEach) => {
if (shared_esm_bundler_isString(interactions)) interactions = [interactions];
let hasHydrated = false;
const doHydrate = (e) => {
if (!hasHydrated) {
hasHydrated = true;
teardown();
hydrate();
e.target.dispatchEvent(new e.constructor(e.type, e));
}
};
const teardown = () => {
forEach((el) => {
for (const i of interactions) {
el.removeEventListener(i, doHydrate);
}
});
};
forEach((el) => {
for (const i of interactions) {
el.addEventListener(i, doHydrate, { once: true });
}
});
return teardown;
};
function forEachElement(node, cb) {
if (isComment(node) && node.data === "[") {
let depth = 1;
let next = node.nextSibling;
while (next) {
if (next.nodeType === 1) {
const result = cb(next);
if (result === false) {
break;
}
} else if (isComment(next)) {
if (next.data === "]") {
if (--depth === 0) break;
} else if (next.data === "[") {
depth++;
}
}
next = next.nextSibling;
}
} else {
cb(node);
}
}
const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function defineAsyncComponent(source) {
if (shared_esm_bundler_isFunction(source)) {
source = { loader: source };
}
const {
loader,
loadingComponent,
errorComponent,
delay = 200,
hydrate: hydrateStrategy,
timeout,
// undefined = never times out
suspensible = true,
onError: userOnError
} = source;
let pendingRequest = null;
let resolvedComp;
let retries = 0;
const retry = () => {
retries++;
pendingRequest = null;
return load();
};
const load = () => {
let thisRequest;
return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
err = err instanceof Error ? err : new Error(String(err));
if (userOnError) {
return new Promise((resolve, reject) => {
const userRetry = () => resolve(retry());
const userFail = () => reject(err);
userOnError(err, userRetry, userFail, retries + 1);
});
} else {
throw err;
}
}).then((comp) => {
if (thisRequest !== pendingRequest && pendingRequest) {
return pendingRequest;
}
if (false) {}
if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
comp = comp.default;
}
if (false) {}
resolvedComp = comp;
return comp;
}));
};
return defineComponent({
name: "AsyncComponentWrapper",
__asyncLoader: load,
__asyncHydrate(el, instance, hydrate) {
const doHydrate = hydrateStrategy ? () => {
const teardown = hydrateStrategy(
hydrate,
(cb) => forEachElement(el, cb)
);
if (teardown) {
(instance.bum || (instance.bum = [])).push(teardown);
}
} : hydrate;
if (resolvedComp) {
doHydrate();
} else {
load().then(() => !instance.isUnmounted && doHydrate());
}
},
get __asyncResolved() {
return resolvedComp;
},
setup() {
const instance = currentInstance;
markAsyncBoundary(instance);
if (resolvedComp) {
return () => createInnerComp(resolvedComp, instance);
}
const onError = (err) => {
pendingRequest = null;
handleError(
err,
instance,
13,
!errorComponent
);
};
if (suspensible && instance.suspense || isInSSRComponentSetup) {
return load().then((comp) => {
return () => createInnerComp(comp, instance);
}).catch((err) => {
onError(err);
return () => errorComponent ? createVNode(errorComponent, {
error: err
}) : null;
});
}
const loaded = ref(false);
const error = ref();
const delayed = ref(!!delay);
if (delay) {
setTimeout(() => {
delayed.value = false;
}, delay);
}
if (timeout != null) {
setTimeout(() => {
if (!loaded.value && !error.value) {
const err = new Error(
`Async component timed out after ${timeout}ms.`
);
onError(err);
error.value = err;
}
}, timeout);
}
load().then(() => {
loaded.value = true;
if (instance.parent && isKeepAlive(instance.parent.vnode)) {
instance.parent.update();
}
}).catch((err) => {
onError(err);
error.value = err;
});
return () => {
if (loaded.value && resolvedComp) {
return createInnerComp(resolvedComp, instance);
} else if (error.value && errorComponent) {
return createVNode(errorComponent, {
error: error.value
});
} else if (loadingComponent && !delayed.value) {
return createVNode(loadingComponent);
}
};
}
});
}
function createInnerComp(comp, parent) {
const { ref: ref2, props, children, ce } = parent.vnode;
const vnode = createVNode(comp, props, children);
vnode.ref = ref2;
vnode.ce = ce;
delete parent.vnode.ce;
return vnode;
}
const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
const KeepAliveImpl = {
name: `KeepAlive`,
// Marker for special handling inside the renderer. We are not using a ===
// check directly on KeepAlive in the renderer, because importing it directly
// would prevent it from being tree-shaken.
__isKeepAlive: true,
props: {
include: [String, RegExp, Array],
exclude: [String, RegExp, Array],
max: [String, Number]
},
setup(props, { slots }) {
const instance = runtime_core_esm_bundler_getCurrentInstance();
const sharedContext = instance.ctx;
if (!sharedContext.renderer) {
return () => {
const children = slots.default && slots.default();
return children && children.length === 1 ? children[0] : children;
};
}
const cache = /* @__PURE__ */ new Map();
const keys = /* @__PURE__ */ new Set();
let current = null;
if (false) {}
const parentSuspense = instance.suspense;
const {
renderer: {
p: patch,
m: move,
um: _unmount,
o: { createElement }
}
} = sharedContext;
const storageContainer = createElement("div");
sharedContext.activate = (vnode, container, anchor, namespace, optimized) => {
const instance2 = vnode.component;
move(vnode, container, anchor, 0, parentSuspense);
patch(
instance2.vnode,
vnode,
container,
anchor,
instance2,
parentSuspense,
namespace,
vnode.slotScopeIds,
optimized
);
queuePostRenderEffect(() => {
instance2.isDeactivated = false;
if (instance2.a) {
invokeArrayFns(instance2.a);
}
const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
if (vnodeHook) {
invokeVNodeHook(vnodeHook, instance2.parent, vnode);
}
}, parentSuspense);
if (false) {}
};
sharedContext.deactivate = (vnode) => {
const instance2 = vnode.component;
invalidateMount(instance2.m);
invalidateMount(instance2.a);
move(vnode, storageContainer, null, 1, parentSuspense);
queuePostRenderEffect(() => {
if (instance2.da) {
invokeArrayFns(instance2.da);
}
const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
if (vnodeHook) {
invokeVNodeHook(vnodeHook, instance2.parent, vnode);
}
instance2.isDeactivated = true;
}, parentSuspense);
if (false) {}
};
function unmount(vnode) {
resetShapeFlag(vnode);
_unmount(vnode, instance, parentSuspense, true);
}
function pruneCache(filter) {
cache.forEach((vnode, key) => {
const name = getComponentName(vnode.type);
if (name && !filter(name)) {
pruneCacheEntry(key);
}
});
}
function pruneCacheEntry(key) {
const cached = cache.get(key);
if (cached && (!current || !isSameVNodeType(cached, current))) {
unmount(cached);
} else if (current) {
resetShapeFlag(current);
}
cache.delete(key);
keys.delete(key);
}
runtime_core_esm_bundler_watch(
() => [props.include, props.exclude],
([include, exclude]) => {
include && pruneCache((name) => matches(include, name));
exclude && pruneCache((name) => !matches(exclude, name));
},
// prune post-render after `current` has been updated
{ flush: "post", deep: true }
);
let pendingCacheKey = null;
const cacheSubtree = () => {
if (pendingCacheKey != null) {
if (isSuspense(instance.subTree.type)) {
queuePostRenderEffect(() => {
cache.set(pendingCacheKey, getInnerChild(instance.subTree));
}, instance.subTree.suspense);
} else {
cache.set(pendingCacheKey, getInnerChild(instance.subTree));
}
}
};
runtime_core_esm_bundler_onMounted(cacheSubtree);
onUpdated(cacheSubtree);
runtime_core_esm_bundler_onBeforeUnmount(() => {
cache.forEach((cached) => {
const { subTree, suspense } = instance;
const vnode = getInnerChild(subTree);
if (cached.type === vnode.type && cached.key === vnode.key) {
resetShapeFlag(vnode);
const da = vnode.component.da;
da && queuePostRenderEffect(da, suspense);
return;
}
unmount(cached);
});
});
return () => {
pendingCacheKey = null;
if (!slots.default) {
return current = null;
}
const children = slots.default();
const rawVNode = children[0];
if (children.length > 1) {
if (false) {}
current = null;
return children;
} else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
current = null;
return rawVNode;
}
let vnode = getInnerChild(rawVNode);
if (vnode.type === Comment) {
current = null;
return vnode;
}
const comp = vnode.type;
const name = getComponentName(
isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp
);
const { include, exclude, max } = props;
if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
vnode.shapeFlag &= ~256;
current = vnode;
return rawVNode;
}
const key = vnode.key == null ? comp : vnode.key;
const cachedVNode = cache.get(key);
if (vnode.el) {
vnode = cloneVNode(vnode);
if (rawVNode.shapeFlag & 128) {
rawVNode.ssContent = vnode;
}
}
pendingCacheKey = key;
if (cachedVNode) {
vnode.el = cachedVNode.el;
vnode.component = cachedVNode.component;
if (vnode.transition) {
setTransitionHooks(vnode, vnode.transition);
}
vnode.shapeFlag |= 512;
keys.delete(key);
keys.add(key);
} else {
keys.add(key);
if (max && keys.size > parseInt(max, 10)) {
pruneCacheEntry(keys.values().next().value);
}
}
vnode.shapeFlag |= 256;
current = vnode;
return isSuspense(rawVNode.type) ? rawVNode : vnode;
};
}
};
const KeepAlive = KeepAliveImpl;
function matches(pattern, name) {
if (shared_esm_bundler_isArray(pattern)) {
return pattern.some((p) => matches(p, name));
} else if (shared_esm_bundler_isString(pattern)) {
return pattern.split(",").includes(name);
} else if (isRegExp(pattern)) {
pattern.lastIndex = 0;
return pattern.test(name);
}
return false;
}
function onActivated(hook, target) {
registerKeepAliveHook(hook, "a", target);
}
function onDeactivated(hook, target) {
registerKeepAliveHook(hook, "da", target);
}
function registerKeepAliveHook(hook, type, target = currentInstance) {
const wrappedHook = hook.__wdc || (hook.__wdc = () => {
let current = target;
while (current) {
if (current.isDeactivated) {
return;
}
current = current.parent;
}
return hook();
});
injectHook(type, wrappedHook, target);
if (target) {
let current = target.parent;
while (current && current.parent) {
if (isKeepAlive(current.parent.vnode)) {
injectToKeepAliveRoot(wrappedHook, type, target, current);
}
current = current.parent;
}
}
}
function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
const injected = injectHook(
type,
hook,
keepAliveRoot,
true
/* prepend */
);
onUnmounted(() => {
remove(keepAliveRoot[type], injected);
}, target);
}
function resetShapeFlag(vnode) {
vnode.shapeFlag &= ~256;
vnode.shapeFlag &= ~512;
}
function getInnerChild(vnode) {
return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
}
function injectHook(type, hook, target = currentInstance, prepend = false) {
if (target) {
const hooks = target[type] || (target[type] = []);
const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
reactivity_esm_bundler_pauseTracking();
const reset = setCurrentInstance(target);
const res = callWithAsyncErrorHandling(hook, target, type, args);
reset();
reactivity_esm_bundler_resetTracking();
return res;
});
if (prepend) {
hooks.unshift(wrappedHook);
} else {
hooks.push(wrappedHook);
}
return wrappedHook;
} else if (false) {}
}
const createHook = (lifecycle) => (hook, target = currentInstance) => {
if (!isInSSRComponentSetup || lifecycle === "sp") {
injectHook(lifecycle, (...args) => hook(...args), target);
}
};
const onBeforeMount = createHook("bm");
const runtime_core_esm_bundler_onMounted = createHook("m");
const onBeforeUpdate = createHook(
"bu"
);
const onUpdated = createHook("u");
const runtime_core_esm_bundler_onBeforeUnmount = createHook(
"bum"
);
const onUnmounted = createHook("um");
const onServerPrefetch = createHook(
"sp"
);
const onRenderTriggered = createHook("rtg");
const onRenderTracked = createHook("rtc");
function onErrorCaptured(hook, target = currentInstance) {
injectHook("ec", hook, target);
}
const COMPONENTS = "components";
const DIRECTIVES = "directives";
function resolveComponent(name, maybeSelfReference) {
return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
}
const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
function resolveDynamicComponent(component) {
if (shared_esm_bundler_isString(component)) {
return resolveAsset(COMPONENTS, component, false) || component;
} else {
return component || NULL_DYNAMIC_COMPONENT;
}
}
function resolveDirective(name) {
return resolveAsset(DIRECTIVES, name);
}
function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
const instance = currentRenderingInstance || currentInstance;
if (instance) {
const Component = instance.type;
if (type === COMPONENTS) {
const selfName = getComponentName(
Component,
false
);
if (selfName && (selfName === name || selfName === shared_esm_bundler_camelize(name) || selfName === shared_esm_bundler_capitalize(shared_esm_bundler_camelize(name)))) {
return Component;
}
}
const res = (
// local registration
// check instance[type] first which is resolved for options API
resolve(instance[type] || Component[type], name) || // global registration
resolve(instance.appContext[type], name)
);
if (!res && maybeSelfReference) {
return Component;
}
if (false) {}
return res;
} else if (false) {}
}
function resolve(registry, name) {
return registry && (registry[name] || registry[shared_esm_bundler_camelize(name)] || registry[shared_esm_bundler_capitalize(shared_esm_bundler_camelize(name))]);
}
function renderList(source, renderItem, cache, index) {
let ret;
const cached = cache && cache[index];
const sourceIsArray = shared_esm_bundler_isArray(source);
if (sourceIsArray || shared_esm_bundler_isString(source)) {
const sourceIsReactiveArray = sourceIsArray && reactivity_esm_bundler_isReactive(source);
let needsWrap = false;
if (sourceIsReactiveArray) {
needsWrap = !reactivity_esm_bundler_isShallow(source);
source = shallowReadArray(source);
}
ret = new Array(source.length);
for (let i = 0, l = source.length; i < l; i++) {
ret[i] = renderItem(
needsWrap ? toReactive(source[i]) : source[i],
i,
void 0,
cached && cached[i]
);
}
} else if (typeof source === "number") {
if (false) {}
ret = new Array(source);
for (let i = 0; i < source; i++) {
ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
}
} else if (shared_esm_bundler_isObject(source)) {
if (source[Symbol.iterator]) {
ret = Array.from(
source,
(item, i) => renderItem(item, i, void 0, cached && cached[i])
);
} else {
const keys = Object.keys(source);
ret = new Array(keys.length);
for (let i = 0, l = keys.length; i < l; i++) {
const key = keys[i];
ret[i] = renderItem(source[key], key, i, cached && cached[i]);
}
}
} else {
ret = [];
}
if (cache) {
cache[index] = ret;
}
return ret;
}
function createSlots(slots, dynamicSlots) {
for (let i = 0; i < dynamicSlots.length; i++) {
const slot = dynamicSlots[i];
if (shared_esm_bundler_isArray(slot)) {
for (let j = 0; j < slot.length; j++) {
slots[slot[j].name] = slot[j].fn;
}
} else if (slot) {
slots[slot.name] = slot.key ? (...args) => {
const res = slot.fn(...args);
if (res) res.key = slot.key;
return res;
} : slot.fn;
}
}
return slots;
}
function renderSlot(slots, name, props = {}, fallback, noSlotted) {
if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) {
if (name !== "default") props.name = name;
return openBlock(), createBlock(
Fragment,
null,
[createVNode("slot", props, fallback && fallback())],
64
);
}
let slot = slots[name];
if (false) {}
if (slot && slot._c) {
slot._d = false;
}
openBlock();
const validSlotContent = slot && ensureValidVNode(slot(props));
const slotKey = props.key || // slot content array of a dynamic conditional slot may have a branch
// key attached in the `createSlots` helper, respect that
validSlotContent && validSlotContent.key;
const rendered = createBlock(
Fragment,
{
key: (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) + // #7256 force differentiate fallback content from actual content
(!validSlotContent && fallback ? "_fb" : "")
},
validSlotContent || (fallback ? fallback() : []),
validSlotContent && slots._ === 1 ? 64 : -2
);
if (!noSlotted && rendered.scopeId) {
rendered.slotScopeIds = [rendered.scopeId + "-s"];
}
if (slot && slot._c) {
slot._d = true;
}
return rendered;
}
function ensureValidVNode(vnodes) {
return vnodes.some((child) => {
if (!isVNode(child)) return true;
if (child.type === Comment) return false;
if (child.type === Fragment && !ensureValidVNode(child.children))
return false;
return true;
}) ? vnodes : null;
}
function toHandlers(obj, preserveCaseIfNecessary) {
const ret = {};
if (false) {}
for (const key in obj) {
ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key];
}
return ret;
}
const getPublicInstance = (i) => {
if (!i) return null;
if (isStatefulComponent(i)) return getComponentPublicInstance(i);
return getPublicInstance(i.parent);
};
const publicPropertiesMap = (
// Move PURE marker to new line to workaround compiler discarding it
// due to type annotation
/* @__PURE__ */ shared_esm_bundler_extend(/* @__PURE__ */ Object.create(null), {
$: (i) => i,
$el: (i) => i.vnode.el,
$data: (i) => i.data,
$props: (i) => false ? 0 : i.props,
$attrs: (i) => false ? 0 : i.attrs,
$slots: (i) => false ? 0 : i.slots,
$refs: (i) => false ? 0 : i.refs,
$parent: (i) => getPublicInstance(i.parent),
$root: (i) => getPublicInstance(i.root),
$host: (i) => i.ce,
$emit: (i) => i.emit,
$options: (i) => true ? resolveMergedOptions(i) : 0,
$forceUpdate: (i) => i.f || (i.f = () => {
queueJob(i.update);
}),
$nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
$watch: (i) => true ? instanceWatch.bind(i) : 0
})
);
const isReservedPrefix = (key) => key === "_" || key === "$";
const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
const PublicInstanceProxyHandlers = {
get({ _: instance }, key) {
if (key === "__v_skip") {
return true;
}
const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
if (false) {}
let normalizedProps;
if (key[0] !== "$") {
const n = accessCache[key];
if (n !== void 0) {
switch (n) {
case 1 /* SETUP */:
return setupState[key];
case 2 /* DATA */:
return data[key];
case 4 /* CONTEXT */:
return ctx[key];
case 3 /* PROPS */:
return props[key];
}
} else if (hasSetupBinding(setupState, key)) {
accessCache[key] = 1 /* SETUP */;
return setupState[key];
} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
accessCache[key] = 2 /* DATA */;
return data[key];
} else if (
// only cache other properties when instance has declared (thus stable)
// props
(normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)
) {
accessCache[key] = 3 /* PROPS */;
return props[key];
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
accessCache[key] = 4 /* CONTEXT */;
return ctx[key];
} else if ( false || shouldCacheAccess) {
accessCache[key] = 0 /* OTHER */;
}
}
const publicGetter = publicPropertiesMap[key];
let cssModule, globalProperties;
if (publicGetter) {
if (key === "$attrs") {
reactivity_esm_bundler_track(instance.attrs, "get", "");
false && 0;
} else if (false) {}
return publicGetter(instance);
} else if (
// css module (injected by vue-loader)
(cssModule = type.__cssModules) && (cssModule = cssModule[key])
) {
return cssModule;
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
accessCache[key] = 4 /* CONTEXT */;
return ctx[key];
} else if (
// global properties
globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)
) {
{
return globalProperties[key];
}
} else if (false) {}
},
set({ _: instance }, key, value) {
const { data, setupState, ctx } = instance;
if (hasSetupBinding(setupState, key)) {
setupState[key] = value;
return true;
} else if (false) {} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
data[key] = value;
return true;
} else if (hasOwn(instance.props, key)) {
false && 0;
return false;
}
if (key[0] === "$" && key.slice(1) in instance) {
false && 0;
return false;
} else {
if (false) {} else {
ctx[key] = value;
}
}
return true;
},
has({
_: { data, setupState, accessCache, ctx, appContext, propsOptions }
}, key) {
let normalizedProps;
return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
},
defineProperty(target, key, descriptor) {
if (descriptor.get != null) {
target._.accessCache[key] = 0;
} else if (hasOwn(descriptor, "value")) {
this.set(target, key, descriptor.value, null);
}
return Reflect.defineProperty(target, key, descriptor);
}
};
if (false) {}
const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ shared_esm_bundler_extend({}, PublicInstanceProxyHandlers, {
get(target, key) {
if (key === Symbol.unscopables) {
return;
}
return PublicInstanceProxyHandlers.get(target, key, target);
},
has(_, key) {
const has = key[0] !== "_" && !isGloballyAllowed(key);
if (false) {}
return has;
}
});
function createDevRenderContext(instance) {
const target = {};
Object.defineProperty(target, `_`, {
configurable: true,
enumerable: false,
get: () => instance
});
Object.keys(publicPropertiesMap).forEach((key) => {
Object.defineProperty(target, key, {
configurable: true,
enumerable: false,
get: () => publicPropertiesMap[key](instance),
// intercepted by the proxy so no need for implementation,
// but needed to prevent set errors
set: NOOP
});
});
return target;
}
function exposePropsOnRenderContext(instance) {
const {
ctx,
propsOptions: [propsOptions]
} = instance;
if (propsOptions) {
Object.keys(propsOptions).forEach((key) => {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => instance.props[key],
set: NOOP
});
});
}
}
function exposeSetupStateOnRenderContext(instance) {
const { ctx, setupState } = instance;
Object.keys(toRaw(setupState)).forEach((key) => {
if (!setupState.__isScriptSetup) {
if (isReservedPrefix(key[0])) {
warn$1(
`setup() return property ${JSON.stringify(
key
)} should not start with "$" or "_" which are reserved prefixes for Vue internals.`
);
return;
}
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => setupState[key],
set: NOOP
});
}
});
}
const warnRuntimeUsage = (method) => warn$1(
`${method}() is a compiler-hint helper that is only usable inside <script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.`
);
function defineProps() {
if (false) {}
return null;
}
function defineEmits() {
if (false) {}
return null;
}
function defineExpose(exposed) {
if (false) {}
}
function defineOptions(options) {
if (false) {}
}
function defineSlots() {
if (false) {}
return null;
}
function defineModel() {
if (false) {}
}
function withDefaults(props, defaults) {
if (false) {}
return null;
}
function useSlots() {
return getContext().slots;
}
function useAttrs() {
return getContext().attrs;
}
function getContext() {
const i = runtime_core_esm_bundler_getCurrentInstance();
if (false) {}
return i.setupContext || (i.setupContext = createSetupContext(i));
}
function normalizePropsOrEmits(props) {
return shared_esm_bundler_isArray(props) ? props.reduce(
(normalized, p) => (normalized[p] = null, normalized),
{}
) : props;
}
function mergeDefaults(raw, defaults) {
const props = normalizePropsOrEmits(raw);
for (const key in defaults) {
if (key.startsWith("__skip")) continue;
let opt = props[key];
if (opt) {
if (shared_esm_bundler_isArray(opt) || shared_esm_bundler_isFunction(opt)) {
opt = props[key] = { type: opt, default: defaults[key] };
} else {
opt.default = defaults[key];
}
} else if (opt === null) {
opt = props[key] = { default: defaults[key] };
} else if (false) {}
if (opt && defaults[`__skip_${key}`]) {
opt.skipFactory = true;
}
}
return props;
}
function mergeModels(a, b) {
if (!a || !b) return a || b;
if (shared_esm_bundler_isArray(a) && shared_esm_bundler_isArray(b)) return a.concat(b);
return shared_esm_bundler_extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
}
function createPropsRestProxy(props, excludedKeys) {
const ret = {};
for (const key in props) {
if (!excludedKeys.includes(key)) {
Object.defineProperty(ret, key, {
enumerable: true,
get: () => props[key]
});
}
}
return ret;
}
function withAsyncContext(getAwaitable) {
const ctx = runtime_core_esm_bundler_getCurrentInstance();
if (false) {}
let awaitable = getAwaitable();
unsetCurrentInstance();
if (isPromise(awaitable)) {
awaitable = awaitable.catch((e) => {
setCurrentInstance(ctx);
throw e;
});
}
return [awaitable, () => setCurrentInstance(ctx)];
}
function createDuplicateChecker() {
const cache = /* @__PURE__ */ Object.create(null);
return (type, key) => {
if (cache[key]) {
warn$1(`${type} property "${key}" is already defined in ${cache[key]}.`);
} else {
cache[key] = type;
}
};
}
let shouldCacheAccess = true;
function applyOptions(instance) {
const options = resolveMergedOptions(instance);
const publicThis = instance.proxy;
const ctx = instance.ctx;
shouldCacheAccess = false;
if (options.beforeCreate) {
callHook(options.beforeCreate, instance, "bc");
}
const {
// state
data: dataOptions,
computed: computedOptions,
methods,
watch: watchOptions,
provide: provideOptions,
inject: injectOptions,
// lifecycle
created,
beforeMount,
mounted,
beforeUpdate,
updated,
activated,
deactivated,
beforeDestroy,
beforeUnmount,
destroyed,
unmounted,
render,
renderTracked,
renderTriggered,
errorCaptured,
serverPrefetch,
// public API
expose,
inheritAttrs,
// assets
components,
directives,
filters
} = options;
const checkDuplicateProperties = false ? 0 : null;
if (false) {}
if (injectOptions) {
resolveInjections(injectOptions, ctx, checkDuplicateProperties);
}
if (methods) {
for (const key in methods) {
const methodHandler = methods[key];
if (shared_esm_bundler_isFunction(methodHandler)) {
if (false) {} else {
ctx[key] = methodHandler.bind(publicThis);
}
if (false) {}
} else if (false) {}
}
}
if (dataOptions) {
if (false) {}
const data = dataOptions.call(publicThis, publicThis);
if (false) {}
if (!shared_esm_bundler_isObject(data)) {
false && 0;
} else {
instance.data = reactive(data);
if (false) {}
}
}
shouldCacheAccess = true;
if (computedOptions) {
for (const key in computedOptions) {
const opt = computedOptions[key];
const get = shared_esm_bundler_isFunction(opt) ? opt.bind(publicThis, publicThis) : shared_esm_bundler_isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : shared_esm_bundler_NOOP;
if (false) {}
const set = !shared_esm_bundler_isFunction(opt) && shared_esm_bundler_isFunction(opt.set) ? opt.set.bind(publicThis) : false ? 0 : shared_esm_bundler_NOOP;
const c = runtime_core_esm_bundler_computed({
get,
set
});
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => c.value,
set: (v) => c.value = v
});
if (false) {}
}
}
if (watchOptions) {
for (const key in watchOptions) {
createWatcher(watchOptions[key], ctx, publicThis, key);
}
}
if (provideOptions) {
const provides = shared_esm_bundler_isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
Reflect.ownKeys(provides).forEach((key) => {
provide(key, provides[key]);
});
}
if (created) {
callHook(created, instance, "c");
}
function registerLifecycleHook(register, hook) {
if (shared_esm_bundler_isArray(hook)) {
hook.forEach((_hook) => register(_hook.bind(publicThis)));
} else if (hook) {
register(hook.bind(publicThis));
}
}
registerLifecycleHook(onBeforeMount, beforeMount);
registerLifecycleHook(runtime_core_esm_bundler_onMounted, mounted);
registerLifecycleHook(onBeforeUpdate, beforeUpdate);
registerLifecycleHook(onUpdated, updated);
registerLifecycleHook(onActivated, activated);
registerLifecycleHook(onDeactivated, deactivated);
registerLifecycleHook(onErrorCaptured, errorCaptured);
registerLifecycleHook(onRenderTracked, renderTracked);
registerLifecycleHook(onRenderTriggered, renderTriggered);
registerLifecycleHook(runtime_core_esm_bundler_onBeforeUnmount, beforeUnmount);
registerLifecycleHook(onUnmounted, unmounted);
registerLifecycleHook(onServerPrefetch, serverPrefetch);
if (shared_esm_bundler_isArray(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 === shared_esm_bundler_NOOP) {
instance.render = render;
}
if (inheritAttrs != null) {
instance.inheritAttrs = inheritAttrs;
}
if (components) instance.components = components;
if (directives) instance.directives = directives;
if (serverPrefetch) {
markAsyncBoundary(instance);
}
}
function resolveInjections(injectOptions, ctx, checkDuplicateProperties = shared_esm_bundler_NOOP) {
if (shared_esm_bundler_isArray(injectOptions)) {
injectOptions = normalizeInject(injectOptions);
}
for (const key in injectOptions) {
const opt = injectOptions[key];
let injected;
if (shared_esm_bundler_isObject(opt)) {
if ("default" in opt) {
injected = runtime_core_esm_bundler_inject(
opt.from || key,
opt.default,
true
);
} else {
injected = runtime_core_esm_bundler_inject(opt.from || key);
}
} else {
injected = runtime_core_esm_bundler_inject(opt);
}
if (reactivity_esm_bundler_isRef(injected)) {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => injected.value,
set: (v) => injected.value = v
});
} else {
ctx[key] = injected;
}
if (false) {}
}
}
function callHook(hook, instance, type) {
callWithAsyncErrorHandling(
shared_esm_bundler_isArray(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy),
instance,
type
);
}
function createWatcher(raw, ctx, publicThis, key) {
let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
if (shared_esm_bundler_isString(raw)) {
const handler = ctx[raw];
if (shared_esm_bundler_isFunction(handler)) {
{
runtime_core_esm_bundler_watch(getter, handler);
}
} else if (false) {}
} else if (shared_esm_bundler_isFunction(raw)) {
{
runtime_core_esm_bundler_watch(getter, raw.bind(publicThis));
}
} else if (shared_esm_bundler_isObject(raw)) {
if (shared_esm_bundler_isArray(raw)) {
raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
} else {
const handler = shared_esm_bundler_isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
if (shared_esm_bundler_isFunction(handler)) {
runtime_core_esm_bundler_watch(getter, handler, raw);
} else if (false) {}
}
} else if (false) {}
}
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);
}
if (shared_esm_bundler_isObject(base)) {
cache.set(base, resolved);
}
return resolved;
}
function mergeOptions(to, from, strats, asMixin = false) {
const { mixins, extends: extendsOptions } = from;
if (extendsOptions) {
mergeOptions(to, extendsOptions, strats, true);
}
if (mixins) {
mixins.forEach(
(m) => mergeOptions(to, m, strats, true)
);
}
for (const key in from) {
if (asMixin && key === "expose") {
false && 0;
} else {
const strat = internalOptionMergeStrats[key] || strats && strats[key];
to[key] = strat ? strat(to[key], from[key]) : from[key];
}
}
return to;
}
const internalOptionMergeStrats = {
data: mergeDataFn,
props: mergeEmitsOrPropsOptions,
emits: mergeEmitsOrPropsOptions,
// objects
methods: mergeObjectOptions,
computed: mergeObjectOptions,
// lifecycle
beforeCreate: mergeAsArray,
created: mergeAsArray,
beforeMount: mergeAsArray,
mounted: mergeAsArray,
beforeUpdate: mergeAsArray,
updated: mergeAsArray,
beforeDestroy: mergeAsArray,
beforeUnmount: mergeAsArray,
destroyed: mergeAsArray,
unmounted: mergeAsArray,
activated: mergeAsArray,
deactivated: mergeAsArray,
errorCaptured: mergeAsArray,
serverPrefetch: mergeAsArray,
// assets
components: mergeObjectOptions,
directives: mergeObjectOptions,
// watch
watch: mergeWatchOptions,
// provide / inject
provide: mergeDataFn,
inject: mergeInject
};
function mergeDataFn(to, from) {
if (!from) {
return to;
}
if (!to) {
return from;
}
return function mergedDataFn() {
return (shared_esm_bundler_extend)(
shared_esm_bundler_isFunction(to) ? to.call(this, this) : to,
shared_esm_bundler_isFunction(from) ? from.call(this, this) : from
);
};
}
function mergeInject(to, from) {
return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
}
function normalizeInject(raw) {
if (shared_esm_bundler_isArray(raw)) {
const res = {};
for (let i = 0; i < raw.length; i++) {
res[raw[i]] = raw[i];
}
return res;
}
return raw;
}
function mergeAsArray(to, from) {
return to ? [...new Set([].concat(to, from))] : from;
}
function mergeObjectOptions(to, from) {
return to ? shared_esm_bundler_extend(/* @__PURE__ */ Object.create(null), to, from) : from;
}
function mergeEmitsOrPropsOptions(to, from) {
if (to) {
if (shared_esm_bundler_isArray(to) && shared_esm_bundler_isArray(from)) {
return [.../* @__PURE__ */ new Set([...to, ...from])];
}
return shared_esm_bundler_extend(
/* @__PURE__ */ Object.create(null),
normalizePropsOrEmits(to),
normalizePropsOrEmits(from != null ? from : {})
);
} else {
return from;
}
}
function mergeWatchOptions(to, from) {
if (!to) return from;
if (!from) return to;
const merged = shared_esm_bundler_extend(/* @__PURE__ */ Object.create(null), to);
for (const key in from) {
merged[key] = mergeAsArray(to[key], from[key]);
}
return merged;
}
function createAppContext() {
return {
app: null,
config: {
isNativeTag: NO,
performance: false,
globalProperties: {},
optionMergeStrategies: {},
errorHandler: void 0,
warnHandler: void 0,
compilerOptions: {}
},
mixins: [],
components: {},
directives: {},
provides: /* @__PURE__ */ Object.create(null),
optionsCache: /* @__PURE__ */ new WeakMap(),
propsCache: /* @__PURE__ */ new WeakMap(),
emitsCache: /* @__PURE__ */ new WeakMap()
};
}
let uid$1 = 0;
function createAppAPI(render, hydrate) {
return function createApp(rootComponent, rootProps = null) {
if (!shared_esm_bundler_isFunction(rootComponent)) {
rootComponent = shared_esm_bundler_extend({}, rootComponent);
}
if (rootProps != null && !shared_esm_bundler_isObject(rootProps)) {
false && 0;
rootProps = null;
}
const context = createAppContext();
const installedPlugins = /* @__PURE__ */ new WeakSet();
const pluginCleanupFns = [];
let isMounted = false;
const app = context.app = {
_uid: uid$1++,
_component: rootComponent,
_props: rootProps,
_container: null,
_context: context,
_instance: null,
version,
get config() {
return context.config;
},
set config(v) {
if (false) {}
},
use(plugin, ...options) {
if (installedPlugins.has(plugin)) {
false && 0;
} else if (plugin && shared_esm_bundler_isFunction(plugin.install)) {
installedPlugins.add(plugin);
plugin.install(app, ...options);
} else if (shared_esm_bundler_isFunction(plugin)) {
installedPlugins.add(plugin);
plugin(app, ...options);
} else if (false) {}
return app;
},
mixin(mixin) {
if (true) {
if (!context.mixins.includes(mixin)) {
context.mixins.push(mixin);
} else if (false) {}
} else {}
return app;
},
component(name, component) {
if (false) {}
if (!component) {
return context.components[name];
}
if (false) {}
context.components[name] = component;
return app;
},
directive(name, directive) {
if (false) {}
if (!directive) {
return context.directives[name];
}
if (false) {}
context.directives[name] = directive;
return app;
},
mount(rootContainer, isHydrate, namespace) {
if (!isMounted) {
if (false) {}
const vnode = app._ceVNode || createVNode(rootComponent, rootProps);
vnode.appContext = context;
if (namespace === true) {
namespace = "svg";
} else if (namespace === false) {
namespace = void 0;
}
if (false) {}
if (isHydrate && hydrate) {
hydrate(vnode, rootContainer);
} else {
render(vnode, rootContainer, namespace);
}
isMounted = true;
app._container = rootContainer;
rootContainer.__vue_app__ = app;
if (false) {}
return getComponentPublicInstance(vnode.component);
} else if (false) {}
},
onUnmount(cleanupFn) {
if (false) {}
pluginCleanupFns.push(cleanupFn);
},
unmount() {
if (isMounted) {
callWithAsyncErrorHandling(
pluginCleanupFns,
app._instance,
16
);
render(null, app._container);
if (false) {}
delete app._container.__vue_app__;
} else if (false) {}
},
provide(key, value) {
if (false) {}
context.provides[key] = value;
return app;
},
runWithContext(fn) {
const lastApp = currentApp;
currentApp = app;
try {
return fn();
} finally {
currentApp = lastApp;
}
}
};
return app;
};
}
let currentApp = null;
function provide(key, value) {
if (!currentInstance) {
if (false) {}
} else {
let provides = currentInstance.provides;
const parentProvides = currentInstance.parent && currentInstance.parent.provides;
if (parentProvides === provides) {
provides = currentInstance.provides = Object.create(parentProvides);
}
provides[key] = value;
}
}
function runtime_core_esm_bundler_inject(key, defaultValue, treatDefaultAsFactory = false) {
const instance = currentInstance || currentRenderingInstance;
if (instance || currentApp) {
const provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
if (provides && key in provides) {
return provides[key];
} else if (arguments.length > 1) {
return treatDefaultAsFactory && shared_esm_bundler_isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
} else if (false) {}
} else if (false) {}
}
function hasInjectionContext() {
return !!(currentInstance || currentRenderingInstance || currentApp);
}
const internalObjectProto = {};
const createInternalObject = () => Object.create(internalObjectProto);
const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
function initProps(instance, rawProps, isStateful, isSSR = false) {
const props = {};
const attrs = createInternalObject();
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;
}
}
if (false) {}
if (isStateful) {
instance.props = isSSR ? props : shallowReactive(props);
} else {
if (!instance.type.props) {
instance.props = attrs;
} else {
instance.props = props;
}
}
instance.attrs = attrs;
}
function isInHmrContext(instance) {
while (instance) {
if (instance.type.__hmrId) return true;
instance = instance.parent;
}
}
function updateProps(instance, rawProps, rawPrevProps, optimized) {
const {
props,
attrs,
vnode: { patchFlag }
} = instance;
const rawCurrentProps = reactivity_esm_bundler_toRaw(props);
const [options] = instance.propsOptions;
let hasAttrsChanged = false;
if (
// always force full diff in dev
// - #1942 if hmr is enabled with sfc component
// - vite#872 non-sfc component used by sfc component
true && (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 = shared_esm_bundler_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 || // for camelCase
!hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
// and converted to camelCase (#955)
((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
if (options) {
if (rawPrevProps && // for camelCase
(rawPrevProps[key] !== void 0 || // for kebab-case
rawPrevProps[kebabKey] !== void 0)) {
props[key] = resolvePropValue(
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.attrs, "set", "");
}
if (false) {}
}
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 = shared_esm_bundler_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 = reactivity_esm_bundler_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 && !opt.skipFactory && shared_esm_bundler_isFunction(defaultValue)) {
const { propsDefaults } = instance;
if (key in propsDefaults) {
value = propsDefaults[key];
} else {
const reset = setCurrentInstance(instance);
value = propsDefaults[key] = defaultValue.call(
null,
props
);
reset();
}
} else {
value = defaultValue;
}
if (instance.ce) {
instance.ce._setProp(key, value);
}
}
if (opt[0 /* shouldCast */]) {
if (isAbsent && !hasDefault) {
value = false;
} else if (opt[1 /* shouldCastTrue */] && (value === "" || value === hyphenate(key))) {
value = true;
}
}
}
return value;
}
const mixinPropsCache = /* @__PURE__ */ new WeakMap();
function normalizePropsOptions(comp, appContext, asMixin = false) {
const cache = true && asMixin ? mixinPropsCache : appContext.propsCache;
const cached = cache.get(comp);
if (cached) {
return cached;
}
const raw = comp.props;
const normalized = {};
const needCastKeys = [];
let hasExtends = false;
if ( true && !shared_esm_bundler_isFunction(comp)) {
const extendProps = (raw2) => {
hasExtends = true;
const [props, keys] = normalizePropsOptions(raw2, appContext, true);
shared_esm_bundler_extend(normalized, props);
if (keys) needCastKeys.push(...keys);
};
if (!asMixin && appContext.mixins.length) {
appContext.mixins.forEach(extendProps);
}
if (comp.extends) {
extendProps(comp.extends);
}
if (comp.mixins) {
comp.mixins.forEach(extendProps);
}
}
if (!raw && !hasExtends) {
if (shared_esm_bundler_isObject(comp)) {
cache.set(comp, EMPTY_ARR);
}
return EMPTY_ARR;
}
if (shared_esm_bundler_isArray(raw)) {
for (let i = 0; i < raw.length; i++) {
if (false) {}
const normalizedKey = shared_esm_bundler_camelize(raw[i]);
if (validatePropName(normalizedKey)) {
normalized[normalizedKey] = EMPTY_OBJ;
}
}
} else if (raw) {
if (false) {}
for (const key in raw) {
const normalizedKey = shared_esm_bundler_camelize(key);
if (validatePropName(normalizedKey)) {
const opt = raw[key];
const prop = normalized[normalizedKey] = shared_esm_bundler_isArray(opt) || shared_esm_bundler_isFunction(opt) ? { type: opt } : shared_esm_bundler_extend({}, opt);
const propType = prop.type;
let shouldCast = false;
let shouldCastTrue = true;
if (shared_esm_bundler_isArray(propType)) {
for (let index = 0; index < propType.length; ++index) {
const type = propType[index];
const typeName = shared_esm_bundler_isFunction(type) && type.name;
if (typeName === "Boolean") {
shouldCast = true;
break;
} else if (typeName === "String") {
shouldCastTrue = false;
}
}
} else {
shouldCast = shared_esm_bundler_isFunction(propType) && propType.name === "Boolean";
}
prop[0 /* shouldCast */] = shouldCast;
prop[1 /* shouldCastTrue */] = shouldCastTrue;
if (shouldCast || hasOwn(prop, "default")) {
needCastKeys.push(normalizedKey);
}
}
}
}
const res = [normalized, needCastKeys];
if (shared_esm_bundler_isObject(comp)) {
cache.set(comp, res);
}
return res;
}
function validatePropName(key) {
if (key[0] !== "$" && !isReservedProp(key)) {
return true;
} else if (false) {}
return false;
}
function getType(ctor) {
if (ctor === null) {
return "null";
}
if (typeof ctor === "function") {
return ctor.name || "";
} else if (typeof ctor === "object") {
const name = ctor.constructor && ctor.constructor.name;
return name || "";
}
return "";
}
function validateProps(rawProps, props, instance) {
const resolvedValues = toRaw(props);
const options = instance.propsOptions[0];
const camelizePropsKey = Object.keys(rawProps).map((key) => camelize(key));
for (const key in options) {
let opt = options[key];
if (opt == null) continue;
validateProp(
key,
resolvedValues[key],
opt,
false ? 0 : resolvedValues,
!camelizePropsKey.includes(key)
);
}
}
function validateProp(name, value, prop, props, isAbsent) {
const { type, required, validator, skipCheck } = prop;
if (required && isAbsent) {
warn$1('Missing required prop: "' + name + '"');
return;
}
if (value == null && !required) {
return;
}
if (type != null && type !== true && !skipCheck) {
let isValid = false;
const types = isArray(type) ? type : [type];
const expectedTypes = [];
for (let i = 0; i < types.length && !isValid; i++) {
const { valid, expectedType } = assertType(value, types[i]);
expectedTypes.push(expectedType || "");
isValid = valid;
}
if (!isValid) {
warn$1(getInvalidTypeMessage(name, value, expectedTypes));
return;
}
}
if (validator && !validator(value, props)) {
warn$1('Invalid prop: custom validator check failed for prop "' + name + '".');
}
}
const isSimpleType = /* @__PURE__ */ (/* unused pure expression or super */ null && (makeMap(
"String,Number,Boolean,Function,Symbol,BigInt"
)));
function assertType(value, type) {
let valid;
const expectedType = getType(type);
if (expectedType === "null") {
valid = value === null;
} else if (isSimpleType(expectedType)) {
const t = typeof value;
valid = t === expectedType.toLowerCase();
if (!valid && t === "object") {
valid = value instanceof type;
}
} else if (expectedType === "Object") {
valid = isObject(value);
} else if (expectedType === "Array") {
valid = isArray(value);
} else {
valid = value instanceof type;
}
return {
valid,
expectedType
};
}
function getInvalidTypeMessage(name, value, expectedTypes) {
if (expectedTypes.length === 0) {
return `Prop type [] for prop "${name}" won't match anything. Did you mean to use type Array instead?`;
}
let message = `Invalid prop: type check failed for prop "${name}". Expected ${expectedTypes.map(capitalize).join(" | ")}`;
const expectedType = expectedTypes[0];
const receivedType = toRawType(value);
const expectedValue = styleValue(value, expectedType);
const receivedValue = styleValue(value, receivedType);
if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
message += ` with value ${expectedValue}`;
}
message += `, got ${receivedType} `;
if (isExplicable(receivedType)) {
message += `with value ${receivedValue}.`;
}
return message;
}
function styleValue(value, type) {
if (type === "String") {
return `"${value}"`;
} else if (type === "Number") {
return `${Number(value)}`;
} else {
return `${value}`;
}
}
function isExplicable(type) {
const explicitTypes = ["string", "number", "boolean"];
return explicitTypes.some((elem) => type.toLowerCase() === elem);
}
function isBoolean(...args) {
return args.some((elem) => elem.toLowerCase() === "boolean");
}
const isInternalKey = (key) => key[0] === "_" || key === "$stable";
const normalizeSlotValue = (value) => shared_esm_bundler_isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
const normalizeSlot = (key, rawSlot, ctx) => {
if (rawSlot._n) {
return rawSlot;
}
const normalized = withCtx((...args) => {
if (false) {}
return normalizeSlotValue(rawSlot(...args));
}, ctx);
normalized._c = false;
return normalized;
};
const normalizeObjectSlots = (rawSlots, slots, instance) => {
const ctx = rawSlots._ctx;
for (const key in rawSlots) {
if (isInternalKey(key)) continue;
const value = rawSlots[key];
if (shared_esm_bundler_isFunction(value)) {
slots[key] = normalizeSlot(key, value, ctx);
} else if (value != null) {
if (false) {}
const normalized = normalizeSlotValue(value);
slots[key] = () => normalized;
}
}
};
const normalizeVNodeSlots = (instance, children) => {
if (false) {}
const normalized = normalizeSlotValue(children);
instance.slots.default = () => normalized;
};
const assignSlots = (slots, children, optimized) => {
for (const key in children) {
if (optimized || key !== "_") {
slots[key] = children[key];
}
}
};
const initSlots = (instance, children, optimized) => {
const slots = instance.slots = createInternalObject();
if (instance.vnode.shapeFlag & 32) {
const type = children._;
if (type) {
assignSlots(slots, children, optimized);
if (optimized) {
def(slots, "_", type, true);
}
} else {
normalizeObjectSlots(children, slots);
}
} else if (children) {
normalizeVNodeSlots(instance, children);
}
};
const updateSlots = (instance, children, optimized) => {
const { vnode, slots } = instance;
let needDeletionCheck = true;
let deletionComparisonTarget = EMPTY_OBJ;
if (vnode.shapeFlag & 32) {
const type = children._;
if (type) {
if (false) {} else if (optimized && type === 1) {
needDeletionCheck = false;
} else {
assignSlots(slots, children, optimized);
}
} else {
needDeletionCheck = !children.$stable;
normalizeObjectSlots(children, slots);
}
deletionComparisonTarget = children;
} else if (children) {
normalizeVNodeSlots(instance, children);
deletionComparisonTarget = { default: 1 };
}
if (needDeletionCheck) {
for (const key in slots) {
if (!isInternalKey(key) && deletionComparisonTarget[key] == null) {
delete slots[key];
}
}
}
};
let supported;
let perf;
function startMeasure(instance, type) {
if (instance.appContext.config.performance && isSupported()) {
perf.mark(`vue-${type}-${instance.uid}`);
}
if (false) {}
}
function endMeasure(instance, type) {
if (instance.appContext.config.performance && isSupported()) {
const startTag = `vue-${type}-${instance.uid}`;
const endTag = startTag + `:end`;
perf.mark(endTag);
perf.measure(
`<${formatComponentName(instance, instance.type)}> ${type}`,
startTag,
endTag
);
perf.clearMarks(startTag);
perf.clearMarks(endTag);
}
if (false) {}
}
function isSupported() {
if (supported !== void 0) {
return supported;
}
if (typeof window !== "undefined" && window.performance) {
supported = true;
perf = window.performance;
} else {
supported = false;
}
return supported;
}
function initFeatureFlags() {
const needWarn = [];
if (false) {}
if (false) {}
if (false) {}
if (false) {}
}
const queuePostRenderEffect = queueEffectWithSuspense ;
function createRenderer(options) {
return baseCreateRenderer(options);
}
function createHydrationRenderer(options) {
return baseCreateRenderer(options, createHydrationFunctions);
}
function baseCreateRenderer(options, createHydrationFns) {
{
initFeatureFlags();
}
const target = getGlobalThis();
target.__VUE__ = true;
if (false) {}
const {
insert: hostInsert,
remove: hostRemove,
patchProp: hostPatchProp,
createElement: hostCreateElement,
createText: hostCreateText,
createComment: hostCreateComment,
setText: hostSetText,
setElementText: hostSetElementText,
parentNode: hostParentNode,
nextSibling: hostNextSibling,
setScopeId: hostSetScopeId = shared_esm_bundler_NOOP,
insertStaticContent: hostInsertStaticContent
} = options;
const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, namespace = void 0, slotScopeIds = null, optimized = false ? 0 : !!n2.dynamicChildren) => {
if (n1 === n2) {
return;
}
if (n1 && !isSameVNodeType(n1, n2)) {
anchor = getNextHostNode(n1);
unmount(n1, parentComponent, parentSuspense, true);
n1 = null;
}
if (n2.patchFlag === -2) {
optimized = false;
n2.dynamicChildren = null;
}
const { type, ref, shapeFlag } = n2;
switch (type) {
case Text:
processText(n1, n2, container, anchor);
break;
case Comment:
processCommentNode(n1, n2, container, anchor);
break;
case Static:
if (n1 == null) {
mountStaticNode(n2, container, anchor, namespace);
} else if (false) {}
break;
case Fragment:
processFragment(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
break;
default:
if (shapeFlag & 1) {
processElement(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else if (shapeFlag & 6) {
processComponent(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else if (shapeFlag & 64) {
type.process(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized,
internals
);
} else if (shapeFlag & 128) {
type.process(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized,
internals
);
} else if (false) {}
}
if (ref != null && parentComponent) {
setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
}
};
const processText = (n1, n2, container, anchor) => {
if (n1 == null) {
hostInsert(
n2.el = hostCreateText(n2.children),
container,
anchor
);
} else {
const el = n2.el = n1.el;
if (n2.children !== n1.children) {
hostSetText(el, n2.children);
}
}
};
const processCommentNode = (n1, n2, container, anchor) => {
if (n1 == null) {
hostInsert(
n2.el = hostCreateComment(n2.children || ""),
container,
anchor
);
} else {
n2.el = n1.el;
}
};
const mountStaticNode = (n2, container, anchor, namespace) => {
[n2.el, n2.anchor] = hostInsertStaticContent(
n2.children,
container,
anchor,
namespace,
n2.el,
n2.anchor
);
};
const patchStaticNode = (n1, n2, container, namespace) => {
if (n2.children !== n1.children) {
const anchor = hostNextSibling(n1.anchor);
removeStaticNode(n1);
[n2.el, n2.anchor] = hostInsertStaticContent(
n2.children,
container,
anchor,
namespace
);
} else {
n2.el = n1.el;
n2.anchor = n1.anchor;
}
};
const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
let next;
while (el && el !== anchor) {
next = hostNextSibling(el);
hostInsert(el, container, nextSibling);
el = next;
}
hostInsert(anchor, container, nextSibling);
};
const removeStaticNode = ({ el, anchor }) => {
let next;
while (el && el !== anchor) {
next = hostNextSibling(el);
hostRemove(el);
el = next;
}
hostRemove(anchor);
};
const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
if (n2.type === "svg") {
namespace = "svg";
} else if (n2.type === "math") {
namespace = "mathml";
}
if (n1 == null) {
mountElement(
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else {
patchElement(
n1,
n2,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
};
const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
let el;
let vnodeHook;
const { props, shapeFlag, transition, dirs } = vnode;
el = vnode.el = hostCreateElement(
vnode.type,
namespace,
props && props.is,
props
);
if (shapeFlag & 8) {
hostSetElementText(el, vnode.children);
} else if (shapeFlag & 16) {
mountChildren(
vnode.children,
el,
null,
parentComponent,
parentSuspense,
resolveChildrenNamespace(vnode, namespace),
slotScopeIds,
optimized
);
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "created");
}
setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
if (props) {
for (const key in props) {
if (key !== "value" && !isReservedProp(key)) {
hostPatchProp(el, key, null, props[key], namespace, parentComponent);
}
}
if ("value" in props) {
hostPatchProp(el, "value", null, props.value, namespace);
}
if (vnodeHook = props.onVnodeBeforeMount) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
}
if (false) {}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
}
const needCallTransitionHooks = needTransition(parentSuspense, transition);
if (needCallTransitionHooks) {
transition.beforeEnter(el);
}
hostInsert(el, container, anchor);
if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
needCallTransitionHooks && transition.enter(el);
dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
}, parentSuspense);
}
};
const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
if (scopeId) {
hostSetScopeId(el, scopeId);
}
if (slotScopeIds) {
for (let i = 0; i < slotScopeIds.length; i++) {
hostSetScopeId(el, slotScopeIds[i]);
}
}
if (parentComponent) {
let subTree = parentComponent.subTree;
if (false) {}
if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
const parentVNode = parentComponent.vnode;
setScopeId(
el,
parentVNode,
parentVNode.scopeId,
parentVNode.slotScopeIds,
parentComponent.parent
);
}
}
};
const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, start = 0) => {
for (let i = start; i < children.length; i++) {
const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
patch(
null,
child,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
};
const patchElement = (n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
const el = n2.el = n1.el;
if (false) {}
let { patchFlag, dynamicChildren, dirs } = n2;
patchFlag |= n1.patchFlag & 16;
const oldProps = n1.props || EMPTY_OBJ;
const newProps = n2.props || EMPTY_OBJ;
let vnodeHook;
parentComponent && toggleRecurse(parentComponent, false);
if (vnodeHook = newProps.onVnodeBeforeUpdate) {
invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
}
if (dirs) {
invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
}
parentComponent && toggleRecurse(parentComponent, true);
if (false) {}
if (oldProps.innerHTML && newProps.innerHTML == null || oldProps.textContent && newProps.textContent == null) {
hostSetElementText(el, "");
}
if (dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
el,
parentComponent,
parentSuspense,
resolveChildrenNamespace(n2, namespace),
slotScopeIds
);
if (false) {}
} else if (!optimized) {
patchChildren(
n1,
n2,
el,
null,
parentComponent,
parentSuspense,
resolveChildrenNamespace(n2, namespace),
slotScopeIds,
false
);
}
if (patchFlag > 0) {
if (patchFlag & 16) {
patchProps(el, oldProps, newProps, parentComponent, namespace);
} else {
if (patchFlag & 2) {
if (oldProps.class !== newProps.class) {
hostPatchProp(el, "class", null, newProps.class, namespace);
}
}
if (patchFlag & 4) {
hostPatchProp(el, "style", oldProps.style, newProps.style, namespace);
}
if (patchFlag & 8) {
const propsToUpdate = n2.dynamicProps;
for (let i = 0; i < propsToUpdate.length; i++) {
const key = propsToUpdate[i];
const prev = oldProps[key];
const next = newProps[key];
if (next !== prev || key === "value") {
hostPatchProp(el, key, prev, next, namespace, parentComponent);
}
}
}
}
if (patchFlag & 1) {
if (n1.children !== n2.children) {
hostSetElementText(el, n2.children);
}
}
} else if (!optimized && dynamicChildren == null) {
patchProps(el, oldProps, newProps, parentComponent, namespace);
}
if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
}, parentSuspense);
}
};
const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, namespace, slotScopeIds) => {
for (let i = 0; i < newChildren.length; i++) {
const oldVNode = oldChildren[i];
const newVNode = newChildren[i];
const container = (
// oldVNode may be an errored async setup() component inside Suspense
// which will not have a mounted element
oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent
// of the Fragment itself so it can move its children.
(oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
// which also requires the correct parent container
!isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : (
// In other cases, the parent container is not actually used so we
// just pass the block element here to avoid a DOM parentNode call.
fallbackContainer
)
);
patch(
oldVNode,
newVNode,
container,
null,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
true
);
}
};
const patchProps = (el, oldProps, newProps, parentComponent, namespace) => {
if (oldProps !== newProps) {
if (oldProps !== EMPTY_OBJ) {
for (const key in oldProps) {
if (!isReservedProp(key) && !(key in newProps)) {
hostPatchProp(
el,
key,
oldProps[key],
null,
namespace,
parentComponent
);
}
}
}
for (const key in newProps) {
if (isReservedProp(key)) continue;
const next = newProps[key];
const prev = oldProps[key];
if (next !== prev && key !== "value") {
hostPatchProp(el, key, prev, next, namespace, parentComponent);
}
}
if ("value" in newProps) {
hostPatchProp(el, "value", oldProps.value, newProps.value, namespace);
}
}
};
const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
if (false) {}
if (fragmentSlotScopeIds) {
slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
}
if (n1 == null) {
hostInsert(fragmentStartAnchor, container, anchor);
hostInsert(fragmentEndAnchor, container, anchor);
mountChildren(
// #10007
// such fragment like `<></>` will be compiled into
// a fragment which doesn't have a children.
// In this case fallback to an empty array
n2.children || [],
container,
fragmentEndAnchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else {
if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
// of renderSlot() with no valid children
n1.dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
container,
parentComponent,
parentSuspense,
namespace,
slotScopeIds
);
if (false) {} else if (
// #2080 if the stable fragment has a key, it's a <template v-for> that may
// get moved around. Make sure all root level vnodes inherit el.
// #2134 or if it's a component root, it may also get moved around
// as the component is being moved.
n2.key != null || parentComponent && n2 === parentComponent.subTree
) {
traverseStaticChildren(
n1,
n2,
true
/* shallow */
);
}
} else {
patchChildren(
n1,
n2,
container,
fragmentEndAnchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
}
};
const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
n2.slotScopeIds = slotScopeIds;
if (n1 == null) {
if (n2.shapeFlag & 512) {
parentComponent.ctx.activate(
n2,
container,
anchor,
namespace,
optimized
);
} else {
mountComponent(
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
optimized
);
}
} else {
updateComponent(n1, n2, optimized);
}
};
const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, namespace, optimized) => {
const instance = (initialVNode.component = createComponentInstance(
initialVNode,
parentComponent,
parentSuspense
));
if (false) {}
if (false) {}
if (isKeepAlive(initialVNode)) {
instance.ctx.renderer = internals;
}
{
if (false) {}
setupComponent(instance, false, optimized);
if (false) {}
}
if (instance.asyncDep) {
if (false) {}
parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect, optimized);
if (!initialVNode.el) {
const placeholder = instance.subTree = createVNode(Comment);
processCommentNode(null, placeholder, container, anchor);
}
} else {
setupRenderEffect(
instance,
initialVNode,
container,
anchor,
parentSuspense,
namespace,
optimized
);
}
if (false) {}
};
const updateComponent = (n1, n2, optimized) => {
const instance = n2.component = n1.component;
if (shouldUpdateComponent(n1, n2, optimized)) {
if (instance.asyncDep && !instance.asyncResolved) {
if (false) {}
updateComponentPreRender(instance, n2, optimized);
if (false) {}
return;
} else {
instance.next = n2;
instance.update();
}
} else {
n2.el = n1.el;
instance.vnode = n2;
}
};
const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) => {
const componentUpdateFn = () => {
if (!instance.isMounted) {
let vnodeHook;
const { el, props } = initialVNode;
const { bm, m, parent, root, type } = instance;
const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
toggleRecurse(instance, false);
if (bm) {
invokeArrayFns(bm);
}
if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHook, parent, initialVNode);
}
toggleRecurse(instance, true);
if (el && hydrateNode) {
const hydrateSubTree = () => {
if (false) {}
instance.subTree = renderComponentRoot(instance);
if (false) {}
if (false) {}
hydrateNode(
el,
instance.subTree,
instance,
parentSuspense,
null
);
if (false) {}
};
if (isAsyncWrapperVNode && type.__asyncHydrate) {
type.__asyncHydrate(
el,
instance,
hydrateSubTree
);
} else {
hydrateSubTree();
}
} else {
if (root.ce) {
root.ce._injectChildStyle(type);
}
if (false) {}
const subTree = instance.subTree = renderComponentRoot(instance);
if (false) {}
if (false) {}
patch(
null,
subTree,
container,
anchor,
instance,
parentSuspense,
namespace
);
if (false) {}
initialVNode.el = subTree.el;
}
if (m) {
queuePostRenderEffect(m, parentSuspense);
}
if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
const scopedInitialVNode = initialVNode;
queuePostRenderEffect(
() => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
parentSuspense
);
}
if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
instance.a && queuePostRenderEffect(instance.a, parentSuspense);
}
instance.isMounted = true;
if (false) {}
initialVNode = container = anchor = null;
} else {
let { next, bu, u, parent, vnode } = instance;
{
const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance);
if (nonHydratedAsyncRoot) {
if (next) {
next.el = vnode.el;
updateComponentPreRender(instance, next, optimized);
}
nonHydratedAsyncRoot.asyncDep.then(() => {
if (!instance.isUnmounted) {
componentUpdateFn();
}
});
return;
}
}
let originNext = next;
let vnodeHook;
if (false) {}
toggleRecurse(instance, false);
if (next) {
next.el = vnode.el;
updateComponentPreRender(instance, next, optimized);
} else {
next = vnode;
}
if (bu) {
invokeArrayFns(bu);
}
if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {
invokeVNodeHook(vnodeHook, parent, next, vnode);
}
toggleRecurse(instance, true);
if (false) {}
const nextTree = renderComponentRoot(instance);
if (false) {}
const prevTree = instance.subTree;
instance.subTree = nextTree;
if (false) {}
patch(
prevTree,
nextTree,
// parent may have changed if it's in a teleport
hostParentNode(prevTree.el),
// anchor may have changed if it's in a fragment
getNextHostNode(prevTree),
instance,
parentSuspense,
namespace
);
if (false) {}
next.el = nextTree.el;
if (originNext === null) {
updateHOCHostEl(instance, nextTree.el);
}
if (u) {
queuePostRenderEffect(u, parentSuspense);
}
if (vnodeHook = next.props && next.props.onVnodeUpdated) {
queuePostRenderEffect(
() => invokeVNodeHook(vnodeHook, parent, next, vnode),
parentSuspense
);
}
if (false) {}
if (false) {}
}
};
instance.scope.on();
const effect = instance.effect = new ReactiveEffect(componentUpdateFn);
instance.scope.off();
const update = instance.update = effect.run.bind(effect);
const job = instance.job = effect.runIfDirty.bind(effect);
job.i = instance;
job.id = instance.uid;
effect.scheduler = () => queueJob(job);
toggleRecurse(instance, true);
if (false) {}
update();
};
const updateComponentPreRender = (instance, nextVNode, optimized) => {
nextVNode.component = instance;
const prevProps = instance.vnode.props;
instance.vnode = nextVNode;
instance.next = null;
updateProps(instance, nextVNode.props, prevProps, optimized);
updateSlots(instance, nextVNode.children, optimized);
reactivity_esm_bundler_pauseTracking();
flushPreFlushCbs(instance);
reactivity_esm_bundler_resetTracking();
};
const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized = false) => {
const c1 = n1 && n1.children;
const prevShapeFlag = n1 ? n1.shapeFlag : 0;
const c2 = n2.children;
const { patchFlag, shapeFlag } = n2;
if (patchFlag > 0) {
if (patchFlag & 128) {
patchKeyedChildren(
c1,
c2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
return;
} else if (patchFlag & 256) {
patchUnkeyedChildren(
c1,
c2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
return;
}
}
if (shapeFlag & 8) {
if (prevShapeFlag & 16) {
unmountChildren(c1, parentComponent, parentSuspense);
}
if (c2 !== c1) {
hostSetElementText(container, c2);
}
} else {
if (prevShapeFlag & 16) {
if (shapeFlag & 16) {
patchKeyedChildren(
c1,
c2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else {
unmountChildren(c1, parentComponent, parentSuspense, true);
}
} else {
if (prevShapeFlag & 8) {
hostSetElementText(container, "");
}
if (shapeFlag & 16) {
mountChildren(
c2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
}
}
};
const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
c1 = c1 || EMPTY_ARR;
c2 = c2 || EMPTY_ARR;
const oldLength = c1.length;
const newLength = c2.length;
const commonLength = Math.min(oldLength, newLength);
let i;
for (i = 0; i < commonLength; i++) {
const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
patch(
c1[i],
nextChild,
container,
null,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
}
if (oldLength > newLength) {
unmountChildren(
c1,
parentComponent,
parentSuspense,
true,
false,
commonLength
);
} else {
mountChildren(
c2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized,
commonLength
);
}
};
const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
let i = 0;
const l2 = c2.length;
let e1 = c1.length - 1;
let e2 = l2 - 1;
while (i <= e1 && i <= e2) {
const n1 = c1[i];
const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
if (isSameVNodeType(n1, n2)) {
patch(
n1,
n2,
container,
null,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else {
break;
}
i++;
}
while (i <= e1 && i <= e2) {
const n1 = c1[e1];
const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
if (isSameVNodeType(n1, n2)) {
patch(
n1,
n2,
container,
null,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else {
break;
}
e1--;
e2--;
}
if (i > e1) {
if (i <= e2) {
const nextPos = e2 + 1;
const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
while (i <= e2) {
patch(
null,
c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]),
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
i++;
}
}
} else if (i > e2) {
while (i <= e1) {
unmount(c1[i], parentComponent, parentSuspense, true);
i++;
}
} else {
const s1 = i;
const s2 = i;
const keyToNewIndexMap = /* @__PURE__ */ new Map();
for (i = s2; i <= e2; i++) {
const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
if (nextChild.key != null) {
if (false) {}
keyToNewIndexMap.set(nextChild.key, i);
}
}
let j;
let patched = 0;
const toBePatched = e2 - s2 + 1;
let moved = false;
let maxNewIndexSoFar = 0;
const newIndexToOldIndexMap = new Array(toBePatched);
for (i = 0; i < toBePatched; i++) newIndexToOldIndexMap[i] = 0;
for (i = s1; i <= e1; i++) {
const prevChild = c1[i];
if (patched >= toBePatched) {
unmount(prevChild, parentComponent, parentSuspense, true);
continue;
}
let newIndex;
if (prevChild.key != null) {
newIndex = keyToNewIndexMap.get(prevChild.key);
} else {
for (j = s2; j <= e2; j++) {
if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
newIndex = j;
break;
}
}
}
if (newIndex === void 0) {
unmount(prevChild, parentComponent, parentSuspense, true);
} else {
newIndexToOldIndexMap[newIndex - s2] = i + 1;
if (newIndex >= maxNewIndexSoFar) {
maxNewIndexSoFar = newIndex;
} else {
moved = true;
}
patch(
prevChild,
c2[newIndex],
container,
null,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
patched++;
}
}
const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR;
j = increasingNewIndexSequence.length - 1;
for (i = toBePatched - 1; i >= 0; i--) {
const nextIndex = s2 + i;
const nextChild = c2[nextIndex];
const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
if (newIndexToOldIndexMap[i] === 0) {
patch(
null,
nextChild,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized
);
} else if (moved) {
if (j < 0 || i !== increasingNewIndexSequence[j]) {
move(nextChild, container, anchor, 2);
} else {
j--;
}
}
}
}
};
const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
const { el, type, transition, children, shapeFlag } = vnode;
if (shapeFlag & 6) {
move(vnode.component.subTree, container, anchor, moveType);
return;
}
if (shapeFlag & 128) {
vnode.suspense.move(container, anchor, moveType);
return;
}
if (shapeFlag & 64) {
type.move(vnode, container, anchor, internals);
return;
}
if (type === Fragment) {
hostInsert(el, container, anchor);
for (let i = 0; i < children.length; i++) {
move(children[i], container, anchor, moveType);
}
hostInsert(vnode.anchor, container, anchor);
return;
}
if (type === Static) {
moveStaticNode(vnode, container, anchor);
return;
}
const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
if (needTransition2) {
if (moveType === 0) {
transition.beforeEnter(el);
hostInsert(el, container, anchor);
queuePostRenderEffect(() => transition.enter(el), parentSuspense);
} else {
const { leave, delayLeave, afterLeave } = transition;
const remove2 = () => hostInsert(el, container, anchor);
const performLeave = () => {
leave(el, () => {
remove2();
afterLeave && afterLeave();
});
};
if (delayLeave) {
delayLeave(el, remove2, performLeave);
} else {
performLeave();
}
}
} else {
hostInsert(el, container, anchor);
}
};
const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
const {
type,
props,
ref,
children,
dynamicChildren,
shapeFlag,
patchFlag,
dirs,
cacheIndex
} = vnode;
if (patchFlag === -2) {
optimized = false;
}
if (ref != null) {
setRef(ref, null, parentSuspense, vnode, true);
}
if (cacheIndex != null) {
parentComponent.renderCache[cacheIndex] = void 0;
}
if (shapeFlag & 256) {
parentComponent.ctx.deactivate(vnode);
return;
}
const shouldInvokeDirs = shapeFlag & 1 && dirs;
const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
let vnodeHook;
if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
if (shapeFlag & 6) {
unmountComponent(vnode.component, parentSuspense, doRemove);
} else {
if (shapeFlag & 128) {
vnode.suspense.unmount(parentSuspense, doRemove);
return;
}
if (shouldInvokeDirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
}
if (shapeFlag & 64) {
vnode.type.remove(
vnode,
parentComponent,
parentSuspense,
internals,
doRemove
);
} else if (dynamicChildren && // #5154
// when v-once is used inside a block, setBlockTracking(-1) marks the
// parent block with hasOnce: true
// so that it doesn't take the fast path during unmount - otherwise
// components nested in v-once are never unmounted.
!dynamicChildren.hasOnce && // #1153: fast path should not be taken for non-stable (v-for) fragments
(type !== Fragment || patchFlag > 0 && patchFlag & 64)) {
unmountChildren(
dynamicChildren,
parentComponent,
parentSuspense,
false,
true
);
} else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
unmountChildren(children, parentComponent, parentSuspense);
}
if (doRemove) {
remove(vnode);
}
}
if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
}, parentSuspense);
}
};
const remove = (vnode) => {
const { type, el, anchor, transition } = vnode;
if (type === Fragment) {
if (false) {} else {
removeFragment(el, anchor);
}
return;
}
if (type === Static) {
removeStaticNode(vnode);
return;
}
const performRemove = () => {
hostRemove(el);
if (transition && !transition.persisted && transition.afterLeave) {
transition.afterLeave();
}
};
if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
const { leave, delayLeave } = transition;
const performLeave = () => leave(el, performRemove);
if (delayLeave) {
delayLeave(vnode.el, performRemove, performLeave);
} else {
performLeave();
}
} else {
performRemove();
}
};
const removeFragment = (cur, end) => {
let next;
while (cur !== end) {
next = hostNextSibling(cur);
hostRemove(cur);
cur = next;
}
hostRemove(end);
};
const unmountComponent = (instance, parentSuspense, doRemove) => {
if (false) {}
const { bum, scope, job, subTree, um, m, a } = instance;
invalidateMount(m);
invalidateMount(a);
if (bum) {
invokeArrayFns(bum);
}
scope.stop();
if (job) {
job.flags |= 8;
unmount(subTree, instance, parentSuspense, doRemove);
}
if (um) {
queuePostRenderEffect(um, parentSuspense);
}
queuePostRenderEffect(() => {
instance.isUnmounted = true;
}, parentSuspense);
if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
parentSuspense.deps--;
if (parentSuspense.deps === 0) {
parentSuspense.resolve();
}
}
if (false) {}
};
const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
for (let i = start; i < children.length; i++) {
unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
}
};
const getNextHostNode = (vnode) => {
if (vnode.shapeFlag & 6) {
return getNextHostNode(vnode.component.subTree);
}
if (vnode.shapeFlag & 128) {
return vnode.suspense.next();
}
const el = hostNextSibling(vnode.anchor || vnode.el);
const teleportEnd = el && el[TeleportEndKey];
return teleportEnd ? hostNextSibling(teleportEnd) : el;
};
let isFlushing = false;
const render = (vnode, container, namespace) => {
if (vnode == null) {
if (container._vnode) {
unmount(container._vnode, null, null, true);
}
} else {
patch(
container._vnode || null,
vnode,
container,
null,
null,
null,
namespace
);
}
container._vnode = vnode;
if (!isFlushing) {
isFlushing = true;
flushPreFlushCbs();
flushPostFlushCbs();
isFlushing = false;
}
};
const internals = {
p: patch,
um: unmount,
m: move,
r: remove,
mt: mountComponent,
mc: mountChildren,
pc: patchChildren,
pbc: patchBlockChildren,
n: getNextHostNode,
o: options
};
let hydrate;
let hydrateNode;
if (createHydrationFns) {
[hydrate, hydrateNode] = createHydrationFns(
internals
);
}
return {
render,
hydrate,
createApp: createAppAPI(render, hydrate)
};
}
function resolveChildrenNamespace({ type, props }, currentNamespace) {
return currentNamespace === "svg" && type === "foreignObject" || currentNamespace === "mathml" && type === "annotation-xml" && props && props.encoding && props.encoding.includes("html") ? void 0 : currentNamespace;
}
function toggleRecurse({ effect, job }, allowed) {
if (allowed) {
effect.flags |= 32;
job.flags |= 4;
} else {
effect.flags &= ~32;
job.flags &= ~4;
}
}
function needTransition(parentSuspense, transition) {
return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
}
function traverseStaticChildren(n1, n2, shallow = false) {
const ch1 = n1.children;
const ch2 = n2.children;
if (shared_esm_bundler_isArray(ch1) && shared_esm_bundler_isArray(ch2)) {
for (let i = 0; i < ch1.length; i++) {
const c1 = ch1[i];
let c2 = ch2[i];
if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
c2 = ch2[i] = cloneIfMounted(ch2[i]);
c2.el = c1.el;
}
if (!shallow && c2.patchFlag !== -2)
traverseStaticChildren(c1, c2);
}
if (c2.type === Text) {
c2.el = c1.el;
}
if (false) {}
}
}
}
function getSequence(arr) {
const p = arr.slice();
const result = [0];
let i, j, u, v, c;
const len = arr.length;
for (i = 0; i < len; i++) {
const arrI = arr[i];
if (arrI !== 0) {
j = result[result.length - 1];
if (arr[j] < arrI) {
p[i] = j;
result.push(i);
continue;
}
u = 0;
v = result.length - 1;
while (u < v) {
c = u + v >> 1;
if (arr[result[c]] < arrI) {
u = c + 1;
} else {
v = c;
}
}
if (arrI < arr[result[u]]) {
if (u > 0) {
p[i] = result[u - 1];
}
result[u] = i;
}
}
}
u = result.length;
v = result[u - 1];
while (u-- > 0) {
result[u] = v;
v = p[v];
}
return result;
}
function locateNonHydratedAsyncRoot(instance) {
const subComponent = instance.subTree.component;
if (subComponent) {
if (subComponent.asyncDep && !subComponent.asyncResolved) {
return subComponent;
} else {
return locateNonHydratedAsyncRoot(subComponent);
}
}
}
function invalidateMount(hooks) {
if (hooks) {
for (let i = 0; i < hooks.length; i++)
hooks[i].flags |= 8;
}
}
const ssrContextKey = Symbol.for("v-scx");
const useSSRContext = () => {
{
const ctx = runtime_core_esm_bundler_inject(ssrContextKey);
if (!ctx) {
false && 0;
}
return ctx;
}
};
function watchEffect(effect, options) {
return doWatch(effect, null, options);
}
function watchPostEffect(effect, options) {
return doWatch(
effect,
null,
false ? 0 : { flush: "post" }
);
}
function watchSyncEffect(effect, options) {
return doWatch(
effect,
null,
false ? 0 : { flush: "sync" }
);
}
function runtime_core_esm_bundler_watch(source, cb, options) {
if (false) {}
return doWatch(source, cb, options);
}
function doWatch(source, cb, options = EMPTY_OBJ) {
const { immediate, deep, flush, once } = options;
if (false) {}
const baseWatchOptions = shared_esm_bundler_extend({}, options);
if (false) {}
const runsImmediately = cb && immediate || !cb && flush !== "post";
let ssrCleanup;
if (isInSSRComponentSetup) {
if (flush === "sync") {
const ctx = useSSRContext();
ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
} else if (!runsImmediately) {
const watchStopHandle = () => {
};
watchStopHandle.stop = shared_esm_bundler_NOOP;
watchStopHandle.resume = shared_esm_bundler_NOOP;
watchStopHandle.pause = shared_esm_bundler_NOOP;
return watchStopHandle;
}
}
const instance = currentInstance;
baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
let isPre = false;
if (flush === "post") {
baseWatchOptions.scheduler = (job) => {
queuePostRenderEffect(job, instance && instance.suspense);
};
} else if (flush !== "sync") {
isPre = true;
baseWatchOptions.scheduler = (job, isFirstRun) => {
if (isFirstRun) {
job();
} else {
queueJob(job);
}
};
}
baseWatchOptions.augmentJob = (job) => {
if (cb) {
job.flags |= 4;
}
if (isPre) {
job.flags |= 2;
if (instance) {
job.id = instance.uid;
job.i = instance;
}
}
};
const watchHandle = reactivity_esm_bundler_watch(source, cb, baseWatchOptions);
if (isInSSRComponentSetup) {
if (ssrCleanup) {
ssrCleanup.push(watchHandle);
} else if (runsImmediately) {
watchHandle();
}
}
return watchHandle;
}
function instanceWatch(source, value, options) {
const publicThis = this.proxy;
const getter = shared_esm_bundler_isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
let cb;
if (shared_esm_bundler_isFunction(value)) {
cb = value;
} else {
cb = value.handler;
options = value;
}
const reset = setCurrentInstance(this);
const res = doWatch(getter, cb.bind(publicThis), options);
reset();
return res;
}
function createPathGetter(ctx, path) {
const segments = path.split(".");
return () => {
let cur = ctx;
for (let i = 0; i < segments.length && cur; i++) {
cur = cur[segments[i]];
}
return cur;
};
}
function useModel(props, name, options = EMPTY_OBJ) {
const i = runtime_core_esm_bundler_getCurrentInstance();
if (false) {}
const camelizedName = shared_esm_bundler_camelize(name);
if (false) {}
const hyphenatedName = hyphenate(name);
const modifiers = getModelModifiers(props, camelizedName);
const res = customRef((track, trigger) => {
let localValue;
let prevSetValue = EMPTY_OBJ;
let prevEmittedValue;
watchSyncEffect(() => {
const propValue = props[camelizedName];
if (hasChanged(localValue, propValue)) {
localValue = propValue;
trigger();
}
});
return {
get() {
track();
return options.get ? options.get(localValue) : localValue;
},
set(value) {
const emittedValue = options.set ? options.set(value) : value;
if (!hasChanged(emittedValue, localValue) && !(prevSetValue !== EMPTY_OBJ && hasChanged(value, prevSetValue))) {
return;
}
const rawProps = i.vnode.props;
if (!(rawProps && // check if parent has passed v-model
(name in rawProps || camelizedName in rawProps || hyphenatedName in rawProps) && (`onUpdate:${name}` in rawProps || `onUpdate:${camelizedName}` in rawProps || `onUpdate:${hyphenatedName}` in rawProps))) {
localValue = value;
trigger();
}
i.emit(`update:${name}`, emittedValue);
if (hasChanged(value, emittedValue) && hasChanged(value, prevSetValue) && !hasChanged(emittedValue, prevEmittedValue)) {
trigger();
}
prevSetValue = value;
prevEmittedValue = emittedValue;
}
};
});
res[Symbol.iterator] = () => {
let i2 = 0;
return {
next() {
if (i2 < 2) {
return { value: i2++ ? modifiers || EMPTY_OBJ : res, done: false };
} else {
return { done: true };
}
}
};
};
return res;
}
const getModelModifiers = (props, modelName) => {
return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${shared_esm_bundler_camelize(modelName)}Modifiers`] || props[`${hyphenate(modelName)}Modifiers`];
};
function emit(instance, event, ...rawArgs) {
if (instance.isUnmounted) return;
const props = instance.vnode.props || EMPTY_OBJ;
if (false) {}
let args = rawArgs;
const isModelListener = event.startsWith("update:");
const modifiers = isModelListener && getModelModifiers(props, event.slice(7));
if (modifiers) {
if (modifiers.trim) {
args = rawArgs.map((a) => shared_esm_bundler_isString(a) ? a.trim() : a);
}
if (modifiers.number) {
args = rawArgs.map(looseToNumber);
}
}
if (false) {}
if (false) {}
let handlerName;
let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
props[handlerName = toHandlerKey(shared_esm_bundler_camelize(event))];
if (!handler && isModelListener) {
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 ( true && !shared_esm_bundler_isFunction(comp)) {
const extendEmits = (raw2) => {
const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
if (normalizedFromExtend) {
hasExtends = true;
shared_esm_bundler_extend(normalized, normalizedFromExtend);
}
};
if (!asMixin && appContext.mixins.length) {
appContext.mixins.forEach(extendEmits);
}
if (comp.extends) {
extendEmits(comp.extends);
}
if (comp.mixins) {
comp.mixins.forEach(extendEmits);
}
}
if (!raw && !hasExtends) {
if (shared_esm_bundler_isObject(comp)) {
cache.set(comp, null);
}
return null;
}
if (shared_esm_bundler_isArray(raw)) {
raw.forEach((key) => normalized[key] = null);
} else {
shared_esm_bundler_extend(normalized, raw);
}
if (shared_esm_bundler_isObject(comp)) {
cache.set(comp, normalized);
}
return normalized;
}
function isEmitListener(options, key) {
if (!options || !isOn(key)) {
return false;
}
key = key.slice(2).replace(/Once$/, "");
return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
}
let accessedAttrs = false;
function markAttrsAccessed() {
accessedAttrs = true;
}
function renderComponentRoot(instance) {
const {
type: Component,
vnode,
proxy,
withProxy,
propsOptions: [propsOptions],
slots,
attrs,
emit,
render,
renderCache,
props,
data,
setupState,
ctx,
inheritAttrs
} = instance;
const prev = setCurrentRenderingInstance(instance);
let result;
let fallthroughAttrs;
if (false) {}
try {
if (vnode.shapeFlag & 4) {
const proxyToUse = withProxy || proxy;
const thisProxy = false ? 0 : proxyToUse;
result = normalizeVNode(
render.call(
thisProxy,
proxyToUse,
renderCache,
false ? 0 : props,
setupState,
data,
ctx
)
);
fallthroughAttrs = attrs;
} else {
const render2 = Component;
if (false) {}
result = normalizeVNode(
render2.length > 1 ? render2(
false ? 0 : props,
false ? 0 : { attrs, slots, emit }
) : render2(
false ? 0 : props,
null
)
);
fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
}
} catch (err) {
blockStack.length = 0;
handleError(err, instance, 1);
result = createVNode(Comment);
}
let root = result;
let setRoot = void 0;
if (false) {}
if (fallthroughAttrs && inheritAttrs !== false) {
const keys = Object.keys(fallthroughAttrs);
const { shapeFlag } = root;
if (keys.length) {
if (shapeFlag & (1 | 6)) {
if (propsOptions && keys.some(isModelListener)) {
fallthroughAttrs = filterModelListeners(
fallthroughAttrs,
propsOptions
);
}
root = cloneVNode(root, fallthroughAttrs, false, true);
} else if (false) {}
}
}
if (vnode.dirs) {
if (false) {}
root = cloneVNode(root, null, false, true);
root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
}
if (vnode.transition) {
if (false) {}
setTransitionHooks(root, vnode.transition);
}
if (false) {} else {
result = root;
}
setCurrentRenderingInstance(prev);
return result;
}
const getChildRoot = (vnode) => {
const rawChildren = vnode.children;
const dynamicChildren = vnode.dynamicChildren;
const childRoot = filterSingleRoot(rawChildren, false);
if (!childRoot) {
return [vnode, void 0];
} else if (false) {}
const index = rawChildren.indexOf(childRoot);
const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
const setRoot = (updatedRoot) => {
rawChildren[index] = updatedRoot;
if (dynamicChildren) {
if (dynamicIndex > -1) {
dynamicChildren[dynamicIndex] = updatedRoot;
} else if (updatedRoot.patchFlag > 0) {
vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
}
}
};
return [normalizeVNode(childRoot), setRoot];
};
function filterSingleRoot(children, recurse = true) {
let singleRoot;
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (isVNode(child)) {
if (child.type !== Comment || child.children === "v-if") {
if (singleRoot) {
return;
} else {
singleRoot = child;
if (false) {}
}
}
} else {
return;
}
}
return singleRoot;
}
const getFunctionalFallthrough = (attrs) => {
let res;
for (const key in attrs) {
if (key === "class" || key === "style" || isOn(key)) {
(res || (res = {}))[key] = attrs[key];
}
}
return res;
};
const filterModelListeners = (attrs, props) => {
const res = {};
for (const key in attrs) {
if (!isModelListener(key) || !(key.slice(9) in props)) {
res[key] = attrs[key];
}
}
return res;
};
const isElementRoot = (vnode) => {
return vnode.shapeFlag & (6 | 1) || vnode.type === Comment;
};
function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
const { props: prevProps, children: prevChildren, component } = prevVNode;
const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
const emits = component.emitsOptions;
if (false) {}
if (nextVNode.dirs || nextVNode.transition) {
return true;
}
if (optimized && patchFlag >= 0) {
if (patchFlag & 1024) {
return true;
}
if (patchFlag & 16) {
if (!prevProps) {
return !!nextProps;
}
return hasPropsChanged(prevProps, nextProps, emits);
} else if (patchFlag & 8) {
const dynamicProps = nextVNode.dynamicProps;
for (let i = 0; i < dynamicProps.length; i++) {
const key = dynamicProps[i];
if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
return true;
}
}
}
} else {
if (prevChildren || nextChildren) {
if (!nextChildren || !nextChildren.$stable) {
return true;
}
}
if (prevProps === nextProps) {
return false;
}
if (!prevProps) {
return !!nextProps;
}
if (!nextProps) {
return true;
}
return hasPropsChanged(prevProps, nextProps, emits);
}
return false;
}
function hasPropsChanged(prevProps, nextProps, emitsOptions) {
const nextKeys = Object.keys(nextProps);
if (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] && !isEmitListener(emitsOptions, key)) {
return true;
}
}
return false;
}
function updateHOCHostEl({ vnode, parent }, el) {
while (parent) {
const root = parent.subTree;
if (root.suspense && root.suspense.activeBranch === vnode) {
root.el = vnode.el;
}
if (root === vnode) {
(vnode = parent.vnode).el = el;
parent = parent.parent;
} else {
break;
}
}
}
const isSuspense = (type) => type.__isSuspense;
let suspenseId = 0;
const SuspenseImpl = {
name: "Suspense",
// In order to make Suspense tree-shakable, we need to avoid importing it
// directly in the renderer. The renderer checks for the __isSuspense flag
// on a vnode's type and calls the `process` method, passing in renderer
// internals.
__isSuspense: true,
process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
if (n1 == null) {
mountSuspense(
n2,
container,
anchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
optimized,
rendererInternals
);
} else {
if (parentSuspense && parentSuspense.deps > 0 && !n1.suspense.isInFallback) {
n2.suspense = n1.suspense;
n2.suspense.vnode = n2;
n2.el = n1.el;
return;
}
patchSuspense(
n1,
n2,
container,
anchor,
parentComponent,
namespace,
slotScopeIds,
optimized,
rendererInternals
);
}
},
hydrate: hydrateSuspense,
normalize: normalizeSuspenseChildren
};
const Suspense = SuspenseImpl ;
function triggerEvent(vnode, name) {
const eventListener = vnode.props && vnode.props[name];
if (shared_esm_bundler_isFunction(eventListener)) {
eventListener();
}
}
function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
const {
p: patch,
o: { createElement }
} = rendererInternals;
const hiddenContainer = createElement("div");
const suspense = vnode.suspense = createSuspenseBoundary(
vnode,
parentSuspense,
parentComponent,
container,
hiddenContainer,
anchor,
namespace,
slotScopeIds,
optimized,
rendererInternals
);
patch(
null,
suspense.pendingBranch = vnode.ssContent,
hiddenContainer,
null,
parentComponent,
suspense,
namespace,
slotScopeIds
);
if (suspense.deps > 0) {
triggerEvent(vnode, "onPending");
triggerEvent(vnode, "onFallback");
patch(
null,
vnode.ssFallback,
container,
anchor,
parentComponent,
null,
// fallback tree will not have suspense context
namespace,
slotScopeIds
);
setActiveBranch(suspense, vnode.ssFallback);
} else {
suspense.resolve(false, true);
}
}
function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
const suspense = n2.suspense = n1.suspense;
suspense.vnode = n2;
n2.el = n1.el;
const newBranch = n2.ssContent;
const newFallback = n2.ssFallback;
const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
if (pendingBranch) {
suspense.pendingBranch = newBranch;
if (isSameVNodeType(newBranch, pendingBranch)) {
patch(
pendingBranch,
newBranch,
suspense.hiddenContainer,
null,
parentComponent,
suspense,
namespace,
slotScopeIds,
optimized
);
if (suspense.deps <= 0) {
suspense.resolve();
} else if (isInFallback) {
if (!isHydrating) {
patch(
activeBranch,
newFallback,
container,
anchor,
parentComponent,
null,
// fallback tree will not have suspense context
namespace,
slotScopeIds,
optimized
);
setActiveBranch(suspense, newFallback);
}
}
} else {
suspense.pendingId = suspenseId++;
if (isHydrating) {
suspense.isHydrating = false;
suspense.activeBranch = pendingBranch;
} else {
unmount(pendingBranch, parentComponent, suspense);
}
suspense.deps = 0;
suspense.effects.length = 0;
suspense.hiddenContainer = createElement("div");
if (isInFallback) {
patch(
null,
newBranch,
suspense.hiddenContainer,
null,
parentComponent,
suspense,
namespace,
slotScopeIds,
optimized
);
if (suspense.deps <= 0) {
suspense.resolve();
} else {
patch(
activeBranch,
newFallback,
container,
anchor,
parentComponent,
null,
// fallback tree will not have suspense context
namespace,
slotScopeIds,
optimized
);
setActiveBranch(suspense, newFallback);
}
} else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
patch(
activeBranch,
newBranch,
container,
anchor,
parentComponent,
suspense,
namespace,
slotScopeIds,
optimized
);
suspense.resolve(true);
} else {
patch(
null,
newBranch,
suspense.hiddenContainer,
null,
parentComponent,
suspense,
namespace,
slotScopeIds,
optimized
);
if (suspense.deps <= 0) {
suspense.resolve();
}
}
}
} else {
if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
patch(
activeBranch,
newBranch,
container,
anchor,
parentComponent,
suspense,
namespace,
slotScopeIds,
optimized
);
setActiveBranch(suspense, newBranch);
} else {
triggerEvent(n2, "onPending");
suspense.pendingBranch = newBranch;
if (newBranch.shapeFlag & 512) {
suspense.pendingId = newBranch.component.suspenseId;
} else {
suspense.pendingId = suspenseId++;
}
patch(
null,
newBranch,
suspense.hiddenContainer,
null,
parentComponent,
suspense,
namespace,
slotScopeIds,
optimized
);
if (suspense.deps <= 0) {
suspense.resolve();
} else {
const { timeout, pendingId } = suspense;
if (timeout > 0) {
setTimeout(() => {
if (suspense.pendingId === pendingId) {
suspense.fallback(newFallback);
}
}, timeout);
} else if (timeout === 0) {
suspense.fallback(newFallback);
}
}
}
}
}
let hasWarned = false;
function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, namespace, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
if (false) {}
const {
p: patch,
m: move,
um: unmount,
n: next,
o: { parentNode, remove }
} = rendererInternals;
let parentSuspenseId;
const isSuspensible = isVNodeSuspensible(vnode);
if (isSuspensible) {
if (parentSuspense && parentSuspense.pendingBranch) {
parentSuspenseId = parentSuspense.pendingId;
parentSuspense.deps++;
}
}
const timeout = vnode.props ? toNumber(vnode.props.timeout) : void 0;
if (false) {}
const initialAnchor = anchor;
const suspense = {
vnode,
parent: parentSuspense,
parentComponent,
namespace,
container,
hiddenContainer,
deps: 0,
pendingId: suspenseId++,
timeout: typeof timeout === "number" ? timeout : -1,
activeBranch: null,
pendingBranch: null,
isInFallback: !isHydrating,
isHydrating,
isUnmounted: false,
effects: [],
resolve(resume = false, sync = false) {
if (false) {}
const {
vnode: vnode2,
activeBranch,
pendingBranch,
pendingId,
effects,
parentComponent: parentComponent2,
container: container2
} = suspense;
let delayEnter = false;
if (suspense.isHydrating) {
suspense.isHydrating = false;
} else if (!resume) {
delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
if (delayEnter) {
activeBranch.transition.afterLeave = () => {
if (pendingId === suspense.pendingId) {
move(
pendingBranch,
container2,
anchor === initialAnchor ? next(activeBranch) : anchor,
0
);
queuePostFlushCb(effects);
}
};
}
if (activeBranch) {
if (parentNode(activeBranch.el) === container2) {
anchor = next(activeBranch);
}
unmount(activeBranch, parentComponent2, suspense, true);
}
if (!delayEnter) {
move(pendingBranch, container2, anchor, 0);
}
}
setActiveBranch(suspense, pendingBranch);
suspense.pendingBranch = null;
suspense.isInFallback = false;
let parent = suspense.parent;
let hasUnresolvedAncestor = false;
while (parent) {
if (parent.pendingBranch) {
parent.effects.push(...effects);
hasUnresolvedAncestor = true;
break;
}
parent = parent.parent;
}
if (!hasUnresolvedAncestor && !delayEnter) {
queuePostFlushCb(effects);
}
suspense.effects = [];
if (isSuspensible) {
if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
parentSuspense.deps--;
if (parentSuspense.deps === 0 && !sync) {
parentSuspense.resolve();
}
}
}
triggerEvent(vnode2, "onResolve");
},
fallback(fallbackVNode) {
if (!suspense.pendingBranch) {
return;
}
const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, namespace: namespace2 } = suspense;
triggerEvent(vnode2, "onFallback");
const anchor2 = next(activeBranch);
const mountFallback = () => {
if (!suspense.isInFallback) {
return;
}
patch(
null,
fallbackVNode,
container2,
anchor2,
parentComponent2,
null,
// fallback tree will not have suspense context
namespace2,
slotScopeIds,
optimized
);
setActiveBranch(suspense, fallbackVNode);
};
const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
if (delayEnter) {
activeBranch.transition.afterLeave = mountFallback;
}
suspense.isInFallback = true;
unmount(
activeBranch,
parentComponent2,
null,
// no suspense so unmount hooks fire now
true
// shouldRemove
);
if (!delayEnter) {
mountFallback();
}
},
move(container2, anchor2, type) {
suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
suspense.container = container2;
},
next() {
return suspense.activeBranch && next(suspense.activeBranch);
},
registerDep(instance, setupRenderEffect, optimized2) {
const isInPendingSuspense = !!suspense.pendingBranch;
if (isInPendingSuspense) {
suspense.deps++;
}
const hydratedEl = instance.vnode.el;
instance.asyncDep.catch((err) => {
handleError(err, instance, 0);
}).then((asyncSetupResult) => {
if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
return;
}
instance.asyncResolved = true;
const { vnode: vnode2 } = instance;
if (false) {}
handleSetupResult(instance, asyncSetupResult, false);
if (hydratedEl) {
vnode2.el = hydratedEl;
}
const placeholder = !hydratedEl && instance.subTree.el;
setupRenderEffect(
instance,
vnode2,
// component may have been moved before resolve.
// if this is not a hydration, instance.subTree will be the comment
// placeholder.
parentNode(hydratedEl || instance.subTree.el),
// anchor will not be used if this is hydration, so only need to
// consider the comment placeholder case.
hydratedEl ? null : next(instance.subTree),
suspense,
namespace,
optimized2
);
if (placeholder) {
remove(placeholder);
}
updateHOCHostEl(instance, vnode2.el);
if (false) {}
if (isInPendingSuspense && --suspense.deps === 0) {
suspense.resolve();
}
});
},
unmount(parentSuspense2, doRemove) {
suspense.isUnmounted = true;
if (suspense.activeBranch) {
unmount(
suspense.activeBranch,
parentComponent,
parentSuspense2,
doRemove
);
}
if (suspense.pendingBranch) {
unmount(
suspense.pendingBranch,
parentComponent,
parentSuspense2,
doRemove
);
}
}
};
return suspense;
}
function hydrateSuspense(node, vnode, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals, hydrateNode) {
const suspense = vnode.suspense = createSuspenseBoundary(
vnode,
parentSuspense,
parentComponent,
node.parentNode,
// eslint-disable-next-line no-restricted-globals
document.createElement("div"),
null,
namespace,
slotScopeIds,
optimized,
rendererInternals,
true
);
const result = hydrateNode(
node,
suspense.pendingBranch = vnode.ssContent,
parentComponent,
suspense,
slotScopeIds,
optimized
);
if (suspense.deps === 0) {
suspense.resolve(false, true);
}
return result;
}
function normalizeSuspenseChildren(vnode) {
const { shapeFlag, children } = vnode;
const isSlotChildren = shapeFlag & 32;
vnode.ssContent = normalizeSuspenseSlot(
isSlotChildren ? children.default : children
);
vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
}
function normalizeSuspenseSlot(s) {
let block;
if (shared_esm_bundler_isFunction(s)) {
const trackBlock = isBlockTreeEnabled && s._c;
if (trackBlock) {
s._d = false;
openBlock();
}
s = s();
if (trackBlock) {
s._d = true;
block = currentBlock;
closeBlock();
}
}
if (shared_esm_bundler_isArray(s)) {
const singleChild = filterSingleRoot(s);
if (false) {}
s = singleChild;
}
s = normalizeVNode(s);
if (block && !s.dynamicChildren) {
s.dynamicChildren = block.filter((c) => c !== s);
}
return s;
}
function queueEffectWithSuspense(fn, suspense) {
if (suspense && suspense.pendingBranch) {
if (shared_esm_bundler_isArray(fn)) {
suspense.effects.push(...fn);
} else {
suspense.effects.push(fn);
}
} else {
queuePostFlushCb(fn);
}
}
function setActiveBranch(suspense, branch) {
suspense.activeBranch = branch;
const { vnode, parentComponent } = suspense;
let el = branch.el;
while (!el && branch.component) {
branch = branch.component.subTree;
el = branch.el;
}
vnode.el = el;
if (parentComponent && parentComponent.subTree === vnode) {
parentComponent.vnode.el = el;
updateHOCHostEl(parentComponent, el);
}
}
function isVNodeSuspensible(vnode) {
const suspensible = vnode.props && vnode.props.suspensible;
return suspensible != null && suspensible !== false;
}
const Fragment = Symbol.for("v-fgt");
const Text = Symbol.for("v-txt");
const Comment = Symbol.for("v-cmt");
const Static = Symbol.for("v-stc");
const blockStack = [];
let currentBlock = null;
function openBlock(disableTracking = false) {
blockStack.push(currentBlock = disableTracking ? null : []);
}
function closeBlock() {
blockStack.pop();
currentBlock = blockStack[blockStack.length - 1] || null;
}
let isBlockTreeEnabled = 1;
function setBlockTracking(value, inVOnce = false) {
isBlockTreeEnabled += value;
if (value < 0 && currentBlock && inVOnce) {
currentBlock.hasOnce = true;
}
}
function setupBlock(vnode) {
vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;
closeBlock();
if (isBlockTreeEnabled > 0 && currentBlock) {
currentBlock.push(vnode);
}
return vnode;
}
function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
return setupBlock(
createBaseVNode(
type,
props,
children,
patchFlag,
dynamicProps,
shapeFlag,
true
)
);
}
function createBlock(type, props, children, patchFlag, dynamicProps) {
return setupBlock(
createVNode(
type,
props,
children,
patchFlag,
dynamicProps,
true
)
);
}
function isVNode(value) {
return value ? value.__v_isVNode === true : false;
}
function isSameVNodeType(n1, n2) {
if (false) {}
return n1.type === n2.type && n1.key === n2.key;
}
let vnodeArgsTransformer;
function transformVNodeArgs(transformer) {
vnodeArgsTransformer = transformer;
}
const createVNodeWithArgsTransform = (...args) => {
return _createVNode(
...vnodeArgsTransformer ? vnodeArgsTransformer(args, currentRenderingInstance) : args
);
};
const normalizeKey = ({ key }) => key != null ? key : null;
const normalizeRef = ({
ref,
ref_key,
ref_for
}) => {
if (typeof ref === "number") {
ref = "" + ref;
}
return ref != null ? shared_esm_bundler_isString(ref) || reactivity_esm_bundler_isRef(ref) || shared_esm_bundler_isFunction(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
};
function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
const vnode = {
__v_isVNode: true,
__v_skip: true,
type,
props,
key: props && normalizeKey(props),
ref: props && normalizeRef(props),
scopeId: currentScopeId,
slotScopeIds: null,
children,
component: null,
suspense: null,
ssContent: null,
ssFallback: null,
dirs: null,
transition: null,
el: null,
anchor: null,
target: null,
targetStart: null,
targetAnchor: null,
staticCount: 0,
shapeFlag,
patchFlag,
dynamicProps,
dynamicChildren: null,
appContext: null,
ctx: currentRenderingInstance
};
if (needFullChildrenNormalization) {
normalizeChildren(vnode, children);
if (shapeFlag & 128) {
type.normalize(vnode);
}
} else if (children) {
vnode.shapeFlag |= shared_esm_bundler_isString(children) ? 8 : 16;
}
if (false) {}
if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself
!isBlockNode && // has current parent block
currentBlock && // presence of a patch flag indicates this node needs patching on updates.
// component nodes also should always be patched, because even if the
// component doesn't need to update, it needs to persist the instance on to
// the next vnode so that it can be properly unmounted later.
(vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
// vnode should not be considered dynamic due to handler caching.
vnode.patchFlag !== 32) {
currentBlock.push(vnode);
}
return vnode;
}
const createVNode = false ? 0 : _createVNode;
function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
if (!type || type === NULL_DYNAMIC_COMPONENT) {
if (false) {}
type = Comment;
}
if (isVNode(type)) {
const cloned = cloneVNode(
type,
props,
true
/* mergeRef: true */
);
if (children) {
normalizeChildren(cloned, children);
}
if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
if (cloned.shapeFlag & 6) {
currentBlock[currentBlock.indexOf(type)] = cloned;
} else {
currentBlock.push(cloned);
}
}
cloned.patchFlag = -2;
return cloned;
}
if (isClassComponent(type)) {
type = type.__vccOpts;
}
if (props) {
props = guardReactiveProps(props);
let { class: klass, style } = props;
if (klass && !shared_esm_bundler_isString(klass)) {
props.class = shared_esm_bundler_normalizeClass(klass);
}
if (shared_esm_bundler_isObject(style)) {
if (isProxy(style) && !shared_esm_bundler_isArray(style)) {
style = shared_esm_bundler_extend({}, style);
}
props.style = shared_esm_bundler_normalizeStyle(style);
}
}
const shapeFlag = shared_esm_bundler_isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : shared_esm_bundler_isObject(type) ? 4 : shared_esm_bundler_isFunction(type) ? 2 : 0;
if (false) {}
return createBaseVNode(
type,
props,
children,
patchFlag,
dynamicProps,
shapeFlag,
isBlockNode,
true
);
}
function guardReactiveProps(props) {
if (!props) return null;
return isProxy(props) || isInternalObject(props) ? shared_esm_bundler_extend({}, props) : props;
}
function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
const { props, ref, patchFlag, children, transition } = vnode;
const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
const cloned = {
__v_isVNode: true,
__v_skip: true,
type: vnode.type,
props: mergedProps,
key: mergedProps && normalizeKey(mergedProps),
ref: extraProps && extraProps.ref ? (
// #2078 in the case of <component :is="vnode" ref="extra"/>
// if the vnode itself already has a ref, cloneVNode will need to merge
// the refs so the single vnode can be set on multiple refs
mergeRef && ref ? shared_esm_bundler_isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps)
) : ref,
scopeId: vnode.scopeId,
slotScopeIds: vnode.slotScopeIds,
children: false ? 0 : children,
target: vnode.target,
targetStart: vnode.targetStart,
targetAnchor: vnode.targetAnchor,
staticCount: vnode.staticCount,
shapeFlag: vnode.shapeFlag,
// if the vnode is cloned with extra props, we can no longer assume its
// existing patch flag to be reliable and need to add the FULL_PROPS flag.
// note: preserve flag for fragments since they use the flag for children
// fast paths only.
patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
dynamicProps: vnode.dynamicProps,
dynamicChildren: vnode.dynamicChildren,
appContext: vnode.appContext,
dirs: vnode.dirs,
transition,
// These should technically only be non-null on mounted VNodes. However,
// they *should* be copied for kept-alive vnodes. So we just always copy
// them since them being non-null during a mount doesn't affect the logic as
// they will simply be overwritten.
component: vnode.component,
suspense: vnode.suspense,
ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
el: vnode.el,
anchor: vnode.anchor,
ctx: vnode.ctx,
ce: vnode.ce
};
if (transition && cloneTransition) {
setTransitionHooks(
cloned,
transition.clone(cloned)
);
}
return cloned;
}
function deepCloneVNode(vnode) {
const cloned = cloneVNode(vnode);
if (isArray(vnode.children)) {
cloned.children = vnode.children.map(deepCloneVNode);
}
return cloned;
}
function createTextVNode(text = " ", flag = 0) {
return createVNode(Text, null, text, flag);
}
function createStaticVNode(content, numberOfNodes) {
const vnode = createVNode(Static, null, content);
vnode.staticCount = numberOfNodes;
return vnode;
}
function createCommentVNode(text = "", asBlock = false) {
return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
}
function normalizeVNode(child) {
if (child == null || typeof child === "boolean") {
return createVNode(Comment);
} else if (shared_esm_bundler_isArray(child)) {
return createVNode(
Fragment,
null,
// #3666, avoid reference pollution when reusing vnode
child.slice()
);
} else if (isVNode(child)) {
return cloneIfMounted(child);
} else {
return createVNode(Text, null, String(child));
}
}
function cloneIfMounted(child) {
return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
}
function normalizeChildren(vnode, children) {
let type = 0;
const { shapeFlag } = vnode;
if (children == null) {
children = null;
} else if (shared_esm_bundler_isArray(children)) {
type = 16;
} else if (typeof children === "object") {
if (shapeFlag & (1 | 64)) {
const slot = children.default;
if (slot) {
slot._c && (slot._d = false);
normalizeChildren(vnode, slot());
slot._c && (slot._d = true);
}
return;
} else {
type = 32;
const slotFlag = children._;
if (!slotFlag && !isInternalObject(children)) {
children._ctx = currentRenderingInstance;
} else if (slotFlag === 3 && currentRenderingInstance) {
if (currentRenderingInstance.slots._ === 1) {
children._ = 1;
} else {
children._ = 2;
vnode.patchFlag |= 1024;
}
}
}
} else if (shared_esm_bundler_isFunction(children)) {
children = { default: children, _ctx: currentRenderingInstance };
type = 32;
} else {
children = String(children);
if (shapeFlag & 64) {
type = 16;
children = [createTextVNode(children)];
} else {
type = 8;
}
}
vnode.children = children;
vnode.shapeFlag |= type;
}
function mergeProps(...args) {
const ret = {};
for (let i = 0; i < args.length; i++) {
const toMerge = args[i];
for (const key in toMerge) {
if (key === "class") {
if (ret.class !== toMerge.class) {
ret.class = shared_esm_bundler_normalizeClass([ret.class, toMerge.class]);
}
} else if (key === "style") {
ret.style = shared_esm_bundler_normalizeStyle([ret.style, toMerge.style]);
} else if (isOn(key)) {
const existing = ret[key];
const incoming = toMerge[key];
if (incoming && existing !== incoming && !(shared_esm_bundler_isArray(existing) && existing.includes(incoming))) {
ret[key] = existing ? [].concat(existing, incoming) : incoming;
}
} else if (key !== "") {
ret[key] = toMerge[key];
}
}
}
return ret;
}
function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
callWithAsyncErrorHandling(hook, instance, 7, [
vnode,
prevVNode
]);
}
const emptyAppContext = createAppContext();
let uid = 0;
function createComponentInstance(vnode, parent, suspense) {
const type = vnode.type;
const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
const instance = {
uid: uid++,
vnode,
type,
parent,
appContext,
root: null,
// to be immediately set
next: null,
subTree: null,
// will be set synchronously right after creation
effect: null,
update: null,
// will be set synchronously right after creation
job: null,
scope: new EffectScope(
true
/* detached */
),
render: null,
proxy: null,
exposed: null,
exposeProxy: null,
withProxy: null,
provides: parent ? parent.provides : Object.create(appContext.provides),
ids: parent ? parent.ids : ["", 0, 0],
accessCache: null,
renderCache: [],
// local resolved assets
components: null,
directives: null,
// resolved props and emits options
propsOptions: normalizePropsOptions(type, appContext),
emitsOptions: normalizeEmitsOptions(type, appContext),
// emit
emit: null,
// to be set immediately
emitted: null,
// props default value
propsDefaults: EMPTY_OBJ,
// inheritAttrs
inheritAttrs: type.inheritAttrs,
// state
ctx: EMPTY_OBJ,
data: EMPTY_OBJ,
props: EMPTY_OBJ,
attrs: EMPTY_OBJ,
slots: EMPTY_OBJ,
refs: EMPTY_OBJ,
setupState: EMPTY_OBJ,
setupContext: null,
// suspense related
suspense,
suspenseId: suspense ? suspense.pendingId : 0,
asyncDep: null,
asyncResolved: false,
// lifecycle hooks
// not using enums here because it results in computed properties
isMounted: false,
isUnmounted: false,
isDeactivated: false,
bc: null,
c: null,
bm: null,
m: null,
bu: null,
u: null,
um: null,
bum: null,
da: null,
a: null,
rtg: null,
rtc: null,
ec: null,
sp: null
};
if (false) {} else {
instance.ctx = { _: instance };
}
instance.root = parent ? parent.root : instance;
instance.emit = emit.bind(null, instance);
if (vnode.ce) {
vnode.ce(instance);
}
return instance;
}
let currentInstance = null;
const runtime_core_esm_bundler_getCurrentInstance = () => currentInstance || currentRenderingInstance;
let internalSetCurrentInstance;
let setInSSRSetupState;
{
const g = getGlobalThis();
const registerGlobalSetter = (key, setter) => {
let setters;
if (!(setters = g[key])) setters = g[key] = [];
setters.push(setter);
return (v) => {
if (setters.length > 1) setters.forEach((set) => set(v));
else setters[0](v);
};
};
internalSetCurrentInstance = registerGlobalSetter(
`__VUE_INSTANCE_SETTERS__`,
(v) => currentInstance = v
);
setInSSRSetupState = registerGlobalSetter(
`__VUE_SSR_SETTERS__`,
(v) => isInSSRComponentSetup = v
);
}
const setCurrentInstance = (instance) => {
const prev = currentInstance;
internalSetCurrentInstance(instance);
instance.scope.on();
return () => {
instance.scope.off();
internalSetCurrentInstance(prev);
};
};
const unsetCurrentInstance = () => {
currentInstance && currentInstance.scope.off();
internalSetCurrentInstance(null);
};
const isBuiltInTag = /* @__PURE__ */ (/* unused pure expression or super */ null && (makeMap("slot,component")));
function validateComponentName(name, { isNativeTag }) {
if (isBuiltInTag(name) || isNativeTag(name)) {
warn$1(
"Do not use built-in or reserved HTML elements as component id: " + name
);
}
}
function isStatefulComponent(instance) {
return instance.vnode.shapeFlag & 4;
}
let isInSSRComponentSetup = false;
function setupComponent(instance, isSSR = false, optimized = false) {
isSSR && setInSSRSetupState(isSSR);
const { props, children } = instance.vnode;
const isStateful = isStatefulComponent(instance);
initProps(instance, props, isStateful, isSSR);
initSlots(instance, children, optimized);
const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
isSSR && setInSSRSetupState(false);
return setupResult;
}
function setupStatefulComponent(instance, isSSR) {
var _a;
const Component = instance.type;
if (false) {}
instance.accessCache = /* @__PURE__ */ Object.create(null);
instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
if (false) {}
const { setup } = Component;
if (setup) {
reactivity_esm_bundler_pauseTracking();
const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
const reset = setCurrentInstance(instance);
const setupResult = callWithErrorHandling(
setup,
instance,
0,
[
false ? 0 : instance.props,
setupContext
]
);
const isAsyncSetup = isPromise(setupResult);
reactivity_esm_bundler_resetTracking();
reset();
if ((isAsyncSetup || instance.sp) && !isAsyncWrapper(instance)) {
markAsyncBoundary(instance);
}
if (isAsyncSetup) {
setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
if (isSSR) {
return setupResult.then((resolvedResult) => {
handleSetupResult(instance, resolvedResult, isSSR);
}).catch((e) => {
handleError(e, instance, 0);
});
} else {
instance.asyncDep = setupResult;
if (false) {}
}
} else {
handleSetupResult(instance, setupResult, isSSR);
}
} else {
finishComponentSetup(instance, isSSR);
}
}
function handleSetupResult(instance, setupResult, isSSR) {
if (shared_esm_bundler_isFunction(setupResult)) {
if (instance.type.__ssrInlineRender) {
instance.ssrRender = setupResult;
} else {
instance.render = setupResult;
}
} else if (shared_esm_bundler_isObject(setupResult)) {
if (false) {}
if (false) {}
instance.setupState = proxyRefs(setupResult);
if (false) {}
} else if (false) {}
finishComponentSetup(instance, isSSR);
}
let compile;
let installWithProxy;
function registerRuntimeCompiler(_compile) {
compile = _compile;
installWithProxy = (i) => {
if (i.render._rc) {
i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
}
};
}
const runtime_core_esm_bundler_isRuntimeOnly = () => !compile;
function finishComponentSetup(instance, isSSR, skipOptions) {
const Component = instance.type;
if (!instance.render) {
if (!isSSR && compile && !Component.render) {
const template = Component.template || true && resolveMergedOptions(instance).template;
if (template) {
if (false) {}
const { isCustomElement, compilerOptions } = instance.appContext.config;
const { delimiters, compilerOptions: componentCompilerOptions } = Component;
const finalCompilerOptions = shared_esm_bundler_extend(
shared_esm_bundler_extend(
{
isCustomElement,
delimiters
},
compilerOptions
),
componentCompilerOptions
);
Component.render = compile(template, finalCompilerOptions);
if (false) {}
}
}
instance.render = Component.render || shared_esm_bundler_NOOP;
if (installWithProxy) {
installWithProxy(instance);
}
}
if (true) {
const reset = setCurrentInstance(instance);
reactivity_esm_bundler_pauseTracking();
try {
applyOptions(instance);
} finally {
reactivity_esm_bundler_resetTracking();
reset();
}
}
if (false) {}
}
const attrsProxyHandlers = false ? 0 : {
get(target, key) {
reactivity_esm_bundler_track(target, "get", "");
return target[key];
}
};
function getSlotsProxy(instance) {
return new Proxy(instance.slots, {
get(target, key) {
track(instance, "get", "$slots");
return target[key];
}
});
}
function createSetupContext(instance) {
const expose = (exposed) => {
if (false) {}
instance.exposed = exposed || {};
};
if (false) {} else {
return {
attrs: new Proxy(instance.attrs, attrsProxyHandlers),
slots: instance.slots,
emit: instance.emit,
expose
};
}
}
function getComponentPublicInstance(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];
} else if (key in publicPropertiesMap) {
return publicPropertiesMap[key](instance);
}
},
has(target, key) {
return key in target || key in publicPropertiesMap;
}
}));
} else {
return instance.proxy;
}
}
const classifyRE = /(?:^|[-_])(\w)/g;
const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
function getComponentName(Component, includeInferred = true) {
return shared_esm_bundler_isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
}
function formatComponentName(instance, Component, isRoot = false) {
let name = getComponentName(Component);
if (!name && Component.__file) {
const match = Component.__file.match(/([^/\\]+)\.\w+$/);
if (match) {
name = match[1];
}
}
if (!name && instance && instance.parent) {
const inferFromRegistry = (registry) => {
for (const key in registry) {
if (registry[key] === Component) {
return key;
}
}
};
name = inferFromRegistry(
instance.components || instance.parent.type.components
) || inferFromRegistry(instance.appContext.components);
}
return name ? classify(name) : isRoot ? `App` : `Anonymous`;
}
function isClassComponent(value) {
return shared_esm_bundler_isFunction(value) && "__vccOpts" in value;
}
const runtime_core_esm_bundler_computed = (getterOrOptions, debugOptions) => {
const c = computed(getterOrOptions, debugOptions, isInSSRComponentSetup);
if (false) {}
return c;
};
function h(type, propsOrChildren, children) {
const l = arguments.length;
if (l === 2) {
if (shared_esm_bundler_isObject(propsOrChildren) && !shared_esm_bundler_isArray(propsOrChildren)) {
if (isVNode(propsOrChildren)) {
return createVNode(type, null, [propsOrChildren]);
}
return createVNode(type, propsOrChildren);
} else {
return createVNode(type, null, propsOrChildren);
}
} else {
if (l > 3) {
children = Array.prototype.slice.call(arguments, 2);
} else if (l === 3 && isVNode(children)) {
children = [children];
}
return createVNode(type, propsOrChildren, children);
}
}
function runtime_core_esm_bundler_initCustomFormatter() {
if (true) {
return;
}
const vueStyle = { style: "color:#3ba776" };
const numberStyle = { style: "color:#1677ff" };
const stringStyle = { style: "color:#f5222d" };
const keywordStyle = { style: "color:#eb2f96" };
const formatter = {
__vue_custom_formatter: true,
header(obj) {
if (!isObject(obj)) {
return null;
}
if (obj.__isVue) {
return ["div", vueStyle, `VueInstance`];
} else if (isRef(obj)) {
return [
"div",
{},
["span", vueStyle, genRefFlag(obj)],
"<",
// avoid debugger accessing value affecting behavior
formatValue("_value" in obj ? obj._value : obj),
`>`
];
} else if (isReactive(obj)) {
return [
"div",
{},
["span", vueStyle, isShallow(obj) ? "ShallowReactive" : "Reactive"],
"<",
formatValue(obj),
`>${isReadonly(obj) ? ` (readonly)` : ``}`
];
} else if (isReadonly(obj)) {
return [
"div",
{},
["span", vueStyle, isShallow(obj) ? "ShallowReadonly" : "Readonly"],
"<",
formatValue(obj),
">"
];
}
return null;
},
hasBody(obj) {
return obj && obj.__isVue;
},
body(obj) {
if (obj && obj.__isVue) {
return [
"div",
{},
...formatInstance(obj.$)
];
}
}
};
function formatInstance(instance) {
const blocks = [];
if (instance.type.props && instance.props) {
blocks.push(createInstanceBlock("props", reactivity_esm_bundler_toRaw(instance.props)));
}
if (instance.setupState !== EMPTY_OBJ) {
blocks.push(createInstanceBlock("setup", instance.setupState));
}
if (instance.data !== EMPTY_OBJ) {
blocks.push(createInstanceBlock("data", reactivity_esm_bundler_toRaw(instance.data)));
}
const computed = extractKeys(instance, "computed");
if (computed) {
blocks.push(createInstanceBlock("computed", computed));
}
const injected = extractKeys(instance, "inject");
if (injected) {
blocks.push(createInstanceBlock("injected", injected));
}
blocks.push([
"div",
{},
[
"span",
{
style: keywordStyle.style + ";opacity:0.66"
},
"$ (internal): "
],
["object", { object: instance }]
]);
return blocks;
}
function createInstanceBlock(type, target) {
target = shared_esm_bundler_extend({}, target);
if (!Object.keys(target).length) {
return ["span", {}];
}
return [
"div",
{ style: "line-height:1.25em;margin-bottom:0.6em" },
[
"div",
{
style: "color:#476582"
},
type
],
[
"div",
{
style: "padding-left:1.25em"
},
...Object.keys(target).map((key) => {
return [
"div",
{},
["span", keywordStyle, key + ": "],
formatValue(target[key], false)
];
})
]
];
}
function formatValue(v, asRaw = true) {
if (typeof v === "number") {
return ["span", numberStyle, v];
} else if (typeof v === "string") {
return ["span", stringStyle, JSON.stringify(v)];
} else if (typeof v === "boolean") {
return ["span", keywordStyle, v];
} else if (shared_esm_bundler_isObject(v)) {
return ["object", { object: asRaw ? reactivity_esm_bundler_toRaw(v) : v }];
} else {
return ["span", stringStyle, String(v)];
}
}
function extractKeys(instance, type) {
const Comp = instance.type;
if (shared_esm_bundler_isFunction(Comp)) {
return;
}
const extracted = {};
for (const key in instance.ctx) {
if (isKeyOfType(Comp, key, type)) {
extracted[key] = instance.ctx[key];
}
}
return extracted;
}
function isKeyOfType(Comp, key, type) {
const opts = Comp[type];
if (shared_esm_bundler_isArray(opts) && opts.includes(key) || shared_esm_bundler_isObject(opts) && key in opts) {
return true;
}
if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {
return true;
}
if (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) {
return true;
}
}
function genRefFlag(v) {
if (reactivity_esm_bundler_isShallow(v)) {
return `ShallowRef`;
}
if (v.effect) {
return `ComputedRef`;
}
return `Ref`;
}
if (window.devtoolsFormatters) {
window.devtoolsFormatters.push(formatter);
} else {
window.devtoolsFormatters = [formatter];
}
}
function withMemo(memo, render, cache, index) {
const cached = cache[index];
if (cached && isMemoSame(cached, memo)) {
return cached;
}
const ret = render();
ret.memo = memo.slice();
ret.cacheIndex = index;
return cache[index] = ret;
}
function isMemoSame(cached, memo) {
const prev = cached.memo;
if (prev.length != memo.length) {
return false;
}
for (let i = 0; i < prev.length; i++) {
if (hasChanged(prev[i], memo[i])) {
return false;
}
}
if (isBlockTreeEnabled > 0 && currentBlock) {
currentBlock.push(cached);
}
return true;
}
const version = "3.5.13";
const runtime_core_esm_bundler_warn = false ? 0 : shared_esm_bundler_NOOP;
const ErrorTypeStrings = ErrorTypeStrings$1 ;
const devtools = true ? devtools$1 : 0;
const setDevtoolsHook = true ? setDevtoolsHook$1 : 0;
const _ssrUtils = {
createComponentInstance,
setupComponent,
renderComponentRoot,
setCurrentRenderingInstance,
isVNode: isVNode,
normalizeVNode,
getComponentPublicInstance,
ensureValidVNode,
pushWarningContext,
popWarningContext
};
const ssrUtils = _ssrUtils ;
const resolveFilter = null;
const compatUtils = null;
const DeprecationTypes = null;
;// ./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js
/**
* @vue/runtime-dom v3.5.13
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
let policy = void 0;
const tt = typeof window !== "undefined" && window.trustedTypes;
if (tt) {
try {
policy = /* @__PURE__ */ tt.createPolicy("vue", {
createHTML: (val) => val
});
} catch (e) {
false && 0;
}
}
const unsafeToTrustedHTML = policy ? (val) => policy.createHTML(val) : (val) => val;
const svgNS = "http://www.w3.org/2000/svg";
const mathmlNS = "http://www.w3.org/1998/Math/MathML";
const doc = typeof document !== "undefined" ? document : null;
const templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
const nodeOps = {
insert: (child, parent, anchor) => {
parent.insertBefore(child, anchor || null);
},
remove: (child) => {
const parent = child.parentNode;
if (parent) {
parent.removeChild(child);
}
},
createElement: (tag, namespace, is, props) => {
const el = namespace === "svg" ? doc.createElementNS(svgNS, tag) : namespace === "mathml" ? doc.createElementNS(mathmlNS, tag) : is ? doc.createElement(tag, { is }) : doc.createElement(tag);
if (tag === "select" && props && props.multiple != null) {
el.setAttribute("multiple", props.multiple);
}
return el;
},
createText: (text) => doc.createTextNode(text),
createComment: (text) => doc.createComment(text),
setText: (node, text) => {
node.nodeValue = text;
},
setElementText: (el, text) => {
el.textContent = text;
},
parentNode: (node) => node.parentNode,
nextSibling: (node) => node.nextSibling,
querySelector: (selector) => doc.querySelector(selector),
setScopeId(el, id) {
el.setAttribute(id, "");
},
// __UNSAFE__
// Reason: innerHTML.
// Static content here can only come from compiled templates.
// As long as the user only uses trusted templates, this is safe.
insertStaticContent(content, parent, anchor, namespace, start, end) {
const before = anchor ? anchor.previousSibling : parent.lastChild;
if (start && (start === end || start.nextSibling)) {
while (true) {
parent.insertBefore(start.cloneNode(true), anchor);
if (start === end || !(start = start.nextSibling)) break;
}
} else {
templateContainer.innerHTML = unsafeToTrustedHTML(
namespace === "svg" ? `<svg>${content}</svg>` : namespace === "mathml" ? `<math>${content}</math>` : content
);
const template = templateContainer.content;
if (namespace === "svg" || namespace === "mathml") {
const wrapper = template.firstChild;
while (wrapper.firstChild) {
template.appendChild(wrapper.firstChild);
}
template.removeChild(wrapper);
}
parent.insertBefore(template, anchor);
}
return [
// first
before ? before.nextSibling : parent.firstChild,
// last
anchor ? anchor.previousSibling : parent.lastChild
];
}
};
const TRANSITION = "transition";
const ANIMATION = "animation";
const vtcKey = Symbol("_vtc");
const DOMTransitionPropsValidators = {
name: String,
type: String,
css: {
type: Boolean,
default: true
},
duration: [String, Number, Object],
enterFromClass: String,
enterActiveClass: String,
enterToClass: String,
appearFromClass: String,
appearActiveClass: String,
appearToClass: String,
leaveFromClass: String,
leaveActiveClass: String,
leaveToClass: String
};
const TransitionPropsValidators = /* @__PURE__ */ shared_esm_bundler_extend(
{},
BaseTransitionPropsValidators,
DOMTransitionPropsValidators
);
const decorate$1 = (t) => {
t.displayName = "Transition";
t.props = TransitionPropsValidators;
return t;
};
const Transition = /* @__PURE__ */ decorate$1(
(props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots)
);
const runtime_dom_esm_bundler_callHook = (hook, args = []) => {
if (shared_esm_bundler_isArray(hook)) {
hook.forEach((h2) => h2(...args));
} else if (hook) {
hook(...args);
}
};
const hasExplicitCallback = (hook) => {
return hook ? shared_esm_bundler_isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
};
function resolveTransitionProps(rawProps) {
const baseProps = {};
for (const key in rawProps) {
if (!(key in DOMTransitionPropsValidators)) {
baseProps[key] = rawProps[key];
}
}
if (rawProps.css === false) {
return baseProps;
}
const {
name = "v",
type,
duration,
enterFromClass = `${name}-enter-from`,
enterActiveClass = `${name}-enter-active`,
enterToClass = `${name}-enter-to`,
appearFromClass = enterFromClass,
appearActiveClass = enterActiveClass,
appearToClass = enterToClass,
leaveFromClass = `${name}-leave-from`,
leaveActiveClass = `${name}-leave-active`,
leaveToClass = `${name}-leave-to`
} = rawProps;
const durations = normalizeDuration(duration);
const enterDuration = durations && durations[0];
const leaveDuration = durations && durations[1];
const {
onBeforeEnter,
onEnter,
onEnterCancelled,
onLeave,
onLeaveCancelled,
onBeforeAppear = onBeforeEnter,
onAppear = onEnter,
onAppearCancelled = onEnterCancelled
} = baseProps;
const finishEnter = (el, isAppear, done, isCancelled) => {
el._enterCancelled = isCancelled;
removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
done && done();
};
const finishLeave = (el, done) => {
el._isLeaving = false;
removeTransitionClass(el, leaveFromClass);
removeTransitionClass(el, leaveToClass);
removeTransitionClass(el, leaveActiveClass);
done && done();
};
const makeEnterHook = (isAppear) => {
return (el, done) => {
const hook = isAppear ? onAppear : onEnter;
const resolve = () => finishEnter(el, isAppear, done);
runtime_dom_esm_bundler_callHook(hook, [el, resolve]);
nextFrame(() => {
removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
addTransitionClass(el, isAppear ? appearToClass : enterToClass);
if (!hasExplicitCallback(hook)) {
whenTransitionEnds(el, type, enterDuration, resolve);
}
});
};
};
return shared_esm_bundler_extend(baseProps, {
onBeforeEnter(el) {
runtime_dom_esm_bundler_callHook(onBeforeEnter, [el]);
addTransitionClass(el, enterFromClass);
addTransitionClass(el, enterActiveClass);
},
onBeforeAppear(el) {
runtime_dom_esm_bundler_callHook(onBeforeAppear, [el]);
addTransitionClass(el, appearFromClass);
addTransitionClass(el, appearActiveClass);
},
onEnter: makeEnterHook(false),
onAppear: makeEnterHook(true),
onLeave(el, done) {
el._isLeaving = true;
const resolve = () => finishLeave(el, done);
addTransitionClass(el, leaveFromClass);
if (!el._enterCancelled) {
forceReflow();
addTransitionClass(el, leaveActiveClass);
} else {
addTransitionClass(el, leaveActiveClass);
forceReflow();
}
nextFrame(() => {
if (!el._isLeaving) {
return;
}
removeTransitionClass(el, leaveFromClass);
addTransitionClass(el, leaveToClass);
if (!hasExplicitCallback(onLeave)) {
whenTransitionEnds(el, type, leaveDuration, resolve);
}
});
runtime_dom_esm_bundler_callHook(onLeave, [el, resolve]);
},
onEnterCancelled(el) {
finishEnter(el, false, void 0, true);
runtime_dom_esm_bundler_callHook(onEnterCancelled, [el]);
},
onAppearCancelled(el) {
finishEnter(el, true, void 0, true);
runtime_dom_esm_bundler_callHook(onAppearCancelled, [el]);
},
onLeaveCancelled(el) {
finishLeave(el);
runtime_dom_esm_bundler_callHook(onLeaveCancelled, [el]);
}
});
}
function normalizeDuration(duration) {
if (duration == null) {
return null;
} else if (shared_esm_bundler_isObject(duration)) {
return [NumberOf(duration.enter), NumberOf(duration.leave)];
} else {
const n = NumberOf(duration);
return [n, n];
}
}
function NumberOf(val) {
const res = toNumber(val);
if (false) {}
return res;
}
function addTransitionClass(el, cls) {
cls.split(/\s+/).forEach((c) => c && el.classList.add(c));
(el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls);
}
function removeTransitionClass(el, cls) {
cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
const _vtc = el[vtcKey];
if (_vtc) {
_vtc.delete(cls);
if (!_vtc.size) {
el[vtcKey] = void 0;
}
}
}
function nextFrame(cb) {
requestAnimationFrame(() => {
requestAnimationFrame(cb);
});
}
let endId = 0;
function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) {
const id = el._endId = ++endId;
const resolveIfNotStale = () => {
if (id === el._endId) {
resolve();
}
};
if (explicitTimeout != null) {
return setTimeout(resolveIfNotStale, explicitTimeout);
}
const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
if (!type) {
return resolve();
}
const endEvent = type + "end";
let ended = 0;
const end = () => {
el.removeEventListener(endEvent, onEnd);
resolveIfNotStale();
};
const onEnd = (e) => {
if (e.target === el && ++ended >= propCount) {
end();
}
};
setTimeout(() => {
if (ended < propCount) {
end();
}
}, timeout + 1);
el.addEventListener(endEvent, onEnd);
}
function getTransitionInfo(el, expectedType) {
const styles = window.getComputedStyle(el);
const getStyleProperties = (key) => (styles[key] || "").split(", ");
const transitionDelays = getStyleProperties(`${TRANSITION}Delay`);
const transitionDurations = getStyleProperties(`${TRANSITION}Duration`);
const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
const animationTimeout = getTimeout(animationDelays, animationDurations);
let type = null;
let timeout = 0;
let propCount = 0;
if (expectedType === TRANSITION) {
if (transitionTimeout > 0) {
type = TRANSITION;
timeout = transitionTimeout;
propCount = transitionDurations.length;
}
} else if (expectedType === ANIMATION) {
if (animationTimeout > 0) {
type = ANIMATION;
timeout = animationTimeout;
propCount = animationDurations.length;
}
} else {
timeout = Math.max(transitionTimeout, animationTimeout);
type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
}
const hasTransform = type === TRANSITION && /\b(transform|all)(,|$)/.test(
getStyleProperties(`${TRANSITION}Property`).toString()
);
return {
type,
timeout,
propCount,
hasTransform
};
}
function getTimeout(delays, durations) {
while (delays.length < durations.length) {
delays = delays.concat(delays);
}
return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
}
function toMs(s) {
if (s === "auto") return 0;
return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
}
function forceReflow() {
return document.body.offsetHeight;
}
function patchClass(el, value, isSVG) {
const transitionClasses = el[vtcKey];
if (transitionClasses) {
value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
}
if (value == null) {
el.removeAttribute("class");
} else if (isSVG) {
el.setAttribute("class", value);
} else {
el.className = value;
}
}
const vShowOriginalDisplay = Symbol("_vod");
const vShowHidden = Symbol("_vsh");
const vShow = {
beforeMount(el, { value }, { transition }) {
el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display;
if (transition && value) {
transition.beforeEnter(el);
} else {
setDisplay(el, value);
}
},
mounted(el, { value }, { transition }) {
if (transition && value) {
transition.enter(el);
}
},
updated(el, { value, oldValue }, { transition }) {
if (!value === !oldValue) return;
if (transition) {
if (value) {
transition.beforeEnter(el);
setDisplay(el, true);
transition.enter(el);
} else {
transition.leave(el, () => {
setDisplay(el, false);
});
}
} else {
setDisplay(el, value);
}
},
beforeUnmount(el, { value }) {
setDisplay(el, value);
}
};
if (false) {}
function setDisplay(el, value) {
el.style.display = value ? el[vShowOriginalDisplay] : "none";
el[vShowHidden] = !value;
}
function initVShowForSSR() {
vShow.getSSRProps = ({ value }) => {
if (!value) {
return { style: { display: "none" } };
}
};
}
const CSS_VAR_TEXT = Symbol( false ? 0 : "");
function useCssVars(getter) {
const instance = runtime_core_esm_bundler_getCurrentInstance();
if (!instance) {
false && 0;
return;
}
const updateTeleports = instance.ut = (vars = getter(instance.proxy)) => {
Array.from(
document.querySelectorAll(`[data-v-owner="${instance.uid}"]`)
).forEach((node) => setVarsOnNode(node, vars));
};
if (false) {}
const setVars = () => {
const vars = getter(instance.proxy);
if (instance.ce) {
setVarsOnNode(instance.ce, vars);
} else {
setVarsOnVNode(instance.subTree, vars);
}
updateTeleports(vars);
};
onBeforeUpdate(() => {
queuePostFlushCb(setVars);
});
runtime_core_esm_bundler_onMounted(() => {
runtime_core_esm_bundler_watch(setVars, shared_esm_bundler_NOOP, { flush: "post" });
const ob = new MutationObserver(setVars);
ob.observe(instance.subTree.el.parentNode, { childList: true });
onUnmounted(() => ob.disconnect());
});
}
function setVarsOnVNode(vnode, vars) {
if (vnode.shapeFlag & 128) {
const suspense = vnode.suspense;
vnode = suspense.activeBranch;
if (suspense.pendingBranch && !suspense.isHydrating) {
suspense.effects.push(() => {
setVarsOnVNode(suspense.activeBranch, vars);
});
}
}
while (vnode.component) {
vnode = vnode.component.subTree;
}
if (vnode.shapeFlag & 1 && vnode.el) {
setVarsOnNode(vnode.el, vars);
} else if (vnode.type === Fragment) {
vnode.children.forEach((c) => setVarsOnVNode(c, vars));
} else if (vnode.type === Static) {
let { el, anchor } = vnode;
while (el) {
setVarsOnNode(el, vars);
if (el === anchor) break;
el = el.nextSibling;
}
}
}
function setVarsOnNode(el, vars) {
if (el.nodeType === 1) {
const style = el.style;
let cssText = "";
for (const key in vars) {
style.setProperty(`--${key}`, vars[key]);
cssText += `--${key}: ${vars[key]};`;
}
style[CSS_VAR_TEXT] = cssText;
}
}
const displayRE = /(^|;)\s*display\s*:/;
function patchStyle(el, prev, next) {
const style = el.style;
const isCssString = shared_esm_bundler_isString(next);
let hasControlledDisplay = false;
if (next && !isCssString) {
if (prev) {
if (!shared_esm_bundler_isString(prev)) {
for (const key in prev) {
if (next[key] == null) {
setStyle(style, key, "");
}
}
} else {
for (const prevStyle of prev.split(";")) {
const key = prevStyle.slice(0, prevStyle.indexOf(":")).trim();
if (next[key] == null) {
setStyle(style, key, "");
}
}
}
}
for (const key in next) {
if (key === "display") {
hasControlledDisplay = true;
}
setStyle(style, key, next[key]);
}
} else {
if (isCssString) {
if (prev !== next) {
const cssVarText = style[CSS_VAR_TEXT];
if (cssVarText) {
next += ";" + cssVarText;
}
style.cssText = next;
hasControlledDisplay = displayRE.test(next);
}
} else if (prev) {
el.removeAttribute("style");
}
}
if (vShowOriginalDisplay in el) {
el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : "";
if (el[vShowHidden]) {
style.display = "none";
}
}
}
const semicolonRE = /[^\\];\s*$/;
const importantRE = /\s*!important$/;
function setStyle(style, name, val) {
if (shared_esm_bundler_isArray(val)) {
val.forEach((v) => setStyle(style, name, v));
} else {
if (val == null) val = "";
if (false) {}
if (name.startsWith("--")) {
style.setProperty(name, val);
} else {
const prefixed = autoPrefix(style, name);
if (importantRE.test(val)) {
style.setProperty(
hyphenate(prefixed),
val.replace(importantRE, ""),
"important"
);
} else {
style[prefixed] = val;
}
}
}
}
const prefixes = ["Webkit", "Moz", "ms"];
const prefixCache = {};
function autoPrefix(style, rawName) {
const cached = prefixCache[rawName];
if (cached) {
return cached;
}
let name = shared_esm_bundler_camelize(rawName);
if (name !== "filter" && name in style) {
return prefixCache[rawName] = name;
}
name = shared_esm_bundler_capitalize(name);
for (let i = 0; i < prefixes.length; i++) {
const prefixed = prefixes[i] + name;
if (prefixed in style) {
return prefixCache[rawName] = prefixed;
}
}
return rawName;
}
const xlinkNS = "http://www.w3.org/1999/xlink";
function patchAttr(el, key, value, isSVG, instance, isBoolean = isSpecialBooleanAttr(key)) {
if (isSVG && key.startsWith("xlink:")) {
if (value == null) {
el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
} else {
el.setAttributeNS(xlinkNS, key, value);
}
} else {
if (value == null || isBoolean && !shared_esm_bundler_includeBooleanAttr(value)) {
el.removeAttribute(key);
} else {
el.setAttribute(
key,
isBoolean ? "" : isSymbol(value) ? String(value) : value
);
}
}
}
function patchDOMProp(el, key, value, parentComponent, attrName) {
if (key === "innerHTML" || key === "textContent") {
if (value != null) {
el[key] = key === "innerHTML" ? unsafeToTrustedHTML(value) : value;
}
return;
}
const tag = el.tagName;
if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally
!tag.includes("-")) {
const oldValue = tag === "OPTION" ? el.getAttribute("value") || "" : el.value;
const newValue = value == null ? (
// #11647: value should be set as empty string for null and undefined,
// but <input type="checkbox"> should be set as 'on'.
el.type === "checkbox" ? "on" : ""
) : String(value);
if (oldValue !== newValue || !("_value" in el)) {
el.value = newValue;
}
if (value == null) {
el.removeAttribute(key);
}
el._value = value;
return;
}
let needRemove = false;
if (value === "" || value == null) {
const type = typeof el[key];
if (type === "boolean") {
value = shared_esm_bundler_includeBooleanAttr(value);
} else if (value == null && type === "string") {
value = "";
needRemove = true;
} else if (type === "number") {
value = 0;
needRemove = true;
}
}
try {
el[key] = value;
} catch (e) {
if (false) {}
}
needRemove && el.removeAttribute(attrName || key);
}
function addEventListener(el, event, handler, options) {
el.addEventListener(event, handler, options);
}
function removeEventListener(el, event, handler, options) {
el.removeEventListener(event, handler, options);
}
const veiKey = Symbol("_vei");
function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
const invokers = el[veiKey] || (el[veiKey] = {});
const existingInvoker = invokers[rawName];
if (nextValue && existingInvoker) {
existingInvoker.value = false ? 0 : nextValue;
} else {
const [name, options] = parseName(rawName);
if (nextValue) {
const invoker = invokers[rawName] = createInvoker(
false ? 0 : nextValue,
instance
);
addEventListener(el, name, invoker, options);
} else if (existingInvoker) {
removeEventListener(el, name, existingInvoker, options);
invokers[rawName] = void 0;
}
}
}
const optionsModifierRE = /(?:Once|Passive|Capture)$/;
function parseName(name) {
let options;
if (optionsModifierRE.test(name)) {
options = {};
let m;
while (m = name.match(optionsModifierRE)) {
name = name.slice(0, name.length - m[0].length);
options[m[0].toLowerCase()] = true;
}
}
const event = name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2));
return [event, options];
}
let cachedNow = 0;
const p = /* @__PURE__ */ Promise.resolve();
const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
function createInvoker(initialValue, instance) {
const invoker = (e) => {
if (!e._vts) {
e._vts = Date.now();
} else if (e._vts <= invoker.attached) {
return;
}
callWithAsyncErrorHandling(
patchStopImmediatePropagation(e, invoker.value),
instance,
5,
[e]
);
};
invoker.value = initialValue;
invoker.attached = getNow();
return invoker;
}
function sanitizeEventValue(value, propName) {
if (isFunction(value) || isArray(value)) {
return value;
}
warn(
`Wrong type passed as event handler to ${propName} - did you forget @ or : in front of your prop?
Expected function or array of functions, received type ${typeof value}.`
);
return NOOP;
}
function patchStopImmediatePropagation(e, value) {
if (shared_esm_bundler_isArray(value)) {
const originalStop = e.stopImmediatePropagation;
e.stopImmediatePropagation = () => {
originalStop.call(e);
e._stopped = true;
};
return value.map(
(fn) => (e2) => !e2._stopped && fn && fn(e2)
);
} else {
return value;
}
}
const isNativeOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // lowercase letter
key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123;
const patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) => {
const isSVG = namespace === "svg";
if (key === "class") {
patchClass(el, nextValue, isSVG);
} else if (key === "style") {
patchStyle(el, prevValue, nextValue);
} else if (isOn(key)) {
if (!isModelListener(key)) {
patchEvent(el, key, prevValue, nextValue, parentComponent);
}
} else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
patchDOMProp(el, key, nextValue);
if (!el.tagName.includes("-") && (key === "value" || key === "checked" || key === "selected")) {
patchAttr(el, key, nextValue, isSVG, parentComponent, key !== "value");
}
} else if (
// #11081 force set props for possible async custom element
el._isVueCE && (/[A-Z]/.test(key) || !shared_esm_bundler_isString(nextValue))
) {
patchDOMProp(el, shared_esm_bundler_camelize(key), nextValue, parentComponent, key);
} else {
if (key === "true-value") {
el._trueValue = nextValue;
} else if (key === "false-value") {
el._falseValue = nextValue;
}
patchAttr(el, key, nextValue, isSVG);
}
};
function shouldSetAsProp(el, key, value, isSVG) {
if (isSVG) {
if (key === "innerHTML" || key === "textContent") {
return true;
}
if (key in el && isNativeOn(key) && shared_esm_bundler_isFunction(value)) {
return true;
}
return false;
}
if (key === "spellcheck" || key === "draggable" || key === "translate") {
return false;
}
if (key === "form") {
return false;
}
if (key === "list" && el.tagName === "INPUT") {
return false;
}
if (key === "type" && el.tagName === "TEXTAREA") {
return false;
}
if (key === "width" || key === "height") {
const tag = el.tagName;
if (tag === "IMG" || tag === "VIDEO" || tag === "CANVAS" || tag === "SOURCE") {
return false;
}
}
if (isNativeOn(key) && shared_esm_bundler_isString(value)) {
return false;
}
return key in el;
}
const REMOVAL = {};
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function defineCustomElement(options, extraOptions, _createApp) {
const Comp = defineComponent(options, extraOptions);
if (isPlainObject(Comp)) shared_esm_bundler_extend(Comp, extraOptions);
class VueCustomElement extends VueElement {
constructor(initialProps) {
super(Comp, initialProps, _createApp);
}
}
VueCustomElement.def = Comp;
return VueCustomElement;
}
/*! #__NO_SIDE_EFFECTS__ */
const defineSSRCustomElement = /* @__NO_SIDE_EFFECTS__ */ (options, extraOptions) => {
return /* @__PURE__ */ defineCustomElement(options, extraOptions, createSSRApp);
};
const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
};
class VueElement extends BaseClass {
constructor(_def, _props = {}, _createApp = createApp) {
super();
this._def = _def;
this._props = _props;
this._createApp = _createApp;
this._isVueCE = true;
/**
* @internal
*/
this._instance = null;
/**
* @internal
*/
this._app = null;
/**
* @internal
*/
this._nonce = this._def.nonce;
this._connected = false;
this._resolved = false;
this._numberProps = null;
this._styleChildren = /* @__PURE__ */ new WeakSet();
this._ob = null;
if (this.shadowRoot && _createApp !== createApp) {
this._root = this.shadowRoot;
} else {
if (false) {}
if (_def.shadowRoot !== false) {
this.attachShadow({ mode: "open" });
this._root = this.shadowRoot;
} else {
this._root = this;
}
}
if (!this._def.__asyncLoader) {
this._resolveProps(this._def);
}
}
connectedCallback() {
if (!this.isConnected) return;
if (!this.shadowRoot) {
this._parseSlots();
}
this._connected = true;
let parent = this;
while (parent = parent && (parent.parentNode || parent.host)) {
if (parent instanceof VueElement) {
this._parent = parent;
break;
}
}
if (!this._instance) {
if (this._resolved) {
this._setParent();
this._update();
} else {
if (parent && parent._pendingResolve) {
this._pendingResolve = parent._pendingResolve.then(() => {
this._pendingResolve = void 0;
this._resolveDef();
});
} else {
this._resolveDef();
}
}
}
}
_setParent(parent = this._parent) {
if (parent) {
this._instance.parent = parent._instance;
this._instance.provides = parent._instance.provides;
}
}
disconnectedCallback() {
this._connected = false;
nextTick(() => {
if (!this._connected) {
if (this._ob) {
this._ob.disconnect();
this._ob = null;
}
this._app && this._app.unmount();
if (this._instance) this._instance.ce = void 0;
this._app = this._instance = null;
}
});
}
/**
* resolve inner component definition (handle possible async component)
*/
_resolveDef() {
if (this._pendingResolve) {
return;
}
for (let i = 0; i < this.attributes.length; i++) {
this._setAttr(this.attributes[i].name);
}
this._ob = new MutationObserver((mutations) => {
for (const m of mutations) {
this._setAttr(m.attributeName);
}
});
this._ob.observe(this, { attributes: true });
const resolve = (def, isAsync = false) => {
this._resolved = true;
this._pendingResolve = void 0;
const { props, styles } = def;
let numberProps;
if (props && !shared_esm_bundler_isArray(props)) {
for (const key in props) {
const opt = props[key];
if (opt === Number || opt && opt.type === Number) {
if (key in this._props) {
this._props[key] = toNumber(this._props[key]);
}
(numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[shared_esm_bundler_camelize(key)] = true;
}
}
}
this._numberProps = numberProps;
if (isAsync) {
this._resolveProps(def);
}
if (this.shadowRoot) {
this._applyStyles(styles);
} else if (false) {}
this._mount(def);
};
const asyncDef = this._def.__asyncLoader;
if (asyncDef) {
this._pendingResolve = asyncDef().then(
(def) => resolve(this._def = def, true)
);
} else {
resolve(this._def);
}
}
_mount(def) {
if (false) {}
this._app = this._createApp(def);
if (def.configureApp) {
def.configureApp(this._app);
}
this._app._ceVNode = this._createVNode();
this._app.mount(this._root);
const exposed = this._instance && this._instance.exposed;
if (!exposed) return;
for (const key in exposed) {
if (!hasOwn(this, key)) {
Object.defineProperty(this, key, {
// unwrap ref to be consistent with public instance behavior
get: () => unref(exposed[key])
});
} else if (false) {}
}
}
_resolveProps(def) {
const { props } = def;
const declaredPropKeys = shared_esm_bundler_isArray(props) ? props : Object.keys(props || {});
for (const key of Object.keys(this)) {
if (key[0] !== "_" && declaredPropKeys.includes(key)) {
this._setProp(key, this[key]);
}
}
for (const key of declaredPropKeys.map(shared_esm_bundler_camelize)) {
Object.defineProperty(this, key, {
get() {
return this._getProp(key);
},
set(val) {
this._setProp(key, val, true, true);
}
});
}
}
_setAttr(key) {
if (key.startsWith("data-v-")) return;
const has = this.hasAttribute(key);
let value = has ? this.getAttribute(key) : REMOVAL;
const camelKey = shared_esm_bundler_camelize(key);
if (has && this._numberProps && this._numberProps[camelKey]) {
value = toNumber(value);
}
this._setProp(camelKey, value, false, true);
}
/**
* @internal
*/
_getProp(key) {
return this._props[key];
}
/**
* @internal
*/
_setProp(key, val, shouldReflect = true, shouldUpdate = false) {
if (val !== this._props[key]) {
if (val === REMOVAL) {
delete this._props[key];
} else {
this._props[key] = val;
if (key === "key" && this._app) {
this._app._ceVNode.key = val;
}
}
if (shouldUpdate && this._instance) {
this._update();
}
if (shouldReflect) {
const ob = this._ob;
ob && ob.disconnect();
if (val === true) {
this.setAttribute(hyphenate(key), "");
} else if (typeof val === "string" || typeof val === "number") {
this.setAttribute(hyphenate(key), val + "");
} else if (!val) {
this.removeAttribute(hyphenate(key));
}
ob && ob.observe(this, { attributes: true });
}
}
}
_update() {
render(this._createVNode(), this._root);
}
_createVNode() {
const baseProps = {};
if (!this.shadowRoot) {
baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this);
}
const vnode = createVNode(this._def, shared_esm_bundler_extend(baseProps, this._props));
if (!this._instance) {
vnode.ce = (instance) => {
this._instance = instance;
instance.ce = this;
instance.isCE = true;
if (false) {}
const dispatch = (event, args) => {
this.dispatchEvent(
new CustomEvent(
event,
isPlainObject(args[0]) ? shared_esm_bundler_extend({ detail: args }, args[0]) : { detail: args }
)
);
};
instance.emit = (event, ...args) => {
dispatch(event, args);
if (hyphenate(event) !== event) {
dispatch(hyphenate(event), args);
}
};
this._setParent();
};
}
return vnode;
}
_applyStyles(styles, owner) {
if (!styles) return;
if (owner) {
if (owner === this._def || this._styleChildren.has(owner)) {
return;
}
this._styleChildren.add(owner);
}
const nonce = this._nonce;
for (let i = styles.length - 1; i >= 0; i--) {
const s = document.createElement("style");
if (nonce) s.setAttribute("nonce", nonce);
s.textContent = styles[i];
this.shadowRoot.prepend(s);
if (false) {}
}
}
/**
* Only called when shadowRoot is false
*/
_parseSlots() {
const slots = this._slots = {};
let n;
while (n = this.firstChild) {
const slotName = n.nodeType === 1 && n.getAttribute("slot") || "default";
(slots[slotName] || (slots[slotName] = [])).push(n);
this.removeChild(n);
}
}
/**
* Only called when shadowRoot is false
*/
_renderSlots() {
const outlets = (this._teleportTarget || this).querySelectorAll("slot");
const scopeId = this._instance.type.__scopeId;
for (let i = 0; i < outlets.length; i++) {
const o = outlets[i];
const slotName = o.getAttribute("name") || "default";
const content = this._slots[slotName];
const parent = o.parentNode;
if (content) {
for (const n of content) {
if (scopeId && n.nodeType === 1) {
const id = scopeId + "-s";
const walker = document.createTreeWalker(n, 1);
n.setAttribute(id, "");
let child;
while (child = walker.nextNode()) {
child.setAttribute(id, "");
}
}
parent.insertBefore(n, o);
}
} else {
while (o.firstChild) parent.insertBefore(o.firstChild, o);
}
parent.removeChild(o);
}
}
/**
* @internal
*/
_injectChildStyle(comp) {
this._applyStyles(comp.styles, comp);
}
/**
* @internal
*/
_removeChildStyle(comp) {
if (false) {}
}
}
function useHost(caller) {
const instance = runtime_core_esm_bundler_getCurrentInstance();
const el = instance && instance.ce;
if (el) {
return el;
} else if (false) {}
return null;
}
function useShadowRoot() {
const el = false ? 0 : useHost();
return el && el.shadowRoot;
}
function useCssModule(name = "$style") {
{
const instance = runtime_core_esm_bundler_getCurrentInstance();
if (!instance) {
false && 0;
return EMPTY_OBJ;
}
const modules = instance.type.__cssModules;
if (!modules) {
false && 0;
return EMPTY_OBJ;
}
const mod = modules[name];
if (!mod) {
false && 0;
return EMPTY_OBJ;
}
return mod;
}
}
const positionMap = /* @__PURE__ */ new WeakMap();
const newPositionMap = /* @__PURE__ */ new WeakMap();
const moveCbKey = Symbol("_moveCb");
const runtime_dom_esm_bundler_enterCbKey = Symbol("_enterCb");
const decorate = (t) => {
delete t.props.mode;
return t;
};
const TransitionGroupImpl = /* @__PURE__ */ decorate({
name: "TransitionGroup",
props: /* @__PURE__ */ shared_esm_bundler_extend({}, TransitionPropsValidators, {
tag: String,
moveClass: String
}),
setup(props, { slots }) {
const instance = runtime_core_esm_bundler_getCurrentInstance();
const state = useTransitionState();
let prevChildren;
let children;
onUpdated(() => {
if (!prevChildren.length) {
return;
}
const moveClass = props.moveClass || `${props.name || "v"}-move`;
if (!hasCSSTransform(
prevChildren[0].el,
instance.vnode.el,
moveClass
)) {
return;
}
prevChildren.forEach(callPendingCbs);
prevChildren.forEach(recordPosition);
const movedChildren = prevChildren.filter(applyTranslation);
forceReflow();
movedChildren.forEach((c) => {
const el = c.el;
const style = el.style;
addTransitionClass(el, moveClass);
style.transform = style.webkitTransform = style.transitionDuration = "";
const cb = el[moveCbKey] = (e) => {
if (e && e.target !== el) {
return;
}
if (!e || /transform$/.test(e.propertyName)) {
el.removeEventListener("transitionend", cb);
el[moveCbKey] = null;
removeTransitionClass(el, moveClass);
}
};
el.addEventListener("transitionend", cb);
});
});
return () => {
const rawProps = reactivity_esm_bundler_toRaw(props);
const cssTransitionProps = resolveTransitionProps(rawProps);
let tag = rawProps.tag || Fragment;
prevChildren = [];
if (children) {
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (child.el && child.el instanceof Element) {
prevChildren.push(child);
setTransitionHooks(
child,
resolveTransitionHooks(
child,
cssTransitionProps,
state,
instance
)
);
positionMap.set(
child,
child.el.getBoundingClientRect()
);
}
}
}
children = slots.default ? getTransitionRawChildren(slots.default()) : [];
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (child.key != null) {
setTransitionHooks(
child,
resolveTransitionHooks(child, cssTransitionProps, state, instance)
);
} else if (false) {}
}
return createVNode(tag, null, children);
};
}
});
const TransitionGroup = TransitionGroupImpl;
function callPendingCbs(c) {
const el = c.el;
if (el[moveCbKey]) {
el[moveCbKey]();
}
if (el[runtime_dom_esm_bundler_enterCbKey]) {
el[runtime_dom_esm_bundler_enterCbKey]();
}
}
function recordPosition(c) {
newPositionMap.set(c, c.el.getBoundingClientRect());
}
function applyTranslation(c) {
const oldPos = positionMap.get(c);
const newPos = newPositionMap.get(c);
const dx = oldPos.left - newPos.left;
const dy = oldPos.top - newPos.top;
if (dx || dy) {
const s = c.el.style;
s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
s.transitionDuration = "0s";
return c;
}
}
function hasCSSTransform(el, root, moveClass) {
const clone = el.cloneNode();
const _vtc = el[vtcKey];
if (_vtc) {
_vtc.forEach((cls) => {
cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c));
});
}
moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c));
clone.style.display = "none";
const container = root.nodeType === 1 ? root : root.parentNode;
container.appendChild(clone);
const { hasTransform } = getTransitionInfo(clone);
container.removeChild(clone);
return hasTransform;
}
const getModelAssigner = (vnode) => {
const fn = vnode.props["onUpdate:modelValue"] || false;
return shared_esm_bundler_isArray(fn) ? (value) => invokeArrayFns(fn, value) : fn;
};
function onCompositionStart(e) {
e.target.composing = true;
}
function onCompositionEnd(e) {
const target = e.target;
if (target.composing) {
target.composing = false;
target.dispatchEvent(new Event("input"));
}
}
const assignKey = Symbol("_assign");
const vModelText = {
created(el, { modifiers: { lazy, trim, number } }, vnode) {
el[assignKey] = getModelAssigner(vnode);
const castToNumber = number || vnode.props && vnode.props.type === "number";
addEventListener(el, lazy ? "change" : "input", (e) => {
if (e.target.composing) return;
let domValue = el.value;
if (trim) {
domValue = domValue.trim();
}
if (castToNumber) {
domValue = looseToNumber(domValue);
}
el[assignKey](domValue);
});
if (trim) {
addEventListener(el, "change", () => {
el.value = el.value.trim();
});
}
if (!lazy) {
addEventListener(el, "compositionstart", onCompositionStart);
addEventListener(el, "compositionend", onCompositionEnd);
addEventListener(el, "change", onCompositionEnd);
}
},
// set value on mounted so it's after min/max for type="range"
mounted(el, { value }) {
el.value = value == null ? "" : value;
},
beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) {
el[assignKey] = getModelAssigner(vnode);
if (el.composing) return;
const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? looseToNumber(el.value) : el.value;
const newValue = value == null ? "" : value;
if (elValue === newValue) {
return;
}
if (document.activeElement === el && el.type !== "range") {
if (lazy && value === oldValue) {
return;
}
if (trim && el.value.trim() === newValue) {
return;
}
}
el.value = newValue;
}
};
const vModelCheckbox = {
// #4096 array checkboxes need to be deep traversed
deep: true,
created(el, _, vnode) {
el[assignKey] = getModelAssigner(vnode);
addEventListener(el, "change", () => {
const modelValue = el._modelValue;
const elementValue = getValue(el);
const checked = el.checked;
const assign = el[assignKey];
if (shared_esm_bundler_isArray(modelValue)) {
const index = looseIndexOf(modelValue, elementValue);
const found = index !== -1;
if (checked && !found) {
assign(modelValue.concat(elementValue));
} else if (!checked && found) {
const filtered = [...modelValue];
filtered.splice(index, 1);
assign(filtered);
}
} else if (isSet(modelValue)) {
const cloned = new Set(modelValue);
if (checked) {
cloned.add(elementValue);
} else {
cloned.delete(elementValue);
}
assign(cloned);
} else {
assign(getCheckboxValue(el, checked));
}
});
},
// set initial checked on mount to wait for true-value/false-value
mounted: setChecked,
beforeUpdate(el, binding, vnode) {
el[assignKey] = getModelAssigner(vnode);
setChecked(el, binding, vnode);
}
};
function setChecked(el, { value, oldValue }, vnode) {
el._modelValue = value;
let checked;
if (shared_esm_bundler_isArray(value)) {
checked = looseIndexOf(value, vnode.props.value) > -1;
} else if (isSet(value)) {
checked = value.has(vnode.props.value);
} else {
if (value === oldValue) return;
checked = looseEqual(value, getCheckboxValue(el, true));
}
if (el.checked !== checked) {
el.checked = checked;
}
}
const vModelRadio = {
created(el, { value }, vnode) {
el.checked = looseEqual(value, vnode.props.value);
el[assignKey] = getModelAssigner(vnode);
addEventListener(el, "change", () => {
el[assignKey](getValue(el));
});
},
beforeUpdate(el, { value, oldValue }, vnode) {
el[assignKey] = getModelAssigner(vnode);
if (value !== oldValue) {
el.checked = looseEqual(value, vnode.props.value);
}
}
};
const vModelSelect = {
// <select multiple> value need to be deep traversed
deep: true,
created(el, { value, modifiers: { number } }, vnode) {
const isSetModel = isSet(value);
addEventListener(el, "change", () => {
const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map(
(o) => number ? looseToNumber(getValue(o)) : getValue(o)
);
el[assignKey](
el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]
);
el._assigning = true;
nextTick(() => {
el._assigning = false;
});
});
el[assignKey] = getModelAssigner(vnode);
},
// set value in mounted & updated because <select> relies on its children
// <option>s.
mounted(el, { value }) {
setSelected(el, value);
},
beforeUpdate(el, _binding, vnode) {
el[assignKey] = getModelAssigner(vnode);
},
updated(el, { value }) {
if (!el._assigning) {
setSelected(el, value);
}
}
};
function setSelected(el, value) {
const isMultiple = el.multiple;
const isArrayValue = shared_esm_bundler_isArray(value);
if (isMultiple && !isArrayValue && !isSet(value)) {
false && 0;
return;
}
for (let i = 0, l = el.options.length; i < l; i++) {
const option = el.options[i];
const optionValue = getValue(option);
if (isMultiple) {
if (isArrayValue) {
const optionType = typeof optionValue;
if (optionType === "string" || optionType === "number") {
option.selected = value.some((v) => String(v) === String(optionValue));
} else {
option.selected = looseIndexOf(value, optionValue) > -1;
}
} else {
option.selected = value.has(optionValue);
}
} else if (looseEqual(getValue(option), value)) {
if (el.selectedIndex !== i) el.selectedIndex = i;
return;
}
}
if (!isMultiple && el.selectedIndex !== -1) {
el.selectedIndex = -1;
}
}
function getValue(el) {
return "_value" in el ? el._value : el.value;
}
function getCheckboxValue(el, checked) {
const key = checked ? "_trueValue" : "_falseValue";
return key in el ? el[key] : checked;
}
const vModelDynamic = {
created(el, binding, vnode) {
callModelHook(el, binding, vnode, null, "created");
},
mounted(el, binding, vnode) {
callModelHook(el, binding, vnode, null, "mounted");
},
beforeUpdate(el, binding, vnode, prevVNode) {
callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
},
updated(el, binding, vnode, prevVNode) {
callModelHook(el, binding, vnode, prevVNode, "updated");
}
};
function resolveDynamicModel(tagName, type) {
switch (tagName) {
case "SELECT":
return vModelSelect;
case "TEXTAREA":
return vModelText;
default:
switch (type) {
case "checkbox":
return vModelCheckbox;
case "radio":
return vModelRadio;
default:
return vModelText;
}
}
}
function callModelHook(el, binding, vnode, prevVNode, hook) {
const modelToUse = resolveDynamicModel(
el.tagName,
vnode.props && vnode.props.type
);
const fn = modelToUse[hook];
fn && fn(el, binding, vnode, prevVNode);
}
function initVModelForSSR() {
vModelText.getSSRProps = ({ value }) => ({ value });
vModelRadio.getSSRProps = ({ value }, vnode) => {
if (vnode.props && looseEqual(vnode.props.value, value)) {
return { checked: true };
}
};
vModelCheckbox.getSSRProps = ({ value }, vnode) => {
if (shared_esm_bundler_isArray(value)) {
if (vnode.props && looseIndexOf(value, vnode.props.value) > -1) {
return { checked: true };
}
} else if (isSet(value)) {
if (vnode.props && value.has(vnode.props.value)) {
return { checked: true };
}
} else if (value) {
return { checked: true };
}
};
vModelDynamic.getSSRProps = (binding, vnode) => {
if (typeof vnode.type !== "string") {
return;
}
const modelToUse = resolveDynamicModel(
// resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase
vnode.type.toUpperCase(),
vnode.props && vnode.props.type
);
if (modelToUse.getSSRProps) {
return modelToUse.getSSRProps(binding, vnode);
}
};
}
const systemModifiers = ["ctrl", "shift", "alt", "meta"];
const modifierGuards = {
stop: (e) => e.stopPropagation(),
prevent: (e) => e.preventDefault(),
self: (e) => e.target !== e.currentTarget,
ctrl: (e) => !e.ctrlKey,
shift: (e) => !e.shiftKey,
alt: (e) => !e.altKey,
meta: (e) => !e.metaKey,
left: (e) => "button" in e && e.button !== 0,
middle: (e) => "button" in e && e.button !== 1,
right: (e) => "button" in e && e.button !== 2,
exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
};
const withModifiers = (fn, modifiers) => {
const cache = fn._withMods || (fn._withMods = {});
const cacheKey = modifiers.join(".");
return cache[cacheKey] || (cache[cacheKey] = (event, ...args) => {
for (let i = 0; i < modifiers.length; i++) {
const guard = modifierGuards[modifiers[i]];
if (guard && guard(event, modifiers)) return;
}
return fn(event, ...args);
});
};
const keyNames = {
esc: "escape",
space: " ",
up: "arrow-up",
left: "arrow-left",
right: "arrow-right",
down: "arrow-down",
delete: "backspace"
};
const withKeys = (fn, modifiers) => {
const cache = fn._withKeys || (fn._withKeys = {});
const cacheKey = modifiers.join(".");
return cache[cacheKey] || (cache[cacheKey] = (event) => {
if (!("key" in event)) {
return;
}
const eventKey = hyphenate(event.key);
if (modifiers.some(
(k) => k === eventKey || keyNames[k] === eventKey
)) {
return fn(event);
}
});
};
const rendererOptions = /* @__PURE__ */ shared_esm_bundler_extend({ patchProp }, nodeOps);
let renderer;
let enabledHydration = false;
function ensureRenderer() {
return renderer || (renderer = createRenderer(rendererOptions));
}
function ensureHydrationRenderer() {
renderer = enabledHydration ? renderer : createHydrationRenderer(rendererOptions);
enabledHydration = true;
return renderer;
}
const render = (...args) => {
ensureRenderer().render(...args);
};
const hydrate = (...args) => {
ensureHydrationRenderer().hydrate(...args);
};
const createApp = (...args) => {
const app = ensureRenderer().createApp(...args);
if (false) {}
const { mount } = app;
app.mount = (containerOrSelector) => {
const container = normalizeContainer(containerOrSelector);
if (!container) return;
const component = app._component;
if (!shared_esm_bundler_isFunction(component) && !component.render && !component.template) {
component.template = container.innerHTML;
}
if (container.nodeType === 1) {
container.textContent = "";
}
const proxy = mount(container, false, resolveRootNamespace(container));
if (container instanceof Element) {
container.removeAttribute("v-cloak");
container.setAttribute("data-v-app", "");
}
return proxy;
};
return app;
};
const createSSRApp = (...args) => {
const app = ensureHydrationRenderer().createApp(...args);
if (false) {}
const { mount } = app;
app.mount = (containerOrSelector) => {
const container = normalizeContainer(containerOrSelector);
if (container) {
return mount(container, true, resolveRootNamespace(container));
}
};
return app;
};
function resolveRootNamespace(container) {
if (container instanceof SVGElement) {
return "svg";
}
if (typeof MathMLElement === "function" && container instanceof MathMLElement) {
return "mathml";
}
}
function injectNativeTagCheck(app) {
Object.defineProperty(app.config, "isNativeTag", {
value: (tag) => isHTMLTag(tag) || isSVGTag(tag) || isMathMLTag(tag),
writable: false
});
}
function injectCompilerOptionsCheck(app) {
if (isRuntimeOnly()) {
const isCustomElement = app.config.isCustomElement;
Object.defineProperty(app.config, "isCustomElement", {
get() {
return isCustomElement;
},
set() {
warn(
`The \`isCustomElement\` config option is deprecated. Use \`compilerOptions.isCustomElement\` instead.`
);
}
});
const compilerOptions = app.config.compilerOptions;
const msg = `The \`compilerOptions\` config option is only respected when using a build of Vue.js that includes the runtime compiler (aka "full build"). Since you are using the runtime-only build, \`compilerOptions\` must be passed to \`@vue/compiler-dom\` in the build setup instead.
- For vue-loader: pass it via vue-loader's \`compilerOptions\` loader option.
- For vue-cli: see https://cli.vuejs.org/guide/webpack.html#modifying-options-of-a-loader
- For vite: pass it via @vitejs/plugin-vue options. See https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue#example-for-passing-options-to-vuecompiler-sfc`;
Object.defineProperty(app.config, "compilerOptions", {
get() {
warn(msg);
return compilerOptions;
},
set() {
warn(msg);
}
});
}
}
function normalizeContainer(container) {
if (shared_esm_bundler_isString(container)) {
const res = document.querySelector(container);
if (false) {}
return res;
}
if (false) {}
return container;
}
let ssrDirectiveInitialized = false;
const initDirectivesForSSR = () => {
if (!ssrDirectiveInitialized) {
ssrDirectiveInitialized = true;
initVModelForSSR();
initVShowForSSR();
}
} ;
;// ./node_modules/@vue/compiler-core/dist/compiler-core.esm-bundler.js
/**
* @vue/compiler-core v3.5.13
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
const FRAGMENT = Symbol( false ? 0 : ``);
const TELEPORT = Symbol( false ? 0 : ``);
const SUSPENSE = Symbol( false ? 0 : ``);
const KEEP_ALIVE = Symbol( false ? 0 : ``);
const BASE_TRANSITION = Symbol(
false ? 0 : ``
);
const OPEN_BLOCK = Symbol( false ? 0 : ``);
const CREATE_BLOCK = Symbol( false ? 0 : ``);
const CREATE_ELEMENT_BLOCK = Symbol(
false ? 0 : ``
);
const CREATE_VNODE = Symbol( false ? 0 : ``);
const CREATE_ELEMENT_VNODE = Symbol(
false ? 0 : ``
);
const CREATE_COMMENT = Symbol(
false ? 0 : ``
);
const CREATE_TEXT = Symbol(
false ? 0 : ``
);
const CREATE_STATIC = Symbol(
false ? 0 : ``
);
const RESOLVE_COMPONENT = Symbol(
false ? 0 : ``
);
const RESOLVE_DYNAMIC_COMPONENT = Symbol(
false ? 0 : ``
);
const RESOLVE_DIRECTIVE = Symbol(
false ? 0 : ``
);
const RESOLVE_FILTER = Symbol(
false ? 0 : ``
);
const WITH_DIRECTIVES = Symbol(
false ? 0 : ``
);
const RENDER_LIST = Symbol( false ? 0 : ``);
const RENDER_SLOT = Symbol( false ? 0 : ``);
const CREATE_SLOTS = Symbol( false ? 0 : ``);
const TO_DISPLAY_STRING = Symbol(
false ? 0 : ``
);
const MERGE_PROPS = Symbol( false ? 0 : ``);
const NORMALIZE_CLASS = Symbol(
false ? 0 : ``
);
const NORMALIZE_STYLE = Symbol(
false ? 0 : ``
);
const NORMALIZE_PROPS = Symbol(
false ? 0 : ``
);
const GUARD_REACTIVE_PROPS = Symbol(
false ? 0 : ``
);
const TO_HANDLERS = Symbol( false ? 0 : ``);
const CAMELIZE = Symbol( false ? 0 : ``);
const CAPITALIZE = Symbol( false ? 0 : ``);
const TO_HANDLER_KEY = Symbol(
false ? 0 : ``
);
const SET_BLOCK_TRACKING = Symbol(
false ? 0 : ``
);
const PUSH_SCOPE_ID = Symbol( false ? 0 : ``);
const POP_SCOPE_ID = Symbol( false ? 0 : ``);
const WITH_CTX = Symbol( false ? 0 : ``);
const UNREF = Symbol( false ? 0 : ``);
const IS_REF = Symbol( false ? 0 : ``);
const WITH_MEMO = Symbol( false ? 0 : ``);
const IS_MEMO_SAME = Symbol( false ? 0 : ``);
const helperNameMap = {
[FRAGMENT]: `Fragment`,
[TELEPORT]: `Teleport`,
[SUSPENSE]: `Suspense`,
[KEEP_ALIVE]: `KeepAlive`,
[BASE_TRANSITION]: `BaseTransition`,
[OPEN_BLOCK]: `openBlock`,
[CREATE_BLOCK]: `createBlock`,
[CREATE_ELEMENT_BLOCK]: `createElementBlock`,
[CREATE_VNODE]: `createVNode`,
[CREATE_ELEMENT_VNODE]: `createElementVNode`,
[CREATE_COMMENT]: `createCommentVNode`,
[CREATE_TEXT]: `createTextVNode`,
[CREATE_STATIC]: `createStaticVNode`,
[RESOLVE_COMPONENT]: `resolveComponent`,
[RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
[RESOLVE_DIRECTIVE]: `resolveDirective`,
[RESOLVE_FILTER]: `resolveFilter`,
[WITH_DIRECTIVES]: `withDirectives`,
[RENDER_LIST]: `renderList`,
[RENDER_SLOT]: `renderSlot`,
[CREATE_SLOTS]: `createSlots`,
[TO_DISPLAY_STRING]: `toDisplayString`,
[MERGE_PROPS]: `mergeProps`,
[NORMALIZE_CLASS]: `normalizeClass`,
[NORMALIZE_STYLE]: `normalizeStyle`,
[NORMALIZE_PROPS]: `normalizeProps`,
[GUARD_REACTIVE_PROPS]: `guardReactiveProps`,
[TO_HANDLERS]: `toHandlers`,
[CAMELIZE]: `camelize`,
[CAPITALIZE]: `capitalize`,
[TO_HANDLER_KEY]: `toHandlerKey`,
[SET_BLOCK_TRACKING]: `setBlockTracking`,
[PUSH_SCOPE_ID]: `pushScopeId`,
[POP_SCOPE_ID]: `popScopeId`,
[WITH_CTX]: `withCtx`,
[UNREF]: `unref`,
[IS_REF]: `isRef`,
[WITH_MEMO]: `withMemo`,
[IS_MEMO_SAME]: `isMemoSame`
};
function registerRuntimeHelpers(helpers) {
Object.getOwnPropertySymbols(helpers).forEach((s) => {
helperNameMap[s] = helpers[s];
});
}
const Namespaces = {
"HTML": 0,
"0": "HTML",
"SVG": 1,
"1": "SVG",
"MATH_ML": 2,
"2": "MATH_ML"
};
const NodeTypes = {
"ROOT": 0,
"0": "ROOT",
"ELEMENT": 1,
"1": "ELEMENT",
"TEXT": 2,
"2": "TEXT",
"COMMENT": 3,
"3": "COMMENT",
"SIMPLE_EXPRESSION": 4,
"4": "SIMPLE_EXPRESSION",
"INTERPOLATION": 5,
"5": "INTERPOLATION",
"ATTRIBUTE": 6,
"6": "ATTRIBUTE",
"DIRECTIVE": 7,
"7": "DIRECTIVE",
"COMPOUND_EXPRESSION": 8,
"8": "COMPOUND_EXPRESSION",
"IF": 9,
"9": "IF",
"IF_BRANCH": 10,
"10": "IF_BRANCH",
"FOR": 11,
"11": "FOR",
"TEXT_CALL": 12,
"12": "TEXT_CALL",
"VNODE_CALL": 13,
"13": "VNODE_CALL",
"JS_CALL_EXPRESSION": 14,
"14": "JS_CALL_EXPRESSION",
"JS_OBJECT_EXPRESSION": 15,
"15": "JS_OBJECT_EXPRESSION",
"JS_PROPERTY": 16,
"16": "JS_PROPERTY",
"JS_ARRAY_EXPRESSION": 17,
"17": "JS_ARRAY_EXPRESSION",
"JS_FUNCTION_EXPRESSION": 18,
"18": "JS_FUNCTION_EXPRESSION",
"JS_CONDITIONAL_EXPRESSION": 19,
"19": "JS_CONDITIONAL_EXPRESSION",
"JS_CACHE_EXPRESSION": 20,
"20": "JS_CACHE_EXPRESSION",
"JS_BLOCK_STATEMENT": 21,
"21": "JS_BLOCK_STATEMENT",
"JS_TEMPLATE_LITERAL": 22,
"22": "JS_TEMPLATE_LITERAL",
"JS_IF_STATEMENT": 23,
"23": "JS_IF_STATEMENT",
"JS_ASSIGNMENT_EXPRESSION": 24,
"24": "JS_ASSIGNMENT_EXPRESSION",
"JS_SEQUENCE_EXPRESSION": 25,
"25": "JS_SEQUENCE_EXPRESSION",
"JS_RETURN_STATEMENT": 26,
"26": "JS_RETURN_STATEMENT"
};
const ElementTypes = {
"ELEMENT": 0,
"0": "ELEMENT",
"COMPONENT": 1,
"1": "COMPONENT",
"SLOT": 2,
"2": "SLOT",
"TEMPLATE": 3,
"3": "TEMPLATE"
};
const ConstantTypes = {
"NOT_CONSTANT": 0,
"0": "NOT_CONSTANT",
"CAN_SKIP_PATCH": 1,
"1": "CAN_SKIP_PATCH",
"CAN_CACHE": 2,
"2": "CAN_CACHE",
"CAN_STRINGIFY": 3,
"3": "CAN_STRINGIFY"
};
const locStub = {
start: { line: 1, column: 1, offset: 0 },
end: { line: 1, column: 1, offset: 0 },
source: ""
};
function createRoot(children, source = "") {
return {
type: 0,
source,
children,
helpers: /* @__PURE__ */ new Set(),
components: [],
directives: [],
hoists: [],
imports: [],
cached: [],
temps: 0,
codegenNode: void 0,
loc: locStub
};
}
function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) {
if (context) {
if (isBlock) {
context.helper(OPEN_BLOCK);
context.helper(getVNodeBlockHelper(context.inSSR, isComponent));
} else {
context.helper(getVNodeHelper(context.inSSR, isComponent));
}
if (directives) {
context.helper(WITH_DIRECTIVES);
}
}
return {
type: 13,
tag,
props,
children,
patchFlag,
dynamicProps,
directives,
isBlock,
disableTracking,
isComponent,
loc
};
}
function createArrayExpression(elements, loc = locStub) {
return {
type: 17,
loc,
elements
};
}
function createObjectExpression(properties, loc = locStub) {
return {
type: 15,
loc,
properties
};
}
function createObjectProperty(key, value) {
return {
type: 16,
loc: locStub,
key: shared_esm_bundler_isString(key) ? createSimpleExpression(key, true) : key,
value
};
}
function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
return {
type: 4,
loc,
content,
isStatic,
constType: isStatic ? 3 : constType
};
}
function createInterpolation(content, loc) {
return {
type: 5,
loc,
content: isString(content) ? createSimpleExpression(content, false, loc) : content
};
}
function createCompoundExpression(children, loc = locStub) {
return {
type: 8,
loc,
children
};
}
function createCallExpression(callee, args = [], loc = locStub) {
return {
type: 14,
loc,
callee,
arguments: args
};
}
function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {
return {
type: 18,
params,
returns,
newline,
isSlot,
loc
};
}
function createConditionalExpression(test, consequent, alternate, newline = true) {
return {
type: 19,
test,
consequent,
alternate,
newline,
loc: locStub
};
}
function createCacheExpression(index, value, needPauseTracking = false, inVOnce = false) {
return {
type: 20,
index,
value,
needPauseTracking,
inVOnce,
needArraySpread: false,
loc: locStub
};
}
function createBlockStatement(body) {
return {
type: 21,
body,
loc: locStub
};
}
function createTemplateLiteral(elements) {
return {
type: 22,
elements,
loc: locStub
};
}
function createIfStatement(test, consequent, alternate) {
return {
type: 23,
test,
consequent,
alternate,
loc: locStub
};
}
function createAssignmentExpression(left, right) {
return {
type: 24,
left,
right,
loc: locStub
};
}
function createSequenceExpression(expressions) {
return {
type: 25,
expressions,
loc: locStub
};
}
function createReturnStatement(returns) {
return {
type: 26,
returns,
loc: locStub
};
}
function getVNodeHelper(ssr, isComponent) {
return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
}
function getVNodeBlockHelper(ssr, isComponent) {
return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
}
function convertToBlock(node, { helper, removeHelper, inSSR }) {
if (!node.isBlock) {
node.isBlock = true;
removeHelper(getVNodeHelper(inSSR, node.isComponent));
helper(OPEN_BLOCK);
helper(getVNodeBlockHelper(inSSR, node.isComponent));
}
}
const defaultDelimitersOpen = new Uint8Array([123, 123]);
const defaultDelimitersClose = new Uint8Array([125, 125]);
function isTagStartChar(c) {
return c >= 97 && c <= 122 || c >= 65 && c <= 90;
}
function isWhitespace(c) {
return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
}
function isEndOfTagSection(c) {
return c === 47 || c === 62 || isWhitespace(c);
}
function toCharCodes(str) {
const ret = new Uint8Array(str.length);
for (let i = 0; i < str.length; i++) {
ret[i] = str.charCodeAt(i);
}
return ret;
}
const Sequences = {
Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),
// CDATA[
CdataEnd: new Uint8Array([93, 93, 62]),
// ]]>
CommentEnd: new Uint8Array([45, 45, 62]),
// `-->`
ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),
// `<\/script`
StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),
// `</style`
TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]),
// `</title`
TextareaEnd: new Uint8Array([
60,
47,
116,
101,
120,
116,
97,
114,
101,
97
])
// `</textarea
};
class Tokenizer {
constructor(stack, cbs) {
this.stack = stack;
this.cbs = cbs;
/** The current state the tokenizer is in. */
this.state = 1;
/** The read buffer. */
this.buffer = "";
/** The beginning of the section that is currently being read. */
this.sectionStart = 0;
/** The index within the buffer that we are currently looking at. */
this.index = 0;
/** The start of the last entity. */
this.entityStart = 0;
/** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
this.baseState = 1;
/** For special parsing behavior inside of script and style tags. */
this.inRCDATA = false;
/** For disabling RCDATA tags handling */
this.inXML = false;
/** For disabling interpolation parsing in v-pre */
this.inVPre = false;
/** Record newline positions for fast line / column calculation */
this.newlines = [];
this.mode = 0;
this.delimiterOpen = defaultDelimitersOpen;
this.delimiterClose = defaultDelimitersClose;
this.delimiterIndex = -1;
this.currentSequence = void 0;
this.sequenceIndex = 0;
}
get inSFCRoot() {
return this.mode === 2 && this.stack.length === 0;
}
reset() {
this.state = 1;
this.mode = 0;
this.buffer = "";
this.sectionStart = 0;
this.index = 0;
this.baseState = 1;
this.inRCDATA = false;
this.currentSequence = void 0;
this.newlines.length = 0;
this.delimiterOpen = defaultDelimitersOpen;
this.delimiterClose = defaultDelimitersClose;
}
/**
* Generate Position object with line / column information using recorded
* newline positions. We know the index is always going to be an already
* processed index, so all the newlines up to this index should have been
* recorded.
*/
getPos(index) {
let line = 1;
let column = index + 1;
for (let i = this.newlines.length - 1; i >= 0; i--) {
const newlineIndex = this.newlines[i];
if (index > newlineIndex) {
line = i + 2;
column = index - newlineIndex;
break;
}
}
return {
column,
line,
offset: index
};
}
peek() {
return this.buffer.charCodeAt(this.index + 1);
}
stateText(c) {
if (c === 60) {
if (this.index > this.sectionStart) {
this.cbs.ontext(this.sectionStart, this.index);
}
this.state = 5;
this.sectionStart = this.index;
} else if (!this.inVPre && c === this.delimiterOpen[0]) {
this.state = 2;
this.delimiterIndex = 0;
this.stateInterpolationOpen(c);
}
}
stateInterpolationOpen(c) {
if (c === this.delimiterOpen[this.delimiterIndex]) {
if (this.delimiterIndex === this.delimiterOpen.length - 1) {
const start = this.index + 1 - this.delimiterOpen.length;
if (start > this.sectionStart) {
this.cbs.ontext(this.sectionStart, start);
}
this.state = 3;
this.sectionStart = start;
} else {
this.delimiterIndex++;
}
} else if (this.inRCDATA) {
this.state = 32;
this.stateInRCDATA(c);
} else {
this.state = 1;
this.stateText(c);
}
}
stateInterpolation(c) {
if (c === this.delimiterClose[0]) {
this.state = 4;
this.delimiterIndex = 0;
this.stateInterpolationClose(c);
}
}
stateInterpolationClose(c) {
if (c === this.delimiterClose[this.delimiterIndex]) {
if (this.delimiterIndex === this.delimiterClose.length - 1) {
this.cbs.oninterpolation(this.sectionStart, this.index + 1);
if (this.inRCDATA) {
this.state = 32;
} else {
this.state = 1;
}
this.sectionStart = this.index + 1;
} else {
this.delimiterIndex++;
}
} else {
this.state = 3;
this.stateInterpolation(c);
}
}
stateSpecialStartSequence(c) {
const isEnd = this.sequenceIndex === this.currentSequence.length;
const isMatch = isEnd ? (
// If we are at the end of the sequence, make sure the tag name has ended
isEndOfTagSection(c)
) : (
// Otherwise, do a case-insensitive comparison
(c | 32) === this.currentSequence[this.sequenceIndex]
);
if (!isMatch) {
this.inRCDATA = false;
} else if (!isEnd) {
this.sequenceIndex++;
return;
}
this.sequenceIndex = 0;
this.state = 6;
this.stateInTagName(c);
}
/** Look for an end tag. For <title> and <textarea>, also decode entities. */
stateInRCDATA(c) {
if (this.sequenceIndex === this.currentSequence.length) {
if (c === 62 || isWhitespace(c)) {
const endOfText = this.index - this.currentSequence.length;
if (this.sectionStart < endOfText) {
const actualIndex = this.index;
this.index = endOfText;
this.cbs.ontext(this.sectionStart, endOfText);
this.index = actualIndex;
}
this.sectionStart = endOfText + 2;
this.stateInClosingTagName(c);
this.inRCDATA = false;
return;
}
this.sequenceIndex = 0;
}
if ((c | 32) === this.currentSequence[this.sequenceIndex]) {
this.sequenceIndex += 1;
} else if (this.sequenceIndex === 0) {
if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {
if (!this.inVPre && c === this.delimiterOpen[0]) {
this.state = 2;
this.delimiterIndex = 0;
this.stateInterpolationOpen(c);
}
} else if (this.fastForwardTo(60)) {
this.sequenceIndex = 1;
}
} else {
this.sequenceIndex = Number(c === 60);
}
}
stateCDATASequence(c) {
if (c === Sequences.Cdata[this.sequenceIndex]) {
if (++this.sequenceIndex === Sequences.Cdata.length) {
this.state = 28;
this.currentSequence = Sequences.CdataEnd;
this.sequenceIndex = 0;
this.sectionStart = this.index + 1;
}
} else {
this.sequenceIndex = 0;
this.state = 23;
this.stateInDeclaration(c);
}
}
/**
* When we wait for one specific character, we can speed things up
* by skipping through the buffer until we find it.
*
* @returns Whether the character was found.
*/
fastForwardTo(c) {
while (++this.index < this.buffer.length) {
const cc = this.buffer.charCodeAt(this.index);
if (cc === 10) {
this.newlines.push(this.index);
}
if (cc === c) {
return true;
}
}
this.index = this.buffer.length - 1;
return false;
}
/**
* Comments and CDATA end with `-->` and `]]>`.
*
* Their common qualities are:
* - Their end sequences have a distinct character they start with.
* - That character is then repeated, so we have to check multiple repeats.
* - All characters but the start character of the sequence can be skipped.
*/
stateInCommentLike(c) {
if (c === this.currentSequence[this.sequenceIndex]) {
if (++this.sequenceIndex === this.currentSequence.length) {
if (this.currentSequence === Sequences.CdataEnd) {
this.cbs.oncdata(this.sectionStart, this.index - 2);
} else {
this.cbs.oncomment(this.sectionStart, this.index - 2);
}
this.sequenceIndex = 0;
this.sectionStart = this.index + 1;
this.state = 1;
}
} else if (this.sequenceIndex === 0) {
if (this.fastForwardTo(this.currentSequence[0])) {
this.sequenceIndex = 1;
}
} else if (c !== this.currentSequence[this.sequenceIndex - 1]) {
this.sequenceIndex = 0;
}
}
startSpecial(sequence, offset) {
this.enterRCDATA(sequence, offset);
this.state = 31;
}
enterRCDATA(sequence, offset) {
this.inRCDATA = true;
this.currentSequence = sequence;
this.sequenceIndex = offset;
}
stateBeforeTagName(c) {
if (c === 33) {
this.state = 22;
this.sectionStart = this.index + 1;
} else if (c === 63) {
this.state = 24;
this.sectionStart = this.index + 1;
} else if (isTagStartChar(c)) {
this.sectionStart = this.index;
if (this.mode === 0) {
this.state = 6;
} else if (this.inSFCRoot) {
this.state = 34;
} else if (!this.inXML) {
if (c === 116) {
this.state = 30;
} else {
this.state = c === 115 ? 29 : 6;
}
} else {
this.state = 6;
}
} else if (c === 47) {
this.state = 8;
} else {
this.state = 1;
this.stateText(c);
}
}
stateInTagName(c) {
if (isEndOfTagSection(c)) {
this.handleTagName(c);
}
}
stateInSFCRootTagName(c) {
if (isEndOfTagSection(c)) {
const tag = this.buffer.slice(this.sectionStart, this.index);
if (tag !== "template") {
this.enterRCDATA(toCharCodes(`</` + tag), 0);
}
this.handleTagName(c);
}
}
handleTagName(c) {
this.cbs.onopentagname(this.sectionStart, this.index);
this.sectionStart = -1;
this.state = 11;
this.stateBeforeAttrName(c);
}
stateBeforeClosingTagName(c) {
if (isWhitespace(c)) ; else if (c === 62) {
if (false) {}
this.state = 1;
this.sectionStart = this.index + 1;
} else {
this.state = isTagStartChar(c) ? 9 : 27;
this.sectionStart = this.index;
}
}
stateInClosingTagName(c) {
if (c === 62 || isWhitespace(c)) {
this.cbs.onclosetag(this.sectionStart, this.index);
this.sectionStart = -1;
this.state = 10;
this.stateAfterClosingTagName(c);
}
}
stateAfterClosingTagName(c) {
if (c === 62) {
this.state = 1;
this.sectionStart = this.index + 1;
}
}
stateBeforeAttrName(c) {
if (c === 62) {
this.cbs.onopentagend(this.index);
if (this.inRCDATA) {
this.state = 32;
} else {
this.state = 1;
}
this.sectionStart = this.index + 1;
} else if (c === 47) {
this.state = 7;
if (false) {}
} else if (c === 60 && this.peek() === 47) {
this.cbs.onopentagend(this.index);
this.state = 5;
this.sectionStart = this.index;
} else if (!isWhitespace(c)) {
if (false) {}
this.handleAttrStart(c);
}
}
handleAttrStart(c) {
if (c === 118 && this.peek() === 45) {
this.state = 13;
this.sectionStart = this.index;
} else if (c === 46 || c === 58 || c === 64 || c === 35) {
this.cbs.ondirname(this.index, this.index + 1);
this.state = 14;
this.sectionStart = this.index + 1;
} else {
this.state = 12;
this.sectionStart = this.index;
}
}
stateInSelfClosingTag(c) {
if (c === 62) {
this.cbs.onselfclosingtag(this.index);
this.state = 1;
this.sectionStart = this.index + 1;
this.inRCDATA = false;
} else if (!isWhitespace(c)) {
this.state = 11;
this.stateBeforeAttrName(c);
}
}
stateInAttrName(c) {
if (c === 61 || isEndOfTagSection(c)) {
this.cbs.onattribname(this.sectionStart, this.index);
this.handleAttrNameEnd(c);
} else if (false) {}
}
stateInDirName(c) {
if (c === 61 || isEndOfTagSection(c)) {
this.cbs.ondirname(this.sectionStart, this.index);
this.handleAttrNameEnd(c);
} else if (c === 58) {
this.cbs.ondirname(this.sectionStart, this.index);
this.state = 14;
this.sectionStart = this.index + 1;
} else if (c === 46) {
this.cbs.ondirname(this.sectionStart, this.index);
this.state = 16;
this.sectionStart = this.index + 1;
}
}
stateInDirArg(c) {
if (c === 61 || isEndOfTagSection(c)) {
this.cbs.ondirarg(this.sectionStart, this.index);
this.handleAttrNameEnd(c);
} else if (c === 91) {
this.state = 15;
} else if (c === 46) {
this.cbs.ondirarg(this.sectionStart, this.index);
this.state = 16;
this.sectionStart = this.index + 1;
}
}
stateInDynamicDirArg(c) {
if (c === 93) {
this.state = 14;
} else if (c === 61 || isEndOfTagSection(c)) {
this.cbs.ondirarg(this.sectionStart, this.index + 1);
this.handleAttrNameEnd(c);
if (false) {}
}
}
stateInDirModifier(c) {
if (c === 61 || isEndOfTagSection(c)) {
this.cbs.ondirmodifier(this.sectionStart, this.index);
this.handleAttrNameEnd(c);
} else if (c === 46) {
this.cbs.ondirmodifier(this.sectionStart, this.index);
this.sectionStart = this.index + 1;
}
}
handleAttrNameEnd(c) {
this.sectionStart = this.index;
this.state = 17;
this.cbs.onattribnameend(this.index);
this.stateAfterAttrName(c);
}
stateAfterAttrName(c) {
if (c === 61) {
this.state = 18;
} else if (c === 47 || c === 62) {
this.cbs.onattribend(0, this.sectionStart);
this.sectionStart = -1;
this.state = 11;
this.stateBeforeAttrName(c);
} else if (!isWhitespace(c)) {
this.cbs.onattribend(0, this.sectionStart);
this.handleAttrStart(c);
}
}
stateBeforeAttrValue(c) {
if (c === 34) {
this.state = 19;
this.sectionStart = this.index + 1;
} else if (c === 39) {
this.state = 20;
this.sectionStart = this.index + 1;
} else if (!isWhitespace(c)) {
this.sectionStart = this.index;
this.state = 21;
this.stateInAttrValueNoQuotes(c);
}
}
handleInAttrValue(c, quote) {
if (c === quote || this.fastForwardTo(quote)) {
this.cbs.onattribdata(this.sectionStart, this.index);
this.sectionStart = -1;
this.cbs.onattribend(
quote === 34 ? 3 : 2,
this.index + 1
);
this.state = 11;
}
}
stateInAttrValueDoubleQuotes(c) {
this.handleInAttrValue(c, 34);
}
stateInAttrValueSingleQuotes(c) {
this.handleInAttrValue(c, 39);
}
stateInAttrValueNoQuotes(c) {
if (isWhitespace(c) || c === 62) {
this.cbs.onattribdata(this.sectionStart, this.index);
this.sectionStart = -1;
this.cbs.onattribend(1, this.index);
this.state = 11;
this.stateBeforeAttrName(c);
} else if ( false || c === 39 || c === 60 || c === 61 || c === 96) {
this.cbs.onerr(
18,
this.index
);
} else ;
}
stateBeforeDeclaration(c) {
if (c === 91) {
this.state = 26;
this.sequenceIndex = 0;
} else {
this.state = c === 45 ? 25 : 23;
}
}
stateInDeclaration(c) {
if (c === 62 || this.fastForwardTo(62)) {
this.state = 1;
this.sectionStart = this.index + 1;
}
}
stateInProcessingInstruction(c) {
if (c === 62 || this.fastForwardTo(62)) {
this.cbs.onprocessinginstruction(this.sectionStart, this.index);
this.state = 1;
this.sectionStart = this.index + 1;
}
}
stateBeforeComment(c) {
if (c === 45) {
this.state = 28;
this.currentSequence = Sequences.CommentEnd;
this.sequenceIndex = 2;
this.sectionStart = this.index + 1;
} else {
this.state = 23;
}
}
stateInSpecialComment(c) {
if (c === 62 || this.fastForwardTo(62)) {
this.cbs.oncomment(this.sectionStart, this.index);
this.state = 1;
this.sectionStart = this.index + 1;
}
}
stateBeforeSpecialS(c) {
if (c === Sequences.ScriptEnd[3]) {
this.startSpecial(Sequences.ScriptEnd, 4);
} else if (c === Sequences.StyleEnd[3]) {
this.startSpecial(Sequences.StyleEnd, 4);
} else {
this.state = 6;
this.stateInTagName(c);
}
}
stateBeforeSpecialT(c) {
if (c === Sequences.TitleEnd[3]) {
this.startSpecial(Sequences.TitleEnd, 4);
} else if (c === Sequences.TextareaEnd[3]) {
this.startSpecial(Sequences.TextareaEnd, 4);
} else {
this.state = 6;
this.stateInTagName(c);
}
}
startEntity() {
}
stateInEntity() {
}
/**
* Iterates through the buffer, calling the function corresponding to the current state.
*
* States that are more likely to be hit are higher up, as a performance improvement.
*/
parse(input) {
this.buffer = input;
while (this.index < this.buffer.length) {
const c = this.buffer.charCodeAt(this.index);
if (c === 10) {
this.newlines.push(this.index);
}
switch (this.state) {
case 1: {
this.stateText(c);
break;
}
case 2: {
this.stateInterpolationOpen(c);
break;
}
case 3: {
this.stateInterpolation(c);
break;
}
case 4: {
this.stateInterpolationClose(c);
break;
}
case 31: {
this.stateSpecialStartSequence(c);
break;
}
case 32: {
this.stateInRCDATA(c);
break;
}
case 26: {
this.stateCDATASequence(c);
break;
}
case 19: {
this.stateInAttrValueDoubleQuotes(c);
break;
}
case 12: {
this.stateInAttrName(c);
break;
}
case 13: {
this.stateInDirName(c);
break;
}
case 14: {
this.stateInDirArg(c);
break;
}
case 15: {
this.stateInDynamicDirArg(c);
break;
}
case 16: {
this.stateInDirModifier(c);
break;
}
case 28: {
this.stateInCommentLike(c);
break;
}
case 27: {
this.stateInSpecialComment(c);
break;
}
case 11: {
this.stateBeforeAttrName(c);
break;
}
case 6: {
this.stateInTagName(c);
break;
}
case 34: {
this.stateInSFCRootTagName(c);
break;
}
case 9: {
this.stateInClosingTagName(c);
break;
}
case 5: {
this.stateBeforeTagName(c);
break;
}
case 17: {
this.stateAfterAttrName(c);
break;
}
case 20: {
this.stateInAttrValueSingleQuotes(c);
break;
}
case 18: {
this.stateBeforeAttrValue(c);
break;
}
case 8: {
this.stateBeforeClosingTagName(c);
break;
}
case 10: {
this.stateAfterClosingTagName(c);
break;
}
case 29: {
this.stateBeforeSpecialS(c);
break;
}
case 30: {
this.stateBeforeSpecialT(c);
break;
}
case 21: {
this.stateInAttrValueNoQuotes(c);
break;
}
case 7: {
this.stateInSelfClosingTag(c);
break;
}
case 23: {
this.stateInDeclaration(c);
break;
}
case 22: {
this.stateBeforeDeclaration(c);
break;
}
case 25: {
this.stateBeforeComment(c);
break;
}
case 24: {
this.stateInProcessingInstruction(c);
break;
}
case 33: {
this.stateInEntity();
break;
}
}
this.index++;
}
this.cleanup();
this.finish();
}
/**
* Remove data that has already been consumed from the buffer.
*/
cleanup() {
if (this.sectionStart !== this.index) {
if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {
this.cbs.ontext(this.sectionStart, this.index);
this.sectionStart = this.index;
} else if (this.state === 19 || this.state === 20 || this.state === 21) {
this.cbs.onattribdata(this.sectionStart, this.index);
this.sectionStart = this.index;
}
}
}
finish() {
this.handleTrailingData();
this.cbs.onend();
}
/** Handle any trailing data. */
handleTrailingData() {
const endIndex = this.buffer.length;
if (this.sectionStart >= endIndex) {
return;
}
if (this.state === 28) {
if (this.currentSequence === Sequences.CdataEnd) {
this.cbs.oncdata(this.sectionStart, endIndex);
} else {
this.cbs.oncomment(this.sectionStart, endIndex);
}
} else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ; else {
this.cbs.ontext(this.sectionStart, endIndex);
}
}
emitCodePoint(cp, consumed) {
}
}
const CompilerDeprecationTypes = {
"COMPILER_IS_ON_ELEMENT": "COMPILER_IS_ON_ELEMENT",
"COMPILER_V_BIND_SYNC": "COMPILER_V_BIND_SYNC",
"COMPILER_V_BIND_OBJECT_ORDER": "COMPILER_V_BIND_OBJECT_ORDER",
"COMPILER_V_ON_NATIVE": "COMPILER_V_ON_NATIVE",
"COMPILER_V_IF_V_FOR_PRECEDENCE": "COMPILER_V_IF_V_FOR_PRECEDENCE",
"COMPILER_NATIVE_TEMPLATE": "COMPILER_NATIVE_TEMPLATE",
"COMPILER_INLINE_TEMPLATE": "COMPILER_INLINE_TEMPLATE",
"COMPILER_FILTERS": "COMPILER_FILTERS"
};
const deprecationData = {
["COMPILER_IS_ON_ELEMENT"]: {
message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`,
link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`
},
["COMPILER_V_BIND_SYNC"]: {
message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`,
link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`
},
["COMPILER_V_BIND_OBJECT_ORDER"]: {
message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,
link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`
},
["COMPILER_V_ON_NATIVE"]: {
message: `.native modifier for v-on has been removed as is no longer necessary.`,
link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`
},
["COMPILER_V_IF_V_FOR_PRECEDENCE"]: {
message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`,
link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`
},
["COMPILER_NATIVE_TEMPLATE"]: {
message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.`
},
["COMPILER_INLINE_TEMPLATE"]: {
message: `"inline-template" has been removed in Vue 3.`,
link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`
},
["COMPILER_FILTERS"]: {
message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`,
link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`
}
};
function getCompatValue(key, { compatConfig }) {
const value = compatConfig && compatConfig[key];
if (key === "MODE") {
return value || 3;
} else {
return value;
}
}
function isCompatEnabled(key, context) {
const mode = getCompatValue("MODE", context);
const value = getCompatValue(key, context);
return mode === 3 ? value === true : value !== false;
}
function checkCompatEnabled(key, context, loc, ...args) {
const enabled = isCompatEnabled(key, context);
if (false) {}
return enabled;
}
function warnDeprecation(key, context, loc, ...args) {
const val = getCompatValue(key, context);
if (val === "suppress-warning") {
return;
}
const { message, link } = deprecationData[key];
const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? `
Details: ${link}` : ``}`;
const err = new SyntaxError(msg);
err.code = key;
if (loc) err.loc = loc;
context.onWarn(err);
}
function defaultOnError(error) {
throw error;
}
function defaultOnWarn(msg) {
false && 0;
}
function createCompilerError(code, loc, messages, additionalMessage) {
const msg = false ? 0 : `https://vuejs.org/error-reference/#compiler-${code}`;
const error = new SyntaxError(String(msg));
error.code = code;
error.loc = loc;
return error;
}
const compiler_core_esm_bundler_ErrorCodes = {
"ABRUPT_CLOSING_OF_EMPTY_COMMENT": 0,
"0": "ABRUPT_CLOSING_OF_EMPTY_COMMENT",
"CDATA_IN_HTML_CONTENT": 1,
"1": "CDATA_IN_HTML_CONTENT",
"DUPLICATE_ATTRIBUTE": 2,
"2": "DUPLICATE_ATTRIBUTE",
"END_TAG_WITH_ATTRIBUTES": 3,
"3": "END_TAG_WITH_ATTRIBUTES",
"END_TAG_WITH_TRAILING_SOLIDUS": 4,
"4": "END_TAG_WITH_TRAILING_SOLIDUS",
"EOF_BEFORE_TAG_NAME": 5,
"5": "EOF_BEFORE_TAG_NAME",
"EOF_IN_CDATA": 6,
"6": "EOF_IN_CDATA",
"EOF_IN_COMMENT": 7,
"7": "EOF_IN_COMMENT",
"EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT": 8,
"8": "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT",
"EOF_IN_TAG": 9,
"9": "EOF_IN_TAG",
"INCORRECTLY_CLOSED_COMMENT": 10,
"10": "INCORRECTLY_CLOSED_COMMENT",
"INCORRECTLY_OPENED_COMMENT": 11,
"11": "INCORRECTLY_OPENED_COMMENT",
"INVALID_FIRST_CHARACTER_OF_TAG_NAME": 12,
"12": "INVALID_FIRST_CHARACTER_OF_TAG_NAME",
"MISSING_ATTRIBUTE_VALUE": 13,
"13": "MISSING_ATTRIBUTE_VALUE",
"MISSING_END_TAG_NAME": 14,
"14": "MISSING_END_TAG_NAME",
"MISSING_WHITESPACE_BETWEEN_ATTRIBUTES": 15,
"15": "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES",
"NESTED_COMMENT": 16,
"16": "NESTED_COMMENT",
"UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME": 17,
"17": "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME",
"UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE": 18,
"18": "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE",
"UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME": 19,
"19": "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME",
"UNEXPECTED_NULL_CHARACTER": 20,
"20": "UNEXPECTED_NULL_CHARACTER",
"UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME": 21,
"21": "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME",
"UNEXPECTED_SOLIDUS_IN_TAG": 22,
"22": "UNEXPECTED_SOLIDUS_IN_TAG",
"X_INVALID_END_TAG": 23,
"23": "X_INVALID_END_TAG",
"X_MISSING_END_TAG": 24,
"24": "X_MISSING_END_TAG",
"X_MISSING_INTERPOLATION_END": 25,
"25": "X_MISSING_INTERPOLATION_END",
"X_MISSING_DIRECTIVE_NAME": 26,
"26": "X_MISSING_DIRECTIVE_NAME",
"X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END": 27,
"27": "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END",
"X_V_IF_NO_EXPRESSION": 28,
"28": "X_V_IF_NO_EXPRESSION",
"X_V_IF_SAME_KEY": 29,
"29": "X_V_IF_SAME_KEY",
"X_V_ELSE_NO_ADJACENT_IF": 30,
"30": "X_V_ELSE_NO_ADJACENT_IF",
"X_V_FOR_NO_EXPRESSION": 31,
"31": "X_V_FOR_NO_EXPRESSION",
"X_V_FOR_MALFORMED_EXPRESSION": 32,
"32": "X_V_FOR_MALFORMED_EXPRESSION",
"X_V_FOR_TEMPLATE_KEY_PLACEMENT": 33,
"33": "X_V_FOR_TEMPLATE_KEY_PLACEMENT",
"X_V_BIND_NO_EXPRESSION": 34,
"34": "X_V_BIND_NO_EXPRESSION",
"X_V_ON_NO_EXPRESSION": 35,
"35": "X_V_ON_NO_EXPRESSION",
"X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET": 36,
"36": "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET",
"X_V_SLOT_MIXED_SLOT_USAGE": 37,
"37": "X_V_SLOT_MIXED_SLOT_USAGE",
"X_V_SLOT_DUPLICATE_SLOT_NAMES": 38,
"38": "X_V_SLOT_DUPLICATE_SLOT_NAMES",
"X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN": 39,
"39": "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN",
"X_V_SLOT_MISPLACED": 40,
"40": "X_V_SLOT_MISPLACED",
"X_V_MODEL_NO_EXPRESSION": 41,
"41": "X_V_MODEL_NO_EXPRESSION",
"X_V_MODEL_MALFORMED_EXPRESSION": 42,
"42": "X_V_MODEL_MALFORMED_EXPRESSION",
"X_V_MODEL_ON_SCOPE_VARIABLE": 43,
"43": "X_V_MODEL_ON_SCOPE_VARIABLE",
"X_V_MODEL_ON_PROPS": 44,
"44": "X_V_MODEL_ON_PROPS",
"X_INVALID_EXPRESSION": 45,
"45": "X_INVALID_EXPRESSION",
"X_KEEP_ALIVE_INVALID_CHILDREN": 46,
"46": "X_KEEP_ALIVE_INVALID_CHILDREN",
"X_PREFIX_ID_NOT_SUPPORTED": 47,
"47": "X_PREFIX_ID_NOT_SUPPORTED",
"X_MODULE_MODE_NOT_SUPPORTED": 48,
"48": "X_MODULE_MODE_NOT_SUPPORTED",
"X_CACHE_HANDLER_NOT_SUPPORTED": 49,
"49": "X_CACHE_HANDLER_NOT_SUPPORTED",
"X_SCOPE_ID_NOT_SUPPORTED": 50,
"50": "X_SCOPE_ID_NOT_SUPPORTED",
"X_VNODE_HOOKS": 51,
"51": "X_VNODE_HOOKS",
"X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 52,
"52": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT",
"__EXTEND_POINT__": 53,
"53": "__EXTEND_POINT__"
};
const errorMessages = {
// parse errors
[0]: "Illegal comment.",
[1]: "CDATA section is allowed only in XML context.",
[2]: "Duplicate attribute.",
[3]: "End tag cannot have attributes.",
[4]: "Illegal '/' in tags.",
[5]: "Unexpected EOF in tag.",
[6]: "Unexpected EOF in CDATA section.",
[7]: "Unexpected EOF in comment.",
[8]: "Unexpected EOF in script.",
[9]: "Unexpected EOF in tag.",
[10]: "Incorrectly closed comment.",
[11]: "Incorrectly opened comment.",
[12]: "Illegal tag name. Use '<' to print '<'.",
[13]: "Attribute value was expected.",
[14]: "End tag name was expected.",
[15]: "Whitespace was expected.",
[16]: "Unexpected '<!--' in comment.",
[17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
[18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
[19]: "Attribute name cannot start with '='.",
[21]: "'<?' is allowed only in XML context.",
[20]: `Unexpected null character.`,
[22]: "Illegal '/' in tags.",
// Vue-specific parse errors
[23]: "Invalid end tag.",
[24]: "Element is missing end tag.",
[25]: "Interpolation end sign was not found.",
[27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
[26]: "Legal directive name was expected.",
// transform errors
[28]: `v-if/v-else-if is missing expression.`,
[29]: `v-if/else branches must use unique keys.`,
[30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
[31]: `v-for is missing expression.`,
[32]: `v-for has invalid expression.`,
[33]: `<template v-for> key should be placed on the <template> tag.`,
[34]: `v-bind is missing expression.`,
[52]: `v-bind with same-name shorthand only allows static argument.`,
[35]: `v-on is missing expression.`,
[36]: `Unexpected custom directive on <slot> outlet.`,
[37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
[38]: `Duplicate slot names found. `,
[39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
[40]: `v-slot can only be used on components or <template> tags.`,
[41]: `v-model is missing expression.`,
[42]: `v-model value must be a valid JavaScript member expression.`,
[43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
[44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
[45]: `Error parsing JavaScript expression: `,
[46]: `<KeepAlive> expects exactly one child component.`,
[51]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`,
// generic errors
[47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
[48]: `ES module mode is not supported in this build of compiler.`,
[49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
[50]: `"scopeId" option is only supported in module mode.`,
// just to fulfill types
[53]: ``
};
function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) {
{
return;
}
}
function isReferencedIdentifier(id, parent, parentStack) {
{
return false;
}
}
function isInDestructureAssignment(parent, parentStack) {
if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
let i = parentStack.length;
while (i--) {
const p = parentStack[i];
if (p.type === "AssignmentExpression") {
return true;
} else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) {
break;
}
}
}
return false;
}
function isInNewExpression(parentStack) {
let i = parentStack.length;
while (i--) {
const p = parentStack[i];
if (p.type === "NewExpression") {
return true;
} else if (p.type !== "MemberExpression") {
break;
}
}
return false;
}
function walkFunctionParams(node, onIdent) {
for (const p of node.params) {
for (const id of extractIdentifiers(p)) {
onIdent(id);
}
}
}
function walkBlockDeclarations(block, onIdent) {
for (const stmt of block.body) {
if (stmt.type === "VariableDeclaration") {
if (stmt.declare) continue;
for (const decl of stmt.declarations) {
for (const id of extractIdentifiers(decl.id)) {
onIdent(id);
}
}
} else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
if (stmt.declare || !stmt.id) continue;
onIdent(stmt.id);
} else if (isForStatement(stmt)) {
walkForStatement(stmt, true, onIdent);
}
}
}
function isForStatement(stmt) {
return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement";
}
function walkForStatement(stmt, isVar, onIdent) {
const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) {
for (const decl of variable.declarations) {
for (const id of extractIdentifiers(decl.id)) {
onIdent(id);
}
}
}
}
function extractIdentifiers(param, nodes = []) {
switch (param.type) {
case "Identifier":
nodes.push(param);
break;
case "MemberExpression":
let object = param;
while (object.type === "MemberExpression") {
object = object.object;
}
nodes.push(object);
break;
case "ObjectPattern":
for (const prop of param.properties) {
if (prop.type === "RestElement") {
extractIdentifiers(prop.argument, nodes);
} else {
extractIdentifiers(prop.value, nodes);
}
}
break;
case "ArrayPattern":
param.elements.forEach((element) => {
if (element) extractIdentifiers(element, nodes);
});
break;
case "RestElement":
extractIdentifiers(param.argument, nodes);
break;
case "AssignmentPattern":
extractIdentifiers(param.left, nodes);
break;
}
return nodes;
}
const isFunctionType = (node) => {
return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
};
const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
const TS_NODE_TYPES = (/* unused pure expression or super */ null && ([
"TSAsExpression",
// foo as number
"TSTypeAssertion",
// (<number>foo)
"TSNonNullExpression",
// foo!
"TSInstantiationExpression",
// foo<string>
"TSSatisfiesExpression"
// foo satisfies T
]));
function unwrapTSNode(node) {
if (TS_NODE_TYPES.includes(node.type)) {
return unwrapTSNode(node.expression);
} else {
return node;
}
}
const isStaticExp = (p) => p.type === 4 && p.isStatic;
function isCoreComponent(tag) {
switch (tag) {
case "Teleport":
case "teleport":
return TELEPORT;
case "Suspense":
case "suspense":
return SUSPENSE;
case "KeepAlive":
case "keep-alive":
return KEEP_ALIVE;
case "BaseTransition":
case "base-transition":
return BASE_TRANSITION;
}
}
const nonIdentifierRE = /^\d|[^\$\w\xA0-\uFFFF]/;
const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
const isMemberExpressionBrowser = (exp) => {
const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());
let state = 0 /* inMemberExp */;
let stateStack = [];
let currentOpenBracketCount = 0;
let currentOpenParensCount = 0;
let currentStringType = null;
for (let i = 0; i < path.length; i++) {
const char = path.charAt(i);
switch (state) {
case 0 /* inMemberExp */:
if (char === "[") {
stateStack.push(state);
state = 1 /* inBrackets */;
currentOpenBracketCount++;
} else if (char === "(") {
stateStack.push(state);
state = 2 /* inParens */;
currentOpenParensCount++;
} else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {
return false;
}
break;
case 1 /* inBrackets */:
if (char === `'` || char === `"` || char === "`") {
stateStack.push(state);
state = 3 /* inString */;
currentStringType = char;
} else if (char === `[`) {
currentOpenBracketCount++;
} else if (char === `]`) {
if (!--currentOpenBracketCount) {
state = stateStack.pop();
}
}
break;
case 2 /* inParens */:
if (char === `'` || char === `"` || char === "`") {
stateStack.push(state);
state = 3 /* inString */;
currentStringType = char;
} else if (char === `(`) {
currentOpenParensCount++;
} else if (char === `)`) {
if (i === path.length - 1) {
return false;
}
if (!--currentOpenParensCount) {
state = stateStack.pop();
}
}
break;
case 3 /* inString */:
if (char === currentStringType) {
state = stateStack.pop();
currentStringType = null;
}
break;
}
}
return !currentOpenBracketCount && !currentOpenParensCount;
};
const isMemberExpressionNode = (/* unused pure expression or super */ null && (NOOP)) ;
const isMemberExpression = isMemberExpressionBrowser ;
const fnExpRE = /^\s*(async\s*)?(\([^)]*?\)|[\w$_]+)\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));
const isFnExpressionNode = (/* unused pure expression or super */ null && (NOOP)) ;
const isFnExpression = isFnExpressionBrowser ;
function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
return advancePositionWithMutation(
{
offset: pos.offset,
line: pos.line,
column: pos.column
},
source,
numberOfCharacters
);
}
function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
let linesCount = 0;
let lastNewLinePos = -1;
for (let i = 0; i < numberOfCharacters; i++) {
if (source.charCodeAt(i) === 10) {
linesCount++;
lastNewLinePos = i;
}
}
pos.offset += numberOfCharacters;
pos.line += linesCount;
pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
return pos;
}
function assert(condition, msg) {
if (!condition) {
throw new Error(msg || `unexpected compiler condition`);
}
}
function findDir(node, name, allowEmpty = false) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7 && (allowEmpty || p.exp) && (shared_esm_bundler_isString(name) ? p.name === name : name.test(p.name))) {
return p;
}
}
}
function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 6) {
if (dynamicOnly) continue;
if (p.name === name && (p.value || allowEmpty)) {
return p;
}
} else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {
return p;
}
}
}
function isStaticArgOf(arg, name) {
return !!(arg && isStaticExp(arg) && arg.content === name);
}
function hasDynamicKeyVBind(node) {
return node.props.some(
(p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj"
p.arg.type !== 4 || // v-bind:[_ctx.foo]
!p.arg.isStatic)
// v-bind:[foo]
);
}
function isText$1(node) {
return node.type === 5 || node.type === 2;
}
function isVSlot(p) {
return p.type === 7 && p.name === "slot";
}
function isTemplateNode(node) {
return node.type === 1 && node.tagType === 3;
}
function isSlotOutlet(node) {
return node.type === 1 && node.tagType === 2;
}
const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
function getUnnormalizedProps(props, callPath = []) {
if (props && !shared_esm_bundler_isString(props) && props.type === 14) {
const callee = props.callee;
if (!shared_esm_bundler_isString(callee) && propsHelperSet.has(callee)) {
return getUnnormalizedProps(
props.arguments[0],
callPath.concat(props)
);
}
}
return [props, callPath];
}
function injectProp(node, prop, context) {
let propsWithInjection;
let props = node.type === 13 ? node.props : node.arguments[2];
let callPath = [];
let parentCall;
if (props && !shared_esm_bundler_isString(props) && props.type === 14) {
const ret = getUnnormalizedProps(props);
props = ret[0];
callPath = ret[1];
parentCall = callPath[callPath.length - 1];
}
if (props == null || shared_esm_bundler_isString(props)) {
propsWithInjection = createObjectExpression([prop]);
} else if (props.type === 14) {
const first = props.arguments[0];
if (!shared_esm_bundler_isString(first) && first.type === 15) {
if (!hasProp(prop, first)) {
first.properties.unshift(prop);
}
} else {
if (props.callee === TO_HANDLERS) {
propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
createObjectExpression([prop]),
props
]);
} else {
props.arguments.unshift(createObjectExpression([prop]));
}
}
!propsWithInjection && (propsWithInjection = props);
} else if (props.type === 15) {
if (!hasProp(prop, props)) {
props.properties.unshift(prop);
}
propsWithInjection = props;
} else {
propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
createObjectExpression([prop]),
props
]);
if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {
parentCall = callPath[callPath.length - 2];
}
}
if (node.type === 13) {
if (parentCall) {
parentCall.arguments[0] = propsWithInjection;
} else {
node.props = propsWithInjection;
}
} else {
if (parentCall) {
parentCall.arguments[0] = propsWithInjection;
} else {
node.arguments[2] = propsWithInjection;
}
}
}
function hasProp(prop, props) {
let result = false;
if (prop.key.type === 4) {
const propKeyName = prop.key.content;
result = props.properties.some(
(p) => p.key.type === 4 && p.key.content === propKeyName
);
}
return result;
}
function toValidAssetId(name, type) {
return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
})}`;
}
function hasScopeRef(node, ids) {
if (!node || Object.keys(ids).length === 0) {
return false;
}
switch (node.type) {
case 1:
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) {
return true;
}
}
return node.children.some((c) => hasScopeRef(c, ids));
case 11:
if (hasScopeRef(node.source, ids)) {
return true;
}
return node.children.some((c) => hasScopeRef(c, ids));
case 9:
return node.branches.some((b) => hasScopeRef(b, ids));
case 10:
if (hasScopeRef(node.condition, ids)) {
return true;
}
return node.children.some((c) => hasScopeRef(c, ids));
case 4:
return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];
case 8:
return node.children.some((c) => isObject(c) && hasScopeRef(c, ids));
case 5:
case 12:
return hasScopeRef(node.content, ids);
case 2:
case 3:
case 20:
return false;
default:
if (false) {}
return false;
}
}
function getMemoedVNodeCall(node) {
if (node.type === 14 && node.callee === WITH_MEMO) {
return node.arguments[1].returns;
} else {
return node;
}
}
const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
const defaultParserOptions = {
parseMode: "base",
ns: 0,
delimiters: [`{{`, `}}`],
getNamespace: () => 0,
isVoidTag: NO,
isPreTag: NO,
isIgnoreNewlineTag: NO,
isCustomElement: NO,
onError: defaultOnError,
onWarn: defaultOnWarn,
comments: !!("production" !== "production"),
prefixIdentifiers: false
};
let currentOptions = defaultParserOptions;
let currentRoot = null;
let currentInput = "";
let currentOpenTag = null;
let currentProp = null;
let currentAttrValue = "";
let currentAttrStartIndex = -1;
let currentAttrEndIndex = -1;
let inPre = 0;
let inVPre = false;
let currentVPreBoundary = null;
const compiler_core_esm_bundler_stack = [];
const tokenizer = new Tokenizer(compiler_core_esm_bundler_stack, {
onerr: emitError,
ontext(start, end) {
onText(getSlice(start, end), start, end);
},
ontextentity(char, start, end) {
onText(char, start, end);
},
oninterpolation(start, end) {
if (inVPre) {
return onText(getSlice(start, end), start, end);
}
let innerStart = start + tokenizer.delimiterOpen.length;
let innerEnd = end - tokenizer.delimiterClose.length;
while (isWhitespace(currentInput.charCodeAt(innerStart))) {
innerStart++;
}
while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) {
innerEnd--;
}
let exp = getSlice(innerStart, innerEnd);
if (exp.includes("&")) {
{
exp = currentOptions.decodeEntities(exp, false);
}
}
addNode({
type: 5,
content: createExp(exp, false, getLoc(innerStart, innerEnd)),
loc: getLoc(start, end)
});
},
onopentagname(start, end) {
const name = getSlice(start, end);
currentOpenTag = {
type: 1,
tag: name,
ns: currentOptions.getNamespace(name, compiler_core_esm_bundler_stack[0], currentOptions.ns),
tagType: 0,
// will be refined on tag close
props: [],
children: [],
loc: getLoc(start - 1, end),
codegenNode: void 0
};
},
onopentagend(end) {
endOpenTag(end);
},
onclosetag(start, end) {
const name = getSlice(start, end);
if (!currentOptions.isVoidTag(name)) {
let found = false;
for (let i = 0; i < compiler_core_esm_bundler_stack.length; i++) {
const e = compiler_core_esm_bundler_stack[i];
if (e.tag.toLowerCase() === name.toLowerCase()) {
found = true;
if (i > 0) {
emitError(24, compiler_core_esm_bundler_stack[0].loc.start.offset);
}
for (let j = 0; j <= i; j++) {
const el = compiler_core_esm_bundler_stack.shift();
onCloseTag(el, end, j < i);
}
break;
}
}
if (!found) {
emitError(23, backTrack(start, 60));
}
}
},
onselfclosingtag(end) {
const name = currentOpenTag.tag;
currentOpenTag.isSelfClosing = true;
endOpenTag(end);
if (compiler_core_esm_bundler_stack[0] && compiler_core_esm_bundler_stack[0].tag === name) {
onCloseTag(compiler_core_esm_bundler_stack.shift(), end);
}
},
onattribname(start, end) {
currentProp = {
type: 6,
name: getSlice(start, end),
nameLoc: getLoc(start, end),
value: void 0,
loc: getLoc(start)
};
},
ondirname(start, end) {
const raw = getSlice(start, end);
const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2);
if (!inVPre && name === "") {
emitError(26, start);
}
if (inVPre || name === "") {
currentProp = {
type: 6,
name: raw,
nameLoc: getLoc(start, end),
value: void 0,
loc: getLoc(start)
};
} else {
currentProp = {
type: 7,
name,
rawName: raw,
exp: void 0,
arg: void 0,
modifiers: raw === "." ? [createSimpleExpression("prop")] : [],
loc: getLoc(start)
};
if (name === "pre") {
inVPre = tokenizer.inVPre = true;
currentVPreBoundary = currentOpenTag;
const props = currentOpenTag.props;
for (let i = 0; i < props.length; i++) {
if (props[i].type === 7) {
props[i] = dirToAttr(props[i]);
}
}
}
}
},
ondirarg(start, end) {
if (start === end) return;
const arg = getSlice(start, end);
if (inVPre) {
currentProp.name += arg;
setLocEnd(currentProp.nameLoc, end);
} else {
const isStatic = arg[0] !== `[`;
currentProp.arg = createExp(
isStatic ? arg : arg.slice(1, -1),
isStatic,
getLoc(start, end),
isStatic ? 3 : 0
);
}
},
ondirmodifier(start, end) {
const mod = getSlice(start, end);
if (inVPre) {
currentProp.name += "." + mod;
setLocEnd(currentProp.nameLoc, end);
} else if (currentProp.name === "slot") {
const arg = currentProp.arg;
if (arg) {
arg.content += "." + mod;
setLocEnd(arg.loc, end);
}
} else {
const exp = createSimpleExpression(mod, true, getLoc(start, end));
currentProp.modifiers.push(exp);
}
},
onattribdata(start, end) {
currentAttrValue += getSlice(start, end);
if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
currentAttrEndIndex = end;
},
onattribentity(char, start, end) {
currentAttrValue += char;
if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
currentAttrEndIndex = end;
},
onattribnameend(end) {
const start = currentProp.loc.start.offset;
const name = getSlice(start, end);
if (currentProp.type === 7) {
currentProp.rawName = name;
}
if (currentOpenTag.props.some(
(p) => (p.type === 7 ? p.rawName : p.name) === name
)) {
emitError(2, start);
}
},
onattribend(quote, end) {
if (currentOpenTag && currentProp) {
setLocEnd(currentProp.loc, end);
if (quote !== 0) {
if (currentAttrValue.includes("&")) {
currentAttrValue = currentOptions.decodeEntities(
currentAttrValue,
true
);
}
if (currentProp.type === 6) {
if (currentProp.name === "class") {
currentAttrValue = condense(currentAttrValue).trim();
}
if (quote === 1 && !currentAttrValue) {
emitError(13, end);
}
currentProp.value = {
type: 2,
content: currentAttrValue,
loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)
};
if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") {
tokenizer.enterRCDATA(toCharCodes(`</template`), 0);
}
} else {
let expParseMode = 0 /* Normal */;
currentProp.exp = createExp(
currentAttrValue,
false,
getLoc(currentAttrStartIndex, currentAttrEndIndex),
0,
expParseMode
);
if (currentProp.name === "for") {
currentProp.forParseResult = parseForExpression(currentProp.exp);
}
let syncIndex = -1;
if (currentProp.name === "bind" && (syncIndex = currentProp.modifiers.findIndex(
(mod) => mod.content === "sync"
)) > -1 && checkCompatEnabled(
"COMPILER_V_BIND_SYNC",
currentOptions,
currentProp.loc,
currentProp.rawName
)) {
currentProp.name = "model";
currentProp.modifiers.splice(syncIndex, 1);
}
}
}
if (currentProp.type !== 7 || currentProp.name !== "pre") {
currentOpenTag.props.push(currentProp);
}
}
currentAttrValue = "";
currentAttrStartIndex = currentAttrEndIndex = -1;
},
oncomment(start, end) {
if (currentOptions.comments) {
addNode({
type: 3,
content: getSlice(start, end),
loc: getLoc(start - 4, end + 3)
});
}
},
onend() {
const end = currentInput.length;
if (false) {}
for (let index = 0; index < compiler_core_esm_bundler_stack.length; index++) {
onCloseTag(compiler_core_esm_bundler_stack[index], end - 1);
emitError(24, compiler_core_esm_bundler_stack[index].loc.start.offset);
}
},
oncdata(start, end) {
if (compiler_core_esm_bundler_stack[0].ns !== 0) {
onText(getSlice(start, end), start, end);
} else {
emitError(1, start - 9);
}
},
onprocessinginstruction(start) {
if ((compiler_core_esm_bundler_stack[0] ? compiler_core_esm_bundler_stack[0].ns : currentOptions.ns) === 0) {
emitError(
21,
start - 1
);
}
}
});
const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
const stripParensRE = /^\(|\)$/g;
function parseForExpression(input) {
const loc = input.loc;
const exp = input.content;
const inMatch = exp.match(forAliasRE);
if (!inMatch) return;
const [, LHS, RHS] = inMatch;
const createAliasExpression = (content, offset, asParam = false) => {
const start = loc.start.offset + offset;
const end = start + content.length;
return createExp(
content,
false,
getLoc(start, end),
0,
asParam ? 1 /* Params */ : 0 /* Normal */
);
};
const result = {
source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),
value: void 0,
key: void 0,
index: void 0,
finalized: false
};
let valueContent = LHS.trim().replace(stripParensRE, "").trim();
const trimmedOffset = LHS.indexOf(valueContent);
const iteratorMatch = valueContent.match(forIteratorRE);
if (iteratorMatch) {
valueContent = valueContent.replace(forIteratorRE, "").trim();
const keyContent = iteratorMatch[1].trim();
let keyOffset;
if (keyContent) {
keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
result.key = createAliasExpression(keyContent, keyOffset, true);
}
if (iteratorMatch[2]) {
const indexContent = iteratorMatch[2].trim();
if (indexContent) {
result.index = createAliasExpression(
indexContent,
exp.indexOf(
indexContent,
result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
),
true
);
}
}
}
if (valueContent) {
result.value = createAliasExpression(valueContent, trimmedOffset, true);
}
return result;
}
function getSlice(start, end) {
return currentInput.slice(start, end);
}
function endOpenTag(end) {
if (tokenizer.inSFCRoot) {
currentOpenTag.innerLoc = getLoc(end + 1, end + 1);
}
addNode(currentOpenTag);
const { tag, ns } = currentOpenTag;
if (ns === 0 && currentOptions.isPreTag(tag)) {
inPre++;
}
if (currentOptions.isVoidTag(tag)) {
onCloseTag(currentOpenTag, end);
} else {
compiler_core_esm_bundler_stack.unshift(currentOpenTag);
if (ns === 1 || ns === 2) {
tokenizer.inXML = true;
}
}
currentOpenTag = null;
}
function onText(content, start, end) {
{
const tag = compiler_core_esm_bundler_stack[0] && compiler_core_esm_bundler_stack[0].tag;
if (tag !== "script" && tag !== "style" && content.includes("&")) {
content = currentOptions.decodeEntities(content, false);
}
}
const parent = compiler_core_esm_bundler_stack[0] || currentRoot;
const lastNode = parent.children[parent.children.length - 1];
if (lastNode && lastNode.type === 2) {
lastNode.content += content;
setLocEnd(lastNode.loc, end);
} else {
parent.children.push({
type: 2,
content,
loc: getLoc(start, end)
});
}
}
function onCloseTag(el, end, isImplied = false) {
if (isImplied) {
setLocEnd(el.loc, backTrack(end, 60));
} else {
setLocEnd(el.loc, lookAhead(end, 62) + 1);
}
if (tokenizer.inSFCRoot) {
if (el.children.length) {
el.innerLoc.end = shared_esm_bundler_extend({}, el.children[el.children.length - 1].loc.end);
} else {
el.innerLoc.end = shared_esm_bundler_extend({}, el.innerLoc.start);
}
el.innerLoc.source = getSlice(
el.innerLoc.start.offset,
el.innerLoc.end.offset
);
}
const { tag, ns, children } = el;
if (!inVPre) {
if (tag === "slot") {
el.tagType = 2;
} else if (isFragmentTemplate(el)) {
el.tagType = 3;
} else if (isComponent(el)) {
el.tagType = 1;
}
}
if (!tokenizer.inRCDATA) {
el.children = condenseWhitespace(children);
}
if (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) {
const first = children[0];
if (first && first.type === 2) {
first.content = first.content.replace(/^\r?\n/, "");
}
}
if (ns === 0 && currentOptions.isPreTag(tag)) {
inPre--;
}
if (currentVPreBoundary === el) {
inVPre = tokenizer.inVPre = false;
currentVPreBoundary = null;
}
if (tokenizer.inXML && (compiler_core_esm_bundler_stack[0] ? compiler_core_esm_bundler_stack[0].ns : currentOptions.ns) === 0) {
tokenizer.inXML = false;
}
{
const props = el.props;
if (false) {}
if (!tokenizer.inSFCRoot && isCompatEnabled(
"COMPILER_NATIVE_TEMPLATE",
currentOptions
) && el.tag === "template" && !isFragmentTemplate(el)) {
false && 0;
const parent = compiler_core_esm_bundler_stack[0] || currentRoot;
const index = parent.children.indexOf(el);
parent.children.splice(index, 1, ...el.children);
}
const inlineTemplateProp = props.find(
(p) => p.type === 6 && p.name === "inline-template"
);
if (inlineTemplateProp && checkCompatEnabled(
"COMPILER_INLINE_TEMPLATE",
currentOptions,
inlineTemplateProp.loc
) && el.children.length) {
inlineTemplateProp.value = {
type: 2,
content: getSlice(
el.children[0].loc.start.offset,
el.children[el.children.length - 1].loc.end.offset
),
loc: inlineTemplateProp.loc
};
}
}
}
function lookAhead(index, c) {
let i = index;
while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;
return i;
}
function backTrack(index, c) {
let i = index;
while (currentInput.charCodeAt(i) !== c && i >= 0) i--;
return i;
}
const specialTemplateDir = /* @__PURE__ */ new Set(["if", "else", "else-if", "for", "slot"]);
function isFragmentTemplate({ tag, props }) {
if (tag === "template") {
for (let i = 0; i < props.length; i++) {
if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) {
return true;
}
}
}
return false;
}
function isComponent({ tag, props }) {
if (currentOptions.isCustomElement(tag)) {
return false;
}
if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) {
return true;
}
for (let i = 0; i < props.length; i++) {
const p = props[i];
if (p.type === 6) {
if (p.name === "is" && p.value) {
if (p.value.content.startsWith("vue:")) {
return true;
} else if (checkCompatEnabled(
"COMPILER_IS_ON_ELEMENT",
currentOptions,
p.loc
)) {
return true;
}
}
} else if (// :is on plain element - only treat as component in compat mode
p.name === "bind" && isStaticArgOf(p.arg, "is") && checkCompatEnabled(
"COMPILER_IS_ON_ELEMENT",
currentOptions,
p.loc
)) {
return true;
}
}
return false;
}
function isUpperCase(c) {
return c > 64 && c < 91;
}
const windowsNewlineRE = /\r\n/g;
function condenseWhitespace(nodes, tag) {
const shouldCondense = currentOptions.whitespace !== "preserve";
let removedWhitespace = false;
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (node.type === 2) {
if (!inPre) {
if (isAllWhitespace(node.content)) {
const prev = nodes[i - 1] && nodes[i - 1].type;
const next = nodes[i + 1] && nodes[i + 1].type;
if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {
removedWhitespace = true;
nodes[i] = null;
} else {
node.content = " ";
}
} else if (shouldCondense) {
node.content = condense(node.content);
}
} else {
node.content = node.content.replace(windowsNewlineRE, "\n");
}
}
}
return removedWhitespace ? nodes.filter(Boolean) : nodes;
}
function isAllWhitespace(str) {
for (let i = 0; i < str.length; i++) {
if (!isWhitespace(str.charCodeAt(i))) {
return false;
}
}
return true;
}
function hasNewlineChar(str) {
for (let i = 0; i < str.length; i++) {
const c = str.charCodeAt(i);
if (c === 10 || c === 13) {
return true;
}
}
return false;
}
function condense(str) {
let ret = "";
let prevCharIsWhitespace = false;
for (let i = 0; i < str.length; i++) {
if (isWhitespace(str.charCodeAt(i))) {
if (!prevCharIsWhitespace) {
ret += " ";
prevCharIsWhitespace = true;
}
} else {
ret += str[i];
prevCharIsWhitespace = false;
}
}
return ret;
}
function addNode(node) {
(compiler_core_esm_bundler_stack[0] || currentRoot).children.push(node);
}
function getLoc(start, end) {
return {
start: tokenizer.getPos(start),
// @ts-expect-error allow late attachment
end: end == null ? end : tokenizer.getPos(end),
// @ts-expect-error allow late attachment
source: end == null ? end : getSlice(start, end)
};
}
function cloneLoc(loc) {
return getLoc(loc.start.offset, loc.end.offset);
}
function setLocEnd(loc, end) {
loc.end = tokenizer.getPos(end);
loc.source = getSlice(loc.start.offset, end);
}
function dirToAttr(dir) {
const attr = {
type: 6,
name: dir.rawName,
nameLoc: getLoc(
dir.loc.start.offset,
dir.loc.start.offset + dir.rawName.length
),
value: void 0,
loc: dir.loc
};
if (dir.exp) {
const loc = dir.exp.loc;
if (loc.end.offset < dir.loc.end.offset) {
loc.start.offset--;
loc.start.column--;
loc.end.offset++;
loc.end.column++;
}
attr.value = {
type: 2,
content: dir.exp.content,
loc
};
}
return attr;
}
function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0 /* Normal */) {
const exp = createSimpleExpression(content, isStatic, loc, constType);
return exp;
}
function emitError(code, index, message) {
currentOptions.onError(
createCompilerError(code, getLoc(index, index), void 0, message)
);
}
function compiler_core_esm_bundler_reset() {
tokenizer.reset();
currentOpenTag = null;
currentProp = null;
currentAttrValue = "";
currentAttrStartIndex = -1;
currentAttrEndIndex = -1;
compiler_core_esm_bundler_stack.length = 0;
}
function compiler_core_esm_bundler_baseParse(input, options) {
compiler_core_esm_bundler_reset();
currentInput = input;
currentOptions = shared_esm_bundler_extend({}, defaultParserOptions);
if (options) {
let key;
for (key in options) {
if (options[key] != null) {
currentOptions[key] = options[key];
}
}
}
if (false) {}
tokenizer.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0;
tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2;
const delimiters = options && options.delimiters;
if (delimiters) {
tokenizer.delimiterOpen = toCharCodes(delimiters[0]);
tokenizer.delimiterClose = toCharCodes(delimiters[1]);
}
const root = currentRoot = createRoot([], input);
tokenizer.parse(currentInput);
root.loc = getLoc(0, input.length);
root.children = condenseWhitespace(root.children);
currentRoot = null;
return root;
}
function cacheStatic(root, context) {
walk(
root,
void 0,
context,
// Root node is unfortunately non-hoistable due to potential parent
// fallthrough attributes.
isSingleElementRoot(root, root.children[0])
);
}
function isSingleElementRoot(root, child) {
const { children } = root;
return children.length === 1 && child.type === 1 && !isSlotOutlet(child);
}
function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
const { children } = node;
const toCache = [];
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (child.type === 1 && child.tagType === 0) {
const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
if (constantType > 0) {
if (constantType >= 2) {
child.codegenNode.patchFlag = -1;
toCache.push(child);
continue;
}
} else {
const codegenNode = child.codegenNode;
if (codegenNode.type === 13) {
const flag = codegenNode.patchFlag;
if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
const props = getNodeProps(child);
if (props) {
codegenNode.props = context.hoist(props);
}
}
if (codegenNode.dynamicProps) {
codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);
}
}
}
} else if (child.type === 12) {
const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
if (constantType >= 2) {
toCache.push(child);
continue;
}
}
if (child.type === 1) {
const isComponent = child.tagType === 1;
if (isComponent) {
context.scopes.vSlot++;
}
walk(child, node, context, false, inFor);
if (isComponent) {
context.scopes.vSlot--;
}
} else if (child.type === 11) {
walk(child, node, context, child.children.length === 1, true);
} else if (child.type === 9) {
for (let i2 = 0; i2 < child.branches.length; i2++) {
walk(
child.branches[i2],
node,
context,
child.branches[i2].children.length === 1,
inFor
);
}
}
}
let cachedAsArray = false;
if (toCache.length === children.length && node.type === 1) {
if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && shared_esm_bundler_isArray(node.codegenNode.children)) {
node.codegenNode.children = getCacheExpression(
createArrayExpression(node.codegenNode.children)
);
cachedAsArray = true;
} else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !shared_esm_bundler_isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {
const slot = getSlotNode(node.codegenNode, "default");
if (slot) {
slot.returns = getCacheExpression(
createArrayExpression(slot.returns)
);
cachedAsArray = true;
}
} else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared_esm_bundler_isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 15) {
const slotName = findDir(node, "slot", true);
const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg);
if (slot) {
slot.returns = getCacheExpression(
createArrayExpression(slot.returns)
);
cachedAsArray = true;
}
}
}
if (!cachedAsArray) {
for (const child of toCache) {
child.codegenNode = context.cache(child.codegenNode);
}
}
function getCacheExpression(value) {
const exp = context.cache(value);
if (inFor && context.hmr) {
exp.needArraySpread = true;
}
return exp;
}
function getSlotNode(node2, name) {
if (node2.children && !shared_esm_bundler_isArray(node2.children) && node2.children.type === 15) {
const slot = node2.children.properties.find(
(p) => p.key === name || p.key.content === name
);
return slot && slot.value;
}
}
if (toCache.length && context.transformHoist) {
context.transformHoist(children, context, node);
}
}
function getConstantType(node, context) {
const { constantCache } = context;
switch (node.type) {
case 1:
if (node.tagType !== 0) {
return 0;
}
const cached = constantCache.get(node);
if (cached !== void 0) {
return cached;
}
const codegenNode = node.codegenNode;
if (codegenNode.type !== 13) {
return 0;
}
if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject" && node.tag !== "math") {
return 0;
}
if (codegenNode.patchFlag === void 0) {
let returnType2 = 3;
const generatedPropsType = getGeneratedPropsConstantType(node, context);
if (generatedPropsType === 0) {
constantCache.set(node, 0);
return 0;
}
if (generatedPropsType < returnType2) {
returnType2 = generatedPropsType;
}
for (let i = 0; i < node.children.length; i++) {
const childType = getConstantType(node.children[i], context);
if (childType === 0) {
constantCache.set(node, 0);
return 0;
}
if (childType < returnType2) {
returnType2 = childType;
}
}
if (returnType2 > 1) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7 && p.name === "bind" && p.exp) {
const expType = getConstantType(p.exp, context);
if (expType === 0) {
constantCache.set(node, 0);
return 0;
}
if (expType < returnType2) {
returnType2 = expType;
}
}
}
}
if (codegenNode.isBlock) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7) {
constantCache.set(node, 0);
return 0;
}
}
context.removeHelper(OPEN_BLOCK);
context.removeHelper(
getVNodeBlockHelper(context.inSSR, codegenNode.isComponent)
);
codegenNode.isBlock = false;
context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));
}
constantCache.set(node, returnType2);
return returnType2;
} else {
constantCache.set(node, 0);
return 0;
}
case 2:
case 3:
return 3;
case 9:
case 11:
case 10:
return 0;
case 5:
case 12:
return getConstantType(node.content, context);
case 4:
return node.constType;
case 8:
let returnType = 3;
for (let i = 0; i < node.children.length; i++) {
const child = node.children[i];
if (shared_esm_bundler_isString(child) || isSymbol(child)) {
continue;
}
const childType = getConstantType(child, context);
if (childType === 0) {
return 0;
} else if (childType < returnType) {
returnType = childType;
}
}
return returnType;
case 20:
return 2;
default:
if (false) {}
return 0;
}
}
const allowHoistedHelperSet = /* @__PURE__ */ new Set([
NORMALIZE_CLASS,
NORMALIZE_STYLE,
NORMALIZE_PROPS,
GUARD_REACTIVE_PROPS
]);
function getConstantTypeOfHelperCall(value, context) {
if (value.type === 14 && !shared_esm_bundler_isString(value.callee) && allowHoistedHelperSet.has(value.callee)) {
const arg = value.arguments[0];
if (arg.type === 4) {
return getConstantType(arg, context);
} else if (arg.type === 14) {
return getConstantTypeOfHelperCall(arg, context);
}
}
return 0;
}
function getGeneratedPropsConstantType(node, context) {
let returnType = 3;
const props = getNodeProps(node);
if (props && props.type === 15) {
const { properties } = props;
for (let i = 0; i < properties.length; i++) {
const { key, value } = properties[i];
const keyType = getConstantType(key, context);
if (keyType === 0) {
return keyType;
}
if (keyType < returnType) {
returnType = keyType;
}
let valueType;
if (value.type === 4) {
valueType = getConstantType(value, context);
} else if (value.type === 14) {
valueType = getConstantTypeOfHelperCall(value, context);
} else {
valueType = 0;
}
if (valueType === 0) {
return valueType;
}
if (valueType < returnType) {
returnType = valueType;
}
}
}
return returnType;
}
function getNodeProps(node) {
const codegenNode = node.codegenNode;
if (codegenNode.type === 13) {
return codegenNode.props;
}
}
function createTransformContext(root, {
filename = "",
prefixIdentifiers = false,
hoistStatic = false,
hmr = false,
cacheHandlers = false,
nodeTransforms = [],
directiveTransforms = {},
transformHoist = null,
isBuiltInComponent = shared_esm_bundler_NOOP,
isCustomElement = shared_esm_bundler_NOOP,
expressionPlugins = [],
scopeId = null,
slotted = true,
ssr = false,
inSSR = false,
ssrCssVars = ``,
bindingMetadata = EMPTY_OBJ,
inline = false,
isTS = false,
onError = defaultOnError,
onWarn = defaultOnWarn,
compatConfig
}) {
const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
const context = {
// options
filename,
selfName: nameMatch && shared_esm_bundler_capitalize(shared_esm_bundler_camelize(nameMatch[1])),
prefixIdentifiers,
hoistStatic,
hmr,
cacheHandlers,
nodeTransforms,
directiveTransforms,
transformHoist,
isBuiltInComponent,
isCustomElement,
expressionPlugins,
scopeId,
slotted,
ssr,
inSSR,
ssrCssVars,
bindingMetadata,
inline,
isTS,
onError,
onWarn,
compatConfig,
// state
root,
helpers: /* @__PURE__ */ new Map(),
components: /* @__PURE__ */ new Set(),
directives: /* @__PURE__ */ new Set(),
hoists: [],
imports: [],
cached: [],
constantCache: /* @__PURE__ */ new WeakMap(),
temps: 0,
identifiers: /* @__PURE__ */ Object.create(null),
scopes: {
vFor: 0,
vSlot: 0,
vPre: 0,
vOnce: 0
},
parent: null,
grandParent: null,
currentNode: root,
childIndex: 0,
inVOnce: false,
// methods
helper(name) {
const count = context.helpers.get(name) || 0;
context.helpers.set(name, count + 1);
return name;
},
removeHelper(name) {
const count = context.helpers.get(name);
if (count) {
const currentCount = count - 1;
if (!currentCount) {
context.helpers.delete(name);
} else {
context.helpers.set(name, currentCount);
}
}
},
helperString(name) {
return `_${helperNameMap[context.helper(name)]}`;
},
replaceNode(node) {
if (false) {}
context.parent.children[context.childIndex] = context.currentNode = node;
},
removeNode(node) {
if (false) {}
const list = context.parent.children;
const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;
if (false) {}
if (!node || node === context.currentNode) {
context.currentNode = null;
context.onNodeRemoved();
} else {
if (context.childIndex > removalIndex) {
context.childIndex--;
context.onNodeRemoved();
}
}
context.parent.children.splice(removalIndex, 1);
},
onNodeRemoved: shared_esm_bundler_NOOP,
addIdentifiers(exp) {
},
removeIdentifiers(exp) {
},
hoist(exp) {
if (shared_esm_bundler_isString(exp)) exp = createSimpleExpression(exp);
context.hoists.push(exp);
const identifier = createSimpleExpression(
`_hoisted_${context.hoists.length}`,
false,
exp.loc,
2
);
identifier.hoisted = exp;
return identifier;
},
cache(exp, isVNode = false, inVOnce = false) {
const cacheExp = createCacheExpression(
context.cached.length,
exp,
isVNode,
inVOnce
);
context.cached.push(cacheExp);
return cacheExp;
}
};
{
context.filters = /* @__PURE__ */ new Set();
}
return context;
}
function transform(root, options) {
const context = createTransformContext(root, options);
traverseNode(root, context);
if (options.hoistStatic) {
cacheStatic(root, context);
}
if (!options.ssr) {
createRootCodegen(root, context);
}
root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);
root.components = [...context.components];
root.directives = [...context.directives];
root.imports = context.imports;
root.hoists = context.hoists;
root.temps = context.temps;
root.cached = context.cached;
root.transformed = true;
{
root.filters = [...context.filters];
}
}
function createRootCodegen(root, context) {
const { helper } = context;
const { children } = root;
if (children.length === 1) {
const child = children[0];
if (isSingleElementRoot(root, child) && child.codegenNode) {
const codegenNode = child.codegenNode;
if (codegenNode.type === 13) {
convertToBlock(codegenNode, context);
}
root.codegenNode = codegenNode;
} else {
root.codegenNode = child;
}
} else if (children.length > 1) {
let patchFlag = 64;
if (false) {}
root.codegenNode = createVNodeCall(
context,
helper(FRAGMENT),
void 0,
root.children,
patchFlag,
void 0,
void 0,
true,
void 0,
false
);
} else ;
}
function traverseChildren(parent, context) {
let i = 0;
const nodeRemoved = () => {
i--;
};
for (; i < parent.children.length; i++) {
const child = parent.children[i];
if (shared_esm_bundler_isString(child)) continue;
context.grandParent = context.parent;
context.parent = parent;
context.childIndex = i;
context.onNodeRemoved = nodeRemoved;
traverseNode(child, context);
}
}
function traverseNode(node, context) {
context.currentNode = node;
const { nodeTransforms } = context;
const exitFns = [];
for (let i2 = 0; i2 < nodeTransforms.length; i2++) {
const onExit = nodeTransforms[i2](node, context);
if (onExit) {
if (shared_esm_bundler_isArray(onExit)) {
exitFns.push(...onExit);
} else {
exitFns.push(onExit);
}
}
if (!context.currentNode) {
return;
} else {
node = context.currentNode;
}
}
switch (node.type) {
case 3:
if (!context.ssr) {
context.helper(CREATE_COMMENT);
}
break;
case 5:
if (!context.ssr) {
context.helper(TO_DISPLAY_STRING);
}
break;
// for container types, further traverse downwards
case 9:
for (let i2 = 0; i2 < node.branches.length; i2++) {
traverseNode(node.branches[i2], context);
}
break;
case 10:
case 11:
case 1:
case 0:
traverseChildren(node, context);
break;
}
context.currentNode = node;
let i = exitFns.length;
while (i--) {
exitFns[i]();
}
}
function createStructuralDirectiveTransform(name, fn) {
const matches = shared_esm_bundler_isString(name) ? (n) => n === name : (n) => name.test(n);
return (node, context) => {
if (node.type === 1) {
const { props } = node;
if (node.tagType === 3 && props.some(isVSlot)) {
return;
}
const exitFns = [];
for (let i = 0; i < props.length; i++) {
const prop = props[i];
if (prop.type === 7 && matches(prop.name)) {
props.splice(i, 1);
i--;
const onExit = fn(node, prop, context);
if (onExit) exitFns.push(onExit);
}
}
return exitFns;
}
};
}
const PURE_ANNOTATION = `/*@__PURE__*/`;
const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
function createCodegenContext(ast, {
mode = "function",
prefixIdentifiers = mode === "module",
sourceMap = false,
filename = `template.vue.html`,
scopeId = null,
optimizeImports = false,
runtimeGlobalName = `Vue`,
runtimeModuleName = `vue`,
ssrRuntimeModuleName = "vue/server-renderer",
ssr = false,
isTS = false,
inSSR = false
}) {
const context = {
mode,
prefixIdentifiers,
sourceMap,
filename,
scopeId,
optimizeImports,
runtimeGlobalName,
runtimeModuleName,
ssrRuntimeModuleName,
ssr,
isTS,
inSSR,
source: ast.source,
code: ``,
column: 1,
line: 1,
offset: 0,
indentLevel: 0,
pure: false,
map: void 0,
helper(key) {
return `_${helperNameMap[key]}`;
},
push(code, newlineIndex = -2 /* None */, node) {
context.code += code;
},
indent() {
newline(++context.indentLevel);
},
deindent(withoutNewLine = false) {
if (withoutNewLine) {
--context.indentLevel;
} else {
newline(--context.indentLevel);
}
},
newline() {
newline(context.indentLevel);
}
};
function newline(n) {
context.push("\n" + ` `.repeat(n), 0 /* Start */);
}
return context;
}
function generate(ast, options = {}) {
const context = createCodegenContext(ast, options);
if (options.onContextCreated) options.onContextCreated(context);
const {
mode,
push,
prefixIdentifiers,
indent,
deindent,
newline,
scopeId,
ssr
} = context;
const helpers = Array.from(ast.helpers);
const hasHelpers = helpers.length > 0;
const useWithBlock = !prefixIdentifiers && mode !== "module";
const preambleContext = context;
{
genFunctionPreamble(ast, preambleContext);
}
const functionName = ssr ? `ssrRender` : `render`;
const args = ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"];
const signature = args.join(", ");
{
push(`function ${functionName}(${signature}) {`);
}
indent();
if (useWithBlock) {
push(`with (_ctx) {`);
indent();
if (hasHelpers) {
push(
`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue
`,
-1 /* End */
);
newline();
}
}
if (ast.components.length) {
genAssets(ast.components, "component", context);
if (ast.directives.length || ast.temps > 0) {
newline();
}
}
if (ast.directives.length) {
genAssets(ast.directives, "directive", context);
if (ast.temps > 0) {
newline();
}
}
if (ast.filters && ast.filters.length) {
newline();
genAssets(ast.filters, "filter", context);
newline();
}
if (ast.temps > 0) {
push(`let `);
for (let i = 0; i < ast.temps; i++) {
push(`${i > 0 ? `, ` : ``}_temp${i}`);
}
}
if (ast.components.length || ast.directives.length || ast.temps) {
push(`
`, 0 /* Start */);
newline();
}
if (!ssr) {
push(`return `);
}
if (ast.codegenNode) {
genNode(ast.codegenNode, context);
} else {
push(`null`);
}
if (useWithBlock) {
deindent();
push(`}`);
}
deindent();
push(`}`);
return {
ast,
code: context.code,
preamble: ``,
map: context.map ? context.map.toJSON() : void 0
};
}
function genFunctionPreamble(ast, context) {
const {
ssr,
prefixIdentifiers,
push,
newline,
runtimeModuleName,
runtimeGlobalName,
ssrRuntimeModuleName
} = context;
const VueBinding = runtimeGlobalName;
const helpers = Array.from(ast.helpers);
if (helpers.length > 0) {
{
push(`const _Vue = ${VueBinding}
`, -1 /* End */);
if (ast.hoists.length) {
const staticHelpers = [
CREATE_VNODE,
CREATE_ELEMENT_VNODE,
CREATE_COMMENT,
CREATE_TEXT,
CREATE_STATIC
].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", ");
push(`const { ${staticHelpers} } = _Vue
`, -1 /* End */);
}
}
}
genHoists(ast.hoists, context);
newline();
push(`return `);
}
function genAssets(assets, type, { helper, push, newline, isTS }) {
const resolver = helper(
type === "filter" ? RESOLVE_FILTER : type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE
);
for (let i = 0; i < assets.length; i++) {
let id = assets[i];
const maybeSelfReference = id.endsWith("__self");
if (maybeSelfReference) {
id = id.slice(0, -6);
}
push(
`const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`
);
if (i < assets.length - 1) {
newline();
}
}
}
function genHoists(hoists, context) {
if (!hoists.length) {
return;
}
context.pure = true;
const { push, newline } = context;
newline();
for (let i = 0; i < hoists.length; i++) {
const exp = hoists[i];
if (exp) {
push(`const _hoisted_${i + 1} = `);
genNode(exp, context);
newline();
}
}
context.pure = false;
}
function isText(n) {
return isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;
}
function genNodeListAsArray(nodes, context) {
const multilines = nodes.length > 3 || false && 0;
context.push(`[`);
multilines && context.indent();
genNodeList(nodes, context, multilines);
multilines && context.deindent();
context.push(`]`);
}
function genNodeList(nodes, context, multilines = false, comma = true) {
const { push, newline } = context;
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (shared_esm_bundler_isString(node)) {
push(node, -3 /* Unknown */);
} else if (shared_esm_bundler_isArray(node)) {
genNodeListAsArray(node, context);
} else {
genNode(node, context);
}
if (i < nodes.length - 1) {
if (multilines) {
comma && push(",");
newline();
} else {
comma && push(", ");
}
}
}
}
function genNode(node, context) {
if (shared_esm_bundler_isString(node)) {
context.push(node, -3 /* Unknown */);
return;
}
if (isSymbol(node)) {
context.push(context.helper(node));
return;
}
switch (node.type) {
case 1:
case 9:
case 11:
false && 0;
genNode(node.codegenNode, context);
break;
case 2:
genText(node, context);
break;
case 4:
genExpression(node, context);
break;
case 5:
genInterpolation(node, context);
break;
case 12:
genNode(node.codegenNode, context);
break;
case 8:
genCompoundExpression(node, context);
break;
case 3:
genComment(node, context);
break;
case 13:
genVNodeCall(node, context);
break;
case 14:
genCallExpression(node, context);
break;
case 15:
genObjectExpression(node, context);
break;
case 17:
genArrayExpression(node, context);
break;
case 18:
genFunctionExpression(node, context);
break;
case 19:
genConditionalExpression(node, context);
break;
case 20:
genCacheExpression(node, context);
break;
case 21:
genNodeList(node.body, context, true, false);
break;
// SSR only types
case 22:
break;
case 23:
break;
case 24:
break;
case 25:
break;
case 26:
break;
/* v8 ignore start */
case 10:
break;
default:
if (false) {}
}
}
function genText(node, context) {
context.push(JSON.stringify(node.content), -3 /* Unknown */, node);
}
function genExpression(node, context) {
const { content, isStatic } = node;
context.push(
isStatic ? JSON.stringify(content) : content,
-3 /* Unknown */,
node
);
}
function genInterpolation(node, context) {
const { push, helper, pure } = context;
if (pure) push(PURE_ANNOTATION);
push(`${helper(TO_DISPLAY_STRING)}(`);
genNode(node.content, context);
push(`)`);
}
function genCompoundExpression(node, context) {
for (let i = 0; i < node.children.length; i++) {
const child = node.children[i];
if (shared_esm_bundler_isString(child)) {
context.push(child, -3 /* Unknown */);
} else {
genNode(child, context);
}
}
}
function genExpressionAsPropertyKey(node, context) {
const { push } = context;
if (node.type === 8) {
push(`[`);
genCompoundExpression(node, context);
push(`]`);
} else if (node.isStatic) {
const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content);
push(text, -2 /* None */, node);
} else {
push(`[${node.content}]`, -3 /* Unknown */, node);
}
}
function genComment(node, context) {
const { push, helper, pure } = context;
if (pure) {
push(PURE_ANNOTATION);
}
push(
`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`,
-3 /* Unknown */,
node
);
}
function genVNodeCall(node, context) {
const { push, helper, pure } = context;
const {
tag,
props,
children,
patchFlag,
dynamicProps,
directives,
isBlock,
disableTracking,
isComponent
} = node;
let patchFlagString;
if (patchFlag) {
if (false) {} else {
patchFlagString = String(patchFlag);
}
}
if (directives) {
push(helper(WITH_DIRECTIVES) + `(`);
}
if (isBlock) {
push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
}
if (pure) {
push(PURE_ANNOTATION);
}
const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);
push(helper(callHelper) + `(`, -2 /* None */, node);
genNodeList(
genNullableArgs([tag, props, children, patchFlagString, dynamicProps]),
context
);
push(`)`);
if (isBlock) {
push(`)`);
}
if (directives) {
push(`, `);
genNode(directives, context);
push(`)`);
}
}
function genNullableArgs(args) {
let i = args.length;
while (i--) {
if (args[i] != null) break;
}
return args.slice(0, i + 1).map((arg) => arg || `null`);
}
function genCallExpression(node, context) {
const { push, helper, pure } = context;
const callee = shared_esm_bundler_isString(node.callee) ? node.callee : helper(node.callee);
if (pure) {
push(PURE_ANNOTATION);
}
push(callee + `(`, -2 /* None */, node);
genNodeList(node.arguments, context);
push(`)`);
}
function genObjectExpression(node, context) {
const { push, indent, deindent, newline } = context;
const { properties } = node;
if (!properties.length) {
push(`{}`, -2 /* None */, node);
return;
}
const multilines = properties.length > 1 || false && 0;
push(multilines ? `{` : `{ `);
multilines && indent();
for (let i = 0; i < properties.length; i++) {
const { key, value } = properties[i];
genExpressionAsPropertyKey(key, context);
push(`: `);
genNode(value, context);
if (i < properties.length - 1) {
push(`,`);
newline();
}
}
multilines && deindent();
push(multilines ? `}` : ` }`);
}
function genArrayExpression(node, context) {
genNodeListAsArray(node.elements, context);
}
function genFunctionExpression(node, context) {
const { push, indent, deindent } = context;
const { params, returns, body, newline, isSlot } = node;
if (isSlot) {
push(`_${helperNameMap[WITH_CTX]}(`);
}
push(`(`, -2 /* None */, node);
if (shared_esm_bundler_isArray(params)) {
genNodeList(params, context);
} else if (params) {
genNode(params, context);
}
push(`) => `);
if (newline || body) {
push(`{`);
indent();
}
if (returns) {
if (newline) {
push(`return `);
}
if (shared_esm_bundler_isArray(returns)) {
genNodeListAsArray(returns, context);
} else {
genNode(returns, context);
}
} else if (body) {
genNode(body, context);
}
if (newline || body) {
deindent();
push(`}`);
}
if (isSlot) {
if (node.isNonScopedSlot) {
push(`, undefined, true`);
}
push(`)`);
}
}
function genConditionalExpression(node, context) {
const { test, consequent, alternate, newline: needNewline } = node;
const { push, indent, deindent, newline } = context;
if (test.type === 4) {
const needsParens = !isSimpleIdentifier(test.content);
needsParens && push(`(`);
genExpression(test, context);
needsParens && push(`)`);
} else {
push(`(`);
genNode(test, context);
push(`)`);
}
needNewline && indent();
context.indentLevel++;
needNewline || push(` `);
push(`? `);
genNode(consequent, context);
context.indentLevel--;
needNewline && newline();
needNewline || push(` `);
push(`: `);
const isNested = alternate.type === 19;
if (!isNested) {
context.indentLevel++;
}
genNode(alternate, context);
if (!isNested) {
context.indentLevel--;
}
needNewline && deindent(
true
/* without newline */
);
}
function genCacheExpression(node, context) {
const { push, helper, indent, deindent, newline } = context;
const { needPauseTracking, needArraySpread } = node;
if (needArraySpread) {
push(`[...(`);
}
push(`_cache[${node.index}] || (`);
if (needPauseTracking) {
indent();
push(`${helper(SET_BLOCK_TRACKING)}(-1`);
if (node.inVOnce) push(`, true`);
push(`),`);
newline();
push(`(`);
}
push(`_cache[${node.index}] = `);
genNode(node.value, context);
if (needPauseTracking) {
push(`).cacheIndex = ${node.index},`);
newline();
push(`${helper(SET_BLOCK_TRACKING)}(1),`);
newline();
push(`_cache[${node.index}]`);
deindent();
}
push(`)`);
if (needArraySpread) {
push(`)]`);
}
}
const prohibitedKeywordRE = new RegExp(
"\\b" + "arguments,await,break,case,catch,class,const,continue,debugger,default,delete,do,else,export,extends,finally,for,function,if,import,let,new,return,super,switch,throw,try,var,void,while,with,yield".split(",").join("\\b|\\b") + "\\b"
);
const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
function validateBrowserExpression(node, context, asParams = false, asRawStatements = false) {
const exp = node.content;
if (!exp.trim()) {
return;
}
try {
new Function(
asRawStatements ? ` ${exp} ` : `return ${asParams ? `(${exp}) => {}` : `(${exp})`}`
);
} catch (e) {
let message = e.message;
const keywordMatch = exp.replace(stripStringRE, "").match(prohibitedKeywordRE);
if (keywordMatch) {
message = `avoid using JavaScript keyword as property name: "${keywordMatch[0]}"`;
}
context.onError(
createCompilerError(
45,
node.loc,
void 0,
message
)
);
}
}
const transformExpression = (node, context) => {
if (node.type === 5) {
node.content = processExpression(
node.content,
context
);
} else if (node.type === 1) {
const memo = findDir(node, "memo");
for (let i = 0; i < node.props.length; i++) {
const dir = node.props[i];
if (dir.type === 7 && dir.name !== "for") {
const exp = dir.exp;
const arg = dir.arg;
if (exp && exp.type === 4 && !(dir.name === "on" && arg) && // key has been processed in transformFor(vMemo + vFor)
!(memo && arg && arg.type === 4 && arg.content === "key")) {
dir.exp = processExpression(
exp,
context,
// slot args must be processed as function params
dir.name === "slot"
);
}
if (arg && arg.type === 4 && !arg.isStatic) {
dir.arg = processExpression(arg, context);
}
}
}
}
};
function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {
{
if (false) {}
return node;
}
}
function stringifyExpression(exp) {
if (isString(exp)) {
return exp;
} else if (exp.type === 4) {
return exp.content;
} else {
return exp.children.map(stringifyExpression).join("");
}
}
const transformIf = createStructuralDirectiveTransform(
/^(if|else|else-if)$/,
(node, dir, context) => {
return processIf(node, dir, context, (ifNode, branch, isRoot) => {
const siblings = context.parent.children;
let i = siblings.indexOf(ifNode);
let key = 0;
while (i-- >= 0) {
const sibling = siblings[i];
if (sibling && sibling.type === 9) {
key += sibling.branches.length;
}
}
return () => {
if (isRoot) {
ifNode.codegenNode = createCodegenNodeForBranch(
branch,
key,
context
);
} else {
const parentCondition = getParentCondition(ifNode.codegenNode);
parentCondition.alternate = createCodegenNodeForBranch(
branch,
key + ifNode.branches.length - 1,
context
);
}
};
});
}
);
function processIf(node, dir, context, processCodegen) {
if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
const loc = dir.exp ? dir.exp.loc : node.loc;
context.onError(
createCompilerError(28, dir.loc)
);
dir.exp = createSimpleExpression(`true`, false, loc);
}
if (false) {}
if (dir.name === "if") {
const branch = createIfBranch(node, dir);
const ifNode = {
type: 9,
loc: cloneLoc(node.loc),
branches: [branch]
};
context.replaceNode(ifNode);
if (processCodegen) {
return processCodegen(ifNode, branch, true);
}
} else {
const siblings = context.parent.children;
const comments = [];
let i = siblings.indexOf(node);
while (i-- >= -1) {
const sibling = siblings[i];
if (sibling && sibling.type === 3) {
context.removeNode(sibling);
false && 0;
continue;
}
if (sibling && sibling.type === 2 && !sibling.content.trim().length) {
context.removeNode(sibling);
continue;
}
if (sibling && sibling.type === 9) {
if (dir.name === "else-if" && sibling.branches[sibling.branches.length - 1].condition === void 0) {
context.onError(
createCompilerError(30, node.loc)
);
}
context.removeNode();
const branch = createIfBranch(node, dir);
if (false) {}
if (false) {}
sibling.branches.push(branch);
const onExit = processCodegen && processCodegen(sibling, branch, false);
traverseNode(branch, context);
if (onExit) onExit();
context.currentNode = null;
} else {
context.onError(
createCompilerError(30, node.loc)
);
}
break;
}
}
}
function createIfBranch(node, dir) {
const isTemplateIf = node.tagType === 3;
return {
type: 10,
loc: node.loc,
condition: dir.name === "else" ? void 0 : dir.exp,
children: isTemplateIf && !findDir(node, "for") ? node.children : [node],
userKey: findProp(node, `key`),
isTemplateIf
};
}
function createCodegenNodeForBranch(branch, keyIndex, context) {
if (branch.condition) {
return createConditionalExpression(
branch.condition,
createChildrenCodegenNode(branch, keyIndex, context),
// make sure to pass in asBlock: true so that the comment node call
// closes the current block.
createCallExpression(context.helper(CREATE_COMMENT), [
false ? 0 : '""',
"true"
])
);
} else {
return createChildrenCodegenNode(branch, keyIndex, context);
}
}
function createChildrenCodegenNode(branch, keyIndex, context) {
const { helper } = context;
const keyProperty = createObjectProperty(
`key`,
createSimpleExpression(
`${keyIndex}`,
false,
locStub,
2
)
);
const { children } = branch;
const firstChild = children[0];
const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1;
if (needFragmentWrapper) {
if (children.length === 1 && firstChild.type === 11) {
const vnodeCall = firstChild.codegenNode;
injectProp(vnodeCall, keyProperty, context);
return vnodeCall;
} else {
let patchFlag = 64;
if (false) {}
return createVNodeCall(
context,
helper(FRAGMENT),
createObjectExpression([keyProperty]),
children,
patchFlag,
void 0,
void 0,
true,
false,
false,
branch.loc
);
}
} else {
const ret = firstChild.codegenNode;
const vnodeCall = getMemoedVNodeCall(ret);
if (vnodeCall.type === 13) {
convertToBlock(vnodeCall, context);
}
injectProp(vnodeCall, keyProperty, context);
return ret;
}
}
function isSameKey(a, b) {
if (!a || a.type !== b.type) {
return false;
}
if (a.type === 6) {
if (a.value.content !== b.value.content) {
return false;
}
} else {
const exp = a.exp;
const branchExp = b.exp;
if (exp.type !== branchExp.type) {
return false;
}
if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) {
return false;
}
}
return true;
}
function getParentCondition(node) {
while (true) {
if (node.type === 19) {
if (node.alternate.type === 19) {
node = node.alternate;
} else {
return node;
}
} else if (node.type === 20) {
node = node.value;
}
}
}
const transformBind = (dir, _node, context) => {
const { modifiers, loc } = dir;
const arg = dir.arg;
let { exp } = dir;
if (exp && exp.type === 4 && !exp.content.trim()) {
{
exp = void 0;
}
}
if (!exp) {
if (arg.type !== 4 || !arg.isStatic) {
context.onError(
createCompilerError(
52,
arg.loc
)
);
return {
props: [
createObjectProperty(arg, createSimpleExpression("", true, loc))
]
};
}
transformBindShorthand(dir);
exp = dir.exp;
}
if (arg.type !== 4) {
arg.children.unshift(`(`);
arg.children.push(`) || ""`);
} else if (!arg.isStatic) {
arg.content = `${arg.content} || ""`;
}
if (modifiers.some((mod) => mod.content === "camel")) {
if (arg.type === 4) {
if (arg.isStatic) {
arg.content = shared_esm_bundler_camelize(arg.content);
} else {
arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
}
} else {
arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
arg.children.push(`)`);
}
}
if (!context.inSSR) {
if (modifiers.some((mod) => mod.content === "prop")) {
injectPrefix(arg, ".");
}
if (modifiers.some((mod) => mod.content === "attr")) {
injectPrefix(arg, "^");
}
}
return {
props: [createObjectProperty(arg, exp)]
};
};
const transformBindShorthand = (dir, context) => {
const arg = dir.arg;
const propName = shared_esm_bundler_camelize(arg.content);
dir.exp = createSimpleExpression(propName, false, arg.loc);
};
const injectPrefix = (arg, prefix) => {
if (arg.type === 4) {
if (arg.isStatic) {
arg.content = prefix + arg.content;
} else {
arg.content = `\`${prefix}\${${arg.content}}\``;
}
} else {
arg.children.unshift(`'${prefix}' + (`);
arg.children.push(`)`);
}
};
const transformFor = createStructuralDirectiveTransform(
"for",
(node, dir, context) => {
const { helper, removeHelper } = context;
return processFor(node, dir, context, (forNode) => {
const renderExp = createCallExpression(helper(RENDER_LIST), [
forNode.source
]);
const isTemplate = isTemplateNode(node);
const memo = findDir(node, "memo");
const keyProp = findProp(node, `key`, false, true);
const isDirKey = keyProp && keyProp.type === 7;
if (isDirKey && !keyProp.exp) {
transformBindShorthand(keyProp);
}
let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null;
const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;
const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;
forNode.codegenNode = createVNodeCall(
context,
helper(FRAGMENT),
void 0,
renderExp,
fragmentFlag,
void 0,
void 0,
true,
!isStableFragment,
false,
node.loc
);
return () => {
let childBlock;
const { children } = forNode;
if (false) {}
const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;
const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;
if (slotOutlet) {
childBlock = slotOutlet.codegenNode;
if (isTemplate && keyProperty) {
injectProp(childBlock, keyProperty, context);
}
} else if (needFragmentWrapper) {
childBlock = createVNodeCall(
context,
helper(FRAGMENT),
keyProperty ? createObjectExpression([keyProperty]) : void 0,
node.children,
64,
void 0,
void 0,
true,
void 0,
false
);
} else {
childBlock = children[0].codegenNode;
if (isTemplate && keyProperty) {
injectProp(childBlock, keyProperty, context);
}
if (childBlock.isBlock !== !isStableFragment) {
if (childBlock.isBlock) {
removeHelper(OPEN_BLOCK);
removeHelper(
getVNodeBlockHelper(context.inSSR, childBlock.isComponent)
);
} else {
removeHelper(
getVNodeHelper(context.inSSR, childBlock.isComponent)
);
}
}
childBlock.isBlock = !isStableFragment;
if (childBlock.isBlock) {
helper(OPEN_BLOCK);
helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
} else {
helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
}
}
if (memo) {
const loop = createFunctionExpression(
createForLoopParams(forNode.parseResult, [
createSimpleExpression(`_cached`)
])
);
loop.body = createBlockStatement([
createCompoundExpression([`const _memo = (`, memo.exp, `)`]),
createCompoundExpression([
`if (_cached`,
...keyExp ? [` && _cached.key === `, keyExp] : [],
` && ${context.helperString(
IS_MEMO_SAME
)}(_cached, _memo)) return _cached`
]),
createCompoundExpression([`const _item = `, childBlock]),
createSimpleExpression(`_item.memo = _memo`),
createSimpleExpression(`return _item`)
]);
renderExp.arguments.push(
loop,
createSimpleExpression(`_cache`),
createSimpleExpression(String(context.cached.length))
);
context.cached.push(null);
} else {
renderExp.arguments.push(
createFunctionExpression(
createForLoopParams(forNode.parseResult),
childBlock,
true
)
);
}
};
});
}
);
function processFor(node, dir, context, processCodegen) {
if (!dir.exp) {
context.onError(
createCompilerError(31, dir.loc)
);
return;
}
const parseResult = dir.forParseResult;
if (!parseResult) {
context.onError(
createCompilerError(32, dir.loc)
);
return;
}
finalizeForParseResult(parseResult, context);
const { addIdentifiers, removeIdentifiers, scopes } = context;
const { source, value, key, index } = parseResult;
const forNode = {
type: 11,
loc: dir.loc,
source,
valueAlias: value,
keyAlias: key,
objectIndexAlias: index,
parseResult,
children: isTemplateNode(node) ? node.children : [node]
};
context.replaceNode(forNode);
scopes.vFor++;
const onExit = processCodegen && processCodegen(forNode);
return () => {
scopes.vFor--;
if (onExit) onExit();
};
}
function finalizeForParseResult(result, context) {
if (result.finalized) return;
if (false) {}
result.finalized = true;
}
function createForLoopParams({ value, key, index }, memoArgs = []) {
return createParamsList([value, key, index, ...memoArgs]);
}
function createParamsList(args) {
let i = args.length;
while (i--) {
if (args[i]) break;
}
return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
}
const defaultFallback = createSimpleExpression(`undefined`, false);
const trackSlotScopes = (node, context) => {
if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
const vSlot = findDir(node, "slot");
if (vSlot) {
vSlot.exp;
context.scopes.vSlot++;
return () => {
context.scopes.vSlot--;
};
}
}
};
const trackVForSlotScopes = (node, context) => {
let vFor;
if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) {
const result = vFor.forParseResult;
if (result) {
finalizeForParseResult(result, context);
const { value, key, index } = result;
const { addIdentifiers, removeIdentifiers } = context;
value && addIdentifiers(value);
key && addIdentifiers(key);
index && addIdentifiers(index);
return () => {
value && removeIdentifiers(value);
key && removeIdentifiers(key);
index && removeIdentifiers(index);
};
}
}
};
const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(
props,
children,
false,
true,
children.length ? children[0].loc : loc
);
function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
context.helper(WITH_CTX);
const { children, loc } = node;
const slotsProperties = [];
const dynamicSlots = [];
let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
const onComponentSlot = findDir(node, "slot", true);
if (onComponentSlot) {
const { arg, exp } = onComponentSlot;
if (arg && !isStaticExp(arg)) {
hasDynamicSlots = true;
}
slotsProperties.push(
createObjectProperty(
arg || createSimpleExpression("default", true),
buildSlotFn(exp, void 0, children, loc)
)
);
}
let hasTemplateSlots = false;
let hasNamedDefaultSlot = false;
const implicitDefaultChildren = [];
const seenSlotNames = /* @__PURE__ */ new Set();
let conditionalBranchIndex = 0;
for (let i = 0; i < children.length; i++) {
const slotElement = children[i];
let slotDir;
if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) {
if (slotElement.type !== 3) {
implicitDefaultChildren.push(slotElement);
}
continue;
}
if (onComponentSlot) {
context.onError(
createCompilerError(37, slotDir.loc)
);
break;
}
hasTemplateSlots = true;
const { children: slotChildren, loc: slotLoc } = slotElement;
const {
arg: slotName = createSimpleExpression(`default`, true),
exp: slotProps,
loc: dirLoc
} = slotDir;
let staticSlotName;
if (isStaticExp(slotName)) {
staticSlotName = slotName ? slotName.content : `default`;
} else {
hasDynamicSlots = true;
}
const vFor = findDir(slotElement, "for");
const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc);
let vIf;
let vElse;
if (vIf = findDir(slotElement, "if")) {
hasDynamicSlots = true;
dynamicSlots.push(
createConditionalExpression(
vIf.exp,
buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++),
defaultFallback
)
);
} else if (vElse = findDir(
slotElement,
/^else(-if)?$/,
true
/* allowEmpty */
)) {
let j = i;
let prev;
while (j--) {
prev = children[j];
if (prev.type !== 3) {
break;
}
}
if (prev && isTemplateNode(prev) && findDir(prev, /^(else-)?if$/)) {
let conditional = dynamicSlots[dynamicSlots.length - 1];
while (conditional.alternate.type === 19) {
conditional = conditional.alternate;
}
conditional.alternate = vElse.exp ? createConditionalExpression(
vElse.exp,
buildDynamicSlot(
slotName,
slotFunction,
conditionalBranchIndex++
),
defaultFallback
) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);
} else {
context.onError(
createCompilerError(30, vElse.loc)
);
}
} else if (vFor) {
hasDynamicSlots = true;
const parseResult = vFor.forParseResult;
if (parseResult) {
finalizeForParseResult(parseResult, context);
dynamicSlots.push(
createCallExpression(context.helper(RENDER_LIST), [
parseResult.source,
createFunctionExpression(
createForLoopParams(parseResult),
buildDynamicSlot(slotName, slotFunction),
true
)
])
);
} else {
context.onError(
createCompilerError(
32,
vFor.loc
)
);
}
} else {
if (staticSlotName) {
if (seenSlotNames.has(staticSlotName)) {
context.onError(
createCompilerError(
38,
dirLoc
)
);
continue;
}
seenSlotNames.add(staticSlotName);
if (staticSlotName === "default") {
hasNamedDefaultSlot = true;
}
}
slotsProperties.push(createObjectProperty(slotName, slotFunction));
}
}
if (!onComponentSlot) {
const buildDefaultSlotProperty = (props, children2) => {
const fn = buildSlotFn(props, void 0, children2, loc);
if (context.compatConfig) {
fn.isNonScopedSlot = true;
}
return createObjectProperty(`default`, fn);
};
if (!hasTemplateSlots) {
slotsProperties.push(buildDefaultSlotProperty(void 0, children));
} else if (implicitDefaultChildren.length && // #3766
// with whitespace: 'preserve', whitespaces between slots will end up in
// implicitDefaultChildren. Ignore if all implicit children are whitespaces.
implicitDefaultChildren.some((node2) => isNonWhitespaceContent(node2))) {
if (hasNamedDefaultSlot) {
context.onError(
createCompilerError(
39,
implicitDefaultChildren[0].loc
)
);
} else {
slotsProperties.push(
buildDefaultSlotProperty(void 0, implicitDefaultChildren)
);
}
}
}
const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;
let slots = createObjectExpression(
slotsProperties.concat(
createObjectProperty(
`_`,
// 2 = compiled but dynamic = can skip normalization, but must run diff
// 1 = compiled and static = can skip normalization AND diff as optimized
createSimpleExpression(
slotFlag + ( false ? 0 : ``),
false
)
)
),
loc
);
if (dynamicSlots.length) {
slots = createCallExpression(context.helper(CREATE_SLOTS), [
slots,
createArrayExpression(dynamicSlots)
]);
}
return {
slots,
hasDynamicSlots
};
}
function buildDynamicSlot(name, fn, index) {
const props = [
createObjectProperty(`name`, name),
createObjectProperty(`fn`, fn)
];
if (index != null) {
props.push(
createObjectProperty(`key`, createSimpleExpression(String(index), true))
);
}
return createObjectExpression(props);
}
function hasForwardedSlots(children) {
for (let i = 0; i < children.length; i++) {
const child = children[i];
switch (child.type) {
case 1:
if (child.tagType === 2 || hasForwardedSlots(child.children)) {
return true;
}
break;
case 9:
if (hasForwardedSlots(child.branches)) return true;
break;
case 10:
case 11:
if (hasForwardedSlots(child.children)) return true;
break;
}
}
return false;
}
function isNonWhitespaceContent(node) {
if (node.type !== 2 && node.type !== 12)
return true;
return node.type === 2 ? !!node.content.trim() : isNonWhitespaceContent(node.content);
}
const directiveImportMap = /* @__PURE__ */ new WeakMap();
const transformElement = (node, context) => {
return function postTransformElement() {
node = context.currentNode;
if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) {
return;
}
const { tag, props } = node;
const isComponent = node.tagType === 1;
let vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`;
const isDynamicComponent = shared_esm_bundler_isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
let vnodeProps;
let vnodeChildren;
let patchFlag = 0;
let vnodeDynamicProps;
let dynamicPropNames;
let vnodeDirectives;
let shouldUseBlock = (
// dynamic component may resolve to plain elements
isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block
// updates inside get proper isSVG flag at runtime. (#639, #643)
// This is technically web-specific, but splitting the logic out of core
// leads to too much unnecessary complexity.
(tag === "svg" || tag === "foreignObject" || tag === "math")
);
if (props.length > 0) {
const propsBuildResult = buildProps(
node,
context,
void 0,
isComponent,
isDynamicComponent
);
vnodeProps = propsBuildResult.props;
patchFlag = propsBuildResult.patchFlag;
dynamicPropNames = propsBuildResult.dynamicPropNames;
const directives = propsBuildResult.directives;
vnodeDirectives = directives && directives.length ? createArrayExpression(
directives.map((dir) => buildDirectiveArgs(dir, context))
) : void 0;
if (propsBuildResult.shouldUseBlock) {
shouldUseBlock = true;
}
}
if (node.children.length > 0) {
if (vnodeTag === KEEP_ALIVE) {
shouldUseBlock = true;
patchFlag |= 1024;
if (false) {}
}
const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling
vnodeTag !== TELEPORT && // explained above.
vnodeTag !== KEEP_ALIVE;
if (shouldBuildAsSlots) {
const { slots, hasDynamicSlots } = buildSlots(node, context);
vnodeChildren = slots;
if (hasDynamicSlots) {
patchFlag |= 1024;
}
} else if (node.children.length === 1 && vnodeTag !== TELEPORT) {
const child = node.children[0];
const type = child.type;
const hasDynamicTextChild = type === 5 || type === 8;
if (hasDynamicTextChild && getConstantType(child, context) === 0) {
patchFlag |= 1;
}
if (hasDynamicTextChild || type === 2) {
vnodeChildren = child;
} else {
vnodeChildren = node.children;
}
} else {
vnodeChildren = node.children;
}
}
if (dynamicPropNames && dynamicPropNames.length) {
vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
}
node.codegenNode = createVNodeCall(
context,
vnodeTag,
vnodeProps,
vnodeChildren,
patchFlag === 0 ? void 0 : patchFlag,
vnodeDynamicProps,
vnodeDirectives,
!!shouldUseBlock,
false,
isComponent,
node.loc
);
};
};
function resolveComponentType(node, context, ssr = false) {
let { tag } = node;
const isExplicitDynamic = isComponentTag(tag);
const isProp = findProp(
node,
"is",
false,
true
/* allow empty */
);
if (isProp) {
if (isExplicitDynamic || isCompatEnabled(
"COMPILER_IS_ON_ELEMENT",
context
)) {
let exp;
if (isProp.type === 6) {
exp = isProp.value && createSimpleExpression(isProp.value.content, true);
} else {
exp = isProp.exp;
if (!exp) {
exp = createSimpleExpression(`is`, false, isProp.arg.loc);
}
}
if (exp) {
return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
exp
]);
}
} else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) {
tag = isProp.value.content.slice(4);
}
}
const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
if (builtIn) {
if (!ssr) context.helper(builtIn);
return builtIn;
}
context.helper(RESOLVE_COMPONENT);
context.components.add(tag);
return toValidAssetId(tag, `component`);
}
function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {
const { tag, loc: elementLoc, children } = node;
let properties = [];
const mergeArgs = [];
const runtimeDirectives = [];
const hasChildren = children.length > 0;
let shouldUseBlock = false;
let patchFlag = 0;
let hasRef = false;
let hasClassBinding = false;
let hasStyleBinding = false;
let hasHydrationEventBinding = false;
let hasDynamicKeys = false;
let hasVnodeHook = false;
const dynamicPropNames = [];
const pushMergeArg = (arg) => {
if (properties.length) {
mergeArgs.push(
createObjectExpression(dedupeProperties(properties), elementLoc)
);
properties = [];
}
if (arg) mergeArgs.push(arg);
};
const pushRefVForMarker = () => {
if (context.scopes.vFor > 0) {
properties.push(
createObjectProperty(
createSimpleExpression("ref_for", true),
createSimpleExpression("true")
)
);
}
};
const analyzePatchFlag = ({ key, value }) => {
if (isStaticExp(key)) {
const name = key.content;
const isEventHandler = isOn(name);
if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click
// dedicated fast path.
name.toLowerCase() !== "onclick" && // omit v-model handlers
name !== "onUpdate:modelValue" && // omit onVnodeXXX hooks
!isReservedProp(name)) {
hasHydrationEventBinding = true;
}
if (isEventHandler && isReservedProp(name)) {
hasVnodeHook = true;
}
if (isEventHandler && value.type === 14) {
value = value.arguments[0];
}
if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {
return;
}
if (name === "ref") {
hasRef = true;
} else if (name === "class") {
hasClassBinding = true;
} else if (name === "style") {
hasStyleBinding = true;
} else if (name !== "key" && !dynamicPropNames.includes(name)) {
dynamicPropNames.push(name);
}
if (isComponent && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) {
dynamicPropNames.push(name);
}
} else {
hasDynamicKeys = true;
}
};
for (let i = 0; i < props.length; i++) {
const prop = props[i];
if (prop.type === 6) {
const { loc, name, nameLoc, value } = prop;
let isStatic = true;
if (name === "ref") {
hasRef = true;
pushRefVForMarker();
}
if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled(
"COMPILER_IS_ON_ELEMENT",
context
))) {
continue;
}
properties.push(
createObjectProperty(
createSimpleExpression(name, true, nameLoc),
createSimpleExpression(
value ? value.content : "",
isStatic,
value ? value.loc : loc
)
)
);
} else {
const { name, arg, exp, loc, modifiers } = prop;
const isVBind = name === "bind";
const isVOn = name === "on";
if (name === "slot") {
if (!isComponent) {
context.onError(
createCompilerError(40, loc)
);
}
continue;
}
if (name === "once" || name === "memo") {
continue;
}
if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || isCompatEnabled(
"COMPILER_IS_ON_ELEMENT",
context
))) {
continue;
}
if (isVOn && ssr) {
continue;
}
if (
// #938: elements with dynamic keys should be forced into blocks
isVBind && isStaticArgOf(arg, "key") || // inline before-update hooks need to force block so that it is invoked
// before children
isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")
) {
shouldUseBlock = true;
}
if (isVBind && isStaticArgOf(arg, "ref")) {
pushRefVForMarker();
}
if (!arg && (isVBind || isVOn)) {
hasDynamicKeys = true;
if (exp) {
if (isVBind) {
pushRefVForMarker();
pushMergeArg();
{
if (false) {}
if (isCompatEnabled(
"COMPILER_V_BIND_OBJECT_ORDER",
context
)) {
mergeArgs.unshift(exp);
continue;
}
}
mergeArgs.push(exp);
} else {
pushMergeArg({
type: 14,
loc,
callee: context.helper(TO_HANDLERS),
arguments: isComponent ? [exp] : [exp, `true`]
});
}
} else {
context.onError(
createCompilerError(
isVBind ? 34 : 35,
loc
)
);
}
continue;
}
if (isVBind && modifiers.some((mod) => mod.content === "prop")) {
patchFlag |= 32;
}
const directiveTransform = context.directiveTransforms[name];
if (directiveTransform) {
const { props: props2, needRuntime } = directiveTransform(prop, node, context);
!ssr && props2.forEach(analyzePatchFlag);
if (isVOn && arg && !isStaticExp(arg)) {
pushMergeArg(createObjectExpression(props2, elementLoc));
} else {
properties.push(...props2);
}
if (needRuntime) {
runtimeDirectives.push(prop);
if (isSymbol(needRuntime)) {
directiveImportMap.set(prop, needRuntime);
}
}
} else if (!shared_esm_bundler_isBuiltInDirective(name)) {
runtimeDirectives.push(prop);
if (hasChildren) {
shouldUseBlock = true;
}
}
}
}
let propsExpression = void 0;
if (mergeArgs.length) {
pushMergeArg();
if (mergeArgs.length > 1) {
propsExpression = createCallExpression(
context.helper(MERGE_PROPS),
mergeArgs,
elementLoc
);
} else {
propsExpression = mergeArgs[0];
}
} else if (properties.length) {
propsExpression = createObjectExpression(
dedupeProperties(properties),
elementLoc
);
}
if (hasDynamicKeys) {
patchFlag |= 16;
} else {
if (hasClassBinding && !isComponent) {
patchFlag |= 2;
}
if (hasStyleBinding && !isComponent) {
patchFlag |= 4;
}
if (dynamicPropNames.length) {
patchFlag |= 8;
}
if (hasHydrationEventBinding) {
patchFlag |= 32;
}
}
if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) {
patchFlag |= 512;
}
if (!context.inSSR && propsExpression) {
switch (propsExpression.type) {
case 15:
let classKeyIndex = -1;
let styleKeyIndex = -1;
let hasDynamicKey = false;
for (let i = 0; i < propsExpression.properties.length; i++) {
const key = propsExpression.properties[i].key;
if (isStaticExp(key)) {
if (key.content === "class") {
classKeyIndex = i;
} else if (key.content === "style") {
styleKeyIndex = i;
}
} else if (!key.isHandlerKey) {
hasDynamicKey = true;
}
}
const classProp = propsExpression.properties[classKeyIndex];
const styleProp = propsExpression.properties[styleKeyIndex];
if (!hasDynamicKey) {
if (classProp && !isStaticExp(classProp.value)) {
classProp.value = createCallExpression(
context.helper(NORMALIZE_CLASS),
[classProp.value]
);
}
if (styleProp && // the static style is compiled into an object,
// so use `hasStyleBinding` to ensure that it is a dynamic style binding
(hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist,
// v-bind:style with static literal object
styleProp.value.type === 17)) {
styleProp.value = createCallExpression(
context.helper(NORMALIZE_STYLE),
[styleProp.value]
);
}
} else {
propsExpression = createCallExpression(
context.helper(NORMALIZE_PROPS),
[propsExpression]
);
}
break;
case 14:
break;
default:
propsExpression = createCallExpression(
context.helper(NORMALIZE_PROPS),
[
createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [
propsExpression
])
]
);
break;
}
}
return {
props: propsExpression,
directives: runtimeDirectives,
patchFlag,
dynamicPropNames,
shouldUseBlock
};
}
function dedupeProperties(properties) {
const knownProps = /* @__PURE__ */ new Map();
const deduped = [];
for (let i = 0; i < properties.length; i++) {
const prop = properties[i];
if (prop.key.type === 8 || !prop.key.isStatic) {
deduped.push(prop);
continue;
}
const name = prop.key.content;
const existing = knownProps.get(name);
if (existing) {
if (name === "style" || name === "class" || isOn(name)) {
compiler_core_esm_bundler_mergeAsArray(existing, prop);
}
} else {
knownProps.set(name, prop);
deduped.push(prop);
}
}
return deduped;
}
function compiler_core_esm_bundler_mergeAsArray(existing, incoming) {
if (existing.value.type === 17) {
existing.value.elements.push(incoming.value);
} else {
existing.value = createArrayExpression(
[existing.value, incoming.value],
existing.loc
);
}
}
function buildDirectiveArgs(dir, context) {
const dirArgs = [];
const runtime = directiveImportMap.get(dir);
if (runtime) {
dirArgs.push(context.helperString(runtime));
} else {
{
context.helper(RESOLVE_DIRECTIVE);
context.directives.add(dir.name);
dirArgs.push(toValidAssetId(dir.name, `directive`));
}
}
const { loc } = dir;
if (dir.exp) dirArgs.push(dir.exp);
if (dir.arg) {
if (!dir.exp) {
dirArgs.push(`void 0`);
}
dirArgs.push(dir.arg);
}
if (Object.keys(dir.modifiers).length) {
if (!dir.arg) {
if (!dir.exp) {
dirArgs.push(`void 0`);
}
dirArgs.push(`void 0`);
}
const trueExpression = createSimpleExpression(`true`, false, loc);
dirArgs.push(
createObjectExpression(
dir.modifiers.map(
(modifier) => createObjectProperty(modifier, trueExpression)
),
loc
)
);
}
return createArrayExpression(dirArgs, dir.loc);
}
function stringifyDynamicPropNames(props) {
let propsNamesString = `[`;
for (let i = 0, l = props.length; i < l; i++) {
propsNamesString += JSON.stringify(props[i]);
if (i < l - 1) propsNamesString += ", ";
}
return propsNamesString + `]`;
}
function isComponentTag(tag) {
return tag === "component" || tag === "Component";
}
const transformSlotOutlet = (node, context) => {
if (isSlotOutlet(node)) {
const { children, loc } = node;
const { slotName, slotProps } = processSlotOutlet(node, context);
const slotArgs = [
context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
slotName,
"{}",
"undefined",
"true"
];
let expectedLen = 2;
if (slotProps) {
slotArgs[2] = slotProps;
expectedLen = 3;
}
if (children.length) {
slotArgs[3] = createFunctionExpression([], children, false, false, loc);
expectedLen = 4;
}
if (context.scopeId && !context.slotted) {
expectedLen = 5;
}
slotArgs.splice(expectedLen);
node.codegenNode = createCallExpression(
context.helper(RENDER_SLOT),
slotArgs,
loc
);
}
};
function processSlotOutlet(node, context) {
let slotName = `"default"`;
let slotProps = void 0;
const nonNameProps = [];
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 6) {
if (p.value) {
if (p.name === "name") {
slotName = JSON.stringify(p.value.content);
} else {
p.name = shared_esm_bundler_camelize(p.name);
nonNameProps.push(p);
}
}
} else {
if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
if (p.exp) {
slotName = p.exp;
} else if (p.arg && p.arg.type === 4) {
const name = shared_esm_bundler_camelize(p.arg.content);
slotName = p.exp = createSimpleExpression(name, false, p.arg.loc);
}
} else {
if (p.name === "bind" && p.arg && isStaticExp(p.arg)) {
p.arg.content = shared_esm_bundler_camelize(p.arg.content);
}
nonNameProps.push(p);
}
}
}
if (nonNameProps.length > 0) {
const { props, directives } = buildProps(
node,
context,
nonNameProps,
false,
false
);
slotProps = props;
if (directives.length) {
context.onError(
createCompilerError(
36,
directives[0].loc
)
);
}
}
return {
slotName,
slotProps
};
}
const transformOn = (dir, node, context, augmentor) => {
const { loc, modifiers, arg } = dir;
if (!dir.exp && !modifiers.length) {
context.onError(createCompilerError(35, loc));
}
let eventName;
if (arg.type === 4) {
if (arg.isStatic) {
let rawName = arg.content;
if (false) {}
if (rawName.startsWith("vue:")) {
rawName = `vnode-${rawName.slice(4)}`;
}
const eventString = node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? (
// for non-element and vnode lifecycle event listeners, auto convert
// it to camelCase. See issue #2249
toHandlerKey(shared_esm_bundler_camelize(rawName))
) : (
// preserve case for plain element listeners that have uppercase
// letters, as these may be custom elements' custom events
`on:${rawName}`
);
eventName = createSimpleExpression(eventString, true, arg.loc);
} else {
eventName = createCompoundExpression([
`${context.helperString(TO_HANDLER_KEY)}(`,
arg,
`)`
]);
}
} else {
eventName = arg;
eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);
eventName.children.push(`)`);
}
let exp = dir.exp;
if (exp && !exp.content.trim()) {
exp = void 0;
}
let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
if (exp) {
const isMemberExp = isMemberExpression(exp);
const isInlineStatement = !(isMemberExp || isFnExpression(exp));
const hasMultipleStatements = exp.content.includes(`;`);
if (false) {}
if (isInlineStatement || shouldCache && isMemberExp) {
exp = createCompoundExpression([
`${isInlineStatement ? `$event` : `${``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,
exp,
hasMultipleStatements ? `}` : `)`
]);
}
}
let ret = {
props: [
createObjectProperty(
eventName,
exp || createSimpleExpression(`() => {}`, false, loc)
)
]
};
if (augmentor) {
ret = augmentor(ret);
}
if (shouldCache) {
ret.props[0].value = context.cache(ret.props[0].value);
}
ret.props.forEach((p) => p.key.isHandlerKey = true);
return ret;
};
const transformText = (node, context) => {
if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) {
return () => {
const children = node.children;
let currentContainer = void 0;
let hasText = false;
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (isText$1(child)) {
hasText = true;
for (let j = i + 1; j < children.length; j++) {
const next = children[j];
if (isText$1(next)) {
if (!currentContainer) {
currentContainer = children[i] = createCompoundExpression(
[child],
child.loc
);
}
currentContainer.children.push(` + `, next);
children.splice(j, 1);
j--;
} else {
currentContainer = void 0;
break;
}
}
}
}
if (!hasText || // if this is a plain element with a single text child, leave it
// as-is since the runtime has dedicated fast path for this by directly
// setting textContent of the element.
// for component root it's always normalized anyway.
children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756
// custom directives can potentially add DOM elements arbitrarily,
// we need to avoid setting textContent of the element at runtime
// to avoid accidentally overwriting the DOM elements added
// by the user through custom directives.
!node.props.find(
(p) => p.type === 7 && !context.directiveTransforms[p.name]
) && // in compat mode, <template> tags with no special directives
// will be rendered as a fragment so its children must be
// converted into vnodes.
!(node.tag === "template"))) {
return;
}
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (isText$1(child) || child.type === 8) {
const callArgs = [];
if (child.type !== 2 || child.content !== " ") {
callArgs.push(child);
}
if (!context.ssr && getConstantType(child, context) === 0) {
callArgs.push(
1 + ( false ? 0 : ``)
);
}
children[i] = {
type: 12,
content: child,
loc: child.loc,
codegenNode: createCallExpression(
context.helper(CREATE_TEXT),
callArgs
)
};
}
}
};
}
};
const seen$1 = /* @__PURE__ */ new WeakSet();
const transformOnce = (node, context) => {
if (node.type === 1 && findDir(node, "once", true)) {
if (seen$1.has(node) || context.inVOnce || context.inSSR) {
return;
}
seen$1.add(node);
context.inVOnce = true;
context.helper(SET_BLOCK_TRACKING);
return () => {
context.inVOnce = false;
const cur = context.currentNode;
if (cur.codegenNode) {
cur.codegenNode = context.cache(
cur.codegenNode,
true,
true
);
}
};
}
};
const transformModel = (dir, node, context) => {
const { exp, arg } = dir;
if (!exp) {
context.onError(
createCompilerError(41, dir.loc)
);
return createTransformProps();
}
const rawExp = exp.loc.source.trim();
const expString = exp.type === 4 ? exp.content : rawExp;
const bindingType = context.bindingMetadata[rawExp];
if (bindingType === "props" || bindingType === "props-aliased") {
context.onError(createCompilerError(44, exp.loc));
return createTransformProps();
}
const maybeRef = false;
if (!expString.trim() || !isMemberExpression(exp) && !maybeRef) {
context.onError(
createCompilerError(42, exp.loc)
);
return createTransformProps();
}
const propName = arg ? arg : createSimpleExpression("modelValue", true);
const eventName = arg ? isStaticExp(arg) ? `onUpdate:${shared_esm_bundler_camelize(arg.content)}` : createCompoundExpression(['"onUpdate:" + ', arg]) : `onUpdate:modelValue`;
let assignmentExp;
const eventArg = context.isTS ? `($event: any)` : `$event`;
{
assignmentExp = createCompoundExpression([
`${eventArg} => ((`,
exp,
`) = $event)`
]);
}
const props = [
// modelValue: foo
createObjectProperty(propName, dir.exp),
// "onUpdate:modelValue": $event => (foo = $event)
createObjectProperty(eventName, assignmentExp)
];
if (dir.modifiers.length && node.tagType === 1) {
const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`;
props.push(
createObjectProperty(
modifiersKey,
createSimpleExpression(
`{ ${modifiers} }`,
false,
dir.loc,
2
)
)
);
}
return createTransformProps(props);
};
function createTransformProps(props = []) {
return { props };
}
const validDivisionCharRE = /[\w).+\-_$\]]/;
const transformFilter = (node, context) => {
if (!isCompatEnabled("COMPILER_FILTERS", context)) {
return;
}
if (node.type === 5) {
rewriteFilter(node.content, context);
} else if (node.type === 1) {
node.props.forEach((prop) => {
if (prop.type === 7 && prop.name !== "for" && prop.exp) {
rewriteFilter(prop.exp, context);
}
});
}
};
function rewriteFilter(node, context) {
if (node.type === 4) {
parseFilter(node, context);
} else {
for (let i = 0; i < node.children.length; i++) {
const child = node.children[i];
if (typeof child !== "object") continue;
if (child.type === 4) {
parseFilter(child, context);
} else if (child.type === 8) {
rewriteFilter(node, context);
} else if (child.type === 5) {
rewriteFilter(child.content, context);
}
}
}
}
function parseFilter(node, context) {
const exp = node.content;
let inSingle = false;
let inDouble = false;
let inTemplateString = false;
let inRegex = false;
let curly = 0;
let square = 0;
let paren = 0;
let lastFilterIndex = 0;
let c, prev, i, expression, filters = [];
for (i = 0; i < exp.length; i++) {
prev = c;
c = exp.charCodeAt(i);
if (inSingle) {
if (c === 39 && prev !== 92) inSingle = false;
} else if (inDouble) {
if (c === 34 && prev !== 92) inDouble = false;
} else if (inTemplateString) {
if (c === 96 && prev !== 92) inTemplateString = false;
} else if (inRegex) {
if (c === 47 && prev !== 92) inRegex = false;
} else if (c === 124 && // pipe
exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) {
if (expression === void 0) {
lastFilterIndex = i + 1;
expression = exp.slice(0, i).trim();
} else {
pushFilter();
}
} else {
switch (c) {
case 34:
inDouble = true;
break;
// "
case 39:
inSingle = true;
break;
// '
case 96:
inTemplateString = true;
break;
// `
case 40:
paren++;
break;
// (
case 41:
paren--;
break;
// )
case 91:
square++;
break;
// [
case 93:
square--;
break;
// ]
case 123:
curly++;
break;
// {
case 125:
curly--;
break;
}
if (c === 47) {
let j = i - 1;
let p;
for (; j >= 0; j--) {
p = exp.charAt(j);
if (p !== " ") break;
}
if (!p || !validDivisionCharRE.test(p)) {
inRegex = true;
}
}
}
}
if (expression === void 0) {
expression = exp.slice(0, i).trim();
} else if (lastFilterIndex !== 0) {
pushFilter();
}
function pushFilter() {
filters.push(exp.slice(lastFilterIndex, i).trim());
lastFilterIndex = i + 1;
}
if (filters.length) {
false && 0;
for (i = 0; i < filters.length; i++) {
expression = wrapFilter(expression, filters[i], context);
}
node.content = expression;
node.ast = void 0;
}
}
function wrapFilter(exp, filter, context) {
context.helper(RESOLVE_FILTER);
const i = filter.indexOf("(");
if (i < 0) {
context.filters.add(filter);
return `${toValidAssetId(filter, "filter")}(${exp})`;
} else {
const name = filter.slice(0, i);
const args = filter.slice(i + 1);
context.filters.add(name);
return `${toValidAssetId(name, "filter")}(${exp}${args !== ")" ? "," + args : args}`;
}
}
const seen = /* @__PURE__ */ new WeakSet();
const transformMemo = (node, context) => {
if (node.type === 1) {
const dir = findDir(node, "memo");
if (!dir || seen.has(node)) {
return;
}
seen.add(node);
return () => {
const codegenNode = node.codegenNode || context.currentNode.codegenNode;
if (codegenNode && codegenNode.type === 13) {
if (node.tagType !== 1) {
convertToBlock(codegenNode, context);
}
node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [
dir.exp,
createFunctionExpression(void 0, codegenNode),
`_cache`,
String(context.cached.length)
]);
context.cached.push(null);
}
};
}
};
function getBaseTransformPreset(prefixIdentifiers) {
return [
[
transformOnce,
transformIf,
transformMemo,
transformFor,
...[transformFilter] ,
... false ? 0 : [],
transformSlotOutlet,
transformElement,
trackSlotScopes,
transformText
],
{
on: transformOn,
bind: transformBind,
model: transformModel
}
];
}
function baseCompile(source, options = {}) {
const onError = options.onError || defaultOnError;
const isModuleMode = options.mode === "module";
{
if (options.prefixIdentifiers === true) {
onError(createCompilerError(47));
} else if (isModuleMode) {
onError(createCompilerError(48));
}
}
const prefixIdentifiers = false;
if (options.cacheHandlers) {
onError(createCompilerError(49));
}
if (options.scopeId && !isModuleMode) {
onError(createCompilerError(50));
}
const resolvedOptions = shared_esm_bundler_extend({}, options, {
prefixIdentifiers
});
const ast = shared_esm_bundler_isString(source) ? compiler_core_esm_bundler_baseParse(source, resolvedOptions) : source;
const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
transform(
ast,
shared_esm_bundler_extend({}, resolvedOptions, {
nodeTransforms: [
...nodeTransforms,
...options.nodeTransforms || []
// user transforms
],
directiveTransforms: shared_esm_bundler_extend(
{},
directiveTransforms,
options.directiveTransforms || {}
// user transforms
)
})
);
return generate(ast, resolvedOptions);
}
const BindingTypes = {
"DATA": "data",
"PROPS": "props",
"PROPS_ALIASED": "props-aliased",
"SETUP_LET": "setup-let",
"SETUP_CONST": "setup-const",
"SETUP_REACTIVE_CONST": "setup-reactive-const",
"SETUP_MAYBE_REF": "setup-maybe-ref",
"SETUP_REF": "setup-ref",
"OPTIONS": "options",
"LITERAL_CONST": "literal-const"
};
const noopDirectiveTransform = () => ({ props: [] });
;// ./node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js
/**
* @vue/compiler-dom v3.5.13
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
const V_MODEL_RADIO = Symbol( false ? 0 : ``);
const V_MODEL_CHECKBOX = Symbol(
false ? 0 : ``
);
const V_MODEL_TEXT = Symbol( false ? 0 : ``);
const V_MODEL_SELECT = Symbol(
false ? 0 : ``
);
const V_MODEL_DYNAMIC = Symbol(
false ? 0 : ``
);
const V_ON_WITH_MODIFIERS = Symbol(
false ? 0 : ``
);
const V_ON_WITH_KEYS = Symbol(
false ? 0 : ``
);
const V_SHOW = Symbol( false ? 0 : ``);
const compiler_dom_esm_bundler_TRANSITION = Symbol( false ? 0 : ``);
const TRANSITION_GROUP = Symbol(
false ? 0 : ``
);
registerRuntimeHelpers({
[V_MODEL_RADIO]: `vModelRadio`,
[V_MODEL_CHECKBOX]: `vModelCheckbox`,
[V_MODEL_TEXT]: `vModelText`,
[V_MODEL_SELECT]: `vModelSelect`,
[V_MODEL_DYNAMIC]: `vModelDynamic`,
[V_ON_WITH_MODIFIERS]: `withModifiers`,
[V_ON_WITH_KEYS]: `withKeys`,
[V_SHOW]: `vShow`,
[compiler_dom_esm_bundler_TRANSITION]: `Transition`,
[TRANSITION_GROUP]: `TransitionGroup`
});
let decoder;
function decodeHtmlBrowser(raw, asAttr = false) {
if (!decoder) {
decoder = document.createElement("div");
}
if (asAttr) {
decoder.innerHTML = `<div foo="${raw.replace(/"/g, """)}">`;
return decoder.children[0].getAttribute("foo");
} else {
decoder.innerHTML = raw;
return decoder.textContent;
}
}
const parserOptions = {
parseMode: "html",
isVoidTag: isVoidTag,
isNativeTag: (tag) => shared_esm_bundler_isHTMLTag(tag) || shared_esm_bundler_isSVGTag(tag) || shared_esm_bundler_isMathMLTag(tag),
isPreTag: (tag) => tag === "pre",
isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea",
decodeEntities: decodeHtmlBrowser ,
isBuiltInComponent: (tag) => {
if (tag === "Transition" || tag === "transition") {
return compiler_dom_esm_bundler_TRANSITION;
} else if (tag === "TransitionGroup" || tag === "transition-group") {
return TRANSITION_GROUP;
}
},
// https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
getNamespace(tag, parent, rootNamespace) {
let ns = parent ? parent.ns : rootNamespace;
if (parent && ns === 2) {
if (parent.tag === "annotation-xml") {
if (tag === "svg") {
return 1;
}
if (parent.props.some(
(a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml")
)) {
ns = 0;
}
} else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") {
ns = 0;
}
} else if (parent && ns === 1) {
if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") {
ns = 0;
}
}
if (ns === 0) {
if (tag === "svg") {
return 1;
}
if (tag === "math") {
return 2;
}
}
return ns;
}
};
const transformStyle = (node) => {
if (node.type === 1) {
node.props.forEach((p, i) => {
if (p.type === 6 && p.name === "style" && p.value) {
node.props[i] = {
type: 7,
name: `bind`,
arg: createSimpleExpression(`style`, true, p.loc),
exp: parseInlineCSS(p.value.content, p.loc),
modifiers: [],
loc: p.loc
};
}
});
}
};
const parseInlineCSS = (cssText, loc) => {
const normalized = parseStringStyle(cssText);
return createSimpleExpression(
JSON.stringify(normalized),
false,
loc,
3
);
};
function createDOMCompilerError(code, loc) {
return createCompilerError(
code,
loc,
false ? 0 : void 0
);
}
const DOMErrorCodes = {
"X_V_HTML_NO_EXPRESSION": 53,
"53": "X_V_HTML_NO_EXPRESSION",
"X_V_HTML_WITH_CHILDREN": 54,
"54": "X_V_HTML_WITH_CHILDREN",
"X_V_TEXT_NO_EXPRESSION": 55,
"55": "X_V_TEXT_NO_EXPRESSION",
"X_V_TEXT_WITH_CHILDREN": 56,
"56": "X_V_TEXT_WITH_CHILDREN",
"X_V_MODEL_ON_INVALID_ELEMENT": 57,
"57": "X_V_MODEL_ON_INVALID_ELEMENT",
"X_V_MODEL_ARG_ON_ELEMENT": 58,
"58": "X_V_MODEL_ARG_ON_ELEMENT",
"X_V_MODEL_ON_FILE_INPUT_ELEMENT": 59,
"59": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
"X_V_MODEL_UNNECESSARY_VALUE": 60,
"60": "X_V_MODEL_UNNECESSARY_VALUE",
"X_V_SHOW_NO_EXPRESSION": 61,
"61": "X_V_SHOW_NO_EXPRESSION",
"X_TRANSITION_INVALID_CHILDREN": 62,
"62": "X_TRANSITION_INVALID_CHILDREN",
"X_IGNORED_SIDE_EFFECT_TAG": 63,
"63": "X_IGNORED_SIDE_EFFECT_TAG",
"__EXTEND_POINT__": 64,
"64": "__EXTEND_POINT__"
};
const DOMErrorMessages = {
[53]: `v-html is missing expression.`,
[54]: `v-html will override element children.`,
[55]: `v-text is missing expression.`,
[56]: `v-text will override element children.`,
[57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
[58]: `v-model argument is not supported on plain elements.`,
[59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
[60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
[61]: `v-show is missing expression.`,
[62]: `<Transition> expects exactly one child element or component.`,
[63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
};
const transformVHtml = (dir, node, context) => {
const { exp, loc } = dir;
if (!exp) {
context.onError(
createDOMCompilerError(53, loc)
);
}
if (node.children.length) {
context.onError(
createDOMCompilerError(54, loc)
);
node.children.length = 0;
}
return {
props: [
createObjectProperty(
createSimpleExpression(`innerHTML`, true, loc),
exp || createSimpleExpression("", true)
)
]
};
};
const transformVText = (dir, node, context) => {
const { exp, loc } = dir;
if (!exp) {
context.onError(
createDOMCompilerError(55, loc)
);
}
if (node.children.length) {
context.onError(
createDOMCompilerError(56, loc)
);
node.children.length = 0;
}
return {
props: [
createObjectProperty(
createSimpleExpression(`textContent`, true),
exp ? getConstantType(exp, context) > 0 ? exp : createCallExpression(
context.helperString(TO_DISPLAY_STRING),
[exp],
loc
) : createSimpleExpression("", true)
)
]
};
};
const compiler_dom_esm_bundler_transformModel = (dir, node, context) => {
const baseResult = transformModel(dir, node, context);
if (!baseResult.props.length || node.tagType === 1) {
return baseResult;
}
if (dir.arg) {
context.onError(
createDOMCompilerError(
58,
dir.arg.loc
)
);
}
function checkDuplicatedValue() {
const value = findDir(node, "bind");
if (value && isStaticArgOf(value.arg, "value")) {
context.onError(
createDOMCompilerError(
60,
value.loc
)
);
}
}
const { tag } = node;
const isCustomElement = context.isCustomElement(tag);
if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
let directiveToUse = V_MODEL_TEXT;
let isInvalidType = false;
if (tag === "input" || isCustomElement) {
const type = findProp(node, `type`);
if (type) {
if (type.type === 7) {
directiveToUse = V_MODEL_DYNAMIC;
} else if (type.value) {
switch (type.value.content) {
case "radio":
directiveToUse = V_MODEL_RADIO;
break;
case "checkbox":
directiveToUse = V_MODEL_CHECKBOX;
break;
case "file":
isInvalidType = true;
context.onError(
createDOMCompilerError(
59,
dir.loc
)
);
break;
default:
false && 0;
break;
}
}
} else if (hasDynamicKeyVBind(node)) {
directiveToUse = V_MODEL_DYNAMIC;
} else {
false && 0;
}
} else if (tag === "select") {
directiveToUse = V_MODEL_SELECT;
} else {
false && 0;
}
if (!isInvalidType) {
baseResult.needRuntime = context.helper(directiveToUse);
}
} else {
context.onError(
createDOMCompilerError(
57,
dir.loc
)
);
}
baseResult.props = baseResult.props.filter(
(p) => !(p.key.type === 4 && p.key.content === "modelValue")
);
return baseResult;
};
const isEventOptionModifier = /* @__PURE__ */ shared_esm_bundler_makeMap(`passive,once,capture`);
const isNonKeyModifier = /* @__PURE__ */ shared_esm_bundler_makeMap(
// event propagation management
`stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
);
const maybeKeyModifier = /* @__PURE__ */ shared_esm_bundler_makeMap("left,right");
const isKeyboardEvent = /* @__PURE__ */ shared_esm_bundler_makeMap(`onkeyup,onkeydown,onkeypress`);
const resolveModifiers = (key, modifiers, context, loc) => {
const keyModifiers = [];
const nonKeyModifiers = [];
const eventOptionModifiers = [];
for (let i = 0; i < modifiers.length; i++) {
const modifier = modifiers[i].content;
if (modifier === "native" && checkCompatEnabled(
"COMPILER_V_ON_NATIVE",
context,
loc
)) {
eventOptionModifiers.push(modifier);
} else if (isEventOptionModifier(modifier)) {
eventOptionModifiers.push(modifier);
} else {
if (maybeKeyModifier(modifier)) {
if (isStaticExp(key)) {
if (isKeyboardEvent(key.content.toLowerCase())) {
keyModifiers.push(modifier);
} else {
nonKeyModifiers.push(modifier);
}
} else {
keyModifiers.push(modifier);
nonKeyModifiers.push(modifier);
}
} else {
if (isNonKeyModifier(modifier)) {
nonKeyModifiers.push(modifier);
} else {
keyModifiers.push(modifier);
}
}
}
}
return {
keyModifiers,
nonKeyModifiers,
eventOptionModifiers
};
};
const transformClick = (key, event) => {
const isStaticClick = isStaticExp(key) && key.content.toLowerCase() === "onclick";
return isStaticClick ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([
`(`,
key,
`) === "onClick" ? "${event}" : (`,
key,
`)`
]) : key;
};
const compiler_dom_esm_bundler_transformOn = (dir, node, context) => {
return transformOn(dir, node, context, (baseResult) => {
const { modifiers } = dir;
if (!modifiers.length) return baseResult;
let { key, value: handlerExp } = baseResult.props[0];
const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
if (nonKeyModifiers.includes("right")) {
key = transformClick(key, `onContextmenu`);
}
if (nonKeyModifiers.includes("middle")) {
key = transformClick(key, `onMouseup`);
}
if (nonKeyModifiers.length) {
handlerExp = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
handlerExp,
JSON.stringify(nonKeyModifiers)
]);
}
if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
(!isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) {
handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [
handlerExp,
JSON.stringify(keyModifiers)
]);
}
if (eventOptionModifiers.length) {
const modifierPostfix = eventOptionModifiers.map(shared_esm_bundler_capitalize).join("");
key = isStaticExp(key) ? createSimpleExpression(`${key.content}${modifierPostfix}`, true) : createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
}
return {
props: [createObjectProperty(key, handlerExp)]
};
});
};
const transformShow = (dir, node, context) => {
const { exp, loc } = dir;
if (!exp) {
context.onError(
createDOMCompilerError(61, loc)
);
}
return {
props: [],
needRuntime: context.helper(V_SHOW)
};
};
const transformTransition = (node, context) => {
if (node.type === 1 && node.tagType === 1) {
const component = context.isBuiltInComponent(node.tag);
if (component === compiler_dom_esm_bundler_TRANSITION) {
return () => {
if (!node.children.length) {
return;
}
if (hasMultipleChildren(node)) {
context.onError(
createDOMCompilerError(
62,
{
start: node.children[0].loc.start,
end: node.children[node.children.length - 1].loc.end,
source: ""
}
)
);
}
const child = node.children[0];
if (child.type === 1) {
for (const p of child.props) {
if (p.type === 7 && p.name === "show") {
node.props.push({
type: 6,
name: "persisted",
nameLoc: node.loc,
value: void 0,
loc: node.loc
});
}
}
}
};
}
}
};
function hasMultipleChildren(node) {
const children = node.children = node.children.filter(
(c) => c.type !== 3 && !(c.type === 2 && !c.content.trim())
);
const child = children[0];
return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);
}
const ignoreSideEffectTags = (node, context) => {
if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
false && 0;
context.removeNode();
}
};
function isValidHTMLNesting(parent, child) {
if (parent in onlyValidChildren) {
return onlyValidChildren[parent].has(child);
}
if (child in onlyValidParents) {
return onlyValidParents[child].has(parent);
}
if (parent in knownInvalidChildren) {
if (knownInvalidChildren[parent].has(child)) return false;
}
if (child in knownInvalidParents) {
if (knownInvalidParents[child].has(parent)) return false;
}
return true;
}
const headings = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
const emptySet = /* @__PURE__ */ new Set([]);
const onlyValidChildren = {
head: /* @__PURE__ */ new Set([
"base",
"basefront",
"bgsound",
"link",
"meta",
"title",
"noscript",
"noframes",
"style",
"script",
"template"
]),
optgroup: /* @__PURE__ */ new Set(["option"]),
select: /* @__PURE__ */ new Set(["optgroup", "option", "hr"]),
// table
table: /* @__PURE__ */ new Set(["caption", "colgroup", "tbody", "tfoot", "thead"]),
tr: /* @__PURE__ */ new Set(["td", "th"]),
colgroup: /* @__PURE__ */ new Set(["col"]),
tbody: /* @__PURE__ */ new Set(["tr"]),
thead: /* @__PURE__ */ new Set(["tr"]),
tfoot: /* @__PURE__ */ new Set(["tr"]),
// these elements can not have any children elements
script: emptySet,
iframe: emptySet,
option: emptySet,
textarea: emptySet,
style: emptySet,
title: emptySet
};
const onlyValidParents = {
// sections
html: emptySet,
body: /* @__PURE__ */ new Set(["html"]),
head: /* @__PURE__ */ new Set(["html"]),
// table
td: /* @__PURE__ */ new Set(["tr"]),
colgroup: /* @__PURE__ */ new Set(["table"]),
caption: /* @__PURE__ */ new Set(["table"]),
tbody: /* @__PURE__ */ new Set(["table"]),
tfoot: /* @__PURE__ */ new Set(["table"]),
col: /* @__PURE__ */ new Set(["colgroup"]),
th: /* @__PURE__ */ new Set(["tr"]),
thead: /* @__PURE__ */ new Set(["table"]),
tr: /* @__PURE__ */ new Set(["tbody", "thead", "tfoot"]),
// data list
dd: /* @__PURE__ */ new Set(["dl", "div"]),
dt: /* @__PURE__ */ new Set(["dl", "div"]),
// other
figcaption: /* @__PURE__ */ new Set(["figure"]),
// li: new Set(["ul", "ol"]),
summary: /* @__PURE__ */ new Set(["details"]),
area: /* @__PURE__ */ new Set(["map"])
};
const knownInvalidChildren = {
p: /* @__PURE__ */ new Set([
"address",
"article",
"aside",
"blockquote",
"center",
"details",
"dialog",
"dir",
"div",
"dl",
"fieldset",
"figure",
"footer",
"form",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"header",
"hgroup",
"hr",
"li",
"main",
"nav",
"menu",
"ol",
"p",
"pre",
"section",
"table",
"ul"
]),
svg: /* @__PURE__ */ new Set([
"b",
"blockquote",
"br",
"code",
"dd",
"div",
"dl",
"dt",
"em",
"embed",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"hr",
"i",
"img",
"li",
"menu",
"meta",
"ol",
"p",
"pre",
"ruby",
"s",
"small",
"span",
"strong",
"sub",
"sup",
"table",
"u",
"ul",
"var"
])
};
const knownInvalidParents = {
a: /* @__PURE__ */ new Set(["a"]),
button: /* @__PURE__ */ new Set(["button"]),
dd: /* @__PURE__ */ new Set(["dd", "dt"]),
dt: /* @__PURE__ */ new Set(["dd", "dt"]),
form: /* @__PURE__ */ new Set(["form"]),
li: /* @__PURE__ */ new Set(["li"]),
h1: headings,
h2: headings,
h3: headings,
h4: headings,
h5: headings,
h6: headings
};
const validateHtmlNesting = (node, context) => {
if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) {
const error = new SyntaxError(
`<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.`
);
error.loc = node.loc;
context.onWarn(error);
}
};
const DOMNodeTransforms = [
transformStyle,
... false ? 0 : []
];
const DOMDirectiveTransforms = {
cloak: noopDirectiveTransform,
html: transformVHtml,
text: transformVText,
model: compiler_dom_esm_bundler_transformModel,
// override compiler-core
on: compiler_dom_esm_bundler_transformOn,
// override compiler-core
show: transformShow
};
function compiler_dom_esm_bundler_compile(src, options = {}) {
return baseCompile(
src,
shared_esm_bundler_extend({}, parserOptions, options, {
nodeTransforms: [
// ignore <script> and <tag>
// this is not put inside DOMNodeTransforms because that list is used
// by compiler-ssr to generate vnode fallback branches
ignoreSideEffectTags,
...DOMNodeTransforms,
...options.nodeTransforms || []
],
directiveTransforms: shared_esm_bundler_extend(
{},
DOMDirectiveTransforms,
options.directiveTransforms || {}
),
transformHoist: null
})
);
}
function parse(template, options = {}) {
return baseParse(template, extend({}, parserOptions, options));
}
;// ./node_modules/vue/dist/vue.esm-bundler.js
/**
* vue v3.5.13
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
function initDev() {
{
initCustomFormatter();
}
}
if (false) {}
const compileCache = /* @__PURE__ */ Object.create(null);
function compileToFunction(template, options) {
if (!shared_esm_bundler_isString(template)) {
if (template.nodeType) {
template = template.innerHTML;
} else {
false && 0;
return shared_esm_bundler_NOOP;
}
}
const key = genCacheKey(template, options);
const cached = compileCache[key];
if (cached) {
return cached;
}
if (template[0] === "#") {
const el = document.querySelector(template);
if (false) {}
template = el ? el.innerHTML : ``;
}
const opts = shared_esm_bundler_extend(
{
hoistStatic: true,
onError: false ? 0 : void 0,
onWarn: false ? 0 : shared_esm_bundler_NOOP
},
options
);
if (!opts.isCustomElement && typeof customElements !== "undefined") {
opts.isCustomElement = (tag) => !!customElements.get(tag);
}
const { code } = compiler_dom_esm_bundler_compile(template, opts);
function onError(err, asWarning = false) {
const message = asWarning ? err.message : `Template compilation error: ${err.message}`;
const codeFrame = err.loc && generateCodeFrame(
template,
err.loc.start.offset,
err.loc.end.offset
);
runtime_core_esm_bundler_warn(codeFrame ? `${message}
${codeFrame}` : message);
}
const render = new Function("Vue", code)(runtime_dom_esm_bundler_namespaceObject);
render._rc = true;
return compileCache[key] = render;
}
registerRuntimeCompiler(compileToFunction);
;// ./node_modules/babel-loader/lib/index.js!./node_modules/vue-loader/dist/templateLoader.js??ruleSet[1].rules[2]!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[7].use[0]!./src/App.vue?vue&type=template&id=49770b9d&scoped=true
var _hoisted_1 = {
class: "config-area"
};
function Appvue_type_template_id_49770b9d_scoped_true_render(_ctx, _cache, $props, $setup, $data, $options) {
var _component_n_button = resolveComponent("n-button");
var _component_n_popover = resolveComponent("n-popover");
var _component_config_panel = resolveComponent("config-panel");
var _component_n_space = resolveComponent("n-space");
return openBlock(), createElementBlock("div", _hoisted_1, [createVNode(_component_n_space, {
vertical: ""
}, {
default: withCtx(function () {
return [createVNode(_component_n_popover, {
placement: "left"
}, {
trigger: withCtx(function () {
return [createVNode(_component_n_button, {
round: "",
type: $setup.runningReadConfig.isAutoReading ? 'primary' : 'default',
onClick: $setup.switchAutoRead
}, {
default: withCtx(function () {
return _cache[0] || (_cache[0] = [createTextVNode("阅读 ")]);
}),
_: 1
}, 8, ["type", "onClick"])];
}),
default: withCtx(function () {
return [_cache[1] || (_cache[1] = createBaseVNode("span", null, " 点击切换阅读状态~ ", -1))];
}),
_: 1
}), createVNode(_component_n_popover, {
placement: "left",
trigger: "click"
}, {
trigger: withCtx(function () {
return [createVNode(_component_n_button, {
round: ""
}, {
default: withCtx(function () {
return _cache[2] || (_cache[2] = [createTextVNode("配置")]);
}),
_: 1
})];
}),
default: withCtx(function () {
return [createVNode(_component_config_panel)];
}),
_: 1
}), createVNode(_component_n_popover, {
placement: "left"
}, {
trigger: withCtx(function () {
return [createVNode(_component_n_button, {
round: "",
onClick: $setup.clearReadConfig
}, {
default: withCtx(function () {
return _cache[3] || (_cache[3] = [createTextVNode("清除")]);
}),
_: 1
}, 8, ["onClick"])];
}),
default: withCtx(function () {
return [_cache[4] || (_cache[4] = createBaseVNode("span", null, "点击恢复所有本地设置成默认", -1))];
}),
_: 1
}), createVNode(_component_n_button, {
round: "",
onClick: $setup.switchPage
}, {
default: withCtx(function () {
return _cache[5] || (_cache[5] = [createTextVNode("翻页")]);
}),
_: 1
}, 8, ["onClick"])];
}),
_: 1
})]);
}
;// ./src/App.vue?vue&type=template&id=49770b9d&scoped=true
;// ./src/helper/storageHelper.js
// localStorageHelper.js
// 序列化并保存对象到 localStorage
function setItem(key, value) {
try {
var serializedValue = JSON.stringify(value);
localStorage.setItem(key, serializedValue);
} catch (e) {
console.error("Failed to serialize and save ".concat(key, ":"), e);
}
}
// 保存数据 localStorage
function setSingItem(key, value) {
try {
localStorage.setItem(key, value);
} catch (e) {
console.error("Failed to serialize and save ".concat(key, ":"), e);
}
}
// 获取数据 localStorage
function getSingleItem(key) {
try {
return localStorage.getItem(key);
} catch (e) {
console.error("Failed to serialize and save ".concat(key, ":"), e);
}
}
// 从 localStorage 获取对象，并处理反序列化
function getItem(key) {
var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
try {
var serializedValue = localStorage.getItem(key);
if (serializedValue) {
return JSON.parse(serializedValue);
} else {
console.warn("".concat(key, " not found, returning default value."));
return defaultValue; // 若没有找到对应数据，则返回默认值
}
} catch (e) {
console.error("Failed to deserialize ".concat(key, ":"), e);
return defaultValue; // 若反序列化失败，则返回默认值
}
}
// 删除指定的键值对
function removeItem(key) {
try {
localStorage.removeItem(key);
} catch (e) {
console.error("Failed to remove ".concat(key, ":"), e);
}
}
// 清空所有 localStorage 数据
function clear() {
try {
localStorage.clear();
} catch (e) {
console.error("Failed to clear localStorage:", e);
}
}
;// ./src/config/autoReadConfig.js
var storageKey = {
READ_CONFIG: "READ_CONFIG"
};
var defaultReadConfig = {
isAutoReading: false,
readStep: 100,
readIntervalMillis: 100,
readDirection: "down",
autoSwitchPageDirection: "right",
autoSwitchPage: false,
autoRefresh: false,
autoRefreshSeconds: 60,
readWith: 1024,
autoWith: false,
showToolbar: false,
randomSleep: false,
sleepTimeSeconds: 60,
// 无限卡天数
infiniteCardDays: 0,
// ios端书币
iosBookCoin: 0,
// 安卓端书币
androidBookCoin: 0,
// 当前阅读时长
currentReadingTime: 0,
// 总共阅读时长
totalReadingTime: 0
};
// 更新部分配置
function updatePartialReadConfig(partialConfig) {
var readConfig = getItem(storageKey.READ_CONFIG, defaultReadConfig);
Object.assign(readConfig, partialConfig);
setItem(storageKey.READ_CONFIG, readConfig);
}
;// ./node_modules/mitt/dist/mitt.mjs
/* harmony default export */ function mitt(n){return{all:n=n||new Map,on:function(t,e){var i=n.get(t);i?i.push(e):n.set(t,[e])},off:function(t,e){var i=n.get(t);i&&(e?i.splice(i.indexOf(e)>>>0,1):n.set(t,[]))},emit:function(t,e){var i=n.get(t);i&&i.slice().map(function(n){n(e)}),(i=n.get("*"))&&i.slice().map(function(n){n(t,e)})}}}
//# sourceMappingURL=mitt.mjs.map
;// ./src/helper/eventHelper.js
var emitter = mitt();
var eventKey = {
READ_CONFIG_UPDATE_EVENT: "READ_CONFIG_UPDATE_EVENT"
};
// 监听事件
function onEvent(eventKey, callback) {
emitter.on(eventKey, callback);
}
// 取消事件监听
function offEvent(eventKey, callback) {
emitter.off(eventKey, callback);
}
// 触发事件
function fireEvent(eventKey, data) {
emitter.emit(eventKey, data);
}
;// ./node_modules/babel-loader/lib/index.js!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[7].use[0]!./src/component/panel/ReadConfigCard.vue?vue&type=script&setup=true&lang=js
/* harmony default export */ var ReadConfigCardvue_type_script_setup_true_lang_js = ({
__name: 'ReadConfigCard',
props: {
config: {
type: Object,
required: true,
default: {}
}
},
setup: function setup(__props) {
var props = __props;
var config = reactive({
readStep: 100,
readIntervalMillis: 100,
readDirection: "down",
autoSwitchPageDirection: "right",
autoSwitchPage: false,
autoRefresh: false,
autoRefreshSeconds: 10
});
if (props.config) {
Object.assign(config, props.config);
}
// 监听
runtime_core_esm_bundler_watch(config, function (newVal) {
updatePartialReadConfig(newVal);
emitter.emit(eventKey.READ_CONFIG_UPDATE_EVENT, newVal);
});
return function (_ctx, _cache) {
var _component_n_input_number = resolveComponent("n-input-number");
var _component_n_form_item = resolveComponent("n-form-item");
var _component_n_radio = resolveComponent("n-radio");
var _component_n_space = resolveComponent("n-space");
var _component_n_radio_group = resolveComponent("n-radio-group");
var _component_n_form = resolveComponent("n-form");
var _component_n_alert = resolveComponent("n-alert");
var _component_n_card = resolveComponent("n-card");
return openBlock(), createBlock(_component_n_card, {
class: "readConfig",
size: "small",
bordered: false,
title: "阅读设置",
segmented: {
content: true,
footer: 'soft'
}
}, {
default: withCtx(function () {
return [createVNode(_component_n_form, {
size: "small",
"label-placement": "left",
model: config,
"label-width": "auto"
}, {
default: withCtx(function () {
return [createVNode(_component_n_form_item, {
label: "自动步长"
}, {
default: withCtx(function () {
return [createVNode(_component_n_input_number, {
placeholder: "",
value: config.readStep,
"onUpdate:value": _cache[0] || (_cache[0] = function ($event) {
return config.readStep = $event;
}),
"button-placement": "both",
min: 1,
max: 1000
}, {
suffix: withCtx(function () {
return _cache[7] || (_cache[7] = [createTextVNode("像素")]);
}),
_: 1
}, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_form_item, {
label: "滚动间隔"
}, {
default: withCtx(function () {
return [createVNode(_component_n_input_number, {
placeholder: "",
value: config.readIntervalMillis,
"onUpdate:value": _cache[1] || (_cache[1] = function ($event) {
return config.readIntervalMillis = $event;
}),
"button-placement": "both",
min: 2,
max: 10000
}, {
suffix: withCtx(function () {
return _cache[8] || (_cache[8] = [createTextVNode("毫秒")]);
}),
_: 1
}, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_form_item, {
label: "阅读方向"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio_group, {
value: config.readDirection,
"onUpdate:value": _cache[2] || (_cache[2] = function ($event) {
return config.readDirection = $event;
})
}, {
default: withCtx(function () {
return [createVNode(_component_n_space, {
justify: "space-evenly"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio, {
value: "up"
}, {
default: withCtx(function () {
return _cache[9] || (_cache[9] = [createTextVNode("往上")]);
}),
_: 1
}), createVNode(_component_n_radio, {
value: "down"
}, {
default: withCtx(function () {
return _cache[10] || (_cache[10] = [createTextVNode("往下")]);
}),
_: 1
})];
}),
_: 1
})];
}),
_: 1
}, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_form_item, {
label: "自动翻页"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio_group, {
value: config.autoSwitchPage,
"onUpdate:value": _cache[3] || (_cache[3] = function ($event) {
return config.autoSwitchPage = $event;
})
}, {
default: withCtx(function () {
return [createVNode(_component_n_space, {
justify: "space-evenly"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio, {
value: true
}, {
default: withCtx(function () {
return _cache[11] || (_cache[11] = [createTextVNode("开启")]);
}),
_: 1
}), createVNode(_component_n_radio, {
value: false
}, {
default: withCtx(function () {
return _cache[12] || (_cache[12] = [createTextVNode("关闭")]);
}),
_: 1
})];
}),
_: 1
})];
}),
_: 1
}, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_form_item, {
label: "翻页方向"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio_group, {
disabled: !config.autoSwitchPage,
value: config.autoSwitchPageDirection,
"onUpdate:value": _cache[4] || (_cache[4] = function ($event) {
return config.autoSwitchPageDirection = $event;
})
}, {
default: withCtx(function () {
return [createVNode(_component_n_space, {
justify: "space-evenly"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio, {
value: "LEFT"
}, {
default: withCtx(function () {
return _cache[13] || (_cache[13] = [createTextVNode("往左")]);
}),
_: 1
}), createVNode(_component_n_radio, {
value: "RIGHT"
}, {
default: withCtx(function () {
return _cache[14] || (_cache[14] = [createTextVNode("往右")]);
}),
_: 1
})];
}),
_: 1
})];
}),
_: 1
}, 8, ["disabled", "value"])];
}),
_: 1
}), createVNode(_component_n_form_item, {
label: "❗️定时刷新"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio_group, {
value: config.autoRefresh,
"onUpdate:value": _cache[5] || (_cache[5] = function ($event) {
return config.autoRefresh = $event;
})
}, {
default: withCtx(function () {
return [createVNode(_component_n_space, {
justify: "space-evenly"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio, {
value: true
}, {
default: withCtx(function () {
return _cache[15] || (_cache[15] = [createTextVNode("开启")]);
}),
_: 1
}), createVNode(_component_n_radio, {
value: false
}, {
default: withCtx(function () {
return _cache[16] || (_cache[16] = [createTextVNode("关闭")]);
}),
_: 1
})];
}),
_: 1
})];
}),
_: 1
}, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_form_item, {
label: "刷新间隔"
}, {
default: withCtx(function () {
return [createVNode(_component_n_input_number, {
disabled: !config.autoRefresh,
placeholder: "",
value: config.autoRefreshSeconds,
"onUpdate:value": _cache[6] || (_cache[6] = function ($event) {
return config.autoRefreshSeconds = $event;
}),
"button-placement": "both",
min: 5,
max: 3600
}, {
suffix: withCtx(function () {
return _cache[17] || (_cache[17] = [createTextVNode("秒")]);
}),
_: 1
}, 8, ["disabled", "value"])];
}),
_: 1
})];
}),
_: 1
}, 8, ["model"]), createVNode(_component_n_alert, {
bordered: false,
type: "success"
}, {
default: withCtx(function () {
return _cache[18] || (_cache[18] = [createTextVNode("提示：ctrl+回车键 可快速 开启/关闭 自动阅读")]);
}),
_: 1
})];
}),
_: 1
});
};
}
});
;// ./src/component/panel/ReadConfigCard.vue?vue&type=script&setup=true&lang=js
;// ./src/component/panel/ReadConfigCard.vue
const __exports__ = ReadConfigCardvue_type_script_setup_true_lang_js;
/* harmony default export */ var ReadConfigCard = (__exports__);
;// ./node_modules/babel-loader/lib/index.js!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[7].use[0]!./src/component/panel/OtherConfigCard.vue?vue&type=script&setup=true&lang=js
/* harmony default export */ var OtherConfigCardvue_type_script_setup_true_lang_js = ({
__name: 'OtherConfigCard',
props: {
config: {
type: Object,
required: true,
default: {}
}
},
setup: function setup(__props) {
var props = __props;
var config = reactive({
readWith: 1024,
autoWith: false,
showToolbar: false,
randomSleep: false,
sleepTimeSeconds: 60
});
if (props.config) {
Object.assign(config, props.config);
}
// 监听
runtime_core_esm_bundler_watch(config, function (newVal) {
updatePartialReadConfig(newVal);
});
return function (_ctx, _cache) {
var _component_n_input_number = resolveComponent("n-input-number");
var _component_n_form_item = resolveComponent("n-form-item");
var _component_n_radio = resolveComponent("n-radio");
var _component_n_space = resolveComponent("n-space");
var _component_n_radio_group = resolveComponent("n-radio-group");
var _component_n_form = resolveComponent("n-form");
var _component_n_card = resolveComponent("n-card");
return openBlock(), createBlock(_component_n_card, {
class: "readConfig",
size: "small",
bordered: false,
title: "其他设置[待开发]",
segmented: {
content: true,
footer: 'soft'
}
}, {
default: withCtx(function () {
return [createVNode(_component_n_form, {
size: "small",
disabled: "",
"label-placement": "left",
model: config,
"label-width": "auto"
}, {
default: withCtx(function () {
return [createVNode(_component_n_form_item, {
label: "阅读宽度"
}, {
default: withCtx(function () {
return [createVNode(_component_n_input_number, {
placeholder: "",
value: config.readWith,
"onUpdate:value": _cache[0] || (_cache[0] = function ($event) {
return config.readWith = $event;
}),
"button-placement": "both",
min: 1,
max: 4096
}, {
suffix: withCtx(function () {
return _cache[5] || (_cache[5] = [createTextVNode("像素")]);
}),
_: 1
}, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_form_item, {
label: "自动宽度"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio_group, {
value: config.autoWith,
"onUpdate:value": _cache[1] || (_cache[1] = function ($event) {
return config.autoWith = $event;
})
}, {
default: withCtx(function () {
return [createVNode(_component_n_space, {
justify: "space-evenly"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio, {
value: true
}, {
default: withCtx(function () {
return _cache[6] || (_cache[6] = [createTextVNode("开启")]);
}),
_: 1
}), createVNode(_component_n_radio, {
value: false
}, {
default: withCtx(function () {
return _cache[7] || (_cache[7] = [createTextVNode("关闭")]);
}),
_: 1
})];
}),
_: 1
})];
}),
_: 1
}, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_form_item, {
label: "工具栏"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio_group, {
value: config.showToolbar,
"onUpdate:value": _cache[2] || (_cache[2] = function ($event) {
return config.showToolbar = $event;
})
}, {
default: withCtx(function () {
return [createVNode(_component_n_space, {
justify: "space-evenly"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio, {
value: true
}, {
default: withCtx(function () {
return _cache[8] || (_cache[8] = [createTextVNode("显示")]);
}),
_: 1
}), createVNode(_component_n_radio, {
value: false
}, {
default: withCtx(function () {
return _cache[9] || (_cache[9] = [createTextVNode("隐藏")]);
}),
_: 1
})];
}),
_: 1
})];
}),
_: 1
}, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_form_item, {
label: "随机休眠"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio_group, {
value: config.randomSleep,
"onUpdate:value": _cache[3] || (_cache[3] = function ($event) {
return config.randomSleep = $event;
})
}, {
default: withCtx(function () {
return [createVNode(_component_n_space, {
justify: "space-evenly"
}, {
default: withCtx(function () {
return [createVNode(_component_n_radio, {
value: true
}, {
default: withCtx(function () {
return _cache[10] || (_cache[10] = [createTextVNode("开启")]);
}),
_: 1
}), createVNode(_component_n_radio, {
value: false
}, {
default: withCtx(function () {
return _cache[11] || (_cache[11] = [createTextVNode("关闭")]);
}),
_: 1
})];
}),
_: 1
})];
}),
_: 1
}, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_form_item, {
label: "休眠时长"
}, {
default: withCtx(function () {
return [createVNode(_component_n_input_number, {
placeholder: "",
value: config.sleepTimeSeconds,
"onUpdate:value": _cache[4] || (_cache[4] = function ($event) {
return config.sleepTimeSeconds = $event;
}),
"button-placement": "both",
min: 1,
max: 1000
}, {
suffix: withCtx(function () {
return _cache[12] || (_cache[12] = [createTextVNode("秒")]);
}),
_: 1
}, 8, ["value"])];
}),
_: 1
})];
}),
_: 1
}, 8, ["model"])];
}),
_: 1
});
};
}
});
;// ./src/component/panel/OtherConfigCard.vue?vue&type=script&setup=true&lang=js
;// ./src/component/panel/OtherConfigCard.vue
const OtherConfigCard_exports_ = OtherConfigCardvue_type_script_setup_true_lang_js;
/* harmony default export */ var OtherConfigCard = (OtherConfigCard_exports_);
;// ./node_modules/babel-loader/lib/index.js!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[7].use[0]!./src/component/panel/MiniCard.vue?vue&type=script&setup=true&lang=js
var MiniCardvue_type_script_setup_true_lang_js_hoisted_1 = {
class: "account-info"
};
var _hoisted_2 = {
style: {
"color": "grey"
}
};
var _hoisted_3 = {
class: "count-number"
};
/* harmony default export */ var MiniCardvue_type_script_setup_true_lang_js = ({
__name: 'MiniCard',
props: {
title: {
type: String,
default: '-'
},
value: {
type: String,
default: '-'
},
unit: {
type: String,
default: '-'
}
},
setup: function setup(__props) {
return function (_ctx, _cache) {
var _component_n_space = resolveComponent("n-space");
return openBlock(), createElementBlock("div", MiniCardvue_type_script_setup_true_lang_js_hoisted_1, [createVNode(_component_n_space, {
vertical: ""
}, {
default: withCtx(function () {
return [createBaseVNode("span", null, toDisplayString(__props.title), 1), createBaseVNode("strong", _hoisted_2, [createBaseVNode("span", _hoisted_3, toDisplayString(__props.value), 1), createTextVNode(" " + toDisplayString(__props.unit), 1)])];
}),
_: 1
})]);
};
}
});
;// ./src/component/panel/MiniCard.vue?vue&type=script&setup=true&lang=js
// EXTERNAL MODULE: ./node_modules/vue-style-loader/index.js!./node_modules/css-loader/dist/cjs.js!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[7].use[0]!./src/component/panel/MiniCard.vue?vue&type=style&index=0&id=5aabe62b&scoped=true&lang=css
var MiniCardvue_type_style_index_0_id_5aabe62b_scoped_true_lang_css = __webpack_require__(848);
;// ./src/component/panel/MiniCard.vue?vue&type=style&index=0&id=5aabe62b&scoped=true&lang=css
// EXTERNAL MODULE: ./node_modules/vue-loader/dist/exportHelper.js
var exportHelper = __webpack_require__(262);
;// ./src/component/panel/MiniCard.vue
;
const MiniCard_exports_ = /*#__PURE__*/(0,exportHelper/* default */.A)(MiniCardvue_type_script_setup_true_lang_js, [['__scopeId',"data-v-5aabe62b"]])
/* harmony default export */ var MiniCard = (MiniCard_exports_);
;// ./node_modules/axios/lib/helpers/bind.js
function bind(fn, thisArg) {
return function wrap() {
return fn.apply(thisArg, arguments);
};
}
;// ./node_modules/axios/lib/utils.js
// utils is a library of generic helper functions non-specific to axios
const {toString: utils_toString} = Object.prototype;
const {getPrototypeOf} = Object;
const {iterator: utils_iterator, toStringTag} = Symbol;
const kindOf = (cache => thing => {
const str = utils_toString.call(thing);
return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
})(Object.create(null));
const kindOfTest = (type) => {
type = type.toLowerCase();
return (thing) => kindOf(thing) === type
}
const typeOfTest = type => thing => typeof thing === type;
/**
* Determine if a value is an Array
*
* @param {Object} val The value to test
*
* @returns {boolean} True if value is an Array, otherwise false
*/
const {isArray: utils_isArray} = Array;
/**
* Determine if a value is undefined
*
* @param {*} val The value to test
*
* @returns {boolean} True if the value is undefined, otherwise false
*/
const isUndefined = typeOfTest('undefined');
/**
* Determine if a value is a Buffer
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a Buffer, otherwise false
*/
function isBuffer(val) {
return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
&& utils_isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
}
/**
* Determine if a value is an ArrayBuffer
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is an ArrayBuffer, otherwise false
*/
const isArrayBuffer = kindOfTest('ArrayBuffer');
/**
* Determine if a value is a view on an ArrayBuffer
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
*/
function isArrayBufferView(val) {
let result;
if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
result = ArrayBuffer.isView(val);
} else {
result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));
}
return result;
}
/**
* Determine if a value is a String
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a String, otherwise false
*/
const utils_isString = typeOfTest('string');
/**
* Determine if a value is a Function
*
* @param {*} val The value to test
* @returns {boolean} True if value is a Function, otherwise false
*/
const utils_isFunction = typeOfTest('function');
/**
* Determine if a value is a Number
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a Number, otherwise false
*/
const isNumber = typeOfTest('number');
/**
* Determine if a value is an Object
*
* @param {*} thing The value to test
*
* @returns {boolean} True if value is an Object, otherwise false
*/
const utils_isObject = (thing) => thing !== null && typeof thing === 'object';
/**
* Determine if a value is a Boolean
*
* @param {*} thing The value to test
* @returns {boolean} True if value is a Boolean, otherwise false
*/
const utils_isBoolean = thing => thing === true || thing === false;
/**
* Determine if a value is a plain Object
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a plain Object, otherwise false
*/
const utils_isPlainObject = (val) => {
if (kindOf(val) !== 'object') {
return false;
}
const prototype = getPrototypeOf(val);
return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(toStringTag in val) && !(utils_iterator in val);
}
/**
* Determine if a value is a Date
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a Date, otherwise false
*/
const utils_isDate = kindOfTest('Date');
/**
* Determine if a value is a File
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a File, otherwise false
*/
const isFile = kindOfTest('File');
/**
* Determine if a value is a Blob
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a Blob, otherwise false
*/
const isBlob = kindOfTest('Blob');
/**
* Determine if a value is a FileList
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a File, otherwise false
*/
const isFileList = kindOfTest('FileList');
/**
* Determine if a value is a Stream
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a Stream, otherwise false
*/
const isStream = (val) => utils_isObject(val) && utils_isFunction(val.pipe);
/**
* Determine if a value is a FormData
*
* @param {*} thing The value to test
*
* @returns {boolean} True if value is an FormData, otherwise false
*/
const isFormData = (thing) => {
let kind;
return thing && (
(typeof FormData === 'function' && thing instanceof FormData) || (
utils_isFunction(thing.append) && (
(kind = kindOf(thing)) === 'formdata' ||
// detect form-data instance
(kind === 'object' && utils_isFunction(thing.toString) && thing.toString() === '[object FormData]')
)
)
)
}
/**
* Determine if a value is a URLSearchParams object
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a URLSearchParams object, otherwise false
*/
const isURLSearchParams = kindOfTest('URLSearchParams');
const [isReadableStream, isRequest, isResponse, isHeaders] = ['ReadableStream', 'Request', 'Response', 'Headers'].map(kindOfTest);
/**
* Trim excess whitespace off the beginning and end of a string
*
* @param {String} str The String to trim
*
* @returns {String} The String freed of excess whitespace
*/
const trim = (str) => str.trim ?
str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
/**
* Iterate over an Array or an Object invoking a function for each item.
*
* If `obj` is an Array callback will be called passing
* the value, index, and complete array for each item.
*
* If 'obj' is an Object callback will be called passing
* the value, key, and complete object for each property.
*
* @param {Object|Array} obj The object to iterate
* @param {Function} fn The callback to invoke for each item
*
* @param {Boolean} [allOwnKeys = false]
* @returns {any}
*/
function forEach(obj, fn, {allOwnKeys = false} = {}) {
// Don't bother if no value provided
if (obj === null || typeof obj === 'undefined') {
return;
}
let i;
let l;
// Force an array if not already something iterable
if (typeof obj !== 'object') {
/*eslint no-param-reassign:0*/
obj = [obj];
}
if (utils_isArray(obj)) {
// Iterate over array values
for (i = 0, l = obj.length; i < l; i++) {
fn.call(null, obj[i], i, obj);
}
} else {
// Iterate over object keys
const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
const len = keys.length;
let key;
for (i = 0; i < len; i++) {
key = keys[i];
fn.call(null, obj[key], key, obj);
}
}
}
function findKey(obj, key) {
key = key.toLowerCase();
const keys = Object.keys(obj);
let i = keys.length;
let _key;
while (i-- > 0) {
_key = keys[i];
if (key === _key.toLowerCase()) {
return _key;
}
}
return null;
}
const _global = (() => {
/*eslint no-undef:0*/
if (typeof globalThis !== "undefined") return globalThis;
return typeof self !== "undefined" ? self : (typeof window !== 'undefined' ? window : global)
})();
const isContextDefined = (context) => !isUndefined(context) && context !== _global;
/**
* Accepts varargs expecting each argument to be an object, then
* immutably merges the properties of each object and returns result.
*
* When multiple objects contain the same key the later object in
* the arguments list will take precedence.
*
* Example:
*
* ```js
* var result = merge({foo: 123}, {foo: 456});
* console.log(result.foo); // outputs 456
* ```
*
* @param {Object} obj1 Object to merge
*
* @returns {Object} Result of all merge properties
*/
function merge(/* obj1, obj2, obj3, ... */) {
const {caseless} = isContextDefined(this) && this || {};
const result = {};
const assignValue = (val, key) => {
const targetKey = caseless && findKey(result, key) || key;
if (utils_isPlainObject(result[targetKey]) && utils_isPlainObject(val)) {
result[targetKey] = merge(result[targetKey], val);
} else if (utils_isPlainObject(val)) {
result[targetKey] = merge({}, val);
} else if (utils_isArray(val)) {
result[targetKey] = val.slice();
} else {
result[targetKey] = val;
}
}
for (let i = 0, l = arguments.length; i < l; i++) {
arguments[i] && forEach(arguments[i], assignValue);
}
return result;
}
/**
* Extends object a by mutably adding to it the properties of object b.
*
* @param {Object} a The object to be extended
* @param {Object} b The object to copy properties from
* @param {Object} thisArg The object to bind function to
*
* @param {Boolean} [allOwnKeys]
* @returns {Object} The resulting value of object a
*/
const utils_extend = (a, b, thisArg, {allOwnKeys}= {}) => {
forEach(b, (val, key) => {
if (thisArg && utils_isFunction(val)) {
a[key] = bind(val, thisArg);
} else {
a[key] = val;
}
}, {allOwnKeys});
return a;
}
/**
* Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
*
* @param {string} content with BOM
*
* @returns {string} content value without BOM
*/
const stripBOM = (content) => {
if (content.charCodeAt(0) === 0xFEFF) {
content = content.slice(1);
}
return content;
}
/**
* Inherit the prototype methods from one constructor into another
* @param {function} constructor
* @param {function} superConstructor
* @param {object} [props]
* @param {object} [descriptors]
*
* @returns {void}
*/
const inherits = (constructor, superConstructor, props, descriptors) => {
constructor.prototype = Object.create(superConstructor.prototype, descriptors);
constructor.prototype.constructor = constructor;
Object.defineProperty(constructor, 'super', {
value: superConstructor.prototype
});
props && Object.assign(constructor.prototype, props);
}
/**
* Resolve object with deep prototype chain to a flat object
* @param {Object} sourceObj source object
* @param {Object} [destObj]
* @param {Function|Boolean} [filter]
* @param {Function} [propFilter]
*
* @returns {Object}
*/
const toFlatObject = (sourceObj, destObj, filter, propFilter) => {
let props;
let i;
let prop;
const merged = {};
destObj = destObj || {};
// eslint-disable-next-line no-eq-null,eqeqeq
if (sourceObj == null) return destObj;
do {
props = Object.getOwnPropertyNames(sourceObj);
i = props.length;
while (i-- > 0) {
prop = props[i];
if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
destObj[prop] = sourceObj[prop];
merged[prop] = true;
}
}
sourceObj = filter !== false && getPrototypeOf(sourceObj);
} while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
return destObj;
}
/**
* Determines whether a string ends with the characters of a specified string
*
* @param {String} str
* @param {String} searchString
* @param {Number} [position= 0]
*
* @returns {boolean}
*/
const endsWith = (str, searchString, position) => {
str = String(str);
if (position === undefined || position > str.length) {
position = str.length;
}
position -= searchString.length;
const lastIndex = str.indexOf(searchString, position);
return lastIndex !== -1 && lastIndex === position;
}
/**
* Returns new array from array like object or null if failed
*
* @param {*} [thing]
*
* @returns {?Array}
*/
const toArray = (thing) => {
if (!thing) return null;
if (utils_isArray(thing)) return thing;
let i = thing.length;
if (!isNumber(i)) return null;
const arr = new Array(i);
while (i-- > 0) {
arr[i] = thing[i];
}
return arr;
}
/**
* Checking if the Uint8Array exists and if it does, it returns a function that checks if the
* thing passed in is an instance of Uint8Array
*
* @param {TypedArray}
*
* @returns {Array}
*/
// eslint-disable-next-line func-names
const isTypedArray = (TypedArray => {
// eslint-disable-next-line func-names
return thing => {
return TypedArray && thing instanceof TypedArray;
};
})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));
/**
* For each entry in the object, call the function with the key and value.
*
* @param {Object<any, any>} obj - The object to iterate over.
* @param {Function} fn - The function to call for each entry.
*
* @returns {void}
*/
const forEachEntry = (obj, fn) => {
const generator = obj && obj[utils_iterator];
const _iterator = generator.call(obj);
let result;
while ((result = _iterator.next()) && !result.done) {
const pair = result.value;
fn.call(obj, pair[0], pair[1]);
}
}
/**
* It takes a regular expression and a string, and returns an array of all the matches
*
* @param {string} regExp - The regular expression to match against.
* @param {string} str - The string to search.
*
* @returns {Array<boolean>}
*/
const matchAll = (regExp, str) => {
let matches;
const arr = [];
while ((matches = regExp.exec(str)) !== null) {
arr.push(matches);
}
return arr;
}
/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */
const isHTMLForm = kindOfTest('HTMLFormElement');
const toCamelCase = str => {
return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,
function replacer(m, p1, p2) {
return p1.toUpperCase() + p2;
}
);
};
/* Creating a function that will check if an object has a property. */
const utils_hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);
/**
* Determine if a value is a RegExp object
*
* @param {*} val The value to test
*
* @returns {boolean} True if value is a RegExp object, otherwise false
*/
const utils_isRegExp = kindOfTest('RegExp');
const reduceDescriptors = (obj, reducer) => {
const descriptors = Object.getOwnPropertyDescriptors(obj);
const reducedDescriptors = {};
forEach(descriptors, (descriptor, name) => {
let ret;
if ((ret = reducer(descriptor, name, obj)) !== false) {
reducedDescriptors[name] = ret || descriptor;
}
});
Object.defineProperties(obj, reducedDescriptors);
}
/**
* Makes all methods read-only
* @param {Object} obj
*/
const freezeMethods = (obj) => {
reduceDescriptors(obj, (descriptor, name) => {
// skip restricted props in strict mode
if (utils_isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
return false;
}
const value = obj[name];
if (!utils_isFunction(value)) return;
descriptor.enumerable = false;
if ('writable' in descriptor) {
descriptor.writable = false;
return;
}
if (!descriptor.set) {
descriptor.set = () => {
throw Error('Can not rewrite read-only method \'' + name + '\'');
};
}
});
}
const toObjectSet = (arrayOrString, delimiter) => {
const obj = {};
const define = (arr) => {
arr.forEach(value => {
obj[value] = true;
});
}
utils_isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
return obj;
}
const noop = () => {}
const toFiniteNumber = (value, defaultValue) => {
return value != null && Number.isFinite(value = +value) ? value : defaultValue;
}
/**
* If the thing is a FormData object, return true, otherwise return false.
*
* @param {unknown} thing - The thing to check.
*
* @returns {boolean}
*/
function isSpecCompliantForm(thing) {
return !!(thing && utils_isFunction(thing.append) && thing[toStringTag] === 'FormData' && thing[utils_iterator]);
}
const toJSONObject = (obj) => {
const stack = new Array(10);
const visit = (source, i) => {
if (utils_isObject(source)) {
if (stack.indexOf(source) >= 0) {
return;
}
if(!('toJSON' in source)) {
stack[i] = source;
const target = utils_isArray(source) ? [] : {};
forEach(source, (value, key) => {
const reducedValue = visit(value, i + 1);
!isUndefined(reducedValue) && (target[key] = reducedValue);
});
stack[i] = undefined;
return target;
}
}
return source;
}
return visit(obj, 0);
}
const isAsyncFn = kindOfTest('AsyncFunction');
const isThenable = (thing) =>
thing && (utils_isObject(thing) || utils_isFunction(thing)) && utils_isFunction(thing.then) && utils_isFunction(thing.catch);
// original code
// https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34
const _setImmediate = ((setImmediateSupported, postMessageSupported) => {
if (setImmediateSupported) {
return setImmediate;
}
return postMessageSupported ? ((token, callbacks) => {
_global.addEventListener("message", ({source, data}) => {
if (source === _global && data === token) {
callbacks.length && callbacks.shift()();
}
}, false);
return (cb) => {
callbacks.push(cb);
_global.postMessage(token, "*");
}
})(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
})(
typeof setImmediate === 'function',
utils_isFunction(_global.postMessage)
);
const asap = typeof queueMicrotask !== 'undefined' ?
queueMicrotask.bind(_global) : ( typeof process !== 'undefined' && process.nextTick || _setImmediate);
// *********************
const isIterable = (thing) => thing != null && utils_isFunction(thing[utils_iterator]);
/* harmony default export */ var utils = ({
isArray: utils_isArray,
isArrayBuffer,
isBuffer,
isFormData,
isArrayBufferView,
isString: utils_isString,
isNumber,
isBoolean: utils_isBoolean,
isObject: utils_isObject,
isPlainObject: utils_isPlainObject,
isReadableStream,
isRequest,
isResponse,
isHeaders,
isUndefined,
isDate: utils_isDate,
isFile,
isBlob,
isRegExp: utils_isRegExp,
isFunction: utils_isFunction,
isStream,
isURLSearchParams,
isTypedArray,
isFileList,
forEach,
merge,
extend: utils_extend,
trim,
stripBOM,
inherits,
toFlatObject,
kindOf,
kindOfTest,
endsWith,
toArray,
forEachEntry,
matchAll,
isHTMLForm,
hasOwnProperty: utils_hasOwnProperty,
hasOwnProp: utils_hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection
reduceDescriptors,
freezeMethods,
toObjectSet,
toCamelCase,
noop,
toFiniteNumber,
findKey,
global: _global,
isContextDefined,
isSpecCompliantForm,
toJSONObject,
isAsyncFn,
isThenable,
setImmediate: _setImmediate,
asap,
isIterable
});
;// ./node_modules/axios/lib/core/AxiosError.js
/**
* Create an Error with the specified message, config, error code, request and response.
*
* @param {string} message The error message.
* @param {string} [code] The error code (for example, 'ECONNABORTED').
* @param {Object} [config] The config.
* @param {Object} [request] The request.
* @param {Object} [response] The response.
*
* @returns {Error} The created error.
*/
function AxiosError(message, code, config, request, response) {
Error.call(this);
if (Error.captureStackTrace) {
Error.captureStackTrace(this, this.constructor);
} else {
this.stack = (new Error()).stack;
}
this.message = message;
this.name = 'AxiosError';
code && (this.code = code);
config && (this.config = config);
request && (this.request = request);
if (response) {
this.response = response;
this.status = response.status ? response.status : null;
}
}
utils.inherits(AxiosError, Error, {
toJSON: function toJSON() {
return {
// Standard
message: this.message,
name: this.name,
// Microsoft
description: this.description,
number: this.number,
// Mozilla
fileName: this.fileName,
lineNumber: this.lineNumber,
columnNumber: this.columnNumber,
stack: this.stack,
// Axios
config: utils.toJSONObject(this.config),
code: this.code,
status: this.status
};
}
});
const AxiosError_prototype = AxiosError.prototype;
const descriptors = {};
[
'ERR_BAD_OPTION_VALUE',
'ERR_BAD_OPTION',
'ECONNABORTED',
'ETIMEDOUT',
'ERR_NETWORK',
'ERR_FR_TOO_MANY_REDIRECTS',
'ERR_DEPRECATED',
'ERR_BAD_RESPONSE',
'ERR_BAD_REQUEST',
'ERR_CANCELED',
'ERR_NOT_SUPPORT',
'ERR_INVALID_URL'
// eslint-disable-next-line func-names
].forEach(code => {
descriptors[code] = {value: code};
});
Object.defineProperties(AxiosError, descriptors);
Object.defineProperty(AxiosError_prototype, 'isAxiosError', {value: true});
// eslint-disable-next-line func-names
AxiosError.from = (error, code, config, request, response, customProps) => {
const axiosError = Object.create(AxiosError_prototype);
utils.toFlatObject(error, axiosError, function filter(obj) {
return obj !== Error.prototype;
}, prop => {
return prop !== 'isAxiosError';
});
AxiosError.call(axiosError, error.message, code, config, request, response);
axiosError.cause = error;
axiosError.name = error.name;
customProps && Object.assign(axiosError, customProps);
return axiosError;
};
/* harmony default export */ var core_AxiosError = (AxiosError);
;// ./node_modules/axios/lib/helpers/null.js
// eslint-disable-next-line strict
/* harmony default export */ var helpers_null = (null);
;// ./node_modules/axios/lib/helpers/toFormData.js
// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored
/**
* Determines if the given thing is a array or js object.
*
* @param {string} thing - The object or array to be visited.
*
* @returns {boolean}
*/
function isVisitable(thing) {
return utils.isPlainObject(thing) || utils.isArray(thing);
}
/**
* It removes the brackets from the end of a string
*
* @param {string} key - The key of the parameter.
*
* @returns {string} the key without the brackets.
*/
function removeBrackets(key) {
return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;
}
/**
* It takes a path, a key, and a boolean, and returns a string
*
* @param {string} path - The path to the current key.
* @param {string} key - The key of the current object being iterated over.
* @param {string} dots - If true, the key will be rendered with dots instead of brackets.
*
* @returns {string} The path to the current key.
*/
function renderKey(path, key, dots) {
if (!path) return key;
return path.concat(key).map(function each(token, i) {
// eslint-disable-next-line no-param-reassign
token = removeBrackets(token);
return !dots && i ? '[' + token + ']' : token;
}).join(dots ? '.' : '');
}
/**
* If the array is an array and none of its elements are visitable, then it's a flat array.
*
* @param {Array<any>} arr - The array to check
*
* @returns {boolean}
*/
function isFlatArray(arr) {
return utils.isArray(arr) && !arr.some(isVisitable);
}
const predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {
return /^is[A-Z]/.test(prop);
});
/**
* Convert a data object to FormData
*
* @param {Object} obj
* @param {?Object} [formData]
* @param {?Object} [options]
* @param {Function} [options.visitor]
* @param {Boolean} [options.metaTokens = true]
* @param {Boolean} [options.dots = false]
* @param {?Boolean} [options.indexes = false]
*
* @returns {Object}
**/
/**
* It converts an object into a FormData object
*
* @param {Object<any, any>} obj - The object to convert to form data.
* @param {string} formData - The FormData object to append to.
* @param {Object<string, any>} options
*
* @returns
*/
function toFormData(obj, formData, options) {
if (!utils.isObject(obj)) {
throw new TypeError('target must be an object');
}
// eslint-disable-next-line no-param-reassign
formData = formData || new (helpers_null || FormData)();
// eslint-disable-next-line no-param-reassign
options = utils.toFlatObject(options, {
metaTokens: true,
dots: false,
indexes: false
}, false, function defined(option, source) {
// eslint-disable-next-line no-eq-null,eqeqeq
return !utils.isUndefined(source[option]);
});
const metaTokens = options.metaTokens;
// eslint-disable-next-line no-use-before-define
const visitor = options.visitor || defaultVisitor;
const dots = options.dots;
const indexes = options.indexes;
const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;
const useBlob = _Blob && utils.isSpecCompliantForm(formData);
if (!utils.isFunction(visitor)) {
throw new TypeError('visitor must be a function');
}
function convertValue(value) {
if (value === null) return '';
if (utils.isDate(value)) {
return value.toISOString();
}
if (utils.isBoolean(value)) {
return value.toString();
}
if (!useBlob && utils.isBlob(value)) {
throw new core_AxiosError('Blob is not supported. Use a Buffer instead.');
}
if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {
return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);
}
return value;
}
/**
* Default visitor.
*
* @param {*} value
* @param {String|Number} key
* @param {Array<String|Number>} path
* @this {FormData}
*
* @returns {boolean} return true to visit the each prop of the value recursively
*/
function defaultVisitor(value, key, path) {
let arr = value;
if (value && !path && typeof value === 'object') {
if (utils.endsWith(key, '{}')) {
// eslint-disable-next-line no-param-reassign
key = metaTokens ? key : key.slice(0, -2);
// eslint-disable-next-line no-param-reassign
value = JSON.stringify(value);
} else if (
(utils.isArray(value) && isFlatArray(value)) ||
((utils.isFileList(value) || utils.endsWith(key, '[]')) && (arr = utils.toArray(value))
)) {
// eslint-disable-next-line no-param-reassign
key = removeBrackets(key);
arr.forEach(function each(el, index) {
!(utils.isUndefined(el) || el === null) && formData.append(
// eslint-disable-next-line no-nested-ternary
indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),
convertValue(el)
);
});
return false;
}
}
if (isVisitable(value)) {
return true;
}
formData.append(renderKey(path, key, dots), convertValue(value));
return false;
}
const stack = [];
const exposedHelpers = Object.assign(predicates, {
defaultVisitor,
convertValue,
isVisitable
});
function build(value, path) {
if (utils.isUndefined(value)) return;
if (stack.indexOf(value) !== -1) {
throw Error('Circular reference detected in ' + path.join('.'));
}
stack.push(value);
utils.forEach(value, function each(el, key) {
const result = !(utils.isUndefined(el) || el === null) && visitor.call(
formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers
);
if (result === true) {
build(el, path ? path.concat(key) : [key]);
}
});
stack.pop();
}
if (!utils.isObject(obj)) {
throw new TypeError('data must be an object');
}
build(obj);
return formData;
}
/* harmony default export */ var helpers_toFormData = (toFormData);
;// ./node_modules/axios/lib/helpers/AxiosURLSearchParams.js
/**
* It encodes a string by replacing all characters that are not in the unreserved set with
* their percent-encoded equivalents
*
* @param {string} str - The string to encode.
*
* @returns {string} The encoded string.
*/
function encode(str) {
const charMap = {
'!': '%21',
"'": '%27',
'(': '%28',
')': '%29',
'~': '%7E',
'%20': '+',
'%00': '\x00'
};
return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
return charMap[match];
});
}
/**
* It takes a params object and converts it to a FormData object
*
* @param {Object<string, any>} params - The parameters to be converted to a FormData object.
* @param {Object<string, any>} options - The options object passed to the Axios constructor.
*
* @returns {void}
*/
function AxiosURLSearchParams(params, options) {
this._pairs = [];
params && helpers_toFormData(params, this, options);
}
const AxiosURLSearchParams_prototype = AxiosURLSearchParams.prototype;
AxiosURLSearchParams_prototype.append = function append(name, value) {
this._pairs.push([name, value]);
};
AxiosURLSearchParams_prototype.toString = function toString(encoder) {
const _encode = encoder ? function(value) {
return encoder.call(this, value, encode);
} : encode;
return this._pairs.map(function each(pair) {
return _encode(pair[0]) + '=' + _encode(pair[1]);
}, '').join('&');
};
/* harmony default export */ var helpers_AxiosURLSearchParams = (AxiosURLSearchParams);
;// ./node_modules/axios/lib/helpers/buildURL.js
/**
* It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
* URI encoded counterparts
*
* @param {string} val The value to be encoded.
*
* @returns {string} The encoded value.
*/
function buildURL_encode(val) {
return encodeURIComponent(val).
replace(/%3A/gi, ':').
replace(/%24/g, '$').
replace(/%2C/gi, ',').
replace(/%20/g, '+').
replace(/%5B/gi, '[').
replace(/%5D/gi, ']');
}
/**
* Build a URL by appending params to the end
*
* @param {string} url The base of the url (e.g., http://www.google.com)
* @param {object} [params] The params to be appended
* @param {?(object|Function)} options
*
* @returns {string} The formatted url
*/
function buildURL(url, params, options) {
/*eslint no-param-reassign:0*/
if (!params) {
return url;
}
const _encode = options && options.encode || buildURL_encode;
if (utils.isFunction(options)) {
options = {
serialize: options
};
}
const serializeFn = options && options.serialize;
let serializedParams;
if (serializeFn) {
serializedParams = serializeFn(params, options);
} else {
serializedParams = utils.isURLSearchParams(params) ?
params.toString() :
new helpers_AxiosURLSearchParams(params, options).toString(_encode);
}
if (serializedParams) {
const hashmarkIndex = url.indexOf("#");
if (hashmarkIndex !== -1) {
url = url.slice(0, hashmarkIndex);
}
url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
}
return url;
}
;// ./node_modules/axios/lib/core/InterceptorManager.js
class InterceptorManager {
constructor() {
this.handlers = [];
}
/**
* Add a new interceptor to the stack
*
* @param {Function} fulfilled The function to handle `then` for a `Promise`
* @param {Function} rejected The function to handle `reject` for a `Promise`
*
* @return {Number} An ID used to remove interceptor later
*/
use(fulfilled, rejected, options) {
this.handlers.push({
fulfilled,
rejected,
synchronous: options ? options.synchronous : false,
runWhen: options ? options.runWhen : null
});
return this.handlers.length - 1;
}
/**
* Remove an interceptor from the stack
*
* @param {Number} id The ID that was returned by `use`
*
* @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
*/
eject(id) {
if (this.handlers[id]) {
this.handlers[id] = null;
}
}
/**
* Clear all interceptors from the stack
*
* @returns {void}
*/
clear() {
if (this.handlers) {
this.handlers = [];
}
}
/**
* Iterate over all the registered interceptors
*
* This method is particularly useful for skipping over any
* interceptors that may have become `null` calling `eject`.
*
* @param {Function} fn The function to call for each interceptor
*
* @returns {void}
*/
forEach(fn) {
utils.forEach(this.handlers, function forEachHandler(h) {
if (h !== null) {
fn(h);
}
});
}
}
/* harmony default export */ var core_InterceptorManager = (InterceptorManager);
;// ./node_modules/axios/lib/defaults/transitional.js
/* harmony default export */ var defaults_transitional = ({
silentJSONParsing: true,
forcedJSONParsing: true,
clarifyTimeoutError: false
});
;// ./node_modules/axios/lib/platform/browser/classes/URLSearchParams.js
/* harmony default export */ var classes_URLSearchParams = (typeof URLSearchParams !== 'undefined' ? URLSearchParams : helpers_AxiosURLSearchParams);
;// ./node_modules/axios/lib/platform/browser/classes/FormData.js
/* harmony default export */ var classes_FormData = (typeof FormData !== 'undefined' ? FormData : null);
;// ./node_modules/axios/lib/platform/browser/classes/Blob.js
/* harmony default export */ var classes_Blob = (typeof Blob !== 'undefined' ? Blob : null);
;// ./node_modules/axios/lib/platform/browser/index.js
/* harmony default export */ var browser = ({
isBrowser: true,
classes: {
URLSearchParams: classes_URLSearchParams,
FormData: classes_FormData,
Blob: classes_Blob
},
protocols: ['http', 'https', 'file', 'blob', 'url', 'data']
});
;// ./node_modules/axios/lib/platform/common/utils.js
const hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined';
const _navigator = typeof navigator === 'object' && navigator || undefined;
/**
* Determine if we're running in a standard browser environment
*
* This allows axios to run in a web worker, and react-native.
* Both environments support XMLHttpRequest, but not fully standard globals.
*
* web workers:
* typeof window -> undefined
* typeof document -> undefined
*
* react-native:
* navigator.product -> 'ReactNative'
* nativescript
* navigator.product -> 'NativeScript' or 'NS'
*
* @returns {boolean}
*/
const hasStandardBrowserEnv = hasBrowserEnv &&
(!_navigator || ['ReactNative', 'NativeScript', 'NS'].indexOf(_navigator.product) < 0);
/**
* Determine if we're running in a standard browser webWorker environment
*
* Although the `isStandardBrowserEnv` method indicates that
* `allows axios to run in a web worker`, the WebWorker will still be
* filtered out due to its judgment standard
* `typeof window !== 'undefined' && typeof document !== 'undefined'`.
* This leads to a problem when axios post `FormData` in webWorker
*/
const hasStandardBrowserWebWorkerEnv = (() => {
return (
typeof WorkerGlobalScope !== 'undefined' &&
// eslint-disable-next-line no-undef
self instanceof WorkerGlobalScope &&
typeof self.importScripts === 'function'
);
})();
const origin = hasBrowserEnv && window.location.href || 'http://localhost';
;// ./node_modules/axios/lib/platform/index.js
/* harmony default export */ var platform = ({
...common_utils_namespaceObject,
...browser
});
;// ./node_modules/axios/lib/helpers/toURLEncodedForm.js
function toURLEncodedForm(data, options) {
return helpers_toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
visitor: function(value, key, path, helpers) {
if (platform.isNode && utils.isBuffer(value)) {
this.append(key, value.toString('base64'));
return false;
}
return helpers.defaultVisitor.apply(this, arguments);
}
}, options));
}
;// ./node_modules/axios/lib/helpers/formDataToJSON.js
/**
* It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
*
* @param {string} name - The name of the property to get.
*
* @returns An array of strings.
*/
function parsePropPath(name) {
// foo[x][y][z]
// foo.x.y.z
// foo-x-y-z
// foo x y z
return utils.matchAll(/\w+|\[(\w*)]/g, name).map(match => {
return match[0] === '[]' ? '' : match[1] || match[0];
});
}
/**
* Convert an array to an object.
*
* @param {Array<any>} arr - The array to convert to an object.
*
* @returns An object with the same keys and values as the array.
*/
function arrayToObject(arr) {
const obj = {};
const keys = Object.keys(arr);
let i;
const len = keys.length;
let key;
for (i = 0; i < len; i++) {
key = keys[i];
obj[key] = arr[key];
}
return obj;
}
/**
* It takes a FormData object and returns a JavaScript object
*
* @param {string} formData The FormData object to convert to JSON.
*
* @returns {Object<string, any> | null} The converted object.
*/
function formDataToJSON(formData) {
function buildPath(path, value, target, index) {
let name = path[index++];
if (name === '__proto__') return true;
const isNumericKey = Number.isFinite(+name);
const isLast = index >= path.length;
name = !name && utils.isArray(target) ? target.length : name;
if (isLast) {
if (utils.hasOwnProp(target, name)) {
target[name] = [target[name], value];
} else {
target[name] = value;
}
return !isNumericKey;
}
if (!target[name] || !utils.isObject(target[name])) {
target[name] = [];
}
const result = buildPath(path, value, target[name], index);
if (result && utils.isArray(target[name])) {
target[name] = arrayToObject(target[name]);
}
return !isNumericKey;
}
if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {
const obj = {};
utils.forEachEntry(formData, (name, value) => {
buildPath(parsePropPath(name), value, obj, 0);
});
return obj;
}
return null;
}
/* harmony default export */ var helpers_formDataToJSON = (formDataToJSON);
;// ./node_modules/axios/lib/defaults/index.js
/**
* It takes a string, tries to parse it, and if it fails, it returns the stringified version
* of the input
*
* @param {any} rawValue - The value to be stringified.
* @param {Function} parser - A function that parses a string into a JavaScript object.
* @param {Function} encoder - A function that takes a value and returns a string.
*
* @returns {string} A stringified version of the rawValue.
*/
function stringifySafely(rawValue, parser, encoder) {
if (utils.isString(rawValue)) {
try {
(parser || JSON.parse)(rawValue);
return utils.trim(rawValue);
} catch (e) {
if (e.name !== 'SyntaxError') {
throw e;
}
}
}
return (encoder || JSON.stringify)(rawValue);
}
const defaults = {
transitional: defaults_transitional,
adapter: ['xhr', 'http', 'fetch'],
transformRequest: [function transformRequest(data, headers) {
const contentType = headers.getContentType() || '';
const hasJSONContentType = contentType.indexOf('application/json') > -1;
const isObjectPayload = utils.isObject(data);
if (isObjectPayload && utils.isHTMLForm(data)) {
data = new FormData(data);
}
const isFormData = utils.isFormData(data);
if (isFormData) {
return hasJSONContentType ? JSON.stringify(helpers_formDataToJSON(data)) : data;
}
if (utils.isArrayBuffer(data) ||
utils.isBuffer(data) ||
utils.isStream(data) ||
utils.isFile(data) ||
utils.isBlob(data) ||
utils.isReadableStream(data)
) {
return data;
}
if (utils.isArrayBufferView(data)) {
return data.buffer;
}
if (utils.isURLSearchParams(data)) {
headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
return data.toString();
}
let isFileList;
if (isObjectPayload) {
if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
return toURLEncodedForm(data, this.formSerializer).toString();
}
if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
const _FormData = this.env && this.env.FormData;
return helpers_toFormData(
isFileList ? {'files[]': data} : data,
_FormData && new _FormData(),
this.formSerializer
);
}
}
if (isObjectPayload || hasJSONContentType ) {
headers.setContentType('application/json', false);
return stringifySafely(data);
}
return data;
}],
transformResponse: [function transformResponse(data) {
const transitional = this.transitional || defaults.transitional;
const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
const JSONRequested = this.responseType === 'json';
if (utils.isResponse(data) || utils.isReadableStream(data)) {
return data;
}
if (data && utils.isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {
const silentJSONParsing = transitional && transitional.silentJSONParsing;
const strictJSONParsing = !silentJSONParsing && JSONRequested;
try {
return JSON.parse(data);
} catch (e) {
if (strictJSONParsing) {
if (e.name === 'SyntaxError') {
throw core_AxiosError.from(e, core_AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
}
throw e;
}
}
}
return data;
}],
/**
* A timeout in milliseconds to abort a request. If set to 0 (default) a
* timeout is not created.
*/
timeout: 0,
xsrfCookieName: 'XSRF-TOKEN',
xsrfHeaderName: 'X-XSRF-TOKEN',
maxContentLength: -1,
maxBodyLength: -1,
env: {
FormData: platform.classes.FormData,
Blob: platform.classes.Blob
},
validateStatus: function validateStatus(status) {
return status >= 200 && status < 300;
},
headers: {
common: {
'Accept': 'application/json, text/plain, */*',
'Content-Type': undefined
}
}
};
utils.forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => {
defaults.headers[method] = {};
});
/* harmony default export */ var lib_defaults = (defaults);
;// ./node_modules/axios/lib/helpers/parseHeaders.js
// RawAxiosHeaders whose duplicates are ignored by node
// c.f. https://nodejs.org/api/http.html#http_message_headers
const ignoreDuplicateOf = utils.toObjectSet([
'age', 'authorization', 'content-length', 'content-type', 'etag',
'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
'last-modified', 'location', 'max-forwards', 'proxy-authorization',
'referer', 'retry-after', 'user-agent'
]);
/**
* Parse headers into an object
*
* ```
* Date: Wed, 27 Aug 2014 08:58:49 GMT
* Content-Type: application/json
* Connection: keep-alive
* Transfer-Encoding: chunked
* ```
*
* @param {String} rawHeaders Headers needing to be parsed
*
* @returns {Object} Headers parsed into an object
*/
/* harmony default export */ var parseHeaders = (rawHeaders => {
const parsed = {};
let key;
let val;
let i;
rawHeaders && rawHeaders.split('\n').forEach(function parser(line) {
i = line.indexOf(':');
key = line.substring(0, i).trim().toLowerCase();
val = line.substring(i + 1).trim();
if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
return;
}
if (key === 'set-cookie') {
if (parsed[key]) {
parsed[key].push(val);
} else {
parsed[key] = [val];
}
} else {
parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
}
});
return parsed;
});
;// ./node_modules/axios/lib/core/AxiosHeaders.js
const $internals = Symbol('internals');
function normalizeHeader(header) {
return header && String(header).trim().toLowerCase();
}
function normalizeValue(value) {
if (value === false || value == null) {
return value;
}
return utils.isArray(value) ? value.map(normalizeValue) : String(value);
}
function parseTokens(str) {
const tokens = Object.create(null);
const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
let match;
while ((match = tokensRE.exec(str))) {
tokens[match[1]] = match[2];
}
return tokens;
}
const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
if (utils.isFunction(filter)) {
return filter.call(this, value, header);
}
if (isHeaderNameFilter) {
value = header;
}
if (!utils.isString(value)) return;
if (utils.isString(filter)) {
return value.indexOf(filter) !== -1;
}
if (utils.isRegExp(filter)) {
return filter.test(value);
}
}
function formatHeader(header) {
return header.trim()
.toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
return char.toUpperCase() + str;
});
}
function buildAccessors(obj, header) {
const accessorName = utils.toCamelCase(' ' + header);
['get', 'set', 'has'].forEach(methodName => {
Object.defineProperty(obj, methodName + accessorName, {
value: function(arg1, arg2, arg3) {
return this[methodName].call(this, header, arg1, arg2, arg3);
},
configurable: true
});
});
}
class AxiosHeaders {
constructor(headers) {
headers && this.set(headers);
}
set(header, valueOrRewrite, rewrite) {
const self = this;
function setHeader(_value, _header, _rewrite) {
const lHeader = normalizeHeader(_header);
if (!lHeader) {
throw new Error('header name must be a non-empty string');
}
const key = utils.findKey(self, lHeader);
if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {
self[key || _header] = normalizeValue(_value);
}
}
const setHeaders = (headers, _rewrite) =>
utils.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
if (utils.isPlainObject(header) || header instanceof this.constructor) {
setHeaders(header, valueOrRewrite)
} else if(utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
setHeaders(parseHeaders(header), valueOrRewrite);
} else if (utils.isObject(header) && utils.isIterable(header)) {
let obj = {}, dest, key;
for (const entry of header) {
if (!utils.isArray(entry)) {
throw TypeError('Object iterator must return a key-value pair');
}
obj[key = entry[0]] = (dest = obj[key]) ?
(utils.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]]) : entry[1];
}
setHeaders(obj, valueOrRewrite)
} else {
header != null && setHeader(valueOrRewrite, header, rewrite);
}
return this;
}
get(header, parser) {
header = normalizeHeader(header);
if (header) {
const key = utils.findKey(this, header);
if (key) {
const value = this[key];
if (!parser) {
return value;
}
if (parser === true) {
return parseTokens(value);
}
if (utils.isFunction(parser)) {
return parser.call(this, value, key);
}
if (utils.isRegExp(parser)) {
return parser.exec(value);
}
throw new TypeError('parser must be boolean|regexp|function');
}
}
}
has(header, matcher) {
header = normalizeHeader(header);
if (header) {
const key = utils.findKey(this, header);
return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
}
return false;
}
delete(header, matcher) {
const self = this;
let deleted = false;
function deleteHeader(_header) {
_header = normalizeHeader(_header);
if (_header) {
const key = utils.findKey(self, _header);
if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
delete self[key];
deleted = true;
}
}
}
if (utils.isArray(header)) {
header.forEach(deleteHeader);
} else {
deleteHeader(header);
}
return deleted;
}
clear(matcher) {
const keys = Object.keys(this);
let i = keys.length;
let deleted = false;
while (i--) {
const key = keys[i];
if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
delete this[key];
deleted = true;
}
}
return deleted;
}
normalize(format) {
const self = this;
const headers = {};
utils.forEach(this, (value, header) => {
const key = utils.findKey(headers, header);
if (key) {
self[key] = normalizeValue(value);
delete self[header];
return;
}
const normalized = format ? formatHeader(header) : String(header).trim();
if (normalized !== header) {
delete self[header];
}
self[normalized] = normalizeValue(value);
headers[normalized] = true;
});
return this;
}
concat(...targets) {
return this.constructor.concat(this, ...targets);
}
toJSON(asStrings) {
const obj = Object.create(null);
utils.forEach(this, (value, header) => {
value != null && value !== false && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);
});
return obj;
}
[Symbol.iterator]() {
return Object.entries(this.toJSON())[Symbol.iterator]();
}
toString() {
return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\n');
}
getSetCookie() {
return this.get("set-cookie") || [];
}
get [Symbol.toStringTag]() {
return 'AxiosHeaders';
}
static from(thing) {
return thing instanceof this ? thing : new this(thing);
}
static concat(first, ...targets) {
const computed = new this(first);
targets.forEach((target) => computed.set(target));
return computed;
}
static accessor(header) {
const internals = this[$internals] = (this[$internals] = {
accessors: {}
});
const accessors = internals.accessors;
const prototype = this.prototype;
function defineAccessor(_header) {
const lHeader = normalizeHeader(_header);
if (!accessors[lHeader]) {
buildAccessors(prototype, _header);
accessors[lHeader] = true;
}
}
utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
return this;
}
}
AxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);
// reserved names hotfix
utils.reduceDescriptors(AxiosHeaders.prototype, ({value}, key) => {
let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`
return {
get: () => value,
set(headerValue) {
this[mapped] = headerValue;
}
}
});
utils.freezeMethods(AxiosHeaders);
/* harmony default export */ var core_AxiosHeaders = (AxiosHeaders);
;// ./node_modules/axios/lib/core/transformData.js
/**
* Transform the data for a request or a response
*
* @param {Array|Function} fns A single function or Array of functions
* @param {?Object} response The response object
*
* @returns {*} The resulting transformed data
*/
function transformData(fns, response) {
const config = this || lib_defaults;
const context = response || config;
const headers = core_AxiosHeaders.from(context.headers);
let data = context.data;
utils.forEach(fns, function transform(fn) {
data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
});
headers.normalize();
return data;
}
;// ./node_modules/axios/lib/cancel/isCancel.js
function isCancel(value) {
return !!(value && value.__CANCEL__);
}
;// ./node_modules/axios/lib/cancel/CanceledError.js
/**
* A `CanceledError` is an object that is thrown when an operation is canceled.
*
* @param {string=} message The message.
* @param {Object=} config The config.
* @param {Object=} request The request.
*
* @returns {CanceledError} The created error.
*/
function CanceledError(message, config, request) {
// eslint-disable-next-line no-eq-null,eqeqeq
core_AxiosError.call(this, message == null ? 'canceled' : message, core_AxiosError.ERR_CANCELED, config, request);
this.name = 'CanceledError';
}
utils.inherits(CanceledError, core_AxiosError, {
__CANCEL__: true
});
/* harmony default export */ var cancel_CanceledError = (CanceledError);
;// ./node_modules/axios/lib/core/settle.js
/**
* Resolve or reject a Promise based on response status.
*
* @param {Function} resolve A function that resolves the promise.
* @param {Function} reject A function that rejects the promise.
* @param {object} response The response.
*
* @returns {object} The response.
*/
function settle(resolve, reject, response) {
const validateStatus = response.config.validateStatus;
if (!response.status || !validateStatus || validateStatus(response.status)) {
resolve(response);
} else {
reject(new core_AxiosError(
'Request failed with status code ' + response.status,
[core_AxiosError.ERR_BAD_REQUEST, core_AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
response.config,
response.request,
response
));
}
}
;// ./node_modules/axios/lib/helpers/parseProtocol.js
function parseProtocol(url) {
const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
return match && match[1] || '';
}
;// ./node_modules/axios/lib/helpers/speedometer.js
/**
* Calculate data maxRate
* @param {Number} [samplesCount= 10]
* @param {Number} [min= 1000]
* @returns {Function}
*/
function speedometer(samplesCount, min) {
samplesCount = samplesCount || 10;
const bytes = new Array(samplesCount);
const timestamps = new Array(samplesCount);
let head = 0;
let tail = 0;
let firstSampleTS;
min = min !== undefined ? min : 1000;
return function push(chunkLength) {
const now = Date.now();
const startedAt = timestamps[tail];
if (!firstSampleTS) {
firstSampleTS = now;
}
bytes[head] = chunkLength;
timestamps[head] = now;
let i = tail;
let bytesCount = 0;
while (i !== head) {
bytesCount += bytes[i++];
i = i % samplesCount;
}
head = (head + 1) % samplesCount;
if (head === tail) {
tail = (tail + 1) % samplesCount;
}
if (now - firstSampleTS < min) {
return;
}
const passed = startedAt && now - startedAt;
return passed ? Math.round(bytesCount * 1000 / passed) : undefined;
};
}
/* harmony default export */ var helpers_speedometer = (speedometer);
;// ./node_modules/axios/lib/helpers/throttle.js
/**
* Throttle decorator
* @param {Function} fn
* @param {Number} freq
* @return {Function}
*/
function throttle(fn, freq) {
let timestamp = 0;
let threshold = 1000 / freq;
let lastArgs;
let timer;
const invoke = (args, now = Date.now()) => {
timestamp = now;
lastArgs = null;
if (timer) {
clearTimeout(timer);
timer = null;
}
fn.apply(null, args);
}
const throttled = (...args) => {
const now = Date.now();
const passed = now - timestamp;
if ( passed >= threshold) {
invoke(args, now);
} else {
lastArgs = args;
if (!timer) {
timer = setTimeout(() => {
timer = null;
invoke(lastArgs)
}, threshold - passed);
}
}
}
const flush = () => lastArgs && invoke(lastArgs);
return [throttled, flush];
}
/* harmony default export */ var helpers_throttle = (throttle);
;// ./node_modules/axios/lib/helpers/progressEventReducer.js
const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
let bytesNotified = 0;
const _speedometer = helpers_speedometer(50, 250);
return helpers_throttle(e => {
const loaded = e.loaded;
const total = e.lengthComputable ? e.total : undefined;
const progressBytes = loaded - bytesNotified;
const rate = _speedometer(progressBytes);
const inRange = loaded <= total;
bytesNotified = loaded;
const data = {
loaded,
total,
progress: total ? (loaded / total) : undefined,
bytes: progressBytes,
rate: rate ? rate : undefined,
estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
event: e,
lengthComputable: total != null,
[isDownloadStream ? 'download' : 'upload']: true
};
listener(data);
}, freq);
}
const progressEventDecorator = (total, throttled) => {
const lengthComputable = total != null;
return [(loaded) => throttled[0]({
lengthComputable,
total,
loaded
}), throttled[1]];
}
const asyncDecorator = (fn) => (...args) => utils.asap(() => fn(...args));
;// ./node_modules/axios/lib/helpers/isURLSameOrigin.js
/* harmony default export */ var isURLSameOrigin = (platform.hasStandardBrowserEnv ? ((origin, isMSIE) => (url) => {
url = new URL(url, platform.origin);
return (
origin.protocol === url.protocol &&
origin.host === url.host &&
(isMSIE || origin.port === url.port)
);
})(
new URL(platform.origin),
platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)
) : () => true);
;// ./node_modules/axios/lib/helpers/cookies.js
/* harmony default export */ var cookies = (platform.hasStandardBrowserEnv ?
// Standard browser envs support document.cookie
{
write(name, value, expires, path, domain, secure) {
const cookie = [name + '=' + encodeURIComponent(value)];
utils.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());
utils.isString(path) && cookie.push('path=' + path);
utils.isString(domain) && cookie.push('domain=' + domain);
secure === true && cookie.push('secure');
document.cookie = cookie.join('; ');
},
read(name) {
const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
return (match ? decodeURIComponent(match[3]) : null);
},
remove(name) {
this.write(name, '', Date.now() - 86400000);
}
}
:
// Non-standard browser env (web workers, react-native) lack needed support.
{
write() {},
read() {
return null;
},
remove() {}
});
;// ./node_modules/axios/lib/helpers/isAbsoluteURL.js
/**
* Determines whether the specified URL is absolute
*
* @param {string} url The URL to test
*
* @returns {boolean} True if the specified URL is absolute, otherwise false
*/
function isAbsoluteURL(url) {
// A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
// RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
// by any combination of letters, digits, plus, period, or hyphen.
return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
}
;// ./node_modules/axios/lib/helpers/combineURLs.js
/**
* Creates a new URL by combining the specified URLs
*
* @param {string} baseURL The base URL
* @param {string} relativeURL The relative URL
*
* @returns {string} The combined URL
*/
function combineURLs(baseURL, relativeURL) {
return relativeURL
? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')
: baseURL;
}
;// ./node_modules/axios/lib/core/buildFullPath.js
/**
* Creates a new URL by combining the baseURL with the requestedURL,
* only when the requestedURL is not already an absolute URL.
* If the requestURL is absolute, this function returns the requestedURL untouched.
*
* @param {string} baseURL The base URL
* @param {string} requestedURL Absolute or relative URL to combine
*
* @returns {string} The combined full path
*/
function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
let isRelativeUrl = !isAbsoluteURL(requestedURL);
if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
return combineURLs(baseURL, requestedURL);
}
return requestedURL;
}
;// ./node_modules/axios/lib/core/mergeConfig.js
const headersToObject = (thing) => thing instanceof core_AxiosHeaders ? { ...thing } : thing;
/**
* Config-specific merge-function which creates a new config-object
* by merging two configuration objects together.
*
* @param {Object} config1
* @param {Object} config2
*
* @returns {Object} New object resulting from merging config2 to config1
*/
function mergeConfig(config1, config2) {
// eslint-disable-next-line no-param-reassign
config2 = config2 || {};
const config = {};
function getMergedValue(target, source, prop, caseless) {
if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
return utils.merge.call({caseless}, target, source);
} else if (utils.isPlainObject(source)) {
return utils.merge({}, source);
} else if (utils.isArray(source)) {
return source.slice();
}
return source;
}
// eslint-disable-next-line consistent-return
function mergeDeepProperties(a, b, prop , caseless) {
if (!utils.isUndefined(b)) {
return getMergedValue(a, b, prop , caseless);
} else if (!utils.isUndefined(a)) {
return getMergedValue(undefined, a, prop , caseless);
}
}
// eslint-disable-next-line consistent-return
function valueFromConfig2(a, b) {
if (!utils.isUndefined(b)) {
return getMergedValue(undefined, b);
}
}
// eslint-disable-next-line consistent-return
function defaultToConfig2(a, b) {
if (!utils.isUndefined(b)) {
return getMergedValue(undefined, b);
} else if (!utils.isUndefined(a)) {
return getMergedValue(undefined, a);
}
}
// eslint-disable-next-line consistent-return
function mergeDirectKeys(a, b, prop) {
if (prop in config2) {
return getMergedValue(a, b);
} else if (prop in config1) {
return getMergedValue(undefined, a);
}
}
const mergeMap = {
url: valueFromConfig2,
method: valueFromConfig2,
data: valueFromConfig2,
baseURL: defaultToConfig2,
transformRequest: defaultToConfig2,
transformResponse: defaultToConfig2,
paramsSerializer: defaultToConfig2,
timeout: defaultToConfig2,
timeoutMessage: defaultToConfig2,
withCredentials: defaultToConfig2,
withXSRFToken: defaultToConfig2,
adapter: defaultToConfig2,
responseType: defaultToConfig2,
xsrfCookieName: defaultToConfig2,
xsrfHeaderName: defaultToConfig2,
onUploadProgress: defaultToConfig2,
onDownloadProgress: defaultToConfig2,
decompress: defaultToConfig2,
maxContentLength: defaultToConfig2,
maxBodyLength: defaultToConfig2,
beforeRedirect: defaultToConfig2,
transport: defaultToConfig2,
httpAgent: defaultToConfig2,
httpsAgent: defaultToConfig2,
cancelToken: defaultToConfig2,
socketPath: defaultToConfig2,
responseEncoding: defaultToConfig2,
validateStatus: mergeDirectKeys,
headers: (a, b , prop) => mergeDeepProperties(headersToObject(a), headersToObject(b),prop, true)
};
utils.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
const merge = mergeMap[prop] || mergeDeepProperties;
const configValue = merge(config1[prop], config2[prop], prop);
(utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
});
return config;
}
;// ./node_modules/axios/lib/helpers/resolveConfig.js
/* harmony default export */ var resolveConfig = ((config) => {
const newConfig = mergeConfig({}, config);
let {data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth} = newConfig;
newConfig.headers = headers = core_AxiosHeaders.from(headers);
newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);
// HTTP basic authentication
if (auth) {
headers.set('Authorization', 'Basic ' +
btoa((auth.username || '') + ':' + (auth.password ? unescape(encodeURIComponent(auth.password)) : ''))
);
}
let contentType;
if (utils.isFormData(data)) {
if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
headers.setContentType(undefined); // Let the browser set it
} else if ((contentType = headers.getContentType()) !== false) {
// fix semicolon duplication issue for ReactNative FormData implementation
const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];
headers.setContentType([type || 'multipart/form-data', ...tokens].join('; '));
}
}
// Add xsrf header
// This is only done if running in a standard browser environment.
// Specifically not if we're in a web worker, or react-native.
if (platform.hasStandardBrowserEnv) {
withXSRFToken && utils.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));
if (withXSRFToken || (withXSRFToken !== false && isURLSameOrigin(newConfig.url))) {
// Add xsrf header
const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);
if (xsrfValue) {
headers.set(xsrfHeaderName, xsrfValue);
}
}
}
return newConfig;
});
;// ./node_modules/axios/lib/adapters/xhr.js
const isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';
/* harmony default export */ var xhr = (isXHRAdapterSupported && function (config) {
return new Promise(function dispatchXhrRequest(resolve, reject) {
const _config = resolveConfig(config);
let requestData = _config.data;
const requestHeaders = core_AxiosHeaders.from(_config.headers).normalize();
let {responseType, onUploadProgress, onDownloadProgress} = _config;
let onCanceled;
let uploadThrottled, downloadThrottled;
let flushUpload, flushDownload;
function done() {
flushUpload && flushUpload(); // flush events
flushDownload && flushDownload(); // flush events
_config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
_config.signal && _config.signal.removeEventListener('abort', onCanceled);
}
let request = new XMLHttpRequest();
request.open(_config.method.toUpperCase(), _config.url, true);
// Set the request timeout in MS
request.timeout = _config.timeout;
function onloadend() {
if (!request) {
return;
}
// Prepare the response
const responseHeaders = core_AxiosHeaders.from(
'getAllResponseHeaders' in request && request.getAllResponseHeaders()
);
const responseData = !responseType || responseType === 'text' || responseType === 'json' ?
request.responseText : request.response;
const response = {
data: responseData,
status: request.status,
statusText: request.statusText,
headers: responseHeaders,
config,
request
};
settle(function _resolve(value) {
resolve(value);
done();
}, function _reject(err) {
reject(err);
done();
}, response);
// Clean up request
request = null;
}
if ('onloadend' in request) {
// Use onloadend if available
request.onloadend = onloadend;
} else {
// Listen for ready state to emulate onloadend
request.onreadystatechange = function handleLoad() {
if (!request || request.readyState !== 4) {
return;
}
// The request errored out and we didn't get a response, this will be
// handled by onerror instead
// With one exception: request that using file: protocol, most browsers
// will return status as 0 even though it's a successful request
if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
return;
}
// readystate handler is calling before onerror or ontimeout handlers,
// so we should call onloadend on the next 'tick'
setTimeout(onloadend);
};
}
// Handle browser request cancellation (as opposed to a manual cancellation)
request.onabort = function handleAbort() {
if (!request) {
return;
}
reject(new core_AxiosError('Request aborted', core_AxiosError.ECONNABORTED, config, request));
// Clean up request
request = null;
};
// Handle low level network errors
request.onerror = function handleError() {
// Real errors are hidden from us by the browser
// onerror should only fire if it's a network error
reject(new core_AxiosError('Network Error', core_AxiosError.ERR_NETWORK, config, request));
// Clean up request
request = null;
};
// Handle timeout
request.ontimeout = function handleTimeout() {
let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded';
const transitional = _config.transitional || defaults_transitional;
if (_config.timeoutErrorMessage) {
timeoutErrorMessage = _config.timeoutErrorMessage;
}
reject(new core_AxiosError(
timeoutErrorMessage,
transitional.clarifyTimeoutError ? core_AxiosError.ETIMEDOUT : core_AxiosError.ECONNABORTED,
config,
request));
// Clean up request
request = null;
};
// Remove Content-Type if data is undefined
requestData === undefined && requestHeaders.setContentType(null);
// Add headers to the request
if ('setRequestHeader' in request) {
utils.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
request.setRequestHeader(key, val);
});
}
// Add withCredentials to request if needed
if (!utils.isUndefined(_config.withCredentials)) {
request.withCredentials = !!_config.withCredentials;
}
// Add responseType to request if needed
if (responseType && responseType !== 'json') {
request.responseType = _config.responseType;
}
// Handle progress if needed
if (onDownloadProgress) {
([downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true));
request.addEventListener('progress', downloadThrottled);
}
// Not all browsers support upload events
if (onUploadProgress && request.upload) {
([uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress));
request.upload.addEventListener('progress', uploadThrottled);
request.upload.addEventListener('loadend', flushUpload);
}
if (_config.cancelToken || _config.signal) {
// Handle cancellation
// eslint-disable-next-line func-names
onCanceled = cancel => {
if (!request) {
return;
}
reject(!cancel || cancel.type ? new cancel_CanceledError(null, config, request) : cancel);
request.abort();
request = null;
};
_config.cancelToken && _config.cancelToken.subscribe(onCanceled);
if (_config.signal) {
_config.signal.aborted ? onCanceled() : _config.signal.addEventListener('abort', onCanceled);
}
}
const protocol = parseProtocol(_config.url);
if (protocol && platform.protocols.indexOf(protocol) === -1) {
reject(new core_AxiosError('Unsupported protocol ' + protocol + ':', core_AxiosError.ERR_BAD_REQUEST, config));
return;
}
// Send the request
request.send(requestData || null);
});
});
;// ./node_modules/axios/lib/helpers/composeSignals.js
const composeSignals = (signals, timeout) => {
const {length} = (signals = signals ? signals.filter(Boolean) : []);
if (timeout || length) {
let controller = new AbortController();
let aborted;
const onabort = function (reason) {
if (!aborted) {
aborted = true;
unsubscribe();
const err = reason instanceof Error ? reason : this.reason;
controller.abort(err instanceof core_AxiosError ? err : new cancel_CanceledError(err instanceof Error ? err.message : err));
}
}
let timer = timeout && setTimeout(() => {
timer = null;
onabort(new core_AxiosError(`timeout ${timeout} of ms exceeded`, core_AxiosError.ETIMEDOUT))
}, timeout)
const unsubscribe = () => {
if (signals) {
timer && clearTimeout(timer);
timer = null;
signals.forEach(signal => {
signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort);
});
signals = null;
}
}
signals.forEach((signal) => signal.addEventListener('abort', onabort));
const {signal} = controller;
signal.unsubscribe = () => utils.asap(unsubscribe);
return signal;
}
}
/* harmony default export */ var helpers_composeSignals = (composeSignals);
;// ./node_modules/axios/lib/helpers/trackStream.js
const streamChunk = function* (chunk, chunkSize) {
let len = chunk.byteLength;
if (!chunkSize || len < chunkSize) {
yield chunk;
return;
}
let pos = 0;
let end;
while (pos < len) {
end = pos + chunkSize;
yield chunk.slice(pos, end);
pos = end;
}
}
const readBytes = async function* (iterable, chunkSize) {
for await (const chunk of readStream(iterable)) {
yield* streamChunk(chunk, chunkSize);
}
}
const readStream = async function* (stream) {
if (stream[Symbol.asyncIterator]) {
yield* stream;
return;
}
const reader = stream.getReader();
try {
for (;;) {
const {done, value} = await reader.read();
if (done) {
break;
}
yield value;
}
} finally {
await reader.cancel();
}
}
const trackStream = (stream, chunkSize, onProgress, onFinish) => {
const iterator = readBytes(stream, chunkSize);
let bytes = 0;
let done;
let _onFinish = (e) => {
if (!done) {
done = true;
onFinish && onFinish(e);
}
}
return new ReadableStream({
async pull(controller) {
try {
const {done, value} = await iterator.next();
if (done) {
_onFinish();
controller.close();
return;
}
let len = value.byteLength;
if (onProgress) {
let loadedBytes = bytes += len;
onProgress(loadedBytes);
}
controller.enqueue(new Uint8Array(value));
} catch (err) {
_onFinish(err);
throw err;
}
},
cancel(reason) {
_onFinish(reason);
return iterator.return();
}
}, {
highWaterMark: 2
})
}
;// ./node_modules/axios/lib/adapters/fetch.js
const isFetchSupported = typeof fetch === 'function' && typeof Request === 'function' && typeof Response === 'function';
const isReadableStreamSupported = isFetchSupported && typeof ReadableStream === 'function';
// used only inside the fetch adapter
const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?
((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :
async (str) => new Uint8Array(await new Response(str).arrayBuffer())
);
const test = (fn, ...args) => {
try {
return !!fn(...args);
} catch (e) {
return false
}
}
const supportsRequestStream = isReadableStreamSupported && test(() => {
let duplexAccessed = false;
const hasContentType = new Request(platform.origin, {
body: new ReadableStream(),
method: 'POST',
get duplex() {
duplexAccessed = true;
return 'half';
},
}).headers.has('Content-Type');
return duplexAccessed && !hasContentType;
});
const DEFAULT_CHUNK_SIZE = 64 * 1024;
const supportsResponseStream = isReadableStreamSupported &&
test(() => utils.isReadableStream(new Response('').body));
const resolvers = {
stream: supportsResponseStream && ((res) => res.body)
};
isFetchSupported && (((res) => {
['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {
!resolvers[type] && (resolvers[type] = utils.isFunction(res[type]) ? (res) => res[type]() :
(_, config) => {
throw new core_AxiosError(`Response type '${type}' is not supported`, core_AxiosError.ERR_NOT_SUPPORT, config);
})
});
})(new Response));
const getBodyLength = async (body) => {
if (body == null) {
return 0;
}
if(utils.isBlob(body)) {
return body.size;
}
if(utils.isSpecCompliantForm(body)) {
const _request = new Request(platform.origin, {
method: 'POST',
body,
});
return (await _request.arrayBuffer()).byteLength;
}
if(utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) {
return body.byteLength;
}
if(utils.isURLSearchParams(body)) {
body = body + '';
}
if(utils.isString(body)) {
return (await encodeText(body)).byteLength;
}
}
const resolveBodyLength = async (headers, body) => {
const length = utils.toFiniteNumber(headers.getContentLength());
return length == null ? getBodyLength(body) : length;
}
/* harmony default export */ var adapters_fetch = (isFetchSupported && (async (config) => {
let {
url,
method,
data,
signal,
cancelToken,
timeout,
onDownloadProgress,
onUploadProgress,
responseType,
headers,
withCredentials = 'same-origin',
fetchOptions
} = resolveConfig(config);
responseType = responseType ? (responseType + '').toLowerCase() : 'text';
let composedSignal = helpers_composeSignals([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
let request;
const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
composedSignal.unsubscribe();
});
let requestContentLength;
try {
if (
onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&
(requestContentLength = await resolveBodyLength(headers, data)) !== 0
) {
let _request = new Request(url, {
method: 'POST',
body: data,
duplex: "half"
});
let contentTypeHeader;
if (utils.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
headers.setContentType(contentTypeHeader)
}
if (_request.body) {
const [onProgress, flush] = progressEventDecorator(
requestContentLength,
progressEventReducer(asyncDecorator(onUploadProgress))
);
data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
}
}
if (!utils.isString(withCredentials)) {
withCredentials = withCredentials ? 'include' : 'omit';
}
// Cloudflare Workers throws when credentials are defined
// see https://github.com/cloudflare/workerd/issues/902
const isCredentialsSupported = "credentials" in Request.prototype;
request = new Request(url, {
...fetchOptions,
signal: composedSignal,
method: method.toUpperCase(),
headers: headers.normalize().toJSON(),
body: data,
duplex: "half",
credentials: isCredentialsSupported ? withCredentials : undefined
});
let response = await fetch(request, fetchOptions);
const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
const options = {};
['status', 'statusText', 'headers'].forEach(prop => {
options[prop] = response[prop];
});
const responseContentLength = utils.toFiniteNumber(response.headers.get('content-length'));
const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
responseContentLength,
progressEventReducer(asyncDecorator(onDownloadProgress), true)
) || [];
response = new Response(
trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
flush && flush();
unsubscribe && unsubscribe();
}),
options
);
}
responseType = responseType || 'text';
let responseData = await resolvers[utils.findKey(resolvers, responseType) || 'text'](response, config);
!isStreamResponse && unsubscribe && unsubscribe();
return await new Promise((resolve, reject) => {
settle(resolve, reject, {
data: responseData,
headers: core_AxiosHeaders.from(response.headers),
status: response.status,
statusText: response.statusText,
config,
request
})
})
} catch (err) {
unsubscribe && unsubscribe();
if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {
throw Object.assign(
new core_AxiosError('Network Error', core_AxiosError.ERR_NETWORK, config, request),
{
cause: err.cause || err
}
)
}
throw core_AxiosError.from(err, err && err.code, config, request);
}
}));
;// ./node_modules/axios/lib/adapters/adapters.js
const knownAdapters = {
http: helpers_null,
xhr: xhr,
fetch: adapters_fetch
}
utils.forEach(knownAdapters, (fn, value) => {
if (fn) {
try {
Object.defineProperty(fn, 'name', {value});
} catch (e) {
// eslint-disable-next-line no-empty
}
Object.defineProperty(fn, 'adapterName', {value});
}
});
const renderReason = (reason) => `- ${reason}`;
const isResolvedHandle = (adapter) => utils.isFunction(adapter) || adapter === null || adapter === false;
/* harmony default export */ var adapters = ({
getAdapter: (adapters) => {
adapters = utils.isArray(adapters) ? adapters : [adapters];
const {length} = adapters;
let nameOrAdapter;
let adapter;
const rejectedReasons = {};
for (let i = 0; i < length; i++) {
nameOrAdapter = adapters[i];
let id;
adapter = nameOrAdapter;
if (!isResolvedHandle(nameOrAdapter)) {
adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
if (adapter === undefined) {
throw new core_AxiosError(`Unknown adapter '${id}'`);
}
}
if (adapter) {
break;
}
rejectedReasons[id || '#' + i] = adapter;
}
if (!adapter) {
const reasons = Object.entries(rejectedReasons)
.map(([id, state]) => `adapter ${id} ` +
(state === false ? 'is not supported by the environment' : 'is not available in the build')
);
let s = length ?
(reasons.length > 1 ? 'since :\n' + reasons.map(renderReason).join('\n') : ' ' + renderReason(reasons[0])) :
'as no adapter specified';
throw new core_AxiosError(
`There is no suitable adapter to dispatch the request ` + s,
'ERR_NOT_SUPPORT'
);
}
return adapter;
},
adapters: knownAdapters
});
;// ./node_modules/axios/lib/core/dispatchRequest.js
/**
* Throws a `CanceledError` if cancellation has been requested.
*
* @param {Object} config The config that is to be used for the request
*
* @returns {void}
*/
function throwIfCancellationRequested(config) {
if (config.cancelToken) {
config.cancelToken.throwIfRequested();
}
if (config.signal && config.signal.aborted) {
throw new cancel_CanceledError(null, config);
}
}
/**
* Dispatch a request to the server using the configured adapter.
*
* @param {object} config The config that is to be used for the request
*
* @returns {Promise} The Promise to be fulfilled
*/
function dispatchRequest(config) {
throwIfCancellationRequested(config);
config.headers = core_AxiosHeaders.from(config.headers);
// Transform request data
config.data = transformData.call(
config,
config.transformRequest
);
if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {
config.headers.setContentType('application/x-www-form-urlencoded', false);
}
const adapter = adapters.getAdapter(config.adapter || lib_defaults.adapter);
return adapter(config).then(function onAdapterResolution(response) {
throwIfCancellationRequested(config);
// Transform response data
response.data = transformData.call(
config,
config.transformResponse,
response
);
response.headers = core_AxiosHeaders.from(response.headers);
return response;
}, function onAdapterRejection(reason) {
if (!isCancel(reason)) {
throwIfCancellationRequested(config);
// Transform response data
if (reason && reason.response) {
reason.response.data = transformData.call(
config,
config.transformResponse,
reason.response
);
reason.response.headers = core_AxiosHeaders.from(reason.response.headers);
}
}
return Promise.reject(reason);
});
}
;// ./node_modules/axios/lib/env/data.js
const VERSION = "1.10.0";
;// ./node_modules/axios/lib/helpers/validator.js
const validators = {};
// eslint-disable-next-line func-names
['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {
validators[type] = function validator(thing) {
return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;
};
});
const deprecatedWarnings = {};
/**
* Transitional option validator
*
* @param {function|boolean?} validator - set to false if the transitional option has been removed
* @param {string?} version - deprecated version / removed since version
* @param {string?} message - some message with additional info
*
* @returns {function}
*/
validators.transitional = function transitional(validator, version, message) {
function formatMessage(opt, desc) {
return '[Axios v' + VERSION + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
}
// eslint-disable-next-line func-names
return (value, opt, opts) => {
if (validator === false) {
throw new core_AxiosError(
formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),
core_AxiosError.ERR_DEPRECATED
);
}
if (version && !deprecatedWarnings[opt]) {
deprecatedWarnings[opt] = true;
// eslint-disable-next-line no-console
console.warn(
formatMessage(
opt,
' has been deprecated since v' + version + ' and will be removed in the near future'
)
);
}
return validator ? validator(value, opt, opts) : true;
};
};
validators.spelling = function spelling(correctSpelling) {
return (value, opt) => {
// eslint-disable-next-line no-console
console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);
return true;
}
};
/**
* Assert object's properties type
*
* @param {object} options
* @param {object} schema
* @param {boolean?} allowUnknown
*
* @returns {object}
*/
function assertOptions(options, schema, allowUnknown) {
if (typeof options !== 'object') {
throw new core_AxiosError('options must be an object', core_AxiosError.ERR_BAD_OPTION_VALUE);
}
const keys = Object.keys(options);
let i = keys.length;
while (i-- > 0) {
const opt = keys[i];
const validator = schema[opt];
if (validator) {
const value = options[opt];
const result = value === undefined || validator(value, opt, options);
if (result !== true) {
throw new core_AxiosError('option ' + opt + ' must be ' + result, core_AxiosError.ERR_BAD_OPTION_VALUE);
}
continue;
}
if (allowUnknown !== true) {
throw new core_AxiosError('Unknown option ' + opt, core_AxiosError.ERR_BAD_OPTION);
}
}
}
/* harmony default export */ var validator = ({
assertOptions,
validators
});
;// ./node_modules/axios/lib/core/Axios.js
const Axios_validators = validator.validators;
/**
* Create a new instance of Axios
*
* @param {Object} instanceConfig The default config for the instance
*
* @return {Axios} A new instance of Axios
*/
class Axios {
constructor(instanceConfig) {
this.defaults = instanceConfig || {};
this.interceptors = {
request: new core_InterceptorManager(),
response: new core_InterceptorManager()
};
}
/**
* Dispatch a request
*
* @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
* @param {?Object} config
*
* @returns {Promise} The Promise to be fulfilled
*/
async request(configOrUrl, config) {
try {
return await this._request(configOrUrl, config);
} catch (err) {
if (err instanceof Error) {
let dummy = {};
Error.captureStackTrace ? Error.captureStackTrace(dummy) : (dummy = new Error());
// slice off the Error: ... line
const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, '') : '';
try {
if (!err.stack) {
err.stack = stack;
// match without the 2 top stack lines
} else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ''))) {
err.stack += '\n' + stack
}
} catch (e) {
// ignore the case where "stack" is an un-writable property
}
}
throw err;
}
}
_request(configOrUrl, config) {
/*eslint no-param-reassign:0*/
// Allow for axios('example/url'[, config]) a la fetch API
if (typeof configOrUrl === 'string') {
config = config || {};
config.url = configOrUrl;
} else {
config = configOrUrl || {};
}
config = mergeConfig(this.defaults, config);
const {transitional, paramsSerializer, headers} = config;
if (transitional !== undefined) {
validator.assertOptions(transitional, {
silentJSONParsing: Axios_validators.transitional(Axios_validators.boolean),
forcedJSONParsing: Axios_validators.transitional(Axios_validators.boolean),
clarifyTimeoutError: Axios_validators.transitional(Axios_validators.boolean)
}, false);
}
if (paramsSerializer != null) {
if (utils.isFunction(paramsSerializer)) {
config.paramsSerializer = {
serialize: paramsSerializer
}
} else {
validator.assertOptions(paramsSerializer, {
encode: Axios_validators.function,
serialize: Axios_validators.function
}, true);
}
}
// Set config.allowAbsoluteUrls
if (config.allowAbsoluteUrls !== undefined) {
// do nothing
} else if (this.defaults.allowAbsoluteUrls !== undefined) {
config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
} else {
config.allowAbsoluteUrls = true;
}
validator.assertOptions(config, {
baseUrl: Axios_validators.spelling('baseURL'),
withXsrfToken: Axios_validators.spelling('withXSRFToken')
}, true);
// Set config.method
config.method = (config.method || this.defaults.method || 'get').toLowerCase();
// Flatten headers
let contextHeaders = headers && utils.merge(
headers.common,
headers[config.method]
);
headers && utils.forEach(
['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
(method) => {
delete headers[method];
}
);
config.headers = core_AxiosHeaders.concat(contextHeaders, headers);
// filter out skipped interceptors
const requestInterceptorChain = [];
let synchronousRequestInterceptors = true;
this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {
return;
}
synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
});
const responseInterceptorChain = [];
this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
});
let promise;
let i = 0;
let len;
if (!synchronousRequestInterceptors) {
const chain = [dispatchRequest.bind(this), undefined];
chain.unshift.apply(chain, requestInterceptorChain);
chain.push.apply(chain, responseInterceptorChain);
len = chain.length;
promise = Promise.resolve(config);
while (i < len) {
promise = promise.then(chain[i++], chain[i++]);
}
return promise;
}
len = requestInterceptorChain.length;
let newConfig = config;
i = 0;
while (i < len) {
const onFulfilled = requestInterceptorChain[i++];
const onRejected = requestInterceptorChain[i++];
try {
newConfig = onFulfilled(newConfig);
} catch (error) {
onRejected.call(this, error);
break;
}
}
try {
promise = dispatchRequest.call(this, newConfig);
} catch (error) {
return Promise.reject(error);
}
i = 0;
len = responseInterceptorChain.length;
while (i < len) {
promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
}
return promise;
}
getUri(config) {
config = mergeConfig(this.defaults, config);
const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
return buildURL(fullPath, config.params, config.paramsSerializer);
}
}
// Provide aliases for supported request methods
utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
/*eslint func-names:0*/
Axios.prototype[method] = function(url, config) {
return this.request(mergeConfig(config || {}, {
method,
url,
data: (config || {}).data
}));
};
});
utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
/*eslint func-names:0*/
function generateHTTPMethod(isForm) {
return function httpMethod(url, data, config) {
return this.request(mergeConfig(config || {}, {
method,
headers: isForm ? {
'Content-Type': 'multipart/form-data'
} : {},
url,
data
}));
};
}
Axios.prototype[method] = generateHTTPMethod();
Axios.prototype[method + 'Form'] = generateHTTPMethod(true);
});
/* harmony default export */ var core_Axios = (Axios);
;// ./node_modules/axios/lib/cancel/CancelToken.js
/**
* A `CancelToken` is an object that can be used to request cancellation of an operation.
*
* @param {Function} executor The executor function.
*
* @returns {CancelToken}
*/
class CancelToken {
constructor(executor) {
if (typeof executor !== 'function') {
throw new TypeError('executor must be a function.');
}
let resolvePromise;
this.promise = new Promise(function promiseExecutor(resolve) {
resolvePromise = resolve;
});
const token = this;
// eslint-disable-next-line func-names
this.promise.then(cancel => {
if (!token._listeners) return;
let i = token._listeners.length;
while (i-- > 0) {
token._listeners[i](cancel);
}
token._listeners = null;
});
// eslint-disable-next-line func-names
this.promise.then = onfulfilled => {
let _resolve;
// eslint-disable-next-line func-names
const promise = new Promise(resolve => {
token.subscribe(resolve);
_resolve = resolve;
}).then(onfulfilled);
promise.cancel = function reject() {
token.unsubscribe(_resolve);
};
return promise;
};
executor(function cancel(message, config, request) {
if (token.reason) {
// Cancellation has already been requested
return;
}
token.reason = new cancel_CanceledError(message, config, request);
resolvePromise(token.reason);
});
}
/**
* Throws a `CanceledError` if cancellation has been requested.
*/
throwIfRequested() {
if (this.reason) {
throw this.reason;
}
}
/**
* Subscribe to the cancel signal
*/
subscribe(listener) {
if (this.reason) {
listener(this.reason);
return;
}
if (this._listeners) {
this._listeners.push(listener);
} else {
this._listeners = [listener];
}
}
/**
* Unsubscribe from the cancel signal
*/
unsubscribe(listener) {
if (!this._listeners) {
return;
}
const index = this._listeners.indexOf(listener);
if (index !== -1) {
this._listeners.splice(index, 1);
}
}
toAbortSignal() {
const controller = new AbortController();
const abort = (err) => {
controller.abort(err);
};
this.subscribe(abort);
controller.signal.unsubscribe = () => this.unsubscribe(abort);
return controller.signal;
}
/**
* Returns an object that contains a new `CancelToken` and a function that, when called,
* cancels the `CancelToken`.
*/
static source() {
let cancel;
const token = new CancelToken(function executor(c) {
cancel = c;
});
return {
token,
cancel
};
}
}
/* harmony default export */ var cancel_CancelToken = (CancelToken);
;// ./node_modules/axios/lib/helpers/spread.js
/**
* Syntactic sugar for invoking a function and expanding an array for arguments.
*
* Common use case would be to use `Function.prototype.apply`.
*
* ```js
* function f(x, y, z) {}
* var args = [1, 2, 3];
* f.apply(null, args);
* ```
*
* With `spread` this example can be re-written.
*
* ```js
* spread(function(x, y, z) {})([1, 2, 3]);
* ```
*
* @param {Function} callback
*
* @returns {Function}
*/
function spread(callback) {
return function wrap(arr) {
return callback.apply(null, arr);
};
}
;// ./node_modules/axios/lib/helpers/isAxiosError.js
/**
* Determines whether the payload is an error thrown by Axios
*
* @param {*} payload The value to test
*
* @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
*/
function isAxiosError(payload) {
return utils.isObject(payload) && (payload.isAxiosError === true);
}
;// ./node_modules/axios/lib/helpers/HttpStatusCode.js
const HttpStatusCode = {
Continue: 100,
SwitchingProtocols: 101,
Processing: 102,
EarlyHints: 103,
Ok: 200,
Created: 201,
Accepted: 202,
NonAuthoritativeInformation: 203,
NoContent: 204,
ResetContent: 205,
PartialContent: 206,
MultiStatus: 207,
AlreadyReported: 208,
ImUsed: 226,
MultipleChoices: 300,
MovedPermanently: 301,
Found: 302,
SeeOther: 303,
NotModified: 304,
UseProxy: 305,
Unused: 306,
TemporaryRedirect: 307,
PermanentRedirect: 308,
BadRequest: 400,
Unauthorized: 401,
PaymentRequired: 402,
Forbidden: 403,
NotFound: 404,
MethodNotAllowed: 405,
NotAcceptable: 406,
ProxyAuthenticationRequired: 407,
RequestTimeout: 408,
Conflict: 409,
Gone: 410,
LengthRequired: 411,
PreconditionFailed: 412,
PayloadTooLarge: 413,
UriTooLong: 414,
UnsupportedMediaType: 415,
RangeNotSatisfiable: 416,
ExpectationFailed: 417,
ImATeapot: 418,
MisdirectedRequest: 421,
UnprocessableEntity: 422,
Locked: 423,
FailedDependency: 424,
TooEarly: 425,
UpgradeRequired: 426,
PreconditionRequired: 428,
TooManyRequests: 429,
RequestHeaderFieldsTooLarge: 431,
UnavailableForLegalReasons: 451,
InternalServerError: 500,
NotImplemented: 501,
BadGateway: 502,
ServiceUnavailable: 503,
GatewayTimeout: 504,
HttpVersionNotSupported: 505,
VariantAlsoNegotiates: 506,
InsufficientStorage: 507,
LoopDetected: 508,
NotExtended: 510,
NetworkAuthenticationRequired: 511,
};
Object.entries(HttpStatusCode).forEach(([key, value]) => {
HttpStatusCode[value] = key;
});
/* harmony default export */ var helpers_HttpStatusCode = (HttpStatusCode);
;// ./node_modules/axios/lib/axios.js
/**
* Create an instance of Axios
*
* @param {Object} defaultConfig The default config for the instance
*
* @returns {Axios} A new instance of Axios
*/
function createInstance(defaultConfig) {
const context = new core_Axios(defaultConfig);
const instance = bind(core_Axios.prototype.request, context);
// Copy axios.prototype to instance
utils.extend(instance, core_Axios.prototype, context, {allOwnKeys: true});
// Copy context to instance
utils.extend(instance, context, null, {allOwnKeys: true});
// Factory for creating new instances
instance.create = function create(instanceConfig) {
return createInstance(mergeConfig(defaultConfig, instanceConfig));
};
return instance;
}
// Create the default instance to be exported
const axios = createInstance(lib_defaults);
// Expose Axios class to allow class inheritance
axios.Axios = core_Axios;
// Expose Cancel & CancelToken
axios.CanceledError = cancel_CanceledError;
axios.CancelToken = cancel_CancelToken;
axios.isCancel = isCancel;
axios.VERSION = VERSION;
axios.toFormData = helpers_toFormData;
// Expose AxiosError class
axios.AxiosError = core_AxiosError;
// alias for CanceledError for backward compatibility
axios.Cancel = axios.CanceledError;
// Expose all/spread
axios.all = function all(promises) {
return Promise.all(promises);
};
axios.spread = spread;
// Expose isAxiosError
axios.isAxiosError = isAxiosError;
// Expose mergeConfig
axios.mergeConfig = mergeConfig;
axios.AxiosHeaders = core_AxiosHeaders;
axios.formToJSON = thing => helpers_formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
axios.getAdapter = adapters.getAdapter;
axios.HttpStatusCode = helpers_HttpStatusCode;
axios.default = axios;
// this module should only have a default export
/* harmony default export */ var lib_axios = (axios);
;// ./node_modules/babel-loader/lib/index.js!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[7].use[0]!./src/component/panel/AccountCard.vue?vue&type=script&setup=true&lang=js
var AccountCardvue_type_script_setup_true_lang_js_hoisted_1 = {
class: "account-info"
};
/* harmony default export */ var AccountCardvue_type_script_setup_true_lang_js = ({
__name: 'AccountCard',
setup: function setup(__props) {
var config = reactive({
// 无限卡天数
infiniteCardDays: 0,
// ios端书币
iosBookCoin: 0,
// 安卓端书币
androidBookCoin: 0,
// 当前阅读时长
currentReadingTime: 0,
// 总共阅读时长
totalReadingTime: 0
});
// load member info
var loadMemberInfo = function loadMemberInfo() {
var balanceCallback = function balanceCallback(res) {
var _res$data = res.data,
iosBookCoin = _res$data.giftBalance,
androidBookCoin = _res$data.peerBalance,
welfare = _res$data.welfare;
var expiredTime = welfare.expiredTime;
var infiniteCardDays = Math.floor(expiredTime / 3600 / 24);
Object.assign(config, {
iosBookCoin: iosBookCoin,
androidBookCoin: androidBookCoin,
infiniteCardDays: infiniteCardDays
});
};
lib_axios.post("/web/pay/balance", {
"zoneid": "1",
"release": "1",
"pf": "weread_wx-2001-iap-2001-iphone"
}).then(balanceCallback);
};
// 加载个人信息，此处只展示阅读时长
var loadMemberProfile = function loadMemberProfile() {
var profileApi = "https://i.weread.qq.com/user/profile";
lib_axios.get(profileApi, {
withCredentials: true,
params: {
gender: 1,
signature: 1,
vDesc: 1,
location: 1,
totalReadingTime: 1,
currentReadingTime: 1,
finishedBookCount: 1,
followerCount: 1,
followingCount: 1,
totalLikedCount: 1,
isFollowing: 1,
platform: "wp"
}
}).then(function (response) {
var status = response.status,
data = response.data;
if (status !== 200) {
return;
}
var currentReadingTime = data.currentReadingTime,
totalReadingTime = data.totalReadingTime;
Object.assign(config, {
currentReadingTime: currentReadingTime,
totalReadingTime: totalReadingTime
});
});
};
runtime_core_esm_bundler_onMounted(function () {
loadMemberInfo();
loadMemberProfile();
});
return function (_ctx, _cache) {
var _component_n_grid_item = resolveComponent("n-grid-item");
var _component_n_space = resolveComponent("n-space");
var _component_n_grid = resolveComponent("n-grid");
var _component_n_card = resolveComponent("n-card");
return openBlock(), createBlock(_component_n_card, {
class: "readConfig",
size: "small",
bordered: false,
title: "我的账户",
segmented: {
content: true,
footer: 'soft'
}
}, {
default: withCtx(function () {
return [createVNode(_component_n_grid, {
"x-gap": "10",
"y-gap": "10",
cols: "2"
}, {
default: withCtx(function () {
return [createVNode(_component_n_grid_item, null, {
default: withCtx(function () {
return [createVNode(MiniCard, {
title: "安卓书币",
value: config.androidBookCoin,
unit: "个"
}, null, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_grid_item, null, {
default: withCtx(function () {
return [createVNode(MiniCard, {
title: "苹果书币",
value: config.iosBookCoin,
unit: "个"
}, null, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_grid_item, null, {
default: withCtx(function () {
return [createVNode(MiniCard, {
title: "本周阅读时长",
value: config.currentReadingTime,
unit: "小时"
}, null, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_grid_item, null, {
default: withCtx(function () {
return [createVNode(MiniCard, {
title: "总阅读时长",
value: config.totalReadingTime,
unit: "小时"
}, null, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_grid_item, null, {
default: withCtx(function () {
return [createVNode(MiniCard, {
title: "无限卡",
value: config.infiniteCardDays,
unit: "天"
}, null, 8, ["value"])];
}),
_: 1
}), createVNode(_component_n_grid_item, null, {
default: withCtx(function () {
return [createBaseVNode("div", AccountCardvue_type_script_setup_true_lang_js_hoisted_1, [createVNode(_component_n_space, {
vertical: ""
}, {
default: withCtx(function () {
return _cache[0] || (_cache[0] = [createBaseVNode("span", null, "源码地址", -1), createBaseVNode("strong", {
class: "gray"
}, [createBaseVNode("a", {
href: "https://gitee.com/diduweiwu-itestdev/wechat-reader-ext",
target: "_blank"
}, "点击直达🧐")], -1)]);
}),
_: 1
})])];
}),
_: 1
})];
}),
_: 1
})];
}),
_: 1
});
};
}
});
;// ./src/component/panel/AccountCard.vue?vue&type=script&setup=true&lang=js
// EXTERNAL MODULE: ./node_modules/vue-style-loader/index.js!./node_modules/css-loader/dist/cjs.js!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[7].use[0]!./src/component/panel/AccountCard.vue?vue&type=style&index=0&id=1ada3bc7&scoped=true&lang=css
var AccountCardvue_type_style_index_0_id_1ada3bc7_scoped_true_lang_css = __webpack_require__(820);
;// ./src/component/panel/AccountCard.vue?vue&type=style&index=0&id=1ada3bc7&scoped=true&lang=css
;// ./src/component/panel/AccountCard.vue
;
const AccountCard_exports_ = /*#__PURE__*/(0,exportHelper/* default */.A)(AccountCardvue_type_script_setup_true_lang_js, [['__scopeId',"data-v-1ada3bc7"]])
/* harmony default export */ var AccountCard = (AccountCard_exports_);
;// ./node_modules/babel-loader/lib/index.js!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[7].use[0]!./src/component/panel/ConfigPanel.vue?vue&type=script&setup=true&lang=js
// 从localStorage读取初始化配置
/* harmony default export */ var ConfigPanelvue_type_script_setup_true_lang_js = ({
__name: 'ConfigPanel',
setup: function setup(__props) {
var storageReadConfig = getItem(storageKey.READ_CONFIG, defaultReadConfig);
return function (_ctx, _cache) {
var _component_n_grid_item = resolveComponent("n-grid-item");
var _component_n_space = resolveComponent("n-space");
var _component_n_grid = resolveComponent("n-grid");
return openBlock(), createBlock(_component_n_grid, {
"x-gap": "12",
cols: 2,
style: {
"width": "800px"
}
}, {
default: withCtx(function () {
return [createVNode(_component_n_grid_item, null, {
default: withCtx(function () {
return [createVNode(ReadConfigCard, {
config: unref(storageReadConfig)
}, null, 8, ["config"])];
}),
_: 1
}), createVNode(_component_n_grid_item, null, {
default: withCtx(function () {
return [createVNode(_component_n_space, {
vertical: ""
}, {
default: withCtx(function () {
return [createVNode(OtherConfigCard, {
config: unref(storageReadConfig)
}, null, 8, ["config"]), createVNode(AccountCard)];
}),
_: 1
})];
}),
_: 1
})];
}),
_: 1
});
};
}
});
;// ./src/component/panel/ConfigPanel.vue?vue&type=script&setup=true&lang=js
// EXTERNAL MODULE: ./node_modules/vue-style-loader/index.js!./node_modules/css-loader/dist/cjs.js!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[7].use[0]!./src/component/panel/ConfigPanel.vue?vue&type=style&index=0&id=6a0d15e8&scoped=true&lang=css
var ConfigPanelvue_type_style_index_0_id_6a0d15e8_scoped_true_lang_css = __webpack_require__(435);
;// ./src/component/panel/ConfigPanel.vue?vue&type=style&index=0&id=6a0d15e8&scoped=true&lang=css
;// ./src/component/panel/ConfigPanel.vue
;
const ConfigPanel_exports_ = /*#__PURE__*/(0,exportHelper/* default */.A)(ConfigPanelvue_type_script_setup_true_lang_js, [['__scopeId',"data-v-6a0d15e8"]])
/* harmony default export */ var ConfigPanel = (ConfigPanel_exports_);
;// ./src/task/taskSignal.js
/* harmony default export */ var taskSignal = ({
START: 'START',
STOP: 'STOP'
});
;// ./src/helper/scrollHelper.js
// scrollHelper.js
function scrollPage() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref$direction = _ref.direction,
direction = _ref$direction === void 0 ? 'down' : _ref$direction,
_ref$distance = _ref.distance,
distance = _ref$distance === void 0 ? 100 : _ref$distance;
var x = 0,
y = 0;
switch (direction) {
case 'up':
y = -distance;
break;
case 'down':
y = distance;
break;
case 'left':
x = -distance;
break;
case 'right':
x = distance;
break;
default:
console.warn('Unknown scroll direction:', direction);
}
window.scrollBy({
top: y,
left: x
});
// 返回当前滚动条位置
return {
scrollX: window.scrollX,
scrollY: window.scrollY
};
}
;// ./src/worker/autoReadWorker.worker.js?raw
/* harmony default export */ var autoReadWorker_workerraw = ("\nlet autoReadTask = null; // 必须先声明！\n\nself.onmessage = (e) => {\n const payload = e.data;\n if (!payload) {\n console.log(\"payload is empty\");\n return;\n }\n\n const {signal, readIntervalMillis} = payload;\n if (!signal) {\n console.log('No signal in auto read worker');\n return;\n }\n\n if (signal === \"START\" && autoReadTask == null) {\n autoReadTask = setInterval(() => {\n self.postMessage(\"doAutoReadTask\");\n }, readIntervalMillis);\n }\n\n if (signal === \"STOP\" && autoReadTask) {\n clearInterval(autoReadTask);\n autoReadTask = null;\n }\n};\n");
;// ./src/helper/keyboardHelper.js
var KEY_ARROW_LEFT = 'ArrowLeft';
var KEY_ARROW_UP = 'ArrowUp';
var KEY_ARROW_RIGHT = 'ArrowRight';
var KEY_ARROW_DOWN = 'ArrowDown';
var KEY_ENTER = 'Enter';
var KEY_ESCAPE = 'Escape';
var KEY_SPACE = 'Space';
function fireKeyEvent(target, type, keyInput) {
var key, code, keyCode;
if (typeof keyInput === 'string') {
var _keyCodeMap$key;
key = keyInput;
code = keyInput;
// 字符串的话，我们自动根据常见key来补充keyCode
var keyCodeMap = {
ArrowLeft: 37,
ArrowUp: 38,
ArrowRight: 39,
ArrowDown: 40,
Enter: 13,
Escape: 27,
Space: 32
};
keyCode = (_keyCodeMap$key = keyCodeMap[key]) !== null && _keyCodeMap$key !== void 0 ? _keyCodeMap$key : keyInput.charCodeAt(0); // 如果是普通字符
} else if (typeof keyInput === 'number') {
var _reverseMap$keyCode;
keyCode = keyInput;
var reverseMap = {
37: 'ArrowLeft',
38: 'ArrowUp',
39: 'ArrowRight',
40: 'ArrowDown',
13: 'Enter',
27: 'Escape',
32: ' '
};
key = (_reverseMap$keyCode = reverseMap[keyCode]) !== null && _reverseMap$keyCode !== void 0 ? _reverseMap$keyCode : String.fromCharCode(keyCode);
code = key;
} else {
throw new Error('fireKeyEvent: keyInput must be string or number!');
}
var event;
try {
event = new KeyboardEvent(type, {
key: key,
code: code,
keyCode: keyCode,
which: keyCode,
bubbles: true,
cancelable: true
});
// 强制覆盖 keyCode / which
Object.defineProperty(event, 'keyCode', {
value: keyCode
});
Object.defineProperty(event, 'which', {
value: keyCode
});
} catch (e) {
event = document.createEvent('Event');
event.initEvent(type, true, true);
event.keyCode = keyCode;
event.which = keyCode;
}
target.dispatchEvent(event);
}
function simulateArrowLeft() {
fireKeyEvent(document, 'keydown', KEY_ARROW_LEFT); // 左箭头翻页
}
function simulateArrowRight() {
fireKeyEvent(document, 'keydown', KEY_ARROW_RIGHT); // 左箭头翻页
}
;// ./src/task/swtichPageDirection.js
/* harmony default export */ var swtichPageDirection = ({
LEFT: 'LEFT',
RIGHT: 'RIGHT'
});
;// ./src/task/autoReadTask.js
function composeAutoReadWorker() {
var blob = new Blob([autoReadWorker_workerraw], {
type: 'application/javascript'
});
var workerUrl = URL.createObjectURL(blob);
return new Worker(workerUrl);
}
// 自动刷新的定时器
var autoRefreshStartTime = Date.now();
var wereadHomePage = "https://weread.qq.com/";
var readingHrefPrefix = wereadHomePage + "web/reader/";
var currentPageKey = "currentReadingPage";
function checkIfHome() {
// 判断是否是当首页
return wereadHomePage === window.location.href;
}
//自动滚动任务
function startAutoReadTask(worker) {
var readConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultReadConfig;
if (!worker) {
console.log("worker not found");
return;
}
var readIntervalMillis = readConfig.readIntervalMillis;
worker.postMessage({
signal: taskSignal.START,
readIntervalMillis: readIntervalMillis
});
// 打开worker事件监听
var direction = readConfig.readDirection;
var distance = readConfig.readStep;
// 是否自动翻页
var autoSwitchPage = readConfig.autoSwitchPage;
var autoSwitchPageDirection = readConfig.autoSwitchPageDirection;
var autoRefresh = readConfig.autoRefresh;
var autoRefreshSeconds = readConfig.autoRefreshSeconds;
var isReloading = false;
var isRedirecting = false;
worker.onmessage = function (event) {
// 只监听自动阅读任务
if (event.data !== 'doAutoReadTask') {
return;
}
// 正在跳转中，不做任何操作
if (isRedirecting) {
return;
}
// 当前是在首页,自动跳转到之前的阅读页面
if (checkIfHome()) {
// 获取正在阅读的页面
var currentReadingPage = getSingleItem(currentPageKey);
if (!currentReadingPage) {
return;
}
// 保存的是首页，忽略
if (currentReadingPage === wereadHomePage) {
return;
}
// 有保存阅读页面，并且匹配阅读页面前缀
console.log(currentReadingPage, readingHrefPrefix);
console.log(!currentReadingPage.startsWith(readingHrefPrefix));
if (!currentReadingPage.startsWith(readingHrefPrefix)) {
return;
}
isRedirecting = true;
location.href = currentReadingPage;
}
// 保存当前阅读的页面
var currentHref = location.href;
if (currentHref.startsWith(readingHrefPrefix)) {
setSingItem(currentPageKey, location.href);
}
if (isReloading) {
console.log("Reloading...");
autoRefreshStartTime = Date.now();
return;
}
var maxScrollY = document.documentElement.scrollHeight - window.innerHeight;
var _scrollPage = scrollPage({
direction: direction,
distance: distance
}),
scrollY = _scrollPage.scrollY;
// 检测是否要刷新页面
var currentTime = Date.now();
var refreshTimeCount = currentTime - autoRefreshStartTime;
if (autoRefresh && refreshTimeCount >= autoRefreshSeconds * 1000) {
isReloading = true;
location.reload();
return;
}
if (scrollY >= maxScrollY) {
// 执行了翻页
if (ifSwitchPage(autoSwitchPage, autoSwitchPageDirection)) {
return;
}
direction = "up";
return;
}
if (scrollY === 0) {
if (ifSwitchPage(autoSwitchPage, autoSwitchPageDirection)) {
return;
}
direction = "down";
}
};
}
function ifSwitchPage(autoSwitchPage, autoSwitchPageDirection) {
// 开启了自动翻页
if (!!autoSwitchPage) {
if (autoSwitchPageDirection === swtichPageDirection.LEFT) {
simulateArrowLeft();
return true;
}
// 开启了自动翻页，优先进行自动翻页
if (autoSwitchPageDirection === swtichPageDirection.RIGHT) {
simulateArrowRight();
return true;
}
return false;
}
return false;
}
function stopAutoReadTask(worker) {
if (!worker) {
console.log("worker not found");
return;
}
worker.postMessage({
signal: taskSignal.STOP
});
}
;// ./node_modules/babel-loader/lib/index.js!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[7].use[0]!./src/App.vue?vue&type=script&lang=js
/* harmony default export */ var Appvue_type_script_lang_js = ({
name: "app",
components: {
ConfigPanel: ConfigPanel
},
methods: {},
setup: function setup() {
var worker = composeAutoReadWorker();
var runningReadConfig = reactive({});
var reloadRunningReadConfig = function reloadRunningReadConfig() {
var storageReadConfig = getItem(storageKey.READ_CONFIG, defaultReadConfig);
Object.assign(runningReadConfig, storageReadConfig);
};
var startAutoRead = function startAutoRead() {
startAutoReadTask(worker, runningReadConfig);
runningReadConfig.isAutoReading = true;
setItem(storageKey.READ_CONFIG, runningReadConfig);
};
var stopAutoRead = function stopAutoRead() {
runningReadConfig.isAutoReading = false;
setItem(storageKey.READ_CONFIG, runningReadConfig);
stopAutoReadTask(worker);
};
reloadRunningReadConfig();
setTimeout(function () {
// 加载完成后，如果记录的状态是正在阅读中，自动开启阅读任务
if (runningReadConfig.isAutoReading) {
startAutoRead();
}
}, 2000);
// 切换阅读任务开启/关闭
var switchAutoRead = function switchAutoRead() {
if (runningReadConfig.isAutoReading) {
stopAutoRead();
return;
}
if (!runningReadConfig.isAutoReading) {
startAutoRead();
}
};
var reloadAutoRead = function reloadAutoRead() {
reloadRunningReadConfig();
if (runningReadConfig.isAutoReading) {
stopAutoRead();
startAutoRead();
}
};
var clearReadConfig = function clearReadConfig() {
removeItem(storageKey.READ_CONFIG);
window.location.reload();
};
var readConfigChangedCallback = function readConfigChangedCallback() {
reloadAutoRead();
};
runtime_core_esm_bundler_onMounted(function () {
// 添加事件监听
onEvent(eventKey.READ_CONFIG_UPDATE_EVENT, readConfigChangedCallback);
});
runtime_core_esm_bundler_onBeforeUnmount(function () {
// 页面卸载前销毁 Worker
if (worker) {
worker.terminate();
}
// 取消事件监听
offEvent(eventKey.READ_CONFIG_UPDATE_EVENT, readConfigChangedCallback);
});
var switchPage = function switchPage() {
return simulateArrowRight();
};
return {
switchAutoRead: switchAutoRead,
reloadAutoRead: reloadAutoRead,
runningReadConfig: runningReadConfig,
clearReadConfig: clearReadConfig,
switchPage: switchPage
};
}
});
;// ./src/App.vue?vue&type=script&lang=js
// EXTERNAL MODULE: ./node_modules/vue-style-loader/index.js!./node_modules/css-loader/dist/cjs.js!./node_modules/vue-loader/dist/stylePostLoader.js!./node_modules/vue-loader/dist/index.js??ruleSet[1].rules[7].use[0]!./src/App.vue?vue&type=style&index=0&id=49770b9d&scoped=true&lang=css
var Appvue_type_style_index_0_id_49770b9d_scoped_true_lang_css = __webpack_require__(557);
;// ./src/App.vue?vue&type=style&index=0&id=49770b9d&scoped=true&lang=css
;// ./src/App.vue
;
const App_exports_ = /*#__PURE__*/(0,exportHelper/* default */.A)(Appvue_type_script_lang_js, [['render',Appvue_type_template_id_49770b9d_scoped_true_render],['__scopeId',"data-v-49770b9d"]])
/* harmony default export */ var App = (App_exports_);
;// ./node_modules/naive-ui/es/version.mjs
/* harmony default export */ var es_version = ('2.41.0');
;// ./node_modules/naive-ui/es/create.mjs
function create({
componentPrefix = 'N',
components = []
} = {}) {
const installTargets = [];
function registerComponent(app, name, component) {
const registered = app.component(componentPrefix + name);
if (!registered) {
app.component(componentPrefix + name, component);
}
}
function install(app) {
if (installTargets.includes(app)) return;
installTargets.push(app);
components.forEach(component => {
const {
name,
alias
} = component;
registerComponent(app, name, component);
if (alias) {
alias.forEach(aliasName => {
registerComponent(app, aliasName, component);
});
}
});
}
return {
version: es_version,
componentPrefix,
install
};
}
/* harmony default export */ var es_create = (create);
;// ./node_modules/seemly/es/color/colors.js
// src: https://www.w3schools.com/colors/colors_names.asp
/* harmony default export */ var colors = ({
aliceblue: "#F0F8FF",
antiquewhite: "#FAEBD7",
aqua: "#0FF",
aquamarine: "#7FFFD4",
azure: "#F0FFFF",
beige: "#F5F5DC",
bisque: "#FFE4C4",
black: "#000",
blanchedalmond: "#FFEBCD",
blue: "#00F",
blueviolet: "#8A2BE2",
brown: "#A52A2A",
burlywood: "#DEB887",
cadetblue: "#5F9EA0",
chartreuse: "#7FFF00",
chocolate: "#D2691E",
coral: "#FF7F50",
cornflowerblue: "#6495ED",
cornsilk: "#FFF8DC",
crimson: "#DC143C",
cyan: "#0FF",
darkblue: "#00008B",
darkcyan: "#008B8B",
darkgoldenrod: "#B8860B",
darkgray: "#A9A9A9",
darkgrey: "#A9A9A9",
darkgreen: "#006400",
darkkhaki: "#BDB76B",
darkmagenta: "#8B008B",
darkolivegreen: "#556B2F",
darkorange: "#FF8C00",
darkorchid: "#9932CC",
darkred: "#8B0000",
darksalmon: "#E9967A",
darkseagreen: "#8FBC8F",
darkslateblue: "#483D8B",
darkslategray: "#2F4F4F",
darkslategrey: "#2F4F4F",
darkturquoise: "#00CED1",
darkviolet: "#9400D3",
deeppink: "#FF1493",
deepskyblue: "#00BFFF",
dimgray: "#696969",
dimgrey: "#696969",
dodgerblue: "#1E90FF",
firebrick: "#B22222",
floralwhite: "#FFFAF0",
forestgreen: "#228B22",
fuchsia: "#F0F",
gainsboro: "#DCDCDC",
ghostwhite: "#F8F8FF",
gold: "#FFD700",
goldenrod: "#DAA520",
gray: "#808080",
grey: "#808080",
green: "#008000",
greenyellow: "#ADFF2F",
honeydew: "#F0FFF0",
hotpink: "#FF69B4",
indianred: "#CD5C5C",
indigo: "#4B0082",
ivory: "#FFFFF0",
khaki: "#F0E68C",
lavender: "#E6E6FA",
lavenderblush: "#FFF0F5",
lawngreen: "#7CFC00",
lemonchiffon: "#FFFACD",
lightblue: "#ADD8E6",
lightcoral: "#F08080",
lightcyan: "#E0FFFF",
lightgoldenrodyellow: "#FAFAD2",
lightgray: "#D3D3D3",
lightgrey: "#D3D3D3",
lightgreen: "#90EE90",
lightpink: "#FFB6C1",
lightsalmon: "#FFA07A",
lightseagreen: "#20B2AA",
lightskyblue: "#87CEFA",
lightslategray: "#778899",
lightslategrey: "#778899",
lightsteelblue: "#B0C4DE",
lightyellow: "#FFFFE0",
lime: "#0F0",
limegreen: "#32CD32",
linen: "#FAF0E6",
magenta: "#F0F",
maroon: "#800000",
mediumaquamarine: "#66CDAA",
mediumblue: "#0000CD",
mediumorchid: "#BA55D3",
mediumpurple: "#9370DB",
mediumseagreen: "#3CB371",
mediumslateblue: "#7B68EE",
mediumspringgreen: "#00FA9A",
mediumturquoise: "#48D1CC",
mediumvioletred: "#C71585",
midnightblue: "#191970",
mintcream: "#F5FFFA",
mistyrose: "#FFE4E1",
moccasin: "#FFE4B5",
navajowhite: "#FFDEAD",
navy: "#000080",
oldlace: "#FDF5E6",
olive: "#808000",
olivedrab: "#6B8E23",
orange: "#FFA500",
orangered: "#FF4500",
orchid: "#DA70D6",
palegoldenrod: "#EEE8AA",
palegreen: "#98FB98",
paleturquoise: "#AFEEEE",
palevioletred: "#DB7093",
papayawhip: "#FFEFD5",
peachpuff: "#FFDAB9",
peru: "#CD853F",
pink: "#FFC0CB",
plum: "#DDA0DD",
powderblue: "#B0E0E6",
purple: "#800080",
rebeccapurple: "#663399",
red: "#F00",
rosybrown: "#BC8F8F",
royalblue: "#4169E1",
saddlebrown: "#8B4513",
salmon: "#FA8072",
sandybrown: "#F4A460",
seagreen: "#2E8B57",
seashell: "#FFF5EE",
sienna: "#A0522D",
silver: "#C0C0C0",
skyblue: "#87CEEB",
slateblue: "#6A5ACD",
slategray: "#708090",
slategrey: "#708090",
snow: "#FFFAFA",
springgreen: "#00FF7F",
steelblue: "#4682B4",
tan: "#D2B48C",
teal: "#008080",
thistle: "#D8BFD8",
tomato: "#FF6347",
turquoise: "#40E0D0",
violet: "#EE82EE",
wheat: "#F5DEB3",
white: "#FFF",
whitesmoke: "#F5F5F5",
yellow: "#FF0",
yellowgreen: "#9ACD32",
transparent: "#0000"
});
;// ./node_modules/seemly/es/color/convert.js
// All the algorithms credit to https://stackoverflow.com/questions/36721830/convert-hsl-to-rgb-and-hex/54014428#54014428
// original author: Kamil Kiełczewski
/**
* @param h 360
* @param s 100
* @param l 100
* @returns [h, s, v] 360, 100, 100
*/
function hsl2hsv(h, s, l) {
s /= 100;
l /= 100;
const v = s * Math.min(l, 1 - l) + l;
return [h, v ? (2 - (2 * l) / v) * 100 : 0, v * 100];
}
/**
* @param h 360
* @param s 100
* @param v 100
* @returns [h, s, l] 360, 100, 100
*/
function hsv2hsl(h, s, v) {
s /= 100;
v /= 100;
const l = v - (v * s) / 2;
const m = Math.min(l, 1 - l);
return [h, m ? ((v - l) / m) * 100 : 0, l * 100];
}
/**
* @param h 360
* @param s 100
* @param v 100
* @returns [r, g, b] 255, 255, 255
*/
function hsv2rgb(h, s, v) {
s /= 100;
v /= 100;
let f = (n, k = (n + h / 60) % 6) => v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
return [f(5) * 255, f(3) * 255, f(1) * 255];
}
/**
* @param r 255
* @param g 255
* @param b 255
* @returns [360, 100, 100]
*/
function rgb2hsv(r, g, b) {
r /= 255;
g /= 255;
b /= 255;
let v = Math.max(r, g, b), c = v - Math.min(r, g, b);
let h = c && (v == r ? (g - b) / c : v == g ? 2 + (b - r) / c : 4 + (r - g) / c);
return [60 * (h < 0 ? h + 6 : h), v && (c / v) * 100, v * 100];
}
/**
* @param r 255
* @param g 255
* @param b 255
* @returns [360, 100, 100]
*/
function rgb2hsl(r, g, b) {
r /= 255;
g /= 255;
b /= 255;
let v = Math.max(r, g, b), c = v - Math.min(r, g, b), f = 1 - Math.abs(v + v - c - 1);
let h = c && (v == r ? (g - b) / c : v == g ? 2 + (b - r) / c : 4 + (r - g) / c);
return [60 * (h < 0 ? h + 6 : h), f ? (c / f) * 100 : 0, (v + v - c) * 50];
}
/**
* @param h 360
* @param s 100
* @param l 100
* @returns [255, 255, 255]
*/
function hsl2rgb(h, s, l) {
s /= 100;
l /= 100;
let a = s * Math.min(l, 1 - l);
let f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
return [f(0) * 255, f(8) * 255, f(4) * 255];
}
;// ./node_modules/seemly/es/color/index.js
const prefix = '^\\s*';
const suffix = '\\s*$';
const percent = '\\s*((\\.\\d+)|(\\d+(\\.\\d*)?))%\\s*'; // 4 offset
const color_float = '\\s*((\\.\\d+)|(\\d+(\\.\\d*)?))\\s*'; // 4 offset
const hex = '([0-9A-Fa-f])';
const dhex = '([0-9A-Fa-f]{2})';
const hslRegex = new RegExp(`${prefix}hsl\\s*\\(${color_float},${percent},${percent}\\)${suffix}`);
const hsvRegex = new RegExp(`${prefix}hsv\\s*\\(${color_float},${percent},${percent}\\)${suffix}`);
const hslaRegex = new RegExp(`${prefix}hsla\\s*\\(${color_float},${percent},${percent},${color_float}\\)${suffix}`);
const hsvaRegex = new RegExp(`${prefix}hsva\\s*\\(${color_float},${percent},${percent},${color_float}\\)${suffix}`);
const rgbRegex = new RegExp(`${prefix}rgb\\s*\\(${color_float},${color_float},${color_float}\\)${suffix}`);
const rgbaRegex = new RegExp(`${prefix}rgba\\s*\\(${color_float},${color_float},${color_float},${color_float}\\)${suffix}`);
const sHexRegex = new RegExp(`${prefix}#${hex}${hex}${hex}${suffix}`);
const hexRegex = new RegExp(`${prefix}#${dhex}${dhex}${dhex}${suffix}`);
const sHexaRegex = new RegExp(`${prefix}#${hex}${hex}${hex}${hex}${suffix}`);
const hexaRegex = new RegExp(`${prefix}#${dhex}${dhex}${dhex}${dhex}${suffix}`);
function parseHex(value) {
return parseInt(value, 16);
}
/**
* Convert color string to hsla array
* @param color format like hsl(180, 100%, 100%), hsla(180, 100%, 100%, 1)
* @returns
*/
function hsla(color) {
try {
let i;
if ((i = hslaRegex.exec(color))) {
return [
roundDeg(i[1]),
roundPercent(i[5]),
roundPercent(i[9]),
roundAlpha(i[13])
];
}
else if ((i = hslRegex.exec(color))) {
return [roundDeg(i[1]), roundPercent(i[5]), roundPercent(i[9]), 1];
}
throw new Error(`[seemly/hsla]: Invalid color value ${color}.`);
}
catch (e) {
throw e;
}
}
/**
* Convert color string to hsva array
* @param color format like hsv(180, 100%, 100%), hsva(180, 100%, 100%, 1)
* @returns
*/
function hsva(color) {
try {
let i;
if ((i = hsvaRegex.exec(color))) {
return [
roundDeg(i[1]),
roundPercent(i[5]),
roundPercent(i[9]),
roundAlpha(i[13])
];
}
else if ((i = hsvRegex.exec(color))) {
return [roundDeg(i[1]), roundPercent(i[5]), roundPercent(i[9]), 1];
}
throw new Error(`[seemly/hsva]: Invalid color value ${color}.`);
}
catch (e) {
throw e;
}
}
/**
* Convert color string to rgba array.
* @param color format like #000[0], #000000[00], rgb(0, 0, 0),
* rgba(0, 0, 0, 0), hsl(a) color, hsv(a) color and color keywords and
* transparent
* @returns
*/
function rgba(color) {
try {
let i;
if ((i = hexRegex.exec(color))) {
return [parseHex(i[1]), parseHex(i[2]), parseHex(i[3]), 1];
}
else if ((i = rgbRegex.exec(color))) {
return [roundChannel(i[1]), roundChannel(i[5]), roundChannel(i[9]), 1];
}
else if ((i = rgbaRegex.exec(color))) {
return [
roundChannel(i[1]),
roundChannel(i[5]),
roundChannel(i[9]),
roundAlpha(i[13])
];
}
else if ((i = sHexRegex.exec(color))) {
return [
parseHex(i[1] + i[1]),
parseHex(i[2] + i[2]),
parseHex(i[3] + i[3]),
1
];
}
else if ((i = hexaRegex.exec(color))) {
return [
parseHex(i[1]),
parseHex(i[2]),
parseHex(i[3]),
roundAlpha(parseHex(i[4]) / 255)
];
}
else if ((i = sHexaRegex.exec(color))) {
return [
parseHex(i[1] + i[1]),
parseHex(i[2] + i[2]),
parseHex(i[3] + i[3]),
roundAlpha(parseHex(i[4] + i[4]) / 255)
];
}
else if (color in colors) {
return rgba(colors[color]);
}
else if (hslRegex.test(color) || hslaRegex.test(color)) {
const [h, s, l, a] = hsla(color);
return [...hsl2rgb(h, s, l), a];
}
else if (hsvRegex.test(color) || hsvaRegex.test(color)) {
const [h, s, v, a] = hsva(color);
return [...hsv2rgb(h, s, v), a];
}
throw new Error(`[seemly/rgba]: Invalid color value ${color}.`);
}
catch (e) {
throw e;
}
}
function normalizeAlpha(alphaValue) {
return alphaValue > 1 ? 1 : alphaValue < 0 ? 0 : alphaValue;
}
function stringifyRgb(r, g, b) {
return `rgb(${roundChannel(r)}, ${roundChannel(g)}, ${roundChannel(b)})`;
}
function stringifyRgba(r, g, b, a) {
return `rgba(${roundChannel(r)}, ${roundChannel(g)}, ${roundChannel(b)}, ${normalizeAlpha(a)})`;
}
function compositeChannel(v1, a1, v2, a2, a) {
return roundChannel((v1 * a1 * (1 - a2) + v2 * a2) / a);
}
function composite(background, overlay) {
if (!Array.isArray(background))
background = rgba(background);
if (!Array.isArray(overlay))
overlay = rgba(overlay);
const a1 = background[3];
const a2 = overlay[3];
const alpha = roundAlpha(a1 + a2 - a1 * a2);
return stringifyRgba(compositeChannel(background[0], a1, overlay[0], a2, alpha), compositeChannel(background[1], a1, overlay[1], a2, alpha), compositeChannel(background[2], a1, overlay[2], a2, alpha), alpha);
}
function changeColor(base, options) {
const [r, g, b, a = 1] = Array.isArray(base) ? base : rgba(base);
if (typeof options.alpha === 'number') {
return stringifyRgba(r, g, b, options.alpha);
}
return stringifyRgba(r, g, b, a);
}
function scaleColor(base, options) {
const [r, g, b, a = 1] = Array.isArray(base) ? base : rgba(base);
const { lightness = 1, alpha = 1 } = options;
return toRgbaString([r * lightness, g * lightness, b * lightness, a * alpha]);
}
function getAlpha(base) {
var _a;
const alpha = (_a = (Array.isArray(base) ? base : rgba(base))[3]) !== null && _a !== void 0 ? _a : 1;
return alpha;
}
function getAlphaString(base) {
return `${getAlpha(base)}`;
}
function roundAlpha(value) {
const v = Math.round(Number(value) * 100) / 100;
if (v > 1)
return 1;
if (v < 0)
return 0;
return v;
}
function roundDeg(value) {
const v = Math.round(Number(value));
if (v >= 360)
return 0;
if (v < 0)
return 0;
return v;
}
function roundChannel(value) {
const v = Math.round(Number(value));
if (v > 255)
return 255;
if (v < 0)
return 0;
return v;
}
function roundPercent(value) {
const v = Math.round(Number(value));
if (v > 100)
return 100;
if (v < 0)
return 0;
return v;
}
function toRgbString(base) {
const [r, g, b] = Array.isArray(base) ? base : rgba(base);
return stringifyRgb(r, g, b);
}
function toRgbaString(base) {
const [r, g, b] = base;
if (3 in base) {
return `rgba(${roundChannel(r)}, ${roundChannel(g)}, ${roundChannel(b)}, ${roundAlpha(base[3])})`;
}
return `rgba(${roundChannel(r)}, ${roundChannel(g)}, ${roundChannel(b)}, 1)`;
}
function toHsvString(base) {
return `hsv(${roundDeg(base[0])}, ${roundPercent(base[1])}%, ${roundPercent(base[2])}%)`;
}
function toHsvaString(base) {
const [h, s, v] = base;
if (3 in base) {
return `hsva(${roundDeg(h)}, ${roundPercent(s)}%, ${roundPercent(v)}%, ${roundAlpha(base[3])})`;
}
return `hsva(${roundDeg(h)}, ${roundPercent(s)}%, ${roundPercent(v)}%, 1)`;
}
function toHslString(base) {
return `hsl(${roundDeg(base[0])}, ${roundPercent(base[1])}%, ${roundPercent(base[2])}%)`;
}
function toHslaString(base) {
const [h, s, l] = base;
if (3 in base) {
return `hsla(${roundDeg(h)}, ${roundPercent(s)}%, ${roundPercent(l)}%, ${roundAlpha(base[3])})`;
}
return `hsla(${roundDeg(h)}, ${roundPercent(s)}%, ${roundPercent(l)}%, 1)`;
}
/**
*
* @param base [255, 255, 255, 255], [255, 255, 255], any hex string
* @returns
*/
function toHexaString(base) {
if (typeof base === 'string') {
let i;
if (i = hexRegex.exec(base)) {
return `${i[0]}FF`;
}
else if (i = hexaRegex.exec(base)) {
return i[0];
}
else if (i = sHexRegex.exec(base)) {
return `#${i[1]}${i[1]}${i[2]}${i[2]}${i[3]}${i[3]}FF`;
}
else if (i = sHexaRegex.exec(base)) {
return `#${i[1]}${i[1]}${i[2]}${i[2]}${i[3]}${i[3]}${i[4]}${i[4]}`;
}
throw new Error(`[seemly/toHexString]: Invalid hex value ${base}.`);
}
const hex = `#${base
.slice(0, 3)
.map((unit) => roundChannel(unit).toString(16).toUpperCase().padStart(2, '0'))
.join('')}`;
const a = base.length === 3
? 'FF'
: roundChannel(base[3] * 255)
.toString(16)
.padStart(2, '0')
.toUpperCase();
return hex + a;
}
/**
*
* @param base [255, 255, 255, 255], [255, 255, 255], any hex string
* @returns
*/
function toHexString(base) {
if (typeof base === 'string') {
let i;
if (i = hexRegex.exec(base)) {
return i[0];
}
else if (i = hexaRegex.exec(base)) {
return i[0].slice(0, 7);
}
else if (i = (sHexRegex.exec(base) || sHexaRegex.exec(base))) {
return `#${i[1]}${i[1]}${i[2]}${i[2]}${i[3]}${i[3]}`;
}
throw new Error(`[seemly/toHexString]: Invalid hex value ${base}.`);
}
return `#${base
.slice(0, 3)
.map((unit) => roundChannel(unit).toString(16).toUpperCase().padStart(2, '0'))
.join('')}`;
}
;// ./node_modules/vooks/es/use-memo.js
function useMemo(getterOrOptions) {
const computedValueRef = runtime_core_esm_bundler_computed(getterOrOptions);
// Maybe it's not possible to lazy evaluate the value, since we can't make
// render phase capture the deps behind useMemo
const valueRef = ref(computedValueRef.value);
runtime_core_esm_bundler_watch(computedValueRef, (value) => {
valueRef.value = value;
});
if (typeof getterOrOptions === 'function') {
return valueRef;
}
else {
return {
__v_isRef: true,
get value() {
return valueRef.value;
},
set value(v) {
getterOrOptions.set(v);
}
};
}
}
/* harmony default export */ var use_memo = (useMemo);
;// ./node_modules/naive-ui/es/_internal/fade-in-expand-transition/src/FadeInExpandTransition.mjs
/* harmony default export */ var FadeInExpandTransition = (defineComponent({
name: 'FadeInExpandTransition',
props: {
appear: Boolean,
group: Boolean,
mode: String,
onLeave: Function,
onAfterLeave: Function,
onAfterEnter: Function,
width: Boolean,
// reverse mode is only used in tree
// it make it from expanded to collapsed after mounted
reverse: Boolean
},
setup(props, {
slots
}) {
function handleBeforeLeave(el) {
if (props.width) {
el.style.maxWidth = `${el.offsetWidth}px`;
} else {
el.style.maxHeight = `${el.offsetHeight}px`;
}
void el.offsetWidth;
}
function handleLeave(el) {
if (props.width) {
el.style.maxWidth = '0';
} else {
el.style.maxHeight = '0';
}
void el.offsetWidth;
const {
onLeave
} = props;
if (onLeave) onLeave();
}
function handleAfterLeave(el) {
if (props.width) {
el.style.maxWidth = '';
} else {
el.style.maxHeight = '';
}
const {
onAfterLeave
} = props;
if (onAfterLeave) onAfterLeave();
}
function handleEnter(el) {
el.style.transition = 'none';
if (props.width) {
const memorizedWidth = el.offsetWidth;
el.style.maxWidth = '0';
void el.offsetWidth;
el.style.transition = '';
el.style.maxWidth = `${memorizedWidth}px`;
} else {
if (props.reverse) {
el.style.maxHeight = `${el.offsetHeight}px`;
void el.offsetHeight;
el.style.transition = '';
el.style.maxHeight = '0';
} else {
const memorizedHeight = el.offsetHeight;
el.style.maxHeight = '0';
void el.offsetWidth;
el.style.transition = '';
el.style.maxHeight = `${memorizedHeight}px`;
}
}
void el.offsetWidth;
}
function handleAfterEnter(el) {
var _a;
if (props.width) {
el.style.maxWidth = '';
} else {
if (!props.reverse) {
el.style.maxHeight = '';
}
}
(_a = props.onAfterEnter) === null || _a === void 0 ? void 0 : _a.call(props);
}
return () => {
const {
group,
width,
appear,
mode
} = props;
const type = group ? TransitionGroup : Transition;
const resolvedProps = {
name: width ? 'fade-in-width-expand-transition' : 'fade-in-height-expand-transition',
appear,
onEnter: handleEnter,
onAfterEnter: handleAfterEnter,
onBeforeLeave: handleBeforeLeave,
onLeave: handleLeave,
onAfterLeave: handleAfterLeave
};
if (!group) {
;
resolvedProps.mode = mode;
}
return h(type, resolvedProps, slots);
};
}
}));
;// ./node_modules/vooks/es/life-cycle/use-is-mounted.js
function isMounted() {
const isMounted = ref(false);
runtime_core_esm_bundler_onMounted(() => { isMounted.value = true; });
return readonly(isMounted);
}
;// ./node_modules/naive-ui/es/_internal/icon-switch-transition/src/IconSwitchTransition.mjs
/* harmony default export */ var IconSwitchTransition = (defineComponent({
name: 'BaseIconSwitchTransition',
setup(_, {
slots
}) {
const isMountedRef = isMounted();
return () => h(Transition, {
name: "icon-switch-transition",
appear: isMountedRef.value
}, slots);
}
}));
;// ./node_modules/@css-render/vue3-ssr/esm/index.js
const esm_ssrContextKey = '@css-render/vue3-ssr';
function createStyleString(id, style) {
return `<style cssr-id="${id}">\n${style}\n</style>`;
}
function ssrAdapter(id, style, ssrContext) {
const { styles, ids } = ssrContext;
// we need to impl other options to make it behaves the same as the client side
if (ids.has(id))
return;
if (styles !== null) {
ids.add(id);
styles.push(createStyleString(id, style));
}
}
const isBrowser = typeof document !== 'undefined';
function useSsrAdapter() {
if (isBrowser)
return undefined;
const context = runtime_core_esm_bundler_inject(esm_ssrContextKey, null);
if (context === null)
return undefined;
return {
adapter: (id, style) => ssrAdapter(id, style, context),
context
};
}
function setup(app) {
const styles = [];
const ssrContext = {
styles,
ids: new Set()
};
app.provide(esm_ssrContextKey, ssrContext);
return {
collect() {
const res = styles.join('\n');
styles.length = 0;
return res;
}
};
}
;// ./node_modules/@css-render/plugin-bem/esm/index.js
/* eslint-disable @typescript-eslint/restrict-template-expressions */
/* eslint-disable @typescript-eslint/strict-boolean-expressions */
function esm_plugin(options) {
let _bPrefix = '.';
let _ePrefix = '__';
let _mPrefix = '--';
let c;
if (options) {
let t = options.blockPrefix;
if (t) {
_bPrefix = t;
}
t = options.elementPrefix;
if (t) {
_ePrefix = t;
}
t = options.modifierPrefix;
if (t) {
_mPrefix = t;
}
}
const _plugin = {
install(instance) {
c = instance.c;
const ctx = instance.context;
ctx.bem = {};
ctx.bem.b = null;
ctx.bem.els = null;
}
};
function b(arg) {
let memorizedB;
let memorizedE;
return {
before(ctx) {
memorizedB = ctx.bem.b;
memorizedE = ctx.bem.els;
ctx.bem.els = null;
},
after(ctx) {
ctx.bem.b = memorizedB;
ctx.bem.els = memorizedE;
},
$({ context, props }) {
arg = typeof arg === 'string' ? arg : arg({ context, props });
context.bem.b = arg;
return `${(props === null || props === void 0 ? void 0 : props.bPrefix) || _bPrefix}${context.bem.b}`;
}
};
}
function e(arg) {
let memorizedE;
return {
before(ctx) {
memorizedE = ctx.bem.els;
},
after(ctx) {
ctx.bem.els = memorizedE;
},
$({ context, props }) {
arg = typeof arg === 'string' ? arg : arg({ context, props });
context.bem.els = arg.split(',').map(v => v.trim());
return context.bem.els
.map(el => `${(props === null || props === void 0 ? void 0 : props.bPrefix) || _bPrefix}${context.bem.b}${_ePrefix}${el}`).join(', ');
}
};
}
function m(arg) {
return {
$({ context, props }) {
arg = typeof arg === 'string' ? arg : arg({ context, props });
const modifiers = arg.split(',').map(v => v.trim());
function elementToSelector(el) {
return modifiers.map(modifier => `&${(props === null || props === void 0 ? void 0 : props.bPrefix) || _bPrefix}${context.bem.b}${el !== undefined ? `${_ePrefix}${el}` : ''}${_mPrefix}${modifier}`).join(', ');
}
const els = context.bem.els;
if (els !== null) {
if (false) {}
return elementToSelector(els[0]);
}
else {
return elementToSelector();
}
}
};
}
function notM(arg) {
return {
$({ context, props }) {
arg = typeof arg === 'string' ? arg : arg({ context, props });
const els = context.bem.els;
if (false) {}
return `&:not(${(props === null || props === void 0 ? void 0 : props.bPrefix) || _bPrefix}${context.bem.b}${(els !== null && els.length > 0) ? `${_ePrefix}${els[0]}` : ''}${_mPrefix}${arg})`;
}
};
}
const cB = ((...args) => c(b(args[0]), args[1], args[2]));
const cE = ((...args) => c(e(args[0]), args[1], args[2]));
const cM = ((...args) => c(m(args[0]), args[1], args[2]));
const cNotM = ((...args) => c(notM(args[0]), args[1], args[2]));
Object.assign(_plugin, {
cB, cE, cM, cNotM
});
return _plugin;
}
/* harmony default export */ var esm = ((/* unused pure expression or super */ null && (esm_plugin)));
;// ./node_modules/css-render/esm/parse.js
function ampCount(selector) {
let cnt = 0;
for (let i = 0; i < selector.length; ++i) {
if (selector[i] === '&')
++cnt;
}
return cnt;
}
/**
* Don't just use ',' to separate css selector. For example:
* x:(a, b) {} will be split into 'x:(a' and 'b)', which is not expected.
* Make sure comma doesn't exist inside parentheses.
*/
const separatorRegex = /\s*,(?![^(]*\))\s*/g;
const extraSpaceRegex = /\s+/g;
/**
* selector must includes '&'
* selector is trimmed
* every part of amp is trimmed
*/
function resolveSelectorWithAmp(amp, selector) {
const nextAmp = [];
selector.split(separatorRegex).forEach(partialSelector => {
let round = ampCount(partialSelector);
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
if (!round) {
amp.forEach(partialAmp => {
nextAmp.push(
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
(partialAmp && partialAmp + ' ') + partialSelector);
});
return;
}
else if (round === 1) {
amp.forEach(partialAmp => {
nextAmp.push(partialSelector.replace('&', partialAmp));
});
return;
}
let partialNextAmp = [
partialSelector
];
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
while (round--) {
const nextPartialNextAmp = [];
partialNextAmp.forEach(selectorItr => {
amp.forEach(partialAmp => {
nextPartialNextAmp.push(selectorItr.replace('&', partialAmp));
});
});
partialNextAmp = nextPartialNextAmp;
}
partialNextAmp.forEach(part => nextAmp.push(part));
});
return nextAmp;
}
/**
* selector mustn't includes '&'
* selector is trimmed
*/
function resolveSelector(amp, selector) {
const nextAmp = [];
selector.split(separatorRegex).forEach(partialSelector => {
amp.forEach(partialAmp => {
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
nextAmp.push(((partialAmp && partialAmp + ' ') + partialSelector));
});
});
return nextAmp;
}
function parseSelectorPath(selectorPaths) {
let amp = [''];
selectorPaths.forEach(selector => {
// eslint-disable-next-line
selector = selector && selector.trim();
if (
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
!selector) {
/**
* if it's a empty selector, do nothing
*/
return;
}
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
if (selector.includes('&')) {
amp = resolveSelectorWithAmp(amp, selector);
}
else {
amp = resolveSelector(amp, selector);
}
});
return amp.join(', ').replace(extraSpaceRegex, ' ');
}
;// ./node_modules/css-render/esm/utils.js
function removeElement(el) {
/* istanbul ignore if */
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
if (!el)
return;
const parentElement = el.parentElement;
/* istanbul ignore else */
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
if (parentElement)
parentElement.removeChild(el);
}
function queryElement(id, parent) {
return (parent !== null && parent !== void 0 ? parent : document.head).querySelector(`style[cssr-id="${id}"]`);
}
function createElement(id) {
const el = document.createElement('style');
el.setAttribute('cssr-id', id);
return el;
}
function isMediaOrSupports(selector) {
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
if (!selector)
return false;
return /^\s*@(s|m)/.test(selector);
}
;// ./node_modules/css-render/esm/render.js
const kebabRegex = /[A-Z]/g;
function kebabCase(pattern) {
return pattern.replace(kebabRegex, match => '-' + match.toLowerCase());
}
/** TODO: refine it to solve nested object */
function unwrapProperty(prop, indent = ' ') {
if (typeof prop === 'object' && prop !== null) {
return (' {\n' +
Object.entries(prop).map(v => {
return indent + ` ${kebabCase(v[0])}: ${v[1]};`;
}).join('\n') +
'\n' + indent + '}');
}
return `: ${prop};`;
}
/** unwrap properties */
function unwrapProperties(props, instance, params) {
if (typeof props === 'function') {
return props({
context: instance.context,
props: params
});
}
return props;
}
function createStyle(selector, props, instance, params) {
if (!props)
return '';
// eslint-disable-next-line
const unwrappedProps = unwrapProperties(props, instance, params);
if (!unwrappedProps)
return '';
if (typeof unwrappedProps === 'string') {
return `${selector} {\n${unwrappedProps}\n}`;
}
const propertyNames = Object.keys(unwrappedProps);
if (propertyNames.length === 0) {
if (instance.config.keepEmptyBlock)
return selector + ' {\n}';
return '';
}
const statements = selector
? [
selector + ' {'
]
: [];
propertyNames.forEach(propertyName => {
const property = unwrappedProps[propertyName];
if (propertyName === 'raw') {
statements.push('\n' + property + '\n');
return;
}
propertyName = kebabCase(propertyName);
if (property !== null && property !== undefined) {
statements.push(` ${propertyName}${unwrapProperty(property)}`);
}
});
if (selector) {
statements.push('}');
}
return statements.join('\n');
}
function loopCNodeListWithCallback(children, options, callback) {
/* istanbul ignore if */
if (!children)
return;
children.forEach(child => {
if (Array.isArray(child)) {
loopCNodeListWithCallback(child, options, callback);
}
else if (typeof child === 'function') {
const grandChildren = child(options);
if (Array.isArray(grandChildren)) {
loopCNodeListWithCallback(grandChildren, options, callback);
}
else if (grandChildren) {
callback(grandChildren);
}
}
else if (child) {
callback(child);
}
});
}
function traverseCNode(node, selectorPaths, styles, instance, params) {
const $ = node.$;
let blockSelector = '';
if (!$ || typeof $ === 'string') {
if (isMediaOrSupports($)) {
blockSelector = $;
}
else {
// as a string selector
selectorPaths.push($);
}
}
else if (typeof $ === 'function') {
const selector = $({
context: instance.context,
props: params
});
if (isMediaOrSupports(selector)) {
blockSelector = selector;
}
else {
// as a lazy selector
selectorPaths.push(selector);
}
}
else { // as a option selector
if ($.before)
$.before(instance.context);
if (!$.$ || typeof $.$ === 'string') {
if (isMediaOrSupports($.$)) {
blockSelector = $.$;
}
else {
// as a string selector
selectorPaths.push($.$);
}
}
else /* istanbul ignore else */ if ($.$) {
const selector = $.$({
context: instance.context,
props: params
});
if (isMediaOrSupports(selector)) {
blockSelector = selector;
}
else {
// as a lazy selector
selectorPaths.push(selector);
}
}
}
const selector = parseSelectorPath(selectorPaths);
const style = createStyle(selector, node.props, instance, params);
if (blockSelector) {
styles.push(`${blockSelector} {`);
}
else if (style.length) {
styles.push(style);
}
if (node.children) {
loopCNodeListWithCallback(node.children, {
context: instance.context,
props: params
}, childNode => {
if (typeof childNode === 'string') {
const style = createStyle(selector, { raw: childNode }, instance, params);
styles.push(style);
}
else {
traverseCNode(childNode, selectorPaths, styles, instance, params);
}
});
}
selectorPaths.pop();
if (blockSelector) {
styles.push('}');
}
if ($ && $.after)
$.after(instance.context);
}
function render_render(node, instance, props) {
const styles = [];
traverseCNode(node, [], styles, instance, props);
return styles.join('\n\n');
}
;// ./node_modules/@emotion/hash/dist/hash.browser.esm.js
/* eslint-disable */
// Inspired by https://github.com/garycourt/murmurhash-js
// Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86
function murmur2(str) {
// 'm' and 'r' are mixing constants generated offline.
// They're not really 'magic', they just happen to work well.
// const m = 0x5bd1e995;
// const r = 24;
// Initialize the hash
var h = 0; // Mix 4 bytes at a time into the hash
var k,
i = 0,
len = str.length;
for (; len >= 4; ++i, len -= 4) {
k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
k =
/* Math.imul(k, m): */
(k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);
k ^=
/* k >>> r: */
k >>> 24;
h =
/* Math.imul(k, m): */
(k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^
/* Math.imul(h, m): */
(h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
} // Handle the last few bytes of the input array
switch (len) {
case 3:
h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
case 2:
h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
case 1:
h ^= str.charCodeAt(i) & 0xff;
h =
/* Math.imul(h, m): */
(h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
} // Do a few final mixes of the hash to ensure the last few
// bytes are well-incorporated.
h ^= h >>> 13;
h =
/* Math.imul(h, m): */
(h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
return ((h ^ h >>> 15) >>> 0).toString(36);
}
/* harmony default export */ var hash_browser_esm = (murmur2);
;// ./node_modules/css-render/esm/mount.js
/* eslint-disable @typescript-eslint/prefer-ts-expect-error */
/* eslint-disable @typescript-eslint/strict-boolean-expressions */
if (typeof window !== 'undefined') {
window.__cssrContext = {};
}
function unmount(instance, node, id, parent) {
const { els } = node;
// If id is undefined, unmount all styles
if (id === undefined) {
els.forEach(removeElement);
node.els = [];
}
else {
const target = queryElement(id, parent);
// eslint-disable-next-line
if (target && els.includes(target)) {
removeElement(target);
node.els = els.filter((el) => el !== target);
}
}
}
function addElementToList(els, target) {
els.push(target);
}
function mount(instance, node, id, props, head, force, anchorMetaName, parent, ssrAdapter
// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
) {
let style;
if (id === undefined) {
style = node.render(props);
id = hash_browser_esm(style);
}
if (ssrAdapter) {
ssrAdapter.adapter(id, style !== null && style !== void 0 ? style : node.render(props));
return;
}
if (parent === undefined) {
parent = document.head;
}
const queriedTarget = queryElement(id, parent);
if (queriedTarget !== null && !force) {
return queriedTarget;
}
const target = queriedTarget !== null && queriedTarget !== void 0 ? queriedTarget : createElement(id);
if (style === undefined)
style = node.render(props);
target.textContent = style;
if (queriedTarget !== null)
return queriedTarget;
if (anchorMetaName) {
const anchorMetaEl = parent.querySelector(`meta[name="${anchorMetaName}"]`);
if (anchorMetaEl) {
parent.insertBefore(target, anchorMetaEl);
addElementToList(node.els, target);
return target;
}
}
if (head) {
parent.insertBefore(target, parent.querySelector('style, link'));
}
else {
parent.appendChild(target);
}
addElementToList(node.els, target);
return target;
}
;// ./node_modules/css-render/esm/c.js
function wrappedRender(props) {
return render_render(this, this.instance, props);
}
// do not guard node calling, it should throw an error.
function wrappedMount(options = {}
// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
) {
const { id, ssr, props, head = false, force = false, anchorMetaName, parent } = options;
const targetElement = mount(this.instance, this, id, props, head, force, anchorMetaName, parent, ssr);
return targetElement;
}
function wrappedUnmount(options = {}) {
/* istanbul ignore next */
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
const { id, parent } = options;
unmount(this.instance, this, id, parent);
}
const createCNode = function (instance, $, props, children) {
return {
instance,
$,
props,
children,
els: [],
render: wrappedRender,
mount: wrappedMount,
unmount: wrappedUnmount
};
};
const c = function (instance, $, props, children) {
if (Array.isArray($)) {
return createCNode(instance, { $: null }, null, $);
}
else if (Array.isArray(props)) {
return createCNode(instance, $, null, props);
}
else if (Array.isArray(children)) {
return createCNode(instance, $, props, children);
}
else {
return createCNode(instance, $, props, null);
}
};
;// ./node_modules/css-render/esm/CssRender.js
function CssRender(config = {}) {
const cssr = {
c: ((...args) => c(cssr, ...args)),
use: (plugin, ...args) => plugin.install(cssr, ...args),
find: queryElement,
context: {},
config
};
return cssr;
}
;// ./node_modules/naive-ui/es/_utils/cssr/index.mjs
const namespace = 'n';
const cssr_prefix = `.${namespace}-`;
const elementPrefix = '__';
const modifierPrefix = '--';
const cssr = CssRender();
const cssr_plugin = esm_plugin({
blockPrefix: cssr_prefix,
elementPrefix,
modifierPrefix
});
cssr.use(cssr_plugin);
const {
c: cssr_c,
find
} = cssr;
const {
cB,
cE,
cM,
cNotM
} = cssr_plugin;
function insideModal(style) {
return cssr_c(({
props: {
bPrefix
}
}) => `${bPrefix || cssr_prefix}modal, ${bPrefix || cssr_prefix}drawer`, [style]);
}
function insidePopover(style) {
return cssr_c(({
props: {
bPrefix
}
}) => `${bPrefix || cssr_prefix}popover`, [style]);
}
function asModal(style) {
return cssr_c(({
props: {
bPrefix
}
}) => `&${bPrefix || cssr_prefix}modal`, style);
}
// child block
const cCB = (...args) => {
return cssr_c('>', [cB(...args)]);
};
function createKey(prefix, suffix) {
return prefix + (suffix === 'default' ? '' : suffix.replace(/^[a-z]/, startChar => startChar.toUpperCase()));
}
;// ./node_modules/naive-ui/es/_styles/common/_common.mjs
/* harmony default export */ var _common = ({
fontFamily: 'v-sans, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol"',
fontFamilyMono: 'v-mono, SFMono-Regular, Menlo, Consolas, Courier, monospace',
fontWeight: '400',
fontWeightStrong: '500',
cubicBezierEaseInOut: 'cubic-bezier(.4, 0, .2, 1)',
cubicBezierEaseOut: 'cubic-bezier(0, 0, .2, 1)',
cubicBezierEaseIn: 'cubic-bezier(.4, 0, 1, 1)',
borderRadius: '3px',
borderRadiusSmall: '2px',
fontSize: '14px',
fontSizeMini: '12px',
fontSizeTiny: '12px',
fontSizeSmall: '14px',
fontSizeMedium: '14px',
fontSizeLarge: '15px',
fontSizeHuge: '16px',
lineHeight: '1.6',
heightMini: '16px',
// private now, it's too small
heightTiny: '22px',
heightSmall: '28px',
heightMedium: '34px',
heightLarge: '40px',
heightHuge: '46px'
});
;// ./node_modules/naive-ui/es/_styles/global/index.cssr.mjs
const {
fontSize,
fontFamily,
lineHeight
} = _common;
// All the components need the style
// It is static and won't be changed in the app's lifetime
// If user want to overrides it they need to use `n-global-style` is provided
//
// Technically we can remove font-size & font-family & line-height to make
// it pure. However the coding cost doesn't worth it.
//
// -webkit-tap-hilight-color:
// https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-tap-highlight-color
// In some android devices, there will be the style.
/* harmony default export */ var index_cssr = (cssr_c('body', `
margin: 0;
font-size: ${fontSize};
font-family: ${fontFamily};
line-height: ${lineHeight};
-webkit-text-size-adjust: 100%;
-webkit-tap-highlight-color: transparent;
`, [cssr_c('input', `
font-family: inherit;
font-size: inherit;
`)]));
;// ./node_modules/naive-ui/es/_utils/vue/create-injection-key.mjs
function createInjectionKey(key) {
return key;
}
;// ./node_modules/naive-ui/es/config-provider/src/context.mjs
const context_configProviderInjectionKey = createInjectionKey('n-config-provider');
;// ./node_modules/naive-ui/es/_mixins/common.mjs
const cssrAnchorMetaName = 'naive-ui-style';
;// ./node_modules/naive-ui/es/_mixins/use-style.mjs
function useStyle(mountId, style, clsPrefixRef) {
if (!style) {
if (false) {}
return;
}
const ssrAdapter = useSsrAdapter();
const NConfigProvider = runtime_core_esm_bundler_inject(context_configProviderInjectionKey, null);
const mountStyle = () => {
const clsPrefix = clsPrefixRef.value;
style.mount({
id: clsPrefix === undefined ? mountId : clsPrefix + mountId,
head: true,
anchorMetaName: cssrAnchorMetaName,
props: {
bPrefix: clsPrefix ? `.${clsPrefix}-` : undefined
},
ssr: ssrAdapter,
parent: NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.styleMountTarget
});
if (!(NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.preflightStyleDisabled)) {
index_cssr.mount({
id: 'n-global',
head: true,
anchorMetaName: cssrAnchorMetaName,
ssr: ssrAdapter,
parent: NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.styleMountTarget
});
}
};
if (ssrAdapter) {
mountStyle();
} else {
onBeforeMount(mountStyle);
}
}
;// ./node_modules/naive-ui/es/_styles/transitions/icon-switch.cssr.mjs
const {
cubicBezierEaseInOut
} = _common;
function iconSwitchTransition({
originalTransform = '',
left = 0,
top = 0,
transition = `all .3s ${cubicBezierEaseInOut} !important`
} = {}) {
return [cssr_c('&.icon-switch-transition-enter-from, &.icon-switch-transition-leave-to', {
transform: `${originalTransform} scale(0.75)`,
left,
top,
opacity: 0
}), cssr_c('&.icon-switch-transition-enter-to, &.icon-switch-transition-leave-from', {
transform: `scale(1) ${originalTransform}`,
left,
top,
opacity: 1
}), cssr_c('&.icon-switch-transition-enter-active, &.icon-switch-transition-leave-active', {
transformOrigin: 'center',
position: 'absolute',
left,
top,
transition
})];
}
;// ./node_modules/naive-ui/es/_internal/loading/src/styles/index.cssr.mjs
/* harmony default export */ var styles_index_cssr = (cssr_c([cssr_c('@keyframes rotator', `
0% {
-webkit-transform: rotate(0deg);
transform: rotate(0deg);
}
100% {
-webkit-transform: rotate(360deg);
transform: rotate(360deg);
}`), cB('base-loading', `
position: relative;
line-height: 0;
width: 1em;
height: 1em;
`, [cE('transition-wrapper', `
position: absolute;
width: 100%;
height: 100%;
`, [iconSwitchTransition()]), cE('placeholder', `
position: absolute;
left: 50%;
top: 50%;
transform: translateX(-50%) translateY(-50%);
`, [iconSwitchTransition({
left: '50%',
top: '50%',
originalTransform: 'translateX(-50%) translateY(-50%)'
})]), cE('container', `
animation: rotator 3s linear infinite both;
`, [cE('icon', `
height: 1em;
width: 1em;
`)])])]));
;// ./node_modules/naive-ui/es/_internal/loading/src/Loading.mjs
const duration = '1.6s';
const exposedLoadingProps = {
strokeWidth: {
type: Number,
default: 28
},
stroke: {
type: String,
default: undefined
}
};
/* harmony default export */ var Loading = (defineComponent({
name: 'BaseLoading',
props: Object.assign({
clsPrefix: {
type: String,
required: true
},
show: {
type: Boolean,
default: true
},
scale: {
type: Number,
default: 1
},
radius: {
type: Number,
default: 100
}
}, exposedLoadingProps),
setup(props) {
useStyle('-base-loading', styles_index_cssr, toRef(props, 'clsPrefix'));
},
render() {
const {
clsPrefix,
radius,
strokeWidth,
stroke,
scale
} = this;
const scaledRadius = radius / scale;
return h("div", {
class: `${clsPrefix}-base-loading`,
role: "img",
"aria-label": "loading"
}, h(IconSwitchTransition, null, {
default: () => this.show ? h("div", {
key: "icon",
class: `${clsPrefix}-base-loading__transition-wrapper`
}, h("div", {
class: `${clsPrefix}-base-loading__container`
}, h("svg", {
class: `${clsPrefix}-base-loading__icon`,
viewBox: `0 0 ${2 * scaledRadius} ${2 * scaledRadius}`,
xmlns: "http://www.w3.org/2000/svg",
style: {
color: stroke
}
}, h("g", null, h("animateTransform", {
attributeName: "transform",
type: "rotate",
values: `0 ${scaledRadius} ${scaledRadius};270 ${scaledRadius} ${scaledRadius}`,
begin: "0s",
dur: duration,
fill: "freeze",
repeatCount: "indefinite"
}), h("circle", {
class: `${clsPrefix}-base-loading__icon`,
fill: "none",
stroke: "currentColor",
"stroke-width": strokeWidth,
"stroke-linecap": "round",
cx: scaledRadius,
cy: scaledRadius,
r: radius - strokeWidth / 2,
"stroke-dasharray": 5.67 * radius,
"stroke-dashoffset": 18.48 * radius
}, h("animateTransform", {
attributeName: "transform",
type: "rotate",
values: `0 ${scaledRadius} ${scaledRadius};135 ${scaledRadius} ${scaledRadius};450 ${scaledRadius} ${scaledRadius}`,
begin: "0s",
dur: duration,
fill: "freeze",
repeatCount: "indefinite"
}), h("animate", {
attributeName: "stroke-dashoffset",
values: `${5.67 * radius};${1.42 * radius};${5.67 * radius}`,
begin: "0s",
dur: duration,
fill: "freeze",
repeatCount: "indefinite"
})))))) : h("div", {
key: "placeholder",
class: `${clsPrefix}-base-loading__placeholder`
}, this.$slots)
}));
}
}));
;// ./node_modules/naive-ui/es/_internal/wave/src/styles/index.cssr.mjs
/* harmony default export */ var src_styles_index_cssr = (cB('base-wave', `
position: absolute;
left: 0;
right: 0;
top: 0;
bottom: 0;
border-radius: inherit;
`));
;// ./node_modules/naive-ui/es/_internal/wave/src/Wave.mjs
/* harmony default export */ var Wave = (defineComponent({
name: 'BaseWave',
props: {
clsPrefix: {
type: String,
required: true
}
},
setup(props) {
useStyle('-base-wave', src_styles_index_cssr, toRef(props, 'clsPrefix'));
const selfRef = ref(null);
const activeRef = ref(false);
let animationTimerId = null;
runtime_core_esm_bundler_onBeforeUnmount(() => {
if (animationTimerId !== null) {
window.clearTimeout(animationTimerId);
}
});
return {
active: activeRef,
selfRef,
play() {
if (animationTimerId !== null) {
window.clearTimeout(animationTimerId);
activeRef.value = false;
animationTimerId = null;
}
void nextTick(() => {
var _a;
void ((_a = selfRef.value) === null || _a === void 0 ? void 0 : _a.offsetHeight);
activeRef.value = true;
animationTimerId = window.setTimeout(() => {
activeRef.value = false;
animationTimerId = null;
}, 1000);
});
}
};
},
render() {
const {
clsPrefix
} = this;
return h("div", {
ref: "selfRef",
"aria-hidden": true,
class: [`${clsPrefix}-base-wave`, this.active && `${clsPrefix}-base-wave--active`]
});
}
}));
;// ./node_modules/lodash-es/_listCacheClear.js
/**
* Removes all key-value entries from the list cache.
*
* @private
* @name clear
* @memberOf ListCache
*/
function listCacheClear() {
this.__data__ = [];
this.size = 0;
}
/* harmony default export */ var _listCacheClear = (listCacheClear);
;// ./node_modules/lodash-es/eq.js
/**
* Performs a
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* comparison between two values to determine if they are equivalent.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
* @example
*
* var object = { 'a': 1 };
* var other = { 'a': 1 };
*
* _.eq(object, object);
* // => true
*
* _.eq(object, other);
* // => false
*
* _.eq('a', 'a');
* // => true
*
* _.eq('a', Object('a'));
* // => false
*
* _.eq(NaN, NaN);
* // => true
*/
function eq(value, other) {
return value === other || (value !== value && other !== other);
}
/* harmony default export */ var lodash_es_eq = (eq);
;// ./node_modules/lodash-es/_assocIndexOf.js
/**
* Gets the index at which the `key` is found in `array` of key-value pairs.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} key The key to search for.
* @returns {number} Returns the index of the matched value, else `-1`.
*/
function assocIndexOf(array, key) {
var length = array.length;
while (length--) {
if (lodash_es_eq(array[length][0], key)) {
return length;
}
}
return -1;
}
/* harmony default export */ var _assocIndexOf = (assocIndexOf);
;// ./node_modules/lodash-es/_listCacheDelete.js
/** Used for built-in method references. */
var _listCacheDelete_arrayProto = Array.prototype;
/** Built-in value references. */
var splice = _listCacheDelete_arrayProto.splice;
/**
* Removes `key` and its value from the list cache.
*
* @private
* @name delete
* @memberOf ListCache
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function listCacheDelete(key) {
var data = this.__data__,
index = _assocIndexOf(data, key);
if (index < 0) {
return false;
}
var lastIndex = data.length - 1;
if (index == lastIndex) {
data.pop();
} else {
splice.call(data, index, 1);
}
--this.size;
return true;
}
/* harmony default export */ var _listCacheDelete = (listCacheDelete);
;// ./node_modules/lodash-es/_listCacheGet.js
/**
* Gets the list cache value for `key`.
*
* @private
* @name get
* @memberOf ListCache
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function listCacheGet(key) {
var data = this.__data__,
index = _assocIndexOf(data, key);
return index < 0 ? undefined : data[index][1];
}
/* harmony default export */ var _listCacheGet = (listCacheGet);
;// ./node_modules/lodash-es/_listCacheHas.js
/**
* Checks if a list cache value for `key` exists.
*
* @private
* @name has
* @memberOf ListCache
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function listCacheHas(key) {
return _assocIndexOf(this.__data__, key) > -1;
}
/* harmony default export */ var _listCacheHas = (listCacheHas);
;// ./node_modules/lodash-es/_listCacheSet.js
/**
* Sets the list cache `key` to `value`.
*
* @private
* @name set
* @memberOf ListCache
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the list cache instance.
*/
function listCacheSet(key, value) {
var data = this.__data__,
index = _assocIndexOf(data, key);
if (index < 0) {
++this.size;
data.push([key, value]);
} else {
data[index][1] = value;
}
return this;
}
/* harmony default export */ var _listCacheSet = (listCacheSet);
;// ./node_modules/lodash-es/_ListCache.js
/**
* Creates an list cache object.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function ListCache(entries) {
var index = -1,
length = entries == null ? 0 : entries.length;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
// Add methods to `ListCache`.
ListCache.prototype.clear = _listCacheClear;
ListCache.prototype['delete'] = _listCacheDelete;
ListCache.prototype.get = _listCacheGet;
ListCache.prototype.has = _listCacheHas;
ListCache.prototype.set = _listCacheSet;
/* harmony default export */ var _ListCache = (ListCache);
;// ./node_modules/lodash-es/_stackClear.js
/**
* Removes all key-value entries from the stack.
*
* @private
* @name clear
* @memberOf Stack
*/
function stackClear() {
this.__data__ = new _ListCache;
this.size = 0;
}
/* harmony default export */ var _stackClear = (stackClear);
;// ./node_modules/lodash-es/_stackDelete.js
/**
* Removes `key` and its value from the stack.
*
* @private
* @name delete
* @memberOf Stack
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function stackDelete(key) {
var data = this.__data__,
result = data['delete'](key);
this.size = data.size;
return result;
}
/* harmony default export */ var _stackDelete = (stackDelete);
;// ./node_modules/lodash-es/_stackGet.js
/**
* Gets the stack value for `key`.
*
* @private
* @name get
* @memberOf Stack
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function stackGet(key) {
return this.__data__.get(key);
}
/* harmony default export */ var _stackGet = (stackGet);
;// ./node_modules/lodash-es/_stackHas.js
/**
* Checks if a stack value for `key` exists.
*
* @private
* @name has
* @memberOf Stack
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function stackHas(key) {
return this.__data__.has(key);
}
/* harmony default export */ var _stackHas = (stackHas);
;// ./node_modules/lodash-es/_freeGlobal.js
/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
/* harmony default export */ var _freeGlobal = (freeGlobal);
;// ./node_modules/lodash-es/_root.js
/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
/** Used as a reference to the global object. */
var root = _freeGlobal || freeSelf || Function('return this')();
/* harmony default export */ var _root = (root);
;// ./node_modules/lodash-es/_Symbol.js
/** Built-in value references. */
var _Symbol_Symbol = _root.Symbol;
/* harmony default export */ var _Symbol = (_Symbol_Symbol);
;// ./node_modules/lodash-es/_getRawTag.js
/** Used for built-in method references. */
var objectProto = Object.prototype;
/** Used to check objects for own properties. */
var _getRawTag_hasOwnProperty = objectProto.hasOwnProperty;
/**
* Used to resolve the
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
* of values.
*/
var nativeObjectToString = objectProto.toString;
/** Built-in value references. */
var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
/**
* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
*
* @private
* @param {*} value The value to query.
* @returns {string} Returns the raw `toStringTag`.
*/
function getRawTag(value) {
var isOwn = _getRawTag_hasOwnProperty.call(value, symToStringTag),
tag = value[symToStringTag];
try {
value[symToStringTag] = undefined;
var unmasked = true;
} catch (e) {}
var result = nativeObjectToString.call(value);
if (unmasked) {
if (isOwn) {
value[symToStringTag] = tag;
} else {
delete value[symToStringTag];
}
}
return result;
}
/* harmony default export */ var _getRawTag = (getRawTag);
;// ./node_modules/lodash-es/_objectToString.js
/** Used for built-in method references. */
var _objectToString_objectProto = Object.prototype;
/**
* Used to resolve the
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
* of values.
*/
var _objectToString_nativeObjectToString = _objectToString_objectProto.toString;
/**
* Converts `value` to a string using `Object.prototype.toString`.
*
* @private
* @param {*} value The value to convert.
* @returns {string} Returns the converted string.
*/
function _objectToString_objectToString(value) {
return _objectToString_nativeObjectToString.call(value);
}
/* harmony default export */ var _objectToString = (_objectToString_objectToString);
;// ./node_modules/lodash-es/_baseGetTag.js
/** `Object#toString` result references. */
var nullTag = '[object Null]',
undefinedTag = '[object Undefined]';
/** Built-in value references. */
var _baseGetTag_symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
/**
* The base implementation of `getTag` without fallbacks for buggy environments.
*
* @private
* @param {*} value The value to query.
* @returns {string} Returns the `toStringTag`.
*/
function baseGetTag(value) {
if (value == null) {
return value === undefined ? undefinedTag : nullTag;
}
return (_baseGetTag_symToStringTag && _baseGetTag_symToStringTag in Object(value))
? _getRawTag(value)
: _objectToString(value);
}
/* harmony default export */ var _baseGetTag = (baseGetTag);
;// ./node_modules/lodash-es/isObject.js
/**
* Checks if `value` is the
* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
* @example
*
* _.isObject({});
* // => true
*
* _.isObject([1, 2, 3]);
* // => true
*
* _.isObject(_.noop);
* // => true
*
* _.isObject(null);
* // => false
*/
function isObject_isObject(value) {
var type = typeof value;
return value != null && (type == 'object' || type == 'function');
}
/* harmony default export */ var lodash_es_isObject = (isObject_isObject);
;// ./node_modules/lodash-es/isFunction.js
/** `Object#toString` result references. */
var asyncTag = '[object AsyncFunction]',
funcTag = '[object Function]',
genTag = '[object GeneratorFunction]',
proxyTag = '[object Proxy]';
/**
* Checks if `value` is classified as a `Function` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a function, else `false`.
* @example
*
* _.isFunction(_);
* // => true
*
* _.isFunction(/abc/);
* // => false
*/
function isFunction_isFunction(value) {
if (!lodash_es_isObject(value)) {
return false;
}
// The use of `Object#toString` avoids issues with the `typeof` operator
// in Safari 9 which returns 'object' for typed arrays and other constructors.
var tag = _baseGetTag(value);
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
}
/* harmony default export */ var lodash_es_isFunction = (isFunction_isFunction);
;// ./node_modules/lodash-es/_coreJsData.js
/** Used to detect overreaching core-js shims. */
var coreJsData = _root['__core-js_shared__'];
/* harmony default export */ var _coreJsData = (coreJsData);
;// ./node_modules/lodash-es/_isMasked.js
/** Used to detect methods masquerading as native. */
var maskSrcKey = (function() {
var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || '');
return uid ? ('Symbol(src)_1.' + uid) : '';
}());
/**
* Checks if `func` has its source masked.
*
* @private
* @param {Function} func The function to check.
* @returns {boolean} Returns `true` if `func` is masked, else `false`.
*/
function isMasked(func) {
return !!maskSrcKey && (maskSrcKey in func);
}
/* harmony default export */ var _isMasked = (isMasked);
;// ./node_modules/lodash-es/_toSource.js
/** Used for built-in method references. */
var funcProto = Function.prototype;
/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;
/**
* Converts `func` to its source code.
*
* @private
* @param {Function} func The function to convert.
* @returns {string} Returns the source code.
*/
function toSource(func) {
if (func != null) {
try {
return funcToString.call(func);
} catch (e) {}
try {
return (func + '');
} catch (e) {}
}
return '';
}
/* harmony default export */ var _toSource = (toSource);
;// ./node_modules/lodash-es/_baseIsNative.js
/**
* Used to match `RegExp`
* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
*/
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;
/** Used for built-in method references. */
var _baseIsNative_funcProto = Function.prototype,
_baseIsNative_objectProto = Object.prototype;
/** Used to resolve the decompiled source of functions. */
var _baseIsNative_funcToString = _baseIsNative_funcProto.toString;
/** Used to check objects for own properties. */
var _baseIsNative_hasOwnProperty = _baseIsNative_objectProto.hasOwnProperty;
/** Used to detect if a method is native. */
var reIsNative = RegExp('^' +
_baseIsNative_funcToString.call(_baseIsNative_hasOwnProperty).replace(reRegExpChar, '\\$&')
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
);
/**
* The base implementation of `_.isNative` without bad shim checks.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a native function,
* else `false`.
*/
function baseIsNative(value) {
if (!lodash_es_isObject(value) || _isMasked(value)) {
return false;
}
var pattern = lodash_es_isFunction(value) ? reIsNative : reIsHostCtor;
return pattern.test(_toSource(value));
}
/* harmony default export */ var _baseIsNative = (baseIsNative);
;// ./node_modules/lodash-es/_getValue.js
/**
* Gets the value at `key` of `object`.
*
* @private
* @param {Object} [object] The object to query.
* @param {string} key The key of the property to get.
* @returns {*} Returns the property value.
*/
function _getValue_getValue(object, key) {
return object == null ? undefined : object[key];
}
/* harmony default export */ var _getValue = (_getValue_getValue);
;// ./node_modules/lodash-es/_getNative.js
/**
* Gets the native function at `key` of `object`.
*
* @private
* @param {Object} object The object to query.
* @param {string} key The key of the method to get.
* @returns {*} Returns the function if it's native, else `undefined`.
*/
function getNative(object, key) {
var value = _getValue(object, key);
return _baseIsNative(value) ? value : undefined;
}
/* harmony default export */ var _getNative = (getNative);
;// ./node_modules/lodash-es/_Map.js
/* Built-in method references that are verified to be native. */
var _Map_Map = _getNative(_root, 'Map');
/* harmony default export */ var _Map = (_Map_Map);
;// ./node_modules/lodash-es/_nativeCreate.js
/* Built-in method references that are verified to be native. */
var nativeCreate = _getNative(Object, 'create');
/* harmony default export */ var _nativeCreate = (nativeCreate);
;// ./node_modules/lodash-es/_hashClear.js
/**
* Removes all key-value entries from the hash.
*
* @private
* @name clear
* @memberOf Hash
*/
function hashClear() {
this.__data__ = _nativeCreate ? _nativeCreate(null) : {};
this.size = 0;
}
/* harmony default export */ var _hashClear = (hashClear);
;// ./node_modules/lodash-es/_hashDelete.js
/**
* Removes `key` and its value from the hash.
*
* @private
* @name delete
* @memberOf Hash
* @param {Object} hash The hash to modify.
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function hashDelete(key) {
var result = this.has(key) && delete this.__data__[key];
this.size -= result ? 1 : 0;
return result;
}
/* harmony default export */ var _hashDelete = (hashDelete);
;// ./node_modules/lodash-es/_hashGet.js
/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';
/** Used for built-in method references. */
var _hashGet_objectProto = Object.prototype;
/** Used to check objects for own properties. */
var _hashGet_hasOwnProperty = _hashGet_objectProto.hasOwnProperty;
/**
* Gets the hash value for `key`.
*
* @private
* @name get
* @memberOf Hash
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function hashGet(key) {
var data = this.__data__;
if (_nativeCreate) {
var result = data[key];
return result === HASH_UNDEFINED ? undefined : result;
}
return _hashGet_hasOwnProperty.call(data, key) ? data[key] : undefined;
}
/* harmony default export */ var _hashGet = (hashGet);
;// ./node_modules/lodash-es/_hashHas.js
/** Used for built-in method references. */
var _hashHas_objectProto = Object.prototype;
/** Used to check objects for own properties. */
var _hashHas_hasOwnProperty = _hashHas_objectProto.hasOwnProperty;
/**
* Checks if a hash value for `key` exists.
*
* @private
* @name has
* @memberOf Hash
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function hashHas(key) {
var data = this.__data__;
return _nativeCreate ? (data[key] !== undefined) : _hashHas_hasOwnProperty.call(data, key);
}
/* harmony default export */ var _hashHas = (hashHas);
;// ./node_modules/lodash-es/_hashSet.js
/** Used to stand-in for `undefined` hash values. */
var _hashSet_HASH_UNDEFINED = '__lodash_hash_undefined__';
/**
* Sets the hash `key` to `value`.
*
* @private
* @name set
* @memberOf Hash
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the hash instance.
*/
function hashSet(key, value) {
var data = this.__data__;
this.size += this.has(key) ? 0 : 1;
data[key] = (_nativeCreate && value === undefined) ? _hashSet_HASH_UNDEFINED : value;
return this;
}
/* harmony default export */ var _hashSet = (hashSet);
;// ./node_modules/lodash-es/_Hash.js
/**
* Creates a hash object.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function Hash(entries) {
var index = -1,
length = entries == null ? 0 : entries.length;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
// Add methods to `Hash`.
Hash.prototype.clear = _hashClear;
Hash.prototype['delete'] = _hashDelete;
Hash.prototype.get = _hashGet;
Hash.prototype.has = _hashHas;
Hash.prototype.set = _hashSet;
/* harmony default export */ var _Hash = (Hash);
;// ./node_modules/lodash-es/_mapCacheClear.js
/**
* Removes all key-value entries from the map.
*
* @private
* @name clear
* @memberOf MapCache
*/
function mapCacheClear() {
this.size = 0;
this.__data__ = {
'hash': new _Hash,
'map': new (_Map || _ListCache),
'string': new _Hash
};
}
/* harmony default export */ var _mapCacheClear = (mapCacheClear);
;// ./node_modules/lodash-es/_isKeyable.js
/**
* Checks if `value` is suitable for use as unique object key.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is suitable, else `false`.
*/
function isKeyable(value) {
var type = typeof value;
return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
? (value !== '__proto__')
: (value === null);
}
/* harmony default export */ var _isKeyable = (isKeyable);
;// ./node_modules/lodash-es/_getMapData.js
/**
* Gets the data for `map`.
*
* @private
* @param {Object} map The map to query.
* @param {string} key The reference key.
* @returns {*} Returns the map data.
*/
function getMapData(map, key) {
var data = map.__data__;
return _isKeyable(key)
? data[typeof key == 'string' ? 'string' : 'hash']
: data.map;
}
/* harmony default export */ var _getMapData = (getMapData);
;// ./node_modules/lodash-es/_mapCacheDelete.js
/**
* Removes `key` and its value from the map.
*
* @private
* @name delete
* @memberOf MapCache
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function mapCacheDelete(key) {
var result = _getMapData(this, key)['delete'](key);
this.size -= result ? 1 : 0;
return result;
}
/* harmony default export */ var _mapCacheDelete = (mapCacheDelete);
;// ./node_modules/lodash-es/_mapCacheGet.js
/**
* Gets the map value for `key`.
*
* @private
* @name get
* @memberOf MapCache
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function mapCacheGet(key) {
return _getMapData(this, key).get(key);
}
/* harmony default export */ var _mapCacheGet = (mapCacheGet);
;// ./node_modules/lodash-es/_mapCacheHas.js
/**
* Checks if a map value for `key` exists.
*
* @private
* @name has
* @memberOf MapCache
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function mapCacheHas(key) {
return _getMapData(this, key).has(key);
}
/* harmony default export */ var _mapCacheHas = (mapCacheHas);
;// ./node_modules/lodash-es/_mapCacheSet.js
/**
* Sets the map `key` to `value`.
*
* @private
* @name set
* @memberOf MapCache
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the map cache instance.
*/
function mapCacheSet(key, value) {
var data = _getMapData(this, key),
size = data.size;
data.set(key, value);
this.size += data.size == size ? 0 : 1;
return this;
}
/* harmony default export */ var _mapCacheSet = (mapCacheSet);
;// ./node_modules/lodash-es/_MapCache.js
/**
* Creates a map cache object to store key-value pairs.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function MapCache(entries) {
var index = -1,
length = entries == null ? 0 : entries.length;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
// Add methods to `MapCache`.
MapCache.prototype.clear = _mapCacheClear;
MapCache.prototype['delete'] = _mapCacheDelete;
MapCache.prototype.get = _mapCacheGet;
MapCache.prototype.has = _mapCacheHas;
MapCache.prototype.set = _mapCacheSet;
/* harmony default export */ var _MapCache = (MapCache);
;// ./node_modules/lodash-es/_stackSet.js
/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;
/**
* Sets the stack `key` to `value`.
*
* @private
* @name set
* @memberOf Stack
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the stack cache instance.
*/
function stackSet(key, value) {
var data = this.__data__;
if (data instanceof _ListCache) {
var pairs = data.__data__;
if (!_Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
pairs.push([key, value]);
this.size = ++data.size;
return this;
}
data = this.__data__ = new _MapCache(pairs);
}
data.set(key, value);
this.size = data.size;
return this;
}
/* harmony default export */ var _stackSet = (stackSet);
;// ./node_modules/lodash-es/_Stack.js
/**
* Creates a stack cache object to store key-value pairs.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function Stack(entries) {
var data = this.__data__ = new _ListCache(entries);
this.size = data.size;
}
// Add methods to `Stack`.
Stack.prototype.clear = _stackClear;
Stack.prototype['delete'] = _stackDelete;
Stack.prototype.get = _stackGet;
Stack.prototype.has = _stackHas;
Stack.prototype.set = _stackSet;
/* harmony default export */ var _Stack = (Stack);
;// ./node_modules/lodash-es/_defineProperty.js
var defineProperty = (function() {
try {
var func = _getNative(Object, 'defineProperty');
func({}, '', {});
return func;
} catch (e) {}
}());
/* harmony default export */ var _defineProperty = (defineProperty);
;// ./node_modules/lodash-es/_baseAssignValue.js
/**
* The base implementation of `assignValue` and `assignMergeValue` without
* value checks.
*
* @private
* @param {Object} object The object to modify.
* @param {string} key The key of the property to assign.
* @param {*} value The value to assign.
*/
function baseAssignValue(object, key, value) {
if (key == '__proto__' && _defineProperty) {
_defineProperty(object, key, {
'configurable': true,
'enumerable': true,
'value': value,
'writable': true
});
} else {
object[key] = value;
}
}
/* harmony default export */ var _baseAssignValue = (baseAssignValue);
;// ./node_modules/lodash-es/_assignMergeValue.js
/**
* This function is like `assignValue` except that it doesn't assign
* `undefined` values.
*
* @private
* @param {Object} object The object to modify.
* @param {string} key The key of the property to assign.
* @param {*} value The value to assign.
*/
function assignMergeValue(object, key, value) {
if ((value !== undefined && !lodash_es_eq(object[key], value)) ||
(value === undefined && !(key in object))) {
_baseAssignValue(object, key, value);
}
}
/* harmony default export */ var _assignMergeValue = (assignMergeValue);
;// ./node_modules/lodash-es/_createBaseFor.js
/**
* Creates a base function for methods like `_.forIn` and `_.forOwn`.
*
* @private
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {Function} Returns the new base function.
*/
function createBaseFor(fromRight) {
return function(object, iteratee, keysFunc) {
var index = -1,
iterable = Object(object),
props = keysFunc(object),
length = props.length;
while (length--) {
var key = props[fromRight ? length : ++index];
if (iteratee(iterable[key], key, iterable) === false) {
break;
}
}
return object;
};
}
/* harmony default export */ var _createBaseFor = (createBaseFor);
;// ./node_modules/lodash-es/_baseFor.js
/**
* The base implementation of `baseForOwn` which iterates over `object`
* properties returned by `keysFunc` and invokes `iteratee` for each property.
* Iteratee functions may exit iteration early by explicitly returning `false`.
*
* @private
* @param {Object} object The object to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @param {Function} keysFunc The function to get the keys of `object`.
* @returns {Object} Returns `object`.
*/
var baseFor = _createBaseFor();
/* harmony default export */ var _baseFor = (baseFor);
;// ./node_modules/lodash-es/_cloneBuffer.js
/** Detect free variable `exports`. */
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
/** Detect free variable `module`. */
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
/** Detect the popular CommonJS extension `module.exports`. */
var moduleExports = freeModule && freeModule.exports === freeExports;
/** Built-in value references. */
var _cloneBuffer_Buffer = moduleExports ? _root.Buffer : undefined,
allocUnsafe = _cloneBuffer_Buffer ? _cloneBuffer_Buffer.allocUnsafe : undefined;
/**
* Creates a clone of `buffer`.
*
* @private
* @param {Buffer} buffer The buffer to clone.
* @param {boolean} [isDeep] Specify a deep clone.
* @returns {Buffer} Returns the cloned buffer.
*/
function cloneBuffer(buffer, isDeep) {
if (isDeep) {
return buffer.slice();
}
var length = buffer.length,
result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
buffer.copy(result);
return result;
}
/* harmony default export */ var _cloneBuffer = (cloneBuffer);
;// ./node_modules/lodash-es/_Uint8Array.js
/** Built-in value references. */
var _Uint8Array_Uint8Array = _root.Uint8Array;
/* harmony default export */ var _Uint8Array = (_Uint8Array_Uint8Array);
;// ./node_modules/lodash-es/_cloneArrayBuffer.js
/**
* Creates a clone of `arrayBuffer`.
*
* @private
* @param {ArrayBuffer} arrayBuffer The array buffer to clone.
* @returns {ArrayBuffer} Returns the cloned array buffer.
*/
function cloneArrayBuffer(arrayBuffer) {
var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
new _Uint8Array(result).set(new _Uint8Array(arrayBuffer));
return result;
}
/* harmony default export */ var _cloneArrayBuffer = (cloneArrayBuffer);
;// ./node_modules/lodash-es/_cloneTypedArray.js
/**
* Creates a clone of `typedArray`.
*
* @private
* @param {Object} typedArray The typed array to clone.
* @param {boolean} [isDeep] Specify a deep clone.
* @returns {Object} Returns the cloned typed array.
*/
function cloneTypedArray(typedArray, isDeep) {
var buffer = isDeep ? _cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
}
/* harmony default export */ var _cloneTypedArray = (cloneTypedArray);
;// ./node_modules/lodash-es/_copyArray.js
/**
* Copies the values of `source` to `array`.
*
* @private
* @param {Array} source The array to copy values from.
* @param {Array} [array=[]] The array to copy values to.
* @returns {Array} Returns `array`.
*/
function copyArray(source, array) {
var index = -1,
length = source.length;
array || (array = Array(length));
while (++index < length) {
array[index] = source[index];
}
return array;
}
/* harmony default export */ var _copyArray = (copyArray);
;// ./node_modules/lodash-es/_baseCreate.js
/** Built-in value references. */
var objectCreate = Object.create;
/**
* The base implementation of `_.create` without support for assigning
* properties to the created object.
*
* @private
* @param {Object} proto The object to inherit from.
* @returns {Object} Returns the new object.
*/
var baseCreate = (function() {
function object() {}
return function(proto) {
if (!lodash_es_isObject(proto)) {
return {};
}
if (objectCreate) {
return objectCreate(proto);
}
object.prototype = proto;
var result = new object;
object.prototype = undefined;
return result;
};
}());
/* harmony default export */ var _baseCreate = (baseCreate);
;// ./node_modules/lodash-es/_overArg.js
/**
* Creates a unary function that invokes `func` with its argument transformed.
*
* @private
* @param {Function} func The function to wrap.
* @param {Function} transform The argument transform.
* @returns {Function} Returns the new function.
*/
function overArg(func, transform) {
return function(arg) {
return func(transform(arg));
};
}
/* harmony default export */ var _overArg = (overArg);
;// ./node_modules/lodash-es/_getPrototype.js
/** Built-in value references. */
var getPrototype = _overArg(Object.getPrototypeOf, Object);
/* harmony default export */ var _getPrototype = (getPrototype);
;// ./node_modules/lodash-es/_isPrototype.js
/** Used for built-in method references. */
var _isPrototype_objectProto = Object.prototype;
/**
* Checks if `value` is likely a prototype object.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
*/
function isPrototype(value) {
var Ctor = value && value.constructor,
proto = (typeof Ctor == 'function' && Ctor.prototype) || _isPrototype_objectProto;
return value === proto;
}
/* harmony default export */ var _isPrototype = (isPrototype);
;// ./node_modules/lodash-es/_initCloneObject.js
/**
* Initializes an object clone.
*
* @private
* @param {Object} object The object to clone.
* @returns {Object} Returns the initialized clone.
*/
function initCloneObject(object) {
return (typeof object.constructor == 'function' && !_isPrototype(object))
? _baseCreate(_getPrototype(object))
: {};
}
/* harmony default export */ var _initCloneObject = (initCloneObject);
;// ./node_modules/lodash-es/isObjectLike.js
/**
* Checks if `value` is object-like. A value is object-like if it's not `null`
* and has a `typeof` result of "object".
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
* @example
*
* _.isObjectLike({});
* // => true
*
* _.isObjectLike([1, 2, 3]);
* // => true
*
* _.isObjectLike(_.noop);
* // => false
*
* _.isObjectLike(null);
* // => false
*/
function isObjectLike(value) {
return value != null && typeof value == 'object';
}
/* harmony default export */ var lodash_es_isObjectLike = (isObjectLike);
;// ./node_modules/lodash-es/_baseIsArguments.js
/** `Object#toString` result references. */
var argsTag = '[object Arguments]';
/**
* The base implementation of `_.isArguments`.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an `arguments` object,
*/
function baseIsArguments(value) {
return lodash_es_isObjectLike(value) && _baseGetTag(value) == argsTag;
}
/* harmony default export */ var _baseIsArguments = (baseIsArguments);
;// ./node_modules/lodash-es/isArguments.js
/** Used for built-in method references. */
var isArguments_objectProto = Object.prototype;
/** Used to check objects for own properties. */
var isArguments_hasOwnProperty = isArguments_objectProto.hasOwnProperty;
/** Built-in value references. */
var propertyIsEnumerable = isArguments_objectProto.propertyIsEnumerable;
/**
* Checks if `value` is likely an `arguments` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an `arguments` object,
* else `false`.
* @example
*
* _.isArguments(function() { return arguments; }());
* // => true
*
* _.isArguments([1, 2, 3]);
* // => false
*/
var isArguments = _baseIsArguments(function() { return arguments; }()) ? _baseIsArguments : function(value) {
return lodash_es_isObjectLike(value) && isArguments_hasOwnProperty.call(value, 'callee') &&
!propertyIsEnumerable.call(value, 'callee');
};
/* harmony default export */ var lodash_es_isArguments = (isArguments);
;// ./node_modules/lodash-es/isArray.js
/**
* Checks if `value` is classified as an `Array` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an array, else `false`.
* @example
*
* _.isArray([1, 2, 3]);
* // => true
*
* _.isArray(document.body.children);
* // => false
*
* _.isArray('abc');
* // => false
*
* _.isArray(_.noop);
* // => false
*/
var isArray_isArray = Array.isArray;
/* harmony default export */ var lodash_es_isArray = (isArray_isArray);
;// ./node_modules/lodash-es/isLength.js
/** Used as references for various `Number` constants. */
var MAX_SAFE_INTEGER = 9007199254740991;
/**
* Checks if `value` is a valid array-like length.
*
* **Note:** This method is loosely based on
* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
* @example
*
* _.isLength(3);
* // => true
*
* _.isLength(Number.MIN_VALUE);
* // => false
*
* _.isLength(Infinity);
* // => false
*
* _.isLength('3');
* // => false
*/
function isLength(value) {
return typeof value == 'number' &&
value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
}
/* harmony default export */ var lodash_es_isLength = (isLength);
;// ./node_modules/lodash-es/isArrayLike.js
/**
* Checks if `value` is array-like. A value is considered array-like if it's
* not a function and has a `value.length` that's an integer greater than or
* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
* @example
*
* _.isArrayLike([1, 2, 3]);
* // => true
*
* _.isArrayLike(document.body.children);
* // => true
*
* _.isArrayLike('abc');
* // => true
*
* _.isArrayLike(_.noop);
* // => false
*/
function isArrayLike(value) {
return value != null && lodash_es_isLength(value.length) && !lodash_es_isFunction(value);
}
/* harmony default export */ var lodash_es_isArrayLike = (isArrayLike);
;// ./node_modules/lodash-es/isArrayLikeObject.js
/**
* This method is like `_.isArrayLike` except that it also checks if `value`
* is an object.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an array-like object,
* else `false`.
* @example
*
* _.isArrayLikeObject([1, 2, 3]);
* // => true
*
* _.isArrayLikeObject(document.body.children);
* // => true
*
* _.isArrayLikeObject('abc');
* // => false
*
* _.isArrayLikeObject(_.noop);
* // => false
*/
function isArrayLikeObject(value) {
return lodash_es_isObjectLike(value) && lodash_es_isArrayLike(value);
}
/* harmony default export */ var lodash_es_isArrayLikeObject = (isArrayLikeObject);
;// ./node_modules/lodash-es/stubFalse.js
/**
* This method returns `false`.
*
* @static
* @memberOf _
* @since 4.13.0
* @category Util
* @returns {boolean} Returns `false`.
* @example
*
* _.times(2, _.stubFalse);
* // => [false, false]
*/
function stubFalse() {
return false;
}
/* harmony default export */ var lodash_es_stubFalse = (stubFalse);
;// ./node_modules/lodash-es/isBuffer.js
/** Detect free variable `exports`. */
var isBuffer_freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
/** Detect free variable `module`. */
var isBuffer_freeModule = isBuffer_freeExports && typeof module == 'object' && module && !module.nodeType && module;
/** Detect the popular CommonJS extension `module.exports`. */
var isBuffer_moduleExports = isBuffer_freeModule && isBuffer_freeModule.exports === isBuffer_freeExports;
/** Built-in value references. */
var isBuffer_Buffer = isBuffer_moduleExports ? _root.Buffer : undefined;
/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeIsBuffer = isBuffer_Buffer ? isBuffer_Buffer.isBuffer : undefined;
/**
* Checks if `value` is a buffer.
*
* @static
* @memberOf _
* @since 4.3.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
* @example
*
* _.isBuffer(new Buffer(2));
* // => true
*
* _.isBuffer(new Uint8Array(2));
* // => false
*/
var isBuffer_isBuffer = nativeIsBuffer || lodash_es_stubFalse;
/* harmony default export */ var lodash_es_isBuffer = (isBuffer_isBuffer);
;// ./node_modules/lodash-es/isPlainObject.js
/** `Object#toString` result references. */
var objectTag = '[object Object]';
/** Used for built-in method references. */
var isPlainObject_funcProto = Function.prototype,
isPlainObject_objectProto = Object.prototype;
/** Used to resolve the decompiled source of functions. */
var isPlainObject_funcToString = isPlainObject_funcProto.toString;
/** Used to check objects for own properties. */
var isPlainObject_hasOwnProperty = isPlainObject_objectProto.hasOwnProperty;
/** Used to infer the `Object` constructor. */
var objectCtorString = isPlainObject_funcToString.call(Object);
/**
* Checks if `value` is a plain object, that is, an object created by the
* `Object` constructor or one with a `[[Prototype]]` of `null`.
*
* @static
* @memberOf _
* @since 0.8.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
* @example
*
* function Foo() {
* this.a = 1;
* }
*
* _.isPlainObject(new Foo);
* // => false
*
* _.isPlainObject([1, 2, 3]);
* // => false
*
* _.isPlainObject({ 'x': 0, 'y': 0 });
* // => true
*
* _.isPlainObject(Object.create(null));
* // => true
*/
function isPlainObject_isPlainObject(value) {
if (!lodash_es_isObjectLike(value) || _baseGetTag(value) != objectTag) {
return false;
}
var proto = _getPrototype(value);
if (proto === null) {
return true;
}
var Ctor = isPlainObject_hasOwnProperty.call(proto, 'constructor') && proto.constructor;
return typeof Ctor == 'function' && Ctor instanceof Ctor &&
isPlainObject_funcToString.call(Ctor) == objectCtorString;
}
/* harmony default export */ var lodash_es_isPlainObject = (isPlainObject_isPlainObject);
;// ./node_modules/lodash-es/_baseIsTypedArray.js
/** `Object#toString` result references. */
var _baseIsTypedArray_argsTag = '[object Arguments]',
arrayTag = '[object Array]',
boolTag = '[object Boolean]',
dateTag = '[object Date]',
errorTag = '[object Error]',
_baseIsTypedArray_funcTag = '[object Function]',
mapTag = '[object Map]',
numberTag = '[object Number]',
_baseIsTypedArray_objectTag = '[object Object]',
regexpTag = '[object RegExp]',
setTag = '[object Set]',
stringTag = '[object String]',
weakMapTag = '[object WeakMap]';
var arrayBufferTag = '[object ArrayBuffer]',
dataViewTag = '[object DataView]',
float32Tag = '[object Float32Array]',
float64Tag = '[object Float64Array]',
int8Tag = '[object Int8Array]',
int16Tag = '[object Int16Array]',
int32Tag = '[object Int32Array]',
uint8Tag = '[object Uint8Array]',
uint8ClampedTag = '[object Uint8ClampedArray]',
uint16Tag = '[object Uint16Array]',
uint32Tag = '[object Uint32Array]';
/** Used to identify `toStringTag` values of typed arrays. */
var typedArrayTags = {};
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
typedArrayTags[uint32Tag] = true;
typedArrayTags[_baseIsTypedArray_argsTag] = typedArrayTags[arrayTag] =
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
typedArrayTags[errorTag] = typedArrayTags[_baseIsTypedArray_funcTag] =
typedArrayTags[mapTag] = typedArrayTags[numberTag] =
typedArrayTags[_baseIsTypedArray_objectTag] = typedArrayTags[regexpTag] =
typedArrayTags[setTag] = typedArrayTags[stringTag] =
typedArrayTags[weakMapTag] = false;
/**
* The base implementation of `_.isTypedArray` without Node.js optimizations.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
*/
function baseIsTypedArray(value) {
return lodash_es_isObjectLike(value) &&
lodash_es_isLength(value.length) && !!typedArrayTags[_baseGetTag(value)];
}
/* harmony default export */ var _baseIsTypedArray = (baseIsTypedArray);
;// ./node_modules/lodash-es/_baseUnary.js
/**
* The base implementation of `_.unary` without support for storing metadata.
*
* @private
* @param {Function} func The function to cap arguments for.
* @returns {Function} Returns the new capped function.
*/
function baseUnary(func) {
return function(value) {
return func(value);
};
}
/* harmony default export */ var _baseUnary = (baseUnary);
;// ./node_modules/lodash-es/_nodeUtil.js
/** Detect free variable `exports`. */
var _nodeUtil_freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
/** Detect free variable `module`. */
var _nodeUtil_freeModule = _nodeUtil_freeExports && typeof module == 'object' && module && !module.nodeType && module;
/** Detect the popular CommonJS extension `module.exports`. */
var _nodeUtil_moduleExports = _nodeUtil_freeModule && _nodeUtil_freeModule.exports === _nodeUtil_freeExports;
/** Detect free variable `process` from Node.js. */
var freeProcess = _nodeUtil_moduleExports && _freeGlobal.process;
/** Used to access faster Node.js helpers. */
var nodeUtil = (function() {
try {
// Use `util.types` for Node.js 10+.
var types = _nodeUtil_freeModule && _nodeUtil_freeModule.require && _nodeUtil_freeModule.require('util').types;
if (types) {
return types;
}
// Legacy `process.binding('util')` for Node.js < 10.
return freeProcess && freeProcess.binding && freeProcess.binding('util');
} catch (e) {}
}());
/* harmony default export */ var _nodeUtil = (nodeUtil);
;// ./node_modules/lodash-es/isTypedArray.js
/* Node.js helper references. */
var nodeIsTypedArray = _nodeUtil && _nodeUtil.isTypedArray;
/**
* Checks if `value` is classified as a typed array.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
* @example
*
* _.isTypedArray(new Uint8Array);
* // => true
*
* _.isTypedArray([]);
* // => false
*/
var isTypedArray_isTypedArray = nodeIsTypedArray ? _baseUnary(nodeIsTypedArray) : _baseIsTypedArray;
/* harmony default export */ var lodash_es_isTypedArray = (isTypedArray_isTypedArray);
;// ./node_modules/lodash-es/_safeGet.js
/**
* Gets the value at `key`, unless `key` is "__proto__" or "constructor".
*
* @private
* @param {Object} object The object to query.
* @param {string} key The key of the property to get.
* @returns {*} Returns the property value.
*/
function safeGet(object, key) {
if (key === 'constructor' && typeof object[key] === 'function') {
return;
}
if (key == '__proto__') {
return;
}
return object[key];
}
/* harmony default export */ var _safeGet = (safeGet);
;// ./node_modules/lodash-es/_assignValue.js
/** Used for built-in method references. */
var _assignValue_objectProto = Object.prototype;
/** Used to check objects for own properties. */
var _assignValue_hasOwnProperty = _assignValue_objectProto.hasOwnProperty;
/**
* Assigns `value` to `key` of `object` if the existing value is not equivalent
* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* for equality comparisons.
*
* @private
* @param {Object} object The object to modify.
* @param {string} key The key of the property to assign.
* @param {*} value The value to assign.
*/
function assignValue(object, key, value) {
var objValue = object[key];
if (!(_assignValue_hasOwnProperty.call(object, key) && lodash_es_eq(objValue, value)) ||
(value === undefined && !(key in object))) {
_baseAssignValue(object, key, value);
}
}
/* harmony default export */ var _assignValue = (assignValue);
;// ./node_modules/lodash-es/_copyObject.js
/**
* Copies properties of `source` to `object`.
*
* @private
* @param {Object} source The object to copy properties from.
* @param {Array} props The property identifiers to copy.
* @param {Object} [object={}] The object to copy properties to.
* @param {Function} [customizer] The function to customize copied values.
* @returns {Object} Returns `object`.
*/
function copyObject(source, props, object, customizer) {
var isNew = !object;
object || (object = {});
var index = -1,
length = props.length;
while (++index < length) {
var key = props[index];
var newValue = customizer
? customizer(object[key], source[key], key, object, source)
: undefined;
if (newValue === undefined) {
newValue = source[key];
}
if (isNew) {
_baseAssignValue(object, key, newValue);
} else {
_assignValue(object, key, newValue);
}
}
return object;
}
/* harmony default export */ var _copyObject = (copyObject);
;// ./node_modules/lodash-es/_baseTimes.js
/**
* The base implementation of `_.times` without support for iteratee shorthands
* or max array length checks.
*
* @private
* @param {number} n The number of times to invoke `iteratee`.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns the array of results.
*/
function baseTimes(n, iteratee) {
var index = -1,
result = Array(n);
while (++index < n) {
result[index] = iteratee(index);
}
return result;
}
/* harmony default export */ var _baseTimes = (baseTimes);
;// ./node_modules/lodash-es/_isIndex.js
/** Used as references for various `Number` constants. */
var _isIndex_MAX_SAFE_INTEGER = 9007199254740991;
/** Used to detect unsigned integer values. */
var reIsUint = /^(?:0|[1-9]\d*)$/;
/**
* Checks if `value` is a valid array-like index.
*
* @private
* @param {*} value The value to check.
* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
*/
function isIndex(value, length) {
var type = typeof value;
length = length == null ? _isIndex_MAX_SAFE_INTEGER : length;
return !!length &&
(type == 'number' ||
(type != 'symbol' && reIsUint.test(value))) &&
(value > -1 && value % 1 == 0 && value < length);
}
/* harmony default export */ var _isIndex = (isIndex);
;// ./node_modules/lodash-es/_arrayLikeKeys.js
/** Used for built-in method references. */
var _arrayLikeKeys_objectProto = Object.prototype;
/** Used to check objects for own properties. */
var _arrayLikeKeys_hasOwnProperty = _arrayLikeKeys_objectProto.hasOwnProperty;
/**
* Creates an array of the enumerable property names of the array-like `value`.
*
* @private
* @param {*} value The value to query.
* @param {boolean} inherited Specify returning inherited property names.
* @returns {Array} Returns the array of property names.
*/
function arrayLikeKeys(value, inherited) {
var isArr = lodash_es_isArray(value),
isArg = !isArr && lodash_es_isArguments(value),
isBuff = !isArr && !isArg && lodash_es_isBuffer(value),
isType = !isArr && !isArg && !isBuff && lodash_es_isTypedArray(value),
skipIndexes = isArr || isArg || isBuff || isType,
result = skipIndexes ? _baseTimes(value.length, String) : [],
length = result.length;
for (var key in value) {
if ((inherited || _arrayLikeKeys_hasOwnProperty.call(value, key)) &&
!(skipIndexes && (
// Safari 9 has enumerable `arguments.length` in strict mode.
key == 'length' ||
// Node.js 0.10 has enumerable non-index properties on buffers.
(isBuff && (key == 'offset' || key == 'parent')) ||
// PhantomJS 2 has enumerable non-index properties on typed arrays.
(isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
// Skip index properties.
_isIndex(key, length)
))) {
result.push(key);
}
}
return result;
}
/* harmony default export */ var _arrayLikeKeys = (arrayLikeKeys);
;// ./node_modules/lodash-es/_nativeKeysIn.js
/**
* This function is like
* [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
* except that it includes inherited enumerable properties.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
*/
function nativeKeysIn(object) {
var result = [];
if (object != null) {
for (var key in Object(object)) {
result.push(key);
}
}
return result;
}
/* harmony default export */ var _nativeKeysIn = (nativeKeysIn);
;// ./node_modules/lodash-es/_baseKeysIn.js
/** Used for built-in method references. */
var _baseKeysIn_objectProto = Object.prototype;
/** Used to check objects for own properties. */
var _baseKeysIn_hasOwnProperty = _baseKeysIn_objectProto.hasOwnProperty;
/**
* The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
*/
function baseKeysIn(object) {
if (!lodash_es_isObject(object)) {
return _nativeKeysIn(object);
}
var isProto = _isPrototype(object),
result = [];
for (var key in object) {
if (!(key == 'constructor' && (isProto || !_baseKeysIn_hasOwnProperty.call(object, key)))) {
result.push(key);
}
}
return result;
}
/* harmony default export */ var _baseKeysIn = (baseKeysIn);
;// ./node_modules/lodash-es/keysIn.js
/**
* Creates an array of the own and inherited enumerable property names of `object`.
*
* **Note:** Non-object values are coerced to objects.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Object
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.keysIn(new Foo);
* // => ['a', 'b', 'c'] (iteration order is not guaranteed)
*/
function keysIn(object) {
return lodash_es_isArrayLike(object) ? _arrayLikeKeys(object, true) : _baseKeysIn(object);
}
/* harmony default export */ var lodash_es_keysIn = (keysIn);
;// ./node_modules/lodash-es/toPlainObject.js
/**
* Converts `value` to a plain object flattening inherited enumerable string
* keyed properties of `value` to own properties of the plain object.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Lang
* @param {*} value The value to convert.
* @returns {Object} Returns the converted plain object.
* @example
*
* function Foo() {
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.assign({ 'a': 1 }, new Foo);
* // => { 'a': 1, 'b': 2 }
*
* _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
* // => { 'a': 1, 'b': 2, 'c': 3 }
*/
function toPlainObject(value) {
return _copyObject(value, lodash_es_keysIn(value));
}
/* harmony default export */ var lodash_es_toPlainObject = (toPlainObject);
;// ./node_modules/lodash-es/_baseMergeDeep.js
/**
* A specialized version of `baseMerge` for arrays and objects which performs
* deep merges and tracks traversed objects enabling objects with circular
* references to be merged.
*
* @private
* @param {Object} object The destination object.
* @param {Object} source The source object.
* @param {string} key The key of the value to merge.
* @param {number} srcIndex The index of `source`.
* @param {Function} mergeFunc The function to merge values.
* @param {Function} [customizer] The function to customize assigned values.
* @param {Object} [stack] Tracks traversed source values and their merged
* counterparts.
*/
function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
var objValue = _safeGet(object, key),
srcValue = _safeGet(source, key),
stacked = stack.get(srcValue);
if (stacked) {
_assignMergeValue(object, key, stacked);
return;
}
var newValue = customizer
? customizer(objValue, srcValue, (key + ''), object, source, stack)
: undefined;
var isCommon = newValue === undefined;
if (isCommon) {
var isArr = lodash_es_isArray(srcValue),
isBuff = !isArr && lodash_es_isBuffer(srcValue),
isTyped = !isArr && !isBuff && lodash_es_isTypedArray(srcValue);
newValue = srcValue;
if (isArr || isBuff || isTyped) {
if (lodash_es_isArray(objValue)) {
newValue = objValue;
}
else if (lodash_es_isArrayLikeObject(objValue)) {
newValue = _copyArray(objValue);
}
else if (isBuff) {
isCommon = false;
newValue = _cloneBuffer(srcValue, true);
}
else if (isTyped) {
isCommon = false;
newValue = _cloneTypedArray(srcValue, true);
}
else {
newValue = [];
}
}
else if (lodash_es_isPlainObject(srcValue) || lodash_es_isArguments(srcValue)) {
newValue = objValue;
if (lodash_es_isArguments(objValue)) {
newValue = lodash_es_toPlainObject(objValue);
}
else if (!lodash_es_isObject(objValue) || lodash_es_isFunction(objValue)) {
newValue = _initCloneObject(srcValue);
}
}
else {
isCommon = false;
}
}
if (isCommon) {
// Recursively merge objects and arrays (susceptible to call stack limits).
stack.set(srcValue, newValue);
mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
stack['delete'](srcValue);
}
_assignMergeValue(object, key, newValue);
}
/* harmony default export */ var _baseMergeDeep = (baseMergeDeep);
;// ./node_modules/lodash-es/_baseMerge.js
/**
* The base implementation of `_.merge` without support for multiple sources.
*
* @private
* @param {Object} object The destination object.
* @param {Object} source The source object.
* @param {number} srcIndex The index of `source`.
* @param {Function} [customizer] The function to customize merged values.
* @param {Object} [stack] Tracks traversed source values and their merged
* counterparts.
*/
function baseMerge(object, source, srcIndex, customizer, stack) {
if (object === source) {
return;
}
_baseFor(source, function(srcValue, key) {
stack || (stack = new _Stack);
if (lodash_es_isObject(srcValue)) {
_baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
}
else {
var newValue = customizer
? customizer(_safeGet(object, key), srcValue, (key + ''), object, source, stack)
: undefined;
if (newValue === undefined) {
newValue = srcValue;
}
_assignMergeValue(object, key, newValue);
}
}, lodash_es_keysIn);
}
/* harmony default export */ var _baseMerge = (baseMerge);
;// ./node_modules/lodash-es/identity.js
/**
* This method returns the first argument it receives.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Util
* @param {*} value Any value.
* @returns {*} Returns `value`.
* @example
*
* var object = { 'a': 1 };
*
* console.log(_.identity(object) === object);
* // => true
*/
function identity(value) {
return value;
}
/* harmony default export */ var lodash_es_identity = (identity);
;// ./node_modules/lodash-es/_apply.js
/**
* A faster alternative to `Function#apply`, this function invokes `func`
* with the `this` binding of `thisArg` and the arguments of `args`.
*
* @private
* @param {Function} func The function to invoke.
* @param {*} thisArg The `this` binding of `func`.
* @param {Array} args The arguments to invoke `func` with.
* @returns {*} Returns the result of `func`.
*/
function _apply_apply(func, thisArg, args) {
switch (args.length) {
case 0: return func.call(thisArg);
case 1: return func.call(thisArg, args[0]);
case 2: return func.call(thisArg, args[0], args[1]);
case 3: return func.call(thisArg, args[0], args[1], args[2]);
}
return func.apply(thisArg, args);
}
/* harmony default export */ var _apply = (_apply_apply);
;// ./node_modules/lodash-es/_overRest.js
/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeMax = Math.max;
/**
* A specialized version of `baseRest` which transforms the rest array.
*
* @private
* @param {Function} func The function to apply a rest parameter to.
* @param {number} [start=func.length-1] The start position of the rest parameter.
* @param {Function} transform The rest array transform.
* @returns {Function} Returns the new function.
*/
function overRest(func, start, transform) {
start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
return function() {
var args = arguments,
index = -1,
length = nativeMax(args.length - start, 0),
array = Array(length);
while (++index < length) {
array[index] = args[start + index];
}
index = -1;
var otherArgs = Array(start + 1);
while (++index < start) {
otherArgs[index] = args[index];
}
otherArgs[start] = transform(array);
return _apply(func, this, otherArgs);
};
}
/* harmony default export */ var _overRest = (overRest);
;// ./node_modules/lodash-es/constant.js
/**
* Creates a function that returns `value`.
*
* @static
* @memberOf _
* @since 2.4.0
* @category Util
* @param {*} value The value to return from the new function.
* @returns {Function} Returns the new constant function.
* @example
*
* var objects = _.times(2, _.constant({ 'a': 1 }));
*
* console.log(objects);
* // => [{ 'a': 1 }, { 'a': 1 }]
*
* console.log(objects[0] === objects[1]);
* // => true
*/
function constant(value) {
return function() {
return value;
};
}
/* harmony default export */ var lodash_es_constant = (constant);
;// ./node_modules/lodash-es/_baseSetToString.js
/**
* The base implementation of `setToString` without support for hot loop shorting.
*
* @private
* @param {Function} func The function to modify.
* @param {Function} string The `toString` result.
* @returns {Function} Returns `func`.
*/
var baseSetToString = !_defineProperty ? lodash_es_identity : function(func, string) {
return _defineProperty(func, 'toString', {
'configurable': true,
'enumerable': false,
'value': lodash_es_constant(string),
'writable': true
});
};
/* harmony default export */ var _baseSetToString = (baseSetToString);
;// ./node_modules/lodash-es/_shortOut.js
/** Used to detect hot functions by number of calls within a span of milliseconds. */
var HOT_COUNT = 800,
HOT_SPAN = 16;
/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeNow = Date.now;
/**
* Creates a function that'll short out and invoke `identity` instead
* of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
* milliseconds.
*
* @private
* @param {Function} func The function to restrict.
* @returns {Function} Returns the new shortable function.
*/
function shortOut(func) {
var count = 0,
lastCalled = 0;
return function() {
var stamp = nativeNow(),
remaining = HOT_SPAN - (stamp - lastCalled);
lastCalled = stamp;
if (remaining > 0) {
if (++count >= HOT_COUNT) {
return arguments[0];
}
} else {
count = 0;
}
return func.apply(undefined, arguments);
};
}
/* harmony default export */ var _shortOut = (shortOut);
;// ./node_modules/lodash-es/_setToString.js
/**
* Sets the `toString` method of `func` to return `string`.
*
* @private
* @param {Function} func The function to modify.
* @param {Function} string The `toString` result.
* @returns {Function} Returns `func`.
*/
var setToString = _shortOut(_baseSetToString);
/* harmony default export */ var _setToString = (setToString);
;// ./node_modules/lodash-es/_baseRest.js
/**
* The base implementation of `_.rest` which doesn't validate or coerce arguments.
*
* @private
* @param {Function} func The function to apply a rest parameter to.
* @param {number} [start=func.length-1] The start position of the rest parameter.
* @returns {Function} Returns the new function.
*/
function baseRest(func, start) {
return _setToString(_overRest(func, start, lodash_es_identity), func + '');
}
/* harmony default export */ var _baseRest = (baseRest);
;// ./node_modules/lodash-es/_isIterateeCall.js
/**
* Checks if the given arguments are from an iteratee call.
*
* @private
* @param {*} value The potential iteratee value argument.
* @param {*} index The potential iteratee index or key argument.
* @param {*} object The potential iteratee object argument.
* @returns {boolean} Returns `true` if the arguments are from an iteratee call,
* else `false`.
*/
function isIterateeCall(value, index, object) {
if (!lodash_es_isObject(object)) {
return false;
}
var type = typeof index;
if (type == 'number'
? (lodash_es_isArrayLike(object) && _isIndex(index, object.length))
: (type == 'string' && index in object)
) {
return lodash_es_eq(object[index], value);
}
return false;
}
/* harmony default export */ var _isIterateeCall = (isIterateeCall);
;// ./node_modules/lodash-es/_createAssigner.js
/**
* Creates a function like `_.assign`.
*
* @private
* @param {Function} assigner The function to assign values.
* @returns {Function} Returns the new assigner function.
*/
function createAssigner(assigner) {
return _baseRest(function(object, sources) {
var index = -1,
length = sources.length,
customizer = length > 1 ? sources[length - 1] : undefined,
guard = length > 2 ? sources[2] : undefined;
customizer = (assigner.length > 3 && typeof customizer == 'function')
? (length--, customizer)
: undefined;
if (guard && _isIterateeCall(sources[0], sources[1], guard)) {
customizer = length < 3 ? undefined : customizer;
length = 1;
}
object = Object(object);
while (++index < length) {
var source = sources[index];
if (source) {
assigner(object, source, index, customizer);
}
}
return object;
});
}
/* harmony default export */ var _createAssigner = (createAssigner);
;// ./node_modules/lodash-es/merge.js
/**
* This method is like `_.assign` except that it recursively merges own and
* inherited enumerable string keyed properties of source objects into the
* destination object. Source properties that resolve to `undefined` are
* skipped if a destination value exists. Array and plain object properties
* are merged recursively. Other objects and value types are overridden by
* assignment. Source objects are applied from left to right. Subsequent
* sources overwrite property assignments of previous sources.
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 0.5.0
* @category Object
* @param {Object} object The destination object.
* @param {...Object} [sources] The source objects.
* @returns {Object} Returns `object`.
* @example
*
* var object = {
* 'a': [{ 'b': 2 }, { 'd': 4 }]
* };
*
* var other = {
* 'a': [{ 'c': 3 }, { 'e': 5 }]
* };
*
* _.merge(object, other);
* // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
*/
var merge_merge = _createAssigner(function(object, source, srcIndex) {
_baseMerge(object, source, srcIndex);
});
/* harmony default export */ var lodash_es_merge = (merge_merge);
;// ./node_modules/naive-ui/es/_mixins/use-theme.mjs
function createTheme(theme) {
return theme;
}
function useTheme(resolveId, mountId, style, defaultTheme, props, clsPrefixRef) {
const ssrAdapter = useSsrAdapter();
const NConfigProvider = runtime_core_esm_bundler_inject(context_configProviderInjectionKey, null);
if (style) {
const mountStyle = () => {
const clsPrefix = clsPrefixRef === null || clsPrefixRef === void 0 ? void 0 : clsPrefixRef.value;
style.mount({
id: clsPrefix === undefined ? mountId : clsPrefix + mountId,
head: true,
props: {
bPrefix: clsPrefix ? `.${clsPrefix}-` : undefined
},
anchorMetaName: cssrAnchorMetaName,
ssr: ssrAdapter,
parent: NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.styleMountTarget
});
if (!(NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.preflightStyleDisabled)) {
index_cssr.mount({
id: 'n-global',
head: true,
anchorMetaName: cssrAnchorMetaName,
ssr: ssrAdapter,
parent: NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.styleMountTarget
});
}
};
if (ssrAdapter) {
mountStyle();
} else {
onBeforeMount(mountStyle);
}
}
const mergedThemeRef = runtime_core_esm_bundler_computed(() => {
var _a;
// keep props to make theme overrideable
const {
theme: {
common: selfCommon,
self,
peers = {}
} = {},
themeOverrides: selfOverrides = {},
builtinThemeOverrides: builtinOverrides = {}
} = props;
const {
common: selfCommonOverrides,
peers: peersOverrides
} = selfOverrides;
const {
common: globalCommon = undefined,
[resolveId]: {
common: globalSelfCommon = undefined,
self: globalSelf = undefined,
peers: globalPeers = {}
} = {}
} = (NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.mergedThemeRef.value) || {};
const {
common: globalCommonOverrides = undefined,
[resolveId]: globalSelfOverrides = {}
} = (NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.mergedThemeOverridesRef.value) || {};
const {
common: globalSelfCommonOverrides,
peers: globalPeersOverrides = {}
} = globalSelfOverrides;
const mergedCommon = lodash_es_merge({}, selfCommon || globalSelfCommon || globalCommon || defaultTheme.common, globalCommonOverrides, globalSelfCommonOverrides, selfCommonOverrides);
const mergedSelf = lodash_es_merge(
// {}, executed every time, no need for empty obj
(_a = self || globalSelf || defaultTheme.self) === null || _a === void 0 ? void 0 : _a(mergedCommon), builtinOverrides, globalSelfOverrides, selfOverrides);
return {
common: mergedCommon,
self: mergedSelf,
peers: lodash_es_merge({}, defaultTheme.peers, globalPeers, peers),
peerOverrides: lodash_es_merge({}, builtinOverrides.peers, globalPeersOverrides, peersOverrides)
};
});
return mergedThemeRef;
}
useTheme.props = {
theme: Object,
themeOverrides: Object,
builtinThemeOverrides: Object
};
/**
* props.theme (Theme):
* {
* common: CommonThemeVars,
* self(): ThemeVars,
* peers: { Component: Theme }
* }
* provider.theme:
* {
* common: CommonThemeVars,
* Button: Theme
* ...
* }
* defaultTheme:
* {
* common: CommonThemeVars,
* self(): ThemeVars,
* peers: { Component: Theme }
* }
*
* props.themeOverrides (ThemeOverrides):
* {
* common: CommonThemeVars,
* peers: { Component: ThemeOverrides },
* ...ThemeVars
* }
* provider.themeOverrides:
* {
* common: CommonThemeVars,
* Component: ThemeOverrides
* ...
* }
*
* mergedTheme:
* {
* common: CommonThemeVars,
* self: ThemeVars,
* peers: { Component: Theme },
* overrides: { Component: ThemeOverrides }
* }
*/
/* harmony default export */ var use_theme = (useTheme);
;// ./node_modules/naive-ui/es/_mixins/use-form-item.mjs
const formItemInjectionKey = createInjectionKey('n-form-item');
function useFormItem(props, {
defaultSize = 'medium',
mergedSize,
mergedDisabled
} = {}) {
const NFormItem = runtime_core_esm_bundler_inject(formItemInjectionKey, null);
provide(formItemInjectionKey, null);
const mergedSizeRef = runtime_core_esm_bundler_computed(mergedSize ? () => mergedSize(NFormItem) : () => {
const {
size
} = props;
if (size) return size;
if (NFormItem) {
const {
mergedSize
} = NFormItem;
if (mergedSize.value !== undefined) {
return mergedSize.value;
}
}
return defaultSize;
});
const mergedDisabledRef = runtime_core_esm_bundler_computed(mergedDisabled ? () => mergedDisabled(NFormItem) : () => {
const {
disabled
} = props;
if (disabled !== undefined) {
return disabled;
}
if (NFormItem) {
return NFormItem.disabled.value;
}
return false;
});
const mergedStatusRef = runtime_core_esm_bundler_computed(() => {
const {
status
} = props;
if (status) return status;
return NFormItem === null || NFormItem === void 0 ? void 0 : NFormItem.mergedValidationStatus.value;
});
runtime_core_esm_bundler_onBeforeUnmount(() => {
if (NFormItem) {
NFormItem.restoreValidation();
}
});
return {
mergedSizeRef,
mergedDisabledRef,
mergedStatusRef,
nTriggerFormBlur() {
if (NFormItem) {
NFormItem.handleContentBlur();
}
},
nTriggerFormChange() {
if (NFormItem) {
NFormItem.handleContentChange();
}
},
nTriggerFormFocus() {
if (NFormItem) {
NFormItem.handleContentFocus();
}
},
nTriggerFormInput() {
if (NFormItem) {
NFormItem.handleContentInput();
}
}
};
}
;// ./node_modules/naive-ui/es/_mixins/use-config.mjs
const defaultClsPrefix = 'n';
function useConfig(props = {}, options = {
defaultBordered: true
}) {
const NConfigProvider = runtime_core_esm_bundler_inject(context_configProviderInjectionKey, null);
return {
// NConfigProvider,
inlineThemeDisabled: NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.inlineThemeDisabled,
mergedRtlRef: NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.mergedRtlRef,
mergedComponentPropsRef: NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.mergedComponentPropsRef,
mergedBreakpointsRef: NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.mergedBreakpointsRef,
mergedBorderedRef: runtime_core_esm_bundler_computed(() => {
var _a, _b;
const {
bordered
} = props;
if (bordered !== undefined) return bordered;
return (_b = (_a = NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.mergedBorderedRef.value) !== null && _a !== void 0 ? _a : options.defaultBordered) !== null && _b !== void 0 ? _b : true;
}),
mergedClsPrefixRef: NConfigProvider ? NConfigProvider.mergedClsPrefixRef : reactivity_esm_bundler_shallowRef(defaultClsPrefix),
namespaceRef: runtime_core_esm_bundler_computed(() => NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.mergedNamespaceRef.value)
};
}
function useMergedClsPrefix() {
const NConfigProvider = inject(configProviderInjectionKey, null);
return NConfigProvider ? NConfigProvider.mergedClsPrefixRef : shallowRef(defaultClsPrefix);
}
;// ./node_modules/naive-ui/es/_utils/naive/warn.mjs
const warnedMessages = new Set();
function warnOnce(location, message) {
const mergedMessage = `[naive/${location}]: ${message}`;
if (warnedMessages.has(mergedMessage)) return;
warnedMessages.add(mergedMessage);
console.error(mergedMessage);
}
function warn_warn(location, message) {
console.error(`[naive/${location}]: ${message}`);
}
function error(location, message, error) {
console.error(`[naive/${location}]: ${message}`, error);
}
function throwError(location, message) {
throw new Error(`[naive/${location}]: ${message}`);
}
;// ./node_modules/naive-ui/es/_mixins/use-css-vars-class.mjs
function useThemeClass(componentName, hashRef, cssVarsRef, props) {
if (!cssVarsRef) throwError('useThemeClass', 'cssVarsRef is not passed');
const NConfigProvider = runtime_core_esm_bundler_inject(context_configProviderInjectionKey, null);
const mergedThemeHashRef = NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.mergedThemeHashRef;
const styleMountTarget = NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.styleMountTarget;
const themeClassRef = ref('');
const ssrAdapter = useSsrAdapter();
let renderCallback;
const hashClassPrefix = `__${componentName}`;
const mountStyle = () => {
let finalThemeHash = hashClassPrefix;
const hashValue = hashRef ? hashRef.value : undefined;
const themeHash = mergedThemeHashRef === null || mergedThemeHashRef === void 0 ? void 0 : mergedThemeHashRef.value;
if (themeHash) finalThemeHash += `-${themeHash}`;
if (hashValue) finalThemeHash += `-${hashValue}`;
const {
themeOverrides,
builtinThemeOverrides
} = props;
if (themeOverrides) {
finalThemeHash += `-${hash_browser_esm(JSON.stringify(themeOverrides))}`;
}
if (builtinThemeOverrides) {
finalThemeHash += `-${hash_browser_esm(JSON.stringify(builtinThemeOverrides))}`;
}
themeClassRef.value = finalThemeHash;
renderCallback = () => {
const cssVars = cssVarsRef.value;
let style = '';
for (const key in cssVars) {
style += `${key}: ${cssVars[key]};`;
}
cssr_c(`.${finalThemeHash}`, style).mount({
id: finalThemeHash,
ssr: ssrAdapter,
parent: styleMountTarget
});
renderCallback = undefined;
};
};
watchEffect(() => {
mountStyle();
});
return {
themeClass: themeClassRef,
onRender: () => {
renderCallback === null || renderCallback === void 0 ? void 0 : renderCallback();
}
};
}
;// ./node_modules/css-render/esm/exists.js
function exists(id, ssr) {
if (id === undefined)
return false;
if (ssr) {
const { context: { ids } } = ssr;
return ids.has(id);
}
return queryElement(id) !== null;
}
;// ./node_modules/naive-ui/es/_mixins/use-rtl.mjs
function useRtl(mountId, rtlStateRef, clsPrefixRef) {
if (!rtlStateRef) return undefined;
const ssrAdapter = useSsrAdapter();
const componentRtlStateRef = runtime_core_esm_bundler_computed(() => {
const {
value: rtlState
} = rtlStateRef;
if (!rtlState) {
return undefined;
}
const componentRtlState = rtlState[mountId];
if (!componentRtlState) {
return undefined;
}
return componentRtlState;
});
const NConfigProvider = runtime_core_esm_bundler_inject(context_configProviderInjectionKey, null);
const mountStyle = () => {
watchEffect(() => {
const {
value: clsPrefix
} = clsPrefixRef;
const id = `${clsPrefix}${mountId}Rtl`;
// if it already exists, we only need to watch clsPrefix, although in most
// of time it's unnecessary... However we can at least listen less
// handlers, which is great.
if (exists(id, ssrAdapter)) return;
const {
value: componentRtlState
} = componentRtlStateRef;
if (!componentRtlState) return;
componentRtlState.style.mount({
id,
head: true,
anchorMetaName: cssrAnchorMetaName,
props: {
bPrefix: clsPrefix ? `.${clsPrefix}-` : undefined
},
ssr: ssrAdapter,
parent: NConfigProvider === null || NConfigProvider === void 0 ? void 0 : NConfigProvider.styleMountTarget
});
});
};
if (ssrAdapter) {
mountStyle();
} else {
onBeforeMount(mountStyle);
}
return componentRtlStateRef;
}
;// ./node_modules/naive-ui/es/_utils/vue/call.mjs
function call(funcs, ...args) {
if (Array.isArray(funcs)) {
funcs.forEach(func => call(func, ...args));
} else {
return funcs(...args);
}
}
;// ./node_modules/naive-ui/es/_utils/css/color-to-class.mjs
function color2Class(color) {
return color.replace(/#|\(|\)|,|\s|\./g, '_');
}
;// ./node_modules/naive-ui/es/_utils/vue/resolve-slot.mjs
function resolve_slot_ensureValidVNode(vnodes) {
return vnodes.some(child => {
if (!isVNode(child)) {
return true;
}
if (child.type === Comment) {
return false;
}
if (child.type === Fragment && !resolve_slot_ensureValidVNode(child.children)) {
return false;
}
return true;
}) ? vnodes : null;
}
/**
* We shouldn't use the following functions with slot flags `_: 1, 2, 3`
*/
function resolveSlot(slot, fallback) {
return slot && resolve_slot_ensureValidVNode(slot()) || fallback();
}
function resolveSlotWithTypedProps(slot, props, fallback) {
return slot && resolve_slot_ensureValidVNode(slot(props)) || fallback(props);
}
/**
* Resolve slot with wrapper if content exists, no fallback
*/
function resolveWrappedSlot(slot, wrapper) {
const children = slot && resolve_slot_ensureValidVNode(slot());
return wrapper(children || null);
}
/*
* Resolve slot with wrapper if content exists, no fallback
*/
function resolveWrappedSlotWithProps(slot, props, wrapper) {
const children = slot && resolve_slot_ensureValidVNode(slot(props));
return wrapper(children || null);
}
function isSlotEmpty(slot) {
return !(slot && resolve_slot_ensureValidVNode(slot()));
}
;// ./node_modules/naive-ui/es/_utils/color/index.mjs
function createHoverColor(rgb) {
return composite(rgb, [255, 255, 255, 0.16]);
}
function createPressedColor(rgb) {
return composite(rgb, [0, 0, 0, 0.12]);
}
;// ./node_modules/naive-ui/es/_utils/env/is-browser.mjs
const is_browser_isBrowser = typeof document !== 'undefined' && typeof window !== 'undefined';
;// ./node_modules/naive-ui/es/_utils/env/browser.mjs
const isChrome = is_browser_isBrowser && 'chrome' in window;
const isFirefox = is_browser_isBrowser && navigator.userAgent.includes('Firefox');
const isSafari = is_browser_isBrowser && navigator.userAgent.includes('Safari') && !isChrome;
;// ./node_modules/naive-ui/es/button-group/src/context.mjs
const buttonGroupInjectionKey = createInjectionKey('n-button-group');
;// ./node_modules/naive-ui/es/_styles/common/light.mjs
const base = {
neutralBase: '#FFF',
neutralInvertBase: '#000',
neutralTextBase: '#000',
neutralPopover: '#fff',
neutralCard: '#fff',
neutralModal: '#fff',
neutralBody: '#fff',
alpha1: '0.82',
alpha2: '0.72',
alpha3: '0.38',
alpha4: '0.24',
// disabled text, placeholder, icon
alpha5: '0.18',
// disabled placeholder
alphaClose: '0.6',
alphaDisabled: '0.5',
alphaDisabledInput: '0.02',
alphaPending: '0.05',
alphaTablePending: '0.02',
alphaPressed: '0.07',
alphaAvatar: '0.2',
alphaRail: '0.14',
alphaProgressRail: '.08',
alphaBorder: '0.12',
alphaDivider: '0.06',
alphaInput: '0',
alphaAction: '0.02',
alphaTab: '0.04',
alphaScrollbar: '0.25',
alphaScrollbarHover: '0.4',
alphaCode: '0.05',
alphaTag: '0.02',
// primary
primaryHover: '#36ad6a',
primaryDefault: '#18a058',
primaryActive: '#0c7a43',
primarySuppl: '#36ad6a',
// info
infoHover: '#4098fc',
infoDefault: '#2080f0',
infoActive: '#1060c9',
infoSuppl: '#4098fc',
// error
errorHover: '#de576d',
errorDefault: '#d03050',
errorActive: '#ab1f3f',
errorSuppl: '#de576d',
// warning
warningHover: '#fcb040',
warningDefault: '#f0a020',
warningActive: '#c97c10',
warningSuppl: '#fcb040',
// success
successHover: '#36ad6a',
successDefault: '#18a058',
successActive: '#0c7a43',
successSuppl: '#36ad6a'
};
const baseBackgroundRgb = rgba(base.neutralBase);
const baseInvertBackgroundRgb = rgba(base.neutralInvertBase);
const overlayPrefix = `rgba(${baseInvertBackgroundRgb.slice(0, 3).join(', ')}, `;
function overlay(alpha) {
return `${overlayPrefix + String(alpha)})`;
}
function neutral(alpha) {
const overlayRgba = Array.from(baseInvertBackgroundRgb);
overlayRgba[3] = Number(alpha);
return composite(baseBackgroundRgb, overlayRgba);
}
const derived = Object.assign(Object.assign({
name: 'common'
}, _common), {
baseColor: base.neutralBase,
// primary color
primaryColor: base.primaryDefault,
primaryColorHover: base.primaryHover,
primaryColorPressed: base.primaryActive,
primaryColorSuppl: base.primarySuppl,
// info color
infoColor: base.infoDefault,
infoColorHover: base.infoHover,
infoColorPressed: base.infoActive,
infoColorSuppl: base.infoSuppl,
// success color
successColor: base.successDefault,
successColorHover: base.successHover,
successColorPressed: base.successActive,
successColorSuppl: base.successSuppl,
// warning color
warningColor: base.warningDefault,
warningColorHover: base.warningHover,
warningColorPressed: base.warningActive,
warningColorSuppl: base.warningSuppl,
// error color
errorColor: base.errorDefault,
errorColorHover: base.errorHover,
errorColorPressed: base.errorActive,
errorColorSuppl: base.errorSuppl,
// text color
textColorBase: base.neutralTextBase,
textColor1: 'rgb(31, 34, 37)',
textColor2: 'rgb(51, 54, 57)',
textColor3: 'rgb(118, 124, 130)',
// textColor4: neutral(base.alpha4), // disabled, placeholder, icon
// textColor5: neutral(base.alpha5),
textColorDisabled: neutral(base.alpha4),
placeholderColor: neutral(base.alpha4),
placeholderColorDisabled: neutral(base.alpha5),
iconColor: neutral(base.alpha4),
iconColorHover: scaleColor(neutral(base.alpha4), {
lightness: 0.75
}),
iconColorPressed: scaleColor(neutral(base.alpha4), {
lightness: 0.9
}),
iconColorDisabled: neutral(base.alpha5),
opacity1: base.alpha1,
opacity2: base.alpha2,
opacity3: base.alpha3,
opacity4: base.alpha4,
opacity5: base.alpha5,
dividerColor: 'rgb(239, 239, 245)',
borderColor: 'rgb(224, 224, 230)',
// close
closeIconColor: neutral(Number(base.alphaClose)),
closeIconColorHover: neutral(Number(base.alphaClose)),
closeIconColorPressed: neutral(Number(base.alphaClose)),
closeColorHover: 'rgba(0, 0, 0, .09)',
closeColorPressed: 'rgba(0, 0, 0, .13)',
// clear
clearColor: neutral(base.alpha4),
clearColorHover: scaleColor(neutral(base.alpha4), {
lightness: 0.75
}),
clearColorPressed: scaleColor(neutral(base.alpha4), {
lightness: 0.9
}),
scrollbarColor: overlay(base.alphaScrollbar),
scrollbarColorHover: overlay(base.alphaScrollbarHover),
scrollbarWidth: '5px',
scrollbarHeight: '5px',
scrollbarBorderRadius: '5px',
progressRailColor: neutral(base.alphaProgressRail),
railColor: 'rgb(219, 219, 223)',
popoverColor: base.neutralPopover,
tableColor: base.neutralCard,
cardColor: base.neutralCard,
modalColor: base.neutralModal,
bodyColor: base.neutralBody,
tagColor: '#eee',
avatarColor: neutral(base.alphaAvatar),
invertedColor: 'rgb(0, 20, 40)',
inputColor: neutral(base.alphaInput),
codeColor: 'rgb(244, 244, 248)',
tabColor: 'rgb(247, 247, 250)',
actionColor: 'rgb(250, 250, 252)',
tableHeaderColor: 'rgb(250, 250, 252)',
hoverColor: 'rgb(243, 243, 245)',
// use color with alpha since it can be nested with header filter & sorter effect
tableColorHover: 'rgba(0, 0, 100, 0.03)',
tableColorStriped: 'rgba(0, 0, 100, 0.02)',
pressedColor: 'rgb(237, 237, 239)',
opacityDisabled: base.alphaDisabled,
inputColorDisabled: 'rgb(250, 250, 252)',
// secondary button color
// can also be used in tertiary button & quaternary button
buttonColor2: 'rgba(46, 51, 56, .05)',
buttonColor2Hover: 'rgba(46, 51, 56, .09)',
buttonColor2Pressed: 'rgba(46, 51, 56, .13)',
boxShadow1: '0 1px 2px -2px rgba(0, 0, 0, .08), 0 3px 6px 0 rgba(0, 0, 0, .06), 0 5px 12px 4px rgba(0, 0, 0, .04)',
boxShadow2: '0 3px 6px -4px rgba(0, 0, 0, .12), 0 6px 16px 0 rgba(0, 0, 0, .08), 0 9px 28px 8px rgba(0, 0, 0, .05)',
boxShadow3: '0 6px 16px -9px rgba(0, 0, 0, .08), 0 9px 28px 0 rgba(0, 0, 0, .05), 0 12px 48px 16px rgba(0, 0, 0, .03)'
});
/* harmony default export */ var light = (derived);
;// ./node_modules/naive-ui/es/button/styles/_common.mjs
/* harmony default export */ var styles_common = ({
paddingTiny: '0 6px',
paddingSmall: '0 10px',
paddingMedium: '0 14px',
paddingLarge: '0 18px',
paddingRoundTiny: '0 10px',
paddingRoundSmall: '0 14px',
paddingRoundMedium: '0 18px',
paddingRoundLarge: '0 22px',
iconMarginTiny: '6px',
iconMarginSmall: '6px',
iconMarginMedium: '6px',
iconMarginLarge: '6px',
iconSizeTiny: '14px',
iconSizeSmall: '18px',
iconSizeMedium: '18px',
iconSizeLarge: '20px',
rippleDuration: '.6s'
});
;// ./node_modules/naive-ui/es/button/styles/light.mjs
function light_self(vars) {
const {
heightTiny,
heightSmall,
heightMedium,
heightLarge,
borderRadius,
fontSizeTiny,
fontSizeSmall,
fontSizeMedium,
fontSizeLarge,
opacityDisabled,
textColor2,
textColor3,
primaryColorHover,
primaryColorPressed,
borderColor,
primaryColor,
baseColor,
infoColor,
infoColorHover,
infoColorPressed,
successColor,
successColorHover,
successColorPressed,
warningColor,
warningColorHover,
warningColorPressed,
errorColor,
errorColorHover,
errorColorPressed,
fontWeight,
buttonColor2,
buttonColor2Hover,
buttonColor2Pressed,
fontWeightStrong
} = vars;
return Object.assign(Object.assign({}, styles_common), {
heightTiny,
heightSmall,
heightMedium,
heightLarge,
borderRadiusTiny: borderRadius,
borderRadiusSmall: borderRadius,
borderRadiusMedium: borderRadius,
borderRadiusLarge: borderRadius,
fontSizeTiny,
fontSizeSmall,
fontSizeMedium,
fontSizeLarge,
opacityDisabled,
// secondary
colorOpacitySecondary: '0.16',
colorOpacitySecondaryHover: '0.22',
colorOpacitySecondaryPressed: '0.28',
colorSecondary: buttonColor2,
colorSecondaryHover: buttonColor2Hover,
colorSecondaryPressed: buttonColor2Pressed,
// tertiary
colorTertiary: buttonColor2,
colorTertiaryHover: buttonColor2Hover,
colorTertiaryPressed: buttonColor2Pressed,
// quaternary
colorQuaternary: '#0000',
colorQuaternaryHover: buttonColor2Hover,
colorQuaternaryPressed: buttonColor2Pressed,
// default type
color: '#0000',
colorHover: '#0000',
colorPressed: '#0000',
colorFocus: '#0000',
colorDisabled: '#0000',
textColor: textColor2,
textColorTertiary: textColor3,
textColorHover: primaryColorHover,
textColorPressed: primaryColorPressed,
textColorFocus: primaryColorHover,
textColorDisabled: textColor2,
textColorText: textColor2,
textColorTextHover: primaryColorHover,
textColorTextPressed: primaryColorPressed,
textColorTextFocus: primaryColorHover,
textColorTextDisabled: textColor2,
textColorGhost: textColor2,
textColorGhostHover: primaryColorHover,
textColorGhostPressed: primaryColorPressed,
textColorGhostFocus: primaryColorHover,
textColorGhostDisabled: textColor2,
border: `1px solid ${borderColor}`,
borderHover: `1px solid ${primaryColorHover}`,
borderPressed: `1px solid ${primaryColorPressed}`,
borderFocus: `1px solid ${primaryColorHover}`,
borderDisabled: `1px solid ${borderColor}`,
rippleColor: primaryColor,
// primary
colorPrimary: primaryColor,
colorHoverPrimary: primaryColorHover,
colorPressedPrimary: primaryColorPressed,
colorFocusPrimary: primaryColorHover,
colorDisabledPrimary: primaryColor,
textColorPrimary: baseColor,
textColorHoverPrimary: baseColor,
textColorPressedPrimary: baseColor,
textColorFocusPrimary: baseColor,
textColorDisabledPrimary: baseColor,
textColorTextPrimary: primaryColor,
textColorTextHoverPrimary: primaryColorHover,
textColorTextPressedPrimary: primaryColorPressed,
textColorTextFocusPrimary: primaryColorHover,
textColorTextDisabledPrimary: textColor2,
textColorGhostPrimary: primaryColor,
textColorGhostHoverPrimary: primaryColorHover,
textColorGhostPressedPrimary: primaryColorPressed,
textColorGhostFocusPrimary: primaryColorHover,
textColorGhostDisabledPrimary: primaryColor,
borderPrimary: `1px solid ${primaryColor}`,
borderHoverPrimary: `1px solid ${primaryColorHover}`,
borderPressedPrimary: `1px solid ${primaryColorPressed}`,
borderFocusPrimary: `1px solid ${primaryColorHover}`,
borderDisabledPrimary: `1px solid ${primaryColor}`,
rippleColorPrimary: primaryColor,
// info
colorInfo: infoColor,
colorHoverInfo: infoColorHover,
colorPressedInfo: infoColorPressed,
colorFocusInfo: infoColorHover,
colorDisabledInfo: infoColor,
textColorInfo: baseColor,
textColorHoverInfo: baseColor,
textColorPressedInfo: baseColor,
textColorFocusInfo: baseColor,
textColorDisabledInfo: baseColor,
textColorTextInfo: infoColor,
textColorTextHoverInfo: infoColorHover,
textColorTextPressedInfo: infoColorPressed,
textColorTextFocusInfo: infoColorHover,
textColorTextDisabledInfo: textColor2,
textColorGhostInfo: infoColor,
textColorGhostHoverInfo: infoColorHover,
textColorGhostPressedInfo: infoColorPressed,
textColorGhostFocusInfo: infoColorHover,
textColorGhostDisabledInfo: infoColor,
borderInfo: `1px solid ${infoColor}`,
borderHoverInfo: `1px solid ${infoColorHover}`,
borderPressedInfo: `1px solid ${infoColorPressed}`,
borderFocusInfo: `1px solid ${infoColorHover}`,
borderDisabledInfo: `1px solid ${infoColor}`,
rippleColorInfo: infoColor,
// success
colorSuccess: successColor,
colorHoverSuccess: successColorHover,
colorPressedSuccess: successColorPressed,
colorFocusSuccess: successColorHover,
colorDisabledSuccess: successColor,
textColorSuccess: baseColor,
textColorHoverSuccess: baseColor,
textColorPressedSuccess: baseColor,
textColorFocusSuccess: baseColor,
textColorDisabledSuccess: baseColor,
textColorTextSuccess: successColor,
textColorTextHoverSuccess: successColorHover,
textColorTextPressedSuccess: successColorPressed,
textColorTextFocusSuccess: successColorHover,
textColorTextDisabledSuccess: textColor2,
textColorGhostSuccess: successColor,
textColorGhostHoverSuccess: successColorHover,
textColorGhostPressedSuccess: successColorPressed,
textColorGhostFocusSuccess: successColorHover,
textColorGhostDisabledSuccess: successColor,
borderSuccess: `1px solid ${successColor}`,
borderHoverSuccess: `1px solid ${successColorHover}`,
borderPressedSuccess: `1px solid ${successColorPressed}`,
borderFocusSuccess: `1px solid ${successColorHover}`,
borderDisabledSuccess: `1px solid ${successColor}`,
rippleColorSuccess: successColor,
// warning
colorWarning: warningColor,
colorHoverWarning: warningColorHover,
colorPressedWarning: warningColorPressed,
colorFocusWarning: warningColorHover,
colorDisabledWarning: warningColor,
textColorWarning: baseColor,
textColorHoverWarning: baseColor,
textColorPressedWarning: baseColor,
textColorFocusWarning: baseColor,
textColorDisabledWarning: baseColor,
textColorTextWarning: warningColor,
textColorTextHoverWarning: warningColorHover,
textColorTextPressedWarning: warningColorPressed,
textColorTextFocusWarning: warningColorHover,
textColorTextDisabledWarning: textColor2,
textColorGhostWarning: warningColor,
textColorGhostHoverWarning: warningColorHover,
textColorGhostPressedWarning: warningColorPressed,
textColorGhostFocusWarning: warningColorHover,
textColorGhostDisabledWarning: warningColor,
borderWarning: `1px solid ${warningColor}`,
borderHoverWarning: `1px solid ${warningColorHover}`,
borderPressedWarning: `1px solid ${warningColorPressed}`,
borderFocusWarning: `1px solid ${warningColorHover}`,
borderDisabledWarning: `1px solid ${warningColor}`,
rippleColorWarning: warningColor,
// error
colorError: errorColor,
colorHoverError: errorColorHover,
colorPressedError: errorColorPressed,
colorFocusError: errorColorHover,
colorDisabledError: errorColor,
textColorError: baseColor,
textColorHoverError: baseColor,
textColorPressedError: baseColor,
textColorFocusError: baseColor,
textColorDisabledError: baseColor,
textColorTextError: errorColor,
textColorTextHoverError: errorColorHover,
textColorTextPressedError: errorColorPressed,
textColorTextFocusError: errorColorHover,
textColorTextDisabledError: textColor2,
textColorGhostError: errorColor,
textColorGhostHoverError: errorColorHover,
textColorGhostPressedError: errorColorPressed,
textColorGhostFocusError: errorColorHover,
textColorGhostDisabledError: errorColor,
borderError: `1px solid ${errorColor}`,
borderHoverError: `1px solid ${errorColorHover}`,
borderPressedError: `1px solid ${errorColorPressed}`,
borderFocusError: `1px solid ${errorColorHover}`,
borderDisabledError: `1px solid ${errorColor}`,
rippleColorError: errorColor,
waveOpacity: '0.6',
fontWeight,
fontWeightStrong
});
}
const buttonLight = {
name: 'Button',
common: light,
self: light_self
};
/* harmony default export */ var styles_light = (buttonLight);
;// ./node_modules/naive-ui/es/_styles/transitions/fade-in-width-expand.cssr.mjs
const {
cubicBezierEaseInOut: fade_in_width_expand_cssr_cubicBezierEaseInOut
} = _common;
function fadeInWidthExpandTransition({
duration = '.2s',
delay = '.1s'
} = {}) {
return [cssr_c('&.fade-in-width-expand-transition-leave-from, &.fade-in-width-expand-transition-enter-to', {
opacity: 1
}), cssr_c('&.fade-in-width-expand-transition-leave-to, &.fade-in-width-expand-transition-enter-from', `
opacity: 0!important;
margin-left: 0!important;
margin-right: 0!important;
`), cssr_c('&.fade-in-width-expand-transition-leave-active', `
overflow: hidden;
transition:
opacity ${duration} ${fade_in_width_expand_cssr_cubicBezierEaseInOut},
max-width ${duration} ${fade_in_width_expand_cssr_cubicBezierEaseInOut} ${delay},
margin-left ${duration} ${fade_in_width_expand_cssr_cubicBezierEaseInOut} ${delay},
margin-right ${duration} ${fade_in_width_expand_cssr_cubicBezierEaseInOut} ${delay};
`), cssr_c('&.fade-in-width-expand-transition-enter-active', `
overflow: hidden;
transition:
opacity ${duration} ${fade_in_width_expand_cssr_cubicBezierEaseInOut} ${delay},
max-width ${duration} ${fade_in_width_expand_cssr_cubicBezierEaseInOut},
margin-left ${duration} ${fade_in_width_expand_cssr_cubicBezierEaseInOut},
margin-right ${duration} ${fade_in_width_expand_cssr_cubicBezierEaseInOut};
`)];
}
;// ./node_modules/naive-ui/es/button/src/styles/index.cssr.mjs
// vars:
// --n-bezier
// --n-bezier-ease-out
// --n-ripple-duration
// --n-opacity-disabled
// --n-text-color
// --n-text-color-hover
// --n-text-color-pressed
// --n-text-color-focus
// --n-text-color-disabled
// --n-color
// --n-color-hover
// --n-color-pressed
// --n-color-focus
// --n-color-disabled
// --n-border
// --n-border-hover
// --n-border-pressed
// --n-border-focus
// --n-border-disabled
// --n-ripple-color
// --n-border-radius
// --n-height
// --n-width
// --n-font-size
// --n-padding
// --n-icon-size
// --n-icon-margin
// --n-wave-opacity
// --n-font-weight
//
// private-vars:
// --n-border-color-xxx, used for custom color
/* harmony default export */ var button_src_styles_index_cssr = (cssr_c([cB('button', `
margin: 0;
font-weight: var(--n-font-weight);
line-height: 1;
font-family: inherit;
padding: var(--n-padding);
height: var(--n-height);
font-size: var(--n-font-size);
border-radius: var(--n-border-radius);
color: var(--n-text-color);
background-color: var(--n-color);
width: var(--n-width);
white-space: nowrap;
outline: none;
position: relative;
z-index: auto;
border: none;
display: inline-flex;
flex-wrap: nowrap;
flex-shrink: 0;
align-items: center;
justify-content: center;
user-select: none;
-webkit-user-select: none;
text-align: center;
cursor: pointer;
text-decoration: none;
transition:
color .3s var(--n-bezier),
background-color .3s var(--n-bezier),
opacity .3s var(--n-bezier),
border-color .3s var(--n-bezier);
`, [cM('color', [cE('border', {
borderColor: 'var(--n-border-color)'
}), cM('disabled', [cE('border', {
borderColor: 'var(--n-border-color-disabled)'
})]), cNotM('disabled', [cssr_c('&:focus', [cE('state-border', {
borderColor: 'var(--n-border-color-focus)'
})]), cssr_c('&:hover', [cE('state-border', {
borderColor: 'var(--n-border-color-hover)'
})]), cssr_c('&:active', [cE('state-border', {
borderColor: 'var(--n-border-color-pressed)'
})]), cM('pressed', [cE('state-border', {
borderColor: 'var(--n-border-color-pressed)'
})])])]), cM('disabled', {
backgroundColor: 'var(--n-color-disabled)',
color: 'var(--n-text-color-disabled)'
}, [cE('border', {
border: 'var(--n-border-disabled)'
})]), cNotM('disabled', [cssr_c('&:focus', {
backgroundColor: 'var(--n-color-focus)',
color: 'var(--n-text-color-focus)'
}, [cE('state-border', {
border: 'var(--n-border-focus)'
})]), cssr_c('&:hover', {
backgroundColor: 'var(--n-color-hover)',
color: 'var(--n-text-color-hover)'
}, [cE('state-border', {
border: 'var(--n-border-hover)'
})]), cssr_c('&:active', {
backgroundColor: 'var(--n-color-pressed)',
color: 'var(--n-text-color-pressed)'
}, [cE('state-border', {
border: 'var(--n-border-pressed)'
})]), cM('pressed', {
backgroundColor: 'var(--n-color-pressed)',
color: 'var(--n-text-color-pressed)'
}, [cE('state-border', {
border: 'var(--n-border-pressed)'
})])]), cM('loading', 'cursor: wait;'), cB('base-wave', `
pointer-events: none;
top: 0;
right: 0;
bottom: 0;
left: 0;
animation-iteration-count: 1;
animation-duration: var(--n-ripple-duration);
animation-timing-function: var(--n-bezier-ease-out), var(--n-bezier-ease-out);
`, [cM('active', {
zIndex: 1,
animationName: 'button-wave-spread, button-wave-opacity'
})]), is_browser_isBrowser && 'MozBoxSizing' in document.createElement('div').style ? cssr_c('&::moz-focus-inner', {
border: 0
}) : null, cE('border, state-border', `
position: absolute;
left: 0;
top: 0;
right: 0;
bottom: 0;
border-radius: inherit;
transition: border-color .3s var(--n-bezier);
pointer-events: none;
`), cE('border', {
border: 'var(--n-border)'
}), cE('state-border', {
border: 'var(--n-border)',
borderColor: '#0000',
zIndex: 1
}), cE('icon', `
margin: var(--n-icon-margin);
margin-left: 0;
height: var(--n-icon-size);
width: var(--n-icon-size);
max-width: var(--n-icon-size);
font-size: var(--n-icon-size);
position: relative;
flex-shrink: 0;
`, [cB('icon-slot', `
height: var(--n-icon-size);
width: var(--n-icon-size);
position: absolute;
left: 0;
top: 50%;
transform: translateY(-50%);
display: flex;
align-items: center;
justify-content: center;
`, [iconSwitchTransition({
top: '50%',
originalTransform: 'translateY(-50%)'
})]), fadeInWidthExpandTransition()]), cE('content', `
display: flex;
align-items: center;
flex-wrap: nowrap;
min-width: 0;
`, [cssr_c('~', [cE('icon', {
margin: 'var(--n-icon-margin)',
marginRight: 0
})])]), cM('block', `
display: flex;
width: 100%;
`), cM('dashed', [cE('border, state-border', {
borderStyle: 'dashed !important'
})]), cM('disabled', {
cursor: 'not-allowed',
opacity: 'var(--n-opacity-disabled)'
})]), cssr_c('@keyframes button-wave-spread', {
from: {
boxShadow: '0 0 0.5px 0 var(--n-ripple-color)'
},
to: {
// don't use exact 5px since chrome will display the animation with glitches
boxShadow: '0 0 0.5px 4.5px var(--n-ripple-color)'
}
}), cssr_c('@keyframes button-wave-opacity', {
from: {
opacity: 'var(--n-wave-opacity)'
},
to: {
opacity: 0
}
})]));
;// ./node_modules/naive-ui/es/button/src/Button.mjs
const buttonProps = Object.assign(Object.assign({}, use_theme.props), {
color: String,
textColor: String,
text: Boolean,
block: Boolean,
loading: Boolean,
disabled: Boolean,
circle: Boolean,
size: String,
ghost: Boolean,
round: Boolean,
secondary: Boolean,
tertiary: Boolean,
quaternary: Boolean,
strong: Boolean,
focusable: {
type: Boolean,
default: true
},
keyboard: {
type: Boolean,
default: true
},
tag: {
type: String,
default: 'button'
},
type: {
type: String,
default: 'default'
},
dashed: Boolean,
renderIcon: Function,
iconPlacement: {
type: String,
default: 'left'
},
attrType: {
type: String,
default: 'button'
},
bordered: {
type: Boolean,
default: true
},
onClick: [Function, Array],
nativeFocusBehavior: {
type: Boolean,
default: !isSafari
}
});
const Button = defineComponent({
name: 'Button',
props: buttonProps,
slots: Object,
setup(props) {
if (false) {}
const selfElRef = ref(null);
const waveElRef = ref(null);
const enterPressedRef = ref(false);
const showBorderRef = use_memo(() => {
return !props.quaternary && !props.tertiary && !props.secondary && !props.text && (!props.color || props.ghost || props.dashed) && props.bordered;
});
const NButtonGroup = runtime_core_esm_bundler_inject(buttonGroupInjectionKey, {});
const {
mergedSizeRef
} = useFormItem({}, {
defaultSize: 'medium',
mergedSize: NFormItem => {
const {
size
} = props;
if (size) return size;
const {
size: buttonGroupSize
} = NButtonGroup;
if (buttonGroupSize) return buttonGroupSize;
const {
mergedSize: formItemSize
} = NFormItem || {};
if (formItemSize) {
return formItemSize.value;
}
return 'medium';
}
});
const mergedFocusableRef = runtime_core_esm_bundler_computed(() => {
return props.focusable && !props.disabled;
});
const handleMousedown = e => {
var _a;
if (!mergedFocusableRef.value) {
e.preventDefault();
}
if (props.nativeFocusBehavior) {
return;
}
e.preventDefault();
// normally this won't be called if disabled (when tag is button)
// if not, we try to make it behave like a button
if (props.disabled) {
return;
}
if (mergedFocusableRef.value) {
(_a = selfElRef.value) === null || _a === void 0 ? void 0 : _a.focus({
preventScroll: true
});
}
};
const handleClick = e => {
var _a;
if (!props.disabled && !props.loading) {
const {
onClick
} = props;
if (onClick) call(onClick, e);
if (!props.text) {
(_a = waveElRef.value) === null || _a === void 0 ? void 0 : _a.play();
}
}
};
const handleKeyup = e => {
switch (e.key) {
case 'Enter':
if (!props.keyboard) {
return;
}
enterPressedRef.value = false;
}
};
const handleKeydown = e => {
switch (e.key) {
case 'Enter':
if (!props.keyboard || props.loading) {
e.preventDefault();
return;
}
enterPressedRef.value = true;
}
};
const handleBlur = () => {
enterPressedRef.value = false;
};
const {
inlineThemeDisabled,
mergedClsPrefixRef,
mergedRtlRef
} = useConfig(props);
const themeRef = use_theme('Button', '-button', button_src_styles_index_cssr, styles_light, props, mergedClsPrefixRef);
const rtlEnabledRef = useRtl('Button', mergedRtlRef, mergedClsPrefixRef);
const cssVarsRef = runtime_core_esm_bundler_computed(() => {
const theme = themeRef.value;
const {
common: {
cubicBezierEaseInOut,
cubicBezierEaseOut
},
self
} = theme;
const {
rippleDuration,
opacityDisabled,
fontWeight,
fontWeightStrong
} = self;
const size = mergedSizeRef.value;
const {
dashed,
type,
ghost,
text,
color,
round,
circle,
textColor,
secondary,
tertiary,
quaternary,
strong
} = props;
// font
const fontProps = {
'--n-font-weight': strong ? fontWeightStrong : fontWeight
};
// color
let colorProps = {
'--n-color': 'initial',
'--n-color-hover': 'initial',
'--n-color-pressed': 'initial',
'--n-color-focus': 'initial',
'--n-color-disabled': 'initial',
'--n-ripple-color': 'initial',
'--n-text-color': 'initial',
'--n-text-color-hover': 'initial',
'--n-text-color-pressed': 'initial',
'--n-text-color-focus': 'initial',
'--n-text-color-disabled': 'initial'
};
const typeIsTertiary = type === 'tertiary';
const typeIsDefault = type === 'default';
const mergedType = typeIsTertiary ? 'default' : type;
if (text) {
const propTextColor = textColor || color;
const mergedTextColor = propTextColor || self[createKey('textColorText', mergedType)];
colorProps = {
'--n-color': '#0000',
'--n-color-hover': '#0000',
'--n-color-pressed': '#0000',
'--n-color-focus': '#0000',
'--n-color-disabled': '#0000',
'--n-ripple-color': '#0000',
'--n-text-color': mergedTextColor,
'--n-text-color-hover': propTextColor ? createHoverColor(propTextColor) : self[createKey('textColorTextHover', mergedType)],
'--n-text-color-pressed': propTextColor ? createPressedColor(propTextColor) : self[createKey('textColorTextPressed', mergedType)],
'--n-text-color-focus': propTextColor ? createHoverColor(propTextColor) : self[createKey('textColorTextHover', mergedType)],
'--n-text-color-disabled': propTextColor || self[createKey('textColorTextDisabled', mergedType)]
};
} else if (ghost || dashed) {
const mergedTextColor = textColor || color;
colorProps = {
'--n-color': '#0000',
'--n-color-hover': '#0000',
'--n-color-pressed': '#0000',
'--n-color-focus': '#0000',
'--n-color-disabled': '#0000',
'--n-ripple-color': color || self[createKey('rippleColor', mergedType)],
'--n-text-color': mergedTextColor || self[createKey('textColorGhost', mergedType)],
'--n-text-color-hover': mergedTextColor ? createHoverColor(mergedTextColor) : self[createKey('textColorGhostHover', mergedType)],
'--n-text-color-pressed': mergedTextColor ? createPressedColor(mergedTextColor) : self[createKey('textColorGhostPressed', mergedType)],
'--n-text-color-focus': mergedTextColor ? createHoverColor(mergedTextColor) : self[createKey('textColorGhostHover', mergedType)],
'--n-text-color-disabled': mergedTextColor || self[createKey('textColorGhostDisabled', mergedType)]
};
} else if (secondary) {
const typeTextColor = typeIsDefault ? self.textColor : typeIsTertiary ? self.textColorTertiary : self[createKey('color', mergedType)];
const mergedTextColor = color || typeTextColor;
const isColoredType = type !== 'default' && type !== 'tertiary';
colorProps = {
'--n-color': isColoredType ? changeColor(mergedTextColor, {
alpha: Number(self.colorOpacitySecondary)
}) : self.colorSecondary,
'--n-color-hover': isColoredType ? changeColor(mergedTextColor, {
alpha: Number(self.colorOpacitySecondaryHover)
}) : self.colorSecondaryHover,
'--n-color-pressed': isColoredType ? changeColor(mergedTextColor, {
alpha: Number(self.colorOpacitySecondaryPressed)
}) : self.colorSecondaryPressed,
'--n-color-focus': isColoredType ? changeColor(mergedTextColor, {
alpha: Number(self.colorOpacitySecondaryHover)
}) : self.colorSecondaryHover,
'--n-color-disabled': self.colorSecondary,
'--n-ripple-color': '#0000',
'--n-text-color': mergedTextColor,
'--n-text-color-hover': mergedTextColor,
'--n-text-color-pressed': mergedTextColor,
'--n-text-color-focus': mergedTextColor,
'--n-text-color-disabled': mergedTextColor
};
} else if (tertiary || quaternary) {
const typeColor = typeIsDefault ? self.textColor : typeIsTertiary ? self.textColorTertiary : self[createKey('color', mergedType)];
const mergedColor = color || typeColor;
if (tertiary) {
colorProps['--n-color'] = self.colorTertiary;
colorProps['--n-color-hover'] = self.colorTertiaryHover;
colorProps['--n-color-pressed'] = self.colorTertiaryPressed;
colorProps['--n-color-focus'] = self.colorSecondaryHover;
colorProps['--n-color-disabled'] = self.colorTertiary;
} else {
colorProps['--n-color'] = self.colorQuaternary;
colorProps['--n-color-hover'] = self.colorQuaternaryHover;
colorProps['--n-color-pressed'] = self.colorQuaternaryPressed;
colorProps['--n-color-focus'] = self.colorQuaternaryHover;
colorProps['--n-color-disabled'] = self.colorQuaternary;
}
colorProps['--n-ripple-color'] = '#0000';
colorProps['--n-text-color'] = mergedColor;
colorProps['--n-text-color-hover'] = mergedColor;
colorProps['--n-text-color-pressed'] = mergedColor;
colorProps['--n-text-color-focus'] = mergedColor;
colorProps['--n-text-color-disabled'] = mergedColor;
} else {
colorProps = {
'--n-color': color || self[createKey('color', mergedType)],
'--n-color-hover': color ? createHoverColor(color) : self[createKey('colorHover', mergedType)],
'--n-color-pressed': color ? createPressedColor(color) : self[createKey('colorPressed', mergedType)],
'--n-color-focus': color ? createHoverColor(color) : self[createKey('colorFocus', mergedType)],
'--n-color-disabled': color || self[createKey('colorDisabled', mergedType)],
'--n-ripple-color': color || self[createKey('rippleColor', mergedType)],
'--n-text-color': textColor || (color ? self.textColorPrimary : typeIsTertiary ? self.textColorTertiary : self[createKey('textColor', mergedType)]),
'--n-text-color-hover': textColor || (color ? self.textColorHoverPrimary : self[createKey('textColorHover', mergedType)]),
'--n-text-color-pressed': textColor || (color ? self.textColorPressedPrimary : self[createKey('textColorPressed', mergedType)]),
'--n-text-color-focus': textColor || (color ? self.textColorFocusPrimary : self[createKey('textColorFocus', mergedType)]),
'--n-text-color-disabled': textColor || (color ? self.textColorDisabledPrimary : self[createKey('textColorDisabled', mergedType)])
};
}
// border
let borderProps = {
'--n-border': 'initial',
'--n-border-hover': 'initial',
'--n-border-pressed': 'initial',
'--n-border-focus': 'initial',
'--n-border-disabled': 'initial'
};
if (text) {
borderProps = {
'--n-border': 'none',
'--n-border-hover': 'none',
'--n-border-pressed': 'none',
'--n-border-focus': 'none',
'--n-border-disabled': 'none'
};
} else {
borderProps = {
'--n-border': self[createKey('border', mergedType)],
'--n-border-hover': self[createKey('borderHover', mergedType)],
'--n-border-pressed': self[createKey('borderPressed', mergedType)],
'--n-border-focus': self[createKey('borderFocus', mergedType)],
'--n-border-disabled': self[createKey('borderDisabled', mergedType)]
};
}
// size
const {
[createKey('height', size)]: height,
[createKey('fontSize', size)]: fontSize,
[createKey('padding', size)]: padding,
[createKey('paddingRound', size)]: paddingRound,
[createKey('iconSize', size)]: iconSize,
[createKey('borderRadius', size)]: borderRadius,
[createKey('iconMargin', size)]: iconMargin,
waveOpacity
} = self;
const sizeProps = {
'--n-width': circle && !text ? height : 'initial',
'--n-height': text ? 'initial' : height,
'--n-font-size': fontSize,
'--n-padding': circle ? 'initial' : text ? 'initial' : round ? paddingRound : padding,
'--n-icon-size': iconSize,
'--n-icon-margin': iconMargin,
'--n-border-radius': text ? 'initial' : circle || round ? height : borderRadius
};
return Object.assign(Object.assign(Object.assign(Object.assign({
'--n-bezier': cubicBezierEaseInOut,
'--n-bezier-ease-out': cubicBezierEaseOut,
'--n-ripple-duration': rippleDuration,
'--n-opacity-disabled': opacityDisabled,
'--n-wave-opacity': waveOpacity
}, fontProps), colorProps), borderProps), sizeProps);
});
const themeClassHandle = inlineThemeDisabled ? useThemeClass('button', runtime_core_esm_bundler_computed(() => {
let hash = '';
const {
dashed,
type,
ghost,
text,
color,
round,
circle,
textColor,
secondary,
tertiary,
quaternary,
strong
} = props;
if (dashed) hash += 'a';
if (ghost) hash += 'b';
if (text) hash += 'c';
if (round) hash += 'd';
if (circle) hash += 'e';
if (secondary) hash += 'f';
if (tertiary) hash += 'g';
if (quaternary) hash += 'h';
if (strong) hash += 'i';
if (color) hash += `j${color2Class(color)}`;
if (textColor) hash += `k${color2Class(textColor)}`;
const {
value: size
} = mergedSizeRef;
hash += `l${size[0]}`;
hash += `m${type[0]}`;
return hash;
}), cssVarsRef, props) : undefined;
return {
selfElRef,
waveElRef,
mergedClsPrefix: mergedClsPrefixRef,
mergedFocusable: mergedFocusableRef,
mergedSize: mergedSizeRef,
showBorder: showBorderRef,
enterPressed: enterPressedRef,
rtlEnabled: rtlEnabledRef,
handleMousedown,
handleKeydown,
handleBlur,
handleKeyup,
handleClick,
customColorCssVars: runtime_core_esm_bundler_computed(() => {
const {
color
} = props;
if (!color) return null;
const hoverColor = createHoverColor(color);
return {
'--n-border-color': color,
'--n-border-color-hover': hoverColor,
'--n-border-color-pressed': createPressedColor(color),
'--n-border-color-focus': hoverColor,
'--n-border-color-disabled': color
};
}),
cssVars: inlineThemeDisabled ? undefined : cssVarsRef,
themeClass: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass,
onRender: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender
};
},
render() {
const {
mergedClsPrefix,
tag: Component,
onRender
} = this;
onRender === null || onRender === void 0 ? void 0 : onRender();
const children = resolveWrappedSlot(this.$slots.default, children => children && h("span", {
class: `${mergedClsPrefix}-button__content`
}, children));
return h(Component, {
ref: "selfElRef",
class: [this.themeClass, `${mergedClsPrefix}-button`, `${mergedClsPrefix}-button--${this.type}-type`, `${mergedClsPrefix}-button--${this.mergedSize}-type`, this.rtlEnabled && `${mergedClsPrefix}-button--rtl`, this.disabled && `${mergedClsPrefix}-button--disabled`, this.block && `${mergedClsPrefix}-button--block`, this.enterPressed && `${mergedClsPrefix}-button--pressed`, !this.text && this.dashed && `${mergedClsPrefix}-button--dashed`, this.color && `${mergedClsPrefix}-button--color`, this.secondary && `${mergedClsPrefix}-button--secondary`, this.loading && `${mergedClsPrefix}-button--loading`, this.ghost && `${mergedClsPrefix}-button--ghost` // required for button group border collapse
],
tabindex: this.mergedFocusable ? 0 : -1,
type: this.attrType,
style: this.cssVars,
disabled: this.disabled,
onClick: this.handleClick,
onBlur: this.handleBlur,
onMousedown: this.handleMousedown,
onKeyup: this.handleKeyup,
onKeydown: this.handleKeydown
}, this.iconPlacement === 'right' && children, h(FadeInExpandTransition, {
width: true
}, {
default: () => resolveWrappedSlot(this.$slots.icon, children => (this.loading || this.renderIcon || children) && h("span", {
class: `${mergedClsPrefix}-button__icon`,
style: {
margin: isSlotEmpty(this.$slots.default) ? '0' : ''
}
}, h(IconSwitchTransition, null, {
default: () => this.loading ? h(Loading, {
clsPrefix: mergedClsPrefix,
key: "loading",
class: `${mergedClsPrefix}-icon-slot`,
strokeWidth: 20
}) : h("div", {
key: "icon",
class: `${mergedClsPrefix}-icon-slot`,
role: "none"
}, this.renderIcon ? this.renderIcon() : children)
})))
}), this.iconPlacement === 'left' && children, !this.text ? h(Wave, {
ref: "waveElRef",
clsPrefix: mergedClsPrefix
}) : null, this.showBorder ? h("div", {
"aria-hidden": true,
class: `${mergedClsPrefix}-button__border`,
style: this.customColorCssVars
}) : null, this.showBorder ? h("div", {
"aria-hidden": true,
class: `${mergedClsPrefix}-button__state-border`,
style: this.customColorCssVars
}) : null);
}
});
/* harmony default export */ var src_Button = (Button);
// XButton is for tsx type checking
// It's not compatible with render function `h`
// Currently we don't expose it as public
// If there's any issue about this, we may expose it
// Since most people use template, the type checking phase doesn't work as tsx
const XButton = Button;
// Also, we may make XButton a generic type which support `tag` prop
// but currently vue doesn't export IntrinsicElementAttributes from runtime-dom
// so we can't easily make an attr map by hand
// just leave it for later
;// ./node_modules/seemly/es/css/index.js
function depx(value) {
if (typeof value === 'string') {
if (value.endsWith('px')) {
return Number(value.slice(0, value.length - 2));
}
return Number(value);
}
return value;
}
function pxfy(value) {
if (value === undefined || value === null)
return undefined;
if (typeof value === 'number')
return `${value}px`;
if (value.endsWith('px'))
return value;
return `${value}px`;
}
function getMargin(value, position) {
const parts = value.trim().split(/\s+/g);
const margin = {
top: parts[0]
};
switch (parts.length) {
case 1:
margin.right = parts[0];
margin.bottom = parts[0];
margin.left = parts[0];
break;
case 2:
margin.right = parts[1];
margin.left = parts[1];
margin.bottom = parts[0];
break;
case 3:
margin.right = parts[1];
margin.bottom = parts[2];
margin.left = parts[1];
break;
case 4:
margin.right = parts[1];
margin.bottom = parts[2];
margin.left = parts[3];
break;
default:
throw new Error('[seemly/getMargin]:' + value + ' is not a valid value.');
}
if (position === undefined)
return margin;
return margin[position];
}
function getGap(value, orient) {
const [rowGap, colGap] = value.split(' ');
if (!orient)
return {
row: rowGap,
col: colGap || rowGap
};
return orient === 'row' ? rowGap : colGap;
}
;// ./node_modules/naive-ui/es/_utils/vue/flatten.mjs
// o(n) flatten
function flatten_flatten(vNodes, filterCommentNode = true, result = []) {
vNodes.forEach(vNode => {
if (vNode === null) return;
if (typeof vNode !== 'object') {
if (typeof vNode === 'string' || typeof vNode === 'number') {
result.push(createTextVNode(String(vNode)));
}
return;
}
if (Array.isArray(vNode)) {
flatten_flatten(vNode, filterCommentNode, result);
return;
}
if (vNode.type === Fragment) {
if (vNode.children === null) return;
if (Array.isArray(vNode.children)) {
flatten_flatten(vNode.children, filterCommentNode, result);
}
// rawSlot
} else {
if (vNode.type === Comment && filterCommentNode) return;
result.push(vNode);
}
});
return result;
}
;// ./node_modules/naive-ui/es/_utils/vue/get-slot.mjs
function getSlot(instance, slotName = 'default', fallback = []) {
const slots = instance.$slots;
const slot = slots[slotName];
if (slot === undefined) return fallback;
return slot();
}
;// ./node_modules/naive-ui/es/space/styles/_common.mjs
/* harmony default export */ var space_styles_common = ({
gapSmall: '4px 8px',
gapMedium: '8px 12px',
gapLarge: '12px 16px'
});
;// ./node_modules/naive-ui/es/space/styles/light.mjs
function styles_light_self() {
return space_styles_common;
}
const spaceLight = {
name: 'Space',
self: styles_light_self
};
/* harmony default export */ var space_styles_light = (spaceLight);
;// ./node_modules/naive-ui/es/space/src/utils.mjs
let supportFlexGap;
function ensureSupportFlexGap() {
if (!is_browser_isBrowser) return true;
if (supportFlexGap === undefined) {
// create flex container with row-gap set
const flex = document.createElement('div');
flex.style.display = 'flex';
flex.style.flexDirection = 'column';
flex.style.rowGap = '1px';
// create two, elements inside it
flex.appendChild(document.createElement('div'));
flex.appendChild(document.createElement('div'));
// append to the DOM (needed to obtain scrollHeight)
document.body.appendChild(flex);
const isSupported = flex.scrollHeight === 1; // flex container should be 1px high from the row-gap
document.body.removeChild(flex);
return supportFlexGap = isSupported;
}
return supportFlexGap;
}
;// ./node_modules/naive-ui/es/space/src/Space.mjs
const spaceProps = Object.assign(Object.assign({}, use_theme.props), {
align: String,
justify: {
type: String,
default: 'start'
},
inline: Boolean,
vertical: Boolean,
reverse: Boolean,
size: {
type: [String, Number, Array],
default: 'medium'
},
wrapItem: {
type: Boolean,
default: true
},
itemClass: String,
itemStyle: [String, Object],
wrap: {
type: Boolean,
default: true
},
// internal
internalUseGap: {
type: Boolean,
default: undefined
}
});
/* harmony default export */ var Space = (defineComponent({
name: 'Space',
props: spaceProps,
setup(props) {
const {
mergedClsPrefixRef,
mergedRtlRef
} = useConfig(props);
const themeRef = use_theme('Space', '-space', undefined, space_styles_light, props, mergedClsPrefixRef);
const rtlEnabledRef = useRtl('Space', mergedRtlRef, mergedClsPrefixRef);
return {
useGap: ensureSupportFlexGap(),
rtlEnabled: rtlEnabledRef,
mergedClsPrefix: mergedClsPrefixRef,
margin: runtime_core_esm_bundler_computed(() => {
const {
size
} = props;
if (Array.isArray(size)) {
return {
horizontal: size[0],
vertical: size[1]
};
}
if (typeof size === 'number') {
return {
horizontal: size,
vertical: size
};
}
const {
self: {
[createKey('gap', size)]: gap
}
} = themeRef.value;
const {
row,
col
} = getGap(gap);
return {
horizontal: depx(col),
vertical: depx(row)
};
})
};
},
render() {
const {
vertical,
reverse,
align,
inline,
justify,
itemClass,
itemStyle,
margin,
wrap,
mergedClsPrefix,
rtlEnabled,
useGap,
wrapItem,
internalUseGap
} = this;
const children = flatten_flatten(getSlot(this), false);
if (!children.length) return null;
const horizontalMargin = `${margin.horizontal}px`;
const semiHorizontalMargin = `${margin.horizontal / 2}px`;
const verticalMargin = `${margin.vertical}px`;
const semiVerticalMargin = `${margin.vertical / 2}px`;
const lastIndex = children.length - 1;
const isJustifySpace = justify.startsWith('space-');
return h("div", {
role: "none",
class: [`${mergedClsPrefix}-space`, rtlEnabled && `${mergedClsPrefix}-space--rtl`],
style: {
display: inline ? 'inline-flex' : 'flex',
flexDirection: (() => {
if (vertical && !reverse) return 'column';
if (vertical && reverse) return 'column-reverse';
if (!vertical && reverse) return 'row-reverse';
/** (!vertical && !reverse) */else return 'row';
})(),
justifyContent: ['start', 'end'].includes(justify) ? `flex-${justify}` : justify,
flexWrap: !wrap || vertical ? 'nowrap' : 'wrap',
marginTop: useGap || vertical ? '' : `-${semiVerticalMargin}`,
marginBottom: useGap || vertical ? '' : `-${semiVerticalMargin}`,
alignItems: align,
gap: useGap ? `${margin.vertical}px ${margin.horizontal}px` : ''
}
}, !wrapItem && (useGap || internalUseGap) ? children : children.map((child, index) => child.type === Comment ? child : h("div", {
role: "none",
class: itemClass,
style: [itemStyle, {
maxWidth: '100%'
}, useGap ? '' : vertical ? {
marginBottom: index !== lastIndex ? verticalMargin : ''
} : rtlEnabled ? {
marginLeft: isJustifySpace ? justify === 'space-between' && index === lastIndex ? '' : semiHorizontalMargin : index !== lastIndex ? horizontalMargin : '',
marginRight: isJustifySpace ? justify === 'space-between' && index === 0 ? '' : semiHorizontalMargin : '',
paddingTop: semiVerticalMargin,
paddingBottom: semiVerticalMargin
} : {
marginRight: isJustifySpace ? justify === 'space-between' && index === lastIndex ? '' : semiHorizontalMargin : index !== lastIndex ? horizontalMargin : '',
marginLeft: isJustifySpace ? justify === 'space-between' && index === 0 ? '' : semiHorizontalMargin : '',
paddingTop: semiVerticalMargin,
paddingBottom: semiVerticalMargin
}]
}, child)));
}
}));
;// ./node_modules/vdirs/es/utils.js
const utils_warnedMessages = new Set();
function utils_warnOnce(location, message) {
const mergedMessage = `[vdirs/${location}]: ${message}`;
if (utils_warnedMessages.has(mergedMessage))
return;
utils_warnedMessages.add(mergedMessage);
}
function utils_warn(location, message) {
console.error(`[vdirs/${location}]: ${message}`);
}
;// ./node_modules/vdirs/es/zindexable/z-index-manager.js
class ZIndexManager {
constructor() {
this.elementZIndex = new Map();
this.nextZIndex = 2000;
}
get elementCount() {
return this.elementZIndex.size;
}
ensureZIndex(el, zIndex) {
const { elementZIndex } = this;
if (zIndex !== undefined) {
el.style.zIndex = `${zIndex}`;
elementZIndex.delete(el);
return;
}
const { nextZIndex } = this;
if (elementZIndex.has(el)) {
const currentZIndex = elementZIndex.get(el);
if (currentZIndex + 1 === this.nextZIndex)
return;
}
el.style.zIndex = `${nextZIndex}`;
elementZIndex.set(el, nextZIndex);
this.nextZIndex = nextZIndex + 1;
this.squashState();
}
unregister(el, zIndex) {
const { elementZIndex } = this;
if (elementZIndex.has(el)) {
elementZIndex.delete(el);
}
else if (zIndex === undefined) {
utils_warn('z-index-manager/unregister-element', 'Element not found when unregistering.');
}
this.squashState();
}
squashState() {
const { elementCount } = this;
if (!elementCount) {
this.nextZIndex = 2000;
}
if (this.nextZIndex - elementCount > 2500)
this.rearrange();
}
rearrange() {
const elementZIndexPair = Array.from(this.elementZIndex.entries());
elementZIndexPair.sort((pair1, pair2) => {
return pair1[1] - pair2[1];
});
this.nextZIndex = 2000;
elementZIndexPair.forEach((pair) => {
const el = pair[0];
const zIndex = this.nextZIndex++;
if (`${zIndex}` !== el.style.zIndex)
el.style.zIndex = `${zIndex}`;
});
}
}
/* harmony default export */ var z_index_manager = (new ZIndexManager());
;// ./node_modules/vdirs/es/zindexable/index.js
const ctx = '@@ziContext';
// We don't expect manually bound zindex should be changed
const zindexable = {
mounted(el, bindings) {
const { value = {} } = bindings;
const { zIndex, enabled } = value;
el[ctx] = {
enabled: !!enabled,
initialized: false
};
if (enabled) {
z_index_manager.ensureZIndex(el, zIndex);
el[ctx].initialized = true;
}
},
updated(el, bindings) {
const { value = {} } = bindings;
const { zIndex, enabled } = value;
const cachedEnabled = el[ctx].enabled;
if (enabled && !cachedEnabled) {
z_index_manager.ensureZIndex(el, zIndex);
el[ctx].initialized = true;
}
el[ctx].enabled = !!enabled;
},
unmounted(el, bindings) {
if (!el[ctx].initialized)
return;
const { value = {} } = bindings;
const { zIndex } = value;
z_index_manager.unregister(el, zIndex);
}
};
/* harmony default export */ var es_zindexable = (zindexable);
;// ./node_modules/vooks/es/use-merged-state.js
function useMergedState(controlledStateRef, uncontrolledStateRef) {
runtime_core_esm_bundler_watch(controlledStateRef, value => {
if (value !== undefined) {
uncontrolledStateRef.value = value;
}
});
return runtime_core_esm_bundler_computed(() => {
if (controlledStateRef.value === undefined) {
return uncontrolledStateRef.value;
}
return controlledStateRef.value;
});
}
;// ./node_modules/vooks/es/use-compitable.js
function useCompitable(reactive, keys) {
// @ts-expect-error
return runtime_core_esm_bundler_computed(() => {
for (const key of keys) {
if (reactive[key] !== undefined)
return reactive[key];
}
return reactive[keys[keys.length - 1]];
});
}
;// ./node_modules/seemly/es/animation/next-frame-once.js
let onceCbs = [];
const paramsMap = new WeakMap();
function flushOnceCallbacks() {
onceCbs.forEach((cb) => cb(...paramsMap.get(cb)));
onceCbs = [];
}
function beforeNextFrameOnce(cb, ...params) {
paramsMap.set(cb, params);
if (onceCbs.includes(cb))
return;
onceCbs.push(cb) === 1 && requestAnimationFrame(flushOnceCallbacks);
}
;// ./node_modules/evtd/es/utils.js
function getEventTarget(e) {
const path = e.composedPath();
return path[0];
}
;// ./node_modules/evtd/es/traps.js
const traps = {
mousemoveoutside: new WeakMap(),
clickoutside: new WeakMap()
};
function createTrapHandler(name, el, originalHandler) {
if (name === 'mousemoveoutside') {
const moveHandler = (e) => {
if (el.contains(getEventTarget(e)))
return;
originalHandler(e);
};
return {
mousemove: moveHandler,
touchstart: moveHandler
};
}
else if (name === 'clickoutside') {
let mouseDownOutside = false;
const downHandler = (e) => {
mouseDownOutside = !el.contains(getEventTarget(e));
};
const upHanlder = (e) => {
if (!mouseDownOutside)
return;
if (el.contains(getEventTarget(e)))
return;
originalHandler(e);
};
return {
mousedown: downHandler,
mouseup: upHanlder,
touchstart: downHandler,
touchend: upHanlder
};
}
console.error(
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
`[evtd/create-trap-handler]: name \`${name}\` is invalid. This could be a bug of evtd.`);
return {};
}
function ensureTrapHandlers(name, el, handler) {
const handlers = traps[name];
let elHandlers = handlers.get(el);
if (elHandlers === undefined) {
handlers.set(el, (elHandlers = new WeakMap()));
}
let trapHandler = elHandlers.get(handler);
if (trapHandler === undefined) {
elHandlers.set(handler, (trapHandler = createTrapHandler(name, el, handler)));
}
return trapHandler;
}
function trapOn(name, el, handler, options) {
if (name === 'mousemoveoutside' || name === 'clickoutside') {
const trapHandlers = ensureTrapHandlers(name, el, handler);
Object.keys(trapHandlers).forEach((key) => {
on(key, document, trapHandlers[key], options);
});
return true;
}
return false;
}
function trapOff(name, el, handler, options) {
if (name === 'mousemoveoutside' || name === 'clickoutside') {
const trapHandlers = ensureTrapHandlers(name, el, handler);
Object.keys(trapHandlers).forEach((key) => {
off(key, document, trapHandlers[key], options);
});
return true;
}
return false;
}
;// ./node_modules/evtd/es/delegate.js
// currently `once` and `passive` is not supported
function createDelegate() {
if (typeof window === 'undefined') {
return {
on: () => { },
off: () => { }
};
}
const propagationStopped = new WeakMap();
const immediatePropagationStopped = new WeakMap();
function trackPropagation() {
propagationStopped.set(this, true);
}
function trackImmediate() {
propagationStopped.set(this, true);
immediatePropagationStopped.set(this, true);
}
function spy(event, propName, fn) {
const source = event[propName];
event[propName] = function () {
fn.apply(event, arguments);
return source.apply(event, arguments);
};
return event;
}
function unspy(event, propName) {
event[propName] = Event.prototype[propName];
}
const currentTargets = new WeakMap();
const currentTargetDescriptor = Object.getOwnPropertyDescriptor(Event.prototype, 'currentTarget');
function getCurrentTarget() {
var _a;
return (_a = currentTargets.get(this)) !== null && _a !== void 0 ? _a : null;
}
function defineCurrentTarget(event, getter) {
if (currentTargetDescriptor === undefined)
return;
Object.defineProperty(event, 'currentTarget', {
configurable: true,
enumerable: true,
get: getter !== null && getter !== void 0 ? getter : currentTargetDescriptor.get
});
}
const phaseToTypeToElToHandlers = {
bubble: {},
capture: {}
};
const typeToWindowEventHandlers = {};
function createUnifiedHandler() {
const delegeteHandler = function (e) {
const { type, eventPhase, bubbles } = e;
const target = getEventTarget(e);
if (eventPhase === 2)
return;
const phase = eventPhase === 1 ? 'capture' : 'bubble';
let cursor = target;
const path = [];
// collecting bubble path
while (true) {
if (cursor === null)
cursor = window;
path.push(cursor);
if (cursor === window) {
break;
}
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
cursor = (cursor.parentNode || null);
}
const captureElToHandlers = phaseToTypeToElToHandlers.capture[type];
const bubbleElToHandlers = phaseToTypeToElToHandlers.bubble[type];
spy(e, 'stopPropagation', trackPropagation);
spy(e, 'stopImmediatePropagation', trackImmediate);
defineCurrentTarget(e, getCurrentTarget);
if (phase === 'capture') {
if (captureElToHandlers === undefined)
return;
// capture
for (let i = path.length - 1; i >= 0; --i) {
if (propagationStopped.has(e))
break;
const target = path[i];
const handlers = captureElToHandlers.get(target);
if (handlers !== undefined) {
currentTargets.set(e, target);
for (const handler of handlers) {
if (immediatePropagationStopped.has(e))
break;
handler(e);
}
}
if (i === 0 && !bubbles && bubbleElToHandlers !== undefined) {
const bubbleHandlers = bubbleElToHandlers.get(target);
if (bubbleHandlers !== undefined) {
for (const handler of bubbleHandlers) {
if (immediatePropagationStopped.has(e))
break;
handler(e);
}
}
}
}
}
else if (phase === 'bubble') {
if (bubbleElToHandlers === undefined)
return;
// bubble
for (let i = 0; i < path.length; ++i) {
if (propagationStopped.has(e))
break;
const target = path[i];
const handlers = bubbleElToHandlers.get(target);
if (handlers !== undefined) {
currentTargets.set(e, target);
for (const handler of handlers) {
if (immediatePropagationStopped.has(e))
break;
handler(e);
}
}
}
}
unspy(e, 'stopPropagation');
unspy(e, 'stopImmediatePropagation');
defineCurrentTarget(e);
};
delegeteHandler.displayName = 'evtdUnifiedHandler';
return delegeteHandler;
}
function createUnifiedWindowEventHandler() {
const delegateHandler = function (e) {
const { type, eventPhase } = e;
if (eventPhase !== 2)
return;
const handlers = typeToWindowEventHandlers[type];
if (handlers === undefined)
return;
handlers.forEach((handler) => handler(e));
};
delegateHandler.displayName = 'evtdUnifiedWindowEventHandler';
return delegateHandler;
}
const unifiedHandler = createUnifiedHandler();
const unfiendWindowEventHandler = createUnifiedWindowEventHandler();
function ensureElToHandlers(phase, type) {
const phaseHandlers = phaseToTypeToElToHandlers[phase];
if (phaseHandlers[type] === undefined) {
phaseHandlers[type] = new Map();
window.addEventListener(type, unifiedHandler, phase === 'capture');
}
return phaseHandlers[type];
}
function ensureWindowEventHandlers(type) {
const windowEventHandlers = typeToWindowEventHandlers[type];
if (windowEventHandlers === undefined) {
typeToWindowEventHandlers[type] = new Set();
window.addEventListener(type, unfiendWindowEventHandler);
}
return typeToWindowEventHandlers[type];
}
function ensureHandlers(elToHandlers, el) {
let elHandlers = elToHandlers.get(el);
if (elHandlers === undefined) {
elToHandlers.set(el, (elHandlers = new Set()));
}
return elHandlers;
}
function handlerExist(el, phase, type, handler) {
const elToHandlers = phaseToTypeToElToHandlers[phase][type];
// phase ${type} event has handlers
if (elToHandlers !== undefined) {
const handlers = elToHandlers.get(el);
// phase using el with ${type} event has handlers
if (handlers !== undefined) {
if (handlers.has(handler))
return true;
}
}
return false;
}
function windowEventHandlerExist(type, handler) {
const handlers = typeToWindowEventHandlers[type];
if (handlers !== undefined) {
if (handlers.has(handler)) {
return true;
}
}
return false;
}
function on(type, el, handler, options) {
let mergedHandler;
if (typeof options === 'object' && options.once === true) {
mergedHandler = (e) => {
off(type, el, mergedHandler, options);
handler(e);
};
}
else {
mergedHandler = handler;
}
const trapped = trapOn(type, el, mergedHandler, options);
if (trapped)
return;
const phase = options === true ||
(typeof options === 'object' && options.capture === true)
? 'capture'
: 'bubble';
const elToHandlers = ensureElToHandlers(phase, type);
const handlers = ensureHandlers(elToHandlers, el);
if (!handlers.has(mergedHandler))
handlers.add(mergedHandler);
if (el === window) {
const windowEventHandlers = ensureWindowEventHandlers(type);
if (!windowEventHandlers.has(mergedHandler)) {
windowEventHandlers.add(mergedHandler);
}
}
}
function off(type, el, handler, options) {
const trapped = trapOff(type, el, handler, options);
if (trapped)
return;
const capture = options === true ||
(typeof options === 'object' && options.capture === true);
const phase = capture ? 'capture' : 'bubble';
const elToHandlers = ensureElToHandlers(phase, type);
const handlers = ensureHandlers(elToHandlers, el);
if (el === window) {
const mirrorPhase = capture ? 'bubble' : 'capture';
if (!handlerExist(el, mirrorPhase, type, handler) &&
windowEventHandlerExist(type, handler)) {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const windowEventHandlers = typeToWindowEventHandlers[type];
windowEventHandlers.delete(handler);
if (windowEventHandlers.size === 0) {
window.removeEventListener(type, unfiendWindowEventHandler);
typeToWindowEventHandlers[type] = undefined;
}
}
}
if (handlers.has(handler))
handlers.delete(handler);
if (handlers.size === 0) {
elToHandlers.delete(el);
}
if (elToHandlers.size === 0) {
window.removeEventListener(type, unifiedHandler, phase === 'capture');
phaseToTypeToElToHandlers[phase][type] = undefined;
}
}
return {
on: on,
off: off
};
}
const { on, off } = createDelegate();
;// ./node_modules/vueuc/es/shared/v-node.js
function v_node_getSlot(scope, slots, slotName = 'default') {
const slot = slots[slotName];
if (slot === undefined) {
throw new Error(`[vueuc/${scope}]: slot[${slotName}] is empty.`);
}
return slot();
}
// o(n) flatten
function v_node_flatten(vNodes, filterCommentNode = true, result = []) {
vNodes.forEach((vNode) => {
if (vNode === null)
return;
if (typeof vNode !== 'object') {
if (typeof vNode === 'string' || typeof vNode === 'number') {
result.push(createTextVNode(String(vNode)));
}
return;
}
if (Array.isArray(vNode)) {
v_node_flatten(vNode, filterCommentNode, result);
return;
}
if (vNode.type === Fragment) {
if (vNode.children === null)
return;
if (Array.isArray(vNode.children)) {
v_node_flatten(vNode.children, filterCommentNode, result);
}
// rawSlot
}
else if (vNode.type !== Comment) {
result.push(vNode);
}
});
return result;
}
function getFirstVNode(scope, slots, slotName = 'default') {
const slot = slots[slotName];
if (slot === undefined) {
throw new Error(`[vueuc/${scope}]: slot[${slotName}] is empty.`);
}
const content = v_node_flatten(slot());
// vue will normalize the slot, so slot must be an array
if (content.length === 1) {
return content[0];
}
else {
throw new Error(`[vueuc/${scope}]: slot[${slotName}] should have exactly one child.`);
}
}
;// ./node_modules/vueuc/es/binder/src/utils.js
let viewMeasurer = null;
function ensureViewBoundingRect() {
if (viewMeasurer === null) {
viewMeasurer = document.getElementById('v-binder-view-measurer');
if (viewMeasurer === null) {
viewMeasurer = document.createElement('div');
viewMeasurer.id = 'v-binder-view-measurer';
const { style } = viewMeasurer;
style.position = 'fixed';
style.left = '0';
style.right = '0';
style.top = '0';
style.bottom = '0';
style.pointerEvents = 'none';
style.visibility = 'hidden';
document.body.appendChild(viewMeasurer);
}
}
return viewMeasurer.getBoundingClientRect();
}
function getPointRect(x, y) {
const viewRect = ensureViewBoundingRect();
return {
top: y,
left: x,
height: 0,
width: 0,
right: viewRect.width - x,
bottom: viewRect.height - y
};
}
function getRect(el) {
const elRect = el.getBoundingClientRect();
const viewRect = ensureViewBoundingRect();
return {
left: elRect.left - viewRect.left,
top: elRect.top - viewRect.top,
bottom: viewRect.height + viewRect.top - elRect.bottom,
right: viewRect.width + viewRect.left - elRect.right,
width: elRect.width,
height: elRect.height
};
}
function getParentNode(node) {
// document type
if (node.nodeType === 9) {
return null;
}
return node.parentNode;
}
function getScrollParent(node) {
if (node === null)
return null;
const parentNode = getParentNode(node);
if (parentNode === null) {
return null;
}
// Document
if (parentNode.nodeType === 9) {
return document;
}
// Element
if (parentNode.nodeType === 1) {
// Firefox want us to check `-x` and `-y` variations as well
const { overflow, overflowX, overflowY } = getComputedStyle(parentNode);
if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
return parentNode;
}
}
return getScrollParent(parentNode);
}
;// ./node_modules/vueuc/es/binder/src/Binder.js
/* eslint-disable @typescript-eslint/no-non-null-assertion */
const Binder = defineComponent({
name: 'Binder',
props: {
syncTargetWithParent: Boolean,
syncTarget: {
type: Boolean,
default: true
}
},
setup(props) {
var _a;
provide('VBinder', (_a = runtime_core_esm_bundler_getCurrentInstance()) === null || _a === void 0 ? void 0 : _a.proxy);
const VBinder = runtime_core_esm_bundler_inject('VBinder', null);
const targetRef = ref(null);
/**
* If there's no nested vbinder, we can simply set the target ref.
*
* However, when it comes to:
* <VBinder> <- syncTarget = false
*
* Should hold target DOM ref, but can't get it directly from
* its VTarget. So if there are nested VBinder, we should:
* 1. Stop setting target DOM from level-1 VTarget
* 2. Set target DOM from level-2 VTarget
* For (1), we need `syncTarget` to `false`
* For (2), we need to set `syncTargetWithParent` to `true` on
* level-2 VBinder
* <VTarget>
* <VBinder> <- syncTargetWithParent = true
* <VTarget>target</VTarget>
* </VBinder>
* <VFollower>
* content1
* </VFollower>
* </VTarget>
* <VFollower>
* content2
* </VFollower>
* </VBinder>
*/
const setTargetRef = (el) => {
targetRef.value = el;
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
if (VBinder && props.syncTargetWithParent) {
VBinder.setTargetRef(el);
}
};
// scroll related
let scrollableNodes = [];
const ensureScrollListener = () => {
let cursor = targetRef.value;
while (true) {
cursor = getScrollParent(cursor);
if (cursor === null)
break;
scrollableNodes.push(cursor);
}
for (const el of scrollableNodes) {
on('scroll', el, onScroll, true);
}
};
const removeScrollListeners = () => {
for (const el of scrollableNodes) {
off('scroll', el, onScroll, true);
}
scrollableNodes = [];
};
const followerScrollListeners = new Set();
const addScrollListener = (listener) => {
if (followerScrollListeners.size === 0) {
ensureScrollListener();
}
if (!followerScrollListeners.has(listener)) {
followerScrollListeners.add(listener);
}
};
const removeScrollListener = (listener) => {
if (followerScrollListeners.has(listener)) {
followerScrollListeners.delete(listener);
}
if (followerScrollListeners.size === 0) {
removeScrollListeners();
}
};
const onScroll = () => {
beforeNextFrameOnce(onScrollRaf);
};
const onScrollRaf = () => {
followerScrollListeners.forEach((listener) => listener());
};
// resize related
const followerResizeListeners = new Set();
const addResizeListener = (listener) => {
if (followerResizeListeners.size === 0) {
on('resize', window, onResize);
}
if (!followerResizeListeners.has(listener)) {
followerResizeListeners.add(listener);
}
};
const removeResizeListener = (listener) => {
if (followerResizeListeners.has(listener)) {
followerResizeListeners.delete(listener);
}
if (followerResizeListeners.size === 0) {
off('resize', window, onResize);
}
};
const onResize = () => {
followerResizeListeners.forEach((listener) => listener());
};
runtime_core_esm_bundler_onBeforeUnmount(() => {
off('resize', window, onResize);
removeScrollListeners();
});
return {
targetRef,
setTargetRef,
addScrollListener,
removeScrollListener,
addResizeListener,
removeResizeListener
};
},
render() {
return v_node_getSlot('binder', this.$slots);
}
});
/* harmony default export */ var src_Binder = (Binder);
;// ./node_modules/vueuc/es/binder/src/Target.js
/* eslint-disable @typescript-eslint/no-non-null-assertion */
/* harmony default export */ var Target = (defineComponent({
name: 'Target',
setup() {
const { setTargetRef, syncTarget } = runtime_core_esm_bundler_inject('VBinder');
const setTargetDirective = {
mounted: setTargetRef,
updated: setTargetRef
};
return {
syncTarget,
setTargetDirective
};
},
render() {
const { syncTarget, setTargetDirective } = this;
/**
* If you are using VBinder as a child of VBinder, the children wouldn't be
* a valid DOM or component that can be attached to by directive.
* So we won't sync target on those kind of situation and control the
* target sync logic manually.
*/
if (syncTarget) {
return withDirectives(getFirstVNode('follower', this.$slots), [
[setTargetDirective]
]);
}
return getFirstVNode('follower', this.$slots);
}
}));
;// ./node_modules/naive-ui/es/_internal/select-menu/src/interface.mjs
const internalSelectionMenuInjectionKey = createInjectionKey('n-internal-select-menu');
const internalSelectionMenuBodyInjectionKey = createInjectionKey('n-internal-select-menu-body');
;// ./node_modules/naive-ui/es/drawer/src/interface.mjs
const drawerBodyInjectionKey = createInjectionKey('n-drawer-body');
const drawerInjectionKey = createInjectionKey('n-drawer');
;// ./node_modules/naive-ui/es/modal/src/interface.mjs
const modalBodyInjectionKey = createInjectionKey('n-modal-body');
const modalProviderInjectionKey = createInjectionKey('n-modal-provider');
const modalInjectionKey = createInjectionKey('n-modal');
;// ./node_modules/naive-ui/es/popover/src/interface.mjs
const popoverBodyInjectionKey = createInjectionKey('n-popover-body');
;// ./node_modules/naive-ui/es/_utils/composable/use-adjusted-to.mjs
const teleportDisabled = '__disabled__';
function useAdjustedTo(props) {
const modal = runtime_core_esm_bundler_inject(modalBodyInjectionKey, null);
const drawer = runtime_core_esm_bundler_inject(drawerBodyInjectionKey, null);
const popover = runtime_core_esm_bundler_inject(popoverBodyInjectionKey, null);
const selectMenu = runtime_core_esm_bundler_inject(internalSelectionMenuBodyInjectionKey, null);
const fullscreenElementRef = ref();
if (typeof document !== 'undefined') {
fullscreenElementRef.value = document.fullscreenElement;
const handleFullscreenChange = () => {
fullscreenElementRef.value = document.fullscreenElement;
};
runtime_core_esm_bundler_onMounted(() => {
on('fullscreenchange', document, handleFullscreenChange);
});
runtime_core_esm_bundler_onBeforeUnmount(() => {
off('fullscreenchange', document, handleFullscreenChange);
});
}
return use_memo(() => {
var _a;
const {
to
} = props;
if (to !== undefined) {
if (to === false) return teleportDisabled;
if (to === true) return fullscreenElementRef.value || 'body';
return to;
}
if (modal === null || modal === void 0 ? void 0 : modal.value) {
return (_a = modal.value.$el) !== null && _a !== void 0 ? _a : modal.value;
}
if (drawer === null || drawer === void 0 ? void 0 : drawer.value) return drawer.value;
if (popover === null || popover === void 0 ? void 0 : popover.value) return popover.value;
if (selectMenu === null || selectMenu === void 0 ? void 0 : selectMenu.value) return selectMenu.value;
return to !== null && to !== void 0 ? to : fullscreenElementRef.value || 'body';
});
}
// teleport disabled key
useAdjustedTo.tdkey = teleportDisabled;
useAdjustedTo.propTo = {
type: [String, Object, Boolean],
default: undefined
};
;// ./node_modules/naive-ui/es/_utils/vue/get-first-slot-vnode.mjs
function getFirstSlotVNode(slots, slotName = 'default', props = undefined) {
const slot = slots[slotName];
if (!slot) {
warn_warn('getFirstSlotVNode', `slot[${slotName}] is empty`);
return null;
}
const slotContent = flatten_flatten(slot(props));
// vue will normalize the slot, so slot must be an array
if (slotContent.length === 1) {
return slotContent[0];
} else {
warn_warn('getFirstSlotVNode', `slot[${slotName}] should have exactly one child`);
return null;
}
}
function getFirstSlotVNodeWithTypedProps(slotName, slot, props) {
if (!slot) {
return null;
}
const slotContent = flatten(slot(props));
// vue will normalize the slot, so slot must be an array
if (slotContent.length === 1) {
return slotContent[0];
} else {
warn('getFirstSlotVNode', `slot[${slotName}] should have exactly one child`);
return null;
}
}
;// ./node_modules/naive-ui/es/_utils/vue/keep.mjs
function keep(object, keys = [], rest) {
const keepedObject = {};
keys.forEach(key => {
keepedObject[key] = object[key];
});
return Object.assign(keepedObject, rest);
}
;// ./node_modules/seemly/es/dom/get-precise-event-target.js
function getPreciseEventTarget(event) {
return event.composedPath()[0] || null;
}
;// ./node_modules/vdirs/es/clickoutside.js
const ctxKey = '@@coContext';
const clickoutside = {
mounted(el, { value, modifiers }) {
el[ctxKey] = {
handler: undefined
};
if (typeof value === 'function') {
el[ctxKey].handler = value;
on('clickoutside', el, value, {
capture: modifiers.capture
});
}
},
updated(el, { value, modifiers }) {
const ctx = el[ctxKey];
if (typeof value === 'function') {
if (ctx.handler) {
if (ctx.handler !== value) {
off('clickoutside', el, ctx.handler, {
capture: modifiers.capture
});
ctx.handler = value;
on('clickoutside', el, value, {
capture: modifiers.capture
});
}
}
else {
el[ctxKey].handler = value;
on('clickoutside', el, value, {
capture: modifiers.capture
});
}
}
else {
if (ctx.handler) {
off('clickoutside', el, ctx.handler, {
capture: modifiers.capture
});
ctx.handler = undefined;
}
}
},
unmounted(el, { modifiers }) {
const { handler } = el[ctxKey];
if (handler) {
off('clickoutside', el, handler, {
capture: modifiers.capture
});
}
el[ctxKey].handler = undefined;
}
};
/* harmony default export */ var es_clickoutside = (clickoutside);
;// ./node_modules/vdirs/es/mousemoveoutside.js
const mousemoveoutside_ctxKey = '@@mmoContext';
const mousemoveoutside = {
mounted(el, { value }) {
el[mousemoveoutside_ctxKey] = {
handler: undefined
};
if (typeof value === 'function') {
el[mousemoveoutside_ctxKey].handler = value;
on('mousemoveoutside', el, value);
}
},
updated(el, { value }) {
const ctx = el[mousemoveoutside_ctxKey];
if (typeof value === 'function') {
if (ctx.handler) {
if (ctx.handler !== value) {
off('mousemoveoutside', el, ctx.handler);
ctx.handler = value;
on('mousemoveoutside', el, value);
}
}
else {
el[mousemoveoutside_ctxKey].handler = value;
on('mousemoveoutside', el, value);
}
}
else {
if (ctx.handler) {
off('mousemoveoutside', el, ctx.handler);
ctx.handler = undefined;
}
}
},
unmounted(el) {
const { handler } = el[mousemoveoutside_ctxKey];
if (handler) {
off('mousemoveoutside', el, handler);
}
el[mousemoveoutside_ctxKey].handler = undefined;
}
};
/* harmony default export */ var es_mousemoveoutside = (mousemoveoutside);
;// ./node_modules/seemly/es/misc/index.js
function createId(length = 8) {
return Math.random()
.toString(16)
.slice(2, 2 + length);
}
function repeat(count, v) {
const ret = [];
for (let i = 0; i < count; ++i) {
ret.push(v);
}
return ret;
}
function indexMap(count, createValue) {
const ret = [];
if (!createValue) {
for (let i = 0; i < count; ++i) {
ret.push(i);
}
return ret;
}
for (let i = 0; i < count; ++i) {
ret.push(createValue(i));
}
return ret;
}
async function sleep(ms) {
return new Promise(resolve => {
setTimeout(resolve, ms);
});
}
;// ./node_modules/vueuc/es/focus-trap/src/utils.js
/* eslint-disable @typescript-eslint/strict-boolean-expressions */
// ref https://www.w3.org/TR/wai-aria-practices-1.1/examples/dialog-modal/js/dialog.js
function isHTMLElement(node) {
return node instanceof HTMLElement;
}
function focusFirstDescendant(node) {
for (let i = 0; i < node.childNodes.length; i++) {
const child = node.childNodes[i];
if (isHTMLElement(child)) {
if (attemptFocus(child) || focusFirstDescendant(child)) {
return true;
}
}
}
return false;
}
function focusLastDescendant(element) {
for (let i = element.childNodes.length - 1; i >= 0; i--) {
const child = element.childNodes[i];
if (isHTMLElement(child)) {
if (attemptFocus(child) || focusLastDescendant(child)) {
return true;
}
}
}
return false;
}
function attemptFocus(element) {
if (!isFocusable(element)) {
return false;
}
try {
element.focus({ preventScroll: true });
}
catch (e) { }
return document.activeElement === element;
}
function isFocusable(element) {
if (element.tabIndex > 0 ||
(element.tabIndex === 0 && element.getAttribute('tabIndex') !== null)) {
return true;
}
if (element.getAttribute('disabled')) {
return false;
}
switch (element.nodeName) {
case 'A':
return (!!element.href &&
element.rel !== 'ignore');
case 'INPUT':
return (element.type !== 'hidden' &&
element.type !== 'file');
case 'BUTTON':
case 'SELECT':
case 'TEXTAREA':
return true;
default:
return false;
}
}
;// ./node_modules/vueuc/es/shared/resolve-to.js
function resolveTo(selector) {
if (typeof selector === 'string') {
return document.querySelector(selector);
}
return selector();
}
;// ./node_modules/vueuc/es/focus-trap/src/index.js
let src_stack = [];
const FocusTrap = defineComponent({
name: 'FocusTrap',
props: {
disabled: Boolean,
active: Boolean,
autoFocus: {
type: Boolean,
default: true
},
onEsc: Function,
initialFocusTo: String,
finalFocusTo: String,
returnFocusOnDeactivated: {
type: Boolean,
default: true
}
},
setup(props) {
const id = createId();
const focusableStartRef = ref(null);
const focusableEndRef = ref(null);
let activated = false;
let ignoreInternalFocusChange = false;
const lastFocusedElement = typeof document === 'undefined' ? null : document.activeElement;
function isCurrentActive() {
const currentActiveId = src_stack[src_stack.length - 1];
return currentActiveId === id;
}
function handleDocumentKeydown(e) {
var _a;
if (e.code === 'Escape') {
if (isCurrentActive()) {
(_a = props.onEsc) === null || _a === void 0 ? void 0 : _a.call(props, e);
}
}
}
runtime_core_esm_bundler_onMounted(() => {
runtime_core_esm_bundler_watch(() => props.active, (value) => {
if (value) {
activate();
on('keydown', document, handleDocumentKeydown);
}
else {
off('keydown', document, handleDocumentKeydown);
if (activated) {
deactivate();
}
}
}, {
immediate: true
});
});
runtime_core_esm_bundler_onBeforeUnmount(() => {
off('keydown', document, handleDocumentKeydown);
if (activated)
deactivate();
});
function handleDocumentFocus(e) {
if (ignoreInternalFocusChange)
return;
if (isCurrentActive()) {
const mainEl = getMainEl();
if (mainEl === null)
return;
if (mainEl.contains(getPreciseEventTarget(e)))
return;
// I don't handle shift + tab status since it's too tricky to handle
// Not impossible but I need to sleep
resetFocusTo('first');
}
}
function getMainEl() {
const focusableStartEl = focusableStartRef.value;
if (focusableStartEl === null)
return null;
let mainEl = focusableStartEl;
while (true) {
mainEl = mainEl.nextSibling;
if (mainEl === null)
break;
if (mainEl instanceof Element && mainEl.tagName === 'DIV') {
break;
}
}
return mainEl;
}
function activate() {
var _a;
if (props.disabled)
return;
src_stack.push(id);
if (props.autoFocus) {
const { initialFocusTo } = props;
if (initialFocusTo === undefined) {
resetFocusTo('first');
}
else {
(_a = resolveTo(initialFocusTo)) === null || _a === void 0 ? void 0 : _a.focus({ preventScroll: true });
}
}
activated = true;
document.addEventListener('focus', handleDocumentFocus, true);
}
function deactivate() {
var _a;
if (props.disabled)
return;
document.removeEventListener('focus', handleDocumentFocus, true);
src_stack = src_stack.filter((idInStack) => idInStack !== id);
if (isCurrentActive())
return;
const { finalFocusTo } = props;
if (finalFocusTo !== undefined) {
(_a = resolveTo(finalFocusTo)) === null || _a === void 0 ? void 0 : _a.focus({ preventScroll: true });
}
else if (props.returnFocusOnDeactivated) {
if (lastFocusedElement instanceof HTMLElement) {
ignoreInternalFocusChange = true;
lastFocusedElement.focus({ preventScroll: true });
ignoreInternalFocusChange = false;
}
}
}
function resetFocusTo(target) {
if (!isCurrentActive())
return;
if (props.active) {
const focusableStartEl = focusableStartRef.value;
const focusableEndEl = focusableEndRef.value;
if (focusableStartEl !== null && focusableEndEl !== null) {
const mainEl = getMainEl();
if (mainEl == null || mainEl === focusableEndEl) {
ignoreInternalFocusChange = true;
focusableStartEl.focus({ preventScroll: true });
ignoreInternalFocusChange = false;
return;
}
ignoreInternalFocusChange = true;
const focused = target === 'first'
? focusFirstDescendant(mainEl)
: focusLastDescendant(mainEl);
ignoreInternalFocusChange = false;
if (!focused) {
ignoreInternalFocusChange = true;
focusableStartEl.focus({ preventScroll: true });
ignoreInternalFocusChange = false;
}
}
}
}
function handleStartFocus(e) {
if (ignoreInternalFocusChange)
return;
const mainEl = getMainEl();
if (mainEl === null)
return;
if (e.relatedTarget !== null && mainEl.contains(e.relatedTarget)) {
// if it comes from inner, focus last
resetFocusTo('last');
}
else {
// otherwise focus first
resetFocusTo('first');
}
}
function handleEndFocus(e) {
if (ignoreInternalFocusChange)
return;
if (e.relatedTarget !== null &&
e.relatedTarget === focusableStartRef.value) {
// if it comes from first, focus last
resetFocusTo('last');
}
else {
// otherwise focus first
resetFocusTo('first');
}
}
return {
focusableStartRef,
focusableEndRef,
focusableStyle: 'position: absolute; height: 0; width: 0;',
handleStartFocus,
handleEndFocus
};
},
render() {
const { default: defaultSlot } = this.$slots;
if (defaultSlot === undefined)
return null;
if (this.disabled)
return defaultSlot();
const { active, focusableStyle } = this;
return h(Fragment, null, [
h('div', {
'aria-hidden': 'true',
tabindex: active ? '0' : '-1',
ref: 'focusableStartRef',
style: focusableStyle,
onFocus: this.handleStartFocus
}),
defaultSlot(),
h('div', {
'aria-hidden': 'true',
style: focusableStyle,
ref: 'focusableEndRef',
tabindex: active ? '0' : '-1',
onFocus: this.handleEndFocus
})
]);
}
});
;// ./node_modules/vooks/es/utils.js
function hasInstance() {
return getCurrentInstance() !== null;
}
const utils_isBrowser = typeof window !== 'undefined';
;// ./node_modules/vooks/es/on-fonts-ready.js
let fontsReady;
let isFontReady;
const init = () => {
var _a, _b;
fontsReady = utils_isBrowser ? (_b = (_a = document) === null || _a === void 0 ? void 0 : _a.fonts) === null || _b === void 0 ? void 0 : _b.ready : undefined;
isFontReady = false;
/* istanbul ignore if */
if (fontsReady !== undefined) {
void fontsReady.then(() => {
isFontReady = true;
});
}
else {
isFontReady = true;
}
};
init();
// For testing
/**
* Call callback on fontsReady is resolved. If fontsReady is already resolved,
* callback won't be called.
*/
function onFontsReady(cb) {
/* istanbul ignore next */
if (isFontReady)
return;
let deactivated = false;
runtime_core_esm_bundler_onMounted(() => {
/* istanbul ignore next */
if (!isFontReady) {
fontsReady === null || fontsReady === void 0 ? void 0 : fontsReady.then(() => {
if (deactivated)
return;
cb();
});
}
});
runtime_core_esm_bundler_onBeforeUnmount(() => {
deactivated = true;
});
}
;// ./node_modules/vueuc/es/shared/cssr.js
const { c: shared_cssr_c } = CssRender();
const cssr_cssrAnchorMetaName = 'vueuc-style';
;// ./node_modules/vooks/es/use-false-until-truthy.js
function useFalseUntilTruthy(originalRef) {
const currentRef = ref(!!originalRef.value);
if (currentRef.value)
return readonly(currentRef);
const stop = runtime_core_esm_bundler_watch(originalRef, (value) => {
if (value) {
currentRef.value = true;
stop();
}
});
return readonly(currentRef);
}
;// ./node_modules/vueuc/es/lazy-teleport/src/index.js
/* harmony default export */ var src = (defineComponent({
name: 'LazyTeleport',
props: {
to: {
type: [String, Object],
default: undefined
},
disabled: Boolean,
show: {
type: Boolean,
required: true
}
},
setup(props) {
return {
showTeleport: useFalseUntilTruthy(toRef(props, 'show')),
mergedTo: runtime_core_esm_bundler_computed(() => {
const { to } = props;
return to !== null && to !== void 0 ? to : 'body';
})
};
},
render() {
return this.showTeleport
? this.disabled
? v_node_getSlot('lazy-teleport', this.$slots)
: h(Teleport, {
disabled: this.disabled,
to: this.mergedTo
}, v_node_getSlot('lazy-teleport', this.$slots))
: null;
}
}));
;// ./node_modules/vueuc/es/binder/src/get-placement-style.js
const oppositionPositions = {
top: 'bottom',
bottom: 'top',
left: 'right',
right: 'left'
};
const oppositeAligns = {
start: 'end',
center: 'center',
end: 'start'
};
const propToCompare = {
top: 'height',
bottom: 'height',
left: 'width',
right: 'width'
};
const transformOrigins = {
'bottom-start': 'top left',
bottom: 'top center',
'bottom-end': 'top right',
'top-start': 'bottom left',
top: 'bottom center',
'top-end': 'bottom right',
'right-start': 'top left',
right: 'center left',
'right-end': 'bottom left',
'left-start': 'top right',
left: 'center right',
'left-end': 'bottom right'
};
const overlapTransformOrigin = {
'bottom-start': 'bottom left',
bottom: 'bottom center',
'bottom-end': 'bottom right',
'top-start': 'top left',
top: 'top center',
'top-end': 'top right',
'right-start': 'top right',
right: 'center right',
'right-end': 'bottom right',
'left-start': 'top left',
left: 'center left',
'left-end': 'bottom left'
};
const oppositeAlignCssPositionProps = {
'bottom-start': 'right',
'bottom-end': 'left',
'top-start': 'right',
'top-end': 'left',
'right-start': 'bottom',
'right-end': 'top',
'left-start': 'bottom',
'left-end': 'top'
};
const keepOffsetDirection = {
top: true,
bottom: false,
left: true,
right: false // left--
};
const cssPositionToOppositeAlign = {
top: 'end',
bottom: 'start',
left: 'end',
right: 'start'
};
function getPlacementAndOffsetOfFollower(placement, targetRect, followerRect, shift, flip, overlap) {
if (!flip || overlap) {
return { placement: placement, top: 0, left: 0 };
}
const [position, align] = placement.split('-');
let properAlign = align !== null && align !== void 0 ? align : 'center';
let properOffset = {
top: 0,
left: 0
};
const deriveOffset = (oppositeAlignCssSizeProp, alignCssPositionProp, offsetVertically) => {
let left = 0;
let top = 0;
const diff = followerRect[oppositeAlignCssSizeProp] -
targetRect[alignCssPositionProp] -
targetRect[oppositeAlignCssSizeProp];
if (diff > 0 && shift) {
if (offsetVertically) {
// screen border
// |-----------------------------------------|
// | | f | |
// | | o | |
// | | l | |
// | | l |---- |
// | | o |tar | |
// | | w |get | |
// | | e | | |
// | | r |---- |
// | ---- |
// |-----------------------------------------|
top = keepOffsetDirection[alignCssPositionProp] ? diff : -diff;
}
else {
// screen border
// |----------------------------------------|
// | |
// | ---------- |
// | | target | |
// | ----------------------------------
// | | follower |
// | ----------------------------------
// | |
// |----------------------------------------|
left = keepOffsetDirection[alignCssPositionProp] ? diff : -diff;
}
}
return {
left,
top
};
};
const offsetVertically = position === 'left' || position === 'right';
// choose proper placement for non-center align
if (properAlign !== 'center') {
const oppositeAlignCssPositionProp = oppositeAlignCssPositionProps[placement];
const currentAlignCssPositionProp = oppositionPositions[oppositeAlignCssPositionProp];
const oppositeAlignCssSizeProp = propToCompare[oppositeAlignCssPositionProp];
// if follower rect is larger than target rect in align direction
// ----------[ target ]---------|
// ----------[ follower ]
if (followerRect[oppositeAlignCssSizeProp] >
targetRect[oppositeAlignCssSizeProp]) {
if (
// current space is not enough
// ----------[ target ]---------|
// -------[ follower ]
targetRect[oppositeAlignCssPositionProp] +
targetRect[oppositeAlignCssSizeProp] <
followerRect[oppositeAlignCssSizeProp]) {
const followerOverTargetSize = (followerRect[oppositeAlignCssSizeProp] -
targetRect[oppositeAlignCssSizeProp]) /
2;
if (targetRect[oppositeAlignCssPositionProp] < followerOverTargetSize ||
targetRect[currentAlignCssPositionProp] < followerOverTargetSize) {
// opposite align has larger space
// -------[ target ]-----------|
// -------[ follower ]-|
if (targetRect[oppositeAlignCssPositionProp] <
targetRect[currentAlignCssPositionProp]) {
properAlign = oppositeAligns[align];
properOffset = deriveOffset(oppositeAlignCssSizeProp, currentAlignCssPositionProp, offsetVertically);
}
else {
// ----------------[ target ]----|
// --------[ follower ]----|
properOffset = deriveOffset(oppositeAlignCssSizeProp, oppositeAlignCssPositionProp, offsetVertically);
}
}
else {
// 'center' align is better
// ------------[ target ]--------|
// -------[ follower ]--|
properAlign = 'center';
}
}
}
else if (followerRect[oppositeAlignCssSizeProp] <
targetRect[oppositeAlignCssSizeProp]) {
// TODO: maybe center is better
if (targetRect[currentAlignCssPositionProp] < 0 &&
// opposite align has larger space
// ------------[ target ]
// ----------------[follower]
targetRect[oppositeAlignCssPositionProp] >
targetRect[currentAlignCssPositionProp]) {
properAlign = oppositeAligns[align];
}
}
}
else {
const possibleAlternativeAlignCssPositionProp1 = position === 'bottom' || position === 'top' ? 'left' : 'top';
const possibleAlternativeAlignCssPositionProp2 = oppositionPositions[possibleAlternativeAlignCssPositionProp1];
const alternativeAlignCssSizeProp = propToCompare[possibleAlternativeAlignCssPositionProp1];
const followerOverTargetSize = (followerRect[alternativeAlignCssSizeProp] -
targetRect[alternativeAlignCssSizeProp]) /
2;
if (
// center is not enough
// ----------- [ target ]--|
// -------[ follower ]
targetRect[possibleAlternativeAlignCssPositionProp1] <
followerOverTargetSize ||
targetRect[possibleAlternativeAlignCssPositionProp2] <
followerOverTargetSize) {
// alternative 2 position's space is larger
if (targetRect[possibleAlternativeAlignCssPositionProp1] >
targetRect[possibleAlternativeAlignCssPositionProp2]) {
properAlign =
cssPositionToOppositeAlign[possibleAlternativeAlignCssPositionProp1];
properOffset = deriveOffset(alternativeAlignCssSizeProp, possibleAlternativeAlignCssPositionProp1, offsetVertically);
}
else {
// alternative 1 position's space is larger
properAlign =
cssPositionToOppositeAlign[possibleAlternativeAlignCssPositionProp2];
properOffset = deriveOffset(alternativeAlignCssSizeProp, possibleAlternativeAlignCssPositionProp2, offsetVertically);
}
}
}
let properPosition = position;
if (
// space is not enough
targetRect[position] < followerRect[propToCompare[position]] &&
// opposite position's space is larger
targetRect[position] < targetRect[oppositionPositions[position]]) {
properPosition = oppositionPositions[position];
}
return {
placement: properAlign !== 'center'
? `${properPosition}-${properAlign}`
: properPosition,
left: properOffset.left,
top: properOffset.top
};
}
function getProperTransformOrigin(placement, overlap) {
if (overlap)
return overlapTransformOrigin[placement];
return transformOrigins[placement];
}
// ------------
// | offset |
// | |
// | [target] |
// | |
// ------------
// TODO: refactor it to remove dup logic
function getOffset(placement, offsetRect, targetRect, offsetTopToStandardPlacement, offsetLeftToStandardPlacement, overlap) {
if (overlap) {
switch (placement) {
case 'bottom-start':
return {
top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height)}px`,
left: `${Math.round(targetRect.left - offsetRect.left)}px`,
transform: 'translateY(-100%)'
};
case 'bottom-end':
return {
top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width)}px`,
transform: 'translateX(-100%) translateY(-100%)'
};
case 'top-start':
return {
top: `${Math.round(targetRect.top - offsetRect.top)}px`,
left: `${Math.round(targetRect.left - offsetRect.left)}px`,
transform: ''
};
case 'top-end':
return {
top: `${Math.round(targetRect.top - offsetRect.top)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width)}px`,
transform: 'translateX(-100%)'
};
case 'right-start':
return {
top: `${Math.round(targetRect.top - offsetRect.top)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width)}px`,
transform: 'translateX(-100%)'
};
case 'right-end':
return {
top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width)}px`,
transform: 'translateX(-100%) translateY(-100%)'
};
case 'left-start':
return {
top: `${Math.round(targetRect.top - offsetRect.top)}px`,
left: `${Math.round(targetRect.left - offsetRect.left)}px`,
transform: ''
};
case 'left-end':
return {
top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height)}px`,
left: `${Math.round(targetRect.left - offsetRect.left)}px`,
transform: 'translateY(-100%)'
};
case 'top':
return {
top: `${Math.round(targetRect.top - offsetRect.top)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width / 2)}px`,
transform: 'translateX(-50%)'
};
case 'right':
return {
top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height / 2)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width)}px`,
transform: 'translateX(-100%) translateY(-50%)'
};
case 'left':
return {
top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height / 2)}px`,
left: `${Math.round(targetRect.left - offsetRect.left)}px`,
transform: 'translateY(-50%)'
};
case 'bottom':
default:
return {
top: `${Math.round(targetRect.top - offsetRect.top + targetRect.height)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + targetRect.width / 2)}px`,
transform: 'translateX(-50%) translateY(-100%)'
};
}
}
switch (placement) {
case 'bottom-start':
return {
top: `${Math.round(targetRect.top -
offsetRect.top +
targetRect.height +
offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + offsetLeftToStandardPlacement)}px`,
transform: ''
};
case 'bottom-end':
return {
top: `${Math.round(targetRect.top -
offsetRect.top +
targetRect.height +
offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left -
offsetRect.left +
targetRect.width +
offsetLeftToStandardPlacement)}px`,
transform: 'translateX(-100%)'
};
case 'top-start':
return {
top: `${Math.round(targetRect.top - offsetRect.top + offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + offsetLeftToStandardPlacement)}px`,
transform: 'translateY(-100%)'
};
case 'top-end':
return {
top: `${Math.round(targetRect.top - offsetRect.top + offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left -
offsetRect.left +
targetRect.width +
offsetLeftToStandardPlacement)}px`,
transform: 'translateX(-100%) translateY(-100%)'
};
case 'right-start':
return {
top: `${Math.round(targetRect.top - offsetRect.top + offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left -
offsetRect.left +
targetRect.width +
offsetLeftToStandardPlacement)}px`,
transform: ''
};
case 'right-end':
return {
top: `${Math.round(targetRect.top -
offsetRect.top +
targetRect.height +
offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left -
offsetRect.left +
targetRect.width +
offsetLeftToStandardPlacement)}px`,
transform: 'translateY(-100%)'
};
case 'left-start':
return {
top: `${Math.round(targetRect.top - offsetRect.top + offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + offsetLeftToStandardPlacement)}px`,
transform: 'translateX(-100%)'
};
case 'left-end':
return {
top: `${Math.round(targetRect.top -
offsetRect.top +
targetRect.height +
offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + offsetLeftToStandardPlacement)}px`,
transform: 'translateX(-100%) translateY(-100%)'
};
case 'top':
return {
top: `${Math.round(targetRect.top - offsetRect.top + offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left -
offsetRect.left +
targetRect.width / 2 +
offsetLeftToStandardPlacement)}px`,
transform: 'translateY(-100%) translateX(-50%)'
};
case 'right':
return {
top: `${Math.round(targetRect.top -
offsetRect.top +
targetRect.height / 2 +
offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left -
offsetRect.left +
targetRect.width +
offsetLeftToStandardPlacement)}px`,
transform: 'translateY(-50%)'
};
case 'left':
return {
top: `${Math.round(targetRect.top -
offsetRect.top +
targetRect.height / 2 +
offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left - offsetRect.left + offsetLeftToStandardPlacement)}px`,
transform: 'translateY(-50%) translateX(-100%)'
};
case 'bottom':
default:
return {
top: `${Math.round(targetRect.top -
offsetRect.top +
targetRect.height +
offsetTopToStandardPlacement)}px`,
left: `${Math.round(targetRect.left -
offsetRect.left +
targetRect.width / 2 +
offsetLeftToStandardPlacement)}px`,
transform: 'translateX(-50%)'
};
}
}
;// ./node_modules/vueuc/es/binder/src/Follower.js
/* eslint-disable @typescript-eslint/no-non-null-assertion */
const style = shared_cssr_c([
shared_cssr_c('.v-binder-follower-container', {
position: 'absolute',
left: '0',
right: '0',
top: '0',
height: '0',
pointerEvents: 'none',
zIndex: 'auto'
}),
shared_cssr_c('.v-binder-follower-content', {
position: 'absolute',
zIndex: 'auto'
}, [
shared_cssr_c('> *', {
pointerEvents: 'all'
})
])
]);
/* harmony default export */ var Follower = (defineComponent({
name: 'Follower',
inheritAttrs: false,
props: {
show: Boolean,
enabled: {
type: Boolean,
default: undefined
},
placement: {
type: String,
default: 'bottom'
},
syncTrigger: {
type: Array,
default: ['resize', 'scroll']
},
to: [String, Object],
flip: {
type: Boolean,
default: true
},
internalShift: Boolean,
x: Number,
y: Number,
width: String,
minWidth: String,
containerClass: String,
teleportDisabled: Boolean,
zindexable: {
type: Boolean,
default: true
},
zIndex: Number,
overlap: Boolean
},
setup(props) {
const VBinder = runtime_core_esm_bundler_inject('VBinder');
const mergedEnabledRef = use_memo(() => {
return props.enabled !== undefined ? props.enabled : props.show;
});
const followerRef = ref(null);
const offsetContainerRef = ref(null);
const ensureListeners = () => {
const { syncTrigger } = props;
if (syncTrigger.includes('scroll')) {
VBinder.addScrollListener(syncPosition);
}
if (syncTrigger.includes('resize')) {
VBinder.addResizeListener(syncPosition);
}
};
const removeListeners = () => {
VBinder.removeScrollListener(syncPosition);
VBinder.removeResizeListener(syncPosition);
};
runtime_core_esm_bundler_onMounted(() => {
if (mergedEnabledRef.value) {
syncPosition();
ensureListeners();
}
});
const ssrAdapter = useSsrAdapter();
style.mount({
id: 'vueuc/binder',
head: true,
anchorMetaName: cssr_cssrAnchorMetaName,
ssr: ssrAdapter
});
runtime_core_esm_bundler_onBeforeUnmount(() => {
removeListeners();
});
onFontsReady(() => {
if (mergedEnabledRef.value) {
syncPosition();
}
});
const syncPosition = () => {
if (!mergedEnabledRef.value) {
return;
}
const follower = followerRef.value;
// sometimes watched props change before its dom is ready
// for example: show=false, x=undefined, y=undefined
// show=true, x=0, y=0
// will cause error
// I may optimize the watch start point later
if (follower === null)
return;
const target = VBinder.targetRef;
const { x, y, overlap } = props;
const targetRect = x !== undefined && y !== undefined
? getPointRect(x, y)
: getRect(target);
follower.style.setProperty('--v-target-width', `${Math.round(targetRect.width)}px`);
follower.style.setProperty('--v-target-height', `${Math.round(targetRect.height)}px`);
const { width, minWidth, placement, internalShift, flip } = props;
follower.setAttribute('v-placement', placement);
if (overlap) {
follower.setAttribute('v-overlap', '');
}
else {
follower.removeAttribute('v-overlap');
}
const { style } = follower;
if (width === 'target') {
style.width = `${targetRect.width}px`;
}
else if (width !== undefined) {
style.width = width;
}
else {
style.width = '';
}
if (minWidth === 'target') {
style.minWidth = `${targetRect.width}px`;
}
else if (minWidth !== undefined) {
style.minWidth = minWidth;
}
else {
style.minWidth = '';
}
const followerRect = getRect(follower);
const offsetContainerRect = getRect(offsetContainerRef.value);
const { left: offsetLeftToStandardPlacement, top: offsetTopToStandardPlacement, placement: properPlacement } = getPlacementAndOffsetOfFollower(placement, targetRect, followerRect, internalShift, flip, overlap);
const properTransformOrigin = getProperTransformOrigin(properPlacement, overlap);
const { left, top, transform } = getOffset(properPlacement, offsetContainerRect, targetRect, offsetTopToStandardPlacement, offsetLeftToStandardPlacement, overlap);
// we assume that the content size doesn't change after flip,
// nor we need to make sync logic more complex
follower.setAttribute('v-placement', properPlacement);
follower.style.setProperty('--v-offset-left', `${Math.round(offsetLeftToStandardPlacement)}px`);
follower.style.setProperty('--v-offset-top', `${Math.round(offsetTopToStandardPlacement)}px`);
follower.style.transform = `translateX(${left}) translateY(${top}) ${transform}`;
follower.style.setProperty('--v-transform-origin', properTransformOrigin);
follower.style.transformOrigin = properTransformOrigin;
};
runtime_core_esm_bundler_watch(mergedEnabledRef, (value) => {
if (value) {
ensureListeners();
syncOnNextTick();
}
else {
removeListeners();
}
});
const syncOnNextTick = () => {
nextTick()
.then(syncPosition)
.catch((e) => console.error(e));
};
[
'placement',
'x',
'y',
'internalShift',
'flip',
'width',
'overlap',
'minWidth'
].forEach((prop) => {
runtime_core_esm_bundler_watch(toRef(props, prop), syncPosition);
});
['teleportDisabled'].forEach((prop) => {
runtime_core_esm_bundler_watch(toRef(props, prop), syncOnNextTick);
});
runtime_core_esm_bundler_watch(toRef(props, 'syncTrigger'), (value) => {
if (!value.includes('resize')) {
VBinder.removeResizeListener(syncPosition);
}
else {
VBinder.addResizeListener(syncPosition);
}
if (!value.includes('scroll')) {
VBinder.removeScrollListener(syncPosition);
}
else {
VBinder.addScrollListener(syncPosition);
}
});
const isMountedRef = isMounted();
const mergedToRef = use_memo(() => {
const { to } = props;
if (to !== undefined)
return to;
if (isMountedRef.value) {
// TODO: find proper container
return undefined;
}
return undefined;
});
return {
VBinder,
mergedEnabled: mergedEnabledRef,
offsetContainerRef,
followerRef,
mergedTo: mergedToRef,
syncPosition
};
},
render() {
return h(src, {
show: this.show,
to: this.mergedTo,
disabled: this.teleportDisabled
}, {
default: () => {
var _a, _b;
const vNode = h('div', {
class: ['v-binder-follower-container', this.containerClass],
ref: 'offsetContainerRef'
}, [
h('div', {
class: 'v-binder-follower-content',
ref: 'followerRef'
}, (_b = (_a = this.$slots).default) === null || _b === void 0 ? void 0 : _b.call(_a))
]);
if (this.zindexable) {
return withDirectives(vNode, [
[
es_zindexable,
{
enabled: this.mergedEnabled,
zIndex: this.zIndex
}
]
]);
}
return vNode;
}
});
}
}));
;// ./node_modules/vooks/es/use-is-ios.js
const isIos = (typeof window === 'undefined'
? false
: /iPad|iPhone|iPod/.test(navigator.platform) ||
(navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1)) &&
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
!window.MSStream;
function useIsIos() {
return isIos;
}
;// ./node_modules/@juggle/resize-observer/lib/utils/resizeObservers.js
var resizeObservers = [];
;// ./node_modules/@juggle/resize-observer/lib/algorithms/hasActiveObservations.js
var hasActiveObservations = function () {
return resizeObservers.some(function (ro) { return ro.activeTargets.length > 0; });
};
;// ./node_modules/@juggle/resize-observer/lib/algorithms/hasSkippedObservations.js
var hasSkippedObservations = function () {
return resizeObservers.some(function (ro) { return ro.skippedTargets.length > 0; });
};
;// ./node_modules/@juggle/resize-observer/lib/algorithms/deliverResizeLoopError.js
var msg = 'ResizeObserver loop completed with undelivered notifications.';
var deliverResizeLoopError = function () {
var event;
if (typeof ErrorEvent === 'function') {
event = new ErrorEvent('error', {
message: msg
});
}
else {
event = document.createEvent('Event');
event.initEvent('error', false, false);
event.message = msg;
}
window.dispatchEvent(event);
};
;// ./node_modules/@juggle/resize-observer/lib/ResizeObserverBoxOptions.js
var ResizeObserverBoxOptions;
(function (ResizeObserverBoxOptions) {
ResizeObserverBoxOptions["BORDER_BOX"] = "border-box";
ResizeObserverBoxOptions["CONTENT_BOX"] = "content-box";
ResizeObserverBoxOptions["DEVICE_PIXEL_CONTENT_BOX"] = "device-pixel-content-box";
})(ResizeObserverBoxOptions || (ResizeObserverBoxOptions = {}));
;// ./node_modules/@juggle/resize-observer/lib/utils/freeze.js
var freeze = function (obj) { return Object.freeze(obj); };
;// ./node_modules/@juggle/resize-observer/lib/ResizeObserverSize.js
var ResizeObserverSize = (function () {
function ResizeObserverSize(inlineSize, blockSize) {
this.inlineSize = inlineSize;
this.blockSize = blockSize;
freeze(this);
}
return ResizeObserverSize;
}());
;// ./node_modules/@juggle/resize-observer/lib/DOMRectReadOnly.js
var DOMRectReadOnly = (function () {
function DOMRectReadOnly(x, y, width, height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
this.top = this.y;
this.left = this.x;
this.bottom = this.top + this.height;
this.right = this.left + this.width;
return freeze(this);
}
DOMRectReadOnly.prototype.toJSON = function () {
var _a = this, x = _a.x, y = _a.y, top = _a.top, right = _a.right, bottom = _a.bottom, left = _a.left, width = _a.width, height = _a.height;
return { x: x, y: y, top: top, right: right, bottom: bottom, left: left, width: width, height: height };
};
DOMRectReadOnly.fromRect = function (rectangle) {
return new DOMRectReadOnly(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
};
return DOMRectReadOnly;
}());
;// ./node_modules/@juggle/resize-observer/lib/utils/element.js
var isSVG = function (target) { return target instanceof SVGElement && 'getBBox' in target; };
var isHidden = function (target) {
if (isSVG(target)) {
var _a = target.getBBox(), width = _a.width, height = _a.height;
return !width && !height;
}
var _b = target, offsetWidth = _b.offsetWidth, offsetHeight = _b.offsetHeight;
return !(offsetWidth || offsetHeight || target.getClientRects().length);
};
var isElement = function (obj) {
var _a;
if (obj instanceof Element) {
return true;
}
var scope = (_a = obj === null || obj === void 0 ? void 0 : obj.ownerDocument) === null || _a === void 0 ? void 0 : _a.defaultView;
return !!(scope && obj instanceof scope.Element);
};
var isReplacedElement = function (target) {
switch (target.tagName) {
case 'INPUT':
if (target.type !== 'image') {
break;
}
case 'VIDEO':
case 'AUDIO':
case 'EMBED':
case 'OBJECT':
case 'CANVAS':
case 'IFRAME':
case 'IMG':
return true;
}
return false;
};
;// ./node_modules/@juggle/resize-observer/lib/utils/global.js
var global_global = typeof window !== 'undefined' ? window : {};
;// ./node_modules/@juggle/resize-observer/lib/algorithms/calculateBoxSize.js
var cache = new WeakMap();
var scrollRegexp = /auto|scroll/;
var verticalRegexp = /^tb|vertical/;
var IE = (/msie|trident/i).test(global_global.navigator && global_global.navigator.userAgent);
var parseDimension = function (pixel) { return parseFloat(pixel || '0'); };
var size = function (inlineSize, blockSize, switchSizes) {
if (inlineSize === void 0) { inlineSize = 0; }
if (blockSize === void 0) { blockSize = 0; }
if (switchSizes === void 0) { switchSizes = false; }
return new ResizeObserverSize((switchSizes ? blockSize : inlineSize) || 0, (switchSizes ? inlineSize : blockSize) || 0);
};
var zeroBoxes = freeze({
devicePixelContentBoxSize: size(),
borderBoxSize: size(),
contentBoxSize: size(),
contentRect: new DOMRectReadOnly(0, 0, 0, 0)
});
var calculateBoxSizes = function (target, forceRecalculation) {
if (forceRecalculation === void 0) { forceRecalculation = false; }
if (cache.has(target) && !forceRecalculation) {
return cache.get(target);
}
if (isHidden(target)) {
cache.set(target, zeroBoxes);
return zeroBoxes;
}
var cs = getComputedStyle(target);
var svg = isSVG(target) && target.ownerSVGElement && target.getBBox();
var removePadding = !IE && cs.boxSizing === 'border-box';
var switchSizes = verticalRegexp.test(cs.writingMode || '');
var canScrollVertically = !svg && scrollRegexp.test(cs.overflowY || '');
var canScrollHorizontally = !svg && scrollRegexp.test(cs.overflowX || '');
var paddingTop = svg ? 0 : parseDimension(cs.paddingTop);
var paddingRight = svg ? 0 : parseDimension(cs.paddingRight);
var paddingBottom = svg ? 0 : parseDimension(cs.paddingBottom);
var paddingLeft = svg ? 0 : parseDimension(cs.paddingLeft);
var borderTop = svg ? 0 : parseDimension(cs.borderTopWidth);
var borderRight = svg ? 0 : parseDimension(cs.borderRightWidth);
var borderBottom = svg ? 0 : parseDimension(cs.borderBottomWidth);
var borderLeft = svg ? 0 : parseDimension(cs.borderLeftWidth);
var horizontalPadding = paddingLeft + paddingRight;
var verticalPadding = paddingTop + paddingBottom;
var horizontalBorderArea = borderLeft + borderRight;
var verticalBorderArea = borderTop + borderBottom;
var horizontalScrollbarThickness = !canScrollHorizontally ? 0 : target.offsetHeight - verticalBorderArea - target.clientHeight;
var verticalScrollbarThickness = !canScrollVertically ? 0 : target.offsetWidth - horizontalBorderArea - target.clientWidth;
var widthReduction = removePadding ? horizontalPadding + horizontalBorderArea : 0;
var heightReduction = removePadding ? verticalPadding + verticalBorderArea : 0;
var contentWidth = svg ? svg.width : parseDimension(cs.width) - widthReduction - verticalScrollbarThickness;
var contentHeight = svg ? svg.height : parseDimension(cs.height) - heightReduction - horizontalScrollbarThickness;
var borderBoxWidth = contentWidth + horizontalPadding + verticalScrollbarThickness + horizontalBorderArea;
var borderBoxHeight = contentHeight + verticalPadding + horizontalScrollbarThickness + verticalBorderArea;
var boxes = freeze({
devicePixelContentBoxSize: size(Math.round(contentWidth * devicePixelRatio), Math.round(contentHeight * devicePixelRatio), switchSizes),
borderBoxSize: size(borderBoxWidth, borderBoxHeight, switchSizes),
contentBoxSize: size(contentWidth, contentHeight, switchSizes),
contentRect: new DOMRectReadOnly(paddingLeft, paddingTop, contentWidth, contentHeight)
});
cache.set(target, boxes);
return boxes;
};
var calculateBoxSize = function (target, observedBox, forceRecalculation) {
var _a = calculateBoxSizes(target, forceRecalculation), borderBoxSize = _a.borderBoxSize, contentBoxSize = _a.contentBoxSize, devicePixelContentBoxSize = _a.devicePixelContentBoxSize;
switch (observedBox) {
case ResizeObserverBoxOptions.DEVICE_PIXEL_CONTENT_BOX:
return devicePixelContentBoxSize;
case ResizeObserverBoxOptions.BORDER_BOX:
return borderBoxSize;
default:
return contentBoxSize;
}
};
;// ./node_modules/@juggle/resize-observer/lib/ResizeObserverEntry.js
var ResizeObserverEntry = (function () {
function ResizeObserverEntry(target) {
var boxes = calculateBoxSizes(target);
this.target = target;
this.contentRect = boxes.contentRect;
this.borderBoxSize = freeze([boxes.borderBoxSize]);
this.contentBoxSize = freeze([boxes.contentBoxSize]);
this.devicePixelContentBoxSize = freeze([boxes.devicePixelContentBoxSize]);
}
return ResizeObserverEntry;
}());
;// ./node_modules/@juggle/resize-observer/lib/algorithms/calculateDepthForNode.js
var calculateDepthForNode = function (node) {
if (isHidden(node)) {
return Infinity;
}
var depth = 0;
var parent = node.parentNode;
while (parent) {
depth += 1;
parent = parent.parentNode;
}
return depth;
};
;// ./node_modules/@juggle/resize-observer/lib/algorithms/broadcastActiveObservations.js
var broadcastActiveObservations = function () {
var shallowestDepth = Infinity;
var callbacks = [];
resizeObservers.forEach(function processObserver(ro) {
if (ro.activeTargets.length === 0) {
return;
}
var entries = [];
ro.activeTargets.forEach(function processTarget(ot) {
var entry = new ResizeObserverEntry(ot.target);
var targetDepth = calculateDepthForNode(ot.target);
entries.push(entry);
ot.lastReportedSize = calculateBoxSize(ot.target, ot.observedBox);
if (targetDepth < shallowestDepth) {
shallowestDepth = targetDepth;
}
});
callbacks.push(function resizeObserverCallback() {
ro.callback.call(ro.observer, entries, ro.observer);
});
ro.activeTargets.splice(0, ro.activeTargets.length);
});
for (var _i = 0, callbacks_1 = callbacks; _i < callbacks_1.length; _i++) {
var callback = callbacks_1[_i];
callback();
}
return shallowestDepth;
};
;// ./node_modules/@juggle/resize-observer/lib/algorithms/gatherActiveObservationsAtDepth.js
var gatherActiveObservationsAtDepth = function (depth) {
resizeObservers.forEach(function processObserver(ro) {
ro.activeTargets.splice(0, ro.activeTargets.length);
ro.skippedTargets.splice(0, ro.skippedTargets.length);
ro.observationTargets.forEach(function processTarget(ot) {
if (ot.isActive()) {
if (calculateDepthForNode(ot.target) > depth) {
ro.activeTargets.push(ot);
}
else {
ro.skippedTargets.push(ot);
}
}
});
});
};
;// ./node_modules/@juggle/resize-observer/lib/utils/process.js
var process_process = function () {
var depth = 0;
gatherActiveObservationsAtDepth(depth);
while (hasActiveObservations()) {
depth = broadcastActiveObservations();
gatherActiveObservationsAtDepth(depth);
}
if (hasSkippedObservations()) {
deliverResizeLoopError();
}
return depth > 0;
};
;// ./node_modules/@juggle/resize-observer/lib/utils/queueMicroTask.js
var queueMicroTask_trigger;
var callbacks = [];
var notify = function () { return callbacks.splice(0).forEach(function (cb) { return cb(); }); };
var queueMicroTask = function (callback) {
if (!queueMicroTask_trigger) {
var toggle_1 = 0;
var el_1 = document.createTextNode('');
var config = { characterData: true };
new MutationObserver(function () { return notify(); }).observe(el_1, config);
queueMicroTask_trigger = function () { el_1.textContent = "".concat(toggle_1 ? toggle_1-- : toggle_1++); };
}
callbacks.push(callback);
queueMicroTask_trigger();
};
;// ./node_modules/@juggle/resize-observer/lib/utils/queueResizeObserver.js
var queueResizeObserver = function (cb) {
queueMicroTask(function ResizeObserver() {
requestAnimationFrame(cb);
});
};
;// ./node_modules/@juggle/resize-observer/lib/utils/scheduler.js
var watching = 0;
var isWatching = function () { return !!watching; };
var CATCH_PERIOD = 250;
var observerConfig = { attributes: true, characterData: true, childList: true, subtree: true };
var events = [
'resize',
'load',
'transitionend',
'animationend',
'animationstart',
'animationiteration',
'keyup',
'keydown',
'mouseup',
'mousedown',
'mouseover',
'mouseout',
'blur',
'focus'
];
var time = function (timeout) {
if (timeout === void 0) { timeout = 0; }
return Date.now() + timeout;
};
var scheduled = false;
var Scheduler = (function () {
function Scheduler() {
var _this = this;
this.stopped = true;
this.listener = function () { return _this.schedule(); };
}
Scheduler.prototype.run = function (timeout) {
var _this = this;
if (timeout === void 0) { timeout = CATCH_PERIOD; }
if (scheduled) {
return;
}
scheduled = true;
var until = time(timeout);
queueResizeObserver(function () {
var elementsHaveResized = false;
try {
elementsHaveResized = process_process();
}
finally {
scheduled = false;
timeout = until - time();
if (!isWatching()) {
return;
}
if (elementsHaveResized) {
_this.run(1000);
}
else if (timeout > 0) {
_this.run(timeout);
}
else {
_this.start();
}
}
});
};
Scheduler.prototype.schedule = function () {
this.stop();
this.run();
};
Scheduler.prototype.observe = function () {
var _this = this;
var cb = function () { return _this.observer && _this.observer.observe(document.body, observerConfig); };
document.body ? cb() : global_global.addEventListener('DOMContentLoaded', cb);
};
Scheduler.prototype.start = function () {
var _this = this;
if (this.stopped) {
this.stopped = false;
this.observer = new MutationObserver(this.listener);
this.observe();
events.forEach(function (name) { return global_global.addEventListener(name, _this.listener, true); });
}
};
Scheduler.prototype.stop = function () {
var _this = this;
if (!this.stopped) {
this.observer && this.observer.disconnect();
events.forEach(function (name) { return global_global.removeEventListener(name, _this.listener, true); });
this.stopped = true;
}
};
return Scheduler;
}());
var scheduler = new Scheduler();
var updateCount = function (n) {
!watching && n > 0 && scheduler.start();
watching += n;
!watching && scheduler.stop();
};
;// ./node_modules/@juggle/resize-observer/lib/ResizeObservation.js
var skipNotifyOnElement = function (target) {
return !isSVG(target)
&& !isReplacedElement(target)
&& getComputedStyle(target).display === 'inline';
};
var ResizeObservation = (function () {
function ResizeObservation(target, observedBox) {
this.target = target;
this.observedBox = observedBox || ResizeObserverBoxOptions.CONTENT_BOX;
this.lastReportedSize = {
inlineSize: 0,
blockSize: 0
};
}
ResizeObservation.prototype.isActive = function () {
var size = calculateBoxSize(this.target, this.observedBox, true);
if (skipNotifyOnElement(this.target)) {
this.lastReportedSize = size;
}
if (this.lastReportedSize.inlineSize !== size.inlineSize
|| this.lastReportedSize.blockSize !== size.blockSize) {
return true;
}
return false;
};
return ResizeObservation;
}());
;// ./node_modules/@juggle/resize-observer/lib/ResizeObserverDetail.js
var ResizeObserverDetail = (function () {
function ResizeObserverDetail(resizeObserver, callback) {
this.activeTargets = [];
this.skippedTargets = [];
this.observationTargets = [];
this.observer = resizeObserver;
this.callback = callback;
}
return ResizeObserverDetail;
}());
;// ./node_modules/@juggle/resize-observer/lib/ResizeObserverController.js
var observerMap = new WeakMap();
var getObservationIndex = function (observationTargets, target) {
for (var i = 0; i < observationTargets.length; i += 1) {
if (observationTargets[i].target === target) {
return i;
}
}
return -1;
};
var ResizeObserverController = (function () {
function ResizeObserverController() {
}
ResizeObserverController.connect = function (resizeObserver, callback) {
var detail = new ResizeObserverDetail(resizeObserver, callback);
observerMap.set(resizeObserver, detail);
};
ResizeObserverController.observe = function (resizeObserver, target, options) {
var detail = observerMap.get(resizeObserver);
var firstObservation = detail.observationTargets.length === 0;
if (getObservationIndex(detail.observationTargets, target) < 0) {
firstObservation && resizeObservers.push(detail);
detail.observationTargets.push(new ResizeObservation(target, options && options.box));
updateCount(1);
scheduler.schedule();
}
};
ResizeObserverController.unobserve = function (resizeObserver, target) {
var detail = observerMap.get(resizeObserver);
var index = getObservationIndex(detail.observationTargets, target);
var lastObservation = detail.observationTargets.length === 1;
if (index >= 0) {
lastObservation && resizeObservers.splice(resizeObservers.indexOf(detail), 1);
detail.observationTargets.splice(index, 1);
updateCount(-1);
}
};
ResizeObserverController.disconnect = function (resizeObserver) {
var _this = this;
var detail = observerMap.get(resizeObserver);
detail.observationTargets.slice().forEach(function (ot) { return _this.unobserve(resizeObserver, ot.target); });
detail.activeTargets.splice(0, detail.activeTargets.length);
};
return ResizeObserverController;
}());
;// ./node_modules/@juggle/resize-observer/lib/ResizeObserver.js
var ResizeObserver = (function () {
function ResizeObserver(callback) {
if (arguments.length === 0) {
throw new TypeError("Failed to construct 'ResizeObserver': 1 argument required, but only 0 present.");
}
if (typeof callback !== 'function') {
throw new TypeError("Failed to construct 'ResizeObserver': The callback provided as parameter 1 is not a function.");
}
ResizeObserverController.connect(this, callback);
}
ResizeObserver.prototype.observe = function (target, options) {
if (arguments.length === 0) {
throw new TypeError("Failed to execute 'observe' on 'ResizeObserver': 1 argument required, but only 0 present.");
}
if (!isElement(target)) {
throw new TypeError("Failed to execute 'observe' on 'ResizeObserver': parameter 1 is not of type 'Element");
}
ResizeObserverController.observe(this, target, options);
};
ResizeObserver.prototype.unobserve = function (target) {
if (arguments.length === 0) {
throw new TypeError("Failed to execute 'unobserve' on 'ResizeObserver': 1 argument required, but only 0 present.");
}
if (!isElement(target)) {
throw new TypeError("Failed to execute 'unobserve' on 'ResizeObserver': parameter 1 is not of type 'Element");
}
ResizeObserverController.unobserve(this, target);
};
ResizeObserver.prototype.disconnect = function () {
ResizeObserverController.disconnect(this);
};
ResizeObserver.toString = function () {
return 'function ResizeObserver () { [polyfill code] }';
};
return ResizeObserver;
}());
;// ./node_modules/@juggle/resize-observer/lib/exports/resize-observer.js
;// ./node_modules/vueuc/es/resize-observer/src/delegate.js
class ResizeObserverDelegate {
constructor() {
this.handleResize = this.handleResize.bind(this);
this.observer = new ((typeof window !== 'undefined' &&
window.ResizeObserver) ||
ResizeObserver)(this.handleResize);
this.elHandlersMap = new Map();
}
handleResize(entries) {
for (const entry of entries) {
const handler = this.elHandlersMap.get(entry.target);
if (handler !== undefined) {
handler(entry);
}
}
}
registerHandler(el, handler) {
this.elHandlersMap.set(el, handler);
this.observer.observe(el);
}
unregisterHandler(el) {
if (!this.elHandlersMap.has(el)) {
return;
}
this.elHandlersMap.delete(el);
this.observer.unobserve(el);
}
}
/* harmony default export */ var delegate = (new ResizeObserverDelegate());
;// ./node_modules/vueuc/es/shared/warn.js
function shared_warn_warn(location, message) {
console.error(`[vueuc/${location}]: ${message}`);
}
;// ./node_modules/vueuc/es/resize-observer/src/VResizeObserver.js
/* harmony default export */ var VResizeObserver = (defineComponent({
name: 'ResizeObserver',
props: {
onResize: Function
},
setup(props) {
let registered = false;
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const proxy = runtime_core_esm_bundler_getCurrentInstance().proxy;
function handleResize(entry) {
const { onResize } = props;
if (onResize !== undefined)
onResize(entry);
}
runtime_core_esm_bundler_onMounted(() => {
const el = proxy.$el;
if (el === undefined) {
shared_warn_warn('resize-observer', '$el does not exist.');
return;
}
if (el.nextElementSibling !== el.nextSibling) {
if (el.nodeType === 3 && el.nodeValue !== '') {
shared_warn_warn('resize-observer', '$el can not be observed (it may be a text node).');
return;
}
}
if (el.nextElementSibling !== null) {
delegate.registerHandler(el.nextElementSibling, handleResize);
registered = true;
}
});
runtime_core_esm_bundler_onBeforeUnmount(() => {
if (registered) {
delegate.unregisterHandler(proxy.$el.nextElementSibling);
}
});
},
render() {
return renderSlot(this.$slots, 'default');
}
}));
;// ./node_modules/naive-ui/es/_utils/composable/use-reactivated.mjs
function useReactivated(callback) {
const isDeactivatedRef = {
isDeactivated: false
};
let activateStateInitialized = false;
onActivated(() => {
isDeactivatedRef.isDeactivated = false;
if (!activateStateInitialized) {
activateStateInitialized = true;
return;
}
callback();
});
onDeactivated(() => {
isDeactivatedRef.isDeactivated = true;
if (!activateStateInitialized) {
activateStateInitialized = true;
}
});
return isDeactivatedRef;
}
;// ./node_modules/naive-ui/es/_utils/css/rtl-inset.mjs
function rtlInset(inset) {
const {
left,
right,
top,
bottom
} = getMargin(inset);
return `${top} ${left} ${bottom} ${right}`;
}
;// ./node_modules/naive-ui/es/_utils/vue/wrapper.mjs
const Wrapper = defineComponent({
render() {
var _a, _b;
return (_b = (_a = this.$slots).default) === null || _b === void 0 ? void 0 : _b.call(_a);
}
});
;// ./node_modules/naive-ui/es/_internal/scrollbar/styles/common.mjs
const commonVars = {
railInsetHorizontalBottom: 'auto 2px 4px 2px',
railInsetHorizontalTop: '4px 2px auto 2px',
railInsetVerticalRight: '2px 4px 2px auto',
railInsetVerticalLeft: '2px auto 2px 4px',
railColor: 'transparent'
};
;// ./node_modules/naive-ui/es/_internal/scrollbar/styles/light.mjs
function scrollbar_styles_light_self(vars) {
const {
scrollbarColor,
scrollbarColorHover,
scrollbarHeight,
scrollbarWidth,
scrollbarBorderRadius
} = vars;
return Object.assign(Object.assign({}, commonVars), {
height: scrollbarHeight,
width: scrollbarWidth,
borderRadius: scrollbarBorderRadius,
color: scrollbarColor,
colorHover: scrollbarColorHover
});
}
const scrollbarLight = {
name: 'Scrollbar',
common: light,
self: scrollbar_styles_light_self
};
/* harmony default export */ var scrollbar_styles_light = (scrollbarLight);
;// ./node_modules/naive-ui/es/_styles/transitions/fade-in.cssr.mjs
const {
cubicBezierEaseInOut: fade_in_cssr_cubicBezierEaseInOut
} = _common;
function fadeInTransition({
name = 'fade-in',
enterDuration = '0.2s',
leaveDuration = '0.2s',
enterCubicBezier = fade_in_cssr_cubicBezierEaseInOut,
leaveCubicBezier = fade_in_cssr_cubicBezierEaseInOut
} = {}) {
return [cssr_c(`&.${name}-transition-enter-active`, {
transition: `all ${enterDuration} ${enterCubicBezier}!important`
}), cssr_c(`&.${name}-transition-leave-active`, {
transition: `all ${leaveDuration} ${leaveCubicBezier}!important`
}), cssr_c(`&.${name}-transition-enter-from, &.${name}-transition-leave-to`, {
opacity: 0
}), cssr_c(`&.${name}-transition-leave-from, &.${name}-transition-enter-to`, {
opacity: 1
})];
}
;// ./node_modules/naive-ui/es/_internal/scrollbar/src/styles/index.cssr.mjs
// vars:
// --n-scrollbar-bezier
// --n-scrollbar-color
// --n-scrollbar-color-hover
// --n-scrollbar-width
// --n-scrollbar-height
// --n-scrollbar-border-radius
// --n-scrollbar-rail-inset-horizontal
// --n-scrollbar-rail-inset-vertical
// --n-scrollbar-rail-color
/* harmony default export */ var scrollbar_src_styles_index_cssr = (cB('scrollbar', `
overflow: hidden;
position: relative;
z-index: auto;
height: 100%;
width: 100%;
`, [cssr_c('>', [cB('scrollbar-container', `
width: 100%;
overflow: scroll;
height: 100%;
min-height: inherit;
max-height: inherit;
scrollbar-width: none;
`, [cssr_c('&::-webkit-scrollbar, &::-webkit-scrollbar-track-piece, &::-webkit-scrollbar-thumb', `
width: 0;
height: 0;
display: none;
`), cssr_c('>', [
// We can't set overflow hidden since it affects positioning.
cB('scrollbar-content', `
box-sizing: border-box;
min-width: 100%;
`)])])]), cssr_c('>, +', [cB('scrollbar-rail', `
position: absolute;
pointer-events: none;
user-select: none;
background: var(--n-scrollbar-rail-color);
-webkit-user-select: none;
`, [cM('horizontal', `
height: var(--n-scrollbar-height);
`, [cssr_c('>', [cE('scrollbar', `
height: var(--n-scrollbar-height);
border-radius: var(--n-scrollbar-border-radius);
right: 0;
`)])]), cM('horizontal--top', `
top: var(--n-scrollbar-rail-top-horizontal-top);
right: var(--n-scrollbar-rail-right-horizontal-top);
bottom: var(--n-scrollbar-rail-bottom-horizontal-top);
left: var(--n-scrollbar-rail-left-horizontal-top);
`), cM('horizontal--bottom', `
top: var(--n-scrollbar-rail-top-horizontal-bottom);
right: var(--n-scrollbar-rail-right-horizontal-bottom);
bottom: var(--n-scrollbar-rail-bottom-horizontal-bottom);
left: var(--n-scrollbar-rail-left-horizontal-bottom);
`), cM('vertical', `
width: var(--n-scrollbar-width);
`, [cssr_c('>', [cE('scrollbar', `
width: var(--n-scrollbar-width);
border-radius: var(--n-scrollbar-border-radius);
bottom: 0;
`)])]), cM('vertical--left', `
top: var(--n-scrollbar-rail-top-vertical-left);
right: var(--n-scrollbar-rail-right-vertical-left);
bottom: var(--n-scrollbar-rail-bottom-vertical-left);
left: var(--n-scrollbar-rail-left-vertical-left);
`), cM('vertical--right', `
top: var(--n-scrollbar-rail-top-vertical-right);
right: var(--n-scrollbar-rail-right-vertical-right);
bottom: var(--n-scrollbar-rail-bottom-vertical-right);
left: var(--n-scrollbar-rail-left-vertical-right);
`), cM('disabled', [cssr_c('>', [cE('scrollbar', 'pointer-events: none;')])]), cssr_c('>', [cE('scrollbar', `
z-index: 1;
position: absolute;
cursor: pointer;
pointer-events: all;
background-color: var(--n-scrollbar-color);
transition: background-color .2s var(--n-scrollbar-bezier);
`, [fadeInTransition(), cssr_c('&:hover', 'background-color: var(--n-scrollbar-color-hover);')])])])])]));
;// ./node_modules/naive-ui/es/_internal/scrollbar/src/Scrollbar.mjs
const scrollbarProps = Object.assign(Object.assign({}, use_theme.props), {
duration: {
type: Number,
default: 0
},
scrollable: {
type: Boolean,
default: true
},
xScrollable: Boolean,
trigger: {
type: String,
default: 'hover'
},
useUnifiedContainer: Boolean,
triggerDisplayManually: Boolean,
// If container is set, resize observer won't not attached
container: Function,
content: Function,
containerClass: String,
containerStyle: [String, Object],
contentClass: [String, Array],
contentStyle: [String, Object],
horizontalRailStyle: [String, Object],
verticalRailStyle: [String, Object],
onScroll: Function,
onWheel: Function,
onResize: Function,
internalOnUpdateScrollLeft: Function,
internalHoistYRail: Boolean,
yPlacement: {
type: String,
default: 'right'
},
xPlacement: {
type: String,
default: 'bottom'
}
});
const Scrollbar = defineComponent({
name: 'Scrollbar',
props: scrollbarProps,
inheritAttrs: false,
setup(props) {
const {
mergedClsPrefixRef,
inlineThemeDisabled,
mergedRtlRef
} = useConfig(props);
const rtlEnabledRef = useRtl('Scrollbar', mergedRtlRef, mergedClsPrefixRef);
// dom ref
const wrapperRef = ref(null);
const containerRef = ref(null);
const contentRef = ref(null);
const yRailRef = ref(null);
const xRailRef = ref(null);
// data ref
const contentHeightRef = ref(null);
const contentWidthRef = ref(null);
const containerHeightRef = ref(null);
const containerWidthRef = ref(null);
const yRailSizeRef = ref(null);
const xRailSizeRef = ref(null);
const containerScrollTopRef = ref(0);
const containerScrollLeftRef = ref(0);
const isShowXBarRef = ref(false);
const isShowYBarRef = ref(false);
let yBarPressed = false;
let xBarPressed = false;
let xBarVanishTimerId;
let yBarVanishTimerId;
let memoYTop = 0;
let memoXLeft = 0;
let memoMouseX = 0;
let memoMouseY = 0;
const isIos = useIsIos();
const themeRef = use_theme('Scrollbar', '-scrollbar', scrollbar_src_styles_index_cssr, scrollbar_styles_light, props, mergedClsPrefixRef);
const yBarSizeRef = runtime_core_esm_bundler_computed(() => {
const {
value: containerHeight
} = containerHeightRef;
const {
value: contentHeight
} = contentHeightRef;
const {
value: yRailSize
} = yRailSizeRef;
if (containerHeight === null || contentHeight === null || yRailSize === null) {
return 0;
} else {
return Math.min(containerHeight, yRailSize * containerHeight / contentHeight + depx(themeRef.value.self.width) * 1.5);
}
});
const yBarSizePxRef = runtime_core_esm_bundler_computed(() => {
return `${yBarSizeRef.value}px`;
});
const xBarSizeRef = runtime_core_esm_bundler_computed(() => {
const {
value: containerWidth
} = containerWidthRef;
const {
value: contentWidth
} = contentWidthRef;
const {
value: xRailSize
} = xRailSizeRef;
if (containerWidth === null || contentWidth === null || xRailSize === null) {
return 0;
} else {
return xRailSize * containerWidth / contentWidth + depx(themeRef.value.self.height) * 1.5;
}
});
const xBarSizePxRef = runtime_core_esm_bundler_computed(() => {
return `${xBarSizeRef.value}px`;
});
const yBarTopRef = runtime_core_esm_bundler_computed(() => {
const {
value: containerHeight
} = containerHeightRef;
const {
value: containerScrollTop
} = containerScrollTopRef;
const {
value: contentHeight
} = contentHeightRef;
const {
value: yRailSize
} = yRailSizeRef;
if (containerHeight === null || contentHeight === null || yRailSize === null) {
return 0;
} else {
const heightDiff = contentHeight - containerHeight;
if (!heightDiff) return 0;
return containerScrollTop / heightDiff * (yRailSize - yBarSizeRef.value);
}
});
const yBarTopPxRef = runtime_core_esm_bundler_computed(() => {
return `${yBarTopRef.value}px`;
});
const xBarLeftRef = runtime_core_esm_bundler_computed(() => {
const {
value: containerWidth
} = containerWidthRef;
const {
value: containerScrollLeft
} = containerScrollLeftRef;
const {
value: contentWidth
} = contentWidthRef;
const {
value: xRailSize
} = xRailSizeRef;
if (containerWidth === null || contentWidth === null || xRailSize === null) {
return 0;
} else {
const widthDiff = contentWidth - containerWidth;
if (!widthDiff) return 0;
return containerScrollLeft / widthDiff * (xRailSize - xBarSizeRef.value);
}
});
const xBarLeftPxRef = runtime_core_esm_bundler_computed(() => {
return `${xBarLeftRef.value}px`;
});
const needYBarRef = runtime_core_esm_bundler_computed(() => {
const {
value: containerHeight
} = containerHeightRef;
const {
value: contentHeight
} = contentHeightRef;
return containerHeight !== null && contentHeight !== null && contentHeight > containerHeight;
});
const needXBarRef = runtime_core_esm_bundler_computed(() => {
const {
value: containerWidth
} = containerWidthRef;
const {
value: contentWidth
} = contentWidthRef;
return containerWidth !== null && contentWidth !== null && contentWidth > containerWidth;
});
const mergedShowXBarRef = runtime_core_esm_bundler_computed(() => {
const {
trigger
} = props;
return trigger === 'none' || isShowXBarRef.value;
});
const mergedShowYBarRef = runtime_core_esm_bundler_computed(() => {
const {
trigger
} = props;
return trigger === 'none' || isShowYBarRef.value;
});
const mergedContainerRef = runtime_core_esm_bundler_computed(() => {
const {
container
} = props;
if (container) return container();
return containerRef.value;
});
const mergedContentRef = runtime_core_esm_bundler_computed(() => {
const {
content
} = props;
if (content) return content();
return contentRef.value;
});
const scrollTo = (options, y) => {
if (!props.scrollable) return;
if (typeof options === 'number') {
scrollToPosition(options, y !== null && y !== void 0 ? y : 0, 0, false, 'auto');
return;
}
const {
left,
top,
index,
elSize,
position,
behavior,
el,
debounce = true
} = options;
if (left !== undefined || top !== undefined) {
scrollToPosition(left !== null && left !== void 0 ? left : 0, top !== null && top !== void 0 ? top : 0, 0, false, behavior);
}
if (el !== undefined) {
scrollToPosition(0, el.offsetTop, el.offsetHeight, debounce, behavior);
} else if (index !== undefined && elSize !== undefined) {
scrollToPosition(0, index * elSize, elSize, debounce, behavior);
} else if (position === 'bottom') {
scrollToPosition(0, Number.MAX_SAFE_INTEGER, 0, false, behavior);
} else if (position === 'top') {
scrollToPosition(0, 0, 0, false, behavior);
}
};
const activateState = useReactivated(() => {
// Only restore for builtin container & content
if (!props.container) {
// remount
scrollTo({
top: containerScrollTopRef.value,
left: containerScrollLeftRef.value
});
}
});
// methods
const handleContentResize = () => {
if (activateState.isDeactivated) return;
sync();
};
const handleContainerResize = e => {
if (activateState.isDeactivated) return;
const {
onResize
} = props;
if (onResize) onResize(e);
sync();
};
const scrollBy = (options, y) => {
if (!props.scrollable) return;
const {
value: container
} = mergedContainerRef;
if (!container) return;
if (typeof options === 'object') {
container.scrollBy(options);
} else {
container.scrollBy(options, y || 0);
}
};
function scrollToPosition(left, top, elSize, debounce, behavior) {
const {
value: container
} = mergedContainerRef;
if (!container) return;
if (debounce) {
const {
scrollTop,
offsetHeight
} = container;
if (top > scrollTop) {
if (top + elSize <= scrollTop + offsetHeight) {
// do nothing
} else {
container.scrollTo({
left,
top: top + elSize - offsetHeight,
behavior
});
}
return;
}
}
container.scrollTo({
left,
top,
behavior
});
}
function handleMouseEnterWrapper() {
showXBar();
showYBar();
sync();
}
function handleMouseLeaveWrapper() {
hideBar();
}
function hideBar() {
hideYBar();
hideXBar();
}
function hideYBar() {
if (yBarVanishTimerId !== undefined) {
window.clearTimeout(yBarVanishTimerId);
}
yBarVanishTimerId = window.setTimeout(() => {
isShowYBarRef.value = false;
}, props.duration);
}
function hideXBar() {
if (xBarVanishTimerId !== undefined) {
window.clearTimeout(xBarVanishTimerId);
}
xBarVanishTimerId = window.setTimeout(() => {
isShowXBarRef.value = false;
}, props.duration);
}
function showXBar() {
if (xBarVanishTimerId !== undefined) {
window.clearTimeout(xBarVanishTimerId);
}
isShowXBarRef.value = true;
}
function showYBar() {
if (yBarVanishTimerId !== undefined) {
window.clearTimeout(yBarVanishTimerId);
}
isShowYBarRef.value = true;
}
function handleScroll(e) {
const {
onScroll
} = props;
if (onScroll) onScroll(e);
syncScrollState();
}
function syncScrollState() {
// only collect scroll state, do not trigger any dom event
const {
value: container
} = mergedContainerRef;
if (container) {
containerScrollTopRef.value = container.scrollTop;
containerScrollLeftRef.value = container.scrollLeft * ((rtlEnabledRef === null || rtlEnabledRef === void 0 ? void 0 : rtlEnabledRef.value) ? -1 : 1);
}
}
function syncPositionState() {
// only collect position state, do not trigger any dom event
// Don't use getClientBoundingRect because element may be scale transformed
const {
value: content
} = mergedContentRef;
if (content) {
contentHeightRef.value = content.offsetHeight;
contentWidthRef.value = content.offsetWidth;
}
const {
value: container
} = mergedContainerRef;
if (container) {
containerHeightRef.value = container.offsetHeight;
containerWidthRef.value = container.offsetWidth;
}
const {
value: xRailEl
} = xRailRef;
const {
value: yRailEl
} = yRailRef;
if (xRailEl) {
xRailSizeRef.value = xRailEl.offsetWidth;
}
if (yRailEl) {
yRailSizeRef.value = yRailEl.offsetHeight;
}
}
/**
* Sometimes there's only one element that we can scroll,
* For example for textarea, there won't be a content element.
*/
function syncUnifiedContainer() {
const {
value: container
} = mergedContainerRef;
if (container) {
containerScrollTopRef.value = container.scrollTop;
containerScrollLeftRef.value = container.scrollLeft * ((rtlEnabledRef === null || rtlEnabledRef === void 0 ? void 0 : rtlEnabledRef.value) ? -1 : 1);
containerHeightRef.value = container.offsetHeight;
containerWidthRef.value = container.offsetWidth;
contentHeightRef.value = container.scrollHeight;
contentWidthRef.value = container.scrollWidth;
}
const {
value: xRailEl
} = xRailRef;
const {
value: yRailEl
} = yRailRef;
if (xRailEl) {
xRailSizeRef.value = xRailEl.offsetWidth;
}
if (yRailEl) {
yRailSizeRef.value = yRailEl.offsetHeight;
}
}
function sync() {
if (!props.scrollable) return;
if (props.useUnifiedContainer) {
syncUnifiedContainer();
} else {
syncPositionState();
syncScrollState();
}
}
function isMouseUpAway(e) {
var _a;
return !((_a = wrapperRef.value) === null || _a === void 0 ? void 0 : _a.contains(getPreciseEventTarget(e)));
}
function handleXScrollMouseDown(e) {
e.preventDefault();
e.stopPropagation();
xBarPressed = true;
on('mousemove', window, handleXScrollMouseMove, true);
on('mouseup', window, handleXScrollMouseUp, true);
memoXLeft = containerScrollLeftRef.value;
memoMouseX = (rtlEnabledRef === null || rtlEnabledRef === void 0 ? void 0 : rtlEnabledRef.value) ? window.innerWidth - e.clientX : e.clientX;
}
function handleXScrollMouseMove(e) {
if (!xBarPressed) return;
if (xBarVanishTimerId !== undefined) {
window.clearTimeout(xBarVanishTimerId);
}
if (yBarVanishTimerId !== undefined) {
window.clearTimeout(yBarVanishTimerId);
}
const {
value: containerWidth
} = containerWidthRef;
const {
value: contentWidth
} = contentWidthRef;
const {
value: xBarSize
} = xBarSizeRef;
if (containerWidth === null || contentWidth === null) return;
const dX = (rtlEnabledRef === null || rtlEnabledRef === void 0 ? void 0 : rtlEnabledRef.value) ? window.innerWidth - e.clientX - memoMouseX : e.clientX - memoMouseX;
const dScrollLeft = dX * (contentWidth - containerWidth) / (containerWidth - xBarSize);
const toScrollLeftUpperBound = contentWidth - containerWidth;
let toScrollLeft = memoXLeft + dScrollLeft;
toScrollLeft = Math.min(toScrollLeftUpperBound, toScrollLeft);
toScrollLeft = Math.max(toScrollLeft, 0);
const {
value: container
} = mergedContainerRef;
if (container) {
container.scrollLeft = toScrollLeft * ((rtlEnabledRef === null || rtlEnabledRef === void 0 ? void 0 : rtlEnabledRef.value) ? -1 : 1);
const {
internalOnUpdateScrollLeft
} = props;
if (internalOnUpdateScrollLeft) internalOnUpdateScrollLeft(toScrollLeft);
}
}
function handleXScrollMouseUp(e) {
e.preventDefault();
e.stopPropagation();
off('mousemove', window, handleXScrollMouseMove, true);
off('mouseup', window, handleXScrollMouseUp, true);
xBarPressed = false;
sync();
if (isMouseUpAway(e)) {
hideBar();
}
}
function handleYScrollMouseDown(e) {
e.preventDefault();
e.stopPropagation();
yBarPressed = true;
on('mousemove', window, handleYScrollMouseMove, true);
on('mouseup', window, handleYScrollMouseUp, true);
memoYTop = containerScrollTopRef.value;
memoMouseY = e.clientY;
}
function handleYScrollMouseMove(e) {
if (!yBarPressed) return;
if (xBarVanishTimerId !== undefined) {
window.clearTimeout(xBarVanishTimerId);
}
if (yBarVanishTimerId !== undefined) {
window.clearTimeout(yBarVanishTimerId);
}
const {
value: containerHeight
} = containerHeightRef;
const {
value: contentHeight
} = contentHeightRef;
const {
value: yBarSize
} = yBarSizeRef;
if (containerHeight === null || contentHeight === null) return;
const dY = e.clientY - memoMouseY;
const dScrollTop = dY * (contentHeight - containerHeight) / (containerHeight - yBarSize);
const toScrollTopUpperBound = contentHeight - containerHeight;
let toScrollTop = memoYTop + dScrollTop;
toScrollTop = Math.min(toScrollTopUpperBound, toScrollTop);
toScrollTop = Math.max(toScrollTop, 0);
const {
value: container
} = mergedContainerRef;
if (container) {
container.scrollTop = toScrollTop;
}
}
function handleYScrollMouseUp(e) {
e.preventDefault();
e.stopPropagation();
off('mousemove', window, handleYScrollMouseMove, true);
off('mouseup', window, handleYScrollMouseUp, true);
yBarPressed = false;
sync();
if (isMouseUpAway(e)) {
hideBar();
}
}
watchEffect(() => {
const {
value: needXBar
} = needXBarRef;
const {
value: needYBar
} = needYBarRef;
const {
value: mergedClsPrefix
} = mergedClsPrefixRef;
const {
value: xRailEl
} = xRailRef;
const {
value: yRailEl
} = yRailRef;
if (xRailEl) {
if (!needXBar) {
xRailEl.classList.add(`${mergedClsPrefix}-scrollbar-rail--disabled`);
} else {
xRailEl.classList.remove(`${mergedClsPrefix}-scrollbar-rail--disabled`);
}
}
if (yRailEl) {
if (!needYBar) {
yRailEl.classList.add(`${mergedClsPrefix}-scrollbar-rail--disabled`);
} else {
yRailEl.classList.remove(`${mergedClsPrefix}-scrollbar-rail--disabled`);
}
}
});
runtime_core_esm_bundler_onMounted(() => {
// if container exist, it always can't be resolved when scrollbar is mounted
// for example:
// - component
// - scrollbar
// - inner
// if you pass inner to scrollbar, you may use a ref inside component
// however, when scrollbar is mounted, ref is not ready at component
// you need to init by yourself
if (props.container) return;
sync();
});
runtime_core_esm_bundler_onBeforeUnmount(() => {
if (xBarVanishTimerId !== undefined) {
window.clearTimeout(xBarVanishTimerId);
}
if (yBarVanishTimerId !== undefined) {
window.clearTimeout(yBarVanishTimerId);
}
off('mousemove', window, handleYScrollMouseMove, true);
off('mouseup', window, handleYScrollMouseUp, true);
});
const cssVarsRef = runtime_core_esm_bundler_computed(() => {
const {
common: {
cubicBezierEaseInOut
},
self: {
color,
colorHover,
height,
width,
borderRadius,
railInsetHorizontalTop,
railInsetHorizontalBottom,
railInsetVerticalRight,
railInsetVerticalLeft,
railColor
}
} = themeRef.value;
const {
top: railTopHorizontalTop,
right: railRightHorizontalTop,
bottom: railBottomHorizontalTop,
left: railLeftHorizontalTop
} = getMargin(railInsetHorizontalTop);
const {
top: railTopHorizontalBottom,
right: railRightHorizontalBottom,
bottom: railBottomHorizontalBottom,
left: railLeftHorizontalBottom
} = getMargin(railInsetHorizontalBottom);
const {
top: railTopVerticalRight,
right: railRightVerticalRight,
bottom: railBottomVerticalRight,
left: railLeftVerticalRight
} = getMargin((rtlEnabledRef === null || rtlEnabledRef === void 0 ? void 0 : rtlEnabledRef.value) ? rtlInset(railInsetVerticalRight) : railInsetVerticalRight);
const {
top: railTopVerticalLeft,
right: railRightVerticalLeft,
bottom: railBottomVerticalLeft,
left: railLeftVerticalLeft
} = getMargin((rtlEnabledRef === null || rtlEnabledRef === void 0 ? void 0 : rtlEnabledRef.value) ? rtlInset(railInsetVerticalLeft) : railInsetVerticalLeft);
return {
'--n-scrollbar-bezier': cubicBezierEaseInOut,
'--n-scrollbar-color': color,
'--n-scrollbar-color-hover': colorHover,
'--n-scrollbar-border-radius': borderRadius,
'--n-scrollbar-width': width,
'--n-scrollbar-height': height,
'--n-scrollbar-rail-top-horizontal-top': railTopHorizontalTop,
'--n-scrollbar-rail-right-horizontal-top': railRightHorizontalTop,
'--n-scrollbar-rail-bottom-horizontal-top': railBottomHorizontalTop,
'--n-scrollbar-rail-left-horizontal-top': railLeftHorizontalTop,
'--n-scrollbar-rail-top-horizontal-bottom': railTopHorizontalBottom,
'--n-scrollbar-rail-right-horizontal-bottom': railRightHorizontalBottom,
'--n-scrollbar-rail-bottom-horizontal-bottom': railBottomHorizontalBottom,
'--n-scrollbar-rail-left-horizontal-bottom': railLeftHorizontalBottom,
'--n-scrollbar-rail-top-vertical-right': railTopVerticalRight,
'--n-scrollbar-rail-right-vertical-right': railRightVerticalRight,
'--n-scrollbar-rail-bottom-vertical-right': railBottomVerticalRight,
'--n-scrollbar-rail-left-vertical-right': railLeftVerticalRight,
'--n-scrollbar-rail-top-vertical-left': railTopVerticalLeft,
'--n-scrollbar-rail-right-vertical-left': railRightVerticalLeft,
'--n-scrollbar-rail-bottom-vertical-left': railBottomVerticalLeft,
'--n-scrollbar-rail-left-vertical-left': railLeftVerticalLeft,
'--n-scrollbar-rail-color': railColor
};
});
const themeClassHandle = inlineThemeDisabled ? useThemeClass('scrollbar', undefined, cssVarsRef, props) : undefined;
const exposedMethods = {
scrollTo,
scrollBy,
sync,
syncUnifiedContainer,
handleMouseEnterWrapper,
handleMouseLeaveWrapper
};
return Object.assign(Object.assign({}, exposedMethods), {
mergedClsPrefix: mergedClsPrefixRef,
rtlEnabled: rtlEnabledRef,
containerScrollTop: containerScrollTopRef,
wrapperRef,
containerRef,
contentRef,
yRailRef,
xRailRef,
needYBar: needYBarRef,
needXBar: needXBarRef,
yBarSizePx: yBarSizePxRef,
xBarSizePx: xBarSizePxRef,
yBarTopPx: yBarTopPxRef,
xBarLeftPx: xBarLeftPxRef,
isShowXBar: mergedShowXBarRef,
isShowYBar: mergedShowYBarRef,
isIos,
handleScroll,
handleContentResize,
handleContainerResize,
handleYScrollMouseDown,
handleXScrollMouseDown,
cssVars: inlineThemeDisabled ? undefined : cssVarsRef,
themeClass: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass,
onRender: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender
});
},
render() {
var _a;
const {
$slots,
mergedClsPrefix,
triggerDisplayManually,
rtlEnabled,
internalHoistYRail,
yPlacement,
xPlacement,
xScrollable
} = this;
if (!this.scrollable) return (_a = $slots.default) === null || _a === void 0 ? void 0 : _a.call($slots);
const triggerIsNone = this.trigger === 'none';
const createYRail = (className, style) => {
return h("div", {
ref: "yRailRef",
class: [`${mergedClsPrefix}-scrollbar-rail`, `${mergedClsPrefix}-scrollbar-rail--vertical`, `${mergedClsPrefix}-scrollbar-rail--vertical--${yPlacement}`, className],
"data-scrollbar-rail": true,
style: [style || '', this.verticalRailStyle],
"aria-hidden": true
}, h(triggerIsNone ? Wrapper : Transition, triggerIsNone ? null : {
name: 'fade-in-transition'
}, {
default: () => this.needYBar && this.isShowYBar && !this.isIos ? h("div", {
class: `${mergedClsPrefix}-scrollbar-rail__scrollbar`,
style: {
height: this.yBarSizePx,
top: this.yBarTopPx
},
onMousedown: this.handleYScrollMouseDown
}) : null
}));
};
const createChildren = () => {
var _a, _b;
(_a = this.onRender) === null || _a === void 0 ? void 0 : _a.call(this);
return h('div', mergeProps(this.$attrs, {
role: 'none',
ref: 'wrapperRef',
class: [`${mergedClsPrefix}-scrollbar`, this.themeClass, rtlEnabled && `${mergedClsPrefix}-scrollbar--rtl`],
style: this.cssVars,
onMouseenter: triggerDisplayManually ? undefined : this.handleMouseEnterWrapper,
onMouseleave: triggerDisplayManually ? undefined : this.handleMouseLeaveWrapper
}), [this.container ? (_b = $slots.default) === null || _b === void 0 ? void 0 : _b.call($slots) : h("div", {
role: "none",
ref: "containerRef",
class: [`${mergedClsPrefix}-scrollbar-container`, this.containerClass],
style: this.containerStyle,
onScroll: this.handleScroll,
onWheel: this.onWheel
}, h(VResizeObserver, {
onResize: this.handleContentResize
}, {
default: () => h("div", {
ref: "contentRef",
role: "none",
style: [{
width: this.xScrollable ? 'fit-content' : null
}, this.contentStyle],
class: [`${mergedClsPrefix}-scrollbar-content`, this.contentClass]
}, $slots)
})), internalHoistYRail ? null : createYRail(undefined, undefined), xScrollable && h("div", {
ref: "xRailRef",
class: [`${mergedClsPrefix}-scrollbar-rail`, `${mergedClsPrefix}-scrollbar-rail--horizontal`, `${mergedClsPrefix}-scrollbar-rail--horizontal--${xPlacement}`],
style: this.horizontalRailStyle,
"data-scrollbar-rail": true,
"aria-hidden": true
}, h(triggerIsNone ? Wrapper : Transition, triggerIsNone ? null : {
name: 'fade-in-transition'
}, {
default: () => this.needXBar && this.isShowXBar && !this.isIos ? h("div", {
class: `${mergedClsPrefix}-scrollbar-rail__scrollbar`,
style: {
width: this.xBarSizePx,
right: rtlEnabled ? this.xBarLeftPx : undefined,
left: rtlEnabled ? undefined : this.xBarLeftPx
},
onMousedown: this.handleXScrollMouseDown
}) : null
}))]);
};
const scrollbarNode = this.container ? createChildren() : h(VResizeObserver, {
onResize: this.handleContainerResize
}, {
default: createChildren
});
if (internalHoistYRail) {
return h(Fragment, null, scrollbarNode, createYRail(this.themeClass, this.cssVars));
} else {
return scrollbarNode;
}
}
});
/* harmony default export */ var src_Scrollbar = (Scrollbar);
const XScrollbar = Scrollbar;
;// ./node_modules/naive-ui/es/_utils/env/is-jsdom.mjs
let _isJsdom;
function isJsdom() {
if (_isJsdom === undefined) {
_isJsdom = navigator.userAgent.includes('Node.js') || navigator.userAgent.includes('jsdom');
}
return _isJsdom;
}
;// ./node_modules/naive-ui/es/_utils/css/format-length.mjs
const pureNumberRegex = /^(\d|\.)+$/;
const numberRegex = /(\d|\.)+/;
function formatLength(length, {
c = 1,
offset = 0,
attachPx = true
} = {}) {
if (typeof length === 'number') {
const result = (length + offset) * c;
if (result === 0) return '0';
return `${result}px`;
} else if (typeof length === 'string') {
if (pureNumberRegex.test(length)) {
const result = (Number(length) + offset) * c;
if (attachPx) {
if (result === 0) return '0';
return `${result}px`;
} else {
return `${result}`;
}
} else {
const result = numberRegex.exec(length);
if (!result) return length;
return length.replace(numberRegex, String((Number(result[0]) + offset) * c));
}
}
return length;
}
;// ./node_modules/naive-ui/es/popover/styles/_common.mjs
/* harmony default export */ var popover_styles_common = ({
space: '6px',
spaceArrow: '10px',
arrowOffset: '10px',
arrowOffsetVertical: '10px',
arrowHeight: '6px',
padding: '8px 14px'
});
;// ./node_modules/naive-ui/es/popover/styles/light.mjs
function popover_styles_light_self(vars) {
const {
boxShadow2,
popoverColor,
textColor2,
borderRadius,
fontSize,
dividerColor
} = vars;
return Object.assign(Object.assign({}, popover_styles_common), {
fontSize,
borderRadius,
color: popoverColor,
dividerColor,
textColor: textColor2,
boxShadow: boxShadow2
});
}
const popoverLight = {
name: 'Popover',
common: light,
self: popover_styles_light_self
};
/* harmony default export */ var popover_styles_light = (popoverLight);
;// ./node_modules/lodash-es/_arrayMap.js
/**
* A specialized version of `_.map` for arrays without support for iteratee
* shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns the new mapped array.
*/
function arrayMap(array, iteratee) {
var index = -1,
length = array == null ? 0 : array.length,
result = Array(length);
while (++index < length) {
result[index] = iteratee(array[index], index, array);
}
return result;
}
/* harmony default export */ var _arrayMap = (arrayMap);
;// ./node_modules/lodash-es/_setCacheAdd.js
/** Used to stand-in for `undefined` hash values. */
var _setCacheAdd_HASH_UNDEFINED = '__lodash_hash_undefined__';
/**
* Adds `value` to the array cache.
*
* @private
* @name add
* @memberOf SetCache
* @alias push
* @param {*} value The value to cache.
* @returns {Object} Returns the cache instance.
*/
function setCacheAdd(value) {
this.__data__.set(value, _setCacheAdd_HASH_UNDEFINED);
return this;
}
/* harmony default export */ var _setCacheAdd = (setCacheAdd);
;// ./node_modules/lodash-es/_setCacheHas.js
/**
* Checks if `value` is in the array cache.
*
* @private
* @name has
* @memberOf SetCache
* @param {*} value The value to search for.
* @returns {number} Returns `true` if `value` is found, else `false`.
*/
function setCacheHas(value) {
return this.__data__.has(value);
}
/* harmony default export */ var _setCacheHas = (setCacheHas);
;// ./node_modules/lodash-es/_SetCache.js
/**
*
* Creates an array cache object to store unique values.
*
* @private
* @constructor
* @param {Array} [values] The values to cache.
*/
function SetCache(values) {
var index = -1,
length = values == null ? 0 : values.length;
this.__data__ = new _MapCache;
while (++index < length) {
this.add(values[index]);
}
}
// Add methods to `SetCache`.
SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd;
SetCache.prototype.has = _setCacheHas;
/* harmony default export */ var _SetCache = (SetCache);
;// ./node_modules/lodash-es/_arraySome.js
/**
* A specialized version of `_.some` for arrays without support for iteratee
* shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} predicate The function invoked per iteration.
* @returns {boolean} Returns `true` if any element passes the predicate check,
* else `false`.
*/
function arraySome(array, predicate) {
var index = -1,
length = array == null ? 0 : array.length;
while (++index < length) {
if (predicate(array[index], index, array)) {
return true;
}
}
return false;
}
/* harmony default export */ var _arraySome = (arraySome);
;// ./node_modules/lodash-es/_cacheHas.js
/**
* Checks if a `cache` value for `key` exists.
*
* @private
* @param {Object} cache The cache to query.
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function cacheHas(cache, key) {
return cache.has(key);
}
/* harmony default export */ var _cacheHas = (cacheHas);
;// ./node_modules/lodash-es/_equalArrays.js
/** Used to compose bitmasks for value comparisons. */
var COMPARE_PARTIAL_FLAG = 1,
COMPARE_UNORDERED_FLAG = 2;
/**
* A specialized version of `baseIsEqualDeep` for arrays with support for
* partial deep comparisons.
*
* @private
* @param {Array} array The array to compare.
* @param {Array} other The other array to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} stack Tracks traversed `array` and `other` objects.
* @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
*/
function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
arrLength = array.length,
othLength = other.length;
if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
return false;
}
// Check that cyclic values are equal.
var arrStacked = stack.get(array);
var othStacked = stack.get(other);
if (arrStacked && othStacked) {
return arrStacked == other && othStacked == array;
}
var index = -1,
result = true,
seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new _SetCache : undefined;
stack.set(array, other);
stack.set(other, array);
// Ignore non-index properties.
while (++index < arrLength) {
var arrValue = array[index],
othValue = other[index];
if (customizer) {
var compared = isPartial
? customizer(othValue, arrValue, index, other, array, stack)
: customizer(arrValue, othValue, index, array, other, stack);
}
if (compared !== undefined) {
if (compared) {
continue;
}
result = false;
break;
}
// Recursively compare arrays (susceptible to call stack limits).
if (seen) {
if (!_arraySome(other, function(othValue, othIndex) {
if (!_cacheHas(seen, othIndex) &&
(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
return seen.push(othIndex);
}
})) {
result = false;
break;
}
} else if (!(
arrValue === othValue ||
equalFunc(arrValue, othValue, bitmask, customizer, stack)
)) {
result = false;
break;
}
}
stack['delete'](array);
stack['delete'](other);
return result;
}
/* harmony default export */ var _equalArrays = (equalArrays);
;// ./node_modules/lodash-es/_mapToArray.js
/**
* Converts `map` to its key-value pairs.
*
* @private
* @param {Object} map The map to convert.
* @returns {Array} Returns the key-value pairs.
*/
function mapToArray(map) {
var index = -1,
result = Array(map.size);
map.forEach(function(value, key) {
result[++index] = [key, value];
});
return result;
}
/* harmony default export */ var _mapToArray = (mapToArray);
;// ./node_modules/lodash-es/_setToArray.js
/**
* Converts `set` to an array of its values.
*
* @private
* @param {Object} set The set to convert.
* @returns {Array} Returns the values.
*/
function setToArray(set) {
var index = -1,
result = Array(set.size);
set.forEach(function(value) {
result[++index] = value;
});
return result;
}
/* harmony default export */ var _setToArray = (setToArray);
;// ./node_modules/lodash-es/_equalByTag.js
/** Used to compose bitmasks for value comparisons. */
var _equalByTag_COMPARE_PARTIAL_FLAG = 1,
_equalByTag_COMPARE_UNORDERED_FLAG = 2;
/** `Object#toString` result references. */
var _equalByTag_boolTag = '[object Boolean]',
_equalByTag_dateTag = '[object Date]',
_equalByTag_errorTag = '[object Error]',
_equalByTag_mapTag = '[object Map]',
_equalByTag_numberTag = '[object Number]',
_equalByTag_regexpTag = '[object RegExp]',
_equalByTag_setTag = '[object Set]',
_equalByTag_stringTag = '[object String]',
symbolTag = '[object Symbol]';
var _equalByTag_arrayBufferTag = '[object ArrayBuffer]',
_equalByTag_dataViewTag = '[object DataView]';
/** Used to convert symbols to primitives and strings. */
var symbolProto = _Symbol ? _Symbol.prototype : undefined,
symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
/**
* A specialized version of `baseIsEqualDeep` for comparing objects of
* the same `toStringTag`.
*
* **Note:** This function only supports comparing values with tags of
* `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
*
* @private
* @param {Object} object The object to compare.
* @param {Object} other The other object to compare.
* @param {string} tag The `toStringTag` of the objects to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} stack Tracks traversed `object` and `other` objects.
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
*/
function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
switch (tag) {
case _equalByTag_dataViewTag:
if ((object.byteLength != other.byteLength) ||
(object.byteOffset != other.byteOffset)) {
return false;
}
object = object.buffer;
other = other.buffer;
case _equalByTag_arrayBufferTag:
if ((object.byteLength != other.byteLength) ||
!equalFunc(new _Uint8Array(object), new _Uint8Array(other))) {
return false;
}
return true;
case _equalByTag_boolTag:
case _equalByTag_dateTag:
case _equalByTag_numberTag:
// Coerce booleans to `1` or `0` and dates to milliseconds.
// Invalid dates are coerced to `NaN`.
return lodash_es_eq(+object, +other);
case _equalByTag_errorTag:
return object.name == other.name && object.message == other.message;
case _equalByTag_regexpTag:
case _equalByTag_stringTag:
// Coerce regexes to strings and treat strings, primitives and objects,
// as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
// for more details.
return object == (other + '');
case _equalByTag_mapTag:
var convert = _mapToArray;
case _equalByTag_setTag:
var isPartial = bitmask & _equalByTag_COMPARE_PARTIAL_FLAG;
convert || (convert = _setToArray);
if (object.size != other.size && !isPartial) {
return false;
}
// Assume cyclic values are equal.
var stacked = stack.get(object);
if (stacked) {
return stacked == other;
}
bitmask |= _equalByTag_COMPARE_UNORDERED_FLAG;
// Recursively compare objects (susceptible to call stack limits).
stack.set(object, other);
var result = _equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
stack['delete'](object);
return result;
case symbolTag:
if (symbolValueOf) {
return symbolValueOf.call(object) == symbolValueOf.call(other);
}
}
return false;
}
/* harmony default export */ var _equalByTag = (equalByTag);
;// ./node_modules/lodash-es/_arrayPush.js
/**
* Appends the elements of `values` to `array`.
*
* @private
* @param {Array} array The array to modify.
* @param {Array} values The values to append.
* @returns {Array} Returns `array`.
*/
function arrayPush(array, values) {
var index = -1,
length = values.length,
offset = array.length;
while (++index < length) {
array[offset + index] = values[index];
}
return array;
}
/* harmony default export */ var _arrayPush = (arrayPush);
;// ./node_modules/lodash-es/_baseGetAllKeys.js
/**
* The base implementation of `getAllKeys` and `getAllKeysIn` which uses
* `keysFunc` and `symbolsFunc` to get the enumerable property names and
* symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @param {Function} keysFunc The function to get the keys of `object`.
* @param {Function} symbolsFunc The function to get the symbols of `object`.
* @returns {Array} Returns the array of property names and symbols.
*/
function baseGetAllKeys(object, keysFunc, symbolsFunc) {
var result = keysFunc(object);
return lodash_es_isArray(object) ? result : _arrayPush(result, symbolsFunc(object));
}
/* harmony default export */ var _baseGetAllKeys = (baseGetAllKeys);
;// ./node_modules/lodash-es/_arrayFilter.js
/**
* A specialized version of `_.filter` for arrays without support for
* iteratee shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} predicate The function invoked per iteration.
* @returns {Array} Returns the new filtered array.
*/
function arrayFilter(array, predicate) {
var index = -1,
length = array == null ? 0 : array.length,
resIndex = 0,
result = [];
while (++index < length) {
var value = array[index];
if (predicate(value, index, array)) {
result[resIndex++] = value;
}
}
return result;
}
/* harmony default export */ var _arrayFilter = (arrayFilter);
;// ./node_modules/lodash-es/stubArray.js
/**
* This method returns a new empty array.
*
* @static
* @memberOf _
* @since 4.13.0
* @category Util
* @returns {Array} Returns the new empty array.
* @example
*
* var arrays = _.times(2, _.stubArray);
*
* console.log(arrays);
* // => [[], []]
*
* console.log(arrays[0] === arrays[1]);
* // => false
*/
function stubArray() {
return [];
}
/* harmony default export */ var lodash_es_stubArray = (stubArray);
;// ./node_modules/lodash-es/_getSymbols.js
/** Used for built-in method references. */
var _getSymbols_objectProto = Object.prototype;
/** Built-in value references. */
var _getSymbols_propertyIsEnumerable = _getSymbols_objectProto.propertyIsEnumerable;
/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeGetSymbols = Object.getOwnPropertySymbols;
/**
* Creates an array of the own enumerable symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of symbols.
*/
var getSymbols = !nativeGetSymbols ? lodash_es_stubArray : function(object) {
if (object == null) {
return [];
}
object = Object(object);
return _arrayFilter(nativeGetSymbols(object), function(symbol) {
return _getSymbols_propertyIsEnumerable.call(object, symbol);
});
};
/* harmony default export */ var _getSymbols = (getSymbols);
;// ./node_modules/lodash-es/_nativeKeys.js
/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeKeys = _overArg(Object.keys, Object);
/* harmony default export */ var _nativeKeys = (nativeKeys);
;// ./node_modules/lodash-es/_baseKeys.js
/** Used for built-in method references. */
var _baseKeys_objectProto = Object.prototype;
/** Used to check objects for own properties. */
var _baseKeys_hasOwnProperty = _baseKeys_objectProto.hasOwnProperty;
/**
* The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
*/
function baseKeys(object) {
if (!_isPrototype(object)) {
return _nativeKeys(object);
}
var result = [];
for (var key in Object(object)) {
if (_baseKeys_hasOwnProperty.call(object, key) && key != 'constructor') {
result.push(key);
}
}
return result;
}
/* harmony default export */ var _baseKeys = (baseKeys);
;// ./node_modules/lodash-es/keys.js
/**
* Creates an array of the own enumerable property names of `object`.
*
* **Note:** Non-object values are coerced to objects. See the
* [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
* for more details.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.keys(new Foo);
* // => ['a', 'b'] (iteration order is not guaranteed)
*
* _.keys('hi');
* // => ['0', '1']
*/
function keys(object) {
return lodash_es_isArrayLike(object) ? _arrayLikeKeys(object) : _baseKeys(object);
}
/* harmony default export */ var lodash_es_keys = (keys);
;// ./node_modules/lodash-es/_getAllKeys.js
/**
* Creates an array of own enumerable property names and symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names and symbols.
*/
function getAllKeys(object) {
return _baseGetAllKeys(object, lodash_es_keys, _getSymbols);
}
/* harmony default export */ var _getAllKeys = (getAllKeys);
;// ./node_modules/lodash-es/_equalObjects.js
/** Used to compose bitmasks for value comparisons. */
var _equalObjects_COMPARE_PARTIAL_FLAG = 1;
/** Used for built-in method references. */
var _equalObjects_objectProto = Object.prototype;
/** Used to check objects for own properties. */
var _equalObjects_hasOwnProperty = _equalObjects_objectProto.hasOwnProperty;
/**
* A specialized version of `baseIsEqualDeep` for objects with support for
* partial deep comparisons.
*
* @private
* @param {Object} object The object to compare.
* @param {Object} other The other object to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} stack Tracks traversed `object` and `other` objects.
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
*/
function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
var isPartial = bitmask & _equalObjects_COMPARE_PARTIAL_FLAG,
objProps = _getAllKeys(object),
objLength = objProps.length,
othProps = _getAllKeys(other),
othLength = othProps.length;
if (objLength != othLength && !isPartial) {
return false;
}
var index = objLength;
while (index--) {
var key = objProps[index];
if (!(isPartial ? key in other : _equalObjects_hasOwnProperty.call(other, key))) {
return false;
}
}
// Check that cyclic values are equal.
var objStacked = stack.get(object);
var othStacked = stack.get(other);
if (objStacked && othStacked) {
return objStacked == other && othStacked == object;
}
var result = true;
stack.set(object, other);
stack.set(other, object);
var skipCtor = isPartial;
while (++index < objLength) {
key = objProps[index];
var objValue = object[key],
othValue = other[key];
if (customizer) {
var compared = isPartial
? customizer(othValue, objValue, key, other, object, stack)
: customizer(objValue, othValue, key, object, other, stack);
}
// Recursively compare objects (susceptible to call stack limits).
if (!(compared === undefined
? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
: compared
)) {
result = false;
break;
}
skipCtor || (skipCtor = key == 'constructor');
}
if (result && !skipCtor) {
var objCtor = object.constructor,
othCtor = other.constructor;
// Non `Object` object instances with different constructors are not equal.
if (objCtor != othCtor &&
('constructor' in object && 'constructor' in other) &&
!(typeof objCtor == 'function' && objCtor instanceof objCtor &&
typeof othCtor == 'function' && othCtor instanceof othCtor)) {
result = false;
}
}
stack['delete'](object);
stack['delete'](other);
return result;
}
/* harmony default export */ var _equalObjects = (equalObjects);
;// ./node_modules/lodash-es/_DataView.js
/* Built-in method references that are verified to be native. */
var DataView = _getNative(_root, 'DataView');
/* harmony default export */ var _DataView = (DataView);
;// ./node_modules/lodash-es/_Promise.js
/* Built-in method references that are verified to be native. */
var _Promise_Promise = _getNative(_root, 'Promise');
/* harmony default export */ var _Promise = (_Promise_Promise);
;// ./node_modules/lodash-es/_Set.js
/* Built-in method references that are verified to be native. */
var _Set_Set = _getNative(_root, 'Set');
/* harmony default export */ var _Set = (_Set_Set);
;// ./node_modules/lodash-es/_WeakMap.js
/* Built-in method references that are verified to be native. */
var _WeakMap_WeakMap = _getNative(_root, 'WeakMap');
/* harmony default export */ var _WeakMap = (_WeakMap_WeakMap);
;// ./node_modules/lodash-es/_getTag.js
/** `Object#toString` result references. */
var _getTag_mapTag = '[object Map]',
_getTag_objectTag = '[object Object]',
promiseTag = '[object Promise]',
_getTag_setTag = '[object Set]',
_getTag_weakMapTag = '[object WeakMap]';
var _getTag_dataViewTag = '[object DataView]';
/** Used to detect maps, sets, and weakmaps. */
var dataViewCtorString = _toSource(_DataView),
mapCtorString = _toSource(_Map),
promiseCtorString = _toSource(_Promise),
setCtorString = _toSource(_Set),
weakMapCtorString = _toSource(_WeakMap);
/**
* Gets the `toStringTag` of `value`.
*
* @private
* @param {*} value The value to query.
* @returns {string} Returns the `toStringTag`.
*/
var getTag = _baseGetTag;
// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
if ((_DataView && getTag(new _DataView(new ArrayBuffer(1))) != _getTag_dataViewTag) ||
(_Map && getTag(new _Map) != _getTag_mapTag) ||
(_Promise && getTag(_Promise.resolve()) != promiseTag) ||
(_Set && getTag(new _Set) != _getTag_setTag) ||
(_WeakMap && getTag(new _WeakMap) != _getTag_weakMapTag)) {
getTag = function(value) {
var result = _baseGetTag(value),
Ctor = result == _getTag_objectTag ? value.constructor : undefined,
ctorString = Ctor ? _toSource(Ctor) : '';
if (ctorString) {
switch (ctorString) {
case dataViewCtorString: return _getTag_dataViewTag;
case mapCtorString: return _getTag_mapTag;
case promiseCtorString: return promiseTag;
case setCtorString: return _getTag_setTag;
case weakMapCtorString: return _getTag_weakMapTag;
}
}
return result;
};
}
/* harmony default export */ var _getTag = (getTag);
;// ./node_modules/lodash-es/_baseIsEqualDeep.js
/** Used to compose bitmasks for value comparisons. */
var _baseIsEqualDeep_COMPARE_PARTIAL_FLAG = 1;
/** `Object#toString` result references. */
var _baseIsEqualDeep_argsTag = '[object Arguments]',
_baseIsEqualDeep_arrayTag = '[object Array]',
_baseIsEqualDeep_objectTag = '[object Object]';
/** Used for built-in method references. */
var _baseIsEqualDeep_objectProto = Object.prototype;
/** Used to check objects for own properties. */
var _baseIsEqualDeep_hasOwnProperty = _baseIsEqualDeep_objectProto.hasOwnProperty;
/**
* A specialized version of `baseIsEqual` for arrays and objects which performs
* deep comparisons and tracks traversed objects enabling objects with circular
* references to be compared.
*
* @private
* @param {Object} object The object to compare.
* @param {Object} other The other object to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} [stack] Tracks traversed `object` and `other` objects.
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
*/
function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
var objIsArr = lodash_es_isArray(object),
othIsArr = lodash_es_isArray(other),
objTag = objIsArr ? _baseIsEqualDeep_arrayTag : _getTag(object),
othTag = othIsArr ? _baseIsEqualDeep_arrayTag : _getTag(other);
objTag = objTag == _baseIsEqualDeep_argsTag ? _baseIsEqualDeep_objectTag : objTag;
othTag = othTag == _baseIsEqualDeep_argsTag ? _baseIsEqualDeep_objectTag : othTag;
var objIsObj = objTag == _baseIsEqualDeep_objectTag,
othIsObj = othTag == _baseIsEqualDeep_objectTag,
isSameTag = objTag == othTag;
if (isSameTag && lodash_es_isBuffer(object)) {
if (!lodash_es_isBuffer(other)) {
return false;
}
objIsArr = true;
objIsObj = false;
}
if (isSameTag && !objIsObj) {
stack || (stack = new _Stack);
return (objIsArr || lodash_es_isTypedArray(object))
? _equalArrays(object, other, bitmask, customizer, equalFunc, stack)
: _equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
}
if (!(bitmask & _baseIsEqualDeep_COMPARE_PARTIAL_FLAG)) {
var objIsWrapped = objIsObj && _baseIsEqualDeep_hasOwnProperty.call(object, '__wrapped__'),
othIsWrapped = othIsObj && _baseIsEqualDeep_hasOwnProperty.call(other, '__wrapped__');
if (objIsWrapped || othIsWrapped) {
var objUnwrapped = objIsWrapped ? object.value() : object,
othUnwrapped = othIsWrapped ? other.value() : other;
stack || (stack = new _Stack);
return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
}
}
if (!isSameTag) {
return false;
}
stack || (stack = new _Stack);
return _equalObjects(object, other, bitmask, customizer, equalFunc, stack);
}
/* harmony default export */ var _baseIsEqualDeep = (baseIsEqualDeep);
;// ./node_modules/lodash-es/_baseIsEqual.js
/**
* The base implementation of `_.isEqual` which supports partial comparisons
* and tracks traversed objects.
*
* @private
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @param {boolean} bitmask The bitmask flags.
* 1 - Unordered comparison
* 2 - Partial comparison
* @param {Function} [customizer] The function to customize comparisons.
* @param {Object} [stack] Tracks traversed `value` and `other` objects.
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
*/
function baseIsEqual(value, other, bitmask, customizer, stack) {
if (value === other) {
return true;
}
if (value == null || other == null || (!lodash_es_isObjectLike(value) && !lodash_es_isObjectLike(other))) {
return value !== value && other !== other;
}
return _baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
}
/* harmony default export */ var _baseIsEqual = (baseIsEqual);
;// ./node_modules/lodash-es/_baseIsMatch.js
/** Used to compose bitmasks for value comparisons. */
var _baseIsMatch_COMPARE_PARTIAL_FLAG = 1,
_baseIsMatch_COMPARE_UNORDERED_FLAG = 2;
/**
* The base implementation of `_.isMatch` without support for iteratee shorthands.
*
* @private
* @param {Object} object The object to inspect.
* @param {Object} source The object of property values to match.
* @param {Array} matchData The property names, values, and compare flags to match.
* @param {Function} [customizer] The function to customize comparisons.
* @returns {boolean} Returns `true` if `object` is a match, else `false`.
*/
function baseIsMatch(object, source, matchData, customizer) {
var index = matchData.length,
length = index,
noCustomizer = !customizer;
if (object == null) {
return !length;
}
object = Object(object);
while (index--) {
var data = matchData[index];
if ((noCustomizer && data[2])
? data[1] !== object[data[0]]
: !(data[0] in object)
) {
return false;
}
}
while (++index < length) {
data = matchData[index];
var key = data[0],
objValue = object[key],
srcValue = data[1];
if (noCustomizer && data[2]) {
if (objValue === undefined && !(key in object)) {
return false;
}
} else {
var stack = new _Stack;
if (customizer) {
var result = customizer(objValue, srcValue, key, object, source, stack);
}
if (!(result === undefined
? _baseIsEqual(srcValue, objValue, _baseIsMatch_COMPARE_PARTIAL_FLAG | _baseIsMatch_COMPARE_UNORDERED_FLAG, customizer, stack)
: result
)) {
return false;
}
}
}
return true;
}
/* harmony default export */ var _baseIsMatch = (baseIsMatch);
;// ./node_modules/lodash-es/_isStrictComparable.js
/**
* Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` if suitable for strict
* equality comparisons, else `false`.
*/
function isStrictComparable(value) {
return value === value && !lodash_es_isObject(value);
}
/* harmony default export */ var _isStrictComparable = (isStrictComparable);
;// ./node_modules/lodash-es/_getMatchData.js
/**
* Gets the property names, values, and compare flags of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the match data of `object`.
*/
function getMatchData(object) {
var result = lodash_es_keys(object),
length = result.length;
while (length--) {
var key = result[length],
value = object[key];
result[length] = [key, value, _isStrictComparable(value)];
}
return result;
}
/* harmony default export */ var _getMatchData = (getMatchData);
;// ./node_modules/lodash-es/_matchesStrictComparable.js
/**
* A specialized version of `matchesProperty` for source values suitable
* for strict equality comparisons, i.e. `===`.
*
* @private
* @param {string} key The key of the property to get.
* @param {*} srcValue The value to match.
* @returns {Function} Returns the new spec function.
*/
function matchesStrictComparable(key, srcValue) {
return function(object) {
if (object == null) {
return false;
}
return object[key] === srcValue &&
(srcValue !== undefined || (key in Object(object)));
};
}
/* harmony default export */ var _matchesStrictComparable = (matchesStrictComparable);
;// ./node_modules/lodash-es/_baseMatches.js
/**
* The base implementation of `_.matches` which doesn't clone `source`.
*
* @private
* @param {Object} source The object of property values to match.
* @returns {Function} Returns the new spec function.
*/
function baseMatches(source) {
var matchData = _getMatchData(source);
if (matchData.length == 1 && matchData[0][2]) {
return _matchesStrictComparable(matchData[0][0], matchData[0][1]);
}
return function(object) {
return object === source || _baseIsMatch(object, source, matchData);
};
}
/* harmony default export */ var _baseMatches = (baseMatches);
;// ./node_modules/lodash-es/isSymbol.js
/** `Object#toString` result references. */
var isSymbol_symbolTag = '[object Symbol]';
/**
* Checks if `value` is classified as a `Symbol` primitive or object.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
* @example
*
* _.isSymbol(Symbol.iterator);
* // => true
*
* _.isSymbol('abc');
* // => false
*/
function isSymbol_isSymbol(value) {
return typeof value == 'symbol' ||
(lodash_es_isObjectLike(value) && _baseGetTag(value) == isSymbol_symbolTag);
}
/* harmony default export */ var lodash_es_isSymbol = (isSymbol_isSymbol);
;// ./node_modules/lodash-es/_isKey.js
/** Used to match property names within property paths. */
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
reIsPlainProp = /^\w*$/;
/**
* Checks if `value` is a property name and not a property path.
*
* @private
* @param {*} value The value to check.
* @param {Object} [object] The object to query keys on.
* @returns {boolean} Returns `true` if `value` is a property name, else `false`.
*/
function isKey(value, object) {
if (lodash_es_isArray(value)) {
return false;
}
var type = typeof value;
if (type == 'number' || type == 'symbol' || type == 'boolean' ||
value == null || lodash_es_isSymbol(value)) {
return true;
}
return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
(object != null && value in Object(object));
}
/* harmony default export */ var _isKey = (isKey);
;// ./node_modules/lodash-es/memoize.js
/** Error message constants. */
var FUNC_ERROR_TEXT = 'Expected a function';
/**
* Creates a function that memoizes the result of `func`. If `resolver` is
* provided, it determines the cache key for storing the result based on the
* arguments provided to the memoized function. By default, the first argument
* provided to the memoized function is used as the map cache key. The `func`
* is invoked with the `this` binding of the memoized function.
*
* **Note:** The cache is exposed as the `cache` property on the memoized
* function. Its creation may be customized by replacing the `_.memoize.Cache`
* constructor with one whose instances implement the
* [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
* method interface of `clear`, `delete`, `get`, `has`, and `set`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {Function} func The function to have its output memoized.
* @param {Function} [resolver] The function to resolve the cache key.
* @returns {Function} Returns the new memoized function.
* @example
*
* var object = { 'a': 1, 'b': 2 };
* var other = { 'c': 3, 'd': 4 };
*
* var values = _.memoize(_.values);
* values(object);
* // => [1, 2]
*
* values(other);
* // => [3, 4]
*
* object.a = 2;
* values(object);
* // => [1, 2]
*
* // Modify the result cache.
* values.cache.set(object, ['a', 'b']);
* values(object);
* // => ['a', 'b']
*
* // Replace `_.memoize.Cache`.
* _.memoize.Cache = WeakMap;
*/
function memoize(func, resolver) {
if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
throw new TypeError(FUNC_ERROR_TEXT);
}
var memoized = function() {
var args = arguments,
key = resolver ? resolver.apply(this, args) : args[0],
cache = memoized.cache;
if (cache.has(key)) {
return cache.get(key);
}
var result = func.apply(this, args);
memoized.cache = cache.set(key, result) || cache;
return result;
};
memoized.cache = new (memoize.Cache || _MapCache);
return memoized;
}
// Expose `MapCache`.
memoize.Cache = _MapCache;
/* harmony default export */ var lodash_es_memoize = (memoize);
;// ./node_modules/lodash-es/_memoizeCapped.js
/** Used as the maximum memoize cache size. */
var MAX_MEMOIZE_SIZE = 500;
/**
* A specialized version of `_.memoize` which clears the memoized function's
* cache when it exceeds `MAX_MEMOIZE_SIZE`.
*
* @private
* @param {Function} func The function to have its output memoized.
* @returns {Function} Returns the new memoized function.
*/
function memoizeCapped(func) {
var result = lodash_es_memoize(func, function(key) {
if (cache.size === MAX_MEMOIZE_SIZE) {
cache.clear();
}
return key;
});
var cache = result.cache;
return result;
}
/* harmony default export */ var _memoizeCapped = (memoizeCapped);
;// ./node_modules/lodash-es/_stringToPath.js
/** Used to match property names within property paths. */
var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
/** Used to match backslashes in property paths. */
var reEscapeChar = /\\(\\)?/g;
/**
* Converts `string` to a property path array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the property path array.
*/
var stringToPath = _memoizeCapped(function(string) {
var result = [];
if (string.charCodeAt(0) === 46 /* . */) {
result.push('');
}
string.replace(rePropName, function(match, number, quote, subString) {
result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
});
return result;
});
/* harmony default export */ var _stringToPath = (stringToPath);
;// ./node_modules/lodash-es/_baseToString.js
/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0;
/** Used to convert symbols to primitives and strings. */
var _baseToString_symbolProto = _Symbol ? _Symbol.prototype : undefined,
symbolToString = _baseToString_symbolProto ? _baseToString_symbolProto.toString : undefined;
/**
* The base implementation of `_.toString` which doesn't convert nullish
* values to empty strings.
*
* @private
* @param {*} value The value to process.
* @returns {string} Returns the string.
*/
function baseToString(value) {
// Exit early for strings to avoid a performance hit in some environments.
if (typeof value == 'string') {
return value;
}
if (lodash_es_isArray(value)) {
// Recursively convert values (susceptible to call stack limits).
return _arrayMap(value, baseToString) + '';
}
if (lodash_es_isSymbol(value)) {
return symbolToString ? symbolToString.call(value) : '';
}
var result = (value + '');
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
}
/* harmony default export */ var _baseToString = (baseToString);
;// ./node_modules/lodash-es/toString.js
/**
* Converts `value` to a string. An empty string is returned for `null`
* and `undefined` values. The sign of `-0` is preserved.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to convert.
* @returns {string} Returns the converted string.
* @example
*
* _.toString(null);
* // => ''
*
* _.toString(-0);
* // => '-0'
*
* _.toString([1, 2, 3]);
* // => '1,2,3'
*/
function toString_toString(value) {
return value == null ? '' : _baseToString(value);
}
/* harmony default export */ var lodash_es_toString = (toString_toString);
;// ./node_modules/lodash-es/_castPath.js
/**
* Casts `value` to a path array if it's not one.
*
* @private
* @param {*} value The value to inspect.
* @param {Object} [object] The object to query keys on.
* @returns {Array} Returns the cast property path array.
*/
function castPath(value, object) {
if (lodash_es_isArray(value)) {
return value;
}
return _isKey(value, object) ? [value] : _stringToPath(lodash_es_toString(value));
}
/* harmony default export */ var _castPath = (castPath);
;// ./node_modules/lodash-es/_toKey.js
/** Used as references for various `Number` constants. */
var _toKey_INFINITY = 1 / 0;
/**
* Converts `value` to a string key if it's not a string or symbol.
*
* @private
* @param {*} value The value to inspect.
* @returns {string|symbol} Returns the key.
*/
function toKey(value) {
if (typeof value == 'string' || lodash_es_isSymbol(value)) {
return value;
}
var result = (value + '');
return (result == '0' && (1 / value) == -_toKey_INFINITY) ? '-0' : result;
}
/* harmony default export */ var _toKey = (toKey);
;// ./node_modules/lodash-es/_baseGet.js
/**
* The base implementation of `_.get` without support for default values.
*
* @private
* @param {Object} object The object to query.
* @param {Array|string} path The path of the property to get.
* @returns {*} Returns the resolved value.
*/
function baseGet(object, path) {
path = _castPath(path, object);
var index = 0,
length = path.length;
while (object != null && index < length) {
object = object[_toKey(path[index++])];
}
return (index && index == length) ? object : undefined;
}
/* harmony default export */ var _baseGet = (baseGet);
;// ./node_modules/lodash-es/get.js
/**
* Gets the value at `path` of `object`. If the resolved value is
* `undefined`, the `defaultValue` is returned in its place.
*
* @static
* @memberOf _
* @since 3.7.0
* @category Object
* @param {Object} object The object to query.
* @param {Array|string} path The path of the property to get.
* @param {*} [defaultValue] The value returned for `undefined` resolved values.
* @returns {*} Returns the resolved value.
* @example
*
* var object = { 'a': [{ 'b': { 'c': 3 } }] };
*
* _.get(object, 'a[0].b.c');
* // => 3
*
* _.get(object, ['a', '0', 'b', 'c']);
* // => 3
*
* _.get(object, 'a.b.c', 'default');
* // => 'default'
*/
function get(object, path, defaultValue) {
var result = object == null ? undefined : _baseGet(object, path);
return result === undefined ? defaultValue : result;
}
/* harmony default export */ var lodash_es_get = (get);
;// ./node_modules/lodash-es/_baseHasIn.js
/**
* The base implementation of `_.hasIn` without support for deep paths.
*
* @private
* @param {Object} [object] The object to query.
* @param {Array|string} key The key to check.
* @returns {boolean} Returns `true` if `key` exists, else `false`.
*/
function baseHasIn(object, key) {
return object != null && key in Object(object);
}
/* harmony default export */ var _baseHasIn = (baseHasIn);
;// ./node_modules/lodash-es/_hasPath.js
/**
* Checks if `path` exists on `object`.
*
* @private
* @param {Object} object The object to query.
* @param {Array|string} path The path to check.
* @param {Function} hasFunc The function to check properties.
* @returns {boolean} Returns `true` if `path` exists, else `false`.
*/
function hasPath(object, path, hasFunc) {
path = _castPath(path, object);
var index = -1,
length = path.length,
result = false;
while (++index < length) {
var key = _toKey(path[index]);
if (!(result = object != null && hasFunc(object, key))) {
break;
}
object = object[key];
}
if (result || ++index != length) {
return result;
}
length = object == null ? 0 : object.length;
return !!length && lodash_es_isLength(length) && _isIndex(key, length) &&
(lodash_es_isArray(object) || lodash_es_isArguments(object));
}
/* harmony default export */ var _hasPath = (hasPath);
;// ./node_modules/lodash-es/hasIn.js
/**
* Checks if `path` is a direct or inherited property of `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The object to query.
* @param {Array|string} path The path to check.
* @returns {boolean} Returns `true` if `path` exists, else `false`.
* @example
*
* var object = _.create({ 'a': _.create({ 'b': 2 }) });
*
* _.hasIn(object, 'a');
* // => true
*
* _.hasIn(object, 'a.b');
* // => true
*
* _.hasIn(object, ['a', 'b']);
* // => true
*
* _.hasIn(object, 'b');
* // => false
*/
function hasIn(object, path) {
return object != null && _hasPath(object, path, _baseHasIn);
}
/* harmony default export */ var lodash_es_hasIn = (hasIn);
;// ./node_modules/lodash-es/_baseMatchesProperty.js
/** Used to compose bitmasks for value comparisons. */
var _baseMatchesProperty_COMPARE_PARTIAL_FLAG = 1,
_baseMatchesProperty_COMPARE_UNORDERED_FLAG = 2;
/**
* The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
*
* @private
* @param {string} path The path of the property to get.
* @param {*} srcValue The value to match.
* @returns {Function} Returns the new spec function.
*/
function baseMatchesProperty(path, srcValue) {
if (_isKey(path) && _isStrictComparable(srcValue)) {
return _matchesStrictComparable(_toKey(path), srcValue);
}
return function(object) {
var objValue = lodash_es_get(object, path);
return (objValue === undefined && objValue === srcValue)
? lodash_es_hasIn(object, path)
: _baseIsEqual(srcValue, objValue, _baseMatchesProperty_COMPARE_PARTIAL_FLAG | _baseMatchesProperty_COMPARE_UNORDERED_FLAG);
};
}
/* harmony default export */ var _baseMatchesProperty = (baseMatchesProperty);
;// ./node_modules/lodash-es/_baseProperty.js
/**
* The base implementation of `_.property` without support for deep paths.
*
* @private
* @param {string} key The key of the property to get.
* @returns {Function} Returns the new accessor function.
*/
function baseProperty(key) {
return function(object) {
return object == null ? undefined : object[key];
};
}
/* harmony default export */ var _baseProperty = (baseProperty);
;// ./node_modules/lodash-es/_basePropertyDeep.js
/**
* A specialized version of `baseProperty` which supports deep paths.
*
* @private
* @param {Array|string} path The path of the property to get.
* @returns {Function} Returns the new accessor function.
*/
function basePropertyDeep(path) {
return function(object) {
return _baseGet(object, path);
};
}
/* harmony default export */ var _basePropertyDeep = (basePropertyDeep);
;// ./node_modules/lodash-es/property.js
/**
* Creates a function that returns the value at `path` of a given object.
*
* @static
* @memberOf _
* @since 2.4.0
* @category Util
* @param {Array|string} path The path of the property to get.
* @returns {Function} Returns the new accessor function.
* @example
*
* var objects = [
* { 'a': { 'b': 2 } },
* { 'a': { 'b': 1 } }
* ];
*
* _.map(objects, _.property('a.b'));
* // => [2, 1]
*
* _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
* // => [1, 2]
*/
function property(path) {
return _isKey(path) ? _baseProperty(_toKey(path)) : _basePropertyDeep(path);
}
/* harmony default export */ var lodash_es_property = (property);
;// ./node_modules/lodash-es/_baseIteratee.js
/**
* The base implementation of `_.iteratee`.
*
* @private
* @param {*} [value=_.identity] The value to convert to an iteratee.
* @returns {Function} Returns the iteratee.
*/
function baseIteratee(value) {
// Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
// See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
if (typeof value == 'function') {
return value;
}
if (value == null) {
return lodash_es_identity;
}
if (typeof value == 'object') {
return lodash_es_isArray(value)
? _baseMatchesProperty(value[0], value[1])
: _baseMatches(value);
}
return lodash_es_property(value);
}
/* harmony default export */ var _baseIteratee = (baseIteratee);
;// ./node_modules/lodash-es/_baseForOwn.js
/**
* The base implementation of `_.forOwn` without support for iteratee shorthands.
*
* @private
* @param {Object} object The object to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Object} Returns `object`.
*/
function baseForOwn(object, iteratee) {
return object && _baseFor(object, iteratee, lodash_es_keys);
}
/* harmony default export */ var _baseForOwn = (baseForOwn);
;// ./node_modules/lodash-es/_createBaseEach.js
/**
* Creates a `baseEach` or `baseEachRight` function.
*
* @private
* @param {Function} eachFunc The function to iterate over a collection.
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {Function} Returns the new base function.
*/
function createBaseEach(eachFunc, fromRight) {
return function(collection, iteratee) {
if (collection == null) {
return collection;
}
if (!lodash_es_isArrayLike(collection)) {
return eachFunc(collection, iteratee);
}
var length = collection.length,
index = fromRight ? length : -1,
iterable = Object(collection);
while ((fromRight ? index-- : ++index < length)) {
if (iteratee(iterable[index], index, iterable) === false) {
break;
}
}
return collection;
};
}
/* harmony default export */ var _createBaseEach = (createBaseEach);
;// ./node_modules/lodash-es/_baseEach.js
/**
* The base implementation of `_.forEach` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array|Object} Returns `collection`.
*/
var baseEach = _createBaseEach(_baseForOwn);
/* harmony default export */ var _baseEach = (baseEach);
;// ./node_modules/lodash-es/_baseMap.js
/**
* The base implementation of `_.map` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns the new mapped array.
*/
function baseMap(collection, iteratee) {
var index = -1,
result = lodash_es_isArrayLike(collection) ? Array(collection.length) : [];
_baseEach(collection, function(value, key, collection) {
result[++index] = iteratee(value, key, collection);
});
return result;
}
/* harmony default export */ var _baseMap = (baseMap);
;// ./node_modules/lodash-es/map.js
/**
* Creates an array of values by running each element in `collection` thru
* `iteratee`. The iteratee is invoked with three arguments:
* (value, index|key, collection).
*
* Many lodash methods are guarded to work as iteratees for methods like
* `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
*
* The guarded methods are:
* `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
* `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
* `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
* `template`, `trim`, `trimEnd`, `trimStart`, and `words`
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Array} Returns the new mapped array.
* @example
*
* function square(n) {
* return n * n;
* }
*
* _.map([4, 8], square);
* // => [16, 64]
*
* _.map({ 'a': 4, 'b': 8 }, square);
* // => [16, 64] (iteration order is not guaranteed)
*
* var users = [
* { 'user': 'barney' },
* { 'user': 'fred' }
* ];
*
* // The `_.property` iteratee shorthand.
* _.map(users, 'user');
* // => ['barney', 'fred']
*/
function map_map(collection, iteratee) {
var func = lodash_es_isArray(collection) ? _arrayMap : _baseMap;
return func(collection, _baseIteratee(iteratee, 3));
}
/* harmony default export */ var lodash_es_map = (map_map);
;// ./node_modules/naive-ui/es/popover/src/styles/index.cssr.mjs
const oppositePlacement = {
top: 'bottom',
bottom: 'top',
left: 'right',
right: 'left'
};
const arrowSize = 'var(--n-arrow-height) * 1.414';
// vars:
// --n-bezier
// --n-bezier-ease-in
// --n-bezier-ease-out
// --n-font-size
// --n-text-color
// --n-color
// --n-border-radius
// --n-arrow-height
// --n-arrow-offset
// --n-arrow-offset-vertical
// --n-padding
// --n-space
// --n-space-arrow
// --n-divider-color
/* harmony default export */ var popover_src_styles_index_cssr = (cssr_c([cB('popover', `
transition:
box-shadow .3s var(--n-bezier),
background-color .3s var(--n-bezier),
color .3s var(--n-bezier);
position: relative;
font-size: var(--n-font-size);
color: var(--n-text-color);
box-shadow: var(--n-box-shadow);
word-break: break-word;
`, [cssr_c('>', [cB('scrollbar', `
height: inherit;
max-height: inherit;
`)]), cNotM('raw', `
background-color: var(--n-color);
border-radius: var(--n-border-radius);
`, [cNotM('scrollable', [cNotM('show-header-or-footer', 'padding: var(--n-padding);')])]), cE('header', `
padding: var(--n-padding);
border-bottom: 1px solid var(--n-divider-color);
transition: border-color .3s var(--n-bezier);
`), cE('footer', `
padding: var(--n-padding);
border-top: 1px solid var(--n-divider-color);
transition: border-color .3s var(--n-bezier);
`), cM('scrollable, show-header-or-footer', [cE('content', `
padding: var(--n-padding);
`)])]), cB('popover-shared', `
transform-origin: inherit;
`, [cB('popover-arrow-wrapper', `
position: absolute;
overflow: hidden;
pointer-events: none;
`, [cB('popover-arrow', `
transition: background-color .3s var(--n-bezier);
position: absolute;
display: block;
width: calc(${arrowSize});
height: calc(${arrowSize});
box-shadow: 0 0 8px 0 rgba(0, 0, 0, .12);
transform: rotate(45deg);
background-color: var(--n-color);
pointer-events: all;
`)]),
// body transition
cssr_c('&.popover-transition-enter-from, &.popover-transition-leave-to', `
opacity: 0;
transform: scale(.85);
`), cssr_c('&.popover-transition-enter-to, &.popover-transition-leave-from', `
transform: scale(1);
opacity: 1;
`), cssr_c('&.popover-transition-enter-active', `
transition:
box-shadow .3s var(--n-bezier),
background-color .3s var(--n-bezier),
color .3s var(--n-bezier),
opacity .15s var(--n-bezier-ease-out),
transform .15s var(--n-bezier-ease-out);
`), cssr_c('&.popover-transition-leave-active', `
transition:
box-shadow .3s var(--n-bezier),
background-color .3s var(--n-bezier),
color .3s var(--n-bezier),
opacity .15s var(--n-bezier-ease-in),
transform .15s var(--n-bezier-ease-in);
`)]), placementStyle('top-start', `
top: calc(${arrowSize} / -2);
left: calc(${getArrowOffset('top-start')} - var(--v-offset-left));
`), placementStyle('top', `
top: calc(${arrowSize} / -2);
transform: translateX(calc(${arrowSize} / -2)) rotate(45deg);
left: 50%;
`), placementStyle('top-end', `
top: calc(${arrowSize} / -2);
right: calc(${getArrowOffset('top-end')} + var(--v-offset-left));
`), placementStyle('bottom-start', `
bottom: calc(${arrowSize} / -2);
left: calc(${getArrowOffset('bottom-start')} - var(--v-offset-left));
`), placementStyle('bottom', `
bottom: calc(${arrowSize} / -2);
transform: translateX(calc(${arrowSize} / -2)) rotate(45deg);
left: 50%;
`), placementStyle('bottom-end', `
bottom: calc(${arrowSize} / -2);
right: calc(${getArrowOffset('bottom-end')} + var(--v-offset-left));
`), placementStyle('left-start', `
left: calc(${arrowSize} / -2);
top: calc(${getArrowOffset('left-start')} - var(--v-offset-top));
`), placementStyle('left', `
left: calc(${arrowSize} / -2);
transform: translateY(calc(${arrowSize} / -2)) rotate(45deg);
top: 50%;
`), placementStyle('left-end', `
left: calc(${arrowSize} / -2);
bottom: calc(${getArrowOffset('left-end')} + var(--v-offset-top));
`), placementStyle('right-start', `
right: calc(${arrowSize} / -2);
top: calc(${getArrowOffset('right-start')} - var(--v-offset-top));
`), placementStyle('right', `
right: calc(${arrowSize} / -2);
transform: translateY(calc(${arrowSize} / -2)) rotate(45deg);
top: 50%;
`), placementStyle('right-end', `
right: calc(${arrowSize} / -2);
bottom: calc(${getArrowOffset('right-end')} + var(--v-offset-top));
`), ...lodash_es_map({
top: ['right-start', 'left-start'],
right: ['top-end', 'bottom-end'],
bottom: ['right-end', 'left-end'],
left: ['top-start', 'bottom-start']
}, (placements, direction) => {
const isVertical = ['right', 'left'].includes(direction);
const sizeType = isVertical ? 'width' : 'height';
return placements.map(placement => {
const isReverse = placement.split('-')[1] === 'end';
const targetSize = `var(--v-target-${sizeType}, 0px)`;
const centerOffset = `calc((${targetSize} - ${arrowSize}) / 2)`;
const offset = getArrowOffset(placement);
return cssr_c(`[v-placement="${placement}"] >`, [cB('popover-shared', [cM('center-arrow', [cB('popover-arrow', `${direction}: calc(max(${centerOffset}, ${offset}) ${isReverse ? '+' : '-'} var(--v-offset-${isVertical ? 'left' : 'top'}));`)])])]);
});
})]));
function getArrowOffset(placement) {
return ['top', 'bottom'].includes(placement.split('-')[0]) ? 'var(--n-arrow-offset)' : 'var(--n-arrow-offset-vertical)';
}
function placementStyle(placement, arrowStyleLiteral) {
const position = placement.split('-')[0];
const sizeStyle = ['top', 'bottom'].includes(position) ? 'height: var(--n-space-arrow);' : 'width: var(--n-space-arrow);';
return cssr_c(`[v-placement="${placement}"] >`, [cB('popover-shared', `
margin-${oppositePlacement[position]}: var(--n-space);
`, [cM('show-arrow', `
margin-${oppositePlacement[position]}: var(--n-space-arrow);
`), cM('overlap', `
margin: 0;
`), cCB('popover-arrow-wrapper', `
right: 0;
left: 0;
top: 0;
bottom: 0;
${position}: 100%;
${oppositePlacement[position]}: auto;
${sizeStyle}
`, [cB('popover-arrow', arrowStyleLiteral)])])]);
}
;// ./node_modules/naive-ui/es/popover/src/PopoverBody.mjs
const popoverBodyProps = Object.assign(Object.assign({}, use_theme.props), {
to: useAdjustedTo.propTo,
show: Boolean,
trigger: String,
showArrow: Boolean,
delay: Number,
duration: Number,
raw: Boolean,
arrowPointToCenter: Boolean,
arrowClass: String,
arrowStyle: [String, Object],
arrowWrapperClass: String,
arrowWrapperStyle: [String, Object],
displayDirective: String,
x: Number,
y: Number,
flip: Boolean,
overlap: Boolean,
placement: String,
width: [Number, String],
keepAliveOnHover: Boolean,
scrollable: Boolean,
contentClass: String,
contentStyle: [Object, String],
headerClass: String,
headerStyle: [Object, String],
footerClass: String,
footerStyle: [Object, String],
// private
internalDeactivateImmediately: Boolean,
animated: Boolean,
onClickoutside: Function,
internalTrapFocus: Boolean,
internalOnAfterLeave: Function,
// deprecated
minWidth: Number,
maxWidth: Number
});
function renderArrow({
arrowClass,
arrowStyle,
arrowWrapperClass,
arrowWrapperStyle,
clsPrefix
}) {
return h("div", {
key: "__popover-arrow__",
style: arrowWrapperStyle,
class: [`${clsPrefix}-popover-arrow-wrapper`, arrowWrapperClass]
}, h("div", {
class: [`${clsPrefix}-popover-arrow`, arrowClass],
style: arrowStyle
}));
}
/* harmony default export */ var PopoverBody = (defineComponent({
name: 'PopoverBody',
inheritAttrs: false,
props: popoverBodyProps,
setup(props, {
slots,
attrs
}) {
const {
namespaceRef,
mergedClsPrefixRef,
inlineThemeDisabled
} = useConfig(props);
const themeRef = use_theme('Popover', '-popover', popover_src_styles_index_cssr, popover_styles_light, props, mergedClsPrefixRef);
const followerRef = ref(null);
const NPopover = runtime_core_esm_bundler_inject('NPopover');
const bodyRef = ref(null);
const followerEnabledRef = ref(props.show);
const displayedRef = ref(false);
watchEffect(() => {
const {
show
} = props;
if (show && !isJsdom() && !props.internalDeactivateImmediately) {
displayedRef.value = true;
}
});
const directivesRef = runtime_core_esm_bundler_computed(() => {
const {
trigger,
onClickoutside
} = props;
const directives = [];
const {
positionManuallyRef: {
value: positionManually
}
} = NPopover;
if (!positionManually) {
if (trigger === 'click' && !onClickoutside) {
directives.push([es_clickoutside, handleClickOutside, undefined, {
capture: true
}]);
}
if (trigger === 'hover') {
directives.push([es_mousemoveoutside, handleMouseMoveOutside]);
}
}
if (onClickoutside) {
directives.push([es_clickoutside, handleClickOutside, undefined, {
capture: true
}]);
}
if (props.displayDirective === 'show' || props.animated && displayedRef.value) {
directives.push([vShow, props.show]);
}
return directives;
});
const cssVarsRef = runtime_core_esm_bundler_computed(() => {
const {
common: {
cubicBezierEaseInOut,
cubicBezierEaseIn,
cubicBezierEaseOut
},
self: {
space,
spaceArrow,
padding,
fontSize,
textColor,
dividerColor,
color,
boxShadow,
borderRadius,
arrowHeight,
arrowOffset,
arrowOffsetVertical
}
} = themeRef.value;
return {
'--n-box-shadow': boxShadow,
'--n-bezier': cubicBezierEaseInOut,
'--n-bezier-ease-in': cubicBezierEaseIn,
'--n-bezier-ease-out': cubicBezierEaseOut,
'--n-font-size': fontSize,
'--n-text-color': textColor,
'--n-color': color,
'--n-divider-color': dividerColor,
'--n-border-radius': borderRadius,
'--n-arrow-height': arrowHeight,
'--n-arrow-offset': arrowOffset,
'--n-arrow-offset-vertical': arrowOffsetVertical,
'--n-padding': padding,
'--n-space': space,
'--n-space-arrow': spaceArrow
};
});
const styleRef = runtime_core_esm_bundler_computed(() => {
const width = props.width === 'trigger' ? undefined : formatLength(props.width);
const style = [];
if (width) {
style.push({
width
});
}
const {
maxWidth,
minWidth
} = props;
if (maxWidth) {
style.push({
maxWidth: formatLength(maxWidth)
});
}
if (minWidth) {
style.push({
maxWidth: formatLength(minWidth)
});
}
if (!inlineThemeDisabled) {
style.push(cssVarsRef.value);
}
return style;
});
const themeClassHandle = inlineThemeDisabled ? useThemeClass('popover', undefined, cssVarsRef, props) : undefined;
NPopover.setBodyInstance({
syncPosition
});
runtime_core_esm_bundler_onBeforeUnmount(() => {
NPopover.setBodyInstance(null);
});
runtime_core_esm_bundler_watch(toRef(props, 'show'), value => {
// If no animation, no transition component will be applied to the
// component. So we need to trigger follower manaully.
if (props.animated) return;
if (value) {
followerEnabledRef.value = true;
} else {
followerEnabledRef.value = false;
}
});
function syncPosition() {
var _a;
(_a = followerRef.value) === null || _a === void 0 ? void 0 : _a.syncPosition();
}
function handleMouseEnter(e) {
if (props.trigger === 'hover' && props.keepAliveOnHover && props.show) {
NPopover.handleMouseEnter(e);
}
}
function handleMouseLeave(e) {
if (props.trigger === 'hover' && props.keepAliveOnHover) {
NPopover.handleMouseLeave(e);
}
}
function handleMouseMoveOutside(e) {
if (props.trigger === 'hover' && !getTriggerElement().contains(getPreciseEventTarget(e))) {
NPopover.handleMouseMoveOutside(e);
}
}
function handleClickOutside(e) {
if (props.trigger === 'click' && !getTriggerElement().contains(getPreciseEventTarget(e)) || props.onClickoutside) {
NPopover.handleClickOutside(e);
}
}
function getTriggerElement() {
return NPopover.getTriggerElement();
}
provide(popoverBodyInjectionKey, bodyRef);
provide(drawerBodyInjectionKey, null);
provide(modalBodyInjectionKey, null);
function renderContentNode() {
themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender();
const shouldRenderDom = props.displayDirective === 'show' || props.show || props.animated && displayedRef.value;
if (!shouldRenderDom) {
return null;
}
let contentNode;
const renderBody = NPopover.internalRenderBodyRef.value;
const {
value: mergedClsPrefix
} = mergedClsPrefixRef;
if (!renderBody) {
const {
value: extraClass
} = NPopover.extraClassRef;
const {
internalTrapFocus
} = props;
const hasHeaderOrFooter = !isSlotEmpty(slots.header) || !isSlotEmpty(slots.footer);
const renderContentInnerNode = () => {
var _a, _b;
const body = hasHeaderOrFooter ? h(Fragment, null, resolveWrappedSlot(slots.header, children => {
return children ? h("div", {
class: [`${mergedClsPrefix}-popover__header`, props.headerClass],
style: props.headerStyle
}, children) : null;
}), resolveWrappedSlot(slots.default, children => {
return children ? h("div", {
class: [`${mergedClsPrefix}-popover__content`, props.contentClass],
style: props.contentStyle
}, slots) : null;
}), resolveWrappedSlot(slots.footer, children => {
return children ? h("div", {
class: [`${mergedClsPrefix}-popover__footer`, props.footerClass],
style: props.footerStyle
}, children) : null;
})) : props.scrollable ? (_a = slots.default) === null || _a === void 0 ? void 0 : _a.call(slots) : h("div", {
class: [`${mergedClsPrefix}-popover__content`, props.contentClass],
style: props.contentStyle
}, slots);
const maybeScrollableBody = props.scrollable ? h(XScrollbar, {
contentClass: hasHeaderOrFooter ? undefined : `${mergedClsPrefix}-popover__content ${(_b = props.contentClass) !== null && _b !== void 0 ? _b : ''}`,
contentStyle: hasHeaderOrFooter ? undefined : props.contentStyle
}, {
default: () => body
}) : body;
const arrow = props.showArrow ? renderArrow({
arrowClass: props.arrowClass,
arrowStyle: props.arrowStyle,
arrowWrapperClass: props.arrowWrapperClass,
arrowWrapperStyle: props.arrowWrapperStyle,
clsPrefix: mergedClsPrefix
}) : null;
return [maybeScrollableBody, arrow];
};
contentNode = h('div', mergeProps({
class: [`${mergedClsPrefix}-popover`, `${mergedClsPrefix}-popover-shared`, themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass.value, extraClass.map(v => `${mergedClsPrefix}-${v}`), {
[`${mergedClsPrefix}-popover--scrollable`]: props.scrollable,
[`${mergedClsPrefix}-popover--show-header-or-footer`]: hasHeaderOrFooter,
[`${mergedClsPrefix}-popover--raw`]: props.raw,
[`${mergedClsPrefix}-popover-shared--overlap`]: props.overlap,
[`${mergedClsPrefix}-popover-shared--show-arrow`]: props.showArrow,
[`${mergedClsPrefix}-popover-shared--center-arrow`]: props.arrowPointToCenter
}],
ref: bodyRef,
style: styleRef.value,
onKeydown: NPopover.handleKeydown,
onMouseenter: handleMouseEnter,
onMouseleave: handleMouseLeave
}, attrs), internalTrapFocus ? h(FocusTrap, {
active: props.show,
autoFocus: true
}, {
default: renderContentInnerNode
}) : renderContentInnerNode());
} else {
contentNode = renderBody(
// The popover class and overlap class must exists, they will be used
// to place the body & transition animation.
// Shadow class exists for reuse box-shadow.
[`${mergedClsPrefix}-popover-shared`, themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass.value, props.overlap && `${mergedClsPrefix}-popover-shared--overlap`, props.showArrow && `${mergedClsPrefix}-popover-shared--show-arrow`, props.arrowPointToCenter && `${mergedClsPrefix}-popover-shared--center-arrow`], bodyRef, styleRef.value, handleMouseEnter, handleMouseLeave);
}
return withDirectives(contentNode, directivesRef.value);
}
return {
displayed: displayedRef,
namespace: namespaceRef,
isMounted: NPopover.isMountedRef,
zIndex: NPopover.zIndexRef,
followerRef,
adjustedTo: useAdjustedTo(props),
followerEnabled: followerEnabledRef,
renderContentNode
};
},
render() {
return h(Follower, {
ref: "followerRef",
zIndex: this.zIndex,
show: this.show,
enabled: this.followerEnabled,
to: this.adjustedTo,
x: this.x,
y: this.y,
flip: this.flip,
placement: this.placement,
containerClass: this.namespace,
overlap: this.overlap,
width: this.width === 'trigger' ? 'target' : undefined,
teleportDisabled: this.adjustedTo === useAdjustedTo.tdkey
}, {
default: () => {
return this.animated ? h(Transition, {
name: "popover-transition",
appear: this.isMounted,
// Don't use watch to enable follower, since the transition may
// make position sync timing very subtle and buggy.
onEnter: () => {
this.followerEnabled = true;
},
onAfterLeave: () => {
var _a;
(_a = this.internalOnAfterLeave) === null || _a === void 0 ? void 0 : _a.call(this);
this.followerEnabled = false;
this.displayed = false;
}
}, {
default: this.renderContentNode
}) : this.renderContentNode();
}
});
}
}));
;// ./node_modules/naive-ui/es/popover/src/Popover.mjs
const bodyPropKeys = Object.keys(popoverBodyProps);
const triggerEventMap = {
focus: ['onFocus', 'onBlur'],
click: ['onClick'],
hover: ['onMouseenter', 'onMouseleave'],
manual: [],
nested: ['onFocus', 'onBlur', 'onMouseenter', 'onMouseleave', 'onClick']
};
function appendEvents(vNode, trigger, events) {
triggerEventMap[trigger].forEach(eventName => {
if (!vNode.props) {
vNode.props = {};
} else {
vNode.props = Object.assign({}, vNode.props);
}
const originalHandler = vNode.props[eventName];
const handler = events[eventName];
if (!originalHandler) {
vNode.props[eventName] = handler;
} else {
vNode.props[eventName] = (...args) => {
originalHandler(...args);
handler(...args);
};
}
});
}
const popoverBaseProps = {
show: {
type: Boolean,
default: undefined
},
defaultShow: Boolean,
showArrow: {
type: Boolean,
default: true
},
trigger: {
type: String,
default: 'hover'
},
delay: {
type: Number,
default: 100
},
duration: {
type: Number,
default: 100
},
raw: Boolean,
placement: {
type: String,
default: 'top'
},
x: Number,
y: Number,
arrowPointToCenter: Boolean,
disabled: Boolean,
getDisabled: Function,
displayDirective: {
type: String,
default: 'if'
},
arrowClass: String,
arrowStyle: [String, Object],
arrowWrapperClass: String,
arrowWrapperStyle: [String, Object],
flip: {
type: Boolean,
default: true
},
animated: {
type: Boolean,
default: true
},
width: {
type: [Number, String],
default: undefined
},
overlap: Boolean,
keepAliveOnHover: {
type: Boolean,
default: true
},
zIndex: Number,
to: useAdjustedTo.propTo,
scrollable: Boolean,
contentClass: String,
contentStyle: [Object, String],
headerClass: String,
headerStyle: [Object, String],
footerClass: String,
footerStyle: [Object, String],
// events
onClickoutside: Function,
'onUpdate:show': [Function, Array],
onUpdateShow: [Function, Array],
// internal
internalDeactivateImmediately: Boolean,
internalSyncTargetWithParent: Boolean,
internalInheritedEventHandlers: {
type: Array,
default: () => []
},
internalTrapFocus: Boolean,
internalExtraClass: {
type: Array,
default: () => []
},
// deprecated
onShow: [Function, Array],
onHide: [Function, Array],
arrow: {
type: Boolean,
default: undefined
},
minWidth: Number,
maxWidth: Number
};
const popoverProps = Object.assign(Object.assign(Object.assign({}, use_theme.props), popoverBaseProps), {
internalOnAfterLeave: Function,
internalRenderBody: Function
});
/* harmony default export */ var Popover = (defineComponent({
name: 'Popover',
inheritAttrs: false,
props: popoverProps,
slots: Object,
__popover__: true,
setup(props) {
if (false) {}
const isMountedRef = isMounted();
const binderInstRef = ref(null);
// setup show
const controlledShowRef = runtime_core_esm_bundler_computed(() => props.show);
const uncontrolledShowRef = ref(props.defaultShow);
const mergedShowWithoutDisabledRef = useMergedState(controlledShowRef, uncontrolledShowRef);
const mergedShowConsideringDisabledPropRef = use_memo(() => {
if (props.disabled) return false;
return mergedShowWithoutDisabledRef.value;
});
const getMergedDisabled = () => {
if (props.disabled) return true;
const {
getDisabled
} = props;
if (getDisabled === null || getDisabled === void 0 ? void 0 : getDisabled()) return true;
return false;
};
const getMergedShow = () => {
if (getMergedDisabled()) return false;
return mergedShowWithoutDisabledRef.value;
};
// setup show-arrow
const compatibleShowArrowRef = useCompitable(props, ['arrow', 'showArrow']);
const mergedShowArrowRef = runtime_core_esm_bundler_computed(() => {
if (props.overlap) return false;
return compatibleShowArrowRef.value;
});
// bodyInstance
let bodyInstance = null;
const showTimerIdRef = ref(null);
const hideTimerIdRef = ref(null);
const positionManuallyRef = use_memo(() => {
return props.x !== undefined && props.y !== undefined;
});
// methods
function doUpdateShow(value) {
const {
'onUpdate:show': _onUpdateShow,
onUpdateShow,
onShow,
onHide
} = props;
uncontrolledShowRef.value = value;
if (_onUpdateShow) {
call(_onUpdateShow, value);
}
if (onUpdateShow) {
call(onUpdateShow, value);
}
if (value && onShow) {
call(onShow, true);
}
if (value && onHide) {
call(onHide, false);
}
}
function syncPosition() {
if (bodyInstance) {
bodyInstance.syncPosition();
}
}
function clearShowTimer() {
const {
value: showTimerId
} = showTimerIdRef;
if (showTimerId) {
window.clearTimeout(showTimerId);
showTimerIdRef.value = null;
}
}
function clearHideTimer() {
const {
value: hideTimerId
} = hideTimerIdRef;
if (hideTimerId) {
window.clearTimeout(hideTimerId);
hideTimerIdRef.value = null;
}
}
function handleFocus() {
const mergedDisabled = getMergedDisabled();
if (props.trigger === 'focus' && !mergedDisabled) {
if (getMergedShow()) return;
doUpdateShow(true);
}
}
function handleBlur() {
const mergedDisabled = getMergedDisabled();
if (props.trigger === 'focus' && !mergedDisabled) {
if (!getMergedShow()) return;
doUpdateShow(false);
}
}
function handleMouseEnter() {
const mergedDisabled = getMergedDisabled();
if (props.trigger === 'hover' && !mergedDisabled) {
clearHideTimer();
if (showTimerIdRef.value !== null) return;
if (getMergedShow()) return;
const delayCallback = () => {
doUpdateShow(true);
showTimerIdRef.value = null;
};
const {
delay
} = props;
if (delay === 0) {
delayCallback();
} else {
showTimerIdRef.value = window.setTimeout(delayCallback, delay);
}
}
}
function handleMouseLeave() {
const mergedDisabled = getMergedDisabled();
if (props.trigger === 'hover' && !mergedDisabled) {
clearShowTimer();
if (hideTimerIdRef.value !== null) return;
if (!getMergedShow()) return;
const delayedCallback = () => {
doUpdateShow(false);
hideTimerIdRef.value = null;
};
const {
duration
} = props;
if (duration === 0) {
delayedCallback();
} else {
hideTimerIdRef.value = window.setTimeout(delayedCallback, duration);
}
}
}
// will be called in popover-content
function handleMouseMoveOutside() {
handleMouseLeave();
}
// will be called in popover-content
function handleClickOutside(e) {
var _a;
if (!getMergedShow()) return;
if (props.trigger === 'click') {
clearShowTimer();
clearHideTimer();
doUpdateShow(false);
}
(_a = props.onClickoutside) === null || _a === void 0 ? void 0 : _a.call(props, e);
}
function handleClick() {
if (props.trigger === 'click' && !getMergedDisabled()) {
clearShowTimer();
clearHideTimer();
const nextShow = !getMergedShow();
doUpdateShow(nextShow);
}
}
function handleKeydown(e) {
if (!props.internalTrapFocus) return;
if (e.key === 'Escape') {
clearShowTimer();
clearHideTimer();
doUpdateShow(false);
}
}
function setShow(value) {
uncontrolledShowRef.value = value;
}
function getTriggerElement() {
var _a;
return (_a = binderInstRef.value) === null || _a === void 0 ? void 0 : _a.targetRef;
}
function setBodyInstance(value) {
bodyInstance = value;
}
provide('NPopover', {
getTriggerElement,
handleKeydown,
handleMouseEnter,
handleMouseLeave,
handleClickOutside,
handleMouseMoveOutside,
setBodyInstance,
positionManuallyRef,
isMountedRef,
zIndexRef: toRef(props, 'zIndex'),
extraClassRef: toRef(props, 'internalExtraClass'),
internalRenderBodyRef: toRef(props, 'internalRenderBody')
});
watchEffect(() => {
if (mergedShowWithoutDisabledRef.value && getMergedDisabled()) {
doUpdateShow(false);
}
});
const returned = {
binderInstRef,
positionManually: positionManuallyRef,
mergedShowConsideringDisabledProp: mergedShowConsideringDisabledPropRef,
// if to show popover body
uncontrolledShow: uncontrolledShowRef,
mergedShowArrow: mergedShowArrowRef,
getMergedShow,
setShow,
handleClick,
handleMouseEnter,
handleMouseLeave,
handleFocus,
handleBlur,
syncPosition
};
return returned;
},
render() {
var _a;
const {
positionManually,
$slots: slots
} = this;
let triggerVNode;
let popoverInside = false;
if (!positionManually) {
triggerVNode = getFirstSlotVNode(slots, 'trigger');
if (triggerVNode) {
triggerVNode = cloneVNode(triggerVNode);
triggerVNode = triggerVNode.type === Text ? h('span', [triggerVNode]) : triggerVNode;
const handlers = {
onClick: this.handleClick,
onMouseenter: this.handleMouseEnter,
onMouseleave: this.handleMouseLeave,
onFocus: this.handleFocus,
onBlur: this.handleBlur
};
if ((_a = triggerVNode.type) === null || _a === void 0 ? void 0 : _a.__popover__) {
popoverInside = true;
// We assume that there's no DOM event handlers on popover element
if (!triggerVNode.props) {
triggerVNode.props = {
internalSyncTargetWithParent: true,
internalInheritedEventHandlers: []
};
}
triggerVNode.props.internalSyncTargetWithParent = true;
if (!triggerVNode.props.internalInheritedEventHandlers) {
triggerVNode.props.internalInheritedEventHandlers = [handlers];
} else {
triggerVNode.props.internalInheritedEventHandlers = [handlers, ...triggerVNode.props.internalInheritedEventHandlers];
}
} else {
const {
internalInheritedEventHandlers
} = this;
const ascendantAndCurrentHandlers = [handlers, ...internalInheritedEventHandlers];
const mergedHandlers = {
onBlur: e => {
ascendantAndCurrentHandlers.forEach(_handlers => {
_handlers.onBlur(e);
});
},
onFocus: e => {
ascendantAndCurrentHandlers.forEach(_handlers => {
_handlers.onFocus(e);
});
},
onClick: e => {
ascendantAndCurrentHandlers.forEach(_handlers => {
_handlers.onClick(e);
});
},
onMouseenter: e => {
ascendantAndCurrentHandlers.forEach(_handlers => {
_handlers.onMouseenter(e);
});
},
onMouseleave: e => {
ascendantAndCurrentHandlers.forEach(_handlers => {
_handlers.onMouseleave(e);
});
}
};
appendEvents(triggerVNode, internalInheritedEventHandlers ? 'nested' : positionManually ? 'manual' : this.trigger, mergedHandlers);
}
}
}
return h(src_Binder, {
ref: "binderInstRef",
syncTarget: !popoverInside,
syncTargetWithParent: this.internalSyncTargetWithParent
}, {
default: () => {
// We need to subscribe it. Sometimes rerender won't ge triggered.
// `mergedShowConsideringDisabledProp` is not the final disabled status.
// In ellpisis it's dynamic.
void this.mergedShowConsideringDisabledProp;
const mergedShow = this.getMergedShow();
return [this.internalTrapFocus && mergedShow ? withDirectives(h("div", {
style: {
position: 'fixed',
top: 0,
right: 0,
bottom: 0,
left: 0
}
}), [[es_zindexable, {
enabled: mergedShow,
zIndex: this.zIndex
}]]) : null, positionManually ? null : h(Target, null, {
default: () => triggerVNode
}), h(PopoverBody, keep(this.$props, bodyPropKeys, Object.assign(Object.assign({}, this.$attrs), {
showArrow: this.mergedShowArrow,
show: mergedShow
})), {
default: () => {
var _a, _b;
return (_b = (_a = this.$slots).default) === null || _b === void 0 ? void 0 : _b.call(_a);
},
header: () => {
var _a, _b;
return (_b = (_a = this.$slots).header) === null || _b === void 0 ? void 0 : _b.call(_a);
},
footer: () => {
var _a, _b;
return (_b = (_a = this.$slots).footer) === null || _b === void 0 ? void 0 : _b.call(_a);
}
})];
}
});
}
}));
;// ./node_modules/naive-ui/es/_internal/icon/src/styles/index.cssr.mjs
/* harmony default export */ var icon_src_styles_index_cssr = (cB('base-icon', `
height: 1em;
width: 1em;
line-height: 1em;
text-align: center;
display: inline-block;
position: relative;
fill: currentColor;
transform: translateZ(0);
`, [cssr_c('svg', `
height: 1em;
width: 1em;
`)]));
;// ./node_modules/naive-ui/es/_internal/icon/src/Icon.mjs
/* harmony default export */ var Icon = (defineComponent({
name: 'BaseIcon',
props: {
role: String,
ariaLabel: String,
ariaDisabled: {
type: Boolean,
default: undefined
},
ariaHidden: {
type: Boolean,
default: undefined
},
clsPrefix: {
type: String,
required: true
},
onClick: Function,
onMousedown: Function,
onMouseup: Function
},
setup(props) {
useStyle('-base-icon', icon_src_styles_index_cssr, toRef(props, 'clsPrefix'));
},
render() {
return h("i", {
class: `${this.clsPrefix}-base-icon`,
onClick: this.onClick,
onMousedown: this.onMousedown,
onMouseup: this.onMouseup,
role: this.role,
"aria-label": this.ariaLabel,
"aria-hidden": this.ariaHidden,
"aria-disabled": this.ariaDisabled
}, this.$slots);
}
}));
;// ./node_modules/lodash-es/_baseSlice.js
/**
* The base implementation of `_.slice` without an iteratee call guard.
*
* @private
* @param {Array} array The array to slice.
* @param {number} [start=0] The start position.
* @param {number} [end=array.length] The end position.
* @returns {Array} Returns the slice of `array`.
*/
function baseSlice(array, start, end) {
var index = -1,
length = array.length;
if (start < 0) {
start = -start > length ? 0 : (length + start);
}
end = end > length ? length : end;
if (end < 0) {
end += length;
}
length = start > end ? 0 : ((end - start) >>> 0);
start >>>= 0;
var result = Array(length);
while (++index < length) {
result[index] = array[index + start];
}
return result;
}
/* harmony default export */ var _baseSlice = (baseSlice);
;// ./node_modules/lodash-es/_castSlice.js
/**
* Casts `array` to a slice if it's needed.
*
* @private
* @param {Array} array The array to inspect.
* @param {number} start The start position.
* @param {number} [end=array.length] The end position.
* @returns {Array} Returns the cast slice.
*/
function castSlice(array, start, end) {
var length = array.length;
end = end === undefined ? length : end;
return (!start && end >= length) ? array : _baseSlice(array, start, end);
}
/* harmony default export */ var _castSlice = (castSlice);
;// ./node_modules/lodash-es/_hasUnicode.js
/** Used to compose unicode character classes. */
var rsAstralRange = '\\ud800-\\udfff',
rsComboMarksRange = '\\u0300-\\u036f',
reComboHalfMarksRange = '\\ufe20-\\ufe2f',
rsComboSymbolsRange = '\\u20d0-\\u20ff',
rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
rsVarRange = '\\ufe0e\\ufe0f';
/** Used to compose unicode capture groups. */
var rsZWJ = '\\u200d';
/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']');
/**
* Checks if `string` contains Unicode symbols.
*
* @private
* @param {string} string The string to inspect.
* @returns {boolean} Returns `true` if a symbol is found, else `false`.
*/
function hasUnicode(string) {
return reHasUnicode.test(string);
}
/* harmony default export */ var _hasUnicode = (hasUnicode);
;// ./node_modules/lodash-es/_asciiToArray.js
/**
* Converts an ASCII `string` to an array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the converted array.
*/
function asciiToArray(string) {
return string.split('');
}
/* harmony default export */ var _asciiToArray = (asciiToArray);
;// ./node_modules/lodash-es/_unicodeToArray.js
/** Used to compose unicode character classes. */
var _unicodeToArray_rsAstralRange = '\\ud800-\\udfff',
_unicodeToArray_rsComboMarksRange = '\\u0300-\\u036f',
_unicodeToArray_reComboHalfMarksRange = '\\ufe20-\\ufe2f',
_unicodeToArray_rsComboSymbolsRange = '\\u20d0-\\u20ff',
_unicodeToArray_rsComboRange = _unicodeToArray_rsComboMarksRange + _unicodeToArray_reComboHalfMarksRange + _unicodeToArray_rsComboSymbolsRange,
_unicodeToArray_rsVarRange = '\\ufe0e\\ufe0f';
/** Used to compose unicode capture groups. */
var rsAstral = '[' + _unicodeToArray_rsAstralRange + ']',
rsCombo = '[' + _unicodeToArray_rsComboRange + ']',
rsFitz = '\\ud83c[\\udffb-\\udfff]',
rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
rsNonAstral = '[^' + _unicodeToArray_rsAstralRange + ']',
rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
_unicodeToArray_rsZWJ = '\\u200d';
/** Used to compose unicode regexes. */
var reOptMod = rsModifier + '?',
rsOptVar = '[' + _unicodeToArray_rsVarRange + ']?',
rsOptJoin = '(?:' + _unicodeToArray_rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
rsSeq = rsOptVar + reOptMod + rsOptJoin,
rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
/**
* Converts a Unicode `string` to an array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the converted array.
*/
function unicodeToArray(string) {
return string.match(reUnicode) || [];
}
/* harmony default export */ var _unicodeToArray = (unicodeToArray);
;// ./node_modules/lodash-es/_stringToArray.js
/**
* Converts `string` to an array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the converted array.
*/
function stringToArray(string) {
return _hasUnicode(string)
? _unicodeToArray(string)
: _asciiToArray(string);
}
/* harmony default export */ var _stringToArray = (stringToArray);
;// ./node_modules/lodash-es/_createCaseFirst.js
/**
* Creates a function like `_.lowerFirst`.
*
* @private
* @param {string} methodName The name of the `String` case method to use.
* @returns {Function} Returns the new case function.
*/
function createCaseFirst(methodName) {
return function(string) {
string = lodash_es_toString(string);
var strSymbols = _hasUnicode(string)
? _stringToArray(string)
: undefined;
var chr = strSymbols
? strSymbols[0]
: string.charAt(0);
var trailing = strSymbols
? _castSlice(strSymbols, 1).join('')
: string.slice(1);
return chr[methodName]() + trailing;
};
}
/* harmony default export */ var _createCaseFirst = (createCaseFirst);
;// ./node_modules/lodash-es/upperFirst.js
/**
* Converts the first character of `string` to upper case.
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the converted string.
* @example
*
* _.upperFirst('fred');
* // => 'Fred'
*
* _.upperFirst('FRED');
* // => 'FRED'
*/
var upperFirst = _createCaseFirst('toUpperCase');
/* harmony default export */ var lodash_es_upperFirst = (upperFirst);
;// ./node_modules/naive-ui/es/_internal/icons/replaceable.mjs
function replaceable(name, icon) {
const IconComponent = defineComponent({
render() {
return icon();
}
});
return defineComponent({
name: lodash_es_upperFirst(name),
setup() {
var _a;
const mergedIconsRef = (_a = runtime_core_esm_bundler_inject(context_configProviderInjectionKey, null)) === null || _a === void 0 ? void 0 : _a.mergedIconsRef;
return () => {
var _a;
const iconOverride = (_a = mergedIconsRef === null || mergedIconsRef === void 0 ? void 0 : mergedIconsRef.value) === null || _a === void 0 ? void 0 : _a[name];
return iconOverride ? iconOverride() : h(IconComponent, null);
};
}
});
}
;// ./node_modules/naive-ui/es/_internal/icons/Close.mjs
/* harmony default export */ var Close = (replaceable('close', () => h("svg", {
viewBox: "0 0 12 12",
version: "1.1",
xmlns: "http://www.w3.org/2000/svg",
"aria-hidden": true
}, h("g", {
stroke: "none",
"stroke-width": "1",
fill: "none",
"fill-rule": "evenodd"
}, h("g", {
fill: "currentColor",
"fill-rule": "nonzero"
}, h("path", {
d: "M2.08859116,2.2156945 L2.14644661,2.14644661 C2.32001296,1.97288026 2.58943736,1.95359511 2.7843055,2.08859116 L2.85355339,2.14644661 L6,5.293 L9.14644661,2.14644661 C9.34170876,1.95118446 9.65829124,1.95118446 9.85355339,2.14644661 C10.0488155,2.34170876 10.0488155,2.65829124 9.85355339,2.85355339 L6.707,6 L9.85355339,9.14644661 C10.0271197,9.32001296 10.0464049,9.58943736 9.91140884,9.7843055 L9.85355339,9.85355339 C9.67998704,10.0271197 9.41056264,10.0464049 9.2156945,9.91140884 L9.14644661,9.85355339 L6,6.707 L2.85355339,9.85355339 C2.65829124,10.0488155 2.34170876,10.0488155 2.14644661,9.85355339 C1.95118446,9.65829124 1.95118446,9.34170876 2.14644661,9.14644661 L5.293,6 L2.14644661,2.85355339 C1.97288026,2.67998704 1.95359511,2.41056264 2.08859116,2.2156945 L2.14644661,2.14644661 L2.08859116,2.2156945 Z"
}))))));
;// ./node_modules/naive-ui/es/_internal/close/src/styles/index.cssr.mjs
// vars:
// --n-close-border-radius
// --n-close-color-hover
// --n-close-color-pressed
// --n-close-icon-color
// --n-close-icon-color-hover
// --n-close-icon-color-pressed
// --n-close-icon-color-disabled
/* harmony default export */ var close_src_styles_index_cssr = (cB('base-close', `
display: flex;
align-items: center;
justify-content: center;
cursor: pointer;
background-color: transparent;
color: var(--n-close-icon-color);
border-radius: var(--n-close-border-radius);
height: var(--n-close-size);
width: var(--n-close-size);
font-size: var(--n-close-icon-size);
outline: none;
border: none;
position: relative;
padding: 0;
`, [cM('absolute', `
height: var(--n-close-icon-size);
width: var(--n-close-icon-size);
`), cssr_c('&::before', `
content: "";
position: absolute;
width: var(--n-close-size);
height: var(--n-close-size);
left: 50%;
top: 50%;
transform: translateY(-50%) translateX(-50%);
transition: inherit;
border-radius: inherit;
`), cNotM('disabled', [cssr_c('&:hover', `
color: var(--n-close-icon-color-hover);
`), cssr_c('&:hover::before', `
background-color: var(--n-close-color-hover);
`), cssr_c('&:focus::before', `
background-color: var(--n-close-color-hover);
`), cssr_c('&:active', `
color: var(--n-close-icon-color-pressed);
`), cssr_c('&:active::before', `
background-color: var(--n-close-color-pressed);
`)]), cM('disabled', `
cursor: not-allowed;
color: var(--n-close-icon-color-disabled);
background-color: transparent;
`), cM('round', [cssr_c('&::before', `
border-radius: 50%;
`)])]));
;// ./node_modules/naive-ui/es/_internal/close/src/Close.mjs
/* harmony default export */ var src_Close = (defineComponent({
name: 'BaseClose',
props: {
isButtonTag: {
type: Boolean,
default: true
},
clsPrefix: {
type: String,
required: true
},
disabled: {
type: Boolean,
default: undefined
},
focusable: {
type: Boolean,
default: true
},
round: Boolean,
onClick: Function,
absolute: Boolean
},
setup(props) {
useStyle('-base-close', close_src_styles_index_cssr, toRef(props, 'clsPrefix'));
return () => {
const {
clsPrefix,
disabled,
absolute,
round,
isButtonTag
} = props;
const Tag = isButtonTag ? 'button' : 'div';
return h(Tag, {
type: isButtonTag ? 'button' : undefined,
tabindex: disabled || !props.focusable ? -1 : 0,
"aria-disabled": disabled,
"aria-label": "close",
role: isButtonTag ? undefined : 'button',
disabled: disabled,
class: [`${clsPrefix}-base-close`, absolute && `${clsPrefix}-base-close--absolute`, disabled && `${clsPrefix}-base-close--disabled`, round && `${clsPrefix}-base-close--round`],
onMousedown: e => {
if (!props.focusable) {
e.preventDefault();
}
},
onClick: props.onClick
}, h(Icon, {
clsPrefix: clsPrefix
}, {
default: () => h(Close, null)
}));
};
}
}));
;// ./node_modules/naive-ui/es/_utils/vue/keysOf.mjs
function keysOf(obj) {
return Object.keys(obj);
}
;// ./node_modules/naive-ui/es/card/styles/_common.mjs
/* harmony default export */ var card_styles_common = ({
paddingSmall: '12px 16px 12px',
paddingMedium: '19px 24px 20px',
paddingLarge: '23px 32px 24px',
paddingHuge: '27px 40px 28px',
titleFontSizeSmall: '16px',
titleFontSizeMedium: '18px',
titleFontSizeLarge: '18px',
titleFontSizeHuge: '18px',
closeIconSize: '18px',
closeSize: '22px'
});
;// ./node_modules/naive-ui/es/card/styles/light.mjs
function card_styles_light_self(vars) {
const {
primaryColor,
borderRadius,
lineHeight,
fontSize,
cardColor,
textColor2,
textColor1,
dividerColor,
fontWeightStrong,
closeIconColor,
closeIconColorHover,
closeIconColorPressed,
closeColorHover,
closeColorPressed,
modalColor,
boxShadow1,
popoverColor,
actionColor
} = vars;
return Object.assign(Object.assign({}, card_styles_common), {
lineHeight,
color: cardColor,
colorModal: modalColor,
colorPopover: popoverColor,
colorTarget: primaryColor,
colorEmbedded: actionColor,
colorEmbeddedModal: actionColor,
colorEmbeddedPopover: actionColor,
textColor: textColor2,
titleTextColor: textColor1,
borderColor: dividerColor,
actionColor,
titleFontWeight: fontWeightStrong,
closeColorHover,
closeColorPressed,
closeBorderRadius: borderRadius,
closeIconColor,
closeIconColorHover,
closeIconColorPressed,
fontSizeSmall: fontSize,
fontSizeMedium: fontSize,
fontSizeLarge: fontSize,
fontSizeHuge: fontSize,
boxShadow: boxShadow1,
borderRadius
});
}
const cardLight = {
name: 'Card',
common: light,
self: card_styles_light_self
};
/* harmony default export */ var card_styles_light = (cardLight);
;// ./node_modules/naive-ui/es/card/src/styles/index.cssr.mjs
// vars:
// --n-bezier
// --n-border-radius
// --n-color
// --n-color-modal
// --n-color-popover
// --n-text-color
// --n-line-height
// --n-padding-top
// --n-padding-bottom
// --n-padding-left
// --n-font-size
// --n-action-color
// --n-title-font-weight
// --n-title-font-size
// --n-title-text-color
// --n-close-size
// --n-close-icon-size
// --n-close-color-hover
// --n-close-color-pressed
// --n-close-icon-color
// --n-close-icon-color-hover
// --n-close-icon-color-pressed
// --n-border-color
// --n-box-shadow
// --n-color-embedded
// --n-color-embedded-modal
// --n-color-embedded-popover
/* harmony default export */ var card_src_styles_index_cssr = (cssr_c([cB('card', `
font-size: var(--n-font-size);
line-height: var(--n-line-height);
display: flex;
flex-direction: column;
width: 100%;
box-sizing: border-box;
position: relative;
border-radius: var(--n-border-radius);
background-color: var(--n-color);
color: var(--n-text-color);
word-break: break-word;
transition:
color .3s var(--n-bezier),
background-color .3s var(--n-bezier),
box-shadow .3s var(--n-bezier),
border-color .3s var(--n-bezier);
`, [asModal({
background: 'var(--n-color-modal)'
}), cM('hoverable', [cssr_c('&:hover', 'box-shadow: var(--n-box-shadow);')]), cM('content-segmented', [cssr_c('>', [cE('content', {
paddingTop: 'var(--n-padding-bottom)'
})])]), cM('content-soft-segmented', [cssr_c('>', [cE('content', `
margin: 0 var(--n-padding-left);
padding: var(--n-padding-bottom) 0;
`)])]), cM('footer-segmented', [cssr_c('>', [cE('footer', {
paddingTop: 'var(--n-padding-bottom)'
})])]), cM('footer-soft-segmented', [cssr_c('>', [cE('footer', `
padding: var(--n-padding-bottom) 0;
margin: 0 var(--n-padding-left);
`)])]), cssr_c('>', [cB('card-header', `
box-sizing: border-box;
display: flex;
align-items: center;
font-size: var(--n-title-font-size);
padding:
var(--n-padding-top)
var(--n-padding-left)
var(--n-padding-bottom)
var(--n-padding-left);
`, [cE('main', `
font-weight: var(--n-title-font-weight);
transition: color .3s var(--n-bezier);
flex: 1;
min-width: 0;
color: var(--n-title-text-color);
`), cE('extra', `
display: flex;
align-items: center;
font-size: var(--n-font-size);
font-weight: 400;
transition: color .3s var(--n-bezier);
color: var(--n-text-color);
`), cE('close', `
margin: 0 0 0 8px;
transition:
background-color .3s var(--n-bezier),
color .3s var(--n-bezier);
`)]), cE('action', `
box-sizing: border-box;
transition:
background-color .3s var(--n-bezier),
border-color .3s var(--n-bezier);
background-clip: padding-box;
background-color: var(--n-action-color);
`), cE('content', 'flex: 1; min-width: 0;'), cE('content, footer', `
box-sizing: border-box;
padding: 0 var(--n-padding-left) var(--n-padding-bottom) var(--n-padding-left);
font-size: var(--n-font-size);
`, [cssr_c('&:first-child', {
paddingTop: 'var(--n-padding-bottom)'
})]), cE('action', `
background-color: var(--n-action-color);
padding: var(--n-padding-bottom) var(--n-padding-left);
border-bottom-left-radius: var(--n-border-radius);
border-bottom-right-radius: var(--n-border-radius);
`)]), cB('card-cover', `
overflow: hidden;
width: 100%;
border-radius: var(--n-border-radius) var(--n-border-radius) 0 0;
`, [cssr_c('img', `
display: block;
width: 100%;
`)]), cM('bordered', `
border: 1px solid var(--n-border-color);
`, [cssr_c('&:target', 'border-color: var(--n-color-target);')]), cM('action-segmented', [cssr_c('>', [cE('action', [cssr_c('&:not(:first-child)', {
borderTop: '1px solid var(--n-border-color)'
})])])]), cM('content-segmented, content-soft-segmented', [cssr_c('>', [cE('content', {
transition: 'border-color 0.3s var(--n-bezier)'
}, [cssr_c('&:not(:first-child)', {
borderTop: '1px solid var(--n-border-color)'
})])])]), cM('footer-segmented, footer-soft-segmented', [cssr_c('>', [cE('footer', {
transition: 'border-color 0.3s var(--n-bezier)'
}, [cssr_c('&:not(:first-child)', {
borderTop: '1px solid var(--n-border-color)'
})])])]), cM('embedded', `
background-color: var(--n-color-embedded);
`)]), insideModal(cB('card', `
background: var(--n-color-modal);
`, [cM('embedded', `
background-color: var(--n-color-embedded-modal);
`)])), insidePopover(cB('card', `
background: var(--n-color-popover);
`, [cM('embedded', `
background-color: var(--n-color-embedded-popover);
`)]))]));
;// ./node_modules/naive-ui/es/card/src/Card.mjs
const cardBaseProps = {
title: [String, Function],
contentClass: String,
contentStyle: [Object, String],
headerClass: String,
headerStyle: [Object, String],
headerExtraClass: String,
headerExtraStyle: [Object, String],
footerClass: String,
footerStyle: [Object, String],
embedded: Boolean,
segmented: {
type: [Boolean, Object],
default: false
},
size: {
type: String,
default: 'medium'
},
bordered: {
type: Boolean,
default: true
},
closable: Boolean,
hoverable: Boolean,
role: String,
onClose: [Function, Array],
tag: {
type: String,
default: 'div'
},
cover: Function,
content: [String, Function],
footer: Function,
action: Function,
headerExtra: Function
};
const cardBasePropKeys = keysOf(cardBaseProps);
const cardProps = Object.assign(Object.assign({}, use_theme.props), cardBaseProps);
/* harmony default export */ var Card = (defineComponent({
name: 'Card',
props: cardProps,
slots: Object,
setup(props) {
const handleCloseClick = () => {
const {
onClose
} = props;
if (onClose) call(onClose);
};
const {
inlineThemeDisabled,
mergedClsPrefixRef,
mergedRtlRef
} = useConfig(props);
const themeRef = use_theme('Card', '-card', card_src_styles_index_cssr, card_styles_light, props, mergedClsPrefixRef);
const rtlEnabledRef = useRtl('Card', mergedRtlRef, mergedClsPrefixRef);
const cssVarsRef = runtime_core_esm_bundler_computed(() => {
const {
size
} = props;
const {
self: {
color,
colorModal,
colorTarget,
textColor,
titleTextColor,
titleFontWeight,
borderColor,
actionColor,
borderRadius,
lineHeight,
closeIconColor,
closeIconColorHover,
closeIconColorPressed,
closeColorHover,
closeColorPressed,
closeBorderRadius,
closeIconSize,
closeSize,
boxShadow,
colorPopover,
colorEmbedded,
colorEmbeddedModal,
colorEmbeddedPopover,
[createKey('padding', size)]: padding,
[createKey('fontSize', size)]: fontSize,
[createKey('titleFontSize', size)]: titleFontSize
},
common: {
cubicBezierEaseInOut
}
} = themeRef.value;
const {
top: paddingTop,
left: paddingLeft,
bottom: paddingBottom
} = getMargin(padding);
return {
'--n-bezier': cubicBezierEaseInOut,
'--n-border-radius': borderRadius,
'--n-color': color,
'--n-color-modal': colorModal,
'--n-color-popover': colorPopover,
'--n-color-embedded': colorEmbedded,
'--n-color-embedded-modal': colorEmbeddedModal,
'--n-color-embedded-popover': colorEmbeddedPopover,
'--n-color-target': colorTarget,
'--n-text-color': textColor,
'--n-line-height': lineHeight,
'--n-action-color': actionColor,
'--n-title-text-color': titleTextColor,
'--n-title-font-weight': titleFontWeight,
'--n-close-icon-color': closeIconColor,
'--n-close-icon-color-hover': closeIconColorHover,
'--n-close-icon-color-pressed': closeIconColorPressed,
'--n-close-color-hover': closeColorHover,
'--n-close-color-pressed': closeColorPressed,
'--n-border-color': borderColor,
'--n-box-shadow': boxShadow,
// size
'--n-padding-top': paddingTop,
'--n-padding-bottom': paddingBottom,
'--n-padding-left': paddingLeft,
'--n-font-size': fontSize,
'--n-title-font-size': titleFontSize,
'--n-close-size': closeSize,
'--n-close-icon-size': closeIconSize,
'--n-close-border-radius': closeBorderRadius
};
});
const themeClassHandle = inlineThemeDisabled ? useThemeClass('card', runtime_core_esm_bundler_computed(() => {
return props.size[0];
}), cssVarsRef, props) : undefined;
return {
rtlEnabled: rtlEnabledRef,
mergedClsPrefix: mergedClsPrefixRef,
mergedTheme: themeRef,
handleCloseClick,
cssVars: inlineThemeDisabled ? undefined : cssVarsRef,
themeClass: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass,
onRender: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender
};
},
render() {
const {
segmented,
bordered,
hoverable,
mergedClsPrefix,
rtlEnabled,
onRender,
embedded,
tag: Component,
$slots
} = this;
onRender === null || onRender === void 0 ? void 0 : onRender();
return h(Component, {
class: [`${mergedClsPrefix}-card`, this.themeClass, embedded && `${mergedClsPrefix}-card--embedded`, {
[`${mergedClsPrefix}-card--rtl`]: rtlEnabled,
[`${mergedClsPrefix}-card--content${typeof segmented !== 'boolean' && segmented.content === 'soft' ? '-soft' : ''}-segmented`]: segmented === true || segmented !== false && segmented.content,
[`${mergedClsPrefix}-card--footer${typeof segmented !== 'boolean' && segmented.footer === 'soft' ? '-soft' : ''}-segmented`]: segmented === true || segmented !== false && segmented.footer,
[`${mergedClsPrefix}-card--action-segmented`]: segmented === true || segmented !== false && segmented.action,
[`${mergedClsPrefix}-card--bordered`]: bordered,
[`${mergedClsPrefix}-card--hoverable`]: hoverable
}],
style: this.cssVars,
role: this.role
}, resolveWrappedSlot($slots.cover, children => {
const mergedChildren = this.cover ? resolve_slot_ensureValidVNode([this.cover()]) : children;
return mergedChildren && h("div", {
class: `${mergedClsPrefix}-card-cover`,
role: "none"
}, mergedChildren);
}), resolveWrappedSlot($slots.header, children => {
const {
title
} = this;
const mergedChildren = title ? resolve_slot_ensureValidVNode(typeof title === 'function' ? [title()] : [title]) : children;
return mergedChildren || this.closable ? h("div", {
class: [`${mergedClsPrefix}-card-header`, this.headerClass],
style: this.headerStyle,
role: "heading"
}, h("div", {
class: `${mergedClsPrefix}-card-header__main`,
role: "heading"
}, mergedChildren), resolveWrappedSlot($slots['header-extra'], children => {
const mergedChildren = this.headerExtra ? resolve_slot_ensureValidVNode([this.headerExtra()]) : children;
return mergedChildren && h("div", {
class: [`${mergedClsPrefix}-card-header__extra`, this.headerExtraClass],
style: this.headerExtraStyle
}, mergedChildren);
}), this.closable && h(src_Close, {
clsPrefix: mergedClsPrefix,
class: `${mergedClsPrefix}-card-header__close`,
onClick: this.handleCloseClick,
absolute: true
})) : null;
}), resolveWrappedSlot($slots.default, children => {
const {
content
} = this;
const mergedChildren = content ? resolve_slot_ensureValidVNode(typeof content === 'function' ? [content()] : [content]) : children;
return mergedChildren && h("div", {
class: [`${mergedClsPrefix}-card__content`, this.contentClass],
style: this.contentStyle,
role: "none"
}, mergedChildren);
}), resolveWrappedSlot($slots.footer, children => {
const mergedChildren = this.footer ? resolve_slot_ensureValidVNode([this.footer()]) : children;
return mergedChildren && h("div", {
class: [`${mergedClsPrefix}-card__footer`, this.footerClass],
style: this.footerStyle,
role: "none"
}, mergedChildren);
}), resolveWrappedSlot($slots.action, children => {
const mergedChildren = this.action ? resolve_slot_ensureValidVNode([this.action()]) : children;
return mergedChildren && h("div", {
class: `${mergedClsPrefix}-card__action`,
role: "none"
}, mergedChildren);
}));
}
}));
;// ./node_modules/seemly/es/css/responsive.js
function parseResponsiveProp(reponsiveProp) {
if (typeof reponsiveProp === "number") {
return {
'': reponsiveProp.toString()
};
}
const params = {};
reponsiveProp.split(/ +/).forEach((pairLiteral) => {
if (pairLiteral === '')
return;
const [prefix, value] = pairLiteral.split(':');
if (value === undefined) {
params[''] = prefix;
}
else {
params[prefix] = value;
}
});
return params;
}
function parseResponsivePropValue(reponsiveProp, activeKeyOrSize) {
var _a;
if (reponsiveProp === undefined || reponsiveProp === null)
return undefined;
const classObj = parseResponsiveProp(reponsiveProp);
if (activeKeyOrSize === undefined)
return classObj[''];
if (typeof activeKeyOrSize === 'string') {
return (_a = classObj[activeKeyOrSize]) !== null && _a !== void 0 ? _a : classObj[''];
}
else if (Array.isArray(activeKeyOrSize)) {
for (let i = activeKeyOrSize.length - 1; i >= 0; --i) {
const key = activeKeyOrSize[i];
if (key in classObj)
return classObj[key];
}
return classObj[''];
}
else {
// Here we suppose all the keys are number formatted
let activeValue = undefined;
let activeKey = -1;
Object.keys(classObj).forEach((key) => {
const keyAsNum = Number(key);
if (!Number.isNaN(keyAsNum) &&
activeKeyOrSize >= keyAsNum &&
keyAsNum >= activeKey) {
activeKey = keyAsNum;
activeValue = classObj[key];
}
});
return activeValue;
}
}
;// ./node_modules/vooks/es/use-breakpoints.js
/* eslint-disable @typescript-eslint/consistent-type-assertions */
const defaultBreakpointOptions = {
// mobile
// 0 ~ 640 doesn't mean it should display well in all the range,
// but means you should treat it like a mobile phone.)
xs: 0,
s: 640,
m: 1024,
l: 1280,
xl: 1536,
'2xl': 1920 // normal desktop display
};
function createMediaQuery(screenWidth) {
return `(min-width: ${screenWidth}px)`;
}
const mqlMap = {};
function useBreakpoints(screens = defaultBreakpointOptions) {
if (!utils_isBrowser)
return runtime_core_esm_bundler_computed(() => []);
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
if (typeof window.matchMedia !== 'function')
return runtime_core_esm_bundler_computed(() => []);
const breakpointStatusRef = ref({});
const breakpoints = Object.keys(screens);
const updateBreakpoints = (e, breakpointName) => {
if (e.matches)
breakpointStatusRef.value[breakpointName] = true;
else
breakpointStatusRef.value[breakpointName] = false;
};
breakpoints.forEach((key) => {
const breakpointValue = screens[key];
let mql;
let cbs;
if (mqlMap[breakpointValue] === undefined) {
mql = window.matchMedia(createMediaQuery(breakpointValue));
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
if (mql.addEventListener) {
mql.addEventListener('change', (e) => {
cbs.forEach((cb) => {
cb(e, key);
});
});
// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
}
else if (mql.addListener) {
mql.addListener((e) => {
cbs.forEach((cb) => {
cb(e, key);
});
});
}
cbs = new Set();
mqlMap[breakpointValue] = {
mql,
cbs
};
}
else {
mql = mqlMap[breakpointValue].mql;
cbs = mqlMap[breakpointValue].cbs;
}
cbs.add(updateBreakpoints);
if (mql.matches) {
cbs.forEach((cb) => {
cb(mql, key);
});
}
});
runtime_core_esm_bundler_onBeforeUnmount(() => {
breakpoints.forEach((breakpoint) => {
const { cbs } = mqlMap[screens[breakpoint]];
if (cbs.has(updateBreakpoints)) {
cbs.delete(updateBreakpoints);
}
});
});
return runtime_core_esm_bundler_computed(() => {
const { value } = breakpointStatusRef;
return breakpoints.filter((key) => value[key]);
});
}
/* harmony default export */ var use_breakpoints = (useBreakpoints);
;// ./node_modules/naive-ui/es/_utils/vue/is-node-v-show-false.mjs
function isNodeVShowFalse(vNode) {
var _a;
const showDir = (_a = vNode.dirs) === null || _a === void 0 ? void 0 : _a.find(({
dir
}) => dir === vShow);
return !!(showDir && showDir.value === false);
}
;// ./node_modules/naive-ui/es/config-provider/src/config.mjs
const defaultBreakpoints = {
xs: 0,
// mobile
s: 640,
// tablet
m: 1024,
// laptop s
l: 1280,
// laptop
xl: 1536,
// laptop l
xxl: 1920 // normal desktop display
};
;// ./node_modules/naive-ui/es/grid/src/config.mjs
const defaultSpan = 1;
const gridInjectionKey = createInjectionKey('n-grid');
;// ./node_modules/naive-ui/es/grid/src/Grid.mjs
const defaultCols = 24;
const SSR_ATTR_NAME = '__ssr__';
const gridProps = {
layoutShiftDisabled: Boolean,
responsive: {
type: [String, Boolean],
default: 'self'
},
cols: {
type: [Number, String],
default: defaultCols
},
itemResponsive: Boolean,
collapsed: Boolean,
// may create grid rows < collapsedRows since a item may take all the row
collapsedRows: {
type: Number,
default: 1
},
itemStyle: [Object, String],
xGap: {
type: [Number, String],
default: 0
},
yGap: {
type: [Number, String],
default: 0
}
};
/* harmony default export */ var Grid = (defineComponent({
name: 'Grid',
inheritAttrs: false,
props: gridProps,
setup(props) {
const {
mergedClsPrefixRef,
mergedBreakpointsRef
} = useConfig(props);
const numRegex = /^\d+$/;
const widthRef = ref(undefined);
const breakpointsRef = use_breakpoints((mergedBreakpointsRef === null || mergedBreakpointsRef === void 0 ? void 0 : mergedBreakpointsRef.value) || defaultBreakpoints);
const isResponsiveRef = use_memo(() => {
if (props.itemResponsive) return true;
if (!numRegex.test(props.cols.toString())) return true;
if (!numRegex.test(props.xGap.toString())) return true;
if (!numRegex.test(props.yGap.toString())) return true;
return false;
});
const responsiveQueryRef = runtime_core_esm_bundler_computed(() => {
if (!isResponsiveRef.value) return undefined;
return props.responsive === 'self' ? widthRef.value : breakpointsRef.value;
});
const responsiveColsRef = use_memo(() => {
var _a;
return (_a = Number(parseResponsivePropValue(props.cols.toString(), responsiveQueryRef.value))) !== null && _a !== void 0 ? _a : defaultCols;
});
const responsiveXGapRef = use_memo(() => parseResponsivePropValue(props.xGap.toString(), responsiveQueryRef.value));
const responsiveYGapRef = use_memo(() => parseResponsivePropValue(props.yGap.toString(), responsiveQueryRef.value));
const handleResize = entry => {
widthRef.value = entry.contentRect.width;
};
const handleResizeRaf = entry => {
beforeNextFrameOnce(handleResize, entry);
};
const overflowRef = ref(false);
const handleResizeRef = runtime_core_esm_bundler_computed(() => {
if (props.responsive === 'self') {
return handleResizeRaf;
}
return undefined;
});
// for SSR, fix bug https://github.com/tusen-ai/naive-ui/issues/2462
const isSsrRef = ref(false);
const contentElRef = ref();
runtime_core_esm_bundler_onMounted(() => {
const {
value: contentEl
} = contentElRef;
if (contentEl) {
if (contentEl.hasAttribute(SSR_ATTR_NAME)) {
contentEl.removeAttribute(SSR_ATTR_NAME);
isSsrRef.value = true;
}
}
});
provide(gridInjectionKey, {
layoutShiftDisabledRef: toRef(props, 'layoutShiftDisabled'),
isSsrRef,
itemStyleRef: toRef(props, 'itemStyle'),
xGapRef: responsiveXGapRef,
overflowRef
});
return {
isSsr: !is_browser_isBrowser,
contentEl: contentElRef,
mergedClsPrefix: mergedClsPrefixRef,
style: runtime_core_esm_bundler_computed(() => {
if (props.layoutShiftDisabled) {
return {
width: '100%',
display: 'grid',
gridTemplateColumns: `repeat(${props.cols}, minmax(0, 1fr))`,
columnGap: pxfy(props.xGap),
rowGap: pxfy(props.yGap)
};
}
return {
width: '100%',
display: 'grid',
gridTemplateColumns: `repeat(${responsiveColsRef.value}, minmax(0, 1fr))`,
columnGap: pxfy(responsiveXGapRef.value),
rowGap: pxfy(responsiveYGapRef.value)
};
}),
isResponsive: isResponsiveRef,
responsiveQuery: responsiveQueryRef,
responsiveCols: responsiveColsRef,
handleResize: handleResizeRef,
overflow: overflowRef
};
},
render() {
if (this.layoutShiftDisabled) {
return h('div', mergeProps({
ref: 'contentEl',
class: `${this.mergedClsPrefix}-grid`,
style: this.style
}, this.$attrs), this.$slots);
}
const renderContent = () => {
var _a, _b, _c, _d, _e, _f, _g;
this.overflow = false;
// render will be called twice when mounted, I can't figure out why
// 2 jobs will be pushed into job queues with same id, and then be flushed
const rawChildren = flatten_flatten(getSlot(this));
const childrenAndRawSpan = [];
const {
collapsed,
collapsedRows,
responsiveCols,
responsiveQuery
} = this;
rawChildren.forEach(child => {
var _a, _b, _c, _d, _e;
if (((_a = child === null || child === void 0 ? void 0 : child.type) === null || _a === void 0 ? void 0 : _a.__GRID_ITEM__) !== true) return;
if (isNodeVShowFalse(child)) {
const clonedNode = cloneVNode(child);
if (clonedNode.props) {
clonedNode.props.privateShow = false;
} else {
clonedNode.props = {
privateShow: false
};
}
childrenAndRawSpan.push({
child: clonedNode,
rawChildSpan: 0
});
return;
}
// We don't want v-show to control display, so we need to stripe it
// here, nor it may mess child's style
child.dirs = ((_b = child.dirs) === null || _b === void 0 ? void 0 : _b.filter(({
dir
}) => dir !== vShow)) || null;
if (((_c = child.dirs) === null || _c === void 0 ? void 0 : _c.length) === 0) {
child.dirs = null;
}
const clonedChild = cloneVNode(child);
const rawChildSpan = Number((_e = parseResponsivePropValue((_d = clonedChild.props) === null || _d === void 0 ? void 0 : _d.span, responsiveQuery)) !== null && _e !== void 0 ? _e : defaultSpan);
if (rawChildSpan === 0) return;
childrenAndRawSpan.push({
child: clonedChild,
rawChildSpan
});
});
let suffixSpan = 0;
const maybeSuffixNode = (_a = childrenAndRawSpan[childrenAndRawSpan.length - 1]) === null || _a === void 0 ? void 0 : _a.child;
if (maybeSuffixNode === null || maybeSuffixNode === void 0 ? void 0 : maybeSuffixNode.props) {
const suffixPropValue = (_b = maybeSuffixNode.props) === null || _b === void 0 ? void 0 : _b.suffix;
if (suffixPropValue !== undefined && suffixPropValue !== false) {
suffixSpan = Number((_d = parseResponsivePropValue((_c = maybeSuffixNode.props) === null || _c === void 0 ? void 0 : _c.span, responsiveQuery)) !== null && _d !== void 0 ? _d : defaultSpan);
maybeSuffixNode.props.privateSpan = suffixSpan;
maybeSuffixNode.props.privateColStart = responsiveCols + 1 - suffixSpan;
maybeSuffixNode.props.privateShow = (_e = maybeSuffixNode.props.privateShow) !== null && _e !== void 0 ? _e : true;
}
}
let spanCounter = 0;
let done = false;
for (const {
child,
rawChildSpan
} of childrenAndRawSpan) {
if (done) {
this.overflow = true;
}
if (!done) {
const childOffset = Number((_g = parseResponsivePropValue((_f = child.props) === null || _f === void 0 ? void 0 : _f.offset, responsiveQuery)) !== null && _g !== void 0 ? _g : 0);
// it could be 0 sometimes (v-show = false)
const childSpan = Math.min(rawChildSpan + childOffset, responsiveCols);
if (!child.props) {
child.props = {
privateSpan: childSpan,
privateOffset: childOffset
};
} else {
child.props.privateSpan = childSpan;
child.props.privateOffset = childOffset;
}
if (collapsed) {
const remainder = spanCounter % responsiveCols;
if (childSpan + remainder > responsiveCols) {
spanCounter += responsiveCols - remainder;
}
if (childSpan + spanCounter + suffixSpan > collapsedRows * responsiveCols) {
done = true;
} else {
spanCounter += childSpan;
}
}
}
if (done) {
if (child.props) {
// suffix node's privateShow may be true
if (child.props.privateShow !== true) {
child.props.privateShow = false;
}
} else {
child.props = {
privateShow: false
};
}
}
}
return h('div', mergeProps({
ref: 'contentEl',
class: `${this.mergedClsPrefix}-grid`,
style: this.style,
[SSR_ATTR_NAME]: this.isSsr || undefined
}, this.$attrs), childrenAndRawSpan.map(({
child
}) => child));
};
return this.isResponsive && this.responsive === 'self' ? h(VResizeObserver, {
onResize: this.handleResize
}, {
default: renderContent
}) : renderContent();
}
}));
;// ./node_modules/naive-ui/es/grid/src/GridItem.mjs
const GridItem_defaultSpan = 1;
const gridItemProps = {
span: {
type: [Number, String],
default: GridItem_defaultSpan
},
offset: {
type: [Number, String],
default: 0
},
suffix: Boolean,
// private props
privateOffset: Number,
privateSpan: Number,
privateColStart: Number,
privateShow: {
type: Boolean,
default: true
}
};
const gridItemPropKeys = keysOf(gridItemProps);
/* harmony default export */ var GridItem = (defineComponent({
__GRID_ITEM__: true,
name: 'GridItem',
alias: ['Gi'],
props: gridItemProps,
setup() {
const {
isSsrRef,
xGapRef,
itemStyleRef,
overflowRef,
layoutShiftDisabledRef
} = runtime_core_esm_bundler_inject(gridInjectionKey);
const self = runtime_core_esm_bundler_getCurrentInstance();
return {
overflow: overflowRef,
itemStyle: itemStyleRef,
layoutShiftDisabled: layoutShiftDisabledRef,
mergedXGap: runtime_core_esm_bundler_computed(() => {
return pxfy(xGapRef.value || 0);
}),
deriveStyle: () => {
void isSsrRef.value;
// Here is quite a hack, I hope there is a better way to solve it
const {
privateSpan = GridItem_defaultSpan,
privateShow = true,
privateColStart = undefined,
privateOffset = 0
} = self.vnode.props;
const {
value: xGap
} = xGapRef;
const mergedXGap = pxfy(xGap || 0);
return {
display: !privateShow ? 'none' : '',
gridColumn: `${privateColStart !== null && privateColStart !== void 0 ? privateColStart : `span ${privateSpan}`} / span ${privateSpan}`,
marginLeft: privateOffset ? `calc((100% - (${privateSpan} - 1) * ${mergedXGap}) / ${privateSpan} * ${privateOffset} + ${mergedXGap} * ${privateOffset})` : ''
};
}
};
},
render() {
var _a, _b;
if (this.layoutShiftDisabled) {
const {
span,
offset,
mergedXGap
} = this;
return h("div", {
style: {
gridColumn: `span ${span} / span ${span}`,
marginLeft: offset ? `calc((100% - (${span} - 1) * ${mergedXGap}) / ${span} * ${offset} + ${mergedXGap} * ${offset})` : ''
}
}, this.$slots);
}
return h("div", {
style: [this.itemStyle, this.deriveStyle()]
}, (_b = (_a = this.$slots).default) === null || _b === void 0 ? void 0 : _b.call(_a, {
overflow: this.overflow
}));
}
}));
;// ./node_modules/naive-ui/es/form/styles/_common.mjs
/* harmony default export */ var form_styles_common = ({
feedbackPadding: '4px 0 0 2px',
feedbackHeightSmall: '24px',
feedbackHeightMedium: '24px',
feedbackHeightLarge: '26px',
feedbackFontSizeSmall: '13px',
feedbackFontSizeMedium: '14px',
feedbackFontSizeLarge: '14px',
labelFontSizeLeftSmall: '14px',
labelFontSizeLeftMedium: '14px',
labelFontSizeLeftLarge: '15px',
labelFontSizeTopSmall: '13px',
labelFontSizeTopMedium: '14px',
labelFontSizeTopLarge: '14px',
labelHeightSmall: '24px',
labelHeightMedium: '26px',
labelHeightLarge: '28px',
labelPaddingVertical: '0 0 6px 2px',
labelPaddingHorizontal: '0 12px 0 0',
labelTextAlignVertical: 'left',
labelTextAlignHorizontal: 'right',
labelFontWeight: '400'
});
;// ./node_modules/naive-ui/es/form/styles/light.mjs
function form_styles_light_self(vars) {
const {
heightSmall,
heightMedium,
heightLarge,
textColor1,
errorColor,
warningColor,
lineHeight,
textColor3
} = vars;
return Object.assign(Object.assign({}, form_styles_common), {
blankHeightSmall: heightSmall,
blankHeightMedium: heightMedium,
blankHeightLarge: heightLarge,
lineHeight,
labelTextColor: textColor1,
asteriskColor: errorColor,
feedbackTextColorError: errorColor,
feedbackTextColorWarning: warningColor,
feedbackTextColor: textColor3
});
}
const formLight = {
name: 'Form',
common: light,
self: form_styles_light_self
};
/* harmony default export */ var form_styles_light = (formLight);
;// ./node_modules/naive-ui/es/form/src/context.mjs
const formInjectionKey = createInjectionKey('n-form');
const formItemInstsInjectionKey = createInjectionKey('n-form-item-insts');
;// ./node_modules/naive-ui/es/form/src/styles/form.cssr.mjs
/* harmony default export */ var form_cssr = (cB('form', [cM('inline', `
width: 100%;
display: inline-flex;
align-items: flex-start;
align-content: space-around;
`, [cB('form-item', {
width: 'auto',
marginRight: '18px'
}, [cssr_c('&:last-child', {
marginRight: 0
})])])]));
;// ./node_modules/naive-ui/es/form/src/Form.mjs
var __awaiter = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function (resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
const formProps = Object.assign(Object.assign({}, use_theme.props), {
inline: Boolean,
labelWidth: [Number, String],
labelAlign: String,
labelPlacement: {
type: String,
default: 'top'
},
model: {
type: Object,
default: () => {}
},
rules: Object,
disabled: Boolean,
size: String,
showRequireMark: {
type: Boolean,
default: undefined
},
requireMarkPlacement: String,
showFeedback: {
type: Boolean,
default: true
},
onSubmit: {
type: Function,
default: e => {
e.preventDefault();
}
},
showLabel: {
type: Boolean,
default: undefined
},
validateMessages: Object
});
/* harmony default export */ var Form = (defineComponent({
name: 'Form',
props: formProps,
setup(props) {
const {
mergedClsPrefixRef
} = useConfig(props);
use_theme('Form', '-form', form_cssr, form_styles_light, props, mergedClsPrefixRef);
// from path to form-item
const formItems = {};
// for label-width = 'auto'
const maxChildLabelWidthRef = ref(undefined);
const deriveMaxChildLabelWidth = currentWidth => {
const currentMaxChildLabelWidth = maxChildLabelWidthRef.value;
if (currentMaxChildLabelWidth === undefined || currentWidth >= currentMaxChildLabelWidth) {
maxChildLabelWidthRef.value = currentWidth;
}
};
function validate(validateCallback_1) {
return __awaiter(this, arguments, void 0, function* (validateCallback, shouldRuleBeApplied = () => true) {
return yield new Promise((resolve, reject) => {
const formItemValidationPromises = [];
for (const key of keysOf(formItems)) {
const formItemInstances = formItems[key];
for (const formItemInstance of formItemInstances) {
if (formItemInstance.path) {
formItemValidationPromises.push(formItemInstance.internalValidate(null, shouldRuleBeApplied));
}
}
}
void Promise.all(formItemValidationPromises).then(results => {
const formInvalid = results.some(result => !result.valid);
const errors = [];
const warnings = [];
results.forEach(result => {
var _a, _b;
if ((_a = result.errors) === null || _a === void 0 ? void 0 : _a.length) {
errors.push(result.errors);
}
if ((_b = result.warnings) === null || _b === void 0 ? void 0 : _b.length) {
warnings.push(result.warnings);
}
});
if (validateCallback) {
validateCallback(errors.length ? errors : undefined, {
warnings: warnings.length ? warnings : undefined
});
}
if (formInvalid) {
reject(errors.length ? errors : undefined);
} else {
resolve({
warnings: warnings.length ? warnings : undefined
});
}
});
});
});
}
function restoreValidation() {
for (const key of keysOf(formItems)) {
const formItemInstances = formItems[key];
for (const formItemInstance of formItemInstances) {
formItemInstance.restoreValidation();
}
}
}
provide(formInjectionKey, {
props,
maxChildLabelWidthRef,
deriveMaxChildLabelWidth
});
provide(formItemInstsInjectionKey, {
formItems
});
const formExposedMethod = {
validate,
restoreValidation
};
return Object.assign(formExposedMethod, {
mergedClsPrefix: mergedClsPrefixRef
});
},
render() {
const {
mergedClsPrefix
} = this;
return h("form", {
class: [`${mergedClsPrefix}-form`, this.inline && `${mergedClsPrefix}-form--inline`],
onSubmit: this.onSubmit
}, this.$slots);
}
}));
;// ./node_modules/async-validator/dist-web/index.js
function _extends() {
_extends = Object.assign ? Object.assign.bind() : function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends.apply(this, arguments);
}
function _inheritsLoose(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
_setPrototypeOf(subClass, superClass);
}
function _getPrototypeOf(o) {
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
function _isNativeReflectConstruct() {
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
if (Reflect.construct.sham) return false;
if (typeof Proxy === "function") return true;
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
return true;
} catch (e) {
return false;
}
}
function _construct(Parent, args, Class) {
if (_isNativeReflectConstruct()) {
_construct = Reflect.construct.bind();
} else {
_construct = function _construct(Parent, args, Class) {
var a = [null];
a.push.apply(a, args);
var Constructor = Function.bind.apply(Parent, a);
var instance = new Constructor();
if (Class) _setPrototypeOf(instance, Class.prototype);
return instance;
};
}
return _construct.apply(null, arguments);
}
function _isNativeFunction(fn) {
return Function.toString.call(fn).indexOf("[native code]") !== -1;
}
function _wrapNativeSuper(Class) {
var _cache = typeof Map === "function" ? new Map() : undefined;
_wrapNativeSuper = function _wrapNativeSuper(Class) {
if (Class === null || !_isNativeFunction(Class)) return Class;
if (typeof Class !== "function") {
throw new TypeError("Super expression must either be null or a function");
}
if (typeof _cache !== "undefined") {
if (_cache.has(Class)) return _cache.get(Class);
_cache.set(Class, Wrapper);
}
function Wrapper() {
return _construct(Class, arguments, _getPrototypeOf(this).constructor);
}
Wrapper.prototype = Object.create(Class.prototype, {
constructor: {
value: Wrapper,
enumerable: false,
writable: true,
configurable: true
}
});
return _setPrototypeOf(Wrapper, Class);
};
return _wrapNativeSuper(Class);
}
/* eslint no-console:0 */
var formatRegExp = /%[sdj%]/g;
var warning = function warning() {}; // don't print warning message when in production env or node runtime
if (typeof process !== 'undefined' && process.env && "production" !== 'production' && 0 && 0) {}
function convertFieldsError(errors) {
if (!errors || !errors.length) return null;
var fields = {};
errors.forEach(function (error) {
var field = error.field;
fields[field] = fields[field] || [];
fields[field].push(error);
});
return fields;
}
function format(template) {
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key];
}
var i = 0;
var len = args.length;
if (typeof template === 'function') {
return template.apply(null, args);
}
if (typeof template === 'string') {
var str = template.replace(formatRegExp, function (x) {
if (x === '%%') {
return '%';
}
if (i >= len) {
return x;
}
switch (x) {
case '%s':
return String(args[i++]);
case '%d':
return Number(args[i++]);
case '%j':
try {
return JSON.stringify(args[i++]);
} catch (_) {
return '[Circular]';
}
break;
default:
return x;
}
});
return str;
}
return template;
}
function isNativeStringType(type) {
return type === 'string' || type === 'url' || type === 'hex' || type === 'email' || type === 'date' || type === 'pattern';
}
function isEmptyValue(value, type) {
if (value === undefined || value === null) {
return true;
}
if (type === 'array' && Array.isArray(value) && !value.length) {
return true;
}
if (isNativeStringType(type) && typeof value === 'string' && !value) {
return true;
}
return false;
}
function asyncParallelArray(arr, func, callback) {
var results = [];
var total = 0;
var arrLength = arr.length;
function count(errors) {
results.push.apply(results, errors || []);
total++;
if (total === arrLength) {
callback(results);
}
}
arr.forEach(function (a) {
func(a, count);
});
}
function asyncSerialArray(arr, func, callback) {
var index = 0;
var arrLength = arr.length;
function next(errors) {
if (errors && errors.length) {
callback(errors);
return;
}
var original = index;
index = index + 1;
if (original < arrLength) {
func(arr[original], next);
} else {
callback([]);
}
}
next([]);
}
function flattenObjArr(objArr) {
var ret = [];
Object.keys(objArr).forEach(function (k) {
ret.push.apply(ret, objArr[k] || []);
});
return ret;
}
var AsyncValidationError = /*#__PURE__*/function (_Error) {
_inheritsLoose(AsyncValidationError, _Error);
function AsyncValidationError(errors, fields) {
var _this;
_this = _Error.call(this, 'Async Validation Error') || this;
_this.errors = errors;
_this.fields = fields;
return _this;
}
return AsyncValidationError;
}( /*#__PURE__*/_wrapNativeSuper(Error));
function asyncMap(objArr, option, func, callback, source) {
if (option.first) {
var _pending = new Promise(function (resolve, reject) {
var next = function next(errors) {
callback(errors);
return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
};
var flattenArr = flattenObjArr(objArr);
asyncSerialArray(flattenArr, func, next);
});
_pending["catch"](function (e) {
return e;
});
return _pending;
}
var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
var objArrKeys = Object.keys(objArr);
var objArrLength = objArrKeys.length;
var total = 0;
var results = [];
var pending = new Promise(function (resolve, reject) {
var next = function next(errors) {
results.push.apply(results, errors);
total++;
if (total === objArrLength) {
callback(results);
return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
}
};
if (!objArrKeys.length) {
callback(results);
resolve(source);
}
objArrKeys.forEach(function (key) {
var arr = objArr[key];
if (firstFields.indexOf(key) !== -1) {
asyncSerialArray(arr, func, next);
} else {
asyncParallelArray(arr, func, next);
}
});
});
pending["catch"](function (e) {
return e;
});
return pending;
}
function isErrorObj(obj) {
return !!(obj && obj.message !== undefined);
}
function dist_web_getValue(value, path) {
var v = value;
for (var i = 0; i < path.length; i++) {
if (v == undefined) {
return v;
}
v = v[path[i]];
}
return v;
}
function complementError(rule, source) {
return function (oe) {
var fieldValue;
if (rule.fullFields) {
fieldValue = dist_web_getValue(source, rule.fullFields);
} else {
fieldValue = source[oe.field || rule.fullField];
}
if (isErrorObj(oe)) {
oe.field = oe.field || rule.fullField;
oe.fieldValue = fieldValue;
return oe;
}
return {
message: typeof oe === 'function' ? oe() : oe,
fieldValue: fieldValue,
field: oe.field || rule.fullField
};
};
}
function deepMerge(target, source) {
if (source) {
for (var s in source) {
if (source.hasOwnProperty(s)) {
var value = source[s];
if (typeof value === 'object' && typeof target[s] === 'object') {
target[s] = _extends({}, target[s], value);
} else {
target[s] = value;
}
}
}
}
return target;
}
var required$1 = function required(rule, value, source, errors, options, type) {
if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type || rule.type))) {
errors.push(format(options.messages.required, rule.fullField));
}
};
/**
* Rule for validating whitespace.
*
* @param rule The validation rule.
* @param value The value of the field on the source object.
* @param source The source object being validated.
* @param errors An array of errors that this rule may add
* validation errors to.
* @param options The validation options.
* @param options.messages The validation messages.
*/
var whitespace = function whitespace(rule, value, source, errors, options) {
if (/^\s+$/.test(value) || value === '') {
errors.push(format(options.messages.whitespace, rule.fullField));
}
};
// https://github.com/kevva/url-regex/blob/master/index.js
var urlReg;
var getUrlRegex = (function () {
if (urlReg) {
return urlReg;
}
var word = '[a-fA-F\\d:]';
var b = function b(options) {
return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=" + word + ")|(?<=" + word + ")(?=\\s|$))" : '';
};
var v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
var v6seg = '[a-fA-F\\d]{1,4}';
var v6 = ("\n(?:\n(?:" + v6seg + ":){7}(?:" + v6seg + "|:)| // 1:2:3:4:5:6:7:: 1:2:3:4:5:6:7:8\n(?:" + v6seg + ":){6}(?:" + v4 + "|:" + v6seg + "|:)| // 1:2:3:4:5:6:: 1:2:3:4:5:6::8 1:2:3:4:5:6::8 1:2:3:4:5:6::1.2.3.4\n(?:" + v6seg + ":){5}(?::" + v4 + "|(?::" + v6seg + "){1,2}|:)| // 1:2:3:4:5:: 1:2:3:4:5::7:8 1:2:3:4:5::8 1:2:3:4:5::7:1.2.3.4\n(?:" + v6seg + ":){4}(?:(?::" + v6seg + "){0,1}:" + v4 + "|(?::" + v6seg + "){1,3}|:)| // 1:2:3:4:: 1:2:3:4::6:7:8 1:2:3:4::8 1:2:3:4::6:7:1.2.3.4\n(?:" + v6seg + ":){3}(?:(?::" + v6seg + "){0,2}:" + v4 + "|(?::" + v6seg + "){1,4}|:)| // 1:2:3:: 1:2:3::5:6:7:8 1:2:3::8 1:2:3::5:6:7:1.2.3.4\n(?:" + v6seg + ":){2}(?:(?::" + v6seg + "){0,3}:" + v4 + "|(?::" + v6seg + "){1,5}|:)| // 1:2:: 1:2::4:5:6:7:8 1:2::8 1:2::4:5:6:7:1.2.3.4\n(?:" + v6seg + ":){1}(?:(?::" + v6seg + "){0,4}:" + v4 + "|(?::" + v6seg + "){1,6}|:)| // 1:: 1::3:4:5:6:7:8 1::8 1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::" + v6seg + "){0,5}:" + v4 + "|(?::" + v6seg + "){1,7}|:)) // ::2:3:4:5:6:7:8 ::2:3:4:5:6:7:8 ::8 ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})? // %eth0 %1\n").replace(/\s*\/\/.*$/gm, '').replace(/\n/g, '').trim(); // Pre-compile only the exact regexes because adding a global flag make regexes stateful
var v46Exact = new RegExp("(?:^" + v4 + "$)|(?:^" + v6 + "$)");
var v4exact = new RegExp("^" + v4 + "$");
var v6exact = new RegExp("^" + v6 + "$");
var ip = function ip(options) {
return options && options.exact ? v46Exact : new RegExp("(?:" + b(options) + v4 + b(options) + ")|(?:" + b(options) + v6 + b(options) + ")", 'g');
};
ip.v4 = function (options) {
return options && options.exact ? v4exact : new RegExp("" + b(options) + v4 + b(options), 'g');
};
ip.v6 = function (options) {
return options && options.exact ? v6exact : new RegExp("" + b(options) + v6 + b(options), 'g');
};
var protocol = "(?:(?:[a-z]+:)?//)";
var auth = '(?:\\S+(?::\\S*)?@)?';
var ipv4 = ip.v4().source;
var ipv6 = ip.v6().source;
var host = "(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)";
var domain = "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*";
var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))";
var port = '(?::\\d{2,5})?';
var path = '(?:[/?#][^\\s"]*)?';
var regex = "(?:" + protocol + "|www\\.)" + auth + "(?:localhost|" + ipv4 + "|" + ipv6 + "|" + host + domain + tld + ")" + port + path;
urlReg = new RegExp("(?:^" + regex + "$)", 'i');
return urlReg;
});
/* eslint max-len:0 */
var pattern$2 = {
// http://emailregex.com/
email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
// url: new RegExp(
// '^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$',
// 'i',
// ),
hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
};
var types = {
integer: function integer(value) {
return types.number(value) && parseInt(value, 10) === value;
},
"float": function float(value) {
return types.number(value) && !types.integer(value);
},
array: function array(value) {
return Array.isArray(value);
},
regexp: function regexp(value) {
if (value instanceof RegExp) {
return true;
}
try {
return !!new RegExp(value);
} catch (e) {
return false;
}
},
date: function date(value) {
return typeof value.getTime === 'function' && typeof value.getMonth === 'function' && typeof value.getYear === 'function' && !isNaN(value.getTime());
},
number: function number(value) {
if (isNaN(value)) {
return false;
}
return typeof value === 'number';
},
object: function object(value) {
return typeof value === 'object' && !types.array(value);
},
method: function method(value) {
return typeof value === 'function';
},
email: function email(value) {
return typeof value === 'string' && value.length <= 320 && !!value.match(pattern$2.email);
},
url: function url(value) {
return typeof value === 'string' && value.length <= 2048 && !!value.match(getUrlRegex());
},
hex: function hex(value) {
return typeof value === 'string' && !!value.match(pattern$2.hex);
}
};
var type$1 = function type(rule, value, source, errors, options) {
if (rule.required && value === undefined) {
required$1(rule, value, source, errors, options);
return;
}
var custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'number', 'date', 'url', 'hex'];
var ruleType = rule.type;
if (custom.indexOf(ruleType) > -1) {
if (!types[ruleType](value)) {
errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
} // straight typeof check
} else if (ruleType && typeof value !== rule.type) {
errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
}
};
var dist_web_range = function range(rule, value, source, errors, options) {
var len = typeof rule.len === 'number';
var min = typeof rule.min === 'number';
var max = typeof rule.max === 'number'; // 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）
var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
var val = value;
var key = null;
var num = typeof value === 'number';
var str = typeof value === 'string';
var arr = Array.isArray(value);
if (num) {
key = 'number';
} else if (str) {
key = 'string';
} else if (arr) {
key = 'array';
} // if the value is not of a supported type for range validation
// the validation rule rule should use the
// type property to also test for a particular type
if (!key) {
return false;
}
if (arr) {
val = value.length;
}
if (str) {
// 处理码点大于U+010000的文字length属性不准确的bug，如"𠮷𠮷𠮷".lenght !== 3
val = value.replace(spRegexp, '_').length;
}
if (len) {
if (val !== rule.len) {
errors.push(format(options.messages[key].len, rule.fullField, rule.len));
}
} else if (min && !max && val < rule.min) {
errors.push(format(options.messages[key].min, rule.fullField, rule.min));
} else if (max && !min && val > rule.max) {
errors.push(format(options.messages[key].max, rule.fullField, rule.max));
} else if (min && max && (val < rule.min || val > rule.max)) {
errors.push(format(options.messages[key].range, rule.fullField, rule.min, rule.max));
}
};
var ENUM$1 = 'enum';
var enumerable$1 = function enumerable(rule, value, source, errors, options) {
rule[ENUM$1] = Array.isArray(rule[ENUM$1]) ? rule[ENUM$1] : [];
if (rule[ENUM$1].indexOf(value) === -1) {
errors.push(format(options.messages[ENUM$1], rule.fullField, rule[ENUM$1].join(', ')));
}
};
var pattern$1 = function pattern(rule, value, source, errors, options) {
if (rule.pattern) {
if (rule.pattern instanceof RegExp) {
// if a RegExp instance is passed, reset `lastIndex` in case its `global`
// flag is accidentally set to `true`, which in a validation scenario
// is not necessary and the result might be misleading
rule.pattern.lastIndex = 0;
if (!rule.pattern.test(value)) {
errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
}
} else if (typeof rule.pattern === 'string') {
var _pattern = new RegExp(rule.pattern);
if (!_pattern.test(value)) {
errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
}
}
}
};
var rules = {
required: required$1,
whitespace: whitespace,
type: type$1,
range: dist_web_range,
"enum": enumerable$1,
pattern: pattern$1
};
var string = function string(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (isEmptyValue(value, 'string') && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options, 'string');
if (!isEmptyValue(value, 'string')) {
rules.type(rule, value, source, errors, options);
rules.range(rule, value, source, errors, options);
rules.pattern(rule, value, source, errors, options);
if (rule.whitespace === true) {
rules.whitespace(rule, value, source, errors, options);
}
}
}
callback(errors);
};
var method = function method(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (isEmptyValue(value) && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options);
if (value !== undefined) {
rules.type(rule, value, source, errors, options);
}
}
callback(errors);
};
var number = function number(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (value === '') {
value = undefined;
}
if (isEmptyValue(value) && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options);
if (value !== undefined) {
rules.type(rule, value, source, errors, options);
rules.range(rule, value, source, errors, options);
}
}
callback(errors);
};
var _boolean = function _boolean(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (isEmptyValue(value) && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options);
if (value !== undefined) {
rules.type(rule, value, source, errors, options);
}
}
callback(errors);
};
var regexp = function regexp(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (isEmptyValue(value) && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options);
if (!isEmptyValue(value)) {
rules.type(rule, value, source, errors, options);
}
}
callback(errors);
};
var integer = function integer(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (isEmptyValue(value) && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options);
if (value !== undefined) {
rules.type(rule, value, source, errors, options);
rules.range(rule, value, source, errors, options);
}
}
callback(errors);
};
var floatFn = function floatFn(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (isEmptyValue(value) && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options);
if (value !== undefined) {
rules.type(rule, value, source, errors, options);
rules.range(rule, value, source, errors, options);
}
}
callback(errors);
};
var array = function array(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if ((value === undefined || value === null) && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options, 'array');
if (value !== undefined && value !== null) {
rules.type(rule, value, source, errors, options);
rules.range(rule, value, source, errors, options);
}
}
callback(errors);
};
var object = function object(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (isEmptyValue(value) && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options);
if (value !== undefined) {
rules.type(rule, value, source, errors, options);
}
}
callback(errors);
};
var ENUM = 'enum';
var enumerable = function enumerable(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (isEmptyValue(value) && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options);
if (value !== undefined) {
rules[ENUM](rule, value, source, errors, options);
}
}
callback(errors);
};
var pattern = function pattern(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (isEmptyValue(value, 'string') && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options);
if (!isEmptyValue(value, 'string')) {
rules.pattern(rule, value, source, errors, options);
}
}
callback(errors);
};
var date = function date(rule, value, callback, source, options) {
// console.log('integer rule called %j', rule);
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field); // console.log('validate on %s value', value);
if (validate) {
if (isEmptyValue(value, 'date') && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options);
if (!isEmptyValue(value, 'date')) {
var dateObject;
if (value instanceof Date) {
dateObject = value;
} else {
dateObject = new Date(value);
}
rules.type(rule, dateObject, source, errors, options);
if (dateObject) {
rules.range(rule, dateObject.getTime(), source, errors, options);
}
}
}
callback(errors);
};
var required = function required(rule, value, callback, source, options) {
var errors = [];
var type = Array.isArray(value) ? 'array' : typeof value;
rules.required(rule, value, source, errors, options, type);
callback(errors);
};
var type = function type(rule, value, callback, source, options) {
var ruleType = rule.type;
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (isEmptyValue(value, ruleType) && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options, ruleType);
if (!isEmptyValue(value, ruleType)) {
rules.type(rule, value, source, errors, options);
}
}
callback(errors);
};
var any = function any(rule, value, callback, source, options) {
var errors = [];
var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
if (validate) {
if (isEmptyValue(value) && !rule.required) {
return callback();
}
rules.required(rule, value, source, errors, options);
}
callback(errors);
};
var dist_web_validators = {
string: string,
method: method,
number: number,
"boolean": _boolean,
regexp: regexp,
integer: integer,
"float": floatFn,
array: array,
object: object,
"enum": enumerable,
pattern: pattern,
date: date,
url: type,
hex: type,
email: type,
required: required,
any: any
};
function newMessages() {
return {
"default": 'Validation error on field %s',
required: '%s is required',
"enum": '%s must be one of %s',
whitespace: '%s cannot be empty',
date: {
format: '%s date %s is invalid for format %s',
parse: '%s date could not be parsed, %s is invalid ',
invalid: '%s date %s is invalid'
},
types: {
string: '%s is not a %s',
method: '%s is not a %s (function)',
array: '%s is not an %s',
object: '%s is not an %s',
number: '%s is not a %s',
date: '%s is not a %s',
"boolean": '%s is not a %s',
integer: '%s is not an %s',
"float": '%s is not a %s',
regexp: '%s is not a valid %s',
email: '%s is not a valid %s',
url: '%s is not a valid %s',
hex: '%s is not a valid %s'
},
string: {
len: '%s must be exactly %s characters',
min: '%s must be at least %s characters',
max: '%s cannot be longer than %s characters',
range: '%s must be between %s and %s characters'
},
number: {
len: '%s must equal %s',
min: '%s cannot be less than %s',
max: '%s cannot be greater than %s',
range: '%s must be between %s and %s'
},
array: {
len: '%s must be exactly %s in length',
min: '%s cannot be less than %s in length',
max: '%s cannot be greater than %s in length',
range: '%s must be between %s and %s in length'
},
pattern: {
mismatch: '%s value %s does not match pattern %s'
},
clone: function clone() {
var cloned = JSON.parse(JSON.stringify(this));
cloned.clone = this.clone;
return cloned;
}
};
}
var messages = newMessages();
/**
* Encapsulates a validation schema.
*
* @param descriptor An object declaring validation rules
* for this schema.
*/
var Schema = /*#__PURE__*/function () {
// ========================= Static =========================
// ======================== Instance ========================
function Schema(descriptor) {
this.rules = null;
this._messages = messages;
this.define(descriptor);
}
var _proto = Schema.prototype;
_proto.define = function define(rules) {
var _this = this;
if (!rules) {
throw new Error('Cannot configure a schema with no rules');
}
if (typeof rules !== 'object' || Array.isArray(rules)) {
throw new Error('Rules must be an object');
}
this.rules = {};
Object.keys(rules).forEach(function (name) {
var item = rules[name];
_this.rules[name] = Array.isArray(item) ? item : [item];
});
};
_proto.messages = function messages(_messages) {
if (_messages) {
this._messages = deepMerge(newMessages(), _messages);
}
return this._messages;
};
_proto.validate = function validate(source_, o, oc) {
var _this2 = this;
if (o === void 0) {
o = {};
}
if (oc === void 0) {
oc = function oc() {};
}
var source = source_;
var options = o;
var callback = oc;
if (typeof options === 'function') {
callback = options;
options = {};
}
if (!this.rules || Object.keys(this.rules).length === 0) {
if (callback) {
callback(null, source);
}
return Promise.resolve(source);
}
function complete(results) {
var errors = [];
var fields = {};
function add(e) {
if (Array.isArray(e)) {
var _errors;
errors = (_errors = errors).concat.apply(_errors, e);
} else {
errors.push(e);
}
}
for (var i = 0; i < results.length; i++) {
add(results[i]);
}
if (!errors.length) {
callback(null, source);
} else {
fields = convertFieldsError(errors);
callback(errors, fields);
}
}
if (options.messages) {
var messages$1 = this.messages();
if (messages$1 === messages) {
messages$1 = newMessages();
}
deepMerge(messages$1, options.messages);
options.messages = messages$1;
} else {
options.messages = this.messages();
}
var series = {};
var keys = options.keys || Object.keys(this.rules);
keys.forEach(function (z) {
var arr = _this2.rules[z];
var value = source[z];
arr.forEach(function (r) {
var rule = r;
if (typeof rule.transform === 'function') {
if (source === source_) {
source = _extends({}, source);
}
value = source[z] = rule.transform(value);
}
if (typeof rule === 'function') {
rule = {
validator: rule
};
} else {
rule = _extends({}, rule);
} // Fill validator. Skip if nothing need to validate
rule.validator = _this2.getValidationMethod(rule);
if (!rule.validator) {
return;
}
rule.field = z;
rule.fullField = rule.fullField || z;
rule.type = _this2.getType(rule);
series[z] = series[z] || [];
series[z].push({
rule: rule,
value: value,
source: source,
field: z
});
});
});
var errorFields = {};
return asyncMap(series, options, function (data, doIt) {
var rule = data.rule;
var deep = (rule.type === 'object' || rule.type === 'array') && (typeof rule.fields === 'object' || typeof rule.defaultField === 'object');
deep = deep && (rule.required || !rule.required && data.value);
rule.field = data.field;
function addFullField(key, schema) {
return _extends({}, schema, {
fullField: rule.fullField + "." + key,
fullFields: rule.fullFields ? [].concat(rule.fullFields, [key]) : [key]
});
}
function cb(e) {
if (e === void 0) {
e = [];
}
var errorList = Array.isArray(e) ? e : [e];
if (!options.suppressWarning && errorList.length) {
Schema.warning('async-validator:', errorList);
}
if (errorList.length && rule.message !== undefined) {
errorList = [].concat(rule.message);
} // Fill error info
var filledErrors = errorList.map(complementError(rule, source));
if (options.first && filledErrors.length) {
errorFields[rule.field] = 1;
return doIt(filledErrors);
}
if (!deep) {
doIt(filledErrors);
} else {
// if rule is required but the target object
// does not exist fail at the rule level and don't
// go deeper
if (rule.required && !data.value) {
if (rule.message !== undefined) {
filledErrors = [].concat(rule.message).map(complementError(rule, source));
} else if (options.error) {
filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
}
return doIt(filledErrors);
}
var fieldsSchema = {};
if (rule.defaultField) {
Object.keys(data.value).map(function (key) {
fieldsSchema[key] = rule.defaultField;
});
}
fieldsSchema = _extends({}, fieldsSchema, data.rule.fields);
var paredFieldsSchema = {};
Object.keys(fieldsSchema).forEach(function (field) {
var fieldSchema = fieldsSchema[field];
var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
});
var schema = new Schema(paredFieldsSchema);
schema.messages(options.messages);
if (data.rule.options) {
data.rule.options.messages = options.messages;
data.rule.options.error = options.error;
}
schema.validate(data.value, data.rule.options || options, function (errs) {
var finalErrors = [];
if (filledErrors && filledErrors.length) {
finalErrors.push.apply(finalErrors, filledErrors);
}
if (errs && errs.length) {
finalErrors.push.apply(finalErrors, errs);
}
doIt(finalErrors.length ? finalErrors : null);
});
}
}
var res;
if (rule.asyncValidator) {
res = rule.asyncValidator(rule, data.value, cb, data.source, options);
} else if (rule.validator) {
try {
res = rule.validator(rule, data.value, cb, data.source, options);
} catch (error) {
console.error == null ? void 0 : console.error(error); // rethrow to report error
if (!options.suppressValidatorError) {
setTimeout(function () {
throw error;
}, 0);
}
cb(error.message);
}
if (res === true) {
cb();
} else if (res === false) {
cb(typeof rule.message === 'function' ? rule.message(rule.fullField || rule.field) : rule.message || (rule.fullField || rule.field) + " fails");
} else if (res instanceof Array) {
cb(res);
} else if (res instanceof Error) {
cb(res.message);
}
}
if (res && res.then) {
res.then(function () {
return cb();
}, function (e) {
return cb(e);
});
}
}, function (results) {
complete(results);
}, source);
};
_proto.getType = function getType(rule) {
if (rule.type === undefined && rule.pattern instanceof RegExp) {
rule.type = 'pattern';
}
if (typeof rule.validator !== 'function' && rule.type && !dist_web_validators.hasOwnProperty(rule.type)) {
throw new Error(format('Unknown rule type %s', rule.type));
}
return rule.type || 'string';
};
_proto.getValidationMethod = function getValidationMethod(rule) {
if (typeof rule.validator === 'function') {
return rule.validator;
}
var keys = Object.keys(rule);
var messageIndex = keys.indexOf('message');
if (messageIndex !== -1) {
keys.splice(messageIndex, 1);
}
if (keys.length === 1 && keys[0] === 'required') {
return dist_web_validators.required;
}
return dist_web_validators[this.getType(rule)] || undefined;
};
return Schema;
}();
Schema.register = function register(type, validator) {
if (typeof validator !== 'function') {
throw new Error('Cannot register a validator by type, validator is not a function');
}
dist_web_validators[type] = validator;
};
Schema.warning = warning;
Schema.messages = messages;
Schema.validators = dist_web_validators;
//# sourceMappingURL=index.js.map
;// ./node_modules/naive-ui/es/_utils/composable/use-collection.mjs
// injection.collection {
// key1: [insta, instb]
// key2: [instc]
// }
function useInjectionInstanceCollection(injectionName, collectionKey, registerKeyRef) {
var _a;
const injection = runtime_core_esm_bundler_inject(injectionName, null);
if (injection === null) return;
const vm = (_a = runtime_core_esm_bundler_getCurrentInstance()) === null || _a === void 0 ? void 0 : _a.proxy;
runtime_core_esm_bundler_watch(registerKeyRef, registerInstance);
registerInstance(registerKeyRef.value);
runtime_core_esm_bundler_onBeforeUnmount(() => {
registerInstance(undefined, registerKeyRef.value);
});
function registerInstance(key, oldKey) {
if (!injection) return;
const collection = injection[collectionKey];
if (oldKey !== undefined) removeInstance(collection, oldKey);
if (key !== undefined) addInstance(collection, key);
}
function removeInstance(collection, key) {
if (!collection[key]) collection[key] = [];
collection[key].splice(collection[key].findIndex(instance => instance === vm), 1);
}
function addInstance(collection, key) {
if (!collection[key]) collection[key] = [];
if (!~collection[key].findIndex(instance => instance === vm)) {
collection[key].push(vm);
}
}
}
// injection.collection {
// key1: [insta.value, instb.value]
// key2: [instc.value]
// }
function useInjectionCollection(injectionName, collectionKey, valueRef) {
const injection = inject(injectionName, null);
if (injection === null) return;
if (!(collectionKey in injection)) {
injection[collectionKey] = [];
}
injection[collectionKey].push(valueRef.value);
watch(valueRef, (value, prevValue) => {
const collectionArray = injection[collectionKey];
const index = collectionArray.findIndex(collectionValue => collectionValue === prevValue);
if (~index) collectionArray.splice(index, 1);
collectionArray.push(value);
});
onBeforeUnmount(() => {
const collectionArray = injection[collectionKey];
const index = collectionArray.findIndex(collectionValue => collectionValue === valueRef.value);
if (~index) collectionArray.splice(index, 1);
});
}
// injection.collection {
// key1: [insta.$el, instb.$el]
// key2: [instc.$el]
// }
function useInjectionElementCollection(injectionName, collectionKey, getElement) {
const injection = inject(injectionName, null);
if (injection === null) return;
if (!(collectionKey in injection)) {
injection[collectionKey] = [];
}
onMounted(() => {
const el = getElement();
if (!el) return;
injection[collectionKey].push(el);
});
onBeforeUnmount(() => {
const collectionArray = injection[collectionKey];
const element = getElement();
const index = collectionArray.findIndex(collectionElement => collectionElement === element);
if (~index) collectionArray.splice(index, 1);
});
}
;// ./node_modules/naive-ui/es/_styles/transitions/fade-down.cssr.mjs
const {
cubicBezierEaseInOut: fade_down_cssr_cubicBezierEaseInOut
} = _common;
function fadeDownTransition({
name = 'fade-down',
fromOffset = '-4px',
enterDuration = '.3s',
leaveDuration = '.3s',
enterCubicBezier = fade_down_cssr_cubicBezierEaseInOut,
leaveCubicBezier = fade_down_cssr_cubicBezierEaseInOut
} = {}) {
return [cssr_c(`&.${name}-transition-enter-from, &.${name}-transition-leave-to`, {
opacity: 0,
transform: `translateY(${fromOffset})`
}), cssr_c(`&.${name}-transition-enter-to, &.${name}-transition-leave-from`, {
opacity: 1,
transform: 'translateY(0)'
}), cssr_c(`&.${name}-transition-leave-active`, {
transition: `opacity ${leaveDuration} ${leaveCubicBezier}, transform ${leaveDuration} ${leaveCubicBezier}`
}), cssr_c(`&.${name}-transition-enter-active`, {
transition: `opacity ${enterDuration} ${enterCubicBezier}, transform ${enterDuration} ${enterCubicBezier}`
})];
}
;// ./node_modules/naive-ui/es/form/src/styles/form-item.cssr.mjs
// vars:
// --n-line-height
// --n-blank-height
// --n-feedback-padding
// --n-feedback-font-size
// --n-label-font-size-left
// --n-label-font-size-top
// --n-label-height
// --n-label-padding
// --n-asterisk-color
// --n-label-text-color
// --n-bezier
// --n-feedback-text-color
// --n-feedback-text-color-warning
// --n-feedback-text-color-error
// --n-label-text-align
// --n-label-padding
/* harmony default export */ var form_item_cssr = (cB('form-item', `
display: grid;
line-height: var(--n-line-height);
`, [cB('form-item-label', `
grid-area: label;
align-items: center;
line-height: 1.25;
text-align: var(--n-label-text-align);
font-size: var(--n-label-font-size);
min-height: var(--n-label-height);
padding: var(--n-label-padding);
color: var(--n-label-text-color);
transition: color .3s var(--n-bezier);
box-sizing: border-box;
font-weight: var(--n-label-font-weight);
`, [cE('asterisk', `
white-space: nowrap;
user-select: none;
-webkit-user-select: none;
color: var(--n-asterisk-color);
transition: color .3s var(--n-bezier);
`), cE('asterisk-placeholder', `
grid-area: mark;
user-select: none;
-webkit-user-select: none;
visibility: hidden;
`)]), cB('form-item-blank', `
grid-area: blank;
min-height: var(--n-blank-height);
`), cM('auto-label-width', [cB('form-item-label', 'white-space: nowrap;')]), cM('left-labelled', `
grid-template-areas:
"label blank"
"label feedback";
grid-template-columns: auto minmax(0, 1fr);
grid-template-rows: auto 1fr;
align-items: flex-start;
`, [cB('form-item-label', `
display: grid;
grid-template-columns: 1fr auto;
min-height: var(--n-blank-height);
height: auto;
box-sizing: border-box;
flex-shrink: 0;
flex-grow: 0;
`, [cM('reverse-columns-space', `
grid-template-columns: auto 1fr;
`), cM('left-mark', `
grid-template-areas:
"mark text"
". text";
`), cM('right-mark', `
grid-template-areas:
"text mark"
"text .";
`), cM('right-hanging-mark', `
grid-template-areas:
"text mark"
"text .";
`), cE('text', `
grid-area: text;
`), cE('asterisk', `
grid-area: mark;
align-self: end;
`)])]), cM('top-labelled', `
grid-template-areas:
"label"
"blank"
"feedback";
grid-template-rows: minmax(var(--n-label-height), auto) 1fr;
grid-template-columns: minmax(0, 100%);
`, [cM('no-label', `
grid-template-areas:
"blank"
"feedback";
grid-template-rows: 1fr;
`), cB('form-item-label', `
display: flex;
align-items: flex-start;
justify-content: var(--n-label-text-align);
`)]), cB('form-item-blank', `
box-sizing: border-box;
display: flex;
align-items: center;
position: relative;
`), cB('form-item-feedback-wrapper', `
grid-area: feedback;
box-sizing: border-box;
min-height: var(--n-feedback-height);
font-size: var(--n-feedback-font-size);
line-height: 1.25;
transform-origin: top left;
`, [cssr_c('&:not(:empty)', `
padding: var(--n-feedback-padding);
`), cB('form-item-feedback', {
transition: 'color .3s var(--n-bezier)',
color: 'var(--n-feedback-text-color)'
}, [cM('warning', {
color: 'var(--n-feedback-text-color-warning)'
}), cM('error', {
color: 'var(--n-feedback-text-color-error)'
}), fadeDownTransition({
fromOffset: '-3px',
enterDuration: '.3s',
leaveDuration: '.2s'
})])])]));
;// ./node_modules/naive-ui/es/form/src/utils.mjs
function formItemSize(props) {
const NForm = runtime_core_esm_bundler_inject(formInjectionKey, null);
return {
mergedSize: runtime_core_esm_bundler_computed(() => {
if (props.size !== undefined) return props.size;
if ((NForm === null || NForm === void 0 ? void 0 : NForm.props.size) !== undefined) return NForm.props.size;
return 'medium';
})
};
}
function formItemMisc(props) {
const NForm = runtime_core_esm_bundler_inject(formInjectionKey, null);
const mergedLabelPlacementRef = runtime_core_esm_bundler_computed(() => {
const {
labelPlacement
} = props;
if (labelPlacement !== undefined) return labelPlacement;
if (NForm === null || NForm === void 0 ? void 0 : NForm.props.labelPlacement) return NForm.props.labelPlacement;
return 'top';
});
const isAutoLabelWidthRef = runtime_core_esm_bundler_computed(() => {
return mergedLabelPlacementRef.value === 'left' && (props.labelWidth === 'auto' || (NForm === null || NForm === void 0 ? void 0 : NForm.props.labelWidth) === 'auto');
});
const mergedLabelWidthRef = runtime_core_esm_bundler_computed(() => {
if (mergedLabelPlacementRef.value === 'top') return;
const {
labelWidth
} = props;
if (labelWidth !== undefined && labelWidth !== 'auto') {
return formatLength(labelWidth);
}
if (isAutoLabelWidthRef.value) {
const autoComputedWidth = NForm === null || NForm === void 0 ? void 0 : NForm.maxChildLabelWidthRef.value;
if (autoComputedWidth !== undefined) {
return formatLength(autoComputedWidth);
} else {
return undefined;
}
}
if ((NForm === null || NForm === void 0 ? void 0 : NForm.props.labelWidth) !== undefined) {
return formatLength(NForm.props.labelWidth);
}
return undefined;
});
const mergedLabelAlignRef = runtime_core_esm_bundler_computed(() => {
const {
labelAlign
} = props;
if (labelAlign) return labelAlign;
if (NForm === null || NForm === void 0 ? void 0 : NForm.props.labelAlign) return NForm.props.labelAlign;
return undefined;
});
const mergedLabelStyleRef = runtime_core_esm_bundler_computed(() => {
var _a;
return [(_a = props.labelProps) === null || _a === void 0 ? void 0 : _a.style, props.labelStyle, {
width: mergedLabelWidthRef.value
}];
});
const mergedShowRequireMarkRef = runtime_core_esm_bundler_computed(() => {
const {
showRequireMark
} = props;
if (showRequireMark !== undefined) return showRequireMark;
return NForm === null || NForm === void 0 ? void 0 : NForm.props.showRequireMark;
});
const mergedRequireMarkPlacementRef = runtime_core_esm_bundler_computed(() => {
const {
requireMarkPlacement
} = props;
if (requireMarkPlacement !== undefined) return requireMarkPlacement;
return (NForm === null || NForm === void 0 ? void 0 : NForm.props.requireMarkPlacement) || 'right';
});
const validationErroredRef = ref(false);
const validationWarnedRef = ref(false);
const mergedValidationStatusRef = runtime_core_esm_bundler_computed(() => {
const {
validationStatus
} = props;
if (validationStatus !== undefined) return validationStatus;
if (validationErroredRef.value) return 'error';
if (validationWarnedRef.value) return 'warning';
return undefined;
});
const mergedShowFeedbackRef = runtime_core_esm_bundler_computed(() => {
const {
showFeedback
} = props;
if (showFeedback !== undefined) return showFeedback;
if ((NForm === null || NForm === void 0 ? void 0 : NForm.props.showFeedback) !== undefined) return NForm.props.showFeedback;
return true;
});
const mergedShowLabelRef = runtime_core_esm_bundler_computed(() => {
const {
showLabel
} = props;
if (showLabel !== undefined) return showLabel;
if ((NForm === null || NForm === void 0 ? void 0 : NForm.props.showLabel) !== undefined) return NForm.props.showLabel;
return true;
});
return {
validationErrored: validationErroredRef,
validationWarned: validationWarnedRef,
mergedLabelStyle: mergedLabelStyleRef,
mergedLabelPlacement: mergedLabelPlacementRef,
mergedLabelAlign: mergedLabelAlignRef,
mergedShowRequireMark: mergedShowRequireMarkRef,
mergedRequireMarkPlacement: mergedRequireMarkPlacementRef,
mergedValidationStatus: mergedValidationStatusRef,
mergedShowFeedback: mergedShowFeedbackRef,
mergedShowLabel: mergedShowLabelRef,
isAutoLabelWidth: isAutoLabelWidthRef
};
}
function formItemRule(props) {
const NForm = runtime_core_esm_bundler_inject(formInjectionKey, null);
const compatibleRulePathRef = runtime_core_esm_bundler_computed(() => {
const {
rulePath
} = props;
if (rulePath !== undefined) return rulePath;
const {
path
} = props;
if (path !== undefined) return path;
return undefined;
});
const mergedRulesRef = runtime_core_esm_bundler_computed(() => {
const rules = [];
const {
rule
} = props;
if (rule !== undefined) {
if (Array.isArray(rule)) rules.push(...rule);else rules.push(rule);
}
if (NForm) {
const {
rules: formRules
} = NForm.props;
const {
value: rulePath
} = compatibleRulePathRef;
if (formRules !== undefined && rulePath !== undefined) {
const formRule = lodash_es_get(formRules, rulePath);
if (formRule !== undefined) {
if (Array.isArray(formRule)) {
rules.push(...formRule);
} else {
// terminate object must be a form item rule
rules.push(formRule);
}
}
}
}
return rules;
});
const hasRequiredRuleRef = runtime_core_esm_bundler_computed(() => {
return mergedRulesRef.value.some(rule => rule.required);
});
// deprecated
const mergedRequiredRef = runtime_core_esm_bundler_computed(() => {
return hasRequiredRuleRef.value || props.required;
});
return {
mergedRules: mergedRulesRef,
mergedRequired: mergedRequiredRef
};
}
;// ./node_modules/naive-ui/es/form/src/FormItem.mjs
var FormItem_awaiter = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function (resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
const formItemProps = Object.assign(Object.assign({}, use_theme.props), {
label: String,
labelWidth: [Number, String],
labelStyle: [String, Object],
labelAlign: String,
labelPlacement: String,
path: String,
first: Boolean,
rulePath: String,
required: Boolean,
showRequireMark: {
type: Boolean,
default: undefined
},
requireMarkPlacement: String,
showFeedback: {
type: Boolean,
default: undefined
},
rule: [Object, Array],
size: String,
ignorePathChange: Boolean,
validationStatus: String,
feedback: String,
feedbackClass: String,
feedbackStyle: [String, Object],
showLabel: {
type: Boolean,
default: undefined
},
labelProps: Object
});
const formItemPropKeys = keysOf(formItemProps);
// wrap sync validator
function wrapValidator(validator, async) {
return (...args) => {
try {
const validateResult = validator(...args);
if (!async && (typeof validateResult === 'boolean' || validateResult instanceof Error || Array.isArray(validateResult)) // Error[]
|| (validateResult === null || validateResult === void 0 ? void 0 : validateResult.then)) {
return validateResult;
} else if (validateResult === undefined) {
return true;
} else {
warn_warn('form-item/validate', `You return a ${typeof validateResult} ` + `typed value in the validator method, which is not recommended. Please use ${async ? '`Promise`' : '`boolean`, `Error` or `Promise`'} typed value instead.`);
return true;
}
} catch (err) {
warn_warn('form-item/validate', 'An error is catched in the validation, ' + 'so the validation won\'t be done. Your callback in `validate` method of ' + '`n-form` or `n-form-item` won\'t be called in this validation.');
console.error(err);
// If returns undefined, async-validator won't trigger callback
// so the result will be abandoned, which means not true and not false
return undefined;
}
};
}
/* harmony default export */ var FormItem = (defineComponent({
name: 'FormItem',
props: formItemProps,
setup(props) {
useInjectionInstanceCollection(formItemInstsInjectionKey, 'formItems', toRef(props, 'path'));
const {
mergedClsPrefixRef,
inlineThemeDisabled
} = useConfig(props);
const NForm = runtime_core_esm_bundler_inject(formInjectionKey, null);
const formItemSizeRefs = formItemSize(props);
const formItemMiscRefs = formItemMisc(props);
const {
validationErrored: validationErroredRef,
validationWarned: validationWarnedRef
} = formItemMiscRefs;
const {
mergedRequired: mergedRequiredRef,
mergedRules: mergedRulesRef
} = formItemRule(props);
const {
mergedSize: mergedSizeRef
} = formItemSizeRefs;
const {
mergedLabelPlacement: labelPlacementRef,
mergedLabelAlign: labelTextAlignRef,
mergedRequireMarkPlacement: mergedRequireMarkPlacementRef
} = formItemMiscRefs;
const renderExplainsRef = ref([]);
const feedbackIdRef = ref(createId());
const mergedDisabledRef = NForm ? toRef(NForm.props, 'disabled') : ref(false);
const themeRef = use_theme('Form', '-form-item', form_item_cssr, form_styles_light, props, mergedClsPrefixRef);
runtime_core_esm_bundler_watch(toRef(props, 'path'), () => {
if (props.ignorePathChange) return;
restoreValidation();
});
function restoreValidation() {
renderExplainsRef.value = [];
validationErroredRef.value = false;
validationWarnedRef.value = false;
if (props.feedback) {
feedbackIdRef.value = createId();
}
}
const internalValidate = (...args_1) => FormItem_awaiter(this, [...args_1], void 0, function* (trigger = null, shouldRuleBeApplied = () => true, options = {
suppressWarning: true
}) {
const {
path
} = props;
if (!options) {
options = {};
} else {
if (!options.first) options.first = props.first;
}
const {
value: rules
} = mergedRulesRef;
const value = NForm ? lodash_es_get(NForm.props.model, path || '') : undefined;
const messageRenderers = {};
const originalMessageRendersMessage = {};
const activeRules = (!trigger ? rules : rules.filter(rule => {
if (Array.isArray(rule.trigger)) {
return rule.trigger.includes(trigger);
} else {
return rule.trigger === trigger;
}
})).filter(shouldRuleBeApplied).map((rule, i) => {
const shallowClonedRule = Object.assign({}, rule);
if (shallowClonedRule.validator) {
shallowClonedRule.validator = wrapValidator(shallowClonedRule.validator, false);
}
if (shallowClonedRule.asyncValidator) {
shallowClonedRule.asyncValidator = wrapValidator(shallowClonedRule.asyncValidator, true);
}
if (shallowClonedRule.renderMessage) {
const rendererKey = `__renderMessage__${i}`;
originalMessageRendersMessage[rendererKey] = shallowClonedRule.message;
shallowClonedRule.message = rendererKey;
messageRenderers[rendererKey] = shallowClonedRule.renderMessage;
}
return shallowClonedRule;
});
const activeErrorRules = activeRules.filter(r => r.level !== 'warning');
const activeWarningRules = activeRules.filter(r => r.level === 'warning');
const validationResult = {
valid: true,
errors: undefined,
warnings: undefined
};
if (!activeRules.length) return validationResult;
const mergedPath = path !== null && path !== void 0 ? path : '__n_no_path__';
const validator = new Schema({
[mergedPath]: activeErrorRules
});
const warningValidator = new Schema({
[mergedPath]: activeWarningRules
});
const {
validateMessages
} = (NForm === null || NForm === void 0 ? void 0 : NForm.props) || {};
if (validateMessages) {
validator.messages(validateMessages);
warningValidator.messages(validateMessages);
}
const renderMessages = errors => {
renderExplainsRef.value = errors.map(error => {
const transformedMessage = (error === null || error === void 0 ? void 0 : error.message) || '';
return {
key: transformedMessage,
render: () => {
if (transformedMessage.startsWith('__renderMessage__')) {
return messageRenderers[transformedMessage]();
}
return transformedMessage;
}
};
});
errors.forEach(error => {
var _a;
if ((_a = error.message) === null || _a === void 0 ? void 0 : _a.startsWith('__renderMessage__')) {
error.message = originalMessageRendersMessage[error.message];
}
});
};
if (activeErrorRules.length) {
const errors = yield new Promise(resolve => {
void validator.validate({
[mergedPath]: value
}, options, resolve);
});
if (errors === null || errors === void 0 ? void 0 : errors.length) {
validationResult.valid = false;
validationResult.errors = errors;
renderMessages(errors);
}
}
// if there are already errors, warning check can be skipped
if (activeWarningRules.length && !validationResult.errors) {
const warnings = yield new Promise(resolve => {
void warningValidator.validate({
[mergedPath]: value
}, options, resolve);
});
if (warnings === null || warnings === void 0 ? void 0 : warnings.length) {
renderMessages(warnings);
validationResult.warnings = warnings;
}
}
if (!validationResult.errors && !validationResult.warnings) {
restoreValidation();
} else {
validationErroredRef.value = !!validationResult.errors;
validationWarnedRef.value = !!validationResult.warnings;
}
return validationResult;
});
function handleContentBlur() {
void internalValidate('blur');
}
function handleContentChange() {
void internalValidate('change');
}
function handleContentFocus() {
void internalValidate('focus');
}
function handleContentInput() {
void internalValidate('input');
}
function validate(options, callback) {
return FormItem_awaiter(this, void 0, void 0, function* () {
/** the following code is for compatibility */
let trigger;
let validateCallback;
let shouldRuleBeApplied;
let asyncValidatorOptions;
if (typeof options === 'string') {
trigger = options;
validateCallback = callback;
} else if (options !== null && typeof options === 'object') {
trigger = options.trigger;
validateCallback = options.callback;
shouldRuleBeApplied = options.shouldRuleBeApplied;
asyncValidatorOptions = options.options;
}
return yield new Promise((resolve, reject) => {
void internalValidate(trigger, shouldRuleBeApplied, asyncValidatorOptions).then(({
valid,
errors,
warnings
}) => {
if (valid) {
if (validateCallback) {
validateCallback(undefined, {
warnings
});
}
resolve({
warnings
});
} else {
if (validateCallback) {
validateCallback(errors, {
warnings
});
}
reject(errors);
}
});
});
});
}
provide(formItemInjectionKey, {
path: toRef(props, 'path'),
disabled: mergedDisabledRef,
mergedSize: formItemSizeRefs.mergedSize,
mergedValidationStatus: formItemMiscRefs.mergedValidationStatus,
restoreValidation,
handleContentBlur,
handleContentChange,
handleContentFocus,
handleContentInput
});
const exposedRef = {
validate,
restoreValidation,
internalValidate
};
const labelElementRef = ref(null);
runtime_core_esm_bundler_onMounted(() => {
if (!formItemMiscRefs.isAutoLabelWidth.value) return;
const labelElement = labelElementRef.value;
if (labelElement !== null) {
const memoizedWhitespace = labelElement.style.whiteSpace;
labelElement.style.whiteSpace = 'nowrap';
labelElement.style.width = '';
NForm === null || NForm === void 0 ? void 0 : NForm.deriveMaxChildLabelWidth(Number(getComputedStyle(labelElement).width.slice(0, -2)));
labelElement.style.whiteSpace = memoizedWhitespace;
}
});
const cssVarsRef = runtime_core_esm_bundler_computed(() => {
var _a;
const {
value: size
} = mergedSizeRef;
const {
value: labelPlacement
} = labelPlacementRef;
const direction = labelPlacement === 'top' ? 'vertical' : 'horizontal';
const {
common: {
cubicBezierEaseInOut
},
self: {
labelTextColor,
asteriskColor,
lineHeight,
feedbackTextColor,
feedbackTextColorWarning,
feedbackTextColorError,
feedbackPadding,
labelFontWeight,
[createKey('labelHeight', size)]: labelHeight,
[createKey('blankHeight', size)]: blankHeight,
[createKey('feedbackFontSize', size)]: feedbackFontSize,
[createKey('feedbackHeight', size)]: feedbackHeight,
[createKey('labelPadding', direction)]: labelPadding,
[createKey('labelTextAlign', direction)]: labelTextAlign,
[createKey(createKey('labelFontSize', labelPlacement), size)]: labelFontSize
}
} = themeRef.value;
let mergedLabelTextAlign = (_a = labelTextAlignRef.value) !== null && _a !== void 0 ? _a : labelTextAlign;
if (labelPlacement === 'top') {
mergedLabelTextAlign = mergedLabelTextAlign === 'right' ? 'flex-end' : 'flex-start';
}
const cssVars = {
'--n-bezier': cubicBezierEaseInOut,
'--n-line-height': lineHeight,
'--n-blank-height': blankHeight,
'--n-label-font-size': labelFontSize,
'--n-label-text-align': mergedLabelTextAlign,
'--n-label-height': labelHeight,
'--n-label-padding': labelPadding,
'--n-label-font-weight': labelFontWeight,
'--n-asterisk-color': asteriskColor,
'--n-label-text-color': labelTextColor,
'--n-feedback-padding': feedbackPadding,
'--n-feedback-font-size': feedbackFontSize,
'--n-feedback-height': feedbackHeight,
'--n-feedback-text-color': feedbackTextColor,
'--n-feedback-text-color-warning': feedbackTextColorWarning,
'--n-feedback-text-color-error': feedbackTextColorError
};
return cssVars;
});
const themeClassHandle = inlineThemeDisabled ? useThemeClass('form-item', runtime_core_esm_bundler_computed(() => {
var _a;
return `${mergedSizeRef.value[0]}${labelPlacementRef.value[0]}${((_a = labelTextAlignRef.value) === null || _a === void 0 ? void 0 : _a[0]) || ''}`;
}), cssVarsRef, props) : undefined;
const reverseColSpaceRef = runtime_core_esm_bundler_computed(() => {
// label placement left
// require-mark-placement | label align | areas (1fr auto)
// left | left | mark text (need reverse)
// left | right | mark text (okay)
// right | left | mark text (okay)
// right | right | mark text (okay)
// right-hanging | left | text mark (okay)
// right-hanging | right | text mark (okay)
return labelPlacementRef.value === 'left' && mergedRequireMarkPlacementRef.value === 'left' && labelTextAlignRef.value === 'left';
});
return Object.assign(Object.assign(Object.assign(Object.assign({
labelElementRef,
mergedClsPrefix: mergedClsPrefixRef,
mergedRequired: mergedRequiredRef,
feedbackId: feedbackIdRef,
renderExplains: renderExplainsRef,
reverseColSpace: reverseColSpaceRef
}, formItemMiscRefs), formItemSizeRefs), exposedRef), {
cssVars: inlineThemeDisabled ? undefined : cssVarsRef,
themeClass: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass,
onRender: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender
});
},
render() {
const {
$slots,
mergedClsPrefix,
mergedShowLabel,
mergedShowRequireMark,
mergedRequireMarkPlacement,
onRender
} = this;
const renderedShowRequireMark = mergedShowRequireMark !== undefined ? mergedShowRequireMark : this.mergedRequired;
onRender === null || onRender === void 0 ? void 0 : onRender();
const renderLabel = () => {
const labelText = this.$slots.label ? this.$slots.label() : this.label;
if (!labelText) return null;
const textNode = h("span", {
class: `${mergedClsPrefix}-form-item-label__text`
}, labelText);
const markNode = renderedShowRequireMark ? h("span", {
class: `${mergedClsPrefix}-form-item-label__asterisk`
}, mergedRequireMarkPlacement !== 'left' ? '\u00A0*' : '*\u00A0') : mergedRequireMarkPlacement === 'right-hanging' && h("span", {
class: `${mergedClsPrefix}-form-item-label__asterisk-placeholder`
}, '\u00A0*');
const {
labelProps
} = this;
return h("label", Object.assign({}, labelProps, {
class: [labelProps === null || labelProps === void 0 ? void 0 : labelProps.class, `${mergedClsPrefix}-form-item-label`, `${mergedClsPrefix}-form-item-label--${mergedRequireMarkPlacement}-mark`, this.reverseColSpace && `${mergedClsPrefix}-form-item-label--reverse-columns-space`],
style: this.mergedLabelStyle,
ref: "labelElementRef"
}), mergedRequireMarkPlacement === 'left' ? [markNode, textNode] : [textNode, markNode]);
};
return h("div", {
class: [`${mergedClsPrefix}-form-item`, this.themeClass, `${mergedClsPrefix}-form-item--${this.mergedSize}-size`, `${mergedClsPrefix}-form-item--${this.mergedLabelPlacement}-labelled`, this.isAutoLabelWidth && `${mergedClsPrefix}-form-item--auto-label-width`, !mergedShowLabel && `${mergedClsPrefix}-form-item--no-label`],
style: this.cssVars
}, mergedShowLabel && renderLabel(), h("div", {
class: [`${mergedClsPrefix}-form-item-blank`, this.mergedValidationStatus && `${mergedClsPrefix}-form-item-blank--${this.mergedValidationStatus}`]
}, $slots), this.mergedShowFeedback ? h("div", {
key: this.feedbackId,
style: this.feedbackStyle,
class: [`${mergedClsPrefix}-form-item-feedback-wrapper`, this.feedbackClass]
}, h(Transition, {
name: "fade-down-transition",
mode: "out-in"
}, {
default: () => {
const {
mergedValidationStatus
} = this;
return resolveWrappedSlot($slots.feedback, children => {
var _a;
const {
feedback
} = this;
const feedbackNodes = children || feedback ? h("div", {
key: "__feedback__",
class: `${mergedClsPrefix}-form-item-feedback__line`
}, children || feedback) : this.renderExplains.length ? (_a = this.renderExplains) === null || _a === void 0 ? void 0 : _a.map(({
key,
render
}) => h("div", {
key: key,
class: `${mergedClsPrefix}-form-item-feedback__line`
}, render())) : null;
return feedbackNodes ? mergedValidationStatus === 'warning' ? h("div", {
key: "controlled-warning",
class: `${mergedClsPrefix}-form-item-feedback ${mergedClsPrefix}-form-item-feedback--warning`
}, feedbackNodes) : mergedValidationStatus === 'error' ? h("div", {
key: "controlled-error",
class: `${mergedClsPrefix}-form-item-feedback ${mergedClsPrefix}-form-item-feedback--error`
}, feedbackNodes) : mergedValidationStatus === 'success' ? h("div", {
key: "controlled-success",
class: `${mergedClsPrefix}-form-item-feedback ${mergedClsPrefix}-form-item-feedback--success`
}, feedbackNodes) : h("div", {
key: "controlled-default",
class: `${mergedClsPrefix}-form-item-feedback`
}, feedbackNodes) : null;
});
}
})) : null);
}
}));
;// ./node_modules/naive-ui/es/_internal/icons/Clear.mjs
/* harmony default export */ var Clear = (replaceable('clear', () => h("svg", {
viewBox: "0 0 16 16",
version: "1.1",
xmlns: "http://www.w3.org/2000/svg"
}, h("g", {
stroke: "none",
"stroke-width": "1",
fill: "none",
"fill-rule": "evenodd"
}, h("g", {
fill: "currentColor",
"fill-rule": "nonzero"
}, h("path", {
d: "M8,2 C11.3137085,2 14,4.6862915 14,8 C14,11.3137085 11.3137085,14 8,14 C4.6862915,14 2,11.3137085 2,8 C2,4.6862915 4.6862915,2 8,2 Z M6.5343055,5.83859116 C6.33943736,5.70359511 6.07001296,5.72288026 5.89644661,5.89644661 L5.89644661,5.89644661 L5.83859116,5.9656945 C5.70359511,6.16056264 5.72288026,6.42998704 5.89644661,6.60355339 L5.89644661,6.60355339 L7.293,8 L5.89644661,9.39644661 L5.83859116,9.4656945 C5.70359511,9.66056264 5.72288026,9.92998704 5.89644661,10.1035534 L5.89644661,10.1035534 L5.9656945,10.1614088 C6.16056264,10.2964049 6.42998704,10.2771197 6.60355339,10.1035534 L6.60355339,10.1035534 L8,8.707 L9.39644661,10.1035534 L9.4656945,10.1614088 C9.66056264,10.2964049 9.92998704,10.2771197 10.1035534,10.1035534 L10.1035534,10.1035534 L10.1614088,10.0343055 C10.2964049,9.83943736 10.2771197,9.57001296 10.1035534,9.39644661 L10.1035534,9.39644661 L8.707,8 L10.1035534,6.60355339 L10.1614088,6.5343055 C10.2964049,6.33943736 10.2771197,6.07001296 10.1035534,5.89644661 L10.1035534,5.89644661 L10.0343055,5.83859116 C9.83943736,5.70359511 9.57001296,5.72288026 9.39644661,5.89644661 L9.39644661,5.89644661 L8,7.293 L6.60355339,5.89644661 Z"
}))))));
;// ./node_modules/naive-ui/es/_internal/clear/src/styles/index.cssr.mjs
// vars:
// --n-bezier
// --n-clear-color
// --n-clear-size
// --n-clear-color-hover
// --n-clear-color-pressed
/* harmony default export */ var clear_src_styles_index_cssr = (cB('base-clear', `
flex-shrink: 0;
height: 1em;
width: 1em;
position: relative;
`, [cssr_c('>', [cE('clear', `
font-size: var(--n-clear-size);
height: 1em;
width: 1em;
cursor: pointer;
color: var(--n-clear-color);
transition: color .3s var(--n-bezier);
display: flex;
`, [cssr_c('&:hover', `
color: var(--n-clear-color-hover)!important;
`), cssr_c('&:active', `
color: var(--n-clear-color-pressed)!important;
`)]), cE('placeholder', `
display: flex;
`), cE('clear, placeholder', `
position: absolute;
left: 50%;
top: 50%;
transform: translateX(-50%) translateY(-50%);
`, [iconSwitchTransition({
originalTransform: 'translateX(-50%) translateY(-50%)',
left: '50%',
top: '50%'
})])])]));
;// ./node_modules/naive-ui/es/_internal/clear/src/Clear.mjs
/* harmony default export */ var src_Clear = (defineComponent({
name: 'BaseClear',
props: {
clsPrefix: {
type: String,
required: true
},
show: Boolean,
onClear: Function
},
setup(props) {
useStyle('-base-clear', clear_src_styles_index_cssr, toRef(props, 'clsPrefix'));
return {
handleMouseDown(e) {
e.preventDefault();
}
};
},
render() {
const {
clsPrefix
} = this;
return h("div", {
class: `${clsPrefix}-base-clear`
}, h(IconSwitchTransition, null, {
default: () => {
var _a, _b;
return this.show ? h("div", {
key: "dismiss",
class: `${clsPrefix}-base-clear__clear`,
onClick: this.onClear,
onMousedown: this.handleMouseDown,
"data-clear": true
}, resolveSlot(this.$slots.icon, () => [h(Icon, {
clsPrefix: clsPrefix
}, {
default: () => h(Clear, null)
})])) : h("div", {
key: "icon",
class: `${clsPrefix}-base-clear__placeholder`
}, (_b = (_a = this.$slots).placeholder) === null || _b === void 0 ? void 0 : _b.call(_a));
}
}));
}
}));
;// ./node_modules/naive-ui/es/_internal/icons/ChevronDown.mjs
/* harmony default export */ var ChevronDown = (defineComponent({
name: 'ChevronDown',
render() {
return h("svg", {
viewBox: "0 0 16 16",
fill: "none",
xmlns: "http://www.w3.org/2000/svg"
}, h("path", {
d: "M3.14645 5.64645C3.34171 5.45118 3.65829 5.45118 3.85355 5.64645L8 9.79289L12.1464 5.64645C12.3417 5.45118 12.6583 5.45118 12.8536 5.64645C13.0488 5.84171 13.0488 6.15829 12.8536 6.35355L8.35355 10.8536C8.15829 11.0488 7.84171 11.0488 7.64645 10.8536L3.14645 6.35355C2.95118 6.15829 2.95118 5.84171 3.14645 5.64645Z",
fill: "currentColor"
}));
}
}));
;// ./node_modules/naive-ui/es/_internal/suffix/src/Suffix.mjs
/* harmony default export */ var Suffix = (defineComponent({
name: 'InternalSelectionSuffix',
props: {
clsPrefix: {
type: String,
required: true
},
showArrow: {
type: Boolean,
default: undefined
},
showClear: {
type: Boolean,
default: undefined
},
loading: {
type: Boolean,
default: false
},
onClear: Function
},
setup(props, {
slots
}) {
return () => {
const {
clsPrefix
} = props;
return h(Loading, {
clsPrefix: clsPrefix,
class: `${clsPrefix}-base-suffix`,
strokeWidth: 24,
scale: 0.85,
show: props.loading
}, {
default: () => props.showArrow ? h(src_Clear, {
clsPrefix: clsPrefix,
show: props.showClear,
onClear: props.onClear
}, {
placeholder: () => h(Icon, {
clsPrefix: clsPrefix,
class: `${clsPrefix}-base-suffix__arrow`
}, {
default: () => resolveSlot(slots.default, () => [h(ChevronDown, null)])
})
}) : null
});
};
}
}));
;// ./node_modules/naive-ui/es/_internal/icons/Eye.mjs
/* harmony default export */ var Eye = (defineComponent({
name: 'Eye',
render() {
return h("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 512 512"
}, h("path", {
d: "M255.66 112c-77.94 0-157.89 45.11-220.83 135.33a16 16 0 0 0-.27 17.77C82.92 340.8 161.8 400 255.66 400c92.84 0 173.34-59.38 221.79-135.25a16.14 16.14 0 0 0 0-17.47C428.89 172.28 347.8 112 255.66 112z",
fill: "none",
stroke: "currentColor",
"stroke-linecap": "round",
"stroke-linejoin": "round",
"stroke-width": "32"
}), h("circle", {
cx: "256",
cy: "256",
r: "80",
fill: "none",
stroke: "currentColor",
"stroke-miterlimit": "10",
"stroke-width": "32"
}));
}
}));
;// ./node_modules/naive-ui/es/_internal/icons/EyeOff.mjs
/* harmony default export */ var EyeOff = (defineComponent({
name: 'EyeOff',
render() {
return h("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 512 512"
}, h("path", {
d: "M432 448a15.92 15.92 0 0 1-11.31-4.69l-352-352a16 16 0 0 1 22.62-22.62l352 352A16 16 0 0 1 432 448z",
fill: "currentColor"
}), h("path", {
d: "M255.66 384c-41.49 0-81.5-12.28-118.92-36.5c-34.07-22-64.74-53.51-88.7-91v-.08c19.94-28.57 41.78-52.73 65.24-72.21a2 2 0 0 0 .14-2.94L93.5 161.38a2 2 0 0 0-2.71-.12c-24.92 21-48.05 46.76-69.08 76.92a31.92 31.92 0 0 0-.64 35.54c26.41 41.33 60.4 76.14 98.28 100.65C162 402 207.9 416 255.66 416a239.13 239.13 0 0 0 75.8-12.58a2 2 0 0 0 .77-3.31l-21.58-21.58a4 4 0 0 0-3.83-1a204.8 204.8 0 0 1-51.16 6.47z",
fill: "currentColor"
}), h("path", {
d: "M490.84 238.6c-26.46-40.92-60.79-75.68-99.27-100.53C349 110.55 302 96 255.66 96a227.34 227.34 0 0 0-74.89 12.83a2 2 0 0 0-.75 3.31l21.55 21.55a4 4 0 0 0 3.88 1a192.82 192.82 0 0 1 50.21-6.69c40.69 0 80.58 12.43 118.55 37c34.71 22.4 65.74 53.88 89.76 91a.13.13 0 0 1 0 .16a310.72 310.72 0 0 1-64.12 72.73a2 2 0 0 0-.15 2.95l19.9 19.89a2 2 0 0 0 2.7.13a343.49 343.49 0 0 0 68.64-78.48a32.2 32.2 0 0 0-.1-34.78z",
fill: "currentColor"
}), h("path", {
d: "M256 160a95.88 95.88 0 0 0-21.37 2.4a2 2 0 0 0-1 3.38l112.59 112.56a2 2 0 0 0 3.38-1A96 96 0 0 0 256 160z",
fill: "currentColor"
}), h("path", {
d: "M165.78 233.66a2 2 0 0 0-3.38 1a96 96 0 0 0 115 115a2 2 0 0 0 1-3.38z",
fill: "currentColor"
}));
}
}));
;// ./node_modules/naive-ui/es/locales/common/enUS.mjs
const enUS = {
name: 'en-US',
global: {
undo: 'Undo',
redo: 'Redo',
confirm: 'Confirm',
clear: 'Clear'
},
Popconfirm: {
positiveText: 'Confirm',
negativeText: 'Cancel'
},
Cascader: {
placeholder: 'Please Select',
loading: 'Loading',
loadingRequiredMessage: label => `Please load all ${label}'s descendants before checking it.`
},
Time: {
dateFormat: 'yyyy-MM-dd',
dateTimeFormat: 'yyyy-MM-dd HH:mm:ss'
},
DatePicker: {
yearFormat: 'yyyy',
monthFormat: 'MMM',
dayFormat: 'eeeeee',
yearTypeFormat: 'yyyy',
monthTypeFormat: 'yyyy-MM',
dateFormat: 'yyyy-MM-dd',
dateTimeFormat: 'yyyy-MM-dd HH:mm:ss',
quarterFormat: 'yyyy-qqq',
weekFormat: 'YYYY-w',
clear: 'Clear',
now: 'Now',
confirm: 'Confirm',
selectTime: 'Select Time',
selectDate: 'Select Date',
datePlaceholder: 'Select Date',
datetimePlaceholder: 'Select Date and Time',
monthPlaceholder: 'Select Month',
yearPlaceholder: 'Select Year',
quarterPlaceholder: 'Select Quarter',
weekPlaceholder: 'Select Week',
startDatePlaceholder: 'Start Date',
endDatePlaceholder: 'End Date',
startDatetimePlaceholder: 'Start Date and Time',
endDatetimePlaceholder: 'End Date and Time',
startMonthPlaceholder: 'Start Month',
endMonthPlaceholder: 'End Month',
monthBeforeYear: true,
firstDayOfWeek: 6,
today: 'Today'
},
DataTable: {
checkTableAll: 'Select all in the table',
uncheckTableAll: 'Unselect all in the table',
confirm: 'Confirm',
clear: 'Clear'
},
LegacyTransfer: {
sourceTitle: 'Source',
targetTitle: 'Target'
},
Transfer: {
selectAll: 'Select all',
unselectAll: 'Unselect all',
clearAll: 'Clear',
total: num => `Total ${num} items`,
selected: num => `${num} items selected`
},
Empty: {
description: 'No Data'
},
Select: {
placeholder: 'Please Select'
},
TimePicker: {
placeholder: 'Select Time',
positiveText: 'OK',
negativeText: 'Cancel',
now: 'Now',
clear: 'Clear'
},
Pagination: {
goto: 'Goto',
selectionSuffix: 'page'
},
DynamicTags: {
add: 'Add'
},
Log: {
loading: 'Loading'
},
Input: {
placeholder: 'Please Input'
},
InputNumber: {
placeholder: 'Please Input'
},
DynamicInput: {
create: 'Create'
},
ThemeEditor: {
title: 'Theme Editor',
clearAllVars: 'Clear All Variables',
clearSearch: 'Clear Search',
filterCompName: 'Filter Component Name',
filterVarName: 'Filter Variable Name',
import: 'Import',
export: 'Export',
restore: 'Reset to Default'
},
Image: {
tipPrevious: 'Previous picture (←)',
tipNext: 'Next picture (→)',
tipCounterclockwise: 'Counterclockwise',
tipClockwise: 'Clockwise',
tipZoomOut: 'Zoom out',
tipZoomIn: 'Zoom in',
tipDownload: 'Download',
tipClose: 'Close (Esc)',
// TODO: translation
tipOriginalSize: 'Zoom to original size'
}
};
/* harmony default export */ var common_enUS = (enUS);
;// ./node_modules/date-fns/locale/en-US/_lib/formatDistance.mjs
const formatDistanceLocale = {
lessThanXSeconds: {
one: "less than a second",
other: "less than {{count}} seconds",
},
xSeconds: {
one: "1 second",
other: "{{count}} seconds",
},
halfAMinute: "half a minute",
lessThanXMinutes: {
one: "less than a minute",
other: "less than {{count}} minutes",
},
xMinutes: {
one: "1 minute",
other: "{{count}} minutes",
},
aboutXHours: {
one: "about 1 hour",
other: "about {{count}} hours",
},
xHours: {
one: "1 hour",
other: "{{count}} hours",
},
xDays: {
one: "1 day",
other: "{{count}} days",
},
aboutXWeeks: {
one: "about 1 week",
other: "about {{count}} weeks",
},
xWeeks: {
one: "1 week",
other: "{{count}} weeks",
},
aboutXMonths: {
one: "about 1 month",
other: "about {{count}} months",
},
xMonths: {
one: "1 month",
other: "{{count}} months",
},
aboutXYears: {
one: "about 1 year",
other: "about {{count}} years",
},
xYears: {
one: "1 year",
other: "{{count}} years",
},
overXYears: {
one: "over 1 year",
other: "over {{count}} years",
},
almostXYears: {
one: "almost 1 year",
other: "almost {{count}} years",
},
};
const formatDistance = (token, count, options) => {
let result;
const tokenValue = formatDistanceLocale[token];
if (typeof tokenValue === "string") {
result = tokenValue;
} else if (count === 1) {
result = tokenValue.one;
} else {
result = tokenValue.other.replace("{{count}}", count.toString());
}
if (options?.addSuffix) {
if (options.comparison && options.comparison > 0) {
return "in " + result;
} else {
return result + " ago";
}
}
return result;
};
;// ./node_modules/date-fns/locale/_lib/buildFormatLongFn.mjs
function buildFormatLongFn(args) {
return (options = {}) => {
// TODO: Remove String()
const width = options.width ? String(options.width) : args.defaultWidth;
const format = args.formats[width] || args.formats[args.defaultWidth];
return format;
};
}
;// ./node_modules/date-fns/locale/en-US/_lib/formatLong.mjs
const dateFormats = {
full: "EEEE, MMMM do, y",
long: "MMMM do, y",
medium: "MMM d, y",
short: "MM/dd/yyyy",
};
const timeFormats = {
full: "h:mm:ss a zzzz",
long: "h:mm:ss a z",
medium: "h:mm:ss a",
short: "h:mm a",
};
const dateTimeFormats = {
full: "{{date}} 'at' {{time}}",
long: "{{date}} 'at' {{time}}",
medium: "{{date}}, {{time}}",
short: "{{date}}, {{time}}",
};
const formatLong = {
date: buildFormatLongFn({
formats: dateFormats,
defaultWidth: "full",
}),
time: buildFormatLongFn({
formats: timeFormats,
defaultWidth: "full",
}),
dateTime: buildFormatLongFn({
formats: dateTimeFormats,
defaultWidth: "full",
}),
};
;// ./node_modules/date-fns/locale/en-US/_lib/formatRelative.mjs
const formatRelativeLocale = {
lastWeek: "'last' eeee 'at' p",
yesterday: "'yesterday at' p",
today: "'today at' p",
tomorrow: "'tomorrow at' p",
nextWeek: "eeee 'at' p",
other: "P",
};
const formatRelative = (token, _date, _baseDate, _options) =>
formatRelativeLocale[token];
;// ./node_modules/date-fns/locale/_lib/buildLocalizeFn.mjs
/* eslint-disable no-unused-vars */
/**
* The localize function argument callback which allows to convert raw value to
* the actual type.
*
* @param value - The value to convert
*
* @returns The converted value
*/
/**
* The map of localized values for each width.
*/
/**
* The index type of the locale unit value. It types conversion of units of
* values that don't start at 0 (i.e. quarters).
*/
/**
* Converts the unit value to the tuple of values.
*/
/**
* The tuple of localized era values. The first element represents BC,
* the second element represents AD.
*/
/**
* The tuple of localized quarter values. The first element represents Q1.
*/
/**
* The tuple of localized day values. The first element represents Sunday.
*/
/**
* The tuple of localized month values. The first element represents January.
*/
function buildLocalizeFn(args) {
return (value, options) => {
const context = options?.context ? String(options.context) : "standalone";
let valuesArray;
if (context === "formatting" && args.formattingValues) {
const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
const width = options?.width ? String(options.width) : defaultWidth;
valuesArray =
args.formattingValues[width] || args.formattingValues[defaultWidth];
} else {
const defaultWidth = args.defaultWidth;
const width = options?.width ? String(options.width) : args.defaultWidth;
valuesArray = args.values[width] || args.values[defaultWidth];
}
const index = args.argumentCallback ? args.argumentCallback(value) : value;
// @ts-expect-error - For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it!
return valuesArray[index];
};
}
;// ./node_modules/date-fns/locale/en-US/_lib/localize.mjs
const eraValues = {
narrow: ["B", "A"],
abbreviated: ["BC", "AD"],
wide: ["Before Christ", "Anno Domini"],
};
const quarterValues = {
narrow: ["1", "2", "3", "4"],
abbreviated: ["Q1", "Q2", "Q3", "Q4"],
wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"],
};
// Note: in English, the names of days of the week and months are capitalized.
// If you are making a new locale based on this one, check if the same is true for the language you're working on.
// Generally, formatted dates should look like they are in the middle of a sentence,
// e.g. in Spanish language the weekdays and months should be in the lowercase.
const monthValues = {
narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
abbreviated: [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec",
],
wide: [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
],
};
const dayValues = {
narrow: ["S", "M", "T", "W", "T", "F", "S"],
short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
wide: [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
],
};
const dayPeriodValues = {
narrow: {
am: "a",
pm: "p",
midnight: "mi",
noon: "n",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night",
},
abbreviated: {
am: "AM",
pm: "PM",
midnight: "midnight",
noon: "noon",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night",
},
wide: {
am: "a.m.",
pm: "p.m.",
midnight: "midnight",
noon: "noon",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night",
},
};
const formattingDayPeriodValues = {
narrow: {
am: "a",
pm: "p",
midnight: "mi",
noon: "n",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night",
},
abbreviated: {
am: "AM",
pm: "PM",
midnight: "midnight",
noon: "noon",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night",
},
wide: {
am: "a.m.",
pm: "p.m.",
midnight: "midnight",
noon: "noon",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night",
},
};
const ordinalNumber = (dirtyNumber, _options) => {
const number = Number(dirtyNumber);
// If ordinal numbers depend on context, for example,
// if they are different for different grammatical genders,
// use `options.unit`.
//
// `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear',
// 'day', 'hour', 'minute', 'second'.
const rem100 = number % 100;
if (rem100 > 20 || rem100 < 10) {
switch (rem100 % 10) {
case 1:
return number + "st";
case 2:
return number + "nd";
case 3:
return number + "rd";
}
}
return number + "th";
};
const localize = {
ordinalNumber,
era: buildLocalizeFn({
values: eraValues,
defaultWidth: "wide",
}),
quarter: buildLocalizeFn({
values: quarterValues,
defaultWidth: "wide",
argumentCallback: (quarter) => quarter - 1,
}),
month: buildLocalizeFn({
values: monthValues,
defaultWidth: "wide",
}),
day: buildLocalizeFn({
values: dayValues,
defaultWidth: "wide",
}),
dayPeriod: buildLocalizeFn({
values: dayPeriodValues,
defaultWidth: "wide",
formattingValues: formattingDayPeriodValues,
defaultFormattingWidth: "wide",
}),
};
;// ./node_modules/date-fns/locale/_lib/buildMatchFn.mjs
function buildMatchFn(args) {
return (string, options = {}) => {
const width = options.width;
const matchPattern =
(width && args.matchPatterns[width]) ||
args.matchPatterns[args.defaultMatchWidth];
const matchResult = string.match(matchPattern);
if (!matchResult) {
return null;
}
const matchedString = matchResult[0];
const parsePatterns =
(width && args.parsePatterns[width]) ||
args.parsePatterns[args.defaultParseWidth];
const key = Array.isArray(parsePatterns)
? findIndex(parsePatterns, (pattern) => pattern.test(matchedString))
: // eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
buildMatchFn_findKey(parsePatterns, (pattern) => pattern.test(matchedString));
let value;
value = args.valueCallback ? args.valueCallback(key) : key;
value = options.valueCallback
? // eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
options.valueCallback(value)
: value;
const rest = string.slice(matchedString.length);
return { value, rest };
};
}
function buildMatchFn_findKey(object, predicate) {
for (const key in object) {
if (
Object.prototype.hasOwnProperty.call(object, key) &&
predicate(object[key])
) {
return key;
}
}
return undefined;
}
function findIndex(array, predicate) {
for (let key = 0; key < array.length; key++) {
if (predicate(array[key])) {
return key;
}
}
return undefined;
}
;// ./node_modules/date-fns/locale/_lib/buildMatchPatternFn.mjs
function buildMatchPatternFn(args) {
return (string, options = {}) => {
const matchResult = string.match(args.matchPattern);
if (!matchResult) return null;
const matchedString = matchResult[0];
const parseResult = string.match(args.parsePattern);
if (!parseResult) return null;
let value = args.valueCallback
? args.valueCallback(parseResult[0])
: parseResult[0];
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
value = options.valueCallback ? options.valueCallback(value) : value;
const rest = string.slice(matchedString.length);
return { value, rest };
};
}
;// ./node_modules/date-fns/locale/en-US/_lib/match.mjs
const matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
const parseOrdinalNumberPattern = /\d+/i;
const matchEraPatterns = {
narrow: /^(b|a)/i,
abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
wide: /^(before christ|before common era|anno domini|common era)/i,
};
const parseEraPatterns = {
any: [/^b/i, /^(a|c)/i],
};
const matchQuarterPatterns = {
narrow: /^[1234]/i,
abbreviated: /^q[1234]/i,
wide: /^[1234](th|st|nd|rd)? quarter/i,
};
const parseQuarterPatterns = {
any: [/1/i, /2/i, /3/i, /4/i],
};
const matchMonthPatterns = {
narrow: /^[jfmasond]/i,
abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i,
};
const parseMonthPatterns = {
narrow: [
/^j/i,
/^f/i,
/^m/i,
/^a/i,
/^m/i,
/^j/i,
/^j/i,
/^a/i,
/^s/i,
/^o/i,
/^n/i,
/^d/i,
],
any: [
/^ja/i,
/^f/i,
/^mar/i,
/^ap/i,
/^may/i,
/^jun/i,
/^jul/i,
/^au/i,
/^s/i,
/^o/i,
/^n/i,
/^d/i,
],
};
const matchDayPatterns = {
narrow: /^[smtwf]/i,
short: /^(su|mo|tu|we|th|fr|sa)/i,
abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i,
};
const parseDayPatterns = {
narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i],
};
const matchDayPeriodPatterns = {
narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i,
};
const parseDayPeriodPatterns = {
any: {
am: /^a/i,
pm: /^p/i,
midnight: /^mi/i,
noon: /^no/i,
morning: /morning/i,
afternoon: /afternoon/i,
evening: /evening/i,
night: /night/i,
},
};
const match = {
ordinalNumber: buildMatchPatternFn({
matchPattern: matchOrdinalNumberPattern,
parsePattern: parseOrdinalNumberPattern,
valueCallback: (value) => parseInt(value, 10),
}),
era: buildMatchFn({
matchPatterns: matchEraPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseEraPatterns,
defaultParseWidth: "any",
}),
quarter: buildMatchFn({
matchPatterns: matchQuarterPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseQuarterPatterns,
defaultParseWidth: "any",
valueCallback: (index) => index + 1,
}),
month: buildMatchFn({
matchPatterns: matchMonthPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseMonthPatterns,
defaultParseWidth: "any",
}),
day: buildMatchFn({
matchPatterns: matchDayPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseDayPatterns,
defaultParseWidth: "any",
}),
dayPeriod: buildMatchFn({
matchPatterns: matchDayPeriodPatterns,
defaultMatchWidth: "any",
parsePatterns: parseDayPeriodPatterns,
defaultParseWidth: "any",
}),
};
;// ./node_modules/date-fns/locale/en-US.mjs
/**
* @category Locales
* @summary English locale (United States).
* @language English
* @iso-639-2 eng
* @author Sasha Koss [@kossnocorp](https://github.com/kossnocorp)
* @author Lesha Koss [@leshakoss](https://github.com/leshakoss)
*/
const en_US_enUS = {
code: "en-US",
formatDistance: formatDistance,
formatLong: formatLong,
formatRelative: formatRelative,
localize: localize,
match: match,
options: {
weekStartsOn: 0 /* Sunday */,
firstWeekContainsDate: 1,
},
};
// Fallback for modularized imports:
/* harmony default export */ var en_US = ((/* unused pure expression or super */ null && (en_US_enUS)));
;// ./node_modules/naive-ui/es/locales/date/enUS.mjs
const dateEnUs = {
name: 'en-US',
locale: en_US_enUS
};
/* harmony default export */ var date_enUS = (dateEnUs);
;// ./node_modules/naive-ui/es/_mixins/use-locale.mjs
function useLocale(ns) {
const {
mergedLocaleRef,
mergedDateLocaleRef
} = runtime_core_esm_bundler_inject(context_configProviderInjectionKey, null) || {};
const localeRef = runtime_core_esm_bundler_computed(() => {
var _a, _b;
return (_b = (_a = mergedLocaleRef === null || mergedLocaleRef === void 0 ? void 0 : mergedLocaleRef.value) === null || _a === void 0 ? void 0 : _a[ns]) !== null && _b !== void 0 ? _b : common_enUS[ns];
});
const dateLocaleRef = runtime_core_esm_bundler_computed(() => {
var _a;
return (_a = mergedDateLocaleRef === null || mergedDateLocaleRef === void 0 ? void 0 : mergedDateLocaleRef.value) !== null && _a !== void 0 ? _a : date_enUS;
});
return {
dateLocaleRef,
localeRef
};
}
;// ./node_modules/naive-ui/es/input/styles/_common.mjs
/* harmony default export */ var input_styles_common = ({
paddingTiny: '0 8px',
paddingSmall: '0 10px',
paddingMedium: '0 12px',
paddingLarge: '0 14px',
clearSize: '16px'
});
;// ./node_modules/naive-ui/es/input/styles/light.mjs
function input_styles_light_self(vars) {
const {
textColor2,
textColor3,
textColorDisabled,
primaryColor,
primaryColorHover,
inputColor,
inputColorDisabled,
borderColor,
warningColor,
warningColorHover,
errorColor,
errorColorHover,
borderRadius,
lineHeight,
fontSizeTiny,
fontSizeSmall,
fontSizeMedium,
fontSizeLarge,
heightTiny,
heightSmall,
heightMedium,
heightLarge,
actionColor,
clearColor,
clearColorHover,
clearColorPressed,
placeholderColor,
placeholderColorDisabled,
iconColor,
iconColorDisabled,
iconColorHover,
iconColorPressed,
fontWeight
} = vars;
return Object.assign(Object.assign({}, input_styles_common), {
fontWeight,
countTextColorDisabled: textColorDisabled,
countTextColor: textColor3,
heightTiny,
heightSmall,
heightMedium,
heightLarge,
fontSizeTiny,
fontSizeSmall,
fontSizeMedium,
fontSizeLarge,
lineHeight,
lineHeightTextarea: lineHeight,
borderRadius,
iconSize: '16px',
groupLabelColor: actionColor,
groupLabelTextColor: textColor2,
textColor: textColor2,
textColorDisabled,
textDecorationColor: textColor2,
caretColor: primaryColor,
placeholderColor,
placeholderColorDisabled,
color: inputColor,
colorDisabled: inputColorDisabled,
colorFocus: inputColor,
groupLabelBorder: `1px solid ${borderColor}`,
border: `1px solid ${borderColor}`,
borderHover: `1px solid ${primaryColorHover}`,
borderDisabled: `1px solid ${borderColor}`,
borderFocus: `1px solid ${primaryColorHover}`,
boxShadowFocus: `0 0 0 2px ${changeColor(primaryColor, {
alpha: 0.2
})}`,
loadingColor: primaryColor,
// warning
loadingColorWarning: warningColor,
borderWarning: `1px solid ${warningColor}`,
borderHoverWarning: `1px solid ${warningColorHover}`,
colorFocusWarning: inputColor,
borderFocusWarning: `1px solid ${warningColorHover}`,
boxShadowFocusWarning: `0 0 0 2px ${changeColor(warningColor, {
alpha: 0.2
})}`,
caretColorWarning: warningColor,
// error
loadingColorError: errorColor,
borderError: `1px solid ${errorColor}`,
borderHoverError: `1px solid ${errorColorHover}`,
colorFocusError: inputColor,
borderFocusError: `1px solid ${errorColorHover}`,
boxShadowFocusError: `0 0 0 2px ${changeColor(errorColor, {
alpha: 0.2
})}`,
caretColorError: errorColor,
clearColor,
clearColorHover,
clearColorPressed,
iconColor,
iconColorDisabled,
iconColorHover,
iconColorPressed,
suffixTextColor: textColor2
});
}
const inputLight = {
name: 'Input',
common: light,
self: input_styles_light_self
};
/* harmony default export */ var input_styles_light = (inputLight);
;// ./node_modules/naive-ui/es/input/src/interface.mjs
const inputInjectionKey = createInjectionKey('n-input');
;// ./node_modules/naive-ui/es/input/src/styles/input.cssr.mjs
// vars:
// --n-bezier
// --n-color
// --n-font-size
// --n-border-radius
// --n-height
// --n-padding-left
// --n-padding-right
// --n-text-color
// --n-text-color-disabled
// --n-caret-color
// --n-text-decoration-color
// --n-border
// --n-border-disabled
// --n-border-hover
// --n-border-focus
// --n-placeholder-color
// --n-placeholder-color-disabled
// --n-line-height-textarea
// --n-color-disabled
// --n-color-focus
// --n-box-shadow-focus
// --n-clear-color
// --n-clear-size
// --n-clear-color-hover
// --n-clear-color-pressed
// --n-suffix-text-color
// --n-icon-color
// --n-icon-color-hover
// --n-icon-color-pressed
// --n-icon-color-disabled
// --n-count-text-color
// --n-count-text-color-disabled
// --n-loading-color
// ...form item vars
/* harmony default export */ var input_cssr = (cB('input', `
max-width: 100%;
cursor: text;
line-height: 1.5;
z-index: auto;
outline: none;
box-sizing: border-box;
position: relative;
display: inline-flex;
border-radius: var(--n-border-radius);
background-color: var(--n-color);
transition: background-color .3s var(--n-bezier);
font-size: var(--n-font-size);
font-weight: var(--n-font-weight);
--n-padding-vertical: calc((var(--n-height) - 1.5 * var(--n-font-size)) / 2);
`, [
// common
cE('input, textarea', `
overflow: hidden;
flex-grow: 1;
position: relative;
`), cE('input-el, textarea-el, input-mirror, textarea-mirror, separator, placeholder', `
box-sizing: border-box;
font-size: inherit;
line-height: 1.5;
font-family: inherit;
border: none;
outline: none;
background-color: #0000;
text-align: inherit;
transition:
-webkit-text-fill-color .3s var(--n-bezier),
caret-color .3s var(--n-bezier),
color .3s var(--n-bezier),
text-decoration-color .3s var(--n-bezier);
`), cE('input-el, textarea-el', `
-webkit-appearance: none;
scrollbar-width: none;
width: 100%;
min-width: 0;
text-decoration-color: var(--n-text-decoration-color);
color: var(--n-text-color);
caret-color: var(--n-caret-color);
background-color: transparent;
`, [cssr_c('&::-webkit-scrollbar, &::-webkit-scrollbar-track-piece, &::-webkit-scrollbar-thumb', `
width: 0;
height: 0;
display: none;
`), cssr_c('&::placeholder', `
color: #0000;
-webkit-text-fill-color: transparent !important;
`), cssr_c('&:-webkit-autofill ~', [cE('placeholder', 'display: none;')])]), cM('round', [cNotM('textarea', 'border-radius: calc(var(--n-height) / 2);')]), cE('placeholder', `
pointer-events: none;
position: absolute;
left: 0;
right: 0;
top: 0;
bottom: 0;
overflow: hidden;
color: var(--n-placeholder-color);
`, [cssr_c('span', `
width: 100%;
display: inline-block;
`)]), cM('textarea', [cE('placeholder', 'overflow: visible;')]), cNotM('autosize', 'width: 100%;'), cM('autosize', [cE('textarea-el, input-el', `
position: absolute;
top: 0;
left: 0;
height: 100%;
`)]),
// input
cB('input-wrapper', `
overflow: hidden;
display: inline-flex;
flex-grow: 1;
position: relative;
padding-left: var(--n-padding-left);
padding-right: var(--n-padding-right);
`), cE('input-mirror', `
padding: 0;
height: var(--n-height);
line-height: var(--n-height);
overflow: hidden;
visibility: hidden;
position: static;
white-space: pre;
pointer-events: none;
`), cE('input-el', `
padding: 0;
height: var(--n-height);
line-height: var(--n-height);
`, [cssr_c('&[type=password]::-ms-reveal', 'display: none;'), cssr_c('+', [cE('placeholder', `
display: flex;
align-items: center;
`)])]), cNotM('textarea', [cE('placeholder', 'white-space: nowrap;')]), cE('eye', `
display: flex;
align-items: center;
justify-content: center;
transition: color .3s var(--n-bezier);
`),
// textarea
cM('textarea', 'width: 100%;', [cB('input-word-count', `
position: absolute;
right: var(--n-padding-right);
bottom: var(--n-padding-vertical);
`), cM('resizable', [cB('input-wrapper', `
resize: vertical;
min-height: var(--n-height);
`)]), cE('textarea-el, textarea-mirror, placeholder', `
height: 100%;
padding-left: 0;
padding-right: 0;
padding-top: var(--n-padding-vertical);
padding-bottom: var(--n-padding-vertical);
word-break: break-word;
display: inline-block;
vertical-align: bottom;
box-sizing: border-box;
line-height: var(--n-line-height-textarea);
margin: 0;
resize: none;
white-space: pre-wrap;
scroll-padding-block-end: var(--n-padding-vertical);
`), cE('textarea-mirror', `
width: 100%;
pointer-events: none;
overflow: hidden;
visibility: hidden;
position: static;
white-space: pre-wrap;
overflow-wrap: break-word;
`)]),
// pair
cM('pair', [cE('input-el, placeholder', 'text-align: center;'), cE('separator', `
display: flex;
align-items: center;
transition: color .3s var(--n-bezier);
color: var(--n-text-color);
white-space: nowrap;
`, [cB('icon', `
color: var(--n-icon-color);
`), cB('base-icon', `
color: var(--n-icon-color);
`)])]), cM('disabled', `
cursor: not-allowed;
background-color: var(--n-color-disabled);
`, [cE('border', 'border: var(--n-border-disabled);'), cE('input-el, textarea-el', `
cursor: not-allowed;
color: var(--n-text-color-disabled);
text-decoration-color: var(--n-text-color-disabled);
`), cE('placeholder', 'color: var(--n-placeholder-color-disabled);'), cE('separator', 'color: var(--n-text-color-disabled);', [cB('icon', `
color: var(--n-icon-color-disabled);
`), cB('base-icon', `
color: var(--n-icon-color-disabled);
`)]), cB('input-word-count', `
color: var(--n-count-text-color-disabled);
`), cE('suffix, prefix', 'color: var(--n-text-color-disabled);', [cB('icon', `
color: var(--n-icon-color-disabled);
`), cB('internal-icon', `
color: var(--n-icon-color-disabled);
`)])]), cNotM('disabled', [cE('eye', `
color: var(--n-icon-color);
cursor: pointer;
`, [cssr_c('&:hover', `
color: var(--n-icon-color-hover);
`), cssr_c('&:active', `
color: var(--n-icon-color-pressed);
`)]), cssr_c('&:hover', [cE('state-border', 'border: var(--n-border-hover);')]), cM('focus', 'background-color: var(--n-color-focus);', [cE('state-border', `
border: var(--n-border-focus);
box-shadow: var(--n-box-shadow-focus);
`)])]), cE('border, state-border', `
box-sizing: border-box;
position: absolute;
left: 0;
right: 0;
top: 0;
bottom: 0;
pointer-events: none;
border-radius: inherit;
border: var(--n-border);
transition:
box-shadow .3s var(--n-bezier),
border-color .3s var(--n-bezier);
`), cE('state-border', `
border-color: #0000;
z-index: 1;
`), cE('prefix', 'margin-right: 4px;'), cE('suffix', `
margin-left: 4px;
`), cE('suffix, prefix', `
transition: color .3s var(--n-bezier);
flex-wrap: nowrap;
flex-shrink: 0;
line-height: var(--n-height);
white-space: nowrap;
display: inline-flex;
align-items: center;
justify-content: center;
color: var(--n-suffix-text-color);
`, [cB('base-loading', `
font-size: var(--n-icon-size);
margin: 0 2px;
color: var(--n-loading-color);
`), cB('base-clear', `
font-size: var(--n-icon-size);
`, [cE('placeholder', [cB('base-icon', `
transition: color .3s var(--n-bezier);
color: var(--n-icon-color);
font-size: var(--n-icon-size);
`)])]), cssr_c('>', [cB('icon', `
transition: color .3s var(--n-bezier);
color: var(--n-icon-color);
font-size: var(--n-icon-size);
`)]), cB('base-icon', `
font-size: var(--n-icon-size);
`)]), cB('input-word-count', `
pointer-events: none;
line-height: 1.5;
font-size: .85em;
color: var(--n-count-text-color);
transition: color .3s var(--n-bezier);
margin-left: 4px;
font-variant: tabular-nums;
`), ['warning', 'error'].map(status => cM(`${status}-status`, [cNotM('disabled', [cB('base-loading', `
color: var(--n-loading-color-${status})
`), cE('input-el, textarea-el', `
caret-color: var(--n-caret-color-${status});
`), cE('state-border', `
border: var(--n-border-${status});
`), cssr_c('&:hover', [cE('state-border', `
border: var(--n-border-hover-${status});
`)]), cssr_c('&:focus', `
background-color: var(--n-color-focus-${status});
`, [cE('state-border', `
box-shadow: var(--n-box-shadow-focus-${status});
border: var(--n-border-focus-${status});
`)]), cM('focus', `
background-color: var(--n-color-focus-${status});
`, [cE('state-border', `
box-shadow: var(--n-box-shadow-focus-${status});
border: var(--n-border-focus-${status});
`)])])]))]));
const safariStyle = cB('input', [cM('disabled', [cE('input-el, textarea-el', `
-webkit-text-fill-color: var(--n-text-color-disabled);
`)])]);
;// ./node_modules/naive-ui/es/input/src/utils.mjs
function len(s) {
let count = 0;
for (const _ of s) {
count++;
}
return count;
}
function isEmptyInputValue(value) {
return value === '' || value == null;
}
function useCursor(inputElRef) {
const selectionRef = ref(null);
function recordCursor() {
const {
value: input
} = inputElRef;
if (!(input === null || input === void 0 ? void 0 : input.focus)) {
reset();
return;
}
const {
selectionStart,
selectionEnd,
value
} = input;
if (selectionStart == null || selectionEnd == null) {
reset();
return;
}
selectionRef.value = {
start: selectionStart,
end: selectionEnd,
beforeText: value.slice(0, selectionStart),
afterText: value.slice(selectionEnd)
};
}
function restoreCursor() {
var _a;
const {
value: selection
} = selectionRef;
const {
value: inputEl
} = inputElRef;
if (!selection || !inputEl) {
return;
}
const {
value
} = inputEl;
const {
start,
beforeText,
afterText
} = selection;
let startPos = value.length;
if (value.endsWith(afterText)) {
startPos = value.length - afterText.length;
} else if (value.startsWith(beforeText)) {
startPos = beforeText.length;
} else {
const beforeLastChar = beforeText[start - 1];
const newIndex = value.indexOf(beforeLastChar, start - 1);
if (newIndex !== -1) {
startPos = newIndex + 1;
}
}
(_a = inputEl.setSelectionRange) === null || _a === void 0 ? void 0 : _a.call(inputEl, startPos, startPos);
}
function reset() {
selectionRef.value = null;
}
runtime_core_esm_bundler_watch(inputElRef, reset);
return {
recordCursor,
restoreCursor
};
}
;// ./node_modules/naive-ui/es/input/src/WordCount.mjs
/* harmony default export */ var WordCount = (defineComponent({
name: 'InputWordCount',
setup(_, {
slots
}) {
const {
mergedValueRef,
maxlengthRef,
mergedClsPrefixRef,
countGraphemesRef
} = runtime_core_esm_bundler_inject(inputInjectionKey);
const wordCountRef = runtime_core_esm_bundler_computed(() => {
const {
value: mergedValue
} = mergedValueRef;
if (mergedValue === null || Array.isArray(mergedValue)) return 0;
return (countGraphemesRef.value || len)(mergedValue);
});
return () => {
const {
value: maxlength
} = maxlengthRef;
const {
value: mergedValue
} = mergedValueRef;
return h("span", {
class: `${mergedClsPrefixRef.value}-input-word-count`
}, resolveSlotWithTypedProps(slots.default, {
value: mergedValue === null || Array.isArray(mergedValue) ? '' : mergedValue
}, () => [maxlength === undefined ? wordCountRef.value : `${wordCountRef.value} / ${maxlength}`]));
};
}
}));
;// ./node_modules/naive-ui/es/input/src/Input.mjs
const inputProps = Object.assign(Object.assign({}, use_theme.props), {
bordered: {
type: Boolean,
default: undefined
},
type: {
type: String,
default: 'text'
},
placeholder: [Array, String],
defaultValue: {
type: [String, Array],
default: null
},
value: [String, Array],
disabled: {
type: Boolean,
default: undefined
},
size: String,
rows: {
type: [Number, String],
default: 3
},
round: Boolean,
minlength: [String, Number],
maxlength: [String, Number],
clearable: Boolean,
autosize: {
type: [Boolean, Object],
default: false
},
pair: Boolean,
separator: String,
readonly: {
type: [String, Boolean],
default: false
},
passivelyActivated: Boolean,
showPasswordOn: String,
stateful: {
type: Boolean,
default: true
},
autofocus: Boolean,
inputProps: Object,
resizable: {
type: Boolean,
default: true
},
showCount: Boolean,
loading: {
type: Boolean,
default: undefined
},
allowInput: Function,
renderCount: Function,
onMousedown: Function,
onKeydown: Function,
onKeyup: [Function, Array],
onInput: [Function, Array],
onFocus: [Function, Array],
onBlur: [Function, Array],
onClick: [Function, Array],
onChange: [Function, Array],
onClear: [Function, Array],
countGraphemes: Function,
status: String,
'onUpdate:value': [Function, Array],
onUpdateValue: [Function, Array],
/** private */
textDecoration: [String, Array],
attrSize: {
type: Number,
default: 20
},
onInputBlur: [Function, Array],
onInputFocus: [Function, Array],
onDeactivate: [Function, Array],
onActivate: [Function, Array],
onWrapperFocus: [Function, Array],
onWrapperBlur: [Function, Array],
internalDeactivateOnEnter: Boolean,
internalForceFocus: Boolean,
internalLoadingBeforeSuffix: {
type: Boolean,
default: true
},
/** deprecated */
showPasswordToggle: Boolean
});
/* harmony default export */ var Input = (defineComponent({
name: 'Input',
props: inputProps,
slots: Object,
setup(props) {
if (false) {}
const {
mergedClsPrefixRef,
mergedBorderedRef,
inlineThemeDisabled,
mergedRtlRef
} = useConfig(props);
const themeRef = use_theme('Input', '-input', input_cssr, input_styles_light, props, mergedClsPrefixRef);
if (isSafari) {
useStyle('-input-safari', safariStyle, mergedClsPrefixRef);
}
// dom refs
const wrapperElRef = ref(null);
const textareaElRef = ref(null);
const textareaMirrorElRef = ref(null);
const inputMirrorElRef = ref(null);
const inputElRef = ref(null);
const inputEl2Ref = ref(null);
const currentFocusedInputRef = ref(null);
const focusedInputCursorControl = useCursor(currentFocusedInputRef);
const textareaScrollbarInstRef = ref(null);
// local
const {
localeRef
} = useLocale('Input');
// value
const uncontrolledValueRef = ref(props.defaultValue);
const controlledValueRef = toRef(props, 'value');
const mergedValueRef = useMergedState(controlledValueRef, uncontrolledValueRef);
// form-item
const formItem = useFormItem(props);
const {
mergedSizeRef,
mergedDisabledRef,
mergedStatusRef
} = formItem;
// states
const focusedRef = ref(false);
const hoverRef = ref(false);
const isComposingRef = ref(false);
const activatedRef = ref(false);
let syncSource = null;
// placeholder
const mergedPlaceholderRef = runtime_core_esm_bundler_computed(() => {
const {
placeholder,
pair
} = props;
if (pair) {
if (Array.isArray(placeholder)) {
return placeholder;
} else if (placeholder === undefined) {
return ['', ''];
}
return [placeholder, placeholder];
} else if (placeholder === undefined) {
return [localeRef.value.placeholder];
} else {
return [placeholder];
}
});
const showPlaceholder1Ref = runtime_core_esm_bundler_computed(() => {
const {
value: isComposing
} = isComposingRef;
const {
value: mergedValue
} = mergedValueRef;
const {
value: mergedPlaceholder
} = mergedPlaceholderRef;
return !isComposing && (isEmptyInputValue(mergedValue) || Array.isArray(mergedValue) && isEmptyInputValue(mergedValue[0])) && mergedPlaceholder[0];
});
const showPlaceholder2Ref = runtime_core_esm_bundler_computed(() => {
const {
value: isComposing
} = isComposingRef;
const {
value: mergedValue
} = mergedValueRef;
const {
value: mergedPlaceholder
} = mergedPlaceholderRef;
return !isComposing && mergedPlaceholder[1] && (isEmptyInputValue(mergedValue) || Array.isArray(mergedValue) && isEmptyInputValue(mergedValue[1]));
});
// focus
const mergedFocusRef = use_memo(() => {
return props.internalForceFocus || focusedRef.value;
});
// clear
const showClearButton = use_memo(() => {
if (mergedDisabledRef.value || props.readonly || !props.clearable || !mergedFocusRef.value && !hoverRef.value) {
return false;
}
const {
value: mergedValue
} = mergedValueRef;
const {
value: mergedFocus
} = mergedFocusRef;
if (props.pair) {
return !!(Array.isArray(mergedValue) && (mergedValue[0] || mergedValue[1])) && (hoverRef.value || mergedFocus);
} else {
return !!mergedValue && (hoverRef.value || mergedFocus);
}
});
// passwordVisible
const mergedShowPasswordOnRef = runtime_core_esm_bundler_computed(() => {
const {
showPasswordOn
} = props;
if (showPasswordOn) {
return showPasswordOn;
}
if (props.showPasswordToggle) return 'click';
return undefined;
});
const passwordVisibleRef = ref(false);
// text-decoration
const textDecorationStyleRef = runtime_core_esm_bundler_computed(() => {
const {
textDecoration
} = props;
if (!textDecoration) return ['', ''];
if (Array.isArray(textDecoration)) {
return textDecoration.map(v => ({
textDecoration: v
}));
}
return [{
textDecoration
}];
});
const textAreaScrollContainerWidthRef = ref(undefined);
// textarea autosize
const updateTextAreaStyle = () => {
var _a, _b;
if (props.type === 'textarea') {
const {
autosize
} = props;
if (autosize) {
textAreaScrollContainerWidthRef.value = (_b = (_a = textareaScrollbarInstRef.value) === null || _a === void 0 ? void 0 : _a.$el) === null || _b === void 0 ? void 0 : _b.offsetWidth;
}
if (!textareaElRef.value) return;
if (typeof autosize === 'boolean') return;
const {
paddingTop: stylePaddingTop,
paddingBottom: stylePaddingBottom,
lineHeight: styleLineHeight
} = window.getComputedStyle(textareaElRef.value);
const paddingTop = Number(stylePaddingTop.slice(0, -2));
const paddingBottom = Number(stylePaddingBottom.slice(0, -2));
const lineHeight = Number(styleLineHeight.slice(0, -2));
const {
value: textareaMirrorEl
} = textareaMirrorElRef;
if (!textareaMirrorEl) return;
if (autosize.minRows) {
const minRows = Math.max(autosize.minRows, 1);
const styleMinHeight = `${paddingTop + paddingBottom + lineHeight * minRows}px`;
textareaMirrorEl.style.minHeight = styleMinHeight;
}
if (autosize.maxRows) {
const styleMaxHeight = `${paddingTop + paddingBottom + lineHeight * autosize.maxRows}px`;
textareaMirrorEl.style.maxHeight = styleMaxHeight;
}
}
};
// word count
const maxlengthRef = runtime_core_esm_bundler_computed(() => {
const {
maxlength
} = props;
return maxlength === undefined ? undefined : Number(maxlength);
});
runtime_core_esm_bundler_onMounted(() => {
// sync mirror if is not pair
const {
value
} = mergedValueRef;
if (!Array.isArray(value)) {
syncMirror(value);
}
});
// other methods
const vm = runtime_core_esm_bundler_getCurrentInstance().proxy;
function doUpdateValue(value, meta) {
const {
onUpdateValue,
'onUpdate:value': _onUpdateValue,
onInput
} = props;
const {
nTriggerFormInput
} = formItem;
if (onUpdateValue) call(onUpdateValue, value, meta);
if (_onUpdateValue) call(_onUpdateValue, value, meta);
if (onInput) call(onInput, value, meta);
uncontrolledValueRef.value = value;
nTriggerFormInput();
}
function doChange(value, meta) {
const {
onChange
} = props;
const {
nTriggerFormChange
} = formItem;
if (onChange) call(onChange, value, meta);
uncontrolledValueRef.value = value;
nTriggerFormChange();
}
function doBlur(e) {
const {
onBlur
} = props;
const {
nTriggerFormBlur
} = formItem;
if (onBlur) call(onBlur, e);
nTriggerFormBlur();
}
function doFocus(e) {
const {
onFocus
} = props;
const {
nTriggerFormFocus
} = formItem;
if (onFocus) call(onFocus, e);
nTriggerFormFocus();
}
function doClear(e) {
const {
onClear
} = props;
if (onClear) call(onClear, e);
}
function doUpdateValueBlur(e) {
const {
onInputBlur
} = props;
if (onInputBlur) call(onInputBlur, e);
}
function doUpdateValueFocus(e) {
const {
onInputFocus
} = props;
if (onInputFocus) call(onInputFocus, e);
}
function doDeactivate() {
const {
onDeactivate
} = props;
if (onDeactivate) call(onDeactivate);
}
function doActivate() {
const {
onActivate
} = props;
if (onActivate) call(onActivate);
}
function doClick(e) {
const {
onClick
} = props;
if (onClick) call(onClick, e);
}
function doWrapperFocus(e) {
const {
onWrapperFocus
} = props;
if (onWrapperFocus) call(onWrapperFocus, e);
}
function doWrapperBlur(e) {
const {
onWrapperBlur
} = props;
if (onWrapperBlur) call(onWrapperBlur, e);
}
// methods
function handleCompositionStart() {
isComposingRef.value = true;
}
function handleCompositionEnd(e) {
isComposingRef.value = false;
if (e.target === inputEl2Ref.value) {
handleInput(e, 1);
} else {
handleInput(e, 0);
}
}
function handleInput(e, index = 0, event = 'input') {
const targetValue = e.target.value;
syncMirror(targetValue);
if (e instanceof InputEvent && !e.isComposing) {
isComposingRef.value = false;
}
if (props.type === 'textarea') {
const {
value: textareaScrollbarInst
} = textareaScrollbarInstRef;
if (textareaScrollbarInst) {
textareaScrollbarInst.syncUnifiedContainer();
}
}
syncSource = targetValue;
if (isComposingRef.value) return;
focusedInputCursorControl.recordCursor();
const isIncomingValueValid = allowInput(targetValue);
if (isIncomingValueValid) {
if (!props.pair) {
if (event === 'input') {
doUpdateValue(targetValue, {
source: index
});
} else {
doChange(targetValue, {
source: index
});
}
} else {
let {
value
} = mergedValueRef;
if (!Array.isArray(value)) {
value = ['', ''];
} else {
value = [value[0], value[1]];
}
value[index] = targetValue;
if (event === 'input') {
doUpdateValue(value, {
source: index
});
} else {
doChange(value, {
source: index
});
}
}
}
// force update to sync input's view with value
// if not set, after input, input value won't sync with dom input value
vm.$forceUpdate();
if (!isIncomingValueValid) {
void nextTick(focusedInputCursorControl.restoreCursor);
}
}
function allowInput(value) {
const {
countGraphemes,
maxlength,
minlength
} = props;
if (countGraphemes) {
let graphemesCount;
if (maxlength !== undefined) {
if (graphemesCount === undefined) {
graphemesCount = countGraphemes(value);
}
if (graphemesCount > Number(maxlength)) return false;
}
if (minlength !== undefined) {
if (graphemesCount === undefined) {
graphemesCount = countGraphemes(value);
}
if (graphemesCount < Number(maxlength)) return false;
}
}
const {
allowInput
} = props;
if (typeof allowInput === 'function') {
return allowInput(value);
}
return true;
}
function handleInputBlur(e) {
doUpdateValueBlur(e);
if (e.relatedTarget === wrapperElRef.value) {
doDeactivate();
}
if (!(e.relatedTarget !== null && (e.relatedTarget === inputElRef.value || e.relatedTarget === inputEl2Ref.value || e.relatedTarget === textareaElRef.value))) {
activatedRef.value = false;
}
dealWithEvent(e, 'blur');
currentFocusedInputRef.value = null;
}
function handleInputFocus(e, index) {
doUpdateValueFocus(e);
focusedRef.value = true;
activatedRef.value = true;
doActivate();
dealWithEvent(e, 'focus');
if (index === 0) {
currentFocusedInputRef.value = inputElRef.value;
} else if (index === 1) {
currentFocusedInputRef.value = inputEl2Ref.value;
} else if (index === 2) {
currentFocusedInputRef.value = textareaElRef.value;
}
}
function handleWrapperBlur(e) {
if (props.passivelyActivated) {
doWrapperBlur(e);
dealWithEvent(e, 'blur');
}
}
function handleWrapperFocus(e) {
if (props.passivelyActivated) {
focusedRef.value = true;
doWrapperFocus(e);
dealWithEvent(e, 'focus');
}
}
function dealWithEvent(e, type) {
if (e.relatedTarget !== null && (e.relatedTarget === inputElRef.value || e.relatedTarget === inputEl2Ref.value || e.relatedTarget === textareaElRef.value || e.relatedTarget === wrapperElRef.value)) {
/**
* activeElement transfer inside the input, do nothing
*/
} else {
if (type === 'focus') {
doFocus(e);
focusedRef.value = true;
} else if (type === 'blur') {
doBlur(e);
focusedRef.value = false;
}
}
}
function handleChange(e, index) {
handleInput(e, index, 'change');
}
function handleClick(e) {
doClick(e);
}
function handleClear(e) {
doClear(e);
clearValue();
}
function clearValue() {
if (props.pair) {
doUpdateValue(['', ''], {
source: 'clear'
});
doChange(['', ''], {
source: 'clear'
});
} else {
doUpdateValue('', {
source: 'clear'
});
doChange('', {
source: 'clear'
});
}
}
function handleMouseDown(e) {
const {
onMousedown
} = props;
if (onMousedown) onMousedown(e);
const {
tagName
} = e.target;
if (tagName !== 'INPUT' && tagName !== 'TEXTAREA') {
if (props.resizable) {
const {
value: wrapperEl
} = wrapperElRef;
if (wrapperEl) {
const {
left,
top,
width,
height
} = wrapperEl.getBoundingClientRect();
const resizeHandleSize = 14;
if (left + width - resizeHandleSize < e.clientX && e.clientX < left + width && top + height - resizeHandleSize < e.clientY && e.clientY < top + height) {
// touching resize handle, just let it go.
// resize won't take focus, maybe there is a better way to do this.
// hope someone can figure out a better solution
return;
}
}
}
e.preventDefault();
if (!focusedRef.value) {
focus();
}
}
}
function handleMouseEnter() {
var _a;
hoverRef.value = true;
if (props.type === 'textarea') {
(_a = textareaScrollbarInstRef.value) === null || _a === void 0 ? void 0 : _a.handleMouseEnterWrapper();
}
}
function handleMouseLeave() {
var _a;
hoverRef.value = false;
if (props.type === 'textarea') {
(_a = textareaScrollbarInstRef.value) === null || _a === void 0 ? void 0 : _a.handleMouseLeaveWrapper();
}
}
function handlePasswordToggleClick() {
if (mergedDisabledRef.value) return;
if (mergedShowPasswordOnRef.value !== 'click') return;
passwordVisibleRef.value = !passwordVisibleRef.value;
}
function handlePasswordToggleMousedown(e) {
if (mergedDisabledRef.value) return;
e.preventDefault();
const preventDefaultOnce = e => {
e.preventDefault();
off('mouseup', document, preventDefaultOnce);
};
on('mouseup', document, preventDefaultOnce);
if (mergedShowPasswordOnRef.value !== 'mousedown') return;
passwordVisibleRef.value = true;
const hidePassword = () => {
passwordVisibleRef.value = false;
off('mouseup', document, hidePassword);
};
on('mouseup', document, hidePassword);
}
function handleWrapperKeyup(e) {
if (props.onKeyup) call(props.onKeyup, e);
}
function handleWrapperKeydown(e) {
if (props.onKeydown) call(props.onKeydown, e);
switch (e.key) {
case 'Escape':
handleWrapperKeydownEsc();
break;
case 'Enter':
handleWrapperKeydownEnter(e);
break;
}
}
function handleWrapperKeydownEnter(e) {
var _a, _b;
if (props.passivelyActivated) {
const {
value: focused
} = activatedRef;
if (focused) {
if (props.internalDeactivateOnEnter) {
handleWrapperKeydownEsc();
}
return;
}
e.preventDefault();
if (props.type === 'textarea') {
(_a = textareaElRef.value) === null || _a === void 0 ? void 0 : _a.focus();
} else {
(_b = inputElRef.value) === null || _b === void 0 ? void 0 : _b.focus();
}
}
}
function handleWrapperKeydownEsc() {
if (props.passivelyActivated) {
activatedRef.value = false;
void nextTick(() => {
var _a;
(_a = wrapperElRef.value) === null || _a === void 0 ? void 0 : _a.focus();
});
}
}
function focus() {
var _a, _b, _c;
if (mergedDisabledRef.value) return;
if (props.passivelyActivated) {
(_a = wrapperElRef.value) === null || _a === void 0 ? void 0 : _a.focus();
} else {
(_b = textareaElRef.value) === null || _b === void 0 ? void 0 : _b.focus();
(_c = inputElRef.value) === null || _c === void 0 ? void 0 : _c.focus();
}
}
function blur() {
var _a;
if ((_a = wrapperElRef.value) === null || _a === void 0 ? void 0 : _a.contains(document.activeElement)) {
;
document.activeElement.blur();
}
}
function select() {
var _a, _b;
(_a = textareaElRef.value) === null || _a === void 0 ? void 0 : _a.select();
(_b = inputElRef.value) === null || _b === void 0 ? void 0 : _b.select();
}
function activate() {
if (mergedDisabledRef.value) return;
if (textareaElRef.value) textareaElRef.value.focus();else if (inputElRef.value) inputElRef.value.focus();
}
function deactivate() {
const {
value: wrapperEl
} = wrapperElRef;
if ((wrapperEl === null || wrapperEl === void 0 ? void 0 : wrapperEl.contains(document.activeElement)) && wrapperEl !== document.activeElement) {
handleWrapperKeydownEsc();
}
}
function scrollTo(options) {
if (props.type === 'textarea') {
const {
value: textareaEl
} = textareaElRef;
textareaEl === null || textareaEl === void 0 ? void 0 : textareaEl.scrollTo(options);
} else {
const {
value: inputEl
} = inputElRef;
inputEl === null || inputEl === void 0 ? void 0 : inputEl.scrollTo(options);
}
}
function syncMirror(value) {
const {
type,
pair,
autosize
} = props;
if (!pair && autosize) {
if (type === 'textarea') {
const {
value: textareaMirrorEl
} = textareaMirrorElRef;
if (textareaMirrorEl) {
textareaMirrorEl.textContent = `${value !== null && value !== void 0 ? value : ''}\r\n`;
}
} else {
const {
value: inputMirrorEl
} = inputMirrorElRef;
if (inputMirrorEl) {
if (value) {
inputMirrorEl.textContent = value;
} else {
inputMirrorEl.innerHTML = ' ';
}
}
}
}
}
function handleTextAreaMirrorResize() {
updateTextAreaStyle();
}
const placeholderStyleRef = ref({
top: '0'
});
function handleTextAreaScroll(e) {
var _a;
const {
scrollTop
} = e.target;
placeholderStyleRef.value.top = `${-scrollTop}px`;
(_a = textareaScrollbarInstRef.value) === null || _a === void 0 ? void 0 : _a.syncUnifiedContainer();
}
let stopWatchMergedValue1 = null;
watchEffect(() => {
const {
autosize,
type
} = props;
if (autosize && type === 'textarea') {
stopWatchMergedValue1 = runtime_core_esm_bundler_watch(mergedValueRef, value => {
if (!Array.isArray(value) && value !== syncSource) {
syncMirror(value);
}
});
} else {
stopWatchMergedValue1 === null || stopWatchMergedValue1 === void 0 ? void 0 : stopWatchMergedValue1();
}
});
let stopWatchMergedValue2 = null;
watchEffect(() => {
if (props.type === 'textarea') {
stopWatchMergedValue2 = runtime_core_esm_bundler_watch(mergedValueRef, value => {
var _a;
if (!Array.isArray(value) && value !== syncSource) {
(_a = textareaScrollbarInstRef.value) === null || _a === void 0 ? void 0 : _a.syncUnifiedContainer();
}
});
} else {
stopWatchMergedValue2 === null || stopWatchMergedValue2 === void 0 ? void 0 : stopWatchMergedValue2();
}
});
provide(inputInjectionKey, {
mergedValueRef,
maxlengthRef,
mergedClsPrefixRef,
countGraphemesRef: toRef(props, 'countGraphemes')
});
const exposedProps = {
wrapperElRef,
inputElRef,
textareaElRef,
isCompositing: isComposingRef,
clear: clearValue,
focus,
blur,
select,
deactivate,
activate,
scrollTo
};
const rtlEnabledRef = useRtl('Input', mergedRtlRef, mergedClsPrefixRef);
const cssVarsRef = runtime_core_esm_bundler_computed(() => {
const {
value: size
} = mergedSizeRef;
const {
common: {
cubicBezierEaseInOut
},
self: {
color,
borderRadius,
textColor,
caretColor,
caretColorError,
caretColorWarning,
textDecorationColor,
border,
borderDisabled,
borderHover,
borderFocus,
placeholderColor,
placeholderColorDisabled,
lineHeightTextarea,
colorDisabled,
colorFocus,
textColorDisabled,
boxShadowFocus,
iconSize,
colorFocusWarning,
boxShadowFocusWarning,
borderWarning,
borderFocusWarning,
borderHoverWarning,
colorFocusError,
boxShadowFocusError,
borderError,
borderFocusError,
borderHoverError,
clearSize,
clearColor,
clearColorHover,
clearColorPressed,
iconColor,
iconColorDisabled,
suffixTextColor,
countTextColor,
countTextColorDisabled,
iconColorHover,
iconColorPressed,
loadingColor,
loadingColorError,
loadingColorWarning,
fontWeight,
[createKey('padding', size)]: padding,
[createKey('fontSize', size)]: fontSize,
[createKey('height', size)]: height
}
} = themeRef.value;
const {
left: paddingLeft,
right: paddingRight
} = getMargin(padding);
return {
'--n-bezier': cubicBezierEaseInOut,
'--n-count-text-color': countTextColor,
'--n-count-text-color-disabled': countTextColorDisabled,
'--n-color': color,
'--n-font-size': fontSize,
'--n-font-weight': fontWeight,
'--n-border-radius': borderRadius,
'--n-height': height,
'--n-padding-left': paddingLeft,
'--n-padding-right': paddingRight,
'--n-text-color': textColor,
'--n-caret-color': caretColor,
'--n-text-decoration-color': textDecorationColor,
'--n-border': border,
'--n-border-disabled': borderDisabled,
'--n-border-hover': borderHover,
'--n-border-focus': borderFocus,
'--n-placeholder-color': placeholderColor,
'--n-placeholder-color-disabled': placeholderColorDisabled,
'--n-icon-size': iconSize,
'--n-line-height-textarea': lineHeightTextarea,
'--n-color-disabled': colorDisabled,
'--n-color-focus': colorFocus,
'--n-text-color-disabled': textColorDisabled,
'--n-box-shadow-focus': boxShadowFocus,
'--n-loading-color': loadingColor,
// form warning
'--n-caret-color-warning': caretColorWarning,
'--n-color-focus-warning': colorFocusWarning,
'--n-box-shadow-focus-warning': boxShadowFocusWarning,
'--n-border-warning': borderWarning,
'--n-border-focus-warning': borderFocusWarning,
'--n-border-hover-warning': borderHoverWarning,
'--n-loading-color-warning': loadingColorWarning,
// form error
'--n-caret-color-error': caretColorError,
'--n-color-focus-error': colorFocusError,
'--n-box-shadow-focus-error': boxShadowFocusError,
'--n-border-error': borderError,
'--n-border-focus-error': borderFocusError,
'--n-border-hover-error': borderHoverError,
'--n-loading-color-error': loadingColorError,
// clear-button
'--n-clear-color': clearColor,
'--n-clear-size': clearSize,
'--n-clear-color-hover': clearColorHover,
'--n-clear-color-pressed': clearColorPressed,
'--n-icon-color': iconColor,
'--n-icon-color-hover': iconColorHover,
'--n-icon-color-pressed': iconColorPressed,
'--n-icon-color-disabled': iconColorDisabled,
'--n-suffix-text-color': suffixTextColor
};
});
const themeClassHandle = inlineThemeDisabled ? useThemeClass('input', runtime_core_esm_bundler_computed(() => {
const {
value: size
} = mergedSizeRef;
return size[0];
}), cssVarsRef, props) : undefined;
return Object.assign(Object.assign({}, exposedProps), {
// DOM ref
wrapperElRef,
inputElRef,
inputMirrorElRef,
inputEl2Ref,
textareaElRef,
textareaMirrorElRef,
textareaScrollbarInstRef,
// value
rtlEnabled: rtlEnabledRef,
uncontrolledValue: uncontrolledValueRef,
mergedValue: mergedValueRef,
passwordVisible: passwordVisibleRef,
mergedPlaceholder: mergedPlaceholderRef,
showPlaceholder1: showPlaceholder1Ref,
showPlaceholder2: showPlaceholder2Ref,
mergedFocus: mergedFocusRef,
isComposing: isComposingRef,
activated: activatedRef,
showClearButton,
mergedSize: mergedSizeRef,
mergedDisabled: mergedDisabledRef,
textDecorationStyle: textDecorationStyleRef,
mergedClsPrefix: mergedClsPrefixRef,
mergedBordered: mergedBorderedRef,
mergedShowPasswordOn: mergedShowPasswordOnRef,
placeholderStyle: placeholderStyleRef,
mergedStatus: mergedStatusRef,
textAreaScrollContainerWidth: textAreaScrollContainerWidthRef,
// methods
handleTextAreaScroll,
handleCompositionStart,
handleCompositionEnd,
handleInput,
handleInputBlur,
handleInputFocus,
handleWrapperBlur,
handleWrapperFocus,
handleMouseEnter,
handleMouseLeave,
handleMouseDown,
handleChange,
handleClick,
handleClear,
handlePasswordToggleClick,
handlePasswordToggleMousedown,
handleWrapperKeydown,
handleWrapperKeyup,
handleTextAreaMirrorResize,
getTextareaScrollContainer: () => {
return textareaElRef.value;
},
mergedTheme: themeRef,
cssVars: inlineThemeDisabled ? undefined : cssVarsRef,
themeClass: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass,
onRender: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender
});
},
render() {
var _a, _b;
const {
mergedClsPrefix,
mergedStatus,
themeClass,
type,
countGraphemes,
onRender
} = this;
const $slots = this.$slots;
onRender === null || onRender === void 0 ? void 0 : onRender();
return h("div", {
ref: "wrapperElRef",
class: [`${mergedClsPrefix}-input`, themeClass, mergedStatus && `${mergedClsPrefix}-input--${mergedStatus}-status`, {
[`${mergedClsPrefix}-input--rtl`]: this.rtlEnabled,
[`${mergedClsPrefix}-input--disabled`]: this.mergedDisabled,
[`${mergedClsPrefix}-input--textarea`]: type === 'textarea',
[`${mergedClsPrefix}-input--resizable`]: this.resizable && !this.autosize,
[`${mergedClsPrefix}-input--autosize`]: this.autosize,
[`${mergedClsPrefix}-input--round`]: this.round && !(type === 'textarea'),
[`${mergedClsPrefix}-input--pair`]: this.pair,
[`${mergedClsPrefix}-input--focus`]: this.mergedFocus,
[`${mergedClsPrefix}-input--stateful`]: this.stateful
}],
style: this.cssVars,
tabindex: !this.mergedDisabled && this.passivelyActivated && !this.activated ? 0 : undefined,
onFocus: this.handleWrapperFocus,
onBlur: this.handleWrapperBlur,
onClick: this.handleClick,
onMousedown: this.handleMouseDown,
onMouseenter: this.handleMouseEnter,
onMouseleave: this.handleMouseLeave,
onCompositionstart: this.handleCompositionStart,
onCompositionend: this.handleCompositionEnd,
onKeyup: this.handleWrapperKeyup,
onKeydown: this.handleWrapperKeydown
}, h("div", {
class: `${mergedClsPrefix}-input-wrapper`
}, resolveWrappedSlot($slots.prefix, children => children && h("div", {
class: `${mergedClsPrefix}-input__prefix`
}, children)), type === 'textarea' ? h(src_Scrollbar, {
ref: "textareaScrollbarInstRef",
class: `${mergedClsPrefix}-input__textarea`,
container: this.getTextareaScrollContainer,
triggerDisplayManually: true,
useUnifiedContainer: true,
internalHoistYRail: true
}, {
default: () => {
var _a, _b;
const {
textAreaScrollContainerWidth
} = this;
const scrollContainerWidthStyle = {
width: this.autosize && textAreaScrollContainerWidth && `${textAreaScrollContainerWidth}px`
};
return h(Fragment, null, h("textarea", Object.assign({}, this.inputProps, {
ref: "textareaElRef",
class: [`${mergedClsPrefix}-input__textarea-el`, (_a = this.inputProps) === null || _a === void 0 ? void 0 : _a.class],
autofocus: this.autofocus,
rows: Number(this.rows),
placeholder: this.placeholder,
value: this.mergedValue,
disabled: this.mergedDisabled,
maxlength: countGraphemes ? undefined : this.maxlength,
minlength: countGraphemes ? undefined : this.minlength,
readonly: this.readonly,
tabindex: this.passivelyActivated && !this.activated ? -1 : undefined,
style: [this.textDecorationStyle[0], (_b = this.inputProps) === null || _b === void 0 ? void 0 : _b.style, scrollContainerWidthStyle],
onBlur: this.handleInputBlur,
onFocus: e => {
this.handleInputFocus(e, 2);
},
onInput: this.handleInput,
onChange: this.handleChange,
onScroll: this.handleTextAreaScroll
})), this.showPlaceholder1 ? h("div", {
class: `${mergedClsPrefix}-input__placeholder`,
style: [this.placeholderStyle, scrollContainerWidthStyle],
key: "placeholder"
}, this.mergedPlaceholder[0]) : null, this.autosize ? h(VResizeObserver, {
onResize: this.handleTextAreaMirrorResize
}, {
default: () => h("div", {
ref: "textareaMirrorElRef",
class: `${mergedClsPrefix}-input__textarea-mirror`,
key: "mirror"
})
}) : null);
}
}) : h("div", {
class: `${mergedClsPrefix}-input__input`
}, h("input", Object.assign({
type: type === 'password' && this.mergedShowPasswordOn && this.passwordVisible ? 'text' : type
}, this.inputProps, {
ref: "inputElRef",
class: [`${mergedClsPrefix}-input__input-el`, (_a = this.inputProps) === null || _a === void 0 ? void 0 : _a.class],
style: [this.textDecorationStyle[0], (_b = this.inputProps) === null || _b === void 0 ? void 0 : _b.style],
tabindex: this.passivelyActivated && !this.activated ? -1 : undefined,
placeholder: this.mergedPlaceholder[0],
disabled: this.mergedDisabled,
maxlength: countGraphemes ? undefined : this.maxlength,
minlength: countGraphemes ? undefined : this.minlength,
value: Array.isArray(this.mergedValue) ? this.mergedValue[0] : this.mergedValue,
readonly: this.readonly,
autofocus: this.autofocus,
size: this.attrSize,
onBlur: this.handleInputBlur,
onFocus: e => {
this.handleInputFocus(e, 0);
},
onInput: e => {
this.handleInput(e, 0);
},
onChange: e => {
this.handleChange(e, 0);
}
})), this.showPlaceholder1 ? h("div", {
class: `${mergedClsPrefix}-input__placeholder`
}, h("span", null, this.mergedPlaceholder[0])) : null, this.autosize ? h("div", {
class: `${mergedClsPrefix}-input__input-mirror`,
key: "mirror",
ref: "inputMirrorElRef"
}, "\u00A0") : null), !this.pair && resolveWrappedSlot($slots.suffix, children => {
return children || this.clearable || this.showCount || this.mergedShowPasswordOn || this.loading !== undefined ? h("div", {
class: `${mergedClsPrefix}-input__suffix`
}, [resolveWrappedSlot($slots['clear-icon-placeholder'], children => {
return (this.clearable || children) && h(src_Clear, {
clsPrefix: mergedClsPrefix,
show: this.showClearButton,
onClear: this.handleClear
}, {
placeholder: () => children,
icon: () => {
var _a, _b;
return (_b = (_a = this.$slots)['clear-icon']) === null || _b === void 0 ? void 0 : _b.call(_a);
}
});
}), !this.internalLoadingBeforeSuffix ? children : null, this.loading !== undefined ? h(Suffix, {
clsPrefix: mergedClsPrefix,
loading: this.loading,
showArrow: false,
showClear: false,
style: this.cssVars
}) : null, this.internalLoadingBeforeSuffix ? children : null, this.showCount && this.type !== 'textarea' ? h(WordCount, null, {
default: props => {
var _a;
const {
renderCount
} = this;
if (renderCount) {
return renderCount(props);
}
return (_a = $slots.count) === null || _a === void 0 ? void 0 : _a.call($slots, props);
}
}) : null, this.mergedShowPasswordOn && this.type === 'password' ? h("div", {
class: `${mergedClsPrefix}-input__eye`,
onMousedown: this.handlePasswordToggleMousedown,
onClick: this.handlePasswordToggleClick
}, this.passwordVisible ? resolveSlot($slots['password-visible-icon'], () => [h(Icon, {
clsPrefix: mergedClsPrefix
}, {
default: () => h(Eye, null)
})]) : resolveSlot($slots['password-invisible-icon'], () => [h(Icon, {
clsPrefix: mergedClsPrefix
}, {
default: () => h(EyeOff, null)
})])) : null]) : null;
})), this.pair ? h("span", {
class: `${mergedClsPrefix}-input__separator`
}, resolveSlot($slots.separator, () => [this.separator])) : null, this.pair ? h("div", {
class: `${mergedClsPrefix}-input-wrapper`
}, h("div", {
class: `${mergedClsPrefix}-input__input`
}, h("input", {
ref: "inputEl2Ref",
type: this.type,
class: `${mergedClsPrefix}-input__input-el`,
tabindex: this.passivelyActivated && !this.activated ? -1 : undefined,
placeholder: this.mergedPlaceholder[1],
disabled: this.mergedDisabled,
maxlength: countGraphemes ? undefined : this.maxlength,
minlength: countGraphemes ? undefined : this.minlength,
value: Array.isArray(this.mergedValue) ? this.mergedValue[1] : undefined,
readonly: this.readonly,
style: this.textDecorationStyle[1],
onBlur: this.handleInputBlur,
onFocus: e => {
this.handleInputFocus(e, 1);
},
onInput: e => {
this.handleInput(e, 1);
},
onChange: e => {
this.handleChange(e, 1);
}
}), this.showPlaceholder2 ? h("div", {
class: `${mergedClsPrefix}-input__placeholder`
}, h("span", null, this.mergedPlaceholder[1])) : null), resolveWrappedSlot($slots.suffix, children => {
return (this.clearable || children) && h("div", {
class: `${mergedClsPrefix}-input__suffix`
}, [this.clearable && h(src_Clear, {
clsPrefix: mergedClsPrefix,
show: this.showClearButton,
onClear: this.handleClear
}, {
icon: () => {
var _a;
return (_a = $slots['clear-icon']) === null || _a === void 0 ? void 0 : _a.call($slots);
},
placeholder: () => {
var _a;
return (_a = $slots['clear-icon-placeholder']) === null || _a === void 0 ? void 0 : _a.call($slots);
}
}), children]);
})) : null, this.mergedBordered ? h("div", {
class: `${mergedClsPrefix}-input__border`
}) : null, this.mergedBordered ? h("div", {
class: `${mergedClsPrefix}-input__state-border`
}) : null, this.showCount && type === 'textarea' ? h(WordCount, null, {
default: props => {
var _a;
const {
renderCount
} = this;
if (renderCount) {
return renderCount(props);
}
return (_a = $slots.count) === null || _a === void 0 ? void 0 : _a.call($slots, props);
}
}) : null);
}
}));
;// ./node_modules/naive-ui/es/radio/styles/_common.mjs
/* harmony default export */ var radio_styles_common = ({
radioSizeSmall: '14px',
radioSizeMedium: '16px',
radioSizeLarge: '18px',
labelPadding: '0 8px',
labelFontWeight: '400'
});
;// ./node_modules/naive-ui/es/radio/styles/light.mjs
function radio_styles_light_self(vars) {
const {
borderColor,
primaryColor,
baseColor,
textColorDisabled,
inputColorDisabled,
textColor2,
opacityDisabled,
borderRadius,
fontSizeSmall,
fontSizeMedium,
fontSizeLarge,
heightSmall,
heightMedium,
heightLarge,
lineHeight
} = vars;
return Object.assign(Object.assign({}, radio_styles_common), {
labelLineHeight: lineHeight,
buttonHeightSmall: heightSmall,
buttonHeightMedium: heightMedium,
buttonHeightLarge: heightLarge,
fontSizeSmall,
fontSizeMedium,
fontSizeLarge,
boxShadow: `inset 0 0 0 1px ${borderColor}`,
boxShadowActive: `inset 0 0 0 1px ${primaryColor}`,
boxShadowFocus: `inset 0 0 0 1px ${primaryColor}, 0 0 0 2px ${changeColor(primaryColor, {
alpha: 0.2
})}`,
boxShadowHover: `inset 0 0 0 1px ${primaryColor}`,
boxShadowDisabled: `inset 0 0 0 1px ${borderColor}`,
color: baseColor,
colorDisabled: inputColorDisabled,
colorActive: '#0000',
textColor: textColor2,
textColorDisabled,
dotColorActive: primaryColor,
dotColorDisabled: borderColor,
buttonBorderColor: borderColor,
buttonBorderColorActive: primaryColor,
buttonBorderColorHover: borderColor,
buttonColor: baseColor,
buttonColorActive: baseColor,
buttonTextColor: textColor2,
buttonTextColorActive: primaryColor,
buttonTextColorHover: primaryColor,
opacityDisabled,
buttonBoxShadowFocus: `inset 0 0 0 1px ${primaryColor}, 0 0 0 2px ${changeColor(primaryColor, {
alpha: 0.3
})}`,
buttonBoxShadowHover: 'inset 0 0 0 1px #0000',
buttonBoxShadow: 'inset 0 0 0 1px #0000',
buttonBorderRadius: borderRadius
});
}
const radioLight = {
name: 'Radio',
common: light,
self: radio_styles_light_self
};
/* harmony default export */ var radio_styles_light = (radioLight);
;// ./node_modules/naive-ui/es/radio/src/styles/radio.cssr.mjs
// vars:
// --n-bezier
// --n-box-shadow
// --n-box-shadow-active
// --n-box-shadow-disabled
// --n-box-shadow-focus
// --n-box-shadow-hover
// --n-color
// --n-color-disabled
// --n-dot-color-active
// --n-dot-color-disabled
// --n-font-size
// --n-radio-size
// --n-text-color
// --n-text-color-disabled
// --n-label-padding
// --n-label-line-height
// --n-color-active
/* harmony default export */ var radio_cssr = (cB('radio', `
line-height: var(--n-label-line-height);
outline: none;
position: relative;
user-select: none;
-webkit-user-select: none;
display: inline-flex;
align-items: flex-start;
flex-wrap: nowrap;
font-size: var(--n-font-size);
word-break: break-word;
`, [cM('checked', [cE('dot', `
background-color: var(--n-color-active);
`)]), cE('dot-wrapper', `
position: relative;
flex-shrink: 0;
flex-grow: 0;
width: var(--n-radio-size);
`), cB('radio-input', `
position: absolute;
border: 0;
border-radius: inherit;
left: 0;
right: 0;
top: 0;
bottom: 0;
opacity: 0;
z-index: 1;
cursor: pointer;
`), cE('dot', `
position: absolute;
top: 50%;
left: 0;
transform: translateY(-50%);
height: var(--n-radio-size);
width: var(--n-radio-size);
background: var(--n-color);
box-shadow: var(--n-box-shadow);
border-radius: 50%;
transition:
background-color .3s var(--n-bezier),
box-shadow .3s var(--n-bezier);
`, [cssr_c('&::before', `
content: "";
opacity: 0;
position: absolute;
left: 4px;
top: 4px;
height: calc(100% - 8px);
width: calc(100% - 8px);
border-radius: 50%;
transform: scale(.8);
background: var(--n-dot-color-active);
transition:
opacity .3s var(--n-bezier),
background-color .3s var(--n-bezier),
transform .3s var(--n-bezier);
`), cM('checked', {
boxShadow: 'var(--n-box-shadow-active)'
}, [cssr_c('&::before', `
opacity: 1;
transform: scale(1);
`)])]), cE('label', `
color: var(--n-text-color);
padding: var(--n-label-padding);
font-weight: var(--n-label-font-weight);
display: inline-block;
transition: color .3s var(--n-bezier);
`), cNotM('disabled', `
cursor: pointer;
`, [cssr_c('&:hover', [cE('dot', {
boxShadow: 'var(--n-box-shadow-hover)'
})]), cM('focus', [cssr_c('&:not(:active)', [cE('dot', {
boxShadow: 'var(--n-box-shadow-focus)'
})])])]), cM('disabled', `
cursor: not-allowed;
`, [cE('dot', {
boxShadow: 'var(--n-box-shadow-disabled)',
backgroundColor: 'var(--n-color-disabled)'
}, [cssr_c('&::before', {
backgroundColor: 'var(--n-dot-color-disabled)'
}), cM('checked', `
opacity: 1;
`)]), cE('label', {
color: 'var(--n-text-color-disabled)'
}), cB('radio-input', `
cursor: not-allowed;
`)])]));
;// ./node_modules/naive-ui/es/radio/src/use-radio.mjs
const radioBaseProps = {
name: String,
value: {
type: [String, Number, Boolean],
default: 'on'
},
checked: {
type: Boolean,
default: undefined
},
defaultChecked: Boolean,
disabled: {
type: Boolean,
default: undefined
},
label: String,
size: String,
onUpdateChecked: [Function, Array],
'onUpdate:checked': [Function, Array],
// deprecated
checkedValue: {
type: Boolean,
default: undefined
}
};
const radioGroupInjectionKey = createInjectionKey('n-radio-group');
function use_radio_setup(props) {
if (false) {}
const NRadioGroup = runtime_core_esm_bundler_inject(radioGroupInjectionKey, null);
const formItem = useFormItem(props, {
mergedSize(NFormItem) {
const {
size
} = props;
if (size !== undefined) return size;
if (NRadioGroup) {
const {
mergedSizeRef: {
value: mergedSize
}
} = NRadioGroup;
if (mergedSize !== undefined) {
return mergedSize;
}
}
if (NFormItem) {
return NFormItem.mergedSize.value;
}
return 'medium';
},
mergedDisabled(NFormItem) {
if (props.disabled) return true;
if (NRadioGroup === null || NRadioGroup === void 0 ? void 0 : NRadioGroup.disabledRef.value) return true;
if (NFormItem === null || NFormItem === void 0 ? void 0 : NFormItem.disabled.value) return true;
return false;
}
});
const {
mergedSizeRef,
mergedDisabledRef
} = formItem;
const inputRef = ref(null);
const labelRef = ref(null);
const uncontrolledCheckedRef = ref(props.defaultChecked);
const controlledCheckedRef = toRef(props, 'checked');
const mergedCheckedRef = useMergedState(controlledCheckedRef, uncontrolledCheckedRef);
const renderSafeCheckedRef = use_memo(() => {
if (NRadioGroup) return NRadioGroup.valueRef.value === props.value;
return mergedCheckedRef.value;
});
const mergedNameRef = use_memo(() => {
const {
name
} = props;
if (name !== undefined) return name;
if (NRadioGroup) return NRadioGroup.nameRef.value;
});
const focusRef = ref(false);
function doUpdateChecked() {
if (NRadioGroup) {
const {
doUpdateValue
} = NRadioGroup;
const {
value
} = props;
call(doUpdateValue, value);
} else {
const {
onUpdateChecked,
'onUpdate:checked': _onUpdateChecked
} = props;
const {
nTriggerFormInput,
nTriggerFormChange
} = formItem;
if (onUpdateChecked) call(onUpdateChecked, true);
if (_onUpdateChecked) call(_onUpdateChecked, true);
nTriggerFormInput();
nTriggerFormChange();
uncontrolledCheckedRef.value = true;
}
}
function toggle() {
if (mergedDisabledRef.value) return;
if (!renderSafeCheckedRef.value) {
doUpdateChecked();
}
}
function handleRadioInputChange() {
toggle();
// Restore element check prop's value to current state, since if doesn't
// reflect current VNode. If not, bug will happens in component with element
// that has internal state such as <input />.
if (inputRef.value) {
inputRef.value.checked = renderSafeCheckedRef.value;
}
}
function handleRadioInputBlur() {
focusRef.value = false;
}
function handleRadioInputFocus() {
focusRef.value = true;
}
return {
mergedClsPrefix: NRadioGroup ? NRadioGroup.mergedClsPrefixRef : useConfig(props).mergedClsPrefixRef,
inputRef,
labelRef,
mergedName: mergedNameRef,
mergedDisabled: mergedDisabledRef,
renderSafeChecked: renderSafeCheckedRef,
focus: focusRef,
mergedSize: mergedSizeRef,
handleRadioInputChange,
handleRadioInputBlur,
handleRadioInputFocus
};
}
;// ./node_modules/naive-ui/es/radio/src/Radio.mjs
const radioProps = Object.assign(Object.assign({}, use_theme.props), radioBaseProps);
/* harmony default export */ var Radio = (defineComponent({
name: 'Radio',
props: radioProps,
setup(props) {
const radio = use_radio_setup(props);
const themeRef = use_theme('Radio', '-radio', radio_cssr, radio_styles_light, props, radio.mergedClsPrefix);
const cssVarsRef = runtime_core_esm_bundler_computed(() => {
const {
mergedSize: {
value: size
}
} = radio;
const {
common: {
cubicBezierEaseInOut
},
self: {
boxShadow,
boxShadowActive,
boxShadowDisabled,
boxShadowFocus,
boxShadowHover,
color,
colorDisabled,
colorActive,
textColor,
textColorDisabled,
dotColorActive,
dotColorDisabled,
labelPadding,
labelLineHeight,
labelFontWeight,
[createKey('fontSize', size)]: fontSize,
[createKey('radioSize', size)]: radioSize
}
} = themeRef.value;
return {
'--n-bezier': cubicBezierEaseInOut,
'--n-label-line-height': labelLineHeight,
'--n-label-font-weight': labelFontWeight,
'--n-box-shadow': boxShadow,
'--n-box-shadow-active': boxShadowActive,
'--n-box-shadow-disabled': boxShadowDisabled,
'--n-box-shadow-focus': boxShadowFocus,
'--n-box-shadow-hover': boxShadowHover,
'--n-color': color,
'--n-color-active': colorActive,
'--n-color-disabled': colorDisabled,
'--n-dot-color-active': dotColorActive,
'--n-dot-color-disabled': dotColorDisabled,
'--n-font-size': fontSize,
'--n-radio-size': radioSize,
'--n-text-color': textColor,
'--n-text-color-disabled': textColorDisabled,
'--n-label-padding': labelPadding
};
});
const {
inlineThemeDisabled,
mergedClsPrefixRef,
mergedRtlRef
} = useConfig(props);
const rtlEnabledRef = useRtl('Radio', mergedRtlRef, mergedClsPrefixRef);
const themeClassHandle = inlineThemeDisabled ? useThemeClass('radio', runtime_core_esm_bundler_computed(() => radio.mergedSize.value[0]), cssVarsRef, props) : undefined;
return Object.assign(radio, {
rtlEnabled: rtlEnabledRef,
cssVars: inlineThemeDisabled ? undefined : cssVarsRef,
themeClass: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass,
onRender: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender
});
},
render() {
const {
$slots,
mergedClsPrefix,
onRender,
label
} = this;
onRender === null || onRender === void 0 ? void 0 : onRender();
return h("label", {
class: [`${mergedClsPrefix}-radio`, this.themeClass, this.rtlEnabled && `${mergedClsPrefix}-radio--rtl`, this.mergedDisabled && `${mergedClsPrefix}-radio--disabled`, this.renderSafeChecked && `${mergedClsPrefix}-radio--checked`, this.focus && `${mergedClsPrefix}-radio--focus`],
style: this.cssVars
}, h("input", {
ref: "inputRef",
type: "radio",
class: `${mergedClsPrefix}-radio-input`,
value: this.value,
name: this.mergedName,
checked: this.renderSafeChecked,
disabled: this.mergedDisabled,
onChange: this.handleRadioInputChange,
onFocus: this.handleRadioInputFocus,
onBlur: this.handleRadioInputBlur
}), h("div", {
class: `${mergedClsPrefix}-radio__dot-wrapper`
}, "\u00A0", h("div", {
class: [`${mergedClsPrefix}-radio__dot`, this.renderSafeChecked && `${mergedClsPrefix}-radio__dot--checked`]
})), resolveWrappedSlot($slots.default, children => {
if (!children && !label) return null;
return h("div", {
ref: "labelRef",
class: `${mergedClsPrefix}-radio__label`
}, children || label);
}));
}
}));
;// ./node_modules/naive-ui/es/radio/src/styles/radio-group.cssr.mjs
// vars:
// --n-bezier
// --n-button-border-color
// --n-button-border-color-active
// --n-height
// --n-opacity-disabled
// --n-font-size
/* harmony default export */ var radio_group_cssr = (cB('radio-group', `
display: inline-block;
font-size: var(--n-font-size);
`, [cE('splitor', `
display: inline-block;
vertical-align: bottom;
width: 1px;
transition:
background-color .3s var(--n-bezier),
opacity .3s var(--n-bezier);
background: var(--n-button-border-color);
`, [cM('checked', {
backgroundColor: 'var(--n-button-border-color-active)'
}), cM('disabled', {
opacity: 'var(--n-opacity-disabled)'
})]), cM('button-group', `
white-space: nowrap;
height: var(--n-height);
line-height: var(--n-height);
`, [cB('radio-button', {
height: 'var(--n-height)',
lineHeight: 'var(--n-height)'
}), cE('splitor', {
height: 'var(--n-height)'
})]), cB('radio-button', `
vertical-align: bottom;
outline: none;
position: relative;
user-select: none;
-webkit-user-select: none;
display: inline-block;
box-sizing: border-box;
padding-left: 14px;
padding-right: 14px;
white-space: nowrap;
transition:
background-color .3s var(--n-bezier),
opacity .3s var(--n-bezier),
border-color .3s var(--n-bezier),
color .3s var(--n-bezier);
background: var(--n-button-color);
color: var(--n-button-text-color);
border-top: 1px solid var(--n-button-border-color);
border-bottom: 1px solid var(--n-button-border-color);
`, [cB('radio-input', `
pointer-events: none;
position: absolute;
border: 0;
border-radius: inherit;
left: 0;
right: 0;
top: 0;
bottom: 0;
opacity: 0;
z-index: 1;
`), cE('state-border', `
z-index: 1;
pointer-events: none;
position: absolute;
box-shadow: var(--n-button-box-shadow);
transition: box-shadow .3s var(--n-bezier);
left: -1px;
bottom: -1px;
right: -1px;
top: -1px;
`), cssr_c('&:first-child', `
border-top-left-radius: var(--n-button-border-radius);
border-bottom-left-radius: var(--n-button-border-radius);
border-left: 1px solid var(--n-button-border-color);
`, [cE('state-border', `
border-top-left-radius: var(--n-button-border-radius);
border-bottom-left-radius: var(--n-button-border-radius);
`)]), cssr_c('&:last-child', `
border-top-right-radius: var(--n-button-border-radius);
border-bottom-right-radius: var(--n-button-border-radius);
border-right: 1px solid var(--n-button-border-color);
`, [cE('state-border', `
border-top-right-radius: var(--n-button-border-radius);
border-bottom-right-radius: var(--n-button-border-radius);
`)]), cNotM('disabled', `
cursor: pointer;
`, [cssr_c('&:hover', [cE('state-border', `
transition: box-shadow .3s var(--n-bezier);
box-shadow: var(--n-button-box-shadow-hover);
`), cNotM('checked', {
color: 'var(--n-button-text-color-hover)'
})]), cM('focus', [cssr_c('&:not(:active)', [cE('state-border', {
boxShadow: 'var(--n-button-box-shadow-focus)'
})])])]), cM('checked', `
background: var(--n-button-color-active);
color: var(--n-button-text-color-active);
border-color: var(--n-button-border-color-active);
`), cM('disabled', `
cursor: not-allowed;
opacity: var(--n-opacity-disabled);
`)])]));
;// ./node_modules/naive-ui/es/radio/src/RadioGroup.mjs
function mapSlot(defaultSlot, value, clsPrefix) {
var _a;
const children = [];
let isButtonGroup = false;
for (let i = 0; i < defaultSlot.length; ++i) {
const wrappedInstance = defaultSlot[i];
const name = (_a = wrappedInstance.type) === null || _a === void 0 ? void 0 : _a.name;
if (name === 'RadioButton') {
isButtonGroup = true;
}
if (false) {}
const instanceProps = wrappedInstance.props;
if (name !== 'RadioButton') {
children.push(wrappedInstance);
continue;
}
if (i === 0) {
children.push(wrappedInstance);
} else {
const lastInstanceProps = children[children.length - 1].props;
const lastInstanceChecked = value === lastInstanceProps.value;
const lastInstanceDisabled = lastInstanceProps.disabled;
const currentInstanceChecked = value === instanceProps.value;
const currentInstanceDisabled = instanceProps.disabled;
/**
* Priority of button splitor:
* !disabled checked >
* disabled checked >
* !disabled !checked >
* disabled !checked
*/
const lastInstancePriority = (lastInstanceChecked ? 2 : 0) + (!lastInstanceDisabled ? 1 : 0);
const currentInstancePriority = (currentInstanceChecked ? 2 : 0) + (!currentInstanceDisabled ? 1 : 0);
const lastInstanceClass = {
[`${clsPrefix}-radio-group__splitor--disabled`]: lastInstanceDisabled,
[`${clsPrefix}-radio-group__splitor--checked`]: lastInstanceChecked
};
const currentInstanceClass = {
[`${clsPrefix}-radio-group__splitor--disabled`]: currentInstanceDisabled,
[`${clsPrefix}-radio-group__splitor--checked`]: currentInstanceChecked
};
const splitorClass = lastInstancePriority < currentInstancePriority ? currentInstanceClass : lastInstanceClass;
children.push(h("div", {
class: [`${clsPrefix}-radio-group__splitor`, splitorClass]
}), wrappedInstance);
}
}
return {
children,
isButtonGroup
};
}
const radioGroupProps = Object.assign(Object.assign({}, use_theme.props), {
name: String,
value: [String, Number, Boolean],
defaultValue: {
type: [String, Number, Boolean],
default: null
},
size: String,
disabled: {
type: Boolean,
default: undefined
},
'onUpdate:value': [Function, Array],
onUpdateValue: [Function, Array]
});
/* harmony default export */ var RadioGroup = (defineComponent({
name: 'RadioGroup',
props: radioGroupProps,
setup(props) {
const selfElRef = ref(null);
const {
mergedSizeRef,
mergedDisabledRef,
nTriggerFormChange,
nTriggerFormInput,
nTriggerFormBlur,
nTriggerFormFocus
} = useFormItem(props);
const {
mergedClsPrefixRef,
inlineThemeDisabled,
mergedRtlRef
} = useConfig(props);
const themeRef = use_theme('Radio', '-radio-group', radio_group_cssr, radio_styles_light, props, mergedClsPrefixRef);
const uncontrolledValueRef = ref(props.defaultValue);
const controlledValueRef = toRef(props, 'value');
const mergedValueRef = useMergedState(controlledValueRef, uncontrolledValueRef);
function doUpdateValue(value) {
const {
onUpdateValue,
'onUpdate:value': _onUpdateValue
} = props;
if (onUpdateValue) {
call(onUpdateValue, value);
}
if (_onUpdateValue) {
call(_onUpdateValue, value);
}
uncontrolledValueRef.value = value;
nTriggerFormChange();
nTriggerFormInput();
}
function handleFocusin(e) {
const {
value: selfEl
} = selfElRef;
if (!selfEl) return;
if (selfEl.contains(e.relatedTarget)) return;
nTriggerFormFocus();
}
function handleFocusout(e) {
const {
value: selfEl
} = selfElRef;
if (!selfEl) return;
if (selfEl.contains(e.relatedTarget)) return;
nTriggerFormBlur();
}
provide(radioGroupInjectionKey, {
mergedClsPrefixRef,
nameRef: toRef(props, 'name'),
valueRef: mergedValueRef,
disabledRef: mergedDisabledRef,
mergedSizeRef,
doUpdateValue
});
const rtlEnabledRef = useRtl('Radio', mergedRtlRef, mergedClsPrefixRef);
const cssVarsRef = runtime_core_esm_bundler_computed(() => {
const {
value: size
} = mergedSizeRef;
const {
common: {
cubicBezierEaseInOut
},
self: {
buttonBorderColor,
buttonBorderColorActive,
buttonBorderRadius,
buttonBoxShadow,
buttonBoxShadowFocus,
buttonBoxShadowHover,
buttonColor,
buttonColorActive,
buttonTextColor,
buttonTextColorActive,
buttonTextColorHover,
opacityDisabled,
[createKey('buttonHeight', size)]: height,
[createKey('fontSize', size)]: fontSize
}
} = themeRef.value;
return {
'--n-font-size': fontSize,
'--n-bezier': cubicBezierEaseInOut,
'--n-button-border-color': buttonBorderColor,
'--n-button-border-color-active': buttonBorderColorActive,
'--n-button-border-radius': buttonBorderRadius,
'--n-button-box-shadow': buttonBoxShadow,
'--n-button-box-shadow-focus': buttonBoxShadowFocus,
'--n-button-box-shadow-hover': buttonBoxShadowHover,
'--n-button-color': buttonColor,
'--n-button-color-active': buttonColorActive,
'--n-button-text-color': buttonTextColor,
'--n-button-text-color-hover': buttonTextColorHover,
'--n-button-text-color-active': buttonTextColorActive,
'--n-height': height,
'--n-opacity-disabled': opacityDisabled
};
});
const themeClassHandle = inlineThemeDisabled ? useThemeClass('radio-group', runtime_core_esm_bundler_computed(() => mergedSizeRef.value[0]), cssVarsRef, props) : undefined;
return {
selfElRef,
rtlEnabled: rtlEnabledRef,
mergedClsPrefix: mergedClsPrefixRef,
mergedValue: mergedValueRef,
handleFocusout,
handleFocusin,
cssVars: inlineThemeDisabled ? undefined : cssVarsRef,
themeClass: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass,
onRender: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender
};
},
render() {
var _a;
const {
mergedValue,
mergedClsPrefix,
handleFocusin,
handleFocusout
} = this;
const {
children,
isButtonGroup
} = mapSlot(flatten_flatten(getSlot(this)), mergedValue, mergedClsPrefix);
(_a = this.onRender) === null || _a === void 0 ? void 0 : _a.call(this);
return h("div", {
onFocusin: handleFocusin,
onFocusout: handleFocusout,
ref: "selfElRef",
class: [`${mergedClsPrefix}-radio-group`, this.rtlEnabled && `${mergedClsPrefix}-radio-group--rtl`, this.themeClass, isButtonGroup && `${mergedClsPrefix}-radio-group--button-group`],
style: this.cssVars
}, children);
}
}));
;// ./node_modules/naive-ui/es/_internal/icons/Success.mjs
/* harmony default export */ var Success = (replaceable('success', () => h("svg", {
viewBox: "0 0 48 48",
version: "1.1",
xmlns: "http://www.w3.org/2000/svg"
}, h("g", {
stroke: "none",
"stroke-width": "1",
"fill-rule": "evenodd"
}, h("g", {
"fill-rule": "nonzero"
}, h("path", {
d: "M24,4 C35.045695,4 44,12.954305 44,24 C44,35.045695 35.045695,44 24,44 C12.954305,44 4,35.045695 4,24 C4,12.954305 12.954305,4 24,4 Z M32.6338835,17.6161165 C32.1782718,17.1605048 31.4584514,17.1301307 30.9676119,17.5249942 L30.8661165,17.6161165 L20.75,27.732233 L17.1338835,24.1161165 C16.6457281,23.6279612 15.8542719,23.6279612 15.3661165,24.1161165 C14.9105048,24.5717282 14.8801307,25.2915486 15.2749942,25.7823881 L15.3661165,25.8838835 L19.8661165,30.3838835 C20.3217282,30.8394952 21.0415486,30.8698693 21.5323881,30.4750058 L21.6338835,30.3838835 L32.6338835,19.3838835 C33.1220388,18.8957281 33.1220388,18.1042719 32.6338835,17.6161165 Z"
}))))));
;// ./node_modules/naive-ui/es/_internal/icons/Info.mjs
/* harmony default export */ var Info = (replaceable('info', () => h("svg", {
viewBox: "0 0 28 28",
version: "1.1",
xmlns: "http://www.w3.org/2000/svg"
}, h("g", {
stroke: "none",
"stroke-width": "1",
"fill-rule": "evenodd"
}, h("g", {
"fill-rule": "nonzero"
}, h("path", {
d: "M14,2 C20.6274,2 26,7.37258 26,14 C26,20.6274 20.6274,26 14,26 C7.37258,26 2,20.6274 2,14 C2,7.37258 7.37258,2 14,2 Z M14,11 C13.4477,11 13,11.4477 13,12 L13,12 L13,20 C13,20.5523 13.4477,21 14,21 C14.5523,21 15,20.5523 15,20 L15,20 L15,12 C15,11.4477 14.5523,11 14,11 Z M14,6.75 C13.3096,6.75 12.75,7.30964 12.75,8 C12.75,8.69036 13.3096,9.25 14,9.25 C14.6904,9.25 15.25,8.69036 15.25,8 C15.25,7.30964 14.6904,6.75 14,6.75 Z"
}))))));
;// ./node_modules/naive-ui/es/_internal/icons/Warning.mjs
/* harmony default export */ var Warning = (replaceable('warning', () => h("svg", {
viewBox: "0 0 24 24",
version: "1.1",
xmlns: "http://www.w3.org/2000/svg"
}, h("g", {
stroke: "none",
"stroke-width": "1",
"fill-rule": "evenodd"
}, h("g", {
"fill-rule": "nonzero"
}, h("path", {
d: "M12,2 C17.523,2 22,6.478 22,12 C22,17.522 17.523,22 12,22 C6.477,22 2,17.522 2,12 C2,6.478 6.477,2 12,2 Z M12.0018002,15.0037242 C11.450254,15.0037242 11.0031376,15.4508407 11.0031376,16.0023869 C11.0031376,16.553933 11.450254,17.0010495 12.0018002,17.0010495 C12.5533463,17.0010495 13.0004628,16.553933 13.0004628,16.0023869 C13.0004628,15.4508407 12.5533463,15.0037242 12.0018002,15.0037242 Z M11.99964,7 C11.4868042,7.00018474 11.0642719,7.38637706 11.0066858,7.8837365 L11,8.00036004 L11.0018003,13.0012393 L11.00857,13.117858 C11.0665141,13.6151758 11.4893244,14.0010638 12.0021602,14.0008793 C12.514996,14.0006946 12.9375283,13.6145023 12.9951144,13.1171428 L13.0018002,13.0005193 L13,7.99964009 L12.9932303,7.8830214 C12.9352861,7.38570354 12.5124758,6.99981552 11.99964,7 Z"
}))))));
;// ./node_modules/naive-ui/es/_internal/icons/Error.mjs
/* harmony default export */ var icons_Error = (replaceable('error', () => h("svg", {
viewBox: "0 0 48 48",
version: "1.1",
xmlns: "http://www.w3.org/2000/svg"
}, h("g", {
stroke: "none",
"stroke-width": "1",
"fill-rule": "evenodd"
}, h("g", {
"fill-rule": "nonzero"
}, h("path", {
d: "M24,4 C35.045695,4 44,12.954305 44,24 C44,35.045695 35.045695,44 24,44 C12.954305,44 4,35.045695 4,24 C4,12.954305 12.954305,4 24,4 Z M17.8838835,16.1161165 L17.7823881,16.0249942 C17.3266086,15.6583353 16.6733914,15.6583353 16.2176119,16.0249942 L16.1161165,16.1161165 L16.0249942,16.2176119 C15.6583353,16.6733914 15.6583353,17.3266086 16.0249942,17.7823881 L16.1161165,17.8838835 L22.233,24 L16.1161165,30.1161165 L16.0249942,30.2176119 C15.6583353,30.6733914 15.6583353,31.3266086 16.0249942,31.7823881 L16.1161165,31.8838835 L16.2176119,31.9750058 C16.6733914,32.3416647 17.3266086,32.3416647 17.7823881,31.9750058 L17.8838835,31.8838835 L24,25.767 L30.1161165,31.8838835 L30.2176119,31.9750058 C30.6733914,32.3416647 31.3266086,32.3416647 31.7823881,31.9750058 L31.8838835,31.8838835 L31.9750058,31.7823881 C32.3416647,31.3266086 32.3416647,30.6733914 31.9750058,30.2176119 L31.8838835,30.1161165 L25.767,24 L31.8838835,17.8838835 L31.9750058,17.7823881 C32.3416647,17.3266086 32.3416647,16.6733914 31.9750058,16.2176119 L31.8838835,16.1161165 L31.7823881,16.0249942 C31.3266086,15.6583353 30.6733914,15.6583353 30.2176119,16.0249942 L30.1161165,16.1161165 L24,22.233 L17.8838835,16.1161165 L17.7823881,16.0249942 L17.8838835,16.1161165 Z"
}))))));
;// ./node_modules/naive-ui/es/alert/styles/_common.mjs
/* harmony default export */ var alert_styles_common = ({
iconMargin: '11px 8px 0 12px',
iconMarginRtl: '11px 12px 0 8px',
iconSize: '24px',
closeIconSize: '16px',
closeSize: '20px',
closeMargin: '13px 14px 0 0',
closeMarginRtl: '13px 0 0 14px',
padding: '13px'
});
;// ./node_modules/naive-ui/es/alert/styles/light.mjs
function alert_styles_light_self(vars) {
const {
lineHeight,
borderRadius,
fontWeightStrong,
baseColor,
dividerColor,
actionColor,
textColor1,
textColor2,
closeColorHover,
closeColorPressed,
closeIconColor,
closeIconColorHover,
closeIconColorPressed,
infoColor,
successColor,
warningColor,
errorColor,
fontSize
} = vars;
return Object.assign(Object.assign({}, alert_styles_common), {
fontSize,
lineHeight,
titleFontWeight: fontWeightStrong,
borderRadius,
border: `1px solid ${dividerColor}`,
color: actionColor,
titleTextColor: textColor1,
iconColor: textColor2,
contentTextColor: textColor2,
closeBorderRadius: borderRadius,
closeColorHover,
closeColorPressed,
closeIconColor,
closeIconColorHover,
closeIconColorPressed,
borderInfo: `1px solid ${composite(baseColor, changeColor(infoColor, {
alpha: 0.25
}))}`,
colorInfo: composite(baseColor, changeColor(infoColor, {
alpha: 0.08
})),
titleTextColorInfo: textColor1,
iconColorInfo: infoColor,
contentTextColorInfo: textColor2,
closeColorHoverInfo: closeColorHover,
closeColorPressedInfo: closeColorPressed,
closeIconColorInfo: closeIconColor,
closeIconColorHoverInfo: closeIconColorHover,
closeIconColorPressedInfo: closeIconColorPressed,
borderSuccess: `1px solid ${composite(baseColor, changeColor(successColor, {
alpha: 0.25
}))}`,
colorSuccess: composite(baseColor, changeColor(successColor, {
alpha: 0.08
})),
titleTextColorSuccess: textColor1,
iconColorSuccess: successColor,
contentTextColorSuccess: textColor2,
closeColorHoverSuccess: closeColorHover,
closeColorPressedSuccess: closeColorPressed,
closeIconColorSuccess: closeIconColor,
closeIconColorHoverSuccess: closeIconColorHover,
closeIconColorPressedSuccess: closeIconColorPressed,
borderWarning: `1px solid ${composite(baseColor, changeColor(warningColor, {
alpha: 0.33
}))}`,
colorWarning: composite(baseColor, changeColor(warningColor, {
alpha: 0.08
})),
titleTextColorWarning: textColor1,
iconColorWarning: warningColor,
contentTextColorWarning: textColor2,
closeColorHoverWarning: closeColorHover,
closeColorPressedWarning: closeColorPressed,
closeIconColorWarning: closeIconColor,
closeIconColorHoverWarning: closeIconColorHover,
closeIconColorPressedWarning: closeIconColorPressed,
borderError: `1px solid ${composite(baseColor, changeColor(errorColor, {
alpha: 0.25
}))}`,
colorError: composite(baseColor, changeColor(errorColor, {
alpha: 0.08
})),
titleTextColorError: textColor1,
iconColorError: errorColor,
contentTextColorError: textColor2,
closeColorHoverError: closeColorHover,
closeColorPressedError: closeColorPressed,
closeIconColorError: closeIconColor,
closeIconColorHoverError: closeIconColorHover,
closeIconColorPressedError: closeIconColorPressed
});
}
const alertLight = {
name: 'Alert',
common: light,
self: alert_styles_light_self
};
/* harmony default export */ var alert_styles_light = (alertLight);
;// ./node_modules/naive-ui/es/_styles/transitions/fade-in-height-expand.cssr.mjs
const {
cubicBezierEaseInOut: fade_in_height_expand_cssr_cubicBezierEaseInOut,
cubicBezierEaseOut,
cubicBezierEaseIn
} = _common;
function fadeInHeightExpandTransition({
overflow = 'hidden',
duration = '.3s',
originalTransition = '',
leavingDelay = '0s',
foldPadding = false,
enterToProps = undefined,
leaveToProps = undefined,
reverse = false
} = {}) {
const enterClass = reverse ? 'leave' : 'enter';
const leaveClass = reverse ? 'enter' : 'leave';
return [cssr_c(`&.fade-in-height-expand-transition-${leaveClass}-from,
&.fade-in-height-expand-transition-${enterClass}-to`, Object.assign(Object.assign({}, enterToProps), {
opacity: 1
})), cssr_c(`&.fade-in-height-expand-transition-${leaveClass}-to,
&.fade-in-height-expand-transition-${enterClass}-from`, Object.assign(Object.assign({}, leaveToProps), {
opacity: 0,
marginTop: '0 !important',
marginBottom: '0 !important',
paddingTop: foldPadding ? '0 !important' : undefined,
paddingBottom: foldPadding ? '0 !important' : undefined
})), cssr_c(`&.fade-in-height-expand-transition-${leaveClass}-active`, `
overflow: ${overflow};
transition:
max-height ${duration} ${fade_in_height_expand_cssr_cubicBezierEaseInOut} ${leavingDelay},
opacity ${duration} ${cubicBezierEaseOut} ${leavingDelay},
margin-top ${duration} ${fade_in_height_expand_cssr_cubicBezierEaseInOut} ${leavingDelay},
margin-bottom ${duration} ${fade_in_height_expand_cssr_cubicBezierEaseInOut} ${leavingDelay},
padding-top ${duration} ${fade_in_height_expand_cssr_cubicBezierEaseInOut} ${leavingDelay},
padding-bottom ${duration} ${fade_in_height_expand_cssr_cubicBezierEaseInOut} ${leavingDelay}
${originalTransition ? `,${originalTransition}` : ''}
`), cssr_c(`&.fade-in-height-expand-transition-${enterClass}-active`, `
overflow: ${overflow};
transition:
max-height ${duration} ${fade_in_height_expand_cssr_cubicBezierEaseInOut},
opacity ${duration} ${cubicBezierEaseIn},
margin-top ${duration} ${fade_in_height_expand_cssr_cubicBezierEaseInOut},
margin-bottom ${duration} ${fade_in_height_expand_cssr_cubicBezierEaseInOut},
padding-top ${duration} ${fade_in_height_expand_cssr_cubicBezierEaseInOut},
padding-bottom ${duration} ${fade_in_height_expand_cssr_cubicBezierEaseInOut}
${originalTransition ? `,${originalTransition}` : ''}
`)];
}
;// ./node_modules/naive-ui/es/alert/src/styles/index.cssr.mjs
// vars:
// --n-bezier
// --n-color
// --n-close-color-hover
// --n-close-color-pressed
// --n-close-icon-color
// --n-close-icon-color-hover
// --n-close-icon-color-pressed
// --n-icon-color
// --n-border
// --n-title-text-color
// --n-content-text-color
// --n-line-height
// --n-border-radius
// --n-font-size
// --n-title-font-weight
// --n-icon-size
// --n-icon-margin
// --n-close-size
// --n-close-icon-size
// --n-close-margin
// --n-padding
// --n-icon-margin-left
// --n-icon-margin-right
/* harmony default export */ var alert_src_styles_index_cssr = (cB('alert', `
line-height: var(--n-line-height);
border-radius: var(--n-border-radius);
position: relative;
transition: background-color .3s var(--n-bezier);
background-color: var(--n-color);
text-align: start;
word-break: break-word;
`, [cE('border', `
border-radius: inherit;
position: absolute;
left: 0;
right: 0;
top: 0;
bottom: 0;
transition: border-color .3s var(--n-bezier);
border: var(--n-border);
pointer-events: none;
`), cM('closable', [cB('alert-body', [cE('title', `
padding-right: 24px;
`)])]), cE('icon', {
color: 'var(--n-icon-color)'
}), cB('alert-body', {
padding: 'var(--n-padding)'
}, [cE('title', {
color: 'var(--n-title-text-color)'
}), cE('content', {
color: 'var(--n-content-text-color)'
})]), fadeInHeightExpandTransition({
originalTransition: 'transform .3s var(--n-bezier)',
enterToProps: {
transform: 'scale(1)'
},
leaveToProps: {
transform: 'scale(0.9)'
}
}), cE('icon', `
position: absolute;
left: 0;
top: 0;
align-items: center;
justify-content: center;
display: flex;
width: var(--n-icon-size);
height: var(--n-icon-size);
font-size: var(--n-icon-size);
margin: var(--n-icon-margin);
`), cE('close', `
transition:
color .3s var(--n-bezier),
background-color .3s var(--n-bezier);
position: absolute;
right: 0;
top: 0;
margin: var(--n-close-margin);
`), cM('show-icon', [cB('alert-body', {
paddingLeft: 'calc(var(--n-icon-margin-left) + var(--n-icon-size) + var(--n-icon-margin-right))'
})]),
// fix: https://github.com/tusen-ai/naive-ui/issues/4588
cM('right-adjust', [cB('alert-body', {
paddingRight: 'calc(var(--n-close-size) + var(--n-padding) + 2px)'
})]), cB('alert-body', `
border-radius: var(--n-border-radius);
transition: border-color .3s var(--n-bezier);
`, [cE('title', `
transition: color .3s var(--n-bezier);
font-size: 16px;
line-height: 19px;
font-weight: var(--n-title-font-weight);
`, [cssr_c('& +', [cE('content', {
marginTop: '9px'
})])]), cE('content', {
transition: 'color .3s var(--n-bezier)',
fontSize: 'var(--n-font-size)'
})]), cE('icon', {
transition: 'color .3s var(--n-bezier)'
})]));
;// ./node_modules/naive-ui/es/alert/src/Alert.mjs
const alertProps = Object.assign(Object.assign({}, use_theme.props), {
title: String,
showIcon: {
type: Boolean,
default: true
},
type: {
type: String,
default: 'default'
},
bordered: {
type: Boolean,
default: true
},
closable: Boolean,
onClose: Function,
onAfterLeave: Function,
/** @deprecated */
onAfterHide: Function
});
/* harmony default export */ var Alert = (defineComponent({
name: 'Alert',
inheritAttrs: false,
props: alertProps,
slots: Object,
setup(props) {
if (false) {}
const {
mergedClsPrefixRef,
mergedBorderedRef,
inlineThemeDisabled,
mergedRtlRef
} = useConfig(props);
const themeRef = use_theme('Alert', '-alert', alert_src_styles_index_cssr, alert_styles_light, props, mergedClsPrefixRef);
const rtlEnabledRef = useRtl('Alert', mergedRtlRef, mergedClsPrefixRef);
const cssVarsRef = runtime_core_esm_bundler_computed(() => {
const {
common: {
cubicBezierEaseInOut
},
self
} = themeRef.value;
const {
fontSize,
borderRadius,
titleFontWeight,
lineHeight,
iconSize,
iconMargin,
iconMarginRtl,
closeIconSize,
closeBorderRadius,
closeSize,
closeMargin,
closeMarginRtl,
padding
} = self;
const {
type
} = props;
const {
left,
right
} = getMargin(iconMargin);
return {
'--n-bezier': cubicBezierEaseInOut,
'--n-color': self[createKey('color', type)],
'--n-close-icon-size': closeIconSize,
'--n-close-border-radius': closeBorderRadius,
'--n-close-color-hover': self[createKey('closeColorHover', type)],
'--n-close-color-pressed': self[createKey('closeColorPressed', type)],
'--n-close-icon-color': self[createKey('closeIconColor', type)],
'--n-close-icon-color-hover': self[createKey('closeIconColorHover', type)],
'--n-close-icon-color-pressed': self[createKey('closeIconColorPressed', type)],
'--n-icon-color': self[createKey('iconColor', type)],
'--n-border': self[createKey('border', type)],
'--n-title-text-color': self[createKey('titleTextColor', type)],
'--n-content-text-color': self[createKey('contentTextColor', type)],
'--n-line-height': lineHeight,
'--n-border-radius': borderRadius,
'--n-font-size': fontSize,
'--n-title-font-weight': titleFontWeight,
'--n-icon-size': iconSize,
'--n-icon-margin': iconMargin,
'--n-icon-margin-rtl': iconMarginRtl,
'--n-close-size': closeSize,
'--n-close-margin': closeMargin,
'--n-close-margin-rtl': closeMarginRtl,
'--n-padding': padding,
'--n-icon-margin-left': left,
'--n-icon-margin-right': right
};
});
const themeClassHandle = inlineThemeDisabled ? useThemeClass('alert', runtime_core_esm_bundler_computed(() => {
return props.type[0];
}), cssVarsRef, props) : undefined;
const visibleRef = ref(true);
const doAfterLeave = () => {
const {
onAfterLeave,
onAfterHide // deprecated
} = props;
if (onAfterLeave) onAfterLeave();
if (onAfterHide) onAfterHide();
};
const handleCloseClick = () => {
var _a;
void Promise.resolve((_a = props.onClose) === null || _a === void 0 ? void 0 : _a.call(props)).then(result => {
if (result === false) return;
visibleRef.value = false;
});
};
const handleAfterLeave = () => {
doAfterLeave();
};
return {
rtlEnabled: rtlEnabledRef,
mergedClsPrefix: mergedClsPrefixRef,
mergedBordered: mergedBorderedRef,
visible: visibleRef,
handleCloseClick,
handleAfterLeave,
mergedTheme: themeRef,
cssVars: inlineThemeDisabled ? undefined : cssVarsRef,
themeClass: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.themeClass,
onRender: themeClassHandle === null || themeClassHandle === void 0 ? void 0 : themeClassHandle.onRender
};
},
render() {
var _a;
(_a = this.onRender) === null || _a === void 0 ? void 0 : _a.call(this);
return h(FadeInExpandTransition, {
onAfterLeave: this.handleAfterLeave
}, {
default: () => {
const {
mergedClsPrefix,
$slots
} = this;
const attrs = {
class: [`${mergedClsPrefix}-alert`, this.themeClass, this.closable && `${mergedClsPrefix}-alert--closable`, this.showIcon && `${mergedClsPrefix}-alert--show-icon`,
// fix: https://github.com/tusen-ai/naive-ui/issues/4588
!this.title && this.closable && `${mergedClsPrefix}-alert--right-adjust`, this.rtlEnabled && `${mergedClsPrefix}-alert--rtl`],
style: this.cssVars,
role: 'alert'
};
return this.visible ? h("div", Object.assign({}, mergeProps(this.$attrs, attrs)), this.closable && h(src_Close, {
clsPrefix: mergedClsPrefix,
class: `${mergedClsPrefix}-alert__close`,
onClick: this.handleCloseClick
}), this.bordered && h("div", {
class: `${mergedClsPrefix}-alert__border`
}), this.showIcon && h("div", {
class: `${mergedClsPrefix}-alert__icon`,
"aria-hidden": "true"
}, resolveSlot($slots.icon, () => [h(Icon, {
clsPrefix: mergedClsPrefix
}, {
default: () => {
switch (this.type) {
case 'success':
return h(Success, null);
case 'info':
return h(Info, null);
case 'warning':
return h(Warning, null);
case 'error':
return h(icons_Error, null);
default:
return null;
}
}
})])), h("div", {
class: [`${mergedClsPrefix}-alert-body`, this.mergedBordered && `${mergedClsPrefix}-alert-body--bordered`]
}, resolveWrappedSlot($slots.header, children => {
const mergedChildren = children || this.title;
return mergedChildren ? h("div", {
class: `${mergedClsPrefix}-alert-body__title`
}, mergedChildren) : null;
}), $slots.default && h("div", {
class: `${mergedClsPrefix}-alert-body__content`
}, $slots))) : null;
}
});
}
}));
;// ./node_modules/naive-ui/es/_internal/icons/Remove.mjs
/* harmony default export */ var Remove = (defineComponent({
name: 'Remove',
render() {
return h("svg", {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 512 512"
}, h("line", {
x1: "400",
y1: "256",
x2: "112",
y2: "256",
style: "\n fill: none;\n stroke: currentColor;\n stroke-linecap: round;\n stroke-linejoin: round;\n stroke-width: 32px;\n "
}));
}
}));
;// ./node_modules/naive-ui/es/_internal/icons/Add.mjs
/* harmony default export */ var Add = (defineComponent({
name: 'Add',
render() {
return h("svg", {
width: "512",
height: "512",
viewBox: "0 0 512 512",
fill: "none",
xmlns: "http://www.w3.org/2000/svg"
}, h("path", {
d: "M256 112V400M400 256H112",
stroke: "currentColor",
"stroke-width": "32",
"stroke-linecap": "round",
"stroke-linejoin": "round"
}));
}
}));
;// ./node_modules/naive-ui/es/input-number/styles/light.mjs
function input_number_styles_light_self(vars) {
const {
textColorDisabled
} = vars;
return {
iconColorDisabled: textColorDisabled
};
}
const inputNumberLight = createTheme({
name: 'InputNumber',
common: light,
peers: {
Button: styles_light,
Input: input_styles_light
},
self: input_number_styles_light_self
});
/* harmony default export */ var input_number_styles_light = (inputNumberLight);
;// ./node_modules/naive-ui/es/input-number/src/styles/input-number.cssr.mjs
/* harmony default export */ var input_number_cssr = (cssr_c([cB('input-number-suffix', `
display: inline-block;
margin-right: 10px;
`), cB('input-number-prefix', `
display: inline-block;
margin-left: 10px;
`)]));
;// ./node_modules/naive-ui/es/input-number/src/utils.mjs
// string => string (expected, not implemented)
// string => number (legacy)
function utils_parse(value) {
if (value === undefined || value === null || typeof value === 'string' && value.trim() === '') {
return null;
}
return Number(value);
}
// This function is created for `update-value-on-input` prop. When the prop is
// true, the input value will update the value and <input />'s value at the same
// time. So we need to make user's content won't be replaced by its parsed value
// in some certain cases. For example '0.' should be parsed and replaced by '0',
// '-0' should be parsed and replaced by '0', since user may input '-0.1' after.
function isWipValue(value) {
return value.includes('.') && (/^(-)?\d+.*(\.|0)$/.test(value) || /^-?\d*$/.test(value)) || value === '-' || value === '-0';
}
// string => boolean (expected, not implemented)
// number => boolean (legacy)
function utils_validator(value) {
if (value === undefined || value === null) return true;
if (Number.isNaN(value)) return false;
return true;
}
// string => string (expected, not implemented)
// number => string (legacy)
function utils_format(value, precision) {
if (typeof value !== 'number') return '';
return precision === undefined ? String(value) : value.toFixed(precision);
}
function parseNumber(number) {
if (number === null) return null;
if (typeof number === 'number') {
return number;
} else {
const parsedNumber = Number(number);
if (Number.isNaN(parsedNumber)) {
return null;
} else {
return parsedNumber;
}
}
}
;// ./node_modules/naive-ui/es/input-number/src/InputNumber.mjs
const HOLDING_CHANGE_THRESHOLD = 800;
const HOLDING_CHANGE_INTERVAL = 100;
const inputNumberProps = Object.assign(Object.assign({}, use_theme.props), {
autofocus: Boolean,
loading: {
type: Boolean,
default: undefined
},
placeholder: String,
defaultValue: {
type: Number,
default: null
},
value: Number,
step: {
type: [Number, String],
default: 1
},
min: [Number, String],
max: [Number, String],
size: String,
disabled: {
type: Boolean,
default: undefined
},
validator: Function,
bordered: {
type: Boolean,
default: undefined
},
showButton: {
type: Boolean,
default: true
},
buttonPlacement: {
type: String,
default: 'right'
},
inputProps: Object,
readonly: Boolean,
clearable: Boolean,
keyboard: {
type: Object,
default: {}
},
updateValueOnInput: {
type: Boolean,
default: true
},
round: {
type: Boolean,
default: undefined
},
parse: Function,
format: Function,
precision: Number,
status: String,
'onUpdate:value': [Function, Array],
onUpdateValue: [Function, Array],
onFocus: [Function, Array],
onBlur: [Function, Array],
onClear: [Function, Array],
// deprecated
onChange: [Function, Array]
});
/* harmony default export */ var InputNumber = (defineComponent({
name: 'InputNumber',
props: inputNumberProps,
slots: Object,
setup(props) {
if (false) {}
const {
mergedBorderedRef,
mergedClsPrefixRef,
mergedRtlRef
} = useConfig(props);
const themeRef = use_theme('InputNumber', '-input-number', input_number_cssr, input_number_styles_light, props, mergedClsPrefixRef);
const {
localeRef
} = useLocale('InputNumber');
const formItem = useFormItem(props);
const {
mergedSizeRef,
mergedDisabledRef,
mergedStatusRef
} = formItem;
// dom ref
const inputInstRef = ref(null);
const minusButtonInstRef = ref(null);
const addButtonInstRef = ref(null);
// value
const uncontrolledValueRef = ref(props.defaultValue);
const controlledValueRef = toRef(props, 'value');
const mergedValueRef = useMergedState(controlledValueRef, uncontrolledValueRef);
const displayedValueRef = ref('');
const getPrecision = value => {
const fraction = String(value).split('.')[1];
return fraction ? fraction.length : 0;
};
const getMaxPrecision = currentValue => {
const precisions = [props.min, props.max, props.step, currentValue].map(value => {
if (value === undefined) return 0;
return getPrecision(value);
});
return Math.max(...precisions);
};
const mergedPlaceholderRef = use_memo(() => {
const {
placeholder
} = props;
if (placeholder !== undefined) return placeholder;
return localeRef.value.placeholder;
});
const mergedStepRef = use_memo(() => {
const parsedNumber = parseNumber(props.step);
if (parsedNumber !== null) {
return parsedNumber === 0 ? 1 : Math.abs(parsedNumber);
}
return 1;
});
const mergedMinRef = use_memo(() => {
const parsedNumber = parseNumber(props.min);
if (parsedNumber !== null) return parsedNumber;else return null;
});
const mergedMaxRef = use_memo(() => {
const parsedNumber = parseNumber(props.max);
if (parsedNumber !== null) return parsedNumber;else return null;
});
const deriveDisplayedValueFromValue = () => {
const {
value: mergedValue
} = mergedValueRef;
if (utils_validator(mergedValue)) {
const {
format: formatProp,
precision
} = props;
if (formatProp) {
displayedValueRef.value = formatProp(mergedValue);
} else {
if (mergedValue === null || precision === undefined
// precision overflow
|| getPrecision(mergedValue) > precision) {
displayedValueRef.value = utils_format(mergedValue, undefined);
} else {
displayedValueRef.value = utils_format(mergedValue, precision);
}
}
} else {
// null can pass the validator check
// so mergedValue is a number
displayedValueRef.value = String(mergedValue);
}
};
deriveDisplayedValueFromValue();
const doUpdateValue = value => {
const {
value: mergedValue
} = mergedValueRef;
if (value === mergedValue) {
deriveDisplayedValueFromValue();
return;
}
const {
'onUpdate:value': _onUpdateValue,
onUpdateValue,
onChange
} = props;
const {
nTriggerFormInput,
nTriggerFormChange
} = formItem;
if (onChange) call(onChange, value);
if (onUpdateValue) call(onUpdateValue, value);
if (_onUpdateValue) call(_onUpdateValue, value);
uncontrolledValueRef.value = value;
nTriggerFormInput();
nTriggerFormChange();
};
const deriveValueFromDisplayedValue = ({
offset,
doUpdateIfValid,
fixPrecision,
isInputing
}) => {
const {
value: displayedValue
} = displayedValueRef;
if (isInputing && isWipValue(displayedValue)) {
return false;
}
const parsedValue = (props.parse || utils_parse)(displayedValue);
if (parsedValue === null) {
if (doUpdateIfValid) doUpdateValue(null);
return null;
}
if (utils_validator(parsedValue)) {
const currentPrecision = getPrecision(parsedValue);
const {
precision
} = props;
if (precision !== undefined && precision < currentPrecision && !fixPrecision) {
return false;
}
let nextValue = Number.parseFloat((parsedValue + offset).toFixed(precision !== null && precision !== void 0 ? precision : getMaxPrecision(parsedValue)));
if (utils_validator(nextValue)) {
const {
value: mergedMax
} = mergedMaxRef;
const {
value: mergedMin
} = mergedMinRef;
if (mergedMax !== null && nextValue > mergedMax) {
if (!doUpdateIfValid || isInputing) return false;
// if doUpdateIfValid=true, we try to make it a valid value
nextValue = mergedMax;
}
if (mergedMin !== null && nextValue < mergedMin) {
if (!doUpdateIfValid || isInputing) return false;
// if doUpdateIfValid=true, we try to make it a valid value
nextValue = mergedMin;
}
if (props.validator && !props.validator(nextValue)) return false;
if (doUpdateIfValid) doUpdateValue(nextValue);
return nextValue;
}
}
return false;
};
const displayedValueInvalidRef = use_memo(() => {
const derivedValue = deriveValueFromDisplayedValue({
offset: 0,
doUpdateIfValid: false,
isInputing: false,
fixPrecision: false
});
return derivedValue === false;
});
const minusableRef = use_memo(() => {
const {
value: mergedValue
} = mergedValueRef;
if (props.validator && mergedValue === null) {
return false;
}
const {
value: mergedStep
} = mergedStepRef;
const derivedNextValue = deriveValueFromDisplayedValue({
offset: -mergedStep,
doUpdateIfValid: false,
isInputing: false,
fixPrecision: false
});
return derivedNextValue !== false;
});
const addableRef = use_memo(() => {
const {
value: mergedValue
} = mergedValueRef;
if (props.validator && mergedValue === null) {
return false;
}
const {
value: mergedStep
} = mergedStepRef;
const derivedNextValue = deriveValueFromDisplayedValue({
offset: +mergedStep,
doUpdateIfValid: false,
isInputing: false,
fixPrecision: false
});
return derivedNextValue !== false;
});
function doFocus(e) {
const {
onFocus
} = props;
const {
nTriggerFormFocus
} = formItem;
if (onFocus) call(onFocus, e);
nTriggerFormFocus();
}
function doBlur(e) {
var _a, _b;
if (e.target === ((_a = inputInstRef.value) === null || _a === void 0 ? void 0 : _a.wrapperElRef)) {
// hit input wrapper
// which means not activated
return;
}
const value = deriveValueFromDisplayedValue({
offset: 0,
doUpdateIfValid: true,
isInputing: false,
fixPrecision: true
});
// If valid, update event has been emitted
// make sure e.target.value is correct in blur callback
if (value !== false) {
const inputElRef = (_b = inputInstRef.value) === null || _b === void 0 ? void 0 : _b.inputElRef;
if (inputElRef) {
inputElRef.value = String(value || '');
}
// If value is not changed, the displayed value may be greater than or
// less than the current value. The derived value is reformatted so the
// value is not changed. We can simply derive a new displayed value
if (mergedValueRef.value === value) {
deriveDisplayedValueFromValue();
}
} else {
// If not valid, nothing will be emitted, so derive displayed value from
// origin value
deriveDisplayedValueFromValue();
}
const {
onBlur
} = props;
const {
nTriggerFormBlur
} = formItem;
if (onBlur) call(onBlur, e);
nTriggerFormBlur();
// User may change value in blur callback, we make sure it will be
// displayed. Sometimes mergedValue won't be viewed as changed
void nextTick(() => {
deriveDisplayedValueFromValue();
});
}
function doClear(e) {
const {
onClear
} = props;
if (onClear) call(onClear, e);
}
function doAdd() {
const {
value: addable
} = addableRef;
if (!addable) {
clearAddHoldTimeout();
return;
}
const {
value: mergedValue
} = mergedValueRef;
if (mergedValue === null) {
if (!props.validator) {
doUpdateValue(createValidValue());
}
} else {
const {
value: mergedStep
} = mergedStepRef;
deriveValueFromDisplayedValue({
offset: mergedStep,
doUpdateIfValid: true,
isInputing: false,
fixPrecision: true
});
}
}
function doMinus() {
const {
value: minusable
} = minusableRef;
if (!minusable) {
clearMinusHoldTimeout();
return;
}
const {
value: mergedValue
} = mergedValueRef;
if (mergedValue === null) {
if (!props.validator) {
doUpdateValue(createValidValue());
}
} else {
const {
value: mergedStep
} = mergedStepRef;
deriveValueFromDisplayedValue({
offset: -mergedStep,
doUpdateIfValid: true,
isInputing: false,
fixPrecision: true
});
}
}
const handleFocus = doFocus;
const handleBlur = doBlur;
function createValidValue() {
if (props.validator) return null;
const {
value: mergedMin
} = mergedMinRef;
const {
value: mergedMax
} = mergedMaxRef;
if (mergedMin !== null) {
return Math.max(0, mergedMin);
} else if (mergedMax !== null) {
return Math.min(0, mergedMax);
} else {
return 0;
}
}
function handleClear(e) {
doClear(e);
doUpdateValue(null);
}
function handleMouseDown(e) {
var _a, _b, _c;
if ((_a = addButtonInstRef.value) === null || _a === void 0 ? void 0 : _a.$el.contains(e.target)) {
e.preventDefault();
}
if ((_b = minusButtonInstRef.value) === null || _b === void 0 ? void 0 : _b.$el.contains(e.target)) {
e.preventDefault();
}
(_c = inputInstRef.value) === null || _c === void 0 ? void 0 : _c.activate();
}
let minusHoldStateIntervalId = null;
let addHoldStateIntervalId = null;
let firstMinusMousedownId = null;
function clearMinusHoldTimeout() {
if (firstMinusMousedownId) {
window.clearTimeout(firstMinusMousedownId);
firstMinusMousedownId = null;
}
if (minusHoldStateIntervalId) {
window.clearInterval(minusHoldStateIntervalId);
minusHoldStateIntervalId = null;
}
}
let firstAddMousedownId = null;
function clearAddHoldTimeout() {
if (firstAddMousedownId) {
window.clearTimeout(firstAddMousedownId);
firstAddMousedownId = null;
}
if (addHoldStateIntervalId) {
window.clearInterval(addHoldStateIntervalId);
addHoldStateIntervalId = null;
}
}
function handleMinusMousedown() {
clearMinusHoldTimeout();
firstMinusMousedownId = window.setTimeout(() => {
minusHoldStateIntervalId = window.setInterval(() => {
doMinus();
}, HOLDING_CHANGE_INTERVAL);
}, HOLDING_CHANGE_THRESHOLD);
on('mouseup', document, clearMinusHoldTimeout, {
once: true
});
}
function handleAddMousedown() {
clearAddHoldTimeout();
firstAddMousedownId = window.setTimeout(() => {
addHoldStateIntervalId = window.setInterval(() => {
doAdd();
}, HOLDING_CHANGE_INTERVAL);
}, HOLDING_CHANGE_THRESHOLD);
on('mouseup', document, clearAddHoldTimeout, {
once: true
});
}
const handleAddClick = () => {
if (addHoldStateIntervalId) return;
doAdd();
};
const handleMinusClick = () => {
if (minusHoldStateIntervalId) return;
doMinus();
};
function handleKeyDown(e) {
var _a, _b;
if (e.key === 'Enter') {
if (e.target === ((_a = inputInstRef.value) === null || _a === void 0 ? void 0 : _a.wrapperElRef)) {
// hit input wrapper
// which means not activated
return;
}
const value = deriveValueFromDisplayedValue({
offset: 0,
doUpdateIfValid: true,
isInputing: false,
fixPrecision: true
});
if (value !== false) {
(_b = inputInstRef.value) === null || _b === void 0 ? void 0 : _b.deactivate();
}
} else if (e.key === 'ArrowUp') {
if (!addableRef.value) return;
if (props.keyboard.ArrowUp === false) return;
e.preventDefault();
const value = deriveValueFromDisplayedValue({
offset: 0,
doUpdateIfValid: true,
isInputing: false,
fixPrecision: true
});
if (value !== false) {
doAdd();
}
} else if (e.key === 'ArrowDown') {
if (!minusableRef.value) return;
if (props.keyboard.ArrowDown === false) return;
e.preventDefault();
const value = deriveValueFromDisplayedValue({
offset: 0,
doUpdateIfValid: true,
isInputing: false,
fixPrecision: true
});
if (value !== false) {
doMinus();
}
}
}
function handleUpdateDisplayedValue(value) {
displayedValueRef.value = value;
if (props.updateValueOnInput && !props.format && !props.parse && props.precision === undefined) {
deriveValueFromDisplayedValue({
offset: 0,
doUpdateIfValid: true,
isInputing: true,
fixPrecision: false
});
}
}
runtime_core_esm_bundler_watch(mergedValueRef, () => {
deriveDisplayedValueFromValue();
});
const exposedMethods = {
focus: () => {
var _a;
return (_a = inputInstRef.value) === null || _a === void 0 ? void 0 : _a.focus();
},
blur: () => {
var _a;
return (_a = inputInstRef.value) === null || _a === void 0 ? void 0 : _a.blur();
},
select: () => {
var _a;
return (_a = inputInstRef.value) === null || _a === void 0 ? void 0 : _a.select();
}
};
const rtlEnabledRef = useRtl('InputNumber', mergedRtlRef, mergedClsPrefixRef);
return Object.assign(Object.assign({}, exposedMethods), {
rtlEnabled: rtlEnabledRef,
inputInstRef,
minusButtonInstRef,
addButtonInstRef,
mergedClsPrefix: mergedClsPrefixRef,
mergedBordered: mergedBorderedRef,
uncontrolledValue: uncontrolledValueRef,
mergedValue: mergedValueRef,
mergedPlaceholder: mergedPlaceholderRef,
displayedValueInvalid: displayedValueInvalidRef,
mergedSize: mergedSizeRef,
mergedDisabled: mergedDisabledRef,
displayedValue: displayedValueRef,
addable: addableRef,
minusable: minusableRef,
mergedStatus: mergedStatusRef,
handleFocus,
handleBlur,
handleClear,
handleMouseDown,
handleAddClick,
handleMinusClick,
handleAddMousedown,
handleMinusMousedown,
handleKeyDown,
handleUpdateDisplayedValue,
// theme
mergedTheme: themeRef,
inputThemeOverrides: {
paddingSmall: '0 8px 0 10px',
paddingMedium: '0 8px 0 12px',
paddingLarge: '0 8px 0 14px'
},
buttonThemeOverrides: runtime_core_esm_bundler_computed(() => {
const {
self: {
iconColorDisabled
}
} = themeRef.value;
const [r, g, b, a] = rgba(iconColorDisabled);
return {
textColorTextDisabled: `rgb(${r}, ${g}, ${b})`,
opacityDisabled: `${a}`
};
})
});
},
render() {
const {
mergedClsPrefix,
$slots
} = this;
const renderMinusButton = () => {
return h(XButton, {
text: true,
disabled: !this.minusable || this.mergedDisabled || this.readonly,
focusable: false,
theme: this.mergedTheme.peers.Button,
themeOverrides: this.mergedTheme.peerOverrides.Button,
builtinThemeOverrides: this.buttonThemeOverrides,
onClick: this.handleMinusClick,
onMousedown: this.handleMinusMousedown,
ref: "minusButtonInstRef"
}, {
icon: () => resolveSlot($slots['minus-icon'], () => [h(Icon, {
clsPrefix: mergedClsPrefix
}, {
default: () => h(Remove, null)
})])
});
};
const renderAddButton = () => {
return h(XButton, {
text: true,
disabled: !this.addable || this.mergedDisabled || this.readonly,
focusable: false,
theme: this.mergedTheme.peers.Button,
themeOverrides: this.mergedTheme.peerOverrides.Button,
builtinThemeOverrides: this.buttonThemeOverrides,
onClick: this.handleAddClick,
onMousedown: this.handleAddMousedown,
ref: "addButtonInstRef"
}, {
icon: () => resolveSlot($slots['add-icon'], () => [h(Icon, {
clsPrefix: mergedClsPrefix
}, {
default: () => h(Add, null)
})])
});
};
return h("div", {
class: [`${mergedClsPrefix}-input-number`, this.rtlEnabled && `${mergedClsPrefix}-input-number--rtl`]
}, h(Input, {
ref: "inputInstRef",
autofocus: this.autofocus,
status: this.mergedStatus,
bordered: this.mergedBordered,
loading: this.loading,
value: this.displayedValue,
onUpdateValue: this.handleUpdateDisplayedValue,
theme: this.mergedTheme.peers.Input,
themeOverrides: this.mergedTheme.peerOverrides.Input,
builtinThemeOverrides: this.inputThemeOverrides,
size: this.mergedSize,
placeholder: this.mergedPlaceholder,
disabled: this.mergedDisabled,
readonly: this.readonly,
round: this.round,
textDecoration: this.displayedValueInvalid ? 'line-through' : undefined,
onFocus: this.handleFocus,
onBlur: this.handleBlur,
onKeydown: this.handleKeyDown,
onMousedown: this.handleMouseDown,
onClear: this.handleClear,
clearable: this.clearable,
inputProps: this.inputProps,
internalLoadingBeforeSuffix: true
}, {
prefix: () => {
var _a;
return this.showButton && this.buttonPlacement === 'both' ? [renderMinusButton(), resolveWrappedSlot($slots.prefix, children => {
if (children) {
return h("span", {
class: `${mergedClsPrefix}-input-number-prefix`
}, children);
}
return null;
})] : (_a = $slots.prefix) === null || _a === void 0 ? void 0 : _a.call($slots);
},
suffix: () => {
var _a;
return this.showButton ? [resolveWrappedSlot($slots.suffix, children => {
if (children) {
return h("span", {
class: `${mergedClsPrefix}-input-number-suffix`
}, children);
}
return null;
}), this.buttonPlacement === 'right' ? renderMinusButton() : null, renderAddButton()] : (_a = $slots.suffix) === null || _a === void 0 ? void 0 : _a.call($slots);
}
}));
}
}));
;// ./src/main.js
// 挂载节点
var naive = es_create({
components: [src_Button, Space, Popover, Card, Grid, GridItem, Form, FormItem, Input, Radio, RadioGroup, Alert, InputNumber]
});
var monkey_plugin = document.createElement("div");
monkey_plugin.id = "monkey_plugin";
monkey_plugin.style = "with:100%;z-index:1000";
document.body.appendChild(monkey_plugin);
var app = createApp(App);
app.use(naive);
app.mount("#monkey_plugin");
}();
/******/ })()
;
QingJ © 2025
镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址