从我来导出markdown 文档
// ==UserScript==
// @name 更好的我来导出
// @namespace https://shenzilong.cn/
// @version 1.0.3
// @description 从我来导出markdown 文档
// @author 崮生 admin@shenzilong.cn
// @include https://www.wolai.com/*
// @grant unsafeWindow
// @grant GM.setValue
// @grant GM.getValue
// @grant GM.xmlHttpRequest
// ==/UserScript==
// 这些代码都来自github actions 编译后的代码，不编译版本体积太大，不放心的欢迎去 https://github.com/2234839/userJS 审查代码,
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = "./更好的我来导出/index.user.ts");
/******/ })
/************************************************************************/
/******/ ({
/***/ "./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js":
/*!*********************************************************************!*\
!*** ./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js ***!
\*********************************************************************/
/*! exports provided: ITERATE_KEY, computed, customRef, effect, enableTracking, isProxy, isReactive, isReadonly, isRef, markRaw, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref */
/*! exports used: computed, effect, isProxy, isReactive, isRef, pauseTracking, proxyRefs, reactive, ref, resetTracking, shallowReactive, shallowReadonly, stop, toRaw, track, trigger, unref */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* unused harmony export ITERATE_KEY */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return computed; });
/* unused harmony export customRef */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return effect; });
/* unused harmony export enableTracking */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return isProxy; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return isReactive; });
/* unused harmony export isReadonly */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return isRef; });
/* unused harmony export markRaw */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return pauseTracking; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return proxyRefs; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return reactive; });
/* unused harmony export readonly */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return ref; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return resetTracking; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return shallowReactive; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "l", function() { return shallowReadonly; });
/* unused harmony export shallowRef */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "m", function() { return stop; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "n", function() { return toRaw; });
/* unused harmony export toRef */
/* unused harmony export toRefs */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "o", function() { return track; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "p", function() { return trigger; });
/* unused harmony export triggerRef */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "q", function() { return unref; });
/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js");
const targetMap = new WeakMap();
const effectStack = [];
let activeEffect;
const ITERATE_KEY = Symbol(( true) ? 'iterate' : undefined);
const MAP_KEY_ITERATE_KEY = Symbol(( true) ? 'Map key iterate' : undefined);
function isEffect(fn) {
return fn && fn._isEffect === true;
}
function effect(fn, options = _vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* EMPTY_OBJ */ "b"]) {
if (isEffect(fn)) {
fn = fn.raw;
}
const effect = createReactiveEffect(fn, options);
if (!options.lazy) {
effect();
}
return effect;
}
function stop(effect) {
if (effect.active) {
cleanup(effect);
if (effect.options.onStop) {
effect.options.onStop();
}
effect.active = false;
}
}
let uid = 0;
function createReactiveEffect(fn, options) {
const effect = function reactiveEffect() {
if (!effect.active) {
return options.scheduler ? undefined : fn();
}
if (!effectStack.includes(effect)) {
cleanup(effect);
try {
enableTracking();
effectStack.push(effect);
activeEffect = effect;
return fn();
}
finally {
effectStack.pop();
resetTracking();
activeEffect = effectStack[effectStack.length - 1];
}
}
};
effect.id = uid++;
effect._isEffect = true;
effect.active = true;
effect.raw = fn;
effect.deps = [];
effect.options = options;
return effect;
}
function cleanup(effect) {
const { deps } = effect;
if (deps.length) {
for (let i = 0; i < deps.length; i++) {
deps[i].delete(effect);
}
deps.length = 0;
}
}
let shouldTrack = true;
const trackStack = [];
function pauseTracking() {
trackStack.push(shouldTrack);
shouldTrack = false;
}
function enableTracking() {
trackStack.push(shouldTrack);
shouldTrack = true;
}
function resetTracking() {
const last = trackStack.pop();
shouldTrack = last === undefined ? true : last;
}
function track(target, type, key) {
if (!shouldTrack || activeEffect === undefined) {
return;
}
let depsMap = targetMap.get(target);
if (!depsMap) {
targetMap.set(target, (depsMap = new Map()));
}
let dep = depsMap.get(key);
if (!dep) {
depsMap.set(key, (dep = new Set()));
}
if (!dep.has(activeEffect)) {
dep.add(activeEffect);
activeEffect.deps.push(dep);
if (( true) && activeEffect.options.onTrack) {
activeEffect.options.onTrack({
effect: activeEffect,
target,
type,
key
});
}
}
}
function trigger(target, type, key, newValue, oldValue, oldTarget) {
const depsMap = targetMap.get(target);
if (!depsMap) {
// never been tracked
return;
}
const effects = new Set();
const add = (effectsToAdd) => {
if (effectsToAdd) {
effectsToAdd.forEach(effect => {
if (effect !== activeEffect) {
effects.add(effect);
}
});
}
};
if (type === "clear" /* CLEAR */) {
// collection being cleared
// trigger all effects for target
depsMap.forEach(add);
}
else if (key === 'length' && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isArray */ "n"])(target)) {
depsMap.forEach((dep, key) => {
if (key === 'length' || key >= newValue) {
add(dep);
}
});
}
else {
// schedule runs for SET | ADD | DELETE
if (key !== void 0) {
add(depsMap.get(key));
}
// also run for iteration key on ADD | DELETE | Map.SET
const shouldTriggerIteration = (type === "add" /* ADD */ &&
(!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isArray */ "n"])(target) || Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isIntegerKey */ "r"])(key))) ||
(type === "delete" /* DELETE */ && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isArray */ "n"])(target));
if (shouldTriggerIteration ||
(type === "set" /* SET */ && target instanceof Map)) {
add(depsMap.get(Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isArray */ "n"])(target) ? 'length' : ITERATE_KEY));
}
if (shouldTriggerIteration && target instanceof Map) {
add(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
const run = (effect) => {
if (( true) && effect.options.onTrigger) {
effect.options.onTrigger({
effect,
target,
key,
type,
newValue,
oldValue,
oldTarget
});
}
if (effect.options.scheduler) {
effect.options.scheduler(effect);
}
else {
effect();
}
};
effects.forEach(run);
}
const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)
.map(key => Symbol[key])
.filter(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isSymbol */ "A"]));
const get = /*#__PURE__*/ createGetter();
const shallowGet = /*#__PURE__*/ createGetter(false, true);
const readonlyGet = /*#__PURE__*/ createGetter(true);
const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
const arrayInstrumentations = {};
['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
arrayInstrumentations[key] = function (...args) {
const arr = toRaw(this);
for (let i = 0, l = this.length; i < l; i++) {
track(arr, "get" /* GET */, i + '');
}
// we run the method using the original args first (which may be reactive)
const res = arr[key](...args);
if (res === -1 || res === false) {
// if that didn't work, run it again using raw values.
return arr[key](...args.map(toRaw));
}
else {
return res;
}
};
});
function createGetter(isReadonly = false, shallow = false) {
return function get(target, key, receiver) {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* RAW */ &&
receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) {
return target;
}
const targetIsArray = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isArray */ "n"])(target);
if (targetIsArray && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* hasOwn */ "k"])(arrayInstrumentations, key)) {
return Reflect.get(arrayInstrumentations, key, receiver);
}
const res = Reflect.get(target, key, receiver);
const keyIsSymbol = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isSymbol */ "A"])(key);
if (keyIsSymbol
? builtInSymbols.has(key)
: key === `__proto__` || key === `__v_isRef`) {
return res;
}
if (!isReadonly) {
track(target, "get" /* GET */, key);
}
if (shallow) {
return res;
}
if (isRef(res)) {
// ref unwrapping - does not apply for Array + integer key.
const shouldUnwrap = !targetIsArray || !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isIntegerKey */ "r"])(key);
return shouldUnwrap ? res.value : res;
}
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isObject */ "t"])(res)) {
// Convert returned value into a proxy as well. we do the isObject check
// here to avoid invalid value warning. Also need to lazy access readonly
// and reactive here to avoid circular dependency.
return isReadonly ? readonly(res) : reactive(res);
}
return res;
};
}
const set = /*#__PURE__*/ createSetter();
const shallowSet = /*#__PURE__*/ createSetter(true);
function createSetter(shallow = false) {
return function set(target, key, value, receiver) {
const oldValue = target[key];
if (!shallow) {
value = toRaw(value);
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isArray */ "n"])(target) && isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
}
}
const hadKey = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isArray */ "n"])(target) && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isIntegerKey */ "r"])(key)
? Number(key) < target.length
: Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* hasOwn */ "k"])(target, key);
const result = Reflect.set(target, key, value, receiver);
// don't trigger if target is something up in the prototype chain of original
if (target === toRaw(receiver)) {
if (!hadKey) {
trigger(target, "add" /* ADD */, key, value);
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* hasChanged */ "j"])(value, oldValue)) {
trigger(target, "set" /* SET */, key, value, oldValue);
}
}
return result;
};
}
function deleteProperty(target, key) {
const hadKey = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* hasOwn */ "k"])(target, key);
const oldValue = target[key];
const result = Reflect.deleteProperty(target, key);
if (result && hadKey) {
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
}
return result;
}
function has(target, key) {
const result = Reflect.has(target, key);
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isSymbol */ "A"])(key) || !builtInSymbols.has(key)) {
track(target, "has" /* HAS */, key);
}
return result;
}
function ownKeys(target) {
track(target, "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.ownKeys(target);
}
const mutableHandlers = {
get,
set,
deleteProperty,
has,
ownKeys
};
const readonlyHandlers = {
get: readonlyGet,
set(target, key) {
if ((true)) {
console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
}
return true;
},
deleteProperty(target, key) {
if ((true)) {
console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
}
return true;
}
};
const shallowReactiveHandlers = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* extend */ "h"])({}, mutableHandlers, {
get: shallowGet,
set: shallowSet
});
// Props handlers are special in the sense that it should not unwrap top-level
// refs (in order to allow refs to be explicitly passed down), but should
// retain the reactivity of the normal readonly object.
const shallowReadonlyHandlers = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* extend */ "h"])({}, readonlyHandlers, {
get: shallowReadonlyGet
});
const toReactive = (value) => Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isObject */ "t"])(value) ? reactive(value) : value;
const toReadonly = (value) => Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isObject */ "t"])(value) ? readonly(value) : value;
const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function get$1(target, key, isReadonly = false, isShallow = false) {
// #1772: readonly(reactive(Map)) should return readonly + reactive version
// of the value
target = target["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
!isReadonly && track(rawTarget, "get" /* GET */, key);
}
!isReadonly && track(rawTarget, "get" /* GET */, rawKey);
const { has } = getProto(rawTarget);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
if (has.call(rawTarget, key)) {
return wrap(target.get(key));
}
else if (has.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
}
}
function has$1(key, isReadonly = false) {
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
!isReadonly && track(rawTarget, "has" /* HAS */, key);
}
!isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
return key === rawKey
? target.has(key)
: target.has(key) || target.has(rawKey);
}
function size(target, isReadonly = false) {
target = target["__v_raw" /* RAW */];
!isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
return Reflect.get(target, 'size', target);
}
function add(value) {
value = toRaw(value);
const target = toRaw(this);
const proto = getProto(target);
const hadKey = proto.has.call(target, value);
const result = proto.add.call(target, value);
if (!hadKey) {
trigger(target, "add" /* ADD */, value, value);
}
return result;
}
function set$1(key, value) {
value = toRaw(value);
const target = toRaw(this);
const { has, get, set } = getProto(target);
let hadKey = has.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has.call(target, key);
}
else if ((true)) {
checkIdentityKeys(target, has, key);
}
const oldValue = get.call(target, key);
const result = set.call(target, key, value);
if (!hadKey) {
trigger(target, "add" /* ADD */, key, value);
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* hasChanged */ "j"])(value, oldValue)) {
trigger(target, "set" /* SET */, key, value, oldValue);
}
return result;
}
function deleteEntry(key) {
const target = toRaw(this);
const { has, get, delete: del } = getProto(target);
let hadKey = has.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has.call(target, key);
}
else if ((true)) {
checkIdentityKeys(target, has, key);
}
const oldValue = get ? get.call(target, key) : undefined;
// forward the operation before queueing reactions
const result = del.call(target, key);
if (hadKey) {
trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
}
return result;
}
function clear() {
const target = toRaw(this);
const hadItems = target.size !== 0;
const oldTarget = ( true)
? target instanceof Map
? new Map(target)
: new Set(target)
: undefined;
// forward the operation before queueing reactions
const result = getProto(target).clear.call(target);
if (hadItems) {
trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);
}
return result;
}
function createForEach(isReadonly, isShallow) {
return function forEach(callback, thisArg) {
const observed = this;
const target = observed["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
return target.forEach((value, key) => {
// important: make sure the callback is
// 1. invoked with the reactive map as `this` and 3rd arg
// 2. the value received should be a corresponding reactive/readonly.
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
};
}
function createIterableMethod(method, isReadonly, isShallow) {
return function (...args) {
const target = this["__v_raw" /* RAW */];
const rawTarget = toRaw(target);
const isMap = rawTarget instanceof Map;
const isPair = method === 'entries' || (method === Symbol.iterator && isMap);
const isKeyOnly = method === 'keys' && isMap;
const innerIterator = target[method](...args);
const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive;
!isReadonly &&
track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
// return a wrapped iterator which returns observed versions of the
// values emitted from the real iterator
return {
// iterator protocol
next() {
const { value, done } = innerIterator.next();
return done
? { value, done }
: {
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
done
};
},
// iterable protocol
[Symbol.iterator]() {
return this;
}
};
};
}
function createReadonlyMethod(type) {
return function (...args) {
if ((true)) {
const key = args[0] ? `on key "${args[0]}" ` : ``;
console.warn(`${Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* capitalize */ "f"])(type)} operation ${key}failed: target is readonly.`, toRaw(this));
}
return type === "delete" /* DELETE */ ? false : this;
};
}
const mutableInstrumentations = {
get(key) {
return get$1(this, key);
},
get size() {
return size(this);
},
has: has$1,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, false)
};
const shallowInstrumentations = {
get(key) {
return get$1(this, key, false, true);
},
get size() {
return size(this);
},
has: has$1,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, true)
};
const readonlyInstrumentations = {
get(key) {
return get$1(this, key, true);
},
get size() {
return size(this, true);
},
has(key) {
return has$1.call(this, key, true);
},
add: createReadonlyMethod("add" /* ADD */),
set: createReadonlyMethod("set" /* SET */),
delete: createReadonlyMethod("delete" /* DELETE */),
clear: createReadonlyMethod("clear" /* CLEAR */),
forEach: createForEach(true, false)
};
const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
iteratorMethods.forEach(method => {
mutableInstrumentations[method] = createIterableMethod(method, false, false);
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
shallowInstrumentations[method] = createIterableMethod(method, false, true);
});
function createInstrumentationGetter(isReadonly, shallow) {
const instrumentations = shallow
? shallowInstrumentations
: isReadonly
? readonlyInstrumentations
: mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive" /* IS_REACTIVE */) {
return !isReadonly;
}
else if (key === "__v_isReadonly" /* IS_READONLY */) {
return isReadonly;
}
else if (key === "__v_raw" /* RAW */) {
return target;
}
return Reflect.get(Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* hasOwn */ "k"])(instrumentations, key) && key in target
? instrumentations
: target, key, receiver);
};
}
const mutableCollectionHandlers = {
get: createInstrumentationGetter(false, false)
};
const shallowCollectionHandlers = {
get: createInstrumentationGetter(false, true)
};
const readonlyCollectionHandlers = {
get: createInstrumentationGetter(true, false)
};
function checkIdentityKeys(target, has, key) {
const rawKey = toRaw(key);
if (rawKey !== key && has.call(target, rawKey)) {
const type = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* toRawType */ "I"])(target);
console.warn(`Reactive ${type} contains both the raw and reactive ` +
`versions of the same object${type === `Map` ? `as keys` : ``}, ` +
`which can lead to inconsistencies. ` +
`Avoid differentiating between the raw and reactive versions ` +
`of an object and only use the reactive version if possible.`);
}
}
const reactiveMap = new WeakMap();
const readonlyMap = new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case 'Object':
case 'Array':
return 1 /* COMMON */;
case 'Map':
case 'Set':
case 'WeakMap':
case 'WeakSet':
return 2 /* COLLECTION */;
default:
return 0 /* INVALID */;
}
}
function getTargetType(value) {
return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
? 0 /* INVALID */
: targetTypeMap(Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* toRawType */ "I"])(value));
}
function reactive(target) {
// if trying to observe a readonly proxy, return the readonly version.
if (target && target["__v_isReadonly" /* IS_READONLY */]) {
return target;
}
return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);
}
// Return a reactive-copy of the original object, where only the root level
// properties are reactive, and does NOT unwrap refs nor recursively convert
// returned properties.
function shallowReactive(target) {
return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers);
}
function readonly(target) {
return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);
}
// Return a reactive-copy of the original object, where only the root level
// properties are readonly, and does NOT unwrap refs nor recursively convert
// returned properties.
// This is used for creating the props proxy object for stateful components.
function shallowReadonly(target) {
return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);
}
function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isObject */ "t"])(target)) {
if ((true)) {
console.warn(`value cannot be made reactive: ${String(target)}`);
}
return target;
}
// target is already a Proxy, return it.
// exception: calling readonly() on a reactive object
if (target["__v_raw" /* RAW */] &&
!(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
return target;
}
// target already has corresponding Proxy
const proxyMap = isReadonly ? readonlyMap : reactiveMap;
const existingProxy = proxyMap.get(target);
if (existingProxy) {
return existingProxy;
}
// only a whitelist of value types can be observed.
const targetType = getTargetType(target);
if (targetType === 0 /* INVALID */) {
return target;
}
const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
proxyMap.set(target, proxy);
return proxy;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value["__v_raw" /* RAW */]);
}
return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
}
function isReadonly(value) {
return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
}
function isProxy(value) {
return isReactive(value) || isReadonly(value);
}
function toRaw(observed) {
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
}
function markRaw(value) {
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* def */ "g"])(value, "__v_skip" /* SKIP */, true);
return value;
}
const convert = (val) => Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isObject */ "t"])(val) ? reactive(val) : val;
function isRef(r) {
return Boolean(r && r.__v_isRef === true);
}
function ref(value) {
return createRef(value);
}
function shallowRef(value) {
return createRef(value, true);
}
class RefImpl {
constructor(_rawValue, _shallow = false) {
this._rawValue = _rawValue;
this._shallow = _shallow;
this.__v_isRef = true;
this._value = _shallow ? _rawValue : convert(_rawValue);
}
get value() {
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newVal) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* hasChanged */ "j"])(toRaw(newVal), this._rawValue)) {
this._rawValue = newVal;
this._value = this._shallow ? newVal : convert(newVal);
trigger(toRaw(this), "set" /* SET */, 'value', newVal);
}
}
}
function createRef(rawValue, shallow = false) {
if (isRef(rawValue)) {
return rawValue;
}
return new RefImpl(rawValue, shallow);
}
function triggerRef(ref) {
trigger(ref, "set" /* SET */, 'value', ( true) ? ref.value : undefined);
}
function unref(ref) {
return isRef(ref) ? ref.value : ref;
}
const shallowUnwrapHandlers = {
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
set: (target, key, value, receiver) => {
const oldValue = target[key];
if (isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
}
else {
return Reflect.set(target, key, value, receiver);
}
}
};
function proxyRefs(objectWithRefs) {
return isReactive(objectWithRefs)
? objectWithRefs
: new Proxy(objectWithRefs, shallowUnwrapHandlers);
}
class CustomRefImpl {
constructor(factory) {
this.__v_isRef = true;
const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value'));
this._get = get;
this._set = set;
}
get value() {
return this._get();
}
set value(newVal) {
this._set(newVal);
}
}
function customRef(factory) {
return new CustomRefImpl(factory);
}
function toRefs(object) {
if (( true) && !isProxy(object)) {
console.warn(`toRefs() expects a reactive object but received a plain one.`);
}
const ret = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isArray */ "n"])(object) ? new Array(object.length) : {};
for (const key in object) {
ret[key] = toRef(object, key);
}
return ret;
}
class ObjectRefImpl {
constructor(_object, _key) {
this._object = _object;
this._key = _key;
this.__v_isRef = true;
}
get value() {
return this._object[this._key];
}
set value(newVal) {
this._object[this._key] = newVal;
}
}
function toRef(object, key) {
return new ObjectRefImpl(object, key);
}
class ComputedRefImpl {
constructor(getter, _setter, isReadonly) {
this._setter = _setter;
this._dirty = true;
this.__v_isRef = true;
this.effect = effect(getter, {
lazy: true,
scheduler: () => {
if (!this._dirty) {
this._dirty = true;
trigger(toRaw(this), "set" /* SET */, 'value');
}
}
});
this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
}
get value() {
if (this._dirty) {
this._value = this.effect();
this._dirty = false;
}
track(toRaw(this), "get" /* GET */, 'value');
return this._value;
}
set value(newValue) {
this._setter(newValue);
}
}
function computed(getterOrOptions) {
let getter;
let setter;
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isFunction */ "o"])(getterOrOptions)) {
getter = getterOrOptions;
setter = ( true)
? () => {
console.warn('Write operation failed: computed value is readonly');
}
: undefined;
}
else {
getter = getterOrOptions.get;
setter = getterOrOptions.set;
}
return new ComputedRefImpl(getter, setter, Object(_vue_shared__WEBPACK_IMPORTED_MODULE_0__[/* isFunction */ "o"])(getterOrOptions) || !getterOrOptions.set);
}
/***/ }),
/***/ "./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js":
/*!*************************************************************************!*\
!*** ./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js ***!
\*************************************************************************/
/*! exports provided: customRef, isProxy, isReactive, isReadonly, isRef, markRaw, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, camelize, capitalize, toDisplayString, BaseTransition, Comment, Fragment, KeepAlive, Static, Suspense, Teleport, Text, callWithAsyncErrorHandling, callWithErrorHandling, cloneVNode, computed, createBlock, createCommentVNode, createHydrationRenderer, createRenderer, createSlots, createStaticVNode, createTextVNode, createVNode, defineAsyncComponent, defineComponent, devtools, getCurrentInstance, getTransitionRawChildren, h, handleError, inject, isVNode, mergeProps, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onUnmounted, onUpdated, openBlock, popScopeId, provide, pushScopeId, queuePostFlushCb, registerRuntimeCompiler, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveTransitionHooks, setBlockTracking, setDevtoolsHook, setTransitionHooks, ssrContextKey, ssrUtils, toHandlers, transformVNodeArgs, useSSRContext, useTransitionState, version, warn, watch, watchEffect, withCtx, withDirectives, withScopeId */
/*! exports used: BaseTransition, Fragment, callWithAsyncErrorHandling, camelize, createHydrationRenderer, createRenderer, createVNode, getCurrentInstance, getTransitionRawChildren, h, onMounted, onUpdated, reactive, resolveTransitionHooks, setDevtoolsHook, setTransitionHooks, unref, useTransitionState, warn, watchEffect */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return BaseTransition; });
/* unused harmony export Comment */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return Fragment; });
/* unused harmony export KeepAlive */
/* unused harmony export Static */
/* unused harmony export Suspense */
/* unused harmony export Teleport */
/* unused harmony export Text */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return callWithAsyncErrorHandling; });
/* unused harmony export callWithErrorHandling */
/* unused harmony export cloneVNode */
/* unused harmony export computed */
/* unused harmony export createBlock */
/* unused harmony export createCommentVNode */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return createHydrationRenderer; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return createRenderer; });
/* unused harmony export createSlots */
/* unused harmony export createStaticVNode */
/* unused harmony export createTextVNode */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return createVNode; });
/* unused harmony export defineAsyncComponent */
/* unused harmony export defineComponent */
/* unused harmony export devtools */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return getCurrentInstance; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return getTransitionRawChildren; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return h; });
/* unused harmony export handleError */
/* unused harmony export inject */
/* unused harmony export isVNode */
/* unused harmony export mergeProps */
/* unused harmony export nextTick */
/* unused harmony export onActivated */
/* unused harmony export onBeforeMount */
/* unused harmony export onBeforeUnmount */
/* unused harmony export onBeforeUpdate */
/* unused harmony export onDeactivated */
/* unused harmony export onErrorCaptured */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return onMounted; });
/* unused harmony export onRenderTracked */
/* unused harmony export onRenderTriggered */
/* unused harmony export onUnmounted */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "l", function() { return onUpdated; });
/* unused harmony export openBlock */
/* unused harmony export popScopeId */
/* unused harmony export provide */
/* unused harmony export pushScopeId */
/* unused harmony export queuePostFlushCb */
/* unused harmony export registerRuntimeCompiler */
/* unused harmony export renderList */
/* unused harmony export renderSlot */
/* unused harmony export resolveComponent */
/* unused harmony export resolveDirective */
/* unused harmony export resolveDynamicComponent */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "n", function() { return resolveTransitionHooks; });
/* unused harmony export setBlockTracking */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "o", function() { return setDevtoolsHook; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "p", function() { return setTransitionHooks; });
/* unused harmony export ssrContextKey */
/* unused harmony export ssrUtils */
/* unused harmony export toHandlers */
/* unused harmony export transformVNodeArgs */
/* unused harmony export useSSRContext */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "r", function() { return useTransitionState; });
/* unused harmony export version */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "s", function() { return warn; });
/* unused harmony export watch */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "t", function() { return watchEffect; });
/* unused harmony export withCtx */
/* unused harmony export withDirectives */
/* unused harmony export withScopeId */
/* harmony import */ var _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/reactivity */ "./node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js");
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "m", function() { return _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__["h"]; });
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "q", function() { return _vue_reactivity__WEBPACK_IMPORTED_MODULE_0__["q"]; });
/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js");
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "d", function() { return _vue_shared__WEBPACK_IMPORTED_MODULE_1__["e"]; });
const stack = [];
function pushWarningContext(vnode) {
stack.push(vnode);
}
function popWarningContext() {
stack.pop();
}
function warn(msg, ...args) {
// avoid props formatting or warn handler tracking deps that might be mutated
// during patch, leading to infinite recursion.
Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* pauseTracking */ "f"])();
const instance = stack.length ? stack[stack.length - 1].component : null;
const appWarnHandler = instance && instance.appContext.config.warnHandler;
const trace = getComponentTrace();
if (appWarnHandler) {
callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [
msg + args.join(''),
instance && instance.proxy,
trace
.map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)
.join('\n'),
trace
]);
}
else {
const warnArgs = [`[Vue warn]: ${msg}`, ...args];
/* istanbul ignore if */
if (trace.length &&
// avoid spamming console during tests
!false) {
warnArgs.push(`\n`, ...formatTrace(trace));
}
console.warn(...warnArgs);
}
Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* resetTracking */ "j"])();
}
function getComponentTrace() {
let currentVNode = stack[stack.length - 1];
if (!currentVNode) {
return [];
}
// we can't just use the stack because it will be incomplete during updates
// that did not start from the root. Re-construct the parent chain using
// instance parent pointers.
const normalizedStack = [];
while (currentVNode) {
const last = normalizedStack[0];
if (last && last.vnode === currentVNode) {
last.recurseCount++;
}
else {
normalizedStack.push({
vnode: currentVNode,
recurseCount: 0
});
}
const parentInstance = currentVNode.component && currentVNode.component.parent;
currentVNode = parentInstance && parentInstance.vnode;
}
return normalizedStack;
}
/* istanbul ignore next */
function formatTrace(trace) {
const logs = [];
trace.forEach((entry, i) => {
logs.push(...(i === 0 ? [] : [`\n`]), ...formatTraceEntry(entry));
});
return logs;
}
function formatTraceEntry({ vnode, recurseCount }) {
const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
const isRoot = vnode.component ? vnode.component.parent == null : false;
const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;
const close = `>` + postfix;
return vnode.props
? [open, ...formatProps(vnode.props), close]
: [open + close];
}
/* istanbul ignore next */
function formatProps(props) {
const res = [];
const keys = Object.keys(props);
keys.slice(0, 3).forEach(key => {
res.push(...formatProp(key, props[key]));
});
if (keys.length > 3) {
res.push(` ...`);
}
return res;
}
/* istanbul ignore next */
function formatProp(key, value, raw) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(value)) {
value = JSON.stringify(value);
return raw ? value : [`${key}=${value}`];
}
else if (typeof value === 'number' ||
typeof value === 'boolean' ||
value == null) {
return raw ? value : [`${key}=${value}`];
}
else if (Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* isRef */ "e"])(value)) {
value = formatProp(key, Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* toRaw */ "n"])(value.value), true);
return raw ? value : [`${key}=Ref<`, value, `>`];
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(value)) {
return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
}
else {
value = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* toRaw */ "n"])(value);
return raw ? value : [`${key}=`, value];
}
}
const ErrorTypeStrings = {
["bc" /* BEFORE_CREATE */]: 'beforeCreate hook',
["c" /* CREATED */]: 'created hook',
["bm" /* BEFORE_MOUNT */]: 'beforeMount hook',
["m" /* MOUNTED */]: 'mounted hook',
["bu" /* BEFORE_UPDATE */]: 'beforeUpdate hook',
["u" /* UPDATED */]: 'updated',
["bum" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',
["um" /* UNMOUNTED */]: 'unmounted hook',
["a" /* ACTIVATED */]: 'activated hook',
["da" /* DEACTIVATED */]: 'deactivated hook',
["ec" /* ERROR_CAPTURED */]: 'errorCaptured hook',
["rtc" /* RENDER_TRACKED */]: 'renderTracked hook',
["rtg" /* RENDER_TRIGGERED */]: 'renderTriggered hook',
[0 /* SETUP_FUNCTION */]: 'setup function',
[1 /* RENDER_FUNCTION */]: 'render function',
[2 /* WATCH_GETTER */]: 'watcher getter',
[3 /* WATCH_CALLBACK */]: 'watcher callback',
[4 /* WATCH_CLEANUP */]: 'watcher cleanup function',
[5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',
[6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',
[7 /* VNODE_HOOK */]: 'vnode hook',
[8 /* DIRECTIVE_HOOK */]: 'directive hook',
[9 /* TRANSITION_HOOK */]: 'transition hook',
[10 /* APP_ERROR_HANDLER */]: 'app errorHandler',
[11 /* APP_WARN_HANDLER */]: 'app warnHandler',
[12 /* FUNCTION_REF */]: 'ref function',
[13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',
[14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +
'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'
};
function callWithErrorHandling(fn, instance, type, args) {
let res;
try {
res = args ? fn(...args) : fn();
}
catch (err) {
handleError(err, instance, type);
}
return res;
}
function callWithAsyncErrorHandling(fn, instance, type, args) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(fn)) {
const res = callWithErrorHandling(fn, instance, type, args);
if (res && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isPromise */ "v"])(res)) {
res.catch(err => {
handleError(err, instance, type);
});
}
return res;
}
const values = [];
for (let i = 0; i < fn.length; i++) {
values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
}
return values;
}
function handleError(err, instance, type) {
const contextVNode = instance ? instance.vnode : null;
if (instance) {
let cur = instance.parent;
// the exposed instance is the render proxy to keep it consistent with 2.x
const exposedInstance = instance.proxy;
// in production the hook receives only the error code
const errorInfo = ( true) ? ErrorTypeStrings[type] : undefined;
while (cur) {
const errorCapturedHooks = cur.ec;
if (errorCapturedHooks) {
for (let i = 0; i < errorCapturedHooks.length; i++) {
if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) {
return;
}
}
}
cur = cur.parent;
}
// app-level handling
const appErrorHandler = instance.appContext.config.errorHandler;
if (appErrorHandler) {
callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);
return;
}
}
logError(err, type, contextVNode);
}
function logError(err, type, contextVNode) {
if ((true)) {
const info = ErrorTypeStrings[type];
if (contextVNode) {
pushWarningContext(contextVNode);
}
warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
if (contextVNode) {
popWarningContext();
}
// crash in dev so it's more noticeable
throw err;
}
else {}
}
let isFlushing = false;
let isFlushPending = false;
const queue = [];
let flushIndex = 0;
const pendingPreFlushCbs = [];
let activePreFlushCbs = null;
let preFlushIndex = 0;
const pendingPostFlushCbs = [];
let activePostFlushCbs = null;
let postFlushIndex = 0;
const resolvedPromise = Promise.resolve();
let currentFlushPromise = null;
let currentPreFlushParentJob = null;
const RECURSION_LIMIT = 100;
function nextTick(fn) {
const p = currentFlushPromise || resolvedPromise;
return fn ? p.then(fn) : p;
}
function queueJob(job) {
// the dedupe search uses the startIndex argument of Array.includes()
// by default the search index includes the current job that is being run
// so it cannot recursively trigger itself again.
// if the job is a watch() callback, the search will start with a +1 index to
// allow it recursively trigger itself - it is the user's responsibility to
// ensure it doesn't end up in an infinite loop.
if ((!queue.length ||
!queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&
job !== currentPreFlushParentJob) {
queue.push(job);
queueFlush();
}
}
function queueFlush() {
if (!isFlushing && !isFlushPending) {
isFlushPending = true;
currentFlushPromise = resolvedPromise.then(flushJobs);
}
}
function invalidateJob(job) {
const i = queue.indexOf(job);
if (i > -1) {
queue[i] = null;
}
}
function queueCb(cb, activeQueue, pendingQueue, index) {
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(cb)) {
if (!activeQueue ||
!activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {
pendingQueue.push(cb);
}
}
else {
// if cb is an array, it is a component lifecycle hook which can only be
// triggered by a job, which is already deduped in the main queue, so
// we can skip duplicate check here to improve perf
pendingQueue.push(...cb);
}
queueFlush();
}
function queuePreFlushCb(cb) {
queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);
}
function queuePostFlushCb(cb) {
queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);
}
function flushPreFlushCbs(seen, parentJob = null) {
if (pendingPreFlushCbs.length) {
currentPreFlushParentJob = parentJob;
activePreFlushCbs = [...new Set(pendingPreFlushCbs)];
pendingPreFlushCbs.length = 0;
if ((true)) {
seen = seen || new Map();
}
for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {
if ((true)) {
checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]);
}
activePreFlushCbs[preFlushIndex]();
}
activePreFlushCbs = null;
preFlushIndex = 0;
currentPreFlushParentJob = null;
// recursively flush until it drains
flushPreFlushCbs(seen, parentJob);
}
}
function flushPostFlushCbs(seen) {
if (pendingPostFlushCbs.length) {
const deduped = [...new Set(pendingPostFlushCbs)];
pendingPostFlushCbs.length = 0;
// #1947 already has active queue, nested flushPostFlushCbs call
if (activePostFlushCbs) {
activePostFlushCbs.push(...deduped);
return;
}
activePostFlushCbs = deduped;
if ((true)) {
seen = seen || new Map();
}
activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
if ((true)) {
checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]);
}
activePostFlushCbs[postFlushIndex]();
}
activePostFlushCbs = null;
postFlushIndex = 0;
}
}
const getId = (job) => job.id == null ? Infinity : job.id;
function flushJobs(seen) {
isFlushPending = false;
isFlushing = true;
if ((true)) {
seen = seen || new Map();
}
flushPreFlushCbs(seen);
// Sort queue before flush.
// This ensures that:
// 1. Components are updated from parent to child. (because parent is always
// created before the child so its render effect will have smaller
// priority number)
// 2. If a component is unmounted during a parent component's update,
// its update can be skipped.
// Jobs can never be null before flush starts, since they are only invalidated
// during execution of another flushed job.
queue.sort((a, b) => getId(a) - getId(b));
try {
for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex];
if (job) {
if ((true)) {
checkRecursiveUpdates(seen, job);
}
callWithErrorHandling(job, null, 14 /* SCHEDULER */);
}
}
}
finally {
flushIndex = 0;
queue.length = 0;
flushPostFlushCbs(seen);
isFlushing = false;
currentFlushPromise = null;
// some postFlushCb queued jobs!
// keep flushing until it drains.
if (queue.length || pendingPostFlushCbs.length) {
flushJobs(seen);
}
}
}
function checkRecursiveUpdates(seen, fn) {
if (!seen.has(fn)) {
seen.set(fn, 1);
}
else {
const count = seen.get(fn);
if (count > RECURSION_LIMIT) {
throw new Error(`Maximum recursive updates exceeded. ` +
`This means you have a reactive effect that is mutating its own ` +
`dependencies and thus recursively triggering itself. Possible sources ` +
`include component template, render function, updated hook or ` +
`watcher source function.`);
}
else {
seen.set(fn, count + 1);
}
}
}
let isHmrUpdating = false;
const hmrDirtyComponents = new Set();
// Expose the HMR runtime on the global object
// This makes it entirely tree-shakable without polluting the exports and makes
// it easier to be used in toolings like vue-loader
// Note: for a component to be eligible for HMR it also needs the __hmrId option
// to be set so that its instances can be registered / removed.
if ((true)) {
const globalObject = typeof global !== 'undefined'
? global
: typeof self !== 'undefined'
? self
: typeof window !== 'undefined'
? window
: {};
globalObject.__VUE_HMR_RUNTIME__ = {
createRecord: tryWrap(createRecord),
rerender: tryWrap(rerender),
reload: tryWrap(reload)
};
}
const map = new Map();
function registerHMR(instance) {
const id = instance.type.__hmrId;
let record = map.get(id);
if (!record) {
createRecord(id);
record = map.get(id);
}
record.add(instance);
}
function unregisterHMR(instance) {
map.get(instance.type.__hmrId).delete(instance);
}
function createRecord(id) {
if (map.has(id)) {
return false;
}
map.set(id, new Set());
return true;
}
function rerender(id, newRender) {
const record = map.get(id);
if (!record)
return;
// Array.from creates a snapshot which avoids the set being mutated during
// updates
Array.from(record).forEach(instance => {
if (newRender) {
instance.render = newRender;
}
instance.renderCache = [];
// this flag forces child components with slot content to update
isHmrUpdating = true;
instance.update();
isHmrUpdating = false;
});
}
function reload(id, newComp) {
const record = map.get(id);
if (!record)
return;
// Array.from creates a snapshot which avoids the set being mutated during
// updates
Array.from(record).forEach(instance => {
const comp = instance.type;
if (!hmrDirtyComponents.has(comp)) {
// 1. Update existing comp definition to match new one
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])(comp, newComp);
for (const key in comp) {
if (!(key in newComp)) {
delete comp[key];
}
}
// 2. Mark component dirty. This forces the renderer to replace the component
// on patch.
hmrDirtyComponents.add(comp);
// 3. Make sure to unmark the component after the reload.
queuePostFlushCb(() => {
hmrDirtyComponents.delete(comp);
});
}
if (instance.parent) {
// 4. Force the parent instance to re-render. This will cause all updated
// components to be unmounted and re-mounted. Queue the update so that we
// don't end up forcing the same parent to re-render multiple times.
queueJob(instance.parent.update);
}
else if (instance.appContext.reload) {
// root instance mounted via createApp() has a reload method
instance.appContext.reload();
}
else if (typeof window !== 'undefined') {
// root instance inside tree created via raw render(). Force reload.
window.location.reload();
}
else {
console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');
}
});
}
function tryWrap(fn) {
return (id, arg) => {
try {
return fn(id, arg);
}
catch (e) {
console.error(e);
console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` +
`Full reload required.`);
}
};
}
// mark the current rendering instance for asset resolution (e.g.
// resolveComponent, resolveDirective) during render
let currentRenderingInstance = null;
function setCurrentRenderingInstance(instance) {
currentRenderingInstance = instance;
}
// dev only flag to track whether $attrs was used during render.
// If $attrs was used during render then the warning for failed attrs
// fallthrough can be suppressed.
let accessedAttrs = false;
function markAttrsAccessed() {
accessedAttrs = true;
}
function renderComponentRoot(instance) {
const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit, render, renderCache, data, setupState, ctx } = instance;
let result;
currentRenderingInstance = instance;
if ((true)) {
accessedAttrs = false;
}
try {
let fallthroughAttrs;
if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) {
// withProxy is a proxy with a different `has` trap only for
// runtime-compiled render functions using `with` block.
const proxyToUse = withProxy || proxy;
result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx));
fallthroughAttrs = attrs;
}
else {
// functional
const render = Component;
// in dev, mark attrs accessed if optional props (attrs === props)
if (( true) && attrs === props) {
markAttrsAccessed();
}
result = normalizeVNode(render.length > 1
? render(props, ( true)
? {
get attrs() {
markAttrsAccessed();
return attrs;
},
slots,
emit
}
: undefined)
: render(props, null /* we know it doesn't need it */));
fallthroughAttrs = Component.props
? attrs
: getFunctionalFallthrough(attrs);
}
// attr merging
// in dev mode, comments are preserved, and it's possible for a template
// to have comments along side the root element which makes it a fragment
let root = result;
let setRoot = undefined;
if ((true)) {
;
[root, setRoot] = getChildRoot(result);
}
if (Component.inheritAttrs !== false && fallthroughAttrs) {
const keys = Object.keys(fallthroughAttrs);
const { shapeFlag } = root;
if (keys.length) {
if (shapeFlag & 1 /* ELEMENT */ ||
shapeFlag & 6 /* COMPONENT */) {
if (propsOptions && keys.some(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isModelListener */ "s"])) {
// If a v-model listener (onUpdate:xxx) has a corresponding declared
// prop, it indicates this component expects to handle v-model and
// it should not fallthrough.
// related: #1543, #1643, #1989
fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);
}
root = cloneVNode(root, fallthroughAttrs);
}
else if (( true) && !accessedAttrs && root.type !== Comment) {
const allAttrs = Object.keys(attrs);
const eventAttrs = [];
const extraAttrs = [];
for (let i = 0, l = allAttrs.length; i < l; i++) {
const key = allAttrs[i];
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isOn */ "u"])(key)) {
// ignore v-model handlers when they fail to fallthrough
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isModelListener */ "s"])(key)) {
// remove `on`, lowercase first letter to reflect event casing
// accurately
eventAttrs.push(key[2].toLowerCase() + key.slice(3));
}
}
else {
extraAttrs.push(key);
}
}
if (extraAttrs.length) {
warn(`Extraneous non-props attributes (` +
`${extraAttrs.join(', ')}) ` +
`were passed to component but could not be automatically inherited ` +
`because component renders fragment or text root nodes.`);
}
if (eventAttrs.length) {
warn(`Extraneous non-emits event listeners (` +
`${eventAttrs.join(', ')}) ` +
`were passed to component but could not be automatically inherited ` +
`because component renders fragment or text root nodes. ` +
`If the listener is intended to be a component custom event listener only, ` +
`declare it using the "emits" option.`);
}
}
}
}
// inherit directives
if (vnode.dirs) {
if (( true) && !isElementRoot(root)) {
warn(`Runtime directive used on component with non-element root node. ` +
`The directives will not function as intended.`);
}
root.dirs = vnode.dirs;
}
// inherit transition data
if (vnode.transition) {
if (( true) && !isElementRoot(root)) {
warn(`Component inside <Transition> renders non-element root node ` +
`that cannot be animated.`);
}
root.transition = vnode.transition;
}
if (( true) && setRoot) {
setRoot(root);
}
else {
result = root;
}
}
catch (err) {
handleError(err, instance, 1 /* RENDER_FUNCTION */);
result = createVNode(Comment);
}
currentRenderingInstance = null;
return result;
}
/**
* dev only
*/
const getChildRoot = (vnode) => {
if (vnode.type !== Fragment) {
return [vnode, undefined];
}
const rawChildren = vnode.children;
const dynamicChildren = vnode.dynamicChildren;
const children = rawChildren.filter(child => {
return !(isVNode(child) &&
child.type === Comment &&
child.children !== 'v-if');
});
if (children.length !== 1) {
return [vnode, undefined];
}
const childRoot = children[0];
const index = rawChildren.indexOf(childRoot);
const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
const setRoot = (updatedRoot) => {
rawChildren[index] = updatedRoot;
if (dynamicIndex > -1) {
dynamicChildren[dynamicIndex] = updatedRoot;
}
else if (dynamicChildren && updatedRoot.patchFlag > 0) {
dynamicChildren.push(updatedRoot);
}
};
return [normalizeVNode(childRoot), setRoot];
};
const getFunctionalFallthrough = (attrs) => {
let res;
for (const key in attrs) {
if (key === 'class' || key === 'style' || Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isOn */ "u"])(key)) {
(res || (res = {}))[key] = attrs[key];
}
}
return res;
};
const filterModelListeners = (attrs, props) => {
const res = {};
for (const key in attrs) {
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isModelListener */ "s"])(key) || !(key.slice(9) in props)) {
res[key] = attrs[key];
}
}
return res;
};
const isElementRoot = (vnode) => {
return (vnode.shapeFlag & 6 /* COMPONENT */ ||
vnode.shapeFlag & 1 /* ELEMENT */ ||
vnode.type === Comment // potential v-if branch switch
);
};
function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
const { props: prevProps, children: prevChildren } = prevVNode;
const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
// Parent component's render function was hot-updated. Since this may have
// caused the child component's slots content to have changed, we need to
// force the child to update as well.
if (( true) && (prevChildren || nextChildren) && isHmrUpdating) {
return true;
}
// force child update for runtime directive or transition on component vnode.
if (nextVNode.dirs || nextVNode.transition) {
return true;
}
if (optimized && patchFlag > 0) {
if (patchFlag & 1024 /* DYNAMIC_SLOTS */) {
// slot content that references values that might have changed,
// e.g. in a v-for
return true;
}
if (patchFlag & 16 /* FULL_PROPS */) {
if (!prevProps) {
return !!nextProps;
}
// presence of this flag indicates props are always non-null
return hasPropsChanged(prevProps, nextProps);
}
else if (patchFlag & 8 /* PROPS */) {
const dynamicProps = nextVNode.dynamicProps;
for (let i = 0; i < dynamicProps.length; i++) {
const key = dynamicProps[i];
if (nextProps[key] !== prevProps[key]) {
return true;
}
}
}
}
else {
// this path is only taken by manually written render functions
// so presence of any children leads to a forced update
if (prevChildren || nextChildren) {
if (!nextChildren || !nextChildren.$stable) {
return true;
}
}
if (prevProps === nextProps) {
return false;
}
if (!prevProps) {
return !!nextProps;
}
if (!nextProps) {
return true;
}
return hasPropsChanged(prevProps, nextProps);
}
return false;
}
function hasPropsChanged(prevProps, nextProps) {
const nextKeys = Object.keys(nextProps);
if (nextKeys.length !== Object.keys(prevProps).length) {
return true;
}
for (let i = 0; i < nextKeys.length; i++) {
const key = nextKeys[i];
if (nextProps[key] !== prevProps[key]) {
return true;
}
}
return false;
}
function updateHOCHostEl({ vnode, parent }, el // HostNode
) {
while (parent && parent.subTree === vnode) {
(vnode = parent.vnode).el = el;
parent = parent.parent;
}
}
const isSuspense = (type) => type.__isSuspense;
// Suspense exposes a component-like API, and is treated like a component
// in the compiler, but internally it's a special built-in type that hooks
// directly into the renderer.
const SuspenseImpl = {
// In order to make Suspense tree-shakable, we need to avoid importing it
// directly in the renderer. The renderer checks for the __isSuspense flag
// on a vnode's type and calls the `process` method, passing in renderer
// internals.
__isSuspense: true,
process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized,
// platform-specific impl passed from renderer
rendererInternals) {
if (n1 == null) {
mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, rendererInternals);
}
else {
patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, optimized, rendererInternals);
}
},
hydrate: hydrateSuspense
};
// Force-casted public typing for h and TSX props inference
const Suspense = ( SuspenseImpl
);
function mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, rendererInternals) {
const { p: patch, o: { createElement } } = rendererInternals;
const hiddenContainer = createElement('div');
const suspense = (n2.suspense = createSuspenseBoundary(n2, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, optimized, rendererInternals));
// start mounting the content subtree in an off-dom container
patch(null, suspense.subTree, hiddenContainer, null, parentComponent, suspense, isSVG, optimized);
// now check if we have encountered any async deps
if (suspense.deps > 0) {
// mount the fallback tree
patch(null, suspense.fallbackTree, container, anchor, parentComponent, null, // fallback tree will not have suspense context
isSVG, optimized);
n2.el = suspense.fallbackTree.el;
}
else {
// Suspense has no async deps. Just resolve.
suspense.resolve();
}
}
function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, optimized, { p: patch }) {
const suspense = (n2.suspense = n1.suspense);
suspense.vnode = n2;
const { content, fallback } = normalizeSuspenseChildren(n2);
const oldSubTree = suspense.subTree;
const oldFallbackTree = suspense.fallbackTree;
if (!suspense.isResolved) {
patch(oldSubTree, content, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, optimized);
if (suspense.deps > 0) {
// still pending. patch the fallback tree.
patch(oldFallbackTree, fallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context
isSVG, optimized);
n2.el = fallback.el;
}
// If deps somehow becomes 0 after the patch it means the patch caused an
// async dep component to unmount and removed its dep. It will cause the
// suspense to resolve and we don't need to do anything here.
}
else {
// just normal patch inner content as a fragment
patch(oldSubTree, content, container, anchor, parentComponent, suspense, isSVG, optimized);
n2.el = content.el;
}
suspense.subTree = content;
suspense.fallbackTree = fallback;
}
let hasWarned = false;
function createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, optimized, rendererInternals, isHydrating = false) {
/* istanbul ignore if */
if ( true && !hasWarned) {
hasWarned = true;
// @ts-ignore `console.info` cannot be null error
console[console.info ? 'info' : 'log'](`<Suspense> is an experimental feature and its API will likely change.`);
}
const { p: patch, m: move, um: unmount, n: next, o: { parentNode } } = rendererInternals;
const getCurrentTree = () => suspense.isResolved || suspense.isHydrating
? suspense.subTree
: suspense.fallbackTree;
const { content, fallback } = normalizeSuspenseChildren(vnode);
const suspense = {
vnode,
parent,
parentComponent,
isSVG,
optimized,
container,
hiddenContainer,
anchor,
deps: 0,
subTree: content,
fallbackTree: fallback,
isHydrating,
isResolved: false,
isUnmounted: false,
effects: [],
resolve() {
if ((true)) {
if (suspense.isResolved) {
throw new Error(`resolveSuspense() is called on an already resolved suspense boundary.`);
}
if (suspense.isUnmounted) {
throw new Error(`resolveSuspense() is called on an already unmounted suspense boundary.`);
}
}
const { vnode, subTree, fallbackTree, effects, parentComponent, container } = suspense;
if (suspense.isHydrating) {
suspense.isHydrating = false;
}
else {
// this is initial anchor on mount
let { anchor } = suspense;
// unmount fallback tree
if (fallbackTree.el) {
// if the fallback tree was mounted, it may have been moved
// as part of a parent suspense. get the latest anchor for insertion
anchor = next(fallbackTree);
unmount(fallbackTree, parentComponent, suspense, true);
}
// move content from off-dom container to actual container
move(subTree, container, anchor, 0 /* ENTER */);
}
const el = (vnode.el = subTree.el);
// suspense as the root node of a component...
if (parentComponent && parentComponent.subTree === vnode) {
parentComponent.vnode.el = el;
updateHOCHostEl(parentComponent, el);
}
// check if there is a pending parent suspense
let parent = suspense.parent;
let hasUnresolvedAncestor = false;
while (parent) {
if (!parent.isResolved) {
// found a pending parent suspense, merge buffered post jobs
// into that parent
parent.effects.push(...effects);
hasUnresolvedAncestor = true;
break;
}
parent = parent.parent;
}
// no pending parent suspense, flush all jobs
if (!hasUnresolvedAncestor) {
queuePostFlushCb(effects);
}
suspense.isResolved = true;
suspense.effects = [];
// invoke @resolve event
const onResolve = vnode.props && vnode.props.onResolve;
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(onResolve)) {
onResolve();
}
},
recede() {
suspense.isResolved = false;
const { vnode, subTree, fallbackTree, parentComponent, container, hiddenContainer, isSVG, optimized } = suspense;
// move content tree back to the off-dom container
const anchor = next(subTree);
move(subTree, hiddenContainer, null, 1 /* LEAVE */);
// remount the fallback tree
patch(null, fallbackTree, container, anchor, parentComponent, null, // fallback tree will not have suspense context
isSVG, optimized);
const el = (vnode.el = fallbackTree.el);
// suspense as the root node of a component...
if (parentComponent && parentComponent.subTree === vnode) {
parentComponent.vnode.el = el;
updateHOCHostEl(parentComponent, el);
}
// invoke @recede event
const onRecede = vnode.props && vnode.props.onRecede;
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(onRecede)) {
onRecede();
}
},
move(container, anchor, type) {
move(getCurrentTree(), container, anchor, type);
suspense.container = container;
},
next() {
return next(getCurrentTree());
},
registerDep(instance, setupRenderEffect) {
// suspense is already resolved, need to recede.
// use queueJob so it's handled synchronously after patching the current
// suspense tree
if (suspense.isResolved) {
queueJob(() => {
suspense.recede();
});
}
const hydratedEl = instance.vnode.el;
suspense.deps++;
instance
.asyncDep.catch(err => {
handleError(err, instance, 0 /* SETUP_FUNCTION */);
})
.then(asyncSetupResult => {
// retry when the setup() promise resolves.
// component may have been unmounted before resolve.
if (instance.isUnmounted || suspense.isUnmounted) {
return;
}
suspense.deps--;
// retry from this component
instance.asyncResolved = true;
const { vnode } = instance;
if ((true)) {
pushWarningContext(vnode);
}
handleSetupResult(instance, asyncSetupResult);
if (hydratedEl) {
// vnode may have been replaced if an update happened before the
// async dep is resolved.
vnode.el = hydratedEl;
}
setupRenderEffect(instance, vnode,
// component may have been moved before resolve.
// if this is not a hydration, instance.subTree will be the comment
// placeholder.
hydratedEl
? parentNode(hydratedEl)
: parentNode(instance.subTree.el),
// anchor will not be used if this is hydration, so only need to
// consider the comment placeholder case.
hydratedEl ? null : next(instance.subTree), suspense, isSVG, optimized);
updateHOCHostEl(instance, vnode.el);
if ((true)) {
popWarningContext();
}
if (suspense.deps === 0) {
suspense.resolve();
}
});
},
unmount(parentSuspense, doRemove) {
suspense.isUnmounted = true;
unmount(suspense.subTree, parentComponent, parentSuspense, doRemove);
if (!suspense.isResolved) {
unmount(suspense.fallbackTree, parentComponent, parentSuspense, doRemove);
}
}
};
return suspense;
}
function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, optimized, rendererInternals, hydrateNode) {
/* eslint-disable no-restricted-globals */
const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement('div'), null, isSVG, optimized, rendererInternals, true /* hydrating */));
// there are two possible scenarios for server-rendered suspense:
// - success: ssr content should be fully resolved
// - failure: ssr content should be the fallback branch.
// however, on the client we don't really know if it has failed or not
// attempt to hydrate the DOM assuming it has succeeded, but we still
// need to construct a suspense boundary first
const result = hydrateNode(node, suspense.subTree, parentComponent, suspense, optimized);
if (suspense.deps === 0) {
suspense.resolve();
}
return result;
/* eslint-enable no-restricted-globals */
}
function normalizeSuspenseChildren(vnode) {
const { shapeFlag, children } = vnode;
if (shapeFlag & 32 /* SLOTS_CHILDREN */) {
const { default: d, fallback } = children;
return {
content: normalizeVNode(Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(d) ? d() : d),
fallback: normalizeVNode(Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(fallback) ? fallback() : fallback)
};
}
else {
return {
content: normalizeVNode(children),
fallback: normalizeVNode(null)
};
}
}
function queueEffectWithSuspense(fn, suspense) {
if (suspense && !suspense.isResolved) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(fn)) {
suspense.effects.push(...fn);
}
else {
suspense.effects.push(fn);
}
}
else {
queuePostFlushCb(fn);
}
}
let isRenderingCompiledSlot = 0;
const setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n);
/**
* Compiler runtime helper for rendering `<slot/>`
* @private
*/
function renderSlot(slots, name, props = {},
// this is not a user-facing function, so the fallback is always generated by
// the compiler and guaranteed to be a function returning an array
fallback) {
let slot = slots[name];
if (( true) && slot && slot.length > 1) {
warn(`SSR-optimized slot function detected in a non-SSR-optimized render ` +
`function. You need to mark this component with $dynamic-slots in the ` +
`parent template.`);
slot = () => [];
}
// a compiled slot disables block tracking by default to avoid manual
// invocation interfering with template-based block tracking, but in
// `renderSlot` we can be sure that it's template-based so we can force
// enable it.
isRenderingCompiledSlot++;
const rendered = (openBlock(),
createBlock(Fragment, { key: props.key }, slot ? slot(props) : fallback ? fallback() : [], slots._ === 1 /* STABLE */
? 64 /* STABLE_FRAGMENT */
: -2 /* BAIL */));
isRenderingCompiledSlot--;
return rendered;
}
/**
* Wrap a slot function to memoize current rendering instance
* @private
*/
function withCtx(fn, ctx = currentRenderingInstance) {
if (!ctx)
return fn;
const renderFnWithContext = (...args) => {
// If a user calls a compiled slot inside a template expression (#1745), it
// can mess up block tracking, so by default we need to push a null block to
// avoid that. This isn't necessary if rendering a compiled `<slot>`.
if (!isRenderingCompiledSlot) {
openBlock(true /* null block that disables tracking */);
}
const owner = currentRenderingInstance;
setCurrentRenderingInstance(ctx);
const res = fn(...args);
setCurrentRenderingInstance(owner);
if (!isRenderingCompiledSlot) {
closeBlock();
}
return res;
};
renderFnWithContext._c = true;
return renderFnWithContext;
}
// SFC scoped style ID management.
let currentScopeId = null;
const scopeIdStack = [];
/**
* @private
*/
function pushScopeId(id) {
scopeIdStack.push((currentScopeId = id));
}
/**
* @private
*/
function popScopeId() {
scopeIdStack.pop();
currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null;
}
/**
* @private
*/
function withScopeId(id) {
return ((fn) => withCtx(function () {
pushScopeId(id);
const res = fn.apply(this, arguments);
popScopeId();
return res;
}));
}
const isTeleport = (type) => type.__isTeleport;
const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === '');
const resolveTarget = (props, select) => {
const targetSelector = props && props.to;
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(targetSelector)) {
if (!select) {
( true) &&
warn(`Current renderer does not support string target for Teleports. ` +
`(missing querySelector renderer option)`);
return null;
}
else {
const target = select(targetSelector);
if (!target) {
( true) &&
warn(`Failed to locate Teleport target with selector "${targetSelector}". ` +
`Note the target element must exist before the component is mounted - ` +
`i.e. the target cannot be rendered by the component itself, and ` +
`ideally should be outside of the entire Vue component tree.`);
}
return target;
}
}
else {
if (( true) && !targetSelector && !isTeleportDisabled(props)) {
warn(`Invalid Teleport target: ${targetSelector}`);
}
return targetSelector;
}
};
const TeleportImpl = {
__isTeleport: true,
process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals) {
const { mc: mountChildren, pc: patchChildren, pbc: patchBlockChildren, o: { insert, querySelector, createText, createComment } } = internals;
const disabled = isTeleportDisabled(n2.props);
const { shapeFlag, children } = n2;
if (n1 == null) {
// insert anchors in the main view
const placeholder = (n2.el = ( true)
? createComment('teleport start')
: undefined);
const mainAnchor = (n2.anchor = ( true)
? createComment('teleport end')
: undefined);
insert(placeholder, container, anchor);
insert(mainAnchor, container, anchor);
const target = (n2.target = resolveTarget(n2.props, querySelector));
const targetAnchor = (n2.targetAnchor = createText(''));
if (target) {
insert(targetAnchor, target);
}
else if (( true) && !disabled) {
warn('Invalid Teleport target on mount:', target, `(${typeof target})`);
}
const mount = (container, anchor) => {
// Teleport *always* has Array children. This is enforced in both the
// compiler and vnode children normalization.
if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
mountChildren(children, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
};
if (disabled) {
mount(container, mainAnchor);
}
else if (target) {
mount(target, targetAnchor);
}
}
else {
// update content
n2.el = n1.el;
const mainAnchor = (n2.anchor = n1.anchor);
const target = (n2.target = n1.target);
const targetAnchor = (n2.targetAnchor = n1.targetAnchor);
const wasDisabled = isTeleportDisabled(n1.props);
const currentContainer = wasDisabled ? container : target;
const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
if (n2.dynamicChildren) {
// fast path when the teleport happens to be a block root
patchBlockChildren(n1.dynamicChildren, n2.dynamicChildren, currentContainer, parentComponent, parentSuspense, isSVG);
// even in block tree mode we need to make sure all root-level nodes
// in the teleport inherit previous DOM references so that they can
// be moved in future patches.
if (n2.shapeFlag & 16 /* ARRAY_CHILDREN */) {
const oldChildren = n1.children;
const children = n2.children;
for (let i = 0; i < children.length; i++) {
// only inherit for non-patched nodes (i.e. static ones)
if (!children[i].el) {
children[i].el = oldChildren[i].el;
}
}
}
}
else if (!optimized) {
patchChildren(n1, n2, currentContainer, currentAnchor, parentComponent, parentSuspense, isSVG);
}
if (disabled) {
if (!wasDisabled) {
// enabled -> disabled
// move into main container
moveTeleport(n2, container, mainAnchor, internals, 1 /* TOGGLE */);
}
}
else {
// target changed
if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
const nextTarget = (n2.target = resolveTarget(n2.props, querySelector));
if (nextTarget) {
moveTeleport(n2, nextTarget, null, internals, 0 /* TARGET_CHANGE */);
}
else if ((true)) {
warn('Invalid Teleport target on update:', target, `(${typeof target})`);
}
}
else if (wasDisabled) {
// disabled -> enabled
// move into teleport target
moveTeleport(n2, target, targetAnchor, internals, 1 /* TOGGLE */);
}
}
}
},
remove(vnode, { r: remove, o: { remove: hostRemove } }) {
const { shapeFlag, children, anchor } = vnode;
hostRemove(anchor);
if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
for (let i = 0; i < children.length; i++) {
remove(children[i]);
}
}
},
move: moveTeleport,
hydrate: hydrateTeleport
};
function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2 /* REORDER */) {
// move target anchor if this is a target change.
if (moveType === 0 /* TARGET_CHANGE */) {
insert(vnode.targetAnchor, container, parentAnchor);
}
const { el, anchor, shapeFlag, children, props } = vnode;
const isReorder = moveType === 2 /* REORDER */;
// move main view anchor if this is a re-order.
if (isReorder) {
insert(el, container, parentAnchor);
}
// if this is a re-order and teleport is enabled (content is in target)
// do not move children. So the opposite is: only move children if this
// is not a reorder, or the teleport is disabled
if (!isReorder || isTeleportDisabled(props)) {
// Teleport has either Array children or no children.
if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
for (let i = 0; i < children.length; i++) {
move(children[i], container, parentAnchor, 2 /* REORDER */);
}
}
}
// move main view anchor if this is a re-order.
if (isReorder) {
insert(anchor, container, parentAnchor);
}
}
function hydrateTeleport(node, vnode, parentComponent, parentSuspense, optimized, { o: { nextSibling, parentNode, querySelector } }, hydrateChildren) {
const target = (vnode.target = resolveTarget(vnode.props, querySelector));
if (target) {
// if multiple teleports rendered to the same target element, we need to
// pick up from where the last teleport finished instead of the first node
const targetNode = target._lpa || target.firstChild;
if (vnode.shapeFlag & 16 /* ARRAY_CHILDREN */) {
if (isTeleportDisabled(vnode.props)) {
vnode.anchor = hydrateChildren(nextSibling(node), vnode, parentNode(node), parentComponent, parentSuspense, optimized);
vnode.targetAnchor = targetNode;
}
else {
vnode.anchor = nextSibling(node);
vnode.targetAnchor = hydrateChildren(targetNode, vnode, target, parentComponent, parentSuspense, optimized);
}
target._lpa =
vnode.targetAnchor && nextSibling(vnode.targetAnchor);
}
}
return vnode.anchor && nextSibling(vnode.anchor);
}
// Force-casted public typing for h and TSX props inference
const Teleport = TeleportImpl;
const COMPONENTS = 'components';
const DIRECTIVES = 'directives';
/**
* @private
*/
function resolveComponent(name) {
return resolveAsset(COMPONENTS, name) || name;
}
const NULL_DYNAMIC_COMPONENT = Symbol();
/**
* @private
*/
function resolveDynamicComponent(component) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(component)) {
return resolveAsset(COMPONENTS, component, false) || component;
}
else {
// invalid types will fallthrough to createVNode and raise warning
return (component || NULL_DYNAMIC_COMPONENT);
}
}
/**
* @private
*/
function resolveDirective(name) {
return resolveAsset(DIRECTIVES, name);
}
// implementation
function resolveAsset(type, name, warnMissing = true) {
const instance = currentRenderingInstance || currentInstance;
if (instance) {
const Component = instance.type;
// self name has highest priority
if (type === COMPONENTS) {
const selfName = Component.displayName || Component.name;
if (selfName &&
(selfName === name ||
selfName === Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* camelize */ "e"])(name) ||
selfName === Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* capitalize */ "f"])(Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* camelize */ "e"])(name)))) {
return Component;
}
}
const res =
// local registration
// check instance[type] first for components with mixin or extends.
resolve(instance[type] || Component[type], name) ||
// global registration
resolve(instance.appContext[type], name);
if (( true) && warnMissing && !res) {
warn(`Failed to resolve ${type.slice(0, -1)}: ${name}`);
}
return res;
}
else if ((true)) {
warn(`resolve${Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* capitalize */ "f"])(type.slice(0, -1))} ` +
`can only be used in render() or setup().`);
}
}
function resolve(registry, name) {
return (registry &&
(registry[name] ||
registry[Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* camelize */ "e"])(name)] ||
registry[Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* capitalize */ "f"])(Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* camelize */ "e"])(name))]));
}
const Fragment = Symbol(( true) ? 'Fragment' : undefined);
const Text = Symbol(( true) ? 'Text' : undefined);
const Comment = Symbol(( true) ? 'Comment' : undefined);
const Static = Symbol(( true) ? 'Static' : undefined);
// Since v-if and v-for are the two possible ways node structure can dynamically
// change, once we consider v-if branches and each v-for fragment a block, we
// can divide a template into nested blocks, and within each block the node
// structure would be stable. This allows us to skip most children diffing
// and only worry about the dynamic nodes (indicated by patch flags).
const blockStack = [];
let currentBlock = null;
/**
* Open a block.
* This must be called before `createBlock`. It cannot be part of `createBlock`
* because the children of the block are evaluated before `createBlock` itself
* is called. The generated code typically looks like this:
*
* ```js
* function render() {
* return (openBlock(),createBlock('div', null, [...]))
* }
* ```
* disableTracking is true when creating a v-for fragment block, since a v-for
* fragment always diffs its children.
*
* @private
*/
function openBlock(disableTracking = false) {
blockStack.push((currentBlock = disableTracking ? null : []));
}
function closeBlock() {
blockStack.pop();
currentBlock = blockStack[blockStack.length - 1] || null;
}
// Whether we should be tracking dynamic child nodes inside a block.
// Only tracks when this value is > 0
// We are not using a simple boolean because this value may need to be
// incremented/decremented by nested usage of v-once (see below)
let shouldTrack = 1;
/**
* Block tracking sometimes needs to be disabled, for example during the
* creation of a tree that needs to be cached by v-once. The compiler generates
* code like this:
*
* ``` js
* _cache[1] || (
* setBlockTracking(-1),
* _cache[1] = createVNode(...),
* setBlockTracking(1),
* _cache[1]
* )
* ```
*
* @private
*/
function setBlockTracking(value) {
shouldTrack += value;
}
/**
* Create a block root vnode. Takes the same exact arguments as `createVNode`.
* A block root keeps track of dynamic nodes within the block in the
* `dynamicChildren` array.
*
* @private
*/
function createBlock(type, props, children, patchFlag, dynamicProps) {
const vnode = createVNode(type, props, children, patchFlag, dynamicProps, true /* isBlock: prevent a block from tracking itself */);
// save current block children on the block vnode
vnode.dynamicChildren = currentBlock || _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_ARR */ "a"];
// close block
closeBlock();
// a block is always going to be patched, so track it as a child of its
// parent block
if (shouldTrack > 0 && currentBlock) {
currentBlock.push(vnode);
}
return vnode;
}
function isVNode(value) {
return value ? value.__v_isVNode === true : false;
}
function isSameVNodeType(n1, n2) {
if (( true) &&
n2.shapeFlag & 6 /* COMPONENT */ &&
hmrDirtyComponents.has(n2.type)) {
// HMR only: if the component has been hot-updated, force a reload.
return false;
}
return n1.type === n2.type && n1.key === n2.key;
}
let vnodeArgsTransformer;
/**
* Internal API for registering an arguments transform for createVNode
* used for creating stubs in the test-utils
* It is *internal* but needs to be exposed for test-utils to pick up proper
* typings
*/
function transformVNodeArgs(transformer) {
vnodeArgsTransformer = transformer;
}
const createVNodeWithArgsTransform = (...args) => {
return _createVNode(...(vnodeArgsTransformer
? vnodeArgsTransformer(args, currentRenderingInstance)
: args));
};
const InternalObjectKey = `__vInternal`;
const normalizeKey = ({ key }) => key != null ? key : null;
const normalizeRef = ({ ref }) => {
return (ref != null
? Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(ref)
? ref
: [currentRenderingInstance, ref]
: null);
};
const createVNode = (( true)
? createVNodeWithArgsTransform
: undefined);
function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
if (!type || type === NULL_DYNAMIC_COMPONENT) {
if (( true) && !type) {
warn(`Invalid vnode type when creating vnode: ${type}.`);
}
type = Comment;
}
if (isVNode(type)) {
const cloned = cloneVNode(type, props);
if (children) {
normalizeChildren(cloned, children);
}
return cloned;
}
// class component normalization.
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(type) && '__vccOpts' in type) {
type = type.__vccOpts;
}
// class & style normalization.
if (props) {
// for reactive or proxy objects, we need to clone it to enable mutation.
if (Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* isProxy */ "c"])(props) || InternalObjectKey in props) {
props = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])({}, props);
}
let { class: klass, style } = props;
if (klass && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(klass)) {
props.class = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* normalizeClass */ "E"])(klass);
}
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(style)) {
// reactive state objects need to be cloned since they are likely to be
// mutated
if (Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* isProxy */ "c"])(style) && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(style)) {
style = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])({}, style);
}
props.style = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* normalizeStyle */ "F"])(style);
}
}
// encode the vnode type information into a bitmap
const shapeFlag = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(type)
? 1 /* ELEMENT */
: isSuspense(type)
? 128 /* SUSPENSE */
: isTeleport(type)
? 64 /* TELEPORT */
: Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(type)
? 4 /* STATEFUL_COMPONENT */
: Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(type)
? 2 /* FUNCTIONAL_COMPONENT */
: 0;
if (( true) && shapeFlag & 4 /* STATEFUL_COMPONENT */ && Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* isProxy */ "c"])(type)) {
type = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* toRaw */ "n"])(type);
warn(`Vue received a Component which was made a reactive object. This can ` +
`lead to unnecessary performance overhead, and should be avoided by ` +
`marking the component with \`markRaw\` or using \`shallowRef\` ` +
`instead of \`ref\`.`, `\nComponent that was made reactive: `, type);
}
const vnode = {
__v_isVNode: true,
["__v_skip" /* SKIP */]: true,
type,
props,
key: props && normalizeKey(props),
ref: props && normalizeRef(props),
scopeId: currentScopeId,
children: null,
component: null,
suspense: null,
dirs: null,
transition: null,
el: null,
anchor: null,
target: null,
targetAnchor: null,
staticCount: 0,
shapeFlag,
patchFlag,
dynamicProps,
dynamicChildren: null,
appContext: null
};
// validate key
if (( true) && vnode.key !== vnode.key) {
warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);
}
normalizeChildren(vnode, children);
if (shouldTrack > 0 &&
// avoid a block node from tracking itself
!isBlockNode &&
// has current parent block
currentBlock &&
// presence of a patch flag indicates this node needs patching on updates.
// component nodes also should always be patched, because even if the
// component doesn't need to update, it needs to persist the instance on to
// the next vnode so that it can be properly unmounted later.
(patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&
// the EVENTS flag is only for hydration and if it is the only flag, the
// vnode should not be considered dynamic due to handler caching.
patchFlag !== 32 /* HYDRATE_EVENTS */) {
currentBlock.push(vnode);
}
return vnode;
}
function cloneVNode(vnode, extraProps) {
// This is intentionally NOT using spread or extend to avoid the runtime
// key enumeration cost.
const { props, patchFlag } = vnode;
const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
return {
__v_isVNode: true,
["__v_skip" /* SKIP */]: true,
type: vnode.type,
props: mergedProps,
key: mergedProps && normalizeKey(mergedProps),
ref: extraProps && extraProps.ref ? normalizeRef(extraProps) : vnode.ref,
scopeId: vnode.scopeId,
children: vnode.children,
target: vnode.target,
targetAnchor: vnode.targetAnchor,
staticCount: vnode.staticCount,
shapeFlag: vnode.shapeFlag,
// if the vnode is cloned with extra props, we can no longer assume its
// existing patch flag to be reliable and need to add the FULL_PROPS flag.
// note: perserve flag for fragments since they use the flag for children
// fast paths only.
patchFlag: extraProps && vnode.type !== Fragment
? patchFlag === -1 // hoisted node
? 16 /* FULL_PROPS */
: patchFlag | 16 /* FULL_PROPS */
: patchFlag,
dynamicProps: vnode.dynamicProps,
dynamicChildren: vnode.dynamicChildren,
appContext: vnode.appContext,
dirs: vnode.dirs,
transition: vnode.transition,
// These should technically only be non-null on mounted VNodes. However,
// they *should* be copied for kept-alive vnodes. So we just always copy
// them since them being non-null during a mount doesn't affect the logic as
// they will simply be overwritten.
component: vnode.component,
suspense: vnode.suspense,
el: vnode.el,
anchor: vnode.anchor
};
}
/**
* @private
*/
function createTextVNode(text = ' ', flag = 0) {
return createVNode(Text, null, text, flag);
}
/**
* @private
*/
function createStaticVNode(content, numberOfNodes) {
// A static vnode can contain multiple stringified elements, and the number
// of elements is necessary for hydration.
const vnode = createVNode(Static, null, content);
vnode.staticCount = numberOfNodes;
return vnode;
}
/**
* @private
*/
function createCommentVNode(text = '',
// when used as the v-else branch, the comment node must be created as a
// block to ensure correct updates.
asBlock = false) {
return asBlock
? (openBlock(), createBlock(Comment, null, text))
: createVNode(Comment, null, text);
}
function normalizeVNode(child) {
if (child == null || typeof child === 'boolean') {
// empty placeholder
return createVNode(Comment);
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(child)) {
// fragment
return createVNode(Fragment, null, child);
}
else if (typeof child === 'object') {
// already vnode, this should be the most common since compiled templates
// always produce all-vnode children arrays
return child.el === null ? child : cloneVNode(child);
}
else {
// strings and numbers
return createVNode(Text, null, String(child));
}
}
// optimized normalization for template-compiled render fns
function cloneIfMounted(child) {
return child.el === null ? child : cloneVNode(child);
}
function normalizeChildren(vnode, children) {
let type = 0;
const { shapeFlag } = vnode;
if (children == null) {
children = null;
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(children)) {
type = 16 /* ARRAY_CHILDREN */;
}
else if (typeof children === 'object') {
if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) {
// Normalize slot to plain children for plain element and Teleport
const slot = children.default;
if (slot) {
// _c marker is added by withCtx() indicating this is a compiled slot
slot._c && setCompiledSlotRendering(1);
normalizeChildren(vnode, slot());
slot._c && setCompiledSlotRendering(-1);
}
return;
}
else {
type = 32 /* SLOTS_CHILDREN */;
const slotFlag = children._;
if (!slotFlag && !(InternalObjectKey in children)) {
children._ctx = currentRenderingInstance;
}
else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {
// a child component receives forwarded slots from the parent.
// its slot type is determined by its parent's slot type.
if (currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */) {
children._ = 2 /* DYNAMIC */;
vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;
}
else {
children._ = 1 /* STABLE */;
}
}
}
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(children)) {
children = { default: children, _ctx: currentRenderingInstance };
type = 32 /* SLOTS_CHILDREN */;
}
else {
children = String(children);
// force teleport children to array so it can be moved around
if (shapeFlag & 64 /* TELEPORT */) {
type = 16 /* ARRAY_CHILDREN */;
children = [createTextVNode(children)];
}
else {
type = 8 /* TEXT_CHILDREN */;
}
}
vnode.children = children;
vnode.shapeFlag |= type;
}
function mergeProps(...args) {
const ret = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])({}, args[0]);
for (let i = 1; i < args.length; i++) {
const toMerge = args[i];
for (const key in toMerge) {
if (key === 'class') {
if (ret.class !== toMerge.class) {
ret.class = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* normalizeClass */ "E"])([ret.class, toMerge.class]);
}
}
else if (key === 'style') {
ret.style = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* normalizeStyle */ "F"])([ret.style, toMerge.style]);
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isOn */ "u"])(key)) {
const existing = ret[key];
const incoming = toMerge[key];
if (existing !== incoming) {
ret[key] = existing
? [].concat(existing, toMerge[key])
: incoming;
}
}
else {
ret[key] = toMerge[key];
}
}
}
return ret;
}
let devtools;
function setDevtoolsHook(hook) {
devtools = hook;
}
function devtoolsInitApp(app, version) {
// TODO queue if devtools is undefined
if (!devtools)
return;
devtools.emit("app:init" /* APP_INIT */, app, version, {
Fragment,
Text,
Comment,
Static
});
}
function devtoolsUnmountApp(app) {
if (!devtools)
return;
devtools.emit("app:unmount" /* APP_UNMOUNT */, app);
}
const devtoolsComponentAdded = /*#__PURE__*/ createDevtoolsComponentHook("component:added" /* COMPONENT_ADDED */);
const devtoolsComponentUpdated = /*#__PURE__*/ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */);
const devtoolsComponentRemoved = /*#__PURE__*/ createDevtoolsComponentHook("component:removed" /* COMPONENT_REMOVED */);
function createDevtoolsComponentHook(hook) {
return (component) => {
if (!devtools)
return;
devtools.emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined);
};
}
function devtoolsComponentEmit(component, event, params) {
if (!devtools)
return;
devtools.emit("component:emit" /* COMPONENT_EMIT */, component.appContext.app, component, event, params);
}
function emit(instance, event, ...args) {
const props = instance.vnode.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"];
if ((true)) {
const { emitsOptions, propsOptions: [propsOptions] } = instance;
if (emitsOptions) {
if (!(event in emitsOptions)) {
if (!propsOptions || !(`on` + Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* capitalize */ "f"])(event) in propsOptions)) {
warn(`Component emitted event "${event}" but it is neither declared in ` +
`the emits option nor as an "on${Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* capitalize */ "f"])(event)}" prop.`);
}
}
else {
const validator = emitsOptions[event];
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(validator)) {
const isValid = validator(...args);
if (!isValid) {
warn(`Invalid event arguments: event validation failed for event "${event}".`);
}
}
}
}
}
if (true) {
devtoolsComponentEmit(instance, event, args);
}
let handlerName = `on${Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* capitalize */ "f"])(event)}`;
let handler = props[handlerName];
// for v-model update:xxx events, also trigger kebab-case equivalent
// for props passed via kebab-case
if (!handler && event.startsWith('update:')) {
handlerName = `on${Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* capitalize */ "f"])(Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hyphenate */ "l"])(event))}`;
handler = props[handlerName];
}
if (!handler) {
handler = props[handlerName + `Once`];
if (!instance.emitted) {
(instance.emitted = {})[handlerName] = true;
}
else if (instance.emitted[handlerName]) {
return;
}
}
if (handler) {
callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);
}
}
function normalizeEmitsOptions(comp, appContext, asMixin = false) {
const appId = appContext.app ? appContext.app._uid : -1;
const cache = comp.__emits || (comp.__emits = {});
const cached = cache[appId];
if (cached !== undefined) {
return cached;
}
const raw = comp.emits;
let normalized = {};
// apply mixin/extends props
let hasExtends = false;
if (__VUE_OPTIONS_API__ && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(comp)) {
const extendEmits = (raw) => {
hasExtends = true;
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])(normalized, normalizeEmitsOptions(raw, appContext, true));
};
if (!asMixin && appContext.mixins.length) {
appContext.mixins.forEach(extendEmits);
}
if (comp.extends) {
extendEmits(comp.extends);
}
if (comp.mixins) {
comp.mixins.forEach(extendEmits);
}
}
if (!raw && !hasExtends) {
return (cache[appId] = null);
}
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(raw)) {
raw.forEach(key => (normalized[key] = null));
}
else {
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])(normalized, raw);
}
return (cache[appId] = normalized);
}
// Check if an incoming prop key is a declared emit event listener.
// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are
// both considered matched listeners.
function isEmitListener(options, key) {
if (!options || !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isOn */ "u"])(key)) {
return false;
}
key = key.replace(/Once$/, '');
return (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(options, key[2].toLowerCase() + key.slice(3)) ||
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(options, key.slice(2)));
}
function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison
isSSR = false) {
const props = {};
const attrs = {};
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* def */ "g"])(attrs, InternalObjectKey, 1);
setFullProps(instance, rawProps, props, attrs);
// validation
if ((true)) {
validateProps(props, instance);
}
if (isStateful) {
// stateful
instance.props = isSSR ? props : Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* shallowReactive */ "k"])(props);
}
else {
if (!instance.type.props) {
// functional w/ optional props, props === attrs
instance.props = attrs;
}
else {
// functional w/ declared props
instance.props = props;
}
}
instance.attrs = attrs;
}
function updateProps(instance, rawProps, rawPrevProps, optimized) {
const { props, attrs, vnode: { patchFlag } } = instance;
const rawCurrentProps = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* toRaw */ "n"])(props);
const [options] = instance.propsOptions;
if (
// always force full diff if hmr is enabled
!(( true) && instance.type.__hmrId) &&
(optimized || patchFlag > 0) &&
!(patchFlag & 16 /* FULL_PROPS */)) {
if (patchFlag & 8 /* PROPS */) {
// Compiler-generated props & no keys change, just set the updated
// the props.
const propsToUpdate = instance.vnode.dynamicProps;
for (let i = 0; i < propsToUpdate.length; i++) {
const key = propsToUpdate[i];
// PROPS flag guarantees rawProps to be non-null
const value = rawProps[key];
if (options) {
// attr / props separation was done on init and will be consistent
// in this code path, so just check if attrs have it.
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(attrs, key)) {
attrs[key] = value;
}
else {
const camelizedKey = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* camelize */ "e"])(key);
props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value);
}
}
else {
attrs[key] = value;
}
}
}
}
else {
// full props update.
setFullProps(instance, rawProps, props, attrs);
// in case of dynamic props, check if we need to delete keys from
// the props object
let kebabKey;
for (const key in rawCurrentProps) {
if (!rawProps ||
// for camelCase
(!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(rawProps, key) &&
// it's possible the original props was passed in as kebab-case
// and converted to camelCase (#955)
((kebabKey = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hyphenate */ "l"])(key)) === key || !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(rawProps, kebabKey)))) {
if (options) {
if (rawPrevProps &&
// for camelCase
(rawPrevProps[key] !== undefined ||
// for kebab-case
rawPrevProps[kebabKey] !== undefined)) {
props[key] = resolvePropValue(options, rawProps || _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"], key, undefined);
}
}
else {
delete props[key];
}
}
}
// in the case of functional component w/o props declaration, props and
// attrs point to the same object so it should already have been updated.
if (attrs !== rawCurrentProps) {
for (const key in attrs) {
if (!rawProps || !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(rawProps, key)) {
delete attrs[key];
}
}
}
}
// trigger updates for $attrs in case it's used in component slots
Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* trigger */ "p"])(instance, "set" /* SET */, '$attrs');
if (( true) && rawProps) {
validateProps(props, instance);
}
}
function setFullProps(instance, rawProps, props, attrs) {
const [options, needCastKeys] = instance.propsOptions;
if (rawProps) {
for (const key in rawProps) {
const value = rawProps[key];
// key, ref are reserved and never passed down
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isReservedProp */ "w"])(key)) {
continue;
}
// prop option names are camelized during normalization, so to support
// kebab -> camel conversion here we need to camelize the key.
let camelKey;
if (options && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(options, (camelKey = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* camelize */ "e"])(key)))) {
props[camelKey] = value;
}
else if (!isEmitListener(instance.emitsOptions, key)) {
// Any non-declared (either as a prop or an emitted event) props are put
// into a separate `attrs` object for spreading. Make sure to preserve
// original key casing
attrs[key] = value;
}
}
}
if (needCastKeys) {
const rawCurrentProps = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* toRaw */ "n"])(props);
for (let i = 0; i < needCastKeys.length; i++) {
const key = needCastKeys[i];
props[key] = resolvePropValue(options, rawCurrentProps, key, rawCurrentProps[key]);
}
}
}
function resolvePropValue(options, props, key, value) {
const opt = options[key];
if (opt != null) {
const hasDefault = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(opt, 'default');
// default values
if (hasDefault && value === undefined) {
const defaultValue = opt.default;
value =
opt.type !== Function && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(defaultValue)
? defaultValue(props)
: defaultValue;
}
// boolean casting
if (opt[0 /* shouldCast */]) {
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(props, key) && !hasDefault) {
value = false;
}
else if (opt[1 /* shouldCastTrue */] &&
(value === '' || value === Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hyphenate */ "l"])(key))) {
value = true;
}
}
}
return value;
}
function normalizePropsOptions(comp, appContext, asMixin = false) {
const appId = appContext.app ? appContext.app._uid : -1;
const cache = comp.__props || (comp.__props = {});
const cached = cache[appId];
if (cached) {
return cached;
}
const raw = comp.props;
const normalized = {};
const needCastKeys = [];
// apply mixin/extends props
let hasExtends = false;
if (__VUE_OPTIONS_API__ && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(comp)) {
const extendProps = (raw) => {
hasExtends = true;
const [props, keys] = normalizePropsOptions(raw, appContext, true);
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])(normalized, props);
if (keys)
needCastKeys.push(...keys);
};
if (!asMixin && appContext.mixins.length) {
appContext.mixins.forEach(extendProps);
}
if (comp.extends) {
extendProps(comp.extends);
}
if (comp.mixins) {
comp.mixins.forEach(extendProps);
}
}
if (!raw && !hasExtends) {
return (cache[appId] = _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_ARR */ "a"]);
}
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(raw)) {
for (let i = 0; i < raw.length; i++) {
if (( true) && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(raw[i])) {
warn(`props must be strings when using array syntax.`, raw[i]);
}
const normalizedKey = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* camelize */ "e"])(raw[i]);
if (validatePropName(normalizedKey)) {
normalized[normalizedKey] = _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"];
}
}
}
else if (raw) {
if (( true) && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(raw)) {
warn(`invalid props options`, raw);
}
for (const key in raw) {
const normalizedKey = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* camelize */ "e"])(key);
if (validatePropName(normalizedKey)) {
const opt = raw[key];
const prop = (normalized[normalizedKey] =
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(opt) || Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(opt) ? { type: opt } : opt);
if (prop) {
const booleanIndex = getTypeIndex(Boolean, prop.type);
const stringIndex = getTypeIndex(String, prop.type);
prop[0 /* shouldCast */] = booleanIndex > -1;
prop[1 /* shouldCastTrue */] =
stringIndex < 0 || booleanIndex < stringIndex;
// if the prop needs boolean casting or default value
if (booleanIndex > -1 || Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(prop, 'default')) {
needCastKeys.push(normalizedKey);
}
}
}
}
}
return (cache[appId] = [normalized, needCastKeys]);
}
// use function string name to check type constructors
// so that it works across vms / iframes.
function getType(ctor) {
const match = ctor && ctor.toString().match(/^\s*function (\w+)/);
return match ? match[1] : '';
}
function isSameType(a, b) {
return getType(a) === getType(b);
}
function getTypeIndex(type, expectedTypes) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(expectedTypes)) {
for (let i = 0, len = expectedTypes.length; i < len; i++) {
if (isSameType(expectedTypes[i], type)) {
return i;
}
}
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(expectedTypes)) {
return isSameType(expectedTypes, type) ? 0 : -1;
}
return -1;
}
/**
* dev only
*/
function validateProps(props, instance) {
const rawValues = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* toRaw */ "n"])(props);
const options = instance.propsOptions[0];
for (const key in options) {
let opt = options[key];
if (opt == null)
continue;
validateProp(key, rawValues[key], opt, !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(rawValues, key));
}
}
/**
* dev only
*/
function validatePropName(key) {
if (key[0] !== '$') {
return true;
}
else if ((true)) {
warn(`Invalid prop name: "${key}" is a reserved property.`);
}
return false;
}
/**
* dev only
*/
function validateProp(name, value, prop, isAbsent) {
const { type, required, validator } = prop;
// required!
if (required && isAbsent) {
warn('Missing required prop: "' + name + '"');
return;
}
// missing but optional
if (value == null && !prop.required) {
return;
}
// type check
if (type != null && type !== true) {
let isValid = false;
const types = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(type) ? type : [type];
const expectedTypes = [];
// value is valid as long as one of the specified types match
for (let i = 0; i < types.length && !isValid; i++) {
const { valid, expectedType } = assertType(value, types[i]);
expectedTypes.push(expectedType || '');
isValid = valid;
}
if (!isValid) {
warn(getInvalidTypeMessage(name, value, expectedTypes));
return;
}
}
// custom validator
if (validator && !validator(value)) {
warn('Invalid prop: custom validator check failed for prop "' + name + '".');
}
}
const isSimpleType = /*#__PURE__*/ Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* makeMap */ "D"])('String,Number,Boolean,Function,Symbol');
/**
* dev only
*/
function assertType(value, type) {
let valid;
const expectedType = getType(type);
if (isSimpleType(expectedType)) {
const t = typeof value;
valid = t === expectedType.toLowerCase();
// for primitive wrapper objects
if (!valid && t === 'object') {
valid = value instanceof type;
}
}
else if (expectedType === 'Object') {
valid = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(value);
}
else if (expectedType === 'Array') {
valid = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(value);
}
else {
valid = value instanceof type;
}
return {
valid,
expectedType
};
}
/**
* dev only
*/
function getInvalidTypeMessage(name, value, expectedTypes) {
let message = `Invalid prop: type check failed for prop "${name}".` +
` Expected ${expectedTypes.map(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* capitalize */ "f"]).join(', ')}`;
const expectedType = expectedTypes[0];
const receivedType = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* toRawType */ "I"])(value);
const expectedValue = styleValue(value, expectedType);
const receivedValue = styleValue(value, receivedType);
// check if we need to specify expected value
if (expectedTypes.length === 1 &&
isExplicable(expectedType) &&
!isBoolean(expectedType, receivedType)) {
message += ` with value ${expectedValue}`;
}
message += `, got ${receivedType} `;
// check if we need to specify received value
if (isExplicable(receivedType)) {
message += `with value ${receivedValue}.`;
}
return message;
}
/**
* dev only
*/
function styleValue(value, type) {
if (type === 'String') {
return `"${value}"`;
}
else if (type === 'Number') {
return `${Number(value)}`;
}
else {
return `${value}`;
}
}
/**
* dev only
*/
function isExplicable(type) {
const explicitTypes = ['string', 'number', 'boolean'];
return explicitTypes.some(elem => type.toLowerCase() === elem);
}
/**
* dev only
*/
function isBoolean(...args) {
return args.some(elem => elem.toLowerCase() === 'boolean');
}
function injectHook(type, hook, target = currentInstance, prepend = false) {
if (target) {
const hooks = target[type] || (target[type] = []);
// cache the error handling wrapper for injected hooks so the same hook
// can be properly deduped by the scheduler. "__weh" stands for "with error
// handling".
const wrappedHook = hook.__weh ||
(hook.__weh = (...args) => {
if (target.isUnmounted) {
return;
}
// disable tracking inside all lifecycle hooks
// since they can potentially be called inside effects.
Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* pauseTracking */ "f"])();
// Set currentInstance during hook invocation.
// This assumes the hook does not synchronously trigger other hooks, which
// can only be false when the user does something really funky.
setCurrentInstance(target);
const res = callWithAsyncErrorHandling(hook, target, type, args);
setCurrentInstance(null);
Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* resetTracking */ "j"])();
return res;
});
if (prepend) {
hooks.unshift(wrappedHook);
}
else {
hooks.push(wrappedHook);
}
return wrappedHook;
}
else if ((true)) {
const apiName = `on${Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* capitalize */ "f"])(ErrorTypeStrings[type].replace(/ hook$/, ''))}`;
warn(`${apiName} is called when there is no active component instance to be ` +
`associated with. ` +
`Lifecycle injection APIs can only be used during execution of setup().` +
( ` If you are using async setup(), make sure to register lifecycle ` +
`hooks before the first await statement.`
));
}
}
const createHook = (lifecycle) => (hook, target = currentInstance) =>
// post-create lifecycle registrations are noops during SSR
!isInSSRComponentSetup && injectHook(lifecycle, hook, target);
const onBeforeMount = createHook("bm" /* BEFORE_MOUNT */);
const onMounted = createHook("m" /* MOUNTED */);
const onBeforeUpdate = createHook("bu" /* BEFORE_UPDATE */);
const onUpdated = createHook("u" /* UPDATED */);
const onBeforeUnmount = createHook("bum" /* BEFORE_UNMOUNT */);
const onUnmounted = createHook("um" /* UNMOUNTED */);
const onRenderTriggered = createHook("rtg" /* RENDER_TRIGGERED */);
const onRenderTracked = createHook("rtc" /* RENDER_TRACKED */);
const onErrorCaptured = (hook, target = currentInstance) => {
injectHook("ec" /* ERROR_CAPTURED */, hook, target);
};
function useTransitionState() {
const state = {
isMounted: false,
isLeaving: false,
isUnmounting: false,
leavingVNodes: new Map()
};
onMounted(() => {
state.isMounted = true;
});
onBeforeUnmount(() => {
state.isUnmounting = true;
});
return state;
}
const TransitionHookValidator = [Function, Array];
const BaseTransitionImpl = {
name: `BaseTransition`,
props: {
mode: String,
appear: Boolean,
persisted: Boolean,
// enter
onBeforeEnter: TransitionHookValidator,
onEnter: TransitionHookValidator,
onAfterEnter: TransitionHookValidator,
onEnterCancelled: TransitionHookValidator,
// leave
onBeforeLeave: TransitionHookValidator,
onLeave: TransitionHookValidator,
onAfterLeave: TransitionHookValidator,
onLeaveCancelled: TransitionHookValidator,
// appear
onBeforeAppear: TransitionHookValidator,
onAppear: TransitionHookValidator,
onAfterAppear: TransitionHookValidator,
onAppearCancelled: TransitionHookValidator
},
setup(props, { slots }) {
const instance = getCurrentInstance();
const state = useTransitionState();
let prevTransitionKey;
return () => {
const children = slots.default && getTransitionRawChildren(slots.default(), true);
if (!children || !children.length) {
return;
}
// warn multiple elements
if (( true) && children.length > 1) {
warn('<transition> can only be used on a single element or component. Use ' +
'<transition-group> for lists.');
}
// there's no need to track reactivity for these props so use the raw
// props for a bit better perf
const rawProps = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* toRaw */ "n"])(props);
const { mode } = rawProps;
// check mode
if (( true) && mode && !['in-out', 'out-in', 'default'].includes(mode)) {
warn(`invalid <transition> mode: ${mode}`);
}
// at this point children has a guaranteed length of 1.
const child = children[0];
if (state.isLeaving) {
return emptyPlaceholder(child);
}
// in the case of <transition><keep-alive/></transition>, we need to
// compare the type of the kept-alive children.
const innerChild = getKeepAliveChild(child);
if (!innerChild) {
return emptyPlaceholder(child);
}
const enterHooks = (innerChild.transition = resolveTransitionHooks(innerChild, rawProps, state, instance));
const oldChild = instance.subTree;
const oldInnerChild = oldChild && getKeepAliveChild(oldChild);
let transitionKeyChanged = false;
const { getTransitionKey } = innerChild.type;
if (getTransitionKey) {
const key = getTransitionKey();
if (prevTransitionKey === undefined) {
prevTransitionKey = key;
}
else if (key !== prevTransitionKey) {
prevTransitionKey = key;
transitionKeyChanged = true;
}
}
// handle mode
if (oldInnerChild &&
oldInnerChild.type !== Comment &&
(!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {
const leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance);
// update old tree's hooks in case of dynamic transition
setTransitionHooks(oldInnerChild, leavingHooks);
// switching between different views
if (mode === 'out-in') {
state.isLeaving = true;
// return placeholder node and queue update when leave finishes
leavingHooks.afterLeave = () => {
state.isLeaving = false;
instance.update();
};
return emptyPlaceholder(child);
}
else if (mode === 'in-out') {
leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild);
leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
// early removal callback
el._leaveCb = () => {
earlyRemove();
el._leaveCb = undefined;
delete enterHooks.delayedLeave;
};
enterHooks.delayedLeave = delayedLeave;
};
}
}
return child;
};
}
};
// export the public type for h/tsx inference
// also to avoid inline import() in generated d.ts files
const BaseTransition = BaseTransitionImpl;
function getLeavingNodesForType(state, vnode) {
const { leavingVNodes } = state;
let leavingVNodesCache = leavingVNodes.get(vnode.type);
if (!leavingVNodesCache) {
leavingVNodesCache = Object.create(null);
leavingVNodes.set(vnode.type, leavingVNodesCache);
}
return leavingVNodesCache;
}
// The transition hooks are attached to the vnode as vnode.transition
// and will be called at appropriate timing in the renderer.
function resolveTransitionHooks(vnode, { appear, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled }, state, instance) {
const key = String(vnode.key);
const leavingVNodesCache = getLeavingNodesForType(state, vnode);
const callHook = (hook, args) => {
hook &&
callWithAsyncErrorHandling(hook, instance, 9 /* TRANSITION_HOOK */, args);
};
const hooks = {
persisted,
beforeEnter(el) {
let hook = onBeforeEnter;
if (!state.isMounted) {
if (appear) {
hook = onBeforeAppear || onBeforeEnter;
}
else {
return;
}
}
// for same element (v-show)
if (el._leaveCb) {
el._leaveCb(true /* cancelled */);
}
// for toggled element with same key (v-if)
const leavingVNode = leavingVNodesCache[key];
if (leavingVNode &&
isSameVNodeType(vnode, leavingVNode) &&
leavingVNode.el._leaveCb) {
// force early removal (not cancelled)
leavingVNode.el._leaveCb();
}
callHook(hook, [el]);
},
enter(el) {
let hook = onEnter;
let afterHook = onAfterEnter;
let cancelHook = onEnterCancelled;
if (!state.isMounted) {
if (appear) {
hook = onAppear || onEnter;
afterHook = onAfterAppear || onAfterEnter;
cancelHook = onAppearCancelled || onEnterCancelled;
}
else {
return;
}
}
let called = false;
const done = (el._enterCb = (cancelled) => {
if (called)
return;
called = true;
if (cancelled) {
callHook(cancelHook, [el]);
}
else {
callHook(afterHook, [el]);
}
if (hooks.delayedLeave) {
hooks.delayedLeave();
}
el._enterCb = undefined;
});
if (hook) {
hook(el, done);
if (hook.length <= 1) {
done();
}
}
else {
done();
}
},
leave(el, remove) {
const key = String(vnode.key);
if (el._enterCb) {
el._enterCb(true /* cancelled */);
}
if (state.isUnmounting) {
return remove();
}
callHook(onBeforeLeave, [el]);
let called = false;
const done = (el._leaveCb = (cancelled) => {
if (called)
return;
called = true;
remove();
if (cancelled) {
callHook(onLeaveCancelled, [el]);
}
else {
callHook(onAfterLeave, [el]);
}
el._leaveCb = undefined;
if (leavingVNodesCache[key] === vnode) {
delete leavingVNodesCache[key];
}
});
leavingVNodesCache[key] = vnode;
if (onLeave) {
onLeave(el, done);
if (onLeave.length <= 1) {
done();
}
}
else {
done();
}
}
};
return hooks;
}
// the placeholder really only handles one special case: KeepAlive
// in the case of a KeepAlive in a leave phase we need to return a KeepAlive
// placeholder with empty content to avoid the KeepAlive instance from being
// unmounted.
function emptyPlaceholder(vnode) {
if (isKeepAlive(vnode)) {
vnode = cloneVNode(vnode);
vnode.children = null;
return vnode;
}
}
function getKeepAliveChild(vnode) {
return isKeepAlive(vnode)
? vnode.children
? vnode.children[0]
: undefined
: vnode;
}
function setTransitionHooks(vnode, hooks) {
if (vnode.shapeFlag & 6 /* COMPONENT */ && vnode.component) {
setTransitionHooks(vnode.component.subTree, hooks);
}
else {
vnode.transition = hooks;
}
}
function getTransitionRawChildren(children, keepComment = false) {
let ret = [];
let keyedFragmentCount = 0;
for (let i = 0; i < children.length; i++) {
const child = children[i];
// handle fragment children case, e.g. v-for
if (child.type === Fragment) {
if (child.patchFlag & 128 /* KEYED_FRAGMENT */)
keyedFragmentCount++;
ret = ret.concat(getTransitionRawChildren(child.children, keepComment));
}
// comment placeholders should be skipped, e.g. v-if
else if (keepComment || child.type !== Comment) {
ret.push(child);
}
}
// #1126 if a transition children list contains multiple sub fragments, these
// fragments will be merged into a flat children array. Since each v-for
// fragment may contain different static bindings inside, we need to de-top
// these children to force full diffs to ensure correct behavior.
if (keyedFragmentCount > 1) {
for (let i = 0; i < ret.length; i++) {
ret[i].patchFlag = -2 /* BAIL */;
}
}
return ret;
}
const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
const KeepAliveImpl = {
name: `KeepAlive`,
// Marker for special handling inside the renderer. We are not using a ===
// check directly on KeepAlive in the renderer, because importing it directly
// would prevent it from being tree-shaken.
__isKeepAlive: true,
inheritRef: true,
props: {
include: [String, RegExp, Array],
exclude: [String, RegExp, Array],
max: [String, Number]
},
setup(props, { slots }) {
const cache = new Map();
const keys = new Set();
let current = null;
const instance = getCurrentInstance();
const parentSuspense = instance.suspense;
// KeepAlive communicates with the instantiated renderer via the
// ctx where the renderer passes in its internals,
// and the KeepAlive instance exposes activate/deactivate implementations.
// The whole point of this is to avoid importing KeepAlive directly in the
// renderer to facilitate tree-shaking.
const sharedContext = instance.ctx;
const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext;
const storageContainer = createElement('div');
sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {
const instance = vnode.component;
move(vnode, container, anchor, 0 /* ENTER */, parentSuspense);
// in case props have changed
patch(instance.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, optimized);
queuePostRenderEffect(() => {
instance.isDeactivated = false;
if (instance.a) {
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* invokeArrayFns */ "m"])(instance.a);
}
const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
if (vnodeHook) {
invokeVNodeHook(vnodeHook, instance.parent, vnode);
}
}, parentSuspense);
};
sharedContext.deactivate = (vnode) => {
const instance = vnode.component;
move(vnode, storageContainer, null, 1 /* LEAVE */, parentSuspense);
queuePostRenderEffect(() => {
if (instance.da) {
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* invokeArrayFns */ "m"])(instance.da);
}
const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
if (vnodeHook) {
invokeVNodeHook(vnodeHook, instance.parent, vnode);
}
instance.isDeactivated = true;
}, parentSuspense);
};
function unmount(vnode) {
// reset the shapeFlag so it can be properly unmounted
resetShapeFlag(vnode);
_unmount(vnode, instance, parentSuspense);
}
function pruneCache(filter) {
cache.forEach((vnode, key) => {
const name = getName(vnode.type);
if (name && (!filter || !filter(name))) {
pruneCacheEntry(key);
}
});
}
function pruneCacheEntry(key) {
const cached = cache.get(key);
if (!current || cached.type !== current.type) {
unmount(cached);
}
else if (current) {
// current active instance should no longer be kept-alive.
// we can't unmount it now but it might be later, so reset its flag now.
resetShapeFlag(current);
}
cache.delete(key);
keys.delete(key);
}
watch(() => [props.include, props.exclude], ([include, exclude]) => {
include && pruneCache(name => matches(include, name));
exclude && pruneCache(name => matches(exclude, name));
});
// cache sub tree in beforeMount/Update (i.e. right after the render)
let pendingCacheKey = null;
const cacheSubtree = () => {
// fix #1621, the pendingCacheKey could be 0
if (pendingCacheKey != null) {
cache.set(pendingCacheKey, instance.subTree);
}
};
onBeforeMount(cacheSubtree);
onBeforeUpdate(cacheSubtree);
onBeforeUnmount(() => {
cache.forEach(cached => {
const { subTree, suspense } = instance;
if (cached.type === subTree.type) {
// current instance will be unmounted as part of keep-alive's unmount
resetShapeFlag(subTree);
// but invoke its deactivated hook here
const da = subTree.component.da;
da && queuePostRenderEffect(da, suspense);
return;
}
unmount(cached);
});
});
return () => {
pendingCacheKey = null;
if (!slots.default) {
return null;
}
const children = slots.default();
let vnode = children[0];
if (children.length > 1) {
if ((true)) {
warn(`KeepAlive should contain exactly one component child.`);
}
current = null;
return children;
}
else if (!isVNode(vnode) ||
!(vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */)) {
current = null;
return vnode;
}
const comp = vnode.type;
const name = getName(comp);
const { include, exclude, max } = props;
if ((include && (!name || !matches(include, name))) ||
(exclude && name && matches(exclude, name))) {
return (current = vnode);
}
const key = vnode.key == null ? comp : vnode.key;
const cachedVNode = cache.get(key);
// clone vnode if it's reused because we are going to mutate it
if (vnode.el) {
vnode = cloneVNode(vnode);
}
// #1513 it's possible for the returned vnode to be cloned due to attr
// fallthrough or scopeId, so the vnode here may not be the final vnode
// that is mounted. Instead of caching it directly, we store the pending
// key and cache `instance.subTree` (the normalized vnode) in
// beforeMount/beforeUpdate hooks.
pendingCacheKey = key;
if (cachedVNode) {
// copy over mounted state
vnode.el = cachedVNode.el;
vnode.component = cachedVNode.component;
if (vnode.transition) {
// recursively update transition hooks on subTree
setTransitionHooks(vnode, vnode.transition);
}
// avoid vnode being mounted as fresh
vnode.shapeFlag |= 512 /* COMPONENT_KEPT_ALIVE */;
// make this key the freshest
keys.delete(key);
keys.add(key);
}
else {
keys.add(key);
// prune oldest entry
if (max && keys.size > parseInt(max, 10)) {
pruneCacheEntry(keys.values().next().value);
}
}
// avoid vnode being unmounted
vnode.shapeFlag |= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;
current = vnode;
return vnode;
};
}
};
// export the public type for h/tsx inference
// also to avoid inline import() in generated d.ts files
const KeepAlive = KeepAliveImpl;
function getName(comp) {
return comp.displayName || comp.name;
}
function matches(pattern, name) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(pattern)) {
return pattern.some((p) => matches(p, name));
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(pattern)) {
return pattern.split(',').indexOf(name) > -1;
}
else if (pattern.test) {
return pattern.test(name);
}
/* istanbul ignore next */
return false;
}
function onActivated(hook, target) {
registerKeepAliveHook(hook, "a" /* ACTIVATED */, target);
}
function onDeactivated(hook, target) {
registerKeepAliveHook(hook, "da" /* DEACTIVATED */, target);
}
function registerKeepAliveHook(hook, type, target = currentInstance) {
// cache the deactivate branch check wrapper for injected hooks so the same
// hook can be properly deduped by the scheduler. "__wdc" stands for "with
// deactivation check".
const wrappedHook = hook.__wdc ||
(hook.__wdc = () => {
// only fire the hook if the target instance is NOT in a deactivated branch.
let current = target;
while (current) {
if (current.isDeactivated) {
return;
}
current = current.parent;
}
hook();
});
injectHook(type, wrappedHook, target);
// In addition to registering it on the target instance, we walk up the parent
// chain and register it on all ancestor instances that are keep-alive roots.
// This avoids the need to walk the entire component tree when invoking these
// hooks, and more importantly, avoids the need to track child components in
// arrays.
if (target) {
let current = target.parent;
while (current && current.parent) {
if (isKeepAlive(current.parent.vnode)) {
injectToKeepAliveRoot(wrappedHook, type, target, current);
}
current = current.parent;
}
}
}
function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
// injectHook wraps the original for error handling, so make sure to remove
// the wrapped version.
const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */);
onUnmounted(() => {
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* remove */ "G"])(keepAliveRoot[type], injected);
}, target);
}
function resetShapeFlag(vnode) {
let shapeFlag = vnode.shapeFlag;
if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {
shapeFlag -= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;
}
if (shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) {
shapeFlag -= 512 /* COMPONENT_KEPT_ALIVE */;
}
vnode.shapeFlag = shapeFlag;
}
const isInternalKey = (key) => key[0] === '_' || key === '$stable';
const normalizeSlotValue = (value) => Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(value)
? value.map(normalizeVNode)
: [normalizeVNode(value)];
const normalizeSlot = (key, rawSlot, ctx) => withCtx((props) => {
if (( true) && currentInstance) {
warn(`Slot "${key}" invoked outside of the render function: ` +
`this will not track dependencies used in the slot. ` +
`Invoke the slot function inside the render function instead.`);
}
return normalizeSlotValue(rawSlot(props));
}, ctx);
const normalizeObjectSlots = (rawSlots, slots) => {
const ctx = rawSlots._ctx;
for (const key in rawSlots) {
if (isInternalKey(key))
continue;
const value = rawSlots[key];
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(value)) {
slots[key] = normalizeSlot(key, value, ctx);
}
else if (value != null) {
if ((true)) {
warn(`Non-function value encountered for slot "${key}". ` +
`Prefer function slots for better performance.`);
}
const normalized = normalizeSlotValue(value);
slots[key] = () => normalized;
}
}
};
const normalizeVNodeSlots = (instance, children) => {
if (( true) && !isKeepAlive(instance.vnode)) {
warn(`Non-function value encountered for default slot. ` +
`Prefer function slots for better performance.`);
}
const normalized = normalizeSlotValue(children);
instance.slots.default = () => normalized;
};
const initSlots = (instance, children) => {
if (instance.vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {
const type = children._;
if (type) {
instance.slots = children;
// make compiler marker non-enumerable
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* def */ "g"])(children, '_', type);
}
else {
normalizeObjectSlots(children, (instance.slots = {}));
}
}
else {
instance.slots = {};
if (children) {
normalizeVNodeSlots(instance, children);
}
}
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* def */ "g"])(instance.slots, InternalObjectKey, 1);
};
const updateSlots = (instance, children) => {
const { vnode, slots } = instance;
let needDeletionCheck = true;
let deletionComparisonTarget = _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"];
if (vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {
const type = children._;
if (type) {
// compiled slots.
if (( true) && isHmrUpdating) {
// Parent was HMR updated so slot content may have changed.
// force update slots and mark instance for hmr as well
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])(slots, children);
}
else if (type === 1 /* STABLE */) {
// compiled AND stable.
// no need to update, and skip stale slots removal.
needDeletionCheck = false;
}
else {
// compiled but dynamic (v-if/v-for on slots) - update slots, but skip
// normalization.
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])(slots, children);
}
}
else {
needDeletionCheck = !children.$stable;
normalizeObjectSlots(children, slots);
}
deletionComparisonTarget = children;
}
else if (children) {
// non slot object children (direct value) passed to a component
normalizeVNodeSlots(instance, children);
deletionComparisonTarget = { default: 1 };
}
// delete stale slots
if (needDeletionCheck) {
for (const key in slots) {
if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {
delete slots[key];
}
}
}
};
/**
Runtime helper for applying directives to a vnode. Example usage:
const comp = resolveComponent('comp')
const foo = resolveDirective('foo')
const bar = resolveDirective('bar')
return withDirectives(h(comp), [
[foo, this.x],
[bar, this.y]
])
*/
const isBuiltInDirective = /*#__PURE__*/ Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* makeMap */ "D"])('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text');
function validateDirectiveName(name) {
if (isBuiltInDirective(name)) {
warn('Do not use built-in directive ids as custom directive id: ' + name);
}
}
/**
* Adds directives to a VNode.
*/
function withDirectives(vnode, directives) {
const internalInstance = currentRenderingInstance;
if (internalInstance === null) {
( true) && warn(`withDirectives can only be used inside render functions.`);
return vnode;
}
const instance = internalInstance.proxy;
const bindings = vnode.dirs || (vnode.dirs = []);
for (let i = 0; i < directives.length; i++) {
let [dir, value, arg, modifiers = _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"]] = directives[i];
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(dir)) {
dir = {
mounted: dir,
updated: dir
};
}
bindings.push({
dir,
instance,
value,
oldValue: void 0,
arg,
modifiers
});
}
return vnode;
}
function invokeDirectiveHook(vnode, prevVNode, instance, name) {
const bindings = vnode.dirs;
const oldBindings = prevVNode && prevVNode.dirs;
for (let i = 0; i < bindings.length; i++) {
const binding = bindings[i];
if (oldBindings) {
binding.oldValue = oldBindings[i].value;
}
const hook = binding.dir[name];
if (hook) {
callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [
vnode.el,
binding,
vnode,
prevVNode
]);
}
}
}
function createAppContext() {
return {
app: null,
config: {
isNativeTag: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NO */ "c"],
performance: false,
globalProperties: {},
optionMergeStrategies: {},
isCustomElement: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NO */ "c"],
errorHandler: undefined,
warnHandler: undefined
},
mixins: [],
components: {},
directives: {},
provides: Object.create(null)
};
}
let uid = 0;
function createAppAPI(render, hydrate) {
return function createApp(rootComponent, rootProps = null) {
if (rootProps != null && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(rootProps)) {
( true) && warn(`root props passed to app.mount() must be an object.`);
rootProps = null;
}
const context = createAppContext();
const installedPlugins = new Set();
let isMounted = false;
const app = (context.app = {
_uid: uid++,
_component: rootComponent,
_props: rootProps,
_container: null,
_context: context,
version,
get config() {
return context.config;
},
set config(v) {
if ((true)) {
warn(`app.config cannot be replaced. Modify individual options instead.`);
}
},
use(plugin, ...options) {
if (installedPlugins.has(plugin)) {
( true) && warn(`Plugin has already been applied to target app.`);
}
else if (plugin && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(plugin.install)) {
installedPlugins.add(plugin);
plugin.install(app, ...options);
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(plugin)) {
installedPlugins.add(plugin);
plugin(app, ...options);
}
else if ((true)) {
warn(`A plugin must either be a function or an object with an "install" ` +
`function.`);
}
return app;
},
mixin(mixin) {
if (__VUE_OPTIONS_API__) {
if (!context.mixins.includes(mixin)) {
context.mixins.push(mixin);
}
else if ((true)) {
warn('Mixin has already been applied to target app' +
(mixin.name ? `: ${mixin.name}` : ''));
}
}
else if ((true)) {
warn('Mixins are only available in builds supporting Options API');
}
return app;
},
component(name, component) {
if ((true)) {
validateComponentName(name, context.config);
}
if (!component) {
return context.components[name];
}
if (( true) && context.components[name]) {
warn(`Component "${name}" has already been registered in target app.`);
}
context.components[name] = component;
return app;
},
directive(name, directive) {
if ((true)) {
validateDirectiveName(name);
}
if (!directive) {
return context.directives[name];
}
if (( true) && context.directives[name]) {
warn(`Directive "${name}" has already been registered in target app.`);
}
context.directives[name] = directive;
return app;
},
mount(rootContainer, isHydrate) {
if (!isMounted) {
const vnode = createVNode(rootComponent, rootProps);
// store app context on the root VNode.
// this will be set on the root instance on initial mount.
vnode.appContext = context;
// HMR root reload
if ((true)) {
context.reload = () => {
render(cloneVNode(vnode), rootContainer);
};
}
if (isHydrate && hydrate) {
hydrate(vnode, rootContainer);
}
else {
render(vnode, rootContainer);
}
isMounted = true;
app._container = rootContainer;
rootContainer.__vue_app__ = app;
if (true) {
devtoolsInitApp(app, version);
}
return vnode.component.proxy;
}
else if ((true)) {
warn(`App has already been mounted.\n` +
`If you want to remount the same app, move your app creation logic ` +
`into a factory function and create fresh app instances for each ` +
`mount - e.g. \`const createMyApp = () => createApp(App)\``);
}
},
unmount() {
if (isMounted) {
render(null, app._container);
if (true) {
devtoolsUnmountApp(app);
}
}
else if ((true)) {
warn(`Cannot unmount an app that is not mounted.`);
}
},
provide(key, value) {
if (( true) && key in context.provides) {
warn(`App already provides property with key "${String(key)}". ` +
`It will be overwritten with the new value.`);
}
// TypeScript doesn't allow symbols as index type
// https://github.com/Microsoft/TypeScript/issues/24587
context.provides[key] = value;
return app;
}
});
return app;
};
}
let hasMismatch = false;
const isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== 'foreignObject';
const isComment = (node) => node.nodeType === 8 /* COMMENT */;
// Note: hydration is DOM-specific
// But we have to place it in core due to tight coupling with core - splitting
// it out creates a ton of unnecessary complexity.
// Hydration also depends on some renderer internal logic which needs to be
// passed in via arguments.
function createHydrationFunctions(rendererInternals) {
const { mt: mountComponent, p: patch, o: { patchProp, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals;
const hydrate = (vnode, container) => {
if (( true) && !container.hasChildNodes()) {
warn(`Attempting to hydrate existing markup but container is empty. ` +
`Performing full mount instead.`);
patch(null, vnode, container);
return;
}
hasMismatch = false;
hydrateNode(container.firstChild, vnode, null, null);
flushPostFlushCbs();
if (hasMismatch && !false) {
// this error should show up in production
console.error(`Hydration completed but contains mismatches.`);
}
};
const hydrateNode = (node, vnode, parentComponent, parentSuspense, optimized = false) => {
const isFragmentStart = isComment(node) && node.data === '[';
const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, isFragmentStart);
const { type, ref, shapeFlag } = vnode;
const domType = node.nodeType;
vnode.el = node;
let nextNode = null;
switch (type) {
case Text:
if (domType !== 3 /* TEXT */) {
nextNode = onMismatch();
}
else {
if (node.data !== vnode.children) {
hasMismatch = true;
( true) &&
warn(`Hydration text mismatch:` +
`\n- Client: ${JSON.stringify(node.data)}` +
`\n- Server: ${JSON.stringify(vnode.children)}`);
node.data = vnode.children;
}
nextNode = nextSibling(node);
}
break;
case Comment:
if (domType !== 8 /* COMMENT */ || isFragmentStart) {
nextNode = onMismatch();
}
else {
nextNode = nextSibling(node);
}
break;
case Static:
if (domType !== 1 /* ELEMENT */) {
nextNode = onMismatch();
}
else {
// determine anchor, adopt content
nextNode = node;
// if the static vnode has its content stripped during build,
// adopt it from the server-rendered HTML.
const needToAdoptContent = !vnode.children.length;
for (let i = 0; i < vnode.staticCount; i++) {
if (needToAdoptContent)
vnode.children += nextNode.outerHTML;
if (i === vnode.staticCount - 1) {
vnode.anchor = nextNode;
}
nextNode = nextSibling(nextNode);
}
return nextNode;
}
break;
case Fragment:
if (!isFragmentStart) {
nextNode = onMismatch();
}
else {
nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, optimized);
}
break;
default:
if (shapeFlag & 1 /* ELEMENT */) {
if (domType !== 1 /* ELEMENT */ ||
vnode.type !== node.tagName.toLowerCase()) {
nextNode = onMismatch();
}
else {
nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, optimized);
}
}
else if (shapeFlag & 6 /* COMPONENT */) {
// when setting up the render effect, if the initial vnode already
// has .el set, the component will perform hydration instead of mount
// on its sub-tree.
const container = parentNode(node);
const hydrateComponent = () => {
mountComponent(vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), optimized);
};
// async component
const loadAsync = vnode.type.__asyncLoader;
if (loadAsync) {
loadAsync().then(hydrateComponent);
}
else {
hydrateComponent();
}
// component may be async, so in the case of fragments we cannot rely
// on component's rendered output to determine the end of the fragment
// instead, we do a lookahead to find the end anchor node.
nextNode = isFragmentStart
? locateClosingAsyncAnchor(node)
: nextSibling(node);
}
else if (shapeFlag & 64 /* TELEPORT */) {
if (domType !== 8 /* COMMENT */) {
nextNode = onMismatch();
}
else {
nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, optimized, rendererInternals, hydrateChildren);
}
}
else if ( shapeFlag & 128 /* SUSPENSE */) {
nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, isSVGContainer(parentNode(node)), optimized, rendererInternals, hydrateNode);
}
else if ((true)) {
warn('Invalid HostVNode type:', type, `(${typeof type})`);
}
}
if (ref != null && parentComponent) {
setRef(ref, null, parentComponent, parentSuspense, vnode);
}
return nextNode;
};
const hydrateElement = (el, vnode, parentComponent, parentSuspense, optimized) => {
optimized = optimized || !!vnode.dynamicChildren;
const { props, patchFlag, shapeFlag, dirs } = vnode;
// skip props & children if this is hoisted static nodes
if (patchFlag !== -1 /* HOISTED */) {
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, 'created');
}
// props
if (props) {
if (!optimized ||
(patchFlag & 16 /* FULL_PROPS */ ||
patchFlag & 32 /* HYDRATE_EVENTS */)) {
for (const key in props) {
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isReservedProp */ "w"])(key) && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isOn */ "u"])(key)) {
patchProp(el, key, null, props[key]);
}
}
}
else if (props.onClick) {
// Fast path for click listeners (which is most often) to avoid
// iterating through props.
patchProp(el, 'onClick', null, props.onClick);
}
}
// vnode / directive hooks
let vnodeHooks;
if ((vnodeHooks = props && props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHooks, parentComponent, vnode);
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount');
}
if ((vnodeHooks = props && props.onVnodeMounted) || dirs) {
queueEffectWithSuspense(() => {
vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted');
}, parentSuspense);
}
// children
if (shapeFlag & 16 /* ARRAY_CHILDREN */ &&
// skip if element has innerHTML / textContent
!(props && (props.innerHTML || props.textContent))) {
let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, optimized);
let hasWarned = false;
while (next) {
hasMismatch = true;
if (( true) && !hasWarned) {
warn(`Hydration children mismatch in <${vnode.type}>: ` +
`server rendered element contains more child nodes than client vdom.`);
hasWarned = true;
}
// The SSRed DOM contains more nodes than it should. Remove them.
const cur = next;
next = next.nextSibling;
remove(cur);
}
}
else if (shapeFlag & 8 /* TEXT_CHILDREN */) {
if (el.textContent !== vnode.children) {
hasMismatch = true;
( true) &&
warn(`Hydration text content mismatch in <${vnode.type}>:\n` +
`- Client: ${el.textContent}\n` +
`- Server: ${vnode.children}`);
el.textContent = vnode.children;
}
}
}
return el.nextSibling;
};
const hydrateChildren = (node, vnode, container, parentComponent, parentSuspense, optimized) => {
optimized = optimized || !!vnode.dynamicChildren;
const children = vnode.children;
const l = children.length;
let hasWarned = false;
for (let i = 0; i < l; i++) {
const vnode = optimized
? children[i]
: (children[i] = normalizeVNode(children[i]));
if (node) {
node = hydrateNode(node, vnode, parentComponent, parentSuspense, optimized);
}
else {
hasMismatch = true;
if (( true) && !hasWarned) {
warn(`Hydration children mismatch in <${container.tagName.toLowerCase()}>: ` +
`server rendered element contains fewer child nodes than client vdom.`);
hasWarned = true;
}
// the SSRed DOM didn't contain enough nodes. Mount the missing ones.
patch(null, vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container));
}
}
return node;
};
const hydrateFragment = (node, vnode, parentComponent, parentSuspense, optimized) => {
const container = parentNode(node);
const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, optimized);
if (next && isComment(next) && next.data === ']') {
return nextSibling((vnode.anchor = next));
}
else {
// fragment didn't hydrate successfully, since we didn't get a end anchor
// back. This should have led to node/children mismatch warnings.
hasMismatch = true;
// since the anchor is missing, we need to create one and insert it
insert((vnode.anchor = createComment(`]`)), container, next);
return next;
}
};
const handleMismatch = (node, vnode, parentComponent, parentSuspense, isFragment) => {
hasMismatch = true;
( true) &&
warn(`Hydration node mismatch:\n- Client vnode:`, vnode.type, `\n- Server rendered DOM:`, node, node.nodeType === 3 /* TEXT */
? `(text)`
: isComment(node) && node.data === '['
? `(start of fragment)`
: ``);
vnode.el = null;
if (isFragment) {
// remove excessive fragment nodes
const end = locateClosingAsyncAnchor(node);
while (true) {
const next = nextSibling(node);
if (next && next !== end) {
remove(next);
}
else {
break;
}
}
}
const next = nextSibling(node);
const container = parentNode(node);
remove(node);
patch(null, vnode, container, next, parentComponent, parentSuspense, isSVGContainer(container));
return next;
};
const locateClosingAsyncAnchor = (node) => {
let match = 0;
while (node) {
node = nextSibling(node);
if (node && isComment(node)) {
if (node.data === '[')
match++;
if (node.data === ']') {
if (match === 0) {
return nextSibling(node);
}
else {
match--;
}
}
}
}
return node;
};
return [hydrate, hydrateNode];
}
let supported;
let perf;
function startMeasure(instance, type) {
if (instance.appContext.config.performance && isSupported()) {
perf.mark(`vue-${type}-${instance.uid}`);
}
}
function endMeasure(instance, type) {
if (instance.appContext.config.performance && isSupported()) {
const startTag = `vue-${type}-${instance.uid}`;
const endTag = startTag + `:end`;
perf.mark(endTag);
perf.measure(`<${formatComponentName(instance, instance.type)}> ${type}`, startTag, endTag);
perf.clearMarks(startTag);
perf.clearMarks(endTag);
}
}
function isSupported() {
if (supported !== undefined) {
return supported;
}
/* eslint-disable no-restricted-globals */
if (typeof window !== 'undefined' && window.performance) {
supported = true;
perf = window.performance;
}
else {
supported = false;
}
/* eslint-enable no-restricted-globals */
return supported;
}
/**
* This is only called in esm-bundler builds.
* It is called when a renderer is created, in `baseCreateRenderer` so that
* importing runtime-core is side-effects free.
*
* istanbul-ignore-next
*/
function initFeatureFlags() {
let needWarn = false;
if (typeof __VUE_OPTIONS_API__ !== 'boolean') {
needWarn = true;
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* getGlobalThis */ "i"])().__VUE_OPTIONS_API__ = true;
}
if (typeof __VUE_PROD_DEVTOOLS__ !== 'boolean') {
needWarn = true;
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* getGlobalThis */ "i"])().__VUE_PROD_DEVTOOLS__ = false;
}
if (( true) && needWarn) {
console.warn(`You are running the esm-bundler build of Vue. It is recommended to ` +
`configure your bundler to explicitly replace feature flag globals ` +
`with boolean literals to get proper tree-shaking in the final bundle. ` +
`See http://link.vuejs.org/feature-flags for more details.`);
}
}
const prodEffectOptions = {
scheduler: queueJob
};
function createDevEffectOptions(instance) {
return {
scheduler: queueJob,
onTrack: instance.rtc ? e => Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* invokeArrayFns */ "m"])(instance.rtc, e) : void 0,
onTrigger: instance.rtg ? e => Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* invokeArrayFns */ "m"])(instance.rtg, e) : void 0
};
}
const queuePostRenderEffect = queueEffectWithSuspense
;
const setRef = (rawRef, oldRawRef, parentComponent, parentSuspense, vnode) => {
let value;
if (!vnode) {
value = null;
}
else {
if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) {
value = vnode.component.proxy;
}
else {
value = vnode.el;
}
}
const [owner, ref] = rawRef;
if (( true) && !owner) {
warn(`Missing ref owner context. ref cannot be used on hoisted vnodes. ` +
`A vnode with ref must be created inside the render function.`);
return;
}
const oldRef = oldRawRef && oldRawRef[1];
const refs = owner.refs === _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"] ? (owner.refs = {}) : owner.refs;
const setupState = owner.setupState;
// unset old ref
if (oldRef != null && oldRef !== ref) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(oldRef)) {
refs[oldRef] = null;
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(setupState, oldRef)) {
setupState[oldRef] = null;
}
}
else if (Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* isRef */ "e"])(oldRef)) {
oldRef.value = null;
}
}
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(ref)) {
const doSet = () => {
refs[ref] = value;
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(setupState, ref)) {
setupState[ref] = value;
}
};
// #1789: for non-null values, set them after render
// null values means this is unmount and it should not overwrite another
// ref with the same key
if (value) {
doSet.id = -1;
queuePostRenderEffect(doSet, parentSuspense);
}
else {
doSet();
}
}
else if (Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* isRef */ "e"])(ref)) {
const doSet = () => {
ref.value = value;
};
if (value) {
doSet.id = -1;
queuePostRenderEffect(doSet, parentSuspense);
}
else {
doSet();
}
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(ref)) {
callWithErrorHandling(ref, parentComponent, 12 /* FUNCTION_REF */, [
value,
refs
]);
}
else if ((true)) {
warn('Invalid template ref type:', value, `(${typeof value})`);
}
};
/**
* The createRenderer function accepts two generic arguments:
* HostNode and HostElement, corresponding to Node and Element types in the
* host environment. For example, for runtime-dom, HostNode would be the DOM
* `Node` interface and HostElement would be the DOM `Element` interface.
*
* Custom renderers can pass in the platform specific types like this:
*
* ``` js
* const { render, createApp } = createRenderer<Node, Element>({
* patchProp,
* ...nodeOps
* })
* ```
*/
function createRenderer(options) {
return baseCreateRenderer(options);
}
// Separate API for creating hydration-enabled renderer.
// Hydration logic is only used when calling this function, making it
// tree-shakable.
function createHydrationRenderer(options) {
return baseCreateRenderer(options, createHydrationFunctions);
}
// implementation
function baseCreateRenderer(options, createHydrationFns) {
// compile-time feature flags check
{
initFeatureFlags();
}
const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, forcePatchProp: hostForcePatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"], cloneNode: hostCloneNode, insertStaticContent: hostInsertStaticContent } = options;
// Note: functions inside this closure should use `const xxx = () => {}`
// style in order to prevent being inlined by minifiers.
const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, optimized = false) => {
// patching & not same type, unmount old tree
if (n1 && !isSameVNodeType(n1, n2)) {
anchor = getNextHostNode(n1);
unmount(n1, parentComponent, parentSuspense, true);
n1 = null;
}
if (n2.patchFlag === -2 /* BAIL */) {
optimized = false;
n2.dynamicChildren = null;
}
const { type, ref, shapeFlag } = n2;
switch (type) {
case Text:
processText(n1, n2, container, anchor);
break;
case Comment:
processCommentNode(n1, n2, container, anchor);
break;
case Static:
if (n1 == null) {
mountStaticNode(n2, container, anchor, isSVG);
}
else if ((true)) {
patchStaticNode(n1, n2, container, isSVG);
}
break;
case Fragment:
processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
break;
default:
if (shapeFlag & 1 /* ELEMENT */) {
processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
else if (shapeFlag & 6 /* COMPONENT */) {
processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
else if (shapeFlag & 64 /* TELEPORT */) {
type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals);
}
else if ( shapeFlag & 128 /* SUSPENSE */) {
type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals);
}
else if ((true)) {
warn('Invalid VNode type:', type, `(${typeof type})`);
}
}
// set ref
if (ref != null && parentComponent) {
setRef(ref, n1 && n1.ref, parentComponent, parentSuspense, n2);
}
};
const processText = (n1, n2, container, anchor) => {
if (n1 == null) {
hostInsert((n2.el = hostCreateText(n2.children)), container, anchor);
}
else {
const el = (n2.el = n1.el);
if (n2.children !== n1.children) {
hostSetText(el, n2.children);
}
}
};
const processCommentNode = (n1, n2, container, anchor) => {
if (n1 == null) {
hostInsert((n2.el = hostCreateComment(n2.children || '')), container, anchor);
}
else {
// there's no support for dynamic comments
n2.el = n1.el;
}
};
const mountStaticNode = (n2, container, anchor, isSVG) => {
[n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG);
};
/**
* Dev / HMR only
*/
const patchStaticNode = (n1, n2, container, isSVG) => {
// static nodes are only patched during dev for HMR
if (n2.children !== n1.children) {
const anchor = hostNextSibling(n1.anchor);
// remove existing
removeStaticNode(n1);
[n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG);
}
else {
n2.el = n1.el;
n2.anchor = n1.anchor;
}
};
/**
* Dev / HMR only
*/
const moveStaticNode = (vnode, container, anchor) => {
let cur = vnode.el;
const end = vnode.anchor;
while (cur && cur !== end) {
const next = hostNextSibling(cur);
hostInsert(cur, container, anchor);
cur = next;
}
hostInsert(end, container, anchor);
};
/**
* Dev / HMR only
*/
const removeStaticNode = (vnode) => {
let cur = vnode.el;
while (cur && cur !== vnode.anchor) {
const next = hostNextSibling(cur);
hostRemove(cur);
cur = next;
}
hostRemove(vnode.anchor);
};
const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
isSVG = isSVG || n2.type === 'svg';
if (n1 == null) {
mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
else {
patchElement(n1, n2, parentComponent, parentSuspense, isSVG, optimized);
}
};
const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
let el;
let vnodeHook;
const { type, props, shapeFlag, transition, scopeId, patchFlag, dirs } = vnode;
if (false /* HOISTED */) {}
else {
el = vnode.el = hostCreateElement(vnode.type, isSVG, props && props.is);
// mount children first, since some props may rely on child content
// being already rendered, e.g. `<select value>`
if (shapeFlag & 8 /* TEXT_CHILDREN */) {
hostSetElementText(el, vnode.children);
}
else if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
mountChildren(vnode.children, el, null, parentComponent, parentSuspense, isSVG && type !== 'foreignObject', optimized || !!vnode.dynamicChildren);
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, 'created');
}
// props
if (props) {
for (const key in props) {
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isReservedProp */ "w"])(key)) {
hostPatchProp(el, key, null, props[key], isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);
}
}
if ((vnodeHook = props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
}
// scopeId
setScopeId(el, scopeId, vnode, parentComponent);
// if (scopeId) {
// hostSetScopeId(el, scopeId)
// }
// if (parentComponent) {
// const treeOwnerId = parentComponent.type.__scopeId
// // vnode's own scopeId and the current patched component's scopeId is
// // different - this is a slot content node.
// if (treeOwnerId && treeOwnerId !== scopeId) {
// hostSetScopeId(el, treeOwnerId + '-s')
// }
// const parentScopeId =
// vnode === parentComponent.subTree && parentComponent.vnode.scopeId
// if (parentScopeId) {
// hostSetScopeId(el, parentScopeId)
// if (parentComponent.parent) {
// const treeOwnerId = parentComponent.parent.type.__scopeId
// // vnode's own scopeId and the current patched component's scopeId is
// // different - this is a slot content node.
// if (treeOwnerId && treeOwnerId !== parentScopeId) {
// hostSetScopeId(el, treeOwnerId + '-s')
// }
// }
// }
// }
}
if (true) {
Object.defineProperty(el, '__vnode', {
value: vnode,
enumerable: false
});
Object.defineProperty(el, '__vueParentComponent', {
value: parentComponent,
enumerable: false
});
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount');
}
// #1583 For inside suspense + suspense not resolved case, enter hook should call when suspense resolved
// #1689 For inside suspense + suspense resolved case, just call it
const needCallTransitionHooks = (!parentSuspense || (parentSuspense && parentSuspense.isResolved)) &&
transition &&
!transition.persisted;
if (needCallTransitionHooks) {
transition.beforeEnter(el);
}
hostInsert(el, container, anchor);
if ((vnodeHook = props && props.onVnodeMounted) ||
needCallTransitionHooks ||
dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
needCallTransitionHooks && transition.enter(el);
dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted');
}, parentSuspense);
}
};
const setScopeId = (el, scopeId, vnode, parentComponent) => {
if (scopeId) {
hostSetScopeId(el, scopeId);
}
if (parentComponent) {
const treeOwnerId = parentComponent.type.__scopeId;
// vnode's own scopeId and the current patched component's scopeId is
// different - this is a slot content node.
if (treeOwnerId && treeOwnerId !== scopeId) {
hostSetScopeId(el, treeOwnerId + '-s');
}
if (vnode === parentComponent.subTree) {
setScopeId(el, parentComponent.vnode.scopeId, parentComponent.vnode, parentComponent.parent);
}
}
};
const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, optimized, start = 0) => {
for (let i = start; i < children.length; i++) {
const child = (children[i] = optimized
? cloneIfMounted(children[i])
: normalizeVNode(children[i]));
patch(null, child, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
};
const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, optimized) => {
const el = (n2.el = n1.el);
let { patchFlag, dynamicChildren, dirs } = n2;
// #1426 take the old vnode's patch flag into account since user may clone a
// compiler-generated vnode, which de-opts to FULL_PROPS
patchFlag |= n1.patchFlag & 16 /* FULL_PROPS */;
const oldProps = n1.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"];
const newProps = n2.props || _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"];
let vnodeHook;
if ((vnodeHook = newProps.onVnodeBeforeUpdate)) {
invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
}
if (dirs) {
invokeDirectiveHook(n2, n1, parentComponent, 'beforeUpdate');
}
if (( true) && isHmrUpdating) {
// HMR updated, force full diff
patchFlag = 0;
optimized = false;
dynamicChildren = null;
}
if (patchFlag > 0) {
// the presence of a patchFlag means this element's render code was
// generated by the compiler and can take the fast path.
// in this path old node and new node are guaranteed to have the same shape
// (i.e. at the exact same position in the source template)
if (patchFlag & 16 /* FULL_PROPS */) {
// element props contain dynamic keys, full diff needed
patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);
}
else {
// class
// this flag is matched when the element has dynamic class bindings.
if (patchFlag & 2 /* CLASS */) {
if (oldProps.class !== newProps.class) {
hostPatchProp(el, 'class', null, newProps.class, isSVG);
}
}
// style
// this flag is matched when the element has dynamic style bindings
if (patchFlag & 4 /* STYLE */) {
hostPatchProp(el, 'style', oldProps.style, newProps.style, isSVG);
}
// props
// This flag is matched when the element has dynamic prop/attr bindings
// other than class and style. The keys of dynamic prop/attrs are saved for
// faster iteration.
// Note dynamic keys like :[foo]="bar" will cause this optimization to
// bail out and go through a full diff because we need to unset the old key
if (patchFlag & 8 /* PROPS */) {
// if the flag is present then dynamicProps must be non-null
const propsToUpdate = n2.dynamicProps;
for (let i = 0; i < propsToUpdate.length; i++) {
const key = propsToUpdate[i];
const prev = oldProps[key];
const next = newProps[key];
if (next !== prev ||
(hostForcePatchProp && hostForcePatchProp(el, key))) {
hostPatchProp(el, key, prev, next, isSVG, n1.children, parentComponent, parentSuspense, unmountChildren);
}
}
}
}
// text
// This flag is matched when the element has only dynamic text children.
if (patchFlag & 1 /* TEXT */) {
if (n1.children !== n2.children) {
hostSetElementText(el, n2.children);
}
}
}
else if (!optimized && dynamicChildren == null) {
// unoptimized, full diff
patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);
}
const areChildrenSVG = isSVG && n2.type !== 'foreignObject';
if (dynamicChildren) {
patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, areChildrenSVG);
if (( true) && parentComponent && parentComponent.type.__hmrId) {
traverseStaticChildren(n1, n2);
}
}
else if (!optimized) {
// full diff
patchChildren(n1, n2, el, null, parentComponent, parentSuspense, areChildrenSVG);
}
if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
dirs && invokeDirectiveHook(n2, n1, parentComponent, 'updated');
}, parentSuspense);
}
};
// The fast path for blocks.
const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG) => {
for (let i = 0; i < newChildren.length; i++) {
const oldVNode = oldChildren[i];
const newVNode = newChildren[i];
// Determine the container (parent element) for the patch.
const container =
// - In the case of a Fragment, we need to provide the actual parent
// of the Fragment itself so it can move its children.
oldVNode.type === Fragment ||
// - In the case of different nodes, there is going to be a replacement
// which also requires the correct parent container
!isSameVNodeType(oldVNode, newVNode) ||
// - In the case of a component, it could contain anything.
oldVNode.shapeFlag & 6 /* COMPONENT */ ||
oldVNode.shapeFlag & 64 /* TELEPORT */
? hostParentNode(oldVNode.el)
: // In other cases, the parent container is not actually used so we
// just pass the block element here to avoid a DOM parentNode call.
fallbackContainer;
patch(oldVNode, newVNode, container, null, parentComponent, parentSuspense, isSVG, true);
}
};
const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {
if (oldProps !== newProps) {
for (const key in newProps) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isReservedProp */ "w"])(key))
continue;
const next = newProps[key];
const prev = oldProps[key];
if (next !== prev ||
(hostForcePatchProp && hostForcePatchProp(el, key))) {
hostPatchProp(el, key, prev, next, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);
}
}
if (oldProps !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"]) {
for (const key in oldProps) {
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isReservedProp */ "w"])(key) && !(key in newProps)) {
hostPatchProp(el, key, oldProps[key], null, isSVG, vnode.children, parentComponent, parentSuspense, unmountChildren);
}
}
}
}
};
const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
const fragmentStartAnchor = (n2.el = n1 ? n1.el : hostCreateText(''));
const fragmentEndAnchor = (n2.anchor = n1 ? n1.anchor : hostCreateText(''));
let { patchFlag, dynamicChildren } = n2;
if (patchFlag > 0) {
optimized = true;
}
if (( true) && isHmrUpdating) {
// HMR updated, force full diff
patchFlag = 0;
optimized = false;
dynamicChildren = null;
}
if (n1 == null) {
hostInsert(fragmentStartAnchor, container, anchor);
hostInsert(fragmentEndAnchor, container, anchor);
// a fragment can only have array children
// since they are either generated by the compiler, or implicitly created
// from arrays.
mountChildren(n2.children, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);
}
else {
if (patchFlag > 0 &&
patchFlag & 64 /* STABLE_FRAGMENT */ &&
dynamicChildren) {
// a stable fragment (template root or <template v-for>) doesn't need to
// patch children order, but it may contain dynamicChildren.
patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, isSVG);
if (( true) && parentComponent && parentComponent.type.__hmrId) {
traverseStaticChildren(n1, n2);
}
}
else {
// keyed / unkeyed, or manual fragments.
// for keyed & unkeyed, since they are compiler generated from v-for,
// each child is guaranteed to be a block so the fragment will never
// have dynamicChildren.
patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, isSVG, optimized);
}
}
};
const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
if (n1 == null) {
if (n2.shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) {
parentComponent.ctx.activate(n2, container, anchor, isSVG, optimized);
}
else {
mountComponent(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
}
else {
updateComponent(n1, n2, optimized);
}
};
const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
const instance = (initialVNode.component = createComponentInstance(initialVNode, parentComponent, parentSuspense));
if (( true) && instance.type.__hmrId) {
registerHMR(instance);
}
if ((true)) {
pushWarningContext(initialVNode);
startMeasure(instance, `mount`);
}
// inject renderer internals for keepAlive
if (isKeepAlive(initialVNode)) {
instance.ctx.renderer = internals;
}
// resolve props and slots for setup context
if ((true)) {
startMeasure(instance, `init`);
}
setupComponent(instance);
if ((true)) {
endMeasure(instance, `init`);
}
// setup() is async. This component relies on async logic to be resolved
// before proceeding
if ( instance.asyncDep) {
if (!parentSuspense) {
if ((true))
warn('async setup() is used without a suspense boundary!');
return;
}
parentSuspense.registerDep(instance, setupRenderEffect);
// Give it a placeholder if this is not hydration
if (!initialVNode.el) {
const placeholder = (instance.subTree = createVNode(Comment));
processCommentNode(null, placeholder, container, anchor);
}
return;
}
setupRenderEffect(instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized);
if ((true)) {
popWarningContext();
endMeasure(instance, `mount`);
}
};
const updateComponent = (n1, n2, optimized) => {
const instance = (n2.component = n1.component);
if (shouldUpdateComponent(n1, n2, optimized)) {
if (
instance.asyncDep &&
!instance.asyncResolved) {
// async & still pending - just update props and slots
// since the component's reactive effect for render isn't set-up yet
if ((true)) {
pushWarningContext(n2);
}
updateComponentPreRender(instance, n2, optimized);
if ((true)) {
popWarningContext();
}
return;
}
else {
// normal update
instance.next = n2;
// in case the child component is also queued, remove it to avoid
// double updating the same child component in the same flush.
invalidateJob(instance.update);
// instance.update is the reactive effect runner.
instance.update();
}
}
else {
// no update needed. just copy over properties
n2.component = n1.component;
n2.el = n1.el;
instance.vnode = n2;
}
};
const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => {
// create reactive effect for rendering
instance.update = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* effect */ "b"])(function componentEffect() {
if (!instance.isMounted) {
let vnodeHook;
const { el, props } = initialVNode;
const { bm, m, parent } = instance;
// beforeMount hook
if (bm) {
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* invokeArrayFns */ "m"])(bm);
}
// onVnodeBeforeMount
if ((vnodeHook = props && props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHook, parent, initialVNode);
}
// render
if ((true)) {
startMeasure(instance, `render`);
}
const subTree = (instance.subTree = renderComponentRoot(instance));
if ((true)) {
endMeasure(instance, `render`);
}
if (el && hydrateNode) {
if ((true)) {
startMeasure(instance, `hydrate`);
}
// vnode has adopted host node - perform hydration instead of mount.
hydrateNode(initialVNode.el, subTree, instance, parentSuspense);
if ((true)) {
endMeasure(instance, `hydrate`);
}
}
else {
if ((true)) {
startMeasure(instance, `patch`);
}
patch(null, subTree, container, anchor, instance, parentSuspense, isSVG);
if ((true)) {
endMeasure(instance, `patch`);
}
initialVNode.el = subTree.el;
}
// mounted hook
if (m) {
queuePostRenderEffect(m, parentSuspense);
}
// onVnodeMounted
if ((vnodeHook = props && props.onVnodeMounted)) {
queuePostRenderEffect(() => {
invokeVNodeHook(vnodeHook, parent, initialVNode);
}, parentSuspense);
}
// activated hook for keep-alive roots.
// #1742 activated hook must be accessed after first render
// since the hook may be injected by a child keep-alive
const { a } = instance;
if (a &&
initialVNode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {
queuePostRenderEffect(a, parentSuspense);
}
instance.isMounted = true;
}
else {
// updateComponent
// This is triggered by mutation of component's own state (next: null)
// OR parent calling processComponent (next: VNode)
let { next, bu, u, parent, vnode } = instance;
let originNext = next;
let vnodeHook;
if ((true)) {
pushWarningContext(next || instance.vnode);
}
if (next) {
updateComponentPreRender(instance, next, optimized);
}
else {
next = vnode;
}
next.el = vnode.el;
// beforeUpdate hook
if (bu) {
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* invokeArrayFns */ "m"])(bu);
}
// onVnodeBeforeUpdate
if ((vnodeHook = next.props && next.props.onVnodeBeforeUpdate)) {
invokeVNodeHook(vnodeHook, parent, next, vnode);
}
// render
if ((true)) {
startMeasure(instance, `render`);
}
const nextTree = renderComponentRoot(instance);
if ((true)) {
endMeasure(instance, `render`);
}
const prevTree = instance.subTree;
instance.subTree = nextTree;
// reset refs
// only needed if previous patch had refs
if (instance.refs !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"]) {
instance.refs = {};
}
if ((true)) {
startMeasure(instance, `patch`);
}
patch(prevTree, nextTree,
// parent may have changed if it's in a teleport
hostParentNode(prevTree.el),
// anchor may have changed if it's in a fragment
getNextHostNode(prevTree), instance, parentSuspense, isSVG);
if ((true)) {
endMeasure(instance, `patch`);
}
next.el = nextTree.el;
if (originNext === null) {
// self-triggered update. In case of HOC, update parent component
// vnode el. HOC is indicated by parent instance's subTree pointing
// to child component's vnode
updateHOCHostEl(instance, nextTree.el);
}
// updated hook
if (u) {
queuePostRenderEffect(u, parentSuspense);
}
// onVnodeUpdated
if ((vnodeHook = next.props && next.props.onVnodeUpdated)) {
queuePostRenderEffect(() => {
invokeVNodeHook(vnodeHook, parent, next, vnode);
}, parentSuspense);
}
if (true) {
devtoolsComponentUpdated(instance);
}
if ((true)) {
popWarningContext();
}
}
}, ( true) ? createDevEffectOptions(instance) : undefined);
instance.update.allowRecurse = true;
};
const updateComponentPreRender = (instance, nextVNode, optimized) => {
nextVNode.component = instance;
const prevProps = instance.vnode.props;
instance.vnode = nextVNode;
instance.next = null;
updateProps(instance, nextVNode.props, prevProps, optimized);
updateSlots(instance, nextVNode.children);
// props update may have triggered pre-flush watchers.
// flush them before the render update.
flushPreFlushCbs(undefined, instance.update);
};
const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized = false) => {
const c1 = n1 && n1.children;
const prevShapeFlag = n1 ? n1.shapeFlag : 0;
const c2 = n2.children;
const { patchFlag, shapeFlag } = n2;
// fast path
if (patchFlag > 0) {
if (patchFlag & 128 /* KEYED_FRAGMENT */) {
// this could be either fully-keyed or mixed (some keyed some not)
// presence of patchFlag means children are guaranteed to be arrays
patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
return;
}
else if (patchFlag & 256 /* UNKEYED_FRAGMENT */) {
// unkeyed
patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
return;
}
}
// children has 3 possibilities: text, array or no children.
if (shapeFlag & 8 /* TEXT_CHILDREN */) {
// text children fast path
if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) {
unmountChildren(c1, parentComponent, parentSuspense);
}
if (c2 !== c1) {
hostSetElementText(container, c2);
}
}
else {
if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) {
// prev children was array
if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
// two arrays, cannot assume anything, do full diff
patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
else {
// no new children, just unmount old
unmountChildren(c1, parentComponent, parentSuspense, true);
}
}
else {
// prev children was text OR null
// new children is array OR null
if (prevShapeFlag & 8 /* TEXT_CHILDREN */) {
hostSetElementText(container, '');
}
// mount new if array
if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized);
}
}
}
};
const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
c1 = c1 || _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_ARR */ "a"];
c2 = c2 || _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_ARR */ "a"];
const oldLength = c1.length;
const newLength = c2.length;
const commonLength = Math.min(oldLength, newLength);
let i;
for (i = 0; i < commonLength; i++) {
const nextChild = (c2[i] = optimized
? cloneIfMounted(c2[i])
: normalizeVNode(c2[i]));
patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, isSVG, optimized);
}
if (oldLength > newLength) {
// remove old
unmountChildren(c1, parentComponent, parentSuspense, true, commonLength);
}
else {
// mount new
mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, commonLength);
}
};
// can be all-keyed or mixed
const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, optimized) => {
let i = 0;
const l2 = c2.length;
let e1 = c1.length - 1; // prev ending index
let e2 = l2 - 1; // next ending index
// 1. sync from start
// (a b) c
// (a b) d e
while (i <= e1 && i <= e2) {
const n1 = c1[i];
const n2 = (c2[i] = optimized
? cloneIfMounted(c2[i])
: normalizeVNode(c2[i]));
if (isSameVNodeType(n1, n2)) {
patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, optimized);
}
else {
break;
}
i++;
}
// 2. sync from end
// a (b c)
// d e (b c)
while (i <= e1 && i <= e2) {
const n1 = c1[e1];
const n2 = (c2[e2] = optimized
? cloneIfMounted(c2[e2])
: normalizeVNode(c2[e2]));
if (isSameVNodeType(n1, n2)) {
patch(n1, n2, container, null, parentComponent, parentSuspense, isSVG, optimized);
}
else {
break;
}
e1--;
e2--;
}
// 3. common sequence + mount
// (a b)
// (a b) c
// i = 2, e1 = 1, e2 = 2
// (a b)
// c (a b)
// i = 0, e1 = -1, e2 = 0
if (i > e1) {
if (i <= e2) {
const nextPos = e2 + 1;
const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
while (i <= e2) {
patch(null, (c2[i] = optimized
? cloneIfMounted(c2[i])
: normalizeVNode(c2[i])), container, anchor, parentComponent, parentSuspense, isSVG);
i++;
}
}
}
// 4. common sequence + unmount
// (a b) c
// (a b)
// i = 2, e1 = 2, e2 = 1
// a (b c)
// (b c)
// i = 0, e1 = 0, e2 = -1
else if (i > e2) {
while (i <= e1) {
unmount(c1[i], parentComponent, parentSuspense, true);
i++;
}
}
// 5. unknown sequence
// [i ... e1 + 1]: a b [c d e] f g
// [i ... e2 + 1]: a b [e d c h] f g
// i = 2, e1 = 4, e2 = 5
else {
const s1 = i; // prev starting index
const s2 = i; // next starting index
// 5.1 build key:index map for newChildren
const keyToNewIndexMap = new Map();
for (i = s2; i <= e2; i++) {
const nextChild = (c2[i] = optimized
? cloneIfMounted(c2[i])
: normalizeVNode(c2[i]));
if (nextChild.key != null) {
if (( true) && keyToNewIndexMap.has(nextChild.key)) {
warn(`Duplicate keys found during update:`, JSON.stringify(nextChild.key), `Make sure keys are unique.`);
}
keyToNewIndexMap.set(nextChild.key, i);
}
}
// 5.2 loop through old children left to be patched and try to patch
// matching nodes & remove nodes that are no longer present
let j;
let patched = 0;
const toBePatched = e2 - s2 + 1;
let moved = false;
// used to track whether any node has moved
let maxNewIndexSoFar = 0;
// works as Map<newIndex, oldIndex>
// Note that oldIndex is offset by +1
// and oldIndex = 0 is a special value indicating the new node has
// no corresponding old node.
// used for determining longest stable subsequence
const newIndexToOldIndexMap = new Array(toBePatched);
for (i = 0; i < toBePatched; i++)
newIndexToOldIndexMap[i] = 0;
for (i = s1; i <= e1; i++) {
const prevChild = c1[i];
if (patched >= toBePatched) {
// all new children have been patched so this can only be a removal
unmount(prevChild, parentComponent, parentSuspense, true);
continue;
}
let newIndex;
if (prevChild.key != null) {
newIndex = keyToNewIndexMap.get(prevChild.key);
}
else {
// key-less node, try to locate a key-less node of the same type
for (j = s2; j <= e2; j++) {
if (newIndexToOldIndexMap[j - s2] === 0 &&
isSameVNodeType(prevChild, c2[j])) {
newIndex = j;
break;
}
}
}
if (newIndex === undefined) {
unmount(prevChild, parentComponent, parentSuspense, true);
}
else {
newIndexToOldIndexMap[newIndex - s2] = i + 1;
if (newIndex >= maxNewIndexSoFar) {
maxNewIndexSoFar = newIndex;
}
else {
moved = true;
}
patch(prevChild, c2[newIndex], container, null, parentComponent, parentSuspense, isSVG, optimized);
patched++;
}
}
// 5.3 move and mount
// generate longest stable subsequence only when nodes have moved
const increasingNewIndexSequence = moved
? getSequence(newIndexToOldIndexMap)
: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_ARR */ "a"];
j = increasingNewIndexSequence.length - 1;
// looping backwards so that we can use last patched node as anchor
for (i = toBePatched - 1; i >= 0; i--) {
const nextIndex = s2 + i;
const nextChild = c2[nextIndex];
const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
if (newIndexToOldIndexMap[i] === 0) {
// mount new
patch(null, nextChild, container, anchor, parentComponent, parentSuspense, isSVG);
}
else if (moved) {
// move if:
// There is no stable subsequence (e.g. a reverse)
// OR current node is not among the stable sequence
if (j < 0 || i !== increasingNewIndexSequence[j]) {
move(nextChild, container, anchor, 2 /* REORDER */);
}
else {
j--;
}
}
}
}
};
const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
const { el, type, transition, children, shapeFlag } = vnode;
if (shapeFlag & 6 /* COMPONENT */) {
move(vnode.component.subTree, container, anchor, moveType);
return;
}
if ( shapeFlag & 128 /* SUSPENSE */) {
vnode.suspense.move(container, anchor, moveType);
return;
}
if (shapeFlag & 64 /* TELEPORT */) {
type.move(vnode, container, anchor, internals);
return;
}
if (type === Fragment) {
hostInsert(el, container, anchor);
for (let i = 0; i < children.length; i++) {
move(children[i], container, anchor, moveType);
}
hostInsert(vnode.anchor, container, anchor);
return;
}
// static node move can only happen when force updating HMR
if (( true) && type === Static) {
moveStaticNode(vnode, container, anchor);
return;
}
// single nodes
const needTransition = moveType !== 2 /* REORDER */ &&
shapeFlag & 1 /* ELEMENT */ &&
transition;
if (needTransition) {
if (moveType === 0 /* ENTER */) {
transition.beforeEnter(el);
hostInsert(el, container, anchor);
queuePostRenderEffect(() => transition.enter(el), parentSuspense);
}
else {
const { leave, delayLeave, afterLeave } = transition;
const remove = () => hostInsert(el, container, anchor);
const performLeave = () => {
leave(el, () => {
remove();
afterLeave && afterLeave();
});
};
if (delayLeave) {
delayLeave(el, remove, performLeave);
}
else {
performLeave();
}
}
}
else {
hostInsert(el, container, anchor);
}
};
const unmount = (vnode, parentComponent, parentSuspense, doRemove = false) => {
const { type, props, ref, children, dynamicChildren, shapeFlag, patchFlag, dirs } = vnode;
// unset ref
if (ref != null && parentComponent) {
setRef(ref, null, parentComponent, parentSuspense, null);
}
if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {
parentComponent.ctx.deactivate(vnode);
return;
}
const shouldInvokeDirs = shapeFlag & 1 /* ELEMENT */ && dirs;
let vnodeHook;
if ((vnodeHook = props && props.onVnodeBeforeUnmount)) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
if (shapeFlag & 6 /* COMPONENT */) {
unmountComponent(vnode.component, parentSuspense, doRemove);
}
else {
if ( shapeFlag & 128 /* SUSPENSE */) {
vnode.suspense.unmount(parentSuspense, doRemove);
return;
}
if (shouldInvokeDirs) {
invokeDirectiveHook(vnode, null, parentComponent, 'beforeUnmount');
}
if (dynamicChildren &&
// #1153: fast path should not be taken for non-stable (v-for) fragments
(type !== Fragment ||
(patchFlag > 0 && patchFlag & 64 /* STABLE_FRAGMENT */))) {
// fast path for block nodes: only need to unmount dynamic children.
unmountChildren(dynamicChildren, parentComponent, parentSuspense);
}
else if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
unmountChildren(children, parentComponent, parentSuspense);
}
// an unmounted teleport should always remove its children
if (shapeFlag & 64 /* TELEPORT */) {
vnode.type.remove(vnode, internals);
}
if (doRemove) {
remove(vnode);
}
}
if ((vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
shouldInvokeDirs &&
invokeDirectiveHook(vnode, null, parentComponent, 'unmounted');
}, parentSuspense);
}
};
const remove = vnode => {
const { type, el, anchor, transition } = vnode;
if (type === Fragment) {
removeFragment(el, anchor);
return;
}
if (( true) && type === Static) {
removeStaticNode(vnode);
return;
}
const performRemove = () => {
hostRemove(el);
if (transition && !transition.persisted && transition.afterLeave) {
transition.afterLeave();
}
};
if (vnode.shapeFlag & 1 /* ELEMENT */ &&
transition &&
!transition.persisted) {
const { leave, delayLeave } = transition;
const performLeave = () => leave(el, performRemove);
if (delayLeave) {
delayLeave(vnode.el, performRemove, performLeave);
}
else {
performLeave();
}
}
else {
performRemove();
}
};
const removeFragment = (cur, end) => {
// For fragments, directly remove all contained DOM nodes.
// (fragment child nodes cannot have transition)
let next;
while (cur !== end) {
next = hostNextSibling(cur);
hostRemove(cur);
cur = next;
}
hostRemove(end);
};
const unmountComponent = (instance, parentSuspense, doRemove) => {
if (( true) && instance.type.__hmrId) {
unregisterHMR(instance);
}
const { bum, effects, update, subTree, um } = instance;
// beforeUnmount hook
if (bum) {
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* invokeArrayFns */ "m"])(bum);
}
if (effects) {
for (let i = 0; i < effects.length; i++) {
Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* stop */ "m"])(effects[i]);
}
}
// update may be null if a component is unmounted before its async
// setup has resolved.
if (update) {
Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* stop */ "m"])(update);
unmount(subTree, instance, parentSuspense, doRemove);
}
// unmounted hook
if (um) {
queuePostRenderEffect(um, parentSuspense);
}
queuePostRenderEffect(() => {
instance.isUnmounted = true;
}, parentSuspense);
// A component with async dep inside a pending suspense is unmounted before
// its async dep resolves. This should remove the dep from the suspense, and
// cause the suspense to resolve immediately if that was the last dep.
if (
parentSuspense &&
!parentSuspense.isResolved &&
!parentSuspense.isUnmounted &&
instance.asyncDep &&
!instance.asyncResolved) {
parentSuspense.deps--;
if (parentSuspense.deps === 0) {
parentSuspense.resolve();
}
}
if (true) {
devtoolsComponentRemoved(instance);
}
};
const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, start = 0) => {
for (let i = start; i < children.length; i++) {
unmount(children[i], parentComponent, parentSuspense, doRemove);
}
};
const getNextHostNode = vnode => {
if (vnode.shapeFlag & 6 /* COMPONENT */) {
return getNextHostNode(vnode.component.subTree);
}
if ( vnode.shapeFlag & 128 /* SUSPENSE */) {
return vnode.suspense.next();
}
return hostNextSibling((vnode.anchor || vnode.el));
};
/**
* #1156
* When a component is HMR-enabled, we need to make sure that all static nodes
* inside a block also inherit the DOM element from the previous tree so that
* HMR updates (which are full updates) can retrieve the element for patching.
*
* Dev only.
*/
const traverseStaticChildren = (n1, n2) => {
const ch1 = n1.children;
const ch2 = n2.children;
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(ch1) && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(ch2)) {
for (let i = 0; i < ch1.length; i++) {
// this is only called in the optimized path so array children are
// guaranteed to be vnodes
const c1 = ch1[i];
const c2 = (ch2[i] = cloneIfMounted(ch2[i]));
if (c2.shapeFlag & 1 /* ELEMENT */ && !c2.dynamicChildren) {
if (c2.patchFlag <= 0 || c2.patchFlag === 32 /* HYDRATE_EVENTS */) {
c2.el = c1.el;
}
traverseStaticChildren(c1, c2);
}
}
}
};
const render = (vnode, container) => {
if (vnode == null) {
if (container._vnode) {
unmount(container._vnode, null, null, true);
}
}
else {
patch(container._vnode || null, vnode, container);
}
flushPostFlushCbs();
container._vnode = vnode;
};
const internals = {
p: patch,
um: unmount,
m: move,
r: remove,
mt: mountComponent,
mc: mountChildren,
pc: patchChildren,
pbc: patchBlockChildren,
n: getNextHostNode,
o: options
};
let hydrate;
let hydrateNode;
if (createHydrationFns) {
[hydrate, hydrateNode] = createHydrationFns(internals);
}
return {
render,
hydrate,
createApp: createAppAPI(render, hydrate)
};
}
function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
callWithAsyncErrorHandling(hook, instance, 7 /* VNODE_HOOK */, [
vnode,
prevVNode
]);
}
// https://en.wikipedia.org/wiki/Longest_increasing_subsequence
function getSequence(arr) {
const p = arr.slice();
const result = [0];
let i, j, u, v, c;
const len = arr.length;
for (i = 0; i < len; i++) {
const arrI = arr[i];
if (arrI !== 0) {
j = result[result.length - 1];
if (arr[j] < arrI) {
p[i] = j;
result.push(i);
continue;
}
u = 0;
v = result.length - 1;
while (u < v) {
c = ((u + v) / 2) | 0;
if (arr[result[c]] < arrI) {
u = c + 1;
}
else {
v = c;
}
}
if (arrI < arr[result[u]]) {
if (u > 0) {
p[i] = result[u - 1];
}
result[u] = i;
}
}
}
u = result.length;
v = result[u - 1];
while (u-- > 0) {
result[u] = v;
v = p[v];
}
return result;
}
// Simple effect.
function watchEffect(effect, options) {
return doWatch(effect, null, options);
}
// initial value for watchers to trigger on undefined initial values
const INITIAL_WATCHER_VALUE = {};
// implementation
function watch(source, cb, options) {
if (( true) && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(cb)) {
warn(`\`watch(fn, options?)\` signature has been moved to a separate API. ` +
`Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` +
`supports \`watch(source, cb, options?) signature.`);
}
return doWatch(source, cb, options);
}
function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"], instance = currentInstance) {
if (( true) && !cb) {
if (immediate !== undefined) {
warn(`watch() "immediate" option is only respected when using the ` +
`watch(source, callback, options?) signature.`);
}
if (deep !== undefined) {
warn(`watch() "deep" option is only respected when using the ` +
`watch(source, callback, options?) signature.`);
}
}
const warnInvalidSource = (s) => {
warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +
`a reactive object, or an array of these types.`);
};
let getter;
const isRefSource = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* isRef */ "e"])(source);
if (isRefSource) {
getter = () => source.value;
}
else if (Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* isReactive */ "d"])(source)) {
getter = () => source;
deep = true;
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(source)) {
getter = () => source.map(s => {
if (Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* isRef */ "e"])(s)) {
return s.value;
}
else if (Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* isReactive */ "d"])(s)) {
return traverse(s);
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(s)) {
return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);
}
else {
( true) && warnInvalidSource(s);
}
});
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(source)) {
if (cb) {
// getter with cb
getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);
}
else {
// no cb -> simple effect
getter = () => {
if (instance && instance.isUnmounted) {
return;
}
if (cleanup) {
cleanup();
}
return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);
};
}
}
else {
getter = _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"];
( true) && warnInvalidSource(source);
}
if (cb && deep) {
const baseGetter = getter;
getter = () => traverse(baseGetter());
}
let cleanup;
const onInvalidate = (fn) => {
cleanup = runner.options.onStop = () => {
callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);
};
};
let oldValue = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(source) ? [] : INITIAL_WATCHER_VALUE;
const job = () => {
if (!runner.active) {
return;
}
if (cb) {
// watch(source, cb)
const newValue = runner();
if (deep || isRefSource || Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasChanged */ "j"])(newValue, oldValue)) {
// cleanup before running cb again
if (cleanup) {
cleanup();
}
callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [
newValue,
// pass undefined as the old value when it's changed for the first time
oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,
onInvalidate
]);
oldValue = newValue;
}
}
else {
// watchEffect
runner();
}
};
// important: mark the job as a watcher callback so that scheduler knows it
// it is allowed to self-trigger (#1727)
job.allowRecurse = !!cb;
let scheduler;
if (flush === 'sync') {
scheduler = job;
}
else if (flush === 'pre') {
// ensure it's queued before component updates (which have positive ids)
job.id = -1;
scheduler = () => {
if (!instance || instance.isMounted) {
queuePreFlushCb(job);
}
else {
// with 'pre' option, the first call must happen before
// the component is mounted so it is called synchronously.
job();
}
};
}
else {
scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
}
const runner = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* effect */ "b"])(getter, {
lazy: true,
onTrack,
onTrigger,
scheduler
});
recordInstanceBoundEffect(runner);
// initial run
if (cb) {
if (immediate) {
job();
}
else {
oldValue = runner();
}
}
else {
runner();
}
return () => {
Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* stop */ "m"])(runner);
if (instance) {
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* remove */ "G"])(instance.effects, runner);
}
};
}
// this.$watch
function instanceWatch(source, cb, options) {
const publicThis = this.proxy;
const getter = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(source)
? () => publicThis[source]
: source.bind(publicThis);
return doWatch(getter, cb.bind(publicThis), options, this);
}
function traverse(value, seen = new Set()) {
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(value) || seen.has(value)) {
return value;
}
seen.add(value);
if (Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* isRef */ "e"])(value)) {
traverse(value.value, seen);
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(value)) {
for (let i = 0; i < value.length; i++) {
traverse(value[i], seen);
}
}
else if (value instanceof Map) {
value.forEach((v, key) => {
// to register mutation dep for existing keys
traverse(value.get(key), seen);
});
}
else if (value instanceof Set) {
value.forEach(v => {
traverse(v, seen);
});
}
else {
for (const key in value) {
traverse(value[key], seen);
}
}
return value;
}
function provide(key, value) {
if (!currentInstance) {
if ((true)) {
warn(`provide() can only be used inside setup().`);
}
}
else {
let provides = currentInstance.provides;
// by default an instance inherits its parent's provides object
// but when it needs to provide values of its own, it creates its
// own provides object using parent provides object as prototype.
// this way in `inject` we can simply look up injections from direct
// parent and let the prototype chain do the work.
const parentProvides = currentInstance.parent && currentInstance.parent.provides;
if (parentProvides === provides) {
provides = currentInstance.provides = Object.create(parentProvides);
}
// TS doesn't allow symbol as index type
provides[key] = value;
}
}
function inject(key, defaultValue) {
// fallback to `currentRenderingInstance` so that this can be called in
// a functional component
const instance = currentInstance || currentRenderingInstance;
if (instance) {
const provides = instance.provides;
if (key in provides) {
// TS doesn't allow symbol as index type
return provides[key];
}
else if (arguments.length > 1) {
return defaultValue;
}
else if ((true)) {
warn(`injection "${String(key)}" not found.`);
}
}
else if ((true)) {
warn(`inject() can only be used inside setup() or functional components.`);
}
}
function createDuplicateChecker() {
const cache = Object.create(null);
return (type, key) => {
if (cache[key]) {
warn(`${type} property "${key}" is already defined in ${cache[key]}.`);
}
else {
cache[key] = type;
}
};
}
let isInBeforeCreate = false;
function applyOptions(instance, options, deferredData = [], deferredWatch = [], asMixin = false) {
const {
// composition
mixins, extends: extendsOptions,
// state
data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions,
// assets
components, directives,
// lifecycle
beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeUnmount, unmounted, render, renderTracked, renderTriggered, errorCaptured } = options;
const publicThis = instance.proxy;
const ctx = instance.ctx;
const globalMixins = instance.appContext.mixins;
if (asMixin && render && instance.render === _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"]) {
instance.render = render;
}
// applyOptions is called non-as-mixin once per instance
if (!asMixin) {
isInBeforeCreate = true;
callSyncHook('beforeCreate', options, publicThis, globalMixins);
isInBeforeCreate = false;
// global mixins are applied first
applyMixins(instance, globalMixins, deferredData, deferredWatch);
}
// extending a base component...
if (extendsOptions) {
applyOptions(instance, extendsOptions, deferredData, deferredWatch, true);
}
// local mixins
if (mixins) {
applyMixins(instance, mixins, deferredData, deferredWatch);
}
const checkDuplicateProperties = ( true) ? createDuplicateChecker() : undefined;
if ((true)) {
const [propsOptions] = instance.propsOptions;
if (propsOptions) {
for (const key in propsOptions) {
checkDuplicateProperties("Props" /* PROPS */, key);
}
}
}
// options initialization order (to be consistent with Vue 2):
// - props (already done outside of this function)
// - inject
// - methods
// - data (deferred since it relies on `this` access)
// - computed
// - watch (deferred since it relies on `this` access)
if (injectOptions) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(injectOptions)) {
for (let i = 0; i < injectOptions.length; i++) {
const key = injectOptions[i];
ctx[key] = inject(key);
if ((true)) {
checkDuplicateProperties("Inject" /* INJECT */, key);
}
}
}
else {
for (const key in injectOptions) {
const opt = injectOptions[key];
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(opt)) {
ctx[key] = inject(opt.from, opt.default);
}
else {
ctx[key] = inject(opt);
}
if ((true)) {
checkDuplicateProperties("Inject" /* INJECT */, key);
}
}
}
}
if (methods) {
for (const key in methods) {
const methodHandler = methods[key];
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(methodHandler)) {
ctx[key] = methodHandler.bind(publicThis);
if ((true)) {
checkDuplicateProperties("Methods" /* METHODS */, key);
}
}
else if ((true)) {
warn(`Method "${key}" has type "${typeof methodHandler}" in the component definition. ` +
`Did you reference the function correctly?`);
}
}
}
if (!asMixin) {
if (deferredData.length) {
deferredData.forEach(dataFn => resolveData(instance, dataFn, publicThis));
}
if (dataOptions) {
resolveData(instance, dataOptions, publicThis);
}
if ((true)) {
const rawData = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* toRaw */ "n"])(instance.data);
for (const key in rawData) {
checkDuplicateProperties("Data" /* DATA */, key);
// expose data on ctx during dev
if (key[0] !== '$' && key[0] !== '_') {
Object.defineProperty(ctx, key, {
configurable: true,
enumerable: true,
get: () => rawData[key],
set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"]
});
}
}
}
}
else if (dataOptions) {
deferredData.push(dataOptions);
}
if (computedOptions) {
for (const key in computedOptions) {
const opt = computedOptions[key];
const get = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(opt)
? opt.bind(publicThis, publicThis)
: Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(opt.get)
? opt.get.bind(publicThis, publicThis)
: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"];
if (( true) && get === _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"]) {
warn(`Computed property "${key}" has no getter.`);
}
const set = !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(opt) && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(opt.set)
? opt.set.bind(publicThis)
: ( true)
? () => {
warn(`Write operation failed: computed property "${key}" is readonly.`);
}
: undefined;
const c = computed({
get,
set
});
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => c.value,
set: v => (c.value = v)
});
if ((true)) {
checkDuplicateProperties("Computed" /* COMPUTED */, key);
}
}
}
if (watchOptions) {
deferredWatch.push(watchOptions);
}
if (!asMixin && deferredWatch.length) {
deferredWatch.forEach(watchOptions => {
for (const key in watchOptions) {
createWatcher(watchOptions[key], ctx, publicThis, key);
}
});
}
if (provideOptions) {
const provides = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(provideOptions)
? provideOptions.call(publicThis)
: provideOptions;
for (const key in provides) {
provide(key, provides[key]);
}
}
// asset options.
// To reduce memory usage, only components with mixins or extends will have
// resolved asset registry attached to instance.
if (asMixin) {
if (components) {
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])(instance.components ||
(instance.components = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])({}, instance.type.components)), components);
}
if (directives) {
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])(instance.directives ||
(instance.directives = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])({}, instance.type.directives)), directives);
}
}
// lifecycle options
if (!asMixin) {
callSyncHook('created', options, publicThis, globalMixins);
}
if (beforeMount) {
onBeforeMount(beforeMount.bind(publicThis));
}
if (mounted) {
onMounted(mounted.bind(publicThis));
}
if (beforeUpdate) {
onBeforeUpdate(beforeUpdate.bind(publicThis));
}
if (updated) {
onUpdated(updated.bind(publicThis));
}
if (activated) {
onActivated(activated.bind(publicThis));
}
if (deactivated) {
onDeactivated(deactivated.bind(publicThis));
}
if (errorCaptured) {
onErrorCaptured(errorCaptured.bind(publicThis));
}
if (renderTracked) {
onRenderTracked(renderTracked.bind(publicThis));
}
if (renderTriggered) {
onRenderTriggered(renderTriggered.bind(publicThis));
}
if (beforeUnmount) {
onBeforeUnmount(beforeUnmount.bind(publicThis));
}
if (unmounted) {
onUnmounted(unmounted.bind(publicThis));
}
}
function callSyncHook(name, options, ctx, globalMixins) {
callHookFromMixins(name, globalMixins, ctx);
const { extends: base, mixins } = options;
if (base) {
callHookFromExtends(name, base, ctx);
}
if (mixins) {
callHookFromMixins(name, mixins, ctx);
}
const selfHook = options[name];
if (selfHook) {
selfHook.call(ctx);
}
}
function callHookFromExtends(name, base, ctx) {
if (base.extends) {
callHookFromExtends(name, base.extends, ctx);
}
const baseHook = base[name];
if (baseHook) {
baseHook.call(ctx);
}
}
function callHookFromMixins(name, mixins, ctx) {
for (let i = 0; i < mixins.length; i++) {
const chainedMixins = mixins[i].mixins;
if (chainedMixins) {
callHookFromMixins(name, chainedMixins, ctx);
}
const fn = mixins[i][name];
if (fn) {
fn.call(ctx);
}
}
}
function applyMixins(instance, mixins, deferredData, deferredWatch) {
for (let i = 0; i < mixins.length; i++) {
applyOptions(instance, mixins[i], deferredData, deferredWatch, true);
}
}
function resolveData(instance, dataFn, publicThis) {
if (( true) && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(dataFn)) {
warn(`The data option must be a function. ` +
`Plain object usage is no longer supported.`);
}
const data = dataFn.call(publicThis, publicThis);
if (( true) && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isPromise */ "v"])(data)) {
warn(`data() returned a Promise - note data() cannot be async; If you ` +
`intend to perform data fetching before component renders, use ` +
`async setup() + <Suspense>.`);
}
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(data)) {
( true) && warn(`data() should return an object.`);
}
else if (instance.data === _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"]) {
instance.data = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* reactive */ "h"])(data);
}
else {
// existing data: this is a mixin or extends.
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])(instance.data, data);
}
}
function createWatcher(raw, ctx, publicThis, key) {
const getter = () => publicThis[key];
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(raw)) {
const handler = ctx[raw];
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(handler)) {
watch(getter, handler);
}
else if ((true)) {
warn(`Invalid watch handler specified by key "${raw}"`, handler);
}
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(raw)) {
watch(getter, raw.bind(publicThis));
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(raw)) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(raw)) {
raw.forEach(r => createWatcher(r, ctx, publicThis, key));
}
else {
const handler = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(raw.handler)
? raw.handler.bind(publicThis)
: ctx[raw.handler];
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(handler)) {
watch(getter, handler, raw);
}
else if ((true)) {
warn(`Invalid watch handler specified by key "${raw.handler}"`, handler);
}
}
}
else if ((true)) {
warn(`Invalid watch option: "${key}"`);
}
}
function resolveMergedOptions(instance) {
const raw = instance.type;
const { __merged, mixins, extends: extendsOptions } = raw;
if (__merged)
return __merged;
const globalMixins = instance.appContext.mixins;
if (!globalMixins.length && !mixins && !extendsOptions)
return raw;
const options = {};
mergeOptions(options, raw, instance);
globalMixins.forEach(m => mergeOptions(options, m, instance));
return (raw.__merged = options);
}
function mergeOptions(to, from, instance) {
const strats = instance.appContext.config.optionMergeStrategies;
for (const key in from) {
if (strats && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(strats, key)) {
to[key] = strats[key](to[key], from[key], instance.proxy, key);
}
else if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(to, key)) {
to[key] = from[key];
}
}
const { mixins, extends: extendsOptions } = from;
extendsOptions && mergeOptions(to, extendsOptions, instance);
mixins &&
mixins.forEach((m) => mergeOptions(to, m, instance));
}
const publicPropertiesMap = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])(Object.create(null), {
$: i => i,
$el: i => i.vnode.el,
$data: i => i.data,
$props: i => (( true) ? Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* shallowReadonly */ "l"])(i.props) : undefined),
$attrs: i => (( true) ? Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* shallowReadonly */ "l"])(i.attrs) : undefined),
$slots: i => (( true) ? Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* shallowReadonly */ "l"])(i.slots) : undefined),
$refs: i => (( true) ? Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* shallowReadonly */ "l"])(i.refs) : undefined),
$parent: i => i.parent && i.parent.proxy,
$root: i => i.root && i.root.proxy,
$emit: i => i.emit,
$options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type),
$forceUpdate: i => () => queueJob(i.update),
$nextTick: () => nextTick,
$watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"])
});
const PublicInstanceProxyHandlers = {
get({ _: instance }, key) {
const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
// let @vue/reactivity know it should never observe Vue public instances.
if (key === "__v_skip" /* SKIP */) {
return true;
}
// data / props / ctx
// This getter gets called for every property access on the render context
// during render and is a major hotspot. The most expensive part of this
// is the multiple hasOwn() calls. It's much faster to do a simple property
// access on a plain object, so we use an accessCache object (with null
// prototype) to memoize what access type a key corresponds to.
let normalizedProps;
if (key[0] !== '$') {
const n = accessCache[key];
if (n !== undefined) {
switch (n) {
case 0 /* SETUP */:
return setupState[key];
case 1 /* DATA */:
return data[key];
case 3 /* CONTEXT */:
return ctx[key];
case 2 /* PROPS */:
return props[key];
// default: just fallthrough
}
}
else if (setupState !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"] && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(setupState, key)) {
accessCache[key] = 0 /* SETUP */;
return setupState[key];
}
else if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"] && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(data, key)) {
accessCache[key] = 1 /* DATA */;
return data[key];
}
else if (
// only cache other properties when instance has declared (thus stable)
// props
(normalizedProps = instance.propsOptions[0]) &&
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(normalizedProps, key)) {
accessCache[key] = 2 /* PROPS */;
return props[key];
}
else if (ctx !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"] && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(ctx, key)) {
accessCache[key] = 3 /* CONTEXT */;
return ctx[key];
}
else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) {
accessCache[key] = 4 /* OTHER */;
}
}
const publicGetter = publicPropertiesMap[key];
let cssModule, globalProperties;
// public $xxx properties
if (publicGetter) {
if (key === '$attrs') {
Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* track */ "o"])(instance, "get" /* GET */, key);
( true) && markAttrsAccessed();
}
return publicGetter(instance);
}
else if (
// css module (injected by vue-loader)
(cssModule = type.__cssModules) &&
(cssModule = cssModule[key])) {
return cssModule;
}
else if (ctx !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"] && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(ctx, key)) {
// user may set custom properties to `this` that start with `$`
accessCache[key] = 3 /* CONTEXT */;
return ctx[key];
}
else if (
// global properties
((globalProperties = appContext.config.globalProperties),
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(globalProperties, key))) {
return globalProperties[key];
}
else if (( true) &&
currentRenderingInstance &&
(!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(key) ||
// #1091 avoid internal isRef/isVNode checks on component instance leading
// to infinite warning loop
key.indexOf('__v') !== 0)) {
if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"] && key[0] === '$' && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(data, key)) {
warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +
`character and is not proxied on the render context.`);
}
else {
warn(`Property ${JSON.stringify(key)} was accessed during render ` +
`but is not defined on instance.`);
}
}
},
set({ _: instance }, key, value) {
const { data, setupState, ctx } = instance;
if (setupState !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"] && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(setupState, key)) {
setupState[key] = value;
}
else if (data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"] && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(data, key)) {
data[key] = value;
}
else if (key in instance.props) {
( true) &&
warn(`Attempting to mutate prop "${key}". Props are readonly.`, instance);
return false;
}
if (key[0] === '$' && key.slice(1) in instance) {
( true) &&
warn(`Attempting to mutate public property "${key}". ` +
`Properties starting with $ are reserved and readonly.`, instance);
return false;
}
else {
if (( true) && key in instance.appContext.config.globalProperties) {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
value
});
}
else {
ctx[key] = value;
}
}
return true;
},
has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {
let normalizedProps;
return (accessCache[key] !== undefined ||
(data !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"] && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(data, key)) ||
(setupState !== _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"] && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(setupState, key)) ||
((normalizedProps = propsOptions[0]) && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(normalizedProps, key)) ||
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(ctx, key) ||
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(publicPropertiesMap, key) ||
Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hasOwn */ "k"])(appContext.config.globalProperties, key));
}
};
if (true) {
PublicInstanceProxyHandlers.ownKeys = (target) => {
warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +
`The keys will be empty in production mode to avoid performance overhead.`);
return Reflect.ownKeys(target);
};
}
const RuntimeCompiledPublicInstanceProxyHandlers = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])({}, PublicInstanceProxyHandlers, {
get(target, key) {
// fast path for unscopables when using `with` block
if (key === Symbol.unscopables) {
return;
}
return PublicInstanceProxyHandlers.get(target, key, target);
},
has(_, key) {
const has = key[0] !== '_' && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isGloballyWhitelisted */ "p"])(key);
if (( true) && !has && PublicInstanceProxyHandlers.has(_, key)) {
warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);
}
return has;
}
});
// In dev mode, the proxy target exposes the same properties as seen on `this`
// for easier console inspection. In prod mode it will be an empty object so
// these properties definitions can be skipped.
function createRenderContext(instance) {
const target = {};
// expose internal instance for proxy handlers
Object.defineProperty(target, `_`, {
configurable: true,
enumerable: false,
get: () => instance
});
// expose public properties
Object.keys(publicPropertiesMap).forEach(key => {
Object.defineProperty(target, key, {
configurable: true,
enumerable: false,
get: () => publicPropertiesMap[key](instance),
// intercepted by the proxy so no need for implementation,
// but needed to prevent set errors
set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"]
});
});
// expose global properties
const { globalProperties } = instance.appContext.config;
Object.keys(globalProperties).forEach(key => {
Object.defineProperty(target, key, {
configurable: true,
enumerable: false,
get: () => globalProperties[key],
set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"]
});
});
return target;
}
// dev only
function exposePropsOnRenderContext(instance) {
const { ctx, propsOptions: [propsOptions] } = instance;
if (propsOptions) {
Object.keys(propsOptions).forEach(key => {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => instance.props[key],
set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"]
});
});
}
}
// dev only
function exposeSetupStateOnRenderContext(instance) {
const { ctx, setupState } = instance;
Object.keys(Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* toRaw */ "n"])(setupState)).forEach(key => {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => setupState[key],
set: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"]
});
});
}
const emptyAppContext = createAppContext();
let uid$1 = 0;
function createComponentInstance(vnode, parent, suspense) {
const type = vnode.type;
// inherit parent app context - or - if root, adopt from root vnode
const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
const instance = {
uid: uid$1++,
vnode,
type,
parent,
appContext,
root: null,
next: null,
subTree: null,
update: null,
render: null,
proxy: null,
withProxy: null,
effects: null,
provides: parent ? parent.provides : Object.create(appContext.provides),
accessCache: null,
renderCache: [],
// local resovled assets
components: null,
directives: null,
// resolved props and emits options
propsOptions: normalizePropsOptions(type, appContext),
emitsOptions: normalizeEmitsOptions(type, appContext),
// emit
emit: null,
emitted: null,
// state
ctx: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"],
data: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"],
props: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"],
attrs: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"],
slots: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"],
refs: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"],
setupState: _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"],
setupContext: null,
// suspense related
suspense,
asyncDep: null,
asyncResolved: false,
// lifecycle hooks
// not using enums here because it results in computed properties
isMounted: false,
isUnmounted: false,
isDeactivated: false,
bc: null,
c: null,
bm: null,
m: null,
bu: null,
u: null,
um: null,
bum: null,
da: null,
a: null,
rtg: null,
rtc: null,
ec: null
};
if ((true)) {
instance.ctx = createRenderContext(instance);
}
else {}
instance.root = parent ? parent.root : instance;
instance.emit = emit.bind(null, instance);
if (true) {
devtoolsComponentAdded(instance);
}
return instance;
}
let currentInstance = null;
const getCurrentInstance = () => currentInstance || currentRenderingInstance;
const setCurrentInstance = (instance) => {
currentInstance = instance;
};
const isBuiltInTag = /*#__PURE__*/ Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* makeMap */ "D"])('slot,component');
function validateComponentName(name, config) {
const appIsNativeTag = config.isNativeTag || _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NO */ "c"];
if (isBuiltInTag(name) || appIsNativeTag(name)) {
warn('Do not use built-in or reserved HTML elements as component id: ' + name);
}
}
let isInSSRComponentSetup = false;
function setupComponent(instance, isSSR = false) {
isInSSRComponentSetup = isSSR;
const { props, children, shapeFlag } = instance.vnode;
const isStateful = shapeFlag & 4 /* STATEFUL_COMPONENT */;
initProps(instance, props, isStateful, isSSR);
initSlots(instance, children);
const setupResult = isStateful
? setupStatefulComponent(instance, isSSR)
: undefined;
isInSSRComponentSetup = false;
return setupResult;
}
function setupStatefulComponent(instance, isSSR) {
const Component = instance.type;
if ((true)) {
if (Component.name) {
validateComponentName(Component.name, instance.appContext.config);
}
if (Component.components) {
const names = Object.keys(Component.components);
for (let i = 0; i < names.length; i++) {
validateComponentName(names[i], instance.appContext.config);
}
}
if (Component.directives) {
const names = Object.keys(Component.directives);
for (let i = 0; i < names.length; i++) {
validateDirectiveName(names[i]);
}
}
}
// 0. create render proxy property access cache
instance.accessCache = {};
// 1. create public instance / render proxy
// also mark it raw so it's never observed
instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
if ((true)) {
exposePropsOnRenderContext(instance);
}
// 2. call setup()
const { setup } = Component;
if (setup) {
const setupContext = (instance.setupContext =
setup.length > 1 ? createSetupContext(instance) : null);
currentInstance = instance;
Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* pauseTracking */ "f"])();
const setupResult = callWithErrorHandling(setup, instance, 0 /* SETUP_FUNCTION */, [( true) ? Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* shallowReadonly */ "l"])(instance.props) : undefined, setupContext]);
Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* resetTracking */ "j"])();
currentInstance = null;
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isPromise */ "v"])(setupResult)) {
if (isSSR) {
// return the promise so server-renderer can wait on it
return setupResult.then((resolvedResult) => {
handleSetupResult(instance, resolvedResult);
});
}
else {
// async setup returned Promise.
// bail here and wait for re-entry.
instance.asyncDep = setupResult;
}
}
else {
handleSetupResult(instance, setupResult);
}
}
else {
finishComponentSetup(instance);
}
}
function handleSetupResult(instance, setupResult, isSSR) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(setupResult)) {
// setup returned an inline render function
instance.render = setupResult;
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(setupResult)) {
if (( true) && isVNode(setupResult)) {
warn(`setup() should not return VNodes directly - ` +
`return a render function instead.`);
}
// setup returned bindings.
// assuming a render function compiled from template is present.
if (true) {
instance.devtoolsRawSetupState = setupResult;
}
instance.setupState = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* proxyRefs */ "g"])(setupResult);
if ((true)) {
exposeSetupStateOnRenderContext(instance);
}
}
else if (( true) && setupResult !== undefined) {
warn(`setup() should return an object. Received: ${setupResult === null ? 'null' : typeof setupResult}`);
}
finishComponentSetup(instance);
}
let compile;
/**
* For runtime-dom to register the compiler.
* Note the exported method uses any to avoid d.ts relying on the compiler types.
*/
function registerRuntimeCompiler(_compile) {
compile = _compile;
}
function finishComponentSetup(instance, isSSR) {
const Component = instance.type;
// template / render function normalization
if (!instance.render) {
// could be set from setup()
if (compile && Component.template && !Component.render) {
if ((true)) {
startMeasure(instance, `compile`);
}
Component.render = compile(Component.template, {
isCustomElement: instance.appContext.config.isCustomElement,
delimiters: Component.delimiters
});
if ((true)) {
endMeasure(instance, `compile`);
}
}
instance.render = (Component.render || _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"]);
// for runtime-compiled render functions using `with` blocks, the render
// proxy used needs a different `has` handler which is more performant and
// also only allows a whitelist of globals to fallthrough.
if (instance.render._rc) {
instance.withProxy = new Proxy(instance.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
}
}
// support for 2.x options
if (__VUE_OPTIONS_API__) {
currentInstance = instance;
applyOptions(instance, Component);
currentInstance = null;
}
// warn missing template/render
if (( true) && !Component.render && instance.render === _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* NOOP */ "d"]) {
/* istanbul ignore if */
if (!compile && Component.template) {
warn(`Component provided template option but ` +
`runtime compilation is not supported in this build of Vue.` +
( ` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".`
) /* should not happen */);
}
else {
warn(`Component is missing template or render function.`);
}
}
}
const attrHandlers = {
get: (target, key) => {
if ((true)) {
markAttrsAccessed();
}
return target[key];
},
set: () => {
warn(`setupContext.attrs is readonly.`);
return false;
},
deleteProperty: () => {
warn(`setupContext.attrs is readonly.`);
return false;
}
};
function createSetupContext(instance) {
if ((true)) {
// We use getters in dev in case libs like test-utils overwrite instance
// properties (overwrites should not be done in prod)
return Object.freeze({
get attrs() {
return new Proxy(instance.attrs, attrHandlers);
},
get slots() {
return Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* shallowReadonly */ "l"])(instance.slots);
},
get emit() {
return (event, ...args) => instance.emit(event, ...args);
}
});
}
else {}
}
// record effects created during a component's setup() so that they can be
// stopped when the component unmounts
function recordInstanceBoundEffect(effect) {
if (currentInstance) {
(currentInstance.effects || (currentInstance.effects = [])).push(effect);
}
}
const classifyRE = /(?:^|[-_])(\w)/g;
const classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');
/* istanbul ignore next */
function formatComponentName(instance, Component, isRoot = false) {
let name = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(Component)
? Component.displayName || Component.name
: Component.name;
if (!name && Component.__file) {
const match = Component.__file.match(/([^/\\]+)\.vue$/);
if (match) {
name = match[1];
}
}
if (!name && instance && instance.parent) {
// try to infer the name based on reverse resolution
const inferFromRegistry = (registry) => {
for (const key in registry) {
if (registry[key] === Component) {
return key;
}
}
};
name =
inferFromRegistry(instance.components ||
instance.parent.type.components) || inferFromRegistry(instance.appContext.components);
}
return name ? classify(name) : isRoot ? `App` : `Anonymous`;
}
function computed(getterOrOptions) {
const c = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* computed */ "a"])(getterOrOptions);
recordInstanceBoundEffect(c.effect);
return c;
}
// implementation, close to no-op
function defineComponent(options) {
return Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(options) ? { setup: options, name: options.name } : options;
}
function defineAsyncComponent(source) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(source)) {
source = { loader: source };
}
const { loader, loadingComponent: loadingComponent, errorComponent: errorComponent, delay = 200, timeout, // undefined = never times out
suspensible = true, onError: userOnError } = source;
let pendingRequest = null;
let resolvedComp;
let retries = 0;
const retry = () => {
retries++;
pendingRequest = null;
return load();
};
const load = () => {
let thisRequest;
return (pendingRequest ||
(thisRequest = pendingRequest = loader()
.catch(err => {
err = err instanceof Error ? err : new Error(String(err));
if (userOnError) {
return new Promise((resolve, reject) => {
const userRetry = () => resolve(retry());
const userFail = () => reject(err);
userOnError(err, userRetry, userFail, retries + 1);
});
}
else {
throw err;
}
})
.then((comp) => {
if (thisRequest !== pendingRequest && pendingRequest) {
return pendingRequest;
}
if (( true) && !comp) {
warn(`Async component loader resolved to undefined. ` +
`If you are using retry(), make sure to return its return value.`);
}
// interop module default
if (comp &&
(comp.__esModule || comp[Symbol.toStringTag] === 'Module')) {
comp = comp.default;
}
if (( true) && comp && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(comp) && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(comp)) {
throw new Error(`Invalid async component load result: ${comp}`);
}
resolvedComp = comp;
return comp;
})));
};
return defineComponent({
__asyncLoader: load,
name: 'AsyncComponentWrapper',
setup() {
const instance = currentInstance;
// already resolved
if (resolvedComp) {
return () => createInnerComp(resolvedComp, instance);
}
const onError = (err) => {
pendingRequest = null;
handleError(err, instance, 13 /* ASYNC_COMPONENT_LOADER */);
};
// suspense-controlled or SSR.
if (( suspensible && instance.suspense) ||
(false )) {
return load()
.then(comp => {
return () => createInnerComp(comp, instance);
})
.catch(err => {
onError(err);
return () => errorComponent
? createVNode(errorComponent, {
error: err
})
: null;
});
}
const loaded = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* ref */ "i"])(false);
const error = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* ref */ "i"])();
const delayed = Object(_vue_reactivity__WEBPACK_IMPORTED_MODULE_0__[/* ref */ "i"])(!!delay);
if (delay) {
setTimeout(() => {
delayed.value = false;
}, delay);
}
if (timeout != null) {
setTimeout(() => {
if (!loaded.value) {
const err = new Error(`Async component timed out after ${timeout}ms.`);
onError(err);
error.value = err;
}
}, timeout);
}
load()
.then(() => {
loaded.value = true;
})
.catch(err => {
onError(err);
error.value = err;
});
return () => {
if (loaded.value && resolvedComp) {
return createInnerComp(resolvedComp, instance);
}
else if (error.value && errorComponent) {
return createVNode(errorComponent, {
error: error.value
});
}
else if (loadingComponent && !delayed.value) {
return createVNode(loadingComponent);
}
};
}
});
}
function createInnerComp(comp, { vnode: { props, children } }) {
return createVNode(comp, props, children);
}
// Actual implementation
function h(type, propsOrChildren, children) {
const l = arguments.length;
if (l === 2) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(propsOrChildren) && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(propsOrChildren)) {
// single vnode without props
if (isVNode(propsOrChildren)) {
return createVNode(type, null, [propsOrChildren]);
}
// props without children
return createVNode(type, propsOrChildren);
}
else {
// omit props
return createVNode(type, null, propsOrChildren);
}
}
else {
if (l > 3) {
children = Array.prototype.slice.call(arguments, 2);
}
else if (l === 3 && isVNode(children)) {
children = [children];
}
return createVNode(type, propsOrChildren, children);
}
}
const ssrContextKey = Symbol(( true) ? `ssrContext` : undefined);
const useSSRContext = () => {
{
const ctx = inject(ssrContextKey);
if (!ctx) {
warn(`Server rendering context not provided. Make sure to only call ` +
`useSsrContext() conditionally in the server build.`);
}
return ctx;
}
};
/**
* Actual implementation
*/
function renderList(source, renderItem) {
let ret;
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(source) || Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(source)) {
ret = new Array(source.length);
for (let i = 0, l = source.length; i < l; i++) {
ret[i] = renderItem(source[i], i);
}
}
else if (typeof source === 'number') {
ret = new Array(source);
for (let i = 0; i < source; i++) {
ret[i] = renderItem(i + 1, i);
}
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(source)) {
if (source[Symbol.iterator]) {
ret = Array.from(source, renderItem);
}
else {
const keys = Object.keys(source);
ret = new Array(keys.length);
for (let i = 0, l = keys.length; i < l; i++) {
const key = keys[i];
ret[i] = renderItem(source[key], key, i);
}
}
}
else {
ret = [];
}
return ret;
}
/**
* For prefixing keys in v-on="obj" with "on"
* @private
*/
function toHandlers(obj) {
const ret = {};
if (( true) && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(obj)) {
warn(`v-on with no argument expects an object value.`);
return ret;
}
for (const key in obj) {
ret[`on${Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* capitalize */ "f"])(key)}`] = obj[key];
}
return ret;
}
/**
* Compiler runtime helper for creating dynamic slots object
* @private
*/
function createSlots(slots, dynamicSlots) {
for (let i = 0; i < dynamicSlots.length; i++) {
const slot = dynamicSlots[i];
// array of dynamic slot generated by <template v-for="..." #[...]>
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(slot)) {
for (let j = 0; j < slot.length; j++) {
slots[slot[j].name] = slot[j].fn;
}
}
else if (slot) {
// conditional single slot generated by <template v-if="..." #foo>
slots[slot.name] = slot.fn;
}
}
return slots;
}
// Core API ------------------------------------------------------------------
const version = "3.0.0-rc.10";
/**
* SSR utils for \@vue/server-renderer. Only exposed in cjs builds.
* @internal
*/
const ssrUtils = ( null);
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))
/***/ }),
/***/ "./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js":
/*!***********************************************************************!*\
!*** ./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js ***!
\***********************************************************************/
/*! exports provided: customRef, isProxy, isReactive, isReadonly, isRef, markRaw, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, camelize, capitalize, toDisplayString, BaseTransition, Comment, Fragment, KeepAlive, Static, Suspense, Teleport, Text, callWithAsyncErrorHandling, callWithErrorHandling, cloneVNode, computed, createBlock, createCommentVNode, createHydrationRenderer, createRenderer, createSlots, createStaticVNode, createTextVNode, createVNode, defineAsyncComponent, defineComponent, devtools, getCurrentInstance, getTransitionRawChildren, h, handleError, inject, isVNode, mergeProps, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onUnmounted, onUpdated, openBlock, popScopeId, provide, pushScopeId, queuePostFlushCb, registerRuntimeCompiler, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveTransitionHooks, setBlockTracking, setDevtoolsHook, setTransitionHooks, ssrContextKey, ssrUtils, toHandlers, transformVNodeArgs, useSSRContext, useTransitionState, version, warn, watch, watchEffect, withCtx, withDirectives, withScopeId, Transition, TransitionGroup, createApp, createSSRApp, hydrate, render, useCssModule, useCssVars, vModelCheckbox, vModelDynamic, vModelRadio, vModelSelect, vModelText, vShow, withKeys, withModifiers */
/*! exports used: reactive, setDevtoolsHook, warn, watchEffect */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* unused harmony export Transition */
/* unused harmony export TransitionGroup */
/* unused harmony export createApp */
/* unused harmony export createSSRApp */
/* unused harmony export hydrate */
/* unused harmony export render */
/* unused harmony export useCssModule */
/* unused harmony export useCssVars */
/* unused harmony export vModelCheckbox */
/* unused harmony export vModelDynamic */
/* unused harmony export vModelRadio */
/* unused harmony export vModelSelect */
/* unused harmony export vModelText */
/* unused harmony export vShow */
/* unused harmony export withKeys */
/* unused harmony export withModifiers */
/* harmony import */ var _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/runtime-core */ "./node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js");
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__["m"]; });
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "b", function() { return _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__["o"]; });
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "c", function() { return _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__["s"]; });
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "d", function() { return _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__["t"]; });
/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js");
const svgNS = 'http://www.w3.org/2000/svg';
const doc = (typeof document !== 'undefined' ? document : null);
let tempContainer;
let tempSVGContainer;
const nodeOps = {
insert: (child, parent, anchor) => {
parent.insertBefore(child, anchor || null);
},
remove: child => {
const parent = child.parentNode;
if (parent) {
parent.removeChild(child);
}
},
createElement: (tag, isSVG, is) => isSVG
? doc.createElementNS(svgNS, tag)
: doc.createElement(tag, is ? { is } : undefined),
createText: text => doc.createTextNode(text),
createComment: text => doc.createComment(text),
setText: (node, text) => {
node.nodeValue = text;
},
setElementText: (el, text) => {
el.textContent = text;
},
parentNode: node => node.parentNode,
nextSibling: node => node.nextSibling,
querySelector: selector => doc.querySelector(selector),
setScopeId(el, id) {
el.setAttribute(id, '');
},
cloneNode(el) {
return el.cloneNode(true);
},
// __UNSAFE__
// Reason: innerHTML.
// Static content here can only come from compiled templates.
// As long as the user only uses trusted templates, this is safe.
insertStaticContent(content, parent, anchor, isSVG) {
const temp = isSVG
? tempSVGContainer ||
(tempSVGContainer = doc.createElementNS(svgNS, 'svg'))
: tempContainer || (tempContainer = doc.createElement('div'));
temp.innerHTML = content;
const first = temp.firstChild;
let node = first;
let last = node;
while (node) {
last = node;
nodeOps.insert(node, parent, anchor);
node = temp.firstChild;
}
return [first, last];
}
};
// compiler should normalize class + :class bindings on the same element
// into a single binding ['staticClass', dynamic]
function patchClass(el, value, isSVG) {
if (value == null) {
value = '';
}
if (isSVG) {
el.setAttribute('class', value);
}
else {
// directly setting className should be faster than setAttribute in theory
// if this is an element during a transition, take the temporary transition
// classes into account.
const transitionClasses = el._vtc;
if (transitionClasses) {
value = (value
? [value, ...transitionClasses]
: [...transitionClasses]).join(' ');
}
el.className = value;
}
}
function patchStyle(el, prev, next) {
const style = el.style;
if (!next) {
el.removeAttribute('style');
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(next)) {
if (prev !== next) {
style.cssText = next;
}
}
else {
for (const key in next) {
setStyle(style, key, next[key]);
}
if (prev && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(prev)) {
for (const key in prev) {
if (next[key] == null) {
setStyle(style, key, '');
}
}
}
}
}
const importantRE = /\s*!important$/;
function setStyle(style, name, val) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(val)) {
val.forEach(v => setStyle(style, name, v));
}
else {
if (name.startsWith('--')) {
// custom property definition
style.setProperty(name, val);
}
else {
const prefixed = autoPrefix(style, name);
if (importantRE.test(val)) {
// !important
style.setProperty(Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hyphenate */ "l"])(prefixed), val.replace(importantRE, ''), 'important');
}
else {
style[prefixed] = val;
}
}
}
}
const prefixes = ['Webkit', 'Moz', 'ms'];
const prefixCache = {};
function autoPrefix(style, rawName) {
const cached = prefixCache[rawName];
if (cached) {
return cached;
}
let name = Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* camelize */ "d"])(rawName);
if (name !== 'filter' && name in style) {
return (prefixCache[rawName] = name);
}
name = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* capitalize */ "f"])(name);
for (let i = 0; i < prefixes.length; i++) {
const prefixed = prefixes[i] + name;
if (prefixed in style) {
return (prefixCache[rawName] = prefixed);
}
}
return rawName;
}
const xlinkNS = 'http://www.w3.org/1999/xlink';
function patchAttr(el, key, value, isSVG) {
if (isSVG && key.startsWith('xlink:')) {
if (value == null) {
el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
}
else {
el.setAttributeNS(xlinkNS, key, value);
}
}
else {
// note we are only checking boolean attributes that don't have a
// corresponding dom prop of the same name here.
const isBoolean = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isSpecialBooleanAttr */ "y"])(key);
if (value == null || (isBoolean && value === false)) {
el.removeAttribute(key);
}
else {
el.setAttribute(key, isBoolean ? '' : value);
}
}
}
// __UNSAFE__
// functions. The user is responsible for using them with only trusted content.
function patchDOMProp(el, key, value,
// the following args are passed only due to potential innerHTML/textContent
// overriding existing VNodes, in which case the old tree must be properly
// unmounted.
prevChildren, parentComponent, parentSuspense, unmountChildren) {
if (key === 'innerHTML' || key === 'textContent') {
if (prevChildren) {
unmountChildren(prevChildren, parentComponent, parentSuspense);
}
el[key] = value == null ? '' : value;
return;
}
if (key === 'value' && el.tagName !== 'PROGRESS') {
// store value as _value as well since
// non-string values will be stringified.
el._value = value;
const newValue = value == null ? '' : value;
if (el.value !== newValue) {
el.value = newValue;
}
return;
}
if (value === '' && typeof el[key] === 'boolean') {
// e.g. <select multiple> compiles to { multiple: '' }
el[key] = true;
}
else if (value == null && typeof el[key] === 'string') {
// e.g. <div :id="null">
el[key] = '';
el.removeAttribute(key);
}
else {
// some properties perform value validation and throw
try {
el[key] = value;
}
catch (e) {
if ((true)) {
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* warn */ "s"])(`Failed setting prop "${key}" on <${el.tagName.toLowerCase()}>: ` +
`value ${value} is invalid.`, e);
}
}
}
}
// Async edge case fix requires storing an event listener's attach timestamp.
let _getNow = Date.now;
// Determine what event timestamp the browser is using. Annoyingly, the
// timestamp can either be hi-res (relative to page load) or low-res
// (relative to UNIX epoch), so in order to compare time we have to use the
// same timestamp type when saving the flush timestamp.
if (typeof document !== 'undefined' &&
_getNow() > document.createEvent('Event').timeStamp) {
// if the low-res timestamp which is bigger than the event timestamp
// (which is evaluated AFTER) it means the event is using a hi-res timestamp,
// and we need to use the hi-res version for event listeners as well.
_getNow = () => performance.now();
}
// To avoid the overhead of repeatedly calling performance.now(), we cache
// and use the same timestamp for all event listeners attached in the same tick.
let cachedNow = 0;
const p = Promise.resolve();
const reset = () => {
cachedNow = 0;
};
const getNow = () => cachedNow || (p.then(reset), (cachedNow = _getNow()));
function addEventListener(el, event, handler, options) {
el.addEventListener(event, handler, options);
}
function removeEventListener(el, event, handler, options) {
el.removeEventListener(event, handler, options);
}
function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
// vei = vue event invokers
const invokers = el._vei || (el._vei = {});
const existingInvoker = invokers[rawName];
if (nextValue && existingInvoker) {
// patch
existingInvoker.value = nextValue;
}
else {
const [name, options] = parseName(rawName);
if (nextValue) {
// add
const invoker = (invokers[rawName] = createInvoker(nextValue, instance));
addEventListener(el, name, invoker, options);
}
else if (existingInvoker) {
// remove
removeEventListener(el, name, existingInvoker, options);
invokers[rawName] = undefined;
}
}
}
const optionsModifierRE = /(?:Once|Passive|Capture)$/;
function parseName(name) {
let options;
if (optionsModifierRE.test(name)) {
options = {};
let m;
while ((m = name.match(optionsModifierRE))) {
name = name.slice(0, name.length - m[0].length);
options[m[0].toLowerCase()] = true;
}
}
return [name.slice(2).toLowerCase(), options];
}
function createInvoker(initialValue, instance) {
const invoker = (e) => {
// async edge case #6566: inner click event triggers patch, event handler
// attached to outer element during patch, and triggered again. This
// happens because browsers fire microtask ticks between event propagation.
// the solution is simple: we save the timestamp when a handler is attached,
// and the handler would only fire if the event passed to it was fired
// AFTER it was attached.
const timeStamp = e.timeStamp || _getNow();
if (timeStamp >= invoker.attached - 1) {
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* callWithAsyncErrorHandling */ "c"])(patchStopImmediatePropagation(e, invoker.value), instance, 5 /* NATIVE_EVENT_HANDLER */, [e]);
}
};
invoker.value = initialValue;
invoker.attached = getNow();
return invoker;
}
function patchStopImmediatePropagation(e, value) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(value)) {
const originalStop = e.stopImmediatePropagation;
e.stopImmediatePropagation = () => {
originalStop.call(e);
e._stopped = true;
};
return value.map(fn => (e) => !e._stopped && fn(e));
}
else {
return value;
}
}
const nativeOnRE = /^on[a-z]/;
const forcePatchProp = (_, key) => key === 'value';
const patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {
switch (key) {
// special
case 'class':
patchClass(el, nextValue, isSVG);
break;
case 'style':
patchStyle(el, prevValue, nextValue);
break;
default:
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isOn */ "u"])(key)) {
// ignore v-model listeners
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isModelListener */ "s"])(key)) {
patchEvent(el, key, prevValue, nextValue, parentComponent);
}
}
else if (shouldSetAsProp(el, key, nextValue, isSVG)) {
patchDOMProp(el, key, nextValue, prevChildren, parentComponent, parentSuspense, unmountChildren);
}
else {
// special case for <input v-model type="checkbox"> with
// :true-value & :false-value
// store value as dom properties since non-string values will be
// stringified.
if (key === 'true-value') {
el._trueValue = nextValue;
}
else if (key === 'false-value') {
el._falseValue = nextValue;
}
patchAttr(el, key, nextValue, isSVG);
}
break;
}
};
function shouldSetAsProp(el, key, value, isSVG) {
if (isSVG) {
// most keys must be set as attribute on svg elements to work
// ...except innerHTML
if (key === 'innerHTML') {
return true;
}
// or native onclick with function values
if (key in el && nativeOnRE.test(key) && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(value)) {
return true;
}
return false;
}
// spellcheck and draggable are numerated attrs, however their
// corresponding DOM properties are actually booleans - this leads to
// setting it with a string "false" value leading it to be coerced to
// `true`, so we need to always treat them as attributes.
// Note that `contentEditable` doesn't have this problem: its DOM
// property is also enumerated string values.
if (key === 'spellcheck' || key === 'draggable') {
return false;
}
// #1787 form as an attribute must be a string, while it accepts an Element as
// a prop
if (key === 'form' && typeof value === 'string') {
return false;
}
// #1526 <input list> must be set as attribute
if (key === 'list' && el.tagName === 'INPUT') {
return false;
}
// native onclick with string value, must be set as attribute
if (nativeOnRE.test(key) && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(value)) {
return false;
}
return key in el;
}
function useCssModule(name = '$style') {
/* istanbul ignore else */
{
const instance = Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* getCurrentInstance */ "h"])();
if (!instance) {
( true) && Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* warn */ "s"])(`useCssModule must be called inside setup()`);
return _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"];
}
const modules = instance.type.__cssModules;
if (!modules) {
( true) && Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* warn */ "s"])(`Current instance does not have CSS modules injected.`);
return _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"];
}
const mod = modules[name];
if (!mod) {
( true) &&
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* warn */ "s"])(`Current instance does not have CSS module named "${name}".`);
return _vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* EMPTY_OBJ */ "b"];
}
return mod;
}
}
function useCssVars(getter, scoped = false) {
const instance = Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* getCurrentInstance */ "h"])();
/* istanbul ignore next */
if (!instance) {
( true) &&
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* warn */ "s"])(`useCssVars is called without current active component instance.`);
return;
}
const prefix = scoped && instance.type.__scopeId
? `${instance.type.__scopeId.replace(/^data-v-/, '')}-`
: ``;
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* onMounted */ "k"])(() => {
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* watchEffect */ "t"])(() => {
setVarsOnVNode(instance.subTree, getter(instance.proxy), prefix);
});
});
}
function setVarsOnVNode(vnode, vars, prefix) {
if ( vnode.shapeFlag & 128 /* SUSPENSE */) {
const { isResolved, isHydrating, fallbackTree, subTree } = vnode.suspense;
if (isResolved || isHydrating) {
vnode = subTree;
}
else {
vnode.suspense.effects.push(() => {
setVarsOnVNode(subTree, vars, prefix);
});
vnode = fallbackTree;
}
}
// drill down HOCs until it's a non-component vnode
while (vnode.component) {
vnode = vnode.component.subTree;
}
if (vnode.shapeFlag & 1 /* ELEMENT */ && vnode.el) {
const style = vnode.el.style;
for (const key in vars) {
style.setProperty(`--${prefix}${key}`, Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* unref */ "q"])(vars[key]));
}
}
else if (vnode.type === _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* Fragment */ "b"]) {
vnode.children.forEach(c => setVarsOnVNode(c, vars, prefix));
}
}
const TRANSITION = 'transition';
const ANIMATION = 'animation';
// DOM Transition is a higher-order-component based on the platform-agnostic
// base Transition component, with DOM-specific logic.
const Transition = (props, { slots }) => Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* h */ "j"])(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* BaseTransition */ "a"], resolveTransitionProps(props), slots);
Transition.displayName = 'Transition';
const DOMTransitionPropsValidators = {
name: String,
type: String,
css: {
type: Boolean,
default: true
},
duration: [String, Number, Object],
enterFromClass: String,
enterActiveClass: String,
enterToClass: String,
appearFromClass: String,
appearActiveClass: String,
appearToClass: String,
leaveFromClass: String,
leaveActiveClass: String,
leaveToClass: String
};
const TransitionPropsValidators = (Transition.props = /*#__PURE__*/ Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])({}, _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* BaseTransition */ "a"].props, DOMTransitionPropsValidators));
function resolveTransitionProps(rawProps) {
let { name = 'v', type, css = true, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps;
const baseProps = {};
for (const key in rawProps) {
if (!(key in DOMTransitionPropsValidators)) {
baseProps[key] = rawProps[key];
}
}
if (!css) {
return baseProps;
}
const durations = normalizeDuration(duration);
const enterDuration = durations && durations[0];
const leaveDuration = durations && durations[1];
const { onBeforeEnter, onEnter, onEnterCancelled, onLeave, onLeaveCancelled, onBeforeAppear = onBeforeEnter, onAppear = onEnter, onAppearCancelled = onEnterCancelled } = baseProps;
const finishEnter = (el, isAppear, done) => {
removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
done && done();
};
const finishLeave = (el, done) => {
removeTransitionClass(el, leaveToClass);
removeTransitionClass(el, leaveActiveClass);
done && done();
};
const makeEnterHook = (isAppear) => {
return (el, done) => {
const hook = isAppear ? onAppear : onEnter;
const resolve = () => finishEnter(el, isAppear, done);
hook && hook(el, resolve);
nextFrame(() => {
removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
addTransitionClass(el, isAppear ? appearToClass : enterToClass);
if (!(hook && hook.length > 1)) {
if (enterDuration) {
setTimeout(resolve, enterDuration);
}
else {
whenTransitionEnds(el, type, resolve);
}
}
});
};
};
return Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])(baseProps, {
onBeforeEnter(el) {
onBeforeEnter && onBeforeEnter(el);
addTransitionClass(el, enterActiveClass);
addTransitionClass(el, enterFromClass);
},
onBeforeAppear(el) {
onBeforeAppear && onBeforeAppear(el);
addTransitionClass(el, appearActiveClass);
addTransitionClass(el, appearFromClass);
},
onEnter: makeEnterHook(false),
onAppear: makeEnterHook(true),
onLeave(el, done) {
const resolve = () => finishLeave(el, done);
addTransitionClass(el, leaveActiveClass);
addTransitionClass(el, leaveFromClass);
nextFrame(() => {
removeTransitionClass(el, leaveFromClass);
addTransitionClass(el, leaveToClass);
if (!(onLeave && onLeave.length > 1)) {
if (leaveDuration) {
setTimeout(resolve, leaveDuration);
}
else {
whenTransitionEnds(el, type, resolve);
}
}
});
onLeave && onLeave(el, resolve);
},
onEnterCancelled(el) {
finishEnter(el, false);
onEnterCancelled && onEnterCancelled(el);
},
onAppearCancelled(el) {
finishEnter(el, true);
onAppearCancelled && onAppearCancelled(el);
},
onLeaveCancelled(el) {
finishLeave(el);
onLeaveCancelled && onLeaveCancelled(el);
}
});
}
function normalizeDuration(duration) {
if (duration == null) {
return null;
}
else if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isObject */ "t"])(duration)) {
return [NumberOf(duration.enter), NumberOf(duration.leave)];
}
else {
const n = NumberOf(duration);
return [n, n];
}
}
function NumberOf(val) {
const res = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* toNumber */ "H"])(val);
if ((true))
validateDuration(res);
return res;
}
function validateDuration(val) {
if (typeof val !== 'number') {
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* warn */ "s"])(`<transition> explicit duration is not a valid number - ` +
`got ${JSON.stringify(val)}.`);
}
else if (isNaN(val)) {
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* warn */ "s"])(`<transition> explicit duration is NaN - ` +
'the duration expression might be incorrect.');
}
}
function addTransitionClass(el, cls) {
cls.split(/\s+/).forEach(c => c && el.classList.add(c));
(el._vtc ||
(el._vtc = new Set())).add(cls);
}
function removeTransitionClass(el, cls) {
cls.split(/\s+/).forEach(c => c && el.classList.remove(c));
const { _vtc } = el;
if (_vtc) {
_vtc.delete(cls);
if (!_vtc.size) {
el._vtc = undefined;
}
}
}
function nextFrame(cb) {
requestAnimationFrame(() => {
requestAnimationFrame(cb);
});
}
function whenTransitionEnds(el, expectedType, cb) {
const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
if (!type) {
return cb();
}
const endEvent = type + 'end';
let ended = 0;
const end = () => {
el.removeEventListener(endEvent, onEnd);
cb();
};
const onEnd = (e) => {
if (e.target === el) {
if (++ended >= propCount) {
end();
}
}
};
setTimeout(() => {
if (ended < propCount) {
end();
}
}, timeout + 1);
el.addEventListener(endEvent, onEnd);
}
function getTransitionInfo(el, expectedType) {
const styles = window.getComputedStyle(el);
// JSDOM may return undefined for transition properties
const getStyleProperties = (key) => (styles[key] || '').split(', ');
const transitionDelays = getStyleProperties(TRANSITION + 'Delay');
const transitionDurations = getStyleProperties(TRANSITION + 'Duration');
const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
const animationDelays = getStyleProperties(ANIMATION + 'Delay');
const animationDurations = getStyleProperties(ANIMATION + 'Duration');
const animationTimeout = getTimeout(animationDelays, animationDurations);
let type = null;
let timeout = 0;
let propCount = 0;
/* istanbul ignore if */
if (expectedType === TRANSITION) {
if (transitionTimeout > 0) {
type = TRANSITION;
timeout = transitionTimeout;
propCount = transitionDurations.length;
}
}
else if (expectedType === ANIMATION) {
if (animationTimeout > 0) {
type = ANIMATION;
timeout = animationTimeout;
propCount = animationDurations.length;
}
}
else {
timeout = Math.max(transitionTimeout, animationTimeout);
type =
timeout > 0
? transitionTimeout > animationTimeout
? TRANSITION
: ANIMATION
: null;
propCount = type
? type === TRANSITION
? transitionDurations.length
: animationDurations.length
: 0;
}
const hasTransform = type === TRANSITION &&
/\b(transform|all)(,|$)/.test(styles[TRANSITION + 'Property']);
return {
type,
timeout,
propCount,
hasTransform
};
}
function getTimeout(delays, durations) {
while (delays.length < durations.length) {
delays = delays.concat(delays);
}
return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
}
// Old versions of Chromium (below 61.0.3163.100) formats floating pointer
// numbers in a locale-dependent way, using a comma instead of a dot.
// If comma is not replaced with a dot, the input will be rounded down
// (i.e. acting as a floor function) causing unexpected behaviors
function toMs(s) {
return Number(s.slice(0, -1).replace(',', '.')) * 1000;
}
function toRaw(observed) {
return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
}
const positionMap = new WeakMap();
const newPositionMap = new WeakMap();
const TransitionGroupImpl = {
name: 'TransitionGroup',
props: /*#__PURE__*/ Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])({}, TransitionPropsValidators, {
tag: String,
moveClass: String
}),
setup(props, { slots }) {
const instance = Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* getCurrentInstance */ "h"])();
const state = Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* useTransitionState */ "r"])();
let prevChildren;
let children;
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* onUpdated */ "l"])(() => {
// children is guaranteed to exist after initial render
if (!prevChildren.length) {
return;
}
const moveClass = props.moveClass || `${props.name || 'v'}-move`;
if (!hasCSSTransform(prevChildren[0].el, instance.vnode.el, moveClass)) {
return;
}
// we divide the work into three loops to avoid mixing DOM reads and writes
// in each iteration - which helps prevent layout thrashing.
prevChildren.forEach(callPendingCbs);
prevChildren.forEach(recordPosition);
const movedChildren = prevChildren.filter(applyTranslation);
// force reflow to put everything in position
forceReflow();
movedChildren.forEach(c => {
const el = c.el;
const style = el.style;
addTransitionClass(el, moveClass);
style.transform = style.webkitTransform = style.transitionDuration = '';
const cb = (el._moveCb = (e) => {
if (e && e.target !== el) {
return;
}
if (!e || /transform$/.test(e.propertyName)) {
el.removeEventListener('transitionend', cb);
el._moveCb = null;
removeTransitionClass(el, moveClass);
}
});
el.addEventListener('transitionend', cb);
});
});
return () => {
const rawProps = toRaw(props);
const cssTransitionProps = resolveTransitionProps(rawProps);
const tag = rawProps.tag || _vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* Fragment */ "b"];
prevChildren = children;
children = slots.default ? Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* getTransitionRawChildren */ "i"])(slots.default()) : [];
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (child.key != null) {
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* setTransitionHooks */ "p"])(child, Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* resolveTransitionHooks */ "n"])(child, cssTransitionProps, state, instance));
}
else if ((true)) {
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* warn */ "s"])(`<TransitionGroup> children must be keyed.`);
}
}
if (prevChildren) {
for (let i = 0; i < prevChildren.length; i++) {
const child = prevChildren[i];
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* setTransitionHooks */ "p"])(child, Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* resolveTransitionHooks */ "n"])(child, cssTransitionProps, state, instance));
positionMap.set(child, child.el.getBoundingClientRect());
}
}
return Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* createVNode */ "g"])(tag, null, children);
};
}
};
const TransitionGroup = TransitionGroupImpl;
function callPendingCbs(c) {
const el = c.el;
if (el._moveCb) {
el._moveCb();
}
if (el._enterCb) {
el._enterCb();
}
}
function recordPosition(c) {
newPositionMap.set(c, c.el.getBoundingClientRect());
}
function applyTranslation(c) {
const oldPos = positionMap.get(c);
const newPos = newPositionMap.get(c);
const dx = oldPos.left - newPos.left;
const dy = oldPos.top - newPos.top;
if (dx || dy) {
const s = c.el.style;
s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
s.transitionDuration = '0s';
return c;
}
}
// this is put in a dedicated function to avoid the line from being treeshaken
function forceReflow() {
return document.body.offsetHeight;
}
function hasCSSTransform(el, root, moveClass) {
// Detect whether an element with the move class applied has
// CSS transitions. Since the element may be inside an entering
// transition at this very moment, we make a clone of it and remove
// all other transition classes applied to ensure only the move class
// is applied.
const clone = el.cloneNode();
if (el._vtc) {
el._vtc.forEach(cls => {
cls.split(/\s+/).forEach(c => c && clone.classList.remove(c));
});
}
moveClass.split(/\s+/).forEach(c => c && clone.classList.add(c));
clone.style.display = 'none';
const container = (root.nodeType === 1
? root
: root.parentNode);
container.appendChild(clone);
const { hasTransform } = getTransitionInfo(clone);
container.removeChild(clone);
return hasTransform;
}
const getModelAssigner = (vnode) => {
const fn = vnode.props['onUpdate:modelValue'];
return Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(fn) ? value => Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* invokeArrayFns */ "m"])(fn, value) : fn;
};
function onCompositionStart(e) {
e.target.composing = true;
}
function onCompositionEnd(e) {
const target = e.target;
if (target.composing) {
target.composing = false;
trigger(target, 'input');
}
}
function trigger(el, type) {
const e = document.createEvent('HTMLEvents');
e.initEvent(type, true, true);
el.dispatchEvent(e);
}
// We are exporting the v-model runtime directly as vnode hooks so that it can
// be tree-shaken in case v-model is never used.
const vModelText = {
created(el, { value, modifiers: { lazy, trim, number } }, vnode) {
el.value = value == null ? '' : value;
el._assign = getModelAssigner(vnode);
const castToNumber = number || el.type === 'number';
addEventListener(el, lazy ? 'change' : 'input', e => {
if (e.target.composing)
return;
let domValue = el.value;
if (trim) {
domValue = domValue.trim();
}
else if (castToNumber) {
domValue = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* toNumber */ "H"])(domValue);
}
el._assign(domValue);
});
if (trim) {
addEventListener(el, 'change', () => {
el.value = el.value.trim();
});
}
if (!lazy) {
addEventListener(el, 'compositionstart', onCompositionStart);
addEventListener(el, 'compositionend', onCompositionEnd);
// Safari < 10.2 & UIWebView doesn't fire compositionend when
// switching focus before confirming composition choice
// this also fixes the issue where some browsers e.g. iOS Chrome
// fires "change" instead of "input" on autocomplete.
addEventListener(el, 'change', onCompositionEnd);
}
},
beforeUpdate(el, { value, modifiers: { trim, number } }, vnode) {
el._assign = getModelAssigner(vnode);
if (document.activeElement === el) {
if (trim && el.value.trim() === value) {
return;
}
if ((number || el.type === 'number') && Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* toNumber */ "H"])(el.value) === value) {
return;
}
}
const newValue = value == null ? '' : value;
if (el.value !== newValue) {
el.value = newValue;
}
}
};
const vModelCheckbox = {
created(el, binding, vnode) {
setChecked(el, binding, vnode);
el._assign = getModelAssigner(vnode);
addEventListener(el, 'change', () => {
const modelValue = el._modelValue;
const elementValue = getValue(el);
const checked = el.checked;
const assign = el._assign;
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(modelValue)) {
const index = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* looseIndexOf */ "C"])(modelValue, elementValue);
const found = index !== -1;
if (checked && !found) {
assign(modelValue.concat(elementValue));
}
else if (!checked && found) {
const filtered = [...modelValue];
filtered.splice(index, 1);
assign(filtered);
}
}
else {
assign(getCheckboxValue(el, checked));
}
});
},
beforeUpdate(el, binding, vnode) {
el._assign = getModelAssigner(vnode);
setChecked(el, binding, vnode);
}
};
function setChecked(el, { value, oldValue }, vnode) {
el._modelValue = value;
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(value)) {
el.checked = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* looseIndexOf */ "C"])(value, vnode.props.value) > -1;
}
else if (value !== oldValue) {
el.checked = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* looseEqual */ "B"])(value, getCheckboxValue(el, true));
}
}
const vModelRadio = {
created(el, { value }, vnode) {
el.checked = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* looseEqual */ "B"])(value, vnode.props.value);
el._assign = getModelAssigner(vnode);
addEventListener(el, 'change', () => {
el._assign(getValue(el));
});
},
beforeUpdate(el, { value, oldValue }, vnode) {
el._assign = getModelAssigner(vnode);
if (value !== oldValue) {
el.checked = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* looseEqual */ "B"])(value, vnode.props.value);
}
}
};
const vModelSelect = {
created(el, binding, vnode) {
addEventListener(el, 'change', () => {
const selectedVal = Array.prototype.filter
.call(el.options, (o) => o.selected)
.map(getValue);
el._assign(el.multiple ? selectedVal : selectedVal[0]);
});
el._assign = getModelAssigner(vnode);
},
// set value in mounted & updated because <select> relies on its children
// <option>s.
mounted(el, { value }) {
setSelected(el, value);
},
beforeUpdate(el, _binding, vnode) {
el._assign = getModelAssigner(vnode);
},
updated(el, { value }) {
setSelected(el, value);
}
};
function setSelected(el, value) {
const isMultiple = el.multiple;
if (isMultiple && !Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isArray */ "n"])(value)) {
( true) &&
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* warn */ "s"])(`<select multiple v-model> expects an Array value for its binding, ` +
`but got ${Object.prototype.toString.call(value).slice(8, -1)}.`);
return;
}
for (let i = 0, l = el.options.length; i < l; i++) {
const option = el.options[i];
const optionValue = getValue(option);
if (isMultiple) {
option.selected = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* looseIndexOf */ "C"])(value, optionValue) > -1;
}
else {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* looseEqual */ "B"])(getValue(option), value)) {
el.selectedIndex = i;
return;
}
}
}
if (!isMultiple) {
el.selectedIndex = -1;
}
}
// retrieve raw value set via :value bindings
function getValue(el) {
return '_value' in el ? el._value : el.value;
}
// retrieve raw value for true-value and false-value set via :true-value or :false-value bindings
function getCheckboxValue(el, checked) {
const key = checked ? '_trueValue' : '_falseValue';
return key in el ? el[key] : checked;
}
const vModelDynamic = {
created(el, binding, vnode) {
callModelHook(el, binding, vnode, null, 'created');
},
mounted(el, binding, vnode) {
callModelHook(el, binding, vnode, null, 'mounted');
},
beforeUpdate(el, binding, vnode, prevVNode) {
callModelHook(el, binding, vnode, prevVNode, 'beforeUpdate');
},
updated(el, binding, vnode, prevVNode) {
callModelHook(el, binding, vnode, prevVNode, 'updated');
}
};
function callModelHook(el, binding, vnode, prevVNode, hook) {
let modelToUse;
switch (el.tagName) {
case 'SELECT':
modelToUse = vModelSelect;
break;
case 'TEXTAREA':
modelToUse = vModelText;
break;
default:
switch (vnode.props && vnode.props.type) {
case 'checkbox':
modelToUse = vModelCheckbox;
break;
case 'radio':
modelToUse = vModelRadio;
break;
default:
modelToUse = vModelText;
}
}
const fn = modelToUse[hook];
fn && fn(el, binding, vnode, prevVNode);
}
const systemModifiers = ['ctrl', 'shift', 'alt', 'meta'];
const modifierGuards = {
stop: e => e.stopPropagation(),
prevent: e => e.preventDefault(),
self: e => e.target !== e.currentTarget,
ctrl: e => !e.ctrlKey,
shift: e => !e.shiftKey,
alt: e => !e.altKey,
meta: e => !e.metaKey,
left: e => 'button' in e && e.button !== 0,
middle: e => 'button' in e && e.button !== 1,
right: e => 'button' in e && e.button !== 2,
exact: (e, modifiers) => systemModifiers.some(m => e[`${m}Key`] && !modifiers.includes(m))
};
/**
* @private
*/
const withModifiers = (fn, modifiers) => {
return (event, ...args) => {
for (let i = 0; i < modifiers.length; i++) {
const guard = modifierGuards[modifiers[i]];
if (guard && guard(event, modifiers))
return;
}
return fn(event, ...args);
};
};
// Kept for 2.x compat.
// Note: IE11 compat for `spacebar` and `del` is removed for now.
const keyNames = {
esc: 'escape',
space: ' ',
up: 'arrow-up',
left: 'arrow-left',
right: 'arrow-right',
down: 'arrow-down',
delete: 'backspace'
};
/**
* @private
*/
const withKeys = (fn, modifiers) => {
return (event) => {
if (!('key' in event))
return;
const eventKey = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* hyphenate */ "l"])(event.key);
if (
// None of the provided key modifiers match the current event key
!modifiers.some(k => k === eventKey || keyNames[k] === eventKey)) {
return;
}
return fn(event);
};
};
const vShow = {
beforeMount(el, { value }, { transition }) {
el._vod = el.style.display === 'none' ? '' : el.style.display;
if (transition && value) {
transition.beforeEnter(el);
}
else {
setDisplay(el, value);
}
},
mounted(el, { value }, { transition }) {
if (transition && value) {
transition.enter(el);
}
},
updated(el, { value, oldValue }, { transition }) {
if (!value === !oldValue)
return;
if (transition) {
if (value) {
transition.beforeEnter(el);
setDisplay(el, true);
transition.enter(el);
}
else {
transition.leave(el, () => {
setDisplay(el, false);
});
}
}
else {
setDisplay(el, value);
}
},
beforeUnmount(el, { value }) {
setDisplay(el, value);
}
};
function setDisplay(el, value) {
el.style.display = value ? el._vod : 'none';
}
const rendererOptions = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* extend */ "h"])({ patchProp, forcePatchProp }, nodeOps);
// lazy create the renderer - this makes core renderer logic tree-shakable
// in case the user only imports reactivity utilities from Vue.
let renderer;
let enabledHydration = false;
function ensureRenderer() {
return renderer || (renderer = Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* createRenderer */ "f"])(rendererOptions));
}
function ensureHydrationRenderer() {
renderer = enabledHydration
? renderer
: Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* createHydrationRenderer */ "e"])(rendererOptions);
enabledHydration = true;
return renderer;
}
// use explicit type casts here to avoid import() calls in rolled-up d.ts
const render = ((...args) => {
ensureRenderer().render(...args);
});
const hydrate = ((...args) => {
ensureHydrationRenderer().hydrate(...args);
});
const createApp = ((...args) => {
const app = ensureRenderer().createApp(...args);
if ((true)) {
injectNativeTagCheck(app);
}
const { mount } = app;
app.mount = (containerOrSelector) => {
const container = normalizeContainer(containerOrSelector);
if (!container)
return;
const component = app._component;
if (!Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isFunction */ "o"])(component) && !component.render && !component.template) {
component.template = container.innerHTML;
}
// clear content before mounting
container.innerHTML = '';
const proxy = mount(container);
container.removeAttribute('v-cloak');
container.setAttribute('data-v-app', '');
return proxy;
};
return app;
});
const createSSRApp = ((...args) => {
const app = ensureHydrationRenderer().createApp(...args);
if ((true)) {
injectNativeTagCheck(app);
}
const { mount } = app;
app.mount = (containerOrSelector) => {
const container = normalizeContainer(containerOrSelector);
if (container) {
return mount(container, true);
}
};
return app;
});
function injectNativeTagCheck(app) {
// Inject `isNativeTag`
// this is used for component name validation (dev only)
Object.defineProperty(app.config, 'isNativeTag', {
value: (tag) => Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isHTMLTag */ "q"])(tag) || Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isSVGTag */ "x"])(tag),
writable: false
});
}
function normalizeContainer(container) {
if (Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* isString */ "z"])(container)) {
const res = document.querySelector(container);
if (( true) && !res) {
Object(_vue_runtime_core__WEBPACK_IMPORTED_MODULE_0__[/* warn */ "s"])(`Failed to mount app: mount target selector returned null.`);
}
return res;
}
return container;
}
/***/ }),
/***/ "./node_modules/@vue/shared/dist/shared.esm-bundler.js":
/*!*************************************************************!*\
!*** ./node_modules/@vue/shared/dist/shared.esm-bundler.js ***!
\*************************************************************/
/*! exports provided: EMPTY_ARR, EMPTY_OBJ, NO, NOOP, PatchFlagNames, babelParserDefaultPlugins, camelize, capitalize, def, escapeHtml, escapeHtmlComment, extend, generateCodeFrame, getGlobalThis, hasChanged, hasOwn, hyphenate, invokeArrayFns, isArray, isBooleanAttr, isDate, isFunction, isGloballyWhitelisted, isHTMLTag, isIntegerKey, isKnownAttr, isModelListener, isNoUnitNumericStyleProp, isObject, isOn, isPlainObject, isPromise, isReservedProp, isSSRSafeAttrName, isSVGTag, isSpecialBooleanAttr, isString, isSymbol, isVoidTag, looseEqual, looseIndexOf, makeMap, normalizeClass, normalizeStyle, objectToString, parseStringStyle, propsToAttrMap, remove, stringifyStyle, toDisplayString, toNumber, toRawType, toTypeString */
/*! exports used: EMPTY_ARR, EMPTY_OBJ, NO, NOOP, camelize, capitalize, def, extend, getGlobalThis, hasChanged, hasOwn, hyphenate, invokeArrayFns, isArray, isFunction, isGloballyWhitelisted, isHTMLTag, isIntegerKey, isModelListener, isObject, isOn, isPromise, isReservedProp, isSVGTag, isSpecialBooleanAttr, isString, isSymbol, looseEqual, looseIndexOf, makeMap, normalizeClass, normalizeStyle, remove, toNumber, toRawType */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return EMPTY_ARR; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return EMPTY_OBJ; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return NO; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return NOOP; });
/* unused harmony export PatchFlagNames */
/* unused harmony export babelParserDefaultPlugins */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return camelize; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return capitalize; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return def; });
/* unused harmony export escapeHtml */
/* unused harmony export escapeHtmlComment */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return extend; });
/* unused harmony export generateCodeFrame */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return getGlobalThis; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return hasChanged; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return hasOwn; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "l", function() { return hyphenate; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "m", function() { return invokeArrayFns; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "n", function() { return isArray; });
/* unused harmony export isBooleanAttr */
/* unused harmony export isDate */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "o", function() { return isFunction; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "p", function() { return isGloballyWhitelisted; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "q", function() { return isHTMLTag; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "r", function() { return isIntegerKey; });
/* unused harmony export isKnownAttr */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "s", function() { return isModelListener; });
/* unused harmony export isNoUnitNumericStyleProp */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "t", function() { return isObject; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "u", function() { return isOn; });
/* unused harmony export isPlainObject */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "v", function() { return isPromise; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "w", function() { return isReservedProp; });
/* unused harmony export isSSRSafeAttrName */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "x", function() { return isSVGTag; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "y", function() { return isSpecialBooleanAttr; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "z", function() { return isString; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "A", function() { return isSymbol; });
/* unused harmony export isVoidTag */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "B", function() { return looseEqual; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "C", function() { return looseIndexOf; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "D", function() { return makeMap; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "E", function() { return normalizeClass; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "F", function() { return normalizeStyle; });
/* unused harmony export objectToString */
/* unused harmony export parseStringStyle */
/* unused harmony export propsToAttrMap */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "G", function() { return remove; });
/* unused harmony export stringifyStyle */
/* unused harmony export toDisplayString */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "H", function() { return toNumber; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "I", function() { return toRawType; });
/* unused harmony export toTypeString */
/**
* Make a map and return a function for checking if a key
* is in that map.
* IMPORTANT: all calls of this function must be prefixed with
* \/\*#\_\_PURE\_\_\*\/
* So that rollup can tree-shake them if necessary.
*/
function makeMap(str, expectsLowerCase) {
const map = Object.create(null);
const list = str.split(',');
for (let i = 0; i < list.length; i++) {
map[list[i]] = true;
}
return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
}
// Patch flags are optimization hints generated by the compiler.
// when a block with dynamicChildren is encountered during diff, the algorithm
// enters "optimized mode". In this mode, we know that the vdom is produced by
// a render function generated by the compiler, so the algorithm only needs to
// handle updates explicitly marked by these patch flags.
// dev only flag -> name mapping
const PatchFlagNames = {
[1 /* TEXT */]: `TEXT`,
[2 /* CLASS */]: `CLASS`,
[4 /* STYLE */]: `STYLE`,
[8 /* PROPS */]: `PROPS`,
[16 /* FULL_PROPS */]: `FULL_PROPS`,
[32 /* HYDRATE_EVENTS */]: `HYDRATE_EVENTS`,
[64 /* STABLE_FRAGMENT */]: `STABLE_FRAGMENT`,
[128 /* KEYED_FRAGMENT */]: `KEYED_FRAGMENT`,
[256 /* UNKEYED_FRAGMENT */]: `UNKEYED_FRAGMENT`,
[1024 /* DYNAMIC_SLOTS */]: `DYNAMIC_SLOTS`,
[512 /* NEED_PATCH */]: `NEED_PATCH`,
[-1 /* HOISTED */]: `HOISTED`,
[-2 /* BAIL */]: `BAIL`
};
const GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' +
'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' +
'Object,Boolean,String,RegExp,Map,Set,JSON,Intl';
const isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED);
const range = 2;
function generateCodeFrame(source, start = 0, end = source.length) {
const lines = source.split(/\r?\n/);
let count = 0;
const res = [];
for (let i = 0; i < lines.length; i++) {
count += lines[i].length + 1;
if (count >= start) {
for (let j = i - range; j <= i + range || end > count; j++) {
if (j < 0 || j >= lines.length)
continue;
const line = j + 1;
res.push(`${line}${' '.repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`);
const lineLength = lines[j].length;
if (j === i) {
// push underline
const pad = start - (count - lineLength) + 1;
const length = Math.max(1, end > count ? lineLength - pad : end - start);
res.push(` | ` + ' '.repeat(pad) + '^'.repeat(length));
}
else if (j > i) {
if (end > count) {
const length = Math.max(Math.min(end - count, lineLength), 1);
res.push(` | ` + '^'.repeat(length));
}
count += lineLength + 1;
}
}
break;
}
}
return res.join('\n');
}
/**
* On the client we only need to offer special cases for boolean attributes that
* have different names from their corresponding dom properties:
* - itemscope -> N/A
* - allowfullscreen -> allowFullscreen
* - formnovalidate -> formNoValidate
* - ismap -> isMap
* - nomodule -> noModule
* - novalidate -> noValidate
* - readonly -> readOnly
*/
const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
const isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs);
/**
* The full list is needed during SSR to produce the correct initial markup.
*/
const isBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs +
`,async,autofocus,autoplay,controls,default,defer,disabled,hidden,` +
`loop,open,required,reversed,scoped,seamless,` +
`checked,muted,multiple,selected`);
const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
const attrValidationCache = {};
function isSSRSafeAttrName(name) {
if (attrValidationCache.hasOwnProperty(name)) {
return attrValidationCache[name];
}
const isUnsafe = unsafeAttrCharRE.test(name);
if (isUnsafe) {
console.error(`unsafe attribute name: ${name}`);
}
return (attrValidationCache[name] = !isUnsafe);
}
const propsToAttrMap = {
acceptCharset: 'accept-charset',
className: 'class',
htmlFor: 'for',
httpEquiv: 'http-equiv'
};
/**
* CSS properties that accept plain numbers
*/
const isNoUnitNumericStyleProp = /*#__PURE__*/ makeMap(`animation-iteration-count,border-image-outset,border-image-slice,` +
`border-image-width,box-flex,box-flex-group,box-ordinal-group,column-count,` +
`columns,flex,flex-grow,flex-positive,flex-shrink,flex-negative,flex-order,` +
`grid-row,grid-row-end,grid-row-span,grid-row-start,grid-column,` +
`grid-column-end,grid-column-span,grid-column-start,font-weight,line-clamp,` +
`line-height,opacity,order,orphans,tab-size,widows,z-index,zoom,` +
// SVG
`fill-opacity,flood-opacity,stop-opacity,stroke-dasharray,stroke-dashoffset,` +
`stroke-miterlimit,stroke-opacity,stroke-width`);
/**
* Known attributes, this is used for stringification of runtime static nodes
* so that we don't stringify bindings that cannot be set from HTML.
* Don't also forget to allow `data-*` and `aria-*`!
* Generated from https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes
*/
const isKnownAttr = /*#__PURE__*/ makeMap(`accept,accept-charset,accesskey,action,align,allow,alt,async,` +
`autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,` +
`border,buffered,capture,challenge,charset,checked,cite,class,code,` +
`codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,` +
`coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,` +
`disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,` +
`formaction,formenctype,formmethod,formnovalidate,formtarget,headers,` +
`height,hidden,high,href,hreflang,http-equiv,icon,id,importance,integrity,` +
`ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,` +
`manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,` +
`open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,` +
`referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,` +
`selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,` +
`start,step,style,summary,tabindex,target,title,translate,type,usemap,` +
`value,width,wrap`);
function normalizeStyle(value) {
if (isArray(value)) {
const res = {};
for (let i = 0; i < value.length; i++) {
const item = value[i];
const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item);
if (normalized) {
for (const key in normalized) {
res[key] = normalized[key];
}
}
}
return res;
}
else if (isObject(value)) {
return value;
}
}
const listDelimiterRE = /;(?![^(]*\))/g;
const propertyDelimiterRE = /:(.+)/;
function parseStringStyle(cssText) {
const ret = {};
cssText.split(listDelimiterRE).forEach(item => {
if (item) {
const tmp = item.split(propertyDelimiterRE);
tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
}
});
return ret;
}
function stringifyStyle(styles) {
let ret = '';
if (!styles) {
return ret;
}
for (const key in styles) {
const value = styles[key];
const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
if (isString(value) ||
(typeof value === 'number' && isNoUnitNumericStyleProp(normalizedKey))) {
// only render valid values
ret += `${normalizedKey}:${value};`;
}
}
return ret;
}
function normalizeClass(value) {
let res = '';
if (isString(value)) {
res = value;
}
else if (isArray(value)) {
for (let i = 0; i < value.length; i++) {
res += normalizeClass(value[i]) + ' ';
}
}
else if (isObject(value)) {
for (const name in value) {
if (value[name]) {
res += name + ' ';
}
}
}
return res.trim();
}
// These tag configs are shared between compiler-dom and runtime-dom, so they
// https://developer.mozilla.org/en-US/docs/Web/HTML/Element
const HTML_TAGS = '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,' +
'summary,template,blockquote,iframe,tfoot';
// https://developer.mozilla.org/en-US/docs/Web/SVG/Element
const SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' +
'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' +
'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' +
'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' +
'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' +
'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' +
'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' +
'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' +
'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +
'text,textPath,title,tspan,unknown,use,view';
const VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr';
const isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS);
const isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS);
const isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS);
const escapeRE = /["'&<>]/;
function escapeHtml(string) {
const str = '' + string;
const match = escapeRE.exec(str);
if (!match) {
return str;
}
let html = '';
let escaped;
let index;
let lastIndex = 0;
for (index = match.index; index < str.length; index++) {
switch (str.charCodeAt(index)) {
case 34: // "
escaped = '"';
break;
case 38: // &
escaped = '&';
break;
case 39: // '
escaped = ''';
break;
case 60: // <
escaped = '<';
break;
case 62: // >
escaped = '>';
break;
default:
continue;
}
if (lastIndex !== index) {
html += str.substring(lastIndex, index);
}
lastIndex = index + 1;
html += escaped;
}
return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
}
// https://www.w3.org/TR/html52/syntax.html#comments
const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
function escapeHtmlComment(src) {
return src.replace(commentStripRE, '');
}
function looseCompareArrays(a, b) {
if (a.length !== b.length)
return false;
let equal = true;
for (let i = 0; equal && i < a.length; i++) {
equal = looseEqual(a[i], b[i]);
}
return equal;
}
function looseEqual(a, b) {
if (a === b)
return true;
let aValidType = isDate(a);
let bValidType = isDate(b);
if (aValidType || bValidType) {
return aValidType && bValidType ? a.getTime() === b.getTime() : false;
}
aValidType = isArray(a);
bValidType = isArray(b);
if (aValidType || bValidType) {
return aValidType && bValidType ? looseCompareArrays(a, b) : false;
}
aValidType = isObject(a);
bValidType = isObject(b);
if (aValidType || bValidType) {
/* istanbul ignore if: this if will probably never be called */
if (!aValidType || !bValidType) {
return false;
}
const aKeysCount = Object.keys(a).length;
const bKeysCount = Object.keys(b).length;
if (aKeysCount !== bKeysCount) {
return false;
}
for (const key in a) {
const aHasKey = a.hasOwnProperty(key);
const bHasKey = b.hasOwnProperty(key);
if ((aHasKey && !bHasKey) ||
(!aHasKey && bHasKey) ||
!looseEqual(a[key], b[key])) {
return false;
}
}
}
return String(a) === String(b);
}
function looseIndexOf(arr, val) {
return arr.findIndex(item => looseEqual(item, val));
}
/**
* For converting {{ interpolation }} values to displayed strings.
* @private
*/
const toDisplayString = (val) => {
return val == null
? ''
: isObject(val)
? JSON.stringify(val, replacer, 2)
: String(val);
};
const replacer = (_key, val) => {
if (val instanceof Map) {
return {
[`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => {
entries[`${key} =>`] = val;
return entries;
}, {})
};
}
else if (val instanceof Set) {
return {
[`Set(${val.size})`]: [...val.values()]
};
}
else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
return String(val);
}
return val;
};
/**
* List of @babel/parser plugins that are used for template expression
* transforms and SFC script transforms. By default we enable proposals slated
* for ES2020. This will need to be updated as the spec moves forward.
* Full list at https://babeljs.io/docs/en/next/babel-parser#plugins
*/
const babelParserDefaultPlugins = [
'bigInt',
'optionalChaining',
'nullishCoalescingOperator'
];
const EMPTY_OBJ = ( true)
? Object.freeze({})
: undefined;
const EMPTY_ARR = [];
const NOOP = () => { };
/**
* Always return false.
*/
const NO = () => false;
const onRE = /^on[^a-z]/;
const isOn = (key) => onRE.test(key);
const isModelListener = (key) => key.startsWith('onUpdate:');
const extend = Object.assign;
const remove = (arr, el) => {
const i = arr.indexOf(el);
if (i > -1) {
arr.splice(i, 1);
}
};
const hasOwnProperty = Object.prototype.hasOwnProperty;
const hasOwn = (val, key) => hasOwnProperty.call(val, key);
const isArray = Array.isArray;
const isDate = (val) => val instanceof Date;
const isFunction = (val) => typeof val === 'function';
const isString = (val) => typeof val === 'string';
const isSymbol = (val) => typeof val === 'symbol';
const isObject = (val) => val !== null && typeof val === 'object';
const isPromise = (val) => {
return isObject(val) && isFunction(val.then) && isFunction(val.catch);
};
const objectToString = Object.prototype.toString;
const toTypeString = (value) => objectToString.call(value);
const toRawType = (value) => {
return toTypeString(value).slice(8, -1);
};
const isPlainObject = (val) => toTypeString(val) === '[object Object]';
const isIntegerKey = (key) => isString(key) && key[0] !== '-' && '' + parseInt(key, 10) === key;
const isReservedProp = /*#__PURE__*/ makeMap('key,ref,' +
'onVnodeBeforeMount,onVnodeMounted,' +
'onVnodeBeforeUpdate,onVnodeUpdated,' +
'onVnodeBeforeUnmount,onVnodeUnmounted');
const cacheStringFunction = (fn) => {
const cache = Object.create(null);
return ((str) => {
const hit = cache[str];
return hit || (cache[str] = fn(str));
});
};
const camelizeRE = /-(\w)/g;
/**
* @private
*/
const camelize = cacheStringFunction((str) => {
return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
});
const hyphenateRE = /\B([A-Z])/g;
/**
* @private
*/
const hyphenate = cacheStringFunction((str) => {
return str.replace(hyphenateRE, '-$1').toLowerCase();
});
/**
* @private
*/
const capitalize = cacheStringFunction((str) => {
return str.charAt(0).toUpperCase() + str.slice(1);
});
// compare whether a value has changed, accounting for NaN.
const hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);
const invokeArrayFns = (fns, arg) => {
for (let i = 0; i < fns.length; i++) {
fns[i](arg);
}
};
const def = (obj, key, value) => {
Object.defineProperty(obj, key, {
configurable: true,
enumerable: false,
value
});
};
const toNumber = (val) => {
const n = parseFloat(val);
return isNaN(n) ? val : n;
};
let _globalThis;
const getGlobalThis = () => {
return (_globalThis ||
(_globalThis =
typeof globalThis !== 'undefined'
? globalThis
: typeof self !== 'undefined'
? self
: typeof window !== 'undefined'
? window
: typeof global !== 'undefined'
? global
: {}));
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))
/***/ }),
/***/ "./node_modules/ajax-hook/index.js":
/*!*****************************************!*\
!*** ./node_modules/ajax-hook/index.js ***!
\*****************************************/
/*! exports provided: hook, unHook, proxy, unProxy */
/*! exports used: proxy */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony import */ var _src_xhr_hook__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/xhr-hook */ "./node_modules/ajax-hook/src/xhr-hook.js");
/* harmony import */ var _src_xhr_proxy__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./src/xhr-proxy */ "./node_modules/ajax-hook/src/xhr-proxy.js");
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _src_xhr_proxy__WEBPACK_IMPORTED_MODULE_1__["a"]; });
/*
* author: wendux
* email: 824783146@qq.com
* source code: https://github.com/wendux/Ajax-hook
**/
/***/ }),
/***/ "./node_modules/ajax-hook/src/xhr-hook.js":
/*!************************************************!*\
!*** ./node_modules/ajax-hook/src/xhr-hook.js ***!
\************************************************/
/*! exports provided: configEvent, hook, unHook */
/*! exports used: configEvent, hook, unHook */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return configEvent; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return hook; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return unHook; });
/*
* author: wendux
* email: 824783146@qq.com
* source code: https://github.com/wendux/Ajax-hook
*/
// Save original XMLHttpRequest as _rxhr
var realXhr = "_rxhr"
function configEvent(event, xhrProxy) {
var e = {};
for (var attr in event) e[attr] = event[attr];
// xhrProxy instead
e.target = e.currentTarget = xhrProxy
return e;
}
function hook(proxy) {
// Avoid double hookAjax
window[realXhr] = window[realXhr] || XMLHttpRequest
XMLHttpRequest = function () {
var xhr = new window[realXhr];
// We shouldn't hookAjax XMLHttpRequest.prototype because we can't
// guarantee that all attributes are on the prototype。
// Instead, hooking XMLHttpRequest instance can avoid this problem.
for (var attr in xhr) {
var type = "";
try {
type = typeof xhr[attr] // May cause exception on some browser
} catch (e) {
}
if (type === "function") {
// hookAjax methods of xhr, such as `open`、`send` ...
this[attr] = hookFunction(attr);
} else {
Object.defineProperty(this, attr, {
get: getterFactory(attr),
set: setterFactory(attr),
enumerable: true
})
}
}
var that = this;
xhr.getProxy = function () {
return that
}
this.xhr = xhr;
}
// Generate getter for attributes of xhr
function getterFactory(attr) {
return function () {
var v = this.hasOwnProperty(attr + "_") ? this[attr + "_"] : this.xhr[attr];
var attrGetterHook = (proxy[attr] || {})["getter"]
return attrGetterHook && attrGetterHook(v, this) || v
}
}
// Generate setter for attributes of xhr; by this we have an opportunity
// to hookAjax event callbacks （eg: `onload`） of xhr;
function setterFactory(attr) {
return function (v) {
var xhr = this.xhr;
var that = this;
var hook = proxy[attr];
// hookAjax event callbacks such as `onload`、`onreadystatechange`...
if (attr.substring(0, 2) === 'on') {
that[attr + "_"] = v;
xhr[attr] = function (e) {
e = configEvent(e, that)
var ret = proxy[attr] && proxy[attr].call(that, xhr, e)
ret || v.call(that, e);
}
} else {
//If the attribute isn't writable, generate proxy attribute
var attrSetterHook = (hook || {})["setter"];
v = attrSetterHook && attrSetterHook(v, that) || v
this[attr + "_"] = v;
try {
// Not all attributes of xhr are writable(setter may undefined).
xhr[attr] = v;
} catch (e) {
}
}
}
}
// Hook methods of xhr.
function hookFunction(fun) {
return function () {
var args = [].slice.call(arguments)
if (proxy[fun]) {
var ret = proxy[fun].call(this, args, this.xhr)
// If the proxy return value exists, return it directly,
// otherwise call the function of xhr.
if (ret) return ret;
}
return this.xhr[fun].apply(this.xhr, args);
}
}
// Return the real XMLHttpRequest
return window[realXhr];
}
function unHook() {
if (window[realXhr]) XMLHttpRequest = window[realXhr];
window[realXhr] = undefined;
}
/***/ }),
/***/ "./node_modules/ajax-hook/src/xhr-proxy.js":
/*!*************************************************!*\
!*** ./node_modules/ajax-hook/src/xhr-proxy.js ***!
\*************************************************/
/*! exports provided: proxy, unProxy */
/*! exports used: proxy */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return proxy; });
/* unused harmony export unProxy */
/* harmony import */ var _xhr_hook__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./xhr-hook */ "./node_modules/ajax-hook/src/xhr-hook.js");
/*
* author: wendux
* email: 824783146@qq.com
* source code: https://github.com/wendux/Ajax-hook
*/
var events = ['load', 'loadend', 'timeout', 'error', 'readystatechange', 'abort'];
var eventLoad = events[0],
eventLoadEnd = events[1],
eventTimeout = events[2],
eventError = events[3],
eventReadyStateChange = events[4],
eventAbort = events[5];
var singleton,
prototype = 'prototype';
function proxy(proxy) {
if (singleton) throw "Proxy already exists";
return singleton = new Proxy(proxy);
}
function unProxy() {
singleton = null
Object(_xhr_hook__WEBPACK_IMPORTED_MODULE_0__[/* unHook */ "c"])()
}
function trim(str) {
return str.replace(/^\s+|\s+$/g, '');
}
function getEventTarget(xhr) {
return xhr.watcher || (xhr.watcher = document.createElement('a'));
}
function triggerListener(xhr, name) {
var xhrProxy = xhr.getProxy();
var callback = 'on' + name + '_';
var event = Object(_xhr_hook__WEBPACK_IMPORTED_MODULE_0__[/* configEvent */ "a"])({type: name}, xhrProxy);
xhrProxy[callback] && xhrProxy[callback](event);
var evt;
if(typeof(Event) === 'function') {
evt = new Event(name,{bubbles: false});
} else {
// https://stackoverflow.com/questions/27176983/dispatchevent-not-working-in-ie11
evt = document.createEvent('Event');
evt.initEvent(name, false, true);
}
getEventTarget(xhr).dispatchEvent(evt);
}
function Handler(xhr) {
this.xhr = xhr;
this.xhrProxy = xhr.getProxy();
}
Handler[prototype] = Object.create({
resolve: function resolve(response) {
var xhrProxy = this.xhrProxy;
var xhr = this.xhr;
xhrProxy.readyState = 4;
xhr.resHeader = response.headers;
xhrProxy.response = xhrProxy.responseText = response.response;
xhrProxy.statusText = response.statusText;
xhrProxy.status = response.status;
triggerListener(xhr, eventReadyStateChange);
triggerListener(xhr, eventLoad);
triggerListener(xhr, eventLoadEnd);
},
reject: function reject(error) {
this.xhrProxy.status = 0;
triggerListener(this.xhr, error.type);
triggerListener(this.xhr, eventLoadEnd);
}
});
function makeHandler(next) {
function sub(xhr) {
Handler.call(this, xhr);
}
sub[prototype] = Object.create(Handler[prototype]);
sub[prototype].next = next;
return sub;
}
var RequestHandler = makeHandler(function (rq) {
var xhr = this.xhr;
rq = rq || xhr.config;
xhr.withCredentials = rq.withCredentials;
xhr.open(rq.method, rq.url, rq.async !== false, rq.user, rq.password);
for (var key in rq.headers) {
xhr.setRequestHeader(key, rq.headers[key]);
}
xhr.send(rq.body);
});
var ResponseHandler = makeHandler(function (response) {
this.resolve(response);
});
var ErrorHandler = makeHandler(function (error) {
this.reject(error);
});
function Proxy(proxy) {
var onRequest = proxy.onRequest,
onResponse = proxy.onResponse,
onError = proxy.onError;
function handleResponse(xhr, xhrProxy) {
var handler = new ResponseHandler(xhr);
if (!onResponse) return handler.resolve();
var ret = {
response: xhrProxy.response,
status: xhrProxy.status,
statusText: xhrProxy.statusText,
config: xhr.config,
headers: xhr.resHeader || xhr.getAllResponseHeaders().split('\r\n').reduce(function (ob, str) {
if (str === "") return ob;
var m = str.split(":");
ob[m.shift()] = trim(m.join(':'));
return ob;
}, {})
};
onResponse(ret, handler);
}
function onerror(xhr, xhrProxy, e) {
var handler = new ErrorHandler(xhr);
var error = {config: xhr.config, error: e};
if (onError) {
onError(error, handler);
} else {
handler.next(error);
}
}
function preventXhrProxyCallback() {
return true;
}
function errorCallback(xhr, e) {
onerror(xhr, this, e);
return true;
}
function stateChangeCallback(xhr, xhrProxy) {
if (xhr.readyState === 4 && xhr.status !== 0) {
handleResponse(xhr, xhrProxy);
} else if (xhr.readyState !== 4) {
triggerListener(xhr, eventReadyStateChange);
}
return true;
}
return Object(_xhr_hook__WEBPACK_IMPORTED_MODULE_0__[/* hook */ "b"])({
onload: preventXhrProxyCallback,
onloadend: preventXhrProxyCallback,
onerror: errorCallback,
ontimeout: errorCallback,
onabort: errorCallback,
onreadystatechange: function (xhr) {
return stateChangeCallback(xhr, this);
},
open: function open(args, xhr) {
var _this = this;
var config = xhr.config = {headers: {}};
config.method = args[0];
config.url = args[1];
config.async = args[2];
config.user = args[3];
config.password = args[4];
config.xhr = xhr;
var evName = 'on' + eventReadyStateChange;
if (!xhr[evName]) {
xhr[evName] = function () {
return stateChangeCallback(xhr, _this);
};
}
var defaultErrorHandler = function defaultErrorHandler(e) {
onerror(xhr, _this, Object(_xhr_hook__WEBPACK_IMPORTED_MODULE_0__[/* configEvent */ "a"])(e, _this));
};
[eventError, eventTimeout, eventAbort].forEach(function (e) {
var event = 'on' + e;
if (!xhr[event]) xhr[event] = defaultErrorHandler;
});
// 如果有请求拦截器，则在调用onRequest后再打开链接。因为onRequest最佳调用时机是在send前，
// 所以我们在send拦截函数中再手动调用open，因此返回true阻止xhr.open调用。
//
// 如果没有请求拦截器，则不用阻断xhr.open调用
if (onRequest) return true;
},
send: function (args, xhr) {
var config = xhr.config
config.withCredentials=xhr.withCredentials
config.body = args[0];
if (onRequest) {
// In 'onRequest', we may call XHR's event handler, such as `xhr.onload`.
// However, XHR's event handler may not be set until xhr.send is called in
// the user's code, so we use `setTimeout` to avoid this situation
var req = function () {
onRequest(config, new RequestHandler(xhr));
}
config.async === false ? req() : setTimeout(req)
return true;
}
},
setRequestHeader: function (args, xhr) {
// Collect request headers
xhr.config.headers[args[0].toLowerCase()] = args[1];
return true;
},
addEventListener: function (args, xhr) {
var _this = this;
if (events.indexOf(args[0]) !== -1) {
var handler = args[1];
getEventTarget(xhr).addEventListener(args[0], function (e) {
var event = Object(_xhr_hook__WEBPACK_IMPORTED_MODULE_0__[/* configEvent */ "a"])(e, _this);
event.type = args[0];
event.isTrusted = true;
handler.call(_this, event);
});
return true;
}
},
getAllResponseHeaders: function (_, xhr) {
var headers = xhr.resHeader
if (headers) {
var header = "";
for (var key in headers) {
header += key + ': ' + headers[key] + '\r\n';
}
return header;
}
},
getResponseHeader: function (args, xhr) {
var headers = xhr.resHeader
if (headers) {
return headers[(args[0] || '').toLowerCase()];
}
}
});
}
/***/ }),
/***/ "./node_modules/svelte/internal/index.mjs":
/*!************************************************!*\
!*** ./node_modules/svelte/internal/index.mjs ***!
\************************************************/
/*! exports provided: HtmlTag, SvelteComponent, SvelteComponentDev, SvelteElement, action_destroyer, add_attribute, add_classes, add_flush_callback, add_location, add_render_callback, add_resize_listener, add_transform, afterUpdate, append, append_dev, assign, attr, attr_dev, beforeUpdate, bind, binding_callbacks, blank_object, bubble, check_outros, children, claim_component, claim_element, claim_space, claim_text, clear_loops, component_subscribe, compute_rest_props, compute_slots, createEventDispatcher, create_animation, create_bidirectional_transition, create_component, create_in_transition, create_out_transition, create_slot, create_ssr_component, current_component, custom_event, dataset_dev, debug, destroy_block, destroy_component, destroy_each, detach, detach_after_dev, detach_before_dev, detach_between_dev, detach_dev, dirty_components, dispatch_dev, each, element, element_is, empty, escape, escaped, exclude_internal_props, fix_and_destroy_block, fix_and_outro_and_destroy_block, fix_position, flush, getContext, get_binding_group_value, get_current_component, get_slot_changes, get_slot_context, get_spread_object, get_spread_update, get_store_value, globals, group_outros, handle_promise, has_prop, identity, init, insert, insert_dev, intros, invalid_attribute_name_character, is_client, is_crossorigin, is_empty, is_function, is_promise, listen, listen_dev, loop, loop_guard, missing_component, mount_component, noop, not_equal, now, null_to_empty, object_without_properties, onDestroy, onMount, once, outro_and_destroy_block, prevent_default, prop_dev, query_selector_all, raf, run, run_all, safe_not_equal, schedule_update, select_multiple_value, select_option, select_options, select_value, self, setContext, set_attributes, set_current_component, set_custom_element_data, set_data, set_data_dev, set_input_type, set_input_value, set_now, set_raf, set_store_value, set_style, set_svg_attributes, space, spread, stop_propagation, subscribe, svg_element, text, tick, time_ranges_to_array, to_number, toggle_class, transition_in, transition_out, update_keyed_each, update_slot, validate_component, validate_each_argument, validate_each_keys, validate_slots, validate_store, xlink_attr */
/*! exports used: HtmlTag, SvelteComponent, add_flush_callback, add_render_callback, add_transform, append, assign, attr, bind, binding_callbacks, check_outros, component_subscribe, createEventDispatcher, create_animation, create_bidirectional_transition, create_component, destroy_block, destroy_component, destroy_each, detach, element, fix_and_outro_and_destroy_block, fix_position, get_store_value, group_outros, identity, init, insert, is_function, listen, mount_component, noop, run_all, safe_not_equal, set_data, set_input_value, set_style, space, subscribe, text, transition_in, transition_out, update_keyed_each */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(global) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return HtmlTag; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return SvelteComponent; });
/* unused harmony export SvelteComponentDev */
/* unused harmony export SvelteElement */
/* unused harmony export action_destroyer */
/* unused harmony export add_attribute */
/* unused harmony export add_classes */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return add_flush_callback; });
/* unused harmony export add_location */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return add_render_callback; });
/* unused harmony export add_resize_listener */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return add_transform; });
/* unused harmony export afterUpdate */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return append; });
/* unused harmony export append_dev */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return assign; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return attr; });
/* unused harmony export attr_dev */
/* unused harmony export beforeUpdate */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return bind; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return binding_callbacks; });
/* unused harmony export blank_object */
/* unused harmony export bubble */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return check_outros; });
/* unused harmony export children */
/* unused harmony export claim_component */
/* unused harmony export claim_element */
/* unused harmony export claim_space */
/* unused harmony export claim_text */
/* unused harmony export clear_loops */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "l", function() { return component_subscribe; });
/* unused harmony export compute_rest_props */
/* unused harmony export compute_slots */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "m", function() { return createEventDispatcher; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "n", function() { return create_animation; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "o", function() { return create_bidirectional_transition; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "p", function() { return create_component; });
/* unused harmony export create_in_transition */
/* unused harmony export create_out_transition */
/* unused harmony export create_slot */
/* unused harmony export create_ssr_component */
/* unused harmony export current_component */
/* unused harmony export custom_event */
/* unused harmony export dataset_dev */
/* unused harmony export debug */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "q", function() { return destroy_block; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "r", function() { return destroy_component; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "s", function() { return destroy_each; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "t", function() { return detach; });
/* unused harmony export detach_after_dev */
/* unused harmony export detach_before_dev */
/* unused harmony export detach_between_dev */
/* unused harmony export detach_dev */
/* unused harmony export dirty_components */
/* unused harmony export dispatch_dev */
/* unused harmony export each */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "u", function() { return element; });
/* unused harmony export element_is */
/* unused harmony export empty */
/* unused harmony export escape */
/* unused harmony export escaped */
/* unused harmony export exclude_internal_props */
/* unused harmony export fix_and_destroy_block */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "v", function() { return fix_and_outro_and_destroy_block; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "w", function() { return fix_position; });
/* unused harmony export flush */
/* unused harmony export getContext */
/* unused harmony export get_binding_group_value */
/* unused harmony export get_current_component */
/* unused harmony export get_slot_changes */
/* unused harmony export get_slot_context */
/* unused harmony export get_spread_object */
/* unused harmony export get_spread_update */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "x", function() { return get_store_value; });
/* unused harmony export globals */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "y", function() { return group_outros; });
/* unused harmony export handle_promise */
/* unused harmony export has_prop */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "z", function() { return identity; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "A", function() { return init; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "B", function() { return insert; });
/* unused harmony export insert_dev */
/* unused harmony export intros */
/* unused harmony export invalid_attribute_name_character */
/* unused harmony export is_client */
/* unused harmony export is_crossorigin */
/* unused harmony export is_empty */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "C", function() { return is_function; });
/* unused harmony export is_promise */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "D", function() { return listen; });
/* unused harmony export listen_dev */
/* unused harmony export loop */
/* unused harmony export loop_guard */
/* unused harmony export missing_component */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "E", function() { return mount_component; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "F", function() { return noop; });
/* unused harmony export not_equal */
/* unused harmony export now */
/* unused harmony export null_to_empty */
/* unused harmony export object_without_properties */
/* unused harmony export onDestroy */
/* unused harmony export onMount */
/* unused harmony export once */
/* unused harmony export outro_and_destroy_block */
/* unused harmony export prevent_default */
/* unused harmony export prop_dev */
/* unused harmony export query_selector_all */
/* unused harmony export raf */
/* unused harmony export run */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "G", function() { return run_all; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "H", function() { return safe_not_equal; });
/* unused harmony export schedule_update */
/* unused harmony export select_multiple_value */
/* unused harmony export select_option */
/* unused harmony export select_options */
/* unused harmony export select_value */
/* unused harmony export self */
/* unused harmony export setContext */
/* unused harmony export set_attributes */
/* unused harmony export set_current_component */
/* unused harmony export set_custom_element_data */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "I", function() { return set_data; });
/* unused harmony export set_data_dev */
/* unused harmony export set_input_type */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "J", function() { return set_input_value; });
/* unused harmony export set_now */
/* unused harmony export set_raf */
/* unused harmony export set_store_value */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "K", function() { return set_style; });
/* unused harmony export set_svg_attributes */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "L", function() { return space; });
/* unused harmony export spread */
/* unused harmony export stop_propagation */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "M", function() { return subscribe; });
/* unused harmony export svg_element */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "N", function() { return text; });
/* unused harmony export tick */
/* unused harmony export time_ranges_to_array */
/* unused harmony export to_number */
/* unused harmony export toggle_class */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "O", function() { return transition_in; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "P", function() { return transition_out; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Q", function() { return update_keyed_each; });
/* unused harmony export update_slot */
/* unused harmony export validate_component */
/* unused harmony export validate_each_argument */
/* unused harmony export validate_each_keys */
/* unused harmony export validate_slots */
/* unused harmony export validate_store */
/* unused harmony export xlink_attr */
function noop() { }
const identity = x => x;
function assign(tar, src) {
// @ts-ignore
for (const k in src)
tar[k] = src[k];
return tar;
}
function is_promise(value) {
return value && typeof value === 'object' && typeof value.then === 'function';
}
function add_location(element, file, line, column, char) {
element.__svelte_meta = {
loc: { file, line, column, char }
};
}
function run(fn) {
return fn();
}
function blank_object() {
return Object.create(null);
}
function run_all(fns) {
fns.forEach(run);
}
function is_function(thing) {
return typeof thing === 'function';
}
function safe_not_equal(a, b) {
return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
}
function not_equal(a, b) {
return a != a ? b == b : a !== b;
}
function is_empty(obj) {
return Object.keys(obj).length === 0;
}
function validate_store(store, name) {
if (store != null && typeof store.subscribe !== 'function') {
throw new Error(`'${name}' is not a store with a 'subscribe' method`);
}
}
function subscribe(store, ...callbacks) {
if (store == null) {
return noop;
}
const unsub = store.subscribe(...callbacks);
return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
}
function get_store_value(store) {
let value;
subscribe(store, _ => value = _)();
return value;
}
function component_subscribe(component, store, callback) {
component.$$.on_destroy.push(subscribe(store, callback));
}
function create_slot(definition, ctx, $$scope, fn) {
if (definition) {
const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
return definition[0](slot_ctx);
}
}
function get_slot_context(definition, ctx, $$scope, fn) {
return definition[1] && fn
? assign($$scope.ctx.slice(), definition[1](fn(ctx)))
: $$scope.ctx;
}
function get_slot_changes(definition, $$scope, dirty, fn) {
if (definition[2] && fn) {
const lets = definition[2](fn(dirty));
if ($$scope.dirty === undefined) {
return lets;
}
if (typeof lets === 'object') {
const merged = [];
const len = Math.max($$scope.dirty.length, lets.length);
for (let i = 0; i < len; i += 1) {
merged[i] = $$scope.dirty[i] | lets[i];
}
return merged;
}
return $$scope.dirty | lets;
}
return $$scope.dirty;
}
function update_slot(slot, slot_definition, ctx, $$scope, dirty, get_slot_changes_fn, get_slot_context_fn) {
const slot_changes = get_slot_changes(slot_definition, $$scope, dirty, get_slot_changes_fn);
if (slot_changes) {
const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
slot.p(slot_context, slot_changes);
}
}
function exclude_internal_props(props) {
const result = {};
for (const k in props)
if (k[0] !== '$')
result[k] = props[k];
return result;
}
function compute_rest_props(props, keys) {
const rest = {};
keys = new Set(keys);
for (const k in props)
if (!keys.has(k) && k[0] !== '$')
rest[k] = props[k];
return rest;
}
function compute_slots(slots) {
const result = {};
for (const key in slots) {
result[key] = true;
}
return result;
}
function once(fn) {
let ran = false;
return function (...args) {
if (ran)
return;
ran = true;
fn.call(this, ...args);
};
}
function null_to_empty(value) {
return value == null ? '' : value;
}
function set_store_value(store, ret, value = ret) {
store.set(value);
return ret;
}
const has_prop = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
function action_destroyer(action_result) {
return action_result && is_function(action_result.destroy) ? action_result.destroy : noop;
}
const is_client = typeof window !== 'undefined';
let now = is_client
? () => window.performance.now()
: () => Date.now();
let raf = is_client ? cb => requestAnimationFrame(cb) : noop;
// used internally for testing
function set_now(fn) {
now = fn;
}
function set_raf(fn) {
raf = fn;
}
const tasks = new Set();
function run_tasks(now) {
tasks.forEach(task => {
if (!task.c(now)) {
tasks.delete(task);
task.f();
}
});
if (tasks.size !== 0)
raf(run_tasks);
}
/**
* For testing purposes only!
*/
function clear_loops() {
tasks.clear();
}
/**
* Creates a new task that runs on each raf frame
* until it returns a falsy value or is aborted
*/
function loop(callback) {
let task;
if (tasks.size === 0)
raf(run_tasks);
return {
promise: new Promise(fulfill => {
tasks.add(task = { c: callback, f: fulfill });
}),
abort() {
tasks.delete(task);
}
};
}
function append(target, node) {
target.appendChild(node);
}
function insert(target, node, anchor) {
target.insertBefore(node, anchor || null);
}
function detach(node) {
node.parentNode.removeChild(node);
}
function destroy_each(iterations, detaching) {
for (let i = 0; i < iterations.length; i += 1) {
if (iterations[i])
iterations[i].d(detaching);
}
}
function element(name) {
return document.createElement(name);
}
function element_is(name, is) {
return document.createElement(name, { is });
}
function object_without_properties(obj, exclude) {
const target = {};
for (const k in obj) {
if (has_prop(obj, k)
// @ts-ignore
&& exclude.indexOf(k) === -1) {
// @ts-ignore
target[k] = obj[k];
}
}
return target;
}
function svg_element(name) {
return document.createElementNS('http://www.w3.org/2000/svg', name);
}
function text(data) {
return document.createTextNode(data);
}
function space() {
return text(' ');
}
function empty() {
return text('');
}
function listen(node, event, handler, options) {
node.addEventListener(event, handler, options);
return () => node.removeEventListener(event, handler, options);
}
function prevent_default(fn) {
return function (event) {
event.preventDefault();
// @ts-ignore
return fn.call(this, event);
};
}
function stop_propagation(fn) {
return function (event) {
event.stopPropagation();
// @ts-ignore
return fn.call(this, event);
};
}
function self(fn) {
return function (event) {
// @ts-ignore
if (event.target === this)
fn.call(this, event);
};
}
function attr(node, attribute, value) {
if (value == null)
node.removeAttribute(attribute);
else if (node.getAttribute(attribute) !== value)
node.setAttribute(attribute, value);
}
function set_attributes(node, attributes) {
// @ts-ignore
const descriptors = Object.getOwnPropertyDescriptors(node.__proto__);
for (const key in attributes) {
if (attributes[key] == null) {
node.removeAttribute(key);
}
else if (key === 'style') {
node.style.cssText = attributes[key];
}
else if (key === '__value') {
node.value = node[key] = attributes[key];
}
else if (descriptors[key] && descriptors[key].set) {
node[key] = attributes[key];
}
else {
attr(node, key, attributes[key]);
}
}
}
function set_svg_attributes(node, attributes) {
for (const key in attributes) {
attr(node, key, attributes[key]);
}
}
function set_custom_element_data(node, prop, value) {
if (prop in node) {
node[prop] = value;
}
else {
attr(node, prop, value);
}
}
function xlink_attr(node, attribute, value) {
node.setAttributeNS('http://www.w3.org/1999/xlink', attribute, value);
}
function get_binding_group_value(group, __value, checked) {
const value = new Set();
for (let i = 0; i < group.length; i += 1) {
if (group[i].checked)
value.add(group[i].__value);
}
if (!checked) {
value.delete(__value);
}
return Array.from(value);
}
function to_number(value) {
return value === '' ? null : +value;
}
function time_ranges_to_array(ranges) {
const array = [];
for (let i = 0; i < ranges.length; i += 1) {
array.push({ start: ranges.start(i), end: ranges.end(i) });
}
return array;
}
function children(element) {
return Array.from(element.childNodes);
}
function claim_element(nodes, name, attributes, svg) {
for (let i = 0; i < nodes.length; i += 1) {
const node = nodes[i];
if (node.nodeName === name) {
let j = 0;
const remove = [];
while (j < node.attributes.length) {
const attribute = node.attributes[j++];
if (!attributes[attribute.name]) {
remove.push(attribute.name);
}
}
for (let k = 0; k < remove.length; k++) {
node.removeAttribute(remove[k]);
}
return nodes.splice(i, 1)[0];
}
}
return svg ? svg_element(name) : element(name);
}
function claim_text(nodes, data) {
for (let i = 0; i < nodes.length; i += 1) {
const node = nodes[i];
if (node.nodeType === 3) {
node.data = '' + data;
return nodes.splice(i, 1)[0];
}
}
return text(data);
}
function claim_space(nodes) {
return claim_text(nodes, ' ');
}
function set_data(text, data) {
data = '' + data;
if (text.wholeText !== data)
text.data = data;
}
function set_input_value(input, value) {
input.value = value == null ? '' : value;
}
function set_input_type(input, type) {
try {
input.type = type;
}
catch (e) {
// do nothing
}
}
function set_style(node, key, value, important) {
node.style.setProperty(key, value, important ? 'important' : '');
}
function select_option(select, value) {
for (let i = 0; i < select.options.length; i += 1) {
const option = select.options[i];
if (option.__value === value) {
option.selected = true;
return;
}
}
}
function select_options(select, value) {
for (let i = 0; i < select.options.length; i += 1) {
const option = select.options[i];
option.selected = ~value.indexOf(option.__value);
}
}
function select_value(select) {
const selected_option = select.querySelector(':checked') || select.options[0];
return selected_option && selected_option.__value;
}
function select_multiple_value(select) {
return [].map.call(select.querySelectorAll(':checked'), option => option.__value);
}
// unfortunately this can't be a constant as that wouldn't be tree-shakeable
// so we cache the result instead
let crossorigin;
function is_crossorigin() {
if (crossorigin === undefined) {
crossorigin = false;
try {
if (typeof window !== 'undefined' && window.parent) {
void window.parent.document;
}
}
catch (error) {
crossorigin = true;
}
}
return crossorigin;
}
function add_resize_listener(node, fn) {
const computed_style = getComputedStyle(node);
const z_index = (parseInt(computed_style.zIndex) || 0) - 1;
if (computed_style.position === 'static') {
node.style.position = 'relative';
}
const iframe = element('iframe');
iframe.setAttribute('style', `display: block; position: absolute; top: 0; left: 0; width: 100%; height: 100%; ` +
`overflow: hidden; border: 0; opacity: 0; pointer-events: none; z-index: ${z_index};`);
iframe.setAttribute('aria-hidden', 'true');
iframe.tabIndex = -1;
const crossorigin = is_crossorigin();
let unsubscribe;
if (crossorigin) {
iframe.src = `data:text/html,<script>onresize=function(){parent.postMessage(0,'*')}</script>`;
unsubscribe = listen(window, 'message', (event) => {
if (event.source === iframe.contentWindow)
fn();
});
}
else {
iframe.src = 'about:blank';
iframe.onload = () => {
unsubscribe = listen(iframe.contentWindow, 'resize', fn);
};
}
append(node, iframe);
return () => {
if (crossorigin) {
unsubscribe();
}
else if (unsubscribe && iframe.contentWindow) {
unsubscribe();
}
detach(iframe);
};
}
function toggle_class(element, name, toggle) {
element.classList[toggle ? 'add' : 'remove'](name);
}
function custom_event(type, detail) {
const e = document.createEvent('CustomEvent');
e.initCustomEvent(type, false, false, detail);
return e;
}
function query_selector_all(selector, parent = document.body) {
return Array.from(parent.querySelectorAll(selector));
}
class HtmlTag {
constructor(anchor = null) {
this.a = anchor;
this.e = this.n = null;
}
m(html, target, anchor = null) {
if (!this.e) {
this.e = element(target.nodeName);
this.t = target;
this.h(html);
}
this.i(anchor);
}
h(html) {
this.e.innerHTML = html;
this.n = Array.from(this.e.childNodes);
}
i(anchor) {
for (let i = 0; i < this.n.length; i += 1) {
insert(this.t, this.n[i], anchor);
}
}
p(html) {
this.d();
this.h(html);
this.i(this.a);
}
d() {
this.n.forEach(detach);
}
}
const active_docs = new Set();
let active = 0;
// https://github.com/darkskyapp/string-hash/blob/master/index.js
function hash(str) {
let hash = 5381;
let i = str.length;
while (i--)
hash = ((hash << 5) - hash) ^ str.charCodeAt(i);
return hash >>> 0;
}
function create_rule(node, a, b, duration, delay, ease, fn, uid = 0) {
const step = 16.666 / duration;
let keyframes = '{\n';
for (let p = 0; p <= 1; p += step) {
const t = a + (b - a) * ease(p);
keyframes += p * 100 + `%{${fn(t, 1 - t)}}\n`;
}
const rule = keyframes + `100% {${fn(b, 1 - b)}}\n}`;
const name = `__svelte_${hash(rule)}_${uid}`;
const doc = node.ownerDocument;
active_docs.add(doc);
const stylesheet = doc.__svelte_stylesheet || (doc.__svelte_stylesheet = doc.head.appendChild(element('style')).sheet);
const current_rules = doc.__svelte_rules || (doc.__svelte_rules = {});
if (!current_rules[name]) {
current_rules[name] = true;
stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);
}
const animation = node.style.animation || '';
node.style.animation = `${animation ? `${animation}, ` : ``}${name} ${duration}ms linear ${delay}ms 1 both`;
active += 1;
return name;
}
function delete_rule(node, name) {
const previous = (node.style.animation || '').split(', ');
const next = previous.filter(name
? anim => anim.indexOf(name) < 0 // remove specific animation
: anim => anim.indexOf('__svelte') === -1 // remove all Svelte animations
);
const deleted = previous.length - next.length;
if (deleted) {
node.style.animation = next.join(', ');
active -= deleted;
if (!active)
clear_rules();
}
}
function clear_rules() {
raf(() => {
if (active)
return;
active_docs.forEach(doc => {
const stylesheet = doc.__svelte_stylesheet;
let i = stylesheet.cssRules.length;
while (i--)
stylesheet.deleteRule(i);
doc.__svelte_rules = {};
});
active_docs.clear();
});
}
function create_animation(node, from, fn, params) {
if (!from)
return noop;
const to = node.getBoundingClientRect();
if (from.left === to.left && from.right === to.right && from.top === to.top && from.bottom === to.bottom)
return noop;
const { delay = 0, duration = 300, easing = identity,
// @ts-ignore todo: should this be separated from destructuring? Or start/end added to public api and documentation?
start: start_time = now() + delay,
// @ts-ignore todo:
end = start_time + duration, tick = noop, css } = fn(node, { from, to }, params);
let running = true;
let started = false;
let name;
function start() {
if (css) {
name = create_rule(node, 0, 1, duration, delay, easing, css);
}
if (!delay) {
started = true;
}
}
function stop() {
if (css)
delete_rule(node, name);
running = false;
}
loop(now => {
if (!started && now >= start_time) {
started = true;
}
if (started && now >= end) {
tick(1, 0);
stop();
}
if (!running) {
return false;
}
if (started) {
const p = now - start_time;
const t = 0 + 1 * easing(p / duration);
tick(t, 1 - t);
}
return true;
});
start();
tick(0, 1);
return stop;
}
function fix_position(node) {
const style = getComputedStyle(node);
if (style.position !== 'absolute' && style.position !== 'fixed') {
const { width, height } = style;
const a = node.getBoundingClientRect();
node.style.position = 'absolute';
node.style.width = width;
node.style.height = height;
add_transform(node, a);
}
}
function add_transform(node, a) {
const b = node.getBoundingClientRect();
if (a.left !== b.left || a.top !== b.top) {
const style = getComputedStyle(node);
const transform = style.transform === 'none' ? '' : style.transform;
node.style.transform = `${transform} translate(${a.left - b.left}px, ${a.top - b.top}px)`;
}
}
let current_component;
function set_current_component(component) {
current_component = component;
}
function get_current_component() {
if (!current_component)
throw new Error(`Function called outside component initialization`);
return current_component;
}
function beforeUpdate(fn) {
get_current_component().$$.before_update.push(fn);
}
function onMount(fn) {
get_current_component().$$.on_mount.push(fn);
}
function afterUpdate(fn) {
get_current_component().$$.after_update.push(fn);
}
function onDestroy(fn) {
get_current_component().$$.on_destroy.push(fn);
}
function createEventDispatcher() {
const component = get_current_component();
return (type, detail) => {
const callbacks = component.$$.callbacks[type];
if (callbacks) {
// TODO are there situations where events could be dispatched
// in a server (non-DOM) environment?
const event = custom_event(type, detail);
callbacks.slice().forEach(fn => {
fn.call(component, event);
});
}
};
}
function setContext(key, context) {
get_current_component().$$.context.set(key, context);
}
function getContext(key) {
return get_current_component().$$.context.get(key);
}
// TODO figure out if we still want to support
// shorthand events, or if we want to implement
// a real bubbling mechanism
function bubble(component, event) {
const callbacks = component.$$.callbacks[event.type];
if (callbacks) {
callbacks.slice().forEach(fn => fn(event));
}
}
const dirty_components = [];
const intros = { enabled: false };
const binding_callbacks = [];
const render_callbacks = [];
const flush_callbacks = [];
const resolved_promise = Promise.resolve();
let update_scheduled = false;
function schedule_update() {
if (!update_scheduled) {
update_scheduled = true;
resolved_promise.then(flush);
}
}
function tick() {
schedule_update();
return resolved_promise;
}
function add_render_callback(fn) {
render_callbacks.push(fn);
}
function add_flush_callback(fn) {
flush_callbacks.push(fn);
}
let flushing = false;
const seen_callbacks = new Set();
function flush() {
if (flushing)
return;
flushing = true;
do {
// first, call beforeUpdate functions
// and update components
for (let i = 0; i < dirty_components.length; i += 1) {
const component = dirty_components[i];
set_current_component(component);
update(component.$$);
}
set_current_component(null);
dirty_components.length = 0;
while (binding_callbacks.length)
binding_callbacks.pop()();
// then, once components are updated, call
// afterUpdate functions. This may cause
// subsequent updates...
for (let i = 0; i < render_callbacks.length; i += 1) {
const callback = render_callbacks[i];
if (!seen_callbacks.has(callback)) {
// ...so guard against infinite loops
seen_callbacks.add(callback);
callback();
}
}
render_callbacks.length = 0;
} while (dirty_components.length);
while (flush_callbacks.length) {
flush_callbacks.pop()();
}
update_scheduled = false;
flushing = false;
seen_callbacks.clear();
}
function update($$) {
if ($$.fragment !== null) {
$$.update();
run_all($$.before_update);
const dirty = $$.dirty;
$$.dirty = [-1];
$$.fragment && $$.fragment.p($$.ctx, dirty);
$$.after_update.forEach(add_render_callback);
}
}
let promise;
function wait() {
if (!promise) {
promise = Promise.resolve();
promise.then(() => {
promise = null;
});
}
return promise;
}
function dispatch(node, direction, kind) {
node.dispatchEvent(custom_event(`${direction ? 'intro' : 'outro'}${kind}`));
}
const outroing = new Set();
let outros;
function group_outros() {
outros = {
r: 0,
c: [],
p: outros // parent group
};
}
function check_outros() {
if (!outros.r) {
run_all(outros.c);
}
outros = outros.p;
}
function transition_in(block, local) {
if (block && block.i) {
outroing.delete(block);
block.i(local);
}
}
function transition_out(block, local, detach, callback) {
if (block && block.o) {
if (outroing.has(block))
return;
outroing.add(block);
outros.c.push(() => {
outroing.delete(block);
if (callback) {
if (detach)
block.d(1);
callback();
}
});
block.o(local);
}
}
const null_transition = { duration: 0 };
function create_in_transition(node, fn, params) {
let config = fn(node, params);
let running = false;
let animation_name;
let task;
let uid = 0;
function cleanup() {
if (animation_name)
delete_rule(node, animation_name);
}
function go() {
const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;
if (css)
animation_name = create_rule(node, 0, 1, duration, delay, easing, css, uid++);
tick(0, 1);
const start_time = now() + delay;
const end_time = start_time + duration;
if (task)
task.abort();
running = true;
add_render_callback(() => dispatch(node, true, 'start'));
task = loop(now => {
if (running) {
if (now >= end_time) {
tick(1, 0);
dispatch(node, true, 'end');
cleanup();
return running = false;
}
if (now >= start_time) {
const t = easing((now - start_time) / duration);
tick(t, 1 - t);
}
}
return running;
});
}
let started = false;
return {
start() {
if (started)
return;
delete_rule(node);
if (is_function(config)) {
config = config();
wait().then(go);
}
else {
go();
}
},
invalidate() {
started = false;
},
end() {
if (running) {
cleanup();
running = false;
}
}
};
}
function create_out_transition(node, fn, params) {
let config = fn(node, params);
let running = true;
let animation_name;
const group = outros;
group.r += 1;
function go() {
const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;
if (css)
animation_name = create_rule(node, 1, 0, duration, delay, easing, css);
const start_time = now() + delay;
const end_time = start_time + duration;
add_render_callback(() => dispatch(node, false, 'start'));
loop(now => {
if (running) {
if (now >= end_time) {
tick(0, 1);
dispatch(node, false, 'end');
if (!--group.r) {
// this will result in `end()` being called,
// so we don't need to clean up here
run_all(group.c);
}
return false;
}
if (now >= start_time) {
const t = easing((now - start_time) / duration);
tick(1 - t, t);
}
}
return running;
});
}
if (is_function(config)) {
wait().then(() => {
// @ts-ignore
config = config();
go();
});
}
else {
go();
}
return {
end(reset) {
if (reset && config.tick) {
config.tick(1, 0);
}
if (running) {
if (animation_name)
delete_rule(node, animation_name);
running = false;
}
}
};
}
function create_bidirectional_transition(node, fn, params, intro) {
let config = fn(node, params);
let t = intro ? 0 : 1;
let running_program = null;
let pending_program = null;
let animation_name = null;
function clear_animation() {
if (animation_name)
delete_rule(node, animation_name);
}
function init(program, duration) {
const d = program.b - t;
duration *= Math.abs(d);
return {
a: t,
b: program.b,
d,
duration,
start: program.start,
end: program.start + duration,
group: program.group
};
}
function go(b) {
const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;
const program = {
start: now() + delay,
b
};
if (!b) {
// @ts-ignore todo: improve typings
program.group = outros;
outros.r += 1;
}
if (running_program) {
pending_program = program;
}
else {
// if this is an intro, and there's a delay, we need to do
// an initial tick and/or apply CSS animation immediately
if (css) {
clear_animation();
animation_name = create_rule(node, t, b, duration, delay, easing, css);
}
if (b)
tick(0, 1);
running_program = init(program, duration);
add_render_callback(() => dispatch(node, b, 'start'));
loop(now => {
if (pending_program && now > pending_program.start) {
running_program = init(pending_program, duration);
pending_program = null;
dispatch(node, running_program.b, 'start');
if (css) {
clear_animation();
animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css);
}
}
if (running_program) {
if (now >= running_program.end) {
tick(t = running_program.b, 1 - t);
dispatch(node, running_program.b, 'end');
if (!pending_program) {
// we're done
if (running_program.b) {
// intro — we can tidy up immediately
clear_animation();
}
else {
// outro — needs to be coordinated
if (!--running_program.group.r)
run_all(running_program.group.c);
}
}
running_program = null;
}
else if (now >= running_program.start) {
const p = now - running_program.start;
t = running_program.a + running_program.d * easing(p / running_program.duration);
tick(t, 1 - t);
}
}
return !!(running_program || pending_program);
});
}
}
return {
run(b) {
if (is_function(config)) {
wait().then(() => {
// @ts-ignore
config = config();
go(b);
});
}
else {
go(b);
}
},
end() {
clear_animation();
running_program = pending_program = null;
}
};
}
function handle_promise(promise, info) {
const token = info.token = {};
function update(type, index, key, value) {
if (info.token !== token)
return;
info.resolved = value;
let child_ctx = info.ctx;
if (key !== undefined) {
child_ctx = child_ctx.slice();
child_ctx[key] = value;
}
const block = type && (info.current = type)(child_ctx);
let needs_flush = false;
if (info.block) {
if (info.blocks) {
info.blocks.forEach((block, i) => {
if (i !== index && block) {
group_outros();
transition_out(block, 1, 1, () => {
info.blocks[i] = null;
});
check_outros();
}
});
}
else {
info.block.d(1);
}
block.c();
transition_in(block, 1);
block.m(info.mount(), info.anchor);
needs_flush = true;
}
info.block = block;
if (info.blocks)
info.blocks[index] = block;
if (needs_flush) {
flush();
}
}
if (is_promise(promise)) {
const current_component = get_current_component();
promise.then(value => {
set_current_component(current_component);
update(info.then, 1, info.value, value);
set_current_component(null);
}, error => {
if (!info.hasCatch) {
throw error;
}
set_current_component(current_component);
update(info.catch, 2, info.error, error);
set_current_component(null);
});
// if we previously had a then/catch block, destroy it
if (info.current !== info.pending) {
update(info.pending, 0);
return true;
}
}
else {
if (info.current !== info.then) {
update(info.then, 1, info.value, promise);
return true;
}
info.resolved = promise;
}
}
const globals = (typeof window !== 'undefined'
? window
: typeof globalThis !== 'undefined'
? globalThis
: global);
function destroy_block(block, lookup) {
block.d(1);
lookup.delete(block.key);
}
function outro_and_destroy_block(block, lookup) {
transition_out(block, 1, 1, () => {
lookup.delete(block.key);
});
}
function fix_and_destroy_block(block, lookup) {
block.f();
destroy_block(block, lookup);
}
function fix_and_outro_and_destroy_block(block, lookup) {
block.f();
outro_and_destroy_block(block, lookup);
}
function update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list, lookup, node, destroy, create_each_block, next, get_context) {
let o = old_blocks.length;
let n = list.length;
let i = o;
const old_indexes = {};
while (i--)
old_indexes[old_blocks[i].key] = i;
const new_blocks = [];
const new_lookup = new Map();
const deltas = new Map();
i = n;
while (i--) {
const child_ctx = get_context(ctx, list, i);
const key = get_key(child_ctx);
let block = lookup.get(key);
if (!block) {
block = create_each_block(key, child_ctx);
block.c();
}
else if (dynamic) {
block.p(child_ctx, dirty);
}
new_lookup.set(key, new_blocks[i] = block);
if (key in old_indexes)
deltas.set(key, Math.abs(i - old_indexes[key]));
}
const will_move = new Set();
const did_move = new Set();
function insert(block) {
transition_in(block, 1);
block.m(node, next);
lookup.set(block.key, block);
next = block.first;
n--;
}
while (o && n) {
const new_block = new_blocks[n - 1];
const old_block = old_blocks[o - 1];
const new_key = new_block.key;
const old_key = old_block.key;
if (new_block === old_block) {
// do nothing
next = new_block.first;
o--;
n--;
}
else if (!new_lookup.has(old_key)) {
// remove old block
destroy(old_block, lookup);
o--;
}
else if (!lookup.has(new_key) || will_move.has(new_key)) {
insert(new_block);
}
else if (did_move.has(old_key)) {
o--;
}
else if (deltas.get(new_key) > deltas.get(old_key)) {
did_move.add(new_key);
insert(new_block);
}
else {
will_move.add(old_key);
o--;
}
}
while (o--) {
const old_block = old_blocks[o];
if (!new_lookup.has(old_block.key))
destroy(old_block, lookup);
}
while (n)
insert(new_blocks[n - 1]);
return new_blocks;
}
function validate_each_keys(ctx, list, get_context, get_key) {
const keys = new Set();
for (let i = 0; i < list.length; i++) {
const key = get_key(get_context(ctx, list, i));
if (keys.has(key)) {
throw new Error(`Cannot have duplicate keys in a keyed each`);
}
keys.add(key);
}
}
function get_spread_update(levels, updates) {
const update = {};
const to_null_out = {};
const accounted_for = { $$scope: 1 };
let i = levels.length;
while (i--) {
const o = levels[i];
const n = updates[i];
if (n) {
for (const key in o) {
if (!(key in n))
to_null_out[key] = 1;
}
for (const key in n) {
if (!accounted_for[key]) {
update[key] = n[key];
accounted_for[key] = 1;
}
}
levels[i] = n;
}
else {
for (const key in o) {
accounted_for[key] = 1;
}
}
}
for (const key in to_null_out) {
if (!(key in update))
update[key] = undefined;
}
return update;
}
function get_spread_object(spread_props) {
return typeof spread_props === 'object' && spread_props !== null ? spread_props : {};
}
// source: https://html.spec.whatwg.org/multipage/indices.html
const boolean_attributes = new Set([
'allowfullscreen',
'allowpaymentrequest',
'async',
'autofocus',
'autoplay',
'checked',
'controls',
'default',
'defer',
'disabled',
'formnovalidate',
'hidden',
'ismap',
'loop',
'multiple',
'muted',
'nomodule',
'novalidate',
'open',
'playsinline',
'readonly',
'required',
'reversed',
'selected'
]);
const invalid_attribute_name_character = /[\s'">/=\u{FDD0}-\u{FDEF}\u{FFFE}\u{FFFF}\u{1FFFE}\u{1FFFF}\u{2FFFE}\u{2FFFF}\u{3FFFE}\u{3FFFF}\u{4FFFE}\u{4FFFF}\u{5FFFE}\u{5FFFF}\u{6FFFE}\u{6FFFF}\u{7FFFE}\u{7FFFF}\u{8FFFE}\u{8FFFF}\u{9FFFE}\u{9FFFF}\u{AFFFE}\u{AFFFF}\u{BFFFE}\u{BFFFF}\u{CFFFE}\u{CFFFF}\u{DFFFE}\u{DFFFF}\u{EFFFE}\u{EFFFF}\u{FFFFE}\u{FFFFF}\u{10FFFE}\u{10FFFF}]/u;
// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
// https://infra.spec.whatwg.org/#noncharacter
function spread(args, classes_to_add) {
const attributes = Object.assign({}, ...args);
if (classes_to_add) {
if (attributes.class == null) {
attributes.class = classes_to_add;
}
else {
attributes.class += ' ' + classes_to_add;
}
}
let str = '';
Object.keys(attributes).forEach(name => {
if (invalid_attribute_name_character.test(name))
return;
const value = attributes[name];
if (value === true)
str += " " + name;
else if (boolean_attributes.has(name.toLowerCase())) {
if (value)
str += " " + name;
}
else if (value != null) {
str += ` ${name}="${String(value).replace(/"/g, '"').replace(/'/g, ''')}"`;
}
});
return str;
}
const escaped = {
'"': '"',
"'": ''',
'&': '&',
'<': '<',
'>': '>'
};
function escape(html) {
return String(html).replace(/["'&<>]/g, match => escaped[match]);
}
function each(items, fn) {
let str = '';
for (let i = 0; i < items.length; i += 1) {
str += fn(items[i], i);
}
return str;
}
const missing_component = {
$$render: () => ''
};
function validate_component(component, name) {
if (!component || !component.$$render) {
if (name === 'svelte:component')
name += ' this={...}';
throw new Error(`<${name}> is not a valid SSR component. You may need to review your build config to ensure that dependencies are compiled, rather than imported as pre-compiled modules`);
}
return component;
}
function debug(file, line, column, values) {
console.log(`{@debug} ${file ? file + ' ' : ''}(${line}:${column})`); // eslint-disable-line no-console
console.log(values); // eslint-disable-line no-console
return '';
}
let on_destroy;
function create_ssr_component(fn) {
function $$render(result, props, bindings, slots) {
const parent_component = current_component;
const $$ = {
on_destroy,
context: new Map(parent_component ? parent_component.$$.context : []),
// these will be immediately discarded
on_mount: [],
before_update: [],
after_update: [],
callbacks: blank_object()
};
set_current_component({ $$ });
const html = fn(result, props, bindings, slots);
set_current_component(parent_component);
return html;
}
return {
render: (props = {}, options = {}) => {
on_destroy = [];
const result = { title: '', head: '', css: new Set() };
const html = $$render(result, props, {}, options);
run_all(on_destroy);
return {
html,
css: {
code: Array.from(result.css).map(css => css.code).join('\n'),
map: null // TODO
},
head: result.title + result.head
};
},
$$render
};
}
function add_attribute(name, value, boolean) {
if (value == null || (boolean && !value))
return '';
return ` ${name}${value === true ? '' : `=${typeof value === 'string' ? JSON.stringify(escape(value)) : `"${value}"`}`}`;
}
function add_classes(classes) {
return classes ? ` class="${classes}"` : ``;
}
function bind(component, name, callback) {
const index = component.$$.props[name];
if (index !== undefined) {
component.$$.bound[index] = callback;
callback(component.$$.ctx[index]);
}
}
function create_component(block) {
block && block.c();
}
function claim_component(block, parent_nodes) {
block && block.l(parent_nodes);
}
function mount_component(component, target, anchor) {
const { fragment, on_mount, on_destroy, after_update } = component.$$;
fragment && fragment.m(target, anchor);
// onMount happens before the initial afterUpdate
add_render_callback(() => {
const new_on_destroy = on_mount.map(run).filter(is_function);
if (on_destroy) {
on_destroy.push(...new_on_destroy);
}
else {
// Edge case - component was destroyed immediately,
// most likely as a result of a binding initialising
run_all(new_on_destroy);
}
component.$$.on_mount = [];
});
after_update.forEach(add_render_callback);
}
function destroy_component(component, detaching) {
const $$ = component.$$;
if ($$.fragment !== null) {
run_all($$.on_destroy);
$$.fragment && $$.fragment.d(detaching);
// TODO null out other refs, including component.$$ (but need to
// preserve final state?)
$$.on_destroy = $$.fragment = null;
$$.ctx = [];
}
}
function make_dirty(component, i) {
if (component.$$.dirty[0] === -1) {
dirty_components.push(component);
schedule_update();
component.$$.dirty.fill(0);
}
component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
}
function init(component, options, instance, create_fragment, not_equal, props, dirty = [-1]) {
const parent_component = current_component;
set_current_component(component);
const prop_values = options.props || {};
const $$ = component.$$ = {
fragment: null,
ctx: null,
// state
props,
update: noop,
not_equal,
bound: blank_object(),
// lifecycle
on_mount: [],
on_destroy: [],
before_update: [],
after_update: [],
context: new Map(parent_component ? parent_component.$$.context : []),
// everything else
callbacks: blank_object(),
dirty,
skip_bound: false
};
let ready = false;
$$.ctx = instance
? instance(component, prop_values, (i, ret, ...rest) => {
const value = rest.length ? rest[0] : ret;
if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
if (!$$.skip_bound && $$.bound[i])
$$.bound[i](value);
if (ready)
make_dirty(component, i);
}
return ret;
})
: [];
$$.update();
ready = true;
run_all($$.before_update);
// `false` as a special case of no DOM component
$$.fragment = create_fragment ? create_fragment($$.ctx) : false;
if (options.target) {
if (options.hydrate) {
const nodes = children(options.target);
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
$$.fragment && $$.fragment.l(nodes);
nodes.forEach(detach);
}
else {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
$$.fragment && $$.fragment.c();
}
if (options.intro)
transition_in(component.$$.fragment);
mount_component(component, options.target, options.anchor);
flush();
}
set_current_component(parent_component);
}
let SvelteElement;
if (typeof HTMLElement === 'function') {
SvelteElement = class extends HTMLElement {
constructor() {
super();
this.attachShadow({ mode: 'open' });
}
connectedCallback() {
// @ts-ignore todo: improve typings
for (const key in this.$$.slotted) {
// @ts-ignore todo: improve typings
this.appendChild(this.$$.slotted[key]);
}
}
attributeChangedCallback(attr, _oldValue, newValue) {
this[attr] = newValue;
}
$destroy() {
destroy_component(this, 1);
this.$destroy = noop;
}
$on(type, callback) {
// TODO should this delegate to addEventListener?
const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
callbacks.push(callback);
return () => {
const index = callbacks.indexOf(callback);
if (index !== -1)
callbacks.splice(index, 1);
};
}
$set($$props) {
if (this.$$set && !is_empty($$props)) {
this.$$.skip_bound = true;
this.$$set($$props);
this.$$.skip_bound = false;
}
}
};
}
class SvelteComponent {
$destroy() {
destroy_component(this, 1);
this.$destroy = noop;
}
$on(type, callback) {
const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
callbacks.push(callback);
return () => {
const index = callbacks.indexOf(callback);
if (index !== -1)
callbacks.splice(index, 1);
};
}
$set($$props) {
if (this.$$set && !is_empty($$props)) {
this.$$.skip_bound = true;
this.$$set($$props);
this.$$.skip_bound = false;
}
}
}
function dispatch_dev(type, detail) {
document.dispatchEvent(custom_event(type, Object.assign({ version: '3.25.0' }, detail)));
}
function append_dev(target, node) {
dispatch_dev("SvelteDOMInsert", { target, node });
append(target, node);
}
function insert_dev(target, node, anchor) {
dispatch_dev("SvelteDOMInsert", { target, node, anchor });
insert(target, node, anchor);
}
function detach_dev(node) {
dispatch_dev("SvelteDOMRemove", { node });
detach(node);
}
function detach_between_dev(before, after) {
while (before.nextSibling && before.nextSibling !== after) {
detach_dev(before.nextSibling);
}
}
function detach_before_dev(after) {
while (after.previousSibling) {
detach_dev(after.previousSibling);
}
}
function detach_after_dev(before) {
while (before.nextSibling) {
detach_dev(before.nextSibling);
}
}
function listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation) {
const modifiers = options === true ? ["capture"] : options ? Array.from(Object.keys(options)) : [];
if (has_prevent_default)
modifiers.push('preventDefault');
if (has_stop_propagation)
modifiers.push('stopPropagation');
dispatch_dev("SvelteDOMAddEventListener", { node, event, handler, modifiers });
const dispose = listen(node, event, handler, options);
return () => {
dispatch_dev("SvelteDOMRemoveEventListener", { node, event, handler, modifiers });
dispose();
};
}
function attr_dev(node, attribute, value) {
attr(node, attribute, value);
if (value == null)
dispatch_dev("SvelteDOMRemoveAttribute", { node, attribute });
else
dispatch_dev("SvelteDOMSetAttribute", { node, attribute, value });
}
function prop_dev(node, property, value) {
node[property] = value;
dispatch_dev("SvelteDOMSetProperty", { node, property, value });
}
function dataset_dev(node, property, value) {
node.dataset[property] = value;
dispatch_dev("SvelteDOMSetDataset", { node, property, value });
}
function set_data_dev(text, data) {
data = '' + data;
if (text.wholeText === data)
return;
dispatch_dev("SvelteDOMSetData", { node: text, data });
text.data = data;
}
function validate_each_argument(arg) {
if (typeof arg !== 'string' && !(arg && typeof arg === 'object' && 'length' in arg)) {
let msg = '{#each} only iterates over array-like objects.';
if (typeof Symbol === 'function' && arg && Symbol.iterator in arg) {
msg += ' You can use a spread to convert this iterable into an array.';
}
throw new Error(msg);
}
}
function validate_slots(name, slot, keys) {
for (const slot_key of Object.keys(slot)) {
if (!~keys.indexOf(slot_key)) {
console.warn(`<${name}> received an unexpected slot "${slot_key}".`);
}
}
}
class SvelteComponentDev extends SvelteComponent {
constructor(options) {
if (!options || (!options.target && !options.$$inline)) {
throw new Error(`'target' is a required option`);
}
super();
}
$destroy() {
super.$destroy();
this.$destroy = () => {
console.warn(`Component was already destroyed`); // eslint-disable-line no-console
};
}
$capture_state() { }
$inject_state() { }
}
function loop_guard(timeout) {
const start = Date.now();
return () => {
if (Date.now() - start > timeout) {
throw new Error(`Infinite loop detected`);
}
};
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))
/***/ }),
/***/ "./node_modules/svelte/store/index.mjs":
/*!*********************************************!*\
!*** ./node_modules/svelte/store/index.mjs ***!
\*********************************************/
/*! exports provided: get, derived, readable, writable */
/*! exports used: derived, get, writable */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return derived; });
/* unused harmony export readable */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return writable; });
/* harmony import */ var _internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "b", function() { return _internal__WEBPACK_IMPORTED_MODULE_0__["x"]; });
const subscriber_queue = [];
/**
* Creates a `Readable` store that allows reading by subscription.
* @param value initial value
* @param {StartStopNotifier}start start and stop notifications for subscriptions
*/
function readable(value, start) {
return {
subscribe: writable(value, start).subscribe
};
}
/**
* Create a `Writable` store that allows both updating and reading by subscription.
* @param {*=}value initial value
* @param {StartStopNotifier=}start start and stop notifications for subscriptions
*/
function writable(value, start = _internal__WEBPACK_IMPORTED_MODULE_0__[/* noop */ "F"]) {
let stop;
const subscribers = [];
function set(new_value) {
if (Object(_internal__WEBPACK_IMPORTED_MODULE_0__[/* safe_not_equal */ "H"])(value, new_value)) {
value = new_value;
if (stop) { // store is ready
const run_queue = !subscriber_queue.length;
for (let i = 0; i < subscribers.length; i += 1) {
const s = subscribers[i];
s[1]();
subscriber_queue.push(s, value);
}
if (run_queue) {
for (let i = 0; i < subscriber_queue.length; i += 2) {
subscriber_queue[i][0](subscriber_queue[i + 1]);
}
subscriber_queue.length = 0;
}
}
}
}
function update(fn) {
set(fn(value));
}
function subscribe(run, invalidate = _internal__WEBPACK_IMPORTED_MODULE_0__[/* noop */ "F"]) {
const subscriber = [run, invalidate];
subscribers.push(subscriber);
if (subscribers.length === 1) {
stop = start(set) || _internal__WEBPACK_IMPORTED_MODULE_0__[/* noop */ "F"];
}
run(value);
return () => {
const index = subscribers.indexOf(subscriber);
if (index !== -1) {
subscribers.splice(index, 1);
}
if (subscribers.length === 0) {
stop();
stop = null;
}
};
}
return { set, update, subscribe };
}
function derived(stores, fn, initial_value) {
const single = !Array.isArray(stores);
const stores_array = single
? [stores]
: stores;
const auto = fn.length < 2;
return readable(initial_value, (set) => {
let inited = false;
const values = [];
let pending = 0;
let cleanup = _internal__WEBPACK_IMPORTED_MODULE_0__[/* noop */ "F"];
const sync = () => {
if (pending) {
return;
}
cleanup();
const result = fn(single ? values[0] : values, set);
if (auto) {
set(result);
}
else {
cleanup = Object(_internal__WEBPACK_IMPORTED_MODULE_0__[/* is_function */ "C"])(result) ? result : _internal__WEBPACK_IMPORTED_MODULE_0__[/* noop */ "F"];
}
};
const unsubscribers = stores_array.map((store, i) => Object(_internal__WEBPACK_IMPORTED_MODULE_0__[/* subscribe */ "M"])(store, (value) => {
values[i] = value;
pending &= ~(1 << i);
if (inited) {
sync();
}
}, () => {
pending |= (1 << i);
}));
inited = true;
sync();
return function stop() {
Object(_internal__WEBPACK_IMPORTED_MODULE_0__[/* run_all */ "G"])(unsubscribers);
cleanup();
};
});
}
/***/ }),
/***/ "./node_modules/vue/dist/vue.runtime.esm-bundler.js":
/*!**********************************************************!*\
!*** ./node_modules/vue/dist/vue.runtime.esm-bundler.js ***!
\**********************************************************/
/*! exports provided: customRef, isProxy, isReactive, isReadonly, isRef, markRaw, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, camelize, capitalize, toDisplayString, BaseTransition, Comment, Fragment, KeepAlive, Static, Suspense, Teleport, Text, callWithAsyncErrorHandling, callWithErrorHandling, cloneVNode, computed, createBlock, createCommentVNode, createHydrationRenderer, createRenderer, createSlots, createStaticVNode, createTextVNode, createVNode, defineAsyncComponent, defineComponent, devtools, getCurrentInstance, getTransitionRawChildren, h, handleError, inject, isVNode, mergeProps, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onUnmounted, onUpdated, openBlock, popScopeId, provide, pushScopeId, queuePostFlushCb, registerRuntimeCompiler, renderList, renderSlot, resolveComponent, resolveDirective, resolveDynamicComponent, resolveTransitionHooks, setBlockTracking, setDevtoolsHook, setTransitionHooks, ssrContextKey, ssrUtils, toHandlers, transformVNodeArgs, useSSRContext, useTransitionState, version, warn, watch, watchEffect, withCtx, withDirectives, withScopeId, Transition, TransitionGroup, createApp, createSSRApp, hydrate, render, useCssModule, useCssVars, vModelCheckbox, vModelDynamic, vModelRadio, vModelSelect, vModelText, vShow, withKeys, withModifiers, compile */
/*! exports used: reactive, watchEffect */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* unused harmony export compile */
/* harmony import */ var _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @vue/runtime-dom */ "./node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js");
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__["a"]; });
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "b", function() { return _vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__["d"]; });
/* harmony import */ var _vue_shared__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @vue/shared */ "./node_modules/@vue/shared/dist/shared.esm-bundler.js");
function initDev() {
const target = Object(_vue_shared__WEBPACK_IMPORTED_MODULE_1__[/* getGlobalThis */ "i"])();
target.__VUE__ = true;
Object(_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__[/* setDevtoolsHook */ "b"])(target.__VUE_DEVTOOLS_GLOBAL_HOOK__);
{
console.info(`You are running a development build of Vue.\n` +
`Make sure to use the production build (*.prod.js) when deploying for production.`);
}
}
// This entry exports the runtime only, and is built as
( true) && initDev();
const compile = () => {
if ((true)) {
Object(_vue_runtime_dom__WEBPACK_IMPORTED_MODULE_0__[/* warn */ "c"])(`Runtime compilation is not supported in this build of Vue.` +
( ` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".`
) /* should not happen */);
}
};
/***/ }),
/***/ "./node_modules/webpack/buildin/global.js":
/*!***********************************!*\
!*** (webpack)/buildin/global.js ***!
\***********************************/
/*! no static exports found */
/*! all exports used */
/***/ (function(module, exports) {
var g;
// This works in non-strict mode
g = (function() {
return this;
})();
try {
// This works if eval is allowed (see CSP)
g = g || new Function("return this")();
} catch (e) {
// This works if the window reference is available
if (typeof window === "object") g = window;
}
// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}
module.exports = g;
/***/ }),
/***/ "./util/dom/element.ts":
/*!*****************************!*\
!*** ./util/dom/element.ts ***!
\*****************************/
/*! exports provided: 检测元素状态, getSelectors */
/*! exports used: 检测元素状态 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return 检测元素状态; });
/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../网页笔记/util */ "./网页笔记/util.ts");
function 检测元素状态(selector, 出现 = () => {}, 变化 = () => {}, 消失 = () => {}) {
let status = false;
let html = "";
setInterval(() => {
const el = document.querySelector(selector);
if (status && el && el.innerHTML !== html) {
html = el.innerHTML;
变化(el);
}
if (el && !status) {
status = true;
出现(el);
} else if (!el && status) {
status = false;
消失();
}
}, 100);
}
/***/ }),
/***/ "./util/dom/剪贴板.ts":
/*!*************************!*\
!*** ./util/dom/剪贴板.ts ***!
\*************************/
/*! exports provided: copy */
/*! exports used: copy */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return copy; });
const copy = str => {
// 第一种
return navigator.clipboard.writeText(str);
};
/***/ }),
/***/ "./更好的我来导出/index.user.ts":
/*!*******************************!*\
!*** ./更好的我来导出/index.user.ts ***!
\*******************************/
/*! exports provided: 我来md导出 */
/*! all exports used */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "我来md导出", function() { return 我来md导出; });
/* harmony import */ var ajax_hook__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ajax-hook */ "./node_modules/ajax-hook/index.js");
/* harmony import */ var _util_dom_element__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../util/dom/element */ "./util/dom/element.ts");
/* harmony import */ var _util_dom___WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../util/dom/剪贴板 */ "./util/dom/剪贴板.ts");
// ==UserScript==
// @name 更好的我来导出
// @namespace https://shenzilong.cn/
// @version 1.0.3
// @description 从我来导出markdown 文档
// @author 崮生 admin@shenzilong.cn
// @include https://www.wolai.com/*
// @grant unsafeWindow
// @grant GM.setValue
// @grant GM.getValue
// @grant GM.xmlHttpRequest
// ==/UserScript==
const _n = "\n\n"; // const _n = "\n";
var 我来md导出;
(function (我来md导出) {
async function toMarkdown(p) {
let mdText = "";
const blocks = Object.keys(p.data.block).map(k => p.data.block[k]).map(el => el.value);
console.log("[blocks]", blocks);
const page = findPage(blocks);
if (!page) {
throw "没有寻找到page块";
}
mdText += await nodeToMarkdown(page, p);
return mdText;
}
我来md导出.toMarkdown = toMarkdown;
function findPage(p) {
return p.find(el => el.type === "page");
}
/** 存储所有节点解析器 */
const nodeParers = [];
/** 对 子节点和父节点的关系 进行处理，因为不同父子节点的组织方式可能不一样 */
const sub_nodeParers = [];
function registerNodeParer(...parers) {
nodeParers.push(...parers);
}
我来md导出.registerNodeParer = registerNodeParer;
function registerSubNodeParer(...parers) {
sub_nodeParers.push(...parers);
}
我来md导出.registerSubNodeParer = registerSubNodeParer;
async function nodeToMarkdown(p, pageChunkRes) {
const parer = nodeParers.find(el => el.check(p, pageChunkRes));
if (parer) {
const md_str = await parer.parer(p, pageChunkRes);
if (p.sub_nodes.length) {
const sub_node_parer = sub_nodeParers.find(el => el.check(p, pageChunkRes));
if (sub_node_parer) {
return await sub_node_parer.parer(md_str, p, pageChunkRes);
} else {
console.log(`[没有对应的结构解析器 ${p.type}]`, p);
}
}
return md_str;
} else {
console.log(`[没有对应的解析器 ${p.type}]`, p);
return `--- 没有对应的解析器 -> ${p.type} ---`;
}
}
我来md导出.nodeToMarkdown = nodeToMarkdown;
/** 对块的title属性进行解析 */
function NodeTitleToMarkdown(p) {
if (!p) {
return "";
}
return p.map(el => {
const text = el[0];
if (el.length === 1) {
return text;
} else {
const 修饰 = el[1];
if (修饰.length === 0) {
/** 无修饰啥也不做 */
}
let _text = text;
for (const mode of 修饰) {
if (mode[0] === "Link") {
_text = `[${_text}](${mode[1]})`;
} else if (mode[0] === "BiLink"
/** 我来内部链接 */
) {
const workspace_url = getWorkUrl();
_text = `[${_text}](${workspace_url}${mode[2]})`;
} else if (mode[0] === "<>"
/** 行内代码块 */
) {
_text = `\`${_text}\``;
} else if (mode[0] === "B"
/** 粗体 */
) {
_text = `**${_text}**`;
} else if (mode[0] === "h"
/** 字体以及背景颜色 */
) {
/** 这里在某些选项下可以选择开启转换 */
_text = _text;
} else if (mode[0] === "i"
/** 斜体 */
) {
_text = `*${_text}*`;
} else if (mode[0] === "U"
/** 下划线 */
) {
/** 这里在某些选项下可以选择开启转换 */
_text = `${_text}`;
} else if (mode[0] === "S"
/** 删除线 */
) {
_text = `~~${_text}~~`;
} else if (mode[0] === "Equation"
/** 公式 */
) {
_text = `$${_text}$`;
} else {
/** 这里mode的类型应当始终为 never */
mode;
_text = `<未知类型 ${mode[0]}>`;
console.log(`<未知类型 ${mode[0]}>`, mode, 修饰, el);
}
}
return _text;
}
}).join("");
}
我来md导出.NodeTitleToMarkdown = NodeTitleToMarkdown;
/** 当前打开页面的工作空间链接 */
function getWorkUrl() {
return location.href.match(/.*?wolai\.com\/.*?\//)[0];
}
我来md导出.getWorkUrl = getWorkUrl;
})(我来md导出 || (我来md导出 = {}));
const NodeTitleToMarkdown = 我来md导出.NodeTitleToMarkdown;
我来md导出.registerNodeParer({
check: p => p.type === "quote",
async parer(p) {
return `> ${NodeTitleToMarkdown(p.attributes.title)}`;
}
},
/** 对各级标题进行处理
* 对bullList节点进行处理 */
(() => {
const header = {
bullList: "-",
header: "#",
midHeader: "##",
subHeader: "###",
tinyHeader: "####"
};
return {
check: p => header.hasOwnProperty(p.type),
async parer(p) {
const t = header[p.type];
return `${t} ${NodeTitleToMarkdown(p.attributes.title)}`;
}
};
})(),
/** 数字列表的解析 */
{
check: p => p.type === "enumList",
async parer(p, pageChunkRes) {
let l = 0;
const brothers = sub_nodeToNode(pageChunkRes.data.block[p.parent_id].value, pageChunkRes);
let i = brothers.findIndex(el => el.id === p.id);
while (i >= 0 && brothers[i].type === "enumList") {
i -= 1;
l += 1;
} // const l = pageChunkRes.data.block[p.parent_id].value.sub_nodes.findIndex((id) => id === p.id) + 1;
return `${l}. ${NodeTitleToMarkdown(p.attributes.title)}`;
}
},
/** 折叠列表的解析 */
{
check: p => p.type === "toggleList",
async parer(p, pageChunkRes) {
return NodeTitleToMarkdown(p.attributes.title);
}
},
/** 对书签的解析， **这里到时候应该要调成可控的** */
{
check: p => p.type === "bookmark",
async parer(p) {
var _rich$thumbnail;
const rich = p.attributes.rich_media[0];
const description = rich.description || "";
const thumbnail =
/** 和我来一样有描述信息才显示缩略图 */
description && (rich === null || rich === void 0 ? void 0 : (_rich$thumbnail = rich.thumbnail) === null || _rich$thumbnail === void 0 ? void 0 : _rich$thumbnail.length) ? `{:height="60px" width="60px"}` : "";
return `> [{:height="30px" width="30px"} 崮生 一些随笔](${p.attributes.source} "${description}") ${description} ${thumbnail}`;
}
},
/** 对嵌入内容的解析， **这里到时候应该要调成可控的** */
{
check: p => ["embed", "bilibiliVideo", "tencentVideo", "youkuVideo", "youtubeVideo"].includes(p.type),
async parer(p) {
return `<iframe src="${p.attributes.embedLink}"></iframe>`;
}
},
/** 对着重文字的解析 */
{
check: p => ["callout"].includes(p.type),
async parer(p) {
return `<em>${我来md导出.NodeTitleToMarkdown(p.attributes.title)}</em>`;
}
},
/** 分割线 */
{
check: p => ["divider"].includes(p.type),
async parer(p) {
return `---`;
}
},
/** 文件 */
{
check: p => ["file"].includes(p.type),
async parer(p) {
/** TODO 这里需要获取签名才能访问 */
const src = `https://secure-static.wolai.com/${encodeURIComponent(p.attributes.file[0])}`;
return `[file:${p.attributes.alias[0]}](${src}})`;
}
},
/** 公式 */
{
check: p => ["blockEquation"].includes(p.type),
async parer(p) {
return `$$\n${p.attributes.title.join("\n")}\n$$`;
}
},
/** 模板按钮 */
{
check: p => ["templateButton"].includes(p.type),
async parer(p) {
/** TODO 暂不解析模板按钮 */
return ``;
}
},
/** 表格解析器 */
{
check: p => ["simpleTable"].includes(p.type),
async parer(p) {
/** TODO 暂不解析模板按钮 */
const cells = JSON.parse(p.attributes.cells);
let md_str = "";
/** 遍历行 */
for (let i = 0; i < cells[0].column.length; i++) {
if (i === 1) {
/** 标题栏的分隔 */
md_str += "|" + cells.map(el => "-").join("|") + "|\n";
}
md_str += "|";
/** 遍历列 */
for (let j = 0; j < cells.length; j++) {
/** 当前遍历到的元素 */
const cur = cells[j].column[i];
md_str += 我来md导出.NodeTitleToMarkdown(cur.attributes.title) + "|";
}
md_str += "\n";
}
return md_str;
}
}, {
check: p => p.type === "text",
async parer(p) {
return `${NodeTitleToMarkdown(p.attributes.title)}`;
}
}, {
check: p => p.type === "row" || p.type === "column",
async parer(p, pageChunkRes) {
const sub_nodes = p.sub_nodes.map(id => pageChunkRes.data.block[id]);
let mdText = ``;
for (const el of sub_nodes) {
mdText += (await 我来md导出.nodeToMarkdown(el.value, pageChunkRes)) + _n;
}
return mdText;
}
}, {
check: p => p.type === "code",
async parer(p, pageChunkRes) {
return `\`\`\`${p.attributes.language}\n${NodeTitleToMarkdown(p.attributes.title)}\n\`\`\``;
}
}, {
check: p => p.type === "image",
async parer(p, pageChunkRes) {
/** 此处需要在浏览器内才能正常运行 */
const src = document.querySelector(`#id-${p.id} img`).getAttribute("src");
return ``; // TODO 描述应该要去获取到
}
}, {
check: p => p.type === "page",
async parer(p, pageChunkRes) {
const workspace_url = 我来md导出.getWorkUrl();
if (p.id === Object.keys(pageChunkRes.data.block)[0]) {
/** 顶层块 也就是当前页面块 */
return `# [${NodeTitleToMarkdown(p.attributes.title)}](${workspace_url}${p.id})`;
} else {
/** 页面内引用其他页面的块 */
return `[${NodeTitleToMarkdown(p.attributes.title)}](${workspace_url}${p.id})`;
}
}
}, {
check: p => p.type === "todoList",
async parer(p, pageChunkRes) {
return `[${p.attributes.checked === "yes" ? "x" : " "}] ${NodeTitleToMarkdown(p.attributes.title)}`;
}
});
function sub_nodeToNode(p, pageChunkRes) {
return p.sub_nodes.map(id => pageChunkRes.data.block[id].value);
}
我来md导出.registerSubNodeParer(
/** 对页面下面的一级节点进行处理 */
{
check: p => p.type === "page",
async parer(md_str, p, pageChunkRes) {
return md_str + "\n\n" + (await Promise.all(sub_nodeToNode(p, pageChunkRes).map(p => 我来md导出.nodeToMarkdown(p, pageChunkRes)))).join("\n\n");
}
},
/** 对列表类的层级进行处理 */
{
check: p => ["bullList", "enumList", "todoList"].includes(p.type),
async parer(md_str, p, pageChunkRes) {
/** 获取一个节点有多少父级 */
function getNodeNumberOfLayers(p, pageChunkRes) {
let l = 0;
let cur = p;
while ((_cur = cur) === null || _cur === void 0 ? void 0 : _cur.parent_id) {
var _cur, _pageChunkRes$data$bl, _cur2;
l++;
cur = (_pageChunkRes$data$bl = pageChunkRes.data.block[cur.parent_id]) === null || _pageChunkRes$data$bl === void 0 ? void 0 : _pageChunkRes$data$bl.value;
if (((_cur2 = cur) === null || _cur2 === void 0 ? void 0 : _cur2.type) === "toggleList") {
/** 不是相同的结构了，层级关系算到这里位置，更外层的层级关系交给该结构自行处理 */
l++;
/** 因为上面算了页面，这里将 toggleList 当做和页面一样看待 */
break;
}
}
/** 不算页面这一级 */
return l - 1;
}
const l = getNodeNumberOfLayers(p, pageChunkRes) - 1; // console.log(l,p,md_str);
const md_str_List = (await Promise.all(sub_nodeToNode(p, pageChunkRes).map(p => 我来md导出.nodeToMarkdown(p, pageChunkRes)))).map(md_str => `${"".padEnd(
/** 列表内的是当前节点的子节点而l是当前节点的层级，所以这里要+1 */
l + 1, "\t")}${md_str}`);
return `${md_str}${md_str_List.length ? "\n" + md_str_List.join("\n") : ""}`;
}
},
/** 对折叠列表类的层级进行处理 */
{
check: p => ["toggleList"].includes(p.type),
async parer(md_str, p, pageChunkRes) {
const md_str_List = await Promise.all(sub_nodeToNode(p, pageChunkRes).map(p => 我来md导出.nodeToMarkdown(p, pageChunkRes)));
return `<details>
<summary>${md_str}</summary>
${md_str_List.join(_n)}
</details>`;
}
});
let curData = null;
Object(ajax_hook__WEBPACK_IMPORTED_MODULE_0__[/* proxy */ "a"])({
//请求发起前进入
onRequest: (config, handler) => {
// console.log("[💚开始请求]", config.url);
// config.url = urlHandler(config.url);
/** 关闭 withCredentials 避免触发跨域 */
// config.withCredentials = false;
handler.next(config);
},
//请求发生错误时进入，比如超时；注意，不包括http状态码错误，如404仍然会认为请求成功
onError: (err, handler) => {
handler.next(err);
},
//请求成功后进入
onResponse: (response, handler) => {
handler.next(response);
if (response.config.url.endsWith("transaction/getPageChunks")) {
curData = response.response;
}
}
});
Object(_util_dom_element__WEBPACK_IMPORTED_MODULE_1__[/* 检测元素状态 */ "a"])('div.oqjLp:nth-child(3) > div:nth-child(1)', el => {
console.log("[ el]", el);
const btn = el.nextElementSibling;
const newBtn = btn.cloneNode(true);
btn.parentElement.appendChild(newBtn);
newBtn.querySelectorAll("span")[1].textContent = `[✨] 导出Markdown`;
newBtn.addEventListener("click", async () => {
if (curData === null) {
return alert("没有获取到当前页面数据，您可以尝试刷新重试。");
}
const res = JSON.parse(curData);
const md = await 我来md导出.toMarkdown(res);
const blob = new Blob([md], {
type: "text/plain;charset=utf-8"
});
const downloadUrl = URL.createObjectURL(blob);
console.log(`[markdown:${downloadUrl}]\n----\n`, md);
console.log("[copy(md)]", Object(_util_dom___WEBPACK_IMPORTED_MODULE_2__[/* copy */ "a"])(md));
alert("复制成功");
});
});
/** 替换 windows 上的 xml 对象 */
//@ts-ignore
unsafeWindow.XMLHttpRequest = XMLHttpRequest;
/***/ }),
/***/ "./网页笔记/config.ts":
/*!************************!*\
!*** ./网页笔记/config.ts ***!
\************************/
/*! exports provided: isDev, config, elementEdit, AllStoreName, default */
/*! exports used: AllStoreName, default, elementEdit, isDev */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return isDev; });
/* unused harmony export config */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return elementEdit; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return AllStoreName; });
/* harmony import */ var svelte_store__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/store */ "./node_modules/svelte/store/index.mjs");
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! vue */ "./node_modules/vue/dist/vue.runtime.esm-bundler.js");
/* harmony import */ var _ui_message__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ui/message */ "./网页笔记/ui/message.ts");
/** 是不是开发环境 */
const isDev = window.__llej__userjs__dev__ === true;
const config = Object(vue__WEBPACK_IMPORTED_MODULE_1__[/* reactive */ "a"])({
state: 0,
/** 是否开启编辑 */
elementEdit: isDev,
/** 服务器地址 */
serverIp: "https://shenzilong.cn/note/",
/** 页面的url */
locationUrl: decodeURIComponent(location.origin + location.pathname),
/** 存储登录凭证的 */
loginCredentials: "loginCredentials"
});
const elementEdit = Object(svelte_store__WEBPACK_IMPORTED_MODULE_0__[/* writable */ "c"])(config.elementEdit, set => {
Object(vue__WEBPACK_IMPORTED_MODULE_1__[/* watchEffect */ "b"])(() => {
set(config.elementEdit);
});
});
elementEdit.subscribe(value => {
config.elementEdit = value;
console.log('[value]', value);
});
Object(vue__WEBPACK_IMPORTED_MODULE_1__[/* watchEffect */ "b"])(() => {
console.log('[config.elementEdit]', config.elementEdit);
new _ui_message__WEBPACK_IMPORTED_MODULE_2__[/* Message */ "a"]({
msg: `${config.elementEdit ? "开启" : "关闭"}编辑模式`
}).autoHide();
});
/** 存储命令栈的地方 */
const AllStoreName = "_storeName_llej_" + config.locationUrl;
/* harmony default export */ __webpack_exports__["b"] = (config);
/***/ }),
/***/ "./网页笔记/fun/ajax.ts":
/*!**************************!*\
!*** ./网页笔记/fun/ajax.ts ***!
\**************************/
/*! exports provided: au_getJSON, _login, remote_register, remote_getStore, remote_setStore, remote_getAllStore */
/*! exports used: _login, remote_getStore, remote_register, remote_setStore */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* unused harmony export au_getJSON */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _login; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return remote_register; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return remote_getStore; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return remote_setStore; });
/* unused harmony export remote_getAllStore */
/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../config */ "./网页笔记/config.ts");
/* harmony import */ var _lib_store__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../lib/store */ "./网页笔记/lib/store.ts");
/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../util */ "./网页笔记/util.ts");
/** 用来识别身份的key */
let key = '';
/** 附带登录信息的ajax */
async function au_getJSON(url, data) {
if (data === undefined) data = {};
data.key = key ? key : await Object(_lib_store__WEBPACK_IMPORTED_MODULE_1__[/* getLocalItem */ "b"])(_config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].loginCredentials);
return Object(_util__WEBPACK_IMPORTED_MODULE_2__[/* getJSon */ "c"])(url, data);
}
/** 登录 */
async function _login(par) {
const res = await Object(_util__WEBPACK_IMPORTED_MODULE_2__[/* getJSon */ "c"])(_config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].serverIp + 'login', par);
if (res.body && res.body.length > 0) key = res.body;
Object(_lib_store__WEBPACK_IMPORTED_MODULE_1__[/* setLocalItem */ "c"])(_config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].loginCredentials, key);
return res;
}
/** 注册 */
async function remote_register(par) {
return await Object(_util__WEBPACK_IMPORTED_MODULE_2__[/* getJSon */ "c"])(_config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].serverIp + 'register', par);
}
/** 获取存储库 */
async function remote_getStore(par) {
return await au_getJSON(_config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].serverIp + 'getStore', par);
}
/** 设置存储库 */
async function remote_setStore(par) {
return await au_getJSON(_config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].serverIp + 'setStore', par);
}
/** 获取存储库 */
async function remote_getAllStore() {
return await au_getJSON(_config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].serverIp + 'getAllStore');
}
/***/ }),
/***/ "./网页笔记/fun/command.ts":
/*!*****************************!*\
!*** ./网页笔记/fun/command.ts ***!
\*****************************/
/*! exports provided: Command, deleteSelect, editSelect, closeEditSelect, addNote, Highlighted, CommandControl */
/*! exports used: CommandControl, Highlighted, addNote, closeEditSelect, deleteSelect, editSelect */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* unused harmony export Command */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return deleteSelect; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return editSelect; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return closeEditSelect; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return addNote; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return Highlighted; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return CommandControl; });
/* harmony import */ var _ui_message__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../ui/message */ "./网页笔记/ui/message.ts");
/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../util */ "./网页笔记/util.ts");
/* harmony import */ var _state_store__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../state/store */ "./网页笔记/state/store.ts");
/* harmony import */ var svelte_store__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! svelte/store */ "./node_modules/svelte/store/index.mjs");
/* harmony import */ var _state_highlighted_style__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../state/highlighted_style */ "./网页笔记/state/highlighted_style.ts");
/* harmony import */ var _lib_store__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../lib/store */ "./网页笔记/lib/store.ts");
/** 每一个命令都应该实现的东西 */
class Command {
constructor(
/** 命令执行的元素 */
select) {
this.selectEL = select;
}
/** 执行这个命令 */
do() {
return this;
}
/** 撤销这个命令 */
undo() {
return this;
}
/** 重新执行命令 */
redo() {
return this.do();
}
/** 将命令变成可以转化为json字符串的对象 */
toJSON() {
return {
selectEL: Object(_util__WEBPACK_IMPORTED_MODULE_1__[/* getSelectors */ "d"])(this.selectEL),
constructor: this.__proto__.constructor.name
};
}
/** 用于可以使用 toJSON 生成的数据重建功能效果 */
static 重建(obj) {
return new this(document.querySelector(obj.selectEL));
}
/** 加载commandJSON转变为命令,通过泛型来构造对象的方式 */
static load(obj, CLASS) {
return CLASS.重建(obj);
}
}
/** 删除一个元素 */
class deleteSelect extends Command {
do() {
this.selectEL_display = this.selectEL.style.display;
this.selectEL.style.display = "none";
return this;
}
undo() {
this.selectEL.style.display = this.selectEL_display;
return this;
}
}
/** 使元素可编辑 */
class editSelect extends Command {
do() {
this.selectEL_contentEditable = this.selectEL.contentEditable;
this.selectEL.contentEditable = "true";
return this;
}
undo() {
this.selectEL.contentEditable = this.selectEL_contentEditable;
return this;
}
}
/** 使元素不可编辑 */
class closeEditSelect extends Command {
do() {
this.selectEL_contentEditable = this.selectEL.contentEditable;
this.selectEL.contentEditable = "false";
return this;
}
undo() {
this.selectEL.contentEditable = this.selectEL_contentEditable;
return this;
}
}
/** 新增一个笔记 */
class addNote extends Command {
do() {
this.selectEL;
_state_store__WEBPACK_IMPORTED_MODULE_2__[/* note_list_store */ "a"].update(list => {
list.push({
point: this.selectEL,
content: "6666666"
});
return list;
});
return this;
}
undo() {
return this;
}
redo() {
return this;
}
}
/** 高亮功能 */
class Highlighted extends Command {
constructor(styleText) {
super();
this.styleText = styleText;
/** css 类名 */
this.className = `llej-page_notes-style-${_lib_store__WEBPACK_IMPORTED_MODULE_5__[/* curStore */ "a"].Highlighted_count++}`;
}
do() {
_state_highlighted_style__WEBPACK_IMPORTED_MODULE_4__[/* styleList */ "a"].update(r => {
return [...r, this.getRawStyleText()];
});
return this;
}
getRawStyleText() {
return `
.${this.className}{
${this.styleText}
}
`;
}
undo() {
_state_highlighted_style__WEBPACK_IMPORTED_MODULE_4__[/* styleList */ "a"].update(r => {
return r.filter(el => el !== this.getRawStyleText());
});
return this;
}
static 重建(obj) {
const r = new this(obj.styleText);
r.className = obj.className;
return r;
}
toJSON() {
return {
selectEL: "",
className: this.className,
styleText: this.styleText,
constructor: this.__proto__.constructor.name
};
}
}
/** 命令控制器 */
const CommandControl = {
commandStack: [],
backOutStack: [],
pushCommand(command) {
return this.commandStack.push(command);
},
run(command) {
try {
this.backOutStack.splice(0, this.backOutStack.length);
return this.pushCommand(command.do());
} catch (error) {
console.error("命令执行失败", command);
}
return -1;
},
backOut() {
if (this.commandStack.length === 0) {
_ui_message__WEBPACK_IMPORTED_MODULE_0__[/* Message */ "a"].getMessage({
msg: "命令栈已空，无法进行撤销"
}).autoHide();
return;
}
const command = this.commandStack.pop();
return this.backOutStack.push(command.undo());
},
reform() {
if (this.backOutStack.length === 0) {
_ui_message__WEBPACK_IMPORTED_MODULE_0__[/* Message */ "a"].getMessage({
msg: "撤销栈已空，无法进行重做"
}).autoHide();
return;
}
const command = this.backOutStack.pop();
return this.commandStack.push(command.redo());
},
/** 从json重建命令栈 */
loadCommandJSON(obj) {
Object(_util__WEBPACK_IMPORTED_MODULE_1__[/* log */ "e"])("-执行命令-", obj.constructor);
if (obj.constructor === "deleteSelect") return Command.load(obj, deleteSelect);
if (obj.constructor === "editSelect") return Command.load(obj, editSelect);
if (obj.constructor === "closeEditSelect") return Command.load(obj, closeEditSelect);
if (obj.constructor === "addNote") return Command.load(obj, addNote);
if (obj.constructor === "Highlighted") return Command.load(obj, Highlighted);
},
getCommandStackJSON() {
return JSON.stringify(this.commandStack);
},
loadCommandJsonAndRun(commandJSON) {
commandJSON.map(this.loadCommandJSON).forEach(command => this.run(command));
return true;
}
};
/***/ }),
/***/ "./网页笔记/fun/fun.ts":
/*!*************************!*\
!*** ./网页笔记/fun/fun.ts ***!
\*************************/
/*! exports provided: fun, KeyMap, saveChanges, loadChanges, outline, on_mouse, on_keydown, on_input, switchState */
/*! exports used: loadChanges, on_input, on_keydown, on_mouse, saveChanges */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* unused harmony export fun */
/* unused harmony export KeyMap */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return saveChanges; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return loadChanges; });
/* unused harmony export outline */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return on_mouse; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return on_keydown; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return on_input; });
/* unused harmony export switchState */
/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../config */ "./网页笔记/config.ts");
/* harmony import */ var _lib_store__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../lib/store */ "./网页笔记/lib/store.ts");
/* harmony import */ var _ui_message__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../ui/message */ "./网页笔记/ui/message.ts");
/* harmony import */ var _ajax__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./ajax */ "./网页笔记/fun/ajax.ts");
/* harmony import */ var _command__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./command */ "./网页笔记/fun/command.ts");
/* harmony import */ var _state_index__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../state/index */ "./网页笔记/state/index.ts");
/* harmony import */ var _ui_warning__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../ui/warning */ "./网页笔记/ui/warning.ts");
/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../util */ "./网页笔记/util.ts");
/** ════════════════════════🏳🌈 提供给用户使用的功能 🏳🌈════════════════════════
*
** ════════════════════════🚧 提供给用户使用的功能 🚧════════════════════════ */
const fun = {
/** 使元素可编辑 */
editElement() {
if (_state_index__WEBPACK_IMPORTED_MODULE_5__[/* currentElement */ "a"].innerHTML.length > 10 * 1000) return new _ui_warning__WEBPACK_IMPORTED_MODULE_6__[/* Warning */ "a"]({
msg: "该元素内容过大，请选择更确定的文本元素。"
}).autoHide();
_command__WEBPACK_IMPORTED_MODULE_4__[/* CommandControl */ "a"].run(new _command__WEBPACK_IMPORTED_MODULE_4__[/* editSelect */ "f"](_state_index__WEBPACK_IMPORTED_MODULE_5__[/* currentElement */ "a"]));
},
/** 删除元素 */
deleteElement() {
_command__WEBPACK_IMPORTED_MODULE_4__[/* CommandControl */ "a"].run(new _command__WEBPACK_IMPORTED_MODULE_4__[/* deleteSelect */ "e"](_state_index__WEBPACK_IMPORTED_MODULE_5__[/* currentElement */ "a"]));
},
/** 复制title */
copyTitle() {
_util__WEBPACK_IMPORTED_MODULE_7__[/* default */ "b"].copyTitle(_state_index__WEBPACK_IMPORTED_MODULE_5__[/* currentElement */ "a"]);
},
/** 关闭可编辑 */
closeEdit() {
_command__WEBPACK_IMPORTED_MODULE_4__[/* CommandControl */ "a"].run(new _command__WEBPACK_IMPORTED_MODULE_4__[/* closeEditSelect */ "d"](_state_index__WEBPACK_IMPORTED_MODULE_5__[/* currentElement */ "a"]));
},
/** 撤销 */
backOut() {
_command__WEBPACK_IMPORTED_MODULE_4__[/* CommandControl */ "a"].backOut();
},
/** 重做 */
undo() {
_command__WEBPACK_IMPORTED_MODULE_4__[/* CommandControl */ "a"].reform();
},
/** 新增笔记 */
addNote() {
_command__WEBPACK_IMPORTED_MODULE_4__[/* CommandControl */ "a"].run(new _command__WEBPACK_IMPORTED_MODULE_4__[/* addNote */ "c"](_state_index__WEBPACK_IMPORTED_MODULE_5__[/* currentElement */ "a"]));
},
/** 保存所有的修改 */
saveChanges() {
saveChanges(_state_index__WEBPACK_IMPORTED_MODULE_5__[/* editElement */ "b"]);
new _ui_message__WEBPACK_IMPORTED_MODULE_2__[/* Message */ "a"]({
msg: "保存成功"
}).autoHide();
},
/** 将修改上传到云端 */
async uploadThe() {
Object(_ajax__WEBPACK_IMPORTED_MODULE_3__[/* remote_setStore */ "d"])({
url: _config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].locationUrl,
store: await saveChanges(_state_index__WEBPACK_IMPORTED_MODULE_5__[/* editElement */ "b"])
}).then(r => {
new _ui_message__WEBPACK_IMPORTED_MODULE_2__[/* Message */ "a"]({
msg: "云端存储:" + r.message
}).autoHide();
});
},
/** 从云端下载修改 */
downloadThe() {
new _ui_message__WEBPACK_IMPORTED_MODULE_2__[/* Message */ "a"]({
msg: "正在读取云端存储"
}).autoHide();
Object(_ajax__WEBPACK_IMPORTED_MODULE_3__[/* remote_getStore */ "b"])({
url: _config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].locationUrl
}).then(r => {
if (r.body === undefined || r.body.length === 0) return new _ui_message__WEBPACK_IMPORTED_MODULE_2__[/* Message */ "a"]({
msg: "云端存储:" + r.message
}).autoHide();
const allStore = JSON.parse(r.body[0].store);
loadChanges(allStore);
new _ui_message__WEBPACK_IMPORTED_MODULE_2__[/* Message */ "a"]({
msg: "云端存储:" + r.message
}).autoHide();
});
},
/** 注册 */
register() {
register();
},
/** 登录 */
login() {
login();
}
};
/** 按键和函数的映射关系 */
const KeyMap = {
KeyQ: [fun.editElement],
KeyD: [fun.deleteElement],
KeyC: [fun.copyTitle],
KeyW: [fun.closeEdit],
KeyZ: [fun.backOut],
KeyY: [fun.undo],
KeyN: [fun.addNote],
KeyS: [fun.saveChanges],
KeyO: [fun.uploadThe],
KeyP: [fun.downloadThe, fun.saveChanges],
KeyK: [fun.register],
KeyL: [fun.login],
F2: [],
KeyM: []
};
/** 编辑模式下才能运行 */
function editRun(list) {
return list.map(f => async () => {
if (_config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].elementEdit === false) {
Object(_util__WEBPACK_IMPORTED_MODULE_7__[/* log */ "e"])("没有开启编辑功能");
} else {
return await f();
}
});
}
/** 保存修改 */
async function saveChanges(editElement) {
const data = {
element_List: {},
CommandStack: _command__WEBPACK_IMPORTED_MODULE_4__[/* CommandControl */ "a"].commandStack
};
/** 获取修改过的元素的html */
editElement.forEach(el => {
const selectors = Object(_util__WEBPACK_IMPORTED_MODULE_7__[/* getSelectors */ "d"])(el);
data.element_List[selectors] = el.innerHTML;
});
const data_str = JSON.stringify(Object.assign(_lib_store__WEBPACK_IMPORTED_MODULE_1__[/* curStore */ "a"], data));
await Object(_lib_store__WEBPACK_IMPORTED_MODULE_1__[/* setLocalItem */ "c"])(_config__WEBPACK_IMPORTED_MODULE_0__[/* AllStoreName */ "a"], JSON.stringify(data));
return data_str;
}
/** 加载修改 */
async function loadChanges(allStore) {
/** 将修改过的 html 写回去 */
for (const selectors in allStore.element_List) {
const html = allStore.element_List[selectors];
const el = document.querySelector(selectors);
if (el === null) {
console.error(`${selectors} 的元素无法找到，无法重写`);
} else {
_state_index__WEBPACK_IMPORTED_MODULE_5__[/* editElement */ "b"].add(el);
el.innerHTML = html;
Object(_util__WEBPACK_IMPORTED_MODULE_7__[/* log */ "e"])("-重写-", el);
}
}
/** 重新执行命令栈 */
_command__WEBPACK_IMPORTED_MODULE_4__[/* CommandControl */ "a"].loadCommandJsonAndRun(allStore.CommandStack);
}
function login() {
const title = ">>>网页笔记<<<\n";
const user = prompt(title + "请输入用户名");
if (user === null) return;
const secret_key = prompt(title + "请输入密钥。");
if (secret_key === null) return;
Object(_ajax__WEBPACK_IMPORTED_MODULE_3__[/* _login */ "a"])({
user,
secret_key
}).then(r => {
new _ui_message__WEBPACK_IMPORTED_MODULE_2__[/* Message */ "a"]({
msg: r.message
}).autoHide();
});
}
function register() {
const title = ">>>网页笔记<<<\n";
const user = prompt(title + "请输入用户名");
if (user === null) return;
const secret_key = prompt(title + "请输入密钥。要记住哦，没有提供找回功能");
if (secret_key === null) return;
Object(_ajax__WEBPACK_IMPORTED_MODULE_3__[/* remote_register */ "c"])({
user,
secret_key
}).then(r => {
new _ui_message__WEBPACK_IMPORTED_MODULE_2__[/* Message */ "a"]({
msg: r.message
}).autoHide();
});
}
/** 轮廓线,用以显示当前元素 */
function outline(el) {
el.classList.add("user_js_llej_outline");
setTimeout(reduction, 400);
function reduction() {
if (el == _state_index__WEBPACK_IMPORTED_MODULE_5__[/* currentElement */ "a"]) {
outline(el);
/** 鼠标还在这个元素上，再等会 */
return;
}
el.classList.remove("user_js_llej_outline");
}
}
/** 监听鼠标移动 */
function on_mouse(event) {
if (event.target instanceof HTMLElement) {
Object(_state_index__WEBPACK_IMPORTED_MODULE_5__[/* setPath */ "c"])(Object(_util__WEBPACK_IMPORTED_MODULE_7__[/* nodePath */ "f"])(event.target));
if (_config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].elementEdit) {
outline(event.target);
}
}
}
/** 监测按键事件 */
async function on_keydown(event) {
const code = event.code;
if (code in KeyMap) {
if (isEditing()) {
return new _ui_message__WEBPACK_IMPORTED_MODULE_2__[/* Message */ "a"]({
msg: "有元素获得焦点，视为正在输入文本，不执行指令"
}).autoHide();
} else {
if (code === "F2" || code === "KeyM") {
/** 切换编辑模式 */
return switchState();
} else if (_config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].elementEdit === false) {
Object(_util__WEBPACK_IMPORTED_MODULE_7__[/* log */ "e"])("没有开启编辑功能");
} else {
/** 执行按键绑定的函数 */
const func_list = KeyMap[code];
Object(_util__WEBPACK_IMPORTED_MODULE_7__[/* log */ "e"])(`[按下了] ${code},执行了: ${func_list.map(f => f.name).join(" ")}`);
for await (const f of func_list) {
await f();
}
}
}
} else {
Object(_util__WEBPACK_IMPORTED_MODULE_7__[/* log */ "e"])("未注册该按键处理程序 " + code);
}
function isEditing() {
return document.querySelector(":focus") ||
/** 如果目标元素是自定义组件的话上面这个还检测不了，需要检测 shadow 中是否存在焦点 */
//@ts-expect-error
event.target.shadowRoot && event.target.shadowRoot.querySelector(":focus");
}
}
/** 编辑事件 */
function on_input(event) {
if (event.target instanceof HTMLElement) {
const el = event.target;
if (el.innerHTML.length > 10 * 1000) new _ui_warning__WEBPACK_IMPORTED_MODULE_6__[/* Warning */ "a"]({
msg: "该元素html内容过大，将不会保存这里的修改，请选择更确定的文本元素。"
}).autoHide();else _state_index__WEBPACK_IMPORTED_MODULE_5__[/* editElement */ "b"].add(el);
}
}
/** 切换状态 */
function switchState() {
return _config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].elementEdit = !_config__WEBPACK_IMPORTED_MODULE_0__[/* default */ "b"].elementEdit;
}
/***/ }),
/***/ "./网页笔记/lib/store.ts":
/*!***************************!*\
!*** ./网页笔记/lib/store.ts ***!
\***************************/
/*! exports provided: setLocalItem, getLocalItem, curStore */
/*! exports used: curStore, getLocalItem, setLocalItem */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return setLocalItem; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getLocalItem; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return curStore; });
/* harmony import */ var vue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! vue */ "./node_modules/vue/dist/vue.runtime.esm-bundler.js");
/* harmony import */ var _fun_fun__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../fun/fun */ "./网页笔记/fun/fun.ts");
/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../config */ "./网页笔记/config.ts");
/** 设置一条本地存储 */
async function setLocalItem(name, value) {
//为了在非油猴环境下存储依旧能起一部分的作用
if (typeof unsafeWindow !== "undefined") {
return await GM.setValue(name, value);
} else {
return await localStorage.setItem(name, String(value));
}
}
/** 读取一条本地存储 */
async function getLocalItem(
/** 键名 */
name,
/** 没有的时候的默认值 */
defaultValue) {
if (typeof unsafeWindow !== "undefined") {
const res = await GM.getValue(name, defaultValue);
return res;
} else {
//为了在非油猴环境下存储依旧能起一部分的作用
const value = localStorage.getItem(name);
if (value === null) return await defaultValue;
return await value;
}
}
const curStore = Object(vue__WEBPACK_IMPORTED_MODULE_0__[/* reactive */ "a"])({
CommandStack: [],
element_List: {},
/** 用于记录高亮 id 避免新高亮出现重复 */
Highlighted_count: 0
});
getLocalItem(_config__WEBPACK_IMPORTED_MODULE_2__[/* AllStoreName */ "a"], "{}").then(s => {
Object.assign(curStore, JSON.parse(s));
/** 自动加载本地暂存更改 */
(async () => {
console.log(curStore);
if (document.readyState === "complete") {
Object(_fun_fun__WEBPACK_IMPORTED_MODULE_1__[/* loadChanges */ "a"])(curStore);
} else {
window.addEventListener("load", function () {
Object(_fun_fun__WEBPACK_IMPORTED_MODULE_1__[/* loadChanges */ "a"])(curStore);
});
}
})();
});
/***/ }),
/***/ "./网页笔记/state/highlighted_style.ts":
/*!*****************************************!*\
!*** ./网页笔记/state/highlighted_style.ts ***!
\*****************************************/
/*! exports provided: styleList, styleText */
/*! exports used: styleList, styleText */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return styleList; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return styleText; });
/* harmony import */ var svelte_store__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/store */ "./node_modules/svelte/store/index.mjs");
const styleList = Object(svelte_store__WEBPACK_IMPORTED_MODULE_0__[/* writable */ "c"])([]);
/** 根据 styleList 计算出来的 css 片段 */
const styleText = Object(svelte_store__WEBPACK_IMPORTED_MODULE_0__[/* derived */ "a"])(styleList, $styleList => {
return `<style>
${Object(svelte_store__WEBPACK_IMPORTED_MODULE_0__[/* get */ "b"])(styleList).join("\n")}
</style>`;
});
/***/ }),
/***/ "./网页笔记/state/index.ts":
/*!*****************************!*\
!*** ./网页笔记/state/index.ts ***!
\*****************************/
/*! exports provided: currentElement, path, setPath, editElement */
/*! exports used: currentElement, editElement, setPath */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return currentElement; });
/* unused harmony export path */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return setPath; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return editElement; });
/* harmony import */ var _remote_state__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./remote.state */ "./网页笔记/state/remote.state.ts");
/** 当前被选中的元素 */
let currentElement;
let path;
/** 修改当前指向的元素和路径 */
function setPath(elList) {
path = elList;
currentElement = elList[0];
}
/** 标记被修改后的元素(被污染了的元素)，以便保存修改的内容 */
const editElement = new Set(); // const globalSettingRef = fireStore.doc("setting/global");
// globalSettingRef.onSnapshot({
// next(r) {
// console.log("[ r]", r.data());
// },
// });
// globalSettingRef.update({
// test: 3,
// });
// globalSettingRef
// // .doc("samples/sandwichData")
// .get()
// .then((r) => {});
/***/ }),
/***/ "./网页笔记/state/remote.state.ts":
/*!************************************!*\
!*** ./网页笔记/state/remote.state.ts ***!
\************************************/
/*! exports provided: fireStore */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* unused harmony export fireStore */
// // Firebase App (the core Firebase SDK) is always required and
// // must be listed before other Firebase SDKs
// import * as firebase from "firebase/app";
// // Add the Firebase services that you want to use
// import "firebase/auth";
// import "firebase/firestore";
// firebase.initializeApp({
// apiKey: "AIzaSyCXy6_GwVogqPwZyJj-KPXIb-JfQaW-MTY",
// authDomain: "llej-2e851.firebaseapp.com",
// databaseURL: "https://llej-2e851.firebaseio.com",
// projectId: "llej-2e851",
// storageBucket: "llej-2e851.appspot.com",
// messagingSenderId: "419799122852",
// appId: "1:419799122852:web:36ddb23180314a8b987731",
// measurementId: "G-SN42ESZX78",
// });
const fireStore = {}; // /** 监听用户状态改变 */
// // firebase.auth().onAuthStateChanged(function (user) {
// // if (user) {
// // console.log("[登录成功]", user.email);
// // }
// // });
// // firebase
// // .auth()
// // .signInWithEmailAndPassword("admin@shenzilong.cn", "987456321")
// // .catch(function (error) {
// // // Handle Errors here.
// // var errorCode = error.code;
// // var errorMessage = error.message;
// // // ...
// // });
/***/ }),
/***/ "./网页笔记/state/store.ts":
/*!*****************************!*\
!*** ./网页笔记/state/store.ts ***!
\*****************************/
/*! exports provided: note_list_store, settingStore */
/*! exports used: note_list_store, settingStore */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return note_list_store; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return settingStore; });
/* harmony import */ var svelte_store__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/store */ "./node_modules/svelte/store/index.mjs");
/* harmony import */ var _lib_store__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../lib/store */ "./网页笔记/lib/store.ts");
/** 用来显示笔记的地方 */
const note_list_store = Object(svelte_store__WEBPACK_IMPORTED_MODULE_0__[/* writable */ "c"])([]);
const defaultSetting = {
a: 3,
swatches: {
textColor: {
default: "#333",
list: ["#EB5757", "#F2C94C", "#9B51E0", "#E0E0E0", "#2F80ED", "#2F80ED", "#828282", "#27AE60", "#27AE60", "#EB5757", "#56CCF2", "#F2994A", "#4F4F4F", "#219653", "#BB6BD9", "#F2F2F2", "#2D9CDB", "#2D9CDB", "#BDBDBD", "#6FCF97", "#6FCF97"]
},
bgColor: {
default: "#EB5757",
list: ["#EB5757", "#F2C94C", "#9B51E0", "#E0E0E0", "#2F80ED", "#2F80ED", "#828282", "#27AE60", "#27AE60", "#EB5757", "#56CCF2", "#F2994A", "#4F4F4F", "#219653", "#BB6BD9", "#F2F2F2", "#2D9CDB", "#2D9CDB", "#BDBDBD", "#6FCF97", "#6FCF97"]
},
underlineColor: {
default: "#EB5757",
list: ["#EB5757", "#F2C94C", "#9B51E0", "#E0E0E0", "#2F80ED", "#2F80ED", "#828282", "#27AE60", "#27AE60", "#EB5757", "#56CCF2", "#F2994A", "#4F4F4F", "#219653", "#BB6BD9", "#F2F2F2", "#2D9CDB", "#2D9CDB", "#BDBDBD", "#6FCF97", "#6FCF97"]
}
}
};
class PageNotesStore {
constructor(storePath) {
this.storePath = storePath;
this.store = {};
this._writable = Object(svelte_store__WEBPACK_IMPORTED_MODULE_0__[/* writable */ "c"])({});
this.initializing = Object(_lib_store__WEBPACK_IMPORTED_MODULE_1__[/* getLocalItem */ "b"])(storePath, JSON.stringify(defaultSetting)).then(r => {
this.store = JSON.parse(r);
this._writable.set(this.store);
this._writable.subscribe(r => {
this.store = r;
this.save(r);
});
return;
});
}
async getStore() {
await this.initializing;
return this.store;
}
save(r) {
Object(_lib_store__WEBPACK_IMPORTED_MODULE_1__[/* setLocalItem */ "c"])(this.storePath, JSON.stringify(r));
}
getWritable() {
return this._writable;
}
async get(k) {
return (await this.getStore())[k];
}
async set(k, value) {
const s = await this.getStore();
s[k] = value;
this._writable.set(s);
this.save(s);
}
}
/** 设置相关的存储 */
const settingStore = new PageNotesStore("__setting__");
/***/ }),
/***/ "./网页笔记/ui/message.ts":
/*!****************************!*\
!*** ./网页笔记/ui/message.ts ***!
\****************************/
/*! exports provided: messageList, Message */
/*! exports used: Message, messageList */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return messageList; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Message; });
/* harmony import */ var svelte_store__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/store */ "./node_modules/svelte/store/index.mjs");
/** 目前在呈现的消息列表 */
const messageList = Object(svelte_store__WEBPACK_IMPORTED_MODULE_0__[/* writable */ "c"])([]);
/** 消息的基类 扩展类记得重写 thatMessage 以免公用出现bug */
class Message {
constructor(par) {
this.par = par;
/** 用来指向不同的类，以便扩展这个类的类的old_message不被公用 */
this.autoHideTime = 1000 * 3;
}
/** 展示el */
show() {
messageList.update(r => [...r, this]);
return this;
}
/** 隐藏el */
hide() {
messageList.update(r => r.filter(el => this !== el));
return this;
}
/** 展示el autoHideTime 毫秒后隐藏*/
autoHide() {
this.show();
setTimeout(() => {
this.hide();
}, this.autoHideTime);
return this;
}
/** 获取一个Message对象 */
static getMessage(par) {
return new Message(par);
}
}
/***/ }),
/***/ "./网页笔记/ui/style.ts":
/*!**************************!*\
!*** ./网页笔记/ui/style.ts ***!
\**************************/
/*! exports provided: Style */
/*! exports used: Style */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Style; });
class Style {}
Style.message = `
border: 1px solid black;
background-color: white;
position: fixed;
top: 20px;
left: 30px;
animation: llej_myfirst 5s;
z-index:800;
`;
Style.warning = `
border: 1px solid black;
background-color: red;
position: fixed;
top: 20px;
left: 30px;
z-index:800;
`;
Style.note = `
border: 1px solid black;
background-color: #c6c5ba;
position: sticky;
top: 20px;
left: 30px;
width: auto;
height: auto;
z-index:800;
`;
/** 注入动画 */
const keyframes = document.createElement('style');
keyframes.innerHTML = `
@keyframes llej_myfirst
{
from { background: red;color:white; }
to { background: yellow;color:black; }
}
`;
document.head.appendChild(keyframes);
/***/ }),
/***/ "./网页笔记/ui/warning.ts":
/*!****************************!*\
!*** ./网页笔记/ui/warning.ts ***!
\****************************/
/*! exports provided: Warning */
/*! exports used: Warning */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Warning; });
/* harmony import */ var _message__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./message */ "./网页笔记/ui/message.ts");
/* harmony import */ var _style__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./style */ "./网页笔记/ui/style.ts");
class Warning extends _message__WEBPACK_IMPORTED_MODULE_0__[/* Message */ "a"] {
constructor({
msg
}) {
super({
msg,
style: _style__WEBPACK_IMPORTED_MODULE_1__[/* Style */ "a"].warning
});
}
}
/***/ }),
/***/ "./网页笔记/util.ts":
/*!**********************!*\
!*** ./网页笔记/util.ts ***!
\**********************/
/*! exports provided: copyTitle, default, getSelectors, getIndex, nodePath, getJSon, ajax_get, log, SelectionEvent, getWindow */
/*! exports used: SelectionEvent, default, getJSon, getSelectors, log, nodePath */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
/* unused harmony export copyTitle */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return getSelectors; });
/* unused harmony export getIndex */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return nodePath; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return getJSon; });
/* unused harmony export ajax_get */
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return log; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return SelectionEvent; });
/* unused harmony export getWindow */
/* harmony import */ var svelte_store__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/store */ "./node_modules/svelte/store/index.mjs");
/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./config */ "./网页笔记/config.ts");
/* harmony import */ var _fun_command__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./fun/command */ "./网页笔记/fun/command.ts");
/* harmony import */ var _state__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./state */ "./网页笔记/state/index.ts");
/** 用于复制文本的input */
const input_copy = document.createElement("textarea");
input_copy.id = "__";
input_copy.style.display = "none"; //不能设置为none因为会导致没有可访问性
input_copy.setAttribute("style", `
position: absolute;
top: -9999px;
left: -9999px;`);
document.body.appendChild(input_copy);
/** 复制一个元素的titil 或者一段字符串到剪贴板 */
function copyTitle(el) {
let title;
if (typeof el === "string") title = el;else title = el.getAttribute("title");
input_copy.setAttribute("readonly", "readonly");
input_copy.setAttribute("value", title);
input_copy.value = title;
input_copy.select();
input_copy.setSelectionRange(0, 9999);
document.execCommand("copy");
}
/** 工具类 */
/* harmony default export */ __webpack_exports__["b"] = ({
copyTitle
});
/** 获取一个元素的选择器 */
function getSelectors(el) {
/** 通过path路径来确定元素 */
let pathSelectors = nodePath(el).reverse().map(el => {
return el.nodeName + `:nth-child(${getIndex(el)})`;
}).join(">");
/** 通过id以及class来确定元素 */
let id_className = "";
const id = el.id;
if (id) id_className += `#${id}`;
Array.from(el.classList)
/** 排除自定义类名 */
.filter(el => el.includes("_llej_")).forEach(className => {
id_className += `.${className}`;
});
/** nth-child 选择 看它是第几个元素 */
const index = getIndex(el);
/** 最终构造出来的选择器 */
return `${pathSelectors}${id_className}:nth-child(${index})`;
}
/** 获取元素它在第几位 */
function getIndex(el) {
if (el.nodeName === "HTML") return 1;
if (el.parentElement === null) {
return 1;
}
return 1 + Array.from(el.parentElement.children).findIndex(child => child === el);
}
/** 获取一个元素的所有父节点到html为止 */
function nodePath(...path) {
while (path[path.length - 1].parentElement != null) {
path.push(path[path.length - 1].parentElement);
}
/** 只需要是HTMLElement的 */
const HTMLElementPath = path.filter(el => el instanceof HTMLElement);
return HTMLElementPath;
}
async function getJSon(url, data) {
const str = await ajax_get(url, data);
const res = JSON.parse(str);
console.log(url, data, res);
return res;
}
/** 油猴的ajaxget */
function ajax_get(url, data) {
if (data) url += "?" + jsonToURLpar(data);
if (window.hasOwnProperty("GM") && window.hasOwnProperty("GM")) return new Promise((resolve, reject) => {
GM.xmlHttpRequest({
method: "GET",
url,
onload: function (response) {
resolve(response.responseText);
},
onerror: reject
});
});else return new Promise((resolve, reject) => {
const xhr = new XMLHttpRequest();
xhr.addEventListener("load", function () {
resolve(xhr.responseText);
});
xhr.addEventListener("error", reject);
xhr.open("get", url);
xhr.send();
});
}
/** json 转 urlpar 只能转一层 */
function jsonToURLpar(json) {
return Object.keys(json).map(function (key) {
return encodeURIComponent(key) + "=" + encodeURIComponent(json[key]);
}).join("&");
}
/** 开发时的调试log */
function log(...arg) {
if (_config__WEBPACK_IMPORTED_MODULE_1__[/* isDev */ "d"]) console.log(`[dev] `, ...arg);
}
/** 用户选中事件 */
var SelectionEvent;
(function (SelectionEvent) {
/** 表示用户选中的对象，唯一的。不用每次去获取 */
const s = window.getSelection();
/** 是否处于 range 的选中状态 */
SelectionEvent.isRange = Object(svelte_store__WEBPACK_IMPORTED_MODULE_0__[/* writable */ "c"])(false);
/** 选区开始位置的元素的 rect */
SelectionEvent.anchorRect = Object(svelte_store__WEBPACK_IMPORTED_MODULE_0__[/* derived */ "a"])(SelectionEvent.isRange, $isRange => {
if (!$isRange) return;
const node = s.anchorNode;
const el = node instanceof Element ? node : node.parentElement;
const rect = el.getBoundingClientRect();
return rect;
});
function 高亮(options = {}) {
const h = new _fun_command__WEBPACK_IMPORTED_MODULE_2__[/* Highlighted */ "b"](options.style);
_fun_command__WEBPACK_IMPORTED_MODULE_2__[/* CommandControl */ "a"].run(h);
const className = h.className;
const tagName = "span";
let 选中的所有节点 = [];
if (
/** 跨元素了 */
s.anchorNode !== s.focusNode) {
const startRange = s.getRangeAt(0);
const endRange = s.getRangeAt(s.rangeCount - 1);
let startNode = startRange.startContainer;
let endNode = endRange.endContainer;
let cur = startNode;
if (cur instanceof Text) {
const s = startRange;
const t2 = cur.splitText(s.startOffset);
const t3 = t2.nextSibling;
const wrap = document.createElement(tagName);
wrap.appendChild(t2);
cur.parentNode.insertBefore(wrap, t3);
}
cur = endNode;
if (cur instanceof Text) {
const s = endRange;
const t2 = cur.splitText(s.endOffset);
const wrap = document.createElement(tagName);
wrap.appendChild(cur);
t2.parentNode.insertBefore(wrap, t2);
endNode = t2;
}
选中的所有节点 = getIntermediateNodes(startNode, endNode);
} else {
/** 单元素类 */
const cur = s.anchorNode;
if (cur instanceof Text) {
const t2 = cur.splitText(s.anchorOffset);
const t3 = t2.splitText(s.focusOffset);
选中的所有节点.push(t2);
} else {
选中的所有节点.push(cur);
}
}
console.log("选中的所有节点", 选中的所有节点);
选中的所有节点.forEach(node => {
let el;
if (node instanceof Element) {
el = node;
} else {
/** 对纯文本节点进行包装，因为纯文本节点无法附加样式等属性 */
const wrap = document.createElement(tagName);
const t2 = node.nextSibling;
const parent = node.parentNode;
wrap.appendChild(node);
parent.insertBefore(wrap, t2);
el = wrap;
}
el.classList.add(className);
});
/** 这些元素被添加了类名，甚至被包裹了一层。属于被污染的元素,直接标记他们的父亲 */
const 共存层 = getIntermediateNodes.寻找共存层(...选中的所有节点); // console.log("[共存层]", 共存层);
let parent = 共存层[0].parentElement;
/** 避免标记的是不够大的元素，实际上也是因为寻找元素的方法不够好否则也用不着这个 */
while (parent.className.includes("llej-page_notes-style")) {
parent = parent.parentElement;
}
_state__WEBPACK_IMPORTED_MODULE_3__[/* editElement */ "b"].add(parent);
}
SelectionEvent.高亮 = 高亮;
document.addEventListener("selectionchange", () => {
SelectionEvent.isRange.set(s.type === "Range");
});
})(SelectionEvent || (SelectionEvent = {}));
function getIntermediateNodes(a, b) {
return getIntermediateNodes.获取两元素之间的元素(a, b);
}
(function (getIntermediateNodes) {
function 寻找共存层(...args) {
if (args.length === 1) {
return args;
}
const parentList = args.map(el => 获取父链路(el).reverse()).sort((a, b) => {
return a.length - b.length;
});
const 最短链路 = parentList[0];
for (let i = 0; i < 最短链路.length; i++) {
const element = 最短链路[i];
const 此层是否全相似 = parentList.map(el => el[i]).every(el => el === element);
if (此层是否全相似 === false) {
return Array.from(最短链路[i - 1].childNodes);
}
}
}
getIntermediateNodes.寻找共存层 = 寻找共存层;
/** 越接近node的元素越在前面 */
function 获取父链路(node) {
const list = [];
list.push(node);
let cur = node;
while (cur.parentNode) {
list.push(cur.parentNode);
cur = cur.parentNode;
}
return list;
}
getIntermediateNodes.获取父链路 = 获取父链路;
function 后面的兄弟元素(node) {
const list = [];
let cur = node;
while (cur.nextSibling) {
list.push(cur.nextSibling);
cur = cur.nextSibling;
}
return list;
}
getIntermediateNodes.后面的兄弟元素 = 后面的兄弟元素;
function 前面的兄弟元素(node) {
const list = [];
let cur = node;
while (cur.previousSibling) {
list.push(cur.previousSibling);
cur = cur.previousSibling;
}
return list;
}
getIntermediateNodes.前面的兄弟元素 = 前面的兄弟元素;
function 获取两元素之间的元素(a, b) {
const list = [];
const aParentList = 获取父链路(a).reverse();
const bParentList = 获取父链路(b).reverse();
/** 找出 a 与 b 在共存层的父元素 */
const 短链路 = aParentList.length > bParentList.length ? bParentList : aParentList;
let n1 = 短链路[0];
let n2 = 短链路[0];
for (let i = 0; i < 短链路.length; i++) {
n1 = aParentList[i];
n2 = bParentList[i];
if (n1 !== n2) {
break;
}
}
/** 获取共存层中间的元素 */
let cur = n1.nextSibling;
while (cur !== n2 && cur.nextSibling !== null) {
list.push(cur);
cur = cur.nextSibling;
}
/** 判断 a 是否在 b前面 */
cur = n1;
let n1在前 = false;
while (cur.nextSibling) {
if (n2 === cur) {
n1在前 = true;
break;
}
cur = cur.nextSibling;
}
const [pre, next] = n1在前 ? [a, b] : [b, a];
const 共存层 = 寻找共存层(a, b);
cur = pre;
while (!共存层.includes(cur)) {
list.push(...后面的兄弟元素(cur));
cur = cur.parentNode;
}
cur = next;
while (!共存层.includes(cur)) {
list.push(...前面的兄弟元素(cur));
cur = cur.parentNode;
}
return list;
}
getIntermediateNodes.获取两元素之间的元素 = 获取两元素之间的元素;
})(getIntermediateNodes || (getIntermediateNodes = {}));
function getWindow() {
return typeof unsafeWindow === "undefined" ? window : unsafeWindow;
}
/***/ })
/******/ });
//# sourceMappingURL=更好的我来导出.user.js.map