@sophistry/charts 0.0.0-stage → 0.0.1

package/dist/hierarchy/treemap.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `treemap`: nested rectangles, each leaf's area proportional to its value.
+ *
+ * Every tile is one `rect` instance of one instances node, keyed by the
+ * node's path of names (so a keyed transition or a data change keeps each
+ * tile's item); per-tile picking, tooltips and drilling go through
+ * `event.item`. Names are `label` nodes, one per tile whose name fits.
+ */
+import type { Point } from "@sophistry/core/geometry";
+import type { RequiredUnless } from "../data/channels";
+import type { TreemapTile } from "../math/hierarchy";
+import type { HierarchyDrillProps } from "./drill";
+import type { HierarchyChartBaseProps, HierarchyFocusSpec, HierarchyTransitionProps } from "./shared";
+/** @category Charts */
+export interface TreemapBaseProps<T> extends HierarchyChartBaseProps<T>, HierarchyTransitionProps<T>, HierarchyDrillProps<T> {
+    /** Width of the whole treemap. */
+    width: number;
+    /** Height of the whole treemap. */
+    height: number;
+    /** Centre of the treemap. Defaults to the origin. */
+    center?: Point;
+    /**
+     * Tiling method. With a keyed transition (`to`), `"resquarify"` lays `to` out in `data`'s rows
+     * so every tile keeps its neighbours (no tiles cross mid-transition), at the cost of `blend =
+     * 1` not matching a fresh squarify of `to`.
+     * @default "squarify"
+     */
+    tile?: TreemapTile;
+    /**
+     * Gap between tiles, and between a group's edge and its tiles.
+     * @default 0.03
+     */
+    padding?: number;
+    /**
+     * Header strip at the top of every group, where its name is written when it fits. Defaults to
+     * `padding` (no header).
+     */
+    paddingTop?: number;
+    /**
+     * Zoom into a node: its tile fills the box while everything outside fades away. A path of names
+     * below the root (`["src"]`), a predicate, or `{ from, to, t }` for a scrubbable transition.
+     * Given, the chart is controlled: taps only call `onFocusChange`. Defaults to the root.
+     */
+    focus?: HierarchyFocusSpec<T>;
+}
+/**
+ * Props of {@link treemap}: `value` is required unless the tree's nodes are numbers.
+ *
+ * @category Charts
+ */
+export type TreemapProps<T> = TreemapBaseProps<T> & RequiredUnless<T, number, "value">;
+/**
+ * A treemap: nested rectangles, each leaf's area proportional to its value, squarified by
+ * default. Lays itself out in a `width × height` box; needs no `chart`. Leaves take their
+ * top-level branch's colour; names are written where they fit. Supports drill-down `focus` and
+ * keyed transitions. The tiles are one instances node (`event.item` picks a tile). See
+ * {@link treemapLayout} for the layout alone.
+ *
+ * @example
+ * ```ts
+ * import { treemap } from "@sophistry/charts";
+ *
+ * const files = {
+ * 	name: "repo",
+ * 	children: [
+ * 		{ name: "src", children: [{ name: "index.ts", size: 12 }, { name: "chart.ts", size: 30 }] },
+ * 		{ name: "README.md", size: 4 },
+ * 	],
+ * };
+ * treemap.create({ data: files, value: "size", label: "name", width: 8, height: 4, drill: true, tooltip: true });
+ * ```
+ *
+ * @see https://sophistry.dev/reference/chart-catalogue/#hierarchies
+ * @category Charts
+ */
+export declare const treemap: import("@sophistry/core").Definition<TreemapBaseProps<any>, import("@sophistry/core/internal").CompositeNode<TreemapBaseProps<any>>, keyof TreemapBaseProps<any>>;
+//# sourceMappingURL=treemap.d.ts.map

