diff --git a/Gruntfile.js b/Gruntfile.js index 78e7047737..2f0d5584a5 100644 --- a/Gruntfile.js +++ b/Gruntfile.js @@ -16,7 +16,7 @@ const chalk = require('chalk') const crypto = require('crypto') const { exec, fork } = require('child_process') const execP = util.promisify(exec) -const { copyFile, readFile } = require('fs/promises') +const { copyFile, readFile, writeFile } = require('fs/promises') const fs = require('fs') const path = require('path') const { resolve } = path @@ -118,12 +118,12 @@ module.exports = (grunt) => { } } - async function deployAndUpdateMainSrc (manifestDir) { + async function deployAndUpdateMainSrc (manifestDir, dest) { if (development) { - grunt.log.writeln(chalk.underline("Running 'chel deploy'")) - const { stdout } = await execWithErrMsg(`./node_modules/.bin/chel deploy ./data ${manifestDir}/*.manifest.json`, 'error deploying contracts') + grunt.log.writeln(chalk.underline(`Running 'chel deploy' to ${dest}`)) + const { stdout } = await execWithErrMsg(`./node_modules/.bin/chel deploy ${dest} ${manifestDir}/*.manifest.json`, 'error deploying contracts') console.log(stdout) - const r = /contracts\/([^.]+)\.(?:x|[\d.]+)\.manifest.*data\/(.*)/g + const r = /contracts\/([^.]+)\.(?:x|[\d.]+)\.manifest.*\/(.*)/g const manifests = Object.fromEntries(Array.from(stdout.replace(/\\/g, '/').matchAll(r), x => [`gi.contracts/${x[1]}`, x[2]])) fs.writeFileSync(manifestJSON, JSON.stringify({ manifests }, null, 2) + '\n', @@ -136,9 +136,9 @@ module.exports = (grunt) => { } } - async function genManifestsAndDeploy (dir, version) { + async function genManifestsAndDeploy (dir, version, dest = './data') { await generateManifests(dir, version) - await deployAndUpdateMainSrc(dir) + await deployAndUpdateMainSrc(dir, dest) } // Used by both the alias plugin and the Vue plugin. @@ -183,6 +183,15 @@ module.exports = (grunt) => { tunnel: grunt.option('tunnel') && `gi${crypto.randomBytes(2).toString('hex')}` } + const databaseOptionBags = { + fs: { + dest: './data/' + }, + sqlite: { + dest: './data/groupincome.db' + } + } + // https://esbuild.github.io/api/ const esbuildOptionBags = { // Native options that are shared between our esbuild tasks. @@ -477,7 +486,7 @@ module.exports = (grunt) => { // it's possible for the UI to get updated without the contracts getting updated, // so we keep their version numbers separate. packageJSON.contractsVersion = version - fs.writeFileSync('package.json', JSON.stringify(packageJSON, null, 2) + '\n', 'utf8') + writeFile('package.json', JSON.stringify(packageJSON, null, 2) + '\n', 'utf8') console.log(chalk.green('updated package.json "contractsVersion" to:'), version) done() }) @@ -604,7 +613,8 @@ module.exports = (grunt) => { } else if (filePath.startsWith(contractsDir)) { await buildContracts.run({ fileEventName, filePath }) await buildContractsSlim.run({ fileEventName, filePath }) - await genManifestsAndDeploy(distContracts, packageJSON.contractsVersion) + const dest = databaseOptionBags[process.env.GI_PERSIST]?.dest ?? process.env.API_URL + await genManifestsAndDeploy(distContracts, packageJSON.contractsVersion, dest) // genManifestsAndDeploy modifies manifests.json, which means we need // to regenerate the main bundle since it imports that file await buildMain.run({ fileEventName, filePath }) diff --git a/contracts/0.1.7/chatroom-slim.js b/contracts/0.1.7/chatroom-slim.js new file mode 100644 index 0000000000..aadb011229 --- /dev/null +++ b/contracts/0.1.7/chatroom-slim.js @@ -0,0 +1,961 @@ +"use strict"; +(() => { + var __create = Object.create; + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __getProtoOf = Object.getPrototypeOf; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { + get: (a, b) => (typeof require !== "undefined" ? require : a)[b] + }) : x)(function(x) { + if (typeof require !== "undefined") + return require.apply(this, arguments); + throw new Error('Dynamic require of "' + x + '" is not supported'); + }); + var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; + }; + var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod)); + + // frontend/model/contracts/chatroom.js + var import_sbp3 = __toESM(__require("@sbp/sbp")); + var import_common2 = __require("@common/common.js"); + + // frontend/model/contracts/shared/giLodash.js + function cloneDeep(obj) { + return JSON.parse(JSON.stringify(obj)); + } + function isMergeableObject(val) { + const nonNullObject = val && typeof val === "object"; + return nonNullObject && Object.prototype.toString.call(val) !== "[object RegExp]" && Object.prototype.toString.call(val) !== "[object Date]"; + } + function merge(obj, src) { + for (const key in src) { + const clone = isMergeableObject(src[key]) ? cloneDeep(src[key]) : void 0; + if (clone && isMergeableObject(obj[key])) { + merge(obj[key], clone); + continue; + } + obj[key] = clone || src[key]; + } + return obj; + } + + // frontend/model/contracts/shared/constants.js + var CHATROOM_NAME_LIMITS_IN_CHARS = 50; + var CHATROOM_DESCRIPTION_LIMITS_IN_CHARS = 280; + var CHATROOM_ACTIONS_PER_PAGE = 40; + var CHATROOM_MESSAGE_ACTION = "chatroom-message-action"; + var MESSAGE_RECEIVE = "message-receive"; + var CHATROOM_TYPES = { + INDIVIDUAL: "individual", + GROUP: "group" + }; + var CHATROOM_PRIVACY_LEVEL = { + GROUP: "group", + PRIVATE: "private", + PUBLIC: "public" + }; + var MESSAGE_TYPES = { + POLL: "poll", + TEXT: "text", + INTERACTIVE: "interactive", + NOTIFICATION: "notification" + }; + var MESSAGE_NOTIFICATIONS = { + ADD_MEMBER: "add-member", + JOIN_MEMBER: "join-member", + LEAVE_MEMBER: "leave-member", + KICK_MEMBER: "kick-member", + UPDATE_DESCRIPTION: "update-description", + UPDATE_NAME: "update-name", + DELETE_CHANNEL: "delete-channel", + VOTE_ON_POLL: "vote-on-poll", + CHANGE_VOTE_ON_POLL: "change-vote-on-poll" + }; + var PROPOSAL_VARIANTS = { + CREATED: "created", + EXPIRING: "expiring", + ACCEPTED: "accepted", + REJECTED: "rejected", + EXPIRED: "expired" + }; + var MESSAGE_NOTIFY_SETTINGS = { + ALL_MESSAGES: "all-messages", + DIRECT_MESSAGES: "direct-messages", + NOTHING: "nothing" + }; + var POLL_STATUS = { + ACTIVE: "active", + CLOSED: "closed" + }; + + // frontend/model/contracts/misc/flowTyper.js + var EMPTY_VALUE = Symbol("@@empty"); + var isEmpty = (v) => v === EMPTY_VALUE; + var isNil = (v) => v === null; + var isUndef = (v) => typeof v === "undefined"; + var isBoolean = (v) => typeof v === "boolean"; + var isNumber = (v) => typeof v === "number"; + var isString = (v) => typeof v === "string"; + var isObject = (v) => !isNil(v) && typeof v === "object"; + var isFunction = (v) => typeof v === "function"; + var getType = (typeFn, _options) => { + if (isFunction(typeFn.type)) + return typeFn.type(_options); + return typeFn.name || "?"; + }; + var TypeValidatorError = class extends Error { + expectedType; + valueType; + value; + typeScope; + sourceFile; + constructor(message, expectedType, valueType, value, typeName = "", typeScope = "") { + const errMessage = message || `invalid "${valueType}" value type; ${typeName || expectedType} type expected`; + super(errMessage); + this.expectedType = expectedType; + this.valueType = valueType; + this.value = value; + this.typeScope = typeScope || ""; + this.sourceFile = this.getSourceFile(); + this.message = `${errMessage} +${this.getErrorInfo()}`; + this.name = this.constructor.name; + if (Error.captureStackTrace) { + Error.captureStackTrace(this, TypeValidatorError); + } + } + getSourceFile() { + const fileNames = this.stack.match(/(\/[\w_\-.]+)+(\.\w+:\d+:\d+)/g) || []; + return fileNames.find((fileName) => fileName.indexOf("/flowTyper-js/dist/") === -1) || ""; + } + getErrorInfo() { + return ` + file ${this.sourceFile} + scope ${this.typeScope} + expected ${this.expectedType.replace(/\n/g, "")} + type ${this.valueType} + value ${this.value} +`; + } + }; + var validatorError = (typeFn, value, scope, message, expectedType, valueType) => { + return new TypeValidatorError(message, expectedType || getType(typeFn), valueType || typeof value, JSON.stringify(value), typeFn.name, scope); + }; + var arrayOf = (typeFn, _scope = "Array") => { + function array(value) { + if (isEmpty(value)) + return [typeFn(value)]; + if (Array.isArray(value)) { + let index = 0; + return value.map((v) => typeFn(v, `${_scope}[${index++}]`)); + } + throw validatorError(array, value, _scope); + } + array.type = () => `Array<${getType(typeFn)}>`; + return array; + }; + var literalOf = (primitive) => { + function literal(value, _scope = "") { + if (isEmpty(value) || value === primitive) + return primitive; + throw validatorError(literal, value, _scope); + } + literal.type = () => { + if (isBoolean(primitive)) + return `${primitive ? "true" : "false"}`; + else + return `"${primitive}"`; + }; + return literal; + }; + var mapOf = (keyTypeFn, typeFn) => { + function mapOf2(value) { + if (isEmpty(value)) + return {}; + const o = object(value); + const reducer = (acc, key) => Object.assign(acc, { + [keyTypeFn(key, "Map[_]")]: typeFn(o[key], `Map.${key}`) + }); + return Object.keys(o).reduce(reducer, {}); + } + mapOf2.type = () => `{ [_:${getType(keyTypeFn)}]: ${getType(typeFn)} }`; + return mapOf2; + }; + var object = function(value) { + if (isEmpty(value)) + return {}; + if (isObject(value) && !Array.isArray(value)) { + return Object.assign({}, value); + } + throw validatorError(object, value); + }; + var objectOf = (typeObj, _scope = "Object") => { + function object2(value) { + const o = object(value); + const typeAttrs = Object.keys(typeObj); + const unknownAttr = Object.keys(o).find((attr) => !typeAttrs.includes(attr)); + if (unknownAttr) { + throw validatorError(object2, value, _scope, `missing object property '${unknownAttr}' in ${_scope} type`); + } + const undefAttr = typeAttrs.find((property) => { + const propertyTypeFn = typeObj[property]; + return propertyTypeFn.name.includes("maybe") && !o.hasOwnProperty(property); + }); + if (undefAttr) { + throw validatorError(object2, o[undefAttr], `${_scope}.${undefAttr}`, `empty object property '${undefAttr}' for ${_scope} type`, `void | null | ${getType(typeObj[undefAttr]).substr(1)}`, "-"); + } + const reducer = isEmpty(value) ? (acc, key) => Object.assign(acc, { [key]: typeObj[key](value) }) : (acc, key) => { + const typeFn = typeObj[key]; + if (typeFn.name.includes("optional") && !o.hasOwnProperty(key)) { + return Object.assign(acc, {}); + } else { + return Object.assign(acc, { [key]: typeFn(o[key], `${_scope}.${key}`) }); + } + }; + return typeAttrs.reduce(reducer, {}); + } + object2.type = () => { + const props = Object.keys(typeObj).map((key) => { + const ret = typeObj[key].name.includes("optional") ? `${key}?: ${getType(typeObj[key], { noVoid: true })}` : `${key}: ${getType(typeObj[key])}`; + return ret; + }); + return `{| + ${props.join(",\n ")} +|}`; + }; + return object2; + }; + function objectMaybeOf(validations, _scope = "Object") { + return function(data) { + object(data); + for (const key in data) { + validations[key]?.(data[key], `${_scope}.${key}`); + } + return data; + }; + } + var optional = (typeFn) => { + const unionFn = unionOf(typeFn, undef); + function optional2(v) { + return unionFn(v); + } + optional2.type = ({ noVoid }) => !noVoid ? getType(unionFn) : getType(typeFn); + return optional2; + }; + function undef(value, _scope = "") { + if (isEmpty(value) || isUndef(value)) + return void 0; + throw validatorError(undef, value, _scope); + } + undef.type = () => "void"; + var number = function number2(value, _scope = "") { + if (isEmpty(value)) + return 0; + if (isNumber(value)) + return value; + throw validatorError(number2, value, _scope); + }; + var string = function string2(value, _scope = "") { + if (isEmpty(value)) + return ""; + if (isString(value)) + return value; + throw validatorError(string2, value, _scope); + }; + function unionOf_(...typeFuncs) { + function union(value, _scope = "") { + for (const typeFn of typeFuncs) { + try { + return typeFn(value, _scope); + } catch (_) { + } + } + throw validatorError(union, value, _scope); + } + union.type = () => `(${typeFuncs.map((fn) => getType(fn)).join(" | ")})`; + return union; + } + var unionOf = unionOf_; + + // frontend/model/contracts/shared/types.js + var inviteType = objectOf({ + inviteSecret: string, + quantity: number, + creator: string, + invitee: optional(string), + status: string, + responses: mapOf(string, string), + expires: number + }); + var chatRoomAttributesType = objectOf({ + name: string, + description: string, + type: unionOf(...Object.values(CHATROOM_TYPES).map((v) => literalOf(v))), + privacyLevel: unionOf(...Object.values(CHATROOM_PRIVACY_LEVEL).map((v) => literalOf(v))) + }); + var messageType = objectMaybeOf({ + type: unionOf(...Object.values(MESSAGE_TYPES).map((v) => literalOf(v))), + text: string, + proposal: objectMaybeOf({ + proposalId: string, + proposalType: string, + expires_date_ms: number, + createdDate: string, + creator: string, + variant: unionOf(...Object.values(PROPOSAL_VARIANTS).map((v) => literalOf(v))) + }), + notification: objectMaybeOf({ + type: unionOf(...Object.values(MESSAGE_NOTIFICATIONS).map((v) => literalOf(v))), + params: mapOf(string, string) + }), + replyingMessage: objectOf({ + hash: string, + text: string + }), + emoticons: mapOf(string, arrayOf(string)), + onlyVisibleTo: arrayOf(string) + }); + + // frontend/model/contracts/shared/functions.js + var import_sbp = __toESM(__require("@sbp/sbp")); + + // frontend/model/contracts/shared/time.js + var import_common = __require("@common/common.js"); + var MINS_MILLIS = 6e4; + var HOURS_MILLIS = 60 * MINS_MILLIS; + var DAYS_MILLIS = 24 * HOURS_MILLIS; + var MONTHS_MILLIS = 30 * DAYS_MILLIS; + + // frontend/views/utils/misc.js + function logExceptNavigationDuplicated(err) { + err.name !== "NavigationDuplicated" && console.error(err); + } + + // frontend/model/contracts/shared/functions.js + function createMessage({ meta, data, hash, id, state }) { + const { type, text, replyingMessage } = data; + const { createdDate } = meta; + let newMessage = { + type, + id, + hash, + from: meta.username, + datetime: new Date(createdDate).toISOString() + }; + if (type === MESSAGE_TYPES.TEXT) { + newMessage = !replyingMessage ? { ...newMessage, text } : { ...newMessage, text, replyingMessage }; + } else if (type === MESSAGE_TYPES.POLL) { + const pollData = data.pollData; + newMessage = { + ...newMessage, + pollData: { + ...pollData, + creator: meta.username, + status: POLL_STATUS.ACTIVE, + options: pollData.options.map((opt) => ({ ...opt, voted: [] })) + } + }; + } else if (type === MESSAGE_TYPES.NOTIFICATION) { + const params = { + channelName: state?.attributes.name, + channelDescription: state?.attributes.description, + ...data.notification + }; + delete params.type; + newMessage = { + ...newMessage, + notification: { type: data.notification.type, params } + }; + } else if (type === MESSAGE_TYPES.INTERACTIVE) { + newMessage = { + ...newMessage, + proposal: data.proposal + }; + } + return newMessage; + } + async function leaveChatRoom({ contractID }) { + const rootState = (0, import_sbp.default)("state/vuex/state"); + const rootGetters = (0, import_sbp.default)("state/vuex/getters"); + if (contractID === rootGetters.currentChatRoomId) { + (0, import_sbp.default)("state/vuex/commit", "setCurrentChatRoomId", { + groupId: rootState.currentGroupId + }); + const curRouteName = (0, import_sbp.default)("controller/router").history.current.name; + if (curRouteName === "GroupChat" || curRouteName === "GroupChatConversation") { + await (0, import_sbp.default)("controller/router").push({ name: "GroupChatConversation", params: { chatRoomId: rootGetters.currentChatRoomId } }).catch(logExceptNavigationDuplicated); + } + } + (0, import_sbp.default)("state/vuex/commit", "deleteChatRoomUnread", { chatRoomId: contractID }); + (0, import_sbp.default)("state/vuex/commit", "deleteChatRoomScrollPosition", { chatRoomId: contractID }); + (0, import_sbp.default)("chelonia/contract/remove", contractID).catch((e) => { + console.error(`leaveChatRoom(${contractID}): remove threw ${e.name}:`, e); + }); + } + function findMessageIdx(hash, messages) { + for (let i = messages.length - 1; i >= 0; i--) { + if (messages[i].hash === hash) { + return i; + } + } + return -1; + } + function makeMentionFromUsername(username) { + return { + me: `@${username}`, + all: "@all" + }; + } + + // frontend/model/contracts/shared/nativeNotification.js + var import_sbp2 = __toESM(__require("@sbp/sbp")); + function makeNotification({ title, body, icon, path }) { + if (Notification?.permission === "granted" && (0, import_sbp2.default)("state/vuex/settings").notificationEnabled) { + const notification = new Notification(title, { body, icon }); + if (path) { + notification.onclick = function(event) { + (0, import_sbp2.default)("controller/router").push({ path }).catch(console.warn); + }; + } + } + } + + // frontend/model/contracts/chatroom.js + function createNotificationData(notificationType, moreParams = {}) { + return { + type: MESSAGE_TYPES.NOTIFICATION, + notification: { + type: notificationType, + ...moreParams + } + }; + } + function emitMessageEvent({ contractID, hash }) { + if (!(0, import_sbp3.default)("chelonia/contract/isSyncing", contractID)) { + (0, import_sbp3.default)("okTurtles.events/emit", `${CHATROOM_MESSAGE_ACTION}-${contractID}`, { hash }); + } + } + function setReadUntilWhileJoining({ contractID, hash, createdDate }) { + if ((0, import_sbp3.default)("chelonia/contract/isSyncing", contractID, { firstSync: true })) { + (0, import_sbp3.default)("state/vuex/commit", "setChatRoomReadUntil", { + chatRoomId: contractID, + messageHash: hash, + createdDate + }); + } + } + function messageReceivePostEffect({ + contractID, + messageHash, + datetime, + text, + isDMOrMention, + messageType: messageType2, + username, + chatRoomName + }) { + if ((0, import_sbp3.default)("chelonia/contract/isSyncing", contractID)) { + return; + } + const rootGetters = (0, import_sbp3.default)("state/vuex/getters"); + const isDirectMessage = rootGetters.isDirectMessage(contractID); + const unreadMessageType = { + [MESSAGE_TYPES.TEXT]: isDMOrMention ? MESSAGE_TYPES.TEXT : void 0, + [MESSAGE_TYPES.INTERACTIVE]: MESSAGE_TYPES.INTERACTIVE, + [MESSAGE_TYPES.POLL]: MESSAGE_TYPES.POLL + }[messageType2]; + if (unreadMessageType) { + (0, import_sbp3.default)("state/vuex/commit", "addChatRoomUnreadMessage", { + chatRoomId: contractID, + messageHash, + createdDate: datetime, + type: unreadMessageType + }); + } + let title = `# ${chatRoomName}`; + let partnerProfile; + if (isDirectMessage) { + if (rootGetters.isGroupDirectMessage(contractID)) { + title = `# ${rootGetters.groupDirectMessageInfo(contractID).title}`; + } else { + partnerProfile = rootGetters.ourContactProfiles[username]; + title = `# ${partnerProfile?.displayName || username}`; + } + } + const path = `/group-chat/${contractID}`; + const chatNotificationSettings = rootGetters.chatNotificationSettings[contractID] || rootGetters.chatNotificationSettings.default; + const { messageNotification, messageSound } = chatNotificationSettings; + const shouldNotifyMessage = messageNotification === MESSAGE_NOTIFY_SETTINGS.ALL_MESSAGES || messageNotification === MESSAGE_NOTIFY_SETTINGS.DIRECT_MESSAGES && isDMOrMention; + const shouldSoundMessage = messageSound === MESSAGE_NOTIFY_SETTINGS.ALL_MESSAGES || messageSound === MESSAGE_NOTIFY_SETTINGS.DIRECT_MESSAGES && isDMOrMention; + shouldNotifyMessage && makeNotification({ title, body: text, icon: partnerProfile?.picture, path }); + shouldSoundMessage && (0, import_sbp3.default)("okTurtles.events/emit", MESSAGE_RECEIVE); + } + (0, import_sbp3.default)("chelonia/defineContract", { + name: "gi.contracts/chatroom", + metadata: { + validate: objectOf({ + createdDate: string, + username: string, + identityContractID: string + }), + async create() { + const { username, identityContractID } = (0, import_sbp3.default)("state/vuex/state").loggedIn; + return { + createdDate: await fetchServerTime(), + username, + identityContractID + }; + } + }, + getters: { + currentChatRoomState(state) { + return state; + }, + chatRoomSettings(state, getters) { + return getters.currentChatRoomState.settings || {}; + }, + chatRoomAttributes(state, getters) { + return getters.currentChatRoomState.attributes || {}; + }, + chatRoomUsers(state, getters) { + return getters.currentChatRoomState.users || {}; + }, + chatRoomLatestMessages(state, getters) { + return getters.currentChatRoomState.messages || []; + } + }, + actions: { + "gi.contracts/chatroom": { + validate: objectOf({ + attributes: chatRoomAttributesType + }), + process({ meta, data }, { state }) { + const initialState = merge({ + settings: { + actionsPerPage: CHATROOM_ACTIONS_PER_PAGE, + maxNameLength: CHATROOM_NAME_LIMITS_IN_CHARS, + maxDescriptionLength: CHATROOM_DESCRIPTION_LIMITS_IN_CHARS + }, + attributes: { + creator: meta.username, + deletedDate: null, + archivedDate: null + }, + users: {}, + messages: [] + }, data); + for (const key in initialState) { + import_common2.Vue.set(state, key, initialState[key]); + } + }, + sideEffect({ contractID }) { + import_common2.Vue.set((0, import_sbp3.default)("state/vuex/state").chatRoomUnread, contractID, { + readUntil: void 0, + messages: [] + }); + } + }, + "gi.contracts/chatroom/join": { + validate: objectOf({ + username: string + }), + process({ data, meta, hash, id }, { state }) { + const { username } = data; + if (!state.onlyRenderMessage && state.users[username]) { + console.warn("Can not join the chatroom which you are already part of"); + return; + } + import_common2.Vue.set(state.users, username, { joinedDate: meta.createdDate }); + const { type, privacyLevel } = state.attributes; + const isPrivateDM = type === CHATROOM_TYPES.INDIVIDUAL && privacyLevel === CHATROOM_PRIVACY_LEVEL.PRIVATE; + if (!state.onlyRenderMessage || isPrivateDM) { + return; + } + const notificationType = username === meta.username ? MESSAGE_NOTIFICATIONS.JOIN_MEMBER : MESSAGE_NOTIFICATIONS.ADD_MEMBER; + const notificationData = createNotificationData(notificationType, notificationType === MESSAGE_NOTIFICATIONS.ADD_MEMBER ? { username } : {}); + const newMessage = createMessage({ meta, hash, id, data: notificationData, state }); + state.messages.push(newMessage); + }, + sideEffect({ data, contractID, hash, meta }, { state }) { + emitMessageEvent({ contractID, hash }); + setReadUntilWhileJoining({ contractID, hash, createdDate: meta.createdDate }); + if (data.username === (0, import_sbp3.default)("state/vuex/state").loggedIn.username) { + const { type, privacyLevel } = state.attributes; + const isPrivateDM = type === CHATROOM_TYPES.INDIVIDUAL && privacyLevel === CHATROOM_PRIVACY_LEVEL.PRIVATE; + if (isPrivateDM) { + (0, import_sbp3.default)("state/vuex/commit", "deleteChatRoomReadUntil", { + chatRoomId: contractID, + deletedDate: meta.createdDate + }); + } + } + } + }, + "gi.contracts/chatroom/rename": { + validate: objectOf({ + name: string + }), + process({ data, meta, hash, id }, { state }) { + import_common2.Vue.set(state.attributes, "name", data.name); + if (!state.onlyRenderMessage) { + return; + } + const notificationData = createNotificationData(MESSAGE_NOTIFICATIONS.UPDATE_NAME, {}); + const newMessage = createMessage({ meta, hash, id, data: notificationData, state }); + state.messages.push(newMessage); + }, + sideEffect({ contractID, hash, meta }) { + emitMessageEvent({ contractID, hash }); + setReadUntilWhileJoining({ contractID, hash, createdDate: meta.createdDate }); + } + }, + "gi.contracts/chatroom/changeDescription": { + validate: objectOf({ + description: string + }), + process({ data, meta, hash, id }, { state }) { + import_common2.Vue.set(state.attributes, "description", data.description); + if (!state.onlyRenderMessage) { + return; + } + const notificationData = createNotificationData(MESSAGE_NOTIFICATIONS.UPDATE_DESCRIPTION, {}); + const newMessage = createMessage({ meta, hash, id, data: notificationData, state }); + state.messages.push(newMessage); + }, + sideEffect({ contractID, hash, meta }) { + emitMessageEvent({ contractID, hash }); + setReadUntilWhileJoining({ contractID, hash, createdDate: meta.createdDate }); + } + }, + "gi.contracts/chatroom/leave": { + validate: objectOf({ + username: optional(string), + member: string + }), + process({ data, meta, hash, id }, { state }) { + const { member } = data; + const isKicked = data.username && member !== data.username; + if (!state.onlyRenderMessage && !state.users[member]) { + throw new Error(`Can not leave the chatroom which ${member} are not part of`); + } + import_common2.Vue.delete(state.users, member); + if (!state.onlyRenderMessage || state.attributes.type === CHATROOM_TYPES.INDIVIDUAL) { + return; + } + const notificationType = !isKicked ? MESSAGE_NOTIFICATIONS.LEAVE_MEMBER : MESSAGE_NOTIFICATIONS.KICK_MEMBER; + const notificationData = createNotificationData(notificationType, isKicked ? { username: member } : {}); + const newMessage = createMessage({ + meta: isKicked ? meta : { ...meta, username: member }, + hash, + id, + data: notificationData, + state + }); + state.messages.push(newMessage); + }, + sideEffect({ data, hash, contractID, meta }) { + if (data.member === (0, import_sbp3.default)("state/vuex/state").loggedIn.username) { + if ((0, import_sbp3.default)("chelonia/contract/isSyncing", contractID)) { + return; + } + leaveChatRoom({ contractID }); + } else { + emitMessageEvent({ contractID, hash }); + setReadUntilWhileJoining({ contractID, hash, createdDate: meta.createdDate }); + } + } + }, + "gi.contracts/chatroom/delete": { + validate: (data, { state, meta }) => { + if (state.attributes.creator !== meta.username) { + throw new TypeError((0, import_common2.L)("Only the channel creator can delete channel.")); + } + }, + process({ data, meta }, { state }) { + import_common2.Vue.set(state.attributes, "deletedDate", meta.createdDate); + for (const username in state.users) { + import_common2.Vue.delete(state.users, username); + } + }, + sideEffect({ meta, contractID }, { state }) { + if ((0, import_sbp3.default)("chelonia/contract/isSyncing", contractID)) { + return; + } + leaveChatRoom({ contractID }); + } + }, + "gi.contracts/chatroom/addMessage": { + validate: messageType, + process({ data, meta, hash, id }, { state }) { + if (!state.onlyRenderMessage) { + return; + } + const pendingMsg = state.messages.find((msg) => msg.id === id && msg.pending); + if (pendingMsg) { + delete pendingMsg.pending; + pendingMsg.hash = hash; + } else { + state.messages.push(createMessage({ meta, data, hash, id, state })); + } + }, + sideEffect({ contractID, hash, id, meta, data }, { state, getters }) { + emitMessageEvent({ contractID, hash }); + setReadUntilWhileJoining({ contractID, hash, createdDate: meta.createdDate }); + const me = (0, import_sbp3.default)("state/vuex/state").loggedIn.username; + if (me === meta.username && data.type !== MESSAGE_TYPES.INTERACTIVE) { + return; + } + const newMessage = createMessage({ meta, data, hash, id, state }); + const mentions = makeMentionFromUsername(me); + const isMentionedMe = data.type === MESSAGE_TYPES.TEXT && (newMessage.text.includes(mentions.me) || newMessage.text.includes(mentions.all)); + messageReceivePostEffect({ + contractID, + messageHash: newMessage.hash, + datetime: newMessage.datetime, + text: newMessage.text, + isDMOrMention: isMentionedMe || getters.chatRoomAttributes.type === CHATROOM_TYPES.INDIVIDUAL, + messageType: data.type, + username: meta.username, + chatRoomName: getters.chatRoomAttributes.name + }); + } + }, + "gi.contracts/chatroom/editMessage": { + validate: objectOf({ + hash: string, + createdDate: string, + text: string + }), + process({ data, meta }, { state }) { + if (!state.onlyRenderMessage) { + return; + } + const msgIndex = findMessageIdx(data.hash, state.messages); + if (msgIndex >= 0 && meta.username === state.messages[msgIndex].from) { + state.messages[msgIndex].text = data.text; + state.messages[msgIndex].updatedDate = meta.createdDate; + if (state.onlyRenderMessage && state.messages[msgIndex].pending) { + delete state.messages[msgIndex].pending; + } + } + }, + sideEffect({ contractID, hash, meta, data }, { getters }) { + emitMessageEvent({ contractID, hash }); + const rootState = (0, import_sbp3.default)("state/vuex/state"); + const me = rootState.loggedIn.username; + if (me === meta.username || getters.chatRoomAttributes.type === CHATROOM_TYPES.INDIVIDUAL) { + return; + } + const isAlreadyAdded = !!(0, import_sbp3.default)("state/vuex/getters").chatRoomUnreadMessages(contractID).find((m) => m.messageHash === data.hash); + const mentions = makeMentionFromUsername(me); + const isMentionedMe = data.text.includes(mentions.me) || data.text.includes(mentions.all); + if (!isAlreadyAdded) { + messageReceivePostEffect({ + contractID, + messageHash: data.hash, + datetime: data.createdDate, + text: data.text, + isDMOrMention: isMentionedMe, + messageType: MESSAGE_TYPES.TEXT, + username: meta.username, + chatRoomName: getters.chatRoomAttributes.name + }); + } else if (!isMentionedMe) { + (0, import_sbp3.default)("state/vuex/commit", "deleteChatRoomUnreadMessage", { + chatRoomId: contractID, + messageHash: data.hash + }); + } + } + }, + "gi.contracts/chatroom/deleteMessage": { + validate: objectOf({ hash: string }), + process({ data, meta }, { state }) { + if (!state.onlyRenderMessage) { + return; + } + const msgIndex = findMessageIdx(data.hash, state.messages); + if (msgIndex >= 0) { + state.messages.splice(msgIndex, 1); + } + for (const message of state.messages) { + if (message.replyingMessage?.hash === data.hash) { + message.replyingMessage.hash = null; + message.replyingMessage.text = (0, import_common2.L)("Original message was removed by {username}", { + username: makeMentionFromUsername(meta.username).me + }); + } + } + }, + sideEffect({ data, contractID, hash, meta }) { + emitMessageEvent({ contractID, hash }); + const rootState = (0, import_sbp3.default)("state/vuex/state"); + const me = rootState.loggedIn.username; + if (rootState.chatRoomScrollPosition[contractID] === data.hash) { + (0, import_sbp3.default)("state/vuex/commit", "setChatRoomScrollPosition", { + chatRoomId: contractID, + messageHash: null + }); + } + if (rootState.chatRoomUnread[contractID].readUntil.messageHash === data.hash) { + (0, import_sbp3.default)("state/vuex/commit", "deleteChatRoomReadUntil", { + chatRoomId: contractID, + deletedDate: meta.createdDate + }); + } + if (me === meta.username) { + return; + } + (0, import_sbp3.default)("state/vuex/commit", "deleteChatRoomUnreadMessage", { + chatRoomId: contractID, + messageHash: data.hash + }); + } + }, + "gi.contracts/chatroom/makeEmotion": { + validate: objectOf({ + hash: string, + emoticon: string + }), + process({ data, meta, contractID }, { state }) { + if (!state.onlyRenderMessage) { + return; + } + const { hash, emoticon } = data; + const msgIndex = findMessageIdx(hash, state.messages); + if (msgIndex >= 0) { + let emoticons = cloneDeep(state.messages[msgIndex].emoticons || {}); + if (emoticons[emoticon]) { + const alreadyAdded = emoticons[emoticon].indexOf(meta.username); + if (alreadyAdded >= 0) { + emoticons[emoticon].splice(alreadyAdded, 1); + if (!emoticons[emoticon].length) { + delete emoticons[emoticon]; + if (!Object.keys(emoticons).length) { + emoticons = null; + } + } + } else { + emoticons[emoticon].push(meta.username); + } + } else { + emoticons[emoticon] = [meta.username]; + } + if (emoticons) { + import_common2.Vue.set(state.messages[msgIndex], "emoticons", emoticons); + } else { + import_common2.Vue.delete(state.messages[msgIndex], "emoticons"); + } + } + }, + sideEffect({ contractID, hash }) { + emitMessageEvent({ contractID, hash }); + } + }, + "gi.contracts/chatroom/voteOnPoll": { + validate: objectOf({ + hash: string, + votes: arrayOf(string), + votesAsString: string + }), + process({ data, meta, hash, id }, { state }) { + if (!state.onlyRenderMessage) { + return; + } + const msgIndex = findMessageIdx(data.hash, state.messages); + if (msgIndex >= 0) { + const myVotes = data.votes; + const pollData = state.messages[msgIndex].pollData; + const optsCopy = cloneDeep(pollData.options); + const votedOptNames = []; + myVotes.forEach((optId) => { + const foundOpt = optsCopy.find((x) => x.id === optId); + if (foundOpt) { + foundOpt.voted.push(meta.username); + votedOptNames.push(`"${foundOpt.value}"`); + } + }); + import_common2.Vue.set(state.messages[msgIndex], "pollData", { ...pollData, options: optsCopy }); + } + const notificationData = createNotificationData(MESSAGE_NOTIFICATIONS.VOTE_ON_POLL, { + votedOptions: data.votesAsString, + pollMessageHash: data.hash + }); + const newMessage = createMessage({ meta, hash, id, data: notificationData, state }); + state.messages.push(newMessage); + }, + sideEffect({ contractID, hash, meta }) { + emitMessageEvent({ contractID, hash }); + setReadUntilWhileJoining({ contractID, hash, createdDate: meta.createdDate }); + } + }, + "gi.contracts/chatroom/changeVoteOnPoll": { + validate: objectOf({ + hash: string, + votes: arrayOf(string), + votesAsString: string + }), + process({ data, meta, hash, id }, { state }) { + if (!state.onlyRenderMessage) { + return; + } + const msgIndex = findMessageIdx(data.hash, state.messages); + if (msgIndex >= 0) { + const me = meta.username; + const myUpdatedVotes = data.votes; + const pollData = state.messages[msgIndex].pollData; + const optsCopy = cloneDeep(pollData.options); + const votedOptNames = []; + optsCopy.forEach((opt) => { + opt.voted = opt.voted.filter((votername) => votername !== me); + }); + myUpdatedVotes.forEach((optId) => { + const foundOpt = optsCopy.find((x) => x.id === optId); + if (foundOpt) { + foundOpt.voted.push(me); + votedOptNames.push(`"${foundOpt.value}"`); + } + }); + import_common2.Vue.set(state.messages[msgIndex], "pollData", { ...pollData, options: optsCopy }); + } + const notificationData = createNotificationData(MESSAGE_NOTIFICATIONS.CHANGE_VOTE_ON_POLL, { + votedOptions: data.votesAsString, + pollMessageHash: data.hash + }); + const newMessage = createMessage({ meta, hash, id, data: notificationData, state }); + state.messages.push(newMessage); + }, + sideEffect({ contractID, hash, meta }) { + emitMessageEvent({ contractID, hash }); + setReadUntilWhileJoining({ contractID, hash, createdDate: meta.createdDate }); + } + }, + "gi.contracts/chatroom/closePoll": { + validate: objectOf({ + hash: string + }), + process({ data }, { state }) { + if (!state.onlyRenderMessage) { + return; + } + const msgIndex = findMessageIdx(data.hash, state.messages); + if (msgIndex >= 0) { + const pollData = state.messages[msgIndex].pollData; + import_common2.Vue.set(state.messages[msgIndex], "pollData", { ...pollData, status: POLL_STATUS.CLOSED }); + } + }, + sideEffect({ contractID, hash }) { + emitMessageEvent({ contractID, hash }); + } + } + } + }); +})(); diff --git a/contracts/0.1.7/chatroom.0.1.7.manifest.json b/contracts/0.1.7/chatroom.0.1.7.manifest.json new file mode 100644 index 0000000000..89b2940031 --- /dev/null +++ b/contracts/0.1.7/chatroom.0.1.7.manifest.json @@ -0,0 +1 @@ +{"head":{"manifestVersion":"1.0.0"},"body":"{\"version\":\"0.1.7\",\"contract\":{\"hash\":\"21XWnNSbTzDVk7QNPYi5n1C8w34ivhT2Xp91CWz1itVdhNjFqX\",\"file\":\"chatroom.js\"},\"authors\":[{\"cipher\":\"algo\",\"key\":\"\"},{\"cipher\":\"algo\",\"key\":\"\"}],\"contractSlim\":{\"file\":\"chatroom-slim.js\",\"hash\":\"21XWnNN7LxitcRpsam5GmmsBJtwY7eekM5cBEdLUJNGCwPXnPE\"}}","signature":{"key":"","signature":""}} \ No newline at end of file diff --git a/contracts/0.1.7/chatroom.js b/contracts/0.1.7/chatroom.js new file mode 100644 index 0000000000..f24e8d6cd6 --- /dev/null +++ b/contracts/0.1.7/chatroom.js @@ -0,0 +1,10063 @@ +"use strict"; +(() => { + var __create = Object.create; + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __getProtoOf = Object.getPrototypeOf; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { + get: (a, b) => (typeof require !== "undefined" ? require : a)[b] + }) : x)(function(x) { + if (typeof require !== "undefined") + return require.apply(this, arguments); + throw new Error('Dynamic require of "' + x + '" is not supported'); + }); + var __commonJS = (cb, mod) => function __require2() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; + var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; + }; + var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2, mod)); + + // node_modules/dompurify/dist/purify.js + var require_purify = __commonJS({ + "node_modules/dompurify/dist/purify.js"(exports, module) { + (function(global2, factory) { + typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global2 = global2 || self, global2.DOMPurify = factory()); + })(exports, function() { + "use strict"; + function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { + arr2[i] = arr[i]; + } + return arr2; + } else { + return Array.from(arr); + } + } + var hasOwnProperty2 = Object.hasOwnProperty, setPrototypeOf = Object.setPrototypeOf, isFrozen = Object.isFrozen, getPrototypeOf = Object.getPrototypeOf, getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + var freeze = Object.freeze, seal = Object.seal, create2 = Object.create; + var _ref = typeof Reflect !== "undefined" && Reflect, apply = _ref.apply, construct = _ref.construct; + if (!apply) { + apply = function apply2(fun, thisValue, args) { + return fun.apply(thisValue, args); + }; + } + if (!freeze) { + freeze = function freeze2(x) { + return x; + }; + } + if (!seal) { + seal = function seal2(x) { + return x; + }; + } + if (!construct) { + construct = function construct2(Func, args) { + return new (Function.prototype.bind.apply(Func, [null].concat(_toConsumableArray(args))))(); + }; + } + var arrayForEach = unapply(Array.prototype.forEach); + var arrayPop = unapply(Array.prototype.pop); + var arrayPush = unapply(Array.prototype.push); + var stringToLowerCase = unapply(String.prototype.toLowerCase); + var stringMatch = unapply(String.prototype.match); + var stringReplace = unapply(String.prototype.replace); + var stringIndexOf = unapply(String.prototype.indexOf); + var stringTrim = unapply(String.prototype.trim); + var regExpTest = unapply(RegExp.prototype.test); + var typeErrorCreate = unconstruct(TypeError); + function unapply(func) { + return function(thisArg) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + return apply(func, thisArg, args); + }; + } + function unconstruct(func) { + return function() { + for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + return construct(func, args); + }; + } + function addToSet(set2, array) { + if (setPrototypeOf) { + setPrototypeOf(set2, null); + } + var l = array.length; + while (l--) { + var element = array[l]; + if (typeof element === "string") { + var lcElement = stringToLowerCase(element); + if (lcElement !== element) { + if (!isFrozen(array)) { + array[l] = lcElement; + } + element = lcElement; + } + } + set2[element] = true; + } + return set2; + } + function clone(object2) { + var newObject = create2(null); + var property = void 0; + for (property in object2) { + if (apply(hasOwnProperty2, object2, [property])) { + newObject[property] = object2[property]; + } + } + return newObject; + } + function lookupGetter(object2, prop) { + while (object2 !== null) { + var desc = getOwnPropertyDescriptor(object2, prop); + if (desc) { + if (desc.get) { + return unapply(desc.get); + } + if (typeof desc.value === "function") { + return unapply(desc.value); + } + } + object2 = getPrototypeOf(object2); + } + function fallbackValue(element) { + console.warn("fallback value for", element); + return null; + } + return fallbackValue; + } + var html2 = freeze(["a", "abbr", "acronym", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "big", "blink", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "content", "data", "datalist", "dd", "decorator", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "element", "em", "fieldset", "figcaption", "figure", "font", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "marquee", "menu", "menuitem", "meter", "nav", "nobr", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "section", "select", "shadow", "small", "source", "spacer", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "tt", "u", "ul", "var", "video", "wbr"]); + var svg = freeze(["svg", "a", "altglyph", "altglyphdef", "altglyphitem", "animatecolor", "animatemotion", "animatetransform", "circle", "clippath", "defs", "desc", "ellipse", "filter", "font", "g", "glyph", "glyphref", "hkern", "image", "line", "lineargradient", "marker", "mask", "metadata", "mpath", "path", "pattern", "polygon", "polyline", "radialgradient", "rect", "stop", "style", "switch", "symbol", "text", "textpath", "title", "tref", "tspan", "view", "vkern"]); + var svgFilters = freeze(["feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence"]); + var svgDisallowed = freeze(["animate", "color-profile", "cursor", "discard", "fedropshadow", "feimage", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "foreignobject", "hatch", "hatchpath", "mesh", "meshgradient", "meshpatch", "meshrow", "missing-glyph", "script", "set", "solidcolor", "unknown", "use"]); + var mathMl = freeze(["math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi", "mlabeledtr", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msup", "msubsup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover"]); + var mathMlDisallowed = freeze(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]); + var text2 = freeze(["#text"]); + var html$1 = freeze(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "noshade", "novalidate", "nowrap", "open", "optimum", "pattern", "placeholder", "playsinline", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "xmlns"]); + var svg$1 = freeze(["accent-height", "accumulate", "additive", "alignment-baseline", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dur", "edgemode", "elevation", "end", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "targetx", "targety", "transform", "text-anchor", "text-decoration", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]); + var mathMl$1 = freeze(["accent", "accentunder", "align", "bevelled", "close", "columnsalign", "columnlines", "columnspan", "denomalign", "depth", "dir", "display", "displaystyle", "encoding", "fence", "frame", "height", "href", "id", "largeop", "length", "linethickness", "lspace", "lquote", "mathbackground", "mathcolor", "mathsize", "mathvariant", "maxsize", "minsize", "movablelimits", "notation", "numalign", "open", "rowalign", "rowlines", "rowspacing", "rowspan", "rspace", "rquote", "scriptlevel", "scriptminsize", "scriptsizemultiplier", "selection", "separator", "separators", "stretchy", "subscriptshift", "supscriptshift", "symmetric", "voffset", "width", "xmlns"]); + var xml = freeze(["xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"]); + var MUSTACHE_EXPR = seal(/\{\{[\s\S]*|[\s\S]*\}\}/gm); + var ERB_EXPR = seal(/<%[\s\S]*|[\s\S]*%>/gm); + var DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]/); + var ARIA_ATTR = seal(/^aria-[\-\w]+$/); + var IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i); + var IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i); + var ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g); + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + function _toConsumableArray$1(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { + arr2[i] = arr[i]; + } + return arr2; + } else { + return Array.from(arr); + } + } + var getGlobal = function getGlobal2() { + return typeof window === "undefined" ? null : window; + }; + var _createTrustedTypesPolicy = function _createTrustedTypesPolicy2(trustedTypes, document2) { + if ((typeof trustedTypes === "undefined" ? "undefined" : _typeof(trustedTypes)) !== "object" || typeof trustedTypes.createPolicy !== "function") { + return null; + } + var suffix = null; + var ATTR_NAME = "data-tt-policy-suffix"; + if (document2.currentScript && document2.currentScript.hasAttribute(ATTR_NAME)) { + suffix = document2.currentScript.getAttribute(ATTR_NAME); + } + var policyName = "dompurify" + (suffix ? "#" + suffix : ""); + try { + return trustedTypes.createPolicy(policyName, { + createHTML: function createHTML(html$$1) { + return html$$1; + } + }); + } catch (_) { + console.warn("TrustedTypes policy " + policyName + " could not be created."); + return null; + } + }; + function createDOMPurify() { + var window2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal(); + var DOMPurify = function DOMPurify2(root) { + return createDOMPurify(root); + }; + DOMPurify.version = "2.2.7"; + DOMPurify.removed = []; + if (!window2 || !window2.document || window2.document.nodeType !== 9) { + DOMPurify.isSupported = false; + return DOMPurify; + } + var originalDocument = window2.document; + var document2 = window2.document; + var DocumentFragment = window2.DocumentFragment, HTMLTemplateElement = window2.HTMLTemplateElement, Node = window2.Node, Element = window2.Element, NodeFilter = window2.NodeFilter, _window$NamedNodeMap = window2.NamedNodeMap, NamedNodeMap = _window$NamedNodeMap === void 0 ? window2.NamedNodeMap || window2.MozNamedAttrMap : _window$NamedNodeMap, Text = window2.Text, Comment = window2.Comment, DOMParser = window2.DOMParser, trustedTypes = window2.trustedTypes; + var ElementPrototype = Element.prototype; + var cloneNode = lookupGetter(ElementPrototype, "cloneNode"); + var getNextSibling = lookupGetter(ElementPrototype, "nextSibling"); + var getChildNodes = lookupGetter(ElementPrototype, "childNodes"); + var getParentNode = lookupGetter(ElementPrototype, "parentNode"); + if (typeof HTMLTemplateElement === "function") { + var template2 = document2.createElement("template"); + if (template2.content && template2.content.ownerDocument) { + document2 = template2.content.ownerDocument; + } + } + var trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, originalDocument); + var emptyHTML = trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML("") : ""; + var _document = document2, implementation = _document.implementation, createNodeIterator = _document.createNodeIterator, getElementsByTagName = _document.getElementsByTagName, createDocumentFragment = _document.createDocumentFragment; + var importNode = originalDocument.importNode; + var documentMode = {}; + try { + documentMode = clone(document2).documentMode ? document2.documentMode : {}; + } catch (_) { + } + var hooks2 = {}; + DOMPurify.isSupported = typeof getParentNode === "function" && implementation && typeof implementation.createHTMLDocument !== "undefined" && documentMode !== 9; + var MUSTACHE_EXPR$$1 = MUSTACHE_EXPR, ERB_EXPR$$1 = ERB_EXPR, DATA_ATTR$$1 = DATA_ATTR, ARIA_ATTR$$1 = ARIA_ATTR, IS_SCRIPT_OR_DATA$$1 = IS_SCRIPT_OR_DATA, ATTR_WHITESPACE$$1 = ATTR_WHITESPACE; + var IS_ALLOWED_URI$$1 = IS_ALLOWED_URI; + var ALLOWED_TAGS = null; + var DEFAULT_ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(html2), _toConsumableArray$1(svg), _toConsumableArray$1(svgFilters), _toConsumableArray$1(mathMl), _toConsumableArray$1(text2))); + var ALLOWED_ATTR = null; + var DEFAULT_ALLOWED_ATTR = addToSet({}, [].concat(_toConsumableArray$1(html$1), _toConsumableArray$1(svg$1), _toConsumableArray$1(mathMl$1), _toConsumableArray$1(xml))); + var FORBID_TAGS = null; + var FORBID_ATTR = null; + var ALLOW_ARIA_ATTR = true; + var ALLOW_DATA_ATTR = true; + var ALLOW_UNKNOWN_PROTOCOLS = false; + var SAFE_FOR_TEMPLATES = false; + var WHOLE_DOCUMENT = false; + var SET_CONFIG = false; + var FORCE_BODY = false; + var RETURN_DOM = false; + var RETURN_DOM_FRAGMENT = false; + var RETURN_DOM_IMPORT = true; + var RETURN_TRUSTED_TYPE = false; + var SANITIZE_DOM = true; + var KEEP_CONTENT = true; + var IN_PLACE = false; + var USE_PROFILES = {}; + var FORBID_CONTENTS = addToSet({}, ["annotation-xml", "audio", "colgroup", "desc", "foreignobject", "head", "iframe", "math", "mi", "mn", "mo", "ms", "mtext", "noembed", "noframes", "noscript", "plaintext", "script", "style", "svg", "template", "thead", "title", "video", "xmp"]); + var DATA_URI_TAGS = null; + var DEFAULT_DATA_URI_TAGS = addToSet({}, ["audio", "video", "img", "source", "image", "track"]); + var URI_SAFE_ATTRIBUTES = null; + var DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ["alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "summary", "title", "value", "style", "xmlns"]); + var CONFIG = null; + var formElement = document2.createElement("form"); + var _parseConfig = function _parseConfig2(cfg) { + if (CONFIG && CONFIG === cfg) { + return; + } + if (!cfg || (typeof cfg === "undefined" ? "undefined" : _typeof(cfg)) !== "object") { + cfg = {}; + } + cfg = clone(cfg); + ALLOWED_TAGS = "ALLOWED_TAGS" in cfg ? addToSet({}, cfg.ALLOWED_TAGS) : DEFAULT_ALLOWED_TAGS; + ALLOWED_ATTR = "ALLOWED_ATTR" in cfg ? addToSet({}, cfg.ALLOWED_ATTR) : DEFAULT_ALLOWED_ATTR; + URI_SAFE_ATTRIBUTES = "ADD_URI_SAFE_ATTR" in cfg ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR) : DEFAULT_URI_SAFE_ATTRIBUTES; + DATA_URI_TAGS = "ADD_DATA_URI_TAGS" in cfg ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS) : DEFAULT_DATA_URI_TAGS; + FORBID_TAGS = "FORBID_TAGS" in cfg ? addToSet({}, cfg.FORBID_TAGS) : {}; + FORBID_ATTR = "FORBID_ATTR" in cfg ? addToSet({}, cfg.FORBID_ATTR) : {}; + USE_PROFILES = "USE_PROFILES" in cfg ? cfg.USE_PROFILES : false; + ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; + ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; + ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; + SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; + WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; + RETURN_DOM = cfg.RETURN_DOM || false; + RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; + RETURN_DOM_IMPORT = cfg.RETURN_DOM_IMPORT !== false; + RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; + FORCE_BODY = cfg.FORCE_BODY || false; + SANITIZE_DOM = cfg.SANITIZE_DOM !== false; + KEEP_CONTENT = cfg.KEEP_CONTENT !== false; + IN_PLACE = cfg.IN_PLACE || false; + IS_ALLOWED_URI$$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI$$1; + if (SAFE_FOR_TEMPLATES) { + ALLOW_DATA_ATTR = false; + } + if (RETURN_DOM_FRAGMENT) { + RETURN_DOM = true; + } + if (USE_PROFILES) { + ALLOWED_TAGS = addToSet({}, [].concat(_toConsumableArray$1(text2))); + ALLOWED_ATTR = []; + if (USE_PROFILES.html === true) { + addToSet(ALLOWED_TAGS, html2); + addToSet(ALLOWED_ATTR, html$1); + } + if (USE_PROFILES.svg === true) { + addToSet(ALLOWED_TAGS, svg); + addToSet(ALLOWED_ATTR, svg$1); + addToSet(ALLOWED_ATTR, xml); + } + if (USE_PROFILES.svgFilters === true) { + addToSet(ALLOWED_TAGS, svgFilters); + addToSet(ALLOWED_ATTR, svg$1); + addToSet(ALLOWED_ATTR, xml); + } + if (USE_PROFILES.mathMl === true) { + addToSet(ALLOWED_TAGS, mathMl); + addToSet(ALLOWED_ATTR, mathMl$1); + addToSet(ALLOWED_ATTR, xml); + } + } + if (cfg.ADD_TAGS) { + if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) { + ALLOWED_TAGS = clone(ALLOWED_TAGS); + } + addToSet(ALLOWED_TAGS, cfg.ADD_TAGS); + } + if (cfg.ADD_ATTR) { + if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) { + ALLOWED_ATTR = clone(ALLOWED_ATTR); + } + addToSet(ALLOWED_ATTR, cfg.ADD_ATTR); + } + if (cfg.ADD_URI_SAFE_ATTR) { + addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR); + } + if (KEEP_CONTENT) { + ALLOWED_TAGS["#text"] = true; + } + if (WHOLE_DOCUMENT) { + addToSet(ALLOWED_TAGS, ["html", "head", "body"]); + } + if (ALLOWED_TAGS.table) { + addToSet(ALLOWED_TAGS, ["tbody"]); + delete FORBID_TAGS.tbody; + } + if (freeze) { + freeze(cfg); + } + CONFIG = cfg; + }; + var MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ["mi", "mo", "mn", "ms", "mtext"]); + var HTML_INTEGRATION_POINTS = addToSet({}, ["foreignobject", "desc", "title", "annotation-xml"]); + var ALL_SVG_TAGS = addToSet({}, svg); + addToSet(ALL_SVG_TAGS, svgFilters); + addToSet(ALL_SVG_TAGS, svgDisallowed); + var ALL_MATHML_TAGS = addToSet({}, mathMl); + addToSet(ALL_MATHML_TAGS, mathMlDisallowed); + var MATHML_NAMESPACE = "http://www.w3.org/1998/Math/MathML"; + var SVG_NAMESPACE = "http://www.w3.org/2000/svg"; + var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml"; + var _checkValidNamespace = function _checkValidNamespace2(element) { + var parent = getParentNode(element); + if (!parent || !parent.tagName) { + parent = { + namespaceURI: HTML_NAMESPACE, + tagName: "template" + }; + } + var tagName2 = stringToLowerCase(element.tagName); + var parentTagName = stringToLowerCase(parent.tagName); + if (element.namespaceURI === SVG_NAMESPACE) { + if (parent.namespaceURI === HTML_NAMESPACE) { + return tagName2 === "svg"; + } + if (parent.namespaceURI === MATHML_NAMESPACE) { + return tagName2 === "svg" && (parentTagName === "annotation-xml" || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]); + } + return Boolean(ALL_SVG_TAGS[tagName2]); + } + if (element.namespaceURI === MATHML_NAMESPACE) { + if (parent.namespaceURI === HTML_NAMESPACE) { + return tagName2 === "math"; + } + if (parent.namespaceURI === SVG_NAMESPACE) { + return tagName2 === "math" && HTML_INTEGRATION_POINTS[parentTagName]; + } + return Boolean(ALL_MATHML_TAGS[tagName2]); + } + if (element.namespaceURI === HTML_NAMESPACE) { + if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) { + return false; + } + if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) { + return false; + } + var commonSvgAndHTMLElements = addToSet({}, ["title", "style", "font", "a", "script"]); + return !ALL_MATHML_TAGS[tagName2] && (commonSvgAndHTMLElements[tagName2] || !ALL_SVG_TAGS[tagName2]); + } + return false; + }; + var _forceRemove = function _forceRemove2(node) { + arrayPush(DOMPurify.removed, { element: node }); + try { + node.parentNode.removeChild(node); + } catch (_) { + try { + node.outerHTML = emptyHTML; + } catch (_2) { + node.remove(); + } + } + }; + var _removeAttribute = function _removeAttribute2(name, node) { + try { + arrayPush(DOMPurify.removed, { + attribute: node.getAttributeNode(name), + from: node + }); + } catch (_) { + arrayPush(DOMPurify.removed, { + attribute: null, + from: node + }); + } + node.removeAttribute(name); + if (name === "is" && !ALLOWED_ATTR[name]) { + if (RETURN_DOM || RETURN_DOM_FRAGMENT) { + try { + _forceRemove(node); + } catch (_) { + } + } else { + try { + node.setAttribute(name, ""); + } catch (_) { + } + } + } + }; + var _initDocument = function _initDocument2(dirty) { + var doc = void 0; + var leadingWhitespace = void 0; + if (FORCE_BODY) { + dirty = "" + dirty; + } else { + var matches2 = stringMatch(dirty, /^[\r\n\t ]+/); + leadingWhitespace = matches2 && matches2[0]; + } + var dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty; + try { + doc = new DOMParser().parseFromString(dirtyPayload, "text/html"); + } catch (_) { + } + if (!doc || !doc.documentElement) { + doc = implementation.createHTMLDocument(""); + var _doc = doc, body = _doc.body; + body.parentNode.removeChild(body.parentNode.firstElementChild); + body.outerHTML = dirtyPayload; + } + if (dirty && leadingWhitespace) { + doc.body.insertBefore(document2.createTextNode(leadingWhitespace), doc.body.childNodes[0] || null); + } + return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? "html" : "body")[0]; + }; + var _createIterator = function _createIterator2(root) { + return createNodeIterator.call(root.ownerDocument || root, root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT, function() { + return NodeFilter.FILTER_ACCEPT; + }, false); + }; + var _isClobbered = function _isClobbered2(elm) { + if (elm instanceof Text || elm instanceof Comment) { + return false; + } + if (typeof elm.nodeName !== "string" || typeof elm.textContent !== "string" || typeof elm.removeChild !== "function" || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== "function" || typeof elm.setAttribute !== "function" || typeof elm.namespaceURI !== "string" || typeof elm.insertBefore !== "function") { + return true; + } + return false; + }; + var _isNode = function _isNode2(object2) { + return (typeof Node === "undefined" ? "undefined" : _typeof(Node)) === "object" ? object2 instanceof Node : object2 && (typeof object2 === "undefined" ? "undefined" : _typeof(object2)) === "object" && typeof object2.nodeType === "number" && typeof object2.nodeName === "string"; + }; + var _executeHook = function _executeHook2(entryPoint, currentNode, data) { + if (!hooks2[entryPoint]) { + return; + } + arrayForEach(hooks2[entryPoint], function(hook) { + hook.call(DOMPurify, currentNode, data, CONFIG); + }); + }; + var _sanitizeElements = function _sanitizeElements2(currentNode) { + var content = void 0; + _executeHook("beforeSanitizeElements", currentNode, null); + if (_isClobbered(currentNode)) { + _forceRemove(currentNode); + return true; + } + if (stringMatch(currentNode.nodeName, /[\u0080-\uFFFF]/)) { + _forceRemove(currentNode); + return true; + } + var tagName2 = stringToLowerCase(currentNode.nodeName); + _executeHook("uponSanitizeElement", currentNode, { + tagName: tagName2, + allowedTags: ALLOWED_TAGS + }); + if (!_isNode(currentNode.firstElementChild) && (!_isNode(currentNode.content) || !_isNode(currentNode.content.firstElementChild)) && regExpTest(/<[/\w]/g, currentNode.innerHTML) && regExpTest(/<[/\w]/g, currentNode.textContent)) { + _forceRemove(currentNode); + return true; + } + if (!ALLOWED_TAGS[tagName2] || FORBID_TAGS[tagName2]) { + if (KEEP_CONTENT && !FORBID_CONTENTS[tagName2]) { + var parentNode2 = getParentNode(currentNode); + var childNodes = getChildNodes(currentNode); + if (childNodes && parentNode2) { + var childCount = childNodes.length; + for (var i = childCount - 1; i >= 0; --i) { + parentNode2.insertBefore(cloneNode(childNodes[i], true), getNextSibling(currentNode)); + } + } + } + _forceRemove(currentNode); + return true; + } + if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) { + _forceRemove(currentNode); + return true; + } + if ((tagName2 === "noscript" || tagName2 === "noembed") && regExpTest(/<\/no(script|embed)/i, currentNode.innerHTML)) { + _forceRemove(currentNode); + return true; + } + if (SAFE_FOR_TEMPLATES && currentNode.nodeType === 3) { + content = currentNode.textContent; + content = stringReplace(content, MUSTACHE_EXPR$$1, " "); + content = stringReplace(content, ERB_EXPR$$1, " "); + if (currentNode.textContent !== content) { + arrayPush(DOMPurify.removed, { element: currentNode.cloneNode() }); + currentNode.textContent = content; + } + } + _executeHook("afterSanitizeElements", currentNode, null); + return false; + }; + var _isValidAttribute = function _isValidAttribute2(lcTag, lcName, value) { + if (SANITIZE_DOM && (lcName === "id" || lcName === "name") && (value in document2 || value in formElement)) { + return false; + } + if (ALLOW_DATA_ATTR && regExpTest(DATA_ATTR$$1, lcName)) + ; + else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR$$1, lcName)) + ; + else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) { + return false; + } else if (URI_SAFE_ATTRIBUTES[lcName]) + ; + else if (regExpTest(IS_ALLOWED_URI$$1, stringReplace(value, ATTR_WHITESPACE$$1, ""))) + ; + else if ((lcName === "src" || lcName === "xlink:href" || lcName === "href") && lcTag !== "script" && stringIndexOf(value, "data:") === 0 && DATA_URI_TAGS[lcTag]) + ; + else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA$$1, stringReplace(value, ATTR_WHITESPACE$$1, ""))) + ; + else if (!value) + ; + else { + return false; + } + return true; + }; + var _sanitizeAttributes = function _sanitizeAttributes2(currentNode) { + var attr = void 0; + var value = void 0; + var lcName = void 0; + var l = void 0; + _executeHook("beforeSanitizeAttributes", currentNode, null); + var attributes = currentNode.attributes; + if (!attributes) { + return; + } + var hookEvent = { + attrName: "", + attrValue: "", + keepAttr: true, + allowedAttributes: ALLOWED_ATTR + }; + l = attributes.length; + while (l--) { + attr = attributes[l]; + var _attr = attr, name = _attr.name, namespaceURI = _attr.namespaceURI; + value = stringTrim(attr.value); + lcName = stringToLowerCase(name); + hookEvent.attrName = lcName; + hookEvent.attrValue = value; + hookEvent.keepAttr = true; + hookEvent.forceKeepAttr = void 0; + _executeHook("uponSanitizeAttribute", currentNode, hookEvent); + value = hookEvent.attrValue; + if (hookEvent.forceKeepAttr) { + continue; + } + _removeAttribute(name, currentNode); + if (!hookEvent.keepAttr) { + continue; + } + if (regExpTest(/\/>/i, value)) { + _removeAttribute(name, currentNode); + continue; + } + if (SAFE_FOR_TEMPLATES) { + value = stringReplace(value, MUSTACHE_EXPR$$1, " "); + value = stringReplace(value, ERB_EXPR$$1, " "); + } + var lcTag = currentNode.nodeName.toLowerCase(); + if (!_isValidAttribute(lcTag, lcName, value)) { + continue; + } + try { + if (namespaceURI) { + currentNode.setAttributeNS(namespaceURI, name, value); + } else { + currentNode.setAttribute(name, value); + } + arrayPop(DOMPurify.removed); + } catch (_) { + } + } + _executeHook("afterSanitizeAttributes", currentNode, null); + }; + var _sanitizeShadowDOM = function _sanitizeShadowDOM2(fragment) { + var shadowNode = void 0; + var shadowIterator = _createIterator(fragment); + _executeHook("beforeSanitizeShadowDOM", fragment, null); + while (shadowNode = shadowIterator.nextNode()) { + _executeHook("uponSanitizeShadowNode", shadowNode, null); + if (_sanitizeElements(shadowNode)) { + continue; + } + if (shadowNode.content instanceof DocumentFragment) { + _sanitizeShadowDOM2(shadowNode.content); + } + _sanitizeAttributes(shadowNode); + } + _executeHook("afterSanitizeShadowDOM", fragment, null); + }; + DOMPurify.sanitize = function(dirty, cfg) { + var body = void 0; + var importedNode = void 0; + var currentNode = void 0; + var oldNode = void 0; + var returnNode = void 0; + if (!dirty) { + dirty = ""; + } + if (typeof dirty !== "string" && !_isNode(dirty)) { + if (typeof dirty.toString !== "function") { + throw typeErrorCreate("toString is not a function"); + } else { + dirty = dirty.toString(); + if (typeof dirty !== "string") { + throw typeErrorCreate("dirty is not a string, aborting"); + } + } + } + if (!DOMPurify.isSupported) { + if (_typeof(window2.toStaticHTML) === "object" || typeof window2.toStaticHTML === "function") { + if (typeof dirty === "string") { + return window2.toStaticHTML(dirty); + } + if (_isNode(dirty)) { + return window2.toStaticHTML(dirty.outerHTML); + } + } + return dirty; + } + if (!SET_CONFIG) { + _parseConfig(cfg); + } + DOMPurify.removed = []; + if (typeof dirty === "string") { + IN_PLACE = false; + } + if (IN_PLACE) + ; + else if (dirty instanceof Node) { + body = _initDocument(""); + importedNode = body.ownerDocument.importNode(dirty, true); + if (importedNode.nodeType === 1 && importedNode.nodeName === "BODY") { + body = importedNode; + } else if (importedNode.nodeName === "HTML") { + body = importedNode; + } else { + body.appendChild(importedNode); + } + } else { + if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT && dirty.indexOf("<") === -1) { + return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty; + } + body = _initDocument(dirty); + if (!body) { + return RETURN_DOM ? null : emptyHTML; + } + } + if (body && FORCE_BODY) { + _forceRemove(body.firstChild); + } + var nodeIterator = _createIterator(IN_PLACE ? dirty : body); + while (currentNode = nodeIterator.nextNode()) { + if (currentNode.nodeType === 3 && currentNode === oldNode) { + continue; + } + if (_sanitizeElements(currentNode)) { + continue; + } + if (currentNode.content instanceof DocumentFragment) { + _sanitizeShadowDOM(currentNode.content); + } + _sanitizeAttributes(currentNode); + oldNode = currentNode; + } + oldNode = null; + if (IN_PLACE) { + return dirty; + } + if (RETURN_DOM) { + if (RETURN_DOM_FRAGMENT) { + returnNode = createDocumentFragment.call(body.ownerDocument); + while (body.firstChild) { + returnNode.appendChild(body.firstChild); + } + } else { + returnNode = body; + } + if (RETURN_DOM_IMPORT) { + returnNode = importNode.call(originalDocument, returnNode, true); + } + return returnNode; + } + var serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML; + if (SAFE_FOR_TEMPLATES) { + serializedHTML = stringReplace(serializedHTML, MUSTACHE_EXPR$$1, " "); + serializedHTML = stringReplace(serializedHTML, ERB_EXPR$$1, " "); + } + return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML; + }; + DOMPurify.setConfig = function(cfg) { + _parseConfig(cfg); + SET_CONFIG = true; + }; + DOMPurify.clearConfig = function() { + CONFIG = null; + SET_CONFIG = false; + }; + DOMPurify.isValidAttribute = function(tag, attr, value) { + if (!CONFIG) { + _parseConfig({}); + } + var lcTag = stringToLowerCase(tag); + var lcName = stringToLowerCase(attr); + return _isValidAttribute(lcTag, lcName, value); + }; + DOMPurify.addHook = function(entryPoint, hookFunction) { + if (typeof hookFunction !== "function") { + return; + } + hooks2[entryPoint] = hooks2[entryPoint] || []; + arrayPush(hooks2[entryPoint], hookFunction); + }; + DOMPurify.removeHook = function(entryPoint) { + if (hooks2[entryPoint]) { + arrayPop(hooks2[entryPoint]); + } + }; + DOMPurify.removeHooks = function(entryPoint) { + if (hooks2[entryPoint]) { + hooks2[entryPoint] = []; + } + }; + DOMPurify.removeAllHooks = function() { + hooks2 = {}; + }; + return DOMPurify; + } + var purify = createDOMPurify(); + return purify; + }); + } + }); + + // frontend/model/contracts/chatroom.js + var import_sbp4 = __toESM(__require("@sbp/sbp")); + + // node_modules/vue/dist/vue.esm.js + var emptyObject = Object.freeze({}); + function isUndef(v) { + return v === void 0 || v === null; + } + function isDef(v) { + return v !== void 0 && v !== null; + } + function isTrue(v) { + return v === true; + } + function isFalse(v) { + return v === false; + } + function isPrimitive(value) { + return typeof value === "string" || typeof value === "number" || typeof value === "symbol" || typeof value === "boolean"; + } + function isObject(obj) { + return obj !== null && typeof obj === "object"; + } + var _toString = Object.prototype.toString; + function toRawType(value) { + return _toString.call(value).slice(8, -1); + } + function isPlainObject(obj) { + return _toString.call(obj) === "[object Object]"; + } + function isRegExp(v) { + return _toString.call(v) === "[object RegExp]"; + } + function isValidArrayIndex(val) { + var n = parseFloat(String(val)); + return n >= 0 && Math.floor(n) === n && isFinite(val); + } + function isPromise(val) { + return isDef(val) && typeof val.then === "function" && typeof val.catch === "function"; + } + function toString(val) { + return val == null ? "" : Array.isArray(val) || isPlainObject(val) && val.toString === _toString ? JSON.stringify(val, null, 2) : String(val); + } + function toNumber(val) { + var n = parseFloat(val); + return isNaN(n) ? val : n; + } + function makeMap(str2, expectsLowerCase) { + var map = /* @__PURE__ */ Object.create(null); + var list = str2.split(","); + for (var i = 0; i < list.length; i++) { + map[list[i]] = true; + } + return expectsLowerCase ? function(val) { + return map[val.toLowerCase()]; + } : function(val) { + return map[val]; + }; + } + var isBuiltInTag = makeMap("slot,component", true); + var isReservedAttribute = makeMap("key,ref,slot,slot-scope,is"); + function remove(arr, item) { + if (arr.length) { + var index2 = arr.indexOf(item); + if (index2 > -1) { + return arr.splice(index2, 1); + } + } + } + var hasOwnProperty = Object.prototype.hasOwnProperty; + function hasOwn(obj, key) { + return hasOwnProperty.call(obj, key); + } + function cached(fn) { + var cache = /* @__PURE__ */ Object.create(null); + return function cachedFn(str2) { + var hit = cache[str2]; + return hit || (cache[str2] = fn(str2)); + }; + } + var camelizeRE = /-(\w)/g; + var camelize = cached(function(str2) { + return str2.replace(camelizeRE, function(_, c) { + return c ? c.toUpperCase() : ""; + }); + }); + var capitalize = cached(function(str2) { + return str2.charAt(0).toUpperCase() + str2.slice(1); + }); + var hyphenateRE = /\B([A-Z])/g; + var hyphenate = cached(function(str2) { + return str2.replace(hyphenateRE, "-$1").toLowerCase(); + }); + function polyfillBind(fn, ctx) { + function boundFn(a) { + var l = arguments.length; + return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx); + } + boundFn._length = fn.length; + return boundFn; + } + function nativeBind(fn, ctx) { + return fn.bind(ctx); + } + var bind = Function.prototype.bind ? nativeBind : polyfillBind; + function toArray(list, start) { + start = start || 0; + var i = list.length - start; + var ret = new Array(i); + while (i--) { + ret[i] = list[i + start]; + } + return ret; + } + function extend(to, _from) { + for (var key in _from) { + to[key] = _from[key]; + } + return to; + } + function toObject(arr) { + var res = {}; + for (var i = 0; i < arr.length; i++) { + if (arr[i]) { + extend(res, arr[i]); + } + } + return res; + } + function noop(a, b, c) { + } + var no = function(a, b, c) { + return false; + }; + var identity = function(_) { + return _; + }; + function genStaticKeys(modules2) { + return modules2.reduce(function(keys, m) { + return keys.concat(m.staticKeys || []); + }, []).join(","); + } + function looseEqual(a, b) { + if (a === b) { + return true; + } + var isObjectA = isObject(a); + var isObjectB = isObject(b); + if (isObjectA && isObjectB) { + try { + var isArrayA = Array.isArray(a); + var isArrayB = Array.isArray(b); + if (isArrayA && isArrayB) { + return a.length === b.length && a.every(function(e, i) { + return looseEqual(e, b[i]); + }); + } else if (a instanceof Date && b instanceof Date) { + return a.getTime() === b.getTime(); + } else if (!isArrayA && !isArrayB) { + var keysA = Object.keys(a); + var keysB = Object.keys(b); + return keysA.length === keysB.length && keysA.every(function(key) { + return looseEqual(a[key], b[key]); + }); + } else { + return false; + } + } catch (e) { + return false; + } + } else if (!isObjectA && !isObjectB) { + return String(a) === String(b); + } else { + return false; + } + } + function looseIndexOf(arr, val) { + for (var i = 0; i < arr.length; i++) { + if (looseEqual(arr[i], val)) { + return i; + } + } + return -1; + } + function once(fn) { + var called = false; + return function() { + if (!called) { + called = true; + fn.apply(this, arguments); + } + }; + } + var SSR_ATTR = "data-server-rendered"; + var ASSET_TYPES = [ + "component", + "directive", + "filter" + ]; + var LIFECYCLE_HOOKS = [ + "beforeCreate", + "created", + "beforeMount", + "mounted", + "beforeUpdate", + "updated", + "beforeDestroy", + "destroyed", + "activated", + "deactivated", + "errorCaptured", + "serverPrefetch" + ]; + var config = { + optionMergeStrategies: /* @__PURE__ */ Object.create(null), + silent: false, + productionTip: true, + devtools: true, + performance: false, + errorHandler: null, + warnHandler: null, + ignoredElements: [], + keyCodes: /* @__PURE__ */ Object.create(null), + isReservedTag: no, + isReservedAttr: no, + isUnknownElement: no, + getTagNamespace: noop, + parsePlatformTagName: identity, + mustUseProp: no, + async: true, + _lifecycleHooks: LIFECYCLE_HOOKS + }; + var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/; + function isReserved(str2) { + var c = (str2 + "").charCodeAt(0); + return c === 36 || c === 95; + } + function def(obj, key, val, enumerable) { + Object.defineProperty(obj, key, { + value: val, + enumerable: !!enumerable, + writable: true, + configurable: true + }); + } + var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]"); + function parsePath(path) { + if (bailRE.test(path)) { + return; + } + var segments = path.split("."); + return function(obj) { + for (var i = 0; i < segments.length; i++) { + if (!obj) { + return; + } + obj = obj[segments[i]]; + } + return obj; + }; + } + var hasProto = "__proto__" in {}; + var inBrowser = typeof window !== "undefined"; + var inWeex = typeof WXEnvironment !== "undefined" && !!WXEnvironment.platform; + var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase(); + var UA = inBrowser && window.navigator.userAgent.toLowerCase(); + var isIE = UA && /msie|trident/.test(UA); + var isIE9 = UA && UA.indexOf("msie 9.0") > 0; + var isEdge = UA && UA.indexOf("edge/") > 0; + var isAndroid = UA && UA.indexOf("android") > 0 || weexPlatform === "android"; + var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA) || weexPlatform === "ios"; + var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge; + var isPhantomJS = UA && /phantomjs/.test(UA); + var isFF = UA && UA.match(/firefox\/(\d+)/); + var nativeWatch = {}.watch; + var supportsPassive = false; + if (inBrowser) { + try { + opts = {}; + Object.defineProperty(opts, "passive", { + get: function get3() { + supportsPassive = true; + } + }); + window.addEventListener("test-passive", null, opts); + } catch (e) { + } + } + var opts; + var _isServer; + var isServerRendering = function() { + if (_isServer === void 0) { + if (!inBrowser && !inWeex && typeof global !== "undefined") { + _isServer = global["process"] && global["process"].env.VUE_ENV === "server"; + } else { + _isServer = false; + } + } + return _isServer; + }; + var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; + function isNative(Ctor) { + return typeof Ctor === "function" && /native code/.test(Ctor.toString()); + } + var hasSymbol = typeof Symbol !== "undefined" && isNative(Symbol) && typeof Reflect !== "undefined" && isNative(Reflect.ownKeys); + var _Set; + if (typeof Set !== "undefined" && isNative(Set)) { + _Set = Set; + } else { + _Set = /* @__PURE__ */ function() { + function Set2() { + this.set = /* @__PURE__ */ Object.create(null); + } + Set2.prototype.has = function has2(key) { + return this.set[key] === true; + }; + Set2.prototype.add = function add2(key) { + this.set[key] = true; + }; + Set2.prototype.clear = function clear() { + this.set = /* @__PURE__ */ Object.create(null); + }; + return Set2; + }(); + } + var warn = noop; + var tip = noop; + var generateComponentTrace = noop; + var formatComponentName = noop; + if (true) { + hasConsole = typeof console !== "undefined"; + classifyRE = /(?:^|[-_])(\w)/g; + classify = function(str2) { + return str2.replace(classifyRE, function(c) { + return c.toUpperCase(); + }).replace(/[-_]/g, ""); + }; + warn = function(msg, vm) { + var trace = vm ? generateComponentTrace(vm) : ""; + if (config.warnHandler) { + config.warnHandler.call(null, msg, vm, trace); + } else if (hasConsole && !config.silent) { + console.error("[Vue warn]: " + msg + trace); + } + }; + tip = function(msg, vm) { + if (hasConsole && !config.silent) { + console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : "")); + } + }; + formatComponentName = function(vm, includeFile) { + if (vm.$root === vm) { + return ""; + } + var options = typeof vm === "function" && vm.cid != null ? vm.options : vm._isVue ? vm.$options || vm.constructor.options : vm; + var name = options.name || options._componentTag; + var file = options.__file; + if (!name && file) { + var match = file.match(/([^/\\]+)\.vue$/); + name = match && match[1]; + } + return (name ? "<" + classify(name) + ">" : "") + (file && includeFile !== false ? " at " + file : ""); + }; + repeat = function(str2, n) { + var res = ""; + while (n) { + if (n % 2 === 1) { + res += str2; + } + if (n > 1) { + str2 += str2; + } + n >>= 1; + } + return res; + }; + generateComponentTrace = function(vm) { + if (vm._isVue && vm.$parent) { + var tree = []; + var currentRecursiveSequence = 0; + while (vm) { + if (tree.length > 0) { + var last = tree[tree.length - 1]; + if (last.constructor === vm.constructor) { + currentRecursiveSequence++; + vm = vm.$parent; + continue; + } else if (currentRecursiveSequence > 0) { + tree[tree.length - 1] = [last, currentRecursiveSequence]; + currentRecursiveSequence = 0; + } + } + tree.push(vm); + vm = vm.$parent; + } + return "\n\nfound in\n\n" + tree.map(function(vm2, i) { + return "" + (i === 0 ? "---> " : repeat(" ", 5 + i * 2)) + (Array.isArray(vm2) ? formatComponentName(vm2[0]) + "... (" + vm2[1] + " recursive calls)" : formatComponentName(vm2)); + }).join("\n"); + } else { + return "\n\n(found in " + formatComponentName(vm) + ")"; + } + }; + } + var hasConsole; + var classifyRE; + var classify; + var repeat; + var uid = 0; + var Dep = function Dep2() { + this.id = uid++; + this.subs = []; + }; + Dep.prototype.addSub = function addSub(sub) { + this.subs.push(sub); + }; + Dep.prototype.removeSub = function removeSub(sub) { + remove(this.subs, sub); + }; + Dep.prototype.depend = function depend() { + if (Dep.target) { + Dep.target.addDep(this); + } + }; + Dep.prototype.notify = function notify() { + var subs = this.subs.slice(); + if (!config.async) { + subs.sort(function(a, b) { + return a.id - b.id; + }); + } + for (var i = 0, l = subs.length; i < l; i++) { + subs[i].update(); + } + }; + Dep.target = null; + var targetStack = []; + function pushTarget(target2) { + targetStack.push(target2); + Dep.target = target2; + } + function popTarget() { + targetStack.pop(); + Dep.target = targetStack[targetStack.length - 1]; + } + var VNode = function VNode2(tag, data, children, text2, elm, context, componentOptions, asyncFactory) { + this.tag = tag; + this.data = data; + this.children = children; + this.text = text2; + this.elm = elm; + this.ns = void 0; + this.context = context; + this.fnContext = void 0; + this.fnOptions = void 0; + this.fnScopeId = void 0; + this.key = data && data.key; + this.componentOptions = componentOptions; + this.componentInstance = void 0; + this.parent = void 0; + this.raw = false; + this.isStatic = false; + this.isRootInsert = true; + this.isComment = false; + this.isCloned = false; + this.isOnce = false; + this.asyncFactory = asyncFactory; + this.asyncMeta = void 0; + this.isAsyncPlaceholder = false; + }; + var prototypeAccessors = { child: { configurable: true } }; + prototypeAccessors.child.get = function() { + return this.componentInstance; + }; + Object.defineProperties(VNode.prototype, prototypeAccessors); + var createEmptyVNode = function(text2) { + if (text2 === void 0) + text2 = ""; + var node = new VNode(); + node.text = text2; + node.isComment = true; + return node; + }; + function createTextVNode(val) { + return new VNode(void 0, void 0, void 0, String(val)); + } + function cloneVNode(vnode) { + var cloned = new VNode(vnode.tag, vnode.data, vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory); + cloned.ns = vnode.ns; + cloned.isStatic = vnode.isStatic; + cloned.key = vnode.key; + cloned.isComment = vnode.isComment; + cloned.fnContext = vnode.fnContext; + cloned.fnOptions = vnode.fnOptions; + cloned.fnScopeId = vnode.fnScopeId; + cloned.asyncMeta = vnode.asyncMeta; + cloned.isCloned = true; + return cloned; + } + var arrayProto = Array.prototype; + var arrayMethods = Object.create(arrayProto); + var methodsToPatch = [ + "push", + "pop", + "shift", + "unshift", + "splice", + "sort", + "reverse" + ]; + methodsToPatch.forEach(function(method) { + var original = arrayProto[method]; + def(arrayMethods, method, function mutator() { + var args = [], len2 = arguments.length; + while (len2--) + args[len2] = arguments[len2]; + var result = original.apply(this, args); + var ob = this.__ob__; + var inserted2; + switch (method) { + case "push": + case "unshift": + inserted2 = args; + break; + case "splice": + inserted2 = args.slice(2); + break; + } + if (inserted2) { + ob.observeArray(inserted2); + } + ob.dep.notify(); + return result; + }); + }); + var arrayKeys = Object.getOwnPropertyNames(arrayMethods); + var shouldObserve = true; + function toggleObserving(value) { + shouldObserve = value; + } + var Observer = function Observer2(value) { + this.value = value; + this.dep = new Dep(); + this.vmCount = 0; + def(value, "__ob__", this); + if (Array.isArray(value)) { + if (hasProto) { + protoAugment(value, arrayMethods); + } else { + copyAugment(value, arrayMethods, arrayKeys); + } + this.observeArray(value); + } else { + this.walk(value); + } + }; + Observer.prototype.walk = function walk(obj) { + var keys = Object.keys(obj); + for (var i = 0; i < keys.length; i++) { + defineReactive$$1(obj, keys[i]); + } + }; + Observer.prototype.observeArray = function observeArray(items) { + for (var i = 0, l = items.length; i < l; i++) { + observe(items[i]); + } + }; + function protoAugment(target2, src) { + target2.__proto__ = src; + } + function copyAugment(target2, src, keys) { + for (var i = 0, l = keys.length; i < l; i++) { + var key = keys[i]; + def(target2, key, src[key]); + } + } + function observe(value, asRootData) { + if (!isObject(value) || value instanceof VNode) { + return; + } + var ob; + if (hasOwn(value, "__ob__") && value.__ob__ instanceof Observer) { + ob = value.__ob__; + } else if (shouldObserve && !isServerRendering() && (Array.isArray(value) || isPlainObject(value)) && Object.isExtensible(value) && !value._isVue) { + ob = new Observer(value); + } + if (asRootData && ob) { + ob.vmCount++; + } + return ob; + } + function defineReactive$$1(obj, key, val, customSetter, shallow) { + var dep = new Dep(); + var property = Object.getOwnPropertyDescriptor(obj, key); + if (property && property.configurable === false) { + return; + } + var getter = property && property.get; + var setter = property && property.set; + if ((!getter || setter) && arguments.length === 2) { + val = obj[key]; + } + var childOb = !shallow && observe(val); + Object.defineProperty(obj, key, { + enumerable: true, + configurable: true, + get: function reactiveGetter() { + var value = getter ? getter.call(obj) : val; + if (Dep.target) { + dep.depend(); + if (childOb) { + childOb.dep.depend(); + if (Array.isArray(value)) { + dependArray(value); + } + } + } + return value; + }, + set: function reactiveSetter(newVal) { + var value = getter ? getter.call(obj) : val; + if (newVal === value || newVal !== newVal && value !== value) { + return; + } + if (customSetter) { + customSetter(); + } + if (getter && !setter) { + return; + } + if (setter) { + setter.call(obj, newVal); + } else { + val = newVal; + } + childOb = !shallow && observe(newVal); + dep.notify(); + } + }); + } + function set(target2, key, val) { + if (isUndef(target2) || isPrimitive(target2)) { + warn("Cannot set reactive property on undefined, null, or primitive value: " + target2); + } + if (Array.isArray(target2) && isValidArrayIndex(key)) { + target2.length = Math.max(target2.length, key); + target2.splice(key, 1, val); + return val; + } + if (key in target2 && !(key in Object.prototype)) { + target2[key] = val; + return val; + } + var ob = target2.__ob__; + if (target2._isVue || ob && ob.vmCount) { + warn("Avoid adding reactive properties to a Vue instance or its root $data at runtime - declare it upfront in the data option."); + return val; + } + if (!ob) { + target2[key] = val; + return val; + } + defineReactive$$1(ob.value, key, val); + ob.dep.notify(); + return val; + } + function del(target2, key) { + if (isUndef(target2) || isPrimitive(target2)) { + warn("Cannot delete reactive property on undefined, null, or primitive value: " + target2); + } + if (Array.isArray(target2) && isValidArrayIndex(key)) { + target2.splice(key, 1); + return; + } + var ob = target2.__ob__; + if (target2._isVue || ob && ob.vmCount) { + warn("Avoid deleting properties on a Vue instance or its root $data - just set it to null."); + return; + } + if (!hasOwn(target2, key)) { + return; + } + delete target2[key]; + if (!ob) { + return; + } + ob.dep.notify(); + } + function dependArray(value) { + for (var e = void 0, i = 0, l = value.length; i < l; i++) { + e = value[i]; + e && e.__ob__ && e.__ob__.dep.depend(); + if (Array.isArray(e)) { + dependArray(e); + } + } + } + var strats = config.optionMergeStrategies; + if (true) { + strats.el = strats.propsData = function(parent, child, vm, key) { + if (!vm) { + warn('option "' + key + '" can only be used during instance creation with the `new` keyword.'); + } + return defaultStrat(parent, child); + }; + } + function mergeData(to, from) { + if (!from) { + return to; + } + var key, toVal, fromVal; + var keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from); + for (var i = 0; i < keys.length; i++) { + key = keys[i]; + if (key === "__ob__") { + continue; + } + toVal = to[key]; + fromVal = from[key]; + if (!hasOwn(to, key)) { + set(to, key, fromVal); + } else if (toVal !== fromVal && isPlainObject(toVal) && isPlainObject(fromVal)) { + mergeData(toVal, fromVal); + } + } + return to; + } + function mergeDataOrFn(parentVal, childVal, vm) { + if (!vm) { + if (!childVal) { + return parentVal; + } + if (!parentVal) { + return childVal; + } + return function mergedDataFn() { + return mergeData(typeof childVal === "function" ? childVal.call(this, this) : childVal, typeof parentVal === "function" ? parentVal.call(this, this) : parentVal); + }; + } else { + return function mergedInstanceDataFn() { + var instanceData = typeof childVal === "function" ? childVal.call(vm, vm) : childVal; + var defaultData = typeof parentVal === "function" ? parentVal.call(vm, vm) : parentVal; + if (instanceData) { + return mergeData(instanceData, defaultData); + } else { + return defaultData; + } + }; + } + } + strats.data = function(parentVal, childVal, vm) { + if (!vm) { + if (childVal && typeof childVal !== "function") { + warn('The "data" option should be a function that returns a per-instance value in component definitions.', vm); + return parentVal; + } + return mergeDataOrFn(parentVal, childVal); + } + return mergeDataOrFn(parentVal, childVal, vm); + }; + function mergeHook(parentVal, childVal) { + var res = childVal ? parentVal ? parentVal.concat(childVal) : Array.isArray(childVal) ? childVal : [childVal] : parentVal; + return res ? dedupeHooks(res) : res; + } + function dedupeHooks(hooks2) { + var res = []; + for (var i = 0; i < hooks2.length; i++) { + if (res.indexOf(hooks2[i]) === -1) { + res.push(hooks2[i]); + } + } + return res; + } + LIFECYCLE_HOOKS.forEach(function(hook) { + strats[hook] = mergeHook; + }); + function mergeAssets(parentVal, childVal, vm, key) { + var res = Object.create(parentVal || null); + if (childVal) { + assertObjectType(key, childVal, vm); + return extend(res, childVal); + } else { + return res; + } + } + ASSET_TYPES.forEach(function(type) { + strats[type + "s"] = mergeAssets; + }); + strats.watch = function(parentVal, childVal, vm, key) { + if (parentVal === nativeWatch) { + parentVal = void 0; + } + if (childVal === nativeWatch) { + childVal = void 0; + } + if (!childVal) { + return Object.create(parentVal || null); + } + if (true) { + assertObjectType(key, childVal, vm); + } + if (!parentVal) { + return childVal; + } + var ret = {}; + extend(ret, parentVal); + for (var key$1 in childVal) { + var parent = ret[key$1]; + var child = childVal[key$1]; + if (parent && !Array.isArray(parent)) { + parent = [parent]; + } + ret[key$1] = parent ? parent.concat(child) : Array.isArray(child) ? child : [child]; + } + return ret; + }; + strats.props = strats.methods = strats.inject = strats.computed = function(parentVal, childVal, vm, key) { + if (childVal && true) { + assertObjectType(key, childVal, vm); + } + if (!parentVal) { + return childVal; + } + var ret = /* @__PURE__ */ Object.create(null); + extend(ret, parentVal); + if (childVal) { + extend(ret, childVal); + } + return ret; + }; + strats.provide = mergeDataOrFn; + var defaultStrat = function(parentVal, childVal) { + return childVal === void 0 ? parentVal : childVal; + }; + function checkComponents(options) { + for (var key in options.components) { + validateComponentName(key); + } + } + function validateComponentName(name) { + if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) { + warn('Invalid component name: "' + name + '". Component names should conform to valid custom element name in html5 specification.'); + } + if (isBuiltInTag(name) || config.isReservedTag(name)) { + warn("Do not use built-in or reserved HTML elements as component id: " + name); + } + } + function normalizeProps(options, vm) { + var props2 = options.props; + if (!props2) { + return; + } + var res = {}; + var i, val, name; + if (Array.isArray(props2)) { + i = props2.length; + while (i--) { + val = props2[i]; + if (typeof val === "string") { + name = camelize(val); + res[name] = { type: null }; + } else if (true) { + warn("props must be strings when using array syntax."); + } + } + } else if (isPlainObject(props2)) { + for (var key in props2) { + val = props2[key]; + name = camelize(key); + res[name] = isPlainObject(val) ? val : { type: val }; + } + } else if (true) { + warn('Invalid value for option "props": expected an Array or an Object, but got ' + toRawType(props2) + ".", vm); + } + options.props = res; + } + function normalizeInject(options, vm) { + var inject = options.inject; + if (!inject) { + return; + } + var normalized = options.inject = {}; + if (Array.isArray(inject)) { + for (var i = 0; i < inject.length; i++) { + normalized[inject[i]] = { from: inject[i] }; + } + } else if (isPlainObject(inject)) { + for (var key in inject) { + var val = inject[key]; + normalized[key] = isPlainObject(val) ? extend({ from: key }, val) : { from: val }; + } + } else if (true) { + warn('Invalid value for option "inject": expected an Array or an Object, but got ' + toRawType(inject) + ".", vm); + } + } + function normalizeDirectives(options) { + var dirs = options.directives; + if (dirs) { + for (var key in dirs) { + var def$$1 = dirs[key]; + if (typeof def$$1 === "function") { + dirs[key] = { bind: def$$1, update: def$$1 }; + } + } + } + } + function assertObjectType(name, value, vm) { + if (!isPlainObject(value)) { + warn('Invalid value for option "' + name + '": expected an Object, but got ' + toRawType(value) + ".", vm); + } + } + function mergeOptions(parent, child, vm) { + if (true) { + checkComponents(child); + } + if (typeof child === "function") { + child = child.options; + } + normalizeProps(child, vm); + normalizeInject(child, vm); + normalizeDirectives(child); + if (!child._base) { + if (child.extends) { + parent = mergeOptions(parent, child.extends, vm); + } + if (child.mixins) { + for (var i = 0, l = child.mixins.length; i < l; i++) { + parent = mergeOptions(parent, child.mixins[i], vm); + } + } + } + var options = {}; + var key; + for (key in parent) { + mergeField(key); + } + for (key in child) { + if (!hasOwn(parent, key)) { + mergeField(key); + } + } + function mergeField(key2) { + var strat = strats[key2] || defaultStrat; + options[key2] = strat(parent[key2], child[key2], vm, key2); + } + return options; + } + function resolveAsset(options, type, id, warnMissing) { + if (typeof id !== "string") { + return; + } + var assets = options[type]; + if (hasOwn(assets, id)) { + return assets[id]; + } + var camelizedId = camelize(id); + if (hasOwn(assets, camelizedId)) { + return assets[camelizedId]; + } + var PascalCaseId = capitalize(camelizedId); + if (hasOwn(assets, PascalCaseId)) { + return assets[PascalCaseId]; + } + var res = assets[id] || assets[camelizedId] || assets[PascalCaseId]; + if (warnMissing && !res) { + warn("Failed to resolve " + type.slice(0, -1) + ": " + id, options); + } + return res; + } + function validateProp(key, propOptions, propsData, vm) { + var prop = propOptions[key]; + var absent = !hasOwn(propsData, key); + var value = propsData[key]; + var booleanIndex = getTypeIndex(Boolean, prop.type); + if (booleanIndex > -1) { + if (absent && !hasOwn(prop, "default")) { + value = false; + } else if (value === "" || value === hyphenate(key)) { + var stringIndex = getTypeIndex(String, prop.type); + if (stringIndex < 0 || booleanIndex < stringIndex) { + value = true; + } + } + } + if (value === void 0) { + value = getPropDefaultValue(vm, prop, key); + var prevShouldObserve = shouldObserve; + toggleObserving(true); + observe(value); + toggleObserving(prevShouldObserve); + } + if (true) { + assertProp(prop, key, value, vm, absent); + } + return value; + } + function getPropDefaultValue(vm, prop, key) { + if (!hasOwn(prop, "default")) { + return void 0; + } + var def2 = prop.default; + if (isObject(def2)) { + warn('Invalid default value for prop "' + key + '": Props with type Object/Array must use a factory function to return the default value.', vm); + } + if (vm && vm.$options.propsData && vm.$options.propsData[key] === void 0 && vm._props[key] !== void 0) { + return vm._props[key]; + } + return typeof def2 === "function" && getType(prop.type) !== "Function" ? def2.call(vm) : def2; + } + function assertProp(prop, name, value, vm, absent) { + if (prop.required && absent) { + warn('Missing required prop: "' + name + '"', vm); + return; + } + if (value == null && !prop.required) { + return; + } + var type = prop.type; + var valid = !type || type === true; + var expectedTypes = []; + if (type) { + if (!Array.isArray(type)) { + type = [type]; + } + for (var i = 0; i < type.length && !valid; i++) { + var assertedType = assertType(value, type[i]); + expectedTypes.push(assertedType.expectedType || ""); + valid = assertedType.valid; + } + } + if (!valid) { + warn(getInvalidTypeMessage(name, value, expectedTypes), vm); + return; + } + var validator = prop.validator; + if (validator) { + if (!validator(value)) { + warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm); + } + } + } + var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/; + function assertType(value, type) { + var valid; + var expectedType = getType(type); + if (simpleCheckRE.test(expectedType)) { + var t = typeof value; + valid = t === expectedType.toLowerCase(); + if (!valid && t === "object") { + valid = value instanceof type; + } + } else if (expectedType === "Object") { + valid = isPlainObject(value); + } else if (expectedType === "Array") { + valid = Array.isArray(value); + } else { + valid = value instanceof type; + } + return { + valid, + expectedType + }; + } + function getType(fn) { + var match = fn && fn.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ""; + } + function isSameType(a, b) { + return getType(a) === getType(b); + } + function getTypeIndex(type, expectedTypes) { + if (!Array.isArray(expectedTypes)) { + return isSameType(expectedTypes, type) ? 0 : -1; + } + for (var i = 0, len2 = expectedTypes.length; i < len2; i++) { + if (isSameType(expectedTypes[i], type)) { + return i; + } + } + return -1; + } + function getInvalidTypeMessage(name, value, expectedTypes) { + var message = 'Invalid prop: type check failed for prop "' + name + '". Expected ' + expectedTypes.map(capitalize).join(", "); + var expectedType = expectedTypes[0]; + var receivedType = toRawType(value); + var expectedValue = styleValue(value, expectedType); + var 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(value) { + var explicitTypes = ["string", "number", "boolean"]; + return explicitTypes.some(function(elem) { + return value.toLowerCase() === elem; + }); + } + function isBoolean() { + var args = [], len2 = arguments.length; + while (len2--) + args[len2] = arguments[len2]; + return args.some(function(elem) { + return elem.toLowerCase() === "boolean"; + }); + } + function handleError(err, vm, info) { + pushTarget(); + try { + if (vm) { + var cur = vm; + while (cur = cur.$parent) { + var hooks2 = cur.$options.errorCaptured; + if (hooks2) { + for (var i = 0; i < hooks2.length; i++) { + try { + var capture = hooks2[i].call(cur, err, vm, info) === false; + if (capture) { + return; + } + } catch (e) { + globalHandleError(e, cur, "errorCaptured hook"); + } + } + } + } + } + globalHandleError(err, vm, info); + } finally { + popTarget(); + } + } + function invokeWithErrorHandling(handler, context, args, vm, info) { + var res; + try { + res = args ? handler.apply(context, args) : handler.call(context); + if (res && !res._isVue && isPromise(res) && !res._handled) { + res.catch(function(e) { + return handleError(e, vm, info + " (Promise/async)"); + }); + res._handled = true; + } + } catch (e) { + handleError(e, vm, info); + } + return res; + } + function globalHandleError(err, vm, info) { + if (config.errorHandler) { + try { + return config.errorHandler.call(null, err, vm, info); + } catch (e) { + if (e !== err) { + logError(e, null, "config.errorHandler"); + } + } + } + logError(err, vm, info); + } + function logError(err, vm, info) { + if (true) { + warn("Error in " + info + ': "' + err.toString() + '"', vm); + } + if ((inBrowser || inWeex) && typeof console !== "undefined") { + console.error(err); + } else { + throw err; + } + } + var isUsingMicroTask = false; + var callbacks = []; + var pending = false; + function flushCallbacks() { + pending = false; + var copies = callbacks.slice(0); + callbacks.length = 0; + for (var i = 0; i < copies.length; i++) { + copies[i](); + } + } + var timerFunc; + if (typeof Promise !== "undefined" && isNative(Promise)) { + p = Promise.resolve(); + timerFunc = function() { + p.then(flushCallbacks); + if (isIOS) { + setTimeout(noop); + } + }; + isUsingMicroTask = true; + } else if (!isIE && typeof MutationObserver !== "undefined" && (isNative(MutationObserver) || MutationObserver.toString() === "[object MutationObserverConstructor]")) { + counter = 1; + observer = new MutationObserver(flushCallbacks); + textNode = document.createTextNode(String(counter)); + observer.observe(textNode, { + characterData: true + }); + timerFunc = function() { + counter = (counter + 1) % 2; + textNode.data = String(counter); + }; + isUsingMicroTask = true; + } else if (typeof setImmediate !== "undefined" && isNative(setImmediate)) { + timerFunc = function() { + setImmediate(flushCallbacks); + }; + } else { + timerFunc = function() { + setTimeout(flushCallbacks, 0); + }; + } + var p; + var counter; + var observer; + var textNode; + function nextTick(cb, ctx) { + var _resolve; + callbacks.push(function() { + if (cb) { + try { + cb.call(ctx); + } catch (e) { + handleError(e, ctx, "nextTick"); + } + } else if (_resolve) { + _resolve(ctx); + } + }); + if (!pending) { + pending = true; + timerFunc(); + } + if (!cb && typeof Promise !== "undefined") { + return new Promise(function(resolve) { + _resolve = resolve; + }); + } + } + var mark; + var measure; + if (true) { + perf = inBrowser && window.performance; + if (perf && perf.mark && perf.measure && perf.clearMarks && perf.clearMeasures) { + mark = function(tag) { + return perf.mark(tag); + }; + measure = function(name, startTag, endTag2) { + perf.measure(name, startTag, endTag2); + perf.clearMarks(startTag); + perf.clearMarks(endTag2); + }; + } + } + var perf; + var initProxy; + if (true) { + allowedGlobals = makeMap("Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,require"); + warnNonPresent = function(target2, key) { + warn('Property or method "' + key + '" is not defined on the instance but referenced during render. Make sure that this property is reactive, either in the data option, or for class-based components, by initializing the property. See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target2); + }; + warnReservedPrefix = function(target2, key) { + warn('Property "' + key + '" must be accessed with "$data.' + key + '" because properties starting with "$" or "_" are not proxied in the Vue instance to prevent conflicts with Vue internals. See: https://vuejs.org/v2/api/#data', target2); + }; + hasProxy = typeof Proxy !== "undefined" && isNative(Proxy); + if (hasProxy) { + isBuiltInModifier = makeMap("stop,prevent,self,ctrl,shift,alt,meta,exact"); + config.keyCodes = new Proxy(config.keyCodes, { + set: function set2(target2, key, value) { + if (isBuiltInModifier(key)) { + warn("Avoid overwriting built-in modifier in config.keyCodes: ." + key); + return false; + } else { + target2[key] = value; + return true; + } + } + }); + } + hasHandler = { + has: function has2(target2, key) { + var has3 = key in target2; + var isAllowed = allowedGlobals(key) || typeof key === "string" && key.charAt(0) === "_" && !(key in target2.$data); + if (!has3 && !isAllowed) { + if (key in target2.$data) { + warnReservedPrefix(target2, key); + } else { + warnNonPresent(target2, key); + } + } + return has3 || !isAllowed; + } + }; + getHandler = { + get: function get3(target2, key) { + if (typeof key === "string" && !(key in target2)) { + if (key in target2.$data) { + warnReservedPrefix(target2, key); + } else { + warnNonPresent(target2, key); + } + } + return target2[key]; + } + }; + initProxy = function initProxy2(vm) { + if (hasProxy) { + var options = vm.$options; + var handlers = options.render && options.render._withStripped ? getHandler : hasHandler; + vm._renderProxy = new Proxy(vm, handlers); + } else { + vm._renderProxy = vm; + } + }; + } + var allowedGlobals; + var warnNonPresent; + var warnReservedPrefix; + var hasProxy; + var isBuiltInModifier; + var hasHandler; + var getHandler; + var seenObjects = new _Set(); + function traverse(val) { + _traverse(val, seenObjects); + seenObjects.clear(); + } + function _traverse(val, seen) { + var i, keys; + var isA = Array.isArray(val); + if (!isA && !isObject(val) || Object.isFrozen(val) || val instanceof VNode) { + return; + } + if (val.__ob__) { + var depId = val.__ob__.dep.id; + if (seen.has(depId)) { + return; + } + seen.add(depId); + } + if (isA) { + i = val.length; + while (i--) { + _traverse(val[i], seen); + } + } else { + keys = Object.keys(val); + i = keys.length; + while (i--) { + _traverse(val[keys[i]], seen); + } + } + } + var normalizeEvent = cached(function(name) { + var passive = name.charAt(0) === "&"; + name = passive ? name.slice(1) : name; + var once$$1 = name.charAt(0) === "~"; + name = once$$1 ? name.slice(1) : name; + var capture = name.charAt(0) === "!"; + name = capture ? name.slice(1) : name; + return { + name, + once: once$$1, + capture, + passive + }; + }); + function createFnInvoker(fns, vm) { + function invoker() { + var arguments$1 = arguments; + var fns2 = invoker.fns; + if (Array.isArray(fns2)) { + var cloned = fns2.slice(); + for (var i = 0; i < cloned.length; i++) { + invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler"); + } + } else { + return invokeWithErrorHandling(fns2, null, arguments, vm, "v-on handler"); + } + } + invoker.fns = fns; + return invoker; + } + function updateListeners(on2, oldOn, add2, remove$$12, createOnceHandler2, vm) { + var name, def$$1, cur, old, event; + for (name in on2) { + def$$1 = cur = on2[name]; + old = oldOn[name]; + event = normalizeEvent(name); + if (isUndef(cur)) { + warn('Invalid handler for event "' + event.name + '": got ' + String(cur), vm); + } else if (isUndef(old)) { + if (isUndef(cur.fns)) { + cur = on2[name] = createFnInvoker(cur, vm); + } + if (isTrue(event.once)) { + cur = on2[name] = createOnceHandler2(event.name, cur, event.capture); + } + add2(event.name, cur, event.capture, event.passive, event.params); + } else if (cur !== old) { + old.fns = cur; + on2[name] = old; + } + } + for (name in oldOn) { + if (isUndef(on2[name])) { + event = normalizeEvent(name); + remove$$12(event.name, oldOn[name], event.capture); + } + } + } + function mergeVNodeHook(def2, hookKey, hook) { + if (def2 instanceof VNode) { + def2 = def2.data.hook || (def2.data.hook = {}); + } + var invoker; + var oldHook = def2[hookKey]; + function wrappedHook() { + hook.apply(this, arguments); + remove(invoker.fns, wrappedHook); + } + if (isUndef(oldHook)) { + invoker = createFnInvoker([wrappedHook]); + } else { + if (isDef(oldHook.fns) && isTrue(oldHook.merged)) { + invoker = oldHook; + invoker.fns.push(wrappedHook); + } else { + invoker = createFnInvoker([oldHook, wrappedHook]); + } + } + invoker.merged = true; + def2[hookKey] = invoker; + } + function extractPropsFromVNodeData(data, Ctor, tag) { + var propOptions = Ctor.options.props; + if (isUndef(propOptions)) { + return; + } + var res = {}; + var attrs2 = data.attrs; + var props2 = data.props; + if (isDef(attrs2) || isDef(props2)) { + for (var key in propOptions) { + var altKey = hyphenate(key); + if (true) { + var keyInLowerCase = key.toLowerCase(); + if (key !== keyInLowerCase && attrs2 && hasOwn(attrs2, keyInLowerCase)) { + tip('Prop "' + keyInLowerCase + '" is passed to component ' + formatComponentName(tag || Ctor) + ', but the declared prop name is "' + key + '". Note that HTML attributes are case-insensitive and camelCased props need to use their kebab-case equivalents when using in-DOM templates. You should probably use "' + altKey + '" instead of "' + key + '".'); + } + } + checkProp(res, props2, key, altKey, true) || checkProp(res, attrs2, key, altKey, false); + } + } + return res; + } + function checkProp(res, hash2, key, altKey, preserve) { + if (isDef(hash2)) { + if (hasOwn(hash2, key)) { + res[key] = hash2[key]; + if (!preserve) { + delete hash2[key]; + } + return true; + } else if (hasOwn(hash2, altKey)) { + res[key] = hash2[altKey]; + if (!preserve) { + delete hash2[altKey]; + } + return true; + } + } + return false; + } + function simpleNormalizeChildren(children) { + for (var i = 0; i < children.length; i++) { + if (Array.isArray(children[i])) { + return Array.prototype.concat.apply([], children); + } + } + return children; + } + function normalizeChildren(children) { + return isPrimitive(children) ? [createTextVNode(children)] : Array.isArray(children) ? normalizeArrayChildren(children) : void 0; + } + function isTextNode(node) { + return isDef(node) && isDef(node.text) && isFalse(node.isComment); + } + function normalizeArrayChildren(children, nestedIndex) { + var res = []; + var i, c, lastIndex, last; + for (i = 0; i < children.length; i++) { + c = children[i]; + if (isUndef(c) || typeof c === "boolean") { + continue; + } + lastIndex = res.length - 1; + last = res[lastIndex]; + if (Array.isArray(c)) { + if (c.length > 0) { + c = normalizeArrayChildren(c, (nestedIndex || "") + "_" + i); + if (isTextNode(c[0]) && isTextNode(last)) { + res[lastIndex] = createTextVNode(last.text + c[0].text); + c.shift(); + } + res.push.apply(res, c); + } + } else if (isPrimitive(c)) { + if (isTextNode(last)) { + res[lastIndex] = createTextVNode(last.text + c); + } else if (c !== "") { + res.push(createTextVNode(c)); + } + } else { + if (isTextNode(c) && isTextNode(last)) { + res[lastIndex] = createTextVNode(last.text + c.text); + } else { + if (isTrue(children._isVList) && isDef(c.tag) && isUndef(c.key) && isDef(nestedIndex)) { + c.key = "__vlist" + nestedIndex + "_" + i + "__"; + } + res.push(c); + } + } + } + return res; + } + function initProvide(vm) { + var provide = vm.$options.provide; + if (provide) { + vm._provided = typeof provide === "function" ? provide.call(vm) : provide; + } + } + function initInjections(vm) { + var result = resolveInject(vm.$options.inject, vm); + if (result) { + toggleObserving(false); + Object.keys(result).forEach(function(key) { + if (true) { + defineReactive$$1(vm, key, result[key], function() { + warn('Avoid mutating an injected value directly since the changes will be overwritten whenever the provided component re-renders. injection being mutated: "' + key + '"', vm); + }); + } else { + defineReactive$$1(vm, key, result[key]); + } + }); + toggleObserving(true); + } + } + function resolveInject(inject, vm) { + if (inject) { + var result = /* @__PURE__ */ Object.create(null); + var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (key === "__ob__") { + continue; + } + var provideKey = inject[key].from; + var source = vm; + while (source) { + if (source._provided && hasOwn(source._provided, provideKey)) { + result[key] = source._provided[provideKey]; + break; + } + source = source.$parent; + } + if (!source) { + if ("default" in inject[key]) { + var provideDefault = inject[key].default; + result[key] = typeof provideDefault === "function" ? provideDefault.call(vm) : provideDefault; + } else if (true) { + warn('Injection "' + key + '" not found', vm); + } + } + } + return result; + } + } + function resolveSlots(children, context) { + if (!children || !children.length) { + return {}; + } + var slots = {}; + for (var i = 0, l = children.length; i < l; i++) { + var child = children[i]; + var data = child.data; + if (data && data.attrs && data.attrs.slot) { + delete data.attrs.slot; + } + if ((child.context === context || child.fnContext === context) && data && data.slot != null) { + var name = data.slot; + var slot = slots[name] || (slots[name] = []); + if (child.tag === "template") { + slot.push.apply(slot, child.children || []); + } else { + slot.push(child); + } + } else { + (slots.default || (slots.default = [])).push(child); + } + } + for (var name$1 in slots) { + if (slots[name$1].every(isWhitespace)) { + delete slots[name$1]; + } + } + return slots; + } + function isWhitespace(node) { + return node.isComment && !node.asyncFactory || node.text === " "; + } + function normalizeScopedSlots(slots, normalSlots, prevSlots) { + var res; + var hasNormalSlots = Object.keys(normalSlots).length > 0; + var isStable = slots ? !!slots.$stable : !hasNormalSlots; + var key = slots && slots.$key; + if (!slots) { + res = {}; + } else if (slots._normalized) { + return slots._normalized; + } else if (isStable && prevSlots && prevSlots !== emptyObject && key === prevSlots.$key && !hasNormalSlots && !prevSlots.$hasNormal) { + return prevSlots; + } else { + res = {}; + for (var key$1 in slots) { + if (slots[key$1] && key$1[0] !== "$") { + res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]); + } + } + } + for (var key$2 in normalSlots) { + if (!(key$2 in res)) { + res[key$2] = proxyNormalSlot(normalSlots, key$2); + } + } + if (slots && Object.isExtensible(slots)) { + slots._normalized = res; + } + def(res, "$stable", isStable); + def(res, "$key", key); + def(res, "$hasNormal", hasNormalSlots); + return res; + } + function normalizeScopedSlot(normalSlots, key, fn) { + var normalized = function() { + var res = arguments.length ? fn.apply(null, arguments) : fn({}); + res = res && typeof res === "object" && !Array.isArray(res) ? [res] : normalizeChildren(res); + return res && (res.length === 0 || res.length === 1 && res[0].isComment) ? void 0 : res; + }; + if (fn.proxy) { + Object.defineProperty(normalSlots, key, { + get: normalized, + enumerable: true, + configurable: true + }); + } + return normalized; + } + function proxyNormalSlot(slots, key) { + return function() { + return slots[key]; + }; + } + function renderList(val, render4) { + var ret, i, l, keys, key; + if (Array.isArray(val) || typeof val === "string") { + ret = new Array(val.length); + for (i = 0, l = val.length; i < l; i++) { + ret[i] = render4(val[i], i); + } + } else if (typeof val === "number") { + ret = new Array(val); + for (i = 0; i < val; i++) { + ret[i] = render4(i + 1, i); + } + } else if (isObject(val)) { + if (hasSymbol && val[Symbol.iterator]) { + ret = []; + var iterator = val[Symbol.iterator](); + var result = iterator.next(); + while (!result.done) { + ret.push(render4(result.value, ret.length)); + result = iterator.next(); + } + } else { + keys = Object.keys(val); + ret = new Array(keys.length); + for (i = 0, l = keys.length; i < l; i++) { + key = keys[i]; + ret[i] = render4(val[key], key, i); + } + } + } + if (!isDef(ret)) { + ret = []; + } + ret._isVList = true; + return ret; + } + function renderSlot(name, fallback, props2, bindObject) { + var scopedSlotFn = this.$scopedSlots[name]; + var nodes; + if (scopedSlotFn) { + props2 = props2 || {}; + if (bindObject) { + if (!isObject(bindObject)) { + warn("slot v-bind without argument expects an Object", this); + } + props2 = extend(extend({}, bindObject), props2); + } + nodes = scopedSlotFn(props2) || fallback; + } else { + nodes = this.$slots[name] || fallback; + } + var target2 = props2 && props2.slot; + if (target2) { + return this.$createElement("template", { slot: target2 }, nodes); + } else { + return nodes; + } + } + function resolveFilter(id) { + return resolveAsset(this.$options, "filters", id, true) || identity; + } + function isKeyNotMatch(expect, actual) { + if (Array.isArray(expect)) { + return expect.indexOf(actual) === -1; + } else { + return expect !== actual; + } + } + function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) { + var mappedKeyCode = config.keyCodes[key] || builtInKeyCode; + if (builtInKeyName && eventKeyName && !config.keyCodes[key]) { + return isKeyNotMatch(builtInKeyName, eventKeyName); + } else if (mappedKeyCode) { + return isKeyNotMatch(mappedKeyCode, eventKeyCode); + } else if (eventKeyName) { + return hyphenate(eventKeyName) !== key; + } + } + function bindObjectProps(data, tag, value, asProp, isSync) { + if (value) { + if (!isObject(value)) { + warn("v-bind without argument expects an Object or Array value", this); + } else { + if (Array.isArray(value)) { + value = toObject(value); + } + var hash2; + var loop = function(key2) { + if (key2 === "class" || key2 === "style" || isReservedAttribute(key2)) { + hash2 = data; + } else { + var type = data.attrs && data.attrs.type; + hash2 = asProp || config.mustUseProp(tag, type, key2) ? data.domProps || (data.domProps = {}) : data.attrs || (data.attrs = {}); + } + var camelizedKey = camelize(key2); + var hyphenatedKey = hyphenate(key2); + if (!(camelizedKey in hash2) && !(hyphenatedKey in hash2)) { + hash2[key2] = value[key2]; + if (isSync) { + var on2 = data.on || (data.on = {}); + on2["update:" + key2] = function($event) { + value[key2] = $event; + }; + } + } + }; + for (var key in value) + loop(key); + } + } + return data; + } + function renderStatic(index2, isInFor) { + var cached2 = this._staticTrees || (this._staticTrees = []); + var tree = cached2[index2]; + if (tree && !isInFor) { + return tree; + } + tree = cached2[index2] = this.$options.staticRenderFns[index2].call(this._renderProxy, null, this); + markStatic(tree, "__static__" + index2, false); + return tree; + } + function markOnce(tree, index2, key) { + markStatic(tree, "__once__" + index2 + (key ? "_" + key : ""), true); + return tree; + } + function markStatic(tree, key, isOnce) { + if (Array.isArray(tree)) { + for (var i = 0; i < tree.length; i++) { + if (tree[i] && typeof tree[i] !== "string") { + markStaticNode(tree[i], key + "_" + i, isOnce); + } + } + } else { + markStaticNode(tree, key, isOnce); + } + } + function markStaticNode(node, key, isOnce) { + node.isStatic = true; + node.key = key; + node.isOnce = isOnce; + } + function bindObjectListeners(data, value) { + if (value) { + if (!isPlainObject(value)) { + warn("v-on without argument expects an Object value", this); + } else { + var on2 = data.on = data.on ? extend({}, data.on) : {}; + for (var key in value) { + var existing = on2[key]; + var ours = value[key]; + on2[key] = existing ? [].concat(existing, ours) : ours; + } + } + } + return data; + } + function resolveScopedSlots(fns, res, hasDynamicKeys, contentHashKey) { + res = res || { $stable: !hasDynamicKeys }; + for (var i = 0; i < fns.length; i++) { + var slot = fns[i]; + if (Array.isArray(slot)) { + resolveScopedSlots(slot, res, hasDynamicKeys); + } else if (slot) { + if (slot.proxy) { + slot.fn.proxy = true; + } + res[slot.key] = slot.fn; + } + } + if (contentHashKey) { + res.$key = contentHashKey; + } + return res; + } + function bindDynamicKeys(baseObj, values) { + for (var i = 0; i < values.length; i += 2) { + var key = values[i]; + if (typeof key === "string" && key) { + baseObj[values[i]] = values[i + 1]; + } else if (key !== "" && key !== null) { + warn("Invalid value for dynamic directive argument (expected string or null): " + key, this); + } + } + return baseObj; + } + function prependModifier(value, symbol) { + return typeof value === "string" ? symbol + value : value; + } + function installRenderHelpers(target2) { + target2._o = markOnce; + target2._n = toNumber; + target2._s = toString; + target2._l = renderList; + target2._t = renderSlot; + target2._q = looseEqual; + target2._i = looseIndexOf; + target2._m = renderStatic; + target2._f = resolveFilter; + target2._k = checkKeyCodes; + target2._b = bindObjectProps; + target2._v = createTextVNode; + target2._e = createEmptyVNode; + target2._u = resolveScopedSlots; + target2._g = bindObjectListeners; + target2._d = bindDynamicKeys; + target2._p = prependModifier; + } + function FunctionalRenderContext(data, props2, children, parent, Ctor) { + var this$1 = this; + var options = Ctor.options; + var contextVm; + if (hasOwn(parent, "_uid")) { + contextVm = Object.create(parent); + contextVm._original = parent; + } else { + contextVm = parent; + parent = parent._original; + } + var isCompiled = isTrue(options._compiled); + var needNormalization = !isCompiled; + this.data = data; + this.props = props2; + this.children = children; + this.parent = parent; + this.listeners = data.on || emptyObject; + this.injections = resolveInject(options.inject, parent); + this.slots = function() { + if (!this$1.$slots) { + normalizeScopedSlots(data.scopedSlots, this$1.$slots = resolveSlots(children, parent)); + } + return this$1.$slots; + }; + Object.defineProperty(this, "scopedSlots", { + enumerable: true, + get: function get3() { + return normalizeScopedSlots(data.scopedSlots, this.slots()); + } + }); + if (isCompiled) { + this.$options = options; + this.$slots = this.slots(); + this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots); + } + if (options._scopeId) { + this._c = function(a, b, c, d) { + var vnode = createElement(contextVm, a, b, c, d, needNormalization); + if (vnode && !Array.isArray(vnode)) { + vnode.fnScopeId = options._scopeId; + vnode.fnContext = parent; + } + return vnode; + }; + } else { + this._c = function(a, b, c, d) { + return createElement(contextVm, a, b, c, d, needNormalization); + }; + } + } + installRenderHelpers(FunctionalRenderContext.prototype); + function createFunctionalComponent(Ctor, propsData, data, contextVm, children) { + var options = Ctor.options; + var props2 = {}; + var propOptions = options.props; + if (isDef(propOptions)) { + for (var key in propOptions) { + props2[key] = validateProp(key, propOptions, propsData || emptyObject); + } + } else { + if (isDef(data.attrs)) { + mergeProps(props2, data.attrs); + } + if (isDef(data.props)) { + mergeProps(props2, data.props); + } + } + var renderContext = new FunctionalRenderContext(data, props2, children, contextVm, Ctor); + var vnode = options.render.call(null, renderContext._c, renderContext); + if (vnode instanceof VNode) { + return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext); + } else if (Array.isArray(vnode)) { + var vnodes = normalizeChildren(vnode) || []; + var res = new Array(vnodes.length); + for (var i = 0; i < vnodes.length; i++) { + res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext); + } + return res; + } + } + function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) { + var clone = cloneVNode(vnode); + clone.fnContext = contextVm; + clone.fnOptions = options; + if (true) { + (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext; + } + if (data.slot) { + (clone.data || (clone.data = {})).slot = data.slot; + } + return clone; + } + function mergeProps(to, from) { + for (var key in from) { + to[camelize(key)] = from[key]; + } + } + var componentVNodeHooks = { + init: function init(vnode, hydrating) { + if (vnode.componentInstance && !vnode.componentInstance._isDestroyed && vnode.data.keepAlive) { + var mountedNode = vnode; + componentVNodeHooks.prepatch(mountedNode, mountedNode); + } else { + var child = vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance); + child.$mount(hydrating ? vnode.elm : void 0, hydrating); + } + }, + prepatch: function prepatch(oldVnode, vnode) { + var options = vnode.componentOptions; + var child = vnode.componentInstance = oldVnode.componentInstance; + updateChildComponent(child, options.propsData, options.listeners, vnode, options.children); + }, + insert: function insert(vnode) { + var context = vnode.context; + var componentInstance = vnode.componentInstance; + if (!componentInstance._isMounted) { + componentInstance._isMounted = true; + callHook(componentInstance, "mounted"); + } + if (vnode.data.keepAlive) { + if (context._isMounted) { + queueActivatedComponent(componentInstance); + } else { + activateChildComponent(componentInstance, true); + } + } + }, + destroy: function destroy(vnode) { + var componentInstance = vnode.componentInstance; + if (!componentInstance._isDestroyed) { + if (!vnode.data.keepAlive) { + componentInstance.$destroy(); + } else { + deactivateChildComponent(componentInstance, true); + } + } + } + }; + var hooksToMerge = Object.keys(componentVNodeHooks); + function createComponent(Ctor, data, context, children, tag) { + if (isUndef(Ctor)) { + return; + } + var baseCtor = context.$options._base; + if (isObject(Ctor)) { + Ctor = baseCtor.extend(Ctor); + } + if (typeof Ctor !== "function") { + if (true) { + warn("Invalid Component definition: " + String(Ctor), context); + } + return; + } + var asyncFactory; + if (isUndef(Ctor.cid)) { + asyncFactory = Ctor; + Ctor = resolveAsyncComponent(asyncFactory, baseCtor); + if (Ctor === void 0) { + return createAsyncPlaceholder(asyncFactory, data, context, children, tag); + } + } + data = data || {}; + resolveConstructorOptions(Ctor); + if (isDef(data.model)) { + transformModel(Ctor.options, data); + } + var propsData = extractPropsFromVNodeData(data, Ctor, tag); + if (isTrue(Ctor.options.functional)) { + return createFunctionalComponent(Ctor, propsData, data, context, children); + } + var listeners = data.on; + data.on = data.nativeOn; + if (isTrue(Ctor.options.abstract)) { + var slot = data.slot; + data = {}; + if (slot) { + data.slot = slot; + } + } + installComponentHooks(data); + var name = Ctor.options.name || tag; + var vnode = new VNode("vue-component-" + Ctor.cid + (name ? "-" + name : ""), data, void 0, void 0, void 0, context, { Ctor, propsData, listeners, tag, children }, asyncFactory); + return vnode; + } + function createComponentInstanceForVnode(vnode, parent) { + var options = { + _isComponent: true, + _parentVnode: vnode, + parent + }; + var inlineTemplate = vnode.data.inlineTemplate; + if (isDef(inlineTemplate)) { + options.render = inlineTemplate.render; + options.staticRenderFns = inlineTemplate.staticRenderFns; + } + return new vnode.componentOptions.Ctor(options); + } + function installComponentHooks(data) { + var hooks2 = data.hook || (data.hook = {}); + for (var i = 0; i < hooksToMerge.length; i++) { + var key = hooksToMerge[i]; + var existing = hooks2[key]; + var toMerge = componentVNodeHooks[key]; + if (existing !== toMerge && !(existing && existing._merged)) { + hooks2[key] = existing ? mergeHook$1(toMerge, existing) : toMerge; + } + } + } + function mergeHook$1(f1, f2) { + var merged = function(a, b) { + f1(a, b); + f2(a, b); + }; + merged._merged = true; + return merged; + } + function transformModel(options, data) { + var prop = options.model && options.model.prop || "value"; + var event = options.model && options.model.event || "input"; + (data.attrs || (data.attrs = {}))[prop] = data.model.value; + var on2 = data.on || (data.on = {}); + var existing = on2[event]; + var callback = data.model.callback; + if (isDef(existing)) { + if (Array.isArray(existing) ? existing.indexOf(callback) === -1 : existing !== callback) { + on2[event] = [callback].concat(existing); + } + } else { + on2[event] = callback; + } + } + var SIMPLE_NORMALIZE = 1; + var ALWAYS_NORMALIZE = 2; + function createElement(context, tag, data, children, normalizationType, alwaysNormalize) { + if (Array.isArray(data) || isPrimitive(data)) { + normalizationType = children; + children = data; + data = void 0; + } + if (isTrue(alwaysNormalize)) { + normalizationType = ALWAYS_NORMALIZE; + } + return _createElement(context, tag, data, children, normalizationType); + } + function _createElement(context, tag, data, children, normalizationType) { + if (isDef(data) && isDef(data.__ob__)) { + warn("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\nAlways create fresh vnode data objects in each render!", context); + return createEmptyVNode(); + } + if (isDef(data) && isDef(data.is)) { + tag = data.is; + } + if (!tag) { + return createEmptyVNode(); + } + if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)) { + { + warn("Avoid using non-primitive value as key, use string/number value instead.", context); + } + } + if (Array.isArray(children) && typeof children[0] === "function") { + data = data || {}; + data.scopedSlots = { default: children[0] }; + children.length = 0; + } + if (normalizationType === ALWAYS_NORMALIZE) { + children = normalizeChildren(children); + } else if (normalizationType === SIMPLE_NORMALIZE) { + children = simpleNormalizeChildren(children); + } + var vnode, ns; + if (typeof tag === "string") { + var Ctor; + ns = context.$vnode && context.$vnode.ns || config.getTagNamespace(tag); + if (config.isReservedTag(tag)) { + if (isDef(data) && isDef(data.nativeOn)) { + warn("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context); + } + vnode = new VNode(config.parsePlatformTagName(tag), data, children, void 0, void 0, context); + } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, "components", tag))) { + vnode = createComponent(Ctor, data, context, children, tag); + } else { + vnode = new VNode(tag, data, children, void 0, void 0, context); + } + } else { + vnode = createComponent(tag, data, context, children); + } + if (Array.isArray(vnode)) { + return vnode; + } else if (isDef(vnode)) { + if (isDef(ns)) { + applyNS(vnode, ns); + } + if (isDef(data)) { + registerDeepBindings(data); + } + return vnode; + } else { + return createEmptyVNode(); + } + } + function applyNS(vnode, ns, force) { + vnode.ns = ns; + if (vnode.tag === "foreignObject") { + ns = void 0; + force = true; + } + if (isDef(vnode.children)) { + for (var i = 0, l = vnode.children.length; i < l; i++) { + var child = vnode.children[i]; + if (isDef(child.tag) && (isUndef(child.ns) || isTrue(force) && child.tag !== "svg")) { + applyNS(child, ns, force); + } + } + } + } + function registerDeepBindings(data) { + if (isObject(data.style)) { + traverse(data.style); + } + if (isObject(data.class)) { + traverse(data.class); + } + } + function initRender(vm) { + vm._vnode = null; + vm._staticTrees = null; + var options = vm.$options; + var parentVnode = vm.$vnode = options._parentVnode; + var renderContext = parentVnode && parentVnode.context; + vm.$slots = resolveSlots(options._renderChildren, renderContext); + vm.$scopedSlots = emptyObject; + vm._c = function(a, b, c, d) { + return createElement(vm, a, b, c, d, false); + }; + vm.$createElement = function(a, b, c, d) { + return createElement(vm, a, b, c, d, true); + }; + var parentData = parentVnode && parentVnode.data; + if (true) { + defineReactive$$1(vm, "$attrs", parentData && parentData.attrs || emptyObject, function() { + !isUpdatingChildComponent && warn("$attrs is readonly.", vm); + }, true); + defineReactive$$1(vm, "$listeners", options._parentListeners || emptyObject, function() { + !isUpdatingChildComponent && warn("$listeners is readonly.", vm); + }, true); + } else { + defineReactive$$1(vm, "$attrs", parentData && parentData.attrs || emptyObject, null, true); + defineReactive$$1(vm, "$listeners", options._parentListeners || emptyObject, null, true); + } + } + var currentRenderingInstance = null; + function renderMixin(Vue2) { + installRenderHelpers(Vue2.prototype); + Vue2.prototype.$nextTick = function(fn) { + return nextTick(fn, this); + }; + Vue2.prototype._render = function() { + var vm = this; + var ref2 = vm.$options; + var render4 = ref2.render; + var _parentVnode = ref2._parentVnode; + if (_parentVnode) { + vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots); + } + vm.$vnode = _parentVnode; + var vnode; + try { + currentRenderingInstance = vm; + vnode = render4.call(vm._renderProxy, vm.$createElement); + } catch (e) { + handleError(e, vm, "render"); + if (vm.$options.renderError) { + try { + vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e); + } catch (e2) { + handleError(e2, vm, "renderError"); + vnode = vm._vnode; + } + } else { + vnode = vm._vnode; + } + } finally { + currentRenderingInstance = null; + } + if (Array.isArray(vnode) && vnode.length === 1) { + vnode = vnode[0]; + } + if (!(vnode instanceof VNode)) { + if (Array.isArray(vnode)) { + warn("Multiple root nodes returned from render function. Render function should return a single root node.", vm); + } + vnode = createEmptyVNode(); + } + vnode.parent = _parentVnode; + return vnode; + }; + } + function ensureCtor(comp, base) { + if (comp.__esModule || hasSymbol && comp[Symbol.toStringTag] === "Module") { + comp = comp.default; + } + return isObject(comp) ? base.extend(comp) : comp; + } + function createAsyncPlaceholder(factory, data, context, children, tag) { + var node = createEmptyVNode(); + node.asyncFactory = factory; + node.asyncMeta = { data, context, children, tag }; + return node; + } + function resolveAsyncComponent(factory, baseCtor) { + if (isTrue(factory.error) && isDef(factory.errorComp)) { + return factory.errorComp; + } + if (isDef(factory.resolved)) { + return factory.resolved; + } + var owner = currentRenderingInstance; + if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) { + factory.owners.push(owner); + } + if (isTrue(factory.loading) && isDef(factory.loadingComp)) { + return factory.loadingComp; + } + if (owner && !isDef(factory.owners)) { + var owners = factory.owners = [owner]; + var sync = true; + var timerLoading = null; + var timerTimeout = null; + owner.$on("hook:destroyed", function() { + return remove(owners, owner); + }); + var forceRender = function(renderCompleted) { + for (var i = 0, l = owners.length; i < l; i++) { + owners[i].$forceUpdate(); + } + if (renderCompleted) { + owners.length = 0; + if (timerLoading !== null) { + clearTimeout(timerLoading); + timerLoading = null; + } + if (timerTimeout !== null) { + clearTimeout(timerTimeout); + timerTimeout = null; + } + } + }; + var resolve = once(function(res2) { + factory.resolved = ensureCtor(res2, baseCtor); + if (!sync) { + forceRender(true); + } else { + owners.length = 0; + } + }); + var reject = once(function(reason) { + warn("Failed to resolve async component: " + String(factory) + (reason ? "\nReason: " + reason : "")); + if (isDef(factory.errorComp)) { + factory.error = true; + forceRender(true); + } + }); + var res = factory(resolve, reject); + if (isObject(res)) { + if (isPromise(res)) { + if (isUndef(factory.resolved)) { + res.then(resolve, reject); + } + } else if (isPromise(res.component)) { + res.component.then(resolve, reject); + if (isDef(res.error)) { + factory.errorComp = ensureCtor(res.error, baseCtor); + } + if (isDef(res.loading)) { + factory.loadingComp = ensureCtor(res.loading, baseCtor); + if (res.delay === 0) { + factory.loading = true; + } else { + timerLoading = setTimeout(function() { + timerLoading = null; + if (isUndef(factory.resolved) && isUndef(factory.error)) { + factory.loading = true; + forceRender(false); + } + }, res.delay || 200); + } + } + if (isDef(res.timeout)) { + timerTimeout = setTimeout(function() { + timerTimeout = null; + if (isUndef(factory.resolved)) { + reject(true ? "timeout (" + res.timeout + "ms)" : null); + } + }, res.timeout); + } + } + } + sync = false; + return factory.loading ? factory.loadingComp : factory.resolved; + } + } + function isAsyncPlaceholder(node) { + return node.isComment && node.asyncFactory; + } + function getFirstComponentChild(children) { + if (Array.isArray(children)) { + for (var i = 0; i < children.length; i++) { + var c = children[i]; + if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) { + return c; + } + } + } + } + function initEvents(vm) { + vm._events = /* @__PURE__ */ Object.create(null); + vm._hasHookEvent = false; + var listeners = vm.$options._parentListeners; + if (listeners) { + updateComponentListeners(vm, listeners); + } + } + var target; + function add(event, fn) { + target.$on(event, fn); + } + function remove$1(event, fn) { + target.$off(event, fn); + } + function createOnceHandler(event, fn) { + var _target = target; + return function onceHandler() { + var res = fn.apply(null, arguments); + if (res !== null) { + _target.$off(event, onceHandler); + } + }; + } + function updateComponentListeners(vm, listeners, oldListeners) { + target = vm; + updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm); + target = void 0; + } + function eventsMixin(Vue2) { + var hookRE = /^hook:/; + Vue2.prototype.$on = function(event, fn) { + var vm = this; + if (Array.isArray(event)) { + for (var i = 0, l = event.length; i < l; i++) { + vm.$on(event[i], fn); + } + } else { + (vm._events[event] || (vm._events[event] = [])).push(fn); + if (hookRE.test(event)) { + vm._hasHookEvent = true; + } + } + return vm; + }; + Vue2.prototype.$once = function(event, fn) { + var vm = this; + function on2() { + vm.$off(event, on2); + fn.apply(vm, arguments); + } + on2.fn = fn; + vm.$on(event, on2); + return vm; + }; + Vue2.prototype.$off = function(event, fn) { + var vm = this; + if (!arguments.length) { + vm._events = /* @__PURE__ */ Object.create(null); + return vm; + } + if (Array.isArray(event)) { + for (var i$1 = 0, l = event.length; i$1 < l; i$1++) { + vm.$off(event[i$1], fn); + } + return vm; + } + var cbs = vm._events[event]; + if (!cbs) { + return vm; + } + if (!fn) { + vm._events[event] = null; + return vm; + } + var cb; + var i = cbs.length; + while (i--) { + cb = cbs[i]; + if (cb === fn || cb.fn === fn) { + cbs.splice(i, 1); + break; + } + } + return vm; + }; + Vue2.prototype.$emit = function(event) { + var vm = this; + if (true) { + var lowerCaseEvent = event.toLowerCase(); + if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) { + tip('Event "' + lowerCaseEvent + '" is emitted in component ' + formatComponentName(vm) + ' but the handler is registered for "' + event + '". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "' + hyphenate(event) + '" instead of "' + event + '".'); + } + } + var cbs = vm._events[event]; + if (cbs) { + cbs = cbs.length > 1 ? toArray(cbs) : cbs; + var args = toArray(arguments, 1); + var info = 'event handler for "' + event + '"'; + for (var i = 0, l = cbs.length; i < l; i++) { + invokeWithErrorHandling(cbs[i], vm, args, vm, info); + } + } + return vm; + }; + } + var activeInstance = null; + var isUpdatingChildComponent = false; + function setActiveInstance(vm) { + var prevActiveInstance = activeInstance; + activeInstance = vm; + return function() { + activeInstance = prevActiveInstance; + }; + } + function initLifecycle(vm) { + var options = vm.$options; + var parent = options.parent; + if (parent && !options.abstract) { + while (parent.$options.abstract && parent.$parent) { + parent = parent.$parent; + } + parent.$children.push(vm); + } + vm.$parent = parent; + vm.$root = parent ? parent.$root : vm; + vm.$children = []; + vm.$refs = {}; + vm._watcher = null; + vm._inactive = null; + vm._directInactive = false; + vm._isMounted = false; + vm._isDestroyed = false; + vm._isBeingDestroyed = false; + } + function lifecycleMixin(Vue2) { + Vue2.prototype._update = function(vnode, hydrating) { + var vm = this; + var prevEl = vm.$el; + var prevVnode = vm._vnode; + var restoreActiveInstance = setActiveInstance(vm); + vm._vnode = vnode; + if (!prevVnode) { + vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false); + } else { + vm.$el = vm.__patch__(prevVnode, vnode); + } + restoreActiveInstance(); + if (prevEl) { + prevEl.__vue__ = null; + } + if (vm.$el) { + vm.$el.__vue__ = vm; + } + if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) { + vm.$parent.$el = vm.$el; + } + }; + Vue2.prototype.$forceUpdate = function() { + var vm = this; + if (vm._watcher) { + vm._watcher.update(); + } + }; + Vue2.prototype.$destroy = function() { + var vm = this; + if (vm._isBeingDestroyed) { + return; + } + callHook(vm, "beforeDestroy"); + vm._isBeingDestroyed = true; + var parent = vm.$parent; + if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) { + remove(parent.$children, vm); + } + if (vm._watcher) { + vm._watcher.teardown(); + } + var i = vm._watchers.length; + while (i--) { + vm._watchers[i].teardown(); + } + if (vm._data.__ob__) { + vm._data.__ob__.vmCount--; + } + vm._isDestroyed = true; + vm.__patch__(vm._vnode, null); + callHook(vm, "destroyed"); + vm.$off(); + if (vm.$el) { + vm.$el.__vue__ = null; + } + if (vm.$vnode) { + vm.$vnode.parent = null; + } + }; + } + function mountComponent(vm, el, hydrating) { + vm.$el = el; + if (!vm.$options.render) { + vm.$options.render = createEmptyVNode; + if (true) { + if (vm.$options.template && vm.$options.template.charAt(0) !== "#" || vm.$options.el || el) { + warn("You are using the runtime-only build of Vue where the template compiler is not available. Either pre-compile the templates into render functions, or use the compiler-included build.", vm); + } else { + warn("Failed to mount component: template or render function not defined.", vm); + } + } + } + callHook(vm, "beforeMount"); + var updateComponent; + if (config.performance && mark) { + updateComponent = function() { + var name = vm._name; + var id = vm._uid; + var startTag = "vue-perf-start:" + id; + var endTag2 = "vue-perf-end:" + id; + mark(startTag); + var vnode = vm._render(); + mark(endTag2); + measure("vue " + name + " render", startTag, endTag2); + mark(startTag); + vm._update(vnode, hydrating); + mark(endTag2); + measure("vue " + name + " patch", startTag, endTag2); + }; + } else { + updateComponent = function() { + vm._update(vm._render(), hydrating); + }; + } + new Watcher(vm, updateComponent, noop, { + before: function before() { + if (vm._isMounted && !vm._isDestroyed) { + callHook(vm, "beforeUpdate"); + } + } + }, true); + hydrating = false; + if (vm.$vnode == null) { + vm._isMounted = true; + callHook(vm, "mounted"); + } + return vm; + } + function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) { + if (true) { + isUpdatingChildComponent = true; + } + var newScopedSlots = parentVnode.data.scopedSlots; + var oldScopedSlots = vm.$scopedSlots; + var hasDynamicScopedSlot = !!(newScopedSlots && !newScopedSlots.$stable || oldScopedSlots !== emptyObject && !oldScopedSlots.$stable || newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key); + var needsForceUpdate = !!(renderChildren || vm.$options._renderChildren || hasDynamicScopedSlot); + vm.$options._parentVnode = parentVnode; + vm.$vnode = parentVnode; + if (vm._vnode) { + vm._vnode.parent = parentVnode; + } + vm.$options._renderChildren = renderChildren; + vm.$attrs = parentVnode.data.attrs || emptyObject; + vm.$listeners = listeners || emptyObject; + if (propsData && vm.$options.props) { + toggleObserving(false); + var props2 = vm._props; + var propKeys = vm.$options._propKeys || []; + for (var i = 0; i < propKeys.length; i++) { + var key = propKeys[i]; + var propOptions = vm.$options.props; + props2[key] = validateProp(key, propOptions, propsData, vm); + } + toggleObserving(true); + vm.$options.propsData = propsData; + } + listeners = listeners || emptyObject; + var oldListeners = vm.$options._parentListeners; + vm.$options._parentListeners = listeners; + updateComponentListeners(vm, listeners, oldListeners); + if (needsForceUpdate) { + vm.$slots = resolveSlots(renderChildren, parentVnode.context); + vm.$forceUpdate(); + } + if (true) { + isUpdatingChildComponent = false; + } + } + function isInInactiveTree(vm) { + while (vm && (vm = vm.$parent)) { + if (vm._inactive) { + return true; + } + } + return false; + } + function activateChildComponent(vm, direct) { + if (direct) { + vm._directInactive = false; + if (isInInactiveTree(vm)) { + return; + } + } else if (vm._directInactive) { + return; + } + if (vm._inactive || vm._inactive === null) { + vm._inactive = false; + for (var i = 0; i < vm.$children.length; i++) { + activateChildComponent(vm.$children[i]); + } + callHook(vm, "activated"); + } + } + function deactivateChildComponent(vm, direct) { + if (direct) { + vm._directInactive = true; + if (isInInactiveTree(vm)) { + return; + } + } + if (!vm._inactive) { + vm._inactive = true; + for (var i = 0; i < vm.$children.length; i++) { + deactivateChildComponent(vm.$children[i]); + } + callHook(vm, "deactivated"); + } + } + function callHook(vm, hook) { + pushTarget(); + var handlers = vm.$options[hook]; + var info = hook + " hook"; + if (handlers) { + for (var i = 0, j = handlers.length; i < j; i++) { + invokeWithErrorHandling(handlers[i], vm, null, vm, info); + } + } + if (vm._hasHookEvent) { + vm.$emit("hook:" + hook); + } + popTarget(); + } + var MAX_UPDATE_COUNT = 100; + var queue = []; + var activatedChildren = []; + var has = {}; + var circular = {}; + var waiting = false; + var flushing = false; + var index = 0; + function resetSchedulerState() { + index = queue.length = activatedChildren.length = 0; + has = {}; + if (true) { + circular = {}; + } + waiting = flushing = false; + } + var currentFlushTimestamp = 0; + var getNow = Date.now; + if (inBrowser && !isIE) { + performance = window.performance; + if (performance && typeof performance.now === "function" && getNow() > document.createEvent("Event").timeStamp) { + getNow = function() { + return performance.now(); + }; + } + } + var performance; + function flushSchedulerQueue() { + currentFlushTimestamp = getNow(); + flushing = true; + var watcher, id; + queue.sort(function(a, b) { + return a.id - b.id; + }); + for (index = 0; index < queue.length; index++) { + watcher = queue[index]; + if (watcher.before) { + watcher.before(); + } + id = watcher.id; + has[id] = null; + watcher.run(); + if (has[id] != null) { + circular[id] = (circular[id] || 0) + 1; + if (circular[id] > MAX_UPDATE_COUNT) { + warn("You may have an infinite update loop " + (watcher.user ? 'in watcher with expression "' + watcher.expression + '"' : "in a component render function."), watcher.vm); + break; + } + } + } + var activatedQueue = activatedChildren.slice(); + var updatedQueue = queue.slice(); + resetSchedulerState(); + callActivatedHooks(activatedQueue); + callUpdatedHooks(updatedQueue); + if (devtools && config.devtools) { + devtools.emit("flush"); + } + } + function callUpdatedHooks(queue2) { + var i = queue2.length; + while (i--) { + var watcher = queue2[i]; + var vm = watcher.vm; + if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) { + callHook(vm, "updated"); + } + } + } + function queueActivatedComponent(vm) { + vm._inactive = false; + activatedChildren.push(vm); + } + function callActivatedHooks(queue2) { + for (var i = 0; i < queue2.length; i++) { + queue2[i]._inactive = true; + activateChildComponent(queue2[i], true); + } + } + function queueWatcher(watcher) { + var id = watcher.id; + if (has[id] == null) { + has[id] = true; + if (!flushing) { + queue.push(watcher); + } else { + var i = queue.length - 1; + while (i > index && queue[i].id > watcher.id) { + i--; + } + queue.splice(i + 1, 0, watcher); + } + if (!waiting) { + waiting = true; + if (!config.async) { + flushSchedulerQueue(); + return; + } + nextTick(flushSchedulerQueue); + } + } + } + var uid$2 = 0; + var Watcher = function Watcher2(vm, expOrFn, cb, options, isRenderWatcher) { + this.vm = vm; + if (isRenderWatcher) { + vm._watcher = this; + } + vm._watchers.push(this); + if (options) { + this.deep = !!options.deep; + this.user = !!options.user; + this.lazy = !!options.lazy; + this.sync = !!options.sync; + this.before = options.before; + } else { + this.deep = this.user = this.lazy = this.sync = false; + } + this.cb = cb; + this.id = ++uid$2; + this.active = true; + this.dirty = this.lazy; + this.deps = []; + this.newDeps = []; + this.depIds = new _Set(); + this.newDepIds = new _Set(); + this.expression = true ? expOrFn.toString() : ""; + if (typeof expOrFn === "function") { + this.getter = expOrFn; + } else { + this.getter = parsePath(expOrFn); + if (!this.getter) { + this.getter = noop; + warn('Failed watching path: "' + expOrFn + '" Watcher only accepts simple dot-delimited paths. For full control, use a function instead.', vm); + } + } + this.value = this.lazy ? void 0 : this.get(); + }; + Watcher.prototype.get = function get() { + pushTarget(this); + var value; + var vm = this.vm; + try { + value = this.getter.call(vm, vm); + } catch (e) { + if (this.user) { + handleError(e, vm, 'getter for watcher "' + this.expression + '"'); + } else { + throw e; + } + } finally { + if (this.deep) { + traverse(value); + } + popTarget(); + this.cleanupDeps(); + } + return value; + }; + Watcher.prototype.addDep = function addDep(dep) { + var id = dep.id; + if (!this.newDepIds.has(id)) { + this.newDepIds.add(id); + this.newDeps.push(dep); + if (!this.depIds.has(id)) { + dep.addSub(this); + } + } + }; + Watcher.prototype.cleanupDeps = function cleanupDeps() { + var i = this.deps.length; + while (i--) { + var dep = this.deps[i]; + if (!this.newDepIds.has(dep.id)) { + dep.removeSub(this); + } + } + var tmp = this.depIds; + this.depIds = this.newDepIds; + this.newDepIds = tmp; + this.newDepIds.clear(); + tmp = this.deps; + this.deps = this.newDeps; + this.newDeps = tmp; + this.newDeps.length = 0; + }; + Watcher.prototype.update = function update() { + if (this.lazy) { + this.dirty = true; + } else if (this.sync) { + this.run(); + } else { + queueWatcher(this); + } + }; + Watcher.prototype.run = function run() { + if (this.active) { + var value = this.get(); + if (value !== this.value || isObject(value) || this.deep) { + var oldValue = this.value; + this.value = value; + if (this.user) { + try { + this.cb.call(this.vm, value, oldValue); + } catch (e) { + handleError(e, this.vm, 'callback for watcher "' + this.expression + '"'); + } + } else { + this.cb.call(this.vm, value, oldValue); + } + } + } + }; + Watcher.prototype.evaluate = function evaluate() { + this.value = this.get(); + this.dirty = false; + }; + Watcher.prototype.depend = function depend2() { + var i = this.deps.length; + while (i--) { + this.deps[i].depend(); + } + }; + Watcher.prototype.teardown = function teardown() { + if (this.active) { + if (!this.vm._isBeingDestroyed) { + remove(this.vm._watchers, this); + } + var i = this.deps.length; + while (i--) { + this.deps[i].removeSub(this); + } + this.active = false; + } + }; + var sharedPropertyDefinition = { + enumerable: true, + configurable: true, + get: noop, + set: noop + }; + function proxy(target2, sourceKey, key) { + sharedPropertyDefinition.get = function proxyGetter() { + return this[sourceKey][key]; + }; + sharedPropertyDefinition.set = function proxySetter(val) { + this[sourceKey][key] = val; + }; + Object.defineProperty(target2, key, sharedPropertyDefinition); + } + function initState(vm) { + vm._watchers = []; + var opts = vm.$options; + if (opts.props) { + initProps(vm, opts.props); + } + if (opts.methods) { + initMethods(vm, opts.methods); + } + if (opts.data) { + initData(vm); + } else { + observe(vm._data = {}, true); + } + if (opts.computed) { + initComputed(vm, opts.computed); + } + if (opts.watch && opts.watch !== nativeWatch) { + initWatch(vm, opts.watch); + } + } + function initProps(vm, propsOptions) { + var propsData = vm.$options.propsData || {}; + var props2 = vm._props = {}; + var keys = vm.$options._propKeys = []; + var isRoot = !vm.$parent; + if (!isRoot) { + toggleObserving(false); + } + var loop = function(key2) { + keys.push(key2); + var value = validateProp(key2, propsOptions, propsData, vm); + if (true) { + var hyphenatedKey = hyphenate(key2); + if (isReservedAttribute(hyphenatedKey) || config.isReservedAttr(hyphenatedKey)) { + warn('"' + hyphenatedKey + '" is a reserved attribute and cannot be used as component prop.', vm); + } + defineReactive$$1(props2, key2, value, function() { + if (!isRoot && !isUpdatingChildComponent) { + warn(`Avoid mutating a prop directly since the value will be overwritten whenever the parent component re-renders. Instead, use a data or computed property based on the prop's value. Prop being mutated: "` + key2 + '"', vm); + } + }); + } else { + defineReactive$$1(props2, key2, value); + } + if (!(key2 in vm)) { + proxy(vm, "_props", key2); + } + }; + for (var key in propsOptions) + loop(key); + toggleObserving(true); + } + function initData(vm) { + var data = vm.$options.data; + data = vm._data = typeof data === "function" ? getData(data, vm) : data || {}; + if (!isPlainObject(data)) { + data = {}; + warn("data functions should return an object:\nhttps://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm); + } + var keys = Object.keys(data); + var props2 = vm.$options.props; + var methods = vm.$options.methods; + var i = keys.length; + while (i--) { + var key = keys[i]; + if (true) { + if (methods && hasOwn(methods, key)) { + warn('Method "' + key + '" has already been defined as a data property.', vm); + } + } + if (props2 && hasOwn(props2, key)) { + warn('The data property "' + key + '" is already declared as a prop. Use prop default value instead.', vm); + } else if (!isReserved(key)) { + proxy(vm, "_data", key); + } + } + observe(data, true); + } + function getData(data, vm) { + pushTarget(); + try { + return data.call(vm, vm); + } catch (e) { + handleError(e, vm, "data()"); + return {}; + } finally { + popTarget(); + } + } + var computedWatcherOptions = { lazy: true }; + function initComputed(vm, computed) { + var watchers = vm._computedWatchers = /* @__PURE__ */ Object.create(null); + var isSSR = isServerRendering(); + for (var key in computed) { + var userDef = computed[key]; + var getter = typeof userDef === "function" ? userDef : userDef.get; + if (getter == null) { + warn('Getter is missing for computed property "' + key + '".', vm); + } + if (!isSSR) { + watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions); + } + if (!(key in vm)) { + defineComputed(vm, key, userDef); + } else if (true) { + if (key in vm.$data) { + warn('The computed property "' + key + '" is already defined in data.', vm); + } else if (vm.$options.props && key in vm.$options.props) { + warn('The computed property "' + key + '" is already defined as a prop.', vm); + } + } + } + } + function defineComputed(target2, key, userDef) { + var shouldCache = !isServerRendering(); + if (typeof userDef === "function") { + sharedPropertyDefinition.get = shouldCache ? createComputedGetter(key) : createGetterInvoker(userDef); + sharedPropertyDefinition.set = noop; + } else { + sharedPropertyDefinition.get = userDef.get ? shouldCache && userDef.cache !== false ? createComputedGetter(key) : createGetterInvoker(userDef.get) : noop; + sharedPropertyDefinition.set = userDef.set || noop; + } + if (sharedPropertyDefinition.set === noop) { + sharedPropertyDefinition.set = function() { + warn('Computed property "' + key + '" was assigned to but it has no setter.', this); + }; + } + Object.defineProperty(target2, key, sharedPropertyDefinition); + } + function createComputedGetter(key) { + return function computedGetter() { + var watcher = this._computedWatchers && this._computedWatchers[key]; + if (watcher) { + if (watcher.dirty) { + watcher.evaluate(); + } + if (Dep.target) { + watcher.depend(); + } + return watcher.value; + } + }; + } + function createGetterInvoker(fn) { + return function computedGetter() { + return fn.call(this, this); + }; + } + function initMethods(vm, methods) { + var props2 = vm.$options.props; + for (var key in methods) { + if (true) { + if (typeof methods[key] !== "function") { + warn('Method "' + key + '" has type "' + typeof methods[key] + '" in the component definition. Did you reference the function correctly?', vm); + } + if (props2 && hasOwn(props2, key)) { + warn('Method "' + key + '" has already been defined as a prop.', vm); + } + if (key in vm && isReserved(key)) { + warn('Method "' + key + '" conflicts with an existing Vue instance method. Avoid defining component methods that start with _ or $.'); + } + } + vm[key] = typeof methods[key] !== "function" ? noop : bind(methods[key], vm); + } + } + function initWatch(vm, watch) { + for (var key in watch) { + var handler = watch[key]; + if (Array.isArray(handler)) { + for (var i = 0; i < handler.length; i++) { + createWatcher(vm, key, handler[i]); + } + } else { + createWatcher(vm, key, handler); + } + } + } + function createWatcher(vm, expOrFn, handler, options) { + if (isPlainObject(handler)) { + options = handler; + handler = handler.handler; + } + if (typeof handler === "string") { + handler = vm[handler]; + } + return vm.$watch(expOrFn, handler, options); + } + function stateMixin(Vue2) { + var dataDef = {}; + dataDef.get = function() { + return this._data; + }; + var propsDef = {}; + propsDef.get = function() { + return this._props; + }; + if (true) { + dataDef.set = function() { + warn("Avoid replacing instance root $data. Use nested data properties instead.", this); + }; + propsDef.set = function() { + warn("$props is readonly.", this); + }; + } + Object.defineProperty(Vue2.prototype, "$data", dataDef); + Object.defineProperty(Vue2.prototype, "$props", propsDef); + Vue2.prototype.$set = set; + Vue2.prototype.$delete = del; + Vue2.prototype.$watch = function(expOrFn, cb, options) { + var vm = this; + if (isPlainObject(cb)) { + return createWatcher(vm, expOrFn, cb, options); + } + options = options || {}; + options.user = true; + var watcher = new Watcher(vm, expOrFn, cb, options); + if (options.immediate) { + try { + cb.call(vm, watcher.value); + } catch (error) { + handleError(error, vm, 'callback for immediate watcher "' + watcher.expression + '"'); + } + } + return function unwatchFn() { + watcher.teardown(); + }; + }; + } + var uid$3 = 0; + function initMixin(Vue2) { + Vue2.prototype._init = function(options) { + var vm = this; + vm._uid = uid$3++; + var startTag, endTag2; + if (config.performance && mark) { + startTag = "vue-perf-start:" + vm._uid; + endTag2 = "vue-perf-end:" + vm._uid; + mark(startTag); + } + vm._isVue = true; + if (options && options._isComponent) { + initInternalComponent(vm, options); + } else { + vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm); + } + if (true) { + initProxy(vm); + } else { + vm._renderProxy = vm; + } + vm._self = vm; + initLifecycle(vm); + initEvents(vm); + initRender(vm); + callHook(vm, "beforeCreate"); + initInjections(vm); + initState(vm); + initProvide(vm); + callHook(vm, "created"); + if (config.performance && mark) { + vm._name = formatComponentName(vm, false); + mark(endTag2); + measure("vue " + vm._name + " init", startTag, endTag2); + } + if (vm.$options.el) { + vm.$mount(vm.$options.el); + } + }; + } + function initInternalComponent(vm, options) { + var opts = vm.$options = Object.create(vm.constructor.options); + var parentVnode = options._parentVnode; + opts.parent = options.parent; + opts._parentVnode = parentVnode; + var vnodeComponentOptions = parentVnode.componentOptions; + opts.propsData = vnodeComponentOptions.propsData; + opts._parentListeners = vnodeComponentOptions.listeners; + opts._renderChildren = vnodeComponentOptions.children; + opts._componentTag = vnodeComponentOptions.tag; + if (options.render) { + opts.render = options.render; + opts.staticRenderFns = options.staticRenderFns; + } + } + function resolveConstructorOptions(Ctor) { + var options = Ctor.options; + if (Ctor.super) { + var superOptions = resolveConstructorOptions(Ctor.super); + var cachedSuperOptions = Ctor.superOptions; + if (superOptions !== cachedSuperOptions) { + Ctor.superOptions = superOptions; + var modifiedOptions = resolveModifiedOptions(Ctor); + if (modifiedOptions) { + extend(Ctor.extendOptions, modifiedOptions); + } + options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions); + if (options.name) { + options.components[options.name] = Ctor; + } + } + } + return options; + } + function resolveModifiedOptions(Ctor) { + var modified; + var latest = Ctor.options; + var sealed = Ctor.sealedOptions; + for (var key in latest) { + if (latest[key] !== sealed[key]) { + if (!modified) { + modified = {}; + } + modified[key] = latest[key]; + } + } + return modified; + } + function Vue(options) { + if (!(this instanceof Vue)) { + warn("Vue is a constructor and should be called with the `new` keyword"); + } + this._init(options); + } + initMixin(Vue); + stateMixin(Vue); + eventsMixin(Vue); + lifecycleMixin(Vue); + renderMixin(Vue); + function initUse(Vue2) { + Vue2.use = function(plugin) { + var installedPlugins = this._installedPlugins || (this._installedPlugins = []); + if (installedPlugins.indexOf(plugin) > -1) { + return this; + } + var args = toArray(arguments, 1); + args.unshift(this); + if (typeof plugin.install === "function") { + plugin.install.apply(plugin, args); + } else if (typeof plugin === "function") { + plugin.apply(null, args); + } + installedPlugins.push(plugin); + return this; + }; + } + function initMixin$1(Vue2) { + Vue2.mixin = function(mixin) { + this.options = mergeOptions(this.options, mixin); + return this; + }; + } + function initExtend(Vue2) { + Vue2.cid = 0; + var cid = 1; + Vue2.extend = function(extendOptions) { + extendOptions = extendOptions || {}; + var Super = this; + var SuperId = Super.cid; + var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {}); + if (cachedCtors[SuperId]) { + return cachedCtors[SuperId]; + } + var name = extendOptions.name || Super.options.name; + if (name) { + validateComponentName(name); + } + var Sub = function VueComponent(options) { + this._init(options); + }; + Sub.prototype = Object.create(Super.prototype); + Sub.prototype.constructor = Sub; + Sub.cid = cid++; + Sub.options = mergeOptions(Super.options, extendOptions); + Sub["super"] = Super; + if (Sub.options.props) { + initProps$1(Sub); + } + if (Sub.options.computed) { + initComputed$1(Sub); + } + Sub.extend = Super.extend; + Sub.mixin = Super.mixin; + Sub.use = Super.use; + ASSET_TYPES.forEach(function(type) { + Sub[type] = Super[type]; + }); + if (name) { + Sub.options.components[name] = Sub; + } + Sub.superOptions = Super.options; + Sub.extendOptions = extendOptions; + Sub.sealedOptions = extend({}, Sub.options); + cachedCtors[SuperId] = Sub; + return Sub; + }; + } + function initProps$1(Comp) { + var props2 = Comp.options.props; + for (var key in props2) { + proxy(Comp.prototype, "_props", key); + } + } + function initComputed$1(Comp) { + var computed = Comp.options.computed; + for (var key in computed) { + defineComputed(Comp.prototype, key, computed[key]); + } + } + function initAssetRegisters(Vue2) { + ASSET_TYPES.forEach(function(type) { + Vue2[type] = function(id, definition) { + if (!definition) { + return this.options[type + "s"][id]; + } else { + if (type === "component") { + validateComponentName(id); + } + if (type === "component" && isPlainObject(definition)) { + definition.name = definition.name || id; + definition = this.options._base.extend(definition); + } + if (type === "directive" && typeof definition === "function") { + definition = { bind: definition, update: definition }; + } + this.options[type + "s"][id] = definition; + return definition; + } + }; + }); + } + function getComponentName(opts) { + return opts && (opts.Ctor.options.name || opts.tag); + } + function matches(pattern, name) { + if (Array.isArray(pattern)) { + return pattern.indexOf(name) > -1; + } else if (typeof pattern === "string") { + return pattern.split(",").indexOf(name) > -1; + } else if (isRegExp(pattern)) { + return pattern.test(name); + } + return false; + } + function pruneCache(keepAliveInstance, filter) { + var cache = keepAliveInstance.cache; + var keys = keepAliveInstance.keys; + var _vnode = keepAliveInstance._vnode; + for (var key in cache) { + var cachedNode = cache[key]; + if (cachedNode) { + var name = getComponentName(cachedNode.componentOptions); + if (name && !filter(name)) { + pruneCacheEntry(cache, key, keys, _vnode); + } + } + } + } + function pruneCacheEntry(cache, key, keys, current) { + var cached$$1 = cache[key]; + if (cached$$1 && (!current || cached$$1.tag !== current.tag)) { + cached$$1.componentInstance.$destroy(); + } + cache[key] = null; + remove(keys, key); + } + var patternTypes = [String, RegExp, Array]; + var KeepAlive = { + name: "keep-alive", + abstract: true, + props: { + include: patternTypes, + exclude: patternTypes, + max: [String, Number] + }, + created: function created() { + this.cache = /* @__PURE__ */ Object.create(null); + this.keys = []; + }, + destroyed: function destroyed() { + for (var key in this.cache) { + pruneCacheEntry(this.cache, key, this.keys); + } + }, + mounted: function mounted() { + var this$1 = this; + this.$watch("include", function(val) { + pruneCache(this$1, function(name) { + return matches(val, name); + }); + }); + this.$watch("exclude", function(val) { + pruneCache(this$1, function(name) { + return !matches(val, name); + }); + }); + }, + render: function render() { + var slot = this.$slots.default; + var vnode = getFirstComponentChild(slot); + var componentOptions = vnode && vnode.componentOptions; + if (componentOptions) { + var name = getComponentName(componentOptions); + var ref2 = this; + var include = ref2.include; + var exclude = ref2.exclude; + if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) { + return vnode; + } + var ref$12 = this; + var cache = ref$12.cache; + var keys = ref$12.keys; + var key = vnode.key == null ? componentOptions.Ctor.cid + (componentOptions.tag ? "::" + componentOptions.tag : "") : vnode.key; + if (cache[key]) { + vnode.componentInstance = cache[key].componentInstance; + remove(keys, key); + keys.push(key); + } else { + cache[key] = vnode; + keys.push(key); + if (this.max && keys.length > parseInt(this.max)) { + pruneCacheEntry(cache, keys[0], keys, this._vnode); + } + } + vnode.data.keepAlive = true; + } + return vnode || slot && slot[0]; + } + }; + var builtInComponents = { + KeepAlive + }; + function initGlobalAPI(Vue2) { + var configDef = {}; + configDef.get = function() { + return config; + }; + if (true) { + configDef.set = function() { + warn("Do not replace the Vue.config object, set individual fields instead."); + }; + } + Object.defineProperty(Vue2, "config", configDef); + Vue2.util = { + warn, + extend, + mergeOptions, + defineReactive: defineReactive$$1 + }; + Vue2.set = set; + Vue2.delete = del; + Vue2.nextTick = nextTick; + Vue2.observable = function(obj) { + observe(obj); + return obj; + }; + Vue2.options = /* @__PURE__ */ Object.create(null); + ASSET_TYPES.forEach(function(type) { + Vue2.options[type + "s"] = /* @__PURE__ */ Object.create(null); + }); + Vue2.options._base = Vue2; + extend(Vue2.options.components, builtInComponents); + initUse(Vue2); + initMixin$1(Vue2); + initExtend(Vue2); + initAssetRegisters(Vue2); + } + initGlobalAPI(Vue); + Object.defineProperty(Vue.prototype, "$isServer", { + get: isServerRendering + }); + Object.defineProperty(Vue.prototype, "$ssrContext", { + get: function get2() { + return this.$vnode && this.$vnode.ssrContext; + } + }); + Object.defineProperty(Vue, "FunctionalRenderContext", { + value: FunctionalRenderContext + }); + Vue.version = "2.6.12"; + var isReservedAttr = makeMap("style,class"); + var acceptValue = makeMap("input,textarea,option,select,progress"); + var mustUseProp = function(tag, type, attr) { + return attr === "value" && acceptValue(tag) && type !== "button" || attr === "selected" && tag === "option" || attr === "checked" && tag === "input" || attr === "muted" && tag === "video"; + }; + var isEnumeratedAttr = makeMap("contenteditable,draggable,spellcheck"); + var isValidContentEditableValue = makeMap("events,caret,typing,plaintext-only"); + var convertEnumeratedValue = function(key, value) { + return isFalsyAttrValue(value) || value === "false" ? "false" : key === "contenteditable" && isValidContentEditableValue(value) ? value : "true"; + }; + var isBooleanAttr = makeMap("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,translate,truespeed,typemustmatch,visible"); + var xlinkNS = "http://www.w3.org/1999/xlink"; + var isXlink = function(name) { + return name.charAt(5) === ":" && name.slice(0, 5) === "xlink"; + }; + var getXlinkProp = function(name) { + return isXlink(name) ? name.slice(6, name.length) : ""; + }; + var isFalsyAttrValue = function(val) { + return val == null || val === false; + }; + function genClassForVnode(vnode) { + var data = vnode.data; + var parentNode2 = vnode; + var childNode = vnode; + while (isDef(childNode.componentInstance)) { + childNode = childNode.componentInstance._vnode; + if (childNode && childNode.data) { + data = mergeClassData(childNode.data, data); + } + } + while (isDef(parentNode2 = parentNode2.parent)) { + if (parentNode2 && parentNode2.data) { + data = mergeClassData(data, parentNode2.data); + } + } + return renderClass(data.staticClass, data.class); + } + function mergeClassData(child, parent) { + return { + staticClass: concat(child.staticClass, parent.staticClass), + class: isDef(child.class) ? [child.class, parent.class] : parent.class + }; + } + function renderClass(staticClass, dynamicClass) { + if (isDef(staticClass) || isDef(dynamicClass)) { + return concat(staticClass, stringifyClass(dynamicClass)); + } + return ""; + } + function concat(a, b) { + return a ? b ? a + " " + b : a : b || ""; + } + function stringifyClass(value) { + if (Array.isArray(value)) { + return stringifyArray(value); + } + if (isObject(value)) { + return stringifyObject(value); + } + if (typeof value === "string") { + return value; + } + return ""; + } + function stringifyArray(value) { + var res = ""; + var stringified; + for (var i = 0, l = value.length; i < l; i++) { + if (isDef(stringified = stringifyClass(value[i])) && stringified !== "") { + if (res) { + res += " "; + } + res += stringified; + } + } + return res; + } + function stringifyObject(value) { + var res = ""; + for (var key in value) { + if (value[key]) { + if (res) { + res += " "; + } + res += key; + } + } + return res; + } + var namespaceMap = { + svg: "http://www.w3.org/2000/svg", + math: "http://www.w3.org/1998/Math/MathML" + }; + var isHTMLTag = makeMap("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,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,rtc,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,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"); + var isSVG = makeMap("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view", true); + var isPreTag = function(tag) { + return tag === "pre"; + }; + var isReservedTag = function(tag) { + return isHTMLTag(tag) || isSVG(tag); + }; + function getTagNamespace(tag) { + if (isSVG(tag)) { + return "svg"; + } + if (tag === "math") { + return "math"; + } + } + var unknownElementCache = /* @__PURE__ */ Object.create(null); + function isUnknownElement(tag) { + if (!inBrowser) { + return true; + } + if (isReservedTag(tag)) { + return false; + } + tag = tag.toLowerCase(); + if (unknownElementCache[tag] != null) { + return unknownElementCache[tag]; + } + var el = document.createElement(tag); + if (tag.indexOf("-") > -1) { + return unknownElementCache[tag] = el.constructor === window.HTMLUnknownElement || el.constructor === window.HTMLElement; + } else { + return unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()); + } + } + var isTextInputType = makeMap("text,number,password,search,email,tel,url"); + function query(el) { + if (typeof el === "string") { + var selected = document.querySelector(el); + if (!selected) { + warn("Cannot find element: " + el); + return document.createElement("div"); + } + return selected; + } else { + return el; + } + } + function createElement$1(tagName2, vnode) { + var elm = document.createElement(tagName2); + if (tagName2 !== "select") { + return elm; + } + if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== void 0) { + elm.setAttribute("multiple", "multiple"); + } + return elm; + } + function createElementNS(namespace, tagName2) { + return document.createElementNS(namespaceMap[namespace], tagName2); + } + function createTextNode(text2) { + return document.createTextNode(text2); + } + function createComment(text2) { + return document.createComment(text2); + } + function insertBefore(parentNode2, newNode, referenceNode) { + parentNode2.insertBefore(newNode, referenceNode); + } + function removeChild(node, child) { + node.removeChild(child); + } + function appendChild(node, child) { + node.appendChild(child); + } + function parentNode(node) { + return node.parentNode; + } + function nextSibling(node) { + return node.nextSibling; + } + function tagName(node) { + return node.tagName; + } + function setTextContent(node, text2) { + node.textContent = text2; + } + function setStyleScope(node, scopeId) { + node.setAttribute(scopeId, ""); + } + var nodeOps = /* @__PURE__ */ Object.freeze({ + createElement: createElement$1, + createElementNS, + createTextNode, + createComment, + insertBefore, + removeChild, + appendChild, + parentNode, + nextSibling, + tagName, + setTextContent, + setStyleScope + }); + var ref = { + create: function create(_, vnode) { + registerRef(vnode); + }, + update: function update2(oldVnode, vnode) { + if (oldVnode.data.ref !== vnode.data.ref) { + registerRef(oldVnode, true); + registerRef(vnode); + } + }, + destroy: function destroy2(vnode) { + registerRef(vnode, true); + } + }; + function registerRef(vnode, isRemoval) { + var key = vnode.data.ref; + if (!isDef(key)) { + return; + } + var vm = vnode.context; + var ref2 = vnode.componentInstance || vnode.elm; + var refs = vm.$refs; + if (isRemoval) { + if (Array.isArray(refs[key])) { + remove(refs[key], ref2); + } else if (refs[key] === ref2) { + refs[key] = void 0; + } + } else { + if (vnode.data.refInFor) { + if (!Array.isArray(refs[key])) { + refs[key] = [ref2]; + } else if (refs[key].indexOf(ref2) < 0) { + refs[key].push(ref2); + } + } else { + refs[key] = ref2; + } + } + } + var emptyNode = new VNode("", {}, []); + var hooks = ["create", "activate", "update", "remove", "destroy"]; + function sameVnode(a, b) { + return a.key === b.key && (a.tag === b.tag && a.isComment === b.isComment && isDef(a.data) === isDef(b.data) && sameInputType(a, b) || isTrue(a.isAsyncPlaceholder) && a.asyncFactory === b.asyncFactory && isUndef(b.asyncFactory.error)); + } + function sameInputType(a, b) { + if (a.tag !== "input") { + return true; + } + var i; + var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type; + var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type; + return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB); + } + function createKeyToOldIdx(children, beginIdx, endIdx) { + var i, key; + var map = {}; + for (i = beginIdx; i <= endIdx; ++i) { + key = children[i].key; + if (isDef(key)) { + map[key] = i; + } + } + return map; + } + function createPatchFunction(backend) { + var i, j; + var cbs = {}; + var modules2 = backend.modules; + var nodeOps2 = backend.nodeOps; + for (i = 0; i < hooks.length; ++i) { + cbs[hooks[i]] = []; + for (j = 0; j < modules2.length; ++j) { + if (isDef(modules2[j][hooks[i]])) { + cbs[hooks[i]].push(modules2[j][hooks[i]]); + } + } + } + function emptyNodeAt(elm) { + return new VNode(nodeOps2.tagName(elm).toLowerCase(), {}, [], void 0, elm); + } + function createRmCb(childElm, listeners) { + function remove$$12() { + if (--remove$$12.listeners === 0) { + removeNode(childElm); + } + } + remove$$12.listeners = listeners; + return remove$$12; + } + function removeNode(el) { + var parent = nodeOps2.parentNode(el); + if (isDef(parent)) { + nodeOps2.removeChild(parent, el); + } + } + function isUnknownElement$$1(vnode, inVPre) { + return !inVPre && !vnode.ns && !(config.ignoredElements.length && config.ignoredElements.some(function(ignore) { + return isRegExp(ignore) ? ignore.test(vnode.tag) : ignore === vnode.tag; + })) && config.isUnknownElement(vnode.tag); + } + var creatingElmInVPre = 0; + function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index2) { + if (isDef(vnode.elm) && isDef(ownerArray)) { + vnode = ownerArray[index2] = cloneVNode(vnode); + } + vnode.isRootInsert = !nested; + if (createComponent2(vnode, insertedVnodeQueue, parentElm, refElm)) { + return; + } + var data = vnode.data; + var children = vnode.children; + var tag = vnode.tag; + if (isDef(tag)) { + if (true) { + if (data && data.pre) { + creatingElmInVPre++; + } + if (isUnknownElement$$1(vnode, creatingElmInVPre)) { + warn("Unknown custom element: <" + tag + '> - did you register the component correctly? For recursive components, make sure to provide the "name" option.', vnode.context); + } + } + vnode.elm = vnode.ns ? nodeOps2.createElementNS(vnode.ns, tag) : nodeOps2.createElement(tag, vnode); + setScope(vnode); + { + createChildren(vnode, children, insertedVnodeQueue); + if (isDef(data)) { + invokeCreateHooks(vnode, insertedVnodeQueue); + } + insert2(parentElm, vnode.elm, refElm); + } + if (data && data.pre) { + creatingElmInVPre--; + } + } else if (isTrue(vnode.isComment)) { + vnode.elm = nodeOps2.createComment(vnode.text); + insert2(parentElm, vnode.elm, refElm); + } else { + vnode.elm = nodeOps2.createTextNode(vnode.text); + insert2(parentElm, vnode.elm, refElm); + } + } + function createComponent2(vnode, insertedVnodeQueue, parentElm, refElm) { + var i2 = vnode.data; + if (isDef(i2)) { + var isReactivated = isDef(vnode.componentInstance) && i2.keepAlive; + if (isDef(i2 = i2.hook) && isDef(i2 = i2.init)) { + i2(vnode, false); + } + if (isDef(vnode.componentInstance)) { + initComponent(vnode, insertedVnodeQueue); + insert2(parentElm, vnode.elm, refElm); + if (isTrue(isReactivated)) { + reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm); + } + return true; + } + } + } + function initComponent(vnode, insertedVnodeQueue) { + if (isDef(vnode.data.pendingInsert)) { + insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert); + vnode.data.pendingInsert = null; + } + vnode.elm = vnode.componentInstance.$el; + if (isPatchable(vnode)) { + invokeCreateHooks(vnode, insertedVnodeQueue); + setScope(vnode); + } else { + registerRef(vnode); + insertedVnodeQueue.push(vnode); + } + } + function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) { + var i2; + var innerNode = vnode; + while (innerNode.componentInstance) { + innerNode = innerNode.componentInstance._vnode; + if (isDef(i2 = innerNode.data) && isDef(i2 = i2.transition)) { + for (i2 = 0; i2 < cbs.activate.length; ++i2) { + cbs.activate[i2](emptyNode, innerNode); + } + insertedVnodeQueue.push(innerNode); + break; + } + } + insert2(parentElm, vnode.elm, refElm); + } + function insert2(parent, elm, ref$$1) { + if (isDef(parent)) { + if (isDef(ref$$1)) { + if (nodeOps2.parentNode(ref$$1) === parent) { + nodeOps2.insertBefore(parent, elm, ref$$1); + } + } else { + nodeOps2.appendChild(parent, elm); + } + } + } + function createChildren(vnode, children, insertedVnodeQueue) { + if (Array.isArray(children)) { + if (true) { + checkDuplicateKeys(children); + } + for (var i2 = 0; i2 < children.length; ++i2) { + createElm(children[i2], insertedVnodeQueue, vnode.elm, null, true, children, i2); + } + } else if (isPrimitive(vnode.text)) { + nodeOps2.appendChild(vnode.elm, nodeOps2.createTextNode(String(vnode.text))); + } + } + function isPatchable(vnode) { + while (vnode.componentInstance) { + vnode = vnode.componentInstance._vnode; + } + return isDef(vnode.tag); + } + function invokeCreateHooks(vnode, insertedVnodeQueue) { + for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) { + cbs.create[i$1](emptyNode, vnode); + } + i = vnode.data.hook; + if (isDef(i)) { + if (isDef(i.create)) { + i.create(emptyNode, vnode); + } + if (isDef(i.insert)) { + insertedVnodeQueue.push(vnode); + } + } + } + function setScope(vnode) { + var i2; + if (isDef(i2 = vnode.fnScopeId)) { + nodeOps2.setStyleScope(vnode.elm, i2); + } else { + var ancestor = vnode; + while (ancestor) { + if (isDef(i2 = ancestor.context) && isDef(i2 = i2.$options._scopeId)) { + nodeOps2.setStyleScope(vnode.elm, i2); + } + ancestor = ancestor.parent; + } + } + if (isDef(i2 = activeInstance) && i2 !== vnode.context && i2 !== vnode.fnContext && isDef(i2 = i2.$options._scopeId)) { + nodeOps2.setStyleScope(vnode.elm, i2); + } + } + function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) { + for (; startIdx <= endIdx; ++startIdx) { + createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx); + } + } + function invokeDestroyHook(vnode) { + var i2, j2; + var data = vnode.data; + if (isDef(data)) { + if (isDef(i2 = data.hook) && isDef(i2 = i2.destroy)) { + i2(vnode); + } + for (i2 = 0; i2 < cbs.destroy.length; ++i2) { + cbs.destroy[i2](vnode); + } + } + if (isDef(i2 = vnode.children)) { + for (j2 = 0; j2 < vnode.children.length; ++j2) { + invokeDestroyHook(vnode.children[j2]); + } + } + } + function removeVnodes(vnodes, startIdx, endIdx) { + for (; startIdx <= endIdx; ++startIdx) { + var ch = vnodes[startIdx]; + if (isDef(ch)) { + if (isDef(ch.tag)) { + removeAndInvokeRemoveHook(ch); + invokeDestroyHook(ch); + } else { + removeNode(ch.elm); + } + } + } + } + function removeAndInvokeRemoveHook(vnode, rm) { + if (isDef(rm) || isDef(vnode.data)) { + var i2; + var listeners = cbs.remove.length + 1; + if (isDef(rm)) { + rm.listeners += listeners; + } else { + rm = createRmCb(vnode.elm, listeners); + } + if (isDef(i2 = vnode.componentInstance) && isDef(i2 = i2._vnode) && isDef(i2.data)) { + removeAndInvokeRemoveHook(i2, rm); + } + for (i2 = 0; i2 < cbs.remove.length; ++i2) { + cbs.remove[i2](vnode, rm); + } + if (isDef(i2 = vnode.data.hook) && isDef(i2 = i2.remove)) { + i2(vnode, rm); + } else { + rm(); + } + } else { + removeNode(vnode.elm); + } + } + function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) { + var oldStartIdx = 0; + var newStartIdx = 0; + var oldEndIdx = oldCh.length - 1; + var oldStartVnode = oldCh[0]; + var oldEndVnode = oldCh[oldEndIdx]; + var newEndIdx = newCh.length - 1; + var newStartVnode = newCh[0]; + var newEndVnode = newCh[newEndIdx]; + var oldKeyToIdx, idxInOld, vnodeToMove, refElm; + var canMove = !removeOnly; + if (true) { + checkDuplicateKeys(newCh); + } + while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) { + if (isUndef(oldStartVnode)) { + oldStartVnode = oldCh[++oldStartIdx]; + } else if (isUndef(oldEndVnode)) { + oldEndVnode = oldCh[--oldEndIdx]; + } else if (sameVnode(oldStartVnode, newStartVnode)) { + patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx); + oldStartVnode = oldCh[++oldStartIdx]; + newStartVnode = newCh[++newStartIdx]; + } else if (sameVnode(oldEndVnode, newEndVnode)) { + patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx); + oldEndVnode = oldCh[--oldEndIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldStartVnode, newEndVnode)) { + patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx); + canMove && nodeOps2.insertBefore(parentElm, oldStartVnode.elm, nodeOps2.nextSibling(oldEndVnode.elm)); + oldStartVnode = oldCh[++oldStartIdx]; + newEndVnode = newCh[--newEndIdx]; + } else if (sameVnode(oldEndVnode, newStartVnode)) { + patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx); + canMove && nodeOps2.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm); + oldEndVnode = oldCh[--oldEndIdx]; + newStartVnode = newCh[++newStartIdx]; + } else { + if (isUndef(oldKeyToIdx)) { + oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); + } + idxInOld = isDef(newStartVnode.key) ? oldKeyToIdx[newStartVnode.key] : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx); + if (isUndef(idxInOld)) { + createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx); + } else { + vnodeToMove = oldCh[idxInOld]; + if (sameVnode(vnodeToMove, newStartVnode)) { + patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx); + oldCh[idxInOld] = void 0; + canMove && nodeOps2.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm); + } else { + createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx); + } + } + newStartVnode = newCh[++newStartIdx]; + } + } + if (oldStartIdx > oldEndIdx) { + refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm; + addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue); + } else if (newStartIdx > newEndIdx) { + removeVnodes(oldCh, oldStartIdx, oldEndIdx); + } + } + function checkDuplicateKeys(children) { + var seenKeys = {}; + for (var i2 = 0; i2 < children.length; i2++) { + var vnode = children[i2]; + var key = vnode.key; + if (isDef(key)) { + if (seenKeys[key]) { + warn("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context); + } else { + seenKeys[key] = true; + } + } + } + } + function findIdxInOld(node, oldCh, start, end) { + for (var i2 = start; i2 < end; i2++) { + var c = oldCh[i2]; + if (isDef(c) && sameVnode(node, c)) { + return i2; + } + } + } + function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index2, removeOnly) { + if (oldVnode === vnode) { + return; + } + if (isDef(vnode.elm) && isDef(ownerArray)) { + vnode = ownerArray[index2] = cloneVNode(vnode); + } + var elm = vnode.elm = oldVnode.elm; + if (isTrue(oldVnode.isAsyncPlaceholder)) { + if (isDef(vnode.asyncFactory.resolved)) { + hydrate(oldVnode.elm, vnode, insertedVnodeQueue); + } else { + vnode.isAsyncPlaceholder = true; + } + return; + } + if (isTrue(vnode.isStatic) && isTrue(oldVnode.isStatic) && vnode.key === oldVnode.key && (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) { + vnode.componentInstance = oldVnode.componentInstance; + return; + } + var i2; + var data = vnode.data; + if (isDef(data) && isDef(i2 = data.hook) && isDef(i2 = i2.prepatch)) { + i2(oldVnode, vnode); + } + var oldCh = oldVnode.children; + var ch = vnode.children; + if (isDef(data) && isPatchable(vnode)) { + for (i2 = 0; i2 < cbs.update.length; ++i2) { + cbs.update[i2](oldVnode, vnode); + } + if (isDef(i2 = data.hook) && isDef(i2 = i2.update)) { + i2(oldVnode, vnode); + } + } + if (isUndef(vnode.text)) { + if (isDef(oldCh) && isDef(ch)) { + if (oldCh !== ch) { + updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); + } + } else if (isDef(ch)) { + if (true) { + checkDuplicateKeys(ch); + } + if (isDef(oldVnode.text)) { + nodeOps2.setTextContent(elm, ""); + } + addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue); + } else if (isDef(oldCh)) { + removeVnodes(oldCh, 0, oldCh.length - 1); + } else if (isDef(oldVnode.text)) { + nodeOps2.setTextContent(elm, ""); + } + } else if (oldVnode.text !== vnode.text) { + nodeOps2.setTextContent(elm, vnode.text); + } + if (isDef(data)) { + if (isDef(i2 = data.hook) && isDef(i2 = i2.postpatch)) { + i2(oldVnode, vnode); + } + } + } + function invokeInsertHook(vnode, queue2, initial) { + if (isTrue(initial) && isDef(vnode.parent)) { + vnode.parent.data.pendingInsert = queue2; + } else { + for (var i2 = 0; i2 < queue2.length; ++i2) { + queue2[i2].data.hook.insert(queue2[i2]); + } + } + } + var hydrationBailed = false; + var isRenderedModule = makeMap("attrs,class,staticClass,staticStyle,key"); + function hydrate(elm, vnode, insertedVnodeQueue, inVPre) { + var i2; + var tag = vnode.tag; + var data = vnode.data; + var children = vnode.children; + inVPre = inVPre || data && data.pre; + vnode.elm = elm; + if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) { + vnode.isAsyncPlaceholder = true; + return true; + } + if (true) { + if (!assertNodeMatch(elm, vnode, inVPre)) { + return false; + } + } + if (isDef(data)) { + if (isDef(i2 = data.hook) && isDef(i2 = i2.init)) { + i2(vnode, true); + } + if (isDef(i2 = vnode.componentInstance)) { + initComponent(vnode, insertedVnodeQueue); + return true; + } + } + if (isDef(tag)) { + if (isDef(children)) { + if (!elm.hasChildNodes()) { + createChildren(vnode, children, insertedVnodeQueue); + } else { + if (isDef(i2 = data) && isDef(i2 = i2.domProps) && isDef(i2 = i2.innerHTML)) { + if (i2 !== elm.innerHTML) { + if (typeof console !== "undefined" && !hydrationBailed) { + hydrationBailed = true; + console.warn("Parent: ", elm); + console.warn("server innerHTML: ", i2); + console.warn("client innerHTML: ", elm.innerHTML); + } + return false; + } + } else { + var childrenMatch = true; + var childNode = elm.firstChild; + for (var i$1 = 0; i$1 < children.length; i$1++) { + if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) { + childrenMatch = false; + break; + } + childNode = childNode.nextSibling; + } + if (!childrenMatch || childNode) { + if (typeof console !== "undefined" && !hydrationBailed) { + hydrationBailed = true; + console.warn("Parent: ", elm); + console.warn("Mismatching childNodes vs. VNodes: ", elm.childNodes, children); + } + return false; + } + } + } + } + if (isDef(data)) { + var fullInvoke = false; + for (var key in data) { + if (!isRenderedModule(key)) { + fullInvoke = true; + invokeCreateHooks(vnode, insertedVnodeQueue); + break; + } + } + if (!fullInvoke && data["class"]) { + traverse(data["class"]); + } + } + } else if (elm.data !== vnode.text) { + elm.data = vnode.text; + } + return true; + } + function assertNodeMatch(node, vnode, inVPre) { + if (isDef(vnode.tag)) { + return vnode.tag.indexOf("vue-component") === 0 || !isUnknownElement$$1(vnode, inVPre) && vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase()); + } else { + return node.nodeType === (vnode.isComment ? 8 : 3); + } + } + return function patch2(oldVnode, vnode, hydrating, removeOnly) { + if (isUndef(vnode)) { + if (isDef(oldVnode)) { + invokeDestroyHook(oldVnode); + } + return; + } + var isInitialPatch = false; + var insertedVnodeQueue = []; + if (isUndef(oldVnode)) { + isInitialPatch = true; + createElm(vnode, insertedVnodeQueue); + } else { + var isRealElement = isDef(oldVnode.nodeType); + if (!isRealElement && sameVnode(oldVnode, vnode)) { + patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly); + } else { + if (isRealElement) { + if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) { + oldVnode.removeAttribute(SSR_ATTR); + hydrating = true; + } + if (isTrue(hydrating)) { + if (hydrate(oldVnode, vnode, insertedVnodeQueue)) { + invokeInsertHook(vnode, insertedVnodeQueue, true); + return oldVnode; + } else if (true) { + warn("The client-side rendered virtual DOM tree is not matching server-rendered content. This is likely caused by incorrect HTML markup, for example nesting block-level elements inside

, or missing . Bailing hydration and performing full client-side render."); + } + } + oldVnode = emptyNodeAt(oldVnode); + } + var oldElm = oldVnode.elm; + var parentElm = nodeOps2.parentNode(oldElm); + createElm(vnode, insertedVnodeQueue, oldElm._leaveCb ? null : parentElm, nodeOps2.nextSibling(oldElm)); + if (isDef(vnode.parent)) { + var ancestor = vnode.parent; + var patchable = isPatchable(vnode); + while (ancestor) { + for (var i2 = 0; i2 < cbs.destroy.length; ++i2) { + cbs.destroy[i2](ancestor); + } + ancestor.elm = vnode.elm; + if (patchable) { + for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) { + cbs.create[i$1](emptyNode, ancestor); + } + var insert3 = ancestor.data.hook.insert; + if (insert3.merged) { + for (var i$2 = 1; i$2 < insert3.fns.length; i$2++) { + insert3.fns[i$2](); + } + } + } else { + registerRef(ancestor); + } + ancestor = ancestor.parent; + } + } + if (isDef(parentElm)) { + removeVnodes([oldVnode], 0, 0); + } else if (isDef(oldVnode.tag)) { + invokeDestroyHook(oldVnode); + } + } + } + invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch); + return vnode.elm; + }; + } + var directives = { + create: updateDirectives, + update: updateDirectives, + destroy: function unbindDirectives(vnode) { + updateDirectives(vnode, emptyNode); + } + }; + function updateDirectives(oldVnode, vnode) { + if (oldVnode.data.directives || vnode.data.directives) { + _update(oldVnode, vnode); + } + } + function _update(oldVnode, vnode) { + var isCreate = oldVnode === emptyNode; + var isDestroy = vnode === emptyNode; + var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context); + var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context); + var dirsWithInsert = []; + var dirsWithPostpatch = []; + var key, oldDir, dir; + for (key in newDirs) { + oldDir = oldDirs[key]; + dir = newDirs[key]; + if (!oldDir) { + callHook$1(dir, "bind", vnode, oldVnode); + if (dir.def && dir.def.inserted) { + dirsWithInsert.push(dir); + } + } else { + dir.oldValue = oldDir.value; + dir.oldArg = oldDir.arg; + callHook$1(dir, "update", vnode, oldVnode); + if (dir.def && dir.def.componentUpdated) { + dirsWithPostpatch.push(dir); + } + } + } + if (dirsWithInsert.length) { + var callInsert = function() { + for (var i = 0; i < dirsWithInsert.length; i++) { + callHook$1(dirsWithInsert[i], "inserted", vnode, oldVnode); + } + }; + if (isCreate) { + mergeVNodeHook(vnode, "insert", callInsert); + } else { + callInsert(); + } + } + if (dirsWithPostpatch.length) { + mergeVNodeHook(vnode, "postpatch", function() { + for (var i = 0; i < dirsWithPostpatch.length; i++) { + callHook$1(dirsWithPostpatch[i], "componentUpdated", vnode, oldVnode); + } + }); + } + if (!isCreate) { + for (key in oldDirs) { + if (!newDirs[key]) { + callHook$1(oldDirs[key], "unbind", oldVnode, oldVnode, isDestroy); + } + } + } + } + var emptyModifiers = /* @__PURE__ */ Object.create(null); + function normalizeDirectives$1(dirs, vm) { + var res = /* @__PURE__ */ Object.create(null); + if (!dirs) { + return res; + } + var i, dir; + for (i = 0; i < dirs.length; i++) { + dir = dirs[i]; + if (!dir.modifiers) { + dir.modifiers = emptyModifiers; + } + res[getRawDirName(dir)] = dir; + dir.def = resolveAsset(vm.$options, "directives", dir.name, true); + } + return res; + } + function getRawDirName(dir) { + return dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join("."); + } + function callHook$1(dir, hook, vnode, oldVnode, isDestroy) { + var fn = dir.def && dir.def[hook]; + if (fn) { + try { + fn(vnode.elm, dir, vnode, oldVnode, isDestroy); + } catch (e) { + handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook"); + } + } + } + var baseModules = [ + ref, + directives + ]; + function updateAttrs(oldVnode, vnode) { + var opts = vnode.componentOptions; + if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) { + return; + } + if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) { + return; + } + var key, cur, old; + var elm = vnode.elm; + var oldAttrs = oldVnode.data.attrs || {}; + var attrs2 = vnode.data.attrs || {}; + if (isDef(attrs2.__ob__)) { + attrs2 = vnode.data.attrs = extend({}, attrs2); + } + for (key in attrs2) { + cur = attrs2[key]; + old = oldAttrs[key]; + if (old !== cur) { + setAttr(elm, key, cur); + } + } + if ((isIE || isEdge) && attrs2.value !== oldAttrs.value) { + setAttr(elm, "value", attrs2.value); + } + for (key in oldAttrs) { + if (isUndef(attrs2[key])) { + if (isXlink(key)) { + elm.removeAttributeNS(xlinkNS, getXlinkProp(key)); + } else if (!isEnumeratedAttr(key)) { + elm.removeAttribute(key); + } + } + } + } + function setAttr(el, key, value) { + if (el.tagName.indexOf("-") > -1) { + baseSetAttr(el, key, value); + } else if (isBooleanAttr(key)) { + if (isFalsyAttrValue(value)) { + el.removeAttribute(key); + } else { + value = key === "allowfullscreen" && el.tagName === "EMBED" ? "true" : key; + el.setAttribute(key, value); + } + } else if (isEnumeratedAttr(key)) { + el.setAttribute(key, convertEnumeratedValue(key, value)); + } else if (isXlink(key)) { + if (isFalsyAttrValue(value)) { + el.removeAttributeNS(xlinkNS, getXlinkProp(key)); + } else { + el.setAttributeNS(xlinkNS, key, value); + } + } else { + baseSetAttr(el, key, value); + } + } + function baseSetAttr(el, key, value) { + if (isFalsyAttrValue(value)) { + el.removeAttribute(key); + } else { + if (isIE && !isIE9 && el.tagName === "TEXTAREA" && key === "placeholder" && value !== "" && !el.__ieph) { + var blocker = function(e) { + e.stopImmediatePropagation(); + el.removeEventListener("input", blocker); + }; + el.addEventListener("input", blocker); + el.__ieph = true; + } + el.setAttribute(key, value); + } + } + var attrs = { + create: updateAttrs, + update: updateAttrs + }; + function updateClass(oldVnode, vnode) { + var el = vnode.elm; + var data = vnode.data; + var oldData = oldVnode.data; + if (isUndef(data.staticClass) && isUndef(data.class) && (isUndef(oldData) || isUndef(oldData.staticClass) && isUndef(oldData.class))) { + return; + } + var cls = genClassForVnode(vnode); + var transitionClass = el._transitionClasses; + if (isDef(transitionClass)) { + cls = concat(cls, stringifyClass(transitionClass)); + } + if (cls !== el._prevClass) { + el.setAttribute("class", cls); + el._prevClass = cls; + } + } + var klass = { + create: updateClass, + update: updateClass + }; + var validDivisionCharRE = /[\w).+\-_$\]]/; + function parseFilters(exp) { + var inSingle = false; + var inDouble = false; + var inTemplateString = false; + var inRegex = false; + var curly = 0; + var square = 0; + var paren = 0; + var lastFilterIndex = 0; + var 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 && 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) { + var j = i - 1; + var p = void 0; + 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 || (filters = [])).push(exp.slice(lastFilterIndex, i).trim()); + lastFilterIndex = i + 1; + } + if (filters) { + for (i = 0; i < filters.length; i++) { + expression = wrapFilter(expression, filters[i]); + } + } + return expression; + } + function wrapFilter(exp, filter) { + var i = filter.indexOf("("); + if (i < 0) { + return '_f("' + filter + '")(' + exp + ")"; + } else { + var name = filter.slice(0, i); + var args = filter.slice(i + 1); + return '_f("' + name + '")(' + exp + (args !== ")" ? "," + args : args); + } + } + function baseWarn(msg, range2) { + console.error("[Vue compiler]: " + msg); + } + function pluckModuleFunction(modules2, key) { + return modules2 ? modules2.map(function(m) { + return m[key]; + }).filter(function(_) { + return _; + }) : []; + } + function addProp(el, name, value, range2, dynamic) { + (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range2)); + el.plain = false; + } + function addAttr(el, name, value, range2, dynamic) { + var attrs2 = dynamic ? el.dynamicAttrs || (el.dynamicAttrs = []) : el.attrs || (el.attrs = []); + attrs2.push(rangeSetItem({ name, value, dynamic }, range2)); + el.plain = false; + } + function addRawAttr(el, name, value, range2) { + el.attrsMap[name] = value; + el.attrsList.push(rangeSetItem({ name, value }, range2)); + } + function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range2) { + (el.directives || (el.directives = [])).push(rangeSetItem({ + name, + rawName, + value, + arg, + isDynamicArg, + modifiers + }, range2)); + el.plain = false; + } + function prependModifierMarker(symbol, name, dynamic) { + return dynamic ? "_p(" + name + ',"' + symbol + '")' : symbol + name; + } + function addHandler(el, name, value, modifiers, important, warn2, range2, dynamic) { + modifiers = modifiers || emptyObject; + if (warn2 && modifiers.prevent && modifiers.passive) { + warn2("passive and prevent can't be used together. Passive handler can't prevent default event.", range2); + } + if (modifiers.right) { + if (dynamic) { + name = "(" + name + ")==='click'?'contextmenu':(" + name + ")"; + } else if (name === "click") { + name = "contextmenu"; + delete modifiers.right; + } + } else if (modifiers.middle) { + if (dynamic) { + name = "(" + name + ")==='click'?'mouseup':(" + name + ")"; + } else if (name === "click") { + name = "mouseup"; + } + } + if (modifiers.capture) { + delete modifiers.capture; + name = prependModifierMarker("!", name, dynamic); + } + if (modifiers.once) { + delete modifiers.once; + name = prependModifierMarker("~", name, dynamic); + } + if (modifiers.passive) { + delete modifiers.passive; + name = prependModifierMarker("&", name, dynamic); + } + var events2; + if (modifiers.native) { + delete modifiers.native; + events2 = el.nativeEvents || (el.nativeEvents = {}); + } else { + events2 = el.events || (el.events = {}); + } + var newHandler = rangeSetItem({ value: value.trim(), dynamic }, range2); + if (modifiers !== emptyObject) { + newHandler.modifiers = modifiers; + } + var handlers = events2[name]; + if (Array.isArray(handlers)) { + important ? handlers.unshift(newHandler) : handlers.push(newHandler); + } else if (handlers) { + events2[name] = important ? [newHandler, handlers] : [handlers, newHandler]; + } else { + events2[name] = newHandler; + } + el.plain = false; + } + function getRawBindingAttr(el, name) { + return el.rawAttrsMap[":" + name] || el.rawAttrsMap["v-bind:" + name] || el.rawAttrsMap[name]; + } + function getBindingAttr(el, name, getStatic) { + var dynamicValue = getAndRemoveAttr(el, ":" + name) || getAndRemoveAttr(el, "v-bind:" + name); + if (dynamicValue != null) { + return parseFilters(dynamicValue); + } else if (getStatic !== false) { + var staticValue = getAndRemoveAttr(el, name); + if (staticValue != null) { + return JSON.stringify(staticValue); + } + } + } + function getAndRemoveAttr(el, name, removeFromMap) { + var val; + if ((val = el.attrsMap[name]) != null) { + var list = el.attrsList; + for (var i = 0, l = list.length; i < l; i++) { + if (list[i].name === name) { + list.splice(i, 1); + break; + } + } + } + if (removeFromMap) { + delete el.attrsMap[name]; + } + return val; + } + function getAndRemoveAttrByRegex(el, name) { + var list = el.attrsList; + for (var i = 0, l = list.length; i < l; i++) { + var attr = list[i]; + if (name.test(attr.name)) { + list.splice(i, 1); + return attr; + } + } + } + function rangeSetItem(item, range2) { + if (range2) { + if (range2.start != null) { + item.start = range2.start; + } + if (range2.end != null) { + item.end = range2.end; + } + } + return item; + } + function genComponentModel(el, value, modifiers) { + var ref2 = modifiers || {}; + var number3 = ref2.number; + var trim = ref2.trim; + var baseValueExpression = "$$v"; + var valueExpression = baseValueExpression; + if (trim) { + valueExpression = "(typeof " + baseValueExpression + " === 'string'? " + baseValueExpression + ".trim(): " + baseValueExpression + ")"; + } + if (number3) { + valueExpression = "_n(" + valueExpression + ")"; + } + var assignment = genAssignmentCode(value, valueExpression); + el.model = { + value: "(" + value + ")", + expression: JSON.stringify(value), + callback: "function (" + baseValueExpression + ") {" + assignment + "}" + }; + } + function genAssignmentCode(value, assignment) { + var res = parseModel(value); + if (res.key === null) { + return value + "=" + assignment; + } else { + return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")"; + } + } + var len; + var str; + var chr; + var index$1; + var expressionPos; + var expressionEndPos; + function parseModel(val) { + val = val.trim(); + len = val.length; + if (val.indexOf("[") < 0 || val.lastIndexOf("]") < len - 1) { + index$1 = val.lastIndexOf("."); + if (index$1 > -1) { + return { + exp: val.slice(0, index$1), + key: '"' + val.slice(index$1 + 1) + '"' + }; + } else { + return { + exp: val, + key: null + }; + } + } + str = val; + index$1 = expressionPos = expressionEndPos = 0; + while (!eof()) { + chr = next(); + if (isStringStart(chr)) { + parseString(chr); + } else if (chr === 91) { + parseBracket(chr); + } + } + return { + exp: val.slice(0, expressionPos), + key: val.slice(expressionPos + 1, expressionEndPos) + }; + } + function next() { + return str.charCodeAt(++index$1); + } + function eof() { + return index$1 >= len; + } + function isStringStart(chr2) { + return chr2 === 34 || chr2 === 39; + } + function parseBracket(chr2) { + var inBracket = 1; + expressionPos = index$1; + while (!eof()) { + chr2 = next(); + if (isStringStart(chr2)) { + parseString(chr2); + continue; + } + if (chr2 === 91) { + inBracket++; + } + if (chr2 === 93) { + inBracket--; + } + if (inBracket === 0) { + expressionEndPos = index$1; + break; + } + } + } + function parseString(chr2) { + var stringQuote = chr2; + while (!eof()) { + chr2 = next(); + if (chr2 === stringQuote) { + break; + } + } + } + var warn$1; + var RANGE_TOKEN = "__r"; + var CHECKBOX_RADIO_TOKEN = "__c"; + function model(el, dir, _warn) { + warn$1 = _warn; + var value = dir.value; + var modifiers = dir.modifiers; + var tag = el.tag; + var type = el.attrsMap.type; + if (true) { + if (tag === "input" && type === "file") { + warn$1("<" + el.tag + ' v-model="' + value + '" type="file">:\nFile inputs are read only. Use a v-on:change listener instead.', el.rawAttrsMap["v-model"]); + } + } + if (el.component) { + genComponentModel(el, value, modifiers); + return false; + } else if (tag === "select") { + genSelect(el, value, modifiers); + } else if (tag === "input" && type === "checkbox") { + genCheckboxModel(el, value, modifiers); + } else if (tag === "input" && type === "radio") { + genRadioModel(el, value, modifiers); + } else if (tag === "input" || tag === "textarea") { + genDefaultModel(el, value, modifiers); + } else if (!config.isReservedTag(tag)) { + genComponentModel(el, value, modifiers); + return false; + } else if (true) { + warn$1("<" + el.tag + ' v-model="' + value + `">: v-model is not supported on this element type. If you are working with contenteditable, it's recommended to wrap a library dedicated for that purpose inside a custom component.`, el.rawAttrsMap["v-model"]); + } + return true; + } + function genCheckboxModel(el, value, modifiers) { + var number3 = modifiers && modifiers.number; + var valueBinding = getBindingAttr(el, "value") || "null"; + var trueValueBinding = getBindingAttr(el, "true-value") || "true"; + var falseValueBinding = getBindingAttr(el, "false-value") || "false"; + addProp(el, "checked", "Array.isArray(" + value + ")?_i(" + value + "," + valueBinding + ")>-1" + (trueValueBinding === "true" ? ":(" + value + ")" : ":_q(" + value + "," + trueValueBinding + ")")); + addHandler(el, "change", "var $$a=" + value + ",$$el=$event.target,$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");if(Array.isArray($$a)){var $$v=" + (number3 ? "_n(" + valueBinding + ")" : valueBinding) + ",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(" + genAssignmentCode(value, "$$a.concat([$$v])") + ")}else{$$i>-1&&(" + genAssignmentCode(value, "$$a.slice(0,$$i).concat($$a.slice($$i+1))") + ")}}else{" + genAssignmentCode(value, "$$c") + "}", null, true); + } + function genRadioModel(el, value, modifiers) { + var number3 = modifiers && modifiers.number; + var valueBinding = getBindingAttr(el, "value") || "null"; + valueBinding = number3 ? "_n(" + valueBinding + ")" : valueBinding; + addProp(el, "checked", "_q(" + value + "," + valueBinding + ")"); + addHandler(el, "change", genAssignmentCode(value, valueBinding), null, true); + } + function genSelect(el, value, modifiers) { + var number3 = modifiers && modifiers.number; + var selectedVal = 'Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ' + (number3 ? "_n(val)" : "val") + "})"; + var assignment = "$event.target.multiple ? $$selectedVal : $$selectedVal[0]"; + var code = "var $$selectedVal = " + selectedVal + ";"; + code = code + " " + genAssignmentCode(value, assignment); + addHandler(el, "change", code, null, true); + } + function genDefaultModel(el, value, modifiers) { + var type = el.attrsMap.type; + if (true) { + var value$1 = el.attrsMap["v-bind:value"] || el.attrsMap[":value"]; + var typeBinding = el.attrsMap["v-bind:type"] || el.attrsMap[":type"]; + if (value$1 && !typeBinding) { + var binding = el.attrsMap["v-bind:value"] ? "v-bind:value" : ":value"; + warn$1(binding + '="' + value$1 + '" conflicts with v-model on the same element because the latter already expands to a value binding internally', el.rawAttrsMap[binding]); + } + } + var ref2 = modifiers || {}; + var lazy = ref2.lazy; + var number3 = ref2.number; + var trim = ref2.trim; + var needCompositionGuard = !lazy && type !== "range"; + var event = lazy ? "change" : type === "range" ? RANGE_TOKEN : "input"; + var valueExpression = "$event.target.value"; + if (trim) { + valueExpression = "$event.target.value.trim()"; + } + if (number3) { + valueExpression = "_n(" + valueExpression + ")"; + } + var code = genAssignmentCode(value, valueExpression); + if (needCompositionGuard) { + code = "if($event.target.composing)return;" + code; + } + addProp(el, "value", "(" + value + ")"); + addHandler(el, event, code, null, true); + if (trim || number3) { + addHandler(el, "blur", "$forceUpdate()"); + } + } + function normalizeEvents(on2) { + if (isDef(on2[RANGE_TOKEN])) { + var event = isIE ? "change" : "input"; + on2[event] = [].concat(on2[RANGE_TOKEN], on2[event] || []); + delete on2[RANGE_TOKEN]; + } + if (isDef(on2[CHECKBOX_RADIO_TOKEN])) { + on2.change = [].concat(on2[CHECKBOX_RADIO_TOKEN], on2.change || []); + delete on2[CHECKBOX_RADIO_TOKEN]; + } + } + var target$1; + function createOnceHandler$1(event, handler, capture) { + var _target = target$1; + return function onceHandler() { + var res = handler.apply(null, arguments); + if (res !== null) { + remove$2(event, onceHandler, capture, _target); + } + }; + } + var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53); + function add$1(name, handler, capture, passive) { + if (useMicrotaskFix) { + var attachedTimestamp = currentFlushTimestamp; + var original = handler; + handler = original._wrapper = function(e) { + if (e.target === e.currentTarget || e.timeStamp >= attachedTimestamp || e.timeStamp <= 0 || e.target.ownerDocument !== document) { + return original.apply(this, arguments); + } + }; + } + target$1.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture); + } + function remove$2(name, handler, capture, _target) { + (_target || target$1).removeEventListener(name, handler._wrapper || handler, capture); + } + function updateDOMListeners(oldVnode, vnode) { + if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) { + return; + } + var on2 = vnode.data.on || {}; + var oldOn = oldVnode.data.on || {}; + target$1 = vnode.elm; + normalizeEvents(on2); + updateListeners(on2, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context); + target$1 = void 0; + } + var events = { + create: updateDOMListeners, + update: updateDOMListeners + }; + var svgContainer; + function updateDOMProps(oldVnode, vnode) { + if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) { + return; + } + var key, cur; + var elm = vnode.elm; + var oldProps = oldVnode.data.domProps || {}; + var props2 = vnode.data.domProps || {}; + if (isDef(props2.__ob__)) { + props2 = vnode.data.domProps = extend({}, props2); + } + for (key in oldProps) { + if (!(key in props2)) { + elm[key] = ""; + } + } + for (key in props2) { + cur = props2[key]; + if (key === "textContent" || key === "innerHTML") { + if (vnode.children) { + vnode.children.length = 0; + } + if (cur === oldProps[key]) { + continue; + } + if (elm.childNodes.length === 1) { + elm.removeChild(elm.childNodes[0]); + } + } + if (key === "value" && elm.tagName !== "PROGRESS") { + elm._value = cur; + var strCur = isUndef(cur) ? "" : String(cur); + if (shouldUpdateValue(elm, strCur)) { + elm.value = strCur; + } + } else if (key === "innerHTML" && isSVG(elm.tagName) && isUndef(elm.innerHTML)) { + svgContainer = svgContainer || document.createElement("div"); + svgContainer.innerHTML = "" + cur + ""; + var svg = svgContainer.firstChild; + while (elm.firstChild) { + elm.removeChild(elm.firstChild); + } + while (svg.firstChild) { + elm.appendChild(svg.firstChild); + } + } else if (cur !== oldProps[key]) { + try { + elm[key] = cur; + } catch (e) { + } + } + } + } + function shouldUpdateValue(elm, checkVal) { + return !elm.composing && (elm.tagName === "OPTION" || isNotInFocusAndDirty(elm, checkVal) || isDirtyWithModifiers(elm, checkVal)); + } + function isNotInFocusAndDirty(elm, checkVal) { + var notInFocus = true; + try { + notInFocus = document.activeElement !== elm; + } catch (e) { + } + return notInFocus && elm.value !== checkVal; + } + function isDirtyWithModifiers(elm, newVal) { + var value = elm.value; + var modifiers = elm._vModifiers; + if (isDef(modifiers)) { + if (modifiers.number) { + return toNumber(value) !== toNumber(newVal); + } + if (modifiers.trim) { + return value.trim() !== newVal.trim(); + } + } + return value !== newVal; + } + var domProps = { + create: updateDOMProps, + update: updateDOMProps + }; + var parseStyleText = cached(function(cssText) { + var res = {}; + var listDelimiter = /;(?![^(]*\))/g; + var propertyDelimiter = /:(.+)/; + cssText.split(listDelimiter).forEach(function(item) { + if (item) { + var tmp = item.split(propertyDelimiter); + tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim()); + } + }); + return res; + }); + function normalizeStyleData(data) { + var style2 = normalizeStyleBinding(data.style); + return data.staticStyle ? extend(data.staticStyle, style2) : style2; + } + function normalizeStyleBinding(bindingStyle) { + if (Array.isArray(bindingStyle)) { + return toObject(bindingStyle); + } + if (typeof bindingStyle === "string") { + return parseStyleText(bindingStyle); + } + return bindingStyle; + } + function getStyle(vnode, checkChild) { + var res = {}; + var styleData; + if (checkChild) { + var childNode = vnode; + while (childNode.componentInstance) { + childNode = childNode.componentInstance._vnode; + if (childNode && childNode.data && (styleData = normalizeStyleData(childNode.data))) { + extend(res, styleData); + } + } + } + if (styleData = normalizeStyleData(vnode.data)) { + extend(res, styleData); + } + var parentNode2 = vnode; + while (parentNode2 = parentNode2.parent) { + if (parentNode2.data && (styleData = normalizeStyleData(parentNode2.data))) { + extend(res, styleData); + } + } + return res; + } + var cssVarRE = /^--/; + var importantRE = /\s*!important$/; + var setProp = function(el, name, val) { + if (cssVarRE.test(name)) { + el.style.setProperty(name, val); + } else if (importantRE.test(val)) { + el.style.setProperty(hyphenate(name), val.replace(importantRE, ""), "important"); + } else { + var normalizedName = normalize(name); + if (Array.isArray(val)) { + for (var i = 0, len2 = val.length; i < len2; i++) { + el.style[normalizedName] = val[i]; + } + } else { + el.style[normalizedName] = val; + } + } + }; + var vendorNames = ["Webkit", "Moz", "ms"]; + var emptyStyle; + var normalize = cached(function(prop) { + emptyStyle = emptyStyle || document.createElement("div").style; + prop = camelize(prop); + if (prop !== "filter" && prop in emptyStyle) { + return prop; + } + var capName = prop.charAt(0).toUpperCase() + prop.slice(1); + for (var i = 0; i < vendorNames.length; i++) { + var name = vendorNames[i] + capName; + if (name in emptyStyle) { + return name; + } + } + }); + function updateStyle(oldVnode, vnode) { + var data = vnode.data; + var oldData = oldVnode.data; + if (isUndef(data.staticStyle) && isUndef(data.style) && isUndef(oldData.staticStyle) && isUndef(oldData.style)) { + return; + } + var cur, name; + var el = vnode.elm; + var oldStaticStyle = oldData.staticStyle; + var oldStyleBinding = oldData.normalizedStyle || oldData.style || {}; + var oldStyle = oldStaticStyle || oldStyleBinding; + var style2 = normalizeStyleBinding(vnode.data.style) || {}; + vnode.data.normalizedStyle = isDef(style2.__ob__) ? extend({}, style2) : style2; + var newStyle = getStyle(vnode, true); + for (name in oldStyle) { + if (isUndef(newStyle[name])) { + setProp(el, name, ""); + } + } + for (name in newStyle) { + cur = newStyle[name]; + if (cur !== oldStyle[name]) { + setProp(el, name, cur == null ? "" : cur); + } + } + } + var style = { + create: updateStyle, + update: updateStyle + }; + var whitespaceRE = /\s+/; + function addClass(el, cls) { + if (!cls || !(cls = cls.trim())) { + return; + } + if (el.classList) { + if (cls.indexOf(" ") > -1) { + cls.split(whitespaceRE).forEach(function(c) { + return el.classList.add(c); + }); + } else { + el.classList.add(cls); + } + } else { + var cur = " " + (el.getAttribute("class") || "") + " "; + if (cur.indexOf(" " + cls + " ") < 0) { + el.setAttribute("class", (cur + cls).trim()); + } + } + } + function removeClass(el, cls) { + if (!cls || !(cls = cls.trim())) { + return; + } + if (el.classList) { + if (cls.indexOf(" ") > -1) { + cls.split(whitespaceRE).forEach(function(c) { + return el.classList.remove(c); + }); + } else { + el.classList.remove(cls); + } + if (!el.classList.length) { + el.removeAttribute("class"); + } + } else { + var cur = " " + (el.getAttribute("class") || "") + " "; + var tar = " " + cls + " "; + while (cur.indexOf(tar) >= 0) { + cur = cur.replace(tar, " "); + } + cur = cur.trim(); + if (cur) { + el.setAttribute("class", cur); + } else { + el.removeAttribute("class"); + } + } + } + function resolveTransition(def$$1) { + if (!def$$1) { + return; + } + if (typeof def$$1 === "object") { + var res = {}; + if (def$$1.css !== false) { + extend(res, autoCssTransition(def$$1.name || "v")); + } + extend(res, def$$1); + return res; + } else if (typeof def$$1 === "string") { + return autoCssTransition(def$$1); + } + } + var autoCssTransition = cached(function(name) { + return { + enterClass: name + "-enter", + enterToClass: name + "-enter-to", + enterActiveClass: name + "-enter-active", + leaveClass: name + "-leave", + leaveToClass: name + "-leave-to", + leaveActiveClass: name + "-leave-active" + }; + }); + var hasTransition = inBrowser && !isIE9; + var TRANSITION = "transition"; + var ANIMATION = "animation"; + var transitionProp = "transition"; + var transitionEndEvent = "transitionend"; + var animationProp = "animation"; + var animationEndEvent = "animationend"; + if (hasTransition) { + if (window.ontransitionend === void 0 && window.onwebkittransitionend !== void 0) { + transitionProp = "WebkitTransition"; + transitionEndEvent = "webkitTransitionEnd"; + } + if (window.onanimationend === void 0 && window.onwebkitanimationend !== void 0) { + animationProp = "WebkitAnimation"; + animationEndEvent = "webkitAnimationEnd"; + } + } + var raf = inBrowser ? window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : setTimeout : function(fn) { + return fn(); + }; + function nextFrame(fn) { + raf(function() { + raf(fn); + }); + } + function addTransitionClass(el, cls) { + var transitionClasses = el._transitionClasses || (el._transitionClasses = []); + if (transitionClasses.indexOf(cls) < 0) { + transitionClasses.push(cls); + addClass(el, cls); + } + } + function removeTransitionClass(el, cls) { + if (el._transitionClasses) { + remove(el._transitionClasses, cls); + } + removeClass(el, cls); + } + function whenTransitionEnds(el, expectedType, cb) { + var ref2 = getTransitionInfo(el, expectedType); + var type = ref2.type; + var timeout = ref2.timeout; + var propCount = ref2.propCount; + if (!type) { + return cb(); + } + var event = type === TRANSITION ? transitionEndEvent : animationEndEvent; + var ended = 0; + var end = function() { + el.removeEventListener(event, onEnd); + cb(); + }; + var onEnd = function(e) { + if (e.target === el) { + if (++ended >= propCount) { + end(); + } + } + }; + setTimeout(function() { + if (ended < propCount) { + end(); + } + }, timeout + 1); + el.addEventListener(event, onEnd); + } + var transformRE = /\b(transform|all)(,|$)/; + function getTransitionInfo(el, expectedType) { + var styles = window.getComputedStyle(el); + var transitionDelays = (styles[transitionProp + "Delay"] || "").split(", "); + var transitionDurations = (styles[transitionProp + "Duration"] || "").split(", "); + var transitionTimeout = getTimeout(transitionDelays, transitionDurations); + var animationDelays = (styles[animationProp + "Delay"] || "").split(", "); + var animationDurations = (styles[animationProp + "Duration"] || "").split(", "); + var animationTimeout = getTimeout(animationDelays, animationDurations); + var type; + var timeout = 0; + var 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; + } + var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + "Property"]); + return { + type, + timeout, + propCount, + hasTransform + }; + } + function getTimeout(delays, durations) { + while (delays.length < durations.length) { + delays = delays.concat(delays); + } + return Math.max.apply(null, durations.map(function(d, i) { + return toMs(d) + toMs(delays[i]); + })); + } + function toMs(s) { + return Number(s.slice(0, -1).replace(",", ".")) * 1e3; + } + function enter(vnode, toggleDisplay) { + var el = vnode.elm; + if (isDef(el._leaveCb)) { + el._leaveCb.cancelled = true; + el._leaveCb(); + } + var data = resolveTransition(vnode.data.transition); + if (isUndef(data)) { + return; + } + if (isDef(el._enterCb) || el.nodeType !== 1) { + return; + } + var css = data.css; + var type = data.type; + var enterClass = data.enterClass; + var enterToClass = data.enterToClass; + var enterActiveClass = data.enterActiveClass; + var appearClass = data.appearClass; + var appearToClass = data.appearToClass; + var appearActiveClass = data.appearActiveClass; + var beforeEnter = data.beforeEnter; + var enter2 = data.enter; + var afterEnter = data.afterEnter; + var enterCancelled = data.enterCancelled; + var beforeAppear = data.beforeAppear; + var appear = data.appear; + var afterAppear = data.afterAppear; + var appearCancelled = data.appearCancelled; + var duration = data.duration; + var context = activeInstance; + var transitionNode = activeInstance.$vnode; + while (transitionNode && transitionNode.parent) { + context = transitionNode.context; + transitionNode = transitionNode.parent; + } + var isAppear = !context._isMounted || !vnode.isRootInsert; + if (isAppear && !appear && appear !== "") { + return; + } + var startClass = isAppear && appearClass ? appearClass : enterClass; + var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass; + var toClass = isAppear && appearToClass ? appearToClass : enterToClass; + var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter; + var enterHook = isAppear ? typeof appear === "function" ? appear : enter2 : enter2; + var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter; + var enterCancelledHook = isAppear ? appearCancelled || enterCancelled : enterCancelled; + var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration); + if (explicitEnterDuration != null) { + checkDuration(explicitEnterDuration, "enter", vnode); + } + var expectsCSS = css !== false && !isIE9; + var userWantsControl = getHookArgumentsLength(enterHook); + var cb = el._enterCb = once(function() { + if (expectsCSS) { + removeTransitionClass(el, toClass); + removeTransitionClass(el, activeClass); + } + if (cb.cancelled) { + if (expectsCSS) { + removeTransitionClass(el, startClass); + } + enterCancelledHook && enterCancelledHook(el); + } else { + afterEnterHook && afterEnterHook(el); + } + el._enterCb = null; + }); + if (!vnode.data.show) { + mergeVNodeHook(vnode, "insert", function() { + var parent = el.parentNode; + var pendingNode = parent && parent._pending && parent._pending[vnode.key]; + if (pendingNode && pendingNode.tag === vnode.tag && pendingNode.elm._leaveCb) { + pendingNode.elm._leaveCb(); + } + enterHook && enterHook(el, cb); + }); + } + beforeEnterHook && beforeEnterHook(el); + if (expectsCSS) { + addTransitionClass(el, startClass); + addTransitionClass(el, activeClass); + nextFrame(function() { + removeTransitionClass(el, startClass); + if (!cb.cancelled) { + addTransitionClass(el, toClass); + if (!userWantsControl) { + if (isValidDuration(explicitEnterDuration)) { + setTimeout(cb, explicitEnterDuration); + } else { + whenTransitionEnds(el, type, cb); + } + } + } + }); + } + if (vnode.data.show) { + toggleDisplay && toggleDisplay(); + enterHook && enterHook(el, cb); + } + if (!expectsCSS && !userWantsControl) { + cb(); + } + } + function leave(vnode, rm) { + var el = vnode.elm; + if (isDef(el._enterCb)) { + el._enterCb.cancelled = true; + el._enterCb(); + } + var data = resolveTransition(vnode.data.transition); + if (isUndef(data) || el.nodeType !== 1) { + return rm(); + } + if (isDef(el._leaveCb)) { + return; + } + var css = data.css; + var type = data.type; + var leaveClass = data.leaveClass; + var leaveToClass = data.leaveToClass; + var leaveActiveClass = data.leaveActiveClass; + var beforeLeave = data.beforeLeave; + var leave2 = data.leave; + var afterLeave = data.afterLeave; + var leaveCancelled = data.leaveCancelled; + var delayLeave = data.delayLeave; + var duration = data.duration; + var expectsCSS = css !== false && !isIE9; + var userWantsControl = getHookArgumentsLength(leave2); + var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration); + if (isDef(explicitLeaveDuration)) { + checkDuration(explicitLeaveDuration, "leave", vnode); + } + var cb = el._leaveCb = once(function() { + if (el.parentNode && el.parentNode._pending) { + el.parentNode._pending[vnode.key] = null; + } + if (expectsCSS) { + removeTransitionClass(el, leaveToClass); + removeTransitionClass(el, leaveActiveClass); + } + if (cb.cancelled) { + if (expectsCSS) { + removeTransitionClass(el, leaveClass); + } + leaveCancelled && leaveCancelled(el); + } else { + rm(); + afterLeave && afterLeave(el); + } + el._leaveCb = null; + }); + if (delayLeave) { + delayLeave(performLeave); + } else { + performLeave(); + } + function performLeave() { + if (cb.cancelled) { + return; + } + if (!vnode.data.show && el.parentNode) { + (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode; + } + beforeLeave && beforeLeave(el); + if (expectsCSS) { + addTransitionClass(el, leaveClass); + addTransitionClass(el, leaveActiveClass); + nextFrame(function() { + removeTransitionClass(el, leaveClass); + if (!cb.cancelled) { + addTransitionClass(el, leaveToClass); + if (!userWantsControl) { + if (isValidDuration(explicitLeaveDuration)) { + setTimeout(cb, explicitLeaveDuration); + } else { + whenTransitionEnds(el, type, cb); + } + } + } + }); + } + leave2 && leave2(el, cb); + if (!expectsCSS && !userWantsControl) { + cb(); + } + } + } + function checkDuration(val, name, vnode) { + if (typeof val !== "number") { + warn(" explicit " + name + " duration is not a valid number - got " + JSON.stringify(val) + ".", vnode.context); + } else if (isNaN(val)) { + warn(" explicit " + name + " duration is NaN - the duration expression might be incorrect.", vnode.context); + } + } + function isValidDuration(val) { + return typeof val === "number" && !isNaN(val); + } + function getHookArgumentsLength(fn) { + if (isUndef(fn)) { + return false; + } + var invokerFns = fn.fns; + if (isDef(invokerFns)) { + return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns); + } else { + return (fn._length || fn.length) > 1; + } + } + function _enter(_, vnode) { + if (vnode.data.show !== true) { + enter(vnode); + } + } + var transition = inBrowser ? { + create: _enter, + activate: _enter, + remove: function remove$$1(vnode, rm) { + if (vnode.data.show !== true) { + leave(vnode, rm); + } else { + rm(); + } + } + } : {}; + var platformModules = [ + attrs, + klass, + events, + domProps, + style, + transition + ]; + var modules = platformModules.concat(baseModules); + var patch = createPatchFunction({ nodeOps, modules }); + if (isIE9) { + document.addEventListener("selectionchange", function() { + var el = document.activeElement; + if (el && el.vmodel) { + trigger(el, "input"); + } + }); + } + var directive = { + inserted: function inserted(el, binding, vnode, oldVnode) { + if (vnode.tag === "select") { + if (oldVnode.elm && !oldVnode.elm._vOptions) { + mergeVNodeHook(vnode, "postpatch", function() { + directive.componentUpdated(el, binding, vnode); + }); + } else { + setSelected(el, binding, vnode.context); + } + el._vOptions = [].map.call(el.options, getValue); + } else if (vnode.tag === "textarea" || isTextInputType(el.type)) { + el._vModifiers = binding.modifiers; + if (!binding.modifiers.lazy) { + el.addEventListener("compositionstart", onCompositionStart); + el.addEventListener("compositionend", onCompositionEnd); + el.addEventListener("change", onCompositionEnd); + if (isIE9) { + el.vmodel = true; + } + } + } + }, + componentUpdated: function componentUpdated(el, binding, vnode) { + if (vnode.tag === "select") { + setSelected(el, binding, vnode.context); + var prevOptions = el._vOptions; + var curOptions = el._vOptions = [].map.call(el.options, getValue); + if (curOptions.some(function(o, i) { + return !looseEqual(o, prevOptions[i]); + })) { + var needReset = el.multiple ? binding.value.some(function(v) { + return hasNoMatchingOption(v, curOptions); + }) : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions); + if (needReset) { + trigger(el, "change"); + } + } + } + } + }; + function setSelected(el, binding, vm) { + actuallySetSelected(el, binding, vm); + if (isIE || isEdge) { + setTimeout(function() { + actuallySetSelected(el, binding, vm); + }, 0); + } + } + function actuallySetSelected(el, binding, vm) { + var value = binding.value; + var isMultiple = el.multiple; + if (isMultiple && !Array.isArray(value)) { + warn('