@vuetify/v0 0.0.2-beta.3 → 0.0.2-beta.4

package/dist/composables-C6dl5kjP.mjs

@@ -0,0 +1,614 @@
+import { createContext, createPlugin, createTrinity, useContext } from "./createTrinity-CwGvQ2ng.mjs";
+import { IN_BROWSER, createTokensContext, useGroup, useLogger, useRegistry, useSingle } from "./useTheme-tY7MoBKr.mjs";
+import { isArray, isFunction } from "./utilities-lZSfrXgw.mjs";
+import { toArray } from "./transformers-BTjuwbOV.mjs";
+import { computed, getCurrentInstance, getCurrentScope, isRef, onMounted, onScopeDispose, onUnmounted, ref, shallowReactive, shallowRef, toRaw, toRef, toValue, unref, watch } from "vue";
+
+//#region src/composables/useEventListener/index.ts
+function useEventListener(target, event, listener, options) {
+	const cleanups = [];
+	function cleanup() {
+		for (const fn of cleanups) fn();
+		cleanups.length = 0;
+	}
+	const register = (el, event$1, listener$1, options$1) => {
+		el.addEventListener(event$1, listener$1, options$1);
+		return () => el.removeEventListener(event$1, listener$1, options$1);
+	};
+	const stopWatcher = watch(() => [
+		toValue(target),
+		toValue(event),
+		unref(listener),
+		toValue(options)
+	], ([el, events, listeners, opts]) => {
+		cleanup();
+		if (!el) return;
+		const eventList = toArray(events);
+		const listenerList = toArray(listeners);
+		for (const event$1 of eventList) for (const listenerFn of listenerList) cleanups.push(register(el, event$1, listenerFn, opts));
+	}, {
+		immediate: true,
+		flush: "post"
+	});
+	function stop() {
+		stopWatcher();
+		cleanup();
+	}
+	onScopeDispose(stop, true);
+	return stop;
+}
+/**
+* Convenience function for attaching event listeners to the window object.
+* This function provides a simplified API by pre-binding the window target,
+* making it easier to handle window-specific events with automatic cleanup.
+*
+* @param event Event name(s) to listen for from WindowEventMap.
+* @param listener Event handler function(s) with proper window event typing.
+* @param options Optional event listener configuration.
+* @returns Function to manually remove all attached listeners.
+*/
+function useWindowEventListener(event, listener, options) {
+	return useEventListener(window, event, listener, options);
+}
+/**
+* Convenience function for attaching event listeners to the document object.
+* This function provides a simplified API by pre-binding the document target,
+* making it easier to handle document-specific events with automatic cleanup.
+*
+* @param event Event name(s) to listen for from DocumentEventMap.
+* @param listener Event handler function(s) with proper document event typing.
+* @param options Optional event listener configuration.
+* @returns Function to manually remove all attached listeners.
+*/
+function useDocumentEventListener(event, listener, options) {
+	return useEventListener(document, event, listener, options);
+}
+
+//#endregion
+//#region src/composables/useFilter/index.ts
+function defaultFilter(query, item, keys, mode = "some") {
+	const queries = Array.isArray(query) ? query.map((q) => String(q).toLowerCase()) : [String(query).toLowerCase()];
+	function match(value, q) {
+		return String(value).toLowerCase().includes(q);
+	}
+	const values = typeof item === "object" && item !== null ? keys?.length ? keys.map((k) => item[k]) : Object.values(item) : [item];
+	const stringValues = values.map((v) => String(v).toLowerCase());
+	if (mode === "some") return stringValues.some((val) => match(val, queries[0]));
+	if (mode === "every") return stringValues.every((val) => match(val, queries[0]));
+	if (mode === "union") return queries.some((q) => stringValues.some((val) => match(val, q)));
+	if (mode === "intersection") return queries.every((q) => stringValues.some((val) => match(val, q)));
+	return false;
+}
+function toRefOrGetter(value) {
+	return isRef(value) ? value : typeof value === "function" ? toRef(value) : toRef(() => value);
+}
+/**
+* Creates a reactive filter for arrays based on query matching with configurable search modes.
+* Supports 'some' (any field matches), 'every' (all fields match), 'union' (any query matches),
+* and 'intersection' (all queries match) filtering strategies.
+*
+* @param query Filter query to match against items.
+* @param items Collection of items to filter.
+* @param options Optional configuration for the filter behavior.
+* @template Z The type of the items being filtered.
+* @returns A computed reference to the filtered items based on the query and options.
+*/
+function useFilter(query, items, options = {}) {
+	const { customFilter, keys, mode = "some" } = options;
+	const filterFunction = customFilter ?? ((q, i) => defaultFilter(q, i, keys, mode));
+	const itemsRef = isRef(items) ? items : toRef(() => items);
+	const queryRef = toRefOrGetter(query);
+	const filteredItems = computed(() => {
+		const q = toValue(queryRef);
+		const queries = (Array.isArray(q) ? q : [q]).filter((q$1) => String(q$1).trim());
+		if (queries.length === 0) return itemsRef.value;
+		const queryParam = queries.length === 1 ? queries[0] : queries;
+		return itemsRef.value.filter((item) => filterFunction(queryParam, item));
+	});
+	return { items: filteredItems };
+}
+
+//#endregion
+//#region src/composables/useForm/index.ts
+function useForm(options) {
+	const registry = useRegistry(options);
+	const validateOn = options?.validateOn || "submit";
+	function parse(value) {
+		return value.toLowerCase().split(/\s+/);
+	}
+	function validatesOn(event) {
+		return parse(validateOn).includes(event);
+	}
+	const isValidating = computed(() => {
+		for (const ticket of registry.collection.values()) if (ticket.isValidating.value) return true;
+		return false;
+	});
+	const isValid = computed(() => {
+		let hasFields = false;
+		for (const ticket of registry.values()) {
+			hasFields = true;
+			if (ticket.isValid.value === false) return false;
+			if (ticket.isValid.value === null) return null;
+		}
+		return hasFields ? true : null;
+	});
+	function reset() {
+		for (const ticket of registry.values()) ticket.reset();
+	}
+	async function submit() {
+		return validate(registry.keys());
+	}
+	async function validate(id) {
+		const validating = toArray(id);
+		if (validatesOn("submit")) {
+			const results = await Promise.all(validating.map(async (id$1) => await registry.get(id$1)?.validate() ?? true));
+			return results.every(Boolean);
+		}
+		const tickets = validating.map((id$1) => registry.get(id$1)).filter(Boolean);
+		return tickets.every((ticket) => ticket.isValid.value === true);
+	}
+	function register(registration) {
+		const model = shallowRef(registration.value == null ? "" : toValue(registration.value));
+		const rules = registration.rules || [];
+		const errors = shallowRef([]);
+		const isValidating$1 = shallowRef(false);
+		const initialValue = model.value;
+		const triggers = registration.validateOn || validateOn;
+		const isPristine = shallowRef(true);
+		const isValid$1 = shallowRef(null);
+		function _validatesOn(event) {
+			return parse(triggers).includes(event);
+		}
+		function _reset() {
+			model.value = initialValue;
+			errors.value = [];
+			isPristine.value = true;
+			isValid$1.value = null;
+		}
+		async function validate$1(silent = false) {
+			if (rules.length === 0) return true;
+			isValidating$1.value = true;
+			try {
+				const results = await Promise.all(rules.map((rule) => rule(model.value)));
+				const errorMessages = results.filter((result) => typeof result === "string");
+				if (!silent) {
+					errors.value = errorMessages;
+					isValid$1.value = errorMessages.length === 0;
+					isPristine.value = toValue(model) === initialValue;
+				}
+				return errorMessages.length === 0;
+			} finally {
+				isValidating$1.value = false;
+			}
+		}
+		const item = {
+			...registration,
+			rules,
+			errors,
+			disabled: registration.disabled || false,
+			validateOn: triggers,
+			isValidating: isValidating$1,
+			isPristine,
+			isValid: isValid$1,
+			reset: _reset,
+			validate: validate$1
+		};
+		const ticket = registry.register(item);
+		Object.defineProperty(ticket, "value", {
+			get() {
+				return model.value;
+			},
+			set(val) {
+				model.value = val;
+				isPristine.value = val === initialValue;
+				isValid$1.value = null;
+				if (_validatesOn("change")) validate$1();
+			},
+			enumerable: true,
+			configurable: true
+		});
+		return ticket;
+	}
+	return {
+		...registry,
+		register,
+		reset,
+		submit,
+		validateOn,
+		isValid,
+		isValidating
+	};
+}
+
+//#endregion
+//#region src/composables/useKeydown/index.ts
+/**
+* Sets up global keyboard event listeners for specified key handlers with automatic cleanup.
+* This composable automatically starts listening when mounted and cleans up when the scope
+* is disposed, providing a clean way to handle global keyboard interactions.
+*
+* @param handlers A single handler or array of handlers to register for keydown events.
+* @returns Object with methods to manually start and stop listening for keydown events.
+*/
+function useKeydown(handlers) {
+	const keyHandlers = Array.isArray(handlers) ? handlers : [handlers];
+	function onKeydown(event) {
+		const handler = keyHandlers.find((h$1) => h$1.key === event.key);
+		if (handler) {
+			if (handler.preventDefault) event.preventDefault();
+			if (handler.stopPropagation) event.stopPropagation();
+			handler.handler(event);
+		}
+	}
+	function startListening() {
+		document.addEventListener("keydown", onKeydown);
+	}
+	function stopListening() {
+		document.removeEventListener("keydown", onKeydown);
+	}
+	if (getCurrentScope()) onMounted(startListening);
+	onScopeDispose(stopListening, true);
+	return {
+		startListening,
+		stopListening
+	};
+}
+
+//#endregion
+//#region src/composables/useLayout/index.ts
+function useLayout(_options = {}) {
+	const { enroll = true, events = true,...options } = _options;
+	const registry = useGroup({
+		enroll,
+		events,
+		...options
+	});
+	const sizes = shallowReactive(/* @__PURE__ */ new Map());
+	const height = shallowRef(0);
+	const width = shallowRef(0);
+	const bounds = {
+		top: computed(() => sum("top")),
+		bottom: computed(() => sum("bottom")),
+		left: computed(() => sum("left")),
+		right: computed(() => sum("right"))
+	};
+	const main = {
+		x: computed(() => bounds.left.value),
+		y: computed(() => bounds.top.value),
+		width: computed(() => width.value - bounds.left.value - bounds.right.value),
+		height: computed(() => height.value - bounds.top.value - bounds.bottom.value)
+	};
+	function sum(position) {
+		let total = 0;
+		for (const item of registry.values()) if (item.position === position && item.isActive.value) total += sizes.get(item.id) ?? item.value ?? 0;
+		return total;
+	}
+	function register(registration) {
+		const item = {
+			position: registration.position,
+			order: registration.order ?? 0,
+			...registration
+		};
+		const ticket = registry.register(item);
+		sizes.set(ticket.id, ticket.value);
+		return ticket;
+	}
+	if (IN_BROWSER && getCurrentInstance()) {
+		function resize() {
+			height.value = window.innerHeight;
+			width.value = window.innerWidth;
+		}
+		onMounted(() => {
+			resize();
+			window.addEventListener("resize", resize);
+		});
+		onUnmounted(() => {
+			window.removeEventListener("resize", resize);
+		});
+	}
+	registry.on("unregister", (item) => {
+		sizes.delete(item.id);
+	});
+	return {
+		...registry,
+		register,
+		bounds,
+		main,
+		sizes,
+		height,
+		width
+	};
+}
+
+//#endregion
+//#region src/composables/useLocale/adapters/v0.ts
+/**
+* Vuetify0.x locale adapter implementation
+*
+* This adapter provides translation and number formatting
+* capabilities using the Intl API and supports both
+* numbered and named variables in translation strings.
+*/
+var Vuetify0LocaleAdapter = class {
+	t(message, ...params) {
+		let resolvedMessage = message;
+		if (params.length > 0 && typeof params[0] === "object" && params[0] !== null && !Array.isArray(params[0])) {
+			const variables = params[0];
+			resolvedMessage = resolvedMessage.replace(/{([a-zA-Z][a-zA-Z0-9_]*)}/g, (match, name) => {
+				return variables[name] === void 0 ? match : String(variables[name]);
+			});
+			params = params.slice(1);
+		}
+		resolvedMessage = resolvedMessage.replace(/\{(\d+)\}/g, (match, index) => {
+			const idx = Number.parseInt(index, 10);
+			if (params[idx] !== void 0) return String(params[idx]);
+			return match;
+		});
+		return resolvedMessage;
+	}
+	n(value, locale, ...params) {
+		if (!IN_BROWSER || !locale) return value.toString();
+		const options = params[0];
+		return new Intl.NumberFormat(String(locale), options).format(value);
+	}
+};
+
+//#endregion
+//#region src/composables/useLocale/index.ts
+/**
+* Creates a locale registry for managing internationalization with translations and number formatting.
+* Supports message resolution with token references and locale-specific number formatting.
+*
+* @param namespace The namespace for the locale context.
+* @param options Configuration including adapter and messages.
+* @template Z The type of the locale context.
+* @template E The type of the locale items managed by the registry.
+* @returns An array containing the inject function, provide function, and the locale context.
+*/
+function createLocale(namespace = "v0:locale", options = {}) {
+	const { adapter = new Vuetify0LocaleAdapter(), messages = {} } = options;
+	const [useLocaleContext, _provideLocaleContext] = createContext(namespace);
+	const registry = useSingle();
+	for (const id in messages) {
+		registry.register({
+			value: messages[id],
+			id
+		});
+		if (id === options.default && !registry.selectedId.value) registry.select(id);
+	}
+	function t(key, ...params) {
+		const locale = registry.selectedId.value;
+		if (!locale) return key;
+		const message = messages[locale]?.[key];
+		const template = typeof message === "string" ? resolve(locale, message) : key;
+		return adapter.t(template, ...params);
+	}
+	function n(value, ...params) {
+		return adapter.n(value, registry.selectedId.value, ...params);
+	}
+	function resolve(locale, str) {
+		return str.replace(/{([a-zA-Z0-9.-_]+)}/g, (match, linkedKey) => {
+			const [linkedLocale, ...rest] = linkedKey.split(".");
+			const keyPath = rest.join(".");
+			const targetLocale = messages[linkedLocale] ? linkedLocale : locale;
+			const targetKey = messages[linkedLocale] ? keyPath : linkedKey;
+			const resolved = messages[targetLocale]?.[targetKey];
+			return typeof resolved === "string" ? resolve(targetLocale, resolved) : match;
+		});
+	}
+	const context = {
+		...registry,
+		t,
+		n
+	};
+	function provideLocaleContext(_context = context, app) {
+		return _provideLocaleContext(_context, app);
+	}
+	return createTrinity(useLocaleContext, provideLocaleContext, context);
+}
+/**
+* Simple hook to access the locale context.
+*
+* @returns The locale context containing translation and formatting functions.
+*/
+function useLocale() {
+	return useContext("v0:locale")();
+}
+/**
+* Creates a Vue plugin for internationalization with locale management and translation support.
+* Integrates with token system for message resolution and provides app-wide locale context.
+*
+* @param options Configuration for adapter, default locale, and messages.
+* @template Z The type of the locale context.
+* @template E The type of the locale items managed by the registry.
+* @template R The type of the token context.
+* @template O The type of the token items managed by the registry.
+* @returns Vue install function for the plugin
+*/
+function createLocalePlugin(options = {}) {
+	const { adapter = new Vuetify0LocaleAdapter(), messages = {} } = options;
+	const [, provideLocaleTokenContext, tokensContext] = createTokensContext("v0:locale:tokens", messages);
+	const [, provideLocaleContext, localeContext] = createLocale("v0:locale", {
+		adapter,
+		messages
+	});
+	return createPlugin({
+		namespace: "v0:locale",
+		provide: (app) => {
+			provideLocaleContext(localeContext, app);
+			provideLocaleTokenContext(tokensContext, app);
+		}
+	});
+}
+
+//#endregion
+//#region src/composables/useProxyModel/index.ts
+/**
+* Creates a proxy model for two-way binding with a selection context.
+*
+* @param registry SelectionContext | GroupContext | SingleContext | StepContext
+* @template Z The type of items managed by the selection.
+* @template E The type of the selection context.
+* @returns The proxy model for two-way binding with the selection context.
+*/
+function useProxyModel(registry, initial, options, _transformIn, _transformOut) {
+	const logger = useLogger();
+	const reactivity = options?.deep ? ref : shallowRef;
+	const internal = reactivity(initial ? toArray(initial) : []);
+	const isModelArray = isArray(initial);
+	function transformIn(val) {
+		if (isFunction(_transformIn)) return _transformIn(val);
+		return toArray(val);
+	}
+	function transformOut(val) {
+		if (isFunction(_transformOut)) return _transformOut(val);
+		return isModelArray ? val : val[0];
+	}
+	const model = computed({
+		get() {
+			return transformOut(internal.value);
+		},
+		set(val) {
+			internal.value = transformIn(val);
+		}
+	});
+	const watcher = watch(registry.selectedIds, (val, oldVal) => {
+		if (toRaw(val).symmetricDifference(toRaw(oldVal)).size === 0) return;
+		if (val.size === 0) {
+			model.value = [];
+			return;
+		}
+		model.value = Array.from(registry.selectedValues.value);
+	});
+	watch(model, (val) => {
+		const currentIds = new Set(toValue(registry.selectedIds));
+		const targetIds = /* @__PURE__ */ new Set();
+		for (const value of toArray(val)) {
+			const id = registry.browse(value);
+			if (id) targetIds.add(id);
+			else logger.warn("Unable to find id for value", value);
+		}
+		watcher.pause();
+		if (isModelArray) {
+			for (const id of currentIds.difference(targetIds)) registry.selectedIds.delete(id);
+			for (const id of targetIds.difference(currentIds)) registry.selectedIds.add(id);
+		} else {
+			const next = targetIds.values().next().value;
+			const last = currentIds.values().next().value;
+			registry.selectedIds.delete(last);
+			registry.selectedIds.add(next);
+		}
+		watcher.resume();
+	});
+	return model;
+}
+
+//#endregion
+//#region src/composables/useStorage/adapters/memory.ts
+/**
+* In-memory storage adapter that implements the StorageAdapter interface.
+* This adapter provides temporary storage that persists only for the current
+* session and is useful for testing or when persistent storage is not available.
+*/
+var MemoryAdapter = class {
+	store = /* @__PURE__ */ new Map();
+	get length() {
+		return this.store.size;
+	}
+	getItem(key) {
+		return this.store.get(key) ?? null;
+	}
+	setItem(key, value) {
+		this.store.set(key, value);
+	}
+	removeItem(key) {
+		this.store.delete(key);
+	}
+	key(index) {
+		return Array.from(this.store.keys())[index];
+	}
+};
+
+//#endregion
+//#region src/composables/useStorage/index.ts
+const [useStorageContext, provideStorageContext] = createContext("v0:storage");
+/**
+* Creates a reactive storage system with automatic persistence and cross-adapter support.
+* This function provides a consistent interface for storing and retrieving reactive values
+* that automatically sync with the underlying storage adapter (localStorage, memory, etc.).
+*
+* @param options Optional configuration for storage adapter, prefix, and serialization.
+* @template E The type of the storage context.
+* @returns A storage context object with get, set, remove, and clear methods.
+*/
+function createStorage(options = {}) {
+	const { adapter = IN_BROWSER ? window.localStorage : new MemoryAdapter(), prefix = "v0:", serializer = {
+		read: JSON.parse,
+		write: JSON.stringify
+	} } = options;
+	const cache = /* @__PURE__ */ new Map();
+	function get(key, defaultValue) {
+		const prefixedKey = `${prefix}${key}`;
+		if (cache.has(prefixedKey)) return cache.get(prefixedKey);
+		const storedValue = adapter?.getItem(prefixedKey);
+		let initialValue = defaultValue;
+		if (storedValue) try {
+			initialValue = serializer.read(storedValue);
+		} catch (error) {
+			console.error(`[v0:storage] Failed to parse stored value for key "${prefixedKey}":`, error);
+		}
+		const valueRef = ref(initialValue);
+		watch(valueRef, (newValue) => {
+			if (newValue === void 0 || newValue === null) adapter?.removeItem(prefixedKey);
+			else adapter?.setItem(prefixedKey, serializer.write(newValue));
+		}, { deep: true });
+		cache.set(prefixedKey, valueRef);
+		return valueRef;
+	}
+	function set(key, value) {
+		const valueRef = get(key);
+		valueRef.value = value;
+	}
+	function remove(key) {
+		const prefixedKey = `${prefix}${key}`;
+		adapter?.removeItem(prefixedKey);
+		cache.delete(prefixedKey);
+	}
+	function clear() {
+		for (const key of cache.keys()) adapter?.removeItem(key);
+		cache.clear();
+	}
+	return {
+		get,
+		set,
+		remove,
+		clear
+	};
+}
+/**
+* Simple hook to access the storage context.
+*
+* @returns The storage context containing reactive storage methods.
+*/
+function useStorage() {
+	return useStorageContext();
+}
+/**
+* Creates a Vue plugin for reactive storage capabilities with automatic persistence.
+* Provides app-wide access to reactive storage that syncs with the configured adapter.
+*
+* @param options Optional configuration for the storage system.
+* @returns A Vue plugin object with install method.
+*/
+function createStoragePlugin(options = {}) {
+	const context = createStorage(options);
+	return createPlugin({
+		namespace: "v0:storage",
+		provide: (app) => {
+			provideStorageContext(context, app);
+		}
+	});
+}
+
+//#endregion
+export { createLocale, createLocalePlugin, createStorage, createStoragePlugin, provideStorageContext, useDocumentEventListener, useEventListener, useFilter, useForm, useKeydown, useLayout, useLocale, useProxyModel, useStorage, useStorageContext, useWindowEventListener };

