@vuetify/v0 1.1.0 → 1.2.0

package/dist/useFeatures-DLafCOWt.mjs

@@ -0,0 +1,221 @@
+import { isArray, isBoolean, isNumber, isObject, isString } from "./utilities/index.mjs";
+import { n as createPluginContext } from "./createPlugin-Oo6t-vBw.mjs";
+import { t as createTokens } from "./createTokens-DoISbwd7.mjs";
+import { t as toArray } from "./toArray-MY9Kb1Qy.mjs";
+import { t as createGroup } from "./createGroup-B_LL7xRr.mjs";
+import { shallowReactive, shallowRef } from "vue";
+//#region src/composables/useFeatures/index.ts
+/**
+* @module useFeatures
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-features
+*
+* @remarks
+* Feature flag system with boolean and token-based features.
+*
+* Key features:
+* - Boolean features (true/false activation)
+* - Token features with $variation support
+* - Auto-selection of enabled features
+* - Multi-select support for feature combinations
+* - Perfect for A/B testing, progressive rollout, feature toggles
+* - Adapter pattern for external feature flag services (Generic, LaunchDarkly, Flagsmith)
+*
+* Inheritance chain: createRegistry → createSelection → createGroup → createFeatures
+* Integrates with createTokens for token-based features.
+*
+* @example
+* ```ts
+* import { useFeatures } from '@vuetify/v0'
+*
+* const features = useFeatures()
+* features.register({ id: 'new-checkout', value: true })
+* console.log(features.variation('new-checkout'))
+* ```
+*/
+function isEnabled(value) {
+	if (/* @__PURE__ */ isBoolean(value)) return value;
+	if (/* @__PURE__ */ isObject(value) && /* @__PURE__ */ isBoolean(value.$value)) return value.$value;
+}
+const seams = /* @__PURE__ */ new WeakMap();
+function coerce(saved) {
+	if (!/* @__PURE__ */ isObject(saved)) return null;
+	const map = /* @__PURE__ */ new Map();
+	if (/* @__PURE__ */ isArray(saved.enabled)) {
+		for (const id of saved.enabled) if (/* @__PURE__ */ isString(id) || /* @__PURE__ */ isNumber(id)) map.set(id, true);
+	}
+	if (/* @__PURE__ */ isArray(saved.disabled)) {
+		for (const id of saved.disabled) if (/* @__PURE__ */ isString(id) || /* @__PURE__ */ isNumber(id)) map.set(id, false);
+	}
+	return map.size > 0 ? map : null;
+}
+/**
+* Creates a new features instance.
+*
+* @param options The options for the features instance.
+* @returns A new features instance.
+*
+* @see https://0.vuetifyjs.com/composables/plugins/use-features
+*
+* @example
+* ```ts
+* import { createFeatures } from '@vuetify/v0'
+*
+* const features = createFeatures({
+*   features: {
+*     'dark-mode': true,
+*     'theme-color': { $variation: 'blue' },
+*   },
+* })
+* ```
+*/
+function createFeatures(_options = {}) {
+	const { features, ...options } = _options;
+	const tokens = createTokens(features, { flat: true });
+	const registry = createGroup({
+		...options,
+		events: true,
+		reactive: true
+	});
+	const touched = shallowReactive(/* @__PURE__ */ new Set());
+	const defaults = /* @__PURE__ */ new Map();
+	const pending = shallowRef(null);
+	for (const [id, { value }] of tokens.entries()) register({
+		id,
+		value
+	});
+	function touch(ids) {
+		for (const id of /* @__PURE__ */ toArray(ids)) if (registry.has(id)) touched.add(id);
+	}
+	function select(ids) {
+		touch(ids);
+		registry.select(ids);
+	}
+	function unselect(ids) {
+		touch(ids);
+		registry.unselect(ids);
+	}
+	function toggle(ids) {
+		touch(ids);
+		registry.toggle(ids);
+	}
+	function reset() {
+		touched.clear();
+		pending.value = null;
+		registry.reset();
+		for (const [id, enabled] of defaults) if (enabled) registry.select(id);
+	}
+	function variation(id, fallback = null) {
+		const ticket = registry.get(id);
+		if (!ticket) return fallback;
+		return /* @__PURE__ */ isObject(ticket.value) ? ticket.value.$variation ?? fallback : ticket.value ?? fallback;
+	}
+	function register(registration = {}) {
+		const item = {
+			value: false,
+			...registration
+		};
+		const ticket = registry.register(item);
+		if (isEnabled(ticket.value) === true) registry.select(ticket.id);
+		defaults.set(ticket.id, registry.selectedIds.has(ticket.id));
+		if (pending.value?.has(ticket.id) && !touched.has(ticket.id)) {
+			touched.add(ticket.id);
+			if (pending.value.get(ticket.id)) registry.select(ticket.id);
+			else registry.unselect(ticket.id);
+		}
+		return ticket;
+	}
+	function sync(flags) {
+		for (const [id, value] of Object.entries(flags)) if (registry.get(id)) {
+			const enabled = isEnabled(value);
+			registry.upsert(id, { value });
+			if (enabled === true) registry.select(id);
+			else if (enabled === false) registry.selectedIds.delete(id);
+		} else register({
+			id,
+			value
+		});
+	}
+	function onboard(registrations) {
+		return registry.batch(() => registrations.map((registration) => register(registration)));
+	}
+	function replay(force = false) {
+		if (!pending.value) return;
+		for (const [id, enabled] of pending.value) {
+			if (!registry.has(id)) continue;
+			if (!force && touched.has(id)) continue;
+			touched.add(id);
+			if (enabled) registry.select(id);
+			else registry.unselect(id);
+		}
+	}
+	function delta() {
+		pending.value;
+		const enabled = [];
+		const disabled = [];
+		for (const id of touched) {
+			if (!registry.has(id)) continue;
+			const selected = registry.selectedIds.has(id);
+			if (selected === defaults.get(id)) continue;
+			if (selected) enabled.push(id);
+			else disabled.push(id);
+		}
+		return {
+			enabled,
+			disabled
+		};
+	}
+	const context = {
+		...registry,
+		select,
+		unselect,
+		toggle,
+		reset,
+		variation,
+		register,
+		onboard,
+		sync,
+		get size() {
+			return registry.size;
+		}
+	};
+	seams.set(context, {
+		delta,
+		restore: (saved) => {
+			pending.value = coerce(saved);
+			replay();
+		},
+		replay: () => replay(true)
+	});
+	return context;
+}
+function createFeaturesFallback() {
+	return {
+		size: 0,
+		variation: (_id, fallback = null) => fallback,
+		sync: () => {},
+		onboard: () => [],
+		register: () => void 0,
+		select: () => {},
+		unselect: () => {},
+		get: () => void 0,
+		has: () => false,
+		selectedIds: /* @__PURE__ */ new Set(),
+		values: () => []
+	};
+}
+const [createFeaturesContext, createFeaturesPlugin, useFeatures] = createPluginContext("v0:features", (options) => createFeatures(options), {
+	fallback: () => createFeaturesFallback(),
+	persist: (context) => seams.get(context)?.delta() ?? null,
+	restore: (context, saved) => seams.get(context)?.restore(saved),
+	setup: (context, app, { adapter }) => {
+		if (!adapter) return;
+		for (const a of /* @__PURE__ */ isArray(adapter) ? adapter : [adapter]) {
+			context.sync(a.setup((flags) => context.sync(flags)));
+			app.onUnmount(() => a.dispose?.());
+		}
+		seams.get(context)?.replay();
+	}
+});
+//#endregion
+export { useFeatures as i, createFeaturesContext as n, createFeaturesPlugin as r, createFeatures as t };

