@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/multivariate/ConditionalPlot.js

@@ -0,0 +1,137 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { MultivariateKit, PanelLayout } from "./MultivariateKit.js";
+import { PanelFit, PanelScatter } from "./PanelScatter.js";
+import { extent, scaleLinear } from "d3";
+// src/charts/multivariate/ConditionalPlot.ts
+var ShingleMethod = /* @__PURE__ */ function(ShingleMethod) {
+	ShingleMethod["EqualCount"] = "equal-count";
+	ShingleMethod["EqualWidth"] = "equal-width";
+	return ShingleMethod;
+}({});
+/** Coplot: see how the x/y relationship changes as a third measure rises, slicing it into overlapping shingles. */
+var ConditionalPlot = class extends PanelScatter {
+	static meta = {
+		id: "conditional-plot",
+		name: "Conditional plot",
+		family: ChartFamily.Relationship,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Draws x against y in panels conditioned on overlapping intervals of a third measure, shown as shingles above the plot.",
+		tags: [
+			"multivariate",
+			"coplot",
+			"shingles",
+			"conditioning"
+		],
+		sample: (seed) => SampleData.points(seed, 180, 3),
+		variants: {
+			intervals: [
+				4,
+				3,
+				6
+			],
+			overlap: [
+				.25,
+				0,
+				.5
+			],
+			method: ["equal-count", "equal-width"],
+			fit: [
+				PanelFit.Loess,
+				PanelFit.None,
+				PanelFit.Linear
+			]
+		}
+	};
+	defaults() {
+		return {
+			x: "x",
+			y: "y",
+			given: "size",
+			intervals: 4,
+			overlap: .25,
+			method: "equal-count",
+			fit: PanelFit.Loess
+		};
+	}
+	legendItems() {
+		return [];
+	}
+	/** Cleveland's shingle: `n` intervals of equal size overlapping by fraction `f`. */
+	shingles(points) {
+		const { given, intervals, overlap, method } = this.options;
+		const value = (d) => +d.row[given];
+		const sorted = points.filter((d) => Number.isFinite(value(d))).sort((a, b) => value(a) - value(b));
+		if (!sorted.length) return [];
+		const n = Math.max(1, intervals), f = Math.max(0, Math.min(.9, overlap));
+		const span = 1 / (n - (n - 1) * f);
+		const spans = Array.from({ length: n }, (_, i) => [i * span * (1 - f), i * span * (1 - f) + span]);
+		if (method === "equal-count") return spans.map(([a, b], index) => {
+			const rows = sorted.slice(Math.floor(a * sorted.length), Math.ceil(b * sorted.length));
+			return {
+				index,
+				rows,
+				low: value(rows[0]),
+				high: value(rows[rows.length - 1])
+			};
+		});
+		const low = value(sorted[0]), range = value(sorted[sorted.length - 1]) - low || 1;
+		return spans.map(([a, b], index) => {
+			const lo = low + a * range, hi = low + b * range;
+			return {
+				index,
+				low: lo,
+				high: hi,
+				rows: sorted.filter((d) => value(d) >= lo && value(d) <= hi)
+			};
+		});
+	}
+	draw(ctx) {
+		const points = this.points();
+		const shingles = this.shingles(points);
+		if (!shingles.length) return;
+		const { width, height } = ctx.plot;
+		const strip = 18 + shingles.length * 6;
+		this.drawStrip(ctx, shingles, width);
+		const nest = ctx.nest(`translate(0,${strip})`, "panels");
+		const panels = MultivariateKit.panels(shingles.length, width, height - strip, shingles.length > 4 ? PanelLayout.Wrap : PanelLayout.Row, 8);
+		const pad = (axis) => {
+			const [low = 0, high = 1] = extent(points, (d) => d[axis]);
+			return low === high ? [low - 1, high + 1] : [low, high];
+		};
+		shingles.forEach((shingle, i) => {
+			const panel = panels[i];
+			this.panel(nest, {
+				panel,
+				name: `${this.round(shingle.low)} – ${this.round(shingle.high)}`,
+				rows: shingle.rows,
+				x: scaleLinear(pad("x"), [4, panel.width - 4]).nice(),
+				y: scaleLinear(pad("y"), [panel.height - 4, 4]).nice(),
+				showX: panel.bottom,
+				showY: panel.left
+			});
+		});
+	}
+	round(value) {
+		return Math.abs(value) < 100 ? value.toFixed(1) : value.toFixed(0);
+	}
+	drawStrip(ctx, shingles, width) {
+		const low = Math.min(...shingles.map((s) => s.low)), high = Math.max(...shingles.map((s) => s.high));
+		const x = scaleLinear([low, high === low ? low + 1 : high], [0, width]);
+		const bars = ctx.marks("shingles", "rect", shingles, (s) => s.index).attr("rx", 2).attr("fill", (s) => ctx.palette.sequential(.3 + .6 * (s.index + 1) / shingles.length));
+		ctx.set(bars, {
+			x: (s) => x(s.low),
+			width: (s) => Math.max(3, x(s.high) - x(s.low)),
+			y: (s) => 14 + s.index * 6,
+			height: 4
+		}, { width: 0 });
+		ctx.hover(bars, (s) => ({
+			title: `${this.options.given} ${this.round(s.low)} – ${this.round(s.high)}`,
+			rows: [["Observations", s.rows.length]]
+		}));
+		const label = ctx.marks("given", "text", [`Given ${this.options.given}`]).text((d) => d);
+		ctx.text(label, 10.5).attr("x", 0).attr("y", 9);
+	}
+};
+export { ConditionalPlot, ShingleMethod };

