@visactor/vutils 0.17.4 → 0.18.0-alpha.1

package/dist/index.js

@@ -4784,6 +4784,684 @@
 	    return { x: lng, y: lat };
 	}
 
+	class TimeUtil {
+	    static getInstance() {
+	        if (!TimeUtil.instance) {
+	            TimeUtil.instance = new TimeUtil();
+	        }
+	        return TimeUtil.instance;
+	    }
+	    constructor() {
+	        this.locale_shortWeekdays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+	        this.locale_periods = ['AM', 'PM'];
+	        this.locale_weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+	        this.locale_shortMonths = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+	        this.numberRe = /^\s*\d+/;
+	        this.pads = { '-': '', _: ' ', '0': '0' };
+	        this.requoteRe = /[\\^$*+?|[\]().{}]/g;
+	        this.locale_months = [
+	            'January',
+	            'February',
+	            'March',
+	            'April',
+	            'May',
+	            'June',
+	            'July',
+	            'August',
+	            'September',
+	            'October',
+	            'November',
+	            'December'
+	        ];
+	        this.formatShortWeekday = (d) => {
+	            return this.locale_shortWeekdays[d.getDay()];
+	        };
+	        this.formatWeekday = (d) => {
+	            return this.locale_weekdays[d.getDay()];
+	        };
+	        this.formatShortMonth = (d) => {
+	            return this.locale_shortMonths[d.getMonth()];
+	        };
+	        this.formatMonth = (d) => {
+	            return this.locale_months[d.getMonth()];
+	        };
+	        this.formatDayOfMonth = (d, p) => {
+	            return this.pad(d.getDate(), p, 2);
+	        };
+	        this.formatHour24 = (d, p) => {
+	            return this.pad(d.getHours(), p, 2);
+	        };
+	        this.formatHour12 = (d, p) => {
+	            return this.pad(d.getHours() % 12 || 12, p, 2);
+	        };
+	        this.formatMilliseconds = (d, p) => {
+	            return this.pad(d.getMilliseconds(), p, 3);
+	        };
+	        this.formatMonthNumber = (d, p) => {
+	            return this.pad(d.getMonth() + 1, p, 2);
+	        };
+	        this.formatMinutes = (d, p) => {
+	            return this.pad(d.getMinutes(), p, 2);
+	        };
+	        this.formatPeriod = (d) => {
+	            return this.locale_periods[+(d.getHours() >= 12)];
+	        };
+	        this.formatSeconds = (d, p) => {
+	            return this.pad(d.getSeconds(), p, 2);
+	        };
+	        this.formatFullYear = (d, p) => {
+	            return this.pad(d.getFullYear() % 10000, p, 4);
+	        };
+	        this.formatUTCShortWeekday = (d) => {
+	            return this.locale_shortWeekdays[d.getUTCDay()];
+	        };
+	        this.formatUTCWeekday = (d) => {
+	            return this.locale_weekdays[d.getUTCDay()];
+	        };
+	        this.formatUTCShortMonth = (d) => {
+	            return this.locale_shortMonths[d.getUTCMonth()];
+	        };
+	        this.formatUTCMonth = (d) => {
+	            return this.locale_months[d.getUTCMonth()];
+	        };
+	        this.formatUTCDayOfMonth = (d, p) => {
+	            return this.pad(d.getUTCDate(), p, 2);
+	        };
+	        this.formatUTCHour24 = (d, p) => {
+	            return this.pad(d.getUTCHours(), p, 2);
+	        };
+	        this.formatUTCHour12 = (d, p) => {
+	            return this.pad(d.getUTCHours() % 12 || 12, p, 2);
+	        };
+	        this.formatUTCMilliseconds = (d, p) => {
+	            return this.pad(d.getUTCMilliseconds(), p, 3);
+	        };
+	        this.formatUTCMonthNumber = (d, p) => {
+	            return this.pad(d.getUTCMonth() + 1, p, 2);
+	        };
+	        this.formatUTCMinutes = (d, p) => {
+	            return this.pad(d.getUTCMinutes(), p, 2);
+	        };
+	        this.formatUTCPeriod = (d) => {
+	            return this.locale_periods[+(d.getUTCHours() >= 12)];
+	        };
+	        this.formatUTCSeconds = (d, p) => {
+	            return this.pad(d.getUTCSeconds(), p, 2);
+	        };
+	        this.formatUTCFullYear = (d, p) => {
+	            return this.pad(d.getUTCFullYear() % 10000, p, 4);
+	        };
+	        this.formats = {
+	            a: this.formatShortWeekday,
+	            A: this.formatWeekday,
+	            b: this.formatShortMonth,
+	            B: this.formatMonth,
+	            d: this.formatDayOfMonth,
+	            e: this.formatDayOfMonth,
+	            H: this.formatHour24,
+	            I: this.formatHour12,
+	            L: this.formatMilliseconds,
+	            m: this.formatMonthNumber,
+	            M: this.formatMinutes,
+	            p: this.formatPeriod,
+	            S: this.formatSeconds,
+	            Y: this.formatFullYear
+	        };
+	        this.utcFormats = {
+	            a: this.formatUTCShortWeekday,
+	            A: this.formatUTCWeekday,
+	            b: this.formatUTCShortMonth,
+	            B: this.formatUTCMonth,
+	            d: this.formatUTCDayOfMonth,
+	            e: this.formatUTCDayOfMonth,
+	            H: this.formatUTCHour24,
+	            I: this.formatUTCHour12,
+	            L: this.formatUTCMilliseconds,
+	            m: this.formatUTCMonthNumber,
+	            M: this.formatUTCMinutes,
+	            p: this.formatUTCPeriod,
+	            S: this.formatUTCSeconds,
+	            Y: this.formatUTCFullYear
+	        };
+	        this.parseShortWeekday = (d, string, i) => {
+	            const n = this.shortWeekdayRe.exec(string.slice(i));
+	            return n ? ((d.w = this.shortWeekdayLookup.get(n[0].toLowerCase())), i + n[0].length) : -1;
+	        };
+	        this.parseWeekday = (d, string, i) => {
+	            const n = this.weekdayRe.exec(string.slice(i));
+	            return n ? ((d.w = this.weekdayLookup.get(n[0].toLowerCase())), i + n[0].length) : -1;
+	        };
+	        this.parseShortMonth = (d, string, i) => {
+	            const n = this.shortMonthRe.exec(string.slice(i));
+	            return n ? ((d.m = this.shortMonthLookup.get(n[0].toLowerCase())), i + n[0].length) : -1;
+	        };
+	        this.parseMonth = (d, string, i) => {
+	            const n = this.monthRe.exec(string.slice(i));
+	            return n ? ((d.m = this.monthLookup.get(n[0].toLowerCase())), i + n[0].length) : -1;
+	        };
+	        this.parseDayOfMonth = (d, string, i) => {
+	            const n = this.numberRe.exec(string.slice(i, i + 2));
+	            return n ? ((d.d = +n[0]), i + n[0].length) : -1;
+	        };
+	        this.parseHour24 = (d, string, i) => {
+	            const n = this.numberRe.exec(string.slice(i, i + 2));
+	            return n ? ((d.H = +n[0]), i + n[0].length) : -1;
+	        };
+	        this.parseMilliseconds = (d, string, i) => {
+	            const n = this.numberRe.exec(string.slice(i, i + 3));
+	            return n ? ((d.L = +n[0]), i + n[0].length) : -1;
+	        };
+	        this.parseMonthNumber = (d, string, i) => {
+	            const n = this.numberRe.exec(string.slice(i, i + 2));
+	            return n ? ((d.m = n - 1), i + n[0].length) : -1;
+	        };
+	        this.parseMinutes = (d, string, i) => {
+	            const n = this.numberRe.exec(string.slice(i, i + 2));
+	            return n ? ((d.M = +n[0]), i + n[0].length) : -1;
+	        };
+	        this.parsePeriod = (d, string, i) => {
+	            const n = this.periodRe.exec(string.slice(i));
+	            return n ? ((d.p = this.periodLookup.get(n[0].toLowerCase())), i + n[0].length) : -1;
+	        };
+	        this.parseSeconds = (d, string, i) => {
+	            const n = this.numberRe.exec(string.slice(i, i + 2));
+	            return n ? ((d.S = +n[0]), i + n[0].length) : -1;
+	        };
+	        this.parseFullYear = (d, string, i) => {
+	            const n = this.numberRe.exec(string.slice(i, i + 4));
+	            return n ? ((d.y = +n[0]), i + n[0].length) : -1;
+	        };
+	        this.parses = {
+	            a: this.parseShortWeekday,
+	            A: this.parseWeekday,
+	            b: this.parseShortMonth,
+	            B: this.parseMonth,
+	            d: this.parseDayOfMonth,
+	            e: this.parseDayOfMonth,
+	            H: this.parseHour24,
+	            I: this.parseHour24,
+	            L: this.parseMilliseconds,
+	            m: this.parseMonthNumber,
+	            M: this.parseMinutes,
+	            p: this.parsePeriod,
+	            S: this.parseSeconds,
+	            Y: this.parseFullYear
+	        };
+	        this.timeFormat = (specifier, timeText) => {
+	            return this.newFormat(specifier, this.formats)(new Date(this.getFullTimeStamp(timeText)));
+	        };
+	        this.timeUTCFormat = (specifier, timeText) => {
+	            return this.newFormat(specifier, this.utcFormats)(new Date(this.getFullTimeStamp(timeText)));
+	        };
+	        this.timeParse = (specifier, timeText) => {
+	            return this.newParse(specifier, false)(timeText + '');
+	        };
+	        this.requoteF = this.requote.bind(this);
+	        this.periodRe = this.formatRe(this.locale_periods);
+	        this.periodLookup = this.formatLookup(this.locale_periods);
+	        this.weekdayRe = this.formatRe(this.locale_weekdays);
+	        this.weekdayLookup = this.formatLookup(this.locale_weekdays);
+	        this.shortWeekdayRe = this.formatRe(this.locale_shortWeekdays);
+	        this.shortWeekdayLookup = this.formatLookup(this.locale_shortWeekdays);
+	        this.monthRe = this.formatRe(this.locale_months);
+	        this.monthLookup = this.formatLookup(this.locale_months);
+	        this.shortMonthRe = this.formatRe(this.locale_shortMonths);
+	        this.shortMonthLookup = this.formatLookup(this.locale_shortMonths);
+	    }
+	    requote(s) {
+	        return s.replace(this.requoteRe, '\\$&');
+	    }
+	    localDate(d) {
+	        if (0 <= d.y && d.y < 100) {
+	            const date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);
+	            date.setFullYear(d.y);
+	            return date;
+	        }
+	        return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);
+	    }
+	    utcDate(d) {
+	        if (0 <= d.y && d.y < 100) {
+	            const date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));
+	            date.setUTCFullYear(d.y);
+	            return date;
+	        }
+	        return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));
+	    }
+	    newDate(y, m, d) {
+	        return { y: y, m: m, d: d, H: 0, M: 0, S: 0, L: 0 };
+	    }
+	    formatRe(names) {
+	        return new RegExp('^(?:' + names.map(this.requoteF).join('|') + ')', 'i');
+	    }
+	    formatLookup(names) {
+	        return new Map(names.map((name, i) => [name.toLowerCase(), i]));
+	    }
+	    pad(value, fill, width) {
+	        const sign = value < 0 ? '-' : '';
+	        const string = (sign ? -value : value) + '';
+	        const length = string.length;
+	        return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
+	    }
+	    parseSpecifier(d, specifier, string, j) {
+	        let i = 0;
+	        const n = specifier.length;
+	        const m = string.length;
+	        let c;
+	        let parse;
+	        while (i < n) {
+	            if (j >= m) {
+	                return -1;
+	            }
+	            c = specifier.charCodeAt(i++);
+	            if (c === 37) {
+	                c = specifier.charAt(i++);
+	                parse = this.parses[c in this.pads ? specifier.charAt(i++) : c];
+	                if (!parse || (j = parse(d, string, j)) < 0) {
+	                    return -1;
+	                }
+	            }
+	            else if (c !== string.charCodeAt(j++)) {
+	                return -1;
+	            }
+	        }
+	        return j;
+	    }
+	    newParse(specifier, Z) {
+	        const that = this;
+	        return function (string) {
+	            const d = that.newDate(1900, undefined, 1);
+	            const i = that.parseSpecifier(d, specifier, (string += ''), 0);
+	            if (i !== string.length) {
+	                return null;
+	            }
+	            if ('Q' in d) {
+	                return new Date(d.Q);
+	            }
+	            if ('s' in d) {
+	                return new Date(d.s * 1000 + ('L' in d ? d.L : 0));
+	            }
+	            if (Z && !('Z' in d)) {
+	                d.Z = 0;
+	            }
+	            if ('p' in d) {
+	                d.H = (d.H % 12) + d.p * 12;
+	            }
+	            if (d.m === undefined) {
+	                d.m = 'q' in d ? d.q : 0;
+	            }
+	            if ('Z' in d) {
+	                d.H += (d.Z / 100) | 0;
+	                d.M += d.Z % 100;
+	                return that.utcDate(d);
+	            }
+	            return that.localDate(d);
+	        };
+	    }
+	    newFormat(specifier, formats) {
+	        const that = this;
+	        return function (date) {
+	            const string = [];
+	            let i = -1;
+	            let j = 0;
+	            const n = specifier.length;
+	            let c;
+	            let pad;
+	            let format;
+	            if (!(date instanceof Date)) {
+	                date = new Date(+date);
+	            }
+	            while (++i < n) {
+	                if (specifier.charCodeAt(i) === 37) {
+	                    string.push(specifier.slice(j, i));
+	                    if ((pad = that.pads[(c = specifier.charAt(++i))])) {
+	                        c = specifier.charAt(++i);
+	                    }
+	                    else {
+	                        pad = c === 'e' ? ' ' : '0';
+	                    }
+	                    format = formats[c];
+	                    c = format(date, pad);
+	                    string.push(c);
+	                    j = i + 1;
+	                }
+	            }
+	            string.push(specifier.slice(j, i));
+	            return string.join('');
+	        };
+	    }
+	    getFullTimeStamp(timeText) {
+	        const timeOriStamp = parseInt(timeText + '', 10);
+	        return String(timeOriStamp).length === 10 ? timeOriStamp * 1000 : timeOriStamp;
+	    }
+	}
+
+	function formatDecimal(x) {
+	    return Math.abs((x = Math.round(x))) >= 1e21 ? x.toLocaleString('en').replace(/,/g, '') : x.toString(10);
+	}
+	function formatDecimalParts(x, p) {
+	    const _x = p ? x.toExponential(p - 1) : x.toExponential();
+	    const i = _x.indexOf('e');
+	    if (i < 0) {
+	        return null;
+	    }
+	    const coefficient = _x.slice(0, i);
+	    return [coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient, +_x.slice(i + 1)];
+	}
+
+	function formatGroup(grouping, thousands) {
+	    return function (value, width) {
+	        let i = value.length;
+	        const t = [];
+	        let j = 0;
+	        let g = grouping[0];
+	        let length = 0;
+	        while (i > 0 && g > 0) {
+	            if (length + g + 1 > width) {
+	                g = Math.max(1, width - length);
+	            }
+	            t.push(value.substring((i -= g), i + g));
+	            if ((length += g + 1) > width) {
+	                break;
+	            }
+	            g = grouping[(j = (j + 1) % grouping.length)];
+	        }
+	        return t.reverse().join(thousands);
+	    };
+	}
+
+	let prefixExponent;
+	function formatPrefixAuto(x, p) {
+	    const d = formatDecimalParts(x, p);
+	    if (!d) {
+	        return x + '';
+	    }
+	    const coefficient = d[0];
+	    const exponent = d[1];
+	    const i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1;
+	    const n = coefficient.length;
+	    return i === n
+	        ? coefficient
+	        : i > n
+	            ? coefficient + new Array(i - n + 1).join('0')
+	            : i > 0
+	                ? coefficient.slice(0, i) + '.' + coefficient.slice(i)
+	                : '0.' + new Array(1 - i).join('0') + formatDecimalParts(x, Math.max(0, p + i - 1))[0];
+	}
+
+	function formatRounded(x, p) {
+	    const d = formatDecimalParts(x, p);
+	    if (!d) {
+	        return x + '';
+	    }
+	    const coefficient = d[0];
+	    const exponent = d[1];
+	    return exponent < 0
+	        ? '0.' + new Array(-exponent).join('0') + coefficient
+	        : coefficient.length > exponent + 1
+	            ? coefficient.slice(0, exponent + 1) + '.' + coefficient.slice(exponent + 1)
+	            : coefficient + new Array(exponent - coefficient.length + 2).join('0');
+	}
+
+	function formatTrim(s) {
+	    const n = s.length;
+	    let i0 = -1;
+	    let i1;
+	    out: for (let i = 1; i < n; ++i) {
+	        switch (s[i]) {
+	            case '.':
+	                i0 = i1 = i;
+	                break;
+	            case '0':
+	                if (i0 === 0) {
+	                    i0 = i;
+	                }
+	                i1 = i;
+	                break;
+	            default:
+	                if (!+s[i]) {
+	                    break out;
+	                }
+	                if (i0 > 0) {
+	                    i0 = 0;
+	                }
+	                break;
+	        }
+	    }
+	    return i0 > 0 ? s.slice(0, i0) + s.slice(i1 + 1) : s;
+	}
+
+	class FormatSpecifier {
+	    constructor(specifier = {}) {
+	        this.fill = specifier.fill === undefined ? ' ' : specifier.fill + '';
+	        this.align = specifier.align === undefined ? '>' : specifier.align + '';
+	        this.sign = specifier.sign === undefined ? '-' : specifier.sign + '';
+	        this.symbol = specifier.symbol === undefined ? '' : specifier.symbol + '';
+	        this.zero = !!specifier.zero;
+	        this.width = specifier.width === undefined ? undefined : +specifier.width;
+	        this.comma = !!specifier.comma;
+	        this.precision = specifier.precision === undefined ? undefined : +specifier.precision;
+	        this.trim = !!specifier.trim;
+	        this.type = specifier.type === undefined ? '' : specifier.type + '';
+	    }
+	    toString() {
+	        return (this.fill +
+	            this.align +
+	            this.sign +
+	            this.symbol +
+	            (this.zero ? '0' : '') +
+	            (this.width === undefined ? '' : Math.max(1, this.width | 0)) +
+	            (this.comma ? ',' : '') +
+	            (this.precision === undefined ? '' : '.' + Math.max(0, this.precision | 0)) +
+	            (this.trim ? '~' : '') +
+	            this.type);
+	    }
+	}
+	const numberSpecifierReg = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;
+	function formatSpecifier(specifier) {
+	    let match;
+	    if (!(match = numberSpecifierReg.exec(specifier))) {
+	        Logger.getInstance().error('invalid format: ' + specifier);
+	        return;
+	    }
+	    return new FormatSpecifier({
+	        fill: match[1],
+	        align: match[2],
+	        sign: match[3],
+	        symbol: match[4],
+	        zero: match[5],
+	        width: match[6],
+	        comma: match[7],
+	        precision: match[8] && match[8].slice(1),
+	        trim: match[9],
+	        type: match[10]
+	    });
+	}
+
+	const prefixes = ['y', 'z', 'a', 'f', 'p', 'n', 'µ', 'm', '', 'k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+	class NumberUtil {
+	    constructor() {
+	        this.locale = {
+	            thousands: ',',
+	            grouping: [3],
+	            currency: ['$', '']
+	        };
+	        this.group = this.locale.grouping === undefined || this.locale.thousands === undefined
+	            ? (group) => group
+	            : formatGroup([...this.locale.grouping].map(Number), `${this.locale.thousands}`);
+	        this.currencyPrefix = this.locale.currency === undefined ? '' : this.locale.currency[0] + '';
+	        this.currencySuffix = this.locale.currency === undefined ? '' : this.locale.currency[1] + '';
+	        this.decimal = this.locale.decimal === undefined ? '.' : this.locale.decimal + '';
+	        this.numerals = this.locale.numerals === undefined
+	            ? (numerals) => numerals
+	            : formatNumerals([...this.locale.numerals].map(String));
+	        this.percent = this.locale.percent === undefined ? '%' : this.locale.percent + '';
+	        this.minus = this.locale.minus === undefined ? '−' : this.locale.minus + '';
+	        this.nan = this.locale.nan === undefined ? 'NaN' : this.locale.nan + '';
+	        this.formatter = (specifier) => {
+	            return this.newFormat(specifier);
+	        };
+	        this.format = (specifier, value) => {
+	            return this.formatter(specifier)(value);
+	        };
+	        this.formatPrefix = (specifier, value) => {
+	            return this._formatPrefix(specifier, value);
+	        };
+	    }
+	    static getInstance() {
+	        if (!NumberUtil.instance) {
+	            NumberUtil.instance = new NumberUtil();
+	        }
+	        return NumberUtil.instance;
+	    }
+	    newFormat(specifier) {
+	        const specifierIns = formatSpecifier(specifier);
+	        let fill = specifierIns.fill;
+	        let align = specifierIns.align;
+	        const sign = specifierIns.sign;
+	        const symbol = specifierIns.symbol;
+	        let zero = specifierIns.zero;
+	        const width = specifierIns.width;
+	        let comma = specifierIns.comma;
+	        let precision = specifierIns.precision;
+	        let trim = specifierIns.trim;
+	        let type = specifierIns.type;
+	        if (type === 'n') {
+	            (comma = true), (type = 'g');
+	        }
+	        else if (!formatTypes[type]) {
+	            precision === undefined && (precision = 12), (trim = true), (type = 'g');
+	        }
+	        if (zero || (fill === '0' && align === '=')) {
+	            (zero = true), (fill = '0'), (align = '=');
+	        }
+	        const prefix = symbol === '$' ? this.currencyPrefix : symbol === '#' && /[boxX]/.test(type) ? '0' + type.toLowerCase() : '';
+	        const suffix = symbol === '$' ? this.currencySuffix : /[%p]/.test(type) ? this.percent : '';
+	        const formatType = formatTypes[type];
+	        const maybeSuffix = /[defgprstz%]/.test(type);
+	        precision =
+	            precision === undefined
+	                ? 6
+	                : /[gprs]/.test(type)
+	                    ? Math.max(1, Math.min(21, precision))
+	                    : Math.max(0, Math.min(20, precision));
+	        const { nan, minus, decimal, group, numerals } = this;
+	        function format(value) {
+	            let valuePrefix = prefix;
+	            let valueSuffix = suffix;
+	            let i;
+	            let n;
+	            let c;
+	            let _value = value;
+	            if (type === 'c') {
+	                valueSuffix = formatType(_value) + valueSuffix;
+	                _value = '';
+	            }
+	            else {
+	                _value = +_value;
+	                let valueNegative = _value < 0 || 1 / _value < 0;
+	                _value = isNaN(_value) ? nan : formatType(Math.abs(_value), precision);
+	                if (trim) {
+	                    _value = formatTrim(_value);
+	                }
+	                if (valueNegative && +_value === 0 && sign !== '+') {
+	                    valueNegative = false;
+	                }
+	                valuePrefix =
+	                    (valueNegative ? (sign === '(' ? sign : minus) : sign === '-' || sign === '(' ? '' : sign) + valuePrefix;
+	                valueSuffix =
+	                    (type === 's' ? prefixes[8 + prefixExponent / 3] : '') +
+	                        valueSuffix +
+	                        (valueNegative && sign === '(' ? ')' : '');
+	                if (maybeSuffix) {
+	                    (i = -1), (n = _value.length);
+	                    while (++i < n) {
+	                        if (((c = _value.charCodeAt(i)), 48 > c || c > 57)) {
+	                            valueSuffix = (c === 46 ? decimal + _value.slice(i + 1) : _value.slice(i)) + valueSuffix;
+	                            _value = _value.slice(0, i);
+	                            break;
+	                        }
+	                    }
+	                }
+	            }
+	            if (comma && !zero) {
+	                _value = group(_value, Infinity);
+	            }
+	            let length = valuePrefix.length + _value.length + valueSuffix.length;
+	            let padding = length < width ? new Array(width - length + 1).join(fill) : '';
+	            if (comma && zero) {
+	                _value = group(padding + _value, padding.length ? width - valueSuffix.length : Infinity);
+	                padding = '';
+	            }
+	            switch (align) {
+	                case '<':
+	                    _value = valuePrefix + _value + valueSuffix + padding;
+	                    break;
+	                case '=':
+	                    _value = valuePrefix + padding + _value + valueSuffix;
+	                    break;
+	                case '^':
+	                    _value =
+	                        padding.slice(0, (length = padding.length >> 1)) +
+	                            valuePrefix +
+	                            _value +
+	                            valueSuffix +
+	                            padding.slice(length);
+	                    break;
+	                default:
+	                    _value = padding + valuePrefix + _value + valueSuffix;
+	                    break;
+	            }
+	            return numerals(_value);
+	        }
+	        format.toString = function () {
+	            return specifier + '';
+	        };
+	        return format;
+	    }
+	    _formatPrefix(specifier, value) {
+	        const _specifier = formatSpecifier(specifier);
+	        _specifier.type = 'f';
+	        const f = this.newFormat(_specifier.toString());
+	        const e = Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3;
+	        const k = Math.pow(10, -e);
+	        const prefix = prefixes[8 + e / 3];
+	        return function (value) {
+	            return f(k * value) + prefix;
+	        };
+	    }
+	}
+	const formatTypes = {
+	    '%': (x, p) => (x * 100).toFixed(p),
+	    b: (x) => Math.round(x).toString(2),
+	    c: (x) => x + '',
+	    d: formatDecimal,
+	    f: (x, p) => x.toFixed(p),
+	    e: (x, p) => x.toExponential(p),
+	    g: (x, p) => x.toPrecision(p),
+	    o: (x) => Math.round(x).toString(8),
+	    p: (x, p) => formatRounded(x * 100, p),
+	    r: formatRounded,
+	    s: formatPrefixAuto,
+	    X: (x) => Math.round(x).toString(16).toUpperCase(),
+	    x: (x) => Math.round(x).toString(16),
+	    t: (x, p) => {
+	        if (Number.isInteger(x)) {
+	            return x.toFixed(2);
+	        }
+	        return Math.floor(x * Math.pow(10, p)) / Math.pow(10, p) + '';
+	    },
+	    z: (x, p) => (x % 1 === 0 ? x + '' : x.toFixed(p))
+	};
+	function exponent(x) {
+	    const _x = formatDecimalParts(Math.abs(x));
+	    return _x ? _x[1] : NaN;
+	}
+	function formatNumerals(numerals) {
+	    return function (value) {
+	        return value.replace(/[0-9]/g, (i) => numerals[+i]);
+	    };
+	}
+
 	exports.AABBBounds = AABBBounds;
 	exports.Bounds = Bounds;
 	exports.Color = Color;