package/dist/createTrinity-CwGvQ2ng.mjs

@@ -0,0 +1,79 @@
+import { inject, provide } from "vue";
+
+//#region src/factories/createContext/index.ts
+/**
+* A simple wrapper for tapping into a v0 namespace
+* @param key The provided string or InjectionKey
+* @template Z The type values for the context.
+* @returns A function that retrieves context
+* @throws Error if namespace is not found.
+*
+* @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
+*/
+function useContext(key) {
+	return function(namespace) {
+		const context = inject(namespace || key, void 0);
+		if (context === void 0) throw new Error(`Context "${String(key)}" not found. Ensure it's provided by an ancestor.`);
+		return context;
+	};
+}
+/**
+* A simple wrapper for Vues provide & inject systems
+* to create context for managing application state
+* @param key The provided string or InjectionKey
+* @template Z The type values for the context.
+* @returns A tuple containing provide/inject
+*
+* @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
+* @see https://0.vuetifyjs.com/composables/foundation/create-context
+*/
+function createContext(key) {
+	function provideContext(context, app) {
+		app?.provide(key, context) ?? provide(key, context);
+		return context;
+	}
+	return [useContext(key), provideContext];
+}
+
+//#endregion
+//#region src/factories/createPlugin/index.ts
+/**
+* A universal plugin factory to reduce boilerplate code for Vue plugin creation
+* @param options Configurable object with namespace and provide/setup methods
+* @returns A Vue plugin object with install method that runs app w/ context
+*
+* @see https://vuejs.org/api/application.html#app-runwithcontext
+* @see https://0.vuetifyjs.com/factories/create-plugin
+*/
+function createPlugin(options) {
+	return { install(app) {
+		app.runWithContext(() => {
+			options.provide(app);
+			options.setup?.(app);
+		});
+	} };
+}
+
+//#endregion
+//#region src/factories/createTrinity/index.ts
+/**
+* A tuple containing Vue's provide/inject and a context object
+* @param createContext The function that creates the context
+* @param provideContext The function that provides context
+* @param context The underlying context object singleton
+* @template Z The type parameter for the context value
+* @template E The vmodel type for the context state.
+* @returns [createContext, provideContext, context]
+*
+* @see https://0.vuetifyjs.com/composables/foundation/create-trinity
+*/
+function createTrinity(createContext$1, provideContext, context) {
+	return [
+		createContext$1,
+		(_context = context, app) => provideContext(_context, app),
+		context
+	];
+}
+
+//#endregion
+export { createContext, createPlugin, createTrinity, useContext };

package/dist/factories/index.d.mts

@@ -0,0 +1,3 @@
+import { ContextTrinity, createTrinity } from "../index-DfahEz6s.mjs";
+import { ContextKey, PluginOptions, createContext, createPlugin, useContext } from "../index-oCBJwhpG.mjs";
+export { ContextKey, ContextTrinity, PluginOptions, createContext, createPlugin, createTrinity, useContext };

package/dist/factories/index.mjs

@@ -0,0 +1,4 @@
+import { createContext, createPlugin, createTrinity, useContext } from "../createTrinity-CwGvQ2ng.mjs";
+import "../factories-DOLmqhVS.mjs";
+
+export { createContext, createPlugin, createTrinity, useContext };