code:
export default class BubbleController extends DatasetController {
    static id: string;
    /**
     * @type {any}
     */
    static overrides: any;
    /**
       * Parse array of primitive values
       * @protected
       */
    protected parsePrimitiveData(meta: any, data: any, start: any, count: any): any;
    /**
       * Parse array of arrays
       * @protected
       */
    protected parseArrayData(meta: any, data: any, start: any, count: any): any;
    /**
       * Parse array of objects
       * @protected
       */
    protected parseObjectData(meta: any, data: any, start: any, count: any): any;
    /**
       * @protected
       */
    protected getMaxOverflow(): number;
    /**
       * @protected
       */
    protected getLabelAndValue(index: any): {
        label: any;
        value: string;
    };
    update(mode: any): void;
}
import DatasetController from "../core/core.datasetController.js";


code:
export default class DoughnutController extends DatasetController {
    static id: string;
    static descriptors: {
        _scriptable: (name: any) => boolean;
        _indexable: (name: any) => boolean;
    };
    /**
     * @type {any}
     */
    static overrides: any;
    constructor(chart: any, datasetIndex: any);
    innerRadius: number;
    outerRadius: number;
    offsetX: number;
    offsetY: number;
    /**
       * Override data parsing, since we are not using scales
       */
    parse(start: any, count: any): void;
    /**
       * @private
       */
    private _getRotation;
    /**
       * @private
       */
    private _getCircumference;
    /**
       * Get the maximal rotation & circumference extents
       * across all visible datasets.
       */
    _getRotationExtents(): {
        rotation: number;
        circumference: number;
    };
    /**
     * @private
     */
    private _circumference;
    calculateTotal(): number;
    calculateCircumference(value: any): number;
    getLabelAndValue(index: any): {
        label: any;
        value: string;
    };
    getMaxBorderWidth(arcs: any): number;
    getMaxOffset(arcs: any): number;
    /**
       * Get radius length offset of the dataset in relation to the visible datasets weights. This allows determining the inner and outer radius correctly
       * @private
       */
    private _getRingWeightOffset;
    /**
       * @private
       */
    private _getRingWeight;
    /**
       * Returns the sum of all visible data set weights.
       * @private
       */
    private _getVisibleDatasetWeightTotal;
}
export type Chart = import('../core/core.controller.js').default;
import DatasetController from "../core/core.datasetController.js";

license: mit


code:
export default class LineController extends DatasetController {
    static id: string;
    /**
     * @type {any}
     */
    static overrides: any;
    update(mode: any): void;
    /**
       * @protected
       */
    protected getMaxOverflow(): any;
}
import DatasetController from "../core/core.datasetController.js";


code:
export default class PieController extends DoughnutController {
}
import DoughnutController from "./controller.doughnut.js";


code:
export default class PolarAreaController extends DatasetController {
    static id: string;
    /**
     * @type {any}
     */
    static overrides: any;
    constructor(chart: any, datasetIndex: any);
    innerRadius: number;
    outerRadius: number;
    getLabelAndValue(index: any): {
        label: any;
        value: string;
    };
    parseObjectData(meta: any, data: any, start: any, count: any): {
        r: unknown;
    }[];
    update(mode: any): void;
    /**
     * @protected
     */
    protected getMinMax(): {
        min: number;
        max: number;
    };
    /**
       * @private
       */
    private _updateRadius;
    countVisibleElements(): number;
    /**
       * @private
       */
    private _computeAngle;
}
import DatasetController from "../core/core.datasetController.js";


code:
export default class RadarController extends DatasetController {
    static id: string;
    /**
     * @type {any}
     */
    static overrides: any;
    /**
       * @protected
       */
    protected getLabelAndValue(index: any): {
        label: any;
        value: string;
    };
    parseObjectData(meta: any, data: any, start: any, count: any): {
        r: unknown;
    }[];
    update(mode: any): void;
}
import DatasetController from "../core/core.datasetController.js";


code:
export default class ScatterController extends DatasetController {
    static id: string;
    /**
     * @type {any}
     */
    static overrides: any;
    /**
       * @protected
       */
    protected getLabelAndValue(index: any): {
        label: any;
        value: string;
    };
    update(mode: any): void;
    /**
       * @protected
       */
    protected getMaxOverflow(): any;
}
import DatasetController from "../core/core.datasetController.js";


code:
export { default as BarController } from "./controller.bar.js";
export { default as BubbleController } from "./controller.bubble.js";
export { default as DoughnutController } from "./controller.doughnut.js";
export { default as LineController } from "./controller.line.js";
export { default as PolarAreaController } from "./controller.polarArea.js";
export { default as PieController } from "./controller.pie.js";
export { default as RadarController } from "./controller.radar.js";
export { default as ScatterController } from "./controller.scatter.js";


code:
/**
 * @namespace Chart._adapters
 * @since 2.8.0
 * @private
 */
import type { AnyObject } from '../types/basic.js';
import type { ChartOptions } from '../types/index.js';
export type TimeUnit = 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
export interface DateAdapter<T extends AnyObject = AnyObject> {
    readonly options: T;
    /**
     * Will called with chart options after adapter creation.
     */
    init(this: DateAdapter<T>, chartOptions: ChartOptions): void;
    /**
     * Returns a map of time formats for the supported formatting units defined
     * in Unit as well as 'datetime' representing a detailed date/time string.
     */
    formats(this: DateAdapter<T>): Record<string, string>;
    /**
     * Parses the given `value` and return the associated timestamp.
     * @param value - the value to parse (usually comes from the data)
     * @param [format] - the expected data format
     */
    parse(this: DateAdapter<T>, value: unknown, format?: TimeUnit): number | null;
    /**
     * Returns the formatted date in the specified `format` for a given `timestamp`.
     * @param timestamp - the timestamp to format
     * @param format - the date/time token
     */
    format(this: DateAdapter<T>, timestamp: number, format: TimeUnit): string;
    /**
     * Adds the specified `amount` of `unit` to the given `timestamp`.
     * @param timestamp - the input timestamp
     * @param amount - the amount to add
     * @param unit - the unit as string
     */
    add(this: DateAdapter<T>, timestamp: number, amount: number, unit: TimeUnit): number;
    /**
     * Returns the number of `unit` between the given timestamps.
     * @param a - the input timestamp (reference)
     * @param b - the timestamp to subtract
     * @param unit - the unit as string
     */
    diff(this: DateAdapter<T>, a: number, b: number, unit: TimeUnit): number;
    /**
     * Returns start of `unit` for the given `timestamp`.
     * @param timestamp - the input timestamp
     * @param unit - the unit as string
     * @param [weekday] - the ISO day of the week with 1 being Monday
     * and 7 being Sunday (only needed if param *unit* is `isoWeek`).
     */
    startOf(this: DateAdapter<T>, timestamp: number, unit: TimeUnit | 'isoWeek', weekday?: number): number;
    /**
     * Returns end of `unit` for the given `timestamp`.
     * @param timestamp - the input timestamp
     * @param unit - the unit as string
     */
    endOf(this: DateAdapter<T>, timestamp: number, unit: TimeUnit | 'isoWeek'): number;
}
/**
 * Date adapter (current used by the time scale)
 * @namespace Chart._adapters._date
 * @memberof Chart._adapters
 * @private
 */
declare class DateAdapterBase implements DateAdapter {
    /**
     * Override default date adapter methods.
     * Accepts type parameter to define options type.
     * @example
     * Chart._adapters._date.override<{myAdapterOption: string}>({
     *   init() {
     *     console.log(this.options.myAdapterOption);
     *   }
     * })
     */
    static override<T extends AnyObject = AnyObject>(members: Partial<Omit<DateAdapter<T>, 'options'>>): void;
    readonly options: AnyObject;
    constructor(options: AnyObject);
    init(): void;
    formats(): Record<string, string>;
    parse(): number | null;
    format(): string;
    add(): number;
    diff(): number;
    startOf(): number;
    endOf(): number;
}
declare const _default: {
    _date: typeof DateAdapterBase;
};
export default _default;


code:
export default class Animation {
    constructor(cfg: any, target: any, prop: any, to: any);
    _active: boolean;
    _fn: any;
    _easing: any;
    _start: number;
    _duration: number;
    _total: number;
    _loop: boolean;
    _target: any;
    _prop: any;
    _from: unknown;
    _to: any;
    _promises: any[];
    active(): boolean;
    update(cfg: any, to: any, date: any): void;
    cancel(): void;
    tick(date: any): void;
    wait(): Promise<any>;
    _notify(resolved: any): void;
}


code:
export default class Animations {
    constructor(chart: any, config: any);
    _chart: any;
    _properties: Map<any, any>;
    configure(config: any): void;
    /**
       * Utility to handle animation of `options`.
       * @private
       */
    private _animateOptions;
    /**
       * @private
       */
    private _createAnimations;
    /**
       * Update `target` properties to new values, using configured animations
       * @param {object} target - object to update
       * @param {object} values - new target properties
       * @returns {boolean|undefined} - `true` if animations were started
       **/
    update(target: object, values: object): boolean | undefined;
}


code: export function applyAnimationsDefaults(defaults: any): void;


code:
/**
 * @typedef { import('./core.animation.js').default } Animation
 * @typedef { import('./core.controller.js').default } Chart
 */
/**
 * Please use the module's default export which provides a singleton instance
 * Note: class is export for typedoc
 */
export class Animator {
    _request: any;
    _charts: Map<any, any>;
    _running: boolean;
    _lastDate: number;
    /**
       * @private
       */
    private _notify;
    /**
       * @private
       */
    private _refresh;
    /**
       * @private
       */
    private _update;
    /**
       * @private
       */
    private _getAnims;
    /**
       * @param {Chart} chart
       * @param {string} event - event name
       * @param {Function} cb - callback
       */
    listen(chart: Chart, event: string, cb: Function): void;
    /**
       * Add animations
       * @param {Chart} chart
       * @param {Animation[]} items - animations
       */
    add(chart: Chart, items: Animation[]): void;
    /**
       * Counts number of active animations for the chart
       * @param {Chart} chart
       */
    has(chart: Chart): boolean;
    /**
       * Start animating (all charts)
       * @param {Chart} chart
       */
    start(chart: Chart): void;
    running(chart: any): boolean;
    /**
       * Stop all animations for the chart
       * @param {Chart} chart
       */
    stop(chart: Chart): void;
    /**
       * Remove chart from Animator
       * @param {Chart} chart
       */
    remove(chart: Chart): boolean;
}
declare const _default: Animator;
export default _default;
export type Animation = import('./core.animation.js').default;
export type Chart = import('./core.controller.js').default;


