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

package/types/src/scripting/declarations.d.ts

@@ -0,0 +1,52 @@
+export declare function getScriptingDeclarations(): Promise<string>;
+/**
+ * The signature index of the script authoring surface — the shipped `scripting-api.json`.
+ *
+ * @remarks
+ * `scripting.d.ts` carries every declaration with its full documentation, which is what an editor
+ * wants. This is the same surface as a lookup table: one entry per declared name, one line per
+ * member, each with where its full declaration sits in `scripting.d.ts`. Both files are written by
+ * one build step from one text, so a name listed here is a name a script type-checks against.
+ */
+export declare namespace ScriptingApi {
+    /** One callable or readable member of a declaration. */
+    interface Member {
+        /** The member's name; `new`, `(call)` and `[index]` for the unnamed signature forms. */
+        readonly name: string;
+        /** The declaration on one line, without its documentation. */
+        readonly signature: string;
+        /** The first sentence of the member's documentation. */
+        readonly summary?: string;
+        readonly deprecated?: true;
+        /** Declared for the type check but not offered: left out of listings, searches and suggestions. */
+        readonly hidden?: true;
+        /** 1-based, inclusive line span in `scripting.d.ts`, documentation included. */
+        readonly lines: readonly [start: number, end: number];
+    }
+    /** One declared name. */
+    interface Entry {
+        readonly kind: 'interface' | 'class' | 'enum' | 'type' | 'const' | 'function' | 'namespace';
+        /** The first sentence of the declaration's documentation. */
+        readonly summary?: string;
+        readonly deprecated?: true;
+        readonly hidden?: true;
+        /** The type parameter list as written, e.g. `<T = any>`. */
+        readonly typeParams?: string;
+        /** The types this one extends, as written. Their members are reachable on this type too. */
+        readonly extends?: readonly string[];
+        /** The declaration on one line — present when there is no member list to show instead. */
+        readonly signature?: string;
+        readonly members?: readonly Member[];
+        /** Names declared in the namespace merged with this one; each is indexed as `<this>.<name>`. */
+        readonly nested?: readonly string[];
+        /** 1-based, inclusive line span in `scripting.d.ts`, documentation included. */
+        readonly lines: readonly [start: number, end: number];
+    }
+    interface Index {
+        readonly version: 1;
+        /** Keyed by the dotted path below `SheetXL` — `ICellRange`, `ICellRange.Coords`. */
+        readonly types: Readonly<Record<string, Entry>>;
+    }
+}
+export declare function getScriptingApi(): Promise<ScriptingApi.Index>;
+//# sourceMappingURL=declarations.d.ts.map

package/types/src/scripting/declarations.node.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Node loaders for the script authoring surface (`scripting.d.ts`) and its signature index
+ * (`scripting-api.json`).
+ *
+ * Selected via the `@sheetxl/sdk/scripting/declarations` conditional export (the `node` condition).
+ */
+export declare function loadScriptingDeclarations(): Promise<string>;
+export declare function loadScriptingApi(): Promise<string>;
+//# sourceMappingURL=declarations.node.d.ts.map

package/types/src/scripting/index.d.ts

@@ -1,4 +1,7 @@
 export * from './IScript';
 export * from './IModule';
+export * from './IModuleCollection';
 export * from './IFunctionCollection';
+export * from './declarations';
+export { getScriptRuntime, withScriptRuntime } from './Runtime';
 //# sourceMappingURL=index.d.ts.map

package/types/src/selection/ChartElementSelection.d.ts

