@d3plus/math 3.0.0-alpha.0

package/es/src/largestRect.js

@@ -0,0 +1,324 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import { extent, merge, range } from "d3-array";
+import { polygonArea, polygonCentroid, polygonContains } from "d3-polygon";
+import polygonInside from "./polygonInside.js";
+import polygonRayCast from "./polygonRayCast.js";
+import polygonRotate from "./polygonRotate.js";
+import simplify from "./simplify.js";
+import pointDistanceSquared from "./pointDistanceSquared.js";
+// Algorithm constants
+var aspectRatioStep = 0.5; // step size for the aspect ratio
+var angleStep = 5; // step size for angles (in degrees); has linear impact on running time
+var polyCache = {};
+/**
+    @typedef {Object} LargestRect
+    @desc The returned Object of the largestRect function.
+    @property {Number} width The width of the rectangle
+    @property {Number} height The height of the rectangle
+    @property {Number} cx The x coordinate of the rectangle's center
+    @property {Number} cy The y coordinate of the rectangle's center
+    @property {Number} angle The rotation angle of the rectangle in degrees. The anchor of rotation is the center point.
+    @property {Number} area The area of the largest rectangle.
+    @property {Array} points An array of x/y coordinates for each point in the rectangle, useful for rendering paths.
+*/ /**
+    @function largestRect
+    @author Daniel Smilkov [dsmilkov@gmail.com]
+    @desc An angle of zero means that the longer side of the polygon (the width) will be aligned with the x axis. An angle of 90 and/or -90 means that the longer side of the polygon (the width) will be aligned with the y axis. The value can be a number between -90 and 90 specifying the angle of rotation of the polygon, a string which is parsed to a number, or an array of numbers specifying the possible rotations of the polygon.
+    @param {Array} poly An Array of points that represent a polygon.
+    @param {Object} [options] An Object that allows for overriding various parameters of the algorithm.
+    @param {Number|String|Array} [options.angle = d3.range(-90, 95, 5)] The allowed rotations of the final rectangle.
+    @param {Number|String|Array} [options.aspectRatio] The ratio between the width and height of the rectangle. The value can be a number, a string which is parsed to a number, or an array of numbers specifying the possible aspect ratios of the final rectangle.
+    @param {Number} [options.maxAspectRatio = 15] The maximum aspect ratio (width/height) allowed for the rectangle. This property should only be used if the aspectRatio is not provided.
+    @param {Number} [options.minAspectRatio = 1] The minimum aspect ratio (width/height) allowed for the rectangle. This property should only be used if the aspectRatio is not provided.
+    @param {Number} [options.nTries = 20] The number of randomly drawn points inside the polygon which the algorithm explores as possible center points of the maximal rectangle.
+    @param {Number} [options.minHeight = 0] The minimum height of the rectangle.
+    @param {Number} [options.minWidth = 0] The minimum width of the rectangle.
+    @param {Number} [options.tolerance = 0.02] The simplification tolerance factor, between 0 and 1. A larger tolerance corresponds to more extensive simplification.
+    @param {Array} [options.origin] The center point of the rectangle. If specified, the rectangle will be fixed at that point, otherwise the algorithm optimizes across all possible points. The given value can be either a two dimensional array specifying the x and y coordinate of the origin or an array of two dimensional points specifying multiple possible center points of the rectangle.
+    @param {Boolean} [options.cache] Whether or not to cache the result, which would be used in subsequent calculations to preserve consistency and speed up calculation time.
+    @return {LargestRect}
+*/ export default function(poly) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    if (poly.length < 3) {
+        if (options.verbose) console.error("polygon has to have at least 3 points", poly);
+        return null;
+    }
+    // For visualization debugging purposes
+    var events = [];
+    // User's input normalization
+    options = Object.assign({
+        angle: range(-90, 90 + angleStep, angleStep),
+        cache: true,
+        maxAspectRatio: 15,
+        minAspectRatio: 1,
+        minHeight: 0,
+        minWidth: 0,
+        nTries: 20,
+        tolerance: 0.02,
+        verbose: false
+    }, options);
+    var angles = _instanceof(options.angle, Array) ? options.angle : typeof options.angle === "number" ? [
+        options.angle
+    ] : typeof options.angle === "string" && !isNaN(options.angle) ? [
+        Number(options.angle)
+    ] : [];
+    var aspectRatios = _instanceof(options.aspectRatio, Array) ? options.aspectRatio : typeof options.aspectRatio === "number" ? [
+        options.aspectRatio
+    ] : typeof options.aspectRatio === "string" && !isNaN(options.aspectRatio) ? [
+        Number(options.aspectRatio)
+    ] : [];
+    var origins = options.origin && _instanceof(options.origin, Array) ? _instanceof(options.origin[0], Array) ? options.origin : [
+        options.origin
+    ] : [];
+    var cacheString;
+    if (options.cache) {
+        cacheString = merge(poly).join(",");
+        cacheString += "-".concat(options.minAspectRatio);
+        cacheString += "-".concat(options.maxAspectRatio);
+        cacheString += "-".concat(options.minHeight);
+        cacheString += "-".concat(options.minWidth);
+        cacheString += "-".concat(angles.join(","));
+        cacheString += "-".concat(origins.join(","));
+        if (polyCache[cacheString]) return polyCache[cacheString];
+    }
+    var area = Math.abs(polygonArea(poly)); // take absolute value of the signed area
+    if (area === 0) {
+        if (options.verbose) console.error("polygon has 0 area", poly);
+        return null;
+    }
+    // get the width of the bounding box of the original polygon to determine tolerance
+    var _extent = _sliced_to_array(extent(poly, function(d) {
+        return d[0];
+    }), 2), minx = _extent[0], maxx = _extent[1];
+    var _extent1 = _sliced_to_array(extent(poly, function(d) {
+        return d[1];
+    }), 2), miny = _extent1[0], maxy = _extent1[1];
+    // simplify polygon
+    var tolerance = Math.min(maxx - minx, maxy - miny) * options.tolerance;
+    if (tolerance > 0) poly = simplify(poly, tolerance);
+    if (options.events) events.push({
+        type: "simplify",
+        poly: poly
+    });
+    var ref;
+    // get the width of the bounding box of the simplified polygon
+    ref = _sliced_to_array(extent(poly, function(d) {
+        return d[0];
+    }), 2), minx = ref[0], maxx = ref[1], ref;
+    var ref1;
+    ref1 = _sliced_to_array(extent(poly, function(d) {
+        return d[1];
+    }), 2), miny = ref1[0], maxy = ref1[1], ref1;
+    var _ref = [
+        maxx - minx,
+        maxy - miny
+    ], boxWidth = _ref[0], boxHeight = _ref[1];
+    // discretize the binary search for optimal width to a resolution of this times the polygon width
+    var widthStep = Math.min(boxWidth, boxHeight) / 50;
+    // populate possible center points with random points inside the polygon
+    if (!origins.length) {
+        // get the centroid of the polygon
+        var centroid = polygonCentroid(poly);
+        if (!isFinite(centroid[0])) {
+            if (options.verbose) console.error("cannot find centroid", poly);
+            return null;
+        }
+        if (polygonContains(poly, centroid)) origins.push(centroid);
+        var nTries = options.nTries;
+        // get few more points inside the polygon
+        while(nTries){
+            var rndX = Math.random() * boxWidth + minx;
+            var rndY = Math.random() * boxHeight + miny;
+            var rndPoint = [
+                rndX,
+                rndY
+            ];
+            if (polygonContains(poly, rndPoint)) {
+                origins.push(rndPoint);
+            }
+            nTries--;
+        }
+    }
+    if (options.events) events.push({
+        type: "origins",
+        points: origins
+    });
+    var maxArea = 0;
+    var maxRect = null;
+    for(var ai = 0; ai < angles.length; ai++){
+        var angle = angles[ai];
+        var angleRad = -angle * Math.PI / 180;
+        if (options.events) events.push({
+            type: "angle",
+            angle: angle
+        });
+        for(var i = 0; i < origins.length; i++){
+            var origOrigin = origins[i];
+            // generate improved origins
+            var _polygonRayCast = _sliced_to_array(polygonRayCast(poly, origOrigin, angleRad), 2), p1W = _polygonRayCast[0], p2W = _polygonRayCast[1];
+            var _polygonRayCast1 = _sliced_to_array(polygonRayCast(poly, origOrigin, angleRad + Math.PI / 2), 2), p1H = _polygonRayCast1[0], p2H = _polygonRayCast1[1];
+            var modifOrigins = [];
+            if (p1W && p2W) modifOrigins.push([
+                (p1W[0] + p2W[0]) / 2,
+                (p1W[1] + p2W[1]) / 2
+            ]); // average along with width axis
+            if (p1H && p2H) modifOrigins.push([
+                (p1H[0] + p2H[0]) / 2,
+                (p1H[1] + p2H[1]) / 2
+            ]); // average along with height axis
+            if (options.events) events.push({
+                type: "modifOrigin",
+                idx: i,
+                p1W: p1W,
+                p2W: p2W,
+                p1H: p1H,
+                p2H: p2H,
+                modifOrigins: modifOrigins
+            });
+            for(var i1 = 0; i1 < modifOrigins.length; i1++){
+                var origin = modifOrigins[i1];
+                if (options.events) events.push({
+                    type: "origin",
+                    cx: origin[0],
+                    cy: origin[1]
+                });
+                var _polygonRayCast2 = _sliced_to_array(polygonRayCast(poly, origin, angleRad), 2), p1W1 = _polygonRayCast2[0], p2W1 = _polygonRayCast2[1];
+                if (p1W1 === null || p2W1 === null) continue;
+                var minSqDistW = Math.min(pointDistanceSquared(origin, p1W1), pointDistanceSquared(origin, p2W1));
+                var maxWidth = 2 * Math.sqrt(minSqDistW);
+                var _polygonRayCast3 = _sliced_to_array(polygonRayCast(poly, origin, angleRad + Math.PI / 2), 2), p1H1 = _polygonRayCast3[0], p2H1 = _polygonRayCast3[1];
+                if (p1H1 === null || p2H1 === null) continue;
+                var minSqDistH = Math.min(pointDistanceSquared(origin, p1H1), pointDistanceSquared(origin, p2H1));
+                var maxHeight = 2 * Math.sqrt(minSqDistH);
+                if (maxWidth * maxHeight < maxArea) continue;
+                var aRatios = aspectRatios;
+                if (!aRatios.length) {
+                    var minAspectRatio = Math.max(options.minAspectRatio, options.minWidth / maxHeight, maxArea / (maxHeight * maxHeight));
+                    var maxAspectRatio = Math.min(options.maxAspectRatio, maxWidth / options.minHeight, maxWidth * maxWidth / maxArea);
+                    aRatios = range(minAspectRatio, maxAspectRatio + aspectRatioStep, aspectRatioStep);
+                }
+                for(var a = 0; a < aRatios.length; a++){
+                    var aRatio = aRatios[a];
+                    // do a binary search to find the max width that works
+                    var left = Math.max(options.minWidth, Math.sqrt(maxArea * aRatio));
+                    var right = Math.min(maxWidth, maxHeight * aRatio);
+                    if (right * maxHeight < maxArea) continue;
+                    if (options.events && right - left >= widthStep) events.push({
+                        type: "aRatio",
+                        aRatio: aRatio
+                    });
+                    while(right - left >= widthStep){
+                        var width = (left + right) / 2;
+                        var height = width / aRatio;
+                        var _origin = _sliced_to_array(origin, 2), cx = _origin[0], cy = _origin[1];
+                        var rectPoly = [
+                            [
+                                cx - width / 2,
+                                cy - height / 2
+                            ],
+                            [
+                                cx + width / 2,
+                                cy - height / 2
+                            ],
+                            [
+                                cx + width / 2,
+                                cy + height / 2
+                            ],
+                            [
+                                cx - width / 2,
+                                cy + height / 2
+                            ]
+                        ];
+                        rectPoly = polygonRotate(rectPoly, angleRad, origin);
+                        var insidePoly = polygonInside(rectPoly, poly);
+                        if (insidePoly) {
+                            // we know that the area is already greater than the maxArea found so far
+                            maxArea = width * height;
+                            rectPoly.push(rectPoly[0]);
+                            maxRect = {
+                                area: maxArea,
+                                cx: cx,
+                                cy: cy,
+                                width: width,
+                                height: height,
+                                angle: -angle,
+                                points: rectPoly
+                            };
+                            left = width; // increase the width in the binary search
+                        } else {
+                            right = width; // decrease the width in the binary search
+                        }
+                        if (options.events) events.push({
+                            type: "rectangle",
+                            areaFraction: width * height / area,
+                            cx: cx,
+                            cy: cy,
+                            width: width,
+                            height: height,
+                            angle: angle,
+                            insidePoly: insidePoly
+                        });
+                    }
+                }
+            }
+        }
+    }
+    if (options.cache) {
+        polyCache[cacheString] = maxRect;
+    }
+    return options.events ? Object.assign(maxRect || {}, {
+        events: events
+    }) : maxRect;
+}

