Documentation / @ripl/core

@ripl/core

Core rendering library for Ripl — a unified API for 2D graphics rendering across Canvas, SVG, and Terminal contexts.

Installation

npm install @ripl/core

Features

• Unified rendering API — One API surface for both Canvas and SVG contexts
• Built-in elements — Arc, circle, rect, line, polyline, polygon, ellipse, path, text, and image
• Scene management — Scenegraph with grouping, property inheritance, and element querying
• Animation — High-performance async transitions with CSS-like keyframe support and custom interpolators
• Event system — Event bubbling, delegation, and stop propagation (mimics the DOM)
• Scales — Continuous, discrete, and time scales for data mapping
• Color — Color parsing, interpolation, and conversion (RGB, HSL, Hex)
• Math — Geometry utilities, vector operations, and easing functions
• Zero dependencies — Fully self-contained
• Tree-shakable — Only ship what you use

Usage

import {
    createCircle,
    createContext,
    createRenderer,
    createScene,
} from '@ripl/web';

const context = createContext('.mount-element');

const circle = createCircle({
    fill: 'rgb(30, 105, 120)',
    cx: context.width / 2,
    cy: context.height / 2,
    radius: 50,
});

const scene = createScene({
    children: [circle],
});

const renderer = createRenderer(scene, {
    autoStart: true,
    autoStop: true,
});

await renderer.transition(circle, {
    duration: 1000,
    state: {
        radius: 100,
        fill: '#FF0000',
    },
});

Switching to SVG

Replace the createContext import with @ripl/svg — everything else stays the same:

import {
    createContext,
} from '@ripl/svg';

Documentation

Full documentation and interactive demos are available at ripl.run.

License

MIT

Namespaces

Namespace	Description
interpolateAny	Fallback interpolator factory that snaps from the first value to the second at the halfway point.
interpolateBorderRadius	Interpolator factory that transitions between two border-radius values (single number or four-corner tuple).
interpolateColor	Interpolator factory that smoothly transitions between two CSS color strings by interpolating their RGBA channels.
interpolateDate	Interpolator factory that interpolates between two Date instances by lerping their timestamps.
interpolateGradient	Interpolator factory that transitions between two CSS gradient strings by interpolating their stops, angles, and positions.
interpolateNumber	Interpolator factory that linearly interpolates between two numbers.
interpolatePoints	Interpolator factory that transitions between two point arrays. By default it extrapolates additional points where set lengths differ; pass resolveKeys to match points by identity instead (preserving curved renderers across add/remove).
interpolateRotation	Interpolator factory that transitions between two rotation values (numbers in radians or strings like "90deg").
interpolateTransformOrigin	Interpolator factory that transitions between two transform-origin values (numbers or percentage strings).

Classes

