@sophistry/charts 0.0.0-stage → 0.0.1

package/dist/math/aggregate.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Reducers and per-series maps: the arithmetic behind the `group`, `bin`,
+ * `rolling` and `normalize` transforms. Arrays of numbers in, numbers out.
+ */
+/**
+ * How a set of values becomes one number. Every reducer but `"count"` (which
+ * counts rows) drops non-finite values first. An empty set reduces to `NaN`
+ * (0 for `"count"` and `"sum"`).
+ *
+ * @category Math & helpers
+ */
+export type ReducerName = "count" | "sum" | "mean" | "median" | "min" | "max" | "first" | "last" | "deviation" | "variance";
+/**
+ * A named reducer, or your own function of the values.
+ *
+ * @category Math & helpers
+ */
+export type Reducer = ReducerName | ((values: number[]) => number);
+/**
+ * Reduces `values` to one number; see {@link ReducerName}.
+ *
+ * @category Math & helpers
+ */
+export declare function reduceValues(values: readonly number[], reducer: Reducer): number;
+/** @category Math */
+export interface RollingOptions {
+    /** Window size, in values. @default 3 */
+    k?: number;
+    /**
+     * Where each value sits in its window: `"middle"` (centred), `"start"`
+     * (looking ahead) or `"end"` (trailing).
+     * @default "middle"
+     */
+    anchor?: "start" | "middle" | "end";
+    /** @default "mean" */
+    reduce?: Reducer;
+    /**
+     * Only reduce full windows of finite values (elsewhere `NaN`). Off, windows
+     * cut short or holding non-finite values reduce what they have.
+     * @default false
+     */
+    strict?: boolean;
+}
+/**
+ * A moving-window reduction of `values`, a rolling mean by default.
+ *
+ * @returns One value per input value.
+ * @category Math & helpers
+ */
+export declare function rollingValues(values: readonly number[], options?: RollingOptions): number[];
+/**
+ * What {@link normalizeValues} divides by: `"first"` (growth from the first
+ * value), `"last"`, `"sum"`, `"mean"`, `"median"`, `"min"` or `"max"`;
+ * `"extent"` rescales min..max to 0..1; `"deviation"` gives z-scores; a
+ * number divides by itself.
+ *
+ * @category Math & helpers
+ */
+export type NormalizeBasis = "first" | "last" | "sum" | "mean" | "median" | "min" | "max" | "extent" | "deviation" | number;
+/**
+ * Normalizes a series against a basis. Non-finite values, and every value
+ * under a zero or non-finite basis, become `NaN`.
+ *
+ * @param basis - Defaults to `"first"`.
+ * @returns One value per input value.
+ * @category Math & helpers
+ */
+export declare function normalizeValues(values: readonly number[], basis?: NormalizeBasis): number[];
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/math/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../src/math/aggregate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GACpB,OAAO,GACP,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,GACL,KAAK,GACL,OAAO,GACP,MAAM,GACN,WAAW,GACX,UAAU,CAAC;AAEd;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG,WAAW,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC,CAAC;AAEnE;;;;GAIG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,EAAE,OAAO,GACd,MAAM,CAyBR;AAED,qBAAqB;AACrB,MAAM,WAAW,cAAc;IAC9B,yCAAyC;IACzC,CAAC,CAAC,EAAE,MAAM,CAAC;IACX;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;IACpC,sBAAsB;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,cAAmB,GAC1B,MAAM,EAAE,CAoBV;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GACvB,OAAO,GACP,MAAM,GACN,KAAK,GACL,MAAM,GACN,QAAQ,GACR,KAAK,GACL,KAAK,GACL,QAAQ,GACR,WAAW,GACX,MAAM,CAAC;AAEV;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,KAAK,GAAE,cAAwB,GAC7B,MAAM,EAAE,CAgBV"}