code:
export function getIndexAxis(type: any, options: any): any;
export function determineAxis(id: any, ...scaleOptions: any[]): any;
export default class Config {
    constructor(config: any);
    _config: any;
    _scopeCache: Map<any, any>;
    _resolverCache: Map<any, any>;
    get platform(): any;
    set type(arg: any);
    get type(): any;
    set data(arg: any);
    get data(): any;
    set options(arg: any);
    get options(): any;
    get plugins(): any;
    update(): void;
    clearCache(): void;
    /**
     * Returns the option scope keys for resolving dataset options.
     * These keys do not include the dataset itself, because it is not under options.
     * @param {string} datasetType
     * @return {string[][]}
     */
    datasetScopeKeys(datasetType: string): string[][];
    /**
     * Returns the option scope keys for resolving dataset animation options.
     * These keys do not include the dataset itself, because it is not under options.
     * @param {string} datasetType
     * @param {string} transition
     * @return {string[][]}
     */
    datasetAnimationScopeKeys(datasetType: string, transition: string): string[][];
    /**
     * Returns the options scope keys for resolving element options that belong
     * to an dataset. These keys do not include the dataset itself, because it
     * is not under options.
     * @param {string} datasetType
     * @param {string} elementType
     * @return {string[][]}
     */
    datasetElementScopeKeys(datasetType: string, elementType: string): string[][];
    /**
     * Returns the options scope keys for resolving plugin options.
     * @param {{id: string, additionalOptionScopes?: string[]}} plugin
     * @return {string[][]}
     */
    pluginScopeKeys(plugin: {
        id: string;
        additionalOptionScopes?: string[];
    }): string[][];
    /**
     * @private
     */
    private _cachedScopes;
    /**
     * Resolves the objects from options and defaults for option value resolution.
     * @param {object} mainScope - The main scope object for options
     * @param {string[][]} keyLists - The arrays of keys in resolution order
     * @param {boolean} [resetCache] - reset the cache for this mainScope
     */
    getOptionScopes(mainScope: object, keyLists: string[][], resetCache?: boolean): any;
    /**
     * Returns the option scopes for resolving chart options
     * @return {object[]}
     */
    chartOptionScopes(): object[];
    /**
     * @param {object[]} scopes
     * @param {string[]} names
     * @param {function|object} context
     * @param {string[]} [prefixes]
     * @return {object}
     */
    resolveNamedOptions(scopes: object[], names: string[], context: Function | object, prefixes?: string[]): object;
    /**
     * @param {object[]} scopes
     * @param {object} [context]
     * @param {string[]} [prefixes]
     * @param {{scriptable: boolean, indexable: boolean, allKeys?: boolean}} [descriptorDefaults]
     */
    createResolver(scopes: object[], context?: object, prefixes?: string[], descriptorDefaults?: {
        scriptable: boolean;
        indexable: boolean;
        allKeys?: boolean;
    }): any;
}


code:
export default Chart;
export type ChartEvent = import('../types/index.js').ChartEvent;
export type Point = import('../types/index.js').Point;
declare class Chart {
    static defaults: import("./core.defaults.js").Defaults;
    static instances: {};
    static overrides: any;
    static registry: import("./core.registry.js").Registry;
    static version: string;
    static getChart: (key: any) => any;
    static register(...items: any[]): void;
    static unregister(...items: any[]): void;
    constructor(item: any, userConfig: any);
    config: Config;
    platform: any;
    id: number;
    ctx: any;
    canvas: any;
    width: any;
    height: any;
    _options: any;
    _aspectRatio: any;
    _layers: any[];
    _metasets: any[];
    _stacks: any;
    boxes: any[];
    currentDevicePixelRatio: any;
    chartArea: any;
    _active: any[];
    _lastEvent: import("../types/index.js").ChartEvent;
    _listeners: {};
    /** @type {?{attach?: function, detach?: function, resize?: function}} */
    _responsiveListeners: {
        attach?: Function;
        detach?: Function;
        resize?: Function;
    };
    _sortedMetasets: any[];
    scales: {};
    _plugins: PluginService;
    $proxies: {};
    _hiddenIndices: {};
    attached: boolean;
    _animationsDisabled: boolean;
    $context: {
        chart: Chart;
        type: string;
    };
    _doResize: (mode?: any) => number;
    _dataChanges: any[];
    get aspectRatio(): any;
    set data(arg: any);
    get data(): any;
    set options(arg: any);
    get options(): any;
    get registry(): import("./core.registry.js").Registry;
    /**
       * @private
       */
    private _initialize;
    clear(): Chart;
    stop(): Chart;
    /**
       * Resize the chart to its container or to explicit dimensions.
       * @param {number} [width]
       * @param {number} [height]
       */
    resize(width?: number, height?: number): void;
    _resizeBeforeDraw: {
        width: number;
        height: number;
    };
    _resize(width: any, height: any): void;
    ensureScalesHaveIDs(): void;
    /**
       * Builds a map of scale ID to scale object for future lookup.
       */
    buildOrUpdateScales(): void;
    /**
       * @private
       */
    private _updateMetasets;
    /**
       * @private
       */
    private _removeUnreferencedMetasets;
    buildOrUpdateControllers(): any[];
    /**
       * Reset the elements of all datasets
       * @private
       */
    private _resetElements;
    /**
      * Resets the chart back to its state before the initial animation
      */
    reset(): void;
    update(mode: any): void;
    _minPadding: number;
    /**
     * @private
     */
    private _updateScales;
    /**
     * @private
     */
    private _checkEventBindings;
    /**
     * @private
     */
    private _updateHiddenIndices;
    /**
     * @private
     */
    private _getUniformDataChanges;
    /**
       * Updates the chart layout unless a plugin returns `false` to the `beforeLayout`
       * hook, in which case, plugins will not be called on `afterLayout`.
       * @private
       */
    private _updateLayout;
    /**
       * Updates all datasets unless a plugin returns `false` to the `beforeDatasetsUpdate`
       * hook, in which case, plugins will not be called on `afterDatasetsUpdate`.
       * @private
       */
    private _updateDatasets;
    /**
       * Updates dataset at index unless a plugin returns `false` to the `beforeDatasetUpdate`
       * hook, in which case, plugins will not be called on `afterDatasetUpdate`.
       * @private
       */
    private _updateDataset;
    render(): void;
    draw(): void;
    /**
       * @private
       */
    private _getSortedDatasetMetas;
    /**
       * Gets the visible dataset metas in drawing order
       * @return {object[]}
       */
    getSortedVisibleDatasetMetas(): object[];
    /**
       * Draws all datasets unless a plugin returns `false` to the `beforeDatasetsDraw`
       * hook, in which case, plugins will not be called on `afterDatasetsDraw`.
       * @private
       */
    private _drawDatasets;
    /**
       * Draws dataset at index unless a plugin returns `false` to the `beforeDatasetDraw`
       * hook, in which case, plugins will not be called on `afterDatasetDraw`.
       * @private
       */
    private _drawDataset;
    /**
     * Checks whether the given point is in the chart area.
     * @param {Point} point - in relative coordinates (see, e.g., getRelativePosition)
     * @returns {boolean}
     */
    isPointInArea(point: Point): boolean;
    getElementsAtEventForMode(e: any, mode: any, options: any, useFinalPosition: any): any;
    getDatasetMeta(datasetIndex: any): any;
    getContext(): {
        chart: Chart;
        type: string;
    };
    getVisibleDatasetCount(): number;
    isDatasetVisible(datasetIndex: any): boolean;
    setDatasetVisibility(datasetIndex: any, visible: any): void;
    toggleDataVisibility(index: any): void;
    getDataVisibility(index: any): boolean;
    /**
       * @private
       */
    private _updateVisibility;
    hide(datasetIndex: any, dataIndex: any): void;
    show(datasetIndex: any, dataIndex: any): void;
    /**
       * @private
       */
    private _destroyDatasetMeta;
    _stop(): void;
    destroy(): void;
    toBase64Image(...args: any[]): any;
    /**
       * @private
       */
    private bindEvents;
    /**
     * @private
     */
    private bindUserEvents;
    /**
     * @private
     */
    private bindResponsiveEvents;
    /**
       * @private
       */
    private unbindEvents;
    updateHoverStyle(items: any, mode: any, enabled: any): void;
    /**
       * Get active (hovered) elements
       * @returns array
       */
    getActiveElements(): any[];
    /**
       * Set active (hovered) elements
       * @param {array} activeElements New active data points
       */
    setActiveElements(activeElements: any[]): void;
    /**
       * Calls enabled plugins on the specified hook and with the given args.
       * This method immediately returns as soon as a plugin explicitly returns false. The
       * returned value can be used, for instance, to interrupt the current action.
       * @param {string} hook - The name of the plugin method to call (e.g. 'beforeUpdate').
       * @param {Object} [args] - Extra arguments to apply to the hook call.
     * @param {import('./core.plugins.js').filterCallback} [filter] - Filtering function for limiting which plugins are notified
       * @returns {boolean} false if any of the plugins return false, else returns true.
       */
    notifyPlugins(hook: string, args?: any, filter?: import('./core.plugins.js').filterCallback): boolean;
    /**
     * Check if a plugin with the specific ID is registered and enabled
     * @param {string} pluginId - The ID of the plugin of which to check if it is enabled
     * @returns {boolean}
     */
    isPluginEnabled(pluginId: string): boolean;
    /**
       * @private
       */
    private _updateHoverStyles;
    /**
       * @private
       */
    private _eventHandler;
    /**
       * Handle an event
       * @param {ChartEvent} e the event to handle
       * @param {boolean} [replay] - true if the event was replayed by `update`
     * @param {boolean} [inChartArea] - true if the event is inside chartArea
       * @return {boolean} true if the chart needs to re-render
       * @private
       */
    private _handleEvent;
    /**
     * @param {ChartEvent} e - The event
     * @param {import('../types/index.js').ActiveElement[]} lastActive - Previously active elements
     * @param {boolean} inChartArea - Is the event inside chartArea
     * @param {boolean} useFinalPosition - Should the evaluation be done with current or final (after animation) element positions
     * @returns {import('../types/index.js').ActiveElement[]} - The active elements
     * @pravate
     */
    _getActiveElements(e: ChartEvent, lastActive: import('../types/index.js').ActiveElement[], inChartArea: boolean, useFinalPosition: boolean): import('../types/index.js').ActiveElement[];
}
import Config from "./core.config.js";
import PluginService from "./core.plugins.js";


