cleek 2.0.7 → 2.1.1

package/dist/cleek.es.js

@@ -17,7 +17,7 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { defineComponent, computed, watch, h, resolveComponent, openBlock, createElementBlock, normalizeClass, createBlock, createCommentVNode, renderSlot, mergeProps, withKeys, withModifiers, createElementVNode, pushScopeId, popScopeId, unref, normalizeStyle, ref, getCurrentInstance, onMounted, withCtx, createTextVNode, toDisplayString, withDirectives, isRef, vModelDynamic, createVNode, Fragment, renderList, vModelRadio, vModelSelect, vModelCheckbox, vModelText } from "vue";
+import { defineComponent, computed as computed$2, watch, h, openBlock, createElementBlock, normalizeClass, unref as unref$1, createBlock, createCommentVNode, ref, onMounted, getCurrentInstance, renderSlot, mergeProps, withKeys, withModifiers, createElementVNode, pushScopeId, popScopeId, normalizeStyle, withCtx, createTextVNode, toDisplayString, withDirectives, isRef as isRef$1, vModelDynamic, createVNode, Fragment, renderList, vModelRadio, vModelSelect, vModelCheckbox, vModelText } from "vue";
 var validators = {
   size: (type) => {
     return ["", "xs", "s", "m", "l", "xl"].includes(type);
@@ -77,17 +77,17 @@ var functions$1 = {
   isColumnDisplayed(column) {
     if (column.isDisplayed === false)
       return false;
+    if (column.unchangeable) {
+      if (column.isDisplayed === true)
+        return true;
+      return false;
+    }
     return true;
   },
   getCleekOptions(getCurrentInstance2) {
     return getCurrentInstance2().appContext.app.config.globalProperties.$cleekOptions;
   }
 };
-var globalVariables = {
-  defaultFailImg: "df",
-  imagesFolderPath: "",
-  defaultImgBorderColor: "#EEEEEE"
-};
 /*!
  * Font Awesome Free 5.15.4 by @fontawesome - https://fontawesome.com
  * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License)
@@ -11110,19 +11110,19 @@ var FontAwesomeIcon = defineComponent({
   },
   setup: function setup(props, _ref2) {
     var attrs = _ref2.attrs;
-    var icon$$1 = computed(function() {
+    var icon$$1 = computed$2(function() {
       return normalizeIconArgs(props.icon);
     });
-    var classes = computed(function() {
+    var classes = computed$2(function() {
       return objectWithKey("classes", classList(props));
     });
-    var transform2 = computed(function() {
+    var transform2 = computed$2(function() {
       return objectWithKey("transform", typeof props.transform === "string" ? parse.transform(props.transform) : props.transform);
     });
-    var mask = computed(function() {
+    var mask = computed$2(function() {
       return objectWithKey("mask", normalizeIconArgs(props.mask));
     });
-    var renderedIcon = computed(function() {
+    var renderedIcon = computed$2(function() {
       return icon(icon$$1.value, _extends({}, classes.value, transform2.value, mask.value, {
         symbol: props.symbol,
         title: props.title
@@ -11133,7 +11133,7 @@ var FontAwesomeIcon = defineComponent({
         return log("Could not find one or more icon(s)", icon$$1.value, mask.value);
       }
     }, { immediate: true });
-    var vnode = computed(function() {
+    var vnode = computed$2(function() {
       return renderedIcon.value ? convert(renderedIcon.value.abstract[0], {}, attrs) : null;
     });
     return function() {
@@ -11152,7 +11152,7 @@ defineComponent({
   setup: function setup2(props, _ref2) {
     var slots = _ref2.slots;
     var familyPrefix = config.familyPrefix;
-    var className = computed(function() {
+    var className = computed$2(function() {
       return [familyPrefix + "-layers"].concat(toConsumableArray(props.fixedWidth ? [familyPrefix + "-fw"] : []));
     });
     return function() {
@@ -11186,20 +11186,20 @@ defineComponent({
   setup: function setup3(props, _ref2) {
     var attrs = _ref2.attrs;
     var familyPrefix = config.familyPrefix;
-    var classes = computed(function() {
+    var classes = computed$2(function() {
       return objectWithKey("classes", [].concat(toConsumableArray(props.counter ? [familyPrefix + "-layers-counter"] : []), toConsumableArray(props.position ? [familyPrefix + "-layers-" + props.position] : [])));
     });
-    var transform2 = computed(function() {
+    var transform2 = computed$2(function() {
       return objectWithKey("transform", typeof props.transform === "string" ? parse.transform(props.transform) : props.transform);
     });
-    var abstractElement = computed(function() {
+    var abstractElement = computed$2(function() {
       var _text = text(props.value.toString(), _extends({}, transform2.value, classes.value)), abstract = _text.abstract;
       if (props.counter) {
         abstract[0].attributes.class = abstract[0].attributes.class.replace("fa-layers-text", "");
       }
       return abstract[0];
     });
-    var vnode = computed(function() {
+    var vnode = computed$2(function() {
       return convert(abstractElement.value, {}, attrs);
     });
     return function() {
@@ -11207,27 +11207,6 @@ defineComponent({
     };
   }
 });
-function render$a(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_font_awesome_icon = resolveComponent("font-awesome-icon");
-  return openBlock(), createElementBlock("div", {
-    class: normalizeClass(["ck-icon", $options.computedClass]),
-    onClick: _cache[0] || (_cache[0] = ($event) => $options.onClick($event))
-  }, [
-    $options.computediconPack === "font-awesome" ? (openBlock(), createBlock(_component_font_awesome_icon, {
-      key: 0,
-      icon: $props.icon,
-      size: $props.size,
-      rotation: $props.rotation,
-      flip: $props.flip,
-      pull: $props.pull,
-      spin: $props.spin,
-      pulse: $props.pulse,
-      inverse: $props.inverse,
-      "fixed-width": $props.fixedWidth,
-      "swap-opacity": $props.swapOpacity
-    }, null, 8, ["icon", "size", "rotation", "flip", "pull", "spin", "pulse", "inverse", "fixed-width", "swap-opacity"])) : createCommentVNode("", true)
-  ], 2);
-}
 var ckIcon_vue_vue_type_style_index_0_scoped_true_lang = "";
 var _export_sfc = (sfc, props) => {
   const target = sfc.__vccOpts || sfc;
@@ -11236,11 +11215,7 @@ var _export_sfc = (sfc, props) => {
   }
   return target;
 };
-const _sfc_main$l = {
-  name: "CkIcon",
-  components: {
-    FontAwesomeIcon
-  },
+const _sfc_main$l = /* @__PURE__ */ defineComponent({
   props: {
     icon: { type: [String, Array], default: "" },
     color: { type: String, default: "" },
@@ -11256,75 +11231,60 @@ const _sfc_main$l = {
     swapOpacity: { type: Boolean, default: false }
   },
   emits: ["click"],
-  computed: {
-    computediconPack() {
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    library.add(_iconsCache$2);
+    library.add(_iconsCache$1);
+    library.add(_iconsCache);
+    const computediconPack = computed$2(() => {
       const defaultPackage = "font-awesome";
-      if (this.iconPack === "")
+      if (props.iconPack === "")
         return defaultPackage;
-      if (this.iconPack === "feather")
-        return this.iconPack;
+      if (props.iconPack === "feather")
+        return props.iconPack;
       return defaultPackage;
-    },
-    computedClass() {
+    });
+    const computedClass = computed$2(() => {
       const classList2 = [];
-      if (this.color)
-        classList2.push(`ck-component__color--${this.color}`);
+      if (props.color)
+        classList2.push(`ck-component__color--${props.color}`);
       return classList2;
+    });
+    function onClick(event) {
+      emits("click", event);
     }
-  },
-  created() {
-    library.add(_iconsCache$2);
-    library.add(_iconsCache$1);
-    library.add(_iconsCache);
-  },
-  methods: {
-    onClick(event) {
-      this.$emit("click", event);
-    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["ck-icon", unref$1(computedClass)]),
+        onClick: _cache[0] || (_cache[0] = ($event) => onClick($event))
+      }, [
+        unref$1(computediconPack) === "font-awesome" ? (openBlock(), createBlock(unref$1(FontAwesomeIcon), {
+          key: 0,
+          icon: __props.icon,
+          size: __props.size,
+          rotation: __props.rotation,
+          flip: __props.flip,
+          pull: __props.pull,
+          spin: __props.spin,
+          pulse: __props.pulse,
+          inverse: __props.inverse,
+          "fixed-width": __props.fixedWidth,
+          "swap-opacity": __props.swapOpacity
+        }, null, 8, ["icon", "size", "rotation", "flip", "pull", "spin", "pulse", "inverse", "fixed-width", "swap-opacity"])) : createCommentVNode("", true)
+      ], 2);
+    };
   }
-};
-var ckIcon = /* @__PURE__ */ _export_sfc(_sfc_main$l, [["render", render$a], ["__scopeId", "data-v-77d9963a"]]);
-const _hoisted_1$i = ["title", "aria-label", "disabled"];
-function render$9(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_ck_icon = resolveComponent("ck-icon");
-  return openBlock(), createElementBlock("button", {
-    type: "button",
-    class: normalizeClass($options.computedClass),
-    title: $props.title,
-    "aria-label": $props.title,
-    disabled: $props.disabled,
-    onClick: _cache[0] || (_cache[0] = ($event) => $options.onClick($event))
-  }, [
-    $props.icon ? (openBlock(), createBlock(_component_ck_icon, {
-      key: 0,
-      class: "ck-button__icon-left",
-      icon: $props.icon,
-      "icon-pack": $props.iconPack
-    }, null, 8, ["icon", "icon-pack"])) : createCommentVNode("", true),
-    renderSlot(_ctx.$slots, "default", {}, void 0, true),
-    $props.iconRight ? (openBlock(), createBlock(_component_ck_icon, {
-      key: 1,
-      class: "ck-button__icon-right",
-      icon: $props.iconRight,
-      "icon-pack": $props.iconPack
-    }, null, 8, ["icon", "icon-pack"])) : createCommentVNode("", true)
-  ], 10, _hoisted_1$i);
-}
+});
+var ckIcon = /* @__PURE__ */ _export_sfc(_sfc_main$l, [["__scopeId", "data-v-25801d7b"]]);
 var ckButton_vue_vue_type_style_index_0_scoped_true_lang = "";