package/dist/math/bar.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A bar's box in data space: slot `index` occupies `[index, index + 1]`, the
+ * bar `barWidth` of it, centred.
+ *
+ * @category Math & helpers
+ */
+export interface BarSlotBox {
+    /** The bar's x extent (not the whole slot): `barWidth` wide, centred on the slot. */
+    x0: number;
+    x1: number;
+    /** The bar's y extent, sorted from `baseline` and `value`, so a negative value hangs below the baseline. */
+    y0: number;
+    y1: number;
+}
+/**
+ * Bar width as a fraction of the slot.
+ *
+ * @category Math & helpers
+ */
+export declare const DEFAULT_BAR_WIDTH = 0.6;
+/**
+ * One bar's box in data space at full height: `barWidth` of slot `[index,
+ * index + 1]`, centred at `index + 0.5`, spanning `baseline` to `value` in
+ * either order.
+ *
+ * @param baseline - The value the bar stands on (usually 0).
+ * @param barWidth - Fraction of the slot. Defaults to {@link DEFAULT_BAR_WIDTH}.
+ * @returns The box, or `null` when `value` is not finite.
+ * @category Math & helpers
+ */
+export declare function barSlot(index: number, value: number, baseline: number, barWidth?: number): BarSlotBox | null;
+//# sourceMappingURL=bar.d.ts.map

package/dist/math/bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bar.d.ts","sourceRoot":"","sources":["../../src/math/bar.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,UAAU;IAC1B,qFAAqF;IACrF,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,4GAA4G;IAC5G,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACX;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CACtB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,QAAQ,SAAoB,GAC1B,UAAU,GAAG,IAAI,CAUnB"}

package/dist/math/barLabels.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Where a bar's value label goes, in scene units: centred inside the bar
+ * and whether it fits there, and which bar of a stack carries the stack's
+ * total past its outer end.
+ *
+ * @category Math & helpers
+ */
+import type { Bounds } from "@sophistry/core/geometry";
+/** A label's size in scene units: its advance width and ink height. */
+export interface BarLabelSize {
+    width: number;
+    height: number;
+}
+/** How far past first fitting (as a fraction of the label's length) the bar grows before its label is fully opaque. */
+export declare const INSIDE_LABEL_FADE = 0.5;
+/**
+ * How visible a label centred inside a bar is, 0..1: 0 while the bar is too
+ * small for the label plus `pad`, rising to 1 as it grows past that, and 1
+ * at full length whenever the label fits. A label never shows ahead of its
+ * growing segment.
+ *
+ * @param box - The bar now (mid-reveal or mid-transition).
+ * @param rest - The bar at full length on this frame.
+ * @param pad - Room kept between the label and each edge.
+ * @param vertical - Whether the bar runs up the y axis.
+ * @category Math & helpers
+ */
+export declare function insideLabelFit(box: Bounds, rest: Bounds, size: BarLabelSize, pad: number, vertical: boolean): number;
+/**
+ * One bar's share in its stack's total: the total of its side of zero, and
+ * whether it is that side's outermost segment (the one the total is
+ * written past).
+ *
+ * @category Math & helpers
+ */
+export interface StackTotal {
+    /** The sum of the segments on this bar's side of zero, in data units. */
+    total: number;
+    /** Whether this bar ends its side of the stack. */
+    outer: boolean;
+}
+/**
+ * Each stacked bar's {@link StackTotal}: segments grouped by category and
+ * sign, each side's total carried by the segment reaching furthest its way.
+ * Zero and non-finite segments belong to no side (`undefined`).
+ *
+ * @param own - Each bar's own signed value.
+ * @param ends - Where each bar ends on the value axis (the stack's `y2`).
+ * @category Math & helpers
+ */
+export declare function stackTotals(categories: readonly unknown[], own: readonly number[], ends: readonly number[]): (StackTotal | undefined)[];
+/** What a bar's labels read from its dataset. */
+export interface BarLabelSide {
+    /** Each bar's own value (a stacked segment's, not where it ends). */
+    own: readonly number[];
+    /** Where each bar ends. */
+    values: readonly number[];
+    /** Where each bar starts, when not at the baseline. */
+    bases: readonly number[] | undefined;
+    stacked: boolean;
+    /** Whether the stack is of shares (`offset="normalize"`). */
+    normalized: boolean;
+    /** Each stacked bar's side of its stack's total. */
+    totals: readonly (StackTotal | undefined)[] | undefined;
+}
+/** The numbers a bar's labels write: its own (a share, when normalized) and its stack's total when it ends its side. @internal */
+export declare function barLabelValues(side: BarLabelSide, index: number): {
+    share: number;
+    total: number | undefined;
+};
+/** Two ends' label values blended at `u`; a total carried at only one end shows while that end is nearer. @internal */
+export declare function mixBarLabelValues(from: {
+    share: number;
+    total: number | undefined;
+}, to: {
+    share: number;
+    total: number | undefined;
+}, u: number): {
+    share: number;
+    total: number | undefined;
+};
+/** Decimal places a value is written with, so a counting label keeps one width (`"1.5e-7"` has 8). @internal */
+export declare function decimalsOf(value: number): number;
+//# sourceMappingURL=barLabels.d.ts.map

