@visactor/vutils 0.18.0-alpha.0 → 0.18.0-alpha.2

package/dist/index.js

@@ -1465,6 +1465,153 @@
 	    });
 	}
 
+	class HashValue {
+	}
+	class HashTable {
+	    constructor() {
+	        this.items = {};
+	        this.itemList = [];
+	    }
+	    get type() {
+	        return 'xhHashTable';
+	    }
+	    set(key, value) {
+	        const vl = new HashValue();
+	        vl.key = key;
+	        vl.value = value;
+	        let index = this.itemList.length;
+	        if (this.has(key)) {
+	            index = this.items[key].index;
+	        }
+	        vl.index = index;
+	        this.itemList[index] = vl;
+	        this.items[key] = vl;
+	        return vl;
+	    }
+	    clear() {
+	        this.items = {};
+	        this.itemList = [];
+	    }
+	    del(key) {
+	        if (this.has(key)) {
+	            const index = this.items[key].index;
+	            if (index > -1) {
+	                this.itemList.splice(index, 1);
+	            }
+	            delete this.items[key];
+	            this.resetIndex();
+	        }
+	    }
+	    delFrom(index) {
+	        for (let i = index + 1; i < this.count(); i++) {
+	            const key = this.itemList[i].key;
+	            delete this.items[key];
+	        }
+	        this.itemList.splice(index + 1, this.count() - index);
+	        this.resetIndex();
+	    }
+	    resetIndex() {
+	        this.foreachHashv((k, v) => {
+	            const index = this.itemList.indexOf(v);
+	            this.items[k].index = index;
+	        });
+	    }
+	    has(key) {
+	        return key in this.items;
+	    }
+	    get(key) {
+	        if (this.has(key)) {
+	            return this.items[key].value;
+	        }
+	        return null;
+	    }
+	    count() {
+	        return this.itemList.length;
+	    }
+	    all() {
+	        return this.itemList.map(vl => {
+	            return vl.value;
+	        });
+	    }
+	    first() {
+	        return this.itemList[0].value;
+	    }
+	    last() {
+	        return this.itemList[this.itemList.length - 1].value;
+	    }
+	    getByIndex(index) {
+	        return this.itemList[index].value;
+	    }
+	    getKeyByIndex(index) {
+	        return this.itemList[index].key;
+	    }
+	    foreach(callback) {
+	        for (const key in this.items) {
+	            const returnVal = callback(key, this.items[key].value);
+	            if (returnVal === false) {
+	                return false;
+	            }
+	        }
+	        return true;
+	    }
+	    foreachHashv(callback) {
+	        for (const key in this.items) {
+	            const returnVal = callback(key, this.items[key]);
+	            if (returnVal === false) {
+	                return false;
+	            }
+	        }
+	        return true;
+	    }
+	    hasValue(value) {
+	        for (const key in this.items) {
+	            if (this.items[key].value === value) {
+	                return true;
+	            }
+	        }
+	        return false;
+	    }
+	    indexOf(key) {
+	        if (this.has(key)) {
+	            return this.items[key].index;
+	        }
+	        return -1;
+	    }
+	    insertAt(index, value, key) {
+	        const hashV = new HashValue();
+	        hashV.index = index;
+	        hashV.key = key;
+	        hashV.value = value;
+	        this.itemList.splice(index, 0, hashV);
+	        this.items[key] = hashV;
+	        this.resetIndex();
+	    }
+	    sort(callback) {
+	        return this.itemList.sort((a, b) => {
+	            return callback(a.value, b.value);
+	        });
+	    }
+	    toArray() {
+	        return this.itemList.slice(0, this.itemList.length).map(vl => {
+	            return vl.value;
+	        });
+	    }
+	    push(lists) {
+	        lists.foreach((key, value) => {
+	            this.set(key, value);
+	        });
+	    }
+	    mapKey() {
+	        const returnArr = [];
+	        for (const key in this.items) {
+	            returnArr.push(key);
+	        }
+	        return returnArr;
+	    }
+	    toImmutableMap() {
+	    }
+	}
+
 	const epsilon = 1e-12;
 	const pi = Math.PI;
 	const halfPi = pi / 2;
