@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/financial/RelativeStrengthRotation.js

@@ -0,0 +1,434 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { ChartFamily, CurveKind, DataShape, Dimension } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { FinanceInk } from "./FinanceInk.js";
+import { Quotes } from "./Quotes.js";
+import { RelativeStrengthRotationMath, RotationFrame, RotationMethod, RotationQuadrant } from "./RelativeStrengthRotationMath.js";
+import { RelativeStrengthRotationSamples } from "./RelativeStrengthRotationSamples.js";
+import { format, group, line, precisionFixed, scaleLinear, tickStep } from "d3";
+// src/charts/financial/RelativeStrengthRotation.ts
+var CENTER = 100;
+var PAD = 1.12;
+var HEAD = 6;
+var NODE = 4;
+var LABEL_CHARS = 12;
+var CHAR = 6.2;
+/** Polarity of each quadrant: the sign is which side of the benchmark it is on, the size whether momentum agrees. The warm pole is the weak side. */
+var TINT = {
+	[RotationQuadrant.Leading]: -.9,
+	[RotationQuadrant.Weakening]: -.35,
+	[RotationQuadrant.Improving]: .35,
+	[RotationQuadrant.Lagging]: .9
+};
+var dayLabel = (value, when) => when ? when.toISOString().slice(0, 10) : String(value ?? "");
+var shorten = (text, chars) => text.length > chars ? `${text.slice(0, Math.max(1, chars - 1))}…` : text;
+var wholeAtLeast = (value, floor, fallback) => Number.isFinite(value) ? Math.max(floor, Math.round(value)) : fallback;
+var overlaps = (a, b) => a.left < b.right && b.left < a.right && a.top < b.bottom && b.top < a.bottom;
+/**
+* Relative strength rotation: use it to compare many symbols against one benchmark and see which are
+* rotating through Leading, Weakening, Lagging and Improving, normally clockwise.
+*
+* Method: Julius de Kempenaer's RRG, whose JdK RS-Ratio and RS-Momentum formulas are proprietary and
+* unpublished, so computed values are an approximation and will not match licensed RRG software.
+* With relative strength `RS = 100 * price / benchmark`:
+* - `RotationMethod.ZScore`, the rolling z-score recipe circulated in public reimplementations:
+*   `ratio = 100 + z(RS, window)`, `momentum = 100 + z(ROC(ratio, lookback), window)`.
+* - `RotationMethod.RatioToAverage`, after Mansfield relative strength as in Weinstein (1988):
+*   `ratio = 100 * RS / SMA(RS, window)`, `momentum = 100 + ROC(ratio, lookback)`.
+* RS first passes through `EMA(RS, smoothing)`, 5 by default, because RRG tails are known to be smoothed
+* and an unsmoothed z-score scribbles on real prices. That default is this library's choice; 1 turns it off.
+* Supply `ratio` and `momentum` columns to draw licensed or other values unchanged.
+*/
+var RelativeStrengthRotation = class RelativeStrengthRotation extends CartesianChart {
+	static meta = {
+		id: "relative-strength-rotation",
+		name: "Relative strength rotation",
+		family: ChartFamily.Financial,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Tracks symbols against a benchmark through the Leading, Weakening, Lagging and Improving quadrants, using a documented approximation of the proprietary JdK RS-Ratio and RS-Momentum, or values you supply.",
+		tags: [
+			"rrg",
+			"rs-ratio",
+			"rs-momentum",
+			"sector rotation",
+			"relative strength",
+			"momentum",
+			"benchmark"
+		],
+		sample: (seed) => RelativeStrengthRotationSamples.prices(seed),
+		variants: {
+			method: [RotationMethod.ZScore, RotationMethod.RatioToAverage],
+			tail: [
+				10,
+				5,
+				20
+			],
+			curve: [CurveKind.Linear, CurveKind.CatmullRom],
+			frame: [RotationFrame.Centered, RotationFrame.Fitted],
+			nodes: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			date: "date",
+			series: "series",
+			close: "close",
+			benchmark: "benchmark",
+			ratio: "rsRatio",
+			momentum: "rsMomentum",
+			method: RotationMethod.ZScore,
+			window: 14,
+			lookback: 1,
+			smoothing: 5,
+			tail: 10,
+			curve: CurveKind.Linear,
+			frame: RotationFrame.Centered,
+			nodes: true,
+			xLabel: "RS-Ratio",
+			yLabel: "RS-Momentum"
+		};
+	}
+	get settings() {
+		const { method, window, lookback, smoothing } = this.options;
+		return {
+			method,
+			window: wholeAtLeast(window, 2, 14),
+			lookback: wholeAtLeast(lookback, 1, 1),
+			smoothing: wholeAtLeast(smoothing, 1, 5)
+		};
+	}
+	rows() {
+		const { data, date, series, close, benchmark, ratio, momentum } = this.options;
+		return (Array.isArray(data) ? data : []).filter((row) => row !== null && typeof row === "object").map((row, i) => {
+			const when = Quotes.date(row[date]);
+			const rsRatio = Quotes.number(row[ratio]), rsMomentum = Quotes.number(row[momentum]);
+			return {
+				name: String(row[series] ?? "Symbol"),
+				time: when?.getTime() ?? i,
+				label: dayLabel(row[date], when),
+				close: Quotes.number(row[close]),
+				base: Quotes.number(row[benchmark]),
+				given: Number.isFinite(rsRatio) && Number.isFinite(rsMomentum) ? {
+					ratio: rsRatio,
+					momentum: rsMomentum
+				} : null
+			};
+		});
+	}
+	/** Oldest first, one row per bar, with the last duplicate winning. */
+	static ordered(rows) {
+		return [...new Map(rows.map((row) => [row.time, row]))].sort((a, b) => a[0] - b[0]).map(([, row]) => row);
+	}
+	computed(rows, indexPrices) {
+		const priced = rows.flatMap((row) => {
+			const base = indexPrices.get(row.time) ?? row.base;
+			return row.close > 0 && base > 0 && Number.isFinite(row.close) && Number.isFinite(base) ? [{
+				row,
+				base
+			}] : [];
+		});
+		const points = RelativeStrengthRotationMath.rotation(priced.map(({ row }) => row.close), priced.map(({ base }) => base), this.settings);
+		return priced.map(({ row }, i) => ({
+			row,
+			point: points[i]
+		}));
+	}
+	/** Every symbol's whole path. Supplied values win over prices, symbol by symbol. */
+	reading() {
+		const { benchmarkSymbol } = this.options;
+		const rows = this.rows();
+		const indexPrices = new Map(rows.filter((row) => row.name === benchmarkSymbol && row.close > 0 && Number.isFinite(row.close)).map((row) => [row.time, row.close]));
+		const trails = [], skipped = [];
+		for (const [name, own] of group(rows.filter((row) => row.name !== benchmarkSymbol), (row) => row.name)) {
+			const ordered = RelativeStrengthRotation.ordered(own);
+			const given = ordered.filter((row) => row.given);
+			const stops = (given.length ? given.map((row) => ({
+				row,
+				point: row.given
+			})) : this.computed(ordered, indexPrices)).flatMap(({ row, point }) => point ? [{
+				...point,
+				series: name,
+				when: row.label,
+				quadrant: RelativeStrengthRotationMath.quadrant(point),
+				age: 0
+			}] : []);
+			if (stops.length) trails.push({
+				name,
+				stops
+			});
+			else skipped.push(name);
+		}
+		return {
+			trails,
+			skipped
+		};
+	}
+	/** The head and `tail` bars behind it, with `age` counting back from the head. */
+	recent(trail) {
+		const stops = trail.stops.slice(-(wholeAtLeast(this.options.tail, 0, 10) + 1));
+		return {
+			name: trail.name,
+			stops: stops.map((stop, i) => ({
+				...stop,
+				age: stops.length - 1 - i
+			}))
+		};
+	}
+	domain(values) {
+		const low = Math.min(CENTER, ...values), high = Math.max(CENTER, ...values);
+		if (low === high) return [99, 101];
+		if (this.options.frame === RotationFrame.Fitted) {
+			const pad = (high - low) * .1200000000000001;
+			return [low - pad, high + pad];
+		}
+		const reach = Math.max(CENTER - low, high - CENTER) * PAD;
+		return [CENTER - reach, CENTER + reach];
+	}
+	scales(ctx) {
+		const { trails, skipped } = this.reading();
+		const shown = trails.map((trail) => this.recent(trail));
+		const stops = shown.flatMap((trail) => trail.stops);
+		const x = scaleLinear(this.domain(stops.map((stop) => stop.ratio)), [0, ctx.plot.width]);
+		const y = scaleLinear(this.domain(stops.map((stop) => stop.momentum)), [ctx.plot.height, 0]);
+		if (this.options.frame !== RotationFrame.Fitted) {
+			x.nice(this.xTicks());
+			y.nice(this.yTicks());
+		}
+		return {
+			x,
+			y,
+			shown,
+			skipped
+		};
+	}
+	/** Readings sit a fraction either side of 100, so ticks take the decimals their spacing needs. */
+	tickFormat(scale) {
+		const [low, high] = scale.domain();
+		const print = format(`.${precisionFixed(tickStep(low, high, this.yTicks()))}f`);
+		return (value) => print(+value);
+	}
+	plotMarks(ctx, axes) {
+		const { x, y, shown } = axes;
+		this.drawQuadrants(ctx, axes);
+		const color = (name) => ctx.palette.color(name);
+		const path = line().curve(Scales.curve(this.options.curve)).x((stop) => x(stop.ratio)).y((stop) => y(stop.momentum));
+		const tails = ctx.marks("tails", "path", shown.filter((trail) => trail.stops.length > 1), (trail) => trail.name).attr("fill", "none").attr("stroke", (trail) => color(trail.name)).attr("stroke-width", 2).attr("stroke-linejoin", "round").attr("stroke-linecap", "round");
+		ctx.set(tails, { d: (trail) => path(trail.stops) ?? "" }, { d: (trail) => path(trail.stops) ?? "" });
+		ctx.drawOn(tails);
+		const last = wholeAtLeast(this.options.tail, 1, 10);
+		const stops = shown.flatMap((trail) => this.options.nodes ? trail.stops : trail.stops.slice(-1));
+		const dots = ctx.marks("dots", "circle", stops, (stop) => `${stop.series}/${stop.age}`).attr("fill", (stop) => color(stop.series)).attr("stroke", ctx.theme.surface).attr("stroke-width", 2).attr("opacity", (stop) => 1 - .6 * stop.age / last);
+		const place = {
+			cx: (stop) => x(stop.ratio),
+			cy: (stop) => y(stop.momentum)
+		};
+		ctx.set(dots, {
+			...place,
+			r: (stop) => stop.age ? NODE : HEAD
+		}, {
+			...place,
+			r: 0
+		}, 6);
+		ctx.hover(dots, (stop) => this.tipFor(stop));
+		this.drawLabels(ctx, axes);
+		this.drawNotice(ctx, axes);
+	}
+	tipFor(stop) {
+		return {
+			title: stop.when ? `${stop.series}, ${stop.when}` : stop.series,
+			color: this.palette.color(stop.series),
+			rows: [
+				["RS-Ratio", stop.ratio.toFixed(2)],
+				["RS-Momentum", stop.momentum.toFixed(2)],
+				["Quadrant", stop.quadrant]
+			]
+		};
+	}
+	drawQuadrants(ctx, { x, y }) {
+		const { width, height } = ctx.plot;
+		const left = Math.max(0, Math.min(width, x(CENTER))), top = Math.max(0, Math.min(height, y(CENTER)));
+		const areas = [
+			{
+				name: RotationQuadrant.Improving,
+				x: 0,
+				y: 0,
+				width: left,
+				height: top,
+				anchor: "start",
+				textX: 6,
+				textY: 14
+			},
+			{
+				name: RotationQuadrant.Leading,
+				x: left,
+				y: 0,
+				width: width - left,
+				height: top,
+				anchor: "end",
+				textX: width - 6,
+				textY: 14
+			},
+			{
+				name: RotationQuadrant.Lagging,
+				x: 0,
+				y: top,
+				width: left,
+				height: height - top,
+				anchor: "start",
+				textX: 6,
+				textY: height - 6
+			},
+			{
+				name: RotationQuadrant.Weakening,
+				x: left,
+				y: top,
+				width: width - left,
+				height: height - top,
+				anchor: "end",
+				textX: width - 6,
+				textY: height - 6
+			}
+		];
+		const tiles = ctx.marks("quadrants", "rect", areas, (area) => area.name).attr("fill", (area) => ctx.palette.diverging(TINT[area.name])).attr("fill-opacity", .1);
+		ctx.set(tiles, {
+			x: (area) => area.x,
+			y: (area) => area.y,
+			width: (area) => area.width,
+			height: (area) => area.height
+		});
+		FinanceInk.note(ctx, "quadrant-labels", areas.filter((area) => area.width >= area.name.length * CHAR + 12 && area.height >= 20), (area) => ({
+			x: area.textX,
+			y: area.textY,
+			text: area.name,
+			anchor: area.anchor
+		}), 11, "muted");
+		const axisLines = [...x(CENTER) >= 0 && x(CENTER) <= width ? [{
+			key: "x",
+			x1: left,
+			x2: left,
+			y1: 0,
+			y2: height
+		}] : [], ...y(CENTER) >= 0 && y(CENTER) <= height ? [{
+			key: "y",
+			x1: 0,
+			x2: width,
+			y1: top,
+			y2: top
+		}] : []];
+		const rules = ctx.marks("center", "line", axisLines, (rule) => rule.key).attr("stroke", ctx.theme.axis).attr("stroke-width", 1);
+		ctx.set(rules, {
+			x1: (rule) => rule.x1,
+			x2: (rule) => rule.x2,
+			y1: (rule) => rule.y1,
+			y2: (rule) => rule.y2
+		});
+	}
+	/** Names sit beside their heads, on the first free side; a name with no room is left to the legend and tooltip. */
+	drawLabels(ctx, { x, y, shown }) {
+		const { width, height } = ctx.plot;
+		const heads = shown.flatMap((trail) => {
+			const head = trail.stops.at(-1);
+			const px = x(head.ratio), py = y(head.momentum);
+			return px >= 0 && px <= width && py >= 0 && py <= height ? [{
+				text: shorten(trail.name, LABEL_CHARS),
+				px,
+				py
+			}] : [];
+		});
+		const taken = heads.map(({ px, py }) => ({
+			left: px - HEAD,
+			right: px + HEAD,
+			top: py - HEAD,
+			bottom: py + HEAD
+		}));
+		const labels = heads.flatMap(({ text, px, py }) => {
+			const wide = text.length * CHAR, gap = 9;
+			const spot = [
+				{
+					x: px + gap,
+					y: py + 4,
+					anchor: "start",
+					box: {
+						left: px + gap,
+						right: px + gap + wide,
+						top: py - 7,
+						bottom: py + 7
+					}
+				},
+				{
+					x: px - gap,
+					y: py + 4,
+					anchor: "end",
+					box: {
+						left: px - gap - wide,
+						right: px - gap,
+						top: py - 7,
+						bottom: py + 7
+					}
+				},
+				{
+					x: px,
+					y: py - gap - 2,
+					anchor: "middle",
+					box: {
+						left: px - wide / 2,
+						right: px + wide / 2,
+						top: py - gap - 12,
+						bottom: py - gap + 2
+					}
+				},
+				{
+					x: px,
+					y: py + gap + 10,
+					anchor: "middle",
+					box: {
+						left: px - wide / 2,
+						right: px + wide / 2,
+						top: py + gap - 2,
+						bottom: py + gap + 12
+					}
+				}
+			].find(({ box }) => box.left >= 0 && box.right <= width && box.top >= 0 && box.bottom <= height && !taken.some((other) => overlaps(box, other)));
+			if (!spot) return [];
+			taken.push(spot.box);
+			return [{
+				text,
+				...spot
+			}];
+		});
+		FinanceInk.note(ctx, "head-labels", labels, (label) => label, 11, "ink");
+	}
+	/** A symbol without enough bars has no position, so the chart says so rather than losing it quietly. */
+	drawNotice(ctx, { shown, skipped }) {
+		const { width, height } = ctx.plot;
+		const need = `${RelativeStrengthRotationMath.required(this.settings)} bars`;
+		const text = !skipped.length ? null : shown.length ? `Too short, needs ${need}: ${skipped.join(", ")}` : `Each symbol needs ${need}`;
+		FinanceInk.note(ctx, "notice", text ? [shorten(text, Math.floor((width - 200) / CHAR))] : [], (note) => ({
+			x: width / 2,
+			y: height - 6,
+			text: note,
+			anchor: "middle"
+		}), 11, "secondary");
+	}
+	/** Exports the computed positions, not the prices that went in. */
+	table() {
+		return {
+			columns: [
+				"series",
+				"date",
+				"rsRatio",
+				"rsMomentum",
+				"quadrant"
+			],
+			rows: this.reading().trails.flatMap((trail) => trail.stops.map((stop) => [
+				stop.series,
+				stop.when,
+				+stop.ratio.toFixed(4),
+				+stop.momentum.toFixed(4),
+				stop.quadrant
+			]))
+		};
+	}
+};
+export { RelativeStrengthRotation };

