@highcharts/grid-pro 2.2.0 → 2.3.0

package/es-modules/Core/Delaunay.js

@@ -0,0 +1,310 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Dawid Dragula
+ *
+ * */
+'use strict';
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Delaunay triangulation of a 2D point set.
+ */
+class Delaunay {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    /**
+     * Create a new Delaunay triangulation.
+     *
+     * @param {Float32Array|Float64Array} points
+     * A 1D array of points in the format [x0, y0, x1, y1, ...].
+     */
+    constructor(points) {
+        this.points = points;
+        const n = points.length >>> 1;
+        // Floating-point error multiplier used by geometric predicates.
+        this.epsilon = 4 * Number.EPSILON;
+        let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+        for (let i = 0; i < n; i++) {
+            const px = points[i << 1], py = points[(i << 1) + 1];
+            if (px < minX) {
+                minX = px;
+            }
+            if (px > maxX) {
+                maxX = px;
+            }
+            if (py < minY) {
+                minY = py;
+            }
+            if (py > maxY) {
+                maxY = py;
+            }
+        }
+        const rangeX = maxX - minX || 1, rangeY = maxY - minY || 1;
+        this.minX = minX;
+        this.minY = minY;
+        this.invScaleX = 1 / rangeX;
+        this.invScaleY = 1 / rangeY;
+        const ids = new Uint32Array(n), x = (i) => (points[i << 1] - minX) * this.invScaleX, y = (i) => (points[(i << 1) + 1] - minY) * this.invScaleY;
+        for (let i = 0; i < n; i++) {
+            ids[i] = i;
+        }
+        ids.sort((a, b) => (x(a) - x(b)) || (y(a) - y(b)));
+        let m = n ? 1 : 0, pa, pb;
+        for (let i = 1; i < n; ++i) {
+            pa = ids[m - 1],
+                pb = ids[i];
+            if (x(pa) !== x(pb) || y(pa) !== y(pb)) {
+                ids[m++] = pb;
+            }
+        }
+        this.ids = ids.subarray(0, m);
+        this.triangles = this.triangulate();
+    }
+    /* *
+     *
+     *  Methods
+     *
+     * */
+    /**
+     * Triangulate the points.
+     *
+     * @return {Uint32Array}
+     * A 1D array of triangle vertex indices.
+     */
+    triangulate() {
+        const count = this.ids.length;
+        if (count < 3) {
+            return new Uint32Array(0);
+        }
+        const points = this.points, { minX, minY, invScaleX, invScaleY } = this, x = (i) => (points[i << 1] - minX) * invScaleX, y = (i) => (points[(i << 1) + 1] - minY) * invScaleY;
+        // Determine if three points are in counter-clockwise order.
+        const orient = (a, b, c) => {
+            const ax = x(a), ay = y(a), bx = x(b) - ax, by = y(b) - ay, cx = x(c) - ax, cy = y(c) - ay, det = bx * cy - by * cx, err = (Math.abs(bx * cy) + Math.abs(by * cx)) * this.epsilon;
+            return det > err;
+        };
+        // Determine if a point (d) is inside the circumcircle of a triangle
+        // (a, b, c).
+        const inCircle = (a, b, c, d) => {
+            if (a === d || b === d || c === d) {
+                // Skip if d is one of the triangle vertices.
+                return false;
+            }
+            const ax = x(a) - x(d), ay = y(a) - y(d), bx = x(b) - x(d), by = y(b) - y(d), cx = x(c) - x(d), cy = y(c) - y(d), aa = ax * ax + ay * ay, bb = bx * bx + by * by, cc = cx * cx + cy * cy, term1 = by * cc - bb * cy, term2 = bx * cc - bb * cx, term3 = bx * cy - by * cx, det = ax * term1 - ay * term2 + aa * term3, err = (Math.abs(ax * term1) +
+                Math.abs(ay * term2) +
+                Math.abs(aa * term3)) * this.epsilon;
+            return det > err;
+        };
+        // Data structures for the quad-edge data structure.
+        let cap = Math.max(32, ((8 * count + 7) & ~3)), // Capacity (% 4 = 0)
+        on = new Int32Array(cap), // Next edge in same face
+        rt = new Int32Array(cap), // Rotation of edge (90 degrees)
+        vtx = new Uint32Array(cap), // Origin vertex of edge
+        seen = new Uint8Array(cap), // Visited flag for edge traversal
+        top = 0; // Next free edge id (% 4 = 0)
+        // Ensure the data structures have enough capacity for the required
+        // number of edges.
+        const ensure = (need) => {
+            // If the capacity is sufficient, return.
+            if (need <= cap) {
+                return;
+            }
+            // Double capacity until sufficient.
+            let ncap = cap << 1;
+            while (ncap < need) {
+                ncap <<= 1;
+            }
+            const on2 = new Int32Array(ncap), rt2 = new Int32Array(ncap), v2 = new Uint32Array(ncap), s2 = new Uint8Array(ncap);
+            on2.set(on);
+            rt2.set(rt);
+            v2.set(vtx);
+            s2.set(seen);
+            on = on2;
+            rt = rt2;
+            vtx = v2;
+            seen = s2;
+            cap = ncap;
+        };
+        const sym = (e) => rt[rt[e]], rotSym = (e) => sym(rt[e]), dest = (e) => vtx[sym(e)], lnext = (e) => rt[on[rotSym(e)]], oprev = (e) => rt[on[rt[e]]], rprev = (e) => on[sym(e)], leftOf = (p, e) => orient(p, vtx[e], dest(e)), rightOf = (p, e) => orient(p, dest(e), vtx[e]), admissible = (e, base) => rightOf(dest(e), base);
+        // Create a new edge between two vertices.
+        const makeEdge = (a, b) => {
+            ensure(top + 4);
+            const e0 = top, e1 = top + 1, e2 = top + 2, e3 = top + 3;
+            top += 4;
+            // Rot cycle
+            rt[e0] = e1;
+            rt[e1] = e2;
+            rt[e2] = e3;
+            rt[e3] = e0;
+            // Onext initial
+            on[e0] = e0;
+            on[e2] = e2;
+            on[e1] = e3;
+            on[e3] = e1;
+            // Origins
+            vtx[e0] = a;
+            vtx[e2] = b;
+            vtx[e1] = 0xffffffff;
+            vtx[e3] = 0xffffffff;
+            return e0;
+        };
+        // Splice two edges.
+        const splice = (a, b) => {
+            const alpha = rt[on[a]];
+            const beta = rt[on[b]];
+            const t2 = on[a];
+            const t3 = on[beta];
+            const t4 = on[alpha];
+            on[a] = on[b];
+            on[b] = t2;
+            on[alpha] = t3;
+            on[beta] = t4;
+        };
+        // Connect two edges.
+        const connect = (a, b) => {
+            const q = makeEdge(dest(a), vtx[b]);
+            splice(q, lnext(a));
+            splice(sym(q), b);
+            return q;
+        };
+        // Removes an edge from both sides.
+        const drop = (e) => {
+            splice(e, oprev(e));
+            const es = sym(e);
+            splice(es, oprev(es));
+        };
+        const A = this.ids;
+        // Recursively triangulate a range [lo, hi) of points. Returns the
+        // two endpoints [left, right] of the lower common tangent.
+        const solve = (lo, hi) => {
+            const len = hi - lo;
+            // If there are only two points, create a single edge.
+            if (len === 2) {
+                const a = makeEdge(A[lo], A[lo + 1]);
+                return [a, sym(a)];
+            }
+            // If there are three points, create two edges and connect them.
+            if (len === 3) {
+                const a = makeEdge(A[lo], A[lo + 1]), b = makeEdge(A[lo + 1], A[lo + 2]);
+                splice(sym(a), b);
+                const p0 = A[lo], p1 = A[lo + 1], p2 = A[lo + 2];
+                if (orient(p0, p1, p2)) {
+                    connect(b, a);
+                    return [a, sym(b)];
+                }
+                if (orient(p0, p2, p1)) {
+                    const c = connect(b, a);
+                    return [sym(c), c];
+                }
+                return [a, sym(b)];
+            }
+            // Find the midpoint of the range.
+            const mid = lo + ((len + 1) >>> 1);
+            const L = solve(lo, mid);
+            const R = solve(mid, hi);
+            let ldo = L[0], ldi = L[1], rdi = R[0], rdo = R[1];
+            // Lower common tangent
+            for (;;) {
+                if (leftOf(vtx[rdi], ldi)) {
+                    ldi = lnext(ldi);
+                }
+                else if (rightOf(vtx[ldi], rdi)) {
+                    rdi = rprev(rdi);
+                }
+                else {
+                    break;
+                }
+            }
+            let base = connect(sym(rdi), ldi);
+            if (vtx[ldi] === vtx[ldo]) {
+                ldo = sym(base);
+            }
+            if (vtx[rdi] === vtx[rdo]) {
+                rdo = base;
+            }
+            // Merge loop - removing bad edges (inCircle) and adding new edges.
+            for (;;) {
+                // Left candidate
+                let lc = on[sym(base)];
+                if (admissible(lc, base)) {
+                    while (inCircle(dest(base), vtx[base], dest(lc), dest(on[lc]))) {
+                        const t = on[lc];
+                        drop(lc);
+                        lc = t;
+                    }
+                }
+                // Right candidate
+                let rc = oprev(base);
+                if (admissible(rc, base)) {
+                    while (inCircle(dest(base), vtx[base], dest(rc), dest(oprev(rc)))) {
+                        const t = oprev(rc);
+                        drop(rc);
+                        rc = t;
+                    }
+                }
+                if (!admissible(lc, base) && !admissible(rc, base)) {
+                    break;
+                }
+                if (!admissible(lc, base) || (admissible(rc, base) &&
+                    inCircle(dest(lc), vtx[lc], vtx[rc], dest(rc)))) {
+                    base = connect(rc, sym(base));
+                }
+                else {
+                    base = connect(sym(base), sym(lc));
+                }
+            }
+            return [ldo, rdo];
+        };
+        let e0 = solve(0, count)[0];
+        while (leftOf(dest(on[e0]), e0)) {
+            e0 = on[e0];
+        }
+        const Q = [e0];
+        let qi = 0;
+        {
+            let c = e0;
+            do {
+                Q.push(sym(c));
+                seen[c] = 1;
+                c = lnext(c);
+            } while (c !== e0);
+        }
+        const faces = [];
+        let cur, t;
+        while (qi < Q.length) {
+            const e = Q[qi++];
+            if (seen[e]) {
+                continue;
+            }
+            cur = e;
+            do {
+                faces.push(vtx[cur]);
+                t = sym(cur);
+                if (!seen[t]) {
+                    Q.push(t);
+                }
+                seen[cur] = 1;
+                cur = lnext(cur);
+            } while (cur !== e);
+        }
+        return new Uint32Array(faces);
+    }
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default Delaunay;

package/es-modules/Core/Foundation.js

@@ -9,8 +9,7 @@
  *
  * */
 'use strict';
-import U from './Utilities.js';
-const { addEvent, isFunction, objectEach, removeEvent } = U;
+import { addEvent, isFunction, objectEach, removeEvent } from '../Shared/Utilities.js';
 /* *
  *
  *  Class Namespace

package/es-modules/Core/Geometry/CircleUtilities.js

@@ -9,9 +9,8 @@
  * */
 'use strict';
 import Geometry from './GeometryUtilities.js';
-import Utilities from '../Utilities';
+import { correctFloat } from '../../Shared/Utilities.js';
 const { getAngleBetweenPoints, getCenterOfPoints, getDistanceBetweenPoints } = Geometry;
-const { correctFloat } = Utilities;
 /* *
  *
  *  Namespace

package/es-modules/Core/Globals.js

@@ -25,7 +25,7 @@ var Globals;
      *  Constants
      *
      * */
-    Globals.SVG_NS = 'http://www.w3.org/2000/svg', Globals.product = 'Highcharts', Globals.version = '2.2.0', Globals.win = (typeof window !== 'undefined' ?
+    Globals.SVG_NS = 'http://www.w3.org/2000/svg', Globals.product = 'Highcharts', Globals.version = '2.3.0', Globals.win = (typeof window !== 'undefined' ?
         window :
         {}), // eslint-disable-line node/no-unsupported-features/es-builtins
     Globals.doc = Globals.win.document, Globals.svg = !!Globals.doc?.createElementNS?.(Globals.SVG_NS, 'svg')?.createSVGRect, Globals.pageLang = Globals.doc?.documentElement?.closest('[lang]')?.lang, Globals.userAgent = Globals.win.navigator?.userAgent || '', Globals.isChrome = Globals.win.chrome, Globals.isFirefox = Globals.userAgent.indexOf('Firefox') !== -1, Globals.isMS = /(edge|msie|trident)/i.test(Globals.userAgent) && !Globals.win.opera, Globals.isSafari = !Globals.isChrome && Globals.userAgent.indexOf('Safari') !== -1, Globals.isTouchDevice = /(Mobile|Android|Windows Phone)/.test(Globals.userAgent), Globals.isWebKit = Globals.userAgent.indexOf('AppleWebKit') !== -1, Globals.deg2rad = Math.PI * 2 / 360, Globals.marginNames = [

package/es-modules/Core/HttpUtilities.js

@@ -11,8 +11,7 @@
 'use strict';
 import G from '../Core/Globals.js';
 const { win } = G;
-import U from '../Core/Utilities.js';
-const { discardElement, objectEach } = U;
+import { discardElement, objectEach } from '../Shared/Utilities.js';
 /* *
  *
  *  Functions

package/es-modules/Core/MSPointer.js

@@ -12,8 +12,7 @@
 import H from './Globals.js';
 const { charts, composed, doc, noop, win } = H;
 import Pointer from './Pointer.js';
-import U from './Utilities.js';
-const { addEvent, attr, css, defined, objectEach, pick, pushUnique, removeEvent } = U;
+import { addEvent, attr, css, defined, objectEach, pick, pushUnique, removeEvent } from '../Shared/Utilities.js';
 /* *
  *
  *  Constants

package/es-modules/Core/Math3D.js

@@ -10,9 +10,8 @@
  * */
 'use strict';
 import H from './Globals.js';
+import { pick } from '../Shared/Utilities.js';
 const { deg2rad } = H;
-import U from './Utilities.js';
-const { pick } = U;
 /* *
  *
  *  Functions

package/es-modules/Core/Options.d.ts

@@ -194,7 +194,7 @@ export interface LoadingOptions {
      * @sample highcharts/loading/hideduration/
      *         Fade in and out over a second
      *
-     * @default   100
+     * @default   0
      * @since     1.2.0
      */
     showDuration?: number;
@@ -233,11 +233,15 @@ export interface LoadingOptions {
  * The thousands separator, defaults to the one given in the lang options, or a
  * space character.
  *
+ * @param {Highcharts.Chart} [ctx]
+ * Since v12.5.0, the chart context passed as an extra argument for arrow
+ * functions.
+ *
  * @return {string}
  * The formatted number.
  */
 export interface NumberFormatterCallbackFunction {
-    (this: Chart | object | void, number: number, decimals: number, decimalPoint?: string, thousandsSep?: string): string;
+    (this: Chart | object | void, number: number, decimals: number, decimalPoint?: string, thousandsSep?: string, ctx?: Chart): string;
 }
 /**
  * Global options for all charts.

package/es-modules/Core/Pointer.js

@@ -13,8 +13,25 @@ import Color from './Color/Color.js';
 const { parse: color } = Color;
 import H from './Globals.js';
 const { charts, composed, isTouchDevice } = H;
-import U from './Utilities.js';
-const { addEvent, attr, css, extend, find, fireEvent, isNumber, isObject, objectEach, offset, pick, pushUnique, splat } = U;
+import { addEvent, attr, css, defined, extend, find, fireEvent, isNumber, isObject, objectEach, offset, pick, pushUnique, splat } from '../Shared/Utilities.js';
+/**
+ *
+ *  Functions
+ *
+ */
+/**
+ * Check whether the configured action key allows the interaction.
+ *
+ * @internal
+ * @param {Event} e
+ *        A mouse event.
+ * @param {string | undefined} key
+ *        Zoom or pan key.
+ * @return {boolean}
+ *         True if the key is undefined
+ *         or if the action key is pressed. False otherwise.
+ */
+const checkActionKey = (e, key) => !defined(key) || e[`${key}Key`];
 /* *
  *
  *  Class
@@ -212,7 +229,8 @@ class Pointer {
                 selectionMarker.attr(attrs);
             }
             // Panning
-            if (clickedInside && !selectionMarker && panningEnabled) {
+            if (clickedInside && !selectionMarker && panningEnabled &&
+                (checkActionKey(e, panKey))) {
                 chart.pan(e, panning);
             }
         }
@@ -1444,7 +1462,8 @@ class Pointer {
         this.zoomY = zoomY = /y/.test(zoomType);
         this.zoomHor = (zoomX && !inverted) || (zoomY && inverted);
         this.zoomVert = (zoomY && !inverted) || (zoomX && inverted);
-        this.hasZoom = zoomX || zoomY;
+        this.hasZoom = (zoomX || zoomY) &&
+            (checkActionKey(e, chart.zooming.key));
     }
 }
 /** @internal */

package/es-modules/Core/PointerEvent.d.ts

@@ -8,10 +8,12 @@ export interface PointerEvent extends globalThis.PointerEvent {
     accumulate?: boolean;
     chartX: number;
     chartY: number;
+    DOMType?: string;
     lat?: number;
     lon?: number;
     point?: Point;
     touches?: Array<Touch>;
+    trigger?: string;
     xAxis?: Array<Pointer.AxisCoordinateObject>;
     yAxis?: Array<Pointer.AxisCoordinateObject>;
 }

package/es-modules/Core/Renderer/HTML/AST.js

@@ -11,8 +11,8 @@
 'use strict';
 import H from '../../Globals.js';
 const { SVG_NS, win } = H;
-import U from '../../Utilities.js';
-const { attr, createElement, css, error, isFunction, isString, objectEach, splat } = U;
+import { attr, createElement, css, isFunction, isString, objectEach, splat } from '../../../Shared/Utilities.js';
+import { error } from '../../Utilities.js';
 const { trustedTypes } = win;
 /* *
  *

package/es-modules/Core/Renderer/HTML/HTMLElement.js

@@ -13,8 +13,7 @@ import AST from './AST.js';
 import H from '../../Globals.js';
 const { composed, isFirefox } = H;
 import SVGElement from '../SVG/SVGElement.js';
-import U from '../../Utilities.js';
-const { attr, css, createElement, defined, extend, getAlignFactor, isNumber, pInt, pushUnique } = U;
+import { attr, createElement, css, defined, extend, getAlignFactor, isNumber, pInt, pushUnique } from '../../../Shared/Utilities.js';
 /**
  * The opacity and visibility properties are set as attributes on the main
  * element and SVG groups, and as identical CSS properties on the HTML element

package/es-modules/Core/Renderer/RendererUtilities.js

@@ -14,8 +14,7 @@
  *  Imports
  *
  * */
-import U from '../Utilities.js';
-const { clamp, pick, pushUnique, stableSort } = U;
+import { clamp, pick, pushUnique, stableSort } from '../../Shared/Utilities.js';
 /* *
  *
  *  Namespace
@@ -47,7 +46,7 @@ var RendererUtilities;
         // Original array will be altered with added .pos
         const origBoxes = boxes, reducedLen = origBoxes.reducedLen || len, sortByRank = (a, b) => (b.rank || 0) - (a.rank || 0), sortByTarget = (a, b) => a.target - b.target, restBoxes = [], // The outranked overshoot
         boxesLength = boxes.length, forDeletion = [], push = restBoxes.push;
-        let i, cursor, step, overlapping = true, box, target, total = 0, equalRank;
+        let i, overlapping = true, box, target, total = 0, equalRank;
         // If the total size exceeds the len, remove those boxes with the lowest
         // rank
         i = boxesLength;
@@ -58,23 +57,39 @@ var RendererUtilities;
         if (total > reducedLen) {
             stableSort(boxes, sortByRank);
             equalRank = boxes[0].rank === boxes[boxes.length - 1].rank;
-            step = equalRank ? boxesLength / 2 : -1;
-            cursor = equalRank ? step : boxesLength - 1;
-            // When the boxes have equal rank (pie data labels, flags - #10073),
-            // decimate the boxes by starting in the middle and gradually remove
-            // more items inside the array. When they are sorted by rank, just
-            // remove the ones with the lowest rank from the end.
-            while (step && total > reducedLen) {
-                i = Math.floor(cursor);
-                box = boxes[i];
-                if (pushUnique(forDeletion, i)) {
-                    total -= box.size;
+            // When all boxes have equal rank (pie data labels, flags - #10073),
+            // decimate from the center outwards by repeatedly splitting index
+            // ranges. This guarantees progress and avoids cursor/step stalling
+            // on repeated indices (#23541). When ranks differ, remove the
+            // lowest ranked boxes from the end.
+            if (equalRank) {
+                const ranges = [[0, boxesLength - 1]];
+                while (ranges.length && total > reducedLen) {
+                    const range = ranges.shift();
+                    if (!range) {
+                        break;
+                    }
+                    i = Math.floor((range[0] + range[1]) / 2);
+                    box = boxes[i];
+                    if (pushUnique(forDeletion, i)) {
+                        total -= box.size;
+                    }
+                    if (range[0] < i) {
+                        ranges.push([range[0], i - 1]);
+                    }
+                    if (i < range[1]) {
+                        ranges.push([i + 1, range[1]]);
+                    }
                 }
-                cursor += step;
-                // Start over the decimation with smaller steps
-                if (equalRank && cursor >= boxes.length) {
-                    step /= 2;
-                    cursor = step;
+            }
+            else {
+                i = boxesLength - 1;
+                while (total > reducedLen && i >= 0) {
+                    box = boxes[i];
+                    if (pushUnique(forDeletion, i)) {
+                        total -= box.size;
+                    }
+                    i--;
                 }
             }
             // Clean out the boxes marked for deletion

package/es-modules/Core/Responsive.d.ts

@@ -22,7 +22,7 @@ declare module './Options' {
 }
 declare namespace Responsive {
     interface CallbackFunction {
-        (this: Chart): boolean;
+        (this: Chart, ctx?: Chart): boolean;
     }
     interface Options {
         /**
@@ -45,7 +45,9 @@ declare namespace Responsive {
          * A callback function to gain complete control on when the responsive
          * rule applies. Return `true` if it applies. This opens for checking
          * against other metrics than the chart size, for example the document
-         * size or other elements.
+         * size or other elements. Since v12.5.0, the callback also receives
+         * `ctx` as the first argument, so that arrow functions can access the
+         * same context as regular functions using `this`.
          *
          * @since     5.0.0
          * @context   Highcharts.Chart

package/es-modules/Core/Responsive.js

@@ -9,8 +9,8 @@
  *
  * */
 'use strict';
-import U from './Utilities.js';
-const { diffObjects, extend, find, merge, pick, uniqueKey } = U;
+import { diffObjects, extend, find, merge, pick } from '../Shared/Utilities.js';
+import { uniqueKey } from './Utilities.js';
 /* *
  *
  *  Composition
@@ -55,7 +55,7 @@ var Responsive;
                 this.chartWidth >= pick(condition.minWidth, 0) &&
                 this.chartHeight >= pick(condition.minHeight, 0));
         };
-        if (fn.call(this)) {
+        if (fn.call(this, this)) {
             matches.push(rule._id);
         }
     }
@@ -140,6 +140,10 @@ export default Responsive;
  * @param {Highcharts.Chart} this
  * Chart context.
  *
+ * @param {Highcharts.Chart} [ctx]
+ * Since v12.5.0, the chart context passed as an extra argument for arrow
+ * functions.
+ *
  * @return {boolean}
  * Return `true` if it applies.
  */
@@ -216,7 +220,9 @@ export default Responsive;
  * A callback function to gain complete control on when the responsive
  * rule applies. Return `true` if it applies. This opens for checking
  * against other metrics than the chart size, for example the document
- * size or other elements.
+ * size or other elements. Since v12.5.0, the callback also receives `ctx`
+ * as the first argument, so that arrow functions can access the same
+ * context as regular functions using `this`.
  *
  * @type      {Highcharts.ResponsiveCallbackFunction}
  * @since     5.0.0

package/es-modules/Core/Templating.d.ts

@@ -110,7 +110,7 @@ declare const Templating: {
 };
 declare namespace Templating {
     interface FormatterCallback<T> {
-        (this: T): string;
+        (this: T, ...args: Array<any>): string;
     }
     interface OwnerOptions {
         /**

package/es-modules/Core/Templating.js

@@ -13,8 +13,7 @@ import D from './Defaults.js';
 const { defaultOptions, defaultTime } = D;
 import G from './Globals.js';
 const { pageLang } = G;
-import U from './Utilities.js';
-const { extend, getNestedProperty, isArray, isNumber, isObject, isString, pick, ucfirst } = U;
+import { extend, getNestedProperty, isArray, isNumber, isObject, isString, pick, ucfirst } from '../Shared/Utilities.js';
 /** @internal */
 const helpers = {
     // Built-in helpers
@@ -133,12 +132,12 @@ function dateFormat(format, timestamp, upperCaseFirst) {
  */
 function format(str = '', ctx, owner) {
     // eslint-disable-next-line prefer-regex-literals
-    const regex = new RegExp('\\{([\\p{L}\\d:\\.,;\\-\\/<>\\[\\]%_@+"\'’= #\\(\\)]+)\\}', 'gu'), 
+    const regex = new RegExp('\\{([\\p{L}\\p{M}\\d:\\.,;\\-\\/<>\\[\\]%_@+"\'’= #\\(\\)]+)\\}', 'gu'), 
     // The sub expression regex is the same as the top expression regex,
     // but except parens and block helpers (#), and surrounded by parens
     // instead of curly brackets.
     // eslint-disable-next-line prefer-regex-literals
-    subRegex = new RegExp('\\(([\\p{L}\\d:\\.,;\\-\\/<>\\[\\]%_@+"\'= ]+)\\)', 'gu'), matches = [], floatRegex = /f$/, decRegex = /\.(\d)/, lang = owner?.options?.lang || defaultOptions.lang, time = owner?.time || defaultTime, numberFormatter = owner?.numberFormatter || numberFormat.bind(owner);
+    subRegex = new RegExp('\\(([\\p{L}\\p{M}\\d:\\.,;\\-\\/<>\\[\\]%_@+"\'= ]+)\\)', 'gu'), matches = [], floatRegex = /f$/, decRegex = /\.(\d)/, lang = owner?.options?.lang || defaultOptions.lang, time = owner?.time || defaultTime, numberFormatter = owner?.numberFormatter || numberFormat.bind(owner);
     /*
      * Get a literal or variable value inside a template expression. May be
      * extended with other types like string or null if needed, but keep it