node-red-contrib-tak-registration 0.2.2 → 0.3.2

package/node_modules/topojson-server/dist/topojson-server.min.js

@@ -0,0 +1,2 @@
+// https://github.com/topojson/topojson-server v3.0.1 Copyright 2019 Mike Bostock
+!function(r,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((r=r||self).topojson=r.topojson||{})}(this,function(r){"use strict";var n=Object.prototype.hasOwnProperty;function t(r,n,t,e,o,i){3===arguments.length&&(e=i=Array,o=null);for(var a=new e(r=1<<Math.max(4,Math.ceil(Math.log(r)/Math.LN2))),u=new i(r),f=r-1,c=0;c<r;++c)a[c]=o;return{set:function(e,i){for(var c=n(e)&f,l=a[c],s=0;l!=o;){if(t(l,e))return u[c]=i;if(++s>=r)throw new Error("full hashmap");l=a[c=c+1&f]}return a[c]=e,u[c]=i,i},maybeSet:function(e,i){for(var c=n(e)&f,l=a[c],s=0;l!=o;){if(t(l,e))return u[c];if(++s>=r)throw new Error("full hashmap");l=a[c=c+1&f]}return a[c]=e,u[c]=i,i},get:function(e,i){for(var c=n(e)&f,l=a[c],s=0;l!=o;){if(t(l,e))return u[c];if(++s>=r)break;l=a[c=c+1&f]}return i},keys:function(){for(var r=[],n=0,t=a.length;n<t;++n){var e=a[n];e!=o&&r.push(e)}return r}}}function e(r,n){return r[0]===n[0]&&r[1]===n[1]}var o=new ArrayBuffer(16),i=new Float64Array(o),a=new Uint32Array(o);function u(r){i[0]=r[0],i[1]=r[1];var n=a[0]^a[1];return 2147483647&(n=n<<5^n>>7^a[2]^a[3])}function f(r){var n,o,i,a,f=r.coordinates,c=r.lines,l=r.rings,s=function(){for(var r=t(1.4*f.length,A,E,Int32Array,-1,Int32Array),n=new Int32Array(f.length),e=0,o=f.length;e<o;++e)n[e]=r.maybeSet(e,e);return n}(),h=new Int32Array(f.length),g=new Int32Array(f.length),v=new Int32Array(f.length),p=new Int8Array(f.length),y=0;for(n=0,o=f.length;n<o;++n)h[n]=g[n]=v[n]=-1;for(n=0,o=c.length;n<o;++n){var d=c[n],m=d[0],b=d[1];for(i=s[m],a=s[++m],++y,p[i]=1;++m<=b;)P(n,i,i=a,a=s[m]);++y,p[a]=1}for(n=0,o=f.length;n<o;++n)h[n]=-1;for(n=0,o=l.length;n<o;++n){var M=l[n],x=M[0]+1,w=M[1];for(P(n,s[w-1],i=s[x-1],a=s[x]);++x<=w;)P(n,i,i=a,a=s[x])}function P(r,n,t,e){if(h[t]!==r){h[t]=r;var o=g[t];if(o>=0){var i=v[t];o===n&&i===e||o===e&&i===n||(++y,p[t]=1)}else g[t]=n,v[t]=e}}function A(r){return u(f[r])}function E(r,n){return e(f[r],f[n])}h=g=v=null;var L,S=function(r,n,t,e,o){3===arguments.length&&(e=Array,o=null);for(var i=new e(r=1<<Math.max(4,Math.ceil(Math.log(r)/Math.LN2))),a=r-1,u=0;u<r;++u)i[u]=o;return{add:function(e){for(var u=n(e)&a,f=i[u],c=0;f!=o;){if(t(f,e))return!0;if(++c>=r)throw new Error("full hashset");f=i[u=u+1&a]}return i[u]=e,!0},has:function(e){for(var u=n(e)&a,f=i[u],c=0;f!=o;){if(t(f,e))return!0;if(++c>=r)break;f=i[u=u+1&a]}return!1},values:function(){for(var r=[],n=0,t=i.length;n<t;++n){var e=i[n];e!=o&&r.push(e)}return r}}}(1.4*y,u,e);for(n=0,o=f.length;n<o;++n)p[L=s[n]]&&S.add(f[L]);return S}function c(r,n,t){for(var e,o=n+(t---n>>1);n<o;++n,--t)e=r[n],r[n]=r[t],r[t]=e}function l(r){var n,t=s(r.geometry);for(n in null!=r.id&&(t.id=r.id),null!=r.bbox&&(t.bbox=r.bbox),r.properties){t.properties=r.properties;break}return t}function s(r){if(null==r)return{type:null};var n="GeometryCollection"===r.type?{type:"GeometryCollection",geometries:r.geometries.map(s)}:"Point"===r.type||"MultiPoint"===r.type?{type:r.type,coordinates:r.coordinates}:{type:r.type,arcs:r.coordinates};return null!=r.bbox&&(n.bbox=r.bbox),n}function h(r){var n,t=r[0],e=r[1];return e<t&&(n=t,t=e,e=n),t+31*e}function g(r,n){var t,e=r[0],o=r[1],i=n[0],a=n[1];return o<e&&(t=e,e=o,o=t),a<i&&(t=i,i=a,a=t),e===i&&o===a}r.topology=function(r,o){var i=function(r){var t=1/0,e=1/0,o=-1/0,i=-1/0;function a(r){null!=r&&n.call(u,r.type)&&u[r.type](r)}var u={GeometryCollection:function(r){r.geometries.forEach(a)},Point:function(r){f(r.coordinates)},MultiPoint:function(r){r.coordinates.forEach(f)},LineString:function(r){c(r.arcs)},MultiLineString:function(r){r.arcs.forEach(c)},Polygon:function(r){r.arcs.forEach(c)},MultiPolygon:function(r){r.arcs.forEach(l)}};function f(r){var n=r[0],a=r[1];n<t&&(t=n),n>o&&(o=n),a<e&&(e=a),a>i&&(i=a)}function c(r){r.forEach(f)}function l(r){r.forEach(c)}for(var s in r)a(r[s]);return o>=t&&i>=e?[t,e,o,i]:void 0}(r=function(r){var n,t,e={};for(n in r)e[n]=null==(t=r[n])?{type:null}:("FeatureCollection"===t.type?function(r){var n={type:"GeometryCollection",geometries:r.features.map(l)};return null!=r.bbox&&(n.bbox=r.bbox),n}:"Feature"===t.type?l:s)(t);return e}(r)),a=o>0&&i&&function(r,t,e){var o=t[0],i=t[1],a=t[2],u=t[3],f=a-o?(e-1)/(a-o):1,c=u-i?(e-1)/(u-i):1;function l(r){return[Math.round((r[0]-o)*f),Math.round((r[1]-i)*c)]}function s(r,n){for(var t,e,a,u,l,s=-1,h=0,g=r.length,v=new Array(g);++s<g;)t=r[s],u=Math.round((t[0]-o)*f),l=Math.round((t[1]-i)*c),u===e&&l===a||(v[h++]=[e=u,a=l]);for(v.length=h;h<n;)h=v.push([v[0][0],v[0][1]]);return v}function h(r){return s(r,2)}function g(r){return s(r,4)}function v(r){return r.map(g)}function p(r){null!=r&&n.call(y,r.type)&&y[r.type](r)}var y={GeometryCollection:function(r){r.geometries.forEach(p)},Point:function(r){r.coordinates=l(r.coordinates)},MultiPoint:function(r){r.coordinates=r.coordinates.map(l)},LineString:function(r){r.arcs=h(r.arcs)},MultiLineString:function(r){r.arcs=r.arcs.map(h)},Polygon:function(r){r.arcs=v(r.arcs)},MultiPolygon:function(r){r.arcs=r.arcs.map(v)}};for(var d in r)p(r[d]);return{scale:[1/f,1/c],translate:[o,i]}}(r,i,o),v=function(r){var n,o,i,a,f=r.coordinates,c=r.lines,l=r.rings,s=c.length+l.length;for(delete r.lines,delete r.rings,i=0,a=c.length;i<a;++i)for(n=c[i];n=n.next;)++s;for(i=0,a=l.length;i<a;++i)for(o=l[i];o=o.next;)++s;var h=t(2*s*1.4,u,e),g=r.arcs=[];for(i=0,a=c.length;i<a;++i){n=c[i];do{v(n)}while(n=n.next)}for(i=0,a=l.length;i<a;++i)if((o=l[i]).next)do{v(o)}while(o=o.next);else p(o);function v(r){var n,t,e,o,i,a,u,c;if(e=h.get(n=f[r[0]]))for(u=0,c=e.length;u<c;++u)if(y(o=e[u],r))return r[0]=o[0],void(r[1]=o[1]);if(i=h.get(t=f[r[1]]))for(u=0,c=i.length;u<c;++u)if(d(a=i[u],r))return r[1]=a[0],void(r[0]=a[1]);e?e.push(r):h.set(n,[r]),i?i.push(r):h.set(t,[r]),g.push(r)}function p(r){var n,t,e,o,i;if(t=h.get(f[r[0]]))for(o=0,i=t.length;o<i;++o){if(m(e=t[o],r))return r[0]=e[0],void(r[1]=e[1]);if(b(e,r))return r[0]=e[1],void(r[1]=e[0])}if(t=h.get(n=f[r[0]+M(r)]))for(o=0,i=t.length;o<i;++o){if(m(e=t[o],r))return r[0]=e[0],void(r[1]=e[1]);if(b(e,r))return r[0]=e[1],void(r[1]=e[0])}t?t.push(r):h.set(n,[r]),g.push(r)}function y(r,n){var t=r[0],o=n[0],i=r[1];if(t-i!=o-n[1])return!1;for(;t<=i;++t,++o)if(!e(f[t],f[o]))return!1;return!0}function d(r,n){var t=r[0],o=n[0],i=r[1],a=n[1];if(t-i!=o-a)return!1;for(;t<=i;++t,--a)if(!e(f[t],f[a]))return!1;return!0}function m(r,n){var t=r[0],o=n[0],i=r[1]-t;if(i!==n[1]-o)return!1;for(var a=M(r),u=M(n),c=0;c<i;++c)if(!e(f[t+(c+a)%i],f[o+(c+u)%i]))return!1;return!0}function b(r,n){var t=r[0],o=n[0],i=r[1],a=n[1],u=i-t;if(u!==a-o)return!1;for(var c=M(r),l=u-M(n),s=0;s<u;++s)if(!e(f[t+(s+c)%u],f[a-(s+l)%u]))return!1;return!0}function M(r){for(var n=r[0],t=r[1],e=n,o=e,i=f[e];++e<t;){var a=f[e];(a[0]<i[0]||a[0]===i[0]&&a[1]<i[1])&&(o=e,i=a)}return o-n}return r}(function(r){var n,t,e,o,i,a,u,l=f(r),s=r.coordinates,h=r.lines,g=r.rings;for(t=0,e=h.length;t<e;++t)for(var v=h[t],p=v[0],y=v[1];++p<y;)l.has(s[p])&&(n={0:p,1:v[1]},v[1]=p,v=v.next=n);for(t=0,e=g.length;t<e;++t)for(var d=g[t],m=d[0],b=m,M=d[1],x=l.has(s[m]);++b<M;)l.has(s[b])&&(x?(n={0:b,1:d[1]},d[1]=b,d=d.next=n):(u=M-b,c(o=s,i=m,a=M),c(o,i,i+u),c(o,i+u,a),s[M]=s[m],x=!0,b=m));return r}(function(r){var t=-1,e=[],o=[],i=[];function a(r){r&&n.call(u,r.type)&&u[r.type](r)}var u={GeometryCollection:function(r){r.geometries.forEach(a)},LineString:function(r){r.arcs=f(r.arcs)},MultiLineString:function(r){r.arcs=r.arcs.map(f)},Polygon:function(r){r.arcs=r.arcs.map(c)},MultiPolygon:function(r){r.arcs=r.arcs.map(l)}};function f(r){for(var n=0,o=r.length;n<o;++n)i[++t]=r[n];var a={0:t-o+1,1:t};return e.push(a),a}function c(r){for(var n=0,e=r.length;n<e;++n)i[++t]=r[n];var a={0:t-e+1,1:t};return o.push(a),a}function l(r){return r.map(c)}for(var s in r)a(r[s]);return{type:"Topology",coordinates:i,lines:e,rings:o,objects:r}}(r))),p=v.coordinates,y=t(1.4*v.arcs.length,h,g);function d(r){r&&n.call(m,r.type)&&m[r.type](r)}r=v.objects,v.bbox=i,v.arcs=v.arcs.map(function(r,n){return y.set(r,n),p.slice(r[0],r[1]+1)}),delete v.coordinates,p=null;var m={GeometryCollection:function(r){r.geometries.forEach(d)},LineString:function(r){r.arcs=b(r.arcs)},MultiLineString:function(r){r.arcs=r.arcs.map(b)},Polygon:function(r){r.arcs=r.arcs.map(b)},MultiPolygon:function(r){r.arcs=r.arcs.map(M)}};function b(r){var n=[];do{var t=y.get(r);n.push(r[0]<r[1]?t:~t)}while(r=r.next);return n}function M(r){return r.map(b)}for(var x in r)d(r[x]);return a&&(v.transform=a,v.arcs=function(r){for(var n=-1,t=r.length;++n<t;){for(var e,o,i=r[n],a=0,u=1,f=i.length,c=i[0],l=c[0],s=c[1];++a<f;)e=(c=i[a])[0],o=c[1],e===l&&o===s||(i[u++]=[e-l,o-s],l=e,s=o);1===u&&(i[u++]=[0,0]),i.length=u}return r}(v.arcs)),v},Object.defineProperty(r,"__esModule",{value:!0})});

