charjs 4.4.6

package/dist/helpers/helpers.easing.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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;

package/dist/helpers/helpers.extras.d.ts

@@ -0,0 +1,45 @@
+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;

package/dist/helpers/helpers.interpolation.d.ts

@@ -0,0 +1,22 @@
+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;
+};

package/dist/helpers/helpers.intl.d.ts

@@ -0,0 +1 @@
+export declare function formatNumber(num: number, locale: string, options?: Intl.NumberFormatOptions): string;

package/dist/helpers/helpers.math.d.ts

@@ -0,0 +1,84 @@
+import type { Point } from '../types/geometric.js';
+/**
+ * @alias Chart.helpers.math
+ * @namespace
+ */
+export declare const PI: number;
+export declare const TAU: number;
+export declare const PITAU: number;
+export declare const INFINITY: number;
+export declare const RAD_PER_DEG: number;
+export declare const HALF_PI: number;
+export declare const QUARTER_PI: number;
+export declare const TWO_THIRDS_PI: number;
+export declare const log10: (x: number) => number;
+export declare const sign: (x: number) => number;
+export declare function almostEquals(x: number, y: number, epsilon: number): boolean;
+/**
+ * Implementation of the nice number algorithm used in determining where axis labels will go
+ */
+export declare function niceNum(range: number): number;
+/**
+ * Returns an array of factors sorted from 1 to sqrt(value)
+ * @private
+ */
+export declare function _factorize(value: number): number[];
+export declare function isNumber(n: unknown): n is number;
+export declare function almostWhole(x: number, epsilon: number): boolean;
+/**
+ * @private
+ */
+export declare function _setMinAndMaxByKey(array: Record<string, number>[], target: {
+    min: number;
+    max: number;
+}, property: string): void;
+export declare function toRadians(degrees: number): number;
+export declare function toDegrees(radians: number): number;
+/**
+ * Returns the number of decimal places
+ * i.e. the number of digits after the decimal point, of the value of this Number.
+ * @param x - A number.
+ * @returns The number of decimal places.
+ * @private
+ */
+export declare function _decimalPlaces(x: number): number;
+export declare function getAngleFromPoint(centrePoint: Point, anglePoint: Point): {
+    angle: number;
+    distance: number;
+};
+export declare function distanceBetweenPoints(pt1: Point, pt2: Point): number;
+/**
+ * Shortest distance between angles, in either direction.
+ * @private
+ */
+export declare function _angleDiff(a: number, b: number): number;
+/**
+ * Normalize angle to be between 0 and 2*PI
+ * @private
+ */
+export declare function _normalizeAngle(a: number): number;
+/**
+ * @private
+ */
+export declare function _angleBetween(angle: number, start: number, end: number, sameAngleIsFullCircle?: boolean): boolean;
+/**
+ * Limit `value` between `min` and `max`
+ * @param value
+ * @param min
+ * @param max
+ * @private
+ */
+export declare function _limitValue(value: number, min: number, max: number): number;
+/**
+ * @param {number} value
+ * @private
+ */
+export declare function _int16Range(value: number): number;
+/**
+ * @param value
+ * @param start
+ * @param end
+ * @param [epsilon]
+ * @private
+ */
+export declare function _isBetween(value: number, start: number, end: number, epsilon?: number): boolean;

package/dist/helpers/helpers.options.d.ts