package/es/src/lineIntersection.js

@@ -0,0 +1,22 @@
+/**
+    @function lineIntersection
+    @desc Finds the intersection point (if there is one) of the lines p1q1 and p2q2.
+    @param {Array} p1 The first point of the first line segment, which should always be an `[x, y]` formatted Array.
+    @param {Array} q1 The second point of the first line segment, which should always be an `[x, y]` formatted Array.
+    @param {Array} p2 The first point of the second line segment, which should always be an `[x, y]` formatted Array.
+    @param {Array} q2 The second point of the second line segment, which should always be an `[x, y]` formatted Array.
+    @returns {Boolean}
+*/ export default function(p1, q1, p2, q2) {
+    // allow for some margins due to numerical errors
+    var eps = 1e-9;
+    // find the intersection point between the two infinite lines
+    var dx1 = p1[0] - q1[0], dx2 = p2[0] - q2[0], dy1 = p1[1] - q1[1], dy2 = p2[1] - q2[1];
+    var denom = dx1 * dy2 - dy1 * dx2;
+    if (Math.abs(denom) < eps) return null;
+    var cross1 = p1[0] * q1[1] - p1[1] * q1[0], cross2 = p2[0] * q2[1] - p2[1] * q2[0];
+    var px = (cross1 * dx2 - cross2 * dx1) / denom, py = (cross1 * dy2 - cross2 * dy1) / denom;
+    return [
+        px,
+        py
+    ];
+}

