mapshaper 0.7.22 → 0.7.24

package/www/modules.js

@@ -973,7 +973,7 @@
 	// Buffer instances.
 	Buffer.prototype._isBuffer = true;
 
-	function swap$2 (b, n, m) {
+	function swap$1 (b, n, m) {
 	  var i = b[n];
 	  b[n] = b[m];
 	  b[m] = i;
@@ -985,7 +985,7 @@
 	    throw new RangeError('Buffer size must be a multiple of 16-bits')
 	  }
 	  for (var i = 0; i < len; i += 2) {
-	    swap$2(this, i, i + 1);
+	    swap$1(this, i, i + 1);
 	  }
 	  return this
 	};
@@ -996,8 +996,8 @@
 	    throw new RangeError('Buffer size must be a multiple of 32-bits')
 	  }
 	  for (var i = 0; i < len; i += 4) {
-	    swap$2(this, i, i + 3);
-	    swap$2(this, i + 1, i + 2);
+	    swap$1(this, i, i + 3);
+	    swap$1(this, i + 1, i + 2);
 	  }
 	  return this
 	};
@@ -1008,10 +1008,10 @@
 	    throw new RangeError('Buffer size must be a multiple of 64-bits')
 	  }
 	  for (var i = 0; i < len; i += 8) {
-	    swap$2(this, i, i + 7);
-	    swap$2(this, i + 1, i + 6);
-	    swap$2(this, i + 2, i + 5);
-	    swap$2(this, i + 3, i + 4);
+	    swap$1(this, i, i + 7);
+	    swap$1(this, i + 1, i + 6);
+	    swap$1(this, i + 2, i + 5);
+	    swap$1(this, i + 3, i + 4);
 	  }
 	  return this
 	};
@@ -33430,452 +33430,6 @@
 	  return pj_init(defn);
 	}
 