@@ -0,0 +1,39 @@
+import { IListener } from '../listener';
+import { IChart } from '../chart/IChart';
+import { IWorksheet } from '../sheet';
+import { IItemSelection } from './IItemSelection';
+import { IChartElementSelection } from './IChartElementSelection';
+import { ItemSelection } from './ItemSelection';
+/**
+ * The chart element selection of a sheet's view, or of one chart.
+ */
+export declare class ChartElementSelection extends ItemSelection<IChart.IElement> implements IChartElementSelection {
+    protected _sheet: IWorksheet | null;
+    protected _own: IChart | null;
+    /** While elements are selected, the chart's listener that drops what an edit removes. */
+    protected _chartRemoveListener: IListener.Remove | null;
+    constructor(options?: IChartElementSelection.ConstructorOptions);
+    /** {@inheritDoc IChartElementSelection.getChart} */
+    getChart(): IChart | null;
+    /** {@inheritDoc IChartElementSelection.addListeners} */
+    addListeners(listeners: IChartElementSelection.IListeners, options?: IListener.Options): IListener.Remove;
+    /**
+     * Empties the selection when the movable selection no longer holds its chart alone: the view
+     * calls it on every movable selection change.
+     * @internal
+     */
+    _follow(): void;
+    protected _traversal(): readonly IChart.IElement[];
+    /** The chart whose movable is the active selected movable on the sheet, if that is a chart. */
+    private _activeChartOnSheet;
+    protected _comparable(other: IItemSelection<IChart.IElement>): boolean;
+    protected _check(element: IChart.IElement): void;
+    protected _beforeSelect(picks: readonly IChart.IElement[]): void;
+    protected _afterChange(): void;
+    /** Drops the elements the chart no longer has, after an edit. */
+    private _prune;
+    get [Symbol.toStringTag](): string;
+    /** {@inheritDoc IChartElementSelection.isIChartElementSelection} */
+    get isIChartElementSelection(): true;
+}
+//# sourceMappingURL=ChartElementSelection.d.ts.map

package/types/src/selection/IChartElementSelection.d.ts

@@ -0,0 +1,103 @@
+import { IListener } from '../listener';
+import { IChart } from '../chart/IChart';
+import { IWorksheet } from '../sheet';
+import { IItemSelection } from './IItemSelection';
+/**
+ * The elements of a chart that are selected: its title, an axis, a series, a point of one, a
+ * legend entry… (see {@link IChart.IElement}), as Excel selects them with a click inside a chart.
+ *
+ * @remarks
+ * A sheet's view holds one beside its {@link IMovableSelection | movable selection}
+ * ({@link IWorksheetView.getChartElementSelection}). Its elements are always of the one chart whose
+ * movable is the active selected movable: selecting an element of another chart selects that
+ * chart's movable first, alone, and the selection empties when the movable selection moves on.
+ * A chart outside a workbook (`createChart`) takes a selection of its own, made with its chart.
+ *
+ * Every selected element has the same {@link IItemSelection.getContainer | container}; the chart
+ * area is the root and is never selected here: with nothing selected, the chart itself is what
+ * the movable selection holds.
+ *
+ * Which element a press selects is the editor's: Excel selects a series on the first press and
+ * its point on the next ({@link IChart.getElementAt} answers the point).
+ */
+export interface IChartElementSelection extends IItemSelection<IChart.IElement> {
+    /**
+     * Returns the chart the selected elements are of, or `null` when the selection is empty.
+     */
+    getChart(): IChart | null;
+    /**
+     * Selects `elements`, replacing the selection.
+     *
+     * @param elements The elements to select, the last one the active one. All of one chart.
+     * @param options With `add`, extends the selection instead.
+     *
+     * @throws If an element is of a chart this selection cannot reach (another sheet's, or not the
+     * selection's own chart), or the chart no longer has it.
+     */
+    select(elements: readonly IChart.IElement[], options?: IChartElementSelection.SelectOptions): this;
+    /**
+     * Selects the next element the chart shows, alone, among {@link IChart.getElements}: what
+     * pressing an arrow key does with a chart selected.
+     *
+     * @param reverse Selects the previous one instead.
+     *
+     * @remarks
+     * With nothing selected, starts from the chart's first element after the chart area. Does nothing
+     * without a chart to walk: one selected, or the selection's own.
+     */
+    traverse(reverse?: boolean): this;
+    /**
+     * Adds listeners to the selection.
+     *
+     * @param listeners The listeners to add.
+     * @param options Options for the listeners.
+     * @returns A function to remove the listeners.
+     */
+    addListeners(listeners: IChartElementSelection.IListeners, options?: IListener.Options): IListener.Remove;
+    /** For runtime type checking. */
+    readonly isIChartElementSelection: true;
+}
+/**
+ * {@inheritDoc IChartElementSelection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IChartElementSelection}
+ */
+export declare namespace IChartElementSelection {
+    /**
+     * Options for {@link IChartElementSelection.select}.
+     */
+    interface SelectOptions extends IItemSelection.SelectOptions {
+    }
+    /**
+     * Events for {@link IChartElementSelection}.
+     */
+    interface Events {
+        /**
+         * Called when the selected elements, or the active one, change.
+         */
+        onChange?(source: IChartElementSelection): void;
+    }
+    /**
+     * Listeners for {@link IChartElementSelection} events.
+     */
+    interface IListeners extends IListener.Callbacks<IChartElementSelection, Events> {
+    }
+    /**
+     * Options for constructing an {@link IChartElementSelection}: one of the two.
+     */
+    interface ConstructorOptions {
+        /**
+         * The sheet whose charts the selection is of: selecting an element selects its chart's movable
+         * on the sheet's view first, and the selection follows the movable selection.
+         */
+        sheet?: IWorksheet;
+        /**
+         * The one chart the selection is of: for a chart outside a workbook, or a chart drawn outside
+         * its sheet's view.
+         */
+        chart?: IChart;
+    }
+}
+//# sourceMappingURL=IChartElementSelection.d.ts.map

