@ntlab/ntjs-assets 2.99.0 → 2.100.0

package/assets/js/highcharts/es-modules/Extensions/ExportData/ExportData.js

@@ -230,7 +230,7 @@ var ExportData;
             return domurl.createObjectURL(new win.Blob(['\uFEFF' + content], // #7084
             { type: type }));
         }
-        catch (e) {
+        catch {
             // Ignore
         }
     }
@@ -629,10 +629,7 @@ var ExportData;
             let textContent = pick(value, ''), className = 'highcharts-text' + (classes ? ' ' + classes : '');
             // Convert to string if number
             if (typeof textContent === 'number') {
-                textContent = textContent.toString();
-                if (decimalPoint === ',') {
-                    textContent = textContent.replace('.', decimalPoint);
-                }
+                textContent = chart.numberFormatter(textContent, -1, decimalPoint, tagName === 'th' ? '' : void 0);
                 className = 'highcharts-number';
             }
             else if (!value) {
@@ -679,6 +676,7 @@ var ExportData;
                         if (cur === subheaders[i]) {
                             if (exporting.options.useRowspanHeaders) {
                                 rowspan = 2;
+                                // eslint-disable-next-line @typescript-eslint/no-array-delete
                                 delete subheaders[i];
                             }
                             else {

package/assets/js/highcharts/es-modules/Extensions/Exporting/Exporting.js

@@ -122,6 +122,85 @@ class Exporting {
             return canvas.toDataURL(imageType);
         }
     }
+    static async fetchCSS(href) {
+        const content = await fetch(href)
+            .then((res) => res.text());
+        const newSheet = new CSSStyleSheet();
+        newSheet.replaceSync(content);
+        return newSheet;
+    }
+    static async handleStyleSheet(sheet, resultArray) {
+        try {
+            for (const rule of Array.from(sheet.cssRules)) {
+                if (rule instanceof CSSImportRule) {
+                    const sheet = await Exporting.fetchCSS(rule.href);
+                    await Exporting.handleStyleSheet(sheet, resultArray);
+                }
+                if (rule instanceof CSSFontFaceRule) {
+                    let cssText = rule.cssText;
+                    if (sheet.href) {
+                        const baseUrl = sheet.href, regexp = /url\(\s*(['"]?)(?![a-z]+:|\/\/)([^'")]+?)\1\s*\)/gi;
+                        // Replace relative URLs
+                        cssText = cssText.replace(regexp, (_, quote, relPath) => {
+                            const absolutePath = new URL(relPath, baseUrl).href;
+                            return `url(${quote}${absolutePath}${quote})`;
+                        });
+                    }
+                    resultArray.push(cssText);
+                }
+            }
+        }
+        catch {
+            if (sheet.href) {
+                const newSheet = await Exporting.fetchCSS(sheet.href);
+                await Exporting.handleStyleSheet(newSheet, resultArray);
+            }
+        }
+    }
+    static async fetchStyleSheets() {
+        const cssTexts = [];
+        for (const sheet of Array.from(doc.styleSheets)) {
+            await Exporting.handleStyleSheet(sheet, cssTexts);
+        }
+        return cssTexts;
+    }
+    static async inlineFonts(svg) {
+        const cssTexts = await Exporting.fetchStyleSheets(), urlRegex = /url\(([^)]+)\)/g, urls = [];
+        let cssText = cssTexts.join('\n'), match;
+        while ((match = urlRegex.exec(cssText))) {
+            const m = match[1].replace(/['"]/g, '');
+            if (!urls.includes(m)) {
+                urls.push(m);
+            }
+        }
+        const arrayBufferToBase64 = (buffer) => {
+            let binary = '';
+            const bytes = new Uint8Array(buffer);
+            for (let i = 0; i < bytes.byteLength; i++) {
+                binary += String.fromCharCode(bytes[i]);
+            }
+            return btoa(binary);
+        };
+        const replacements = {};
+        for (const url of urls) {
+            try {
+                const res = await fetch(url), contentType = res.headers.get('Content-Type') || '', b64 = arrayBufferToBase64(await res.arrayBuffer());
+                replacements[url] = `data:${contentType};base64,${b64}`;
+            }
+            catch {
+                // eslint-disable-next-line
+            }
+        }
+        cssText = cssText.replace(urlRegex, (_, url) => {
+            const strippedUrl = url.replace(/['"]/g, '');
+            return `url(${replacements[strippedUrl] || strippedUrl})`;
+        });
+        const styleEl = document.createElementNS('http://www.w3.org/2000/svg', 'style');
+        styleEl.textContent = cssText;
+        // Needs to be appended to pass sanitization
+        svg.append(styleEl);
+        return svg;
+    }
     /**
      * Loads an image from the provided URL.
      *
@@ -152,6 +231,7 @@ class Exporting {
             };
             // Reject in case of fail
             image.onerror = (error) => {
+                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                 reject(error);
             };
             // Provide the image URL
@@ -1220,6 +1300,7 @@ class Exporting {
                     // Get the defaults into a standard object (simple merge
                     // won't do)
                     const s = win.getComputedStyle(dummy, null), defaults = {};
+                    // eslint-disable-next-line @typescript-eslint/no-for-in-array
                     for (const key in s) {
                         if (key.length < 1000 /* RegexLimits.shortLimit */ &&
                             typeof s[key] === 'string' &&
@@ -1356,6 +1437,11 @@ class Exporting {
                     image.parentNode.removeChild(image);
                 }
             }
+            const svgElement = chartCopyContainer?.querySelector('svg');
+            if (svgElement &&
+                !exportingOptions.chartOptions?.chart?.style?.fontFamily) {
+                await Exporting.inlineFonts(svgElement);
+            }
             // Sanitize the SVG
             const sanitizedSVG = sanitize(chartCopyContainer?.innerHTML);
             // Use SVG of chart copy. If SVG contains foreignObjects PDF fails

package/assets/js/highcharts/es-modules/Extensions/Exporting/ExportingDefaults.js

@@ -180,7 +180,7 @@ const exporting = {
      * @since     5.0.0
      * @apioption exporting.libURL
      */
-    libURL: 'https://code.highcharts.com/12.3.0/lib/',
+    libURL: 'https://code.highcharts.com/12.4.0/lib/',
     /**
      * Whether the chart should be exported using the browser's built-in
      * capabilities, allowing offline exports without requiring access to the

package/assets/js/highcharts/es-modules/Extensions/NonCartesianSeriesZoom/NonCartesianSeriesZoom.js

@@ -35,17 +35,17 @@ function onTransform(params) {
                 series.isDirty = true;
                 chart.isDirtyBox = true;
                 params.hasZoomed = true;
-                const { plotSizeX = 0, plotSizeY = 0 } = chart;
+                const { plotWidth = 0, plotHeight = 0 } = chart;
                 if (trigger === 'pan' && series.zooming) {
-                    series.zooming.panX -= (to.x || 0) / plotSizeX;
-                    series.zooming.panY -= (to.y || 0) / plotSizeY;
+                    series.zooming.panX -= (to.x || 0) / plotWidth;
+                    series.zooming.panY -= (to.y || 0) / plotHeight;
                 }
                 else {
                     if (Object.keys(from).length) {
                         const { width: toWidth = 1, height: toHeight = 1 } = to, currentScale = Math.abs(series.group?.scaleX || 1);
                         let { x: zoomX = 0, y: zoomY = 0, width: fromWidth = 1, height: fromHeight = 1 } = from, x = zoomX, y = zoomY, scale = series.zooming?.scale ||
                             series.group?.scaleX ||
-                            1, width = (series.zooming?.width || 1) * plotSizeX, height = (series.zooming?.height || 1) * plotSizeY;
+                            1, width = (series.zooming?.width || 1) * plotWidth, height = (series.zooming?.height || 1) * plotHeight;
                         if (Object.keys(to).length) {
                             width = width * (fromWidth / toWidth);
                             height = height * (fromWidth / toHeight);
@@ -54,7 +54,7 @@ function onTransform(params) {
                             x = zoomX - width / 2;
                             y = zoomY - height / 2;
                             scale =
-                                Math.min(plotSizeX / width, plotSizeY / height);
+                                Math.min(plotWidth / width, plotHeight / height);
                             // Uncomment this block to visualize the zooming
                             // bounding box and the point, which is normalized
                             // position to zoom-in
@@ -80,18 +80,18 @@ function onTransform(params) {
                         else {
                             fromWidth /= currentScale;
                             fromHeight /= currentScale;
-                            scale = Math.min(plotSizeX / fromWidth, plotSizeY / fromHeight);
+                            scale = Math.min(plotWidth / fromWidth, plotHeight / fromHeight);
                             let prevX = 0, prevY = 0;
                             if (series.zooming) {
-                                prevX = series.zooming.x * plotSizeX;
-                                prevY = series.zooming.y * plotSizeY;
+                                prevX = series.zooming.x * plotWidth;
+                                prevY = series.zooming.y * plotHeight;
                             }
                             // Calculate the normalized coefficients of the
                             // rectangle center position
                             const factorX = (zoomX - chart.plotLeft) /
-                                ((plotSizeX - fromWidth * currentScale) ||
+                                ((plotWidth - fromWidth * currentScale) ||
                                     1), factorY = (zoomY - chart.plotTop) /
-                                ((plotSizeY - fromHeight * currentScale) ||
+                                ((plotHeight - fromHeight * currentScale) ||
                                     1);
                             width = fromWidth;
                             height = fromHeight;
@@ -111,26 +111,26 @@ function onTransform(params) {
                             // bounding box and the point, which is normalized
                             // position to zoom-in
                             // chart.renderer.rect(
-                            //    x + chart.plotLeft,
-                            //    y + chart.plotTop,
-                            //    fromWidth,
-                            //    fromHeight,
-                            //    0,
-                            //    2
+                            //     x + chart.plotLeft,
+                            //     y + chart.plotTop,
+                            //     fromWidth,
+                            //     fromHeight,
+                            //     0,
+                            //     2
                             // ).attr({ stroke: 'red' }).add();
                             // chart.renderer.circle(
-                            //    zoomX + chart.plotLeft,
-                            //    zoomY + chart.plotTop,
-                            //    2
+                            //     zoomX + chart.plotLeft,
+                            //     zoomY + chart.plotTop,
+                            //     2
                             // ).attr({ stroke: 'blue' }).add();
                         }
                         series.zooming = {
-                            x: x / plotSizeX,
-                            y: y / plotSizeY,
-                            zoomX: zoomX / plotSizeX,
-                            zoomY: zoomY / plotSizeY,
-                            width: width / plotSizeX,
-                            height: height / plotSizeY,
+                            x: x / plotWidth,
+                            y: y / plotHeight,
+                            zoomX: zoomX / plotWidth,
+                            zoomY: zoomY / plotHeight,
+                            width: width / plotWidth,
+                            height: height / plotHeight,
                             scale,
                             panX: 0,
                             panY: 0

package/assets/js/highcharts/es-modules/Extensions/OfflineExporting/OfflineExporting.js

@@ -235,7 +235,7 @@ var OfflineExporting;
                         normalBase64 = base64;
                     }
                 }
-                catch (e) {
+                catch {
                     // If fetch or reading fails, fallback to next variant
                 }
             }

package/assets/js/highcharts/es-modules/Extensions/Pane/PaneComposition.js

@@ -51,29 +51,36 @@ function compose(ChartClass, PointerClass) {
  */
 function isInsidePane(x, y, center, startAngle, endAngle) {
     let insideSlice = true;
-    const cx = center[0], cy = center[1];
+    const cx = center[0], cy = center[1], twoPi = 2 * Math.PI;
     const distance = Math.sqrt(Math.pow(x - cx, 2) + Math.pow(y - cy, 2));
     if (defined(startAngle) && defined(endAngle)) {
         // Round angle to N-decimals to avoid numeric errors
-        const angle = Math.atan2(correctFloat(y - cy, 8), correctFloat(x - cx, 8));
+        let angle = Math.atan2(correctFloat(y - cy, 8), correctFloat(x - cx, 8));
+        // Normalize angle to [0, 2π)
+        angle = (angle + twoPi) % (twoPi);
+        startAngle = (startAngle + twoPi) % (twoPi);
+        endAngle = (endAngle + twoPi) % (twoPi);
         // Ignore full circle panes:
-        if (endAngle !== startAngle) {
-            // If normalized start angle is bigger than normalized end,
-            // it means angles have different signs. In such situation we
-            // check the <-PI, startAngle> and <endAngle, PI> ranges.
+        if (Math.abs(endAngle - startAngle) > 1e-6) {
+            // If the normalized start angle is greater than the end angle,
+            // it means the arc wraps around 0°. In this case, we check
+            // if the angle falls into either [startAngle, 2π) or [0, endAngle].
             if (startAngle > endAngle) {
-                insideSlice = (angle >= startAngle &&
-                    angle <= Math.PI) || (angle <= endAngle &&
-                    angle >= -Math.PI);
+                insideSlice = (angle >= startAngle ||
+                    angle <= endAngle);
             }
             else {
-                // In this case, we simple check if angle is within the
-                // <startAngle, endAngle> range
+                // In this case, we simply check if angle is within the
+                // [startAngle, endAngle] range
                 insideSlice = angle >= startAngle &&
-                    angle <= correctFloat(endAngle, 8);
+                    angle <= endAngle;
             }
         }
     }
+    else {
+        // If no start/end angles are defined, treat it as a full circle
+        insideSlice = true;
+    }
     // Round up radius because x and y values are rounded
     return distance <= Math.ceil(center[2] / 2) && insideSlice;
 }

package/assets/js/highcharts/es-modules/Extensions/ScrollablePlotArea.js

@@ -49,29 +49,33 @@ class ScrollablePlotArea {
     static afterSetSize(chart, e) {
         const { minWidth, minHeight } = chart.options.chart.scrollablePlotArea || {}, { clipBox, plotBox, inverted, renderer } = chart;
         let scrollablePixelsX, scrollablePixelsY, recalculateHoriz;
-        if (!renderer.forExport) {
-            // The amount of pixels to scroll, the difference between chart
-            // width and scrollable width
-            if (minWidth) {
-                chart.scrollablePixelsX = scrollablePixelsX = Math.max(0, minWidth - chart.chartWidth);
-                if (scrollablePixelsX) {
-                    chart.scrollablePlotBox = merge(chart.plotBox);
-                    plotBox.width = chart.plotWidth += scrollablePixelsX;
-                    clipBox[inverted ? 'height' : 'width'] += scrollablePixelsX;
-                    recalculateHoriz = true;
-                }
-                // Currently we can only do either X or Y
+        // Skip for exporting
+        if (renderer.forExport) {
+            return;
+        }
+        // The amount of pixels to scroll, the difference between chart width
+        // and scrollable width
+        if (minWidth) {
+            chart.scrollablePixelsX = scrollablePixelsX = Math.max(0, minWidth - chart.chartWidth);
+            if (scrollablePixelsX) {
+                chart.scrollablePlotBox = merge(chart.plotBox);
+                plotBox.width = chart.plotWidth += scrollablePixelsX;
+                clipBox[inverted ? 'height' : 'width'] += scrollablePixelsX;
+                recalculateHoriz = true;
             }
-            else if (minHeight) {
-                chart.scrollablePixelsY = scrollablePixelsY = Math.max(0, minHeight - chart.chartHeight);
-                if (defined(scrollablePixelsY)) {
-                    chart.scrollablePlotBox = merge(chart.plotBox);
-                    plotBox.height = chart.plotHeight += scrollablePixelsY;
-                    clipBox[inverted ? 'width' : 'height'] += scrollablePixelsY;
-                    recalculateHoriz = false;
-                }
+            // Currently we can only do either X or Y
+        }
+        else if (minHeight) {
+            chart.scrollablePixelsY = scrollablePixelsY = Math.max(0, minHeight - chart.chartHeight);
+            if (defined(scrollablePixelsY)) {
+                chart.scrollablePlotBox = merge(chart.plotBox);
+                plotBox.height = chart.plotHeight += scrollablePixelsY;
+                clipBox[inverted ? 'width' : 'height'] += scrollablePixelsY;
+                recalculateHoriz = false;
             }
-            if (defined(recalculateHoriz) && !e.skipAxes) {
+        }
+        if (defined(recalculateHoriz)) {
+            if (!e.skipAxes) {
                 for (const axis of chart.axes) {
                     // Apply the corrected plot size to the axes of the other
                     // orientation than the scrolling direction
@@ -84,6 +88,10 @@ class ScrollablePlotArea {
                 }
             }
         }
+        else {
+            // Clear (potential) old box when a new one was not set
+            delete chart.scrollablePlotBox;
+        }
     }
     constructor(chart) {
         const chartOptions = chart.options.chart, Renderer = RendererRegistry.getRendererType(), scrollableOptions = chartOptions.scrollablePlotArea || {}, moveFixedElements = this.moveFixedElements.bind(this), styles = {

package/assets/js/highcharts/es-modules/Extensions/Sonification/Sonification.js

@@ -61,7 +61,7 @@ class Sonification {
             this.audioContext.suspend();
             this.audioDestination = this.audioContext.destination;
         }
-        catch (e) { /* Ignore */ }
+        catch { /* Ignore */ }
     }
     /**
      * Set the audio destination node to something other than the default

package/assets/js/highcharts/es-modules/Extensions/StaticScale.js

@@ -9,7 +9,7 @@
  * */
 'use strict';
 import U from '../Core/Utilities.js';
-const { addEvent, defined, isNumber, pick } = U;
+const { addEvent, defined, isNumber } = U;
 /* *
  *
  *  Composition
@@ -26,12 +26,11 @@ function compose(AxisClass, ChartClass) {
 }
 /** @private */
 function onAxisAfterSetOptions() {
-    const chartOptions = this.chart.options.chart;
+    const chartOptions = this.chart.userOptions.chart;
     if (!this.horiz &&
         isNumber(this.options.staticScale) &&
-        (!chartOptions.height ||
-            (chartOptions.scrollablePlotArea &&
-                chartOptions.scrollablePlotArea.minHeight))) {
+        (!chartOptions?.height ||
+            chartOptions.scrollablePlotArea?.minHeight)) {
         this.staticScale = this.options.staticScale;
     }
 }
@@ -40,17 +39,20 @@ function chartAdjustHeight() {
     const chart = this;
     if (chart.redrawTrigger !== 'adjustHeight') {
         for (const axis of (chart.axes || [])) {
-            const chart = axis.chart, animate = !!chart.initiatedScale &&
-                chart.options.animation, staticScale = axis.options.staticScale;
-            if (axis.staticScale && defined(axis.min)) {
-                let height = pick(axis.brokenAxis && axis.brokenAxis.unitLength, axis.max + axis.tickInterval - axis.min) * staticScale;
+            const chart = axis.chart, staticScale = axis.options.staticScale;
+            if (axis.staticScale &&
+                staticScale &&
+                defined(axis.min) &&
+                defined(axis.max)) {
+                let height = (axis.brokenAxis?.unitLength ??
+                    (axis.max + axis.tickInterval - axis.min)) * (staticScale);
                 // Minimum height is 1 x staticScale.
                 height = Math.max(height, staticScale);
                 const diff = height - chart.plotHeight;
                 if (!chart.scrollablePixelsY && Math.abs(diff) >= 1) {
                     chart.plotHeight = height;
                     chart.redrawTrigger = 'adjustHeight';
-                    chart.setSize(void 0, chart.chartHeight + diff, animate);
+                    chart.setSize(void 0, chart.chartHeight + diff, chart.initiatedScale ? void 0 : false);
                 }
                 // Make sure clip rects have the right height before initial
                 // animation.
@@ -69,7 +71,7 @@ function chartAdjustHeight() {
         }
         this.initiatedScale = true;
     }
-    this.redrawTrigger = null;
+    this.redrawTrigger = void 0;
 }
 /* *
  *

package/assets/js/highcharts/es-modules/Extensions/TextPath.js

@@ -165,7 +165,7 @@ function setPolygon(event) {
                         }
                     }
                 }
-                catch (e) {
+                catch {
                     // Safari fails on getStartPositionOfChar even if the
                     // character is within the `textContent.length`
                     break;
@@ -177,7 +177,7 @@ function setPolygon(event) {
                 polygon.unshift(upper);
                 polygon.unshift(lower);
             }
-            catch (e) {
+            catch {
                 // Safari fails on getStartPositionOfChar even if the character
                 // is within the `textContent.length`
                 break;

package/assets/js/highcharts/es-modules/Series/Bellcurve/BellcurveSeries.js

@@ -65,6 +65,16 @@ class BellcurveSeries extends AreaSplineSeries {
      *  Functions
      *
      * */
+    setData(data, redraw = true, animation, updatePoints) {
+        let alteredData;
+        if (typeof data !== 'undefined' && data.length > 0) {
+            data = data.filter(isNumber),
+                this.setMean(data);
+            this.setStandardDeviation(data);
+            alteredData = this.derivedData(this.mean || 0, this.standardDeviation || 0);
+        }
+        super.setData.call(this, alteredData, redraw, animation, updatePoints);
+    }
     derivedData(mean, standardDeviation) {
         const options = this.options, intervals = options.intervals, pointsInInterval = options.pointsInInterval, stop = intervals * pointsInInterval * 2 + 1, increment = standardDeviation / pointsInInterval, data = [];
         let x = mean - intervals * standardDeviation;
@@ -76,20 +86,17 @@ class BellcurveSeries extends AreaSplineSeries {
     }
     setDerivedData() {
         const series = this;
-        if (series.baseSeries?.getColumn('y').length || 0 > 1) {
-            series.setMean();
-            series.setStandardDeviation();
-            series.setData(series.derivedData(series.mean || 0, series.standardDeviation || 0), false, void 0, false);
+        if (series.baseSeries?.getColumn('y').length) {
+            series.setData(series.baseSeries?.getColumn('y'), false, void 0, false);
         }
-        return (void 0);
     }
-    setMean() {
+    setMean(data) {
         const series = this;
-        series.mean = correctFloat(BellcurveSeries.mean(series.baseSeries?.getColumn('y') || []));
+        series.mean = correctFloat(BellcurveSeries.mean(data || []));
     }
-    setStandardDeviation() {
+    setStandardDeviation(data) {
         const series = this;
-        series.standardDeviation = correctFloat(BellcurveSeries.standardDeviation(series.baseSeries?.getColumn('y') || [], series.mean));
+        series.standardDeviation = correctFloat(BellcurveSeries.standardDeviation(data || [], series.mean));
     }
 }
 /* *

package/assets/js/highcharts/es-modules/Series/DataModifyComposition.js

@@ -8,10 +8,8 @@
  *
  * */
 'use strict';
-import Axis from '../Core/Axis/Axis.js';
 import Point from '../Core/Series/Point.js';
 const { tooltipFormatter: pointTooltipFormatter } = Point.prototype;
-import Series from '../Core/Series/Series.js';
 import U from '../Core/Utilities.js';
 const { addEvent, arrayMax, arrayMin, correctFloat, defined, isArray, isNumber, isString, pick } = U;
 /* *

package/assets/js/highcharts/es-modules/Series/DrawPointUtilities.js

@@ -31,7 +31,7 @@ function draw(point, params) {
     params.attribs = {
         ...params.attribs,
         'class': point.getClassName()
-    } || {};
+    };
     if ((point.shouldDraw())) {
         if (!graphic) {
             if (params.shapeType === 'text') {

package/assets/js/highcharts/es-modules/Series/Histogram/HistogramSeries.js

@@ -14,23 +14,22 @@ import HistogramSeriesDefaults from './HistogramSeriesDefaults.js';
 import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
 const { column: ColumnSeries } = SeriesRegistry.seriesTypes;
 import U from '../../Core/Utilities.js';
-const { arrayMax, arrayMin, correctFloat, extend, isNumber, merge } = U;
+const { arrayMax, arrayMin, correctFloat, isNumber, merge } = U;
 /* ************************************************************************** *
  *  HISTOGRAM
  * ************************************************************************** */
 /**
- * A dictionary with formulas for calculating number of bins based on the
- * base series
+ * A dictionary with formulas for calculating number of bins based on data
  **/
 const binsNumberFormulas = {
-    'square-root': function (baseSeries) {
-        return Math.ceil(Math.sqrt(baseSeries.options.data.length));
+    'square-root': function (data) {
+        return Math.ceil(Math.sqrt(data.length));
     },
-    'sturges': function (baseSeries) {
-        return Math.ceil(Math.log(baseSeries.options.data.length) * Math.LOG2E);
+    'sturges': function (data) {
+        return Math.ceil(Math.log(data.length) * Math.LOG2E);
     },
-    'rice': function (baseSeries) {
-        return Math.ceil(2 * Math.pow(baseSeries.options.data.length, 1 / 3));
+    'rice': function (data) {
+        return Math.ceil(2 * Math.pow(data.length, 1 / 3));
     }
 };
 /**
@@ -66,15 +65,22 @@ class HistogramSeries extends ColumnSeries {
      *  Functions
      *
      * */
-    binsNumber() {
+    binsNumber(data) {
         const binsNumberOption = this.options.binsNumber;
         const binsNumber = binsNumberFormulas[binsNumberOption] ||
             // #7457
             (typeof binsNumberOption === 'function' && binsNumberOption);
-        return Math.ceil((binsNumber && binsNumber(this.baseSeries)) ||
+        return Math.ceil((binsNumber && binsNumber(data)) ||
             (isNumber(binsNumberOption) ?
                 binsNumberOption :
-                binsNumberFormulas['square-root'](this.baseSeries)));
+                binsNumberFormulas['square-root'](data)));
+    }
+    setData(data, redraw = true, animation, updatePoints) {
+        let alteredData;
+        if (typeof data !== 'undefined' && data.length > 0) {
+            alteredData = this.derivedData(data.filter(isNumber), this.binsNumber(data), this.options.binWidth);
+        }
+        super.setData.call(this, alteredData, redraw, animation, updatePoints);
     }
     derivedData(baseData, binsNumber, binWidth) {
         const series = this, max = correctFloat(arrayMax(baseData)), 
@@ -131,8 +137,7 @@ class HistogramSeries extends ColumnSeries {
             this.setData([]);
             return;
         }
-        const data = this.derivedData(yData, this.binsNumber(), this.options.binWidth);
-        this.setData(data, false);
+        this.setData(yData, false, void 0, false);
     }
 }
 /* *
@@ -141,9 +146,6 @@ class HistogramSeries extends ColumnSeries {
  *
  * */
 HistogramSeries.defaultOptions = merge(ColumnSeries.defaultOptions, HistogramSeriesDefaults);
-extend(HistogramSeries.prototype, {
-    hasDerivedData: DerivedComposition.hasDerivedData
-});
 DerivedComposition.compose(HistogramSeries);
 SeriesRegistry.registerSeriesType('histogram', HistogramSeries);
 /* *

package/assets/js/highcharts/es-modules/Series/Pie/PieDataLabel.js

@@ -16,7 +16,7 @@ const { distribute } = R;
 import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
 const { series: Series } = SeriesRegistry;
 import U from '../../Core/Utilities.js';
-const { arrayMax, clamp, defined, pick, pushUnique, relativeLength } = U;
+const { arrayMax, clamp, defined, isNumber, pick, pushUnique, relativeLength } = U;
 /* *
  *
  *  Composition
@@ -368,7 +368,7 @@ var ColumnDataLabel;
                     // #8864: every connector can have individual options
                     const { connectorColor, connectorWidth = 1 } = (dataLabel.options || {}), labelPosition = dataLabel.dataLabelPosition;
                     // Draw the connector
-                    if (connectorWidth) {
+                    if (isNumber(connectorWidth)) {
                         let isNew;
                         connector = dataLabel.connector;
                         if (labelPosition && labelPosition.distance > 0) {

package/assets/js/highcharts/es-modules/Series/Pie/PieSeries.js

@@ -158,11 +158,11 @@ class PieSeries extends Series {
     }
     /**
      * Define hasData function for non-cartesian series. Returns true if the
-     * series has points at all.
+     * series has at least one visible point (#23235)
      * @private
      */
     hasData() {
-        return !!this.dataTable.rowCount;
+        return this.points.some((point) => point.visible);
     }
     /**
      * Draw the data points