package/dist/hierarchy/treemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treemap.d.ts","sourceRoot":"","sources":["../../src/hierarchy/treemap.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAItD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAiB,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAMnD,OAAO,KAAK,EACX,uBAAuB,EACvB,kBAAkB,EAClB,wBAAwB,EACxB,MAAM,UAAU,CAAC;AAgBlB,uBAAuB;AACvB,MAAM,WAAW,gBAAgB,CAAC,CAAC,CAClC,SAAQ,uBAAuB,CAAC,CAAC,CAAC,EACjC,wBAAwB,CAAC,CAAC,CAAC,EAC3B,mBAAmB,CAAC,CAAC,CAAC;IACvB,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,MAAM,CAAC,EAAE,KAAK,CAAC;IACf;;;;;OAKG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,KAAK,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAChD,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AA8LpC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,OAAO,mKAmClB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `@sophistry/charts`: charts built on instanced primitives, scales and
+ * keyed joins. A `chart` fits its axes to the layers inside it; per-datum
+ * marks draw as one instances node, marks with distinct outlines as one path
+ * batch, rasters as images.
+ *
+ * @module @sophistry/charts
+ * @packageDocumentation
+ */
+export * from "./bars/index";
+export type { BatchedMark, BatchedMarkOptions, BatchItem, MarkTransition, } from "./batch";
+export { createBatchedMark } from "./batch";
+export { chart, chartHandle } from "./chart";
+export type { ChartLayer } from "./context";
+export { chartContext, chartLayer, chartLayersContext } from "./context";
+export * from "./curves/index";
+export * from "./data/channels";
+export type * from "./frame/types";
+export * from "./grids/index";
+export * from "./guides/index";
+export * from "./hierarchy/index";
+export * from "./math/index";
+export * from "./multiview/index";
+export * from "./points/index";
+export type { AnyDatum, BarReveal, CurveReveal, DensityReveal, KeyedTransitionProps, LayersReveal, RadialReveal, RevealProps, SeriesTransitionProps, StackReveal, StaggerOrder, TransitionProps, } from "./props";
+export * from "./radial/index";
+export * from "./statistics/index";
+export type { ActiveTooltip, TooltipAnchor, TooltipConfig, TooltipContent, TooltipField, TooltipFormat, TooltipOptions, TooltipPoint, TooltipRow, TooltipSpec, TooltipState, } from "./tooltip";
+export { createTooltipState, tooltipContext, tooltipLabel } from "./tooltip";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,cAAc,cAAc,CAAC;AAC7B,YAAY,EACX,WAAW,EACX,kBAAkB,EAClB,SAAS,EACT,cAAc,GACd,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC7C,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACzE,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,mBAAmB,eAAe,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,YAAY,EACX,QAAQ,EACR,SAAS,EACT,WAAW,EACX,aAAa,EACb,oBAAoB,EACpB,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,eAAe,GACf,MAAM,SAAS,CAAC;AACjB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,YAAY,EACX,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,YAAY,EACZ,aAAa,EACb,cAAc,EACd,YAAY,EACZ,UAAU,EACV,WAAW,EACX,YAAY,GACZ,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+import { $ as e, A as t, At as n, B as r, Bt as i, C as a, Ct as o, D as s, Dt as c, E as l, Et as u, F as d, Ft as f, G as p, Gt as m, H as h, Ht as g, I as _, It as v, J as y, Jt as b, K as x, Kt as S, L as C, Lt as w, M as T, Mt as E, N as D, Nt as O, O as k, Ot as A, P as j, Pt as M, Q as N, R as P, Rt as F, S as I, St as L, T as R, Tt as z, U as B, Ut as V, V as H, Vt as U, W, Wt as G, X as K, Xt as q, Y as J, Yt as Y, Z as X, Zt as Z, _ as Q, _t as $, a as ee, at as te, b as ne, bt as re, c as ie, ct as ae, d as oe, dt as se, et as ce, f as le, ft as ue, g as de, gt as fe, h as pe, ht as me, i as he, it as ge, j as _e, jt as ve, k as ye, kt as be, l as xe, lt as Se, m as Ce, mt as we, n as Te, nt as Ee, o as De, ot as Oe, p as ke, pt as Ae, q as je, qt as Me, r as Ne, rt as Pe, s as Fe, st as Ie, tt as Le, u as Re, ut as ze, v as Be, vt as Ve, w as He, wt as Ue, x as We, xt as Ge, y as Ke, yt as qe, z as Je, zt as Ye } from "./src-CwGo1bes.js";
+import { $ as Xe, $t as Ze, A as Qe, An as $e, At as et, B as tt, Bn as nt, Bt as rt, C as it, Cn as at, Ct as ot, D as st, Dn as ct, Dt as lt, E as ut, En as dt, Et as ft, F as pt, Fn as mt, Ft as ht, G as gt, Gn as _t, Gt as vt, H as yt, Hn as bt, Ht as xt, I as St, In as Ct, It as wt, J as Tt, Jt as Et, K as Dt, Kn as Ot, Kt as kt, L as At, Ln as jt, Lt as Mt, M as Nt, Mn as Pt, Mt as Ft, N as It, Nn as Lt, Nt as Rt, O as zt, On as Bt, Ot as Vt, P as Ht, Pn as Ut, Pt as Wt, Q as Gt, Qt as Kt, R as qt, Rn as Jt, Rt as Yt, S as Xt, Sn as Zt, St as Qt, T as $t, Tn as en, Tt as tn, U as nn, Un as rn, Ut as an, V as on, Vn as sn, Vt as cn, W as ln, Wn as un, Wt as dn, X as fn, Xt as pn, Y as mn, Yt as hn, Z as gn, Zt as _n, _ as vn, _n as yn, _t as bn, a as xn, an as Sn, at as Cn, b as wn, bn as Tn, bt as En, c as Dn, cn as On, ct as kn, d as An, dn as jn, dt as Mn, en as Nn, et as Pn, f as Fn, fn as In, ft as Ln, g as Rn, gn as zn, gt as Bn, h as Vn, hn as Hn, ht as Un, i as Wn, in as Gn, it as Kn, j as qn, jn as Jn, jt as Yn, k as Xn, kn as Zn, kt as Qn, l as $n, ln as er, lt as tr, m as nr, mn as rr, mt as ir, n as ar, nn as or, nt as sr, o as cr, on as lr, ot as ur, p as dr, pn as fr, pt as pr, q as mr, qt as hr, r as gr, rn as _r, rt as vr, s as yr, sn as br, st as xr, t as Sr, tn as Cr, tt as wr, u as Tr, un as Er, ut as Dr, v as Or, vn as kr, vt as Ar, w as jr, wn as Mr, wt as Nr, x as Pr, xn as Fr, xt as Ir, y as Lr, yn as Rr, yt as zr, z as Br, zn as Vr, zt as Hr } from "./math-CSHNpGej.js";
+import { a as Ur, c as Wr, i as Gr, l as Kr, n as qr, o as Jr, r as Yr, s as Xr, t as Zr } from "./channels-_Xf-p6Lx.js";
+import { a as Qr, i as $r, n as ei, o as ti, r as ni, s as ri, t as ii } from "./voxels-9lJ2TZS4.js";
+export { zr as DECIMATION_MIN_PER_COLUMN, zn as DEFAULT_BAR_WIDTH, or as DEFAULT_BIN_COUNT, lt as DEFAULT_ECDF_PAD_FALLBACK, Vt as DEFAULT_ECDF_PAD_FRACTION, et as DEFAULT_SAMPLES, Yn as DEFAULT_VIOLIN_SCALE, It as DEFAULT_WHISKER_SCALE, Or as GAUGE_END_ANGLE, Lr as GAUGE_START_ANGLE, Er as INSIDE_LABEL_FADE, ct as SYMBOLS, Jn as alignedRange, gr as assertRadarShape, Pt as autoRange, ri as bar3dSlots, o as barChart, Ue as barChartHandle, jn as barLabelValues, yn as barSlot, bn as barbGlyph, Oe as barbs, z as bars, u as barsHandle, Ce as beeswarm, Sn as beeswarmOffsets, c as bin, Gn as binIndex, Ft as blendViolinProfiles, T as boxBrushDrags, he as boxPlot, Ht as boxplotStats, mr as breadcrumbLayout, p as breadcrumbs, D as brushDrags, j as brushWheel, ye as brushedCategories, en as bubbleLegendValues, dt as bubbleRadiusScale, Ge as bullet, kt as bulletDomain, hr as bulletRow, L as bulletTooltip, re as candlestick, te as cells, Zr as channelValues, v as chart, Y as chartContext, F as chartGroupContext, w as chartHandle, q as chartLayer, Z as chartLayersContext, t as chartLink, Ye as chartPanel, k as chartZoom, d as chartZoomActions, _ as chartZoomDrag, oe as chord, Qe as chordLayout, qn as chordRibbon, B as circlePack, kr as clipPolylineToX, Rr as clipRingToX, ur as clusterRows, qr as colorResolver, b as colorbar, ge as contour, ir as contourBands, Pe as contourF, Un as contourLines, f as createBatchedMark, i as createChartGroup, W as createDrillDown, V as createTooltipState, Bn as dataExtent, En as dataRuns, Yr as dateSinkContext, sn as datumKeys, In as decimalsOf, Ir as decimateRun, Ee as dendrogram, Ae as density, xr as distanceMatrix, A as dodge, lr as dodgeSpan, se as ecdf, Qn as ecdfSteps, Ne as errorBar, Xn as errorBarPoints, We as eventPlot, zt as eventPlotRows, s as facet, jr as facetGrid, $t as facetSlots, ze as fillBetween, Nr as fillBetweenCurve, tn as fillBetweenRings, Lt as fitRange, Tt as flattenPathSpec, qe as funnel, Re as gauge, wn as gaugeAngle, Pr as gaugeBandIndex, Xt as gaugeBands, it as gaugeFraction, Rt as gaussianKde, vr as gridNcols, be as group, Le as heatmap, ce as hexBin, Cn as hexbin, on as hierarchyJoin, yt as hierarchyKeys, Dr as hierarchyTreeLayout, N as hist2d, Ve as histogram, Kn as histogram2d, _r as histogramBins, h as icicle, Gr as identity, X as imshow, wr as imshowCells, Ur as indexOf, fr as insideLabelFit, Qt as isNonDecreasingX, mn as isPathTransition, n as jitter, Cr as jitterOffsets, Ut as joinStages, He as jointPlot, mt as keyWindow, Ct as keyedJoin, an as keyframeAt, ne as labels, qt as largestRemainder, U as layoutTooltip, kn as leafOrder, Me as legend, Zn as legendLayout, Se as linePlot, tr as linkageTree, Be as links, pn as loess, _n as loessBand, Kt as meanInterval, rr as mixBarLabelValues, Mt as morphArea, Yt as morphAreaRuns, Hr as morphPolyline, rt as morphRuns, cn as morphSteps, H as mosaic, tt as mosaicLayout, ve as normalize, br as normalizeValues, Jr as numberValues, bt as observable10, rn as okabeIto, un as ordinalColorScale, ut as outerEdge, nn as packLayout, a as pairPlot, st as panelProgress, Rn as parallelAxisX, I as parallelCoordinates, vn as parallelLines, ln as partitionLayout, e as pcolormesh, sr as pcolormeshCells, xe as pieChart, $n as pieGrow, Tr as pieSlices, An as pieSweep, ie as polarAreaChart, Dn as polarAreaSlices, ti as quiverVectors, dn as raceTimeline, Wn as radarAxisFrames, Fe as radarChart, xn as radarFramePolygon, cr as radarLabelOffset, yr as radarVertices, De as radialBarChart, Mn as radialTreeLink, Ln as radialTreePoint, _e as rangeBrush, $ as rankRace, l as rects, On as reduceValues, Ze as regression, ae as regressionPlot, jt as rescaleKind, Jt as rescaleWindow, Xr as resolveChannel, Wr as resolveColor, Nt as resolvePolarSweep, Kr as resolveQuantity, Tn as revealClipAlongX, Fr as revealCutoff, Zt as revealPolylinesAlongX, at as revealRingsAlongX, Fn as ringLayout, dr as ringOrder, E as rolling, er as rollingValues, Q as rug, me as ruleX, fe as ruleY, fn as samePath, ot as sameRuns, r as sankey, St as sankeyLayout, At as sankeyRibbon, R as scatter, ar as scatterPoints, Qr as scatterPoints3, x as secondaryX, je as secondaryY, S as sizeLegend, $e as sizeLegendLayout, O as stack, Et as stackColumns, hn as stackOrder, Ie as stackPlot, Hn as stackTotals, Ar as stackedBands, Vr as stageProgress, nt as staggeredStageProgress, ue as stairs, ft as stairsPolyline, de as stem, Sr as stemPoints, $r as stemPoints3, pe as strip, Nn as studentT, M as summarize, Je as sunburst, ei as surfaceGridFaces, ni as surfaceGridWireframe, nr as sweepShare, Vn as sweepWedge, Bt as symbolPolygon, _t as tableau10, le as tickX, ke as tickY, G as tooltipContext, m as tooltipLabel, g as tooltipOverlay, vt as trailPolyline, P as tree, pr as treeLink, C as treemap, gt as treemapLayout, Dt as treemapRows, J as triContour, K as triContourF, gn as triangulate, Gt as tricontourBands, Xe as tricontourLines, y as tripcolor, Pn as tripcolorFaces, pt as trisurfaceFaces, Ot as uniqueKeys, Ke as vectors, Te as violinPlot, Wt as violinProfile, ht as violinProfileRing, wt as violinRing, ii as voxelFaces, ee as waffle, Br as waffleCells, we as waterfall, xt as waterfallSteps, Mr as xExtent };