package/dist/{useLocale-D-V0DENN.mjs → useLocale-K_45ulPt.mjs}

@@ -1,8 +1,8 @@
 import { isNumber, isString } from "./utilities/index.mjs";
-import { o as createPluginContext } from "./useLogger-CbvzXCWb.mjs";
-import { t as createSingle } from "./createSingle-Dz-1Iv7u.mjs";
-import { r as flatten, t as createTokens } from "./createTokens-C4qcW2Kv.mjs";
-import { t as V0LocaleAdapter } from "./v0-CZBkpQjr.mjs";
+import { n as createPluginContext } from "./createPlugin-Oo6t-vBw.mjs";
+import { t as createSingle } from "./createSingle-DHyIQ9Cj.mjs";
+import { r as flatten, t as createTokens } from "./createTokens-DoISbwd7.mjs";
+import { t as V0LocaleAdapter } from "./v0-D0Exc2bO.mjs";
 //#region src/composables/useLocale/index.ts
 /**
 * @module useLocale

package/dist/{useLogger-CbvzXCWb.mjs → useLogger-YyWuYvrH.mjs}

@@ -1,161 +1,7 @@
-import { s as __LOGGER_ENABLED__, t as IN_BROWSER } from "./globals-CtaXlEOI.mjs";
-import { isNullOrUndefined, isUndefined } from "./utilities/index.mjs";
-import { i as useContext, t as createTrinity } from "./createTrinity-z-3q9QWR.mjs";
-import { t as V0LoggerAdapter } from "./v0-CCWHeKJM.mjs";
-import { hasInjectionContext, inject, watch } from "vue";
-//#region src/composables/createPlugin/index.ts
-/**
-* @module createPlugin
-*
-* @see https://vuejs.org/guide/reusability/plugins.html
-* @see https://0.vuetifyjs.com/composables/foundation/create-plugin
-*
-* @remarks
-* Factory for creating Vue plugins with proper context provision.
-*
-* Wraps the provide function in app.runWithContext() to ensure proper execution context,
-* allowing plugins to safely provide dependency injection contexts at the application level.
-*
-* Also exports `createPluginContext` — a higher-level factory that generates the standard
-* context/plugin/consumer triple for plugin composables, eliminating boilerplate.
-* Supports `persist()` / `restore()` lifecycle hooks for saving and rehydrating plugin state.
-*
-* @example
-* ```ts
-* import { createPlugin } from '@vuetify/v0'
-*
-* const plugin = createPlugin({
-*   namespace: 'v0:my-plugin',
-*   provide: app => app.provide('my-key', { greet: () => 'hello' }),
-* })
-* // app.use(plugin)
-* ```
-*/
-const INSTALLED = Symbol.for("v0:installed-plugins");
-function getInstalled(app) {
-	const ctx = app._context;
-	return ctx[INSTALLED] ??= /* @__PURE__ */ new Set();
-}
-/**
-* Creates a new Vue plugin.
-*
-* @param options The plugin options.
-* @returns A new Vue plugin.
-*
-* @see https://0.vuetifyjs.com/composables/foundation/create-plugin
-*
-* @example
-* ```ts
-* export const [useContext, provideContext] = createContext<MyContext>('my-plugin')
-*
-* const context = {}
-*
-* export const MyPlugin = createPlugin({
-*   namespace: 'my-plugin',
-*   provide: (app) => {
-*     provideContext(context, app)
-*   },
-*   setup: (app) => {
-*     // Optional setup logic
-*   },
-* })
-*/
-function createPlugin(options) {
-	return { install(app) {
-		app.runWithContext(() => {
-			const installed = getInstalled(app);
-			if (installed.has(options.namespace)) return;
-			installed.add(options.namespace);
-			options.provide(app);
-			options.setup?.(app);
-		});
-	} };
-}
-function deriveKey(namespace) {
-	return namespace.startsWith("v0:") ? namespace.slice(3) : namespace;
-}
-function getPersistedStorage() {
-	return useContext("v0:storage");
-}
-/**
-* Creates the three standard functions for a plugin composable.
-*
-* @param defaultNamespace The default DI namespace string (e.g. `'v0:logger'`).
-* @param factory Function that creates the composable context instance from options.
-* @param config Optional setup callback and fallback factory.
-* @returns A readonly tuple: `[createXContext, createXPlugin, useX]`.
-*
-* @example
-* ```ts
-* // Simple — no setup or fallback
-* export const [createStorageContext, createStoragePlugin, useStorage] =
-*   createPluginContext('v0:storage', options => createStorage(options))
-*
-* // With fallback — safe outside component instances
-* export const [createLoggerContext, createLoggerPlugin, useLogger] =
-*   createPluginContext('v0:logger', options => createLogger(options), {
-*     fallback: ns => createFallbackLogger(ns),
-*     setup: (context) => {
-*       if (__DEV__ && IN_BROWSER) (window as Window & { __v0Logger__?: typeof context }).__v0Logger__ = context
-*     },
-*   })
-* ```
-*/
-function createPluginContext(defaultNamespace, factory, config) {
-	function createXContext(_options = {}) {
-		const { namespace = defaultNamespace, persist: _persist, ...options } = _options;
-		return createTrinity(namespace, factory(options));
-	}
-	function createXPlugin(_options = {}) {
-		const { namespace = defaultNamespace, persist: shouldPersist, ...options } = _options;
-		let context;
-		return createPlugin({
-			namespace,
-			provide: (app) => {
-				const [, provide, ctx] = createXContext({
-					...options,
-					namespace
-				});
-				context = ctx;
-				provide(context, app);
-				if (shouldPersist && config?.restore) {
-					const storage = getPersistedStorage();
-					const key = deriveKey(namespace);
-					const saved = storage.get(key);
-					if (!/* @__PURE__ */ isNullOrUndefined(saved.value)) config.restore(context, saved.value);
-				}
-			},
-			setup: config?.setup || shouldPersist ? (app) => {
-				const ctx = context;
-				config?.setup?.(ctx, app, options);
-				if (shouldPersist && config?.persist) {
-					const storage = getPersistedStorage();
-					const key = deriveKey(namespace);
-					const stored = storage.get(key);
-					const stop = watch(() => config.persist(ctx), (val) => {
-						stored.value = val;
-					});
-					app.onUnmount(stop);
-				}
-			} : void 0
-		});
-	}
-	function useX(namespace = defaultNamespace) {
-		if (config?.fallback) {
-			if (!hasInjectionContext()) return config.fallback(namespace);
-			const provided = inject(namespace, void 0);
-			if (!/* @__PURE__ */ isUndefined(provided)) return provided;
-			return config.fallback(namespace);
-		}
-		return useContext(namespace);
-	}
-	return [
-		createXContext,
-		createXPlugin,
-		useX
-	];
-}
-//#endregion
+import { s as __LOGGER_ENABLED__, t as IN_BROWSER } from "./globals-DaoKtIGF.mjs";
+import { isUndefined } from "./utilities/index.mjs";
+import { n as createPluginContext } from "./createPlugin-Oo6t-vBw.mjs";
+import { t as V0LoggerAdapter } from "./v0-SuxTihEe.mjs";
 //#region src/composables/useLogger/index.ts
 /**
 * @module useLogger
@@ -364,4 +210,4 @@ function useLogger(scope) {
 	return /* @__PURE__ */ isUndefined(scope) || !scope.trim() ? logger : createScopedLogger(logger, scope);
 }
 //#endregion