package/types/src/selection/IItemSelection.d.ts

@@ -0,0 +1,131 @@
+import { IListener } from '../listener';
+/**
+ * A selection of items that stand in a tree: drawings on a sheet and the members of groups, or
+ * the elements of a chart. What a selection of either kind does is here; what each kind adds is
+ * on its own interface ({@link IMovableSelection}, {@link IChartElementSelection}).
+ *
+ * @remarks
+ * Every selected item has the same parent, its {@link getContainer | container}. Selecting an item
+ * from another container replaces the selection, as Excel's does: a shape and a member of a group
+ * cannot be selected together, nor a chart's title and a point of one of its series.
+ *
+ * The latest item picked is the {@link getActive | active} one, the one a Format pane shows.
+ *
+ * @typeParam T The kind of item selected.
+ */
+export interface IItemSelection<T extends IItemSelection.Item> {
+    /**
+     * Returns what every selected item shares as its parent: `null` for the root (the sheet, the
+     * chart), else the group or element they are in.
+     *
+     * @remarks
+     * `null` when the selection is empty.
+     */
+    getContainer(): T | null;
+    /**
+     * Returns the selected items, in the order the selection keeps them.
+     */
+    getItems(): readonly T[];
+    /**
+     * Returns the item selected most recently, or `null` when the selection is empty.
+     */
+    getActive(): T | null;
+    /**
+     * Returns `true` if `item` is selected.
+     */
+    isSelected(item: T): boolean;
+    /**
+     * Returns `true` if nothing is selected.
+     */
+    isEmpty(): boolean;
+    /**
+     * Selects `items`, replacing the selection.
+     *
+     * @param items The items to select, the last one the active one.
+     * @param options With `add`, extends the selection instead.
+     *
+     * @remarks
+     * Items are taken in order, as picks: one in another container than those selected before it
+     * replaces them.
+     *
+     * @throws If an item cannot be selected here: it is not where this selection looks, or has
+     * been removed.
+     */
+    select(items: readonly T[], options?: IItemSelection.SelectOptions): this;
+    /**
+     * Removes `items` from the selection. Items not selected are ignored.
+     */
+    unselect(items: readonly T[]): this;
+    /**
+     * Empties the selection.
+     */
+    clear(): this;
+    /**
+     * Selects the next item, alone: what pressing Tab does.
+     *
+     * @param reverse Selects the previous one instead.
+     *
+     * @remarks
+     * Wraps at the ends. With nothing selected, starts from the first (or, in reverse, the last).
+     */
+    traverse(reverse?: boolean): this;
+    /**
+     * Returns `true` if `other` selects the same items, with the same one active.
+     */
+    isEquals(other: IItemSelection<T>): boolean;
+    /**
+     * Adds listeners to the selection.
+     *
+     * @param listeners The listeners to add.
+     * @param options Options for the listeners.
+     * @returns A function to remove the listeners.
+     */
+    addListeners(listeners: IItemSelection.IListeners<T>, options?: IListener.Options): IListener.Remove;
+}
+/**
+ * {@inheritDoc IItemSelection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IItemSelection}
+ */
+export declare namespace IItemSelection {
+    /**
+     * What an item of a selection is: something that knows what it is part of.
+     */
+    interface Item {
+        /**
+         * Returns the item this one is part of, or `null` at the root.
+         */
+        getParent(): Item | null;
+    }
+    /**
+     * Options for {@link IItemSelection.select}.
+     */
+    interface SelectOptions {
+        /**
+         * Extend the selection rather than replace it.
+         *
+         * @remarks
+         * The equivalent of Ctrl+click in the UI.
+         *
+         * @defaultValue false
+         */
+        add?: boolean;
+    }
+    /**
+     * Events for {@link IItemSelection}.
+     */
+    interface Events<T extends Item> {
+        /**
+         * Called when the selected items, or the active one, change.
+         */
+        onChange?(source: IItemSelection<T>): void;
+    }
+    /**
+     * Listeners for {@link IItemSelection} events.
+     */
+    interface IListeners<T extends Item> extends IListener.Callbacks<IItemSelection<T>, Events<T>> {
+    }
+}
+//# sourceMappingURL=IItemSelection.d.ts.map

