@piwitests/server 0.25.0 → 0.26.0

package/.output/server/node_modules/supercluster/dist/supercluster.js

@@ -1,635 +0,0 @@
-(function (global, factory) {
-typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-typeof define === 'function' && define.amd ? define(factory) :
-(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Supercluster = factory());
-})(this, (function () { 'use strict';
-
-function sortKD(ids, coords, nodeSize, left, right, depth) {
-    if (right - left <= nodeSize) { return; }
-
-    var m = (left + right) >> 1;
-
-    select(ids, coords, m, left, right, depth % 2);
-
-    sortKD(ids, coords, nodeSize, left, m - 1, depth + 1);
-    sortKD(ids, coords, nodeSize, m + 1, right, depth + 1);
-}
-
-function select(ids, coords, k, left, right, inc) {
-
-    while (right > left) {
-        if (right - left > 600) {
-            var n = right - left + 1;
-            var m = k - left + 1;
-            var z = Math.log(n);
-            var s = 0.5 * Math.exp(2 * z / 3);
-            var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
-            var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
-            var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
-            select(ids, coords, k, newLeft, newRight, inc);
-        }
-
-        var t = coords[2 * k + inc];
-        var i = left;
-        var j = right;
-
-        swapItem(ids, coords, left, k);
-        if (coords[2 * right + inc] > t) { swapItem(ids, coords, left, right); }
-
-        while (i < j) {
-            swapItem(ids, coords, i, j);
-            i++;
-            j--;
-            while (coords[2 * i + inc] < t) { i++; }
-            while (coords[2 * j + inc] > t) { j--; }
-        }
-
-        if (coords[2 * left + inc] === t) { swapItem(ids, coords, left, j); }
-        else {
-            j++;
-            swapItem(ids, coords, j, right);
-        }
-
-        if (j <= k) { left = j + 1; }
-        if (k <= j) { right = j - 1; }
-    }
-}
-
-function swapItem(ids, coords, i, j) {
-    swap(ids, i, j);
-    swap(coords, 2 * i, 2 * j);
-    swap(coords, 2 * i + 1, 2 * j + 1);
-}
-
-function swap(arr, i, j) {
-    var tmp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = tmp;
-}
-
-function range(ids, coords, minX, minY, maxX, maxY, nodeSize) {
-    var stack = [0, ids.length - 1, 0];
-    var result = [];
-    var x, y;
-
-    while (stack.length) {
-        var axis = stack.pop();
-        var right = stack.pop();
-        var left = stack.pop();
-
-        if (right - left <= nodeSize) {
-            for (var i = left; i <= right; i++) {
-                x = coords[2 * i];
-                y = coords[2 * i + 1];
-                if (x >= minX && x <= maxX && y >= minY && y <= maxY) { result.push(ids[i]); }
-            }
-            continue;
-        }
-
-        var m = Math.floor((left + right) / 2);
-
-        x = coords[2 * m];
-        y = coords[2 * m + 1];
-
-        if (x >= minX && x <= maxX && y >= minY && y <= maxY) { result.push(ids[m]); }
-
-        var nextAxis = (axis + 1) % 2;
-
-        if (axis === 0 ? minX <= x : minY <= y) {
-            stack.push(left);
-            stack.push(m - 1);
-            stack.push(nextAxis);
-        }
-        if (axis === 0 ? maxX >= x : maxY >= y) {
-            stack.push(m + 1);
-            stack.push(right);
-            stack.push(nextAxis);
-        }
-    }
-
-    return result;
-}
-
-function within(ids, coords, qx, qy, r, nodeSize) {
-    var stack = [0, ids.length - 1, 0];
-    var result = [];
-    var r2 = r * r;
-
-    while (stack.length) {
-        var axis = stack.pop();
-        var right = stack.pop();
-        var left = stack.pop();
-
-        if (right - left <= nodeSize) {
-            for (var i = left; i <= right; i++) {
-                if (sqDist(coords[2 * i], coords[2 * i + 1], qx, qy) <= r2) { result.push(ids[i]); }
-            }
-            continue;
-        }
-
-        var m = Math.floor((left + right) / 2);
-
-        var x = coords[2 * m];
-        var y = coords[2 * m + 1];
-
-        if (sqDist(x, y, qx, qy) <= r2) { result.push(ids[m]); }
-
-        var nextAxis = (axis + 1) % 2;
-
-        if (axis === 0 ? qx - r <= x : qy - r <= y) {
-            stack.push(left);
-            stack.push(m - 1);
-            stack.push(nextAxis);
-        }
-        if (axis === 0 ? qx + r >= x : qy + r >= y) {
-            stack.push(m + 1);
-            stack.push(right);
-            stack.push(nextAxis);
-        }
-    }
-
-    return result;
-}
-
-function sqDist(ax, ay, bx, by) {
-    var dx = ax - bx;
-    var dy = ay - by;
-    return dx * dx + dy * dy;
-}
-
-var defaultGetX = function (p) { return p[0]; };
-var defaultGetY = function (p) { return p[1]; };
-
-var KDBush = function KDBush(points, getX, getY, nodeSize, ArrayType) {
-    if ( getX === void 0 ) getX = defaultGetX;
-    if ( getY === void 0 ) getY = defaultGetY;
-    if ( nodeSize === void 0 ) nodeSize = 64;
-    if ( ArrayType === void 0 ) ArrayType = Float64Array;
-
-    this.nodeSize = nodeSize;
-    this.points = points;
-
-    var IndexArrayType = points.length < 65536 ? Uint16Array : Uint32Array;
-
-    var ids = this.ids = new IndexArrayType(points.length);
-    var coords = this.coords = new ArrayType(points.length * 2);
-
-    for (var i = 0; i < points.length; i++) {
-        ids[i] = i;
-        coords[2 * i] = getX(points[i]);
-        coords[2 * i + 1] = getY(points[i]);
-    }
-
-    sortKD(ids, coords, nodeSize, 0, ids.length - 1, 0);
-};
-
-KDBush.prototype.range = function range$1 (minX, minY, maxX, maxY) {
-    return range(this.ids, this.coords, minX, minY, maxX, maxY, this.nodeSize);
-};
-
-KDBush.prototype.within = function within$1 (x, y, r) {
-    return within(this.ids, this.coords, x, y, r, this.nodeSize);
-};
-
-var defaultOptions = {
-    minZoom: 0,   // min zoom to generate clusters on
-    maxZoom: 16,  // max zoom level to cluster the points on
-    minPoints: 2, // minimum points to form a cluster
-    radius: 40,   // cluster radius in pixels
-    extent: 512,  // tile extent (radius is calculated relative to it)
-    nodeSize: 64, // size of the KD-tree leaf node, affects performance
-    log: false,   // whether to log timing info
-
-    // whether to generate numeric ids for input features (in vector tiles)
-    generateId: false,
-
-    // a reduce function for calculating custom cluster properties
-    reduce: null, // (accumulated, props) => { accumulated.sum += props.sum; }
-
-    // properties to use for individual points when running the reducer
-    map: function (props) { return props; } // props => ({sum: props.my_value})
-};
-
-var fround = Math.fround || (function (tmp) { return (function (x) { tmp[0] = +x; return tmp[0]; }); })(new Float32Array(1));
-
-var Supercluster = function Supercluster(options) {
-    this.options = extend(Object.create(defaultOptions), options);
-    this.trees = new Array(this.options.maxZoom + 1);
-};
-
-Supercluster.prototype.load = function load (points) {
-    var ref = this.options;
-        var log = ref.log;
-        var minZoom = ref.minZoom;
-        var maxZoom = ref.maxZoom;
-        var nodeSize = ref.nodeSize;
-
-    if (log) { console.time('total time'); }
-
-    var timerId = "prepare " + (points.length) + " points";
-    if (log) { console.time(timerId); }
-
-    this.points = points;
-
-    // generate a cluster object for each point and index input points into a KD-tree
-    var clusters = [];
-    for (var i = 0; i < points.length; i++) {
-        if (!points[i].geometry) { continue; }
-        clusters.push(createPointCluster(points[i], i));
-    }
-    this.trees[maxZoom + 1] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);
-
-    if (log) { console.timeEnd(timerId); }
-
-    // cluster points on max zoom, then cluster the results on previous zoom, etc.;
-    // results in a cluster hierarchy across zoom levels
-    for (var z = maxZoom; z >= minZoom; z--) {
-        var now = +Date.now();
-
-        // create a new set of clusters for the zoom and index them with a KD-tree
-        clusters = this._cluster(clusters, z);
-        this.trees[z] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);
-
-        if (log) { console.log('z%d: %d clusters in %dms', z, clusters.length, +Date.now() - now); }
-    }
-
-    if (log) { console.timeEnd('total time'); }
-
-    return this;
-};
-
-Supercluster.prototype.getClusters = function getClusters (bbox, zoom) {
-    var minLng = ((bbox[0] + 180) % 360 + 360) % 360 - 180;
-    var minLat = Math.max(-90, Math.min(90, bbox[1]));
-    var maxLng = bbox[2] === 180 ? 180 : ((bbox[2] + 180) % 360 + 360) % 360 - 180;
-    var maxLat = Math.max(-90, Math.min(90, bbox[3]));
-
-    if (bbox[2] - bbox[0] >= 360) {
-        minLng = -180;
-        maxLng = 180;
-    } else if (minLng > maxLng) {
-        var easternHem = this.getClusters([minLng, minLat, 180, maxLat], zoom);
-        var westernHem = this.getClusters([-180, minLat, maxLng, maxLat], zoom);
-        return easternHem.concat(westernHem);
-    }
-
-    var tree = this.trees[this._limitZoom(zoom)];
-    var ids = tree.range(lngX(minLng), latY(maxLat), lngX(maxLng), latY(minLat));
-    var clusters = [];
-    for (var i = 0, list = ids; i < list.length; i += 1) {
-        var id = list[i];
-
-            var c = tree.points[id];
-        clusters.push(c.numPoints ? getClusterJSON(c) : this.points[c.index]);
-    }
-    return clusters;
-};
-
-Supercluster.prototype.getChildren = function getChildren (clusterId) {
-    var originId = this._getOriginId(clusterId);
-    var originZoom = this._getOriginZoom(clusterId);
-    var errorMsg = 'No cluster with the specified id.';
-
-    var index = this.trees[originZoom];
-    if (!index) { throw new Error(errorMsg); }
-
-    var origin = index.points[originId];
-    if (!origin) { throw new Error(errorMsg); }
-
-    var r = this.options.radius / (this.options.extent * Math.pow(2, originZoom - 1));
-    var ids = index.within(origin.x, origin.y, r);
-    var children = [];
-    for (var i = 0, list = ids; i < list.length; i += 1) {
-        var id = list[i];
-
-            var c = index.points[id];
-        if (c.parentId === clusterId) {
-            children.push(c.numPoints ? getClusterJSON(c) : this.points[c.index]);
-        }
-    }
-
-    if (children.length === 0) { throw new Error(errorMsg); }
-
-    return children;
-};
-
-Supercluster.prototype.getLeaves = function getLeaves (clusterId, limit, offset) {
-    limit = limit || 10;
-    offset = offset || 0;
-
-    var leaves = [];
-    this._appendLeaves(leaves, clusterId, limit, offset, 0);
-
-    return leaves;
-};
-
-Supercluster.prototype.getTile = function getTile (z, x, y) {
-    var tree = this.trees[this._limitZoom(z)];
-    var z2 = Math.pow(2, z);
-    var ref = this.options;
-        var extent = ref.extent;
-        var radius = ref.radius;
-    var p = radius / extent;
-    var top = (y - p) / z2;
-    var bottom = (y + 1 + p) / z2;
-
-    var tile = {
-        features: []
-    };
-
-    this._addTileFeatures(
-        tree.range((x - p) / z2, top, (x + 1 + p) / z2, bottom),
-        tree.points, x, y, z2, tile);
-
-    if (x === 0) {
-        this._addTileFeatures(
-            tree.range(1 - p / z2, top, 1, bottom),
-            tree.points, z2, y, z2, tile);
-    }
-    if (x === z2 - 1) {
-        this._addTileFeatures(
-            tree.range(0, top, p / z2, bottom),
-            tree.points, -1, y, z2, tile);
-    }
-
-    return tile.features.length ? tile : null;
-};
-
-Supercluster.prototype.getClusterExpansionZoom = function getClusterExpansionZoom (clusterId) {
-    var expansionZoom = this._getOriginZoom(clusterId) - 1;
-    while (expansionZoom <= this.options.maxZoom) {
-        var children = this.getChildren(clusterId);
-        expansionZoom++;
-        if (children.length !== 1) { break; }
-        clusterId = children[0].properties.cluster_id;
-    }
-    return expansionZoom;
-};
-
-Supercluster.prototype._appendLeaves = function _appendLeaves (result, clusterId, limit, offset, skipped) {
-    var children = this.getChildren(clusterId);
-
-    for (var i = 0, list = children; i < list.length; i += 1) {
-        var child = list[i];
-
-            var props = child.properties;
-
-        if (props && props.cluster) {
-            if (skipped + props.point_count <= offset) {
-                // skip the whole cluster
-                skipped += props.point_count;
-            } else {
-                // enter the cluster
-                skipped = this._appendLeaves(result, props.cluster_id, limit, offset, skipped);
-                // exit the cluster
-            }
-        } else if (skipped < offset) {
-            // skip a single point
-            skipped++;
-        } else {
-            // add a single point
-            result.push(child);
-        }
-        if (result.length === limit) { break; }
-    }
-
-    return skipped;
-};
-
-Supercluster.prototype._addTileFeatures = function _addTileFeatures (ids, points, x, y, z2, tile) {
-    for (var i$1 = 0, list = ids; i$1 < list.length; i$1 += 1) {
-        var i = list[i$1];
-
-            var c = points[i];
-        var isCluster = c.numPoints;
-
-        var tags = (void 0), px = (void 0), py = (void 0);
-        if (isCluster) {
-            tags = getClusterProperties(c);
-            px = c.x;
-            py = c.y;
-        } else {
-            var p = this.points[c.index];
-            tags = p.properties;
-            px = lngX(p.geometry.coordinates[0]);
-            py = latY(p.geometry.coordinates[1]);
-        }
-
-        var f = {
-            type: 1,
-            geometry: [[
-                Math.round(this.options.extent * (px * z2 - x)),
-                Math.round(this.options.extent * (py * z2 - y))
-            ]],
-            tags: tags
-        };
-
-        // assign id
-        var id = (void 0);
-        if (isCluster) {
-            id = c.id;
-        } else if (this.options.generateId) {
-            // optionally generate id
-            id = c.index;
-        } else if (this.points[c.index].id) {
-            // keep id if already assigned
-            id = this.points[c.index].id;
-        }
-
-        if (id !== undefined) { f.id = id; }
-
-        tile.features.push(f);
-    }
-};
-
-Supercluster.prototype._limitZoom = function _limitZoom (z) {
-    return Math.max(this.options.minZoom, Math.min(Math.floor(+z), this.options.maxZoom + 1));
-};
-
-Supercluster.prototype._cluster = function _cluster (points, zoom) {
-    var clusters = [];
-    var ref = this.options;
-        var radius = ref.radius;
-        var extent = ref.extent;
-        var reduce = ref.reduce;
-        var minPoints = ref.minPoints;
-    var r = radius / (extent * Math.pow(2, zoom));
-
-    // loop through each point
-    for (var i = 0; i < points.length; i++) {
-        var p = points[i];
-        // if we've already visited the point at this zoom level, skip it
-        if (p.zoom <= zoom) { continue; }
-        p.zoom = zoom;
-
-        // find all nearby points
-        var tree = this.trees[zoom + 1];
-        var neighborIds = tree.within(p.x, p.y, r);
-
-        var numPointsOrigin = p.numPoints || 1;
-        var numPoints = numPointsOrigin;
-
-        // count the number of points in a potential cluster
-        for (var i$1 = 0, list = neighborIds; i$1 < list.length; i$1 += 1) {
-            var neighborId = list[i$1];
-
-                var b = tree.points[neighborId];
-            // filter out neighbors that are already processed
-            if (b.zoom > zoom) { numPoints += b.numPoints || 1; }
-        }
-
-        // if there were neighbors to merge, and there are enough points to form a cluster
-        if (numPoints > numPointsOrigin && numPoints >= minPoints) {
-            var wx = p.x * numPointsOrigin;
-            var wy = p.y * numPointsOrigin;
-
-            var clusterProperties = reduce && numPointsOrigin > 1 ? this._map(p, true) : null;
-
-            // encode both zoom and point index on which the cluster originated -- offset by total length of features
-            var id = (i << 5) + (zoom + 1) + this.points.length;
-
-            for (var i$2 = 0, list$1 = neighborIds; i$2 < list$1.length; i$2 += 1) {
-                var neighborId$1 = list$1[i$2];
-
-                    var b$1 = tree.points[neighborId$1];
-
-                if (b$1.zoom <= zoom) { continue; }
-                b$1.zoom = zoom; // save the zoom (so it doesn't get processed twice)
-
-                var numPoints2 = b$1.numPoints || 1;
-                wx += b$1.x * numPoints2; // accumulate coordinates for calculating weighted center
-                wy += b$1.y * numPoints2;
-
-                b$1.parentId = id;
-
-                if (reduce) {
-                    if (!clusterProperties) { clusterProperties = this._map(p, true); }
-                    reduce(clusterProperties, this._map(b$1));
-                }
-            }
-
-            p.parentId = id;
-            clusters.push(createCluster(wx / numPoints, wy / numPoints, id, numPoints, clusterProperties));
-
-        } else { // left points as unclustered
-            clusters.push(p);
-
-            if (numPoints > 1) {
-                for (var i$3 = 0, list$2 = neighborIds; i$3 < list$2.length; i$3 += 1) {
-                    var neighborId$2 = list$2[i$3];
-
-                        var b$2 = tree.points[neighborId$2];
-                    if (b$2.zoom <= zoom) { continue; }
-                    b$2.zoom = zoom;
-                    clusters.push(b$2);
-                }
-            }
-        }
-    }
-
-    return clusters;
-};
-
-// get index of the point from which the cluster originated
-Supercluster.prototype._getOriginId = function _getOriginId (clusterId) {
-    return (clusterId - this.points.length) >> 5;
-};
-
-// get zoom of the point from which the cluster originated
-Supercluster.prototype._getOriginZoom = function _getOriginZoom (clusterId) {
-    return (clusterId - this.points.length) % 32;
-};
-
-Supercluster.prototype._map = function _map (point, clone) {
-    if (point.numPoints) {
-        return clone ? extend({}, point.properties) : point.properties;
-    }
-    var original = this.points[point.index].properties;
-    var result = this.options.map(original);
-    return clone && result === original ? extend({}, result) : result;
-};
-
-function createCluster(x, y, id, numPoints, properties) {
-    return {
-        x: fround(x), // weighted cluster center; round for consistency with Float32Array index
-        y: fround(y),
-        zoom: Infinity, // the last zoom the cluster was processed at
-        id: id, // encodes index of the first child of the cluster and its zoom level
-        parentId: -1, // parent cluster id
-        numPoints: numPoints,
-        properties: properties
-    };
-}
-
-function createPointCluster(p, id) {
-    var ref = p.geometry.coordinates;
-    var x = ref[0];
-    var y = ref[1];
-    return {
-        x: fround(lngX(x)), // projected point coordinates
-        y: fround(latY(y)),
-        zoom: Infinity, // the last zoom the point was processed at
-        index: id, // index of the source feature in the original input array,
-        parentId: -1 // parent cluster id
-    };
-}
-
-function getClusterJSON(cluster) {
-    return {
-        type: 'Feature',
-        id: cluster.id,
-        properties: getClusterProperties(cluster),
-        geometry: {
-            type: 'Point',
-            coordinates: [xLng(cluster.x), yLat(cluster.y)]
-        }
-    };
-}
-
-function getClusterProperties(cluster) {
-    var count = cluster.numPoints;
-    var abbrev =
-        count >= 10000 ? ((Math.round(count / 1000)) + "k") :
-        count >= 1000 ? ((Math.round(count / 100) / 10) + "k") : count;
-    return extend(extend({}, cluster.properties), {
-        cluster: true,
-        cluster_id: cluster.id,
-        point_count: count,
-        point_count_abbreviated: abbrev
-    });
-}
-
-// longitude/latitude to spherical mercator in [0..1] range
-function lngX(lng) {
-    return lng / 360 + 0.5;
-}
-function latY(lat) {
-    var sin = Math.sin(lat * Math.PI / 180);
-    var y = (0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI);
-    return y < 0 ? 0 : y > 1 ? 1 : y;
-}
-
-// spherical mercator to longitude/latitude
-function xLng(x) {
-    return (x - 0.5) * 360;
-}
-function yLat(y) {
-    var y2 = (180 - y * 360) * Math.PI / 180;
-    return 360 * Math.atan(Math.exp(y2)) / Math.PI - 90;
-}
-
-function extend(dest, src) {
-    for (var id in src) { dest[id] = src[id]; }
-    return dest;
-}
-
-function getX(p) {
-    return p.x;
-}
-function getY(p) {
-    return p.y;
-}
-
-return Supercluster;
-
-}));

