bitboss-ui 2.1.119 → 2.1.121

package/dist/index184.js

@@ -1,4 +1,112 @@
-import f from "./index74.js";
-export {
-  f as default
-};
+import e from "./index181.js";
+import t from "./index183.js";
+import { createBlock as n, defineComponent as r, guardReactiveProps as i, normalizeProps as a, openBlock as o, ref as s, renderSlot as c, withCtx as l } from "vue";
+//#region src/components/ListBox/ListBox.vue?vue&type=script&setup=true&lang.ts
+var u = /* @__PURE__ */ r({
+	__name: "ListBox",
+	props: {
+		compact: { type: Boolean },
+		options: {},
+		groups: {},
+		headerHeight: {},
+		open: { type: Boolean },
+		loading: { type: Boolean },
+		multiple: { type: Boolean },
+		transitionDuration: {},
+		loadingText: {},
+		noDataText: {},
+		optionHeight: {}
+	},
+	emits: [
+		"option:selected",
+		"option:unselected",
+		"focused:change"
+	],
+	setup(r, { expose: u }) {
+		let d = s();
+		return u({
+			focusNext: () => d.value?.focusNext(),
+			focusPrevious: () => d.value?.focusPrevious(),
+			focusFirst: () => d.value?.focusFirst(),
+			focusFirstSelected: () => d.value?.focusFirstSelected(),
+			focusLast: () => d.value?.focusLast(),
+			focusLastSelected: () => d.value?.focusLastSelected(),
+			blur: () => d.value?.blur(),
+			confirmOption: () => d.value?.confirmOption(),
+			focusByHash: (e) => d.value?.focusByHash(e),
+			getHighlighted: () => d.value?.getHighlighted(),
+			getActiveDescendantId: () => d.value?.getActiveDescendantId()
+		}), (r, s) => r.groups ? (o(), n(t, {
+			key: 0,
+			ref_key: "child",
+			ref: d,
+			compact: r.compact,
+			groups: r.groups,
+			"header-height": r.headerHeight,
+			loading: r.loading,
+			"loading-text": r.loadingText,
+			multiple: r.multiple,
+			"no-data-text": r.noDataText,
+			open: r.open,
+			"option-height": r.optionHeight,
+			"transition-duration": r.transitionDuration,
+			"onOption:selected": s[0] ||= (e) => r.$emit("option:selected", e),
+			"onOption:unselected": s[1] ||= (e) => r.$emit("option:unselected", e),
+			"onFocused:change": s[2] ||= (e) => r.$emit("focused:change", e)
+		}, {
+			"options:prepend": l(() => [c(r.$slots, "options:prepend")]),
+			loading: l(() => [c(r.$slots, "loading")]),
+			"no-data": l(() => [c(r.$slots, "no-data")]),
+			"options:append": l(() => [c(r.$slots, "options:append")]),
+			option: l((e) => [c(r.$slots, "option", a(i(e)))]),
+			group: l((e) => [c(r.$slots, "group", a(i(e)))]),
+			_: 3
+		}, 8, [
+			"compact",
+			"groups",
+			"header-height",
+			"loading",
+			"loading-text",
+			"multiple",
+			"no-data-text",
+			"open",
+			"option-height",
+			"transition-duration"
+		])) : (o(), n(e, {
+			key: 1,
+			ref_key: "child",
+			ref: d,
+			compact: r.compact,
+			loading: r.loading,
+			"loading-text": r.loadingText,
+			multiple: r.multiple,
+			"no-data-text": r.noDataText,
+			open: r.open,
+			options: r.options ?? [],
+			"option-height": r.optionHeight,
+			"transition-duration": r.transitionDuration,
+			"onOption:selected": s[3] ||= (e) => r.$emit("option:selected", e),
+			"onOption:unselected": s[4] ||= (e) => r.$emit("option:unselected", e),
+			"onFocused:change": s[5] ||= (e) => r.$emit("focused:change", e)
+		}, {
+			"options:prepend": l(() => [c(r.$slots, "options:prepend")]),
+			loading: l(() => [c(r.$slots, "loading")]),
+			"no-data": l(() => [c(r.$slots, "no-data")]),
+			"options:append": l(() => [c(r.$slots, "options:append")]),
+			option: l((e) => [c(r.$slots, "option", a(i(e)))]),
+			_: 3
+		}, 8, [
+			"compact",
+			"loading",
+			"loading-text",
+			"multiple",
+			"no-data-text",
+			"open",
+			"options",
+			"option-height",
+			"transition-duration"
+		]));
+	}
+});
+//#endregion
+export { u as default };