package/dist/charts/financial/RelativeStrengthRotationMath.js

@@ -0,0 +1,71 @@
+import { FinanceMath } from "./FinanceMath.js";
+// src/charts/financial/RelativeStrengthRotationMath.ts
+/** How price and benchmark become the two rotation axes. Both are public approximations: the JdK formula is proprietary. */
+var RotationMethod = /* @__PURE__ */ function(RotationMethod) {
+	RotationMethod["ZScore"] = "z-score";
+	RotationMethod["RatioToAverage"] = "ratio-to-average";
+	return RotationMethod;
+}({});
+var RotationQuadrant = /* @__PURE__ */ function(RotationQuadrant) {
+	RotationQuadrant["Leading"] = "Leading";
+	RotationQuadrant["Weakening"] = "Weakening";
+	RotationQuadrant["Lagging"] = "Lagging";
+	RotationQuadrant["Improving"] = "Improving";
+	return RotationQuadrant;
+}({});
+/** `Centered` keeps 100,100 mid-plot, the customary framing. `Fitted` follows the data but always holds 100,100. */
+var RotationFrame = /* @__PURE__ */ function(RotationFrame) {
+	RotationFrame["Centered"] = "centered";
+	RotationFrame["Fitted"] = "fitted";
+	return RotationFrame;
+}({});
+/** Below this share of the mean, a rolling deviation is rounding error rather than movement. */
+var FLAT = 1e-12;
+/** Pure maths behind the relative rotation graph; everything is centred on 100. */
+var RelativeStrengthRotationMath = class {
+	static relativeStrength(prices, benchmark) {
+		return prices.map((price, i) => 100 * price / benchmark[i]);
+	}
+	/** Rolling population z-score, `(value - mean) / deviation`. A flat window scores 0. */
+	static zScore(values, window) {
+		const means = FinanceMath.sma(values, window), spreads = FinanceMath.stdev(values, window);
+		return values.map((value, i) => {
+			const mean = means[i], spread = spreads[i];
+			if (value === null || mean == null || spread == null) return null;
+			return spread <= Math.abs(mean) * FLAT ? 0 : (value - mean) / spread;
+		});
+	}
+	/** Percent change over `lookback` bars. */
+	static rateOfChange(values, lookback) {
+		return values.map((value, i) => {
+			const before = values[i - lookback];
+			return value === null || before == null || before === 0 ? null : 100 * (value / before - 1);
+		});
+	}
+	/** Each aligned bar's position, or null while the rolling windows fill. */
+	static rotation(prices, benchmark, { method, window, lookback, smoothing }) {
+		const strength = FinanceMath.ema(this.relativeStrength(prices, benchmark), smoothing);
+		const zScore = method === "z-score";
+		const averages = FinanceMath.sma(strength, window);
+		const ratios = zScore ? this.zScore(strength, window).map((z) => z === null ? null : 100 + z) : strength.map((value, i) => value === null || !averages[i] ? null : 100 * value / averages[i]);
+		const change = this.rateOfChange(ratios, lookback);
+		const momenta = zScore ? this.zScore(change, window) : change;
+		return ratios.map((ratio, i) => {
+			const momentum = momenta[i];
+			return ratio === null || momentum == null ? null : {
+				ratio,
+				momentum: 100 + momentum
+			};
+		});
+	}
+	/** Bars a series needs before its first point appears. */
+	static required({ method, window, lookback, smoothing }) {
+		return smoothing - 1 + window + lookback + (method === "z-score" ? window - 1 : 0);
+	}
+	/** Clockwise from top right. A point exactly on 100 counts as the stronger side. */
+	static quadrant({ ratio, momentum }) {
+		if (ratio >= 100) return momentum >= 100 ? "Leading" : "Weakening";
+		return momentum >= 100 ? "Improving" : "Lagging";
+	}
+};
+export { RelativeStrengthRotationMath, RotationFrame, RotationMethod, RotationQuadrant };