package/types/src/selection/IMovableSelection.d.ts

@@ -0,0 +1,120 @@
+import { IListener } from '../listener';
+import { IMovable } from '../movable';
+import { IWorksheet } from '../sheet';
+import { IItemSelection } from './IItemSelection';
+/**
+ * The drawings selected on a sheet's view: shapes, pictures, charts, controls, groups and the
+ * members of groups.
+ *
+ * @remarks
+ * The counterpart of {@link IRangeSelection}. A view holds both, independently: selecting a
+ * drawing does not change the range selection and selecting cells does not clear this one. Which
+ * of the two the keyboard acts on is a matter of focus, which belongs to the UI.
+ *
+ * Empty is the usual state, when the cells have the selection.
+ *
+ * Every selected movable has the same parent, its {@link getContainer | container}: the sheet,
+ * or one group. Selecting a movable from another container replaces the selection.
+ */
+export interface IMovableSelection extends IItemSelection<IMovable> {
+    /**
+     * Returns the sheet the selection is on.
+     */
+    getWorksheet(): IWorksheet;
+    /**
+     * Returns what every selected movable shares as its parent: `null` for the sheet, else the
+     * group's movable.
+     *
+     * @remarks
+     * `null` when the selection is empty.
+     */
+    getContainer(): IMovable | null;
+    /**
+     * Returns the selected movables, back to front.
+     *
+     * @remarks
+     * Empty when the cells have the selection.
+     */
+    getItems(): readonly IMovable[];
+    /**
+     * Returns the movable selected most recently, or `null` when the selection is empty.
+     *
+     * @remarks
+     * The one a Format pane shows.
+     */
+    getActive(): IMovable | null;
+    /**
+     * Selects `movables`, replacing the selection.
+     *
+     * @param movables The movables to select, the last one the active one.
+     * @param options With `add`, extends the selection instead.
+     *
+     * @remarks
+     * Movables are taken in order, as picks: one in another container than those selected before it
+     * replaces them.
+     *
+     * @throws If a movable is not on this sheet, or has been deleted.
+     */
+    select(movables: readonly IMovable[], options?: IMovableSelection.SelectOptions): this;
+    /**
+     * Selects the next drawing on the sheet, alone.
+     *
+     * @param reverse Selects the previous one instead.
+     *
+     * @remarks
+     * Visits every drawing back to front, a group and then its members in the group's order. A
+     * hidden drawing is not visited. Wraps at the ends. With nothing selected, starts from the first
+     * (or, in reverse, the last).
+     *
+     * Useful for pressing Tab from the UI.
+     */
+    traverse(reverse?: boolean): this;
+    /**
+     * Adds listeners to the selection.
+     *
+     * @param listeners The listeners to add.
+     * @param options Options for the listeners.
+     * @returns A function to remove the listeners.
+     */
+    addListeners(listeners: IMovableSelection.IListeners, options?: IListener.Options): IListener.Remove;
+    /** For runtime type checking. */
+    readonly isIMovableSelection: true;
+}
+/**
+ * {@inheritDoc IMovableSelection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IMovableSelection}
+ */
+export declare namespace IMovableSelection {
+    /**
+     * Options for {@link IMovableSelection.select}.
+     */
+    interface SelectOptions extends IItemSelection.SelectOptions {
+    }
+    /**
+     * Events for {@link IMovableSelection}.
+     */
+    interface Events {
+        /**
+         * Called when the selected movables, or the active one, change.
+         */
+        onChange?(source: IMovableSelection): void;
+    }
+    /**
+     * Listeners for {@link IMovableSelection} events.
+     */
+    interface IListeners extends IListener.Callbacks<IMovableSelection, Events> {
+    }
+    /**
+     * Options for constructing an {@link IMovableSelection}.
+     */
+    interface ConstructorOptions {
+        /**
+         * The sheet the selection is on.
+         */
+        sheet: IWorksheet;
+    }
+}
+//# sourceMappingURL=IMovableSelection.d.ts.map