Class	Description
Arc	An arc or annular sector shape supporting inner radius and pad angle.
Box	An axis-aligned bounding box defined by its four edges.
Circle	A circle shape rendered at a center point with a given radius.
ColorParseError	Error thrown when a color string cannot be parsed in the expected format.
Context	Abstract rendering context providing a unified API for Canvas and SVG, with state management and coordinate scaling.
ContextPath	A virtual path element used to record drawing commands; subclassed by Canvas and SVG implementations.
ContextText	A virtual text element capturing position, content, and optional path-based text layout.
Disposer	Abstract base class that manages disposable resources, supporting keyed retention and bulk disposal.
Element	The base renderable element with state management, event handling, interpolation, transform support, and context rendering.
Ellipse	An ellipse shape rendered at a center point with separate x/y radii, rotation, and angle range.
Event	An event object carrying type, data, target reference, and propagation control.
EventBus	A typed pub/sub event system with parent-chain bubbling, disposable subscriptions, and self-filtering.
Group	A container element that manages child elements, providing scenegraph traversal, CSS-like querying, and composite bounding boxes.
ImageElement	An image element that draws a CanvasImageSource at a given position and optional size.
Line	A straight line segment between two points.
Navigator	An interactive 2D pan/zoom/brush controller — the flat-scene analogue of the 3D Camera. This base class is deliberately context-agnostic: it owns the view model (a { k, x, y } transform plus an optional brush selection) and the imperative commands that mutate it, but it attaches no input listeners of its own. That mirrors the Context/DOMContext split — the DOM-bound DOMNavigator in @ripl/dom extends this class to translate real wheel/pointer/touch gestures into these commands, while non-DOM environments can drive the same view model programmatically (or subclass it with their own input source).
Path	A general-purpose shape rendered by a user-supplied path renderer callback.
Polygon	A regular polygon shape with a configurable number of sides.
Polyline	A multi-point line shape supporting various curve interpolation algorithms.
Rect	A rectangle shape with optional rounded corners via border radius.
Renderer	Drives the animation loop via requestAnimationFrame, managing per-element transitions and rendering the scene each frame.
Scene	The top-level group bound to a rendering context, maintaining a hoisted flat instruction stream for O(n) rendering.
Shape	Abstract base class for renderable shapes, extending Element with a type-constrained constructor.
Shape2D	A concrete 2D shape with path management, automatic fill/stroke rendering, clipping support, and path-based hit testing.
Task	A cancellable promise with AbortController integration, supporting abort callbacks and chaining.
TaskAbortError	Error thrown when a task is aborted, carrying the abort reason.
Text	A text element that renders string or numeric content, with optional path-based text layout.
Transition	A Task-based animation that drives a callback over time with easing, looping, and abort support.

Interfaces