-	class FlatQueue {
-
-	    constructor() {
-	        this.ids = [];
-	        this.values = [];
-	        this.length = 0;
-	    }
-
-	    clear() {
-	        this.length = 0;
-	    }
-
-	    push(id, value) {
-	        let pos = this.length++;
-	        this.ids[pos] = id;
-	        this.values[pos] = value;
-
-	        while (pos > 0) {
-	            const parent = (pos - 1) >> 1;
-	            const parentValue = this.values[parent];
-	            if (value >= parentValue) break;
-	            this.ids[pos] = this.ids[parent];
-	            this.values[pos] = parentValue;
-	            pos = parent;
-	        }
-
-	        this.ids[pos] = id;
-	        this.values[pos] = value;
-	    }
-
-	    pop() {
-	        if (this.length === 0) return undefined;
-
-	        const top = this.ids[0];
-	        this.length--;
-
-	        if (this.length > 0) {
-	            const id = this.ids[0] = this.ids[this.length];
-	            const value = this.values[0] = this.values[this.length];
-	            const halfLength = this.length >> 1;
-	            let pos = 0;
-
-	            while (pos < halfLength) {
-	                let left = (pos << 1) + 1;
-	                const right = left + 1;
-	                let bestIndex = this.ids[left];
-	                let bestValue = this.values[left];
-	                const rightValue = this.values[right];
-
-	                if (right < this.length && rightValue < bestValue) {
-	                    left = right;
-	                    bestIndex = this.ids[right];
-	                    bestValue = rightValue;
-	                }
-	                if (bestValue >= value) break;
-
-	                this.ids[pos] = bestIndex;
-	                this.values[pos] = bestValue;
-	                pos = left;
-	            }
-
-	            this.ids[pos] = id;
-	            this.values[pos] = value;
-	        }
-
-	        return top;
-	    }
-
-	    peek() {
-	        return this.ids[0];
-	    }
-
-	    peekValue() {
-	        return this.values[0];
-	    }
-	}
-
-	const ARRAY_TYPES = [
-	    Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array,
-	    Int32Array, Uint32Array, Float32Array, Float64Array
-	];
-
-	const VERSION = 3; // serialized format version
-
-	class Flatbush {
-
-	    static from(data) {
-	        if (!(data instanceof ArrayBuffer)) {
-	            throw new Error('Data must be an instance of ArrayBuffer.');
-	        }
-	        const [magic, versionAndType] = new Uint8Array(data, 0, 2);
-	        if (magic !== 0xfb) {
-	            throw new Error('Data does not appear to be in a Flatbush format.');
-	        }
-	        if (versionAndType >> 4 !== VERSION) {
-	            throw new Error(`Got v${versionAndType >> 4} data when expected v${VERSION}.`);
-	        }
-	        const [nodeSize] = new Uint16Array(data, 2, 1);
-	        const [numItems] = new Uint32Array(data, 4, 1);
-
-	        return new Flatbush(numItems, nodeSize, ARRAY_TYPES[versionAndType & 0x0f], data);
-	    }
-
-	    constructor(numItems, nodeSize = 16, ArrayType = Float64Array, data) {
-	        if (numItems === undefined) throw new Error('Missing required argument: numItems.');
-	        if (isNaN(numItems) || numItems <= 0) throw new Error(`Unpexpected numItems value: ${numItems}.`);
-
-	        this.numItems = +numItems;
-	        this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
-
-	        // calculate the total number of nodes in the R-tree to allocate space for
-	        // and the index of each tree level (used in search later)
-	        let n = numItems;
-	        let numNodes = n;
-	        this._levelBounds = [n * 4];
-	        do {
-	            n = Math.ceil(n / this.nodeSize);
-	            numNodes += n;
-	            this._levelBounds.push(numNodes * 4);
-	        } while (n !== 1);
-
-	        this.ArrayType = ArrayType || Float64Array;
-	        this.IndexArrayType = numNodes < 16384 ? Uint16Array : Uint32Array;
-
-	        const arrayTypeIndex = ARRAY_TYPES.indexOf(this.ArrayType);
-	        const nodesByteSize = numNodes * 4 * this.ArrayType.BYTES_PER_ELEMENT;
-
-	        if (arrayTypeIndex < 0) {
-	            throw new Error(`Unexpected typed array class: ${ArrayType}.`);
-	        }
-
-	        if (data && (data instanceof ArrayBuffer)) {
-	            this.data = data;
-	            this._boxes = new this.ArrayType(this.data, 8, numNodes * 4);
-	            this._indices = new this.IndexArrayType(this.data, 8 + nodesByteSize, numNodes);
-
-	            this._pos = numNodes * 4;
-	            this.minX = this._boxes[this._pos - 4];
-	            this.minY = this._boxes[this._pos - 3];
-	            this.maxX = this._boxes[this._pos - 2];
-	            this.maxY = this._boxes[this._pos - 1];
-
-	        } else {
-	            this.data = new ArrayBuffer(8 + nodesByteSize + numNodes * this.IndexArrayType.BYTES_PER_ELEMENT);
-	            this._boxes = new this.ArrayType(this.data, 8, numNodes * 4);
-	            this._indices = new this.IndexArrayType(this.data, 8 + nodesByteSize, numNodes);
-	            this._pos = 0;
-	            this.minX = Infinity;
-	            this.minY = Infinity;
-	            this.maxX = -Infinity;
-	            this.maxY = -Infinity;
-
-	            new Uint8Array(this.data, 0, 2).set([0xfb, (VERSION << 4) + arrayTypeIndex]);
-	            new Uint16Array(this.data, 2, 1)[0] = nodeSize;
-	            new Uint32Array(this.data, 4, 1)[0] = numItems;
-	        }
-
-	        // a priority queue for k-nearest-neighbors queries
-	        this._queue = new FlatQueue();
-	    }
-
-	    add(minX, minY, maxX, maxY) {
-	        const index = this._pos >> 2;
-	        this._indices[index] = index;
-	        this._boxes[this._pos++] = minX;
-	        this._boxes[this._pos++] = minY;
-	        this._boxes[this._pos++] = maxX;
-	        this._boxes[this._pos++] = maxY;
-
-	        if (minX < this.minX) this.minX = minX;
-	        if (minY < this.minY) this.minY = minY;
-	        if (maxX > this.maxX) this.maxX = maxX;
-	        if (maxY > this.maxY) this.maxY = maxY;
-
-	        return index;
-	    }
-
-	    finish() {
-	        if (this._pos >> 2 !== this.numItems) {
-	            throw new Error(`Added ${this._pos >> 2} items when expected ${this.numItems}.`);
-	        }
-
-	        const width = this.maxX - this.minX;
-	        const height = this.maxY - this.minY;
-	        const hilbertValues = new Uint32Array(this.numItems);
-	        const hilbertMax = (1 << 16) - 1;
-
-	        // map item centers into Hilbert coordinate space and calculate Hilbert values
-	        for (let i = 0; i < this.numItems; i++) {
-	            let pos = 4 * i;
-	            const minX = this._boxes[pos++];
-	            const minY = this._boxes[pos++];
-	            const maxX = this._boxes[pos++];
-	            const maxY = this._boxes[pos++];
-	            const x = Math.floor(hilbertMax * ((minX + maxX) / 2 - this.minX) / width);
-	            const y = Math.floor(hilbertMax * ((minY + maxY) / 2 - this.minY) / height);
-	            hilbertValues[i] = hilbert(x, y);
-	        }
-
-	        // sort items by their Hilbert value (for packing later)
-	        sort(hilbertValues, this._boxes, this._indices, 0, this.numItems - 1);
-
-	        // generate nodes at each tree level, bottom-up
-	        for (let i = 0, pos = 0; i < this._levelBounds.length - 1; i++) {
-	            const end = this._levelBounds[i];
-
-	            // generate a parent node for each block of consecutive <nodeSize> nodes
-	            while (pos < end) {
-	                let nodeMinX = Infinity;
-	                let nodeMinY = Infinity;
-	                let nodeMaxX = -Infinity;
-	                let nodeMaxY = -Infinity;
-	                const nodeIndex = pos;
-
-	                // calculate bbox for the new node
-	                for (let i = 0; i < this.nodeSize && pos < end; i++) {
-	                    const minX = this._boxes[pos++];
-	                    const minY = this._boxes[pos++];
-	                    const maxX = this._boxes[pos++];
-	                    const maxY = this._boxes[pos++];
-	                    if (minX < nodeMinX) nodeMinX = minX;
-	                    if (minY < nodeMinY) nodeMinY = minY;
-	                    if (maxX > nodeMaxX) nodeMaxX = maxX;
-	                    if (maxY > nodeMaxY) nodeMaxY = maxY;
-	                }
-
-	                // add the new node to the tree data
-	                this._indices[this._pos >> 2] = nodeIndex;
-	                this._boxes[this._pos++] = nodeMinX;
-	                this._boxes[this._pos++] = nodeMinY;
-	                this._boxes[this._pos++] = nodeMaxX;
-	                this._boxes[this._pos++] = nodeMaxY;
-	            }
-	        }
-	    }
-
-	    search(minX, minY, maxX, maxY, filterFn) {
-	        if (this._pos !== this._boxes.length) {
-	            throw new Error('Data not yet indexed - call index.finish().');
-	        }
-
-	        let nodeIndex = this._boxes.length - 4;
-	        let level = this._levelBounds.length - 1;
-	        const queue = [];
-	        const results = [];
-
-	        while (nodeIndex !== undefined) {
-	            // find the end index of the node
-	            const end = Math.min(nodeIndex + this.nodeSize * 4, this._levelBounds[level]);
-
-	            // search through child nodes
-	            for (let pos = nodeIndex; pos < end; pos += 4) {
-	                const index = this._indices[pos >> 2] | 0;
-
-	                // check if node bbox intersects with query bbox
-	                if (maxX < this._boxes[pos]) continue; // maxX < nodeMinX
-	                if (maxY < this._boxes[pos + 1]) continue; // maxY < nodeMinY
-	                if (minX > this._boxes[pos + 2]) continue; // minX > nodeMaxX
-	                if (minY > this._boxes[pos + 3]) continue; // minY > nodeMaxY
-
-	                if (nodeIndex < this.numItems * 4) {
-	                    if (filterFn === undefined || filterFn(index)) {
-	                        results.push(index); // leaf item
-	                    }
-
-	                } else {
-	                    queue.push(index); // node; add it to the search queue
-	                    queue.push(level - 1);
-	                }
-	            }
-
-	            level = queue.pop();
-	            nodeIndex = queue.pop();
-	        }
-
-	        return results;
-	    }
-
-	    neighbors(x, y, maxResults = Infinity, maxDistance = Infinity, filterFn) {
-	        if (this._pos !== this._boxes.length) {
-	            throw new Error('Data not yet indexed - call index.finish().');
-	        }
-
-	        let nodeIndex = this._boxes.length - 4;
-	        const q = this._queue;
-	        const results = [];
-	        const maxDistSquared = maxDistance * maxDistance;
-
-	        while (nodeIndex !== undefined) {
-	            // find the end index of the node
-	            const end = Math.min(nodeIndex + this.nodeSize * 4, upperBound(nodeIndex, this._levelBounds));
-
-	            // add child nodes to the queue
-	            for (let pos = nodeIndex; pos < end; pos += 4) {
-	                const index = this._indices[pos >> 2] | 0;
-
-	                const dx = axisDist(x, this._boxes[pos], this._boxes[pos + 2]);
-	                const dy = axisDist(y, this._boxes[pos + 1], this._boxes[pos + 3]);
-	                const dist = dx * dx + dy * dy;
-
-	                if (nodeIndex < this.numItems * 4) { // leaf node
-	                    if (filterFn === undefined || filterFn(index)) {
-	                        // put a negative index if it's an item rather than a node, to recognize later
-	                        q.push(-index - 1, dist);
-	                    }
-	                } else {
-	                    q.push(index, dist);
-	                }
-	            }
-
-	            // pop items from the queue
-	            while (q.length && q.peek() < 0) {
-	                const dist = q.peekValue();
-	                if (dist > maxDistSquared) {
-	                    q.clear();
-	                    return results;
-	                }
-	                results.push(-q.pop() - 1);
-
-	                if (results.length === maxResults) {
-	                    q.clear();
-	                    return results;
-	                }
-	            }
-
-	            nodeIndex = q.pop();
-	        }
-
-	        q.clear();
-	        return results;
-	    }
-	}
-
-	function axisDist(k, min, max) {
-	    return k < min ? min - k : k <= max ? 0 : k - max;
-	}
-
-	// binary search for the first value in the array bigger than the given
-	function upperBound(value, arr) {
-	    let i = 0;
-	    let j = arr.length - 1;
-	    while (i < j) {
-	        const m = (i + j) >> 1;
-	        if (arr[m] > value) {
-	            j = m;
-	        } else {
-	            i = m + 1;
-	        }
-	    }
-	    return arr[i];
-	}
-
-	// custom quicksort that sorts bbox data alongside the hilbert values
-	function sort(values, boxes, indices, left, right) {
-	    if (left >= right) return;
-
-	    const pivot = values[(left + right) >> 1];
-	    let i = left - 1;
-	    let j = right + 1;
-
-	    while (true) {
-	        do i++; while (values[i] < pivot);
-	        do j--; while (values[j] > pivot);
-	        if (i >= j) break;
-	        swap$1(values, boxes, indices, i, j);
-	    }
-
-	    sort(values, boxes, indices, left, j);
-	    sort(values, boxes, indices, j + 1, right);
-	}
-
-	// swap two values and two corresponding boxes
-	function swap$1(values, boxes, indices, i, j) {
-	    const temp = values[i];
-	    values[i] = values[j];
-	    values[j] = temp;
-
-	    const k = 4 * i;
-	    const m = 4 * j;
-
-	    const a = boxes[k];
-	    const b = boxes[k + 1];
-	    const c = boxes[k + 2];
-	    const d = boxes[k + 3];
-	    boxes[k] = boxes[m];
-	    boxes[k + 1] = boxes[m + 1];
-	    boxes[k + 2] = boxes[m + 2];
-	    boxes[k + 3] = boxes[m + 3];
-	    boxes[m] = a;
-	    boxes[m + 1] = b;
-	    boxes[m + 2] = c;
-	    boxes[m + 3] = d;
-
-	    const e = indices[i];
-	    indices[i] = indices[j];
-	    indices[j] = e;
-	}
-
-	// Fast Hilbert curve algorithm by http://threadlocalmutex.com/
-	// Ported from C++ https://github.com/rawrunprotected/hilbert_curves (public domain)
-	function hilbert(x, y) {
-	    let a = x ^ y;
-	    let b = 0xFFFF ^ a;
-	    let c = 0xFFFF ^ (x | y);
-	    let d = x & (y ^ 0xFFFF);
-
-	    let A = a | (b >> 1);
-	    let B = (a >> 1) ^ a;
-	    let C = ((c >> 1) ^ (b & (d >> 1))) ^ c;
-	    let D = ((a & (c >> 1)) ^ (d >> 1)) ^ d;
-
-	    a = A; b = B; c = C; d = D;
-	    A = ((a & (a >> 2)) ^ (b & (b >> 2)));
-	    B = ((a & (b >> 2)) ^ (b & ((a ^ b) >> 2)));
-	    C ^= ((a & (c >> 2)) ^ (b & (d >> 2)));
-	    D ^= ((b & (c >> 2)) ^ ((a ^ b) & (d >> 2)));
-
-	    a = A; b = B; c = C; d = D;
-	    A = ((a & (a >> 4)) ^ (b & (b >> 4)));
-	    B = ((a & (b >> 4)) ^ (b & ((a ^ b) >> 4)));
-	    C ^= ((a & (c >> 4)) ^ (b & (d >> 4)));
-	    D ^= ((b & (c >> 4)) ^ ((a ^ b) & (d >> 4)));
-
-	    a = A; b = B; c = C; d = D;
-	    C ^= ((a & (c >> 8)) ^ (b & (d >> 8)));
-	    D ^= ((b & (c >> 8)) ^ ((a ^ b) & (d >> 8)));
-
-	    a = C ^ (C >> 1);
-	    b = D ^ (D >> 1);
-
-	    let i0 = x ^ y;
-	    let i1 = b | (0xFFFF ^ (i0 | a));
-
-	    i0 = (i0 | (i0 << 8)) & 0x00FF00FF;
-	    i0 = (i0 | (i0 << 4)) & 0x0F0F0F0F;
-	    i0 = (i0 | (i0 << 2)) & 0x33333333;
-	    i0 = (i0 | (i0 << 1)) & 0x55555555;
-
-	    i1 = (i1 | (i1 << 8)) & 0x00FF00FF;
-	    i1 = (i1 | (i1 << 4)) & 0x0F0F0F0F;
-	    i1 = (i1 | (i1 << 2)) & 0x33333333;
-	    i1 = (i1 | (i1 << 1)) & 0x55555555;
-
-	    return ((i1 << 1) | i0) >>> 0;
-	}
-
 	function sortKD(ids, coords, nodeSize, left, right, depth) {
 	    if (right - left <= nodeSize) return;
 
@@ -34213,7 +33767,6 @@
 	  '@tmcw/togeojson': togeojson,
 	  'geographiclib-geodesic': GeographicLib,
 	  mproj: api,
-	  flatbush: Flatbush,
 	  kdbush: KDBush,
 	  buffer
 	};

