lightweight-charts-indicators 0.13.3 → 0.15.0

package/README.md

@@ -144,6 +144,20 @@ before, and the indicator pane keeps its height across a redraw.
 
 The demo page (`example/`) uses the same renderer.
 
+## Source Code of the Built-in Indicators
+
+`lightweight-charts-indicators/sources` gives the source code of every standard (built-in) indicator by registry id:
+a plain JavaScript module in the library's indicator shape (`metadata`, `inputConfig`, `plotConfig`, `defaultInputs`,
+`calculate`), with the registry's names in `metadata`. It imports only `oakscriptjs` and
+`lightweight-charts-indicators/helpers` (chart context accessors, higher-timeframe periods, other-symbol requests,
+lower-timeframe volume, bar times), so a host can show it, or run a copy of it as a user script by providing those two
+modules. The table is about 500 kB: load it on demand.
+
+```typescript
+const { builtinSource } = await import('lightweight-charts-indicators/sources');
+const rsiSource = builtinSource('rsi'); // string | undefined
+```
+
 ## Lightweight-Charts Integration Example
 
 Here's a complete example showing how to integrate indicators with lightweight-charts without the renderer:

package/dist/helpers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Helpers the built-in indicator sources import (`lightweight-charts-indicators/helpers`): the chart context
+ * accessors, higher-timeframe periods, other-symbol requests, lower-timeframe volume and bar times. A source given by
+ * `lightweight-charts-indicators/sources` imports from here instead of the library's own relative paths, so a host
+ * that runs the source as a script provides this one module next to oakscriptjs.
+ */
+export * from './chart-context';
+export * from './anchor-period';
+export * from './other-symbol';
+export * from './lower-tf-volume';
+export * from './bar-time';
+//# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC"}

package/dist/helpers.mjs

