react-klinecharts-ui 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1497 @@
+'use strict';
+
+var chunkSLTXNLKN_cjs = require('./chunk-SLTXNLKN.cjs');
+var react = require('react');
+var reactKlinecharts = require('react-klinecharts');
+var jsxRuntime = require('react/jsx-runtime');
+
+var KlinechartsUIStateContext = react.createContext(null);
+var KlinechartsUIDispatchContext = react.createContext(null);
+function useKlinechartsUIDispatch() {
+  const ctx = react.useContext(KlinechartsUIDispatchContext);
+  if (!ctx) {
+    throw new Error(
+      "useKlinechartsUI must be used within a <KlinechartsUIProvider>"
+    );
+  }
+  return ctx;
+}
+function useKlinechartsUI() {
+  const state = react.useContext(KlinechartsUIStateContext);
+  const dispatch = react.useContext(KlinechartsUIDispatchContext);
+  if (!state || !dispatch) {
+    throw new Error(
+      "useKlinechartsUI must be used within a <KlinechartsUIProvider>"
+    );
+  }
+  return { state, ...dispatch };
+}
+
+// src/data/periods.ts
+var DEFAULT_PERIODS = [
+  { span: 1, type: "minute", label: "1m" },
+  { span: 5, type: "minute", label: "5m" },
+  { span: 15, type: "minute", label: "15m" },
+  { span: 1, type: "hour", label: "1H" },
+  { span: 2, type: "hour", label: "2H" },
+  { span: 4, type: "hour", label: "4H" },
+  { span: 1, type: "day", label: "D" },
+  { span: 1, type: "week", label: "W" },
+  { span: 1, type: "month", label: "M" },
+  { span: 1, type: "year", label: "Y" }
+];
+function reducer(state, action) {
+  switch (action.type) {
+    case "SET_CHART":
+      return { ...state, chart: action.chart };
+    case "SET_SYMBOL":
+      return { ...state, symbol: action.symbol };
+    case "SET_PERIOD":
+      return { ...state, period: action.period };
+    case "SET_THEME":
+      return { ...state, theme: action.theme };
+    case "SET_TIMEZONE":
+      return { ...state, timezone: action.timezone };
+    case "SET_LOADING":
+      return { ...state, isLoading: action.isLoading };
+    case "SET_MAIN_INDICATORS":
+      return { ...state, mainIndicators: action.indicators };
+    case "SET_SUB_INDICATORS":
+      return { ...state, subIndicators: action.indicators };
+    case "SET_STYLES":
+      return { ...state, styles: action.styles };
+    case "SET_LOCALE":
+      return { ...state, locale: action.locale };
+    case "SET_SCREENSHOT_URL":
+      return { ...state, screenshotUrl: action.url };
+    default:
+      return state;
+  }
+}
+function KlinechartsUIProvider({
+  datafeed,
+  defaultSymbol,
+  defaultPeriod,
+  defaultTheme = "light",
+  defaultTimezone = "Asia/Shanghai",
+  defaultMainIndicators = ["MA"],
+  defaultSubIndicators = ["VOL"],
+  defaultLocale = "en-US",
+  periods,
+  styles,
+  registerExtensions: shouldRegister = true,
+  overlays: extraOverlays,
+  children,
+  onStateChange,
+  onSymbolChange,
+  onPeriodChange,
+  onThemeChange,
+  onTimezoneChange,
+  onMainIndicatorsChange,
+  onSubIndicatorsChange,
+  onSettingsChange
+}) {
+  const [state, dispatch] = react.useReducer(
+    reducer,
+    {
+      datafeed,
+      defaultSymbol,
+      defaultPeriod,
+      defaultTheme,
+      defaultTimezone,
+      defaultMainIndicators,
+      defaultSubIndicators,
+      defaultLocale,
+      periods,
+      styles
+    },
+    (opts) => ({
+      chart: null,
+      datafeed: opts.datafeed,
+      symbol: opts.defaultSymbol ?? null,
+      period: opts.defaultPeriod ?? (opts.periods ?? DEFAULT_PERIODS)[0],
+      theme: opts.defaultTheme ?? "light",
+      timezone: opts.defaultTimezone ?? "Asia/Shanghai",
+      isLoading: false,
+      locale: opts.defaultLocale ?? "en-US",
+      periods: opts.periods ?? DEFAULT_PERIODS,
+      mainIndicators: opts.defaultMainIndicators ?? ["MA"],
+      subIndicators: (opts.defaultSubIndicators ?? ["VOL"]).reduce(
+        (acc, name) => ({ ...acc, [name]: "" }),
+        {}
+      ),
+      styles: opts.styles,
+      screenshotUrl: null
+    })
+  );
+  const fullscreenContainerRef = react.useRef(null);
+  const stateRef = react.useRef(state);
+  stateRef.current = state;
+  const callbacksRef = react.useRef({
+    onStateChange,
+    onSymbolChange,
+    onPeriodChange,
+    onThemeChange,
+    onTimezoneChange,
+    onMainIndicatorsChange,
+    onSubIndicatorsChange
+  });
+  callbacksRef.current = {
+    onStateChange,
+    onSymbolChange,
+    onPeriodChange,
+    onThemeChange,
+    onTimezoneChange,
+    onMainIndicatorsChange,
+    onSubIndicatorsChange
+  };
+  const enhancedDispatch = react.useCallback((action) => {
+    const prevState = stateRef.current;
+    const newState = reducer(prevState, action);
+    stateRef.current = newState;
+    dispatch(action);
+    const cbs = callbacksRef.current;
+    cbs.onStateChange?.(action, newState, prevState);
+    switch (action.type) {
+      case "SET_SYMBOL":
+        cbs.onSymbolChange?.(action.symbol);
+        break;
+      case "SET_PERIOD":
+        cbs.onPeriodChange?.(action.period);
+        break;
+      case "SET_THEME":
+        cbs.onThemeChange?.(action.theme);
+        break;
+      case "SET_TIMEZONE":
+        cbs.onTimezoneChange?.(action.timezone);
+        break;
+      case "SET_MAIN_INDICATORS":
+        cbs.onMainIndicatorsChange?.(action.indicators);
+        break;
+      case "SET_SUB_INDICATORS":
+        cbs.onSubIndicatorsChange?.(action.indicators);
+        break;
+    }
+  }, []);
+  const extraOverlaysRef = react.useRef(extraOverlays);
+  react.useEffect(() => {
+    if (shouldRegister) {
+      chunkSLTXNLKN_cjs.registerExtensions();
+    }
+    extraOverlaysRef.current?.forEach((overlay) => reactKlinecharts.registerOverlay(overlay));
+  }, [shouldRegister]);
+  react.useEffect(() => {
+    if (state.chart && state.styles) {
+      state.chart.setStyles(state.styles);
+    }
+  }, [state.chart, state.styles]);
+  const dispatchValue = react.useMemo(
+    () => ({
+      dispatch: enhancedDispatch,
+      datafeed,
+      onSettingsChange,
+      fullscreenContainerRef
+    }),
+    [enhancedDispatch, datafeed, onSettingsChange]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(KlinechartsUIStateContext.Provider, { value: state, children: /* @__PURE__ */ jsxRuntime.jsx(KlinechartsUIDispatchContext.Provider, { value: dispatchValue, children }) });
+}
+function useKlinechartsUITheme() {
+  const { state, dispatch } = useKlinechartsUI();
+  const setTheme = react.useCallback(
+    (theme) => {
+      state.chart?.setStyles(theme);
+      dispatch({ type: "SET_THEME", theme });
+    },
+    [state.chart, dispatch]
+  );
+  const toggleTheme = react.useCallback(() => {
+    const newTheme = state.theme === "light" ? "dark" : "light";
+    setTheme(newTheme);
+  }, [state.theme, setTheme]);
+  return {
+    theme: state.theme,
+    setTheme,
+    toggleTheme
+  };
+}
+
+// src/hooks/useKlinechartsUILoading.ts
+function useKlinechartsUILoading() {
+  const { state } = useKlinechartsUI();
+  return { isLoading: state.isLoading };
+}
+function usePeriods() {
+  const { state, dispatch } = useKlinechartsUI();
+  const setPeriod = react.useCallback(
+    (period) => {
+      dispatch({ type: "SET_PERIOD", period });
+    },
+    [dispatch]
+  );
+  return {
+    periods: state.periods,
+    activePeriod: state.period,
+    setPeriod
+  };
+}
+
+// src/data/timezones.ts
+var TIMEZONES = [
+  { key: "Etc/UTC", localeKey: "utc" },
+  { key: "Pacific/Honolulu", localeKey: "honolulu" },
+  { key: "America/Juneau", localeKey: "juneau" },
+  { key: "America/Los_Angeles", localeKey: "los_angeles" },
+  { key: "America/Chicago", localeKey: "chicago" },
+  { key: "America/Toronto", localeKey: "toronto" },
+  { key: "America/Sao_Paulo", localeKey: "sao_paulo" },
+  { key: "Europe/London", localeKey: "london" },
+  { key: "Europe/Berlin", localeKey: "berlin" },
+  { key: "Asia/Bahrain", localeKey: "bahrain" },
+  { key: "Asia/Dubai", localeKey: "dubai" },
+  { key: "Asia/Ashkhabad", localeKey: "ashkhabad" },
+  { key: "Asia/Almaty", localeKey: "almaty" },
+  { key: "Asia/Bangkok", localeKey: "bangkok" },
+  { key: "Asia/Shanghai", localeKey: "shanghai" },
+  { key: "Asia/Tokyo", localeKey: "tokyo" },
+  { key: "Australia/Sydney", localeKey: "sydney" },
+  { key: "Pacific/Norfolk", localeKey: "norfolk" }
+];
+
+// src/hooks/useTimezone.ts
+function useTimezone() {
+  const { state, dispatch } = useKlinechartsUI();
+  const timezones = react.useMemo(
+    () => TIMEZONES.map((tz) => ({
+      key: tz.key,
+      localeKey: tz.localeKey
+    })),
+    []
+  );
+  const setTimezone = react.useCallback(
+    (timezone) => {
+      state.chart?.setTimezone(timezone);
+      dispatch({ type: "SET_TIMEZONE", timezone });
+    },
+    [state.chart, dispatch]
+  );
+  return {
+    timezones,
+    activeTimezone: state.timezone,
+    setTimezone
+  };
+}
+function useSymbolSearch(debounceMs = 300) {
+  const { state, dispatch, datafeed } = useKlinechartsUI();
+  const [query, setQueryState] = react.useState("");
+  const [results, setResults] = react.useState([]);
+  const [isSearching, setIsSearching] = react.useState(false);
+  const timerRef = react.useRef(null);
+  const abortRef = react.useRef(null);
+  const setQuery = react.useCallback(
+    (q) => {
+      setQueryState(q);
+      if (timerRef.current) clearTimeout(timerRef.current);
+      abortRef.current?.abort();
+      abortRef.current = null;
+      if (!q.trim()) {
+        setResults([]);
+        setIsSearching(false);
+        return;
+      }
+      setIsSearching(true);
+      timerRef.current = setTimeout(async () => {
+        const controller = new AbortController();
+        abortRef.current = controller;
+        try {
+          const data = await datafeed.searchSymbols(q, controller.signal);
+          if (!controller.signal.aborted) {
+            setResults(data);
+          }
+        } catch {
+          if (!controller.signal.aborted) {
+            setResults([]);
+          }
+        } finally {
+          if (!controller.signal.aborted) {
+            setIsSearching(false);
+          }
+        }
+      }, debounceMs);
+    },
+    [datafeed, debounceMs]
+  );
+  const selectSymbol = react.useCallback(
+    (symbol) => {
+      dispatch({ type: "SET_SYMBOL", symbol });
+      setQueryState("");
+      setResults([]);
+    },
+    [dispatch]
+  );
+  const clearResults = react.useCallback(() => {
+    setQueryState("");
+    setResults([]);
+    setIsSearching(false);
+  }, []);
+  react.useEffect(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+      abortRef.current?.abort();
+    };
+  }, []);
+  return {
+    query,
+    results,
+    isSearching,
+    activeSymbol: state.symbol,
+    setQuery,
+    selectSymbol,
+    clearResults
+  };
+}
+
+// src/data/indicators.ts
+var MAIN_INDICATORS = [
+  "MA",
+  "EMA",
+  "SMA",
+  "BOLL",
+  "SAR",
+  "BBI"
+];
+var SUB_INDICATORS = [
+  "MA",
+  "EMA",
+  "VOL",
+  "MACD",
+  "BOLL",
+  "KDJ",
+  "RSI",
+  "BIAS",
+  "BRAR",
+  "CCI",
+  "DMI",
+  "CR",
+  "PSY",
+  "DMA",
+  "TRIX",
+  "OBV",
+  "VR",
+  "WR",
+  "MTM",
+  "EMV",
+  "SAR",
+  "SMA",
+  "ROC",
+  "PVT",
+  "BBI",
+  "AO"
+];
+var INDICATOR_PARAMS = {
+  SMA: {
+    name: "SMA",
+    localeKey: "sma",
+    params: [
+      { label: "params_1", defaultValue: 12 },
+      { label: "params_2", defaultValue: 2 }
+    ]
+  },
+  BOLL: {
+    name: "BOLL",
+    localeKey: "boll",
+    params: [
+      { label: "period", defaultValue: 20 },
+      { label: "standard_deviation", defaultValue: 2 }
+    ]
+  },
+  SAR: {
+    name: "SAR",
+    localeKey: "sar",
+    params: [
+      { label: "params_1", defaultValue: 2 },
+      { label: "params_2", defaultValue: 2 },
+      { label: "params_3", defaultValue: 20 }
+    ]
+  },
+  BBI: {
+    name: "BBI",
+    localeKey: "bbi",
+    params: [
+      { label: "params_1", defaultValue: 3 },
+      { label: "params_2", defaultValue: 6 },
+      { label: "params_3", defaultValue: 12 },
+      { label: "params_4", defaultValue: 24 }
+    ]
+  },
+  MACD: {
+    name: "MACD",
+    localeKey: "macd",
+    params: [
+      { label: "params_1", defaultValue: 12 },
+      { label: "params_2", defaultValue: 26 },
+      { label: "params_3", defaultValue: 9 }
+    ]
+  },
+  KDJ: {
+    name: "KDJ",
+    localeKey: "kdj",
+    params: [
+      { label: "params_1", defaultValue: 9 },
+      { label: "params_2", defaultValue: 3 },
+      { label: "params_3", defaultValue: 3 }
+    ]
+  },
+  BRAR: {
+    name: "BRAR",
+    localeKey: "brar",
+    params: [{ label: "params_1", defaultValue: 26 }]
+  },
+  CCI: {
+    name: "CCI",
+    localeKey: "cci",
+    params: [{ label: "params_1", defaultValue: 20 }]
+  },
+  DMI: {
+    name: "DMI",
+    localeKey: "dmi",
+    params: [
+      { label: "params_1", defaultValue: 14 },
+      { label: "params_2", defaultValue: 6 }
+    ]
+  },
+  CR: {
+    name: "CR",
+    localeKey: "cr",
+    params: [
+      { label: "params_1", defaultValue: 26 },
+      { label: "params_2", defaultValue: 10 },
+      { label: "params_3", defaultValue: 20 },
+      { label: "params_4", defaultValue: 40 },
+      { label: "params_5", defaultValue: 60 }
+    ]
+  },
+  PSY: {
+    name: "PSY",
+    localeKey: "psy",
+    params: [
+      { label: "params_1", defaultValue: 12 },
+      { label: "params_2", defaultValue: 6 }
+    ]
+  },
+  DMA: {
+    name: "DMA",
+    localeKey: "dma",
+    params: [
+      { label: "params_1", defaultValue: 10 },
+      { label: "params_2", defaultValue: 50 },
+      { label: "params_3", defaultValue: 10 }
+    ]
+  },
+  TRIX: {
+    name: "TRIX",
+    localeKey: "trix",
+    params: [
+      { label: "params_1", defaultValue: 12 },
+      { label: "params_2", defaultValue: 9 }
+    ]
+  },
+  OBV: {
+    name: "OBV",
+    localeKey: "obv",
+    params: [{ label: "params_1", defaultValue: 30 }]
+  },
+  VR: {
+    name: "VR",
+    localeKey: "vr",
+    params: [
+      { label: "params_1", defaultValue: 26 },
+      { label: "params_2", defaultValue: 6 }
+    ]
+  },
+  MTM: {
+    name: "MTM",
+    localeKey: "mtm",
+    params: [
+      { label: "params_1", defaultValue: 12 },
+      { label: "params_2", defaultValue: 6 }
+    ]
+  },
+  EMV: {
+    name: "EMV",
+    localeKey: "emv",
+    params: [
+      { label: "params_1", defaultValue: 14 },
+      { label: "params_2", defaultValue: 9 }
+    ]
+  },
+  ROC: {
+    name: "ROC",
+    localeKey: "roc",
+    params: [
+      { label: "params_1", defaultValue: 12 },
+      { label: "params_2", defaultValue: 6 }
+    ]
+  },
+  PVT: {
+    name: "PVT",
+    localeKey: "pvt",
+    params: []
+  },
+  AO: {
+    name: "AO",
+    localeKey: "ao",
+    params: [
+      { label: "params_1", defaultValue: 5 },
+      { label: "params_2", defaultValue: 34 }
+    ]
+  }
+};
+
+// src/hooks/useIndicators.ts
+function useIndicators() {
+  const { state, dispatch } = useKlinechartsUI();
+  const mainIndicators = react.useMemo(() => {
+    const activeNames = state.mainIndicators;
+    const inactive = MAIN_INDICATORS.filter((n) => !activeNames.includes(n));
+    return [
+      ...activeNames.map((name) => ({ name, isActive: true })),
+      ...inactive.map((name) => ({ name, isActive: false }))
+    ];
+  }, [state.mainIndicators]);
+  const subIndicators = react.useMemo(() => {
+    const activeNames = Object.keys(state.subIndicators);
+    const inactive = SUB_INDICATORS.filter((n) => !activeNames.includes(n));
+    return [
+      ...activeNames.map((name) => ({ name, isActive: true })),
+      ...inactive.map((name) => ({ name, isActive: false }))
+    ];
+  }, [state.subIndicators]);
+  const addMainIndicator = react.useCallback(
+    (name) => {
+      if (state.mainIndicators.includes(name)) return;
+      state.chart?.createIndicator(
+        { name, id: `main_${name}`, paneId: "candle_pane" },
+        true,
+        { id: "candle_pane" }
+      );
+      const newIndicators = [...state.mainIndicators, name];
+      dispatch({ type: "SET_MAIN_INDICATORS", indicators: newIndicators });
+    },
+    [state.chart, state.mainIndicators, dispatch]
+  );
+  const removeMainIndicator = react.useCallback(
+    (name) => {
+      state.chart?.removeIndicator({ id: `main_${name}` });
+      const newIndicators = state.mainIndicators.filter((n) => n !== name);
+      dispatch({ type: "SET_MAIN_INDICATORS", indicators: newIndicators });
+    },
+    [state.chart, state.mainIndicators, dispatch]
+  );
+  const addSubIndicator = react.useCallback(
+    (name) => {
+      if (name in state.subIndicators) return;
+      const id = `sub_${name}`;
+      state.chart?.createIndicator({ name, id });
+      const paneId = state.chart?.getIndicators({ id })?.[0]?.paneId ?? "";
+      const newIndicators = { ...state.subIndicators, [name]: paneId };
+      dispatch({ type: "SET_SUB_INDICATORS", indicators: newIndicators });
+    },
+    [state.chart, state.subIndicators, dispatch]
+  );
+  const removeSubIndicator = react.useCallback(
+    (name) => {
+      state.chart?.removeIndicator({ id: `sub_${name}` });
+      const newIndicators = { ...state.subIndicators };
+      delete newIndicators[name];
+      dispatch({ type: "SET_SUB_INDICATORS", indicators: newIndicators });
+    },
+    [state.chart, state.subIndicators, dispatch]
+  );
+  const toggleMainIndicator = react.useCallback(
+    (name) => {
+      if (state.mainIndicators.includes(name)) {
+        removeMainIndicator(name);
+      } else {
+        addMainIndicator(name);
+      }
+    },
+    [state.mainIndicators, addMainIndicator, removeMainIndicator]
+  );
+  const toggleSubIndicator = react.useCallback(
+    (name) => {
+      if (name in state.subIndicators) {
+        removeSubIndicator(name);
+      } else {
+        addSubIndicator(name);
+      }
+    },
+    [state.subIndicators, addSubIndicator, removeSubIndicator]
+  );
+  const setIndicatorVisible = react.useCallback(
+    (name, isMain, visible) => {
+      const id = isMain ? `main_${name}` : `sub_${name}`;
+      state.chart?.overrideIndicator({ name, id, visible });
+    },
+    [state.chart]
+  );
+  const updateIndicatorParams = react.useCallback(
+    (name, paneId, params) => {
+      state.chart?.overrideIndicator({ name, paneId, calcParams: params });
+    },
+    [state.chart]
+  );
+  const getIndicatorParams = react.useCallback((name) => {
+    const config = INDICATOR_PARAMS[name];
+    if (!config) return [];
+    return config.params.map((p) => ({
+      label: p.label,
+      defaultValue: p.defaultValue
+    }));
+  }, []);
+  const moveToMain = react.useCallback(
+    (name) => {
+      if (!state.chart) return;
+      state.chart.removeIndicator({ id: `sub_${name}` });
+      state.chart.createIndicator(
+        { name, id: `main_${name}`, paneId: "candle_pane" },
+        true,
+        { id: "candle_pane" }
+      );
+      const newSub = { ...state.subIndicators };
+      delete newSub[name];
+      dispatch({ type: "SET_SUB_INDICATORS", indicators: newSub });
+      dispatch({
+        type: "SET_MAIN_INDICATORS",
+        indicators: [...state.mainIndicators, name]
+      });
+    },
+    [state.chart, state.mainIndicators, state.subIndicators, dispatch]
+  );
+  const moveToSub = react.useCallback(
+    (name) => {
+      if (!state.chart) return;
+      state.chart.removeIndicator({ id: `main_${name}` });
+      const subId = `sub_${name}`;
+      state.chart.createIndicator({ name, id: subId });
+      const paneId = state.chart.getIndicators({ id: subId })?.[0]?.paneId ?? "";
+      const newMain = state.mainIndicators.filter((n) => n !== name);
+      dispatch({ type: "SET_MAIN_INDICATORS", indicators: newMain });
+      dispatch({
+        type: "SET_SUB_INDICATORS",
+        indicators: { ...state.subIndicators, [name]: paneId }
+      });
+    },
+    [state.chart, state.mainIndicators, state.subIndicators, dispatch]
+  );
+  const isMainIndicatorActive = react.useCallback(
+    (name) => state.mainIndicators.includes(name),
+    [state.mainIndicators]
+  );
+  const isSubIndicatorActive = react.useCallback(
+    (name) => name in state.subIndicators,
+    [state.subIndicators]
+  );
+  return {
+    mainIndicators,
+    subIndicators,
+    activeMainIndicators: state.mainIndicators,
+    activeSubIndicators: state.subIndicators,
+    availableMainIndicators: MAIN_INDICATORS,
+    availableSubIndicators: SUB_INDICATORS,
+    addMainIndicator,
+    removeMainIndicator,
+    addSubIndicator,
+    removeSubIndicator,
+    toggleMainIndicator,
+    toggleSubIndicator,
+    moveToMain,
+    moveToSub,
+    setIndicatorVisible,
+    updateIndicatorParams,
+    getIndicatorParams,
+    isMainIndicatorActive,
+    isSubIndicatorActive
+  };
+}
+
+// src/data/drawings.ts
+var DRAWING_CATEGORIES = [
+  {
+    key: "singleLine",
+    tools: [
+      { name: "horizontalStraightLine", localeKey: "horizontal_straight_line" },
+      { name: "horizontalRayLine", localeKey: "horizontal_ray_line" },
+      { name: "horizontalSegment", localeKey: "horizontal_segment" },
+      { name: "verticalStraightLine", localeKey: "vertical_straight_line" },
+      { name: "verticalRayLine", localeKey: "vertical_ray_line" },
+      { name: "verticalSegment", localeKey: "vertical_segment" },
+      { name: "straightLine", localeKey: "straight_line" },
+      { name: "rayLine", localeKey: "ray_line" },
+      { name: "segment", localeKey: "segment" },
+      { name: "arrow", localeKey: "arrow" },
+      { name: "priceLine", localeKey: "price_line" }
+    ]
+  },
+  {
+    key: "moreLine",
+    tools: [
+      { name: "priceChannelLine", localeKey: "price_channel_line" },
+      { name: "parallelStraightLine", localeKey: "parallel_straight_line" }
+    ]
+  },
+  {
+    key: "polygon",
+    tools: [
+      { name: "circle", localeKey: "circle" },
+      { name: "rect", localeKey: "rect" },
+      { name: "parallelogram", localeKey: "parallelogram" },
+      { name: "triangle", localeKey: "triangle" }
+    ]
+  },
+  {
+    key: "fibonacci",
+    tools: [
+      { name: "fibonacciLine", localeKey: "fibonacci_line" },
+      { name: "fibonacciSegment", localeKey: "fibonacci_segment" },
+      { name: "fibonacciCircle", localeKey: "fibonacci_circle" },
+      { name: "fibonacciSpiral", localeKey: "fibonacci_spiral" },
+      {
+        name: "fibonacciSpeedResistanceFan",
+        localeKey: "fibonacci_speed_resistance_fan"
+      },
+      { name: "fibonacciExtension", localeKey: "fibonacci_extension" },
+      { name: "gannBox", localeKey: "gann_box" }
+    ]
+  },
+  {
+    key: "wave",
+    tools: [
+      { name: "xabcd", localeKey: "xabcd" },
+      { name: "abcd", localeKey: "abcd" },
+      { name: "threeWaves", localeKey: "three_waves" },
+      { name: "fiveWaves", localeKey: "five_waves" },
+      { name: "eightWaves", localeKey: "eight_waves" },
+      { name: "anyWaves", localeKey: "any_waves" }
+    ]
+  }
+];
+
+// src/hooks/useDrawingTools.ts
+var DRAWING_GROUP_ID = "drawing_tools";
+function useDrawingTools() {
+  const { state } = useKlinechartsUI();
+  const [activeTool, setActiveTool] = react.useState(null);
+  const [magnetMode, setMagnetModeState] = react.useState("normal");
+  const [isLocked, setIsLocked] = react.useState(false);
+  const [isVisible, setIsVisible] = react.useState(true);
+  const categories = react.useMemo(
+    () => DRAWING_CATEGORIES.map((cat) => ({
+      key: cat.key,
+      tools: cat.tools.map((tool) => ({
+        name: tool.name,
+        localeKey: tool.localeKey
+      }))
+    })),
+    []
+  );
+  const selectTool = react.useCallback(
+    (name) => {
+      setActiveTool(name);
+      state.chart?.createOverlay({
+        name,
+        groupId: DRAWING_GROUP_ID,
+        lock: isLocked,
+        visible: isVisible,
+        mode: magnetMode === "strong" ? "strong_magnet" : magnetMode === "weak" ? "weak_magnet" : "normal"
+      });
+    },
+    [state.chart, isLocked, isVisible, magnetMode]
+  );
+  const clearActiveTool = react.useCallback(() => {
+    setActiveTool(null);
+  }, []);
+  const setMagnetMode = react.useCallback(
+    (mode) => {
+      setMagnetModeState(mode);
+      const overlays2 = state.chart?.getOverlays({ groupId: DRAWING_GROUP_ID });
+      if (overlays2) {
+        const overlayMode = mode === "strong" ? "strong_magnet" : mode === "weak" ? "weak_magnet" : "normal";
+        overlays2.forEach((overlay) => {
+          state.chart?.overrideOverlay({
+            id: overlay.id,
+            mode: overlayMode
+          });
+        });
+      }
+    },
+    [state.chart]
+  );
+  const toggleLock = react.useCallback(() => {
+    const newLocked = !isLocked;
+    setIsLocked(newLocked);
+    const overlays2 = state.chart?.getOverlays({ groupId: DRAWING_GROUP_ID });
+    if (overlays2) {
+      overlays2.forEach((overlay) => {
+        state.chart?.overrideOverlay({
+          id: overlay.id,
+          lock: newLocked
+        });
+      });
+    }
+  }, [state.chart, isLocked]);
+  const toggleVisibility = react.useCallback(() => {
+    const newVisible = !isVisible;
+    setIsVisible(newVisible);
+    const overlays2 = state.chart?.getOverlays({ groupId: DRAWING_GROUP_ID });
+    if (overlays2) {
+      overlays2.forEach((overlay) => {
+        state.chart?.overrideOverlay({
+          id: overlay.id,
+          visible: newVisible
+        });
+      });
+    }
+  }, [state.chart, isVisible]);
+  const removeAllDrawings = react.useCallback(() => {
+    state.chart?.removeOverlay({ groupId: DRAWING_GROUP_ID });
+    setActiveTool(null);
+  }, [state.chart]);
+  return {
+    categories,
+    activeTool,
+    magnetMode,
+    isLocked,
+    isVisible,
+    selectTool,
+    clearActiveTool,
+    setMagnetMode,
+    toggleLock,
+    toggleVisibility,
+    removeAllDrawings
+  };
+}
+
+// src/data/candle-types.ts
+var CANDLE_TYPES = [
+  { key: "candle_solid", localeKey: "candle_solid" },
+  { key: "candle_stroke", localeKey: "candle_stroke" },
+  { key: "candle_up_stroke", localeKey: "candle_up_stroke" },
+  { key: "candle_down_stroke", localeKey: "candle_down_stroke" },
+  { key: "ohlc", localeKey: "ohlc" },
+  { key: "area", localeKey: "area" }
+];
+var PRICE_AXIS_TYPES = ["normal", "percentage", "logarithm"];
+var YAXIS_POSITIONS = ["left", "right"];
+var COMPARE_RULES = ["current_open", "prev_close"];
+var TOOLTIP_SHOW_RULES = ["always", "follow_cross", "none"];
+
+// src/hooks/useKlinechartsUISettings.ts
+var defaultSettings = {
+  candleType: "candle_solid",
+  candleUpColor: "#2DC08E",
+  candleDownColor: "#F92855",
+  compareRule: "current_open",
+  showLastPrice: true,
+  showLastPriceLine: true,
+  showHighPrice: true,
+  showLowPrice: true,
+  showIndicatorLastValue: true,
+  priceAxisType: "normal",
+  yAxisPosition: "right",
+  yAxisInside: false,
+  reverseCoordinate: false,
+  showTimeAxis: true,
+  showGrid: true,
+  showCrosshair: true,
+  showCandleTooltip: true,
+  showIndicatorTooltip: true,
+  tooltipShowRule: "always"
+};
+function useKlinechartsUISettings() {
+  const { state, onSettingsChange } = useKlinechartsUI();
+  const [settings, setSettings] = react.useState(defaultSettings);
+  const isInitialMount = react.useRef(true);
+  react.useEffect(() => {
+    if (isInitialMount.current) {
+      isInitialMount.current = false;
+      return;
+    }
+    onSettingsChange?.({ ...settings });
+  }, [settings, onSettingsChange]);
+  const candleTypes = react.useMemo(
+    () => CANDLE_TYPES.map((ct) => ({
+      key: ct.key,
+      localeKey: ct.localeKey
+    })),
+    []
+  );
+  const priceAxisTypes = react.useMemo(
+    () => PRICE_AXIS_TYPES.map((pat) => ({ key: pat, localeKey: pat })),
+    []
+  );
+  const yAxisPositions = react.useMemo(
+    () => YAXIS_POSITIONS.map((p) => ({ key: p, localeKey: p })),
+    []
+  );
+  const compareRules = react.useMemo(
+    () => COMPARE_RULES.map((r) => ({ key: r, localeKey: r })),
+    []
+  );
+  const tooltipShowRules = react.useMemo(
+    () => TOOLTIP_SHOW_RULES.map((r) => ({ key: r, localeKey: r })),
+    []
+  );
+  const hasAppliedInitial = react.useRef(false);
+  react.useEffect(() => {
+    if (!state.chart || hasAppliedInitial.current) return;
+    hasAppliedInitial.current = true;
+    const needsPaneOptions = settings.reverseCoordinate || settings.priceAxisType !== "normal" || settings.yAxisPosition !== "right" || settings.yAxisInside;
+    if (needsPaneOptions) {
+      state.chart.setPaneOptions({
+        id: "candle_pane",
+        axis: {
+          ...settings.priceAxisType !== "normal" && { name: settings.priceAxisType },
+          ...settings.reverseCoordinate && { reverse: true },
+          ...settings.yAxisPosition !== "right" && { position: settings.yAxisPosition },
+          ...settings.yAxisInside && { inside: true }
+        }
+      });
+    }
+    if (settings.showIndicatorLastValue) {
+      state.chart.setStyles({
+        indicator: { lastValueMark: { show: true } }
+      });
+    }
+  }, [state.chart]);
+  const applyStyle = react.useCallback(
+    (path, value) => {
+      const parts = path.split(".");
+      const styleObj = {};
+      let current = styleObj;
+      for (let i = 0; i < parts.length - 1; i++) {
+        current[parts[i]] = {};
+        current = current[parts[i]];
+      }
+      current[parts[parts.length - 1]] = value;
+      state.chart?.setStyles(styleObj);
+    },
+    [state.chart]
+  );
+  const applyPaneAxis = react.useCallback(
+    (axis) => {
+      state.chart?.setPaneOptions({ id: "candle_pane", axis });
+    },
+    [state.chart]
+  );
+  const setCandleType = react.useCallback(
+    (type) => {
+      applyStyle("candle.type", type);
+      setSettings((s) => ({ ...s, candleType: type }));
+    },
+    [applyStyle]
+  );
+  const setCandleUpColor = react.useCallback(
+    (color) => {
+      state.chart?.setStyles({
+        candle: {
+          bar: { upColor: color, upBorderColor: color, upWickColor: color }
+        }
+      });
+      setSettings((s) => ({ ...s, candleUpColor: color }));
+    },
+    [state.chart]
+  );
+  const setCandleDownColor = react.useCallback(
+    (color) => {
+      state.chart?.setStyles({
+        candle: {
+          bar: { downColor: color, downBorderColor: color, downWickColor: color }
+        }
+      });
+      setSettings((s) => ({ ...s, candleDownColor: color }));
+    },
+    [state.chart]
+  );
+  const setCompareRule = react.useCallback(
+    (rule) => {
+      applyStyle("candle.bar.compareRule", rule);
+      setSettings((s) => ({ ...s, compareRule: rule }));
+    },
+    [applyStyle]
+  );
+  const setShowLastPrice = react.useCallback(
+    (show) => {
+      applyStyle("candle.priceMark.last.show", show);
+      setSettings((s) => ({ ...s, showLastPrice: show }));
+    },
+    [applyStyle]
+  );
+  const setShowLastPriceLine = react.useCallback(
+    (show) => {
+      applyStyle("candle.priceMark.last.line.show", show);
+      setSettings((s) => ({ ...s, showLastPriceLine: show }));
+    },
+    [applyStyle]
+  );
+  const setShowHighPrice = react.useCallback(
+    (show) => {
+      applyStyle("candle.priceMark.high.show", show);
+      setSettings((s) => ({ ...s, showHighPrice: show }));
+    },
+    [applyStyle]
+  );
+  const setShowLowPrice = react.useCallback(
+    (show) => {
+      applyStyle("candle.priceMark.low.show", show);
+      setSettings((s) => ({ ...s, showLowPrice: show }));
+    },
+    [applyStyle]
+  );
+  const setShowIndicatorLastValue = react.useCallback(
+    (show) => {
+      applyStyle("indicator.lastValueMark.show", show);
+      setSettings((s) => ({ ...s, showIndicatorLastValue: show }));
+    },
+    [applyStyle]
+  );
+  const setPriceAxisType = react.useCallback(
+    (type) => {
+      applyPaneAxis({ name: type });
+      setSettings((s) => ({ ...s, priceAxisType: type }));
+    },
+    [applyPaneAxis]
+  );
+  const setYAxisPosition = react.useCallback(
+    (position) => {
+      applyPaneAxis({ position });
+      setSettings((s) => ({ ...s, yAxisPosition: position }));
+    },
+    [applyPaneAxis]
+  );
+  const setYAxisInside = react.useCallback(
+    (inside) => {
+      applyPaneAxis({ inside });
+      setSettings((s) => ({ ...s, yAxisInside: inside }));
+    },
+    [applyPaneAxis]
+  );
+  const setReverseCoordinate = react.useCallback(
+    (reverse) => {
+      applyPaneAxis({ reverse });
+      setSettings((s) => ({ ...s, reverseCoordinate: reverse }));
+    },
+    [applyPaneAxis]
+  );
+  const setShowGrid = react.useCallback(
+    (show) => {
+      applyStyle("grid.show", show);
+      setSettings((s) => ({ ...s, showGrid: show }));
+    },
+    [applyStyle]
+  );
+  const setShowTimeAxis = react.useCallback(
+    (show) => {
+      applyStyle("xAxis.show", show);
+      setSettings((s) => ({ ...s, showTimeAxis: show }));
+    },
+    [applyStyle]
+  );
+  const setShowCrosshair = react.useCallback(
+    (show) => {
+      applyStyle("crosshair.show", show);
+      setSettings((s) => ({ ...s, showCrosshair: show }));
+    },
+    [applyStyle]
+  );
+  const setShowCandleTooltip = react.useCallback(
+    (show) => {
+      applyStyle("candle.tooltip.show", show);
+      setSettings((s) => ({ ...s, showCandleTooltip: show }));
+    },
+    [applyStyle]
+  );
+  const setShowIndicatorTooltip = react.useCallback(
+    (show) => {
+      applyStyle("indicator.tooltip.show", show);
+      setSettings((s) => ({ ...s, showIndicatorTooltip: show }));
+    },
+    [applyStyle]
+  );
+  const setTooltipShowRule = react.useCallback(
+    (rule) => {
+      state.chart?.setStyles({
+        candle: { tooltip: { showRule: rule } },
+        indicator: { tooltip: { showRule: rule } }
+      });
+      setSettings((s) => ({ ...s, tooltipShowRule: rule }));
+    },
+    [state.chart]
+  );
+  const resetToDefaults = react.useCallback(() => {
+    setSettings(defaultSettings);
+    state.chart?.setStyles(state.theme);
+    state.chart?.setPaneOptions({
+      id: "candle_pane",
+      axis: { name: "normal", reverse: false, position: "right", inside: false }
+    });
+  }, [state.chart, state.theme]);
+  return {
+    ...settings,
+    candleTypes,
+    priceAxisTypes,
+    yAxisPositions,
+    compareRules,
+    tooltipShowRules,
+    setCandleType,
+    setCandleUpColor,
+    setCandleDownColor,
+    setCompareRule,
+    setShowLastPrice,
+    setShowLastPriceLine,
+    setShowHighPrice,
+    setShowLowPrice,
+    setShowIndicatorLastValue,
+    setPriceAxisType,
+    setYAxisPosition,
+    setYAxisInside,
+    setReverseCoordinate,
+    setShowTimeAxis,
+    setShowGrid,
+    setShowCrosshair,
+    setShowCandleTooltip,
+    setShowIndicatorTooltip,
+    setTooltipShowRule,
+    resetToDefaults
+  };
+}
+function useScreenshot() {
+  const { state, dispatch } = useKlinechartsUI();
+  const capture = react.useCallback(() => {
+    if (!state.chart) return;
+    const url = state.chart.getConvertPictureUrl(true, "jpeg", state.theme === "dark" ? "#151517" : "#ffffff");
+    dispatch({ type: "SET_SCREENSHOT_URL", url });
+  }, [state.chart, state.theme, dispatch]);
+  const download = react.useCallback(
+    (filename = "chart-screenshot.jpg") => {
+      if (!state.screenshotUrl) return;
+      const link = document.createElement("a");
+      link.href = state.screenshotUrl;
+      link.download = filename;
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+    },
+    [state.screenshotUrl]
+  );
+  const clear = react.useCallback(() => {
+    dispatch({ type: "SET_SCREENSHOT_URL", url: null });
+  }, [dispatch]);
+  return {
+    screenshotUrl: state.screenshotUrl,
+    capture,
+    download,
+    clear
+  };
+}
+function useFullscreen() {
+  const { fullscreenContainerRef } = useKlinechartsUIDispatch();
+  const [isFullscreen, setIsFullscreen] = react.useState(false);
+  const enter = react.useCallback(() => {
+    const el = fullscreenContainerRef.current;
+    if (!el) return;
+    if (el.requestFullscreen) {
+      el.requestFullscreen();
+    } else if ("webkitRequestFullscreen" in el) {
+      el.webkitRequestFullscreen();
+    } else if ("msRequestFullscreen" in el) {
+      el.msRequestFullscreen();
+    }
+  }, [fullscreenContainerRef]);
+  const exit = react.useCallback(() => {
+    if (document.exitFullscreen) {
+      document.exitFullscreen();
+    } else if ("webkitExitFullscreen" in document) {
+      document.webkitExitFullscreen();
+    } else if ("msExitFullscreen" in document) {
+      document.msExitFullscreen();
+    }
+  }, []);
+  const toggle = react.useCallback(() => {
+    if (isFullscreen) {
+      exit();
+    } else {
+      enter();
+    }
+  }, [isFullscreen, enter, exit]);
+  react.useEffect(() => {
+    const handler = () => {
+      setIsFullscreen(!!document.fullscreenElement);
+    };
+    document.addEventListener("fullscreenchange", handler);
+    document.addEventListener("webkitfullscreenchange", handler);
+    return () => {
+      document.removeEventListener("fullscreenchange", handler);
+      document.removeEventListener("webkitfullscreenchange", handler);
+    };
+  }, []);
+  return {
+    isFullscreen,
+    toggle,
+    enter,
+    exit,
+    containerRef: fullscreenContainerRef
+  };
+}
+function useOrderLines() {
+  const { state } = useKlinechartsUI();
+  const callbacksRef = react.useRef(/* @__PURE__ */ new Map());
+  const createOrderLine = react.useCallback(
+    (options) => {
+      if (!state.chart) return null;
+      const {
+        id: optId,
+        price,
+        draggable = false,
+        onPriceChange,
+        ...extendData
+      } = options;
+      const id = optId ?? `order_line_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+      if (onPriceChange) {
+        callbacksRef.current.set(id, onPriceChange);
+      }
+      const dataCount = state.chart.getDataList().length;
+      const anchorIndex = dataCount > 0 ? dataCount - 1 : 0;
+      state.chart.createOverlay({
+        name: "orderLine",
+        id,
+        points: [{ dataIndex: anchorIndex, value: price }],
+        extendData,
+        lock: !draggable,
+        mode: "normal",
+        onPressedMoveEnd: (event) => {
+          const newPrice = event.overlay.points[0]?.value;
+          if (newPrice != null) {
+            callbacksRef.current.get(id)?.(newPrice);
+          }
+        }
+      });
+      return id;
+    },
+    [state.chart]
+  );
+  const updateOrderLine = react.useCallback(
+    (id, options) => {
+      if (!state.chart) return;
+      const { price, draggable, onPriceChange, ...extendData } = options;
+      const existing = state.chart.getOverlays({ id })?.[0];
+      if (!existing) return;
+      if (onPriceChange !== void 0) {
+        callbacksRef.current.set(id, onPriceChange);
+      }
+      const dataCount = state.chart.getDataList().length;
+      const anchorIndex = dataCount > 0 ? dataCount - 1 : 0;
+      state.chart.overrideOverlay({
+        id,
+        ...price != null ? { points: [{ dataIndex: anchorIndex, value: price }] } : {},
+        ...draggable != null ? { lock: !draggable } : {},
+        extendData: {
+          ...existing.extendData,
+          ...extendData
+        }
+      });
+    },
+    [state.chart]
+  );
+  const removeOrderLine = react.useCallback(
+    (id) => {
+      state.chart?.removeOverlay({ id });
+      callbacksRef.current.delete(id);
+    },
+    [state.chart]
+  );
+  const removeAllOrderLines = react.useCallback(() => {
+    state.chart?.removeOverlay({ name: "orderLine" });
+    callbacksRef.current.clear();
+  }, [state.chart]);
+  return {
+    createOrderLine,
+    updateOrderLine,
+    removeOrderLine,
+    removeAllOrderLines
+  };
+}
+
+// src/utils/createDataLoader.ts
+function createDataLoader(datafeed, dispatch) {
+  let oldestTimestamp = null;
+  let currentGen = 0;
+  return {
+    getBars: async (params) => {
+      try {
+        dispatch({ type: "SET_LOADING", isLoading: true });
+        if (params.type === "init") {
+          oldestTimestamp = null;
+          const gen = ++currentGen;
+          const data = await datafeed.getHistoryKLineData(
+            params.symbol,
+            { ...params.period, label: "" },
+            0,
+            Date.now()
+          );
+          if (gen !== currentGen) return;
+          if (data.length > 0) {
+            oldestTimestamp = data[0].timestamp;
+          }
+          params.callback(data, {
+            forward: data.length > 0,
+            backward: false
+          });
+        } else if (params.type === "forward" && oldestTimestamp !== null) {
+          const gen = currentGen;
+          const data = await datafeed.getHistoryKLineData(
+            params.symbol,
+            { ...params.period, label: "" },
+            0,
+            oldestTimestamp - 1
+          );
+          if (gen !== currentGen) return;
+          if (data.length > 0) {
+            oldestTimestamp = data[0].timestamp;
+          }
+          params.callback(data, {
+            forward: data.length > 0,
+            backward: false
+          });
+        } else if (params.type === "backward") {
+          params.callback([], { forward: false, backward: false });
+        }
+      } catch (error) {
+        console.error("Failed to load chart data:", error);
+        params.callback([], { forward: false, backward: false });
+      } finally {
+        dispatch({ type: "SET_LOADING", isLoading: false });
+      }
+    },
+    subscribeBar: (params) => {
+      datafeed.subscribe(
+        params.symbol,
+        { ...params.period, label: "" },
+        (klineData) => params.callback(klineData)
+      );
+    },
+    unsubscribeBar: (params) => {
+      datafeed.unsubscribe(params.symbol, { ...params.period, label: "" });
+    }
+  };
+}
+
+Object.defineProperty(exports, "abcd", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.abcd_default; }
+});
+Object.defineProperty(exports, "anyWaves", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.anyWaves_default; }
+});
+Object.defineProperty(exports, "arrow", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.arrow_default; }
+});
+Object.defineProperty(exports, "circle", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.circle_default; }
+});
+Object.defineProperty(exports, "eightWaves", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.eightWaves_default; }
+});
+Object.defineProperty(exports, "fibonacciCircle", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.fibonacciCircle_default; }
+});
+Object.defineProperty(exports, "fibonacciExtension", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.fibonacciExtension_default; }
+});
+Object.defineProperty(exports, "fibonacciSegment", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.fibonacciSegment_default; }
+});
+Object.defineProperty(exports, "fibonacciSpeedResistanceFan", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.fibonacciSpeedResistanceFan_default; }
+});
+Object.defineProperty(exports, "fibonacciSpiral", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.fibonacciSpiral_default; }
+});
+Object.defineProperty(exports, "fiveWaves", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.fiveWaves_default; }
+});
+Object.defineProperty(exports, "gannBox", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.gannBox_default; }
+});
+Object.defineProperty(exports, "orderLine", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.orderLine_default; }
+});
+Object.defineProperty(exports, "overlays", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.overlays; }
+});
+Object.defineProperty(exports, "parallelogram", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.parallelogram_default; }
+});
+Object.defineProperty(exports, "rect", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.rect_default; }
+});
+Object.defineProperty(exports, "registerExtensions", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.registerExtensions; }
+});
+Object.defineProperty(exports, "threeWaves", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.threeWaves_default; }
+});
+Object.defineProperty(exports, "triangle", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.triangle_default; }
+});
+Object.defineProperty(exports, "xabcd", {
+  enumerable: true,
+  get: function () { return chunkSLTXNLKN_cjs.xabcd_default; }
+});
+exports.CANDLE_TYPES = CANDLE_TYPES;
+exports.COMPARE_RULES = COMPARE_RULES;
+exports.DEFAULT_PERIODS = DEFAULT_PERIODS;
+exports.DRAWING_CATEGORIES = DRAWING_CATEGORIES;
+exports.INDICATOR_PARAMS = INDICATOR_PARAMS;
+exports.KlinechartsUIDispatchContext = KlinechartsUIDispatchContext;
+exports.KlinechartsUIProvider = KlinechartsUIProvider;
+exports.KlinechartsUIStateContext = KlinechartsUIStateContext;
+exports.MAIN_INDICATORS = MAIN_INDICATORS;
+exports.PRICE_AXIS_TYPES = PRICE_AXIS_TYPES;
+exports.SUB_INDICATORS = SUB_INDICATORS;
+exports.TIMEZONES = TIMEZONES;
+exports.TOOLTIP_SHOW_RULES = TOOLTIP_SHOW_RULES;
+exports.YAXIS_POSITIONS = YAXIS_POSITIONS;
+exports.createDataLoader = createDataLoader;
+exports.useDrawingTools = useDrawingTools;
+exports.useFullscreen = useFullscreen;
+exports.useIndicators = useIndicators;
+exports.useKlinechartsUI = useKlinechartsUI;
+exports.useKlinechartsUILoading = useKlinechartsUILoading;
+exports.useKlinechartsUISettings = useKlinechartsUISettings;
+exports.useKlinechartsUITheme = useKlinechartsUITheme;
+exports.useOrderLines = useOrderLines;
+exports.usePeriods = usePeriods;
+exports.useScreenshot = useScreenshot;
+exports.useSymbolSearch = useSymbolSearch;
+exports.useTimezone = useTimezone;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map