cosey 0.9.5 → 0.10.1

package/components/editor/components/color-picker/color-picker.vue.js

@@ -1,181 +0,0 @@
-import { defineComponent, computed, ref, createBlock, openBlock, unref, withCtx, renderSlot, createElementVNode, normalizeClass, toDisplayString, createElementBlock, Fragment, renderList, normalizeStyle, createCommentVNode, createVNode } from 'vue';
-import stdin_default$2 from '../picker/picker.vue.js';
-import stdin_default$1 from './color-picker.style.js';
-import { colorNames, colorPalettes } from './color-picker.js';
-import { Icon as _Icon } from '../../../icon/index.js';
-import { ElInput } from 'element-plus';
-import { TinyColor } from '@ctrl/tinycolor';
-import { useHistoryColor } from './useHistoryColor.js';
-import { useComponentConfig } from '../../../config-provider/config-provider.api.js';
-import { useLocale } from '../../../../hooks/useLocale.js';
-
-const _hoisted_1 = ["onClick"];
-const _hoisted_2 = ["onClick"];
-var stdin_default = /* @__PURE__ */defineComponent({
-  __name: "color-picker",
-  props: {
-    visible: {
-      type: Boolean,
-      required: false
-    }
-  },
-  emits: ["update:visible", "select", "clear"],
-  setup(__props, {
-    emit: __emit
-  }) {
-    const props = __props;
-    const emit = __emit;
-    const {
-      prefixCls
-    } = useComponentConfig("editor-color-picker");
-    const {
-      hashId
-    } = stdin_default$1(prefixCls);
-    const {
-      t
-    } = useLocale();
-    const innerVisible = computed({
-      get() {
-        return props.visible;
-      },
-      set(visible) {
-        emit("update:visible", visible);
-      }
-    });
-    const inputColor = ref("");
-    const {
-      historyColors,
-      pushHistory
-    } = useHistoryColor();
-    const mapHistoryColors = computed(() => {
-      return Array(colorNames.length).fill(0).map((_, i) => {
-        return historyColors.value[i] || "";
-      });
-    });
-    const normalInputColor = computed(() => new TinyColor(inputColor.value).toHexString());
-    const isEyeDropperSupported = computed(() => typeof window.EyeDropper === "function");
-    const select = color => {
-      pushHistory(color);
-      emit("select", color);
-      emit("update:visible", false);
-    };
-    const onSelect = color => {
-      if (color) {
-        select(color);
-      }
-    };
-    const onCustomSelect = () => {
-      select(normalInputColor.value);
-    };
-    const onClear = () => {
-      emit("clear");
-      emit("update:visible", false);
-    };
-    const onAbsorb = () => {
-      const eyeDropper = new window.EyeDropper();
-      eyeDropper.open().then(result => {
-        inputColor.value = result.sRGBHex;
-      });
-    };
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(stdin_default$2, {
-        "popper-class": [unref(hashId), unref(prefixCls)],
-        visible: innerVisible.value,
-        "onUpdate:visible": _cache[1] || (_cache[1] = $event => innerVisible.value = $event)
-      }, {
-        content: withCtx(() => [createElementVNode("div", {
-          class: normalizeClass(`${unref(prefixCls)}-title`)
-        }, toDisplayString(unref(t)("co.colorPicker.preset")), 3
-        /* TEXT, CLASS */), createElementVNode("div", {
-          class: normalizeClass(`${unref(prefixCls)}-preset`)
-        }, [(openBlock(true), createElementBlock(Fragment, null, renderList(unref(colorPalettes), (row, i) => {
-          return openBlock(), createElementBlock("div", {
-            key: i,
-            class: normalizeClass(`${unref(prefixCls)}-row`)
-          }, [(openBlock(true), createElementBlock(Fragment, null, renderList(row, (color, j) => {
-            return openBlock(), createElementBlock("div", {
-              key: j,
-              class: normalizeClass(`${unref(prefixCls)}-item`)
-            }, [createElementVNode("button", {
-              type: "button",
-              class: normalizeClass([`${unref(prefixCls)}-color`, `${unref(prefixCls)}-btn`]),
-              style: normalizeStyle({
-                background: color
-              }),
-              onClick: $event => onSelect(color)
-            }, null, 14, _hoisted_1)], 2
-            /* CLASS */);
-          }), 128
-          /* KEYED_FRAGMENT */))], 2
-          /* CLASS */);
-        }), 128
-        /* KEYED_FRAGMENT */))], 2
-        /* CLASS */), createElementVNode("div", {
-          class: normalizeClass(`${unref(prefixCls)}-title`)
-        }, toDisplayString(unref(t)("co.colorPicker.recents")), 3
-        /* TEXT, CLASS */), createElementVNode("div", {
-          class: normalizeClass(`${unref(prefixCls)}-row`)
-        }, [(openBlock(true), createElementBlock(Fragment, null, renderList(mapHistoryColors.value, (color, i) => {
-          return openBlock(), createElementBlock("div", {
-            key: i,
-            class: normalizeClass(`${unref(prefixCls)}-item`)
-          }, [createElementVNode("button", {
-            type: "button",
-            class: normalizeClass([`${unref(prefixCls)}-color`, `${unref(prefixCls)}-btn`, {
-              "is-empty": !color
-            }]),
-            style: normalizeStyle({
-              background: color
-            }),
-            onClick: $event => onSelect(color)
-          }, null, 14, _hoisted_2)], 2
-          /* CLASS */);
-        }), 128
-        /* KEYED_FRAGMENT */))], 2
-        /* CLASS */), createElementVNode("div", {
-          class: normalizeClass(`${unref(prefixCls)}-title`)
-        }, toDisplayString(unref(t)("co.colorPicker.manual")), 3
-        /* TEXT, CLASS */), createElementVNode("div", {
-          class: normalizeClass(`${unref(prefixCls)}-manual`)
-        }, [isEyeDropperSupported.value ? (openBlock(), createElementBlock("button", {
-          key: 0,
-          type: "button",
-          class: normalizeClass([`${unref(prefixCls)}-btn`]),
-          onClick: onAbsorb
-        }, [createVNode(unref(_Icon), {
-          name: "co:eyedropper",
-          size: "lg"
-        })], 2
-        /* CLASS */)) : createCommentVNode("v-if", true), createVNode(unref(ElInput), {
-          modelValue: inputColor.value,
-          "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => inputColor.value = $event),
-          size: "small",
-          placeholder: unref(t)("co.common.pleaseInput"),
-          class: normalizeClass([`${unref(prefixCls)}-input`])
-        }, null, 8, ["modelValue", "placeholder", "class"]), createElementVNode("button", {
-          type: "button",
-          class: normalizeClass([`${unref(prefixCls)}-color`, `${unref(prefixCls)}-btn`]),
-          style: normalizeStyle({
-            backgroundColor: normalInputColor.value
-          }),
-          onClick: onCustomSelect
-        }, null, 6
-        /* CLASS, STYLE */), createElementVNode("button", {
-          type: "button",
-          class: normalizeClass([`${unref(prefixCls)}-color`, `${unref(prefixCls)}-btn`, `${unref(prefixCls)}-clear`]),
-          onClick: onClear
-        }, [createVNode(unref(_Icon), {
-          name: "co:slash-forward",
-          size: "lg"
-        })], 2
-        /* CLASS */)], 2
-        /* CLASS */)]),
-        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
-        _: 3
-        /* FORWARDED */
-      }, 8, ["popper-class", "visible"]);
-    };
-  }
-});
-
-export { stdin_default as default };