package/types/src/selection/IRangeSelection.d.ts

@@ -3,7 +3,7 @@ import { SelectionCoords as WellKnownSelectionCoords, RunCoordValue } from '@she
 import { IListener } from '../listener';
 import { ICell } from '../cell';
 import { ICellRange, ICellRanges } from '../cellRange';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 /**
  * Interface representing a range selection within a sheet.
  */
@@ -23,11 +23,14 @@ export interface IRangeSelection {
      * @param axis The axis to traverse. Default is `ICellRange.Axis.Row`.
      * @param reverse Whether to traverse in reverse. Default is false.
      * @param region An optional bounding region to *wrap within* when there is no explicit selection (a
-     *   bare cursor) — e.g. a table's data range, so Tab/Enter cycle inside it instead of walking off its
-     *   edge. Resolving this region is the caller's job (the view's `getRegionBounds`); omit it (the bare
-     *   sheet) and a bare-cursor traverse is a plain move.
+     *   bare cursor), so the move cycles inside it instead of walking off its edge. Omit it and a
+     *   bare-cursor traverse is a plain move.
      *
-     * @remarks Useful for pressing tab or enter from the UI.
+     * @remarks
+     * Useful for pressing tab or enter from the UI.
+     *
+     * A bare cursor in a table wraps a row traverse (Tab) within the table's data range without being
+     * given a region; a column traverse (Enter) moves on out of the table.
      */
     traverse(axis?: IRange.Axis, reverse?: boolean, region?: IRange.Coords): this;
     /**
@@ -72,9 +75,9 @@ export interface IRangeSelection {
      * A selection's *ranges* may span multiple sheets (each range/cell carries its own optional `scope`
      * sheet name — e.g. a formula's cross-sheet references), but the selection itself is always anchored to
      * one sheet: the one it was constructed with (or, for a {@link create} picker, the sheet it was
-     * derived from). This is that sheet — the analog of {@link ICellRange.getSheet} for a selection.
+     * derived from). This is that sheet — the analog of {@link ICellRange.getWorksheet} for a selection.
      */
-    getSheet(): ISheet;
+    getWorksheet(): IWorksheet;
     /**
      * Returns the selected cell.
      */
@@ -177,6 +180,8 @@ export interface IRangeSelection {
      * @returns A function to remove the listeners.
      */
     addListeners(listeners: IRangeSelection.IListeners, options?: IListener.Options): IListener.Remove;
+    /** For runtime type checking. */
+    readonly isIRangeSelection: true;
 }
 /**
  * {@inheritDoc IRangeSelection}
@@ -268,7 +273,7 @@ export declare namespace IRangeSelection {
         /**
          * The sheet to which the selection belongs.
          */
