@highcharts/grid-pro 2.0.0

package/es-modules/Core/Templating.js

@@ -0,0 +1,428 @@
+/* *
+ *
+ *  (c) 2010-2025 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+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;
+const helpers = {
+    // Built-in helpers
+    add: (a, b) => a + b,
+    divide: (a, b) => (b !== 0 ? a / b : ''),
+    // eslint-disable-next-line eqeqeq
+    eq: (a, b) => a == b,
+    each: function (arr) {
+        const match = arguments[arguments.length - 1];
+        return isArray(arr) ?
+            arr.map((item, i) => format(match.body, extend(isObject(item) ? item : { '@this': item }, {
+                '@index': i,
+                '@first': i === 0,
+                '@last': i === arr.length - 1
+            }))).join('') :
+            false;
+    },
+    ge: (a, b) => a >= b,
+    gt: (a, b) => a > b,
+    'if': (condition) => !!condition,
+    le: (a, b) => a <= b,
+    lt: (a, b) => a < b,
+    multiply: (a, b) => a * b,
+    // eslint-disable-next-line eqeqeq
+    ne: (a, b) => a != b,
+    subtract: (a, b) => a - b,
+    ucfirst,
+    unless: (condition) => !condition
+};
+const numberFormatCache = {};
+/* *
+ *
+ *  Functions
+ *
+ * */
+// Internal convenience function
+const isQuotedString = (str) => /^["'].+["']$/.test(str);
+/**
+ * Formats a JavaScript date timestamp (milliseconds since Jan 1st 1970) into a
+ * human readable date string. The format is a subset of the formats for PHP's
+ * [strftime](https://www.php.net/manual/en/function.strftime.php) function.
+ * Additional formats can be given in the {@link Highcharts.dateFormats} hook.
+ *
+ * Since v6.0.5, all internal dates are formatted through the
+ * {@link Highcharts.Chart#time} instance to respect chart-level time settings.
+ * The `Highcharts.dateFormat` function only reflects global time settings set
+ * with `setOptions`.
+ *
+ * Supported format keys:
+ * - `%a`: Short weekday, like 'Mon'
+ * - `%A`: Long weekday, like 'Monday'
+ * - `%d`: Two digit day of the month, 01 to 31
+ * - `%e`: Day of the month, 1 through 31
+ * - `%w`: Day of the week, 0 through 6
+ * - `%b`: Short month, like 'Jan'
+ * - `%B`: Long month, like 'January'
+ * - `%m`: Two digit month number, 01 through 12
+ * - `%y`: Two digits year, like 09 for 2009
+ * - `%Y`: Four digits year, like 2009
+ * - `%H`: Two digits hours in 24h format, 00 through 23
+ * - `%k`: Hours in 24h format, 0 through 23
+ * - `%I`: Two digits hours in 12h format, 00 through 11
+ * - `%l`: Hours in 12h format, 1 through 12
+ * - `%M`: Two digits minutes, 00 through 59
+ * - `%p`: Upper case AM or PM
+ * - `%P`: Lower case AM or PM
+ * - `%S`: Two digits seconds, 00 through 59
+ * - `%L`: Milliseconds (naming from Ruby)
+ *
+ * @function Highcharts.dateFormat
+ *
+ * @param {string} format
+ *        The desired format where various time representations are prefixed
+ *        with `%`.
+ *
+ * @param {number} timestamp
+ *        The JavaScript timestamp.
+ *
+ * @param {boolean} [upperCaseFirst=false]
+ *        Upper case first letter in the return.
+ *
+ * @return {string}
+ *         The formatted date.
+ */
+function dateFormat(format, timestamp, upperCaseFirst) {
+    return defaultTime.dateFormat(format, timestamp, upperCaseFirst);
+}
+/**
+ * Format a string according to a subset of the rules of Python's String.format
+ * method.
+ *
+ * @example
+ * let s = Highcharts.format(
+ *     'The {color} fox was {len:.2f} feet long',
+ *     { color: 'red', len: Math.PI }
+ * );
+ * // => The red fox was 3.14 feet long
+ *
+ * @function Highcharts.format
+ *
+ * @param {string} str
+ *        The string to format.
+ *
+ * @param {Record<string, *>} ctx
+ *        The context, a collection of key-value pairs where each key is
+ *        replaced by its value.
+ *
+ * @param {Highcharts.Chart} [owner]
+ *        A `Chart` or `Grid` instance used to get numberFormatter and time.
+ *
+ * @return {string}
+ *         The formatted string.
+ */
+function format(str = '', ctx, owner) {
+    // Notice: using u flag will require a refactor for ES5 (#22450).
+    const regex = /\{([a-zA-Z\u00C0-\u017F\d:\.,;\-\/<>\[\]%_@+"'’= #\(\)]+)\}/g, // eslint-disable-line max-len
+    // 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.
+    subRegex = /\(([a-zA-Z\u00C0-\u017F\d:\.,;\-\/<>\[\]%_@+"'= ]+)\)/g, 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
+     * small for now.
+     */
+    const resolveProperty = (key = '') => {
+        let n;
+        // Literals
+        if (key === 'true') {
+            return true;
+        }
+        if (key === 'false') {
+            return false;
+        }
+        if ((n = Number(key)).toString() === key) {
+            return n;
+        }
+        if (isQuotedString(key)) {
+            return key.slice(1, -1);
+        }
+        // Variables and constants
+        return getNestedProperty(key, ctx);
+    };
+    let match, currentMatch, depth = 0, hasSub;
+    // Parse and create tree
+    while ((match = regex.exec(str)) !== null) {
+        // When a sub expression is found, it is evaluated first, and the
+        // results recursively evaluated until no subexpression exists.
+        const mainMatch = match, subMatch = subRegex.exec(match[1]);
+        if (subMatch) {
+            match = subMatch;
+            hasSub = true;
+        }
+        if (!currentMatch?.isBlock) {
+            currentMatch = {
+                ctx,
+                expression: match[1],
+                find: match[0],
+                isBlock: match[1].charAt(0) === '#',
+                start: match.index,
+                startInner: match.index + match[0].length,
+                length: match[0].length
+            };
+        }
+        // Identify helpers
+        const fn = (currentMatch.isBlock ? mainMatch : match)[1].split(' ')[0].replace('#', '');
+        if (helpers[fn]) {
+            // Block helper, only 0 level is handled
+            if (currentMatch.isBlock && fn === currentMatch.fn) {
+                depth++;
+            }
+            if (!currentMatch.fn) {
+                currentMatch.fn = fn;
+            }
+        }
+        // Closing a block helper
+        const startingElseSection = match[1] === 'else';
+        if (currentMatch.isBlock &&
+            currentMatch.fn && (match[1] === `/${currentMatch.fn}` ||
+            startingElseSection)) {
+            if (!depth) { // === 0
+                const start = currentMatch.startInner, body = str.substr(start, match.index - start);
+                // Either closing without an else section, or when encountering
+                // an else section
+                if (currentMatch.body === void 0) {
+                    currentMatch.body = body;
+                    currentMatch.startInner = match.index + match[0].length;
+                    // The body exists already, so this is the else section
+                }
+                else {
+                    currentMatch.elseBody = body;
+                }
+                currentMatch.find += body + match[0];
+                if (!startingElseSection) {
+                    matches.push(currentMatch);
+                    currentMatch = void 0;
+                }
+            }
+            else if (!startingElseSection) {
+                depth--;
+            }
+            // Common expression
+        }
+        else if (!currentMatch.isBlock) {
+            matches.push(currentMatch);
+        }
+        // Evaluate sub-matches one by one to prevent orphaned block closers
+        if (subMatch && !currentMatch?.isBlock) {
+            break;
+        }
+    }
+    // Execute
+    matches.forEach((match) => {
+        const { body, elseBody, expression, fn } = match;
+        let replacement, i;
+        // Helper function
+        if (fn) {
+            // Pass the helpers the amount of arguments defined by the function,
+            // then the match as the last argument.
+            const args = [match], parts = [], len = expression.length;
+            let start = 0, startChar;
+            for (i = 0; i <= len; i++) {
+                const char = expression.charAt(i);
+                // Start of string
+                if (!startChar && (char === '"' || char === '\'')) {
+                    startChar = char;
+                    // End of string
+                }
+                else if (startChar === char) {
+                    startChar = '';
+                }
+                if (!startChar &&
+                    (char === ' ' || i === len)) {
+                    parts.push(expression.substr(start, i - start));
+                    start = i + 1;
+                }
+            }
+            i = helpers[fn].length;
+            while (i--) {
+                args.unshift(resolveProperty(parts[i + 1]));
+            }
+            replacement = helpers[fn].apply(ctx, args);
+            // Block helpers may return true or false. They may also return a
+            // string, like the `each` helper.
+            if (match.isBlock && typeof replacement === 'boolean') {
+                replacement = format(replacement ? body : elseBody, ctx, owner);
+            }
+            // Simple variable replacement
+        }
+        else {
+            const valueAndFormat = isQuotedString(expression) ?
+                [expression] : expression.split(':');
+            replacement = resolveProperty(valueAndFormat.shift() || '');
+            // Format the replacement
+            const isFloat = replacement % 1 !== 0;
+            if (typeof replacement === 'number' &&
+                (valueAndFormat.length || isFloat)) {
+                const segment = valueAndFormat.join(':');
+                if (floatRegex.test(segment) || isFloat) { // Float
+                    const decimals = parseInt((segment.match(decRegex) || ['', '-1'])[1], 10);
+                    if (replacement !== null) {
+                        replacement = numberFormatter(replacement, decimals, lang.decimalPoint, segment.indexOf(',') > -1 ? lang.thousandsSep : '');
+                    }
+                }
+                else {
+                    replacement = time.dateFormat(segment, replacement);
+                }
+            }
+            // Use string literal in order to be preserved in the outer
+            // expression
+            subRegex.lastIndex = 0;
+            if (subRegex.test(match.find) && isString(replacement)) {
+                replacement = `"${replacement}"`;
+            }
+        }
+        str = str.replace(match.find, pick(replacement, ''));
+    });
+    return hasSub ? format(str, ctx, owner) : str;
+}
+/**
+ * Format a number and return a string based on input settings.
+ *
+ * @sample highcharts/members/highcharts-numberformat/
+ *         Custom number format
+ *
+ * @function Highcharts.numberFormat
+ *
+ * @param {number} number
+ *        The input number to format.
+ *
+ * @param {number} decimals
+ *        The amount of decimals. A value of -1 preserves the amount in the
+ *        input number.
+ *
+ * @param {string} [decimalPoint]
+ *        The decimal point, defaults to the one given in the lang options, or
+ *        a dot.
+ *
+ * @param {string} [thousandsSep]
+ *        The thousands separator, defaults to the one given in the lang
+ *        options, or a space character.
+ *
+ * @return {string}
+ *         The formatted number.
+ */
+function numberFormat(number, decimals, decimalPoint, thousandsSep) {
+    number = +number || 0;
+    decimals = +decimals;
+    let ret, fractionDigits, [mantissa, exp] = number.toString().split('e').map(Number);
+    const lang = this?.options?.lang || defaultOptions.lang, origDec = (number.toString().split('.')[1] || '').split('e')[0].length, firstDecimals = decimals, options = {};
+    decimalPoint ?? (decimalPoint = lang.decimalPoint);
+    thousandsSep ?? (thousandsSep = lang.thousandsSep);
+    if (decimals === -1) {
+        // Preserve decimals. Not huge numbers (#3793).
+        decimals = Math.min(origDec, 20);
+    }
+    else if (!isNumber(decimals)) {
+        decimals = 2;
+    }
+    else if (decimals && exp < 0) {
+        // Expose decimals from exponential notation (#7042)
+        fractionDigits = decimals + exp;
+        if (fractionDigits >= 0) {
+            // Remove too small part of the number while keeping the notation
+            mantissa = +mantissa.toExponential(fractionDigits).split('e')[0];
+            decimals = fractionDigits;
+        }
+        else {
+            // `fractionDigits < 0`
+            mantissa = Math.floor(mantissa);
+            if (decimals < 20) {
+                // Use number instead of exponential notation (#7405)
+                number = +(mantissa * Math.pow(10, exp)).toFixed(decimals);
+            }
+            else {
+                // Or zero
+                number = 0;
+            }
+            exp = 0;
+        }
+    }
+    if (exp) {
+        decimals ?? (decimals = 2);
+        number = mantissa;
+    }
+    if (isNumber(decimals) && decimals >= 0) {
+        options.minimumFractionDigits = decimals;
+        options.maximumFractionDigits = decimals;
+    }
+    if (thousandsSep === '') {
+        options.useGrouping = false;
+    }
+    const hasSeparators = thousandsSep || decimalPoint, locale = hasSeparators ?
+        'en' : (this?.locale || lang.locale || pageLang), cacheKey = JSON.stringify(options) + locale, nf = numberFormatCache[cacheKey] ?? (numberFormatCache[cacheKey] = new Intl.NumberFormat(locale, options));
+    ret = nf.format(number);
+    // If thousandsSep or decimalPoint are set, fall back to using English
+    // format with string replacement for the separators.
+    if (hasSeparators) {
+        ret = ret
+            // Preliminary step to avoid re-swapping (#22402)
+            .replace(/([,\.])/g, '_$1')
+            .replace(/_\,/g, thousandsSep ?? ',')
+            .replace('_.', decimalPoint ?? '.');
+    }
+    if (
+    // Remove signed zero (#20564)
+    (!decimals && +ret === 0) ||
+        // Small numbers, no decimals (#14023)
+        (exp < 0 && !firstDecimals)) {
+        ret = '0';
+    }
+    if (exp && +ret !== 0) {
+        ret += 'e' + (exp < 0 ? '' : '+') + exp;
+    }
+    return ret;
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+const Templating = {
+    dateFormat,
+    format,
+    helpers,
+    numberFormat
+};
+export default Templating;
+/* *
+ * API Declarations
+ * */
+/**
+ * @interface Highcharts.Templating
+ *
+ * The Highcharts.Templating interface provides a structure for defining
+ * helpers. Helpers can be used as conditional blocks or functions within
+ * expressions. Highcharts includes several built-in helpers and supports
+ * the addition of custom helpers.
+ *
+ * @see [More information](
+ * https://www.highcharts.com/docs/chart-concepts/templating#helpers)
+ *
+ * @example
+ * // Define a custom helper to return the absolute value of a number
+ * Highcharts.Templating.helpers.abs = value => Math.abs(value);
+ *
+ * // Usage in a format string
+ * format: 'Absolute value: {abs point.y}'
+ *
+ * @name Highcharts.Templating#helpers
+ * @type {Record<string, Function>}
+ */
+(''); // Keeps doclets above in file

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

@@ -0,0 +1,69 @@
+import type TickPositionsArray from './Axis/TickPositionsArray';
+import type TimeTicksInfoObject from './Axis/TimeTicksInfoObject';
+import TimeBase from '../Shared/TimeBase.js';
+declare module './Axis/TickPositionsArray' {
+    interface TickPositionsArray {
+        info?: TimeTicksInfoObject;
+    }
+}
+declare class Time extends TimeBase {
+    /**
+     * Return an array with time positions distributed on round time values
+     * right and right after min and max. Used in datetime axes as well as for
+     * grouping data on a datetime axis.
+     *
+     * @function Highcharts.Time#getTimeTicks
+     *
+     * @param {Highcharts.TimeNormalizedObject} normalizedInterval
+     *        The interval in axis values (ms) and the count
+     *
+     * @param {number} [min]
+     *        The minimum in axis values
+     *
+     * @param {number} [max]
+     *        The maximum in axis values
+     *
+     * @param {number} [startOfWeek=1]
+     *
+     * @return {Highcharts.AxisTickPositionsArray}
+     * Time positions
+     */
+    getTimeTicks(normalizedInterval: Time.TimeNormalizedObject, min?: number, max?: number, startOfWeek?: number): TickPositionsArray;
+}
+declare namespace Time {
+    interface DateTimeFormatOptions extends Intl.DateTimeFormatOptions {
+        dateStyle?: 'full' | 'long' | 'medium' | 'short';
+        fractionalSecondDigits?: number;
+        prefix?: string;
+        suffix?: string;
+        timeStyle?: 'full' | 'long' | 'medium' | 'short';
+    }
+    type DateTimeFormat = string | DateTimeFormatOptions;
+    interface DateTimeLabelFormatObject {
+        from?: DateTimeFormat;
+        list?: DateTimeFormat[];
+        main: DateTimeFormat;
+        range?: boolean;
+        to?: DateTimeFormat;
+    }
+    type DateTimeLabelFormatOption = (DateTimeFormat | Array<string> | Time.DateTimeLabelFormatObject);
+    type DateTimeLabelFormatsOption = (Record<TimeUnit, DateTimeLabelFormatOption>);
+    interface TimeOptions {
+        Date?: any;
+        locale?: string | Array<string>;
+        timezone?: string;
+        timezoneOffset?: number;
+        useUTC?: boolean;
+    }
+    interface TimeFormatCallbackFunction {
+        (this: Time, timestamp: number): string;
+    }
+    interface TimeNormalizedObject {
+        count: number;
+        unitName: TimeUnit;
+        unitRange: number;
+    }
+    type TimeUnit = ('millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year');
+    type TimeUnitValue = ('Date' | 'Day' | 'FullYear' | 'Hours' | 'Milliseconds' | 'Minutes' | 'Month' | 'Seconds');
+}
+export default Time;

package/es-modules/Core/Time.js

@@ -0,0 +1,172 @@
+/* *
+ *
+ *  (c) 2010-2025 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import TimeBase from '../Shared/TimeBase.js';
+import U from '../Core/Utilities.js';
+const { defined, extend, timeUnits } = U;
+/* *
+ *
+ *  Constants
+ *
+ * */
+class Time extends TimeBase {
+    /**
+     * Return an array with time positions distributed on round time values
+     * right and right after min and max. Used in datetime axes as well as for
+     * grouping data on a datetime axis.
+     *
+     * @function Highcharts.Time#getTimeTicks
+     *
+     * @param {Highcharts.TimeNormalizedObject} normalizedInterval
+     *        The interval in axis values (ms) and the count
+     *
+     * @param {number} [min]
+     *        The minimum in axis values
+     *
+     * @param {number} [max]
+     *        The maximum in axis values
+     *
+     * @param {number} [startOfWeek=1]
+     *
+     * @return {Highcharts.AxisTickPositionsArray}
+     * Time positions
+     */
+    getTimeTicks(normalizedInterval, min, max, startOfWeek) {
+        const time = this, tickPositions = [], higherRanks = {}, { count = 1, unitRange } = normalizedInterval;
+        let [year, month, dayOfMonth, hours, minutes, seconds] = time.toParts(min), milliseconds = (min || 0) % 1000, variableDayLength;
+        startOfWeek ?? (startOfWeek = 1);
+        if (defined(min)) { // #1300
+            milliseconds = unitRange >= timeUnits.second ?
+                0 : // #3935
+                count * Math.floor(milliseconds / count);
+            if (unitRange >= timeUnits.second) { // Second
+                seconds = unitRange >= timeUnits.minute ?
+                    0 : // #3935
+                    count * Math.floor(seconds / count);
+            }
+            if (unitRange >= timeUnits.minute) { // Minute
+                minutes = unitRange >= timeUnits.hour ?
+                    0 :
+                    count * Math.floor(minutes / count);
+            }
+            if (unitRange >= timeUnits.hour) { // Hour
+                hours = unitRange >= timeUnits.day ?
+                    0 :
+                    count * Math.floor(hours / count);
+            }
+            if (unitRange >= timeUnits.day) { // Day
+                dayOfMonth = unitRange >= timeUnits.month ?
+                    1 :
+                    Math.max(1, count * Math.floor(dayOfMonth / count));
+            }
+            if (unitRange >= timeUnits.month) { // Month
+                month = unitRange >= timeUnits.year ? 0 :
+                    count * Math.floor(month / count);
+            }
+            if (unitRange >= timeUnits.year) { // Year
+                year -= year % count;
+            }
+            // Week is a special case that runs outside the hierarchy
+            if (unitRange === timeUnits.week) {
+                if (count) {
+                    min = time.makeTime(year, month, dayOfMonth, hours, minutes, seconds, milliseconds);
+                }
+                // Get start of current week, independent of count
+                const weekday = this.dateTimeFormat({
+                    timeZone: this.timezone,
+                    weekday: 'narrow'
+                }, min, 'es'), 
+                // Spanish weekday index
+                weekdayNo = 'DLMXJVS'.indexOf(weekday);
+                dayOfMonth += -weekdayNo + startOfWeek +
+                    // We don't want to skip days that are before
+                    // startOfWeek (#7051)
+                    (weekdayNo < startOfWeek ? -7 : 0);
+            }
+            min = time.makeTime(year, month, dayOfMonth, hours, minutes, seconds, milliseconds);
+            // Handle local timezone offset
+            if (time.variableTimezone && defined(max)) {
+                // Detect whether we need to take the DST crossover into
+                // consideration. If we're crossing over DST, the day length may
+                // be 23h or 25h and we need to compute the exact clock time for
+                // each tick instead of just adding hours. This comes at a cost,
+                // so first we find out if it is needed (#4951).
+                variableDayLength = (
+                // Long range, assume we're crossing over.
+                max - min > 4 * timeUnits.month ||
+                    // Short range, check if min and max are in different time
+                    // zones.
+                    time.getTimezoneOffset(min) !==
+                        time.getTimezoneOffset(max));
+            }
+            // Iterate and add tick positions at appropriate values
+            let t = min, i = 1;
+            while (t < max) {
+                tickPositions.push(t);
+                // Increase the years
+                if (unitRange === timeUnits.year) {
+                    t = time.makeTime(year + i * count, 0);
+                    // Increase the months
+                }
+                else if (unitRange === timeUnits.month) {
+                    t = time.makeTime(year, month + i * count);
+                    // If we're using local time, the interval is not fixed as it
+                    // jumps one hour at the DST crossover
+                }
+                else if (variableDayLength && (unitRange === timeUnits.day ||
+                    unitRange === timeUnits.week)) {
+                    t = time.makeTime(year, month, dayOfMonth +
+                        i * count * (unitRange === timeUnits.day ? 1 : 7));
+                }
+                else if (variableDayLength &&
+                    unitRange === timeUnits.hour &&
+                    count > 1) {
+                    // Make sure higher ranks are preserved across DST (#6797,
+                    // #7621)
+                    t = time.makeTime(year, month, dayOfMonth, hours + i * count);
+                    // Else, the interval is fixed and we use simple addition
+                }
+                else {
+                    t += unitRange * count;
+                }
+                i++;
+            }
+            // Push the last time
+            tickPositions.push(t);
+            // Handle higher ranks. Mark new days if the time is on midnight
+            // (#950, #1649, #1760, #3349). Use a reasonable dropout threshold
+            // to prevent looping over dense data grouping (#6156).
+            if (unitRange <= timeUnits.hour && tickPositions.length < 10000) {
+                tickPositions.forEach((t) => {
+                    if (
+                    // Speed optimization, no need to run dateFormat unless
+                    // we're on a full or half hour
+                    t % 1800000 === 0 &&
+                        // Check for local or global midnight
+                        time.dateFormat('%H%M%S%L', t) === '000000000') {
+                        higherRanks[t] = 'day';
+                    }
+                });
+            }
+        }
+        // Record information on the chosen unit - for dynamic label formatter
+        tickPositions.info = extend(normalizedInterval, {
+            higherRanks,
+            totalRange: unitRange * count
+        });
+        return tickPositions;
+    }
+}
+/* *
+ *
+ * Default export
+ *
+ * */
+export default Time;