package/dist/item-tooltip.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Tooltips for a batched layer: one node, one tooltip per item.
+ *
+ * `tooltipHandlers` serves a node that is one datum. A batched layer (see
+ * `instances()` or a path batch) is one node for every datum, and the pointer driver
+ * tells it which item it is on through `event.item` — leaving one item and
+ * entering the next as the pointer crosses between them. These handlers turn
+ * that into the same show/hide calls, with each item's own text and anchor.
+ */
+import type { ScenePointerEvent } from "@sophistry/core";
+import type { Point } from "@sophistry/core/geometry";
+import type { TooltipContent, TooltipState } from "./tooltip";
+/**
+ * Hover and tap handlers showing item `event.item`'s tooltip.
+ *
+ * @param tooltip - The chart's tooltip, or undefined for none.
+ * @param textOf - An item's tooltip, or undefined for none.
+ * @param atOf - Where an item's tooltip points, in scene units.
+ * Spread the result into the batched node's `shared` props (instances) or
+ * props (path batch); handlers receive `event.item`.
+ *
+ * @param label - The layer's accessible name: a batched layer is one tab stop,
+ *   whose items the arrow keys walk (see `InteractionHandlers.itemLabel`).
+ *
+ * @internal
+ */
+export declare function itemTooltipHandlers(tooltip: TooltipState | null | undefined, textOf: (item: number) => TooltipContent | undefined, atOf: (item: number) => Point | undefined, label: () => string | undefined): {
+    readonly label?: string;
+    readonly onEnter?: (event: ScenePointerEvent) => void;
+    readonly onLeave?: (event: ScenePointerEvent) => void;
+    readonly onTap?: (event: ScenePointerEvent) => void;
+    readonly itemLabel?: (item: number) => string | undefined;
+};
+//# sourceMappingURL=item-tooltip.d.ts.map