-const defaultType = "outlined";
-const defaultColor = "primary";
-const defaultAlign = "left";
-const _sfc_main$k = {
-  name: "CkButton",
-  components: {
-    ckIcon
-  },
+const _hoisted_1$i = ["title", "aria-label", "disabled"];
+const _sfc_main$k = /* @__PURE__ */ defineComponent({
   props: {
     title: { type: String, default: void 0 },
     disabled: { type: Boolean, default: false },
-    type: { type: String, default: defaultType, validator: validators.buttonType },
-    color: { type: String, default: defaultColor },
-    align: { type: String, default: defaultAlign, validator: validators.align },
+    type: { type: String, default: "outlined", validator: validators.buttonType },
+    color: { type: String, default: "primary" },
+    align: { type: String, default: "left", validator: validators.align },
     icon: { type: [String, Array], default: void 0 },
     iconPack: { type: String, default: void 0 },
     iconRight: { type: String, default: void 0 },
@@ -11335,108 +11295,921 @@ const _sfc_main$k = {
     groupVertical: { type: String, default: void 0, validator: validators.groupVertical }
   },
   emits: ["click"],
-  computed: {
-    computedClass() {
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    let context;
+    const isMounted = ref(false);
+    const computedClass = computed$2(() => {
       const classList2 = [];
-      classList2.push(functions$1.getGroupClass(this));
-      if (this.color !== defaultColor) {
-        if (this.type === "filled") {
-          classList2.push(`ck-component__bg-color--${this.color}`);
+      classList2.push(functions$1.getGroupClass(props));
+      if (props.color !== "primary") {
+        if (props.type === "filled") {
+          classList2.push(`ck-component__bg-color--${props.color}`);
         } else {
-          classList2.push(`ck-component__border-color--${this.color}`);
+          classList2.push(`ck-component__border-color--${props.color}`);
         }
       }
-      if (this.align !== defaultAlign) {
-        classList2.push(`ck-button__align--${this.align}`);
+      if (props.align !== "left") {
+        classList2.push(`ck-button__align--${props.align}`);
       }
-      if (!this.$slots.default) {
-        if (this.icon || this.iconRight) {
-          if (!(this.icon && this.iconRight))
-            classList2.push("just-icon");
+      if (isMounted.value) {
+        if (!context.$slots.default) {
+          if (props.icon || props.iconRight) {
+            if (!(props.icon && props.iconRight))
+              classList2.push("just-icon");
+          }
         }
       }
-      let type = this.type;
-      if (!validators.buttonType(this.type))
-        type = defaultType;
+      let type = props.type;
+      if (!validators.buttonType(props.type))
+        type = "outlined";
       classList2.push(`type-${type}`);
       return classList2;
+    });
+    function onClick(event) {
+      emits("click", event);
     }
-  },
-  methods: {
-    onClick(event) {
-      this.$emit("click", event);
+    onMounted(() => {
+      context = getCurrentInstance().ctx;
+      isMounted.value = true;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("button", {
+        type: "button",
+        class: normalizeClass(unref$1(computedClass)),
+        title: __props.title,
+        "aria-label": __props.title,
+        disabled: __props.disabled,
+        onClick: _cache[0] || (_cache[0] = ($event) => onClick($event))
+      }, [
+        __props.icon ? (openBlock(), createBlock(ckIcon, {
+          key: 0,
+          class: "ck-button__icon-left",
+          icon: __props.icon,
+          "icon-pack": __props.iconPack
+        }, null, 8, ["icon", "icon-pack"])) : createCommentVNode("", true),
+        renderSlot(_ctx.$slots, "default", {}, void 0, true),
+        __props.iconRight ? (openBlock(), createBlock(ckIcon, {
+          key: 1,
+          class: "ck-button__icon-right",
+          icon: __props.iconRight,
+          "icon-pack": __props.iconPack
+        }, null, 8, ["icon", "icon-pack"])) : createCommentVNode("", true)
+      ], 10, _hoisted_1$i);
+    };
+  }
+});
+var ckButton = /* @__PURE__ */ _export_sfc(_sfc_main$k, [["__scopeId", "data-v-36b03be6"]]);
+const NOOP$1 = () => {
+};
+const isArray$1 = Array.isArray;
+const isFunction$1 = (val) => typeof val === "function";
+const isSymbol = (val) => typeof val === "symbol";
+const def = (obj, key, value) => {
+  Object.defineProperty(obj, key, {
+    configurable: true,
+    enumerable: false,
+    value
+  });
+};
+let activeEffectScope;
+function recordEffectScope(effect3, scope) {
+  scope = scope || activeEffectScope;
+  if (scope && scope.active) {
+    scope.effects.push(effect3);
+  }
+}
+const createDep = (effects) => {
+  const dep = new Set(effects);
+  dep.w = 0;
+  dep.n = 0;
+  return dep;
+};
+const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
+const newTracked = (dep) => (dep.n & trackOpBit) > 0;
+const initDepMarkers = ({ deps }) => {
+  if (deps.length) {
+    for (let i = 0; i < deps.length; i++) {
+      deps[i].w |= trackOpBit;
+    }
+  }
+};
+const finalizeDepMarkers = (effect3) => {
+  const { deps } = effect3;
+  if (deps.length) {
+    let ptr = 0;
+    for (let i = 0; i < deps.length; i++) {
+      const dep = deps[i];
+      if (wasTracked(dep) && !newTracked(dep)) {
+        dep.delete(effect3);
+      } else {
+        deps[ptr++] = dep;
+      }
+      dep.w &= ~trackOpBit;
+      dep.n &= ~trackOpBit;
+    }
+    deps.length = ptr;
+  }
+};
+let effectTrackDepth = 0;
+let trackOpBit = 1;
+const maxMarkerBits = 30;
+const effectStack = [];
+let activeEffect;
+class ReactiveEffect {
+  constructor(fn2, scheduler = null, scope) {
+    this.fn = fn2;
+    this.scheduler = scheduler;
+    this.active = true;
+    this.deps = [];
+    recordEffectScope(this, scope);
+  }
+  run() {
+    if (!this.active) {
+      return this.fn();
+    }
+    if (!effectStack.length || !effectStack.includes(this)) {
+      try {
+        effectStack.push(activeEffect = this);
+        enableTracking();
+        trackOpBit = 1 << ++effectTrackDepth;
+        if (effectTrackDepth <= maxMarkerBits) {
+          initDepMarkers(this);
+        } else {
+          cleanupEffect(this);
+        }
+        return this.fn();
+      } finally {
+        if (effectTrackDepth <= maxMarkerBits) {
+          finalizeDepMarkers(this);
+        }
+        trackOpBit = 1 << --effectTrackDepth;
+        resetTracking();
+        effectStack.pop();
+        const n = effectStack.length;
+        activeEffect = n > 0 ? effectStack[n - 1] : void 0;
+      }
+    }
+  }
+  stop() {
+    if (this.active) {
+      cleanupEffect(this);
+      if (this.onStop) {
+        this.onStop();
+      }
+      this.active = false;
+    }
+  }
+}
+function cleanupEffect(effect3) {
+  const { deps } = effect3;
+  if (deps.length) {
+    for (let i = 0; i < deps.length; i++) {
+      deps[i].delete(effect3);
+    }
+    deps.length = 0;
+  }
+}
+let shouldTrack = true;
+const trackStack = [];
+function enableTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = true;
+}
+function resetTracking() {
+  const last = trackStack.pop();
+  shouldTrack = last === void 0 ? true : last;
+}
+function isTracking() {
+  return shouldTrack && activeEffect !== void 0;
+}
+function trackEffects(dep, debuggerEventExtraInfo) {
+  let shouldTrack2 = false;
+  if (effectTrackDepth <= maxMarkerBits) {
+    if (!newTracked(dep)) {
+      dep.n |= trackOpBit;
+      shouldTrack2 = !wasTracked(dep);
+    }
+  } else {
+    shouldTrack2 = !dep.has(activeEffect);
+  }
+  if (shouldTrack2) {
+    dep.add(activeEffect);
+    activeEffect.deps.push(dep);
+  }
+}
+function triggerEffects(dep, debuggerEventExtraInfo) {
+  for (const effect3 of isArray$1(dep) ? dep : [...dep]) {
+    if (effect3 !== activeEffect || effect3.allowRecurse) {
+      if (effect3.scheduler) {
+        effect3.scheduler();
+      } else {
+        effect3.run();
+      }
+    }
+  }
+}
+new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol));
+function isReactive(value) {
+  if (isReadonly(value)) {
+    return isReactive(value["__v_raw"]);
+  }
+  return !!(value && value["__v_isReactive"]);
+}
+function isReadonly(value) {
+  return !!(value && value["__v_isReadonly"]);
+}
+function isShallow(value) {
+  return !!(value && value["__v_isShallow"]);
+}
+function toRaw(observed) {
+  const raw = observed && observed["__v_raw"];
+  return raw ? toRaw(raw) : observed;
+}
+function markRaw(value) {
+  def(value, "__v_skip", true);
+  return value;
+}
+function trackRefValue(ref2) {
+  if (isTracking()) {
+    ref2 = toRaw(ref2);
+    if (!ref2.dep) {
+      ref2.dep = createDep();
+    }
+    {
+      trackEffects(ref2.dep);
+    }
+  }
+}
+function triggerRefValue(ref2, newVal) {
+  ref2 = toRaw(ref2);
+  if (ref2.dep) {
+    {
+      triggerEffects(ref2.dep);
+    }
+  }
+}
+function isRef(r) {
+  return Boolean(r && r.__v_isRef === true);
+}
+function unref(ref2) {
+  return isRef(ref2) ? ref2.value : ref2;
+}
+const shallowUnwrapHandlers = {
+  get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
+  set: (target, key, value, receiver) => {
+    const oldValue = target[key];
+    if (isRef(oldValue) && !isRef(value)) {
+      oldValue.value = value;
+      return true;
+    } else {
+      return Reflect.set(target, key, value, receiver);
+    }
+  }
+};
+function proxyRefs(objectWithRefs) {
+  return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+}
+class ComputedRefImpl {
+  constructor(getter, _setter, isReadonly2, isSSR) {
+    this._setter = _setter;
+    this.dep = void 0;
+    this.__v_isRef = true;
+    this._dirty = true;
+    this.effect = new ReactiveEffect(getter, () => {
+      if (!this._dirty) {
+        this._dirty = true;
+        triggerRefValue(this);
+      }
+    });
+    this.effect.computed = this;
+    this.effect.active = this._cacheable = !isSSR;
+    this["__v_isReadonly"] = isReadonly2;
+  }
+  get value() {
+    const self2 = toRaw(this);
+    trackRefValue(self2);
+    if (self2._dirty || !self2._cacheable) {
+      self2._dirty = false;
+      self2._value = self2.effect.run();
     }
+    return self2._value;
+  }
+  set value(newValue) {
+    this._setter(newValue);
+  }
+}
+function computed$1(getterOrOptions, debugOptions, isSSR = false) {
+  let getter;
+  let setter;
+  const onlyGetter = isFunction$1(getterOrOptions);
+  if (onlyGetter) {
+    getter = getterOrOptions;
+    setter = NOOP$1;
+  } else {
+    getter = getterOrOptions.get;
+    setter = getterOrOptions.set;
+  }
+  const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+  return cRef;
+}
+Promise.resolve();
+const EMPTY_OBJ = {};
+const NOOP = () => {
+};
+const extend = Object.assign;
+const remove = (arr, el) => {
+  const i = arr.indexOf(el);
+  if (i > -1) {
+    arr.splice(i, 1);
   }
 };
-var ckButton = /* @__PURE__ */ _export_sfc(_sfc_main$k, [["render", render$9], ["__scopeId", "data-v-a687842a"]]);
-const _withScopeId$2 = (n) => (pushScopeId("data-v-69dfa524"), n = n(), popScopeId(), n);
+const isArray = Array.isArray;
+const isMap = (val) => toTypeString(val) === "[object Map]";
+const isSet = (val) => toTypeString(val) === "[object Set]";
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => {
+  return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => toTypeString(val) === "[object Object]";
+const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+function callWithErrorHandling(fn2, instance, type, args) {
+  let res;
+  try {
+    res = args ? fn2(...args) : fn2();
+  } catch (err) {
+    handleError(err, instance, type);
+  }
+  return res;
+}
+function callWithAsyncErrorHandling(fn2, instance, type, args) {
+  if (isFunction(fn2)) {
+    const res = callWithErrorHandling(fn2, instance, type, args);
+    if (res && isPromise(res)) {
+      res.catch((err) => {
+        handleError(err, instance, type);
+      });
+    }
+    return res;
+  }
+  const values = [];
+  for (let i = 0; i < fn2.length; i++) {
+    values.push(callWithAsyncErrorHandling(fn2[i], instance, type, args));
+  }
+  return values;
+}
+function handleError(err, instance, type, throwInDev = true) {
+  const contextVNode = instance ? instance.vnode : null;
+  if (instance) {
+    let cur = instance.parent;
+    const exposedInstance = instance.proxy;
+    const errorInfo = type;
+    while (cur) {
+      const errorCapturedHooks = cur.ec;
+      if (errorCapturedHooks) {
+        for (let i = 0; i < errorCapturedHooks.length; i++) {
+          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+            return;
+          }
+        }
+      }
+      cur = cur.parent;
+    }
+    const appErrorHandler = instance.appContext.config.errorHandler;
+    if (appErrorHandler) {
+      callWithErrorHandling(appErrorHandler, null, 10, [err, exposedInstance, errorInfo]);
+      return;
+    }
+  }
+  logError(err, type, contextVNode, throwInDev);
+}
+function logError(err, type, contextVNode, throwInDev = true) {
+  {
+    console.error(err);
+  }
+}
+let isFlushing = false;
+let isFlushPending = false;
+const queue = [];
+let flushIndex = 0;
+const pendingPreFlushCbs = [];
+let activePreFlushCbs = null;
+let preFlushIndex = 0;
+const pendingPostFlushCbs = [];
+let activePostFlushCbs = null;
+let postFlushIndex = 0;
+const resolvedPromise = Promise.resolve();
+let currentFlushPromise = null;
+let currentPreFlushParentJob = null;
+function nextTick(fn2) {
+  const p = currentFlushPromise || resolvedPromise;
+  return fn2 ? p.then(this ? fn2.bind(this) : fn2) : p;
+}
+function findInsertionIndex(id) {
+  let start2 = flushIndex + 1;
+  let end2 = queue.length;
+  while (start2 < end2) {
+    const middle = start2 + end2 >>> 1;
+    const middleJobId = getId(queue[middle]);
+    middleJobId < id ? start2 = middle + 1 : end2 = middle;
+  }
+  return start2;
+}
+function queueJob(job) {
+  if ((!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && job !== currentPreFlushParentJob) {
+    if (job.id == null) {
+      queue.push(job);
+    } else {
+      queue.splice(findInsertionIndex(job.id), 0, job);
+    }
+    queueFlush();
+  }
+}
+function queueFlush() {
+  if (!isFlushing && !isFlushPending) {
+    isFlushPending = true;
+    currentFlushPromise = resolvedPromise.then(flushJobs);
+  }
+}
+function queueCb(cb, activeQueue, pendingQueue, index) {
+  if (!isArray(cb)) {
+    if (!activeQueue || !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {
+      pendingQueue.push(cb);
+    }
+  } else {
+    pendingQueue.push(...cb);
+  }
+  queueFlush();
+}
+function queuePreFlushCb(cb) {
+  queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);
+}
+function queuePostFlushCb(cb) {
+  queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);
+}
+function flushPreFlushCbs(seen, parentJob = null) {
+  if (pendingPreFlushCbs.length) {
+    currentPreFlushParentJob = parentJob;
+    activePreFlushCbs = [...new Set(pendingPreFlushCbs)];
+    pendingPreFlushCbs.length = 0;
+    for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {
+      activePreFlushCbs[preFlushIndex]();
+    }
+    activePreFlushCbs = null;
+    preFlushIndex = 0;
+    currentPreFlushParentJob = null;
+    flushPreFlushCbs(seen, parentJob);
+  }
+}
+function flushPostFlushCbs(seen) {
+  if (pendingPostFlushCbs.length) {
+    const deduped = [...new Set(pendingPostFlushCbs)];
+    pendingPostFlushCbs.length = 0;
+    if (activePostFlushCbs) {
+      activePostFlushCbs.push(...deduped);
+      return;
+    }
+    activePostFlushCbs = deduped;
+    activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
+    for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+      activePostFlushCbs[postFlushIndex]();
+    }
+    activePostFlushCbs = null;
+    postFlushIndex = 0;
+  }
+}
+const getId = (job) => job.id == null ? Infinity : job.id;
+function flushJobs(seen) {
+  isFlushPending = false;
+  isFlushing = true;
+  flushPreFlushCbs(seen);
+  queue.sort((a, b) => getId(a) - getId(b));
+  const check = NOOP;
+  try {
+    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+      const job = queue[flushIndex];
+      if (job && job.active !== false) {
+        if (false)
+          ;
+        callWithErrorHandling(job, null, 14);
+      }
+    }
+  } finally {
+    flushIndex = 0;
+    queue.length = 0;
+    flushPostFlushCbs();
+    isFlushing = false;
+    currentFlushPromise = null;
+    if (queue.length || pendingPreFlushCbs.length || pendingPostFlushCbs.length) {
+      flushJobs(seen);
+    }
+  }
+}
+function queueEffectWithSuspense(fn2, suspense) {
+  if (suspense && suspense.pendingBranch) {
+    if (isArray(fn2)) {
+      suspense.effects.push(...fn2);
+    } else {
+      suspense.effects.push(fn2);
+    }
+  } else {
+    queuePostFlushCb(fn2);
+  }
+}
+const INITIAL_WATCHER_VALUE = {};
+function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger: onTrigger2 } = EMPTY_OBJ) {
+  const instance = currentInstance;
+  let getter;
+  let forceTrigger = false;
+  let isMultiSource = false;
+  if (isRef(source)) {
+    getter = () => source.value;
+    forceTrigger = isShallow(source);
+  } else if (isReactive(source)) {
+    getter = () => source;
+    deep = true;
+  } else if (isArray(source)) {
+    isMultiSource = true;
+    forceTrigger = source.some(isReactive);
+    getter = () => source.map((s) => {
+      if (isRef(s)) {
+        return s.value;
+      } else if (isReactive(s)) {
+        return traverse(s);
+      } else if (isFunction(s)) {
+        return callWithErrorHandling(s, instance, 2);
+      } else
+        ;
+    });
+  } else if (isFunction(source)) {
+    if (cb) {
+      getter = () => callWithErrorHandling(source, instance, 2);
+    } else {
+      getter = () => {
+        if (instance && instance.isUnmounted) {
+          return;
+        }
+        if (cleanup) {
+          cleanup();
+        }
+        return callWithAsyncErrorHandling(source, instance, 3, [onCleanup]);
+      };
+    }
+  } else {
+    getter = NOOP;
+  }
+  if (cb && deep) {
+    const baseGetter = getter;
+    getter = () => traverse(baseGetter());
+  }
+  let cleanup;
+  let onCleanup = (fn2) => {
+    cleanup = effect3.onStop = () => {
+      callWithErrorHandling(fn2, instance, 4);
+    };
+  };
+  let oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE;
+  const job = () => {
+    if (!effect3.active) {
+      return;
+    }
+    if (cb) {
+      const newValue = effect3.run();
+      if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) {
+        if (cleanup) {
+          cleanup();
+        }
+        callWithAsyncErrorHandling(cb, instance, 3, [
+          newValue,
+          oldValue === INITIAL_WATCHER_VALUE ? void 0 : oldValue,
+          onCleanup
+        ]);
+        oldValue = newValue;
+      }
+    } else {
+      effect3.run();
+    }
+  };
+  job.allowRecurse = !!cb;
+  let scheduler;
+  if (flush === "sync") {
+    scheduler = job;
+  } else if (flush === "post") {
+    scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
+  } else {
+    scheduler = () => {
+      if (!instance || instance.isMounted) {
+        queuePreFlushCb(job);
+      } else {
+        job();
+      }
+    };
+  }
+  const effect3 = new ReactiveEffect(getter, scheduler);
+  if (cb) {
+    if (immediate) {
+      job();
+    } else {
+      oldValue = effect3.run();
+    }
+  } else if (flush === "post") {
+    queuePostRenderEffect(effect3.run.bind(effect3), instance && instance.suspense);
+  } else {
+    effect3.run();
+  }
+  return () => {
+    effect3.stop();
+    if (instance && instance.scope) {
+      remove(instance.scope.effects, effect3);
+    }
+  };
+}
+function instanceWatch(source, value, options) {
+  const publicThis = this.proxy;
+  const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+  let cb;
+  if (isFunction(value)) {
+    cb = value;
+  } else {
+    cb = value.handler;
+    options = value;
+  }
+  const cur = currentInstance;
+  setCurrentInstance(this);
+  const res = doWatch(getter, cb.bind(publicThis), options);
+  if (cur) {
+    setCurrentInstance(cur);
+  } else {
+    unsetCurrentInstance();
+  }
+  return res;
+}
+function createPathGetter(ctx, path) {
+  const segments = path.split(".");
+  return () => {
+    let cur = ctx;
+    for (let i = 0; i < segments.length && cur; i++) {
+      cur = cur[segments[i]];
+    }
+    return cur;
+  };
+}
+function traverse(value, seen) {
+  if (!isObject(value) || value["__v_skip"]) {
+    return value;
+  }
+  seen = seen || new Set();
+  if (seen.has(value)) {
+    return value;
+  }
+  seen.add(value);
+  if (isRef(value)) {
+    traverse(value.value, seen);
+  } else if (isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      traverse(value[i], seen);
+    }
+  } else if (isSet(value) || isMap(value)) {
+    value.forEach((v) => {
+      traverse(v, seen);
+    });
+  } else if (isPlainObject(value)) {
+    for (const key in value) {
+      traverse(value[key], seen);
+    }
+  }
+  return value;
+}
+function resolveMergedOptions(instance) {
+  const base = instance.type;
+  const { mixins, extends: extendsOptions } = base;
+  const { mixins: globalMixins, optionsCache: cache, config: { optionMergeStrategies } } = instance.appContext;
+  const cached = cache.get(base);
+  let resolved;
+  if (cached) {
+    resolved = cached;
+  } else if (!globalMixins.length && !mixins && !extendsOptions) {
+    {
+      resolved = base;
+    }
+  } else {
+    resolved = {};
+    if (globalMixins.length) {
+      globalMixins.forEach((m) => mergeOptions(resolved, m, optionMergeStrategies, true));
+    }
+    mergeOptions(resolved, base, optionMergeStrategies);
+  }
+  cache.set(base, resolved);
+  return resolved;
+}
+function mergeOptions(to, from, strats, asMixin = false) {
+  const { mixins, extends: extendsOptions } = from;
+  if (extendsOptions) {
+    mergeOptions(to, extendsOptions, strats, true);
+  }
+  if (mixins) {
+    mixins.forEach((m) => mergeOptions(to, m, strats, true));
+  }
+  for (const key in from) {
+    if (asMixin && key === "expose")
+      ;
+    else {
+      const strat = internalOptionMergeStrats[key] || strats && strats[key];
+      to[key] = strat ? strat(to[key], from[key]) : from[key];
+    }
+  }
+  return to;
+}
+const internalOptionMergeStrats = {
+  data: mergeDataFn,
+  props: mergeObjectOptions,
+  emits: mergeObjectOptions,
+  methods: mergeObjectOptions,
+  computed: mergeObjectOptions,
+  beforeCreate: mergeAsArray,
+  created: mergeAsArray,
+  beforeMount: mergeAsArray,
+  mounted: mergeAsArray,
+  beforeUpdate: mergeAsArray,
+  updated: mergeAsArray,
+  beforeDestroy: mergeAsArray,
+  beforeUnmount: mergeAsArray,
+  destroyed: mergeAsArray,
+  unmounted: mergeAsArray,
+  activated: mergeAsArray,
+  deactivated: mergeAsArray,
+  errorCaptured: mergeAsArray,
+  serverPrefetch: mergeAsArray,
+  components: mergeObjectOptions,
+  directives: mergeObjectOptions,
+  watch: mergeWatchOptions,
+  provide: mergeDataFn,
+  inject: mergeInject
+};
+function mergeDataFn(to, from) {
+  if (!from) {
+    return to;
+  }
+  if (!to) {
+    return from;
+  }
+  return function mergedDataFn() {
+    return extend(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from);
+  };
+}
+function mergeInject(to, from) {
+  return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
+}
+function normalizeInject(raw) {
+  if (isArray(raw)) {
+    const res = {};
+    for (let i = 0; i < raw.length; i++) {
+      res[raw[i]] = raw[i];
+    }
+    return res;
+  }
+  return raw;
+}
+function mergeAsArray(to, from) {
+  return to ? [...new Set([].concat(to, from))] : from;
+}
+function mergeObjectOptions(to, from) {
+  return to ? extend(extend(Object.create(null), to), from) : from;
+}
+function mergeWatchOptions(to, from) {
+  if (!to)
+    return from;
+  if (!from)
+    return to;
+  const merged = extend(Object.create(null), to);
+  for (const key in from) {
+    merged[key] = mergeAsArray(to[key], from[key]);
+  }
+  return merged;
+}
+const queuePostRenderEffect = queueEffectWithSuspense;
+const getPublicInstance = (i) => {
+  if (!i)
+    return null;
+  if (isStatefulComponent(i))
+    return getExposeProxy(i) || i.proxy;
+  return getPublicInstance(i.parent);
+};
+const publicPropertiesMap = extend(Object.create(null), {
+  $: (i) => i,
+  $el: (i) => i.vnode.el,
+  $data: (i) => i.data,
+  $props: (i) => i.props,
+  $attrs: (i) => i.attrs,
+  $slots: (i) => i.slots,
+  $refs: (i) => i.refs,
+  $parent: (i) => getPublicInstance(i.parent),
+  $root: (i) => getPublicInstance(i.root),
+  $emit: (i) => i.emit,
+  $options: (i) => resolveMergedOptions(i),
+  $forceUpdate: (i) => () => queueJob(i.update),
+  $nextTick: (i) => nextTick.bind(i.proxy),
+  $watch: (i) => instanceWatch.bind(i)
+});
+let currentInstance = null;
+const setCurrentInstance = (instance) => {
+  currentInstance = instance;
+  instance.scope.on();
+};
+const unsetCurrentInstance = () => {
+  currentInstance && currentInstance.scope.off();
+  currentInstance = null;
+};
+function isStatefulComponent(instance) {
+  return instance.vnode.shapeFlag & 4;
+}
+let isInSSRComponentSetup = false;
+function getExposeProxy(instance) {
+  if (instance.exposed) {
+    return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
+      get(target, key) {
+        if (key in target) {
+          return target[key];
+        } else if (key in publicPropertiesMap) {
+          return publicPropertiesMap[key](instance);
+        }
+      }
+    }));
+  }
+}
+const computed = (getterOrOptions, debugOptions) => {
+  return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
+};
+var ckCheckbox_vue_vue_type_style_index_0_scoped_true_lang = "";
+const _withScopeId$2 = (n) => (pushScopeId("data-v-132565da"), n = n(), popScopeId(), n);
 const _hoisted_1$h = ["disabled", "checked"];
 const _hoisted_2$8 = /* @__PURE__ */ _withScopeId$2(() => /* @__PURE__ */ createElementVNode("div", { class: "ck-checkbox__element" }, null, -1));
 const _hoisted_3$5 = {
   key: 0,
   class: "c-Checkbox__label"
 };