package/node_modules/topojson-server/package.json

@@ -0,0 +1,75 @@
+{
+  "_from": "topojson-server@3.x",
+  "_id": "topojson-server@3.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-/VS9j/ffKr2XAOjlZ9CgyyeLmgJ9dMwq6Y0YEON8O7p/tGGk+dCWnrE03zEdu7i4L7YsFZLEPZPzCvcB7lEEXw==",
+  "_location": "/topojson-server",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "topojson-server@3.x",
+    "name": "topojson-server",
+    "escapedName": "topojson-server",
+    "rawSpec": "3.x",
+    "saveSpec": null,
+    "fetchSpec": "3.x"
+  },
+  "_requiredBy": [
+    "/@turf/concave"
+  ],
+  "_resolved": "https://registry.npmjs.org/topojson-server/-/topojson-server-3.0.1.tgz",
+  "_shasum": "d2b3ec095b6732299be76a48406111b3201a34f5",
+  "_spec": "topojson-server@3.x",
+  "_where": "/Users/conway/Projects/TAKreg/node_modules/@turf/concave",
+  "author": {
+    "name": "Mike Bostock",
+    "url": "https://bost.ocks.org/mike"
+  },
+  "bin": {
+    "geo2topo": "bin/geo2topo"
+  },
+  "bugs": {
+    "url": "https://github.com/topojson/topojson-server/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "commander": "2"
+  },
+  "deprecated": false,
+  "description": "Convert GeoJSON to TopoJSON for smaller files and the power of topology!",
+  "devDependencies": {
+    "eslint": "6",
+    "rollup": "1",
+    "rollup-plugin-terser": "5",
+    "tape": "4",
+    "topojson-client": "3"
+  },
+  "files": [
+    "bin/geo*",
+    "dist/**/*.js",
+    "src/**/*.js"
+  ],
+  "homepage": "https://github.com/topojson/topojson-server",
+  "jsdelivr": "dist/topojson-server.min.js",
+  "keywords": [
+    "topojson",
+    "geojson"
+  ],
+  "license": "ISC",
+  "main": "dist/topojson-server.js",
+  "module": "src/index.js",
+  "name": "topojson-server",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/topojson/topojson-server.git"
+  },
+  "scripts": {
+    "postpublish": "git push && git push --tags && zip -j dist/${npm_package_name}.zip -- LICENSE README.md dist/${npm_package_name}.js dist/${npm_package_name}.min.js",
+    "prepublishOnly": "rm -rf dist && yarn test",
+    "pretest": "rollup -c",
+    "test": "tape 'test/**/*-test.js' && eslint src test"
+  },
+  "unpkg": "dist/topojson-server.min.js",
+  "version": "3.0.1"
+}

