@fecp/mobile 1.0.1

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/calendar/CalendarMonth.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const utils$1 = require("../date-picker/utils.js");
+const utils = require("./utils.js");
+const index_esm = require("../../../../../@vant_use@1.6.0_vue@3.5.13_typescript@5.7.3_/node_modules/@vant/use/dist/index.esm.js");
+const useExpose = require("../composables/use-expose.js");
+const useHeight = require("../composables/use-height.js");
+const CalendarDay = require("./CalendarDay.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const format = require("../utils/format.js");
+const dom = require("../utils/dom.js");
+const basic = require("../utils/basic.js");
+const [name] = create.createNamespace("calendar-month");
+const calendarMonthProps = {
+  date: props.makeRequiredProp(Date),
+  type: String,
+  color: String,
+  minDate: Date,
+  maxDate: Date,
+  showMark: Boolean,
+  rowHeight: props.numericProp,
+  formatter: Function,
+  lazyRender: Boolean,
+  currentDate: [Date, Array],
+  allowSameDay: Boolean,
+  showSubtitle: Boolean,
+  showMonthTitle: Boolean,
+  firstDayOfWeek: Number
+};
+var stdin_default = vue.defineComponent({
+  name,
+  props: calendarMonthProps,
+  emits: ["click", "clickDisabledDate"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const [visible, setVisible] = index_esm.useToggle();
+    const daysRef = vue.ref();
+    const monthRef = vue.ref();
+    const height = useHeight.useHeight(monthRef);
+    const title = vue.computed(() => utils.formatMonthTitle(props2.date));
+    const rowHeight = vue.computed(() => format.addUnit(props2.rowHeight));
+    const offset = vue.computed(() => {
+      const date = props2.date.getDate();
+      const day = props2.date.getDay();
+      const realDay = (day - date % 7 + 8) % 7;
+      if (props2.firstDayOfWeek) {
+        return (realDay + 7 - props2.firstDayOfWeek) % 7;
+      }
+      return realDay;
+    });
+    const totalDay = vue.computed(() => utils$1.getMonthEndDay(props2.date.getFullYear(), props2.date.getMonth() + 1));
+    const shouldRender = vue.computed(() => visible.value || !props2.lazyRender);
+    const getTitle = () => title.value;
+    const getMultipleDayType = (day) => {
+      const isSelected = (date) => props2.currentDate.some((item) => utils.compareDay(item, date) === 0);
+      if (isSelected(day)) {
+        const prevDay = utils.getPrevDay(day);
+        const nextDay = utils.getNextDay(day);
+        const prevSelected = isSelected(prevDay);
+        const nextSelected = isSelected(nextDay);
+        if (prevSelected && nextSelected) {
+          return "multiple-middle";
+        }
+        if (prevSelected) {
+          return "end";
+        }
+        if (nextSelected) {
+          return "start";
+        }
+        return "multiple-selected";
+      }
+      return "";
+    };
+    const getRangeDayType = (day) => {
+      const [startDay, endDay] = props2.currentDate;
+      if (!startDay) {
+        return "";
+      }
+      const compareToStart = utils.compareDay(day, startDay);
+      if (!endDay) {
+        return compareToStart === 0 ? "start" : "";
+      }
+      const compareToEnd = utils.compareDay(day, endDay);
+      if (props2.allowSameDay && compareToStart === 0 && compareToEnd === 0) {
+        return "start-end";
+      }
+      if (compareToStart === 0) {
+        return "start";
+      }
+      if (compareToEnd === 0) {
+        return "end";
+      }
+      if (compareToStart > 0 && compareToEnd < 0) {
+        return "middle";
+      }
+      return "";
+    };
+    const getDayType = (day) => {
+      const {
+        type,
+        minDate,
+        maxDate,
+        currentDate
+      } = props2;
+      if (minDate && utils.compareDay(day, minDate) < 0 || maxDate && utils.compareDay(day, maxDate) > 0) {
+        return "disabled";
+      }
+      if (currentDate === null) {
+        return "";
+      }
+      if (Array.isArray(currentDate)) {
+        if (type === "multiple") {
+          return getMultipleDayType(day);
+        }
+        if (type === "range") {
+          return getRangeDayType(day);
+        }
+      } else if (type === "single") {
+        return utils.compareDay(day, currentDate) === 0 ? "selected" : "";
+      }
+      return "";
+    };
+    const getBottomInfo = (dayType) => {
+      if (props2.type === "range") {
+        if (dayType === "start" || dayType === "end") {
+          return utils.t(dayType);
+        }
+        if (dayType === "start-end") {
+          return `${utils.t("start")}/${utils.t("end")}`;
+        }
+      }
+    };
+    const renderTitle = () => {
+      if (props2.showMonthTitle) {
+        return vue.createVNode("div", {
+          "class": utils.bem("month-title")
+        }, [slots["month-title"] ? slots["month-title"]({
+          date: props2.date,
+          text: title.value
+        }) : title.value]);
+      }
+    };
+    const renderMark = () => {
+      if (props2.showMark && shouldRender.value) {
+        return vue.createVNode("div", {
+          "class": utils.bem("month-mark")
+        }, [props2.date.getMonth() + 1]);
+      }
+    };
+    const placeholders = vue.computed(() => {
+      const count = Math.ceil((totalDay.value + offset.value) / 7);
+      return Array(count).fill({
+        type: "placeholder"
+      });
+    });
+    const days = vue.computed(() => {
+      const days2 = [];
+      const year = props2.date.getFullYear();
+      const month = props2.date.getMonth();
+      for (let day = 1; day <= totalDay.value; day++) {
+        const date = new Date(year, month, day);
+        const type = getDayType(date);
+        let config = {
+          date,
+          type,
+          text: day,
+          bottomInfo: getBottomInfo(type)
+        };
+        if (props2.formatter) {
+          config = props2.formatter(config);
+        }
+        days2.push(config);
+      }
+      return days2;
+    });
+    const disabledDays = vue.computed(() => days.value.filter((day) => day.type === "disabled"));
+    const scrollToDate = (body, targetDate) => {
+      if (daysRef.value) {
+        const daysRect = index_esm.useRect(daysRef.value);
+        const totalRows = placeholders.value.length;
+        const currentRow = Math.ceil((targetDate.getDate() + offset.value) / 7);
+        const rowOffset = (currentRow - 1) * daysRect.height / totalRows;
+        dom.setScrollTop(body, daysRect.top + rowOffset + body.scrollTop - index_esm.useRect(body).top);
+      }
+    };
+    const renderDay = (item, index) => vue.createVNode(CalendarDay.default, {
+      "item": item,
+      "index": index,
+      "color": props2.color,
+      "offset": offset.value,
+      "rowHeight": rowHeight.value,
+      "onClick": (item2) => emit("click", item2),
+      "onClickDisabledDate": (item2) => emit("clickDisabledDate", item2)
+    }, basic.pick(slots, ["top-info", "bottom-info", "text"]));
+    const renderDays = () => vue.createVNode("div", {
+      "ref": daysRef,
+      "role": "grid",
+      "class": utils.bem("days")
+    }, [renderMark(), (shouldRender.value ? days : placeholders).value.map(renderDay)]);
+    useExpose.useExpose({
+      getTitle,
+      getHeight: () => height.value,
+      setVisible,
+      scrollToDate,
+      disabledDays
+    });
+    return () => vue.createVNode("div", {
+      "class": utils.bem("month"),
+      "ref": monthRef
+    }, [renderTitle(), renderDays()]);
+  }
+});
+exports.default = stdin_default;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/calendar/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Calendar$1 = require("./Calendar.js");
+const withInstall = require("../utils/with-install.js");
+const Calendar = withInstall.withInstall(Calendar$1.default);
+exports.calendarProps = Calendar$1.calendarProps;
+exports.Calendar = Calendar;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/calendar/utils.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const create = require("../utils/create.js");
+const [name, bem, t] = create.createNamespace("calendar");
+const formatMonthTitle = (date) => t("monthTitle", date.getFullYear(), date.getMonth() + 1);
+function compareMonth(date1, date2) {
+  const year1 = date1.getFullYear();
+  const year2 = date2.getFullYear();
+  if (year1 === year2) {
+    const month1 = date1.getMonth();
+    const month2 = date2.getMonth();
+    return month1 === month2 ? 0 : month1 > month2 ? 1 : -1;
+  }
+  return year1 > year2 ? 1 : -1;
+}
+function compareDay(day1, day2) {
+  const compareMonthResult = compareMonth(day1, day2);
+  if (compareMonthResult === 0) {
+    const date1 = day1.getDate();
+    const date2 = day2.getDate();
+    return date1 === date2 ? 0 : date1 > date2 ? 1 : -1;
+  }
+  return compareMonthResult;
+}
+const cloneDate = (date) => new Date(date);
+const cloneDates = (dates) => Array.isArray(dates) ? dates.map(cloneDate) : cloneDate(dates);
+function getDayByOffset(date, offset) {
+  const cloned = cloneDate(date);
+  cloned.setDate(cloned.getDate() + offset);
+  return cloned;
+}
+function getMonthByOffset(date, offset) {
+  const cloned = cloneDate(date);
+  cloned.setMonth(cloned.getMonth() + offset);
+  if (cloned.getDate() !== date.getDate()) {
+    cloned.setDate(0);
+  }
+  return cloned;
+}
+function getYearByOffset(date, offset) {
+  const cloned = cloneDate(date);
+  cloned.setFullYear(cloned.getFullYear() + offset);
+  if (cloned.getDate() !== date.getDate()) {
+    cloned.setDate(0);
+  }
+  return cloned;
+}
+const getPrevDay = (date) => getDayByOffset(date, -1);
+const getNextDay = (date) => getDayByOffset(date, 1);
+const getPrevMonth = (date) => getMonthByOffset(date, -1);
+const getNextMonth = (date) => getMonthByOffset(date, 1);
+const getPrevYear = (date) => getYearByOffset(date, -1);
+const getNextYear = (date) => getYearByOffset(date, 1);
+const getToday = () => {
+  const today = /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  return today;
+};
+function calcDateNum(date) {
+  const day1 = date[0].getTime();
+  const day2 = date[1].getTime();
+  return (day2 - day1) / (1e3 * 60 * 60 * 24) + 1;
+}
+function isLastRowInMonth(date, offset = 0) {
+  const lastDay = new Date(date.getFullYear(), date.getMonth() + 1, 0);
+  const currentPos = offset + date.getDate() - 1;
+  const lastDayPos = offset + lastDay.getDate() - 1;
+  return Math.floor(currentPos / 7) === Math.floor(lastDayPos / 7);
+}
+exports.bem = bem;
+exports.calcDateNum = calcDateNum;
+exports.cloneDate = cloneDate;
+exports.cloneDates = cloneDates;
+exports.compareDay = compareDay;
+exports.compareMonth = compareMonth;
+exports.formatMonthTitle = formatMonthTitle;
+exports.getDayByOffset = getDayByOffset;
+exports.getMonthByOffset = getMonthByOffset;
+exports.getNextDay = getNextDay;
+exports.getNextMonth = getNextMonth;
+exports.getNextYear = getNextYear;
+exports.getPrevDay = getPrevDay;
+exports.getPrevMonth = getPrevMonth;
+exports.getPrevYear = getPrevYear;
+exports.getToday = getToday;
+exports.getYearByOffset = getYearByOffset;
+exports.isLastRowInMonth = isLastRowInMonth;
+exports.name = name;
+exports.t = t;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/cascader/Cascader.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const useRefs = require("../composables/use-refs.js");
+const index$2 = require("../tab/index.js");
+const index$1 = require("../tabs/index.js");
+const index = require("../icon/index.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const basic = require("../utils/basic.js");
+const constant = require("../utils/constant.js");
+const [name, bem, t] = create.createNamespace("cascader");
+const cascaderProps = {
+  title: String,
+  options: props.makeArrayProp(),
+  closeable: props.truthProp,
+  swipeable: props.truthProp,
+  closeIcon: props.makeStringProp("cross"),
+  showHeader: props.truthProp,
+  modelValue: props.numericProp,
+  fieldNames: Object,
+  placeholder: String,
+  activeColor: String
+};
+var stdin_default = vue.defineComponent({
+  name,
+  props: cascaderProps,
+  emits: ["close", "change", "finish", "clickTab", "update:modelValue"],
+  setup(props2, {
+    slots,
+    emit
+  }) {
+    const tabs = vue.ref([]);
+    const activeTab = vue.ref(0);
+    const [selectedElementRefs, setSelectedElementRefs] = useRefs.useRefs();
+    const {
+      text: textKey,
+      value: valueKey,
+      children: childrenKey
+    } = basic.extend({
+      text: "text",
+      value: "value",
+      children: "children"
+    }, props2.fieldNames);
+    const getSelectedOptionsByValue = (options, value) => {
+      for (const option of options) {
+        if (option[valueKey] === value) {
+          return [option];
+        }
+        if (option[childrenKey]) {
+          const selectedOptions = getSelectedOptionsByValue(option[childrenKey], value);
+          if (selectedOptions) {
+            return [option, ...selectedOptions];
+          }
+        }
+      }
+    };
+    const updateTabs = () => {
+      const {
+        options,
+        modelValue
+      } = props2;
+      if (modelValue !== void 0) {
+        const selectedOptions = getSelectedOptionsByValue(options, modelValue);
+        if (selectedOptions) {
+          let optionsCursor = options;
+          tabs.value = selectedOptions.map((option) => {
+            const tab = {
+              options: optionsCursor,
+              selected: option
+            };
+            const next = optionsCursor.find((item) => item[valueKey] === option[valueKey]);
+            if (next) {
+              optionsCursor = next[childrenKey];
+            }
+            return tab;
+          });
+          if (optionsCursor) {
+            tabs.value.push({
+              options: optionsCursor,
+              selected: null
+            });
+          }
+          vue.nextTick(() => {
+            activeTab.value = tabs.value.length - 1;
+          });
+          return;
+        }
+      }
+      tabs.value = [{
+        options,
+        selected: null
+      }];
+    };
+    const onSelect = (option, tabIndex) => {
+      if (option.disabled) {
+        return;
+      }
+      tabs.value[tabIndex].selected = option;
+      if (tabs.value.length > tabIndex + 1) {
+        tabs.value = tabs.value.slice(0, tabIndex + 1);
+      }
+      if (option[childrenKey]) {
+        const nextTab = {
+          options: option[childrenKey],
+          selected: null
+        };
+        if (tabs.value[tabIndex + 1]) {
+          tabs.value[tabIndex + 1] = nextTab;
+        } else {
+          tabs.value.push(nextTab);
+        }
+        vue.nextTick(() => {
+          activeTab.value++;
+        });
+      }
+      const selectedOptions = tabs.value.map((tab) => tab.selected).filter(Boolean);
+      emit("update:modelValue", option[valueKey]);
+      const params = {
+        value: option[valueKey],
+        tabIndex,
+        selectedOptions
+      };
+      emit("change", params);
+      if (!option[childrenKey]) {
+        emit("finish", params);
+      }
+    };
+    const onClose = () => emit("close");
+    const onClickTab = ({
+      name: name2,
+      title
+    }) => emit("clickTab", name2, title);
+    const renderHeader = () => props2.showHeader ? vue.createVNode("div", {
+      "class": bem("header")
+    }, [vue.createVNode("h2", {
+      "class": bem("title")
+    }, [slots.title ? slots.title() : props2.title]), props2.closeable ? vue.createVNode(index.Icon, {
+      "name": props2.closeIcon,
+      "class": [bem("close-icon"), constant.HAPTICS_FEEDBACK],
+      "onClick": onClose
+    }, null) : null]) : null;
+    const renderOption = (option, selectedOption, tabIndex) => {
+      const {
+        disabled
+      } = option;
+      const selected = !!(selectedOption && option[valueKey] === selectedOption[valueKey]);
+      const color = option.color || (selected ? props2.activeColor : void 0);
+      const Text = slots.option ? slots.option({
+        option,
+        selected
+      }) : vue.createVNode("span", null, [option[textKey]]);
+      return vue.createVNode("li", {
+        "ref": selected ? setSelectedElementRefs(tabIndex) : void 0,
+        "role": "menuitemradio",
+        "class": [bem("option", {
+          selected,
+          disabled
+        }), option.className],
+        "style": {
+          color
+        },
+        "tabindex": disabled ? void 0 : selected ? 0 : -1,
+        "aria-checked": selected,
+        "aria-disabled": disabled || void 0,
+        "onClick": () => onSelect(option, tabIndex)
+      }, [Text, selected ? vue.createVNode(index.Icon, {
+        "name": "success",
+        "class": bem("selected-icon")
+      }, null) : null]);
+    };
+    const renderOptions = (options, selectedOption, tabIndex) => vue.createVNode("ul", {
+      "role": "menu",
+      "class": bem("options")
+    }, [options.map((option) => renderOption(option, selectedOption, tabIndex))]);
+    const renderTab = (tab, tabIndex) => {
+      const {
+        options,
+        selected
+      } = tab;
+      const placeholder = props2.placeholder || t("select");
+      const title = selected ? selected[textKey] : placeholder;
+      return vue.createVNode(index$2.Tab, {
+        "title": title,
+        "titleClass": bem("tab", {
+          unselected: !selected
+        })
+      }, {
+        default: () => {
+          var _a, _b;
+          return [(_a = slots["options-top"]) == null ? void 0 : _a.call(slots, {
+            tabIndex
+          }), renderOptions(options, selected, tabIndex), (_b = slots["options-bottom"]) == null ? void 0 : _b.call(slots, {
+            tabIndex
+          })];
+        }
+      });
+    };
+    const renderTabs = () => vue.createVNode(index$1.Tabs, {
+      "active": activeTab.value,
+      "onUpdate:active": ($event) => activeTab.value = $event,
+      "shrink": true,
+      "animated": true,
+      "class": bem("tabs"),
+      "color": props2.activeColor,
+      "swipeable": props2.swipeable,
+      "onClickTab": onClickTab
+    }, {
+      default: () => [tabs.value.map(renderTab)]
+    });
+    const scrollIntoView = (el) => {
+      const scrollParent = el.parentElement;
+      if (scrollParent) {
+        scrollParent.scrollTop = el.offsetTop - (scrollParent.offsetHeight - el.offsetHeight) / 2;
+      }
+    };
+    updateTabs();
+    vue.watch(activeTab, (value) => {
+      const el = selectedElementRefs.value[value];
+      if (el) scrollIntoView(el);
+    });
+    vue.watch(() => props2.options, updateTabs, {
+      deep: true
+    });
+    vue.watch(() => props2.modelValue, (value) => {
+      if (value !== void 0) {
+        const values = tabs.value.map((tab) => {
+          var _a;
+          return (_a = tab.selected) == null ? void 0 : _a[valueKey];
+        });
+        if (values.includes(value)) {
+          return;
+        }
+      }
+      updateTabs();
+    });
+    return () => vue.createVNode("div", {
+      "class": bem()
+    }, [renderHeader(), renderTabs()]);
+  }
+});
+exports.cascaderProps = cascaderProps;
+exports.default = stdin_default;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/cascader/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Cascader$1 = require("./Cascader.js");
+const withInstall = require("../utils/with-install.js");
+const Cascader = withInstall.withInstall(Cascader$1.default);
+exports.cascaderProps = Cascader$1.cascaderProps;
+exports.Cascader = Cascader;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/cell/Cell.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const useRoute = require("../composables/use-route.js");
+const index = require("../icon/index.js");
+const basic = require("../utils/basic.js");
+const create = require("../utils/create.js");
+const props = require("../utils/props.js");
+const [name, bem] = create.createNamespace("cell");
+const cellSharedProps = {
+  tag: props.makeStringProp("div"),
+  icon: String,
+  size: String,
+  title: props.numericProp,
+  value: props.numericProp,
+  label: props.numericProp,
+  center: Boolean,
+  isLink: Boolean,
+  border: props.truthProp,
+  iconPrefix: String,
+  valueClass: props.unknownProp,
+  labelClass: props.unknownProp,
+  titleClass: props.unknownProp,
+  titleStyle: null,
+  arrowDirection: String,
+  required: {
+    type: [Boolean, String],
+    default: null
+  },
+  clickable: {
+    type: Boolean,
+    default: null
+  }
+};
+const cellProps = basic.extend({}, cellSharedProps, useRoute.routeProps);
+var stdin_default = vue.defineComponent({
+  name,
+  props: cellProps,
+  setup(props2, {
+    slots
+  }) {
+    const route = useRoute.useRoute();
+    const renderLabel = () => {
+      const showLabel = slots.label || basic.isDef(props2.label);
+      if (showLabel) {
+        return vue.createVNode("div", {
+          "class": [bem("label"), props2.labelClass]
+        }, [slots.label ? slots.label() : props2.label]);
+      }
+    };
+    const renderTitle = () => {
+      var _a;
+      if (slots.title || basic.isDef(props2.title)) {
+        const titleSlot = (_a = slots.title) == null ? void 0 : _a.call(slots);
+        if (Array.isArray(titleSlot) && titleSlot.length === 0) {
+          return;
+        }
+        return vue.createVNode("div", {
+          "class": [bem("title"), props2.titleClass],
+          "style": props2.titleStyle
+        }, [titleSlot || vue.createVNode("span", null, [props2.title]), renderLabel()]);
+      }
+    };
+    const renderValue = () => {
+      const slot = slots.value || slots.default;
+      const hasValue = slot || basic.isDef(props2.value);
+      if (hasValue) {
+        return vue.createVNode("div", {
+          "class": [bem("value"), props2.valueClass]
+        }, [slot ? slot() : vue.createVNode("span", null, [props2.value])]);
+      }
+    };
+    const renderLeftIcon = () => {
+      if (slots.icon) {
+        return slots.icon();
+      }
+      if (props2.icon) {
+        return vue.createVNode(index.Icon, {
+          "name": props2.icon,
+          "class": bem("left-icon"),
+          "classPrefix": props2.iconPrefix
+        }, null);
+      }
+    };
+    const renderRightIcon = () => {
+      if (slots["right-icon"]) {
+        return slots["right-icon"]();
+      }
+      if (props2.isLink) {
+        const name2 = props2.arrowDirection && props2.arrowDirection !== "right" ? `arrow-${props2.arrowDirection}` : "arrow";
+        return vue.createVNode(index.Icon, {
+          "name": name2,
+          "class": bem("right-icon")
+        }, null);
+      }
+    };
+    return () => {
+      var _a;
+      const {
+        tag,
+        size,
+        center,
+        border,
+        isLink,
+        required
+      } = props2;
+      const clickable = (_a = props2.clickable) != null ? _a : isLink;
+      const classes = {
+        center,
+        required: !!required,
+        clickable,
+        borderless: !border
+      };
+      if (size) {
+        classes[size] = !!size;
+      }
+      return vue.createVNode(tag, {
+        "class": bem(classes),
+        "role": clickable ? "button" : void 0,
+        "tabindex": clickable ? 0 : void 0,
+        "onClick": route
+      }, {
+        default: () => {
+          var _a2;
+          return [renderLeftIcon(), renderTitle(), renderValue(), renderRightIcon(), (_a2 = slots.extra) == null ? void 0 : _a2.call(slots)];
+        }
+      });
+    };
+  }
+});
+exports.cellProps = cellProps;
+exports.cellSharedProps = cellSharedProps;
+exports.default = stdin_default;