@sheetxl/sdk 0.8.0-beta.10 → 0.8.0-beta.11

package/types/src/chart/resolve/_ResolvedChart.d.ts

@@ -0,0 +1,444 @@
+import { IFill } from '../../fill/IFill';
+import { IStroke } from '../../fill/IStroke';
+import { ChartModel } from '../model/ChartModel';
+import { HistogramBin } from '../math/Histogram';
+import { BoxStats, QuartileMethod } from '../math/BoxStats';
+import { TrendlineFit, TrendlineTextRun, TrendlineType } from '../math/Trendlines';
+/**
+ * A chart with every property concrete: what it states, else its style's, else Excel's default.
+ * Every color is concrete CSS (`#RRGGBB` or `rgba()`, `PaintUtils.toConcreteCSS`), in the fills and
+ * lines the model states: a gradient keeps its stops and a pattern its two colors. Lengths and font
+ * sizes are points, and labels are text.
+ *
+ * @remarks
+ * The input of layout. Values come from the model's caches.
+ */
+export interface ResolvedChart {
+    /** The chart's type, by Office Scripts' names: what `IChart.getChartType` answers. */
+    chartType: string;
+    /** A 2016 chart (`cx:chartSpace`): its chrome is that style's, not a classic chart's. */
+    chartEx?: boolean;
+    /** The chart's own text font: what text with no font of its own is drawn in. */
+    font: ResolvedChart.Font;
+    /** `cornerRadius` in points: 0 for square corners. */
+    chartArea: {
+        fill: IFill.JSON | null;
+        border: ResolvedChart.Stroke | null;
+        cornerRadius: number;
+    };
+    title: ResolvedChart.Text | null;
+    plotArea: {
+        fill: IFill.JSON | null;
+        border: ResolvedChart.Stroke | null;
+    };
+    /** In the chart's order. */
+    axes: ResolvedChart.Axis[];
+    /** In the chart's order. */
+    groups: ResolvedChart.Group[];
+    legend: ResolvedChart.Legend | null;
+    /** Dates are serials of the 1904 system. */
+    date1904: boolean;
+    /** Whether a line is drawn across a blank point rather than broken at it (`dispBlanksAs span`). */
+    spanBlanks: boolean;
+}
+export declare namespace ResolvedChart {
+    interface Font {
+        family: string;
+        /** In pt. */
+        size: number;
+        bold: boolean;
+        italic: boolean;
+        /** What the text is filled with: a solid color, or a gradient. */
+        color: IFill.JSON;
+    }
+    /** A line as the model states it, with its fill concrete and its width (in pt) stated. */
+    type Stroke = IStroke.JSON & {
+        fill: IFill.JSON;
+        width: number;
+    };
+    interface Text {
+        text: string;
+        font: Font;
+        fill: IFill.JSON | null;
+        border: Stroke | null;
+        overlay: boolean;
+        /** The text's angle in degrees counterclockwise: 90 reads up, as an axis title up a side does. */
+        rotation?: number;
+    }
+    /** Where a data label sits by its point: DrawingML's `dLblPos`. */
+    type LabelPosition = 'bestFit' | 'b' | 'ctr' | 'inBase' | 'inEnd' | 'l' | 'outEnd' | 'r' | 't';
+    /** The label of one point. */
+    interface DataLabel {
+        /** Its lines joined by `
+    `. */
+        text: string;
+        position: LabelPosition;
+        font: Font;
+        fill: IFill.JSON | null;
+        border: Stroke | null;
+    }
+    interface Axis {
+        id: number;
+        crossAx: number;
+        type: ChartModel.AxisType;
+        position: 'b' | 'l' | 'r' | 't';
+        deleted: boolean;
+        line: Stroke | null;
+        majorGridlines: Stroke | null;
+        minorGridlines: Stroke | null;
+        majorTickMark: ChartModel.TickMark;
+        minorTickMark: ChartModel.TickMark;
+        tickLblPos: 'high' | 'low' | 'nextTo' | 'none';
+        labelFont: Font;
+        /** The labels' stated angle, in degrees counterclockwise; absent when Excel chooses. */
+        labelRotation?: number;
+        /** A category axis: the stated interval between labels (`tickLblSkip`); absent when Excel chooses. */
+        labelSkip?: number;
+        /**
+         * A category axis over multi-level categories draws each level (`noMultiLvlLbl` off), rather
+         * than one label of all of a category's levels.
+         */
+        multiLevel: boolean;
+        /** The format the labels are written in: the axis's own, or its data's when linked to source. */
+        formatCode: string;
+        orientation: 'minMax' | 'maxMin';
+        /** Stated bounds and units; absent ones are automatic. */
+        min?: number;
+        max?: number;
+        majorUnit?: number;
+        minorUnit?: number;
+        logBase?: number;
+        /** A date axis: the stated unit of its slots, and the stated units of its major and minor ticks. */
+        baseTimeUnit?: ChartModel.TimeUnit;
+        majorTimeUnit?: ChartModel.TimeUnit;
+        minorTimeUnit?: ChartModel.TimeUnit;
+        crosses: 'autoZero' | 'max' | 'min';
+        crossesAt?: number;
+        /** A value axis: whether the axis crossing it lays its categories out between ticks or on them. */
+        crossBetween: 'between' | 'midCat';
+        /** A built-in unit's name or a divisor. */
+        displayUnit?: string | number;
+        /** The display unit's label, shown beside the axis; `null` when the values are not shown in a unit or it is hidden. */
+        displayUnitLabel: Text | null;
+        /** A category axis's `lblOffset`: the labels' distance from the axis as a percentage of the default, 100. */
+        labelOffset: number;
+        /** The labels are stacked letter over letter (`a:bodyPr vert="wordArtVert"`). */
+        labelVertical: boolean;
+        title: Text | null;
+    }
+    interface Marker {
+        symbol: 'circle' | 'square' | 'diamond' | 'triangle' | 'x' | 'star' | 'plus' | 'dot' | 'dash';
+        /** In pt. */
+        size: number;
+        fill: IFill.JSON | null;
+        stroke: Stroke | null;
+    }
+    interface Series {
+        /**
+         * `s` and the key the chart names the series by: its `idx`, or `#` and its place among the
+         * chart's series where it states none (a 2016 chart's).
+         */
+        id: string;
+        idx: number;
+        order: number;
+        name: string;
+        /** By point; `null` is blank. */
+        values: (number | null)[];
+        /** Scatter groups: the x of each point, `1..n` when the series states none. */
+        xValues?: (number | null)[];
+        /** Bubble groups: each point's bubble size; `null` is blank. */
+        bubbleSizes?: (number | null)[];
+        /** By point, as text: the innermost level of multi-level categories. */
+        categories: string[];
+        /**
+         * Multi-level categories: by level, the innermost first, each by point with `''` for a blank (a
+         * blank in an outer level continues the group before it). Absent for categories of one level.
+         */
+        categoryLevels?: string[][];
+        /** By point, as numbers, where the categories are numbers (dates): what a date axis places them by. */
+        categoryValues?: (number | null)[];
+        /** The values' format: the cache's. */
+        formatCode: string;
+        fill: IFill.JSON | null;
+        stroke: Stroke | null;
+        marker: Marker | null;
+        smooth: boolean;
+        /**
+         * Pie, doughnut, of-pie and waterfall groups: how each point is drawn, by point; an of-pie's has
+         * one more, its slice for the points of the second plot (Excel's "Other").
+         */
+        points?: PointStyle[];
+        /** By point, the label drawn by it; `null` for a point without one. Absent when no point has one. */
+        labels?: (DataLabel | null)[];
+        /** The marker's size in pt, stated or Excel's 5, whether or not a marker is drawn: a label keeps clear of it. */
+        markerSize: number;
+        /** The series' trendlines, in the order it lists them. Absent when it has none. */
+        trendlines?: Trendline[];
+        /** The series' error bars, in the order it lists them. Absent when it has none. */
+        errorBars?: ErrorBars[];
+        /** Histogram groups: the values as read, which the group's bins index, before they were counted into `values`. */
+        raw?: (number | null)[];
+        /** Box and whisker groups: by category, the statistics of the series' values there; `null` for a category with none. */
+        boxes?: (BoxStats | null)[];
+        /** Box and whisker groups: what of each box is drawn, and the line it is drawn with. */
+        box?: BoxOptions;
+    }
+    /** How a box and whisker series draws its boxes (DESIGN-CHART §4.17). */
+    interface BoxOptions {
+        quartileMethod: QuartileMethod;
+        /** An x at each box's mean. */
+        meanMarker: boolean;
+        /** A line from each box's mean to the next's. */
+        meanLine: boolean;
+        /** A dot at each value beyond the whiskers. */
+        outliers: boolean;
+        /** A dot at each value within the whiskers. */
+        innerPoints: boolean;
+        /** The box's outline, its median, its whiskers and its marks: the fill's darker shade. */
+        line: Stroke;
+    }
+    /** A series' error bars: a bar about each point, of an amount below and above. */
+    interface ErrorBars {
+        /** Which of the points' values the bars are of: `y`, along the value axis, or a scatter's `x`. */
+        direction: 'x' | 'y';
+        /** What the bars are about: each point's value, or (standard deviations) the series' mean. */
+        about: 'point' | number;
+        /** By point, how far below and above the bar runs; `null` for a point with no bar. */
+        amounts: ({
+            minus: number;
+            plus: number;
+        } | null)[];
+        /** The bar's far ends are capped: an end of no amount is not. */
+        cap: boolean;
+        stroke: Stroke | null;
+    }
+    /** A trendline of a series, fitted to the series' points. */
+    interface Trendline {
+        /** Its entry in the legend. */
+        name: string;
+        type: TrendlineType;
+        /** The fit; `null` for a moving average, or where the points allow none (nothing is drawn). */
+        fit: TrendlineFit | null;
+        /** A moving average's points, in the series' x. */
+        average?: {
+            x: number;
+            y: number;
+        }[];
+        /**
+         * The x the line runs over: the series' first and last point's, `backward` before and
+         * `forward` past them. On a category axis x is the category's number, from 1.
+         */
+        from: number;
+        to: number;
+        /** How far past the last point it runs: on a category axis, the categories it adds. */
+        forward: number;
+        stroke: Stroke | null;
+        label: TrendlineLabel | null;
+    }
+    /** A trendline's label: its equation and R², a line each. */
+    interface TrendlineLabel {
+        /** Each line's runs, an exponent raised. */
+        lines: TrendlineTextRun[][];
+        /**
+         * Where it was moved by hand (`c:manualLayout`): a fraction of the chart's width and height, by
+         * which it is moved from its own place (`factor`), or its position from the chart's top left
+         * (`edge`). Absent where it sits in its own place.
+         */
+        moved?: {
+            x: number;
+            y: number;
+            xEdge: boolean;
+            yEdge: boolean;
+        };
+        font: Font;
+        fill: IFill.JSON | null;
+        border: Stroke | null;
+    }
+    /** One point of a pie, doughnut or of-pie. */
+    interface PointStyle {
+        fill: IFill.JSON | null;
+        stroke: Stroke | null;
+        /** How far the slice is pulled out, as a percentage of the radius. */
+        explosion: number;
+        /** A waterfall's point that is a total: its bar runs from zero to its value, which the steps after it start from. */
+        total?: boolean;
+    }
+    interface Group {
+        type: ChartModel.GroupType;
+        /** A custom group's kind and options, as the model states them. */
+        custom?: ChartModel.CustomGroup;
+        barDir: 'bar' | 'col';
+        grouping: 'clustered' | 'stacked' | 'percentStacked' | 'standard';
+        /** Percent of a bar's width. */
+        gapWidth: number;
+        /** -100..100. */
+        overlap: number;
+        varyColors: boolean;
+        /** Pie and doughnut: where the first slice starts, in degrees clockwise from 12 o'clock. */
+        firstSliceAng: number;
+        /** Doughnut: the hole, as a percentage of the radius. */
+        holeSize: number;
+        axIds: number[];
+        /** In plot order. */
+        series: Series[];
+        /** Line and stock groups: a bar in each category from the first series' value to the last's. */
+        upDownBars?: UpDownBars;
+        /** Line and stock groups: a line in each category from its lowest value to its highest. */
+        hiLowLines?: Stroke | null;
+        /** Line, area and stock groups: a line from each category's values to the category axis. */
+        dropLines?: Stroke | null;
+        /** Stacked bar groups: a line joining each series' ends in neighboring categories; an of-pie's lines to its second plot. */
+        seriesLines?: Stroke | null;
+        /** Of-pie groups: the second plot and the points it takes. */
+        ofPie?: OfPie;
+        /** Surface groups: the value bands they are drawn in. */
+        surface?: Surface;
+        /** Radar groups: lines and markers, or filled. */
+        radarStyle?: 'standard' | 'marker' | 'filled';
+        /** Bubble groups: how the bubbles are sized. */
+        bubble?: Bubble;
+        /** Waterfall groups: how steps up, steps down and totals are drawn, and the lines between bars. */
+        waterfall?: Waterfall;
+        /** Sunburst and treemap groups: the colors of the hierarchy's branches and the line between its segments. */
+        hierarchy?: Hierarchy;
+        /** Histogram groups: the bins the values were counted in, and a pareto's line. */
+        histogram?: Histogram;
+        /** Treemap groups: how the top-level categories are labeled, the font their names are in, and a banner's fill. */
+        treemap?: {
+            parentLabels: 'none' | 'banner' | 'overlapping';
+            font: Font;
+            bannerFill: IFill.JSON | null;
+        };
+    }
+    /**
+     * How a histogram's values were counted (DESIGN-CHART §4.16): each series' `values` are its
+     * counts by bin and its `categories` the bins' labels; a pareto's are its sums by category,
+     * largest first, with a line of the running share on an axis of its own.
+     */
+    interface Histogram {
+        /** The first series' bins, each with the indexes of its `raw` values. */
+        bins: HistogramBin[];
+        intervalClosed: 'l' | 'r';
+        /** The values were summed by category (`aggregation`) rather than binned. */
+        byCategory: boolean;
+        /** A pareto's line: the series the chart lists it as, the axis it is drawn against, and its line. */
+        cumulative?: {
+            id: string;
+            name: string;
+            axisId: number;
+            stroke: Stroke | null;
+        };
+    }
+    /**
+     * How a hierarchy (a sunburst) is drawn: each top-level category, a branch, with everything under
+     * it in the branch's fill; every segment outlined in `border`.
+     */
+    interface Hierarchy {
+        branches: {
+            name: string;
+            fill: IFill.JSON | null;
+        }[];
+        border: Stroke | null;
+    }
+    /**
+     * How a waterfall draws its bars: a step up (a positive value), a step down (a negative one) and a
+     * total, each where the series and its points state nothing; the lines from each bar's end to the
+     * next bar, `null` where they are hidden.
+     */
+    interface Waterfall {
+        increase: {
+            fill: IFill.JSON | null;
+            stroke: Stroke | null;
+        };
+        decrease: {
+            fill: IFill.JSON | null;
+            stroke: Stroke | null;
+        };
+        total: {
+            fill: IFill.JSON | null;
+            stroke: Stroke | null;
+        };
+        connectorLines: Stroke | null;
+    }
+    /** How a bubble group sizes its bubbles. */
+    interface Bubble {
+        /** The largest bubble's size, as a percentage of Excel's default: 0 to 300. */
+        scale: number;
+        /** A bubble's size is its area's (`area`) or its width's (`w`). */
+        sizeRepresents: 'area' | 'w';
+        /** A negative size draws a bubble of its size's magnitude; else none. */
+        showNegative: boolean;
+    }
+    /**
+     * A surface's value bands: one between each major tick of its value axis and the next, each drawn in
+     * its own color, or its own line for a wireframe.
+     */
+    interface Surface {
+        wireframe: boolean;
+        /** A 3-D surface, which Excel draws in perspective; drawn flat from above. */
+        flat: boolean;
+        /** The value axis's scale. */
+        min: number;
+        max: number;
+        majorUnit: number;
+        bands: {
+            from: number;
+            to: number;
+            text: string;
+            fill: IFill.JSON | null;
+            stroke: Stroke | null;
+        }[];
+    }
+    /** A pie of pie or bar of pie's second plot. */
+    interface OfPie {
+        of: 'pie' | 'bar';
+        /** How the points of the second plot are chosen, and by what. */
+        splitType: 'auto' | 'cust' | 'percent' | 'pos' | 'val';
+        splitPos?: number;
+        /** `cust`: the indexes of the points in the second plot. */
+        custSplit: number[];
+        /** The second plot's size, as a percentage of the first pie's. */
+        secondSize: number;
+    }
+    /** A line or stock group's up/down bars. */
+    interface UpDownBars {
+        /** Percent of a bar's width. */
+        gapWidth: number;
+        /** Where the last series' value is above the first's. */
+        up: {
+            fill: IFill.JSON | null;
+            stroke: Stroke | null;
+        };
+        /** Where it is not: below or equal. */
+        down: {
+            fill: IFill.JSON | null;
+            stroke: Stroke | null;
+        };
+    }
+    interface LegendEntry {
+        seriesId: string;
+        /** An entry for one point of the series (a pie's slice), rather than for the series. */
+        pointIndex?: number;
+        /** An entry for the series' trendline of this index, rather than for the series. */
+        trendlineIndex?: number;
+        /** An entry for a surface's value band of this index, rather than for a series. */
+        bandIndex?: number;
+        text: string;
+        /** The kind of key the entry shows. */
+        key: 'bar' | 'line';
+        /** The key's colors, where they are not its series' (a waterfall's increase, decrease and total). */
+        swatch?: {
+            fill: IFill.JSON | null;
+            stroke: Stroke | null;
+        };
+    }
+    interface Legend {
+        position: 'b' | 'tr' | 'l' | 'r' | 't';
+        overlay: boolean;
+        font: Font;
+        fill: IFill.JSON | null;
+        border: Stroke | null;
+        entries: LegendEntry[];
+    }
+}
+//# sourceMappingURL=_ResolvedChart.d.ts.map

