https://www.ledevoluy.com/app/dist/ledevoluy-tourisme/addons/woody…/code/es-modules/Core/Utilities.js

1/* *
2 *
3 *  (c) 2010-2024 Torstein Honsi
4 *
5 *  License: www.highcharts.com/license
6 *
7 *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
8 *
9 * */
10'use strict';
11import H from './Globals.js';
12const { charts, doc, win } = H;
13/* *
14 *
15 *  Functions
16 *
17 * */
18/**
19 * Provide error messages for debugging, with links to online explanation. This
20 * function can be overridden to provide custom error handling.
21 *
22 * @sample highcharts/chart/highcharts-error/
23 *         Custom error handler
24 *
25 * @function Highcharts.error
26 *
27 * @param {number|string} code
28 *        The error code. See
29 *        [errors.xml](https://github.com/highcharts/highcharts/blob/master/errors/errors.xml)
30 *        for available codes. If it is a string, the error message is printed
31 *        directly in the console.
32 *
33 * @param {boolean} [stop=false]
34 *        Whether to throw an error or just log a warning in the console.
35 *
36 * @param {Highcharts.Chart} [chart]
37 *        Reference to the chart that causes the error. Used in 'debugger'
38 *        module to display errors directly on the chart.
39 *        Important note: This argument is undefined for errors that lack
40 *        access to the Chart instance. In such case, the error will be
41 *        displayed on the last created chart.
42 *
43 * @param {Highcharts.Dictionary<string>} [params]
44 *        Additional parameters for the generated message.
45 *
46 * @return {void}
47 */
48function error(code, stop, chart, params) {
49    const severity = stop ? 'Highcharts error' : 'Highcharts warning';
50    if (code === 32) {
51        code = `${severity}: Deprecated member`;
52    }
53    const isCode = isNumber(code);
54    let message = isCode ?
55        `${severity} #${code}: www.highcharts.com/errors/${code}/` :
56        code.toString();
57    const defaultHandler = function () {
58        if (stop) {
59            throw new Error(message);
60        }
61        // Else ...
62        if (win.console &&
63            error.messages.indexOf(message) === -1 // Prevent console flooting
64        ) {
65            console.warn(message); // eslint-disable-line no-console
66        }
67    };
68    if (typeof params !== 'undefined') {
69        let additionalMessages = '';
70        if (isCode) {
71            message += '?';
72        }
73        objectEach(params, function (value, key) {
74            additionalMessages += `\n - ${key}: ${value}`;
75            if (isCode) {
76                message += encodeURI(key) + '=' + encodeURI(value);
77            }
78        });
79        message += additionalMessages;
80    }
81    fireEvent(H, 'displayError', { chart, code, message, params }, defaultHandler);
82    error.messages.push(message);
83}
84(function (error) {
85    error.messages = [];
86})(error || (error = {}));
87/**
88 * Utility function to deep merge two or more objects and return a third object.
89 * If the first argument is true, the contents of the second object is copied
90 * into the first object. The merge function can also be used with a single
91 * object argument to create a deep copy of an object.
92 *
93 * @function Highcharts.merge<T>
94 *
95 * @param {true | T} extendOrSource
96 *        Whether to extend the left-side object,
97 *        or the first object to merge as a deep copy.
98 *
99 * @param {...Array<object|undefined>} [sources]
100 *        Object(s) to merge into the previous one.
101 *
102 * @return {T}
103 *         The merged object. If the first argument is true, the return is the
104 *         same as the second argument.
105 */
106function merge(extendOrSource, ...sources) {
107    let i, args = [extendOrSource, ...sources], ret = {};
108    const doCopy = function (copy, original) {
109        // An object is replacing a primitive
110        if (typeof copy !== 'object') {
111            copy = {};
112        }
113        objectEach(original, function (value, key) {
114            // Prototype pollution (#14883)
115            if (key === '__proto__' || key === 'constructor') {
116                return;
117            }
118            // Copy the contents of objects, but not arrays or DOM nodes
119            if (isObject(value, true) &&
120                !isClass(value) &&
121                !isDOMElement(value)) {
122                copy[key] = doCopy(copy[key] || {}, value);
123                // Primitives and arrays are copied over directly
124            }
125            else {
126                copy[key] = original[key];
127            }
128        });
129        return copy;
130    };
131    // If first argument is true, copy into the existing object. Used in
132    // setOptions.
133    if (extendOrSource === true) {
134        ret = args[1];
135        args = Array.prototype.slice.call(args, 2);
136    }
137    // For each argument, extend the return
138    const len = args.length;
139    for (i = 0; i < len; i++) {
140        ret = doCopy(ret, args[i]);
141    }
142    return ret;
143}
144/**
145 * Constrain a value to within a lower and upper threshold.
146 *
147 * @private
148 * @param {number} value The initial value
149 * @param {number} min The lower threshold
150 * @param {number} max The upper threshold
151 * @return {number} Returns a number value within min and max.
152 */
153function clamp(value, min, max) {
154    return value > min ? value < max ? value : max : min;
155}
156/**
157 * Utility for crisping a line position to the nearest full pixel depening on
158 * the line width
159 * @param {number} value       The raw pixel position
160 * @param {number} lineWidth   The line width
161 * @param {boolean} [inverted] Whether the containing group is inverted.
162 *                             Crisping round numbers on the y-scale need to go
163 *                             to the other side because the coordinate system
164 *                             is flipped (scaleY is -1)
165 * @return {number}            The pixel position to use for a crisp display
166 */
167function crisp(value, lineWidth = 0, inverted) {
168    const mod = lineWidth % 2 / 2, inverter = inverted ? -1 : 1;
169    return (Math.round(value * inverter - mod) + mod) * inverter;
170}
171// eslint-disable-next-line valid-jsdoc
172/**
173 * Return the deep difference between two objects. It can either return the new
174 * properties, or optionally return the old values of new properties.
175 * @private
176 */
177function diffObjects(newer, older, keepOlder, collectionsWithUpdate) {
178    const ret = {};
179    /**
180     * Recurse over a set of options and its current values, and store the
181     * current values in the ret object.
182     */
183    function diff(newer, older, ret, depth) {
184        const keeper = keepOlder ? older : newer;
185        objectEach(newer, function (newerVal, key) {
186            if (!depth &&
187                collectionsWithUpdate &&
188                collectionsWithUpdate.indexOf(key) > -1 &&
189                older[key]) {
190                newerVal = splat(newerVal);
191                ret[key] = [];
192                // Iterate over collections like series, xAxis or yAxis and map
193                // the items by index.
194                for (let i = 0; i < Math.max(newerVal.length, older[key].length); i++) {
195                    // Item exists in current data (#6347)
196                    if (older[key][i]) {
197                        // If the item is missing from the new data, we need to
198                        // save the whole config structure. Like when
199                        // responsively updating from a dual axis layout to a
200                        // single axis and back (#13544).
201                        if (newerVal[i] === void 0) {
202                            ret[key][i] = older[key][i];
203                            // Otherwise, proceed
204                        }
205                        else {
206                            ret[key][i] = {};
207                            diff(newerVal[i], older[key][i], ret[key][i], depth + 1);
208                        }
209                    }
210                }
211            }
212            else if (isObject(newerVal, true) &&
213                !newerVal.nodeType // #10044
214            ) {
215                ret[key] = isArray(newerVal) ? [] : {};
216                diff(newerVal, older[key] || {}, ret[key], depth + 1);
217                // Delete empty nested objects
218                if (Object.keys(ret[key]).length === 0 &&
219                    // Except colorAxis which is a special case where the empty
220                    // object means it is enabled. Which is unfortunate and we
221                    // should try to find a better way.
222                    !(key === 'colorAxis' && depth === 0)) {
223                    delete ret[key];
224                }
225            }
226            else if (newer[key] !== older[key] ||
227                // If the newer key is explicitly undefined, keep it (#10525)
228                (key in newer && !(key in older))) {
229                if (key !== '__proto__' && key !== 'constructor') {
230                    ret[key] = keeper[key];
231                }
232            }
233        });
234    }
235    diff(newer, older, ret, 0);
236    return ret;
237}
238/**
239 * Shortcut for parseInt
240 *
241 * @private
242 * @function Highcharts.pInt
243 *
244 * @param {*} s
245 *        any
246 *
247 * @param {number} [mag]
248 *        Magnitude
249 *
250 * @return {number}
251 *         number
252 */
253function pInt(s, mag) {
254    return parseInt(s, mag || 10);
255}
256/**
257 * Utility function to check for string type.
258 *
259 * @function Highcharts.isString
260 *
261 * @param {*} s
262 *        The item to check.
263 *
264 * @return {boolean}
265 *         True if the argument is a string.
266 */
267function isString(s) {
268    return typeof s === 'string';
269}
270/**
271 * Utility function to check if an item is an array.
272 *
273 * @function Highcharts.isArray
274 *
275 * @param {*} obj
276 *        The item to check.
277 *
278 * @return {boolean}
279 *         True if the argument is an array.
280 */
281function isArray(obj) {
282    const str = Object.prototype.toString.call(obj);
283    return str === '[object Array]' || str === '[object Array Iterator]';
284}
285/**
286 * Utility function to check if an item is of type object.
287 *
288 * @function Highcharts.isObject
289 *
290 * @param {*} obj
291 *        The item to check.
292 *
293 * @param {boolean} [strict=false]
294 *        Also checks that the object is not an array.
295 *
296 * @return {boolean}
297 *         True if the argument is an object.
298 */

