@thuantan2060/technicalindicators/dist/browser.js

Techincal Indicators written in javascript

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
	typeof define === 'function' && define.amd ? define(factory) :
	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.TechnicalIndicators = factory());
})(this, (function () { 'use strict';

	function getDefaultExportFromCjs (x) {
		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
	}

	var indexCjs$1 = {};

	var lib = {};

	var interopRequireDefault = {exports: {}};

	(function (module) {
		function _interopRequireDefault(e) {
		  return e && e.__esModule ? e : {
		    "default": e
		  };
		}
		module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (interopRequireDefault));

	var interopRequireDefaultExports = interopRequireDefault.exports;

	var FixedSizeLinkedList = {};

	var LinkedList = {};

	var hasRequiredLinkedList;

	function requireLinkedList () {
		if (hasRequiredLinkedList) return LinkedList;
		hasRequiredLinkedList = 1;

		Object.defineProperty(LinkedList, "__esModule", {
		  value: true
		});
		LinkedList.LinkedList = void 0;
		class Item {
		  next;
		  prev;
		  data;
		  constructor(data, prev, next) {
		    this.next = next;
		    if (next) next.prev = this;
		    this.prev = prev;
		    if (prev) prev.next = this;
		    this.data = data;
		  }
		}
		let LinkedList$1 = class LinkedList {
		  _head;
		  _tail;
		  _next;
		  _length = 0;
		  _current;
		  constructor() {}
		  get head() {
		    return this._head && this._head.data;
		  }
		  get tail() {
		    return this._tail && this._tail.data;
		  }
		  get current() {
		    return this._current && this._current.data;
		  }
		  get length() {
		    return this._length;
		  }
		  push(data) {
		    this._tail = new Item(data, this._tail);
		    if (this._length === 0) {
		      this._head = this._tail;
		      this._current = this._head;
		      this._next = this._head;
		    }
		    this._length++;
		  }
		  pop() {
		    var tail = this._tail;
		    if (this._length === 0) {
		      return;
		    }
		    this._length--;
		    if (this._length === 0) {
		      this._head = this._tail = this._current = this._next = undefined;
		      return tail.data;
		    }
		    this._tail = tail.prev;
		    this._tail.next = undefined;
		    if (this._current === tail) {
		      this._current = this._tail;
		      this._next = undefined;
		    }
		    return tail.data;
		  }
		  shift() {
		    var head = this._head;
		    if (this._length === 0) {
		      return;
		    }
		    this._length--;
		    if (this._length === 0) {
		      this._head = this._tail = this._current = this._next = undefined;
		      return head.data;
		    }
		    this._head = this._head.next;
		    if (this._current === head) {
		      this._current = this._head;
		      this._next = this._current.next;
		    }
		    return head.data;
		  }
		  unshift(data) {
		    this._head = new Item(data, undefined, this._head);
		    if (this._length === 0) {
		      this._tail = this._head;
		      this._next = this._head;
		    }
		    this._length++;
		  }
		  unshiftCurrent() {
		    var current = this._current;
		    if (current === this._head || this._length < 2) {
		      return current && current.data;
		    }
		    // remove
		    if (current === this._tail) {
		      this._tail = current.prev;
		      this._tail.next = undefined;
		      this._current = this._tail;
		    } else {
		      current.next.prev = current.prev;
		      current.prev.next = current.next;
		      this._current = current.prev;
		    }
		    this._next = this._current.next;
		    // unshift
		    current.next = this._head;
		    current.prev = undefined;
		    this._head.prev = current;
		    this._head = current;
		    return current.data;
		  }
		  removeCurrent() {
		    var current = this._current;
		    if (this._length === 0) {
		      return;
		    }
		    this._length--;
		    if (this._length === 0) {
		      this._head = this._tail = this._current = this._next = undefined;
		      return current.data;
		    }
		    if (current === this._tail) {
		      this._tail = current.prev;
		      this._tail.next = undefined;
		      this._current = this._tail;
		    } else if (current === this._head) {
		      this._head = current.next;
		      this._head.prev = undefined;
		      this._current = this._head;
		    } else {
		      current.next.prev = current.prev;
		      current.prev.next = current.next;
		      this._current = current.prev;
		    }
		    this._next = this._current.next;
		    return current.data;
		  }
		  resetCursor() {
		    this._current = this._next = this._head;
		    return this;
		  }
		  next() {
		    var next = this._next;
		    if (next !== undefined) {
		      this._next = next.next;
		      this._current = next;
		      return next.data;
		    }
		  }
		};
		LinkedList.LinkedList = LinkedList$1;
		
		return LinkedList;
	}

	var hasRequiredFixedSizeLinkedList;

	function requireFixedSizeLinkedList () {
		if (hasRequiredFixedSizeLinkedList) return FixedSizeLinkedList;
		hasRequiredFixedSizeLinkedList = 1;

		Object.defineProperty(FixedSizeLinkedList, "__esModule", {
		  value: true
		});
		FixedSizeLinkedList.default = void 0;
		var _LinkedList = requireLinkedList();
		/**
		 * Created by AAravindan on 5/7/16.
		 */

		let FixedSizeLinkedList$1 = class FixedSizeLinkedList extends _LinkedList.LinkedList {
		  totalPushed = 0;
		  periodHigh = 0;
		  periodLow = Infinity;
		  periodSum = 0;
		  lastShift;
		  _push;
		  constructor(size, maintainHigh, maintainLow, maintainSum) {
		    super();
		    this.size = size;
		    this.maintainHigh = maintainHigh;
		    this.maintainLow = maintainLow;
		    this.maintainSum = maintainSum;
		    if (!size || typeof size !== 'number') {
		      throw 'Size required and should be a number.';
		    }
		    this._push = this.push;
		    this.push = function (data) {
		      this.add(data);
		      this.totalPushed++;
		    };
		  }
		  add(data) {
		    if (this.length === this.size) {
		      this.lastShift = this.shift();
		      this._push(data);
		      //TODO: FInd a better way
		      if (this.maintainHigh) if (this.lastShift == this.periodHigh) this.calculatePeriodHigh();
		      if (this.maintainLow) if (this.lastShift == this.periodLow) this.calculatePeriodLow();
		      if (this.maintainSum) {
		        this.periodSum = this.periodSum - this.lastShift;
		      }
		    } else {
		      this._push(data);
		    }
		    //TODO: FInd a better way
		    if (this.maintainHigh) if (this.periodHigh <= data) this.periodHigh = data;
		    if (this.maintainLow) if (this.periodLow >= data) this.periodLow = data;
		    if (this.maintainSum) {
		      this.periodSum = this.periodSum + data;
		    }
		  }
		  *iterator() {
		    this.resetCursor();
		    while (this.next()) {
		      yield this.current;
		    }
		  }
		  calculatePeriodHigh() {
		    this.resetCursor();
		    if (this.next()) this.periodHigh = this.current;
		    while (this.next()) {
		      if (this.periodHigh <= this.current) {
		        this.periodHigh = this.current;
		      }
		    }
		  }
		  calculatePeriodLow() {
		    this.resetCursor();
		    if (this.next()) this.periodLow = this.current;
		    while (this.next()) {
		      if (this.periodLow >= this.current) {
		        this.periodLow = this.current;
		      }
		    }
		  }
		};
		FixedSizeLinkedList.default = FixedSizeLinkedList$1;
		
		return FixedSizeLinkedList;
	}

	var StockData = {};

	var hasRequiredStockData;

	function requireStockData () {
		if (hasRequiredStockData) return StockData;
		hasRequiredStockData = 1;

		Object.defineProperty(StockData, "__esModule", {
		  value: true
		});
		StockData.default = StockData.CandleList = StockData.CandleData = void 0;
		let StockData$1 = class StockData {
		  reversedInput;
		  constructor(open, high, low, close, reversedInput) {
		    this.open = open;
		    this.high = high;
		    this.low = low;
		    this.close = close;
		    this.reversedInput = reversedInput;
		  }
		};
		StockData.default = StockData$1;
		class CandleData {
		  open;
		  high;
		  low;
		  close;
		  timestamp;
		  volume;
		}
		StockData.CandleData = CandleData;
		class CandleList {
		  open = [];
		  high = [];
		  low = [];
		  close = [];
		  volume = [];
		  timestamp = [];
		}
		StockData.CandleList = CandleList;
		
		return StockData;
	}

	var SMA = {};

	var indicator = {};

	var NumberFormatter = {};

	var config = {};

	var hasRequiredConfig;

	function requireConfig () {
		if (hasRequiredConfig) return config;
		hasRequiredConfig = 1;

		Object.defineProperty(config, "__esModule", {
		  value: true
		});
		config.getConfig = getConfig;
		config.setConfig = setConfig;
		let config$1 = {};
		function setConfig(key, value) {
		  config$1[key] = value;
		}
		function getConfig(key) {
		  return config$1[key];
		}
		
		return config;
	}

	var hasRequiredNumberFormatter;

	function requireNumberFormatter () {
		if (hasRequiredNumberFormatter) return NumberFormatter;
		hasRequiredNumberFormatter = 1;

		Object.defineProperty(NumberFormatter, "__esModule", {
		  value: true
		});
		NumberFormatter.format = format;
		var _config = requireConfig();
		function format(v) {
		  let precision = (0, _config.getConfig)('precision');
		  if (precision) {
		    return parseFloat(v.toPrecision(precision));
		  }
		  return v;
		}
		
		return NumberFormatter;
	}

	var hasRequiredIndicator;

	function requireIndicator () {
		if (hasRequiredIndicator) return indicator;
		hasRequiredIndicator = 1;

		Object.defineProperty(indicator, "__esModule", {
		  value: true
		});
		indicator.IndicatorInput = indicator.Indicator = indicator.AllInputs = void 0;
		var _NumberFormatter = requireNumberFormatter();
		class IndicatorInput {
		  reversedInput;
		  format;
		}
		indicator.IndicatorInput = IndicatorInput;
		class AllInputs {
		  values;
		  open;
		  high;
		  low;
		  close;
		  volume;
		  timestamp;
		}
		indicator.AllInputs = AllInputs;
		class Indicator {
		  result;
		  format;
		  constructor(input) {
		    this.format = input.format || _NumberFormatter.format;
		  }
		  static reverseInputs(input) {
		    if (input.reversedInput) {
		      input.values ? input.values.reverse() : undefined;
		      input.open ? input.open.reverse() : undefined;
		      input.high ? input.high.reverse() : undefined;
		      input.low ? input.low.reverse() : undefined;
		      input.close ? input.close.reverse() : undefined;
		      input.volume ? input.volume.reverse() : undefined;
		      input.timestamp ? input.timestamp.reverse() : undefined;
		    }
		  }
		  getResult() {
		    return this.result;
		  }
		}
		indicator.Indicator = Indicator;
		
		return indicator;
	}

	var hasRequiredSMA;

	function requireSMA () {
		if (hasRequiredSMA) return SMA;
		hasRequiredSMA = 1;

		Object.defineProperty(SMA, "__esModule", {
		  value: true
		});
		SMA.SMA = SMA.MAInput = void 0;
		SMA.sma = sma;
		var _indicator = requireIndicator();
		var _LinkedList = requireLinkedList();
		//STEP 1. Import Necessary indicator or rather last step

		//STEP 2. Create the input for the indicator, mandatory should be in the constructor
		class MAInput extends _indicator.IndicatorInput {
		  constructor(period, values) {
		    super();
		    this.period = period;
		    this.values = values;
		  }
		}

		//STEP3. Add class based syntax with export
		SMA.MAInput = MAInput;
		let SMA$1 = class SMA extends _indicator.Indicator {
		  period;
		  price;
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    this.period = input.period;
		    this.price = input.values;
		    var genFn = function* (period) {
		      var list = new _LinkedList.LinkedList();
		      var sum = 0;
		      var counter = 1;
		      var current = yield;
		      var result;
		      list.push(0);
		      while (true) {
		        if (counter < period) {
		          counter++;
		          list.push(current);
		          sum = sum + current;
		        } else {
		          sum = sum - list.shift() + current;
		          result = sum / period;
		          list.push(current);
		        }
		        current = yield result;
		      }
		    };
		    this.generator = genFn(this.period);
		    this.generator.next();
		    this.result = [];
		    this.price.forEach(tick => {
		      var result = this.generator.next(tick);
		      if (result.value !== undefined) {
		        this.result.push(this.format(result.value));
		      }
		    });
		  }
		  static calculate = sma;
		  nextValue(price) {
		    var result = this.generator.next(price).value;
		    if (result != undefined) return this.format(result);
		  }
		};
		SMA.SMA = SMA$1;
		function sma(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new SMA$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}

		//STEP 6. Run the tests
		
		return SMA;
	}

	var EMA = {};

	var hasRequiredEMA;

	function requireEMA () {
		if (hasRequiredEMA) return EMA;
		hasRequiredEMA = 1;

		Object.defineProperty(EMA, "__esModule", {
		  value: true
		});
		EMA.EMA = void 0;
		EMA.ema = ema;
		var _indicator = requireIndicator();
		var _SMA = requireSMA();
		let EMA$1 = class EMA extends _indicator.Indicator {
		  period;
		  price;
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    var period = input.period;
		    var priceArray = input.values;
		    var exponent = 2 / (period + 1);
		    var sma;
		    this.result = [];
		    sma = new _SMA.SMA({
		      period: period,
		      values: []
		    });
		    var genFn = function* () {
		      var tick = yield;
		      var prevEma;
		      while (true) {
		        if (prevEma !== undefined && tick !== undefined) {
		          prevEma = (tick - prevEma) * exponent + prevEma;
		          tick = yield prevEma;
		        } else {
		          tick = yield;
		          prevEma = sma.nextValue(tick);
		          if (prevEma) tick = yield prevEma;
		        }
		      }
		    };
		    this.generator = genFn();
		    this.generator.next();
		    this.generator.next();
		    priceArray.forEach(tick => {
		      var result = this.generator.next(tick);
		      if (result.value != undefined) {
		        this.result.push(this.format(result.value));
		      }
		    });
		  }
		  static calculate = ema;
		  nextValue(price) {
		    var result = this.generator.next(price).value;
		    if (result != undefined) return this.format(result);
		  }
		};
		EMA.EMA = EMA$1;
		function ema(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new EMA$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return EMA;
	}

	var WMA = {};

	var hasRequiredWMA;

	function requireWMA () {
		if (hasRequiredWMA) return WMA;
		hasRequiredWMA = 1;

		Object.defineProperty(WMA, "__esModule", {
		  value: true
		});
		WMA.WMA = void 0;
		WMA.wma = wma;
		var _indicator = requireIndicator();
		var _LinkedList = requireLinkedList();
		let WMA$1 = class WMA extends _indicator.Indicator {
		  period;
		  price;
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    var period = input.period;
		    var priceArray = input.values;
		    this.result = [];
		    this.generator = function* () {
		      let data = new _LinkedList.LinkedList();
		      let denominator = period * (period + 1) / 2;
		      while (true) {
		        if (data.length < period) {
		          data.push(yield);
		        } else {
		          data.resetCursor();
		          let result = 0;
		          for (let i = 1; i <= period; i++) {
		            result = result + data.next() * i / denominator;
		          }
		          var next = yield result;
		          data.shift();
		          data.push(next);
		        }
		      }
		    }();
		    this.generator.next();
		    priceArray.forEach((tick, index) => {
		      var result = this.generator.next(tick);
		      if (result.value != undefined) {
		        this.result.push(this.format(result.value));
		      }
		    });
		  }
		  static calculate = wma;

		  //STEP 5. REMOVE GET RESULT FUNCTION
		  nextValue(price) {
		    var result = this.generator.next(price).value;
		    if (result != undefined) return this.format(result);
		  }
		};
		WMA.WMA = WMA$1;
		function wma(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new WMA$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return WMA;
	}

	var WEMA = {};

	var hasRequiredWEMA;

	function requireWEMA () {
		if (hasRequiredWEMA) return WEMA;
		hasRequiredWEMA = 1;

		Object.defineProperty(WEMA, "__esModule", {
		  value: true
		});
		WEMA.WEMA = void 0;
		WEMA.wema = wema;
		var _indicator = requireIndicator();
		var _SMA = requireSMA();
		let WEMA$1 = class WEMA extends _indicator.Indicator {
		  period;
		  price;
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    var period = input.period;
		    var priceArray = input.values;
		    var exponent = 1 / period;
		    var sma;
		    this.result = [];
		    sma = new _SMA.SMA({
		      period: period,
		      values: []
		    });
		    var genFn = function* () {
		      var tick = yield;
		      var prevEma;
		      while (true) {
		        if (prevEma !== undefined && tick !== undefined) {
		          prevEma = (tick - prevEma) * exponent + prevEma;
		          tick = yield prevEma;
		        } else {
		          tick = yield;
		          prevEma = sma.nextValue(tick);
		          if (prevEma !== undefined) tick = yield prevEma;
		        }
		      }
		    };
		    this.generator = genFn();
		    this.generator.next();
		    this.generator.next();
		    priceArray.forEach(tick => {
		      var result = this.generator.next(tick);
		      if (result.value != undefined) {
		        this.result.push(this.format(result.value));
		      }
		    });
		  }
		  static calculate = wema;
		  nextValue(price) {
		    var result = this.generator.next(price).value;
		    if (result != undefined) return this.format(result);
		  }
		};
		WEMA.WEMA = WEMA$1;
		function wema(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new WEMA$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return WEMA;
	}

	var MACD = {};

	var hasRequiredMACD;

	function requireMACD () {
		if (hasRequiredMACD) return MACD;
		hasRequiredMACD = 1;

		Object.defineProperty(MACD, "__esModule", {
		  value: true
		});
		MACD.MACDOutput = MACD.MACDInput = MACD.MACD = void 0;
		MACD.macd = macd;
		var _indicator = requireIndicator();
		var _SMA = requireSMA();
		var _EMA = requireEMA();
		/**
		 * Created by AAravindan on 5/4/16.
		 */

		class MACDInput extends _indicator.IndicatorInput {
		  SimpleMAOscillator = true;
		  SimpleMASignal = true;
		  fastPeriod;
		  slowPeriod;
		  signalPeriod;
		  constructor(values) {
		    super();
		    this.values = values;
		  }
		}
		MACD.MACDInput = MACDInput;
		class MACDOutput {
		  MACD;
		  signal;
		  histogram;
		}
		MACD.MACDOutput = MACDOutput;
		let MACD$1 = class MACD extends _indicator.Indicator {
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    var oscillatorMAtype = input.SimpleMAOscillator ? _SMA.SMA : _EMA.EMA;
		    var signalMAtype = input.SimpleMASignal ? _SMA.SMA : _EMA.EMA;
		    var fastMAProducer = new oscillatorMAtype({
		      period: input.fastPeriod,
		      values: [],
		      format: v => {
		        return v;
		      }
		    });
		    var slowMAProducer = new oscillatorMAtype({
		      period: input.slowPeriod,
		      values: [],
		      format: v => {
		        return v;
		      }
		    });
		    var signalMAProducer = new signalMAtype({
		      period: input.signalPeriod,
		      values: [],
		      format: v => {
		        return v;
		      }
		    });
		    var format = this.format;
		    this.result = [];
		    this.generator = function* () {
		      var index = 0;
		      var tick;
		      var MACD, signal, histogram, fast, slow;
		      while (true) {
		        if (index < input.slowPeriod) {
		          tick = yield;
		          fast = fastMAProducer.nextValue(tick);
		          slow = slowMAProducer.nextValue(tick);
		          index++;
		          continue;
		        }
		        if (fast && slow) {
		          //Just for typescript to be happy
		          MACD = fast - slow;
		          signal = signalMAProducer.nextValue(MACD);
		        }
		        histogram = MACD - signal;
		        tick = yield {
		          //fast : fast,
		          //slow : slow,
		          MACD: format(MACD),
		          signal: signal ? format(signal) : undefined,
		          histogram: isNaN(histogram) ? undefined : format(histogram)
		        };
		        fast = fastMAProducer.nextValue(tick);
		        slow = slowMAProducer.nextValue(tick);
		      }
		    }();
		    this.generator.next();
		    input.values.forEach(tick => {
		      var result = this.generator.next(tick);
		      if (result.value != undefined) {
		        this.result.push(result.value);
		      }
		    });
		  }
		  static calculate = macd;
		  nextValue(price) {
		    var result = this.generator.next(price).value;
		    return result;
		  }
		};
		MACD.MACD = MACD$1;
		function macd(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new MACD$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return MACD;
	}

	var RSI = {};

	var AverageGain = {};

	var hasRequiredAverageGain;

	function requireAverageGain () {
		if (hasRequiredAverageGain) return AverageGain;
		hasRequiredAverageGain = 1;

		Object.defineProperty(AverageGain, "__esModule", {
		  value: true
		});
		AverageGain.AvgGainInput = AverageGain.AverageGain = void 0;
		AverageGain.averagegain = averagegain;
		var _indicator = requireIndicator();
		class AvgGainInput extends _indicator.IndicatorInput {
		  period;
		  values;
		}
		AverageGain.AvgGainInput = AvgGainInput;
		let AverageGain$1 = class AverageGain extends _indicator.Indicator {
		  generator;
		  constructor(input) {
		    super(input);
		    let values = input.values;
		    let period = input.period;
		    let format = this.format;
		    this.generator = function* (period) {
		      var currentValue = yield;
		      var counter = 1;
		      var gainSum = 0;
		      var avgGain;
		      var gain;
		      var lastValue = currentValue;
		      currentValue = yield;
		      while (true) {
		        gain = currentValue - lastValue;
		        gain = gain > 0 ? gain : 0;
		        if (gain > 0) {
		          gainSum = gainSum + gain;
		        }
		        if (counter < period) {
		          counter++;
		        } else if (avgGain === undefined) {
		          avgGain = gainSum / period;
		        } else {
		          avgGain = (avgGain * (period - 1) + gain) / period;
		        }
		        lastValue = currentValue;
		        avgGain = avgGain !== undefined ? format(avgGain) : undefined;
		        currentValue = yield avgGain;
		      }
		    }(period);
		    this.generator.next();
		    this.result = [];
		    values.forEach(tick => {
		      var result = this.generator.next(tick);
		      if (result.value !== undefined) {
		        this.result.push(result.value);
		      }
		    });
		  }
		  static calculate = averagegain;
		  nextValue(price) {
		    return this.generator.next(price).value;
		  }
		};
		AverageGain.AverageGain = AverageGain$1;
		function averagegain(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new AverageGain$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return AverageGain;
	}

	var AverageLoss = {};

	var hasRequiredAverageLoss;

	function requireAverageLoss () {
		if (hasRequiredAverageLoss) return AverageLoss;
		hasRequiredAverageLoss = 1;

		Object.defineProperty(AverageLoss, "__esModule", {
		  value: true
		});
		AverageLoss.AvgLossInput = AverageLoss.AverageLoss = void 0;
		AverageLoss.averageloss = averageloss;
		var _indicator = requireIndicator();
		class AvgLossInput extends _indicator.IndicatorInput {
		  values;
		  period;
		}
		AverageLoss.AvgLossInput = AvgLossInput;
		let AverageLoss$1 = class AverageLoss extends _indicator.Indicator {
		  generator;
		  constructor(input) {
		    super(input);
		    let values = input.values;
		    let period = input.period;
		    let format = this.format;
		    this.generator = function* (period) {
		      var currentValue = yield;
		      var counter = 1;
		      var lossSum = 0;
		      var avgLoss;
		      var loss;
		      var lastValue = currentValue;
		      currentValue = yield;
		      while (true) {
		        loss = lastValue - currentValue;
		        loss = loss > 0 ? loss : 0;
		        if (loss > 0) {
		          lossSum = lossSum + loss;
		        }
		        if (counter < period) {
		          counter++;
		        } else if (avgLoss === undefined) {
		          avgLoss = lossSum / period;
		        } else {
		          avgLoss = (avgLoss * (period - 1) + loss) / period;
		        }
		        lastValue = currentValue;
		        avgLoss = avgLoss !== undefined ? format(avgLoss) : undefined;
		        currentValue = yield avgLoss;
		      }
		    }(period);
		    this.generator.next();
		    this.result = [];
		    values.forEach(tick => {
		      var result = this.generator.next(tick);
		      if (result.value !== undefined) {
		        this.result.push(result.value);
		      }
		    });
		  }
		  static calculate = averageloss;
		  nextValue(price) {
		    return this.generator.next(price).value;
		  }
		};
		AverageLoss.AverageLoss = AverageLoss$1;
		function averageloss(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new AverageLoss$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return AverageLoss;
	}

	var hasRequiredRSI;

	function requireRSI () {
		if (hasRequiredRSI) return RSI;
		hasRequiredRSI = 1;

		Object.defineProperty(RSI, "__esModule", {
		  value: true
		});
		RSI.RSIInput = RSI.RSI = void 0;
		RSI.rsi = rsi;
		var _indicator = requireIndicator();
		var _AverageGain = requireAverageGain();
		var _AverageLoss = requireAverageLoss();
		/**
		 * Created by AAravindan on 5/5/16.
		 */

		class RSIInput extends _indicator.IndicatorInput {
		  period;
		  values;
		}
		RSI.RSIInput = RSIInput;
		let RSI$1 = class RSI extends _indicator.Indicator {
		  generator;
		  constructor(input) {
		    super(input);
		    var period = input.period;
		    var values = input.values;
		    var GainProvider = new _AverageGain.AverageGain({
		      period: period,
		      values: []
		    });
		    var LossProvider = new _AverageLoss.AverageLoss({
		      period: period,
		      values: []
		    });
		    this.generator = function* (period) {
		      var current = yield;
		      var lastAvgGain, lastAvgLoss, RS, currentRSI;
		      while (true) {
		        lastAvgGain = GainProvider.nextValue(current);
		        lastAvgLoss = LossProvider.nextValue(current);
		        if (lastAvgGain !== undefined && lastAvgLoss !== undefined) {
		          if (lastAvgLoss === 0) {
		            currentRSI = 100;
		          } else if (lastAvgGain === 0) {
		            currentRSI = 0;
		          } else {
		            RS = lastAvgGain / lastAvgLoss;
		            RS = isNaN(RS) ? 0 : RS;
		            currentRSI = parseFloat((100 - 100 / (1 + RS)).toFixed(2));
		          }
		        }
		        current = yield currentRSI;
		      }
		    }();
		    this.generator.next();
		    this.result = [];
		    values.forEach(tick => {
		      var result = this.generator.next(tick);
		      if (result.value !== undefined) {
		        this.result.push(result.value);
		      }
		    });
		  }
		  static calculate = rsi;
		  nextValue(price) {
		    return this.generator.next(price).value;
		  }
		};
		RSI.RSI = RSI$1;
		function rsi(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new RSI$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return RSI;
	}

	var BollingerBands = {};

	var SD = {};

	var hasRequiredSD;

	function requireSD () {
		if (hasRequiredSD) return SD;
		hasRequiredSD = 1;

		var _interopRequireDefault = interopRequireDefaultExports;
		Object.defineProperty(SD, "__esModule", {
		  value: true
		});
		SD.SDInput = SD.SD = void 0;
		SD.sd = sd;
		var _indicator = requireIndicator();
		var _SMA = requireSMA();
		var _FixedSizeLinkedList = _interopRequireDefault(requireFixedSizeLinkedList());
		class SDInput extends _indicator.IndicatorInput {
		  period;
		  values;
		}
		SD.SDInput = SDInput;
		let SD$1 = class SD extends _indicator.Indicator {
		  generator;
		  constructor(input) {
		    super(input);
		    var period = input.period;
		    var priceArray = input.values;
		    var sma = new _SMA.SMA({
		      period: period,
		      values: [],
		      format: v => {
		        return v;
		      }
		    });
		    this.result = [];
		    this.generator = function* () {
		      var tick;
		      var mean;
		      var currentSet = new _FixedSizeLinkedList.default(period);
		      tick = yield;
		      var sd;
		      while (true) {
		        currentSet.push(tick);
		        mean = sma.nextValue(tick);
		        if (mean) {
		          let sum = 0;
		          for (let x of currentSet.iterator()) {
		            sum = sum + Math.pow(x - mean, 2);
		          }
		          sd = Math.sqrt(sum / period);
		        }
		        tick = yield sd;
		      }
		    }();
		    this.generator.next();
		    priceArray.forEach(tick => {
		      var result = this.generator.next(tick);
		      if (result.value != undefined) {
		        this.result.push(this.format(result.value));
		      }
		    });
		  }
		  static calculate = sd;
		  nextValue(price) {
		    var nextResult = this.generator.next(price);
		    if (nextResult.value != undefined) return this.format(nextResult.value);
		  }
		};
		SD.SD = SD$1;
		function sd(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new SD$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return SD;
	}

	var hasRequiredBollingerBands;

	function requireBollingerBands () {
		if (hasRequiredBollingerBands) return BollingerBands;
		hasRequiredBollingerBands = 1;

		Object.defineProperty(BollingerBands, "__esModule", {
		  value: true
		});
		BollingerBands.BollingerBandsOutput = BollingerBands.BollingerBandsInput = BollingerBands.BollingerBands = void 0;
		BollingerBands.bollingerbands = bollingerbands;
		var _indicator = requireIndicator();
		var _SMA = requireSMA();
		var _SD = requireSD();
		class BollingerBandsInput extends _indicator.IndicatorInput {
		  period;
		  stdDev;
		  values;
		}
		BollingerBands.BollingerBandsInput = BollingerBandsInput;
		class BollingerBandsOutput extends _indicator.IndicatorInput {
		  middle;
		  upper;
		  lower;
		  pb;
		}
		BollingerBands.BollingerBandsOutput = BollingerBandsOutput;
		let BollingerBands$1 = class BollingerBands extends _indicator.Indicator {
		  generator;
		  constructor(input) {
		    super(input);
		    var period = input.period;
		    var priceArray = input.values;
		    var stdDev = input.stdDev;
		    var format = this.format;
		    var sma, sd;
		    this.result = [];
		    sma = new _SMA.SMA({
		      period: period,
		      values: [],
		      format: v => {
		        return v;
		      }
		    });
		    sd = new _SD.SD({
		      period: period,
		      values: [],
		      format: v => {
		        return v;
		      }
		    });
		    this.generator = function* () {
		      var result;
		      var tick;
		      var calcSMA;
		      var calcsd;
		      tick = yield;
		      while (true) {
		        calcSMA = sma.nextValue(tick);
		        calcsd = sd.nextValue(tick);
		        if (calcSMA) {
		          let middle = format(calcSMA);
		          let upper = format(calcSMA + calcsd * stdDev);
		          let lower = format(calcSMA - calcsd * stdDev);
		          let pb = format((tick - lower) / (upper - lower));
		          result = {
		            middle: middle,
		            upper: upper,
		            lower: lower,
		            pb: pb
		          };
		        }
		        tick = yield result;
		      }
		    }();
		    this.generator.next();
		    priceArray.forEach(tick => {
		      var result = this.generator.next(tick);
		      if (result.value != undefined) {
		        this.result.push(result.value);
		      }
		    });
		  }
		  static calculate = bollingerbands;
		  nextValue(price) {
		    return this.generator.next(price).value;
		  }
		};
		BollingerBands.BollingerBands = BollingerBands$1;
		function bollingerbands(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new BollingerBands$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return BollingerBands;
	}

	var ADX = {};

	var WilderSmoothing = {};

	var hasRequiredWilderSmoothing;

	function requireWilderSmoothing () {
		if (hasRequiredWilderSmoothing) return WilderSmoothing;
		hasRequiredWilderSmoothing = 1;

		Object.defineProperty(WilderSmoothing, "__esModule", {
		  value: true
		});
		WilderSmoothing.WilderSmoothing = void 0;
		WilderSmoothing.wildersmoothing = wildersmoothing;
		var _indicator = requireIndicator();
		var _LinkedList = requireLinkedList();
		//STEP3. Add class based syntax with export
		let WilderSmoothing$1 = class WilderSmoothing extends _indicator.Indicator {
		  period;
		  price;
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    this.period = input.period;
		    this.price = input.values;
		    var genFn = function* (period) {
		      new _LinkedList.LinkedList();
		      var sum = 0;
		      var counter = 1;
		      var current = yield;
		      var result = 0;
		      while (true) {
		        if (counter < period) {
		          counter++;
		          sum = sum + current;
		          result = undefined;
		        } else if (counter == period) {
		          counter++;
		          sum = sum + current;
		          result = sum;
		        } else {
		          result = result - result / period + current;
		        }
		        current = yield result;
		      }
		    };
		    this.generator = genFn(this.period);
		    this.generator.next();
		    this.result = [];
		    this.price.forEach(tick => {
		      var result = this.generator.next(tick);
		      if (result.value != undefined) {
		        this.result.push(this.format(result.value));
		      }
		    });
		  }
		  static calculate = wildersmoothing;
		  nextValue(price) {
		    var result = this.generator.next(price).value;
		    if (result != undefined) return this.format(result);
		  }
		};
		WilderSmoothing.WilderSmoothing = WilderSmoothing$1;
		function wildersmoothing(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new WilderSmoothing$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}

		//STEP 6. Run the tests
		
		return WilderSmoothing;
	}

	var MinusDM = {};

	var hasRequiredMinusDM;

	function requireMinusDM () {
		if (hasRequiredMinusDM) return MinusDM;
		hasRequiredMinusDM = 1;

		Object.defineProperty(MinusDM, "__esModule", {
		  value: true
		});
		MinusDM.MDMInput = MinusDM.MDM = void 0;
		var _indicator = requireIndicator();
		class MDMInput extends _indicator.IndicatorInput {
		  low;
		  high;
		}
		MinusDM.MDMInput = MDMInput;
		class MDM extends _indicator.Indicator {
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    var lows = input.low;
		    var highs = input.high;
		    var format = this.format;
		    if (lows.length != highs.length) {
		      throw 'Inputs(low,high) not of equal size';
		    }
		    this.result = [];
		    this.generator = function* () {
		      var minusDm;
		      var current = yield;
		      var last;
		      while (true) {
		        if (last) {
		          let upMove = current.high - last.high;
		          let downMove = last.low - current.low;
		          minusDm = format(downMove > upMove && downMove > 0 ? downMove : 0);
		        }
		        last = current;
		        current = yield minusDm;
		      }
		    }();
		    this.generator.next();
		    lows.forEach((tick, index) => {
		      var result = this.generator.next({
		        high: highs[index],
		        low: lows[index]
		      });
		      if (result.value !== undefined) this.result.push(result.value);
		    });
		  }
		  static calculate(input) {
		    _indicator.Indicator.reverseInputs(input);
		    var result = new MDM(input).result;
		    if (input.reversedInput) {
		      result.reverse();
		    }
		    _indicator.Indicator.reverseInputs(input);
		    return result;
		  }
		  nextValue(price) {
		    return this.generator.next(price).value;
		  }
		}
		MinusDM.MDM = MDM;
		
		return MinusDM;
	}

	var PlusDM = {};

	var hasRequiredPlusDM;

	function requirePlusDM () {
		if (hasRequiredPlusDM) return PlusDM;
		hasRequiredPlusDM = 1;

		Object.defineProperty(PlusDM, "__esModule", {
		  value: true
		});
		PlusDM.PDMInput = PlusDM.PDM = void 0;
		var _indicator = requireIndicator();
		/**
		 * Created by AAravindan on 5/8/16.
		 */
		class PDMInput extends _indicator.IndicatorInput {
		  low;
		  high;
		}
		PlusDM.PDMInput = PDMInput;
		class PDM extends _indicator.Indicator {
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    var lows = input.low;
		    var highs = input.high;
		    var format = this.format;
		    if (lows.length != highs.length) {
		      throw 'Inputs(low,high) not of equal size';
		    }
		    this.result = [];
		    this.generator = function* () {
		      var plusDm;
		      var current = yield;
		      var last;
		      while (true) {
		        if (last) {
		          let upMove = current.high - last.high;
		          let downMove = last.low - current.low;
		          plusDm = format(upMove > downMove && upMove > 0 ? upMove : 0);
		        }
		        last = current;
		        current = yield plusDm;
		      }
		    }();
		    this.generator.next();
		    lows.forEach((tick, index) => {
		      var result = this.generator.next({
		        high: highs[index],
		        low: lows[index]
		      });
		      if (result.value !== undefined) this.result.push(result.value);
		    });
		  }
		  static calculate(input) {
		    _indicator.Indicator.reverseInputs(input);
		    var result = new PDM(input).result;
		    if (input.reversedInput) {
		      result.reverse();
		    }
		    _indicator.Indicator.reverseInputs(input);
		    return result;
		  }
		  nextValue(price) {
		    return this.generator.next(price).value;
		  }
		}
		PlusDM.PDM = PDM;
		
		return PlusDM;
	}

	var TrueRange = {};

	var hasRequiredTrueRange;

	function requireTrueRange () {
		if (hasRequiredTrueRange) return TrueRange;
		hasRequiredTrueRange = 1;

		Object.defineProperty(TrueRange, "__esModule", {
		  value: true
		});
		TrueRange.TrueRangeInput = TrueRange.TrueRange = void 0;
		TrueRange.truerange = truerange;
		var _indicator = requireIndicator();
		class TrueRangeInput extends _indicator.IndicatorInput {
		  low;
		  high;
		  close;
		}
		TrueRange.TrueRangeInput = TrueRangeInput;
		let TrueRange$1 = class TrueRange extends _indicator.Indicator {
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    var lows = input.low;
		    var highs = input.high;
		    var closes = input.close;
		    var format = this.format;
		    if (lows.length != highs.length) {
		      throw 'Inputs(low,high) not of equal size';
		    }
		    this.result = [];
		    this.generator = function* () {
		      var current = yield;
		      var previousClose, result;
		      while (true) {
		        if (previousClose === undefined) {
		          previousClose = current.close;
		          current = yield result;
		        }
		        result = Math.max(current.high - current.low, isNaN(Math.abs(current.high - previousClose)) ? 0 : Math.abs(current.high - previousClose), isNaN(Math.abs(current.low - previousClose)) ? 0 : Math.abs(current.low - previousClose));
		        previousClose = current.close;
		        if (result != undefined) {
		          result = format(result);
		        }
		        current = yield result;
		      }
		    }();
		    this.generator.next();
		    lows.forEach((tick, index) => {
		      var result = this.generator.next({
		        high: highs[index],
		        low: lows[index],
		        close: closes[index]
		      });
		      if (result.value != undefined) {
		        this.result.push(result.value);
		      }
		    });
		  }
		  static calculate = truerange;
		  nextValue(price) {
		    return this.generator.next(price).value;
		  }
		};
		TrueRange.TrueRange = TrueRange$1;
		function truerange(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new TrueRange$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return TrueRange;
	}

	var hasRequiredADX;

	function requireADX () {
		if (hasRequiredADX) return ADX;
		hasRequiredADX = 1;

		Object.defineProperty(ADX, "__esModule", {
		  value: true
		});
		ADX.ADXOutput = ADX.ADXInput = ADX.ADX = void 0;
		ADX.adx = adx;
		var _WilderSmoothing = requireWilderSmoothing();
		var _indicator = requireIndicator();
		var _MinusDM = requireMinusDM();
		var _PlusDM = requirePlusDM();
		var _TrueRange = requireTrueRange();
		var _WEMA = requireWEMA();
		class ADXInput extends _indicator.IndicatorInput {
		  high;
		  low;
		  close;
		  period;
		}
		ADX.ADXInput = ADXInput;
		class ADXOutput extends _indicator.IndicatorInput {
		  adx;
		  pdi;
		  mdi;
		}
		ADX.ADXOutput = ADXOutput;
		let ADX$1 = class ADX extends _indicator.Indicator {
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    var lows = input.low;
		    var highs = input.high;
		    var closes = input.close;
		    var period = input.period;
		    var format = this.format;
		    var plusDM = new _PlusDM.PDM({
		      high: [],
		      low: []
		    });
		    var minusDM = new _MinusDM.MDM({
		      high: [],
		      low: []
		    });
		    var emaPDM = new _WilderSmoothing.WilderSmoothing({
		      period: period,
		      values: [],
		      format: v => {
		        return v;
		      }
		    });
		    var emaMDM = new _WilderSmoothing.WilderSmoothing({
		      period: period,
		      values: [],
		      format: v => {
		        return v;
		      }
		    });
		    var emaTR = new _WilderSmoothing.WilderSmoothing({
		      period: period,
		      values: [],
		      format: v => {
		        return v;
		      }
		    });
		    var emaDX = new _WEMA.WEMA({
		      period: period,
		      values: [],
		      format: v => {
		        return v;
		      }
		    });
		    var tr = new _TrueRange.TrueRange({
		      low: [],
		      high: [],
		      close: []
		    });
		    if (!(lows.length === highs.length && highs.length === closes.length)) {
		      throw 'Inputs(low,high, close) not of equal size';
		    }
		    this.result = [];
		    this.generator = function* () {
		      var tick = yield;
		      var lastPDI, lastMDI, lastDX, smoothedDX;
		      while (true) {
		        let calcTr = tr.nextValue(tick);
		        let calcPDM = plusDM.nextValue(tick);
		        let calcMDM = minusDM.nextValue(tick);
		        if (calcTr === undefined) {
		          tick = yield;
		          continue;
		        }
		        let lastATR = emaTR.nextValue(calcTr);
		        let lastAPDM = emaPDM.nextValue(calcPDM);
		        let lastAMDM = emaMDM.nextValue(calcMDM);
		        if (lastATR != undefined && lastAPDM != undefined && lastAMDM != undefined) {
		          lastPDI = lastAPDM * 100 / lastATR;
		          lastMDI = lastAMDM * 100 / lastATR;
		          let diDiff = Math.abs(lastPDI - lastMDI);
		          let diSum = lastPDI + lastMDI;
		          lastDX = diDiff / diSum * 100;
		          smoothedDX = emaDX.nextValue(lastDX);
		          // console.log(tick.high.toFixed(2), tick.low.toFixed(2), tick.close.toFixed(2) , calcTr.toFixed(2), calcPDM.toFixed(2), calcMDM.toFixed(2), lastATR.toFixed(2), lastAPDM.toFixed(2), lastAMDM.toFixed(2), lastPDI.toFixed(2), lastMDI.toFixed(2), diDiff.toFixed(2), diSum.toFixed(2), lastDX.toFixed(2));
		        }
		        tick = yield {
		          adx: smoothedDX,
		          pdi: lastPDI,
		          mdi: lastMDI
		        };
		      }
		    }();
		    this.generator.next();
		    lows.forEach((tick, index) => {
		      var result = this.generator.next({
		        high: highs[index],
		        low: lows[index],
		        close: closes[index]
		      });
		      if (result.value != undefined && result.value.adx != undefined) {
		        this.result.push({
		          adx: format(result.value.adx),
		          pdi: format(result.value.pdi),
		          mdi: format(result.value.mdi)
		        });
		      }
		    });
		  }
		  static calculate = adx;
		  nextValue(price) {
		    let result = this.generator.next(price).value;
		    if (result != undefined && result.adx != undefined) {
		      return {
		        adx: this.format(result.adx),
		        pdi: this.format(result.pdi),
		        mdi: this.format(result.mdi)
		      };
		    }
		  }
		};
		ADX.ADX = ADX$1;
		function adx(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new ADX$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return ADX;
	}

	var ATR = {};

	var hasRequiredATR;

	function requireATR () {
		if (hasRequiredATR) return ATR;
		hasRequiredATR = 1;

		Object.defineProperty(ATR, "__esModule", {
		  value: true
		});
		ATR.ATRInput = ATR.ATR = void 0;
		ATR.atr = atr;
		var _indicator = requireIndicator();
		var _WEMA = requireWEMA();
		var _TrueRange = requireTrueRange();
		class ATRInput extends _indicator.IndicatorInput {
		  low;
		  high;
		  close;
		  period;
		}
		ATR.ATRInput = ATRInput;
		let ATR$1 = class ATR extends _indicator.Indicator {
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    var lows = input.low;
		    var highs = input.high;
		    var closes = input.close;
		    var period = input.period;
		    var format = this.format;
		    if (!(lows.length === highs.length && highs.length === closes.length)) {
		      throw 'Inputs(low,high, close) not of equal size';
		    }
		    var trueRange = new _TrueRange.TrueRange({
		      low: [],
		      high: [],
		      close: []
		    });
		    var wema = new _WEMA.WEMA({
		      period: period,
		      values: [],
		      format: v => {
		        return v;
		      }
		    });
		    this.result = [];
		    this.generator = function* () {
		      var tick = yield;
		      var avgTrueRange, trange;
		      while (true) {
		        trange = trueRange.nextValue({
		          low: tick.low,
		          high: tick.high,
		          close: tick.close
		        });
		        if (trange === undefined) {
		          avgTrueRange = undefined;
		        } else {
		          avgTrueRange = wema.nextValue(trange);
		        }
		        tick = yield avgTrueRange;
		      }
		    }();
		    this.generator.next();
		    lows.forEach((tick, index) => {
		      var result = this.generator.next({
		        high: highs[index],
		        low: lows[index],
		        close: closes[index]
		      });
		      if (result.value !== undefined) {
		        this.result.push(format(result.value));
		      }
		    });
		  }
		  static calculate = atr;
		  nextValue(price) {
		    return this.generator.next(price).value;
		  }
		};
		ATR.ATR = ATR$1;
		function atr(input) {
		  _indicator.Indicator.reverseInputs(input);
		  var result = new ATR$1(input).result;
		  if (input.reversedInput) {
		    result.reverse();
		  }
		  _indicator.Indicator.reverseInputs(input);
		  return result;
		}
		
		return ATR;
	}

	var ROC = {};

	var hasRequiredROC;

	function requireROC () {
		if (hasRequiredROC) return ROC;
		hasRequiredROC = 1;

		var _interopRequireDefault = interopRequireDefaultExports;
		Object.defineProperty(ROC, "__esModule", {
		  value: true
		});
		ROC.ROCInput = ROC.ROC = void 0;
		ROC.roc = roc;
		var _indicator = requireIndicator();
		var _FixedSizeLinkedList = _interopRequireDefault(requireFixedSizeLinkedList());
		class ROCInput extends _indicator.IndicatorInput {
		  period;
		  values;
		}
		ROC.ROCInput = ROCInput;
		let ROC$1 = class ROC extends _indicator.Indicator {
		  result;
		  generator;
		  constructor(input) {
		    super(input);
		    var period = input.period;
		    var priceArray = input.values;
		    this.result = [];
		    this.generator = function* () {
		      let index = 1;
		      var pastPeriods = new _FixedSizeLinkedList.default(period);
		      var tick = yield;
		      var roc;
		      while (true) {
		        pastPeriods.push(tick);
		        if (index < period) {
		          index++;
		        } else {
		          roc = (tick - pastPeriods.lastShift) / pastPeriods.lastShift * 100;
		        }
		        tick = yield roc;
		      }
		    }();
		    this.generator.next();
		    priceArray