@youcan/celeste 0.6.96 → 0.6.98

package/dist/cjs/chunks/core.js

@@ -0,0 +1,325 @@
+require("./dist.js");
+let vue = require("vue");
+//#region ../../node_modules/.pnpm/@vueuse+shared@13.9.0_vue@3.5.13_typescript@5.8.3_/node_modules/@vueuse/shared/index.mjs
+function tryOnScopeDispose(fn) {
+	if ((0, vue.getCurrentScope)()) {
+		(0, vue.onScopeDispose)(fn);
+		return true;
+	}
+	return false;
+}
+var localProvidedStateMap = /* @__PURE__ */ new WeakMap();
+var injectLocal = /* @__NO_SIDE_EFFECTS__ */ (...args) => {
+	var _a;
+	const key = args[0];
+	const instance = (_a = (0, vue.getCurrentInstance)()) == null ? void 0 : _a.proxy;
+	if (instance == null && !(0, vue.hasInjectionContext)()) throw new Error("injectLocal must be called in setup");
+	if (instance && localProvidedStateMap.has(instance) && key in localProvidedStateMap.get(instance)) return localProvidedStateMap.get(instance)[key];
+	return (0, vue.inject)(...args);
+};
+function toReactive(objectRef) {
+	if (!(0, vue.isRef)(objectRef)) return (0, vue.reactive)(objectRef);
+	return (0, vue.reactive)(new Proxy({}, {
+		get(_, p, receiver) {
+			return (0, vue.unref)(Reflect.get(objectRef.value, p, receiver));
+		},
+		set(_, p, value) {
+			if ((0, vue.isRef)(objectRef.value[p]) && !(0, vue.isRef)(value)) objectRef.value[p].value = value;
+			else objectRef.value[p] = value;
+			return true;
+		},
+		deleteProperty(_, p) {
+			return Reflect.deleteProperty(objectRef.value, p);
+		},
+		has(_, p) {
+			return Reflect.has(objectRef.value, p);
+		},
+		ownKeys() {
+			return Object.keys(objectRef.value);
+		},
+		getOwnPropertyDescriptor() {
+			return {
+				enumerable: true,
+				configurable: true
+			};
+		}
+	}));
+}
+function reactiveComputed(fn) {
+	return toReactive((0, vue.computed)(fn));
+}
+function reactiveOmit(obj, ...keys) {
+	const flatKeys = keys.flat();
+	const predicate = flatKeys[0];
+	return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries((0, vue.toRefs)(obj)).filter(([k, v]) => !predicate((0, vue.toValue)(v), k))) : Object.fromEntries(Object.entries((0, vue.toRefs)(obj)).filter((e) => !flatKeys.includes(e[0]))));
+}
+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]";
+function pxValue(px) {
+	return px.endsWith("rem") ? Number.parseFloat(px) * 16 : Number.parseFloat(px);
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+function watchImmediate(source, cb, options) {
+	return (0, vue.watch)(source, cb, {
+		...options,
+		immediate: true
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@vueuse+core@13.9.0_vue@3.5.13_typescript@5.8.3_/node_modules/@vueuse/core/index.mjs
+var defaultWindow = isClient ? window : void 0;
+var defaultDocument = isClient ? window.document : void 0;
+isClient && window.navigator;
+isClient && window.location;
+function unrefElement(elRef) {
+	var _a;
+	const plain = (0, vue.toValue)(elRef);
+	return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+}
+function useEventListener(...args) {
+	const cleanups = [];
+	const cleanup = () => {
+		cleanups.forEach((fn) => fn());
+		cleanups.length = 0;
+	};
+	const register = (el, event, listener, options) => {
+		el.addEventListener(event, listener, options);
+		return () => el.removeEventListener(event, listener, options);
+	};
+	const firstParamTargets = (0, vue.computed)(() => {
+		const test = toArray((0, vue.toValue)(args[0])).filter((e) => e != null);
+		return test.every((e) => typeof e !== "string") ? test : void 0;
+	});
+	const 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((0, vue.toValue)(firstParamTargets.value ? args[1] : args[0])),
+			toArray((0, vue.unref)(firstParamTargets.value ? args[2] : args[1])),
+			(0, vue.toValue)(firstParamTargets.value ? args[3] : args[2])
+		];
+	}, ([raw_targets, raw_events, raw_listeners, raw_options]) => {
+		cleanup();
+		if (!(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" });
+	const stop = () => {
+		stopWatch();
+		cleanup();
+	};
+	tryOnScopeDispose(cleanup);
+	return stop;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function useMounted() {
+	const isMounted = (0, vue.shallowRef)(false);
+	const instance = (0, vue.getCurrentInstance)();
+	if (instance) (0, vue.onMounted)(() => {
+		isMounted.value = true;
+	}, instance);
+	return isMounted;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function useSupported(callback) {
+	const isMounted = /* @__PURE__ */ useMounted();
+	return (0, vue.computed)(() => {
+		isMounted.value;
+		return Boolean(callback());
+	});
+}
+var ssrWidthSymbol = Symbol("vueuse-ssr-width");
+/* @__NO_SIDE_EFFECTS__ */
+function useSSRWidth() {
+	const ssrWidth = (0, vue.hasInjectionContext)() ? /* @__PURE__ */ injectLocal(ssrWidthSymbol, null) : null;
+	return typeof ssrWidth === "number" ? ssrWidth : void 0;
+}
+function useMediaQuery(query, options = {}) {
+	const { window = defaultWindow, ssrWidth = /* @__PURE__ */ useSSRWidth() } = options;
+	const isSupported = /* @__PURE__ */ useSupported(() => window && "matchMedia" in window && typeof window.matchMedia === "function");
+	const ssrSupport = (0, vue.shallowRef)(typeof ssrWidth === "number");
+	const mediaQuery = (0, vue.shallowRef)();
+	const matches = (0, vue.shallowRef)(false);
+	const handler = (event) => {
+		matches.value = event.matches;
+	};
+	(0, vue.watchEffect)(() => {
+		if (ssrSupport.value) {
+			ssrSupport.value = !isSupported.value;
+			matches.value = (0, vue.toValue)(query).split(",").some((queryString) => {
+				const not = queryString.includes("not all");
+				const minWidth = queryString.match(/\(\s*min-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
+				const maxWidth = queryString.match(/\(\s*max-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
+				let res = Boolean(minWidth || maxWidth);
+				if (minWidth && res) res = ssrWidth >= pxValue(minWidth[1]);
+				if (maxWidth && res) res = ssrWidth <= pxValue(maxWidth[1]);
+				return not ? !res : res;
+			});
+			return;
+		}
+		if (!isSupported.value) return;
+		mediaQuery.value = window.matchMedia((0, vue.toValue)(query));
+		matches.value = mediaQuery.value.matches;
+	});
+	useEventListener(mediaQuery, "change", handler, { passive: true });
+	return (0, vue.computed)(() => matches.value);
+}
+function cloneFnJSON(source) {
+	return JSON.parse(JSON.stringify(source));
+}
+function useDropZone(target, options = {}) {
+	var _a, _b;
+	const isOverDropZone = (0, vue.shallowRef)(false);
+	const files = (0, vue.shallowRef)(null);
+	let counter = 0;
+	let isValid = true;
+	if (isClient) {
+		const _options = typeof options === "function" ? { onDrop: options } : options;
+		const multiple = (_a = _options.multiple) != null ? _a : true;
+		const preventDefaultForUnhandled = (_b = _options.preventDefaultForUnhandled) != null ? _b : false;
+		const getFiles = (event) => {
+			var _a2, _b2;
+			const list = Array.from((_b2 = (_a2 = event.dataTransfer) == null ? void 0 : _a2.files) != null ? _b2 : []);
+			return list.length === 0 ? null : multiple ? list : [list[0]];
+		};
+		const checkDataTypes = (types) => {
+			const dataTypes = (0, vue.unref)(_options.dataTypes);
+			if (typeof dataTypes === "function") return dataTypes(types);
+			if (!(dataTypes == null ? void 0 : dataTypes.length)) return true;
+			if (types.length === 0) return false;
+			return types.every((type) => dataTypes.some((allowedType) => type.includes(allowedType)));
+		};
+		const checkValidity = (items) => {
+			const dataTypesValid = checkDataTypes(Array.from(items != null ? items : []).map((item) => item.type));
+			const multipleFilesValid = multiple || items.length <= 1;
+			return dataTypesValid && multipleFilesValid;
+		};
+		const isSafari = () => /^(?:(?!chrome|android).)*safari/i.test(navigator.userAgent) && !("chrome" in window);
+		const handleDragEvent = (event, eventType) => {
+			var _a2, _b2, _c, _d, _e, _f;
+			const dataTransferItemList = (_a2 = event.dataTransfer) == null ? void 0 : _a2.items;
+			isValid = (_b2 = dataTransferItemList && checkValidity(dataTransferItemList)) != null ? _b2 : false;
+			if (preventDefaultForUnhandled) event.preventDefault();
+			if (!isSafari() && !isValid) {
+				if (event.dataTransfer) event.dataTransfer.dropEffect = "none";
+				return;
+			}
+			event.preventDefault();
+			if (event.dataTransfer) event.dataTransfer.dropEffect = "copy";
+			const currentFiles = getFiles(event);
+			switch (eventType) {
+				case "enter":
+					counter += 1;
+					isOverDropZone.value = true;
+					(_c = _options.onEnter) == null || _c.call(_options, null, event);
+					break;
+				case "over":
+					(_d = _options.onOver) == null || _d.call(_options, null, event);
+					break;
+				case "leave":
+					counter -= 1;
+					if (counter === 0) isOverDropZone.value = false;
+					(_e = _options.onLeave) == null || _e.call(_options, null, event);
+					break;
+				case "drop":
+					counter = 0;
+					isOverDropZone.value = false;
+					if (isValid) {
+						files.value = currentFiles;
+						(_f = _options.onDrop) == null || _f.call(_options, currentFiles, event);
+					}
+					break;
+			}
+		};
+		useEventListener(target, "dragenter", (event) => handleDragEvent(event, "enter"));
+		useEventListener(target, "dragover", (event) => handleDragEvent(event, "over"));
+		useEventListener(target, "dragleave", (event) => handleDragEvent(event, "leave"));
+		useEventListener(target, "drop", (event) => handleDragEvent(event, "drop"));
+	}
+	return {
+		files,
+		isOverDropZone
+	};
+}
+Number.POSITIVE_INFINITY;
+/* @__NO_SIDE_EFFECTS__ */
+function useVModel(props, key, emit, options = {}) {
+	var _a, _b, _c;
+	const { clone = false, passive = false, eventName, deep = false, defaultValue, shouldEmit } = options;
+	const vm = (0, vue.getCurrentInstance)();
+	const _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);
+	const getValue = () => 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 = (0, vue.ref)(getValue());
+		let isUpdating = false;
+		(0, vue.watch)(() => props[key], (v) => {
+			if (!isUpdating) {
+				isUpdating = true;
+				proxy.value = cloneFn(v);
+				(0, vue.nextTick)(() => isUpdating = false);
+			}
+		});
+		(0, vue.watch)(proxy, (v) => {
+			if (!isUpdating && (v !== props[key] || deep)) triggerEmit(v);
+		}, { deep });
+		return proxy;
+	} else return (0, vue.computed)({
+		get() {
+			return getValue();
+		},
+		set(value) {
+			triggerEmit(value);
+		}
+	});
+}
+//#endregion
+Object.defineProperty(exports, "defaultDocument", {
+	enumerable: true,
+	get: function() {
+		return defaultDocument;
+	}
+});
+Object.defineProperty(exports, "reactiveOmit", {
+	enumerable: true,
+	get: function() {
+		return reactiveOmit;
+	}
+});
+Object.defineProperty(exports, "useDropZone", {
+	enumerable: true,
+	get: function() {
+		return useDropZone;
+	}
+});
+Object.defineProperty(exports, "useEventListener", {
+	enumerable: true,
+	get: function() {
+		return useEventListener;
+	}
+});
+Object.defineProperty(exports, "useMediaQuery", {
+	enumerable: true,
+	get: function() {
+		return useMediaQuery;
+	}
+});
+Object.defineProperty(exports, "useVModel", {
+	enumerable: true,
+	get: function() {
+		return useVModel;
+	}
+});

package/dist/cjs/chunks/counter-input.js

@@ -1,70 +1,75 @@
-"use strict";
-const No = require("vue");
-const clsx = require("./clsx.js");
-const index = require("./index.js");
-const useDelegatedProps = require("../use-delegated-props.js");
-const compactButton = require("../compact-button.js");
-const _sfc_main = /* @__PURE__ */ No.defineComponent({
-  __name: "counter-input",
-  props: {
-    defaultValue: { default: 0 },
-    modelValue: {},
-    min: {},
-    max: {},
-    step: {},
-    formatOptions: {},
-    locale: {},
-    disabled: { type: Boolean },
-    required: { type: Boolean },
-    name: {},
-    id: {},
-    asChild: { type: Boolean },
-    as: {},
-    class: {},
-    size: { default: "md" },
-    hasError: { type: Boolean, default: false }
-  },
-  emits: ["update:modelValue"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const delegatedProps = useDelegatedProps.useDelegatedProps(props, "class");
-    const forwarded = index.Se(delegatedProps, emits);
-    return (_ctx, _cache) => {
-      return No.openBlock(), No.createBlock(No.unref(index.gy), No.mergeProps(No.unref(forwarded), {
-        "has-error": _ctx.hasError,
-        class: No.unref(clsx.clsx)("celeste-counter-input-wrapper", props.class)
-      }), {
-        default: No.withCtx(() => [
-          No.createVNode(No.unref(index.wy), {
-            "as-child": "",
-            class: "celeste-counter-input-decrement"
-          }, {
-            default: No.withCtx(() => [
-              No.createVNode(compactButton, {
-                variant: "ghost",
-                icon: "i-celeste-subtract-line"
-              })
-            ]),
-            _: 1
-          }),
-          No.createVNode(No.unref(index.by), { class: "celeste-counter-input" }),
-          No.createVNode(No.unref(index.Cy), {
-            "as-child": "",
-            class: "celeste-counter-input-increment"
-          }, {
-            default: No.withCtx(() => [
-              No.createVNode(compactButton, {
-                variant: "ghost",
-                icon: "i-celeste-add-line"
-              })
-            ]),
-            _: 1
-          })
-        ]),
-        _: 1
-      }, 16, ["has-error", "class"]);
-    };
-  }
+const require_dist = require("./dist.js");
+const require_clsx = require("./clsx.js");
+const require_compact_button = require("./compact-button.js");
+const require_use_delegated_props = require("../use-delegated-props.js");
+let vue = require("vue");
+//#endregion
+//#region src/components/counter-input/counter-input.vue
+var counter_input_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "counter-input",
+	props: {
+		defaultValue: { default: 0 },
+		modelValue: {},
+		min: {},
+		max: {},
+		step: {},
+		formatOptions: {},
+		locale: {},
+		disabled: { type: Boolean },
+		required: { type: Boolean },
+		name: {},
+		id: {},
+		asChild: { type: Boolean },
+		as: {},
+		class: {},
+		size: { default: "md" },
+		hasError: {
+			type: Boolean,
+			default: false
+		}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const forwarded = require_dist.Se(require_use_delegated_props.useDelegatedProps(props, "class"), emits);
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_dist.gy), (0, vue.mergeProps)((0, vue.unref)(forwarded), {
+				"has-error": _ctx.hasError,
+				class: (0, vue.unref)(require_clsx.clsx)("celeste-counter-input-wrapper", props.class)
+			}), {
+				default: (0, vue.withCtx)(() => [
+					(0, vue.createVNode)((0, vue.unref)(require_dist.wy), {
+						"as-child": "",
+						class: "celeste-counter-input-decrement"
+					}, {
+						default: (0, vue.withCtx)(() => [(0, vue.createVNode)(require_compact_button.compact_button_default, {
+							variant: "ghost",
+							icon: "i-celeste-subtract-line"
+						})]),
+						_: 1
+					}),
+					(0, vue.createVNode)((0, vue.unref)(require_dist.by), { class: "celeste-counter-input" }),
+					(0, vue.createVNode)((0, vue.unref)(require_dist.Cy), {
+						"as-child": "",
+						class: "celeste-counter-input-increment"
+					}, {
+						default: (0, vue.withCtx)(() => [(0, vue.createVNode)(require_compact_button.compact_button_default, {
+							variant: "ghost",
+							icon: "i-celeste-add-line"
+						})]),
+						_: 1
+					})
+				]),
+				_: 1
+			}, 16, ["has-error", "class"]);
+		};
+	}
+});
+//#endregion
+Object.defineProperty(exports, "counter_input_default", {
+	enumerable: true,
+	get: function() {
+		return counter_input_default;
+	}
 });
-exports._sfc_main = _sfc_main;

package/dist/cjs/chunks/digit-input-group.js

@@ -0,0 +1,34 @@
+const require_dist = require("./dist.js");
+const require_clsx = require("./clsx.js");
+const require__plugin_vue_export_helper = require("./_plugin-vue_export-helper.js");
+const require_core = require("./core.js");
+let vue = require("vue");
+//#region src/components/digit-input/digit-input-group.vue?vue&type=script&setup=true&lang.ts
+var digit_input_group_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "digit-input-group",
+	props: {
+		asChild: { type: Boolean },
+		as: {},
+		class: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const forwardedProps = require_dist.Ot(require_core.reactiveOmit(props, "class"));
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_dist.O), (0, vue.mergeProps)((0, vue.unref)(forwardedProps), { class: (0, vue.unref)(require_clsx.clsx)("celeste-digit-input-group", props.class) }), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", {}, void 0, true)]),
+				_: 3
+			}, 16, ["class"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/digit-input/digit-input-group.vue
+var digit_input_group_default = /* @__PURE__ */ require__plugin_vue_export_helper._plugin_vue_export_helper_default(digit_input_group_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-44b2fcc1"]]);
+//#endregion
+Object.defineProperty(exports, "digit_input_group_default", {
+	enumerable: true,
+	get: function() {
+		return digit_input_group_default;
+	}
+});

package/dist/cjs/chunks/digit-input-slot.js

@@ -0,0 +1,33 @@
+const require_dist = require("./dist.js");
+const require_clsx = require("./clsx.js");
+const require__plugin_vue_export_helper = require("./_plugin-vue_export-helper.js");
+const require_core = require("./core.js");
+let vue = require("vue");
+//#region src/components/digit-input/digit-input-slot.vue?vue&type=script&setup=true&lang.ts
+var digit_input_slot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "digit-input-slot",
+	props: {
+		index: {},
+		disabled: { type: Boolean },
+		asChild: { type: Boolean },
+		as: {},
+		class: {}
+	},
+	setup(__props) {
+		const props = __props;
+		const forwardedProps = require_dist.Ot(require_core.reactiveOmit(props, "class"));
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_dist.Ty), (0, vue.mergeProps)((0, vue.unref)(forwardedProps), { class: (0, vue.unref)(require_clsx.clsx)("celeste-digit-input-slot", props.class) }), null, 16, ["class"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/digit-input/digit-input-slot.vue
+var digit_input_slot_default = /* @__PURE__ */ require__plugin_vue_export_helper._plugin_vue_export_helper_default(digit_input_slot_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-5a1bb76d"]]);
+//#endregion
+Object.defineProperty(exports, "digit_input_slot_default", {
+	enumerable: true,
+	get: function() {
+		return digit_input_slot_default;
+	}
+});

package/dist/cjs/chunks/digit-input.js

@@ -0,0 +1,54 @@
+const require_dist = require("./dist.js");
+const require_clsx = require("./clsx.js");
+const require__plugin_vue_export_helper = require("./_plugin-vue_export-helper.js");
+const require_core = require("./core.js");
+let vue = require("vue");
+//#region src/components/digit-input/digit-input.vue?vue&type=script&setup=true&lang.ts
+var digit_input_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ (0, vue.defineComponent)({
+	__name: "digit-input",
+	props: {
+		modelValue: { default: () => [] },
+		defaultValue: {},
+		placeholder: {},
+		mask: { type: Boolean },
+		otp: { type: Boolean },
+		type: {},
+		dir: {},
+		name: {},
+		disabled: { type: Boolean },
+		required: { type: Boolean },
+		id: {},
+		asChild: { type: Boolean },
+		as: {},
+		class: {},
+		hasError: {
+			type: Boolean,
+			default: false
+		}
+	},
+	emits: ["update:modelValue", "complete"],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const forwarded = require_dist.Se(require_core.reactiveOmit(props, "class", "hasError"), emits);
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_dist.Iy), (0, vue.mergeProps)((0, vue.unref)(forwarded), {
+				class: (0, vue.unref)(require_clsx.clsx)("celeste-digit-input", props.class),
+				"data-error": _ctx.hasError
+			}), {
+				default: (0, vue.withCtx)(() => [(0, vue.renderSlot)(_ctx.$slots, "default", {}, void 0, true)]),
+				_: 3
+			}, 16, ["class", "data-error"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/digit-input/digit-input.vue
+var digit_input_default = /* @__PURE__ */ require__plugin_vue_export_helper._plugin_vue_export_helper_default(digit_input_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-86bf03a4"]]);
+//#endregion
+Object.defineProperty(exports, "digit_input_default", {
+	enumerable: true,
+	get: function() {
+		return digit_input_default;
+	}
+});