@@ -0,0 +1,623 @@
+// src/chart-context.ts
+import {
+  MissingSymbolDataError
+} from "oakscriptjs/script";
+function symbolBarsOf(requests, chart) {
+  const out = requests.map((r) => chart?.bars?.(r.symbol, r.timeframe));
+  const missing = requests.filter((_, i) => out[i] === void 0);
+  if (missing.length)
+    throw new MissingSymbolDataError(missing);
+  return out;
+}
+function mintickOf(chart) {
+  if (chart?.mintick !== void 0)
+    return chart.mintick;
+  if (chart?.minmove !== void 0 && chart.pricescale !== void 0)
+    return chart.minmove / chart.pricescale;
+  return 0.01;
+}
+function sessionHoursOf(chart) {
+  return (typeof chart?.session === "string" ? chart.session : chart?.session?.session) ?? "";
+}
+function timezoneOf(chart) {
+  return chart?.timezone ?? "Etc/UTC";
+}
+function tickeridOf(chart) {
+  return chart?.tickerid ?? "";
+}
+function tickerOf(chart) {
+  const id = tickeridOf(chart);
+  return id.includes(":") ? id.slice(id.indexOf(":") + 1) : id;
+}
+function symbolTypeOf(chart) {
+  return chart?.symbolType ?? "";
+}
+function currencyOf(chart) {
+  return chart?.currency ?? "USD";
+}
+function basecurrencyOf(chart) {
+  if (chart?.basecurrency !== void 0)
+    return chart.basecurrency;
+  const type = symbolTypeOf(chart);
+  if (type !== "crypto" && type !== "forex")
+    return "";
+  const pair = tickerOf(chart).replace(/\.P$/, "");
+  const quote = currencyOf(chart);
+  return pair.length > quote.length && pair.endsWith(quote) ? pair.slice(0, -quote.length) : "";
+}
+function rootOf(chart) {
+  if (chart?.root !== void 0)
+    return chart.root;
+  const ticker = tickerOf(chart);
+  if (symbolTypeOf(chart) !== "futures")
+    return ticker;
+  return ticker.replace(/\d+!$/, "").replace(/[FGHJKMNQUVXZ]\d{4}$/, "");
+}
+function foregroundColorOf(chart) {
+  return chart?.foregroundColor ?? "#DBDBDB";
+}
+function backgroundColorOf(chart) {
+  return chart?.backgroundColor ?? "#0F0F0F";
+}
+function lastBarConfirmedOf(chart) {
+  return chart?.lastBarConfirmed ?? true;
+}
+function nowOf(chart) {
+  return chart?.now ?? Date.now();
+}
+function visibleRangeOf(bars, chart) {
+  const toMs = chart?.timeUnit === "ms" ? 1 : 1e3;
+  const last = bars.length - 1;
+  if (last < 0)
+    return { left: 0, right: -1, leftTime: NaN, rightTime: NaN };
+  const leftTime = chart?.leftVisibleBarTime ?? bars[0].time * toMs;
+  const rightTime = chart?.rightVisibleBarTime ?? bars[last].time * toMs;
+  let left = 0;
+  while (left < last && bars[left].time * toMs < leftTime)
+    left++;
+  let right = last;
+  while (right > 0 && bars[right].time * toMs > rightTime)
+    right--;
+  return { left, right, leftTime, rightTime };
+}
+
+// src/anchor-period.ts
+import {
+  barInterval,
+  timeframe,
+  periodTime,
+  tradingDayTime,
+  chartSessionFlags,
+  resampleSession,
+  chartSessions,
+  barTimeAfter,
+  barsUntil,
+  afterCompletion,
+  periodsOf,
+  resample
+} from "oakscriptjs";
+var DAY = 864e5;
+var WEEK = 7 * DAY;
+function hasCalendar(chart) {
+  return !!chart && !!chart.timezone && !!chart.session;
+}
+function calendarOf(bars, chart) {
+  if (!chart || !hasCalendar(chart) || bars.length === 0)
+    return null;
+  const tf = chartTimeframe(bars, chart);
+  if (tf === "")
+    return null;
+  const ms = bars[0].time >= 1e12;
+  const key = `${tf}|${ms ? "ms" : "s"}`;
+  let contexts = sessionContexts.get(chart);
+  if (!contexts) {
+    contexts = /* @__PURE__ */ new Map();
+    sessionContexts.set(chart, contexts);
+  }
+  let context = contexts.get(key);
+  if (context === void 0) {
+    context = {
+      timeframe: tf,
+      timezone: chart.timezone,
+      session: chart.session,
+      regularSession: chart.regularSession,
+      timeUnit: ms ? "ms" : "s"
+    };
+    try {
+      chartSessions(context);
+      periodTime(bars[0].time, "1D", context);
+    } catch {
+      context = null;
+    }
+    contexts.set(key, context);
+  }
+  return context ? { chart: context, unit: ms ? 1 : 1e3 } : null;
+}
+var sessionContexts = /* @__PURE__ */ new WeakMap();
+function calendarPeriodStart(day, info) {
+  const n = info.multiplier;
+  const d = new Date(day);
+  const year = d.getUTCFullYear();
+  if (info.isdaily) {
+    if (n === 1)
+      return day;
+    const jan1 = Date.UTC(year, 0, 1);
+    return jan1 + Math.floor((day - jan1) / DAY / n) * n * DAY;
+  }
+  if (info.isweekly) {
+    const monday = day - (d.getUTCDay() + 6) % 7 * DAY;
+    if (n === 1)
+      return monday;
+    const jan1 = Date.UTC(new Date(monday).getUTCFullYear(), 0, 1);
+    const firstMonday = jan1 + (8 - new Date(jan1).getUTCDay()) % 7 * DAY;
+    return firstMonday + Math.floor((monday - firstMonday) / WEEK / n) * n * WEEK;
+  }
+  return Date.UTC(year, Math.floor(d.getUTCMonth() / n) * n, 1);
+}
+function periodStarts(bars, tf, chart) {
+  if (tf.trim() === "")
+    return bars.map((b) => b.time);
+  const info = timeframe.info(tf);
+  if (info.isticks)
+    throw new RangeError(`Unsupported timeframe "${tf}"`);
+  const calendar = calendarOf(bars, chart);
+  if (calendar) {
+    const sessions = chartSessions(calendar.chart).bars;
+    const out2 = [];
+    bars.forEach((b, i) => {
+      const t = periodTime(b.time, tf, calendar.chart);
+      if (!Number.isNaN(t))
+        out2.push(t / calendar.unit);
+      else
+        out2.push(i > 0 && sessions.stray(b.time * calendar.unit) ? out2[i - 1] : b.time);
+    });
+    return out2;
+  }
+  const ms = bars.length > 0 && bars[0].time >= 1e12;
+  const times = bars.map((b) => ms ? b.time : b.time * 1e3);
+  const weekend = (t) => {
+    const wd = new Date(t).getUTCDay();
+    return wd === 0 || wd === 6;
+  };
+  const everyDay = times.some(weekend);
+  const len = info.isintraday ? timeframe.in_seconds(tf) * 1e3 : 0;
+  const out = [];
+  let prevDay = NaN;
+  let sessionStart = NaN;
+  let prevKey = NaN;
+  let start = NaN;
+  let tradingYear = NaN;
+  let tradingDays2 = -1;
+  let prevTradingDay = NaN;
+  for (const t of times) {
+    const day = Math.floor(t / DAY) * DAY;
+    if (day !== prevDay)
+      sessionStart = everyDay ? day : t;
+    prevDay = day;
+    if (info.isintraday) {
+      start = len >= DAY ? sessionStart : sessionStart + Math.floor((t - sessionStart) / len) * len;
+    } else if (info.isdaily && info.multiplier > 1 && !everyDay) {
+      const year = new Date(day).getUTCFullYear();
+      if (year !== tradingYear) {
+        tradingYear = year;
+        tradingDays2 = -1;
+      }
+      if (day !== prevTradingDay) {
+        tradingDays2++;
+        prevTradingDay = day;
+        if (tradingDays2 % info.multiplier === 0)
+          start = t;
+      }
+    } else {
+      const key = calendarPeriodStart(day, info);
+      if (key !== prevKey)
+        start = everyDay ? key : t;
+      prevKey = key;
+    }
+    out.push(ms ? start : Math.floor(start / 1e3));
+  }
+  return out;
+}
+function periodChanges(bars, tf, chart) {
+  const calendar = tf.trim() === "" ? null : calendarOf(bars, chart);
+  if (calendar) {
+    if (timeframe.info(tf).isticks)
+      throw new RangeError(`Unsupported timeframe "${tf}"`);
+    const times = bars.map((b) => periodTime(b.time, tf, calendar.chart));
+    return times.map((t, i) => i > 0 && !Number.isNaN(t) && !Number.isNaN(times[i - 1]) && t !== times[i - 1]);
+  }
+  const starts = periodStarts(bars, tf, chart);
+  return starts.map((t, i) => i > 0 && t !== starts[i - 1]);
+}
+function chartTimeframe(bars, chart) {
+  if (chart?.timeframe)
+    return timeframe.info(chart.timeframe).period;
+  const gap = barInterval(bars);
+  const s = Math.round(bars.length > 0 && bars[0].time >= 1e12 ? gap / 1e3 : gap);
+  if (!(s > 0))
+    return "";
+  if (s < 86400)
+    return timeframe.from_seconds(s);
+  if (s < 7 * 86400)
+    return `${Math.round(s / 86400)}D`;
+  if (s < 28 * 86400)
+    return `${Math.round(s / (7 * 86400))}W`;
+  return `${Math.max(1, Math.round(s / timeframe.in_seconds("1M")))}M`;
+}
+function securityPeriods(bars, tf, chart) {
+  return resampled(bars.map((b) => ({ time: b.time, open: 1, high: 1, low: 1, close: 1, volume: 1 })), tf, chart)?.periods ?? null;
+}
+function resampled(bars, tf, chart) {
+  const calendar = calendarOf(bars, chart);
+  if (!calendar)
+    return null;
+  const n = bars.length;
+  const { bars: htf, group, latest } = resampleSession(bars, tf, calendar.chart);
+  const starts = group.map((g, i) => Number.isNaN(htf[g].time) ? bars[i].time : htf[g].time);
+  return {
+    periods: {
+      starts,
+      group,
+      latest,
+      after: afterCompletion(group, latest),
+      lastCompletes: n > 0 && latest[n - 1] === group[n - 1]
+    },
+    htf
+  };
+}
+function securityStarts(bars, tf, chart) {
+  if (tf.trim() !== "" && hasCalendar(chart)) {
+    const chartTf = chartTimeframe(bars, chart);
+    if (chartTf !== "" && timeframe.in_seconds(tf) >= timeframe.in_seconds(chartTf)) {
+      const periods = securityPeriods(bars, tf, chart);
+      if (periods)
+        return periods.starts;
+    }
+  }
+  return periodStarts(bars, tf, chart);
+}
+function securityBars(bars, tf, chart) {
+  const res = resampled(bars, tf, chart);
+  if (!res)
+    return null;
+  const { periods } = res;
+  const first = [];
+  periods.group.forEach((g, i) => {
+    if (g >= first.length)
+      first.push(i);
+  });
+  const htf = res.htf.map((b, g) => ({ ...b, time: periods.starts[first[g]], volume: b.volume ?? NaN }));
+  return { ...periods, htf, first };
+}
+function higherTimeframeBars(bars, tf, chart) {
+  const exchange = securityBars(bars, tf, chart);
+  if (exchange)
+    return exchange;
+  const n = bars.length;
+  const starts = periodStarts(bars, tf);
+  const ms = n > 0 && bars[0].time >= 1e12;
+  const weekend = (t) => {
+    const wd = new Date(ms ? t : t * 1e3).getUTCDay();
+    return wd === 0 || wd === 6;
+  };
+  const interval = barInterval(bars);
+  const closes = bars.map((b) => ({ time: b.time + interval }));
+  let reaches;
+  if (bars.some((b) => weekend(b.time)) && closes.some((b) => weekend(b.time))) {
+    const closeStarts = periodStarts(closes, tf);
+    reaches = starts.map((s, i) => closeStarts[i] !== s);
+  } else {
+    const next = timeAfterLastBar(bars, 1);
+    const withNext = Number.isNaN(next) ? [] : periodStarts([...bars, { time: next }], tf);
+    const lastEnds = withNext.length === 0 || withNext[n] !== withNext[n - 1];
+    reaches = starts.map((_s, i) => i < n - 1 || lastEnds);
+  }
+  const { group, latest } = periodsOf(starts, starts, reaches);
+  const first = [];
+  group.forEach((g, i) => {
+    if (g >= first.length)
+      first.push(i);
+  });
+  return {
+    starts,
+    group,
+    latest,
+    after: afterCompletion(group, latest),
+    lastCompletes: n > 0 && latest[n - 1] === group[n - 1],
+    htf: resample(bars, starts).bars,
+    first
+  };
+}
+function sessionFlags(bars, chart) {
+  const calendar = calendarOf(bars, chart);
+  return calendar ? chartSessionFlags(bars.map((b) => b.time), calendar.chart) : null;
+}
+function tradingDays(bars, chart) {
+  const calendar = calendarOf(bars, chart);
+  return calendar ? bars.map((b) => tradingDayTime(b.time, calendar.chart) / calendar.unit) : null;
+}
+function timeAfterLastBar(bars, count, chart) {
+  const n = bars.length;
+  if (n === 0)
+    return NaN;
+  const last = bars[n - 1].time;
+  if (count <= 0)
+    return last;
+  const calendar = calendarOf(bars, chart);
+  if (calendar) {
+    const t2 = barTimeAfter(last, count, calendar.chart);
+    if (!Number.isNaN(t2))
+      return t2;
+  }
+  const next = utcNextBar(bars);
+  let t = last;
+  for (let k = 0; k < count && !Number.isNaN(t); k++)
+    t = next(t);
+  return t;
+}
+function barsAfterLastBar(bars, time, chart) {
+  const n = bars.length;
+  if (n === 0)
+    return NaN;
+  const last = bars[n - 1].time;
+  const calendar = calendarOf(bars, chart);
+  if (calendar) {
+    const k = barsUntil(last, time, calendar.chart);
+    if (!Number.isNaN(k))
+      return k;
+  }
+  const next = utcNextBar(bars);
+  let t = last;
+  for (let k = 0; k < 1e5; k++) {
+    const after = next(t);
+    if (Number.isNaN(after))
+      return NaN;
+    if (after > time)
+      return k;
+    t = after;
+  }
+  return NaN;
+}
+function utcNextBar(bars) {
+  const n = bars.length;
+  const ms = n > 0 && bars[0].time >= 1e12;
+  const toMs = (t) => ms ? t : t * 1e3;
+  const fromMs = (t) => ms ? t : t / 1e3;
+  const interval = toMs(barInterval(bars));
+  if (!(interval > 0))
+    return () => NaN;
+  const weekend = (t) => {
+    const wd = new Date(t).getUTCDay();
+    return wd === 0 || wd === 6;
+  };
+  if (bars.some((b) => weekend(toMs(b.time))))
+    return (t) => t + fromMs(interval);
+  const nextWeekday = (day) => {
+    let d = day + DAY;
+    while (weekend(d))
+      d += DAY;
+    return d;
+  };
+  if (interval >= 28 * DAY) {
+    const months = Math.max(1, Math.round(interval / (timeframe.in_seconds("1M") * 1e3)));
+    return (t) => {
+      const d = new Date(toMs(t));
+      let m = Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + months, 1) + toMs(t) % DAY;
+      while (weekend(m))
+        m += DAY;
+      return fromMs(m);
+    };
+  }
+  if (interval >= 7 * DAY)
+    return (t) => t + fromMs(interval);
+  if (interval >= DAY) {
+    const days = Math.round(interval / DAY);
+    return (t) => {
+      let d = Math.floor(toMs(t) / DAY) * DAY;
+      for (let k = 0; k < days; k++)
+        d = nextWeekday(d);
+      return fromMs(d + toMs(t) % DAY);
+    };
+  }
+  const lastDay = Math.floor(toMs(bars[n - 1].time) / DAY) * DAY;
+  let j = n - 1;
+  while (j >= 0 && toMs(bars[j].time) >= lastDay)
+    j--;
+  const refDay = j < 0 ? lastDay : Math.floor(toMs(bars[j].time) / DAY) * DAY;
+  const refLast = j < 0 ? toMs(bars[n - 1].time) - lastDay : toMs(bars[j].time) - refDay;
+  let i = j < 0 ? n - 1 : j;
+  while (i > 0 && toMs(bars[i - 1].time) >= refDay)
+    i--;
+  const refFirst = toMs(bars[i].time) - refDay;
+  return (t) => {
+    const day = Math.floor(toMs(t) / DAY) * DAY;
+    return fromMs(toMs(t) - day < refLast ? toMs(t) + interval : nextWeekday(day) + refFirst);
+  };
+}
+
+// src/other-symbol.ts
+import { chartSessions as chartSessions2, tradingDayTime as tradingDayTime2 } from "oakscriptjs";
+import {
+  securityOther,
+  securityOtherValues,
+  securityLowerTf
+} from "oakscriptjs";
+function otherSymbolChart(chartBars, chart) {
+  return {
+    timeframe: chartTimeframe(chartBars, chart) || "1D",
+    timezone: chart?.timezone,
+    session: chart?.session,
+    timeUnit: chart?.timeUnit ?? (chartBars.length > 0 && chartBars[0].time >= 1e12 ? "ms" : "s"),
+    lastBarConfirmed: chart?.lastBarConfirmed
+  };
+}
+var DAY2 = 864e5;
+var UTC_24X7 = { timezone: "Etc/UTC", session: "24x7" };
+var calendars = /* @__PURE__ */ new Map();
+function dailyCalendarOf(zone) {
+  if (!zone)
+    return null;
+  const key = `${zone.timezone}|${typeof zone.session === "string" ? zone.session : JSON.stringify(zone.session)}`;
+  let context = calendars.get(key);
+  if (context === void 0) {
+    context = { timeframe: "1D", timezone: zone.timezone, session: zone.session, timeUnit: "ms" };
+    try {
+      chartSessions2(context);
+    } catch {
+      context = null;
+    }
+    if (calendars.size > 64)
+      calendars.clear();
+    calendars.set(key, context);
+  }
+  return context;
+}
+function parseSpread(expr) {
+  const s = expr.replace(/\s+/g, "");
+  const m = /^([^*/]+)([*/])([^*/]+)$/.exec(s);
+  return m ? { a: m[1], op: m[2], b: m[3] } : { a: s };
+}
+function spreadSymbols(expr) {
+  const e = parseSpread(expr);
+  return e.b !== void 0 && e.b !== e.a ? [e.a, e.b] : [e.a];
+}
+function spreadOptions(expr, chart) {
+  const e = parseSpread(expr);
+  return { other: e.op ? { ...UTC_24X7 } : chart?.symbolInfo?.(e.a) };
+}
+function spreadTradingDays(times, zone) {
+  const calendar = dailyCalendarOf(zone);
+  return times.map((t) => {
+    const d = calendar ? tradingDayTime2(t, calendar) : NaN;
+    if (!Number.isNaN(d))
+      return d;
+    const day = Math.floor(t / DAY2) * DAY2;
+    return t - day >= DAY2 / 2 ? day + DAY2 : day;
+  });
+}
+function spreadBars(expr, barsBySymbol, chart) {
+  const get = (symbol) => {
+    const bars = typeof barsBySymbol === "function" ? barsBySymbol(symbol) : barsBySymbol.get(symbol);
+    if (!bars)
+      throw new RangeError(`No bars for the symbol "${symbol}" of "${expr}"`);
+    return bars;
+  };
+  const e = parseSpread(expr);
+  if (!e.op || e.b === void 0)
+    return get(e.a).slice();
+  const a = get(e.a);
+  const b = get(e.b);
+  if (a.length === 0 || b.length === 0)
+    return [];
+  const unit = chart?.timeUnit === "ms" || chart?.timeUnit === void 0 && a[0].time >= 1e12 ? 1 : 1e3;
+  const days = (bars, symbol) => {
+    const info = chart?.symbolInfo?.(symbol);
+    const zone = info?.timezone && info.session ? { timezone: info.timezone, session: info.session } : null;
+    return spreadTradingDays(bars.map((x) => x.time * unit), zone);
+  };
+  const aDays = days(a, e.a);
+  const bDays = days(b, e.b);
+  const start = Math.max(aDays[0], bDays[0]);
+  const out = [];
+  let i = -1;
+  let j = -1;
+  while (i + 1 < a.length || j + 1 < b.length) {
+    const next = Math.min(i + 1 < a.length ? aDays[i + 1] : Infinity, j + 1 < b.length ? bDays[j + 1] : Infinity);
+    while (i + 1 < a.length && aDays[i + 1] <= next)
+      i++;
+    while (j + 1 < b.length && bDays[j + 1] <= next)
+      j++;
+    if (next < start)
+      continue;
+    const c = e.op === "*" ? a[i].close * b[j].close : a[i].close / b[j].close;
+    out.push({ time: next / unit, open: c, high: c, low: c, close: c, volume: 0 });
+  }
+  return out;
+}
+
+// src/lower-tf-volume.ts
+import { timeframe as timeframe2 } from "oakscriptjs";
+var EPS = 1e-10;
+var gt = (a, b) => a - b > EPS;
+function lowerTimeframe(bars, useCustomTimeframe, customTimeframe, context) {
+  const chart = chartTimeframe(bars, context);
+  if (chart === "")
+    return { timeframe: useCustomTimeframe ? customTimeframe : "", chart, exact: false };
+  const info = timeframe2.info(chart);
+  const tf = useCustomTimeframe ? customTimeframe : info.isseconds ? "1S" : info.isintraday ? "1" : info.isdaily ? "5" : "60";
+  const lower = tf.trim() === "" ? timeframe2.in_seconds(chart) : timeframe2.in_seconds(tf);
+  const chartSeconds = timeframe2.in_seconds(chart);
+  if (lower > chartSeconds) {
+    throw new Error(`The chart's timeframe must be greater or equal to the \`${tf}\` timeframe used with \`request.security_lower_tf()\`.`);
+  }
+  return { timeframe: tf, chart, exact: lower === chartSeconds };
+}
+function upDownVolumeOfChartBars(bars) {
+  const up = [];
+  const down = [];
+  const delta = [];
+  let isBuyVolume = true;
+  for (let i = 0; i < bars.length; i++) {
+    const { open, close } = bars[i];
+    const prevClose = i > 0 ? bars[i - 1].close : NaN;
+    if (gt(close, open))
+      isBuyVolume = true;
+    else if (gt(open, close))
+      isBuyVolume = false;
+    else if (gt(close, prevClose))
+      isBuyVolume = true;
+    else if (gt(prevClose, close))
+      isBuyVolume = false;
+    const volume = bars[i].volume ?? 0;
+    const pos = isBuyVolume ? volume : 0;
+    const neg = isBuyVolume ? 0 : -volume;
+    up.push(pos);
+    down.push(neg);
+    delta.push(pos + neg);
+  }
+  return { up, down, delta };
+}
+
+// src/bar-time.ts
+import { barInterval as barInterval2, barTime } from "oakscriptjs";
+export {
+  MissingSymbolDataError,
+  backgroundColorOf,
+  barInterval2 as barInterval,
+  barTime,
+  barsAfterLastBar,
+  basecurrencyOf,
+  chartTimeframe,
+  currencyOf,
+  foregroundColorOf,
+  hasCalendar,
+  higherTimeframeBars,
+  lastBarConfirmedOf,
+  lowerTimeframe,
+  mintickOf,
+  nowOf,
+  otherSymbolChart,
+  periodChanges,
+  periodStarts,
+  rootOf,
+  securityBars,
+  securityLowerTf,
+  securityOther,
+  securityOtherValues,
+  securityPeriods,
+  securityStarts,
+  sessionFlags,
+  sessionHoursOf,
+  spreadBars,
+  spreadOptions,
+  spreadSymbols,
+  symbolBarsOf,
+  symbolTypeOf,
+  tickerOf,
+  tickeridOf,
+  timeAfterLastBar,
+  timezoneOf,
+  tradingDays,
+  upDownVolumeOfChartBars,
+  visibleRangeOf
+};