code:
export default class DatasetController {
    /**
     * @type {any}
     */
    static defaults: any;
    /**
     * Element type used to generate a meta dataset (e.g. Chart.element.LineElement).
     */
    static datasetElementType: any;
    /**
     * Element type used to generate a meta data (e.g. Chart.element.PointElement).
     */
    static dataElementType: any;
    /**
       * @param {Chart} chart
       * @param {number} datasetIndex
       */
    constructor(chart: Chart, datasetIndex: number);
    chart: import("./core.controller.js").default;
    _ctx: any;
    index: number;
    _cachedDataOpts: {};
    _cachedMeta: any;
    _type: any;
    options: any;
    /** @type {boolean | object} */
    _parsing: boolean | object;
    _data: any;
    _objectData: any;
    _sharedOptions: any;
    _drawStart: any;
    _drawCount: any;
    enableOptionSharing: boolean;
    supportsDecimation: boolean;
    $context: any;
    _syncList: any[];
    datasetElementType: any;
    dataElementType: any;
    initialize(): void;
    updateIndex(datasetIndex: any): void;
    linkScales(): void;
    getDataset(): any;
    getMeta(): any;
    /**
       * @param {string} scaleID
       * @return {Scale}
       */
    getScaleForId(scaleID: string): Scale;
    /**
       * @private
       */
    private _getOtherScale;
    reset(): void;
    /**
       * @private
       */
    private _destroy;
    /**
       * @private
       */
    private _dataCheck;
    addElements(): void;
    buildOrUpdateElements(resetNewElements: any): void;
    /**
       * Merges user-supplied and default dataset-level options
       * @private
       */
    private configure;
    /**
       * @param {number} start
       * @param {number} count
       */
    parse(start: number, count: number): void;
    /**
       * Parse array of primitive values
       * @param {object} meta - dataset meta
       * @param {array} data - data array. Example [1,3,4]
       * @param {number} start - start index
       * @param {number} count - number of items to parse
       * @returns {object} parsed item - item containing index and a parsed value
       * for each scale id.
       * Example: {xScale0: 0, yScale0: 1}
       * @protected
       */
    protected parsePrimitiveData(meta: object, data: any[], start: number, count: number): object;
    /**
       * Parse array of arrays
       * @param {object} meta - dataset meta
       * @param {array} data - data array. Example [[1,2],[3,4]]
       * @param {number} start - start index
       * @param {number} count - number of items to parse
       * @returns {object} parsed item - item containing index and a parsed value
       * for each scale id.
       * Example: {x: 0, y: 1}
       * @protected
       */
    protected parseArrayData(meta: object, data: any[], start: number, count: number): object;
    /**
       * Parse array of objects
       * @param {object} meta - dataset meta
       * @param {array} data - data array. Example [{x:1, y:5}, {x:2, y:10}]
       * @param {number} start - start index
       * @param {number} count - number of items to parse
       * @returns {object} parsed item - item containing index and a parsed value
       * for each scale id. _custom is optional
       * Example: {xScale0: 0, yScale0: 1, _custom: {r: 10, foo: 'bar'}}
       * @protected
       */
    protected parseObjectData(meta: object, data: any[], start: number, count: number): object;
    /**
       * @protected
       */
    protected getParsed(index: any): any;
    /**
       * @protected
       */
    protected getDataElement(index: any): any;
    /**
       * @protected
       */
    protected applyStack(scale: any, parsed: any, mode: any): any;
    /**
       * @protected
       */
    protected updateRangeFromParsed(range: any, scale: any, parsed: any, stack: any): void;
    /**
       * @protected
       */
    protected getMinMax(scale: any, canStack: any): {
        min: number;
        max: number;
    };
    getAllParsedValues(scale: any): number[];
    /**
       * @return {number|boolean}
       * @protected
       */
    protected getMaxOverflow(): number | boolean;
    /**
       * @protected
       */
    protected getLabelAndValue(index: any): {
        label: string;
        value: string;
    };
    /**
       * @private
       */
    private _update;
    /**
       * @param {string} mode
       */
    update(mode: string): void;
    draw(): void;
    /**
       * Returns a set of predefined style properties that should be used to represent the dataset
       * or the data if the index is specified
       * @param {number} index - data index
       * @param {boolean} [active] - true if hover
       * @return {object} style object
       */
    getStyle(index: number, active?: boolean): object;
    /**
       * @protected
       */
    protected getContext(index: any, active: any, mode: any): any;
    /**
       * @param {string} [mode]
       * @protected
       */
    protected resolveDatasetElementOptions(mode?: string): any;
    /**
       * @param {number} index
       * @param {string} [mode]
       * @protected
       */
    protected resolveDataElementOptions(index: number, mode?: string): any;
    /**
       * @private
       */
    private _resolveElementOptions;
    /**
       * @private
       */
    private _resolveAnimations;
    /**
       * Utility for getting the options object shared between elements
       * @protected
       */
    protected getSharedOptions(options: any): any;
    /**
       * Utility for determining if `options` should be included in the updated properties
       * @protected
       */
    protected includeOptions(mode: any, sharedOptions: any): boolean;
    /**
     * @todo v4, rename to getSharedOptions and remove excess functions
     */
    _getSharedOptions(start: any, mode: any): {
        sharedOptions: any;
        includeOptions: boolean;
    };
    /**
       * Utility for updating an element with new properties, using animations when appropriate.
       * @protected
       */
    protected updateElement(element: any, index: any, properties: any, mode: any): void;
    /**
       * Utility to animate the shared options, that are potentially affecting multiple elements.
       * @protected
       */
    protected updateSharedOptions(sharedOptions: any, mode: any, newOptions: any): void;
    /**
       * @private
       */
    private _setStyle;
    removeHoverStyle(element: any, datasetIndex: any, index: any): void;
    setHoverStyle(element: any, datasetIndex: any, index: any): void;
    /**
       * @private
       */
    private _removeDatasetHoverStyle;
    /**
       * @private
       */
    private _setDatasetHoverStyle;
    /**
       * @private
       */
    private _resyncElements;
    /**
       * @private
       */
    private _insertElements;
    updateElements(element: any, start: any, count: any, mode: any): void;
    /**
       * @private
       */
    private _removeElements;
    /**
       * @private
     */
    private _sync;
    _onDataPush(...args: any[]): void;
    _onDataPop(): void;
    _onDataShift(): void;
    _onDataSplice(start: any, count: any, ...args: any[]): void;
    _onDataUnshift(...args: any[]): void;
}
export type Chart = import('./core.controller.js').default;
export type Scale = import('./core.scale.js').default;


code:
export const overrides: any;
export const descriptors: any;
/**
 * Please use the module's default export which provides a singleton instance
 * Note: class is exported for typedoc
 */
export class Defaults {
    constructor(_descriptors: any, _appliers: any);
    animation: any;
    backgroundColor: string;
    borderColor: string;
    color: string;
    datasets: {};
    devicePixelRatio: (context: any) => any;
    elements: {};
    events: string[];
    font: {
        family: string;
        size: number;
        style: string;
        lineHeight: number;
        weight: any;
    };
    hover: {};
    hoverBackgroundColor: (ctx: any, options: any) => CanvasGradient;
    hoverBorderColor: (ctx: any, options: any) => CanvasGradient;
    hoverColor: (ctx: any, options: any) => CanvasGradient;
    indexAxis: string;
    interaction: {
        mode: string;
        intersect: boolean;
        includeInvisible: boolean;
    };
    maintainAspectRatio: boolean;
    onHover: any;
    onClick: any;
    parsing: boolean;
    plugins: {};
    responsive: boolean;
    scale: any;
    scales: {};
    showLine: boolean;
    drawActiveElementsOnTop: boolean;
    /**
       * @param {string|object} scope
       * @param {object} [values]
       */
    set(scope: string | object, values?: object): any;
    /**
       * @param {string} scope
       */
    get(scope: string): any;
    /**
       * @param {string|object} scope
       * @param {object} [values]
       */
    describe(scope: string | object, values?: object): any;
    override(scope: any, values: any): any;
    /**
       * Routes the named defaults to fallback to another scope/name.
       * This routing is useful when those target values, like defaults.color, are changed runtime.
       * If the values would be copied, the runtime change would not take effect. By routing, the
       * fallback is evaluated at each access, so its always up to date.
       *
       * Example:
       *
       * 	defaults.route('elements.arc', 'backgroundColor', '', 'color')
       *   - reads the backgroundColor from defaults.color when undefined locally
       *
       * @param {string} scope Scope this route applies to.
       * @param {string} name Property name that should be routed to different namespace when not defined here.
       * @param {string} targetScope The namespace where those properties should be routed to.
       * Empty string ('') is the root of defaults.
       * @param {string} targetName The target name in the target scope the property should be routed to.
       */
    route(scope: string, name: string, targetScope: string, targetName: string): void;
    apply(appliers: any): void;
}
declare const _default: Defaults;
export default _default;


code:
import type { AnyObject } from '../types/basic.js';
import type { Point } from '../types/geometric.js';
import type { Animation } from '../types/animation.js';
export default class Element<T = AnyObject, O = AnyObject> {
    static defaults: {};
    static defaultRoutes: any;
    x: number;
    y: number;
    active: boolean;
    options: O;
    $animations: Record<keyof T, Animation>;
    tooltipPosition(useFinalPosition: boolean): Point;
    hasValue(): boolean;
    /**
     * Gets the current or final value of each prop. Can return extra properties (whole object).
     * @param props - properties to get
     * @param [final] - get the final value (animation target)
     */
    getProps<P extends (keyof T)[]>(props: P, final?: boolean): Pick<T, P[number]>;
    getProps<P extends string>(props: P[], final?: boolean): Partial<Record<P, unknown>>;
}