808 *        If it has tickAmount, avoid landing on tick intervals lower than
809 *        original.
810 *
811 * @return {number}
812 *         The normalized interval.
813 *
814 * @todo
815 * Move this function to the Axis prototype. It is here only for historical
816 * reasons.
817 */
818function normalizeTickInterval(interval, multiples, magnitude, allowDecimals, hasTickAmount) {
819    let i, retInterval = interval;
820    // Round to a tenfold of 1, 2, 2.5 or 5
821    magnitude = pick(magnitude, getMagnitude(interval));
822    const normalized = interval / magnitude;
823    // Multiples for a linear scale
824    if (!multiples) {
825        multiples = hasTickAmount ?
826            // Finer grained ticks when the tick amount is hard set, including
827            // when alignTicks is true on multiple axes (#4580).
828            [1, 1.2, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10] :
829            // Else, let ticks fall on rounder numbers
830            [1, 2, 2.5, 5, 10];
831        // The allowDecimals option
832        if (allowDecimals === false) {
833            if (magnitude === 1) {
834                multiples = multiples.filter(function (num) {
835                    return num % 1 === 0;
836                });
837            }
838            else if (magnitude <= 0.1) {
839                multiples = [1 / magnitude];
840            }
841        }
842    }
843    // Normalize the interval to the nearest multiple
844    for (i = 0; i < multiples.length; i++) {
845        retInterval = multiples[i];
846        // Only allow tick amounts smaller than natural
847        if ((hasTickAmount &&
848            retInterval * magnitude >= interval) ||
849            (!hasTickAmount &&
850                (normalized <=
851                    (multiples[i] +
852                        (multiples[i + 1] || multiples[i])) / 2))) {
853            break;
854        }
855    }
856    // Multiply back to the correct magnitude. Correct floats to appropriate
857    // precision (#6085).
858    retInterval = correctFloat(retInterval * magnitude, -Math.round(Math.log(0.001) / Math.LN10));
859    return retInterval;
860}
861/**
862 * Sort an object array and keep the order of equal items. The ECMAScript
863 * standard does not specify the behaviour when items are equal.
864 *
865 * @function Highcharts.stableSort
866 *
867 * @param {Array<*>} arr
868 *        The array to sort.
869 *
870 * @param {Function} sortFunction
871 *        The function to sort it with, like with regular Array.prototype.sort.
872 */
873function stableSort(arr, sortFunction) {
874    // @todo It seems like Chrome since v70 sorts in a stable way internally,
875    // plus all other browsers do it, so over time we may be able to remove this
876    // function
877    const length = arr.length;
878    let sortValue, i;
879    // Add index to each item
880    for (i = 0; i < length; i++) {
881        arr[i].safeI = i; // Stable sort index
882    }
883    arr.sort(function (a, b) {
884        sortValue = sortFunction(a, b);
885        return sortValue === 0 ? a.safeI - b.safeI : sortValue;
886    });
887    // Remove index from items
888    for (i = 0; i < length; i++) {
889        delete arr[i].safeI; // Stable sort index
890    }
891}
892/**
893 * Non-recursive method to find the lowest member of an array. `Math.min` raises
894 * a maximum call stack size exceeded error in Chrome when trying to apply more
895 * than 150.000 points. This method is slightly slower, but safe.
896 *
897 * @function Highcharts.arrayMin
898 *
899 * @param {Array<*>} data
900 *        An array of numbers.
901 *
902 * @return {number}
903 *         The lowest number.
904 */
905function arrayMin(data) {
906    let i = data.length, min = data[0];
907    while (i--) {
908        if (data[i] < min) {
909            min = data[i];
910        }
911    }
912    return min;
913}
914/**
915 * Non-recursive method to find the lowest member of an array. `Math.max` raises
916 * a maximum call stack size exceeded error in Chrome when trying to apply more
917 * than 150.000 points. This method is slightly slower, but safe.
918 *
919 * @function Highcharts.arrayMax
920 *
921 * @param {Array<*>} data
922 *        An array of numbers.
923 *
924 * @return {number}
925 *         The highest number.
926 */
927function arrayMax(data) {
928    let i = data.length, max = data[0];
929    while (i--) {
930        if (data[i] > max) {
931            max = data[i];
932        }
933    }
934    return max;
935}
936/**
937 * Utility method that destroys any SVGElement instances that are properties on
938 * the given object. It loops all properties and invokes destroy if there is a
939 * destroy method. The property is then delete.
940 *
941 * @function Highcharts.destroyObjectProperties
942 *
943 * @param {*} obj
944 *        The object to destroy properties on.
945 *
946 * @param {*} [except]
947 *        Exception, do not destroy this property, only delete it.
948 */
949function destroyObjectProperties(obj, except, destructablesOnly) {
950    objectEach(obj, function (val, n) {
951        // If the object is non-null and destroy is defined
952        if (val !== except && val?.destroy) {
953            // Invoke the destroy
954            val.destroy();
955        }
956        // Delete the property from the object
957        if (val?.destroy || !destructablesOnly) {
958            delete obj[n];
959        }
960    });
961}
962/**
963 * Discard a HTML element
964 *
965 * @function Highcharts.discardElement
966 *
967 * @param {Highcharts.HTMLDOMElement} element
968 *        The HTML node to discard.
969 */
970function discardElement(element) {
971    if (element && element.parentElement) {
972        element.parentElement.removeChild(element);
973    }
974}
975/**
976 * Fix JS round off float errors.
977 *
978 * @function Highcharts.correctFloat
979 *
980 * @param {number} num
981 *        A float number to fix.
982 *
983 * @param {number} [prec=14]
984 *        The precision.
985 *
986 * @return {number}
987 *         The corrected float number.
988 */
989function correctFloat(num, prec) {
990    // When the number is higher than 1e14 use the number (#16275)
991    return num > 1e14 ? num : parseFloat(num.toPrecision(prec || 14));
992}
993/**
994 * The time unit lookup
995 *
996 * @ignore
997 */
998const timeUnits = {
999    millisecond: 1,
1000    second: 1000,
1001    minute: 60000,
1002    hour: 3600000,
1003    day: 24 * 3600000,
1004    week: 7 * 24 * 3600000,
1005    month: 28 * 24 * 3600000,
1006    year: 364 * 24 * 3600000
1007};
1008/**
1009 * Easing definition
1010 *
1011 * @private
1012 * @function Math.easeInOutSine
1013 *
1014 * @param {number} pos
1015 *        Current position, ranging from 0 to 1.
1016 *
1017 * @return {number}
1018 *         Ease result
1019 */
1020Math.easeInOutSine = function (pos) {
1021    return -0.5 * (Math.cos(Math.PI * pos) - 1);
1022};
1023/**
1024 * Convenience function to get the align factor, used several places for
1025 * computing positions
1026 * @private
1027 */
1028const getAlignFactor = (align = '') => ({
1029    center: 0.5,
1030    right: 1,
1031    middle: 0.5,
1032    bottom: 1
1033}[align] || 0);
1034/**
1035 * Find the closest distance between two values of a two-dimensional array
1036 * @private
1037 * @function Highcharts.getClosestDistance
1038 *
1039 * @param {Array<Array<number>>} arrays
1040 *          An array of arrays of numbers
1041 *
1042 * @return {number | undefined}
1043 *          The closest distance between values
1044 */
1045function getClosestDistance(arrays, onError) {
1046    const allowNegative = !onError;

1047    let closest, loopLength, distance, i;
1048    arrays.forEach((xData) => {
1049        if (xData.length > 1) {
1050            loopLength = xData.length - 1;
1051            for (i = loopLength; i > 0; i--) {
1052                distance = xData[i] - xData[i - 1];
1053                if (distance < 0 && !allowNegative) {
1054                    onError?.();
1055                    // Only one call
1056                    onError = void 0;
1057                }
1058                else if (distance && (typeof closest === 'undefined' || distance < closest)) {
1059                    closest = distance;
1060                }
1061            }
1062        }
1063    });
1064    return closest;
1065}
1066/**
1067 * Returns the value of a property path on a given object.
1068 *
1069 * @private
1070 * @function getNestedProperty
1071 *
1072 * @param {string} path
1073 * Path to the property, for example `custom.myValue`.
1074 *
1075 * @param {unknown} obj
1076 * Instance containing the property on the specific path.
1077 *
1078 * @return {unknown}
1079 * The unknown property value.
1080 */
1081function getNestedProperty(path, parent) {
1082    const pathElements = path.split('.');
1083    while (pathElements.length && defined(parent)) {
1084        const pathElement = pathElements.shift();
1085        // Filter on the key
1086        if (typeof pathElement === 'undefined' ||
1087            pathElement === '__proto__') {
1088            return; // Undefined
1089        }
1090        if (pathElement === 'this') {
1091            let thisProp;
1092            if (isObject(parent)) {
1093                thisProp = parent['@this'];
1094            }
1095            return thisProp ?? parent;
1096        }
1097        const child = parent[pathElement.replace(/[\\'"]/g, '')];
1098        // Filter on the child
1099        if (!defined(child) ||
1100            typeof child === 'function' ||
1101            typeof child.nodeType === 'number' ||
1102            child === win) {
1103            return; // Undefined
1104        }
1105        // Else, proceed
1106        parent = child;
1107    }
1108    return parent;
1109}
1110/**
1111 * Get the computed CSS value for given element and property, only for numerical
1112 * properties. For width and height, the dimension of the inner box (excluding
1113 * padding) is returned. Used for fitting the chart within the container.
1114 *
1115 * @function Highcharts.getStyle
1116 *
1117 * @param {Highcharts.HTMLDOMElement} el
1118 * An HTML element.
1119 *
1120 * @param {string} prop
1121 * The property name.
1122 *
1123 * @param {boolean} [toInt=true]
1124 * Parse to integer.
1125 *
1126 * @return {number|string|undefined}
1127 * The style value.
1128 */
1129function getStyle(el, prop, toInt) {
1130    let style;
1131    // For width and height, return the actual inner pixel size (#4913)
1132    if (prop === 'width') {
1133        let offsetWidth = Math.min(el.offsetWidth, el.scrollWidth);
1134        // In flex boxes, we need to use getBoundingClientRect and floor it,
1135        // because scrollWidth doesn't support subpixel precision (#6427) ...
1136        const boundingClientRectWidth = el.getBoundingClientRect &&
1137            el.getBoundingClientRect().width;
1138        // ...unless if the containing div or its parents are transform-scaled
1139        // down, in which case the boundingClientRect can't be used as it is
1140        // also scaled down (#9871, #10498).
1141        if (boundingClientRectWidth < offsetWidth &&
1142            boundingClientRectWidth >= offsetWidth - 1) {
1143            offsetWidth = Math.floor(boundingClientRectWidth);
1144        }
1145        return Math.max(0, // #8377
1146        (offsetWidth -
1147            (getStyle(el, 'padding-left', true) || 0) -
1148            (getStyle(el, 'padding-right', true) || 0)));
1149    }
1150    if (prop === 'height') {
1151        return Math.max(0, // #8377
1152        (Math.min(el.offsetHeight, el.scrollHeight) -
1153            (getStyle(el, 'padding-top', true) || 0) -
1154            (getStyle(el, 'padding-bottom', true) || 0)));
1155    }
1156    // Otherwise, get the computed style
1157    const css = win.getComputedStyle(el, void 0); // eslint-disable-line no-undefined
1158    if (css) {
1159        style = css.getPropertyValue(prop);
1160        if (pick(toInt, prop !== 'opacity')) {
1161            style = pInt(style);
1162        }
1163    }
1164    return style;
1165}
1166/**
1167 * Return the value of the first element in the array that satisfies the
1168 * provided testing function.
1169 *
1170 * @function Highcharts.find<T>
1171 *
1172 * @param {Array<T>} arr
1173 *        The array to test.
1174 *
1175 * @param {Function} callback
1176 *        The callback function. The function receives the item as the first
1177 *        argument. Return `true` if this item satisfies the condition.
1178 *
1179 * @return {T|undefined}
1180 *         The value of the element.
1181 */
1182const find = Array.prototype.find ?
1183    function (arr, callback) {
1184        return arr.find(callback);
1185    } :
1186    // Legacy implementation. PhantomJS, IE <= 11 etc. #7223.
1187    function (arr, callback) {
1188        let i;
1189        const length = arr.length;
1190        for (i = 0; i < length; i++) {
1191            if (callback(arr[i], i)) { // eslint-disable-line node/callback-return
1192                return arr[i];
1193            }
1194        }
1195    };
1196/**
1197 * Get the element's offset position, corrected for `overflow: auto`.
1198 *
1199 * @function Highcharts.offset
1200 *
1201 * @param {global.Element} el
1202 *        The DOM element.
1203 *
1204 * @return {Highcharts.OffsetObject}
1205 *         An object containing `left` and `top` properties for the position in
1206 *         the page.
1207 */
1208function offset(el) {
1209    const docElem = doc.documentElement, box = (el.parentElement || el.parentNode) ?
1210        el.getBoundingClientRect() :
1211        { top: 0, left: 0, width: 0, height: 0 };
1212    return {
1213        top: box.top + (win.pageYOffset || docElem.scrollTop) -
1214            (docElem.clientTop || 0),
1215        left: box.left + (win.pageXOffset || docElem.scrollLeft) -
1216            (docElem.clientLeft || 0),
1217        width: box.width,
1218        height: box.height
1219    };
1220}
1221/* eslint-disable valid-jsdoc */
1222/**
1223 * Iterate over object key pairs in an object.
1224 *
1225 * @function Highcharts.objectEach<T>
1226 *
1227 * @param {*} obj
1228 *        The object to iterate over.
1229 *
1230 * @param {Highcharts.ObjectEachCallbackFunction<T>} fn
1231 *        The iterator callback. It passes three arguments:
1232 *        * value - The property value.
1233 *        * key - The property key.
1234 *        * obj - The object that objectEach is being applied to.
1235 *
1236 * @param {T} [ctx]
1237 *        The context.
1238 */
1239function objectEach(obj, fn, ctx) {
1240    /* eslint-enable valid-jsdoc */
1241    for (const key in obj) {
1242        if (Object.hasOwnProperty.call(obj, key)) {
1243            fn.call(ctx || obj[key], obj[key], key, obj);
1244        }
1245    }
1246}
1247/* eslint-disable valid-jsdoc */
1248/**
1249 * Add an event listener.
1250 *
1251 * @function Highcharts.addEvent<T>
1252 *
1253 * @param  {Highcharts.Class<T>|T} el
1254 *         The element or object to add a listener to. It can be a
1255 *         {@link HTMLDOMElement}, an {@link SVGElement} or any other object.
1256 *
1257 * @param  {string} type
1258 *         The event type.
1259 *
1260 * @param  {Highcharts.EventCallbackFunction<T>|Function} fn
1261 *         The function callback to execute when the event is fired.
1262 *
1263 * @param  {Highcharts.EventOptionsObject} [options]
1264 *         Options for adding the event.
1265 *
1266 * @sample highcharts/members/addevent
1267 *         Use a general `render` event to draw shapes on a chart
1268 *
1269 * @return {Function}
1270 *         A callback function to remove the added event.
1271 */
1272function addEvent(el, type, fn, options = {}) {
1273    /* eslint-enable valid-jsdoc */
1274    // Add hcEvents to either the prototype (in case we're running addEvent on a
1275    // class) or the instance. If hasOwnProperty('hcEvents') is false, it is
1276    // inherited down the prototype chain, in which case we need to set the
1277    // property on this instance (which may itself be a prototype).
1278    const owner = typeof el === 'function' && el.prototype || el;
1279    if (!Object.hasOwnProperty.call(owner, 'hcEvents')) {
1280        owner.hcEvents = {};
1281    }
1282    const events = owner.hcEvents;
1283    // Allow click events added to points, otherwise they will be prevented by
1284    // the TouchPointer.pinch function after a pinch zoom operation (#7091).
1285    if (H.Point && // Without H a dependency loop occurs
1286        el instanceof H.Point &&
1287        el.series &&
1288        el.series.chart) {
1289        el.series.chart.runTrackerClick = true;
1290    }
1291    // Handle DOM events
1292    // If the browser supports passive events, add it to improve performance
1293    // on touch events (#11353).
1294    const addEventListener = el.addEventListener;
1295    if (addEventListener) {
1296        addEventListener.call(el, type, fn, H.supportsPassiveEvents ? {
1297            passive: options.passive === void 0 ?
1298                type.indexOf('touch') !== -1 : options.passive,
1299            capture: false
1300        } : false);
1301    }
1302    if (!events[type]) {
1303        events[type] = [];
1304    }
1305    const eventObject = {
1306        fn,
1307        order: typeof options.order === 'number' ? options.order : Infinity
1308    };
1309    events[type].push(eventObject);
1310    // Order the calls
1311    events[type].sort((a, b) => a.order - b.order);
1312    // Return a function that can be called to remove this event.
1313    return function () {
1314        removeEvent(el, type, fn);
1315    };
1316}
1317/* eslint-disable valid-jsdoc */
1318/**
1319 * Remove an event that was added with {@link Highcharts#addEvent}.
1320 *
1321 * @function Highcharts.removeEvent<T>
1322 *
1323 * @param {Highcharts.Class<T>|T} el
1324 *        The element to remove events on.
1325 *
1326 * @param {string} [type]
1327 *        The type of events to remove. If undefined, all events are removed
1328 *        from the element.
1329 *
1330 * @param {Highcharts.EventCallbackFunction<T>} [fn]
1331 *        The specific callback to remove. If undefined, all events that match
1332 *        the element and optionally the type are removed.
1333 *
1334 * @return {void}
1335 */
1336function removeEvent(el, type, fn) {
1337    /* eslint-enable valid-jsdoc */
1338    /**
1339     * @private
1340     */
1341    function removeOneEvent(type, fn) {
1342        const removeEventListener = el.removeEventListener;
1343        if (removeEventListener) {
1344            removeEventListener.call(el, type, fn, false);
1345        }
1346    }
1347    /**
1348     * @private
1349     */
1350    function removeAllEvents(eventCollection) {
1351        let types, len;
1352        if (!el.nodeName) {
1353            return; // Break on non-DOM events
1354        }
1355        if (type) {
1356            types = {};
1357            types[type] = true;
1358        }
1359        else {
1360            types = eventCollection;
1361        }
1362        objectEach(types, function (_val, n) {
1363            if (eventCollection[n]) {
1364                len = eventCollection[n].length;
1365                while (len--) {
1366                    removeOneEvent(n, eventCollection[n][len].fn);
1367                }
1368            }
1369        });
1370    }
1371    const owner = typeof el === 'function' && el.prototype || el;
1372    if (Object.hasOwnProperty.call(owner, 'hcEvents')) {
1373        const events = owner.hcEvents;
1374        if (type) {
1375            const typeEvents = (events[type] || []);
1376            if (fn) {
1377                events[type] = typeEvents.filter(function (obj) {
1378                    return fn !== obj.fn;
1379                });
1380                removeOneEvent(type, fn);
1381            }
1382            else {
1383                removeAllEvents(events);
1384                events[type] = [];
1385            }
1386        }
1387        else {
1388            removeAllEvents(events);
1389            delete owner.hcEvents;
1390        }
1391    }
1392}
1393/* eslint-disable valid-jsdoc */
1394/**
1395 * Fire an event that was registered with {@link Highcharts#addEvent}.
1396 *
1397 * @function Highcharts.fireEvent<T>
1398 *
1399 * @param {T} el
1400 *        The object to fire the event on. It can be a {@link HTMLDOMElement},
1401 *        an {@link SVGElement} or any other object.
1402 *
1403 * @param {string} type
1404 *        The type of event.
1405 *
1406 * @param {Highcharts.Dictionary<*>|Event} [eventArguments]
1407 *        Custom event arguments that are passed on as an argument to the event
1408 *        handler.
1409 *
1410 * @param {Highcharts.EventCallbackFunction<T>|Function} [defaultFunction]
1411 *        The default function to execute if the other listeners haven't
1412 *        returned false.
1413 *
1414 * @return {void}
1415 */
1416function fireEvent(el, type, eventArguments, defaultFunction) {
1417    /* eslint-enable valid-jsdoc */
1418    eventArguments = eventArguments || {};
1419    if (doc.createEvent &&
1420        (el.dispatchEvent ||
1421            (el.fireEvent &&
1422                // Enable firing events on Highcharts instance.
1423                el !== H))) {
1424        const e = doc.createEvent('Events');
1425        e.initEvent(type, true, true);
1426        eventArguments = extend(e, eventArguments);
1427        if (el.dispatchEvent) {
1428            el.dispatchEvent(eventArguments);
1429        }
1430        else {
1431            el.fireEvent(type, eventArguments);
1432        }
1433    }
1434    else if (el.hcEvents) {
1435        if (!eventArguments.target) {
1436            // We're running a custom event
1437            extend(eventArguments, {
1438                // Attach a simple preventDefault function to skip
1439                // default handler if called. The built-in
1440                // defaultPrevented property is not overwritable (#5112)
1441                preventDefault: function () {
1442                    eventArguments.defaultPrevented = true;
1443                },
1444                // Setting target to native events fails with clicking
1445                // the zoom-out button in Chrome.
1446                target: el,
1447                // If the type is not set, we're running a custom event
1448                // (#2297). If it is set, we're running a browser event.
1449                type: type
1450            });
1451        }
1452        const events = [];
1453        let object = el;
1454        let multilevel = false;
1455        // Recurse up the inheritance chain and collect hcEvents set as own
1456        // objects on the prototypes.
1457        while (object.hcEvents) {
1458            if (Object.hasOwnProperty.call(object, 'hcEvents') &&
1459                object.hcEvents[type]) {
1460                if (events.length) {
1461                    multilevel = true;
1462                }
1463                events.unshift.apply(events, object.hcEvents[type]);
1464            }
1465            object = Object.getPrototypeOf(object);
1466        }
1467        // For performance reasons, only sort the event handlers in case we are
1468        // dealing with multiple levels in the prototype chain. Otherwise, the
1469        // events are already sorted in the addEvent function.
1470        if (multilevel) {
1471            // Order the calls
1472            events.sort((a, b) => a.order - b.order);
1473        }
1474        // Call the collected event handlers