@dra2020/baseclient 1.0.163 → 1.0.164

package/dist/baseclient.js

@@ -6639,6 +6639,7 @@ __exportStar(__webpack_require__(/*! ./shamos */ "./lib/poly/shamos.ts"), export
 __exportStar(__webpack_require__(/*! ./pointinpoly */ "./lib/poly/pointinpoly.ts"), exports);
 __exportStar(__webpack_require__(/*! ./mapto */ "./lib/poly/mapto.ts"), exports);
 __exportStar(__webpack_require__(/*! ./featurecleanholes */ "./lib/poly/featurecleanholes.ts"), exports);
+__exportStar(__webpack_require__(/*! ./polyhash */ "./lib/poly/polyhash.ts"), exports);
 
 
 /***/ }),
@@ -9067,6 +9068,98 @@ function topoFromBuffer(coder, ab) {
 }
 
 
+/***/ }),
+
+/***/ "./lib/poly/polyhash.ts":
+/*!******************************!*\
+  !*** ./lib/poly/polyhash.ts ***!
+  \******************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.polyHash32 = polyHash32;
+const P = __importStar(__webpack_require__(/*! ./poly */ "./lib/poly/poly.ts"));
+const PP = __importStar(__webpack_require__(/*! ./polypack */ "./lib/poly/polypack.ts"));
+// Hash coordinates to 32 bit number in order to produce a fast (and a little sloppy) equivalence test.
+// Note that this depends on ordering, so an equivalent polygon with different coordinate ordering would
+// not test as equivalent. As a 32 bit number, you can expect collisions when used for large numbers of
+// polygons (e.g. a 700k block set might expect ~57 collisions - TX at 660K gets 62 collisions, e.g.).
+//
+function polyHash32(poly, seed = 0) {
+    let pp = P.polyNormalize(poly);
+    if (!pp)
+        return 0;
+    let h = (seed | 0) ^ 0x9e3779b9;
+    const buf = new ArrayBuffer(8);
+    const dv = new DataView(buf);
+    function mix32(x) {
+        x ^= x >>> 16;
+        x = Math.imul(x, 0x7feb352d);
+        x ^= x >>> 15;
+        x = Math.imul(x, 0x846ca68b);
+        x ^= x >>> 16;
+        return x | 0;
+    }
+    let l = 0;
+    PP.polyPackEachRing(pp, (b, iPoly, iRing, iOffset, nPoints) => {
+        let iEnd = iOffset + (nPoints * 2);
+        for (; iOffset < iEnd; iOffset++) {
+            const x = b[iOffset];
+            if (Number.isNaN(x)) {
+                dv.setUint32(0, 0x7ff80001, true);
+                dv.setUint32(4, 0, true);
+            }
+            else
+                dv.setFloat64(0, x, true);
+            const lo = dv.getUint32(0, true) | 0;
+            const hi = dv.getUint32(4, true) | 0;
+            let z = mix32(lo ^ Math.imul(hi, 0x9e3779b9) ^ Math.imul(l + 1, 0x85ebca6b));
+            h ^= z;
+            h = mix32(h);
+            l++;
+        }
+    });
+    h ^= l | 0;
+    h = mix32(h);
+    // return as unsigned 32-bit in a JS number
+    return h >>> 0;
+}
+
+
 /***/ }),
 
 /***/ "./lib/poly/polylabel.ts":