@pubinfo/devtools 2.0.15 → 2.1.0

package/dist/client/assets/fetch-CTfoU6yt.js

@@ -0,0 +1,873 @@
+import { J as watch, N as customRef, O as effectScope, P as getCurrentScope, Q as isRef, R as onScopeDispose, T as readonly, U as ref, V as shallowReadonly, W as shallowRef, X as toRef, Y as toValue, Z as unref, k as computed, r as defineComponent, s as getCurrentInstance, x as nextTick, z as onMounted } from "./index-BSkduMKH.js";
+function tryOnScopeDispose(fn) {
+	return getCurrentScope() ? (onScopeDispose(fn), true) : false;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function createEventHook() {
+	const fns = /* @__PURE__ */ new Set(), off = (fn) => {
+		fns.delete(fn);
+	}, clear = () => {
+		fns.clear();
+	}, on = (fn) => {
+		fns.add(fn);
+		const offFn = () => off(fn);
+		return tryOnScopeDispose(offFn), { off: offFn };
+	}, trigger = (...args) => {
+		return Promise.all(Array.from(fns).map((fn) => fn(...args)));
+	};
+	return {
+		on,
+		off,
+		trigger,
+		clear
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function createSharedComposable(composable) {
+	let subscribers = 0, state, scope;
+	const dispose = () => {
+		if (subscribers -= 1, scope && subscribers <= 0) scope.stop(), state = void 0, scope = void 0;
+	};
+	return (...args) => {
+		if (subscribers += 1, !scope) scope = effectScope(true), state = scope.run(() => composable(...args));
+		return tryOnScopeDispose(dispose), state;
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function makeDestructurable(obj, arr) {
+	if (typeof Symbol !== "undefined") {
+		const clone = { ...obj };
+		return Object.defineProperty(clone, Symbol.iterator, {
+			enumerable: false,
+			value() {
+				let index = 0;
+				return { next: () => ({
+					value: arr[index++],
+					done: index > arr.length
+				}) };
+			}
+		}), clone;
+	} else return Object.assign([...arr], obj);
+}
+const isClient = typeof window !== "undefined" && typeof document !== "undefined", isWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope, isDef = (val) => typeof val !== "undefined", toString = Object.prototype.toString, isObject = (val) => toString.call(val) === "[object Object]", noop = () => {}, isIOS = /* @__PURE__ */ getIsIOS();
+function getIsIOS() {
+	var _a, _b;
+	return isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_b = window == null ? void 0 : window.navigator) == null ? void 0 : _b.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window == null ? void 0 : window.navigator.userAgent));
+}
+function toRef$1(...args) {
+	if (args.length !== 1) return toRef(...args);
+	const r = args[0];
+	return typeof r === "function" ? readonly(customRef(() => ({
+		get: r,
+		set: noop
+	}))) : ref(r);
+}
+function createFilterWrapper(filter, fn) {
+	function wrapper(...args) {
+		return new Promise((resolve, reject) => {
+			Promise.resolve(filter(() => fn.apply(this, args), {
+				fn,
+				thisArg: this,
+				args
+			})).then(resolve).catch(reject);
+		});
+	}
+	return wrapper;
+}
+const bypassFilter = (invoke) => {
+	return invoke();
+};
+function pausableFilter(extendFilter = bypassFilter, options = {}) {
+	const { initialState = "active" } = options, isActive = toRef$1(initialState === "active");
+	function pause() {
+		isActive.value = false;
+	}
+	function resume() {
+		isActive.value = true;
+	}
+	const eventFilter = (...args) => {
+		if (isActive.value) extendFilter(...args);
+	};
+	return {
+		isActive: readonly(isActive),
+		pause,
+		resume,
+		eventFilter
+	};
+}
+function promiseTimeout(ms, throwOnTimeout = false, reason = "Timeout") {
+	return new Promise((resolve, reject) => {
+		if (throwOnTimeout) setTimeout(() => reject(reason), ms);
+		else setTimeout(resolve, ms);
+	});
+}
+function containsProp(obj, ...props) {
+	return props.some((k) => k in obj);
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function cacheStringFunction(fn) {
+	const cache = /* @__PURE__ */ Object.create(null);
+	return (str) => {
+		const hit = cache[str];
+		return hit || (cache[str] = fn(str));
+	};
+}
+const hyphenateRE = /\B([A-Z])/g, hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase()), camelizeRE = /-(\w)/g, camelize = cacheStringFunction((str) => {
+	return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+function getLifeCycleTarget(target) {
+	return target || getCurrentInstance();
+}
+function watchWithFilter(source, cb, options = {}) {
+	const { eventFilter = bypassFilter,...watchOptions } = options;
+	return watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
+}
+function watchPausable(source, cb, options = {}) {
+	const { eventFilter: filter, initialState = "active",...watchOptions } = options, { eventFilter, pause, resume, isActive } = pausableFilter(filter, { initialState }), stop = watchWithFilter(source, cb, {
+		...watchOptions,
+		eventFilter
+	});
+	return {
+		stop,
+		pause,
+		resume,
+		isActive
+	};
+}
+function tryOnMounted(fn, sync = true, target) {
+	const instance = getLifeCycleTarget(target);
+	if (instance) onMounted(fn, target);
+	else if (sync) fn();
+	else nextTick(fn);
+}
+function createUntil(r, isNot = false) {
+	function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
+		let stop = null;
+		const watcher = new Promise((resolve) => {
+			stop = watch(r, (v) => {
+				if (condition(v) !== isNot) {
+					if (stop) stop();
+					else nextTick(() => stop == null ? void 0 : stop());
+					resolve(v);
+				}
+			}, {
+				flush,
+				deep,
+				immediate: true
+			});
+		}), promises = [watcher];
+		if (timeout != null) promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => stop == null ? void 0 : stop()));
+		return Promise.race(promises);
+	}
+	function toBe(value, options) {
+		if (!isRef(value)) return toMatch((v) => v === value, options);
+		const { flush = "sync", deep = false, timeout, throwOnTimeout } = options != null ? options : {};
+		let stop = null;
+		const watcher = new Promise((resolve) => {
+			stop = watch([r, value], ([v1, v2]) => {
+				if (isNot !== (v1 === v2)) {
+					if (stop) stop();
+					else nextTick(() => stop == null ? void 0 : stop());
+					resolve(v1);
+				}
+			}, {
+				flush,
+				deep,
+				immediate: true
+			});
+		}), promises = [watcher];
+		if (timeout != null) promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => {
+			return stop?.(), toValue(r);
+		}));
+		return Promise.race(promises);
+	}
+	function toBeTruthy(options) {
+		return toMatch((v) => Boolean(v), options);
+	}
+	function toBeNull(options) {
+		return toBe(null, options);
+	}
+	function toBeUndefined(options) {
+		return toBe(void 0, options);
+	}
+	function toBeNaN(options) {
+		return toMatch(Number.isNaN, options);
+	}
+	function toContains(value, options) {
+		return toMatch((v) => {
+			const array = Array.from(v);
+			return array.includes(value) || array.includes(toValue(value));
+		}, options);
+	}
+	function changed(options) {
+		return changedTimes(1, options);
+	}
+	function changedTimes(n = 1, options) {
+		let count = -1;
+		return toMatch(() => {
+			return count += 1, count >= n;
+		}, options);
+	}
+	if (Array.isArray(toValue(r))) {
+		const instance = {
+			toMatch,
+			toContains,
+			changed,
+			changedTimes,
+			get not() {
+				return createUntil(r, !isNot);
+			}
+		};
+		return instance;
+	} else {
+		const instance = {
+			toMatch,
+			toBe,
+			toBeTruthy,
+			toBeNull,
+			toBeNaN,
+			toBeUndefined,
+			changed,
+			changedTimes,
+			get not() {
+				return createUntil(r, !isNot);
+			}
+		};
+		return instance;
+	}
+}
+function until(r) {
+	return createUntil(r);
+}
+function useTimeoutFn(cb, interval, options = {}) {
+	const { immediate = true, immediateCallback = false } = options, isPending = shallowRef(false);
+	let timer;
+	function clear() {
+		if (timer) clearTimeout(timer), timer = void 0;
+	}
+	function stop() {
+		isPending.value = false, clear();
+	}
+	function start(...args) {
+		if (immediateCallback) cb();
+		clear(), isPending.value = true, timer = setTimeout(() => {
+			isPending.value = false, timer = void 0, cb(...args);
+		}, toValue(interval));
+	}
+	if (immediate) {
+		if (isPending.value = true, isClient) start();
+	}
+	return tryOnScopeDispose(stop), {
+		isPending: shallowReadonly(isPending),
+		start,
+		stop
+	};
+}
+function watchImmediate(source, cb, options) {
+	return watch(source, cb, {
+		...options,
+		immediate: true
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function createReusableTemplate(options = {}) {
+	const { inheritAttrs = true } = options, render = shallowRef(), define = /* @__PURE__ */ defineComponent({ setup(_, { slots }) {
+		return () => {
+			render.value = slots.default;
+		};
+	} }), reuse = /* @__PURE__ */ defineComponent({
+		inheritAttrs,
+		props: options.props,
+		setup(props, { attrs, slots }) {
+			return () => {
+				var _a;
+				if (!render.value && false);
+				const vnode = (_a = render.value) == null ? void 0 : _a.call(render, {
+					...options.props == null ? keysToCamelKebabCase(attrs) : props,
+					$slots: slots
+				});
+				return inheritAttrs && (vnode == null ? void 0 : vnode.length) === 1 ? vnode[0] : vnode;
+			};
+		}
+	});
+	return /* @__PURE__ */ makeDestructurable({
+		define,
+		reuse
+	}, [define, reuse]);
+}
+function keysToCamelKebabCase(obj) {
+	const newObj = {};
+	for (const key in obj) newObj[camelize(key)] = obj[key];
+	return newObj;
+}
+const defaultWindow = isClient ? window : void 0, defaultDocument = isClient ? window.document : void 0, defaultNavigator = isClient ? window.navigator : void 0, defaultLocation = isClient ? window.location : void 0;
+function unrefElement(elRef) {
+	var _a;
+	const plain = toValue(elRef);
+	return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+}
+function useEventListener(...args) {
+	const cleanups = [], cleanup = () => {
+		cleanups.forEach((fn) => fn()), cleanups.length = 0;
+	}, register = (el, event, listener, options) => {
+		return el.addEventListener(event, listener, options), () => el.removeEventListener(event, listener, options);
+	}, firstParamTargets = computed(() => {
+		const test = toArray(toValue(args[0])).filter((e) => e != null);
+		return test.every((e) => typeof e !== "string") ? test : void 0;
+	}), stopWatch = watchImmediate(() => {
+		var _a, _b;
+		return [
+			(_b = (_a = firstParamTargets.value) == null ? void 0 : _a.map((e) => unrefElement(e))) != null ? _b : [defaultWindow].filter((e) => e != null),
+			toArray(toValue(firstParamTargets.value ? args[1] : args[0])),
+			toArray(unref(firstParamTargets.value ? args[2] : args[1])),
+			toValue(firstParamTargets.value ? args[3] : args[2])
+		];
+	}, ([raw_targets, raw_events, raw_listeners, raw_options]) => {
+		if (cleanup(), !(raw_targets == null ? void 0 : raw_targets.length) || !(raw_events == null ? void 0 : raw_events.length) || !(raw_listeners == null ? void 0 : raw_listeners.length)) return;
+		const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
+		cleanups.push(...raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone)))));
+	}, { flush: "post" }), stop = () => {
+		stopWatch(), cleanup();
+	};
+	return tryOnScopeDispose(cleanup), stop;
+}
+let _iOSWorkaround = false;
+function onClickOutside(target, handler, options = {}) {
+	const { window: window$1 = defaultWindow, ignore = [], capture = true, detectIframe = false, controls = false } = options;
+	if (!window$1) return controls ? {
+		stop: noop,
+		cancel: noop,
+		trigger: noop
+	} : noop;
+	if (isIOS && !_iOSWorkaround) {
+		_iOSWorkaround = true;
+		const listenerOptions = { passive: true };
+		Array.from(window$1.document.body.children).forEach((el) => el.addEventListener("click", noop, listenerOptions)), window$1.document.documentElement.addEventListener("click", noop, listenerOptions);
+	}
+	let shouldListen = true;
+	const shouldIgnore = (event) => {
+		return toValue(ignore).some((target2) => {
+			if (typeof target2 === "string") return Array.from(window$1.document.querySelectorAll(target2)).some((el) => el === event.target || event.composedPath().includes(el));
+			{
+				const el = unrefElement(target2);
+				return el && (event.target === el || event.composedPath().includes(el));
+			}
+		});
+	};
+	function hasMultipleRoots(target2) {
+		const vm = toValue(target2);
+		return vm && vm.$.subTree.shapeFlag === 16;
+	}
+	function checkMultipleRoots(target2, event) {
+		const vm = toValue(target2), children = vm.$.subTree && vm.$.subTree.children;
+		return children == null || !Array.isArray(children) ? false : children.some((child) => child.el === event.target || event.composedPath().includes(child.el));
+	}
+	const listener = (event) => {
+		const el = unrefElement(target);
+		if (event.target != null && !(!(el instanceof Element) && hasMultipleRoots(target) && checkMultipleRoots(target, event)) && !(!el || el === event.target || event.composedPath().includes(el))) {
+			if ("detail" in event && event.detail === 0) shouldListen = !shouldIgnore(event);
+			if (!shouldListen) {
+				shouldListen = true;
+				return;
+			}
+			handler(event);
+		}
+	};
+	let isProcessingClick = false;
+	const cleanup = [
+		useEventListener(window$1, "click", (event) => {
+			if (!isProcessingClick) isProcessingClick = true, setTimeout(() => {
+				isProcessingClick = false;
+			}, 0), listener(event);
+		}, {
+			passive: true,
+			capture
+		}),
+		useEventListener(window$1, "pointerdown", (e) => {
+			const el = unrefElement(target);
+			shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el));
+		}, { passive: true }),
+		detectIframe && useEventListener(window$1, "blur", (event) => {
+			setTimeout(() => {
+				var _a;
+				const el = unrefElement(target);
+				if (((_a = window$1.document.activeElement) == null ? void 0 : _a.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(window$1.document.activeElement))) handler(event);
+			}, 0);
+		}, { passive: true })
+	].filter(Boolean), stop = () => cleanup.forEach((fn) => fn());
+	return controls ? {
+		stop,
+		cancel: () => {
+			shouldListen = false;
+		},
+		trigger: (event) => {
+			shouldListen = true, listener(event), shouldListen = false;
+		}
+	} : stop;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function useMounted() {
+	const isMounted = shallowRef(false), instance = getCurrentInstance();
+	if (instance) onMounted(() => {
+		isMounted.value = true;
+	}, instance);
+	return isMounted;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function useSupported(callback) {
+	const isMounted = /* @__PURE__ */ useMounted();
+	return computed(() => {
+		return isMounted.value, Boolean(callback());
+	});
+}
+const ssrWidthSymbol = Symbol("vueuse-ssr-width");
+function cloneFnJSON(source) {
+	return JSON.parse(JSON.stringify(source));
+}
+const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {}, globalKey = "__vueuse_ssr_handlers__", handlers = /* @__PURE__ */ getHandlers();
+function getHandlers() {
+	if (!(globalKey in _global)) _global[globalKey] = _global[globalKey] || {};
+	return _global[globalKey];
+}
+function getSSRHandler(key, fallback) {
+	return handlers[key] || fallback;
+}
+function guessSerializerType(rawInit) {
+	return rawInit == null ? "any" : rawInit instanceof Set ? "set" : rawInit instanceof Map ? "map" : rawInit instanceof Date ? "date" : typeof rawInit === "boolean" ? "boolean" : typeof rawInit === "string" ? "string" : typeof rawInit === "object" ? "object" : !Number.isNaN(rawInit) ? "number" : "any";
+}
+const StorageSerializers = {
+	boolean: {
+		read: (v) => v === "true",
+		write: (v) => String(v)
+	},
+	object: {
+		read: (v) => JSON.parse(v),
+		write: (v) => JSON.stringify(v)
+	},
+	number: {
+		read: (v) => Number.parseFloat(v),
+		write: (v) => String(v)
+	},
+	any: {
+		read: (v) => v,
+		write: (v) => String(v)
+	},
+	string: {
+		read: (v) => v,
+		write: (v) => String(v)
+	},
+	map: {
+		read: (v) => new Map(JSON.parse(v)),
+		write: (v) => JSON.stringify(Array.from(v.entries()))
+	},
+	set: {
+		read: (v) => new Set(JSON.parse(v)),
+		write: (v) => JSON.stringify(Array.from(v))
+	},
+	date: {
+		read: (v) => new Date(v),
+		write: (v) => v.toISOString()
+	}
+}, customStorageEventName = "vueuse-storage";
+function useStorage(key, defaults, storage, options = {}) {
+	var _a;
+	const { flush = "pre", deep = true, listenToStorageChanges = true, writeDefaults = true, mergeDefaults = false, shallow, window: window$1 = defaultWindow, eventFilter, onError = (e) => {
+		console.error(e);
+	}, initOnMounted } = options, data = (shallow ? shallowRef : ref)(typeof defaults === "function" ? defaults() : defaults), keyComputed = computed(() => toValue(key));
+	if (!storage) try {
+		storage = getSSRHandler("getDefaultStorage", () => {
+			var _a2;
+			return (_a2 = defaultWindow) == null ? void 0 : _a2.localStorage;
+		})();
+	} catch (e) {
+		onError(e);
+	}
+	if (!storage) return data;
+	const rawInit = toValue(defaults), type = guessSerializerType(rawInit), serializer = (_a = options.serializer) != null ? _a : StorageSerializers[type], { pause: pauseWatch, resume: resumeWatch } = watchPausable(data, (newValue) => write(newValue), {
+		flush,
+		deep,
+		eventFilter
+	});
+	watch(keyComputed, () => update(), { flush });
+	let firstMounted = false;
+	const onStorageEvent = (ev) => {
+		initOnMounted && !firstMounted || update(ev);
+	}, onStorageCustomEvent = (ev) => {
+		initOnMounted && !firstMounted || updateFromCustomEvent(ev);
+	};
+	if (window$1 && listenToStorageChanges) if (storage instanceof Storage) useEventListener(window$1, "storage", onStorageEvent, { passive: true });
+	else useEventListener(window$1, customStorageEventName, onStorageCustomEvent);
+	if (initOnMounted) tryOnMounted(() => {
+		firstMounted = true, update();
+	});
+	else update();
+	function dispatchWriteEvent(oldValue, newValue) {
+		if (window$1) {
+			const payload = {
+				key: keyComputed.value,
+				oldValue,
+				newValue,
+				storageArea: storage
+			};
+			window$1.dispatchEvent(storage instanceof Storage ? new StorageEvent("storage", payload) : new CustomEvent(customStorageEventName, { detail: payload }));
+		}
+	}
+	function write(v) {
+		try {
+			const oldValue = storage.getItem(keyComputed.value);
+			if (v == null) dispatchWriteEvent(oldValue, null), storage.removeItem(keyComputed.value);
+			else {
+				const serialized = serializer.write(v);
+				if (oldValue !== serialized) storage.setItem(keyComputed.value, serialized), dispatchWriteEvent(oldValue, serialized);
+			}
+		} catch (e) {
+			onError(e);
+		}
+	}
+	function read(event) {
+		const rawValue = event ? event.newValue : storage.getItem(keyComputed.value);
+		if (rawValue == null) {
+			if (writeDefaults && rawInit != null) storage.setItem(keyComputed.value, serializer.write(rawInit));
+			return rawInit;
+		} else if (!event && mergeDefaults) {
+			const value = serializer.read(rawValue);
+			return typeof mergeDefaults === "function" ? mergeDefaults(value, rawInit) : type === "object" && !Array.isArray(value) ? {
+				...rawInit,
+				...value
+			} : value;
+		} else if (typeof rawValue !== "string") return rawValue;
+		else return serializer.read(rawValue);
+	}
+	function update(event) {
+		if (!(event && event.storageArea !== storage)) {
+			if (event && event.key == null) {
+				data.value = rawInit;
+				return;
+			}
+			if (!(event && event.key !== keyComputed.value)) {
+				pauseWatch();
+				try {
+					const serializedData = serializer.write(data.value);
+					if (event === void 0 || (event == null ? void 0 : event.newValue) !== serializedData) data.value = read(event);
+				} catch (e) {
+					onError(e);
+				} finally {
+					if (event) nextTick(resumeWatch);
+					else resumeWatch();
+				}
+			}
+		}
+	}
+	function updateFromCustomEvent(event) {
+		update(event.detail);
+	}
+	return data;
+}
+function useResizeObserver(target, callback, options = {}) {
+	const { window: window$1 = defaultWindow,...observerOptions } = options;
+	let observer;
+	const isSupported = /* @__PURE__ */ useSupported(() => window$1 && "ResizeObserver" in window$1), cleanup = () => {
+		if (observer) observer.disconnect(), observer = void 0;
+	}, targets = computed(() => {
+		const _targets = toValue(target);
+		return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
+	}), stopWatch = watch(targets, (els) => {
+		if (cleanup(), isSupported.value && window$1) {
+			observer = new ResizeObserver(callback);
+			for (const _el of els) if (_el) observer.observe(_el, observerOptions);
+		}
+	}, {
+		immediate: true,
+		flush: "post"
+	}), stop = () => {
+		cleanup(), stopWatch();
+	};
+	return tryOnScopeDispose(stop), {
+		isSupported,
+		stop
+	};
+}
+function useElementSize(target, initialSize = {
+	width: 0,
+	height: 0
+}, options = {}) {
+	const { window: window$1 = defaultWindow, box = "content-box" } = options, isSVG = computed(() => {
+		var _a, _b;
+		return (_b = (_a = unrefElement(target)) == null ? void 0 : _a.namespaceURI) == null ? void 0 : _b.includes("svg");
+	}), width = shallowRef(initialSize.width), height = shallowRef(initialSize.height), { stop: stop1 } = useResizeObserver(target, ([entry]) => {
+		const boxSize = box === "border-box" ? entry.borderBoxSize : box === "content-box" ? entry.contentBoxSize : entry.devicePixelContentBoxSize;
+		if (window$1 && isSVG.value) {
+			const $elem = unrefElement(target);
+			if ($elem) {
+				const rect = $elem.getBoundingClientRect();
+				width.value = rect.width, height.value = rect.height;
+			}
+		} else if (boxSize) {
+			const formatBoxSize = toArray(boxSize);
+			width.value = formatBoxSize.reduce((acc, { inlineSize }) => acc + inlineSize, 0), height.value = formatBoxSize.reduce((acc, { blockSize }) => acc + blockSize, 0);
+		} else width.value = entry.contentRect.width, height.value = entry.contentRect.height;
+	}, options);
+	tryOnMounted(() => {
+		const ele = unrefElement(target);
+		if (ele) width.value = "offsetWidth" in ele ? ele.offsetWidth : initialSize.width, height.value = "offsetHeight" in ele ? ele.offsetHeight : initialSize.height;
+	});
+	const stop2 = watch(() => unrefElement(target), (ele) => {
+		width.value = ele ? initialSize.width : 0, height.value = ele ? initialSize.height : 0;
+	});
+	function stop() {
+		stop1(), stop2();
+	}
+	return {
+		width,
+		height,
+		stop
+	};
+}
+const payloadMapping = {
+	json: "application/json",
+	text: "text/plain"
+};
+function isFetchOptions(obj) {
+	return obj && containsProp(obj, "immediate", "refetch", "initialData", "timeout", "beforeFetch", "afterFetch", "onFetchError", "fetch", "updateDataOnError");
+}
+function headersToObject(headers) {
+	return typeof Headers !== "undefined" && headers instanceof Headers ? Object.fromEntries(headers.entries()) : headers;
+}
+function useFetch(url, ...args) {
+	var _a, _b;
+	const supportsAbort = typeof AbortController === "function";
+	let fetchOptions = {}, options = {
+		immediate: true,
+		refetch: false,
+		timeout: 0,
+		updateDataOnError: false
+	};
+	const config = {
+		method: "GET",
+		type: "text",
+		payload: void 0
+	};
+	if (args.length > 0) if (isFetchOptions(args[0])) options = {
+		...options,
+		...args[0]
+	};
+	else fetchOptions = args[0];
+	if (args.length > 1) {
+		if (isFetchOptions(args[1])) options = {
+			...options,
+			...args[1]
+		};
+	}
+	const { fetch = (_b = (_a = defaultWindow) == null ? void 0 : _a.fetch) != null ? _b : globalThis == null ? void 0 : globalThis.fetch, initialData, timeout } = options, responseEvent = /* @__PURE__ */ createEventHook(), errorEvent = /* @__PURE__ */ createEventHook(), finallyEvent = /* @__PURE__ */ createEventHook(), isFinished = shallowRef(false), isFetching = shallowRef(false), aborted = shallowRef(false), statusCode = shallowRef(null), response = shallowRef(null), error = shallowRef(null), data = shallowRef(initialData || null), canAbort = computed(() => supportsAbort && isFetching.value);
+	let controller, timer;
+	const abort = (reason) => {
+		if (supportsAbort) controller?.abort(reason), controller = new AbortController(), controller.signal.onabort = () => aborted.value = true, fetchOptions = {
+			...fetchOptions,
+			signal: controller.signal
+		};
+	}, loading = (isLoading) => {
+		isFetching.value = isLoading, isFinished.value = !isLoading;
+	};
+	if (timeout) timer = useTimeoutFn(abort, timeout, { immediate: false });
+	let executeCounter = 0;
+	const execute = async (throwOnFailed = false) => {
+		var _a2, _b2;
+		abort(), loading(true), error.value = null, statusCode.value = null, aborted.value = false, executeCounter += 1;
+		const currentExecuteCounter = executeCounter, defaultFetchOptions = {
+			method: config.method,
+			headers: {}
+		}, payload = toValue(config.payload);
+		if (payload) {
+			const headers = headersToObject(defaultFetchOptions.headers), proto = Object.getPrototypeOf(payload);
+			if (!config.payloadType && payload && (proto === Object.prototype || Array.isArray(proto)) && !(payload instanceof FormData)) config.payloadType = "json";
+			if (config.payloadType) headers["Content-Type"] = (_a2 = payloadMapping[config.payloadType]) != null ? _a2 : config.payloadType;
+			defaultFetchOptions.body = config.payloadType === "json" ? JSON.stringify(payload) : payload;
+		}
+		let isCanceled = false;
+		const context = {
+			url: toValue(url),
+			options: {
+				...defaultFetchOptions,
+				...fetchOptions
+			},
+			cancel: () => {
+				isCanceled = true;
+			}
+		};
+		if (options.beforeFetch) Object.assign(context, await options.beforeFetch(context));
+		if (isCanceled || !fetch) return loading(false), Promise.resolve(null);
+		let responseData = null;
+		if (timer) timer.start();
+		return fetch(context.url, {
+			...defaultFetchOptions,
+			...context.options,
+			headers: {
+				...headersToObject(defaultFetchOptions.headers),
+				...headersToObject((_b2 = context.options) == null ? void 0 : _b2.headers)
+			}
+		}).then(async (fetchResponse) => {
+			if (response.value = fetchResponse, statusCode.value = fetchResponse.status, responseData = await fetchResponse.clone()[config.type](), !fetchResponse.ok) throw data.value = initialData || null, new Error(fetchResponse.statusText);
+			if (options.afterFetch) ({data: responseData} = await options.afterFetch({
+				data: responseData,
+				response: fetchResponse,
+				context,
+				execute
+			}));
+			return data.value = responseData, responseEvent.trigger(fetchResponse), fetchResponse;
+		}).catch(async (fetchError) => {
+			let errorData = fetchError.message || fetchError.name;
+			if (options.onFetchError) ({error: errorData, data: responseData} = await options.onFetchError({
+				data: responseData,
+				error: fetchError,
+				response: response.value,
+				context,
+				execute
+			}));
+			if (error.value = errorData, options.updateDataOnError) data.value = responseData;
+			if (errorEvent.trigger(fetchError), throwOnFailed) throw fetchError;
+			return null;
+		}).finally(() => {
+			if (currentExecuteCounter === executeCounter) loading(false);
+			if (timer) timer.stop();
+			finallyEvent.trigger(null);
+		});
+	}, refetch = toRef$1(options.refetch);
+	watch([refetch, toRef$1(url)], ([refetch2]) => refetch2 && execute(), { deep: true });
+	const shell = {
+		isFinished: readonly(isFinished),
+		isFetching: readonly(isFetching),
+		statusCode,
+		response,
+		error,
+		data,
+		canAbort,
+		aborted,
+		abort,
+		execute,
+		onFetchResponse: responseEvent.on,
+		onFetchError: errorEvent.on,
+		onFetchFinally: finallyEvent.on,
+		get: setMethod("GET"),
+		put: setMethod("PUT"),
+		post: setMethod("POST"),
+		delete: setMethod("DELETE"),
+		patch: setMethod("PATCH"),
+		head: setMethod("HEAD"),
+		options: setMethod("OPTIONS"),
+		json: setType("json"),
+		text: setType("text"),
+		blob: setType("blob"),
+		arrayBuffer: setType("arrayBuffer"),
+		formData: setType("formData")
+	};
+	function setMethod(method) {
+		return (payload, payloadType) => {
+			if (!isFetching.value) {
+				if (config.method = method, config.payload = payload, config.payloadType = payloadType, isRef(config.payload)) watch([refetch, toRef$1(config.payload)], ([refetch2]) => refetch2 && execute(), { deep: true });
+				return {
+					...shell,
+					then(onFulfilled, onRejected) {
+						return waitUntilFinished().then(onFulfilled, onRejected);
+					}
+				};
+			}
+			return void 0;
+		};
+	}
+	function waitUntilFinished() {
+		return new Promise((resolve, reject) => {
+			until(isFinished).toBe(true).then(() => resolve(shell)).catch(reject);
+		});
+	}
+	function setType(type) {
+		return () => {
+			return isFetching.value ? void 0 : (config.type = type, {
+				...shell,
+				then(onFulfilled, onRejected) {
+					return waitUntilFinished().then(onFulfilled, onRejected);
+				}
+			});
+		};
+	}
+	if (options.immediate) Promise.resolve().then(() => execute());
+	return {
+		...shell,
+		then(onFulfilled, onRejected) {
+			return waitUntilFinished().then(onFulfilled, onRejected);
+		}
+	};
+}
+function useLocalStorage(key, initialValue, options = {}) {
+	const { window: window$1 = defaultWindow } = options;
+	return useStorage(key, initialValue, window$1 == null ? void 0 : window$1.localStorage, options);
+}
+const DEFAULT_UNITS = [
+	{
+		max: 6e4,
+		value: 1e3,
+		name: "second"
+	},
+	{
+		max: 276e4,
+		value: 6e4,
+		name: "minute"
+	},
+	{
+		max: 72e6,
+		value: 36e5,
+		name: "hour"
+	},
+	{
+		max: 5184e5,
+		value: 864e5,
+		name: "day"
+	},
+	{
+		max: 24192e5,
+		value: 6048e5,
+		name: "week"
+	},
+	{
+		max: 28512e6,
+		value: 2592e6,
+		name: "month"
+	},
+	{
+		max: Number.POSITIVE_INFINITY,
+		value: 31536e6,
+		name: "year"
+	}
+];
+/* @__NO_SIDE_EFFECTS__ */
+function useVModel(props, key, emit, options = {}) {
+	var _a, _b, _c;
+	const { clone = false, passive = false, eventName, deep = false, defaultValue, shouldEmit } = options, vm = getCurrentInstance(), _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a.bind(vm)) || ((_c = (_b = vm == null ? void 0 : vm.proxy) == null ? void 0 : _b.$emit) == null ? void 0 : _c.bind(vm == null ? void 0 : vm.proxy));
+	let event = eventName;
+	if (!key) key = "modelValue";
+	event = event || `update:${key.toString()}`;
+	const cloneFn = (val) => !clone ? val : typeof clone === "function" ? clone(val) : cloneFnJSON(val), getValue = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue, triggerEmit = (value) => {
+		if (shouldEmit) {
+			if (shouldEmit(value)) _emit(event, value);
+		} else _emit(event, value);
+	};
+	if (passive) {
+		const initialValue = getValue(), proxy = ref(initialValue);
+		let isUpdating = false;
+		return watch(() => props[key], (v) => {
+			if (!isUpdating) isUpdating = true, proxy.value = cloneFn(v), nextTick(() => isUpdating = false);
+		}), watch(proxy, (v) => {
+			if (!isUpdating && (v !== props[key] || deep)) triggerEmit(v);
+		}, { deep }), proxy;
+	} else return computed({
+		get() {
+			return getValue();
+		},
+		set(value) {
+			triggerEmit(value);
+		}
+	});
+}
+const API_ROOT = "/__pubinfo_devtools_api", infoFetch = useFetch(`${API_ROOT}`).json(), apiListFetch = useFetch(`${API_ROOT}/api-list`, { immediate: false }).json();
+export { apiListFetch as b, infoFetch as c, createReusableTemplate as d, onClickOutside as e, useElementSize as f, useLocalStorage as g, useVModel as h, createSharedComposable as i };