package/.output/server/node_modules/supercluster/package.json

@@ -1,54 +0,0 @@
-{
-  "name": "supercluster",
-  "version": "7.1.5",
-  "description": "A very fast geospatial point clustering library.",
-  "main": "dist/supercluster.js",
-  "module": "index.js",
-  "jsdelivr": "dist/supercluster.min.js",
-  "unpkg": "dist/supercluster.min.js",
-  "scripts": {
-    "pretest": "eslint index.js bench.js test/test.js demo/index.js demo/worker.js",
-    "test": "tape -r esm test/test.js",
-    "cov": "c8 npm run test",
-    "bench": "node --expose-gc -r esm bench.js",
-    "build": "mkdirp dist && rollup -c",
-    "prepublishOnly": "npm run test && npm run build"
-  },
-  "files": [
-    "index.js",
-    "dist/supercluster.js",
-    "dist/supercluster.min.js"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/mapbox/supercluster.git"
-  },
-  "keywords": [
-    "clustering",
-    "geospatial",
-    "markers"
-  ],
-  "author": "Vladimir Agafonkin",
-  "license": "ISC",
-  "dependencies": {
-    "kdbush": "^3.0.0"
-  },
-  "devDependencies": {
-    "@rollup/plugin-buble": "^0.21.3",
-    "@rollup/plugin-node-resolve": "^13.1.3",
-    "c8": "^7.11.0",
-    "eslint": "^8.12.0",
-    "eslint-config-mourner": "^3.0.0",
-    "esm": "^3.2.25",
-    "mkdirp": "^1.0.4",
-    "rollup": "^2.70.1",
-    "rollup-plugin-terser": "^7.0.2",
-    "tape": "^5.5.2"
-  },
-  "eslintConfig": {
-    "extends": "mourner",
-    "rules": {
-      "camelcase": 0
-    }
-  }
-}