cnhis-design-vue 3.1.14-beta.2 → 3.1.14-beta.5

package/es/packages/fabric-chart/src/hooks/useDraw.js

@@ -0,0 +1,144 @@
+import { fabric } from '../utils/index.js';
+
+const defaultStyle = {
+  evented: false,
+  selectable: false
+};
+const defaultBorderStyle = {
+  stroke: "#999",
+  strokeWidth: 1,
+  ...defaultStyle
+};
+const defaultLineStyle = {
+  stroke: "#000",
+  strokeWidth: 1,
+  strokeDashArray: [0, 0],
+  ...defaultStyle
+};
+const defaultRectStyle = {
+  fill: "transparent",
+  stroke: "#999",
+  strokeWidth: 1,
+  originX: "center",
+  originY: "center",
+  ...defaultStyle
+};
+const defaultTextStyle = {
+  fontFamily: "\u5FAE\u8F6F\u96C5\u9ED1",
+  fontSize: 12,
+  fill: "#000",
+  centeredRotation: true,
+  originX: "center",
+  originY: "center",
+  lineHeight: 1,
+  ...defaultStyle
+};
+function drawLine(points, style) {
+  return new fabric.Line(points, {
+    ...defaultLineStyle,
+    ...style
+  });
+}
+function drawTextGroup(rectStyle, fontStyle, groupStyle) {
+  const rect = new fabric.Rect({
+    ...defaultRectStyle,
+    ...rectStyle
+  });
+  const texts = new fabric.Text(String(fontStyle.value), {
+    ...defaultTextStyle,
+    ...fontStyle,
+    ...fontStyle.textAlign == "left" ? {
+      originX: "left",
+      left: -(rectStyle.width / 2)
+    } : {}
+  });
+  return new fabric.Group([rect, texts], {
+    ...groupStyle
+  });
+}
+function drawPoint(type = "circle", style) {
+  const newStyle = {
+    originX: "center",
+    originY: "center",
+    hasControls: false,
+    hasBorders: false,
+    ...style
+  };
+  const createCircleBorder = () => {
+    return new fabric.Circle({
+      objectCaching: false,
+      strokeWidth: style.strokeWidth || 1,
+      stroke: style.stroke || "red",
+      radius: style.radius || 5,
+      fill: "#fff"
+    });
+  };
+  switch (type) {
+    case "triangle":
+      return new fabric.Triangle({
+        width: 20,
+        height: 20,
+        strokeWidth: 1,
+        scale: 1,
+        ...newStyle
+      });
+    case "circle":
+      return new fabric.Circle({
+        objectCaching: false,
+        strokeWidth: 1,
+        radius: 5,
+        scale: 1,
+        ...newStyle
+      });
+    case "image":
+      if (style == null ? void 0 : style.url) ; else {
+        return new fabric.Image(style.element, {
+          ...newStyle,
+          scale: 1
+        });
+      }
+    case "yemai":
+      const createAdd = () => {
+        const width = ((style.radius || 5) + (style.strokeWidth || 1)) * 2;
+        const subLineStyle = {
+          stroke: style.strokeX || "blue",
+          strokeWidth: style.strokeWidthX || 1,
+          originX: "center",
+          originY: "center"
+        };
+        const line1 = new fabric.Line([0, width / 2, width, width / 2], subLineStyle);
+        const line2 = new fabric.Line([width / 2, 0, width / 2, width], subLineStyle);
+        return new fabric.Group([line1, line2]);
+      };
+      return new fabric.Group([createCircleBorder(), createAdd()], {
+        scale: 1,
+        ...newStyle
+      });
+    case "koumai":
+      const left = (style.radius || 5) + (style.strokeWidth || 1);
+      const circle = new fabric.Circle({
+        objectCaching: false,
+        radius: style.radiusCircle || 2,
+        fill: style.fillCircle || "#000",
+        originX: "center",
+        originY: "center",
+        left,
+        top: left
+      });
+      return new fabric.Group([createCircleBorder(), circle], {
+        scale: 1,
+        ...newStyle
+      });
+    default:
+      style && Reflect.deleteProperty(style, "stroke");
+      return new fabric.Text(String(type), {
+        fontFamily: "\u5FAE\u8F6F\u96C5\u9ED1",
+        scale: 1,
+        fontSize: 14,
+        fill: "#000",
+        ...newStyle
+      });
+  }
+}
+
+export { defaultBorderStyle, defaultLineStyle, defaultRectStyle, defaultStyle, defaultTextStyle, drawLine, drawPoint, drawTextGroup };