package/components/editor/components/list/list.d.ts

@@ -1,6 +0,0 @@
-import type { CSSProperties } from 'vue';
-export interface ListItem {
-    label: string;
-    value: any;
-    style?: CSSProperties;
-}

package/components/editor/components/list/list.vue.d.ts

@@ -1,11 +0,0 @@
-import { ListItem } from './list';
-type __VLS_Props = {
-    selectedValue?: any;
-    list: ListItem[];
-};
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    select: (item: ListItem) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onSelect?: ((item: ListItem) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;

package/components/editor/components/list/list.vue.js

@@ -1,51 +0,0 @@
-import { defineComponent, createElementBlock, openBlock, normalizeClass, unref, Fragment, renderList, normalizeStyle, toDisplayString } from 'vue';
-import stdin_default$1 from './list.style.js';
-import { useComponentConfig } from '../../../config-provider/config-provider.api.js';
-
-const _hoisted_1 = ["onClick"];
-var stdin_default = /* @__PURE__ */defineComponent({
-  __name: "list",
-  props: {
-    selectedValue: {
-      type: null,
-      required: false
-    },
-    list: {
-      type: Array,
-      required: true
-    }
-  },
-  emits: ["select"],
-  setup(__props, {
-    emit: __emit
-  }) {
-    const emit = __emit;
-    const {
-      prefixCls
-    } = useComponentConfig("editor-list");
-    const {
-      hashId
-    } = stdin_default$1(prefixCls);
-    const onSelect = item => {
-      emit("select", item);
-    };
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([unref(hashId), unref(prefixCls)])
-      }, [(openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.list, item => {
-        return openBlock(), createElementBlock("div", {
-          key: item.value,
-          class: normalizeClass([`${unref(prefixCls)}-item`, {
-            "is-active": _ctx.selectedValue === item.value
-          }]),
-          style: normalizeStyle(item.style),
-          onClick: $event => onSelect(item)
-        }, toDisplayString(item.label), 15, _hoisted_1);
-      }), 128
-      /* KEYED_FRAGMENT */))], 2
-      /* CLASS */);
-    };
-  }
-});
-
-export { stdin_default as default };