package/dist/charts/multivariate/CrossfilterHistograms.js

@@ -0,0 +1,247 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { MultivariateKit, PanelLayout } from "./MultivariateKit.js";
+import { MultivariateSample } from "./MultivariateSample.js";
+import { WideTable } from "./WideTable.js";
+import { area, bin, brushX, curveStepAfter, line, max, pointer, scaleLinear, thresholdFreedmanDiaconis, thresholdScott, thresholdSturges } from "d3";
+// src/charts/multivariate/CrossfilterHistograms.ts
+var CrossfilterBinning = /* @__PURE__ */ function(CrossfilterBinning) {
+	CrossfilterBinning["Sturges"] = "sturges";
+	CrossfilterBinning["Scott"] = "scott";
+	CrossfilterBinning["FreedmanDiaconis"] = "freedman-diaconis";
+	return CrossfilterBinning;
+}({});
+var CrossfilterForm = /* @__PURE__ */ function(CrossfilterForm) {
+	CrossfilterForm["Bars"] = "bars";
+	CrossfilterForm["Area"] = "area";
+	CrossfilterForm["Steps"] = "steps";
+	return CrossfilterForm;
+}({});
+var RULES = {
+	["sturges"]: thresholdSturges,
+	["scott"]: thresholdScott,
+	["freedman-diaconis"]: thresholdFreedmanDiaconis
+};
+var HEAD = 16;
+var AXIS = 16;
+var GUTTER = 66;
+/** Explore a table by dragging across any histogram: the rest redraw to show only the selected rows. */
+var CrossfilterHistograms = class extends Chart2D {
+	static meta = {
+		id: "crossfilter-histograms",
+		name: "Crossfilter histograms",
+		family: ChartFamily.Distribution,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Links a histogram per measure so that brushing a range in one filters the observations shown in all the others.",
+		tags: [
+			"multivariate",
+			"coordinated views",
+			"brushing",
+			"dashboard"
+		],
+		sample: (seed) => MultivariateSample.wide(seed, 320).map(({ Cost: _cost, ...row }) => row),
+		variants: {
+			form: [
+				"bars",
+				"area",
+				"steps"
+			],
+			layout: [
+				PanelLayout.Wrap,
+				PanelLayout.Row,
+				PanelLayout.Column
+			],
+			binning: [
+				"sturges",
+				"scott",
+				"freedman-diaconis"
+			],
+			preselect: [false, true]
+		}
+	};
+	ranges = /* @__PURE__ */ new Map();
+	seeded = false;
+	defaults() {
+		return {
+			group: "group",
+			binning: "sturges",
+			layout: PanelLayout.Wrap,
+			form: "bars",
+			preselect: false
+		};
+	}
+	plotMargin() {
+		return {
+			top: 2,
+			right: 16,
+			bottom: 6,
+			left: 16
+		};
+	}
+	legendItems() {
+		return [];
+	}
+	panes(ctx, table) {
+		const panels = MultivariateKit.panels(table.dimensions.length, ctx.plot.width, ctx.plot.height, this.options.layout, 14);
+		return table.dimensions.map((name, column) => {
+			const panel = panels[column];
+			const values = table.column(column);
+			const domain = table.bounds(column);
+			const stacked = this.options.layout === PanelLayout.Column;
+			const gutter = stacked ? GUTTER : 0;
+			const x = scaleLinear(domain, [gutter, panel.width]);
+			const count = Math.max(4, Math.min(Math.floor(panel.width / 7), Math.ceil(RULES[this.options.binning](values, domain[0], domain[1]))));
+			const thresholds = Array.from({ length: count + 1 }, (_, i) => domain[0] + (domain[1] - domain[0]) * i / count);
+			const bins = bin().domain(domain).thresholds(thresholds.slice(1, -1))(values);
+			const top = max(bins, (b) => b.length) || 1;
+			return {
+				name,
+				column,
+				panel,
+				gutter,
+				x,
+				thresholds,
+				bins,
+				y: scaleLinear([0, top], [panel.height - (stacked ? 2 : AXIS), stacked ? 2 : HEAD])
+			};
+		});
+	}
+	selected(table, skip) {
+		return table.records.filter((record) => table.dimensions.every((name, d) => {
+			const range = this.ranges.get(name);
+			return d === skip || !range || record.values[d] >= range[0] && record.values[d] <= range[1];
+		}));
+	}
+	counts(table, pane) {
+		return bin().domain(pane.x.domain()).thresholds(pane.thresholds.slice(1, -1))(table.column(pane.column, this.selected(table, pane.column))).map((b) => b.length);
+	}
+	draw(ctx) {
+		const table = WideTable.of(this.options);
+		if (!table.dimensions.length || !table.records.length) return;
+		if (this.options.preselect && !this.seeded) {
+			const [low, high] = table.bounds(0);
+			this.ranges.set(table.dimensions[0], [low + (high - low) * 2 / 3, high]);
+		}
+		this.seeded = true;
+		const panes = this.panes(ctx, table);
+		const color = ctx.palette.color("selected");
+		const nests = panes.map((pane) => ctx.nest(`translate(${pane.panel.x},${pane.panel.y})`, `pane-${pane.column}`));
+		const paintAll = (still) => panes.forEach((pane, i) => this.paintSelection(nests[i], table, pane, color, still));
+		panes.forEach((pane, i) => {
+			const nest = nests[i];
+			this.frame(nest, pane);
+			this.ghost(nest, pane);
+			this.paintSelection(nest, table, pane, color, false);
+			this.brush(nest, table, pane, paintAll);
+		});
+	}
+	frame(ctx, pane) {
+		const { panel, x, name, gutter } = pane;
+		const base = pane.y.range()[0];
+		const rule = ctx.marks("base", "line", [base]).attr("stroke", ctx.theme.axis);
+		ctx.set(rule, {
+			x1: gutter,
+			x2: panel.width,
+			y1: base,
+			y2: base
+		});
+		const [low, high] = x.domain();
+		const short = (value) => Intl.NumberFormat("en", {
+			notation: "compact",
+			maximumFractionDigits: 1
+		}).format(value);
+		const ticks = gutter ? [] : [{
+			text: short(low),
+			at: 0,
+			anchor: "start"
+		}, {
+			text: short(high),
+			at: panel.width,
+			anchor: "end"
+		}];
+		ctx.text(ctx.marks("ticks", "text", ticks, (d) => d.anchor).attr("x", (d) => d.at).attr("y", base + 12).attr("text-anchor", (d) => d.anchor).text((d) => d.text), 10);
+		ctx.text(ctx.marks("name", "text", [name]).attr("font-weight", 600).attr("y", 10).text(MultivariateKit.trim(name, gutter ? gutter - 8 : panel.width - 60)), 11, "ink");
+	}
+	ghost(ctx, pane) {
+		const { bins, x, y } = pane;
+		const base = y.range()[0];
+		const bars = ctx.marks("ghost", "rect", bins.filter((b) => b.x0 < b.x1), (b) => b.x0).attr("fill", ctx.theme.grid).attr("rx", 1.5);
+		ctx.set(bars, {
+			x: (b) => x(b.x0),
+			width: (b) => Math.max(1, x(b.x1) - x(b.x0) - 2),
+			y: (b) => y(b.length),
+			height: (b) => base - y(b.length)
+		}, {
+			y: base,
+			height: 0
+		});
+	}
+	/** Foreground counts: runs on first draw and on every brush move. */
+	paintSelection(ctx, table, pane, color, still) {
+		const { bins, x, y } = pane;
+		const counts = this.counts(table, pane);
+		const base = y.range()[0];
+		const form = this.options.form;
+		const usable = bins.map((b, i) => ({
+			low: b.x0,
+			high: b.x1,
+			count: counts[i] ?? 0
+		})).filter((b) => b.low < b.high);
+		const rects = ctx.marks("front-bars", "rect", form === "bars" ? usable : [], (b) => b.low).attr("fill", color).attr("rx", 1.5).style("pointer-events", "none");
+		const final = {
+			x: (b) => x(b.low),
+			width: (b) => Math.max(1, x(b.high) - x(b.low) - 2),
+			y: (b) => y(b.count),
+			height: (b) => base - y(b.count)
+		};
+		if (still) for (const [key, value] of Object.entries(final)) rects.attr(key, value);
+		else ctx.set(rects, final, {
+			y: base,
+			height: 0
+		}, 6);
+		const steps = [...usable.map((b) => ({
+			at: x(b.low),
+			count: b.count
+		})), {
+			at: x(usable[usable.length - 1]?.high ?? 0),
+			count: usable[usable.length - 1]?.count ?? 0
+		}];
+		const fillPath = form === "bars" ? [] : [area().x((s) => s.at).y0(base).y1((s) => y(s.count)).curve(curveStepAfter)(steps) ?? ""];
+		const outline = form === "bars" ? [] : [line().x((s) => s.at).y((s) => y(s.count)).curve(curveStepAfter)(steps) ?? ""];
+		ctx.marks("front-area", "path", form === "area" ? fillPath : []).attr("d", (d) => d).attr("fill", color).attr("fill-opacity", .75).style("pointer-events", "none");
+		ctx.marks("front-line", "path", form === "steps" ? outline : []).attr("d", (d) => d).attr("fill", "none").attr("stroke", color).attr("stroke-width", 2).style("pointer-events", "none");
+		const shown = table.column(pane.column, this.selected(table, -1)).length;
+		const total = table.column(pane.column).length;
+		ctx.text(ctx.marks("tally", "text", [`${shown} of ${total}`]).attr("text-anchor", pane.gutter ? "start" : "end").attr("x", pane.gutter ? 0 : pane.panel.width).attr("y", pane.gutter ? 23 : 10).text((d) => d), 10, "muted");
+	}
+	brush(ctx, table, pane, paintAll) {
+		const { panel, x, y, name, gutter } = pane;
+		const base = y.range()[0];
+		const brush = brushX().extent([[gutter, y.range()[1]], [panel.width, base]]).on("brush end", (event) => {
+			if (!event.sourceEvent) return;
+			const span = event.selection;
+			if (span) this.ranges.set(name, [x.invert(span[0]), x.invert(span[1])]);
+			else this.ranges.delete(name);
+			paintAll(true);
+		});
+		const layer = ctx.group("brush").call(brush);
+		const range = this.ranges.get(name);
+		layer.call(brush.move, range ? [x(range[0]), x(range[1])] : null);
+		layer.select(".selection").attr("fill", ctx.theme.ink).attr("fill-opacity", .08).attr("stroke", ctx.theme.axis);
+		layer.on("pointermove.tip", (event) => {
+			const value = x.invert(pointer(event, layer.node())[0]);
+			const hit = pane.bins.find((b) => value >= b.x0 && value < b.x1);
+			if (hit) this.tip(event, {
+				title: name,
+				color: ctx.palette.color("selected"),
+				rows: [
+					["Range", `${+hit.x0.toFixed(1)} – ${+hit.x1.toFixed(1)}`],
+					["Selected", this.counts(table, pane)[pane.bins.indexOf(hit)] ?? 0],
+					["All", hit.length]
+				]
+			});
+		}).on("pointerleave.tip", () => this.untip());
+	}
+};
+export { CrossfilterBinning, CrossfilterForm, CrossfilterHistograms };