package/node_modules/topojson-server/src/bounds.js

@@ -0,0 +1,46 @@
+import {hasOwnProperty} from "./object.js";
+
+// Computes the bounding box of the specified hash of GeoJSON objects.
+export default function(objects) {
+  var x0 = Infinity,
+      y0 = Infinity,
+      x1 = -Infinity,
+      y1 = -Infinity;
+
+  function boundGeometry(geometry) {
+    if (geometry != null && hasOwnProperty.call(boundGeometryType, geometry.type)) boundGeometryType[geometry.type](geometry);
+  }
+
+  var boundGeometryType = {
+    GeometryCollection: function(o) { o.geometries.forEach(boundGeometry); },
+    Point: function(o) { boundPoint(o.coordinates); },
+    MultiPoint: function(o) { o.coordinates.forEach(boundPoint); },
+    LineString: function(o) { boundLine(o.arcs); },
+    MultiLineString: function(o) { o.arcs.forEach(boundLine); },
+    Polygon: function(o) { o.arcs.forEach(boundLine); },
+    MultiPolygon: function(o) { o.arcs.forEach(boundMultiLine); }
+  };
+
+  function boundPoint(coordinates) {
+    var x = coordinates[0],
+        y = coordinates[1];
+    if (x < x0) x0 = x;
+    if (x > x1) x1 = x;
+    if (y < y0) y0 = y;
+    if (y > y1) y1 = y;
+  }
+
+  function boundLine(coordinates) {
+    coordinates.forEach(boundPoint);
+  }
+
+  function boundMultiLine(coordinates) {
+    coordinates.forEach(boundLine);
+  }
+
+  for (var key in objects) {
+    boundGeometry(objects[key]);
+  }
+
+  return x1 >= x0 && y1 >= y0 ? [x0, y0, x1, y1] : undefined;
+}