package/dist/item-tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-tooltip.d.ts","sourceRoot":"","sources":["../src/item-tooltip.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAG9D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAClC,OAAO,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,EACxC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,cAAc,GAAG,SAAS,EACpD,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,KAAK,GAAG,SAAS,EACzC,KAAK,EAAE,MAAM,MAAM,GAAG,SAAS,GAC7B;IACF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACtD,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACtD,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACpD,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAC1D,CAgDA"}

package/dist/join.d.ts

@@ -0,0 +1,224 @@
+/**
+ * Keyed data transitions (`to` + `blend`) shared by chart marks: the join
+ * between the two datasets' keys and each stage's progress. A key in both
+ * ends updates (interpolates in data space), one only in `to` enters at its
+ * new place, one only in `data` exits at its old place. Stages come from the
+ * enclosing chart, or from the join alone outside one.
+ *
+ * Each is a factory called once in
+ * a composite's `setup` that returns a function to call in every `update`.
+ * The factory keeps last-input caches (keys compared by value), so a frame
+ * of a blend recomputes the stage progress and nothing else. Internal.
+ */
+import type { BandKey, Point } from "@sophistry/core/geometry";
+import type { Channel, DateSink } from "./data/channels";
+import type { AxisExtent, ColorExtent, LayerTransition } from "./frame/types";
+import type { JoinStages, JoinStaging, KeyedJoin } from "./math/join";
+import type { Category, GroupKey } from "./series";
+/** One update's view of a keyed join. See {@link createJoin}. */
+export interface JoinState {
+    /** True while a transition is requested (`to` given). */
+    active: boolean;
+    /** Every key to keep an item for: the union while active, else `data`'s keys. */
+    keys: readonly BandKey[];
+    /** The join, while active. */
+    join: KeyedJoin | undefined;
+    /** Where each key sits in `data`'s keys. */
+    fromSlots: Map<BandKey, number>;
+    /** Where each key sits in `to`'s keys, while active. */
+    toSlots: Map<BandKey, number> | undefined;
+    /** The blend, clamped (0 when inactive). */
+    t: number;
+    /** The stages in use, while active. */
+    stages: JoinStages | undefined;
+    /** Progress of the update stage, 0..1 (0 when inactive). */
+    update: number;
+    /** Progress of the enter stage, 0..1 (0 when inactive). */
+    enter: number;
+    /** One entering key's progress through the enter stage: its own sub-window under `enterStagger`, else `enter`. */
+    enterOf(key: BandKey): number;
+    /** Progress of the exit stage, 0..1 (0 when inactive). */
+    exit: number;
+    /** Whether anything enters or exits, including the mark's own `more` (false when inactive). */
+    flags: {
+        enters: boolean;
+        exits: boolean;
+    };
+}
+/** What {@link createJoin}'s function takes on each update. */
+export interface JoinSpec {
+    fromKeys: readonly BandKey[];
+    /** `to`'s keys, or undefined without a transition. */
+    toKeys: readonly BandKey[] | undefined;
+    blend: number | undefined;
+    staging: JoinStaging | undefined;
+    /** The enclosing chart's stages (`frame.join`), which win over the join's own. */
+    chartStages?: JoinStages | undefined;
+    /** Enters and exits beyond the keys (a radar's axes), so the stages make room. */
+    more?: {
+        enters?: boolean;
+        exits?: boolean;
+    } | undefined;
+    /** Fraction of the enter stage spent staggering entering keys, 0..0.95. */
+    enterStagger?: number | undefined;
+    /** Each entering key's stagger rank; defaults to `to`'s order. */
+    enterRanks?: (entering: readonly BandKey[], join: KeyedJoin) => readonly number[];
+}
+/**
+ * Makes a keyed join for one mark. Call once, in `setup`; call the result
+ * in every `update` with that update's keys and blend.
+ *
+ * @returns `(spec) => JoinState`, caching the join while the keys are equal
+ *   by value.
+ */
+export declare function createJoin(): (spec: JoinSpec) => JoinState;
+/** Which end of a transition a key's datum is read from. */
+export type JoinEnd = "from" | "to";
+/** What one key is on one frame of a keyed transition. See {@link joinFrame}. */
+export interface JoinFrame<S> {
+    /** Its state: `data`'s, `to`'s, or the two blended by the update stage. */
+    state: S;
+    /** 0..1 presence: `1 − exit` while leaving, `enter` while arriving, else 1. */
+    presence: number;
+    /** The end its datum is read from: the nearer one while it updates. */
+    end: JoinEnd;
+    /** That datum's index in its end's data. */
+    index: number;
+    /**
+     * While an axis changes kind, for a key in both ends mid-update: each end's
+     * own state and the update progress, so the mark can blend them in scene
+     * units; `state` is then only the data-unit blend.
+     */
+    pair?: {
+        a: S;
+        b: S;
+        u: number;
+    };
+}
+/**
+ * One key's frame: in both ends it blends from `a` to `b` on the update
+ * stage; only in `data` it stays at `a` as presence falls; only in `to` it
+ * stands at `b` as presence rises. Marks spend `presence` like their reveal
+ * spends `progress`, so exit is the reveal reversed.
+ *
+ * @param blend - Blends two states at update progress `u`.
+ * @param key - The key, so an entering one reads its staggered enter.
+ * @param pair - Keep both ends' states mid-swap: pass `space.swapping`.
+ * @returns The frame, or undefined when neither end has the key.
+ */
+export declare function joinFrame<S>(join: JoinState, a: {
+    state: S;
+    index: number;
+} | undefined, b: {
+    state: S;
+    index: number;
+} | undefined, blend: (a: S, b: S, u: number) => S, key?: BandKey, pair?: boolean): JoinFrame<S> | undefined;
+/** One update's keyed data: the join, plus where each key's datum is at each end. */
+export interface KeyedData extends JoinState {
+    /** Each `to` datum's category, with a `series` and a transition. */
+    toOf: Category[] | undefined;
+    /** A key's datum index in `data`, or -1 (entering). */
+    fromIndex(key: BandKey): number;
+    /** A key's datum index in `to`, or -1 (leaving, or no transition). */
+    toIndex(key: BandKey): number;
+}
+/** What {@link createKeyedData}'s function takes on each update. */
+export interface KeyedDataSpec<T> {
+    data: readonly T[];
+    to: readonly T[] | undefined;
+    key: Channel<T, BandKey> | undefined;
+    series: Channel<T, BandKey> | undefined;
+    /** `data`'s categories (the `series` channel read across it), if any. */
+    of: readonly Category[] | undefined;
+    /** The indices a dataset draws, in draw order; defaults to all. */
+    drawn?: (data: readonly T[]) => readonly number[];
+    blend: number | undefined;
+    staging: JoinStaging | undefined;
+    chartStages?: JoinStages | undefined;
+    more?: {
+        enters?: boolean;
+        exits?: boolean;
+    } | undefined;
+    enterStagger?: number | undefined;
+    /** As {@link JoinSpec.enterRanks}, also given each entering key's index in `to`. */
+    enterRanks?: (entering: readonly BandKey[], join: KeyedJoin, toIndex: (key: BandKey) => number) => readonly number[];
+    /** The chart's date sink, for channels reading dates. */
+    dates?: DateSink | null;
+}
+/**
+ * The keyed join of a per-datum mark (dots, stems, error bars, ticks): each
+ * end's keys (the `key` channel, else place within series, else index),
+ * restricted to what the mark draws. Call once, in `setup`; call the result
+ * in each `update`, draw its `keys` and read each key's frame with
+ * {@link joinFrame} (or all of them with {@link joinFrames}).
+ */
+export declare function createKeyedData<T>(): (spec: KeyedDataSpec<T>) => KeyedData;
+/**
+ * Every key's {@link joinFrame} for a per-datum mark, in key order.
+ * `stateOf(end, index)` reads one end's datum, or undefined where it draws
+ * nothing.
+ *
+ * @param pair - Mid-swap, keep both ends' states (`space.swapping`).
+ */
+export declare function joinFrames<S>(keyed: KeyedData, stateOf: (end: JoinEnd, index: number) => S | undefined, blend: (a: S, b: S, u: number) => S, pair?: boolean): Map<BandKey, JoinFrame<S>>;
+/** Each key's place in a per-datum mark's reveal order: `data`'s keys, then those only in `to`. */
+export declare function keyRanks(keys: readonly BandKey[]): Map<BandKey, number>;
+/**
+ * A layer's `transition` report: the far end's extents, the blend and what
+ * the join contains. Undefined without a transition.
+ *
+ * @param far - The `to` data's extents (omit axes the layer doesn't report),
+ * and `enters` / `exits` when the layer decides them rather than the join.
+ */
+export declare function layerTransition(join: JoinState, staging: JoinStaging | undefined, far: {
+    x?: AxisExtent;
+    y?: AxisExtent;
+    enters?: boolean;
+    exits?: boolean;
+}): LayerTransition | undefined;
+/**
+ * A layer's `color` report across a keyed transition: both ends' categories,
+ * `data`'s first (so colours hold still), with each end's as `ends` (so the
+ * legend fades entries). Otherwise the report as given.
+ */
+export declare function transitionColor(own: ColorExtent | undefined, toCategories: readonly Category[] | undefined): ColorExtent | undefined;
+/** The keyed join of a grouped mark (one shape per `series` category, or one {@link WHOLE} shape). */
+export interface GroupJoin extends JoinState {
+    /** Every group to draw: both ends' while a transition runs (`data`'s first), else `data`'s. */
+    groups: readonly GroupKey[];
+    /** The categories `to` draws (its groups, less {@link WHOLE}), while a transition runs. */
+    toCategories: readonly BandKey[] | undefined;
+    /** Whether a group is only in `to`: it enters, on the enter stage. */
+    entering(key: GroupKey): boolean;
+    /** A group's fade: `1 − exit` for one only `data` has (it leaves), else 1. */
+    fade(key: GroupKey): number;
+}
+/** What {@link createGroupJoin}'s function takes on each update. */
+export interface GroupJoinSpec {
+    fromGroups: readonly GroupKey[];
+    toGroups: readonly GroupKey[] | undefined;
+    blend: number | undefined;
+    staging: JoinStaging | undefined;
+    chartStages?: JoinStages | undefined;
+    enterStagger?: number | undefined;
+    enterRanks?: (entering: readonly BandKey[], join: KeyedJoin) => readonly number[];
+}
+/**
+ * The keyed join of a grouped mark: groups matched by category. A group in
+ * both ends morphs on the update stage, one only in `to` enters, one only
+ * in `data` exits. Without `to`, `groups` is `data`'s and every stage reads
+ * 0. Call once, in `setup`.
+ */
+export declare function createGroupJoin(): (spec: GroupJoinSpec) => GroupJoin;
+/**
+ * An entering shape swept in along x (along y when `vertical`): its lines
+ * and rings cut at the front `enter` of the way across their extent.
+ */
+export declare function sweepIn(shape: {
+    lines: readonly (readonly Point[])[];
+    rings: readonly (readonly Point[])[];
+}, enter: number, vertical?: boolean): {
+    lines: Point[][];
+    rings: Point[][];
+};
+//# sourceMappingURL=join.d.ts.map

