bt-core-app 2.2.10 → 2.2.12

package/dist/bt-core/core/node_modules/vuetify/lib/components/VTextField/VTextField.mjs

@@ -0,0 +1,204 @@
+import { computed as x, ref as h, createVNode as p, mergeProps as b, createElementVNode as o, Fragment as C, withDirectives as te, normalizeClass as le, cloneVNode as ne, nextTick as P } from "vue";
+import "../../../../../../../_virtual/VTextField.sass.mjs";
+import { VCounter as oe } from "../VCounter/VCounter.mjs";
+import { makeVFieldProps as ue, VField as T } from "../VField/VField.mjs";
+import { makeVInputProps as ie, VInput as B } from "../VInput/VInput.mjs";
+import { makeAutocompleteProps as ae, useAutocomplete as re } from "../../composables/autocomplete.mjs";
+import { useAutofocus as ce } from "../../composables/autofocus.mjs";
+import { useFocus as se } from "../../composables/focus.mjs";
+import { forwardRefs as de } from "../../composables/forwardRefs.mjs";
+import { useProxiedModel as fe } from "../../composables/proxiedModel.mjs";
+import E from "../../directives/intersect/index.mjs";
+import { propsFactory as me } from "../../util/propsFactory.mjs";
+import { omit as M, filterInputAttrs as ve, callEvent as xe } from "../../util/helpers.mjs";
+import { genericComponent as Ve } from "../../util/defineComponent.mjs";
+import { useRender as ge } from "../../util/useRender.mjs";
+const ye = ["color", "file", "time", "date", "datetime-local", "week", "month"], he = me({
+  autofocus: Boolean,
+  counter: [Boolean, Number, String],
+  counterValue: [Number, Function],
+  prefix: String,
+  placeholder: String,
+  persistentPlaceholder: Boolean,
+  persistentCounter: Boolean,
+  suffix: String,
+  role: String,
+  type: {
+    type: String,
+    default: "text"
+  },
+  modelModifiers: Object,
+  ...ae(),
+  ...M(ie(), ["direction"]),
+  ...ue()
+}, "VTextField"), Be = Ve()({
+  name: "VTextField",
+  directives: {
+    vIntersect: E
+  },
+  inheritAttrs: !1,
+  props: he(),
+  emits: {
+    "click:control": (e) => !0,
+    "mousedown:control": (e) => !0,
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0
+  },
+  setup(e, O) {
+    let {
+      attrs: V,
+      emit: F,
+      slots: n
+    } = O;
+    const u = fe(e, "modelValue", void 0, (t) => Object.is(t, -0) ? "-0" : t), {
+      isFocused: a,
+      focus: k,
+      blur: j
+    } = se(e), {
+      onIntersect: z
+    } = ce(e), U = x(() => typeof e.counterValue == "function" ? e.counterValue(u.value) : typeof e.counterValue == "number" ? e.counterValue : (u.value ?? "").toString().length), $ = x(() => {
+      if (V.maxlength)
+        return V.maxlength;
+      if (!(!e.counter || typeof e.counter != "number" && typeof e.counter != "string"))
+        return e.counter;
+    }), _ = x(() => ["plain", "underlined"].includes(e.variant)), S = h(), A = h(), r = h(), f = re(e), q = x(() => ye.includes(e.type) || e.persistentPlaceholder || a.value || e.active);
+    function I() {
+      f.isSuppressing.value && f.update(), a.value || k(), P(() => {
+        var t;
+        r.value !== document.activeElement && ((t = r.value) == null || t.focus());
+      });
+    }
+    function G(t) {
+      F("mousedown:control", t), t.target !== r.value && (I(), t.preventDefault());
+    }
+    function H(t) {
+      F("click:control", t);
+    }
+    function J(t, l) {
+      t.stopPropagation(), I(), P(() => {
+        l(), xe(e["onClick:clear"], t);
+      });
+    }
+    function K(t) {
+      var v;
+      const l = t.target;
+      if (!((v = e.modelModifiers) != null && v.trim && ["text", "search", "password", "tel", "url"].includes(e.type))) {
+        u.value = l.value;
+        return;
+      }
+      const c = l.value, m = l.selectionStart, g = l.selectionEnd;
+      u.value = c, P(() => {
+        let s = 0;
+        c.trimStart().length === l.value.length && (s = c.length - l.value.length), m != null && (l.selectionStart = m - s), g != null && (l.selectionEnd = g - s);
+      });
+    }
+    return ge(() => {
+      const t = !!(n.counter || e.counter !== !1 && e.counter != null), l = !!(t || n.details), [c, m] = ve(V), {
+        modelValue: g,
+        ...v
+      } = B.filterProps(e), s = T.filterProps(e);
+      return p(B, b({
+        ref: S,
+        modelValue: u.value,
+        "onUpdate:modelValue": (d) => u.value = d,
+        class: ["v-text-field", {
+          "v-text-field--prefixed": e.prefix,
+          "v-text-field--suffixed": e.suffix,
+          "v-input--plain-underlined": _.value
+        }, e.class],
+        style: e.style
+      }, c, v, {
+        centerAffix: !_.value,
+        focused: a.value
+      }), {
+        ...n,
+        default: (d) => {
+          let {
+            id: i,
+            isDisabled: w,
+            isDirty: N,
+            isReadonly: L,
+            isValid: Q,
+            hasDetails: W,
+            reset: X
+          } = d;
+          return p(T, b({
+            ref: A,
+            onMousedown: G,
+            onClick: H,
+            "onClick:clear": (y) => J(y, X),
+            role: e.role
+          }, M(s, ["onClick:clear"]), {
+            id: i.value,
+            labelId: `${i.value}-label`,
+            active: q.value || N.value,
+            dirty: N.value || e.dirty,
+            disabled: w.value,
+            focused: a.value,
+            details: W.value,
+            error: Q.value === !1
+          }), {
+            ...n,
+            default: (y) => {
+              let {
+                props: {
+                  class: R,
+                  ...Y
+                },
+                controlRef: Z
+              } = y;
+              const D = o("input", b({
+                ref: (ee) => r.value = Z.value = ee,
+                value: u.value,
+                onInput: K,
+                autofocus: e.autofocus,
+                readonly: L.value,
+                disabled: w.value,
+                name: f.fieldName.value,
+                autocomplete: f.fieldAutocomplete.value,
+                placeholder: e.placeholder,
+                size: 1,
+                role: e.role,
+                type: e.type,
+                onFocus: k,
+                onBlur: j,
+                "aria-labelledby": `${i.value}-label`
+              }, Y, m), null);
+              return o(C, null, [e.prefix && o("span", {
+                class: "v-text-field__prefix"
+              }, [o("span", {
+                class: "v-text-field__prefix__text"
+              }, [e.prefix])]), te(n.default ? o("div", {
+                class: le(R),
+                "data-no-activator": ""
+              }, [n.default({
+                id: i
+              }), D]) : ne(D, {
+                class: R
+              }), [[E, z, null, {
+                once: !0
+              }]]), e.suffix && o("span", {
+                class: "v-text-field__suffix"
+              }, [o("span", {
+                class: "v-text-field__suffix__text"
+              }, [e.suffix])])]);
+            }
+          });
+        },
+        details: l ? (d) => {
+          var i;
+          return o(C, null, [(i = n.details) == null ? void 0 : i.call(n, d), t && o(C, null, [o("span", null, null), p(oe, {
+            active: e.persistentCounter || a.value,
+            value: U.value,
+            max: $.value,
+            disabled: e.disabled
+          }, n.counter)])]);
+        } : void 0
+      });
+    }), de({}, S, A, r);
+  }
+});
+export {
+  Be as VTextField,
+  he as makeVTextFieldProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VTextarea/VTextarea.mjs

@@ -0,0 +1,258 @@
+import { computed as C, ref as w, shallowRef as re, watchEffect as ce, onMounted as se, watch as f, onBeforeUnmount as de, nextTick as P, createVNode as H, mergeProps as A, createElementVNode as r, Fragment as M, withDirectives as U, normalizeClass as fe, vModelText as me } from "vue";
+import "../../../../../../../_virtual/VTextarea.sass.mjs";
+import "../../../../../../../_virtual/VTextField.sass.mjs";
+import { VCounter as ve } from "../VCounter/VCounter.mjs";
+import { makeVFieldProps as xe, VField as $ } from "../VField/VField.mjs";
+import { makeVInputProps as ge, VInput as O } from "../VInput/VInput.mjs";
+import { makeAutocompleteProps as he, useAutocomplete as we } from "../../composables/autocomplete.mjs";
+import { useAutofocus as ye } from "../../composables/autofocus.mjs";
+import { useFocus as Ve } from "../../composables/focus.mjs";
+import { forwardRefs as be } from "../../composables/forwardRefs.mjs";
+import { useProxiedModel as Fe } from "../../composables/proxiedModel.mjs";
+import W from "../../directives/intersect/index.mjs";
+import { useDisplay as Ce } from "../../composables/display.mjs";
+import { propsFactory as Pe } from "../../util/propsFactory.mjs";
+import { omit as pe, convertToUnit as z, filterInputAttrs as ke, callEvent as Ie, clamp as Ne } from "../../util/helpers.mjs";
+import { genericComponent as Re } from "../../util/defineComponent.mjs";
+import { useRender as Se } from "../../util/useRender.mjs";
+const He = Pe({
+  autoGrow: Boolean,
+  autofocus: Boolean,
+  counter: [Boolean, Number, String],
+  counterValue: Function,
+  prefix: String,
+  placeholder: String,
+  persistentPlaceholder: Boolean,
+  persistentCounter: Boolean,
+  noResize: Boolean,
+  rows: {
+    type: [Number, String],
+    default: 5,
+    validator: (e) => !isNaN(parseFloat(e))
+  },
+  maxHeight: {
+    type: [Number, String],
+    validator: (e) => !isNaN(parseFloat(e))
+  },
+  maxRows: {
+    type: [Number, String],
+    validator: (e) => !isNaN(parseFloat(e))
+  },
+  suffix: String,
+  modelModifiers: Object,
+  ...he(),
+  ...pe(ge(), ["direction"]),
+  ...xe()
+}, "VTextarea"), Le = Re()({
+  name: "VTextarea",
+  directives: {
+    vIntersect: W
+  },
+  inheritAttrs: !1,
+  props: He(),
+  emits: {
+    "click:control": (e) => !0,
+    "mousedown:control": (e) => !0,
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0,
+    "update:rows": (e) => !0
+  },
+  setup(e, j) {
+    let {
+      attrs: p,
+      emit: k,
+      slots: n
+    } = j;
+    const l = Fe(e, "modelValue"), {
+      isFocused: y,
+      focus: q,
+      blur: J
+    } = Ve(e), {
+      onIntersect: K
+    } = ye(e), L = C(() => typeof e.counterValue == "function" ? e.counterValue(l.value) : (l.value || "").toString().length), Q = C(() => {
+      if (p.maxlength)
+        return p.maxlength;
+      if (!(!e.counter || typeof e.counter != "number" && typeof e.counter != "string"))
+        return e.counter;
+    }), B = w(), b = w(), T = re(""), m = w(), I = w(0), {
+      platform: X
+    } = Ce(), F = we(e), Y = C(() => e.persistentPlaceholder || y.value || e.active);
+    function N() {
+      var t;
+      F.isSuppressing.value && F.update(), m.value !== document.activeElement && ((t = m.value) == null || t.focus()), y.value || q();
+    }
+    function Z(t) {
+      N(), k("click:control", t);
+    }
+    function ee(t) {
+      k("mousedown:control", t);
+    }
+    function te(t) {
+      t.stopPropagation(), N(), P(() => {
+        l.value = "", Ie(e["onClick:clear"], t);
+      });
+    }
+    function ae(t) {
+      var g;
+      const a = t.target;
+      if (!((g = e.modelModifiers) != null && g.trim)) {
+        l.value = a.value;
+        return;
+      }
+      const o = a.value, x = a.selectionStart, s = a.selectionEnd;
+      l.value = o, P(() => {
+        let d = 0;
+        o.trimStart().length === a.value.length && (d = o.length - a.value.length), x != null && (a.selectionStart = x - d), s != null && (a.selectionEnd = s - d);
+      });
+    }
+    const v = w(), V = w(Number(e.rows)), R = C(() => ["plain", "underlined"].includes(e.variant));
+    ce(() => {
+      e.autoGrow || (V.value = Number(e.rows));
+    });
+    function c() {
+      P(() => {
+        if (!m.value)
+          return;
+        if (X.value.firefox) {
+          I.value = 12;
+          return;
+        }
+        const {
+          offsetWidth: t,
+          clientWidth: a
+        } = m.value;
+        I.value = Math.max(0, t - a);
+      }), e.autoGrow && P(() => {
+        if (!v.value || !b.value)
+          return;
+        const t = getComputedStyle(v.value), a = getComputedStyle(b.value.$el), o = parseFloat(t.getPropertyValue("--v-field-padding-top")) + parseFloat(t.getPropertyValue("--v-input-padding-top")) + parseFloat(t.getPropertyValue("--v-field-padding-bottom")), x = v.value.scrollHeight, s = parseFloat(t.lineHeight), g = Math.max(parseFloat(e.rows) * s + o, parseFloat(a.getPropertyValue("--v-input-control-height"))), d = e.maxHeight ? parseFloat(e.maxHeight) : parseFloat(e.maxRows) * s + o || 1 / 0, u = Ne(x ?? 0, g, d);
+        V.value = Math.floor((u - o) / s), T.value = z(u);
+      });
+    }
+    se(c), f(l, c), f(() => e.rows, c), f(() => e.maxHeight, c), f(() => e.maxRows, c), f(() => e.density, c), f(V, (t) => {
+      k("update:rows", t);
+    });
+    let i;
+    return f(v, (t) => {
+      t ? (i = new ResizeObserver(c), i.observe(v.value)) : i == null || i.disconnect();
+    }), de(() => {
+      i == null || i.disconnect();
+    }), Se(() => {
+      const t = !!(n.counter || e.counter || e.counterValue), a = !!(t || n.details), [o, x] = ke(p), {
+        modelValue: s,
+        ...g
+      } = O.filterProps(e), d = {
+        ...$.filterProps(e),
+        "onClick:clear": te
+      };
+      return H(O, A({
+        ref: B,
+        modelValue: l.value,
+        "onUpdate:modelValue": (u) => l.value = u,
+        class: ["v-textarea v-text-field", {
+          "v-textarea--prefixed": e.prefix,
+          "v-textarea--suffixed": e.suffix,
+          "v-text-field--prefixed": e.prefix,
+          "v-text-field--suffixed": e.suffix,
+          "v-textarea--auto-grow": e.autoGrow,
+          "v-textarea--no-resize": e.noResize || e.autoGrow,
+          "v-input--plain-underlined": R.value
+        }, e.class],
+        style: [{
+          "--v-textarea-max-height": e.maxHeight ? z(e.maxHeight) : void 0,
+          "--v-textarea-scroll-bar-width": z(I.value)
+        }, e.style]
+      }, o, g, {
+        centerAffix: V.value === 1 && !R.value,
+        focused: y.value
+      }), {
+        ...n,
+        default: (u) => {
+          let {
+            id: h,
+            isDisabled: _,
+            isDirty: D,
+            isReadonly: le,
+            isValid: oe,
+            hasDetails: ne
+          } = u;
+          return H($, A({
+            ref: b,
+            style: {
+              "--v-textarea-control-height": T.value
+            },
+            onClick: Z,
+            onMousedown: ee,
+            "onClick:prependInner": e["onClick:prependInner"],
+            "onClick:appendInner": e["onClick:appendInner"]
+          }, d, {
+            id: h.value,
+            active: Y.value || D.value,
+            labelId: `${h.value}-label`,
+            centerAffix: V.value === 1 && !R.value,
+            dirty: D.value || e.dirty,
+            disabled: _.value,
+            focused: y.value,
+            details: ne.value,
+            error: oe.value === !1
+          }), {
+            ...n,
+            default: (ie) => {
+              let {
+                props: {
+                  class: E,
+                  ...G
+                },
+                controlRef: ue
+              } = ie;
+              return r(M, null, [e.prefix && r("span", {
+                class: "v-text-field__prefix"
+              }, [e.prefix]), U(r("textarea", A({
+                ref: (S) => m.value = ue.value = S,
+                class: E,
+                value: l.value,
+                onInput: ae,
+                autofocus: e.autofocus,
+                readonly: le.value,
+                disabled: _.value,
+                placeholder: e.placeholder,
+                rows: e.rows,
+                name: F.fieldName.value,
+                autocomplete: F.fieldAutocomplete.value,
+                onFocus: N,
+                onBlur: J,
+                "aria-labelledby": `${h.value}-label`
+              }, G, x), null), [[W, {
+                handler: K
+              }, null, {
+                once: !0
+              }]]), e.autoGrow && U(r("textarea", {
+                class: fe([E, "v-textarea__sizer"]),
+                id: `${G.id}-sizer`,
+                "onUpdate:modelValue": (S) => l.value = S,
+                ref: v,
+                readonly: !0,
+                "aria-hidden": "true"
+              }, null), [[me, l.value]]), e.suffix && r("span", {
+                class: "v-text-field__suffix"
+              }, [e.suffix])]);
+            }
+          });
+        },
+        details: a ? (u) => {
+          var h;
+          return r(M, null, [(h = n.details) == null ? void 0 : h.call(n, u), t && r(M, null, [r("span", null, null), H(ve, {
+            active: e.persistentCounter || y.value,
+            value: L.value,
+            max: Q.value,
+            disabled: e.disabled
+          }, n.counter)])]);
+        } : void 0
+      });
+    }), be({}, B, b, m);
+  }
+});
+export {
+  Le as VTextarea,
+  He as makeVTextareaProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VToolbar/VToolbar.mjs

@@ -0,0 +1,167 @@
+import { shallowRef as B, computed as v, createVNode as o, normalizeClass as N, normalizeStyle as E, createElementVNode as a } from "vue";
+import "../../../../../../../_virtual/VToolbar.sass.mjs";
+import { VToolbarTitle as H } from "./VToolbarTitle.mjs";
+import { VExpandTransition as I } from "../transitions/index.mjs";
+import { makeBorderProps as R, useBorder as p } from "../../composables/border.mjs";
+import { useBackgroundColor as D } from "../../composables/color.mjs";
+import { makeComponentProps as w } from "../../composables/component.mjs";
+import { provideDefaults as z } from "../../composables/defaults.mjs";
+import { makeElevationProps as L, useElevation as $ } from "../../composables/elevation.mjs";
+import { useRtl as F } from "../../composables/locale.mjs";
+import { makeLocationProps as U, useLocation as j } from "../../composables/location.mjs";
+import { makeRoundedProps as q, useRounded as A } from "../../composables/rounded.mjs";
+import { makeTagProps as G } from "../../composables/tag.mjs";
+import { makeThemeProps as J, provideTheme as K } from "../../composables/theme.mjs";
+import { VImg as M } from "../VImg/VImg.mjs";
+import { VDefaultsProvider as m } from "../VDefaultsProvider/VDefaultsProvider.mjs";
+import { propsFactory as O } from "../../util/propsFactory.mjs";
+import { genericComponent as Q } from "../../util/defineComponent.mjs";
+import { useRender as W } from "../../util/useRender.mjs";
+import { convertToUnit as l } from "../../util/helpers.mjs";
+const X = [null, "prominent", "default", "comfortable", "compact"], Y = O({
+  absolute: Boolean,
+  collapse: Boolean,
+  collapsePosition: {
+    type: String,
+    default: "start"
+  },
+  color: String,
+  density: {
+    type: String,
+    default: "default",
+    validator: (e) => X.includes(e)
+  },
+  extended: {
+    type: Boolean,
+    default: null
+  },
+  extensionHeight: {
+    type: [Number, String],
+    default: 48
+  },
+  flat: Boolean,
+  floating: Boolean,
+  height: {
+    type: [Number, String],
+    default: 64
+  },
+  image: String,
+  title: String,
+  ...R(),
+  ...w(),
+  ...L(),
+  ...U(),
+  ...q(),
+  ...G({
+    tag: "header"
+  }),
+  ...J()
+}, "VToolbar"), xe = Q()({
+  name: "VToolbar",
+  props: Y(),
+  setup(e, b) {
+    var d;
+    let {
+      slots: t
+    } = b;
+    const {
+      backgroundColorClasses: h,
+      backgroundColorStyles: y
+    } = D(() => e.color), {
+      borderClasses: x
+    } = p(e), {
+      elevationClasses: k
+    } = $(e), {
+      locationStyles: T
+    } = j(e), {
+      roundedClasses: V
+    } = A(e), {
+      themeClasses: C
+    } = K(e), {
+      rtlClasses: P
+    } = F(), n = B(e.extended === null ? !!((d = t.extension) != null && d.call(t)) : e.extended), i = v(() => parseInt(Number(e.height) + (e.density === "prominent" ? Number(e.height) : 0) - (e.density === "comfortable" ? 8 : 0) - (e.density === "compact" ? 16 : 0), 10)), r = v(() => n.value ? parseInt(Number(e.extensionHeight) + (e.density === "prominent" ? Number(e.extensionHeight) : 0) - (e.density === "comfortable" ? 4 : 0) - (e.density === "compact" ? 8 : 0), 10) : 0);
+    return z({
+      VBtn: {
+        variant: "text"
+      }
+    }), W(() => {
+      var u;
+      const S = !!(e.title || t.title), _ = !!(t.image || e.image), s = (u = t.extension) == null ? void 0 : u.call(t);
+      return n.value = e.extended === null ? !!s : e.extended, o(e.tag, {
+        class: N(["v-toolbar", `v-toolbar--collapse-${e.collapsePosition}`, {
+          "v-toolbar--absolute": e.absolute,
+          "v-toolbar--collapse": e.collapse,
+          "v-toolbar--flat": e.flat,
+          "v-toolbar--floating": e.floating,
+          [`v-toolbar--density-${e.density}`]: !0
+        }, h.value, x.value, k.value, V.value, C.value, P.value, e.class]),
+        style: E([y.value, T.value, e.style])
+      }, {
+        default: () => [_ && a("div", {
+          key: "image",
+          class: "v-toolbar__image"
+        }, [t.image ? o(m, {
+          key: "image-defaults",
+          disabled: !e.image,
+          defaults: {
+            VImg: {
+              cover: !0,
+              src: e.image
+            }
+          }
+        }, t.image) : o(M, {
+          key: "image-img",
+          cover: !0,
+          src: e.image
+        }, null)]), o(m, {
+          defaults: {
+            VTabs: {
+              height: l(i.value)
+            }
+          }
+        }, {
+          default: () => {
+            var c, f, g;
+            return [a("div", {
+              class: "v-toolbar__content",
+              style: {
+                height: l(i.value)
+              }
+            }, [t.prepend && a("div", {
+              class: "v-toolbar__prepend"
+            }, [(c = t.prepend) == null ? void 0 : c.call(t)]), S && o(H, {
+              key: "title",
+              text: e.title
+            }, {
+              text: t.title
+            }), (f = t.default) == null ? void 0 : f.call(t), t.append && a("div", {
+              class: "v-toolbar__append"
+            }, [(g = t.append) == null ? void 0 : g.call(t)])])];
+          }
+        }), o(m, {
+          defaults: {
+            VTabs: {
+              height: l(r.value)
+            }
+          }
+        }, {
+          default: () => [o(I, null, {
+            default: () => [n.value && a("div", {
+              class: "v-toolbar__extension",
+              style: {
+                height: l(r.value)
+              }
+            }, [s])]
+          })]
+        })]
+      });
+    }), {
+      contentHeight: i,
+      extensionHeight: r
+    };
+  }
+});
+export {
+  xe as VToolbar,
+  Y as makeVToolbarProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VToolbar/VToolbarItems.mjs

@@ -0,0 +1,38 @@
+import { toRef as e, createElementVNode as a, normalizeClass as i, normalizeStyle as n } from "vue";
+import { makeComponentProps as l } from "../../composables/component.mjs";
+import { provideDefaults as s } from "../../composables/defaults.mjs";
+import { makeVariantProps as p } from "../../composables/variant.mjs";
+import { propsFactory as f } from "../../util/propsFactory.mjs";
+import { genericComponent as c } from "../../util/defineComponent.mjs";
+import { useRender as V } from "../../util/useRender.mjs";
+const v = f({
+  ...l(),
+  ...p({
+    variant: "text"
+  })
+}, "VToolbarItems"), k = c()({
+  name: "VToolbarItems",
+  props: v(),
+  setup(o, m) {
+    let {
+      slots: r
+    } = m;
+    return s({
+      VBtn: {
+        color: e(() => o.color),
+        height: "inherit",
+        variant: e(() => o.variant)
+      }
+    }), V(() => {
+      var t;
+      return a("div", {
+        class: i(["v-toolbar-items", o.class]),
+        style: n(o.style)
+      }, [(t = r.default) == null ? void 0 : t.call(r)]);
+    }), {};
+  }
+});
+export {
+  k as VToolbarItems,
+  v as makeVToolbarItemsProps
+};