@antv/path-util

--- package/package.json (excerpt) ---
{
  "name": "@antv/path-util",
  "version": "3.0.1",
  "description": "A common util collection for antv projects",
  "main": "lib/index.js",
  "types": "lib/index.d.ts",
  "module": "esm/index.js",
  "files": [
    "src",
    "package.json",
    "esm",
    "lib",
    "README.md"
  ],
  "scripts": {
    "build": "npm run clean && run-p build:*",
    "build:esm": "tsc -p tsconfig.json --target ES5 --module ESNext --outDir esm",
    "build:cjs": "tsc -p tsconfig.json --target ES5 --module commonjs --outDir lib",
    "clean": "rm -rf lib && rm -rf esm",
    "coverage": "npm run coverage-generator && npm run coverage-viewer",
    "coverage-generator": "torch --coverage --compile --source-pattern src/*.js,src/**/*.js --opts __tests__/mocha.opts",
    "coverage-viewer": "torch-coverage",
    "test": "torch --renderer --compile --opts __tests__/mocha.opts",
    "test-live": "torch --compile --interactive --opts __tests__/mocha.opts",
    "tsc": "tsc --noEmit",
    "typecheck": "tsc --noEmit"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/antvis/util.git"
  },
  "keywords": [
    "util",
    "antv",
    "g"
  ],
  "author": "https://github.com/orgs/antvis/people",
  "license": "MIT",
  "bugs": {
    "url": "https://github.com/antvis/util/issues"
  },
  "devDependencies": {
    "@types/gl-matrix": "^2.4.5",
    "@types/lodash-es": "^4.17.6",
    "@antv/torch": "^1.0.0",
    "chai": "^4.2.0",
    "less": "^3.9.0",
    "npm-run-all": "^4.1.5"
  },
  "homepa

--- bundled output (OSV-MAL flagged — LLM scope expansion) ---

--- lib/catmull-rom-2-bezier.js (bundled) ---
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var gl_matrix_1 = require("gl-matrix");
function smoothBezier(points, smooth, isLoop, constraint) {
    var cps = [];
    var hasConstraint = !!constraint;
    var prevPoint;
    var nextPoint;
    var min;
    var max;
    var nextCp0;
    var cp1;
    var cp0;
    if (hasConstraint) {
        min = constraint[0], max = constraint[1];
        for (var i = 0, l = points.length; i < l; i += 1) {
            var point = points[i];
            min = gl_matrix_1.vec2.min([0, 0], min, point);
            max = gl_matrix_1.vec2.max([0, 0], max, point);
        }
    }
    for (var i = 0, len = points.length; i < len; i += 1) {
        var point = points[i];
        if (i === 0 && !isLoop) {
            cp0 = point;
        }
        else if (i === len - 1 && !isLoop) {
            cp1 = point;
            cps.push(cp0);
            cps.push(cp1);
        }
        else {
            var prevIdx = [i ? i - 1 : len - 1, i - 1][isLoop ? 0 : 1];
            prevPoint = points[prevIdx];
            nextPoint = points[isLoop ? (i + 1) % len : i + 1];
            var v = [0, 0];
            v = gl_matrix_1.vec2.sub(v, nextPoint, prevPoint);
            v = gl_matrix_1.vec2.scale(v, v, smooth);
            var d0 = gl_matrix_1.vec2.distance(point, prevPoint);
            var d1 = gl_matrix_1.vec2.distance(point, nextPoint);
            var sum = d0 + d1;
            if (sum !== 0) {
                d0 /= sum;
                d1 /= sum;
            }
            var v1 = gl_matrix_1.vec2.scale([0, 0], v, -d0);
            var v2 = gl_matrix_1.vec2.scale([0, 0], v, d1);
            cp1 = gl_matrix_1.vec2.add([0, 0], point, v1);
            nextCp0 = gl_matrix_1.vec2.add([0, 0], point, v2);
            // 下一个控制点必须在这个点和下一个点之间
            nextCp0 = gl_matrix_1.vec2.min([0, 0], nextCp0, gl_matrix_1.vec2.max([0, 0], nextPoint, point));
            nextCp0 = gl_matrix_1.vec2.max([0, 0], nextCp0, gl_matrix_1.vec2

--- lib/get-arc-params.js (bundled) ---
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isSamePoint = void 0;
var mod = function (n, m) {
    return ((n % m) + m) % m;
};
// 向量长度
function vMag(v) {
    return Math.sqrt(v[0] * v[0] + v[1] * v[1]);
}
// u.v/|u||v|，计算夹角的余弦值
function vRatio(u, v) {
    // 当存在一个向量的长度为 0 时，夹角也为 0，即夹角的余弦值为 1
    return vMag(u) * vMag(v) ? (u[0] * v[0] + u[1] * v[1]) / (vMag(u) * vMag(v)) : 1;
}
// 向量角度
function vAngle(u, v) {
    return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) * Math.acos(vRatio(u, v));
}
/**
 * 判断两个点是否重合，点坐标的格式为 [x, y]
 * @param {Array} point1 第一个点
 * @param {Array} point2 第二个点
 */
function isSamePoint(point1, point2) {
    return point1[0] === point2[0] && point1[1] === point2[1];
}
exports.isSamePoint = isSamePoint;
// A 0:rx 1:ry 2:x-axis-rotation 3:large-arc-flag 4:sweep-flag 5: x 6: y
function getArcParams(startPoint, params) {
    var rx = params[1];
    var ry = params[2];
    var xRotation = mod((params[3] * Math.PI) / 180, Math.PI * 2);
    var arcFlag = params[4];
    var sweepFlag = params[5];
    // 弧形起点坐标
    var x1 = startPoint[0];
    var y1 = startPoint[1];
    // 弧形终点坐标
    var x2 = params[6];
    var y2 = params[7];
    var xp = (Math.cos(xRotation) * (x1 - x2)) / 2.0 + (Math.sin(xRotation) * (y1 - y2)) / 2.0;
    var yp = (-1 * Math.sin(xRotation) * (x1 - x2)) / 2.0 + (Math.cos(xRotation) * (y1 - y2)) / 2.0;
    var lambda = (xp * xp) / (rx * rx) + (yp * yp) / (ry * ry);
    if (lambda > 1) {
        rx *= Math.sqrt(lambda);
        ry *= Math.sqrt(lambda);
    }
    var diff = rx * rx * (yp * yp) + ry * ry * (xp * xp);
    var f = diff ? Math.sqrt((rx * rx * (ry * ry) - diff) / diff) : 1;
    if (arcFlag === sweepFlag) {
        f *= -1;
    }
    if (isNaN(f)) {
        f = 0;
    }
    // 旋转前的起点坐标，且当长半轴和短半轴的长度为 0 时，坐标按 (0, 0) 处理
    var cxp = ry ? (f * rx * yp) / ry : 0;
    var cyp = rx ? (f * -ry * xp) / rx : 0;
    // 椭圆圆心坐标
    var cx = (x1 + x2) / 2.0 + Math.cos(xRotation) * cxp - Math.sin(xRotation) *

--- lib/get-line-intersect.js (bundled) ---
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var isBetween = function (value, min, max) { return value >= min && value <= max; };
function getLineIntersect(p0, p1, p2, p3) {
    var tolerance = 0.001;
    var E = {
        x: p2.x - p0.x,
        y: p2.y - p0.y,
    };
    var D0 = {
        x: p1.x - p0.x,
        y: p1.y - p0.y,
    };
    var D1 = {
        x: p3.x - p2.x,
        y: p3.y - p2.y,
    };
    var kross = D0.x * D1.y - D0.y * D1.x;
    var sqrKross = kross * kross;
    var sqrLen0 = D0.x * D0.x + D0.y * D0.y;
    var sqrLen1 = D1.x * D1.x + D1.y * D1.y;
    var point = null;
    if (sqrKross > tolerance * sqrLen0 * sqrLen1) {
        var s = (E.x * D1.y - E.y * D1.x) / kross;
        var t = (E.x * D0.y - E.y * D0.x) / kross;
        if (isBetween(s, 0, 1) && isBetween(t, 0, 1)) {
            point = {
                x: p0.x + s * D0.x,
                y: p0.y + s * D0.y,
            };
        }
    }
    return point;
}
exports.default = getLineIntersect;
;
//# sourceMappingURL=get-line-intersect.js.map

--- lib/is-polygons-intersect.js (bundled) ---
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var point_in_polygon_1 = require("./point-in-polygon");
var get_line_intersect_1 = require("./get-line-intersect");
var lodash_es_1 = require("lodash-es");
function parseToLines(points) {
    var lines = [];
    var count = points.length;
    for (var i = 0; i < count - 1; i++) {
        var point = points[i];
        var next = points[i + 1];
        lines.push({
            from: {
                x: point[0],
                y: point[1],
            },
            to: {
                x: next[0],
                y: next[1],
            },
        });
    }
    if (lines.length > 1) {
        var first = points[0];
        var last = points[count - 1];
        lines.push({
            from: {
                x: last[0],
                y: last[1],
            },
            to: {
                x: first[0],
                y: first[1],
            },
        });
    }
    return lines;
}
function lineIntersectPolygon(lines, line) {
    var isIntersect = false;
    lodash_es_1.each(lines, function (l) {
        if (get_line_intersect_1.default(l.from, l.to, line.from, line.to)) {
            isIntersect = true;
            return false;
        }
    });
    return isIntersect;
}
function getBBox(points) {
    var xArr = points.map(function (p) { return p[0]; });
    var yArr = points.map(function (p) { return p[1]; });
    return {
        minX: Math.min.apply(null, xArr),
        maxX: Math.max.apply(null, xArr),
        minY: Math.min.apply(null, yArr),
        maxY: Math.max.apply(null, yArr),
    };
}
function intersectBBox(box1, box2) {
    return !(box2.minX > box1.maxX || box2.maxX < box1.minX || box2.minY > box1.maxY || box2.maxY < box1.minY);
}
function isPolygonsIntersect(points1, points2) {
    // 空数组，或者一个点返回 false
    if (points1.length < 2 || points2.length < 2) {
        return false;
    }
    var bbox1 = getBBox(points1);
    var bbox2 = getBBox(points2);
    // 判定包围盒是否相

--- lib/parse-path-string.js (bundled) ---
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var lodash_es_1 = require("lodash-es");
var SPACES = '\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029';
var PATH_COMMAND = new RegExp('([a-z])[' + SPACES + ',]*((-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?[' + SPACES + ']*,?[' + SPACES + ']*)+)', 'ig');
var PATH_VALUES = new RegExp('(-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?)[' + SPACES + ']*,?[' + SPACES + ']*', 'ig');
// Parses given path string into an array of arrays of path segments
function parsePathString(pathString) {
    if (!pathString) {
        return null;
    }
    if (lodash_es_1.isArray(pathStr