@@ -1598,13 +1745,13 @@
 	    static distanceNN(x, y, x1, y1) {
 	        return sqrt(pow(x - x1, 2) + pow(y - y1, 2));
 	    }
+	    static distancePN(point, x, y) {
+	        return sqrt(pow(x - point.x, 2) + pow(y - point.y, 2));
+	    }
 	    static pointAtPP(p1, p2, t) {
 	        return new Point((p2.x - p1.x) * t + p1.x, (p2.y - p1.y) * t + p1.y);
 	    }
 	}
-	function pointAtPP(p1, p2, t) {
-	    return new Point((p2.x - p1.x) * t + p1.x, (p2.y - p1.y) * t + p1.y);
-	}
 	class PolarPoint {
 	    constructor(r = 0, theta = 0, r1, theta1) {
 	        this.r = 0;
@@ -2155,9 +2302,113 @@
 	    out.f = of + ob * rotateCenterX + od * rotateCenterY - b1 * offsetX - d1 * offsetY;
 	}
 
-	function hex(value) {
-	    value = Math.max(0, Math.min(255, Math.round(value) || 0));
-	    return (value < 16 ? '0' : '') + value.toString(16);
+	class LRU {
+	    constructor() {
+	        this.CLEAN_THRESHOLD = 1e3;
+	        this.L_TIME = 1000;
+	        this.R_COUNT = 1;
+	        this.R_TIMESTAMP_MAX_SIZE = 20;
+	    }
+	    clearCache(cache, params) {
+	        const { CLEAN_THRESHOLD = this.CLEAN_THRESHOLD, L_TIME = this.L_TIME, R_COUNT = this.R_COUNT } = params;
+	        if (cache.size < CLEAN_THRESHOLD) {
+	            return 0;
+	        }
+	        let clearNum = 0;
+	        const clear = (key) => {
+	            clearNum++;
+	            cache.delete(key);
+	        };
+	        const now = Date.now();
+	        cache.forEach((item, key) => {
+	            if (item.timestamp.length < R_COUNT) {
+	                return clear(key);
+	            }
+	            let useCount = 0;
+	            while (now - item.timestamp[item.timestamp.length - 1 - useCount] < L_TIME) {
+	                useCount++;
+	                if (useCount >= R_COUNT) {
+	                    break;
+	                }
+	            }
+	            if (useCount < R_COUNT) {
+	                return clear(key);
+	            }
+	            while (now - item.timestamp[0] > L_TIME) {
+	                item.timestamp.shift();
+	            }
+	            return;
+	        });
+	        return clearNum;
+	    }
+	    addLimitedTimestamp(cacheItem, t, params) {
+	        const { R_TIMESTAMP_MAX_SIZE = this.R_TIMESTAMP_MAX_SIZE } = params;
+	        if (cacheItem.timestamp.length > R_TIMESTAMP_MAX_SIZE) {
+	            cacheItem.timestamp.shift();
+	        }
+	        cacheItem.timestamp.push(t);
+	    }
+	    clearTimeStamp(cache, params) {
+	        const { L_TIME = this.L_TIME } = params;
+	        const now = Date.now();
+	        cache.forEach(item => {
+	            while (now - item.timestamp[0] > L_TIME) {
+	                item.timestamp.shift();
+	            }
+	        });
+	    }
+	    clearItemTimestamp(cacheItem, params) {
+	        const { L_TIME = this.L_TIME } = params;
+	        const now = Date.now();
+	        while (now - cacheItem.timestamp[0] > L_TIME) {
+	            cacheItem.timestamp.shift();
+	        }
+	    }
+	}
+
+	function hslToRgb(h, s, l) {
+	    s /= 100;
+	    l /= 100;
+	    const c = (1 - Math.abs(2 * l - 1)) * s;
+	    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+	    const m = l - c / 2;
+	    let r = 0;
+	    let g = 0;
+	    let b = 0;
+	    if (0 <= h && h < 60) {
+	        r = c;
+	        g = x;
+	        b = 0;
+	    }
+	    else if (60 <= h && h < 120) {
+	        r = x;
+	        g = c;
+	        b = 0;
+	    }
+	    else if (120 <= h && h < 180) {
+	        r = 0;
+	        g = c;
+	        b = x;
+	    }
+	    else if (180 <= h && h < 240) {
+	        r = 0;
+	        g = x;
+	        b = c;
+	    }
+	    else if (240 <= h && h < 300) {
+	        r = x;
+	        g = 0;
+	        b = c;
+	    }
+	    else if (300 <= h && h < 360) {
+	        r = c;
+	        g = 0;
+	        b = x;
+	    }
+	    r = Math.round((r + m) * 255);
+	    g = Math.round((g + m) * 255);
+	    b = Math.round((b + m) * 255);
+	    return { r, g, b };
 	}
 
 	function rgbToHsl(r, g, b) {
@@ -2197,35 +2448,10 @@
 	    };
 	}
 
-	class RGB {
-	    constructor(r, g, b, opacity) {
-	        this.r = isNaN(+r) ? 255 : Math.max(0, Math.min(255, +r));
-	        this.g = isNaN(+g) ? 255 : Math.max(0, Math.min(255, +g));
-	        this.b = isNaN(+b) ? 255 : Math.max(0, Math.min(255, +b));
-	        if (isValid(opacity)) {
-	            this.opacity = isNaN(+opacity) ? 1 : Math.max(0, Math.min(1, +opacity));
-	        }
-	        else {
-	            this.opacity = 1;
-	        }
-	    }
-	    formatHex() {
-	        return `#${hex(this.r) + hex(this.g) + hex(this.b) + (this.opacity === 1 ? '' : hex(this.opacity * 255))}`;
-	    }
-	    formatRgb() {
-	        const opacity = this.opacity;
-	        return `${opacity === 1 ? 'rgb(' : 'rgba('}${this.r},${this.g},${this.b}${opacity === 1 ? ')' : `,${opacity})`}`;
-	    }
-	    formatHsl() {
-	        const opacity = this.opacity;
-	        const { h, s, l } = rgbToHsl(this.r, this.g, this.b);
-	        return `${opacity === 1 ? 'hsl(' : 'hsla('}${h},${s}%,${l}%${opacity === 1 ? ')' : `,${opacity})`}`;
-	    }
-	    toString() {
-	        return this.formatHex();
-	    }
-	}
-
+	const REG_HEX = /^#([0-9a-f]{3,8})$/;
+	const DEFAULT_COLORS_OPACITY = {
+	    transparent: 0xffffff00
+	};
 	const DEFAULT_COLORS = {
 	    aliceblue: 0xf0f8ff,
 	    antiquewhite: 0xfaebd7,
@@ -2376,52 +2602,10 @@
 	    yellow: 0xffff00,
 	    yellowgreen: 0x9acd32
 	};