@@ -0,0 +1,97 @@
+import type { ChartArea, FontSpec, Point } from '../types/index.js';
+import type { TRBL, TRBLCorners } from '../types/geometric.js';
+/**
+ * @alias Chart.helpers.options
+ * @namespace
+ */
+/**
+ * Converts the given line height `value` in pixels for a specific font `size`.
+ * @param value - The lineHeight to parse (eg. 1.6, '14px', '75%', '1.6em').
+ * @param size - The font size (in pixels) used to resolve relative `value`.
+ * @returns The effective line height in pixels (size * 1.2 if value is invalid).
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/line-height
+ * @since 2.7.0
+ */
+export declare function toLineHeight(value: number | string, size: number): number;
+/**
+ * @param value
+ * @param props
+ */
+export declare function _readValueToProps<K extends string>(value: number | Record<K, number>, props: K[]): Record<K, number>;
+export declare function _readValueToProps<K extends string, T extends string>(value: number | Record<K & T, number>, props: Record<T, K>): Record<T, number>;
+/**
+ * Converts the given value into a TRBL object.
+ * @param value - If a number, set the value to all TRBL component,
+ *  else, if an object, use defined properties and sets undefined ones to 0.
+ *  x / y are shorthands for same value for left/right and top/bottom.
+ * @returns The padding values (top, right, bottom, left)
+ * @since 3.0.0
+ */
+export declare function toTRBL(value: number | TRBL | Point): Record<"left" | "top" | "bottom" | "right", number>;
+/**
+ * Converts the given value into a TRBL corners object (similar with css border-radius).
+ * @param value - If a number, set the value to all TRBL corner components,
+ *  else, if an object, use defined properties and sets undefined ones to 0.
+ * @returns The TRBL corner values (topLeft, topRight, bottomLeft, bottomRight)
+ * @since 3.0.0
+ */
+export declare function toTRBLCorners(value: number | TRBLCorners): Record<"topLeft" | "topRight" | "bottomLeft" | "bottomRight", number>;
+/**
+ * Converts the given value into a padding object with pre-computed width/height.
+ * @param value - If a number, set the value to all TRBL component,
+ *  else, if an object, use defined properties and sets undefined ones to 0.
+ *  x / y are shorthands for same value for left/right and top/bottom.
+ * @returns The padding values (top, right, bottom, left, width, height)
+ * @since 2.7.0
+ */
+export declare function toPadding(value?: number | TRBL): ChartArea;
+/**
+ * Parses font options and returns the font object.
+ * @param options - A object that contains font options to be parsed.
+ * @param fallback - A object that contains fallback font options.
+ * @return The font object.
+ * @private
+ */
+export declare function toFont(options: Partial<FontSpec>, fallback?: Partial<FontSpec>): {
+    family: string;
+    lineHeight: number;
+    size: number;
+    style: "normal" | "inherit" | "italic" | "oblique" | "initial";
+    weight: number | "bold" | "normal" | "lighter" | "bolder";
+    string: string;
+};
+/**
+ * Evaluates the given `inputs` sequentially and returns the first defined value.
+ * @param inputs - An array of values, falling back to the last value.
+ * @param context - If defined and the current value is a function, the value
+ * is called with `context` as first argument and the result becomes the new input.
+ * @param index - If defined and the current value is an array, the value
+ * at `index` become the new input.
+ * @param info - object to return information about resolution in
+ * @param info.cacheable - Will be set to `false` if option is not cacheable.
+ * @since 2.7.0
+ */
+export declare function resolve(inputs: Array<unknown>, context?: object, index?: number, info?: {
+    cacheable: boolean;
+}): unknown;
+/**
+ * @param minmax
+ * @param grace
+ * @param beginAtZero
+ * @private
+ */
+export declare function _addGrace(minmax: {
+    min: number;
+    max: number;
+}, grace: number | string, beginAtZero: boolean): {
+    min: number;
+    max: number;
+};
+/**
+ * Create a context inheriting parentContext
+ * @param parentContext
+ * @param context
+ * @returns
+ */
+export declare function createContext<T extends object>(parentContext: null, context: T): T;
+export declare function createContext<T extends object, P extends T>(parentContext: P, context: T): P & T;

package/dist/helpers/helpers.rtl.d.ts

@@ -0,0 +1,10 @@
+export interface RTLAdapter {
+    x(x: number): number;
+    setWidth(w: number): void;
+    textAlign(align: 'center' | 'left' | 'right'): 'center' | 'left' | 'right';
+    xPlus(x: number, value: number): number;
+    leftForLtr(x: number, itemWidth: number): number;
+}
+export declare function getRtlAdapter(rtl: boolean, rectX: number, width: number): RTLAdapter;
+export declare function overrideTextDirection(ctx: CanvasRenderingContext2D, direction: 'ltr' | 'rtl'): void;
+export declare function restoreTextDirection(ctx: CanvasRenderingContext2D, original?: [string, string]): void;

package/dist/helpers/helpers.segment.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Returns the sub-segment(s) of a line segment that fall in the given bounds
+ * @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} [segment.style] - segment style
+ * @param {PointElement[]} points - the points that this segment refers to
+ * @param {object} [bounds]
+ * @param {string} bounds.property - the property of a `PointElement` we are bounding. `x`, `y` or `angle`.
+ * @param {number} bounds.start - start value of the property
+ * @param {number} bounds.end - end value of the property
+ * @private
+ **/
+export function _boundSegment(segment: {
+    start: number;
+    end: number;
+    loop: boolean;
+    style?: object;
+}, points: PointElement[], bounds?: {
+    property: string;
+    start: number;
+    end: number;
+}): {
+    start: number;
+    end: number;
+    loop: boolean;
+    style?: object;
+}[];
+/**
+ * Returns the segments of the line that are inside given bounds
+ * @param {LineElement} line
+ * @param {object} [bounds]
+ * @param {string} bounds.property - the property we are bounding with. `x`, `y` or `angle`.
+ * @param {number} bounds.start - start value of the `property`
+ * @param {number} bounds.end - end value of the `property`
+ * @private
+ */
+export function _boundSegments(line: LineElement, bounds?: {
+    property: string;
+    start: number;
+    end: number;
+}): {
+    start: number;
+    end: number;
+    loop: boolean;
+    style?: object;
+}[];
+/**
+ * Compute the continuous segments that define the whole line
+ * There can be skipped points within a segment, if spanGaps is true.
+ * @param {LineElement} line
+ * @param {object} [segmentOptions]
+ * @return {Segment[]}
+ * @private
+ */
+export function _computeSegments(line: LineElement, segmentOptions?: object): Segment[];
+export type LineElement = import('../elements/element.line.js').default;
+export type PointElement = import('../elements/element.point.js').default;
+export type Segment = {
+    start: number;
+    end: number;
+    loop: boolean;
+    style?: any;
+};