package/dist/math/barLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"barLabels.d.ts","sourceRoot":"","sources":["../../src/math/barLabels.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAIvD,uEAAuE;AACvE,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,uHAAuH;AACvH,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC7B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,GACf,MAAM,CAUR;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IAC1B,yEAAyE;IACzE,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,KAAK,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAC1B,UAAU,EAAE,SAAS,OAAO,EAAE,EAC9B,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,IAAI,EAAE,SAAS,MAAM,EAAE,GACrB,CAAC,UAAU,GAAG,SAAS,CAAC,EAAE,CAuB5B;AAED,iDAAiD;AACjD,MAAM,WAAW,YAAY;IAC5B,qEAAqE;IACrE,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IACvB,2BAA2B;IAC3B,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,uDAAuD;IACvD,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,6DAA6D;IAC7D,UAAU,EAAE,OAAO,CAAC;IACpB,oDAAoD;IACpD,MAAM,EAAE,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,EAAE,GAAG,SAAS,CAAC;CACxD;AAED,kIAAkI;AAClI,wBAAgB,cAAc,CAC7B,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,MAAM,GACX;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAU9C;AAED,uHAAuH;AACvH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,EAClD,EAAE,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,EAChD,CAAC,EAAE,MAAM,GACP;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAQ9C;AAED,gHAAgH;AAChH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIhD"}

package/dist/math/barbs.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Wind barb glyphs: a shaft with ticks near one end coding magnitude
+ * (pennant 50, full tick 10, half tick 5), built in a local frame (shaft
+ * along +x from the origin) for a caller to place, rotate and scale.
+ */
+import type { Point } from "@sophistry/core/geometry";
+/**
+ * One barb glyph: how many of each tick it decomposed to, and its geometry.
+ *
+ * @category Math & helpers
+ */
+export interface BarbGlyph {
+    pennants: number;
+    fullBarbs: number;
+    halfBarbs: number;
+    /** Polylines and polygons in the local frame: the shaft first, then each tick. */
+    segments: Point[][];
+}
+/** @category Math */
+export interface BarbGlyphOptions {
+    /** Shaft length, local units. @default 1 */
+    shaftLength?: number;
+    /** Spacing between successive ticks along the shaft. Defaults to `shaftLength / 6`. */
+    barbSpacing?: number;
+    /** Tick length, local units. Defaults to `shaftLength / 2`. */
+    barbLength?: number;
+}
+/**
+ * Local-frame geometry for a wind barb: a shaft from the origin to
+ * `(shaftLength, 0)` plus ticks stepping in from the far end, each at 45° on
+ * the `-y` side. Negative or `NaN` magnitudes draw a bare shaft (calm).
+ *
+ * @param magnitude - Wind speed in the tick values' units (conventionally knots).
+ * @category Math & helpers
+ */
+export declare function barbGlyph(magnitude: number, options?: BarbGlyphOptions): BarbGlyph;
+//# sourceMappingURL=barbs.d.ts.map

package/dist/math/barbs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"barbs.d.ts","sourceRoot":"","sources":["../../src/math/barbs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEtD;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,kFAAkF;IAClF,QAAQ,EAAE,KAAK,EAAE,EAAE,CAAC;CACpB;AAED,qBAAqB;AACrB,MAAM,WAAW,gBAAgB;IAChC,4CAA4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uFAAuF;IACvF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAuBD;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACxB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,gBAAqB,GAC5B,SAAS,CA8CX"}