package/es/src/path2polygon.js

@@ -0,0 +1,23 @@
+/**
+    @function path2polygon
+    @desc Transforms a path string into an Array of points.
+    @param {String} path An SVG string path, commonly the "d" property of a <path> element.
+    @param {Number} [segmentLength = 50] The length of line segments when converting curves line segments. Higher values lower computation time, but will result in curves that are more rigid.
+    @returns {Array}
+*/ export default function(path) {
+    var segmentLength = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 50;
+    if (typeof document === "undefined") return [];
+    var svgPath = document.createElementNS("http://www.w3.org/2000/svg", "path");
+    svgPath.setAttribute("d", path);
+    var len = svgPath.getTotalLength();
+    var NUM_POINTS = len / segmentLength < 10 ? len / 10 : len / segmentLength;
+    var points = [];
+    for(var i = 0; i < NUM_POINTS; i++){
+        var pt = svgPath.getPointAtLength(i * len / (NUM_POINTS - 1));
+        points.push([
+            pt.x,
+            pt.y
+        ]);
+    }
+    return points;
+};

package/es/src/pointDistance.js

@@ -0,0 +1,10 @@
+import pointDistanceSquared from "./pointDistanceSquared.js";
+/**
+    @function pointDistance
+    @desc Calculates the pixel distance between two points.
+    @param {Array} p1 The first point, which should always be an `[x, y]` formatted Array.
+    @param {Array} p2 The second point, which should always be an `[x, y]` formatted Array.
+    @returns {Number}
+*/ export default function(p1, p2) {
+    return Math.sqrt(pointDistanceSquared(p1, p2));
+};