package/dist/helpers/index.d.ts

@@ -0,0 +1,15 @@
+export * from './helpers.color.js';
+export * from './helpers.core.js';
+export * from './helpers.canvas.js';
+export * from './helpers.collection.js';
+export * from './helpers.config.js';
+export * from './helpers.curve.js';
+export * from './helpers.dom.js';
+export { default as easingEffects } from './helpers.easing.js';
+export * from './helpers.extras.js';
+export * from './helpers.interpolation.js';
+export * from './helpers.intl.js';
+export * from './helpers.options.js';
+export * from './helpers.math.js';
+export * from './helpers.rtl.js';
+export * from './helpers.segment.js';

package/dist/helpers.cjs

@@ -0,0 +1,135 @@
+/*!
+ * Chart.js v4.4.6
+ * 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

package/dist/helpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/helpers.js

@@ -0,0 +1,9 @@
+/*!
+ * Chart.js v4.4.6
+ * https://www.chartjs.org
+ * (c) 2024 Chart.js Contributors
+ * Released under the MIT License
+ */
+export { H as HALF_PI, b2 as INFINITY, P as PI, b1 as PITAU, b4 as QUARTER_PI, b3 as RAD_PER_DEG, T as TAU, b5 as TWO_THIRDS_PI, R as _addGrace, X as _alignPixel, a2 as _alignStartEnd, p as _angleBetween, b6 as _angleDiff, _ as _arrayUnique, a8 as _attachContext, as as _bezierCurveTo, ap as _bezierInterpolation, ax as _boundSegment, an as _boundSegments, a5 as _capitalize, am as _computeSegments, a9 as _createResolver, aK as _decimalPlaces, aV as _deprecated, aa as _descriptors, ah as _elementsEqual, N as _factorize, aO as _filterBetween, I as _getParentNode, q as _getStartAndCountOfVisiblePoints, W as _int16Range, aj as _isBetween, ai as _isClickEvent, M as _isDomSupported, C as _isPointInArea, S as _limitValue, aN as _longestText, aP as _lookup, B as _lookupByKey, V as _measureText, aT as _merger, aU as _mergerIf, ay as _normalizeAngle, y as _parseObjectDataRadialScale, aq as _pointInLine, ak as _readValueToProps, A as _rlookupByKey, w as _scaleRangesChanged, aG as _setMinAndMaxByKey, aW as _splitKey, ao as _steppedInterpolation, ar as _steppedLineTo, aB as _textX, a1 as _toLeftRightCenter, al as _updateBezierControlPoints, au as addRoundedRectPath, aJ as almostEquals, aI as almostWhole, Q as callback, af as clearCanvas, Y as clipArea, aS as clone, c as color, j as createContext, ad as debounce, h as defined, aE as distanceBetweenPoints, at as drawPoint, aD as drawPointLegend, F as each, e as easingEffects, O as finiteOrDefault, a$ as fontString, o as formatNumber, D as getAngleFromPoint, aR as getHoverColor, G as getMaximumSize, z as getRelativePosition, az as getRtlAdapter, a_ as getStyle, b as isArray, g as isFinite, a7 as isFunction, k as isNullOrUndef, x as isNumber, i as isObject, aQ as isPatternOrGradient, l as listenArrayEvents, aM as log10, a4 as merge, ab as mergeIf, aH as niceNum, aF as noop, aA as overrideTextDirection, J as readUsedSize, Z as renderText, r as requestAnimFrame, a as resolve, f as resolveObjectKey, aC as restoreTextDirection, ae as retinaScale, ag as setsEqual, s as sign, aY as splineCurve, aZ as splineCurveMonotone, K as supportsEventListenerOptions, L as throttled, U as toDegrees, n as toDimension, a0 as toFont, aX as toFontString, b0 as toLineHeight, E as toPadding, m as toPercentage, t as toRadians, av as toTRBL, aw as toTRBLCorners, ac as uid, $ as unclipArea, u as unlistenArrayEvents, v as valueOrDefault } from './chunks/helpers.segment.js';
+import '@kurkle/color';
+//# sourceMappingURL=helpers.js.map

