@voicenter-team/voicenter-ui-plus 2.0.12 → 3.0.0

package/library/components/VcMdEditor/mdEditor.config.mjs

@@ -0,0 +1,378 @@
+import { computed } from "vue";
+import { tVU } from "../../localization/index.mjs";
+import { Plugin, PluginKey, TextSelection } from "@milkdown/kit/prose/state";
+import { findWrapping } from "@milkdown/kit/prose/transform";
+import { editorViewCtx } from "@milkdown/kit/core";
+import { codeBlockSchema, listItemSchema, orderedListSchema, bulletListSchema, hrSchema, blockquoteSchema, paragraphSchema, headingSchema } from "@milkdown/kit/preset/commonmark";
+import { imageBlockSchema } from "@milkdown/kit/component/image-block";
+import { createTable } from "@milkdown/kit/preset/gfm";
+import { $prose } from "@milkdown/utils";
+import { DecorationSet, Decoration } from "@milkdown/kit/prose/view";
+import ParameterNode from "./ParameterNode.vue.mjs";
+import { Heading1, Heading2, Heading3, Heading4, Heading5, Heading6, ReceiptText, Quote, Minus, List, ListOrdered, ListChecks, Image, Code, Table, SquareFunction, ListStart, ListEnd, Braces, Brackets } from "@lucide/vue";
+const NodeParameterHiddenClass = "hidden-parameter-text";
+const NodeParameterClasses = {
+  simple: "parameter-simple",
+  single: "parameter-block-single",
+  array: "parameter-array-block",
+  object: "parameter-block-with-fields"
+};
+const NodeParameterIcons = {
+  "parameter-simple": "",
+  "parameter-block-single-start": ListStart,
+  "parameter-block-single-end": ListEnd,
+  "parameter-array-block": Brackets,
+  "parameter-block-with-fields": Braces
+};
+const HEADING_SCHEMA = "headingSchema";
+const PARAGRAPH_SCHEMA = "paragraphSchema";
+const QUOTES_SCHEMA = "blockquoteSchema";
+const DIVIDER_SCHEMA = "hrSchema";
+const LIST_BULLET_SCHEMA = "bulletListSchema";
+const LIST_ORDERED_SCHEMA = "orderedListSchema";
+const LIST_ITEM_SCHEMA = "listItemSchema";
+const IMAGE_SCHEMA = "imageBlockSchema";
+const CODE_BLOCK_SCHEMA = "codeBlockSchema";
+const TABLE_SCHEMA = "tableSchema";
+const SCHEMA_TYPES = {
+  [HEADING_SCHEMA]: headingSchema,
+  [PARAGRAPH_SCHEMA]: paragraphSchema,
+  [QUOTES_SCHEMA]: blockquoteSchema,
+  [DIVIDER_SCHEMA]: hrSchema,
+  [LIST_BULLET_SCHEMA]: bulletListSchema,
+  [LIST_ORDERED_SCHEMA]: orderedListSchema,
+  [LIST_ITEM_SCHEMA]: listItemSchema,
+  [IMAGE_SCHEMA]: imageBlockSchema,
+  [CODE_BLOCK_SCHEMA]: codeBlockSchema,
+  [TABLE_SCHEMA]: null
+};
+const SCHEMA_TYPE_ACTION = {
+  [HEADING_SCHEMA]: setContentBlockType,
+  [PARAGRAPH_SCHEMA]: setContentBlockType,
+  [QUOTES_SCHEMA]: setContentAndWrapInBlockType,
+  [DIVIDER_SCHEMA]: contentAddBlockType,
+  [LIST_BULLET_SCHEMA]: setContentAndWrapInBlockType,
+  [LIST_ORDERED_SCHEMA]: setContentAndWrapInBlockType,
+  [LIST_ITEM_SCHEMA]: setContentAndWrapInBlockType,
+  [IMAGE_SCHEMA]: contentAddBlockType,
+  [CODE_BLOCK_SCHEMA]: contentAddBlockType,
+  [TABLE_SCHEMA]: null
+};
+const headingMenuItems = computed(() => {
+  return [
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.heading1"),
+      icon: Heading1,
+      schemaType: HEADING_SCHEMA,
+      attrs: { level: 1 }
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.heading2"),
+      icon: Heading2,
+      schemaType: HEADING_SCHEMA,
+      attrs: { level: 2 }
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.heading3"),
+      icon: Heading3,
+      schemaType: HEADING_SCHEMA,
+      attrs: { level: 3 }
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.heading4"),
+      icon: Heading4,
+      schemaType: HEADING_SCHEMA,
+      attrs: { level: 4 }
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.heading5"),
+      icon: Heading5,
+      schemaType: HEADING_SCHEMA,
+      attrs: { level: 5 }
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.heading6"),
+      icon: Heading6,
+      schemaType: HEADING_SCHEMA,
+      attrs: { level: 6 }
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.text"),
+      icon: ReceiptText,
+      schemaType: PARAGRAPH_SCHEMA,
+      attrs: null
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.quote"),
+      icon: Quote,
+      schemaType: QUOTES_SCHEMA,
+      attrs: null
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.divider"),
+      icon: Minus,
+      schemaType: DIVIDER_SCHEMA,
+      attrs: null
+    }
+  ];
+});
+const listMenuItems = computed(() => {
+  return [
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.bulletList"),
+      icon: List,
+      schemaType: LIST_BULLET_SCHEMA,
+      attrs: null
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.orderedList"),
+      icon: ListOrdered,
+      schemaType: LIST_ORDERED_SCHEMA,
+      attrs: null
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.todoList"),
+      icon: ListChecks,
+      schemaType: LIST_ITEM_SCHEMA,
+      attrs: { checked: false }
+    }
+  ];
+});
+const advancedMenuItems = computed(() => {
+  return [
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.image"),
+      icon: Image,
+      schemaType: IMAGE_SCHEMA,
+      attrs: null,
+      isAdvanced: true
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.code"),
+      icon: Code,
+      schemaType: CODE_BLOCK_SCHEMA,
+      attrs: null,
+      isAdvanced: true
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.table"),
+      icon: Table,
+      schemaType: TABLE_SCHEMA,
+      attrs: null,
+      isAdvanced: true
+    },
+    {
+      label: tVU.t("voicenterUi.mdEditor.toolbar.math"),
+      icon: SquareFunction,
+      schemaType: CODE_BLOCK_SCHEMA,
+      attrs: { language: "LaTex" },
+      isAdvanced: true
+    }
+  ];
+});
+function dispatchEditorAction(crepeInstance, actionType) {
+  if (!crepeInstance) {
+    return;
+  }
+  crepeInstance.editor.action((ctx) => {
+    const view = ctx.get(editorViewCtx);
+    const { dispatch, state } = view;
+    const schemaType = SCHEMA_TYPES[actionType.schemaType];
+    const commandType = SCHEMA_TYPE_ACTION[actionType.schemaType];
+    if (!schemaType || !commandType) return false;
+    const command = commandType(schemaType.type(ctx), actionType.attrs);
+    command(state, dispatch);
+  });
+}
+function dispatchAdvancedEditorAction(crepeInstance, actionType) {
+  if (!crepeInstance) {
+    return;
+  }
+  if (actionType.schemaType === "tableSchema") {
+    dispatchEditorTableAction(crepeInstance);
+  } else {
+    dispatchEditorAction(crepeInstance, actionType);
+  }
+}
+function dispatchEditorTableAction(crepeInstance) {
+  if (!crepeInstance) {
+    return;
+  }
+  crepeInstance.editor.action((ctx) => {
+    const view = ctx.get(editorViewCtx);
+    const { dispatch, state } = view;
+    let { tr } = state;
+    const from = tr.selection.from;
+    const table = createTable(ctx, 3, 3);
+    tr = tr.replaceSelectionWith(table);
+    dispatch(tr);
+    requestAnimationFrame(() => {
+      const docSize = view.state.doc.content.size;
+      const $pos = view.state.doc.resolve(
+        from > docSize ? docSize : from < 0 ? 0 : from
+      );
+      const selection = TextSelection.near($pos);
+      const tr2 = view.state.tr;
+      tr2.setSelection(selection);
+      dispatch(tr2.scrollIntoView());
+    });
+  });
+}
+function setBlockType(tr, nodeType, attrs = null) {
+  const { from, to } = tr.selection;
+  return tr.setBlockType(from, to, nodeType, attrs);
+}
+function addEditorBlockType(tr, nodeType, attrs = null) {
+  const node = nodeType.createAndFill(attrs);
+  if (!node) return null;
+  return tr.replaceSelectionWith(node);
+}
+function setContentBlockType(nodeType, attrs = null) {
+  return (state, dispatch) => {
+    if (dispatch) {
+      const tr = setBlockType(state.tr, nodeType, attrs);
+      dispatch(tr.scrollIntoView());
+    }
+    return true;
+  };
+}
+function contentAddBlockType(nodeType, attrs = null) {
+  return (state, dispatch) => {
+    const tr = addEditorBlockType(state.tr, nodeType, attrs);
+    if (!tr) return false;
+    if (dispatch) dispatch(tr.scrollIntoView());
+    return true;
+  };
+}
+function wrapInBlockType(tr, nodeType, attrs = null) {
+  const { $from, $to } = tr.selection;
+  const range = $from.blockRange($to);
+  const wrapping = range && findWrapping(range, nodeType, attrs);
+  if (!wrapping) return null;
+  return tr.wrap(range, wrapping);
+}
+function setContentAndWrapInBlockType(nodeType, attrs = null) {
+  return (state, dispatch) => {
+    const tr = wrapInBlockType(state.tr, nodeType, attrs);
+    if (!tr) return false;
+    if (dispatch) dispatch(tr.scrollIntoView());
+    return true;
+  };
+}
+const MUSTACHE_PATTERNS = {
+  ARRAY_BLOCK: /{{#(\w+)}}[^{]*{{\.}}[^{]*{{\/\1}}/g,
+  BLOCK_WITH_FIELDS: /{{#(\w+)}}(?:(?!{{[/#]).)*?:\s*{{.*?}}.*?{{\/\1}}/g,
+  SINGLE_LINE_BLOCK: /^[ \t]*{{[/#](\w+)}}[ \t]*$/gm,
+  SIMPLE_PARAMETER: /{{(\w+)}}/g
+};
+const useMustachePlugin = (replaceTest, widgetViewFactory) => {
+  return $prose(() => {
+    const getParameterWidget = widgetViewFactory({
+      as: "span",
+      component: ParameterNode
+    });
+    const processParameter = (match, pos, processedRanges) => {
+      const start = pos + match.index;
+      const end = start + match[0].length;
+      const isProcessed = processedRanges.some(
+        ([from, to]) => start >= from && start < to || end > from && end <= to
+      );
+      return isProcessed ? null : {
+        fullMatch: match[0],
+        parameterName: match[1],
+        start,
+        end
+      };
+    };
+    const createDecorations = (paramMatch, parameterClass, processedRanges) => {
+      processedRanges.push([paramMatch.start, paramMatch.end]);
+      return [
+        getParameterWidget(paramMatch.start, {
+          parameterName: paramMatch.parameterName,
+          fullString: paramMatch.fullMatch,
+          class: parameterClass,
+          onTest: (snippet) => replaceTest(snippet, paramMatch.start, paramMatch.end)
+        }),
+        Decoration.inline(paramMatch.start, paramMatch.end, {
+          class: NodeParameterHiddenClass
+        })
+      ];
+    };
+    const processText = (text, pos) => {
+      const processedRanges = [];
+      const widgets = [];
+      const parameterConfigs = [
+        {
+          regex: MUSTACHE_PATTERNS.ARRAY_BLOCK,
+          parameterClass: NodeParameterClasses.array
+        },
+        {
+          regex: MUSTACHE_PATTERNS.BLOCK_WITH_FIELDS,
+          parameterClass: NodeParameterClasses.object
+        },
+        {
+          regex: MUSTACHE_PATTERNS.SINGLE_LINE_BLOCK,
+          parameterClass: NodeParameterClasses.single
+        },
+        {
+          regex: MUSTACHE_PATTERNS.SIMPLE_PARAMETER,
+          parameterClass: NodeParameterClasses.simple
+        }
+      ];
+      for (const config of parameterConfigs) {
+        let match;
+        while ((match = config.regex.exec(text)) !== null) {
+          const paramMatch = processParameter(match, pos, processedRanges);
+          if (paramMatch) {
+            widgets.push(...createDecorations(paramMatch, config.parameterClass, processedRanges));
+          }
+        }
+      }
+      return widgets;
+    };
+    return new Plugin({
+      key: new PluginKey("MILKDOWN_PARAMETER_DECORATIONS"),
+      props: {
+        decorations: (state) => {
+          const widgets = [];
+          state.doc.descendants((node, pos) => {
+            if (node.isText) {
+              widgets.push(...processText(node.text || "", pos));
+            }
+          });
+          return DecorationSet.create(state.doc, widgets);
+        }
+      }
+    });
+  });
+};
+export {
+  CODE_BLOCK_SCHEMA,
+  DIVIDER_SCHEMA,
+  HEADING_SCHEMA,
+  IMAGE_SCHEMA,
+  LIST_BULLET_SCHEMA,
+  LIST_ITEM_SCHEMA,
+  LIST_ORDERED_SCHEMA,
+  NodeParameterClasses,
+  NodeParameterHiddenClass,
+  NodeParameterIcons,
+  PARAGRAPH_SCHEMA,
+  QUOTES_SCHEMA,
+  SCHEMA_TYPES,
+  SCHEMA_TYPE_ACTION,
+  TABLE_SCHEMA,
+  addEditorBlockType,
+  advancedMenuItems,
+  contentAddBlockType,
+  dispatchAdvancedEditorAction,
+  dispatchEditorAction,
+  dispatchEditorTableAction,
+  headingMenuItems,
+  listMenuItems,
+  setBlockType,
+  setContentAndWrapInBlockType,
+  setContentBlockType,
+  useMustachePlugin,
+  wrapInBlockType
+};

package/library/components/VcMdEditor/rtlCursorPlugin.mjs

@@ -0,0 +1,125 @@
+import { editorViewCtx } from "@milkdown/kit/core";
+import { TextSelection } from "@milkdown/kit/prose/state";
+const rtlCursorPlugin = (ctx) => {
+  return async () => {
+    let eventHandler = null;
+    const setupRTLCursorFix = () => {
+      const view = ctx.get(editorViewCtx);
+      eventHandler = (event) => {
+        if (!["ArrowLeft", "ArrowRight", "Backspace", "Delete"].includes(event.key)) {
+          return false;
+        }
+        if (event.ctrlKey || event.metaKey || event.altKey || event.shiftKey) {
+          return false;
+        }
+        const isArrowKey = ["ArrowLeft", "ArrowRight"].includes(event.key);
+        const isDeletionKey = ["Backspace", "Delete"].includes(event.key);
+        if (isArrowKey) {
+          const editorElement = view.dom;
+          const computedStyle = window.getComputedStyle(editorElement);
+          const isRTL = computedStyle.direction === "rtl";
+          if (!isRTL) {
+            return false;
+          }
+        }
+        if (isDeletionKey) {
+          const { state: state2 } = view;
+          const { selection: selection2 } = state2;
+          if (!(selection2 instanceof TextSelection)) {
+            return false;
+          }
+          const $pos = selection2.$anchor;
+          const textNode = $pos.parent;
+          const hasHebrewText = /[\u0590-\u05FF]/.test(textNode.textContent || "");
+          if (!hasHebrewText) {
+            return false;
+          }
+        }
+        const { state, dispatch } = view;
+        const { selection } = state;
+        if (!(selection instanceof TextSelection) || !selection.empty) {
+          return false;
+        }
+        const { $cursor } = selection;
+        if (!$cursor) {
+          return false;
+        }
+        try {
+          const doc = state.doc;
+          const pos = $cursor.pos;
+          if (isArrowKey) {
+            const isLeftArrow = event.key === "ArrowLeft";
+            let targetPos;
+            if (isLeftArrow) {
+              targetPos = pos + 1;
+              if (targetPos > doc.content.size) {
+                targetPos = doc.content.size;
+              }
+            } else {
+              targetPos = pos - 1;
+              if (targetPos < 0) {
+                targetPos = 0;
+              }
+            }
+            const resolvedPos = doc.resolve(targetPos);
+            const newSelection = TextSelection.near(resolvedPos, isLeftArrow ? 1 : -1);
+            if (newSelection && !newSelection.eq(selection)) {
+              const tr = state.tr.setSelection(newSelection);
+              dispatch(tr);
+              event.preventDefault();
+              return true;
+            }
+          } else if (isDeletionKey) {
+            const isBackspace = event.key === "Backspace";
+            const $pos = doc.resolve(pos);
+            if (isBackspace && $pos.parentOffset === 0) {
+              return false;
+            }
+            if (!isBackspace && $pos.parentOffset === $pos.parent.content.size) {
+              return false;
+            }
+            if (isBackspace && pos > 0) {
+              const tr = state.tr.delete(pos - 1, pos);
+              dispatch(tr);
+              event.preventDefault();
+              return true;
+            } else if (!isBackspace && pos < doc.content.size) {
+              const tr = state.tr.delete(pos, pos + 1);
+              dispatch(tr);
+              event.preventDefault();
+              return true;
+            }
+          }
+        } catch (error) {
+          console.warn("RTL cursor fix error:", error);
+        }
+        return false;
+      };
+      const originalHandleDOMEvents = view.props.handleDOMEvents || {};
+      const originalKeydown = originalHandleDOMEvents.keydown;
+      view.setProps({
+        ...view.props,
+        handleDOMEvents: {
+          ...originalHandleDOMEvents,
+          keydown: (view2, event) => {
+            const handled = event instanceof KeyboardEvent ? eventHandler == null ? void 0 : eventHandler(event) : false;
+            if (handled) {
+              return true;
+            }
+            if (originalKeydown) {
+              return originalKeydown(view2, event);
+            }
+            return false;
+          }
+        }
+      });
+    };
+    setTimeout(setupRTLCursorFix, 0);
+    return async () => {
+      eventHandler = null;
+    };
+  };
+};
+export {
+  rtlCursorPlugin
+};

package/library/components/VcMeterGroup/VcMeterGroup.vue.mjs

@@ -0,0 +1,156 @@
+import '../../assets/components/VcMeterGroup/VcMeterGroup.css';
+import { defineComponent, computed, openBlock, createElementBlock, normalizeStyle, normalizeClass, renderSlot, createVNode, createCommentVNode, createElementVNode, Fragment, renderList } from "vue";
+import _sfc_main$1 from "./VcMeterGroupLabel.vue.mjs";
+const _hoisted_1 = ["aria-valuemin", "aria-valuemax", "aria-valuenow"];
+const _hoisted_2 = { class: "vc-metergroup-meters" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "VcMeterGroup",
+  props: {
+    value: { default: () => [] },
+    min: { default: 0 },
+    max: { default: 100 },
+    orientation: { default: "horizontal" },
+    labelPosition: { default: "end" },
+    labelOrientation: { default: "horizontal" },
+    hideLabel: { type: Boolean, default: false },
+    iconClasses: { default: "icon-base" },
+    labelClasses: { default: void 0 },
+    labelOffset: { default: "1rem" },
+    height: { default: "0.5rem" },
+    borderRadius: { default: "6px" },
+    markerSize: { default: "0.5rem" }
+  },
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const totalPercent = computed(() => {
+      return percent(getTotal());
+    });
+    const mappedValue = computed(() => {
+      return props.value.map((i) => {
+        return {
+          ...i,
+          percent: percentValue(i.value)
+        };
+      });
+    });
+    const percentages = computed(() => {
+      let sum = 0;
+      const sumsArray = [];
+      props.value.forEach((item) => {
+        sum += item.value;
+        sumsArray.push(sum);
+      });
+      return sumsArray;
+    });
+    function getTotal() {
+      return props.value.reduce((total, val) => total + val.value, 0);
+    }
+    function percent(value = 0) {
+      const max = props.max || getTotal();
+      const percentOfItem = (value - props.min) / (max - props.min) * 100;
+      return Math.round(Math.max(0, Math.min(100, percentOfItem)));
+    }
+    function percentValue(value) {
+      return percent(value) + "%";
+    }
+    function meterCalculatedStyles(val) {
+      if (props.orientation === "horizontal") {
+        return {
+          backgroundColor: val.color,
+          width: percentValue(val.value)
+        };
+      }
+      if (props.orientation === "vertical") {
+        return {
+          backgroundColor: val.color,
+          height: percentValue(val.value)
+        };
+      }
+      return {};
+    }
+    __expose({
+      totalPercent,
+      mappedValue,
+      percentages
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        role: "meter",
+        "aria-valuemin": __props.min,
+        "aria-valuemax": __props.max,
+        "aria-valuenow": totalPercent.value,
+        class: normalizeClass([{
+          "is--horizontal": __props.orientation === "horizontal",
+          "is--vertical": __props.orientation === "vertical"
+        }, "vc-meter-group"]),
+        style: normalizeStyle({
+          "--meter-size": __props.height,
+          "--meter-gap": __props.labelOffset,
+          "--meter-marker-size": __props.markerSize,
+          "--meter-b-radius": __props.borderRadius
+        })
+      }, [
+        __props.labelPosition === "start" && !__props.hideLabel ? renderSlot(_ctx.$slots, "label", {
+          key: 0,
+          value: __props.value,
+          totalPercent: totalPercent.value,
+          percentages: percentages.value
+        }, () => [
+          createVNode(_sfc_main$1, {
+            value: mappedValue.value,
+            "label-position": __props.labelPosition,
+            "label-orientation": __props.labelOrientation,
+            "icon-class": __props.iconClasses,
+            "label-class": __props.labelClasses
+          }, null, 8, ["value", "label-position", "label-orientation", "icon-class", "label-class"])
+        ]) : createCommentVNode("", true),
+        renderSlot(_ctx.$slots, "start", {
+          value: __props.value,
+          totalPercent: totalPercent.value,
+          percentages: percentages.value
+        }),
+        createElementVNode("div", _hoisted_2, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(__props.value, (val, index) => {
+            return renderSlot(_ctx.$slots, "meter", {
+              key: index,
+              value: val,
+              index,
+              orientation: __props.orientation,
+              size: percentValue(val.value),
+              totalPercent: totalPercent.value,
+              class: "vc-metergroup-meter"
+            }, () => [
+              percent(val.value) ? (openBlock(), createElementBlock("span", {
+                key: 0,
+                style: normalizeStyle(meterCalculatedStyles(val)),
+                class: "vc-metergroup-meter"
+              }, null, 4)) : createCommentVNode("", true)
+            ]);
+          }), 128))
+        ]),
+        renderSlot(_ctx.$slots, "end", {
+          value: __props.value,
+          totalPercent: totalPercent.value,
+          percentages: percentages.value
+        }),
+        __props.labelPosition === "end" && !__props.hideLabel ? renderSlot(_ctx.$slots, "label", {
+          key: 1,
+          value: __props.value,
+          totalPercent: totalPercent.value,
+          percentages: percentages.value
+        }, () => [
+          createVNode(_sfc_main$1, {
+            value: mappedValue.value,
+            "label-position": __props.labelPosition,
+            "label-orientation": __props.labelOrientation,
+            "icon-class": __props.iconClasses,
+            "label-class": __props.labelClasses
+          }, null, 8, ["value", "label-position", "label-orientation", "icon-class", "label-class"])
+        ]) : createCommentVNode("", true)
+      ], 14, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/library/components/VcMeterGroup/VcMeterGroup.vue3.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from "./VcMeterGroup.vue.mjs";
+import '../../assets/components/VcMeterGroup/VcMeterGroup.css';/* empty css                   */
+export {
+  _sfc_main as default
+};