package/dist/join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../src/join.ts"],"names":[],"mappings":"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"}

package/dist/math/3d/bar3d.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 3D bar geometry: one box per index, anchored at `(x, y, z)` (not centred)
+ * and extended by `(width, height, depth)`. Each extent is a number for
+ * every bar or one per bar; arrays pair by index up to the shortest.
+ */
+/** @category Math */
+export interface BarSlotBox3D {
+    /** Index into the input arrays, keeping a `colors` array aligned past dropped entries. */
+    index: number;
+    x0: number;
+    x1: number;
+    y0: number;
+    y1: number;
+    z0: number;
+    z1: number;
+}
+/**
+ * One box per index: anchored at `(xs[i], ys[i], zs[i])` and extended by
+ * that index's `(width, height, depth)`. Negative extents still give a
+ * well-formed box; non-finite components drop the entry.
+ *
+ * @param widths - Extent along x: one number for every bar, or one per bar.
+ * @param heights - Extent along y: one number for every bar, or one per bar.
+ * @param depths - Extent along z: one number for every bar, or one per bar.
+ * @category Math & helpers
+ */
+export declare function bar3dSlots(xs: readonly number[], ys: readonly number[], zs: readonly number[], widths: number | readonly number[], heights: number | readonly number[], depths: number | readonly number[]): BarSlotBox3D[];
+//# sourceMappingURL=bar3d.d.ts.map