package/es/src/pointDistanceSquared.js

@@ -0,0 +1,10 @@
+/**
+    @function pointDistanceSquared
+    @desc Returns the squared euclidean distance between two points.
+    @param {Array} p1 The first point, which should always be an `[x, y]` formatted Array.
+    @param {Array} p2 The second point, which should always be an `[x, y]` formatted Array.
+    @returns {Number}
+*/ export default function(p1, p2) {
+    var dx = p2[0] - p1[0], dy = p2[1] - p1[1];
+    return dx * dx + dy * dy;
+};

package/es/src/pointRotate.js

@@ -0,0 +1,18 @@
+/**
+    @function pointRotate
+    @desc Rotates a point around a given origin.
+    @param {Array} p The point to be rotated, which should always be an `[x, y]` formatted Array.
+    @param {Number} alpha The angle in radians to rotate.
+    @param {Array} [origin = [0, 0]] The origin point of the rotation, which should always be an `[x, y]` formatted Array.
+    @returns {Boolean}
+*/ export default function(p, alpha) {
+    var origin = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [
+        0,
+        0
+    ];
+    var cosAlpha = Math.cos(alpha), sinAlpha = Math.sin(alpha), xshifted = p[0] - origin[0], yshifted = p[1] - origin[1];
+    return [
+        cosAlpha * xshifted - sinAlpha * yshifted + origin[0],
+        sinAlpha * xshifted + cosAlpha * yshifted + origin[1]
+    ];
+}