package/types/src/collections/RTree.d.ts

@@ -4,26 +4,43 @@ import { RangeCoordValue, RangeCoords } from '@sheetxl/utils';
  *
  * Use this to answer "which items overlap this region?" without a linear scan.
  *
- * @typeParam T must extend `RangeCoordValue` (carries `colStart/rowStart/colEnd/rowEnd`)
+ * {@link clone} is O(1): the copies share every node, and a change to either copies only the
+ * nodes on its path from the root, so each keeps the version it had.
+ *
+ * Items are returned by identity: {@link search} and {@link all} return the objects that were
+ * inserted. An item's coordinates must not change while it is in the tree.
  *
- * @TODO See RTree-REDESIGN.md for planned structural changes.
+ * @typeParam T must extend `RangeCoordValue` (carries `colStart/rowStart/colEnd/rowEnd`)
  */
 export declare class RTree<T extends RangeCoordValue> {
     protected _maxEntries: number;
     protected _minEntries: number;
-    protected _data: Node<T>;
+    /** The nodes and items, shared with every clone of this tree. */
+    protected _arena: Arena<T>;
+    /** The id carried by the arena nodes this tree may write in place. */
+    protected _owner: number;
+    protected _root: number;
+    protected _size: number;
+    /** The nodes reachable from the root; the arena holding many more is what triggers a compaction. */
+    protected _nodes: number;
+    protected _colStart: number;
+    protected _rowStart: number;
+    protected _colEnd: number;
+    protected _rowEnd: number;
     /**
      * Constructs an `RTree`, a high-performance 2D spatial index for points and
      * rectangles. Based on an optimized __R-tree__ data structure with
      * __bulk-insertion__ support.
      *
      * @param maxEntries An optional argument to RTree defines the maximum
-     *                   number of entries in a tree node. `9` (used by default)
-     *                   is a reasonable choice for most applications. Higher
-     *                   value means faster insertion and slower search, and
-     *                   vice versa.
+     *                   number of entries in a tree node, from `4` to `12`. `9`
+     *                   (used by default) is a reasonable choice for most
+     *                   applications. Higher value means faster insertion and
+     *                   slower search, and vice versa.
      */
     constructor(maxEntries?: number);
+    /** Returns the number of items in the tree. */
+    size(): number;
     /** Returns all items contained in the tree. */
     all(result?: T[]): T[];
     /**
@@ -64,6 +81,10 @@ export declare class RTree<T extends RangeCoordValue> {
      * Removes all items.
      */
     clear(): RTree<T>;
+    /**
+     * Returns a copy that shares this tree's nodes; changing either leaves the other as it was.
+     */
+    clone(): this;
     /**
      * Inserts an item. To insert many items at once, use `load()`.
      */
@@ -73,39 +94,98 @@ export declare class RTree<T extends RangeCoordValue> {
      * Pass `equals` to compare by value instead.
      */
     remove(item: T, equals?: (a: T, b: T) => boolean): RTree<T>;
-    protected _all(node: Node<T>, result: T[]): T[];
-    protected _build(items: T[], left: number, right: number, height: number): Node<T>;
-    protected _chooseSubtree(coords: RangeCoordValue, node: Node<T>, level: number, path: Node<T>[]): Node<T>;
-    protected _insert(node: Node<T>, level: number): void;
-    protected _split(insertPath: Node<T>[], level: number): void;
-    protected _splitRoot(node: Node<T>, newNode: Node<T>): void;
-    protected _chooseSplitIndex(node: Node<T>, min: number, length: number): number;
-    protected _chooseSplitAxis(node: Node<T>, min: number, length: number): void;
-    protected _allDistMargin(node: Node<T>, min: number, length: number, compare: (a: Node<T>, b: Node<T>) => number): number;
+    protected _rootIntersects(coords: RangeCoords): boolean;
+    protected _setRootBox(): void;
+    /** The arena, created on the first write: an empty tree holds none. */
+    protected _writableArena(): Arena<T>;
+    /** `node` if this tree owns it, otherwise an owned copy of it that nothing points at yet. */
+    protected _ownDetached(node: number): number;
+    /**
+     * `node` if this tree owns it, otherwise an owned copy put in its place: in slot `slot` of
+     * `parent` (which this tree must own), or as the root when `parent` is `NONE`.
+     */
+    protected _own(node: number, parent: number, slot: number): number;
+    protected _all(node: number, result: T[]): T[];
+    /**
+     * Builds a subtree over `order[left..right]` (indices into `itemBoxes`, four numbers an item,
+     * and into the payload from `first`) and returns its node, leaving its box in `_bx0`..`_bx3` and
+     * its height in `_BuiltHeight`. The same overlap-minimizing tiling as rbush's bulk load.
+     */
+    protected _build(order: Int32Array, itemBoxes: Float64Array, first: number, left: number, right: number, height: number): number;
+    /**
+     * Adds `child` (an item's payload index when `height` is `0`, otherwise a node of height
+     * `height - 1`) to a node of height `height`, copying the shared nodes on the way down and
+     * splitting full ones on the way up.
+     */
+    protected _insertEntry(child: number, colStart: number, rowStart: number, colEnd: number, rowEnd: number, height: number): void;
+    /**
+     * Adds an entry to an owned node; when the node is full, splits it and returns the new sibling
+     * (for the caller to add to the parent), otherwise `NONE`.
+     */
+    protected _addEntry(node: number, child: number, colStart: number, rowStart: number, colEnd: number, rowEnd: number): number;
+    /** Grows the tree by a level: a new root over the old root and `sibling`, of the same height. */
+    protected _splitRoot(sibling: number): void;
+    /**
+     * Finds `item` under `node` as `remove` does: a leaf's items are compared, a node whose children
+     * are leaves has every leaf searched, a deeper node only the children that contain the item. On
+     * a match, records the path in `_RemovePath`/`_RemoveSlots` and the item's slot in `_RemoveSlot`.
+     *
+     * The path is written only on the way back up, after the last call to `equals`, so an `equals`
+     * that uses another tree cannot disturb it.
+     */
+    protected _findItem(node: number, depth: number, item: T, equals: ((a: T, b: T) => boolean) | undefined): boolean;
+    /**
+     * Removes every item under `node` that `isRemove` matches, visiting only children that intersect
+     * the given box. A node is written only when something under it is removed, and copied first
+     * when it is shared, so a subtree with nothing to remove is never copied.
+     *
+     * @returns `UNCHANGED`, `EMPTY` (the node should be removed from its parent), or the node to keep
+     * in its place (a copy when it was shared).
+     */
+    protected _removeWithin(node: number, isRemove: (item: T) => boolean, colStart: number, rowStart: number, colEnd: number, rowEnd: number): number;
+    /**
+     * Compacts when the arena holds much more than this tree reaches: the nodes and items other
+     * versions still use, and the ones no version does. A compaction copies the tree's nodes and
+     * items, so it waits until the unreached nodes outnumber both, which keeps its cost per write
+     * constant.
+     */
+    protected _maybeCompact(): void;
+    /**
+     * Moves this tree into an arena of its own, copying what it reaches depth first so a parent is
+     * next to its first child. Other versions keep the old arena, which is freed with the last of them.
+     */
+    protected _detach(): void;
+    /**
+     * Throws if the tree is inconsistent: heights, boxes, counts, the size and the node count. For
+     * tests.
+     */
+    protected _validate(): void;
 }
 /**
- * Internal R-tree node.
+ * The storage of a tree and every clone of it.
  *
- * - Leaf nodes: `children === null`, `range` is a cast of the user item (`T`), `height === 0`.
- * - Internal nodes: `children` is an array of child nodes, `range` is the mutable aggregate
- *   bounding box of all descendants, `height >= 1`.
+ * Nodes are appended and never freed or rewritten once another version can reach them: a tree
+ * writes a node in place only when the node carries the tree's owner id, and {@link RTree.clone}
+ * gives both trees new ids, so no existing node carries either. That is what makes a clone free
+ * and an old version immutable. The garbage collects as a whole: a tree that reaches much less
+ * than its arena holds moves to a new one ({@link RTree._detach}), and the old one goes when the
+ * last version using it does.
  */
-interface Node<T> {
-    range: RangeCoordValue<T>;
-    children: Node<T>[] | null;
-    height: number;
+declare class Arena<T> {
+    boxes: Float64Array;
+    meta: Int32Array;
+    /** The number of nodes allocated. */
+    top: number;
+    /** Item by payload index. */
+    payload: T[];
+    /** The last owner id handed out. */
+    owners: number;
+    constructor(capacity: number);
+    /** A new node carrying `owner`; may replace `boxes` and `meta`, so neither is held across it. */
+    alloc(owner: number): number;
+    /** Grows the arrays to hold at least `capacity` nodes; replaces `boxes` and `meta` when it does. */
+    reserve(capacity: number): void;
+    nextOwner(): number;
 }
-/**
- * Rearranges items so that all items in the [left, k] are the smallest.
- * The k-th element will have the (k - left + 1)-th smallest value in [left, right].
- *
- * @template T
- * @param arr the array to partially sort (in place)
- * @param k middle index for partial sorting (as defined above)
- * @param left left index of the range to sort
- * @param right right index
- * @param compare compare function
- */
-export declare function quickSelect<T>(arr: T[], k: number, left?: number | undefined, right?: number | undefined, compare?: ((a: T, b: T) => number) | undefined): void;
 export {};
 //# sourceMappingURL=RTree.d.ts.map

package/types/src/collections/SparseGrid.d.ts

@@ -3,6 +3,7 @@ import { Tuple } from './Tuple';
 import { IReadableList } from './IReadableList';
 import { IGrid } from './IGrid';
 import { ISparseGrid } from './ISparseGrid';
+import { IListLike } from './IList';
 /**
  * Implementation of {@link IGrid} that uses a ISparseList of ISparseList.
  */
@@ -89,11 +90,13 @@ export declare namespace SparseGrid {
          */
         axis?: RangeAxis;
         /**
-         * Hook to allow for custom storing of contiguous values.
+         * Makes the list a run of contiguous values is stored as: the one place a value enters this
+         * grid, so a grid with a policy about what it holds applies it here, once per run.
          *
-         * @param values The values to wrap in a List.
+         * @param values The run's values: a writer's array, or a list another grid already held.
+         * @defaultValue wraps the values as they are
          */
-        createRun?: (values: T[]) => IReadableList<T>;
+        createRun?: (values: IListLike<T> | T[]) => IReadableList<T>;
     }
 }
 //# sourceMappingURL=SparseGrid.d.ts.map