@maplibre/geojson-vt 5.0.0

package/dist/geojson-vt.js

@@ -0,0 +1 @@
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).geojsonvt=e()}(this,(function(){"use strict";function t(n,o,i,s){let r=s;const l=o+(i-o>>1);let u,a=i-o;const f=n[o],c=n[o+1],m=n[i],d=n[i+1];for(let t=o+3;t<i;t+=3){const o=e(n[t],n[t+1],f,c,m,d);if(o>r)u=t,r=o;else if(o===r){const e=Math.abs(t-l);e<a&&(u=t,a=e)}}r>s&&(u-o>3&&t(n,o,u,s),n[u+2]=r,i-u>3&&t(n,u,i,s))}function e(t,e,n,o,i,s){let r=i-n,l=s-o;if(0!==r||0!==l){const u=((t-n)*r+(e-o)*l)/(r*r+l*l);u>1?(n=i,o=s):u>0&&(n+=r*u,o+=l*u)}return r=t-n,l=e-o,r*r+l*l}function n(t,e,n,i){const s={id:null==t?null:t,type:e,geometry:n,tags:i,minX:1/0,minY:1/0,maxX:-1/0,maxY:-1/0};if("Point"===e||"MultiPoint"===e||"LineString"===e)o(s,n);else if("Polygon"===e)o(s,n[0]);else if("MultiLineString"===e)for(const t of n)o(s,t);else if("MultiPolygon"===e)for(const t of n)o(s,t[0]);return s}function o(t,e){for(let n=0;n<e.length;n+=3)t.minX=Math.min(t.minX,e[n]),t.minY=Math.min(t.minY,e[n+1]),t.maxX=Math.max(t.maxX,e[n]),t.maxY=Math.max(t.maxY,e[n+1])}function i(t,e){const n=[];if("FeatureCollection"===t.type)for(let o=0;o<t.features.length;o++)s(n,t.features[o],e,o);else"Feature"===t.type?s(n,t,e):s(n,{geometry:t},e);return n}function s(t,e,o,i){if(!e.geometry)return;const a=e.geometry.coordinates;if(a&&0===a.length)return;const f=e.geometry.type,c=Math.pow(o.tolerance/((1<<o.maxZoom)*o.extent),2);let m=[],d=e.id;if(o.promoteId?d=e.properties[o.promoteId]:o.generateId&&(d=i||0),"Point"===f)r(a,m);else if("MultiPoint"===f)for(const t of a)r(t,m);else if("LineString"===f)l(a,m,c,!1);else if("MultiLineString"===f){if(o.lineMetrics){for(const o of a)m=[],l(o,m,c,!1),t.push(n(d,"LineString",m,e.properties));return}u(a,m,c,!1)}else if("Polygon"===f)u(a,m,c,!0);else{if("MultiPolygon"!==f){if("GeometryCollection"===f){for(const n of e.geometry.geometries)s(t,{id:d,geometry:n,properties:e.properties},o,i);return}throw new Error("Input data is not a valid GeoJSON object.")}for(const t of a){const e=[];u(t,e,c,!0),m.push(e)}}t.push(n(d,f,m,e.properties))}function r(t,e){e.push(a(t[0]),f(t[1]),0)}function l(e,n,o,i){let s,r,l=0;for(let t=0;t<e.length;t++){const o=a(e[t][0]),u=f(e[t][1]);n.push(o,u,0),t>0&&(l+=i?(s*u-o*r)/2:Math.sqrt(Math.pow(o-s,2)+Math.pow(u-r,2))),s=o,r=u}const u=n.length-3;n[2]=1,o>0&&t(n,0,u,o),n[u+2]=1,n.size=Math.abs(l),n.start=0,n.end=n.size}function u(t,e,n,o){for(let i=0;i<t.length;i++){const s=[];l(t[i],s,n,o),e.push(s)}}function a(t){return t/360+.5}function f(t){const e=Math.sin(t*Math.PI/180),n=.5-.25*Math.log((1+e)/(1-e))/Math.PI;return n<0?0:n>1?1:n}function c(t,e,o,i,s,r,l,u){if(i/=e,r>=(o/=e)&&l<i)return t;if(l<o||r>=i)return null;const a=[];for(const e of t){const t=e.geometry;let r=e.type;const l=0===s?e.minX:e.minY,f=0===s?e.maxX:e.maxY;if(l>=o&&f<i){a.push(e);continue}if(f<o||l>=i)continue;let c=[];if("Point"===r||"MultiPoint"===r)m(t,c,o,i,s);else if("LineString"===r)d(t,c,o,i,s,!1,u.lineMetrics);else if("MultiLineString"===r)p(t,c,o,i,s,!1);else if("Polygon"===r)p(t,c,o,i,s,!0);else if("MultiPolygon"===r)for(const e of t){const t=[];p(e,t,o,i,s,!0),t.length&&c.push(t)}if(c.length){if(u.lineMetrics&&"LineString"===r){for(const t of c)a.push(n(e.id,r,t,e.tags));continue}"LineString"!==r&&"MultiLineString"!==r||(1===c.length?(r="LineString",c=c[0]):r="MultiLineString"),"Point"!==r&&"MultiPoint"!==r||(r=3===c.length?"Point":"MultiPoint"),a.push(n(e.id,r,c,e.tags))}}return a.length?a:null}function m(t,e,n,o,i){for(let s=0;s<t.length;s+=3){const r=t[s+i];r>=n&&r<=o&&g(e,t[s],t[s+1],t[s+2])}}function d(t,e,n,o,i,s,r){let l=h(t);const u=0===i?x:M;let a,f,c=t.start;for(let m=0;m<t.length-3;m+=3){const d=t[m],p=t[m+1],x=t[m+2],M=t[m+3],y=t[m+4],P=0===i?d:p,S=0===i?M:y;let z=!1;r&&(a=Math.sqrt(Math.pow(d-M,2)+Math.pow(p-y,2))),P<n?S>n&&(f=u(l,d,p,M,y,n),r&&(l.start=c+a*f)):P>o?S<o&&(f=u(l,d,p,M,y,o),r&&(l.start=c+a*f)):g(l,d,p,x),S<n&&P>=n&&(f=u(l,d,p,M,y,n),z=!0),S>o&&P<=o&&(f=u(l,d,p,M,y,o),z=!0),!s&&z&&(r&&(l.end=c+a*f),e.push(l),l=h(t)),r&&(c+=a)}let m=t.length-3;const d=t[m],p=t[m+1],y=t[m+2],P=0===i?d:p;P>=n&&P<=o&&g(l,d,p,y),m=l.length-3,s&&m>=3&&(l[m]!==l[0]||l[m+1]!==l[1])&&g(l,l[0],l[1],l[2]),l.length&&e.push(l)}function h(t){const e=[];return e.size=t.size,e.start=t.start,e.end=t.end,e}function p(t,e,n,o,i,s){for(const r of t)d(r,e,n,o,i,s,!1)}function g(t,e,n,o){t.push(e,n,o)}function x(t,e,n,o,i,s){const r=(s-e)/(o-e);return g(t,s,n+(i-n)*r,1),r}function M(t,e,n,o,i,s){const r=(s-n)/(i-n);return g(t,e+(o-e)*r,s,1),r}function y(t,e){const n=e.buffer/e.extent;let o=t;const i=c(t,1,-1-n,n,0,-1,2,e),s=c(t,1,1-n,2+n,0,-1,2,e);return(i||s)&&(o=c(t,1,-n,1+n,0,-1,2,e)||[],i&&(o=P(i,1).concat(o)),s&&(o=o.concat(P(s,-1)))),o}function P(t,e){const o=[];for(let i=0;i<t.length;i++){const s=t[i],r=s.type;let l;if("Point"===r||"MultiPoint"===r||"LineString"===r)l=S(s.geometry,e);else if("MultiLineString"===r||"Polygon"===r){l=[];for(const t of s.geometry)l.push(S(t,e))}else if("MultiPolygon"===r){l=[];for(const t of s.geometry){const n=[];for(const o of t)n.push(S(o,e));l.push(n)}}o.push(n(s.id,r,l,s.tags))}return o}function S(t,e){const n=[];n.size=t.size,void 0!==t.start&&(n.start=t.start,n.end=t.end);for(let o=0;o<t.length;o+=3)n.push(t[o]+e,t[o+1],t[o+2]);return n}function z(t,e){if(t.transformed)return t;const n=1<<t.z,o=t.x,i=t.y;for(const s of t.features){const t=s.geometry,r=s.type;if(s.geometry=[],1===r)for(let r=0;r<t.length;r+=2)s.geometry.push(Y(t[r],t[r+1],e,n,o,i));else for(let r=0;r<t.length;r++){const l=[];for(let s=0;s<t[r].length;s+=2)l.push(Y(t[r][s],t[r][s+1],e,n,o,i));s.geometry.push(l)}}return t.transformed=!0,t}function Y(t,e,n,o,i,s){return[Math.round(n*(t*o-i)),Math.round(n*(e*o-s))]}function b(t,e,n,o,i){const s=e===i.maxZoom?0:i.tolerance/((1<<e)*i.extent),r={features:[],numPoints:0,numSimplified:0,numFeatures:t.length,source:null,x:n,y:o,z:e,transformed:!1,minX:2,minY:1,maxX:-1,maxY:0};for(const e of t)v(r,e,s,i);return r}function v(t,e,n,o){const i=e.geometry,s=e.type,r=[];if(t.minX=Math.min(t.minX,e.minX),t.minY=Math.min(t.minY,e.minY),t.maxX=Math.max(t.maxX,e.maxX),t.maxY=Math.max(t.maxY,e.maxY),"Point"===s||"MultiPoint"===s)for(let e=0;e<i.length;e+=3)r.push(i[e],i[e+1]),t.numPoints++,t.numSimplified++;else if("LineString"===s)w(r,i,t,n,!1,!1);else if("MultiLineString"===s||"Polygon"===s)for(let e=0;e<i.length;e++)w(r,i[e],t,n,"Polygon"===s,0===e);else if("MultiPolygon"===s)for(let e=0;e<i.length;e++){const o=i[e];for(let e=0;e<o.length;e++)w(r,o[e],t,n,!0,0===e)}if(r.length){let n=e.tags||null;if("LineString"===s&&o.lineMetrics){n={};for(const t in e.tags)n[t]=e.tags[t];n.mapbox_clip_start=i.start/i.size,n.mapbox_clip_end=i.end/i.size}const l={geometry:r,type:"Polygon"===s||"MultiPolygon"===s?3:"LineString"===s||"MultiLineString"===s?2:1,tags:n};null!==e.id&&(l.id=e.id),t.features.push(l)}}function w(t,e,n,o,i,s){const r=o*o;if(o>0&&e.size<(i?r:o))return void(n.numPoints+=e.length/3);const l=[];for(let t=0;t<e.length;t+=3)(0===o||e[t+2]>r)&&(n.numSimplified++,l.push(e[t],e[t+1])),n.numPoints++;i&&function(t,e){let n=0;for(let e=0,o=t.length,i=o-2;e<o;i=e,e+=2)n+=(t[e]-t[i])*(t[e+1]+t[i+1]);if(n>0===e)for(let e=0,n=t.length;e<n/2;e+=2){const o=t[e],i=t[e+1];t[e]=t[n-2-e],t[e+1]=t[n-1-e],t[n-2-e]=o,t[n-1-e]=i}}(l,s),t.push(l)}function X(t,e,n){const o=function(t){if(!t)return{};const e={};return e.removeAll=t.removeAll,e.remove=new Set(t.remove||[]),e.add=new Map(t.add?.map((t=>[t.id,t]))),e.update=new Map(t.update?.map((t=>[t.id,t]))),e}(e);let s=[];if(o.removeAll&&(s=t,t=[]),o.remove.size||o.add.size){const e=[];for(const n of t){const{id:t}=n;(o.remove.has(t)||o.add.has(t))&&e.push(n)}if(e.length){s.push(...e);const n=new Set(e.map((t=>t.id)));t=t.filter((t=>!n.has(t.id)))}if(o.add.size){let e=i({type:"FeatureCollection",features:Array.from(o.add.values())},n);e=y(e,n),s.push(...e),t.push(...e)}}if(o.update.size)for(const[e,i]of o.update){const o=t.findIndex((t=>t.id===e));if(-1===o)continue;const r=t[o],l=L(r,i,n);l&&(s.push(r,l),t[o]=l)}return{affected:s,source:t}}function L(t,e,n){const o=!!e.newGeometry,s=e.removeAllProperties||e.removeProperties?.length>0||e.addOrUpdateProperties?.length>0;if(!o&&!s)return null;if(o){let o=i({type:"FeatureCollection",features:[{type:"Feature",id:t.id,geometry:e.newGeometry,properties:s?I(t.tags,e):t.tags}]},n);return o=y(o,n),o[0]}if(s){const n={...t};return n.tags=I(n.tags,e),n}return null}function I(t,e){if(e.removeAllProperties)return{};const n={...t||{}};if(e.removeProperties)for(const t of e.removeProperties)delete n[t];if(e.addOrUpdateProperties)for(const{key:t,value:o}of e.addOrUpdateProperties)n[t]=o;return n}const Z={maxZoom:14,indexMaxZoom:5,indexMaxPoints:1e5,tolerance:3,extent:4096,buffer:64,lineMetrics:!1,promoteId:null,generateId:!1,updateable:!1,debug:0};class E{constructor(t,e){const n=(e=this.options=function(t,e){for(const n in e)t[n]=e[n];return t}(Object.create(Z),e)).debug;if(n&&console.time("preprocess data"),e.maxZoom<0||e.maxZoom>24)throw new Error("maxZoom should be in the 0-24 range");if(e.promoteId&&e.generateId)throw new Error("promoteId and generateId cannot be used together.");let o=i(t,e);this.tiles={},this.tileCoords=[],n&&(console.timeEnd("preprocess data"),console.log("index: maxZoom: %d, maxPoints: %d",e.indexMaxZoom,e.indexMaxPoints),console.time("generate tiles"),this.stats={},this.total=0),o=y(o,e),o.length&&this.splitTile(o,0,0,0),e.updateable&&(this.source=o),n&&(o.length&&console.log("features: %d, points: %d",this.tiles[0].numFeatures,this.tiles[0].numPoints),console.timeEnd("generate tiles"),console.log("tiles generated:",this.total,JSON.stringify(this.stats)))}splitTile(t,e,n,o,i,s,r){const l=[t,e,n,o],u=this.options,a=u.debug;for(;l.length;){o=l.pop(),n=l.pop(),e=l.pop(),t=l.pop();const f=1<<e,m=C(e,n,o);let d=this.tiles[m];if(!d&&(a>1&&console.time("creation"),d=this.tiles[m]=b(t,e,n,o,u),this.tileCoords.push({z:e,x:n,y:o,id:m}),a)){a>1&&(console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)",e,n,o,d.numFeatures,d.numPoints,d.numSimplified),console.timeEnd("creation"));const t=`z${e}`;this.stats[t]=(this.stats[t]||0)+1,this.total++}if(d.source=t,null==i){if(e===u.indexMaxZoom||d.numPoints<=u.indexMaxPoints)continue}else{if(e===u.maxZoom||e===i)continue;if(null!=i){const t=i-e;if(n!==s>>t||o!==r>>t)continue}}if(d.source=null,0===t.length)continue;a>1&&console.time("clipping");const h=.5*u.buffer/u.extent,p=.5-h,g=.5+h,x=1+h;let M=null,y=null,P=null,S=null;const z=c(t,f,n-h,n+g,0,d.minX,d.maxX,u),Y=c(t,f,n+p,n+x,0,d.minX,d.maxX,u);z&&(M=c(z,f,o-h,o+g,1,d.minY,d.maxY,u),y=c(z,f,o+p,o+x,1,d.minY,d.maxY,u)),Y&&(P=c(Y,f,o-h,o+g,1,d.minY,d.maxY,u),S=c(Y,f,o+p,o+x,1,d.minY,d.maxY,u)),a>1&&console.timeEnd("clipping"),l.push(M||[],e+1,2*n,2*o),l.push(y||[],e+1,2*n,2*o+1),l.push(P||[],e+1,2*n+1,2*o),l.push(S||[],e+1,2*n+1,2*o+1)}}getTile(t,e,n){t=+t,e=+e,n=+n;const o=this.options,{extent:i,debug:s}=o;if(t<0||t>24)return null;const r=1<<t,l=C(t,e=e+r&r-1,n);if(this.tiles[l])return z(this.tiles[l],i);s>1&&console.log("drilling down to z%d-%d-%d",t,e,n);let u,a=t,f=e,c=n;for(;!u&&a>0;)a--,f>>=1,c>>=1,u=this.tiles[C(a,f,c)];return u&&u.source?(s>1&&(console.log("found parent tile z%d-%d-%d",a,f,c),console.time("drilling down")),this.splitTile(u.source,a,f,c,t,e,n),s>1&&console.timeEnd("drilling down"),this.tiles[l]?z(this.tiles[l],i):null):null}invalidateTiles(t){const e=this.options,{debug:n}=e;let o=1/0,i=-1/0,s=1/0,r=-1/0;for(const e of t)o=Math.min(o,e.minX),i=Math.max(i,e.maxX),s=Math.min(s,e.minY),r=Math.max(r,e.maxY);const l=e.buffer/e.extent,u=new Set;for(const e in this.tiles){const a=this.tiles[e],f=1<<a.z,c=(a.x-l)/f,m=(a.x+1+l)/f,d=(a.y-l)/f,h=(a.y+1+l)/f;if(i<c||o>=m||r<d||s>=h)continue;let p=!1;for(const e of t)if(e.maxX>=c&&e.minX<m&&e.maxY>=d&&e.minY<h){p=!0;break}if(p){if(n){n>1&&console.log("invalidate tile z%d-%d-%d (features: %d, points: %d, simplified: %d)",a.z,a.x,a.y,a.numFeatures,a.numPoints,a.numSimplified);const t=`z${a.z}`;this.stats[t]=(this.stats[t]||0)-1,this.total--}delete this.tiles[e],u.add(e)}}u.size&&(this.tileCoords=this.tileCoords.filter((t=>!u.has(t.id))))}updateData(t){const e=this.options,n=e.debug;if(!e.updateable)throw new Error("to update tile geojson `updateable` option must be set to true");const{affected:o,source:i}=X(this.source,t,e);if(!o.length)return;this.source=i,n>1&&(console.log("invalidating tiles"),console.time("invalidating")),this.invalidateTiles(o),n>1&&console.timeEnd("invalidating");const[s,r,l]=[0,0,0],u=b(this.source,s,r,l,this.options);u.source=this.source;const a=C(s,r,l);if(this.tiles[a]=u,this.tileCoords.push({z:s,x:r,y:l,id:a}),n){const t=`z${s}`;this.stats[t]=(this.stats[t]||0)+1,this.total++}}}function C(t,e,n){return 32*((1<<t)*n+e)+t}return function(t,e){return new E(t,e)}}));

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@maplibre/geojson-vt",
+  "version": "5.0.0",
+  "description": "Slice GeoJSON data into vector tiles efficiently",
+  "type": "module",
+  "exports": "./src/index.js",
+  "sideEffects": false,
+  "keywords": [
+    "spatial",
+    "geojson",
+    "tiles",
+    "geometry"
+  ],
+  "module": "src/index.js",
+  "main": "dist/geojson-vt-dev.js",
+  "jsdelivr": "dist/geojson-vt.js",
+  "unpkg": "dist/geojson-vt.js",
+  "devDependencies": {
+    "@rollup/plugin-terser": "^0.4.4",
+    "benchmark": "^2.1.4",
+    "eslint": "^9.38.0",
+    "eslint-config-mourner": "^4.1.0",
+    "rollup": "^4.18.0"
+  },
+  "license": "ISC",
+  "scripts": {
+    "pretest": "eslint src/*.js test/*.js debug/viz.js",
+    "test": "node --test",
+    "build": "rollup -c",
+    "watch": "rollup -cw",
+    "bench": "node bench/benchmark.js",
+    "prepublishOnly": "npm run test && npm run build"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/maplibre/geojson-vt"
+  }
+}

package/src/clip.js

@@ -0,0 +1,200 @@
+
+import createFeature from './feature.js';
+
+/* clip features between two vertical or horizontal axis-parallel lines:
+ *     |        |
+ *  ___|___     |     /
+ * /   |   \____|____/
+ *     |        |
+ *
+ * k1 and k2 are the line coordinates
+ * axis: 0 for x, 1 for y
+ * minAll and maxAll: minimum and maximum coordinate value for all features
+ */
+export default function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
+    k1 /= scale;
+    k2 /= scale;
+
+    if (minAll >= k1 && maxAll < k2) return features; // trivial accept
+    else if (maxAll < k1 || minAll >= k2) return null; // trivial reject
+
+    const clipped = [];
+
+    for (const feature of features) {
+        const geometry = feature.geometry;
+        let type = feature.type;
+
+        const min = axis === 0 ? feature.minX : feature.minY;
+        const max = axis === 0 ? feature.maxX : feature.maxY;
+
+        if (min >= k1 && max < k2) { // trivial accept
+            clipped.push(feature);
+            continue;
+        } else if (max < k1 || min >= k2) { // trivial reject
+            continue;
+        }
+
+        let newGeometry = [];
+
+        if (type === 'Point' || type === 'MultiPoint') {
+            clipPoints(geometry, newGeometry, k1, k2, axis);
+
+        } else if (type === 'LineString') {
+            clipLine(geometry, newGeometry, k1, k2, axis, false, options.lineMetrics);
+
+        } else if (type === 'MultiLineString') {
+            clipLines(geometry, newGeometry, k1, k2, axis, false);
+
+        } else if (type === 'Polygon') {
+            clipLines(geometry, newGeometry, k1, k2, axis, true);
+
+        } else if (type === 'MultiPolygon') {
+            for (const polygon of geometry) {
+                const newPolygon = [];
+                clipLines(polygon, newPolygon, k1, k2, axis, true);
+                if (newPolygon.length) {
+                    newGeometry.push(newPolygon);
+                }
+            }
+        }
+
+        if (newGeometry.length) {
+            if (options.lineMetrics && type === 'LineString') {
+                for (const line of newGeometry) {
+                    clipped.push(createFeature(feature.id, type, line, feature.tags));
+                }
+                continue;
+            }
+
+            if (type === 'LineString' || type === 'MultiLineString') {
+                if (newGeometry.length === 1) {
+                    type = 'LineString';
+                    newGeometry = newGeometry[0];
+                } else {
+                    type = 'MultiLineString';
+                }
+            }
+            if (type === 'Point' || type === 'MultiPoint') {
+                type = newGeometry.length === 3 ? 'Point' : 'MultiPoint';
+            }
+
+            clipped.push(createFeature(feature.id, type, newGeometry, feature.tags));
+        }
+    }
+
+    return clipped.length ? clipped : null;
+}
+
+function clipPoints(geom, newGeom, k1, k2, axis) {
+    for (let i = 0; i < geom.length; i += 3) {
+        const a = geom[i + axis];
+
+        if (a >= k1 && a <= k2) {
+            addPoint(newGeom, geom[i], geom[i + 1], geom[i + 2]);
+        }
+    }
+}
+
+function clipLine(geom, newGeom, k1, k2, axis, isPolygon, trackMetrics) {
+
+    let slice = newSlice(geom);
+    const intersect = axis === 0 ? intersectX : intersectY;
+    let len = geom.start;
+    let segLen, t;
+
+    for (let i = 0; i < geom.length - 3; i += 3) {
+        const ax = geom[i];
+        const ay = geom[i + 1];
+        const az = geom[i + 2];
+        const bx = geom[i + 3];
+        const by = geom[i + 4];
+        const a = axis === 0 ? ax : ay;
+        const b = axis === 0 ? bx : by;
+        let exited = false;
+
+        if (trackMetrics) segLen = Math.sqrt(Math.pow(ax - bx, 2) + Math.pow(ay - by, 2));
+
+        if (a < k1) {
+            // ---|-->  | (line enters the clip region from the left)
+            if (b > k1) {
+                t = intersect(slice, ax, ay, bx, by, k1);
+                if (trackMetrics) slice.start = len + segLen * t;
+            }
+        } else if (a > k2) {
+            // |  <--|--- (line enters the clip region from the right)
+            if (b < k2) {
+                t = intersect(slice, ax, ay, bx, by, k2);
+                if (trackMetrics) slice.start = len + segLen * t;
+            }
+        } else {
+            addPoint(slice, ax, ay, az);
+        }
+        if (b < k1 && a >= k1) {
+            // <--|---  | or <--|-----|--- (line exits the clip region on the left)
+            t = intersect(slice, ax, ay, bx, by, k1);
+            exited = true;
+        }
+        if (b > k2 && a <= k2) {
+            // |  ---|--> or ---|-----|--> (line exits the clip region on the right)
+            t = intersect(slice, ax, ay, bx, by, k2);
+            exited = true;
+        }
+
+        if (!isPolygon && exited) {
+            if (trackMetrics) slice.end = len + segLen * t;
+            newGeom.push(slice);
+            slice = newSlice(geom);
+        }
+
+        if (trackMetrics) len += segLen;
+    }
+
+    // add the last point
+    let last = geom.length - 3;
+    const ax = geom[last];
+    const ay = geom[last + 1];
+    const az = geom[last + 2];
+    const a = axis === 0 ? ax : ay;
+    if (a >= k1 && a <= k2) addPoint(slice, ax, ay, az);
+
+    // close the polygon if its endpoints are not the same after clipping
+    last = slice.length - 3;
+    if (isPolygon && last >= 3 && (slice[last] !== slice[0] || slice[last + 1] !== slice[1])) {
+        addPoint(slice, slice[0], slice[1], slice[2]);
+    }
+
+    // add the final slice
+    if (slice.length) {
+        newGeom.push(slice);
+    }
+}
+
+function newSlice(line) {
+    const slice = [];
+    slice.size = line.size;
+    slice.start = line.start;
+    slice.end = line.end;
+    return slice;
+}
+
+function clipLines(geom, newGeom, k1, k2, axis, isPolygon) {
+    for (const line of geom) {
+        clipLine(line, newGeom, k1, k2, axis, isPolygon, false);
+    }
+}
+
+function addPoint(out, x, y, z) {
+    out.push(x, y, z);
+}
+
+function intersectX(out, ax, ay, bx, by, x) {
+    const t = (x - ax) / (bx - ax);
+    addPoint(out, x, ay + (by - ay) * t, 1);
+    return t;
+}
+
+function intersectY(out, ax, ay, bx, by, y) {
+    const t = (y - ay) / (by - ay);
+    addPoint(out, ax + (bx - ax) * t, y, 1);
+    return t;
+}

package/src/convert.js

@@ -0,0 +1,139 @@
+
+import simplify from './simplify.js';
+import createFeature from './feature.js';
+
+// converts GeoJSON feature into an intermediate projected JSON vector format with simplification data
+
+export default function convert(data, options) {
+    const features = [];
+    if (data.type === 'FeatureCollection') {
+        for (let i = 0; i < data.features.length; i++) {
+            convertFeature(features, data.features[i], options, i);
+        }
+
+    } else if (data.type === 'Feature') {
+        convertFeature(features, data, options);
+
+    } else {
+        // single geometry or a geometry collection
+        convertFeature(features, {geometry: data}, options);
+    }
+
+    return features;
+}
+
+function convertFeature(features, geojson, options, index) {
+    if (!geojson.geometry) return;
+
+    const coords = geojson.geometry.coordinates;
+    if (coords && coords.length === 0) return;
+
+    const type = geojson.geometry.type;
+    const tolerance = Math.pow(options.tolerance / ((1 << options.maxZoom) * options.extent), 2);
+    let geometry = [];
+    let id = geojson.id;
+    if (options.promoteId) {
+        id = geojson.properties[options.promoteId];
+    } else if (options.generateId) {
+        id = index || 0;
+    }
+    if (type === 'Point') {
+        convertPoint(coords, geometry);
+
+    } else if (type === 'MultiPoint') {
+        for (const p of coords) {
+            convertPoint(p, geometry);
+        }
+
+    } else if (type === 'LineString') {
+        convertLine(coords, geometry, tolerance, false);
+
+    } else if (type === 'MultiLineString') {
+        if (options.lineMetrics) {
+            // explode into linestrings to be able to track metrics
+            for (const line of coords) {
+                geometry = [];
+                convertLine(line, geometry, tolerance, false);
+                features.push(createFeature(id, 'LineString', geometry, geojson.properties));
+            }
+            return;
+        }
+        convertLines(coords, geometry, tolerance, false);
+
+    } else if (type === 'Polygon') {
+        convertLines(coords, geometry, tolerance, true);
+
+    } else if (type === 'MultiPolygon') {
+        for (const polygon of coords) {
+            const newPolygon = [];
+            convertLines(polygon, newPolygon, tolerance, true);
+            geometry.push(newPolygon);
+        }
+    } else if (type === 'GeometryCollection') {
+        for (const singleGeometry of geojson.geometry.geometries) {
+            convertFeature(features, {
+                id,
+                geometry: singleGeometry,
+                properties: geojson.properties
+            }, options, index);
+        }
+        return;
+    } else {
+        throw new Error('Input data is not a valid GeoJSON object.');
+    }
+
+    features.push(createFeature(id, type, geometry, geojson.properties));
+}
+
+function convertPoint(coords, out) {
+    out.push(projectX(coords[0]), projectY(coords[1]), 0);
+}
+
+function convertLine(ring, out, tolerance, isPolygon) {
+    let x0, y0;
+    let size = 0;
+
+    for (let j = 0; j < ring.length; j++) {
+        const x = projectX(ring[j][0]);
+        const y = projectY(ring[j][1]);
+
+        out.push(x, y, 0);
+
+        if (j > 0) {
+            if (isPolygon) {
+                size += (x0 * y - x * y0) / 2; // area
+            } else {
+                size += Math.sqrt(Math.pow(x - x0, 2) + Math.pow(y - y0, 2)); // length
+            }
+        }
+        x0 = x;
+        y0 = y;
+    }
+
+    const last = out.length - 3;
+    out[2] = 1;
+    if (tolerance > 0) simplify(out, 0, last, tolerance);
+    out[last + 2] = 1;
+
+    out.size = Math.abs(size);
+    out.start = 0;
+    out.end = out.size;
+}
+
+function convertLines(rings, out, tolerance, isPolygon) {
+    for (let i = 0; i < rings.length; i++) {
+        const geom = [];
+        convertLine(rings[i], geom, tolerance, isPolygon);
+        out.push(geom);
+    }
+}
+
+function projectX(x) {
+    return x / 360 + 0.5;
+}
+
+function projectY(y) {
+    const sin = Math.sin(y * Math.PI / 180);
+    const y2 = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
+    return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
+}

package/src/difference.js

@@ -0,0 +1,180 @@
+import convert from './convert.js'; // GeoJSON conversion and preprocessing
+import wrap from './wrap.js';       // date line processing
+
+// This file provides a set of helper functions for managing "diffs" (changes)
+// to GeoJSON data structures. These diffs describe additions, removals,
+// and updates of features in a GeoJSON source in an efficient way.
+
+// GeoJSON Source Diff:
+// {
+//   removeAll: true,                    // If true, clear all existing features
+//   remove: [featureId, ...],           // Array of feature IDs to remove
+//   add: [feature, ...],                // Array of GeoJSON features to add
+//   update: [GeoJSON Feature Diff, ...]   // Array of per-feature updates
+// }
+
+// GeoJSON Feature Diff:
+// {
+//   id: featureId,                       // ID of the feature being updated
+//   newGeometry: GeoJSON.Geometry,      // Optional new geometry
+//   removeAllProperties: true,          // Remove all properties if true
+//   removeProperties: [key, ...],       // Specific properties to delete
+//   addOrUpdateProperties: [            // Properties to add or update
+//     { key: "name", value: "New name" }
+//   ]
+// }
+
+/* eslint @stylistic/comma-spacing: 0, no-shadow: 0 */
+
+// applies a diff to the geojsonvt source simplified features array
+// returns an object with the affected features and new source array for invalidation
+export function applySourceDiff(source, dataDiff, options) {
+
+    // convert diff to sets/maps for o(1) lookups
+    const diff = diffToHashed(dataDiff);
+
+    // collection for features that will be affected by this update
+    let affected = [];
+
+    // full removal - clear everything before applying diff
+    if (diff.removeAll) {
+        affected = source;
+        source = [];
+    }
+
+    // remove/add features and collect affected ones
+    if (diff.remove.size || diff.add.size) {
+        const removeFeatures = [];
+
+        // collect source features to be removed
+        for (const feature of source) {
+            const {id} = feature;
+
+            // explicit feature removal
+            if (diff.remove.has(id)) {
+                removeFeatures.push(feature);
+            // feature with duplicate id being added
+            } else if (diff.add.has(id)) {
+                removeFeatures.push(feature);
+            }
+        }
+
+        // collect affected and remove from source
+        if (removeFeatures.length) {
+            affected.push(...removeFeatures);
+
+            const removeIds = new Set(removeFeatures.map(f => f.id));
+            source = source.filter(f => !removeIds.has(f.id));
+        }
+
+        // convert and add new features
+        if (diff.add.size) {
+            // projects and adds simplification info
+            let addFeatures = convert({type: 'FeatureCollection', features: Array.from(diff.add.values())}, options);
+
+            // wraps features (ie extreme west and extreme east)
+            addFeatures = wrap(addFeatures, options);
+
+            affected.push(...addFeatures);
+            source.push(...addFeatures);
+        }
+    }
+
+    if (diff.update.size) {
+        for (const [id, update] of diff.update) {
+            const featureIndex = source.findIndex(f => f.id === id);
+            if (featureIndex === -1) continue;
+
+            const feature = source[featureIndex];
+
+            // get updated geojsonvt simplified feature
+            const updatedFeature = getUpdatedFeature(feature, update, options);
+            if (!updatedFeature) continue;
+
+            // track both features for invalidation
+            affected.push(feature, updatedFeature);
+
+            // replace old feature with updated feature
+            source[featureIndex] = updatedFeature;
+        }
+    }
+
+    return {affected, source};
+}
+
+// return an updated geojsonvt simplified feature
+function getUpdatedFeature(vtFeature, update, options) {
+    const changeGeometry = !!update.newGeometry;
+
+    const changeProps =
+        update.removeAllProperties ||
+        update.removeProperties?.length > 0 ||
+        update.addOrUpdateProperties?.length > 0;
+
+    // nothing to do
+    if (!changeGeometry && !changeProps) return null;
+
+    // if geometry changed, need to create new geojson feature and convert to simplified format
+    if (changeGeometry) {
+        const geojsonFeature = {
+            type: 'Feature',
+            id: vtFeature.id,
+            geometry: update.newGeometry,
+            properties: changeProps ? applyPropertyUpdates(vtFeature.tags, update) : vtFeature.tags
+        };
+
+        // projects and adds simplification info
+        let features = convert({type: 'FeatureCollection', features: [geojsonFeature]}, options);
+
+        // wraps features (ie extreme west and extreme east)
+        features = wrap(features, options);
+
+        return features[0];
+    }
+
+    // only properties changed - update tags directly
+    if (changeProps) {
+        const feature = {...vtFeature};
+        feature.tags = applyPropertyUpdates(feature.tags, update);
+        return feature;
+    }
+
+    return null;
+}
+
+// helper to apply property updates from a diff update object to a properties object
+function applyPropertyUpdates(tags, update) {
+    if (update.removeAllProperties) {
+        return {};
+    }
+
+    const properties = {...tags || {}};
+
+    if (update.removeProperties) {
+        for (const key of update.removeProperties) {
+            delete properties[key];
+        }
+    }
+
+    if (update.addOrUpdateProperties) {
+        for (const {key, value} of update.addOrUpdateProperties) {
+            properties[key] = value;
+        }
+    }
+
+    return properties;
+}
+
+// Convert a GeoJSON Source Diff to an idempotent hashed representation using Sets and Maps
+export function diffToHashed(diff) {
+    if (!diff) return {};
+
+    const hashed = {};
+
+    hashed.removeAll = diff.removeAll;
+    hashed.remove = new Set(diff.remove || []);
+    hashed.add    = new Map(diff.add?.map(feature => [feature.id, feature]));
+    hashed.update = new Map(diff.update?.map(update => [update.id, update]));
+
+    return hashed;
+}

package/src/feature.js

@@ -0,0 +1,43 @@
+
+export default function createFeature(id, type, geom, tags) {
+    const feature = {
+        id: id == null ? null : id,
+        type,
+        geometry: geom,
+        tags,
+        minX: Infinity,
+        minY: Infinity,
+        maxX: -Infinity,
+        maxY: -Infinity
+    };
+
+    if (type === 'Point' || type === 'MultiPoint' || type === 'LineString') {
+        calcLineBBox(feature, geom);
+
+    } else if (type === 'Polygon') {
+        // the outer ring (ie [0]) contains all inner rings
+        calcLineBBox(feature, geom[0]);
+
+    } else if (type === 'MultiLineString') {
+        for (const line of geom) {
+            calcLineBBox(feature, line);
+        }
+
+    } else if (type === 'MultiPolygon') {
+        for (const polygon of geom) {
+            // the outer ring (ie [0]) contains all inner rings
+            calcLineBBox(feature, polygon[0]);
+        }
+    }
+
+    return feature;
+}
+
+function calcLineBBox(feature, geom) {
+    for (let i = 0; i < geom.length; i += 3) {
+        feature.minX = Math.min(feature.minX, geom[i]);
+        feature.minY = Math.min(feature.minY, geom[i + 1]);
+        feature.maxX = Math.max(feature.maxX, geom[i]);
+        feature.maxY = Math.max(feature.maxY, geom[i + 1]);
+    }
+}