package/es/src/polygonInside.js

@@ -0,0 +1,26 @@
+import { polygonContains } from "d3-polygon";
+import segmentsIntersect from "./segmentsIntersect.js";
+/**
+    @function polygonInside
+    @desc Checks if one polygon is inside another polygon.
+    @param {Array} polyA An Array of `[x, y]` points to be used as the inner polygon, checking if it is inside polyA.
+    @param {Array} polyB An Array of `[x, y]` points to be used as the containing polygon.
+    @returns {Boolean}
+*/ export default function(polyA, polyB) {
+    var iA = -1;
+    var nA = polyA.length;
+    var nB = polyB.length;
+    var bA = polyA[nA - 1];
+    while(++iA < nA){
+        var aA = bA;
+        bA = polyA[iA];
+        var iB = -1;
+        var bB = polyB[nB - 1];
+        while(++iB < nB){
+            var aB = bB;
+            bB = polyB[iB];
+            if (segmentsIntersect(aA, bA, aB, bB)) return false;
+        }
+    }
+    return polygonContains(polyB, polyA[0]);
+}

package/es/src/polygonRayCast.js

@@ -0,0 +1,101 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import lineIntersection from "./lineIntersection.js";
+import segmentBoxContains from "./segmentBoxContains.js";
+import pointDistanceSquared from "./pointDistanceSquared.js";
+/**
+    @function polygonRayCast
+    @desc Gives the two closest intersection points between a ray cast from a point inside a polygon. The two points should lie on opposite sides of the origin.
+    @param {Array} poly The polygon to test against, which should be an `[x, y]` formatted Array.
+    @param {Array} origin The origin point of the ray to be cast, which should be an `[x, y]` formatted Array.
+    @param {Number} [alpha = 0] The angle in radians of the ray.
+    @returns {Array} An array containing two values, the closest point on the left and the closest point on the right. If either point cannot be found, that value will be `null`.
+*/ export default function(poly, origin) {
+    var alpha = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+    var eps = 1e-9;
+    origin = [
+        origin[0] + eps * Math.cos(alpha),
+        origin[1] + eps * Math.sin(alpha)
+    ];
+    var _origin = _sliced_to_array(origin, 2), x0 = _origin[0], y0 = _origin[1];
+    var shiftedOrigin = [
+        x0 + Math.cos(alpha),
+        y0 + Math.sin(alpha)
+    ];
+    var idx = 0;
+    if (Math.abs(shiftedOrigin[0] - x0) < eps) idx = 1;
+    var i = -1;
+    var n = poly.length;
+    var b = poly[n - 1];
+    var minSqDistLeft = Number.MAX_VALUE;
+    var minSqDistRight = Number.MAX_VALUE;
+    var closestPointLeft = null;
+    var closestPointRight = null;
+    while(++i < n){
+        var a = b;
+        b = poly[i];
+        var p = lineIntersection(origin, shiftedOrigin, a, b);
+        if (p && segmentBoxContains(a, b, p)) {
+            var sqDist = pointDistanceSquared(origin, p);
+            if (p[idx] < origin[idx]) {
+                if (sqDist < minSqDistLeft) {
+                    minSqDistLeft = sqDist;
+                    closestPointLeft = p;
+                }
+            } else if (p[idx] > origin[idx]) {
+                if (sqDist < minSqDistRight) {
+                    minSqDistRight = sqDist;
+                    closestPointRight = p;
+                }
+            }
+        }
+    }
+    return [
+        closestPointLeft,
+        closestPointRight
+    ];
+}

