@visactor/vutils 0.17.2 → 0.18.0-alpha.0

package/dist/index.js

@@ -1465,153 +1465,6 @@
 	    });
 	}
 
-	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;
@@ -1745,13 +1598,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;
@@ -2302,113 +2155,9 @@
 	    out.f = of + ob * rotateCenterX + od * rotateCenterY - b1 * offsetX - d1 * offsetY;
 	}
 
-	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 hex(value) {
+	    value = Math.max(0, Math.min(255, Math.round(value) || 0));
+	    return (value < 16 ? '0' : '') + value.toString(16);
 	}
 
 	function rgbToHsl(r, g, b) {
@@ -2448,10 +2197,35 @@
 	    };
 	}
 
-	const REG_HEX = /^#([0-9a-f]{3,8})$/;
-	const DEFAULT_COLORS_OPACITY = {
-	    transparent: 0xffffff00
-	};
+	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 DEFAULT_COLORS = {
 	    aliceblue: 0xf0f8ff,
 	    antiquewhite: 0xfaebd7,
@@ -2602,10 +2376,52 @@
 	    yellow: 0xffff00,
 	    yellowgreen: 0x9acd32
 	};
-	function hex(value) {
-	    value = Math.max(0, Math.min(255, Math.round(value) || 0));
-	    return (value < 16 ? '0' : '') + value.toString(16);
+
+	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 rgb(value) {
 	    if (isNumber(value)) {
 	        return new RGB(value >> 16, (value >> 8) & 0xff, value & 0xff, 1);
@@ -2624,6 +2440,46 @@
 	    }
 	    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);
 	}
@@ -2660,42 +2516,8 @@
 	                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 = Color.parseColorString(value);
+	        const color = parseColorString(value);
 	        if (color) {
 	            this.color = color;
 	        }
@@ -2854,34 +2676,6 @@
 	        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 = '';
@@ -2936,10 +2730,12 @@
 		__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
 	});
@@ -3343,124 +3139,6 @@
 	    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++) {
@@ -3865,7 +3543,6 @@
 	            if (isNil(this._canvas) &&
 	                typeof window !== 'undefined' &&
 	                typeof window.document !== 'undefined' &&
-	                globalThis &&
 	                isValid(globalThis.document)) {
 	                this._canvas = globalThis.document.createElement('canvas');
 	            }
@@ -4080,6 +3757,16 @@
 	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));
@@ -4791,11 +4478,7 @@
 	exports.DAY = DAY;
 	exports.DEFAULT_COLORS = DEFAULT_COLORS;
 	exports.EventEmitter = index$1;
-	exports.GraphicUtil = GraphicUtil;
 	exports.HOUR = HOUR;
-	exports.HashTable = HashTable;
-	exports.HashValue = HashValue;
-	exports.LRU = LRU;
 	exports.Logger = Logger;
 	exports.MINUTE = MINUTE;
 	exports.MONTH = MONTH;
@@ -4806,6 +4489,7 @@
 	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;
@@ -4844,6 +4528,9 @@
 	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.fixPrecision = fixPrecision;
@@ -4866,7 +4553,6 @@
 	exports.getFormatFromValue = getFormatFromValue;
 	exports.getIntersectPoint = getIntersectPoint;
 	exports.getIntervalOptions = getIntervalOptions;
-	exports.getOBBFromLine = getOBBFromLine;
 	exports.getRectIntersect = getRectIntersect;
 	exports.getScale = getScale;
 	exports.getScaleX = getScaleX;
@@ -4955,16 +4641,15 @@
 	exports.normalTransform = normalTransform;
 	exports.normalizePadding = normalizePadding;
 	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.pointBetweenLine = pointBetweenLine;
+	exports.pointAtPP = pointAtPP;
 	exports.pointInAABB = pointInAABB;
-	exports.pointInLine = pointInLine;
-	exports.pointInOBB = pointInOBB;
 	exports.pointInRect = pointInRect;
 	exports.polarToCartesian = polarToCartesian;
 	exports.polygonContainPoint = polygonContainPoint;