@fecp/designer 5.5.113 → 5.5.115

package/lib/node_modules/vant/es/number-keyboard/NumberKeyboardKey.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const useTouch = require("../composables/use-touch.js");
+const index = require("../loading/index.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const dom = require("../utils/dom.js");
+const [name, bem] = create.createNamespace("key");
+const CollapseIcon = Vue.createVNode("svg", {
+  "class": bem("collapse-icon"),
+  "viewBox": "0 0 30 24"
+}, [Vue.createVNode("path", {
+  "d": "M26 13h-2v2h2v-2zm-8-3h2V8h-2v2zm2-4h2V4h-2v2zm2 4h4V4h-2v4h-2v2zm-7 14 3-3h-6l3 3zM6 13H4v2h2v-2zm16 0H8v2h14v-2zm-12-3h2V8h-2v2zM28 0l1 1 1 1v15l-1 2H1l-1-2V2l1-1 1-1zm0 2H2v15h26V2zM6 4v2H4V4zm10 2h2V4h-2v2zM8 9v1H4V8zm8 0v1h-2V8zm-6-5v2H8V4zm4 0v2h-2V4z",
+  "fill": "currentColor"
+}, null)]);
+const DeleteIcon = Vue.createVNode("svg", {
+  "class": bem("delete-icon"),
+  "viewBox": "0 0 32 22"
+}, [Vue.createVNode("path", {
+  "d": "M28 0a4 4 0 0 1 4 4v14a4 4 0 0 1-4 4H10.4a2 2 0 0 1-1.4-.6L1 13.1c-.6-.5-.9-1.3-.9-2 0-1 .3-1.7.9-2.2L9 .6a2 2 0 0 1 1.4-.6zm0 2H10.4l-8.2 8.3a1 1 0 0 0-.3.7c0 .3.1.5.3.7l8.2 8.4H28a2 2 0 0 0 2-2V4c0-1.1-.9-2-2-2zm-5 4a1 1 0 0 1 .7.3 1 1 0 0 1 0 1.4L20.4 11l3.3 3.3c.2.2.3.5.3.7 0 .3-.1.5-.3.7a1 1 0 0 1-.7.3 1 1 0 0 1-.7-.3L19 12.4l-3.4 3.3a1 1 0 0 1-.6.3 1 1 0 0 1-.7-.3 1 1 0 0 1-.3-.7c0-.2.1-.5.3-.7l3.3-3.3-3.3-3.3A1 1 0 0 1 14 7c0-.3.1-.5.3-.7A1 1 0 0 1 15 6a1 1 0 0 1 .6.3L19 9.6l3.3-3.3A1 1 0 0 1 23 6z",
+  "fill": "currentColor"
+}, null)]);
+var stdin_default = Vue.defineComponent({
+  name,
+  props: {
+    type: String,
+    text: props.numericProp,
+    color: String,
+    wider: Boolean,
+    large: Boolean,
+    loading: Boolean
+  },
+  emits: ["press"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const active = Vue.ref(false);
+    const touch = useTouch.useTouch();
+    const onTouchStart = (event) => {
+      touch.start(event);
+      active.value = true;
+    };
+    const onTouchMove = (event) => {
+      touch.move(event);
+      if (touch.direction.value) {
+        active.value = false;
+      }
+    };
+    const onTouchEnd = (event) => {
+      if (active.value) {
+        if (!slots.default) {
+          dom.preventDefault(event);
+        }
+        active.value = false;
+        emit("press", props2.text, props2.type);
+      }
+    };
+    const renderContent = () => {
+      if (props2.loading) {
+        return Vue.createVNode(index.Loading, {
+          "class": bem("loading-icon")
+        }, null);
+      }
+      const text = slots.default ? slots.default() : props2.text;
+      switch (props2.type) {
+        case "delete":
+          return text || DeleteIcon;
+        case "extra":
+          return text || CollapseIcon;
+        default:
+          return text;
+      }
+    };
+    return () => Vue.createVNode("div", {
+      "class": bem("wrapper", {
+        wider: props2.wider
+      }),
+      "onTouchstartPassive": onTouchStart,
+      "onTouchmovePassive": onTouchMove,
+      "onTouchend": onTouchEnd,
+      "onTouchcancel": onTouchEnd
+    }, [Vue.createVNode("div", {
+      "role": "button",
+      "tabindex": 0,
+      "class": bem([props2.color, {
+        large: props2.large,
+        active: active.value,
+        delete: props2.type === "delete"
+      }])
+    }, [renderContent()])]);
+  }
+});
+exports.default = stdin_default;

package/lib/node_modules/vant/es/number-keyboard/index.js

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

package/lib/node_modules/vant/es/overlay/Overlay.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const index_esm = require("../../../@vant/use/dist/index.esm.js");
+const useLazyRender = require("../composables/use-lazy-render.js");
+const format = require("../utils/format.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const dom = require("../utils/dom.js");
+const basic = require("../utils/basic.js");
+const [name, bem] = create.createNamespace("overlay");
+const overlayProps = {
+  show: Boolean,
+  zIndex: props.numericProp,
+  duration: props.numericProp,
+  className: props.unknownProp,
+  lockScroll: props.truthProp,
+  lazyRender: props.truthProp,
+  customStyle: Object,
+  teleport: [String, Object]
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: overlayProps,
+  setup(props2, {
+    slots
+  }) {
+    const root = Vue.ref();
+    const lazyRender = useLazyRender.useLazyRender(() => props2.show || !props2.lazyRender);
+    const onTouchMove = (event) => {
+      if (props2.lockScroll) {
+        dom.preventDefault(event, true);
+      }
+    };
+    const renderOverlay = lazyRender(() => {
+      var _a;
+      const style = basic.extend(format.getZIndexStyle(props2.zIndex), props2.customStyle);
+      if (basic.isDef(props2.duration)) {
+        style.animationDuration = `${props2.duration}s`;
+      }
+      return Vue.withDirectives(Vue.createVNode("div", {
+        "ref": root,
+        "style": style,
+        "class": [bem(), props2.className]
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]), [[Vue.vShow, props2.show]]);
+    });
+    index_esm.useEventListener("touchmove", onTouchMove, {
+      target: root
+    });
+    return () => {
+      const Content = Vue.createVNode(Vue.Transition, {
+        "name": "van-fade",
+        "appear": true
+      }, {
+        default: renderOverlay
+      });
+      if (props2.teleport) {
+        return Vue.createVNode(Vue.Teleport, {
+          "to": props2.teleport
+        }, {
+          default: () => [Content]
+        });
+      }
+      return Content;
+    };
+  }
+});
+exports.default = stdin_default;
+exports.overlayProps = overlayProps;

package/lib/node_modules/vant/es/overlay/index.js

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

package/lib/node_modules/vant/es/pagination/Pagination.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const format = require("../utils/format.js");
+const constant = require("../utils/constant.js");
+const [name, bem, t] = create.createNamespace("pagination");
+const makePage = (number, text, active) => ({
+  number,
+  text,
+  active
+});
+const paginationProps = {
+  mode: props.makeStringProp("multi"),
+  prevText: String,
+  nextText: String,
+  pageCount: props.makeNumericProp(0),
+  modelValue: props.makeNumberProp(0),
+  totalItems: props.makeNumericProp(0),
+  showPageSize: props.makeNumericProp(5),
+  itemsPerPage: props.makeNumericProp(10),
+  forceEllipses: Boolean,
+  showPrevButton: props.truthProp,
+  showNextButton: props.truthProp
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: paginationProps,
+  emits: ["change", "update:modelValue"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const count = Vue.computed(() => {
+      const {
+        pageCount,
+        totalItems,
+        itemsPerPage
+      } = props2;
+      const count2 = +pageCount || Math.ceil(+totalItems / +itemsPerPage);
+      return Math.max(1, count2);
+    });
+    const pages = Vue.computed(() => {
+      const items = [];
+      const pageCount = count.value;
+      const showPageSize = +props2.showPageSize;
+      const {
+        modelValue,
+        forceEllipses
+      } = props2;
+      let startPage = 1;
+      let endPage = pageCount;
+      const isMaxSized = showPageSize < pageCount;
+      if (isMaxSized) {
+        startPage = Math.max(modelValue - Math.floor(showPageSize / 2), 1);
+        endPage = startPage + showPageSize - 1;
+        if (endPage > pageCount) {
+          endPage = pageCount;
+          startPage = endPage - showPageSize + 1;
+        }
+      }
+      for (let number = startPage; number <= endPage; number++) {
+        const page = makePage(number, number, number === modelValue);
+        items.push(page);
+      }
+      if (isMaxSized && showPageSize > 0 && forceEllipses) {
+        if (startPage > 1) {
+          const prevPages = makePage(startPage - 1, "...");
+          items.unshift(prevPages);
+        }
+        if (endPage < pageCount) {
+          const nextPages = makePage(endPage + 1, "...");
+          items.push(nextPages);
+        }
+      }
+      return items;
+    });
+    const updateModelValue = (value, emitChange) => {
+      value = format.clamp(value, 1, count.value);
+      if (props2.modelValue !== value) {
+        emit("update:modelValue", value);
+        if (emitChange) {
+          emit("change", value);
+        }
+      }
+    };
+    Vue.watchEffect(() => updateModelValue(props2.modelValue));
+    const renderDesc = () => Vue.createVNode("li", {
+      "class": bem("page-desc")
+    }, [slots.pageDesc ? slots.pageDesc() : `${props2.modelValue}/${count.value}`]);
+    const renderPrevButton = () => {
+      const {
+        mode,
+        modelValue,
+        showPrevButton
+      } = props2;
+      if (!showPrevButton) {
+        return;
+      }
+      const slot = slots["prev-text"];
+      const disabled = modelValue === 1;
+      return Vue.createVNode("li", {
+        "class": [bem("item", {
+          disabled,
+          border: mode === "simple",
+          prev: true
+        }), constant.BORDER_SURROUND]
+      }, [Vue.createVNode("button", {
+        "type": "button",
+        "disabled": disabled,
+        "onClick": () => updateModelValue(modelValue - 1, true)
+      }, [slot ? slot() : props2.prevText || t("prev")])]);
+    };
+    const renderNextButton = () => {
+      const {
+        mode,
+        modelValue,
+        showNextButton
+      } = props2;
+      if (!showNextButton) {
+        return;
+      }
+      const slot = slots["next-text"];
+      const disabled = modelValue === count.value;
+      return Vue.createVNode("li", {
+        "class": [bem("item", {
+          disabled,
+          border: mode === "simple",
+          next: true
+        }), constant.BORDER_SURROUND]
+      }, [Vue.createVNode("button", {
+        "type": "button",
+        "disabled": disabled,
+        "onClick": () => updateModelValue(modelValue + 1, true)
+      }, [slot ? slot() : props2.nextText || t("next")])]);
+    };
+    const renderPages = () => pages.value.map((page) => Vue.createVNode("li", {
+      "class": [bem("item", {
+        active: page.active,
+        page: true
+      }), constant.BORDER_SURROUND]
+    }, [Vue.createVNode("button", {
+      "type": "button",
+      "aria-current": page.active || void 0,
+      "onClick": () => updateModelValue(page.number, true)
+    }, [slots.page ? slots.page(page) : page.text])]));
+    return () => Vue.createVNode("nav", {
+      "role": "navigation",
+      "class": bem()
+    }, [Vue.createVNode("ul", {
+      "class": bem("items")
+    }, [renderPrevButton(), props2.mode === "simple" ? renderDesc() : renderPages(), renderNextButton()])]);
+  }
+});
+exports.default = stdin_default;
+exports.paginationProps = paginationProps;

