@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/financial/PointFigureChart.js

@@ -0,0 +1,135 @@
+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 { FinanceInk } from "./FinanceInk.js";
+import { PriceTransforms } from "./PriceTransforms.js";
+// src/charts/financial/PointFigureChart.ts
+/** Columns of X and O on a price grid: use it to read breakouts, support and price targets without time. */
+var PointFigureChart = class extends BrickChart {
+	static meta = {
+		id: "point-figure",
+		name: "Point and figure chart",
+		family: ChartFamily.Financial,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Records only meaningful moves as columns of X and O on a box grid, making breakouts and targets explicit.",
+		tags: [
+			"p&f",
+			"x and o",
+			"box",
+			"reversal"
+		],
+		sample: (seed) => SampleData.ohlc(seed, 240),
+		variants: {
+			method: [
+				BoxMethod.ATR,
+				BoxMethod.Range,
+				BoxMethod.Percent
+			],
+			reversal: [
+				3,
+				2,
+				1
+			],
+			source: [PriceSource.Close, PriceSource.HighLow],
+			trendlines: [false, true],
+			paper: [true, false]
+		}
+	};
+	columns = [];
+	unit = 0;
+	defaults() {
+		return {
+			...super.defaults(),
+			multiple: .6,
+			reversal: 3,
+			trendlines: false,
+			paper: true
+		};
+	}
+	construct(bars, box) {
+		this.unit = box;
+		this.columns = PriceTransforms.pointFigure(bars, box, this.options.reversal, this.options.source);
+		return this.columns.map((column) => {
+			const low = (column.low - .5) * box, high = (column.high + .5) * box;
+			return this.column(column.index, column.rising ? low : high, column.rising ? high : low, column.bar);
+		});
+	}
+	columnMarks(ctx, view, tones) {
+		const { x, y, step } = view;
+		const box = this.unit;
+		const level = (k) => y(k * box);
+		const cell = box ? Math.abs(level(1) - level(0)) : 0;
+		const half = Math.max(1, Math.min(step, cell) / 2 - 1);
+		const cells = this.columns.flatMap((column) => Array.from({ length: column.high - column.low + 1 }, (_, i) => ({
+			column: column.index,
+			level: column.low + i,
+			rising: column.rising
+		})));
+		const key = (mark) => `${mark.column}/${mark.level}`;
+		const [floor, ceiling] = view.y.domain();
+		const first = box ? Math.ceil(floor / box) : 0, boxes = box ? Math.floor(ceiling / box) - first + 1 : 0;
+		const every = cell >= 7 ? 1 : 5;
+		const levels = this.options.paper && box ? Array.from({ length: boxes }, (_, i) => first + i).filter((k) => k % every === 0) : [];
+		ctx.marks("paper", "line", levels).attr("stroke", ctx.theme.grid).attr("stroke-width", 1).attr("x1", 0).attr("x2", ctx.plot.width).attr("y1", level).attr("y2", level);
+		const crosses = ctx.marks("xs", "path", cells.filter((mark) => mark.rising), key).attr("fill", "none").attr("stroke", tones.up).attr("stroke-width", 1.5).attr("stroke-linecap", "round");
+		const cross = (mark, r) => {
+			const cx = x(mark.column), cy = level(mark.level);
+			return `M${cx - r},${cy - r}L${cx + r},${cy + r}M${cx + r},${cy - r}L${cx - r},${cy + r}`;
+		};
+		ctx.set(crosses, { d: (mark) => cross(mark, half) }, { d: (mark) => cross(mark, 0) }, 1);
+		const noughts = ctx.marks("os", "circle", cells.filter((mark) => !mark.rising), key).attr("fill", "none").attr("stroke", tones.down).attr("stroke-width", 1.5);
+		ctx.set(noughts, {
+			cx: (mark) => x(mark.column),
+			cy: (mark) => level(mark.level),
+			r: half
+		}, {
+			cx: (mark) => x(mark.column),
+			cy: (mark) => level(mark.level),
+			r: 0
+		}, 1);
+		const lines = this.options.trendlines ? this.trendlines(view) : {
+			support: null,
+			resistance: null
+		};
+		FinanceInk.stroke(ctx, "support", lines.support, tones.up, 1.5);
+		FinanceInk.stroke(ctx, "resistance", lines.resistance, tones.down, 1.5);
+	}
+	/** Classic construction: rising from the lowest O and falling from the highest X, one box per column, until price breaks through. */
+	trendlines(view) {
+		const { columns, unit } = this;
+		if (columns.length < 3) return {
+			support: null,
+			resistance: null
+		};
+		const [floorY, ceilY] = view.y.domain();
+		const walk = (start, base, slope) => {
+			let last = start.index;
+			for (const column of columns.slice(start.index + 1)) {
+				const value = base + slope * (column.index - start.index);
+				if ((slope > 0 ? column.low <= value : column.high >= value) || value * unit > ceilY || value * unit < floorY) break;
+				last = column.index;
+			}
+			if (last === start.index) return null;
+			const end = base + slope * (last - start.index);
+			return `M${view.x(start.index)},${view.y(base * unit)}L${view.x(last)},${view.y(end * unit)}`;
+		};
+		const lowest = columns.reduce((best, column) => column.low < best.low ? column : best);
+		const highest = columns.reduce((best, column) => column.high > best.high ? column : best);
+		return {
+			support: walk(lowest, lowest.low - 1, 1),
+			resistance: walk(highest, highest.high + 1, -1)
+		};
+	}
+	legendItems() {
+		return [{
+			key: "X rising",
+			color: this.palette.diverging(-1)
+		}, {
+			key: "O falling",
+			color: this.palette.diverging(1)
+		}];
+	}
+};
+export { PointFigureChart };

