oakscriptjs 0.8.1 → 0.9.0

package/dist/cjs/script/index.js

@@ -0,0 +1,1169 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var script_exports = {};
+__export(script_exports, {
+  BarData: () => import_series.BarData,
+  STRATEGY_DEFAULTS: () => import_strategy2.STRATEGY_DEFAULTS,
+  Series: () => import_series.Series,
+  alertcondition: () => alertcondition,
+  barcolor: () => barcolor,
+  barmerge: () => barmerge,
+  barstate: () => barstate,
+  bgcolor: () => bgcolor,
+  box: () => box,
+  chart: () => chart,
+  close: () => close,
+  color: () => color,
+  compare: () => compare,
+  dayofmonth: () => dayofmonth,
+  dayofweek: () => dayofweek,
+  eachBar: () => eachBar,
+  executeScript: () => executeScript,
+  fill: () => fill,
+  fixnan: () => fixnan,
+  high: () => high,
+  hl2: () => hl2,
+  hlc3: () => hlc3,
+  hlcc4: () => hlcc4,
+  hline: () => hline,
+  hour: () => hour,
+  inSession: () => inSession,
+  indicator: () => indicator,
+  input: () => input,
+  label: () => label,
+  line: () => line,
+  linefill: () => linefill,
+  low: () => low,
+  math: () => math,
+  minute: () => minute,
+  month: () => month,
+  na: () => import_utils.isNA,
+  nz: () => import_utils.nz,
+  ohlc4: () => ohlc4,
+  open: () => open,
+  plot: () => plot,
+  plotarrow: () => plotarrow,
+  plotchar: () => plotchar,
+  plotshape: () => plotshape,
+  polyline: () => polyline,
+  request: () => request,
+  second: () => second,
+  seriesOf: () => seriesOf,
+  session: () => session,
+  str: () => str,
+  strategy: () => strategy,
+  syminfo: () => syminfo,
+  ta: () => ta,
+  text: () => text,
+  ticker: () => ticker,
+  time: () => time,
+  time_close: () => time_close,
+  time_tradingday: () => time_tradingday,
+  timeframe: () => timeframe,
+  timestamp: () => timestamp,
+  volume: () => volume,
+  weekofyear: () => weekofyear,
+  year: () => year
+});
+module.exports = __toCommonJS(script_exports);
+var import_series = require("../runtime/series.js");
+var taSeries = __toESM(require("../ta-series.js"), 1);
+var colorCore = __toESM(require("../color/index.js"), 1);
+var import_utils = require("../utils/index.js");
+var lineCore = __toESM(require("../line/index.js"), 1);
+var labelCore = __toESM(require("../label/index.js"), 1);
+var boxCore = __toESM(require("../box/index.js"), 1);
+var linefillCore = __toESM(require("../linefill/index.js"), 1);
+var polylineCore = __toESM(require("../polyline/index.js"), 1);
+var chartPointCore = __toESM(require("../chartpoint/index.js"), 1);
+var textCore = __toESM(require("../text/index.js"), 1);
+var mathCore = __toESM(require("../math/index.js"), 1);
+var import_registry = require("../drawing/registry.js");
+var timeframeCore = __toESM(require("../timeframe/index.js"), 1);
+var timeCore = __toESM(require("../time/index.js"), 1);
+var strCore = __toESM(require("../str/index.js"), 1);
+var import_messageformat = require("../str/messageformat.js");
+var import_calendar = require("../session/calendar.js");
+var import_bars = require("../session/bars.js");
+var import_resample = require("../security/resample.js");
+var import_strategy = require("../strategy/index.js");
+var import_strategy2 = require("../strategy/index.js");
+var compare = __toESM(require("../compare/index.js"), 1);
+const ctxBars = new import_series.BarData([]);
+let ctx = null;
+function collector() {
+  if (!ctx) {
+    throw new Error(
+      "oakscriptjs/script functions can only run inside executeScript() \u2014 the host (chart/worker) drives script execution."
+    );
+  }
+  return ctx;
+}
+function freshCollector(inputValues) {
+  return {
+    title: "Untitled",
+    overlay: true,
+    inputValues,
+    inputConfig: [],
+    inputIds: /* @__PURE__ */ new Set(),
+    defaultInputs: {},
+    plotConfig: [],
+    plots: {},
+    hlineConfig: [],
+    fills: [],
+    fillConfig: [],
+    shapeConfig: [],
+    markers: [],
+    arrowConfig: [],
+    arrows: [],
+    barColorConfig: [],
+    bgcolors: [],
+    barcolors: [],
+    alertConfig: [],
+    alerts: []
+  };
+}
+function slugId(title, fallback, taken) {
+  const base = (title ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || fallback;
+  let id = base;
+  for (let n = 2; taken.has(id); n++) id = `${base}_${n}`;
+  taken.add(id);
+  return id;
+}
+let scriptOptions = {};
+function executeScript(body, barsInput, inputs = {}, chart2 = {}, options = {}) {
+  ctxBars.setAll(barsInput);
+  chartCtx = { ...chart2 };
+  scriptOptions = options;
+  ctx = freshCollector(inputs);
+  (0, import_registry.resetDrawings)();
+  try {
+    body();
+    const c = ctx;
+    return {
+      metadata: {
+        title: c.title,
+        shortTitle: c.shortTitle,
+        overlay: c.overlay,
+        precision: c.precision,
+        format: c.format
+      },
+      inputConfig: c.inputConfig,
+      plotConfig: c.plotConfig,
+      hlineConfig: c.hlineConfig,
+      fillConfig: c.fillConfig,
+      shapeConfig: c.shapeConfig,
+      arrowConfig: c.arrowConfig,
+      barColorConfig: c.barColorConfig,
+      defaultInputs: c.defaultInputs,
+      alertConfig: c.alertConfig,
+      strategyConfig: c.strategy?.properties,
+      result: {
+        metadata: { title: c.title, shorttitle: c.shortTitle, overlay: c.overlay, precision: c.precision },
+        plots: c.plots,
+        fills: c.fills.length ? c.fills : void 0,
+        markers: c.markers.length ? c.markers : void 0,
+        arrows: c.arrows.length ? c.arrows : void 0,
+        bgcolors: c.bgcolors.length ? c.bgcolors : void 0,
+        barcolors: c.barcolors.length ? c.barcolors : void 0,
+        alerts: c.alerts.length ? c.alerts : void 0
+      }
+    };
+  } finally {
+    ctx = null;
+  }
+}
+function indicator(title, options = {}) {
+  const c = collector();
+  declare(c, "indicator");
+  c.title = title;
+  c.shortTitle = options.shorttitle;
+  c.overlay = options.overlay ?? true;
+  c.precision = options.precision;
+  c.format = options.format;
+  (0, import_registry.setDrawingLimits)({
+    line: options.max_lines_count,
+    label: options.max_labels_count,
+    box: options.max_boxes_count,
+    polyline: options.max_polylines_count
+  });
+}
+function declare(c, kind) {
+  if (c.declaration) {
+    throw new Error(`${kind}(): the script already declared ${c.declaration}(); a script has one declaration.`);
+  }
+  c.declaration = kind;
+}
+function common(opts) {
+  const out = {};
+  if (opts.group !== void 0) out.group = opts.group;
+  if (opts.inline !== void 0) out.inline = opts.inline;
+  if (opts.tooltip !== void 0) out.tooltip = opts.tooltip;
+  if (opts.confirm !== void 0) out.confirm = opts.confirm;
+  if (opts.display !== void 0) out.display = opts.display;
+  return out;
+}
+function registerInput(config, fallbackId) {
+  const c = collector();
+  const id = slugId(config.title, fallbackId, c.inputIds);
+  c.inputConfig.push({ id, ...config });
+  c.defaultInputs[id] = config.defval;
+  const value = c.inputValues[id];
+  return value === void 0 ? config.defval : value;
+}
+function registerNumeric(type, defval, title, opts = {}) {
+  const v = registerInput(
+    { type, defval, title, min: opts.minval, max: opts.maxval, step: opts.step, ...common(opts) },
+    `input_${type}`
+  );
+  return typeof v === "number" ? v : defval;
+}
+const input = {
+  int(defval, title, opts = {}) {
+    return Math.round(registerNumeric("int", defval, title, opts));
+  },
+  float(defval, title, opts = {}) {
+    return registerNumeric("float", defval, title, opts);
+  },
+  bool(defval, title, opts = {}) {
+    return registerInput({ type: "bool", defval, title, ...common(opts) }, "input_bool");
+  },
+  string(defval, title, opts = {}) {
+    return registerInput({ type: "string", defval, title, options: opts.options, ...common(opts) }, "input_string");
+  },
+  color(defval, title, opts = {}) {
+    return registerInput({ type: "color", defval, title, ...common(opts) }, "input_color");
+  },
+  /** Declares a source input and returns it as a Series. */
+  source(defval = "close", title, opts = {}) {
+    const name = registerInput({ type: "source", defval, title, ...common(opts) }, "input_source");
+    return sourceSeries(name);
+  },
+  /** Timeframe string ("60", "1D", "W"). As in PineScript, "" means the chart timeframe. */
+  timeframe(defval, title, opts = {}) {
+    return registerInput(
+      { type: "timeframe", defval, title, options: opts.options, ...common(opts) },
+      "input_timeframe"
+    );
+  },
+  /** Session string ("0930-1600", "0930-1600:23456"). */
+  session(defval, title, opts = {}) {
+    return registerInput(
+      { type: "session", defval, title, options: opts.options, ...common(opts) },
+      "input_session"
+    );
+  },
+  /** Date and time as a UNIX time in milliseconds, e.g. `input.time(timestamp('2024-01-01'), 'Start')`. */
+  time(defval, title, opts = {}) {
+    const v = registerInput({ type: "time", defval, title, ...common(opts) }, "input_time");
+    return typeof v === "number" ? v : defval;
+  }
+};
+const open = import_series.Series.fromBars(ctxBars, "open");
+const high = import_series.Series.fromBars(ctxBars, "high");
+const low = import_series.Series.fromBars(ctxBars, "low");
+const close = import_series.Series.fromBars(ctxBars, "close");
+const volume = import_series.Series.fromBars(ctxBars, "volume");
+const hl2 = new import_series.Series(ctxBars, (b) => (b.high + b.low) / 2);
+const hlc3 = new import_series.Series(ctxBars, (b) => (b.high + b.low + b.close) / 3);
+const ohlc4 = new import_series.Series(ctxBars, (b) => (b.open + b.high + b.low + b.close) / 4);
+const hlcc4 = new import_series.Series(ctxBars, (b) => (b.high + b.low + b.close + b.close) / 4);
+const SOURCES = { open, high, low, close, volume, hl2, hlc3, ohlc4, hlcc4 };
+function sourceSeries(name) {
+  return SOURCES[name] ?? close;
+}
+const bars = () => ctxBars.bars;
+function barsSeries(compute) {
+  let version = -1;
+  let values = [];
+  return new import_series.Series(ctxBars, (_bar, i, data) => {
+    if (version !== ctxBars.version) {
+      values = compute(data).toArray();
+      version = ctxBars.version;
+    }
+    return values[i] ?? NaN;
+  });
+}
+const ta = {
+  ...taSeries,
+  tr: (handleNa = false) => taSeries.tr(bars(), handleNa),
+  atr: (length) => taSeries.atr(bars(), length),
+  sar: (start, inc, max) => taSeries.sar(bars(), start, inc, max),
+  wpr: (length) => taSeries.wpr(bars(), length),
+  supertrend: (factor, atrLength) => taSeries.supertrend(bars(), factor, atrLength),
+  dmi: (diLength, adxSmoothing) => taSeries.dmi(bars(), diLength, adxSmoothing),
+  kc: (source, length, mult, useTrueRange) => taSeries.kc(bars(), source, length, mult, useTrueRange),
+  kcw: (source, length, mult, useTrueRange) => taSeries.kcw(bars(), source, length, mult, useTrueRange),
+  ichimoku: (conversionPeriods, basePeriods, laggingSpan2Periods, displacement) => taSeries.ichimoku(bars(), conversionPeriods, basePeriods, laggingSpan2Periods, displacement),
+  /** `ta.highest(source, length)` or `ta.highest(length)` (source = high). */
+  highest: (sourceOrLength, length) => typeof sourceOrLength === "number" ? taSeries.highest(high, sourceOrLength) : taSeries.highest(sourceOrLength, length),
+  /** `ta.lowest(source, length)` or `ta.lowest(length)` (source = low). */
+  lowest: (sourceOrLength, length) => typeof sourceOrLength === "number" ? taSeries.lowest(low, sourceOrLength) : taSeries.lowest(sourceOrLength, length),
+  /** `ta.highestbars(source, length)` or `ta.highestbars(length)` (source = high); offsets are 0 or negative. */
+  highestbars: (sourceOrLength, length) => typeof sourceOrLength === "number" ? taSeries.highestbars(high, sourceOrLength) : taSeries.highestbars(sourceOrLength, length),
+  /** `ta.lowestbars(source, length)` or `ta.lowestbars(length)` (source = low); offsets are 0 or negative. */
+  lowestbars: (sourceOrLength, length) => typeof sourceOrLength === "number" ? taSeries.lowestbars(low, sourceOrLength) : taSeries.lowestbars(sourceOrLength, length),
+  /** `ta.vwap(source, anchor?, stdev_mult?)` with the chart volume; the default anchor is a new trading
+   *  day (`timeframe.change("1D")`), which needs the chart context (timeframe, time zone, session). */
+  vwap: ((source, anchor, stdev_mult) => {
+    const a = anchor ?? changeOf("1D");
+    return stdev_mult === void 0 ? taSeries.vwap(source, volume, a) : taSeries.vwapBands(source, volume, a, stdev_mult);
+  }),
+  /** `ta.mfi(source, length)` with the chart volume (PineScript takes 2 arguments). */
+  mfi: (source, length) => taSeries.mfi(source, length, volume),
+  /** `ta.pivothigh(source, leftbars, rightbars)` or `ta.pivothigh(leftbars, rightbars)` (source = high).
+   *  The value appears `rightbars` bars after the pivot bar, as in PineScript. */
+  pivothigh: (sourceOrLeft, leftOrRight, rightbars) => typeof sourceOrLeft === "number" ? taSeries.pivothigh(high, sourceOrLeft, leftOrRight) : taSeries.pivothigh(sourceOrLeft, leftOrRight, rightbars),
+  /** `ta.pivotlow(source, leftbars, rightbars)` or `ta.pivotlow(leftbars, rightbars)` (source = low). */
+  pivotlow: (sourceOrLeft, leftOrRight, rightbars) => typeof sourceOrLeft === "number" ? taSeries.pivotlow(low, sourceOrLeft, leftOrRight) : taSeries.pivotlow(sourceOrLeft, leftOrRight, rightbars),
+  // PineScript variables of the chart bars: `ta.obv`, not `ta.obv()`.
+  obv: barsSeries(taSeries.obv),
+  pvt: barsSeries(taSeries.pvt),
+  accdist: barsSeries(taSeries.accdist),
+  nvi: barsSeries(taSeries.nvi),
+  pvi: barsSeries(taSeries.pvi),
+  iii: barsSeries(taSeries.iii),
+  wad: barsSeries(taSeries.wad),
+  wvad: barsSeries(taSeries.wvad)
+};
+function fixnan(source) {
+  return source instanceof import_series.Series ? import_series.Series.fromArray(ctxBars, (0, import_utils.fixnan)(source.toArray())) : (0, import_utils.fixnan)(source);
+}
+function colorWhen(cond, colorTrue, colorFalse) {
+  return cond.toArray().map((v) => !(0, import_utils.isNA)(v) && v !== 0 ? colorTrue : colorFalse);
+}
+const color = {
+  ...colorCore,
+  new: colorCore.new_color,
+  when: colorWhen
+};
+function plotImpl(series, title, options = {}) {
+  const c = collector();
+  const id = `plot${c.plotConfig.length}`;
+  const perBar2 = Array.isArray(options.color) ? options.color : void 0;
+  const staticColor = typeof options.color === "string" ? options.color : perBar2?.[perBar2.length - 1] ?? "#2962FF";
+  c.plotConfig.push({
+    id,
+    title: title ?? id,
+    color: staticColor,
+    lineWidth: options.linewidth,
+    style: options.style,
+    linestyle: options.linestyle,
+    display: options.display,
+    histbase: options.histbase,
+    forceOverlay: options.force_overlay
+  });
+  const values = series.toArray();
+  const b = bars();
+  const data = [];
+  for (let i = 0; i < b.length; i++) {
+    const value = values[i];
+    if (value === void 0 || !Number.isFinite(value)) continue;
+    data.push(perBar2 ? { time: b[i].time, value, color: perBar2[i] } : { time: b[i].time, value });
+  }
+  c.plots[id] = data;
+  return { id, kind: "plot" };
+}
+const plot = Object.assign(plotImpl, {
+  style_line: "line",
+  style_linebr: "linebr",
+  style_stepline: "stepline",
+  style_steplinebr: "steplinebr",
+  style_stepline_diamond: "stepline_diamond",
+  style_histogram: "histogram",
+  style_columns: "columns",
+  style_area: "area",
+  style_areabr: "areabr",
+  style_circles: "circles",
+  style_cross: "cross",
+  linestyle_solid: "solid",
+  linestyle_dotted: "dotted",
+  linestyle_dashed: "dashed"
+});
+function hlineImpl(price, title, options = {}) {
+  const c = collector();
+  const id = `hline${c.hlineConfig.length}`;
+  c.hlineConfig.push({
+    id,
+    price,
+    title,
+    color: options.color,
+    linestyle: options.linestyle ?? "dashed",
+    linewidth: options.linewidth
+  });
+  return { id, kind: "hline" };
+}
+const hline = Object.assign(hlineImpl, {
+  style_solid: "solid",
+  style_dotted: "dotted",
+  style_dashed: "dashed"
+});
+function perBarValues(v, n) {
+  return v instanceof import_series.Series ? v.toArray().slice(0, n) : new Array(n).fill(v);
+}
+function perBarColors(c, n) {
+  if (Array.isArray(c)) return Array.from({ length: n }, (_, i) => c[i] ?? null);
+  return new Array(n).fill(c ?? null);
+}
+function fill(a, b, ...args) {
+  const c = collector();
+  const third = args[0];
+  let perBar2;
+  let staticColor;
+  let title;
+  let gradient;
+  if (typeof third === "number" || third instanceof import_series.Series) {
+    const n = ctxBars.bars.length;
+    gradient = {
+      topValue: perBarValues(third, n),
+      bottomValue: perBarValues(args[1], n),
+      topColor: perBarColors(args[2], n),
+      bottomColor: perBarColors(args[3], n)
+    };
+    title = args[4];
+  } else if (third !== null && typeof third === "object" && !Array.isArray(third)) {
+    const options = third;
+    perBar2 = Array.isArray(options.color) ? options.color : void 0;
+    staticColor = typeof options.color === "string" ? options.color : void 0;
+    title = options.title;
+  } else {
+    const color2 = third;
+    perBar2 = Array.isArray(color2) ? color2.map((x) => x ?? "") : void 0;
+    staticColor = typeof color2 === "string" ? color2 : void 0;
+    title = args[1];
+  }
+  if (a.kind === "hline" && b.kind === "hline") {
+    c.fillConfig.push({
+      id: `fill${c.fillConfig.length}`,
+      plot1: a.id,
+      plot2: b.id,
+      color: staticColor,
+      colors: perBar2,
+      gradient,
+      title
+    });
+    return;
+  }
+  c.fills.push({
+    plot1: a.id,
+    plot2: b.id,
+    options: { color: staticColor, title },
+    colors: perBar2,
+    gradient
+  });
+}
+function emitMarkers(kind, condition, title, options) {
+  const c = collector();
+  const id = `${kind}${c.shapeConfig.filter((s) => s.kind === kind).length}`;
+  const style = kind === "shape" ? options.style ?? "xcross" : "char";
+  const char = kind === "char" ? options.char ?? "*" : void 0;
+  const location = options.location ?? "abovebar";
+  c.shapeConfig.push({
+    id,
+    kind,
+    title,
+    style: kind === "shape" ? style : void 0,
+    char,
+    location,
+    color: options.color,
+    text: options.text,
+    textcolor: options.textcolor,
+    size: options.size,
+    offset: options.offset,
+    forceOverlay: options.force_overlay
+  });
+  const values = condition.toArray();
+  const b = bars();
+  const off = options.offset ?? 0;
+  for (let i = 0; i < b.length; i++) {
+    const v = values[i];
+    if (v === void 0 || Number.isNaN(v) || v === 0) continue;
+    const j = i + off;
+    if (j < 0 || j >= b.length) continue;
+    c.markers.push({
+      time: b[j].time,
+      id,
+      location,
+      style,
+      char,
+      color: options.color,
+      text: options.text,
+      textcolor: options.textcolor,
+      size: options.size,
+      tooltip: options.tooltip,
+      price: location === "absolute" ? v : void 0
+    });
+  }
+}
+function plotshape(condition, title, options = {}) {
+  emitMarkers("shape", condition, title, options);
+}
+function plotchar(condition, title, options = {}) {
+  emitMarkers("char", condition, title, options);
+}
+function plotarrow(series, title, options = {}) {
+  const c = collector();
+  const id = `arrow${c.arrowConfig.length}`;
+  const pick = (col, fallback, i) => col === void 0 ? fallback : typeof col === "string" ? col : col[i];
+  const colorup = typeof options.colorup === "string" ? options.colorup : "#00FF00";
+  const colordown = typeof options.colordown === "string" ? options.colordown : "#FF0000";
+  c.arrowConfig.push({
+    id,
+    title,
+    colorup,
+    colordown,
+    minheight: options.minheight ?? 5,
+    maxheight: options.maxheight ?? 100,
+    offset: options.offset,
+    display: options.display,
+    forceOverlay: options.force_overlay
+  });
+  const values = series.toArray();
+  const b = bars();
+  const off = options.offset ?? 0;
+  for (let i = 0; i < b.length; i++) {
+    const v = values[i];
+    if (v === void 0 || Number.isNaN(v) || v === 0) continue;
+    const j = i + off;
+    if (j < 0 || j >= b.length) continue;
+    const color2 = v > 0 ? pick(options.colorup, "#00FF00", i) : pick(options.colordown, "#FF0000", i);
+    if (color2 === void 0) continue;
+    c.arrows.push({ time: b[j].time, id, value: v, color: color2 });
+  }
+}
+function emitBarColors(kind, colors, options) {
+  const c = collector();
+  const id = `${kind}${c.barColorConfig.filter((x) => x.kind === kind).length}`;
+  c.barColorConfig.push({ id, kind, title: options.title, offset: options.offset, forceOverlay: options.force_overlay });
+  const b = bars();
+  const off = options.offset ?? 0;
+  const target = kind === "bgcolor" ? c.bgcolors : c.barcolors;
+  for (let i = 0; i < b.length; i++) {
+    const col = typeof colors === "string" ? colors : colors[i];
+    if (!col) continue;
+    const j = i + off;
+    if (j < 0 || j >= b.length) continue;
+    target.push({ time: b[j].time, color: col });
+  }
+}
+function bgcolor(colors, options = {}) {
+  emitBarColors("bgcolor", colors, options);
+}
+function barcolor(colors, options = {}) {
+  emitBarColors("barcolor", colors, options);
+}
+function eachBar(fn) {
+  collector();
+  const b = bars();
+  const out = new Array(b.length).fill(NaN);
+  const cache = /* @__PURE__ */ new Map();
+  let idx = 0;
+  const ctx2 = {
+    get i() {
+      return idx;
+    },
+    n: b.length,
+    get time() {
+      return b[idx].time;
+    },
+    get open() {
+      return b[idx].open;
+    },
+    get high() {
+      return b[idx].high;
+    },
+    get low() {
+      return b[idx].low;
+    },
+    get close() {
+      return b[idx].close;
+    },
+    get volume() {
+      return b[idx].volume ?? NaN;
+    },
+    get(src, offset = 0) {
+      if (offset < 0) throw new RangeError(`c.get(): the offset cannot be negative (${offset} would read a future bar).`);
+      let vals = cache.get(src);
+      if (!vals) {
+        vals = src.toArray();
+        cache.set(src, vals);
+      }
+      const j = idx - offset;
+      return j >= 0 && j < vals.length ? vals[j] ?? NaN : NaN;
+    },
+    prev(offset = 1) {
+      const j = idx - Math.max(1, offset);
+      return j >= 0 ? out[j] : NaN;
+    }
+  };
+  try {
+    for (idx = 0; idx < b.length; idx++) {
+      currentBar = idx;
+      const r = fn(ctx2);
+      out[idx] = typeof r === "number" ? r : typeof r === "boolean" ? r ? 1 : 0 : NaN;
+    }
+  } finally {
+    currentBar = -1;
+  }
+  return import_series.Series.fromArray(ctxBars, out);
+}
+let currentBar = -1;
+function strategyRun(caller) {
+  const run = collector().strategy;
+  if (!run) throw new Error(`${caller}: declare the script with strategy() first.`);
+  return run;
+}
+function strategyEngine(caller) {
+  const run = strategyRun(caller);
+  if (!run.engine) {
+    throw new Error(
+      `${caller}: no strategy engine; pass it as executeScript(body, bars, inputs, chart, { strategyEngine }).`
+    );
+  }
+  return run.engine;
+}
+function orderEngine(caller) {
+  const engine = strategyEngine(caller);
+  if (!strategyRun(caller).inLoop) throw new Error(`${caller} must be called inside strategy.eachBar().`);
+  return engine;
+}
+function given(options) {
+  const out = {};
+  for (const [key, value] of Object.entries(options)) {
+    if (value === void 0 || typeof value === "number" && Number.isNaN(value)) continue;
+    out[key] = value;
+  }
+  return out;
+}
+function readEngine(caller) {
+  const engine = strategyEngine(caller);
+  if (!strategyRun(caller).inLoop) throw new Error(`${caller} must be read inside strategy.eachBar().`);
+  return engine;
+}
+const STRATEGY_CONSTANT_VARIABLES = /* @__PURE__ */ new Set(["initial_capital", "account_currency"]);
+function strategyVariable(name) {
+  const caller = `strategy.${name}`;
+  const engine = STRATEGY_CONSTANT_VARIABLES.has(name) ? strategyEngine(caller) : readEngine(caller);
+  const value = engine.get(name);
+  if (value === void 0) throw new Error(`strategy.${name} is not provided by the strategy engine.`);
+  return value;
+}
+function riskRule(rule) {
+  const engine = strategyEngine(`strategy.risk.${rule.rule}()`);
+  if (!engine.risk) throw new Error(`strategy.risk.${rule.rule}() is not provided by the strategy engine.`);
+  engine.risk(rule);
+}
+function declareStrategy(title, options = {}) {
+  const c = collector();
+  declare(c, "strategy");
+  c.title = title;
+  c.shortTitle = options.shorttitle;
+  c.overlay = options.overlay ?? false;
+  c.precision = options.precision;
+  c.format = options.format;
+  (0, import_registry.setDrawingLimits)({
+    line: options.max_lines_count,
+    label: options.max_labels_count,
+    box: options.max_boxes_count,
+    polyline: options.max_polylines_count
+  });
+  const properties = { ...import_strategy.STRATEGY_DEFAULTS };
+  const target = properties;
+  for (const key of [...Object.keys(import_strategy.STRATEGY_DEFAULTS), "currency"]) {
+    const value = options[key];
+    if (value !== void 0) target[key] = value;
+  }
+  const factory = scriptOptions.strategyEngine;
+  c.strategy = {
+    properties,
+    engine: factory?.({ properties, bars: ctxBars.bars, chart: chartCtx }),
+    looped: false,
+    inLoop: false
+  };
+}
+function strategyEachBar(fn) {
+  const run = strategyRun("strategy.eachBar()");
+  const engine = strategyEngine("strategy.eachBar()");
+  if (run.looped) throw new Error("strategy.eachBar() runs once per script run.");
+  run.looped = true;
+  return eachBar((c) => {
+    engine.processBar(c.i);
+    run.inLoop = true;
+    try {
+      return fn(c);
+    } finally {
+      run.inLoop = false;
+      engine.processClose(c.i);
+    }
+  });
+}
+const strategyMembers = {
+  ...import_strategy.STRATEGY_CONSTANTS,
+  eachBar: strategyEachBar,
+  entry(id, direction, options = {}) {
+    orderEngine("strategy.entry()").entry(id, direction, given(options));
+  },
+  order(id, direction, options = {}) {
+    orderEngine("strategy.order()").order(id, direction, given(options));
+  },
+  exit(id, options = {}) {
+    orderEngine("strategy.exit()").exit(id, given(options));
+  },
+  close(id, options = {}) {
+    orderEngine("strategy.close()").close(id, given(options));
+  },
+  close_all(options = {}) {
+    orderEngine("strategy.close_all()").close_all(given(options));
+  },
+  cancel(id) {
+    orderEngine("strategy.cancel()").cancel(id);
+  },
+  cancel_all() {
+    orderEngine("strategy.cancel_all()").cancel_all();
+  },
+  opentrade(index) {
+    return readEngine("strategy.opentrade()").openTrade(index);
+  },
+  closedtrade(index) {
+    return readEngine("strategy.closedtrade()").closedTrade(index);
+  },
+  default_entry_qty(fill_price) {
+    const engine = readEngine("strategy.default_entry_qty()");
+    if (!engine.defaultEntryQty) throw new Error("strategy.default_entry_qty() is not provided by the strategy engine.");
+    return engine.defaultEntryQty(fill_price);
+  },
+  risk: {
+    allow_entry_in: (direction) => riskRule({ rule: "allow_entry_in", direction }),
+    max_cons_loss_days: (count, alert_message) => riskRule(given({ rule: "max_cons_loss_days", count, alert_message })),
+    max_drawdown: (value, type, alert_message) => riskRule(given({ rule: "max_drawdown", value, type, alert_message })),
+    max_intraday_filled_orders: (count, alert_message) => riskRule(given({ rule: "max_intraday_filled_orders", count, alert_message })),
+    max_intraday_loss: (value, type, alert_message) => riskRule(given({ rule: "max_intraday_loss", value, type, alert_message })),
+    max_position_size: (contracts) => riskRule({ rule: "max_position_size", contracts })
+  }
+};
+const variableGetters = {};
+for (const name of [...import_strategy.STRATEGY_NUMBER_VARIABLES, ...import_strategy.STRATEGY_TEXT_VARIABLES]) {
+  variableGetters[name] = { get: () => strategyVariable(name), enumerable: true };
+}
+const strategy = Object.defineProperties(
+  Object.assign((title, options) => declareStrategy(title, options), strategyMembers),
+  variableGetters
+);
+let chartCtx = {};
+function chartTimeframe() {
+  collector();
+  if (!chartCtx.timeframe) {
+    throw new Error("The chart timeframe is not known: pass it as executeScript(body, bars, inputs, { timeframe }).");
+  }
+  return timeframeCore.info(chartCtx.timeframe);
+}
+function exchangeTimezone() {
+  collector();
+  if (!chartCtx.timezone) {
+    throw new Error("The exchange time zone is not known: pass it as executeScript(body, bars, inputs, { timezone }).");
+  }
+  return chartCtx.timezone;
+}
+const timeframe = {
+  ...timeframeCore,
+  get period() {
+    return chartTimeframe().period;
+  },
+  get main_period() {
+    return chartTimeframe().period;
+  },
+  get multiplier() {
+    return chartTimeframe().multiplier;
+  },
+  get isintraday() {
+    return chartTimeframe().isintraday;
+  },
+  get isdaily() {
+    return chartTimeframe().isdaily;
+  },
+  get isweekly() {
+    return chartTimeframe().isweekly;
+  },
+  get ismonthly() {
+    return chartTimeframe().ismonthly;
+  },
+  get isminutes() {
+    return chartTimeframe().isminutes;
+  },
+  get isseconds() {
+    return chartTimeframe().isseconds;
+  },
+  get isticks() {
+    return chartTimeframe().isticks;
+  },
+  get isdwm() {
+    return chartTimeframe().isdwm;
+  },
+  /** PineScript `timeframe.change(tf)`: 1 on bars that open a new `tf` period (0 on the first bar). */
+  change(tf) {
+    return changeOf(tf || chartTimeframe().period);
+  },
+  /** Seconds in `timeframe`; without it (or with "") the chart timeframe, as in PineScript. */
+  in_seconds(tf) {
+    return timeframeCore.in_seconds(tf === void 0 || tf === "" ? chartTimeframe().period : tf);
+  }
+};
+function symbolProperty(key) {
+  collector();
+  const value = chartCtx[key];
+  if (value === void 0) {
+    throw new Error(`syminfo.${key} is not known: pass it as executeScript(body, bars, inputs, { ${key} }).`);
+  }
+  return value;
+}
+const syminfo = {
+  get mintick() {
+    return symbolProperty("mintick");
+  },
+  get pointvalue() {
+    return symbolProperty("pointvalue");
+  },
+  get mincontract() {
+    return symbolProperty("mincontract");
+  },
+  get timezone() {
+    return exchangeTimezone();
+  },
+  get tickerid() {
+    collector();
+    if (!chartCtx.tickerid) {
+      throw new Error("The chart symbol is not known: pass it as executeScript(body, bars, inputs, { tickerid }).");
+    }
+    return chartCtx.tickerid;
+  },
+  get session() {
+    collector();
+    return chartCtx.sessionType ?? "regular";
+  }
+};
+function calendar(fn) {
+  return ((time2, timezone) => {
+    const tz = timezone ?? exchangeTimezone();
+    return time2 instanceof import_series.Series ? import_series.Series.fromArray(ctxBars, time2.toArray().map((t) => fn(t, tz))) : fn(time2, tz);
+  });
+}
+const year = calendar(timeCore.year);
+const month = calendar(timeCore.month);
+const weekofyear = calendar(timeCore.weekofyear);
+const dayofmonth = calendar(timeCore.dayofmonth);
+const dayofweek = calendar(timeCore.dayofweek);
+const hour = calendar(timeCore.hour);
+const minute = calendar(timeCore.minute);
+const second = calendar(timeCore.second);
+function timestamp(first, ...rest) {
+  if (typeof first === "number") {
+    const [m2, d2, h2, mi2, s2] = rest;
+    return timeCore.timestamp(exchangeTimezone(), first, m2, d2, h2, mi2, s2);
+  }
+  if (rest.length === 0) return timeCore.timestamp(first);
+  const [y, m, d, h, mi, s] = rest;
+  return timeCore.timestamp(first, y, m, d, h, mi, s);
+}
+function inSession(time2, session2, timezone) {
+  return timeCore.inSession(time2, session2, timezone ?? exchangeTimezone());
+}
+const str = {
+  ...strCore,
+  format_time(time2, format = "yyyy-MM-dd'T'HH:mm:ssZ", timezone) {
+    return strCore.format_time(time2, format, timezone ?? exchangeTimezone());
+  },
+  format(pattern, ...args) {
+    return (0, import_messageformat.formatMessage)(pattern, args, exchangeTimezone);
+  }
+};
+function barTime(bar) {
+  return bar.time * (chartCtx.timeUnit === "ms" ? 1 : 1e3);
+}
+const toSpec = (s) => typeof s === "string" ? { session: s } : s;
+let sessionCache = null;
+function sessionBars() {
+  const tz = exchangeTimezone();
+  const tf = chartTimeframe().period;
+  if (!chartCtx.session) {
+    throw new Error("The session is not known: pass it as executeScript(body, bars, inputs, { session }).");
+  }
+  if (sessionCache?.ctx !== chartCtx) {
+    const loaded = toSpec(chartCtx.session);
+    const regular = chartCtx.regularSession ? toSpec(chartCtx.regularSession) : loaded;
+    sessionCache = {
+      ctx: chartCtx,
+      bars: new import_bars.SessionBars(new import_calendar.TradingCalendar(tz, loaded), tf),
+      regular: new import_bars.SessionBars(new import_calendar.TradingCalendar(tz, { holidays: loaded.holidays, ...regular }), tf)
+    };
+  }
+  return sessionCache;
+}
+function calendarFor(session2, timezone) {
+  const { bars: bars2 } = sessionBars();
+  if (!session2 && !timezone) return { bars: bars2, test: false };
+  const tz = timezone ?? exchangeTimezone();
+  const spec = session2 ? { session: session2 } : { session: toSpec(chartCtx.session).session };
+  return { bars: new import_bars.SessionBars(new import_calendar.TradingCalendar(tz, spec, session2 ? "pine" : "symbol"), bars2.chart.period), test: true };
+}
+function perBar(fn) {
+  const times = ctxBars.bars.map(barTime);
+  return import_series.Series.fromArray(ctxBars, times.map((t, i) => fn(t, i, times)));
+}
+function callableSeries(series, fn) {
+  Object.setPrototypeOf(fn, import_series.Series.prototype);
+  Object.assign(fn, series);
+  return fn;
+}
+function timeFunction(tf, session2, timezone) {
+  collector();
+  const { bars: bars2, test } = calendarFor(session2, timezone);
+  const timeframeString = tf || chartTimeframe().period;
+  return perBar((t) => test && !bars2.inside(t) ? NaN : bars2.timeOf(t, timeframeString));
+}
+function timeCloseFunction(tf, session2, timezone) {
+  collector();
+  const { bars: bars2, test } = calendarFor(session2, timezone);
+  const timeframeString = tf || chartTimeframe().period;
+  return perBar((t) => test && !bars2.inside(t) ? NaN : bars2.closeOf(t, timeframeString));
+}
+const time = callableSeries(new import_series.Series(ctxBars, (b) => barTime(b)), timeFunction);
+const time_close = callableSeries(
+  new import_series.Series(ctxBars, (_b, i) => sessionBars().bars.closeOf(barTime(ctxBars.bars[i]), chartTimeframe().period)),
+  timeCloseFunction
+);
+const time_tradingday = new import_series.Series(ctxBars, (b) => sessionBars().bars.tradingDayTime(barTime(b)));
+function changeOf(tf) {
+  const { bars: bars2 } = sessionBars();
+  return perBar((t, i, times) => i > 0 && bars2.timeOf(t, tf) !== bars2.timeOf(times[i - 1], tf) ? 1 : 0);
+}
+function flag(key) {
+  const { bars: bars2, regular } = sessionBars();
+  const values = (0, import_bars.sessionFlags)(ctxBars.bars.map(barTime), bars2, regular)[key];
+  return import_series.Series.fromArray(ctxBars, values.map((v) => v ? 1 : 0));
+}
+function barFlag(test) {
+  const n = ctxBars.bars.length;
+  return import_series.Series.fromArray(ctxBars, Array.from({ length: n }, (_, i) => test(i, n) ? 1 : 0));
+}
+const lastRealtime = (i, n) => i === n - 1 && chartCtx.realtime === true;
+const barstate = {
+  get isfirst() {
+    return barFlag((i) => i === 0);
+  },
+  get islast() {
+    return barFlag((i, n) => i === n - 1);
+  },
+  get isconfirmed() {
+    return barFlag((i, n) => i < n - 1 || chartCtx.lastBarConfirmed === true);
+  },
+  get isrealtime() {
+    return barFlag(lastRealtime);
+  },
+  get ishistory() {
+    return barFlag((i, n) => !lastRealtime(i, n));
+  },
+  get isnew() {
+    return barFlag((i, n) => !lastRealtime(i, n) || chartCtx.lastBarNew !== false);
+  },
+  get islastconfirmedhistory() {
+    return barFlag((i, n) => {
+      const lastConfirmed = chartCtx.lastBarConfirmed === true && chartCtx.realtime !== true;
+      return i === (lastConfirmed ? n - 1 : n - 2);
+    });
+  }
+};
+const session = {
+  regular: "regular",
+  extended: "extended",
+  get isfirstbar() {
+    return flag("isfirstbar");
+  },
+  get islastbar() {
+    return flag("islastbar");
+  },
+  get ismarket() {
+    return flag("ismarket");
+  },
+  get ispremarket() {
+    return flag("ispremarket");
+  },
+  get ispostmarket() {
+    return flag("ispostmarket");
+  },
+  get isfirstbar_regular() {
+    return flag("isfirstbar_regular");
+  },
+  get islastbar_regular() {
+    return flag("islastbar_regular");
+  }
+};
+const barmerge = {
+  gaps_on: "gaps_on",
+  gaps_off: "gaps_off",
+  lookahead_on: "lookahead_on",
+  lookahead_off: "lookahead_off"
+};
+const HEIKIN_ASHI = "heikinashi:";
+const ticker = {
+  heikinashi(symbol) {
+    return HEIKIN_ASHI + symbol;
+  },
+  standard(symbol) {
+    return symbol.startsWith(HEIKIN_ASHI) ? symbol.slice(HEIKIN_ASHI.length) : symbol;
+  }
+};
+function valuesOf(value, length) {
+  if (!(value instanceof import_series.Series)) return new Array(length).fill(Number(value));
+  if (value.bars !== ctxBars.bars) {
+    throw new Error(
+      "request.security(): the expression returned a series computed on the chart bars. Compute the series inside the expression, e.g. () => ta.ema(close, 10)."
+    );
+  }
+  return value.toArray().slice();
+}
+function security(symbol, timeframe2, expression, gaps = barmerge.gaps_off, lookahead = barmerge.lookahead_off) {
+  collector();
+  const heikin = symbol.startsWith(HEIKIN_ASHI);
+  const base = heikin ? symbol.slice(HEIKIN_ASHI.length) : symbol;
+  if (base !== "" && base !== chartCtx.tickerid) {
+    throw new Error(`request.security: "${symbol}" is not the chart symbol; other symbols need external data.`);
+  }
+  const chart2 = chartTimeframe();
+  const tf = timeframeCore.info(timeframe2 || chart2.period).period;
+  if (timeframeCore.in_seconds(tf) < timeframeCore.in_seconds(chart2.period)) {
+    throw new Error(`request.security: timeframe "${tf}" is lower than the chart timeframe "${chart2.period}".`);
+  }
+  const chartBars = ctxBars.bars;
+  const times = chartBars.map(barTime);
+  let htf;
+  let group;
+  let latest;
+  if (tf === chart2.period) {
+    htf = chartBars;
+    group = chartBars.map((_, i) => i);
+    latest = group;
+  } else {
+    const { bars: loaded, regular } = sessionBars();
+    const calendar2 = timeframeCore.info(tf).isdwm ? regular : loaded;
+    const starts = times.map((t) => calendar2.timeOf(t, tf));
+    const dayPeriods = times.map((t, i) => {
+      const at = loaded.calendar.locate(t);
+      const periods = at ? calendar2.calendar.periods(at.date) : [];
+      return periods.length ? calendar2.timeOf(periods[0][0], tf) : starts[i];
+    });
+    const reaches = times.map((t) => loaded.closeOf(t, chart2.period) >= calendar2.periodEnd(t, tf));
+    ({ group, latest } = (0, import_resample.periodsOf)(starts, dayPeriods, reaches));
+    const unit = chartCtx.timeUnit === "ms" ? 1 : 1e3;
+    const after = (0, import_resample.afterCompletion)(group, latest);
+    const kept = (_, i) => !after[i];
+    htf = (0, import_resample.resample)(chartBars.filter(kept), starts.map((s) => s / unit).filter(kept)).bars;
+  }
+  if (heikin) htf = (0, import_resample.heikinAshi)(htf);
+  const savedCtx = chartCtx;
+  let result;
+  let values;
+  ctxBars.setAll(htf);
+  chartCtx = { ...chartCtx, timeframe: tf };
+  try {
+    result = expression();
+    const parts = Array.isArray(result) ? result : [result];
+    values = parts.map((p) => valuesOf(p, htf.length));
+  } finally {
+    ctxBars.setAll(chartBars);
+    chartCtx = savedCtx;
+  }
+  const mapped = values.map(
+    (v) => import_series.Series.fromArray(ctxBars, (0, import_resample.mapToChart)(v, group, latest, lookahead === barmerge.lookahead_on, gaps === barmerge.gaps_on))
+  );
+  return Array.isArray(result) ? mapped : mapped[0];
+}
+const request = { security };
+const line = {
+  ...lineCore,
+  get all() {
+    return lineCore.all();
+  }
+};
+const label = {
+  ...labelCore,
+  get all() {
+    return labelCore.all();
+  }
+};
+const box = {
+  ...boxCore,
+  get all() {
+    return boxCore.all();
+  }
+};
+const linefill = {
+  ...linefillCore,
+  get all() {
+    return linefillCore.all();
+  }
+};
+const polyline = {
+  ...polylineCore,
+  get all() {
+    return polylineCore.all();
+  }
+};
+const text = { ...textCore };
+const chart = {
+  point: {
+    ...chartPointCore,
+    now(price) {
+      collector();
+      if (currentBar < 0) {
+        throw new Error("chart.point.now() needs a current bar: call it inside eachBar().");
+      }
+      const bar = ctxBars.bars[currentBar];
+      return chartPointCore.new_point(barTime(bar), currentBar, price ?? bar.close);
+    }
+  }
+};
+function seriesOf(values) {
+  collector();
+  return import_series.Series.fromArray(ctxBars, values);
+}
+function alertcondition(condition, title, message) {
+  const c = collector();
+  const id = `alert${c.alertConfig.length}`;
+  c.alertConfig.push({ id, title, message });
+  const last = condition.length() ? condition.last() : NaN;
+  c.alerts.push({ id, title, message, triggered: !(0, import_utils.isNA)(last) && last !== 0 });
+}
+const math = {
+  ...mathCore,
+  round_to_mintick: ((number, mintick) => {
+    const tick = mintick ?? syminfo.mintick;
+    return number instanceof import_series.Series ? mathCore.round_to_mintick(number, tick) : mathCore.round_to_mintick(number, tick);
+  })
+};
+//# sourceMappingURL=index.js.map