-export { createPlugin as a, useLogger as i, createLoggerContext as n, createPluginContext as o, createLoggerPlugin as r, createLogger as t };
+export { useLogger as i, createLoggerContext as n, createLoggerPlugin as r, createLogger as t };

package/dist/{useNotifications-Cqg3uDz0.mjs → useNotifications-Kh_KvM7j.mjs}

@@ -1,156 +1,9 @@
-import { t as IN_BROWSER } from "./globals-CtaXlEOI.mjs";
-import { isFunction, isNull, isUndefined, useId as useId$1 } from "./utilities/index.mjs";
+import { UNSAFE_KEYS, isNaN, isNull, isObject, isString, isUndefined, useId as useId$1 } from "./utilities/index.mjs";
 import { i as useContext, t as createTrinity } from "./createTrinity-z-3q9QWR.mjs";
-import { o as createPluginContext } from "./useLogger-CbvzXCWb.mjs";
-import { t as createRegistry } from "./createRegistry-B9cOWny2.mjs";
-import { onScopeDispose, shallowRef, toValue } from "vue";
-//#region src/composables/useTimer/index.ts
-/**
-* @module useTimer
-*
-* @see https://0.vuetifyjs.com/composables/system/use-timer
-*
-* @remarks
-* A reactive timer composable with pause/resume support.
-*
-* Key features:
-* - Start/stop/pause/resume controls
-* - Reactive remaining time tracking
-* - Reactive `duration` via `MaybeRefOrGetter` — read fresh on each `start()`
-* - One-shot (default) or repeating mode
-* - Automatic cleanup on scope disposal
-* - SSR-safe
-*
-* @example
-* ```ts
-* import { useTimer } from '@vuetify/v0'
-*
-* const timer = useTimer(() => console.log('fired'), { duration: 5000 })
-* timer.start()
-* ```
-*/
-/**
-* Creates a reactive timer with pause/resume support.
-*
-* @param handler Callback invoked when the timer fires.
-* @param options Timer configuration.
-* @returns Timer controls and reactive state.
-*
-* @see https://0.vuetifyjs.com/composables/system/use-timer
-*
-* @example
-* ```ts
-* const timer = useTimer(() => console.log('fired'), { duration: 5000 })
-*
-* timer.start()
-* timer.pause()
-* timer.resume()
-* timer.stop()
-*
-* // Reactive duration — re-read on each start()
-* const duration = shallowRef(1000)
-* const reactive = useTimer(handler, { duration })
-* duration.value = 2000
-* reactive.start() // fires after 2000ms
-* ```
-*/
-function useTimer(handler, options = {}) {
-	const { duration = 1e3, repeat = false } = options;
-	function resolveDuration() {
-		return toValue(duration);
-	}
-	const remaining = shallowRef(resolveDuration());
-	const isActive = shallowRef(false);
-	const isPaused = shallowRef(false);
-	let timeoutId;
-	let trackingId;
-	let startedAt = 0;
-	let budget = remaining.value;
-	function clearTimer() {
-		if (!/* @__PURE__ */ isUndefined(timeoutId)) {
-			globalThis.clearTimeout(timeoutId);
-			timeoutId = void 0;
-		}
-	}
-	function startTracking() {
-		stopTracking();
-		if (!IN_BROWSER) return;
-		trackingId = globalThis.setInterval(() => {
-			if (!isActive.value || isPaused.value) return;
-			const elapsed = Date.now() - startedAt;
-			remaining.value = Math.max(0, budget - elapsed);
-		}, 100);
-	}
-	function stopTracking() {
-		if (!/* @__PURE__ */ isUndefined(trackingId)) {
-			globalThis.clearInterval(trackingId);
-			trackingId = void 0;
-		}
-	}
-	function fire() {
-		clearTimer();
-		stopTracking();
-		handler();
-		if (repeat) begin(resolveDuration());
-		else {
-			isActive.value = false;
-			remaining.value = 0;
-		}
-	}
-	function begin(ms) {
-		clearTimer();
-		stopTracking();
-		budget = ms;
-		startedAt = Date.now();
-		remaining.value = ms;
-		isActive.value = true;
-		isPaused.value = false;
-		timeoutId = globalThis.setTimeout(fire, ms);
-		startTracking();
-	}
-	function start() {
-		const ms = resolveDuration();
-		if (ms < 0) return;
-		begin(ms);
-	}
-	function stop() {
-		clearTimer();
-		stopTracking();
-		isActive.value = false;
-		isPaused.value = false;
-		remaining.value = resolveDuration();
-	}
-	function pause() {
-		if (!isActive.value || isPaused.value) return;
-		const elapsed = Date.now() - startedAt;
-		budget = Math.max(0, budget - elapsed);
-		remaining.value = budget;
-		clearTimer();
-		stopTracking();
-		isPaused.value = true;
-	}
-	function resume() {
-		if (!isPaused.value) return;
-		isPaused.value = false;
-		startedAt = Date.now();
-		timeoutId = globalThis.setTimeout(fire, budget);
-		startTracking();
-	}
-	onScopeDispose(() => {
-		clearTimer();
-		stopTracking();
-	}, true);
-	return {
-		start,
-		stop,
-		pause,
-		resume,
-		remaining,
-		isActive,
-		isPaused
-	};
-}
-//#endregion
+import { n as createPluginContext } from "./createPlugin-Oo6t-vBw.mjs";
+import { t as createRegistry } from "./createRegistry-DVdvep0v.mjs";
+import { t as useTimer } from "./useTimer-CGVXk397.mjs";
+import { onScopeDispose } from "vue";
 //#region src/composables/createQueue/index.ts
 /**
 * @module createQueue
@@ -762,6 +615,49 @@ function createNotifications(_options = {}) {
 		}
 	};
 }
+function toDate(value) {
+	if (!/* @__PURE__ */ isString(value)) return null;
+	const date = new Date(value);
+	return /* @__PURE__ */ isNaN(date.getTime()) ? null : date;
+}
+function snapshot(context) {
+	const out = {};
+	let count = 0;
+	for (const ticket of context.values()) {
+		if (UNSAFE_KEYS.has(String(ticket.id))) continue;
+		const entry = {};
+		if (!/* @__PURE__ */ isNull(ticket.readAt)) entry.readAt = ticket.readAt.toISOString();
+		if (!/* @__PURE__ */ isNull(ticket.seenAt)) entry.seenAt = ticket.seenAt.toISOString();
+		if (!/* @__PURE__ */ isNull(ticket.archivedAt)) entry.archivedAt = ticket.archivedAt.toISOString();
+		if (!/* @__PURE__ */ isNull(ticket.snoozedUntil) && ticket.snoozedUntil.getTime() > Date.now()) entry.snoozedUntil = ticket.snoozedUntil.toISOString();
+		if (Object.keys(entry).length === 0) continue;
+		out[ticket.id] = entry;
+		count++;
+	}
+	return count > 0 ? out : null;
+}
+function coerce(saved) {
+	if (!/* @__PURE__ */ isObject(saved)) return null;
+	const map = /* @__PURE__ */ new Map();
+	for (const [id, entry] of Object.entries(saved)) {
+		if (!/* @__PURE__ */ isObject(entry)) continue;
+		const state = {};
+		const readAt = toDate(entry.readAt);
+		const seenAt = toDate(entry.seenAt);
+		const archivedAt = toDate(entry.archivedAt);
+		const snoozedUntil = toDate(entry.snoozedUntil);
+		if (!/* @__PURE__ */ isNull(readAt)) state.readAt = readAt;
+		if (!/* @__PURE__ */ isNull(seenAt)) state.seenAt = seenAt;
+		if (!/* @__PURE__ */ isNull(archivedAt)) state.archivedAt = archivedAt;
+		if (!/* @__PURE__ */ isNull(snoozedUntil) && snoozedUntil.getTime() > Date.now()) state.snoozedUntil = snoozedUntil;
+		if (Object.keys(state).length > 0) map.set(id, state);
+	}
+	return map.size > 0 ? map : null;
+}
+function merge(context, map, ticket) {
+	const state = map.get(ticket.id) ?? map.get(String(ticket.id));
+	if (state) context.upsert(ticket.id, state);
+}
 function noop() {}
 const EMPTY = [];
 function createNotificationsFallback() {
@@ -867,6 +763,13 @@ function createNotificationsFallback() {
 */
 const [createNotificationsContext, createNotificationsPlugin, useNotifications] = createPluginContext("v0:notifications", (options) => createNotifications(options), {
 	fallback: () => createNotificationsFallback(),
+	persist: (context) => snapshot(context),
+	restore: (context, saved) => {
+		const map = coerce(saved);
+		if (!map) return;
+		for (const ticket of context.values()) merge(context, map, ticket);
+		context.on("register:ticket", (ticket) => merge(context, map, ticket));
+	},
 	setup: (context, app, options) => {
 		app.onUnmount(() => {
 			context.dispose();
@@ -880,8 +783,8 @@ const [createNotificationsContext, createNotificationsPlugin, useNotifications]
 			on: context.on,
 			off: context.off
 		});
-		if (/* @__PURE__ */ isFunction(adapter.dispose)) app.onUnmount(() => adapter.dispose());
+		app.onUnmount(() => adapter.dispose?.());
 	}
 });
 //#endregion
-export { createQueue as a, useTimer as c, useNotifications as i, createNotificationsContext as n, createQueueContext as o, createNotificationsPlugin as r, useQueue as s, createNotifications as t };
+export { createQueue as a, useNotifications as i, createNotificationsContext as n, createQueueContext as o, createNotificationsPlugin as r, useQueue as s, createNotifications as t };

package/dist/{usePermissions-BTdUVyQe.mjs → usePermissions-BCGwsOES.mjs}

@@ -1,8 +1,8 @@
 import { UNSAFE_KEYS } from "./utilities/index.mjs";
-import { o as createPluginContext } from "./useLogger-CbvzXCWb.mjs";
-import { t as createTokens } from "./createTokens-C4qcW2Kv.mjs";
-import { t as toArray } from "./toArray-C89ZaEuF.mjs";
-import { t as V0PermissionsAdapter } from "./v0-UNyykD27.mjs";
+import { n as createPluginContext } from "./createPlugin-Oo6t-vBw.mjs";
+import { t as createTokens } from "./createTokens-DoISbwd7.mjs";
+import { t as toArray } from "./toArray-MY9Kb1Qy.mjs";
+import { t as V0PermissionsAdapter } from "./v0-Ch0yBKEj.mjs";
 //#region src/composables/usePermissions/index.ts
 /**
 * @module usePermissions