package/es/packages/fabric-chart/src/hooks/useEvent.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+import { fabric } from '../utils';
+import { IPropItems } from '../interface';
+export declare function useEvent(element: HTMLCanvasElement | any): void;
+export declare function useCanvasEvent(canvas: Ref<fabric.Canvas>, propItems: IPropItems, emits: any): {
+    select: (key: string) => void;
+};

package/es/packages/fabric-chart/src/hooks/useEvent.js

@@ -0,0 +1,75 @@
+import { useEventListener } from '@vueuse/core';
+import { fabric } from '../utils/index.js';
+
+function useEvent(element) {
+  useEventListener(element.nextSibling, "contextmenu", (e) => {
+    e.preventDefault();
+    return false;
+  });
+}
+function useCanvasEvent(canvas, propItems, emits) {
+  const { originY, originX, endX, endY, iconsWidth, selectionStyle, topList } = propItems;
+  function drawRect(options, key) {
+    const { left, top, width, height } = options;
+    const rect = new fabric.Rect({
+      key,
+      left: left != null ? left : 0,
+      top: top != null ? top : 0,
+      width,
+      height,
+      stroke: "transparent",
+      strokeWidth: 1,
+      fill: "transparent",
+      lockMovementX: true,
+      lockMovementY: true,
+      transparentCorners: false,
+      ...selectionStyle
+    });
+    canvas.value.add(rect);
+    rect.on("mousedown", () => {
+      emits("select", key);
+    });
+    return rect;
+  }
+  function initSelection() {
+    if (typeof (selectionStyle == null ? void 0 : selectionStyle.evented) === "boolean" && !(selectionStyle == null ? void 0 : selectionStyle.evented))
+      return;
+    const selections2 = [];
+    selections2.push(drawRect({
+      left: iconsWidth,
+      top: originY,
+      width: originX - iconsWidth,
+      height: endY
+    }, "left"));
+    let topY = 0;
+    topList.forEach((item, index) => {
+      if (index > 0) {
+        topY += propItems[`${topList[index - 1].key}Height`];
+      }
+      selections2.push(drawRect({
+        left: iconsWidth,
+        top: topY,
+        width: endX - iconsWidth,
+        height: propItems[`${item.key}Height`]
+      }, item.key));
+    });
+    selections2.push(drawRect({
+      left: originX,
+      top: originY,
+      width: endX - originX,
+      height: endY - originY
+    }, "grid"));
+    canvas.value.renderAll();
+    return selections2;
+  }
+  const selections = initSelection();
+  function select(key) {
+    canvas.value.discardActiveObject();
+    const obj = selections == null ? void 0 : selections.find((obj2) => obj2.key === key);
+    obj && obj.bringToFront();
+    obj && canvas.value.setActiveObject(obj);
+  }
+  return { select };
+}
+
+export { useCanvasEvent, useEvent };

package/es/packages/fabric-chart/src/hooks/useGrid.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { fabric } from '../utils';
+import { IPropItems } from '../interface';
+export default function useGrid(canvas: Ref<fabric.Canvas>, propItems: IPropItems): void;

package/es/packages/fabric-chart/src/hooks/useGrid.js

