@datalayer/cells 0.0.0-stage → 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2026 Datalayer, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,56 @@
-# Temporary Holding Version
+[![Datalayer](https://images.datalayer.io/legacy/datalayer-25.svg)](https://datalayer.ai)
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![Become a Sponsor](https://img.shields.io/static/v1?label=Become%20a%20Sponsor&message=%E2%9D%A4&logo=GitHub&style=flat&color=1ABC9C)](https://github.com/sponsors/datalayer)
+
+# ☰ 🦠 Datalayer Cells
+
+A spreadsheet drawn on canvas and exposed as a React component, over a
+headless model that also runs in Node and in workers. Cells is built on
+[Reactor](https://github.com/datalayer/reactor): every extension point (formula
+functions, cell types, commands, importers and exporters, data sources, the
+collaboration provider) is a Reactor contribution point, and the built-in
+features are Reactor plugins contributing through the same points.
+
+> Work in progress: nothing is published yet.
+
+## Packages
+
+| Import                    | What                                                    |
+| ------------------------- | ------------------------------------------------------- |
+| `@datalayer/cells`        | the React component and hooks; re-exports `./core`      |
+| `@datalayer/cells/core`   | the headless model: no React, no DOM                    |
+| `@datalayer/cells/csv`    | CSV and TSV in and out                                  |
+| `@datalayer/cells/xlsx`   | XLSX in and out, loaded lazily                          |
+| `@datalayer/cells/collab` | real-time collaboration over Loro                       |
+| `@datalayer/cells/chrome` | toolbar, formula bar and sheet tabs                     |
+| `@datalayer/cells/plugin` | views for a Reactor shell                               |
+
+## Development
+
+The reactor is resolved from a checkout beside this repository (`../reactor`).
+
+```bash
+npm install
+npm run lint        # Prettier and the licence header on every file
+npm run typecheck   # everything, tests included, against ../reactor/src
+npm test            # unit tests (vitest, two workers)
+npm run build       # lib/
+npm run bench       # Node benches into bench/results/
+npm run size        # bundle sizes against their budgets
+```
+
+Browser benches and end-to-end tests run on the system Chrome, headless:
+
+```bash
+env -u WAYLAND_DISPLAY -u DISPLAY node scripts/bench.mjs --browser
+```
+
+## Credits
+
+Cells was designed after reading [x-spreadsheet](https://github.com/myliang/x-spreadsheet)
+(MIT) and [o-spreadsheet](https://github.com/odoo/o-spreadsheet) (LGPLv3) for
+ideas; no code of either is included. See [THIRD_PARTY.md](THIRD_PARTY.md).
+
+## License
+
+MIT, see [LICENSE](LICENSE).

package/lib/chrome/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `@datalayer/cells/chrome`: the optional toolbar, formula bar and sheet tabs.
+ *
+ * @module chrome
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/chrome/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/chrome/index.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH,OAAO,EAAE,CAAC"}

package/lib/chrome/index.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2022-2026 Datalayer, Inc.
+ *
+ * MIT License
+ */
+export {};
+//# sourceMappingURL=index.js.map

package/lib/chrome/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/chrome/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/lib/collab/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `@datalayer/cells/collab`: real-time collaboration over Loro.
+ *
+ * @module collab
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/collab/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/collab/index.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH,OAAO,EAAE,CAAC"}

package/lib/collab/index.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2022-2026 Datalayer, Inc.
+ *
+ * MIT License
+ */
+export {};
+//# sourceMappingURL=index.js.map

package/lib/collab/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/collab/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/lib/core/axis.d.ts

@@ -0,0 +1,97 @@
+/**
+ * An axis of a sheet: its rows, or its columns.
+ *
+ * - **Ids.** Every index has a stable id that follows the row through inserts,
+ *   deletes and moves. Ids are materialised only up to the last index ever
+ *   named; beyond, an index has an *implicit* id derived from where the row
+ *   was when the axis was created (`IMPLICIT_BASE + creation index`), so two
+ *   replicas that materialise the same index independently agree on its id.
+ *   Inserted indexes get fresh ids, from `FRESH_BASE` up.
+ * - **Sizes.** Default until the first resize; then a raw `Float64Array` of
+ *   sizes and a Fenwick tree over the effective sizes (0 when hidden), so
+ *   `offsetOf` and `indexAt` are O(log n) and a resize is O(log n). An insert
+ *   or delete rebuilds the tree from the edit point only.
+ * - **Hidden** is a bitset beside the sizes: a hidden index keeps its size for
+ *   unhide and contributes 0 to offsets.
+ *
+ * @module core/axis
+ */
+/** Implicit ids are `IMPLICIT_BASE + creation index`. */
+export declare const IMPLICIT_BASE = 0;
+/** Fresh ids (inserted indexes) start here, above any creation index. */
+export declare const FRESH_BASE: number;
+/** The state of a run of indexes, as patches carry it. */
+export interface AxisSegment {
+    readonly ids: Int32Array;
+    /** `null`: every size is the default. */
+    readonly sizes: Float64Array | null;
+    /** `null`: none is hidden; else 1 per hidden index. */
+    readonly hidden: Uint8Array | null;
+}
+export interface AxisOptions {
+    /** The logical number of indexes (1,048,576 rows, 16,384 columns in Excel). */
+    readonly count: number;
+    /** The size of an index nobody resized, in CSS px. */
+    readonly defaultSize: number;
+}
+export declare class Axis {
+    #private;
+    readonly count: number;
+    readonly defaultSize: number;
+    constructor(options: AxisOptions);
+    /** The id of an index, materialised or implicit. */
+    idAt(index: number): number;
+    /**
+     * Materialise ids up to `index` inclusive and return its id. Anything that
+     * names an index (content, a size, a merge corner, a reference) calls this
+     * first, so no implicit id is ever referenced.
+     */
+    materialize(index: number): number;
+    /** How many ids are materialised. */
+    get materialized(): number;
+    /** The index of an id, or -1. O(n) over the materialised ids; for the binding, not the hot path. */
+    indexOfId(id: number): number;
+    /** A copy of the materialised ids, for snapshots and the file format. */
+    ids(): Int32Array;
+    /** The state of `n` indexes from `at`: ids, sizes and hidden flags, for patches. */
+    segment(at: number, n: number): AxisSegment;
+    /**
+     * Insert `n` indexes before `at`. The count stays: the last `n` indexes fall
+     * off the end (the command checks they are empty), and come back as
+     * `dropped`. With `segment`, the inserted indexes take its ids, sizes and
+     * hidden flags (undo, redo, remote inserts); without, fresh ids and the
+     * default size.
+     */
+    insert(at: number, n: number, segment?: AxisSegment): {
+        inserted: AxisSegment;
+        dropped: AxisSegment;
+    };
+    /**
+     * Delete `n` indexes from `at`; returns them. New indexes appear at the end:
+     * implicit ones, or `tail`'s when given (undoing an insert brings back the
+     * indexes it pushed off).
+     */
+    delete(at: number, n: number, tail?: AxisSegment): AxisSegment;
+    /**
+     * Move `n` indexes from `at` to before `to` (an index in the coordinates
+     * before the move, outside `[at, at + n]`). Ids, sizes and hidden flags travel.
+     */
+    move(at: number, n: number, to: number): void;
+    /** Set sizes and hidden flags of `n` indexes from `at` at once (patches). */
+    setSegmentSizes(at: number, sizes: Float64Array | null, hidden: Uint8Array | null, n: number): void;
+    /** The size of an index as set, hidden or not. */
+    sizeOf(index: number): number;
+    /** The size an index takes on screen: 0 when hidden. */
+    effectiveSizeOf(index: number): number;
+    /** Set the size of an index. O(log n). */
+    resize(index: number, size: number): void;
+    isHidden(index: number): boolean;
+    setHidden(index: number, hidden: boolean): void;
+    /** The offset of an index's start: the sum of the effective sizes before it. O(log n). */
+    offsetOf(index: number): number;
+    /** The total extent of the axis. */
+    get extent(): number;
+    /** The index under an offset: the last index whose start is at or before it. O(log n). */
+    indexAt(offset: number): number;
+}
+//# sourceMappingURL=axis.d.ts.map

package/lib/core/axis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axis.d.ts","sourceRoot":"","sources":["../../src/core/axis.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;GAiBG;AAEH,yDAAyD;AACzD,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,yEAAyE;AACzE,eAAO,MAAM,UAAU,QAAU,CAAC;AAElC,0DAA0D;AAC1D,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;IACzB,yCAAyC;IACzC,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;IACpC,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,WAAW;IAC1B,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sDAAsD;IACtD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,qBAAa,IAAI;;IACf,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAcjB,OAAO,EAAE,WAAW;IAehC,oDAAoD;IACpD,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAM3B;;;;OAIG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAalC,qCAAqC;IACrC,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,oGAAoG;IACpG,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAS7B,yEAAyE;IACzE,GAAG,IAAI,UAAU;IAMjB,oFAAoF;IACpF,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW;IAU3C;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG;QAAE,QAAQ,EAAE,WAAW,CAAC;QAAC,OAAO,EAAE,WAAW,CAAA;KAAE;IAkCrG;;;;OAIG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,WAAW;IA8B9D;;;OAGG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IA8B7C,6EAA6E;IAC7E,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAenG,kDAAkD;IAClD,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAK7B,wDAAwD;IACxD,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAItC,0CAA0C;IAC1C,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAWzC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAMhC,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAU/C,0FAA0F;IAC1F,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAU/B,oCAAoC;IACpC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,0FAA0F;IAC1F,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;CA+FhC"}

package/lib/core/axis.js

@@ -0,0 +1,431 @@
+/*
+ * Copyright (c) 2022-2026 Datalayer, Inc.
+ *
+ * MIT License
+ */
+/**
+ * An axis of a sheet: its rows, or its columns.
+ *
+ * - **Ids.** Every index has a stable id that follows the row through inserts,
+ *   deletes and moves. Ids are materialised only up to the last index ever
+ *   named; beyond, an index has an *implicit* id derived from where the row
+ *   was when the axis was created (`IMPLICIT_BASE + creation index`), so two
+ *   replicas that materialise the same index independently agree on its id.
+ *   Inserted indexes get fresh ids, from `FRESH_BASE` up.
+ * - **Sizes.** Default until the first resize; then a raw `Float64Array` of
+ *   sizes and a Fenwick tree over the effective sizes (0 when hidden), so
+ *   `offsetOf` and `indexAt` are O(log n) and a resize is O(log n). An insert
+ *   or delete rebuilds the tree from the edit point only.
+ * - **Hidden** is a bitset beside the sizes: a hidden index keeps its size for
+ *   unhide and contributes 0 to offsets.
+ *
+ * @module core/axis
+ */
+/** Implicit ids are `IMPLICIT_BASE + creation index`. */
+export const IMPLICIT_BASE = 0;
+/** Fresh ids (inserted indexes) start here, above any creation index. */
+export const FRESH_BASE = 1 << 30;
+export class Axis {
+    count;
+    defaultSize;
+    /** Materialised ids, `[0, #length)`; the buffer grows by doubling. */
+    #ids = new Int32Array(0);
+    #length = 0;
+    /** The creation index of the first implicit index (`#length`). */
+    #implicitStart = 0;
+    #nextFresh = FRESH_BASE;
+    /** `null` until the first non-default size or hidden index. */
+    #sizes = null;
+    #tree = null;
+    #hidden = null;
+    constructor(options) {
+        if (!Number.isInteger(options.count) || options.count < 1 || options.count > FRESH_BASE - 1) {
+            throw new Error(`An axis holds 1 to ${FRESH_BASE - 1} indexes; ${options.count} was asked for.`);
+        }
+        if (!(options.defaultSize > 0)) {
+            throw new Error(`An axis's default size must be positive; ${options.defaultSize} was given.`);
+        }
+        this.count = options.count;
+        this.defaultSize = options.defaultSize;
+    }
+    // ---------------------------------------------------------------- ids
+    /** The id of an index, materialised or implicit. */
+    idAt(index) {
+        this.#check(index);
+        if (index < this.#length)
+            return this.#ids[index];
+        return IMPLICIT_BASE + this.#implicitStart + (index - this.#length);
+    }
+    /**
+     * Materialise ids up to `index` inclusive and return its id. Anything that
+     * names an index (content, a size, a merge corner, a reference) calls this
+     * first, so no implicit id is ever referenced.
+     */
+    materialize(index) {
+        this.#check(index);
+        if (index >= this.#length) {
+            const n = index + 1 - this.#length;
+            this.#reserve(index + 1);
+            for (let k = 0; k < n; k += 1)
+                this.#ids[this.#length + k] = IMPLICIT_BASE + this.#implicitStart + k;
+            this.#implicitStart += n;
+            this.#length = index + 1;
+        }
+        return this.#ids[index];
+    }
+    /** How many ids are materialised. */
+    get materialized() {
+        return this.#length;
+    }
+    /** The index of an id, or -1. O(n) over the materialised ids; for the binding, not the hot path. */
+    indexOfId(id) {
+        for (let i = 0; i < this.#length; i += 1)
+            if (this.#ids[i] === id)
+                return i;
+        if (id >= IMPLICIT_BASE + this.#implicitStart && id < FRESH_BASE) {
+            const index = this.#length + (id - IMPLICIT_BASE - this.#implicitStart);
+            return index < this.count ? index : -1;
+        }
+        return -1;
+    }
+    /** A copy of the materialised ids, for snapshots and the file format. */
+    ids() {
+        return this.#ids.slice(0, this.#length);
+    }
+    // ---------------------------------------------------------------- structure
+    /** The state of `n` indexes from `at`: ids, sizes and hidden flags, for patches. */
+    segment(at, n) {
+        this.#checkSpan(at, n, false);
+        this.materialize(at + n - 1);
+        return {
+            ids: this.#ids.slice(at, at + n),
+            sizes: this.#sizes === null ? null : this.#sizes.slice(at, at + n),
+            hidden: this.#hidden === null ? null : Uint8Array.from({ length: n }, (_, k) => (this.isHidden(at + k) ? 1 : 0)),
+        };
+    }
+    /**
+     * Insert `n` indexes before `at`. The count stays: the last `n` indexes fall
+     * off the end (the command checks they are empty), and come back as
+     * `dropped`. With `segment`, the inserted indexes take its ids, sizes and
+     * hidden flags (undo, redo, remote inserts); without, fresh ids and the
+     * default size.
+     */
+    insert(at, n, segment) {
+        this.#checkSpan(at, n, true);
+        if (segment !== undefined && segment.ids.length !== n) {
+            throw new Error(`insert: ${n} indexes but a segment of ${segment.ids.length}.`);
+        }
+        const dropped = this.segment(this.count - n, n);
+        let ids;
+        if (segment !== undefined)
+            ids = segment.ids.slice();
+        else {
+            ids = new Int32Array(n);
+            for (let k = 0; k < n; k += 1)
+                ids[k] = this.#nextFresh++;
+        }
+        if (at > this.#length)
+            this.materialize(at - 1);
+        this.#reserve(Math.min(this.#length + n, this.count));
+        this.#ids.copyWithin(at + n, at, Math.min(this.#length, this.count - n));
+        this.#ids.set(ids, at);
+        this.#length = Math.min(this.#length + n, this.count);
+        const needsSizes = this.#sizes !== null || segment?.sizes != null || segment?.hidden != null;
+        if (needsSizes) {
+            this.#allocate();
+            const sizes = this.#sizes;
+            sizes.copyWithin(at + n, at, this.count - n);
+            if (segment?.sizes)
+                sizes.set(segment.sizes, at);
+            else
+                sizes.fill(this.defaultSize, at, at + n);
+            if (this.#hidden !== null || segment?.hidden) {
+                if (this.#hidden === null)
+                    this.#hidden = new Uint32Array(Math.ceil(this.count / 32));
+                shiftBits(this.#hidden, this.count, at, n);
+                if (segment?.hidden)
+                    for (let k = 0; k < n; k += 1)
+                        if (segment.hidden[k])
+                            this.#setBit(at + k, true);
+            }
+            this.#rebuildFrom(at);
+        }
+        return { inserted: { ids, sizes: segment?.sizes ?? null, hidden: segment?.hidden ?? null }, dropped };
+    }
+    /**
+     * Delete `n` indexes from `at`; returns them. New indexes appear at the end:
+     * implicit ones, or `tail`'s when given (undoing an insert brings back the
+     * indexes it pushed off).
+     */
+    delete(at, n, tail) {
+        this.#checkSpan(at, n, false);
+        if (tail !== undefined && tail.ids.length !== n) {
+            throw new Error(`delete: ${n} indexes but a tail of ${tail.ids.length}.`);
+        }
+        const removed = this.segment(at, n);
+        if (tail !== undefined)
+            this.materialize(this.count - 1);
+        this.#ids.copyWithin(at, at + n, this.#length);
+        this.#length -= n;
+        if (tail !== undefined) {
+            this.#ids.set(tail.ids, this.count - n);
+            this.#length = this.count;
+        }
+        const needsSizes = this.#sizes !== null || tail?.sizes != null || tail?.hidden != null;
+        if (needsSizes) {
+            this.#allocate();
+            const sizes = this.#sizes;
+            sizes.copyWithin(at, at + n, this.count);
+            if (tail?.sizes)
+                sizes.set(tail.sizes, this.count - n);
+            else
+                sizes.fill(this.defaultSize, this.count - n, this.count);
+            if (this.#hidden !== null || tail?.hidden) {
+                if (this.#hidden === null)
+                    this.#hidden = new Uint32Array(Math.ceil(this.count / 32));
+                shiftBits(this.#hidden, this.count, at, -n);
+                if (tail?.hidden)
+                    for (let k = 0; k < n; k += 1)
+                        if (tail.hidden[k])
+                            this.#setBit(this.count - n + k, true);
+            }
+            this.#rebuildFrom(at);
+        }
+        return removed;
+    }
+    /**
+     * Move `n` indexes from `at` to before `to` (an index in the coordinates
+     * before the move, outside `[at, at + n]`). Ids, sizes and hidden flags travel.
+     */
+    move(at, n, to) {
+        this.#checkSpan(at, n, false);
+        if (!Number.isInteger(to) || to < 0 || to > this.count || (to >= at && to <= at + n)) {
+            throw new Error(`Cannot move ${n} index(es) at ${at} to ${to}.`);
+        }
+        const lo = Math.min(at, to);
+        const hi = Math.max(at + n, to);
+        this.materialize(hi - 1);
+        const rotate = (arr) => {
+            const part = arr.slice(at, at + n);
+            if (to < at) {
+                arr.copyWithin(to + n, to, at);
+                arr.set(part, to);
+            }
+            else {
+                arr.copyWithin(at, at + n, to);
+                arr.set(part, to - n);
+            }
+        };
+        rotate(this.#ids);
+        if (this.#sizes !== null) {
+            rotate(this.#sizes);
+            if (this.#hidden !== null) {
+                const flags = Float64Array.from({ length: this.count }, (_, i) => (i >= lo && i < hi && this.isHidden(i) ? 1 : 0));
+                rotate(flags);
+                for (let i = lo; i < hi; i += 1)
+                    this.#setBit(i, flags[i] === 1);
+            }
+            this.#rebuildFrom(lo);
+        }
+    }
+    /** Set sizes and hidden flags of `n` indexes from `at` at once (patches). */
+    setSegmentSizes(at, sizes, hidden, n) {
+        this.#checkSpan(at, n, false);
+        if (sizes === null && hidden === null && this.#sizes === null)
+            return;
+        this.#allocate();
+        if (sizes)
+            this.#sizes.set(sizes, at);
+        else
+            this.#sizes.fill(this.defaultSize, at, at + n);
+        if (hidden || this.#hidden !== null) {
+            if (this.#hidden === null)
+                this.#hidden = new Uint32Array(Math.ceil(this.count / 32));
+            for (let k = 0; k < n; k += 1)
+                this.#setBit(at + k, hidden ? hidden[k] === 1 : false);
+        }
+        this.#rebuildFrom(at);
+    }
+    // ---------------------------------------------------------------- sizes
+    /** The size of an index as set, hidden or not. */
+    sizeOf(index) {
+        this.#check(index);
+        return this.#sizes === null ? this.defaultSize : this.#sizes[index];
+    }
+    /** The size an index takes on screen: 0 when hidden. */
+    effectiveSizeOf(index) {
+        return this.isHidden(index) ? 0 : this.sizeOf(index);
+    }
+    /** Set the size of an index. O(log n). */
+    resize(index, size) {
+        this.#check(index);
+        if (!(size > 0) || !Number.isFinite(size))
+            throw new Error(`A size must be positive; ${size} was given.`);
+        this.#allocate();
+        const before = this.effectiveSizeOf(index);
+        this.#sizes[index] = size;
+        const after = this.effectiveSizeOf(index);
+        if (after !== before)
+            this.#add(index, after - before);
+    }
+    isHidden(index) {
+        this.#check(index);
+        const h = this.#hidden;
+        return h !== null && (h[index >>> 5] & (1 << (index & 31))) !== 0;
+    }
+    setHidden(index, hidden) {
+        if (this.isHidden(index) === hidden)
+            return;
+        this.#allocate();
+        if (this.#hidden === null)
+            this.#hidden = new Uint32Array(Math.ceil(this.count / 32));
+        const size = this.#sizes[index];
+        if (hidden)
+            this.#hidden[index >>> 5] |= 1 << (index & 31);
+        else
+            this.#hidden[index >>> 5] &= ~(1 << (index & 31));
+        this.#add(index, hidden ? -size : size);
+    }
+    /** The offset of an index's start: the sum of the effective sizes before it. O(log n). */
+    offsetOf(index) {
+        if (!Number.isInteger(index) || index < 0 || index > this.count) {
+            throw new Error(`No offset at index ${index} of an axis of ${this.count}.`);
+        }
+        if (this.#tree === null)
+            return index * this.defaultSize;
+        let sum = 0;
+        for (let i = index; i > 0; i -= i & -i)
+            sum += this.#tree[i];
+        return sum;
+    }
+    /** The total extent of the axis. */
+    get extent() {
+        return this.offsetOf(this.count);
+    }
+    /** The index under an offset: the last index whose start is at or before it. O(log n). */
+    indexAt(offset) {
+        if (offset <= 0)
+            return this.#firstVisibleFrom(0);
+        if (this.#tree === null)
+            return Math.min(Math.floor(offset / this.defaultSize), this.count - 1);
+        const tree = this.#tree;
+        let pos = 0;
+        let rest = offset;
+        for (let step = highestPowerOfTwo(this.count); step > 0; step >>= 1) {
+            const next = pos + step;
+            if (next <= this.count && tree[next] <= rest) {
+                pos = next;
+                rest -= tree[next];
+            }
+        }
+        // `pos` indexes end at or before the offset; the one under it is `pos`,
+        // or the last index when the offset is past the end.
+        return Math.min(pos, this.count - 1);
+    }
+    // ---------------------------------------------------------------- internals
+    #firstVisibleFrom(index) {
+        let i = index;
+        while (i < this.count - 1 && this.effectiveSizeOf(i) === 0)
+            i += 1;
+        return i;
+    }
+    #allocate() {
+        if (this.#sizes !== null)
+            return;
+        this.#sizes = new Float64Array(this.count).fill(this.defaultSize);
+        this.#tree = new Float64Array(this.count + 1);
+        this.#rebuildFrom(0);
+    }
+    #setBit(index, on) {
+        const h = this.#hidden;
+        if (on)
+            h[index >>> 5] |= 1 << (index & 31);
+        else
+            h[index >>> 5] &= ~(1 << (index & 31));
+    }
+    #add(index, delta) {
+        const tree = this.#tree;
+        for (let i = index + 1; i <= this.count; i += i & -i)
+            tree[i] += delta;
+    }
+    /**
+     * Recompute the Fenwick nodes covering indexes `>= from`, in one pass:
+     * node i holds prefix(i) - prefix(i - lowbit(i)); prefixes below `from`
+     * come from the still-valid lower nodes, those above from a running sum.
+     */
+    #rebuildFrom(from) {
+        const tree = this.#tree;
+        const n = this.count;
+        const start = from + 1;
+        const below = this.#prefixFromTree(from);
+        const running = new Float64Array(n - from + 1);
+        running[0] = below;
+        let sum = below;
+        for (let i = start; i <= n; i += 1) {
+            sum += this.effectiveSizeOf(i - 1);
+            running[i - from] = sum;
+            const lower = i - (i & -i);
+            const lowerPrefix = lower >= from ? running[lower - from] : this.#prefixFromTree(lower);
+            tree[i] = sum - lowerPrefix;
+        }
+    }
+    #prefixFromTree(index) {
+        const tree = this.#tree;
+        let sum = 0;
+        for (let i = index; i > 0; i -= i & -i)
+            sum += tree[i];
+        return sum;
+    }
+    #reserve(length) {
+        if (length <= this.#ids.length)
+            return;
+        let capacity = Math.max(64, this.#ids.length);
+        while (capacity < length)
+            capacity *= 2;
+        const ids = new Int32Array(Math.min(capacity, this.count + 1));
+        ids.set(this.#ids.subarray(0, this.#length));
+        this.#ids = ids;
+    }
+    #check(index) {
+        if (!Number.isInteger(index) || index < 0 || index >= this.count) {
+            throw new Error(`Index ${index} is outside an axis of ${this.count}.`);
+        }
+    }
+    #checkSpan(at, n, inserting) {
+        if (!Number.isInteger(n) || n < 1)
+            throw new Error(`A span needs at least one index; ${n} was given.`);
+        if (!Number.isInteger(at) || at < 0 || at + n > this.count || (inserting && at >= this.count)) {
+            throw new Error(`${n} index(es) at ${at} do not fit an axis of ${this.count}.`);
+        }
+    }
+}
+function highestPowerOfTwo(n) {
+    let p = 1;
+    while (p * 2 <= n)
+        p *= 2;
+    return p;
+}
+/** Shift the bits at and after `at` by `n` (negative: towards `at`, dropping `-n` bits). */
+function shiftBits(bits, count, at, n) {
+    const get = (i) => (bits[i >>> 5] & (1 << (i & 31))) !== 0;
+    const set = (i, v) => {
+        if (v)
+            bits[i >>> 5] |= 1 << (i & 31);
+        else
+            bits[i >>> 5] &= ~(1 << (i & 31));
+    };
+    if (n > 0) {
+        for (let i = count - 1; i >= at + n; i -= 1)
+            set(i, get(i - n));
+        for (let i = at; i < at + n; i += 1)
+            set(i, false);
+    }
+    else {
+        const m = -n;
+        for (let i = at; i < count - m; i += 1)
+            set(i, get(i + m));
+        for (let i = count - m; i < count; i += 1)
+            set(i, false);
+    }
+}
+//# sourceMappingURL=axis.js.map