package/www/page.css

@@ -23,6 +23,7 @@
 	--colored-text: #10699b;
 	--normal-text: #333;
 	--left-sidebar-width: 420px;
+	--sidebar-panels-separator-position: 50%;
 	--sidebar-resize-col: #f2c65a; /* #d6a51d; */
 }
 
@@ -788,7 +789,7 @@ input[type="checkbox"]
 
 /* --- Sidebar panels ------------ */
 
-.sidebar-panel {
+.sidebar-panels {
 	right: auto;
 	width: var(--left-sidebar-width);
 	max-width: 100%;
@@ -800,6 +801,31 @@ input[type="checkbox"]
 	display: none;
 }
 
+.sidebar-panel {
+	position: relative;
+}
+
+.sidebar-panel:first-child {
+	height: var(--sidebar-panels-separator-position);
+}
+
+.sidebar-panel:last-child {
+	height: calc(100% - var(--sidebar-panels-separator-position));
+}
+
+.sidebar-panels:not(:has(> .sidebar-panel.open ~ .sidebar-panel.open)) > .sidebar-panel.open {
+	height: 100%;
+}
+
+.sidebar-panels:not(:has(> .sidebar-panel.open ~ .sidebar-panel.open)) .sidebar-panels-resize-handle {
+	display: none;
+}
+
+body.sidebar-open .sidebar-panels {
+	display: flex;
+	flex-direction: column;
+}
+
 .console-area {
 	font-size: 12px;
 }
@@ -845,6 +871,39 @@ body.sidebar-resizing .sidebar-resize-handle::before,
 	background-color: var(--sidebar-resize-col);
 }
 