package/lib/node_modules/vant/es/pagination/index.js

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

package/lib/node_modules/vant/es/password-input/PasswordInput.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const constant = require("../utils/constant.js");
+const format = require("../utils/format.js");
+const [name, bem] = create.createNamespace("password-input");
+const passwordInputProps = {
+  info: String,
+  mask: props.truthProp,
+  value: props.makeStringProp(""),
+  gutter: props.numericProp,
+  length: props.makeNumericProp(6),
+  focused: Boolean,
+  errorInfo: String
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: passwordInputProps,
+  emits: ["focus"],
+  setup(props2, {
+    emit
+  }) {
+    const onTouchStart = (event) => {
+      event.stopPropagation();
+      emit("focus", event);
+    };
+    const renderPoints = () => {
+      const Points = [];
+      const {
+        mask,
+        value,
+        gutter,
+        focused
+      } = props2;
+      const length = +props2.length;
+      for (let i = 0; i < length; i++) {
+        const char = value[i];
+        const showBorder = i !== 0 && !gutter;
+        const showCursor = focused && i === value.length;
+        let style;
+        if (i !== 0 && gutter) {
+          style = {
+            marginLeft: format.addUnit(gutter)
+          };
+        }
+        Points.push(Vue.createVNode("li", {
+          "class": [{
+            [constant.BORDER_LEFT]: showBorder
+          }, bem("item", {
+            focus: showCursor
+          })],
+          "style": style
+        }, [mask ? Vue.createVNode("i", {
+          "style": {
+            visibility: char ? "visible" : "hidden"
+          }
+        }, null) : char, showCursor && Vue.createVNode("div", {
+          "class": bem("cursor")
+        }, null)]));
+      }
+      return Points;
+    };
+    return () => {
+      const info = props2.errorInfo || props2.info;
+      return Vue.createVNode("div", {
+        "class": bem()
+      }, [Vue.createVNode("ul", {
+        "class": [bem("security"), {
+          [constant.BORDER_SURROUND]: !props2.gutter
+        }],
+        "onTouchstartPassive": onTouchStart
+      }, [renderPoints()]), info && Vue.createVNode("div", {
+        "class": bem(props2.errorInfo ? "error-info" : "info")
+      }, [info])]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.passwordInputProps = passwordInputProps;

package/lib/node_modules/vant/es/password-input/index.js

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

package/lib/node_modules/vant/es/picker/Picker.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const utils = require("./utils.js");
+const index_esm = require("../../../@vant/use/dist/index.esm.js");
+const useExpose = require("../composables/use-expose.js");
+const index = require("../loading/index.js");
+const PickerColumn = require("./PickerColumn.js");
+const PickerToolbar = require("./PickerToolbar.js");
+const PickerGroup = require("../picker-group/PickerGroup.js");
+const basic = require("../utils/basic.js");
+const constant = require("../utils/constant.js");
+const props = require("../utils/props.js");
+const format = require("../utils/format.js");
+const dom = require("../utils/dom.js");
+const pickerSharedProps = basic.extend({
+  loading: Boolean,
+  readonly: Boolean,
+  allowHtml: Boolean,
+  optionHeight: props.makeNumericProp(44),
+  showToolbar: props.truthProp,
+  swipeDuration: props.makeNumericProp(1e3),
+  visibleOptionNum: props.makeNumericProp(6)
+}, PickerToolbar.pickerToolbarProps);
+const pickerProps = basic.extend({}, pickerSharedProps, {
+  columns: props.makeArrayProp(),
+  modelValue: props.makeArrayProp(),
+  toolbarPosition: props.makeStringProp("top"),
+  columnsFieldNames: Object
+});
+var stdin_default = Vue.defineComponent({
+  name: utils.name,
+  props: pickerProps,
+  emits: ["confirm", "cancel", "change", "scrollInto", "clickOption", "update:modelValue"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const columnsRef = Vue.ref();
+    const selectedValues = Vue.ref(props2.modelValue.slice(0));
+    const {
+      parent
+    } = index_esm.useParent(PickerGroup.PICKER_GROUP_KEY);
+    const {
+      children,
+      linkChildren
+    } = index_esm.useChildren(PickerColumn.PICKER_KEY);
+    linkChildren();
+    const fields = Vue.computed(() => utils.assignDefaultFields(props2.columnsFieldNames));
+    const optionHeight = Vue.computed(() => format.unitToPx(props2.optionHeight));
+    const columnsType = Vue.computed(() => utils.getColumnsType(props2.columns, fields.value));
+    const currentColumns = Vue.computed(() => {
+      const {
+        columns
+      } = props2;
+      switch (columnsType.value) {
+        case "multiple":
+          return columns;
+        case "cascade":
+          return utils.formatCascadeColumns(columns, fields.value, selectedValues);
+        default:
+          return [columns];
+      }
+    });
+    const hasOptions = Vue.computed(() => currentColumns.value.some((options) => options.length));
+    const selectedOptions = Vue.computed(() => currentColumns.value.map((options, index2) => utils.findOptionByValue(options, selectedValues.value[index2], fields.value)));
+    const selectedIndexes = Vue.computed(() => currentColumns.value.map((options, index2) => options.findIndex((option) => option[fields.value.value] === selectedValues.value[index2])));
+    const setValue = (index2, value) => {
+      if (selectedValues.value[index2] !== value) {
+        const newValues = selectedValues.value.slice(0);
+        newValues[index2] = value;
+        selectedValues.value = newValues;
+      }
+    };
+    const getEventParams = () => ({
+      selectedValues: selectedValues.value.slice(0),
+      selectedOptions: selectedOptions.value,
+      selectedIndexes: selectedIndexes.value
+    });
+    const onChange = (value, columnIndex) => {
+      setValue(columnIndex, value);
+      if (columnsType.value === "cascade") {
+        selectedValues.value.forEach((value2, index2) => {
+          const options = currentColumns.value[index2];
+          if (!utils.isOptionExist(options, value2, fields.value)) {
+            setValue(index2, options.length ? options[0][fields.value.value] : void 0);
+          }
+        });
+      }
+      Vue.nextTick(() => {
+        emit("change", basic.extend({
+          columnIndex
+        }, getEventParams()));
+      });
+    };
+    const onClickOption = (currentOption, columnIndex) => {
+      const params = {
+        columnIndex,
+        currentOption
+      };
+      emit("clickOption", basic.extend(getEventParams(), params));
+      emit("scrollInto", params);
+    };
+    const confirm = () => {
+      children.forEach((child) => child.stopMomentum());
+      const params = getEventParams();
+      Vue.nextTick(() => {
+        emit("confirm", params);
+      });
+      return params;
+    };
+    const cancel = () => emit("cancel", getEventParams());
+    const renderColumnItems = () => currentColumns.value.map((options, columnIndex) => Vue.createVNode(PickerColumn.default, {
+      "value": selectedValues.value[columnIndex],
+      "fields": fields.value,
+      "options": options,
+      "readonly": props2.readonly,
+      "allowHtml": props2.allowHtml,
+      "optionHeight": optionHeight.value,
+      "swipeDuration": props2.swipeDuration,
+      "visibleOptionNum": props2.visibleOptionNum,
+      "onChange": (value) => onChange(value, columnIndex),
+      "onClickOption": (option) => onClickOption(option, columnIndex),
+      "onScrollInto": (option) => {
+        emit("scrollInto", {
+          currentOption: option,
+          columnIndex
+        });
+      }
+    }, {
+      option: slots.option
+    }));
+    const renderMask = (wrapHeight) => {
+      if (hasOptions.value) {
+        const frameStyle = {
+          height: `${optionHeight.value}px`
+        };
+        const maskStyle = {
+          backgroundSize: `100% ${(wrapHeight - optionHeight.value) / 2}px`
+        };
+        return [Vue.createVNode("div", {
+          "class": utils.bem("mask"),
+          "style": maskStyle
+        }, null), Vue.createVNode("div", {
+          "class": [constant.BORDER_UNSET_TOP_BOTTOM, utils.bem("frame")],
+          "style": frameStyle
+        }, null)];
+      }
+    };
+    const renderColumns = () => {
+      const wrapHeight = optionHeight.value * +props2.visibleOptionNum;
+      const columnsStyle = {
+        height: `${wrapHeight}px`
+      };
+      if (!props2.loading && !hasOptions.value && slots.empty) {
+        return slots.empty();
+      }
+      return Vue.createVNode("div", {
+        "ref": columnsRef,
+        "class": utils.bem("columns"),
+        "style": columnsStyle
+      }, [renderColumnItems(), renderMask(wrapHeight)]);
+    };
+    const renderToolbar = () => {
+      if (props2.showToolbar && !parent) {
+        return Vue.createVNode(PickerToolbar.default, Vue.mergeProps(basic.pick(props2, PickerToolbar.pickerToolbarPropKeys), {
+          "onConfirm": confirm,
+          "onCancel": cancel
+        }), basic.pick(slots, PickerToolbar.pickerToolbarSlots));
+      }
+    };
+    Vue.watch(currentColumns, (columns) => {
+      columns.forEach((options, index2) => {
+        if (options.length && !utils.isOptionExist(options, selectedValues.value[index2], fields.value)) {
+          setValue(index2, utils.getFirstEnabledOption(options)[fields.value.value]);
+        }
+      });
+    }, {
+      immediate: true
+    });
+    let lastEmittedModelValue;
+    Vue.watch(() => props2.modelValue, (newValues) => {
+      if (!basic.isSameValue(newValues, selectedValues.value) && !basic.isSameValue(newValues, lastEmittedModelValue)) {
+        selectedValues.value = newValues.slice(0);
+        lastEmittedModelValue = newValues.slice(0);
+      }
+    }, {
+      deep: true
+    });
+    Vue.watch(selectedValues, (newValues) => {
+      if (!basic.isSameValue(newValues, props2.modelValue)) {
+        lastEmittedModelValue = newValues.slice(0);
+        emit("update:modelValue", lastEmittedModelValue);
+      }
+    }, {
+      immediate: true
+    });
+    index_esm.useEventListener("touchmove", dom.preventDefault, {
+      target: columnsRef
+    });
+    const getSelectedOptions = () => selectedOptions.value;
+    useExpose.useExpose({
+      confirm,
+      getSelectedOptions
+    });
+    return () => {
+      var _a, _b;
+      return Vue.createVNode("div", {
+        "class": utils.bem()
+      }, [props2.toolbarPosition === "top" ? renderToolbar() : null, props2.loading ? Vue.createVNode(index.Loading, {
+        "class": utils.bem("loading")
+      }, null) : null, (_a = slots["columns-top"]) == null ? void 0 : _a.call(slots), renderColumns(), (_b = slots["columns-bottom"]) == null ? void 0 : _b.call(slots), props2.toolbarPosition === "bottom" ? renderToolbar() : null]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.pickerProps = pickerProps;
+exports.pickerSharedProps = pickerSharedProps;