@pubinfo-pr/devtools 0.171.2 → 0.171.3

package/dist/client/assets/fetch-X85SI-zj.js

@@ -0,0 +1,1112 @@
+import { $ as toValue, D as onMounted, G as onScopeDispose, H as effectScope, J as ref, L as watch, O as openBlock, Q as toRef$1, T as nextTick, U as getCurrentScope, V as customRef, W as isRef, X as shallowRef, Y as shallowReadonly, Z as toRaw, b as getCurrentInstance, d as computed, et as unref, h as createElementBlock, j as renderSlot, q as readonly, y as defineComponent } from "./index-C74Jw2V-.js";
+function tryOnScopeDispose(fn, failSilently) {
+	if (getCurrentScope()) {
+		onScopeDispose(fn, failSilently);
+		return true;
+	}
+	return false;
+}
+function createEventHook() {
+	const fns = /* @__PURE__ */ new Set();
+	const off = (fn) => {
+		fns.delete(fn);
+	};
+	const clear = () => {
+		fns.clear();
+	};
+	const on = (fn) => {
+		fns.add(fn);
+		const offFn = () => off(fn);
+		tryOnScopeDispose(offFn);
+		return { off: offFn };
+	};
+	const trigger = (...args) => {
+		return Promise.all(Array.from(fns).map((fn) => fn(...args)));
+	};
+	return {
+		on,
+		off,
+		trigger,
+		clear
+	};
+}
+var isClient = typeof window !== "undefined" && typeof document !== "undefined";
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+var isDef = (val) => typeof val !== "undefined";
+var toString = Object.prototype.toString;
+var isObject = (val) => toString.call(val) === "[object Object]";
+var noop = () => {};
+var isIOS = /* @__PURE__ */ getIsIOS();
+function getIsIOS() {
+	var _window, _window2, _window3;
+	return isClient && !!((_window = window) === null || _window === void 0 || (_window = _window.navigator) === null || _window === void 0 ? void 0 : _window.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_window2 = window) === null || _window2 === void 0 || (_window2 = _window2.navigator) === null || _window2 === void 0 ? void 0 : _window2.maxTouchPoints) > 2 && /iPad|Macintosh/.test((_window3 = window) === null || _window3 === void 0 ? void 0 : _window3.navigator.userAgent));
+}
+function toRef(...args) {
+	if (args.length !== 1) return toRef$1(...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;
+}
+var bypassFilter = (invoke$1) => {
+	return invoke$1();
+};
+function pausableFilter(extendFilter = bypassFilter, options = {}) {
+	const { initialState = "active" } = options;
+	const isActive = toRef(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 createSingletonPromise(fn) {
+	let _promise;
+	function wrapper() {
+		if (!_promise) _promise = fn();
+		return _promise;
+	}
+	wrapper.reset = async () => {
+		const _prev = _promise;
+		_promise = void 0;
+		if (_prev) await _prev;
+	};
+	return wrapper;
+}
+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 = Object.create(null);
+	return ((str) => {
+		return cache[str] || (cache[str] = fn(str));
+	});
+}
+var hyphenateRE = /\B([A-Z])/g;
+cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+var camelizeRE = /-(\w)/g;
+var camelize = cacheStringFunction((str) => {
+	return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+});
+function getLifeCycleTarget(target) {
+	return target || getCurrentInstance();
+}
+function createSharedComposable(composable) {
+	if (!isClient) return composable;
+	let subscribers = 0;
+	let state;
+	let scope;
+	const dispose = () => {
+		subscribers -= 1;
+		if (scope && subscribers <= 0) {
+			scope.stop();
+			state = void 0;
+			scope = void 0;
+		}
+	};
+	return ((...args) => {
+		subscribers += 1;
+		if (!scope) {
+			scope = effectScope(true);
+			state = scope.run(() => composable(...args));
+		}
+		tryOnScopeDispose(dispose);
+		return state;
+	});
+}
+/* @__NO_SIDE_EFFECTS__ */
+function makeDestructurable(obj, arr) {
+	if (typeof Symbol !== "undefined") {
+		const clone = { ...obj };
+		Object.defineProperty(clone, Symbol.iterator, {
+			enumerable: false,
+			value() {
+				let index = 0;
+				return { next: () => ({
+					value: arr[index++],
+					done: index > arr.length
+				}) };
+			}
+		});
+		return clone;
+	} else return Object.assign([...arr], obj);
+}
+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;
+	const { eventFilter, pause, resume, isActive } = pausableFilter(filter, { initialState });
+	return {
+		stop: watchWithFilter(source, cb, {
+			...watchOptions,
+			eventFilter
+		}),
+		pause,
+		resume,
+		isActive
+	};
+}
+var pausableWatch = watchPausable;
+function tryOnMounted(fn, sync = true, target) {
+	if (getLifeCycleTarget(target)) 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 promises = [new Promise((resolve) => {
+			stop = watch(r, (v) => {
+				if (condition(v) !== isNot) {
+					if (stop) stop();
+					else nextTick(() => stop === null || stop === void 0 ? void 0 : stop());
+					resolve(v);
+				}
+			}, {
+				flush,
+				deep,
+				immediate: true
+			});
+		})];
+		if (timeout != null) promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => stop === null || stop === void 0 ? 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 !== void 0 ? options : {};
+		let stop = null;
+		const promises = [new Promise((resolve) => {
+			stop = watch([r, value], ([v1, v2]) => {
+				if (isNot !== (v1 === v2)) {
+					if (stop) stop();
+					else nextTick(() => stop === null || stop === void 0 ? void 0 : stop());
+					resolve(v1);
+				}
+			}, {
+				flush,
+				deep,
+				immediate: true
+			});
+		})];
+		if (timeout != null) promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => {
+			stop === null || stop === void 0 || stop();
+			return 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(() => {
+			count += 1;
+			return count >= n;
+		}, options);
+	}
+	if (Array.isArray(toValue(r))) return {
+		toMatch,
+		toContains,
+		changed,
+		changedTimes,
+		get not() {
+			return createUntil(r, !isNot);
+		}
+	};
+	else return {
+		toMatch,
+		toBe,
+		toBeTruthy,
+		toBeNull,
+		toBeNaN,
+		toBeUndefined,
+		changed,
+		changedTimes,
+		get not() {
+			return createUntil(r, !isNot);
+		}
+	};
+}
+function until(r) {
+	return createUntil(r);
+}
+function useTimeoutFn(cb, interval, options = {}) {
+	const { immediate = true, immediateCallback = false } = options;
+	const 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) {
+		isPending.value = true;
+		if (isClient) start();
+	}
+	tryOnScopeDispose(stop);
+	return {
+		isPending: shallowReadonly(isPending),
+		start,
+		stop
+	};
+}
+function watchImmediate(source, cb, options) {
+	return watch(source, cb, {
+		...options,
+		immediate: true
+	});
+}
+function createReusableTemplate(options = {}) {
+	const { inheritAttrs = true } = options;
+	const render = shallowRef();
+	const define = defineComponent({ setup(_, { slots }) {
+		return () => {
+			render.value = slots.default;
+		};
+	} });
+	const reuse = defineComponent({
+		inheritAttrs,
+		props: options.props,
+		setup(props, { attrs, slots }) {
+			return () => {
+				var _render$value;
+				if (!render.value && true) throw new Error("[VueUse] Failed to find the definition of reusable template");
+				const vnode = (_render$value = render.value) === null || _render$value === void 0 ? void 0 : _render$value.call(render, {
+					...options.props == null ? keysToCamelKebabCase(attrs) : props,
+					$slots: slots
+				});
+				return inheritAttrs && (vnode === null || vnode === void 0 ? 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;
+}
+var defaultWindow = isClient ? window : void 0;
+isClient && window.document;
+var defaultNavigator = isClient ? window.navigator : void 0;
+isClient && window.location;
+function unrefElement(elRef) {
+	var _$el;
+	const plain = toValue(elRef);
+	return (_$el = plain === null || plain === void 0 ? void 0 : plain.$el) !== null && _$el !== void 0 ? _$el : plain;
+}
+function useEventListener(...args) {
+	const register = (el, event, listener, options) => {
+		el.addEventListener(event, listener, options);
+		return () => el.removeEventListener(event, listener, options);
+	};
+	const firstParamTargets = computed(() => {
+		const test = toArray(toValue(args[0])).filter((e) => e != null);
+		return test.every((e) => typeof e !== "string") ? test : void 0;
+	});
+	return watchImmediate(() => {
+		var _firstParamTargets$va, _firstParamTargets$va2;
+		return [
+			(_firstParamTargets$va = (_firstParamTargets$va2 = firstParamTargets.value) === null || _firstParamTargets$va2 === void 0 ? void 0 : _firstParamTargets$va2.map((e) => unrefElement(e))) !== null && _firstParamTargets$va !== void 0 ? _firstParamTargets$va : [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], _, onCleanup) => {
+		if (!(raw_targets === null || raw_targets === void 0 ? void 0 : raw_targets.length) || !(raw_events === null || raw_events === void 0 ? void 0 : raw_events.length) || !(raw_listeners === null || raw_listeners === void 0 ? void 0 : raw_listeners.length)) return;
+		const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
+		const cleanups = raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))));
+		onCleanup(() => {
+			cleanups.forEach((fn) => fn());
+		});
+	}, { flush: "post" });
+}
+var _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((target$1) => {
+			if (typeof target$1 === "string") return Array.from(window$1.document.querySelectorAll(target$1)).some((el) => el === event.target || event.composedPath().includes(el));
+			else {
+				const el = unrefElement(target$1);
+				return el && (event.target === el || event.composedPath().includes(el));
+			}
+		});
+	};
+	function hasMultipleRoots(target$1) {
+		const vm = toValue(target$1);
+		return vm && vm.$.subTree.shapeFlag === 16;
+	}
+	function checkMultipleRoots(target$1, event) {
+		const vm = toValue(target$1);
+		const children = vm.$.subTree && vm.$.subTree.children;
+		if (children == null || !Array.isArray(children)) return false;
+		return children.some((child) => child.el === event.target || event.composedPath().includes(child.el));
+	}
+	const listener = (event) => {
+		const el = unrefElement(target);
+		if (event.target == null) return;
+		if (!(el instanceof Element) && hasMultipleRoots(target) && checkMultipleRoots(target, event)) return;
+		if (!el || el === event.target || event.composedPath().includes(el)) return;
+		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 _window$document$acti;
+				const el = unrefElement(target);
+				if (((_window$document$acti = window$1.document.activeElement) === null || _window$document$acti === void 0 ? void 0 : _window$document$acti.tagName) === "IFRAME" && !(el === null || el === void 0 ? void 0 : el.contains(window$1.document.activeElement))) handler(event);
+			}, 0);
+		}, { passive: true })
+	].filter(Boolean);
+	const stop = () => cleanup.forEach((fn) => fn());
+	if (controls) return {
+		stop,
+		cancel: () => {
+			shouldListen = false;
+		},
+		trigger: (event) => {
+			shouldListen = true;
+			listener(event);
+			shouldListen = false;
+		}
+	};
+	return stop;
+}
+function useMounted() {
+	const isMounted = shallowRef(false);
+	const instance = getCurrentInstance();
+	if (instance) onMounted(() => {
+		isMounted.value = true;
+	}, instance);
+	return isMounted;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function useSupported(callback) {
+	const isMounted = useMounted();
+	return computed(() => {
+		isMounted.value;
+		return Boolean(callback());
+	});
+}
+function usePermission(permissionDesc, options = {}) {
+	const { controls = false, navigator: navigator$1 = defaultNavigator } = options;
+	const isSupported = /* @__PURE__ */ useSupported(() => navigator$1 && "permissions" in navigator$1);
+	const permissionStatus = shallowRef();
+	const desc = typeof permissionDesc === "string" ? { name: permissionDesc } : permissionDesc;
+	const state = shallowRef();
+	const update = () => {
+		var _permissionStatus$val, _permissionStatus$val2;
+		state.value = (_permissionStatus$val = (_permissionStatus$val2 = permissionStatus.value) === null || _permissionStatus$val2 === void 0 ? void 0 : _permissionStatus$val2.state) !== null && _permissionStatus$val !== void 0 ? _permissionStatus$val : "prompt";
+	};
+	useEventListener(permissionStatus, "change", update, { passive: true });
+	const query = createSingletonPromise(async () => {
+		if (!isSupported.value) return;
+		if (!permissionStatus.value) try {
+			permissionStatus.value = await navigator$1.permissions.query(desc);
+		} catch (_unused) {
+			permissionStatus.value = void 0;
+		} finally {
+			update();
+		}
+		if (controls) return toRaw(permissionStatus.value);
+	});
+	query();
+	if (controls) return {
+		state,
+		isSupported,
+		query
+	};
+	else return state;
+}
+function useClipboard(options = {}) {
+	const { navigator: navigator$1 = defaultNavigator, read = false, source, copiedDuring = 1500, legacy = false } = options;
+	const isClipboardApiSupported = /* @__PURE__ */ useSupported(() => navigator$1 && "clipboard" in navigator$1);
+	const permissionRead = usePermission("clipboard-read");
+	const permissionWrite = usePermission("clipboard-write");
+	const isSupported = computed(() => isClipboardApiSupported.value || legacy);
+	const text = shallowRef("");
+	const copied = shallowRef(false);
+	const timeout = useTimeoutFn(() => copied.value = false, copiedDuring, { immediate: false });
+	async function updateText() {
+		let useLegacy = !(isClipboardApiSupported.value && isAllowed(permissionRead.value));
+		if (!useLegacy) try {
+			text.value = await navigator$1.clipboard.readText();
+		} catch (_unused) {
+			useLegacy = true;
+		}
+		if (useLegacy) text.value = legacyRead();
+	}
+	if (isSupported.value && read) useEventListener(["copy", "cut"], updateText, { passive: true });
+	async function copy(value = toValue(source)) {
+		if (isSupported.value && value != null) {
+			let useLegacy = !(isClipboardApiSupported.value && isAllowed(permissionWrite.value));
+			if (!useLegacy) try {
+				await navigator$1.clipboard.writeText(value);
+			} catch (_unused2) {
+				useLegacy = true;
+			}
+			if (useLegacy) legacyCopy(value);
+			text.value = value;
+			copied.value = true;
+			timeout.start();
+		}
+	}
+	function legacyCopy(value) {
+		const ta = document.createElement("textarea");
+		ta.value = value;
+		ta.style.position = "absolute";
+		ta.style.opacity = "0";
+		ta.setAttribute("readonly", "");
+		document.body.appendChild(ta);
+		ta.select();
+		document.execCommand("copy");
+		ta.remove();
+	}
+	function legacyRead() {
+		var _document$getSelectio, _document, _document$getSelectio2;
+		return (_document$getSelectio = (_document = document) === null || _document === void 0 || (_document$getSelectio2 = _document.getSelection) === null || _document$getSelectio2 === void 0 || (_document$getSelectio2 = _document$getSelectio2.call(_document)) === null || _document$getSelectio2 === void 0 ? void 0 : _document$getSelectio2.toString()) !== null && _document$getSelectio !== void 0 ? _document$getSelectio : "";
+	}
+	function isAllowed(status) {
+		return status === "granted" || status === "prompt";
+	}
+	return {
+		isSupported,
+		text: readonly(text),
+		copied: readonly(copied),
+		copy
+	};
+}
+function cloneFnJSON(source) {
+	return JSON.parse(JSON.stringify(source));
+}
+var _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+var globalKey = "__vueuse_ssr_handlers__";
+var 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";
+}
+var 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()
+	}
+};
+var customStorageEventName = "vueuse-storage";
+function useStorage(key, defaults$1, storage, options = {}) {
+	var _options$serializer;
+	const { flush = "pre", deep = true, listenToStorageChanges = true, writeDefaults = true, mergeDefaults = false, shallow, window: window$1 = defaultWindow, eventFilter, onError = (e) => {
+		console.error(e);
+	}, initOnMounted } = options;
+	const data = (shallow ? shallowRef : ref)(typeof defaults$1 === "function" ? defaults$1() : defaults$1);
+	const keyComputed = computed(() => toValue(key));
+	if (!storage) try {
+		storage = getSSRHandler("getDefaultStorage", () => defaultWindow === null || defaultWindow === void 0 ? void 0 : defaultWindow.localStorage)();
+	} catch (e) {
+		onError(e);
+	}
+	if (!storage) return data;
+	const rawInit = toValue(defaults$1);
+	const type = guessSerializerType(rawInit);
+	const serializer = (_options$serializer = options.serializer) !== null && _options$serializer !== void 0 ? _options$serializer : StorageSerializers[type];
+	const { pause: pauseWatch, resume: resumeWatch } = pausableWatch(data, (newValue) => write(newValue), {
+		flush,
+		deep,
+		eventFilter
+	});
+	watch(keyComputed, () => update(), { flush });
+	let firstMounted = false;
+	const onStorageEvent = (ev) => {
+		if (initOnMounted && !firstMounted) return;
+		update(ev);
+	};
+	const onStorageCustomEvent = (ev) => {
+		if (initOnMounted && !firstMounted) return;
+		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);
+			if (typeof mergeDefaults === "function") return mergeDefaults(value, rawInit);
+			else if (type === "object" && !Array.isArray(value)) return {
+				...rawInit,
+				...value
+			};
+			return value;
+		} else if (typeof rawValue !== "string") return rawValue;
+		else return serializer.read(rawValue);
+	}
+	function update(event) {
+		if (event && event.storageArea !== storage) return;
+		if (event && event.key == null) {
+			data.value = rawInit;
+			return;
+		}
+		if (event && event.key !== keyComputed.value) return;
+		pauseWatch();
+		try {
+			const serializedData = serializer.write(data.value);
+			if (event === void 0 || (event === null || event === void 0 ? 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);
+	const cleanup = () => {
+		if (observer) {
+			observer.disconnect();
+			observer = void 0;
+		}
+	};
+	const stopWatch = watch(computed(() => {
+		const _targets = toValue(target);
+		return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
+	}), (els) => {
+		cleanup();
+		if (isSupported.value && window$1) {
+			observer = new ResizeObserver(callback);
+			for (const _el of els) if (_el) observer.observe(_el, observerOptions);
+		}
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	const stop = () => {
+		cleanup();
+		stopWatch();
+	};
+	tryOnScopeDispose(stop);
+	return {
+		isSupported,
+		stop
+	};
+}
+function useElementSize(target, initialSize = {
+	width: 0,
+	height: 0
+}, options = {}) {
+	const { window: window$1 = defaultWindow, box = "content-box" } = options;
+	const isSVG = computed(() => {
+		var _unrefElement;
+		return (_unrefElement = unrefElement(target)) === null || _unrefElement === void 0 || (_unrefElement = _unrefElement.namespaceURI) === null || _unrefElement === void 0 ? void 0 : _unrefElement.includes("svg");
+	});
+	const width = shallowRef(initialSize.width);
+	const height = shallowRef(initialSize.height);
+	const { 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
+	};
+}
+var 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) {
+	if (typeof Headers !== "undefined" && headers instanceof Headers) return Object.fromEntries(headers.entries());
+	return headers;
+}
+function useFetch(url, ...args) {
+	var _defaultWindow$fetch, _globalThis;
+	const supportsAbort = typeof AbortController === "function";
+	let fetchOptions = {};
+	let 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 = (_defaultWindow$fetch = defaultWindow === null || defaultWindow === void 0 ? void 0 : defaultWindow.fetch) !== null && _defaultWindow$fetch !== void 0 ? _defaultWindow$fetch : (_globalThis = globalThis) === null || _globalThis === void 0 ? void 0 : _globalThis.fetch, initialData, timeout } = options;
+	const responseEvent = createEventHook();
+	const errorEvent = createEventHook();
+	const finallyEvent = createEventHook();
+	const isFinished = shallowRef(false);
+	const isFetching = shallowRef(false);
+	const aborted = shallowRef(false);
+	const statusCode = shallowRef(null);
+	const response = shallowRef(null);
+	const error = shallowRef(null);
+	const data = shallowRef(initialData || null);
+	const canAbort = computed(() => supportsAbort && isFetching.value);
+	let controller;
+	let timer;
+	const abort = (reason) => {
+		if (supportsAbort) {
+			controller === null || controller === void 0 || controller.abort(reason);
+			controller = new AbortController();
+			controller.signal.onabort = () => aborted.value = true;
+			fetchOptions = {
+				...fetchOptions,
+				signal: controller.signal
+			};
+		}
+	};
+	const 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 _context$options;
+		abort();
+		loading(true);
+		error.value = null;
+		statusCode.value = null;
+		aborted.value = false;
+		executeCounter += 1;
+		const currentExecuteCounter = executeCounter;
+		const defaultFetchOptions = {
+			method: config.method,
+			headers: {}
+		};
+		const payload = toValue(config.payload);
+		if (payload) {
+			var _payloadMapping$confi;
+			const headers = headersToObject(defaultFetchOptions.headers);
+			const 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"] = (_payloadMapping$confi = payloadMapping[config.payloadType]) !== null && _payloadMapping$confi !== void 0 ? _payloadMapping$confi : 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) {
+			loading(false);
+			return Promise.resolve(null);
+		}
+		let responseData = null;
+		if (timer) timer.start();
+		return fetch(context.url, {
+			...defaultFetchOptions,
+			...context.options,
+			headers: {
+				...headersToObject(defaultFetchOptions.headers),
+				...headersToObject((_context$options = context.options) === null || _context$options === void 0 ? void 0 : _context$options.headers)
+			}
+		}).then(async (fetchResponse) => {
+			response.value = fetchResponse;
+			statusCode.value = fetchResponse.status;
+			responseData = await fetchResponse.clone()[config.type]();
+			if (!fetchResponse.ok) {
+				data.value = initialData || null;
+				throw new Error(fetchResponse.statusText);
+			}
+			if (options.afterFetch) ({data: responseData} = await options.afterFetch({
+				data: responseData,
+				response: fetchResponse,
+				context,
+				execute
+			}));
+			data.value = responseData;
+			responseEvent.trigger(fetchResponse);
+			return 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
+			}));
+			error.value = errorData;
+			if (options.updateDataOnError) data.value = responseData;
+			errorEvent.trigger(fetchError);
+			if (throwOnFailed) throw fetchError;
+			return null;
+		}).finally(() => {
+			if (currentExecuteCounter === executeCounter) loading(false);
+			if (timer) timer.stop();
+			finallyEvent.trigger(null);
+		});
+	};
+	const refetch = toRef(options.refetch);
+	watch([refetch, toRef(url)], ([refetch$1]) => refetch$1 && 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) {
+				config.method = method;
+				config.payload = payload;
+				config.payloadType = payloadType;
+				if (isRef(config.payload)) watch([refetch, toRef(config.payload)], ([refetch$1]) => refetch$1 && execute(), { deep: true });
+				return {
+					...shell,
+					then(onFulfilled, onRejected) {
+						return waitUntilFinished().then(onFulfilled, onRejected);
+					}
+				};
+			}
+		};
+	}
+	function waitUntilFinished() {
+		return new Promise((resolve, reject) => {
+			until(isFinished).toBe(true).then(() => resolve(shell)).catch(reject);
+		});
+	}
+	function setType(type) {
+		return () => {
+			if (!isFetching.value) {
+				config.type = type;
+				return {
+					...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 || window$1 === void 0 ? void 0 : window$1.localStorage, options);
+}
+Number.POSITIVE_INFINITY;
+function useVModel(props, key, emit, options = {}) {
+	var _vm$$emit, _vm$proxy;
+	const { clone = false, passive = false, eventName, deep = false, defaultValue, shouldEmit } = options;
+	const vm = getCurrentInstance();
+	const _emit = emit || (vm === null || vm === void 0 ? void 0 : vm.emit) || (vm === null || vm === void 0 || (_vm$$emit = vm.$emit) === null || _vm$$emit === void 0 ? void 0 : _vm$$emit.bind(vm)) || (vm === null || vm === void 0 || (_vm$proxy = vm.proxy) === null || _vm$proxy === void 0 || (_vm$proxy = _vm$proxy.$emit) === null || _vm$proxy === void 0 ? void 0 : _vm$proxy.bind(vm === null || vm === void 0 ? 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);
+	const getValue$1 = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue;
+	const triggerEmit = (value) => {
+		if (shouldEmit) {
+			if (shouldEmit(value)) _emit(event, value);
+		} else _emit(event, value);
+	};
+	if (passive) {
+		const proxy = ref(getValue$1());
+		let isUpdating = false;
+		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 });
+		return proxy;
+	} else return computed({
+		get() {
+			return getValue$1();
+		},
+		set(value) {
+			triggerEmit(value);
+		}
+	});
+}
+var _plugin_vue_export_helper_default = (sfc, props) => {
+	const target = sfc.__vccOpts || sfc;
+	for (const [key, val] of props) target[key] = val;
+	return target;
+};
+var _hoisted_1 = { class: "n-badge" };
+var Badge_default = /* @__PURE__ */ defineComponent({
+	name: "Badge",
+	__name: "Badge",
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", _hoisted_1, [renderSlot(_ctx.$slots, "default")]);
+		};
+	}
+});
+var API_ROOT = "/__pubinfo_devtools_api";
+const overviewFetch = useFetch(`${API_ROOT}/overview`, { immediate: false }).json();
+const apiListFetch = useFetch(`${API_ROOT}/api-list`, { immediate: false }).json();
+const componentUsageFetch = useFetch(`${API_ROOT}/component-usage`, { immediate: false }).json();
+const importUsageFetch = useFetch(`${API_ROOT}/import-usage`, { immediate: false }).json();
+function usePackageVersion(packageName) {
+	return useFetch(`${API_ROOT}/package-version?package=${encodeURIComponent(packageName)}`, { immediate: false }).json();
+}
+export { usePackageVersion as a, createReusableTemplate as c, useElementSize as d, useLocalStorage as f, createSharedComposable as h, overviewFetch as i, onClickOutside as l, createEventHook as m, componentUsageFetch as n, Badge_default as o, useVModel as p, importUsageFetch as r, _plugin_vue_export_helper_default as s, apiListFetch as t, useClipboard as u };