-function render$8(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(), createElementBlock("label", mergeProps({ class: "ck-checkbox" }, $options.checkboxAttributes, {
-    onKeydown: _cache[1] || (_cache[1] = withKeys(withModifiers(() => {
-    }, ["prevent"]), ["space"])),
-    onKeyup: [
-      _cache[2] || (_cache[2] = withKeys(($event) => $options.onTrigger(), ["enter"])),
-      _cache[3] || (_cache[3] = withKeys(($event) => $options.onTrigger(), ["space"]))
-    ]
-  }), [
-    createElementVNode("input", {
-      class: "ck-checkbox__input",
-      "aria-hidden": "true",
-      type: "checkbox",
-      disabled: $props.disabled,
-      checked: $options.value,
-      onChange: _cache[0] || (_cache[0] = ($event) => {
-        $options.value = $event.target.checked;
-        $options.onChange($event);
-      })
-    }, null, 40, _hoisted_1$h),
-    _hoisted_2$8,
-    _ctx.$slots.default ? (openBlock(), createElementBlock("span", _hoisted_3$5, [
-      renderSlot(_ctx.$slots, "default", {}, void 0, true)
-    ])) : createCommentVNode("", true)
-  ], 16);
-}
-var ckCheckbox_vue_vue_type_style_index_0_scoped_true_lang = "";
-const _sfc_main$j = {
-  name: "CkCheckbox",
+const _sfc_main$j = /* @__PURE__ */ defineComponent({
   props: {
     modelValue: { type: Boolean, default: false },
     label: { type: String, default: void 0 },
     disabled: { type: Boolean, default: false }
   },
   emits: ["update:modelValue", "change"],
-  computed: {
-    value: {
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const value = computed({
       get() {
-        return this.modelValue;
+        return props.modelValue;
       },
       set(val) {
-        this.$emit("update:modelValue", val);
+        emits("update:modelValue", val);
       }
-    },
-    checkboxAttributes() {
+    });
+    const checkboxAttributes = computed(() => {
       return {
-        "aria-disabled": this.disabled,
-        tabindex: this.disabled ? void 0 : "0"
+        "aria-disabled": props.disabled,
+        tabindex: props.disabled ? void 0 : "0"
       };
+    });
+    function onChange(event) {
+      emits("change", event);
     }
-  },
-  methods: {
-    onChange(event) {
-      this.$emit("change", event);
-    },
-    onTrigger() {
-      this.value = !this.value;
+    function onTrigger2() {
+      value.value = !value.value;
     }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", mergeProps({ class: "ck-checkbox" }, unref$1(checkboxAttributes), {
+        onKeydown: _cache[1] || (_cache[1] = withKeys(withModifiers(() => {
+        }, ["prevent"]), ["space"])),
+        onKeyup: [
+          _cache[2] || (_cache[2] = withKeys(($event) => onTrigger2(), ["enter"])),
+          _cache[3] || (_cache[3] = withKeys(($event) => onTrigger2(), ["space"]))
+        ]
+      }), [
+        createElementVNode("input", {
+          class: "ck-checkbox__input",
+          "aria-hidden": "true",
+          type: "checkbox",
+          disabled: __props.disabled,
+          checked: unref$1(value),
+          onChange: _cache[0] || (_cache[0] = ($event) => {
+            value.value = $event.target.checked;
+            onChange($event);
+          })
+        }, null, 40, _hoisted_1$h),
+        _hoisted_2$8,
+        _ctx.$slots.default ? (openBlock(), createElementBlock("span", _hoisted_3$5, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ])) : createCommentVNode("", true)
+      ], 16);
+    };
   }