package/node_modules/topojson-server/src/cut.js

@@ -0,0 +1,62 @@
+import join from "./join.js";
+
+// Given an extracted (pre-)topology, cuts (or rotates) arcs so that all shared
+// point sequences are identified. The topology can then be subsequently deduped
+// to remove exact duplicate arcs.
+export default function(topology) {
+  var junctions = join(topology),
+      coordinates = topology.coordinates,
+      lines = topology.lines,
+      rings = topology.rings,
+      next,
+      i, n;
+
+  for (i = 0, n = lines.length; i < n; ++i) {
+    var line = lines[i],
+        lineMid = line[0],
+        lineEnd = line[1];
+    while (++lineMid < lineEnd) {
+      if (junctions.has(coordinates[lineMid])) {
+        next = {0: lineMid, 1: line[1]};
+        line[1] = lineMid;
+        line = line.next = next;
+      }
+    }
+  }
+
+  for (i = 0, n = rings.length; i < n; ++i) {
+    var ring = rings[i],
+        ringStart = ring[0],
+        ringMid = ringStart,
+        ringEnd = ring[1],
+        ringFixed = junctions.has(coordinates[ringStart]);
+    while (++ringMid < ringEnd) {
+      if (junctions.has(coordinates[ringMid])) {
+        if (ringFixed) {
+          next = {0: ringMid, 1: ring[1]};
+          ring[1] = ringMid;
+          ring = ring.next = next;
+        } else { // For the first junction, we can rotate rather than cut.
+          rotateArray(coordinates, ringStart, ringEnd, ringEnd - ringMid);
+          coordinates[ringEnd] = coordinates[ringStart];
+          ringFixed = true;
+          ringMid = ringStart; // restart; we may have skipped junctions
+        }
+      }
+    }
+  }
+
+  return topology;
+}
+
+function rotateArray(array, start, end, offset) {
+  reverse(array, start, end);
+  reverse(array, start, start + offset);
+  reverse(array, start + offset, end);
+}
+
+function reverse(array, start, end) {
+  for (var mid = start + ((end-- - start) >> 1), t; start < mid; ++start, --end) {
+    t = array[start], array[start] = array[end], array[end] = t;
+  }
+}