-        sheet: ISheet;
+        sheet: IWorksheet;
         /**
          * Initial selection coordinates.
          */

package/types/src/selection/ItemSelection.d.ts

@@ -0,0 +1,49 @@
+import { IListener } from '../listener';
+import { IItemSelection } from './IItemSelection';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+/**
+ * The mechanics of an {@link IItemSelection}: the picks, their container, the active item,
+ * replacing and extending, and the listeners. What a kind of selection admits and how it walks
+ * its items for {@link traverse} is the subclass's.
+ */
+export declare abstract class ItemSelection<T extends IItemSelection.Item> implements IItemSelection<T> {
+    protected _emitter: ListenerEmitter<IItemSelection<T>, IItemSelection.IListeners<T>>;
+    /** The selected items in the order they were picked; the last is the active one. */
+    protected _picks: readonly T[];
+    protected _container: T | null;
+    constructor();
+    /** {@inheritDoc IItemSelection.getContainer} */
+    getContainer(): T | null;
+    /** {@inheritDoc IItemSelection.getItems} */
+    getItems(): readonly T[];
+    /** {@inheritDoc IItemSelection.getActive} */
+    getActive(): T | null;
+    /** {@inheritDoc IItemSelection.isSelected} */
+    isSelected(item: T): boolean;
+    /** {@inheritDoc IItemSelection.isEmpty} */
+    isEmpty(): boolean;
+    /** {@inheritDoc IItemSelection.select} */
+    select(items: readonly T[], options?: IItemSelection.SelectOptions): this;
+    /** {@inheritDoc IItemSelection.unselect} */
+    unselect(items: readonly T[]): this;
+    /** {@inheritDoc IItemSelection.clear} */
+    clear(): this;
+    /** {@inheritDoc IItemSelection.traverse} */
+    traverse(reverse?: boolean): this;
+    /** {@inheritDoc IItemSelection.isEquals} */
+    isEquals(other: IItemSelection<T>): boolean;
+    /** {@inheritDoc IItemSelection.addListeners} */
+    addListeners(listeners: IItemSelection.IListeners<T>, options?: IListener.Options): IListener.Remove;
+    /** Throws where `item` cannot be selected here. */
+    protected abstract _check(item: T): void;
+    /** Every item that {@link traverse} visits, in order. */
+    protected abstract _traversal(): readonly T[];
+    /** Whether `other` selects among the same items as this one (the same sheet, the same chart). */
+    protected _comparable(_other: IItemSelection<T>): boolean;
+    /** Called with the picks about to be selected, before the selection changes: for what must come first (selecting the movable a chart is in). */
+    protected _beforeSelect(_picks: readonly T[]): void;
+    /** Called once the selection has changed. */
+    protected _afterChange(): void;
+    protected _update(picks: readonly T[], container: T | null): this;
+}
+//# sourceMappingURL=ItemSelection.d.ts.map

package/types/src/selection/MovableSelection.d.ts

@@ -0,0 +1,29 @@
+import { IListener } from '../listener';
+import { IMovable } from '../movable';
+import { IWorksheet } from '../sheet';
+import { IItemSelection } from './IItemSelection';
+import { IMovableSelection } from './IMovableSelection';
+import { ItemSelection } from './ItemSelection';
+/**
+ * The movable selection of a sheet's view.
+ */
+export declare class MovableSelection extends ItemSelection<IMovable> implements IMovableSelection {
+    protected _sheet: IWorksheet;
+    /** {@link _picks} back to front, handed out again while the z-order holds. */
+    protected _items: readonly IMovable[];
+    constructor(options: IMovableSelection.ConstructorOptions);
+    /** {@inheritDoc IMovableSelection.getWorksheet} */
+    getWorksheet(): IWorksheet;
+    /** {@inheritDoc IMovableSelection.getItems} */
+    getItems(): readonly IMovable[];
+    /** {@inheritDoc IMovableSelection.addListeners} */
+    addListeners(listeners: IMovableSelection.IListeners, options?: IListener.Options): IListener.Remove;
+    protected _traversal(): readonly IMovable[];
+    protected _comparable(other: IItemSelection<IMovable>): boolean;
+    protected _check(movable: IMovable): void;
+    protected _afterChange(): void;
+    get [Symbol.toStringTag](): string;
+    /** {@inheritDoc IMovableSelection.isIMovableSelection} */
+    get isIMovableSelection(): true;
+}
+//# sourceMappingURL=MovableSelection.d.ts.map

