react-klinecharts-ui 0.1.0 → 0.2.0

package/dist/chunk-47JXSAIT.cjs

@@ -0,0 +1,2467 @@
+'use strict';
+
+var reactKlinecharts = require('react-klinecharts');
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/overlays/index.ts
+var overlays_exports = {};
+__export(overlays_exports, {
+  abcd: () => abcd_default,
+  anyWaves: () => anyWaves_default,
+  arrow: () => arrow_default,
+  brush: () => brush_default,
+  circle: () => circle_default,
+  eightWaves: () => eightWaves_default,
+  elliottWave: () => elliottWave_default,
+  fibRetracement: () => fibRetracement_default,
+  fibonacciCircle: () => fibonacciCircle_default,
+  fibonacciExtension: () => fibonacciExtension_default,
+  fibonacciSegment: () => fibonacciSegment_default,
+  fibonacciSpeedResistanceFan: () => fibonacciSpeedResistanceFan_default,
+  fibonacciSpiral: () => fibonacciSpiral_default,
+  fiveWaves: () => fiveWaves_default,
+  gannBox: () => gannBox_default,
+  gannFan: () => gannFan_default,
+  longPosition: () => longPosition_default,
+  measure: () => measure_default,
+  parallelChannel: () => parallelChannel_default,
+  parallelogram: () => parallelogram_default,
+  ray: () => ray_default,
+  rect: () => rect_default,
+  shortPosition: () => shortPosition_default,
+  threeWaves: () => threeWaves_default,
+  triangle: () => triangle_default,
+  xabcd: () => xabcd_default
+});
+function getRotateCoordinate(coordinate, targetCoordinate, angle) {
+  const x = (coordinate.x - targetCoordinate.x) * Math.cos(angle) - (coordinate.y - targetCoordinate.y) * Math.sin(angle) + targetCoordinate.x;
+  const y = (coordinate.x - targetCoordinate.x) * Math.sin(angle) + (coordinate.y - targetCoordinate.y) * Math.cos(angle) + targetCoordinate.y;
+  return { x, y };
+}
+function getRayLine(coordinates, bounding) {
+  if (coordinates.length > 1) {
+    let coordinate;
+    if (coordinates[0].x === coordinates[1].x && coordinates[0].y !== coordinates[1].y) {
+      if (coordinates[0].y < coordinates[1].y) {
+        coordinate = { x: coordinates[0].x, y: bounding.height };
+      } else {
+        coordinate = { x: coordinates[0].x, y: 0 };
+      }
+    } else if (coordinates[0].x > coordinates[1].x) {
+      coordinate = {
+        x: 0,
+        y: reactKlinecharts.utils.getLinearYFromCoordinates(coordinates[0], coordinates[1], {
+          x: 0,
+          y: coordinates[0].y
+        })
+      };
+    } else {
+      coordinate = {
+        x: bounding.width,
+        y: reactKlinecharts.utils.getLinearYFromCoordinates(coordinates[0], coordinates[1], {
+          x: bounding.width,
+          y: coordinates[0].y
+        })
+      };
+    }
+    return { coordinates: [coordinates[0], coordinate] };
+  }
+  return [];
+}
+function getDistance(coordinate1, coordinate2) {
+  const xDis = Math.abs(coordinate1.x - coordinate2.x);
+  const yDis = Math.abs(coordinate1.y - coordinate2.y);
+  return Math.sqrt(xDis * xDis + yDis * yDis);
+}
+
+// src/overlays/arrow.ts
+var arrow = {
+  name: "arrow",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      const flag = coordinates[1].x > coordinates[0].x ? 0 : 1;
+      const kb = reactKlinecharts.utils.getLinearSlopeIntercept(coordinates[0], coordinates[1]);
+      let offsetAngle;
+      if (kb) {
+        offsetAngle = Math.atan(kb[0]) + Math.PI * flag;
+      } else {
+        if (coordinates[1].y > coordinates[0].y) {
+          offsetAngle = Math.PI / 2;
+        } else {
+          offsetAngle = Math.PI / 2 * 3;
+        }
+      }
+      const rotateCoordinate1 = getRotateCoordinate(
+        { x: coordinates[1].x - 8, y: coordinates[1].y + 4 },
+        coordinates[1],
+        offsetAngle
+      );
+      const rotateCoordinate2 = getRotateCoordinate(
+        { x: coordinates[1].x - 8, y: coordinates[1].y - 4 },
+        coordinates[1],
+        offsetAngle
+      );
+      return [
+        { type: "line", attrs: { coordinates } },
+        {
+          type: "line",
+          ignoreEvent: true,
+          attrs: {
+            coordinates: [rotateCoordinate1, coordinates[1], rotateCoordinate2]
+          }
+        }
+      ];
+    }
+    return [];
+  }
+};
+var arrow_default = arrow;
+
+// src/overlays/circle.ts
+var circle = {
+  name: "circle",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { circle: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      const radius = getDistance(coordinates[0], coordinates[1]);
+      return {
+        type: "circle",
+        attrs: { ...coordinates[0], r: radius },
+        styles: { style: "stroke_fill" }
+      };
+    }
+    return [];
+  }
+};
+var circle_default = circle;
+
+// src/overlays/rect.ts
+var rect = {
+  name: "rect",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { polygon: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      return [
+        {
+          type: "polygon",
+          attrs: {
+            coordinates: [
+              coordinates[0],
+              { x: coordinates[1].x, y: coordinates[0].y },
+              coordinates[1],
+              { x: coordinates[0].x, y: coordinates[1].y }
+            ]
+          },
+          styles: { style: "stroke_fill" }
+        }
+      ];
+    }
+    return [];
+  }
+};
+var rect_default = rect;
+
+// src/overlays/triangle.ts
+var triangle = {
+  name: "triangle",
+  totalStep: 4,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { polygon: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    return [
+      {
+        type: "polygon",
+        attrs: { coordinates },
+        styles: { style: "stroke_fill" }
+      }
+    ];
+  }
+};
+var triangle_default = triangle;
+
+// src/overlays/parallelogram.ts
+var parallelogram = {
+  name: "parallelogram",
+  totalStep: 4,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { polygon: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length === 2) {
+      return [{ type: "line", ignoreEvent: true, attrs: { coordinates } }];
+    }
+    if (coordinates.length === 3) {
+      const coordinate = {
+        x: coordinates[0].x + (coordinates[2].x - coordinates[1].x),
+        y: coordinates[2].y - coordinates[1].y + coordinates[0].y
+      };
+      return [
+        {
+          type: "polygon",
+          attrs: {
+            coordinates: [
+              coordinates[0],
+              coordinates[1],
+              coordinates[2],
+              coordinate
+            ]
+          },
+          styles: { style: "stroke_fill" }
+        }
+      ];
+    }
+    return [];
+  },
+  performEventPressedMove: ({ points, performPointIndex, performPoint }) => {
+    if (performPointIndex < 2) {
+      if (points[0]) points[0].price = performPoint.price;
+      if (points[1]) points[1].price = performPoint.price;
+    }
+  },
+  performEventMoveForDrawing: ({ currentStep, points, performPoint }) => {
+    if (currentStep === 2) {
+      if (points[0]) points[0].price = performPoint.price;
+    }
+  }
+};
+var parallelogram_default = parallelogram;
+
+// src/overlays/fibonacciCircle.ts
+var fibonacciCircle = {
+  name: "fibonacciCircle",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      const xDis = Math.abs(coordinates[0].x - coordinates[1].x);
+      const yDis = Math.abs(coordinates[0].y - coordinates[1].y);
+      const radius = Math.sqrt(xDis * xDis + yDis * yDis);
+      const percents = [0.236, 0.382, 0.5, 0.618, 0.786, 1];
+      const circles = [];
+      const texts = [];
+      percents.forEach((percent) => {
+        const r = radius * percent;
+        circles.push({ ...coordinates[0], r });
+        texts.push({
+          x: coordinates[0].x,
+          y: coordinates[0].y + r + 6,
+          text: `${(percent * 100).toFixed(1)}%`
+        });
+      });
+      return [
+        { type: "circle", attrs: circles, styles: { style: "stroke" } },
+        { type: "text", ignoreEvent: true, attrs: texts }
+      ];
+    }
+    return [];
+  }
+};
+var fibonacciCircle_default = fibonacciCircle;
+
+// src/overlays/fibonacciSegment.ts
+var fibonacciSegment = {
+  name: "fibonacciSegment",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates, overlay, chart }) => {
+    const precision = chart.getSymbol()?.pricePrecision ?? 2;
+    const lines = [];
+    const texts = [];
+    if (coordinates.length > 1) {
+      const textX = coordinates[1].x > coordinates[0].x ? coordinates[0].x : coordinates[1].x;
+      const percents = [1, 0.786, 0.618, 0.5, 0.382, 0.236, 0];
+      const yDif = coordinates[0].y - coordinates[1].y;
+      const points = overlay.points;
+      const valueDif = points[0].value - points[1].value;
+      percents.forEach((percent) => {
+        const y = coordinates[1].y + yDif * percent;
+        const price = (points[1].value + valueDif * percent).toFixed(precision);
+        lines.push({
+          coordinates: [
+            { x: coordinates[0].x, y },
+            { x: coordinates[1].x, y }
+          ]
+        });
+        texts.push({
+          x: textX,
+          y,
+          text: `${price} (${(percent * 100).toFixed(1)}%)`,
+          baseline: "bottom"
+        });
+      });
+    }
+    return [
+      { type: "line", attrs: lines },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var fibonacciSegment_default = fibonacciSegment;
+var fibonacciSpiral = {
+  name: "fibonacciSpiral",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates, bounding }) => {
+    if (coordinates.length > 1) {
+      const startRadius = getDistance(coordinates[0], coordinates[1]) / Math.sqrt(24);
+      const flag = coordinates[1].x > coordinates[0].x ? 0 : 1;
+      const kb = reactKlinecharts.utils.getLinearSlopeIntercept(coordinates[0], coordinates[1]);
+      let offsetAngle;
+      if (kb) {
+        offsetAngle = Math.atan(kb[0]) + Math.PI * flag;
+      } else {
+        if (coordinates[1].y > coordinates[0].y) {
+          offsetAngle = Math.PI / 2;
+        } else {
+          offsetAngle = Math.PI / 2 * 3;
+        }
+      }
+      const rotateCoordinate1 = getRotateCoordinate(
+        { x: coordinates[0].x - startRadius, y: coordinates[0].y },
+        coordinates[0],
+        offsetAngle
+      );
+      const rotateCoordinate2 = getRotateCoordinate(
+        {
+          x: coordinates[0].x - startRadius,
+          y: coordinates[0].y - startRadius
+        },
+        coordinates[0],
+        offsetAngle
+      );
+      const arcs = [
+        {
+          ...rotateCoordinate1,
+          r: startRadius,
+          startAngle: offsetAngle,
+          endAngle: offsetAngle + Math.PI / 2
+        },
+        {
+          ...rotateCoordinate2,
+          r: startRadius * 2,
+          startAngle: offsetAngle + Math.PI / 2,
+          endAngle: offsetAngle + Math.PI
+        }
+      ];
+      let x = coordinates[0].x - startRadius;
+      let y = coordinates[0].y - startRadius;
+      for (let i = 2; i < 9; i++) {
+        const r = arcs[i - 2].r + arcs[i - 1].r;
+        let startAngle = 0;
+        switch (i % 4) {
+          case 0:
+            startAngle = offsetAngle;
+            x -= arcs[i - 2].r;
+            break;
+          case 1:
+            startAngle = offsetAngle + Math.PI / 2;
+            y -= arcs[i - 2].r;
+            break;
+          case 2:
+            startAngle = offsetAngle + Math.PI;
+            x += arcs[i - 2].r;
+            break;
+          case 3:
+            startAngle = offsetAngle + Math.PI / 2 * 3;
+            y += arcs[i - 2].r;
+            break;
+        }
+        const endAngle = startAngle + Math.PI / 2;
+        const rotateCoordinate = getRotateCoordinate(
+          { x, y },
+          coordinates[0],
+          offsetAngle
+        );
+        arcs.push({ ...rotateCoordinate, r, startAngle, endAngle });
+      }
+      return [
+        { type: "arc", attrs: arcs },
+        { type: "line", attrs: getRayLine(coordinates, bounding) }
+      ];
+    }
+    return [];
+  }
+};
+var fibonacciSpiral_default = fibonacciSpiral;
+
+// src/overlays/fibonacciSpeedResistanceFan.ts
+var fibonacciSpeedResistanceFan = {
+  name: "fibonacciSpeedResistanceFan",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates, bounding }) => {
+    const lines1 = [];
+    let lines2 = [];
+    const texts = [];
+    if (coordinates.length > 1) {
+      const xOffset = coordinates[1].x > coordinates[0].x ? -38 : 4;
+      const yOffset = coordinates[1].y > coordinates[0].y ? -2 : 20;
+      const xDistance = coordinates[1].x - coordinates[0].x;
+      const yDistance = coordinates[1].y - coordinates[0].y;
+      const percents = [1, 0.75, 0.618, 0.5, 0.382, 0.25, 0];
+      percents.forEach((percent) => {
+        const x = coordinates[1].x - xDistance * percent;
+        const y = coordinates[1].y - yDistance * percent;
+        lines1.push({
+          coordinates: [
+            { x, y: coordinates[0].y },
+            { x, y: coordinates[1].y }
+          ]
+        });
+        lines1.push({
+          coordinates: [
+            { x: coordinates[0].x, y },
+            { x: coordinates[1].x, y }
+          ]
+        });
+        lines2 = lines2.concat(
+          getRayLine(
+            [coordinates[0], { x, y: coordinates[1].y }],
+            bounding
+          )
+        );
+        lines2 = lines2.concat(
+          getRayLine(
+            [coordinates[0], { x: coordinates[1].x, y }],
+            bounding
+          )
+        );
+        texts.unshift({
+          x: coordinates[0].x + xOffset,
+          y: y + 10,
+          text: `${percent.toFixed(3)}`
+        });
+        texts.unshift({
+          x: x - 18,
+          y: coordinates[0].y + yOffset,
+          text: `${percent.toFixed(3)}`
+        });
+      });
+    }
+    return [
+      { type: "line", attrs: lines1 },
+      { type: "line", attrs: lines2 },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var fibonacciSpeedResistanceFan_default = fibonacciSpeedResistanceFan;
+
+// src/overlays/fibonacciExtension.ts
+var fibonacciExtension = {
+  name: "fibonacciExtension",
+  totalStep: 4,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates, overlay, chart }) => {
+    const precision = chart.getSymbol()?.pricePrecision ?? 2;
+    const fbLines = [];
+    const texts = [];
+    if (coordinates.length > 2) {
+      const points = overlay.points;
+      const valueDif = points[1].value - points[0].value;
+      const yDif = coordinates[1].y - coordinates[0].y;
+      const percents = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1];
+      const textX = coordinates[2].x > coordinates[1].x ? coordinates[1].x : coordinates[2].x;
+      percents.forEach((percent) => {
+        const y = coordinates[2].y + yDif * percent;
+        const price = (points[2].value + valueDif * percent).toFixed(precision);
+        fbLines.push({
+          coordinates: [
+            { x: coordinates[1].x, y },
+            { x: coordinates[2].x, y }
+          ]
+        });
+        texts.push({
+          x: textX,
+          y,
+          text: `${price} (${(percent * 100).toFixed(1)}%)`,
+          baseline: "bottom"
+        });
+      });
+    }
+    return [
+      {
+        type: "line",
+        attrs: { coordinates },
+        styles: { style: "dashed" }
+      },
+      { type: "line", attrs: fbLines },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var fibonacciExtension_default = fibonacciExtension;
+
+// src/overlays/fibRetracement.ts
+var fibRetracement = {
+  name: "fibRetracement",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates, bounding }) => {
+    if (coordinates.length > 1) {
+      const lines = [];
+      const texts = [];
+      const x1 = coordinates[0].x;
+      const x2 = bounding.width;
+      const y1 = coordinates[0].y;
+      const y2 = coordinates[1].y;
+      const diff = y2 - y1;
+      const levels = [
+        { level: 0, text: "0 (0.00%)" },
+        { level: 0.236, text: "0.236 (23.6%)" },
+        { level: 0.382, text: "0.382 (38.2%)" },
+        { level: 0.5, text: "0.5 (50.0%)" },
+        { level: 0.618, text: "0.618 (61.8%)" },
+        { level: 0.786, text: "0.786 (78.6%)" },
+        { level: 1, text: "1 (100.0%)" }
+      ];
+      levels.forEach((l) => {
+        const y = y1 + diff * l.level;
+        lines.push({ coordinates: [{ x: x1, y }, { x: x2, y }] });
+        texts.push({
+          x: x1,
+          y,
+          text: l.text,
+          align: "left",
+          baseline: "bottom"
+        });
+      });
+      return [
+        { type: "line", attrs: lines },
+        { type: "text", attrs: texts }
+      ];
+    }
+    return [];
+  }
+};
+var fibRetracement_default = fibRetracement;
+
+// src/overlays/gannBox.ts
+var gannBox = {
+  name: "gannBox",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { polygon: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      const quarterYDis = (coordinates[1].y - coordinates[0].y) / 4;
+      const xDis = coordinates[1].x - coordinates[0].x;
+      const dashedLines = [
+        {
+          coordinates: [
+            coordinates[0],
+            { x: coordinates[1].x, y: coordinates[1].y - quarterYDis }
+          ]
+        },
+        {
+          coordinates: [
+            coordinates[0],
+            { x: coordinates[1].x, y: coordinates[1].y - quarterYDis * 2 }
+          ]
+        },
+        {
+          coordinates: [
+            { x: coordinates[0].x, y: coordinates[1].y },
+            { x: coordinates[1].x, y: coordinates[0].y + quarterYDis }
+          ]
+        },
+        {
+          coordinates: [
+            { x: coordinates[0].x, y: coordinates[1].y },
+            { x: coordinates[1].x, y: coordinates[0].y + quarterYDis * 2 }
+          ]
+        },
+        {
+          coordinates: [
+            { ...coordinates[0] },
+            { x: coordinates[0].x + xDis * 0.236, y: coordinates[1].y }
+          ]
+        },
+        {
+          coordinates: [
+            { ...coordinates[0] },
+            { x: coordinates[0].x + xDis * 0.5, y: coordinates[1].y }
+          ]
+        },
+        {
+          coordinates: [
+            { x: coordinates[0].x, y: coordinates[1].y },
+            { x: coordinates[0].x + xDis * 0.236, y: coordinates[0].y }
+          ]
+        },
+        {
+          coordinates: [
+            { x: coordinates[0].x, y: coordinates[1].y },
+            { x: coordinates[0].x + xDis * 0.5, y: coordinates[0].y }
+          ]
+        }
+      ];
+      const solidLines = [
+        { coordinates: [coordinates[0], coordinates[1]] },
+        {
+          coordinates: [
+            { x: coordinates[0].x, y: coordinates[1].y },
+            { x: coordinates[1].x, y: coordinates[0].y }
+          ]
+        }
+      ];
+      return [
+        {
+          type: "line",
+          attrs: [
+            {
+              coordinates: [
+                coordinates[0],
+                { x: coordinates[1].x, y: coordinates[0].y }
+              ]
+            },
+            {
+              coordinates: [
+                { x: coordinates[1].x, y: coordinates[0].y },
+                coordinates[1]
+              ]
+            },
+            {
+              coordinates: [
+                coordinates[1],
+                { x: coordinates[0].x, y: coordinates[1].y }
+              ]
+            },
+            {
+              coordinates: [
+                { x: coordinates[0].x, y: coordinates[1].y },
+                coordinates[0]
+              ]
+            }
+          ]
+        },
+        {
+          type: "polygon",
+          ignoreEvent: true,
+          attrs: {
+            coordinates: [
+              coordinates[0],
+              { x: coordinates[1].x, y: coordinates[0].y },
+              coordinates[1],
+              { x: coordinates[0].x, y: coordinates[1].y }
+            ]
+          },
+          styles: { style: "fill" }
+        },
+        { type: "line", attrs: dashedLines, styles: { style: "dashed" } },
+        { type: "line", attrs: solidLines }
+      ];
+    }
+    return [];
+  }
+};
+var gannBox_default = gannBox;
+
+// src/overlays/gannFan.ts
+var gannFan = {
+  name: "gannFan",
+  totalStep: 2,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates, bounding }) => {
+    if (coordinates.length > 0) {
+      const p1 = coordinates[0];
+      const p2 = coordinates[1] || p1;
+      const lines = [];
+      const dx = p2.x - p1.x;
+      const dy = p2.y - p1.y;
+      const ratios = [8, 4, 3, 2, 1, 0.5, 0.333, 0.25, 0.125];
+      ratios.forEach((ratio) => {
+        const targetX = bounding.width;
+        const targetY = p1.y + dy * (ratio * ((targetX - p1.x) / (dx || 1)));
+        lines.push({ coordinates: [p1, { x: targetX, y: targetY }] });
+      });
+      return [{ type: "line", attrs: lines }];
+    }
+    return [];
+  }
+};
+var gannFan_default = gannFan;
+
+// src/overlays/threeWaves.ts
+var threeWaves = {
+  name: "threeWaves",
+  totalStep: 5,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      text: `(${i})`,
+      baseline: "bottom"
+    }));
+    return [
+      { type: "line", attrs: { coordinates } },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var threeWaves_default = threeWaves;
+
+// src/overlays/fiveWaves.ts
+var fiveWaves = {
+  name: "fiveWaves",
+  totalStep: 7,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      text: `(${i})`,
+      baseline: "bottom"
+    }));
+    return [
+      { type: "line", attrs: { coordinates } },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var fiveWaves_default = fiveWaves;
+
+// src/overlays/eightWaves.ts
+var eightWaves = {
+  name: "eightWaves",
+  totalStep: 10,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      text: `(${i})`,
+      baseline: "bottom"
+    }));
+    return [
+      { type: "line", attrs: { coordinates } },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var eightWaves_default = eightWaves;
+
+// src/overlays/anyWaves.ts
+var anyWaves = {
+  name: "anyWaves",
+  totalStep: Number.MAX_SAFE_INTEGER,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      text: `(${i})`,
+      baseline: "bottom"
+    }));
+    return [
+      { type: "line", attrs: { coordinates } },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var anyWaves_default = anyWaves;
+
+// src/overlays/elliottWave.ts
+var elliottWave = {
+  name: "elliottWave",
+  totalStep: 6,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      const lines = [];
+      const texts = [];
+      for (let i = 0; i < coordinates.length - 1; i++) {
+        lines.push({
+          coordinates: [coordinates[i], coordinates[i + 1]]
+        });
+        texts.push({
+          ...coordinates[i],
+          text: `(${i})`,
+          align: "center",
+          baseline: "bottom"
+        });
+      }
+      if (coordinates.length === 6) {
+        texts.push({
+          ...coordinates[5],
+          text: "(5)",
+          align: "center",
+          baseline: "bottom"
+        });
+      }
+      return [
+        { type: "line", attrs: lines },
+        { type: "text", attrs: texts }
+      ];
+    }
+    return [];
+  }
+};
+var elliottWave_default = elliottWave;
+
+// src/overlays/abcd.ts
+var abcd = {
+  name: "abcd",
+  totalStep: 5,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    let acLineCoordinates = [];
+    let bdLineCoordinates = [];
+    const tags = ["A", "B", "C", "D"];
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      baseline: "bottom",
+      text: `(${tags[i]})`
+    }));
+    if (coordinates.length > 2) {
+      acLineCoordinates = [coordinates[0], coordinates[2]];
+      if (coordinates.length > 3) {
+        bdLineCoordinates = [coordinates[1], coordinates[3]];
+      }
+    }
+    return [
+      { type: "line", attrs: { coordinates } },
+      {
+        type: "line",
+        attrs: [
+          { coordinates: acLineCoordinates },
+          { coordinates: bdLineCoordinates }
+        ],
+        styles: { style: "dashed" }
+      },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var abcd_default = abcd;
+
+// src/overlays/xabcd.ts
+var xabcd = {
+  name: "xabcd",
+  totalStep: 6,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  styles: { polygon: { color: "rgba(22, 119, 255, 0.15)" } },
+  createPointFigures: ({ coordinates }) => {
+    const dashedLines = [];
+    const polygons = [];
+    const tags = ["X", "A", "B", "C", "D"];
+    const texts = coordinates.map((coordinate, i) => ({
+      ...coordinate,
+      baseline: "bottom",
+      text: `(${tags[i]})`
+    }));
+    if (coordinates.length > 2) {
+      dashedLines.push({ coordinates: [coordinates[0], coordinates[2]] });
+      polygons.push({
+        coordinates: [coordinates[0], coordinates[1], coordinates[2]]
+      });
+      if (coordinates.length > 3) {
+        dashedLines.push({ coordinates: [coordinates[1], coordinates[3]] });
+        if (coordinates.length > 4) {
+          dashedLines.push({ coordinates: [coordinates[2], coordinates[4]] });
+          polygons.push({
+            coordinates: [coordinates[2], coordinates[3], coordinates[4]]
+          });
+        }
+      }
+    }
+    return [
+      { type: "line", attrs: { coordinates } },
+      { type: "line", attrs: dashedLines, styles: { style: "dashed" } },
+      { type: "polygon", ignoreEvent: true, attrs: polygons },
+      { type: "text", ignoreEvent: true, attrs: texts }
+    ];
+  }
+};
+var xabcd_default = xabcd;
+
+// src/overlays/ray.ts
+var ray = {
+  name: "ray",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates, bounding }) => {
+    if (coordinates.length > 1) {
+      let coordinate = { x: 0, y: 0 };
+      if (coordinates[0].x === coordinates[1].x && coordinates[0].y !== coordinates[1].y) {
+        if (coordinates[0].y < coordinates[1].y) {
+          coordinate = { x: coordinates[0].x, y: bounding.height };
+        } else {
+          coordinate = { x: coordinates[0].x, y: 0 };
+        }
+      } else {
+        const x = coordinates[0].x < coordinates[1].x ? bounding.width : 0;
+        const y = (coordinates[1].y - coordinates[0].y) / (coordinates[1].x - coordinates[0].x) * (x - coordinates[0].x) + coordinates[0].y;
+        coordinate = { x, y };
+      }
+      return [
+        {
+          type: "line",
+          attrs: { coordinates: [coordinates[0], coordinate] }
+        }
+      ];
+    }
+    return [];
+  }
+};
+var ray_default = ray;
+
+// src/overlays/parallelChannel.ts
+var parallelChannel = {
+  name: "parallelChannel",
+  totalStep: 4,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: ({ coordinates }) => {
+    if (coordinates.length > 1) {
+      const p1 = coordinates[0];
+      const p2 = coordinates[1];
+      const p3 = coordinates[2] || p2;
+      const dx = p1.x - p2.x;
+      const dy = p1.y - p2.y;
+      const p4 = {
+        x: p3.x + dx,
+        y: p3.y + dy
+      };
+      return [
+        {
+          type: "line",
+          attrs: [
+            { coordinates: [p1, p2] },
+            { coordinates: [p3, p4] },
+            { coordinates: [p1, p4] },
+            { coordinates: [p2, p3] }
+          ]
+        },
+        {
+          type: "polygon",
+          attrs: { coordinates: [p1, p2, p3, p4] },
+          styles: { style: "fill" }
+        }
+      ];
+    }
+    return [];
+  }
+};
+var parallelChannel_default = parallelChannel;
+
+// src/overlays/longPosition.ts
+var longPosition = {
+  name: "longPosition",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: (params) => {
+    const { coordinates, overlay, yAxis } = params;
+    const figures = [];
+    if (coordinates.length > 1 && yAxis) {
+      const startX = coordinates[0].x;
+      const endX = coordinates[1].x;
+      const entryY = coordinates[0].y;
+      const targetY = coordinates[1].y;
+      const stopY = coordinates.length > 2 ? coordinates[2].y : entryY + 40;
+      const entryPrice = overlay.points[0].value;
+      const targetPrice = overlay.points[1].value;
+      const stopPrice = overlay.points[2]?.value ?? yAxis.convertFromPixel(stopY);
+      const reward = targetPrice - entryPrice;
+      const risk = entryPrice - stopPrice;
+      const rr = risk > 0 ? (reward / risk).toFixed(2) : "0.00";
+      const profitPercent = (reward / entryPrice * 100).toFixed(2);
+      const lossPercent = (risk / entryPrice * 100).toFixed(2);
+      figures.push({
+        type: "rect",
+        attrs: {
+          x: Math.min(startX, endX),
+          y: Math.min(entryY, targetY),
+          width: Math.abs(startX - endX),
+          height: Math.abs(entryY - targetY)
+        },
+        styles: { color: "rgba(38, 166, 154, 0.2)", style: "fill" }
+      });
+      figures.push({
+        type: "rect",
+        attrs: {
+          x: Math.min(startX, endX),
+          y: Math.min(entryY, stopY),
+          width: Math.abs(startX - endX),
+          height: Math.abs(entryY - stopY)
+        },
+        styles: { color: "rgba(239, 83, 80, 0.2)", style: "fill" }
+      });
+      figures.push({
+        type: "line",
+        attrs: {
+          coordinates: [
+            { x: startX, y: entryY },
+            { x: endX, y: entryY }
+          ]
+        },
+        styles: { color: "#888888", size: 2 }
+      });
+      figures.push({
+        type: "text",
+        attrs: {
+          x: endX,
+          y: targetY,
+          text: `Target: ${targetPrice.toFixed(2)} (${profitPercent}%)`,
+          align: "left",
+          baseline: "bottom"
+        },
+        styles: {
+          color: "#26a69a",
+          backgroundColor: "rgba(0,0,0,0.6)",
+          paddingLeft: 4,
+          paddingRight: 4
+        }
+      });
+      figures.push({
+        type: "text",
+        attrs: {
+          x: endX,
+          y: stopY,
+          text: `Stop: ${stopPrice.toFixed(2)} (${lossPercent}%)`,
+          align: "left",
+          baseline: "top"
+        },
+        styles: {
+          color: "#ef5350",
+          backgroundColor: "rgba(0,0,0,0.6)",
+          paddingLeft: 4,
+          paddingRight: 4
+        }
+      });
+      figures.push({
+        type: "text",
+        attrs: {
+          x: Math.min(startX, endX) + Math.abs(startX - endX) / 2,
+          y: entryY,
+          text: `R/R Ratio: ${rr}`,
+          align: "center",
+          baseline: "middle"
+        },
+        styles: {
+          color: "#ffffff",
+          backgroundColor: "rgba(0,0,0,0.8)",
+          paddingLeft: 6,
+          paddingRight: 6,
+          borderRadius: 2
+        }
+      });
+    }
+    return figures;
+  }
+};
+var longPosition_default = longPosition;
+
+// src/overlays/shortPosition.ts
+var shortPosition = {
+  name: "shortPosition",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: (params) => {
+    const { coordinates, overlay, yAxis } = params;
+    const figures = [];
+    if (coordinates.length > 1 && yAxis) {
+      const startX = coordinates[0].x;
+      const endX = coordinates[1].x;
+      const entryY = coordinates[0].y;
+      const targetY = coordinates[1].y;
+      const stopY = coordinates.length > 2 ? coordinates[2].y : entryY - 40;
+      const entryPrice = overlay.points[0].value;
+      const targetPrice = overlay.points[1].value;
+      const stopPrice = overlay.points[2]?.value ?? yAxis.convertFromPixel(stopY);
+      const reward = entryPrice - targetPrice;
+      const risk = stopPrice - entryPrice;
+      const rr = risk > 0 ? (reward / risk).toFixed(2) : "0.00";
+      const profitPercent = (reward / entryPrice * 100).toFixed(2);
+      const lossPercent = (risk / entryPrice * 100).toFixed(2);
+      figures.push({
+        type: "rect",
+        attrs: {
+          x: Math.min(startX, endX),
+          y: Math.min(entryY, targetY),
+          width: Math.abs(startX - endX),
+          height: Math.abs(entryY - targetY)
+        },
+        styles: { color: "rgba(38, 166, 154, 0.2)", style: "fill" }
+      });
+      figures.push({
+        type: "rect",
+        attrs: {
+          x: Math.min(startX, endX),
+          y: Math.min(entryY, stopY),
+          width: Math.abs(startX - endX),
+          height: Math.abs(entryY - stopY)
+        },
+        styles: { color: "rgba(239, 83, 80, 0.2)", style: "fill" }
+      });
+      figures.push({
+        type: "line",
+        attrs: {
+          coordinates: [
+            { x: startX, y: entryY },
+            { x: endX, y: entryY }
+          ]
+        },
+        styles: { color: "#888888", size: 2 }
+      });
+      figures.push({
+        type: "text",
+        attrs: {
+          x: endX,
+          y: targetY,
+          text: `Target: ${targetPrice.toFixed(2)} (${profitPercent}%)`,
+          align: "left",
+          baseline: "top"
+        },
+        styles: {
+          color: "#26a69a",
+          backgroundColor: "rgba(0,0,0,0.6)",
+          paddingLeft: 4,
+          paddingRight: 4
+        }
+      });
+      figures.push({
+        type: "text",
+        attrs: {
+          x: endX,
+          y: stopY,
+          text: `Stop: ${stopPrice.toFixed(2)} (${lossPercent}%)`,
+          align: "left",
+          baseline: "bottom"
+        },
+        styles: {
+          color: "#ef5350",
+          backgroundColor: "rgba(0,0,0,0.6)",
+          paddingLeft: 4,
+          paddingRight: 4
+        }
+      });
+      figures.push({
+        type: "text",
+        attrs: {
+          x: Math.min(startX, endX) + Math.abs(startX - endX) / 2,
+          y: entryY,
+          text: `R/R Ratio: ${rr}`,
+          align: "center",
+          baseline: "middle"
+        },
+        styles: {
+          color: "#ffffff",
+          backgroundColor: "rgba(0,0,0,0.8)",
+          paddingLeft: 6,
+          paddingRight: 6,
+          borderRadius: 2
+        }
+      });
+    }
+    return figures;
+  }
+};
+var shortPosition_default = shortPosition;
+
+// src/overlays/measure.ts
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  return `${minutes}m`;
+}
+var measure = {
+  name: "measure",
+  totalStep: 3,
+  needDefaultPointFigure: true,
+  needDefaultXAxisFigure: true,
+  needDefaultYAxisFigure: true,
+  createPointFigures: (params) => {
+    const { overlay, coordinates, yAxis } = params;
+    if (coordinates.length < 2 || !yAxis) return [];
+    const startPoint = overlay.points[0];
+    const endPoint = overlay.points[1];
+    const startCoord = coordinates[0];
+    const endCoord = coordinates[1];
+    const diff = endPoint.value - startPoint.value;
+    const percent = (diff / startPoint.value * 100).toFixed(2);
+    const bars = Math.abs(
+      (endPoint.dataIndex ?? 0) - (startPoint.dataIndex ?? 0)
+    );
+    const time = formatDuration(
+      Math.abs((endPoint.timestamp ?? 0) - (startPoint.timestamp ?? 0))
+    );
+    const isUp = diff >= 0;
+    const color = isUp ? "rgba(38, 166, 154, 0.2)" : "rgba(239, 83, 80, 0.2)";
+    const strokeColor = isUp ? "#26a69a" : "#ef5350";
+    const rectX = Math.min(startCoord.x, endCoord.x);
+    const rectY = Math.min(startCoord.y, endCoord.y);
+    const rectWidth = Math.abs(startCoord.x - endCoord.x);
+    const rectHeight = Math.abs(startCoord.y - endCoord.y);
+    const infoLines = [
+      `${isUp ? "\u25B2" : "\u25BC"} ${diff.toFixed(2)} (${percent}%)`,
+      `${bars} bars, ${time}`
+    ];
+    const textX = endCoord.x;
+    const textY = endCoord.y + (isUp ? -40 : 20);
+    const textFigures = infoLines.map((line, i) => ({
+      type: "text",
+      attrs: {
+        x: textX,
+        y: textY + i * 16,
+        text: line,
+        align: "center",
+        baseline: "middle"
+      },
+      styles: {
+        color: "#fff",
+        backgroundColor: strokeColor,
+        paddingLeft: 4,
+        paddingRight: 4,
+        paddingTop: 2,
+        paddingBottom: 2,
+        borderRadius: 2
+      }
+    }));
+    return [
+      {
+        type: "rect",
+        attrs: {
+          x: rectX,
+          y: rectY,
+          width: rectWidth,
+          height: rectHeight
+        },
+        styles: { style: "fill", color }
+      },
+      {
+        type: "line",
+        attrs: { coordinates: [startCoord, endCoord] },
+        styles: { color: strokeColor, style: "dash" }
+      },
+      ...textFigures
+    ];
+  }
+};
+var measure_default = measure;
+function getSqSegDist(p, p1, p2) {
+  let x = p1.x;
+  let y = p1.y;
+  let dx = p2.x - x;
+  let dy = p2.y - y;
+  if (dx !== 0 || dy !== 0) {
+    const t = ((p.x - x) * dx + (p.y - y) * dy) / (dx * dx + dy * dy);
+    if (t > 1) {
+      x = p2.x;
+      y = p2.y;
+    } else if (t > 0) {
+      x += dx * t;
+      y += dy * t;
+    }
+  }
+  dx = p.x - x;
+  dy = p.y - y;
+  return dx * dx + dy * dy;
+}
+function rdp(points, epsilon) {
+  const len = points.length;
+  if (len <= 2) return points;
+  const sqEpsilon = epsilon * epsilon;
+  const markers = new Uint8Array(len);
+  markers[0] = markers[len - 1] = 1;
+  const stack = [[0, len - 1]];
+  while (stack.length > 0) {
+    const [first, last] = stack.pop();
+    let maxSqDist = 0;
+    let index = 0;
+    for (let i = first + 1; i < last; i++) {
+      const sqDist = getSqSegDist(points[i], points[first], points[last]);
+      if (sqDist > maxSqDist) {
+        maxSqDist = sqDist;
+        index = i;
+      }
+    }
+    if (maxSqDist > sqEpsilon) {
+      markers[index] = 1;
+      stack.push([first, index]);
+      stack.push([index, last]);
+    }
+  }
+  const result = [];
+  for (let i = 0; i < len; i++) {
+    if (markers[i]) result.push(points[i]);
+  }
+  return result;
+}
+reactKlinecharts.registerFigure({
+  name: "brush_path",
+  draw: (ctx, attrs, styles) => {
+    const { coordinates } = attrs;
+    if (coordinates.length < 2) return;
+    ctx.save();
+    ctx.setLineDash([]);
+    ctx.strokeStyle = styles.color || "#f00";
+    ctx.lineWidth = styles.size || 2;
+    ctx.lineCap = "round";
+    ctx.lineJoin = "round";
+    ctx.beginPath();
+    ctx.moveTo(coordinates[0].x, coordinates[0].y);
+    if (coordinates.length === 2) {
+      ctx.lineTo(coordinates[1].x, coordinates[1].y);
+    } else {
+      for (let i = 1; i < coordinates.length - 2; i++) {
+        const xc = (coordinates[i].x + coordinates[i + 1].x) / 2;
+        const yc = (coordinates[i].y + coordinates[i + 1].y) / 2;
+        ctx.quadraticCurveTo(coordinates[i].x, coordinates[i].y, xc, yc);
+      }
+      const last = coordinates.length - 2;
+      ctx.quadraticCurveTo(
+        coordinates[last].x,
+        coordinates[last].y,
+        coordinates[last + 1].x,
+        coordinates[last + 1].y
+      );
+    }
+    ctx.stroke();
+    ctx.restore();
+  },
+  checkEventOn: (coordinate, attrs, styles) => {
+    const { coordinates } = attrs;
+    if (!coordinates || coordinates.length < 2) return false;
+    const radius = (styles?.size ?? 2) / 2 + 4;
+    const sqRadius = radius * radius;
+    for (let i = 0; i < coordinates.length - 1; i++) {
+      const sqDist = getSqSegDist(
+        coordinate,
+        coordinates[i],
+        coordinates[i + 1]
+      );
+      if (sqDist <= sqRadius) return true;
+    }
+    return false;
+  }
+});
+var brush = {
+  name: "brush",
+  totalStep: 3,
+  needDefaultPointFigure: false,
+  needDefaultXAxisFigure: false,
+  needDefaultYAxisFigure: false,
+  onDrawing: (params) => {
+    const { overlay, x, y } = params;
+    const paneId = params.paneId;
+    if (x === void 0 || y === void 0) return true;
+    if (overlay.currentStep !== 2) return true;
+    if (!overlay.extendData) {
+      overlay.extendData = {
+        pixels: [],
+        points: [],
+        isDirty: false,
+        paneId
+      };
+    }
+    const data = overlay.extendData;
+    if (data.paneId && data.paneId !== paneId) return true;
+    const lastPixel = data.pixels[data.pixels.length - 1];
+    if (lastPixel) {
+      const dx = x - lastPixel.x;
+      const dy = y - lastPixel.y;
+      if (dx * dx + dy * dy < 4) return true;
+    }
+    data.pixels.push({ x, y });
+    return true;
+  },
+  onDrawEnd: (params) => {
+    const { overlay } = params;
+    const data = overlay.extendData;
+    if (data) {
+      data.isDirty = true;
+    }
+    return true;
+  },
+  createPointFigures: ({ overlay, xAxis, yAxis, defaultStyles }) => {
+    const data = overlay.extendData;
+    if (!data || !xAxis || !yAxis) return [];
+    if (data.pixels.length > 0) {
+      for (const p of data.pixels) {
+        data.points.push({
+          timestamp: xAxis.convertFromPixel(p.x),
+          value: yAxis.convertFromPixel(p.y)
+        });
+      }
+      data.pixels = [];
+    }
+    let { points } = data;
+    if (data.isDirty && points.length > 2) {
+      const pixelPoints = points.map((p) => ({
+        x: xAxis.convertToPixel(p.timestamp),
+        y: yAxis.convertToPixel(p.value)
+      }));
+      const simplified = rdp(pixelPoints, 1.5);
+      data.points = simplified.map((p) => ({
+        timestamp: xAxis.convertFromPixel(p.x),
+        value: yAxis.convertFromPixel(p.y)
+      }));
+      points = data.points;
+      data.isDirty = false;
+    }
+    if (points.length < 2) return [];
+    const coordinates = points.map((p) => ({
+      x: xAxis.convertToPixel(p.timestamp),
+      y: yAxis.convertToPixel(p.value)
+    }));
+    return [
+      {
+        type: "brush_path",
+        attrs: { coordinates },
+        styles: {
+          color: overlay.styles?.line?.color ?? defaultStyles?.line?.color ?? "#1677ff",
+          size: overlay.styles?.line?.size ?? defaultStyles?.line?.size ?? 2
+        }
+      }
+    ];
+  }
+};
+var brush_default = brush;
+
+// src/indicators/index.ts
+var indicators_exports = {};
+__export(indicators_exports, {
+  bollTv: () => bollTv_default,
+  cci: () => cci_default,
+  hma: () => hma_default,
+  ichimoku: () => ichimoku_default,
+  maRibbon: () => maRibbon_default,
+  macdTv: () => macdTv_default,
+  pivotPoints: () => pivotPoints_default,
+  rsiTv: () => rsiTv_default,
+  stochastic: () => stochastic_default,
+  superTrend: () => superTrend_default,
+  vwap: () => vwap_default
+});
+
+// src/utils/TA.ts
+var TA = {
+  /**
+   * Simple Moving Average (SMA)
+   * Optimized with running sum.
+   */
+  sma: (data, period) => {
+    const result = [];
+    let sum = 0;
+    for (let i = 0; i < data.length; i++) {
+      sum += data[i];
+      if (i >= period) {
+        sum -= data[i - period];
+      }
+      if (i >= period - 1) {
+        result.push(sum / period);
+      } else {
+        result.push(null);
+      }
+    }
+    return result;
+  },
+  /**
+   * Exponential Moving Average (EMA)
+   * alpha = 2 / (period + 1)
+   */
+  ema: (data, period) => {
+    const result = [];
+    const alpha = 2 / (period + 1);
+    let prevEma = null;
+    for (let i = 0; i < data.length; i++) {
+      if (prevEma === null) {
+        if (i === period - 1) {
+          let sum = 0;
+          for (let j = 0; j <= i; j++) sum += data[j];
+          prevEma = sum / period;
+          result.push(prevEma);
+        } else {
+          result.push(null);
+        }
+      } else {
+        prevEma = data[i] * alpha + prevEma * (1 - alpha);
+        result.push(prevEma);
+      }
+    }
+    return result;
+  },
+  /**
+   * Running Moving Average (RMA / Wilder's MA)
+   * Used in RSI, alpha = 1 / period
+   */
+  rma: (data, period) => {
+    const result = [];
+    const alpha = 1 / period;
+    let prevRma = null;
+    for (let i = 0; i < data.length; i++) {
+      if (prevRma === null) {
+        if (i === period - 1) {
+          let sum = 0;
+          for (let j = 0; j <= i; j++) sum += data[j];
+          prevRma = sum / period;
+          result.push(prevRma);
+        } else {
+          result.push(null);
+        }
+      } else {
+        prevRma = data[i] * alpha + prevRma * (1 - alpha);
+        result.push(prevRma);
+      }
+    }
+    return result;
+  },
+  /**
+   * Standard Deviation
+   */
+  stdev: (data, period) => {
+    const result = [];
+    const sma = TA.sma(data, period);
+    for (let i = 0; i < data.length; i++) {
+      const currentSma = sma[i];
+      if (currentSma === null) {
+        result.push(null);
+      } else {
+        let sumSq = 0;
+        for (let j = 0; j < period; j++) {
+          sumSq += Math.pow(data[i - j] - currentSma, 2);
+        }
+        result.push(Math.sqrt(sumSq / period));
+      }
+    }
+    return result;
+  },
+  /**
+   * Relative Strength Index (RSI)
+   */
+  rsi: (data, period) => {
+    const changes = [0];
+    for (let i = 1; i < data.length; i++) {
+      changes.push(data[i] - data[i - 1]);
+    }
+    const ups = changes.map((c) => Math.max(c, 0));
+    const downs = changes.map((c) => Math.max(-c, 0));
+    const avgUps = TA.rma(ups, period);
+    const avgDowns = TA.rma(downs, period);
+    return avgUps.map((up, i) => {
+      const down = avgDowns[i];
+      if (up === null || down === null) return null;
+      if (down === 0) return 100;
+      const rs = up / down;
+      return 100 - 100 / (1 + rs);
+    });
+  },
+  /**
+   * Moving Average Convergence Divergence (MACD)
+   */
+  macd: (data, fastPeriod, slowPeriod, signalPeriod) => {
+    const fastEma = TA.ema(data, fastPeriod);
+    const slowEma = TA.ema(data, slowPeriod);
+    const dif = fastEma.map(
+      (f, i) => f !== null && slowEma[i] !== null ? f - slowEma[i] : null
+    );
+    const dea = TA.ema(
+      dif.filter((v) => v !== null),
+      signalPeriod
+    );
+    let deaIdx = 0;
+    const fullDea = dif.map((v) => v === null ? null : dea[deaIdx++]);
+    const macd = dif.map(
+      (v, i) => v !== null && fullDea[i] !== null ? v - fullDea[i] : null
+    );
+    return { dif, dea: fullDea, macd };
+  },
+  /**
+   * Bollinger Bands (BOLL)
+   */
+  bollinger: (data, period, multiplier) => {
+    const mid = TA.sma(data, period);
+    const std = TA.stdev(data, period);
+    const upper = mid.map(
+      (m, i) => m !== null && std[i] !== null ? m + multiplier * std[i] : null
+    );
+    const lower = mid.map(
+      (m, i) => m !== null && std[i] !== null ? m - multiplier * std[i] : null
+    );
+    return { mid, upper, lower };
+  },
+  /**
+   * Weighted Moving Average (WMA)
+   */
+  wma: (data, period) => {
+    const result = [];
+    let sumWeight = 0;
+    for (let i = 1; i <= period; i++) sumWeight += i;
+    for (let i = 0; i < data.length; i++) {
+      if (i < period - 1) {
+        result.push(null);
+      } else {
+        let sum = 0;
+        for (let j = 0; j < period; j++) {
+          sum += data[i - j] * (period - j);
+        }
+        result.push(sum / sumWeight);
+      }
+    }
+    return result;
+  },
+  /**
+   * True Range (TR)
+   */
+  tr: (highs, lows, closes) => {
+    const result = [];
+    for (let i = 0; i < highs.length; i++) {
+      if (i === 0) {
+        result.push(highs[i] - lows[i]);
+      } else {
+        const tr = Math.max(
+          highs[i] - lows[i],
+          Math.abs(highs[i] - closes[i - 1]),
+          Math.abs(lows[i] - closes[i - 1])
+        );
+        result.push(tr);
+      }
+    }
+    return result;
+  },
+  /**
+   * Average True Range (ATR)
+   */
+  atr: (highs, lows, closes, period) => {
+    const tr = TA.tr(highs, lows, closes);
+    return TA.rma(tr, period);
+  },
+  /**
+   * Volume Weighted Average Price (VWAP)
+   */
+  vwap: (highs, lows, closes, volumes) => {
+    let totalVolume = 0;
+    let totalVolumePrice = 0;
+    return highs.map((h, i) => {
+      const price = (h + lows[i] + closes[i]) / 3;
+      totalVolume += volumes[i];
+      totalVolumePrice += price * volumes[i];
+      return totalVolume === 0 ? price : totalVolumePrice / totalVolume;
+    });
+  },
+  /**
+   * Commodity Channel Index (CCI)
+   */
+  cci: (highs, lows, closes, period) => {
+    const tp = highs.map((h, i) => (h + lows[i] + closes[i]) / 3);
+    const smaTp = TA.sma(tp, period);
+    const result = [];
+    for (let i = 0; i < tp.length; i++) {
+      const currentSma = smaTp[i];
+      if (currentSma === null) {
+        result.push(null);
+      } else {
+        let meanDev = 0;
+        for (let j = 0; j < period; j++) {
+          meanDev += Math.abs(tp[i - j] - currentSma);
+        }
+        meanDev /= period;
+        if (meanDev === 0) {
+          result.push(0);
+        } else {
+          result.push((tp[i] - currentSma) / (0.015 * meanDev));
+        }
+      }
+    }
+    return result;
+  },
+  /**
+   * Hull Moving Average (HMA)
+   */
+  hma: (data, period) => {
+    const halfPeriod = Math.floor(period / 2);
+    const sqrtPeriod = Math.floor(Math.sqrt(period));
+    const wma1 = TA.wma(data, halfPeriod);
+    const wma2 = TA.wma(data, period);
+    const diff = wma1.map((v, i) => {
+      if (v !== null && wma2[i] !== null) {
+        return 2 * v - wma2[i];
+      }
+      return null;
+    });
+    const diffValues = diff.filter((v) => v !== null);
+    const finalHma = TA.wma(diffValues, sqrtPeriod);
+    let finalIndex = 0;
+    return diff.map((v) => {
+      if (v === null) return null;
+      return finalHma[finalIndex++] ?? null;
+    });
+  }
+};
+var TA_default = TA;
+
+// src/indicators/bollTv.ts
+var bollTv = {
+  name: "BOLL_TV",
+  shortName: "BOLL (TV)",
+  calcParams: [20, 2],
+  figures: [
+    { key: "mid", title: "Mid: ", type: "line" },
+    { key: "upper", title: "Upper: ", type: "line" },
+    { key: "lower", title: "Lower: ", type: "line" }
+  ],
+  calc: (dataList, indicator) => {
+    const period = indicator.calcParams[0];
+    const multiplier = indicator.calcParams[1];
+    const closes = dataList.map((d) => d.close);
+    const { mid, upper, lower } = TA_default.bollinger(closes, period, multiplier);
+    return dataList.map((_, i) => ({
+      mid: mid[i],
+      upper: upper[i],
+      lower: lower[i]
+    }));
+  }
+};
+var bollTv_default = bollTv;
+
+// src/indicators/cci.ts
+var cci = {
+  name: "CCI_TV",
+  shortName: "CCI",
+  calcParams: [20],
+  figures: [{ key: "cci", title: "CCI: ", type: "line" }],
+  calc: (dataList, indicator) => {
+    const period = indicator.calcParams[0];
+    const highs = dataList.map((d) => d.high);
+    const lows = dataList.map((d) => d.low);
+    const closes = dataList.map((d) => d.close);
+    const cciValues = TA_default.cci(highs, lows, closes, period);
+    return cciValues.map((v) => ({ cci: v }));
+  }
+};
+var cci_default = cci;
+
+// src/indicators/hma.ts
+var hma = {
+  name: "HMA",
+  shortName: "HMA",
+  calcParams: [9],
+  figures: [{ key: "hma", title: "HMA: ", type: "line" }],
+  calc: (dataList, indicator) => {
+    const period = indicator.calcParams[0];
+    const halfPeriod = Math.floor(period / 2);
+    const sqrtPeriod = Math.floor(Math.sqrt(period));
+    const closes = dataList.map((d) => d.close);
+    const wma1 = TA_default.wma(closes, halfPeriod);
+    const wma2 = TA_default.wma(closes, period);
+    const diff = wma1.map((v, i) => {
+      if (v !== null && wma2[i] !== null) {
+        return 2 * v - wma2[i];
+      }
+      return null;
+    });
+    const diffValues = diff.filter((v) => v !== null);
+    const finalHma = TA_default.wma(diffValues, sqrtPeriod);
+    let finalIndex = 0;
+    return diff.map((v) => {
+      if (v === null) return { hma: null };
+      const res = finalHma[finalIndex++];
+      return { hma: res };
+    });
+  }
+};
+var hma_default = hma;
+
+// src/indicators/ichimoku.ts
+var ichimoku = {
+  name: "Ichimoku",
+  shortName: "Ichimoku",
+  calcParams: [9, 26, 52, 26],
+  figures: [
+    { key: "tenkan", title: "Tenkan: ", type: "line" },
+    { key: "kijun", title: "Kijun: ", type: "line" },
+    { key: "chikou", title: "Chikou: ", type: "line" },
+    { key: "spanA", title: "Span A: ", type: "line" },
+    { key: "spanB", title: "Span B: ", type: "line" }
+  ],
+  calc: (dataList, indicator) => {
+    const params = indicator.calcParams;
+    const tenkanPeriod = params[0];
+    const kijunPeriod = params[1];
+    const spanBPeriod = params[2];
+    const offset = params[3];
+    const highLowAvg = (data, start, end) => {
+      let high = -Infinity;
+      let low = Infinity;
+      for (let i = start; i <= end; i++) {
+        high = Math.max(high, data[i].high);
+        low = Math.min(low, data[i].low);
+      }
+      return (high + low) / 2;
+    };
+    return dataList.map((_kLineData, index) => {
+      const item = {
+        tenkan: null,
+        kijun: null,
+        chikou: null,
+        spanA: null,
+        spanB: null
+      };
+      if (index >= tenkanPeriod - 1) {
+        item.tenkan = highLowAvg(
+          dataList,
+          index - tenkanPeriod + 1,
+          index
+        );
+      }
+      if (index >= kijunPeriod - 1) {
+        item.kijun = highLowAvg(dataList, index - kijunPeriod + 1, index);
+      }
+      if (index + offset < dataList.length) {
+        item.chikou = dataList[index + offset].close;
+      }
+      const prevIndex = index - offset;
+      if (prevIndex >= 0) {
+        const prevTenkan = prevIndex >= tenkanPeriod - 1 ? highLowAvg(dataList, prevIndex - tenkanPeriod + 1, prevIndex) : null;
+        const prevKijun = prevIndex >= kijunPeriod - 1 ? highLowAvg(dataList, prevIndex - kijunPeriod + 1, prevIndex) : null;
+        if (prevTenkan !== null && prevKijun !== null) {
+          item.spanA = (prevTenkan + prevKijun) / 2;
+        }
+        if (prevIndex >= spanBPeriod - 1) {
+          item.spanB = highLowAvg(
+            dataList,
+            prevIndex - spanBPeriod + 1,
+            prevIndex
+          );
+        }
+      }
+      return item;
+    });
+  }
+};
+var ichimoku_default = ichimoku;
+
+// src/indicators/maRibbon.ts
+var COLORS = [
+  "#001CFF",
+  "#0055FF",
+  "#008CFF",
+  "#00C4FF",
+  "#00FFED",
+  "#00FF8E",
+  "#2EFF00",
+  "#B7FF00",
+  "#FFE100",
+  "#FF9100",
+  "#FF4400",
+  "#FF0000",
+  "#C4003E",
+  "#8A007B",
+  "#4E00B8"
+];
+var maRibbon = {
+  name: "MA_Ribbon",
+  shortName: "Ribbon",
+  series: "price",
+  calcParams: [10, 20, 30, 40],
+  figures: Array.from({ length: 15 }).map((_, i) => ({
+    key: `ma${i}`,
+    title: `MA${i + 1}: `,
+    type: "line",
+    styles: () => ({ color: COLORS[i] })
+  })),
+  calc: (dataList, indicator) => {
+    const params = indicator.calcParams;
+    const closes = dataList.map((d) => d.close);
+    const count = Math.min(params.length, COLORS.length);
+    const emas = [];
+    for (let i = 0; i < count; i++) {
+      emas.push(TA_default.ema(closes, params[i]));
+    }
+    return dataList.map((_, i) => {
+      const barData = {};
+      for (let j = 0; j < count; j++) {
+        barData[`ma${j}`] = emas[j][i];
+      }
+      return barData;
+    });
+  }
+};
+var maRibbon_default = maRibbon;
+
+// src/indicators/macdTv.ts
+var macdTv = {
+  name: "MACD_TV",
+  shortName: "MACD (TV)",
+  calcParams: [12, 26, 9],
+  figures: [
+    {
+      key: "histogram",
+      title: "Histogram: ",
+      type: "bar",
+      baseValue: 0,
+      styles: (data) => {
+        const current = data.current?.histogram ?? 0;
+        const pre = data.prev?.histogram ?? 0;
+        let color = "#26A69A";
+        if (current > 0) {
+          color = current > pre ? "#26A69A" : "#B2DFDB";
+        } else if (current < 0) {
+          color = current < pre ? "#FF5252" : "#FFCDD2";
+        } else {
+          color = "#B2DFDB";
+        }
+        return { color };
+      }
+    },
+    {
+      key: "macd",
+      title: "MACD: ",
+      type: "line",
+      styles: () => ({ color: "#2962FF" })
+    },
+    {
+      key: "signal",
+      title: "Signal: ",
+      type: "line",
+      styles: () => ({ color: "#FF6D00" })
+    }
+  ],
+  calc: (dataList, indicator) => {
+    const fast = indicator.calcParams[0];
+    const slow = indicator.calcParams[1];
+    const signalLen = indicator.calcParams[2];
+    const closes = dataList.map((d) => d.close);
+    const { dif, dea, macd } = TA_default.macd(closes, fast, slow, signalLen);
+    return dataList.map((_, i) => ({
+      macd: dif[i],
+      signal: dea[i],
+      histogram: macd[i]
+    }));
+  }
+};
+var macdTv_default = macdTv;
+
+// src/indicators/pivotPoints.ts
+var pivotPoints = {
+  name: "PivotPoints",
+  shortName: "Pivot",
+  calcParams: [],
+  figures: [
+    { key: "p", title: "P: ", type: "line" },
+    { key: "r1", title: "R1: ", type: "line" },
+    { key: "s1", title: "S1: ", type: "line" },
+    { key: "r2", title: "R2: ", type: "line" },
+    { key: "s2", title: "S2: ", type: "line" }
+  ],
+  calc: (dataList) => {
+    let lastP = null;
+    let lastR1 = null;
+    let lastS1 = null;
+    let lastR2 = null;
+    let lastS2 = null;
+    let lastDate = "";
+    let dayHigh = -Infinity;
+    let dayLow = Infinity;
+    let dayClose = 0;
+    return dataList.map((kLineData) => {
+      const date = new Date(kLineData.timestamp).toLocaleDateString();
+      if (date !== lastDate) {
+        if (lastDate !== "") {
+          lastP = (dayHigh + dayLow + dayClose) / 3;
+          lastR1 = 2 * lastP - dayLow;
+          lastS1 = 2 * lastP - dayHigh;
+          lastR2 = lastP + (dayHigh - dayLow);
+          lastS2 = lastP - (dayHigh - dayLow);
+        }
+        dayHigh = kLineData.high;
+        dayLow = kLineData.low;
+        dayClose = kLineData.close;
+        lastDate = date;
+      } else {
+        dayHigh = Math.max(dayHigh, kLineData.high);
+        dayLow = Math.min(dayLow, kLineData.low);
+        dayClose = kLineData.close;
+      }
+      return {
+        p: lastP,
+        r1: lastR1,
+        s1: lastS1,
+        r2: lastR2,
+        s2: lastS2
+      };
+    });
+  }
+};
+var pivotPoints_default = pivotPoints;
+
+// src/indicators/rsiTv.ts
+var rsiTv = {
+  name: "RSI_TV",
+  shortName: "RSI (TV)",
+  calcParams: [14, 14],
+  figures: [
+    {
+      key: "rsi",
+      title: "RSI: ",
+      type: "line",
+      styles: () => ({ color: "#7E57C2", size: 1.5 })
+    },
+    {
+      key: "rsi_ma",
+      title: "MA: ",
+      type: "line",
+      styles: () => ({ color: "#FFEE58", size: 1.2 })
+    }
+  ],
+  calc: (dataList, indicator) => {
+    const rsiPeriod = indicator.calcParams[0];
+    const maPeriod = indicator.calcParams[1];
+    const closes = dataList.map((d) => d.close);
+    const rsiValues = TA_default.rsi(closes, rsiPeriod);
+    const nonNullRsi = rsiValues.map((v) => v ?? 0);
+    const maValues = TA_default.sma(nonNullRsi, maPeriod);
+    return dataList.map((_, i) => {
+      const rsi = rsiValues[i];
+      const rsi_ma = rsi !== null && maValues[i] !== null ? maValues[i] : null;
+      return { rsi, rsi_ma };
+    });
+  },
+  draw: ({
+    ctx,
+    chart,
+    indicator,
+    bounding,
+    yAxis
+  }) => {
+    const { from, to } = chart.getVisibleRange();
+    const barSpace = chart.getBarSpace();
+    const resultData = indicator.result;
+    const y70 = yAxis.convertToPixel(70);
+    const y50 = yAxis.convertToPixel(50);
+    const y30 = yAxis.convertToPixel(30);
+    const left = bounding.left;
+    const right = bounding.left + bounding.width;
+    const getX = (i) => right - barSpace.halfBar - (to - 1 - i) * barSpace.bar;
+    ctx.save();
+    const fillZone = (yThreshold, above, gradFrom, gradTo) => {
+      const compare = above ? (v) => v > 70 : (v) => v < 30;
+      let i = from;
+      while (i < to) {
+        while (i < to) {
+          const d = resultData[i];
+          const v = d?.rsi;
+          if (v !== null && v !== void 0 && compare(v)) break;
+          i++;
+        }
+        if (i >= to) break;
+        const pts = [];
+        while (i < to) {
+          const d = resultData[i];
+          const v = d?.rsi;
+          if (v === null || v === void 0 || !compare(v)) break;
+          pts.push({ x: getX(i), y: yAxis.convertToPixel(v) });
+          i++;
+        }
+        if (pts.length === 0) continue;
+        ctx.beginPath();
+        ctx.moveTo(pts[0].x, yThreshold);
+        for (const p of pts) ctx.lineTo(p.x, p.y);
+        ctx.lineTo(pts[pts.length - 1].x, yThreshold);
+        ctx.closePath();
+        const gradY1 = yThreshold;
+        const gradY2 = above ? Math.min(...pts.map((p) => p.y)) - 5 : Math.max(...pts.map((p) => p.y)) + 5;
+        const grad = ctx.createLinearGradient(0, gradY1, 0, gradY2);
+        grad.addColorStop(0, gradFrom);
+        grad.addColorStop(1, gradTo);
+        ctx.globalAlpha = 1;
+        ctx.fillStyle = grad;
+        ctx.fill();
+      }
+    };
+    fillZone(
+      y70,
+      true,
+      "rgba(239,83,80,0.0)",
+      "rgba(239,83,80,0.35)"
+    );
+    fillZone(
+      y30,
+      false,
+      "rgba(38,166,154,0.0)",
+      "rgba(38,166,154,0.35)"
+    );
+    const drawDash = (y, color, alpha) => {
+      ctx.beginPath();
+      ctx.globalAlpha = alpha;
+      ctx.setLineDash([5, 4]);
+      ctx.strokeStyle = color;
+      ctx.lineWidth = 1;
+      ctx.moveTo(left, y);
+      ctx.lineTo(right, y);
+      ctx.stroke();
+    };
+    ctx.globalAlpha = 1;
+    drawDash(y70, "#EF5350", 0.7);
+    drawDash(y30, "#26A69A", 0.7);
+    drawDash(y50, "#aaaaaa", 0.3);
+    ctx.restore();
+    return false;
+  }
+};
+var rsiTv_default = rsiTv;
+
+// src/indicators/stochastic.ts
+function rollingMinMax(data, period) {
+  const min = [];
+  const max = [];
+  for (let i = 0; i < data.length; i++) {
+    if (i < period - 1) {
+      min.push(NaN);
+      max.push(NaN);
+    } else {
+      let lo = data[i];
+      let hi = data[i];
+      for (let j = 1; j < period; j++) {
+        if (data[i - j] < lo) lo = data[i - j];
+        if (data[i - j] > hi) hi = data[i - j];
+      }
+      min.push(lo);
+      max.push(hi);
+    }
+  }
+  return { min, max };
+}
+function smaWithNaN(data, period) {
+  const result = [];
+  let sum = 0;
+  let count = 0;
+  let windowStart = 0;
+  for (let i = 0; i < data.length; i++) {
+    if (!isNaN(data[i])) {
+      sum += data[i];
+      count++;
+    }
+    if (i >= period) {
+      if (!isNaN(data[windowStart])) {
+        sum -= data[windowStart];
+        count--;
+      }
+      windowStart++;
+    }
+    result.push(count === period ? sum / period : NaN);
+  }
+  return result;
+}
+var stochastic = {
+  name: "Stochastic",
+  shortName: "STOCH",
+  calcParams: [14, 3, 3],
+  figures: [
+    { key: "k", title: "%K: ", type: "line" },
+    { key: "d", title: "%D: ", type: "line" }
+  ],
+  calc: (dataList, indicator) => {
+    const [period, smoothK, smoothD] = indicator.calcParams;
+    const highs = dataList.map((d) => d.high);
+    const lows = dataList.map((d) => d.low);
+    const closes = dataList.map((d) => d.close);
+    const { min: lowestLow } = rollingMinMax(lows, period);
+    const { max: highestHigh } = rollingMinMax(highs, period);
+    const rawK = closes.map((c, i) => {
+      const lo = lowestLow[i];
+      const hi = highestHigh[i];
+      if (isNaN(lo) || isNaN(hi) || hi === lo) return null;
+      return (c - lo) / (hi - lo) * 100;
+    });
+    const validK = rawK.map((v) => v ?? NaN);
+    const kSmoothed = smaWithNaN(validK, smoothK);
+    const dLine = smaWithNaN(kSmoothed, smoothD);
+    return kSmoothed.map((k, i) => ({
+      k: isNaN(k) ? null : k,
+      d: isNaN(dLine[i]) ? null : dLine[i]
+    }));
+  }
+};
+var stochastic_default = stochastic;
+
+// src/indicators/superTrend.ts
+var superTrend = {
+  name: "SuperTrend",
+  shortName: "SuperTrend",
+  calcParams: [10, 3],
+  figures: [
+    { key: "up", title: "Up: ", type: "line" },
+    { key: "down", title: "Down: ", type: "line" }
+  ],
+  calc: (dataList, indicator) => {
+    const period = indicator.calcParams[0];
+    const factor = indicator.calcParams[1];
+    const highs = dataList.map((d) => d.high);
+    const lows = dataList.map((d) => d.low);
+    const closes = dataList.map((d) => d.close);
+    const atr = TA_default.atr(highs, lows, closes, period);
+    let trend = 1;
+    let up = 0;
+    let down = 0;
+    return dataList.map((kLineData, index) => {
+      const currentAtr = atr[index];
+      if (currentAtr === null) return { up: null, down: null };
+      const mid = (kLineData.high + kLineData.low) / 2;
+      const basicUpper = mid + factor * currentAtr;
+      const basicLower = mid - factor * currentAtr;
+      if (index === 0 || atr[index - 1] === null) {
+        up = basicUpper;
+        down = basicLower;
+      } else {
+        const prevUp = up;
+        const prevDown = down;
+        const prevClose = dataList[index - 1].close;
+        up = basicUpper < prevUp || prevClose > prevUp ? basicUpper : prevUp;
+        down = basicLower > prevDown || prevClose < prevDown ? basicLower : prevDown;
+      }
+      if (trend === 1 && kLineData.close < down) {
+        trend = -1;
+      } else if (trend === -1 && kLineData.close > up) {
+        trend = 1;
+      }
+      return {
+        up: trend === 1 ? down : null,
+        down: trend === -1 ? up : null
+      };
+    });
+  }
+};
+var superTrend_default = superTrend;
+
+// src/indicators/vwap.ts
+var vwap = {
+  name: "VWAP",
+  shortName: "VWAP",
+  calcParams: [],
+  figures: [{ key: "vwap", title: "VWAP: ", type: "line" }],
+  calc: (dataList) => {
+    let cumulativeVolume = 0;
+    let cumulativePriceVolume = 0;
+    let lastDate = "";
+    return dataList.map((kLineData) => {
+      const date = new Date(kLineData.timestamp).toLocaleDateString();
+      if (date !== lastDate) {
+        cumulativeVolume = 0;
+        cumulativePriceVolume = 0;
+        lastDate = date;
+      }
+      const price = (kLineData.high + kLineData.low + kLineData.close) / 3;
+      cumulativeVolume += kLineData.volume ?? 0;
+      cumulativePriceVolume += price * (kLineData.volume ?? 0);
+      return {
+        vwap: cumulativePriceVolume / (cumulativeVolume || 1)
+      };
+    });
+  }
+};
+var vwap_default = vwap;
+
+// src/extensions/overlays/orderLine.ts
+var DEFAULT_FONT_FAMILY = "Helvetica Neue, Arial, sans-serif";
+var orderLine = {
+  name: "orderLine",
+  totalStep: 2,
+  needDefaultPointFigure: false,
+  needDefaultXAxisFigure: false,
+  needDefaultYAxisFigure: false,
+  createYAxisFigures: ({ chart, overlay, coordinates }) => {
+    if (coordinates.length < 1) return [];
+    const y = coordinates[0].y;
+    const price = overlay.points[0]?.value;
+    if (price == null) return [];
+    const d = overlay.extendData ?? {};
+    const color = d.color ?? "rgba(255, 165, 0, 0.85)";
+    const m = d.mark;
+    const precision = chart.getSymbol()?.pricePrecision ?? 2;
+    return [
+      {
+        type: "text",
+        attrs: {
+          x: 0,
+          y,
+          text: price.toFixed(precision),
+          align: "left",
+          baseline: "middle"
+        },
+        styles: {
+          color: m?.color ?? "#ffffff",
+          size: m?.font?.size ?? 11,
+          family: m?.font?.family ?? DEFAULT_FONT_FAMILY,
+          weight: m?.font?.weight ?? "bold",
+          paddingLeft: m?.padding?.x ?? 4,
+          paddingRight: m?.padding?.x ?? 4,
+          paddingTop: m?.padding?.y ?? 4,
+          paddingBottom: m?.padding?.y ?? 4,
+          backgroundColor: m?.bg ?? color,
+          borderRadius: m?.borderRadius ?? 2
+        }
+      }
+    ];
+  },
+  createPointFigures: ({ coordinates, bounding, overlay }) => {
+    if (coordinates.length < 1) return [];
+    const y = coordinates[0].y;
+    const d = overlay.extendData ?? {};
+    const color = d.color ?? "rgba(255, 165, 0, 0.85)";
+    const ln = d.line;
+    const figures = [
+      {
+        type: "line",
+        attrs: {
+          coordinates: [
+            { x: 0, y },
+            { x: bounding.width, y }
+          ]
+        },
+        styles: {
+          style: ln?.style ?? "dashed",
+          color,
+          size: ln?.width ?? 1,
+          dashedValue: ln?.dashedValue ?? [4, 2]
+        }
+      }
+    ];
+    if (d.text) {
+      const lb = d.label;
+      figures.push({
+        type: "text",
+        ignoreEvent: true,
+        attrs: {
+          x: lb?.offset?.x ?? 8,
+          y: y - (lb?.offset?.y ?? 3),
+          text: d.text,
+          align: "left",
+          baseline: "bottom"
+        },
+        styles: {
+          color: lb?.color ?? color,
+          size: lb?.font?.size ?? 11,
+          family: lb?.font?.family ?? DEFAULT_FONT_FAMILY,
+          weight: lb?.font?.weight ?? "normal",
+          paddingLeft: lb?.padding?.x ?? 0,
+          paddingRight: lb?.padding?.x ?? 0,
+          paddingTop: lb?.padding?.y ?? 0,
+          paddingBottom: lb?.padding?.y ?? 0,
+          backgroundColor: lb?.bg ?? "transparent",
+          borderRadius: lb?.borderRadius ?? 0
+        }
+      });
+    }
+    return figures;
+  },
+  performEventPressedMove: ({ points, performPoint }) => {
+    points[0].value = performPoint.value;
+  }
+};
+var orderLine_default = orderLine;
+
+// src/extensions/index.ts
+var overlays = Object.values(overlays_exports);
+var indicators = Object.values(indicators_exports);
+var registered = false;
+function registerExtensions() {
+  if (registered) return;
+  overlays.forEach((overlay) => reactKlinecharts.registerOverlay(overlay));
+  indicators.forEach((indicator) => reactKlinecharts.registerIndicator(indicator));
+  registered = true;
+}
+
+exports.TA_default = TA_default;
+exports.abcd_default = abcd_default;
+exports.anyWaves_default = anyWaves_default;
+exports.arrow_default = arrow_default;
+exports.bollTv_default = bollTv_default;
+exports.brush_default = brush_default;
+exports.cci_default = cci_default;
+exports.circle_default = circle_default;
+exports.eightWaves_default = eightWaves_default;
+exports.elliottWave_default = elliottWave_default;
+exports.fibRetracement_default = fibRetracement_default;
+exports.fibonacciCircle_default = fibonacciCircle_default;
+exports.fibonacciExtension_default = fibonacciExtension_default;
+exports.fibonacciSegment_default = fibonacciSegment_default;
+exports.fibonacciSpeedResistanceFan_default = fibonacciSpeedResistanceFan_default;
+exports.fibonacciSpiral_default = fibonacciSpiral_default;
+exports.fiveWaves_default = fiveWaves_default;
+exports.gannBox_default = gannBox_default;
+exports.gannFan_default = gannFan_default;
+exports.hma_default = hma_default;
+exports.ichimoku_default = ichimoku_default;
+exports.indicators = indicators;
+exports.longPosition_default = longPosition_default;
+exports.maRibbon_default = maRibbon_default;
+exports.macdTv_default = macdTv_default;
+exports.measure_default = measure_default;
+exports.orderLine_default = orderLine_default;
+exports.overlays = overlays;
+exports.parallelChannel_default = parallelChannel_default;
+exports.parallelogram_default = parallelogram_default;
+exports.pivotPoints_default = pivotPoints_default;
+exports.ray_default = ray_default;
+exports.rect_default = rect_default;
+exports.registerExtensions = registerExtensions;
+exports.rsiTv_default = rsiTv_default;
+exports.shortPosition_default = shortPosition_default;
+exports.stochastic_default = stochastic_default;
+exports.superTrend_default = superTrend_default;
+exports.threeWaves_default = threeWaves_default;
+exports.triangle_default = triangle_default;
+exports.vwap_default = vwap_default;
+exports.xabcd_default = xabcd_default;
+//# sourceMappingURL=chunk-47JXSAIT.cjs.map
+//# sourceMappingURL=chunk-47JXSAIT.cjs.map