package/node_modules/topojson-server/src/dedup.js

@@ -0,0 +1,187 @@
+import hashmap from "./hash/hashmap.js";
+import equalPoint from "./hash/point-equal.js";
+import hashPoint from "./hash/point-hash.js";
+
+// Given a cut topology, combines duplicate arcs.
+export default function(topology) {
+  var coordinates = topology.coordinates,
+      lines = topology.lines, line,
+      rings = topology.rings, ring,
+      arcCount = lines.length + rings.length,
+      i, n;
+
+  delete topology.lines;
+  delete topology.rings;
+
+  // Count the number of (non-unique) arcs to initialize the hashmap safely.
+  for (i = 0, n = lines.length; i < n; ++i) {
+    line = lines[i]; while (line = line.next) ++arcCount;
+  }
+  for (i = 0, n = rings.length; i < n; ++i) {
+    ring = rings[i]; while (ring = ring.next) ++arcCount;
+  }
+
+  var arcsByEnd = hashmap(arcCount * 2 * 1.4, hashPoint, equalPoint),
+      arcs = topology.arcs = [];
+
+  for (i = 0, n = lines.length; i < n; ++i) {
+    line = lines[i];
+    do {
+      dedupLine(line);
+    } while (line = line.next);
+  }
+
+  for (i = 0, n = rings.length; i < n; ++i) {
+    ring = rings[i];
+    if (ring.next) { // arc is no longer closed
+      do {
+        dedupLine(ring);
+      } while (ring = ring.next);
+    } else {
+      dedupRing(ring);
+    }
+  }
+
+  function dedupLine(arc) {
+    var startPoint,
+        endPoint,
+        startArcs, startArc,
+        endArcs, endArc,
+        i, n;
+
+    // Does this arc match an existing arc in order?
+    if (startArcs = arcsByEnd.get(startPoint = coordinates[arc[0]])) {
+      for (i = 0, n = startArcs.length; i < n; ++i) {
+        startArc = startArcs[i];
+        if (equalLine(startArc, arc)) {
+          arc[0] = startArc[0];
+          arc[1] = startArc[1];
+          return;
+        }
+      }
+    }
+
+    // Does this arc match an existing arc in reverse order?
+    if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[1]])) {
+      for (i = 0, n = endArcs.length; i < n; ++i) {
+        endArc = endArcs[i];
+        if (reverseEqualLine(endArc, arc)) {
+          arc[1] = endArc[0];
+          arc[0] = endArc[1];
+          return;
+        }
+      }
+    }
+
+    if (startArcs) startArcs.push(arc); else arcsByEnd.set(startPoint, [arc]);
+    if (endArcs) endArcs.push(arc); else arcsByEnd.set(endPoint, [arc]);
+    arcs.push(arc);
+  }
+
+  function dedupRing(arc) {
+    var endPoint,
+        endArcs,
+        endArc,
+        i, n;
+
+    // Does this arc match an existing line in order, or reverse order?
+    // Rings are closed, so their start point and end point is the same.
+    if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[0]])) {
+      for (i = 0, n = endArcs.length; i < n; ++i) {
+        endArc = endArcs[i];
+        if (equalRing(endArc, arc)) {
+          arc[0] = endArc[0];
+          arc[1] = endArc[1];
+          return;
+        }
+        if (reverseEqualRing(endArc, arc)) {
+          arc[0] = endArc[1];
+          arc[1] = endArc[0];
+          return;
+        }
+      }
+    }
+
+    // Otherwise, does this arc match an existing ring in order, or reverse order?
+    if (endArcs = arcsByEnd.get(endPoint = coordinates[arc[0] + findMinimumOffset(arc)])) {
+      for (i = 0, n = endArcs.length; i < n; ++i) {
+        endArc = endArcs[i];
+        if (equalRing(endArc, arc)) {
+          arc[0] = endArc[0];
+          arc[1] = endArc[1];
+          return;
+        }
+        if (reverseEqualRing(endArc, arc)) {
+          arc[0] = endArc[1];
+          arc[1] = endArc[0];
+          return;
+        }
+      }
+    }
+
+    if (endArcs) endArcs.push(arc); else arcsByEnd.set(endPoint, [arc]);
+    arcs.push(arc);
+  }
+
+  function equalLine(arcA, arcB) {
+    var ia = arcA[0], ib = arcB[0],
+        ja = arcA[1], jb = arcB[1];
+    if (ia - ja !== ib - jb) return false;
+    for (; ia <= ja; ++ia, ++ib) if (!equalPoint(coordinates[ia], coordinates[ib])) return false;
+    return true;
+  }
+
+  function reverseEqualLine(arcA, arcB) {
+    var ia = arcA[0], ib = arcB[0],
+        ja = arcA[1], jb = arcB[1];
+    if (ia - ja !== ib - jb) return false;
+    for (; ia <= ja; ++ia, --jb) if (!equalPoint(coordinates[ia], coordinates[jb])) return false;
+    return true;
+  }
+
+  function equalRing(arcA, arcB) {
+    var ia = arcA[0], ib = arcB[0],
+        ja = arcA[1], jb = arcB[1],
+        n = ja - ia;
+    if (n !== jb - ib) return false;
+    var ka = findMinimumOffset(arcA),
+        kb = findMinimumOffset(arcB);
+    for (var i = 0; i < n; ++i) {
+      if (!equalPoint(coordinates[ia + (i + ka) % n], coordinates[ib + (i + kb) % n])) return false;
+    }
+    return true;
+  }
+
+  function reverseEqualRing(arcA, arcB) {
+    var ia = arcA[0], ib = arcB[0],
+        ja = arcA[1], jb = arcB[1],
+        n = ja - ia;
+    if (n !== jb - ib) return false;
+    var ka = findMinimumOffset(arcA),
+        kb = n - findMinimumOffset(arcB);
+    for (var i = 0; i < n; ++i) {
+      if (!equalPoint(coordinates[ia + (i + ka) % n], coordinates[jb - (i + kb) % n])) return false;
+    }
+    return true;
+  }
+
+  // Rings are rotated to a consistent, but arbitrary, start point.
+  // This is necessary to detect when a ring and a rotated copy are dupes.
+  function findMinimumOffset(arc) {
+    var start = arc[0],
+        end = arc[1],
+        mid = start,
+        minimum = mid,
+        minimumPoint = coordinates[mid];
+    while (++mid < end) {
+      var point = coordinates[mid];
+      if (point[0] < minimumPoint[0] || point[0] === minimumPoint[0] && point[1] < minimumPoint[1]) {
+        minimum = mid;
+        minimumPoint = point;
+      }
+    }
+    return minimum - start;
+  }
+
+  return topology;
+}