-
-	function hslToRgb(h, s, l) {
-	    s /= 100;
-	    l /= 100;
-	    const c = (1 - Math.abs(2 * l - 1)) * s;
-	    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
-	    const m = l - c / 2;
-	    let r = 0;
-	    let g = 0;
-	    let b = 0;
-	    if (0 <= h && h < 60) {
-	        r = c;
-	        g = x;
-	        b = 0;
-	    }
-	    else if (60 <= h && h < 120) {
-	        r = x;
-	        g = c;
-	        b = 0;
-	    }
-	    else if (120 <= h && h < 180) {
-	        r = 0;
-	        g = c;
-	        b = x;
-	    }
-	    else if (180 <= h && h < 240) {
-	        r = 0;
-	        g = x;
-	        b = c;
-	    }
-	    else if (240 <= h && h < 300) {
-	        r = x;
-	        g = 0;
-	        b = c;
-	    }
-	    else if (300 <= h && h < 360) {
-	        r = c;
-	        g = 0;
-	        b = x;
-	    }
-	    r = Math.round((r + m) * 255);
-	    g = Math.round((g + m) * 255);
-	    b = Math.round((b + m) * 255);
-	    return { r, g, b };
+	function hex(value) {
+	    value = Math.max(0, Math.min(255, Math.round(value) || 0));
+	    return (value < 16 ? '0' : '') + value.toString(16);
 	}
-
 	function rgb(value) {
 	    if (isNumber(value)) {
 	        return new RGB(value >> 16, (value >> 8) & 0xff, value & 0xff, 1);
@@ -2440,46 +2624,6 @@
 	    }
 	    return new RGB(255, 255, 255, 1);
 	}
-
-	const DEFAULT_COLORS_OPACITY = {
-	    transparent: 0xffffff00
-	};
-	const REG_HEX = /^#([0-9a-f]{3,8})$/;
-	function parseColorString(color) {
-	    if (isValid(DEFAULT_COLORS_OPACITY[color])) {
-	        return rgba(DEFAULT_COLORS_OPACITY[color]);
-	    }
-	    if (isValid(DEFAULT_COLORS[color])) {
-	        return rgb(DEFAULT_COLORS[color]);
-	    }
-	    const formatValue = `${color}`.trim().toLowerCase();
-	    const isHex = REG_HEX.exec(formatValue);
-	    if (isHex) {
-	        const hex = parseInt(isHex[1], 16);
-	        const hexLength = isHex[1].length;
-	        if (hexLength === 3) {
-	            return new RGB(((hex >> 8) & 0xf) + (((hex >> 8) & 0xf) << 4), ((hex >> 4) & 0xf) + (((hex >> 4) & 0xf) << 4), (hex & 0xf) + ((hex & 0xf) << 4), 1);
-	        }
-	        if (hexLength === 6) {
-	            return rgb(hex);
-	        }
-	        else if (hexLength === 8) {
-	            return new RGB((hex >> 24) & 0xff, (hex >> 16) & 0xff, (hex >> 8) & 0xff, (hex & 0xff) / 0xff);
-	        }
-	        return;
-	    }
-	    if (/^(rgb|RGB|rgba|RGBA)/.test(formatValue)) {
-	        const aColor = formatValue.replace(/(?:\(|\)|rgba|RGBA|rgb|RGB)*/g, '').split(',');
-	        return new RGB(parseInt(aColor[0], 10), parseInt(aColor[1], 10), parseInt(aColor[2], 10), parseFloat(aColor[3]));
-	    }
-	    if (/^(hsl|HSL|hsla|HSLA)/.test(formatValue)) {
-	        const aColor = formatValue.replace(/(?:\(|\)|hsla|HSLA|hsl|HSL)*/g, '').split(',');
-	        const rgb = hslToRgb(parseInt(aColor[0], 10), parseInt(aColor[1], 10), parseInt(aColor[2], 10));
-	        return new RGB(rgb.r, rgb.g, rgb.b, parseFloat(aColor[3]));
-	    }
-	    return;
-	}
-
 	function SRGBToLinear(c) {
 	    return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
 	}
@@ -2516,8 +2660,42 @@
 	                return color.getHSVBrightness();
 	        }
 	    }