package/dist/index185.js

@@ -1,5 +1,5 @@
-import o from "./index75.js";
-/* empty css        */
-export {
-  o as default
-};
+import e from "./index184.js";
+//#region src/components/ListBox/ListBox.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/index186.js

@@ -1,4 +1,457 @@
-import f from "./index77.js";
-export {
-  f as default
-};
+import { wait as e } from "./index10.js";
+import { useId as t } from "./index12.js";
+import { useElementSize as n, useIntersectionObserver as r, useMounted as ee } from "./index14.js";
+import { useMobile as te } from "./index15.js";
+import { useLogger as ne } from "./index31.js";
+import { get as re } from "./index41.js";
+import { useLocale as ie } from "./index42.js";
+import { useUntil as ae } from "./index50.js";
+import oe from "./index60.js";
+import se from "./index71.js";
+import ce from "./index74.js";
+import { hash as i } from "./index81.js";
+import { useItemsGetter as le } from "./index89.js";
+import { useIndexById as a } from "./index90.js";
+import { useBaseOptions as ue } from "./index93.js";
+import { isNil as de } from "./index94.js";
+import { useCoherence as fe } from "./index95.js";
+import { useHashedWatcher as o } from "./index96.js";
+import { usePrefill as pe } from "./index97.js";
+import { last as me } from "./index105.js";
+import { isEmpty as he } from "./index132.js";
+import { when as ge } from "./index151.js";
+import _e from "./index163.js";
+import { matchAnyKey as s } from "./index164.js";
+import { useArray as ve } from "./index165.js";
+import ye from "./index171.js";
+import be from "./index174.js";
+import xe from "./index185.js";
+import { Fragment as Se, computed as c, createBlock as l, createCommentVNode as u, createElementBlock as d, createElementVNode as f, createVNode as p, defineComponent as Ce, guardReactiveProps as we, mergeProps as Te, nextTick as m, normalizeClass as Ee, normalizeProps as De, normalizeStyle as Oe, openBlock as h, ref as g, renderList as ke, renderSlot as _, toDisplayString as Ae, toRef as v, unref as y, vModelDynamic as je, withCtx as b, withDirectives as Me, withKeys as x, withModifiers as S } from "vue";
+//#region src/components/BaseSelect/BaseSelect.vue?vue&type=script&setup=true&lang.ts
+var Ne = { class: "bb-base-select__input-container" }, Pe = {
+	key: 1,
+	class: "bb-base-select__max-reached"
+}, Fe = [
+	"id",
+	"aria-activedescendant",
+	"aria-controls",
+	"aria-describedby",
+	"aria-expanded",
+	"autocomplete",
+	"autofocus",
+	"disabled",
+	"inputmode",
+	"placeholder",
+	"readonly",
+	"required",
+	"onKeydown"
+], Ie = /* @__PURE__ */ Ce({
+	__name: "BaseSelect",
+	props: {
+		allowWriting: {
+			type: [Boolean, String],
+			default: !0
+		},
+		"append:icon": {},
+		ariaDescribedby: {},
+		autocomplete: { default: "off" },
+		autofocus: {},
+		clearable: { type: Boolean },
+		comma: { type: Boolean },
+		compact: { type: Boolean },
+		dependencies: { default: () => [] },
+		depsDebounceTime: { default: 0 },
+		disabled: { type: Boolean },
+		enforceCoherence: { type: Boolean },
+		filterBy: {
+			type: [
+				String,
+				Array,
+				Boolean,
+				Function,
+				null
+			],
+			default: () => []
+		},
+		groupBy: {},
+		headerHeight: {},
+		hasErrors: { type: Boolean },
+		id: {},
+		items: {},
+		itemHeight: {},
+		itemText: {},
+		itemValue: {},
+		loading: { type: Boolean },
+		loadingText: {},
+		max: { default: Infinity },
+		maxSelectedLabels: { default: Infinity },
+		modelValue: {},
+		modelValueDebounceTime: { default: 0 },
+		multiple: { type: Boolean },
+		name: {},
+		noDataText: {},
+		placeholder: {},
+		prefill: {
+			type: [Boolean, String],
+			default: "focus"
+		},
+		"prepend:icon": {},
+		queryDebounceTime: { default: 500 },
+		readonly: { type: Boolean },
+		required: { type: Boolean },
+		showChevron: {
+			type: Boolean,
+			default: !0
+		},
+		stash: { type: Boolean },
+		selectedLabelsFn: {},
+		transitionDuration: { default: 300 },
+		updateOnAnimationFrame: {
+			type: Boolean,
+			default: !1
+		}
+	},
+	emits: [
+		"blur",
+		"change",
+		"click",
+		"focus",
+		"inactive",
+		"input",
+		"update:modelValue",
+		"option:add"
+	],
+	setup(Ce, { emit: Ie }) {
+		let C = Ce, w = Ie, Le = ne();
+		C.multiple && !Array.isArray(C.modelValue) && Le.throw("BaseSelect: multiple is set to \"true\" but modelValue is not an array.");
+		let { t: Re } = ie(), ze = ee(), T = g(null), E = g(null), D = g(null), O = g(null), k = g(null), A = c(() => C.comma ? O.value : k.value), { width: Be } = n(E), { isMobile: Ve } = te(), He = c(() => C.allowWriting === "not-mobile" && Ve.value ? "none" : void 0), j = C.id || t().id.value, { resume: Ue, pause: We } = r(E, async ([{ intersectionRatio: e }]) => {
+			e !== 1 && Y.value && await Q();
+		}, {
+			threshold: [0, 1],
+			immediate: !1
+		}), Ge = c(() => ({ width: `${Be.value ?? 0}px` })), M = g(null), N = g(), P = () => {
+			M.value instanceof HTMLInputElement && M.value.focus();
+		}, Ke = async (e) => {
+			w("focus", e), Ct(), document.addEventListener("click", F), document.addEventListener("focusin", F);
+		}, qe = () => {
+			C.prefill === "focus" && !lt.value && !H.value && ut();
+		}, Je = async (e) => {
+			w("blur", e);
+		}, Ye = (e) => w("change", e), Xe = (e) => {
+			w("input", e), L.value === "" && (C.multiple || w("update:modelValue", null)), A.value?.blur(), X.value && Z(), at(L.value, !1, C.modelValue);
+		}, Ze = (e) => {
+			N.value = e;
+		}, F = async (t) => {
+			if (t.target instanceof Node && T.value && !T.value.$el.contains(t.target) && !D.value?.$el?.contains(t.target)) {
+				Q(), wt(), document.removeEventListener("click", F), document.removeEventListener("focusin", F), await e(C.transitionDuration), q();
+				return;
+			}
+		}, I = c(() => !(C.readonly || C.disabled || K.value || !A.value && C.multiple && G.value.length <= C.maxSelectedLabels)), Qe = async () => {
+			I.value && (A.value?.blur(), Y.value ? D.value?.focusPrevious() : (await Z(), await e(C.transitionDuration), D.value?.focusLastSelected()));
+		}, $e = async () => {
+			I.value && (A.value?.blur(), Y.value ? D.value?.focusNext() : (await Z(), await e(C.transitionDuration), D.value?.focusFirstSelected()));
+		}, et = (e) => {
+			if (!I.value || !C.multiple || L.value || (e.preventDefault(), D.value?.blur(), !G.value.length)) return;
+			A.value?.focusPrevious();
+			let t = A.value?.getHighlighted();
+			t && D.value?.focusByHash(t.valueHash);
+		}, tt = (e) => {
+			if (!I.value || !C.multiple || L.value || (e.preventDefault(), D.value?.blur(), !G.value.length)) return;
+			A.value?.focusNext();
+			let t = A.value?.getHighlighted();
+			t && D.value?.focusByHash(t.valueHash);
+		}, nt = async () => {
+			if (!I.value) return;
+			if (!Y.value) {
+				await Z(), await e(C.transitionDuration), G.value.length && D.value?.focusFirstSelected();
+				return;
+			} else if (D.value?.getHighlighted()) {
+				D.value.confirmOption();
+				return;
+			}
+			let t = L.value.trim();
+			dt(t) || (w("option:add", t), L.value = "");
+		}, rt = async () => {
+			Y.value && await Q();
+		}, it = async () => {
+			!I.value || L.value || !G.value.length || (A.value?.getHighlighted() && A.value.confirmOption(), await m(), A.value?.focusPrevious());
+		}, L = g(""), { getter: R, debouncedGetter: at, items: ot, loading: z } = le({
+			items: v(C, "items"),
+			debounce: C.queryDebounceTime
+		}), { array: B, add: V, remove: st, set: ct } = ve(), { hasPrefilled: H, isPrefilling: lt, prefill: ut } = pe({
+			trigger: C.prefill === !0,
+			currentValue: C.modelValue,
+			multiple: C.multiple,
+			fn: async (e) => {
+				await R(L.value, e, C.modelValue), C.stash && V(...W.value.map((e) => e.item)), q();
+			}
+		}), { data: U, get: dt } = a({ items: c(() => [].concat(C.modelValue)) }), { options: W } = ue({
+			disabled: v(C, "disabled"),
+			items: c(() => [...ot.value, ...B.value]),
+			itemText: C.itemText,
+			itemValue: C.itemValue,
+			max: C.max,
+			selectable: !0,
+			selectedIndexedByHash: U
+		}), { data: ft } = a({
+			items: W,
+			key: "valueHash"
+		}), { coherent: pt, coherentValue: mt } = fe({
+			modelValue: v(C, "modelValue"),
+			multiple: C.multiple,
+			iteratee: (e) => !!ft.value[i(e)]
+		}), G = c(() => [].concat(C.modelValue).map((e) => ft.value[i(e)]).filter(Boolean)), K = c(() => !!(z.value || C.loading));
+		o(() => C.modelValue, async () => {
+			pt.value || (await R(L.value, !0, C.modelValue), C.enforceCoherence && (w("update:modelValue", mt.value), A.value?.blur(), D.value?.blur())), q();
+		}, { debounce: C.modelValueDebounceTime }), o(() => [C.dependencies, C.items], async () => {
+			H.value && (await R(L.value, !0, C.modelValue), C.enforceCoherence && !pt.value && (w("update:modelValue", mt.value), A.value?.blur(), D.value?.blur()), q());
+		}, { debounce: C.depsDebounceTime });
+		let q = () => {
+			if (C.multiple) {
+				L.value = "";
+				return;
+			}
+			let e;
+			G.value && (e = me(G.value)), L.value = e?.text || "";
+		}, ht = c(() => G.value.length ? "" : C.placeholder), gt = async (e) => {
+			C.multiple ? (w("update:modelValue", C.modelValue.concat(e.value)), C.stash && V(e.item), q()) : (C.stash && ct(e.item), w("update:modelValue", e.value), await m(), q()), P(), C.multiple || Q();
+		}, J = async (e) => {
+			if (st((t) => t.valueHash !== e.valueHash), C.multiple) {
+				let t = { ...U.value };
+				delete t[e.valueHash], w("update:modelValue", Object.values(t));
+			} else w("update:modelValue", null), await m(), q();
+			P();
+		}, _t = c(() => {
+			let e = G.value.some((e) => e.text === L.value);
+			if (!(C.multiple && L.value || C.filterBy === "not_stashed" && L.value || L.value && !e && !C.multiple) || !C.filterBy) return W.value;
+			let t = C.filterBy === "not_stashed" ? new Set(B.value.map((e) => e.valueHash)) : null;
+			return W.value.filter((e) => {
+				let n = !1;
+				return typeof C.filterBy == "function" ? n = C.filterBy(e.value, e.item, L.value) : C.filterBy === "not_stashed" && L.value ? n = !t.has(e.valueHash) : Array.isArray(C.filterBy) && C.filterBy.length && (n = s(e.item, C.filterBy, L.value.trim())), n || s(e, ["text"], L.value.trim());
+			});
+		}), vt = Symbol("default"), yt = (e) => de(C.groupBy) ? vt : typeof C.groupBy == "function" ? C.groupBy(e.item) : re(e.item, C.groupBy), bt = c(() => {
+			let e = {};
+			for (let t of _t.value) {
+				let n = yt(t), r = i(n);
+				e[r] || (e[r] = {
+					id: r,
+					data: n ?? null,
+					options: []
+				}), e[r].options.push(t);
+			}
+			return Object.values(e).filter((e) => e.options.length);
+		}), Y = g(!1), X = g(!0), xt = ae(Y), Z = async () => {
+			Ue(), X.value = !1, Y.value = !0;
+		}, Q = async () => {
+			Y.value = !1, X.value = !0, N.value = void 0, A.value?.blur(), We();
+		}, St = () => Y.value ? Q() : Z(), $ = g(!1), Ct = () => {
+			$.value = !0;
+		}, wt = () => {
+			$.value = !1, w("inactive");
+		}, Tt = (e) => {
+			e.preventDefault(), w("click", e), !(C.disabled || C.readonly) && (P(), St());
+		}, Et = ge((e) => typeof e != "string", JSON.stringify), Dt = c(() => [].concat(C.modelValue).map((e) => {
+			let t = Et(e);
+			return {
+				disabled: C.disabled,
+				name: C.name,
+				type: "hidden",
+				value: t
+			};
+		})), Ot = () => {
+			let e = null;
+			C.multiple && (e = []), w("update:modelValue", e);
+		};
+		return (e, t) => (h(), l(ce, {
+			ref_key: "outerContainer",
+			ref: T,
+			class: Ee({
+				"bb-base-select": !0,
+				"bb-base-select--active": $.value,
+				"bb-base-select--shown": Y.value,
+				"bb-base-select--loading": K.value,
+				"bb-base-select--disabled": e.disabled,
+				"bb-base-select--errors": e.hasErrors,
+				"bb-base-select--readonly": e.readonly,
+				"bb-base-select--compact": e.compact
+			}),
+			onClick: Tt
+		}, {
+			"prepend-outer": b(() => [_(e.$slots, "prepend-outer", { query: L.value })]),
+			"append-outer": b(() => [_(e.$slots, "append-outer", { query: L.value })]),
+			default: b(() => [
+				f("span", {
+					ref_key: "innerContainer",
+					ref: E,
+					class: "bb-base-select__inner-wrapper"
+				}, [p(se, {
+					"append:icon": C["append:icon"],
+					clearable: e.clearable && !y(he)(e.modelValue),
+					"prepend:icon": C["prepend:icon"],
+					"prevent-focus": !0,
+					"onClick:clear": Ot
+				}, {
+					prepend: b(() => [_(e.$slots, "prepend", {
+						query: L.value,
+						focus: P
+					})]),
+					prefix: b(() => [_(e.$slots, "prefix")]),
+					append: b(() => [_(e.$slots, "append", {
+						query: L.value,
+						focus: P
+					})]),
+					suffix: b(() => [_(e.$slots, "suffix")]),
+					default: b(() => [p(_e, { tag: "span" }, {
+						default: b(() => [f("span", Ne, [e.multiple && G.value.length <= e.maxSelectedLabels ? (h(), d(Se, { key: 0 }, [e.comma ? (h(), l(be, {
+							key: 0,
+							ref_key: "commaBox",
+							ref: O,
+							options: G.value,
+							"onOption:unselected": J
+						}, null, 8, ["options"])) : (h(), l(ye, {
+							key: 1,
+							ref_key: "chipsBox",
+							ref: k,
+							options: G.value,
+							"onOption:unselected": J
+						}, null, 8, ["options"]))], 64)) : e.multiple ? (h(), d("span", Pe, Ae(e.selectedLabelsFn ? e.selectedLabelsFn(G.value.length) : y(Re)("select.multipleMaxReached", G.value.length)), 1)) : u("", !0), Me((h(), d("input", {
+							id: y(j),
+							key: `${y(ze)}`,
+							ref_key: "input",
+							ref: M,
+							"onUpdate:modelValue": t[0] ||= (e) => L.value = e,
+							"aria-activedescendant": Y.value ? N.value : void 0,
+							"aria-autocomplete": "list",
+							"aria-controls": y(xt) ? `${y(j)}_listbox` : void 0,
+							"aria-describedby": e.ariaDescribedby,
+							"aria-expanded": Y.value,
+							autocomplete: e.autocomplete,
+							autofocus: e.autofocus,
+							class: Ee("bb-base-select__text-input"),
+							disabled: e.disabled,
+							inputmode: He.value,
+							placeholder: ht.value,
+							readonly: e.readonly || !e.allowWriting,
+							required: e.required && (!e.multiple || !e.modelValue.length),
+							role: "combobox",
+							size: "1",
+							style: Oe({ "--characters": L.value.length }),
+							type: "text",
+							onBlur: S(Je, ["stop"]),
+							onChange: S(Ye, ["stop"]),
+							onFocusOnce: S(qe, ["stop"]),
+							onFocus: S(Ke, ["stop"]),
+							onInput: S(Xe, ["stop"]),
+							onKeydown: [
+								x(S(it, ["stop"]), ["delete"]),
+								x(S(et, ["stop"]), ["left"]),
+								x(S($e, ["stop", "prevent"]), ["down"]),
+								x(S(nt, ["stop", "prevent"]), ["enter"]),
+								x(S(rt, ["stop", "prevent"]), ["esc"]),
+								x(S(Qe, ["stop", "prevent"]), ["up"]),
+								x(S(tt, ["stop"]), ["right"])
+							]
+						}, null, 44, Fe)), [[je, L.value]])])]),
+						_: 1
+					}), e.showChevron ? _(e.$slots, "chevron", {
+						key: 0,
+						loading: !!y(z),
+						shown: Y.value
+					}, () => [t[2] ||= f("svg", {
+						class: "bb-base-select__chevron",
+						viewBox: "0 0 24 24",
+						xmlns: "http://www.w3.org/2000/svg"
+					}, [f("path", {
+						d: "M7.41 8.58L12 13.17l4.59-4.59L18 10l-6 6l-6-6z",
+						fill: "currentColor"
+					})], -1)]) : u("", !0)]),
+					_: 3
+				}, 8, [
+					"append:icon",
+					"clearable",
+					"prepend:icon"
+				])], 512),
+				p(oe, {
+					modelValue: Y.value,
+					"onUpdate:modelValue": t[1] ||= (e) => Y.value = e,
+					anchor: E.value,
+					offset: 4,
+					"transition-duration": e.transitionDuration
+				}, {
+					default: b(() => [
+						Y.value ? _(e.$slots, "options:prepend:outer", {
+							key: 0,
+							focus: P
+						}) : u("", !0),
+						p(xe, {
+							ref_key: "optionsContainer",
+							ref: D,
+							compact: e.compact,
+							loading: K.value,
+							"loading-text": e.loadingText,
+							multiple: e.multiple,
+							"no-data-text": e.noDataText,
+							open: Y.value,
+							options: e.groupBy ? void 0 : _t.value,
+							groups: e.groupBy ? bt.value : void 0,
+							"header-height": e.headerHeight,
+							style: Oe(Ge.value),
+							"option-height": e.itemHeight,
+							"onFocused:change": Ze,
+							"onOption:selected": gt,
+							"onOption:unselected": J
+						}, {
+							"options:prepend": b(() => [Y.value ? _(e.$slots, "options:prepend", {
+								key: 0,
+								focus: P
+							}) : u("", !0)]),
+							loading: b(() => [_(e.$slots, "loading", { query: L.value })]),
+							"no-data": b(() => [_(e.$slots, "no-data", {
+								query: L.value,
+								focus: P
+							})]),
+							"options:append": b(() => [Y.value ? _(e.$slots, "options:append", {
+								key: 0,
+								focus: P
+							}) : u("", !0)]),
+							option: b((t) => [_(e.$slots, "option", Te({
+								hasErrors: e.hasErrors,
+								loading: K.value
+							}, t))]),
+							group: b((t) => [_(e.$slots, "group", De(we(t)))]),
+							_: 3
+						}, 8, [
+							"compact",
+							"loading",
+							"loading-text",
+							"multiple",
+							"no-data-text",
+							"open",
+							"options",
+							"groups",
+							"header-height",
+							"style",
+							"option-height"
+						]),
+						Y.value ? _(e.$slots, "options:append:outer", {
+							key: 1,
+							focus: P
+						}) : u("", !0)
+					]),
+					_: 3
+				}, 8, [
+					"modelValue",
+					"anchor",
+					"transition-duration"
+				]),
+				(h(!0), d(Se, null, ke(Dt.value, (e) => (h(), d("input", Te({
+					key: e.value,
+					ref_for: !0
+				}, e), null, 16))), 128))
+			]),
+			_: 3
+		}, 8, ["class"]));
+	}
+});
+//#endregion
+export { Ie as default };