@@ -0,0 +1,50 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { drawLine } from './useDraw.js';
+
+function useGrid(canvas, propItems) {
+  var _a, _b;
+  const { gridYNumber, originY, grid, originX, endX, xCellWidth, yCellHeight, gridXNumber, endY } = propItems;
+  const yList = [];
+  const xList = [];
+  const mainList = /* @__PURE__ */ new Set();
+  for (let i = 0; i <= gridYNumber; i++) {
+    const y = originY + parseInt(String(yCellHeight * (gridYNumber - i)));
+    const style = i % grid.subYCell === 0 ? ((_a = grid.mainLineStyle) == null ? void 0 : _a.x) || {} : grid.subLineStyle || {};
+    const line = drawLine([originX, y, endX, y], style);
+    if (i % grid.subYCell === 0) {
+      mainList.add(line);
+    } else {
+      yList.push(line);
+    }
+  }
+  for (let i = 0; i <= gridXNumber; i++) {
+    const x = originX + parseInt(String(xCellWidth * i));
+    let style = grid.subLineStyle || {};
+    if (i % grid.subSecondXCell === 0) {
+      style = grid.subSecondLineStyle || {};
+    }
+    if (i % grid.subXCell === 0) {
+      style = ((_b = grid.mainLineStyle) == null ? void 0 : _b.y) || {};
+    }
+    const line = drawLine([x, originY, x, endY], style);
+    if (i % grid.subXCell === 0) {
+      mainList.add(line);
+    } else {
+      xList.push(line);
+    }
+  }
+  const group = new fabric.Group([...xList, ...yList, ...mainList], {
+    evented: false,
+    selectable: false
+  });
+  onMounted(() => {
+    nextTick(() => {
+      canvas.value.add(group);
+      canvas.value.sendToBack(group);
+      canvas.value.renderAll();
+    });
+  });
+}
+
+export { useGrid as default };

package/es/packages/fabric-chart/src/hooks/useLeft.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { fabric } from '../utils';
+import { IPropItems } from '../interface';
+export declare function useLeft(canvas: Ref<fabric.Canvas>, propItems: IPropItems, emits: any, setPopup: Function, pointTipProps: any, getXValue: Function, getYValue: Function, getEqualXTypes: Function): void;

package/es/packages/fabric-chart/src/hooks/useLeft.js

