highcharts 13.0.0 → 13.0.2

package/esm/highcharts-more.src.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LicenseRef-Highcharts
 /**
- * @license Highcharts JS v13.0.0 (2026-06-11)
+ * @license Highcharts JS v13.0.2 (2026-08-27)
  * @module highcharts/highcharts-more
  * @requires highcharts
  *
@@ -11,14 +11,14 @@
  */
 import * as __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_c57973fa__ from "./highcharts.src.js";
 /******/ // The require scope
-/******/ var __webpack_require__ = {};
+/******/ const __webpack_require__ = {};
 /******/ 
 /************************************************************************/
 /******/ /* webpack/runtime/compat get default export */
 /******/ (() => {
 /******/ 	// getDefaultExport function for compatibility with non-harmony modules
 /******/ 	__webpack_require__.n = (module) => {
-/******/ 		var getter = module && module.__esModule ?
+/******/ 		const getter = module && module.__esModule ?
 /******/ 			() => (module['default']) :
 /******/ 			() => (module);
 /******/ 		__webpack_require__.d(getter, { a: getter });
@@ -28,11 +28,26 @@ import * as __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_c57973fa__ from "./high
 /******/ 
 /******/ /* webpack/runtime/define property getters */
 /******/ (() => {
-/******/ 	// define getter functions for harmony exports
+/******/ 	// define getter/value functions for harmony exports
 /******/ 	__webpack_require__.d = (exports, definition) => {
-/******/ 		for(var key in definition) {
-/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 		if(Array.isArray(definition)) {
+/******/ 			var i = 0;
+/******/ 			while(i < definition.length) {
+/******/ 				var key = definition[i++];
+/******/ 				var binding = definition[i++];
+/******/ 				if(!__webpack_require__.o(exports, key)) {
+/******/ 					if(binding === 0) {
+/******/ 						Object.defineProperty(exports, key, { enumerable: true, value: definition[i++] });
+/******/ 					} else {
+/******/ 						Object.defineProperty(exports, key, { enumerable: true, get: binding });
+/******/ 					}
+/******/ 				} else if(binding === 0) { i++; }
+/******/ 			}
+/******/ 		} else {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
 /******/ 			}
 /******/ 		}
 /******/ 	};
@@ -44,7 +59,6 @@ import * as __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_c57973fa__ from "./high
 /******/ })();
 /******/ 
 /************************************************************************/
-var __webpack_exports__ = {};
 
 ;// external ["./highcharts.src.js","default"]
 const external_highcharts_src_js_default_namespaceObject = __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_c57973fa__["default"];
@@ -69,7 +83,7 @@ var external_highcharts_src_js_default_SeriesRegistry_default = /*#__PURE__*/__w
 const { deg2rad } = (external_highcharts_src_js_default_default());
 
 /**
- * @private
+ * @internal
  */
 var CenteredUtilities;
 (function (CenteredUtilities) {
@@ -87,7 +101,7 @@ var CenteredUtilities;
      * Get the center of the pie based on the size and center options relative
      * to the plot area. Borrowed by the polar and gauge series types.
      *
-     * @private
+     * @internal
      * @function Highcharts.CenteredSeriesMixin.getCenter
      */
     function getCenter() {
@@ -100,11 +114,13 @@ var CenteredUtilities;
             innerSize = parseFloat(innerSize);
         }
         const positions = [
-            (0,external_highcharts_src_js_default_namespaceObject.pick)(centerOption?.[0], '50%'),
-            (0,external_highcharts_src_js_default_namespaceObject.pick)(centerOption?.[1], '50%'),
+            (centerOption?.[0] ?? '50%'),
+            (centerOption?.[1] ?? '50%'),
             // Prevent from negative values
-            (0,external_highcharts_src_js_default_namespaceObject.pick)(size && size < 0 ? void 0 : options.size, '100%'),
-            (0,external_highcharts_src_js_default_namespaceObject.pick)(innerSize && innerSize < 0 ? void 0 : options.innerSize || 0, '0%')
+            ((size && size < 0 ? void 0 : options.size) ?? '100%'),
+            ((innerSize && innerSize < 0 ?
+                void 0 :
+                options.innerSize || 0) ?? '0%')
         ];
         for (i = 0; i < 4; ++i) {
             value = positions[i];
@@ -132,7 +148,7 @@ var CenteredUtilities;
      * GetStartAndEndRadians - Calculates start and end angles in radians.
      * Used in series types such as pie and sunburst.
      *
-     * @private
+     * @internal
      * @function Highcharts.CenteredSeriesMixin.getStartAndEndRadians
      *
      * @param {number} [start]
@@ -164,6 +180,7 @@ var CenteredUtilities;
  *  Default Export
  *
  * */
+/** @internal */
 /* harmony default export */ const Series_CenteredUtilities = (CenteredUtilities);
 /* *
  *
@@ -171,7 +188,7 @@ var CenteredUtilities;
  *
  * */
 /**
- * @private
+ * @internal
  * @interface Highcharts.RadianAngles
  */ /**
 * @name Highcharts.RadianAngles#end
@@ -304,7 +321,7 @@ function onPointerBeforeGetHoverData(eventArgs) {
         eventArgs.filter = function (s) {
             return (s.visible &&
                 !(!eventArgs.shared && s.directTouch) && // #3821
-                (0,external_highcharts_src_js_default_namespaceObject.pick)(s.options.enableMouseTracking, true) &&
+                (s.options.enableMouseTracking ?? true) &&
                 (!chart.hoverPane || s.xAxis.pane === chart.hoverPane));
         };
     }
@@ -353,7 +370,7 @@ const { defaultOptions } = (external_highcharts_src_js_default_default());
  * @sample {highcharts} highcharts/series-solidgauge/pane-borderradius
  *         Solid gauge with background settings
  *
- * @type         {*|Array<*>}
+ * @type         {null|*|Array<*>}
  * @requires     highcharts-more
  * @optionparent pane.background
  */
@@ -1037,6 +1054,139 @@ class AreaRangePoint extends AreaPoint {
  */
 ''; // Keeps doclets above in JS file.
 
+;// external ["./highcharts.src.js","default","Series","types","column"]
+const external_highcharts_src_js_default_Series_types_column_namespaceObject = __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_c57973fa__["default"].Series.types.column;
+var external_highcharts_src_js_default_Series_types_column_default = /*#__PURE__*/__webpack_require__.n(external_highcharts_src_js_default_Series_types_column_namespaceObject);
+;// ./code/es-modules/Series/RangeDataLabel.js
+/* *
+ *
+ *  (c) 2010-2026 Highsoft AS
+ *  Author: Andrzej Buleczka
+ *
+ * */
+
+
+
+/* *
+ *
+ *  Declarations
+ *
+ * */
+var RangeDataLabel;
+(function (RangeDataLabel) {
+    const plotYKeys = {
+        close: ['plotClose'],
+        high: ['highPlot', 'plotHigh'],
+        low: ['lowPlot', 'plotLow'],
+        median: ['medianPlot'],
+        open: ['plotOpen'],
+        q1: ['q1Plot'],
+        q3: ['q3Plot'],
+        y: ['plotY']
+    };
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    function getPointPlotY(point, pointValKey) {
+        const keys = plotYKeys[pointValKey] ?? [];
+        for (const key of keys) {
+            const value = point[key];
+            if ((0,external_highcharts_src_js_default_namespaceObject.isNumber)(value)) {
+                return value;
+            }
+        }
+    }
+    function getBelow(point, options, plotY) {
+        const plotHigh = getPointPlotY(point, 'high'), plotLow = getPointPlotY(point, 'low');
+        if ((0,external_highcharts_src_js_default_namespaceObject.isNumber)(plotHigh) && (0,external_highcharts_src_js_default_namespaceObject.isNumber)(plotLow)) {
+            return options.inside ?
+                plotY === Math.min(plotHigh, plotLow) :
+                plotY === Math.max(plotHigh, plotLow);
+        }
+        return false;
+    }
+    function compose(SeriesClass) {
+        const seriesProto = SeriesClass.prototype;
+        seriesProto.alignDataLabel = alignDataLabel;
+        return SeriesClass;
+    }
+    RangeDataLabel.compose = compose;
+    /**
+     * Default formatter for range series data labels. Renders the value of
+     * the point key the label is aligned to, so the legacy high and low
+     * labels keep showing their respective values without an explicit format.
+     * Does not modify `point.y`. Falls back to `point.y` (the value of
+     * `series.pointValKey`) for an unresolved key.
+     * @internal
+     */
+    function formatter(options) {
+        const rawValue = options.alignToKey ?
+            this.getNestedProperty(options.alignToKey) :
+            this.y, value = (0,external_highcharts_src_js_default_namespaceObject.isNumber)(rawValue) ? rawValue : this.y;
+        return (0,external_highcharts_src_js_default_namespaceObject.isNumber)(value) ?
+            this.series.chart.numberFormatter(value, -1) :
+            '';
+    }
+    RangeDataLabel.formatter = formatter;
+    /**
+     * Rewrite a label's `format` so that `{y}` and `{point.y}` references
+     * resolve to the value of the point key the label is aligned to, keeping
+     * the legacy per-label `{y}` behavior of range data labels.
+     * @internal
+     */
+    function applyAlignToKeyValue(options) {
+        const { alignToKey, format } = options;
+        // An explicit `format` ignores `alignToKey`, so its `{y}` (and
+        // `{point.y}`) tokens point at the whole point. Rewrite them to the
+        // aligned key so each range label keeps rendering its own value.
+        // The default formatter already reads `alignToKey`.
+        if (alignToKey && format) {
+            options.format = format.replace(/\{(?:point\.)?y([:}])/g, '{point.' + alignToKey + '$1');
+        }
+    }
+    RangeDataLabel.applyAlignToKeyValue = applyAlignToKeyValue;
+    function resolveAlignToKey(series, rawKey) {
+        return rawKey && series.pointArrayMap.indexOf(rawKey) > -1 ?
+            rawKey :
+            series.pointValKey;
+    }
+    RangeDataLabel.resolveAlignToKey = resolveAlignToKey;
+    function alignDataLabel(point, dataLabel, options, alignTo, isNew) {
+        const series = this, alignToKey = resolveAlignToKey(series, options.alignToKey), plotY = getPointPlotY(point, alignToKey), shapeArgs = point.shapeArgs, originalPlotY = point.plotY, originalDlBox = point.dlBox, originalBelow = point.below;
+        if ((0,external_highcharts_src_js_default_namespaceObject.isNumber)(plotY)) {
+            point.plotY = plotY;
+            if (shapeArgs && !options.inside) {
+                point.dlBox = {
+                    x: shapeArgs.x ?? 0,
+                    y: (0,external_highcharts_src_js_default_namespaceObject.crisp)(plotY, series.borderWidth, series.chart.inverted),
+                    width: shapeArgs.width ?? 0,
+                    height: 0
+                };
+            }
+            const below = point.below = getBelow(point, options, plotY);
+            if (series.chart.inverted) {
+                options.align ?? (options.align = below ? 'right' : 'left');
+            }
+            else {
+                options.verticalAlign ?? (options.verticalAlign = below ? 'top' : 'bottom');
+            }
+        }
+        external_highcharts_src_js_default_Series_types_column_default().prototype.alignDataLabel.call(series, point, dataLabel, options, alignTo, isNew);
+        point.plotY = originalPlotY;
+        point.dlBox = originalDlBox;
+        point.below = originalBelow;
+    }
+    RangeDataLabel.alignDataLabel = alignDataLabel;
+})(RangeDataLabel || (RangeDataLabel = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+/* harmony default export */ const Series_RangeDataLabel = (RangeDataLabel);
+
 ;// ./code/es-modules/Series/AreaRange/AreaRangeSeries.js
 /* *
  *
@@ -1054,7 +1204,8 @@ class AreaRangePoint extends AreaPoint {
 
 const { noop } = (external_highcharts_src_js_default_default());
 
-const { area: AreaSeries, area: { prototype: AreaRangeSeries_areaProto }, column: { prototype: columnProto } } = (external_highcharts_src_js_default_SeriesRegistry_default()).seriesTypes;
+
+const { area: AreaSeries, area: { prototype: AreaRangeSeries_areaProto } } = (external_highcharts_src_js_default_SeriesRegistry_default()).seriesTypes;
 
 /* *
  *
@@ -1139,12 +1290,10 @@ const areaRangeSeriesOptions = {
     trackByArea: true,
     /**
      * Extended data labels for range series types. Range series data
-     * labels use no `x` and `y` options. Instead, they have `xLow`,
-     * `xHigh`, `yLow` and `yHigh` options to allow the higher and lower
-     * data label sets individually.
+     * labels can be positioned individually by defining them as an array
+     * and setting `alignToKey` to `high` or `low`.
      *
      * @declare Highcharts.SeriesAreaRangeDataLabelsOptionsObject
-     * @exclude x, y
      * @since   2.3.0
      * @product highcharts highstock
      *
@@ -1152,39 +1301,103 @@ const areaRangeSeriesOptions = {
      */
     dataLabels: {
         align: void 0,
+        formatter: Series_RangeDataLabel.formatter,
         verticalAlign: void 0,
         /**
          * X offset of the lower data labels relative to the point value.
          *
+         * Deprecated. Use a data labels array with `alignToKey: 'low'` and
+         * the regular `x` option instead.
+         *
          * @sample highcharts/plotoptions/arearange-datalabels/
          *         Data labels on range series
          * @sample highcharts/plotoptions/arearange-datalabels/
          *         Data labels on range series
+         * @deprecated 13.0.1
          */
         xLow: 0,
         /**
          * X offset of the higher data labels relative to the point value.
          *
+         * Deprecated. Use a data labels array with `alignToKey: 'high'` and
+         * the regular `x` option instead.
+         *
          * @sample highcharts/plotoptions/arearange-datalabels/
          *         Data labels on range series
+         * @deprecated 13.0.1
          */
         xHigh: 0,
         /**
          * Y offset of the lower data labels relative to the point value.
          *
+         * Deprecated. Use a data labels array with `alignToKey: 'low'` and
+         * the regular `y` option instead.
+         *
          * @sample highcharts/plotoptions/arearange-datalabels/
          *         Data labels on range series
+         * @deprecated 13.0.1
          */
         yLow: 0,
         /**
          * Y offset of the higher data labels relative to the point value.
          *
+         * Deprecated. Use a data labels array with `alignToKey: 'high'` and
+         * the regular `y` option instead.
+         *
          * @sample highcharts/plotoptions/arearange-datalabels/
          *         Data labels on range series
+         * @deprecated 13.0.1
          */
         yHigh: 0
     }
 };
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * Normalize the dataLabels config into a per-label array. Resolves the
+ * `alignToKey` default (`high` for the first label, `low` for the second) and
+ * maps the deprecated `xLow/xHigh/yLow/yHigh` offsets onto each label's `x/y`.
+ * @internal
+ */
+function getRangeDataLabelOptions(series) {
+    const dataLabels = series.options.dataLabels;
+    if ((0,external_highcharts_src_js_default_namespaceObject.isArray)(dataLabels)) {
+        return Array.from({
+            length: Math.max(dataLabels.length, 2)
+        }, (_, index) => {
+            const options = dataLabels[index], defaultAlignToKey = index === 0 ? 'high' :
+                index === 1 ? 'low' :
+                    series.pointValKey, alignToKey = options?.alignToKey ?? defaultAlignToKey;
+            return (0,external_highcharts_src_js_default_namespaceObject.merge)(options ?? { enabled: false }, { alignToKey });
+        });
+    }
+    if (dataLabels?.alignToKey) {
+        return [
+            (0,external_highcharts_src_js_default_namespaceObject.merge)(dataLabels, dataLabels.alignToKey === 'high' ? {
+                x: dataLabels.xHigh,
+                y: dataLabels.yHigh
+            } : dataLabels.alignToKey === 'low' ? {
+                x: dataLabels.xLow,
+                y: dataLabels.yLow
+            } : {})
+        ];
+    }
+    return [
+        (0,external_highcharts_src_js_default_namespaceObject.merge)(dataLabels, {
+            alignToKey: 'high',
+            x: dataLabels?.xHigh,
+            y: dataLabels?.yHigh
+        }),
+        (0,external_highcharts_src_js_default_namespaceObject.merge)(dataLabels, {
+            alignToKey: 'low',
+            x: dataLabels?.xLow,
+            y: dataLabels?.yLow
+        })
+    ];
+}
 /* *
  *
  *  Class
@@ -1258,7 +1471,7 @@ class AreaRangeSeries extends AreaSeries {
                 rectPlotX: point.rectPlotX,
                 yBottom: point.yBottom,
                 // `plotHighX` is for polar charts
-                plotX: (0,external_highcharts_src_js_default_namespaceObject.pick)(point.plotHighX, point.plotX),
+                plotX: point.plotHighX ?? point.plotX,
                 plotY: point.plotHigh,
                 isNull: point.isNull
             };
@@ -1308,151 +1521,27 @@ class AreaRangeSeries extends AreaSeries {
         this.areaPath.xMap = lowerPath.xMap;
         return linePath;
     }
-    /**
-     * Extend the basic drawDataLabels method by running it for both lower and
-     * higher values.
-     * @internal
-     */
     drawDataLabels() {
-        const data = this.points, length = data.length, originalDataLabels = [], dataLabelOptions = this.options.dataLabels, inverted = this.chart.inverted;
-        let i, point, up, upperDataLabelOptions, lowerDataLabelOptions;
+        const series = this, dataLabelOptions = series.options.dataLabels;
         if (dataLabelOptions) {
-            // Split into upper and lower options. If data labels is an array,
-            // the first element is the upper label, the second is the lower.
-            //
-            // TODO: We want to change this and allow multiple labels for both
-            // upper and lower values in the future - introducing some options
-            // for which point value to use as Y for the dataLabel, so that this
-            // could be handled in Series.drawDataLabels. This would also
-            // improve performance since we now have to loop over all the points
-            // multiple times to work around the data label logic.
-            if ((0,external_highcharts_src_js_default_namespaceObject.isArray)(dataLabelOptions)) {
-                upperDataLabelOptions = dataLabelOptions[0] || {
-                    enabled: false
-                };
-                lowerDataLabelOptions = dataLabelOptions[1] || {
-                    enabled: false
-                };
-            }
-            else {
-                // Make copies
-                upperDataLabelOptions = (0,external_highcharts_src_js_default_namespaceObject.extend)({}, dataLabelOptions);
-                upperDataLabelOptions.x = dataLabelOptions.xHigh;
-                upperDataLabelOptions.y = dataLabelOptions.yHigh;
-                lowerDataLabelOptions = (0,external_highcharts_src_js_default_namespaceObject.extend)({}, dataLabelOptions);
-                lowerDataLabelOptions.x = dataLabelOptions.xLow;
-                lowerDataLabelOptions.y = dataLabelOptions.yLow;
-            }
-            // Draw upper labels
-            if (upperDataLabelOptions.enabled || this.hasDataLabels?.()) {
-                // Set preliminary values for plotY and dataLabel
-                // and draw the upper labels
-                i = length;
-                while (i--) {
-                    point = data[i];
-                    if (point) {
-                        const { plotHigh = 0, plotLow = 0 } = point;
-                        up = upperDataLabelOptions.inside ?
-                            plotHigh < plotLow :
-                            plotHigh > plotLow;
-                        point.y = point.high;
-                        point._plotY = point.plotY;
-                        point.plotY = plotHigh;
-                        // Store original data labels and set preliminary label
-                        // objects to be picked up in the uber method
-                        originalDataLabels[i] = point.dataLabel;
-                        point.dataLabel = point.dataLabelUpper;
-                        // Set the default offset
-                        point.below = up;
-                        if (inverted) {
-                            if (!upperDataLabelOptions.align) {
-                                upperDataLabelOptions.align = up ?
-                                    'right' : 'left';
-                            }
-                        }
-                        else {
-                            if (!upperDataLabelOptions.verticalAlign) {
-                                upperDataLabelOptions.verticalAlign = up ?
-                                    'top' :
-                                    'bottom';
-                            }
-                        }
-                    }
-                }
-                this.options.dataLabels = upperDataLabelOptions;
-                if (AreaRangeSeries_areaProto.drawDataLabels) {
-                    // #1209:
-                    AreaRangeSeries_areaProto.drawDataLabels.apply(this, arguments);
-                }
-                // Reset state after the upper labels were created. Move
-                // it to point.dataLabelUpper and reassign the originals.
-                // We do this here to support not drawing a lower label.
-                i = length;
-                while (i--) {
-                    point = data[i];
-                    if (point) {
-                        point.dataLabelUpper = point.dataLabel;
-                        point.dataLabel = originalDataLabels[i];
-                        delete point.dataLabels;
-                        point.y = point.low;
-                        point.plotY = point._plotY;
-                    }
-                }
-            }
-            // Draw lower labels
-            if (lowerDataLabelOptions.enabled || this.hasDataLabels?.()) {
-                i = length;
-                while (i--) {
-                    point = data[i];
-                    if (point) {
-                        const { plotHigh = 0, plotLow = 0 } = point;
-                        up = lowerDataLabelOptions.inside ?
-                            plotHigh < plotLow :
-                            plotHigh > plotLow;
-                        // Set the default offset
-                        point.below = !up;
-                        if (inverted) {
-                            if (!lowerDataLabelOptions.align) {
-                                lowerDataLabelOptions.align = up ?
-                                    'left' : 'right';
-                            }
-                        }
-                        else {
-                            if (!lowerDataLabelOptions.verticalAlign) {
-                                lowerDataLabelOptions.verticalAlign = up ?
-                                    'bottom' :
-                                    'top';
-                            }
-                        }
-                    }
-                }
-                this.options.dataLabels = lowerDataLabelOptions;
-                if (AreaRangeSeries_areaProto.drawDataLabels) {
-                    AreaRangeSeries_areaProto.drawDataLabels.apply(this, arguments);
-                }
-            }
-            // Merge upper and lower into point.dataLabels for later destroying
-            if (upperDataLabelOptions.enabled) {
-                i = length;
-                while (i--) {
-                    point = data[i];
-                    if (point) {
-                        point.dataLabels = [
-                            point.dataLabelUpper,
-                            point.dataLabel
-                        ].filter(function (label) {
-                            return !!label;
-                        });
-                    }
-                }
+            const rangeOptions = getRangeDataLabelOptions(series);
+            // Resolve value references like `{y}` against the aligned key
+            rangeOptions.forEach(Series_RangeDataLabel.applyAlignToKeyValue);
+            series.options.dataLabels = rangeOptions;
+            if (AreaRangeSeries_areaProto.drawDataLabels) {
+                // #1209
+                AreaRangeSeries_areaProto.drawDataLabels.call(series);
+            }
+            series.options.dataLabels = dataLabelOptions;
+            for (const point of series.points) {
+                const labels = point.dataLabels ?? [];
+                point.dataLabelUpper = labels.find((label) => (Series_RangeDataLabel.resolveAlignToKey(series, label.options
+                    ?.alignToKey) === 'high'));
+                point.dataLabel = labels.find((label) => (Series_RangeDataLabel.resolveAlignToKey(series, label.options
+                    ?.alignToKey) === 'low'));
             }
-            // Reset options
-            this.options.dataLabels = dataLabelOptions;
         }
     }
-    alignDataLabel() {
-        columnProto.alignDataLabel.apply(this, arguments);
-    }
     modifyMarkerSettings() {
         const series = this, originalMarkerSettings = {
             marker: series.options.marker,
@@ -1503,7 +1592,7 @@ class AreaRangeSeries extends AreaSeries {
             if ((0,external_highcharts_src_js_default_namespaceObject.defined)(point.plotHighX)) {
                 point.plotX = point.plotHighX;
             }
-            point.y = (0,external_highcharts_src_js_default_namespaceObject.pick)(point.high, point.origProps.y); // #15523
+            point.y = point.high ?? point.origProps.y; // #15523
             point.negative = point.y < (series.options.threshold || 0);
             if (series.zones.length) {
                 point.zone = point.getZone();
@@ -1601,6 +1690,7 @@ AreaRangeSeries.defaultOptions = (0,external_highcharts_src_js_default_namespace
     pointValKey: 'low',
     setStackedPoints: noop
 });
+Series_RangeDataLabel.compose(AreaRangeSeries);
 external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('arearange', AreaRangeSeries);
 /* *
  *
@@ -1785,10 +1875,15 @@ external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('
  */
 ''; // Adds doclets above to transpiled file
 
-;// ./code/es-modules/Series/BoxPlot/BoxPlotSeriesDefaults.js
+;// ./code/es-modules/Extensions/BorderRadius.js
+/* unused harmony import specifier */ var relativeLength;
+/* unused harmony import specifier */ var isObject;
+/* unused harmony import specifier */ var extend;
+/* unused harmony import specifier */ var addEvent;
 /* *
  *
- *  (c) 2010-2026 Highsoft AS
+ *  Highcharts Border Radius module
+ *
  *  Author: Torstein Hønsi
  *
  *  Integration of this software requires a license.
@@ -1798,44 +1893,448 @@ external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('
  *
  * */
 
+
+const { defaultOptions: BorderRadius_defaultOptions } = (external_highcharts_src_js_default_default());
+
+const { noop: BorderRadius_noop } = (external_highcharts_src_js_default_default());
+
 /* *
  *
- *  API Options
+ *  Constants
  *
  * */
-/**
- * A box plot is a convenient way of depicting groups of data through their
- * five-number summaries: the smallest observation (sample minimum), lower
- * quartile (Q1), median (Q2), upper quartile (Q3), and largest observation
- * (sample maximum).
+const defaultBorderRadiusOptions = {
+    radius: 0,
+    scope: 'stack',
+    where: void 0
+};
+/* *
  *
- * @sample highcharts/demo/box-plot/
- *         Box plot
- * @sample {highcharts} highcharts/css/boxplot/
- *         Box plot in styled mode
- * @sample {highcharts} highcharts/series-scatter/jitter-boxplot
- *         Jittered scatter plot on top of a box plot
+ *  Variables
  *
- * @extends      plotOptions.column
- * @excluding    borderColor, borderRadius, borderWidth, groupZPadding,
- *               states, boostThreshold, boostBlending
- * @product      highcharts
- * @requires     highcharts-more
- * @optionparent plotOptions.boxplot
+ * */
+let oldArc = (/* unused pure expression or super */ null && (BorderRadius_noop));
+let oldRoundedRect = (/* unused pure expression or super */ null && (BorderRadius_noop));
+/* *
+ *
+ *  Functions
+ *
+ * */
+/** @internal */
+function applyBorderRadius(path, i, r) {
+    const a = path[i];
+    let b = path[i + 1];
+    if (b[0] === 'Z') {
+        b = path[0];
+    }
+    let line, arc, fromLineToArc;
+    // From straight line to arc
+    if ((a[0] === 'M' || a[0] === 'L') && b[0] === 'A') {
+        line = a;
+        arc = b;
+        fromLineToArc = true;
+        // From arc to straight line
+    }
+    else if (a[0] === 'A' && (b[0] === 'M' || b[0] === 'L')) {
+        line = b;
+        arc = a;
+    }
+    if (line && arc && arc.params) {
+        const bigR = arc[1], 
+        // In our use cases, outer pie slice arcs are clockwise and inner
+        // arcs (donut/sunburst etc) are anti-clockwise
+        clockwise = arc[5], params = arc.params, { start, end, cx, cy } = params;
+        // Some geometric constants
+        const relativeR = clockwise ? (bigR - r) : (bigR + r), 
+        // The angle, on the big arc, that the border radius arc takes up
+        angleOfBorderRadius = relativeR ? Math.asin(r / relativeR) : 0, angleOffset = clockwise ?
+            angleOfBorderRadius :
+            -angleOfBorderRadius, 
+        // The distance along the radius of the big arc to the starting
+        // point of the small border radius arc
+        distanceBigCenterToStartArc = (Math.cos(angleOfBorderRadius) *
+            relativeR);
+        // From line to arc
+        if (fromLineToArc) {
+            // Update the cache
+            params.start = start + angleOffset;
+            // First move to the start position at the radial line. We want to
+            // start one borderRadius closer to the center.
+            line[1] = cx + distanceBigCenterToStartArc * Math.cos(start);
+            line[2] = cy + distanceBigCenterToStartArc * Math.sin(start);
+            // Now draw an arc towards the point where the small circle touches
+            // the great circle.
+            path.splice(i + 1, 0, [
+                'A',
+                r,
+                r,
+                0, // Slanting,
+                0, // Long arc
+                1, // Clockwise
+                cx + bigR * Math.cos(params.start),
+                cy + bigR * Math.sin(params.start)
+            ]);
+            // From arc to line
+        }
+        else {
+            // Update the cache
+            params.end = end - angleOffset;
+            // End the big arc a bit earlier
+            arc[6] = cx + bigR * Math.cos(params.end);
+            arc[7] = cy + bigR * Math.sin(params.end);
+            // Draw a small arc towards a point on the end angle, but one
+            // borderRadius closer to the center relative to the perimeter.
+            path.splice(i + 1, 0, [
+                'A',
+                r,
+                r,
+                0,
+                0,
+                1,
+                cx + distanceBigCenterToStartArc * Math.cos(end),
+                cy + distanceBigCenterToStartArc * Math.sin(end)
+            ]);
+        }
+        // Long or short arc must be reconsidered because we have modified the
+        // start and end points
+        arc[4] = Math.abs(params.end - params.start) < Math.PI ? 0 : 1;
+    }
+}
+/**
+ * Extend arc with borderRadius.
+ * @internal
  */
-const BoxPlotSeriesDefaults = {
-    /**
-     * The Y axis value to serve as the base for the columns, for
-     * distinguishing between values above and below a threshold. If `null`,
-     * the columns extend from the padding Y axis minimum.
-     *
-     * @type    {number|null}
-     * @default null
-     * @since   2.0
-     * @product highcharts
-     */
-    threshold: null,
-    tooltip: {
+function arc(x, y, w, h, options = {}) {
+    const path = oldArc(x, y, w, h, options), { brStart = true, brEnd = true, innerR = 0, r = w, start = 0, end = 0 } = options;
+    if (options.open || !options.borderRadius) {
+        return path;
+    }
+    const alpha = end - start, sinHalfAlpha = Math.sin(alpha / 2), borderRadius = Math.max(Math.min(relativeLength(borderRadiusObject(options.borderRadius).radius, r - innerR), 
+    // Cap to half the sector radius
+    (r - innerR) / 2, 
+    // For smaller pie slices, cap to the largest small circle that
+    // can be fitted within the sector
+    (r * sinHalfAlpha) / (1 + sinHalfAlpha)), 0), 
+    // For the inner radius, we need an extra cap because the inner arc
+    // is shorter than the outer arc
+    innerBorderRadius = Math.min(borderRadius, 2 * (alpha / Math.PI) * innerR);
+    // Apply turn-by-turn border radius. Start at the end since we're
+    // splicing in arc segments.
+    let i = path.length - 1;
+    while (i--) {
+        if ((!brStart && (i === 0 || i === 3)) ||
+            (!brEnd && (i === 1 || i === 2))) {
+            continue;
+        }
+        applyBorderRadius(path, i, i > 1 ? innerBorderRadius : borderRadius);
+    }
+    return path;
+}
+/** @internal */
+function seriesOnAfterColumnTranslate() {
+    if (this.options.borderRadius &&
+        !(this.chart.is3d && this.chart.is3d())) {
+        const { options, yAxis } = this, percent = options.stacking === 'percent', seriesDefault = BorderRadius_defaultOptions.plotOptions?.[this.type]
+            ?.borderRadius, borderRadius = borderRadiusObject(options.borderRadius, isObject(seriesDefault) ? seriesDefault : {}), reversed = yAxis.options.reversed;
+        for (const point of this.points) {
+            const { shapeArgs } = point;
+            if (point.shapeType === 'roundedRect' && shapeArgs) {
+                const { width = 0, height = 0, y = 0 } = shapeArgs;
+                let brBoxY = y, brBoxHeight = height;
+                // It would be nice to refactor StackItem.getStackBox/
+                // setOffset so that we could get a reliable box out of
+                // it. Currently it is close if we remove the label
+                // offset, but we still need to run crispCol and also
+                // flip it if inverted, so atm it is simpler to do it
+                // like the below.
+                if (borderRadius.scope === 'stack' &&
+                    point.stackTotal) {
+                    const stackEnd = yAxis.translate(percent ? 100 : point.stackTotal, false, true, false, true), stackThreshold = yAxis.translate(options.threshold || 0, false, true, false, true), box = this.crispCol(0, Math.min(stackEnd, stackThreshold), 0, Math.abs(stackEnd - stackThreshold));
+                    brBoxY = box.y;
+                    brBoxHeight = box.height;
+                }
+                const flip = (point.negative ? -1 : 1) *
+                    (reversed ? -1 : 1) === -1;
+                // Handle the where option
+                let where = borderRadius.where;
+                // Waterfall, hanging columns should have rounding on
+                // all sides
+                if (!where &&
+                    this.is('waterfall') &&
+                    Math.abs((point.yBottom || 0) -
+                        (this.translatedThreshold || 0)) > this.borderWidth) {
+                    where = 'all';
+                }
+                if (!where) {
+                    where = 'end';
+                }
+                // Get the radius
+                const r = Math.min(relativeLength(borderRadius.radius, width), width / 2, 
+                // Cap to the height, but not if where is `end`
+                where === 'all' ? brBoxHeight / 2 : Infinity) || 0;
+                // If the `where` option is 'end', cut off the
+                // rectangles by making the border-radius box one r
+                // greater, so that the imaginary radius falls outside
+                // the rectangle.
+                if (where === 'end') {
+                    if (flip) {
+                        brBoxY -= r;
+                        brBoxHeight += r;
+                    }
+                    else {
+                        brBoxHeight += r;
+                    }
+                }
+                extend(shapeArgs, { brBoxHeight, brBoxY, r });
+            }
+        }
+    }
+}
+/** @internal */
+function composeBorderRadius(SeriesClass, SVGElementClass, SVGRendererClass) {
+    const PieSeriesClass = SeriesClass.types.pie;
+    if (!SVGElementClass.symbolCustomAttribs.includes('borderRadius')) {
+        const symbols = SVGRendererClass.prototype.symbols;
+        addEvent(SeriesClass, 'afterColumnTranslate', seriesOnAfterColumnTranslate, {
+            // After columnrange and polar column modifications
+            order: 9
+        });
+        addEvent(PieSeriesClass, 'afterTranslate', pieSeriesOnAfterTranslate);
+        SVGElementClass.symbolCustomAttribs.push('borderRadius', 'brBoxHeight', 'brBoxY', 'brEnd', 'brStart');
+        oldArc = symbols.arc;
+        oldRoundedRect = symbols.roundedRect;
+        symbols.arc = arc;
+        symbols.roundedRect = roundedRect;
+    }
+}
+/**
+ * Utility function to get the full border radius options object, from a simple
+ * number or a partial options object.
+ * @internal
+ */
+function borderRadiusObject(options, seriesBROptions) {
+    if (!(0,external_highcharts_src_js_default_namespaceObject.isObject)(options)) {
+        options = { radius: options || 0 };
+    }
+    return (0,external_highcharts_src_js_default_namespaceObject.merge)(defaultBorderRadiusOptions, seriesBROptions, options);
+}
+/** @internal */
+function pieSeriesOnAfterTranslate() {
+    const borderRadius = borderRadiusObject(this.options.borderRadius);
+    for (const point of this.points) {
+        const shapeArgs = point.shapeArgs;
+        if (shapeArgs) {
+            shapeArgs.borderRadius = relativeLength(borderRadius.radius, (shapeArgs.r || 0) - ((shapeArgs.innerR) || 0));
+        }
+    }
+}
+/**
+ * Extend roundedRect with individual cutting through rOffset.
+ * @internal
+ */
+function roundedRect(x, y, width, height, options = {}) {
+    const path = oldRoundedRect(x, y, width, height, options), { r = 0, brBoxHeight = height, brBoxY = y } = options, brOffsetTop = y - brBoxY, brOffsetBtm = (brBoxY + brBoxHeight) - (y + height), 
+    // When the distance to the border-radius box is greater than the r
+    // itself, it means no border radius. The -0.1 accounts for float
+    // rounding errors.
+    rTop = (brOffsetTop - r) > -0.1 ? 0 : r, rBtm = (brOffsetBtm - r) > -0.1 ? 0 : r, cutTop = Math.max(rTop && brOffsetTop, 0), cutBtm = Math.max(rBtm && brOffsetBtm, 0);
+    /*
+
+    The naming of control points:
+
+      / a -------- b \
+     /                \
+    h                  c
+    |                  |
+    |                  |
+    |                  |
+    g                  d
+     \                /
+      \ f -------- e /
+
+    */
+    const a = [x + rTop, y], b = [x + width - rTop, y], c = [x + width, y + rTop], d = [
+        x + width, y + height - rBtm
+    ], e = [
+        x + width - rBtm,
+        y + height
+    ], f = [x + rBtm, y + height], g = [x, y + height - rBtm], h = [x, y + rTop];
+    const applyPythagoras = (r, altitude) => Math.sqrt(Math.pow(r, 2) - Math.pow(altitude, 2));
+    // Inside stacks, cut off part of the top
+    if (cutTop) {
+        const base = applyPythagoras(rTop, rTop - cutTop);
+        a[0] -= base;
+        b[0] += base;
+        c[1] = h[1] = y + rTop - cutTop;
+    }
+    // Column is lower than the radius. Cut off bottom inside the top
+    // radius.
+    if (height < rTop - cutTop) {
+        const base = applyPythagoras(rTop, rTop - cutTop - height);
+        c[0] = d[0] = x + width - rTop + base;
+        e[0] = Math.min(c[0], e[0]);
+        f[0] = Math.max(d[0], f[0]);
+        g[0] = h[0] = x + rTop - base;
+        c[1] = h[1] = y + height;
+    }
+    // Inside stacks, cut off part of the bottom
+    if (cutBtm) {
+        const base = applyPythagoras(rBtm, rBtm - cutBtm);
+        e[0] += base;
+        f[0] -= base;
+        d[1] = g[1] = y + height - rBtm + cutBtm;
+    }
+    // Cut off top inside the bottom radius
+    if (height < rBtm - cutBtm) {
+        const base = applyPythagoras(rBtm, rBtm - cutBtm - height);
+        c[0] = d[0] = x + width - rBtm + base;
+        b[0] = Math.min(c[0], b[0]);
+        a[0] = Math.max(d[0], a[0]);
+        g[0] = h[0] = x + rBtm - base;
+        d[1] = g[1] = y;
+    }
+    // Preserve the box for data labels
+    path.length = 0;
+    path.push(['M', ...a], 
+    // Top side
+    ['L', ...b], 
+    // Top right corner
+    ['A', rTop, rTop, 0, 0, 1, ...c], 
+    // Right side
+    ['L', ...d], 
+    // Bottom right corner
+    ['A', rBtm, rBtm, 0, 0, 1, ...e], 
+    // Bottom side
+    ['L', ...f], 
+    // Bottom left corner
+    ['A', rBtm, rBtm, 0, 0, 1, ...g], 
+    // Left side
+    ['L', ...h], 
+    // Top left corner
+    ['A', rTop, rTop, 0, 0, 1, ...a], ['Z']);
+    return path;
+}
+/* *
+ *
+ *  API Declarations
+ *
+ * */
+/**
+ * Detailed options for border radius.
+ *
+ * @sample  {highcharts} highcharts/plotoptions/column-borderradius/
+ *          Rounded columns
+ * @sample  highcharts/plotoptions/series-border-radius
+ *          Column and pie with rounded border
+ *
+ * @interface Highcharts.BorderRadiusOptionsObject
+ */ /**
+* The border radius. A number signifies pixels. A percentage string, like for
+* example `50%`, signifies a relative size. For columns this is relative to the
+* column width, for pies it is relative to the radius and the inner radius.
+*
+* @sample  {highcharts} highcharts/plotoptions/column-borderradius/
+*          Rounded columns
+* @sample  highcharts/plotoptions/series-border-radius
+*          Column and pie with rounded border
+*
+* @name Highcharts.BorderRadiusOptionsObject#radius
+* @type {string|number|undefined}
+*/ /**
+* The scope of the rounding for column charts or plot bands. In a stacked
+* column chart, the value `point` means each single point will get rounded
+* corners. The value `stack` means the rounding will apply to the full
+* stack, so that only points close to the top or bottom will receive
+* rounding.
+*
+* Similarly, for plot bands, the `individual` value means each plot band
+* will get rounded corners.
+*
+* @sample  {highcharts} highcharts/plotoptions/column-borderradius/
+*          Rounded columns
+*
+* @name Highcharts.BorderRadiusOptionsObject#scope
+* @type {"individual"|"point"|"stack"|undefined}
+*/ /**
+* For column charts, where in the point or stack to apply rounding. The `end`
+* value means only those corners at the point value will be rounded, leaving
+* the corners at the base or threshold unrounded. This is the most intuitive
+* behavior. The `all` value means also the base will be rounded.
+*
+* @sample  {highcharts} highcharts/plotoptions/column-borderradius-where-all
+*          Rounding on all corners
+*
+* @name Highcharts.BorderRadiusOptionsObject#where
+* @type {"all"|"end"|undefined}
+* @default end
+*/
+(''); // Keeps doclets above in JS file
+
+;// ./code/es-modules/Series/BoxPlot/BoxPlotSeriesDefaults.js
+/* *
+ *
+ *  (c) 2010-2026 Highsoft AS
+ *  Author: Torstein Hønsi
+ *
+ *  Integration of this software requires a license.
+ *  - For commercial use, see www.highcharts.com/license
+ *  - For non-commercial, see www.highcharts.com/license-eula
+ *
+ *
+ * */
+
+/* *
+ *
+ *  API Options
+ *
+ * */
+/**
+ * A box plot is a convenient way of depicting groups of data through their
+ * five-number summaries: the smallest observation (sample minimum), lower
+ * quartile (Q1), median (Q2), upper quartile (Q3), and largest observation
+ * (sample maximum).
+ *
+ * @sample highcharts/demo/box-plot/
+ *         Box plot
+ * @sample {highcharts} highcharts/css/boxplot/
+ *         Box plot in styled mode
+ * @sample {highcharts} highcharts/series-scatter/jitter-boxplot
+ *         Jittered scatter plot on top of a box plot
+ *
+ * @extends      plotOptions.column
+ * @excluding    borderColor, borderWidth, groupZPadding,
+ *               states, boostThreshold, boostBlending
+ * @product      highcharts
+ * @requires     highcharts-more
+ * @optionparent plotOptions.boxplot
+ */
+const BoxPlotSeriesDefaults = {
+    /**
+     * The corner radius of the border surrounding the box. A number
+     * signifies pixels. A percentage string, like for example `50%`, signifies
+     * a size relative to the box width.
+     *
+     * @sample {highcharts} highcharts/demo/violin-plot/
+     *         Box plot with rounded corners
+     *
+     * @type    {number|string|Highcharts.BorderRadiusOptionsObject}
+     * @default 0
+     * @since   13.0.1
+     * @product highcharts
+     */
+    borderRadius: 0,
+    /**
+     * The Y axis value to serve as the base for the columns, for
+     * distinguishing between values above and below a threshold. If `null`,
+     * the columns extend from the padding Y axis minimum.
+     *
+     * @type    {number|null}
+     * @default null
+     * @since   2.0
+     * @product highcharts
+     */
+    threshold: null,
+    tooltip: {
         pointFormat: '<span style="color:{point.color}">\u25CF</span> <b>' +
             '{series.name}</b><br/>' +
             'Maximum: {point.high}<br/>' +
@@ -2035,6 +2534,24 @@ const BoxPlotSeriesDefaults = {
      * @default   high
      * @apioption plotOptions.boxplot.colorKey
      */
+    /**
+     * The point key used to position a box plot data label.
+     *
+     * @typedef {"low"|"q1"|"median"|"q3"|"high"} Highcharts.BoxPlotPointValKey
+     */
+    /**
+     * The point key to use for positioning this data label.
+     * Possible values are `low`, `q1`, `median`, `q3` and `high`.
+     *
+     * @sample {highcharts} highcharts/series-boxplot/data-labels/
+     *         Multiple data labels
+     *
+     * @type      {Highcharts.BoxPlotPointValKey}
+     * @default   high
+     * @validvalue ["low", "q1", "median", "q3", "high"]
+     * @product   highcharts
+     * @apioption plotOptions.boxplot.dataLabels.alignToKey
+     */
     /**
      * The color of the whiskers, the horizontal lines marking low and high
      * values. When `undefined`, the general series color is used.
@@ -2246,9 +2763,6 @@ const BoxPlotSeriesDefaults = {
  * */
 /* harmony default export */ const BoxPlot_BoxPlotSeriesDefaults = (BoxPlotSeriesDefaults);
 
-;// external ["./highcharts.src.js","default","Series","types","column"]
-const external_highcharts_src_js_default_Series_types_column_namespaceObject = __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_c57973fa__["default"].Series.types.column;
-var external_highcharts_src_js_default_Series_types_column_default = /*#__PURE__*/__webpack_require__.n(external_highcharts_src_js_default_Series_types_column_namespaceObject);
 ;// ./code/es-modules/Series/BoxPlot/BoxPlotSeries.js
 /* *
  *
@@ -2265,9 +2779,11 @@ var external_highcharts_src_js_default_Series_types_column_default = /*#__PURE__
 
 
 
+
 const { noop: BoxPlotSeries_noop } = (external_highcharts_src_js_default_default());
 
 
+
 /* *
  *
  *  Class
@@ -2323,8 +2839,9 @@ class BoxPlotSeries extends (external_highcharts_src_js_default_Series_types_col
         // Do the translation on each point dimension
         series.points.forEach(function (point) {
             pointArrayMap.forEach(function (key) {
-                if (point[key] !== null) {
-                    point[key + 'Plot'] = yAxis.translate(point[key], 0, 1, 0, 1);
+                const value = point[key];
+                if (value !== null) {
+                    point[`${key}Plot`] = yAxis.translate(value, false, true, false, true);
                 }
             });
             point.plotHigh = point.highPlot; // For data label validation
@@ -2376,7 +2893,10 @@ class BoxPlotSeries extends (external_highcharts_src_js_default_Series_types_col
                     // Stem attributes
                     stemAttr.stroke =
                         point.stemColor || options.stemColor || color;
-                    stemAttr['stroke-width'] = (0,external_highcharts_src_js_default_namespaceObject.pick)(point.stemWidth, options.stemWidth, options.lineWidth);
+                    stemAttr['stroke-width'] =
+                        point.stemWidth ??
+                            options.stemWidth ??
+                            options.lineWidth;
                     stemAttr.dashstyle = (point.stemDashStyle ||
                         options.stemDashStyle ||
                         options.dashStyle);
@@ -2386,7 +2906,10 @@ class BoxPlotSeries extends (external_highcharts_src_js_default_Series_types_col
                         whiskersAttr.stroke = (point.whiskerColor ||
                             options.whiskerColor ||
                             color);
-                        whiskersAttr['stroke-width'] = (0,external_highcharts_src_js_default_namespaceObject.pick)(point.whiskerWidth, options.whiskerWidth, options.lineWidth);
+                        whiskersAttr['stroke-width'] =
+                            point.whiskerWidth ??
+                                options.whiskerWidth ??
+                                options.lineWidth;
                         whiskersAttr.dashstyle = (point.whiskerDashStyle ||
                             options.whiskerDashStyle ||
                             options.dashStyle);
@@ -2407,25 +2930,28 @@ class BoxPlotSeries extends (external_highcharts_src_js_default_Series_types_col
                     medianAttr.stroke = (point.medianColor ||
                         options.medianColor ||
                         color);
-                    medianAttr['stroke-width'] = (0,external_highcharts_src_js_default_namespaceObject.pick)(point.medianWidth, options.medianWidth, options.lineWidth);
+                    medianAttr['stroke-width'] =
+                        point.medianWidth ??
+                            options.medianWidth ??
+                            options.lineWidth;
                     medianAttr.dashstyle = (point.medianDashStyle ||
                         options.medianDashStyle ||
                         options.dashStyle);
                     point.medianShape.attr(medianAttr);
                 }
-                let d;
                 // The stem
                 const stemX = (0,external_highcharts_src_js_default_namespaceObject.crisp)((point.plotX || 0) + (series.pointXOffset || 0) +
                     ((series.barW || 0) / 2), point.stem.strokeWidth());
-                d = [
-                    // Stem up
-                    ['M', stemX, q3Plot],
-                    ['L', stemX, highPlot],
-                    // Stem down
-                    ['M', stemX, q1Plot],
-                    ['L', stemX, lowPlot]
-                ];
-                point.stem[verb]({ d });
+                point.stem[verb]({
+                    d: [
+                        // Stem up
+                        ['M', stemX, q3Plot],
+                        ['L', stemX, highPlot],
+                        // Stem down
+                        ['M', stemX, q1Plot],
+                        ['L', stemX, lowPlot]
+                    ]
+                });
                 // The box
                 if (doQuartiles) {
                     const boxStrokeWidth = point.box.strokeWidth();
@@ -2433,15 +2959,11 @@ class BoxPlotSeries extends (external_highcharts_src_js_default_Series_types_col
                     q3Plot = (0,external_highcharts_src_js_default_namespaceObject.crisp)(q3Plot, boxStrokeWidth);
                     x = (0,external_highcharts_src_js_default_namespaceObject.crisp)(x, boxStrokeWidth);
                     right = (0,external_highcharts_src_js_default_namespaceObject.crisp)(right, boxStrokeWidth);
-                    d = [
-                        ['M', x, q3Plot],
-                        ['L', x, q1Plot],
-                        ['L', right, q1Plot],
-                        ['L', right, q3Plot],
-                        ['L', x, q3Plot],
-                        ['Z']
-                    ];
-                    point.box[verb]({ d });
+                    // Optionally round the corners of the box
+                    const r = Math.min((0,external_highcharts_src_js_default_namespaceObject.relativeLength)(borderRadiusObject(options.borderRadius).radius, right - x), (right - x) / 2, Math.abs(q1Plot - q3Plot) / 2);
+                    point.box[verb]({
+                        d: renderer.symbols.roundedRect(x, Math.min(q1Plot, q3Plot), right - x, Math.abs(q1Plot - q3Plot), { r })
+                    });
                 }
                 // The whiskers
                 if (pointWhiskerLength) {
@@ -2454,11 +2976,12 @@ class BoxPlotSeries extends (external_highcharts_src_js_default_Series_types_col
                 }
                 // The median
                 medianPlot = (0,external_highcharts_src_js_default_namespaceObject.crisp)(point.medianPlot, point.medianShape.strokeWidth());
-                d = [
-                    ['M', x, medianPlot],
-                    ['L', right, medianPlot]
-                ];
-                point.medianShape[verb]({ d });
+                point.medianShape[verb]({
+                    d: [
+                        ['M', x, medianPlot],
+                        ['L', right, medianPlot]
+                    ]
+                });
             }
         }
     }
@@ -2478,10 +3001,9 @@ BoxPlotSeries.defaultOptions = (0,external_highcharts_src_js_default_namespaceOb
     pointArrayMap: ['low', 'q1', 'median', 'q3', 'high'],
     // Defines the top of the tracker
     pointValKey: 'high',
-    // Disable data labels for box plot
-    drawDataLabels: BoxPlotSeries_noop,
     setStackedPoints: BoxPlotSeries_noop // #3890
 });
+Series_RangeDataLabel.compose(BoxPlotSeries);
 external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('boxplot', BoxPlotSeries);
 /* *
  *
@@ -2847,7 +3369,7 @@ class BubbleLegendItem {
      *        Legend instance
      */
     drawLegendSymbol(legend) {
-        const itemDistance = (0,external_highcharts_src_js_default_namespaceObject.pick)(legend.options.itemDistance, 20), legendItem = this.legendItem || {}, options = this.options, ranges = options.ranges, connectorDistance = options.connectorDistance;
+        const itemDistance = (legend.options.itemDistance ?? 20), legendItem = this.legendItem || {}, options = this.options, ranges = options.ranges, connectorDistance = options.connectorDistance;
         let connectorSpace;
         // Do not create bubbleLegend now if ranges or ranges values are not
         // specified or if are empty array.
@@ -2893,13 +3415,17 @@ class BubbleLegendItem {
         // Allow to parts of styles be used individually for range
         ranges.forEach(function (range, i) {
             if (!styledMode) {
-                bubbleAttribs.stroke = (0,external_highcharts_src_js_default_namespaceObject.pick)(range.borderColor, options.borderColor, series.color);
+                bubbleAttribs.stroke =
+                    range.borderColor ?? options.borderColor ?? series.color;
                 bubbleAttribs.fill = range.color || options.color;
                 if (!bubbleAttribs.fill) {
                     bubbleAttribs.fill = series.color;
                     bubbleAttribs['fill-opacity'] = fillOpacity ?? 1;
                 }
-                connectorAttribs.stroke = (0,external_highcharts_src_js_default_namespaceObject.pick)(range.connectorColor, options.connectorColor, series.color);
+                connectorAttribs.stroke =
+                    range.connectorColor ??
+                        options.connectorColor ??
+                        series.color;
             }
             // Set options needed for rendering each range
             ranges[i].radius = this.getRangeRadius(range.value);
@@ -3096,10 +3622,10 @@ class BubbleLegendItem {
             if (s.isBubble && !s.ignoreSeries) {
                 zData = s.getColumn('z').filter(external_highcharts_src_js_default_namespaceObject.isNumber);
                 if (zData.length) {
-                    minZ = (0,external_highcharts_src_js_default_namespaceObject.pick)(s.options.zMin, Math.min(minZ, Math.max((0,external_highcharts_src_js_default_namespaceObject.arrayMin)(zData), s.options.displayNegative === false ?
+                    minZ = (s.options.zMin ?? Math.min(minZ, Math.max((0,external_highcharts_src_js_default_namespaceObject.arrayMin)(zData), s.options.displayNegative === false ?
                         s.options.zThreshold :
                         -Number.MAX_VALUE)));
-                    maxZ = (0,external_highcharts_src_js_default_namespaceObject.pick)(s.options.zMax, Math.max(maxZ, (0,external_highcharts_src_js_default_namespaceObject.arrayMax)(zData)));
+                    maxZ = (s.options.zMax ?? Math.max(maxZ, (0,external_highcharts_src_js_default_namespaceObject.arrayMax)(zData)));
                 }
             }
         });
@@ -3563,7 +4089,7 @@ class BubblePoint extends ScatterPoint {
 
 const { composed: BubbleSeries_composed, noop: BubbleSeries_noop } = (external_highcharts_src_js_default_default());
 
-const { series: Series, seriesTypes: { column: { prototype: BubbleSeries_columnProto }, scatter: ScatterSeries } } = (external_highcharts_src_js_default_SeriesRegistry_default());
+const { series: Series, seriesTypes: { column: { prototype: columnProto }, scatter: ScatterSeries } } = (external_highcharts_src_js_default_SeriesRegistry_default());
 
 /* *
  *
@@ -3617,7 +4143,8 @@ function onAxisFoundExtremes() {
             ['min', 'userMin', pxMin],
             ['max', 'userMax', pxMax]
         ].forEach((keys) => {
-            if (typeof (0,external_highcharts_src_js_default_namespaceObject.pick)(this.options[keys[0]], this[keys[1]]) === 'undefined') {
+            if (typeof (this.options[keys[0]] ??
+                this[keys[1]]) === 'undefined') {
                 this[keys[0]] += keys[2] / transA;
             }
         });
@@ -3714,10 +4241,10 @@ class BubbleSeries extends ScatterSeries {
                 if (otherSeries.bubblePadding && otherSeries.reserveSpace()) {
                     const zExtremes = (otherSeries.onPoint || otherSeries).getZExtremes();
                     if (zExtremes) {
-                        // Changed '||' to 'pick' because min or max can be 0.
+                        // Use nullish coalescing because min or max can be 0.
                         // #17280
-                        zMin = Math.min((0,external_highcharts_src_js_default_namespaceObject.pick)(zMin, zExtremes.zMin), zExtremes.zMin);
-                        zMax = Math.max((0,external_highcharts_src_js_default_namespaceObject.pick)(zMax, zExtremes.zMax), zExtremes.zMax);
+                        zMin = Math.min((zMin ?? zExtremes.zMin), zExtremes.zMin);
+                        zMax = Math.max((zMax ?? zExtremes.zMax), zExtremes.zMax);
                         valid = true;
                     }
                 }
@@ -3855,19 +4382,19 @@ class BubbleSeries extends ScatterSeries {
             }
             return isPercent ? smallestSize * length / 100 : length;
         };
-        const minPxSize = getPxSize((0,external_highcharts_src_js_default_namespaceObject.pick)(this.options.minSize, 8));
+        const minPxSize = getPxSize(this.options.minSize ?? 8);
         // Prioritize min size if conflict to make sure bubbles are
         // always visible. #5873
-        const maxPxSize = Math.max(getPxSize((0,external_highcharts_src_js_default_namespaceObject.pick)(this.options.maxSize, '20%')), minPxSize);
+        const maxPxSize = Math.max(getPxSize(this.options.maxSize ?? '20%'), minPxSize);
         return { minPxSize, maxPxSize };
     }
     getZExtremes() {
         const options = this.options, zData = this.getColumn('z').filter(external_highcharts_src_js_default_namespaceObject.isNumber);
         if (zData.length) {
-            const zMin = (0,external_highcharts_src_js_default_namespaceObject.pick)(options.zMin, (0,external_highcharts_src_js_default_namespaceObject.clamp)((0,external_highcharts_src_js_default_namespaceObject.arrayMin)(zData), options.displayNegative === false ?
+            const zMin = (options.zMin ?? (0,external_highcharts_src_js_default_namespaceObject.clamp)((0,external_highcharts_src_js_default_namespaceObject.arrayMin)(zData), options.displayNegative === false ?
                 (options.zThreshold || 0) :
                 -Number.MAX_VALUE, Number.MAX_VALUE));
-            const zMax = (0,external_highcharts_src_js_default_namespaceObject.pick)(options.zMax, (0,external_highcharts_src_js_default_namespaceObject.arrayMax)(zData));
+            const zMax = (options.zMax ?? (0,external_highcharts_src_js_default_namespaceObject.arrayMax)(zData));
             if ((0,external_highcharts_src_js_default_namespaceObject.isNumber)(zMin) && (0,external_highcharts_src_js_default_namespaceObject.isNumber)(zMax)) {
                 return { zMin, zMax };
             }
@@ -3939,6 +4466,21 @@ BubbleSeries.defaultOptions = (0,external_highcharts_src_js_default_namespaceObj
      * @since 6.1.0
      */
     animationLimit: 250,
+    /**
+     * When using automatic point colors pulled from the global
+     * [colors](colors) or series-specific
+     * [plotOptions.bubble.colors](series.colors) collections, this option
+     * determines whether the chart should receive one color per series or
+     * one color per point.
+     *
+     * In styled mode, the `colors` or `series.colors` arrays are not
+     * supported, and instead this option gives the points individual color
+     * class names on the form `highcharts-color-{n}`.
+     *
+     * @type      {boolean}
+     * @default   false
+     * @apioption plotOptions.bubble.colorByPoint
+     */
     /**
      * Whether to display negative sized bubbles. The threshold is given
      * by the [zThreshold](#plotOptions.bubble.zThreshold) option, and negative
@@ -4142,7 +4684,7 @@ BubbleSeries.defaultOptions = (0,external_highcharts_src_js_default_namespaceObj
     zoneAxis: 'z'
 });
 (0,external_highcharts_src_js_default_namespaceObject.extend)(BubbleSeries.prototype, {
-    alignDataLabel: BubbleSeries_columnProto.alignDataLabel,
+    alignDataLabel: columnProto.alignDataLabel,
     applyZones: BubbleSeries_noop,
     bubblePadding: true,
     isBubble: true,
@@ -4299,6 +4841,7 @@ const { seriesTypes: { column: { prototype: { pointClass: { prototype: ColumnRan
  *  Class
  *
  * */
+/** @internal */
 class ColumnRangePoint extends ColumnRangePoint_AreaRangePoint {
     /* *
      *
@@ -4317,9 +4860,10 @@ class ColumnRangePoint extends ColumnRangePoint_AreaRangePoint {
  *  Default Export
  *
  * */
+/** @internal */
 /* harmony default export */ const ColumnRange_ColumnRangePoint = (ColumnRangePoint);
 
-;// ./code/es-modules/Series/ColumnRange/ColumnRangeSeries.js
+;// ./code/es-modules/Series/ColumnRange/ColumnRangeSeriesDefaults.js
 /* *
  *
  *  (c) 2010-2026 Highsoft AS
@@ -4332,15 +4876,9 @@ class ColumnRangePoint extends ColumnRangePoint_AreaRangePoint {
  *
  * */
 
-
-
-const { noop: ColumnRangeSeries_noop } = (external_highcharts_src_js_default_default());
-
-const { seriesTypes: { arearange: ColumnRangeSeries_AreaRangeSeries, column: ColumnSeries, column: { prototype: ColumnRangeSeries_columnProto } } } = (external_highcharts_src_js_default_SeriesRegistry_default());
-
 /* *
  *
- *  Constants
+ *  API Options
  *
  * */
 /**
@@ -4358,7 +4896,7 @@ const { seriesTypes: { arearange: ColumnRangeSeries_AreaRangeSeries, column: Col
  * @requires     highcharts-more
  * @optionparent plotOptions.columnrange
  */
-const columnRangeOptions = {
+const ColumnRangeSeriesDefaults = {
     borderRadius: {
         where: 'all'
     },
@@ -4385,6 +4923,116 @@ const columnRangeOptions = {
         }
     }
 };
+/**
+ * A `columnrange` series. If the [type](#series.columnrange.type)
+ * option is not specified, it is inherited from
+ * [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.columnrange
+ * @excluding dataParser, dataURL, stack, stacking
+ * @product   highcharts highstock
+ * @requires  highcharts-more
+ * @apioption series.columnrange
+ */
+/**
+ * An array of data points for the series. For the `columnrange` series
+ * type, points can be given in the following ways:
+ *
+ * 1. An array of arrays with 3 or 2 values. In this case, the values correspond
+ *    to `x,low,high`. If the first value is a string, it is applied as the name
+ *    of the point, and the `x` value is inferred. The `x` value can also be
+ *    omitted, in which case the inner arrays should be of length 2\. Then the
+ *    `x` value is automatically calculated, either starting at 0 and
+ *    incremented by 1, or from `pointStart` and `pointInterval` given in the
+ *    series options.
+ *    ```js
+ *    data: [
+ *        [0, 4, 2],
+ *        [1, 2, 1],
+ *        [2, 9, 10]
+ *    ]
+ *    ```
+ *
+ * 2. An array of objects with named values. The following snippet shows only a
+ *    few settings, see the complete options set below. If the total number of
+ *    data points exceeds the series'
+ *    [turboThreshold](#series.columnrange.turboThreshold), this option is not
+ *    available.
+ *    ```js
+ *    data: [{
+ *        x: 1,
+ *        low: 0,
+ *        high: 4,
+ *        name: "Point2",
+ *        color: "#00FF00"
+ *    }, {
+ *        x: 1,
+ *        low: 5,
+ *        high: 3,
+ *        name: "Point1",
+ *        color: "#FF00FF"
+ *    }]
+ *    ```
+ *
+ * @sample {highcharts} highcharts/series/data-array-of-arrays/
+ *         Arrays of numeric x and y
+ * @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/
+ *         Arrays of datetime x and y
+ * @sample {highcharts} highcharts/series/data-array-of-name-value/
+ *         Arrays of point.name and y
+ * @sample {highcharts} highcharts/series/data-array-of-objects/
+ *         Config objects
+ *
+ * @basic
+ * @type      {Array<Array<(number|string),number>|Array<(number|string),number,number>|*>}
+ * @extends   series.arearange.data
+ * @excluding marker
+ * @product   highcharts highstock
+ * @apioption series.columnrange.data
+ */
+/**
+ * @extends   series.columnrange.dataLabels
+ * @product   highcharts highstock
+ * @apioption series.columnrange.data.dataLabels
+ */
+/**
+ * @excluding halo, lineWidth, lineWidthPlus, marker
+ * @product   highcharts highstock
+ * @apioption series.columnrange.states.hover
+ */
+/**
+ * @excluding halo, lineWidth, lineWidthPlus, marker
+ * @product   highcharts highstock
+ * @apioption series.columnrange.states.select
+ */
+''; // Adds doclets above into transpiled
+/* *
+ *
+ *  Default Export
+ *
+ * */
+/* harmony default export */ const ColumnRange_ColumnRangeSeriesDefaults = (ColumnRangeSeriesDefaults);
+
+;// ./code/es-modules/Series/ColumnRange/ColumnRangeSeries.js
+/* *
+ *
+ *  (c) 2010-2026 Highsoft AS
+ *  Author: Torstein Hønsi
+ *
+ *  Integration of this software requires a license.
+ *  - For commercial use, see www.highcharts.com/license
+ *  - For non-commercial, see www.highcharts.com/license-eula
+ *
+ *
+ * */
+
+
+
+
+const { noop: ColumnRangeSeries_noop } = (external_highcharts_src_js_default_default());
+
+const { seriesTypes: { arearange: ColumnRangeSeries_AreaRangeSeries, column: ColumnSeries, column: { prototype: ColumnRangeSeries_columnProto } } } = (external_highcharts_src_js_default_SeriesRegistry_default());
+
 /* *
  *
  *  Class
@@ -4393,7 +5041,7 @@ const columnRangeOptions = {
 /**
  * The ColumnRangeSeries class
  *
- * @private
+ * @internal
  * @class
  * @name Highcharts.seriesTypes.columnrange
  *
@@ -4442,17 +5090,17 @@ class ColumnRangeSeries extends ColumnRangeSeries_AreaRangeSeries {
     translate3dShapes() {
         return ColumnRangeSeries_columnProto.translate3dShapes.apply(this, arguments);
     }
+    /**
+     * Translate data points from raw values x and y to plotX and plotY
+     * @internal
+     */
     afterColumnTranslate() {
-        /**
-         * Translate data points from raw values x and y to plotX and plotY
-         * @private
-         */
         const yAxis = this.yAxis, xAxis = this.xAxis, startAngleRad = xAxis.startAngleRad, chart = this.chart, isRadial = this.xAxis.isRadial, safeDistance = Math.max(chart.chartWidth, chart.chartHeight) + 999;
         let height, heightDifference, start, y;
         // eslint-disable-next-line valid-jsdoc
         /**
          * Don't draw too far outside plot area (#6835)
-         * @private
+         * @internal
          */
         function safeBounds(pixelPos) {
             return (0,external_highcharts_src_js_default_namespaceObject.clamp)(pixelPos, -safeDistance, safeDistance);
@@ -4465,7 +5113,9 @@ class ColumnRangeSeries extends ColumnRangeSeries_AreaRangeSeries {
                 point.plotLow = safeBounds(plotY);
                 // Adjust shape
                 y = point.plotHigh;
-                height = (0,external_highcharts_src_js_default_namespaceObject.pick)(point.rectPlotY, point.plotY) - point.plotHigh;
+                height =
+                    (point.rectPlotY ?? point.plotY) -
+                        point.plotHigh;
                 // Adjust for minPointLength
                 if (Math.abs(height) < minPointLength) {
                     heightDifference = (minPointLength - height);
@@ -4511,7 +5161,7 @@ class ColumnRangeSeries extends ColumnRangeSeries_AreaRangeSeries {
  *  Static Properties
  *
  * */
-ColumnRangeSeries.defaultOptions = (0,external_highcharts_src_js_default_namespaceObject.merge)(ColumnSeries.defaultOptions, ColumnRangeSeries_AreaRangeSeries.defaultOptions, columnRangeOptions);
+ColumnRangeSeries.defaultOptions = (0,external_highcharts_src_js_default_namespaceObject.merge)(ColumnSeries.defaultOptions, ColumnRangeSeries_AreaRangeSeries.defaultOptions, ColumnRange_ColumnRangeSeriesDefaults);
 (0,external_highcharts_src_js_default_namespaceObject.addEvent)(ColumnRangeSeries, 'afterColumnTranslate', function () {
     ColumnRangeSeries.prototype.afterColumnTranslate.apply(this);
 }, { order: 5 });
@@ -4531,98 +5181,11 @@ ColumnRangeSeries.defaultOptions = (0,external_highcharts_src_js_default_namespa
 external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('columnrange', ColumnRangeSeries);
 /* *
  *
- *  Default Export
- *
- * */
-/* harmony default export */ const ColumnRange_ColumnRangeSeries = ((/* unused pure expression or super */ null && (ColumnRangeSeries)));
-/* *
- *
- *  API Options
- *
- * */
-/**
- * A `columnrange` series. If the [type](#series.columnrange.type)
- * option is not specified, it is inherited from
- * [chart.type](#chart.type).
- *
- * @extends   series,plotOptions.columnrange
- * @excluding dataParser, dataURL, stack, stacking
- * @product   highcharts highstock
- * @requires  highcharts-more
- * @apioption series.columnrange
- */
-/**
- * An array of data points for the series. For the `columnrange` series
- * type, points can be given in the following ways:
- *
- * 1. An array of arrays with 3 or 2 values. In this case, the values correspond
- *    to `x,low,high`. If the first value is a string, it is applied as the name
- *    of the point, and the `x` value is inferred. The `x` value can also be
- *    omitted, in which case the inner arrays should be of length 2\. Then the
- *    `x` value is automatically calculated, either starting at 0 and
- *    incremented by 1, or from `pointStart` and `pointInterval` given in the
- *    series options.
- *    ```js
- *    data: [
- *        [0, 4, 2],
- *        [1, 2, 1],
- *        [2, 9, 10]
- *    ]
- *    ```
- *
- * 2. An array of objects with named values. The following snippet shows only a
- *    few settings, see the complete options set below. If the total number of
- *    data points exceeds the series'
- *    [turboThreshold](#series.columnrange.turboThreshold), this option is not
- *    available.
- *    ```js
- *    data: [{
- *        x: 1,
- *        low: 0,
- *        high: 4,
- *        name: "Point2",
- *        color: "#00FF00"
- *    }, {
- *        x: 1,
- *        low: 5,
- *        high: 3,
- *        name: "Point1",
- *        color: "#FF00FF"
- *    }]
- *    ```
- *
- * @sample {highcharts} highcharts/series/data-array-of-arrays/
- *         Arrays of numeric x and y
- * @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/
- *         Arrays of datetime x and y
- * @sample {highcharts} highcharts/series/data-array-of-name-value/
- *         Arrays of point.name and y
- * @sample {highcharts} highcharts/series/data-array-of-objects/
- *         Config objects
- *
- * @basic
- * @type      {Array<Array<(number|string),number>|Array<(number|string),number,number>|*>}
- * @extends   series.arearange.data
- * @excluding marker
- * @product   highcharts highstock
- * @apioption series.columnrange.data
- */
-/**
- * @extends   series.columnrange.dataLabels
- * @product   highcharts highstock
- * @apioption series.columnrange.data.dataLabels
- */
-/**
- * @excluding halo, lineWidth, lineWidthPlus, marker
- * @product   highcharts highstock
- * @apioption series.columnrange.states.hover
- */
-/**
- * @excluding halo, lineWidth, lineWidthPlus, marker
- * @product   highcharts highstock
- * @apioption series.columnrange.states.select
- */
-''; // Adds doclets above into transpiled
+ *  Default Export
+ *
+ * */
+/** @internal */
+/* harmony default export */ const ColumnRange_ColumnRangeSeries = ((/* unused pure expression or super */ null && (ColumnRangeSeries)));
 
 ;// ./code/es-modules/Series/ColumnPyramid/ColumnPyramidSeriesDefaults.js
 /* *
@@ -4779,7 +5342,7 @@ const { column: ColumnPyramidSeries_ColumnSeries } = (external_highcharts_src_js
 /**
  * The ColumnPyramidSeries class
  *
- * @private
+ * @internal
  * @class
  * @name Highcharts.seriesTypes.columnpyramid
  *
@@ -4793,12 +5356,12 @@ class ColumnPyramidSeries extends ColumnPyramidSeries_ColumnSeries {
      * */
     /**
      * Overrides the column translate method
-     * @private
+     * @internal
      */
     translate() {
         const series = this, chart = series.chart, options = series.options, dense = series.dense =
-            series.closestPointRange * series.xAxis.transA < 2, borderWidth = series.borderWidth = (0,external_highcharts_src_js_default_namespaceObject.pick)(options.borderWidth, dense ? 0 : 1 // #3635
-        ), yAxis = series.yAxis, threshold = options.threshold, minPointLength = (0,external_highcharts_src_js_default_namespaceObject.pick)(options.minPointLength, 5), metrics = series.getColumnMetrics(), pointWidth = metrics.width, pointXOffset = series.pointXOffset = metrics.offset;
+            series.closestPointRange * series.xAxis.transA < 2, borderWidth = series.borderWidth =
+            options.borderWidth ?? (dense ? 0 : 1), yAxis = series.yAxis, threshold = options.threshold, minPointLength = (options.minPointLength ?? 5), metrics = series.getColumnMetrics(), pointWidth = metrics.width, pointXOffset = series.pointXOffset = metrics.offset;
         let translatedThreshold = series.translatedThreshold =
             yAxis.getThreshold(threshold), 
         // Postprocessed for border width
@@ -4818,7 +5381,7 @@ class ColumnPyramidSeries extends ColumnPyramidSeries_ColumnSeries {
         super.translate();
         // Record the new values
         for (const point of series.points) {
-            const yBottom = (0,external_highcharts_src_js_default_namespaceObject.pick)(point.yBottom, translatedThreshold), safeDistance = 999 + Math.abs(yBottom), plotY = (0,external_highcharts_src_js_default_namespaceObject.clamp)(point.plotY, -safeDistance, yAxis.len + safeDistance), 
+            const yBottom = (point.yBottom ?? translatedThreshold), safeDistance = 999 + Math.abs(yBottom), plotY = (0,external_highcharts_src_js_default_namespaceObject.clamp)(point.plotY, -safeDistance, yAxis.len + safeDistance), 
             // Don't draw too far outside plot area
             // (#1303, #2241, #4264)
             barW = seriesBarW / 2, barY = Math.min(plotY, yBottom), barH = Math.max(plotY, yBottom) - barY;
@@ -4934,6 +5497,7 @@ external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('
  *  Default Export
  *
  * */
+/** @internal */
 /* harmony default export */ const ColumnPyramid_ColumnPyramidSeries = ((/* unused pure expression or super */ null && (ColumnPyramidSeries)));
 
 ;// ./code/es-modules/Series/ErrorBar/ErrorBarSeriesDefaults.js
@@ -4967,7 +5531,7 @@ external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('
  *         Error bars with data labels
  *
  * @extends      plotOptions.boxplot
- * @excluding    boostBlending, boostThreshold
+ * @excluding    borderRadius, boostBlending, boostThreshold
  * @product      highcharts
  * @requires     highcharts-more
  * @optionparent plotOptions.errorbar
@@ -4986,6 +5550,20 @@ const ErrorBarSeriesDefaults = {
      * @product highcharts
      */
     color: 'var(--highcharts-neutral-color-100)',
+    dataLabels: {
+    /**
+     * Callback JavaScript function to format the data label. Note that if
+     * a `format` is defined, the format takes precedence and the formatter
+     * is ignored.
+     *
+     * The default formatter renders the value of the point key the label
+     * is [aligned to](#plotOptions.errorbar.dataLabels.alignToKey). Define
+     * a [format](#plotOptions.errorbar.dataLabels.format) or `formatter`
+     * to display other values.
+     *
+     * @type {Highcharts.DataLabelsFormatterCallbackFunction}
+     */
+    },
     grouping: false,
     /**
      * The parent series of the error bar. The default value links it to
@@ -5106,6 +5684,7 @@ const ErrorBarSeriesDefaults = {
 
 const { arearange: ErrorBarSeries_AreaRangeSeries } = (external_highcharts_src_js_default_SeriesRegistry_default()).seriesTypes;
 
+
 /* *
  *
  *  Class
@@ -5114,7 +5693,7 @@ const { arearange: ErrorBarSeries_AreaRangeSeries } = (external_highcharts_src_j
 /**
  * Errorbar series type
  *
- * @private
+ * @internal
  * @class
  * @name Highcharts.seriesTypes.errorbar
  *
@@ -5134,14 +5713,9 @@ class ErrorBarSeries extends BoxPlot_BoxPlotSeries {
             external_highcharts_src_js_default_Series_types_column_default().prototype.getColumnMetrics.call(series));
     }
     drawDataLabels() {
-        const series = this, valKey = series.pointValKey;
+        // Error bars draw upper/lower labels via the area range option adapter.
         if (ErrorBarSeries_AreaRangeSeries) {
-            ErrorBarSeries_AreaRangeSeries.prototype.drawDataLabels.call(series);
-            // Arearange drawDataLabels does not reset point.y to high,
-            // but to low after drawing (#4133)
-            for (const point of series.points) {
-                point.y = point[valKey];
-            }
+            ErrorBarSeries_AreaRangeSeries.prototype.drawDataLabels.call(this);
         }
     }
     toYData(point) {
@@ -5154,7 +5728,7 @@ class ErrorBarSeries extends BoxPlot_BoxPlotSeries {
  *  Static Properties
  *
  * */
-ErrorBarSeries.defaultOptions = (0,external_highcharts_src_js_default_namespaceObject.merge)(BoxPlot_BoxPlotSeries.defaultOptions, ErrorBar_ErrorBarSeriesDefaults);
+ErrorBarSeries.defaultOptions = (0,external_highcharts_src_js_default_namespaceObject.merge)(BoxPlot_BoxPlotSeries.defaultOptions, ErrorBar_ErrorBarSeriesDefaults, { dataLabels: { formatter: Series_RangeDataLabel.formatter } });
 (0,external_highcharts_src_js_default_namespaceObject.addEvent)(ErrorBarSeries, 'afterTranslate', function () {
     for (const point of this.points) {
         point.plotLow = point.plotY;
@@ -5171,6 +5745,7 @@ external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('
  *  Default Export
  *
  * */
+/** @internal */
 /* harmony default export */ const ErrorBar_ErrorBarSeries = ((/* unused pure expression or super */ null && (ErrorBarSeries)));
 
 ;// ./code/es-modules/Series/Gauge/GaugePoint.js
@@ -5411,7 +5986,7 @@ class GaugeSeries extends GaugeSeries_Series {
         GaugeSeries_Series.prototype.setData.call(this, data, false);
         this.processData();
         this.generatePoints();
-        if ((0,external_highcharts_src_js_default_namespaceObject.pick)(redraw, true)) {
+        if (redraw ?? true) {
             this.chart.redraw();
         }
     }
@@ -5852,7 +6427,7 @@ const { composed: DragNodesComposition_composed } = (external_highcharts_src_js_
  *
  * */
 /**
- * @private
+ * @internal
  */
 function DragNodesComposition_compose(ChartClass) {
     if ((0,external_highcharts_src_js_default_namespaceObject.pushUnique)(DragNodesComposition_composed, 'DragNodes')) {
@@ -5861,7 +6436,7 @@ function DragNodesComposition_compose(ChartClass) {
 }
 /**
  * Draggable mode:
- * @private
+ * @internal
  */
 function onChartLoad() {
     const chart = this;
@@ -5900,7 +6475,7 @@ function onChartLoad() {
 /**
  * Mouse down action, initializing drag&drop mode.
  *
- * @private
+ * @internal
  * @param {Highcharts.Point} point
  *        The point that event occurred.
  * @param {Highcharts.PointerEventObject} event
@@ -5923,7 +6498,7 @@ function onMouseDown(point, event) {
 /**
  * Mouse move action during drag&drop.
  *
- * @private
+ * @internal
  *
  * @param {Highcharts.Point} point
  *        The point that event occurred.
@@ -5953,7 +6528,7 @@ function onMouseMove(point, event) {
 /**
  * Mouse up action, finalizing drag&drop.
  *
- * @private
+ * @internal
  * @param {Highcharts.Point} point
  *        The point that event occurred.
  */
@@ -5976,14 +6551,15 @@ function onMouseUp(point) {
 /**
  * Redraw halo on mousemove during the drag&drop action.
  *
- * @private
+ * @internal
  * @param {Highcharts.Point} point
  *        The point that should show halo.
  */
 function redrawHalo(point) {
     if (point && this.halo) {
         this.halo.attr({
-            d: point.haloPath(this.options.states.hover.halo.size)
+            d: point.haloPath((0,external_highcharts_src_js_default_namespaceObject.isObject)(this.options.states?.hover?.halo) &&
+                this.options.states?.hover?.halo.size || 0)
         });
     }
 }
@@ -5992,6 +6568,7 @@ function redrawHalo(point) {
  *  Default Export
  *
  * */
+/** @internal */
 const DragNodesComposition = {
     compose: DragNodesComposition_compose,
     onMouseDown,
@@ -5999,6 +6576,7 @@ const DragNodesComposition = {
     onMouseUp,
     redrawHalo
 };
+/** @internal */
 /* harmony default export */ const Series_DragNodesComposition = (DragNodesComposition);
 
 ;// ./code/es-modules/Series/GraphLayoutComposition.js
@@ -6017,7 +6595,6 @@ const DragNodesComposition = {
  * */
 
 
-const { setAnimation } = (external_highcharts_src_js_default_default());
 
 const { composed: GraphLayoutComposition_composed } = (external_highcharts_src_js_default_default());
 
@@ -6105,7 +6682,7 @@ function onChartRender() {
     };
     // Don't animate layout when series is dragged
     if (this.graphLayoutsLookup && !this.pointer?.hasDragged) {
-        setAnimation(false, this);
+        (0,external_highcharts_src_js_default_namespaceObject.setAnimation)(false, this);
         // Start simulation
         this.graphLayoutsLookup.forEach((layout) => layout.start());
         // Just one sync step, to run different layouts similar to
@@ -6118,6 +6695,7 @@ function onChartRender() {
             this.series.forEach((series) => {
                 if (series && series.layout) {
                     series.render();
+                    (0,external_highcharts_src_js_default_namespaceObject.fireEvent)(series, 'afterSimulation');
                 }
             });
         }
@@ -7584,12 +8162,16 @@ class ReingoldFruchtermanLayout {
         this.integration =
             Series_GraphLayoutComposition.integrations[options.integration];
         this.enableSimulation = options.enableSimulation;
-        this.attractiveForce = (0,external_highcharts_src_js_default_namespaceObject.pick)(options.attractiveForce, this.integration.attractiveForceFunction);
-        this.repulsiveForce = (0,external_highcharts_src_js_default_namespaceObject.pick)(options.repulsiveForce, this.integration.repulsiveForceFunction);
+        this.attractiveForce =
+            options.attractiveForce ??
+                this.integration.attractiveForceFunction;
+        this.repulsiveForce =
+            options.repulsiveForce ??
+                this.integration.repulsiveForceFunction;
         this.approximation = options.approximation;
     }
     updateSimulation(enable) {
-        this.enableSimulation = (0,external_highcharts_src_js_default_namespaceObject.pick)(enable, this.options.enableSimulation);
+        this.enableSimulation = (enable ?? this.options.enableSimulation);
     }
     start() {
         const layout = this, series = this.series, options = this.options;
@@ -7719,7 +8301,7 @@ class ReingoldFruchtermanLayout {
         }
     }
     setMaxIterations(maxIterations) {
-        this.maxIterations = (0,external_highcharts_src_js_default_namespaceObject.pick)(maxIterations, this.options.maxIterations);
+        this.maxIterations = (maxIterations ?? this.options.maxIterations);
     }
     setTemperature() {
         this.temperature = this.startTemperature =
@@ -7795,8 +8377,12 @@ class ReingoldFruchtermanLayout {
         // as a cluster in the middle
         for (let i = 0, iEnd = sortedNodes.length; i < iEnd; ++i) {
             node = sortedNodes[i];
-            node.plotX = node.prevX = (0,external_highcharts_src_js_default_namespaceObject.pick)(node.plotX, box.width / 2 + radius * Math.cos(i * angle));
-            node.plotY = node.prevY = (0,external_highcharts_src_js_default_namespaceObject.pick)(node.plotY, box.height / 2 + radius * Math.sin(i * angle));
+            node.plotX = node.prevX =
+                node.plotX ??
+                    box.width / 2 + radius * Math.cos(i * angle);
+            node.plotY = node.prevY =
+                node.plotY ??
+                    box.height / 2 + radius * Math.sin(i * angle);
             node.dispX = 0;
             node.dispY = 0;
         }
@@ -7817,8 +8403,9 @@ class ReingoldFruchtermanLayout {
         // Initial positions:
         for (let i = 0, iEnd = nodes.length; i < iEnd; ++i) {
             node = nodes[i];
-            node.plotX = node.prevX = (0,external_highcharts_src_js_default_namespaceObject.pick)(node.plotX, box.width * unrandom(i));
-            node.plotY = node.prevY = (0,external_highcharts_src_js_default_namespaceObject.pick)(node.plotY, box.height * unrandom(nodesLength + i));
+            node.plotX = node.prevX = (node.plotX ?? box.width * unrandom(i));
+            node.plotY = node.prevY =
+                node.plotY ?? box.height * unrandom(nodesLength + i);
             node.dispX = 0;
             node.dispY = 0;
         }
@@ -8141,9 +8728,9 @@ class PackedBubbleLayout extends Networkgraph_ReingoldFruchtermanLayout {
                 centerX = box.width / 2;
                 centerY = box.height / 2;
             }
-            node.plotX = node.prevX = (0,external_highcharts_src_js_default_namespaceObject.pick)(node.plotX, centerX +
+            node.plotX = node.prevX = (node.plotX ?? centerX +
                 radius * Math.cos(node.index || index * angle));
-            node.plotY = node.prevY = (0,external_highcharts_src_js_default_namespaceObject.pick)(node.plotY, centerY +
+            node.plotY = node.prevY = (node.plotY ?? centerY +
                 radius * Math.sin(node.index || index * angle));
             node.dispX = 0;
             node.dispY = 0;
@@ -8243,7 +8830,6 @@ Series_GraphLayoutComposition.layouts.packedbubble = PackedBubbleLayout;
 
 
 
-const { animObject } = (external_highcharts_src_js_default_default());
 /**
  * Create a setTimeout for the first drawDataLabels()
  * based on the dataLabels.animation.defer value
@@ -8263,7 +8849,7 @@ function initDataLabelsDefer() {
     else {
         (0,external_highcharts_src_js_default_namespaceObject.syncTimeout)(() => {
             this.deferDataLabels = false;
-        }, dlOptions ? animObject(dlOptions.animation).defer : 0);
+        }, dlOptions ? (0,external_highcharts_src_js_default_namespaceObject.animObject)(dlOptions.animation).defer : 0);
     }
 }
 /**
@@ -8773,8 +9359,8 @@ class PackedBubbleSeries extends PackedBubbleSeries_BubbleSeries {
                 }
             });
         });
-        zMin = (0,external_highcharts_src_js_default_namespaceObject.pick)(zMin, valMin);
-        zMax = (0,external_highcharts_src_js_default_namespaceObject.pick)(zMax, valMax);
+        zMin = (zMin ?? valMin);
+        zMax = (zMax ?? valMax);
         return [zMin, zMax];
     }
     /**
@@ -8913,7 +9499,7 @@ class PackedBubbleSeries extends PackedBubbleSeries_BubbleSeries {
                 color(this.color).brighten(0.4).get()),
             opacity: nodeMarker.fillOpacity,
             stroke: nodeMarker.lineColor || this.color,
-            'stroke-width': (0,external_highcharts_src_js_default_namespaceObject.pick)(nodeMarker.lineWidth, this.options.lineWidth)
+            'stroke-width': (nodeMarker.lineWidth ?? this.options.lineWidth)
         };
         let parentAttribs = {};
         // Create the group for parent Nodes if doesn't exist
@@ -9368,7 +9954,7 @@ class PackedBubbleSeries extends PackedBubbleSeries_BubbleSeries {
                 // Update the series points with the val from positions
                 // array
                 point = data[position[4]];
-                radius = (0,external_highcharts_src_js_default_namespaceObject.pick)(position[2], void 0);
+                radius = (position[2] ?? void 0);
                 if (!useSimulation) {
                     point.plotX = (position[0] - chart.plotLeft +
                         chart.diffX);
@@ -9436,577 +10022,208 @@ external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('
 
 /* *
  *
- *  API Options
- *
- * */
-/**
- * A polygon series can be used to draw any freeform shape in the cartesian
- * coordinate system. A fill is applied with the `color` option, and
- * stroke is applied through `lineWidth` and `lineColor` options.
- *
- * @sample {highcharts} highcharts/demo/polygon/
- *         Polygon
- * @sample {highstock} highcharts/demo/polygon/
- *         Polygon
- *
- * @extends      plotOptions.scatter
- * @since        4.1.0
- * @excluding    jitter, softThreshold, threshold, cluster, boostThreshold,
- *               boostBlending
- * @product      highcharts highstock
- * @requires     highcharts-more
- * @optionparent plotOptions.polygon
- */
-const PolygonSeriesDefaults = {
-    marker: {
-        enabled: false,
-        states: {
-            hover: {
-                enabled: false
-            }
-        }
-    },
-    stickyTracking: false,
-    tooltip: {
-        followPointer: true,
-        pointFormat: ''
-    },
-    trackByArea: true,
-    legendSymbol: 'rectangle'
-};
-/**
- * A `polygon` series. If the [type](#series.polygon.type) option is
- * not specified, it is inherited from [chart.type](#chart.type).
- *
- * @extends   series,plotOptions.polygon
- * @excluding dataParser, dataURL, stack, boostThreshold, boostBlending
- * @product   highcharts highstock
- * @requires  highcharts-more
- * @apioption series.polygon
- */
-/**
- * An array of data points for the series. For the `polygon` series
- * type, points can be given in the following ways:
- *
- * 1. An array of numerical values. In this case, the numerical values will be
- *    interpreted as `y` options. The `x` values will be automatically
- *    calculated, either starting at 0 and incremented by 1, or from
- *    `pointStart` and `pointInterval` given in the series options. If the axis
- *    has categories, these will be used. Example:
- *    ```js
- *    data: [0, 5, 3, 5]
- *    ```
- *
- * 2. An array of arrays with 2 values. In this case, the values correspond to
- *    `x,y`. If the first value is a string, it is applied as the name of the
- *    point, and the `x` value is inferred.
- *    ```js
- *    data: [
- *        [0, 10],
- *        [1, 3],
- *        [2, 1]
- *    ]
- *    ```
- *
- * 3. An array of objects with named values. The following snippet shows only a
- *    few settings, see the complete options set below. If the total number of
- *    data points exceeds the series'
- *    [turboThreshold](#series.polygon.turboThreshold), this option is not
- *    available.
- *    ```js
- *    data: [{
- *        x: 1,
- *        y: 1,
- *        name: "Point2",
- *        color: "#00FF00"
- *    }, {
- *        x: 1,
- *        y: 8,
- *        name: "Point1",
- *        color: "#FF00FF"
- *    }]
- *    ```
- *
- * @sample {highcharts} highcharts/chart/reflow-true/
- *         Numerical values
- * @sample {highcharts} highcharts/series/data-array-of-arrays/
- *         Arrays of numeric x and y
- * @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/
- *         Arrays of datetime x and y
- * @sample {highcharts} highcharts/series/data-array-of-name-value/
- *         Arrays of point.name and y
- * @sample {highcharts} highcharts/series/data-array-of-objects/
- *         Config objects
- *
- * @basic
- * @type      {Array<number|Array<(number|string),(number|null)>|null|*>}
- * @extends   series.line.data
- * @product   highcharts highstock
- * @apioption series.polygon.data
- */
-''; // Keeps doclets above separate
-/* *
- *
- *  Default Export
- *
- * */
-/* harmony default export */ const Polygon_PolygonSeriesDefaults = (PolygonSeriesDefaults);
-
-;// ./code/es-modules/Series/Polygon/PolygonSeries.js
-/* *
- *
- *  (c) 2010-2026 Highsoft AS
- *  Author: Torstein Hønsi
- *
- *  Integration of this software requires a license.
- *  - For commercial use, see www.highcharts.com/license
- *  - For non-commercial, see www.highcharts.com/license-eula
- *
- *
- * */
-
-
-const { noop: PolygonSeries_noop } = (external_highcharts_src_js_default_default());
-
-
-const { area: PolygonSeries_AreaSeries, line: LineSeries, scatter: PolygonSeries_ScatterSeries } = (external_highcharts_src_js_default_SeriesRegistry_default()).seriesTypes;
-
-/* *
- *
- *  Class
- *
- * */
-class PolygonSeries extends PolygonSeries_ScatterSeries {
-    /* *
-     *
-     *  Functions
-     *
-     * */
-    getGraphPath() {
-        const graphPath = LineSeries.prototype.getGraphPath.call(this);
-        let i = graphPath.length + 1;
-        // Close all segments
-        while (i--) {
-            if ((i === graphPath.length || graphPath[i][0] === 'M') && i > 0) {
-                graphPath.splice(i, 0, ['Z']);
-            }
-        }
-        this.areaPath = graphPath;
-        return graphPath;
-    }
-    drawGraph() {
-        // Hack into the fill logic in area.drawGraph
-        this.options.fillColor = this.color;
-        PolygonSeries_AreaSeries.prototype.drawGraph.call(this);
-    }
-}
-/* *
- *
- *  Static Properties
- *
- * */
-PolygonSeries.defaultOptions = (0,external_highcharts_src_js_default_namespaceObject.merge)(PolygonSeries_ScatterSeries.defaultOptions, Polygon_PolygonSeriesDefaults);
-(0,external_highcharts_src_js_default_namespaceObject.extend)(PolygonSeries.prototype, {
-    type: 'polygon',
-    drawTracker: LineSeries.prototype.drawTracker,
-    setStackedPoints: PolygonSeries_noop // No stacking points on polygons (#5310)
-});
-external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('polygon', PolygonSeries);
-/* *
- *
- *  Default Export
- *
- * */
-/* harmony default export */ const Polygon_PolygonSeries = ((/* unused pure expression or super */ null && (PolygonSeries)));
-
-;// ./code/es-modules/Extensions/BorderRadius.js
-/* *
- *
- *  Highcharts Border Radius module
- *
- *  Author: Torstein Hønsi
- *
- *  Integration of this software requires a license.
- *  - For commercial use, see www.highcharts.com/license
- *  - For non-commercial, see www.highcharts.com/license-eula
- *
- *
- * */
-
-
-const { defaultOptions: BorderRadius_defaultOptions } = (external_highcharts_src_js_default_default());
-
-const { noop: BorderRadius_noop } = (external_highcharts_src_js_default_default());
-
-/* *
- *
- *  Constants
- *
- * */
-const defaultBorderRadiusOptions = {
-    radius: 0,
-    scope: 'stack',
-    where: void 0
-};
-/* *
- *
- *  Variables
+ *  API Options
  *
  * */
-let oldArc = (/* unused pure expression or super */ null && (BorderRadius_noop));
-let oldRoundedRect = (/* unused pure expression or super */ null && (BorderRadius_noop));
-/* *
+/**
+ * A polygon series can be used to draw any freeform shape in the cartesian
+ * coordinate system. A fill is applied with the `color` option, and
+ * stroke is applied through `lineWidth` and `lineColor` options.
  *
- *  Functions
+ * @sample {highcharts} highcharts/demo/polygon/
+ *         Polygon
+ * @sample {highstock} highcharts/demo/polygon/
+ *         Polygon
  *
- * */
-/** @internal */
-function applyBorderRadius(path, i, r) {
-    const a = path[i];
-    let b = path[i + 1];
-    if (b[0] === 'Z') {
-        b = path[0];
-    }
-    let line, arc, fromLineToArc;
-    // From straight line to arc
-    if ((a[0] === 'M' || a[0] === 'L') && b[0] === 'A') {
-        line = a;
-        arc = b;
-        fromLineToArc = true;
-        // From arc to straight line
-    }
-    else if (a[0] === 'A' && (b[0] === 'M' || b[0] === 'L')) {
-        line = b;
-        arc = a;
-    }
-    if (line && arc && arc.params) {
-        const bigR = arc[1], 
-        // In our use cases, outer pie slice arcs are clockwise and inner
-        // arcs (donut/sunburst etc) are anti-clockwise
-        clockwise = arc[5], params = arc.params, { start, end, cx, cy } = params;
-        // Some geometric constants
-        const relativeR = clockwise ? (bigR - r) : (bigR + r), 
-        // The angle, on the big arc, that the border radius arc takes up
-        angleOfBorderRadius = relativeR ? Math.asin(r / relativeR) : 0, angleOffset = clockwise ?
-            angleOfBorderRadius :
-            -angleOfBorderRadius, 
-        // The distance along the radius of the big arc to the starting
-        // point of the small border radius arc
-        distanceBigCenterToStartArc = (Math.cos(angleOfBorderRadius) *
-            relativeR);
-        // From line to arc
-        if (fromLineToArc) {
-            // Update the cache
-            params.start = start + angleOffset;
-            // First move to the start position at the radial line. We want to
-            // start one borderRadius closer to the center.
-            line[1] = cx + distanceBigCenterToStartArc * Math.cos(start);
-            line[2] = cy + distanceBigCenterToStartArc * Math.sin(start);
-            // Now draw an arc towards the point where the small circle touches
-            // the great circle.
-            path.splice(i + 1, 0, [
-                'A',
-                r,
-                r,
-                0, // Slanting,
-                0, // Long arc
-                1, // Clockwise
-                cx + bigR * Math.cos(params.start),
-                cy + bigR * Math.sin(params.start)
-            ]);
-            // From arc to line
-        }
-        else {
-            // Update the cache
-            params.end = end - angleOffset;
-            // End the big arc a bit earlier
-            arc[6] = cx + bigR * Math.cos(params.end);
-            arc[7] = cy + bigR * Math.sin(params.end);
-            // Draw a small arc towards a point on the end angle, but one
-            // borderRadius closer to the center relative to the perimeter.
-            path.splice(i + 1, 0, [
-                'A',
-                r,
-                r,
-                0,
-                0,
-                1,
-                cx + distanceBigCenterToStartArc * Math.cos(end),
-                cy + distanceBigCenterToStartArc * Math.sin(end)
-            ]);
-        }
-        // Long or short arc must be reconsidered because we have modified the
-        // start and end points
-        arc[4] = Math.abs(params.end - params.start) < Math.PI ? 0 : 1;
-    }
-}
-/**
- * Extend arc with borderRadius.
- * @internal
+ * @extends      plotOptions.scatter
+ * @since        4.1.0
+ * @excluding    jitter, softThreshold, threshold, cluster, boostThreshold,
+ *               boostBlending
+ * @product      highcharts highstock
+ * @requires     highcharts-more
+ * @optionparent plotOptions.polygon
  */
-function arc(x, y, w, h, options = {}) {
-    const path = oldArc(x, y, w, h, options), { brStart = true, brEnd = true, innerR = 0, r = w, start = 0, end = 0 } = options;
-    if (options.open || !options.borderRadius) {
-        return path;
-    }
-    const alpha = end - start, sinHalfAlpha = Math.sin(alpha / 2), borderRadius = Math.max(Math.min(relativeLength(options.borderRadius || 0, r - innerR), 
-    // Cap to half the sector radius
-    (r - innerR) / 2, 
-    // For smaller pie slices, cap to the largest small circle that
-    // can be fitted within the sector
-    (r * sinHalfAlpha) / (1 + sinHalfAlpha)), 0), 
-    // For the inner radius, we need an extra cap because the inner arc
-    // is shorter than the outer arc
-    innerBorderRadius = Math.min(borderRadius, 2 * (alpha / Math.PI) * innerR);
-    // Apply turn-by-turn border radius. Start at the end since we're
-    // splicing in arc segments.
-    let i = path.length - 1;
-    while (i--) {
-        if ((!brStart && (i === 0 || i === 3)) ||
-            (!brEnd && (i === 1 || i === 2))) {
-            continue;
-        }
-        applyBorderRadius(path, i, i > 1 ? innerBorderRadius : borderRadius);
-    }
-    return path;
-}
-/** @internal */
-function seriesOnAfterColumnTranslate() {
-    if (this.options.borderRadius &&
-        !(this.chart.is3d && this.chart.is3d())) {
-        const { options, yAxis } = this, percent = options.stacking === 'percent', seriesDefault = BorderRadius_defaultOptions.plotOptions?.[this.type]
-            ?.borderRadius, borderRadius = optionsToObject(options.borderRadius, isObject(seriesDefault) ? seriesDefault : {}), reversed = yAxis.options.reversed;
-        for (const point of this.points) {
-            const { shapeArgs } = point;
-            if (point.shapeType === 'roundedRect' && shapeArgs) {
-                const { width = 0, height = 0, y = 0 } = shapeArgs;
-                let brBoxY = y, brBoxHeight = height;
-                // It would be nice to refactor StackItem.getStackBox/
-                // setOffset so that we could get a reliable box out of
-                // it. Currently it is close if we remove the label
-                // offset, but we still need to run crispCol and also
-                // flip it if inverted, so atm it is simpler to do it
-                // like the below.
-                if (borderRadius.scope === 'stack' &&
-                    point.stackTotal) {
-                    const stackEnd = yAxis.translate(percent ? 100 : point.stackTotal, false, true, false, true), stackThreshold = yAxis.translate(options.threshold || 0, false, true, false, true), box = this.crispCol(0, Math.min(stackEnd, stackThreshold), 0, Math.abs(stackEnd - stackThreshold));
-                    brBoxY = box.y;
-                    brBoxHeight = box.height;
-                }
-                const flip = (point.negative ? -1 : 1) *
-                    (reversed ? -1 : 1) === -1;
-                // Handle the where option
-                let where = borderRadius.where;
-                // Waterfall, hanging columns should have rounding on
-                // all sides
-                if (!where &&
-                    this.is('waterfall') &&
-                    Math.abs((point.yBottom || 0) -
-                        (this.translatedThreshold || 0)) > this.borderWidth) {
-                    where = 'all';
-                }
-                if (!where) {
-                    where = 'end';
-                }
-                // Get the radius
-                const r = Math.min(relativeLength(borderRadius.radius, width), width / 2, 
-                // Cap to the height, but not if where is `end`
-                where === 'all' ? brBoxHeight / 2 : Infinity) || 0;
-                // If the `where` option is 'end', cut off the
-                // rectangles by making the border-radius box one r
-                // greater, so that the imaginary radius falls outside
-                // the rectangle.
-                if (where === 'end') {
-                    if (flip) {
-                        brBoxY -= r;
-                        brBoxHeight += r;
-                    }
-                    else {
-                        brBoxHeight += r;
-                    }
-                }
-                extend(shapeArgs, { brBoxHeight, brBoxY, r });
+const PolygonSeriesDefaults = {
+    /**
+     * Fill opacity for the polygon. When you set an explicit `fillColor`,
+     * the `fillOpacity` is not applied. Instead, you should define the
+     * opacity in the `fillColor` with an rgba color definition.
+     *
+     * In styled mode, the fill opacity can be set with the
+     * `.highcharts-area` class name.
+     *
+     * @see [color](#plotOptions.polygon.color)
+     * @see [fillColor](#plotOptions.polygon.fillColor)
+     *
+     * @sample {highcharts} highcharts/demo/violin-plot/
+     *         Translucent violins
+     *
+     * @type    {number}
+     * @default 1
+     * @since   13.0.1
+     * @product highcharts highstock
+     */
+    fillOpacity: 1,
+    marker: {
+        enabled: false,
+        states: {
+            hover: {
+                enabled: false
             }
         }
-    }
-}
-/** @internal */
-function composeBorderRadius(SeriesClass, SVGElementClass, SVGRendererClass) {
-    const PieSeriesClass = SeriesClass.types.pie;
-    if (!SVGElementClass.symbolCustomAttribs.includes('borderRadius')) {
-        const symbols = SVGRendererClass.prototype.symbols;
-        addEvent(SeriesClass, 'afterColumnTranslate', seriesOnAfterColumnTranslate, {
-            // After columnrange and polar column modifications
-            order: 9
-        });
-        addEvent(PieSeriesClass, 'afterTranslate', pieSeriesOnAfterTranslate);
-        SVGElementClass.symbolCustomAttribs.push('borderRadius', 'brBoxHeight', 'brBoxY', 'brEnd', 'brStart');
-        oldArc = symbols.arc;
-        oldRoundedRect = symbols.roundedRect;
-        symbols.arc = arc;
-        symbols.roundedRect = roundedRect;
-    }
-}
-/** @internal */
-function optionsToObject(options, seriesBROptions) {
-    if (!(0,external_highcharts_src_js_default_namespaceObject.isObject)(options)) {
-        options = { radius: options || 0 };
-    }
-    return (0,external_highcharts_src_js_default_namespaceObject.merge)(defaultBorderRadiusOptions, seriesBROptions, options);
-}
-/** @internal */
-function pieSeriesOnAfterTranslate() {
-    const borderRadius = optionsToObject(this.options.borderRadius);
-    for (const point of this.points) {
-        const shapeArgs = point.shapeArgs;
-        if (shapeArgs) {
-            shapeArgs.borderRadius = relativeLength(borderRadius.radius, (shapeArgs.r || 0) - ((shapeArgs.innerR) || 0));
-        }
-    }
-}
+    },
+    stickyTracking: false,
+    tooltip: {
+        followPointer: true,
+        pointFormat: ''
+    },
+    trackByArea: true,
+    legendSymbol: 'rectangle'
+};
 /**
- * Extend roundedRect with individual cutting through rOffset.
- * @internal
+ * A `polygon` series. If the [type](#series.polygon.type) option is
+ * not specified, it is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.polygon
+ * @excluding dataParser, dataURL, stack, boostThreshold, boostBlending
+ * @product   highcharts highstock
+ * @requires  highcharts-more
+ * @apioption series.polygon
  */
-function roundedRect(x, y, width, height, options = {}) {
-    const path = oldRoundedRect(x, y, width, height, options), { r = 0, brBoxHeight = height, brBoxY = y } = options, brOffsetTop = y - brBoxY, brOffsetBtm = (brBoxY + brBoxHeight) - (y + height), 
-    // When the distance to the border-radius box is greater than the r
-    // itself, it means no border radius. The -0.1 accounts for float
-    // rounding errors.
-    rTop = (brOffsetTop - r) > -0.1 ? 0 : r, rBtm = (brOffsetBtm - r) > -0.1 ? 0 : r, cutTop = Math.max(rTop && brOffsetTop, 0), cutBtm = Math.max(rBtm && brOffsetBtm, 0);
-    /*
+/**
+ * An array of data points for the series. For the `polygon` series
+ * type, points can be given in the following ways:
+ *
+ * 1. An array of numerical values. In this case, the numerical values will be
+ *    interpreted as `y` options. The `x` values will be automatically
+ *    calculated, either starting at 0 and incremented by 1, or from
+ *    `pointStart` and `pointInterval` given in the series options. If the axis
+ *    has categories, these will be used. Example:
+ *    ```js
+ *    data: [0, 5, 3, 5]
+ *    ```
+ *
+ * 2. An array of arrays with 2 values. In this case, the values correspond to
+ *    `x,y`. If the first value is a string, it is applied as the name of the
+ *    point, and the `x` value is inferred.
+ *    ```js
+ *    data: [
+ *        [0, 10],
+ *        [1, 3],
+ *        [2, 1]
+ *    ]
+ *    ```
+ *
+ * 3. An array of objects with named values. The following snippet shows only a
+ *    few settings, see the complete options set below. If the total number of
+ *    data points exceeds the series'
+ *    [turboThreshold](#series.polygon.turboThreshold), this option is not
+ *    available.
+ *    ```js
+ *    data: [{
+ *        x: 1,
+ *        y: 1,
+ *        name: "Point2",
+ *        color: "#00FF00"
+ *    }, {
+ *        x: 1,
+ *        y: 8,
+ *        name: "Point1",
+ *        color: "#FF00FF"
+ *    }]
+ *    ```
+ *
+ * @sample {highcharts} highcharts/chart/reflow-true/
+ *         Numerical values
+ * @sample {highcharts} highcharts/series/data-array-of-arrays/
+ *         Arrays of numeric x and y
+ * @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/
+ *         Arrays of datetime x and y
+ * @sample {highcharts} highcharts/series/data-array-of-name-value/
+ *         Arrays of point.name and y
+ * @sample {highcharts} highcharts/series/data-array-of-objects/
+ *         Config objects
+ *
+ * @basic
+ * @type      {Array<number|Array<(number|string),(number|null)>|null|*>}
+ * @extends   series.line.data
+ * @product   highcharts highstock
+ * @apioption series.polygon.data
+ */
+''; // Keeps doclets above separate
+/* *
+ *
+ *  Default Export
+ *
+ * */
+/* harmony default export */ const Polygon_PolygonSeriesDefaults = (PolygonSeriesDefaults);
 
-    The naming of control points:
+;// ./code/es-modules/Series/Polygon/PolygonSeries.js
+/* *
+ *
+ *  (c) 2010-2026 Highsoft AS
+ *  Author: Torstein Hønsi
+ *
+ *  Integration of this software requires a license.
+ *  - For commercial use, see www.highcharts.com/license
+ *  - For non-commercial, see www.highcharts.com/license-eula
+ *
+ *
+ * */
 
-      / a -------- b \
-     /                \
-    h                  c
-    |                  |
-    |                  |
-    |                  |
-    g                  d
-     \                /
-      \ f -------- e /
 
-    */
-    const a = [x + rTop, y], b = [x + width - rTop, y], c = [x + width, y + rTop], d = [
-        x + width, y + height - rBtm
-    ], e = [
-        x + width - rBtm,
-        y + height
-    ], f = [x + rBtm, y + height], g = [x, y + height - rBtm], h = [x, y + rTop];
-    const applyPythagoras = (r, altitude) => Math.sqrt(Math.pow(r, 2) - Math.pow(altitude, 2));
-    // Inside stacks, cut off part of the top
-    if (cutTop) {
-        const base = applyPythagoras(rTop, rTop - cutTop);
-        a[0] -= base;
-        b[0] += base;
-        c[1] = h[1] = y + rTop - cutTop;
-    }
-    // Column is lower than the radius. Cut off bottom inside the top
-    // radius.
-    if (height < rTop - cutTop) {
-        const base = applyPythagoras(rTop, rTop - cutTop - height);
-        c[0] = d[0] = x + width - rTop + base;
-        e[0] = Math.min(c[0], e[0]);
-        f[0] = Math.max(d[0], f[0]);
-        g[0] = h[0] = x + rTop - base;
-        c[1] = h[1] = y + height;
-    }
-    // Inside stacks, cut off part of the bottom
-    if (cutBtm) {
-        const base = applyPythagoras(rBtm, rBtm - cutBtm);
-        e[0] += base;
-        f[0] -= base;
-        d[1] = g[1] = y + height - rBtm + cutBtm;
+const { noop: PolygonSeries_noop } = (external_highcharts_src_js_default_default());
+
+
+const { area: PolygonSeries_AreaSeries, line: LineSeries, scatter: PolygonSeries_ScatterSeries } = (external_highcharts_src_js_default_SeriesRegistry_default()).seriesTypes;
+
+/* *
+ *
+ *  Class
+ *
+ * */
+class PolygonSeries extends PolygonSeries_ScatterSeries {
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    getGraphPath() {
+        const graphPath = LineSeries.prototype.getGraphPath.call(this);
+        let i = graphPath.length + 1;
+        // Close all segments
+        while (i--) {
+            if ((i === graphPath.length || graphPath[i][0] === 'M') && i > 0) {
+                graphPath.splice(i, 0, ['Z']);
+            }
+        }
+        this.areaPath = graphPath;
+        return graphPath;
     }
-    // Cut off top inside the bottom radius
-    if (height < rBtm - cutBtm) {
-        const base = applyPythagoras(rBtm, rBtm - cutBtm - height);
-        c[0] = d[0] = x + width - rBtm + base;
-        b[0] = Math.min(c[0], b[0]);
-        a[0] = Math.max(d[0], a[0]);
-        g[0] = h[0] = x + rBtm - base;
-        d[1] = g[1] = y;
+    drawGraph() {
+        // Borrow the fill logic from area.drawGraph, honoring `fillOpacity`
+        // and an optional `fillColor`
+        PolygonSeries_AreaSeries.prototype.drawGraph.call(this);
     }
-    // Preserve the box for data labels
-    path.length = 0;
-    path.push(['M', ...a], 
-    // Top side
-    ['L', ...b], 
-    // Top right corner
-    ['A', rTop, rTop, 0, 0, 1, ...c], 
-    // Right side
-    ['L', ...d], 
-    // Bottom right corner
-    ['A', rBtm, rBtm, 0, 0, 1, ...e], 
-    // Bottom side
-    ['L', ...f], 
-    // Bottom left corner
-    ['A', rBtm, rBtm, 0, 0, 1, ...g], 
-    // Left side
-    ['L', ...h], 
-    // Top left corner
-    ['A', rTop, rTop, 0, 0, 1, ...a], ['Z']);
-    return path;
 }
 /* *
  *
- *  API Declarations
+ *  Static Properties
  *
  * */
-/**
- * Detailed options for border radius.
+PolygonSeries.defaultOptions = (0,external_highcharts_src_js_default_namespaceObject.merge)(PolygonSeries_ScatterSeries.defaultOptions, Polygon_PolygonSeriesDefaults);
+(0,external_highcharts_src_js_default_namespaceObject.extend)(PolygonSeries.prototype, {
+    type: 'polygon',
+    drawTracker: LineSeries.prototype.drawTracker,
+    setStackedPoints: PolygonSeries_noop // No stacking points on polygons (#5310)
+});
+external_highcharts_src_js_default_SeriesRegistry_default().registerSeriesType('polygon', PolygonSeries);
+/* *
  *
- * @sample  {highcharts} highcharts/plotoptions/column-borderradius/
- *          Rounded columns
- * @sample  highcharts/plotoptions/series-border-radius
- *          Column and pie with rounded border
+ *  Default Export
  *
- * @interface Highcharts.BorderRadiusOptionsObject
- */ /**
-* The border radius. A number signifies pixels. A percentage string, like for
-* example `50%`, signifies a relative size. For columns this is relative to the
-* column width, for pies it is relative to the radius and the inner radius.
-*
-* @sample  {highcharts} highcharts/plotoptions/column-borderradius/
-*          Rounded columns
-* @sample  highcharts/plotoptions/series-border-radius
-*          Column and pie with rounded border
-*
-* @name Highcharts.BorderRadiusOptionsObject#radius
-* @type {string|number}
-*/ /**
-* The scope of the rounding for column charts or plot bands. In a stacked
-* column chart, the value `point` means each single point will get rounded
-* corners. The value `stack` means the rounding will apply to the full
-* stack, so that only points close to the top or bottom will receive
-* rounding.
-*
-* Similarly, for plot bands, the `individual` value means each plot band
-* will get rounded corners.
-*
-* @sample  {highcharts} highcharts/plotoptions/column-borderradius/
-*          Rounded columns
-*
-* @name Highcharts.BorderRadiusOptionsObject#scope
-* @validvalue ["individual", "point", "stack"]
-* @type {string}
-*/ /**
-* For column charts, where in the point or stack to apply rounding. The `end`
-* value means only those corners at the point value will be rounded, leaving
-* the corners at the base or threshold unrounded. This is the most intuitive
-* behavior. The `all` value means also the base will be rounded.
-*
-* @sample  {highcharts} highcharts/plotoptions/column-borderradius-where-all
-*          Rounding on all corners
-*
-* @name Highcharts.BorderRadiusOptionsObject#where
-* @validvalue ["all", "end"]
-* @type {string}
-* @default end
-*/
-(''); // Keeps doclets above in JS file
+ * */
+/* harmony default export */ const Polygon_PolygonSeries = ((/* unused pure expression or super */ null && (PolygonSeries)));
 
 ;// external ["./highcharts.src.js","default","Series"]
 const external_highcharts_src_js_default_Series_namespaceObject = __WEBPACK_EXTERNAL_MODULE__highcharts_src_js_c57973fa__["default"].Series;
@@ -10234,7 +10451,7 @@ var RadialAxis;
         // one closestPointRange is added to the X axis to prevent the last
         // point from overlapping the first.
         this.autoConnect = (this.isCircular &&
-            typeof (0,external_highcharts_src_js_default_namespaceObject.pick)(this.userMax, this.options.max) === 'undefined' &&
+            typeof (this.userMax ?? this.options.max) === 'undefined' &&
             (0,external_highcharts_src_js_default_namespaceObject.correctFloat)(this.endAngleRad - this.startAngleRad) ===
                 (0,external_highcharts_src_js_default_namespaceObject.correctFloat)(2 * Math.PI));
         // This will lead to add an extra tick to xAxis in order to display
@@ -10362,7 +10579,7 @@ var RadialAxis;
      */
     function getLinePath(_lineWidth, radius, innerRadius) {
         const center = this.pane.center, chart = this.chart, left = this.left || 0, top = this.top || 0;
-        let end, path, r = (0,external_highcharts_src_js_default_namespaceObject.pick)(radius, center[2] / 2 - this.offset);
+        let end, path, r = (radius ?? center[2] / 2 - this.offset);
         innerRadius ?? (innerRadius = this.horiz ? 0 : this.center && -this.center[3] / 2);
         // In case when innerSize of pane is set, it must be included
         if (innerRadius && innerRadius > 0) {
@@ -10425,10 +10642,10 @@ var RadialAxis;
                 return r;
             }
             return radius;
-        }, center = this.center, { endAngleRad, startAngleRad } = this, borderRadius = optionsToObject(options.borderRadius ??
+        }, center = this.center, { endAngleRad, startAngleRad } = this, borderRadius = borderRadiusObject(options.borderRadius ??
             this.pane.options.borderRadius), fullRadius = center[2] / 2, offset = Math.min(this.offset || 0, 0), left = this.left || 0, top = this.top || 0, percentRegex = /%$/, isCircular = this.isCircular, // X axis in a polar chart
         trueBands = this.options.plotBands || [], index = trueBands.indexOf(options);
-        let start, end, angle, xOnPerimeter, open, path, outerRadius = (0,external_highcharts_src_js_default_namespaceObject.pick)(radiusToPixels(options.outerRadius), fullRadius), innerRadius = radiusToPixels(options.innerRadius), thickness = radiusToPixels(options.thickness), brStart = true, brEnd = true;
+        let start, end, angle, xOnPerimeter, open, path, outerRadius = (radiusToPixels(options.outerRadius) ?? fullRadius), innerRadius = radiusToPixels(options.innerRadius), thickness = radiusToPixels(options.thickness), brStart = true, brEnd = true;
         // Apply conditional border radius, only for ends of band stacks
         if (borderRadius.radius &&
             borderRadius.scope === 'stack' &&
@@ -10487,7 +10704,9 @@ var RadialAxis;
                 // Math is for reversed yAxis (#3606)
                 start: Math.min(start, end),
                 end: Math.max(start, end),
-                innerR: (0,external_highcharts_src_js_default_namespaceObject.pick)(innerRadius, (0,external_highcharts_src_js_default_namespaceObject.isNumber)(thickness) ? outerRadius - thickness : void 0, this.center[3] / 2),
+                innerR: innerRadius ?? ((0,external_highcharts_src_js_default_namespaceObject.isNumber)(thickness) ?
+                    outerRadius - thickness :
+                    this.center[3] / 2),
                 open,
                 borderRadius: borderRadius.radius,
                 brStart,
@@ -10561,17 +10780,12 @@ var RadialAxis;
             // Concentric circles
         }
         else {
-            // Pick the right values depending if it is grid line or crosshair
-            let transValue = this.translate(value);
-            // This is required in case when xAxis is non-circular to
-            // prevent grid lines (or crosshairs, if enabled) from
-            // rendering above the center after they supposed to be
-            // displayed below the center point
-            if (transValue) {
-                if (transValue < 0 || transValue > height) {
-                    transValue = 0;
-                }
-            }
+            // Pick the right values depending if it is grid line or crosshair.
+            // Clamp is required in case when xAxis is non-circular to prevent
+            // grid lines (or crosshairs, if enabled) from rendering above the
+            // center after they supposed to be displayed below the center
+            // point.
+            let transValue = (0,external_highcharts_src_js_default_namespaceObject.clamp)(this.translate(value), 0, height);
             if (this.options.gridLineInterpolation === 'circle') {
                 // A value of 0 is in the center, so it won't be
                 // visible, but draw it anyway for update and animation
@@ -10622,13 +10836,16 @@ var RadialAxis;
      */
     function getPosition(value, length) {
         const translatedVal = this.translate(value);
+        const centerRadius = ((this.center && this.center[2]) || 0) / 2;
         return this.postTranslate(this.isCircular ? translatedVal : this.angleRad, // #2848
         // In case when translatedVal is negative, the 0 value must be
         // used instead, in order to deal with lines and labels that
         // fall out of the visible range near the center of a pane
-        (0,external_highcharts_src_js_default_namespaceObject.pick)(this.isCircular ?
-            length :
-            (translatedVal < 0 ? 0 : translatedVal), this.center[2] / 2) - this.offset);
+        (this.isCircular ?
+            (length ?? centerRadius) :
+            (typeof translatedVal === 'number' && translatedVal < 0 ?
+                0 :
+                translatedVal ?? centerRadius)) - this.offset);
     }
     /**
      * Find the position for the axis title, by default inside the gauge.
@@ -10695,7 +10912,8 @@ var RadialAxis;
             // Start and end angle options are given in degrees relative to
             // top, while internal computations are in radians relative to
             // right (like SVG).
-            start = (startAngle - 90) * Math.PI / 180, end = ((0,external_highcharts_src_js_default_namespaceObject.pick)(paneOptions.endAngle, startAngle + (chart.angular ? 270 : 360)) - 90) * Math.PI / 180;
+            start = (startAngle - 90) * Math.PI / 180, end = ((paneOptions.endAngle ??
+                startAngle + (chart.angular ? 270 : 360)) - 90) * Math.PI / 180;
             // Y axis in polar charts
             this.angleRad = (options.angle || 0) * Math.PI / 180;
             // Gauges
@@ -11135,7 +11353,6 @@ var RadialAxis;
  * */
 
 
-const { animObject: PolarComposition_animObject } = (external_highcharts_src_js_default_default());
 
 
 const { defaultOptions: PolarComposition_defaultOptions } = (external_highcharts_src_js_default_default());
@@ -11462,7 +11679,7 @@ function onSeriesAfterColumnTranslate() {
         chart.polar &&
         chart.inverted) {
         const seriesDefault = PolarComposition_defaultOptions.plotOptions?.[this.type]
-            ?.borderRadius, { scope, where = 'end' } = optionsToObject(options.borderRadius, (0,external_highcharts_src_js_default_namespaceObject.isObject)(seriesDefault) ? seriesDefault : {});
+            ?.borderRadius, { scope, where = 'end' } = borderRadiusObject(options.borderRadius, (0,external_highcharts_src_js_default_namespaceObject.isObject)(seriesDefault) ? seriesDefault : {});
         for (const point of this.points) {
             const { shapeArgs } = point;
             if (point.shapeType === 'arc' && shapeArgs) {
@@ -11510,7 +11727,7 @@ function onSeriesAfterTranslate() {
             // Treat points below Y axis min as null (#10082)
             if (!chart.hasParallelCoordinates &&
                 !series.yAxis.reversed) {
-                if ((0,external_highcharts_src_js_default_namespaceObject.pick)(points[i].y, Number.MIN_VALUE) < yAxis.min ||
+                if ((points[i].y ?? Number.MIN_VALUE) < yAxis.min ||
                     points[i].x < xAxis.min ||
                     points[i].x > xAxis.max) {
                     // Destroy markers
@@ -11603,7 +11820,7 @@ function wrapChartGet(proceed, id) {
  * @private
  */
 function wrapColumnSeriesAlignDataLabel(proceed, point, dataLabel, options, alignTo, isNew) {
-    const chart = this.chart, inside = (0,external_highcharts_src_js_default_namespaceObject.pick)(options.inside, !!this.options.stacking);
+    const chart = this.chart, inside = (options.inside ?? !!this.options.stacking);
     let angle, shapeArgs, labelPos;
     if (chart.polar) {
         angle = point.rectPlotX / Math.PI * 180;
@@ -11640,9 +11857,9 @@ function wrapColumnSeriesAlignDataLabel(proceed, point, dataLabel, options, alig
                     y: point.tooltipPos[1]
                 });
             }
-            options.align = (0,external_highcharts_src_js_default_namespaceObject.pick)(options.align, 'center');
+            options.align = (options.align ?? 'center');
             options.verticalAlign =
-                (0,external_highcharts_src_js_default_namespaceObject.pick)(options.verticalAlign, 'middle');
+                (options.verticalAlign ?? 'middle');
         }
         external_highcharts_src_js_default_Series_default().prototype.alignDataLabel.call(this, point, dataLabel, options, alignTo, isNew);
         // Hide label of a point (only inverted) that is outside the
@@ -11664,7 +11881,7 @@ function wrapColumnSeriesAlignDataLabel(proceed, point, dataLabel, options, alig
  * @private
  */
 function onAfterColumnTranslate() {
-    const series = this, options = series.options, stacking = options.stacking, chart = series.chart, xAxis = series.xAxis, yAxis = series.yAxis, reversed = yAxis.reversed, center = yAxis.center, startAngleRad = xAxis.startAngleRad, endAngleRad = xAxis.endAngleRad, visibleRange = endAngleRad - startAngleRad;
+    const series = this, { chart, options, xAxis, yAxis } = series, stacking = options.stacking, { center, reversed } = yAxis, { endAngleRad, startAngleRad } = xAxis, visibleRange = endAngleRad - startAngleRad;
     let threshold = options.threshold, thresholdAngleRad = 0, points, point, i, yMin, yMax, start = 0, end = 0, tooltipPos, pointX, pointY, stackValues, stack, barX, innerR, r;
     // Postprocess plot coordinates
     if (xAxis.isRadial) {
@@ -11762,8 +11979,7 @@ function onAfterColumnTranslate() {
                 innerR = Math.max(barX, 0);
                 r = Math.max(barX + (point.pointWidth || 0), 0);
                 // Handle border radius
-                const brOption = options.borderRadius, brValue = typeof brOption === 'object' ?
-                    brOption.radius : brOption, borderRadius = (0,external_highcharts_src_js_default_namespaceObject.relativeLength)(brValue || 0, r - innerR);
+                const brOption = borderRadiusObject(options.borderRadius), borderRadius = (0,external_highcharts_src_js_default_namespaceObject.relativeLength)(brOption.radius, r - innerR);
                 point.shapeArgs = {
                     x: center[0],
                     y: center[1],
@@ -11921,12 +12137,13 @@ function wrapSeriesAnimate(proceed, init) {
         if (series.isRadialBar) {
             if (!init) {
                 // Run the pie animation for radial bars
-                series.startAngleRad = (0,external_highcharts_src_js_default_namespaceObject.pick)(series.translatedThreshold, series.xAxis.startAngleRad);
+                series.startAngleRad =
+                    series.translatedThreshold ?? series.xAxis.startAngleRad;
                 external_highcharts_src_js_default_default().seriesTypes.pie.prototype.animate.call(series, init);
             }
         }
         else {
-            animation = PolarComposition_animObject(animation);
+            animation = (0,external_highcharts_src_js_default_namespaceObject.animObject)(animation);
             // A different animation needed for column like series
             if (series.is('column')) {
                 if (!init) {
@@ -12116,7 +12333,7 @@ class PolarAdditions {
      * */
     arc(low, high, start, end) {
         const series = this.series, center = series.xAxis.center, len = series.yAxis.len, paneInnerR = center[3] / 2;
-        let r = len - high + paneInnerR, innerR = len - (0,external_highcharts_src_js_default_namespaceObject.pick)(low, len) + paneInnerR;
+        let r = len - high + paneInnerR, innerR = len - (low ?? len) + paneInnerR;
         // Prevent columns from shooting through the pane's center
         if (series.yAxis.reversed) {
             if (r < 0) {
@@ -12705,7 +12922,7 @@ class WaterfallSeries extends WaterfallSeries_ColumnSeries {
     pointAttribs(point, state) {
         const upColor = this.options.upColor;
         // Set or reset up color (#3710, update to negative)
-        if (upColor && !point.options.color && (0,external_highcharts_src_js_default_namespaceObject.isNumber)(point.y)) {
+        if (upColor && point && !point.options.color && (0,external_highcharts_src_js_default_namespaceObject.isNumber)(point.y)) {
             point.color = point.y > 0 ? upColor : void 0;
         }
         const attr = WaterfallSeries_ColumnSeries.prototype.pointAttribs.call(this, point, state);
@@ -12944,7 +13161,7 @@ WaterfallSeries.compose = Axis_WaterfallAxis.compose;
 });
 // Translate data points from raw values
 (0,external_highcharts_src_js_default_namespaceObject.addEvent)(WaterfallSeries, 'afterColumnTranslate', function () {
-    const series = this, { options, points, yAxis } = series, minPointLength = (0,external_highcharts_src_js_default_namespaceObject.pick)(options.minPointLength, 5), halfMinPointLength = minPointLength / 2, threshold = options.threshold || 0, stacking = options.stacking, actualStack = yAxis.waterfall?.stacks[series.stackKey], processedYData = series.getColumn('y', true);
+    const series = this, { options, points, yAxis } = series, minPointLength = (options.minPointLength ?? 5), halfMinPointLength = minPointLength / 2, threshold = options.threshold || 0, stacking = options.stacking, actualStack = yAxis.waterfall?.stacks[series.stackKey], processedYData = series.getColumn('y', true);
     let previousIntermediate = threshold, previousY = threshold, y, total, hPos;
     for (let i = 0; i < points.length; i++) {
         const point = points[i], yValue = processedYData[i], shapeArgs = point.shapeArgs, box = (0,external_highcharts_src_js_default_namespaceObject.extend)({