package/dist/index188.js

@@ -1,5 +1,6 @@
-import o from "./index80.js";
-/* empty css        */
-export {
-  o as default
-};
+import e from "./index186.js";
+/* empty css         */
+//#region src/components/BaseSelect/BaseSelect.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/index189.js

@@ -1,5 +1,4 @@
-import o from "./index82.js";
-/* empty css        */
-export {
-  o as default
-};
+//#region src/utilities/functions/head.ts
+var e = (e) => e[0];
+//#endregion
+export { e as head };

package/dist/index19.js

@@ -0,0 +1,4 @@
+//#region node_modules/nanoid/url-alphabet/index.js
+var e = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+//#endregion
+export { e as urlAlphabet };

package/dist/index190.js

@@ -1,5 +1,8 @@
-import o from "./index84.js";
-/* empty css        */
-export {
-  o as default
+//#region src/utilities/functions/snapToStep.ts
+var e = (e, t, n, r) => {
+	if (r <= 0) throw Error("Step must be a positive number");
+	if (t > n) throw Error("Min must be less than or equal to Max");
+	return t + Math.round((Math.max(t, Math.min(n, e)) - t) / r) * r;
 };
+//#endregion
+export { e as snapToStep };

package/dist/index191.js

@@ -1,5 +1,7 @@
-import o from "./index86.js";
-/* empty css        */
-export {
-  o as default
-};
+//#region src/utilities/functions/transpose.ts
+function e(e, t, n, r, i) {
+	if (n === t) throw Error("Original boundaries cannot be equal.");
+	return r + (e - t) / (n - t) * (i - r);
+}
+//#endregion
+export { e as transpose };