yuyeon 0.0.0 → 0.0.3

package/dist/yuyeon.mjs

@@ -0,0 +1,3607 @@
+import { defineComponent as $, h as _, getCurrentInstance as he, createVNode as l, withDirectives as pe, resolveDirective as dt, ref as C, toRef as ie, computed as w, watch as I, nextTick as ve, withKeys as Xt, createTextVNode as ae, watchEffect as Ne, withModifiers as Re, Transition as Me, reactive as re, Teleport as Zt, mergeProps as oe, vShow as Jt, Fragment as P, onScopeDispose as Qt, effectScope as ft, toRaw as ht, inject as en, provide as tn, onBeforeUnmount as nn, readonly as an } from "vue";
+const rn = $({
+  name: "YApp",
+  setup(e, { slots: t }) {
+    return () => _(
+      "y-app",
+      { class: "y-app" },
+      _("div", { class: "y-app__container" }, t)
+    );
+  }
+});
+const pt = "y-plate-wave__animation";
+function vt(e) {
+  if (!e)
+    return;
+  const t = document.createElement("span");
+  t.className = pt, e.appendChild(t), t.dataset.activated = String(performance.now());
+}
+function Fe(e) {
+  if (!e)
+    return;
+  const t = e.getElementsByClassName(pt);
+  if (t.length === 0)
+    return;
+  const n = t[t.length - 1];
+  if (n.dataset.isHiding)
+    return;
+  n.dataset.isHiding = "true";
+  const i = performance.now() - Number(n.dataset.activated), a = Math.max(250 - i, 0);
+  setTimeout(() => {
+    n && e.removeChild(n);
+  }, a + 300);
+}
+let _e = !1;
+function mt(e) {
+  vt(e.currentTarget);
+}
+function X(e) {
+  Fe(e.currentTarget);
+}
+function on(e) {
+}
+function yt(e) {
+  !_e && (e.key === "Enter" || e.key === "Space") && (_e = !0, vt(e.currentTarget));
+}
+function gt(e) {
+  _e = !1, Fe(e.currentTarget);
+}
+function bt(e) {
+  e.removeEventListener("mousedown", mt), e.removeEventListener("mouseup", X), e.removeEventListener("mouseleave", X), e.removeEventListener("keydown", yt), e.removeEventListener("keyup", gt);
+}
+function Ge(e, t, n = !1) {
+  const { value: i, modifiers: a } = t, r = !!i;
+  if (r || Fe(e), r && n) {
+    if (a.stop) {
+      e.addEventListener("mousedown", on);
+      return;
+    }
+    e.addEventListener("mousedown", mt), e.addEventListener("mouseup", X), e.addEventListener("mouseleave", X), e.addEventListener("keydown", yt), e.addEventListener("keyup", gt), e.addEventListener("blur", X);
+  } else
+    !r && !n && bt(e);
+}
+const Ce = {
+  mounted(e, t) {
+    Ge(e, t, !0);
+  },
+  updated(e, t) {
+    t.value !== t.oldValue && Ge(e, t);
+  },
+  unmount(e) {
+    bt(e);
+  }
+};
+function sn(e) {
+  if (e && e[0] === "#") {
+    const t = e.substring(1, e.length), n = t.length, i = [];
+    if (n === 3 || n === 6) {
+      const a = n === 6 ? 2 : 1;
+      for (let r = 0; r < 3; r += 1) {
+        const s = t.substring(
+          r * a,
+          r * a + a
+        );
+        i.push(Number.parseInt(s, 16));
+      }
+      return i;
+    }
+  }
+}
+const ln = /rgb(a?)\((?<v>.*)\)/, un = /#([0-9a-fA-F]{3,6,8})/;
+function cn(e) {
+  return ln.test(e) || un.test(e);
+}
+function wt(e, t = "px") {
+  if (e === "" || e === null || e === void 0)
+    return;
+  let n = Number(e);
+  if (!(isNaN(n) || !isFinite(n)))
+    return `${n}${t}`;
+}
+function H(e, t) {
+  return e ? Object.prototype.hasOwnProperty.call(e, t) : !1;
+}
+function dn(e, t, n) {
+  const i = t.length - 1;
+  let a = e;
+  if (i < 0)
+    return a === void 0 ? n : a;
+  for (let r = 0; r < i; r += 1) {
+    if (a == null)
+      return n;
+    a = a[t[r]];
+  }
+  return a == null || a[t[i]] === void 0 ? n : a[t[i]];
+}
+function Se(e = {}, t = {}, n) {
+  const i = { ...e };
+  for (const a in t) {
+    const r = i[a], s = t[a];
+    if (Array.isArray(r) && Array.isArray(s) && n) {
+      i[a] = n(r, s);
+      continue;
+    }
+    if (typeof r == "object" && typeof s == "object") {
+      i[a] = Se(r, s, n);
+      continue;
+    }
+    i[a] = s;
+  }
+  return i;
+}
+function Z(e, t, n) {
+  let i = t;
+  return e == null || !i || typeof i != "string" ? n : e[i] !== void 0 ? e[i] : (i = i.replace(/\[(\w+)\]/g, ".$1"), i = i.replace(/^\./, ""), dn(e, i.split("."), n));
+}
+function F(e, t = "default", n, i = !1) {
+  var a;
+  if ((a = e.$slots) != null && a[t])
+    return e.$slots[t](n instanceof Function ? n() : n).filter((s) => {
+      var o;
+      return ((o = s.el) == null ? void 0 : o.nodeType) !== 8;
+    });
+}
+function fn() {
+  const e = he();
+  return e == null ? void 0 : e.uid;
+}
+function W(e) {
+  const t = {};
+  return typeof e == "string" ? t[e] = !0 : Array.isArray(e) ? e.reduce((n, i) => (n[i] = !0, n), t) : typeof e == "object" && Object.keys(e).reduce((n, i) => (n[i] = !!e[i], n), t), t;
+}
+function hn(e) {
+  return e && H(e, "$el") ? e.$el : e;
+}
+function ee(e, t) {
+  return (n) => Object.keys(e).reduce((i, a) => {
+    const r = e[a], o = typeof r == "object" && r != null && !Array.isArray(r) ? r : { type: r };
+    return n && a in n ? i[a] = {
+      ...o,
+      default: n[a]
+    } : i[a] = o, t && !i[a].source && (i[a].source = t), i;
+  }, {});
+}
+const pn = "YSpinnerRing", _t = /* @__PURE__ */ $({
+  name: pn,
+  render() {
+    return l("svg", {
+      class: "y-spinner-ring",
+      width: "48",
+      height: "48",
+      viewBox: "0 0 48 48",
+      xmlns: "http://www.w3.org/2000/svg"
+    }, [l("circle", {
+      class: "y-spinner-ring__circle",
+      cx: "24",
+      cy: "24",
+      r: "18",
+      "stroke-width": "4",
+      "stroke-dasharray": "113.097",
+      "stroke-dashoffset": "113.097"
+    }, null)]);
+  }
+});
+const R = "y-button", Ct = {
+  loading: Boolean,
+  outlined: {
+    type: Boolean,
+    default: !1
+  },
+  rounded: {
+    type: Boolean,
+    default: !1
+  },
+  filled: {
+    type: Boolean,
+    default: !1
+  },
+  disabled: {
+    type: Boolean
+  },
+  text: {
+    type: Boolean
+  },
+  color: {
+    type: String
+  },
+  noWave: {
+    type: Boolean,
+    default: !1
+  },
+  variation: {
+    type: String
+  }
+}, $e = $({
+  name: "YButton",
+  directives: {
+    PlateWave: Ce
+  },
+  props: {
+    ...Ct
+  },
+  computed: {
+    variations() {
+      const { variation: e } = this;
+      return e ? e.split(",").map((t) => t.trim()) : [];
+    },
+    small() {
+      return this.variations.includes("small");
+    },
+    icon() {
+      return this.variations.includes("icon");
+    },
+    //
+    classes() {
+      return {
+        [`${R}--outlined`]: this.outlined,
+        [`${R}--loading`]: this.loading,
+        [`${R}--rounded`]: this.rounded,
+        [`${R}--filled`]: this.filled,
+        [`${R}--disabled`]: this.disabled,
+        [`${R}--text`]: this.text,
+        [`${R}--small`]: this.small,
+        [`${R}--icon`]: this.icon,
+        [`${R}--color`]: this.color
+      };
+    },
+    styles() {
+      let { color: e } = this;
+      return e && !cn(e) && (e = `rgba(var(--y-theme--${e}), 1)`), {
+        ["--y-button__color"]: e
+      };
+    }
+  },
+  methods: {
+    createContent() {
+      const e = F(this, "default"), t = [];
+      return this.loading && t.push(_(_t, { width: "24", height: "24" })), t.push(e), _("span", { class: "y-button__content" }, t);
+    },
+    getClasses() {
+      return this.classes;
+    },
+    /// Events
+    onClick(e) {
+      e.preventDefault(), this.loading;
+    }
+  },
+  render() {
+    const { onClick: e, styles: t, noWave: n, loading: i } = this;
+    return pe(
+      _(
+        "button",
+        {
+          class: {
+            ...this.getClasses(),
+            [`${R}`]: !0
+          },
+          style: t,
+          onClick: e,
+          "^disabled": this.disabled ? !0 : void 0
+        },
+        this.createContent()
+      ),
+      [[Ce, !n && !i]]
+    );
+  }
+}), vn = $({
+  name: "DiMixin",
+  inject: {
+    theme: {
+      from: "theme"
+    },
+    form$: {
+      default: null
+    }
+  },
+  mounted() {
+    var e;
+    (e = this.form$) == null || e.register(this);
+  },
+  beforeUnmount() {
+    var e;
+    (e = this.form$) == null || e.unregister(this);
+  }
+});
+const M = "y-input";
+let Xe = 0;
+const se = {
+  name: String,
+  width: {
+    type: [String, Number]
+  },
+  height: [Number, String],
+  displayTag: {
+    type: String,
+    default: "div"
+  },
+  outlined: Boolean,
+  filled: {
+    type: Boolean
+  },
+  ceramic: Boolean,
+  label: String,
+  modelValue: { type: [String, Number] },
+  autoSelect: {
+    type: Boolean,
+    default: !0
+  },
+  floated: { type: Boolean, default: () => !1 },
+  placeholder: String,
+  loading: Boolean,
+  // validate
+  readonly: Boolean,
+  disabled: Boolean,
+  status: {
+    type: String,
+    validator(e) {
+      return ["success", "warning", "error"].includes(e);
+    }
+  },
+  validators: Array
+}, xe = $({
+  name: M,
+  mixins: [vn],
+  props: se,
+  emits: ["error", "click", "mousedown", "mouseup", "focus", "blur", "click:prepend", "update:modelValue"],
+  data() {
+    const e = Xe.toString();
+    return Xe += 1, {
+      isFocused: !1,
+      iid: e,
+      lazyValue: void 0,
+      inValue: "",
+      hasMouseDown: !1,
+      errorResult: void 0,
+      inError: !1
+    };
+  },
+  computed: {
+    classes() {
+      return {
+        "y-input--outlined": !this.ceramic && !!this.outlined,
+        "y-input--filled": !!this.filled,
+        "y-input--focused": this.isFocused,
+        "y-input--ceramic": !!this.ceramic,
+        "y-input--readonly": !!this.readonly,
+        "y-input--has-value": !!this.inValue,
+        "y-input--disabled": !!this.disabled,
+        "y-input--error": this.isError,
+        "y-input--success": this.isSuccess
+      };
+    },
+    displayStyles() {
+      let { width: e } = this;
+      return Number.isNaN(Number(e)) || (e = `${e}px`), {
+        width: e,
+        height: this.getDisplayHeight()
+      };
+    },
+    attrId() {
+      return this.$attrs.id ?? `y-input--${this.iid}`;
+    },
+    isFloatedLabel() {
+      return this.floated || !!this.placeholder || !this.placeholder && this.isFocused || !!this.inValue;
+    },
+    formLoading() {
+      const e = this.form$;
+      return e ? e.loading : !1;
+    },
+    isError() {
+      return this.status === "error" || this.inError;
+    },
+    isSuccess() {
+      return !this.isError && this.status === "success";
+    }
+  },
+  methods: {
+    createPrependOuter() {
+      const e = F(this, "prepend-outer");
+      return e ? _("div", { class: `${M}__prepend-outer` }, e) : void 0;
+    },
+    createAppendOuter() {
+      const e = F(this, "append-outer");
+      return e ? _("div", { class: `${M}__append-outer` }, e) : void 0;
+    },
+    createLabelSlot() {
+      const e = F(this, "label");
+      if (!e) {
+        if (this.label)
+          return [this.label];
+        if (this.placeholder && !this.inValue)
+          return [this.placeholder];
+      }
+      return e ? [e] : [];
+    },
+    createLabel() {
+      if (this.label || F(this, "label"))
+        return _(
+          "label",
+          {
+            class: {
+              [`${M}__label`]: !0,
+              "y-input__label--floated": this.isFloatedLabel
+            },
+            ".for": this.attrId
+          },
+          this.createLabelSlot()
+        );
+    },
+    createDefaultChildren() {
+      const { modelValue: e } = this;
+      return [this.createLabel(), e == null ? void 0 : e.toString()];
+    },
+    createDefault() {
+      const { modelValue: e, formLoading: t, attrId: n } = this;
+      return F(this, "default", { value: e, formLoading: t, attrId: n }) ?? _(
+        "div",
+        {
+          [`.${M}__value`]: !0,
+          ".data-id": this.attrId,
+          ".tabindex": 0,
+          onFocus: this.onFocus,
+          onBlur: this.onBlur
+        },
+        this.createDefaultChildren()
+      );
+    },
+    createPrepend() {
+      const e = F(this, "prepend", { error: this.isError });
+      return e ? _(
+        "div",
+        {
+          class: "y-input__prepend",
+          onClick: this.onClickPrepend
+        },
+        e
+      ) : void 0;
+    },
+    createAppend() {
+      return F(this, "append");
+    },
+    getDisplayHeight() {
+      const { height: e } = this;
+      return isNaN(Number(e)) ? e : `${e}px`;
+    },
+    createDisplay() {
+      return _(
+        "div",
+        {
+          class: {
+            [`${M}__display`]: !0
+          },
+          // onClick: this.onClick,
+          // onMousedown: this.onMousedown,
+          // onMouseup: this.onMouseup,
+          ref: "display",
+          style: {
+            ...this.displayStyles
+          }
+        },
+        [
+          _("div", { class: `${M}__plate` }),
+          this.createPrepend(),
+          this.createDefault(),
+          this.createAppend()
+        ]
+      );
+    },
+    createHelperText() {
+      const e = F(this, "helper-text", {
+        error: this.status === "error" || this.inError,
+        errorResult: this.errorResult
+      }), t = [];
+      return e ? t.push(_("span", {}, e)) : t.push(this.errorResult), _("div", { class: `${M}__helper-text` }, t);
+    },
+    createStackChildren() {
+      return [this.createDisplay(), this.createHelperText()];
+    },
+    createStack() {
+      return _(
+        "div",
+        {
+          class: `${M}__stack`,
+          ref: "stack"
+        },
+        this.createStackChildren()
+      );
+    },
+    createContent() {
+      return [
+        this.createPrependOuter(),
+        this.createStack(),
+        this.createAppendOuter()
+      ];
+    },
+    //
+    onClick(e) {
+      var t;
+      this.autoSelect && e.target && ((t = window.getSelection()) == null || t.selectAllChildren(e.target)), this.$emit("click", e);
+    },
+    onMousedown(e) {
+      this.hasMouseDown = !0, this.$emit("mousedown", e);
+    },
+    onMouseup(e) {
+      this.hasMouseDown = !1, this.$emit("mouseup", e);
+    },
+    onFocus(e) {
+      this.isFocused = !0, this.$emit("focus", e);
+    },
+    onBlur(e) {
+      this.isFocused = !1, this.invokeValidators(), this.$emit("blur", e);
+    },
+    onClickPrepend(e) {
+      this.$emit("click:prepend", e);
+    },
+    onChange(e) {
+      this.invokeValidators();
+    },
+    //
+    invokeValidators() {
+      const { validators: e, inValue: t, $attrs: n } = this, { required: i } = n;
+      this.resetError();
+      let a = !0;
+      return Array.isArray(e) && e.some((r) => {
+        const s = r(t);
+        return typeof s == "string" ? (this.inError = !0, this.errorResult = s, a = !1, !0) : s === !1 ? (this.inError = !0, this.errorResult = "", a = !1, !0) : !1;
+      }), a && i && !t ? (this.inError = !0, !1) : a;
+    },
+    resetError() {
+      this.inError = !1, this.errorResult = void 0;
+    },
+    getClasses() {
+      return this.classes;
+    }
+  },
+  watch: {
+    modelValue(e) {
+      this.readonly || (this.inValue = e);
+    },
+    readonly(e) {
+      e || (this.inValue = this.modelValue);
+    },
+    inValue(e) {
+      this.readonly || this.$emit("update:modelValue", e);
+    },
+    isError(e) {
+      this.$emit("error", e);
+    }
+  },
+  created() {
+    this.inValue = this.modelValue;
+  },
+  render() {
+    var e;
+    return pe(
+      _(
+        "div",
+        {
+          class: { ...this.getClasses(), [`${M}`]: !0 }
+        },
+        this.createContent()
+      ),
+      [
+        [
+          dt("theme"),
+          (e = this == null ? void 0 : this.theme) != null && e.dark ? "dark" : "light"
+        ]
+      ]
+    );
+  }
+}), St = /* @__PURE__ */ $({
+  name: "YIconClear",
+  setup() {
+    return () => l("svg", {
+      viewBox: "0 0 16 16",
+      xmlns: "http://www.w3.org/2000/svg"
+    }, [l("path", {
+      d: "m8 1.5c-3.5839 0-6.5 2.9161-6.5 6.5 0 3.5839 2.9161 6.5 6.5 6.5 3.5839 0 6.5-2.9161 6.5-6.5 0-3.5839-2.9161-6.5-6.5-6.5zm-2 4a.5.5 0 01.35352.14648l1.6465 1.6465 1.6465-1.6465a.5.5 0 01.35352-.14648.5.5 0 01.35352.14648.5.5 0 010 .70703l-1.6465 1.6465 1.6465 1.6465a.5.5 0 010 .70703.5.5 0 01-.70703 0l-1.6465-1.6465-1.6465 1.6465a.5.5 0 01-.70703 0 .5.5 0 010-.70703l1.6465-1.6465-1.6465-1.6465a.5.5 0 010-.70703.5.5 0 01.35352-.14648z",
+      fill: "currentColor",
+      "stroke-miterlimit": "10"
+    }, null)]);
+  }
+});
+const ye = "y-field-input", ke = $({
+  name: "YFieldInput",
+  props: {
+    ...se,
+    clearable: Boolean,
+    inputAlign: String,
+    displayText: [String, Function],
+    whenInputValid: [Boolean, Number],
+    tabindex: {
+      type: String,
+      default: "0"
+    },
+    type: {
+      type: String,
+      default: "text"
+    }
+  },
+  emits: [
+    "update:modelValue",
+    "input",
+    "change",
+    "click",
+    "mousedown",
+    "mouseup",
+    "keydown",
+    "keyup",
+    "focus",
+    "blur"
+  ],
+  setup(e, { attrs: t, expose: n, emit: i, slots: a }) {
+    const r = C(), s = C(), o = C(!1), c = C(""), p = C(""), h = ie(e, "type"), u = w(() => {
+      var f;
+      return {
+        ...((f = r.value) == null ? void 0 : f.classes) || {},
+        "y-input--focused": o.value,
+        [ye]: !0
+      };
+    });
+    function d(f) {
+      var S;
+      (S = s.value) == null || S.focus(), i("click", f);
+    }
+    function g(f) {
+      o.value = !0, p.value = c.value, i("focus", f);
+    }
+    function v(f) {
+      o.value = !1, i("blur", f), m();
+    }
+    function y(f) {
+      i("input", f);
+      const S = f.target;
+      c.value = S == null ? void 0 : S.value, p.value = S == null ? void 0 : S.value, e.whenInputValid;
+    }
+    function x(f) {
+      i("change", c.value);
+    }
+    function A(f) {
+      i("keydown", f);
+    }
+    function b(f) {
+      i("keyup", f);
+    }
+    function k(f) {
+      V();
+    }
+    function T(f) {
+      (f.code === "Space" || f.code === "Enter") && V();
+    }
+    function Y() {
+      var f;
+      (f = s.value) == null || f.focus();
+    }
+    function O() {
+      var f;
+      (f = s.value) == null || f.select();
+    }
+    function V() {
+      c.value = "", p.value = "", i("update:modelValue", c.value);
+    }
+    function m() {
+      const f = he(), { displayText: S } = e;
+      if (S !== void 0) {
+        let D = c.value;
+        typeof S == "string" && (D = S), S && typeof S == "function" && (D = S.call(f, D)), ve(() => {
+          p.value = D;
+        });
+      }
+    }
+    I(
+      () => e.modelValue,
+      (f) => {
+        c.value = f, p.value = f;
+      },
+      {
+        immediate: !0
+      }
+    ), I(c, (f) => {
+      o.value ? p.value = f : m();
+    }), n({
+      focus: Y,
+      select: O,
+      clear: V,
+      inputRef: s
+    });
+    const B = () => {
+      const f = {};
+      for (const S in se)
+        f[S] = e[S];
+      return f;
+    };
+    function E(f) {
+      i("update:modelValue", f);
+    }
+    return () => _(
+      xe,
+      {
+        class: u.value,
+        ref: r,
+        ...B(),
+        modelValue: c.value,
+        "onUpdate:modelValue": E,
+        onClick: d
+      },
+      {
+        prepend: a.prepend ? (...f) => {
+          var qe;
+          const S = [], D = (qe = a.prepend) == null ? void 0 : qe.call(a, ...f);
+          if (D)
+            S.push(D);
+          else
+            return;
+          return S;
+        } : void 0,
+        default: (f) => _(
+          "div",
+          {
+            class: `${ye}__field`,
+            "data-id": f.attrId,
+            ref: "field"
+          },
+          [
+            xe.methods.createLabel.call(r),
+            _("input", {
+              ".value": p.value,
+              ".id": f.attrId,
+              "^type": h.value,
+              readonly: e.readonly || e.loading || f.formLoading,
+              ".placeholder": e.placeholder,
+              ".disabled": e.disabled,
+              "^tabindex": e.tabindex || "0",
+              autocomplete: t.autocomplete,
+              maxlength: t.maxlength,
+              onInput: y,
+              onFocus: g,
+              onBlur: v,
+              onChange: x,
+              onKeydown: A,
+              onKeyup: b,
+              style: {
+                textAlign: e.inputAlign
+              },
+              ref: s
+            })
+          ]
+        ),
+        append: () => {
+          const f = [];
+          e.clearable && c.value && f.push(
+            _("div", { class: "y-input__append y-input__append--clear" }, [
+              _(
+                "button",
+                {
+                  class: `${ye}__clear`,
+                  onClick: k,
+                  onKeydown: T,
+                  "^tabindex": "2"
+                },
+                [_(St)]
+              )
+            ])
+          );
+          const S = a.append;
+          return S && f.push(_("div", { class: "y-input__append" }, S())), f;
+        },
+        "helper-text": () => {
+          var f;
+          return (f = a["helper-text"]) == null ? void 0 : f.call(a);
+        }
+      }
+    );
+  }
+}), mn = $({
+  data: () => ({
+    attrs_$: {},
+    listeners_$: {}
+  }),
+  watch: {
+    // Work around unwanted re-renders: https://github.com/vuejs/vue/issues/10115
+    // Make sure to use `v-bind="$data.$_attrs"` instead of `v-bind="$attrs"`
+    $attrs: {
+      handler(e) {
+        for (const t in e)
+          this.$data.attrs_$[t] = e[t];
+      },
+      immediate: !0
+    },
+    $listeners: {
+      handler(e) {
+        for (const t in e)
+          this.$data.listeners_$[t] = e[t];
+      },
+      immediate: !0
+    }
+  }
+}), Ze = "y-form", yn = ["form", "div", "section", "article"], gn = $({
+  name: Ze,
+  inheritAttrs: !1,
+  mixins: [mn],
+  provide() {
+    return {
+      form$: this
+    };
+  },
+  props: {
+    tag: {
+      type: String,
+      default: "form",
+      validator(e) {
+        return yn.includes(e);
+      }
+    },
+    loading: Boolean
+  },
+  data() {
+    return {
+      inputs: {},
+      formData: {}
+    };
+  },
+  methods: {
+    register(e) {
+      const { iid: t, name: n } = e;
+      this.inputs[t] = e;
+    },
+    unregister(e) {
+      delete this.inputs[e.iid];
+    },
+    validate() {
+      let e = !0;
+      return Object.values(this.inputs).forEach((t) => {
+        const n = t == null ? void 0 : t.invokeValidators.call(t);
+        e = e && n;
+      }), e;
+    }
+  },
+  computed: {
+    attrs() {
+      return {
+        ...this.attrs_$
+      };
+    }
+  },
+  render() {
+    var t, n;
+    const { tag: e } = this;
+    return _(
+      e,
+      {
+        class: Ze,
+        ".novalidate": !0,
+        onSubmit: (i) => {
+          i.preventDefault(), this.$emit("submit", i, this.formData);
+        },
+        onKeydown: Xt(
+          (i) => {
+            i.preventDefault(), i.stopImmediatePropagation(), this.$emit("keydown.enter", i);
+          },
+          ["enter"]
+        )
+      },
+      (n = (t = this.$slots).default) == null ? void 0 : n.call(t)
+    );
+  }
+});
+function bn(e) {
+  return {
+    numValue: w(() => {
+      const { value: n } = e, i = Number(n);
+      return Number.isNaN(i) || i < 0 ? 0 : i > 100 ? 100 : i;
+    })
+  };
+}
+const wn = /* @__PURE__ */ $({
+  name: "YProgressBar",
+  props: {
+    value: {
+      type: Number
+    },
+    rounded: {
+      type: Boolean
+    },
+    height: {
+      type: Number
+    },
+    noRewindTransition: {
+      type: Boolean
+    },
+    outlined: {
+      type: Boolean
+    },
+    innerText: {
+      type: Boolean
+    },
+    textColor: {
+      type: String
+    },
+    outlineColor: {
+      type: String
+    }
+  },
+  setup(e) {
+    const {
+      numValue: t
+    } = bn(e);
+    return {
+      numValue: t
+    };
+  },
+  data() {
+    return {
+      delta: 0
+    };
+  },
+  computed: {
+    classes() {
+      let e = !1;
+      return this.noRewindTransition && this.delta < 0 && (e = !0), {
+        "y-progress--no-trans": e,
+        "y-progress--outlined": !!this.outlined,
+        "y-progress-bar--rounded": !!this.rounded
+      };
+    },
+    styles() {
+      let e;
+      return this.innerText && this.numValue < 5 && this.numValue > 0 && (e = "2rem"), {
+        transform: `scaleX(${this.numValue / 100})`,
+        minWidth: e
+      };
+    }
+  },
+  render() {
+    const {
+      classes: e,
+      numValue: t,
+      height: n,
+      outlineColor: i,
+      textColor: a,
+      styles: r,
+      innerText: s
+    } = this, o = this.$slots;
+    return l("div", {
+      class: {
+        "y-progress y-progress-bar": !0,
+        ...e
+      },
+      role: "progressbar",
+      "aria-valuemin": "0",
+      "aria-valuemax": "100",
+      "aria-valuenow": t,
+      style: {
+        "--y-progress-bar__height": n !== void 0 ? `${n}px` : void 0,
+        "--y-progress-bar__outline-color": i !== void 0 ? i : void 0
+      }
+    }, [l("div", {
+      class: "y-progress__track"
+    }, null), l("div", {
+      class: "y-progress__tube"
+    }, [l("div", {
+      class: "y-progress__lead",
+      style: r
+    }, [o["lead-inner"] ? o["lead-inner"]() : s && l("div", {
+      class: {
+        "y-progress__lead-inner": !0,
+        "y-progress__lead-inner--fixed": t < 3
+      },
+      style: {
+        color: a
+      }
+    }, [l("span", null, [t, ae(" %")])])])])]);
+  }
+}), $t = (e, t, n) => {
+  function i(a) {
+    e.classList.forEach((r) => {
+      r.startsWith("theme--") && r !== a && e.classList.remove(r);
+    }), e.classList.add(a);
+  }
+  Ne(() => {
+    var o, c, p, h, u;
+    const a = ((c = (o = t.instance) == null ? void 0 : o.$yuyeon) == null ? void 0 : c.theme) ?? ((u = (h = (p = n == null ? void 0 : n.ctx) == null ? void 0 : p.root.appContext.config.globalProperties) == null ? void 0 : h.$yuyeon) == null ? void 0 : u.theme), r = t.value ?? a.name ?? "";
+    if (!r)
+      return;
+    const s = `theme--${r}`;
+    i(s);
+  }, { flush: "post" });
+};
+const xt = $({
+  name: "y-card",
+  props: {
+    outline: {
+      type: Boolean
+    }
+  },
+  render() {
+    var t;
+    const e = $t;
+    return pe(
+      _(
+        "div",
+        {
+          class: ["y-card"]
+        },
+        (t = this.$slots.default) == null ? void 0 : t.call(this)
+      ),
+      [[e]]
+    );
+  }
+}), _n = $({
+  name: "y-card-body",
+  render() {
+    var e, t;
+    return _("div", { class: "y-card__body" }, (t = (e = this.$slots).default) == null ? void 0 : t.call(e));
+  }
+}), Cn = $({
+  name: "y-card-footer",
+  render() {
+    var e, t;
+    return _("div", { class: "y-card__footer" }, (t = (e = this.$slots).default) == null ? void 0 : t.call(e));
+  }
+}), Sn = $({
+  name: "y-card-header",
+  render() {
+    var e, t;
+    return _("div", { class: "y-card__header" }, (t = (e = this.$slots).default) == null ? void 0 : t.call(e));
+  }
+});
+const $n = /* @__PURE__ */ $({
+  name: "y-chip",
+  props: {
+    color: String,
+    background: String,
+    small: Boolean,
+    bgOpacity: {
+      type: Number,
+      default: 0.14
+    }
+  },
+  computed: {
+    clickable() {
+      return H(this.$attrs, "onClick");
+    },
+    classes() {
+      return {
+        "y-chip": !0,
+        "y-chip--clickable": this.clickable
+      };
+    },
+    backgroundColor() {
+      const e = this.background ?? this.color;
+      return this.colorRgb(e);
+    },
+    styles() {
+      return {
+        color: this.color,
+        background: `rgba(${this.backgroundColor}, ${this.bgOpacity})`
+      };
+    }
+  },
+  methods: {
+    colorRgb(e) {
+      var n, i;
+      if (e != null && e.startsWith("#"))
+        return ((n = sn(e)) == null ? void 0 : n.join(",")) || "";
+      const t = /rgb(a?)\((?<v>.*)\)/;
+      if (t.test(e)) {
+        const a = ((i = t.exec(e)) == null ? void 0 : i[2]) || "";
+        if (a) {
+          const r = a.trim().split(",");
+          return r.splice(3, 1), r.join(",");
+        }
+      }
+      return "";
+    }
+  },
+  render() {
+    var n, i;
+    const {
+      classes: e,
+      styles: t
+    } = this;
+    return l("span", {
+      class: e,
+      style: t
+    }, [l("span", {
+      class: "y-chip__content"
+    }, [(i = (n = this.$slots).default) == null ? void 0 : i.call(n)])]);
+  }
+});
+let Je = 0;
+const xn = /* @__PURE__ */ $({
+  name: "YSwitch",
+  model: {
+    prop: "input",
+    event: "change"
+  },
+  props: {
+    input: {
+      type: [Boolean, Array],
+      default: !1
+    },
+    value: {
+      type: [String, Number, Object]
+    },
+    max: {
+      type: Number
+    },
+    loading: {
+      type: Boolean
+    },
+    disabled: {
+      type: Boolean
+    },
+    stickOut: {
+      type: Boolean
+    },
+    stateLabel: {
+      type: Boolean
+    },
+    color: {
+      type: String
+    },
+    labelOn: {
+      type: String,
+      default: "ON"
+    },
+    labelOff: {
+      type: String,
+      default: "OFF"
+    }
+  },
+  data() {
+    return {
+      innerValue: !1,
+      counterId: "",
+      focused: !1
+    };
+  },
+  created() {
+    const e = Je.toString();
+    Je += 1, this.counterId = e, Array.isArray(this.input) ? this.inputByValue() : this.innerValue = this.input;
+  },
+  computed: {
+    isMultipleInput() {
+      return Array.isArray(this.input);
+    },
+    multipleInputIndex() {
+      return Array.isArray(this.input) ? this.input.findIndex((e) => e === this.value) : -1;
+    },
+    inputId() {
+      return `y-switch--${this.counterId}`;
+    },
+    trackStyles() {
+      return {
+        backgroundColor: this.color
+      };
+    },
+    classes() {
+      return {
+        "y-switch--disabled": this.disabled,
+        "y-switch--loading": this.loading,
+        "y-switch--active": this.innerValue,
+        "y-switch--stick-out": this.stickOut,
+        "y-switch--focused": this.focused
+      };
+    }
+  },
+  methods: {
+    inputByValue() {
+      Array.isArray(this.input) && (this.input.find((t) => t === this.value) !== void 0 ? this.innerValue = !0 : this.innerValue = !1);
+    },
+    changeMultipleInput(e) {
+      if (Array.isArray(this.input)) {
+        const t = this.input.slice();
+        if (e && this.max !== void 0 && t.length >= this.max) {
+          this.$emit("overmax"), this.nextChange(!1, t);
+          return;
+        }
+        e && this.multipleInputIndex < 0 ? t.push(this.value) : this.multipleInputIndex > -1 && t.splice(this.multipleInputIndex, 1), this.$emit("change", t);
+      }
+    },
+    nextChange(e, t) {
+      this.$nextTick(() => {
+        this.innerValue = e;
+      });
+    },
+    onClick(e) {
+      this.disabled || this.loading || this.changeInput(!this.innerValue, e);
+    },
+    onFocus() {
+      this.focused = !0;
+    },
+    onBlur() {
+      this.focused = !1;
+    },
+    onKeydown(e) {
+    },
+    onChange(e) {
+      const t = e.target, {
+        checked: n
+      } = t;
+      this.changeInput(n, e);
+    },
+    changeInput(e, t) {
+      this.innerValue = e, this.isMultipleInput ? this.changeMultipleInput(e) : this.$emit("change", e);
+    }
+  },
+  watch: {
+    input() {
+      this.inputByValue();
+    }
+  },
+  render() {
+    const {
+      classes: e,
+      onClick: t,
+      onKeydown: n,
+      onFocus: i,
+      onBlur: a,
+      onChange: r,
+      inputId: s,
+      innerValue: o,
+      disabled: c,
+      trackStyles: p,
+      stateLabel: h,
+      labelOn: u,
+      labelOff: d,
+      loading: g
+    } = this;
+    return l("div", {
+      class: {
+        "y-switch": !0,
+        ...e
+      }
+    }, [l("div", {
+      class: "y-switch__slot"
+    }, [l("div", {
+      class: "y-switch__input",
+      onClick: Re(t, ["capture"]),
+      onKeydown: n
+    }, [l("input", {
+      id: s,
+      "aria-checked": o,
+      type: "checkbox",
+      role: "switch",
+      onFocus: i,
+      onBlur: a,
+      onChange: r,
+      disabled: c,
+      checked: o,
+      ref: "checkbox"
+    }, null), l("div", {
+      class: "y-switch__track",
+      style: p
+    }, [h && l("div", {
+      class: "y-switch__state"
+    }, [l("span", {
+      class: "y-switch__state-label y-switch__state-label--on"
+    }, {
+      labelOn: u
+    }), l("span", {
+      class: "y-switch__state-label y-switch__state-label--off"
+    }, {
+      labelOff: d
+    })])]), l("div", {
+      class: "y-switch__thumb"
+    }, [g && l("div", {
+      class: "y-switch__spinner"
+    }, null)])]), l("label", {
+      for: s,
+      class: "y-switch__label"
+    }, [l("slot", {
+      name: "label"
+    }, null), l("input", {
+      hidden: !0
+    }, null)])])]);
+  }
+});
+function L(e) {
+  const t = he();
+  t && (t.render = e);
+}
+const Qe = "y-layer-group";
+function kn(e) {
+  return { layerGroup: w(() => {
+    const n = e == null ? void 0 : e.value;
+    let i = document.body;
+    if (typeof n == "string") {
+      const r = document.querySelector(n);
+      r && (i = r);
+    }
+    n && n.nodeType === 1 && (i = n);
+    let a = i.querySelector(`.${Qe}`);
+    return a || (a = document.createElement("div"), a.className = Qe, i.appendChild(a)), a;
+  }) };
+}
+function Tn(e, t) {
+  const n = C(!1), i = C();
+  i.value = t.value;
+  const a = w(() => e ? t.value : i.value);
+  I(t, () => {
+    n.value || (i.value = t.value), e || (n.value = !0);
+  });
+  function r() {
+    i.value = t.value, e || (n.value = !1);
+  }
+  return {
+    entered: n,
+    lazyValue: a,
+    onAfterUpdate: r
+  };
+}
+function En(e, t = 1e3, n) {
+  const { tickDuration: i } = n ?? {};
+  let a = i ?? 100, r = -1;
+  const s = C(0), o = C(t), c = C(!1);
+  function p() {
+    const g = Date.now(), v = g - s.value;
+    if (o.value = o.value - v, o.value < 1)
+      e();
+    else {
+      const y = g - s.value + a, x = y >= 1 ? y : a;
+      s.value = g, r = window.setTimeout(p, x);
+    }
+  }
+  function h() {
+    c.value || (c.value = !0, s.value = Date.now(), r = window.setTimeout(p, a));
+  }
+  function u() {
+    window.clearTimeout(r), r = -1, c.value = !1;
+  }
+  function d() {
+    u(), o.value = t;
+  }
+  return {
+    start: h,
+    stop: u,
+    reset: d,
+    drift: o,
+    isWork: c
+  };
+}
+const je = {
+  transition: {
+    type: [String, Object],
+    default: "slide-fade"
+  }
+};
+function Vn(e) {
+  return {
+    polyTransitionBindProps: w(() => {
+      const { is: n, ...i } = typeof e.transition == "object" ? e.transition : { is: e.transition, name: e.transition };
+      return {
+        is: n,
+        transitionProps: i
+      };
+    })
+  };
+}
+const et = (e, { slots: t }) => {
+  const { is: n, transitionProps: i, ...a } = e, { component: r = Me, ...s } = typeof n == "object" ? { component: n, ...i } : { name: n };
+  return _(r, { ...s, ...i, ...a }, t);
+};
+function kt(e) {
+  const t = e.getRootNode();
+  return t !== document && t.getRootNode({ composed: !0 }) !== document ? null : t;
+}
+function An() {
+  return !0;
+}
+function Bn(e, t, n) {
+  const { value: i } = n, a = typeof i == "function" ? i : i.handler;
+  t._complementClick.lastMousedownWasOutside && Tt(e, t, n) && setTimeout(() => {
+    Et(e, n) && a && a(e);
+  }, 0);
+}
+function Tt(e, t, n) {
+  if (!e || Et(e, n) === !1)
+    return !1;
+  const i = kt(t);
+  if (typeof ShadowRoot < "u" && i instanceof ShadowRoot && i.host === e.target)
+    return !1;
+  const a = (typeof n.value == "object" && n.value.include || (() => []))();
+  return a.push(t), !a.some((r) => r == null ? void 0 : r.contains(e.target));
+}
+function Et(e, t) {
+  const { value: n } = t, i = typeof n == "object" && n.determine || An;
+  return i && (i == null ? void 0 : i(e));
+}
+function tt(e, t) {
+  const n = kt(e);
+  t(document), typeof ShadowRoot < "u" && n instanceof ShadowRoot && t(n);
+}
+const Yn = {
+  mounted(e, t) {
+    const n = (r) => Bn(r, e, t), i = (r) => {
+      e._complementClick.lastMousedownWasOutside = Tt(
+        r,
+        e,
+        t
+      );
+    };
+    tt(e, (r) => {
+      r == null || r.addEventListener("click", n, !0), r == null || r.addEventListener("mousedown", i, !0);
+    }), e._complementClick || (e._complementClick = {
+      lastMousedownWasOutside: !0
+    });
+    const a = t.instance.$.uid;
+    e._complementClick[a] = {
+      onClick: n,
+      onMousedown: i
+    };
+  },
+  unmounted(e, t) {
+    if (!e._complementClick)
+      return;
+    const n = t.instance.$.uid;
+    tt(e, (i) => {
+      var r;
+      const a = (r = e._complementClick) == null ? void 0 : r[n];
+      if (a) {
+        const { onClick: s, onMousedown: o } = a;
+        i == null || i.removeEventListener("click", s, !0), i == null || i.removeEventListener("mousedown", o, !0);
+      }
+    }), delete e._complementClick[n];
+  }
+};
+const K = /* @__PURE__ */ $({
+  name: "YLayer",
+  inheritAttrs: !1,
+  components: {
+    PolyTransition: et
+  },
+  directives: {
+    ComplementClick: Yn
+  },
+  props: {
+    modelValue: {
+      type: Boolean
+    },
+    scrim: {
+      type: Boolean
+    },
+    eager: {
+      type: Boolean
+    },
+    classes: {
+      type: [Array, String, Object]
+    },
+    contentClasses: {
+      type: [Array, String, Object]
+    },
+    closeClickScrim: {
+      type: Boolean
+    },
+    persistent: Boolean,
+    contentStyles: {
+      type: Object,
+      default: () => {
+      }
+    },
+    disabled: {
+      type: Boolean,
+      default: !1
+    },
+    ...je
+  },
+  emits: {
+    "update:modelValue": (e) => !0,
+    "click:complement": (e) => !0
+  },
+  setup(e, {
+    emit: t,
+    expose: n,
+    attrs: i,
+    slots: a
+  }) {
+    const {
+      layerGroup: r
+    } = kn(), {
+      polyTransitionBindProps: s
+    } = Vn(e), o = w({
+      get: () => !!e.modelValue,
+      set: (V) => {
+        t("update:modelValue", V);
+      }
+    }), c = ie(e, "disabled"), {
+      lazyValue: p,
+      onAfterUpdate: h
+    } = Tn(!!e.eager, o), u = w(() => !c.value && (p.value || o.value)), d = C(), g = C();
+    function v(V) {
+      t("click:complement", V), e.persistent || d.value !== null && d.value === V.target && e.closeClickScrim && (o.value = !1);
+    }
+    function y() {
+      return o.value;
+    }
+    const x = re({
+      handler: v,
+      determine: y,
+      include: () => [
+        // activatorEl.value
+      ]
+    });
+    n({
+      scrim$: d,
+      content$: g,
+      active: o,
+      onAfterUpdate: h
+    });
+    function A() {
+    }
+    function b() {
+      h();
+    }
+    function k() {
+      e.closeClickScrim && (o.value = !1);
+    }
+    const T = w(() => ({
+      zIndex: "2000"
+    })), Y = w(() => {
+      const {
+        classes: V
+      } = e;
+      return {
+        ...W(V),
+        "y-layer--active": !!o.value
+      };
+    }), O = w(() => ({
+      ...W(e.contentClasses)
+    }));
+    return L(() => l(Zt, {
+      disabled: !r.value,
+      to: r.value
+    }, {
+      default: () => [u.value && l("div", oe({
+        class: {
+          "y-layer": !0,
+          ...Y.value
+        },
+        style: T.value
+      }, i), [l(Me, {
+        name: "fade",
+        appear: !0
+      }, {
+        default: () => [o.value && e.scrim && l("div", {
+          class: "y-layer__scrim",
+          onClick: k,
+          ref: "scrim$"
+        }, null)]
+      }), l(et, oe({
+        onAfterEnter: A,
+        onAfterLeave: b,
+        appear: !0
+      }, s.value), {
+        default: () => {
+          var V;
+          return [pe(l("div", {
+            class: {
+              "y-layer__content": !0,
+              ...O.value
+            },
+            style: e.contentStyles,
+            ref: "content$"
+          }, [(V = a.default) == null ? void 0 : V.call(a, {
+            active: o.value
+          })]), [[Jt, o.value], [dt("complement-click"), {
+            ...x
+          }]])];
+        }
+      })])]
+    })), {
+      complementClickOption: x,
+      layerGroup: r,
+      active: o,
+      rendered: u,
+      onAfterUpdate: h,
+      scrim$: d,
+      content$: g,
+      polyTransitionBindProps: s
+    };
+  }
+});
+const On = /* @__PURE__ */ $({
+  name: "YDialog",
+  components: {
+    YLayer: K,
+    YCard: xt
+  },
+  props: {
+    modelValue: {
+      type: Boolean
+    },
+    dialogClasses: {
+      type: [Array, String, Object]
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(e, {
+    emit: t,
+    slots: n
+  }) {
+    const i = w({
+      get: () => !!e.modelValue,
+      set: (h) => {
+        t("update:modelValue", h);
+      }
+    }), a = w(() => ({
+      ...W(e.dialogClasses),
+      "y-dialog": !0
+    })), r = C();
+    function s(h) {
+      var g, v, y;
+      const u = h.relatedTarget, d = h.target;
+      if (u !== d && ((g = r.value) != null && g.content$) && ![document, (v = r.value) == null ? void 0 : v.content$].includes(d) && !((y = r.value) != null && y.content$.contains(d))) {
+        const x = 'button, [href], input:not([type="hidden"]), select, textarea, [tabindex]:not([tabindex="-1"])', A = [...r.value.content$.querySelectorAll(x)].filter((T) => !T.hasAttribute("disabled") && !T.matches('[tabindex="-1"]'));
+        if (!A.length)
+          return;
+        const b = A[0], k = A[A.length - 1];
+        b === k ? k.focus() : b.focus();
+      }
+    }
+    function o() {
+      document.addEventListener("focusin", s);
+    }
+    function c() {
+      document.removeEventListener("focusin", s);
+    }
+    function p(h) {
+      i.value = h;
+    }
+    return I(() => i.value, (h) => {
+      h ? o() : c();
+    }, {
+      immediate: !0
+    }), L(() => {
+      var h;
+      return l(P, null, [(h = n.base) == null ? void 0 : h.call(n), l(K, {
+        "model-value": i.value,
+        "onUpdate:modelValue": p,
+        scrim: !0,
+        classes: a.value,
+        ref: r
+      }, {
+        default: (...u) => {
+          var d;
+          return (d = n.default) == null ? void 0 : d.call(n, ...u);
+        }
+      })]);
+    }), {
+      active: i,
+      layer: r,
+      classes: a
+    };
+  }
+});
+function Ln(e, t) {
+  e.indexOf(t) === -1 && e.push(t);
+}
+const Vt = (e, t, n) => Math.min(Math.max(n, e), t), N = {
+  duration: 0.3,
+  delay: 0,
+  endDelay: 0,
+  repeat: 0,
+  easing: "ease"
+}, le = (e) => typeof e == "number", z = (e) => Array.isArray(e) && !le(e[0]), In = (e, t, n) => {
+  const i = t - e;
+  return ((n - e) % i + i) % i + e;
+};
+function Pn(e, t) {
+  return z(e) ? e[In(0, e.length, t)] : e;
+}
+const At = (e, t, n) => -n * e + n * t + e, Bt = () => {
+}, j = (e) => e, He = (e, t, n) => t - e === 0 ? 1 : (n - e) / (t - e);
+function Yt(e, t) {
+  const n = e[e.length - 1];
+  for (let i = 1; i <= t; i++) {
+    const a = He(0, t, i);
+    e.push(At(n, 1, a));
+  }
+}
+function Dn(e) {
+  const t = [0];
+  return Yt(t, e - 1), t;
+}
+function Nn(e, t = Dn(e.length), n = j) {
+  const i = e.length, a = i - t.length;
+  return a > 0 && Yt(t, a), (r) => {
+    let s = 0;
+    for (; s < i - 2 && !(r < t[s + 1]); s++)
+      ;
+    let o = Vt(0, 1, He(t[s], t[s + 1], r));
+    return o = Pn(n, s)(o), At(e[s], e[s + 1], o);
+  };
+}
+const Ot = (e) => Array.isArray(e) && le(e[0]), Te = (e) => typeof e == "object" && !!e.createAnimation, q = (e) => typeof e == "function", Rn = (e) => typeof e == "string", J = {
+  ms: (e) => e * 1e3,
+  s: (e) => e / 1e3
+}, Lt = (e, t, n) => (((1 - 3 * n + 3 * t) * e + (3 * n - 6 * t)) * e + 3 * t) * e, Mn = 1e-7, Fn = 12;
+function jn(e, t, n, i, a) {
+  let r, s, o = 0;
+  do
+    s = t + (n - t) / 2, r = Lt(s, i, a) - e, r > 0 ? n = s : t = s;
+  while (Math.abs(r) > Mn && ++o < Fn);
+  return s;
+}
+function G(e, t, n, i) {
+  if (e === t && n === i)
+    return j;
+  const a = (r) => jn(r, 0, 1, e, n);
+  return (r) => r === 0 || r === 1 ? r : Lt(a(r), t, i);
+}
+const Hn = (e, t = "end") => (n) => {
+  n = t === "end" ? Math.min(n, 0.999) : Math.max(n, 1e-3);
+  const i = n * e, a = t === "end" ? Math.floor(i) : Math.ceil(i);
+  return Vt(0, 1, a / e);
+}, nt = {
+  ease: G(0.25, 0.1, 0.25, 1),
+  "ease-in": G(0.42, 0, 1, 1),
+  "ease-in-out": G(0.42, 0, 0.58, 1),
+  "ease-out": G(0, 0, 0.58, 1)
+}, Kn = /\((.*?)\)/;
+function it(e) {
+  if (q(e))
+    return e;
+  if (Ot(e))
+    return G(...e);
+  if (nt[e])
+    return nt[e];
+  if (e.startsWith("steps")) {
+    const t = Kn.exec(e);
+    if (t) {
+      const n = t[1].split(",");
+      return Hn(parseFloat(n[0]), n[1].trim());
+    }
+  }
+  return j;
+}
+class It {
+  constructor(t, n = [0, 1], { easing: i, duration: a = N.duration, delay: r = N.delay, endDelay: s = N.endDelay, repeat: o = N.repeat, offset: c, direction: p = "normal" } = {}) {
+    if (this.startTime = null, this.rate = 1, this.t = 0, this.cancelTimestamp = null, this.easing = j, this.duration = 0, this.totalDuration = 0, this.repeat = 0, this.playState = "idle", this.finished = new Promise((u, d) => {
+      this.resolve = u, this.reject = d;
+    }), i = i || N.easing, Te(i)) {
+      const u = i.createAnimation(n);
+      i = u.easing, n = u.keyframes || n, a = u.duration || a;
+    }
+    this.repeat = o, this.easing = z(i) ? j : it(i), this.updateDuration(a);
+    const h = Nn(n, c, z(i) ? i.map(it) : j);
+    this.tick = (u) => {
+      var d;
+      r = r;
+      let g = 0;
+      this.pauseTime !== void 0 ? g = this.pauseTime : g = (u - this.startTime) * this.rate, this.t = g, g /= 1e3, g = Math.max(g - r, 0), this.playState === "finished" && this.pauseTime === void 0 && (g = this.totalDuration);
+      const v = g / this.duration;
+      let y = Math.floor(v), x = v % 1;
+      !x && v >= 1 && (x = 1), x === 1 && y--;
+      const A = y % 2;
+      (p === "reverse" || p === "alternate" && A || p === "alternate-reverse" && !A) && (x = 1 - x);
+      const b = g >= this.totalDuration ? 1 : Math.min(x, 1), k = h(this.easing(b));
+      t(k), this.pauseTime === void 0 && (this.playState === "finished" || g >= this.totalDuration + s) ? (this.playState = "finished", (d = this.resolve) === null || d === void 0 || d.call(this, k)) : this.playState !== "idle" && (this.frameRequestId = requestAnimationFrame(this.tick));
+    }, this.play();
+  }
+  play() {
+    const t = performance.now();
+    this.playState = "running", this.pauseTime !== void 0 ? this.startTime = t - this.pauseTime : this.startTime || (this.startTime = t), this.cancelTimestamp = this.startTime, this.pauseTime = void 0, this.frameRequestId = requestAnimationFrame(this.tick);
+  }
+  pause() {
+    this.playState = "paused", this.pauseTime = this.t;
+  }
+  finish() {
+    this.playState = "finished", this.tick(0);
+  }
+  stop() {
+    var t;
+    this.playState = "idle", this.frameRequestId !== void 0 && cancelAnimationFrame(this.frameRequestId), (t = this.reject) === null || t === void 0 || t.call(this, !1);
+  }
+  cancel() {
+    this.stop(), this.tick(this.cancelTimestamp);
+  }
+  reverse() {
+    this.rate *= -1;
+  }
+  commitStyles() {
+  }
+  updateDuration(t) {
+    this.duration = t, this.totalDuration = t * (this.repeat + 1);
+  }
+  get currentTime() {
+    return this.t;
+  }
+  set currentTime(t) {
+    this.pauseTime !== void 0 || this.rate === 0 ? this.pauseTime = t : this.startTime = performance.now() - t / this.rate;
+  }
+  get playbackRate() {
+    return this.rate;
+  }
+  set playbackRate(t) {
+    this.rate = t;
+  }
+}
+var Ee = function() {
+};
+process.env.NODE_ENV !== "production" && (Ee = function(e, t) {
+  if (!e)
+    throw new Error(t);
+});
+class Un {
+  setAnimation(t) {
+    this.animation = t, t == null || t.finished.then(() => this.clearAnimation()).catch(() => {
+    });
+  }
+  clearAnimation() {
+    this.animation = this.generator = void 0;
+  }
+}
+const ge = /* @__PURE__ */ new WeakMap();
+function Pt(e) {
+  return ge.has(e) || ge.set(e, {
+    transforms: [],
+    values: /* @__PURE__ */ new Map()
+  }), ge.get(e);
+}
+function zn(e, t) {
+  return e.has(t) || e.set(t, new Un()), e.get(t);
+}
+const Wn = ["", "X", "Y", "Z"], qn = ["translate", "scale", "rotate", "skew"], ue = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ"
+}, at = {
+  syntax: "<angle>",
+  initialValue: "0deg",
+  toDefaultUnit: (e) => e + "deg"
+}, Gn = {
+  translate: {
+    syntax: "<length-percentage>",
+    initialValue: "0px",
+    toDefaultUnit: (e) => e + "px"
+  },
+  rotate: at,
+  scale: {
+    syntax: "<number>",
+    initialValue: 1,
+    toDefaultUnit: j
+  },
+  skew: at
+}, Q = /* @__PURE__ */ new Map(), Ke = (e) => `--motion-${e}`, ce = ["x", "y", "z"];
+qn.forEach((e) => {
+  Wn.forEach((t) => {
+    ce.push(e + t), Q.set(Ke(e + t), Gn[e]);
+  });
+});
+const Xn = (e, t) => ce.indexOf(e) - ce.indexOf(t), Zn = new Set(ce), Dt = (e) => Zn.has(e), Jn = (e, t) => {
+  ue[t] && (t = ue[t]);
+  const { transforms: n } = Pt(e);
+  Ln(n, t), e.style.transform = Qn(n);
+}, Qn = (e) => e.sort(Xn).reduce(ei, "").trim(), ei = (e, t) => `${e} ${t}(var(${Ke(t)}))`, Ve = (e) => e.startsWith("--"), rt = /* @__PURE__ */ new Set();
+function ti(e) {
+  if (!rt.has(e)) {
+    rt.add(e);
+    try {
+      const { syntax: t, initialValue: n } = Q.has(e) ? Q.get(e) : {};
+      CSS.registerProperty({
+        name: e,
+        inherits: !1,
+        syntax: t,
+        initialValue: n
+      });
+    } catch {
+    }
+  }
+}
+const be = (e, t) => document.createElement("div").animate(e, t), ot = {
+  cssRegisterProperty: () => typeof CSS < "u" && Object.hasOwnProperty.call(CSS, "registerProperty"),
+  waapi: () => Object.hasOwnProperty.call(Element.prototype, "animate"),
+  partialKeyframes: () => {
+    try {
+      be({ opacity: [1] });
+    } catch {
+      return !1;
+    }
+    return !0;
+  },
+  finished: () => !!be({ opacity: [0, 1] }, { duration: 1e-3 }).finished,
+  linearEasing: () => {
+    try {
+      be({ opacity: 0 }, { easing: "linear(0, 1)" });
+    } catch {
+      return !1;
+    }
+    return !0;
+  }
+}, we = {}, U = {};
+for (const e in ot)
+  U[e] = () => (we[e] === void 0 && (we[e] = ot[e]()), we[e]);
+const ni = 0.015, ii = (e, t) => {
+  let n = "";
+  const i = Math.round(t / ni);
+  for (let a = 0; a < i; a++)
+    n += e(He(0, i - 1, a)) + ", ";
+  return n.substring(0, n.length - 2);
+}, st = (e, t) => q(e) ? U.linearEasing() ? `linear(${ii(e, t)})` : N.easing : Ot(e) ? ai(e) : e, ai = ([e, t, n, i]) => `cubic-bezier(${e}, ${t}, ${n}, ${i})`;
+function ri(e, t) {
+  for (let n = 0; n < e.length; n++)
+    e[n] === null && (e[n] = n ? e[n - 1] : t());
+  return e;
+}
+const oi = (e) => Array.isArray(e) ? e : [e];
+function Ae(e) {
+  return ue[e] && (e = ue[e]), Dt(e) ? Ke(e) : e;
+}
+const te = {
+  get: (e, t) => {
+    t = Ae(t);
+    let n = Ve(t) ? e.style.getPropertyValue(t) : getComputedStyle(e)[t];
+    if (!n && n !== 0) {
+      const i = Q.get(t);
+      i && (n = i.initialValue);
+    }
+    return n;
+  },
+  set: (e, t, n) => {
+    t = Ae(t), Ve(t) ? e.style.setProperty(t, n) : e.style[t] = n;
+  }
+};
+function Nt(e, t = !0) {
+  if (!(!e || e.playState === "finished"))
+    try {
+      e.stop ? e.stop() : (t && e.commitStyles(), e.cancel());
+    } catch {
+    }
+}
+function si(e, t) {
+  var n;
+  let i = (t == null ? void 0 : t.toDefaultUnit) || j;
+  const a = e[e.length - 1];
+  if (Rn(a)) {
+    const r = ((n = a.match(/(-?[\d.]+)([a-z%]*)/)) === null || n === void 0 ? void 0 : n[2]) || "";
+    r && (i = (s) => s + r);
+  }
+  return i;
+}
+function li() {
+  return window.__MOTION_DEV_TOOLS_RECORD;
+}
+function ui(e, t, n, i = {}, a) {
+  const r = li(), s = i.record !== !1 && r;
+  let o, { duration: c = N.duration, delay: p = N.delay, endDelay: h = N.endDelay, repeat: u = N.repeat, easing: d = N.easing, persist: g = !1, direction: v, offset: y, allowWebkitAcceleration: x = !1 } = i;
+  const A = Pt(e), b = Dt(t);
+  let k = U.waapi();
+  b && Jn(e, t);
+  const T = Ae(t), Y = zn(A.values, T), O = Q.get(T);
+  return Nt(Y.animation, !(Te(d) && Y.generator) && i.record !== !1), () => {
+    const V = () => {
+      var E, f;
+      return (f = (E = te.get(e, T)) !== null && E !== void 0 ? E : O == null ? void 0 : O.initialValue) !== null && f !== void 0 ? f : 0;
+    };
+    let m = ri(oi(n), V);
+    const B = si(m, O);
+    if (Te(d)) {
+      const E = d.createAnimation(m, t !== "opacity", V, T, Y);
+      d = E.easing, m = E.keyframes || m, c = E.duration || c;
+    }
+    if (Ve(T) && (U.cssRegisterProperty() ? ti(T) : k = !1), b && !U.linearEasing() && (q(d) || z(d) && d.some(q)) && (k = !1), k) {
+      O && (m = m.map((S) => le(S) ? O.toDefaultUnit(S) : S)), m.length === 1 && (!U.partialKeyframes() || s) && m.unshift(V());
+      const E = {
+        delay: J.ms(p),
+        duration: J.ms(c),
+        endDelay: J.ms(h),
+        easing: z(d) ? void 0 : st(d, c),
+        direction: v,
+        iterations: u + 1,
+        fill: "both"
+      };
+      o = e.animate({
+        [T]: m,
+        offset: y,
+        easing: z(d) ? d.map((S) => st(S, c)) : void 0
+      }, E), o.finished || (o.finished = new Promise((S, D) => {
+        o.onfinish = S, o.oncancel = D;
+      }));
+      const f = m[m.length - 1];
+      o.finished.then(() => {
+        g || (te.set(e, T, f), o.cancel());
+      }).catch(Bt), x || (o.playbackRate = 1.000001);
+    } else if (a && b)
+      m = m.map((E) => typeof E == "string" ? parseFloat(E) : E), m.length === 1 && m.unshift(parseFloat(V())), o = new a((E) => {
+        te.set(e, T, B ? B(E) : E);
+      }, m, Object.assign(Object.assign({}, i), {
+        duration: c,
+        easing: d
+      }));
+    else {
+      const E = m[m.length - 1];
+      te.set(e, T, O && le(E) ? O.toDefaultUnit(E) : E);
+    }
+    return s && r(e, t, m, {
+      duration: c,
+      delay: p,
+      easing: d,
+      repeat: u,
+      offset: y
+    }, "motion-one"), Y.setAnimation(o), o;
+  };
+}
+const ci = (e, t) => (
+  /**
+   * TODO: Make test for this
+   * Always return a new object otherwise delay is overwritten by results of stagger
+   * and this results in no stagger
+   */
+  e[t] ? Object.assign(Object.assign({}, e), e[t]) : Object.assign({}, e)
+);
+function di(e, t) {
+  var n;
+  return typeof e == "string" ? t ? ((n = t[e]) !== null && n !== void 0 || (t[e] = document.querySelectorAll(e)), e = t[e]) : e = document.querySelectorAll(e) : e instanceof Element && (e = [e]), Array.from(e || []);
+}
+const fi = (e) => e(), Rt = (e, t, n = N.duration) => new Proxy({
+  animations: e.map(fi).filter(Boolean),
+  duration: n,
+  options: t
+}, pi), hi = (e) => e.animations[0], pi = {
+  get: (e, t) => {
+    const n = hi(e);
+    switch (t) {
+      case "duration":
+        return e.duration;
+      case "currentTime":
+        return J.s((n == null ? void 0 : n[t]) || 0);
+      case "playbackRate":
+      case "playState":
+        return n == null ? void 0 : n[t];
+      case "finished":
+        return e.finished || (e.finished = Promise.all(e.animations.map(vi)).catch(Bt)), e.finished;
+      case "stop":
+        return () => {
+          e.animations.forEach((i) => Nt(i));
+        };
+      case "forEachNative":
+        return (i) => {
+          e.animations.forEach((a) => i(a, e));
+        };
+      default:
+        return typeof (n == null ? void 0 : n[t]) > "u" ? void 0 : () => e.animations.forEach((i) => i[t]());
+    }
+  },
+  set: (e, t, n) => {
+    switch (t) {
+      case "currentTime":
+        n = J.ms(n);
+      case "currentTime":
+      case "playbackRate":
+        for (let i = 0; i < e.animations.length; i++)
+          e.animations[i][t] = n;
+        return !0;
+    }
+    return !1;
+  }
+}, vi = (e) => e.finished;
+function mi(e, t, n) {
+  return q(e) ? e(t, n) : e;
+}
+function yi(e) {
+  return function(n, i, a = {}) {
+    n = di(n);
+    const r = n.length;
+    Ee(!!r, "No valid element provided."), Ee(!!i, "No keyframes defined.");
+    const s = [];
+    for (let o = 0; o < r; o++) {
+      const c = n[o];
+      for (const p in i) {
+        const h = ci(a, p);
+        h.delay = mi(h.delay, o, r);
+        const u = ui(c, p, i[p], h, e);
+        s.push(u);
+      }
+    }
+    return Rt(
+      s,
+      a,
+      /**
+       * TODO:
+       * If easing is set to spring or glide, duration will be dynamically
+       * generated. Ideally we would dynamically generate this from
+       * animation.effect.getComputedTiming().duration but this isn't
+       * supported in iOS13 or our number polyfill. Perhaps it's possible
+       * to Proxy animations returned from animateStyle that has duration
+       * as a getter.
+       */
+      a.duration
+    );
+  };
+}
+const gi = yi(It);
+function bi(e, t = {}) {
+  return Rt([
+    () => {
+      const n = new It(e, [0, 1], t);
+      return n.finished.catch(() => {
+      }), n;
+    }
+  ], t, t.duration);
+}
+function wi(e, t, n) {
+  return (q(e) ? bi : gi)(e, t, n);
+}
+function Ue(e, t = "camel") {
+  let n = "";
+  for (let i = 0; i < e.length; i += 1) {
+    const a = e[i], r = a.charCodeAt(0);
+    r >= 65 && r <= 90 ? n += `${i === 0 && t === "camel" ? "" : "-"}${a.toLowerCase()}` : n += a;
+  }
+  return n;
+}
+function Mt(e) {
+  let t = "", n = 0;
+  for (; n < e.length; ) {
+    const i = e[n];
+    i === "-" ? (n += 1, t += e[n].toUpperCase()) : t += i, n += 1;
+  }
+  return t;
+}
+function _i(e, t) {
+  let n;
+  function i() {
+    n = ft(), n.run(
+      () => t.length ? t(() => {
+        n == null || n.stop(), i();
+      }) : t()
+    );
+  }
+  I(
+    e,
+    (a) => {
+      a && !n ? i() : a || (n == null || n.stop(), n = void 0);
+    },
+    { immediate: !0 }
+  ), Qt(() => {
+    n == null || n.stop();
+  });
+}
+function me(e, t = "modelValue", n, i = (r) => r, a = (r) => r) {
+  const r = he(), s = Ue(t), o = s === t ? Mt(t) : t, c = C(
+    e[o] !== void 0 ? e[o] : n
+  );
+  function p() {
+    return e[o];
+  }
+  const h = w(() => {
+    p();
+    const d = r.vnode.props;
+    return (H(d, s) || H(d, o)) && (H(d, `onUpdate:${s}`) || H(d, `onUpdate:${o}`));
+  });
+  _i(
+    () => !h.value,
+    () => {
+      I(
+        () => p(),
+        (d) => {
+          c.value = d;
+        }
+      );
+    }
+  );
+  const u = w({
+    get() {
+      return i(h.value ? p() : c.value);
+    },
+    set(d) {
+      const g = a(d), v = ht(h.value ? p() : c.value);
+      v === g || a(v) === d || (c.value = g, r == null || r.emit(`update:${o}`, g));
+    }
+  });
+  return Object.defineProperty(u, "rxValue", {
+    get: () => h.value ? p() : c.value
+  }), u;
+}
+const Be = /* @__PURE__ */ $({
+  name: "YPlate",
+  props: {
+    variation: Object
+  },
+  setup() {
+    const e = w(() => ({
+      "y-plate": !0
+    }));
+    L(() => l("div", {
+      class: e.value
+    }, null));
+  }
+});
+const lt = {
+  name: "y-snackbar",
+  onBeforeEnter: (e) => (t) => {
+    if (!t.getAttribute("data-transform")) {
+      const n = t.style.getPropertyValue("transform");
+      t.setAttribute("data-transform", n), t.style.setProperty("transform", `${n} translateY(${e === "top" ? "-" : ""}40px)`);
+    }
+  },
+  onEnter(e, t) {
+    const n = e.getAttribute("data-transform");
+    e.getAttribute("data-motion") || !n || (e.setAttribute("data-motion", "true"), wi(e, {
+      transform: `${n.replace(/translateY(.+)/, "translateY(0)")}`
+    }, {
+      duration: 0.1
+    }).finished.then(() => {
+      e.removeAttribute("data-transform"), e.removeAttribute("data-motion"), t();
+    }));
+  }
+}, Ci = /* @__PURE__ */ $({
+  name: "YSnackbar",
+  components: {
+    YPlate: Be,
+    YLayer: K
+  },
+  emits: ["update:modelValue", "click"],
+  props: {
+    modelValue: {
+      type: Boolean
+    },
+    contentClasses: {
+      type: [Array, String, Object]
+    },
+    position: {
+      type: String,
+      default: "top center"
+    },
+    transition: {
+      type: [String, Object],
+      default: () => ({
+        ...lt
+      })
+    },
+    /**
+     * @property Number
+     *
+     * The amount of time the snackbar should be displayed.
+     * @default 4000
+     */
+    duration: {
+      type: Number,
+      default: 4e3
+    }
+  },
+  setup(e, {
+    emit: t,
+    slots: n
+  }) {
+    const i = me(e), a = C(!1), r = w(() => ({
+      "y-snackbar": !0
+    })), s = w(() => ({
+      ...W(e.contentClasses),
+      "y-snackbar__display": !0
+    })), o = w(() => {
+      var T;
+      const [y, x] = (T = e.position) == null ? void 0 : T.split(" ");
+      let A = "top", b = "left";
+      x ? (b = x, A = y) : b = y;
+      const k = {
+        [b === "center" ? "left" : b]: b === "center" ? "50%" : 0,
+        [A]: 0
+      };
+      return b === "center" && (k.transform = "translateX(-50%)"), k;
+    });
+    function c() {
+      i.value = !1;
+    }
+    const {
+      start: p,
+      stop: h,
+      reset: u
+    } = En(c, e.duration);
+    function d() {
+      e.duration > 0 && p();
+    }
+    I(a, (y) => {
+      y ? h() : d();
+    }), I(i, (y) => {
+      y ? d() : u();
+    }, {
+      immediate: !0
+    });
+    function g(y) {
+      t("click", y), i.value = !1;
+    }
+    const v = w(() => {
+      const {
+        transition: y,
+        position: x
+      } = e;
+      return (y == null ? void 0 : y.name) === "y-snackbar" ? (y.onBeforeEnter = lt.onBeforeEnter(x.includes("top") ? "top" : "bottom"), {
+        ...y
+      }) : e.transition;
+    });
+    return L(() => l(K, {
+      modelValue: i.value,
+      "onUpdate:modelValue": (y) => i.value = y,
+      classes: r.value,
+      "content-classes": s.value,
+      scrim: !1,
+      "content-styles": o.value,
+      transition: v.value,
+      ref: "layer"
+    }, {
+      default: () => {
+        var y;
+        return l(P, null, [l(Be, null, null), l("div", {
+          class: "y-snackbar__content",
+          onClick: Re(g, ["capture"]),
+          onMouseenter: () => a.value = !0,
+          onMouseleave: () => a.value = !1
+        }, [(y = n.default) == null ? void 0 : y.call(n)])]);
+      }
+    })), {
+      active: i,
+      hover: a,
+      classes: r,
+      computedContentClasses: s,
+      computedInset: o,
+      proxyTransition: v,
+      onClickContent: g
+    };
+  }
+});
+const Ft = "YTooltip";
+Ue(Ft);
+const Si = {
+  modelValue: {
+    type: Boolean,
+    default: !1
+  },
+  tooltipClasses: {
+    type: [Array, String, Object]
+  },
+  disabled: {
+    type: Boolean,
+    default: !1
+  },
+  position: {
+    type: String,
+    default: "default"
+  },
+  align: {
+    type: String,
+    default: "center"
+  },
+  openOnHover: {
+    type: Boolean,
+    default: !0
+  },
+  preventClip: {
+    type: Boolean,
+    default: !0
+  }
+}, $i = /* @__PURE__ */ $({
+  name: Ft,
+  props: {
+    ...Si,
+    transition: {
+      ...je.transition,
+      default: "fade"
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(e, {
+    slots: t,
+    emit: n,
+    expose: i
+  }) {
+    const a = C(), r = C(), s = C(), o = C(), c = C(), p = w(() => ({
+      ...W(e.tooltipClasses),
+      "y-tooltip": !0
+    })), h = me(e), u = w({
+      get: () => !!h.value,
+      set: (b) => {
+        b && e.disabled || (h.value = b);
+      }
+    }), d = w(() => {
+      const b = o.value;
+      if (b) {
+        const {
+          position: k,
+          align: T
+        } = e, Y = c.value, O = b.getBoundingClientRect();
+        let V = O.top, m = O.left + O.width / 2;
+        return Y && (k === "top" || k === "bottom") && (k === "top" && (V -= Y.clientHeight, V -= 8), k === "bottom" && (V += O.height, V += 8), T === "center" ? m -= Y.clientWidth / 2 : T === "end" && (m = O.right, m -= Y.clientWidth)), {
+          top: `${V}px`,
+          left: `${m}px`
+        };
+      }
+      return {};
+    }), g = w(() => {
+      var b, k;
+      return (k = (b = s.value) == null ? void 0 : b[0]) == null ? void 0 : k.el;
+    });
+    Ne(() => {
+      var k, T, Y;
+      if (!r.value) {
+        ((k = g.value) == null ? void 0 : k.nodeType) !== 3 && (o.value = g.value);
+        return;
+      }
+      const b = r.value;
+      o.value = (T = r.value) != null && T.$el ? (Y = r.value) == null ? void 0 : Y.$el : b;
+    }), I(u, (b) => {
+      b && ve(() => {
+        var T;
+        const k = (T = a.value) == null ? void 0 : T.content$;
+        c.value = k;
+      });
+    });
+    function v(b) {
+      e.openOnHover && (u.value = !0);
+    }
+    function y(b) {
+      e.openOnHover && (u.value = !1);
+    }
+    function x(b) {
+      b.addEventListener("mouseenter", v), b.addEventListener("mouseleave", y);
+    }
+    function A(b) {
+      b.removeEventListener("mouseenter", v), b.removeEventListener("mouseleave", y);
+    }
+    I(o, (b, k) => {
+      b ? x(b) : k && A(k);
+    }), L(() => {
+      var k;
+      const b = (k = t.base) == null ? void 0 : k.call(t, {
+        active: u.value,
+        props: oe({
+          ref: r
+        })
+      });
+      return s.value = b, l(P, null, [b, l(K, {
+        modelValue: u.value,
+        "onUpdate:modelValue": (T) => u.value = T,
+        ref: a,
+        classes: p.value,
+        scrim: !1,
+        disabled: e.disabled,
+        "content-styles": {
+          ...d.value
+        },
+        transition: e.transition
+      }, {
+        default: (...T) => {
+          var Y;
+          return l(P, null, [l(Be, null, null), l("div", {
+            class: "y-tooltip__content"
+          }, [((Y = t.default) == null ? void 0 : Y.call(t, ...T)) ?? ""])]);
+        }
+      })]);
+    });
+  }
+});
+function jt(e = !1) {
+  const n = `expand-${e ? "h" : "v"}-transition`, i = e ? "width" : "height", a = Mt(`offset-${i}`);
+  function r() {
+    function s(o) {
+      if (o._originStyle) {
+        o.style.overflow = o._originStyle.overflow;
+        const c = o._originStyle[i];
+        c != null && (o.style[i] = c);
+      }
+      delete o._originStyle;
+    }
+    return {
+      onBeforeEnter(o) {
+        o._parent = o.parentNode, o._originStyle = {
+          transition: o.style.transition,
+          overflow: o.style.overflow,
+          [i]: o.style[i]
+        };
+      },
+      onEnter(o) {
+        const c = o._originStyle;
+        o.style.setProperty("transition", "none", "important"), o.style.overflow = "hidden";
+        const p = `${o[a]}px`;
+        o.style[i] = "0", o.getBoundingClientRect(), o.style.transition = (c == null ? void 0 : c.transition) ?? "", requestAnimationFrame(() => {
+          o.style[i] = p;
+        });
+      },
+      onAfterEnter(o) {
+        s(o);
+      },
+      onEnterCancelled(o) {
+        s(o);
+      },
+      onLeave(o) {
+        o._originStyle = {
+          transition: "",
+          overflow: o.style.overflow,
+          [i]: o.style[i]
+        }, o.style.overflow = "hidden", o.style[i] = `${o[a]}px`, o.getBoundingClientRect(), requestAnimationFrame(() => {
+          o.style[i] = "0";
+        });
+      },
+      onAfterLeave(o) {
+        s(o);
+      },
+      onLeaveCancelled(o) {
+        s(o);
+      }
+    };
+  }
+  return $({
+    name: n,
+    props: {
+      disabled: {
+        type: Boolean,
+        default: !1
+      }
+    },
+    setup(s, { slots: o }) {
+      return () => _(
+        Me,
+        { name: s.disabled ? "" : n, css: !s.disabled, ...s.disabled ? {} : r() },
+        o.default
+      );
+    }
+  });
+}
+const xi = jt(!1), ki = jt(!0);
+const Ti = /* @__PURE__ */ $({
+  setup(e, {
+    slots: t
+  }) {
+    const n = C(50), i = C(!1), a = C(), r = C(!1), s = C();
+    I(a, (v) => {
+      r.value = !!v;
+    });
+    const o = w(() => {
+      let v = "0 0";
+      return r.value && (v = `0 0 ${100 - n.value}% 0`), {
+        position: "absolute",
+        inset: v
+      };
+    }), c = w(() => ({
+      "y-divide-panel": !0,
+      "y-divide-panel--resizing": i.value
+    }));
+    function p(v) {
+      const y = v, x = s.value.getBoundingClientRect();
+      requestAnimationFrame(() => {
+        n.value = Math.min(Math.max(10, (y.clientY - x.y) / x.height * 100), 90);
+      });
+    }
+    function h() {
+      i.value = !1, s.value.removeEventListener("mousemove", p), s.value.removeEventListener("mouseup", u), s.value.removeEventListener("mouseleave", d);
+    }
+    function u(v) {
+      h();
+    }
+    function d(v) {
+      h();
+    }
+    function g(v) {
+      v.preventDefault(), i.value = !0, s.value.addEventListener("mousemove", p), s.value.addEventListener("mouseup", u), s.value.addEventListener("mouseleave", d);
+    }
+    return L(() => {
+      var v, y;
+      return l(P, null, [l("div", {
+        class: c.value,
+        ref: s
+      }, [l("div", {
+        class: "y-divide-panel__top-container",
+        style: o.value
+      }, [(v = t.default) == null ? void 0 : v.call(t)]), a.value = t.secondary && l(P, null, [l("div", {
+        class: "y-divide-panel__divider",
+        style: {
+          position: "absolute",
+          inset: `${n.value}% 0 0 0`
+        },
+        onMousedown: g
+      }, [l("div", {
+        class: "y-divide-panel__divider-line"
+      }, null)]), l("div", {
+        class: "y-divide-panel__secondary-container",
+        style: {
+          position: "absolute",
+          inset: `${n.value}% 0 0 0`
+        }
+      }, [(y = t.secondary) == null ? void 0 : y.call(t)])])])]);
+    }), {
+      activeSecondary: r
+    };
+  }
+}), de = /* @__PURE__ */ $({
+  name: "YIconExpand",
+  setup() {
+    return () => l("svg", {
+      version: "1.1",
+      viewBox: "0 0 32 32",
+      xmlns: "http://www.w3.org/2000/svg"
+    }, [l("path", {
+      d: "m9.6086 5.7953 13.557 10.269-13.557 10.141",
+      fill: "none",
+      stroke: "currentColor",
+      "stroke-linecap": "round",
+      "stroke-linejoin": "round",
+      "stroke-width": "4.1024"
+    }, null)]);
+  }
+}), ne = /* @__PURE__ */ $({
+  name: "YIconCheckbox",
+  render() {
+    return l("svg", {
+      class: "y-icon-checkbox",
+      xmlns: "http://www.w3.org/2000/svg",
+      width: "24",
+      height: "24"
+    }, [l("path", {
+      class: "y-icon-checkbox__border-path",
+      d: "M 15.525 21.825 H 8.325 C 4.851 21.825 2.025 18.999 2.025 15.525 V 8.325 C 2.025 4.851 4.851 2.025 8.325 2.025 H 15.525 C 18.999 2.025 21.825 4.851 21.825 8.325 V 15.525 C 21.825 18.999 18.999 21.825 15.525 21.825 Z"
+    }, null), l("path", {
+      class: "y-icon-checkbox__checkmark-path",
+      fill: "none",
+      d: "M5.73,11.91 11.1,16.28 17.79,7.59"
+    }, null)]);
+  }
+}), ze = $({
+  name: "YTreeNode",
+  props: {
+    item: {
+      type: Object
+    },
+    itemKey: {
+      type: String,
+      default: "id"
+    },
+    textKey: {
+      type: String,
+      default: "text"
+    },
+    childrenKey: {
+      type: String,
+      default: "children"
+    },
+    level: {
+      type: Number,
+      default: 0
+    }
+  },
+  setup(e, { slots: t }) {
+    const n = en("tree-view"), i = w(() => {
+      var h;
+      return ((h = e.item) == null ? void 0 : h[e.childrenKey]) ?? [];
+    }), a = w(() => i.value.length < 1), r = w(() => ({
+      "y-tree-view-node": !0,
+      "y-tree-view-node--leaf": a.value
+    })), s = w(() => ({
+      "--tree-view-node--level": e.level
+    })), o = w(() => Z(e.item, e.textKey) ?? ""), c = w(() => ({
+      level: e.level,
+      imLeaf: a.value
+    }));
+    L(() => {
+      var d;
+      const h = i.value.map((g) => _(
+        ze,
+        { ...e, level: (e.level ?? 0) + 1, item: g },
+        t
+      )), u = [];
+      for (let g = 0; g < e.level; g += 1)
+        u.push(
+          _("div", { class: "y-tree-view-node__indent-spacer" })
+        );
+      return _(
+        "div",
+        {
+          class: r.value,
+          style: s.value,
+          ".role": "treeitem",
+          "data-level": e.level
+        },
+        [
+          _("div", { class: "y-tree-view-node__container" }, [
+            _("div", { class: "y-tree-view-node__indents" }, u),
+            /* EXPAND */
+            a.value ? _("i", { class: "y-tree-view-node__no-expand-icon" }) : _("i", { class: "y-tree-view-node__expand-icon" }, [
+              t["expand-icon"] ? t["expand-icon"]() : _(de, {
+                style: { width: "12px", height: "12px" }
+              })
+            ]),
+            /* CONTENT */
+            _("div", { class: "y-tree-view-node__content" }, [
+              t.leading && _(
+                "div",
+                { class: "y-tree-view-node__leading" },
+                t.leading(c.value)
+              ),
+              _(
+                "div",
+                { class: "y-tree-view-node__text" },
+                t.default ? (d = t.default) == null ? void 0 : d.call(t, {
+                  text: o.value,
+                  item: e.item
+                }) : o.value
+              ),
+              t.trailing && _(
+                "div",
+                { class: "y-tree-view-node__trailing" },
+                t.trailing()
+              )
+            ])
+          ]),
+          /* CHILDREN */
+          i.value.length > 0 ? _(
+            "div",
+            { class: { "y-tree-view-node__leaves": !0 }, role: "tree" },
+            h
+          ) : void 0
+        ]
+      );
+    });
+    const p = w(() => Z(e.item, e.itemKey));
+    return {
+      treeView: n,
+      myKey: p
+    };
+  },
+  created() {
+    var e, t;
+    (t = (e = this.treeView) == null ? void 0 : e.register) == null || t.call(e, this.myKey, this);
+  }
+});
+const Ei = /* @__PURE__ */ $({
+  name: "YTreeView",
+  props: {
+    items: {
+      type: Array,
+      default: () => []
+    },
+    itemKey: {
+      type: String,
+      default: "id"
+    },
+    childrenKey: {
+      type: String,
+      default: "children"
+    }
+  },
+  setup(e, {
+    slots: t
+  }) {
+    const n = w(() => ({
+      "y-tree-view": !0
+    })), i = C({});
+    C([]);
+    function a(o, c = null) {
+      for (const p of o) {
+        const h = Z(p, e.itemKey), u = Z(p, e.childrenKey) ?? [], v = {
+          vnode: (H(i.value, h) ? i.value[h] : {
+            selected: !1,
+            indeterminate: !1,
+            active: !1,
+            opened: !1,
+            vnode: null
+          }).vnode,
+          item: p,
+          parentKey: c,
+          childKeys: u.map((y) => Z(y, e.itemKey))
+        };
+        a(u, h), i.value[h] = v;
+      }
+    }
+    a(e.items), I(() => e.items, (o) => {
+      a(o);
+    }, {
+      deep: !0
+    });
+    function r(o, c) {
+      i.value[o] && (i.value[o].vnode = c);
+    }
+    tn("tree-view", {
+      register: r
+    });
+    const s = w(() => e.items);
+    return L(() => l(P, null, [l("div", {
+      class: n.value,
+      role: "tree"
+    }, [s.value.length > 0 ? s.value.map((o) => l(ze, {
+      item: o,
+      level: 0
+    }, t)) : l("div", {
+      class: "y-tree-view__no-data"
+    }, [t["no-data"] ? t["no-data"]() : l("span", null, [ae("No Data")])])])])), {
+      nodes: i
+    };
+  }
+});
+const Ht = ee({
+  tag: {
+    type: String,
+    default: "div"
+  }
+}, "y-list-item"), Vi = /* @__PURE__ */ $({
+  name: "YListItem",
+  props: {
+    ...Ht()
+  },
+  setup(e, {
+    slots: t
+  }) {
+    L(() => {
+      const n = e.tag;
+      return l(n, {
+        class: ["y-list-item"]
+      }, {
+        default: () => {
+          var i;
+          return [t.prepend && l("div", {
+            class: "y-list-item__prepend"
+          }, [t.prepend()]), l("div", {
+            class: "y-list-item__content"
+          }, [(i = t.default) == null ? void 0 : i.call(t)]), t.append && l("div", {
+            class: "y-list-item__append"
+          }, [t.append()])];
+        }
+      });
+    });
+  }
+});
+const Ai = /* @__PURE__ */ $({
+  name: "YList",
+  setup(e, {
+    slots: t
+  }) {
+    L(() => {
+      var n;
+      return l(P, null, [l("div", {
+        class: "y-list"
+      }, [(n = t.default) == null ? void 0 : n.call(t)])]);
+    });
+  }
+});
+function Kt(e) {
+  const t = C(), n = C();
+  if (window) {
+    const i = new ResizeObserver((a, r) => {
+      e == null || e(a, r), a.length && (n.value = a[0].contentRect);
+    });
+    nn(() => {
+      i.disconnect();
+    }), I(
+      t,
+      (a, r) => {
+        r && (i.unobserve(r), n.value = void 0), a && i.observe(hn(a));
+      },
+      { flush: "post" }
+    );
+  }
+  return {
+    resizeObservedRef: t,
+    contentRect: an(n)
+  };
+}
+const fe = /* @__PURE__ */ $({
+  name: "YTable",
+  props: {
+    tag: {
+      type: String,
+      default: "div"
+    },
+    fixedHead: {
+      type: Boolean
+    },
+    height: {
+      type: [Number, String]
+    },
+    flexHeight: {
+      type: Boolean
+    }
+  },
+  setup(e, {
+    slots: t
+  }) {
+    const {
+      resizeObservedRef: n,
+      contentRect: i
+    } = Kt();
+    L(() => {
+      var s;
+      const a = e.tag ?? "div", r = e.flexHeight ? ((s = i.value) == null ? void 0 : s.height) ?? e.height : e.height;
+      return l(a, {
+        class: ["y-table", {
+          "y-table--fixed-head": e.fixedHead,
+          "y-table--fixed-height": e.flexHeight || e.height,
+          "y-table--flex-height": e.flexHeight
+        }]
+      }, {
+        default: () => {
+          var o, c, p, h, u;
+          return [(o = t.top) == null ? void 0 : o.call(t), t.default ? l("div", {
+            class: ["y-table__container"],
+            ref: n,
+            style: {
+              height: wt(r)
+            }
+          }, [(c = t.leading) == null ? void 0 : c.call(t), l("table", null, [t.default()]), (p = t.trailing) == null ? void 0 : p.call(t)]) : (h = t.container) == null ? void 0 : h.call(t, n, i), (u = t.bottom) == null ? void 0 : u.call(t)];
+        }
+      });
+    });
+  }
+}), Ye = /* @__PURE__ */ $({
+  name: "YDataTableBody",
+  setup() {
+    L(() => l("div", null, null));
+  }
+});
+const Oe = /* @__PURE__ */ $({
+  name: "YDataTableControl",
+  components: {
+    YButton: $e,
+    YIconExpand: de,
+    YFieldInput: ke
+  },
+  setup(e, {
+    slots: t
+  }) {
+    L(() => l("footer", {
+      class: ["y-data-table-control"]
+    }, [t.default ? t.default() : l(P, null, [l($e, {
+      outlined: !0
+    }, {
+      default: () => [ae("20"), l(de, {
+        style: {
+          width: "16px",
+          height: "16px"
+        }
+      }, null)]
+    }), ae("페이지"), l("div", null, [l(ke, {
+      outlined: !0
+    }, null)])])]));
+  }
+}), Le = /* @__PURE__ */ $({
+  name: "YDataTableHead",
+  setup() {
+    L(() => l("tr", null, null));
+  }
+}), Ie = /* @__PURE__ */ $({
+  name: "YDataTableLayer",
+  setup() {
+    L(() => l("div", {
+      class: ["y-data-table-layer"]
+    }, null));
+  }
+}), Ut = ee(
+  {
+    page: {
+      type: [Number, String],
+      default: 0
+    },
+    pageSize: {
+      type: [Number, String],
+      default: 10
+    }
+  },
+  "YDataTable__pagination"
+), We = ee({
+  width: [String, Number],
+  search: String,
+  ...Ut()
+}, "YDataTable"), Bi = /* @__PURE__ */ $({
+  name: "YDataTable",
+  props: {
+    ...We()
+  },
+  setup(e, {
+    slots: t
+  }) {
+    const n = w(() => ({}));
+    L(() => l(fe, {
+      class: ["y-data-table"]
+    }, {
+      default: () => [{
+        top: () => {
+          var i;
+          return (i = t.top) == null ? void 0 : i.call(t, n.value);
+        },
+        leading: () => t.leading ? t.leading(n.value) : l(P, null, [l(Ie, null, t)]),
+        default: () => {
+          var i, a, r;
+          return t.default ? t.default(n.value) : l(P, null, [l("thead", null, [l(Le, null, t)]), (i = t.thead) == null ? void 0 : i.call(t, n.value), l("tbody", null, [l(Ye, null, t)]), (a = t.tbody) == null ? void 0 : a.call(t, n.value), (r = t.tfoot) == null ? void 0 : r.call(t, n.value)]);
+        },
+        trailing: () => {
+          var i;
+          return (i = t.trailing) == null ? void 0 : i.call(t, n.value);
+        },
+        bottom: () => t.bottom ? t.bottom(n.value) : l(Oe, null, {
+          prepend: t["control.prepend"]
+        })
+      }],
+      ...t
+    }));
+  }
+}), zt = ee({
+  total: {
+    type: [Number, String],
+    required: !0
+  },
+  ...Ut(),
+  ...We()
+}, "YDataTableServer"), Yi = /* @__PURE__ */ $({
+  name: "YDataTableServer",
+  components: {
+    YTable: fe,
+    YDataTableLayer: Ie,
+    YDataTableHead: Le,
+    YDataTableBody: Ye,
+    YDataTableControl: Oe
+  },
+  props: {
+    ...zt()
+  },
+  setup(e, {
+    slots: t
+  }) {
+    const n = w(() => ({}));
+    L(() => l(fe, {
+      class: ["y-data-table"]
+    }, {
+      top: () => {
+        var i;
+        return (i = t.top) == null ? void 0 : i.call(t, n.value);
+      },
+      leading: () => t.leading ? t.leading(n.value) : l(P, null, [l(Ie, null, t)]),
+      default: () => {
+        var i, a, r;
+        return t.default ? t.default(n.value) : l(P, null, [l("thead", null, [l(Le, null, t)]), (i = t.thead) == null ? void 0 : i.call(t, n.value), l("tbody", null, [l(Ye, null, t)]), (a = t.tbody) == null ? void 0 : a.call(t, n.value), (r = t.tfoot) == null ? void 0 : r.call(t, n.value)]);
+      },
+      trailing: () => {
+        var i;
+        return (i = t.trailing) == null ? void 0 : i.call(t, n.value);
+      },
+      bottom: () => t.bottom ? t.bottom(n.value) : l(Oe, null, {
+        prepend: t["control.prepend"]
+      })
+    }));
+  }
+});
+const Wt = "YMenu";
+Ue(Wt);
+const qt = {
+  modelValue: {
+    type: Boolean,
+    default: !1
+  },
+  menuClasses: {
+    type: [Array, String, Object]
+  },
+  disabled: {
+    type: Boolean,
+    default: !1
+  },
+  position: {
+    type: String,
+    default: "default"
+  },
+  align: {
+    type: String,
+    default: "start"
+  },
+  openOnHover: {
+    type: Boolean,
+    default: !1
+  },
+  closeOnClick: {
+    type: Boolean
+  },
+  preventClip: {
+    type: Boolean,
+    default: !0
+  },
+  offsetY: {
+    type: [Number, String]
+  }
+}, Oi = /* @__PURE__ */ $({
+  name: Wt,
+  props: {
+    ...qt,
+    transition: {
+      ...je.transition,
+      default: "fade"
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(e, {
+    slots: t,
+    emit: n,
+    expose: i
+  }) {
+    const a = C(), r = C(), s = C(), o = C(), c = C(), p = w(() => ({
+      ...W(e.menuClasses),
+      "y-menu": !0
+    })), h = me(e), u = w({
+      get: () => !!h.value,
+      set: (m) => {
+        m && e.disabled || (h.value = m);
+      }
+    }), d = ie(e, "position"), g = ie(e, "align"), v = C(), y = w(() => v.value ?? {});
+    function x() {
+      const m = o.value, B = u.value;
+      if (m && B) {
+        const E = c.value, f = m.getBoundingClientRect();
+        let S = f.top, D = f.left + f.width / 2;
+        return E && ((d.value === "top" || d.value === "bottom") && (d.value === "top" && (S -= E.clientHeight, S -= 8), d.value === "bottom" && (S += f.height, S += 8)), g.value === "center" ? D -= E.clientWidth / 2 : g.value === "start" ? D = f.left : g.value === "end" && (D = f.right, D -= E.clientWidth)), e.offsetY && (S += +e.offsetY), {
+          top: `${S}px`,
+          left: `${D}px`,
+          minWidth: wt(f.width)
+        };
+      }
+      return {};
+    }
+    const A = w(() => {
+      var m, B;
+      return (B = (m = s.value) == null ? void 0 : m[0]) == null ? void 0 : B.el;
+    });
+    Ne(() => {
+      var B, E;
+      if (!r.value) {
+        o.value = A.value;
+        return;
+      }
+      const m = r.value;
+      o.value = (B = r.value) != null && B.$el ? (E = r.value) == null ? void 0 : E.$el : m;
+    }), I(u, (m) => {
+      m && ve(() => {
+        var E;
+        const B = (E = a.value) == null ? void 0 : E.content$;
+        c.value = B, v.value = x();
+      });
+    });
+    function b(m) {
+      e.openOnHover && (u.value = !0);
+    }
+    function k(m) {
+      e.openOnHover && (u.value = !1);
+    }
+    function T(m) {
+      const B = u.value;
+      e.disabled || (u.value = !B);
+    }
+    function Y(m) {
+      u.value && (u.value = !1);
+    }
+    function O(m) {
+      m.addEventListener("mouseenter", b), m.addEventListener("mouseleave", k);
+    }
+    function V(m) {
+      m.removeEventListener("mouseenter", b), m.removeEventListener("mouseleave", k);
+    }
+    I(o, (m, B) => {
+      m ? (O(m), m.addEventListener("click", T)) : B && (V(B), B.removeEventListener("click", T));
+    }), L(() => {
+      var B;
+      const m = (B = t.base) == null ? void 0 : B.call(t, {
+        active: u.value,
+        props: oe({
+          ref: r,
+          class: {
+            "y-menu-base": !0,
+            "y-menu-base--active": u.value
+          }
+        })
+      });
+      return s.value = m, l(P, null, [m, l(K, {
+        modelValue: u.value,
+        "onUpdate:modelValue": (E) => u.value = E,
+        ref: a,
+        classes: p.value,
+        scrim: !1,
+        disabled: e.disabled,
+        "content-styles": {
+          ...y.value
+        },
+        "content-classes": ["y-menu__content"],
+        transition: e.transition,
+        "onClick:complement": Y
+      }, {
+        default: (...E) => {
+          var f;
+          return l(P, null, [((f = t.default) == null ? void 0 : f.call(t, ...E)) ?? ""]);
+        }
+      })]);
+    });
+  }
+});
+const Pe = /* @__PURE__ */ $({
+  name: "YInputCheckbox",
+  components: {
+    YIconCheckbox: ne
+  },
+  props: {
+    id: String,
+    value: Boolean,
+    icon: String,
+    color: {
+      type: String,
+      default: () => "primary"
+    },
+    disabled: Boolean,
+    readonly: Boolean
+  },
+  emits: ["focus", "blur", "click"],
+  data() {
+    return {
+      counterId: this.$.uid.toString(),
+      checked: !1,
+      focused: !1
+    };
+  },
+  computed: {
+    coloredClass() {
+      if (!this.color.startsWith("#"))
+        return `color--${this.color}`;
+    },
+    classes() {
+      const e = {
+        "y-input": !0,
+        "y-input--checkbox": !0,
+        "y-input--active": this.checked,
+        "y-input--focused": this.focused
+      };
+      return this.coloredClass && (e[this.coloredClass] = !0), e;
+    },
+    inputId() {
+      let e = this.counterId;
+      return this.id && (e = this.id), `input-${e}`;
+    },
+    iconComponent() {
+      return this.icon ? null : ne;
+    }
+  },
+  methods: {
+    onFocus(e) {
+      this.focused = !0, this.$emit("focus", e);
+    },
+    onBlur(e) {
+      this.focused = !1, this.$emit("blur", e);
+    },
+    onClick(e) {
+      this.$emit("click", e);
+    }
+  },
+  watch: {
+    value(e) {
+      this.checked = e;
+    }
+  },
+  created() {
+    this.checked = !!this.value;
+  },
+  render() {
+    const {
+      onClick: e,
+      classes: t,
+      inputId: n,
+      checked: i,
+      onFocus: a,
+      onBlur: r,
+      disabled: s,
+      readonly: o,
+      iconComponent: c
+    } = this;
+    return l(P, null, [l("div", {
+      onClick: e,
+      class: t
+    }, [l("input", {
+      id: n,
+      "aria-checked": i,
+      role: "checkbox",
+      type: "checkbox",
+      checked: i,
+      onFocus: a,
+      onBlur: r,
+      disabled: s,
+      readonly: o
+    }, null), this.$slots.icon ? this.$slots.icon({
+      checked: i
+    }) : c ? _(c) : l(ne, null, null)])]);
+  }
+}), Li = /* @__PURE__ */ $({
+  name: "YCheckbox",
+  components: {
+    YInputCheckbox: Pe
+  },
+  model: {
+    prop: "inputValue",
+    event: "change"
+  },
+  emits: ["focus", "blur", "change"],
+  props: {
+    inputValue: [Boolean, Array],
+    value: [String, Number, Object],
+    label: String,
+    reverse: Boolean,
+    icon: {
+      type: [Object, String]
+    },
+    color: {
+      type: String,
+      default: () => "primary"
+    },
+    disabled: Boolean,
+    readonly: Boolean
+  },
+  setup(e, {
+    emit: t,
+    slots: n
+  }) {
+    const i = C(!1), a = C(!1), s = `input-${(fn() ?? "").toString()}`;
+    function o(v) {
+      i.value = !0, t("focus", v);
+    }
+    function c(v) {
+      i.value = !1, t("blur", v);
+    }
+    function p(v, ...y) {
+      e.disabled || e.readonly || (a.value = !a.value, t("change", a.value, v));
+    }
+    function h() {
+      var v;
+      Array.isArray(e.inputValue) ? ((v = e.inputValue) == null ? void 0 : v.find((x) => x === e.value)) !== void 0 ? a.value = !0 : a.value = !1 : typeof e.inputValue == "boolean" && (a.value = e.inputValue);
+    }
+    const u = w(() => {
+      const {
+        reverse: v,
+        disabled: y,
+        readonly: x
+      } = e;
+      return {
+        "y-checkbox": !0,
+        "y-checkbox--reverse": !!v,
+        "y-checkbox--focused": i.value,
+        "y-checkbox--disabled": !!y,
+        "y-checkbox--readonly": !!x
+      };
+    }), d = w(() => {
+      if (typeof e.icon == "string")
+        return e.icon;
+    }), g = w(() => Array.isArray(e.inputValue));
+    return w(() => g.value ? e.inputValue.findIndex((v) => v === e.value) : -1), L(() => {
+      var v, y;
+      return l("div", {
+        class: u
+      }, [l("slot", {
+        name: "prepend"
+      }, null), l("div", {
+        class: "y-checkbox__slot"
+      }, [l(Pe, {
+        onClick: (x, ...A) => {
+          x.stopPropagation(), p(x, ...A);
+        },
+        onFocus: o,
+        onBlur: c,
+        id: "counterId",
+        value: a.value,
+        icon: d.value,
+        color: e.color,
+        disabled: e.disabled,
+        readonly: e.readonly
+      }, {
+        default: () => [n.icon && {
+          icon: (...x) => {
+            var A;
+            return (A = n.icon) == null ? void 0 : A.call(n, ...x);
+          }
+        }]
+      }), l("label", {
+        onClick: Re(() => {
+        }, ["stop"]),
+        class: "y-checkbox__label",
+        for: s
+      }, [n.label ? (v = n.label) == null ? void 0 : v.call(n) : e.label])]), (y = n.append) == null ? void 0 : y.call(n)]);
+    }), {
+      innerValue: a,
+      inputByValue: h
+    };
+  },
+  created() {
+    Array.isArray(this.inputValue) ? this.inputByValue() : this.innerValue = !!this.inputValue;
+  },
+  watch: {
+    inputValue: {
+      handler() {
+        this.inputByValue();
+      },
+      immediate: !0
+    }
+  }
+});
+const Gt = ee({
+  start: {
+    type: [Number, String],
+    default: 1
+  },
+  modelValue: {
+    type: Number,
+    default: (e) => e.start
+  },
+  disabled: Boolean,
+  length: {
+    type: [Number, String],
+    default: 1,
+    validator: (e) => e % 1 === 0
+  },
+  totalVisible: [Number, String],
+  showEndButton: Boolean
+}, "y-pagination"), Ii = /* @__PURE__ */ $({
+  name: "YPagination",
+  props: {
+    ...Gt()
+  },
+  emits: {
+    "update:modelValue": (e) => !0,
+    first: (e) => !0,
+    last: (e) => !0,
+    prev: (e) => !0,
+    next: (e) => !0
+  },
+  setup(e, {
+    slots: t
+  }) {
+    me(e), w(() => parseInt(e.length, 10)), w(() => parseInt(e.start, 10));
+    const {
+      resizeObservedRef: n
+    } = Kt((i) => {
+      1 > i.length;
+    });
+    L(() => l("div", {
+      class: ["y-pagination"],
+      role: "navigation",
+      ref: n
+    }, [l("ul", {
+      class: ["y-pagination__list"]
+    }, [l("li", null, null)])]));
+  }
+}), ut = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  YApp: rn,
+  YButton: $e,
+  YCard: xt,
+  YCardBody: _n,
+  YCardFooter: Cn,
+  YCardHeader: Sn,
+  YCheckbox: Li,
+  YChip: $n,
+  YDataTable: Bi,
+  YDataTableServer: Yi,
+  YDialog: On,
+  YDividePanel: Ti,
+  YExpandHTransition: ki,
+  YExpandVTransition: xi,
+  YFieldInput: ke,
+  YForm: gn,
+  YIconCheckbox: ne,
+  YIconClear: St,
+  YIconExpand: de,
+  YInput: xe,
+  YInputCheckbox: Pe,
+  YInputProps: se,
+  YLayer: K,
+  YList: Ai,
+  YListItem: Vi,
+  YMenu: Oi,
+  YMenuPropOptions: qt,
+  YPagination: Ii,
+  YProgressBar: wn,
+  YSnackbar: Ci,
+  YSpinnerRing: _t,
+  YSwitch: xn,
+  YTable: fe,
+  YTooltip: $i,
+  YTreeView: Ei,
+  YTreeViewNode: ze,
+  buttonProps: Ct,
+  pressDataTableProps: We,
+  pressDataTableServerProps: zt,
+  pressYListItemProps: Ht,
+  pressYPaginationProps: Gt
+}, Symbol.toStringTag, { value: "Module" })), De = {
+  light: "light",
+  dark: "dark"
+}, ct = {
+  light: {
+    scheme: De.light,
+    colors: {
+      "app-background": "#ffffff",
+      "base-font": "#141414"
+    },
+    variables: {
+      "base-shadow-opacity": 0.14
+    }
+  },
+  dark: {
+    scheme: De.dark,
+    colors: {
+      "app-background": "#1e1e1e",
+      "base-font": "#fff"
+    },
+    variables: {
+      "base-shadow-opacity": 0.14
+    }
+  }
+};
+function Pi(e) {
+  return e ? {
+    scheme: De.light,
+    theme: ["light", "dark"],
+    themes: { ...Se(ct, e.themes) }
+  } : {
+    scheme: "normal",
+    theme: ["light", "dark"],
+    themes: { ...Se(ct) }
+  };
+}
+function Di(e) {
+  const t = ft(), n = re(Pi(e)), i = C(n.scheme), a = C(n.mode), r = C(n.theme), s = C(n.themes), o = re({
+    scheme: i,
+    theme: r,
+    themes: s,
+    mode: a
+  });
+  function c(u) {
+    u.directive("theme", $t);
+  }
+  function p(u) {
+    console.log(ht(u.theme)), I(
+      r,
+      (d) => {
+        const [g, v] = d;
+        u.root.dataset.lightTheme = g, u.root.dataset.darkTheme = v;
+      },
+      { immediate: !0 }
+    ), I(
+      i,
+      (d) => {
+        u.root.setAttribute("data-theme-scheme", d);
+      },
+      { immediate: !0 }
+    );
+  }
+  function h(u) {
+    t.run(() => {
+      p(u);
+    });
+  }
+  return {
+    install: c,
+    init: h,
+    scope: t,
+    instance: o
+  };
+}
+const Ni = ",--. ,--.,--.,--.,--. ,--.,---.  ,---. ,--,--,  \n \\  '  / |  ||  | \\  '  /| .-. :| .-. ||      \\ \n  \\   '  '  ''  '  \\   ' \\   --.' '-' '|  ||  | \n.-'  /    `----' .-'  /   `----' `---' `--''--' \n`---'            `---'                          ";
+const Ri = {
+  credit: !0
+};
+function Fi(e = Ri) {
+  const t = Di(e == null ? void 0 : e.theme);
+  return {
+    install: (i) => {
+      t.install(i);
+      const a = re({
+        app: null,
+        root: null,
+        theme: t.instance
+      });
+      Object.keys(ut).forEach((s) => {
+        const o = ut[s];
+        i.component(s, o);
+      }), i.directive("plate-wave", Ce), i.provide("theme", a.theme), i.config.globalProperties.$yuyeon = a, ve(() => {
+        if (a.app = i._instance, a.root = i._container, !a.root)
+          throw new Error("yuyeon: Can't found instance");
+        const s = a.root;
+        s.classList.add("y-root"), s.setAttribute("data-y-root", ""), t.init(a);
+      }), e != null && e.credit && console.log(Ni);
+      const { unmount: r } = i;
+      i.unmount = () => {
+        r(), t.scope.stop(), i.unmount = r;
+      };
+    }
+    // theme: themeModule,
+  };
+}
+export {
+  Fi as init
+};