package/dist/charts/financial/PriceChart.js

@@ -0,0 +1,168 @@
+import { FinanceInk } from "./FinanceInk.js";
+import { FinanceMath } from "./FinanceMath.js";
+import { PriceMark, PriceOverlay, PriceScale, VolumeLayout } from "./financeEnums.js";
+import { PriceMarks } from "./PriceMarks.js";
+import { Quotes } from "./Quotes.js";
+import { SessionChart } from "./SessionChart.js";
+import { extent, scaleLinear, scaleLog } from "d3";
+// src/charts/financial/PriceChart.ts
+/** Everything shared by charts whose main axis is price: scale modes, overlays and the volume pane. */
+var PriceChart = class extends SessionChart {
+	defaults() {
+		return {
+			...super.defaults(),
+			scale: PriceScale.Linear,
+			overlay: PriceOverlay.None,
+			period: 20,
+			volumeLayout: VolumeLayout.None
+		};
+	}
+	/** Bars actually drawn; transforms override this and overlays follow it. */
+	shown(bars) {
+		return bars;
+	}
+	bars() {
+		const bars = super.bars();
+		return this.shown(this.options.scale === PriceScale.Percent ? Quotes.rebased(bars) : bars);
+	}
+	percentValues() {
+		return this.options.scale === PriceScale.Percent;
+	}
+	get logarithmic() {
+		return this.options.scale === PriceScale.Log && Quotes.read(this.options.data, this.options).every((bar) => bar.low > 0);
+	}
+	valueScale() {
+		return this.logarithmic ? scaleLog() : scaleLinear();
+	}
+	subShare() {
+		return this.options.volumeLayout === VolumeLayout.Pane ? .22 : 0;
+	}
+	/** Extra lines this chart wants on the price axis. */
+	studies(bars) {
+		return this.overlayLines(bars);
+	}
+	overlayLines(bars) {
+		const { overlay, period } = this.options;
+		const closes = bars.map((bar) => bar.close);
+		const window = period;
+		switch (overlay) {
+			case PriceOverlay.SMA: return [{
+				name: `SMA ${window}`,
+				mid: FinanceMath.sma(closes, window)
+			}];
+			case PriceOverlay.EMA: return [{
+				name: `EMA ${window}`,
+				mid: FinanceMath.ema(closes, window)
+			}];
+			case PriceOverlay.WMA: return [{
+				name: `WMA ${window}`,
+				mid: FinanceMath.wma(closes, window)
+			}];
+			case PriceOverlay.VWAP: return [{
+				name: "VWAP",
+				mid: FinanceMath.vwap(bars)
+			}];
+			case PriceOverlay.Bollinger: {
+				const mid = FinanceMath.sma(closes, window), deviation = FinanceMath.stdev(closes, window);
+				return [{
+					name: `Bollinger ${window}`,
+					mid,
+					upper: mid.map((v, i) => v === null ? null : v + 2 * deviation[i]),
+					lower: mid.map((v, i) => v === null ? null : v - 2 * deviation[i])
+				}];
+			}
+			case PriceOverlay.Keltner: {
+				const mid = FinanceMath.ema(closes, window), range = FinanceMath.atr(bars, Math.min(window, 10));
+				const shift = (sign) => mid.map((v, i) => v === null || range[i] == null ? null : v + sign * 2 * range[i]);
+				return [{
+					name: `Keltner ${window}`,
+					mid,
+					upper: shift(1),
+					lower: shift(-1)
+				}];
+			}
+			case PriceOverlay.Donchian: {
+				const upper = FinanceMath.highest(bars.map((bar) => bar.high), window), lower = FinanceMath.lowest(bars.map((bar) => bar.low), window);
+				return [{
+					name: `Donchian ${window}`,
+					mid: FinanceMath.midpoint(upper, lower),
+					upper,
+					lower
+				}];
+			}
+			default: return [];
+		}
+	}
+	valueDomain(bars) {
+		const values = [...bars.flatMap((bar) => [bar.high, bar.low]), ...this.studies(bars).flatMap((study) => [
+			study.mid,
+			study.upper,
+			study.lower
+		].flatMap((series) => (series ?? []).filter((v) => v !== null)))];
+		const [low, high] = extent(values);
+		const spread = high - low || Math.abs(high) * .05 || 1;
+		const floor = low - spread * (this.options.volumeLayout === VolumeLayout.Overlay ? .3 : .05);
+		return [this.logarithmic ? Math.max(low * .8, floor) : floor, high + spread * .05];
+	}
+	plotMarks(ctx, view) {
+		const tones = this.tones(ctx);
+		this.drawVolume(ctx, view, tones);
+		this.priceMarks(ctx, view, tones);
+		this.drawStudies(ctx, view);
+		const zero = this.options.scale === PriceScale.Percent && view.bars.length ? [view.y(0)] : [];
+		FinanceInk.rules(ctx, "zero", zero, ctx.plot.width, ctx.theme.axis, null);
+		this.paneTitle(ctx, "volume-title", "Volume", view.sub && this.options.volumeLayout === VolumeLayout.Pane ? view.sub : null);
+		this.sessions(ctx, view);
+	}
+	drawPrice(ctx, view, tones, mark) {
+		const { bars } = view;
+		PriceMarks.candles(ctx, view, tones, mark === PriceMark.Candles ? bars : []);
+		PriceMarks.ohlc(ctx, view, tones, mark === PriceMark.Bars ? bars : []);
+		if (mark === PriceMark.Line || mark === PriceMark.Area) PriceMarks.closeLine(ctx, view, bars, tones.up, mark === PriceMark.Area);
+		else PriceMarks.closeLine(ctx, view, [], tones.up, false);
+	}
+	drawStudies(ctx, view) {
+		const studies = this.studies(view.bars);
+		const line = ctx.group("studies");
+		const nested = Object.create(ctx);
+		Object.defineProperty(nested, "root", { value: line });
+		for (const slot of [
+			0,
+			1,
+			2
+		]) {
+			const study = studies[slot];
+			const color = study ? ctx.palette.color(study.name) : ctx.theme.axis;
+			PriceMarks.band(nested, view, `study-fill-${slot}`, study?.upper ?? [], study?.lower ?? [], color, .1);
+			PriceMarks.line(nested, view, `study-upper-${slot}`, study?.upper ?? [], color, 1);
+			PriceMarks.line(nested, view, `study-lower-${slot}`, study?.lower ?? [], color, 1);
+			PriceMarks.line(nested, view, `study-mid-${slot}`, study?.mid ?? [], color, study?.upper ? 1.5 : 2, study?.upper ? "4 3" : null);
+		}
+	}
+	drawVolume(ctx, view, tones) {
+		const layout = this.options.volumeLayout;
+		const pane = layout === VolumeLayout.Pane ? view.sub : layout === VolumeLayout.Overlay ? {
+			top: view.main.bottom - (view.main.bottom - view.main.top) * .2,
+			bottom: view.main.bottom
+		} : null;
+		const bars = pane ? view.bars : [];
+		const peak = Math.max(1, ...bars.map((bar) => bar.volume));
+		const height = scaleLinear([0, peak], pane ? [pane.bottom, pane.top] : [0, 0]).nice(2);
+		const top = height.domain()[1];
+		const { x, body } = view;
+		const volume = ctx.marks("volume", "rect", bars, (bar) => bar.index).attr("fill", (bar) => bar.close >= bar.open ? tones.up : tones.down).attr("fill-opacity", .45).attr("rx", Math.min(1, body / 3));
+		ctx.set(volume, {
+			x: (bar) => x(bar.index) - body / 2,
+			width: body,
+			y: (bar) => height(bar.volume),
+			height: (bar) => Math.max(.5, height(0) - height(bar.volume))
+		}, {
+			x: (bar) => x(bar.index) - body / 2,
+			width: body,
+			y: height(0),
+			height: 0
+		});
+		FinanceInk.paneAxis(ctx, "volume-axis", layout === VolumeLayout.Pane && bars.length ? [top] : [], height, Quotes.compact, ctx.plot.width);
+	}
+};
+export { PriceChart };