-};
-var ckCheckbox = /* @__PURE__ */ _export_sfc(_sfc_main$j, [["render", render$8], ["__scopeId", "data-v-69dfa524"]]);
+});
+var ckCheckbox = /* @__PURE__ */ _export_sfc(_sfc_main$j, [["__scopeId", "data-v-132565da"]]);
 var ckChip_vue_vue_type_style_index_0_scoped_true_lang = "";
 const _hoisted_1$g = ["color"];
 const _sfc_main$i = /* @__PURE__ */ defineComponent({
@@ -11450,13 +12223,13 @@ const _sfc_main$i = /* @__PURE__ */ defineComponent({
   emits: ["click"],
   setup(__props, { emit: emits }) {
     const props = __props;
-    const computedClass = computed(() => {
+    const computedClass = computed$2(() => {
       return [
         `size-${props.size}`,
         `ck-component__bg-color--${props.color}`
       ];
     });
-    const computedStyle = computed(() => {
+    const computedStyle = computed$2(() => {
       const list = [];
       if (props.color)
         ;
@@ -11464,9 +12237,9 @@ const _sfc_main$i = /* @__PURE__ */ defineComponent({
     });
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock("div", {
-        class: normalizeClass(["ck-chip", unref(computedClass)]),
+        class: normalizeClass(["ck-chip", unref$1(computedClass)]),
         color: __props.color,
-        style: normalizeStyle(unref(computedStyle)),
+        style: normalizeStyle(unref$1(computedStyle)),
         onClick: _cache[0] || (_cache[0] = ($event) => emits("click", $event))
       }, [
         __props.icon ? (openBlock(), createBlock(ckIcon, {
@@ -11480,6 +12253,11 @@ const _sfc_main$i = /* @__PURE__ */ defineComponent({
   }
 });
 var ckChip = /* @__PURE__ */ _export_sfc(_sfc_main$i, [["__scopeId", "data-v-73ff343b"]]);
+var globalVariables = {
+  defaultFailImg: "df",
+  imagesFolderPath: "",
+  defaultImgBorderColor: "#EEEEEE"
+};
 var ckImg_vue_vue_type_style_index_0_scoped_true_lang = "";
 const _hoisted_1$f = ["src", "alt"];
 const _sfc_main$h = /* @__PURE__ */ defineComponent({
@@ -11502,14 +12280,14 @@ const _sfc_main$h = /* @__PURE__ */ defineComponent({
     const props = __props;
     const altNeeded = ref(false);
     let isMounted = ref(false);
-    const imageUrl = computed(() => {
+    const imageUrl = computed$2(() => {
       if (!isMounted.value)
         return "";
       if (props.isFullPath)
         return props.src;
       return getImg(props.src);
     });
-    const computedClass = computed(() => {
+    const computedClass = computed$2(() => {
       const classList2 = [];
       let size = props.size;
       if (!size && !props.sizeAbsolute && !props.width && !props.height) {
@@ -11527,7 +12305,7 @@ const _sfc_main$h = /* @__PURE__ */ defineComponent({
         classList2.push("zoom-able");
       return classList2;
     });
-    const computedStyle = computed(() => {
+    const computedStyle = computed$2(() => {
       const styleList = [];
       if (props.sizeAbsolute) {
         styleList.push({ width: props.sizeAbsolute });
@@ -11542,7 +12320,7 @@ const _sfc_main$h = /* @__PURE__ */ defineComponent({
       }
       return styleList;
     });
-    const computedImgStyle = computed(() => {
+    const computedImgStyle = computed$2(() => {
       const styleList = [];
       if (props.radius)
         styleList.push({ "border-radius": props.radius });
@@ -11552,7 +12330,7 @@ const _sfc_main$h = /* @__PURE__ */ defineComponent({
         styleList.push({ height: props.height });
       return styleList;
     });
-    const realBorderColor = computed(() => {
+    const realBorderColor = computed$2(() => {
       if (props.borderColor)
         return props.borderColor;
       return globalVariables.defaultImgBorderColor;
@@ -11576,13 +12354,13 @@ const _sfc_main$h = /* @__PURE__ */ defineComponent({
     });
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock("div", {
-        class: normalizeClass(["ck-img", unref(computedClass)]),
-        style: normalizeStyle(unref(computedStyle)),
+        class: normalizeClass(["ck-img", unref$1(computedClass)]),
+        style: normalizeStyle(unref$1(computedStyle)),
         onClick: _cache[1] || (_cache[1] = ($event) => clickImg())
       }, [
         createElementVNode("img", {
-          src: unref(imageUrl),
-          style: normalizeStyle(unref(computedImgStyle)),
+          src: unref$1(imageUrl),
+          style: normalizeStyle(unref$1(computedImgStyle)),
           alt: __props.alt,
           onError: _cache[0] || (_cache[0] = ($event) => altNeeded.value = true)
         }, null, 44, _hoisted_1$f)
@@ -11591,34 +12369,34 @@ const _sfc_main$h = /* @__PURE__ */ defineComponent({
   }
 });
 var ckImg = /* @__PURE__ */ _export_sfc(_sfc_main$h, [["__scopeId", "data-v-53d78f2e"]]);
-const _hoisted_1$e = ["for"];
-function render$7(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(), createElementBlock("label", {
-    class: normalizeClass(["ck-label", $options.computedClass]),
-    for: $props.for
-  }, [
-    renderSlot(_ctx.$slots, "default", {}, void 0, true)
-  ], 10, _hoisted_1$e);
-}
 var ckLabel_vue_vue_type_style_index_0_scoped_true_lang = "";
-const _sfc_main$g = {
-  name: "CkLabel",
+const _hoisted_1$e = ["for"];
+const _sfc_main$g = /* @__PURE__ */ defineComponent({
   props: {
     for: { type: String, default: "" },
     align: { type: String, default: "" }
   },
-  computed: {
-    computedClass() {
+  setup(__props) {
+    const props = __props;
+    const computedClass = computed$2(() => {
       const list = [];
       let align = "left";
-      if (this.align === "center" || this.align === "right")
-        align = this.align;
+      if (props.align === "center" || props.align === "right")
+        align = props.align;
       list.push(`ck-align--${align}`);
       return list;
-    }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", {
+        class: normalizeClass(["ck-label", unref$1(computedClass)]),
+        for: __props.for
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 10, _hoisted_1$e);
+    };
   }
-};
-var ckLabel = /* @__PURE__ */ _export_sfc(_sfc_main$g, [["render", render$7], ["__scopeId", "data-v-4b8b9ab4"]]);
+});
+var ckLabel = /* @__PURE__ */ _export_sfc(_sfc_main$g, [["__scopeId", "data-v-6efffcd8"]]);
 var ckInput_vue_vue_type_style_index_0_scoped_true_lang = "";
 const _hoisted_1$d = { class: "ck-input" };
 const _hoisted_2$7 = ["type", "placeholder", "id", "disabled"];
@@ -11644,7 +12422,7 @@ const _sfc_main$f = /* @__PURE__ */ defineComponent({
   emits: ["update:modelValue", "click", "input", "change"],
   setup(__props, { emit: emits }) {
     const props = __props;
-    const value = computed({
+    const value = computed$2({
       get() {
         return props.modelValue;
       },
@@ -11663,13 +12441,13 @@ const _sfc_main$f = /* @__PURE__ */ defineComponent({
     const onChange = (event) => {
       emits("change", event);
     };
-    const computedStyleInput = computed(() => {
+    const computedStyleInput = computed$2(() => {
       const list = [];
       if (props.width)
         list.push({ width: props.width });
       return list;
     });
-    const computedClassInput = computed(() => {
+    const computedClassInput = computed$2(() => {
       const list = [];
       list.push(functions$1.getGroupClass(props));
       if (props.icon)
@@ -11702,18 +12480,18 @@ const _sfc_main$f = /* @__PURE__ */ defineComponent({
           "icon-pack": __props.iconPack
         }, null, 8, ["icon", "icon-pack"])) : createCommentVNode("", true),
         withDirectives(createElementVNode("input", {
-          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(value) ? value.value = $event : null),
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef$1(value) ? value.value = $event : null),
           type: __props.type,
           placeholder: __props.placeholder,
-          class: normalizeClass(unref(computedClassInput)),
-          style: normalizeStyle(unref(computedStyleInput)),
+          class: normalizeClass(unref$1(computedClassInput)),
+          style: normalizeStyle(unref$1(computedStyleInput)),
           id: __props.label ? "ck-input" : "",
           disabled: __props.disabled,
           onChange: _cache[1] || (_cache[1] = ($event) => onChange($event)),
           onInput: _cache[2] || (_cache[2] = ($event) => onInput($event)),
           onClick: _cache[3] || (_cache[3] = ($event) => onClick($event))
         }, null, 46, _hoisted_2$7), [
-          [vModelDynamic, unref(value)]
+          [vModelDynamic, unref$1(value)]
         ]),
         __props.iconRight ? (openBlock(), createBlock(ckIcon, {
           key: 2,
@@ -11749,7 +12527,7 @@ const _hoisted_7 = {
 };
 const _hoisted_8 = /* @__PURE__ */ createTextVNode("Cancelar");
 const _hoisted_9 = /* @__PURE__ */ createTextVNode("Aceptar");
-const __default__$1 = {
+const _sfc_main$e = /* @__PURE__ */ defineComponent({
   props: {
     modelValue: { type: Boolean },
     title: { type: String, default: void 0 },
@@ -11759,40 +12537,35 @@ const __default__$1 = {
     preventCloseOnCancel: { type: Boolean, default: false }
   },
   emits: ["update:modelValue", "cancel", "accept"],
-  computed: {
-    value: {
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const value = computed$2({
       get() {
-        return this.modelValue;
+        return props.modelValue;
       },
       set(val) {
-        this.$emit("update:modelValue", val);
+        emits("update:modelValue", val);
       }
+    });
+    function onCancel() {
+      emits("cancel");
+      if (!props.preventCloseOnCancel)
+        value.value = false;
     }
-  },
-  methods: {
-    onCancel() {
-      this.$emit("cancel");
-      if (!this.preventCloseOnCancel)
-        this.value = false;
-    },
-    onAccept() {
-      this.$emit("accept");
-    },
-    onBgClick() {
-      if (this.notCloseByBg)
+    function onAccept() {
+      emits("accept");
+    }
+    function onBgClick() {
+      if (props.notCloseByBg)
         return;
-      this.value = false;
+      value.value = false;
     }
-  }
-};
-const _sfc_main$e = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues({}, __default__$1), {
-  setup(__props) {
     return (_ctx, _cache) => {
-      return _ctx.value ? (openBlock(), createElementBlock("div", _hoisted_1$c, [
+      return unref$1(value) ? (openBlock(), createElementBlock("div", _hoisted_1$c, [
         _hoisted_2$6,
         createElementVNode("div", {
           class: "popup-container",
-          onClick: _cache[4] || (_cache[4] = ($event) => _ctx.onBgClick())
+          onClick: _cache[4] || (_cache[4] = ($event) => onBgClick())
         }, [
           createElementVNode("div", {
             class: "ck-popup__content",
@@ -11806,7 +12579,7 @@ const _sfc_main$e = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues
                 key: 1,
                 class: "mr-3 close",
                 icon: "times",
-                onClick: _cache[0] || (_cache[0] = ($event) => _ctx.value = false)
+                onClick: _cache[0] || (_cache[0] = ($event) => value.value = false)
               })) : createCommentVNode("", true)
             ]),
             createElementVNode("div", _hoisted_5$1, [
@@ -11817,7 +12590,7 @@ const _sfc_main$e = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues
               __props.confirmButtons ? (openBlock(), createElementBlock("div", _hoisted_7, [
                 createVNode(ckButton, {
                   class: "cancel-button",
-                  onClick: _cache[1] || (_cache[1] = ($event) => _ctx.onCancel()),
+                  onClick: _cache[1] || (_cache[1] = ($event) => onCancel()),
                   color: "danger"
                 }, {
                   default: withCtx(() => [
@@ -11826,7 +12599,7 @@ const _sfc_main$e = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues
                   _: 1
                 }),
                 createVNode(ckButton, {
-                  onClick: _cache[2] || (_cache[2] = ($event) => _ctx.onAccept())
+                  onClick: _cache[2] || (_cache[2] = ($event) => onAccept())
                 }, {
                   default: withCtx(() => [
                     _hoisted_9
@@ -11840,8 +12613,9 @@ const _sfc_main$e = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues
       ])) : createCommentVNode("", true);
     };
   }
-}));
-const _withScopeId$1 = (n) => (pushScopeId("data-v-73a891e8"), n = n(), popScopeId(), n);
+});
+var ckRadio_vue_vue_type_style_index_0_scoped_true_lang = "";
+const _withScopeId$1 = (n) => (pushScopeId("data-v-a5198d80"), n = n(), popScopeId(), n);
 const _hoisted_1$b = ["onKeyup"];
 const _hoisted_2$5 = ["name", "value", "disabled"];
 const _hoisted_3$3 = /* @__PURE__ */ _withScopeId$1(() => /* @__PURE__ */ createElementVNode("div", { class: "c-Radio__element" }, null, -1));
@@ -11849,38 +12623,7 @@ const _hoisted_4$2 = {
   key: 0,
   class: "c-Radio__label"
 };
-function render$6(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(true), createElementBlock(Fragment, null, renderList($props.options, (item, index) => {
-    return openBlock(), createElementBlock("label", mergeProps({
-      key: `radio-${index}`,
-      class: "c-Radio"
-    }, $options.radioAttributes, {
-      onKeydown: _cache[1] || (_cache[1] = withKeys(withModifiers(() => {
-      }, ["prevent"]), ["space"])),
-      onKeyup: [
-        withKeys(($event) => $options.handleChange(item.value), ["enter"]),
-        withKeys(($event) => $options.handleChange(item.value), ["space"])
-      ]
-    }), [
-      withDirectives(createElementVNode("input", {
-        class: "c-Radio__input",
-        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => $options.value = $event),
-        "aria-hidden": "true",
-        type: "radio",
-        name: $props.name,
-        value: item.value,
-        disabled: $props.disabled
-      }, null, 8, _hoisted_2$5), [
-        [vModelRadio, $options.value]
-      ]),
-      _hoisted_3$3,
-      item.label ? (openBlock(), createElementBlock("span", _hoisted_4$2, toDisplayString(item.label), 1)) : createCommentVNode("", true)
-    ], 16, _hoisted_1$b);
-  }), 128);
-}
-var ckRadio_vue_vue_type_style_index_0_scoped_true_lang = "";
-const _sfc_main$d = {
-  name: "CkRadio",
+const _sfc_main$d = /* @__PURE__ */ defineComponent({
   props: {
     modelValue: { type: String, default: void 0 },
     name: { type: String, required: true },
@@ -11888,30 +12631,58 @@ const _sfc_main$d = {
     disabled: { type: Boolean, default: false }
   },
   emits: ["update:modelValue", "change"],
-  computed: {
-    value: {
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const value = computed$2({
       get() {
-        return this.modelValue;
+        return props.modelValue;
       },
       set(val) {
-        this.$emit("update:modelValue", val);
+        emits("update:modelValue", val);
       }
-    },
-    radioAttributes() {
+    });
+    const radioAttributes = computed$2(() => {
       return {
-        "aria-disabled": this.disabled,
-        tabindex: this.disabled ? void 0 : "0"
+        "aria-disabled": props.disabled,
+        tabindex: props.disabled ? void 0 : "0"
       };
+    });
+    function handleChange(value2) {
+      value2.value = value2;
+      emits("change", value2);
     }
-  },
-  methods: {
-    handleChange(value) {
-      this.value = value;
-      this.$emit("change", value);
-    }
+    return (_ctx, _cache) => {
+      return openBlock(true), createElementBlock(Fragment, null, renderList(__props.options, (item, index) => {
+        return openBlock(), createElementBlock("label", mergeProps({
+          key: `radio-${index}`,
+          class: "c-Radio"
+        }, unref$1(radioAttributes), {
+          onKeydown: _cache[1] || (_cache[1] = withKeys(withModifiers(() => {
+          }, ["prevent"]), ["space"])),
+          onKeyup: [
+            withKeys(($event) => handleChange(item.value), ["enter"]),
+            withKeys(($event) => handleChange(item.value), ["space"])
+          ]
+        }), [
+          withDirectives(createElementVNode("input", {
+            class: "c-Radio__input",
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef$1(value) ? value.value = $event : null),
+            "aria-hidden": "true",
+            type: "radio",
+            name: __props.name,
+            value: item.value,
+            disabled: __props.disabled
+          }, null, 8, _hoisted_2$5), [
+            [vModelRadio, unref$1(value)]
+          ]),
+          _hoisted_3$3,
+          item.label ? (openBlock(), createElementBlock("span", _hoisted_4$2, toDisplayString(item.label), 1)) : createCommentVNode("", true)
+        ], 16, _hoisted_1$b);
+      }), 128);
+    };
   }
-};
-var ckRadio = /* @__PURE__ */ _export_sfc(_sfc_main$d, [["render", render$6], ["__scopeId", "data-v-73a891e8"]]);
+});
+var ckRadio = /* @__PURE__ */ _export_sfc(_sfc_main$d, [["__scopeId", "data-v-a5198d80"]]);
 var qmApi = {};
 var qmArray = {
   arrayToText(arr, key = null) {
@@ -12217,7 +12988,7 @@ const _sfc_main$c = /* @__PURE__ */ defineComponent({
     const { qmStr: qmStr2 } = main$1;
     const search = ref("");
     ref(null);
-    const value = computed({
+    const value = computed$2({
       get() {
         return props.modelValue;
       },
@@ -12227,25 +12998,25 @@ const _sfc_main$c = /* @__PURE__ */ defineComponent({
         emits("update:modelValue", val);
       }
     });
-    const filteredOptions = computed(() => {
+    const filteredOptions = computed$2(() => {
       const list = props.options.filter((option) => {
         const name = getOptionName(option);
         return qmStr2.checkContainsStr(name, search.value);
       });
       return list;
     });
-    const computedClass = computed(() => {
+    const computedClass = computed$2(() => {
       const classList2 = [];
       classList2.push(functions$1.getGroupClass(props));
       return classList2;
     });
-    const computedStyle = computed(() => {
+    const computedStyle = computed$2(() => {
       const list = [];
       if (props.minWidth)
         list.push({ "min-width": props.minWidth });
       return list;
     });
-    computed(() => {
+    computed$2(() => {
       if (props.searchable === "auto") {
         if (props.options.length < 5)
           return false;
@@ -12253,7 +13024,7 @@ const _sfc_main$c = /* @__PURE__ */ defineComponent({
       }
       return props.searchable;
     });
-    const realClearValue = computed(() => {
+    const realClearValue = computed$2(() => {
       switch (typeof props.modelValue) {
         case "number":
           return 0;
@@ -12267,7 +13038,7 @@ const _sfc_main$c = /* @__PURE__ */ defineComponent({
           return null;
       }
     });
-    computed(() => {
+    computed$2(() => {
       switch (typeof props.modelValue) {
         case "number":
           return props.modelValue === 0;
@@ -12306,7 +13077,7 @@ const _sfc_main$c = /* @__PURE__ */ defineComponent({
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock("div", {
         class: "ck-select",
-        style: normalizeStyle(unref(computedStyle))
+        style: normalizeStyle(unref$1(computedStyle))
       }, [
         __props.label ? (openBlock(), createBlock(ckLabel, {
           key: 0,
@@ -12319,19 +13090,19 @@ const _sfc_main$c = /* @__PURE__ */ defineComponent({
           _: 1
         }, 8, ["align"])) : createCommentVNode("", true),
         withDirectives(createElementVNode("select", {
-          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(value) ? value.value = $event : null),
-          class: normalizeClass(unref(computedClass)),
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef$1(value) ? value.value = $event : null),
+          class: normalizeClass(unref$1(computedClass)),
           onClick: _cache[1] || (_cache[1] = ($event) => onClick($event)),
           onChange: _cache[2] || (_cache[2] = ($event) => onChange($event))
         }, [
-          (openBlock(true), createElementBlock(Fragment, null, renderList(unref(filteredOptions), (option) => {
+          (openBlock(true), createElementBlock(Fragment, null, renderList(unref$1(filteredOptions), (option) => {
             return openBlock(), createElementBlock("option", {
               value: getOptionKey(option),
               key: option
             }, toDisplayString(getOptionName(option)), 9, _hoisted_1$a);
           }), 128))
         ], 34), [
-          [vModelSelect, unref(value)]
+          [vModelSelect, unref$1(value)]
         ])
       ], 4);
     };
@@ -12339,7 +13110,7 @@ const _sfc_main$c = /* @__PURE__ */ defineComponent({
 });
 var ckSelect = /* @__PURE__ */ _export_sfc(_sfc_main$c, [["__scopeId", "data-v-31af160a"]]);
 var ckSwitch_vue_vue_type_style_index_0_scoped_true_lang = "";
-const _withScopeId = (n) => (pushScopeId("data-v-6a563501"), n = n(), popScopeId(), n);
+const _withScopeId = (n) => (pushScopeId("data-v-35213eec"), n = n(), popScopeId(), n);
 const _hoisted_1$9 = ["disabled"];
 const _hoisted_2$4 = { class: "ck-switch__slider-container" };
 const _hoisted_3$2 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ createElementVNode("div", { class: "ck-switch__slider" }, null, -1));
@@ -12349,7 +13120,7 @@ const _hoisted_4$1 = {
 };
 const _sfc_main$b = /* @__PURE__ */ defineComponent({
   props: {
-    modelValue: { type: Boolean, default: false },
+    modelValue: { type: [Boolean, Number], default: false },
     disabled: { type: Boolean, default: false },
     outlined: { type: Boolean, default: false },
     squared: { type: Boolean, default: false },
@@ -12359,7 +13130,7 @@ const _sfc_main$b = /* @__PURE__ */ defineComponent({
   emits: ["update:modelValue"],
   setup(__props, { emit: emits }) {
     const props = __props;
-    const value = computed({
+    const value = computed$2({
       get() {
         return props.modelValue;
       },
@@ -12367,7 +13138,7 @@ const _sfc_main$b = /* @__PURE__ */ defineComponent({
         emits("update:modelValue", val);
       }
     });
-    const computedClass = computed(() => {
+    const computedClass = computed$2(() => {
       const list = [];
       if (props.squared)
         list.push("is-squared");
@@ -12375,7 +13146,7 @@ const _sfc_main$b = /* @__PURE__ */ defineComponent({
         list.push("is-outlined");
       return list;
     });
-    const computedAttributes = computed(() => {
+    const computedAttributes = computed$2(() => {
       return {
         "aria-disabled": props.disabled,
         tabindex: props.disabled ? void 0 : "0"
@@ -12385,8 +13156,8 @@ const _sfc_main$b = /* @__PURE__ */ defineComponent({
       value.value = !value.value;
     }
     return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("label", mergeProps({ class: "ck-switch" }, unref(computedAttributes), {
-        class: unref(computedClass),
+      return openBlock(), createElementBlock("label", mergeProps({ class: "ck-switch" }, unref$1(computedAttributes), {
+        class: unref$1(computedClass),
         onKeydown: _cache[2] || (_cache[2] = withKeys(withModifiers(() => {
         }, ["prevent"]), ["space"])),
         onKeyup: [
@@ -12398,21 +13169,21 @@ const _sfc_main$b = /* @__PURE__ */ defineComponent({
           class: "ck-switch__input",
           "aria-hidden": "true",
           type: "checkbox",
-          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(value) ? value.value = $event : null),
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef$1(value) ? value.value = $event : null),
           disabled: __props.disabled,
           onClick: _cache[1] || (_cache[1] = ($event) => onTrigger2())
         }, null, 8, _hoisted_1$9), [
-          [vModelCheckbox, unref(value)]
+          [vModelCheckbox, unref$1(value)]
         ]),
         createElementVNode("div", _hoisted_2$4, [
           _hoisted_3$2,
-          __props.icon && unref(value) ? (openBlock(), createBlock(ckIcon, {
+          __props.icon && unref$1(value) ? (openBlock(), createBlock(ckIcon, {
             key: 0,
             class: "ck-switch__icon-left",
             icon: __props.icon,
             "icon-pack": __props.iconPack
           }, null, 8, ["icon", "icon-pack"])) : createCommentVNode("", true),
-          __props.icon && !unref(value) ? (openBlock(), createBlock(ckIcon, {
+          __props.icon && !unref$1(value) ? (openBlock(), createBlock(ckIcon, {
             key: 1,
             class: "ck-switch__icon-right",
             icon: __props.icon,
@@ -12426,40 +13197,11 @@ const _sfc_main$b = /* @__PURE__ */ defineComponent({
     };
   }
 });
-var ckSwitch = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["__scopeId", "data-v-6a563501"]]);
+var ckSwitch = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["__scopeId", "data-v-35213eec"]]);
+var ckSwitchOptions_vue_vue_type_style_index_0_scoped_true_lang = "";
 const _hoisted_1$8 = { class: "ck-switch-options__container-exterior" };
 const _hoisted_2$3 = ["onClick"];
-function render$5(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_ck_label = resolveComponent("ck-label");
-  return openBlock(), createElementBlock("div", _hoisted_1$8, [
-    $props.label ? (openBlock(), createBlock(_component_ck_label, {
-      key: 0,
-      align: $props.labelAlign
-    }, {
-      default: withCtx(() => [
-        createTextVNode(toDisplayString($props.label), 1)
-      ]),
-      _: 1
-    }, 8, ["align"])) : createCommentVNode("", true),
-    createElementVNode("div", {
-      class: normalizeClass(["ck-switch-options__container", $options.computedClass])
-    }, [
-      (openBlock(true), createElementBlock(Fragment, null, renderList($props.options, (Option, index) => {
-        return openBlock(), createElementBlock("div", {
-          class: normalizeClass(["ck-switch-options__option", { selected: $options.selectedOption == $options.getOptionValue(Option) }]),
-          key: `ck-switch-options${index}`,
-          style: normalizeStyle($options.computedItemStyle),
-          onClick: ($event) => $options.selectedOption = $options.getOptionValue(Option)
-        }, toDisplayString(Option[$props.prop]), 15, _hoisted_2$3);
-      }), 128))
-    ], 2)
-  ]);
-}
-var ckSwitchOptions_vue_vue_type_style_index_0_scoped_true_lang = "";
-const _sfc_main$a = {
-  components: {
-    ckLabel
-  },
+const _sfc_main$a = /* @__PURE__ */ defineComponent({
   props: {
     modelValue: { type: [Boolean, Number, Object], default: 0 },
     options: { type: Array, required: true },
@@ -12474,80 +13216,105 @@ const _sfc_main$a = {
     sameWidthOptions: { type: Boolean, default: false }
   },
   emits: ["update:modelValue", "change"],
-  computed: {
-    selectedOption: {
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const selectedOption = computed$2({
       get() {
-        return this.modelValue;
+        return props.modelValue;
       },
       set(val) {
-        this.$emit("update:modelValue", val);
-        this.$emit("change", val);
+        emits("update:modelValue", val);
+        emits("change", val);
       }
-    },
-    computedClass() {
+    });
+    const computedClass = computed$2(() => {
       const classList2 = [];
-      classList2.push(functions$1.getGroupClass(this));
+      classList2.push(functions$1.getGroupClass(props));
       return classList2;
-    },
-    computedItemStyle() {
+    });
+    const computedItemStyle = computed$2(() => {
       const list = [];
-      if (this.sameWidthOptions)
-        list.push({ width: `${100 / this.options.length}%` });
+      if (props.sameWidthOptions)
+        list.push({ width: `${100 / props.options.length}%` });
       return list;
-    }
-  },
-  methods: {
-    getOptionValue(Option) {
-      if (this.notReduce)
+    });
+    function getOptionValue(Option) {
+      if (props.notReduce)
         return Option;
-      return this.reduceFunction(Option);
+      return props.reduceFunction(Option);
     }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$8, [
+        __props.label ? (openBlock(), createBlock(ckLabel, {
+          key: 0,
+          align: __props.labelAlign
+        }, {
+          default: withCtx(() => [
+            createTextVNode(toDisplayString(__props.label), 1)
+          ]),
+          _: 1
+        }, 8, ["align"])) : createCommentVNode("", true),
+        createElementVNode("div", {
+          class: normalizeClass(["ck-switch-options__container", unref$1(computedClass)])
+        }, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(__props.options, (Option, index) => {
+            return openBlock(), createElementBlock("div", {
+              class: normalizeClass(["ck-switch-options__option", { selected: unref$1(selectedOption) == getOptionValue(Option) }]),
+              key: `ck-switch-options${index}`,
+              style: normalizeStyle(unref$1(computedItemStyle)),
+              onClick: ($event) => selectedOption.value = getOptionValue(Option)
+            }, toDisplayString(Option[__props.prop]), 15, _hoisted_2$3);
+          }), 128))
+        ], 2)
+      ]);
+    };
   }
-};
-var ckSwitchOptions = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["render", render$5], ["__scopeId", "data-v-f0c51430"]]);
+});
+var ckSwitchOptions = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["__scopeId", "data-v-dfbb0b9e"]]);
 const _hoisted_1$7 = { class: "ck-tr" };
-function render$4(_ctx, _cache) {
+function render$1(_ctx, _cache) {
   return openBlock(), createElementBlock("tr", _hoisted_1$7, [
     renderSlot(_ctx.$slots, "default", {}, void 0, true)
   ]);
 }
 var ckTr_vue_vue_type_style_index_0_scoped_true_lang = "";
 const _sfc_main$9 = {};
-var ckTr = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["render", render$4], ["__scopeId", "data-v-1dd12190"]]);
-const _hoisted_1$6 = { class: "ck-th" };
-function render$3(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(), createElementBlock("th", _hoisted_1$6, [
-    createElementVNode("span", {
-      class: normalizeClass($options.computedSpanClass),
-      style: normalizeStyle($options.computedStyle)
-    }, [
-      renderSlot(_ctx.$slots, "default", {}, void 0, true)
-    ], 6)
-  ]);
-}
+var ckTr = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["render", render$1], ["__scopeId", "data-v-1dd12190"]]);
 var ckTh_vue_vue_type_style_index_0_scoped_true_lang = "";
-const _sfc_main$8 = {
+const _hoisted_1$6 = { class: "ck-th" };
+const _sfc_main$8 = /* @__PURE__ */ defineComponent({
   props: {
     align: { type: String, default: "center", validator: validators.align },
     minWidth: { type: String, default: void 0 }
   },
-  computed: {
-    computedSpanClass() {
+  setup(__props) {
+    const props = __props;
+    const computedSpanClass = computed$2(() => {
       return {
-        "align-center": this.align !== "left" && this.align !== "right",
-        "align-left": this.align === "left",
-        "align-right": this.align === "right"
+        "align-center": props.align !== "left" && props.align !== "right",
+        "align-left": props.align === "left",
+        "align-right": props.align === "right"
       };
-    },
-    computedStyle() {
+    });
+    const computedStyle = computed$2(() => {
       const list = [];
-      if (this.minWidth)
-        list.push({ "min-width": this.minWidth });
+      if (props.minWidth)
+        list.push({ "min-width": props.minWidth });
       return list;
-    }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("th", _hoisted_1$6, [
+        createElementVNode("span", {
+          class: normalizeClass(unref$1(computedSpanClass)),
+          style: normalizeStyle(unref$1(computedStyle))
+        }, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ], 6)
+      ]);
+    };
   }
-};
-var ckTh = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["render", render$3], ["__scopeId", "data-v-e9943550"]]);
+});
+var ckTh = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["__scopeId", "data-v-a6c5a34e"]]);
 const _sfc_main$7 = /* @__PURE__ */ defineComponent({
   props: {
     col: { type: Object, required: true }
@@ -12581,7 +13348,7 @@ const _sfc_main$6 = /* @__PURE__ */ defineComponent({
   emits: ["update:search", "refreshList", "openColumnsManager"],
   setup(__props, { emit: emits }) {
     const props = __props;
-    const searchLocal = computed({
+    const searchLocal = computed$2({
       get() {
         return props.search;
       },
@@ -12589,22 +13356,22 @@ const _sfc_main$6 = /* @__PURE__ */ defineComponent({
         emits("update:search", val);
       }
     });
-    const hideSearch = computed(() => {
+    const hideSearch = computed$2(() => {
       return typeof searchLocal.value === "undefined";
     });
-    const itemsPerPageStart = computed(() => {
+    const itemsPerPageStart = computed$2(() => {
       return (props.currentPage - 1) * props.itemsPerPage + 1;
     });
-    const itemsPerPageEnd = computed(() => {
+    const itemsPerPageEnd = computed$2(() => {
       const value = props.currentPage * props.itemsPerPage;
       if (value > props.listLength)
         return props.listLength;
       return value;
     });
-    const itemsPerPageIsVisible = computed(() => {
+    const itemsPerPageIsVisible = computed$2(() => {
       return !props.hideItemsPerPage && props.listLength;
     });
-    const searchGroupValue = computed(() => {
+    const searchGroupValue = computed$2(() => {
       if (itemsPerPageIsVisible.value && props.hasColumnsManager) {
         return "center";
       }
@@ -12631,17 +13398,17 @@ const _sfc_main$6 = /* @__PURE__ */ defineComponent({
           title: "Recargar lista",
           onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("refreshList", false))
         })) : createCommentVNode("", true),
-        unref(itemsPerPageIsVisible) ? (openBlock(), createElementBlock("div", {
+        unref$1(itemsPerPageIsVisible) ? (openBlock(), createElementBlock("div", {
           key: 1,
-          class: normalizeClass(["items-per-page", { "ck-component__group--left": !unref(hideSearch) }])
-        }, toDisplayString(unref(itemsPerPageStart)) + " - " + toDisplayString(unref(itemsPerPageEnd)) + " de " + toDisplayString(__props.listLength), 3)) : createCommentVNode("", true),
-        !unref(hideSearch) ? (openBlock(), createBlock(ckInput, {
+          class: normalizeClass(["items-per-page", { "ck-component__group--left": !unref$1(hideSearch) }])
+        }, toDisplayString(unref$1(itemsPerPageStart)) + " - " + toDisplayString(unref$1(itemsPerPageEnd)) + " de " + toDisplayString(__props.listLength), 3)) : createCommentVNode("", true),
+        !unref$1(hideSearch) ? (openBlock(), createBlock(ckInput, {
           key: 2,
-          modelValue: unref(searchLocal),
-          "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef(searchLocal) ? searchLocal.value = $event : null),
+          modelValue: unref$1(searchLocal),
+          "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef$1(searchLocal) ? searchLocal.value = $event : null),
           icon: "search",
           placeholder: "Buscar...",
-          group: unref(searchGroupValue),
+          group: unref$1(searchGroupValue),
           onInput: _cache[2] || (_cache[2] = ($event) => checkRefresh())
         }, null, 8, ["modelValue", "group"])) : createCommentVNode("", true),
         __props.hasColumnsManager ? (openBlock(), createBlock(ckButton, {
@@ -12649,7 +13416,7 @@ const _sfc_main$6 = /* @__PURE__ */ defineComponent({
           icon: "columns",
           type: "filled",
           title: "Administrador de columnas",
-          group: unref(itemsPerPageIsVisible) || !unref(hideSearch) ? "right" : "",
+          group: unref$1(itemsPerPageIsVisible) || !unref$1(hideSearch) ? "right" : "",
           onClick: _cache[3] || (_cache[3] = ($event) => _ctx.$emit("openColumnsManager"))
         }, null, 8, ["group"])) : createCommentVNode("", true)
       ]);
@@ -12763,7 +13530,7 @@ const _sfc_main$5 = /* @__PURE__ */ defineComponent(__spreadProps(__spreadValues
             width: "50px",
             align: "center",
             modelValue: _ctx.currentPageLocal2,
-            "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef(currentPageLocal2) ? currentPageLocal2.value = $event : null),
+            "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => isRef$1(currentPageLocal2) ? currentPageLocal2.value = $event : null),
             onChange: _cache[2] || (_cache[2] = ($event) => _ctx.validateInputNumber($event.target.value))
           }, null, 8, ["modelValue"]),
           (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.listRight, (num) => {
@@ -12798,7 +13565,7 @@ const _sfc_main$4 = /* @__PURE__ */ defineComponent({
   setup(__props, { emit: emits }) {
     const props = __props;
     let columnsCheckable = ref([]);
-    const isActive = computed({
+    const isActive = computed$2({
       get() {
         return props.modelValue;
       },
@@ -12815,12 +13582,13 @@ const _sfc_main$4 = /* @__PURE__ */ defineComponent({
       console.log("hoola");
       const list = [];
       props.columnsArray.forEach((col) => {
-        if (functions$1)
+        if (!col.unchangeable) {
           list.push({
             name: col.name,
             title: col.title,
             value: functions$1.isColumnDisplayed(col)
           });
+        }
       });
       columnsCheckable.value = list;
     }
@@ -12829,13 +13597,13 @@ const _sfc_main$4 = /* @__PURE__ */ defineComponent({
     }
     return (_ctx, _cache) => {
       return openBlock(), createBlock(_sfc_main$e, {
-        modelValue: unref(isActive),
-        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(isActive) ? isActive.value = $event : null),
+        modelValue: unref$1(isActive),
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef$1(isActive) ? isActive.value = $event : null),
         title: "Administrador de columnas"
       }, {
         default: withCtx(() => [
           createElementVNode("div", _hoisted_1$3, [
-            (openBlock(true), createElementBlock(Fragment, null, renderList(unref(columnsCheckable), (col) => {
+            (openBlock(true), createElementBlock(Fragment, null, renderList(unref$1(columnsCheckable), (col) => {
               return openBlock(), createElementBlock("div", _hoisted_2$1, [
                 createVNode(ckCheckbox, {
                   modelValue: col.value,
@@ -12856,7 +13624,7 @@ const _sfc_main$4 = /* @__PURE__ */ defineComponent({
     };
   }
 });
-var TableColumnsManager = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-6ae82d89"]]);
+var TableColumnsManager = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-e6aed8c8"]]);
 var ckTable_vue_vue_type_style_index_0_scoped_true_lang = "";
 const _hoisted_1$2 = { class: "ck-table" };
 const _hoisted_2 = {
@@ -12890,8 +13658,8 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
     const IsPopupActive = ref({
       columnsManager: false
     });
-    const columnsAreObj = computed(() => !qmObj2.isArray(props.columns));
-    const columnsArray = computed(() => {
+    const columnsAreObj = computed$2(() => !qmObj2.isArray(props.columns));
+    const columnsArray = computed$2(() => {
       if (!columnsAreObj.value)
         return props.columns;
       const arr = Object.values(props.columns);
@@ -12902,10 +13670,10 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
       });
       return arr;
     });
-    const filteredColumnsList = computed(() => {
+    const filteredColumnsList = computed$2(() => {
       return columnsArray.value.filter(functions$1.isColumnDisplayed);
     });
-    const searchLocal = computed({
+    const searchLocal = computed$2({
       get() {
         return props.search;
       },
@@ -12913,7 +13681,7 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
         emits("update:search", val);
       }
     });
-    const currentPageLocal = computed({
+    const currentPageLocal = computed$2({
       get() {
         return props.currentPage;
       },
@@ -12933,19 +13701,19 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
     }
     return (_ctx, _cache) => {
       return openBlock(), createElementBlock(Fragment, null, [
-        __props.hasColumnsManager && unref(columnsAreObj) ? (openBlock(), createBlock(TableColumnsManager, {
+        __props.hasColumnsManager && unref$1(columnsAreObj) ? (openBlock(), createBlock(TableColumnsManager, {
           key: 0,
           modelValue: IsPopupActive.value.columnsManager,
           "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => IsPopupActive.value.columnsManager = $event),
-          columnsArray: unref(columnsArray),
+          columnsArray: unref$1(columnsArray),
           columns: __props.columns
         }, null, 8, ["modelValue", "columnsArray", "columns"])) : createCommentVNode("", true),
         createElementVNode("div", _hoisted_1$2, [
           _ctx.$slots.header || !__props.hideHeaderActions ? (openBlock(), createElementBlock("div", _hoisted_2, [
             !__props.hideHeaderActions ? (openBlock(), createBlock(TableHeaderItems, {
               key: 0,
-              search: unref(searchLocal),
-              "onUpdate:search": _cache[1] || (_cache[1] = ($event) => isRef(searchLocal) ? searchLocal.value = $event : null),
+              search: unref$1(searchLocal),
+              "onUpdate:search": _cache[1] || (_cache[1] = ($event) => isRef$1(searchLocal) ? searchLocal.value = $event : null),
               currentPage: __props.currentPage,
               hasColumnsManager: __props.hasColumnsManager,
               itemsPerPage: __props.itemsPerPage,
@@ -12960,10 +13728,10 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
             ])) : createCommentVNode("", true)
           ])) : createCommentVNode("", true),
           createElementVNode("table", _hoisted_4, [
-            unref(filteredColumnsList).length ? (openBlock(), createElementBlock("thead", _hoisted_5, [
+            unref$1(filteredColumnsList).length ? (openBlock(), createElementBlock("thead", _hoisted_5, [
               createVNode(ckTr, null, {
                 default: withCtx(() => [
-                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref(filteredColumnsList), (col) => {
+                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref$1(filteredColumnsList), (col) => {
                     return openBlock(), createBlock(_sfc_main$7, {
                       key: col.title,
                       col
@@ -12981,8 +13749,8 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
             ])) : createCommentVNode("", true)
           ]),
           createVNode(TablePagination, {
-            currentPage: unref(currentPageLocal),
-            "onUpdate:currentPage": _cache[4] || (_cache[4] = ($event) => isRef(currentPageLocal) ? currentPageLocal.value = $event : null),
+            currentPage: unref$1(currentPageLocal),
+            "onUpdate:currentPage": _cache[4] || (_cache[4] = ($event) => isRef$1(currentPageLocal) ? currentPageLocal.value = $event : null),
             itemsPerPage: __props.itemsPerPage,
             listLength: __props.listLength,
             align: __props.paginationAlign,
@@ -13009,12 +13777,12 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
   },
   setup(__props) {
     const props = __props;
-    const computedTdClass = computed(() => {
+    const computedTdClass = computed$2(() => {
       return {
         "auto-width": props.autoWidth
       };
     });
-    const computedSpanClass = computed(() => {
+    const computedSpanClass = computed$2(() => {
       const list = [];
       let align;
       if (props.col)
@@ -13033,7 +13801,7 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
         list.push("wrap-text");
       return list;
     });
-    const computedStyle = computed(() => {
+    const computedStyle = computed$2(() => {
       const list = {};
       if (props.minWidth)
         list["min-width"] = props.minWidth;
@@ -13047,19 +13815,19 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
         list["max-height"] = props.maxHeight;
       return list;
     });
-    const isColumnDisplayed = computed(() => {
+    const isColumnDisplayed = computed$2(() => {
       if (!props.col)
         return true;
       return functions$1.isColumnDisplayed(props.col);
     });
     return (_ctx, _cache) => {
-      return unref(isColumnDisplayed) ? (openBlock(), createElementBlock("td", {
+      return unref$1(isColumnDisplayed) ? (openBlock(), createElementBlock("td", {
         key: 0,
-        class: normalizeClass(["ck-td", unref(computedTdClass)])
+        class: normalizeClass(["ck-td", unref$1(computedTdClass)])
       }, [
         createElementVNode("span", {
-          class: normalizeClass(unref(computedSpanClass)),
-          style: normalizeStyle(unref(computedStyle))
+          class: normalizeClass(unref$1(computedSpanClass)),
+          style: normalizeStyle(unref$1(computedStyle))
         }, [
           renderSlot(_ctx.$slots, "default", {}, void 0, true)
         ], 6)
@@ -13068,47 +13836,46 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
   }
 });
 var ckTd = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-c34b91ca"]]);
-const _hoisted_1$1 = { class: "ck-textarea" };
-function render$2(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_ck_label = resolveComponent("ck-label");
-  return openBlock(), createElementBlock("div", _hoisted_1$1, [
-    $props.label ? (openBlock(), createBlock(_component_ck_label, {
-      key: 0,
-      "label-align": $props.labelAlign
-    }, {
-      default: withCtx(() => [
-        createTextVNode(toDisplayString($props.label), 1)
-      ]),
-      _: 1
-    }, 8, ["label-align"])) : createCommentVNode("", true),
-    withDirectives(createElementVNode("textarea", {
-      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => $options.value = $event)
-    }, null, 512), [
-      [vModelText, $options.value]
-    ])
-  ]);
-}
 var ckTextarea_vue_vue_type_style_index_0_scoped_true_lang = "";
-const _sfc_main$1 = {
-  name: "CkTextarea",
+const _hoisted_1$1 = { class: "ck-textarea" };
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
   props: {
     modelValue: {},
     label: { type: String, default: "" },
     labelAlign: { type: String, default: "" }
   },
   emits: ["update:modelValue"],
-  computed: {
-    value: {
+  setup(__props, { emit: emits }) {
+    const props = __props;
+    const value = computed$2({
       get() {
-        return this.modelValue;
+        return props.modelValue;
       },
       set(val) {
-        this.$emit("update:modelValue", val);
+        emits("update:modelValue", val);
       }
-    }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1$1, [
+        __props.label ? (openBlock(), createBlock(ckLabel, {
+          key: 0,
+          "label-align": __props.labelAlign
+        }, {
+          default: withCtx(() => [
+            createTextVNode(toDisplayString(__props.label), 1)
+          ]),
+          _: 1
+        }, 8, ["label-align"])) : createCommentVNode("", true),
+        withDirectives(createElementVNode("textarea", {
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef$1(value) ? value.value = $event : null)
+        }, null, 512), [
+          [vModelText, unref$1(value)]
+        ])
+      ]);
+    };
   }
-};
-var ckTextarea = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", render$2], ["__scopeId", "data-v-ec889100"]]);
+});
+var ckTextarea = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-509e26c4"]]);
 var top = "top";
 var bottom = "bottom";
 var right = "right";
@@ -14766,7 +15533,7 @@ function getChildren(popper2) {
     })
   };
 }
-function render$1(instance) {
+function render(instance) {
   var popper2 = div();
   var box = div();
   box.className = BOX_CLASS;
@@ -14821,7 +15588,7 @@ function render$1(instance) {
     onUpdate
   };
 }
-render$1.$$tippy = true;
+render.$$tippy = true;
 var idCounter = 1;
 var mouseMoveListeners = [];
 var mountedInstances = [];
@@ -15561,31 +16328,33 @@ Object.assign({}, applyStyles$1, {
   }
 });
 tippy$1.setDefaultProps({
-  render: render$1
+  render
 });
 var tippy = "";
+var ckTooltip_vue_vue_type_style_index_0_scoped_true_lang = "";
 const _hoisted_1 = {
   class: "ck-tooltip",
   tabindex: "0"
 };
-function render(_ctx, _cache, $props, $setup, $data, $options) {
-  return openBlock(), createElementBlock("div", _hoisted_1, [
-    renderSlot(_ctx.$slots, "default", {}, void 0, true)
-  ]);
-}
-var ckTooltip_vue_vue_type_style_index_0_scoped_true_lang = "";
-const _sfc_main = {
-  name: "CkTooltip",
+const _sfc_main = /* @__PURE__ */ defineComponent({
   props: {
-    content: { type: String, required: true }
+    text: { type: String, required: true }
   },
-  mounted() {
-    tippy$1(this.$el, {
-      content: this.content
+  setup(__props) {
+    onMounted(() => {
+      const context = getCurrentInstance().ctx;
+      tippy$1(context.$el, {
+        content: context.text
+      });
     });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ]);
+    };
   }
-};
-var ckTooltip = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", render], ["__scopeId", "data-v-52ad7158"]]);
+});
+var ckTooltip = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-00df84d4"]]);
 var events = {
   OPEN_MODAL: "OPEN_MODAL",
   CLOSE_MODAL: "CLOSE_MODAL",