@tissuumaps/render 0.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,2599 @@
+import { Color } from '@tissuumaps/core';
+import { CustomTileSource } from '@tissuumaps/core';
+import { default as default_2 } from 'openseadragon';
+import { Dims } from '@tissuumaps/core';
+import { GroupValueMap } from '@tissuumaps/core';
+import { IDArray } from '@tissuumaps/core';
+import { Image as Image_2 } from '@tissuumaps/core';
+import { ImageData as ImageData_2 } from '@tissuumaps/core';
+import { InteractionMode } from '@tissuumaps/core';
+import { Labels } from '@tissuumaps/core';
+import { LabelsData } from '@tissuumaps/core';
+import { Layer } from '@tissuumaps/core';
+import { Marker } from '@tissuumaps/core';
+import { MultiPolygon } from '@tissuumaps/core';
+import { OpenSeadragonViewerOptions } from '@tissuumaps/core';
+import { Points } from '@tissuumaps/core';
+import { PointsData } from '@tissuumaps/core';
+import { PointsGeometry } from '@tissuumaps/core';
+import { Rect } from '@tissuumaps/core';
+import { Shapes } from '@tissuumaps/core';
+import { ShapesData } from '@tissuumaps/core';
+import { Table } from '@tissuumaps/core';
+import { TableData } from '@tissuumaps/core';
+import { TileSourceConfig } from '@tissuumaps/core';
+import { TypedArray } from '@tissuumaps/core';
+import { WebGLPointsRenderOptions } from '@tissuumaps/core';
+import { WebGLShapesRenderOptions } from '@tissuumaps/core';
+
+/**
+ * Recolors the tiles of a tiled image whose pixels carry values rather than colors
+ *
+ * `getTileData` extracts the raw pixel values of an invalidated tile, in row-major
+ * order, one per raster pixel, along with the width and height of the raster.
+ * The raster may cover the full tile size rather than the tile's source bounds,
+ * as OpenSeadragon crops it when drawing. `transferValues` writes the packed RGBA
+ * color of each value to the pixel at the same index, as `0xAABBGGRR`, i.e.
+ * `(a << 24) | (b << 16) | (g << 8) | r` (see
+ * {@link OpenSeadragonContext.updateTiledImageDataTransfer}). It is called
+ * once per tile, with `pixelBuffer` as long as `values`. The buffer is reused
+ * across tiles and still holds the colors of the previous one, so every pixel
+ * has to be written.
+ */
+declare type DataTransfer_2 = {
+    getTileData: (event: default_2.TileInvalidatedEvent) => Promise<{
+        values: TypedArray;
+        width: number;
+        height: number;
+    }>;
+    transferValues: (values: TypedArray, pixelBuffer: Uint32Array) => void;
+};
+
+/**
+ * A reference to either an image or labels object on a specific layer
+ *
+ * The reference of a rendered object carries the layer and object as they were
+ * when the reference was loaded; the properties applied to its tiled images
+ * come from the current model instead (see
+ * {@link OpenSeadragonRendererBase._updateRenderedObject}).
+ */
+declare type ObjectRef<TObject extends Image_2 | Labels, TObjectData extends ImageData_2 | LabelsData> = {
+    layer: Layer;
+    object: TObject;
+    data: TObjectData;
+};
+
+/**
+ * A reference to a points or shapes object on a specific layer
+ *
+ * Identifies the layer, and carries the object as it was when the reference was
+ * loaded: everything that is resolved into a GPU resource is read from it, so
+ * that one synchronization sees one consistent model state, however often the
+ * model is set while it runs. The properties that are applied when drawing are
+ * not read from it - those come from the current model, which may have moved on
+ * since (see {@link WebGLRendererBase.getRenderPasses}).
+ *
+ * The item IDs and the item mask are cached and shared between references and
+ * across calls to {@link WebGLRendererBase.loadObjects}, and must not be
+ * modified.
+ */
+declare type ObjectRef_2<TObject extends Points | Shapes, TObjectData extends PointsData | ShapesData> = {
+    layerId: string;
+    object: TObject;
+    itemIds: IDArray;
+    itemsMask: Uint8Array | undefined;
+    data: TObjectData;
+};
+
+/**
+ * A wrapper around an OpenSeadragon viewer
+ *
+ * In addition to creating and destroying the viewer, this class manages viewer
+ * options (including temporary overrides while the viewer is animating) and
+ * mutations of the viewer's world.
+ *
+ * Additions are split in two: tile sources are opened concurrently, but the
+ * world itself is mutated one operation at a time. World indices are shared
+ * mutable state that every addition and removal invalidates, and OpenSeadragon
+ * applies the `index` option only once an addition is committed - a microtask or
+ * more after it was requested - so an index is valid only while nothing else
+ * touches the world in between. Removals therefore go through the same queue as
+ * additions, rather than being applied right away. Reordering the world
+ * afterwards is not an alternative: the navigator mirrors index changes
+ * positionally and on a timer, and corrupts its own world if it has not caught
+ * up yet.
+ *
+ * Queued world mutations are ordered by request, so a caller that removes tiled
+ * images before requesting additions still resolves its indices against the
+ * world as it is once those removals have been applied.
+ *
+ * Tiled images can also be recolored: a tiled image whose pixels carry values
+ * rather than colors is drawn by mapping each value to an RGBA color (see
+ * {@link updateTiledImageDataTransfer}). As OpenSeadragon has no notion of a
+ * per-image color mapping, it is applied to the tiles themselves, in a
+ * `tile-invalidated` handler installed on the viewer. Data transfers are kept
+ * per tile source, rather than per tiled image, which also covers the
+ * navigator: it mirrors the world with tiled images of its own, but shares
+ * their tile sources, and OpenSeadragon raises the invalidation events of its
+ * tiles on this viewer. Its tiles are cached separately, though, so the
+ * navigator's mirror of a tiled image is invalidated alongside the original
+ * whenever the data transfer changes.
+ *
+ * The context also owns the world background: an opaque single-tile image at
+ * world index 0 that spans the bounds registered by every source via
+ * {@link setContentBounds} - the content of each renderer, and content rendered
+ * outside OpenSeadragon, such as points and shapes. It thereby fits the world,
+ * and with it the viewport, to all content, and it makes the drawer's canvas
+ * opaque wherever content is drawn, which additive compositing relies on (see
+ * `OpenSeadragonRendererBase.usesAdditiveBlending`). Its color is given on
+ * construction and is expected to match the background behind the viewer,
+ * which shows outside of it. Renderers insert their anchors after it, i.e. at
+ * world index 1 and up. See {@link _resizeBackground} for how it is resized
+ * without ever uncovering the canvas.
+ */
+export declare class OpenSeadragonContext {
+    private static readonly _isLittleEndian;
+    private static readonly _emptyWorldBounds;
+    private static readonly _navigationKeyCodes;
+    readonly viewer: default_2.Viewer;
+    private readonly _tileSourceDataTransfers;
+    private readonly _tileDataTransfers;
+    private readonly _backgroundPixelUrl;
+    private readonly _contentBounds;
+    private _animationMemory?;
+    private _animationStartHandler?;
+    private _animationFinishHandler?;
+    private _worldMutationQueue;
+    private _pixelBuffer;
+    private _destroyed;
+    private _viewportControlledByUser;
+    private _background;
+    private _backgroundUpdateQueue;
+    /**
+     * Creates a new OpenSeadragonContext instance and initializes the OpenSeadragon viewer
+     *
+     * @param viewerElement - DOM element in which the OpenSeadragon viewer is created
+     * @param backgroundColor - Color of the world background (see the class
+     * documentation), which has to match the background of `viewerElement`
+     * @param viewerOptions - Options for configuring the OpenSeadragon viewer (optional)
+     */
+    constructor(viewerElement: HTMLElement, backgroundColor: Color, viewerOptions?: OpenSeadragonViewerOptions);
+    /**
+     * Installs OpenSeadragon `animation-start` and `animation-finish` handlers
+     *
+     * On animation start, the current values of all keys of the start options are
+     * saved (for the viewer and for each tiled image having such a property) and
+     * the start options are applied. On animation finish, the saved values are
+     * restored, overridden by the finish options.
+     *
+     * Only keys of the start options are saved and restored; keys appearing solely
+     * in the finish options are applied without ever being reverted. Likewise, only
+     * tiled images present at animation start have their values restored.
+     *
+     * Calling this method again replaces any previously installed handlers.
+     *
+     * @param viewerAnimationStartOptions - Options to apply when an animation starts
+     * @param viewerAnimationFinishOptions - Options to apply when an animation finishes
+     */
+    configureAnimationHandlers(viewerAnimationStartOptions: OpenSeadragonViewerOptions, viewerAnimationFinishOptions: OpenSeadragonViewerOptions): void;
+    /**
+     * Returns whether {@link destroy} has been called
+     *
+     * Turns `true` as soon as destruction starts, i.e. before pending world
+     * mutations have settled and before the viewer is actually destroyed. Further
+     * additions are rejected and further removals are ignored from that point on.
+     */
+    isDestroyed(): boolean;
+    /**
+     * Returns the currently visible viewport bounds in world coordinates
+     *
+     * Reflects the current viewport, not the target of an ongoing animation.
+     */
+    getViewport(): Rect;
+    /**
+     * Returns the size of the viewer container element, in screen-space pixels
+     */
+    getContainerSize(): Dims;
+    /**
+     * Applies viewer options to the OpenSeadragon viewer and all existing tiled images
+     *
+     * For each option key, performs a shallow merge (one level deep) of nested objects
+     * on both the viewer instance and every tiled image in the world.
+     *
+     * @param viewerOptions - Options to apply
+     */
+    setViewerOptions(viewerOptions: OpenSeadragonViewerOptions): void;
+    /**
+     * Resolves a tile source specifier to a ready-to-use OpenSeadragon tile source
+     *
+     * Fetches the image information if the specifier is a URL, awaits promised
+     * tile sources, and passes ready tile sources through. Doing this before an
+     * addition keeps the loading concurrent, while the additions themselves stay
+     * serialized (see {@link addTiledImage}).
+     *
+     * Rejects as soon as the operation is aborted, so that nothing waits for an
+     * abandoned open; the open itself cannot be canceled, and settles unobserved.
+     *
+     * @param tiledImageOptions - Options containing the tile source to open
+     * @param options - Optional abort signal
+     * @returns A promise that resolves with the opened tile source
+     */
+    openTileSource(tiledImageOptions: Omit<default_2.TileSourceSpecifier, "success" | "error">, options?: {
+        signal?: AbortSignal;
+    }): Promise<default_2.TileSource>;
+    /**
+     * Adds a tiled image to the OpenSeadragon viewer
+     *
+     * The tile source is opened right away, i.e. concurrently with the tile sources
+     * of other additions, but the tiled images are added to the world one after
+     * another, in the order in which they were requested. The index is resolved in
+     * between, when nothing else can shift the world anymore.
+     *
+     * The tile source may also be a promise of an already opened tile source,
+     * which is only awaited once the addition is executed. Callers can thus derive
+     * a tile source from another one that is still being opened, without giving up
+     * their place in the queue and thereby their world index.
+     *
+     * Rejects right away once the context has been destroyed.
+     *
+     * Aborting before the addition is executed skips it entirely. Later than that,
+     * the pending tile source load cannot be canceled anymore: the tiled image is
+     * added, immediately removed again, and the returned promise rejects with the
+     * signal's reason. Aborting a replacement (`tiledImageOptions.replace`) instead
+     * resolves, as the replaced tiled image is already gone by then and removing
+     * the new one, too, would leave a gap in the world.
+     *
+     * @param tiledImageOptions - Options for adding the tiled image, including the tile source
+     * @param options - Optional abort signal and index resolver. The latter takes
+     * precedence over `tiledImageOptions.index`, and appends the tiled image to the
+     * world if it returns `undefined`.
+     * @returns A promise that resolves with the added tiled image, or rejects if
+     * adding it failed or the operation was aborted
+     */
+    addTiledImage(tiledImageOptions: Omit<default_2.TileSourceSpecifier, "success" | "error">, options?: {
+        signal?: AbortSignal;
+        getIndex?: () => number | undefined;
+    }): Promise<default_2.TiledImage>;
+    /**
+     * Removes a tiled image from the OpenSeadragon viewer
+     *
+     * The removal is queued behind the world mutations requested before it, so
+     * that it cannot shift the world while an addition is waiting for
+     * OpenSeadragon to apply its index. Does nothing once the context has been
+     * destroyed, as the viewer tears down its world itself.
+     *
+     * @param tiledImage - The tiled image to remove
+     * @returns A promise that resolves once the tiled image has been removed.
+     */
+    removeTiledImage(tiledImage: default_2.TiledImage): Promise<void>;
+    /**
+     * Returns the index of a tiled image in the OpenSeadragon viewer's world
+     *
+     * @param tiledImage - The tiled image for which to get the index
+     * @returns The index of the tiled image, or -1 if it is not in the world
+     */
+    getTiledImageIndex(tiledImage: default_2.TiledImage): number;
+    /**
+     * Updates the data transfer of a tiled image
+     *
+     * The data transfer is applied per tile: the tile's pixel values are
+     * extracted and each is replaced by the color it maps to (see
+     * {@link DataTransfer}). Passing `undefined` leaves the tiles as they are. It
+     * is applied to every tile of the tiled image, including those loaded later.
+     *
+     * The data transfer is remembered per tile source, until the tile source is
+     * garbage-collected. Tiled images that share a tile source therefore also
+     * share a data transfer, with the last one set winning - including the tiled
+     * images of the navigator, which mirror those of this viewer and are
+     * recolored along with them. As the navigator keeps a tile cache of its own,
+     * which the invalidation of `tiledImage` does not reach, its tiled images
+     * that share the tile source are invalidated explicitly, too. Those are few
+     * low-resolution tiles, so this stays cheap; invalidating the whole viewer
+     * would re-run every data transfer on every loaded tile instead.
+     *
+     * A tiled image keeps up to the whole tile cache loaded, most of it outside
+     * the viewport, so only the tiles drawn in the viewport are invalidated. The
+     * others are recolored once they are drawn again (see
+     * {@link _recolorStaleTiles}), which keeps the cost of a change proportional
+     * to the viewport rather than to the tile cache. Removing a data transfer
+     * invalidates every tile of the tiled image instead, as tiles without a data
+     * transfer are not caught up with.
+     *
+     * Data transfers are compared by identity: the tiles are only invalidated,
+     * and thereby recolored from their original data, if a different data
+     * transfer object is passed. Callers are expected to pass the same object for
+     * as long as its outcome would not change, as invalidating the tiles re-runs
+     * the data transfer on every tile in the viewport, and on every other loaded
+     * tile of the tile source once it is drawn.
+     *
+     * @param tiledImage - The tiled image to update
+     * @param dataTransfer - The data transfer to apply, or `undefined` for none
+     */
+    updateTiledImageDataTransfer(tiledImage: default_2.TiledImage, dataTransfer: DataTransfer_2 | undefined): void;
+    /**
+     * Sets the bounds of the content that a source contributes to the world
+     *
+     * The world background (see the class documentation) is resized to the
+     * bounding box of the bounds of all sources, or to
+     * {@link _emptyWorldBounds} if there are none (see
+     * {@link _resizeBackground}). Renderers register the bounds of their tiled
+     * images under themselves; the bounds of content rendered outside
+     * OpenSeadragon are registered under any other stable object. Passing no
+     * bounds removes the source.
+     *
+     * @param source - The object under which to register the bounds
+     * @param bounds - The bounds contributed by the source, in world coordinates
+     * @param options - Optional abort signal
+     * @returns A promise that resolves once the background covers the bounds,
+     * i.e. once it has been drawn wherever they are in the viewport
+     */
+    setContentBounds(source: object, bounds: Rect[], options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Hands viewport control back to the renderers
+     *
+     * Fits the viewport to the bounds of the world, and resumes doing so whenever
+     * they change, until the user pans or zooms again. Call this when the content
+     * of the viewer is replaced, e.g. on opening a project.
+     */
+    resetViewport(): void;
+    /**
+     * Destroys the OpenSeadragon viewer and cleans up resources
+     *
+     * The context is marked as destroyed immediately (see {@link isDestroyed}), but
+     * the viewer is only destroyed once no world mutation is pending anymore, as
+     * their callbacks would otherwise run against a destroyed viewer. Marking the
+     * context as destroyed also stops further world mutations from being enqueued,
+     * so awaiting the queue's current tail is enough to drain it.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Opens a tile source, see {@link openTileSource}
+     *
+     * @param tiledImageOptions - Options containing the tile source to open
+     * @param options - Optional abort signal, which skips the open if the
+     * operation is aborted before it starts
+     * @returns A promise that resolves with the opened tile source
+     */
+    private _openTileSource;
+    /**
+     * Resizes the world background to the registered bounds, creating it at world index 0 if it does not exist yet
+     *
+     * The background is kept if it already has the bounds (see
+     * {@link OpenSeadragonUtils.hasBounds}). Otherwise, a new background is
+     * inserted right below it, and the old one is removed only once the new one
+     * has been drawn (see {@link _waitUntilDrawn}). Unlike a renderer's anchor
+     * (see `OpenSeadragonRendererBase._resizeAnchor`), the background is not
+     * replaced as part of the addition: OpenSeadragon removes the replaced tiled
+     * image right away, whereas the new one is drawn only once its tile has
+     * loaded, which would leave the canvas uncovered for a frame or more. While
+     * both backgrounds exist, they sit below all anchors, so the world indices
+     * that the renderers resolve relative to their anchors are unaffected.
+     *
+     * Resizes are run one at a time, in call order, each to the bounds
+     * registered by the time it runs, so intermediate ones are skipped. A
+     * failing resize does not prevent subsequent ones from running. Aborting
+     * skips the resize if the new background has not been added yet, and has no
+     * effect afterwards, as that would leave two backgrounds in the world. Does
+     * nothing once the context has been destroyed.
+     *
+     * @param options - Optional abort signal
+     * @returns A promise that resolves once the background has been resized
+     */
+    private _resizeBackground;
+    /**
+     * Implementation of {@link addTiledImage}, bypassing the world mutation queue
+     *
+     * Must only be called from within an enqueued world mutation, such that the
+     * index resolved by `options.getIndex` is still valid when OpenSeadragon
+     * applies it.
+     */
+    private _addTiledImage;
+    /**
+     * Waits until a tiled image has been drawn wherever it is in the viewport
+     *
+     * That is, until all tiles it needs for the current view have loaded, or
+     * until it is not in the viewport at all: OpenSeadragon keeps the loading
+     * state of a tiled image outside the viewport as it is, so the tiled image
+     * would otherwise be waited for until it is panned into view. OpenSeadragon
+     * sets the former while updating a frame, right before drawing it; the
+     * latter can only change along with the viewport, as the tiled image is not
+     * moved while waited for. Both are therefore checked right away, and again
+     * whenever either changes. Also resolves once its tile has failed to load
+     * for good, as it is never fully loaded then, and once the context has been
+     * destroyed, at the latest when it destroys the viewer (see {@link destroy}).
+     *
+     * @param tiledImage - The tiled image to wait for
+     * @returns A promise that resolves once the tiled image has been drawn
+     */
+    private _waitUntilDrawn;
+    /**
+     * Appends a world mutation to the world mutation queue
+     *
+     * Tasks are run one at a time, in call order, and a failing task does not
+     * prevent subsequent tasks from running. Every operation that adds to or
+     * removes from the world has to be enqueued here, so that the world cannot
+     * shift between an addition resolving its index and OpenSeadragon applying it.
+     *
+     * @param task - Task to run once all previously enqueued tasks have settled
+     * @returns A promise that resolves with the task's result
+     */
+    private _enqueueWorldMutation;
+    /**
+     * Recolors the drawn tiles whose data transfer is outdated
+     *
+     * A change of a data transfer only invalidates the tiles in the viewport
+     * (see {@link updateTiledImageDataTransfer}), which leaves the other loaded
+     * tiles of the tile source in the colors of an earlier data transfer. Every
+     * tile records the data transfer it was last recolored with (see
+     * {@link _applyDataTransfer}); a drawn tile that recorded a different one than
+     * its tile source's is invalidated, unless it is being recolored already.
+     * Such a tile is drawn in its earlier colors until it is recolored, which
+     * takes a frame or two.
+     *
+     * Tiles loaded after a change are recolored on load, and tile sources
+     * without a data transfer are skipped: their tiles were all restored when
+     * the data transfer was removed.
+     */
+    private _recolorStaleTiles;
+    /**
+     * Replaces the data of an invalidated tile with the colors of its values
+     *
+     * Does nothing unless a data transfer is set for the tile source of the tile
+     * (see {@link updateTiledImageDataTransfer}).
+     *
+     * OpenSeadragon raises the invalidation events of all tiles of a change at
+     * once, and recoloring a tile holds the thread for as long as the tile has
+     * pixels, so each tile first yields to the event loop: the user interface
+     * stays responsive while a change is recolored. A change that arrives
+     * meanwhile invalidates the same tiles again, which marks the runs of the
+     * change before it as outdated; those are abandoned, as the newer runs
+     * recolor the tiles. The data transfer is read only after yielding, so that
+     * a run that continues always applies the latest one. It is recorded as the
+     * tile's before the tile is recolored (see {@link _recolorStaleTiles}), so
+     * that a tile whose recoloring fails is not retried on every draw.
+     *
+     * The colors are written as packed 32-bit values through a `Uint32Array`
+     * view of an `ImageData` buffer, whose bytes are R, G, B, A. The
+     * `0xAABBGGRR` layout of {@link DataTransfer} lands in that order on a
+     * little-endian host; on a big-endian host, the bytes of every pixel are
+     * swapped afterwards. The buffer is shared by all tiles of the viewer and
+     * only ever grows, as this is a hot path: changing a data transfer
+     * reconverts every cached tile. Sharing is safe because nothing awaits
+     * between filling and copying the buffer, and `putImageData` copies the
+     * pixels.
+     *
+     * The pixels are copied onto a new canvas of the raster's size, which
+     * becomes the tile's data. The canvas cannot be shared, as OpenSeadragon
+     * keeps it in its tile cache by reference. Nor is the tile's own canvas
+     * used: obtaining that would convert the tile's original data to a canvas
+     * first, only for it to be overwritten. The canvas is created with
+     * `willReadFrequently`, which keeps it in memory rather than on the GPU: the
+     * WebGL drawer reads a pixel of every canvas it turns into a texture, to
+     * check whether it is tainted, and reading from a GPU canvas waits for the
+     * GPU.
+     *
+     * @param event - The tile invalidation event whose tile data is replaced
+     * @returns A promise that resolves once the tile data has been replaced
+     * @throws Error if the number of pixel values does not match the raster size
+     */
+    private _applyDataTransfer;
+}
+
+/**
+ * Renderer for the tiled images of {@link Image} data objects
+ *
+ * Multi-channel image data provides one tiled image per channel, whose tiles
+ * carry the channel's values rather than colors. Each channel is recolored by a
+ * data transfer (see {@link OpenSeadragonContext.updateTiledImageDataTransfer})
+ * that scales the values between the channel's contrast limits and multiplies
+ * them with the channel's color. Color and contrast limits are resolved by
+ * {@link ImageUtils.getChannelColor} and
+ * {@link ImageUtils.getChannelContrastLimits}; channels without contrast
+ * limits are stretched over the value range of each tile's data type. In the
+ * grayscale view mode, every channel is colorized white instead of its color.
+ * Channels whose data does not provide values are drawn as they are, as is
+ * image data that is not multi-channel. Channel visibility and opacity are not
+ * part of the transfer: like layer and image opacity, OpenSeadragon applies
+ * them when drawing the tiled image, which is also where the single-channel
+ * view modes hide all but the image's active channel (see
+ * {@link getTiledImageOpacity}).
+ *
+ * Channel colors, contrast limits and the view mode need no synchronization:
+ * like visibility and opacity, they are read from the current model whenever
+ * the image's tiled images are updated (see
+ * {@link resolveTiledImageDataTransfer}), so changing them only requires
+ * {@link setModel}. As data transfers are compared by identity, each channel's
+ * data transfer is kept until the image's data, or the channel's resolved color
+ * (white in grayscale) or contrast limits change, so that tiles are only
+ * recolored when needed.
+ */
+export declare class OpenSeadragonImageRenderer extends OpenSeadragonRendererBase<Image_2, ImageData_2, OpenSeadragonImageSyncContext> {
+    private readonly _renderedMultichannelImages;
+    /**
+     * Returns the state of an image that a synchronization depends on
+     *
+     * Blanks out the channel view mode and active channel, and the name,
+     * visibility, opacity, color and contrast limits of every channel on top of
+     * what the base class blanks out: they are applied from the current model
+     * when updating the channel's tiled image (see {@link getTiledImageOpacity}
+     * and {@link resolveTiledImageDataTransfer}), except for the name, which is
+     * cosmetic.
+     *
+     * @param image - The image to return the state of
+     * @returns The image without the properties that are applied by
+     * {@link setModel}, and without the cosmetic ones
+     */
+    protected getObjectSyncState(image: Image_2): object;
+    /**
+     * Drops the data transfers of all images other than the given ones
+     *
+     * @param images - The images about to be displayed
+     */
+    protected retainObjects(images: Image_2[]): void;
+    /**
+     * Returns the tile sources for the given image data
+     *
+     * Multi-channel image data provides one tile source per channel, in channel
+     * order; all other image data provides a single tile source.
+     *
+     * @param data - The image data for which to retrieve the tile sources
+     * @returns The tile sources, one per channel for multi-channel image data and
+     * a single one otherwise
+     */
+    protected getTileSources(data: ImageData_2): (string | TileSourceConfig | CustomTileSource)[];
+    /**
+     * Returns whether the channels of the given image data are blended additively
+     *
+     * Multi-channel image data blends additively, so that its channels add up
+     * rather than hide one another. Image data that is not multi-channel has a
+     * single tile source, so there is nothing to add up, and it keeps
+     * OpenSeadragon's default compositing, which preserves the transparency of its
+     * tiles.
+     *
+     * @param data - The image data to check
+     * @returns Whether the image's channels are blended additively
+     */
+    protected usesAdditiveBlending(data: ImageData_2): boolean;
+    /**
+     * Computes the effective opacity for one of an image's tiled images
+     *
+     * Multiplies the layer and image opacity computed by the base class with the
+     * visibility and opacity of the channel that the tiled image renders. Channels
+     * are only applied to multi-channel image data, and channels that the image
+     * does not define are visible at full opacity. In the single-channel view
+     * modes, only the image's active channel is visible (see
+     * {@link ImageUtils.getActiveChannel}). Without a channel index, i.e. for the
+     * image's backdrop, the layer and image opacity is returned as is.
+     *
+     * @param ref - The image reference for which to compute the opacity
+     * @param index - The index of the tiled image (channel), or `null` for the image's backdrop
+     * @returns The effective opacity for the tiled image
+     */
+    protected getTiledImageOpacity(ref: ObjectRef<Image_2, ImageData_2>, index: number | null): number;
+    /**
+     * Resolves the data transfer for one of an image's tiled images, unless it is up to date
+     *
+     * Only the tiled images of the channels of multi-channel image data are
+     * recolored, never the backdrop. A channel's color and contrast limits are
+     * resolved (see {@link ImageUtils.getChannelColor} and
+     * {@link ImageUtils.getChannelContrastLimits}), with every channel white in
+     * the grayscale view mode. The channel's data transfer is kept as long as the
+     * image's data and the resolved values are unchanged, and is created anew
+     * otherwise (see {@link _createDataTransfer}). Channels are resolved
+     * independently, so that changing one channel only recolors the tiles of that
+     * channel.
+     *
+     * @param ref - The image reference for which to get the data transfer, holding
+     * the image as it currently is in the model
+     * @param index - The index of the tiled image (channel), or `null` for the image's backdrop
+     * @returns The channel's data transfer, or `undefined` if the channel has none
+     */
+    protected resolveTiledImageDataTransfer(ref: ObjectRef<Image_2, ImageData_2>, index: number | null): DataTransfer_2 | undefined;
+    /**
+     * Creates the data transfer of an image channel
+     *
+     * The transfer scales each value linearly between the contrast limits,
+     * clamped to `[0, 1]`, and multiplies the result with the channel's color,
+     * which {@link resolveTiledImageDataTransfer} has already resolved. Without
+     * contrast limits, the value range of the data type of each tile's data is
+     * used (see {@link ImageUtils.getDataTypeRange}); contrast limits that are not
+     * ascending render every value black. The resulting pixels are opaque;
+     * channel visibility and opacity are applied by OpenSeadragon when drawing
+     * the tiled image.
+     *
+     * The scaled color is not computed per pixel: the transfer packs a ramp of
+     * 256 colors once, with `ColorUtils.packColor` and `ColorUtils.withAlpha`,
+     * and maps each value to the nearest ramp entry. As no color component
+     * exceeds 255, the ramp holds every color the channel can take.
+     *
+     * @param data - The image data providing the channel's values
+     * @param channel - The resolved color and contrast limits of the channel
+     * @returns The data transfer, or `undefined` if the data provides no channel
+     * values
+     */
+    private static _createDataTransfer;
+}
+
+declare type OpenSeadragonImageSyncContext = {
+    loadObject: (image: Image_2, options?: {
+        signal?: AbortSignal;
+    }) => Promise<ImageData_2>;
+};
+
+/**
+ * Renderer for the tiled images of {@link Labels} data objects
+ *
+ * The tiles of a labels object carry label IDs rather than colors, and are
+ * recolored by a data transfer (see
+ * {@link OpenSeadragonContext.updateTiledImageDataTransfer}) that looks each
+ * ID up in a color lookup table, which folds the visibility and opacity into
+ * the alpha channel. Layer and object opacity are not part of it; OpenSeadragon
+ * applies them when drawing the tiled image.
+ *
+ * A label image does not enumerate its labels (see {@link LabelsData}), so the
+ * lookup table is resolved per object for the labels that the referenced table
+ * lists, in the same way as the WebGL renderers resolve the appearance of their
+ * items, and every other label is resolved as it is first drawn (see
+ * {@link _resolveDataTransfer}).
+ *
+ * As data transfers are compared by identity, each object's data transfer is
+ * kept (see {@link resolveObject}) until its data, one of the configurations
+ * it was resolved from, or one of the group-to-value maps those configurations
+ * reference changes, so that tiles are only recolored when needed. Maps are
+ * never mutated - an edit replaces the map object - so they are compared by
+ * identity, which is why the maps passed to a synchronization have to keep
+ * their identity for as long as they are unchanged.
+ */
+export declare class OpenSeadragonLabelsRenderer extends OpenSeadragonRendererBase<Labels, LabelsData, OpenSeadragonLabelsSyncContext> {
+    private readonly _renderedLabels;
+    /**
+     * Drops the data transfers of all labels objects other than the given ones
+     *
+     * @param labels - The labels objects about to be displayed
+     */
+    protected retainObjects(labels: Labels[]): void;
+    /**
+     * Resolves the data transfer of a labels object, unless it is up to date
+     *
+     * An object's data transfer is kept as long as its data, its label color,
+     * visibility and opacity configurations, and the group-to-value maps those
+     * configurations resolve from (see {@link ConfigUtils.findGroupByMap}) are
+     * unchanged, and is resolved anew otherwise (see
+     * {@link _resolveDataTransfer}). Configurations are compared by value, maps
+     * by identity. If resolving from the referenced table fails, e.g. because the
+     * table failed to load, the failure is logged and the object's labels are
+     * resolved without table data instead, until its data, one of its
+     * configurations or one of its maps changes.
+     *
+     * @param labels - The labels object to resolve
+     * @param data - The loaded data of the labels object
+     * @param context - The inputs of the current synchronization
+     * @param options - Optional abort signal
+     * @returns A promise that resolves once the data transfer has been resolved
+     */
+    protected resolveObject(labels: Labels, data: LabelsData, context: OpenSeadragonLabelsSyncContext, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Returns the data transfer resolved for the given labels object
+     *
+     * A labels object has a single tiled image, whose tiles carry the label IDs,
+     * and no backdrop, so the index is not looked at.
+     *
+     * @param ref - The labels reference for which to get the data transfer
+     * @returns The data transfer resolved by {@link resolveObject}, or
+     * `undefined` if the object has not been resolved
+     */
+    protected resolveTiledImageDataTransfer(ref: ObjectRef<Labels, LabelsData>): DataTransfer_2 | undefined;
+    /**
+     * Resolves the data transfer of a labels object
+     *
+     * If a label color, visibility or opacity configuration reads from the
+     * referenced table, the table is loaded and the appearance of every label it
+     * lists is resolved up front, in the same way as the WebGL renderers resolve
+     * the appearance of their items, into a lookup table from label ID to packed
+     * pixel. Every other label - those the table does not list, and all labels
+     * if no configuration needs the table - is resolved as it is first drawn
+     * (see {@link _createDataTransfer}).
+     *
+     * If the table cannot be loaded or a configuration cannot be resolved from
+     * it, the failure is logged and the lookup table is left empty, so that all
+     * labels are resolved without table data.
+     *
+     * @param labels - The labels object to resolve
+     * @param data - The loaded data of the labels object
+     * @param context - The inputs of the current synchronization
+     * @param options - Optional abort signal
+     * @returns The resolved data transfer
+     */
+    private static _resolveDataTransfer;
+    /**
+     * Creates the data transfer of a labels object from a lookup table
+     *
+     * Label value `0` is background and maps to a fully transparent pixel. Labels
+     * that the lookup table does not list are resolved without table data as
+     * they are first drawn (see e.g. {@link ColorResolver.resolveColorWithoutTable}):
+     * constant values and random colors resolve exactly, whereas configurations
+     * that need the table fall back to the default label color, visibility and
+     * opacity. The result is memoized in the lookup table, so that each label is
+     * resolved once.
+     *
+     * @param labels - The labels object whose configurations unlisted labels are resolved from
+     * @param data - The loaded data of the labels object
+     * @param labelPixelValues - The lookup table from label ID to packed pixel,
+     * extended as labels are drawn
+     * @returns The data transfer
+     */
+    private static _createDataTransfer;
+}
+
+declare type OpenSeadragonLabelsSyncContext = {
+    tables: Table[];
+    colorMaps: GroupValueMap<Color>[];
+    visibilityMaps: GroupValueMap<boolean>[];
+    opacityMaps: GroupValueMap<number>[];
+    loadObject: (labels: Labels, options?: {
+        signal?: AbortSignal;
+    }) => Promise<LabelsData>;
+    loadTable: (table: Table, options?: {
+        signal?: AbortSignal;
+    }) => Promise<TableData>;
+};
+
+/**
+ * Base class for OpenSeadragon renderers that manage tiled images for objects (images or labels)
+ *
+ * Renderers share a viewer, so each renderer owns an anchor: an invisible
+ * single-tile image that marks where the renderer's own tiled images belong.
+ * They directly follow the anchor, in the order of {@link _renderedObjects},
+ * with one tiled image per channel of each object.
+ *
+ * Every tiled image contributes to the bounds of the world, the anchor
+ * included, so the anchor spans just the renderer's own tiled images, which
+ * keeps it from extending the world (see {@link updateBounds}). The same bounds
+ * are registered with the context (see
+ * {@link OpenSeadragonContext.setContentBounds}), whose world background fits
+ * the world to the content of all renderers, and covers it from below.
+ *
+ * The tiled images of an object that uses additive blending are preceded by one
+ * more tiled image, its backdrop (see {@link usesAdditiveBlending}).
+ *
+ * Tiled images are inserted behind the anchor when they are added, rather than
+ * moved there afterwards, as OpenSeadragon's navigator cannot keep up with
+ * reordering. {@link _cleanRenderedObjects} recreates those that are out of place.
+ *
+ * The layers and objects to render are set by {@link setModel}, which applies
+ * the properties that tiled images take directly - transforms, visibility and
+ * opacity - to the rendered objects right away. Everything else - the set and
+ * order of the layers and objects, data sources and whatever the subclasses
+ * resolve from an object (see {@link resolveObject}) - requires a
+ * synchronization, which {@link needsSynchronization} reports and
+ * {@link synchronize} performs. The properties applied directly are always read
+ * from the current model, never from the reference of a rendered object (see
+ * {@link _updateRenderedObject}), so a synchronization that is in flight while
+ * the model changes does not write stale values.
+ */
+declare abstract class OpenSeadragonRendererBase<TObject extends Image_2 | Labels, TObjectData extends ImageData_2 | LabelsData, TSyncContext extends {
+    loadObject: (object: TObject, options?: {
+        signal?: AbortSignal;
+    }) => Promise<TObjectData>;
+}> {
+    private static readonly _emptyAnchorBounds;
+    readonly context: OpenSeadragonContext;
+    private _anchor;
+    private _model?;
+    private _lastSyncState?;
+    private _renderedObjects;
+    private _anchorTaskPromise;
+    private _destroyed;
+    /**
+     * Creates a new OpenSeadragonRendererBase instance and asynchronously adds its anchor
+     *
+     * The renderer must not be used before `onInitialized` has been called;
+     * `onError` is called instead if adding the anchor failed or was aborted.
+     *
+     * @param context - The OpenSeadragon context that provides access to the viewer and other shared state
+     * @param onInitialized - Called once the anchor has been added to the world
+     * @param onError - Called if the anchor could not be added
+     * @param options - Optional abort signal and world index at which to insert
+     * the anchor, behind the context's world background (i.e. `1` or higher)
+     */
+    constructor(context: OpenSeadragonContext, onInitialized: () => void, onError: (error: Error) => void, options?: {
+        signal?: AbortSignal;
+        anchorIndex?: number;
+    });
+    /**
+     * Sets the layers and objects to render
+     *
+     * The properties that tiled images take directly - the layer and object
+     * transforms, visibility and opacity, and whatever else a subclass reads from
+     * the current model when updating a tiled image (see
+     * {@link getTiledImageOpacity} and {@link resolveTiledImageDataTransfer}) -
+     * are applied to the rendered objects right away (see
+     * {@link _updateRenderedObject}), and need no synchronization.
+     * Every other change - a different set or order of layers or objects, layer
+     * memberships, data sources or the configurations that subclasses resolve
+     * from - requires a resynchronization, which the caller is expected to
+     * trigger whenever {@link needsSynchronization} says so.
+     *
+     * Does not resize the anchor: a transform change moves the tiled images, so
+     * the caller is expected to call {@link updateBounds} afterwards.
+     *
+     * The layers and objects are cloned, so that what the renderer compares
+     * against later - in {@link needsSynchronization}, and in the references of
+     * a synchronization - is what it was given, whatever the caller does with its
+     * instances afterwards.
+     *
+     * @param layers - The layers to render
+     * @param objects - The objects (images or labels) to render
+     */
+    setModel(layers: Layer[], objects: TObject[]): void;
+    /**
+     * Returns whether the rendered objects have to be synchronized with the
+     * current model
+     *
+     * Compares the state that a synchronization depends on (see
+     * {@link getSyncState}) against the one the last synchronization was based
+     * on, which {@link synchronize} records before its first `await` and forgets
+     * again if it fails. Everything else about the model - the properties that
+     * tiled images take directly - is fully applied by {@link setModel}.
+     */
+    needsSynchronization(): boolean;
+    /**
+     * Synchronizes the viewer's tiled images with the current model
+     *
+     * Loads all objects assigned to the layers of the model set by
+     * {@link setModel}, removes the tiled images that are no longer needed, and
+     * creates or updates the remaining ones. Resolves once the tiled images have
+     * actually been added to the world, i.e. once the viewer reflects the model
+     * state that was read. The model may be set again while the synchronization
+     * runs; it reads the model once, so it sees one consistent state, while the
+     * properties it applies to the tiled images come from the current model (see
+     * {@link _updateRenderedObject}).
+     *
+     * Objects whose tiled images cannot be created, e.g. because their data
+     * provides no tile sources, are logged and skipped, just like objects whose
+     * data failed to load (see {@link _loadObjects}). A synchronization that
+     * fails or is aborted leaves the model unsynchronized (see
+     * {@link needsSynchronization}).
+     *
+     * @param context - The inputs to synchronize with: an immutable snapshot of
+     * the tables and maps that the objects resolve from and the loaders that the
+     * renderer needs. It carries inputs only; a renderer that derives state from
+     * an object does so in {@link resolveObject}.
+     * @param options - Optional abort signal
+     * @throws Error if no model has been set (see {@link setModel})
+     */
+    synchronize(context: TSyncContext, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Resizes the anchor to the bounding box of all tiled images, and registers it with the context
+     *
+     * Rendered objects whose tiled images have not been added to the world yet are
+     * ignored; they update the anchor themselves upon arrival (see
+     * {@link _createRenderedObject}). Resolves once the context's world
+     * background covers the bounds, too (see
+     * {@link OpenSeadragonContext.setContentBounds}). The bounds are registered
+     * after the anchor task rather than within it, so that the anchor task
+     * queue, and with it {@link destroy}, never waits for the background, which
+     * waits for being drawn. Does nothing once the renderer has been destroyed,
+     * as there is no anchor to resize anymore.
+     *
+     * @param options - Optional abort signal
+     */
+    updateBounds(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Destroys the renderer by removing the anchor tiled image and all rendered objects from the OpenSeadragon viewer, and its bounds from the context
+     *
+     * Rendered objects whose tiled images have not been added to the world yet are
+     * only marked for deletion, and are removed as soon as they arrive.
+     *
+     * The renderer is unusable afterwards: it has no anchor anymore, so
+     * {@link updateBounds} does nothing, {@link _cleanRenderedObjects} throws, and
+     * tiled images that still arrive are removed right away.
+     *
+     * The bounds are removed from the context without waiting for the world
+     * background to be resized, and a failure to resize it is only logged: the
+     * background waits for being drawn, which never happens while the page is
+     * hidden, and the teardown of the renderer, and thereby of the context, must
+     * not depend on it.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Returns the state of the current model that a synchronization depends on
+     *
+     * Unlike the WebGL renderers, whose draw order is read from the model on
+     * every draw, the order of the layers and objects is part of the state: it
+     * is the order of the tiled images in the world, which only a
+     * synchronization can change (see {@link _cleanRenderedObjects}). See
+     * {@link getLayerSyncState} and {@link getObjectSyncState} for what else is.
+     *
+     * @returns The state, or `undefined` if no model has been set
+     */
+    protected getSyncState(): object | undefined;
+    /**
+     * Returns the state of a layer that a synchronization depends on
+     *
+     * The counterpart of {@link getObjectSyncState} for layers. The point size
+     * factor is blanked out as well, as nothing rendered here depends on it, and
+     * so is the name.
+     *
+     * @param layer - The layer to return the state of
+     * @returns The layer without the properties that are applied by
+     * {@link setModel}, and without the cosmetic ones
+     */
+    protected getLayerSyncState(layer: Layer): object;
+    /**
+     * Returns the state of an object that a synchronization depends on
+     *
+     * Everything but the properties that are applied by {@link setModel}, and
+     * but the cosmetic ones, which nothing rendered depends on. Those are blanked
+     * out rather than dropped, so that a property added to the model later is
+     * part of the state, and thereby requires a resynchronization, unless it is
+     * blanked out here as well. Subclasses override this to blank out the
+     * properties that they apply from the current model themselves.
+     *
+     * The result is only ever deep-compared against that of another object, hence
+     * the opaque return type.
+     *
+     * @param object - The object (image or labels) to return the state of
+     * @returns The object without the properties that are applied by
+     * {@link setModel}, and without the cosmetic ones
+     */
+    protected getObjectSyncState(object: TObject): object;
+    /**
+     * Retains what was resolved for the given objects, and discards the rest
+     *
+     * Called by {@link synchronize} once all objects have loaded and the rendered
+     * objects of all others have been deleted, with the objects that are about
+     * to be displayed: those assigned to a rendered layer whose data loaded
+     * successfully. Does nothing here; subclasses that keep
+     * state per object (see {@link resolveObject} and
+     * {@link resolveTiledImageDataTransfer}) override this to drop the state of
+     * every object that is not among the given ones.
+     *
+     * @param _objects - The objects (images or labels) about to be displayed
+     */
+    protected retainObjects(_objects: TObject[]): void;
+    /**
+     * Resolves what a renderer derives from an object, once its data has loaded
+     *
+     * Called by {@link _loadObjects} for every object on one of the given layers,
+     * concurrently, right after
+     * its data has loaded and before its tiled images are created or updated. An
+     * object that cannot be resolved is logged, but kept: its tiled images are
+     * still created or updated, with whatever the synchronous hooks return for
+     * it. Does nothing here; subclasses override this to resolve, from the
+     * object, its data and the inputs of the synchronization, whatever their
+     * synchronous hooks return later (see {@link resolveTiledImageDataTransfer}),
+     * and to keep it for as long as its outcome would not change.
+     *
+     * @param _object - The object (image or labels) to resolve
+     * @param _data - The loaded data of the object
+     * @param _context - The inputs of the current synchronization
+     * @param _options - Optional abort signal
+     * @returns A promise that resolves once the object has been resolved
+     */
+    protected resolveObject(_object: TObject, _data: TObjectData, _context: TSyncContext, _options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Returns the tile sources for the given object data
+     *
+     * @param data - The object data (image or labels) for which to retrieve the tile sources
+     * @returns The tile sources, one per tiled image of the object. Defaults to
+     * the single tile source of the data; renderers of multi-channel data
+     * override this.
+     */
+    protected getTileSources(data: TObjectData): (string | TileSourceConfig | CustomTileSource)[];
+    /**
+     * Returns whether the channels of the given object data are blended additively
+     *
+     * The channels of an object that blends additively are composited with
+     * OpenSeadragon's "lighter" operation onto an opaque black backdrop below
+     * them, so that they add up among themselves while the backdrop hides
+     * whatever is below the object, thereby compositing the object as a whole over
+     * it. Objects that do not blend additively have no backdrop and keep
+     * OpenSeadragon's default composite operation, i.e. each of their channels is
+     * composited over the one below it.
+     *
+     * This only composites correctly onto an opaque canvas: "lighter" adds alpha
+     * as well as color, so onto the transparent canvas that OpenSeadragon clears
+     * to, an object with opacity below one would accumulate alpha from each
+     * channel and fade out to the wrong color, in wrong proportions, instead of
+     * fading out to the background behind the viewer. The context's world
+     * background (see {@link OpenSeadragonContext.setContentBounds}) therefore makes the
+     * canvas opaque wherever objects are.
+     *
+     * @param _data - The object data (image or labels) to check
+     * @returns Whether the object's channels are blended additively. Defaults to `false`.
+     */
+    protected usesAdditiveBlending(_data: TObjectData): boolean;
+    /**
+     * Computes the effective opacity for one of an object's tiled images
+     *
+     * Returns `0` when either the layer or the object is invisible; otherwise
+     * multiplies layer and object opacities. The channel index is ignored here,
+     * i.e. all tiled images of an object share the same opacity; subclasses
+     * override this to additionally apply per-channel visibility and opacity. The
+     * channel index is omitted for an object's backdrop, which carries the opacity
+     * of the object itself.
+     *
+     * @param ref - The object reference for which to compute the opacity
+     * @param _index - The index of the tiled image (e.g. channel), or `null` for the object's backdrop
+     * @returns The effective opacity for the tiled image
+     */
+    protected getTiledImageOpacity(ref: ObjectRef<TObject, TObjectData>, _index: number | null): number;
+    /**
+     * Resolves the data transfer for one of an object's tiled images
+     *
+     * Returns `undefined` here, i.e. the tiles are drawn as they are; subclasses
+     * whose tiles carry values rather than colors override this to map the values
+     * to colors (see {@link OpenSeadragonContext.updateTiledImageDataTransfer}).
+     * As data transfers are compared by identity, the returned object has to stay
+     * the same for as long as its outcome would not change. This hook is
+     * synchronous and receives the object as it currently is in the model:
+     * subclasses either resolve the data transfer here, from the current object
+     * and its data, which needs no synchronization, or, if resolving is
+     * asynchronous, once the object's data has loaded (see
+     * {@link resolveObject}), and only return it here.
+     *
+     * @param _ref - The object reference for which to get the data transfer
+     * @param _index - The index of the tiled image (e.g. channel), or `null` for the object's backdrop
+     * @returns The data transfer to apply, or `undefined` for none. Defaults to
+     * `undefined`.
+     */
+    protected resolveTiledImageDataTransfer(_ref: ObjectRef<TObject, TObjectData>, _index: number | null): DataTransfer_2 | undefined;
+    /**
+     * Concurrently loads and resolves all objects assigned to the layers of the current model
+     *
+     * Each object's data is loaded with the context's `loadObject`, and the object
+     * is then resolved (see {@link resolveObject}). The returned references are
+     * ordered by layer and then by object, which determines the order of the
+     * corresponding tiled images in the world. Objects whose data failed to load
+     * are logged and skipped; objects that could not be resolved are logged, but
+     * kept. The model is read once, before the first `await`, so one
+     * synchronization sees one consistent model state, however often the model
+     * is set while it runs.
+     *
+     * @param context - The inputs of the current synchronization
+     * @param options - Optional abort signal
+     * @returns A promise that resolves to one object reference per successfully loaded object
+     * @throws Error if no model has been set (see {@link setModel})
+     */
+    private _loadObjects;
+    /**
+     * Retains the rendered objects that can be reused for the new object references, and deletes the rest
+     *
+     * A rendered object is matched by the layer and object it references.
+     * Unmatched rendered objects are deleted first, so that removing an object
+     * does not shift the world indices of the objects behind it. A matched
+     * rendered object is reusable if the data source it was loaded for is that of
+     * the reference, and if its backdrop, if any, and all of its tiled images
+     * already sit at the consecutive world indices expected for its position
+     * among the references, counted from the anchor. A partially misplaced object
+     * is not reusable. The other matched rendered objects are deleted as well,
+     * and are expected to be recreated by the caller via
+     * {@link _createRenderedObject}, which is also how the world is reordered.
+     *
+     * The expected indices account for every matched rendered object, reusable or
+     * not, by the world footprint it currently has: a matched object that is
+     * recreated, e.g. because its data source changed, is deleted and inserted at
+     * the same position, with possibly different tiled images, so the objects
+     * behind it keep their indices relative to it and stay reusable. Only the
+     * backdrop and tiled images assigned to it count, i.e. none for an object
+     * whose tiled images could not be added, which is thereby retried without
+     * recreating the objects behind it. The tiled images that an earlier
+     * synchronization is still adding are waited for first, so that each
+     * rendered object is either fully in the world or not at all. This does not
+     * delay the additions of this synchronization, which are queued behind them
+     * anyway (see {@link OpenSeadragonContext.addTiledImage}).
+     *
+     * @param newRefs - The new object references, in the intended world order
+     * @param options - Optional abort signal
+     * @returns A map of new object references to their reusable rendered objects
+     * @throws Error if the renderer has no anchor, i.e. it is not initialized or
+     * already destroyed
+     */
+    private _cleanRenderedObjects;
+    /**
+     * Creates a new rendered object for the given object reference and adds one TiledImage per channel, preceded by a backdrop where required, to the world
+     *
+     * The TiledImages are inserted at consecutive indices, starting `offset` places
+     * after the anchor, which establishes the world layout that
+     * {@link _cleanRenderedObjects} expects. `offset` therefore counts TiledImages,
+     * not objects, and callers have to advance it by
+     * {@link RenderedObject.tileSourceCount} plus the object's backdrop, if it has
+     * one. The indices are resolved once each addition is executed, as the anchor
+     * may have been replaced, and world indices may have shifted, while it was
+     * enqueued.
+     *
+     * The tile sources are opened here, rather than by the additions themselves,
+     * so that the backdrop can be sized like the object's content, which is only
+     * known once one of them has been opened. The additions are all requested
+     * before this function returns, and in world order, so that the TiledImages of
+     * the object that the caller creates next end up behind them.
+     *
+     * Returns before the TiledImages exist: they are added asynchronously and only
+     * then assigned to the rendered object, transformed, and included in the anchor
+     * bounds, which is when {@link RenderedObject.tiledImagesPromise} resolves. The
+     * backdrop and TiledImages are removed again immediately after they were added
+     * if the rendered object is deleted or the operation is aborted in the
+     * meantime, or if any of them could not be added at all - a partially added
+     * object would shift the world indices of every object after it. For the same
+     * reason, a tile source that fails to open is replaced by a transparent
+     * placeholder rather than skipped: the indices of the objects created after
+     * this one are resolved against the full footprint of this one, so it has to
+     * take up all of its indices until it is removed again. If the context
+     * is destroyed, nothing is done at all, as the viewer tears down its world
+     * itself.
+     *
+     * @param offset - The number of TiledImages between the anchor and the object's first new TiledImage
+     * @param newRef - The object reference for which to create a rendered object
+     * @param options - Optional abort signal
+     * @returns The newly created rendered object, which does not have TiledImages yet
+     * @throws Error if the object data provides no tile sources
+     */
+    private _createRenderedObject;
+    /**
+     * Stores a reference on the rendered object and applies the current model to its backdrop and TiledImages
+     *
+     * The reference holds the layer and object as they were when it was loaded,
+     * and is what the next synchronization matches against (see
+     * {@link _cleanRenderedObjects}). The transform, visibility and opacity
+     * applied to the TiledImages are not read from it, but from the current
+     * model, as they are the properties {@link setModel} applies without a
+     * synchronization: read from the reference, a call from {@link setModel}
+     * would re-apply the values of the last synchronization, and a call from a
+     * synchronization that was in flight while the model changed would overwrite
+     * what {@link setModel} applied.
+     *
+     * Nothing is applied if the layer or object has left the model, the object
+     * has moved to another layer, or its data source has changed: each of these
+     * requires a resynchronization, which drops or recreates the rendered object.
+     * The last one also protects the reference's data, which its provider may
+     * release once the data source it was loaded for is gone from the model.
+     *
+     * The opacity is computed per TiledImage via {@link getTiledImageOpacity}, so
+     * that subclasses can vary it by channel; all other properties are shared by
+     * all TiledImages of an object, and by its backdrop. The backdrop is opaque
+     * where the object is, so it gets {@link getTiledImageOpacity} without a
+     * channel index. A rendered object that is `pendingBackground` gets
+     * everything but its opacity, which stays at zero; its tiles are loaded
+     * nonetheless, unless it is invisible anyway, so that they are ready by the
+     * time it is revealed.
+     *
+     * @param renderedObject - The rendered object to update
+     * @param newRef - The reference to store, addressing the same layer, object
+     * and data source as the current one; defaults to the current one
+     * @throws Error if the TiledImages have not been created yet
+     */
+    private _updateRenderedObject;
+    /**
+     * Deletes the rendered object by removing its backdrop and TiledImages from the OpenSeadragon viewer, or marking it for deletion if the TiledImages have not yet been created
+     *
+     * The removals are queued by the context (see
+     * {@link OpenSeadragonContext.removeTiledImage}) and applied before any tiled
+     * image requested after them, so a caller that deletes before it creates still
+     * gets the world indices it expects.
+     *
+     * Deleting a rendered object does not remove it from {@link _renderedObjects}.
+     * An object that is `pendingBackground` is no longer, so that it is not
+     * revealed once the bounds update it waits for settles (see
+     * {@link _updateBoundsAndReveal}), which would update TiledImages that are
+     * no longer in the world.
+     *
+     * @param renderedObject - The rendered object to delete
+     * @returns A promise that resolves once its backdrop and all of its TiledImages have been removed
+     */
+    private _deleteRenderedObject;
+    /**
+     * Applies the transform, opacity and data transfer of an object reference to a single TiledImage
+     *
+     * Only properties whose value actually changed are written, as each write
+     * triggers a redraw. The data transfer is applied to the TiledImage's tiles
+     * (see {@link OpenSeadragonContext.updateTiledImageDataTransfer}).
+     *
+     * @param tiledImage - The TiledImage to update
+     * @param ref - The object reference whose transform to apply
+     * @param index - The index of the tiled image (e.g. channel), or `null` for the object's backdrop
+     * @param options - Whether to keep the TiledImage hidden, i.e. at opacity
+     * `0`, while preloading its tiles if it would be visible otherwise
+     */
+    private _updateTiledImage;
+    /**
+     * Updates the bounds (see {@link updateBounds}), and then reveals the given rendered objects that are `pendingBackground`
+     *
+     * The objects are revealed once the context's world background covers them,
+     * and also if that failed for any other reason than an abort: an object
+     * shown on an uncovered canvas, where its channels may be composited wrongly
+     * (see {@link usesAdditiveBlending}), beats one that is not shown at all. An
+     * aborted update leaves them hidden, for the synchronization that follows to
+     * reveal them (see {@link synchronize}).
+     *
+     * @param renderedObjects - The rendered objects to reveal
+     * @param options - Optional abort signal
+     * @returns A promise that resolves once the bounds have been updated
+     */
+    private _updateBoundsAndReveal;
+    /**
+     * Resizes the anchor (see the class documentation), or creates it
+     *
+     * If the anchor already has `newBounds` (see
+     * {@link OpenSeadragonUtils.hasBounds}), it is kept. Otherwise, a new anchor
+     * is created at `anchorIndex` (defaulting to the index of the current
+     * anchor, or appended if neither is specified) and the current anchor is
+     * removed. Where possible, OpenSeadragon replaces the current anchor as part
+     * of the addition, so that the new anchor takes its place without leaving a
+     * gap. Replacing the anchor cannot be aborted once the new anchor has been
+     * created, as that would leave the renderer without an anchor.
+     *
+     * The viewport is not fitted here: it follows the bounds of the world as a
+     * whole, for as long as the renderers own it (see
+     * {@link OpenSeadragonContext.resetViewport}). Reads and writes
+     * {@link _anchor}, so it must only be called from within an anchor task (see
+     * {@link _enqueueAnchorTask}).
+     *
+     * @param newBounds - The new bounds of the anchor, in world coordinates
+     * @param options - Optional abort signal, and index at which to insert the
+     * new anchor
+     * @returns A promise that resolves once the anchor has the new bounds
+     */
+    private _resizeAnchor;
+    /**
+     * Appends a task to the anchor task queue
+     *
+     * Tasks are run one at a time, in call order, and a failing task does not
+     * prevent subsequent tasks from running. Every task that reads or writes
+     * {@link _anchor} has to be enqueued here: concurrent tasks would each replace
+     * the anchor they captured, leaving the anchors created in between orphaned in
+     * the world, which shifts all subsequent world indices and thereby invalidates
+     * the layout expected by {@link _cleanRenderedObjects}.
+     *
+     * The queue is per renderer, and separate from the context's addition queue,
+     * which anchor tasks enqueue onto themselves.
+     *
+     * @param task - Task to run once all previously enqueued tasks have settled
+     * @returns A promise that resolves with the task's result
+     */
+    private _enqueueAnchorTask;
+}
+
+/**
+ * A reference to a points object, its layer, and its loaded data
+ */
+declare type PointsRef = ObjectRef_2<Points, PointsData>;
+
+/**
+ * What a preparation of a points object uploads
+ *
+ * See {@link WebGLPointsRenderer.prepareRenderedObject}.
+ */
+declare type PreparedPoints = {
+    objectBounds: Rect;
+    maskedGeometry: PointsGeometry | undefined;
+    packedPointMarkers: Uint8Array | number | undefined;
+    packedPointSizes: Float32Array | number | undefined;
+    packedPointColors: Uint32Array | number | undefined;
+    renderConfigSnapshot: RenderedPoints["renderConfigSnapshot"];
+};
+
+/**
+ * What a preparation of a shapes object uploads
+ *
+ * See {@link WebGLShapesRenderer.prepareRenderedObject}.
+ */
+declare type PreparedShapes = {
+    objectBounds: Rect;
+    edgesPerScanline: number;
+    binWidthFactor: number;
+    shapePadding: number;
+    numScanlines: number;
+    numBins: number;
+    scanlineBuffer: Uint32Array | undefined;
+    packedShapeFillColors: Uint32Array | undefined;
+    packedShapeStrokeColors: Uint32Array | undefined;
+    renderConfigSnapshot: RenderedShapes["renderConfigSnapshot"];
+};
+
+/**
+ * The rendered state of one {@link ObjectRef}
+ *
+ * Extended by the renderers with the GPU resources they own, and with a
+ * snapshot of the object properties those were built from, which their change
+ * detection compares against. Rendered objects are mutated in place across
+ * synchronizations:
+ * {@link WebGLRendererBase.matchOrDestroyRenderedObjects} replaces the
+ * reference of a matched object, and the renderers replace the bounds, the
+ * snapshot and the GPU resources of an object as they are rebuilt.
+ */
+declare type RenderedObjectBase<TObject extends Points | Shapes, TObjectData extends PointsData | ShapesData> = {
+    /** The reference the object was last matched to, holding what its GPU resources were resolved from */
+    ref: ObjectRef_2<TObject, TObjectData>;
+    /** The bounds of the object's items, in data coordinates */
+    objectBounds: Rect;
+};
+
+/**
+ * GPU state for a single points object
+ *
+ * Holds the vertex array, the coordinate buffers it is configured with, and
+ * the per-point attributes, each backed by a buffer holding one value per
+ * point or by one constant value for all points (see
+ * {@link WebGLPointsRenderer._backAttribute}), plus a snapshot of the model
+ * values they were loaded from, which the change predicates compare against
+ * (see {@link WebGLPointsRenderer._createRenderConfigSnapshot}). Layer- and
+ * object-level properties are read from the current model when drawing (see
+ * {@link WebGLRendererBase.getRenderPasses}), and are not part of the snapshot.
+ */
+declare type RenderedPoints = RenderedObjectBase<Points, PointsData> & {
+    vao: WebGLVertexArrayObject;
+    buffers: {
+        x: WebGLBuffer;
+        y: WebGLBuffer;
+    };
+    attributes: {
+        marker: WebGLBuffer | number;
+        size: WebGLBuffer | number;
+        color: WebGLBuffer | number;
+    };
+    renderConfigSnapshot: Pick<Points, "pointMarker" | "pointSize" | "pointColor" | "pointVisibility" | "pointOpacity"> & {
+        pointMarkerMap: GroupValueMap<Marker> | undefined;
+        pointSizeMap: GroupValueMap<number> | undefined;
+        pointColorMap: GroupValueMap<Color> | undefined;
+        pointVisibilityMap: GroupValueMap<boolean> | undefined;
+        pointOpacityMap: GroupValueMap<number> | undefined;
+    };
+};
+
+/**
+ * GPU state for a single shapes object
+ *
+ * Holds the texture handles for scanline data, fill colors and stroke colors,
+ * plus a snapshot of the model values they were built from, which the change
+ * predicates compare against (see
+ * {@link WebGLShapesRenderer._createRenderConfigSnapshot}). Layer- and
+ * object-level properties are read from the current model when drawing (see
+ * {@link WebGLRendererBase.getRenderPasses}), and are not part of the
+ * snapshot. The grid render options are the ones the scanline data texture
+ * was rasterized for (see
+ * {@link WebGLShapesRenderer.getRenderOptionsSyncState}), and the numbers of
+ * scanlines and bins are the ones it was rasterized into, which are also the
+ * ones the object is drawn with.
+ */
+declare type RenderedShapes = RenderedObjectBase<Shapes, ShapesData> & {
+    edgesPerScanline: number;
+    binWidthFactor: number;
+    shapePadding: number;
+    numScanlines: number;
+    numBins: number;
+    scanlineDataTexture: WebGLTexture;
+    shapeFillColorsTexture: WebGLTexture;
+    shapeStrokeColorsTexture: WebGLTexture;
+    renderConfigSnapshot: Pick<Shapes, "shapeVisibility" | "shapeOpacity" | "shapeFillColor" | "shapeFillVisibility" | "shapeFillOpacity" | "shapeStrokeColor" | "shapeStrokeVisibility" | "shapeStrokeOpacity"> & {
+        shapeVisibilityMap: GroupValueMap<boolean> | undefined;
+        shapeOpacityMap: GroupValueMap<number> | undefined;
+        shapeFillColorMap: GroupValueMap<Color> | undefined;
+        shapeFillVisibilityMap: GroupValueMap<boolean> | undefined;
+        shapeFillOpacityMap: GroupValueMap<number> | undefined;
+        shapeStrokeColorMap: GroupValueMap<Color> | undefined;
+        shapeStrokeVisibilityMap: GroupValueMap<boolean> | undefined;
+        shapeStrokeOpacityMap: GroupValueMap<number> | undefined;
+    };
+};
+
+/**
+ * A reference to a shapes object, its layer, and its loaded data
+ */
+declare type ShapesRef = ObjectRef_2<Shapes, ShapesData>;
+
+/**
+ * Controller for managing the drawing of SVG shapes
+ */
+export declare class SVGController {
+    readonly container: SVGSVGElement;
+    readonly transformNode: SVGGElement;
+    readonly shapeCompleteHandler?: (shape: MultiPolygon) => void;
+    private static readonly _previewFillColor;
+    private static readonly _previewStrokeColor;
+    private static readonly _previewStrokeWidthFactor;
+    private static readonly _minShapeSizeFactor;
+    private static readonly _closeShapeThresholdFactor;
+    private static readonly _vertexMarkerRadiusFactor;
+    private _containerSize;
+    private _viewport;
+    private _interactionMode?;
+    private _rectangleDrawingState;
+    private _polygonDrawingState;
+    private _freehandDrawingState;
+    /** Creates a positioned, full-size `<svg>` element for the SVG overlay */
+    static createContainer(): SVGSVGElement;
+    /**
+     * Creates the transform node inside the given container and registers the
+     * shape drawing event handlers
+     *
+     * The viewport starts out as the unit square; {@link setViewport} is the only
+     * way to change it.
+     *
+     * @param container - The `<svg>` element to draw on (typically created by {@link createContainer})
+     * @param options - Optional shape drawing event handlers
+     */
+    constructor(container: SVGSVGElement, options?: {
+        onShapeComplete?: (shape: MultiPolygon) => void;
+    });
+    /**
+     * Updates the world-space viewport rectangle
+     *
+     * @param viewport - New viewport bounds in world coordinates
+     * @returns `true` if the viewport actually changed, `false` otherwise
+     */
+    setViewport(viewport: Rect): boolean;
+    /**
+     * Updates the interaction mode
+     *
+     * @param newInteractionMode - New interaction mode
+     */
+    setInteractionMode(newInteractionMode: InteractionMode): void;
+    /**
+     * Resizes the SVG container to match the given screen-space dimensions,
+     * accounting for `devicePixelRatio`
+     *
+     * @param newContainerSize - Desired container size in screen-space pixels
+     * @returns `true` if the container size actually changed, `false` otherwise
+     */
+    resizeContainer(newContainerSize: Dims): boolean;
+    destroy(): void;
+    private _registerEventHandlers;
+    private _unregisterEventHandlers;
+    private _handlePointerDown;
+    private _handleRectanglePointerDown;
+    private _handleRectanglePointerMove;
+    private _handleRectanglePointerUp;
+    private _handlePolygonPointerDown;
+    private _handlePolygonPointerMove;
+    private _handlePolygonKeyDown;
+    private _handlePolygonPointerCancel;
+    private _handleFreehandPointerDown;
+    private _handleFreehandPointerMove;
+    private _handleFreehandPointerUp;
+    private _handleFreehandPointerCancel;
+    private _cancelFreehand;
+    private _createPreviewRect;
+    private _updatePreviewRect;
+    private _createRectangleMultiPolygon;
+    private _hasMinimumSize;
+    private _updatePolygonPreviewPolyline;
+    private _updateFirstVertexMarker;
+    private _completePolygon;
+    private _cancelPolygon;
+    private _createPreviewPolyline;
+    private _createVertexMarker;
+    private _setMarkerHighlighted;
+    private _createMultiPolygon;
+    private _isNearPoint;
+    private _screenToWorld;
+    /**
+     * Updates the world-to-viewport transform based on the current container size
+     * (in screen coordinates) and the current viewport (in world coordinates)
+     */
+    private _updateTransformNode;
+}
+
+/**
+ * A wrapper around a WebGL2RenderingContext that provides utility methods for
+ * creating shaders, programs, buffers, and textures
+ */
+export declare class WebGLContext {
+    private static readonly _maxCanvasSize;
+    readonly gl: WebGL2RenderingContext;
+    /** The largest width and height of a texture that the GPU supports, in texels */
+    readonly maxTextureSize: number;
+    /**
+     * Creates a new WebGLContext for the given canvas element
+     *
+     * @param canvas - The HTML canvas element to use for rendering
+     * @throws Error if the browser does not support WebGL 2.0
+     */
+    constructor(canvas: HTMLCanvasElement);
+    /**
+     * Resizes the canvas to match the given screen-space dimensions,
+     * accounting for `devicePixelRatio` and clamping to {@link _maxCanvasSize}
+     *
+     * @param canvas - The HTML canvas element to resize
+     * @param newCanvasSize - Desired canvas size in screen-space pixels
+     * @returns `true` if the canvas size actually changed, `false` otherwise
+     */
+    resizeCanvas(canvas: HTMLCanvasElement, newCanvasSize: Dims): boolean;
+    /**
+     * Clears the color buffer with transparent black
+     */
+    clear(): void;
+    /**
+     * Compiles vertex and fragment shaders, links them into a program, and
+     * returns the linked program
+     *
+     * The individual shaders are flagged for deletion after linking.
+     *
+     * @param vertexShaderSource - GLSL source for the vertex shader
+     * @param fragmentShaderSource - GLSL source for the fragment shader
+     * @throws Error if shader compilation or program linking fails
+     */
+    createProgram(vertexShaderSource: string, fragmentShaderSource: string): WebGLProgram;
+    /**
+     * Returns the location of a uniform variable in a shader program
+     *
+     * @param program - The shader program
+     * @param name - The uniform name as declared in the shader
+     * @throws Error if the uniform is not found
+     */
+    getUniformLocation(program: WebGLProgram, name: string): WebGLUniformLocation;
+    /**
+     * Creates a new vertex array object (VAO)
+     *
+     * @throws Error if VAO creation fails
+     */
+    createVertexArray(): WebGLVertexArrayObject;
+    /**
+     * Binds a buffer to a vertex attribute as a floating-point attribute
+     *
+     * @param target - Buffer binding target
+     * @param buffer - The buffer containing attribute data
+     * @param index - Attribute location index
+     * @param size - Number of components per vertex attribute
+     * @param type - Data type (e.g. `gl.FLOAT`)
+     * @param options - Optional normalized, stride, offset, and divisor settings
+     */
+    configureVertexFloatAttribute(target: GLenum, buffer: WebGLBuffer, index: number, size: number, type: GLenum, options?: {
+        normalized?: boolean;
+        stride?: number;
+        offset?: number;
+        divisor?: number;
+    }): void;
+    /**
+     * Binds a buffer to a vertex attribute as an integer attribute
+     *
+     * @param target - Buffer binding target
+     * @param buffer - The buffer containing attribute data
+     * @param index - Attribute location index
+     * @param size - Number of components per vertex attribute
+     * @param type - Data type (e.g. `gl.UNSIGNED_INT`)
+     * @param options - Optional stride, offset, and divisor settings
+     */
+    configureVertexIntAttribute(target: GLenum, buffer: WebGLBuffer, index: number, size: number, type: GLenum, options?: {
+        stride?: number;
+        offset?: number;
+        divisor?: number;
+    }): void;
+    /**
+     * Creates an immutable 2D data texture with nearest-neighbor filtering
+     * and clamp-to-edge wrapping
+     *
+     * @param internalformat - Internal texture format (e.g. `gl.RGBA32F`)
+     * @param width - Texture width in texels
+     * @param height - Texture height in texels
+     * @param format - Pixel data format (e.g. `gl.RGBA`)
+     * @param type - Pixel data type (e.g. `gl.FLOAT`)
+     * @param data - Optional initial pixel data
+     * @throws Error if texture creation fails
+     */
+    createDataTexture(internalformat: GLenum, width: number, height: number, format: GLenum, type: GLenum, data?: TypedArray): WebGLTexture;
+    /**
+     * Uploads new pixel data into an existing immutable 2D data texture
+     *
+     * @param texture - The target texture
+     * @param width - Texture width in texels
+     * @param height - Texture height in texels
+     * @param format - Pixel data format (e.g. `gl.RGBA`)
+     * @param type - Pixel data type (e.g. `gl.FLOAT`)
+     * @param data - The pixel data to upload
+     */
+    loadDataTexture(texture: WebGLTexture, width: number, height: number, format: GLenum, type: GLenum, data: TypedArray): void;
+    /**
+     * Loads an image from a URL and creates a WebGL texture from it
+     *
+     * If the image fails to load, or the operation is aborted, the pending image load is
+     * cancelled and the texture is deleted again before rejecting.
+     *
+     * @param url - The image URL
+     * @param options - Optional mipmap generation flag and abort signal
+     * @throws Error if texture creation fails, the image fails to load, or the
+     * operation was aborted
+     */
+    loadImageTextureFromUrl(url: string, options?: {
+        signal?: AbortSignal;
+        mipmap?: boolean;
+    }): Promise<WebGLTexture>;
+    /**
+     * Creates a new WebGL buffer
+     *
+     * @throws Error if buffer creation fails
+     */
+    createBuffer(): WebGLBuffer;
+    /**
+     * Allocates (or re-allocates) storage for a buffer and fills it with the
+     * given data, discarding previous contents
+     *
+     * @param target - Buffer binding target (e.g. `gl.ARRAY_BUFFER`)
+     * @param buffer - The buffer to allocate
+     * @param data - The data to fill the buffer with; sets its size
+     * @param usage - Usage hint (e.g. `gl.STATIC_DRAW`)
+     */
+    allocateBuffer(target: GLenum, buffer: WebGLBuffer, data: Exclude<TypedArray, Float64Array>, usage: GLenum): void;
+    /**
+     * Uploads typed array data into a region of an existing buffer
+     *
+     * @param target - Buffer binding target
+     * @param buffer - The target buffer
+     * @param data - The data to upload
+     * @param options - Optional element offset within the buffer
+     */
+    loadBuffer(target: GLenum, buffer: WebGLBuffer, data: Exclude<TypedArray, Float64Array>, options?: {
+        offset?: number;
+    }): void;
+    /**
+     * Enables premultiplied-alpha blending (Porter-Duff "over" operator)
+     */
+    enableAlphaBlending(): void;
+    /**
+     * Disables blending and restores the default blend state
+     */
+    disableAlphaBlending(): void;
+    /**
+     * Destroys the WebGLContext by forcing the underlying WebGL context to be
+     * lost, releasing its GPU resources immediately.
+     *
+     * Browsers cap the number of concurrently live WebGL contexts, so a context
+     * that is never released (e.g. across React StrictMode / HMR remounts)
+     * eventually prevents new contexts from being created. Callers are expected
+     * to have already destroyed any resources (programs, buffers, textures, VAOs)
+     * they created through this context.
+     */
+    destroy(): void;
+}
+
+/**
+ * WebGL renderer for two-dimensional point clouds
+ *
+ * Manages a shader program, a marker atlas texture, and per-object GPU
+ * buffers. Points are rendered as `gl.POINTS` using per-vertex attributes (x,
+ * y, size, color, marker), one draw call per object.
+ *
+ * Every object owns its vertex array and attribute buffers. Synchronizing
+ * compares the current model against the snapshot those buffers were loaded
+ * from, and re-uploads only the attributes whose inputs changed. An attribute
+ * whose configuration is a constant has no buffer at all: its value is
+ * supplied as a generic vertex attribute when drawing, which saves the buffer,
+ * its upload and the resolve (see {@link _backAttribute}).
+ * Layer- and object-level properties (transforms, point size factors,
+ * visibility and opacity) are shader uniforms, so changing them never touches
+ * the buffers, and never requires a synchronization (see
+ * {@link WebGLRendererBase.setModel}).
+ */
+export declare class WebGLPointsRenderer extends WebGLRendererBase<Points, PointsData, WebGLPointsSyncContext, PreparedPoints, RenderedPoints> {
+    private static readonly _attribLocations;
+    private static readonly _textureUnits;
+    renderOptions: WebGLPointsRenderOptions;
+    private readonly _program;
+    private readonly _uniformLocations;
+    private _markerAtlasTexture;
+    private _destroyed;
+    /**
+     * Creates the shader program and retrieves uniform locations
+     *
+     * The marker atlas texture is loaded asynchronously, so the renderer must not
+     * be drawn before `onInitialized` has been called; `onError` is called instead
+     * if loading it failed or was aborted, or if the renderer was destroyed
+     * meanwhile, in which case the texture is released right away.
+     *
+     * @param context - The WebGL context to use for rendering
+     * @param onInitialized - Called once the marker atlas texture has been loaded
+     * @param onError - Called if the marker atlas texture could not be loaded
+     * @param options - Optional abort signal
+     */
+    constructor(context: WebGLContext, onInitialized: () => void, onError: (error: Error) => void, options?: {
+        signal?: AbortSignal;
+    });
+    /**
+     * Issues the WebGL draw calls for all synchronized points
+     *
+     * Binds the shader program, configures the global uniforms (transform,
+     * viewport, canvas size in device pixels), binds the marker atlas texture,
+     * and then draws every object in its own `gl.POINTS` call with alpha
+     * blending, with its data → world matrix, point size factor and opacity
+     * factor as uniforms, computed from the current model (see
+     * {@link getRenderPasses}), and with the constants of its per-point
+     * attributes as generic vertex attributes (see {@link _backAttribute}).
+     * Objects whose layer or object is invisible are skipped.
+     *
+     * @throws Error if the renderer has not been initialized
+     */
+    draw(): void;
+    /**
+     * Releases the shader program, the marker atlas texture, and all per-object
+     * GPU resources
+     *
+     * A marker atlas texture that is still loading is released once it has
+     * loaded (see the constructor).
+     */
+    destroy(): void;
+    /**
+     * Returns the state of a points object that a synchronization depends on
+     *
+     * Blanks out the object-level point size factor, and the units of the point
+     * size configuration, on top of what the base class blanks out: the sizes are
+     * uploaded without their unit, which is applied as part of the point size
+     * factor uniform instead (see {@link _computePointSizeFactor}).
+     *
+     * @param points - The points object to return the state of
+     * @returns The points object without the properties that are applied when drawing
+     */
+    protected getObjectSyncState(points: Points): object;
+    /**
+     * Prepares everything that has to be uploaded for an object
+     *
+     * Decides what the object's buffers need - the geometry for a new object,
+     * and the markers, sizes and colors whose configurations or referenced maps
+     * changed (see {@link _createRenderConfigSnapshot}) - requests all of it
+     * before the first `await`, and then computes the bounds and folds the
+     * resolved visibilities and opacities into the colors. An attribute whose
+     * configuration is a constant is not resolved per point: it is prepared as
+     * the one packed value all points share (see {@link _backAttribute}).
+     *
+     * See {@link WebGLRendererBase.prepareRenderedObject} for when this runs.
+     *
+     * @param newRef - The object to prepare
+     * @param renderedPoints - The object's current GPU state, if it is reused
+     * @param syncContext - The inputs of the current synchronization
+     * @param options - Optional abort signal
+     * @returns The snapshot the decisions were based on, the masked geometry
+     * (new objects only), the bounds, and the attributes that have to be
+     * uploaded, each resolved per point or as a constant
+     */
+    protected prepareRenderedObject(newRef: PointsRef, renderedPoints: RenderedPoints | undefined, syncContext: WebGLPointsSyncContext, options?: {
+        signal?: AbortSignal;
+    }): Promise<PreparedPoints>;
+    /**
+     * Creates the vertex array and attributes of a new object
+     *
+     * @param newRef - The object
+     * @param prepared - Its preparation, which holds every attribute
+     * @returns The rendered object
+     */
+    protected createRenderedObject(newRef: PointsRef, prepared: PreparedPoints): RenderedPoints;
+    /**
+     * Backs the attributes of an object that were resolved again
+     *
+     * The snapshot is adopted last, so that an update that throws is retried by
+     * the next synchronization.
+     *
+     * @param renderedPoints - The rendered object to update in place
+     * @param prepared - Its preparation, holding the attributes that changed
+     * @returns Whether any attribute was backed again
+     */
+    protected updateRenderedObject(renderedPoints: RenderedPoints, prepared: PreparedPoints): boolean;
+    /**
+     * Deletes the vertex array and all attribute buffers owned by a single
+     * rendered object
+     *
+     * @param renderedPoints - The rendered object whose GPU resources to delete
+     */
+    protected destroyRenderedObject(renderedPoints: RenderedPoints): void;
+    /**
+     * Creates the vertex array of an object, configured with its coordinate
+     * buffers and per-point attributes
+     *
+     * The coordinates always go into buffers; the other attributes go into
+     * buffers or are constants, see {@link _backAttribute}.
+     *
+     * @param geometry - X and Y coordinates of the points, in data coordinates
+     * @param packedPointMarkers - The marker index of every point, or of all points
+     * @param packedPointSizes - The size of every point, or of all points
+     * @param packedPointColors - The packed RGBA color of every point, or of all points
+     * @returns The vertex array, the coordinate buffers and the per-point
+     * attributes it is configured with
+     */
+    private _createVertexArray;
+    /**
+     * Brings a per-point attribute of an object up to date with its prepared
+     * values, and returns what the attribute is now backed by
+     *
+     * A per-point attribute is backed either by a buffer holding one value per
+     * point, or, if its configuration is a constant, by nothing: the vertex
+     * attribute array is disabled in the vertex array, and the constant is
+     * supplied as a generic vertex attribute when drawing (see {@link draw}).
+     * Per-point values refill an existing buffer in place, or allocate one and
+     * enable the attribute array if the attribute was constant before; a constant
+     * releases an existing buffer and disables the attribute array. The buffer is
+     * released with the vertex array bound, as that is the only way a deleted
+     * buffer is detached from its attribute pointer; otherwise the vertex array
+     * would keep it alive.
+     *
+     * @param vao - The vertex array of the object
+     * @param location - The attribute location, see {@link _attribLocations}
+     * @param type - The data type of the attribute: `gl.FLOAT` configures a float
+     * attribute, any other type an integer attribute
+     * @param values - The prepared values: one per point, or one constant
+     * @param current - What the attribute is currently backed by; omitted for a
+     * new object
+     * @returns The buffer now holding the values, or the constant
+     */
+    private _backAttribute;
+    /**
+     * Computes the factor that converts the sizes of an object to world units
+     *
+     * Multiplies the object- and layer-level point size factors with the
+     * transform scales that the unit of the size configuration is subject to:
+     * sizes in data units scale with the object and layer transforms, sizes in
+     * layer units with the layer transform only, and sizes in world units with
+     * neither.
+     *
+     * @param layer - The layer the points are drawn on, as of the current model
+     * @param points - The points object being drawn, as of the current model
+     */
+    private static _computePointSizeFactor;
+    /**
+     * Copies a size configuration without its units
+     *
+     * The unit only affects {@link _computePointSizeFactor}, not the resolved
+     * sizes, so it is left out of the snapshot that
+     * {@link _checkPointSizeBufferChanged} compares.
+     */
+    private static _stripSizeUnit;
+    /**
+     * Captures what the buffers of an object are resolved from
+     *
+     * Every property the change predicates read has to be captured here: the
+     * item-level configurations, and the maps they resolve their values from,
+     * looked up now so that the predicates compare maps rather than map IDs (see
+     * {@link ConfigUtils.findGroupByMap}).
+     *
+     * @param newRef - The object to capture the snapshot of
+     * @param syncContext - The inputs of the current synchronization, holding the maps
+     * @returns The snapshot
+     */
+    private static _createRenderConfigSnapshot;
+    /**
+     * Returns whether the markers of an object have to be resolved again
+     *
+     * Also true for an object that has not been rendered yet, like the other
+     * predicates. Configurations are compared by value, maps by identity (see
+     * {@link _createRenderConfigSnapshot}).
+     */
+    private static _checkPointMarkerBufferChanged;
+    /**
+     * Returns whether the sizes of an object have to be resolved again
+     *
+     * The point size factors, transform scales and size units are shader
+     * uniforms (see {@link _computePointSizeFactor}), so only the rest of the
+     * point size configuration matters here.
+     */
+    private static _checkPointSizeBufferChanged;
+    /**
+     * Returns whether the colors of an object have to be resolved again
+     *
+     * Colors carry the resolved point visibilities and opacities in their alpha
+     * channel, so they also depend on those configurations. The layer- and
+     * object-level visibility and opacity are shader uniforms (see
+     * {@link WebGLRendererBase.computeOpacityFactor}) and do not matter here.
+     */
+    private static _checkPointColorBufferChanged;
+    /**
+     * Resolves the packed RGBA color all points share if the color, visibility
+     * and opacity configurations are all constants, `undefined` otherwise
+     *
+     * The three fold into one attribute (see {@link ColorUtils.withAlpha}), so
+     * it is only constant if all of them are.
+     */
+    private static _resolveConstantColor;
+    /**
+     * Computes the axis-aligned bounding box of the given points in data coordinates
+     *
+     * @param geometry - X and Y coordinates of the points, in data coordinates
+     * @param options - Optional abort signal
+     * @returns The axis-aligned bounding box of the points in data coordinates
+     * @throws Error if the coordinate arrays are empty or have different lengths
+     */
+    private static _getObjectBounds;
+}
+
+/**
+ * The inputs of a synchronization of the points renderer
+ *
+ * The tables and group-to-value maps that the objects resolve their
+ * properties from, and the loaders for points and table data (see
+ * {@link WebGLRendererBase.synchronize}).
+ */
+declare type WebGLPointsSyncContext = {
+    tables: Table[];
+    markerMaps: GroupValueMap<Marker>[];
+    sizeMaps: GroupValueMap<number>[];
+    colorMaps: GroupValueMap<Color>[];
+    visibilityMaps: GroupValueMap<boolean>[];
+    opacityMaps: GroupValueMap<number>[];
+    loadObject: (points: Points, options?: {
+        signal?: AbortSignal;
+    }) => Promise<PointsData>;
+    loadTable: (table: Table, options?: {
+        signal?: AbortSignal;
+    }) => Promise<TableData>;
+};
+
+/**
+ * Base class for WebGL renderers that draw the items of objects (points or shapes)
+ *
+ * {@link setModel} sets the layers and objects to render. The properties that
+ * are applied when drawing (transforms, visibility, opacity, draw order) are
+ * read from the current model on every draw (see {@link getRenderPasses}).
+ * Everything else is built into GPU resources by {@link synchronize}, which
+ * {@link needsSynchronization} tells when to call, through the
+ * {@link prepareRenderedObject}, {@link createRenderedObject} and
+ * {@link updateRenderedObject} hooks that the renderers implement.
+ *
+ * Objects are assigned to a layer either as a whole, by layer ID, or per item,
+ * by a table column; {@link loadObjects} resolves both into one
+ * {@link ObjectRef} per object and layer. The per-item assignment is cached by
+ * the identity of the object and table data (see {@link _getLayerItemsInfos}),
+ * so the loaders have to return immutable data that keeps its identity for as
+ * long as its content is unchanged. Likewise, the renderers detect an edit to
+ * a group-to-value map by comparing the maps that their objects' configurations
+ * resolve from by identity (see `ConfigUtils.findGroupByMap`), so the maps
+ * passed to a synchronization have to keep their identity for as long as they
+ * are unchanged.
+ */
+declare abstract class WebGLRendererBase<TObject extends Points | Shapes, TObjectData extends PointsData | ShapesData, TSyncContext extends {
+    tables: Table[];
+    loadObject: (object: TObject, options?: {
+        signal?: AbortSignal;
+    }) => Promise<TObjectData>;
+    loadTable: (table: Table, options?: {
+        signal?: AbortSignal;
+    }) => Promise<TableData>;
+}, TPreparedObject, TRenderedObject extends RenderedObjectBase<TObject, TObjectData>> {
+    readonly context: WebGLContext;
+    viewport: Rect;
+    private _model?;
+    private _lastSyncState?;
+    private _hasUnreportedChanges;
+    private readonly _renderedObjects;
+    private readonly _layerItemsInfosCache;
+    /**
+     * Creates a new WebGLRendererBase instance
+     *
+     * @param context - The WebGL context to use for rendering
+     */
+    constructor(context: WebGLContext);
+    /**
+     * Sets the layers and objects to render
+     *
+     * Layer- and object-level properties are drawn from uniforms, and the draw
+     * order is the order of the model, so a change that affects nothing else
+     * needs nothing done here: both are read from the new model by the next draw
+     * (see {@link getRenderPasses}).
+     * Every other change - a different set of layers or objects, layer
+     * memberships, data sources or item-level configurations - requires a
+     * resynchronization, which the caller is expected to trigger whenever
+     * {@link needsSynchronization} says so.
+     *
+     * Does not redraw: a model that differs at all differs either in a property
+     * that is applied when drawing, or in one that requires a resynchronization,
+     * so the caller is expected to redraw whenever this returns `true`. A model
+     * equal to the current one is ignored.
+     *
+     * The layers and objects are cloned, so that what the renderer compares
+     * against later - in {@link needsSynchronization}, and in the references of
+     * a synchronization - is what it was given, whatever the caller does with its
+     * instances afterwards.
+     *
+     * @param layers - The layers to render
+     * @param objects - The objects (points or shapes) to render
+     * @returns Whether the model differs from the current one
+     */
+    setModel(layers: Layer[], objects: TObject[]): boolean;
+    /**
+     * Gets the bounding box of all drawn objects, in world coordinates
+     *
+     * Reads the transforms from the current model (see
+     * {@link getRenderPasses}), so the bounds follow a model that requires no
+     * resynchronization.
+     *
+     * @returns The bounds, or null if nothing is drawn
+     */
+    getRenderedBounds(): Rect | null;
+    /**
+     * Returns whether the rendered objects have to be synchronized with the
+     * current model and render options
+     *
+     * Compares the state that a synchronization depends on (see
+     * {@link getSyncState}) against the one the last synchronization was based
+     * on (see {@link _recordSyncState}). Everything else about the model - the
+     * properties that are applied when drawing, and the order of the layers and
+     * objects - is fully applied by {@link setModel}, and everything else about
+     * the render options by the next draw.
+     *
+     * @returns Whether {@link synchronize} has to be called
+     */
+    needsSynchronization(): boolean;
+    /**
+     * Synchronizes the rendered objects with the current model and render options
+     *
+     * Loads the objects of the model (see {@link loadObjects}), drops the
+     * rendered objects that no longer match one (see
+     * {@link matchOrDestroyRenderedObjects}), and then creates or updates the
+     * rest in two passes. The first prepares every object (see
+     * {@link prepareRenderedObject}), issuing all requests before the first
+     * `await`: requests are shared with, and cancelled once abandoned by, a
+     * superseded synchronization, unless they are reclaimed within the same
+     * task. The second awaits the preparations in order and uploads each of them
+     * in one synchronous block (see {@link createRenderedObject} and
+     * {@link updateRenderedObject}), so a draw never sees a half-updated object.
+     *
+     * An object whose preparation fails, or finds nothing to render, is logged
+     * and dropped. A synchronization that fails or is aborted leaves the model
+     * unsynchronized (see {@link _discardSyncState}), and the changes it made
+     * before it stopped are reported by the next one that completes.
+     *
+     * @param syncContext - The inputs to synchronize with: the tables and
+     * group-to-value maps that the objects resolve their properties from, and
+     * the loaders for object and table data. It carries inputs only; what an
+     * object was resolved from is captured per object (see {@link ObjectRef})
+     * @param options - Optional abort signal
+     * @returns A promise that resolves to whether any rendered object changed
+     * since the last completed synchronization
+     * @throws Error if no model has been set (see {@link setModel})
+     */
+    synchronize(syncContext: TSyncContext, options?: {
+        signal?: AbortSignal;
+    }): Promise<boolean>;
+    /**
+     * Returns the state of the current model and render options that a
+     * synchronization depends on
+     *
+     * The layers and objects are keyed by ID, so that their order - the draw order
+     * - is not part of the state (see {@link getLayerSyncState} and
+     * {@link getObjectSyncState} for what is, and
+     * {@link getRenderOptionsSyncState} for the render options).
+     *
+     * @returns The state, or `undefined` if no model has been set
+     */
+    protected getSyncState(): object | undefined;
+    /**
+     * Returns the state of a layer that a synchronization depends on
+     *
+     * The counterpart of {@link getObjectSyncState} for layers. The point size
+     * factor is blanked out as well: it is a uniform of the points renderer, and
+     * the shapes renderer never reads it. So is the name, which nothing rendered
+     * depends on.
+     *
+     * @param layer - The layer to return the state of
+     * @returns The layer without the properties that are applied when drawing,
+     * and without the cosmetic ones
+     */
+    protected getLayerSyncState(layer: Layer): object;
+    /**
+     * Returns the state of an object that a synchronization depends on
+     *
+     * Everything but the properties that are applied when drawing, which are read
+     * from the current model on every draw (see {@link getRenderPasses}) and
+     * hence need no synchronization, and but the cosmetic ones, which nothing
+     * rendered depends on. Those are blanked out rather than dropped, so that a
+     * property added to the model later is part of the state, and thereby
+     * requires a resynchronization, unless it is blanked out here as well.
+     *
+     * The result is only ever deep-compared against that of another object, hence
+     * the opaque return type.
+     *
+     * @param object - The object (points or shapes) to return the state of
+     * @returns The object without the properties that are applied when drawing,
+     * and without the cosmetic ones
+     */
+    protected getObjectSyncState(object: TObject): object;
+    /**
+     * Returns the state of the render options that a synchronization depends on
+     *
+     * Render options that are applied when drawing need no synchronization and
+     * are left out. Nothing by default; a renderer whose GPU resources are built
+     * for a render option overrides this to return it.
+     *
+     * @returns The state, or `undefined` if no render option needs a synchronization
+     */
+    protected getRenderOptionsSyncState(): object | undefined;
+    /**
+     * Concurrently loads the data of all objects to be rendered on the layers of the current model
+     *
+     * An object assigned to a layer by layer ID is loaded for that layer only, an
+     * object assigned per item by a table column is loaded for every layer, with
+     * the items on each layer resolved from the table (see
+     * {@link _getLayerItemsInfos}). The data of an object, and of a table, is
+     * loaded once, no matter how many references it is shared by.
+     *
+     * The returned references are ordered by layer and then by object. Objects
+     * whose data or table failed to load are logged and skipped, and so are
+     * objects whose items are assigned per item without a table to resolve the
+     * assignment from. Objects without items on a layer are skipped silently,
+     * which also covers empty objects and objects whose table is empty - those
+     * are legitimate states, not failures.
+     *
+     * @param syncContext - The inputs of the current synchronization: the tables
+     * that the objects resolve their item layers from, and the loaders for
+     * object and table data
+     * @param options - Optional abort signal
+     * @returns A promise that resolves to one reference per loaded object and layer
+     * @throws Error if no model has been set (see {@link setModel})
+     */
+    protected loadObjects(syncContext: TSyncContext, options?: {
+        signal?: AbortSignal;
+    }): Promise<ObjectRef_2<TObject, TObjectData>[]>;
+    /**
+     * Matches the rendered objects to a new set of references, and destroys the
+     * ones left over
+     *
+     * A rendered object is matched by the layer and object it is kept under, and
+     * kept if its contributed items and data source are those of the reference,
+     * which it then adopts and is returned for reuse with. Every other rendered
+     * object - one that no reference addresses, or one whose items or data source
+     * changed - is destroyed and dropped.
+     *
+     * @param newRefs - The object references to match against
+     * @returns One match per reference, in the order of the references, each with
+     * the rendered object to reuse for it, or `undefined` if it has none yet
+     */
+    protected matchOrDestroyRenderedObjects(newRefs: ObjectRef_2<TObject, TObjectData>[]): {
+        newRef: ObjectRef_2<TObject, TObjectData>;
+        renderedObject: TRenderedObject | undefined;
+    }[];
+    /**
+     * Adds a newly created rendered object under its layer and object
+     *
+     * @param renderedObject - The rendered object to add
+     */
+    protected addRenderedObject(renderedObject: TRenderedObject): void;
+    /**
+     * Drops a rendered object and releases its GPU resources
+     *
+     * @param renderedObject - The rendered object to remove
+     */
+    protected removeRenderedObject(renderedObject: TRenderedObject): void;
+    /**
+     * Drops all rendered objects and releases their GPU resources
+     */
+    protected clearRenderedObjects(): void;
+    /**
+     * Prepares everything that has to be uploaded for an object
+     *
+     * Runs in the first pass of {@link synchronize}, which calls it synchronously
+     * for every object of a synchronization, one after the other: every request
+     * has to be issued before the first `await`. Decides, from the object's
+     * current rendered state, which of its GPU resources have to be rebuilt, and
+     * resolves only those.
+     *
+     * @param newRef - The object to prepare
+     * @param renderedObject - The object's current rendered state, if it is reused
+     * @param syncContext - The inputs of the current synchronization
+     * @param options - Optional abort signal
+     * @returns What {@link createRenderedObject} or {@link updateRenderedObject}
+     * upload, or `null` if there is nothing to render for the object, which is
+     * then dropped
+     */
+    protected abstract prepareRenderedObject(newRef: ObjectRef_2<TObject, TObjectData>, renderedObject: TRenderedObject | undefined, syncContext: TSyncContext, options?: {
+        signal?: AbortSignal;
+    }): Promise<TPreparedObject | null>;
+    /**
+     * Creates the rendered object, with its GPU resources, of a newly prepared object
+     *
+     * Runs in the second pass of {@link synchronize}, synchronously.
+     *
+     * @param newRef - The object
+     * @param prepared - Its preparation, made without a rendered object to reuse
+     * @returns The rendered object, which {@link synchronize} adds
+     */
+    protected abstract createRenderedObject(newRef: ObjectRef_2<TObject, TObjectData>, prepared: TPreparedObject): TRenderedObject;
+    /**
+     * Updates the GPU resources of a rendered object from its preparation
+     *
+     * Runs in the second pass of {@link synchronize}, synchronously.
+     *
+     * @param renderedObject - The rendered object to update in place
+     * @param prepared - Its preparation, made with it as the rendered object to reuse
+     * @returns Whether any GPU resource was uploaded to, i.e. whether the object
+     * draws differently now
+     */
+    protected abstract updateRenderedObject(renderedObject: TRenderedObject, prepared: TPreparedObject): boolean;
+    /**
+     * Releases the GPU resources owned by a single rendered object
+     *
+     * Does not remove the object from {@link _renderedObjects}, see
+     * {@link removeRenderedObject}.
+     *
+     * @param renderedObject - The rendered object whose GPU resources to release
+     */
+    protected abstract destroyRenderedObject(renderedObject: TRenderedObject): void;
+    /**
+     * Returns one render pass per rendered object to draw, in draw order
+     *
+     * A pass carries the layer and the object of the current model, and the
+     * rendered object holding the GPU resources to draw them with.
+     *
+     * The properties that are applied when drawing - the transforms, the
+     * visibility, the opacity and the point size factors - are read from the
+     * layer and the object returned here, never from the reference of a rendered
+     * object: the reference holds the object as it was when it was loaded (see
+     * {@link ObjectRef}), whereas these are the current ones, so that setting a
+     * model that only changes them takes effect without a resynchronization.
+     *
+     * The model is what is iterated, the way {@link loadObjects} iterates it:
+     * by layer, then by object, pairing an object with the layer it is assigned
+     * to by ID, or with every layer if its items are assigned to layers by a
+     * table column. That order is the draw order. Rendered objects whose layer or
+     * object has been removed from the model, or whose object has moved to
+     * another layer, are therefore never visited, until the resynchronization
+     * that the change requires drops them. Before a model is set, there is
+     * nothing to draw.
+     *
+     * @returns The render passes, in draw order
+     */
+    protected getRenderPasses(): {
+        layer: Layer;
+        object: TObject;
+        renderedObject: TRenderedObject;
+    }[];
+    /**
+     * Records the current model and render options as what the rendered objects
+     * are being synchronized with
+     *
+     * {@link synchronize} calls this first, before its first `await`: the model
+     * may be set again while it runs, and {@link needsSynchronization} has to
+     * report such a change against the model the synchronization actually read,
+     * not against the one it found when it finished. A synchronization that
+     * fails hands the returned state back to {@link _discardSyncState}, so that
+     * the model is synchronized again.
+     *
+     * @returns The recorded state
+     */
+    private _recordSyncState;
+    /**
+     * Forgets a recorded synchronization state, unless another synchronization
+     * has recorded its own since
+     *
+     * Called by a synchronization that failed, so that
+     * {@link needsSynchronization} reports the model as unsynchronized again. A
+     * synchronization that was aborted because a newer one started must not
+     * undo what the newer one recorded, hence the identity check.
+     *
+     * @param syncState - The state the failed synchronization recorded, as
+     * returned by {@link _recordSyncState}
+     */
+    private _discardSyncState;
+    /**
+     * Returns the items of an object that belong to each of the given layers
+     *
+     * Layers that are missing from {@link _layerItemsInfosCache} are computed in a
+     * single pass over the items of the object, looking each item's row up in the
+     * table (see {@link TableUtils.forEachRow}), and are added to the cache.
+     * Layers that are already cached for the same object data, table data and
+     * layer column are re-used as they are, so that objects sharing their data,
+     * but not their table or layer column, do not evict each other's layers.
+     * Cached layers that are not among the given ones are dropped, as are their
+     * item masks, which take one byte per item of the object. Item IDs and masks
+     * are only allocated for layers that turn out to contain items, layers
+     * without items are cached as `null`.
+     *
+     * @param data - The data of the object to compute the item masks for
+     * @param tableData - The data of the table holding the item layers
+     * @param tableLayersColumn - The name of the table column holding the layer IDs
+     * @param tableLayers - The values of the table column, in table item order
+     * @param layers - The layers to compute the item masks for
+     * @param options - Optional abort signal
+     * @returns A promise that resolves to the item IDs and mask of each layer, by
+     * layer ID, or to `null` for layers without items
+     */
+    private _getLayerItemsInfos;
+    /**
+     * Awaits the preparation of an object, dropping the object if it fails or
+     * finds nothing to render
+     *
+     * @param newRef - The prepared object
+     * @param renderedObject - The object's current rendered state, if any, which
+     * is removed if the object is dropped
+     * @param preparedPromise - The preparation, see {@link prepareRenderedObject}
+     * @param options - Optional abort signal
+     * @returns The preparation, or `undefined` if the object was dropped (which
+     * is logged)
+     */
+    private _settleRenderedObjectPreparation;
+    /**
+     * Creates the loader for the tables that an object resolves its properties
+     * from
+     *
+     * A configuration may name a table other than the object's, in which case its
+     * values are resolved by the item IDs of the object's own table.
+     *
+     * @param ref - The object reference
+     * @param syncContext - The inputs of the current synchronization: the tables to
+     * look the configured table up in, and the loader for table data
+     * @returns The loader, taking the ID of a table, or `undefined` for the
+     * object's own table; it rejects if the object has no table, or the table was
+     * not found
+     */
+    protected static createTableLoader(ref: ObjectRef_2<Points | Shapes, PointsData | ShapesData>, syncContext: {
+        tables: Table[];
+        loadTable: (table: Table, options?: {
+            signal?: AbortSignal;
+        }) => Promise<TableData>;
+    }): (tableId: string | undefined, options?: {
+        signal?: AbortSignal;
+    }) => Promise<TableData>;
+    /**
+     * Computes the factor that the alpha of every item of an object is
+     * multiplied with when drawing
+     *
+     * @param layer - The layer the object is drawn on, as of the current model
+     * @param object - The object being drawn, as of the current model
+     * @returns The product of the layer and object opacities, or `0` if the
+     * layer or the object is invisible
+     */
+    protected static computeOpacityFactor(layer: Layer, object: Points | Shapes): number;
+}
+
+/**
+ * WebGL renderer for two-dimensional shape clouds
+ *
+ * Shapes are rasterized on the GPU via a scanline-based algorithm. Each shapes
+ * object is represented by a quad covering its bounds within the viewport,
+ * whose fragment shader samples a scanline data texture to determine polygon
+ * membership, fill colors, and stroke colors.
+ *
+ * Every object owns its textures. Synchronizing compares the current model
+ * against the snapshot those textures were built from, and rebuilds only the
+ * ones whose inputs changed. Layer- and object-level properties (transforms,
+ * visibility and opacity) are shader uniforms, so changing them never touches
+ * the textures, and never requires a synchronization (see
+ * {@link WebGLRendererBase.setModel}).
+ */
+export declare class WebGLShapesRenderer extends WebGLRendererBase<Shapes, ShapesData, WebGLShapesSyncContext, PreparedShapes, RenderedShapes> {
+    private static readonly _scanlineDataTextureWidth;
+    private static readonly _shapeColorsTextureWidth;
+    private static readonly _numValuesPerScanlineDataTextureLine;
+    private static readonly _numValuesPerShapeColorsTextureLine;
+    private static readonly _textureUnits;
+    renderOptions: WebGLShapesRenderOptions;
+    private readonly _program;
+    private readonly _uniformLocations;
+    /**
+     * Creates the shader program and retrieves uniform locations
+     *
+     * @param context - The WebGL context to use for rendering
+     */
+    constructor(context: WebGLContext);
+    /**
+     * Issues the WebGL draw calls for all synchronized shapes
+     *
+     * Renders each shapes object as a quad whose fragment shader performs
+     * scanline-based polygon rasterization using the per-object scanline data
+     * texture, with the viewport → world matrix as a global uniform and its
+     * world → data matrix, bounds, numbers of scanlines and bins, half stroke
+     * width and device pixel size in data units (for anti-aliasing) and opacity
+     * factor as per-pass uniforms, computed from the current model (see
+     * {@link getRenderPasses}). The quad covers the object's bounds, dilated by
+     * how far the anti-aliased strokes reach beyond them, within the viewport, so
+     * that fragments are only shaded where the object can be; objects outside the
+     * viewport, objects whose layer or object is invisible, and objects without
+     * scanlines or bins are skipped.
+     */
+    draw(): void;
+    /**
+     * Releases the shader program and all per-object GPU textures
+     */
+    destroy(): void;
+    /**
+     * Gets the bounding box of all drawn shapes, in world coordinates
+     *
+     * Dilates the bounds of the shapes by half the stroke width, as the strokes
+     * reach beyond them, but not by the anti-aliasing margin, which depends on
+     * the current zoom level (see {@link _computeQuad}).
+     */
+    getRenderedBounds(): Rect | null;
+    /**
+     * Returns the grid render options (the number of edges per scanline, the
+     * bin width factor and the shape padding), which the scanline data textures
+     * are rasterized for, so that changing them requires a resynchronization
+     */
+    protected getRenderOptionsSyncState(): object;
+    /**
+     * Prepares everything that has to be uploaded for an object
+     *
+     * Decides what the object's textures need - the geometry for a new object or
+     * changed grid render options (see {@link getRenderOptionsSyncState}), and
+     * the resolved fill and stroke colors whose configurations or referenced
+     * maps changed (see {@link _createRenderConfigSnapshot}) -
+     * requests all of it before the first `await`, and then computes the bounds,
+     * the grid size and the paddings, rasterizes the scanline data and folds the
+     * resolved visibilities and opacities into the colors.
+     *
+     * See {@link WebGLRendererBase.prepareRenderedObject} for when this runs.
+     *
+     * @param newRef - The object to prepare
+     * @param renderedShapes - The object's current GPU state, if it is reused
+     * @param syncContext - The inputs of the current synchronization
+     * @param options - Optional abort signal
+     * @returns The snapshot the decisions were based on, the bounds, the grid
+     * render options and the numbers of scanlines and bins, the packed scanline
+     * data (if the geometry was loaded) and the resolved colors that have to be
+     * uploaded, or `null` if the shapes have no area
+     */
+    protected prepareRenderedObject(newRef: ShapesRef, renderedShapes: RenderedShapes | undefined, syncContext: WebGLShapesSyncContext, options?: {
+        signal?: AbortSignal;
+    }): Promise<PreparedShapes | null>;
+    /**
+     * Creates the textures of a new object
+     *
+     * @param newRef - The object
+     * @param prepared - Its preparation, which holds every texture's data
+     * @returns The rendered object
+     */
+    protected createRenderedObject(newRef: ShapesRef, prepared: PreparedShapes): RenderedShapes;
+    /**
+     * Reloads the textures of an object whose data was prepared again
+     *
+     * Refills the colors textures in place, and creates a new scanline data
+     * texture before releasing the one it replaces, so that the old one survives
+     * if creating the new one throws. The snapshot is adopted last, so that an
+     * update that throws is retried by the next synchronization.
+     *
+     * @param renderedShapes - The rendered object to update in place
+     * @param prepared - Its preparation, holding the texture data that changed
+     * @returns Whether any texture was reloaded
+     */
+    protected updateRenderedObject(renderedShapes: RenderedShapes, prepared: PreparedShapes): boolean;
+    /**
+     * Deletes all GPU textures owned by a single rendered object
+     *
+     * @param renderedShapes - The rendered object whose textures to delete
+     */
+    protected destroyRenderedObject(renderedShapes: RenderedShapes): void;
+    /**
+     * Builds the scanline data of a shapes object
+     *
+     * Rasterizes all shapes into horizontal scanlines and their x-bins, packed
+     * into a 32-bit integer buffer, aligned to the lines of the scanline data
+     * texture that {@link _createScanlineDataTexture} creates from it.
+     *
+     * @param numScanlines - Number of scanlines to rasterize into
+     * @param numBins - Number of x-bins per scanline
+     * @param scanlinePadding - See {@link WebGLShapesRasterizer.rasterizeScanlines}
+     * @param binPadding - See {@link WebGLShapesRasterizer.rasterizeScanlines}
+     * @param geometry - Geometry for all shapes in the object
+     * @param shapesMask - Per-shape inclusion mask, or `undefined` if all shapes are included
+     * @param objectBounds - Axis-aligned bounding box of all shapes
+     * @param options - Optional abort signal
+     * @returns The packed scanline data
+     */
+    private static _createScanlineBuffer;
+    /**
+     * Throws unless a data texture of the given size fits the GPU
+     *
+     * Checked while an object is prepared, where a failure drops only that
+     * object, with a message that says why, rather than when its textures are
+     * created, where WebGL would fail with an opaque error, or render garbage.
+     * The width is fixed per texture, but WebGL 2 only guarantees 2048 texels.
+     *
+     * @param name - What the texture holds, for the error message
+     * @param width - The width of the texture, in texels
+     * @param height - The number of texture lines the data needs
+     * @throws Error if the width or height exceeds the maximum texture size
+     */
+    private _checkDataTextureSize;
+    /**
+     * Uploads packed scanline data as an RGBA32UI texture
+     *
+     * @param scanlineBuffer - The packed scanline data, see {@link _createScanlineBuffer}
+     * @returns The scanline data texture
+     */
+    private _createScanlineDataTexture;
+    /**
+     * Uploads packed fill or stroke colors as a new R32UI texture
+     *
+     * @param packedShapeColors - The packed RGBA colors, one per shape, aligned
+     * to the texture width
+     * @returns The colors texture
+     */
+    private _createShapeColorsTexture;
+    /**
+     * Refills an existing colors texture with packed fill or stroke colors
+     *
+     * The texture has to have been created by {@link _createShapeColorsTexture}
+     * for the same number of shapes: its storage is immutable, so the colors
+     * have to fill it exactly.
+     *
+     * @param texture - The colors texture to refill
+     * @param packedShapeColors - The packed RGBA colors, one per shape, aligned
+     * to the texture width
+     */
+    private _loadShapeColorsTexture;
+    /**
+     * Computes the quad to draw an object with, in viewport coordinates
+     *
+     * The object's bounds are transformed to world coordinates, dilated by how
+     * far the anti-aliased strokes reach beyond the shapes (half the stroke
+     * width, which is at least half a pixel, plus half a pixel, see fragment
+     * shader), and intersected with the viewport, then expressed in viewport
+     * coordinates, `[0, 1]` spanning the viewport. Fragments outside the
+     * object's bounds are discarded by the fragment shader anyway, so drawing
+     * only this quad changes nothing but the number of fragments shaded.
+     *
+     * @param objectBounds - The bounds of the object's shapes, in data coordinates
+     * @param dataToWorldMatrix - The data → world matrix of the object
+     * @param worldDevicePixelSize - The size of a device pixel, in world coordinates
+     * @returns The quad, or `null` if the object lies outside the viewport
+     */
+    private _computeQuad;
+    /**
+     * Captures what the textures of an object are resolved from
+     *
+     * Every property the change predicates read has to be captured here: the
+     * item-level configurations, and the maps they resolve their values from,
+     * looked up now so that the predicates compare maps rather than map IDs (see
+     * {@link ConfigUtils.findGroupByMap}).
+     *
+     * @param newRef - The object to capture the snapshot of
+     * @param syncContext - The inputs of the current synchronization, holding the maps
+     * @returns The snapshot
+     */
+    private static _createRenderConfigSnapshot;
+    /**
+     * Returns whether the fill colors of an object have to be resolved again
+     *
+     * Colors carry the resolved shape and fill visibilities and opacities in
+     * their alpha channel, so they also depend on those configurations. The
+     * layer- and object-level visibility and opacity are shader uniforms (see
+     * {@link WebGLRendererBase.computeOpacityFactor}) and do not matter here.
+     * Also true for an object that has not been rendered yet, like the other
+     * predicate. Configurations are compared by value, maps by identity (see
+     * {@link _createRenderConfigSnapshot}).
+     */
+    private static _checkShapeFillColorsTextureChanged;
+    /**
+     * Returns whether the stroke colors of an object have to be resolved again
+     *
+     * See {@link _checkShapeFillColorsTextureChanged}.
+     */
+    private static _checkShapeStrokeColorsTextureChanged;
+    /**
+     * Computes the axis-aligned bounding box of all (included) shapes
+     *
+     * @param geometry - Geometry for all shapes in the object
+     * @param shapesMask - Per-shape inclusion mask, or `undefined` if all shapes are included
+     * @param options - Optional abort signal
+     * @returns The bounding rectangle in data-space coordinates, or `null` if the
+     * shapes have no area, including shapes without any vertices, as such an
+     * object can neither be rasterized into scanlines nor drawn by the fragment
+     * shader
+     */
+    private static _getObjectBounds;
+}
+
+/**
+ * The inputs of a synchronization of the shapes renderer
+ *
+ * The tables and group-to-value maps that the objects resolve their
+ * properties from, and the loaders for shapes and table data (see
+ * {@link WebGLRendererBase.synchronize}).
+ */
+declare type WebGLShapesSyncContext = {
+    tables: Table[];
+    colorMaps: GroupValueMap<Color>[];
+    visibilityMaps: GroupValueMap<boolean>[];
+    opacityMaps: GroupValueMap<number>[];
+    loadObject: (shapes: Shapes, options?: {
+        signal?: AbortSignal;
+    }) => Promise<ShapesData>;
+    loadTable: (table: Table, options?: {
+        signal?: AbortSignal;
+    }) => Promise<TableData>;
+};
+
+export { }