@@ -0,0 +1,243 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { defaultBorderStyle, defaultTextStyle, defaultStyle, defaultRectStyle, drawPoint, drawTextGroup } from './useDraw.js';
+
+function useLeft(canvas, propItems, emits, setPopup, pointTipProps, getXValue, getYValue, getEqualXTypes) {
+  const {
+    originY,
+    endY,
+    originX,
+    endX,
+    yCellHeight,
+    borderStyle,
+    left,
+    vitalSignsOriginY,
+    painOriginY,
+    painHeight,
+    iconsWidth,
+    itemList
+  } = propItems;
+  const mainScaleWidth = 9;
+  const subScaleWidth = 5;
+  function drawScaleNumber(text, item, left2, top) {
+    return new fabric.Text(String(text), {
+      ...defaultTextStyle,
+      originX: item.position || "center",
+      left: left2,
+      top,
+      ...item.style
+    });
+  }
+  function getScaleInfo(position = "center", x, width) {
+    let scaleLeft = x + width / 2;
+    let lineXMain = [scaleLeft - mainScaleWidth / 2, scaleLeft + mainScaleWidth / 2];
+    let lineXSub = [scaleLeft - subScaleWidth / 2, scaleLeft + subScaleWidth / 2];
+    let textLeft = scaleLeft;
+    if (position === "left") {
+      scaleLeft = x;
+      lineXMain = [scaleLeft, scaleLeft + mainScaleWidth];
+      lineXSub = [scaleLeft, scaleLeft + subScaleWidth];
+      textLeft = lineXMain[1];
+    }
+    if (position === "right") {
+      scaleLeft = x + width;
+      lineXMain = [scaleLeft - mainScaleWidth, scaleLeft];
+      lineXSub = [scaleLeft - subScaleWidth, scaleLeft];
+      textLeft = lineXMain[0];
+    }
+    return { lineXMain, lineXSub, textLeft };
+  }
+  function drwaPainScaleValue(item) {
+    const title = drawTextGroup({
+      width: originX - iconsWidth,
+      height: painHeight,
+      ...defaultRectStyle
+    }, {
+      value: `${item.title.slice(0, 2)}
+${item.title.slice(-2)}`,
+      ...defaultTextStyle,
+      ...item.titleStyle || {}
+    }, {
+      left: iconsWidth,
+      top: painOriginY.originY
+    });
+    const list = [];
+    if (item.showScale || item.showNumber) {
+      const { lineXMain, textLeft } = getScaleInfo(item.position, iconsWidth, originX - iconsWidth);
+      item.list.forEach((v, i) => {
+        let top = painOriginY.endY - i * yCellHeight * item.spaceGridNumber;
+        if (i === 0) {
+          top = endY - 5;
+        }
+        if (item.showNumber) {
+          list.push(drawScaleNumber(v, item, textLeft, top));
+        }
+        if (item.showScale && i !== 0) {
+          const [x1, x2] = lineXMain;
+          const line = new fabric.Line([x1, top, x2, top], {
+            ...defaultBorderStyle,
+            ...item.style
+          });
+          list.push(line);
+        }
+      });
+    }
+    canvas.value.add(title, ...list);
+    title.sendToBack();
+  }
+  function drawScaleValue() {
+    let groupList = [];
+    const column = !painHeight ? left.yScaleValue.length : left.yScaleValue.length - 1;
+    const colWidth = (originX - iconsWidth) / column;
+    const residue = (originX - iconsWidth) % column;
+    const firstColWidth = colWidth + residue;
+    left.yScaleValue.forEach((item, index) => {
+      if (item.type === "pain") {
+        drwaPainScaleValue(item);
+        return;
+      }
+      let list = [];
+      const rectWidth = index === 0 ? firstColWidth : colWidth;
+      const rectLeft = index === 0 ? iconsWidth : firstColWidth + iconsWidth + (index - 1) * colWidth;
+      const line = index > 0 ? new fabric.Line([rectLeft, vitalSignsOriginY.originY, rectLeft, vitalSignsOriginY.endY], {
+        ...defaultBorderStyle
+      }) : null;
+      line && list.push(line);
+      const centerX = rectLeft + rectWidth / 2;
+      const spaceGridNumber = item.spaceGridNumber || 5;
+      if (item.showScale || item.showNumber) {
+        const spaceScale = spaceGridNumber * yCellHeight / 5;
+        const position = item.position || "center";
+        const { lineXMain, lineXSub, textLeft } = getScaleInfo(item.position, rectLeft, rectWidth);
+        item.list.forEach((v, i) => {
+          const top = vitalSignsOriginY.endY - i * yCellHeight * spaceGridNumber;
+          if (item.showNumber) {
+            const text = drawScaleNumber(v, item, textLeft, i === 0 ? top - 5 : top);
+            list.push(text);
+          }
+          if (item.showScale && i !== item.list.length - 1) {
+            for (let j = 0; j < 5; j++) {
+              if (j > 0 || !item.showNumber || position !== "center") {
+                let createLine = function(points) {
+                  const line2 = new fabric.Line(points, {
+                    ...defaultBorderStyle,
+                    ...item.style
+                  });
+                  list.push(line2);
+                };
+                const x1 = j == 0 ? lineXMain[0] : lineXSub[0];
+                const x2 = j == 0 ? lineXMain[1] : lineXSub[1];
+                const y = top - j * spaceScale;
+                createLine([x1, y, x2, y]);
+                if (i == item.list.length - 2 && j == 4) {
+                  createLine([lineXMain[0], y - spaceScale, lineXMain[1], y - spaceScale]);
+                }
+              }
+            }
+          }
+        });
+      }
+      let title = item.title || "";
+      if (item.unit)
+        title += "\n" + item.unit;
+      title && list.push(new fabric.Text(String(title), {
+        ...defaultTextStyle,
+        left: centerX,
+        top: vitalSignsOriginY.originY + yCellHeight * spaceGridNumber / 2,
+        textAlign: "center",
+        ...item.style
+      }));
+      const group2 = new fabric.Group(list, defaultStyle);
+      groupList.push(group2);
+    });
+    groupList.push(new fabric.Rect({
+      ...defaultRectStyle,
+      width: originX - iconsWidth,
+      height: endY - originY,
+      left: iconsWidth,
+      top: originY,
+      originX: "left",
+      originY: "top"
+    }));
+    const group = groupList.length > 0 ? new fabric.Group([...groupList], { ...defaultStyle }) : null;
+    group && canvas.value.add(group);
+    group && group.sendToBack();
+  }
+  function drawIcons() {
+    let list = JSON.parse(JSON.stringify(itemList));
+    let topY = endY;
+    let leftX = iconsWidth - left.icons.marginRight;
+    list.reverse().forEach((item, index) => {
+      topY -= 10;
+      let title = item.title.replace(/(.{2})/g, "$1\n");
+      if (title.endsWith("\n")) {
+        title = title.slice(0, title.length - 1);
+      }
+      const text = new fabric.Text(String(title), {
+        ...defaultStyle,
+        ...item.titleStyle || {},
+        originX: "right",
+        originY: "bottom",
+        left: leftX - (item.pointAttr.width || 10) - 5,
+        top: topY,
+        lineHeight: 1,
+        fontSize: 12
+      });
+      const icon = drawPoint(item.type, {
+        left: leftX,
+        top: topY - (text.height || 30) / 2,
+        ...item.pointAttr,
+        originY: "center",
+        originX: "right",
+        origin: {
+          title: item.title,
+          unit: item.unit,
+          type: item.bigType,
+          dataIndex: item.dataIndex
+        }
+      });
+      topY -= text.height || 30;
+      setPointEvent(icon);
+      canvas.value.add(text, icon);
+    });
+  }
+  function isLimit(point) {
+    return point.left >= originX && point.left <= endX && point.top >= originY && point.top <= endY;
+  }
+  function setPointEvent(point) {
+    point.on("moving", () => {
+      if (isLimit(point)) {
+        setPopup(point);
+      } else {
+        pointTipProps.show = false;
+      }
+    });
+    point.on("mouseup:before", (event) => {
+      pointTipProps.show = false;
+      if (event.e.button === 0) {
+        if (isLimit(point)) {
+          if (!getEqualXTypes(point.left).includes(point.origin.type)) {
+            emits("add", {
+              data: {
+                time: getXValue(point.left),
+                value: getYValue(point.origin.type, point.top)
+              },
+              ...point.origin
+            });
+          } else {
+            console.log("\u5F53\u524D\u65F6\u95F4\u6BB5\u5185\u65E0\u53EF\u65B0\u589E\u8282\u70B9");
+          }
+        }
+      }
+    });
+  }
+  onMounted(() => {
+    nextTick(() => {
+      iconsWidth && drawIcons();
+      drawScaleValue();
+      canvas.value.renderAll();
+    });
+  });
+}
+
+export { useLeft };