package/node_modules/topojson-server/src/delta.js

@@ -0,0 +1,30 @@
+// Given an array of arcs in absolute (but already quantized!) coordinates,
+// converts to fixed-point delta encoding.
+// This is a destructive operation that modifies the given arcs!
+export default function(arcs) {
+  var i = -1,
+      n = arcs.length;
+
+  while (++i < n) {
+    var arc = arcs[i],
+        j = 0,
+        k = 1,
+        m = arc.length,
+        point = arc[0],
+        x0 = point[0],
+        y0 = point[1],
+        x1,
+        y1;
+
+    while (++j < m) {
+      point = arc[j], x1 = point[0], y1 = point[1];
+      if (x1 !== x0 || y1 !== y0) arc[k++] = [x1 - x0, y1 - y0], x0 = x1, y0 = y1;
+    }
+
+    if (k === 1) arc[k++] = [0, 0]; // Each arc must be an array of two or more positions.
+
+    arc.length = k;
+  }
+
+  return arcs;
+}

package/node_modules/topojson-server/src/extract.js

@@ -0,0 +1,67 @@
+import {hasOwnProperty} from "./object.js";
+
+// Extracts the lines and rings from the specified hash of geometry objects.
+//
+// Returns an object with three properties:
+//
+// * coordinates - shared buffer of [x, y] coordinates
+// * lines - lines extracted from the hash, of the form [start, end]
+// * rings - rings extracted from the hash, of the form [start, end]
+//
+// For each ring or line, start and end represent inclusive indexes into the
+// coordinates buffer. For rings (and closed lines), coordinates[start] equals
+// coordinates[end].
+//
+// For each line or polygon geometry in the input hash, including nested
+// geometries as in geometry collections, the `coordinates` array is replaced
+// with an equivalent `arcs` array that, for each line (for line string
+// geometries) or ring (for polygon geometries), points to one of the above
+// lines or rings.
+export default function(objects) {
+  var index = -1,
+      lines = [],
+      rings = [],
+      coordinates = [];
+
+  function extractGeometry(geometry) {
+    if (geometry && hasOwnProperty.call(extractGeometryType, geometry.type)) extractGeometryType[geometry.type](geometry);
+  }
+
+  var extractGeometryType = {
+    GeometryCollection: function(o) { o.geometries.forEach(extractGeometry); },
+    LineString: function(o) { o.arcs = extractLine(o.arcs); },
+    MultiLineString: function(o) { o.arcs = o.arcs.map(extractLine); },
+    Polygon: function(o) { o.arcs = o.arcs.map(extractRing); },
+    MultiPolygon: function(o) { o.arcs = o.arcs.map(extractMultiRing); }
+  };
+
+  function extractLine(line) {
+    for (var i = 0, n = line.length; i < n; ++i) coordinates[++index] = line[i];
+    var arc = {0: index - n + 1, 1: index};
+    lines.push(arc);
+    return arc;
+  }
+
+  function extractRing(ring) {
+    for (var i = 0, n = ring.length; i < n; ++i) coordinates[++index] = ring[i];
+    var arc = {0: index - n + 1, 1: index};
+    rings.push(arc);
+    return arc;
+  }
+
+  function extractMultiRing(rings) {
+    return rings.map(extractRing);
+  }
+
+  for (var key in objects) {
+    extractGeometry(objects[key]);
+  }
+
+  return {
+    type: "Topology",
+    coordinates: coordinates,
+    lines: lines,
+    rings: rings,
+    objects: objects
+  };
+}

