react-klinecharts-ui 0.6.0 → 1.1.0

package/dist/index.js

@@ -1,31 +1,12 @@
-import { registerExtensions, TA_default, ensureAlertLineRegistered } from './chunk-MVD3ILJT.js';
-export { TA_default as TA, abcd_default as abcd, alertLine_default as alertLine, anyWaves_default as anyWaves, arrow_default as arrow, bollTv_default as bollTv, brush_default as brush, cci_default as cci, circle_default as circle, depthOverlay_default as depthOverlay, eightWaves_default as eightWaves, elliottWave_default as elliottWave, fibRetracement_default as fibRetracement, fibonacciCircle_default as fibonacciCircle, fibonacciExtension_default as fibonacciExtension, fibonacciSegment_default as fibonacciSegment, fibonacciSpeedResistanceFan_default as fibonacciSpeedResistanceFan, fibonacciSpiral_default as fibonacciSpiral, fiveWaves_default as fiveWaves, gannBox_default as gannBox, gannFan_default as gannFan, hma_default as hma, ichimoku_default as ichimoku, indicators, longPosition_default as longPosition, maRibbon_default as maRibbon, macdTv_default as macdTv, measure_default as measure, orderLine_default as orderLine, overlays, parallelChannel_default as parallelChannel, parallelogram_default as parallelogram, pivotPoints_default as pivotPoints, ray_default as ray, rect_default as rect, registerExtensions, rsiTv_default as rsiTv, shortPosition_default as shortPosition, stochastic_default as stochastic, superTrend_default as superTrend, threeWaves_default as threeWaves, triangle_default as triangle, vwap_default as vwap, xabcd_default as xabcd } from './chunk-MVD3ILJT.js';
-import { createContext, useContext, useReducer, useRef, useCallback, useEffect, useMemo, useState } from 'react';
-import { registerOverlay, registerHotkey, getHotkey, getSupportedHotkeys, registerIndicator } from 'react-klinecharts';
+import { registerExtensions, TA_default, ensureAlertLineRegistered } from './chunk-RIT2LJQT.js';
+export { TA_default as TA, abcd_default as abcd, alertLine_default as alertLine, anyWaves_default as anyWaves, arrow_default as arrow, bollTv_default as bollTv, brush_default as brush, cci_default as cci, circle_default as circle, depthOverlay_default as depthOverlay, eightWaves_default as eightWaves, elliottWave_default as elliottWave, fibRetracement_default as fibRetracement, fibonacciCircle_default as fibonacciCircle, fibonacciExtension_default as fibonacciExtension, fibonacciSegment_default as fibonacciSegment, fibonacciSpeedResistanceFan_default as fibonacciSpeedResistanceFan, fibonacciSpiral_default as fibonacciSpiral, fiveWaves_default as fiveWaves, gannBox_default as gannBox, gannFan_default as gannFan, hma_default as hma, ichimoku_default as ichimoku, indicators, longPosition_default as longPosition, maRibbon_default as maRibbon, macdTv_default as macdTv, measure_default as measure, orderLine_default as orderLine, overlays, parallelChannel_default as parallelChannel, parallelogram_default as parallelogram, pivotPoints_default as pivotPoints, ray_default as ray, rect_default as rect, registerExtensions, rsiTv_default as rsiTv, shortPosition_default as shortPosition, stochastic_default as stochastic, superTrend_default as superTrend, threeWaves_default as threeWaves, triangle_default as triangle, vwap_default as vwap, xabcd_default as xabcd } from './chunk-RIT2LJQT.js';
+import { KlinechartsUIStateContext, KlinechartsUIDispatchContext, useKlinechartsUI, useKlinechartsUIDispatch } from './chunk-O7E57I66.js';
+export { KlinechartsUIDispatchContext, KlinechartsUIStateContext, createDataLoader, useKlinechartsUI } from './chunk-O7E57I66.js';
+import './chunk-PZ5AY32C.js';
+import { createContext, useMemo, useReducer, useRef, useEffect, useCallback, useState, useId, useContext } from 'react';
+import { registerOverlay, registerHotkey, getHotkey, getSupportedHotkeys, registerIndicator } from 'klinecharts';
 import { jsx } from 'react/jsx-runtime';
 
