{"version":3,"file":"npm-delaunator-4866f7de5286bacfb135.js","mappings":"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","sources":["webpack:///../node_modules/delaunator/index.js"],"sourcesContent":["\nconst EPSILON = Math.pow(2, -52);\nconst EDGE_STACK = new Uint32Array(512);\n\nexport default class Delaunator {\n\n    static from(points, getX = defaultGetX, getY = defaultGetY) {\n        const n = points.length;\n        const coords = new Float64Array(n * 2);\n\n        for (let i = 0; i < n; i++) {\n            const p = points[i];\n            coords[2 * i] = getX(p);\n            coords[2 * i + 1] = getY(p);\n        }\n\n        return new Delaunator(coords);\n    }\n\n    constructor(coords) {\n        const n = coords.length >> 1;\n        if (n > 0 && typeof coords[0] !== 'number') throw new Error('Expected coords to contain numbers.');\n\n        this.coords = coords;\n\n        // arrays that will store the triangulation graph\n        const maxTriangles = Math.max(2 * n - 5, 0);\n        this._triangles = new Uint32Array(maxTriangles * 3);\n        this._halfedges = new Int32Array(maxTriangles * 3);\n\n        // temporary arrays for tracking the edges of the advancing convex hull\n        this._hashSize = Math.ceil(Math.sqrt(n));\n        this._hullPrev = new Uint32Array(n); // edge to prev edge\n        this._hullNext = new Uint32Array(n); // edge to next edge\n        this._hullTri = new Uint32Array(n); // edge to adjacent triangle\n        this._hullHash = new Int32Array(this._hashSize).fill(-1); // angular edge hash\n\n        // temporary arrays for sorting points\n        this._ids = new Uint32Array(n);\n        this._dists = new Float64Array(n);\n\n        this.update();\n    }\n\n    update() {\n        const {coords, _hullPrev: hullPrev, _hullNext: hullNext, _hullTri: hullTri, _hullHash: hullHash} =  this;\n        const n = coords.length >> 1;\n\n        // populate an array of point indices; calculate input data bbox\n        let minX = Infinity;\n        let minY = Infinity;\n        let maxX = -Infinity;\n        let maxY = -Infinity;\n\n        for (let i = 0; i < n; i++) {\n            const x = coords[2 * i];\n            const y = coords[2 * i + 1];\n            if (x < minX) minX = x;\n            if (y < minY) minY = y;\n            if (x > maxX) maxX = x;\n            if (y > maxY) maxY = y;\n            this._ids[i] = i;\n        }\n        const cx = (minX + maxX) / 2;\n        const cy = (minY + maxY) / 2;\n\n        let minDist = Infinity;\n        let i0, i1, i2;\n\n        // pick a seed point close to the center\n        for (let i = 0; i < n; i++) {\n            const d = dist(cx, cy, coords[2 * i], coords[2 * i + 1]);\n            if (d < minDist) {\n                i0 = i;\n                minDist = d;\n            }\n        }\n        const i0x = coords[2 * i0];\n        const i0y = coords[2 * i0 + 1];\n\n        minDist = Infinity;\n\n        // find the point closest to the seed\n        for (let i = 0; i < n; i++) {\n            if (i === i0) continue;\n            const d = dist(i0x, i0y, coords[2 * i], coords[2 * i + 1]);\n            if (d < minDist && d > 0) {\n                i1 = i;\n                minDist = d;\n            }\n        }\n        let i1x = coords[2 * i1];\n        let i1y = coords[2 * i1 + 1];\n\n        let minRadius = Infinity;\n\n        // find the third point which forms the smallest circumcircle with the first two\n        for (let i = 0; i < n; i++) {\n            if (i === i0 || i === i1) continue;\n            const r = circumradius(i0x, i0y, i1x, i1y, coords[2 * i], coords[2 * i + 1]);\n            if (r < minRadius) {\n                i2 = i;\n                minRadius = r;\n            }\n        }\n        let i2x = coords[2 * i2];\n        let i2y = coords[2 * i2 + 1];\n\n        if (minRadius === Infinity) {\n            // order collinear points by dx (or dy if all x are identical)\n            // and return the list as a hull\n            for (let i = 0; i < n; i++) {\n                this._dists[i] = (coords[2 * i] - coords[0]) || (coords[2 * i + 1] - coords[1]);\n            }\n            quicksort(this._ids, this._dists, 0, n - 1);\n            const hull = new Uint32Array(n);\n            let j = 0;\n            for (let i = 0, d0 = -Infinity; i < n; i++) {\n                const id = this._ids[i];\n                if (this._dists[id] > d0) {\n                    hull[j++] = id;\n                    d0 = this._dists[id];\n                }\n            }\n            this.hull = hull.subarray(0, j);\n            this.triangles = new Uint32Array(0);\n            this.halfedges = new Uint32Array(0);\n            return;\n        }\n\n        // swap the order of the seed points for counter-clockwise orientation\n        if (orient(i0x, i0y, i1x, i1y, i2x, i2y)) {\n            const i = i1;\n            const x = i1x;\n            const y = i1y;\n            i1 = i2;\n            i1x = i2x;\n            i1y = i2y;\n            i2 = i;\n            i2x = x;\n            i2y = y;\n        }\n\n        const center = circumcenter(i0x, i0y, i1x, i1y, i2x, i2y);\n        this._cx = center.x;\n        this._cy = center.y;\n\n        for (let i = 0; i < n; i++) {\n            this._dists[i] = dist(coords[2 * i], coords[2 * i + 1], center.x, center.y);\n        }\n\n        // sort the points by distance from the seed triangle circumcenter\n        quicksort(this._ids, this._dists, 0, n - 1);\n\n        // set up the seed triangle as the starting hull\n        this._hullStart = i0;\n        let hullSize = 3;\n\n        hullNext[i0] = hullPrev[i2] = i1;\n        hullNext[i1] = hullPrev[i0] = i2;\n        hullNext[i2] = hullPrev[i1] = i0;\n\n        hullTri[i0] = 0;\n        hullTri[i1] = 1;\n        hullTri[i2] = 2;\n\n        hullHash.fill(-1);\n        hullHash[this._hashKey(i0x, i0y)] = i0;\n        hullHash[this._hashKey(i1x, i1y)] = i1;\n        hullHash[this._hashKey(i2x, i2y)] = i2;\n\n        this.trianglesLen = 0;\n        this._addTriangle(i0, i1, i2, -1, -1, -1);\n\n        for (let k = 0, xp, yp; k < this._ids.length; k++) {\n            const i = this._ids[k];\n            const x = coords[2 * i];\n            const y = coords[2 * i + 1];\n\n            // skip near-duplicate points\n            if (k > 0 && Math.abs(x - xp) <= EPSILON && Math.abs(y - yp) <= EPSILON) continue;\n            xp = x;\n            yp = y;\n\n            // skip seed triangle points\n            if (i === i0 || i === i1 || i === i2) continue;\n\n            // find a visible edge on the convex hull using edge hash\n            let start = 0;\n            for (let j = 0, key = this._hashKey(x, y); j < this._hashSize; j++) {\n                start = hullHash[(key + j) % this._hashSize];\n                if (start !== -1 && start !== hullNext[start]) break;\n            }\n\n            start = hullPrev[start];\n            let e = start, q;\n            while (q = hullNext[e], !orient(x, y, coords[2 * e], coords[2 * e + 1], coords[2 * q], coords[2 * q + 1])) {\n                e = q;\n                if (e === start) {\n                    e = -1;\n                    break;\n                }\n            }\n            if (e === -1) continue; // likely a near-duplicate point; skip it\n\n            // add the first triangle from the point\n            let t = this._addTriangle(e, i, hullNext[e], -1, -1, hullTri[e]);\n\n            // recursively flip triangles from the point until they satisfy the Delaunay condition\n            hullTri[i] = this._legalize(t + 2);\n            hullTri[e] = t; // keep track of boundary triangles on the hull\n            hullSize++;\n\n            // walk forward through the hull, adding more triangles and flipping recursively\n            let n = hullNext[e];\n            while (q = hullNext[n], orient(x, y, coords[2 * n], coords[2 * n + 1], coords[2 * q], coords[2 * q + 1])) {\n                t = this._addTriangle(n, i, q, hullTri[i], -1, hullTri[n]);\n                hullTri[i] = this._legalize(t + 2);\n                hullNext[n] = n; // mark as removed\n                hullSize--;\n                n = q;\n            }\n\n            // walk backward from the other side, adding more triangles and flipping\n            if (e === start) {\n                while (q = hullPrev[e], orient(x, y, coords[2 * q], coords[2 * q + 1], coords[2 * e], coords[2 * e + 1])) {\n                    t = this._addTriangle(q, i, e, -1, hullTri[e], hullTri[q]);\n                    this._legalize(t + 2);\n                    hullTri[q] = t;\n                    hullNext[e] = e; // mark as removed\n                    hullSize--;\n                    e = q;\n                }\n            }\n\n            // update the hull indices\n            this._hullStart = hullPrev[i] = e;\n            hullNext[e] = hullPrev[n] = i;\n            hullNext[i] = n;\n\n            // save the two new edges in the hash table\n            hullHash[this._hashKey(x, y)] = i;\n            hullHash[this._hashKey(coords[2 * e], coords[2 * e + 1])] = e;\n        }\n\n        this.hull = new Uint32Array(hullSize);\n        for (let i = 0, e = this._hullStart; i < hullSize; i++) {\n            this.hull[i] = e;\n            e = hullNext[e];\n        }\n\n        // trim typed triangle mesh arrays\n        this.triangles = this._triangles.subarray(0, this.trianglesLen);\n        this.halfedges = this._halfedges.subarray(0, this.trianglesLen);\n    }\n\n    _hashKey(x, y) {\n        return Math.floor(pseudoAngle(x - this._cx, y - this._cy) * this._hashSize) % this._hashSize;\n    }\n\n    _legalize(a) {\n        const {_triangles: triangles, _halfedges: halfedges, coords} = this;\n\n        let i = 0;\n        let ar = 0;\n\n        // recursion eliminated with a fixed-size stack\n        while (true) {\n            const b = halfedges[a];\n\n            /* if the pair of triangles doesn't satisfy the Delaunay condition\n             * (p1 is inside the circumcircle of [p0, pl, pr]), flip them,\n             * then do the same check/flip recursively for the new pair of triangles\n             *\n             *           pl                    pl\n             *          /||\\                  /  \\\n             *       al/ || \\bl            al/    \\a\n             *        /  ||  \\              /      \\\n             *       /  a||b  \\    flip    /___ar___\\\n             *     p0\\   ||   /p1   =>   p0\\---bl---/p1\n             *        \\  ||  /              \\      /\n             *       ar\\ || /br             b\\    /br\n             *          \\||/                  \\  /\n             *           pr                    pr\n             */\n            const a0 = a - a % 3;\n            ar = a0 + (a + 2) % 3;\n\n            if (b === -1) { // convex hull edge\n                if (i === 0) break;\n                a = EDGE_STACK[--i];\n                continue;\n            }\n\n            const b0 = b - b % 3;\n            const al = a0 + (a + 1) % 3;\n            const bl = b0 + (b + 2) % 3;\n\n            const p0 = triangles[ar];\n            const pr = triangles[a];\n            const pl = triangles[al];\n            const p1 = triangles[bl];\n\n            const illegal = inCircle(\n                coords[2 * p0], coords[2 * p0 + 1],\n                coords[2 * pr], coords[2 * pr + 1],\n                coords[2 * pl], coords[2 * pl + 1],\n                coords[2 * p1], coords[2 * p1 + 1]);\n\n            if (illegal) {\n                triangles[a] = p1;\n                triangles[b] = p0;\n\n                const hbl = halfedges[bl];\n\n                // edge swapped on the other side of the hull (rare); fix the halfedge reference\n                if (hbl === -1) {\n                    let e = this._hullStart;\n                    do {\n                        if (this._hullTri[e] === bl) {\n                            this._hullTri[e] = a;\n                            break;\n                        }\n                        e = this._hullPrev[e];\n                    } while (e !== this._hullStart);\n                }\n                this._link(a, hbl);\n                this._link(b, halfedges[ar]);\n                this._link(ar, bl);\n\n                const br = b0 + (b + 1) % 3;\n\n                // don't worry about hitting the cap: it can only happen on extremely degenerate input\n                if (i < EDGE_STACK.length) {\n                    EDGE_STACK[i++] = br;\n                }\n            } else {\n                if (i === 0) break;\n                a = EDGE_STACK[--i];\n            }\n        }\n\n        return ar;\n    }\n\n    _link(a, b) {\n        this._halfedges[a] = b;\n        if (b !== -1) this._halfedges[b] = a;\n    }\n\n    // add a new triangle given vertex indices and adjacent half-edge ids\n    _addTriangle(i0, i1, i2, a, b, c) {\n        const t = this.trianglesLen;\n\n        this._triangles[t] = i0;\n        this._triangles[t + 1] = i1;\n        this._triangles[t + 2] = i2;\n\n        this._link(t, a);\n        this._link(t + 1, b);\n        this._link(t + 2, c);\n\n        this.trianglesLen += 3;\n\n        return t;\n    }\n}\n\n// monotonically increases with real angle, but doesn't need expensive trigonometry\nfunction pseudoAngle(dx, dy) {\n    const p = dx / (Math.abs(dx) + Math.abs(dy));\n    return (dy > 0 ? 3 - p : 1 + p) / 4; // [0..1]\n}\n\nfunction dist(ax, ay, bx, by) {\n    const dx = ax - bx;\n    const dy = ay - by;\n    return dx * dx + dy * dy;\n}\n\n// return 2d orientation sign if we're confident in it through J. Shewchuk's error bound check\nfunction orientIfSure(px, py, rx, ry, qx, qy) {\n    const l = (ry - py) * (qx - px);\n    const r = (rx - px) * (qy - py);\n    return Math.abs(l - r) >= 3.3306690738754716e-16 * Math.abs(l + r) ? l - r : 0;\n}\n\n// a more robust orientation test that's stable in a given triangle (to fix robustness issues)\nfunction orient(rx, ry, qx, qy, px, py) {\n    const sign = orientIfSure(px, py, rx, ry, qx, qy) ||\n    orientIfSure(rx, ry, qx, qy, px, py) ||\n    orientIfSure(qx, qy, px, py, rx, ry);\n    return sign < 0;\n}\n\nfunction inCircle(ax, ay, bx, by, cx, cy, px, py) {\n    const dx = ax - px;\n    const dy = ay - py;\n    const ex = bx - px;\n    const ey = by - py;\n    const fx = cx - px;\n    const fy = cy - py;\n\n    const ap = dx * dx + dy * dy;\n    const bp = ex * ex + ey * ey;\n    const cp = fx * fx + fy * fy;\n\n    return dx * (ey * cp - bp * fy) -\n           dy * (ex * cp - bp * fx) +\n           ap * (ex * fy - ey * fx) < 0;\n}\n\nfunction circumradius(ax, ay, bx, by, cx, cy) {\n    const dx = bx - ax;\n    const dy = by - ay;\n    const ex = cx - ax;\n    const ey = cy - ay;\n\n    const bl = dx * dx + dy * dy;\n    const cl = ex * ex + ey * ey;\n    const d = 0.5 / (dx * ey - dy * ex);\n\n    const x = (ey * bl - dy * cl) * d;\n    const y = (dx * cl - ex * bl) * d;\n\n    return x * x + y * y;\n}\n\nfunction circumcenter(ax, ay, bx, by, cx, cy) {\n    const dx = bx - ax;\n    const dy = by - ay;\n    const ex = cx - ax;\n    const ey = cy - ay;\n\n    const bl = dx * dx + dy * dy;\n    const cl = ex * ex + ey * ey;\n    const d = 0.5 / (dx * ey - dy * ex);\n\n    const x = ax + (ey * bl - dy * cl) * d;\n    const y = ay + (dx * cl - ex * bl) * d;\n\n    return {x, y};\n}\n\nfunction quicksort(ids, dists, left, right) {\n    if (right - left <= 20) {\n        for (let i = left + 1; i <= right; i++) {\n            const temp = ids[i];\n            const tempDist = dists[temp];\n            let j = i - 1;\n            while (j >= left && dists[ids[j]] > tempDist) ids[j + 1] = ids[j--];\n            ids[j + 1] = temp;\n        }\n    } else {\n        const median = (left + right) >> 1;\n        let i = left + 1;\n        let j = right;\n        swap(ids, median, i);\n        if (dists[ids[left]] > dists[ids[right]]) swap(ids, left, right);\n        if (dists[ids[i]] > dists[ids[right]]) swap(ids, i, right);\n        if (dists[ids[left]] > dists[ids[i]]) swap(ids, left, i);\n\n        const temp = ids[i];\n        const tempDist = dists[temp];\n        while (true) {\n            do i++; while (dists[ids[i]] < tempDist);\n            do j--; while (dists[ids[j]] > tempDist);\n            if (j < i) break;\n            swap(ids, i, j);\n        }\n        ids[left + 1] = ids[j];\n        ids[j] = temp;\n\n        if (right - i + 1 >= j - left) {\n            quicksort(ids, dists, i, right);\n            quicksort(ids, dists, left, j - 1);\n        } else {\n            quicksort(ids, dists, left, j - 1);\n            quicksort(ids, dists, i, right);\n        }\n    }\n}\n\nfunction swap(arr, i, j) {\n    const tmp = arr[i];\n    arr[i] = arr[j];\n    arr[j] = tmp;\n}\n\nfunction defaultGetX(p) {\n    return p[0];\n}\nfunction defaultGetY(p) {\n    return p[1];\n}\n"],"names":["EPSILON","Math","pow","EDGE_STACK","Uint32Array","coords","n","length","Error","this","maxTriangles","max","_triangles","_halfedges","Int32Array","_hashSize","ceil","sqrt","_hullPrev","_hullNext","_hullTri","_hullHash","fill","_ids","_dists","Float64Array","update","Delaunator","points","getX","getY","i","p","hullPrev","hullNext","hullTri","hullHash","minX","Infinity","minY","maxX","maxY","x","y","i0","i1","i2","cx","cy","minDist","d","dist","i0x","i0y","i1x","i1y","minRadius","r","circumradius","i2x","i2y","quicksort","hull","j","d0","id","subarray","triangles","halfedges","orient","center","ax","ay","bx","by","dx","dy","ex","ey","bl","cl","circumcenter","_cx","_cy","_hullStart","hullSize","_hashKey","trianglesLen","_addTriangle","k","xp","yp","abs","start","key","e","q","t","_legalize","n_1","floor","a","px","py","fx","fy","bp","cp","ar","b","a0","b0","al","p0","pr","pl","p1","hbl","_link","br","c","orientIfSure","rx","ry","qx","qy","l","ids","dists","left","right","tempDist","temp","swap","arr","tmp","defaultGetX","defaultGetY"],"sourceRoot":""}