@vulcan-js/indicators 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present enpitsulin <enpitsulin@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# @vulcan-js/indicators
+
+Technical analysis indicators for the [Vulcan](../../README.md) library, built on generator-based streaming with high-precision decimal arithmetic ([`dnum`](https://github.com/bpierre/dnum)).
+
+## Installation
+
+```bash
+pnpm add @vulcan-js/indicators
+```
+
+## Usage
+
+Every indicator is a generator function. Pass an iterable source and iterate over the results:
+
+```ts
+import { collect } from '@vulcan-js/core'
+import { sma } from '@vulcan-js/indicators'
+
+const prices = [10, 11, 12, 13, 14, 15]
+
+// Collect all results into an array
+const results = collect(sma(prices, { period: 3 }))
+
+// Or iterate lazily
+for (const value of sma(prices, { period: 3 })) {
+  console.log(value) // Dnum tuple: [bigint, number]
+}
+```
+
+Use `.create()` to get a stateful processor for real-time / streaming scenarios:
+
+```ts
+import { rsi } from '@vulcan-js/indicators'
+
+const process = rsi.create({ period: 14 })
+
+process(100) // feed prices one by one
+process(102)
+process(98)
+```
+
+## Supported Indicators
+
+### Trend
+
+| Indicator | Function | Alias |
+| --- | --- | --- |
+| Aroon Indicator | `aroon` | — |
+| Balance of Power | `bop` | `balanceOfPower` |
+| Chande Forecast Oscillator | `cfo` | `chandeForecastOscillator` |
+| Commodity Channel Index | `cci` | `commodityChannelIndex` |
+| Double Exponential Moving Average | `dema` | `doubleExponentialMovingAverage` |
+| Exponential Moving Average | `ema` | `exponentialMovingAverage` |
+| Mass Index | `mi` | `massIndex` |
+| MACD | `macd` | `movingAverageConvergenceDivergence` |
+| Moving Max | `mmax` | `movingMax` |
+| Moving Min | `mmin` | `movingMin` |
+| Moving Sum | `msum` | — |
+| Rolling Moving Average | `rma` | `rollingMovingAverage` |
+| Simple Moving Average | `sma` | `simpleMovingAverage` |
+| Triangular Moving Average | `trima` | `triangularMovingAverage` |
+
+### Momentum
+
+| Indicator | Function | Alias |
+| --- | --- | --- |
+| Absolute Price Oscillator | `apo` | `absolutePriceOscillator` |
+| Awesome Oscillator | `ao` | `awesomeOscillator` |
+| Chaikin Oscillator | `cmo` | `chaikinOscillator` |
+| Ichimoku Cloud | `ichimokuCloud` | — |
+| Percentage Price Oscillator | `ppo` | `percentagePriceOscillator` |
+| Relative Strength Index | `rsi` | `relativeStrengthIndex` |
+| Stochastic Oscillator | `stoch` | `stochasticOscillator` |
+
+### Volume
+
+| Indicator | Function | Alias |
+| --- | --- | --- |
+| Accumulation/Distribution | `ad` | `accumulationDistribution` |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,485 @@
+import * as _vulcan_js_core0 from "@vulcan-js/core";
+import * as dnum from "dnum";
+import { Dnum, Numberish } from "dnum";
+
+//#region src/momentum/absolutePriceOscillator.d.ts
+interface AbsolutePriceOscillatorOptions {
+  fastPeriod: number;
+  slowPeriod: number;
+}
+declare const defaultAbsolutePriceOscillatorOptions: AbsolutePriceOscillatorOptions;
+declare const apo: _vulcan_js_core0.SignalGenerator<Numberish, dnum.Dnum, AbsolutePriceOscillatorOptions>;
+//#endregion
+//#region src/momentum/awesomeOscillator.d.ts
+interface AwesomeOscillatorOptions {
+  fastPeriod: number;
+  slowPeriod: number;
+}
+declare const defaultAwesomeOscillatorOptions: AwesomeOscillatorOptions;
+/**
+ * Awesome Oscillator (AO)
+ *
+ * AO = SMA(median, fastPeriod) - SMA(median, slowPeriod)
+ * Where median = (high + low) / 2
+ */
+declare const ao: _vulcan_js_core0.SignalGenerator<{
+  h: dnum.Numberish;
+  l: dnum.Numberish;
+}, dnum.Dnum, AwesomeOscillatorOptions>;
+//#endregion
+//#region src/momentum/chaikinOscillator.d.ts
+interface ChaikinOscillatorOptions {
+  fastPeriod: number;
+  slowPeriod: number;
+}
+declare const defaultChaikinOscillatorOptions: ChaikinOscillatorOptions;
+/**
+ * The ChaikinOscillator function measures the momentum of the
+ * Accumulation/Distribution (A/D) using the Moving Average
+ * Convergence Divergence (MACD) formula. It takes the
+ * difference between fast and slow periods EMA of the A/D.
+ * Cross above the A/D line indicates bullish.
+ *
+ * CO = Ema(fastPeriod, AD) - Ema(slowPeriod, AD)
+ */
+declare const cmo: _vulcan_js_core0.SignalGenerator<{
+  h: dnum.Numberish;
+  l: dnum.Numberish;
+  c: dnum.Numberish;
+  v: dnum.Numberish;
+}, dnum.Dnum, ChaikinOscillatorOptions>;
+//#endregion
+//#region src/momentum/ichimokuCloud.d.ts
+interface IchimokuCloudOptions {
+  /** Conversion line period */
+  conversionPeriod: number;
+  /** Base line period */
+  basePeriod: number;
+  /** Leading span B period */
+  leadingBPeriod: number;
+}
+declare const defaultIchimokuCloudOptions: IchimokuCloudOptions;
+interface IchimokuCloudPoint {
+  conversion: Dnum;
+  base: Dnum;
+  leadingA: Dnum;
+  leadingB: Dnum;
+  lagging: Dnum;
+}
+/**
+ * Ichimoku Cloud (Ichimoku Kinko Hyo)
+ *
+ * Computes raw values for each component. Displacement (shifting
+ * Leading Spans forward and Lagging Span backward on the chart)
+ * is a presentation concern left to the consumer.
+ *
+ * - Conversion (Tenkan-sen): (highest high + lowest low) / 2 over conversionPeriod
+ * - Base (Kijun-sen): (highest high + lowest low) / 2 over basePeriod
+ * - Leading Span A (Senkou A): (conversion + base) / 2
+ * - Leading Span B (Senkou B): (highest high + lowest low) / 2 over leadingBPeriod
+ * - Lagging (Chikou): current close price
+ */
+declare const ichimokuCloud: _vulcan_js_core0.SignalGenerator<{
+  h: dnum.Numberish;
+  l: dnum.Numberish;
+  c: dnum.Numberish;
+}, {
+  conversion: Dnum;
+  base: Dnum;
+  leadingA: Dnum;
+  leadingB: Dnum;
+  lagging: Dnum;
+}, IchimokuCloudOptions>;
+//#endregion
+//#region src/momentum/percentagePriceOscillator.d.ts
+interface PercentagePriceOscillatorOptions {
+  fastPeriod: number;
+  slowPeriod: number;
+  signalPeriod: number;
+}
+declare const defaultPercentagePriceOscillatorOptions: PercentagePriceOscillatorOptions;
+interface PercentagePriceOscillatorPoint {
+  ppo: Dnum;
+  signal: Dnum;
+  histogram: Dnum;
+}
+/**
+ * Percentage Price Oscillator (PPO)
+ *
+ * The Percentage Price Oscillator (PPO) is a momentum oscillator that measures the difference
+ * between two moving averages as a percentage of the slower moving average. It consists of three components:
+ * - PPO Line: ((Fast EMA - Slow EMA) / Slow EMA) * 100
+ * - Signal Line: EMA of the PPO line
+ * - Histogram: PPO - Signal
+ *
+ * Formula:
+ * - PPO = ((EMA(fastPeriod, prices) - EMA(slowPeriod, prices)) / EMA(slowPeriod, prices)) * 100
+ * - Signal = EMA(signalPeriod, PPO)
+ * - Histogram = PPO - Signal
+ *
+ * @param source - Iterable of price values
+ * @param options - Configuration options
+ * @param options.fastPeriod - Period for the fast EMA (default: 12)
+ * @param options.slowPeriod - Period for the slow EMA (default: 26)
+ * @param options.signalPeriod - Period for the signal EMA (default: 9)
+ * @returns Generator yielding PPO point objects
+ */
+declare const ppo: _vulcan_js_core0.SignalGenerator<Numberish, {
+  ppo: Dnum;
+  signal: Dnum;
+  histogram: Dnum;
+}, PercentagePriceOscillatorOptions>;
+//#endregion
+//#region src/momentum/relativeStrengthIndex.d.ts
+interface RSIOptions {
+  period: number;
+}
+declare const defaultRSIOptions: RSIOptions;
+/**
+ * Relative Strength Index (RSI). It is a momentum indicator that measures the magnitude of
+ * recent price changes to evaluate overbought and oversold conditions
+ * using the given window period.
+ *
+ * RS = Average Gain / Average Loss
+ *
+ * RSI = 100 - (100 / (1 + RS))
+ */
+declare const rsi: _vulcan_js_core0.SignalGenerator<Numberish, Dnum, RSIOptions>;
+//#endregion
+//#region src/momentum/stochasticOscillator.d.ts
+interface StochasticOscillatorOptions {
+  /** The %k period */
+  kPeriod: number;
+  /** The %k slowing period */
+  slowingPeriod: number;
+  /** The %d period  */
+  dPeriod: number;
+}
+declare const defaultStochasticOscillatorOptions: StochasticOscillatorOptions;
+interface StochPoint {
+  k: Dnum;
+  d: Dnum;
+}
+/**
+ * Stochastic Oscillator
+ *
+ * %K = ((Close - Lowest Low) / (Highest High - Lowest Low)) * 100
+ * %D = SMA(%K, dPeriod)
+ */
+declare const stoch: _vulcan_js_core0.SignalGenerator<{
+  h: dnum.Numberish;
+  l: dnum.Numberish;
+  c: dnum.Numberish;
+}, {
+  k: Dnum;
+  d: Dnum;
+}, StochasticOscillatorOptions>;
+//#endregion
+//#region src/trend/aroon.d.ts
+interface AroonOptions {
+  period: number;
+}
+declare const defaultAroonOptions: AroonOptions;
+interface AroonPoint {
+  up: Dnum;
+  down: Dnum;
+  oscillator: Dnum;
+}
+/**
+ * Aroon Indicator
+ *
+ * Aroon Up = ((period - days since highest high) / period) * 100
+ * Aroon Down = ((period - days since lowest low) / period) * 100
+ * Oscillator = Aroon Up - Aroon Down
+ */
+declare const aroon: _vulcan_js_core0.SignalGenerator<{
+  h: dnum.Numberish;
+  l: dnum.Numberish;
+}, {
+  up: Dnum;
+  down: Dnum;
+  oscillator: Dnum;
+}, AroonOptions>;
+//#endregion
+//#region src/trend/balanceOfPower.d.ts
+declare const bop: _vulcan_js_core0.SignalGenerator<{
+  h: dnum.Numberish;
+  l: dnum.Numberish;
+  c: dnum.Numberish;
+  o: dnum.Numberish;
+}, dnum.Dnum, Record<string, any>>;
+//#endregion
+//#region src/trend/chandeForecastOscillator.d.ts
+interface ChandeForecastOscillatorOptions {
+  /**
+   * The period for linear regression
+   * @default 14
+   */
+  period: number;
+}
+declare const defaultCFOOptions: ChandeForecastOscillatorOptions;
+/**
+ * Chande Forecast Oscillator (CFO)
+ *
+ * Measures the percentage difference between the actual close price and the
+ * n-period linear regression forecast price. Positive values indicate bullish
+ * momentum (price above forecast), negative values indicate bearish momentum.
+ *
+ * Formula: CFO = ((Close - Forecast) / Close) * 100
+ * Where: Forecast = Linear regression value at current point
+ *
+ * @param source - Iterable of price values
+ * @param options - Configuration options
+ * @param options.period - The period for linear regression (default: 14)
+ * @returns Generator yielding CFO values as percentages
+ */
+declare const cfo: _vulcan_js_core0.SignalGenerator<Numberish, Dnum, ChandeForecastOscillatorOptions>;
+//#endregion
+//#region src/trend/commodityChannelIndex.d.ts
+interface CommodityChannelIndexOptions {
+  /**
+   * The period for CCI calculation
+   * @default 20
+   */
+  period: number;
+}
+declare const defaultCCIOptions: CommodityChannelIndexOptions;
+/**
+ * Commodity Channel Index (CCI)
+ *
+ * Developed by Donald Lambert in 1980, CCI measures the deviation of the
+ * typical price from its simple moving average, normalized by mean deviation.
+ * The constant 0.015 ensures approximately 70-80% of CCI values fall between
+ * +100 and -100.
+ *
+ * Formula:
+ *   TP = (High + Low + Close) / 3
+ *   CCI = (TP - SMA(TP, period)) / (0.015 * Mean Deviation)
+ *   Mean Deviation = SUM(|TP_i - SMA|) / period
+ *
+ * @param source - Iterable of OHLC candle data
+ * @param options - Configuration options
+ * @param options.period - The period for CCI calculation (default: 20)
+ * @returns Generator yielding CCI values
+ */
+declare const cci: _vulcan_js_core0.SignalGenerator<{
+  h: dnum.Numberish;
+  l: dnum.Numberish;
+  c: dnum.Numberish;
+}, Dnum, CommodityChannelIndexOptions>;
+//#endregion
+//#region src/trend/doubleExponentialMovingAverage.d.ts
+interface DoubleExponentialMovingAverageOptions {
+  period: number;
+}
+declare const defaultDoubleExponentialMovingAverageOptions: DoubleExponentialMovingAverageOptions;
+/**
+ * Double Exponential Moving Average (DEMA)
+ *
+ * DEMA reduces lag compared to a traditional EMA by applying the formula:
+ * DEMA = 2 * EMA(data, period) - EMA(EMA(data, period), period)
+ *
+ * @param source - Iterable of input values
+ * @param options - Configuration options
+ * @param options.period - The lookback period (default: 12)
+ * @returns Generator yielding DEMA values
+ */
+declare const dema: _vulcan_js_core0.SignalGenerator<Numberish, dnum.Dnum, DoubleExponentialMovingAverageOptions>;
+//#endregion
+//#region src/trend/exponentialMovingAverage.d.ts
+interface ExponentialMovingAverageOptions {
+  period: number;
+}
+declare const defaultExponentialMovingAverageOptions: ExponentialMovingAverageOptions;
+/**
+ * Exponential Moving Average (EMA)
+ *
+ * EMA = Price * k + PrevEMA * (1 - k)
+ * Where k = 2 / (period + 1)
+ */
+declare const ema: _vulcan_js_core0.SignalGenerator<Numberish, Dnum, ExponentialMovingAverageOptions>;
+//#endregion
+//#region src/trend/macd.d.ts
+interface MACDOptions {
+  fastPeriod: number;
+  slowPeriod: number;
+  signalPeriod: number;
+}
+declare const defaultMACDOptions: MACDOptions;
+interface MACDPoint {
+  macd: Dnum;
+  signal: Dnum;
+  histogram: Dnum;
+}
+/**
+ * Moving Average Convergence Divergence (MACD)
+ *
+ * MACD is a trend-following momentum indicator that shows the relationship
+ * between two exponential moving averages of prices. It consists of three components:
+ * - MACD Line: Fast EMA - Slow EMA
+ * - Signal Line: EMA of the MACD line
+ * - Histogram: MACD - Signal
+ *
+ * Formula:
+ * - MACD = EMA(fastPeriod, prices) - EMA(slowPeriod, prices)
+ * - Signal = EMA(signalPeriod, MACD)
+ * - Histogram = MACD - Signal
+ *
+ * @param source - Iterable of price values
+ * @param options - Configuration options
+ * @param options.fastPeriod - Period for the fast EMA (default: 12)
+ * @param options.slowPeriod - Period for the slow EMA (default: 26)
+ * @param options.signalPeriod - Period for the signal EMA (default: 9)
+ * @returns Generator yielding MACDPoint objects
+ */
+declare const macd: _vulcan_js_core0.SignalGenerator<Numberish, {
+  macd: Dnum;
+  signal: Dnum;
+  histogram: Dnum;
+}, MACDOptions>;
+//#endregion
+//#region src/trend/massIndex.d.ts
+interface MassIndexOptions {
+  /**
+   * The period for EMA smoothing of the high-low range
+   * @default 9
+   */
+  emaPeriod: number;
+  /**
+   * The period for the moving sum of the EMA ratio
+   * @default 25
+   */
+  miPeriod: number;
+}
+declare const defaultMassIndexOptions: MassIndexOptions;
+/**
+ * Mass Index (MI)
+ *
+ * Developed by Donald Dorsey, the Mass Index uses the high-low range
+ * to identify trend reversals based on range expansions. A "reversal bulge"
+ * occurs when the Mass Index rises above 27 and then falls below 26.5.
+ *
+ * Formula:
+ *   Range = High - Low
+ *   EMA1 = EMA(Range, emaPeriod)
+ *   EMA2 = EMA(EMA1, emaPeriod)
+ *   Ratio = EMA1 / EMA2
+ *   MI = MovingSum(Ratio, miPeriod)
+ *
+ * @param source - Iterable of OHLC candle data (requires high and low)
+ * @param options - Configuration options
+ * @param options.emaPeriod - The EMA smoothing period (default: 9)
+ * @param options.miPeriod - The moving sum period (default: 25)
+ * @returns Generator yielding Mass Index values
+ */
+declare const mi: _vulcan_js_core0.SignalGenerator<{
+  h: dnum.Numberish;
+  l: dnum.Numberish;
+}, dnum.Dnum, MassIndexOptions>;
+//#endregion
+//#region src/trend/movingMax.d.ts
+interface MovingMaxOptions {
+  /**
+   * period
+   */
+  period: number;
+}
+declare const defaultMovingMaxOptions: MovingMaxOptions;
+/**
+ * Moving Maximum (MovingMax)
+ */
+declare const mmax: _vulcan_js_core0.SignalGenerator<Numberish, Dnum, MovingMaxOptions>;
+//#endregion
+//#region src/trend/movingMin.d.ts
+interface MovingMinOptions {
+  /**
+   * period
+   */
+  period: number;
+}
+declare const defaultMovingMinOptions: MovingMinOptions;
+/**
+ * Moving Minimum (MovingMin)
+ */
+declare const mmin: _vulcan_js_core0.SignalGenerator<Numberish, Dnum, MovingMinOptions>;
+//#endregion
+//#region src/trend/movingSum.d.ts
+interface MovingSumOptions {
+  period: number;
+}
+declare const defaultMovingSumOptions: MovingSumOptions;
+/**
+ * Moving Sum
+ *
+ * Calculates the sum of values in a sliding window of the specified period.
+ */
+declare const msum: _vulcan_js_core0.SignalGenerator<Numberish, Dnum, MovingSumOptions>;
+//#endregion
+//#region src/trend/rollingMovingAverage.d.ts
+interface RMAOptions {
+  /**
+   * period
+   */
+  period: number;
+}
+declare const defaultRMAOptions: RMAOptions;
+/**
+ * Rolling moving average (RMA).
+ *
+ * R[0] to R[p-1] is SMA(values)
+ *
+ * R[p] and after is R[i] = ((R[i-1]*(p-1)) + v[i]) / p
+ */
+declare const rma: _vulcan_js_core0.SignalGenerator<Numberish, Dnum, RMAOptions>;
+//#endregion
+//#region src/trend/simpleMovingAverage.d.ts
+interface SimpleMovingAverageOptions {
+  /**
+   * The period for calculating the moving average
+   * @default 2
+   */
+  period: number;
+}
+declare const defaultSMAOptions: SimpleMovingAverageOptions;
+/**
+ * Simple Moving Average (SMA)
+ *
+ * Calculates the arithmetic mean of a set of values over a specified period.
+ * The SMA is calculated by summing all values in the period and dividing by the period length.
+ *
+ * Formula: SMA = (P1 + P2 + ... + Pn) / n
+ * Where: P = Price values, n = Period
+ *
+ * @param source - Iterable of price values
+ * @param options - Configuration options
+ * @param options.period - The period for calculating the moving average (default: 2)
+ * @returns Generator yielding SMA values
+ */
+declare const sma: _vulcan_js_core0.SignalGenerator<Numberish, Dnum, SimpleMovingAverageOptions>;
+//#endregion
+//#region src/trend/triangularMovingAverage.d.ts
+interface TriangularMovingAverageOptions {
+  period: number;
+}
+declare const defaultTriangularMovingAverageOptions: TriangularMovingAverageOptions;
+declare const trima: _vulcan_js_core0.SignalGenerator<Numberish, dnum.Dnum, TriangularMovingAverageOptions>;
+//#endregion
+//#region src/volume/accumulationDistribution.d.ts
+/**
+ * Accumulation/Distribution Indicator (A/D). Cumulative indicator
+ * that uses volume and price to assess whether a stock is
+ * being accumulated or distributed.
+ *
+ * MFM = ((Closing - Low) - (High - Closing)) / (High - Low)
+ * MFV = MFM * Period Volume
+ * AD = Previous AD + CMFV
+ */
+declare const ad: _vulcan_js_core0.SignalGenerator<{
+  h: dnum.Numberish;
+  l: dnum.Numberish;
+  c: dnum.Numberish;
+  v: dnum.Numberish;
+}, Dnum, Record<string, any>>;
+//#endregion
+export { AbsolutePriceOscillatorOptions, AroonOptions, AroonPoint, AwesomeOscillatorOptions, ChaikinOscillatorOptions, ChandeForecastOscillatorOptions, CommodityChannelIndexOptions, DoubleExponentialMovingAverageOptions, ExponentialMovingAverageOptions, IchimokuCloudOptions, IchimokuCloudPoint, MACDOptions, MACDPoint, MassIndexOptions, MovingMaxOptions, MovingMinOptions, MovingSumOptions, PercentagePriceOscillatorOptions, PercentagePriceOscillatorPoint, RMAOptions, RSIOptions, SimpleMovingAverageOptions, StochPoint, StochasticOscillatorOptions, TriangularMovingAverageOptions, apo as absolutePriceOscillator, apo, ad as accumulationDistribution, ad, ao, ao as awesomeOscillator, aroon, bop as balanceOfPower, bop, cci, cci as commodityChannelIndex, cfo, cfo as chandeForecastOscillator, cmo as chaikinOscillator, cmo, defaultAbsolutePriceOscillatorOptions, defaultAroonOptions, defaultAwesomeOscillatorOptions, defaultCCIOptions, defaultCFOOptions, defaultChaikinOscillatorOptions, defaultDoubleExponentialMovingAverageOptions, defaultExponentialMovingAverageOptions, defaultIchimokuCloudOptions, defaultMACDOptions, defaultMassIndexOptions, defaultMovingMaxOptions, defaultMovingMinOptions, defaultMovingSumOptions, defaultPercentagePriceOscillatorOptions, defaultRMAOptions, defaultRSIOptions, defaultSMAOptions, defaultStochasticOscillatorOptions, defaultTriangularMovingAverageOptions, dema, dema as doubleExponentialMovingAverage, ema, ema as exponentialMovingAverage, ichimokuCloud, macd, macd as movingAverageConvergenceDivergence, mi as massIndex, mi, mmax, mmax as movingMax, mmin, mmin as movingMin, msum, ppo as percentagePriceOscillator, ppo, rsi as relativeStrengthIndex, rsi, rma, rma as rollingMovingAverage, sma as simpleMovingAverage, sma, stoch, stoch as stochasticOscillator, trima as triangularMovingAverage, trima };
+//# sourceMappingURL=index.d.ts.map