package/dist/math/boxplot.d.ts

@@ -0,0 +1,37 @@
+/** Box-and-whisker statistics: quartiles, median, whiskers clipped to Tukey's fences, and outliers beyond them. */
+/** @category Math */
+export interface BoxplotStats {
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+    /** Lower whisker end — the smallest finite value still inside the fence. */
+    low: number;
+    /** Upper whisker end — the largest finite value still inside the fence. */
+    high: number;
+    /** Finite values outside `[q1 - whiskerScale * iqr, q3 + whiskerScale * iqr]`. */
+    outliers: number[];
+}
+/** @category Math */
+export interface BoxplotOptions {
+    /** How many IQRs past q1/q3 the whiskers may reach before a point is an outlier. @default 1.5 */
+    whiskerScale?: number;
+}
+/**
+ * `BoxplotOptions.whiskerScale`'s default.
+ *
+ * @category Math & helpers
+ */
+export declare const DEFAULT_WHISKER_SCALE = 1.5;
+/**
+ * Five-number summary of `values` by Tukey's rule: whiskers reach the most
+ * extreme value within `whiskerScale * iqr` of the box; anything further is
+ * an outlier.
+ *
+ * @param values - Raw samples; non-finite entries are dropped.
+ * @returns The summary, or `null` when no finite value remains.
+ * @category Math & helpers
+ */
+export declare function boxplotStats(values: readonly number[], options?: BoxplotOptions): BoxplotStats | null;
+//# sourceMappingURL=boxplot.d.ts.map

package/dist/math/boxplot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boxplot.d.ts","sourceRoot":"","sources":["../../src/math/boxplot.ts"],"names":[],"mappings":"AAAA,mHAAmH;AAKnH,qBAAqB;AACrB,MAAM,WAAW,YAAY;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,4EAA4E;IAC5E,GAAG,EAAE,MAAM,CAAC;IACZ,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,kFAAkF;IAClF,QAAQ,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,qBAAqB;AACrB,MAAM,WAAW,cAAc;IAC9B,iGAAiG;IACjG,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,cAAmB,GAC1B,YAAY,GAAG,IAAI,CA2BrB"}