package/node_modules/topojson-server/src/geometry.js

@@ -0,0 +1,39 @@
+// Given a hash of GeoJSON objects, returns a hash of GeoJSON geometry objects.
+// Any null input geometry objects are represented as {type: null} in the output.
+// Any feature.{id,properties,bbox} are transferred to the output geometry object.
+// Each output geometry object is a shallow copy of the input (e.g., properties, coordinates)!
+export default function(inputs) {
+  var outputs = {}, key;
+  for (key in inputs) outputs[key] = geomifyObject(inputs[key]);
+  return outputs;
+}
+
+function geomifyObject(input) {
+  return input == null ? {type: null}
+      : (input.type === "FeatureCollection" ? geomifyFeatureCollection
+      : input.type === "Feature" ? geomifyFeature
+      : geomifyGeometry)(input);
+}
+
+function geomifyFeatureCollection(input) {
+  var output = {type: "GeometryCollection", geometries: input.features.map(geomifyFeature)};
+  if (input.bbox != null) output.bbox = input.bbox;
+  return output;
+}
+
+function geomifyFeature(input) {
+  var output = geomifyGeometry(input.geometry), key; // eslint-disable-line no-unused-vars
+  if (input.id != null) output.id = input.id;
+  if (input.bbox != null) output.bbox = input.bbox;
+  for (key in input.properties) { output.properties = input.properties; break; }
+  return output;
+}
+
+function geomifyGeometry(input) {
+  if (input == null) return {type: null};
+  var output = input.type === "GeometryCollection" ? {type: "GeometryCollection", geometries: input.geometries.map(geomifyGeometry)}
+      : input.type === "Point" || input.type === "MultiPoint" ? {type: input.type, coordinates: input.coordinates}
+      : {type: input.type, arcs: input.coordinates}; // TODO Check for unknown types?
+  if (input.bbox != null) output.bbox = input.bbox;
+  return output;
+}