package/dist/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from './controllers/index.js';
+export * from './core/index.js';
+export * from './elements/index.js';
+export * from './platform/index.js';
+export * from './plugins/index.js';
+export * from './scales/index.js';
+import * as controllers from './controllers/index.js';
+import * as elements from './elements/index.js';
+import * as plugins from './plugins/index.js';
+import * as scales from './scales/index.js';
+export { controllers, elements, plugins, scales, };
+export declare const registerables: (typeof controllers | typeof elements | typeof plugins | typeof scales)[];

package/dist/index.umd.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @namespace Chart
+ */
+import Chart from './core/core.controller.js';
+export default Chart;

package/dist/platform/index.d.ts

@@ -0,0 +1,5 @@
+export function _detectPlatform(canvas: any): typeof BasicPlatform | typeof DomPlatform;
+import BasicPlatform from "./platform.basic.js";
+import DomPlatform from "./platform.dom.js";
+import BasePlatform from "./platform.base.js";
+export { BasePlatform, BasicPlatform, DomPlatform };

package/dist/platform/platform.base.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @typedef { import('../core/core.controller.js').default } Chart
+ */
+/**
+ * Abstract class that allows abstracting platform dependencies away from the chart.
+ */
+export default class BasePlatform {
+    /**
+       * Called at chart construction time, returns a context2d instance implementing
+       * the [W3C Canvas 2D Context API standard]{@link https://www.w3.org/TR/2dcontext/}.
+       * @param {HTMLCanvasElement} canvas - The canvas from which to acquire context (platform specific)
+       * @param {number} [aspectRatio] - The chart options
+       */
+    acquireContext(canvas: HTMLCanvasElement, aspectRatio?: number): void;
+    /**
+       * Called at chart destruction time, releases any resources associated to the context
+       * previously returned by the acquireContext() method.
+       * @param {CanvasRenderingContext2D} context - The context2d instance
+       * @returns {boolean} true if the method succeeded, else false
+       */
+    releaseContext(context: CanvasRenderingContext2D): boolean;
+    /**
+       * Registers the specified listener on the given chart.
+       * @param {Chart} chart - Chart from which to listen for event
+       * @param {string} type - The ({@link ChartEvent}) type to listen for
+       * @param {function} listener - Receives a notification (an object that implements
+       * the {@link ChartEvent} interface) when an event of the specified type occurs.
+       */
+    addEventListener(chart: Chart, type: string, listener: Function): void;
+    /**
+       * Removes the specified listener previously registered with addEventListener.
+       * @param {Chart} chart - Chart from which to remove the listener
+       * @param {string} type - The ({@link ChartEvent}) type to remove
+       * @param {function} listener - The listener function to remove from the event target.
+       */
+    removeEventListener(chart: Chart, type: string, listener: Function): void;
+    /**
+       * @returns {number} the current devicePixelRatio of the device this platform is connected to.
+       */
+    getDevicePixelRatio(): number;
+    /**
+       * Returns the maximum size in pixels of given canvas element.
+       * @param {HTMLCanvasElement} element
+       * @param {number} [width] - content width of parent element
+       * @param {number} [height] - content height of parent element
+       * @param {number} [aspectRatio] - aspect ratio to maintain
+       */
+    getMaximumSize(element: HTMLCanvasElement, width?: number, height?: number, aspectRatio?: number): {
+        width: number;
+        height: number;
+    };
+    /**
+       * @param {HTMLCanvasElement} canvas
+       * @returns {boolean} true if the canvas is attached to the platform, false if not.
+       */
+    isAttached(canvas: HTMLCanvasElement): boolean;
+    /**
+     * Updates config with platform specific requirements
+     * @param {import('../core/core.config.js').default} config
+     */
+    updateConfig(config: import('../core/core.config.js').default): void;
+}
+export type Chart = import('../core/core.controller.js').default;

package/dist/platform/platform.basic.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Platform class for charts without access to the DOM or to many element properties
+ * This platform is used by default for any chart passed an OffscreenCanvas.
+ * @extends BasePlatform
+ */
+export default class BasicPlatform extends BasePlatform {
+    acquireContext(item: any): any;
+    updateConfig(config: any): void;
+}
+import BasePlatform from "./platform.base.js";

package/dist/platform/platform.dom.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Platform class for charts that can access the DOM and global window/document properties
+ * @extends BasePlatform
+ */
+export default class DomPlatform extends BasePlatform {
+    /**
+       * @param {HTMLCanvasElement} canvas
+       * @param {number} [aspectRatio]
+       * @return {CanvasRenderingContext2D|null}
+       */
+    acquireContext(canvas: HTMLCanvasElement, aspectRatio?: number): CanvasRenderingContext2D | null;
+    /**
+       * @param {Chart} chart
+       * @param {string} type
+       */
+    removeEventListener(chart: Chart, type: string): void;
+}
+export type Chart = import('../core/core.controller.js').default;
+import BasePlatform from "./platform.base.js";