package/dist/charts/financial/RelativeStrengthRotationSamples.js

@@ -0,0 +1,27 @@
+import { SampleData } from "../../data/SampleData.js";
+// src/charts/financial/RelativeStrengthRotationSamples.ts
+var BARS = 90;
+var SYMBOLS = 6;
+/** Synthetic prices only: seeded sine waves of relative strength over a seeded walk. Not market data. */
+var RelativeStrengthRotationSamples = class {
+	/** `{ date, series, close, benchmark }`, long form, with every symbol cycling around the benchmark at its own pace. */
+	static prices(seed) {
+		const benchmark = SampleData.ohlc(seed, BARS);
+		const noise = SampleData.timeSeries(seed, BARS, SYMBOLS);
+		return noise.map((row, i) => {
+			const bar = i % BARS, symbol = Math.floor(i / BARS);
+			const period = 42 + symbol * 5, phase = symbol * 2.1 + seed;
+			const previous = bar ? Number(noise[i - 1].value) : Number(row.value);
+			const wobble = (Number(row.value) - previous) * 6e-4;
+			const strength = Math.exp(.05 * Math.sin(2 * Math.PI * bar / period + phase) + wobble);
+			const index = Number(benchmark[bar].close);
+			return {
+				date: row.date,
+				series: row.series,
+				close: +(index * strength * (1 + symbol * .2)).toFixed(3),
+				benchmark: index
+			};
+		});
+	}
+};
+export { RelativeStrengthRotationSamples };