+.sidebar-panels-resize-handle {
+	display: block;
+	position: absolute;
+	left: 0;
+	right: 0;
+	top: -4px;
+	height: 8px;
+	z-index: 35;
+	cursor: ns-resize;
+	pointer-events: auto;
+}
+
+.sidebar-panels-resize-handle::before {
+	content: "";
+	position: absolute;
+	left: 0;
+	right: 0;
+	top: 3px;
+	height: 2px;
+	background-color: transparent;
+}
+
+body.sidebar-panels-resizing,
+body.sidebar-panels-resizing * {
+	cursor: ns-resize !important;
+	user-select: none;
+}
+
+body.sidebar-panels-resizing .sidebar-panels-resize-handle::before,
+.sidebar-panels-resize-handle:hover::before {
+	background-color: var(--sidebar-resize-col);
+}
+
 /* Give the console a little more line length on wide screens. */
 @media screen and (max-width: 525px) {
 	body.sidebar-open .map-area {

package/www/sponsor.html

@@ -36,6 +36,7 @@
 
 <h2>Recent work</h2>
 <ul class="support-list">
+  <li><strong>Buffer command</strong> &mdash; Geodesic and planar buffering for points, lines and polygons</li>
   <li><strong>Raster importing</strong> &mdash; GeoTIFF + georeferenced JPEG and PNG</li>
   <li><strong>Undo/redo</strong> in the browser &mdash; the most requested feature</li>
   <li><strong>New vector formats</strong> &mdash; GeoParquet, GeoPackage and FlatGeobuf</li>