package/es/packages/fabric-chart/src/hooks/useOther.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { fabric } from '../utils';
+import { IPropItems } from '../interface';
+export declare function useOther(canvas: Ref<fabric.Canvas>, propItems: IPropItems, cumputedX: Function): void;

package/es/packages/fabric-chart/src/hooks/useOther.js

@@ -0,0 +1,35 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { defaultStyle } from './useDraw.js';
+
+function useOther(canvas, propItems, cumputedX) {
+  const { originY, other, vitalSignsOriginY } = propItems;
+  function drawOther() {
+    if (!other || !other.list)
+      return false;
+    const list = [];
+    other.list.forEach((v, i) => {
+      var _a;
+      const text = new fabric.Text(String(v.value.toString().split("").join("\n")), {
+        originX: "center",
+        top: (((_a = v.style) == null ? void 0 : _a.baseTop) || 0) + vitalSignsOriginY.originY,
+        left: cumputedX(v.time),
+        textAlign: "center",
+        ...defaultStyle,
+        ...v.style || {}
+      });
+      list.push(text);
+    });
+    const group = list.length > 0 ? new fabric.Group([...list], { ...defaultStyle }) : null;
+    group && group.sendToBack();
+    group && canvas.value.add(group);
+  }
+  onMounted(() => {
+    nextTick(() => {
+      drawOther();
+      canvas.value.renderAll();
+    });
+  });
+}
+
+export { useOther };

package/es/packages/fabric-chart/src/hooks/useRight.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import { fabric } from '../utils';
+import { IPropItems } from '../interface';
+export declare function useRight(canvas: Ref<fabric.Canvas>, propItems: IPropItems): void;

package/es/packages/fabric-chart/src/hooks/useRight.js

