Add decaf webui

webui/node_modules/@vue/compiler-core/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

webui/node_modules/@vue/compiler-core/README.md

@@ -0,0 +1 @@
+# @vue/compiler-core

webui/node_modules/@vue/compiler-core/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/compiler-core.cjs.prod.js')
+} else {
+  module.exports = require('./dist/compiler-core.cjs.js')
+}

webui/node_modules/@vue/compiler-core/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@vue/compiler-core",
+  "version": "3.2.37",
+  "description": "@vue/compiler-core",
+  "main": "index.js",
+  "module": "dist/compiler-core.esm-bundler.js",
+  "types": "dist/compiler-core.d.ts",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "buildOptions": {
+    "name": "VueCompilerCore",
+    "compat": true,
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-core"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-core#readme",
+  "dependencies": {
+    "@vue/shared": "3.2.37",
+    "@babel/parser": "^7.16.4",
+    "estree-walker": "^2.0.2",
+    "source-map": "^0.6.1"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.16.0"
+  }
+}

webui/node_modules/@vue/compiler-dom/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

webui/node_modules/@vue/compiler-dom/README.md

@@ -0,0 +1 @@
+# @vue/compiler-dom

webui/node_modules/@vue/compiler-dom/dist/compiler-dom.d.ts

@@ -0,0 +1,66 @@
+import { CodegenResult } from '@vue/compiler-core';
+import { CompilerError } from '@vue/compiler-core';
+import { CompilerOptions } from '@vue/compiler-core';
+import { DirectiveTransform } from '@vue/compiler-core';
+import { NodeTransform } from '@vue/compiler-core';
+import { ParserOptions } from '@vue/compiler-core';
+import { RootNode } from '@vue/compiler-core';
+import { SourceLocation } from '@vue/compiler-core';
+
+export declare function compile(template: string, options?: CompilerOptions): CodegenResult;
+
+export declare function createDOMCompilerError(code: DOMErrorCodes, loc?: SourceLocation): DOMCompilerError;
+
+declare interface DOMCompilerError extends CompilerError {
+    code: DOMErrorCodes;
+}
+
+export declare const DOMDirectiveTransforms: Record<string, DirectiveTransform>;
+
+export declare const enum DOMErrorCodes {
+    X_V_HTML_NO_EXPRESSION = 50,
+    X_V_HTML_WITH_CHILDREN = 51,
+    X_V_TEXT_NO_EXPRESSION = 52,
+    X_V_TEXT_WITH_CHILDREN = 53,
+    X_V_MODEL_ON_INVALID_ELEMENT = 54,
+    X_V_MODEL_ARG_ON_ELEMENT = 55,
+    X_V_MODEL_ON_FILE_INPUT_ELEMENT = 56,
+    X_V_MODEL_UNNECESSARY_VALUE = 57,
+    X_V_SHOW_NO_EXPRESSION = 58,
+    X_TRANSITION_INVALID_CHILDREN = 59,
+    X_IGNORED_SIDE_EFFECT_TAG = 60,
+    __EXTEND_POINT__ = 61
+}
+
+export declare const DOMNodeTransforms: NodeTransform[];
+
+export declare function parse(template: string, options?: ParserOptions): RootNode;
+
+export declare const parserOptions: ParserOptions;
+
+export declare const transformStyle: NodeTransform;
+
+export declare const TRANSITION: unique symbol;
+
+export declare const TRANSITION_GROUP: unique symbol;
+
+export declare const V_MODEL_CHECKBOX: unique symbol;
+
+export declare const V_MODEL_DYNAMIC: unique symbol;
+
+export declare const V_MODEL_RADIO: unique symbol;
+
+export declare const V_MODEL_SELECT: unique symbol;
+
+export declare const V_MODEL_TEXT: unique symbol;
+
+export declare const V_ON_WITH_KEYS: unique symbol;
+
+export declare const V_ON_WITH_MODIFIERS: unique symbol;
+
+export declare const V_SHOW: unique symbol;
+
+
+export * from "@vue/compiler-core";
+
+export { }

webui/node_modules/@vue/compiler-dom/dist/compiler-dom.esm-bundler.js

@@ -0,0 +1,483 @@
+import { registerRuntimeHelpers, isBuiltInType, createSimpleExpression, createCompilerError, createObjectProperty, getConstantType, createCallExpression, TO_DISPLAY_STRING, transformModel as transformModel$1, findProp, hasDynamicKeyVBind, transformOn as transformOn$1, createCompoundExpression, isStaticExp, checkCompatEnabled, noopDirectiveTransform, baseCompile, baseParse } from '@vue/compiler-core';
+export * from '@vue/compiler-core';
+import { isVoidTag, isHTMLTag, isSVGTag, makeMap, parseStringStyle, capitalize, extend } from '@vue/shared';
+
+const V_MODEL_RADIO = Symbol((process.env.NODE_ENV !== 'production') ? `vModelRadio` : ``);
+const V_MODEL_CHECKBOX = Symbol((process.env.NODE_ENV !== 'production') ? `vModelCheckbox` : ``);
+const V_MODEL_TEXT = Symbol((process.env.NODE_ENV !== 'production') ? `vModelText` : ``);
+const V_MODEL_SELECT = Symbol((process.env.NODE_ENV !== 'production') ? `vModelSelect` : ``);
+const V_MODEL_DYNAMIC = Symbol((process.env.NODE_ENV !== 'production') ? `vModelDynamic` : ``);
+const V_ON_WITH_MODIFIERS = Symbol((process.env.NODE_ENV !== 'production') ? `vOnModifiersGuard` : ``);
+const V_ON_WITH_KEYS = Symbol((process.env.NODE_ENV !== 'production') ? `vOnKeysGuard` : ``);
+const V_SHOW = Symbol((process.env.NODE_ENV !== 'production') ? `vShow` : ``);
+const TRANSITION = Symbol((process.env.NODE_ENV !== 'production') ? `Transition` : ``);
+const TRANSITION_GROUP = Symbol((process.env.NODE_ENV !== 'production') ? `TransitionGroup` : ``);
+registerRuntimeHelpers({
+    [V_MODEL_RADIO]: `vModelRadio`,
+    [V_MODEL_CHECKBOX]: `vModelCheckbox`,
+    [V_MODEL_TEXT]: `vModelText`,
+    [V_MODEL_SELECT]: `vModelSelect`,
+    [V_MODEL_DYNAMIC]: `vModelDynamic`,
+    [V_ON_WITH_MODIFIERS]: `withModifiers`,
+    [V_ON_WITH_KEYS]: `withKeys`,
+    [V_SHOW]: `vShow`,
+    [TRANSITION]: `Transition`,
+    [TRANSITION_GROUP]: `TransitionGroup`
+});
+
+/* eslint-disable no-restricted-globals */
+let decoder;
+function decodeHtmlBrowser(raw, asAttr = false) {
+    if (!decoder) {
+        decoder = document.createElement('div');
+    }
+    if (asAttr) {
+        decoder.innerHTML = `<div foo="${raw.replace(/"/g, '&quot;')}">`;
+        return decoder.children[0].getAttribute('foo');
+    }
+    else {
+        decoder.innerHTML = raw;
+        return decoder.textContent;
+    }
+}
+
+const isRawTextContainer = /*#__PURE__*/ makeMap('style,iframe,script,noscript', true);
+const parserOptions = {
+    isVoidTag,
+    isNativeTag: tag => isHTMLTag(tag) || isSVGTag(tag),
+    isPreTag: tag => tag === 'pre',
+    decodeEntities: decodeHtmlBrowser ,
+    isBuiltInComponent: (tag) => {
+        if (isBuiltInType(tag, `Transition`)) {
+            return TRANSITION;
+        }
+        else if (isBuiltInType(tag, `TransitionGroup`)) {
+            return TRANSITION_GROUP;
+        }
+    },
+    // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
+    getNamespace(tag, parent) {
+        let ns = parent ? parent.ns : 0 /* HTML */;
+        if (parent && ns === 2 /* MATH_ML */) {
+            if (parent.tag === 'annotation-xml') {
+                if (tag === 'svg') {
+                    return 1 /* SVG */;
+                }
+                if (parent.props.some(a => a.type === 6 /* ATTRIBUTE */ &&
+                    a.name === 'encoding' &&
+                    a.value != null &&
+                    (a.value.content === 'text/html' ||
+                        a.value.content === 'application/xhtml+xml'))) {
+                    ns = 0 /* HTML */;
+                }
+            }
+            else if (/^m(?:[ions]|text)$/.test(parent.tag) &&
+                tag !== 'mglyph' &&
+                tag !== 'malignmark') {
+                ns = 0 /* HTML */;
+            }
+        }
+        else if (parent && ns === 1 /* SVG */) {
+            if (parent.tag === 'foreignObject' ||
+                parent.tag === 'desc' ||
+                parent.tag === 'title') {
+                ns = 0 /* HTML */;
+            }
+        }
+        if (ns === 0 /* HTML */) {
+            if (tag === 'svg') {
+                return 1 /* SVG */;
+            }
+            if (tag === 'math') {
+                return 2 /* MATH_ML */;
+            }
+        }
+        return ns;
+    },
+    // https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
+    getTextMode({ tag, ns }) {
+        if (ns === 0 /* HTML */) {
+            if (tag === 'textarea' || tag === 'title') {
+                return 1 /* RCDATA */;
+            }
+            if (isRawTextContainer(tag)) {
+                return 2 /* RAWTEXT */;
+            }
+        }
+        return 0 /* DATA */;
+    }
+};
+
+// Parse inline CSS strings for static style attributes into an object.
+// This is a NodeTransform since it works on the static `style` attribute and
+// converts it into a dynamic equivalent:
+// style="color: red" -> :style='{ "color": "red" }'
+// It is then processed by `transformElement` and included in the generated
+// props.
+const transformStyle = node => {
+    if (node.type === 1 /* ELEMENT */) {
+        node.props.forEach((p, i) => {
+            if (p.type === 6 /* ATTRIBUTE */ && p.name === 'style' && p.value) {
+                // replace p with an expression node
+                node.props[i] = {
+                    type: 7 /* DIRECTIVE */,
+                    name: `bind`,
+                    arg: createSimpleExpression(`style`, true, p.loc),
+                    exp: parseInlineCSS(p.value.content, p.loc),
+                    modifiers: [],
+                    loc: p.loc
+                };
+            }
+        });
+    }
+};
+const parseInlineCSS = (cssText, loc) => {
+    const normalized = parseStringStyle(cssText);
+    return createSimpleExpression(JSON.stringify(normalized), false, loc, 3 /* CAN_STRINGIFY */);
+};
+
+function createDOMCompilerError(code, loc) {
+    return createCompilerError(code, loc, (process.env.NODE_ENV !== 'production') || !true ? DOMErrorMessages : undefined);
+}
+const DOMErrorMessages = {
+    [50 /* X_V_HTML_NO_EXPRESSION */]: `v-html is missing expression.`,
+    [51 /* X_V_HTML_WITH_CHILDREN */]: `v-html will override element children.`,
+    [52 /* X_V_TEXT_NO_EXPRESSION */]: `v-text is missing expression.`,
+    [53 /* X_V_TEXT_WITH_CHILDREN */]: `v-text will override element children.`,
+    [54 /* X_V_MODEL_ON_INVALID_ELEMENT */]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+    [55 /* X_V_MODEL_ARG_ON_ELEMENT */]: `v-model argument is not supported on plain elements.`,
+    [56 /* X_V_MODEL_ON_FILE_INPUT_ELEMENT */]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+    [57 /* X_V_MODEL_UNNECESSARY_VALUE */]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+    [58 /* X_V_SHOW_NO_EXPRESSION */]: `v-show is missing expression.`,
+    [59 /* X_TRANSITION_INVALID_CHILDREN */]: `<Transition> expects exactly one child element or component.`,
+    [60 /* X_IGNORED_SIDE_EFFECT_TAG */]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
+};
+
+const transformVHtml = (dir, node, context) => {
+    const { exp, loc } = dir;
+    if (!exp) {
+        context.onError(createDOMCompilerError(50 /* X_V_HTML_NO_EXPRESSION */, loc));
+    }
+    if (node.children.length) {
+        context.onError(createDOMCompilerError(51 /* X_V_HTML_WITH_CHILDREN */, loc));
+        node.children.length = 0;
+    }
+    return {
+        props: [
+            createObjectProperty(createSimpleExpression(`innerHTML`, true, loc), exp || createSimpleExpression('', true))
+        ]
+    };
+};
+
+const transformVText = (dir, node, context) => {
+    const { exp, loc } = dir;
+    if (!exp) {
+        context.onError(createDOMCompilerError(52 /* X_V_TEXT_NO_EXPRESSION */, loc));
+    }
+    if (node.children.length) {
+        context.onError(createDOMCompilerError(53 /* X_V_TEXT_WITH_CHILDREN */, loc));
+        node.children.length = 0;
+    }
+    return {
+        props: [
+            createObjectProperty(createSimpleExpression(`textContent`, true), exp
+                ? getConstantType(exp, context) > 0
+                    ? exp
+                    : createCallExpression(context.helperString(TO_DISPLAY_STRING), [exp], loc)
+                : createSimpleExpression('', true))
+        ]
+    };
+};
+
+const transformModel = (dir, node, context) => {
+    const baseResult = transformModel$1(dir, node, context);
+    // base transform has errors OR component v-model (only need props)
+    if (!baseResult.props.length || node.tagType === 1 /* COMPONENT */) {
+        return baseResult;
+    }
+    if (dir.arg) {
+        context.onError(createDOMCompilerError(55 /* X_V_MODEL_ARG_ON_ELEMENT */, dir.arg.loc));
+    }
+    function checkDuplicatedValue() {
+        const value = findProp(node, 'value');
+        if (value) {
+            context.onError(createDOMCompilerError(57 /* X_V_MODEL_UNNECESSARY_VALUE */, value.loc));
+        }
+    }
+    const { tag } = node;
+    const isCustomElement = context.isCustomElement(tag);
+    if (tag === 'input' ||
+        tag === 'textarea' ||
+        tag === 'select' ||
+        isCustomElement) {
+        let directiveToUse = V_MODEL_TEXT;
+        let isInvalidType = false;
+        if (tag === 'input' || isCustomElement) {
+            const type = findProp(node, `type`);
+            if (type) {
+                if (type.type === 7 /* DIRECTIVE */) {
+                    // :type="foo"
+                    directiveToUse = V_MODEL_DYNAMIC;
+                }
+                else if (type.value) {
+                    switch (type.value.content) {
+                        case 'radio':
+                            directiveToUse = V_MODEL_RADIO;
+                            break;
+                        case 'checkbox':
+                            directiveToUse = V_MODEL_CHECKBOX;
+                            break;
+                        case 'file':
+                            isInvalidType = true;
+                            context.onError(createDOMCompilerError(56 /* X_V_MODEL_ON_FILE_INPUT_ELEMENT */, dir.loc));
+                            break;
+                        default:
+                            // text type
+                            (process.env.NODE_ENV !== 'production') && checkDuplicatedValue();
+                            break;
+                    }
+                }
+            }
+            else if (hasDynamicKeyVBind(node)) {
+                // element has bindings with dynamic keys, which can possibly contain
+                // "type".
+                directiveToUse = V_MODEL_DYNAMIC;
+            }
+            else {
+                // text type
+                (process.env.NODE_ENV !== 'production') && checkDuplicatedValue();
+            }
+        }
+        else if (tag === 'select') {
+            directiveToUse = V_MODEL_SELECT;
+        }
+        else {
+            // textarea
+            (process.env.NODE_ENV !== 'production') && checkDuplicatedValue();
+        }
+        // inject runtime directive
+        // by returning the helper symbol via needRuntime
+        // the import will replaced a resolveDirective call.
+        if (!isInvalidType) {
+            baseResult.needRuntime = context.helper(directiveToUse);
+        }
+    }
+    else {
+        context.onError(createDOMCompilerError(54 /* X_V_MODEL_ON_INVALID_ELEMENT */, dir.loc));
+    }
+    // native vmodel doesn't need the `modelValue` props since they are also
+    // passed to the runtime as `binding.value`. removing it reduces code size.
+    baseResult.props = baseResult.props.filter(p => !(p.key.type === 4 /* SIMPLE_EXPRESSION */ &&
+        p.key.content === 'modelValue'));
+    return baseResult;
+};
+
+const isEventOptionModifier = /*#__PURE__*/ makeMap(`passive,once,capture`);
+const isNonKeyModifier = /*#__PURE__*/ makeMap(
+// event propagation management
+`stop,prevent,self,` +
+    // system modifiers + exact
+    `ctrl,shift,alt,meta,exact,` +
+    // mouse
+    `middle`);
+// left & right could be mouse or key modifiers based on event type
+const maybeKeyModifier = /*#__PURE__*/ makeMap('left,right');
+const isKeyboardEvent = /*#__PURE__*/ makeMap(`onkeyup,onkeydown,onkeypress`, true);
+const resolveModifiers = (key, modifiers, context, loc) => {
+    const keyModifiers = [];
+    const nonKeyModifiers = [];
+    const eventOptionModifiers = [];
+    for (let i = 0; i < modifiers.length; i++) {
+        const modifier = modifiers[i];
+        if (modifier === 'native' &&
+            checkCompatEnabled("COMPILER_V_ON_NATIVE" /* COMPILER_V_ON_NATIVE */, context, loc)) {
+            eventOptionModifiers.push(modifier);
+        }
+        else if (isEventOptionModifier(modifier)) {
+            // eventOptionModifiers: modifiers for addEventListener() options,
+            // e.g. .passive & .capture
+            eventOptionModifiers.push(modifier);
+        }
+        else {
+            // runtimeModifiers: modifiers that needs runtime guards
+            if (maybeKeyModifier(modifier)) {
+                if (isStaticExp(key)) {
+                    if (isKeyboardEvent(key.content)) {
+                        keyModifiers.push(modifier);
+                    }
+                    else {
+                        nonKeyModifiers.push(modifier);
+                    }
+                }
+                else {
+                    keyModifiers.push(modifier);
+                    nonKeyModifiers.push(modifier);
+                }
+            }
+            else {
+                if (isNonKeyModifier(modifier)) {
+                    nonKeyModifiers.push(modifier);
+                }
+                else {
+                    keyModifiers.push(modifier);
+                }
+            }
+        }
+    }
+    return {
+        keyModifiers,
+        nonKeyModifiers,
+        eventOptionModifiers
+    };
+};
+const transformClick = (key, event) => {
+    const isStaticClick = isStaticExp(key) && key.content.toLowerCase() === 'onclick';
+    return isStaticClick
+        ? createSimpleExpression(event, true)
+        : key.type !== 4 /* SIMPLE_EXPRESSION */
+            ? createCompoundExpression([
+                `(`,
+                key,
+                `) === "onClick" ? "${event}" : (`,
+                key,
+                `)`
+            ])
+            : key;
+};
+const transformOn = (dir, node, context) => {
+    return transformOn$1(dir, node, context, baseResult => {
+        const { modifiers } = dir;
+        if (!modifiers.length)
+            return baseResult;
+        let { key, value: handlerExp } = baseResult.props[0];
+        const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
+        // normalize click.right and click.middle since they don't actually fire
+        if (nonKeyModifiers.includes('right')) {
+            key = transformClick(key, `onContextmenu`);
+        }
+        if (nonKeyModifiers.includes('middle')) {
+            key = transformClick(key, `onMouseup`);
+        }
+        if (nonKeyModifiers.length) {
+            handlerExp = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
+                handlerExp,
+                JSON.stringify(nonKeyModifiers)
+            ]);
+        }
+        if (keyModifiers.length &&
+            // if event name is dynamic, always wrap with keys guard
+            (!isStaticExp(key) || isKeyboardEvent(key.content))) {
+            handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [
+                handlerExp,
+                JSON.stringify(keyModifiers)
+            ]);
+        }
+        if (eventOptionModifiers.length) {
+            const modifierPostfix = eventOptionModifiers.map(capitalize).join('');
+            key = isStaticExp(key)
+                ? createSimpleExpression(`${key.content}${modifierPostfix}`, true)
+                : createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
+        }
+        return {
+            props: [createObjectProperty(key, handlerExp)]
+        };
+    });
+};
+
+const transformShow = (dir, node, context) => {
+    const { exp, loc } = dir;
+    if (!exp) {
+        context.onError(createDOMCompilerError(58 /* X_V_SHOW_NO_EXPRESSION */, loc));
+    }
+    return {
+        props: [],
+        needRuntime: context.helper(V_SHOW)
+    };
+};
+
+const transformTransition = (node, context) => {
+    if (node.type === 1 /* ELEMENT */ &&
+        node.tagType === 1 /* COMPONENT */) {
+        const component = context.isBuiltInComponent(node.tag);
+        if (component === TRANSITION) {
+            return () => {
+                if (!node.children.length) {
+                    return;
+                }
+                // warn multiple transition children
+                if (hasMultipleChildren(node)) {
+                    context.onError(createDOMCompilerError(59 /* X_TRANSITION_INVALID_CHILDREN */, {
+                        start: node.children[0].loc.start,
+                        end: node.children[node.children.length - 1].loc.end,
+                        source: ''
+                    }));
+                }
+                // check if it's s single child w/ v-show
+                // if yes, inject "persisted: true" to the transition props
+                const child = node.children[0];
+                if (child.type === 1 /* ELEMENT */) {
+                    for (const p of child.props) {
+                        if (p.type === 7 /* DIRECTIVE */ && p.name === 'show') {
+                            node.props.push({
+                                type: 6 /* ATTRIBUTE */,
+                                name: 'persisted',
+                                value: undefined,
+                                loc: node.loc
+                            });
+                        }
+                    }
+                }
+            };
+        }
+    }
+};
+function hasMultipleChildren(node) {
+    // #1352 filter out potential comment nodes.
+    const children = (node.children = node.children.filter(c => c.type !== 3 /* COMMENT */ &&
+        !(c.type === 2 /* TEXT */ && !c.content.trim())));
+    const child = children[0];
+    return (children.length !== 1 ||
+        child.type === 11 /* FOR */ ||
+        (child.type === 9 /* IF */ && child.branches.some(hasMultipleChildren)));
+}
+
+const ignoreSideEffectTags = (node, context) => {
+    if (node.type === 1 /* ELEMENT */ &&
+        node.tagType === 0 /* ELEMENT */ &&
+        (node.tag === 'script' || node.tag === 'style')) {
+        context.onError(createDOMCompilerError(60 /* X_IGNORED_SIDE_EFFECT_TAG */, node.loc));
+        context.removeNode();
+    }
+};
+
+const DOMNodeTransforms = [
+    transformStyle,
+    ...((process.env.NODE_ENV !== 'production') ? [transformTransition] : [])
+];
+const DOMDirectiveTransforms = {
+    cloak: noopDirectiveTransform,
+    html: transformVHtml,
+    text: transformVText,
+    model: transformModel,
+    on: transformOn,
+    show: transformShow
+};
+function compile(template, options = {}) {
+    return baseCompile(template, extend({}, parserOptions, options, {
+        nodeTransforms: [
+            // ignore <script> and <tag>
+            // this is not put inside DOMNodeTransforms because that list is used
+            // by compiler-ssr to generate vnode fallback branches
+            ignoreSideEffectTags,
+            ...DOMNodeTransforms,
+            ...(options.nodeTransforms || [])
+        ],
+        directiveTransforms: extend({}, DOMDirectiveTransforms, options.directiveTransforms || {}),
+        transformHoist: null 
+    }));
+}
+function parse(template, options = {}) {
+    return baseParse(template, extend({}, parserOptions, options));
+}
+
+export { DOMDirectiveTransforms, DOMNodeTransforms, TRANSITION, TRANSITION_GROUP, V_MODEL_CHECKBOX, V_MODEL_DYNAMIC, V_MODEL_RADIO, V_MODEL_SELECT, V_MODEL_TEXT, V_ON_WITH_KEYS, V_ON_WITH_MODIFIERS, V_SHOW, compile, createDOMCompilerError, parse, parserOptions, transformStyle };