package/dist/charts/financial/PriceMarks.js

@@ -0,0 +1,64 @@
+import { FinanceInk } from "./FinanceInk.js";
+import { CandleBody, OhlcTicks } from "./financeEnums.js";
+import { area, line } from "d3";
+// src/charts/financial/PriceMarks.ts
+/** Draws price itself, in each of the classic forms, on a session axis. */
+var PriceMarks = class {
+	static bodyPath(left, top, width, height, ring) {
+		const outer = `M${left},${top}h${width}v${height}h${-width}Z`;
+		const wall = Math.min(1.5, width / 3, height / 3);
+		return ring ? `${outer}M${left + wall},${top + wall}v${height - wall * 2}h${width - wall * 2}v${-(height - wall * 2)}Z` : outer;
+	}
+	static candles(ctx, view, tones, bars, { body = CandleBody.Solid, wicks = true } = {}) {
+		const { x, y, step } = view;
+		const peak = Math.max(1, ...bars.map((bar) => bar.volume));
+		const widthOf = (bar) => body === CandleBody.VolumeWidth ? Math.max(1, view.body * Math.sqrt(bar.volume / peak)) : view.body;
+		const rising = (bar, i) => body === CandleBody.Hollow ? bar.close >= (bars[i - 1]?.close ?? bar.open) : bar.close >= bar.open;
+		const tone = (bar, i) => rising(bar, i) ? tones.up : tones.down;
+		const top = (bar) => y(Math.max(bar.open, bar.close));
+		const tall = (bar) => Math.max(1, y(Math.min(bar.open, bar.close)) - top(bar));
+		const wick = ctx.marks("wicks", "line", wicks ? bars : [], (bar) => bar.index).attr("stroke", tone).attr("stroke-width", 1);
+		ctx.set(wick, {
+			x1: (bar) => x(bar.index),
+			x2: (bar) => x(bar.index),
+			y1: (bar) => y(bar.high),
+			y2: (bar) => y(bar.low)
+		}, {
+			x1: (bar) => x(bar.index),
+			x2: (bar) => x(bar.index),
+			y1: (bar) => y(bar.open),
+			y2: (bar) => y(bar.open)
+		}, Math.min(3, 240 / Math.max(1, bars.length)));
+		const shape = ctx.marks("bodies", "path", bars, (bar) => bar.index).attr("fill", tone).attr("fill-rule", "evenodd");
+		const hollow = (bar) => body === CandleBody.Hollow && bar.close >= bar.open && step >= 4;
+		ctx.set(shape, { d: (bar) => this.bodyPath(x(bar.index) - widthOf(bar) / 2, top(bar), widthOf(bar), tall(bar), hollow(bar)) }, { d: (bar) => this.bodyPath(x(bar.index) - widthOf(bar) / 2, y(bar.open), widthOf(bar), 0, hollow(bar)) }, Math.min(3, 240 / Math.max(1, bars.length)));
+	}
+	/** Vertical range bars with open and close ticks, the western alternative to candles. */
+	static ohlc(ctx, view, tones, bars, ticks = OhlcTicks.OpenClose) {
+		const { x, y } = view;
+		const reach = Math.max(1, Math.min(6, view.step * .42));
+		const d = (bar, flat) => {
+			const at = x(bar.index);
+			return `M${at},${y(flat ? bar.close : bar.high)}V${y(flat ? bar.close : bar.low)}${ticks === OhlcTicks.OpenClose ? `M${at - reach},${y(bar.open)}H${at}` : ""}${ticks === OhlcTicks.RangeOnly ? "" : `M${at},${y(bar.close)}H${at + reach}`}`;
+		};
+		const mark = ctx.marks("bars", "path", bars, (bar) => bar.index).attr("fill", "none").attr("stroke-width", ticks === OhlcTicks.RangeOnly ? 2 : 1.5).attr("stroke-linecap", "round").attr("stroke", (bar) => bar.close >= bar.open ? tones.up : tones.down);
+		ctx.set(mark, { d: (bar) => d(bar, false) }, { d: (bar) => d(bar, true) }, Math.min(3, 240 / Math.max(1, bars.length)));
+	}
+	static line(ctx, view, name, values, color, width = 2, dash = null, shift = 0) {
+		const path = line().defined((value) => value !== null).x((_, i) => view.x(i + shift)).y((value) => view.y(value));
+		const drawn = values.some((value) => value !== null);
+		FinanceInk.stroke(ctx, name, drawn ? path(values) : null, color, width, dash);
+	}
+	/** Filled band between two aligned series. */
+	static band(ctx, view, name, upper, lower, color, opacity = .12, shift = 0) {
+		const path = area().defined((value, i) => value !== null && lower[i] != null).x((_, i) => view.x(i + shift)).y0((_, i) => view.y(lower[i])).y1((value) => view.y(value));
+		FinanceInk.fill(ctx, name, upper.some((value) => value !== null) ? path(upper) : null, color, opacity);
+	}
+	/** Close as a plain line, with an optional soft fill to the bottom of the pane. */
+	static closeLine(ctx, view, bars, color, fill) {
+		const shade = area().x((bar) => view.x(bar.index)).y0(view.main.bottom).y1((bar) => view.y(bar.close));
+		FinanceInk.fill(ctx, "price-area", fill && bars.length ? shade(bars) : null, color, .14);
+		this.line(ctx, view, "price-line", bars.map((bar) => bar.close), color);
+	}
+};
+export { PriceMarks };