package/dist/math/breadcrumbs.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Breadcrumbs for a drill-down: the trail of names from a hierarchy's root
+ * to the focused node, laid out left to right, with text widths from a
+ * `measure` callback. A trail may be a `{ from, to, t }` transition: shared
+ * crumbs stay put, others fade with their end's weight, so it scrubs.
+ */
+/**
+ * A focus path (names below the root: `[]` is the root, `["src", "lib"]`
+ * is "lib" inside "src"), or a scrubbable `{ from, to, t }` transition
+ * between two, either end possibly itself a transition. What
+ * {@link useDrillDown} produces and both a hierarchy chart's `focus` and
+ * {@link Breadcrumbs} take.
+ *
+ * @category Charts
+ */
+export type HierarchyPathSpec = readonly string[] | {
+    from: HierarchyPathSpec;
+    to: HierarchyPathSpec;
+    t: number;
+};
+/** Whether a path spec is a transition rather than a plain path. */
+export declare function isPathTransition(spec: HierarchyPathSpec): spec is Exclude<HierarchyPathSpec, readonly string[]>;
+/**
+ * One path of a (possibly nested) transition with its share of the blend.
+ *
+ * @category Math & helpers
+ */
+export interface WeightedPath {
+    path: readonly string[];
+    /** 0..1; the weights of one spec sum to 1. */
+    weight: number;
+}
+/** Whether two paths name the same node. */
+export declare function samePath(a: readonly string[], b: readonly string[]): boolean;
+/**
+ * A path spec as the paths it blends, each with its weight (equal paths
+ * merged, zero weights dropped, in first-seen order).
+ *
+ * @category Math & helpers
+ */
+export declare function flattenPathSpec(spec: HierarchyPathSpec): WeightedPath[];
+/**
+ * Where a path spec is heading: `to`'s path (recursively), or the plain path.
+ *
+ * @category Math & helpers
+ */
+export declare function pathTarget(spec: HierarchyPathSpec): readonly string[];
+/**
+ * One crumb of a laid-out trail. Offsets are from the trail's anchor, in
+ * the unit `measure` returned.
+ *
+ * @category Math & helpers
+ */
+export interface BreadcrumbItem {
+    /** Stable identity: the crumb's path, JSON-encoded (`"…"` for the ellipsis). */
+    key: string;
+    /** The crumb's own path below the root (`[]` for the root crumb); for the ellipsis, the deepest crumb it hides. */
+    path: string[];
+    /** The text shown (the root's name for the root crumb). */
+    name: string;
+    /** 0 for the root crumb, +1 per level (the ellipsis is 1). */
+    depth: number;
+    /** Left edge of the crumb's text. */
+    x: number;
+    /** Width of the crumb's text. */
+    width: number;
+    /** Centre of the separator drawn before this crumb (unused at depth 0). */
+    separatorX: number;
+    /** Presence, 0..1: the summed weight of the paths that show it. */
+    weight: number;
+    /** How much this crumb is the focused (last) one, 0..1, as a fraction of its own weight. */
+    current: number;
+    /** Whether this is the ellipsis standing for the crumbs collapsed out of the middle. */
+    ellipsis?: boolean;
+    /** For the ellipsis: the names it stands for, root side first (of its heaviest path). */
+    hidden?: string[];
+}
+/**
+ * The trail's "back" control, laid out before the root crumb.
+ *
+ * @category Math & helpers
+ */
+export interface BreadcrumbBack {
+    /** Left edge of the control. */
+    x: number;
+    /** Its width, as given. */
+    width: number;
+    /** Presence, 0..1: the weight of the paths below the root (none at the root). */
+    weight: number;
+    /** Where it goes: the parent of the path the spec is heading for; null when heading for the root. */
+    path: string[] | null;
+}
+/** @category Math */
+export interface BreadcrumbLayoutOptions {
+    /** The root crumb's text. */
+    root: string;
+    /** Width of a crumb's text. */
+    measure: (text: string) => number;
+    /** Width of the separator's text. */
+    separatorWidth: number;
+    /** Space each side of a separator. */
+    gap: number;
+    /** Where the anchor is on the trail. @default "left" */
+    align?: "left" | "center" | "right";
+    /**
+     * The widest a trail may be, back control included. Wider paths keep the
+     * root and as many last crumbs as fit, collapsing the rest into one
+     * ellipsis; root, ellipsis and last crumb always show. Omitted, never collapses.
+     */
+    maxWidth?: number;
+    /** The ellipsis's text. @default "…" */
+    ellipsis?: string;
+    /** Reserve room for a back control this wide before the root crumb (plus `2 × gap`). Omitted, none. */
+    backWidth?: number;
+}
+/**
+ * Lays out a path spec's crumbs: one per distinct prefix of every blended
+ * path, each placed after those before it on its own path. With
+ * `maxWidth`, paths too wide collapse their middle into an ellipsis whose
+ * `path` is the deepest crumb it hides.
+ *
+ * @category Math & helpers
+ */
+export declare function breadcrumbLayout(spec: HierarchyPathSpec, options: BreadcrumbLayoutOptions): {
+    items: BreadcrumbItem[];
+    width: number;
+    back?: BreadcrumbBack;
+};
+//# sourceMappingURL=breadcrumbs.d.ts.map