+	    static parseColorString(value) {
+	        if (isValid(DEFAULT_COLORS_OPACITY[value])) {
+	            return rgba(DEFAULT_COLORS_OPACITY[value]);
+	        }
+	        if (isValid(DEFAULT_COLORS[value])) {
+	            return rgb(DEFAULT_COLORS[value]);
+	        }
+	        const formatValue = `${value}`.trim().toLowerCase();
+	        const isHex = REG_HEX.exec(formatValue);
+	        if (isHex) {
+	            const hex = parseInt(isHex[1], 16);
+	            const hexLength = isHex[1].length;
+	            if (hexLength === 3) {
+	                return new RGB(((hex >> 8) & 0xf) + (((hex >> 8) & 0xf) << 4), ((hex >> 4) & 0xf) + (((hex >> 4) & 0xf) << 4), (hex & 0xf) + ((hex & 0xf) << 4), 1);
+	            }
+	            if (hexLength === 6) {
+	                return rgb(hex);
+	            }
+	            else if (hexLength === 8) {
+	                return new RGB((hex >> 24) & 0xff, (hex >> 16) & 0xff, (hex >> 8) & 0xff, (hex & 0xff) / 0xff);
+	            }
+	            return;
+	        }
+	        if (/^(rgb|RGB|rgba|RGBA)/.test(formatValue)) {
+	            const aColor = formatValue.replace(/(?:\(|\)|rgba|RGBA|rgb|RGB)*/g, '').split(',');
+	            return new RGB(parseInt(aColor[0], 10), parseInt(aColor[1], 10), parseInt(aColor[2], 10), parseFloat(aColor[3]));
+	        }
+	        if (/^(hsl|HSL|hsla|HSLA)/.test(formatValue)) {
+	            const aColor = formatValue.replace(/(?:\(|\)|hsla|HSLA|hsl|HSL)*/g, '').split(',');
+	            const rgb = hslToRgb(parseInt(aColor[0], 10), parseInt(aColor[1], 10), parseInt(aColor[2], 10));
+	            return new RGB(rgb.r, rgb.g, rgb.b, parseFloat(aColor[3]));
+	        }
+	        return;
+	    }
 	    constructor(value) {
-	        const color = parseColorString(value);
+	        const color = Color.parseColorString(value);
 	        if (color) {
 	            this.color = color;
 	        }
@@ -2676,6 +2854,34 @@
 	        return this;
 	    }
 	}