webui/node_modules/@vue/compiler-dom/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/compiler-dom.cjs.prod.js')
+} else {
+  module.exports = require('./dist/compiler-dom.cjs.js')
+}

webui/node_modules/@vue/compiler-dom/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@vue/compiler-dom",
+  "version": "3.2.37",
+  "description": "@vue/compiler-dom",
+  "main": "index.js",
+  "module": "dist/compiler-dom.esm-bundler.js",
+  "types": "dist/compiler-dom.d.ts",
+  "unpkg": "dist/compiler-dom.global.js",
+  "jsdelivr": "dist/compiler-dom.global.js",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "sideEffects": false,
+  "buildOptions": {
+    "name": "VueCompilerDOM",
+    "compat": true,
+    "formats": [
+      "esm-bundler",
+      "esm-browser",
+      "cjs",
+      "global"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-dom"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-dom#readme",
+  "dependencies": {
+    "@vue/shared": "3.2.37",
+    "@vue/compiler-core": "3.2.37"
+  }
+}

webui/node_modules/@vue/compiler-sfc/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

webui/node_modules/@vue/compiler-sfc/README.md

@@ -0,0 +1,80 @@
+# @vue/compiler-sfc
+
+> Lower level utilities for compiling Vue Single File Components
+
+**Note: as of 3.2.13+, this package is included as a dependency of the main `vue` package and can be accessed as `vue/compiler-sfc`. This means you no longer need to explicitly install this package and ensure its version match that of `vue`'s. Just use the main `vue/compiler-sfc` deep import instead.**
+
+This package contains lower level utilities that you can use if you are writing a plugin / transform for a bundler or module system that compiles Vue Single File Components (SFCs) into JavaScript. It is used in [vue-loader](https://github.com/vuejs/vue-loader), [rollup-plugin-vue](https://github.com/vuejs/rollup-plugin-vue) and [vite](https://github.com/vitejs/vite).
+
+## API
+
+The API is intentionally low-level due to the various considerations when integrating Vue SFCs in a build system:
+
+- Separate hot-module replacement (HMR) for script, template and styles
+
+  - template updates should not reset component state
+  - style updates should be performed without component re-render
+
+- Leveraging the tool's plugin system for pre-processor handling. e.g. `<style lang="scss">` should be processed by the corresponding webpack loader.
+
+- In some cases, transformers of each block in an SFC do not share the same execution context. For example, when used with `thread-loader` or other parallelized configurations, the template sub-loader in `vue-loader` may not have access to the full SFC and its descriptor.
+
+The general idea is to generate a facade module that imports the individual blocks of the component. The trick is the module imports itself with different query strings so that the build system can handle each request as "virtual" modules:
+
+```
+                                  +--------------------+
+                                  |                    |
+                                  |  script transform  |
+                           +----->+                    |
+                           |      +--------------------+
+                           |
++--------------------+     |      +--------------------+
+|                    |     |      |                    |
+|  facade transform  +----------->+ template transform |
+|                    |     |      |                    |
++--------------------+     |      +--------------------+
+                           |
+                           |      +--------------------+
+                           +----->+                    |
+                                  |  style transform   |
+                                  |                    |
+                                  +--------------------+
+```
+
+Where the facade module looks like this:
+
+```js
+// main script
+import script from '/project/foo.vue?vue&type=script'
+// template compiled to render function
+import { render } from '/project/foo.vue?vue&type=template&id=xxxxxx'
+// css
+import '/project/foo.vue?vue&type=style&index=0&id=xxxxxx'
+
+// attach render function to script
+script.render = render
+
+// attach additional metadata
+// some of these should be dev only
+script.__file = 'example.vue'
+script.__scopeId = 'xxxxxx'
+
+// additional tooling-specific HMR handling code
+// using __VUE_HMR_API__ global
+
+export default script
+```
+
+### High Level Workflow
+
+1. In facade transform, parse the source into descriptor with the `parse` API and generate the above facade module code based on the descriptor;
+
+2. In script transform, use `compileScript` to process the script. This handles features like `<script setup>` and CSS variable injection. Alternatively, this can be done directly in the facade module (with the code inlined instead of imported), but it will require rewriting `export default` to a temp variable (a `rewriteDefault` convenience API is provided for this purpose) so additional options can be attached to the exported object.
+
+3. In template transform, use `compileTemplate` to compile the raw template into render function code.
+
+4. In style transform, use `compileStyle` to compile raw CSS to handle `<style scoped>`, `<style module>` and CSS variable injection.
+
+Options needed for these APIs can be passed via the query string.
+
+For detailed API references and options, check out the source type definitions. For actual usage of these APIs, check out [rollup-plugin-vue](https://github.com/vuejs/rollup-plugin-vue/tree/next) or [vue-loader](https://github.com/vuejs/vue-loader/tree/next).

webui/node_modules/@vue/compiler-sfc/dist/compiler-sfc.d.ts

@@ -0,0 +1,321 @@
+import { parse as babelParse } from '@babel/parser';
+import { BindingMetadata } from '@vue/compiler-core';
+import { CodegenResult } from '@vue/compiler-core';
+import { CompilerError } from '@vue/compiler-core';
+import { CompilerOptions } from '@vue/compiler-core';
+import { ElementNode } from '@vue/compiler-core';
+import { extractIdentifiers } from '@vue/compiler-core';
+import { generateCodeFrame } from '@vue/compiler-core';
+import { isInDestructureAssignment } from '@vue/compiler-core';
+import { isStaticProperty } from '@vue/compiler-core';
+import { LazyResult } from 'postcss';
+import MagicString from 'magic-string';
+import { ParserOptions } from '@vue/compiler-core';
+import { ParserPlugin } from '@babel/parser';
+import { RawSourceMap } from 'source-map';
+import { Result } from 'postcss';
+import { RootNode } from '@vue/compiler-core';
+import { shouldTransform as shouldTransformRef } from '@vue/reactivity-transform';
+import { SourceLocation } from '@vue/compiler-core';
+import { transform as transformRef } from '@vue/reactivity-transform';
+import { transformAST as transformRefAST } from '@vue/reactivity-transform';
+import { walkIdentifiers } from '@vue/compiler-core';
+
+export declare interface AssetURLOptions {
+    /**
+     * If base is provided, instead of transforming relative asset urls into
+     * imports, they will be directly rewritten to absolute urls.
+     */
+    base?: string | null;
+    /**
+     * If true, also processes absolute urls.
+     */
+    includeAbsolute?: boolean;
+    tags?: AssetURLTagConfig;
+}
+
+export declare interface AssetURLTagConfig {
+    [name: string]: string[];
+}
+
+export { babelParse }
+
+export { BindingMetadata }
+
+export { CompilerError }
+
+export { CompilerOptions }
+
+/**
+ * Compile `<script setup>`
+ * It requires the whole SFC descriptor because we need to handle and merge
+ * normal `<script>` + `<script setup>` if both are present.
+ */
+export declare function compileScript(sfc: SFCDescriptor, options: SFCScriptCompileOptions): SFCScriptBlock;
+
+export declare function compileStyle(options: SFCStyleCompileOptions): SFCStyleCompileResults;
+
+export declare function compileStyleAsync(options: SFCAsyncStyleCompileOptions): Promise<SFCStyleCompileResults>;
+
+export declare function compileTemplate(options: SFCTemplateCompileOptions): SFCTemplateCompileResults;
+
+/**
+ * Aligns with postcss-modules
+ * https://github.com/css-modules/postcss-modules
+ */
+declare interface CSSModulesOptions {
+    scopeBehaviour?: 'global' | 'local';
+    generateScopedName?: string | ((name: string, filename: string, css: string) => string);
+    hashPrefix?: string;
+    localsConvention?: 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly';
+    exportGlobals?: boolean;
+    globalModulePaths?: RegExp[];
+}
+
+export { extractIdentifiers }
+
+export { generateCodeFrame }
+
+declare interface ImportBinding {
+    isType: boolean;
+    imported: string;
+    source: string;
+    isFromSetup: boolean;
+    isUsedInTemplate: boolean;
+}
+
+export { isInDestructureAssignment }
+
+export { isStaticProperty }
+
+export { MagicString }
+
+export declare function parse(source: string, { sourceMap, filename, sourceRoot, pad, ignoreEmpty, compiler }?: SFCParseOptions): SFCParseResult;
+
+declare type PreprocessLang = 'less' | 'sass' | 'scss' | 'styl' | 'stylus';
+
+/**
+ * Utility for rewriting `export default` in a script block into a variable
+ * declaration so that we can inject things into it
+ */
+export declare function rewriteDefault(input: string, as: string, parserPlugins?: ParserPlugin[]): string;
+
+export declare interface SFCAsyncStyleCompileOptions extends SFCStyleCompileOptions {
+    isAsync?: boolean;
+    modules?: boolean;
+    modulesOptions?: CSSModulesOptions;
+}
+
+export declare interface SFCBlock {
+    type: string;
+    content: string;
+    attrs: Record<string, string | true>;
+    loc: SourceLocation;
+    map?: RawSourceMap;
+    lang?: string;
+    src?: string;
+}
+
+export declare interface SFCDescriptor {
+    filename: string;
+    source: string;
+    template: SFCTemplateBlock | null;
+    script: SFCScriptBlock | null;
+    scriptSetup: SFCScriptBlock | null;
+    styles: SFCStyleBlock[];
+    customBlocks: SFCBlock[];
+    cssVars: string[];
+    /**
+     * whether the SFC uses :slotted() modifier.
+     * this is used as a compiler optimization hint.
+     */
+    slotted: boolean;
+    /**
+     * compare with an existing descriptor to determine whether HMR should perform
+     * a reload vs. re-render.
+     *
+     * Note: this comparison assumes the prev/next script are already identical,
+     * and only checks the special case where <script setup lang="ts"> unused import
+     * pruning result changes due to template changes.
+     */
+    shouldForceReload: (prevImports: Record<string, ImportBinding>) => boolean;
+}
+
+export declare interface SFCParseOptions {
+    filename?: string;
+    sourceMap?: boolean;
+    sourceRoot?: string;
+    pad?: boolean | 'line' | 'space';
+    ignoreEmpty?: boolean;
+    compiler?: TemplateCompiler;
+}
+
+export declare interface SFCParseResult {
+    descriptor: SFCDescriptor;
+    errors: (CompilerError | SyntaxError)[];
+}
+
+export declare interface SFCScriptBlock extends SFCBlock {
+    type: 'script';
+    setup?: string | boolean;
+    bindings?: BindingMetadata;
+    imports?: Record<string, ImportBinding>;
+    /**
+     * import('\@babel/types').Statement
+     */
+    scriptAst?: any[];
+    /**
+     * import('\@babel/types').Statement
+     */
+    scriptSetupAst?: any[];
+}
+
+export declare interface SFCScriptCompileOptions {
+    /**
+     * Scope ID for prefixing injected CSS variables.
+     * This must be consistent with the `id` passed to `compileStyle`.
+     */
+    id: string;
+    /**
+     * Production mode. Used to determine whether to generate hashed CSS variables
+     */
+    isProd?: boolean;
+    /**
+     * Enable/disable source map. Defaults to true.
+     */
+    sourceMap?: boolean;
+    /**
+     * https://babeljs.io/docs/en/babel-parser#plugins
+     */
+    babelParserPlugins?: ParserPlugin[];
+    /**
+     * (Experimental) Enable syntax transform for using refs without `.value` and
+     * using destructured props with reactivity
+     */
+    reactivityTransform?: boolean;
+    /**
+     * (Experimental) Enable syntax transform for using refs without `.value`
+     * https://github.com/vuejs/rfcs/discussions/369
+     * @deprecated now part of `reactivityTransform`
+     * @default false
+     */
+    refTransform?: boolean;
+    /**
+     * (Experimental) Enable syntax transform for destructuring from defineProps()
+     * https://github.com/vuejs/rfcs/discussions/394
+     * @deprecated now part of `reactivityTransform`
+     * @default false
+     */
+    propsDestructureTransform?: boolean;
+    /**
+     * @deprecated use `reactivityTransform` instead.
+     */
+    refSugar?: boolean;
+    /**
+     * Compile the template and inline the resulting render function
+     * directly inside setup().
+     * - Only affects `<script setup>`
+     * - This should only be used in production because it prevents the template
+     * from being hot-reloaded separately from component state.
+     */
+    inlineTemplate?: boolean;
+    /**
+     * Options for template compilation when inlining. Note these are options that
+     * would normally be passed to `compiler-sfc`'s own `compileTemplate()`, not
+     * options passed to `compiler-dom`.
+     */
+    templateOptions?: Partial<SFCTemplateCompileOptions>;
+}
+
+export declare interface SFCStyleBlock extends SFCBlock {
+    type: 'style';
+    scoped?: boolean;
+    module?: string | boolean;
+}
+
+export declare interface SFCStyleCompileOptions {
+    source: string;
+    filename: string;
+    id: string;
+    scoped?: boolean;
+    trim?: boolean;
+    isProd?: boolean;
+    inMap?: RawSourceMap;
+    preprocessLang?: PreprocessLang;
+    preprocessOptions?: any;
+    preprocessCustomRequire?: (id: string) => any;
+    postcssOptions?: any;
+    postcssPlugins?: any[];
+    /**
+     * @deprecated use `inMap` instead.
+     */
+    map?: RawSourceMap;
+}
+
+export declare interface SFCStyleCompileResults {
+    code: string;
+    map: RawSourceMap | undefined;
+    rawResult: Result | LazyResult | undefined;
+    errors: Error[];
+    modules?: Record<string, string>;
+    dependencies: Set<string>;
+}
+
+export declare interface SFCTemplateBlock extends SFCBlock {
+    type: 'template';
+    ast: ElementNode;
+}
+
+export declare interface SFCTemplateCompileOptions {
+    source: string;
+    filename: string;
+    id: string;
+    scoped?: boolean;
+    slotted?: boolean;
+    isProd?: boolean;
+    ssr?: boolean;
+    ssrCssVars?: string[];
+    inMap?: RawSourceMap;
+    compiler?: TemplateCompiler;
+    compilerOptions?: CompilerOptions;
+    preprocessLang?: string;
+    preprocessOptions?: any;
+    /**
+     * In some cases, compiler-sfc may not be inside the project root (e.g. when
+     * linked or globally installed). In such cases a custom `require` can be
+     * passed to correctly resolve the preprocessors.
+     */
+    preprocessCustomRequire?: (id: string) => any;
+    /**
+     * Configure what tags/attributes to transform into asset url imports,
+     * or disable the transform altogether with `false`.
+     */
+    transformAssetUrls?: AssetURLOptions | AssetURLTagConfig | boolean;
+}
+
+export declare interface SFCTemplateCompileResults {
+    code: string;
+    ast?: RootNode;
+    preamble?: string;
+    source: string;
+    tips: string[];
+    errors: (string | CompilerError)[];
+    map?: RawSourceMap;
+}
+
+export { shouldTransformRef }
+
+export declare interface TemplateCompiler {
+    compile(template: string, options: CompilerOptions): CodegenResult;
+    parse(template: string, options: ParserOptions): RootNode;
+}
+
+export { transformRef }
+
+export { transformRefAST }
+
+export declare const walk: any;
+
+export { walkIdentifiers }
+
+export { }

webui/node_modules/@vue/compiler-sfc/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@vue/compiler-sfc",
+  "version": "3.2.37",
+  "description": "@vue/compiler-sfc",
+  "main": "dist/compiler-sfc.cjs.js",
+  "module": "dist/compiler-sfc.esm-browser.js",
+  "types": "dist/compiler-sfc.d.ts",
+  "files": [
+    "dist"
+  ],
+  "buildOptions": {
+    "name": "VueCompilerSFC",
+    "formats": [
+      "cjs",
+      "esm-browser"
+    ],
+    "prod": false,
+    "enableNonBrowserBranches": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-sfc"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-sfc#readme",
+  "dependencies": {
+    "@babel/parser": "^7.16.4",
+    "@vue/compiler-core": "3.2.37",
+    "@vue/compiler-dom": "3.2.37",
+    "@vue/compiler-ssr": "3.2.37",
+    "@vue/reactivity-transform": "3.2.37",
+    "@vue/shared": "3.2.37",
+    "estree-walker": "^2.0.2",
+    "magic-string": "^0.25.7",
+    "source-map": "^0.6.1",
+    "postcss": "^8.1.10"
+  },
+  "devDependencies": {
+    "@types/estree": "^0.0.48",
+    "@babel/types": "^7.16.0",
+    "@types/lru-cache": "^5.1.0",
+    "pug": "^3.0.1",
+    "sass": "^1.26.9",
+    "@vue/consolidate": "^0.17.3",
+    "hash-sum": "^2.0.0",
+    "lru-cache": "^5.1.1",
+    "merge-source-map": "^1.1.0",
+    "postcss-modules": "^4.0.0",
+    "postcss-selector-parser": "^6.0.4"
+  }
+}

webui/node_modules/@vue/compiler-ssr/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

webui/node_modules/@vue/compiler-ssr/README.md

@@ -0,0 +1 @@
+# @vue/compiler-ssr

webui/node_modules/@vue/compiler-ssr/dist/compiler-ssr.d.ts

@@ -0,0 +1,6 @@
+import { CodegenResult } from '@vue/compiler-dom';
+import { CompilerOptions } from '@vue/compiler-dom';
+
+export declare function compile(template: string, options?: CompilerOptions): CodegenResult;
+
+export { }

webui/node_modules/@vue/compiler-ssr/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@vue/compiler-ssr",
+  "version": "3.2.37",
+  "description": "@vue/compiler-ssr",
+  "main": "dist/compiler-ssr.cjs.js",
+  "types": "dist/compiler-ssr.d.ts",
+  "files": [
+    "dist"
+  ],
+  "buildOptions": {
+    "prod": false,
+    "formats": [
+      "cjs"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/compiler-ssr"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-ssr#readme",
+  "dependencies": {
+    "@vue/shared": "3.2.37",
+    "@vue/compiler-dom": "3.2.37"
+  }
+}

webui/node_modules/@vue/devtools-api/lib/cjs/api/api.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

webui/node_modules/@vue/devtools-api/lib/cjs/api/app.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

webui/node_modules/@vue/devtools-api/lib/cjs/api/component.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

webui/node_modules/@vue/devtools-api/lib/cjs/api/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

webui/node_modules/@vue/devtools-api/lib/cjs/api/hooks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

webui/node_modules/@vue/devtools-api/lib/cjs/api/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api.js"), exports);
+__exportStar(require("./app.js"), exports);
+__exportStar(require("./component.js"), exports);
+__exportStar(require("./context.js"), exports);
+__exportStar(require("./hooks.js"), exports);
+__exportStar(require("./util.js"), exports);

webui/node_modules/@vue/devtools-api/lib/cjs/api/util.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

webui/node_modules/@vue/devtools-api/lib/cjs/const.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOOK_PLUGIN_SETTINGS_SET = exports.HOOK_SETUP = void 0;
+exports.HOOK_SETUP = 'devtools-plugin:setup';
+exports.HOOK_PLUGIN_SETTINGS_SET = 'plugin:settings:set';

webui/node_modules/@vue/devtools-api/lib/cjs/env.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProxyAvailable = exports.getTarget = exports.getDevtoolsGlobalHook = void 0;
+function getDevtoolsGlobalHook() {
+    return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;
+}
+exports.getDevtoolsGlobalHook = getDevtoolsGlobalHook;
+function getTarget() {
+    // @ts-ignore
+    return (typeof navigator !== 'undefined' && typeof window !== 'undefined')
+        ? window
+        : typeof global !== 'undefined'
+            ? global
+            : {};
+}
+exports.getTarget = getTarget;
+exports.isProxyAvailable = typeof Proxy === 'function';

webui/node_modules/@vue/devtools-api/lib/cjs/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupDevtoolsPlugin = void 0;
+const env_js_1 = require("./env.js");
+const const_js_1 = require("./const.js");
+const proxy_js_1 = require("./proxy.js");
+__exportStar(require("./api/index.js"), exports);
+__exportStar(require("./plugin.js"), exports);
+__exportStar(require("./time.js"), exports);
+function setupDevtoolsPlugin(pluginDescriptor, setupFn) {
+    const descriptor = pluginDescriptor;
+    const target = (0, env_js_1.getTarget)();
+    const hook = (0, env_js_1.getDevtoolsGlobalHook)();
+    const enableProxy = env_js_1.isProxyAvailable && descriptor.enableEarlyProxy;
+    if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {
+        hook.emit(const_js_1.HOOK_SETUP, pluginDescriptor, setupFn);
+    }
+    else {
+        const proxy = enableProxy ? new proxy_js_1.ApiProxy(descriptor, hook) : null;
+        const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];
+        list.push({
+            pluginDescriptor: descriptor,
+            setupFn,
+            proxy,
+        });
+        if (proxy)
+            setupFn(proxy.proxiedTarget);
+    }
+}
+exports.setupDevtoolsPlugin = setupDevtoolsPlugin;

webui/node_modules/@vue/devtools-api/lib/cjs/plugin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

webui/node_modules/@vue/devtools-api/lib/cjs/proxy.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiProxy = void 0;
+const const_js_1 = require("./const.js");
+const time_js_1 = require("./time.js");
+class ApiProxy {
+    constructor(plugin, hook) {
+        this.target = null;
+        this.targetQueue = [];
+        this.onQueue = [];
+        this.plugin = plugin;
+        this.hook = hook;
+        const defaultSettings = {};
+        if (plugin.settings) {
+            for (const id in plugin.settings) {
+                const item = plugin.settings[id];
+                defaultSettings[id] = item.defaultValue;
+            }
+        }
+        const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`;
+        let currentSettings = Object.assign({}, defaultSettings);
+        try {
+            const raw = localStorage.getItem(localSettingsSaveId);
+            const data = JSON.parse(raw);
+            Object.assign(currentSettings, data);
+        }
+        catch (e) {
+            // noop
+        }
+        this.fallbacks = {
+            getSettings() {
+                return currentSettings;
+            },
+            setSettings(value) {
+                try {
+                    localStorage.setItem(localSettingsSaveId, JSON.stringify(value));
+                }
+                catch (e) {
+                    // noop
+                }
+                currentSettings = value;
+            },
+            now() {
+                return (0, time_js_1.now)();
+            },
+        };
+        if (hook) {
+            hook.on(const_js_1.HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {
+                if (pluginId === this.plugin.id) {
+                    this.fallbacks.setSettings(value);
+                }
+            });
+        }
+        this.proxiedOn = new Proxy({}, {
+            get: (_target, prop) => {
+                if (this.target) {
+                    return this.target.on[prop];
+                }
+                else {
+                    return (...args) => {
+                        this.onQueue.push({
+                            method: prop,
+                            args,
+                        });
+                    };
+                }
+            },
+        });
+        this.proxiedTarget = new Proxy({}, {
+            get: (_target, prop) => {
+                if (this.target) {
+                    return this.target[prop];
+                }
+                else if (prop === 'on') {
+                    return this.proxiedOn;
+                }
+                else if (Object.keys(this.fallbacks).includes(prop)) {
+                    return (...args) => {
+                        this.targetQueue.push({
+                            method: prop,
+                            args,
+                            resolve: () => { },
+                        });
+                        return this.fallbacks[prop](...args);
+                    };
+                }
+                else {
+                    return (...args) => {
+                        return new Promise(resolve => {
+                            this.targetQueue.push({
+                                method: prop,
+                                args,
+                                resolve,
+                            });
+                        });
+                    };
+                }
+            },
+        });
+    }
+    async setRealTarget(target) {
+        this.target = target;
+        for (const item of this.onQueue) {
+            this.target.on[item.method](...item.args);
+        }
+        for (const item of this.targetQueue) {
+            item.resolve(await this.target[item.method](...item.args));
+        }
+    }
+}
+exports.ApiProxy = ApiProxy;

webui/node_modules/@vue/devtools-api/lib/cjs/time.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.now = exports.isPerformanceSupported = void 0;
+let supported;
+let perf;
+function isPerformanceSupported() {
+    var _a;
+    if (supported !== undefined) {
+        return supported;
+    }
+    if (typeof window !== 'undefined' && window.performance) {
+        supported = true;
+        perf = window.performance;
+    }
+    else if (typeof global !== 'undefined' && ((_a = global.perf_hooks) === null || _a === void 0 ? void 0 : _a.performance)) {
+        supported = true;
+        perf = global.perf_hooks.performance;
+    }
+    else {
+        supported = false;
+    }
+    return supported;
+}
+exports.isPerformanceSupported = isPerformanceSupported;
+function now() {
+    return isPerformanceSupported() ? perf.now() : Date.now();
+}
+exports.now = now;

webui/node_modules/@vue/devtools-api/lib/esm/api/api.d.ts

@@ -0,0 +1,108 @@
+import type { ComponentBounds, Hookable } from './hooks.js';
+import type { Context } from './context.js';
+import type { ComponentInstance, ComponentState, StateBase } from './component.js';
+import type { App } from './app.js';
+import type { ID } from './util.js';
+export interface DevtoolsPluginApi<TSettings> {
+    on: Hookable<Context>;
+    notifyComponentUpdate(instance?: ComponentInstance): void;
+    addTimelineLayer(options: TimelineLayerOptions): void;
+    addTimelineEvent(options: TimelineEventOptions): void;
+    addInspector(options: CustomInspectorOptions): void;
+    sendInspectorTree(inspectorId: string): void;
+    sendInspectorState(inspectorId: string): void;
+    selectInspectorNode(inspectorId: string, nodeId: string): void;
+    getComponentBounds(instance: ComponentInstance): Promise<ComponentBounds>;
+    getComponentName(instance: ComponentInstance): Promise<string>;
+    getComponentInstances(app: App): Promise<ComponentInstance[]>;
+    highlightElement(instance: ComponentInstance): void;
+    unhighlightElement(): void;
+    getSettings(pluginId?: string): TSettings;
+    now(): number;
+    /**
+     * @private Not implemented yet
+     */
+    setSettings(values: TSettings): void;
+}
+export interface AppRecord {
+    id: string;
+    name: string;
+    instanceMap: Map<string, ComponentInstance>;
+    rootInstance: ComponentInstance;
+}
+export interface TimelineLayerOptions<TData = any, TMeta = any> {
+    id: string;
+    label: string;
+    color: number;
+    skipScreenshots?: boolean;
+    groupsOnly?: boolean;
+    ignoreNoDurationGroups?: boolean;
+    screenshotOverlayRender?: (event: TimelineEvent<TData, TMeta> & ScreenshotOverlayEvent, ctx: ScreenshotOverlayRenderContext) => ScreenshotOverlayRenderResult | Promise<ScreenshotOverlayRenderResult>;
+}
+export interface ScreenshotOverlayEvent {
+    layerId: string;
+    renderMeta: any;
+}
+export interface ScreenshotOverlayRenderContext<TData = any, TMeta = any> {
+    screenshot: ScreenshotData;
+    events: (TimelineEvent<TData, TMeta> & ScreenshotOverlayEvent)[];
+    index: number;
+}
+export declare type ScreenshotOverlayRenderResult = HTMLElement | string | false;
+export interface ScreenshotData {
+    time: number;
+}
+export interface TimelineEventOptions {
+    layerId: string;
+    event: TimelineEvent;
+    all?: boolean;
+}
+export interface TimelineEvent<TData = any, TMeta = any> {
+    time: number;
+    data: TData;
+    logType?: 'default' | 'warning' | 'error';
+    meta?: TMeta;
+    groupId?: ID;
+    title?: string;
+    subtitle?: string;
+}
+export interface TimelineMarkerOptions {
+    id: string;
+    time: number;
+    color: number;
+    label: string;
+    all?: boolean;
+}
+export interface CustomInspectorOptions {
+    id: string;
+    label: string;
+    icon?: string;
+    treeFilterPlaceholder?: string;
+    stateFilterPlaceholder?: string;
+    noSelectionText?: string;
+    actions?: {
+        icon: string;
+        tooltip?: string;
+        action: () => void | Promise<void>;
+    }[];
+    nodeActions?: {
+        icon: string;
+        tooltip?: string;
+        action: (nodeId: string) => void | Promise<void>;
+    }[];
+}
+export interface CustomInspectorNode {
+    id: string;
+    label: string;
+    children?: CustomInspectorNode[];
+    tags?: InspectorNodeTag[];
+}
+export interface InspectorNodeTag {
+    label: string;
+    textColor: number;
+    backgroundColor: number;
+    tooltip?: string;
+}
+export interface CustomInspectorState {
+    [key: string]: (StateBase | Omit<ComponentState, 'type'>)[];
+}

webui/node_modules/@vue/devtools-api/lib/esm/api/api.js

@@ -0,0 +1 @@
+export {};

webui/node_modules/@vue/devtools-api/lib/esm/api/app.d.ts

@@ -0,0 +1 @@
+export declare type App = any;

webui/node_modules/@vue/devtools-api/lib/esm/api/app.js

@@ -0,0 +1 @@
+export {};

webui/node_modules/@vue/devtools-api/lib/esm/api/component.d.ts

@@ -0,0 +1,77 @@
+import type { InspectorNodeTag } from './api.js';
+import type { ID } from './util.js';
+export declare type ComponentInstance = any;
+export interface ComponentTreeNode {
+    uid: ID;
+    id: string;
+    name: string;
+    renderKey: string | number;
+    inactive: boolean;
+    isFragment: boolean;
+    hasChildren: boolean;
+    children: ComponentTreeNode[];
+    domOrder?: number[];
+    consoleId?: string;
+    isRouterView?: boolean;
+    macthedRouteSegment?: string;
+    tags: InspectorNodeTag[];
+    meta?: any;
+}
+export interface InspectedComponentData {
+    id: string;
+    name: string;
+    file: string;
+    state: ComponentState[];
+    functional?: boolean;
+}
+export interface StateBase {
+    key: string;
+    value: any;
+    editable?: boolean;
+    objectType?: 'ref' | 'reactive' | 'computed' | 'other';
+    raw?: string;
+}
+export interface ComponentStateBase extends StateBase {
+    type: string;
+}
+export interface ComponentPropState extends ComponentStateBase {
+    meta?: {
+        type: string;
+        required: boolean;
+        /** Vue 1 only */
+        mode?: 'default' | 'sync' | 'once';
+    };
+}
+export declare type ComponentBuiltinCustomStateTypes = 'function' | 'map' | 'set' | 'reference' | 'component' | 'component-definition' | 'router' | 'store';
+export interface ComponentCustomState extends ComponentStateBase {
+    value: CustomState;
+}
+export declare type CustomState = {
+    _custom: {
+        type: ComponentBuiltinCustomStateTypes | string;
+        objectType?: string;
+        display?: string;
+        tooltip?: string;
+        value?: any;
+        abstract?: boolean;
+        file?: string;
+        uid?: number;
+        readOnly?: boolean;
+        /** Configure immediate child fields */
+        fields?: {
+            abstract?: boolean;
+        };
+        id?: any;
+        actions?: {
+            icon: string;
+            tooltip?: string;
+            action: () => void | Promise<void>;
+        }[];
+        /** internal */
+        _reviveId?: number;
+    };
+};
+export declare type ComponentState = ComponentStateBase | ComponentPropState | ComponentCustomState;
+export interface ComponentDevtoolsOptions {
+    hide?: boolean;
+}

webui/node_modules/@vue/devtools-api/lib/esm/api/component.js

@@ -0,0 +1 @@
+export {};

webui/node_modules/@vue/devtools-api/lib/esm/api/context.d.ts

@@ -0,0 +1,5 @@
+import type { AppRecord } from './api.js';
+export interface Context {
+    currentTab: string;
+    currentAppRecord: AppRecord;
+}

webui/node_modules/@vue/devtools-api/lib/esm/api/context.js

@@ -0,0 +1 @@
+export {};

webui/node_modules/@vue/devtools-api/lib/esm/api/hooks.d.ts

@@ -0,0 +1,179 @@
+import type { ComponentTreeNode, InspectedComponentData, ComponentInstance, ComponentDevtoolsOptions } from './component.js';
+import type { App } from './app.js';
+import type { CustomInspectorNode, CustomInspectorState, TimelineEvent } from './api.js';
+export declare const enum Hooks {
+    TRANSFORM_CALL = "transformCall",
+    GET_APP_RECORD_NAME = "getAppRecordName",
+    GET_APP_ROOT_INSTANCE = "getAppRootInstance",
+    REGISTER_APPLICATION = "registerApplication",
+    WALK_COMPONENT_TREE = "walkComponentTree",
+    VISIT_COMPONENT_TREE = "visitComponentTree",
+    WALK_COMPONENT_PARENTS = "walkComponentParents",
+    INSPECT_COMPONENT = "inspectComponent",
+    GET_COMPONENT_BOUNDS = "getComponentBounds",
+    GET_COMPONENT_NAME = "getComponentName",
+    GET_COMPONENT_INSTANCES = "getComponentInstances",
+    GET_ELEMENT_COMPONENT = "getElementComponent",
+    GET_COMPONENT_ROOT_ELEMENTS = "getComponentRootElements",
+    EDIT_COMPONENT_STATE = "editComponentState",
+    GET_COMPONENT_DEVTOOLS_OPTIONS = "getAppDevtoolsOptions",
+    GET_COMPONENT_RENDER_CODE = "getComponentRenderCode",
+    INSPECT_TIMELINE_EVENT = "inspectTimelineEvent",
+    TIMELINE_CLEARED = "timelineCleared",
+    GET_INSPECTOR_TREE = "getInspectorTree",
+    GET_INSPECTOR_STATE = "getInspectorState",
+    EDIT_INSPECTOR_STATE = "editInspectorState",
+    SET_PLUGIN_SETTINGS = "setPluginSettings"
+}
+export interface ComponentBounds {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare type HookPayloads = {
+    [Hooks.TRANSFORM_CALL]: {
+        callName: string;
+        inArgs: any[];
+        outArgs: any[];
+    };
+    [Hooks.GET_APP_RECORD_NAME]: {
+        app: App;
+        name: string;
+    };
+    [Hooks.GET_APP_ROOT_INSTANCE]: {
+        app: App;
+        root: ComponentInstance;
+    };
+    [Hooks.REGISTER_APPLICATION]: {
+        app: App;
+    };
+    [Hooks.WALK_COMPONENT_TREE]: {
+        componentInstance: ComponentInstance;
+        componentTreeData: ComponentTreeNode[];
+        maxDepth: number;
+        filter: string;
+    };
+    [Hooks.VISIT_COMPONENT_TREE]: {
+        app: App;
+        componentInstance: ComponentInstance;
+        treeNode: ComponentTreeNode;
+        filter: string;
+    };
+    [Hooks.WALK_COMPONENT_PARENTS]: {
+        componentInstance: ComponentInstance;
+        parentInstances: ComponentInstance[];
+    };
+    [Hooks.INSPECT_COMPONENT]: {
+        app: App;
+        componentInstance: ComponentInstance;
+        instanceData: InspectedComponentData;
+    };
+    [Hooks.GET_COMPONENT_BOUNDS]: {
+        componentInstance: ComponentInstance;
+        bounds: ComponentBounds;
+    };
+    [Hooks.GET_COMPONENT_NAME]: {
+        componentInstance: ComponentInstance;
+        name: string;
+    };
+    [Hooks.GET_COMPONENT_INSTANCES]: {
+        app: App;
+        componentInstances: ComponentInstance[];
+    };
+    [Hooks.GET_ELEMENT_COMPONENT]: {
+        element: HTMLElement | any;
+        componentInstance: ComponentInstance;
+    };
+    [Hooks.GET_COMPONENT_ROOT_ELEMENTS]: {
+        componentInstance: ComponentInstance;
+        rootElements: (HTMLElement | any)[];
+    };
+    [Hooks.EDIT_COMPONENT_STATE]: {
+        app: App;
+        componentInstance: ComponentInstance;
+        path: string[];
+        type: string;
+        state: EditStatePayload;
+        set: (object: any, path?: string | (string[]), value?: any, cb?: (object: any, field: string, value: any) => void) => void;
+    };
+    [Hooks.GET_COMPONENT_DEVTOOLS_OPTIONS]: {
+        componentInstance: ComponentInstance;
+        options: ComponentDevtoolsOptions;
+    };
+    [Hooks.GET_COMPONENT_RENDER_CODE]: {
+        componentInstance: ComponentInstance;
+        code: string;
+    };
+    [Hooks.INSPECT_TIMELINE_EVENT]: {
+        app: App;
+        layerId: string;
+        event: TimelineEvent;
+        all?: boolean;
+        data: any;
+    };
+    [Hooks.TIMELINE_CLEARED]: Record<string, never>;
+    [Hooks.GET_INSPECTOR_TREE]: {
+        app: App;
+        inspectorId: string;
+        filter: string;
+        rootNodes: CustomInspectorNode[];
+    };
+    [Hooks.GET_INSPECTOR_STATE]: {
+        app: App;
+        inspectorId: string;
+        nodeId: string;
+        state: CustomInspectorState;
+    };
+    [Hooks.EDIT_INSPECTOR_STATE]: {
+        app: App;
+        inspectorId: string;
+        nodeId: string;
+        path: string[];
+        type: string;
+        state: EditStatePayload;
+        set: (object: any, path?: string | (string[]), value?: any, cb?: (object: any, field: string, value: any) => void) => void;
+    };
+    [Hooks.SET_PLUGIN_SETTINGS]: {
+        app: App;
+        pluginId: string;
+        key: string;
+        newValue: any;
+        oldValue: any;
+        settings: any;
+    };
+};
+export declare type EditStatePayload = {
+    value: any;
+    newKey?: string | null;
+    remove?: undefined | false;
+} | {
+    value?: undefined;
+    newKey?: undefined;
+    remove: true;
+};
+export declare type HookHandler<TPayload, TContext> = (payload: TPayload, ctx: TContext) => void | Promise<void>;
+export interface Hookable<TContext> {
+    transformCall(handler: HookHandler<HookPayloads[Hooks.TRANSFORM_CALL], TContext>): any;
+    getAppRecordName(handler: HookHandler<HookPayloads[Hooks.GET_APP_RECORD_NAME], TContext>): any;
+    getAppRootInstance(handler: HookHandler<HookPayloads[Hooks.GET_APP_ROOT_INSTANCE], TContext>): any;
+    registerApplication(handler: HookHandler<HookPayloads[Hooks.REGISTER_APPLICATION], TContext>): any;
+    walkComponentTree(handler: HookHandler<HookPayloads[Hooks.WALK_COMPONENT_TREE], TContext>): any;
+    visitComponentTree(handler: HookHandler<HookPayloads[Hooks.VISIT_COMPONENT_TREE], TContext>): any;
+    walkComponentParents(handler: HookHandler<HookPayloads[Hooks.WALK_COMPONENT_PARENTS], TContext>): any;
+    inspectComponent(handler: HookHandler<HookPayloads[Hooks.INSPECT_COMPONENT], TContext>): any;
+    getComponentBounds(handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_BOUNDS], TContext>): any;
+    getComponentName(handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_NAME], TContext>): any;
+    getComponentInstances(handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_INSTANCES], TContext>): any;
+    getElementComponent(handler: HookHandler<HookPayloads[Hooks.GET_ELEMENT_COMPONENT], TContext>): any;
+    getComponentRootElements(handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_ROOT_ELEMENTS], TContext>): any;
+    editComponentState(handler: HookHandler<HookPayloads[Hooks.EDIT_COMPONENT_STATE], TContext>): any;
+    getComponentDevtoolsOptions(handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_DEVTOOLS_OPTIONS], TContext>): any;
+    getComponentRenderCode(handler: HookHandler<HookPayloads[Hooks.GET_COMPONENT_RENDER_CODE], TContext>): any;
+    inspectTimelineEvent(handler: HookHandler<HookPayloads[Hooks.INSPECT_TIMELINE_EVENT], TContext>): any;
+    timelineCleared(handler: HookHandler<HookPayloads[Hooks.TIMELINE_CLEARED], TContext>): any;
+    getInspectorTree(handler: HookHandler<HookPayloads[Hooks.GET_INSPECTOR_TREE], TContext>): any;
+    getInspectorState(handler: HookHandler<HookPayloads[Hooks.GET_INSPECTOR_STATE], TContext>): any;
+    editInspectorState(handler: HookHandler<HookPayloads[Hooks.EDIT_INSPECTOR_STATE], TContext>): any;
+    setPluginSettings(handler: HookHandler<HookPayloads[Hooks.SET_PLUGIN_SETTINGS], TContext>): any;
+}

webui/node_modules/@vue/devtools-api/lib/esm/api/hooks.js

@@ -0,0 +1 @@
+export {};

webui/node_modules/@vue/devtools-api/lib/esm/api/index.d.ts

@@ -0,0 +1,6 @@
+export * from './api.js';
+export * from './app.js';
+export * from './component.js';
+export * from './context.js';
+export * from './hooks.js';
+export * from './util.js';

webui/node_modules/@vue/devtools-api/lib/esm/api/index.js

@@ -0,0 +1,6 @@
+export * from './api.js';
+export * from './app.js';
+export * from './component.js';
+export * from './context.js';
+export * from './hooks.js';
+export * from './util.js';

webui/node_modules/@vue/devtools-api/lib/esm/api/util.d.ts

@@ -0,0 +1,4 @@
+export declare type ID = number | string;
+export interface WithId {
+    id: ID;
+}

webui/node_modules/@vue/devtools-api/lib/esm/api/util.js

@@ -0,0 +1 @@
+export {};

webui/node_modules/@vue/devtools-api/lib/esm/const.d.ts

@@ -0,0 +1,2 @@
+export declare const HOOK_SETUP = "devtools-plugin:setup";
+export declare const HOOK_PLUGIN_SETTINGS_SET = "plugin:settings:set";

webui/node_modules/@vue/devtools-api/lib/esm/const.js

@@ -0,0 +1,2 @@
+export const HOOK_SETUP = 'devtools-plugin:setup';
+export const HOOK_PLUGIN_SETTINGS_SET = 'plugin:settings:set';

webui/node_modules/@vue/devtools-api/lib/esm/env.d.ts

@@ -0,0 +1,15 @@
+import type { PluginDescriptor, SetupFunction } from './index.js';
+import type { ApiProxy } from './proxy.js';
+export interface PluginQueueItem {
+    pluginDescriptor: PluginDescriptor;
+    setupFn: SetupFunction;
+    proxy?: ApiProxy;
+}
+interface GlobalTarget {
+    __VUE_DEVTOOLS_PLUGINS__?: PluginQueueItem[];
+    __VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__?: boolean;
+}
+export declare function getDevtoolsGlobalHook(): any;
+export declare function getTarget(): GlobalTarget;
+export declare const isProxyAvailable: boolean;
+export {};

webui/node_modules/@vue/devtools-api/lib/esm/env.js

@@ -0,0 +1,12 @@
+export function getDevtoolsGlobalHook() {
+    return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;
+}
+export function getTarget() {
+    // @ts-ignore
+    return (typeof navigator !== 'undefined' && typeof window !== 'undefined')
+        ? window
+        : typeof global !== 'undefined'
+            ? global
+            : {};
+}
+export const isProxyAvailable = typeof Proxy === 'function';

webui/node_modules/@vue/devtools-api/lib/esm/index.d.ts

@@ -0,0 +1,18 @@
+import type { DevtoolsPluginApi } from './api/index.js';
+import type { PluginDescriptor, ExtractSettingsTypes, PluginSettingsItem } from './plugin.js';
+export * from './api/index.js';
+export * from './plugin.js';
+export * from './time.js';
+export { PluginQueueItem } from './env.js';
+declare type Cast<A, B> = A extends B ? A : B;
+declare type Narrowable = string | number | bigint | boolean;
+declare type Narrow<A> = Cast<A, [] | (A extends Narrowable ? A : never) | ({
+    [K in keyof A]: Narrow<A[K]>;
+})>;
+declare type Exact<C, T> = {
+    [K in keyof C]: K extends keyof T ? T[K] : never;
+};
+export declare type SetupFunction<TSettings = any> = (api: DevtoolsPluginApi<TSettings>) => void;
+export declare function setupDevtoolsPlugin<TDescriptor extends Exact<TDescriptor, PluginDescriptor>, TSettings = ExtractSettingsTypes<TDescriptor extends {
+    settings: infer S;
+} ? S extends Record<string, PluginSettingsItem> ? S : Record<string, PluginSettingsItem> : Record<string, PluginSettingsItem>>>(pluginDescriptor: Narrow<TDescriptor>, setupFn: SetupFunction<TSettings>): void;

webui/node_modules/@vue/devtools-api/lib/esm/index.js

@@ -0,0 +1,26 @@
+import { getTarget, getDevtoolsGlobalHook, isProxyAvailable } from './env.js';
+import { HOOK_SETUP } from './const.js';
+import { ApiProxy } from './proxy.js';
+export * from './api/index.js';
+export * from './plugin.js';
+export * from './time.js';
+export function setupDevtoolsPlugin(pluginDescriptor, setupFn) {
+    const descriptor = pluginDescriptor;
+    const target = getTarget();
+    const hook = getDevtoolsGlobalHook();
+    const enableProxy = isProxyAvailable && descriptor.enableEarlyProxy;
+    if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {
+        hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);
+    }
+    else {
+        const proxy = enableProxy ? new ApiProxy(descriptor, hook) : null;
+        const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];
+        list.push({
+            pluginDescriptor: descriptor,
+            setupFn,
+            proxy,
+        });
+        if (proxy)
+            setupFn(proxy.proxiedTarget);
+    }
+}

webui/node_modules/@vue/devtools-api/lib/esm/plugin.d.ts

@@ -0,0 +1,47 @@
+import type { App } from './api/index.js';
+export interface PluginDescriptor {
+    id: string;
+    label: string;
+    app: App;
+    packageName?: string;
+    homepage?: string;
+    componentStateTypes?: string[];
+    logo?: string;
+    disableAppScope?: boolean;
+    disablePluginScope?: boolean;
+    /**
+     * Run the plugin setup and expose the api even if the devtools is not opened yet.
+     * Useful to record timeline events early.
+     */
+    enableEarlyProxy?: boolean;
+    settings?: Record<string, PluginSettingsItem>;
+}
+export declare type PluginSettingsItem = {
+    label: string;
+    description?: string;
+} & ({
+    type: 'boolean';
+    defaultValue: boolean;
+} | {
+    type: 'choice';
+    defaultValue: string | number;
+    options: {
+        value: string | number;
+        label: string;
+    }[];
+    component?: 'select' | 'button-group';
+} | {
+    type: 'text';
+    defaultValue: string;
+});
+declare type InferSettingsType<T extends PluginSettingsItem> = [T] extends [{
+    type: 'boolean';
+}] ? boolean : [T] extends [{
+    type: 'choice';
+}] ? T['options'][number]['value'] : [T] extends [{
+    type: 'text';
+}] ? string : unknown;
+export declare type ExtractSettingsTypes<O extends Record<string, PluginSettingsItem>> = {
+    [K in keyof O]: InferSettingsType<O[K]>;
+};
+export {};

webui/node_modules/@vue/devtools-api/lib/esm/plugin.js

@@ -0,0 +1 @@
+export {};

webui/node_modules/@vue/devtools-api/lib/esm/proxy.d.ts

@@ -0,0 +1,20 @@
+import type { Context, DevtoolsPluginApi, Hookable } from './api/index.js';
+import type { PluginDescriptor } from './plugin.js';
+interface QueueItem {
+    method: string;
+    args: any[];
+    resolve?: (value?: any) => void;
+}
+export declare class ApiProxy<TTarget extends DevtoolsPluginApi<any> = DevtoolsPluginApi<any>> {
+    target: TTarget | null;
+    targetQueue: QueueItem[];
+    proxiedTarget: TTarget;
+    onQueue: QueueItem[];
+    proxiedOn: Hookable<Context>;
+    plugin: PluginDescriptor;
+    hook: any;
+    fallbacks: Record<string, any>;
+    constructor(plugin: PluginDescriptor, hook: any);
+    setRealTarget(target: TTarget): Promise<void>;
+}
+export {};

webui/node_modules/@vue/devtools-api/lib/esm/proxy.js

@@ -0,0 +1,107 @@
+import { HOOK_PLUGIN_SETTINGS_SET } from './const.js';
+import { now } from './time.js';
+export class ApiProxy {
+    constructor(plugin, hook) {
+        this.target = null;
+        this.targetQueue = [];
+        this.onQueue = [];
+        this.plugin = plugin;
+        this.hook = hook;
+        const defaultSettings = {};
+        if (plugin.settings) {
+            for (const id in plugin.settings) {
+                const item = plugin.settings[id];
+                defaultSettings[id] = item.defaultValue;
+            }
+        }
+        const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`;
+        let currentSettings = Object.assign({}, defaultSettings);
+        try {
+            const raw = localStorage.getItem(localSettingsSaveId);
+            const data = JSON.parse(raw);
+            Object.assign(currentSettings, data);
+        }
+        catch (e) {
+            // noop
+        }
+        this.fallbacks = {
+            getSettings() {
+                return currentSettings;
+            },
+            setSettings(value) {
+                try {
+                    localStorage.setItem(localSettingsSaveId, JSON.stringify(value));
+                }
+                catch (e) {
+                    // noop
+                }
+                currentSettings = value;
+            },
+            now() {
+                return now();
+            },
+        };
+        if (hook) {
+            hook.on(HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {
+                if (pluginId === this.plugin.id) {
+                    this.fallbacks.setSettings(value);
+                }
+            });
+        }
+        this.proxiedOn = new Proxy({}, {
+            get: (_target, prop) => {
+                if (this.target) {
+                    return this.target.on[prop];
+                }
+                else {
+                    return (...args) => {
+                        this.onQueue.push({
+                            method: prop,
+                            args,
+                        });
+                    };
+                }
+            },
+        });
+        this.proxiedTarget = new Proxy({}, {
+            get: (_target, prop) => {
+                if (this.target) {
+                    return this.target[prop];
+                }
+                else if (prop === 'on') {
+                    return this.proxiedOn;
+                }
+                else if (Object.keys(this.fallbacks).includes(prop)) {
+                    return (...args) => {
+                        this.targetQueue.push({
+                            method: prop,
+                            args,
+                            resolve: () => { },
+                        });
+                        return this.fallbacks[prop](...args);
+                    };
+                }
+                else {
+                    return (...args) => {
+                        return new Promise(resolve => {
+                            this.targetQueue.push({
+                                method: prop,
+                                args,
+                                resolve,
+                            });
+                        });
+                    };
+                }
+            },
+        });
+    }
+    async setRealTarget(target) {
+        this.target = target;
+        for (const item of this.onQueue) {
+            this.target.on[item.method](...item.args);
+        }
+        for (const item of this.targetQueue) {
+            item.resolve(await this.target[item.method](...item.args));
+        }
+    }
+}

webui/node_modules/@vue/devtools-api/lib/esm/time.d.ts

@@ -0,0 +1,2 @@
+export declare function isPerformanceSupported(): boolean;
+export declare function now(): number;

webui/node_modules/@vue/devtools-api/lib/esm/time.js

@@ -0,0 +1,23 @@
+let supported;
+let perf;
+export function isPerformanceSupported() {
+    var _a;
+    if (supported !== undefined) {
+        return supported;
+    }
+    if (typeof window !== 'undefined' && window.performance) {
+        supported = true;
+        perf = window.performance;
+    }
+    else if (typeof global !== 'undefined' && ((_a = global.perf_hooks) === null || _a === void 0 ? void 0 : _a.performance)) {
+        supported = true;
+        perf = global.perf_hooks.performance;
+    }
+    else {
+        supported = false;
+    }
+    return supported;
+}
+export function now() {
+    return isPerformanceSupported() ? perf.now() : Date.now();
+}

webui/node_modules/@vue/devtools-api/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@vue/devtools-api",
+  "version": "6.2.1",
+  "description": "Interact with the Vue devtools from the page",
+  "main": "lib/cjs/index.js",
+  "browser": "lib/esm/index.js",
+  "module": "lib/esm/index.js",
+  "types": "lib/esm/index.d.ts",
+  "sideEffects": false,
+  "author": {
+    "name": "Guillaume Chau"
+  },
+  "files": [
+    "lib/esm",
+    "lib/cjs"
+  ],
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/vuejs/vue-devtools.git",
+    "type": "git",
+    "directory": "packages/api"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rimraf lib && yarn build:esm && yarn build:cjs",
+    "build:esm": "tsc --module es2015 --outDir lib/esm -d",
+    "build:cjs": "tsc --module commonjs --outDir lib/cjs",
+    "build:watch": "yarn tsc --module es2015 --outDir lib/esm -d -w --sourceMap"
+  },
+  "devDependencies": {
+    "@types/node": "^13.9.1",
+    "@types/webpack-env": "^1.15.1",
+    "typescript": "^4.5.2"
+  }
+}

webui/node_modules/@vue/reactivity-transform/README.md

@@ -0,0 +1,121 @@
+# @vue/reactivity-transform
+
+> ⚠️ This is experimental and currently only provided for testing and feedback. It may break during patches or even be removed. Use at your own risk!
+>
+> Follow https://github.com/vuejs/rfcs/discussions/369 for details and updates.
+
+## Basic Rules
+
+- Ref-creating APIs have `$`-prefixed versions that create reactive variables instead. They also do not need to be explicitly imported. These include:
+  - `ref`
+  - `computed`
+  - `shallowRef`
+  - `customRef`
+  - `toRef`
+- `$()` can be used to destructure an object into reactive variables, or turn existing refs into reactive variables
+- `$$()` to "escape" the transform, which allows access to underlying refs
+
+```js
+import { watchEffect } from 'vue'
+
+// bind ref as a variable
+let count = $ref(0)
+
+watchEffect(() => {
+  // no need for .value
+  console.log(count)
+})
+
+// assignments are reactive
+count++
+
+// get the actual ref
+console.log($$(count)) // { value: 1 }
+```
+
+Macros can be optionally imported to make it more explicit:
+
+```js
+// not necessary, but also works
+import { $, $ref } from 'vue/macros'
+
+let count = $ref(0)
+const { x, y } = $(useMouse())
+```
+
+### Global Types
+
+To enable types for the macros globally, include the following in a `.d.ts` file:
+
+```ts
+/// <reference types="vue/macros-global" />
+```
+
+## API
+
+This package is the lower-level transform that can be used standalone. Higher-level tooling (e.g. `@vitejs/plugin-vue` and `vue-loader`) will provide integration via options.
+
+### `shouldTransform`
+
+Can be used to do a cheap check to determine whether full transform should be performed.
+
+```js
+import { shouldTransform } from '@vue/reactivity-transform'
+
+shouldTransform(`let a = ref(0)`) // false
+shouldTransform(`let a = $ref(0)`) // true
+```
+
+### `transform`
+
+```js
+import { transform } from '@vue/reactivity-transform'
+
+const src = `let a = $ref(0); a++`
+const {
+  code, // import { ref as _ref } from 'vue'; let a = (ref(0)); a.value++"
+  map
+} = transform(src, {
+  filename: 'foo.ts',
+  sourceMap: true,
+
+  // @babel/parser plugins to enable.
+  // 'typescript' and 'jsx' will be auto-inferred from filename if provided,
+  // so in most cases explicit parserPlugins are not necessary
+  parserPlugins: [
+    /* ... */
+  ]
+})
+```
+
+**Options**
+
+```ts
+interface RefTransformOptions {
+  filename?: string
+  sourceMap?: boolean // default: false
+  parserPlugins?: ParserPlugin[]
+  importHelpersFrom?: string // default: "vue"
+}
+```
+
+### `transformAST`
+
+Transform with an existing Babel AST + MagicString instance. This is used internally by `@vue/compiler-sfc` to avoid double parse/transform cost.
+
+```js
+import { transformAST } from '@vue/reactivity-transform'
+import { parse } from '@babel/parser'
+import MagicString from 'magic-string'
+
+const src = `let a = $ref(0); a++`
+const ast = parse(src, { sourceType: 'module' })
+const s = new MagicString(src)
+
+const {
+  rootRefs, // ['a']
+  importedHelpers // ['ref']
+} = transformAST(ast, s)
+
+console.log(s.toString()) // let a = _ref(0); a.value++
+```

webui/node_modules/@vue/reactivity-transform/dist/reactivity-transform.cjs.js

@@ -0,0 +1,538 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var MagicString = require('magic-string');
+var estreeWalker = require('estree-walker');
+var compilerCore = require('@vue/compiler-core');
+var parser = require('@babel/parser');
+var shared = require('@vue/shared');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e['default'] : e; }
+
+var MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
+
+const CONVERT_SYMBOL = '$';
+const ESCAPE_SYMBOL = '$$';
+const shorthands = ['ref', 'computed', 'shallowRef', 'toRef', 'customRef'];
+const transformCheckRE = /[^\w]\$(?:\$|ref|computed|shallowRef)?\s*(\(|\<)/;
+function shouldTransform(src) {
+    return transformCheckRE.test(src);
+}
+function transform(src, { filename, sourceMap, parserPlugins, importHelpersFrom = 'vue' } = {}) {
+    const plugins = parserPlugins || [];
+    if (filename) {
+        if (/\.tsx?$/.test(filename)) {
+            plugins.push('typescript');
+        }
+        if (filename.endsWith('x')) {
+            plugins.push('jsx');
+        }
+    }
+    const ast = parser.parse(src, {
+        sourceType: 'module',
+        plugins
+    });
+    const s = new MagicString__default(src);
+    const res = transformAST(ast.program, s, 0);
+    // inject helper imports
+    if (res.importedHelpers.length) {
+        s.prepend(`import { ${res.importedHelpers
+            .map(h => `${h} as _${h}`)
+            .join(', ')} } from '${importHelpersFrom}'\n`);
+    }
+    return {
+        ...res,
+        code: s.toString(),
+        map: sourceMap
+            ? s.generateMap({
+                source: filename,
+                hires: true,
+                includeContent: true
+            })
+            : null
+    };
+}
+function transformAST(ast, s, offset = 0, knownRefs, knownProps) {
+    // TODO remove when out of experimental
+    warnExperimental();
+    let convertSymbol = CONVERT_SYMBOL;
+    let escapeSymbol = ESCAPE_SYMBOL;
+    // macro import handling
+    for (const node of ast.body) {
+        if (node.type === 'ImportDeclaration' &&
+            node.source.value === 'vue/macros') {
+            // remove macro imports
+            s.remove(node.start + offset, node.end + offset);
+            // check aliasing
+            for (const specifier of node.specifiers) {
+                if (specifier.type === 'ImportSpecifier') {
+                    const imported = specifier.imported.name;
+                    const local = specifier.local.name;
+                    if (local !== imported) {
+                        if (imported === ESCAPE_SYMBOL) {
+                            escapeSymbol = local;
+                        }
+                        else if (imported === CONVERT_SYMBOL) {
+                            convertSymbol = local;
+                        }
+                        else {
+                            error(`macro imports for ref-creating methods do not support aliasing.`, specifier);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const importedHelpers = new Set();
+    const rootScope = {};
+    const scopeStack = [rootScope];
+    let currentScope = rootScope;
+    let escapeScope; // inside $$()
+    const excludedIds = new WeakSet();
+    const parentStack = [];
+    const propsLocalToPublicMap = Object.create(null);
+    if (knownRefs) {
+        for (const key of knownRefs) {
+            rootScope[key] = true;
+        }
+    }
+    if (knownProps) {
+        for (const key in knownProps) {
+            const { local } = knownProps[key];
+            rootScope[local] = 'prop';
+            propsLocalToPublicMap[local] = key;
+        }
+    }
+    function isRefCreationCall(callee) {
+        if (callee === convertSymbol) {
+            return convertSymbol;
+        }
+        if (callee[0] === '$' && shorthands.includes(callee.slice(1))) {
+            return callee;
+        }
+        return false;
+    }
+    function error(msg, node) {
+        const e = new Error(msg);
+        e.node = node;
+        throw e;
+    }
+    function helper(msg) {
+        importedHelpers.add(msg);
+        return `_${msg}`;
+    }
+    function registerBinding(id, isRef = false) {
+        excludedIds.add(id);
+        if (currentScope) {
+            currentScope[id.name] = isRef;
+        }
+        else {
+            error('registerBinding called without active scope, something is wrong.', id);
+        }
+    }
+    const registerRefBinding = (id) => registerBinding(id, true);
+    let tempVarCount = 0;
+    function genTempVar() {
+        return `__$temp_${++tempVarCount}`;
+    }
+    function snip(node) {
+        return s.original.slice(node.start + offset, node.end + offset);
+    }
+    function walkScope(node, isRoot = false) {
+        for (const stmt of node.body) {
+            if (stmt.type === 'VariableDeclaration') {
+                walkVariableDeclaration(stmt, isRoot);
+            }
+            else if (stmt.type === 'FunctionDeclaration' ||
+                stmt.type === 'ClassDeclaration') {
+                if (stmt.declare || !stmt.id)
+                    continue;
+                registerBinding(stmt.id);
+            }
+            else if ((stmt.type === 'ForOfStatement' || stmt.type === 'ForInStatement') &&
+                stmt.left.type === 'VariableDeclaration') {
+                walkVariableDeclaration(stmt.left);
+            }
+            else if (stmt.type === 'ExportNamedDeclaration' &&
+                stmt.declaration &&
+                stmt.declaration.type === 'VariableDeclaration') {
+                walkVariableDeclaration(stmt.declaration, isRoot);
+            }
+            else if (stmt.type === 'LabeledStatement' &&
+                stmt.body.type === 'VariableDeclaration') {
+                walkVariableDeclaration(stmt.body, isRoot);
+            }
+        }
+    }
+    function walkVariableDeclaration(stmt, isRoot = false) {
+        if (stmt.declare) {
+            return;
+        }
+        for (const decl of stmt.declarations) {
+            let refCall;
+            const isCall = decl.init &&
+                decl.init.type === 'CallExpression' &&
+                decl.init.callee.type === 'Identifier';
+            if (isCall &&
+                (refCall = isRefCreationCall(decl.init.callee.name))) {
+                processRefDeclaration(refCall, decl.id, decl.init);
+            }
+            else {
+                const isProps = isRoot && isCall && decl.init.callee.name === 'defineProps';
+                for (const id of compilerCore.extractIdentifiers(decl.id)) {
+                    if (isProps) {
+                        // for defineProps destructure, only exclude them since they
+                        // are already passed in as knownProps
+                        excludedIds.add(id);
+                    }
+                    else {
+                        registerBinding(id);
+                    }
+                }
+            }
+        }
+    }
+    function processRefDeclaration(method, id, call) {
+        excludedIds.add(call.callee);
+        if (method === convertSymbol) {
+            // $
+            // remove macro
+            s.remove(call.callee.start + offset, call.callee.end + offset);
+            if (id.type === 'Identifier') {
+                // single variable
+                registerRefBinding(id);
+            }
+            else if (id.type === 'ObjectPattern') {
+                processRefObjectPattern(id, call);
+            }
+            else if (id.type === 'ArrayPattern') {
+                processRefArrayPattern(id, call);
+            }
+        }
+        else {
+            // shorthands
+            if (id.type === 'Identifier') {
+                registerRefBinding(id);
+                // replace call
+                s.overwrite(call.start + offset, call.start + method.length + offset, helper(method.slice(1)));
+            }
+            else {
+                error(`${method}() cannot be used with destructure patterns.`, call);
+            }
+        }
+    }
+    function processRefObjectPattern(pattern, call, tempVar, path = []) {
+        if (!tempVar) {
+            tempVar = genTempVar();
+            // const { x } = $(useFoo()) --> const __$temp_1 = useFoo()
+            s.overwrite(pattern.start + offset, pattern.end + offset, tempVar);
+        }
+        for (const p of pattern.properties) {
+            let nameId;
+            let key;
+            let defaultValue;
+            if (p.type === 'ObjectProperty') {
+                if (p.key.start === p.value.start) {
+                    // shorthand { foo }
+                    nameId = p.key;
+                    if (p.value.type === 'Identifier') {
+                        // avoid shorthand value identifier from being processed
+                        excludedIds.add(p.value);
+                    }
+                    else if (p.value.type === 'AssignmentPattern' &&
+                        p.value.left.type === 'Identifier') {
+                        // { foo = 1 }
+                        excludedIds.add(p.value.left);
+                        defaultValue = p.value.right;
+                    }
+                }
+                else {
+                    key = p.computed ? p.key : p.key.name;
+                    if (p.value.type === 'Identifier') {
+                        // { foo: bar }
+                        nameId = p.value;
+                    }
+                    else if (p.value.type === 'ObjectPattern') {
+                        processRefObjectPattern(p.value, call, tempVar, [...path, key]);
+                    }
+                    else if (p.value.type === 'ArrayPattern') {
+                        processRefArrayPattern(p.value, call, tempVar, [...path, key]);
+                    }
+                    else if (p.value.type === 'AssignmentPattern') {
+                        if (p.value.left.type === 'Identifier') {
+                            // { foo: bar = 1 }
+                            nameId = p.value.left;
+                            defaultValue = p.value.right;
+                        }
+                        else if (p.value.left.type === 'ObjectPattern') {
+                            processRefObjectPattern(p.value.left, call, tempVar, [
+                                ...path,
+                                [key, p.value.right]
+                            ]);
+                        }
+                        else if (p.value.left.type === 'ArrayPattern') {
+                            processRefArrayPattern(p.value.left, call, tempVar, [
+                                ...path,
+                                [key, p.value.right]
+                            ]);
+                        }
+                        else ;
+                    }
+                }
+            }
+            else {
+                // rest element { ...foo }
+                error(`reactivity destructure does not support rest elements.`, p);
+            }
+            if (nameId) {
+                registerRefBinding(nameId);
+                // inject toRef() after original replaced pattern
+                const source = pathToString(tempVar, path);
+                const keyStr = shared.isString(key)
+                    ? `'${key}'`
+                    : key
+                        ? snip(key)
+                        : `'${nameId.name}'`;
+                const defaultStr = defaultValue ? `, ${snip(defaultValue)}` : ``;
+                s.appendLeft(call.end + offset, `,\n  ${nameId.name} = ${helper('toRef')}(${source}, ${keyStr}${defaultStr})`);
+            }
+        }
+    }
+    function processRefArrayPattern(pattern, call, tempVar, path = []) {
+        if (!tempVar) {
+            // const [x] = $(useFoo()) --> const __$temp_1 = useFoo()
+            tempVar = genTempVar();
+            s.overwrite(pattern.start + offset, pattern.end + offset, tempVar);
+        }
+        for (let i = 0; i < pattern.elements.length; i++) {
+            const e = pattern.elements[i];
+            if (!e)
+                continue;
+            let nameId;
+            let defaultValue;
+            if (e.type === 'Identifier') {
+                // [a] --> [__a]
+                nameId = e;
+            }
+            else if (e.type === 'AssignmentPattern') {
+                // [a = 1]
+                nameId = e.left;
+                defaultValue = e.right;
+            }
+            else if (e.type === 'RestElement') {
+                // [...a]
+                error(`reactivity destructure does not support rest elements.`, e);
+            }
+            else if (e.type === 'ObjectPattern') {
+                processRefObjectPattern(e, call, tempVar, [...path, i]);
+            }
+            else if (e.type === 'ArrayPattern') {
+                processRefArrayPattern(e, call, tempVar, [...path, i]);
+            }
+            if (nameId) {
+                registerRefBinding(nameId);
+                // inject toRef() after original replaced pattern
+                const source = pathToString(tempVar, path);
+                const defaultStr = defaultValue ? `, ${snip(defaultValue)}` : ``;
+                s.appendLeft(call.end + offset, `,\n  ${nameId.name} = ${helper('toRef')}(${source}, ${i}${defaultStr})`);
+            }
+        }
+    }
+    function pathToString(source, path) {
+        if (path.length) {
+            for (const seg of path) {
+                if (shared.isArray(seg)) {
+                    source = `(${source}${segToString(seg[0])} || ${snip(seg[1])})`;
+                }
+                else {
+                    source += segToString(seg);
+                }
+            }
+        }
+        return source;
+    }
+    function segToString(seg) {
+        if (typeof seg === 'number') {
+            return `[${seg}]`;
+        }
+        else if (typeof seg === 'string') {
+            return `.${seg}`;
+        }
+        else {
+            return snip(seg);
+        }
+    }
+    function rewriteId(scope, id, parent, parentStack) {
+        if (shared.hasOwn(scope, id.name)) {
+            const bindingType = scope[id.name];
+            if (bindingType) {
+                const isProp = bindingType === 'prop';
+                if (compilerCore.isStaticProperty(parent) && parent.shorthand) {
+                    // let binding used in a property shorthand
+                    // skip for destructure patterns
+                    if (!parent.inPattern ||
+                        compilerCore.isInDestructureAssignment(parent, parentStack)) {
+                        if (isProp) {
+                            if (escapeScope) {
+                                // prop binding in $$()
+                                // { prop } -> { prop: __props_prop }
+                                registerEscapedPropBinding(id);
+                                s.appendLeft(id.end + offset, `: __props_${propsLocalToPublicMap[id.name]}`);
+                            }
+                            else {
+                                // { prop } -> { prop: __props.prop }
+                                s.appendLeft(id.end + offset, `: ${shared.genPropsAccessExp(propsLocalToPublicMap[id.name])}`);
+                            }
+                        }
+                        else {
+                            // { foo } -> { foo: foo.value }
+                            s.appendLeft(id.end + offset, `: ${id.name}.value`);
+                        }
+                    }
+                }
+                else {
+                    if (isProp) {
+                        if (escapeScope) {
+                            // x --> __props_x
+                            registerEscapedPropBinding(id);
+                            s.overwrite(id.start + offset, id.end + offset, `__props_${propsLocalToPublicMap[id.name]}`);
+                        }
+                        else {
+                            // x --> __props.x
+                            s.overwrite(id.start + offset, id.end + offset, shared.genPropsAccessExp(propsLocalToPublicMap[id.name]));
+                        }
+                    }
+                    else {
+                        // x --> x.value
+                        s.appendLeft(id.end + offset, '.value');
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    const propBindingRefs = {};
+    function registerEscapedPropBinding(id) {
+        if (!propBindingRefs.hasOwnProperty(id.name)) {
+            propBindingRefs[id.name] = true;
+            const publicKey = propsLocalToPublicMap[id.name];
+            s.prependRight(offset, `const __props_${publicKey} = ${helper(`toRef`)}(__props, '${publicKey}')\n`);
+        }
+    }
+    // check root scope first
+    walkScope(ast, true);
+    estreeWalker.walk(ast, {
+        enter(node, parent) {
+            parent && parentStack.push(parent);
+            // function scopes
+            if (compilerCore.isFunctionType(node)) {
+                scopeStack.push((currentScope = {}));
+                compilerCore.walkFunctionParams(node, registerBinding);
+                if (node.body.type === 'BlockStatement') {
+                    walkScope(node.body);
+                }
+                return;
+            }
+            // catch param
+            if (node.type === 'CatchClause') {
+                scopeStack.push((currentScope = {}));
+                if (node.param && node.param.type === 'Identifier') {
+                    registerBinding(node.param);
+                }
+                walkScope(node.body);
+                return;
+            }
+            // non-function block scopes
+            if (node.type === 'BlockStatement' && !compilerCore.isFunctionType(parent)) {
+                scopeStack.push((currentScope = {}));
+                walkScope(node);
+                return;
+            }
+            // skip type nodes
+            if (parent &&
+                parent.type.startsWith('TS') &&
+                parent.type !== 'TSAsExpression' &&
+                parent.type !== 'TSNonNullExpression' &&
+                parent.type !== 'TSTypeAssertion') {
+                return this.skip();
+            }
+            if (node.type === 'Identifier' &&
+                // if inside $$(), skip unless this is a destructured prop binding
+                !(escapeScope && rootScope[node.name] !== 'prop') &&
+                compilerCore.isReferencedIdentifier(node, parent, parentStack) &&
+                !excludedIds.has(node)) {
+                // walk up the scope chain to check if id should be appended .value
+                let i = scopeStack.length;
+                while (i--) {
+                    if (rewriteId(scopeStack[i], node, parent, parentStack)) {
+                        return;
+                    }
+                }
+            }
+            if (node.type === 'CallExpression' && node.callee.type === 'Identifier') {
+                const callee = node.callee.name;
+                const refCall = isRefCreationCall(callee);
+                if (refCall && (!parent || parent.type !== 'VariableDeclarator')) {
+                    return error(`${refCall} can only be used as the initializer of ` +
+                        `a variable declaration.`, node);
+                }
+                if (callee === escapeSymbol) {
+                    s.remove(node.callee.start + offset, node.callee.end + offset);
+                    escapeScope = node;
+                }
+                // TODO remove when out of experimental
+                if (callee === '$raw') {
+                    error(`$raw() has been replaced by $$(). ` +
+                        `See ${RFC_LINK} for latest updates.`, node);
+                }
+                if (callee === '$fromRef') {
+                    error(`$fromRef() has been replaced by $(). ` +
+                        `See ${RFC_LINK} for latest updates.`, node);
+                }
+            }
+        },
+        leave(node, parent) {
+            parent && parentStack.pop();
+            if ((node.type === 'BlockStatement' && !compilerCore.isFunctionType(parent)) ||
+                compilerCore.isFunctionType(node)) {
+                scopeStack.pop();
+                currentScope = scopeStack[scopeStack.length - 1] || null;
+            }
+            if (node === escapeScope) {
+                escapeScope = undefined;
+            }
+        }
+    });
+    return {
+        rootRefs: Object.keys(rootScope).filter(key => rootScope[key] === true),
+        importedHelpers: [...importedHelpers]
+    };
+}
+const RFC_LINK = `https://github.com/vuejs/rfcs/discussions/369`;
+const hasWarned = {};
+function warnExperimental() {
+    // eslint-disable-next-line
+    if (typeof window !== 'undefined') {
+        return;
+    }
+    warnOnce(`Reactivity transform is an experimental feature.\n` +
+        `Experimental features may change behavior between patch versions.\n` +
+        `It is recommended to pin your vue dependencies to exact versions to avoid breakage.\n` +
+        `You can follow the proposal's status at ${RFC_LINK}.`);
+}
+function warnOnce(msg) {
+    const isNodeProd = typeof process !== 'undefined' && process.env.NODE_ENV === 'production';
+    if (!isNodeProd && !false && !hasWarned[msg]) {
+        hasWarned[msg] = true;
+        warn(msg);
+    }
+}
+function warn(msg) {
+    console.warn(`\x1b[1m\x1b[33m[@vue/reactivity-transform]\x1b[0m\x1b[33m ${msg}\x1b[0m\n`);
+}
+
+exports.shouldTransform = shouldTransform;
+exports.transform = transform;
+exports.transformAST = transformAST;

webui/node_modules/@vue/reactivity-transform/dist/reactivity-transform.d.ts

@@ -0,0 +1,33 @@
+import MagicString from 'magic-string';
+import { ParserPlugin } from '@babel/parser';
+import { Program } from '@babel/types';
+import { SourceMap } from 'magic-string';
+
+export declare interface RefTransformOptions {
+    filename?: string;
+    sourceMap?: boolean;
+    parserPlugins?: ParserPlugin[];
+    importHelpersFrom?: string;
+}
+
+export declare interface RefTransformResults {
+    code: string;
+    map: SourceMap | null;
+    rootRefs: string[];
+    importedHelpers: string[];
+}
+
+export declare function shouldTransform(src: string): boolean;
+
+export declare function transform(src: string, { filename, sourceMap, parserPlugins, importHelpersFrom }?: RefTransformOptions): RefTransformResults;
+
+export declare function transformAST(ast: Program, s: MagicString, offset?: number, knownRefs?: string[], knownProps?: Record<string, // public prop key
+    {
+    local: string;
+    default?: any;
+}>): {
+    rootRefs: string[];
+    importedHelpers: string[];
+};
+
+export { }

webui/node_modules/@vue/reactivity-transform/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@vue/reactivity-transform",
+  "version": "3.2.37",
+  "description": "@vue/reactivity-transform",
+  "main": "dist/reactivity-transform.cjs.js",
+  "files": [
+    "dist"
+  ],
+  "buildOptions": {
+    "formats": [
+      "cjs"
+    ],
+    "prod": false
+  },
+  "types": "dist/reactivity-transform.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/reactivity-transform"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/dev/packages/reactivity-transform#readme",
+  "dependencies": {
+    "@babel/parser": "^7.16.4",
+    "@vue/compiler-core": "3.2.37",
+    "@vue/shared": "3.2.37",
+    "estree-walker": "^2.0.2",
+    "magic-string": "^0.25.7"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.16.0",
+    "@babel/types": "^7.16.0"
+  }
+}

webui/node_modules/@vue/reactivity/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

webui/node_modules/@vue/reactivity/README.md

@@ -0,0 +1,19 @@
+# @vue/reactivity
+
+## Usage Note
+
+This package is inlined into Global & Browser ESM builds of user-facing renderers (e.g. `@vue/runtime-dom`), but also published as a package that can be used standalone. The standalone build should not be used alongside a pre-bundled build of a user-facing renderer, as they will have different internal storage for reactivity connections. A user-facing renderer should re-export all APIs from this package.
+
+For full exposed APIs, see `src/index.ts`. You can also run `yarn build reactivity --types` from repo root, which will generate an API report at `temp/reactivity.api.md`.
+
+## Credits
+
+The implementation of this module is inspired by the following prior art in the JavaScript ecosystem:
+
+- [Meteor Tracker](https://docs.meteor.com/api/tracker.html)
+- [nx-js/observer-util](https://github.com/nx-js/observer-util)
+- [salesforce/observable-membrane](https://github.com/salesforce/observable-membrane)
+
+## Caveats
+
+- Built-in objects are not observed except for `Array`, `Map`, `WeakMap`, `Set` and `WeakSet`.

webui/node_modules/@vue/reactivity/dist/reactivity.d.ts

@@ -0,0 +1,347 @@
+import { IfAny } from '@vue/shared';
+
+declare type BaseTypes = string | number | boolean;
+
+declare type Builtin = Primitive | Function | Date | Error | RegExp;
+
+declare type CollectionTypes = IterableCollections | WeakCollections;
+
+export declare function computed<T>(getter: ComputedGetter<T>, debugOptions?: DebuggerOptions): ComputedRef<T>;
+
+export declare function computed<T>(options: WritableComputedOptions<T>, debugOptions?: DebuggerOptions): WritableComputedRef<T>;
+
+export declare type ComputedGetter<T> = (...args: any[]) => T;
+
+export declare interface ComputedRef<T = any> extends WritableComputedRef<T> {
+    readonly value: T;
+    [ComputedRefSymbol]: true;
+}
+
+declare class ComputedRefImpl<T> {
+    private readonly _setter;
+    dep?: Dep;
+    private _value;
+    readonly effect: ReactiveEffect<T>;
+    readonly __v_isRef = true;
+    readonly [ReactiveFlags.IS_READONLY]: boolean;
+    _dirty: boolean;
+    _cacheable: boolean;
+    constructor(getter: ComputedGetter<T>, _setter: ComputedSetter<T>, isReadonly: boolean, isSSR: boolean);
+    get value(): T;
+    set value(newValue: T);
+}
+
+declare const ComputedRefSymbol: unique symbol;
+
+export declare type ComputedSetter<T> = (v: T) => void;
+
+export declare function customRef<T>(factory: CustomRefFactory<T>): Ref<T>;
+
+export declare type CustomRefFactory<T> = (track: () => void, trigger: () => void) => {
+    get: () => T;
+    set: (value: T) => void;
+};
+
+export declare type DebuggerEvent = {
+    effect: ReactiveEffect;
+} & DebuggerEventExtraInfo;
+
+export declare type DebuggerEventExtraInfo = {
+    target: object;
+    type: TrackOpTypes | TriggerOpTypes;
+    key: any;
+    newValue?: any;
+    oldValue?: any;
+    oldTarget?: Map<any, any> | Set<any>;
+};
+
+export declare interface DebuggerOptions {
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+}
+
+export declare type DeepReadonly<T> = T extends Builtin ? T : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends WeakMap<infer K, infer V> ? WeakMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends WeakSet<infer U> ? WeakSet<DeepReadonly<U>> : T extends Promise<infer U> ? Promise<DeepReadonly<U>> : T extends Ref<infer U> ? Readonly<Ref<DeepReadonly<U>>> : T extends {} ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : Readonly<T>;
+
+export declare function deferredComputed<T>(getter: () => T): ComputedRef<T>;
+
+declare type Dep = Set<ReactiveEffect> & TrackedMarkers;
+
+export declare function effect<T = any>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffectRunner;
+
+export declare type EffectScheduler = (...args: any[]) => any;
+
+export declare class EffectScope {
+    /* Excluded from this release type: active */
+    /* Excluded from this release type: effects */
+    /* Excluded from this release type: cleanups */
+    /* Excluded from this release type: parent */
+    /* Excluded from this release type: scopes */
+    /* Excluded from this release type: index */
+    constructor(detached?: boolean);
+    run<T>(fn: () => T): T | undefined;
+    /* Excluded from this release type: on */
+    /* Excluded from this release type: off */
+    stop(fromParent?: boolean): void;
+}
+
+export declare function effectScope(detached?: boolean): EffectScope;
+
+export declare function enableTracking(): void;
+
+export declare function getCurrentScope(): EffectScope | undefined;
+
+export declare function isProxy(value: unknown): boolean;
+
+export declare function isReactive(value: unknown): boolean;
+
+export declare function isReadonly(value: unknown): boolean;
+
+export declare function isRef<T>(r: Ref<T> | unknown): r is Ref<T>;
+
+export declare function isShallow(value: unknown): boolean;
+
+declare type IterableCollections = Map<any, any> | Set<any>;
+
+export declare const ITERATE_KEY: unique symbol;
+
+export declare function markRaw<T extends object>(value: T): T & {
+    [RawSymbol]?: true;
+};
+
+export declare function onScopeDispose(fn: () => void): void;
+
+export declare function pauseTracking(): void;
+
+declare type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+
+export declare function proxyRefs<T extends object>(objectWithRefs: T): ShallowUnwrapRef<T>;
+
+declare const RawSymbol: unique symbol;
+
+/**
+ * Creates a reactive copy of the original object.
+ *
+ * The reactive conversion is "deep"—it affects all nested properties. In the
+ * ES2015 Proxy based implementation, the returned proxy is **not** equal to the
+ * original object. It is recommended to work exclusively with the reactive
+ * proxy and avoid relying on the original object.
+ *
+ * A reactive object also automatically unwraps refs contained in it, so you
+ * don't need to use `.value` when accessing and mutating their value:
+ *
+ * ```js
+ * const count = ref(0)
+ * const obj = reactive({
+ *   count
+ * })
+ *
+ * obj.count++
+ * obj.count // -> 1
+ * count.value // -> 1
+ * ```
+ */
+export declare function reactive<T extends object>(target: T): UnwrapNestedRefs<T>;
+
+export declare class ReactiveEffect<T = any> {
+    fn: () => T;
+    scheduler: EffectScheduler | null;
+    active: boolean;
+    deps: Dep[];
+    parent: ReactiveEffect | undefined;
+    /* Excluded from this release type: computed */
+    /* Excluded from this release type: allowRecurse */
+    /* Excluded from this release type: deferStop */
+    onStop?: () => void;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+    constructor(fn: () => T, scheduler?: EffectScheduler | null, scope?: EffectScope);
+    run(): T | undefined;
+    stop(): void;
+}
+
+export declare interface ReactiveEffectOptions extends DebuggerOptions {
+    lazy?: boolean;
+    scheduler?: EffectScheduler;
+    scope?: EffectScope;
+    allowRecurse?: boolean;
+    onStop?: () => void;
+}
+
+export declare interface ReactiveEffectRunner<T = any> {
+    (): T;
+    effect: ReactiveEffect;
+}
+
+export declare const enum ReactiveFlags {
+    SKIP = "__v_skip",
+    IS_REACTIVE = "__v_isReactive",
+    IS_READONLY = "__v_isReadonly",
+    IS_SHALLOW = "__v_isShallow",
+    RAW = "__v_raw"
+}
+
+/**
+ * Creates a readonly copy of the original object. Note the returned copy is not
+ * made reactive, but `readonly` can be called on an already reactive object.
+ */
+export declare function readonly<T extends object>(target: T): DeepReadonly<UnwrapNestedRefs<T>>;
+
+export declare interface Ref<T = any> {
+    value: T;
+    /**
+     * Type differentiator only.
+     * We need this to be in public d.ts but don't want it to show up in IDE
+     * autocomplete, so we use a private Symbol instead.
+     */
+    [RefSymbol]: true;
+}
+
+export declare function ref<T extends object>(value: T): [T] extends [Ref] ? T : Ref<UnwrapRef<T>>;
+
+export declare function ref<T>(value: T): Ref<UnwrapRef<T>>;
+
+export declare function ref<T = any>(): Ref<T | undefined>;
+
+declare const RefSymbol: unique symbol;
+
+/**
+ * This is a special exported interface for other packages to declare
+ * additional types that should bail out for ref unwrapping. For example
+ * \@vue/runtime-dom can declare it like so in its d.ts:
+ *
+ * ``` ts
+ * declare module '@vue/reactivity' {
+ *   export interface RefUnwrapBailTypes {
+ *     runtimeDOMBailTypes: Node | Window
+ *   }
+ * }
+ * ```
+ *
+ * Note that api-extractor somehow refuses to include `declare module`
+ * augmentations in its generated d.ts, so we have to manually append them
+ * to the final generated d.ts in our build process.
+ */
+export declare interface RefUnwrapBailTypes {
+}
+
+export declare function resetTracking(): void;
+
+export declare type ShallowReactive<T> = T & {
+    [ShallowReactiveMarker]?: true;
+};
+
+/**
+ * Return a shallowly-reactive copy of the original object, where only the root
+ * level properties are reactive. It also does not auto-unwrap refs (even at the
+ * root level).
+ */
+export declare function shallowReactive<T extends object>(target: T): ShallowReactive<T>;
+
+declare const ShallowReactiveMarker: unique symbol;
+
+/**
+ * Returns 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.
+ */
+export declare function shallowReadonly<T extends object>(target: T): Readonly<T>;
+
+export declare type ShallowRef<T = any> = Ref<T> & {
+    [ShallowRefMarker]?: true;
+};
+
+export declare function shallowRef<T extends object>(value: T): T extends Ref ? T : ShallowRef<T>;
+
+export declare function shallowRef<T>(value: T): ShallowRef<T>;
+
+export declare function shallowRef<T = any>(): ShallowRef<T | undefined>;
+
+declare const ShallowRefMarker: unique symbol;
+
+export declare type ShallowUnwrapRef<T> = {
+    [K in keyof T]: T[K] extends Ref<infer V> ? V : T[K] extends Ref<infer V> | undefined ? unknown extends V ? undefined : V | undefined : T[K];
+};
+
+declare function stop_2(runner: ReactiveEffectRunner): void;
+export { stop_2 as stop }
+
+export declare function toRaw<T>(observed: T): T;
+
+export declare type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>;
+
+export declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ToRef<T[K]>;
+
+export declare function toRef<T extends object, K extends keyof T>(object: T, key: K, defaultValue: T[K]): ToRef<Exclude<T[K], undefined>>;
+
+export declare type ToRefs<T = any> = {
+    [K in keyof T]: ToRef<T[K]>;
+};
+
+export declare function toRefs<T extends object>(object: T): ToRefs<T>;
+
+export declare function track(target: object, type: TrackOpTypes, key: unknown): void;
+
+/**
+ * wasTracked and newTracked maintain the status for several levels of effect
+ * tracking recursion. One bit per level is used to define whether the dependency
+ * was/is tracked.
+ */
+declare type TrackedMarkers = {
+    /**
+     * wasTracked
+     */
+    w: number;
+    /**
+     * newTracked
+     */
+    n: number;
+};
+
+export declare const enum TrackOpTypes {
+    GET = "get",
+    HAS = "has",
+    ITERATE = "iterate"
+}
+
+export declare function trigger(target: object, type: TriggerOpTypes, key?: unknown, newValue?: unknown, oldValue?: unknown, oldTarget?: Map<unknown, unknown> | Set<unknown>): void;
+
+export declare const enum TriggerOpTypes {
+    SET = "set",
+    ADD = "add",
+    DELETE = "delete",
+    CLEAR = "clear"
+}
+
+export declare function triggerRef(ref: Ref): void;
+
+export declare function unref<T>(ref: T | Ref<T>): T;
+
+export declare type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
+
+export declare type UnwrapRef<T> = T extends ShallowRef<infer V> ? V : T extends Ref<infer V> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
+
+declare type UnwrapRefSimple<T> = T extends Function | CollectionTypes | BaseTypes | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
+    [RawSymbol]?: true;
+} ? T : T extends Array<any> ? {
+    [K in keyof T]: UnwrapRefSimple<T[K]>;
+} : T extends object & {
+    [ShallowReactiveMarker]?: never;
+} ? {
+    [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>;
+} : T;
+
+declare type WeakCollections = WeakMap<any, any> | WeakSet<any>;
+
+export declare interface WritableComputedOptions<T> {
+    get: ComputedGetter<T>;
+    set: ComputedSetter<T>;
+}
+
+export declare interface WritableComputedRef<T> extends Ref<T> {
+    readonly effect: ReactiveEffect<T>;
+}
+
+export { }

webui/node_modules/@vue/reactivity/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/reactivity.cjs.prod.js')
+} else {
+  module.exports = require('./dist/reactivity.cjs.js')
+}

webui/node_modules/@vue/reactivity/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@vue/reactivity",
+  "version": "3.2.37",
+  "description": "@vue/reactivity",
+  "main": "index.js",
+  "module": "dist/reactivity.esm-bundler.js",
+  "types": "dist/reactivity.d.ts",
+  "unpkg": "dist/reactivity.global.js",
+  "jsdelivr": "dist/reactivity.global.js",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/reactivity"
+  },
+  "buildOptions": {
+    "name": "VueReactivity",
+    "formats": [
+      "esm-bundler",
+      "esm-browser",
+      "cjs",
+      "global"
+    ]
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/reactivity#readme",
+  "dependencies": {
+    "@vue/shared": "3.2.37"
+  }
+}

webui/node_modules/@vue/runtime-core/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

webui/node_modules/@vue/runtime-core/README.md

@@ -0,0 +1,28 @@
+# @vue/runtime-core
+
+> This package is published only for typing and building custom renderers. It is NOT meant to be used in applications.
+
+For full exposed APIs, see `src/index.ts`. You can also run `yarn build runtime-core --types` from repo root, which will generate an API report at `temp/runtime-core.api.md`.
+
+## Building a Custom Renderer
+
+``` ts
+import { createRenderer } from '@vue/runtime-core'
+
+const { render, createApp } = createRenderer({
+  patchProp,
+  insert,
+  remove,
+  createElement,
+  // ...
+})
+
+// `render` is the low-level API
+// `createApp` returns an app instance with configurable context shared
+// by the entire app tree.
+export { render, createApp }
+
+export * from '@vue/runtime-core'
+```
+
+See `@vue/runtime-dom` for how a DOM-targeting renderer is implemented.

webui/node_modules/@vue/runtime-core/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/runtime-core.cjs.prod.js')
+} else {
+  module.exports = require('./dist/runtime-core.cjs.js')
+}

webui/node_modules/@vue/runtime-core/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@vue/runtime-core",
+  "version": "3.2.37",
+  "description": "@vue/runtime-core",
+  "main": "index.js",
+  "module": "dist/runtime-core.esm-bundler.js",
+  "types": "dist/runtime-core.d.ts",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "buildOptions": {
+    "name": "VueRuntimeCore",
+    "formats": [
+      "esm-bundler",
+      "cjs"
+    ]
+  },
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/core.git",
+    "directory": "packages/runtime-core"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/core/issues"
+  },
+  "homepage": "https://github.com/vuejs/core/tree/main/packages/runtime-core#readme",
+  "dependencies": {
+    "@vue/shared": "3.2.37",
+    "@vue/reactivity": "3.2.37"
+  }
+}

webui/node_modules/@vue/runtime-dom/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

webui/node_modules/@vue/runtime-dom/README.md

@@ -0,0 +1,13 @@
+# @vue/runtime-dom
+
+``` js
+import { h, createApp } from '@vue/runtime-dom'
+
+const RootComponent = {
+  render() {
+    return h('div', 'hello world')
+  }
+}
+
+createApp(RootComponent).mount('#app')
+```