package/node_modules/topojson-server/src/hash/hashmap.js

@@ -0,0 +1,70 @@
+export default function(size, hash, equal, keyType, keyEmpty, valueType) {
+  if (arguments.length === 3) {
+    keyType = valueType = Array;
+    keyEmpty = null;
+  }
+
+  var keystore = new keyType(size = 1 << Math.max(4, Math.ceil(Math.log(size) / Math.LN2))),
+      valstore = new valueType(size),
+      mask = size - 1;
+
+  for (var i = 0; i < size; ++i) {
+    keystore[i] = keyEmpty;
+  }
+
+  function set(key, value) {
+    var index = hash(key) & mask,
+        matchKey = keystore[index],
+        collisions = 0;
+    while (matchKey != keyEmpty) {
+      if (equal(matchKey, key)) return valstore[index] = value;
+      if (++collisions >= size) throw new Error("full hashmap");
+      matchKey = keystore[index = (index + 1) & mask];
+    }
+    keystore[index] = key;
+    valstore[index] = value;
+    return value;
+  }
+
+  function maybeSet(key, value) {
+    var index = hash(key) & mask,
+        matchKey = keystore[index],
+        collisions = 0;
+    while (matchKey != keyEmpty) {
+      if (equal(matchKey, key)) return valstore[index];
+      if (++collisions >= size) throw new Error("full hashmap");
+      matchKey = keystore[index = (index + 1) & mask];
+    }
+    keystore[index] = key;
+    valstore[index] = value;
+    return value;
+  }
+
+  function get(key, missingValue) {
+    var index = hash(key) & mask,
+        matchKey = keystore[index],
+        collisions = 0;
+    while (matchKey != keyEmpty) {
+      if (equal(matchKey, key)) return valstore[index];
+      if (++collisions >= size) break;
+      matchKey = keystore[index = (index + 1) & mask];
+    }
+    return missingValue;
+  }
+
+  function keys() {
+    var keys = [];
+    for (var i = 0, n = keystore.length; i < n; ++i) {
+      var matchKey = keystore[i];
+      if (matchKey != keyEmpty) keys.push(matchKey);
+    }
+    return keys;
+  }
+
+  return {
+    set: set,
+    maybeSet: maybeSet, // set if unset
+    get: get,
+    keys: keys
+  };
+}

package/node_modules/topojson-server/src/hash/hashset.js

@@ -0,0 +1,53 @@
+export default function(size, hash, equal, type, empty) {
+  if (arguments.length === 3) {
+    type = Array;
+    empty = null;
+  }
+
+  var store = new type(size = 1 << Math.max(4, Math.ceil(Math.log(size) / Math.LN2))),
+      mask = size - 1;
+
+  for (var i = 0; i < size; ++i) {
+    store[i] = empty;
+  }
+
+  function add(value) {
+    var index = hash(value) & mask,
+        match = store[index],
+        collisions = 0;
+    while (match != empty) {
+      if (equal(match, value)) return true;
+      if (++collisions >= size) throw new Error("full hashset");
+      match = store[index = (index + 1) & mask];
+    }
+    store[index] = value;
+    return true;
+  }
+
+  function has(value) {
+    var index = hash(value) & mask,
+        match = store[index],
+        collisions = 0;
+    while (match != empty) {
+      if (equal(match, value)) return true;
+      if (++collisions >= size) break;
+      match = store[index = (index + 1) & mask];
+    }
+    return false;
+  }
+
+  function values() {
+    var values = [];
+    for (var i = 0, n = store.length; i < n; ++i) {
+      var match = store[i];
+      if (match != empty) values.push(match);
+    }
+    return values;
+  }
+
+  return {
+    add: add,
+    has: has,
+    values: values
+  };
+}

package/node_modules/topojson-server/src/hash/point-equal.js

@@ -0,0 +1,3 @@
+export default function(pointA, pointB) {
+  return pointA[0] === pointB[0] && pointA[1] === pointB[1];
+}

package/node_modules/topojson-server/src/hash/point-hash.js

@@ -0,0 +1,13 @@
+// TODO if quantized, use simpler Int32 hashing?
+
+var buffer = new ArrayBuffer(16),
+    floats = new Float64Array(buffer),
+    uints = new Uint32Array(buffer);
+
+export default function(point) {
+  floats[0] = point[0];
+  floats[1] = point[1];
+  var hash = uints[0] ^ uints[1];
+  hash = hash << 5 ^ hash >> 7 ^ uints[2] ^ uints[3];
+  return hash & 0x7fffffff;
+}

package/node_modules/topojson-server/src/index.js

@@ -0,0 +1 @@
+export {default as topology} from "./topology.js";