package/dist/charts/financial/RenkoChart.js

@@ -0,0 +1,58 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { BoxMethod, PriceSource } from "./financeEnums.js";
+import { BrickChart } from "./BrickChart.js";
+import { FinanceMath } from "./FinanceMath.js";
+import { PriceMarks } from "./PriceMarks.js";
+import { PriceTransforms } from "./PriceTransforms.js";
+// src/charts/financial/RenkoChart.ts
+/** Equal bricks printed only when price moves a set amount: use it to read trend and levels with time removed. */
+var RenkoChart = class extends BrickChart {
+	static meta = {
+		id: "renko",
+		name: "Renko chart",
+		family: ChartFamily.Financial,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Stacks fixed-size bricks as price moves, stripping out time and small fluctuations to expose trend.",
+		tags: [
+			"bricks",
+			"price action",
+			"atr"
+		],
+		sample: (seed) => SampleData.ohlc(seed, 240),
+		variants: {
+			method: [
+				BoxMethod.ATR,
+				BoxMethod.Range,
+				BoxMethod.Percent
+			],
+			source: [PriceSource.Close, PriceSource.HighLow],
+			reversal: [
+				2,
+				1,
+				3
+			],
+			wicks: [false, true],
+			average: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			reversal: 2,
+			wicks: false,
+			average: false
+		};
+	}
+	construct(bars, box) {
+		return PriceTransforms.renko(bars, box, this.options.reversal, this.options.source).map((brick) => this.column(brick.index, brick.up ? brick.bottom : brick.top, brick.up ? brick.top : brick.bottom, brick.bar, this.options.wicks ? brick.wick : void 0));
+	}
+	columnMarks(ctx, view, tones) {
+		PriceMarks.candles(ctx, view, tones, view.bars, { wicks: this.options.wicks });
+		const closes = view.bars.map((bar) => bar.close);
+		const window = Math.min(10, Math.max(2, Math.floor(closes.length / 4)));
+		PriceMarks.line(ctx, view, "brick-average", this.options.average ? FinanceMath.ema(closes, window) : [], ctx.palette.color(this.options.average ? `EMA ${window}` : "Up"));
+	}
+};
+export { RenkoChart };