package/dist/math/breadcrumbs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breadcrumbs.d.ts","sourceRoot":"","sources":["../../src/math/breadcrumbs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAC1B,SAAS,MAAM,EAAE,GACjB;IACA,IAAI,EAAE,iBAAiB,CAAC;IACxB,EAAE,EAAE,iBAAiB,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;CACT,CAAC;AAEL,oEAAoE;AACpE,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,iBAAiB,GACrB,IAAI,IAAI,OAAO,CAAC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC,CAEvD;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;CACf;AAED,4CAA4C;AAC5C,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAE5E;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,iBAAiB,GAAG,YAAY,EAAE,CAgBvE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,iBAAiB,GAAG,SAAS,MAAM,EAAE,CAErE;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC9B,gFAAgF;IAChF,GAAG,EAAE,MAAM,CAAC;IACZ,mHAAmH;IACnH,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,4FAA4F;IAC5F,OAAO,EAAE,MAAM,CAAC;IAChB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yFAAyF;IACzF,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC9B,gCAAgC;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;IACf,qGAAqG;IACrG,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;CACtB;AAED,qBAAqB;AACrB,MAAM,WAAW,uBAAuB;IACvC,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAClC,qCAAqC;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,sCAAsC;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,wDAAwD;IACxD,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uGAAuG;IACvG,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAYD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,uBAAuB,GAC9B;IAAE,KAAK,EAAE,cAAc,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,cAAc,CAAA;CAAE,CAkJnE"}

package/dist/math/bubble.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Bubble sizing: values to marker radii with area, not radius, proportional
+ * to value (a viewer reads area).
+ */
+/**
+ * One radius per input value, parallel to `values`.
+ *
+ * @category Math & helpers
+ */
+export type BubbleRadii = number[];
+/** @category Math */
+export interface BubbleRadiusOptions {
+    /** Radius for a value of 0. @default 0 */
+    minRadius?: number;
+    /** Radius for `maxValue`. @default 1 */
+    maxRadius?: number;
+    /** The value that maps to `maxRadius`. Defaults to the greatest finite value in `values`. */
+    maxValue?: number;
+}
+/**
+ * Values to marker radii with area proportional to value:
+ * `minRadius + (maxRadius - minRadius) * sqrt(value / maxValue)`. When every
+ * value is 0, every radius is `minRadius`.
+ *
+ * @param values - One per marker; non-finite or negative entries clamp to 0.
+ * @returns One radius per value, in `minRadius`/`maxRadius`'s units.
+ * @category Math & helpers
+ */
+export declare function bubbleRadiusScale(values: readonly number[], options?: BubbleRadiusOptions): BubbleRadii;
+/**
+ * Reference values for a size key over `[0, maxValue]`: at most `count`
+ * round numbers above zero, the largest kept.
+ *
+ * @param count - Defaults to 3.
+ * @returns Ascending values in `(0, maxValue]`; empty when `maxValue` is not positive.
+ * @category Math & helpers
+ */
+export declare function bubbleLegendValues(maxValue: number, count?: number): number[];
+//# sourceMappingURL=bubble.d.ts.map

package/dist/math/bubble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bubble.d.ts","sourceRoot":"","sources":["../../src/math/bubble.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,EAAE,CAAC;AAEnC,qBAAqB;AACrB,MAAM,WAAW,mBAAmB;IACnC,0CAA0C;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAKD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,mBAAwB,GAC/B,WAAW,CAYb;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,MAAM,EAAE,CAcxE"}

package/dist/math/bullet.d.ts

