import { defineComponent, ref, onMounted, onUnmounted, withDirectives, createVNode, createTextVNode, resolveDirective, toRefs, watch, resolveComponent, computed, Fragment, reactive, getCurrentInstance, mergeProps, nextTick } from "vue";
const paginationProps = {
  pageSize: {
    type: Number,
    default: 10
  },
  total: {
    type: Number,
    default: 0
  },
  pageSizeOptions: {
    type: Array,
    default: () => [5, 10, 20, 50]
  },
  pageSizeDirection: {
    type: Array,
    default: () => ["centerDown", "centerUp"]
  },
  pageIndex: {
    type: Number,
    default: 1
  },
  maxItems: {
    type: Number,
    default: 10
  },
  preLink: {
    type: String,
    default: "&lt;"
  },
  nextLink: {
    type: String,
    default: "&gt;"
  },
  size: {
    type: String,
    default: ""
  },
  canJumpPage: {
    type: Boolean,
    default: false
  },
  canChangePageSize: {
    type: Boolean,
    default: false
  },
  canViewTotal: {
    type: Boolean,
    default: false
  },
  totalItemText: {
    type: String
  },
  goToText: {
    type: String
  },
  showJumpButton: {
    type: Boolean,
    default: false
  },
  showTruePageIndex: {
    type: Boolean,
    default: false
  },
  lite: {
    type: Boolean,
    default: false
  },
  showPageSelector: {
    type: Boolean,
    default: true
  },
  haveConfigMenu: {
    type: Boolean,
    default: false
  },
  autoFixPageIndex: {
    type: Boolean,
    default: true
  },
  autoHide: {
    type: Boolean,
    default: false
  },
  "onUpdate:pageIndex": {
    type: Function
  },
  "onUpdate:pageSize": {
    type: Function
  },
  "onPageIndexChange": {
    type: Function
  },
  "onPageSizeChange": {
    type: Function
  }
};
const handlePages = (cursor, maxItems, totalPages) => {
  const currentPage = cursor;
  const maxPages = maxItems;
  if (maxPages >= totalPages) {
    return [2, totalPages];
  }
  const midPages = maxPages - 2;
  let midStart = currentPage - (midPages >> 1);
  let midEnd = currentPage + (midPages - 1 >> 1);
  if (midStart < 2) {
    midStart = 2;
    midEnd = maxPages - 2;
  }
  if (midEnd > totalPages) {
    midStart = totalPages - maxPages + 3;
    midEnd = totalPages;
  }
  return [midStart, midEnd];
};
function liteSelectOptions(total) {
  return new Array(total || 1).fill(0).map((v, index2) => {
    return {
      name: `${index2 + 1}/${total}`,
      value: index2 + 1
    };
  });
}
function on(element, eventName, handler) {
  if (document.addEventListener) {
    if (element && eventName && handler) {
      element.addEventListener(eventName, handler, false);
    }
  } else {
    if (element && eventName && handler) {
      element.attachEvent("on" + eventName, handler);
    }
  }
}
function off(element, eventName, handler) {
  if (document.removeEventListener) {
    if (element && eventName && handler) {
      element.removeEventListener(eventName, handler, false);
    }
  } else {
    if (element && eventName && handler) {
      element.detachEvent("on" + eventName, handler);
    }
  }
}
const inBrowser = typeof window !== "undefined";
const ctx = Symbol("@@clickoutside");
const nodeList = /* @__PURE__ */ new Map();
let startClick;
let nid = 0;
let isFirst = true;
function createDocumentHandler(el, binding, vnode) {
  if (inBrowser && isFirst) {
    isFirst = false;
    on(document, "mousedown", (e) => {
      startClick = e;
    });
    on(document, "mouseup", (e) => {
      for (const [id, node] of nodeList) {
        node[ctx].documentHandler(e, startClick);
      }
    });
  }
  return function(mouseup, mousedown) {
    if (!vnode || !binding.instance || !mouseup.target || !mousedown.target || el.contains(mouseup.target) || el.contains(mousedown.target) || el === mouseup.target) {
      return;
    }
    el[ctx].bindingFn && el[ctx].bindingFn();
  };
}
const clickoutsideDirective = {
  beforeMount: function(el, binding, vnode) {
    nid++;
    nodeList.set(nid, el);
    el[ctx] = {
      nid,
      documentHandler: createDocumentHandler(el, binding, vnode),
      bindingFn: binding.value
    };
  },
  updated: function(el, binding, vnode) {
    el[ctx].documentHandler = createDocumentHandler(el, binding, vnode);
    el[ctx].bindingFn = binding.value;
  },
  unmounted: function(el) {
    nodeList.delete(el[ctx].nid);
    delete el[ctx];
  }
};
function createBem(namespace, element, modifier) {
  let cls = namespace;
  if (element) {
    cls += `__${element}`;
  }
  if (modifier) {
    cls += `--${modifier}`;
  }
  return cls;
}
function useNamespace(block, needDot = false) {
  const namespace = needDot ? `.devui-${block}` : `devui-${block}`;
  const b = () => createBem(namespace);
  const e = (element) => element ? createBem(namespace, element) : "";
  const m = (modifier) => modifier ? createBem(namespace, "", modifier) : "";
  const em = (element, modifier) => element && modifier ? createBem(namespace, element, modifier) : "";
  return {
    b,
    e,
    m,
    em
  };
}
var ConfigMenu = defineComponent({
  directives: {
    clickoutside: clickoutsideDirective
  },
  props: {
    currentPageSize: Number,
    pageSizeChange: Function,
    pageSizeOptions: Array
  },
  setup() {
    const paginationConfig = ref(null);
    const isShowConfig = ref(false);
    const closeConfigMenu = (e) => {
      isShowConfig.value = isShowConfig.value ? false : !!e;
    };
    onMounted(() => {
      on(paginationConfig.value, "click", closeConfigMenu);
    });
    onUnmounted(() => {
      off(paginationConfig.value, "click", closeConfigMenu);
    });
    return {
      paginationConfig,
      isShowConfig,
      closeConfigMenu
    };
  },
  render() {
    var _a;
    const {
      closeConfigMenu,
      currentPageSize,
      pageSizeChange,
      pageSizeOptions,
      isShowConfig,
      $slots
    } = this;
    const ns = useNamespace("pagination");
    return withDirectives(createVNode("div", {
      "class": ns.e("config"),
      "ref": "paginationConfig"
    }, [createVNode("div", {
      "class": ns.e("setup-icon")
    }, [createVNode("i", {
      "class": "icon-setting",
      "style": "font-weight: bold;"
    }, null)]), isShowConfig && createVNode("div", {
      "class": ns.e("config-container")
    }, [(_a = $slots.default) == null ? void 0 : _a.call($slots), createVNode("div", {
      "class": ns.e("config-item")
    }, [createVNode("div", {
      "class": "config-item-title"
    }, [createTextVNode("\u6BCF\u9875\u6761\u6570")]), createVNode("div", {
      "class": ns.e("number")
    }, [pageSizeOptions.map((v) => {
      return createVNode("div", {
        "class": {
          choosed: v === currentPageSize
        },
        "key": v,
        "onClick": pageSizeChange.bind(null, {
          value: v
        })
      }, [v]);
    })])])])]), [[resolveDirective("clickoutside"), closeConfigMenu]]);
  }
});
const jumpPageProps = {
  goToText: String,
  size: {
    type: String,
    default: ""
  },
  pageIndex: Number,
  showJumpButton: Boolean,
  totalPages: Number,
  cursor: Number,
  onChangeCursorEmit: Function
};
var JumpPage = defineComponent({
  props: jumpPageProps,
  emits: ["changeCursorEmit"],
  setup(props, {
    emit
  }) {
    const {
      pageIndex,
      totalPages,
      cursor
    } = toRefs(props);
    const inputNum = ref(pageIndex == null ? void 0 : pageIndex.value);
    watch(() => pageIndex == null ? void 0 : pageIndex.value, (val) => {
      inputNum.value = val;
    });
    let curPage = pageIndex == null ? void 0 : pageIndex.value;
    const jumpPageChange = (currentPage) => {
      curPage = +currentPage;
      inputNum.value = currentPage;
      if (isNaN(currentPage)) {
        setTimeout(() => {
          inputNum.value = pageIndex == null ? void 0 : pageIndex.value;
        }, 300);
      }
    };
    const jump = (e) => {
      if (curPage > (totalPages == null ? void 0 : totalPages.value)) {
        return;
      }
      if ((e === "btn" || e.key === "Enter") && (cursor == null ? void 0 : cursor.value) !== curPage) {
        emit("changeCursorEmit", curPage);
      }
    };
    return {
      inputNum,
      jumpPageChange,
      jump
    };
  },
  render() {
    const {
      goToText,
      size,
      inputNum,
      jumpPageChange,
      jump,
      showJumpButton
    } = this;
    const ns = useNamespace("pagination");
    const inputProps = {
      class: [ns.e("input"), size ? ns.em("input", size) : ""],
      size,
      modelValue: String(inputNum),
      "onUpdate:modelValue": jumpPageChange,
      onKeydown: jump
    };
    return createVNode("div", {
      "class": ns.e("jump-container")
    }, [
      goToText,
      createVNode(resolveComponent("d-input"), inputProps, null),
      goToText === "\u8DF3\u81F3" && "\u9875",
      showJumpButton && createVNode("div", {
        "class": [ns.e("jump-button"), size ? ns.em("jump-size", size) : ns.em("jump-size", "default")],
        "onClick": jump.bind(null, "btn"),
        "title": goToText
      }, [createVNode("div", {
        "class": ns.e("go")
      }, null)])
    ]);
  }
});
const pageNumBtnProps = {
  size: {
    type: String,
    default: ""
  },
  preLink: String,
  nextLink: String,
  lite: Boolean,
  cursor: Number,
  maxItems: Number,
  totalPages: Number,
  onChangeCursorEmit: Function,
  showTruePageIndex: Boolean
};
var PageNumBtn = defineComponent({
  props: pageNumBtnProps,
  emits: ["changeCursorEmit"],
  setup(props, {
    emit
  }) {
    const showPageNum = computed(() => handlePages(props.cursor, props.maxItems, props.totalPages));
    const changeCursor = (pageSize) => {
      if (isNaN(pageSize)) {
        return;
      }
      const page = pageSize < 1 ? 1 : pageSize > props.totalPages ? props.totalPages : pageSize | 0;
      emit("changeCursorEmit", page);
    };
    const prevChange = (page) => {
      if (props.cursor > 1) {
        const toPage = page === -1 ? props.cursor - 1 : page;
        emit("changeCursorEmit", toPage);
      }
    };
    const nextChange = (page) => {
      if (props.cursor < props.totalPages) {
        const toPage = page === -1 ? props.cursor + 1 : page;
        emit("changeCursorEmit", toPage);
      }
    };
    return {
      showPageNum,
      changeCursor,
      prevChange,
      nextChange
    };
  },
  render() {
    const {
      size,
      preLink,
      nextLink,
      lite,
      changeCursor,
      cursor,
      showPageNum,
      prevChange,
      totalPages,
      nextChange,
      showTruePageIndex
    } = this;
    const ns = useNamespace("pagination");
    return createVNode("ul", {
      "class": [ns.e("list"), size ? ns.m(size) : ""]
    }, [createVNode("li", {
      "onClick": prevChange.bind(null, -1),
      "class": {
        [ns.e("item")]: true,
        disabled: cursor <= 1
      }
    }, [createVNode("a", {
      "innerHTML": preLink,
      "class": ns.e("link")
    }, null)]), !lite && createVNode(Fragment, null, [
      createVNode("li", {
        "onClick": changeCursor.bind(null, 1),
        "class": {
          [ns.e("item")]: true,
          active: cursor === 1
        }
      }, [createVNode("a", {
        "class": ns.e("link")
      }, [createTextVNode("1")])]),
      showPageNum[0] > 2 && createVNode("li", {
        "onClick": prevChange.bind(null, showPageNum[0] - 1),
        "class": ns.e("item")
      }, [createVNode("a", {
        "class": ns.e("link")
      }, [createTextVNode("...")])]),
      (() => {
        const list = [];
        for (let i = showPageNum[0]; i <= showPageNum[1]; i++) {
          list.push(createVNode("li", {
            "onClick": changeCursor.bind(null, i),
            "key": i,
            "class": {
              [ns.e("item")]: true,
              active: cursor === i
            }
          }, [createVNode("a", {
            "class": ns.e("link")
          }, [i])]));
        }
        return list;
      })(),
      showPageNum[1] < totalPages - 1 && createVNode("li", {
        "onClick": nextChange.bind(null, showPageNum[1] + 1),
        "class": ns.e("item")
      }, [createVNode("a", {
        "class": ns.e("link")
      }, [createTextVNode("...")])]),
      showPageNum[1] < totalPages && createVNode("li", {
        "onClick": changeCursor.bind(null, totalPages),
        "class": {
          [ns.e("item")]: true,
          active: cursor === totalPages
        }
      }, [createVNode("a", {
        "class": ns.e("link")
      }, [totalPages])]),
      showTruePageIndex && cursor > totalPages && totalPages > 0 && createVNode(Fragment, null, [cursor > totalPages + 1 && createVNode("li", {
        "class": [ns.e("item"), "disabled"]
      }, [createVNode("a", {
        "class": ns.e("link")
      }, [createTextVNode("...")])]), createVNode("li", {
        "class": [ns.e("item"), "disabled", "active"]
      }, [createVNode("a", {
        "class": ns.e("link")
      }, [cursor])])])
    ]), createVNode("li", {
      "onClick": nextChange.bind(null, -1),
      "class": {
        [ns.e("item")]: true,
        disabled: cursor >= totalPages
      }
    }, [createVNode("a", {
      "innerHTML": nextLink,
      "class": ns.e("link")
    }, null)])]);
  }
});
function deepAssign(...objects) {
  const isObject = (obj) => obj && typeof obj === "object";
  return objects.reduce((prev, from) => {
    Object.keys(from).forEach((key) => {
      const pVal = prev[key];
      const oVal = from[key];
      if (Array.isArray(pVal) && Array.isArray(oVal)) {
        prev[key] = Array.from(/* @__PURE__ */ new Set([...oVal, ...pVal]));
      } else if (isObject(pVal) && isObject(oVal)) {
        prev[key] = deepAssign(pVal, oVal);
      } else {
        prev[key] = oVal;
      }
    });
    return prev;
  }, {});
}
var zhCN = {
  pagination: {
    totalItemText: "\u6240\u6709\u6761\u76EE",
    goToText: "\u8DF3\u81F3"
  },
  accordion: {
    loading: "\u52A0\u8F7D\u4E2D",
    noData: "\u6CA1\u6709\u6570\u636E"
  },
  autoCompleteDropdown: {
    latestInput: "\u6700\u8FD1\u8F93\u5165"
  },
  cascaderList: {
    noData: "\u6CA1\u6709\u6570\u636E"
  },
  colorPicker: {
    foundationPanel: "\u57FA\u7840\u9762\u677F",
    advancedPanel: "\u9AD8\u7EA7\u9762\u677F"
  },
  datePickerPro: {
    ok: "\u786E\u5B9A",
    placeholder: "\u8BF7\u9009\u62E9\u65E5\u671F",
    month1: "1\u6708",
    month2: "2\u6708",
    month3: "3\u6708",
    month4: "4\u6708",
    month5: "5\u6708",
    month6: "6\u6708",
    month7: "7\u6708",
    month8: "8\u6708",
    month9: "9\u6708",
    month10: "10\u6708",
    month11: "11\u6708",
    month12: "12\u6708",
    year: "\u5E74",
    startPlaceholder: "\u8BF7\u9009\u62E9\u5F00\u59CB\u65E5\u671F",
    endPlaceholder: "\u8BF7\u9009\u62E9\u7ED3\u675F\u65E5\u671F",
    getWeekDays() {
      return ["\u65E5", "\u4E00", "\u4E8C", "\u4E09", "\u56DB", "\u4E94", "\u516D"];
    },
    getTimeArr() {
      return ["\u65F6", "\u5206", "\u79D2"];
    },
    getYearMonthStr(year, month) {
      return `${year}\u5E74${month}\u6708`;
    }
  },
  editableSelect: {
    noRelatedRecords: "\u627E\u4E0D\u5230\u76F8\u5173\u8BB0\u5F55",
    noData: "\u6CA1\u6709\u6570\u636E"
  },
  input: {
    placeholder: "\u8BF7\u8F93\u5165"
  },
  splitterBar: {
    collapse: "\u6536\u8D77",
    expand: "\u5C55\u5F00"
  },
  stepsGuide: {
    previous: "\u4E0A\u4E00\u6B65",
    continue: "\u6211\u77E5\u9053\u5566\uFF0C\u7EE7\u7EED",
    ok: "\u6211\u77E5\u9053\u5566"
  },
  table: {
    selectAll: "\u5168\u9009",
    ok: "\u786E\u5B9A"
  },
  timePopup: {
    ok: "\u786E\u5B9A"
  },
  transfer: {
    unit: "\u9879",
    panelUnit: "\u9879",
    headerUnit: "\u9879",
    noData: "\u6682\u65E0\u6570\u636E",
    placeholder: "\u8BF7\u8F93\u5165\u5173\u952E\u8BCD\u641C\u7D22"
  },
  tree: {
    loading: "\u52A0\u8F7D\u4E2D",
    newNode: "\u65B0\u8282\u70B9",
    selectPlaceholder: "\u8BF7\u9009\u62E9"
  },
  upload: {
    placeholder: "\u9009\u62E9\u6587\u4EF6",
    getExistSameNameFilesMsg(sameNames) {
      return `\u60A8\u4E0A\u4F20\u7684 "${sameNames}" \u5B58\u5728\u91CD\u540D\u6587\u4EF6, \u8BF7\u91CD\u65B0\u9009\u62E9\u6587\u4EF6`;
    },
    getAllFilesBeyondMaximalFileSizeMsg(maximalSize) {
      return `\u6700\u5927\u652F\u6301\u4E0A\u4F20${maximalSize}MB\u7684\u6587\u4EF6, \u60A8\u672C\u6B21\u4E0A\u4F20\u7684\u6240\u6709\u6587\u4EF6\u8D85\u8FC7\u53EF\u4E0A\u4F20\u6587\u4EF6\u5927\u5C0F`;
    },
    getBeyondMaximalFileSizeMsg(filename, maximalSize) {
      return `\u6700\u5927\u652F\u6301\u4E0A\u4F20${maximalSize}MB\u7684\u6587\u4EF6, \u60A8\u4E0A\u4F20\u7684\u6587\u4EF6"${filename}"\u8D85\u8FC7\u53EF\u4E0A\u4F20\u6587\u4EF6\u5927\u5C0F`;
    },
    getNotAllowedFileTypeMsg(filename, scope) {
      return `\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B: "${scope}", \u60A8\u4E0A\u4F20\u7684\u6587\u4EF6"${filename}"\u4E0D\u5728\u5141\u8BB8\u8303\u56F4\u5185\uFF0C\u8BF7\u91CD\u65B0\u9009\u62E9\u6587\u4EF6`;
    }
  },
  search: {
    placeholder: "\u8BF7\u8F93\u5165\u5173\u952E\u5B57"
  },
  select: {
    placeholder: "\u8BF7\u9009\u62E9",
    noDataText: "\u65E0\u6570\u636E",
    noMatchText: "\u627E\u4E0D\u5230\u76F8\u5173\u8BB0\u5F55",
    loadingText: "\u52A0\u8F7D\u4E2D..."
  },
  tagInput: {
    maxTagsText: "\u5DF2\u8FBE\u5230\u6700\u5927\u4E2A\u6570\uFF1A"
  },
  timeSelect: {
    placeholder: "\u8BF7\u9009\u62E9\u65F6\u95F4"
  }
};
const lang = ref("zh-CN");
let langMessages = reactive({
  [lang.value]: zhCN
});
const Locale = {
  messages() {
    return langMessages[lang.value];
  },
  lang() {
    return lang.value;
  },
  use(newLang, newMessages) {
    lang.value = newLang;
    this.add({ [newLang]: newMessages });
  },
  add(newMessages = {}) {
    langMessages = deepAssign(langMessages, newMessages);
  }
};
const camelize = (name) => name.substring(1).replace(/^\S/, (s) => s.toLocaleLowerCase());
function get(object, path) {
  const keys = path.split(".");
  let result = object;
  keys.forEach((key) => {
    var _a;
    result = (_a = result[key]) != null ? _a : "";
  });
  return result;
}
function createI18nTranslate(name, app, newPrefix) {
  const prefix = newPrefix || camelize(name) + ".";
  return (path) => {
    var _a;
    const messages = ((_a = app == null ? void 0 : app.appContext.config.globalProperties.langMessages) == null ? void 0 : _a.value) || Locale.messages();
    const message = get(messages, prefix + path) || get(messages, path);
    return message;
  };
}
var pagination = "";
var Pagination = defineComponent({
  name: "DPagination",
  components: {
    ConfigMenu,
    JumpPage,
    PageNumBtn
  },
  props: paginationProps,
  emits: ["pageIndexChange", "pageSizeChange", "update:pageSize", "update:pageIndex"],
  setup(props, {
    emit,
    slots
  }) {
    const app = getCurrentInstance();
    const t = createI18nTranslate("DPagination", app);
    const {
      autoHide,
      pageSizeOptions,
      total,
      canChangePageSize,
      lite,
      size,
      pageSizeDirection,
      showPageSelector,
      canViewTotal,
      totalItemText,
      maxItems,
      preLink,
      nextLink,
      showTruePageIndex,
      canJumpPage,
      goToText,
      pageIndex,
      showJumpButton,
      haveConfigMenu
    } = toRefs(props);
    const ns = useNamespace("pagination");
    const totalPages = computed(() => Math.ceil(props.total / props.pageSize));
    const litePageOptions = computed(() => liteSelectOptions(totalPages.value));
    const cursor = computed({
      get() {
        if (!props.showTruePageIndex && props.pageIndex > totalPages.value) {
          emit("update:pageIndex", totalPages.value || 1);
          return totalPages.value || 1;
        }
        return props.pageIndex || 1;
      },
      set(val) {
        emit("update:pageIndex", val);
      }
    });
    const currentPageSize = computed({
      get() {
        return props.pageSize;
      },
      set(val) {
        emit("update:pageSize", val);
      }
    });
    const changeCursorEmit = (val) => {
      cursor.value = val;
      emit("pageIndexChange", val);
    };
    const pageSizeChange = (val) => {
      currentPageSize.value = val.value;
      if (props.autoFixPageIndex) {
        nextTick(() => {
          if (cursor.value > totalPages.value) {
            changeCursorEmit(totalPages.value);
          }
        });
      }
      emit("pageSizeChange", val.value);
    };
    const litePageIndexChange = (page) => {
      changeCursorEmit(page.value);
    };
    return () => {
      return autoHide.value && Math.min(...pageSizeOptions.value) > total.value ? null : createVNode("div", {
        "class": ns.b()
      }, [
        canChangePageSize.value && !lite.value && createVNode("div", {
          "class": [ns.e("size"), size.value ? ns.em("size", size.value) : ""]
        }, [createVNode(resolveComponent("d-select"), {
          "options": pageSizeOptions.value,
          "modelValue": currentPageSize.value,
          "onValueChange": pageSizeChange,
          "pageSizeDirection": pageSizeDirection.value
        }, null)]),
        (!lite.value || lite.value && showPageSelector.value) && canViewTotal.value && createVNode("div", {
          "class": ns.e("total-size")
        }, [totalItemText.value || t("totalItemText"), createTextVNode(": "), total.value]),
        lite.value && showPageSelector.value && createVNode("div", {
          "class": ns.e("size")
        }, [createVNode(resolveComponent("d-select"), {
          "options": litePageOptions.value,
          "disabled": total.value === 0,
          "modelValue": cursor.value,
          "onValueChange": litePageIndexChange,
          "pageSizeDirection": pageSizeDirection.value
        }, null)]),
        createVNode(resolveComponent("page-num-btn"), mergeProps({
          cursor: cursor.value,
          totalPages: totalPages.value,
          size: size.value,
          lite: lite.value,
          maxItems: maxItems.value,
          preLink: preLink.value,
          nextLink: nextLink.value,
          showTruePageIndex: showTruePageIndex.value
        }, {
          "onChangeCursorEmit": changeCursorEmit
        }), null),
        canJumpPage.value && !lite.value && createVNode(resolveComponent("jump-page"), mergeProps({
          goToText: goToText.value || t("goToText"),
          size: size.value,
          pageIndex: pageIndex.value,
          totalPages: totalPages.value,
          cursor: cursor.value,
          showJumpButton: showJumpButton.value
        }, {
          "onChangeCursorEmit": changeCursorEmit
        }), null),
        lite.value && haveConfigMenu.value && createVNode(resolveComponent("config-menu"), {
          currentPageSize: currentPageSize.value,
          pageSizeChange,
          pageSizeOptions: pageSizeOptions.value
        }, {
          default: () => {
            var _a;
            return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
          }
        })
      ]);
    };
  }
});
var index = {
  title: "Pagination \u5206\u9875",
  category: "\u5BFC\u822A",
  status: "100%",
  install(app) {
    app.component(Pagination.name, Pagination);
  }
};
export { Pagination, index as default, paginationProps };