package/types/src/selection/RangeSelection.d.ts

@@ -3,14 +3,14 @@ import { RunCoordValue } from '@sheetxl/utils';
 import { IListener } from '../listener';
 import { ICell } from '../cell';
 import { ICellRange, ICellRanges } from '../cellRange';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 import { IRangeSelection } from './IRangeSelection';
 import { ListenerEmitter } from '../listener/ListenerEmitter';
 /**
  * Used for managing selection of a range.
  */
 export declare class RangeSelection {
-    protected _sheet: ISheet;
+    protected _sheet: IWorksheet;
     protected _coords: Required<IRangeSelection.Coords>;
     protected _navigationPolicy: IRangeSelection.NavigationPolicy;
     protected _shapePolicy: IRangeSelection.ShapePolicy;
@@ -26,8 +26,8 @@ export declare class RangeSelection {
     getCoords(): IRangeSelection.Coords;
     /** {@inheritDoc IRangeSelection.hasTopOrLeft} */
     hasTopOrLeft(): boolean;
-    /** {@inheritDoc IRangeSelection.getSheet} */
-    getSheet(): ISheet;
+    /** {@inheritDoc IRangeSelection.getWorksheet} */
+    getWorksheet(): IWorksheet;
     /** {@inheritDoc IRangeSelection.getCell} */
     getCell(): ICell;
     /** {@inheritDoc IRangeSelection.getRange} */
@@ -111,6 +111,19 @@ export declare class RangeSelection {
     protected _setSelectionCell(activeCell: IRange.CellCoords | null): this;
     protected _isCellOutOfBounds(cell: IRange.CellCoords): boolean;
     protected _cellToRangeActual(start: IRange.CellCoords, end: IRange.CellCoords): IRange.Coords;
+    /** `range` grown until it cuts through no merge — see `_SheetUtils.closeOverMerges`. */
+    protected _closeOverMerges<T extends IRange.Coords>(range: T): T;
+    /**
+     * Keeps the selection off merge interiors, whoever wrote it: every range is grown until it cuts
+     * through no merge, and a bare anchor on a merged cell becomes that merge as a range (a merged cell
+     * is never a 1×1). The grid writes selections straight through {@link updateCoords} — a click, a
+     * tap, a fill — so this is the one place that sees them all.
+     *
+     * @remarks
+     * Ranges carrying a `scope` belong to another sheet's geometry (a reference picker's cross-sheet
+     * range) and are left as given — see {@link _localCoords}.
+     */
+    protected _resolveMerges(coords: Required<IRangeSelection.Coords>): Required<IRangeSelection.Coords>;
     protected _rangesFromCellOptional(selection: Required<IRangeSelection.Coords>, cell: Partial<IRange.CellCoords>, cellPivot: Partial<IRange.CellCoords>): IRange.Coords | undefined;
     protected _getEntireRange(): IRange.Coords;
     protected _hiddenRowsAt(index: number, reverse?: boolean): number;
@@ -135,6 +148,8 @@ export declare class RangeSelection {
     protected _scrollCellCoordsIntoView(coords: Partial<IRange.Coords>, options?: globalThis.ScrollIntoViewOptions | boolean): Promise<boolean>;
     get [Symbol.toStringTag](): string;
     toString(): string;
+    /** {@inheritDoc IRangeSelection.isIRangeSelection} */
+    get isIRangeSelection(): true;
 }
 interface _ReadCache {
     range: ICellRange | null;

package/types/src/selection/index.d.ts

@@ -1,2 +1,6 @@
 export * from './IRangeSelection';
+export * from './IItemSelection';
+export * from './IMovableSelection';
+export * from './IChartElementSelection';
+export { ChartElementSelection } from './ChartElementSelection';
 //# sourceMappingURL=index.d.ts.map