@dou-ui/pivot 0.0.0-stage → 0.1.0-alpha.1

package/dist/engine/compute.js

@@ -0,0 +1,735 @@
+import { BUILTIN_AGGREGATORS, FAST_AGGREGATES, distinctAggregator } from "./aggregate.js";
+import { PivotFormulaError, parsePivotFormula } from "./formula.js";
+import { IntIndex, typed } from "./hash.js";
+import { PivotShown, resolveShow } from "./show.js";
+import { PivotTree, PivotTreeBuilder } from "./tree.js";
+// src/engine/compute.ts
+/** The ways of showing a value that write it as a percentage. */
+var PERCENT_SHOWS = /* @__PURE__ */ new Set([
+	"percentOfTotal",
+	"percentOfRow",
+	"percentOfColumn",
+	"percentOfParent",
+	"percentDifference"
+]);
+/** A `show` as an object. */
+var showOf = (show) => show === void 0 ? void 0 : typeof show === "string" ? { as: show } : show;
+/** A `mark` with its tone filled in. */
+var markOf = (mark) => mark === void 0 ? void 0 : typeof mark === "string" ? {
+	type: mark,
+	tone: "neutral"
+} : {
+	type: mark.type,
+	tone: mark.tone ?? "neutral"
+};
+/**
+* Reads a calculated value's formula and finds its fields by name (or by
+* label). Throws a `PivotFormulaError` when it is not well formed, names a
+* field that is not there, or sums up one that is not a number.
+*/
+function checkPivotFormula(source, text) {
+	const formula = parsePivotFormula(text);
+	const byLabel = /* @__PURE__ */ new Map();
+	for (const f of source.fields.values()) if (!byLabel.has(f.label)) byLabel.set(f.label, f.name);
+	for (const term of formula.terms) {
+		if (term.field === null) continue;
+		const name = source.fields.has(term.field) ? term.field : byLabel.get(term.field);
+		if (name === void 0) {
+			const at = text.indexOf(term.field);
+			throw new PivotFormulaError("unknownField", Math.max(0, at), term.field);
+		}
+		if (term.aggregate !== "count" && source.field(name).type !== "number") throw new PivotFormulaError("notNumber", Math.max(0, text.indexOf(term.field)), term.field);
+		term.field = name;
+	}
+	return formula;
+}
+/** The fields of the config resolved against a source, without reading any records. */
+function resolveConfig(source, config, options = {}) {
+	const level = (item) => {
+		const spec = typeof item === "string" ? { field: item } : item;
+		return {
+			field: source.field(spec.field),
+			sort: spec.sort ?? "asc",
+			subtotal: spec.subtotal ?? true,
+			by: spec.by
+		};
+	};
+	const formulas = [];
+	const values = (config.values ?? []).map((item) => {
+		const spec = typeof item === "string" ? { field: item } : item;
+		const show = showOf(spec.show);
+		const mark = markOf(spec.mark);
+		const ownFormat = show && (PERCENT_SHOWS.has(show.as) || show.as === "rank");
+		if (spec.formula !== void 0) {
+			formulas.push(checkPivotFormula(source, spec.formula));
+			return {
+				field: null,
+				aggregate: "formula",
+				label: spec.label,
+				format: spec.format,
+				integer: false,
+				formula: spec.formula,
+				...show ? { show } : {},
+				...mark ? { mark } : {}
+			};
+		}
+		formulas.push(null);
+		const field = spec.field === void 0 ? null : source.field(spec.field);
+		let name = spec.aggregate ?? (field?.type === "number" ? "sum" : "count");
+		if (!field && name !== "count") name = "count";
+		const aggregator = FAST_AGGREGATES.has(name) ? void 0 : options.aggregators?.[name] ?? BUILTIN_AGGREGATORS[name];
+		if (!FAST_AGGREGATES.has(name) && !aggregator) throw new Error(`[@dou-ui/pivot] there is no aggregate named "${name}"`);
+		return {
+			field,
+			aggregate: name,
+			aggregator,
+			label: spec.label,
+			format: spec.format ?? (ownFormat ? void 0 : field?.format),
+			integer: name === "count" || !!aggregator?.integer,
+			...show ? { show } : {},
+			...mark ? { mark } : {}
+		};
+	});
+	if (values.length === 0) {
+		values.push({
+			field: null,
+			aggregate: "count",
+			integer: true,
+			implicit: true
+		});
+		formulas.push(null);
+	}
+	return {
+		rows: (config.rows ?? []).map(level),
+		columns: (config.columns ?? []).map(level),
+		values,
+		formulas
+	};
+}
+/**
+* Groups the records by the config's row and column fields and sums up
+* its values for every group, subtotal and total.
+*
+* Each record is placed once, in its innermost row group and innermost
+* column group; the values are summed per such pair, and every subtotal
+* is then merged from those pairs, never from the records again.
+*/
+function computePivot(source, config, options = {}) {
+	const src = source;
+	if (Object.values(config.filters ?? {}).some((f) => f.top || f.between)) return computePivot(source, {
+		...config,
+		filters: rankedFilters(src, config, options)
+	}, options);
+	const resolved = resolveConfig(src, config, options);
+	const rowLevels = resolved.rows.map((l) => ({
+		...l,
+		column: src.dimension(l.field.name, l.by)
+	}));
+	const colLevels = resolved.columns.map((l) => ({
+		...l,
+		column: src.dimension(l.field.name, l.by)
+	}));
+	const n = source.length;
+	const rowTree = new PivotTreeBuilder(stride(rowLevels));
+	const colTree = new PivotTreeBuilder(stride(colLevels));
+	const rowCodes = rowLevels.map((l) => l.column.codes);
+	const colCodes = colLevels.map((l) => l.column.codes);
+	const width = n * Math.max(1, colLevels.length) + 2;
+	const filters = Object.entries(config.filters ?? {}).flatMap(([name, filter]) => {
+		if (!filter.include && !filter.exclude) return [];
+		const by = filter.by ?? [...resolved.rows, ...resolved.columns].find((l) => l.field.name === name)?.by;
+		const column = src.dimension(name, by);
+		const allow = new Uint8Array(column.labels.length).fill(filter.include ? 0 : 1);
+		for (const value of filter.include ?? []) {
+			const code = column.find(value);
+			if (code >= 0) allow[code] = 1;
+		}
+		for (const value of filter.exclude ?? []) {
+			const code = column.find(value);
+			if (code >= 0) allow[code] = 0;
+		}
+		return [{
+			codes: column.codes,
+			allow
+		}];
+	});
+	const slotOf = new Int32Array(n);
+	const cells = new IntIndex(1024);
+	let matched = 0;
+	const rowCards = rowLevels.map((l) => l.column.labels.length);
+	const colCards = colLevels.map((l) => l.column.labels.length);
+	const rowSpace = rowCards.reduce((a, b) => a * b, 1);
+	const colSpace = colCards.reduce((a, b) => a * b, 1);
+	const skip = (i) => {
+		for (let f = 0; f < filters.length; f++) {
+			const filter = filters[f];
+			if (filter.allow[filter.codes[i]] === 0) return true;
+		}
+		return false;
+	};
+	if (rowSpace * colSpace <= Number.MAX_SAFE_INTEGER) {
+		const space = rowSpace * colSpace;
+		const dense = space <= DENSE_PAIRS ? new Int32Array(space).fill(-1) : null;
+		const index = dense ? null : new IntIndex(1024);
+		let pairRow = /* @__PURE__ */ new Float64Array(1024);
+		let pairCol = /* @__PURE__ */ new Float64Array(1024);
+		let pairs = 0;
+		for (let i = 0; i < n; i++) {
+			if (filters.length && skip(i)) {
+				slotOf[i] = -1;
+				continue;
+			}
+			let rk = 0;
+			for (let d = 0; d < rowCodes.length; d++) rk = rk * rowCards[d] + rowCodes[d][i];
+			let ck = 0;
+			for (let d = 0; d < colCodes.length; d++) ck = ck * colCards[d] + colCodes[d][i];
+			const key = rk * colSpace + ck;
+			let slot;
+			if (dense) {
+				slot = dense[key];
+				if (slot < 0) slot = dense[key] = pairs;
+			} else slot = index.add(key);
+			if (slot === pairs) {
+				if (pairs === pairRow.length) {
+					const grownRow = new Float64Array(pairs * 2);
+					grownRow.set(pairRow);
+					pairRow = grownRow;
+					const grownCol = new Float64Array(pairs * 2);
+					grownCol.set(pairCol);
+					pairCol = grownCol;
+				}
+				pairRow[pairs] = rk;
+				pairCol[pairs] = ck;
+				pairs++;
+			}
+			slotOf[i] = slot;
+			matched++;
+		}
+		const rowLeaf = /* @__PURE__ */ new Map();
+		const colLeaf = /* @__PURE__ */ new Map();
+		const rowDigits = new Int32Array(rowCards.length);
+		const colDigits = new Int32Array(colCards.length);
+		for (let p = 0; p < pairs; p++) {
+			const row = leaf(pairRow[p], rowLeaf, rowTree, rowCards, rowDigits);
+			const col = leaf(pairCol[p], colLeaf, colTree, colCards, colDigits);
+			cells.add(row * width + col);
+		}
+	} else for (let i = 0; i < n; i++) {
+		if (filters.length && skip(i)) {
+			slotOf[i] = -1;
+			continue;
+		}
+		let row = 0;
+		for (let d = 0; d < rowCodes.length; d++) row = rowTree.child(row, rowCodes[d][i]);
+		let col = 0;
+		for (let d = 0; d < colCodes.length; d++) col = colTree.child(col, colCodes[d][i]);
+		slotOf[i] = cells.add(row * width + col);
+		matched++;
+	}
+	const leaves = cells.size;
+	const rowDepth = rowLevels.length;
+	const colDepth = colLevels.length;
+	const fan = (rowDepth + 1) * (colDepth + 1) - 1;
+	const targets = new Int32Array(leaves * fan);
+	const rowUp = new Int32Array(rowDepth + 1);
+	const colUp = new Int32Array(colDepth + 1);
+	const leafRow = new Int32Array(leaves);
+	const leafCol = new Int32Array(leaves);
+	for (let s = 0; s < leaves; s++) {
+		const key = cells.keys[s];
+		const row = Math.floor(key / width);
+		const col = key - row * width;
+		leafRow[s] = row;
+		leafCol[s] = col;
+		for (let d = 0, at = row; d <= rowDepth; d++, at = rowTree.parent[at]) rowUp[d] = at;
+		for (let d = 0, at = col; d <= colDepth; d++, at = colTree.parent[at]) colUp[d] = at;
+		let k = s * fan;
+		for (let a = 0; a <= rowDepth; a++) for (let b = 0; b <= colDepth; b++) {
+			if (a === 0 && b === 0) continue;
+			targets[k++] = cells.add(rowUp[a] * width + colUp[b]);
+		}
+	}
+	const size = cells.size;
+	const sum = (value) => aggregate(src, value, slotOf, leaves, size, targets, fan);
+	const data = resolved.values.map((value, i) => {
+		const formula = resolved.formulas[i];
+		return formula ? calculate(src, formula, sum, size) : sum(value);
+	});
+	return new PivotResult({
+		rows: new PivotTree(rowTree, rowLevels),
+		columns: new PivotTree(colTree, colLevels),
+		values: resolved.values,
+		matched,
+		cells,
+		width,
+		data,
+		slotOf,
+		leafRow,
+		leafCol
+	});
+}
+/**
+* The filters with `top` and `between` turned into lists of the groups they
+* keep: each field's groups are summed up once on their own, over the
+* records that the `include` and `exclude` lists keep.
+*/
+function rankedFilters(source, config, options) {
+	const given = config.filters ?? {};
+	const plain = {};
+	for (const [name, f] of Object.entries(given)) if (f.include || f.exclude) plain[name] = {
+		include: f.include,
+		exclude: f.exclude,
+		by: f.by
+	};
+	const out = { ...plain };
+	const axes = [...config.rows ?? [], ...config.columns ?? []];
+	for (const [name, f] of Object.entries(given)) {
+		if (!f.top && !f.between) continue;
+		const onAxis = axes.find((d) => typeof d === "object" && d.field === name);
+		const by = f.by ?? (typeof onAxis === "object" ? onAxis.by : void 0);
+		const index = f.top?.valueIndex ?? f.between?.valueIndex ?? 0;
+		const value = config.values?.[index];
+		const plainValue = value === void 0 ? [] : [typeof value === "string" ? value : {
+			...value,
+			show: void 0
+		}];
+		const totals = computePivot(source, {
+			rows: [{
+				field: name,
+				by,
+				subtotal: false
+			}],
+			values: plainValue,
+			filters: plain
+		}, options);
+		const tree = totals.rows;
+		let groups = [];
+		for (let k = tree.childStart[0]; k < tree.childStart[1]; k++) {
+			const node = tree.children[k];
+			groups.push({
+				label: tree.label(node),
+				total: totals.get(node, 0)
+			});
+		}
+		if (f.between) {
+			const { min = -Infinity, max = Infinity } = f.between;
+			groups = groups.filter((g) => g.total >= min && g.total <= max);
+		}
+		if (f.top) {
+			const sign = f.top.order === "asc" ? 1 : -1;
+			const ranked = groups.filter((g) => g.total === g.total);
+			ranked.sort((a, b) => sign * (a.total - b.total));
+			groups = ranked.slice(0, Math.max(0, f.top.count));
+		}
+		out[name] = {
+			include: groups.map((g) => g.label),
+			by
+		};
+	}
+	return out;
+}
+/** A calculated value: each term summed up as usual, then the formula per cell. */
+function calculate(source, formula, sum, size) {
+	const columns = formula.terms.map((term) => sum({
+		field: term.field === null ? null : source.field(term.field),
+		aggregate: term.aggregate,
+		integer: term.aggregate === "count"
+	}));
+	const out = new Float64Array(size);
+	const values = new Float64Array(columns.length);
+	for (let s = 0; s < size; s++) {
+		for (let t = 0; t < columns.length; t++) values[t] = columns[t][s];
+		out[s] = formula.evaluate(values);
+	}
+	return out;
+}
+/** More than any group number of the axis, so (parent, group) makes a unique key. */
+var stride = (levels) => Math.max(1, ...levels.map((l) => l.column.labels.length)) + 1;
+/** The innermost group whose group numbers are the digits of `key`, made when new. */
+function leaf(key, memo, tree, cards, digits) {
+	let node = memo.get(key);
+	if (node !== void 0) return node;
+	for (let d = cards.length - 1, rest = key; d >= 0; d--) {
+		const card = cards[d];
+		const digit = rest % card;
+		digits[d] = digit;
+		rest = (rest - digit) / card;
+	}
+	node = 0;
+	for (let d = 0; d < cards.length; d++) node = tree.child(node, digits[d]);
+	memo.set(key, node);
+	return node;
+}
+/** Pairs of innermost groups up to this many are found in a plain array instead of a hash. */
+var DENSE_PAIRS = 1 << 22;
+/** One value for every cell: summed per innermost pair, then merged up into the totals. */
+function aggregate(source, value, slotOf, leaves, size, targets, fan) {
+	const n = slotOf.length;
+	const out = new Float64Array(size);
+	const kind = value.aggregate;
+	const roll = (fn) => {
+		for (let s = 0; s < leaves; s++) {
+			const base = s * fan;
+			for (let k = 0; k < fan; k++) fn(targets[base + k], s);
+		}
+	};
+	if (kind === "count") {
+		if (value.field) {
+			const { codes, empty } = source.dimension(value.field.name);
+			for (let i = 0; i < n; i++) {
+				const s = slotOf[i];
+				if (s >= 0 && codes[i] !== empty) out[s]++;
+			}
+		} else for (let i = 0; i < n; i++) {
+			const s = slotOf[i];
+			if (s >= 0) out[s]++;
+		}
+		roll((t, s) => out[t] += out[s]);
+		return out;
+	}
+	if (FAST_AGGREGATES.has(kind)) {
+		const values = source.measure(value.field.name);
+		if (kind === "min" || kind === "max") {
+			out.fill(NaN);
+			const max = kind === "max";
+			for (let i = 0; i < n; i++) {
+				const s = slotOf[i];
+				const v = values[i];
+				if (s < 0 || v !== v) continue;
+				const at = out[s];
+				if (max ? !(at >= v) : !(at <= v)) out[s] = v;
+			}
+			roll((t, s) => {
+				const v = out[s];
+				if (v !== v) return;
+				const at = out[t];
+				if (max ? !(at >= v) : !(at <= v)) out[t] = v;
+			});
+			return out;
+		}
+		const count = new Float64Array(size);
+		for (let i = 0; i < n; i++) {
+			const s = slotOf[i];
+			const v = values[i];
+			if (s < 0 || v !== v) continue;
+			out[s] += v;
+			count[s]++;
+		}
+		roll((t, s) => {
+			out[t] += out[s];
+			count[t] += count[s];
+		});
+		for (let s = 0; s < size; s++) {
+			const c = count[s];
+			out[s] = c === 0 ? NaN : kind === "avg" ? out[s] / c : out[s];
+		}
+		return out;
+	}
+	const aggregator = value.aggregator;
+	const field = value.field;
+	const states = Array.from({ length: size });
+	const { init, merge } = aggregator;
+	const add = aggregator.add;
+	if (aggregator.input === "number") {
+		const values = source.measure(field.name);
+		for (let i = 0; i < n; i++) {
+			const s = slotOf[i];
+			const v = values[i];
+			if (s < 0 || v !== v) continue;
+			states[s] = add(states[s] ?? init(), v);
+		}
+	} else {
+		const { codes, labels, empty } = source.dimension(field.name);
+		const byCode = aggregator === distinctAggregator;
+		for (let i = 0; i < n; i++) {
+			const s = slotOf[i];
+			const code = codes[i];
+			if (s < 0 || code === empty) continue;
+			states[s] = add(states[s] ?? init(), byCode ? code : labels[code]);
+		}
+	}
+	roll((t, s) => {
+		const from = states[s];
+		if (from !== void 0) states[t] = merge(states[t] ?? init(), from);
+	});
+	const { result } = aggregator;
+	for (let s = 0; s < size; s++) {
+		const state = states[s];
+		out[s] = state === void 0 ? NaN : result(state) ?? NaN;
+	}
+	return out;
+}
+var plainArray = (a) => Array.from(a);
+/** A packet with plain arrays in place of typed ones, ready for JSON. */
+function toPlain(packet) {
+	const tree = (t) => ({
+		...t,
+		parent: plainArray(t.parent),
+		depth: plainArray(t.depth),
+		code: plainArray(t.code),
+		childStart: plainArray(t.childStart),
+		children: plainArray(t.children),
+		enter: plainArray(t.enter),
+		exit: plainArray(t.exit),
+		index: index(t.index),
+		levels: t.levels.map((l) => ({
+			...l,
+			rank: plainArray(l.rank)
+		}))
+	});
+	const index = (i) => ({
+		size: i.size,
+		table: plainArray(i.table),
+		ids: plainArray(i.ids),
+		keys: plainArray(i.keys).slice(0, i.size)
+	});
+	return {
+		...packet,
+		rows: tree(packet.rows),
+		columns: tree(packet.columns),
+		cells: index(packet.cells),
+		data: packet.data.map((d) => Array.from(d, (v) => v === v ? v : null)),
+		slotOf: plainArray(packet.slotOf),
+		leafRow: plainArray(packet.leafRow),
+		leafCol: plainArray(packet.leafCol)
+	};
+}
+/** The groups on both axes and every cell's values. */
+var PivotResult = class PivotResult {
+	rows;
+	columns;
+	values;
+	/** How many records passed the filters. */
+	matched;
+	cells;
+	width;
+	data;
+	/** Each record's innermost cell, -1 when filtered out; and each such cell's groups. */
+	slotOf;
+	leafRow;
+	leafCol;
+	constructor(init) {
+		this.rows = init.rows;
+		this.columns = init.columns;
+		this.values = init.values;
+		this.matched = init.matched;
+		this.cells = init.cells;
+		this.width = init.width;
+		this.data = init.data;
+		this.slotOf = init.slotOf;
+		this.leafRow = init.leafRow;
+		this.leafCol = init.leafCol;
+	}
+	/**
+	* The result as data, to send from a worker or a server. With `plain`,
+	* plain arrays for `JSON.stringify` (typed arrays do not survive it);
+	* empty cells go as `null`.
+	*/
+	pack({ plain = false } = {}) {
+		const packet = this.packTyped();
+		return plain ? toPlain(packet) : packet;
+	}
+	packTyped() {
+		return {
+			rows: this.rows.pack(),
+			columns: this.columns.pack(),
+			values: this.values.map((v) => ({
+				field: v.field?.name ?? null,
+				aggregate: v.aggregate,
+				integer: v.integer,
+				...v.implicit ? { implicit: true } : {},
+				...v.label === void 0 ? {} : { label: v.label },
+				...v.formula === void 0 ? {} : { formula: v.formula },
+				...v.show ? { show: v.show } : {},
+				...v.mark ? { mark: v.mark } : {}
+			})),
+			matched: this.matched,
+			cells: this.cells.pack(),
+			width: this.width,
+			data: this.data,
+			slotOf: this.slotOf,
+			leafRow: this.leafRow,
+			leafCol: this.leafCol
+		};
+	}
+	/** The typed arrays in a packet, to move them instead of copying (`postMessage`'s transfer list). */
+	static transferables(packet) {
+		const out = /* @__PURE__ */ new Set();
+		const add = (a) => {
+			if (ArrayBuffer.isView(a) && a.buffer instanceof ArrayBuffer) out.add(a.buffer);
+		};
+		for (const tree of [packet.rows, packet.columns]) {
+			for (const a of [
+				tree.parent,
+				tree.depth,
+				tree.code,
+				tree.childStart,
+				tree.children
+			]) add(a);
+			for (const a of [
+				tree.enter,
+				tree.exit,
+				tree.index.table,
+				tree.index.ids,
+				tree.index.keys
+			]) add(a);
+		}
+		for (const a of [
+			packet.cells.table,
+			packet.cells.ids,
+			packet.cells.keys
+		]) add(a);
+		for (const a of [
+			...packet.data,
+			packet.slotOf,
+			packet.leafRow,
+			packet.leafCol
+		]) add(a);
+		return [...out];
+	}
+	/**
+	* A result made from `pack()`'s output. Fields are described by
+	* `source` (no record is read), formats come from `config`.
+	*/
+	static unpack(packet, source, config) {
+		const field = (name) => source.field(name);
+		const given = config?.values ?? [];
+		return new PivotResult({
+			rows: PivotTree.unpack(packet.rows, field),
+			columns: PivotTree.unpack(packet.columns, field),
+			values: packet.values.map((v, i) => {
+				const f = v.field === null ? null : field(v.field);
+				const spec = v.implicit ? void 0 : given[i];
+				const format = typeof spec === "object" ? spec.format : void 0;
+				const own = v.formula !== void 0 || v.show && (PERCENT_SHOWS.has(v.show.as) || v.show.as === "rank");
+				return {
+					...v,
+					field: f,
+					format: format ?? (own ? void 0 : f?.format)
+				};
+			}),
+			matched: packet.matched,
+			cells: IntIndex.unpack(packet.cells),
+			width: packet.width,
+			data: packet.data.map((d) => d instanceof Float64Array ? d : Float64Array.from(d, (v) => v ?? NaN)),
+			slotOf: typed(Int32Array, packet.slotOf),
+			leafRow: typed(Int32Array, packet.leafRow),
+			leafCol: typed(Int32Array, packet.leafCol)
+		});
+	}
+	showing = /* @__PURE__ */ new Map();
+	ranges = /* @__PURE__ */ new Map();
+	shownBy(valueIndex, show) {
+		const spec = show === void 0 ? this.values[valueIndex]?.show : show;
+		const key = `${valueIndex}|${spec ? `${spec.as}|${spec.axis ?? ""}` : ""}`;
+		let shown = this.showing.get(key);
+		if (shown === void 0) {
+			shown = spec ? new PivotShown(resolveShow(spec, this.rows, this.columns), this.rows, this.columns, (r, c) => this.get(r, c, valueIndex)) : null;
+			this.showing.set(key, shown);
+		}
+		return shown;
+	}
+	/**
+	* How a value is shown, its `show` with the axis worked out; null when as
+	* it is. `show` stands in for the value's own (`null` for none).
+	*/
+	show(valueIndex = 0, show) {
+		return this.shownBy(valueIndex, show)?.show ?? null;
+	}
+	/**
+	* The value as it is shown: a share, a difference, a running total or a
+	* rank when the value has a `show` (or one is given), the summed-up value
+	* otherwise. Nothing is summed up again.
+	*/
+	shown(row, column, valueIndex = 0, show) {
+		const shown = this.shownBy(valueIndex, show);
+		return shown ? shown.value(row, column) : this.get(row, column, valueIndex);
+	}
+	/**
+	* The smallest and largest shown values of the innermost cells (those
+	* under no subtotal or total), which marks are drawn against.
+	*/
+	range(valueIndex = 0, show) {
+		const spec = show === void 0 ? this.values[valueIndex]?.show : show;
+		const key = `${valueIndex}|${spec ? `${spec.as}|${spec.axis ?? ""}` : ""}`;
+		let range = this.ranges.get(key);
+		if (!range) {
+			const { rows, columns, cells, width } = this;
+			const rowDepth = rows.levels.length;
+			const colDepth = columns.levels.length;
+			let min = Infinity;
+			let max = -Infinity;
+			for (let s = 0; s < cells.size; s++) {
+				const cell = cells.keys[s];
+				const row = Math.floor(cell / width);
+				const col = cell - row * width;
+				if (rows.depth[row] !== rowDepth || columns.depth[col] !== colDepth) continue;
+				const v = this.shown(row, col, valueIndex, spec ?? null);
+				if (v !== v) continue;
+				if (v < min) min = v;
+				if (v > max) max = v;
+			}
+			range = min > max ? {
+				min: NaN,
+				max: NaN
+			} : {
+				min,
+				max
+			};
+			this.ranges.set(key, range);
+		}
+		return range;
+	}
+	/**
+	* The value at `valueIndex` (its place in `values`) of a row group and a
+	* column group; `NaN` when no record falls in both. The trees' `total`
+	* is the grand total.
+	*/
+	get(row, column, valueIndex = 0) {
+		const slot = this.cells.get(row * this.width + column);
+		return slot < 0 ? NaN : this.data[valueIndex][slot];
+	}
+	/** The indexes of the records in a row group and a column group, for showing the details. */
+	indices(row, column) {
+		const { slotOf, leafRow, leafCol, rows, columns } = this;
+		const inside = new Uint8Array(leafRow.length);
+		for (let s = 0; s < leafRow.length; s++) inside[s] = rows.within(leafRow[s], row) && columns.within(leafCol[s], column) ? 1 : 0;
+		const out = [];
+		for (let i = 0; i < slotOf.length; i++) {
+			const s = slotOf[i];
+			if (s >= 0 && inside[s]) out.push(i);
+		}
+		return out;
+	}
+	/**
+	* The children of every row group, reordered by a column's values (or as
+	* they are when `sort` is empty). Nothing is summed up again.
+	*/
+	rowOrder(sort) {
+		const { rows } = this;
+		if (!sort || !this.data[sort.valueIndex]) return rows.children;
+		const column = this.columns.find(sort.column ?? []);
+		if (column < 0) return rows.children;
+		const children = rows.children.slice();
+		const keys = new Float64Array(rows.size);
+		for (let node = 0; node < rows.size; node++) keys[node] = this.get(node, column, sort.valueIndex);
+		const sign = sort.order === "desc" ? -1 : 1;
+		const place = new Int32Array(rows.size);
+		rows.children.forEach((node, at) => place[node] = at);
+		for (let node = 0; node < rows.size; node++) {
+			const from = rows.childStart[node];
+			const to = rows.childStart[node + 1];
+			if (to - from < 2) continue;
+			children.subarray(from, to).sort((a, b) => {
+				const ka = keys[a];
+				const kb = keys[b];
+				if (ka !== ka || kb !== kb) return ka !== ka ? kb !== kb ? place[a] - place[b] : 1 : -1;
+				return ka === kb ? place[a] - place[b] : sign * (ka - kb);
+			});
+		}
+		return children;
+	}
+};
+export { PERCENT_SHOWS, PivotResult, checkPivotFormula, computePivot, markOf, resolveConfig, showOf };
+
+//# sourceMappingURL=compute.js.map