code:
declare namespace _default {
    export { evaluateInteractionItems };
    export namespace modes {
        /**
             * Returns items at the same index. If the options.intersect parameter is true, we only return items if we intersect something
             * If the options.intersect mode is false, we find the nearest item and return the items at the same index as that item
             * @function Chart.Interaction.modes.index
             * @since v2.4.0
             * @param {Chart} chart - the chart we are returning items from
             * @param {Event} e - the event we are find things at
             * @param {InteractionOptions} options - options to use
             * @param {boolean} [useFinalPosition] - use final element position (animation target)
             * @return {InteractionItem[]} - items that are found
             */
        function index(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
        /**
             * Returns items in the same dataset. If the options.intersect parameter is true, we only return items if we intersect something
             * If the options.intersect is false, we find the nearest item and return the items in that dataset
             * @function Chart.Interaction.modes.dataset
             * @param {Chart} chart - the chart we are returning items from
             * @param {Event} e - the event we are find things at
             * @param {InteractionOptions} options - options to use
             * @param {boolean} [useFinalPosition] - use final element position (animation target)
             * @return {InteractionItem[]} - items that are found
             */
        function dataset(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
        /**
             * Point mode returns all elements that hit test based on the event position
             * of the event
             * @function Chart.Interaction.modes.intersect
             * @param {Chart} chart - the chart we are returning items from
             * @param {Event} e - the event we are find things at
             * @param {InteractionOptions} options - options to use
             * @param {boolean} [useFinalPosition] - use final element position (animation target)
             * @return {InteractionItem[]} - items that are found
             */
        function point(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
        /**
             * nearest mode returns the element closest to the point
             * @function Chart.Interaction.modes.intersect
             * @param {Chart} chart - the chart we are returning items from
             * @param {Event} e - the event we are find things at
             * @param {InteractionOptions} options - options to use
             * @param {boolean} [useFinalPosition] - use final element position (animation target)
             * @return {InteractionItem[]} - items that are found
             */
        function nearest(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
        /**
             * x mode returns the elements that hit-test at the current x coordinate
             * @function Chart.Interaction.modes.x
             * @param {Chart} chart - the chart we are returning items from
             * @param {Event} e - the event we are find things at
             * @param {InteractionOptions} options - options to use
             * @param {boolean} [useFinalPosition] - use final element position (animation target)
             * @return {InteractionItem[]} - items that are found
             */
        function x(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
        /**
             * y mode returns the elements that hit-test at the current y coordinate
             * @function Chart.Interaction.modes.y
             * @param {Chart} chart - the chart we are returning items from
             * @param {Event} e - the event we are find things at
             * @param {InteractionOptions} options - options to use
             * @param {boolean} [useFinalPosition] - use final element position (animation target)
             * @return {InteractionItem[]} - items that are found
             */
        function y(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
    }
}
export default _default;
export type Chart = import('./core.controller.js').default;
export type ChartEvent = import('../types/index.js').ChartEvent;
export type InteractionOptions = {
    axis?: string;
    intersect?: boolean;
    includeInvisible?: boolean;
};
export type InteractionItem = {
    datasetIndex: number;
    index: number;
    element: import('./core.element.js').default;
};
export type Point = import('../types/index.js').Point;
/**
 * Helper function to select candidate elements for interaction
 * @param {Chart} chart - the chart
 * @param {string} axis - the axis mode. x|y|xy|r
 * @param {Point} position - the point to be nearest to, in relative coordinates
 * @param {function} handler - the callback to execute for each visible item
 * @param {boolean} [intersect] - consider intersecting items
 */
declare function evaluateInteractionItems(chart: Chart, axis: string, position: Point, handler: Function, intersect?: boolean): void;


code:
declare namespace _default {
    /**
       * Register a box to a chart.
       * A box is simply a reference to an object that requires layout. eg. Scales, Legend, Title.
       * @param {Chart} chart - the chart to use
       * @param {LayoutItem} item - the item to add to be laid out
       */
    function addBox(chart: import("./core.controller.js").default, item: LayoutItem): void;
    /**
       * Remove a layoutItem from a chart
       * @param {Chart} chart - the chart to remove the box from
       * @param {LayoutItem} layoutItem - the item to remove from the layout
       */
    function removeBox(chart: import("./core.controller.js").default, layoutItem: LayoutItem): void;
    /**
       * Sets (or updates) options on the given `item`.
       * @param {Chart} chart - the chart in which the item lives (or will be added to)
       * @param {LayoutItem} item - the item to configure with the given options
       * @param {object} options - the new item options.
       */
    function configure(chart: import("./core.controller.js").default, item: LayoutItem, options: any): void;
    /**
       * Fits boxes of the given chart into the given size by having each box measure itself
       * then running a fitting algorithm
       * @param {Chart} chart - the chart
       * @param {number} width - the width to fit into
       * @param {number} height - the height to fit into
     * @param {number} minPadding - minimum padding required for each side of chart area
       */
    function update(chart: import("./core.controller.js").default, width: number, height: number, minPadding: number): void;
}
export default _default;
export type Chart = import('./core.controller.js').default;
export type LayoutItem = {
    /**
     * - The position of the item in the chart layout. Possible values are
     * 'left', 'top', 'right', 'bottom', and 'chartArea'
     */
    position: string;
    /**
     * - The weight used to sort the item. Higher weights are further away from the chart area
     */
    weight: number;
    /**
     * - if true, and the item is horizontal, then push vertical boxes down
     */
    fullSize: boolean;
    /**
     * - returns true if the layout item is horizontal (ie. top or bottom)
     */
    isHorizontal: Function;
    /**
     * - Takes two parameters: width and height. Returns size of item
     */
    update: Function;
    /**
     * - Draws the element
     */
    draw: Function;
    /**
     * -  Returns an object with padding on the edges
     */
    getPadding?: Function;
    /**
     * - Width of item. Must be valid after update()
     */
    width: number;
    /**
     * - Height of item. Must be valid after update()
     */
    height: number;
    /**
     * - Left edge of the item. Set by layout system and cannot be used in update
     */
    left: number;
    /**
     * - Top edge of the item. Set by layout system and cannot be used in update
     */
    top: number;
    /**
     * - Right edge of the item. Set by layout system and cannot be used in update
     */
    right: number;
    /**
     * - Bottom edge of the item. Set by layout system and cannot be used in update
     */
    bottom: number;
};


code: export function applyLayoutsDefaults(defaults: any): void;


code:
/**
 * @typedef { import('./core.controller.js').default } Chart
 * @typedef { import('../types/index.js').ChartEvent } ChartEvent
 * @typedef { import('../plugins/plugin.tooltip.js').default } Tooltip
 */
/**
 * @callback filterCallback
 * @param {{plugin: object, options: object}} value
 * @param {number} [index]
 * @param {array} [array]
 * @param {object} [thisArg]
 * @return {boolean}
 */
export default class PluginService {
    _init: any[];
    /**
       * Calls enabled plugins for `chart` on the specified hook and with the given args.
       * This method immediately returns as soon as a plugin explicitly returns false. The
       * returned value can be used, for instance, to interrupt the current action.
       * @param {Chart} chart - The chart instance for which plugins should be called.
       * @param {string} hook - The name of the plugin method to call (e.g. 'beforeUpdate').
       * @param {object} [args] - Extra arguments to apply to the hook call.
     * @param {filterCallback} [filter] - Filtering function for limiting which plugins are notified
       * @returns {boolean} false if any of the plugins return false, else returns true.
       */
    notify(chart: Chart, hook: string, args?: object, filter?: filterCallback): boolean;
    /**
       * @private
       */
    private _notify;
    invalidate(): void;
    _oldCache: {
        plugin: any;
        options: any;
    }[];
    _cache: {
        plugin: any;
        options: any;
    }[];
    /**
       * @param {Chart} chart
       * @private
       */
    private _descriptors;
    _createDescriptors(chart: any, all: any): {
        plugin: any;
        options: any;
    }[];
    /**
       * @param {Chart} chart
       * @private
       */
    private _notifyStateChanges;
}
export type Chart = import('./core.controller.js').default;
export type ChartEvent = import('../types/index.js').ChartEvent;
export type Tooltip = any;
export type filterCallback = (value: {
    plugin: object;
    options: object;
}, index?: number, array?: any[], thisArg?: object) => boolean;


code:
/**
 * Please use the module's default export which provides a singleton instance
 * Note: class is exported for typedoc
 */
export class Registry {
    controllers: TypedRegistry;
    elements: TypedRegistry;
    plugins: TypedRegistry;
    scales: TypedRegistry;
    _typedRegistries: TypedRegistry[];
    /**
       * @param  {...any} args
       */
    add(...args: any[]): void;
    remove(...args: any[]): void;
    /**
       * @param  {...typeof DatasetController} args
       */
    addControllers(...args: (typeof DatasetController)[]): void;
    /**
       * @param  {...typeof Element} args
       */
    addElements(...args: (typeof Element)[]): void;
    /**
       * @param  {...any} args
       */
    addPlugins(...args: any[]): void;
    /**
       * @param  {...typeof Scale} args
       */
    addScales(...args: (typeof Scale)[]): void;
    /**
       * @param {string} id
       * @returns {typeof DatasetController}
       */
    getController(id: string): typeof DatasetController;
    /**
       * @param {string} id
       * @returns {typeof Element}
       */
    getElement(id: string): typeof Element;
    /**
       * @param {string} id
       * @returns {object}
       */
    getPlugin(id: string): object;
    /**
       * @param {string} id
       * @returns {typeof Scale}
       */
    getScale(id: string): typeof Scale;
    /**
       * @param  {...typeof DatasetController} args
       */
    removeControllers(...args: (typeof DatasetController)[]): void;
    /**
       * @param  {...typeof Element} args
       */
    removeElements(...args: (typeof Element)[]): void;
    /**
       * @param  {...any} args
       */
    removePlugins(...args: any[]): void;
    /**
       * @param  {...typeof Scale} args
       */
    removeScales(...args: (typeof Scale)[]): void;
    /**
       * @private
       */
    private _each;
    /**
       * @private
       */
    private _exec;
    /**
       * @private
       */
    private _getRegistryForType;
    /**
       * @private
       */
    private _get;
}
declare const _default: Registry;
export default _default;
import TypedRegistry from "./core.typedRegistry.js";
import DatasetController from "./core.datasetController.js";
import Element from "./core.element.js";
import Scale from "./core.scale.js";


code:
/**
 * @typedef { import('./core.controller.js').default } Chart
 * @typedef {{value:number | string, label?:string, major?:boolean, $context?:any}} Tick
 */
/**
 * Returns a subset of ticks to be plotted to avoid overlapping labels.
 * @param {import('./core.scale.js').default} scale
 * @param {Tick[]} ticks
 * @return {Tick[]}
 * @private
 */
export function autoSkip(scale: import('./core.scale.js').default, ticks: Tick[]): Tick[];
export type Chart = import('./core.controller.js').default;
export type Tick = {
    value: number | string;
    label?: string;
    major?: boolean;
    $context?: any;
};


code:
export default class Scale extends Element<import("../types/basic.js").AnyObject, import("../types/basic.js").AnyObject> {
    constructor(cfg: any);
    /** @type {string} */
    id: string;
    /** @type {string} */
    type: string;
    /** @type {any} */
    options: any;
    /** @type {CanvasRenderingContext2D} */
    ctx: CanvasRenderingContext2D;
    /** @type {Chart} */
    chart: Chart;
    /** @type {number} */
    top: number;
    /** @type {number} */
    bottom: number;
    /** @type {number} */
    left: number;
    /** @type {number} */
    right: number;
    /** @type {number} */
    width: number;
    /** @type {number} */
    height: number;
    _margins: {
        left: number;
        right: number;
        top: number;
        bottom: number;
    };
    /** @type {number} */
    maxWidth: number;
    /** @type {number} */
    maxHeight: number;
    /** @type {number} */
    paddingTop: number;
    /** @type {number} */
    paddingBottom: number;
    /** @type {number} */
    paddingLeft: number;
    /** @type {number} */
    paddingRight: number;
    /** @type {string=} */
    axis: string | undefined;
    /** @type {number=} */
    labelRotation: number | undefined;
    min: any;
    max: any;
    _range: {
        min: number;
        max: number;
    };
    /** @type {Tick[]} */
    ticks: Tick[];
    /** @type {object[]|null} */
    _gridLineItems: object[] | null;
    /** @type {object[]|null} */
    _labelItems: object[] | null;
    /** @type {object|null} */
    _labelSizes: object | null;
    _length: number;
    _maxLength: number;
    _longestTextCache: {};
    /** @type {number} */
    _startPixel: number;
    /** @type {number} */
    _endPixel: number;
    _reversePixels: boolean;
    _userMax: any;
    _userMin: any;
    _suggestedMax: any;
    _suggestedMin: any;
    _ticksLength: number;
    _borderValue: number;
    _cache: {};
    _dataLimitsCached: boolean;
    $context: any;
    /**
       * @param {any} options
       * @since 3.0
       */
    init(options: any): void;
    /**
       * Parse a supported input value to internal representation.
       * @param {*} raw
       * @param {number} [index]
       * @since 3.0
       */
    parse(raw: any, index?: number): any;
    /**
       * @return {{min: number, max: number, minDefined: boolean, maxDefined: boolean}}
       * @protected
       * @since 3.0
       */
    protected getUserBounds(): {
        min: number;
        max: number;
        minDefined: boolean;
        maxDefined: boolean;
    };
    /**
       * @param {boolean} canStack
       * @return {{min: number, max: number}}
       * @protected
       * @since 3.0
       */
    protected getMinMax(canStack: boolean): {
        min: number;
        max: number;
    };
    /**
       * Get the padding needed for the scale
       * @return {{top: number, left: number, bottom: number, right: number}} the necessary padding
       * @private
       */
    private getPadding;
    /**
       * Returns the scale tick objects
       * @return {Tick[]}
       * @since 2.7
       */
    getTicks(): Tick[];
    /**
       * @return {string[]}
       */
    getLabels(): string[];
    /**
     * @return {import('../types.js').LabelItem[]}
     */
    getLabelItems(chartArea?: import("../types.js").ChartArea): import('../types.js').LabelItem[];
    beforeLayout(): void;
    beforeUpdate(): void;
    /**
       * @param {number} maxWidth - the max width in pixels
       * @param {number} maxHeight - the max height in pixels
       * @param {{top: number, left: number, bottom: number, right: number}} margins - the space between the edge of the other scales and edge of the chart
       *   This space comes from two sources:
       *     - padding - space that's required to show the labels at the edges of the scale
       *     - thickness of scales or legends in another orientation
       */
    update(maxWidth: number, maxHeight: number, margins: {
        top: number;
        left: number;
        bottom: number;
        right: number;
    }): void;
    /**
       * @protected
       */
    protected configure(): void;
    _alignToPixels: any;
    afterUpdate(): void;
    beforeSetDimensions(): void;
    setDimensions(): void;
    afterSetDimensions(): void;
    _callHooks(name: any): void;
    beforeDataLimits(): void;
    determineDataLimits(): void;
    afterDataLimits(): void;
    beforeBuildTicks(): void;
    /**
       * @return {object[]} the ticks
       */
    buildTicks(): object[];
    afterBuildTicks(): void;
    beforeTickToLabelConversion(): void;
    /**
       * Convert ticks to label strings
       * @param {Tick[]} ticks
       */
    generateTickLabels(ticks: Tick[]): void;
    afterTickToLabelConversion(): void;
    beforeCalculateLabelRotation(): void;
    calculateLabelRotation(): void;
    afterCalculateLabelRotation(): void;
    afterAutoSkip(): void;
    beforeFit(): void;
    fit(): void;
    _calculatePadding(first: any, last: any, sin: any, cos: any): void;
    /**
       * Handle margins and padding interactions
       * @private
       */
    private _handleMargins;
    afterFit(): void;
    /**
       * @return {boolean}
       */
    isHorizontal(): boolean;
    /**
       * @return {boolean}
       */
    isFullSize(): boolean;
    /**
       * @param {Tick[]} ticks
       * @private
       */
    private _convertTicksToLabels;
    /**
       * @return {{ first: object, last: object, widest: object, highest: object, widths: Array, heights: array }}
       * @private
       */
    private _getLabelSizes;
    /**
       * Returns {width, height, offset} objects for the first, last, widest, highest tick
       * labels where offset indicates the anchor point offset from the top in pixels.
       * @return {{ first: object, last: object, widest: object, highest: object, widths: Array, heights: array }}
       * @private
       */
    private _computeLabelSizes;
    /**
       * Used to get the label to display in the tooltip for the given value
       * @param {*} value
       * @return {string}
       */
    getLabelForValue(value: any): string;
    /**
       * Returns the location of the given data point. Value can either be an index or a numerical value
       * The coordinate (0, 0) is at the upper-left corner of the canvas
       * @param {*} value
       * @param {number} [index]
       * @return {number}
       */
    getPixelForValue(value: any, index?: number): number;
    /**
       * Used to get the data value from a given pixel. This is the inverse of getPixelForValue
       * The coordinate (0, 0) is at the upper-left corner of the canvas
       * @param {number} pixel
       * @return {*}
       */
    getValueForPixel(pixel: number): any;
    /**
       * Returns the location of the tick at the given index
       * The coordinate (0, 0) is at the upper-left corner of the canvas
       * @param {number} index
       * @return {number}
       */
    getPixelForTick(index: number): number;
    /**
       * Utility for getting the pixel location of a percentage of scale
       * The coordinate (0, 0) is at the upper-left corner of the canvas
       * @param {number} decimal
       * @return {number}
       */
    getPixelForDecimal(decimal: number): number;
    /**
       * @param {number} pixel
       * @return {number}
       */
    getDecimalForPixel(pixel: number): number;
    /**
       * Returns the pixel for the minimum chart value
       * The coordinate (0, 0) is at the upper-left corner of the canvas
       * @return {number}
       */
    getBasePixel(): number;
    /**
       * @return {number}
       */
    getBaseValue(): number;
    /**
       * @protected
       */
    protected getContext(index: any): any;
    /**
       * @return {number}
       * @private
       */
    private _tickSize;
    /**
       * @return {boolean}
       * @private
       */
    private _isVisible;
    /**
       * @private
       */
    private _computeGridLineItems;
    /**
       * @private
       */
    private _computeLabelItems;
    _getXAxisLabelAlignment(): string;
    _getYAxisLabelAlignment(tl: any): {
        textAlign: string;
        x: any;
    };
    /**
       * @private
       */
    private _computeLabelArea;
    /**
     * @protected
     */
    protected drawBackground(): void;
    getLineWidthForValue(value: any): any;
    /**
       * @protected
       */
    protected drawGrid(chartArea: any): void;
    /**
       * @protected
       */
    protected drawBorder(): void;
    /**
       * @protected
       */
    protected drawLabels(chartArea: any): void;
    /**
       * @protected
       */
    protected drawTitle(): void;
    draw(chartArea: any): void;
    /**
       * @return {object[]}
       * @private
       */
    private _layers;
    /**
       * Returns visible dataset metas that are attached to this scale
       * @param {string} [type] - if specified, also filter by dataset type
       * @return {object[]}
       */
    getMatchingVisibleMetas(type?: string): object[];
    /**
       * @param {number} index
       * @return {object}
       * @protected
       */
    protected _resolveTickFontOptions(index: number): object;
    /**
     * @protected
     */
    protected _maxDigits(): number;
}
export type Chart = import('../types/index.js').Chart;
export type Tick = {
    value: number | string;
    label?: string;
    major?: boolean;
    $context?: any;
};
import Element from "./core.element.js";


code: export function applyScaleDefaults(defaults: any): void;


code:
declare namespace _default {
    export { formatters };
}
export default _default;
declare namespace formatters {
    /**
     * Formatter for value labels
     * @method Chart.Ticks.formatters.values
     * @param value the value to display
     * @return {string|string[]} the label to display
     */
    function values(value: any): string | string[];
    /**
     * Formatter for numeric ticks
     * @method Chart.Ticks.formatters.numeric
     * @param tickValue {number} the value to be formatted
     * @param index {number} the position of the tickValue parameter in the ticks array
     * @param ticks {object[]} the list of ticks being converted
     * @return {string} string representation of the tickValue parameter
     */
    function numeric(tickValue: number, index: number, ticks: any[]): string;
    /**
     * Formatter for logarithmic ticks
     * @method Chart.Ticks.formatters.logarithmic
     * @param tickValue {number} the value to be formatted
     * @param index {number} the position of the tickValue parameter in the ticks array
     * @param ticks {object[]} the list of ticks being converted
     * @return {string} string representation of the tickValue parameter
     */
    function logarithmic(tickValue: number, index: number, ticks: any[]): string;
}


code:
/**
 * @typedef {{id: string, defaults: any, overrides?: any, defaultRoutes: any}} IChartComponent
 */
export default class TypedRegistry {
    constructor(type: any, scope: any, override: any);
    type: any;
    scope: any;
    override: any;
    items: any;
    isForType(type: any): boolean;
    /**
       * @param {IChartComponent} item
       * @returns {string} The scope where items defaults were registered to.
       */
    register(item: IChartComponent): string;
    /**
       * @param {string} id
       * @returns {object?}
       */
    get(id: string): object | null;
    /**
       * @param {IChartComponent} item
       */
    unregister(item: IChartComponent): void;
}
export type IChartComponent = {
    id: string;
    defaults: any;
    overrides?: any;
    defaultRoutes: any;
};
import defaults from "./core.defaults.js";
import { overrides } from "./core.defaults.js";


code:
export type { DateAdapter, TimeUnit } from './core.adapters.js';
export { default as _adapters } from './core.adapters.js';
export { default as Animation } from './core.animation.js';
export { default as Animations } from './core.animations.js';
export { default as animator } from './core.animator.js';
export { default as Chart } from './core.controller.js';
export { default as DatasetController } from './core.datasetController.js';
export { default as defaults } from './core.defaults.js';
export { default as Element } from './core.element.js';
export { default as Interaction } from './core.interaction.js';
export { default as layouts } from './core.layouts.js';
export { default as plugins } from './core.plugins.js';
export { default as registry } from './core.registry.js';
export { default as Scale } from './core.scale.js';
export { default as Ticks } from './core.ticks.js';


code:
import Element from '../core/core.element.js';
import type { ArcOptions, Point } from '../types/index.js';
export interface ArcProps extends Point {
    startAngle: number;
    endAngle: number;
    innerRadius: number;
    outerRadius: number;
    circumference: number;
}
export default class ArcElement extends Element<ArcProps, ArcOptions> {
    static id: string;
    static defaults: {
        borderAlign: string;
        borderColor: string;
        borderDash: any[];
        borderDashOffset: number;
        borderJoinStyle: any;
        borderRadius: number;
        borderWidth: number;
        offset: number;
        spacing: number;
        angle: any;
        circular: boolean;
    };
    static defaultRoutes: {
        backgroundColor: string;
    };
    static descriptors: {
        _scriptable: boolean;
        _indexable: (name: any) => boolean;
    };
    circumference: number;
    endAngle: number;
    fullCircles: number;
    innerRadius: number;
    outerRadius: number;
    pixelMargin: number;
    startAngle: number;
    constructor(cfg: any);
    inRange(chartX: number, chartY: number, useFinalPosition: boolean): boolean;
    getCenterPoint(useFinalPosition: boolean): {
        x: number;
        y: number;
    };
    tooltipPosition(useFinalPosition: boolean): {
        x: number;
        y: number;
    };
    draw(ctx: CanvasRenderingContext2D): void;
}


code:
export default class BarElement extends Element<import("../types/basic.js").AnyObject, import("../types/basic.js").AnyObject> {
    static id: string;
    /**
     * @type {any}
     */
    static defaults: any;
    constructor(cfg: any);
    options: any;
    horizontal: any;
    base: any;
    width: any;
    height: any;
    inflateAmount: any;
    draw(ctx: any): void;
    inRange(mouseX: any, mouseY: any, useFinalPosition: any): boolean;
    inXRange(mouseX: any, useFinalPosition: any): boolean;
    inYRange(mouseY: any, useFinalPosition: any): boolean;
    getCenterPoint(useFinalPosition: any): {
        x: number;
        y: number;
    };
    getRange(axis: any): number;
}
export type BarProps = {
    x: number;
    y: number;
    base: number;
    horizontal: boolean;
    width: number;
    height: number;
};
import Element from "../core/core.element.js";


code:
export default class LineElement extends Element<import("../types/basic.js").AnyObject, import("../types/basic.js").AnyObject> {
    static id: string;
    /**
     * @type {any}
     */
    static defaults: any;
    static descriptors: {
        _scriptable: boolean;
        _indexable: (name: any) => boolean;
    };
    constructor(cfg: any);
    animated: boolean;
    options: any;
    _chart: any;
    _loop: any;
    _fullLoop: any;
    _path: any;
    _points: any;
    _segments: import("../helpers/helpers.segment.js").Segment[];
    _decimated: boolean;
    _pointsUpdated: boolean;
    _datasetIndex: any;
    updateControlPoints(chartArea: any, indexAxis: any): void;
    set points(arg: any);
    get points(): any;
    get segments(): import("../helpers/helpers.segment.js").Segment[];
    /**
       * First non-skipped point on this line
       * @returns {PointElement|undefined}
       */
    first(): PointElement | undefined;
    /**
       * Last non-skipped point on this line
       * @returns {PointElement|undefined}
       */
    last(): PointElement | undefined;
    /**
       * Interpolate a point in this line at the same value on `property` as
       * the reference `point` provided
       * @param {PointElement} point - the reference point
       * @param {string} property - the property to match on
       * @returns {PointElement|undefined}
       */
    interpolate(point: PointElement, property: string): PointElement | undefined;
    /**
       * Append a segment of this line to current path.
       * @param {CanvasRenderingContext2D} ctx
       * @param {object} segment
       * @param {number} segment.start - start index of the segment, referring the points array
       * @param {number} segment.end - end index of the segment, referring the points array
       * @param {boolean} segment.loop - indicates that the segment is a loop
       * @param {object} params
       * @param {boolean} params.move - move to starting point (vs line to it)
       * @param {boolean} params.reverse - path the segment from end to start
       * @param {number} params.start - limit segment to points starting from `start` index
       * @param {number} params.end - limit segment to points ending at `start` + `count` index
       * @returns {undefined|boolean} - true if the segment is a full loop (path should be closed)
       */
    pathSegment(ctx: CanvasRenderingContext2D, segment: {
        start: number;
        end: number;
        loop: boolean;
    }, params: {
        move: boolean;
        reverse: boolean;
        start: number;
        end: number;
    }): undefined | boolean;
    /**
       * Append all segments of this line to current path.
       * @param {CanvasRenderingContext2D|Path2D} ctx
       * @param {number} [start]
       * @param {number} [count]
       * @returns {undefined|boolean} - true if line is a full loop (path should be closed)
       */
    path(ctx: CanvasRenderingContext2D | Path2D, start?: number, count?: number): undefined | boolean;
    /**
       * Draw
       * @param {CanvasRenderingContext2D} ctx
       * @param {object} chartArea
       * @param {number} [start]
       * @param {number} [count]
       */
    draw(ctx: CanvasRenderingContext2D, chartArea: object, start?: number, count?: number): void;
}
export type PointElement = import('./element.point.js').default;
import Element from "../core/core.element.js";


code:
import Element from '../core/core.element.js';
import type { CartesianParsedData, ChartArea, Point, PointHoverOptions, PointOptions } from '../types/index.js';
export type PointProps = Point;
export default class PointElement extends Element<PointProps, PointOptions & PointHoverOptions> {
    static id: string;
    parsed: CartesianParsedData;
    skip?: boolean;
    stop?: boolean;
    /**
     * @type {any}
     */
    static defaults: {
        borderWidth: number;
        hitRadius: number;
        hoverBorderWidth: number;
        hoverRadius: number;
        pointStyle: string;
        radius: number;
        rotation: number;
    };
    /**
     * @type {any}
     */
    static defaultRoutes: {
        backgroundColor: string;
        borderColor: string;
    };
    constructor(cfg: any);
    inRange(mouseX: number, mouseY: number, useFinalPosition?: boolean): boolean;
    inXRange(mouseX: number, useFinalPosition?: boolean): boolean;
    inYRange(mouseY: number, useFinalPosition?: boolean): boolean;
    getCenterPoint(useFinalPosition?: boolean): {
        x: number;
        y: number;
    };
    size(options?: Partial<PointOptions & PointHoverOptions>): number;
    draw(ctx: CanvasRenderingContext2D, area: ChartArea): void;
    getRange(): any;
}


code:
export { default as ArcElement } from "./element.arc.js";
export { default as LineElement } from "./element.line.js";
export { default as PointElement } from "./element.point.js";
export { default as BarElement } from "./element.bar.js";


code:
/*!
 * Chart.js v4.4.5
 * https://www.chartjs.org
 * (c) 2024 Chart.js Contributors
 * Released under the MIT License
 */
'use strict';

var helpers_segment = require('./chunks/helpers.segment.cjs');
require('@kurkle/color');

exports.HALF_PI = helpers_segment.HALF_PI;
exports.INFINITY = helpers_segment.INFINITY;
exports.PI = helpers_segment.PI;
exports.PITAU = helpers_segment.PITAU;
exports.QUARTER_PI = helpers_segment.QUARTER_PI;
exports.RAD_PER_DEG = helpers_segment.RAD_PER_DEG;
exports.TAU = helpers_segment.TAU;
exports.TWO_THIRDS_PI = helpers_segment.TWO_THIRDS_PI;
exports._addGrace = helpers_segment._addGrace;
exports._alignPixel = helpers_segment._alignPixel;
exports._alignStartEnd = helpers_segment._alignStartEnd;
exports._angleBetween = helpers_segment._angleBetween;
exports._angleDiff = helpers_segment._angleDiff;
exports._arrayUnique = helpers_segment._arrayUnique;
exports._attachContext = helpers_segment._attachContext;
exports._bezierCurveTo = helpers_segment._bezierCurveTo;
exports._bezierInterpolation = helpers_segment._bezierInterpolation;
exports._boundSegment = helpers_segment._boundSegment;
exports._boundSegments = helpers_segment._boundSegments;
exports._capitalize = helpers_segment._capitalize;
exports._computeSegments = helpers_segment._computeSegments;
exports._createResolver = helpers_segment._createResolver;
exports._decimalPlaces = helpers_segment._decimalPlaces;
exports._deprecated = helpers_segment._deprecated;
exports._descriptors = helpers_segment._descriptors;
exports._elementsEqual = helpers_segment._elementsEqual;
exports._factorize = helpers_segment._factorize;
exports._filterBetween = helpers_segment._filterBetween;
exports._getParentNode = helpers_segment._getParentNode;
exports._getStartAndCountOfVisiblePoints = helpers_segment._getStartAndCountOfVisiblePoints;
exports._int16Range = helpers_segment._int16Range;
exports._isBetween = helpers_segment._isBetween;
exports._isClickEvent = helpers_segment._isClickEvent;
exports._isDomSupported = helpers_segment._isDomSupported;
exports._isPointInArea = helpers_segment._isPointInArea;
exports._limitValue = helpers_segment._limitValue;
exports._longestText = helpers_segment._longestText;
exports._lookup = helpers_segment._lookup;
exports._lookupByKey = helpers_segment._lookupByKey;
exports._measureText = helpers_segment._measureText;
exports._merger = helpers_segment._merger;
exports._mergerIf = helpers_segment._mergerIf;
exports._normalizeAngle = helpers_segment._normalizeAngle;
exports._parseObjectDataRadialScale = helpers_segment._parseObjectDataRadialScale;
exports._pointInLine = helpers_segment._pointInLine;
exports._readValueToProps = helpers_segment._readValueToProps;
exports._rlookupByKey = helpers_segment._rlookupByKey;
exports._scaleRangesChanged = helpers_segment._scaleRangesChanged;
exports._setMinAndMaxByKey = helpers_segment._setMinAndMaxByKey;
exports._splitKey = helpers_segment._splitKey;
exports._steppedInterpolation = helpers_segment._steppedInterpolation;
exports._steppedLineTo = helpers_segment._steppedLineTo;
exports._textX = helpers_segment._textX;
exports._toLeftRightCenter = helpers_segment._toLeftRightCenter;
exports._updateBezierControlPoints = helpers_segment._updateBezierControlPoints;
exports.addRoundedRectPath = helpers_segment.addRoundedRectPath;
exports.almostEquals = helpers_segment.almostEquals;
exports.almostWhole = helpers_segment.almostWhole;
exports.callback = helpers_segment.callback;
exports.clearCanvas = helpers_segment.clearCanvas;
exports.clipArea = helpers_segment.clipArea;
exports.clone = helpers_segment.clone;
exports.color = helpers_segment.color;
exports.createContext = helpers_segment.createContext;
exports.debounce = helpers_segment.debounce;
exports.defined = helpers_segment.defined;
exports.distanceBetweenPoints = helpers_segment.distanceBetweenPoints;
exports.drawPoint = helpers_segment.drawPoint;
exports.drawPointLegend = helpers_segment.drawPointLegend;
exports.each = helpers_segment.each;
exports.easingEffects = helpers_segment.effects;
exports.finiteOrDefault = helpers_segment.finiteOrDefault;
exports.fontString = helpers_segment.fontString;
exports.formatNumber = helpers_segment.formatNumber;
exports.getAngleFromPoint = helpers_segment.getAngleFromPoint;
exports.getHoverColor = helpers_segment.getHoverColor;
exports.getMaximumSize = helpers_segment.getMaximumSize;
exports.getRelativePosition = helpers_segment.getRelativePosition;
exports.getRtlAdapter = helpers_segment.getRtlAdapter;
exports.getStyle = helpers_segment.getStyle;
exports.isArray = helpers_segment.isArray;
exports.isFinite = helpers_segment.isNumberFinite;
exports.isFunction = helpers_segment.isFunction;
exports.isNullOrUndef = helpers_segment.isNullOrUndef;
exports.isNumber = helpers_segment.isNumber;
exports.isObject = helpers_segment.isObject;
exports.isPatternOrGradient = helpers_segment.isPatternOrGradient;
exports.listenArrayEvents = helpers_segment.listenArrayEvents;
exports.log10 = helpers_segment.log10;
exports.merge = helpers_segment.merge;
exports.mergeIf = helpers_segment.mergeIf;
exports.niceNum = helpers_segment.niceNum;
exports.noop = helpers_segment.noop;
exports.overrideTextDirection = helpers_segment.overrideTextDirection;
exports.readUsedSize = helpers_segment.readUsedSize;
exports.renderText = helpers_segment.renderText;
exports.requestAnimFrame = helpers_segment.requestAnimFrame;
exports.resolve = helpers_segment.resolve;
exports.resolveObjectKey = helpers_segment.resolveObjectKey;
exports.restoreTextDirection = helpers_segment.restoreTextDirection;
exports.retinaScale = helpers_segment.retinaScale;
exports.setsEqual = helpers_segment.setsEqual;
exports.sign = helpers_segment.sign;
exports.splineCurve = helpers_segment.splineCurve;
exports.splineCurveMonotone = helpers_segment.splineCurveMonotone;
exports.supportsEventListenerOptions = helpers_segment.supportsEventListenerOptions;
exports.throttled = helpers_segment.throttled;
exports.toDegrees = helpers_segment.toDegrees;
exports.toDimension = helpers_segment.toDimension;
exports.toFont = helpers_segment.toFont;
exports.toFontString = helpers_segment.toFontString;
exports.toLineHeight = helpers_segment.toLineHeight;
exports.toPadding = helpers_segment.toPadding;
exports.toPercentage = helpers_segment.toPercentage;
exports.toRadians = helpers_segment.toRadians;
exports.toTRBL = helpers_segment.toTRBL;
exports.toTRBLCorners = helpers_segment.toTRBLCorners;
exports.uid = helpers_segment.uid;
exports.unclipArea = helpers_segment.unclipArea;
exports.unlistenArrayEvents = helpers_segment.unlistenArrayEvents;
exports.valueOrDefault = helpers_segment.valueOrDefault;
//# sourceMappingURL=helpers.cjs.map


code:
import type { Chart, Point, FontSpec, CanvasFontSpec, PointStyle, RenderTextOpts } from '../types/index.js';
import type { TRBL, SplinePoint, RoundedRect, TRBLCorners } from '../types/geometric.js';
/**
 * Converts the given font object into a CSS font string.
 * @param font - A font object.
 * @return The CSS font string. See https://developer.mozilla.org/en-US/docs/Web/CSS/font
 * @private
 */
export declare function toFontString(font: FontSpec): string;
/**
 * @private
 */
export declare function _measureText(ctx: CanvasRenderingContext2D, data: Record<string, number>, gc: string[], longest: number, string: string): number;
type Thing = string | undefined | null;
type Things = (Thing | Thing[])[];
/**
 * @private
 */
export declare function _longestText(ctx: CanvasRenderingContext2D, font: string, arrayOfThings: Things, cache?: {
    data?: Record<string, number>;
    garbageCollect?: string[];
    font?: string;
}): number;
/**
 * Returns the aligned pixel value to avoid anti-aliasing blur
 * @param chart - The chart instance.
 * @param pixel - A pixel value.
 * @param width - The width of the element.
 * @returns The aligned pixel value.
 * @private
 */
export declare function _alignPixel(chart: Chart, pixel: number, width: number): number;
/**
 * Clears the entire canvas.
 */
export declare function clearCanvas(canvas?: HTMLCanvasElement, ctx?: CanvasRenderingContext2D): void;
export interface DrawPointOptions {
    pointStyle: PointStyle;
    rotation?: number;
    radius: number;
    borderWidth: number;
}
export declare function drawPoint(ctx: CanvasRenderingContext2D, options: DrawPointOptions, x: number, y: number): void;
export declare function drawPointLegend(ctx: CanvasRenderingContext2D, options: DrawPointOptions, x: number, y: number, w: number): void;
/**
 * Returns true if the point is inside the rectangle
 * @param point - The point to test
 * @param area - The rectangle
 * @param margin - allowed margin
 * @private
 */
export declare function _isPointInArea(point: Point, area: TRBL, margin?: number): boolean;
export declare function clipArea(ctx: CanvasRenderingContext2D, area: TRBL): void;
export declare function unclipArea(ctx: CanvasRenderingContext2D): void;
/**
 * @private
 */
export declare function _steppedLineTo(ctx: CanvasRenderingContext2D, previous: Point, target: Point, flip?: boolean, mode?: string): void;
/**
 * @private
 */
export declare function _bezierCurveTo(ctx: CanvasRenderingContext2D, previous: SplinePoint, target: SplinePoint, flip?: boolean): void;
/**
 * Render text onto the canvas
 */
export declare function renderText(ctx: CanvasRenderingContext2D, text: string | string[], x: number, y: number, font: CanvasFontSpec, opts?: RenderTextOpts): void;
/**
 * Add a path of a rectangle with rounded corners to the current sub-path
 * @param ctx - Context
 * @param rect - Bounding rect
 */
export declare function addRoundedRectPath(ctx: CanvasRenderingContext2D, rect: RoundedRect & {
    radius: TRBLCorners;
}): void;
export {};


code:
/**
 * Binary search
 * @param table - the table search. must be sorted!
 * @param value - value to find
 * @param cmp
 * @private
 */
export declare function _lookup(table: number[], value: number, cmp?: (value: number) => boolean): {
    lo: number;
    hi: number;
};
export declare function _lookup<T>(table: T[], value: number, cmp: (value: number) => boolean): {
    lo: number;
    hi: number;
};
/**
 * Binary search
 * @param table - the table search. must be sorted!
 * @param key - property name for the value in each entry
 * @param value - value to find
 * @param last - lookup last index
 * @private
 */
export declare const _lookupByKey: (table: Record<string, number>[], key: string, value: number, last?: boolean) => {
    lo: number;
    hi: number;
};
/**
 * Reverse binary search
 * @param table - the table search. must be sorted!
 * @param key - property name for the value in each entry
 * @param value - value to find
 * @private
 */
export declare const _rlookupByKey: (table: Record<string, number>[], key: string, value: number) => {
    lo: number;
    hi: number;
};
/**
 * Return subset of `values` between `min` and `max` inclusive.
 * Values are assumed to be in sorted order.
 * @param values - sorted array of values
 * @param min - min value
 * @param max - max value
 */
export declare function _filterBetween(values: number[], min: number, max: number): number[];
export interface ArrayListener<T> {
    _onDataPush?(...item: T[]): void;
    _onDataPop?(): void;
    _onDataShift?(): void;
    _onDataSplice?(index: number, deleteCount: number, ...items: T[]): void;
    _onDataUnshift?(...item: T[]): void;
}
/**
 * Hooks the array methods that add or remove values ('push', pop', 'shift', 'splice',
 * 'unshift') and notify the listener AFTER the array has been altered. Listeners are
 * called on the '_onData*' callbacks (e.g. _onDataPush, etc.) with same arguments.
 */
export declare function listenArrayEvents<T>(array: T[], listener: ArrayListener<T>): void;
/**
 * Removes the given array event listener and cleanup extra attached properties (such as
 * the _chartjs stub and overridden methods) if array doesn't have any more listeners.
 */
export declare function unlistenArrayEvents<T>(array: T[], listener: ArrayListener<T>): void;
/**
 * @param items
 */
export declare function _arrayUnique<T>(items: T[]): T[];


code:
import { Color } from '@kurkle/color';
export declare function isPatternOrGradient(value: unknown): value is CanvasPattern | CanvasGradient;
export declare function color(value: CanvasGradient): CanvasGradient;
export declare function color(value: CanvasPattern): CanvasPattern;
export declare function color(value: string | {
    r: number;
    g: number;
    b: number;
    a: number;
} | [number, number, number] | [number, number, number, number]): Color;
export declare function getHoverColor(value: CanvasGradient): CanvasGradient;
export declare function getHoverColor(value: CanvasPattern): CanvasPattern;
export declare function getHoverColor(value: string): string;


code:
import type { AnyObject } from '../types/basic.js';
import type { ChartMeta } from '../types/index.js';
import type { ResolverObjectKey, ResolverCache, ResolverProxy, DescriptorDefaults, Descriptor, ContextProxy } from './helpers.config.types.js';
export * from './helpers.config.types.js';
/**
 * Creates a Proxy for resolving raw values for options.
 * @param scopes - The option scopes to look for values, in resolution order
 * @param prefixes - The prefixes for values, in resolution order.
 * @param rootScopes - The root option scopes
 * @param fallback - Parent scopes fallback
 * @param getTarget - callback for getting the target for changed values
 * @returns Proxy
 * @private
 */
export declare function _createResolver<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T>(scopes: T, prefixes?: string[], rootScopes?: R, fallback?: ResolverObjectKey, getTarget?: () => AnyObject): any;
/**
 * Returns an Proxy for resolving option values with context.
 * @param proxy - The Proxy returned by `_createResolver`
 * @param context - Context object for scriptable/indexable options
 * @param subProxy - The proxy provided for scriptable options
 * @param descriptorDefaults - Defaults for descriptors
 * @private
 */
export declare function _attachContext<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T>(proxy: ResolverProxy<T, R>, context: AnyObject, subProxy?: ResolverProxy<T, R>, descriptorDefaults?: DescriptorDefaults): ContextProxy<T, R>;
/**
 * @private
 */
export declare function _descriptors(proxy: ResolverCache, defaults?: DescriptorDefaults): Descriptor;
export declare function _parseObjectDataRadialScale(meta: ChartMeta<'line' | 'scatter'>, data: AnyObject[], start: number, count: number): {
    r: unknown;
}[];


code:
import type { AnyObject } from '../types/basic.js';
import type { Merge } from '../types/utils.js';
export type ResolverObjectKey = string | boolean;
export interface ResolverCache<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T> {
    [Symbol.toStringTag]: 'Object';
    _cacheable: boolean;
    _scopes: T;
    _rootScopes: T | R;
    _fallback: ResolverObjectKey;
    _keys?: string[];
    _scriptable?: boolean;
    _indexable?: boolean;
    _allKeys?: boolean;
    _storage?: T[number];
    _getTarget(): T[number];
    override<S extends AnyObject>(scope: S): ResolverProxy<(T[number] | S)[], T | R>;
}
export type ResolverProxy<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T> = Merge<T[number]> & ResolverCache<T, R>;
export interface DescriptorDefaults {
    scriptable: boolean;
    indexable: boolean;
    allKeys?: boolean;
}
export interface Descriptor {
    allKeys: boolean;
    scriptable: boolean;
    indexable: boolean;
    isScriptable(key: string): boolean;
    isIndexable(key: string): boolean;
}
export interface ContextCache<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T> {
    _cacheable: boolean;
    _proxy: ResolverProxy<T, R>;
    _context: AnyObject;
    _subProxy: ResolverProxy<T, R>;
    _stack: Set<string>;
    _descriptors: Descriptor;
    setContext(ctx: AnyObject): ContextProxy<T, R>;
    override<S extends AnyObject>(scope: S): ContextProxy<(T[number] | S)[], T | R>;
}
export type ContextProxy<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T> = Merge<T[number]> & ContextCache<T, R>;


code:
/**
 * @namespace Chart.helpers
 */
import type { AnyObject } from '../types/basic.js';
import type { ActiveDataPoint, ChartEvent } from '../types/index.js';
/**
 * An empty function that can be used, for example, for optional callback.
 */
export declare function noop(): void;
/**
 * Returns a unique id, sequentially generated from a global variable.
 */
export declare const uid: () => number;
/**
 * Returns true if `value` is neither null nor undefined, else returns false.
 * @param value - The value to test.
 * @since 2.7.0
 */
export declare function isNullOrUndef(value: unknown): value is null | undefined;
/**
 * Returns true if `value` is an array (including typed arrays), else returns false.
 * @param value - The value to test.
 * @function
 */
export declare function isArray<T = unknown>(value: unknown): value is T[];
/**
 * Returns true if `value` is an object (excluding null), else returns false.
 * @param value - The value to test.
 * @since 2.7.0
 */
export declare function isObject(value: unknown): value is AnyObject;
/**
 * Returns true if `value` is a finite number, else returns false
 * @param value  - The value to test.
 */
declare function isNumberFinite(value: unknown): value is number;
export { isNumberFinite as isFinite, };
/**
 * Returns `value` if finite, else returns `defaultValue`.
 * @param value - The value to return if defined.
 * @param defaultValue - The value to return if `value` is not finite.
 */
export declare function finiteOrDefault(value: unknown, defaultValue: number): number;
/**
 * Returns `value` if defined, else returns `defaultValue`.
 * @param value - The value to return if defined.
 * @param defaultValue - The value to return if `value` is undefined.
 */
export declare function valueOrDefault<T>(value: T | undefined, defaultValue: T): T;
export declare const toPercentage: (value: number | string, dimension: number) => number;
export declare const toDimension: (value: number | string, dimension: number) => number;
/**
 * Calls `fn` with the given `args` in the scope defined by `thisArg` and returns the
 * value returned by `fn`. If `fn` is not a function, this method returns undefined.
 * @param fn - The function to call.
 * @param args - The arguments with which `fn` should be called.
 * @param [thisArg] - The value of `this` provided for the call to `fn`.
 */
export declare function callback<T extends (this: TA, ...restArgs: unknown[]) => R, TA, R>(fn: T | undefined, args: unknown[], thisArg?: TA): R | undefined;
/**
 * Note(SB) for performance sake, this method should only be used when loopable type
 * is unknown or in none intensive code (not called often and small loopable). Else
 * it's preferable to use a regular for() loop and save extra function calls.
 * @param loopable - The object or array to be iterated.
 * @param fn - The function to call for each item.
 * @param [thisArg] - The value of `this` provided for the call to `fn`.
 * @param [reverse] - If true, iterates backward on the loopable.
 */
export declare function each<T, TA>(loopable: Record<string, T>, fn: (this: TA, v: T, i: string) => void, thisArg?: TA, reverse?: boolean): void;
export declare function each<T, TA>(loopable: T[], fn: (this: TA, v: T, i: number) => void, thisArg?: TA, reverse?: boolean): void;
/**
 * Returns true if the `a0` and `a1` arrays have the same content, else returns false.
 * @param a0 - The array to compare
 * @param a1 - The array to compare
 * @private
 */
export declare function _elementsEqual(a0: ActiveDataPoint[], a1: ActiveDataPoint[]): boolean;
/**
 * Returns a deep copy of `source` without keeping references on objects and arrays.
 * @param source - The value to clone.
 */
export declare function clone<T>(source: T): T;
/**
 * The default merger when Chart.helpers.merge is called without merger option.
 * Note(SB): also used by mergeConfig and mergeScaleConfig as fallback.
 * @private
 */
export declare function _merger(key: string, target: AnyObject, source: AnyObject, options: AnyObject): void;
export interface MergeOptions {
    merger?: (key: string, target: AnyObject, source: AnyObject, options?: AnyObject) => void;
}
/**
 * Recursively deep copies `source` properties into `target` with the given `options`.
 * IMPORTANT: `target` is not cloned and will be updated with `source` properties.
 * @param target - The target object in which all sources are merged into.
 * @param source - Object(s) to merge into `target`.
 * @param [options] - Merging options:
 * @param [options.merger] - The merge method (key, target, source, options)
 * @returns The `target` object.
 */
export declare function merge<T>(target: T, source: [], options?: MergeOptions): T;
export declare function merge<T, S1>(target: T, source: S1, options?: MergeOptions): T & S1;
export declare function merge<T, S1>(target: T, source: [S1], options?: MergeOptions): T & S1;
export declare function merge<T, S1, S2>(target: T, source: [S1, S2], options?: MergeOptions): T & S1 & S2;
export declare function merge<T, S1, S2, S3>(target: T, source: [S1, S2, S3], options?: MergeOptions): T & S1 & S2 & S3;
export declare function merge<T, S1, S2, S3, S4>(target: T, source: [S1, S2, S3, S4], options?: MergeOptions): T & S1 & S2 & S3 & S4;
export declare function merge<T>(target: T, source: AnyObject[], options?: MergeOptions): AnyObject;
/**
 * Recursively deep copies `source` properties into `target` *only* if not defined in target.
 * IMPORTANT: `target` is not cloned and will be updated with `source` properties.
 * @param target - The target object in which all sources are merged into.
 * @param source - Object(s) to merge into `target`.
 * @returns The `target` object.
 */
export declare function mergeIf<T>(target: T, source: []): T;
export declare function mergeIf<T, S1>(target: T, source: S1): T & S1;
export declare function mergeIf<T, S1>(target: T, source: [S1]): T & S1;
export declare function mergeIf<T, S1, S2>(target: T, source: [S1, S2]): T & S1 & S2;
export declare function mergeIf<T, S1, S2, S3>(target: T, source: [S1, S2, S3]): T & S1 & S2 & S3;
export declare function mergeIf<T, S1, S2, S3, S4>(target: T, source: [S1, S2, S3, S4]): T & S1 & S2 & S3 & S4;
export declare function mergeIf<T>(target: T, source: AnyObject[]): AnyObject;
/**
 * Merges source[key] in target[key] only if target[key] is undefined.
 * @private
 */
export declare function _mergerIf(key: string, target: AnyObject, source: AnyObject): void;
/**
 * @private
 */
export declare function _deprecated(scope: string, value: unknown, previous: string, current: string): void;
/**
 * @private
 */
export declare function _splitKey(key: string): string[];
export declare function resolveObjectKey(obj: AnyObject, key: string): any;
/**
 * @private
 */
export declare function _capitalize(str: string): string;
export declare const defined: (value: unknown) => boolean;
export declare const isFunction: (value: unknown) => value is (...args: any[]) => any;
export declare const setsEqual: <T>(a: Set<T>, b: Set<T>) => boolean;
/**
 * @param e - The event
 * @private
 */
export declare function _isClickEvent(e: ChartEvent): boolean;


code:
import type { ChartArea } from '../types/index.js';
import type { SplinePoint } from '../types/geometric.js';
export declare function splineCurve(firstPoint: SplinePoint, middlePoint: SplinePoint, afterPoint: SplinePoint, t: number): {
    previous: SplinePoint;
    next: SplinePoint;
};
/**
 * This function calculates Bézier control points in a similar way than |splineCurve|,
 * but preserves monotonicity of the provided data and ensures no local extremums are added
 * between the dataset discrete points due to the interpolation.
 * See : https://en.wikipedia.org/wiki/Monotone_cubic_interpolation
 */
export declare function splineCurveMonotone(points: SplinePoint[], indexAxis?: 'x' | 'y'): void;
/**
 * @private
 */
export declare function _updateBezierControlPoints(points: SplinePoint[], options: any, area: ChartArea, loop: boolean, indexAxis: 'x' | 'y'): void;


code:
import type Chart from '../core/core.controller.js';
import type { ChartEvent } from '../types.js';
/**
 * Note: typedefs are auto-exported, so use a made-up `dom` namespace where
 * necessary to avoid duplicates with `export * from './helpers`; see
 * https://github.com/microsoft/TypeScript/issues/46011
 * @typedef { import('../core/core.controller.js').default } dom.Chart
 * @typedef { import('../../types').ChartEvent } ChartEvent
 */
/**
 * @private
 */
export declare function _isDomSupported(): boolean;
/**
 * @private
 */
export declare function _getParentNode(domNode: HTMLCanvasElement): HTMLCanvasElement;
export declare function getStyle(el: HTMLElement, property: string): string;
/**
 * Gets an event's x, y coordinates, relative to the chart area
 * @param event
 * @param chart
 * @returns x and y coordinates of the event
 */
export declare function getRelativePosition(event: Event | ChartEvent | TouchEvent | MouseEvent, chart: Chart): {
    x: number;
    y: number;
};
export declare function getMaximumSize(canvas: HTMLCanvasElement, bbWidth?: number, bbHeight?: number, aspectRatio?: number): {
    width: number;
    height: number;
};
/**
 * @param chart
 * @param forceRatio
 * @param forceStyle
 * @returns True if the canvas context size or transformation has changed.
 */
export declare function retinaScale(chart: Chart, forceRatio: number, forceStyle?: boolean): boolean | void;
/**
 * Detects support for options object argument in addEventListener.
 * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
 * @private
 */
export declare const supportsEventListenerOptions: boolean;
/**
 * The "used" size is the final value of a dimension property after all calculations have
 * been performed. This method uses the computed style of `element` but returns undefined
 * if the computed style is not expressed in pixels. That can happen in some cases where
 * `element` has a size relative to its parent and this last one is not yet displayed,
 * for example because of `display: none` on a parent node.
 * @see https://developer.mozilla.org/en-US/docs/Web/CSS/used_value
 * @returns Size in pixels or undefined if unknown.
 */
export declare function readUsedSize(element: HTMLElement, property: 'width' | 'height'): number | undefined;


code:
/**
 * Easing functions adapted from Robert Penner's easing equations.
 * @namespace Chart.helpers.easing.effects
 * @see http://www.robertpenner.com/easing/
 */
declare const effects: {
    readonly linear: (t: number) => number;
    readonly easeInQuad: (t: number) => number;
    readonly easeOutQuad: (t: number) => number;
    readonly easeInOutQuad: (t: number) => number;
    readonly easeInCubic: (t: number) => number;
    readonly easeOutCubic: (t: number) => number;
    readonly easeInOutCubic: (t: number) => number;
    readonly easeInQuart: (t: number) => number;
    readonly easeOutQuart: (t: number) => number;
    readonly easeInOutQuart: (t: number) => number;
    readonly easeInQuint: (t: number) => number;
    readonly easeOutQuint: (t: number) => number;
    readonly easeInOutQuint: (t: number) => number;
    readonly easeInSine: (t: number) => number;
    readonly easeOutSine: (t: number) => number;
    readonly easeInOutSine: (t: number) => number;
    readonly easeInExpo: (t: number) => number;
    readonly easeOutExpo: (t: number) => number;
    readonly easeInOutExpo: (t: number) => number;
    readonly easeInCirc: (t: number) => number;
    readonly easeOutCirc: (t: number) => number;
    readonly easeInOutCirc: (t: number) => number;
    readonly easeInElastic: (t: number) => number;
    readonly easeOutElastic: (t: number) => number;
    readonly easeInOutElastic: (t: number) => number;
    readonly easeInBack: (t: number) => number;
    readonly easeOutBack: (t: number) => number;
    readonly easeInOutBack: (t: number) => number;
    readonly easeInBounce: (t: number) => number;
    readonly easeOutBounce: (t: number) => number;
    readonly easeInOutBounce: (t: number) => number;
};
export type EasingFunction = keyof typeof effects;
export default effects;


code:
import type { ChartMeta, PointElement } from '../types/index.js';
export declare function fontString(pixelSize: number, fontStyle: string, fontFamily: string): string;
/**
* Request animation polyfill
*/
export declare const requestAnimFrame: (((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame) | ((callback: any) => any);
/**
 * Throttles calling `fn` once per animation frame
 * Latest arguments are used on the actual call
 */
export declare function throttled<TArgs extends Array<any>>(fn: (...args: TArgs) => void, thisArg: any): (...args: TArgs) => void;
/**
 * Debounces calling `fn` for `delay` ms
 */
export declare function debounce<TArgs extends Array<any>>(fn: (...args: TArgs) => void, delay: number): (...args: TArgs) => number;
/**
 * Converts 'start' to 'left', 'end' to 'right' and others to 'center'
 * @private
 */
export declare const _toLeftRightCenter: (align: 'start' | 'end' | 'center') => "center" | "left" | "right";
/**
 * Returns `start`, `end` or `(start + end) / 2` depending on `align`. Defaults to `center`
 * @private
 */
export declare const _alignStartEnd: (align: 'start' | 'end' | 'center', start: number, end: number) => number;
/**
 * Returns `left`, `right` or `(left + right) / 2` depending on `align`. Defaults to `left`
 * @private
 */
export declare const _textX: (align: 'left' | 'right' | 'center', left: number, right: number, rtl: boolean) => number;
/**
 * Return start and count of visible points.
 * @private
 */
export declare function _getStartAndCountOfVisiblePoints(meta: ChartMeta<'line' | 'scatter'>, points: PointElement[], animationsDisabled: boolean): {
    start: number;
    count: number;
};
/**
 * Checks if the scale ranges have changed.
 * @param {object} meta - dataset meta.
 * @returns {boolean}
 * @private
 */
export declare function _scaleRangesChanged(meta: any): boolean;


code:
import type { Point, SplinePoint } from '../types/geometric.js';
/**
 * @private
 */
export declare function _pointInLine(p1: Point, p2: Point, t: number, mode?: any): {
    x: number;
    y: number;
};
/**
 * @private
 */
export declare function _steppedInterpolation(p1: Point, p2: Point, t: number, mode: 'middle' | 'after' | unknown): {
    x: number;
    y: number;
};
/**
 * @private
 */
export declare function _bezierInterpolation(p1: SplinePoint, p2: SplinePoint, t: number, mode?: any): {
    x: number;
    y: number;
};


code: export declare function formatNumber(num: number, locale: string, options?: Intl.NumberFormatOptions): string;