package/dist/math/3d/bar3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bar3d.d.ts","sourceRoot":"","sources":["../../../src/math/3d/bar3d.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,qBAAqB;AACrB,MAAM,WAAW,YAAY;IAC5B,0FAA0F;IAC1F,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACX;AAcD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACzB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EAClC,OAAO,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EACnC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAChC,YAAY,EAAE,CAoChB"}

package/dist/math/3d/quiver3d.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 3D vector field geometry: one arrow per index, tail at `(x, y, z)`,
+ * direction and length `(u, v, w) * scale` (not normalised; pre-normalise
+ * the components for equal lengths).
+ */
+import type { Point3 } from "@sophistry/core/internal";
+/** @category Math */
+export interface QuiverVector3 {
+    /** Index into the input arrays, keeping a `colors` array aligned past dropped entries. */
+    index: number;
+    origin: Point3;
+    vector: Point3;
+}
+/** @category Math */
+export interface QuiverOptions {
+    /** Multiplies `(u, v, w)` before it becomes the drawn vector. @default 1 */
+    scale?: number;
+}
+/**
+ * One vector per finite `(x, y, z, u, v, w)`, keeping its index; the six
+ * arrays pair by index.
+ *
+ * @param us - Vector x component, in data units (before `scale`).
+ * @category Math & helpers
+ */
+export declare function quiverVectors(xs: readonly number[], ys: readonly number[], zs: readonly number[], us: readonly number[], vs: readonly number[], ws: readonly number[], options?: QuiverOptions): QuiverVector3[];
+//# sourceMappingURL=quiver3d.d.ts.map

