cleek 2.4.52 → 2.4.53

package/dist/cleek.es.js

@@ -29,7 +29,897 @@ var __objRest = (source2, exclude) => {
     }
   return target;
 };
-import { pushScopeId, popScopeId, defineComponent, nextTick as nextTick$1, openBlock, createBlock, withScopeId, resolveComponent, createElementBlock, normalizeClass, normalizeStyle, withKeys, createElementVNode, Fragment, renderSlot, createCommentVNode, mergeProps, withCtx, createVNode, ref, createApp, h, toDisplayString, computed as computed$2, onMounted, getCurrentInstance, unref as unref$1, createTextVNode, watch, onBeforeUnmount, withDirectives, isRef as isRef$1, vModelDynamic, renderList, vModelText, withModifiers, vModelRadio, vModelSelect, vModelCheckbox, Teleport } from "vue";
+import { watch, reactive, pushScopeId, popScopeId, defineComponent, nextTick as nextTick$1, openBlock, createBlock, withScopeId, resolveComponent, createElementBlock, normalizeClass, normalizeStyle, withKeys, createElementVNode, Fragment, renderSlot, createCommentVNode, mergeProps, withCtx, createVNode, ref, createApp, h, toDisplayString, computed as computed$2, onMounted, getCurrentInstance, unref as unref$1, createTextVNode, onBeforeUnmount, withDirectives, isRef as isRef$1, vModelDynamic, renderList, vModelText, withModifiers, vModelRadio, vModelSelect, vModelCheckbox, Teleport } from "vue";
+function getDevtoolsGlobalHook() {
+  return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;
+}
+function getTarget() {
+  return typeof navigator !== "undefined" && typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
+}
+const isProxyAvailable = typeof Proxy === "function";
+const HOOK_SETUP = "devtools-plugin:setup";
+const HOOK_PLUGIN_SETTINGS_SET = "plugin:settings:set";
+class ApiProxy {
+  constructor(plugin2, hook) {
+    this.target = null;
+    this.targetQueue = [];
+    this.onQueue = [];
+    this.plugin = plugin2;
+    this.hook = hook;
+    const defaultSettings = {};
+    if (plugin2.settings) {
+      for (const id in plugin2.settings) {
+        const item = plugin2.settings[id];
+        defaultSettings[id] = item.defaultValue;
+      }
+    }
+    const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin2.id}`;
+    let currentSettings = Object.assign({}, defaultSettings);
+    try {
+      const raw = localStorage.getItem(localSettingsSaveId);
+      const data2 = JSON.parse(raw);
+      Object.assign(currentSettings, data2);
+    } catch (e) {
+    }
+    this.fallbacks = {
+      getSettings() {
+        return currentSettings;
+      },
+      setSettings(value) {
+        try {
+          localStorage.setItem(localSettingsSaveId, JSON.stringify(value));
+        } catch (e) {
+        }
+        currentSettings = value;
+      }
+    };
+    if (hook) {
+      hook.on(HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {
+        if (pluginId === this.plugin.id) {
+          this.fallbacks.setSettings(value);
+        }
+      });
+    }
+    this.proxiedOn = new Proxy({}, {
+      get: (_target, prop) => {
+        if (this.target) {
+          return this.target.on[prop];
+        } else {
+          return (...args) => {
+            this.onQueue.push({
+              method: prop,
+              args
+            });
+          };
+        }
+      }
+    });
+    this.proxiedTarget = new Proxy({}, {
+      get: (_target, prop) => {
+        if (this.target) {
+          return this.target[prop];
+        } else if (prop === "on") {
+          return this.proxiedOn;
+        } else if (Object.keys(this.fallbacks).includes(prop)) {
+          return (...args) => {
+            this.targetQueue.push({
+              method: prop,
+              args,
+              resolve: () => {
+              }
+            });
+            return this.fallbacks[prop](...args);
+          };
+        } else {
+          return (...args) => {
+            return new Promise((resolve) => {
+              this.targetQueue.push({
+                method: prop,
+                args,
+                resolve
+              });
+            });
+          };
+        }
+      }
+    });
+  }
+  async setRealTarget(target) {
+    this.target = target;
+    for (const item of this.onQueue) {
+      this.target.on[item.method](...item.args);
+    }
+    for (const item of this.targetQueue) {
+      item.resolve(await this.target[item.method](...item.args));
+    }
+  }
+}
+function setupDevtoolsPlugin(pluginDescriptor, setupFn) {
+  const descriptor = pluginDescriptor;
+  const target = getTarget();
+  const hook = getDevtoolsGlobalHook();
+  const enableProxy = isProxyAvailable && descriptor.enableEarlyProxy;
+  if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {
+    hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);
+  } else {
+    const proxy = enableProxy ? new ApiProxy(descriptor, hook) : null;
+    const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];
+    list.push({
+      pluginDescriptor: descriptor,
+      setupFn,
+      proxy
+    });
+    if (proxy)
+      setupFn(proxy.proxiedTarget);
+  }
+}
+/*!
+ * vuex v4.0.2
+ * (c) 2021 Evan You
+ * @license MIT
+ */
+var storeKey = "store";
+function forEachValue(obj, fn) {
+  Object.keys(obj).forEach(function(key) {
+    return fn(obj[key], key);
+  });
+}
+function isObject$2(obj) {
+  return obj !== null && typeof obj === "object";
+}
+function isPromise$1(val) {
+  return val && typeof val.then === "function";
+}
+function partial(fn, arg) {
+  return function() {
+    return fn(arg);
+  };
+}
+function genericSubscribe(fn, subs, options) {
+  if (subs.indexOf(fn) < 0) {
+    options && options.prepend ? subs.unshift(fn) : subs.push(fn);
+  }
+  return function() {
+    var i = subs.indexOf(fn);
+    if (i > -1) {
+      subs.splice(i, 1);
+    }
+  };
+}
+function resetStore(store, hot) {
+  store._actions = Object.create(null);
+  store._mutations = Object.create(null);
+  store._wrappedGetters = Object.create(null);
+  store._modulesNamespaceMap = Object.create(null);
+  var state = store.state;
+  installModule(store, state, [], store._modules.root, true);
+  resetStoreState(store, state, hot);
+}
+function resetStoreState(store, state, hot) {
+  var oldState = store._state;
+  store.getters = {};
+  store._makeLocalGettersCache = Object.create(null);
+  var wrappedGetters = store._wrappedGetters;
+  var computedObj = {};
+  forEachValue(wrappedGetters, function(fn, key) {
+    computedObj[key] = partial(fn, store);
+    Object.defineProperty(store.getters, key, {
+      get: function() {
+        return computedObj[key]();
+      },
+      enumerable: true
+    });
+  });
+  store._state = reactive({
+    data: state
+  });
+  if (store.strict) {
+    enableStrictMode(store);
+  }
+  if (oldState) {
+    if (hot) {
+      store._withCommit(function() {
+        oldState.data = null;
+      });
+    }
+  }
+}
+function installModule(store, rootState, path, module, hot) {
+  var isRoot = !path.length;
+  var namespace2 = store._modules.getNamespace(path);
+  if (module.namespaced) {
+    if (store._modulesNamespaceMap[namespace2] && false) {
+      console.error("[vuex] duplicate namespace " + namespace2 + " for the namespaced module " + path.join("/"));
+    }
+    store._modulesNamespaceMap[namespace2] = module;
+  }
+  if (!isRoot && !hot) {
+    var parentState = getNestedState(rootState, path.slice(0, -1));
+    var moduleName = path[path.length - 1];
+    store._withCommit(function() {
+      parentState[moduleName] = module.state;
+    });
+  }
+  var local = module.context = makeLocalContext(store, namespace2, path);
+  module.forEachMutation(function(mutation, key) {
+    var namespacedType = namespace2 + key;
+    registerMutation(store, namespacedType, mutation, local);
+  });
+  module.forEachAction(function(action, key) {
+    var type = action.root ? key : namespace2 + key;
+    var handler = action.handler || action;
+    registerAction(store, type, handler, local);
+  });
+  module.forEachGetter(function(getter, key) {
+    var namespacedType = namespace2 + key;
+    registerGetter(store, namespacedType, getter, local);
+  });
+  module.forEachChild(function(child, key) {
+    installModule(store, rootState, path.concat(key), child, hot);
+  });
+}
+function makeLocalContext(store, namespace2, path) {
+  var noNamespace = namespace2 === "";
+  var local = {
+    dispatch: noNamespace ? store.dispatch : function(_type, _payload, _options) {
+      var args = unifyObjectStyle(_type, _payload, _options);
+      var payload = args.payload;
+      var options = args.options;
+      var type = args.type;
+      if (!options || !options.root) {
+        type = namespace2 + type;
+      }
+      return store.dispatch(type, payload);
+    },
+    commit: noNamespace ? store.commit : function(_type, _payload, _options) {
+      var args = unifyObjectStyle(_type, _payload, _options);
+      var payload = args.payload;
+      var options = args.options;
+      var type = args.type;
+      if (!options || !options.root) {
+        type = namespace2 + type;
+      }
+      store.commit(type, payload, options);
+    }
+  };
+  Object.defineProperties(local, {
+    getters: {
+      get: noNamespace ? function() {
+        return store.getters;
+      } : function() {
+        return makeLocalGetters(store, namespace2);
+      }
+    },
+    state: {
+      get: function() {
+        return getNestedState(store.state, path);
+      }
+    }
+  });
+  return local;
+}
+function makeLocalGetters(store, namespace2) {
+  if (!store._makeLocalGettersCache[namespace2]) {
+    var gettersProxy = {};
+    var splitPos = namespace2.length;
+    Object.keys(store.getters).forEach(function(type) {
+      if (type.slice(0, splitPos) !== namespace2) {
+        return;
+      }
+      var localType = type.slice(splitPos);
+      Object.defineProperty(gettersProxy, localType, {
+        get: function() {
+          return store.getters[type];
+        },
+        enumerable: true
+      });
+    });
+    store._makeLocalGettersCache[namespace2] = gettersProxy;
+  }
+  return store._makeLocalGettersCache[namespace2];
+}
+function registerMutation(store, type, handler, local) {
+  var entry = store._mutations[type] || (store._mutations[type] = []);
+  entry.push(function wrappedMutationHandler(payload) {
+    handler.call(store, local.state, payload);
+  });
+}
+function registerAction(store, type, handler, local) {
+  var entry = store._actions[type] || (store._actions[type] = []);
+  entry.push(function wrappedActionHandler(payload) {
+    var res = handler.call(store, {
+      dispatch: local.dispatch,
+      commit: local.commit,
+      getters: local.getters,
+      state: local.state,
+      rootGetters: store.getters,
+      rootState: store.state
+    }, payload);
+    if (!isPromise$1(res)) {
+      res = Promise.resolve(res);
+    }
+    if (store._devtoolHook) {
+      return res.catch(function(err) {
+        store._devtoolHook.emit("vuex:error", err);
+        throw err;
+      });
+    } else {
+      return res;
+    }
+  });
+}
+function registerGetter(store, type, rawGetter, local) {
+  if (store._wrappedGetters[type]) {
+    return;
+  }
+  store._wrappedGetters[type] = function wrappedGetter(store2) {
+    return rawGetter(local.state, local.getters, store2.state, store2.getters);
+  };
+}
+function enableStrictMode(store) {
+  watch(function() {
+    return store._state.data;
+  }, function() {
+  }, { deep: true, flush: "sync" });
+}
+function getNestedState(state, path) {
+  return path.reduce(function(state2, key) {
+    return state2[key];
+  }, state);
+}
+function unifyObjectStyle(type, payload, options) {
+  if (isObject$2(type) && type.type) {
+    options = payload;
+    payload = type;
+    type = type.type;
+  }
+  return { type, payload, options };
+}
+var LABEL_VUEX_BINDINGS = "vuex bindings";
+var MUTATIONS_LAYER_ID = "vuex:mutations";
+var ACTIONS_LAYER_ID = "vuex:actions";
+var INSPECTOR_ID = "vuex";
+var actionId = 0;
+function addDevtools(app, store) {
+  setupDevtoolsPlugin({
+    id: "org.vuejs.vuex",
+    app,
+    label: "Vuex",
+    homepage: "https://next.vuex.vuejs.org/",
+    logo: "https://vuejs.org/images/icons/favicon-96x96.png",
+    packageName: "vuex",
+    componentStateTypes: [LABEL_VUEX_BINDINGS]
+  }, function(api2) {
+    api2.addTimelineLayer({
+      id: MUTATIONS_LAYER_ID,
+      label: "Vuex Mutations",
+      color: COLOR_LIME_500
+    });
+    api2.addTimelineLayer({
+      id: ACTIONS_LAYER_ID,
+      label: "Vuex Actions",
+      color: COLOR_LIME_500
+    });
+    api2.addInspector({
+      id: INSPECTOR_ID,
+      label: "Vuex",
+      icon: "storage",
+      treeFilterPlaceholder: "Filter stores..."
+    });
+    api2.on.getInspectorTree(function(payload) {
+      if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
+        if (payload.filter) {
+          var nodes = [];
+          flattenStoreForInspectorTree(nodes, store._modules.root, payload.filter, "");
+          payload.rootNodes = nodes;
+        } else {
+          payload.rootNodes = [
+            formatStoreForInspectorTree(store._modules.root, "")
+          ];
+        }
+      }
+    });
+    api2.on.getInspectorState(function(payload) {
+      if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
+        var modulePath = payload.nodeId;
+        makeLocalGetters(store, modulePath);
+        payload.state = formatStoreForInspectorState(getStoreModule(store._modules, modulePath), modulePath === "root" ? store.getters : store._makeLocalGettersCache, modulePath);
+      }
+    });
+    api2.on.editInspectorState(function(payload) {
+      if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
+        var modulePath = payload.nodeId;
+        var path = payload.path;
+        if (modulePath !== "root") {
+          path = modulePath.split("/").filter(Boolean).concat(path);
+        }
+        store._withCommit(function() {
+          payload.set(store._state.data, path, payload.state.value);
+        });
+      }
+    });
+    store.subscribe(function(mutation, state) {
+      var data2 = {};
+      if (mutation.payload) {
+        data2.payload = mutation.payload;
+      }
+      data2.state = state;
+      api2.notifyComponentUpdate();
+      api2.sendInspectorTree(INSPECTOR_ID);
+      api2.sendInspectorState(INSPECTOR_ID);
+      api2.addTimelineEvent({
+        layerId: MUTATIONS_LAYER_ID,
+        event: {
+          time: Date.now(),
+          title: mutation.type,
+          data: data2
+        }
+      });
+    });
+    store.subscribeAction({
+      before: function(action, state) {
+        var data2 = {};
+        if (action.payload) {
+          data2.payload = action.payload;
+        }
+        action._id = actionId++;
+        action._time = Date.now();
+        data2.state = state;
+        api2.addTimelineEvent({
+          layerId: ACTIONS_LAYER_ID,
+          event: {
+            time: action._time,
+            title: action.type,
+            groupId: action._id,
+            subtitle: "start",
+            data: data2
+          }
+        });
+      },
+      after: function(action, state) {
+        var data2 = {};
+        var duration = Date.now() - action._time;
+        data2.duration = {
+          _custom: {
+            type: "duration",
+            display: duration + "ms",
+            tooltip: "Action duration",
+            value: duration
+          }
+        };
+        if (action.payload) {
+          data2.payload = action.payload;
+        }
+        data2.state = state;
+        api2.addTimelineEvent({
+          layerId: ACTIONS_LAYER_ID,
+          event: {
+            time: Date.now(),
+            title: action.type,
+            groupId: action._id,
+            subtitle: "end",
+            data: data2
+          }
+        });
+      }
+    });
+  });
+}
+var COLOR_LIME_500 = 8702998;
+var COLOR_DARK = 6710886;
+var COLOR_WHITE = 16777215;
+var TAG_NAMESPACED = {
+  label: "namespaced",
+  textColor: COLOR_WHITE,
+  backgroundColor: COLOR_DARK
+};
+function extractNameFromPath(path) {
+  return path && path !== "root" ? path.split("/").slice(-2, -1)[0] : "Root";
+}
+function formatStoreForInspectorTree(module, path) {
+  return {
+    id: path || "root",
+    label: extractNameFromPath(path),
+    tags: module.namespaced ? [TAG_NAMESPACED] : [],
+    children: Object.keys(module._children).map(function(moduleName) {
+      return formatStoreForInspectorTree(module._children[moduleName], path + moduleName + "/");
+    })
+  };
+}
+function flattenStoreForInspectorTree(result, module, filter, path) {
+  if (path.includes(filter)) {
+    result.push({
+      id: path || "root",
+      label: path.endsWith("/") ? path.slice(0, path.length - 1) : path || "Root",
+      tags: module.namespaced ? [TAG_NAMESPACED] : []
+    });
+  }
+  Object.keys(module._children).forEach(function(moduleName) {
+    flattenStoreForInspectorTree(result, module._children[moduleName], filter, path + moduleName + "/");
+  });
+}
+function formatStoreForInspectorState(module, getters, path) {
+  getters = path === "root" ? getters : getters[path];
+  var gettersKeys = Object.keys(getters);
+  var storeState = {
+    state: Object.keys(module.state).map(function(key) {
+      return {
+        key,
+        editable: true,
+        value: module.state[key]
+      };
+    })
+  };
+  if (gettersKeys.length) {
+    var tree = transformPathsToObjectTree(getters);
+    storeState.getters = Object.keys(tree).map(function(key) {
+      return {
+        key: key.endsWith("/") ? extractNameFromPath(key) : key,
+        editable: false,
+        value: canThrow(function() {
+          return tree[key];
+        })
+      };
+    });
+  }
+  return storeState;
+}
+function transformPathsToObjectTree(getters) {
+  var result = {};
+  Object.keys(getters).forEach(function(key) {
+    var path = key.split("/");
+    if (path.length > 1) {
+      var target = result;
+      var leafKey = path.pop();
+      path.forEach(function(p2) {
+        if (!target[p2]) {
+          target[p2] = {
+            _custom: {
+              value: {},
+              display: p2,
+              tooltip: "Module",
+              abstract: true
+            }
+          };
+        }
+        target = target[p2]._custom.value;
+      });
+      target[leafKey] = canThrow(function() {
+        return getters[key];
+      });
+    } else {
+      result[key] = canThrow(function() {
+        return getters[key];
+      });
+    }
+  });
+  return result;
+}
+function getStoreModule(moduleMap, path) {
+  var names = path.split("/").filter(function(n) {
+    return n;
+  });
+  return names.reduce(function(module, moduleName, i) {
+    var child = module[moduleName];
+    if (!child) {
+      throw new Error('Missing module "' + moduleName + '" for path "' + path + '".');
+    }
+    return i === names.length - 1 ? child : child._children;
+  }, path === "root" ? moduleMap : moduleMap.root._children);
+}
+function canThrow(cb) {
+  try {
+    return cb();
+  } catch (e) {
+    return e;
+  }
+}
+var Module = function Module2(rawModule, runtime) {
+  this.runtime = runtime;
+  this._children = Object.create(null);
+  this._rawModule = rawModule;
+  var rawState = rawModule.state;
+  this.state = (typeof rawState === "function" ? rawState() : rawState) || {};
+};
+var prototypeAccessors$1 = { namespaced: { configurable: true } };
+prototypeAccessors$1.namespaced.get = function() {
+  return !!this._rawModule.namespaced;
+};
+Module.prototype.addChild = function addChild(key, module) {
+  this._children[key] = module;
+};
+Module.prototype.removeChild = function removeChild(key) {
+  delete this._children[key];
+};
+Module.prototype.getChild = function getChild(key) {
+  return this._children[key];
+};
+Module.prototype.hasChild = function hasChild(key) {
+  return key in this._children;
+};
+Module.prototype.update = function update(rawModule) {
+  this._rawModule.namespaced = rawModule.namespaced;
+  if (rawModule.actions) {
+    this._rawModule.actions = rawModule.actions;
+  }
+  if (rawModule.mutations) {
+    this._rawModule.mutations = rawModule.mutations;
+  }
+  if (rawModule.getters) {
+    this._rawModule.getters = rawModule.getters;
+  }
+};
+Module.prototype.forEachChild = function forEachChild(fn) {
+  forEachValue(this._children, fn);
+};
+Module.prototype.forEachGetter = function forEachGetter(fn) {
+  if (this._rawModule.getters) {
+    forEachValue(this._rawModule.getters, fn);
+  }
+};
+Module.prototype.forEachAction = function forEachAction(fn) {
+  if (this._rawModule.actions) {
+    forEachValue(this._rawModule.actions, fn);
+  }
+};
+Module.prototype.forEachMutation = function forEachMutation(fn) {
+  if (this._rawModule.mutations) {
+    forEachValue(this._rawModule.mutations, fn);
+  }
+};
+Object.defineProperties(Module.prototype, prototypeAccessors$1);
+var ModuleCollection = function ModuleCollection2(rawRootModule) {
+  this.register([], rawRootModule, false);
+};
+ModuleCollection.prototype.get = function get(path) {
+  return path.reduce(function(module, key) {
+    return module.getChild(key);
+  }, this.root);
+};
+ModuleCollection.prototype.getNamespace = function getNamespace(path) {
+  var module = this.root;
+  return path.reduce(function(namespace2, key) {
+    module = module.getChild(key);
+    return namespace2 + (module.namespaced ? key + "/" : "");
+  }, "");
+};
+ModuleCollection.prototype.update = function update$1(rawRootModule) {
+  update2([], this.root, rawRootModule);
+};
+ModuleCollection.prototype.register = function register(path, rawModule, runtime) {
+  var this$1$1 = this;
+  if (runtime === void 0)
+    runtime = true;
+  var newModule = new Module(rawModule, runtime);
+  if (path.length === 0) {
+    this.root = newModule;
+  } else {
+    var parent = this.get(path.slice(0, -1));
+    parent.addChild(path[path.length - 1], newModule);
+  }
+  if (rawModule.modules) {
+    forEachValue(rawModule.modules, function(rawChildModule, key) {
+      this$1$1.register(path.concat(key), rawChildModule, runtime);
+    });
+  }
+};
+ModuleCollection.prototype.unregister = function unregister(path) {
+  var parent = this.get(path.slice(0, -1));
+  var key = path[path.length - 1];
+  var child = parent.getChild(key);
+  if (!child) {
+    return;
+  }
+  if (!child.runtime) {
+    return;
+  }
+  parent.removeChild(key);
+};
+ModuleCollection.prototype.isRegistered = function isRegistered(path) {
+  var parent = this.get(path.slice(0, -1));
+  var key = path[path.length - 1];
+  if (parent) {
+    return parent.hasChild(key);
+  }
+  return false;
+};
+function update2(path, targetModule, newModule) {
+  targetModule.update(newModule);
+  if (newModule.modules) {
+    for (var key in newModule.modules) {
+      if (!targetModule.getChild(key)) {
+        return;
+      }
+      update2(path.concat(key), targetModule.getChild(key), newModule.modules[key]);
+    }
+  }
+}
+function createStore(options) {
+  return new Store(options);
+}
+var Store = function Store2(options) {
+  var this$1$1 = this;
+  if (options === void 0)
+    options = {};
+  var plugins2 = options.plugins;
+  if (plugins2 === void 0)
+    plugins2 = [];
+  var strict = options.strict;
+  if (strict === void 0)
+    strict = false;
+  var devtools = options.devtools;
+  this._committing = false;
+  this._actions = Object.create(null);
+  this._actionSubscribers = [];
+  this._mutations = Object.create(null);
+  this._wrappedGetters = Object.create(null);
+  this._modules = new ModuleCollection(options);
+  this._modulesNamespaceMap = Object.create(null);
+  this._subscribers = [];
+  this._makeLocalGettersCache = Object.create(null);
+  this._devtools = devtools;
+  var store = this;
+  var ref2 = this;
+  var dispatch2 = ref2.dispatch;
+  var commit2 = ref2.commit;
+  this.dispatch = function boundDispatch(type, payload) {
+    return dispatch2.call(store, type, payload);
+  };
+  this.commit = function boundCommit(type, payload, options2) {
+    return commit2.call(store, type, payload, options2);
+  };
+  this.strict = strict;
+  var state = this._modules.root.state;
+  installModule(this, state, [], this._modules.root);
+  resetStoreState(this, state);
+  plugins2.forEach(function(plugin2) {
+    return plugin2(this$1$1);
+  });
+};
+var prototypeAccessors = { state: { configurable: true } };
+Store.prototype.install = function install(app, injectKey) {
+  app.provide(injectKey || storeKey, this);
+  app.config.globalProperties.$store = this;
+  var useDevtools = this._devtools !== void 0 ? this._devtools : false;
+  if (useDevtools) {
+    addDevtools(app, this);
+  }
+};
+prototypeAccessors.state.get = function() {
+  return this._state.data;
+};
+prototypeAccessors.state.set = function(v) {
+};
+Store.prototype.commit = function commit(_type, _payload, _options) {
+  var this$1$1 = this;
+  var ref2 = unifyObjectStyle(_type, _payload, _options);
+  var type = ref2.type;
+  var payload = ref2.payload;
+  var mutation = { type, payload };
+  var entry = this._mutations[type];
+  if (!entry) {
+    return;
+  }
+  this._withCommit(function() {
+    entry.forEach(function commitIterator(handler) {
+      handler(payload);
+    });
+  });
+  this._subscribers.slice().forEach(function(sub) {
+    return sub(mutation, this$1$1.state);
+  });
+};
+Store.prototype.dispatch = function dispatch(_type, _payload) {
+  var this$1$1 = this;
+  var ref2 = unifyObjectStyle(_type, _payload);
+  var type = ref2.type;
+  var payload = ref2.payload;
+  var action = { type, payload };
+  var entry = this._actions[type];
+  if (!entry) {
+    return;
+  }
+  try {
+    this._actionSubscribers.slice().filter(function(sub) {
+      return sub.before;
+    }).forEach(function(sub) {
+      return sub.before(action, this$1$1.state);
+    });
+  } catch (e) {
+  }
+  var result = entry.length > 1 ? Promise.all(entry.map(function(handler) {
+    return handler(payload);
+  })) : entry[0](payload);
+  return new Promise(function(resolve, reject) {
+    result.then(function(res) {
+      try {
+        this$1$1._actionSubscribers.filter(function(sub) {
+          return sub.after;
+        }).forEach(function(sub) {
+          return sub.after(action, this$1$1.state);
+        });
+      } catch (e) {
+      }
+      resolve(res);
+    }, function(error) {
+      try {
+        this$1$1._actionSubscribers.filter(function(sub) {
+          return sub.error;
+        }).forEach(function(sub) {
+          return sub.error(action, this$1$1.state, error);
+        });
+      } catch (e) {
+      }
+      reject(error);
+    });
+  });
+};
+Store.prototype.subscribe = function subscribe(fn, options) {
+  return genericSubscribe(fn, this._subscribers, options);
+};
+Store.prototype.subscribeAction = function subscribeAction(fn, options) {
+  var subs = typeof fn === "function" ? { before: fn } : fn;
+  return genericSubscribe(subs, this._actionSubscribers, options);
+};
+Store.prototype.watch = function watch$1(getter, cb, options) {
+  var this$1$1 = this;
+  return watch(function() {
+    return getter(this$1$1.state, this$1$1.getters);
+  }, cb, Object.assign({}, options));
+};
+Store.prototype.replaceState = function replaceState(state) {
+  var this$1$1 = this;
+  this._withCommit(function() {
+    this$1$1._state.data = state;
+  });
+};
+Store.prototype.registerModule = function registerModule(path, rawModule, options) {
+  if (options === void 0)
+    options = {};
+  if (typeof path === "string") {
+    path = [path];
+  }
+  this._modules.register(path, rawModule);
+  installModule(this, this.state, path, this._modules.get(path), options.preserveState);
+  resetStoreState(this, this.state);
+};
+Store.prototype.unregisterModule = function unregisterModule(path) {
+  var this$1$1 = this;
+  if (typeof path === "string") {
+    path = [path];
+  }
+  this._modules.unregister(path);
+  this._withCommit(function() {
+    var parentState = getNestedState(this$1$1.state, path.slice(0, -1));
+    delete parentState[path[path.length - 1]];
+  });
+  resetStore(this);
+};
+Store.prototype.hasModule = function hasModule(path) {
+  if (typeof path === "string") {
+    path = [path];
+  }
+  return this._modules.isRegistered(path);
+};
+Store.prototype.hotUpdate = function hotUpdate(newOptions) {
+  this._modules.update(newOptions);
+  resetStore(this, true);
+};
+Store.prototype._withCommit = function _withCommit(fn) {
+  var committing = this._committing;
+  this._committing = true;
+  fn();
+  this._committing = committing;
+};
+Object.defineProperties(Store.prototype, prototypeAccessors);
+createStore({
+  state() {
+    return {
+      count: 1,
+      imagesFolderPath: "holis"
+    };
+  }
+});
 function getBasePlacement(placement) {
   return placement.split("-")[0];
 }
@@ -3228,7 +4118,7 @@ Object.keys(_config).forEach(function(key) {
         return cb(config);
       });
     },
-    get: function get() {
+    get: function get2() {
       return _config[key];
     }
   });
@@ -3910,14 +4800,14 @@ function domVariants(val, abstractCreator) {
     get: abstractCreator
   });
   Object.defineProperty(val, "html", {
-    get: function get() {
+    get: function get2() {
       return val.abstract.map(function(a) {
         return toHtml(a);
       });
     }
   });
   Object.defineProperty(val, "node", {
-    get: function get() {
+    get: function get2() {
       if (!IS_DOM)
         return;
       var container = DOCUMENT.createElement("div");
@@ -20120,7 +21010,7 @@ CancelToken.prototype.throwIfRequested = function throwIfRequested() {
     throw this.reason;
   }
 };
-CancelToken.prototype.subscribe = function subscribe(listener3) {
+CancelToken.prototype.subscribe = function subscribe2(listener3) {
   if (this.reason) {
     listener3(this.reason);
     return;
@@ -21333,7 +22223,7 @@ const _sfc_main$h = /* @__PURE__ */ defineComponent({
 });
 var TableHeaderItems = /* @__PURE__ */ _export_sfc(_sfc_main$h, [["__scopeId", "data-v-4bfc21c8"]]);
 var ckTable__pagination_vue_vue_type_style_index_0_scoped_true_lang = "";
-const _withScopeId$4 = (n) => (pushScopeId("data-v-46510d24"), n = n(), popScopeId(), n);
+const _withScopeId$4 = (n) => (pushScopeId("data-v-13fd1fa4"), n = n(), popScopeId(), n);
 const _hoisted_1$f = { class: "ck-table__pagination" };
 const _hoisted_2$b = { class: "ck-table__pagination--numbers-container" };
 const _hoisted_3$7 = ["onClick"];
@@ -21425,6 +22315,12 @@ const _sfc_main$g = /* @__PURE__ */ defineComponent({
         currentPageLocal.value = newValue;
       }
     }
+    function onClickArrowRight() {
+      console.log("hasArrowRight", hasArrowRight.value);
+      if (!hasArrowRight.value)
+        return;
+      currentPageLocal.value = props.currentPage + 1;
+    }
     onMounted(() => {
       cleekOptions2.value = hooks8.getCleekOptions(getCurrentInstance);
     });
@@ -21470,7 +22366,7 @@ const _sfc_main$g = /* @__PURE__ */ defineComponent({
           ]),
           createElementVNode("div", {
             class: normalizeClass(["ck-table__pagination--arrow-right", { disabled: !unref$1(hasArrowRight) }]),
-            onClick: _cache[4] || (_cache[4] = ($event) => currentPageLocal.value = __props.currentPage + 1)
+            onClick: _cache[4] || (_cache[4] = ($event) => onClickArrowRight())
           }, [
             createVNode(CkIcon, {
               icon: unref$1(hasArrowRight) ? "angle-right" : "grip-lines-vertical"
@@ -21481,7 +22377,7 @@ const _sfc_main$g = /* @__PURE__ */ defineComponent({
     };
   }
 });
-var TablePagination = /* @__PURE__ */ _export_sfc(_sfc_main$g, [["__scopeId", "data-v-46510d24"]]);
+var TablePagination = /* @__PURE__ */ _export_sfc(_sfc_main$g, [["__scopeId", "data-v-13fd1fa4"]]);
 const EMPTY_OBJ = {};
 const NOOP = () => {
 };
@@ -22887,7 +23783,7 @@ const _sfc_main$b = /* @__PURE__ */ defineComponent({
     };
   }
 });
-var ckChip = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["__scopeId", "data-v-ad665c4a"]]);
+var ckChip = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["__scopeId", "data-v-c7cdf0ec"]]);
 var ckDiv_vue_vue_type_style_index_0_lang = "";
 const _sfc_main$a = /* @__PURE__ */ defineComponent({
   props: {
@@ -23158,6 +24054,7 @@ const _sfc_main$7 = /* @__PURE__ */ defineComponent({
       },
       set(val) {
         emits("update:modelValue", val);
+        emits("change");
       }
     });
     const filteredOptions = computed$2(() => {
@@ -23269,9 +24166,6 @@ const _sfc_main$7 = /* @__PURE__ */ defineComponent({
     function onClick2(event) {
       emits("click", event);
     }
-    function onChange2(event) {
-      emits("change", event);
-    }
     function getOptionValue(option) {
       if (props.reduceValueFunction)
         return props.reduceValueFunction(option);
@@ -23299,7 +24193,6 @@ const _sfc_main$7 = /* @__PURE__ */ defineComponent({
       computedStyle,
       computedClassSelect,
       getOptionValue,
-      onChange2,
       onClick2,
       filteredOptions
     ]);
@@ -23344,8 +24237,7 @@ const _sfc_main$7 = /* @__PURE__ */ defineComponent({
           class: normalizeClass(unref$1(computedClassSelect)),
           style: normalizeStyle(unref$1(computedStyleSelect)),
           disabled: __props.disabled,
-          onClick: _cache[2] || (_cache[2] = ($event) => onClick2($event)),
-          onChange: _cache[3] || (_cache[3] = ($event) => onChange2($event))
+          onClick: _cache[2] || (_cache[2] = ($event) => onClick2($event))
         }, [
           (openBlock(true), createElementBlock(Fragment, null, renderList(unref$1(filteredOptions), (option) => {
             return openBlock(), createElementBlock("option", {
@@ -23353,14 +24245,14 @@ const _sfc_main$7 = /* @__PURE__ */ defineComponent({
               key: option
             }, toDisplayString(getOptionName(option)), 9, _hoisted_2$5);
           }), 128))
-        ], 46, _hoisted_1$7), [
+        ], 14, _hoisted_1$7), [
           [vModelSelect, unref$1(value)]
         ])
       ], 4);
     };
   }
 });
-var ckSelect = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__scopeId", "data-v-5aafba97"]]);
+var ckSelect = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__scopeId", "data-v-d0d09d48"]]);
 var ckSidebar_vue_vue_type_style_index_0_scoped_true_lang = "";
 const _hoisted_1$6 = {
   key: 0,
@@ -24087,11 +24979,11 @@ function getCleekOptions(userOptions) {
   setRootColors(options.colors);
   return options;
 }
-const install = function installCleek(app, options) {
+const install2 = function installCleek(app, options) {
   app.config.globalProperties.$cleekOptions = getCleekOptions(options);
   app.use(plugin);
   Object.entries(components).forEach(([componentName, component]) => {
     app.component(componentName, component);
   });
 };
-export { CkButton, CkCheckbox, ckChip as CkChip, _sfc_main$a as CkDiv, ckDropdown as CkDropdown, CkIcon, ckImg as CkImg, CkInput, CkLabel, ckNavbar as CkNavbar, _sfc_main$e as CkPopup, ckRadio as CkRadio, ckSelect as CkSelect, ckSidebar as CkSidebar, ckSwitch as CkSwitch, ckSwitchOptions as CkSwitchOptions, ckTable as CkTable, CkTd, ckTextarea as CkTextarea, CkTh, CkTr, ckNotify, install as default };
+export { CkButton, CkCheckbox, ckChip as CkChip, _sfc_main$a as CkDiv, ckDropdown as CkDropdown, CkIcon, ckImg as CkImg, CkInput, CkLabel, ckNavbar as CkNavbar, _sfc_main$e as CkPopup, ckRadio as CkRadio, ckSelect as CkSelect, ckSidebar as CkSidebar, ckSwitch as CkSwitch, ckSwitchOptions as CkSwitchOptions, ckTable as CkTable, CkTd, ckTextarea as CkTextarea, CkTh, CkTr, ckNotify, install2 as default };