hyperprop-charting-library 0.1.135 → 0.1.137

package/dist/index.js

@@ -2121,6 +2121,82 @@ var hashScriptSource = (source) => {
   }
   return (hash >>> 0).toString(36);
 };
+var SCRIPT_SOURCE_INPUT_VALUES = ["open", "high", "low", "close", "hl2", "hlc3", "ohlc4"];
+var slugifyInputLabel = (label) => {
+  const slug = String(label).trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return slug || "input";
+};
+var createScriptInputHelper = (values, registry) => {
+  const usedKeys = /* @__PURE__ */ new Set();
+  const resolveKey = (label, options) => {
+    let key = options?.key ?? slugifyInputLabel(label);
+    if (usedKeys.has(key)) {
+      let suffix = 2;
+      while (usedKeys.has(`${key}_${suffix}`)) suffix += 1;
+      key = `${key}_${suffix}`;
+    }
+    usedKeys.add(key);
+    return key;
+  };
+  const resolve = (key, fallback, coerce) => {
+    if (!values) return fallback;
+    const raw = values[key];
+    if (raw === void 0 || raw === null) return fallback;
+    const coerced = coerce(raw);
+    return coerced === void 0 ? fallback : coerced;
+  };
+  const coerceNumber = (raw) => {
+    const num = typeof raw === "number" ? raw : Number(raw);
+    return Number.isFinite(num) ? num : void 0;
+  };
+  const numberInput = (integer) => (label, defaultValue, options) => {
+    const key = resolveKey(label, options);
+    registry?.push({
+      key,
+      label,
+      type: "number",
+      default: defaultValue,
+      ...options?.min !== void 0 ? { min: options.min } : {},
+      ...options?.max !== void 0 ? { max: options.max } : {},
+      ...options?.step !== void 0 ? { step: options.step } : integer ? { step: 1 } : {}
+    });
+    const value = resolve(key, defaultValue, coerceNumber);
+    return integer ? Math.round(value) : value;
+  };
+  const selectInput = (label, defaultValue, choices, options) => {
+    const key = resolveKey(label, options);
+    const normalized = (Array.isArray(choices) ? choices : []).map(
+      (choice) => typeof choice === "string" ? { value: choice, label: choice } : { value: String(choice.value), label: String(choice.label ?? choice.value) }
+    );
+    registry?.push({ key, label, type: "select", default: defaultValue, options: normalized });
+    return resolve(key, defaultValue, (raw) => typeof raw === "string" ? raw : String(raw));
+  };
+  return Object.freeze({
+    int: numberInput(true),
+    float: numberInput(false),
+    bool: (label, defaultValue = false, options) => {
+      const key = resolveKey(label, options);
+      registry?.push({ key, label, type: "boolean", default: defaultValue });
+      return resolve(
+        key,
+        defaultValue,
+        (raw) => typeof raw === "boolean" ? raw : raw === "true" ? true : raw === "false" ? false : void 0
+      );
+    },
+    color: (label, defaultValue, options) => {
+      const key = resolveKey(label, options);
+      registry?.push({ key, label, type: "color", default: defaultValue });
+      return resolve(key, defaultValue, (raw) => typeof raw === "string" ? raw : void 0);
+    },
+    string: (label, defaultValue = "", options) => {
+      const key = resolveKey(label, options);
+      registry?.push({ key, label, type: "string", default: defaultValue });
+      return resolve(key, defaultValue, (raw) => typeof raw === "string" ? raw : String(raw));
+    },
+    select: selectInput,
+    source: (label = "Source", defaultValue = "close", options) => selectInput(label, defaultValue, SCRIPT_SOURCE_INPUT_VALUES, options)
+  });
+};
 var SCRIPT_GUARD_BUDGET_MS = 1e3;
 var ScriptBudgetError = class extends Error {
   constructor() {
@@ -2395,31 +2471,34 @@ var injectLoopGuards = (source, guardName) => {
   }
   return out;
 };
-var compileScriptCompute = (source, guard) => {
+var compileScriptFactory = (source) => {
   const makeFactory = (body) => new Function(
     "__hpGuard",
+    "input",
     `"use strict";
 ${body}
 ;if (typeof compute !== "function") { throw new Error("Script must define function compute(bars, inputs, hp)"); }
 return compute;`
   );
-  let factory;
   try {
-    factory = makeFactory(injectLoopGuards(source, "__hpGuard"));
+    return makeFactory(injectLoopGuards(source, "__hpGuard"));
   } catch {
-    factory = makeFactory(source);
+    return makeFactory(source);
   }
-  guard.reset();
-  return factory(guard);
 };
-var validateScriptSource = (source) => {
+var extractScriptInputs = (source) => {
+  const registry = [];
   try {
-    compileScriptCompute(source, createScriptGuard());
-    return null;
+    const factory = compileScriptFactory(source);
+    const guard = createScriptGuard();
+    guard.reset();
+    factory(guard, createScriptInputHelper(null, registry));
+    return { inputs: registry, error: null };
   } catch (error) {
-    return error instanceof Error ? error.message : String(error);
+    return { inputs: registry, error: error instanceof Error ? error.message : String(error) };
   }
 };
+var validateScriptSource = (source) => extractScriptInputs(source).error;
 var drawScriptError = (ctx, renderContext, name, message) => {
   ctx.save();
   ctx.font = "11px -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif";
@@ -2436,18 +2515,24 @@ var compileScriptIndicator = (definition) => {
   for (const input of definition.inputs ?? []) {
     defaultInputs[input.key] = input.default;
   }
-  let compiled = null;
+  let factory = null;
   let compileError = null;
   const guard = createScriptGuard();
   try {
-    compiled = compileScriptCompute(definition.source, guard);
+    factory = compileScriptFactory(definition.source);
+    const declared = [];
+    guard.reset();
+    factory(guard, createScriptInputHelper(null, declared));
+    for (const input of declared) {
+      defaultInputs[input.key] = input.default;
+    }
   } catch (error) {
     compileError = error instanceof Error ? error.message : String(error);
   }
   const sourceKey = hashScriptSource(definition.source);
   let trippedError = null;
   const runCompute = (data, inputs) => {
-    if (!compiled) {
+    if (!factory || compileError) {
       return { error: compileError ?? "Script failed to compile" };
     }
     if (trippedError) {
@@ -2455,6 +2540,7 @@ var compileScriptIndicator = (definition) => {
     }
     try {
       guard.reset();
+      const compiled = factory(guard, createScriptInputHelper(inputs, null));
       const result = compiled(data, inputs, SCRIPT_HELPERS);
       if (!result || !Array.isArray(result.plots)) {
         return { error: "compute() must return { plots: [...] }" };
@@ -2949,6 +3035,24 @@ function createChart(element, options = {}) {
   let drawingDoubleClickHandler = null;
   let drawingEditTextHandler = null;
   let magnetMode = "none";
+  let priceScaleMode = "linear";
+  let priceScaleInverted = false;
+  const PRICE_SCALE_LOG_FLOOR = 1e-9;
+  const priceScaleTransform = (price) => priceScaleMode === "log" ? Math.log10(Math.max(PRICE_SCALE_LOG_FLOOR, price)) : price;
+  const priceScaleUntransform = (value) => priceScaleMode === "log" ? Math.pow(10, value) : value;
+  const percentBaselineForXStart = (xStartValue) => {
+    if (priceScaleMode !== "percent") return null;
+    const bar = data[clamp(Math.round(xStartValue), 0, Math.max(0, data.length - 1))];
+    return bar && bar.c > 0 ? bar.c : null;
+  };
+  const formatPriceForScale = (price, percentBaseline) => {
+    if (percentBaseline !== null) {
+      const pct = (price / percentBaseline - 1) * 100;
+      const rounded = Math.abs(pct) < 5e-3 ? 0 : pct;
+      return `${rounded > 0 ? "+" : ""}${rounded.toFixed(2)}%`;
+    }
+    return formatPrice(price);
+  };
   let magnetModifierActive = false;
   let shiftKeyActive = false;
   const MAGNET_WEAK_THRESHOLD_PX = 16;
@@ -4282,9 +4386,14 @@ function createChart(element, options = {}) {
       yMax
     };
     plotBottomForHit = fullChartBottom;
+    const scaledYMin = priceScaleTransform(yMin);
+    const scaledYRange = priceScaleTransform(yMax) - scaledYMin || 1;
     const yFromPrice = (price) => {
-      return chartBottom - (price - yMin) / yRange * chartHeight;
+      const ratio = (priceScaleTransform(price) - scaledYMin) / scaledYRange;
+      return priceScaleInverted ? chartTop + ratio * chartHeight : chartBottom - ratio * chartHeight;
     };
+    const percentBaseline = percentBaselineForXStart(xStart);
+    const formatAxisPrice = (price) => formatPriceForScale(price, percentBaseline);
     const xFromDrawingPoint = (point) => chartLeft + (point.index + 0.5 - xStart) / xSpan * chartWidth;
     const FIB_RATIOS = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1, 1.618];
     const FIB_EXT_RATIOS = [0, 0.382, 0.5, 0.618, 1, 1.272, 1.618, 2.618];
@@ -4788,6 +4897,216 @@ function createChart(element, options = {}) {
             drawDrawingLabel(drawing.label, (leftX + rightX) / 2, topY - 4, drawing.color);
           }
         }
+      } else if (drawing.type === "ellipse") {
+        const p0 = drawing.points[0];
+        const p1 = drawing.points[1];
+        if (p0 && p1) {
+          const px0 = xFromDrawingPoint(p0);
+          const px1 = xFromDrawingPoint(p1);
+          const y0 = yFromPrice(p0.price);
+          const y1 = yFromPrice(p1.price);
+          const cx = (px0 + px1) / 2;
+          const cy = (y0 + y1) / 2;
+          const rx = Math.max(1, Math.abs(px1 - px0) / 2);
+          const ry = Math.max(1, Math.abs(y1 - y0) / 2);
+          ctx.save();
+          ctx.globalAlpha = draft ? 0.6 : 1;
+          ctx.beginPath();
+          ctx.ellipse(cx, cy, rx, ry, 0, 0, Math.PI * 2);
+          ctx.fillStyle = hexToRgba(drawing.color, 0.14);
+          ctx.fill();
+          ctx.lineWidth = Math.max(1, drawing.width);
+          ctx.strokeStyle = drawing.color;
+          applyDashPattern(drawing.style, dashPatterns.dotted, dashPatterns.dashed);
+          ctx.stroke();
+          ctx.restore();
+          handleAt(px0, y0, drawing.color);
+          handleAt(px1, y1, drawing.color);
+          handleAt(px0, y1, drawing.color);
+          handleAt(px1, y0, drawing.color);
+          if (drawing.label) {
+            drawDrawingLabel(drawing.label, cx, cy - ry - 4, drawing.color);
+          }
+        }
+      } else if (drawing.type === "parallel-channel") {
+        const p0 = drawing.points[0];
+        const p1 = drawing.points[1];
+        const p2 = drawing.points[2];
+        if (p0 && p1) {
+          const x0 = xFromDrawingPoint(p0);
+          const y0 = yFromPrice(p0.price);
+          const x1 = xFromDrawingPoint(p1);
+          const y1 = yFromPrice(p1.price);
+          ctx.beginPath();
+          ctx.moveTo(x0, y0);
+          ctx.lineTo(x1, y1);
+          ctx.stroke();
+          handleAt(x0, y0, drawing.color);
+          handleAt(x1, y1, drawing.color);
+          if (p2) {
+            const indexSpan = p1.index - p0.index;
+            const slope = indexSpan !== 0 ? (p1.price - p0.price) / indexSpan : 0;
+            const basePriceAtP2 = p0.price + slope * (p2.index - p0.index);
+            const offset = p2.price - basePriceAtP2;
+            const q0x = x0;
+            const q0y = yFromPrice(p0.price + offset);
+            const q1x = x1;
+            const q1y = yFromPrice(p1.price + offset);
+            ctx.save();
+            ctx.globalAlpha = draft ? 0.5 : 1;
+            ctx.fillStyle = hexToRgba(drawing.color, 0.08);
+            ctx.beginPath();
+            ctx.moveTo(x0, y0);
+            ctx.lineTo(x1, y1);
+            ctx.lineTo(q1x, q1y);
+            ctx.lineTo(q0x, q0y);
+            ctx.closePath();
+            ctx.fill();
+            ctx.restore();
+            ctx.beginPath();
+            ctx.moveTo(q0x, q0y);
+            ctx.lineTo(q1x, q1y);
+            ctx.stroke();
+            ctx.save();
+            ctx.setLineDash([4, 4]);
+            ctx.globalAlpha = draft ? 0.5 : 0.7;
+            ctx.beginPath();
+            ctx.moveTo(x0, (y0 + q0y) / 2);
+            ctx.lineTo(x1, (y1 + q1y) / 2);
+            ctx.stroke();
+            ctx.restore();
+            handleAt(xFromDrawingPoint(p2), yFromPrice(p2.price), drawing.color);
+          }
+          if (drawing.label) {
+            drawDrawingLabel(drawing.label, (x0 + x1) / 2, Math.min(y0, y1) - 4, drawing.color);
+          }
+        }
+      } else if (drawing.type === "arrow") {
+        const first = drawing.points[0];
+        const second = drawing.points[1];
+        if (first && second) {
+          const x0 = xFromDrawingPoint(first);
+          const y0 = yFromPrice(first.price);
+          const x1 = xFromDrawingPoint(second);
+          const y1 = yFromPrice(second.price);
+          const angle = Math.atan2(y1 - y0, x1 - x0);
+          const head = 5 + Math.max(1, drawing.width) * 3;
+          const shaftX = x1 - Math.cos(angle) * head * 0.6;
+          const shaftY = y1 - Math.sin(angle) * head * 0.6;
+          ctx.beginPath();
+          ctx.moveTo(x0, y0);
+          ctx.lineTo(shaftX, shaftY);
+          ctx.stroke();
+          ctx.save();
+          ctx.setLineDash([]);
+          ctx.fillStyle = drawing.color;
+          ctx.beginPath();
+          ctx.moveTo(x1, y1);
+          ctx.lineTo(x1 - Math.cos(angle - Math.PI / 7) * head, y1 - Math.sin(angle - Math.PI / 7) * head);
+          ctx.lineTo(x1 - Math.cos(angle + Math.PI / 7) * head, y1 - Math.sin(angle + Math.PI / 7) * head);
+          ctx.closePath();
+          ctx.fill();
+          ctx.restore();
+          handleAt(x0, y0, drawing.color);
+          handleAt(x1, y1, drawing.color);
+          if (drawing.label) {
+            const midX = (x0 + x1) / 2;
+            const midY = (y0 + y1) / 2;
+            drawDrawingLabel(drawing.label, midX, midY, drawing.color);
+          }
+        }
+      } else if (drawing.type === "brush") {
+        const pts = drawing.points;
+        if (pts.length >= 2) {
+          ctx.save();
+          ctx.lineJoin = "round";
+          ctx.lineCap = "round";
+          ctx.beginPath();
+          const startX = xFromDrawingPoint(pts[0]);
+          const startY = yFromPrice(pts[0].price);
+          ctx.moveTo(startX, startY);
+          if (pts.length === 2) {
+            ctx.lineTo(xFromDrawingPoint(pts[1]), yFromPrice(pts[1].price));
+          } else {
+            for (let i = 1; i < pts.length - 1; i += 1) {
+              const cxp = xFromDrawingPoint(pts[i]);
+              const cyp = yFromPrice(pts[i].price);
+              const nx = xFromDrawingPoint(pts[i + 1]);
+              const ny = yFromPrice(pts[i + 1].price);
+              ctx.quadraticCurveTo(cxp, cyp, (cxp + nx) / 2, (cyp + ny) / 2);
+            }
+            const last = pts[pts.length - 1];
+            ctx.lineTo(xFromDrawingPoint(last), yFromPrice(last.price));
+          }
+          ctx.stroke();
+          ctx.restore();
+          if (isSelected) {
+            handleAt(startX, startY, drawing.color);
+            const last = pts[pts.length - 1];
+            handleAt(xFromDrawingPoint(last), yFromPrice(last.price), drawing.color);
+          }
+        }
+      } else if (drawing.type === "callout") {
+        const anchor = drawing.points[0];
+        const boxPoint = drawing.points[1];
+        if (anchor && boxPoint) {
+          const ax = xFromDrawingPoint(anchor);
+          const ay = yFromPrice(anchor.price);
+          const bx = xFromDrawingPoint(boxPoint);
+          const by = yFromPrice(boxPoint.price);
+          const fontSize = Math.max(6, drawing.fontSize);
+          const prevFont = ctx.font;
+          ctx.font = `500 ${fontSize}px ${mergedOptions.fontFamily}`;
+          const rawLabel = drawing.label ?? "";
+          const isPlaceholder = rawLabel.trim().length === 0;
+          const lines = (isPlaceholder ? "Text" : rawLabel).split("\n");
+          const textW = Math.max(1, ...lines.map((line) => measureTextWidth(line)));
+          const padX = 10;
+          const padY = 7;
+          const lineH = Math.round(fontSize * 1.35);
+          const blockW = textW + padX * 2;
+          const blockH = lines.length * lineH + padY * 2;
+          const edgeX = Math.max(bx, Math.min(bx + blockW, ax));
+          const edgeY = Math.max(by, Math.min(by + blockH, ay));
+          const insideBox = ax >= bx && ax <= bx + blockW && ay >= by && ay <= by + blockH;
+          if (!insideBox) {
+            ctx.save();
+            ctx.setLineDash([]);
+            ctx.lineWidth = Math.max(1, drawing.width);
+            ctx.beginPath();
+            ctx.moveTo(edgeX, edgeY);
+            ctx.lineTo(ax, ay);
+            ctx.stroke();
+            const angle = Math.atan2(ay - edgeY, ax - edgeX);
+            const head = 7;
+            ctx.fillStyle = drawing.color;
+            ctx.beginPath();
+            ctx.moveTo(ax, ay);
+            ctx.lineTo(ax - Math.cos(angle - Math.PI / 7) * head, ay - Math.sin(angle - Math.PI / 7) * head);
+            ctx.lineTo(ax - Math.cos(angle + Math.PI / 7) * head, ay - Math.sin(angle + Math.PI / 7) * head);
+            ctx.closePath();
+            ctx.fill();
+            ctx.restore();
+          }
+          ctx.save();
+          ctx.setLineDash([]);
+          ctx.fillStyle = hexToRgba(drawing.color, 0.16);
+          fillRoundedRect(bx, by, blockW, blockH, 6);
+          ctx.strokeStyle = drawing.color;
+          ctx.lineWidth = Math.max(1, drawing.width);
+          strokeRoundedRect(bx, by, blockW, blockH, 6);
+          ctx.fillStyle = drawing.color;
+          ctx.globalAlpha = (draft ? 0.72 : 1) * (isPlaceholder ? 0.55 : 1);
+          ctx.textAlign = "left";
+          ctx.textBaseline = "middle";
+          lines.forEach((line, lineIndex) => {
+            ctx.fillText(line, bx + padX, by + padY + lineIndex * lineH + lineH / 2);
+          });
+          ctx.restore();
+          ctx.font = prevFont;
+          handleAt(ax, ay, drawing.color);
+          handleAt(bx, by, drawing.color);
+        }
       } else if (drawing.type === "price-range") {
         const p0 = drawing.points[0];
         const p1 = drawing.points[1];
@@ -4981,19 +5300,40 @@ function createChart(element, options = {}) {
     const yTicks = Math.max(1, Math.floor(yTickCountInput));
     const gridColor = grid.color ?? mergedOptions.gridColor;
     const priceTicks = [];
-    {
-      const targetStep = yRange / Math.max(1, yTicks);
-      let step;
-      if (targetStep > 0 && Number.isFinite(targetStep)) {
-        const base = Math.pow(10, Math.floor(Math.log10(targetStep)));
-        const frac = targetStep / base;
-        step = (frac <= 1 ? 1 : frac <= 2 ? 2 : frac <= 2.5 ? 2.5 : frac <= 5 ? 5 : 10) * base;
-        const instrumentTick = getConfiguredTickSize();
-        if (instrumentTick > 0 && step < instrumentTick * 1e6) {
-          step = Math.max(instrumentTick, Math.round(step / instrumentTick) * instrumentTick);
+    const pickNiceStep = (targetStep) => {
+      if (!(targetStep > 0) || !Number.isFinite(targetStep)) return 1;
+      const base = Math.pow(10, Math.floor(Math.log10(targetStep)));
+      const frac = targetStep / base;
+      return (frac <= 1 ? 1 : frac <= 2 ? 2 : frac <= 2.5 ? 2.5 : frac <= 5 ? 5 : 10) * base;
+    };
+    if (percentBaseline !== null) {
+      const pctMin = (yMin / percentBaseline - 1) * 100;
+      const pctMax = (yMax / percentBaseline - 1) * 100;
+      const step = pickNiceStep((pctMax - pctMin) / Math.max(1, yTicks));
+      const firstTick = Math.ceil(pctMin / step) * step;
+      for (let i = 0; ; i += 1) {
+        const pct = firstTick + i * step;
+        if (pct > pctMax + step * 1e-6) break;
+        priceTicks.push(percentBaseline * (1 + pct / 100));
+        if (priceTicks.length > 200) break;
+      }
+    } else if (priceScaleMode === "log" && yMin > 0 && yMax / yMin > 4) {
+      const mantissas = Math.log10(yMax / yMin) > 8 ? [1] : [1, 2, 5];
+      const firstDecade = Math.floor(Math.log10(Math.max(PRICE_SCALE_LOG_FLOOR, yMin)));
+      const lastDecade = Math.ceil(Math.log10(yMax));
+      for (let decade = firstDecade; decade <= lastDecade; decade += 1) {
+        for (const mantissa of mantissas) {
+          const price = mantissa * Math.pow(10, decade);
+          if (price >= yMin && price <= yMax) priceTicks.push(price);
+          if (priceTicks.length > 200) break;
         }
-      } else {
-        step = 1;
+      }
+    } else {
+      const targetStep = yRange / Math.max(1, yTicks);
+      let step = pickNiceStep(targetStep);
+      const instrumentTick = getConfiguredTickSize();
+      if (targetStep > 0 && Number.isFinite(targetStep) && instrumentTick > 0 && step < instrumentTick * 1e6) {
+        step = Math.max(instrumentTick, Math.round(step / instrumentTick) * instrumentTick);
       }
       const firstTick = Math.ceil(yMin / step) * step;
       for (let i = 0; ; i += 1) {
@@ -5756,7 +6096,7 @@ function createChart(element, options = {}) {
       ctx.font = `${yAxisFontSize}px ${mergedOptions.fontFamily}`;
       for (const price of priceTicks) {
         const y = clamp(yFromPrice(price), chartTop + priceScaleTickLabelInset, chartBottom - priceScaleTickLabelInset);
-        drawText(formatPrice(price), chartRight + 6, y, "left", "middle", yAxis.textColor);
+        drawText(formatAxisPrice(price), chartRight + 6, y, "left", "middle", yAxis.textColor);
       }
       ctx.font = prevFont;
     }
@@ -5831,7 +6171,7 @@ function createChart(element, options = {}) {
         ...ticker.showCountdownInLabel ? [getCountdownText()] : []
       ].map((value) => value === null || value === void 0 ? "" : String(value).trim()).filter((value) => value.length > 0);
       addPriceAxisLabel({
-        text: formatPrice(tickerPrice),
+        text: formatAxisPrice(tickerPrice),
         ...tickerSubtexts.length > 0 ? { subtexts: tickerSubtexts } : {},
         subtextColor: ticker.labelSubtextColor ?? ticker.labelTextColor ?? "#0b1220",
         ...ticker.labelSubtextFontSize === void 0 ? {} : { subtextFontSize: ticker.labelSubtextFontSize },
@@ -5858,7 +6198,7 @@ function createChart(element, options = {}) {
         const previousClose = previousCloseCandidate;
         drawReferenceLine(previousClose, labels.previousCloseColor, "dashed");
         addPriceAxisLabel({
-          text: `PDC ${formatPrice(previousClose)}`,
+          text: `PDC ${formatAxisPrice(previousClose)}`,
           price: previousClose,
           backgroundColor: labels.backgroundColor,
           textColor: labels.mutedTextColor,
@@ -5877,7 +6217,7 @@ function createChart(element, options = {}) {
         if (point.l < visibleLow) visibleLow = point.l;
       }
       addPriceAxisLabel({
-        text: `H ${formatPrice(visibleHigh)}`,
+        text: `H ${formatAxisPrice(visibleHigh)}`,
         price: visibleHigh,
         backgroundColor: labels.backgroundColor,
         textColor: labels.textColor,
@@ -5885,7 +6225,7 @@ function createChart(element, options = {}) {
         priority: 40
       });
       addPriceAxisLabel({
-        text: `L ${formatPrice(visibleLow)}`,
+        text: `L ${formatAxisPrice(visibleLow)}`,
         price: visibleLow,
         backgroundColor: labels.backgroundColor,
         textColor: labels.textColor,
@@ -5897,7 +6237,7 @@ function createChart(element, options = {}) {
       if (Number.isFinite(labels.bidPrice)) {
         drawReferenceLine(labels.bidPrice, labels.bidColor, "dotted");
         addPriceAxisLabel({
-          text: `B ${formatPrice(labels.bidPrice)}`,
+          text: `B ${formatAxisPrice(labels.bidPrice)}`,
           price: labels.bidPrice,
           backgroundColor: labels.bidColor,
           textColor: "#0b1220",
@@ -5908,7 +6248,7 @@ function createChart(element, options = {}) {
       if (Number.isFinite(labels.askPrice)) {
         drawReferenceLine(labels.askPrice, labels.askColor, "dotted");
         addPriceAxisLabel({
-          text: `A ${formatPrice(labels.askPrice)}`,
+          text: `A ${formatAxisPrice(labels.askPrice)}`,
           price: labels.askPrice,
           backgroundColor: labels.askColor,
           textColor: "#0b1220",
@@ -6169,8 +6509,11 @@ function createChart(element, options = {}) {
       ctx.restore();
     };
     if (crosshair.showPriceLabel) {
-      const hoverPrice = yMin + (chartBottom - cy) / chartHeight * yRange;
-      const priceText = formatPrice(hoverPrice);
+      const scaledYMin = priceScaleTransform(yMin);
+      const scaledYRange = priceScaleTransform(yMin + yRange) - scaledYMin || 1;
+      const hoverRatio = priceScaleInverted ? (cy - chartTop) / chartHeight : (chartBottom - cy) / chartHeight;
+      const hoverPrice = priceScaleUntransform(scaledYMin + hoverRatio * scaledYRange);
+      const priceText = formatPriceForScale(hoverPrice, percentBaselineForXStart(xStart));
       const priceWidth = getRightAxisLabelWidth(chartRight, getPriceLabelWidth(priceText, labelPaddingX));
       const priceX = getRightAxisLabelX(chartRight);
       const priceY = clamp(cy - labelHeight / 2, chartTop, chartBottom - labelHeight);
@@ -6338,8 +6681,8 @@ function createChart(element, options = {}) {
     const maxRange = bounds.hardSpan;
     const nextRange = clamp(currentRange * factor, minRange, maxRange);
     const anchorRatio = clamp((anchorY - drawState.chartTop) / drawState.chartHeight, 0, 1);
-    const anchorPrice = currentMax - anchorRatio * currentRange;
-    const nextMax = anchorPrice + anchorRatio * nextRange;
+    const anchorPrice = priceScaleInverted ? currentMin + anchorRatio * currentRange : currentMax - anchorRatio * currentRange;
+    const nextMax = priceScaleInverted ? anchorPrice + (1 - anchorRatio) * nextRange : anchorPrice + anchorRatio * nextRange;
     const nextMin = nextMax - nextRange;
     const clamped = clampYRange(nextMin, nextMax);
     yMinOverride = clamped.min;
@@ -6363,7 +6706,7 @@ function createChart(element, options = {}) {
       const currentMin = yMinOverride ?? drawState.yMin;
       const currentMax = yMaxOverride ?? drawState.yMax;
       const range = currentMax - currentMin || 1;
-      const priceShift = deltaY / drawState.chartHeight * range;
+      const priceShift = deltaY / drawState.chartHeight * range * (priceScaleInverted ? -1 : 1);
       const clamped = clampYRange(currentMin + priceShift, currentMax + priceShift);
       yMinOverride = clamped.min;
       yMaxOverride = clamped.max;
@@ -6596,8 +6939,14 @@ function createChart(element, options = {}) {
     if (!drawState) {
       return 0;
     }
-    const ratio = clamp((drawState.chartBottom - y) / drawState.chartHeight, 0, 1);
-    return drawState.yMin + ratio * (drawState.yMax - drawState.yMin);
+    const ratio = clamp(
+      priceScaleInverted ? (y - drawState.chartTop) / drawState.chartHeight : (drawState.chartBottom - y) / drawState.chartHeight,
+      0,
+      1
+    );
+    const scaledMin = priceScaleTransform(drawState.yMin);
+    const scaledMax = priceScaleTransform(drawState.yMax);
+    return priceScaleUntransform(scaledMin + ratio * (scaledMax - scaledMin));
   };
   const applyMagnet = (y, index, price) => {
     const effective = magnetModifierActive ? "strong" : magnetMode;
@@ -6669,8 +7018,10 @@ function createChart(element, options = {}) {
   };
   const canvasYFromDrawingPrice = (price) => {
     if (!drawState) return 0;
-    const range = drawState.yMax - drawState.yMin || 1;
-    return drawState.chartBottom - (price - drawState.yMin) / range * drawState.chartHeight;
+    const scaledMin = priceScaleTransform(drawState.yMin);
+    const scaledRange = priceScaleTransform(drawState.yMax) - scaledMin || 1;
+    const ratio = (priceScaleTransform(price) - scaledMin) / scaledRange;
+    return priceScaleInverted ? drawState.chartTop + ratio * drawState.chartHeight : drawState.chartBottom - ratio * drawState.chartHeight;
   };
   const distanceToSegment = (x, y, x1, y1, x2, y2) => {
     const dx = x2 - x1;
@@ -6842,6 +7193,126 @@ function createChart(element, options = {}) {
         if (x >= Math.min(px0, px1) && x <= Math.max(px0, px1) && y >= Math.min(y0, y1) && y <= Math.max(y0, y1)) {
           return { drawing, target: "line" };
         }
+      } else if (drawing.type === "ellipse") {
+        const p0 = drawing.points[0];
+        const p1 = drawing.points[1];
+        if (!p0 || !p1) continue;
+        const px0 = canvasXFromDrawingPoint(p0);
+        const px1 = canvasXFromDrawingPoint(p1);
+        const y0 = canvasYFromDrawingPrice(p0.price);
+        const y1 = canvasYFromDrawingPrice(p1.price);
+        if (Math.hypot(x - px0, y - y0) <= 9) return { drawing, target: "handle", pointIndex: 0 };
+        if (Math.hypot(x - px1, y - y1) <= 9) return { drawing, target: "handle", pointIndex: 1 };
+        if (Math.hypot(x - px0, y - y1) <= 9) return { drawing, target: "handle", pointIndex: 2 };
+        if (Math.hypot(x - px1, y - y0) <= 9) return { drawing, target: "handle", pointIndex: 3 };
+        const cx = (px0 + px1) / 2;
+        const cy = (y0 + y1) / 2;
+        const rx = Math.max(1, Math.abs(px1 - px0) / 2);
+        const ry = Math.max(1, Math.abs(y1 - y0) / 2);
+        const norm = ((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2;
+        if (norm <= 1) {
+          return { drawing, target: "line" };
+        }
+      } else if (drawing.type === "parallel-channel") {
+        const p0 = drawing.points[0];
+        const p1 = drawing.points[1];
+        const p2 = drawing.points[2];
+        if (!p0 || !p1) continue;
+        const x0 = canvasXFromDrawingPoint(p0);
+        const y0 = canvasYFromDrawingPrice(p0.price);
+        const x1 = canvasXFromDrawingPoint(p1);
+        const y1 = canvasYFromDrawingPrice(p1.price);
+        if (Math.hypot(x - x0, y - y0) <= 8) return { drawing, target: "handle", pointIndex: 0 };
+        if (Math.hypot(x - x1, y - y1) <= 8) return { drawing, target: "handle", pointIndex: 1 };
+        if (p2) {
+          const x2 = canvasXFromDrawingPoint(p2);
+          const y2 = canvasYFromDrawingPrice(p2.price);
+          if (Math.hypot(x - x2, y - y2) <= 8) return { drawing, target: "handle", pointIndex: 2 };
+          const indexSpan = p1.index - p0.index;
+          const slope = indexSpan !== 0 ? (p1.price - p0.price) / indexSpan : 0;
+          const offset = p2.price - (p0.price + slope * (p2.index - p0.index));
+          const q0y = canvasYFromDrawingPrice(p0.price + offset);
+          const q1y = canvasYFromDrawingPrice(p1.price + offset);
+          if (distanceToSegment(x, y, x0, y0, x1, y1) <= 6 || distanceToSegment(x, y, x0, q0y, x1, q1y) <= 6) {
+            return { drawing, target: "line" };
+          }
+          const minX = Math.min(x0, x1);
+          const maxX = Math.max(x0, x1);
+          if (x >= minX && x <= maxX && maxX > minX) {
+            const t = (x - x0) / (x1 - x0);
+            const baseY = y0 + t * (y1 - y0);
+            const parY = q0y + t * (q1y - q0y);
+            if (y >= Math.min(baseY, parY) && y <= Math.max(baseY, parY)) {
+              return { drawing, target: "line" };
+            }
+          }
+        } else if (distanceToSegment(x, y, x0, y0, x1, y1) <= 6) {
+          return { drawing, target: "line" };
+        }
+      } else if (drawing.type === "arrow") {
+        const first = drawing.points[0];
+        const second = drawing.points[1];
+        if (!first || !second) continue;
+        const x1 = canvasXFromDrawingPoint(first);
+        const y1 = canvasYFromDrawingPrice(first.price);
+        const x2 = canvasXFromDrawingPoint(second);
+        const y2 = canvasYFromDrawingPrice(second.price);
+        if (Math.hypot(x - x1, y - y1) <= 8) {
+          return { drawing, target: "handle", pointIndex: 0 };
+        }
+        if (Math.hypot(x - x2, y - y2) <= 8) {
+          return { drawing, target: "handle", pointIndex: 1 };
+        }
+        if (distanceToSegment(x, y, x1, y1, x2, y2) <= 6) {
+          return { drawing, target: "line" };
+        }
+      } else if (drawing.type === "brush") {
+        const pts = drawing.points;
+        if (pts.length < 2) continue;
+        let hitBody = false;
+        let prevX = canvasXFromDrawingPoint(pts[0]);
+        let prevY = canvasYFromDrawingPrice(pts[0].price);
+        for (let i = 1; i < pts.length; i += 1) {
+          const nextX = canvasXFromDrawingPoint(pts[i]);
+          const nextY = canvasYFromDrawingPrice(pts[i].price);
+          if (distanceToSegment(x, y, prevX, prevY, nextX, nextY) <= 7) {
+            hitBody = true;
+            break;
+          }
+          prevX = nextX;
+          prevY = nextY;
+        }
+        if (hitBody) {
+          return { drawing, target: "line" };
+        }
+      } else if (drawing.type === "callout") {
+        const anchor = drawing.points[0];
+        const boxPoint = drawing.points[1];
+        if (!anchor || !boxPoint) continue;
+        const ax = canvasXFromDrawingPoint(anchor);
+        const ay = canvasYFromDrawingPrice(anchor.price);
+        const bx = canvasXFromDrawingPoint(boxPoint);
+        const by = canvasYFromDrawingPrice(boxPoint.price);
+        if (Math.hypot(x - ax, y - ay) <= 9) return { drawing, target: "handle", pointIndex: 0 };
+        if (Math.hypot(x - bx, y - by) <= 9) return { drawing, target: "handle", pointIndex: 1 };
+        const fontSize = Math.max(6, drawing.fontSize);
+        const prevFont = ctx.font;
+        ctx.font = `500 ${fontSize}px ${mergedOptions.fontFamily}`;
+        const rawLabel = drawing.label ?? "";
+        const lines = (rawLabel.trim().length === 0 ? "Text" : rawLabel).split("\n");
+        const textW = Math.max(1, ...lines.map((line) => measureTextWidth(line)));
+        ctx.font = prevFont;
+        const padX = 10;
+        const padY = 7;
+        const lineH = Math.round(fontSize * 1.35);
+        const blockW = textW + padX * 2;
+        const blockH = lines.length * lineH + padY * 2;
+        if (x >= bx && x <= bx + blockW && y >= by && y <= by + blockH) {
+          return { drawing, target: "line" };
+        }
+        if (distanceToSegment(x, y, bx + blockW / 2, by + blockH / 2, ax, ay) <= 5) {
+          return { drawing, target: "line" };
+        }
       } else if (drawing.type === "price-range") {
         const p0 = drawing.points[0];
         const p1 = drawing.points[1];
@@ -7070,6 +7541,128 @@ function createChart(element, options = {}) {
       scheduleDraw();
       return true;
     }
+    if (activeDrawingTool === "arrow") {
+      if (draftDrawing?.type === "arrow") {
+        const anchor = draftDrawing.points[0];
+        const endPoint = shiftKeyActive ? constrainAngleFromAnchor(anchor, x, y) ?? point : point;
+        const completed = normalizeDrawingState({
+          ...serializeDrawing(draftDrawing),
+          points: [anchor, endPoint]
+        });
+        drawings.push(completed);
+        draftDrawing = null;
+        activeDrawingTool = null;
+        emitDrawingsChange();
+        scheduleDraw();
+        return true;
+      }
+      const defaults = getDrawingToolDefaults("arrow");
+      draftDrawing = normalizeDrawingState({
+        type: "arrow",
+        points: [point, point],
+        color: defaults.color ?? "#2563eb",
+        style: defaults.style ?? "solid",
+        width: defaults.width ?? 2
+      });
+      scheduleDraw();
+      return true;
+    }
+    if (activeDrawingTool === "parallel-channel") {
+      if (draftDrawing?.type === "parallel-channel") {
+        if (draftDrawing.points.length < 3) {
+          draftDrawing = normalizeDrawingState({
+            ...serializeDrawing(draftDrawing),
+            points: [...draftDrawing.points.slice(0, -1), point, point]
+          });
+          scheduleDraw();
+          return true;
+        }
+        const completed = normalizeDrawingState({
+          ...serializeDrawing(draftDrawing),
+          points: [draftDrawing.points[0], draftDrawing.points[1], point]
+        });
+        drawings.push(completed);
+        draftDrawing = null;
+        activeDrawingTool = null;
+        emitDrawingsChange();
+        scheduleDraw();
+        return true;
+      }
+      const defaults = getDrawingToolDefaults("parallel-channel");
+      draftDrawing = normalizeDrawingState({
+        type: "parallel-channel",
+        points: [point, point],
+        color: defaults.color ?? "#2563eb",
+        style: defaults.style ?? "solid",
+        width: defaults.width ?? 2
+      });
+      scheduleDraw();
+      return true;
+    }
+    if (activeDrawingTool === "ellipse") {
+      if (draftDrawing?.type === "ellipse") {
+        const completed = normalizeDrawingState({
+          ...serializeDrawing(draftDrawing),
+          points: [draftDrawing.points[0], point]
+        });
+        drawings.push(completed);
+        draftDrawing = null;
+        activeDrawingTool = null;
+        emitDrawingsChange();
+        scheduleDraw();
+        return true;
+      }
+      const defaults = getDrawingToolDefaults("ellipse");
+      draftDrawing = normalizeDrawingState({
+        type: "ellipse",
+        points: [point, point],
+        color: defaults.color ?? "#2962ff",
+        style: defaults.style ?? "solid",
+        width: defaults.width ?? 1
+      });
+      scheduleDraw();
+      return true;
+    }
+    if (activeDrawingTool === "callout") {
+      if (draftDrawing?.type === "callout") {
+        const completed = normalizeDrawingState({
+          ...serializeDrawing(draftDrawing),
+          points: [draftDrawing.points[0], point]
+        });
+        drawings.push(completed);
+        draftDrawing = null;
+        activeDrawingTool = null;
+        selectedDrawingId = completed.id;
+        emitDrawingsChange();
+        scheduleDraw();
+        drawingEditTextHandler?.({ drawing: serializeDrawing(completed), target: "line", x, y });
+        return true;
+      }
+      const defaults = getDrawingToolDefaults("callout");
+      draftDrawing = normalizeDrawingState({
+        type: "callout",
+        points: [point, point],
+        color: defaults.color ?? "#2962ff",
+        style: defaults.style ?? "solid",
+        width: defaults.width ?? 1,
+        ...defaults.fontSize === void 0 ? {} : { fontSize: defaults.fontSize },
+        label: ""
+      });
+      scheduleDraw();
+      return true;
+    }
+    if (activeDrawingTool === "brush") {
+      const defaults = getDrawingToolDefaults("brush");
+      draftDrawing = normalizeDrawingState({
+        type: "brush",
+        points: [point],
+        color: defaults.color ?? "#f59e0b",
+        style: defaults.style ?? "solid",
+        width: defaults.width ?? 2
+      });
+      scheduleDraw();
+      return true;
+    }
     if (activeDrawingTool === "fib-retracement") {
       if (draftDrawing?.type === "fib-retracement") {
         const completed = normalizeDrawingState({
@@ -7273,7 +7866,7 @@ function createChart(element, options = {}) {
         }
         return { ...drawing, points: pts };
       }
-      if (drawingDragState.target === "handle" && drawing.type === "rectangle") {
+      if (drawingDragState.target === "handle" && (drawing.type === "rectangle" || drawing.type === "ellipse")) {
         const pts = drawing.points.map((point) => ({ ...point }));
         const p0 = pts[0];
         const p1 = pts[1];
@@ -7292,7 +7885,7 @@ function createChart(element, options = {}) {
         }
         return { ...drawing, points: pts };
       }
-      if (drawingDragState.target === "handle" && shiftKeyActive && (drawing.type === "trendline" || drawing.type === "ray")) {
+      if (drawingDragState.target === "handle" && shiftKeyActive && (drawing.type === "trendline" || drawing.type === "ray" || drawing.type === "arrow")) {
         const pointIndex = drawingDragState.pointIndex ?? 0;
         const anchor = drawing.points[pointIndex === 0 ? 1 : 0];
         const constrained = anchor ? constrainAngleFromAnchor(anchor, x, y) : null;
@@ -7542,6 +8135,10 @@ function createChart(element, options = {}) {
     if (region === "plot" && handleDrawingToolPointerDown(point.x, point.y)) {
       setCrosshairPoint(null);
       canvas.style.cursor = "crosshair";
+      if (activeDrawingTool === "brush" && draftDrawing?.type === "brush") {
+        activePointerId = event.pointerId;
+        capturePointer(event.pointerId);
+      }
       return;
     }
     isDragging = true;
@@ -7626,9 +8223,30 @@ function createChart(element, options = {}) {
       setCrosshairPoint(null);
       return;
     }
-    if (draftDrawing && (activeDrawingTool === "trendline" || activeDrawingTool === "ray" || activeDrawingTool === "rectangle" || activeDrawingTool === "fib-retracement" || activeDrawingTool === "fib-extension")) {
+    if (draftDrawing?.type === "brush" && activeDrawingTool === "brush") {
+      if (activePointerId !== null && event.pointerId !== activePointerId) {
+        return;
+      }
+      const nextPoint = drawingPointFromCanvas(point.x, point.y);
+      if (nextPoint) {
+        const last = draftDrawing.points[draftDrawing.points.length - 1];
+        const lastX = last ? canvasXFromDrawingPoint(last) : Number.NEGATIVE_INFINITY;
+        const lastY = last ? canvasYFromDrawingPrice(last.price) : Number.NEGATIVE_INFINITY;
+        if (Math.hypot(point.x - lastX, point.y - lastY) >= 3) {
+          draftDrawing = {
+            ...draftDrawing,
+            points: [...draftDrawing.points, nextPoint]
+          };
+        }
+        canvas.style.cursor = "crosshair";
+        setCrosshairPoint(null);
+        scheduleDraw();
+      }
+      return;
+    }
+    if (draftDrawing && (activeDrawingTool === "trendline" || activeDrawingTool === "ray" || activeDrawingTool === "arrow" || activeDrawingTool === "rectangle" || activeDrawingTool === "ellipse" || activeDrawingTool === "callout" || activeDrawingTool === "parallel-channel" || activeDrawingTool === "fib-retracement" || activeDrawingTool === "fib-extension")) {
       let nextPoint = drawingPointFromCanvas(point.x, point.y);
-      if (nextPoint && shiftKeyActive && (draftDrawing.type === "trendline" || draftDrawing.type === "ray") && draftDrawing.points[0]) {
+      if (nextPoint && shiftKeyActive && (draftDrawing.type === "trendline" || draftDrawing.type === "ray" || draftDrawing.type === "arrow") && draftDrawing.points[0]) {
         nextPoint = constrainAngleFromAnchor(draftDrawing.points[0], point.x, point.y) ?? nextPoint;
       }
       if (nextPoint) {
@@ -7865,6 +8483,25 @@ function createChart(element, options = {}) {
       scheduleDraw();
       return;
     }
+    if (draftDrawing?.type === "brush" && activeDrawingTool === "brush") {
+      if (draftDrawing.points.length >= 2) {
+        const completed = normalizeDrawingState(serializeDrawing(draftDrawing));
+        drawings.push(completed);
+        draftDrawing = null;
+        activeDrawingTool = null;
+        canvas.style.cursor = "default";
+        emitDrawingsChange();
+      } else {
+        draftDrawing = null;
+        canvas.style.cursor = "crosshair";
+      }
+      isDragging = false;
+      dragMode = null;
+      activePointerId = null;
+      pointerDownInfo = null;
+      scheduleDraw();
+      return;
+    }
     if (orderDragState) {
       const moved = orderDragState.lastPrice !== orderDragState.startPrice;
       const finalLine = orderLines.find((line) => line.id === orderDragState?.orderId);
@@ -8008,7 +8645,7 @@ function createChart(element, options = {}) {
           x: point.x,
           y: point.y
         };
-        if (drawingHit.drawing.type === "text" || drawingHit.drawing.type === "note") {
+        if (drawingHit.drawing.type === "text" || drawingHit.drawing.type === "note" || drawingHit.drawing.type === "callout") {
           drawingEditTextHandler?.(payload);
         } else {
           drawingDoubleClickHandler?.(payload);
@@ -8398,6 +9035,16 @@ function createChart(element, options = {}) {
     magnetMode = mode;
   };
   const getMagnetMode = () => magnetMode;
+  const setPriceScale = (options2) => {
+    if (options2.mode === "linear" || options2.mode === "log" || options2.mode === "percent") {
+      priceScaleMode = options2.mode;
+    }
+    if (typeof options2.inverted === "boolean") {
+      priceScaleInverted = options2.inverted;
+    }
+    scheduleDraw();
+  };
+  const getPriceScale = () => ({ mode: priceScaleMode, inverted: priceScaleInverted });
   const getDrawings = () => drawings.map((drawing) => serializeDrawing(drawing));
   const setDrawings = (nextDrawings) => {
     drawings = dedupeDrawingIds(nextDrawings.map((drawing) => normalizeDrawingState(drawing)));
@@ -8455,6 +9102,55 @@ function createChart(element, options = {}) {
   const onDrawingHover = (handler) => {
     drawingHoverHandler = handler;
   };
+  const saveState = () => {
+    const drawingDefaults = {};
+    for (const [tool, defaults] of drawingToolDefaults) {
+      drawingDefaults[tool] = { ...defaults };
+    }
+    return {
+      version: 1,
+      chartType: getChartType(),
+      viewport: getViewport(),
+      drawings: getDrawings(),
+      indicators: getIndicators(),
+      magnetMode: getMagnetMode(),
+      priceScale: getPriceScale(),
+      drawingDefaults
+    };
+  };
+  const loadState = (state) => {
+    if (!state || typeof state !== "object") {
+      return;
+    }
+    if (typeof state.chartType === "string") {
+      setChartType(state.chartType);
+    }
+    if (Array.isArray(state.indicators)) {
+      setIndicators(state.indicators);
+    }
+    if (Array.isArray(state.drawings)) {
+      setDrawings(state.drawings);
+    }
+    if (state.magnetMode === "none" || state.magnetMode === "weak" || state.magnetMode === "strong") {
+      setMagnetMode(state.magnetMode);
+    }
+    if (state.priceScale && typeof state.priceScale === "object") {
+      setPriceScale(state.priceScale);
+    }
+    if (state.drawingDefaults && typeof state.drawingDefaults === "object") {
+      for (const [tool, defaults] of Object.entries(state.drawingDefaults)) {
+        if (defaults && typeof defaults === "object") {
+          setDrawingDefaults(tool, defaults);
+        }
+      }
+    }
+    if (state.viewport && typeof state.viewport === "object") {
+      setViewport(state.viewport);
+    }
+  };
+  const takeScreenshot = (options2 = {}) => {
+    return canvas.toDataURL(options2.type ?? "image/png", options2.quality);
+  };
   const destroy = () => {
     cancelKineticPan();
     if (smoothingRafId !== null) {
@@ -8535,6 +9231,8 @@ function createChart(element, options = {}) {
     onDrawingEditText,
     setMagnetMode,
     getMagnetMode,
+    setPriceScale,
+    getPriceScale,
     cancelDrawing,
     setTradeMarkers,
     setSelectedDrawing,
@@ -8550,6 +9248,9 @@ function createChart(element, options = {}) {
     updateIndicator,
     removeIndicator,
     setIndicators,
+    saveState,
+    loadState,
+    takeScreenshot,
     resize,
     destroy
   };
@@ -8557,7 +9258,9 @@ function createChart(element, options = {}) {
 export {
   FIB_DEFAULT_PALETTE,
   POSITION_DEFAULT_COLORS,
+  SCRIPT_SOURCE_INPUT_VALUES,
   compileScriptIndicator,
   createChart,
+  extractScriptInputs,
   validateScriptSource
 };