@@ -0,0 +1,90 @@
+import { onMounted, nextTick } from 'vue';
+import { fabric } from '../utils/index.js';
+import { defaultBorderStyle, defaultRectStyle, defaultStyle } from './useDraw.js';
+
+function useRight(canvas, propItems) {
+  const {
+    endX,
+    endY,
+    temperatureYCell,
+    canvasWidth,
+    canvasHeight,
+    left,
+    right,
+    breathingHeight,
+    vitalSignsOriginY,
+    painOriginY
+  } = propItems;
+  function drawScaleValue() {
+    var _a, _b, _c;
+    if (!right) {
+      canvas.value.add(new fabric.Line([canvasWidth - 1, 0, canvasWidth - 1, canvasHeight], defaultBorderStyle));
+      return false;
+    }
+    let list = [];
+    list.push(new fabric.Rect({
+      ...defaultRectStyle,
+      width: canvasWidth - endX - 1,
+      height: endY + breathingHeight - 1,
+      left: endX,
+      top: 0,
+      originX: "left",
+      originY: "top"
+    }));
+    const difVal = 6;
+    const spaceScaleNumber = right.yScaleValue.spaceScaleNumber || 5;
+    const mainScaleWidth = 9;
+    const subScaleWidth = 5;
+    const cList = left.yScaleValue.find((v) => v.type === "temperature").list;
+    const minC = Math.min(...cList);
+    const h1 = right.yScaleValue.list[1];
+    const h0 = right.yScaleValue.list[0];
+    const c1 = 5 * (h1 - 32) / 9;
+    const c0 = 5 * (h0 - 32) / 9;
+    const top1 = vitalSignsOriginY.endY - (c1 - minC) * temperatureYCell - difVal;
+    const top0 = vitalSignsOriginY.endY - (c0 - minC) * temperatureYCell - difVal;
+    const spaceHVaule = (top0 - top1) / spaceScaleNumber;
+    let endTop = 0;
+    right.yScaleValue.list.forEach((v, i) => {
+      var _a2;
+      const c = 5 * (+v - 32) / 9;
+      const top = vitalSignsOriginY.endY - (c - minC) * temperatureYCell - difVal;
+      if (i === right.yScaleValue.list.length - 1)
+        endTop = top;
+      const text = new fabric.Text(`${v}\xB0`, {
+        left: endX + mainScaleWidth,
+        top: i === 0 ? vitalSignsOriginY.endY - 5 : top - 5,
+        originX: "left",
+        ...((_a2 = right.yScaleValue) == null ? void 0 : _a2.style) || {}
+      });
+      list.push(text);
+      const spaceHVaule0 = (vitalSignsOriginY.endY - top1) / spaceScaleNumber;
+      for (let k = 0; k < spaceScaleNumber; k++) {
+        const scaleTop = i === 0 ? vitalSignsOriginY.endY - k * spaceHVaule0 : top - k * spaceHVaule;
+        const line = new fabric.Line([endX, scaleTop, k > 0 ? endX + subScaleWidth : endX + mainScaleWidth, scaleTop], {
+          ...defaultBorderStyle
+        });
+        list.push(line);
+      }
+    });
+    const width = canvasWidth - endX;
+    const unit = right.yScaleValue.unit ? new fabric.Text((_b = (_a = right.yScaleValue) == null ? void 0 : _a.unit) == null ? void 0 : _b.split("").join("\n"), {
+      left: endX + width / 2,
+      top: endTop / 2,
+      originX: "center",
+      ...((_c = right.yScaleValue) == null ? void 0 : _c.style) || {}
+    }) : null;
+    unit && list.push(unit);
+    const group = list.length > 0 ? new fabric.Group([...list], { ...defaultStyle }) : null;
+    group && canvas.value.add(group);
+    group && group.sendToBack();
+  }
+  onMounted(() => {
+    nextTick(() => {
+      drawScaleValue();
+      canvas.value.renderAll();
+    });
+  });
+}
+
+export { useRight };

package/es/packages/fabric-chart/src/hooks/useShadow.d.ts

@@ -0,0 +1,6 @@
+import { fabric } from '../utils';
+declare type Point = [number, number];
+export declare function useShadow(): {
+    createShadowLines: (coordinates: Point[], angle?: number, space?: number) => fabric.Line[];
+};
+export {};