@@ -0,0 +1,111 @@
+/** Bullet-chart geometry: one row's scale, qualitative bands, measure bar and target marker, as data values and as fractions of the row. */
+import type { Range } from "@sophistry/core/geometry";
+/**
+ * Options for {@link bulletDomain}.
+ *
+ * @category Math & helpers
+ */
+export interface BulletDomainOptions {
+    /**
+     * The scale's start, in data units. Defaults to 0, or below the smallest value when one is
+     * negative.
+     */
+    min?: number;
+    /**
+     * The scale's end, in data units. Defaults to the largest value (0 when every value is
+     * negative).
+     */
+    max?: number;
+    /** Round default ends out to tick values; an explicit `min`/`max` is kept. @default true */
+    nice?: boolean;
+    /** Roughly how many ticks the scale should offer. @default 5 */
+    targetTicks?: number;
+}
+/**
+ * The scale one bullet (or several sharing a scale) spans: from 0, or the
+ * smallest value when negative, to the largest, rounded out to ticks.
+ * Non-finite values are ignored; with nothing to fit it reads `0..1`.
+ *
+ * @param values - Everything the scale must show: values, targets, thresholds.
+ * @returns `[min, max, step]`, with `step` the tick spacing.
+ * @category Math & helpers
+ */
+export declare function bulletDomain(values: readonly number[], options?: BulletDomainOptions): Range;
+/**
+ * A stretch of a bullet's scale, in data units and as fractions of its
+ * length (0 at the scale's start, 1 at its end).
+ *
+ * @category Math & helpers
+ */
+export interface BulletSpan {
+    /** Start, in data units. */
+    from: number;
+    /** End, in data units. */
+    to: number;
+    /** `from` as a fraction of the scale, 0..1. */
+    startFraction: number;
+    /** `to` as a fraction of the scale, 0..1. */
+    endFraction: number;
+}
+/**
+ * One qualitative band of a bullet: a {@link BulletSpan} and its place in the
+ * input `ranges`.
+ *
+ * @category Math & helpers
+ */
+export interface BulletBand extends BulletSpan {
+    /** Position in the input `ranges` array: 0 is the worst band. */
+    index: number;
+}
+/**
+ * Options for {@link bulletRow}.
+ *
+ * @category Math & helpers
+ */
+export interface BulletRowOptions extends BulletDomainOptions {
+    /** The comparative measure the value is judged against, in data units. */
+    target?: number;
+    /**
+     * Qualitative thresholds in ascending order, each where a band ends:
+     * `[150, 225, 300]` is poor to 150, satisfactory to 225, good beyond. The
+     * last band runs on to the scale's end.
+     */
+    ranges?: readonly number[];
+    /** Use this scale as is, ignoring `min`, `max`, `nice` and `targetTicks`, so several bullets share one ({@link bulletDomain}). */
+    domain?: Range;
+}
+/**
+ * One bullet's resolved geometry.
+ *
+ * @category Math & helpers
+ */
+export interface BulletRowGeometry {
+    /** The scale, `[min, max, step]`. */
+    domain: Range;
+    /** Tick values along the scale, ascending. */
+    ticks: number[];
+    /** One band per input threshold, in input order (worst first). */
+    bands: BulletBand[];
+    /** Where the measure bar starts: 0, or the scale end nearest it when the scale has no zero. */
+    baseline: number;
+    /** Whether the scale contains zero, so the bar can grow from it (otherwise it fades in). */
+    zero: boolean;
+    /** The measure bar from `baseline` to the value (clamped to the scale), or null for a non-finite value. */
+    measure: BulletSpan | null;
+    /** The target (clamped to the scale) and its fraction, or null when there is none. */
+    target: {
+        value: number;
+        fraction: number;
+    } | null;
+}
+/**
+ * Resolves one bullet: scale (covering value, target and thresholds), ticks,
+ * bands, measure bar and target marker, clamped to the scale. Non-finite
+ * inputs drop their part; a bad threshold leaves an empty band so `index`
+ * stays aligned.
+ *
+ * @param value - The featured measure, in data units.
+ * @category Math & helpers
+ */
+export declare function bulletRow(value: number, options?: BulletRowOptions): BulletRowGeometry;
+//# sourceMappingURL=bullet.d.ts.map

package/dist/math/bullet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bullet.d.ts","sourceRoot":"","sources":["../../src/math/bullet.ts"],"names":[],"mappings":"AAAA,4IAA4I;AAE5I,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAMtD;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,4FAA4F;IAC5F,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,gEAAgE;IAChE,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,mBAAwB,GAC/B,KAAK,CAsBP;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IAC1B,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,+CAA+C;IAC/C,aAAa,EAAE,MAAM,CAAC;IACtB,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAW,SAAQ,UAAU;IAC7C,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAiB,SAAQ,mBAAmB;IAC5D,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,kIAAkI;IAClI,MAAM,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IACjC,qCAAqC;IACrC,MAAM,EAAE,KAAK,CAAC;IACd,8CAA8C;IAC9C,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,kEAAkE;IAClE,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,+FAA+F;IAC/F,QAAQ,EAAE,MAAM,CAAC;IACjB,4FAA4F;IAC5F,IAAI,EAAE,OAAO,CAAC;IACd,2GAA2G;IAC3G,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;IAC3B,sFAAsF;IACtF,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACnD;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACxB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,gBAAqB,GAC5B,iBAAiB,CA2DnB"}