package/es/src/polygonRotate.js

@@ -0,0 +1,17 @@
+import pointRotate from "./pointRotate.js";
+/**
+    @function polygonRotate
+    @desc Rotates a point around a given origin.
+    @param {Array} poly The polygon to be rotated, which should be an Array of `[x, y]` values.
+    @param {Number} alpha The angle in radians to rotate.
+    @param {Array} [origin = [0, 0]] The origin point of the rotation, which should be an `[x, y]` formatted Array.
+    @returns {Boolean}
+*/ export default function(poly, alpha) {
+    var origin = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [
+        0,
+        0
+    ];
+    return poly.map(function(p) {
+        return pointRotate(p, alpha, origin);
+    });
+};

package/es/src/segmentBoxContains.js

@@ -0,0 +1,57 @@
+/**
+    @function segmentBoxContains
+    @desc Checks whether a point is inside the bounding box of a line segment.
+    @param {Array} s1 The first point of the line segment to be used for the bounding box, which should always be an `[x, y]` formatted Array.
+    @param {Array} s2 The second point of the line segment to be used for the bounding box, which should always be an `[x, y]` formatted Array.
+    @param {Array} p The point to be checked, which should always be an `[x, y]` formatted Array.
+    @returns {Boolean}
+*/ function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+export default function(s1, s2, p) {
+    var eps = 1e-9, _p = _sliced_to_array(p, 2), px = _p[0], py = _p[1];
+    return !(px < Math.min(s1[0], s2[0]) - eps || px > Math.max(s1[0], s2[0]) + eps || py < Math.min(s1[1], s2[1]) - eps || py > Math.max(s1[1], s2[1]) + eps);
+}

package/es/src/segmentsIntersect.js

@@ -0,0 +1,15 @@
+import lineIntersection from "./lineIntersection.js";
+import segmentBoxContains from "./segmentBoxContains.js";
+/**
+    @function segmentsIntersect
+    @desc Checks whether the line segments p1q1 && p2q2 intersect.
+    @param {Array} p1 The first point of the first line segment, which should always be an `[x, y]` formatted Array.
+    @param {Array} q1 The second point of the first line segment, which should always be an `[x, y]` formatted Array.
+    @param {Array} p2 The first point of the second line segment, which should always be an `[x, y]` formatted Array.
+    @param {Array} q2 The second point of the second line segment, which should always be an `[x, y]` formatted Array.
+    @returns {Boolean}
+*/ export default function(p1, q1, p2, q2) {
+    var p = lineIntersection(p1, q1, p2, q2);
+    if (!p) return false;
+    return segmentBoxContains(p1, q1, p) && segmentBoxContains(p2, q2, p);
+}