package/dist/charts/multivariate/DimensionalStacking.js

@@ -0,0 +1,205 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { MultivariateKit } from "./MultivariateKit.js";
+import { MultivariateSample } from "./MultivariateSample.js";
+import { WideTable } from "./WideTable.js";
+import { extent, max, rollup, scaleLinear } from "d3";
+// src/charts/multivariate/DimensionalStacking.ts
+var StackingOrder = /* @__PURE__ */ function(StackingOrder) {
+	StackingOrder["Given"] = "given";
+	StackingOrder["Swapped"] = "swapped";
+	StackingOrder["Reversed"] = "reversed";
+	return StackingOrder;
+}({});
+var StackingMark = /* @__PURE__ */ function(StackingMark) {
+	StackingMark["Tile"] = "tile";
+	StackingMark["Disc"] = "disc";
+	return StackingMark;
+}({});
+var StackingAspect = /* @__PURE__ */ function(StackingAspect) {
+	StackingAspect["Fill"] = "fill";
+	StackingAspect["Square"] = "square";
+	return StackingAspect;
+}({});
+var ORDERS = {
+	["given"]: [
+		0,
+		1,
+		2,
+		3
+	],
+	["swapped"]: [
+		2,
+		3,
+		0,
+		1
+	],
+	["reversed"]: [
+		1,
+		0,
+		3,
+		2
+	]
+};
+/** LeBlanc's stacking: nest two binned axes inside two others to read a four-way distribution on one flat grid. */
+var DimensionalStacking = class extends Chart2D {
+	static meta = {
+		id: "dimensional-stacking",
+		name: "Dimensional stacking",
+		family: ChartFamily.Distribution,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Bins four measures and nests one pair of axes inside each cell of the other, showing a four-way distribution on a flat grid.",
+		tags: [
+			"multivariate",
+			"nested axes",
+			"leblanc",
+			"binned"
+		],
+		sample: (seed) => MultivariateSample.wide(seed, 420),
+		variants: {
+			bins: [
+				4,
+				3,
+				5
+			],
+			stackOrder: [
+				"given",
+				"swapped",
+				"reversed"
+			],
+			mark: ["tile", "disc"],
+			aspect: ["fill", "square"]
+		}
+	};
+	defaults() {
+		return {
+			group: "group",
+			bins: 4,
+			stackOrder: "given",
+			mark: "tile",
+			aspect: "fill"
+		};
+	}
+	plotMargin() {
+		return {
+			top: 4,
+			right: 16,
+			bottom: 6,
+			left: 22
+		};
+	}
+	legendItems() {
+		return [];
+	}
+	draw(ctx) {
+		const table = WideTable.of(this.options);
+		if (table.dimensions.length < 4 || !table.complete.length) return;
+		const b = Math.max(2, Math.round(this.options.bins));
+		const order = ORDERS[this.options.stackOrder];
+		const names = order.map((d) => table.dimensions[d]);
+		const cut = order.map((d) => {
+			const [low, high] = table.bounds(d);
+			return (value) => Math.min(b - 1, Math.floor((value - low) / (high - low) * b));
+		});
+		const counts = rollup(table.complete, (own) => own.length, (record) => order.map((d, i) => cut[i](record.values[d])).join());
+		const { width, height } = ctx.plot;
+		const head = 18, foot = 16;
+		const outerGap = 5, innerGap = 1.5;
+		const fitW = (width - outerGap * (b - 1) - innerGap * b * (b - 1)) / (b * b), fitH = (height - head - foot - outerGap * (b - 1) - innerGap * b * (b - 1)) / (b * b);
+		const square = this.options.aspect === "square";
+		const w = square ? Math.min(fitW, fitH) : fitW, h = square ? Math.min(fitW, fitH) : fitH;
+		const blockW = b * w + (b - 1) * innerGap, blockH = b * h + (b - 1) * innerGap;
+		const tile = (i, j, cell, gap, block) => i * (block + outerGap) + j * (cell + gap);
+		const tiles = [];
+		for (let a = 0; a < b; a++) for (let c = 0; c < b; c++) for (let e = 0; e < b; e++) for (let f = 0; f < b; f++) {
+			const count = counts.get([
+				a,
+				c,
+				e,
+				f
+			].join()) ?? 0;
+			tiles.push({
+				key: `${a}${c}${e}${f}`,
+				count,
+				column: a * b + e,
+				row: c * b + f,
+				x: tile(a, e, w, innerGap, blockW),
+				y: head + tile(c, f, h, innerGap, blockH),
+				bins: [
+					a,
+					c,
+					e,
+					f
+				]
+			});
+		}
+		const top = max(tiles, (d) => d.count) || 1;
+		const blocks = Array.from({ length: b * b }, (_, i) => ({
+			x: i % b * (blockW + outerGap),
+			y: head + Math.floor(i / b) * (blockH + outerGap)
+		}));
+		const plates = ctx.marks("blocks", "rect", blocks, (_, i) => i).attr("fill", ctx.theme.grid).attr("fill-opacity", .45).attr("rx", 2);
+		ctx.set(plates, {
+			x: (d) => d.x - .5,
+			y: (d) => d.y - .5,
+			width: blockW + 1,
+			height: blockH + 1
+		});
+		const heat = scaleLinear([0, top], [.1, 1]);
+		const fill = (d) => ctx.palette.sequential(heat(d.count));
+		const tip = (d) => ({
+			title: `${d.count} observations`,
+			color: fill(d),
+			rows: names.map((name, i) => [name, `level ${d.bins[i] + 1} of ${b}`])
+		});
+		const filled = tiles.filter((d) => d.count > 0);
+		if (this.options.mark === "tile") {
+			const rects = ctx.marks("tiles", "rect", filled, (d) => d.key).attr("fill", fill).attr("rx", Math.min(1.5, w / 4));
+			ctx.set(rects, {
+				x: (d) => d.x,
+				y: (d) => d.y,
+				width: w,
+				height: h
+			}, {
+				width: 0,
+				height: 0
+			}, 1);
+			ctx.hover(rects, tip);
+		} else {
+			const radius = (d) => Math.max(.8, Math.sqrt(d.count / top) * (Math.min(w, h) / 2));
+			const discs = ctx.marks("tiles", "circle", filled, (d) => d.key).attr("fill", fill);
+			ctx.set(discs, {
+				cx: (d) => d.x + w / 2,
+				cy: (d) => d.y + h / 2,
+				r: radius
+			}, { r: 0 }, 1);
+			ctx.hover(discs, tip);
+		}
+		const span = (d) => extent(table.bounds(d));
+		const fmt = (value) => Math.abs(value) >= 100 ? value.toFixed(0) : value.toFixed(1);
+		const totalW = b * blockW + (b - 1) * outerGap, totalH = b * blockH + (b - 1) * outerGap;
+		const notes = [
+			{
+				key: "x",
+				text: MultivariateKit.trim(`${names[0]} ${fmt(span(order[0])[0])} → ${fmt(span(order[0])[1])}`, totalW),
+				transform: `translate(0,10)`,
+				anchor: "start"
+			},
+			{
+				key: "y",
+				text: MultivariateKit.trim(`← ${names[1]}`, totalH),
+				transform: `translate(-8,${head + totalH}) rotate(-90)`,
+				anchor: "start"
+			},
+			{
+				key: "inner",
+				text: MultivariateKit.trim(`Within each block: ${names[2]} →, ${names[3]} ↓`, width),
+				transform: `translate(0,${height - 3})`,
+				anchor: "start"
+			}
+		];
+		ctx.text(ctx.marks("notes", "text", notes, (d) => d.key).attr("text-anchor", (d) => d.anchor).attr("transform", (d) => d.transform).text((d) => d.text), 10.5);
+	}
+};
+export { DimensionalStacking, StackingAspect, StackingMark, StackingOrder };