+	class RGB {
+	    constructor(r, g, b, opacity) {
+	        this.r = isNaN(+r) ? 255 : Math.max(0, Math.min(255, +r));
+	        this.g = isNaN(+g) ? 255 : Math.max(0, Math.min(255, +g));
+	        this.b = isNaN(+b) ? 255 : Math.max(0, Math.min(255, +b));
+	        if (isValid(opacity)) {
+	            this.opacity = isNaN(+opacity) ? 1 : Math.max(0, Math.min(1, +opacity));
+	        }
+	        else {
+	            this.opacity = 1;
+	        }
+	    }
+	    formatHex() {
+	        return `#${hex(this.r) + hex(this.g) + hex(this.b) + (this.opacity === 1 ? '' : hex(this.opacity * 255))}`;
+	    }
+	    formatRgb() {
+	        const opacity = this.opacity;
+	        return `${opacity === 1 ? 'rgb(' : 'rgba('}${this.r},${this.g},${this.b}${opacity === 1 ? ')' : `,${opacity})`}`;
+	    }
+	    formatHsl() {
+	        const opacity = this.opacity;
+	        const { h, s, l } = rgbToHsl(this.r, this.g, this.b);
+	        return `${opacity === 1 ? 'hsl(' : 'hsla('}${h},${s}%,${l}%${opacity === 1 ? ')' : `,${opacity})`}`;
+	    }
+	    toString() {
+	        return this.formatHex();
+	    }
+	}
 
 	function hexToRgb(str) {
 	    let r = '';
@@ -2730,12 +2936,10 @@
 		__proto__: null,
 		Color: Color,
 		DEFAULT_COLORS: DEFAULT_COLORS,
-		REG_HEX: REG_HEX,
 		RGB: RGB,
 		hexToRgb: hexToRgb,
 		hslToRgb: hslToRgb,
 		interpolateRgb: interpolateRgb,
-		parseColorString: parseColorString,
 		rgbToHex: rgbToHex,
 		rgbToHsl: rgbToHsl
 	});
@@ -3139,6 +3343,124 @@
 	    return nextList;
 	}
 