-var KlinechartsUIStateContext = createContext(null);
-var KlinechartsUIDispatchContext = createContext(null);
-function useKlinechartsUIDispatch() {
-  const ctx = useContext(KlinechartsUIDispatchContext);
-  if (!ctx) {
-    throw new Error(
-      "useKlinechartsUI must be used within a <KlinechartsUIProvider>"
-    );
-  }
-  return ctx;
-}
-function useKlinechartsUI() {
-  const state = useContext(KlinechartsUIStateContext);
-  const dispatch = 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" },
@@ -39,6 +20,50 @@ var DEFAULT_PERIODS = [
   { span: 1, type: "month", label: "M" },
   { span: 1, type: "year", label: "Y" }
 ];
+
+// src/storage/types.ts
+var DEFAULT_STORAGE_NAMESPACES = [
+  "alerts",
+  "settings",
+  "indicators"
+];
+var DEFAULT_STORAGE_KEY_PREFIX = "rkui:";
+
+// src/storage/createDefaultStorage.ts
+var NOOP_ADAPTER = {
+  getItem: () => null,
+  setItem: () => {
+  },
+  removeItem: () => {
+  }
+};
+function createDefaultStorage() {
+  if (typeof localStorage === "undefined") return NOOP_ADAPTER;
+  try {
+    const probe = localStorage.getItem("__rkui_probe__");
+    return probe === null ? localStorage : localStorage;
+  } catch {
+    return NOOP_ADAPTER;
+  }
+}
+function resolveStorage(options) {
+  const adapter = options?.adapter ?? createDefaultStorage();
+  const keyPrefix = options?.keyPrefix ?? DEFAULT_STORAGE_KEY_PREFIX;
+  const namespaces = new Set(
+    options?.namespaces ?? DEFAULT_STORAGE_NAMESPACES
+  );
+  return {
+    adapter,
+    namespaces,
+    keyPrefix,
+    key(namespace) {
+      return `${keyPrefix}${namespace}`;
+    },
+    persists(namespace) {
+      return namespaces.has(namespace);
+    }
+  };
+}
 function reducer(state, action) {
   switch (action.type) {
     case "SET_CHART":
@@ -63,6 +88,25 @@ function reducer(state, action) {
       return { ...state, indicatorVisibility: action.visibility };
     case "SET_ALERTS":
       return { ...state, alerts: action.alerts };
+    case "ADD_ALERT":
+      return { ...state, alerts: [...state.alerts, action.alert] };
+    case "REMOVE_ALERT":
+      return {
+        ...state,
+        alerts: state.alerts.filter((a) => a.id !== action.id)
+      };
+    case "CLEAR_ALERTS":
+      return { ...state, alerts: [] };
+    case "MARK_ALERT_TRIGGERED": {
+      if (action.ids.length === 0) return state;
+      const triggered = new Set(action.ids);
+      return {
+        ...state,
+        alerts: state.alerts.map(
+          (a) => triggered.has(a.id) ? { ...a, triggered: true } : a
+        )
+      };
+    }
     case "SET_MEASURE":
       return { ...state, measure: { ...state.measure, ...action.measure } };
     case "SET_REPLAY":
@@ -83,13 +127,16 @@ function KlinechartsUIProvider({
   defaultPeriod,
   defaultTheme = "light",
   defaultTimezone = "Asia/Shanghai",
-  defaultMainIndicators = ["MA"],
-  defaultSubIndicators = ["VOL"],
+  // NOTE: no destructuring default here — the init function must distinguish
+  // "consumer passed default*" (wins) from "use stored value" (hydrate).
+  defaultMainIndicators,
+  defaultSubIndicators,
   defaultLocale = "en-US",
   periods,
   styles,
   registerExtensions: shouldRegister = true,
   overlays: extraOverlays,
+  storage: storageOptions,
   children,
   onStateChange,
   onSymbolChange,
@@ -100,6 +147,11 @@ function KlinechartsUIProvider({
   onSubIndicatorsChange,
   onSettingsChange
 }) {
+  const resolvedStorage = useMemo(
+    () => storageOptions ? resolveStorage(storageOptions) : null,
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
   const [state, dispatch] = useReducer(
     reducer,
     {
@@ -112,47 +164,66 @@ function KlinechartsUIProvider({
       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]: "" }),
-        {}
-      ),
-      indicatorAxes: {},
-      indicatorVisibility: {},
-      alerts: [],
-      measure: { isActive: false, fromPoint: null, result: null },
-      replay: {
-        isReplaying: false,
-        isPaused: false,
-        speed: 1,
-        barIndex: 0,
-        totalBars: 0
-      },
-      styles: opts.styles,
-      screenshotUrl: null
-    })
+      styles,
+      storage: resolvedStorage
+    },
+    (opts) => {
+      const s = opts.storage;
+      const read = (ns, fallback) => {
+        if (!s || !s.persists(ns)) return fallback;
+        try {
+          const raw = s.adapter.getItem(s.key(ns));
+          return raw ? JSON.parse(raw) : fallback;
+        } catch {
+          return fallback;
+        }
+      };
+      const storedIndicators = read("indicators", {});
+      return {
+        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,
+        // Persistence semantics: STORED values win over `default*` props —
+        // the user's saved configuration should survive reload even when the
+        // app passes defaults. Only when storage is empty/unconfigured do the
+        // `default*` props apply, falling back to the built-ins last.
+        // (Settings live in useKlinechartsUISettings useState and hydrate
+        // separately via the dispatch-context `storage`.)
+        mainIndicators: storedIndicators.main ?? opts.defaultMainIndicators ?? ["MA"],
+        subIndicators: storedIndicators.sub ?? (opts.defaultSubIndicators ? opts.defaultSubIndicators.reduce(
+          (acc, name) => ({ ...acc, [name]: "" }),
+          {}
+        ) : { VOL: "" }),
+        indicatorAxes: storedIndicators.axes ?? {},
+        indicatorVisibility: storedIndicators.visibility ?? {},
+        alerts: read("alerts", []),
+        measure: { isActive: false, fromPoint: null, result: null },
+        replay: {
+          isReplaying: false,
+          isPaused: false,
+          speed: 1,
+          barIndex: 0,
+          totalBars: 0
+        },
+        styles: opts.styles,
+        screenshotUrl: null
+      };
+    }
   );
   const fullscreenContainerRef = useRef(null);
   const undoRedoListenerRef = useRef(null);
-  const alertTriggeredListenerRef = useRef(null);
+  const alertTriggeredListenersRef = useRef(/* @__PURE__ */ new Set());
   const replayIntervalRef = useRef(null);
   const replaySavedDataRef = useRef([]);
   const replayIndexRef = useRef(0);
   const alertPrevCloseRef = useRef(null);
   const stateRef = useRef(state);
-  stateRef.current = state;
   const callbacksRef = useRef({
     onStateChange,
     onSymbolChange,
@@ -162,15 +233,18 @@ function KlinechartsUIProvider({
     onMainIndicatorsChange,
     onSubIndicatorsChange
   });
-  callbacksRef.current = {
-    onStateChange,
-    onSymbolChange,
-    onPeriodChange,
-    onThemeChange,
-    onTimezoneChange,
-    onMainIndicatorsChange,
-    onSubIndicatorsChange
-  };
+  useEffect(() => {
+    stateRef.current = state;
+    callbacksRef.current = {
+      onStateChange,
+      onSymbolChange,
+      onPeriodChange,
+      onThemeChange,
+      onTimezoneChange,
+      onMainIndicatorsChange,
+      onSubIndicatorsChange
+    };
+  });
   const enhancedDispatch = useCallback((action) => {
     const prevState = stateRef.current;
     const newState = reducer(prevState, action);
@@ -200,6 +274,12 @@ function KlinechartsUIProvider({
     }
   }, []);
   const extraOverlaysRef = useRef(extraOverlays);
+  const datafeedRef = useRef(datafeed);
+  const onSettingsChangeRef = useRef(onSettingsChange);
+  useEffect(() => {
+    datafeedRef.current = datafeed;
+    onSettingsChangeRef.current = onSettingsChange;
+  });
   useEffect(() => {
     if (shouldRegister) {
       registerExtensions();
@@ -216,34 +296,97 @@ function KlinechartsUIProvider({
     const chart = state.chart;
     if (!chart || !hasAlerts) return;
     alertPrevCloseRef.current = null;
+    const prevValueByAlert = /* @__PURE__ */ new Map();
     const interval = setInterval(() => {
       const dataList = chart.getDataList();
       if (!dataList || dataList.length === 0) return;
-      const currentClose = dataList[dataList.length - 1].close;
-      const prevClose = alertPrevCloseRef.current;
-      alertPrevCloseRef.current = currentClose;
-      if (prevClose === null) return;
+      const lastIdx = dataList.length - 1;
+      const indicatorCache = /* @__PURE__ */ new Map();
+      const readIndicatorValue = (indicatorId, figureKey) => {
+        const cacheKey = `${indicatorId}:${figureKey}`;
+        if (indicatorCache.has(cacheKey)) return indicatorCache.get(cacheKey);
+        let value = null;
+        try {
+          const indicators2 = chart.getIndicators({ id: indicatorId });
+          const ind = indicators2?.[0];
+          const result = ind?.result;
+          const last = Array.isArray(result) ? result[lastIdx] : null;
+          if (last && typeof last === "object") {
+            const v = last[figureKey];
+            value = typeof v === "number" ? v : null;
+          }
+        } catch {
+          value = null;
+        }
+        indicatorCache.set(cacheKey, value);
+        return value;
+      };
       const alerts = stateRef.current.alerts;
-      let changed = false;
-      const next = alerts.map((alert) => {
-        if (alert.triggered) return alert;
-        const crossedUp = prevClose < alert.price && currentClose >= alert.price;
-        const crossedDown = prevClose > alert.price && currentClose <= alert.price;
+      const triggeredIds = [];
+      for (const alert of alerts) {
+        if (alert.triggered) continue;
+        const target = alert.target ?? { type: "price" };
+        let currentValue;
+        if (target.type === "indicator") {
+          currentValue = readIndicatorValue(target.indicatorId, target.figureKey);
+        } else {
+          currentValue = dataList[lastIdx].close;
+        }
+        if (currentValue === null || !Number.isFinite(currentValue)) continue;
+        const prevValue = prevValueByAlert.get(alert.id) ?? null;
+        prevValueByAlert.set(alert.id, currentValue);
+        if (prevValue === null) continue;
+        const crossedUp = prevValue < alert.price && currentValue >= alert.price;
+        const crossedDown = prevValue > alert.price && currentValue <= alert.price;
         const shouldTrigger = alert.condition === "crossing_up" ? crossedUp : alert.condition === "crossing_down" ? crossedDown : crossedUp || crossedDown;
         if (shouldTrigger) {
-          changed = true;
-          const triggered = { ...alert, triggered: true };
-          alertTriggeredListenerRef.current?.(triggered);
-          return triggered;
+          triggeredIds.push(alert.id);
+          const fired = { ...alert, triggered: true };
+          alertTriggeredListenersRef.current.forEach((cb) => cb(fired));
         }
-        return alert;
-      });
-      if (changed) {
-        enhancedDispatch({ type: "SET_ALERTS", alerts: next });
+      }
+      if (triggeredIds.length > 0) {
+        enhancedDispatch({
+          type: "MARK_ALERT_TRIGGERED",
+          ids: triggeredIds
+        });
       }
     }, 1e3);
     return () => clearInterval(interval);
   }, [state.chart, hasAlerts, enhancedDispatch]);
+  useEffect(() => {
+    alertPrevCloseRef.current = null;
+  }, [state.symbol, state.period]);
+  const writeNs = useCallback(
+    (ns, value) => {
+      if (!resolvedStorage || !resolvedStorage.persists(ns)) return;
+      try {
+        resolvedStorage.adapter.setItem(
+          resolvedStorage.key(ns),
+          JSON.stringify(value)
+        );
+      } catch {
+      }
+    },
+    [resolvedStorage]
+  );
+  useEffect(() => {
+    writeNs("alerts", state.alerts);
+  }, [state.alerts, writeNs]);
+  useEffect(() => {
+    writeNs("indicators", {
+      main: state.mainIndicators,
+      sub: state.subIndicators,
+      axes: state.indicatorAxes,
+      visibility: state.indicatorVisibility
+    });
+  }, [
+    state.mainIndicators,
+    state.subIndicators,
+    state.indicatorAxes,
+    state.indicatorVisibility,
+    writeNs
+  ]);
   useEffect(() => {
     return () => {
       if (replayIntervalRef.current !== null) {
@@ -255,16 +398,18 @@ function KlinechartsUIProvider({
   const dispatchValue = useMemo(
     () => ({
       dispatch: enhancedDispatch,
-      datafeed,
-      onSettingsChange,
+      datafeed: datafeedRef.current,
+      onSettingsChange: onSettingsChangeRef.current,
       fullscreenContainerRef,
       undoRedoListenerRef,
-      alertTriggeredListenerRef,
+      alertTriggeredListenersRef,
       replayIntervalRef,
       replaySavedDataRef,
-      replayIndexRef
+      replayIndexRef,
+      storage: resolvedStorage
     }),
-    [enhancedDispatch, datafeed, onSettingsChange]
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [enhancedDispatch, resolvedStorage]
   );
   return /* @__PURE__ */ jsx(KlinechartsUIStateContext.Provider, { value: state, children: /* @__PURE__ */ jsx(KlinechartsUIDispatchContext.Provider, { value: dispatchValue, children }) });
 }
@@ -1222,15 +1367,17 @@ function useDrawingTools() {
   const [isVisible, setIsVisible] = useState(true);
   const [autoRetrigger, setAutoRetrigger] = useState(true);
   const activeToolRef = useRef(activeTool);
-  activeToolRef.current = activeTool;
   const autoRetriggerRef = useRef(autoRetrigger);
-  autoRetriggerRef.current = autoRetrigger;
   const isLockedRef = useRef(isLocked);
-  isLockedRef.current = isLocked;
   const isVisibleRef = useRef(isVisible);
-  isVisibleRef.current = isVisible;
   const magnetModeRef = useRef(magnetMode);
-  magnetModeRef.current = magnetMode;
+  useEffect(() => {
+    activeToolRef.current = activeTool;
+    autoRetriggerRef.current = autoRetrigger;
+    isLockedRef.current = isLocked;
+    isVisibleRef.current = isVisible;
+    magnetModeRef.current = magnetMode;
+  });
   const categories = useMemo(
     () => DRAWING_CATEGORIES.map((cat) => ({
       key: cat.key,
@@ -1241,6 +1388,8 @@ function useDrawingTools() {
     })),
     []
   );
+  const createOverlayForToolRef = useRef(() => {
+  });
   const createOverlayForTool = useCallback(
     (name) => {
       const mode = magnetModeRef.current === "strong" ? "strong_magnet" : magnetModeRef.current === "weak" ? "weak_magnet" : "normal";
@@ -1266,7 +1415,7 @@ function useDrawingTools() {
           });
           if (autoRetriggerRef.current && activeToolRef.current === name) {
             requestAnimationFrame(() => {
-              createOverlayForTool(name);
+              createOverlayForToolRef.current(name);
             });
           }
         }
@@ -1274,6 +1423,9 @@ function useDrawingTools() {
     },
     [state.chart, undoRedoListenerRef]
   );
+  useEffect(() => {
+    createOverlayForToolRef.current = createOverlayForTool;
+  });
   const selectTool = useCallback(
     (name) => {
       setActiveTool(name);
@@ -1399,7 +1551,17 @@ var defaultSettings = {
 };
 function useKlinechartsUISettings() {
   const { state, onSettingsChange } = useKlinechartsUI();
-  const [settings, setSettings] = useState(defaultSettings);
+  const { storage } = useKlinechartsUIDispatch();
+  const [settings, setSettings] = useState(() => {
+    if (storage && storage.persists("settings")) {
+      try {
+        const raw = storage.adapter.getItem(storage.key("settings"));
+        if (raw) return { ...defaultSettings, ...JSON.parse(raw) };
+      } catch {
+      }
+    }
+    return defaultSettings;
+  });
   const isInitialMount = useRef(true);
   useEffect(() => {
     if (isInitialMount.current) {
@@ -1408,6 +1570,14 @@ function useKlinechartsUISettings() {
     }
     onSettingsChange?.({ ...settings });
   }, [settings, onSettingsChange]);
+  useEffect(() => {
+    if (!storage || !storage.persists("settings")) return;
+    if (isInitialMount.current) return;
+    try {
+      storage.adapter.setItem(storage.key("settings"), JSON.stringify(settings));
+    } catch {
+    }
+  }, [settings, storage]);
   const candleTypes = useMemo(
     () => CANDLE_TYPES.map((ct) => ({
       key: ct.key,
@@ -1730,22 +1900,28 @@ function useFullscreen() {
   const enter = useCallback(() => {
     const el = fullscreenContainerRef.current;
     if (!el) return;
+    let result;
     if (el.requestFullscreen) {
-      el.requestFullscreen();
+      result = el.requestFullscreen();
     } else if ("webkitRequestFullscreen" in el) {
       el.webkitRequestFullscreen();
     } else if ("msRequestFullscreen" in el) {
       el.msRequestFullscreen();
     }
+    result?.catch(() => {
+    });
   }, [fullscreenContainerRef]);
   const exit = useCallback(() => {
+    let result;
     if (document.exitFullscreen) {
-      document.exitFullscreen();
+      result = document.exitFullscreen();
     } else if ("webkitExitFullscreen" in document) {
       document.webkitExitFullscreen();
     } else if ("msExitFullscreen" in document) {
       document.msExitFullscreen();
     }
+    result?.catch(() => {
+    });
   }, []);
   const toggle = useCallback(() => {
     if (isFullscreen) {
@@ -1776,6 +1952,7 @@ function useFullscreen() {
 function useOrderLines() {
   const { state } = useKlinechartsUI();
   const callbacksRef = useRef(/* @__PURE__ */ new Map());
+  const ownedIdsRef = useRef(/* @__PURE__ */ new Set());
   const createOrderLine = useCallback(
     (options) => {
       if (!state.chart) return null;
@@ -1806,6 +1983,7 @@ function useOrderLines() {
           }
         }
       });
+      ownedIdsRef.current.add(id);
       return id;
     },
     [state.chart]
@@ -1837,12 +2015,28 @@ function useOrderLines() {
     (id) => {
       state.chart?.removeOverlay({ id });
       callbacksRef.current.delete(id);
+      ownedIdsRef.current.delete(id);
     },
     [state.chart]
   );
   const removeAllOrderLines = useCallback(() => {
     state.chart?.removeOverlay({ name: "orderLine" });
     callbacksRef.current.clear();
+    ownedIdsRef.current.clear();
+  }, [state.chart]);
+  useEffect(() => {
+    const chart = state.chart;
+    const owned = ownedIdsRef.current;
+    return () => {
+      owned.forEach((id) => {
+        try {
+          chart?.removeOverlay({ id });
+        } catch {
+        }
+      });
+      owned.clear();
+      callbacksRef.current.clear();
+    };
   }, [state.chart]);
   return {
     createOrderLine,
@@ -1860,6 +2054,14 @@ function useUndoRedo() {
   const isProcessingRef = useRef(false);
   const canUndo = undoStack.length > 0;
   const canRedo = redoStack.length > 0;
+  const undoStackRef = useRef([]);
+  const redoStackRef = useRef([]);
+  useEffect(() => {
+    undoStackRef.current = undoStack;
+  }, [undoStack]);
+  useEffect(() => {
+    redoStackRef.current = redoStack;
+  }, [redoStack]);
   const pushAction = useCallback((action) => {
     if (isProcessingRef.current) return;
     setUndoStack((prev) => [...prev, action]);
@@ -1876,10 +2078,11 @@ function useUndoRedo() {
     setRedoStack([]);
   }, []);
   const undo = useCallback(() => {
-    if (undoStack.length === 0 || !state.chart || isProcessingRef.current)
+    const stack = undoStackRef.current;
+    if (stack.length === 0 || !state.chart || isProcessingRef.current)
       return;
     isProcessingRef.current = true;
-    const action = undoStack[undoStack.length - 1];
+    const action = stack[stack.length - 1];
     setUndoStack((prev) => prev.slice(0, -1));
     try {
       switch (action.type) {
@@ -2000,12 +2203,13 @@ function useUndoRedo() {
     } finally {
       isProcessingRef.current = false;
     }
-  }, [undoStack, state.chart, state.mainIndicators, state.subIndicators, state.indicatorAxes, dispatch]);
+  }, [state.chart, state.mainIndicators, state.subIndicators, state.indicatorAxes, dispatch]);
   const redo = useCallback(() => {
-    if (redoStack.length === 0 || !state.chart || isProcessingRef.current)
+    const stack = redoStackRef.current;
+    if (stack.length === 0 || !state.chart || isProcessingRef.current)
       return;
     isProcessingRef.current = true;
-    const action = redoStack[redoStack.length - 1];
+    const action = stack[stack.length - 1];
     setRedoStack((prev) => prev.slice(0, -1));
     try {
       switch (action.type) {
@@ -2130,7 +2334,7 @@ function useUndoRedo() {
     } finally {
       isProcessingRef.current = false;
     }
-  }, [redoStack, state.chart, state.mainIndicators, state.subIndicators, state.indicatorAxes, dispatch]);
+  }, [state.chart, state.mainIndicators, state.subIndicators, state.indicatorAxes, dispatch]);
   useEffect(() => {
     const handleKeyDown = (e) => {
       const isCtrlOrMeta = e.ctrlKey || e.metaKey;
@@ -2168,6 +2372,7 @@ function generateId() {
   );
 }
 function getLayoutIds() {
+  if (typeof localStorage === "undefined") return [];
   try {
     const raw = localStorage.getItem(INDEX_KEY);
     return raw ? JSON.parse(raw) : [];
@@ -2176,6 +2381,7 @@ function getLayoutIds() {
   }
 }
 function getEntry(id) {
+  if (typeof localStorage === "undefined") return null;
   try {
     const raw = localStorage.getItem(STORAGE_KEY_PREFIX + id);
     return raw ? JSON.parse(raw) : null;
@@ -2185,35 +2391,31 @@ function getEntry(id) {
 }
 function useLayoutManager() {
   const { state, dispatch } = useKlinechartsUI();
-  const [layouts, setLayouts] = useState([]);
+  const [layouts, setLayouts] = useState(
+    () => getLayoutIds().map((id) => getEntry(id)).filter((e) => e !== null)
+  );
   const [autoSaveEnabled, setAutoSaveEnabled] = useState(false);
   const autoSaveTimerRef = useRef(null);
   const autoSaveIdRef = useRef(null);
   const refreshLayouts = useCallback(() => {
-    const entries = getLayoutIds().map((id) => getEntry(id)).filter((e) => e !== null);
-    setLayouts(entries);
+    setLayouts(
+      getLayoutIds().map((id) => getEntry(id)).filter((e) => e !== null)
+    );
   }, []);
-  useEffect(() => {
-    refreshLayouts();
-  }, [refreshLayouts]);
   const serializeState = useCallback(() => {
     const chart = state.chart;
     if (!chart) return null;
     const indicators2 = [];
-    const indicatorMap = chart.getIndicatorByPaneId?.();
-    if (indicatorMap) {
-      indicatorMap.forEach((paneIndicators, paneId) => {
-        paneIndicators.forEach((indicator) => {
-          const yAxisId = state.indicatorAxes[indicator.id];
-          indicators2.push({
-            paneId,
-            name: indicator.name,
-            calcParams: indicator.calcParams,
-            visible: indicator.visible,
-            ...indicator.styles ? { styles: indicator.styles } : {},
-            ...yAxisId ? { yAxisId } : {}
-          });
-        });
+    const allIndicators = chart.getIndicators();
+    for (const indicator of allIndicators) {
+      const yAxisId = state.indicatorAxes[indicator.id];
+      indicators2.push({
+        paneId: indicator.paneId,
+        name: indicator.name,
+        calcParams: indicator.calcParams,
+        visible: indicator.visible,
+        ...indicator.styles ? { styles: indicator.styles } : {},
+        ...yAxisId ? { yAxisId } : {}
       });
     }
     const drawings = [];
@@ -2277,13 +2479,8 @@ function useLayoutManager() {
       if (chartState.version !== STATE_VERSION) return false;
       const chart = state.chart;
       chart.removeOverlay();
-      const indicatorMap = chart.getIndicatorByPaneId?.();
-      if (indicatorMap) {
-        indicatorMap.forEach((_paneIndicators, paneId) => {
-          _paneIndicators.forEach((_, indicatorName) => {
-            chart.removeIndicator({ paneId, name: indicatorName });
-          });
-        });
+      for (const indicator of chart.getIndicators()) {
+        chart.removeIndicator({ id: indicator.id });
       }
       const newMainIndicators = [];
       const newSubIndicators = {};
@@ -2301,7 +2498,12 @@ function useLayoutManager() {
               visible: ind.visible
             },
             {
-              isStack: ind.paneId !== "candle_pane",
+              // Main indicators stack OVER the candle series on the candle
+              // pane (isStack: true), exactly as useIndicators does on the
+              // add path. The previous `ind.paneId !== "candle_pane"` inverted
+              // this, so loading a layout with main indicators replaced the
+              // candles instead of overlaying them.
+              isStack: isMain,
               pane: { id: ind.paneId },
               ...ind.yAxisId ? { yAxis: { id: ind.yAxisId } } : {}
             }
@@ -2501,8 +2703,10 @@ function useScriptEditor() {
   const [status, setStatus] = useState("");
   const [isRunning, setIsRunning] = useState(false);
   const activeIdRef = useRef(null);
+  const [activeName, setActiveName] = useState(null);
   const activeNameRef = useRef(null);
-  const hasActiveScript = activeNameRef.current !== null;
+  activeNameRef.current = activeName;
+  const hasActiveScript = activeName !== null;
   const runScript = useCallback(() => {
     const chart = state.chart;
     if (!chart) {
@@ -2523,19 +2727,26 @@ function useScriptEditor() {
         `"use strict";
 ${code}`
       ];
-      const fn = new Function(...allArgs);
+      const compiledFn = new Function(...allArgs);
       const shadowValues = SHADOW_KEYS.map(() => void 0);
-      const result = fn(...shadowValues, TA_default, dataList, parsedParams);
-      if (!Array.isArray(result)) {
+      const sampleResult = compiledFn(
+        ...shadowValues,
+        TA_default,
+        dataList,
+        parsedParams
+      );
+      if (!Array.isArray(sampleResult)) {
         throw new Error("Script must return an Array.");
       }
-      const sample = result.find((v) => v !== null && v !== void 0);
+      const sample = sampleResult.find(
+        (v) => v !== null && v !== void 0
+      );
       const seriesKeys = sample ? Object.keys(sample) : ["value"];
       if (seriesKeys.length === 0) {
         throw new Error("Returned objects have no keys.");
       }
       scriptCounter++;
-      const indicatorName = `_custom_script_${scriptCounter}`;
+      const indicatorName = `_custom_script_active`;
       const figures = seriesKeys.map((key, i) => ({
         key,
         title: `${key}: `,
@@ -2547,7 +2758,7 @@ ${code}`
         shortName: (scriptName.trim() || `Script #${scriptCounter}`) + (placement === "main" ? " (Main)" : " (Sub)"),
         calcParams: parsedParams,
         figures,
-        calc: () => result,
+        calc: (liveDataList) => compiledFn(...shadowValues, TA_default, liveDataList, parsedParams),
         extendData: {
           isCustomScript: true,
           code,
@@ -2573,7 +2784,7 @@ ${code}`
         paneId = chart.createIndicator({ name: indicatorName });
       }
       activeIdRef.current = typeof paneId === "string" ? paneId : null;
-      activeNameRef.current = indicatorName;
+      setActiveName(indicatorName);
       const title = scriptName.trim() || `Script #${scriptCounter}`;
       setStatus(
         `${title} applied to ${placement === "main" ? "Main Chart" : "Sub Pane"} \u2014 ${seriesKeys.length} series: ${seriesKeys.join(", ")}`
@@ -2595,7 +2806,7 @@ ${code}`
       } catch {
       }
       activeIdRef.current = null;
-      activeNameRef.current = null;
+      setActiveName(null);
       setStatus("Indicator removed.");
     }
   }, [state.chart]);
@@ -2709,10 +2920,10 @@ function useCrosshair() {
 var alertCounter = 0;
 function useAlerts() {
   const { state, dispatch } = useKlinechartsUI();
-  const { alertTriggeredListenerRef } = useKlinechartsUIDispatch();
+  const { alertTriggeredListenersRef } = useKlinechartsUIDispatch();
   const alerts = state.alerts;
   const addAlert = useCallback(
-    (price, condition, message, extendData) => {
+    (price, condition, message, extendData, target) => {
       const id = `alert_${++alertCounter}`;
       const precision = state.chart?.getSymbol()?.pricePrecision ?? 2;
       const resolvedExtendData = {
@@ -2725,9 +2936,12 @@ function useAlerts() {
         condition,
         message,
         triggered: false,
-        extendData: resolvedExtendData
+        extendData: resolvedExtendData,
+        // Persist the target only when it's an indicator alert; omit for the
+        // default price target so existing serialized alerts stay compatible.
+        ...target && target.type === "indicator" ? { target } : {}
       };
-      dispatch({ type: "SET_ALERTS", alerts: [...state.alerts, alert] });
+      dispatch({ type: "ADD_ALERT", alert });
       if (state.chart) {
         ensureAlertLineRegistered();
         state.chart.createOverlay({
@@ -2741,29 +2955,28 @@ function useAlerts() {
       }
       return id;
     },
-    [state.chart, state.alerts, dispatch]
+    [state.chart, dispatch]
   );
   const removeAlert = useCallback(
     (id) => {
-      dispatch({
-        type: "SET_ALERTS",
-        alerts: state.alerts.filter((a) => a.id !== id)
-      });
+      dispatch({ type: "REMOVE_ALERT", id });
       state.chart?.removeOverlay({ id });
     },
-    [state.chart, state.alerts, dispatch]
+    [state.chart, dispatch]
   );
   const clearAlerts = useCallback(() => {
-    for (const alert of state.alerts) {
-      state.chart?.removeOverlay({ id: alert.id });
-    }
-    dispatch({ type: "SET_ALERTS", alerts: [] });
-  }, [state.chart, state.alerts, dispatch]);
+    state.chart?.removeOverlay({ groupId: "price_alerts" });
+    dispatch({ type: "CLEAR_ALERTS" });
+  }, [state.chart, dispatch]);
   const onAlertTriggered = useCallback(
     (callback) => {
-      alertTriggeredListenerRef.current = callback;
+      const set = alertTriggeredListenersRef.current;
+      set.add(callback);
+      return () => {
+        set.delete(callback);
+      };
     },
-    [alertTriggeredListenerRef]
+    [alertTriggeredListenersRef]
   );
   return {
     alerts,
@@ -2942,6 +3155,7 @@ function useReplay() {
   );
   const startReplay = useCallback(() => {
     if (!state.chart) return;
+    if (isReplaying) return;
     const dataList = state.chart.getDataList();
     if (!dataList || dataList.length === 0) return;
     replaySavedDataRef.current = [...dataList];
@@ -2957,7 +3171,12 @@ function useReplay() {
     });
     state.chart.clearData?.();
     startInterval(speed);
-  }, [state.chart, speed, startInterval, replaySavedDataRef, replayIndexRef, dispatch]);
+  }, [state.chart, state.symbol, state.period, speed, startInterval, isReplaying, replaySavedDataRef, replayIndexRef, dispatch]);
+  useEffect(() => {
+    if (isReplaying) {
+      stopReplay();
+    }
+  }, [state.symbol, state.period]);
   const stopReplay = useCallback(() => {
     if (!state.chart) return;
     clearInterval_();
@@ -3053,24 +3272,29 @@ var DEFAULT_COLORS = [
   "#ff5722",
   "#8bc34a"
 ];
-var colorIndex = 0;
-var compareCounter = 0;
 function useCompare() {
   const { state, datafeed } = useKlinechartsUI();
   const [symbols, setSymbols] = useState([]);
   const indicatorsRef = useRef(/* @__PURE__ */ new Map());
+  const instanceSalt = useId().replace(/[^a-zA-Z0-9]/g, "");
   const addSymbol = useCallback(
     async (ticker, color) => {
       if (!state.chart || !datafeed) return;
       if (indicatorsRef.current.has(ticker)) return;
-      const assignedColor = color ?? DEFAULT_COLORS[colorIndex++ % DEFAULT_COLORS.length];
+      const assignedColor = color ?? DEFAULT_COLORS[symbols.length % DEFAULT_COLORS.length];
       const mainDataList = state.chart.getDataList();
       if (!mainDataList || mainDataList.length === 0) return;
       const from = mainDataList[0].timestamp;
       const to = mainDataList[mainDataList.length - 1].timestamp;
+      const mainSymbol = state.symbol;
+      const symbol = {
+        ticker,
+        pricePrecision: mainSymbol?.pricePrecision ?? 2,
+        volumePrecision: mainSymbol?.volumePrecision ?? 8
+      };
       const compareData = await datafeed.getHistoryKLineData(
-        { ticker },
-        { ...state.period, label: "" },
+        symbol,
+        state.period,
         from,
         to
       );
@@ -3089,13 +3313,7 @@ function useCompare() {
       }
       if (basePrice === null || basePrice === 0) return;
       const bp = basePrice;
-      const normalizedData = mainDataList.map((mainBar) => {
-        const close = compareMap.get(mainBar.timestamp);
-        return {
-          pct: close != null ? (close - bp) / bp * 100 : NaN
-        };
-      });
-      const indicatorName = `__cmp_${++compareCounter}_${ticker}`;
+      const indicatorName = `__cmp_${instanceSalt}_${ticker}`;
       registerIndicator({
         name: indicatorName,
         shortName: ticker,
@@ -3107,7 +3325,16 @@ function useCompare() {
             styles: () => ({ color: assignedColor })
           }
         ],
-        calc: () => normalizedData
+        calc: (dataList) => {
+          let lastPct = null;
+          return dataList.map((bar) => {
+            const close = compareMap.get(bar.timestamp);
+            if (close != null) {
+              lastPct = (close - bp) / bp * 100;
+            }
+            return { pct: lastPct };
+          });
+        }
       });
       const paneId = state.chart.createIndicator(
         { name: indicatorName },
@@ -3125,7 +3352,7 @@ function useCompare() {
         ];
       });
     },
-    [state.chart, state.period, datafeed]
+    [state.chart, state.symbol, state.period, datafeed, symbols.length, instanceSalt]
   );
   const removeSymbol = useCallback(
     (ticker) => {
@@ -3335,13 +3562,11 @@ function useAnnotations() {
     [state.chart]
   );
   const clearAnnotations = useCallback(() => {
-    setAnnotations((prev) => {
-      for (const annotation of prev) {
-        state.chart?.removeOverlay({ id: annotation.id });
-      }
-      return [];
-    });
-  }, [state.chart]);
+    for (const annotation of annotations) {
+      state.chart?.removeOverlay({ id: annotation.id });
+    }
+    setAnnotations([]);
+  }, [state.chart, annotations]);
   useEffect(() => {
     return () => {
       state.chart?.removeOverlay({ groupId: "annotations" });
@@ -3355,71 +3580,161 @@ function useAnnotations() {
     clearAnnotations
   };
 }
+var WorkspaceContext = createContext(null);
+function useWorkspace() {
+  const ctx = useContext(WorkspaceContext);
+  if (!ctx) {
+    throw new Error("useWorkspace must be used within a <WorkspaceProvider>");
+  }
+  return ctx;
+}
 
-// src/utils/createDataLoader.ts
-function createDataLoader(datafeed, dispatch) {
-  let oldestTimestamp = null;
-  let currentGen = 0;
-  return {
-    getBars: async (params) => {
+// src/workspace/types.ts
+var DEFAULT_SYNC_CONFIG = {
+  crosshair: true,
+  scroll: true,
+  zoom: true,
+  symbol: true,
+  period: true
+};
+function reducer2(state, action) {
+  switch (action.type) {
+    case "SET_CELLS":
+      return { ...state, cells: action.cells };
+    case "ADD_CELL":
+      return { ...state, cells: [...state.cells, action.cell] };
+    case "REMOVE_CELL": {
+      const cells = state.cells.filter((c) => c.id !== action.id);
+      return {
+        cells,
+        activeCellId: state.activeCellId === action.id ? cells[0]?.id ?? null : state.activeCellId
+      };
+    }
+    case "SET_CELL_SYMBOL":
+      return {
+        ...state,
+        cells: state.cells.map(
+          (c) => c.id === action.id ? { ...c, symbol: action.symbol } : c
+        )
+      };
+    case "SET_CELL_PERIOD":
+      return {
+        ...state,
+        cells: state.cells.map(
+          (c) => c.id === action.id ? { ...c, period: action.period } : c
+        )
+      };
+    case "SET_ACTIVE_CELL":
+      return { ...state, activeCellId: action.id };
+    default:
+      return state;
+  }
+}
+function WorkspaceProvider({
+  defaultCells,
+  sync,
+  children
+}) {
+  const [state, dispatch] = useReducer(reducer2, defaultCells, (cells) => ({
+    cells,
+    activeCellId: cells[0]?.id ?? null
+  }));
+  const chartsRef = useRef(/* @__PURE__ */ new Map());
+  const broadcastingRef = useRef(false);
+  const resolvedSync = useMemo(
+    () => ({ ...DEFAULT_SYNC_CONFIG, ...sync }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const value = useMemo(
+    () => ({
+      state,
+      dispatch,
+      chartsRef,
+      broadcastingRef,
+      sync: resolvedSync
+    }),
+    [state, resolvedSync]
+  );
+  return /* @__PURE__ */ jsx(WorkspaceContext.Provider, { value, children });
+}
+function useChartSync({ cellId }) {
+  const { chartsRef, broadcastingRef, sync, dispatch: workspaceDispatch } = useWorkspace();
+  const { state } = useKlinechartsUI();
+  const chart = state.chart;
+  useEffect(() => {
+    if (!chart) return;
+    chartsRef.current.set(cellId, chart);
+    return () => {
+      chartsRef.current.delete(cellId);
+    };
+  }, [chart, cellId, chartsRef]);
+  useEffect(() => {
+    if (!chart) return;
+    const broadcast = (fn) => {
+      if (broadcastingRef.current) return;
+      broadcastingRef.current = true;
       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;
+        chartsRef.current.forEach((target, id) => {
+          if (id !== cellId) {
+            try {
+              fn(target);
+            } catch {
+            }
           }
-          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 });
+        broadcastingRef.current = false;
       }
-    },
-    subscribeBar: (params) => {
-      datafeed.subscribe(
-        params.symbol,
-        { ...params.period, label: "" },
-        (klineData) => params.callback(klineData)
+    };
+    const onCrosshairChange = (data) => {
+      if (!sync.crosshair) return;
+      const crosshair = data;
+      if (!crosshair) return;
+      broadcast((target) => target.executeAction("onCrosshairChange", crosshair));
+    };
+    const onScroll = () => {
+      if (!sync.scroll) return;
+      let range = null;
+      try {
+        range = chart.getVisibleRange();
+      } catch {
+        return;
+      }
+      if (!range || range.realTo == null) return;
+      broadcast(
+        (target) => target.scrollToTimestamp(range.realTo, 0)
       );
-    },
-    unsubscribeBar: (params) => {
-      datafeed.unsubscribe(params.symbol, { ...params.period, label: "" });
+    };
+    const onZoom = () => {
+      if (!sync.zoom) return;
+      let bar = 0;
+      try {
+        bar = chart.getBarSpace().bar;
+      } catch {
+        return;
+      }
+      broadcast((target) => target.setBarSpace(bar));
+    };
+    chart.subscribeAction("onCrosshairChange", onCrosshairChange);
+    chart.subscribeAction("onScroll", onScroll);
+    chart.subscribeAction("onZoom", onZoom);
+    return () => {
+      chart.unsubscribeAction("onCrosshairChange", onCrosshairChange);
+      chart.unsubscribeAction("onScroll", onScroll);
+      chart.unsubscribeAction("onZoom", onZoom);
+    };
+  }, [chart, cellId, chartsRef, broadcastingRef, sync.crosshair, sync.scroll, sync.zoom]);
+  useEffect(() => {
+    if (state.symbol) {
+      workspaceDispatch({ type: "SET_CELL_SYMBOL", id: cellId, symbol: state.symbol });
     }
-  };
+  }, [state.symbol]);
+  useEffect(() => {
+    workspaceDispatch({ type: "SET_CELL_PERIOD", id: cellId, period: state.period });
+  }, [state.period]);
 }
 
-export { CANDLE_TYPES, COMPARE_RULES, DEFAULT_PERIODS, DRAWING_CATEGORIES, INDICATOR_PARAMS, KlinechartsUIDispatchContext, KlinechartsUIProvider, KlinechartsUIStateContext, MAIN_INDICATORS, PRICE_AXIS_TYPES, SUB_INDICATORS, TIMEZONES, TOOLTIP_SHOW_RULES, YAXIS_POSITIONS, createDataLoader, useAlerts, useAnnotations, useChartAxes, useCompare, useCrosshair, useDataExport, useDrawingTools, useFullscreen, useHotkeys, useIndicators, useKlinechartsUI, useKlinechartsUILoading, useKlinechartsUISettings, useKlinechartsUITheme, useLayoutManager, useMeasure, useOrderLines, usePeriods, useReplay, useScreenshot, useScriptEditor, useSymbolSearch, useTimezone, useUndoRedo, useWatchlist };
+export { CANDLE_TYPES, COMPARE_RULES, DEFAULT_PERIODS, DEFAULT_STORAGE_KEY_PREFIX, DEFAULT_STORAGE_NAMESPACES, DEFAULT_SYNC_CONFIG, DRAWING_CATEGORIES, INDICATOR_PARAMS, KlinechartsUIProvider, MAIN_INDICATORS, PRICE_AXIS_TYPES, SUB_INDICATORS, TIMEZONES, TOOLTIP_SHOW_RULES, WorkspaceProvider, YAXIS_POSITIONS, createDefaultStorage, resolveStorage, useAlerts, useAnnotations, useChartAxes, useChartSync, useCompare, useCrosshair, useDataExport, useDrawingTools, useFullscreen, useHotkeys, useIndicators, useKlinechartsUILoading, useKlinechartsUISettings, useKlinechartsUITheme, useLayoutManager, useMeasure, useOrderLines, usePeriods, useReplay, useScreenshot, useScriptEditor, useSymbolSearch, useTimezone, useUndoRedo, useWatchlist, useWorkspace };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map