package/dist/math/3d/quiver3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quiver3d.d.ts","sourceRoot":"","sources":["../../../src/math/3d/quiver3d.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAGvD,qBAAqB;AACrB,MAAM,WAAW,aAAa;IAC7B,0FAA0F;IAC1F,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CACf;AAED,qBAAqB;AACrB,MAAM,WAAW,aAAa;IAC7B,4EAA4E;IAC5E,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAID;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC5B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,OAAO,GAAE,aAAkB,GACzB,aAAa,EAAE,CA0BjB"}

package/dist/math/3d/scatter3d.d.ts

@@ -0,0 +1,16 @@
+/** 3D scatter geometry: one marker per finite `(x, y, z)` triple. */
+/** @category Math */
+export interface ScatterPoint3 {
+    /** Index into the input arrays, keeping `sizes`/`colors` aligned past dropped triples. */
+    index: number;
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * The finite `(x, y, z)` triples, paired by index, each keeping its index.
+ *
+ * @category Math & helpers
+ */
+export declare function scatterPoints3(xs: readonly number[], ys: readonly number[], zs: readonly number[]): ScatterPoint3[];
+//# sourceMappingURL=scatter3d.d.ts.map

package/dist/math/3d/scatter3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatter3d.d.ts","sourceRoot":"","sources":["../../../src/math/3d/scatter3d.ts"],"names":[],"mappings":"AAAA,qEAAqE;AAIrE,qBAAqB;AACrB,MAAM,WAAW,aAAa;IAC7B,0FAA0F;IAC1F,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC7B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,GACnB,aAAa,EAAE,CAajB"}

package/dist/math/3d/stem3d.d.ts

@@ -0,0 +1,23 @@
+/** 3D stem geometry: a drop line along world y (up) from `baseline`, and a marker, per finite `(x, y, z)`. */
+import type { Point3 } from "@sophistry/core/internal";
+/** @category Math */
+export interface StemPoint3 {
+    /** Index into the input arrays, keeping a `colors` array aligned past dropped triples. */
+    index: number;
+    /** `(x, baseline, z) → (x, y, z)`, in data coordinates. */
+    drop: [Point3, Point3];
+    marker: Point3;
+}
+/** @category Math */
+export interface Stem3DOptions {
+    /** The y (height) value each drop line starts from. @default 0 */
+    baseline?: number;
+}
+/**
+ * One drop line and marker per finite `(x, y, z)`, paired by index.
+ *
+ * @param ys - Heights; the drop runs along this axis.
+ * @category Math & helpers
+ */
+export declare function stemPoints3(xs: readonly number[], ys: readonly number[], zs: readonly number[], options?: Stem3DOptions): StemPoint3[];
+//# sourceMappingURL=stem3d.d.ts.map

package/dist/math/3d/stem3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stem3d.d.ts","sourceRoot":"","sources":["../../../src/math/3d/stem3d.ts"],"names":[],"mappings":"AAAA,8GAA8G;AAE9G,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAGvD,qBAAqB;AACrB,MAAM,WAAW,UAAU;IAC1B,0FAA0F;IAC1F,KAAK,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CACf;AAED,qBAAqB;AACrB,MAAM,WAAW,aAAa;IAC7B,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAID;;;;;GAKG;AACH,wBAAgB,WAAW,CAC1B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,OAAO,GAAE,aAAkB,GACzB,UAAU,EAAE,CAsBd"}

package/dist/math/3d/surfaceGrid3d.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Structured-grid surfaces: `X`, `Y`, `Z` are three `nrows x ncols` arrays of
+ * world coordinates for one grid of points, computed by the caller. Quads
+ * are wound so `MeshFaces` sees them facing outward. Mismatched grid
+ * shapes throw.
+ */
+import type { Point3 } from "@sophistry/core/internal";
+/** @category Math */
+export interface SurfaceGridFace {
+    points: Point3[];
+}
+/**
+ * A rectangular grid of numbers (rows of columns).
+ *
+ * @category Math & helpers
+ */
+export type SurfaceGrid = readonly (readonly number[])[];
+/**
+ * One outward-wound quad per grid cell, `(nrows - 1) * (ncols - 1)` total.
+ *
+ * @param X - World x of each grid point, `X[row][col]`.
+ * @throws If the three grids differ in row count or any row's length.
+ * @category Math & helpers
+ */
+export declare function surfaceGridFaces(X: SurfaceGrid, Y: SurfaceGrid, Z: SurfaceGrid): SurfaceGridFace[];
+/**
+ * One polyline per grid row plus one per column: the wireframe.
+ *
+ * @param X - World x of each grid point, `X[row][col]`.
+ * @throws If the three grids differ in row count or any row's length.
+ * @category Math & helpers
+ */
+export declare function surfaceGridWireframe(X: SurfaceGrid, Y: SurfaceGrid, Z: SurfaceGrid): Point3[][];
+//# sourceMappingURL=surfaceGrid3d.d.ts.map

package/dist/math/3d/surfaceGrid3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surfaceGrid3d.d.ts","sourceRoot":"","sources":["../../../src/math/3d/surfaceGrid3d.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAEvD,qBAAqB;AACrB,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC;AAuCzD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC/B,CAAC,EAAE,WAAW,EACd,CAAC,EAAE,WAAW,EACd,CAAC,EAAE,WAAW,GACZ,eAAe,EAAE,CAcnB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CACnC,CAAC,EAAE,WAAW,EACd,CAAC,EAAE,WAAW,EACd,CAAC,EAAE,WAAW,GACZ,MAAM,EAAE,EAAE,CAgBZ"}

package/dist/math/3d/trisurface.d.ts

@@ -0,0 +1,12 @@
+/** Triangulated surface faces: the xy-plane Delaunay triangulation, lifted to each point's `z`. */
+import type { Point3 } from "@sophistry/core/internal";
+/**
+ * The xy-plane Delaunay triangles, each as 3 world points with `zs` as height.
+ *
+ * @param zs - Heights per point; triangles with a non-finite height are skipped.
+ * @category Math & helpers
+ */
+export declare function trisurfaceFaces(xs: readonly number[], ys: readonly number[], zs: readonly number[]): {
+    points: Point3[];
+}[];
+//# sourceMappingURL=trisurface.d.ts.map

package/dist/math/3d/trisurface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trisurface.d.ts","sourceRoot":"","sources":["../../../src/math/3d/trisurface.ts"],"names":[],"mappings":"AAAA,mGAAmG;AAEnG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAGvD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,GACnB;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,EAAE,CAkBxB"}

package/dist/math/3d/voxels.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Boolean voxel grid geometry: each `true` `filled[i][j][k]` occupies the unit
+ * cube `[i, i+1] x [j, j+1] x [k, k+1]`; ragged or missing entries are empty.
+ * Only exposed faces are emitted (faces between two filled voxels are
+ * culled), wound counter-clockwise from outside.
+ */
+import type { Point3 } from "@sophistry/core/internal";
+/** @category Math */
+export interface VoxelFace {
+    points: Point3[];
+}
+/**
+ * One quad per exposed face of every filled voxel.
+ *
+ * @category Math & helpers
+ */
+export declare function voxelFaces(filled: readonly (readonly (readonly boolean[])[])[]): VoxelFace[];
+//# sourceMappingURL=voxels.d.ts.map

package/dist/math/3d/voxels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voxels.d.ts","sourceRoot":"","sources":["../../../src/math/3d/voxels.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAEvD,qBAAqB;AACrB,MAAM,WAAW,SAAS;IACzB,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AAYD;;;;GAIG;AACH,wBAAgB,UAAU,CACzB,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,GAClD,SAAS,EAAE,CA2Cb"}