Interface	Description
ArcState	State interface for an arc element, defining center, angles, radii, pad angle, and border radius.
BandScale	A band scale that divides a continuous range into uniform bands for categorical data, exposing bandwidth and step.
BaseState	The full set of visual state properties inherited by every renderable element.
CircleState	State interface for a circle element, defining center coordinates and radius.
ColorParser	A color parser that can test, parse, and serialise a specific color format.
ColorScale	A callable colour scale mapping a numeric value to a CSS colour, with domain and tick access.
ConicGradient	A parsed conic gradient with angle, position, color stops, and optional repeating flag.
ContextElement	Minimal interface for context-level elements (paths, text) identified by a unique id.
ContextEventMap	Event map for a rendering context, including resize and pointer events.
ContextExport	Snapshot exporter returned by Context.export. Each method serializes the snapshot that was captured at the moment export() was called, so later mutations to the context do not affect the exported result. Contexts implement the formats relevant to them (see each context's export() for specifics); unsupported formats throw a descriptive error.
ContextOptions	Options for constructing a rendering context.
DivergingScaleOptions	Options for a diverging scale, adding a midpoint to the base linear scale options.
ElementEventMap	Event map for elements, extending the base event map with lifecycle and interaction events.
ElementValidationResult	The result of validating an element, with a severity type and descriptive message.
EllipseState	State interface for an ellipse element, defining center, radii, rotation, and angle range.
FactoryOptions	Platform-specific function implementations injected at runtime.
GradientColorStop	A single color stop within a gradient, consisting of a CSS color and an optional offset position.
GroupOptions	Options for constructing a group, extending element options with an optional initial set of children.
ImageState	State interface for an image element, defining position, optional size, and image source.
InterpolatePointsFactory	The interpolatePoints factory: a point-array interpolator factory that also accepts InterpolatePointsOptions.
InterpolatePointsOptions	Options controlling how interpolatePoints reconciles two point sets.
LinearGradient	A parsed linear gradient with angle, color stops, and optional repeating flag.
LinearScaleOptions	Options shared by linear-based scales (continuous, logarithmic, power, etc.).
LineState	State interface for a line element, defining start and end coordinates.
LogarithmicScaleOptions	Options for a logarithmic scale, adding a configurable base to the base linear scale options.
NavigatorBrush	A rectangular brush selection in the navigator's pixel space.
NavigatorEventMap	Events emitted by a Navigator.
NavigatorFitOptions	Options for Navigator.fitBounds.
NavigatorInteractions	Configures which navigator interactions (zoom, pan, brush) are enabled.
NavigatorOptions	Options for constructing a Navigator.
NavigatorTransform	A 2D affine view transform: uniform scale k plus translation [x, y] (screen pixels).
NavigatorViewport	The pixel dimensions of the surface the navigator drives (used to centre/fit content).
OrdinalScale	A callable ordinal scale mapping discrete domain values to a cycling range of output values.
PathState	State interface for a path element, defining bounding position and dimensions.
PointScale	A point scale that positions discrete domain values at evenly spaced points, exposing the step.
PointScaleOptions	Options for a point scale, controlling outer padding and alignment within the range.
PolygonState	State interface for a regular polygon element, defining center, radius, and number of sides.
PolylineState	State interface for a polyline element, defining points and an optional curve renderer.
PowerScaleOptions	Options for a power scale, adding a configurable exponent to the base linear scale options.
Queryable	The structural contract the CSS-like query engine operates on, implemented by every Element. Container elements (Group) additionally provide children and a flattened descendant graph so combinators can traverse the scene tree. Typing the engine against this interface (rather than the concrete classes) lets Element, Group, and the engine live in separate modules without import cycles.
RadialGradient	A parsed radial gradient with shape, position, color stops, and optional repeating flag.
RectState	State interface for a rectangle element, defining position, dimensions, and optional border radius.
RenderElement	Minimal interface for any element that can be rendered and hit-tested by a context.
RenderElementIntersectionOptions	Options for render element intersection testing.
RendererDebugOptions	Options for enabling debug overlays on the renderer.
RendererEventMap	Event map for the renderer, with start, stop, and per-frame tick events.
RendererOptions	Configuration for the renderer, controlling auto-start/stop behaviour and debug overlays.
RendererTransition	Internal representation of an active transition managed by the renderer.
RendererTransitionOptions	Options for scheduling a transition on one or more elements via the renderer.
RenderInstruction	A single entry in a Scene's flat render instruction stream. push/pop bracket a group so its transform and any group-scoped clip apply to the leaves drawn between them; draw renders a leaf element. Groups are contiguous (stacking-context ordering), so each group contributes exactly one push/pop pair.
Scale	A callable scale with domain, range, inverse mapping, tick generation, and inclusion testing.
ScaleBindingOptions	Low-level options for constructing a scale, providing conversion, inversion, inclusion, and tick generation callbacks.
SceneOptions	Options for constructing a scene, extending group options with an optional auto-render-on-resize flag.
StringInterpolatorTag	A tagged template result capturing the static fragments and dynamic numeric arguments.
TextState	State interface for a text element, defining position, content, and optional path-based text layout.
TransformTarget	The subset of Context transform operations required to apply an element's transform. Implemented by every Context, and by the internal matrix accumulator used to reconstruct an element's world transform for hit testing.
TransitionOptions	Configuration for a transition animation.

Type Aliases

Type Alias	Description
BandScaleOptions	Options for a band scale, controlling padding between and around bands, alignment, and rounding.
BaseElementState	Base state interface for all elements. All visual properties are optional at the element level.
BorderRadius	Four-corner border radius represented as [topLeft, topRight, bottomRight, bottomLeft].
ColorHSL	An HSL color represented as a three-element tuple.
ColorHSLA	An HSLA color represented as a four-element tuple.
ColorHSV	An HSV color represented as a three-element tuple.
ColorHSVA	An HSVA color represented as a four-element tuple.
ColorInterpolator	A function mapping a normalised position (0–1) to a CSS colour string.
ColorInterpolatorInput	Either a ready-made colour interpolator or an array of colour stops to interpolate between.
ColorRGBA	An RGBA color represented as a four-element tuple of channel values.
ColorSpace	Supported color space identifiers.
Direction	Text direction for the rendering context.
Ease	An easing function that maps a linear progress value (0–1) to an eased output value.
ElementInterpolationKeyFrame	A single keyframe in a multi-step interpolation, with an optional offset (0–1) and a target value.
ElementInterpolationState	Partial state where each property can be a target value, keyframe array, or interpolator function.
ElementInterpolationStateValue	An interpolation target: a direct value, an array of keyframes, or a custom interpolator function.
ElementInterpolators	A map of interpolator factories keyed by state property, used to override default interpolation behaviour.
ElementIntersectionOptions	Options for element intersection (hit) testing.
ElementOptions	Options for constructing an element, combining an optional id, CSS classes, data, pointer events, and initial state.
ElementPointerEvents	Controls which pointer events an element responds to during hit testing.
ElementValidationType	Severity level of an element validation result.
EventHandler	A callable event handler function with optional subscription options.
EventMap	Base event map interface; all custom event maps should extend this.
EventOptions	Options for emitting an event, controlling bubbling and attached data.
EventSubscriptionOptions	Options for subscribing to an event, such as filtering to self-targeted events only.
FillRule	Fill rule algorithm used to determine if a point is inside a path.
FontKerning	Font kerning mode for the rendering context.
Gradient	Union of all supported gradient types.
GradientType	The discriminant string identifying a gradient's kind ('linear', 'radial', or 'conic').
Interpolator	A function that interpolates between two values based on a normalised position (0–1).
InterpolatorFactory	A factory that creates an interpolator between two values of the same type, with a test predicate for type matching.
LineCap	Line cap style for stroke endpoints.
LineJoin	Line join style for stroke corners.
Matrix	A 2D affine transformation matrix stored as the six significant values of the augmented 3×3 matrix, in the same [a, b, c, d, e, f] order used by the Canvas 2D API (setTransform) and CSS matrix():
MeasureTextOptions	Options for measuring text dimensions.
NavigatorInteractionOption	Enable/disable a single interaction, optionally with a sensitivity multiplier.
PathPoint	A sampled point on an SVG path with position and tangent angle.
PathRenderer	A callback that draws custom geometry onto a ContextPath using the element's state.
Point	A 2D point represented as an [x, y] tuple.
PolylineRenderer	Built-in polyline curve interpolation algorithm names.
PolylineRenderFunc	A function that renders a polyline curve onto a path from an array of points.
PredicatedFunction	A callable with a test method used to determine whether the factory can handle a given value.
RenderElementPointerEvents	Controls which pointer events a render element responds to during hit testing.
RendererTransitionDirection	Alias for the transition playback direction within the renderer.
RendererTransitionOptionsArg	Transition options can be a static object or a per-element factory function.
RenderInstructionType	The kind of a RenderInstruction: enter a group boundary, draw a leaf, or exit a group boundary.
Rotation	Rotation value — a numeric radian value or a string with deg/rad suffix.
ScaleMethod	A function that maps a value from one space to another.
SceneEventMap	Event map for the scene. Resize is deliberately not re-emitted here — listen for it on the scene's context instead (scene.context.on('resize', …)), the single source of truth.
Shape2DOptions	Options for a 2D shape, adding automatic fill/stroke and clipping controls.
StringInterpolationFormatter	Optional formatter applied to each interpolated numeric value before insertion into the output string.
StringInterpolationSet	A pair of tagged template results representing the start and end states for string interpolation.
TaskAbortCallback	Callback invoked when a task is aborted, receiving the abort reason.
TaskExecutor	Executor function for a task, providing resolve, reject, abort registration, and the underlying AbortController.
TaskReject	Callback to reject a task with an optional reason.
TaskResolve	Callback to resolve a task with a value or promise.
TextAlignment	Horizontal text alignment relative to the drawing position.
TextBaseline	Vertical text baseline used when rendering text.
TextOptions	Options for creating a text element within the context.
TransformOrigin	Transform origin value — a numeric pixel offset or a percentage string.
TransitionCallback	Callback invoked on each animation frame with the current eased time value (0–1).
TransitionDirection	The playback direction of a transition.
TransitionLoopMode	Controls whether a transition loops: true restarts from the beginning, 'alternate' ping-pongs direction each iteration.

Variables

Variable	Description
COLOR_SCHEME_BRBG	Diverging — brown → white → teal (ColorBrewer BrBG).
COLOR_SCHEME_CIVIDIS	Sequential — dark blue → slate → tan → yellow. Colour-vision-deficiency friendly.
COLOR_SCHEME_INFERNO	Sequential — black → purple → red → orange → pale yellow.
COLOR_SCHEME_MAGMA	Sequential — black → purple → magenta → orange → cream.
COLOR_SCHEME_PLASMA	Sequential — dark blue → purple → magenta → orange → yellow.
COLOR_SCHEME_RDBU	Diverging — red → white → blue (ColorBrewer RdBu).
COLOR_SCHEME_TURBO	Sequential rainbow — purple → blue → cyan → green → yellow → orange → red. High contrast.
COLOR_SCHEME_VIRIDIS	Sequential — dark purple → blue → teal → green → yellow. The default perceptual scheme.
CONTEXT_OPERATIONS	Maps element state properties to their corresponding context setter functions.
easeInCubic	Cubic ease-in — accelerates from zero velocity.
easeInOutCubic	Cubic ease-in-out — accelerates then decelerates.
easeInOutQuad	Quadratic ease-in-out — accelerates then decelerates.
easeInOutQuart	Quartic ease-in-out — accelerates then decelerates.
easeInOutQuint	Quintic ease-in-out — accelerates then decelerates.
easeInQuad	Quadratic ease-in — accelerates from zero velocity.
easeInQuart	Quartic ease-in — accelerates from zero velocity.
easeInQuint	Quintic ease-in — accelerates from zero velocity.
easeLinear	Linear easing — no acceleration or deceleration.
easeOutBack	Back ease-out — overshoots slightly past the target and settles back (a subtle spring).
easeOutCubic	Cubic ease-out — decelerates to zero velocity.
easeOutElastic	Elastic ease-out — springs past the target and oscillates with decaying amplitude before settling.
easeOutQuad	Quadratic ease-out — decelerates to zero velocity.
easeOutQuart	Quartic ease-out — decelerates to zero velocity.
easeOutQuint	Quintic ease-out — decelerates to zero velocity.
factory	Global platform factory instance. Call factory.set(...) to provide environment-specific implementations.
interpolateAny	Fallback interpolator factory that snaps from the first value to the second at the halfway point.
interpolateBorderRadius	Interpolator factory that transitions between two border-radius values (single number or four-corner tuple).
interpolateColor	Interpolator factory that smoothly transitions between two CSS color strings by interpolating their RGBA channels.
interpolateDate	Interpolator factory that interpolates between two Date instances by lerping their timestamps.
interpolateGradient	Interpolator factory that transitions between two CSS gradient strings by interpolating their stops, angles, and positions.
interpolateImage	Interpolator factory that cross-fades between two image sources using an offscreen canvas.
interpolateNumber	Interpolator factory that linearly interpolates between two numbers.
interpolatePoints	Interpolator factory that transitions between two point arrays. By default it extrapolates additional points where set lengths differ; pass resolveKeys to match points by identity instead (preserving curved renderers across add/remove).
interpolateRotation	Interpolator factory that transitions between two rotation values (numbers in radians or strings like "90deg").
interpolateTransformOrigin	Interpolator factory that transitions between two transform-origin values (numbers or percentage strings).
scaleRGB	A continuous scale mapping normalised values (0–1) to the RGB channel range (0–255) with clamping.
TAU	Full circle in radians (2π).
TRACKED_EVENTS	DOM event types that are tracked and forwarded to elements for hit testing and interaction.
TRANSFORM_DEFAULTS	Default numeric values for transform properties (translate, scale, rotation, transform-origin).
TRANSFORM_INTERPOLATORS	Interpolator factories for transform-related properties that require special interpolation (rotation, transform-origin).

Functions

Function	Description
applyElementTransform	Applies an element's transform (translate, rotate, scale about its transform-origin) to the given target. Used both to drive a Context's transform during rendering and, via a matrix accumulator, to reconstruct an element's world transform for hit testing.
arePointsEqual	Tests whether two points have identical coordinates.
clamp	Constrains a value to the inclusive range between lower and upper bounds.
closest	Returns the closest ancestor (including the element itself) matching a CSS-like selector, or undefined.
computeTransitionTime	Computes the eased time value for a transition given elapsed time, duration, easing function, and direction.
createArc	Factory function that creates a new Arc instance.
createCircle	Factory function that creates a new Circle instance.
createElement	Factory function that creates a new Element instance.
createEllipse	Factory function that creates a new Ellipse instance.
createFrameBuffer	Creates a debounced requestAnimationFrame wrapper that cancels any pending frame before scheduling a new one.
createGroup	Factory function that creates a new Group instance.
createImage	Factory function that creates a new ImageElement instance.
createLine	Factory function that creates a new Line instance.
createNumericIncludesMethod	Creates an includes predicate that tests whether a value falls within the numeric domain.
createPath	Factory function that creates a new Path instance.
createPolygon	Factory function that creates a new Polygon instance.
createPolyline	Factory function that creates a new Polyline instance.
createRect	Factory function that creates a new Rect instance.
createRenderer	Factory function that creates a new Renderer bound to the given scene.
createScale	Assembles a Scale object from explicit conversion, inversion, and tick functions.
createScene	Factory function that creates a new Scene instance from a context, selector, or element.
createShape	Factory function that creates a new Shape2D instance.
createText	Factory function that creates a new Text instance.
degreesToRadians	Converts degrees to radians.
elementIsArc	Type guard that checks whether a value is an Arc instance.
elementIsCircle	Type guard that checks whether a value is a Circle instance.
elementIsEllipse	Type guard that checks whether a value is an Ellipse instance.
elementIsImage	Type guard that checks whether a value is an ImageElement instance.
elementIsLine	Type guard that checks whether a value is a Line instance.
elementIsPath	Type guard that checks whether a value is a Path instance.
elementIsPolygon	Type guard that checks whether a value is a Polygon instance.
elementIsPolyline	Type guard that checks whether a value is a Polyline instance.
elementIsRect	Type guard that checks whether a value is a Rect instance.
elementIsShape	Type guard that checks whether a value is a Shape instance.
elementIsText	Type guard that checks whether a value is a Text instance.
fractional	Returns the fractional part of a number (e.g. fractional(3.7) → 0.7).
getColorParser	Finds the first color parser whose pattern matches the given color string.
getContainingBox	Computes the smallest axis-aligned bounding box that contains all boxes extracted from the array.
getEuclideanDistance	Computes the Euclidean distance from two points.
getExtent	Computes the [min, max] extent of an array using the given numeric accessor.
getLinearScaleMethod	Creates a linear mapping function from a numeric domain to a numeric range, with optional clamping and tick-padding.
getLinearTicks	Generates an array of evenly spaced, "nice" tick values across the domain.
getMidpoint	Returns the midpoint between two points.
getPathLength	Computes the total length of an SVG path from its d attribute string.
getPolygonPoints	Generates the vertex points of a regular polygon centred at (cx, cy) with the given radius and number of sides.
getThetaPoint	Returns the point at a given angle and distance from an optional centre.
getTimeTicks	Generates calendar-aligned tick dates spanning [min, max] at roughly count ticks.
getTotal	Sums all numeric values extracted from an array via the accessor.
getWaypoint	Returns a point along the line segment between two points at the given normalised position (0–1).
getWorldTransform	Reconstructs an element's world transform — the composition of its own transform and every ancestor group's transform, from the root down — for use in hit testing against backends (such as canvas) that do not natively account for element transforms.
hslToRGBA	Converts HSLA values to an RGBA tuple.
hsvToRGBA	Converts HSVA values to an RGBA tuple.
interpolateCirclePoint	Creates an interpolator that traces a point around a circle of the given centre and radius.
interpolateColors	Builds a colour interpolator from an array of colour stops. Position 0 returns the first stop, 1 the last, and intermediate positions interpolate (RGBA, channel-wise) between adjacent stops.
interpolatePath	Creates an interpolator that progressively reveals a path from start to end as position advances from 0 to 1.
interpolatePolygonPoint	Creates an interpolator that traces a point around the vertices of a regular polygon.
interpolateString	Creates a string interpolator by interpolating between numeric values embedded in tagged template literals.
interpolateWaypoint	Creates an interpolator that returns the point along a polyline at the given normalised position.
isGradientString	Tests whether a string looks like a CSS gradient (starts with a recognised gradient function name).
isGroup	Type guard that checks whether a value is a Group instance.
isPointInBox	Tests whether a point lies within the given bounding box (inclusive).
matches	Tests whether an element matches a CSS-like selector.
matrixApplyToPoint	Applies matrix to the point [x, y], returning the transformed point.
matrixIdentity	Returns the identity matrix (a no-op transform).
matrixInvert	Returns the inverse of matrix, or null when it is singular (zero determinant) and therefore not invertible.
matrixIsIdentity	Tests whether matrix is the identity transform (within an exact comparison).
matrixMultiply	Post-multiplies a by b, returning the composite a · b. Applying the result to a point is equivalent to applying b first and then a, matching how successive translate/rotate/scale calls accumulate onto a canvas transform matrix.
matrixRotate	Returns a rotation matrix for the given angle, in radians.
matrixScale	Returns a scaling matrix with the given horizontal and vertical factors.
matrixTranslate	Returns a translation matrix that moves points by (x, y).
max	Returns the maximum of the provided numbers.
maxOf	Returns the maximum numeric value extracted from an array via the accessor.
measureText	Measures the dimensions of a text string using an optional font and context override.
min	Returns the minimum of the provided numbers.
minOf	Returns the minimum numeric value extracted from an array via the accessor.
niceDomain	Returns the domain expanded to round, tick-aligned [min, max] boundaries.
normaliseBorderRadius	Normalises a border radius value into a four-corner tuple, expanding a single number to all corners.
padDomain	Expands a numeric domain to "nice" tick-aligned boundaries and returns [min, max, step].
parseColor	Parses any supported color string into an RGBA tuple, or returns undefined if no parser matches.
parseGradient	Parses a CSS gradient string (linear, radial, or conic) into a structured Gradient object, or returns undefined if the string is not a recognised gradient.
parseHEX	Parses a hexadecimal color string (e.g. #ff0000 or #ff000080) into an RGBA tuple.
parseHSL	Parses an hsl() color string into an RGBA tuple.
parseHSLA	Parses an hsla() color string into an RGBA tuple.
parseHSV	Parses an hsv() color string into an RGBA tuple.
parseHSVA	Parses an hsva() color string into an RGBA tuple.
parseRGB	Parses an rgb() color string into an RGBA tuple with alpha set to 1.
parseRGBA	Parses an rgba() color string into an RGBA tuple.
polylineBasisRenderer	Creates a cubic B-spline polyline renderer.
polylineBumpXRenderer	Creates a bump-X polyline renderer using horizontal midpoint bezier curves.
polylineBumpYRenderer	Creates a bump-Y polyline renderer using vertical midpoint bezier curves.
polylineCardinalRenderer	Creates a cardinal spline polyline renderer with configurable tension.
polylineCatmullRomRenderer	Creates a Catmull-Rom spline polyline renderer with configurable alpha.
polylineLinearRenderer	Creates a linear (straight segment) polyline renderer.
polylineMonotoneXRenderer	Creates a monotone-X polyline renderer preserving monotonicity along the x-axis.
polylineMonotoneYRenderer	Creates a monotone-Y polyline renderer preserving monotonicity along the y-axis.
polylineNaturalRenderer	Creates a natural cubic spline polyline renderer with second-derivative continuity.
polylineSplineRenderer	Creates a spline polyline renderer with configurable tension.
polylineStepAfterRenderer	Creates a step-after polyline renderer where the vertical transition occurs at the end of each segment.
polylineStepBeforeRenderer	Creates a step-before polyline renderer where the vertical transition occurs at the start of each segment.
polylineStepRenderer	Creates a step polyline renderer with midpoint horizontal transitions.
query	Returns the first element matching a CSS-like selector, or undefined if none match.
queryAll	Queries all elements matching a CSS-like selector across the given element(s) and their descendants.
radiansToDegrees	Converts radians to degrees.
rescaleDomain	Rescales a scale's domain to the window currently visible under a navigator transform. The scale maps data → the given pixel range; inverting the transformed range endpoints back through the scale yields the zoomed/panned data domain. This is how a cartesian chart turns navigator gestures into axis rescaling (scale.inverse) without transforming the rendered geometry.
resolveNiceCount	Resolves a nice option to a target tick count (defaults to 10 when true).
resolvePolylineRenderer	Resolves a named curve algorithm (or a custom render function) to its render function. Defaults to linear.
resolveRotation	Resolves a rotation value (number, degrees string, or radians string) to radians.
resolveTransformOrigin	Resolves a transform-origin value (number or percentage string) to a pixel offset relative to the given dimension.
rgbaToHSL	Converts RGBA channel values to an HSLA tuple.
rgbaToHSV	Converts RGBA channel values to an HSVA tuple.
rgbChannelToHEX	Converts a single RGB channel value (0–255) to a two-character hexadecimal string.
samplePathPoint	Samples a point and tangent angle at the given distance along an SVG path.
scaleBand	Creates a band scale that maps discrete domain values to evenly spaced bands within the range.
scaleContinuous	Creates a continuous linear scale that maps a numeric domain to a numeric range.
scaleDiscrete	Creates a discrete (ordinal) scale that maps domain values to corresponding range values by index.
scaleDiverging	Creates a diverging scale that maps values below and above a midpoint to separate sub-ranges.
scaleLog	Shortcut for a base-10 logarithmic scale.
scaleLogarithmic	Creates a logarithmic scale that maps a numeric domain to a range using a log transformation.
scaleOrdinal	Creates an ordinal scale mapping each distinct domain value to a value from range, cycling when there are more domain values than range values. Unknown values encountered later are assigned the next range slot (so a chart can colour series without pre-declaring every category). Unlike the numeric scales this maps value → value of any type — its most common use is categorical colour.
scalePoint	Creates a point scale that maps discrete domain values to evenly spaced positions across the range (the categorical analogue of a continuous axis — points, not bands). With zero padding the first and last values sit exactly on the range endpoints. inverse returns the nearest domain value.
scalePower	Creates a power scale that maps a numeric domain to a range using an exponential transformation.
scaleQuantile	Creates a quantile scale that divides a sorted numeric domain into quantiles mapped to discrete range values.
scaleQuantize	Creates a quantize scale that divides a continuous numeric domain into uniform segments mapped to discrete range values.
scaleSequential	Creates a colour scale mapping a numeric domain through a colour interpolator (or array of stops, e.g. one of the built-in COLOR_SCHEME_* palettes). Values are clamped to the domain.
scaleSqrt	Shortcut for a power scale with exponent 0.5 (square root).
scaleThreshold	Creates a threshold scale that maps numeric values to range values based on a set of threshold breakpoints.
scaleTime	Creates a time scale that maps a Date domain to a numeric range using linear interpolation of timestamps.
serialiseGradient	Serialises a structured Gradient object back into a CSS gradient string.
serialiseHEX	Serialises RGBA channel values into a hexadecimal color string (e.g. #ff0000).
serialiseHSL	Serialises RGBA channel values into an hsl() color string.
serialiseHSLA	Serialises RGBA channel values into an hsla() color string.
serialiseHSV	Serialises RGBA channel values into an hsv() color string.
serialiseHSVA	Serialises RGBA channel values into an hsva() color string.
serialiseRGB	Serialises RGBA channel values into an rgb() color string.
serialiseRGBA	Serialises RGBA channel values into an rgba() color string.
setColorAlpha	Returns a new color string with the alpha channel replaced by the given value.
transformBox	Transforms a box by an affine matrix and returns the axis-aligned bounding box of the result. Returns the box unchanged when matrix is null (the identity case). Because it re-fits an AABB around the transformed corners, a rotated box yields a conservative (enlarged) bounding box.
transition	Creates and starts a frame-driven transition that invokes the callback with the eased time on each animation frame.
typeIsContext	Type guard that checks whether a value is a Context instance.
typeIsElement	Type guard that checks whether a value is an Element instance.
typeIsPoint	Type guard that checks whether a value is a Point (a two-element array).