package/dist/charts/financial/PriceTransforms.js

@@ -0,0 +1,284 @@
+import { FinanceMath } from "./FinanceMath.js";
+import { BoxMethod, PriceSource } from "./financeEnums.js";
+// src/charts/financial/PriceTransforms.ts
+var ohlc = (bar, open, high, low, close) => ({
+	...bar,
+	open,
+	high,
+	low,
+	close
+});
+/** Price-action constructions: each turns time-based bars into something driven by price moves alone. */
+var PriceTransforms = class {
+	static heikinAshi(bars) {
+		const out = [];
+		bars.forEach((bar, i) => {
+			const close = (bar.open + bar.high + bar.low + bar.close) / 4;
+			const previous = out[i - 1];
+			const open = previous ? (previous.open + previous.close) / 2 : (bar.open + bar.close) / 2;
+			out.push(ohlc(bar, open, Math.max(bar.high, open, close), Math.min(bar.low, open, close), close));
+		});
+		return out;
+	}
+	/** EMA-smooths each price before the Heikin-Ashi step, which removes more noise and adds lag. */
+	static smoothed(bars, period = 5) {
+		const pick = (field) => FinanceMath.ema(bars.map((bar) => bar[field]), Math.min(period, Math.max(1, bars.length)));
+		const [open, high, low, close] = [
+			pick("open"),
+			pick("high"),
+			pick("low"),
+			pick("close")
+		];
+		const ready = bars.flatMap((bar, i) => close[i] === null ? [] : [ohlc(bar, open[i], high[i], low[i], close[i])]);
+		return this.heikinAshi(ready.map((bar, index) => ({
+			...bar,
+			index
+		})));
+	}
+	/** One box in price units. An explicit `size` always wins. */
+	static boxSize(bars, method, multiple = 1, size) {
+		if (size && size > 0) return size;
+		const closes = bars.map((bar) => Math.abs(bar.close));
+		const peak = Math.max(...bars.map((bar) => bar.high)), trough = Math.min(...bars.map((bar) => bar.low));
+		const last = closes.at(-1) ?? 1;
+		return ((method === BoxMethod.ATR ? FinanceMath.lastAtr(bars) : method === BoxMethod.Percent ? last * .015 : (peak - trough) / 24) || last * .01 || 1) * multiple;
+	}
+	/** Bricks of a fixed size; a turn needs `reversal` box lengths against the last brick's far edge. */
+	static renko(bars, box, reversal, source) {
+		const first = bars[0];
+		if (!first || !(box > 0)) return [];
+		const bricks = [];
+		let top = first.close, bottom = first.close - box, up = true, far = first.close;
+		const push = (bar, high, rising) => {
+			top = high;
+			bottom = high - box;
+			up = rising;
+			bricks.push({
+				index: bricks.length,
+				top,
+				bottom,
+				up,
+				bar,
+				wick: far
+			});
+			far = rising ? top : bottom;
+		};
+		for (const bar of bars.slice(1)) {
+			const highPrice = source === PriceSource.HighLow ? bar.high : bar.close;
+			const lowPrice = source === PriceSource.HighLow ? bar.low : bar.close;
+			const before = bricks.length;
+			if (up) {
+				while (highPrice >= top + box) push(bar, top + box, true);
+				if (bricks.length === before && lowPrice <= top - reversal * box) {
+					let edge = reversal === 1 ? top : bottom;
+					while (lowPrice <= edge - box) {
+						push(bar, edge, false);
+						edge -= box;
+					}
+				}
+			} else {
+				while (lowPrice <= bottom - box) push(bar, bottom, false);
+				if (bricks.length === before && highPrice >= bottom + reversal * box) {
+					let edge = reversal === 1 ? bottom : top;
+					while (highPrice >= edge + box) {
+						push(bar, edge + box, true);
+						edge += box;
+					}
+				}
+			}
+			far = up ? Math.min(far, lowPrice) : Math.max(far, highPrice);
+		}
+		return bricks;
+	}
+	/** Line that keeps running until price turns by `box`, thick (yang) above the last shoulder, thin (yin) below the last waist. */
+	static kagi(bars, box, source) {
+		const first = bars[0];
+		if (!first || !(box > 0)) return {
+			segments: [],
+			pivots: [],
+			columns: 0
+		};
+		const legs = [];
+		let from = first.close, to = first.close, up = true, bar = first;
+		let started = false;
+		for (const next of bars.slice(1)) {
+			const high = source === PriceSource.HighLow ? next.high : next.close;
+			const low = source === PriceSource.HighLow ? next.low : next.close;
+			if (!started) {
+				if (high >= from + box) {
+					started = true;
+					up = true;
+					to = high;
+					bar = next;
+				} else if (low <= from - box) {
+					started = true;
+					up = false;
+					to = low;
+					bar = next;
+				}
+				continue;
+			}
+			if (up ? high > to : low < to) {
+				to = up ? high : low;
+				bar = next;
+			} else if (up ? to - low >= box : high - to >= box) {
+				legs.push({
+					from,
+					to,
+					bar
+				});
+				from = to;
+				to = up ? low : high;
+				up = !up;
+				bar = next;
+			}
+		}
+		if (started) legs.push({
+			from,
+			to,
+			bar
+		});
+		const segments = [], pivots = [];
+		let yang = legs.length ? legs[0].to >= legs[0].from : true;
+		let shoulder = -Infinity, waist = Infinity;
+		legs.forEach((leg, column) => {
+			const rising = leg.to >= leg.from;
+			const line = rising ? shoulder : waist;
+			if (Number.isFinite(line) && (rising ? !yang && leg.to > line : yang && leg.to < line)) {
+				segments.push({
+					column,
+					from: leg.from,
+					to: line,
+					yang,
+					up: rising,
+					bar: leg.bar
+				});
+				yang = rising;
+				segments.push({
+					column,
+					from: line,
+					to: leg.to,
+					yang,
+					up: rising,
+					bar: leg.bar
+				});
+			} else segments.push({
+				column,
+				from: leg.from,
+				to: leg.to,
+				yang,
+				up: rising,
+				bar: leg.bar
+			});
+			if (rising) shoulder = leg.to;
+			else waist = leg.to;
+			if (column < legs.length - 1) pivots.push({
+				column,
+				price: leg.to,
+				shoulder: rising
+			});
+		});
+		return {
+			segments,
+			pivots,
+			columns: legs.length
+		};
+	}
+	/** Columns of X and O on a box grid; a new column needs `reversal` boxes against the current one. */
+	static pointFigure(bars, box, reversal, source) {
+		const first = bars[0];
+		if (!first || !(box > 0)) return [];
+		const snap = (price) => Math.round(price / box);
+		const columns = [];
+		const start = snap(first.close);
+		let current = null;
+		for (const bar of bars.slice(1)) {
+			const high = Math.floor((source === PriceSource.HighLow ? bar.high : bar.close) / box);
+			const low = Math.ceil((source === PriceSource.HighLow ? bar.low : bar.close) / box);
+			if (!current) {
+				if (high >= start + reversal) current = {
+					index: 0,
+					rising: true,
+					low: start,
+					high,
+					bar
+				};
+				else if (low <= start - reversal) current = {
+					index: 0,
+					rising: false,
+					low,
+					high: start,
+					bar
+				};
+				if (current) columns.push(current);
+				continue;
+			}
+			if (current.rising) {
+				if (high > current.high) {
+					current.high = high;
+					current.bar = bar;
+				} else if (low <= current.high - reversal) {
+					current = {
+						index: columns.length,
+						rising: false,
+						low,
+						high: current.high - 1,
+						bar
+					};
+					columns.push(current);
+				}
+			} else if (low < current.low) {
+				current.low = low;
+				current.bar = bar;
+			} else if (high >= current.low + reversal) {
+				current = {
+					index: columns.length,
+					rising: true,
+					low: current.low + 1,
+					high,
+					bar
+				};
+				columns.push(current);
+			}
+		}
+		return columns;
+	}
+	/** N-line break: a new line prints only past the extreme of the last `lines` lines when reversing. */
+	static lineBreak(bars, lines, source) {
+		const price = (bar) => source === PriceSource.HighLow ? (bar.high + bar.low) / 2 : bar.close;
+		const out = [];
+		let last = bars[0] ? price(bars[0]) : 0;
+		for (const bar of bars.slice(1)) {
+			const value = price(bar);
+			const tail = out.slice(-lines);
+			const previous = out.at(-1);
+			if (!previous) {
+				if (value !== last) out.push({
+					index: 0,
+					top: Math.max(value, last),
+					bottom: Math.min(value, last),
+					up: value > last,
+					bar
+				});
+				continue;
+			}
+			const high = Math.max(...tail.map((line) => line.top)), low = Math.min(...tail.map((line) => line.bottom));
+			if (previous.up ? value > previous.top : value > high) out.push({
+				index: out.length,
+				top: value,
+				bottom: previous.top,
+				up: true,
+				bar
+			});
+			else if (!previous.up ? value < previous.bottom : value < low) out.push({
+				index: out.length,
+				top: previous.bottom,
+				bottom: value,
+				up: false,
+				bar
+			});
+		}
+		return out;
+	}
+};
+export { PriceTransforms };