2127 lines
76 KiB
JavaScript
2127 lines
76 KiB
JavaScript
import { shallowReactive, reactive, effectScope, getCurrentScope, hasInjectionContext, getCurrentInstance, toRef, inject, shallowRef, isReadonly, isRef, isShallow, isReactive, toRaw, ref, computed, unref, onScopeDispose, watchEffect, readonly, nextTick, defineComponent, provide, h, watch, Suspense, Fragment, useSSRContext, defineAsyncComponent, mergeProps, onErrorCaptured, onServerPrefetch, createVNode, resolveDynamicComponent, createApp } from 'vue';
|
|
import { k as createHooks, l as getContext, h as createError$1, m as toRouteMatcher, n as createRouter, o as sanitizeStatusCode, p as executeAsync } from '../_/nitro.mjs';
|
|
import { START_LOCATION, createMemoryHistory, createRouter as createRouter$1, RouterView } from 'vue-router';
|
|
import { ssrRenderComponent, ssrRenderSuspense, ssrRenderVNode } from 'vue/server-renderer';
|
|
|
|
const HASH_RE = /#/g;
|
|
const AMPERSAND_RE = /&/g;
|
|
const SLASH_RE = /\//g;
|
|
const EQUAL_RE = /=/g;
|
|
const PLUS_RE = /\+/g;
|
|
const ENC_CARET_RE = /%5e/gi;
|
|
const ENC_BACKTICK_RE = /%60/gi;
|
|
const ENC_PIPE_RE = /%7c/gi;
|
|
const ENC_SPACE_RE = /%20/gi;
|
|
function encode(text) {
|
|
return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
|
|
}
|
|
function encodeQueryValue(input) {
|
|
return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
|
|
}
|
|
function encodeQueryKey(text) {
|
|
return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
|
|
}
|
|
function decode(text = "") {
|
|
try {
|
|
return decodeURIComponent("" + text);
|
|
} catch {
|
|
return "" + text;
|
|
}
|
|
}
|
|
function decodeQueryKey(text) {
|
|
return decode(text.replace(PLUS_RE, " "));
|
|
}
|
|
function decodeQueryValue(text) {
|
|
return decode(text.replace(PLUS_RE, " "));
|
|
}
|
|
function parseQuery(parametersString = "") {
|
|
const object = {};
|
|
if (parametersString[0] === "?") {
|
|
parametersString = parametersString.slice(1);
|
|
}
|
|
for (const parameter of parametersString.split("&")) {
|
|
const s = parameter.match(/([^=]+)=?(.*)/) || [];
|
|
if (s.length < 2) {
|
|
continue;
|
|
}
|
|
const key = decodeQueryKey(s[1]);
|
|
if (key === "__proto__" || key === "constructor") {
|
|
continue;
|
|
}
|
|
const value = decodeQueryValue(s[2] || "");
|
|
if (object[key] === void 0) {
|
|
object[key] = value;
|
|
} else if (Array.isArray(object[key])) {
|
|
object[key].push(value);
|
|
} else {
|
|
object[key] = [object[key], value];
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
function encodeQueryItem(key, value) {
|
|
if (typeof value === "number" || typeof value === "boolean") {
|
|
value = String(value);
|
|
}
|
|
if (!value) {
|
|
return encodeQueryKey(key);
|
|
}
|
|
if (Array.isArray(value)) {
|
|
return value.map((_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`).join("&");
|
|
}
|
|
return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
|
|
}
|
|
function stringifyQuery(query) {
|
|
return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
|
|
}
|
|
const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
|
|
const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
|
|
const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
|
|
const PROTOCOL_SCRIPT_RE = /^[\s\0]*(blob|data|javascript|vbscript):$/i;
|
|
const TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
|
|
const JOIN_LEADING_SLASH_RE = /^\.?\//;
|
|
function hasProtocol(inputString, opts = {}) {
|
|
if (typeof opts === "boolean") {
|
|
opts = { acceptRelative: opts };
|
|
}
|
|
if (opts.strict) {
|
|
return PROTOCOL_STRICT_REGEX.test(inputString);
|
|
}
|
|
return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
|
|
}
|
|
function isScriptProtocol(protocol) {
|
|
return !!protocol && PROTOCOL_SCRIPT_RE.test(protocol);
|
|
}
|
|
function hasTrailingSlash(input = "", respectQueryAndFragment) {
|
|
if (!respectQueryAndFragment) {
|
|
return input.endsWith("/");
|
|
}
|
|
return TRAILING_SLASH_RE.test(input);
|
|
}
|
|
function withoutTrailingSlash(input = "", respectQueryAndFragment) {
|
|
if (!respectQueryAndFragment) {
|
|
return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
|
|
}
|
|
if (!hasTrailingSlash(input, true)) {
|
|
return input || "/";
|
|
}
|
|
let path = input;
|
|
let fragment = "";
|
|
const fragmentIndex = input.indexOf("#");
|
|
if (fragmentIndex >= 0) {
|
|
path = input.slice(0, fragmentIndex);
|
|
fragment = input.slice(fragmentIndex);
|
|
}
|
|
const [s0, ...s] = path.split("?");
|
|
const cleanPath = s0.endsWith("/") ? s0.slice(0, -1) : s0;
|
|
return (cleanPath || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
|
|
}
|
|
function withTrailingSlash(input = "", respectQueryAndFragment) {
|
|
if (!respectQueryAndFragment) {
|
|
return input.endsWith("/") ? input : input + "/";
|
|
}
|
|
if (hasTrailingSlash(input, true)) {
|
|
return input || "/";
|
|
}
|
|
let path = input;
|
|
let fragment = "";
|
|
const fragmentIndex = input.indexOf("#");
|
|
if (fragmentIndex >= 0) {
|
|
path = input.slice(0, fragmentIndex);
|
|
fragment = input.slice(fragmentIndex);
|
|
if (!path) {
|
|
return fragment;
|
|
}
|
|
}
|
|
const [s0, ...s] = path.split("?");
|
|
return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
|
|
}
|
|
function withQuery(input, query) {
|
|
const parsed = parseURL(input);
|
|
const mergedQuery = { ...parseQuery(parsed.search), ...query };
|
|
parsed.search = stringifyQuery(mergedQuery);
|
|
return stringifyParsedURL(parsed);
|
|
}
|
|
function isNonEmptyURL(url) {
|
|
return url && url !== "/";
|
|
}
|
|
function joinURL(base, ...input) {
|
|
let url = base || "";
|
|
for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
|
|
if (url) {
|
|
const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
|
|
url = withTrailingSlash(url) + _segment;
|
|
} else {
|
|
url = segment;
|
|
}
|
|
}
|
|
return url;
|
|
}
|
|
const protocolRelative = Symbol.for("ufo:protocolRelative");
|
|
function parseURL(input = "", defaultProto) {
|
|
const _specialProtoMatch = input.match(
|
|
/^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i
|
|
);
|
|
if (_specialProtoMatch) {
|
|
const [, _proto, _pathname = ""] = _specialProtoMatch;
|
|
return {
|
|
protocol: _proto.toLowerCase(),
|
|
pathname: _pathname,
|
|
href: _proto + _pathname,
|
|
auth: "",
|
|
host: "",
|
|
search: "",
|
|
hash: ""
|
|
};
|
|
}
|
|
if (!hasProtocol(input, { acceptRelative: true })) {
|
|
return parsePath(input);
|
|
}
|
|
const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
|
|
let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
|
|
if (protocol === "file:") {
|
|
path = path.replace(/\/(?=[A-Za-z]:)/, "");
|
|
}
|
|
const { pathname, search, hash } = parsePath(path);
|
|
return {
|
|
protocol: protocol.toLowerCase(),
|
|
auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
|
|
host,
|
|
pathname,
|
|
search,
|
|
hash,
|
|
[protocolRelative]: !protocol
|
|
};
|
|
}
|
|
function parsePath(input = "") {
|
|
const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
|
|
return {
|
|
pathname,
|
|
search,
|
|
hash
|
|
};
|
|
}
|
|
function stringifyParsedURL(parsed) {
|
|
const pathname = parsed.pathname || "";
|
|
const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
|
|
const hash = parsed.hash || "";
|
|
const auth = parsed.auth ? parsed.auth + "@" : "";
|
|
const host = parsed.host || "";
|
|
const proto = parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || "") + "//" : "";
|
|
return proto + auth + host + pathname + search + hash;
|
|
}
|
|
|
|
const appPageTransition = false;
|
|
const nuxtLinkDefaults = { "componentName": "NuxtLink" };
|
|
const appId = "nuxt-app";
|
|
|
|
function getNuxtAppCtx(id = appId) {
|
|
return getContext(id, {
|
|
asyncContext: false
|
|
});
|
|
}
|
|
const NuxtPluginIndicator = "__nuxt_plugin";
|
|
function createNuxtApp(options) {
|
|
var _a;
|
|
let hydratingCount = 0;
|
|
const nuxtApp = {
|
|
_id: options.id || appId || "nuxt-app",
|
|
_scope: effectScope(),
|
|
provide: void 0,
|
|
globalName: "nuxt",
|
|
versions: {
|
|
get nuxt() {
|
|
return "3.16.0";
|
|
},
|
|
get vue() {
|
|
return nuxtApp.vueApp.version;
|
|
}
|
|
},
|
|
payload: shallowReactive({
|
|
...((_a = options.ssrContext) == null ? void 0 : _a.payload) || {},
|
|
data: shallowReactive({}),
|
|
state: reactive({}),
|
|
once: /* @__PURE__ */ new Set(),
|
|
_errors: shallowReactive({})
|
|
}),
|
|
static: {
|
|
data: {}
|
|
},
|
|
runWithContext(fn) {
|
|
if (nuxtApp._scope.active && !getCurrentScope()) {
|
|
return nuxtApp._scope.run(() => callWithNuxt(nuxtApp, fn));
|
|
}
|
|
return callWithNuxt(nuxtApp, fn);
|
|
},
|
|
isHydrating: false,
|
|
deferHydration() {
|
|
if (!nuxtApp.isHydrating) {
|
|
return () => {
|
|
};
|
|
}
|
|
hydratingCount++;
|
|
let called = false;
|
|
return () => {
|
|
if (called) {
|
|
return;
|
|
}
|
|
called = true;
|
|
hydratingCount--;
|
|
if (hydratingCount === 0) {
|
|
nuxtApp.isHydrating = false;
|
|
return nuxtApp.callHook("app:suspense:resolve");
|
|
}
|
|
};
|
|
},
|
|
_asyncDataPromises: {},
|
|
_asyncData: shallowReactive({}),
|
|
_payloadRevivers: {},
|
|
...options
|
|
};
|
|
{
|
|
nuxtApp.payload.serverRendered = true;
|
|
}
|
|
if (nuxtApp.ssrContext) {
|
|
nuxtApp.payload.path = nuxtApp.ssrContext.url;
|
|
nuxtApp.ssrContext.nuxt = nuxtApp;
|
|
nuxtApp.ssrContext.payload = nuxtApp.payload;
|
|
nuxtApp.ssrContext.config = {
|
|
public: nuxtApp.ssrContext.runtimeConfig.public,
|
|
app: nuxtApp.ssrContext.runtimeConfig.app
|
|
};
|
|
}
|
|
nuxtApp.hooks = createHooks();
|
|
nuxtApp.hook = nuxtApp.hooks.hook;
|
|
{
|
|
const contextCaller = async function(hooks, args) {
|
|
for (const hook of hooks) {
|
|
await nuxtApp.runWithContext(() => hook(...args));
|
|
}
|
|
};
|
|
nuxtApp.hooks.callHook = (name, ...args) => nuxtApp.hooks.callHookWith(contextCaller, name, ...args);
|
|
}
|
|
nuxtApp.callHook = nuxtApp.hooks.callHook;
|
|
nuxtApp.provide = (name, value) => {
|
|
const $name = "$" + name;
|
|
defineGetter(nuxtApp, $name, value);
|
|
defineGetter(nuxtApp.vueApp.config.globalProperties, $name, value);
|
|
};
|
|
defineGetter(nuxtApp.vueApp, "$nuxt", nuxtApp);
|
|
defineGetter(nuxtApp.vueApp.config.globalProperties, "$nuxt", nuxtApp);
|
|
const runtimeConfig = options.ssrContext.runtimeConfig;
|
|
nuxtApp.provide("config", runtimeConfig);
|
|
return nuxtApp;
|
|
}
|
|
function registerPluginHooks(nuxtApp, plugin) {
|
|
if (plugin.hooks) {
|
|
nuxtApp.hooks.addHooks(plugin.hooks);
|
|
}
|
|
}
|
|
async function applyPlugin(nuxtApp, plugin) {
|
|
if (typeof plugin === "function") {
|
|
const { provide } = await nuxtApp.runWithContext(() => plugin(nuxtApp)) || {};
|
|
if (provide && typeof provide === "object") {
|
|
for (const key in provide) {
|
|
nuxtApp.provide(key, provide[key]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
async function applyPlugins(nuxtApp, plugins) {
|
|
var _a, _b, _c, _d;
|
|
const resolvedPlugins = [];
|
|
const unresolvedPlugins = [];
|
|
const parallels = [];
|
|
const errors = [];
|
|
let promiseDepth = 0;
|
|
async function executePlugin(plugin) {
|
|
var _a2;
|
|
const unresolvedPluginsForThisPlugin = ((_a2 = plugin.dependsOn) == null ? void 0 : _a2.filter((name) => plugins.some((p) => p._name === name) && !resolvedPlugins.includes(name))) ?? [];
|
|
if (unresolvedPluginsForThisPlugin.length > 0) {
|
|
unresolvedPlugins.push([new Set(unresolvedPluginsForThisPlugin), plugin]);
|
|
} else {
|
|
const promise = applyPlugin(nuxtApp, plugin).then(async () => {
|
|
if (plugin._name) {
|
|
resolvedPlugins.push(plugin._name);
|
|
await Promise.all(unresolvedPlugins.map(async ([dependsOn, unexecutedPlugin]) => {
|
|
if (dependsOn.has(plugin._name)) {
|
|
dependsOn.delete(plugin._name);
|
|
if (dependsOn.size === 0) {
|
|
promiseDepth++;
|
|
await executePlugin(unexecutedPlugin);
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
});
|
|
if (plugin.parallel) {
|
|
parallels.push(promise.catch((e) => errors.push(e)));
|
|
} else {
|
|
await promise;
|
|
}
|
|
}
|
|
}
|
|
for (const plugin of plugins) {
|
|
if (((_a = nuxtApp.ssrContext) == null ? void 0 : _a.islandContext) && ((_b = plugin.env) == null ? void 0 : _b.islands) === false) {
|
|
continue;
|
|
}
|
|
registerPluginHooks(nuxtApp, plugin);
|
|
}
|
|
for (const plugin of plugins) {
|
|
if (((_c = nuxtApp.ssrContext) == null ? void 0 : _c.islandContext) && ((_d = plugin.env) == null ? void 0 : _d.islands) === false) {
|
|
continue;
|
|
}
|
|
await executePlugin(plugin);
|
|
}
|
|
await Promise.all(parallels);
|
|
if (promiseDepth) {
|
|
for (let i = 0; i < promiseDepth; i++) {
|
|
await Promise.all(parallels);
|
|
}
|
|
}
|
|
if (errors.length) {
|
|
throw errors[0];
|
|
}
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function defineNuxtPlugin(plugin) {
|
|
if (typeof plugin === "function") {
|
|
return plugin;
|
|
}
|
|
const _name = plugin._name || plugin.name;
|
|
delete plugin.name;
|
|
return Object.assign(plugin.setup || (() => {
|
|
}), plugin, { [NuxtPluginIndicator]: true, _name });
|
|
}
|
|
function callWithNuxt(nuxt, setup, args) {
|
|
const fn = () => setup();
|
|
const nuxtAppCtx = getNuxtAppCtx(nuxt._id);
|
|
{
|
|
return nuxt.vueApp.runWithContext(() => nuxtAppCtx.callAsync(nuxt, fn));
|
|
}
|
|
}
|
|
function tryUseNuxtApp(id) {
|
|
var _a;
|
|
let nuxtAppInstance;
|
|
if (hasInjectionContext()) {
|
|
nuxtAppInstance = (_a = getCurrentInstance()) == null ? void 0 : _a.appContext.app.$nuxt;
|
|
}
|
|
nuxtAppInstance || (nuxtAppInstance = getNuxtAppCtx(id).tryUse());
|
|
return nuxtAppInstance || null;
|
|
}
|
|
function useNuxtApp(id) {
|
|
const nuxtAppInstance = tryUseNuxtApp(id);
|
|
if (!nuxtAppInstance) {
|
|
{
|
|
throw new Error("[nuxt] instance unavailable");
|
|
}
|
|
}
|
|
return nuxtAppInstance;
|
|
}
|
|
// @__NO_SIDE_EFFECTS__
|
|
function useRuntimeConfig(_event) {
|
|
return useNuxtApp().$config;
|
|
}
|
|
function defineGetter(obj, key, val) {
|
|
Object.defineProperty(obj, key, { get: () => val });
|
|
}
|
|
|
|
const NUXT_ERROR_SIGNATURE = "__nuxt_error";
|
|
const useError = () => toRef(useNuxtApp().payload, "error");
|
|
const showError = (error) => {
|
|
const nuxtError = createError(error);
|
|
try {
|
|
const nuxtApp = useNuxtApp();
|
|
const error2 = useError();
|
|
if (false) ;
|
|
error2.value || (error2.value = nuxtError);
|
|
} catch {
|
|
throw nuxtError;
|
|
}
|
|
return nuxtError;
|
|
};
|
|
const isNuxtError = (error) => !!error && typeof error === "object" && NUXT_ERROR_SIGNATURE in error;
|
|
const createError = (error) => {
|
|
const nuxtError = createError$1(error);
|
|
Object.defineProperty(nuxtError, NUXT_ERROR_SIGNATURE, {
|
|
value: true,
|
|
configurable: false,
|
|
writable: false
|
|
});
|
|
return nuxtError;
|
|
};
|
|
|
|
const unhead_dp1SxSKB06hYMJELWjNfMtwvJsT23iDY2Mk_6THvQzk = defineNuxtPlugin({
|
|
name: "nuxt:head",
|
|
enforce: "pre",
|
|
setup(nuxtApp) {
|
|
const head = nuxtApp.ssrContext.head;
|
|
nuxtApp.vueApp.use(head);
|
|
}
|
|
});
|
|
|
|
const ROUTE_KEY_PARENTHESES_RE$1 = /(:\w+)\([^)]+\)/g;
|
|
const ROUTE_KEY_SYMBOLS_RE$1 = /(:\w+)[?+*]/g;
|
|
const ROUTE_KEY_NORMAL_RE$1 = /:\w+/g;
|
|
const interpolatePath = (route, match) => {
|
|
return match.path.replace(ROUTE_KEY_PARENTHESES_RE$1, "$1").replace(ROUTE_KEY_SYMBOLS_RE$1, "$1").replace(ROUTE_KEY_NORMAL_RE$1, (r) => {
|
|
var _a;
|
|
return ((_a = route.params[r.slice(1)]) == null ? void 0 : _a.toString()) || "";
|
|
});
|
|
};
|
|
const generateRouteKey$1 = (routeProps, override) => {
|
|
const matchedRoute = routeProps.route.matched.find((m) => {
|
|
var _a;
|
|
return ((_a = m.components) == null ? void 0 : _a.default) === routeProps.Component.type;
|
|
});
|
|
const source = override ?? (matchedRoute == null ? void 0 : matchedRoute.meta.key) ?? (matchedRoute && interpolatePath(routeProps.route, matchedRoute));
|
|
return typeof source === "function" ? source(routeProps.route) : source;
|
|
};
|
|
function toArray(value) {
|
|
return Array.isArray(value) ? value : [value];
|
|
}
|
|
|
|
function isPlainObject(value) {
|
|
if (value === null || typeof value !== "object") {
|
|
return false;
|
|
}
|
|
const prototype = Object.getPrototypeOf(value);
|
|
if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
|
|
return false;
|
|
}
|
|
if (Symbol.iterator in value) {
|
|
return false;
|
|
}
|
|
if (Symbol.toStringTag in value) {
|
|
return Object.prototype.toString.call(value) === "[object Module]";
|
|
}
|
|
return true;
|
|
}
|
|
function _defu(baseObject, defaults, namespace = ".", merger) {
|
|
if (!isPlainObject(defaults)) {
|
|
return _defu(baseObject, {}, namespace);
|
|
}
|
|
const object = Object.assign({}, defaults);
|
|
for (const key in baseObject) {
|
|
if (key === "__proto__" || key === "constructor") {
|
|
continue;
|
|
}
|
|
const value = baseObject[key];
|
|
if (value === null || value === void 0) {
|
|
continue;
|
|
}
|
|
if (Array.isArray(value) && Array.isArray(object[key])) {
|
|
object[key] = [...value, ...object[key]];
|
|
} else if (isPlainObject(value) && isPlainObject(object[key])) {
|
|
object[key] = _defu(
|
|
value,
|
|
object[key],
|
|
(namespace ? `${namespace}.` : "") + key.toString());
|
|
} else {
|
|
object[key] = value;
|
|
}
|
|
}
|
|
return object;
|
|
}
|
|
function createDefu(merger) {
|
|
return (...arguments_) => (
|
|
// eslint-disable-next-line unicorn/no-array-reduce
|
|
arguments_.reduce((p, c) => _defu(p, c, ""), {})
|
|
);
|
|
}
|
|
const defu = createDefu();
|
|
|
|
async function getRouteRules(arg) {
|
|
const path = typeof arg === "string" ? arg : arg.path;
|
|
{
|
|
useNuxtApp().ssrContext._preloadManifest = true;
|
|
const _routeRulesMatcher = toRouteMatcher(
|
|
createRouter({ routes: useRuntimeConfig().nitro.routeRules })
|
|
);
|
|
return defu({}, ..._routeRulesMatcher.matchAll(path).reverse());
|
|
}
|
|
}
|
|
|
|
const LayoutMetaSymbol = Symbol("layout-meta");
|
|
const PageRouteSymbol = Symbol("route");
|
|
|
|
const useRouter = () => {
|
|
var _a;
|
|
return (_a = useNuxtApp()) == null ? void 0 : _a.$router;
|
|
};
|
|
const useRoute = () => {
|
|
if (hasInjectionContext()) {
|
|
return inject(PageRouteSymbol, useNuxtApp()._route);
|
|
}
|
|
return useNuxtApp()._route;
|
|
};
|
|
// @__NO_SIDE_EFFECTS__
|
|
function defineNuxtRouteMiddleware(middleware) {
|
|
return middleware;
|
|
}
|
|
const isProcessingMiddleware = () => {
|
|
try {
|
|
if (useNuxtApp()._processingMiddleware) {
|
|
return true;
|
|
}
|
|
} catch {
|
|
return false;
|
|
}
|
|
return false;
|
|
};
|
|
const URL_QUOTE_RE = /"/g;
|
|
const navigateTo = (to, options) => {
|
|
to || (to = "/");
|
|
const toPath = typeof to === "string" ? to : "path" in to ? resolveRouteObject(to) : useRouter().resolve(to).href;
|
|
const isExternalHost = hasProtocol(toPath, { acceptRelative: true });
|
|
const isExternal = (options == null ? void 0 : options.external) || isExternalHost;
|
|
if (isExternal) {
|
|
if (!(options == null ? void 0 : options.external)) {
|
|
throw new Error("Navigating to an external URL is not allowed by default. Use `navigateTo(url, { external: true })`.");
|
|
}
|
|
const { protocol } = new URL(toPath, "http://localhost");
|
|
if (protocol && isScriptProtocol(protocol)) {
|
|
throw new Error(`Cannot navigate to a URL with '${protocol}' protocol.`);
|
|
}
|
|
}
|
|
const inMiddleware = isProcessingMiddleware();
|
|
const router = useRouter();
|
|
const nuxtApp = useNuxtApp();
|
|
{
|
|
if (nuxtApp.ssrContext) {
|
|
const fullPath = typeof to === "string" || isExternal ? toPath : router.resolve(to).fullPath || "/";
|
|
const location2 = isExternal ? toPath : joinURL(useRuntimeConfig().app.baseURL, fullPath);
|
|
const redirect = async function(response) {
|
|
await nuxtApp.callHook("app:redirected");
|
|
const encodedLoc = location2.replace(URL_QUOTE_RE, "%22");
|
|
const encodedHeader = encodeURL(location2, isExternalHost);
|
|
nuxtApp.ssrContext._renderResponse = {
|
|
statusCode: sanitizeStatusCode((options == null ? void 0 : options.redirectCode) || 302, 302),
|
|
body: `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head></html>`,
|
|
headers: { location: encodedHeader }
|
|
};
|
|
return response;
|
|
};
|
|
if (!isExternal && inMiddleware) {
|
|
router.afterEach((final) => final.fullPath === fullPath ? redirect(false) : void 0);
|
|
return to;
|
|
}
|
|
return redirect(!inMiddleware ? void 0 : (
|
|
/* abort route navigation */
|
|
false
|
|
));
|
|
}
|
|
}
|
|
if (isExternal) {
|
|
nuxtApp._scope.stop();
|
|
if (options == null ? void 0 : options.replace) {
|
|
(void 0).replace(toPath);
|
|
} else {
|
|
(void 0).href = toPath;
|
|
}
|
|
if (inMiddleware) {
|
|
if (!nuxtApp.isHydrating) {
|
|
return false;
|
|
}
|
|
return new Promise(() => {
|
|
});
|
|
}
|
|
return Promise.resolve();
|
|
}
|
|
return (options == null ? void 0 : options.replace) ? router.replace(to) : router.push(to);
|
|
};
|
|
function resolveRouteObject(to) {
|
|
return withQuery(to.path || "", to.query || {}) + (to.hash || "");
|
|
}
|
|
function encodeURL(location2, isExternalHost = false) {
|
|
const url = new URL(location2, "http://localhost");
|
|
if (!isExternalHost) {
|
|
return url.pathname + url.search + url.hash;
|
|
}
|
|
if (location2.startsWith("//")) {
|
|
return url.toString().replace(url.protocol, "");
|
|
}
|
|
return url.toString();
|
|
}
|
|
|
|
function handleHotUpdate(_router, _generateRoutes) {
|
|
}
|
|
const _routes = [
|
|
{
|
|
name: "details-id",
|
|
path: "/details/:id()",
|
|
component: () => import('./_id_.vue.mjs')
|
|
},
|
|
{
|
|
name: "index.html",
|
|
path: "/index.html",
|
|
component: () => import('./index.vue.mjs')
|
|
},
|
|
{
|
|
name: "index",
|
|
path: "/",
|
|
component: () => import('./index.vue2.mjs')
|
|
},
|
|
{
|
|
name: "publish",
|
|
path: "/publish",
|
|
component: () => import('./index.vue3.mjs')
|
|
}
|
|
];
|
|
|
|
const ROUTE_KEY_PARENTHESES_RE = /(:\w+)\([^)]+\)/g;
|
|
const ROUTE_KEY_SYMBOLS_RE = /(:\w+)[?+*]/g;
|
|
const ROUTE_KEY_NORMAL_RE = /:\w+/g;
|
|
function generateRouteKey(route) {
|
|
const source = (route == null ? void 0 : route.meta.key) ?? route.path.replace(ROUTE_KEY_PARENTHESES_RE, "$1").replace(ROUTE_KEY_SYMBOLS_RE, "$1").replace(ROUTE_KEY_NORMAL_RE, (r) => {
|
|
var _a;
|
|
return ((_a = route.params[r.slice(1)]) == null ? void 0 : _a.toString()) || "";
|
|
});
|
|
return typeof source === "function" ? source(route) : source;
|
|
}
|
|
function isChangingPage(to, from) {
|
|
if (to === from || from === START_LOCATION) {
|
|
return false;
|
|
}
|
|
if (generateRouteKey(to) !== generateRouteKey(from)) {
|
|
return true;
|
|
}
|
|
const areComponentsSame = to.matched.every(
|
|
(comp, index) => {
|
|
var _a, _b;
|
|
return comp.components && comp.components.default === ((_b = (_a = from.matched[index]) == null ? void 0 : _a.components) == null ? void 0 : _b.default);
|
|
}
|
|
);
|
|
if (areComponentsSame) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
const routerOptions0 = {
|
|
scrollBehavior(to, from, savedPosition) {
|
|
var _a;
|
|
const nuxtApp = useNuxtApp();
|
|
const behavior = ((_a = useRouter().options) == null ? void 0 : _a.scrollBehaviorType) ?? "auto";
|
|
let position = savedPosition || void 0;
|
|
const routeAllowsScrollToTop = typeof to.meta.scrollToTop === "function" ? to.meta.scrollToTop(to, from) : to.meta.scrollToTop;
|
|
if (!position && from && to && routeAllowsScrollToTop !== false && isChangingPage(to, from)) {
|
|
position = { left: 0, top: 0 };
|
|
}
|
|
if (to.path === from.path) {
|
|
if (from.hash && !to.hash) {
|
|
return { left: 0, top: 0 };
|
|
}
|
|
if (to.hash) {
|
|
return { el: to.hash, top: _getHashElementScrollMarginTop(to.hash), behavior };
|
|
}
|
|
return false;
|
|
}
|
|
const hasTransition = (route) => !!(route.meta.pageTransition ?? appPageTransition);
|
|
const hookToWait = hasTransition(from) && hasTransition(to) ? "page:transition:finish" : "page:finish";
|
|
return new Promise((resolve) => {
|
|
nuxtApp.hooks.hookOnce(hookToWait, async () => {
|
|
await new Promise((resolve2) => setTimeout(resolve2, 0));
|
|
if (to.hash) {
|
|
position = { el: to.hash, top: _getHashElementScrollMarginTop(to.hash), behavior };
|
|
}
|
|
resolve(position);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
function _getHashElementScrollMarginTop(selector) {
|
|
try {
|
|
const elem = (void 0).querySelector(selector);
|
|
if (elem) {
|
|
return (Number.parseFloat(getComputedStyle(elem).scrollMarginTop) || 0) + (Number.parseFloat(getComputedStyle((void 0).documentElement).scrollPaddingTop) || 0);
|
|
}
|
|
} catch {
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
const configRouterOptions = {
|
|
hashMode: false,
|
|
scrollBehaviorType: "auto"
|
|
};
|
|
const routerOptions = {
|
|
...configRouterOptions,
|
|
...routerOptions0
|
|
};
|
|
|
|
const validate = defineNuxtRouteMiddleware(async (to) => {
|
|
var _a;
|
|
let __temp, __restore;
|
|
if (!((_a = to.meta) == null ? void 0 : _a.validate)) {
|
|
return;
|
|
}
|
|
const nuxtApp = useNuxtApp();
|
|
const router = useRouter();
|
|
const result = ([__temp, __restore] = executeAsync(() => Promise.resolve(to.meta.validate(to))), __temp = await __temp, __restore(), __temp);
|
|
if (result === true) {
|
|
return;
|
|
}
|
|
const error = createError({
|
|
statusCode: result && result.statusCode || 404,
|
|
statusMessage: result && result.statusMessage || `Page Not Found: ${to.fullPath}`,
|
|
data: {
|
|
path: to.fullPath
|
|
}
|
|
});
|
|
const unsub = router.beforeResolve((final) => {
|
|
unsub();
|
|
if (final === to) {
|
|
const unsub2 = router.afterEach(async () => {
|
|
unsub2();
|
|
await nuxtApp.runWithContext(() => showError(error));
|
|
});
|
|
return false;
|
|
}
|
|
});
|
|
});
|
|
|
|
const manifest_45route_45rule = defineNuxtRouteMiddleware(async (to) => {
|
|
{
|
|
return;
|
|
}
|
|
});
|
|
|
|
const globalMiddleware = [
|
|
validate,
|
|
manifest_45route_45rule
|
|
];
|
|
const namedMiddleware = {
|
|
"error-handler": () => import('./errorHandler.mjs')
|
|
};
|
|
|
|
const plugin = defineNuxtPlugin({
|
|
name: "nuxt:router",
|
|
enforce: "pre",
|
|
async setup(nuxtApp) {
|
|
var _a, _b, _c, _d;
|
|
let __temp, __restore;
|
|
let routerBase = useRuntimeConfig().app.baseURL;
|
|
const history = ((_b = (_a = routerOptions).history) == null ? void 0 : _b.call(_a, routerBase)) ?? createMemoryHistory(routerBase);
|
|
const routes = routerOptions.routes ? ([__temp, __restore] = executeAsync(() => routerOptions.routes(_routes)), __temp = await __temp, __restore(), __temp) ?? _routes : _routes;
|
|
let startPosition;
|
|
const router = createRouter$1({
|
|
...routerOptions,
|
|
scrollBehavior: (to, from, savedPosition) => {
|
|
if (from === START_LOCATION) {
|
|
startPosition = savedPosition;
|
|
return;
|
|
}
|
|
if (routerOptions.scrollBehavior) {
|
|
router.options.scrollBehavior = routerOptions.scrollBehavior;
|
|
if ("scrollRestoration" in (void 0).history) {
|
|
const unsub = router.beforeEach(() => {
|
|
unsub();
|
|
(void 0).history.scrollRestoration = "manual";
|
|
});
|
|
}
|
|
return routerOptions.scrollBehavior(to, START_LOCATION, startPosition || savedPosition);
|
|
}
|
|
},
|
|
history,
|
|
routes
|
|
});
|
|
handleHotUpdate(router, routerOptions.routes ? routerOptions.routes : (routes2) => routes2);
|
|
nuxtApp.vueApp.use(router);
|
|
const previousRoute = shallowRef(router.currentRoute.value);
|
|
router.afterEach((_to, from) => {
|
|
previousRoute.value = from;
|
|
});
|
|
Object.defineProperty(nuxtApp.vueApp.config.globalProperties, "previousRoute", {
|
|
get: () => previousRoute.value
|
|
});
|
|
const initialURL = nuxtApp.ssrContext.url;
|
|
const _route = shallowRef(router.currentRoute.value);
|
|
const syncCurrentRoute = () => {
|
|
_route.value = router.currentRoute.value;
|
|
};
|
|
nuxtApp.hook("page:finish", syncCurrentRoute);
|
|
router.afterEach((to, from) => {
|
|
var _a2, _b2, _c2, _d2;
|
|
if (((_b2 = (_a2 = to.matched[0]) == null ? void 0 : _a2.components) == null ? void 0 : _b2.default) === ((_d2 = (_c2 = from.matched[0]) == null ? void 0 : _c2.components) == null ? void 0 : _d2.default)) {
|
|
syncCurrentRoute();
|
|
}
|
|
});
|
|
const route = {};
|
|
for (const key in _route.value) {
|
|
Object.defineProperty(route, key, {
|
|
get: () => _route.value[key],
|
|
enumerable: true
|
|
});
|
|
}
|
|
nuxtApp._route = shallowReactive(route);
|
|
nuxtApp._middleware || (nuxtApp._middleware = {
|
|
global: [],
|
|
named: {}
|
|
});
|
|
useError();
|
|
if (!((_c = nuxtApp.ssrContext) == null ? void 0 : _c.islandContext)) {
|
|
router.afterEach(async (to, _from, failure) => {
|
|
delete nuxtApp._processingMiddleware;
|
|
if (failure) {
|
|
await nuxtApp.callHook("page:loading:end");
|
|
}
|
|
if ((failure == null ? void 0 : failure.type) === 4) {
|
|
return;
|
|
}
|
|
if (to.redirectedFrom && to.fullPath !== initialURL) {
|
|
await nuxtApp.runWithContext(() => navigateTo(to.fullPath || "/"));
|
|
}
|
|
});
|
|
}
|
|
try {
|
|
if (true) {
|
|
;
|
|
[__temp, __restore] = executeAsync(() => router.push(initialURL)), await __temp, __restore();
|
|
;
|
|
}
|
|
;
|
|
[__temp, __restore] = executeAsync(() => router.isReady()), await __temp, __restore();
|
|
;
|
|
} catch (error2) {
|
|
[__temp, __restore] = executeAsync(() => nuxtApp.runWithContext(() => showError(error2))), await __temp, __restore();
|
|
}
|
|
const resolvedInitialRoute = router.currentRoute.value;
|
|
syncCurrentRoute();
|
|
if ((_d = nuxtApp.ssrContext) == null ? void 0 : _d.islandContext) {
|
|
return { provide: { router } };
|
|
}
|
|
const initialLayout = nuxtApp.payload.state._layout;
|
|
router.beforeEach(async (to, from) => {
|
|
var _a2, _b2, _c2;
|
|
await nuxtApp.callHook("page:loading:start");
|
|
to.meta = reactive(to.meta);
|
|
if (nuxtApp.isHydrating && initialLayout && !isReadonly(to.meta.layout)) {
|
|
to.meta.layout = initialLayout;
|
|
}
|
|
nuxtApp._processingMiddleware = true;
|
|
if (!((_a2 = nuxtApp.ssrContext) == null ? void 0 : _a2.islandContext)) {
|
|
const middlewareEntries = /* @__PURE__ */ new Set([...globalMiddleware, ...nuxtApp._middleware.global]);
|
|
for (const component of to.matched) {
|
|
const componentMiddleware = component.meta.middleware;
|
|
if (!componentMiddleware) {
|
|
continue;
|
|
}
|
|
for (const entry of toArray(componentMiddleware)) {
|
|
middlewareEntries.add(entry);
|
|
}
|
|
}
|
|
{
|
|
const routeRules = await nuxtApp.runWithContext(() => getRouteRules({ path: to.path }));
|
|
if (routeRules.appMiddleware) {
|
|
for (const key in routeRules.appMiddleware) {
|
|
if (routeRules.appMiddleware[key]) {
|
|
middlewareEntries.add(key);
|
|
} else {
|
|
middlewareEntries.delete(key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (const entry of middlewareEntries) {
|
|
const middleware = typeof entry === "string" ? nuxtApp._middleware.named[entry] || await ((_c2 = (_b2 = namedMiddleware)[entry]) == null ? void 0 : _c2.call(_b2).then((r) => r.default || r)) : entry;
|
|
if (!middleware) {
|
|
throw new Error(`Unknown route middleware: '${entry}'.`);
|
|
}
|
|
const result = await nuxtApp.runWithContext(() => middleware(to, from));
|
|
{
|
|
if (result === false || result instanceof Error) {
|
|
const error2 = result || createError$1({
|
|
statusCode: 404,
|
|
statusMessage: `Page Not Found: ${initialURL}`
|
|
});
|
|
await nuxtApp.runWithContext(() => showError(error2));
|
|
return false;
|
|
}
|
|
}
|
|
if (result === true) {
|
|
continue;
|
|
}
|
|
if (result || result === false) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
router.onError(async () => {
|
|
delete nuxtApp._processingMiddleware;
|
|
await nuxtApp.callHook("page:loading:end");
|
|
});
|
|
router.afterEach(async (to, _from) => {
|
|
if (to.matched.length === 0) {
|
|
await nuxtApp.runWithContext(() => showError(createError$1({
|
|
statusCode: 404,
|
|
fatal: false,
|
|
statusMessage: `Page not found: ${to.fullPath}`,
|
|
data: {
|
|
path: to.fullPath
|
|
}
|
|
})));
|
|
}
|
|
});
|
|
nuxtApp.hooks.hookOnce("app:created", async () => {
|
|
try {
|
|
if ("name" in resolvedInitialRoute) {
|
|
resolvedInitialRoute.name = void 0;
|
|
}
|
|
await router.replace({
|
|
...resolvedInitialRoute,
|
|
force: true
|
|
});
|
|
router.options.scrollBehavior = routerOptions.scrollBehavior;
|
|
} catch (error2) {
|
|
await nuxtApp.runWithContext(() => showError(error2));
|
|
}
|
|
});
|
|
return { provide: { router } };
|
|
}
|
|
});
|
|
|
|
function definePayloadReducer(name, reduce) {
|
|
{
|
|
useNuxtApp().ssrContext._payloadReducers[name] = reduce;
|
|
}
|
|
}
|
|
|
|
const reducers = [
|
|
["NuxtError", (data) => isNuxtError(data) && data.toJSON()],
|
|
["EmptyShallowRef", (data) => isRef(data) && isShallow(data) && !data.value && (typeof data.value === "bigint" ? "0n" : JSON.stringify(data.value) || "_")],
|
|
["EmptyRef", (data) => isRef(data) && !data.value && (typeof data.value === "bigint" ? "0n" : JSON.stringify(data.value) || "_")],
|
|
["ShallowRef", (data) => isRef(data) && isShallow(data) && data.value],
|
|
["ShallowReactive", (data) => isReactive(data) && isShallow(data) && toRaw(data)],
|
|
["Ref", (data) => isRef(data) && data.value],
|
|
["Reactive", (data) => isReactive(data) && toRaw(data)]
|
|
];
|
|
const revive_payload_server_BXtMNu_ou6aFPdlr2yij0Fh8hzak_1_swgnvOLyyoss = defineNuxtPlugin({
|
|
name: "nuxt:revive-payload:server",
|
|
setup() {
|
|
for (const [reducer, fn] of reducers) {
|
|
definePayloadReducer(reducer, fn);
|
|
}
|
|
}
|
|
});
|
|
|
|
const components_plugin_z4hgvsiddfKkfXTP6M8M4zG5Cb7sGnDhcryKVM45Di4 = defineNuxtPlugin({
|
|
name: "nuxt:global-components"
|
|
});
|
|
|
|
const element_plus_teleports_plugin_3k7A_fjEiCzFRl6aN3qftblOS_EZCmhIb_4gXrhvbuY = defineNuxtPlugin((nuxtApp) => {
|
|
nuxtApp.hook("app:rendered", (ctx) => {
|
|
var _a;
|
|
if ((_a = ctx.ssrContext) == null ? void 0 : _a.teleports) {
|
|
ctx.ssrContext.teleports = renderTeleports(ctx.ssrContext.teleports);
|
|
}
|
|
});
|
|
});
|
|
function renderTeleports(teleports) {
|
|
const body = Object.entries(teleports).reduce((all, [key, value]) => {
|
|
if (key.startsWith("#el-popper-container-") || [].includes(key)) {
|
|
return `${all}<div id="${key.slice(1)}">${value}</div>`;
|
|
}
|
|
return all;
|
|
}, teleports.body || "");
|
|
return { ...teleports, body };
|
|
}
|
|
|
|
const defaultNamespace = "el";
|
|
const statePrefix = "is-";
|
|
const _bem = (namespace, block, blockSuffix, element, modifier) => {
|
|
let cls = `${namespace}-${block}`;
|
|
if (blockSuffix) {
|
|
cls += `-${blockSuffix}`;
|
|
}
|
|
if (element) {
|
|
cls += `__${element}`;
|
|
}
|
|
if (modifier) {
|
|
cls += `--${modifier}`;
|
|
}
|
|
return cls;
|
|
};
|
|
const namespaceContextKey = Symbol("namespaceContextKey");
|
|
const useGetDerivedNamespace = (namespaceOverrides) => {
|
|
const derivedNamespace = getCurrentInstance() ? inject(namespaceContextKey, ref(defaultNamespace)) : ref(defaultNamespace);
|
|
const namespace = computed(() => {
|
|
return unref(derivedNamespace) || defaultNamespace;
|
|
});
|
|
return namespace;
|
|
};
|
|
const useNamespace = (block, namespaceOverrides) => {
|
|
const namespace = useGetDerivedNamespace();
|
|
const b = (blockSuffix = "") => _bem(namespace.value, block, blockSuffix, "", "");
|
|
const e = (element) => element ? _bem(namespace.value, block, "", element, "") : "";
|
|
const m = (modifier) => modifier ? _bem(namespace.value, block, "", "", modifier) : "";
|
|
const be = (blockSuffix, element) => blockSuffix && element ? _bem(namespace.value, block, blockSuffix, element, "") : "";
|
|
const em = (element, modifier) => element && modifier ? _bem(namespace.value, block, "", element, modifier) : "";
|
|
const bm = (blockSuffix, modifier) => blockSuffix && modifier ? _bem(namespace.value, block, blockSuffix, "", modifier) : "";
|
|
const bem = (blockSuffix, element, modifier) => blockSuffix && element && modifier ? _bem(namespace.value, block, blockSuffix, element, modifier) : "";
|
|
const is = (name, ...args) => {
|
|
const state = args.length >= 1 ? args[0] : true;
|
|
return name && state ? `${statePrefix}${name}` : "";
|
|
};
|
|
const cssVar = (object) => {
|
|
const styles = {};
|
|
for (const key in object) {
|
|
if (object[key]) {
|
|
styles[`--${namespace.value}-${key}`] = object[key];
|
|
}
|
|
}
|
|
return styles;
|
|
};
|
|
const cssVarBlock = (object) => {
|
|
const styles = {};
|
|
for (const key in object) {
|
|
if (object[key]) {
|
|
styles[`--${namespace.value}-${block}-${key}`] = object[key];
|
|
}
|
|
}
|
|
return styles;
|
|
};
|
|
const cssVarName = (name) => `--${namespace.value}-${name}`;
|
|
const cssVarBlockName = (name) => `--${namespace.value}-${block}-${name}`;
|
|
return {
|
|
namespace,
|
|
b,
|
|
e,
|
|
m,
|
|
be,
|
|
em,
|
|
bm,
|
|
bem,
|
|
is,
|
|
cssVar,
|
|
cssVarName,
|
|
cssVarBlock,
|
|
cssVarBlockName
|
|
};
|
|
};
|
|
|
|
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
|
|
|
|
var shared_cjs_prod = {};
|
|
|
|
var hasRequiredShared_cjs_prod;
|
|
function requireShared_cjs_prod() {
|
|
if (hasRequiredShared_cjs_prod) return shared_cjs_prod;
|
|
hasRequiredShared_cjs_prod = 1;
|
|
/**
|
|
* @vue/shared v3.5.13
|
|
* (c) 2018-present Yuxi (Evan) You and Vue contributors
|
|
* @license MIT
|
|
**/
|
|
Object.defineProperty(shared_cjs_prod, "__esModule", { value: true });
|
|
/*! #__NO_SIDE_EFFECTS__ */
|
|
// @__NO_SIDE_EFFECTS__
|
|
function makeMap(str) {
|
|
const map = /* @__PURE__ */ Object.create(null);
|
|
for (const key of str.split(",")) map[key] = 1;
|
|
return (val) => val in map;
|
|
}
|
|
const EMPTY_OBJ = {};
|
|
const EMPTY_ARR = [];
|
|
const NOOP = () => {
|
|
};
|
|
const NO = () => false;
|
|
const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
|
|
(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
|
|
const isModelListener = (key) => key.startsWith("onUpdate:");
|
|
const extend = Object.assign;
|
|
const remove = (arr, el) => {
|
|
const i = arr.indexOf(el);
|
|
if (i > -1) {
|
|
arr.splice(i, 1);
|
|
}
|
|
};
|
|
const hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
const hasOwn = (val, key) => hasOwnProperty.call(val, key);
|
|
const isArray = Array.isArray;
|
|
const isMap = (val) => toTypeString(val) === "[object Map]";
|
|
const isSet = (val) => toTypeString(val) === "[object Set]";
|
|
const isDate = (val) => toTypeString(val) === "[object Date]";
|
|
const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
|
|
const isFunction = (val) => typeof val === "function";
|
|
const isString = (val) => typeof val === "string";
|
|
const isSymbol = (val) => typeof val === "symbol";
|
|
const isObject = (val) => val !== null && typeof val === "object";
|
|
const isPromise = (val) => {
|
|
return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
|
|
};
|
|
const objectToString = Object.prototype.toString;
|
|
const toTypeString = (value) => objectToString.call(value);
|
|
const toRawType = (value) => {
|
|
return toTypeString(value).slice(8, -1);
|
|
};
|
|
const isPlainObject = (val) => toTypeString(val) === "[object Object]";
|
|
const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
|
|
const isReservedProp = /* @__PURE__ */ makeMap(
|
|
// the leading comma is intentional so empty string "" is also included
|
|
",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
|
|
);
|
|
const isBuiltInDirective = /* @__PURE__ */ makeMap(
|
|
"bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
|
|
);
|
|
const cacheStringFunction = (fn) => {
|
|
const cache = /* @__PURE__ */ Object.create(null);
|
|
return (str) => {
|
|
const hit = cache[str];
|
|
return hit || (cache[str] = fn(str));
|
|
};
|
|
};
|
|
const camelizeRE = /-(\w)/g;
|
|
const camelize = cacheStringFunction(
|
|
(str) => {
|
|
return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
|
|
}
|
|
);
|
|
const hyphenateRE = /\B([A-Z])/g;
|
|
const hyphenate = cacheStringFunction(
|
|
(str) => str.replace(hyphenateRE, "-$1").toLowerCase()
|
|
);
|
|
const capitalize = cacheStringFunction((str) => {
|
|
return str.charAt(0).toUpperCase() + str.slice(1);
|
|
});
|
|
const toHandlerKey = cacheStringFunction(
|
|
(str) => {
|
|
const s = str ? `on${capitalize(str)}` : ``;
|
|
return s;
|
|
}
|
|
);
|
|
const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
|
|
const invokeArrayFns = (fns, ...arg) => {
|
|
for (let i = 0; i < fns.length; i++) {
|
|
fns[i](...arg);
|
|
}
|
|
};
|
|
const def = (obj, key, value, writable = false) => {
|
|
Object.defineProperty(obj, key, {
|
|
configurable: true,
|
|
enumerable: false,
|
|
writable,
|
|
value
|
|
});
|
|
};
|
|
const looseToNumber = (val) => {
|
|
const n = parseFloat(val);
|
|
return isNaN(n) ? val : n;
|
|
};
|
|
const toNumber = (val) => {
|
|
const n = isString(val) ? Number(val) : NaN;
|
|
return isNaN(n) ? val : n;
|
|
};
|
|
let _globalThis;
|
|
const getGlobalThis = () => {
|
|
return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof commonjsGlobal !== "undefined" ? commonjsGlobal : {});
|
|
};
|
|
const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
|
|
function genPropsAccessExp(name) {
|
|
return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
|
|
}
|
|
function genCacheKey(source, options) {
|
|
return source + JSON.stringify(
|
|
options,
|
|
(_, val) => typeof val === "function" ? val.toString() : val
|
|
);
|
|
}
|
|
const PatchFlags = {
|
|
"TEXT": 1,
|
|
"1": "TEXT",
|
|
"CLASS": 2,
|
|
"2": "CLASS",
|
|
"STYLE": 4,
|
|
"4": "STYLE",
|
|
"PROPS": 8,
|
|
"8": "PROPS",
|
|
"FULL_PROPS": 16,
|
|
"16": "FULL_PROPS",
|
|
"NEED_HYDRATION": 32,
|
|
"32": "NEED_HYDRATION",
|
|
"STABLE_FRAGMENT": 64,
|
|
"64": "STABLE_FRAGMENT",
|
|
"KEYED_FRAGMENT": 128,
|
|
"128": "KEYED_FRAGMENT",
|
|
"UNKEYED_FRAGMENT": 256,
|
|
"256": "UNKEYED_FRAGMENT",
|
|
"NEED_PATCH": 512,
|
|
"512": "NEED_PATCH",
|
|
"DYNAMIC_SLOTS": 1024,
|
|
"1024": "DYNAMIC_SLOTS",
|
|
"DEV_ROOT_FRAGMENT": 2048,
|
|
"2048": "DEV_ROOT_FRAGMENT",
|
|
"CACHED": -1,
|
|
"-1": "CACHED",
|
|
"BAIL": -2,
|
|
"-2": "BAIL"
|
|
};
|
|
const PatchFlagNames = {
|
|
[1]: `TEXT`,
|
|
[2]: `CLASS`,
|
|
[4]: `STYLE`,
|
|
[8]: `PROPS`,
|
|
[16]: `FULL_PROPS`,
|
|
[32]: `NEED_HYDRATION`,
|
|
[64]: `STABLE_FRAGMENT`,
|
|
[128]: `KEYED_FRAGMENT`,
|
|
[256]: `UNKEYED_FRAGMENT`,
|
|
[512]: `NEED_PATCH`,
|
|
[1024]: `DYNAMIC_SLOTS`,
|
|
[2048]: `DEV_ROOT_FRAGMENT`,
|
|
[-1]: `HOISTED`,
|
|
[-2]: `BAIL`
|
|
};
|
|
const ShapeFlags = {
|
|
"ELEMENT": 1,
|
|
"1": "ELEMENT",
|
|
"FUNCTIONAL_COMPONENT": 2,
|
|
"2": "FUNCTIONAL_COMPONENT",
|
|
"STATEFUL_COMPONENT": 4,
|
|
"4": "STATEFUL_COMPONENT",
|
|
"TEXT_CHILDREN": 8,
|
|
"8": "TEXT_CHILDREN",
|
|
"ARRAY_CHILDREN": 16,
|
|
"16": "ARRAY_CHILDREN",
|
|
"SLOTS_CHILDREN": 32,
|
|
"32": "SLOTS_CHILDREN",
|
|
"TELEPORT": 64,
|
|
"64": "TELEPORT",
|
|
"SUSPENSE": 128,
|
|
"128": "SUSPENSE",
|
|
"COMPONENT_SHOULD_KEEP_ALIVE": 256,
|
|
"256": "COMPONENT_SHOULD_KEEP_ALIVE",
|
|
"COMPONENT_KEPT_ALIVE": 512,
|
|
"512": "COMPONENT_KEPT_ALIVE",
|
|
"COMPONENT": 6,
|
|
"6": "COMPONENT"
|
|
};
|
|
const SlotFlags = {
|
|
"STABLE": 1,
|
|
"1": "STABLE",
|
|
"DYNAMIC": 2,
|
|
"2": "DYNAMIC",
|
|
"FORWARDED": 3,
|
|
"3": "FORWARDED"
|
|
};
|
|
const slotFlagsText = {
|
|
[1]: "STABLE",
|
|
[2]: "DYNAMIC",
|
|
[3]: "FORWARDED"
|
|
};
|
|
const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
|
|
const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
|
|
const isGloballyWhitelisted = isGloballyAllowed;
|
|
const range = 2;
|
|
function generateCodeFrame(source, start = 0, end = source.length) {
|
|
start = Math.max(0, Math.min(start, source.length));
|
|
end = Math.max(0, Math.min(end, source.length));
|
|
if (start > end) return "";
|
|
let lines = source.split(/(\r?\n)/);
|
|
const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
|
|
lines = lines.filter((_, idx) => idx % 2 === 0);
|
|
let count = 0;
|
|
const res = [];
|
|
for (let i = 0; i < lines.length; i++) {
|
|
count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
|
|
if (count >= start) {
|
|
for (let j = i - range; j <= i + range || end > count; j++) {
|
|
if (j < 0 || j >= lines.length) continue;
|
|
const line = j + 1;
|
|
res.push(
|
|
`${line}${" ".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`
|
|
);
|
|
const lineLength = lines[j].length;
|
|
const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
|
|
if (j === i) {
|
|
const pad = start - (count - (lineLength + newLineSeqLength));
|
|
const length = Math.max(
|
|
1,
|
|
end > count ? lineLength - pad : end - start
|
|
);
|
|
res.push(` | ` + " ".repeat(pad) + "^".repeat(length));
|
|
} else if (j > i) {
|
|
if (end > count) {
|
|
const length = Math.max(Math.min(end - count, lineLength), 1);
|
|
res.push(` | ` + "^".repeat(length));
|
|
}
|
|
count += lineLength + newLineSeqLength;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return res.join("\n");
|
|
}
|
|
function normalizeStyle(value) {
|
|
if (isArray(value)) {
|
|
const res = {};
|
|
for (let i = 0; i < value.length; i++) {
|
|
const item = value[i];
|
|
const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
|
|
if (normalized) {
|
|
for (const key in normalized) {
|
|
res[key] = normalized[key];
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
} else if (isString(value) || isObject(value)) {
|
|
return value;
|
|
}
|
|
}
|
|
const listDelimiterRE = /;(?![^(]*\))/g;
|
|
const propertyDelimiterRE = /:([^]+)/;
|
|
const styleCommentRE = /\/\*[^]*?\*\//g;
|
|
function parseStringStyle(cssText) {
|
|
const ret = {};
|
|
cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
|
|
if (item) {
|
|
const tmp = item.split(propertyDelimiterRE);
|
|
tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
|
|
}
|
|
});
|
|
return ret;
|
|
}
|
|
function stringifyStyle(styles) {
|
|
if (!styles) return "";
|
|
if (isString(styles)) return styles;
|
|
let ret = "";
|
|
for (const key in styles) {
|
|
const value = styles[key];
|
|
if (isString(value) || typeof value === "number") {
|
|
const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
|
|
ret += `${normalizedKey}:${value};`;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
function normalizeClass(value) {
|
|
let res = "";
|
|
if (isString(value)) {
|
|
res = value;
|
|
} else if (isArray(value)) {
|
|
for (let i = 0; i < value.length; i++) {
|
|
const normalized = normalizeClass(value[i]);
|
|
if (normalized) {
|
|
res += normalized + " ";
|
|
}
|
|
}
|
|
} else if (isObject(value)) {
|
|
for (const name in value) {
|
|
if (value[name]) {
|
|
res += name + " ";
|
|
}
|
|
}
|
|
}
|
|
return res.trim();
|
|
}
|
|
function normalizeProps(props) {
|
|
if (!props) return null;
|
|
let { class: klass, style } = props;
|
|
if (klass && !isString(klass)) {
|
|
props.class = normalizeClass(klass);
|
|
}
|
|
if (style) {
|
|
props.style = normalizeStyle(style);
|
|
}
|
|
return props;
|
|
}
|
|
const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
|
|
const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
|
|
const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
|
|
const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
|
|
const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
|
|
const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
|
|
const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
|
|
const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
|
|
const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
|
|
const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
|
|
const isBooleanAttr = /* @__PURE__ */ makeMap(
|
|
specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
|
|
);
|
|
function includeBooleanAttr(value) {
|
|
return !!value || value === "";
|
|
}
|
|
const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
|
|
const attrValidationCache = {};
|
|
function isSSRSafeAttrName(name) {
|
|
if (attrValidationCache.hasOwnProperty(name)) {
|
|
return attrValidationCache[name];
|
|
}
|
|
const isUnsafe = unsafeAttrCharRE.test(name);
|
|
if (isUnsafe) {
|
|
console.error(`unsafe attribute name: ${name}`);
|
|
}
|
|
return attrValidationCache[name] = !isUnsafe;
|
|
}
|
|
const propsToAttrMap = {
|
|
acceptCharset: "accept-charset",
|
|
className: "class",
|
|
htmlFor: "for",
|
|
httpEquiv: "http-equiv"
|
|
};
|
|
const isKnownHtmlAttr = /* @__PURE__ */ makeMap(
|
|
`accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`
|
|
);
|
|
const isKnownSvgAttr = /* @__PURE__ */ makeMap(
|
|
`xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
|
|
);
|
|
const isKnownMathMLAttr = /* @__PURE__ */ makeMap(
|
|
`accent,accentunder,actiontype,align,alignmentscope,altimg,altimg-height,altimg-valign,altimg-width,alttext,bevelled,close,columnsalign,columnlines,columnspan,denomalign,depth,dir,display,displaystyle,encoding,equalcolumns,equalrows,fence,fontstyle,fontweight,form,frame,framespacing,groupalign,height,href,id,indentalign,indentalignfirst,indentalignlast,indentshift,indentshiftfirst,indentshiftlast,indextype,justify,largetop,largeop,lquote,lspace,mathbackground,mathcolor,mathsize,mathvariant,maxsize,minlabelspacing,mode,other,overflow,position,rowalign,rowlines,rowspan,rquote,rspace,scriptlevel,scriptminsize,scriptsizemultiplier,selection,separator,separators,shift,side,src,stackalign,stretchy,subscriptshift,superscriptshift,symmetric,voffset,width,widths,xlink:href,xlink:show,xlink:type,xmlns`
|
|
);
|
|
function isRenderableAttrValue(value) {
|
|
if (value == null) {
|
|
return false;
|
|
}
|
|
const type = typeof value;
|
|
return type === "string" || type === "number" || type === "boolean";
|
|
}
|
|
const escapeRE = /["'&<>]/;
|
|
function escapeHtml(string) {
|
|
const str = "" + string;
|
|
const match = escapeRE.exec(str);
|
|
if (!match) {
|
|
return str;
|
|
}
|
|
let html = "";
|
|
let escaped;
|
|
let index;
|
|
let lastIndex = 0;
|
|
for (index = match.index; index < str.length; index++) {
|
|
switch (str.charCodeAt(index)) {
|
|
case 34:
|
|
escaped = """;
|
|
break;
|
|
case 38:
|
|
escaped = "&";
|
|
break;
|
|
case 39:
|
|
escaped = "'";
|
|
break;
|
|
case 60:
|
|
escaped = "<";
|
|
break;
|
|
case 62:
|
|
escaped = ">";
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
if (lastIndex !== index) {
|
|
html += str.slice(lastIndex, index);
|
|
}
|
|
lastIndex = index + 1;
|
|
html += escaped;
|
|
}
|
|
return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
|
|
}
|
|
const commentStripRE = /^-?>|<!--|-->|--!>|<!-$/g;
|
|
function escapeHtmlComment(src) {
|
|
return src.replace(commentStripRE, "");
|
|
}
|
|
const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
|
|
function getEscapedCssVarName(key, doubleEscape) {
|
|
return key.replace(
|
|
cssVarNameEscapeSymbolsRE,
|
|
(s) => doubleEscape ? s === '"' ? '\\\\\\"' : `\\\\${s}` : `\\${s}`
|
|
);
|
|
}
|
|
function looseCompareArrays(a, b) {
|
|
if (a.length !== b.length) return false;
|
|
let equal = true;
|
|
for (let i = 0; equal && i < a.length; i++) {
|
|
equal = looseEqual(a[i], b[i]);
|
|
}
|
|
return equal;
|
|
}
|
|
function looseEqual(a, b) {
|
|
if (a === b) return true;
|
|
let aValidType = isDate(a);
|
|
let bValidType = isDate(b);
|
|
if (aValidType || bValidType) {
|
|
return aValidType && bValidType ? a.getTime() === b.getTime() : false;
|
|
}
|
|
aValidType = isSymbol(a);
|
|
bValidType = isSymbol(b);
|
|
if (aValidType || bValidType) {
|
|
return a === b;
|
|
}
|
|
aValidType = isArray(a);
|
|
bValidType = isArray(b);
|
|
if (aValidType || bValidType) {
|
|
return aValidType && bValidType ? looseCompareArrays(a, b) : false;
|
|
}
|
|
aValidType = isObject(a);
|
|
bValidType = isObject(b);
|
|
if (aValidType || bValidType) {
|
|
if (!aValidType || !bValidType) {
|
|
return false;
|
|
}
|
|
const aKeysCount = Object.keys(a).length;
|
|
const bKeysCount = Object.keys(b).length;
|
|
if (aKeysCount !== bKeysCount) {
|
|
return false;
|
|
}
|
|
for (const key in a) {
|
|
const aHasKey = a.hasOwnProperty(key);
|
|
const bHasKey = b.hasOwnProperty(key);
|
|
if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return String(a) === String(b);
|
|
}
|
|
function looseIndexOf(arr, val) {
|
|
return arr.findIndex((item) => looseEqual(item, val));
|
|
}
|
|
const isRef = (val) => {
|
|
return !!(val && val["__v_isRef"] === true);
|
|
};
|
|
const toDisplayString = (val) => {
|
|
return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
|
|
};
|
|
const replacer = (_key, val) => {
|
|
if (isRef(val)) {
|
|
return replacer(_key, val.value);
|
|
} else if (isMap(val)) {
|
|
return {
|
|
[`Map(${val.size})`]: [...val.entries()].reduce(
|
|
(entries, [key, val2], i) => {
|
|
entries[stringifySymbol(key, i) + " =>"] = val2;
|
|
return entries;
|
|
},
|
|
{}
|
|
)
|
|
};
|
|
} else if (isSet(val)) {
|
|
return {
|
|
[`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
|
|
};
|
|
} else if (isSymbol(val)) {
|
|
return stringifySymbol(val);
|
|
} else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
|
|
return String(val);
|
|
}
|
|
return val;
|
|
};
|
|
const stringifySymbol = (v, i = "") => {
|
|
var _a;
|
|
return (
|
|
// Symbol.description in es2019+ so we need to cast here to pass
|
|
// the lib: es2016 check
|
|
isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
|
|
);
|
|
};
|
|
shared_cjs_prod.EMPTY_ARR = EMPTY_ARR;
|
|
shared_cjs_prod.EMPTY_OBJ = EMPTY_OBJ;
|
|
shared_cjs_prod.NO = NO;
|
|
shared_cjs_prod.NOOP = NOOP;
|
|
shared_cjs_prod.PatchFlagNames = PatchFlagNames;
|
|
shared_cjs_prod.PatchFlags = PatchFlags;
|
|
shared_cjs_prod.ShapeFlags = ShapeFlags;
|
|
shared_cjs_prod.SlotFlags = SlotFlags;
|
|
shared_cjs_prod.camelize = camelize;
|
|
shared_cjs_prod.capitalize = capitalize;
|
|
shared_cjs_prod.cssVarNameEscapeSymbolsRE = cssVarNameEscapeSymbolsRE;
|
|
shared_cjs_prod.def = def;
|
|
shared_cjs_prod.escapeHtml = escapeHtml;
|
|
shared_cjs_prod.escapeHtmlComment = escapeHtmlComment;
|
|
shared_cjs_prod.extend = extend;
|
|
shared_cjs_prod.genCacheKey = genCacheKey;
|
|
shared_cjs_prod.genPropsAccessExp = genPropsAccessExp;
|
|
shared_cjs_prod.generateCodeFrame = generateCodeFrame;
|
|
shared_cjs_prod.getEscapedCssVarName = getEscapedCssVarName;
|
|
shared_cjs_prod.getGlobalThis = getGlobalThis;
|
|
shared_cjs_prod.hasChanged = hasChanged;
|
|
shared_cjs_prod.hasOwn = hasOwn;
|
|
shared_cjs_prod.hyphenate = hyphenate;
|
|
shared_cjs_prod.includeBooleanAttr = includeBooleanAttr;
|
|
shared_cjs_prod.invokeArrayFns = invokeArrayFns;
|
|
shared_cjs_prod.isArray = isArray;
|
|
shared_cjs_prod.isBooleanAttr = isBooleanAttr;
|
|
shared_cjs_prod.isBuiltInDirective = isBuiltInDirective;
|
|
shared_cjs_prod.isDate = isDate;
|
|
shared_cjs_prod.isFunction = isFunction;
|
|
shared_cjs_prod.isGloballyAllowed = isGloballyAllowed;
|
|
shared_cjs_prod.isGloballyWhitelisted = isGloballyWhitelisted;
|
|
shared_cjs_prod.isHTMLTag = isHTMLTag;
|
|
shared_cjs_prod.isIntegerKey = isIntegerKey;
|
|
shared_cjs_prod.isKnownHtmlAttr = isKnownHtmlAttr;
|
|
shared_cjs_prod.isKnownMathMLAttr = isKnownMathMLAttr;
|
|
shared_cjs_prod.isKnownSvgAttr = isKnownSvgAttr;
|
|
shared_cjs_prod.isMap = isMap;
|
|
shared_cjs_prod.isMathMLTag = isMathMLTag;
|
|
shared_cjs_prod.isModelListener = isModelListener;
|
|
shared_cjs_prod.isObject = isObject;
|
|
shared_cjs_prod.isOn = isOn;
|
|
shared_cjs_prod.isPlainObject = isPlainObject;
|
|
shared_cjs_prod.isPromise = isPromise;
|
|
shared_cjs_prod.isRegExp = isRegExp;
|
|
shared_cjs_prod.isRenderableAttrValue = isRenderableAttrValue;
|
|
shared_cjs_prod.isReservedProp = isReservedProp;
|
|
shared_cjs_prod.isSSRSafeAttrName = isSSRSafeAttrName;
|
|
shared_cjs_prod.isSVGTag = isSVGTag;
|
|
shared_cjs_prod.isSet = isSet;
|
|
shared_cjs_prod.isSpecialBooleanAttr = isSpecialBooleanAttr;
|
|
shared_cjs_prod.isString = isString;
|
|
shared_cjs_prod.isSymbol = isSymbol;
|
|
shared_cjs_prod.isVoidTag = isVoidTag;
|
|
shared_cjs_prod.looseEqual = looseEqual;
|
|
shared_cjs_prod.looseIndexOf = looseIndexOf;
|
|
shared_cjs_prod.looseToNumber = looseToNumber;
|
|
shared_cjs_prod.makeMap = makeMap;
|
|
shared_cjs_prod.normalizeClass = normalizeClass;
|
|
shared_cjs_prod.normalizeProps = normalizeProps;
|
|
shared_cjs_prod.normalizeStyle = normalizeStyle;
|
|
shared_cjs_prod.objectToString = objectToString;
|
|
shared_cjs_prod.parseStringStyle = parseStringStyle;
|
|
shared_cjs_prod.propsToAttrMap = propsToAttrMap;
|
|
shared_cjs_prod.remove = remove;
|
|
shared_cjs_prod.slotFlagsText = slotFlagsText;
|
|
shared_cjs_prod.stringifyStyle = stringifyStyle;
|
|
shared_cjs_prod.toDisplayString = toDisplayString;
|
|
shared_cjs_prod.toHandlerKey = toHandlerKey;
|
|
shared_cjs_prod.toNumber = toNumber;
|
|
shared_cjs_prod.toRawType = toRawType;
|
|
shared_cjs_prod.toTypeString = toTypeString;
|
|
return shared_cjs_prod;
|
|
}
|
|
|
|
var shared_cjs_prodExports = /* @__PURE__ */ requireShared_cjs_prod();
|
|
|
|
var __defProp$9 = Object.defineProperty;
|
|
var __defProps$6 = Object.defineProperties;
|
|
var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
|
|
var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
|
|
var __hasOwnProp$b = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
|
|
var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __spreadValues$9 = (a, b) => {
|
|
for (var prop in b || (b = {}))
|
|
if (__hasOwnProp$b.call(b, prop))
|
|
__defNormalProp$9(a, prop, b[prop]);
|
|
if (__getOwnPropSymbols$b)
|
|
for (var prop of __getOwnPropSymbols$b(b)) {
|
|
if (__propIsEnum$b.call(b, prop))
|
|
__defNormalProp$9(a, prop, b[prop]);
|
|
}
|
|
return a;
|
|
};
|
|
var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
|
|
function computedEager(fn, options) {
|
|
var _a2;
|
|
const result = shallowRef();
|
|
watchEffect(() => {
|
|
result.value = fn();
|
|
}, __spreadProps$6(__spreadValues$9({}, options), {
|
|
flush: (_a2 = void 0) != null ? _a2 : "sync"
|
|
}));
|
|
return readonly(result);
|
|
}
|
|
const isClient = false;
|
|
const isString = (val) => typeof val === "string";
|
|
const noop = () => {
|
|
};
|
|
function resolveUnref(r) {
|
|
return typeof r === "function" ? r() : unref(r);
|
|
}
|
|
function identity(arg) {
|
|
return arg;
|
|
}
|
|
function tryOnScopeDispose(fn) {
|
|
if (getCurrentScope()) {
|
|
onScopeDispose(fn);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function tryOnMounted(fn, sync = true) {
|
|
if (getCurrentInstance())
|
|
;
|
|
else if (sync)
|
|
fn();
|
|
else
|
|
nextTick(fn);
|
|
}
|
|
function useTimeoutFn(cb, interval, options = {}) {
|
|
const {
|
|
immediate = true
|
|
} = options;
|
|
const isPending = ref(false);
|
|
let timer = null;
|
|
function clear() {
|
|
if (timer) {
|
|
clearTimeout(timer);
|
|
timer = null;
|
|
}
|
|
}
|
|
function stop() {
|
|
isPending.value = false;
|
|
clear();
|
|
}
|
|
function start(...args) {
|
|
clear();
|
|
isPending.value = true;
|
|
timer = setTimeout(() => {
|
|
isPending.value = false;
|
|
timer = null;
|
|
cb(...args);
|
|
}, resolveUnref(interval));
|
|
}
|
|
if (immediate) {
|
|
isPending.value = true;
|
|
}
|
|
tryOnScopeDispose(stop);
|
|
return {
|
|
isPending: readonly(isPending),
|
|
start,
|
|
stop
|
|
};
|
|
}
|
|
|
|
const defaultIdInjection = {
|
|
prefix: Math.floor(Math.random() * 1e4),
|
|
current: 0
|
|
};
|
|
const ID_INJECTION_KEY = Symbol("elIdInjection");
|
|
const useIdInjection = () => {
|
|
return getCurrentInstance() ? inject(ID_INJECTION_KEY, defaultIdInjection) : defaultIdInjection;
|
|
};
|
|
const useId = (deterministicId) => {
|
|
const idInjection = useIdInjection();
|
|
const namespace = useGetDerivedNamespace();
|
|
const idRef = computedEager(() => unref(deterministicId) || `${namespace.value}-id-${idInjection.prefix}-${idInjection.current++}`);
|
|
return idRef;
|
|
};
|
|
|
|
const isUndefined = (val) => val === void 0;
|
|
const isBoolean = (val) => typeof val === "boolean";
|
|
const isNumber = (val) => typeof val === "number";
|
|
const isEmpty = (val) => !val && val !== 0 || shared_cjs_prodExports.isArray(val) && val.length === 0 || shared_cjs_prodExports.isObject(val) && !Object.keys(val).length;
|
|
const isElement = (e) => {
|
|
if (typeof Element === "undefined")
|
|
return false;
|
|
return e instanceof Element;
|
|
};
|
|
const isStringNumber = (val) => {
|
|
if (!shared_cjs_prodExports.isString(val)) {
|
|
return false;
|
|
}
|
|
return !Number.isNaN(Number(val));
|
|
};
|
|
shared_cjs_prodExports.isArray;
|
|
shared_cjs_prodExports.isDate;
|
|
shared_cjs_prodExports.isFunction;
|
|
shared_cjs_prodExports.isObject;
|
|
shared_cjs_prodExports.isString;
|
|
|
|
const initial = {
|
|
current: 0
|
|
};
|
|
const zIndex = ref(0);
|
|
const defaultInitialZIndex = 2e3;
|
|
const ZINDEX_INJECTION_KEY = Symbol("elZIndexContextKey");
|
|
const zIndexContextKey = Symbol("zIndexContextKey");
|
|
const useZIndex = (zIndexOverrides) => {
|
|
const increasingInjection = getCurrentInstance() ? inject(ZINDEX_INJECTION_KEY, initial) : initial;
|
|
const zIndexInjection = getCurrentInstance() ? inject(zIndexContextKey, void 0) : void 0;
|
|
const initialZIndex = computed(() => {
|
|
const zIndexFromInjection = unref(zIndexInjection);
|
|
return isNumber(zIndexFromInjection) ? zIndexFromInjection : defaultInitialZIndex;
|
|
});
|
|
const currentZIndex = computed(() => initialZIndex.value + zIndex.value);
|
|
const nextZIndex = () => {
|
|
increasingInjection.current++;
|
|
zIndex.value = increasingInjection.current;
|
|
return currentZIndex.value;
|
|
};
|
|
if (!inject(ZINDEX_INJECTION_KEY)) ;
|
|
return {
|
|
initialZIndex,
|
|
currentZIndex,
|
|
nextZIndex
|
|
};
|
|
};
|
|
|
|
const element_plus_injection_plugin_LfLkpoHjV8s4Q4lRVuq_y_LbzJB5vFvehZzxqpiP_nk = defineNuxtPlugin((nuxtApp) => {
|
|
nuxtApp.vueApp.provide(ID_INJECTION_KEY, { "prefix": 1024, "current": 0 }).provide(ZINDEX_INJECTION_KEY, { "current": 0 });
|
|
});
|
|
|
|
const plugins = [
|
|
unhead_dp1SxSKB06hYMJELWjNfMtwvJsT23iDY2Mk_6THvQzk,
|
|
plugin,
|
|
revive_payload_server_BXtMNu_ou6aFPdlr2yij0Fh8hzak_1_swgnvOLyyoss,
|
|
components_plugin_z4hgvsiddfKkfXTP6M8M4zG5Cb7sGnDhcryKVM45Di4,
|
|
element_plus_teleports_plugin_3k7A_fjEiCzFRl6aN3qftblOS_EZCmhIb_4gXrhvbuY,
|
|
element_plus_injection_plugin_LfLkpoHjV8s4Q4lRVuq_y_LbzJB5vFvehZzxqpiP_nk
|
|
];
|
|
|
|
const defineRouteProvider = (name = "RouteProvider") => defineComponent({
|
|
name,
|
|
props: {
|
|
vnode: {
|
|
type: Object,
|
|
required: true
|
|
},
|
|
route: {
|
|
type: Object,
|
|
required: true
|
|
},
|
|
vnodeRef: Object,
|
|
renderKey: String,
|
|
trackRootNodes: Boolean
|
|
},
|
|
setup(props) {
|
|
const previousKey = props.renderKey;
|
|
const previousRoute = props.route;
|
|
const route = {};
|
|
for (const key in props.route) {
|
|
Object.defineProperty(route, key, {
|
|
get: () => previousKey === props.renderKey ? props.route[key] : previousRoute[key],
|
|
enumerable: true
|
|
});
|
|
}
|
|
provide(PageRouteSymbol, shallowReactive(route));
|
|
return () => {
|
|
return h(props.vnode, { ref: props.vnodeRef });
|
|
};
|
|
}
|
|
});
|
|
const RouteProvider = defineRouteProvider();
|
|
|
|
const __nuxt_component_0 = defineComponent({
|
|
name: "NuxtPage",
|
|
inheritAttrs: false,
|
|
props: {
|
|
name: {
|
|
type: String
|
|
},
|
|
transition: {
|
|
type: [Boolean, Object],
|
|
default: void 0
|
|
},
|
|
keepalive: {
|
|
type: [Boolean, Object],
|
|
default: void 0
|
|
},
|
|
route: {
|
|
type: Object
|
|
},
|
|
pageKey: {
|
|
type: [Function, String],
|
|
default: null
|
|
}
|
|
},
|
|
setup(props, { attrs, slots, expose }) {
|
|
const nuxtApp = useNuxtApp();
|
|
const pageRef = ref();
|
|
const forkRoute = inject(PageRouteSymbol, null);
|
|
let previousPageKey;
|
|
expose({ pageRef });
|
|
inject(LayoutMetaSymbol, null);
|
|
let vnode;
|
|
const done = nuxtApp.deferHydration();
|
|
if (props.pageKey) {
|
|
watch(() => props.pageKey, (next, prev) => {
|
|
if (next !== prev) {
|
|
nuxtApp.callHook("page:loading:start");
|
|
}
|
|
});
|
|
}
|
|
return () => {
|
|
return h(RouterView, { name: props.name, route: props.route, ...attrs }, {
|
|
default: (routeProps) => {
|
|
if (!routeProps.Component) {
|
|
done();
|
|
return;
|
|
}
|
|
const key = generateRouteKey$1(routeProps, props.pageKey);
|
|
if (!nuxtApp.isHydrating && !hasChildrenRoutes(forkRoute, routeProps.route, routeProps.Component) && previousPageKey === key) {
|
|
nuxtApp.callHook("page:loading:end");
|
|
}
|
|
previousPageKey = key;
|
|
{
|
|
vnode = h(Suspense, {
|
|
suspensible: true
|
|
}, {
|
|
default: () => {
|
|
const providerVNode = h(RouteProvider, {
|
|
key: key || void 0,
|
|
vnode: slots.default ? normalizeSlot(slots.default, routeProps) : routeProps.Component,
|
|
route: routeProps.route,
|
|
renderKey: key || void 0,
|
|
vnodeRef: pageRef
|
|
});
|
|
return providerVNode;
|
|
}
|
|
});
|
|
return vnode;
|
|
}
|
|
}
|
|
});
|
|
};
|
|
}
|
|
});
|
|
function hasChildrenRoutes(fork, newRoute, Component) {
|
|
if (!fork) {
|
|
return false;
|
|
}
|
|
const index = newRoute.matched.findIndex((m) => {
|
|
var _a;
|
|
return ((_a = m.components) == null ? void 0 : _a.default) === (Component == null ? void 0 : Component.type);
|
|
});
|
|
return index < newRoute.matched.length - 1;
|
|
}
|
|
function normalizeSlot(slot, data) {
|
|
const slotContent = slot(data);
|
|
return slotContent.length === 1 ? h(slotContent[0]) : h(Fragment, void 0, slotContent);
|
|
}
|
|
|
|
/* empty css */
|
|
const _sfc_main$2 = {
|
|
__name: "app",
|
|
__ssrInlineRender: true,
|
|
setup(__props) {
|
|
useRoute();
|
|
let isNeedLogin = ref(true);
|
|
let userInfo = ref({});
|
|
let isGetLoginState = ref(true);
|
|
const goLogin = () => {
|
|
return;
|
|
};
|
|
provide("isNeedLogin", isNeedLogin);
|
|
provide("userInfo", userInfo);
|
|
provide("goLogin", goLogin);
|
|
provide("isGetLoginState", isGetLoginState);
|
|
return (_ctx, _push, _parent, _attrs) => {
|
|
const _component_NuxtPage = __nuxt_component_0;
|
|
_push(`<!--[--><div id="append_parent"></div><div id="ajaxwaitid"></div>`);
|
|
_push(ssrRenderComponent(_component_NuxtPage, null, null, _parent));
|
|
_push(`<!--]-->`);
|
|
};
|
|
}
|
|
};
|
|
const _sfc_setup$2 = _sfc_main$2.setup;
|
|
_sfc_main$2.setup = (props, ctx) => {
|
|
const ssrContext = useSSRContext();
|
|
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("app.vue");
|
|
return _sfc_setup$2 ? _sfc_setup$2(props, ctx) : void 0;
|
|
};
|
|
|
|
const _sfc_main$1 = {
|
|
__name: "nuxt-error-page",
|
|
__ssrInlineRender: true,
|
|
props: {
|
|
error: Object
|
|
},
|
|
setup(__props) {
|
|
const props = __props;
|
|
const _error = props.error;
|
|
_error.stack ? _error.stack.split("\n").splice(1).map((line) => {
|
|
const text = line.replace("webpack:/", "").replace(".vue", ".js").trim();
|
|
return {
|
|
text,
|
|
internal: line.includes("node_modules") && !line.includes(".cache") || line.includes("internal") || line.includes("new Promise")
|
|
};
|
|
}).map((i) => `<span class="stack${i.internal ? " internal" : ""}">${i.text}</span>`).join("\n") : "";
|
|
const statusCode = Number(_error.statusCode || 500);
|
|
const is404 = statusCode === 404;
|
|
const statusMessage = _error.statusMessage ?? (is404 ? "Page Not Found" : "Internal Server Error");
|
|
const description = _error.message || _error.toString();
|
|
const stack = void 0;
|
|
const _Error404 = defineAsyncComponent(() => import('./error-404.vue.mjs'));
|
|
const _Error = defineAsyncComponent(() => import('./error-500.vue.mjs'));
|
|
const ErrorTemplate = is404 ? _Error404 : _Error;
|
|
return (_ctx, _push, _parent, _attrs) => {
|
|
_push(ssrRenderComponent(unref(ErrorTemplate), mergeProps({ statusCode: unref(statusCode), statusMessage: unref(statusMessage), description: unref(description), stack: unref(stack) }, _attrs), null, _parent));
|
|
};
|
|
}
|
|
};
|
|
const _sfc_setup$1 = _sfc_main$1.setup;
|
|
_sfc_main$1.setup = (props, ctx) => {
|
|
const ssrContext = useSSRContext();
|
|
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("node_modules/.store/nuxt@3.16.0/node_modules/nuxt/dist/app/components/nuxt-error-page.vue");
|
|
return _sfc_setup$1 ? _sfc_setup$1(props, ctx) : void 0;
|
|
};
|
|
|
|
const _sfc_main = {
|
|
__name: "nuxt-root",
|
|
__ssrInlineRender: true,
|
|
setup(__props) {
|
|
const IslandRenderer = () => null;
|
|
const nuxtApp = useNuxtApp();
|
|
nuxtApp.deferHydration();
|
|
nuxtApp.ssrContext.url;
|
|
const SingleRenderer = false;
|
|
provide(PageRouteSymbol, useRoute());
|
|
nuxtApp.hooks.callHookWith((hooks) => hooks.map((hook) => hook()), "vue:setup");
|
|
const error = useError();
|
|
const abortRender = error.value && !nuxtApp.ssrContext.error;
|
|
onErrorCaptured((err, target, info) => {
|
|
nuxtApp.hooks.callHook("vue:error", err, target, info).catch((hookError) => console.error("[nuxt] Error in `vue:error` hook", hookError));
|
|
{
|
|
const p = nuxtApp.runWithContext(() => showError(err));
|
|
onServerPrefetch(() => p);
|
|
return false;
|
|
}
|
|
});
|
|
const islandContext = nuxtApp.ssrContext.islandContext;
|
|
return (_ctx, _push, _parent, _attrs) => {
|
|
ssrRenderSuspense(_push, {
|
|
default: () => {
|
|
if (unref(abortRender)) {
|
|
_push(`<div></div>`);
|
|
} else if (unref(error)) {
|
|
_push(ssrRenderComponent(unref(_sfc_main$1), { error: unref(error) }, null, _parent));
|
|
} else if (unref(islandContext)) {
|
|
_push(ssrRenderComponent(unref(IslandRenderer), { context: unref(islandContext) }, null, _parent));
|
|
} else if (unref(SingleRenderer)) {
|
|
ssrRenderVNode(_push, createVNode(resolveDynamicComponent(unref(SingleRenderer)), null, null), _parent);
|
|
} else {
|
|
_push(ssrRenderComponent(unref(_sfc_main$2), null, null, _parent));
|
|
}
|
|
},
|
|
_: 1
|
|
});
|
|
};
|
|
}
|
|
};
|
|
const _sfc_setup = _sfc_main.setup;
|
|
_sfc_main.setup = (props, ctx) => {
|
|
const ssrContext = useSSRContext();
|
|
(ssrContext.modules || (ssrContext.modules = /* @__PURE__ */ new Set())).add("node_modules/.store/nuxt@3.16.0/node_modules/nuxt/dist/app/components/nuxt-root.vue");
|
|
return _sfc_setup ? _sfc_setup(props, ctx) : void 0;
|
|
};
|
|
|
|
let entry;
|
|
{
|
|
entry = async function createNuxtAppServer(ssrContext) {
|
|
var _a;
|
|
const vueApp = createApp(_sfc_main);
|
|
const nuxt = createNuxtApp({ vueApp, ssrContext });
|
|
try {
|
|
await applyPlugins(nuxt, plugins);
|
|
await nuxt.hooks.callHook("app:created", vueApp);
|
|
} catch (error) {
|
|
await nuxt.hooks.callHook("app:error", error);
|
|
(_a = nuxt.payload).error || (_a.error = createError(error));
|
|
}
|
|
if (ssrContext == null ? void 0 : ssrContext._renderResponse) {
|
|
throw new Error("skipping render");
|
|
}
|
|
return vueApp;
|
|
};
|
|
}
|
|
const entry$1 = (ssrContext) => entry(ssrContext);
|
|
|
|
const server = /*#__PURE__*/Object.freeze({
|
|
__proto__: null,
|
|
default: entry$1
|
|
});
|
|
|
|
export { noop as A, resolveUnref as B, tryOnMounted as C, identity as D, useGetDerivedNamespace as E, useIdInjection as F, isStringNumber as G, namespaceContextKey as H, zIndexContextKey as I, tryUseNuxtApp as J, server as K, useNuxtApp as a, useRuntimeConfig as b, withoutTrailingSlash as c, nuxtLinkDefaults as d, useNamespace as e, useRoute as f, useZIndex as g, hasProtocol as h, isBoolean as i, joinURL as j, useId as k, defaultNamespace as l, useTimeoutFn as m, navigateTo as n, isElement as o, parseQuery as p, isNumber as q, resolveRouteObject as r, shared_cjs_prodExports as s, isEmpty as t, useRouter as u, isUndefined as v, withTrailingSlash as w, tryOnScopeDispose as x, isClient as y, isString as z };
|
|
//# sourceMappingURL=server.mjs.map
|