@@ -4791,6 +5469,7 @@
 	exports.DAY = DAY;
 	exports.DEFAULT_COLORS = DEFAULT_COLORS;
 	exports.EventEmitter = index$1;
+	exports.FormatSpecifier = FormatSpecifier;
 	exports.GraphicUtil = GraphicUtil;
 	exports.HOUR = HOUR;
 	exports.HashTable = HashTable;
@@ -4802,6 +5481,7 @@
 	exports.Matrix = Matrix;
 	exports.NEWTON_ITERATIONS = NEWTON_ITERATIONS;
 	exports.NEWTON_MIN_SLOPE = NEWTON_MIN_SLOPE;
+	exports.NumberUtil = NumberUtil;
 	exports.OBBBounds = OBBBounds;
 	exports.Point = Point;
 	exports.PointService = PointService;
@@ -4811,6 +5491,7 @@
 	exports.SUBDIVISION_MAX_ITERATIONS = SUBDIVISION_MAX_ITERATIONS;
 	exports.SUBDIVISION_PRECISION = SUBDIVISION_PRECISION;
 	exports.TextMeasure = TextMeasure;
+	exports.TimeUtil = TimeUtil;
 	exports.YEAR = YEAR;
 	exports.abs = abs;
 	exports.acos = acos;
@@ -4846,8 +5527,12 @@
 	exports.deviation = deviation;
 	exports.eastAsianCharacterInfo = eastAsianCharacterInfo;
 	exports.epsilon = epsilon;
+	exports.exponent = exponent;
 	exports.fixPrecision = fixPrecision;
 	exports.flattenArray = flattenArray;
+	exports.formatNumerals = formatNumerals;
+	exports.formatSpecifier = formatSpecifier;
+	exports.formatTypes = formatTypes;
 	exports.fullYearGetterName = fullYearGetterName;
 	exports.fullYearSetterName = fullYearSetterName;
 	exports.fuzzyEqualNumber = fuzzyEqualNumber;
@@ -4954,6 +5639,7 @@
 	exports.monthSetterName = monthSetterName;
 	exports.normalTransform = normalTransform;
 	exports.normalizePadding = normalizePadding;
+	exports.numberSpecifierReg = numberSpecifierReg;
 	exports.pad = pad;
 	exports.parseUint8ToImageData = parseUint8ToImageData;
 	exports.pi = pi;