+	let dirX;
+	let dirY;
+	let normalX;
+	let normalY;
+	let len;
+	let lineWidthDiv2;
+	let width;
+	let height;
+	function getOBBFromLine(point1, point2, lineWidth) {
+	    dirX = point2.x - point1.x;
+	    dirY = point2.y - point1.y;
+	    (normalX = dirY), (normalY = -dirX);
+	    width = len = Math.sqrt(normalX * normalX + normalY * normalY);
+	    height = lineWidth;
+	    normalX /= len;
+	    normalY /= len;
+	    lineWidthDiv2 = lineWidth / 2;
+	    dirX = lineWidthDiv2 * normalX;
+	    dirY = lineWidthDiv2 * normalY;
+	    const point11 = { x: point1.x + dirX, y: point1.y + dirY };
+	    const point12 = { x: point1.x - dirX, y: point1.y - dirY };
+	    const point13 = { x: point2.x + dirX, y: point2.y + dirY };
+	    const point14 = { x: point2.x - dirX, y: point2.y - dirY };
+	    return {
+	        point1: point11,
+	        point2: point12,
+	        point3: point13,
+	        point4: point14,
+	        width,
+	        height,
+	        left: Math.min(point1.x, point2.x) - Math.abs(dirX),
+	        top: Math.min(point1.y, point2.y) - Math.abs(dirY)
+	    };
+	}
+	const point1 = { x: 0, y: 0 };
+	const point2 = { x: 0, y: 0 };
+	function pointInOBB(point, obb) {
+	    point1.x = (obb.point1.x + obb.point2.x) / 2;
+	    point1.y = (obb.point1.y + obb.point2.y) / 2;
+	    point2.x = (obb.point3.x + obb.point4.x) / 2;
+	    point2.y = (obb.point3.y + obb.point4.y) / 2;
+	    return pointInLine(point, point1, point2, obb.height);
+	}
+	function pointInLine(point, point1, point2, lineWidth) {
+	    return lengthFromPointToLine(point, point1, point2) <= lineWidth / 2 && pointBetweenLine(point, point1, point2);
+	}
+	const dir1 = { x: 0, y: 0 };
+	const dir2 = { x: 0, y: 0 };
+	const normal = { x: 0, y: 0 };
+	function pointBetweenLine(point, point1, point2) {
+	    dir1.x = point1.x - point.x;
+	    dir1.y = point1.y - point.y;
+	    dir2.x = point2.x - point.x;
+	    dir2.y = point2.y - point.y;
+	    normal.x = point1.y - point2.y;
+	    normal.y = point2.x - point1.x;
+	    return crossProductPoint(dir1, normal) * crossProductPoint(dir2, normal) < 0;
+	}
+
+	function getContextFont$1({ fontStyle, fontVariant, fontWeight, fontSize, fontFamily }) {
+	    return ('' +
+	        (fontStyle ? fontStyle + ' ' : '') +
+	        (fontVariant ? fontVariant + ' ' : '') +
+	        (fontWeight ? fontWeight + ' ' : '') +
+	        (fontSize || 12) +
+	        'px ' +
+	        (fontFamily ? fontFamily : 'sans-serif'));
+	}
+	class GraphicUtil {
+	    constructor(canvas) {
+	        this.canvas = canvas;
+	        if (canvas) {
+	            this.ctx = canvas.getContext('2d');
+	        }
+	    }
+	    setCanvas(canvas) {
+	        this.canvas = canvas;
+	        if (canvas) {
+	            this.ctx = canvas.getContext('2d');
+	        }
+	    }
+	    measureText(tc) {
+	        if (!this.canvas) {
+	            console.warn('[warn] no canvas, measureText might be not accurate');
+	            return this.estimate(tc);
+	        }
+	        return this.measureTextByCanvas(tc);
+	    }
+	    measureTextByCanvas(tc) {
+	        if (!this.ctx) {
+	            console.error('[error!!!]measureTextByCanvas can not be called without canvas');
+	            return { width: -1, height: tc.fontSize };
+	        }
+	        this.ctx.font = getContextFont$1(tc);
+	        return {
+	            width: this.ctx.measureText(tc.text).width,
+	            height: tc.fontSize
+	        };
+	    }
+	    estimate({ text, fontSize }) {
+	        let eCharLen = 0;
+	        let cCharLen = 0;
+	        for (let i = 0; i < text.length; i++) {
+	            text.charCodeAt(i) < 128 ? eCharLen++ : cCharLen++;
+	        }
+	        return {
+	            width: ~~(0.8 * eCharLen * fontSize + cCharLen * fontSize),
+	            height: fontSize
+	        };
+	    }
+	    static getDefaultUtils(canvas) {
+	        if (!GraphicUtil.instance) {
+	            GraphicUtil.instance = new GraphicUtil(canvas);
+	        }
+	        return GraphicUtil.instance;
+	    }
+	}
+
 	const EPSILON = 1e-8;
 	function lineIntersectPolygon(a1x, a1y, a2x, a2y, points) {
 	    for (let i = 0, p2 = points[points.length - 1]; i < points.length; i++) {
@@ -3543,6 +3865,7 @@
 	            if (isNil(this._canvas) &&
 	                typeof window !== 'undefined' &&
 	                typeof window.document !== 'undefined' &&
+	                globalThis &&
 	                isValid(globalThis.document)) {
 	                this._canvas = globalThis.document.createElement('canvas');
 	            }
@@ -3757,16 +4080,6 @@
 	TextMeasure.NUMBERS_CHAR_SET = '0123456789';
 	TextMeasure.FULL_SIZE_CHAR = '字';
 
-	function distancePP(p1, p2) {
-	    return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
-	}
-	function distanceNN(x, y, x1, y1) {
-	    return sqrt(pow(x - x1, 2) + pow(y - y1, 2));
-	}
-	function distancePN(point, x, y) {
-	    return sqrt(pow(x - point.x, 2) + pow(y - point.y, 2));
-	}
-
 	const hasConsole = typeof console !== 'undefined';
 	function log(method, level, input) {
 	    const args = [level].concat([].slice.call(input));
@@ -4471,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;
@@ -4478,23 +5469,29 @@
 	exports.DAY = DAY;
 	exports.DEFAULT_COLORS = DEFAULT_COLORS;
 	exports.EventEmitter = index$1;
+	exports.FormatSpecifier = FormatSpecifier;
+	exports.GraphicUtil = GraphicUtil;
 	exports.HOUR = HOUR;
+	exports.HashTable = HashTable;
+	exports.HashValue = HashValue;
+	exports.LRU = LRU;
 	exports.Logger = Logger;
 	exports.MINUTE = MINUTE;
 	exports.MONTH = MONTH;
 	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;
 	exports.PolarPoint = PolarPoint;
-	exports.REG_HEX = REG_HEX;
 	exports.RGB = RGB;
 	exports.SECOND = SECOND;
 	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;
@@ -4528,13 +5525,14 @@
 	exports.degreeToRadian = degreeToRadian;
 	exports.destination = destination;
 	exports.deviation = deviation;
-	exports.distanceNN = distanceNN;
-	exports.distancePN = distancePN;
-	exports.distancePP = distancePP;
 	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;
@@ -4553,6 +5551,7 @@
 	exports.getFormatFromValue = getFormatFromValue;
 	exports.getIntersectPoint = getIntersectPoint;
 	exports.getIntervalOptions = getIntervalOptions;
+	exports.getOBBFromLine = getOBBFromLine;
 	exports.getRectIntersect = getRectIntersect;
 	exports.getScale = getScale;
 	exports.getScaleX = getScaleX;
@@ -4640,16 +5639,18 @@
 	exports.monthSetterName = monthSetterName;
 	exports.normalTransform = normalTransform;
 	exports.normalizePadding = normalizePadding;
+	exports.numberSpecifierReg = numberSpecifierReg;
 	exports.pad = pad;
-	exports.parseColorString = parseColorString;
 	exports.parseUint8ToImageData = parseUint8ToImageData;
 	exports.pi = pi;
 	exports.pi2 = pi2;
 	exports.pick = pick;
 	exports.pickWithout = pickWithout;
 	exports.pointAt = pointAt;
-	exports.pointAtPP = pointAtPP;
+	exports.pointBetweenLine = pointBetweenLine;
 	exports.pointInAABB = pointInAABB;
+	exports.pointInLine = pointInLine;
+	exports.pointInOBB = pointInOBB;
 	exports.pointInRect = pointInRect;
 	exports.polarToCartesian = polarToCartesian;
 	exports.polygonContainPoint = polygonContainPoint;