package/components/editor/components/picker/picker.vue.d.ts

@@ -1,25 +0,0 @@
-type __VLS_Props = {
-    popperClass?: any;
-    visible?: boolean;
-    maxHeight?: string;
-    triggerTarget?: HTMLElement | null;
-    nopadding?: boolean;
-};
-declare var __VLS_6: {}, __VLS_8: {};
-type __VLS_Slots = {} & {
-    content?: (props: typeof __VLS_6) => any;
-} & {
-    default?: (props: typeof __VLS_8) => any;
-};
-declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    "update:visible": (visible: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/components/editor/components/picker/picker.vue.js

@@ -1,95 +0,0 @@
-import { defineComponent, useTemplateRef, ref, provide, computed, onMounted, onBeforeUnmount, createBlock, openBlock, unref, withCtx, renderSlot, createElementVNode, normalizeStyle, normalizeClass } from 'vue';
-import { ElTooltip } from 'element-plus';
-import stdin_default$1 from './picker.style.js';
-import { pickerContextKey } from './picker.js';
-import { useComponentConfig } from '../../../config-provider/config-provider.api.js';
-
-var stdin_default = /* @__PURE__ */defineComponent({
-  __name: "picker",
-  props: {
-    popperClass: {
-      type: null,
-      required: false
-    },
-    visible: {
-      type: Boolean,
-      required: false
-    },
-    maxHeight: {
-      type: String,
-      required: false
-    },
-    triggerTarget: {
-      type: null,
-      required: false
-    },
-    nopadding: {
-      type: Boolean,
-      required: false
-    }
-  },
-  emits: ["update:visible"],
-  setup(__props, {
-    emit: __emit
-  }) {
-    const props = __props;
-    const emit = __emit;
-    const {
-      prefixCls
-    } = useComponentConfig("editor-picker");
-    const {
-      hashId
-    } = stdin_default$1(prefixCls);
-    const contentRef = useTemplateRef("content");
-    const contextTriggerTarget = ref();
-    provide(pickerContextKey, {
-      triggerTarget: contextTriggerTarget
-    });
-    const mergedTriggerTarget = computed(() => {
-      return props.triggerTarget || contextTriggerTarget.value;
-    });
-    const onDocClick = event => {
-      const target = event.target;
-      if (!props.visible || mergedTriggerTarget.value && mergedTriggerTarget.value.contains(target) || contentRef.value?.contains(target)) {
-        return;
-      }
-      emit("update:visible", false);
-    };
-    onMounted(() => {
-      document.addEventListener("click", onDocClick, false);
-    });
-    onBeforeUnmount(() => {
-      document.removeEventListener("click", onDocClick, false);
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(unref(ElTooltip), {
-        visible: _ctx.visible,
-        "show-arrow": false,
-        placement: "bottom-start",
-        offset: 0,
-        "gpu-acceleration": false,
-        "popper-class": [unref(hashId), _ctx.popperClass, `${unref(prefixCls)}-panel`],
-        "stop-popper-mouse-event": false,
-        effect: "light",
-        trigger: "click",
-        persistent: ""
-      }, {
-        content: withCtx(() => [createElementVNode("div", {
-          ref: "content",
-          class: normalizeClass([`${unref(prefixCls)}-content`, {
-            "is-nopadding": _ctx.nopadding
-          }]),
-          style: normalizeStyle({
-            maxHeight: _ctx.maxHeight
-          })
-        }, [renderSlot(_ctx.$slots, "content")], 6
-        /* CLASS, STYLE */)]),
-        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
-        _: 3
-        /* FORWARDED */
-      }, 8, ["visible", "popper-class"]);
-    };
-  }
-});
-
-export { stdin_default as default };

package/components/editor/components/resize/resize.d.ts

@@ -1,23 +0,0 @@
-export interface Rect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-export type ResizePosition = 'nw' | 'ne' | 'sw' | 'se';
-export type ResizeAlign = 'left' | 'center' | 'right';
-export declare const mapIcons: {
-    left: string;
-    center: string;
-    right: string;
-};
-export declare const getAlign: (el?: HTMLElement) => ResizeAlign | null;
-export declare const onDrag: (downRect: Rect, currRect: Rect, options: {
-    position: ResizePosition;
-    x: number;
-    y: number;
-    min: number;
-    max: number;
-    cb: (rect: Rect) => void;
-}) => void;
-export declare const setAlignStyle: (el: HTMLElement, align: ResizeAlign | null) => void;

package/components/editor/components/resize/resize.js

@@ -1,88 +0,0 @@
-const mapIcons = {
-  left: "co:text-align-left",
-  center: "co:text-align-center",
-  right: "co:text-align-right"
-};
-const getAlign = (el) => {
-  if (!el) {
-    return null;
-  }
-  const style = el.style;
-  if (style.float === "left") {
-    return "left";
-  }
-  if (style.float === "right") {
-    return "right";
-  }
-  if (style.marginInlineStart === "auto" && style.marginInlineEnd === "auto" && style.display === "block") {
-    return "center";
-  }
-  return null;
-};
-const onDrag = (downRect, currRect, options) => {
-  const { x, y } = currRect;
-  const aspectScale = downRect.width / downRect.height;
-  let width = 0;
-  switch (options.position) {
-    case "nw":
-    case "sw":
-      width = downRect.x + downRect.width - options.x;
-      break;
-    case "ne":
-    case "se":
-      width = options.x - downRect.x;
-      break;
-  }
-  if (width < options.min) {
-    width = options.min;
-  } else if (width > options.max) {
-    width = options.max;
-  }
-  const height = width / aspectScale;
-  options.cb({
-    x,
-    y,
-    width,
-    height
-  });
-};
-const setAlignStyle = (el, align) => {
-  let style;
-  switch (align) {
-    case null:
-      style = {
-        display: "",
-        float: "",
-        marginInlineStart: "",
-        marginInlineEnd: ""
-      };
-      break;
-    case "left":
-      style = {
-        display: "",
-        float: "left",
-        marginInlineStart: "",
-        marginInlineEnd: ""
-      };
-      break;
-    case "center":
-      style = {
-        display: "block",
-        float: "",
-        marginInlineStart: "auto",
-        marginInlineEnd: "auto"
-      };
-      break;
-    case "right":
-      style = {
-        display: "",
-        float: "right",
-        marginInlineStart: "",
-        marginInlineEnd: ""
-      };
-      break;
-  }
-  Object.assign(el.style, style);
-};
-
-export { getAlign, mapIcons, onDrag, setAlignStyle };

package/components/editor/components/resize/resize.vue.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export default _default;

package/components/editor/components/resize/resize.vue.js

@@ -1,204 +0,0 @@
-import { defineComponent, useTemplateRef, inject, ref, shallowRef, watch, onMounted, onBeforeUnmount, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref, createElementVNode, Fragment, renderList, createVNode, withCtx, toDisplayString } from 'vue';
-import Quill from 'quill';
-import stdin_default$1 from './resize.style.js';
-import { getAlign, mapIcons, onDrag, setAlignStyle } from './resize.js';
-import { Icon as _Icon } from '../../../icon/index.js';
-import stdin_default$3 from '../button.vue.js';
-import stdin_default$2 from '../button-group.vue.js';
-import { editorContextKey } from '../../quillContext.js';
-import { useRectObserver } from '../../../../hooks/useRectObserver.js';
-import { useComponentConfig } from '../../../config-provider/config-provider.api.js';
-
-const _hoisted_1 = ["onPointerdown", "onPointermove", "onPointerup", "onPointercancel"];
-var stdin_default = /* @__PURE__ */defineComponent({
-  __name: "resize",
-  setup(__props) {
-    const {
-      prefixCls
-    } = useComponentConfig("editor-resize");
-    const {
-      hashId
-    } = stdin_default$1(prefixCls);
-    const overlayEl = useTemplateRef("overlay");
-    const {
-      quill
-    } = inject(editorContextKey);
-    const visible = ref(false);
-    const target = shallowRef(null);
-    const currentAlign = ref(null);
-    const corners = ["nw", "ne", "sw", "se"];
-    const aligns = ["left", "center", "right"];
-    const downs = {};
-    let downRect = null;
-    const displaySize = ref("");
-    const isOutSize = ref(false);
-    const overlayStyle = ref();
-    const setOverlayRect = rect => {
-      const parent = overlayEl.value?.offsetParent;
-      if (parent) {
-        const parentRect = parent.getBoundingClientRect();
-        const width = ~~rect.width;
-        const height = ~~rect.height;
-        overlayStyle.value = {
-          insetInlineStart: ~~(rect.x - parentRect.x) + "px",
-          insetBlockStart: ~~(rect.y - parentRect.y) + "px",
-          width: width + "px",
-          height: height + "px"
-        };
-        displaySize.value = `${width} x ${height}`;
-        isOutSize.value = width < 64;
-      }
-    };
-    useRectObserver(target, rect => {
-      setOverlayRect(rect);
-    });
-    const onPointerDown = (corner, event) => {
-      downs[corner] = true;
-      const el = event.currentTarget;
-      el.setPointerCapture(event.pointerId);
-      downRect = target.value.getBoundingClientRect();
-    };
-    const onPointerMove = (corner, event) => {
-      if (downs[corner]) {
-        const rect = target.value.getBoundingClientRect();
-        onDrag(downRect, rect, {
-          position: corner,
-          x: event.clientX,
-          y: event.clientY,
-          min: 16,
-          max: Infinity,
-          cb: rect2 => {
-            target.value.setAttribute("width", `${~~rect2.width}`);
-            target.value.setAttribute("height", `${~~rect2.height}`);
-          }
-        });
-      }
-    };
-    const onPointerUp = corner => {
-      downs[corner] = false;
-    };
-    const onAlignClick = align => {
-      if (align === currentAlign.value) {
-        currentAlign.value = null;
-      } else {
-        currentAlign.value = align;
-      }
-      setAlignStyle(target.value, currentAlign.value);
-    };
-    watch(() => target.value, () => {
-      if (target.value) {
-        currentAlign.value = getAlign(target.value);
-      }
-    });
-    const show = el => {
-      target.value = el;
-      const blot = Quill.find(el);
-      const index = quill.value.getIndex(blot);
-      quill.value.setSelection(index + 1);
-      quill.value.setSelection(null);
-      visible.value = true;
-    };
-    const hide = () => {
-      if (visible.value) {
-        target.value = null;
-        visible.value = false;
-      }
-    };
-    const onDocMouseDown = event => {
-      const el = event.target;
-      if (target.value && (el === target.value || overlayEl.value.contains(el))) {
-        return;
-      }
-      if (["img", "video"].includes(el.tagName.toLowerCase()) && quill.value.container.contains(el)) {
-        if (target.value) {
-          hide();
-        }
-        show(el);
-        return;
-      }
-      hide();
-    };
-    const onDocKeyDown = event => {
-      if (!target.value) {
-        return;
-      }
-      event.preventDefault();
-      const blot = Quill.find(target.value);
-      let index = quill.value.getIndex(blot);
-      switch (event.key) {
-        case "ArrowLeft":
-        case "ArrowUp":
-          break;
-        case "ArrowRight":
-        case "ArrowDown":
-          index += 1;
-          break;
-        case "Backspace":
-        case "Delete":
-          quill.value.deleteText(index, 1);
-          break;
-        default:
-          return;
-      }
-      hide();
-      setTimeout(() => {
-        quill.value.setSelection(index);
-      });
-    };
-    onMounted(() => {
-      document.addEventListener("mousedown", onDocMouseDown, false);
-      document.addEventListener("keydown", onDocKeyDown, false);
-    });
-    onBeforeUnmount(() => {
-      document.removeEventListener("mousedown", onDocMouseDown, false);
-      document.removeEventListener("keydown", onDocKeyDown, false);
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        ref: "overlay",
-        class: normalizeClass([unref(hashId), unref(prefixCls), {
-          "is-show": visible.value
-        }]),
-        style: normalizeStyle(overlayStyle.value)
-      }, [(openBlock(), createElementBlock(Fragment, null, renderList(corners, corner => {
-        return createElementVNode("div", {
-          key: corner,
-          class: normalizeClass([`${unref(prefixCls)}-corner`, `${unref(prefixCls)}-corner-${corner}`]),
-          onPointerdown: $event => onPointerDown(corner, $event),
-          onPointermove: $event => onPointerMove(corner, $event),
-          onPointerup: $event => onPointerUp(corner),
-          onPointercancel: $event => onPointerUp(corner)
-        }, null, 42, _hoisted_1);
-      }), 64
-      /* STABLE_FRAGMENT */)), createElementVNode("div", {
-        class: normalizeClass(`${unref(prefixCls)}-align`)
-      }, [createVNode(stdin_default$2, null, {
-        default: withCtx(() => [(openBlock(), createElementBlock(Fragment, null, renderList(aligns, align => {
-          return createVNode(stdin_default$3, {
-            key: align,
-            active: align === currentAlign.value,
-            onClick: $event => onAlignClick(align)
-          }, {
-            default: withCtx(() => [createVNode(unref(_Icon), {
-              name: unref(mapIcons)[align]
-            }, null, 8, ["name"])]),
-            _: 2
-            /* DYNAMIC */
-          }, 1032, ["active", "onClick"]);
-        }), 64
-        /* STABLE_FRAGMENT */))]),
-        _: 1
-        /* STABLE */
-      })], 2
-      /* CLASS */), createElementVNode("div", {
-        class: normalizeClass([`${unref(prefixCls)}-size`, {
-          "is-outside": isOutSize.value
-        }])
-      }, toDisplayString(displaySize.value), 3
-      /* TEXT, CLASS */)], 6
-      /* CLASS, STYLE */);
-    };
-  }
-});
-
-export { stdin_default as default };