Bar graph added.

node_modules/d3-geo-projection/LICENSE

@@ -0,0 +1,54 @@
+Copyright 2013-2016 Mike Bostock
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the author nor the names of contributors may be used to
+  endorse or promote products derived from this software without specific prior
+  written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+
+MIT License for https://github.com/scijs/integrate-adaptive-simpson
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Ricky Reusser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/d3-geo-projection/bin/geo2svg

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+var os = require("os"),
+    commander = require("commander"),
+    d3 = Object.assign({}, require("d3-geo"), require("../")),
+    read = require("./read"),
+    write = require("./write");
+
+commander
+    .version(require("../package.json").version)
+    .usage("[options] [file]")
+    .description("Convert GeoJSON to SVG.")
+    .option("-o, --out <file>", "output file name; defaults to “-” for stdout", "-")
+    .option("-w, --width <value>", "output width", 960)
+    .option("-h, --height <value>", "output height", 500)
+    .option("-p, --precision <value>", "number of output digits after the decimal point", 6)
+    .option("-n, --newline-delimited", "accept newline-delimited JSON")
+    .option("--fill <value>", "default fill", "none")
+    .option("--stroke <value>", "default stroke", "black")
+    .option("-r, --radius <value>", "default point radius", 4.5)
+    .parse(process.argv);
+
+if (commander.args.length === 0) commander.args[0] = "-";
+else if (commander.args.length !== 1) {
+  console.error();
+  console.error("  error: multiple input files");
+  console.error();
+  process.exit(1);
+}
+
+var reader = read(commander.args[0], commander.newlineDelimited, transform).then(end).catch(abort),
+    writer = write(commander.out),
+    path = d3.geoPath().pointRadius(function(d) { var p = d.properties, v; return p && (v = p["point-radius"] || p.pointRadius) != null ? v : commander.radius; }),
+    render = commander.precision == null ? path : function(d) { return path(d3.geoQuantize(d, commander.precision)); };
+
+writer.write("<?xml version=\"1.0\" encoding=\"utf-8\"?>" + os.EOL
+    + "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">" + os.EOL
+    + "<!-- Generated by geo2svg " + require("../package.json").version + ". https://d3js.org/d3-geo-projection/ -->" + os.EOL
+    + "<svg version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\""
+    + " width=\"" + +commander.width + "\""
+    + " height=\"" + +commander.height + "\""
+    + " viewBox=\"0 0 " + +commander.width + " " + +commander.height + "\""
+    + (commander.fill != "black" ? " fill=\"" + attr(commander.fill) + "\"" : "")
+    + (commander.stroke != "none" ? " stroke=\"" + attr(commander.stroke) + "\"" : "")
+    + ">" + os.EOL);
+
+function transform(d) {
+  var p = d.properties, v;
+  return writer.write("  <path"
+      + ((v = d.id) != null ? " id=\"" + attr(v + "") + "\"" : "")
+      + (p ? ((v = p["fill"]) != null ? " fill=\"" + attr(v + "") + "\"" : "")
+        + ((v = p["fill-rule"] || p.fillRule) != null ? " fill-rule=\"" + attr(v + "") + "\"" : "")
+        + ((v = p["fill-opacity"] || p.fillOpacity) != null ? " fill-opacity=\"" + attr(v + "") + "\"" : "")
+        + ((v = p["stroke"]) != null ? " stroke=\"" + attr(v + "") + "\"" : "")
+        + ((v = p["stroke-width"] || p.strokeWidth) != null ? " stroke-width=\"" + attr(v + "") + "\"" : "")
+        + ((v = p["stroke-linecap"] || p.strokeLinecap) != null ? " stroke-linecap=\"" + attr(v + "") + "\"" : "")
+        + ((v = p["stroke-linejoin"] || p.strokeLinejoin) != null ? " stroke-linejoin=\"" + attr(v + "") + "\"" : "")
+        + ((v = p["stroke-miterlimit"] || p.strokeMiterlimit) != null ? " stroke-miterlimit=\"" + attr(v + "") + "\"" : "")
+        + ((v = p["stroke-dasharray"] || p.strokeDasharray) != null ? " stroke-dasharray=\"" + attr(v + "") + "\"" : "")
+        + ((v = p["stroke-dashoffset"] || p.strokeDashoffset) != null ? " stroke-dashoffset=\"" + attr(v + "") + "\"" : "")
+        + ((v = p["stroke-opacity"] || p.strokeOpacity) != null ? " stroke-opacity=\"" + attr(v + "") + "\"" : "")
+      : "")
+      + (v = render(d), v ? " d=\"" + v + "\"" : "")
+      + ">"
+      + ((v = p && p["title"]) != null ? "<title>" + text(v + "") + "</title>" : "")
+      + "</path>" + os.EOL);
+}
+
+function end() {
+  return writer.write("</svg>" + os.EOL);
+}
+
+function abort(error) {
+  console.error(error.stack);
+}
+
+function text(string) {
+  return string.replace(/[&<>]/g, function(character) {
+    switch (character) {
+      case "&": return "&amp;";
+      case "<": return "&lt;";
+      case ">": return "&gt;";
+    }
+  });
+}
+
+function attr(string) {
+  return string.replace(/"/g, "&quot;");
+}

node_modules/d3-geo-projection/bin/geograticule

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+var commander = require("commander"),
+    graticule = require("d3-geo").geoGraticule(),
+    write = require("./write");
+
+commander
+    .version(require("../package.json").version)
+    .usage("[options]")
+    .description("Generate a GeoJSON graticule.")
+    .option("-o, --out <file>", "output file name; defaults to “-” for stdout", "-")
+    .option("--extent <value>", "the major and minor extent", parseExtent)
+    .option("--extent-minor <value>", "the minor extent; defaults to " + graticule.extentMajor(), parseExtent)
+    .option("--extent-major <value>", "the major extent; defaults to " + graticule.extentMinor(), parseExtent)
+    .option("--step <value>", "the major and minor step", parseStep)
+    .option("--step-minor <value>", "the minor step; defaults to " + graticule.stepMinor(), parseStep)
+    .option("--step-major <value>", "the major step; defaults to " + graticule.stepMajor(), parseStep)
+    .option("--precision <value>", "the precision; defaults to " + graticule.precision(), graticule.precision)
+    .parse(process.argv);
+
+if (commander.args.length !== 0) {
+  console.error();
+  console.error("  error: unexpected arguments");
+  console.error();
+  process.exit(1);
+}
+
+if (commander.extent != null) {
+  if (commander.extentMinor == null) commander.extentMinor = commander.extent;
+  if (commander.extentMajor == null) commander.extentMajor = commander.extent;
+}
+if (commander.step != null) {
+  if (commander.stepMinor == null) commander.stepMinor = commander.step;
+  if (commander.stepMajor == null) commander.stepMajor = commander.step;
+}
+if (commander.extentMinor != null) graticule.extentMinor(commander.extentMinor);
+if (commander.extentMajor != null) graticule.extentMajor(commander.extentMajor);
+if (commander.stepMinor != null) graticule.stepMinor(commander.stepMinor);
+if (commander.stepMajor != null) graticule.stepMajor(commander.stepMajor);
+
+var writer = write(commander.out);
+writer.write(JSON.stringify(graticule()) + "\n");
+writer.end().catch(abort);
+
+function parseStep(x) {
+  return x = x.split(","), x.length === 1 ? [+x[0], +x[0]] : [+x[0], +x[1]];
+}
+
+function parseExtent(x) {
+  return x = x.split(","), [[+x[0], +x[1]], [+x[2], +x[3]]];
+}
+
+function abort(error) {
+  console.error(error.stack);
+}

node_modules/d3-geo-projection/bin/geoproject

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+var commander = require("commander"),
+    vm = require("vm"),
+    d3 = Object.assign({}, require("d3-geo"), require("../")),
+    read = require("./read"),
+    requires = require("./requires"),
+    write = require("./write");
+
+commander
+    .version(require("../package.json").version)
+    .usage("[options] <projection> [file]")
+    .description("Transform GeoJSON, such as to project from spherical to planar coordinates.")
+    .option("-o, --out <file>", "output file name; defaults to “-” for stdout", "-")
+    .option("-p, --precision <value>", "number of output digits after the decimal point")
+    .option("-n, --newline-delimited", "use newline-delimited JSON")
+    .option("-r, --require <[name=]module>", "require a module", requires, {d3: d3, d: undefined, i: -1})
+    .parse(process.argv);
+
+if (commander.args.length < 1) {
+  console.error();
+  console.error("  error: missing projection");
+  console.error();
+  process.exit(1);
+} else if (commander.args.length > 2) {
+  console.error();
+  console.error("  error: multiple input files");
+  console.error();
+  process.exit(1);
+} else if (commander.args.length === 1) {
+  commander.args.push("-");
+}
+
+var sandbox = commander.require,
+    context = new vm.createContext(sandbox),
+    projection = new vm.Script("(" + commander.args[0] + ")"),
+    reader = read(commander.args[1], commander.newlineDelimited, project).then(end).catch(abort),
+    writer = write(commander.out);
+
+function project(d, i) {
+  sandbox.d = d, sandbox.i = i;
+  d = d3.geoProject(d, projection.runInContext(context));
+  if (commander.precision != null) d = d3.geoQuantize(d, commander.precision);
+  return writer.write(JSON.stringify(d) + "\n");
+}
+
+function end() {
+  return writer.end();
+}
+
+function abort(error) {
+  console.error(error.stack);
+}

node_modules/d3-geo-projection/bin/geoquantize

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+var commander = require("commander"),
+    d3 = Object.assign({}, require("d3-geo"), require("../")),
+    read = require("./read"),
+    write = require("./write");
+
+commander
+    .version(require("../package.json").version)
+    .usage("[options] [file]")
+    .description("Quantize GeoJSON.")
+    .option("-o, --out <file>", "output file name; defaults to “-” for stdout", "-")
+    .option("-p, --precision <value>", "number of output digits after the decimal point")
+    .option("-n, --newline-delimited", "use newline-delimited JSON")
+    .parse(process.argv);
+
+if (commander.args.length > 1) {
+  console.error();
+  console.error("  error: multiple input files");
+  console.error();
+  process.exit(1);
+} else if (commander.args.length === 0) {
+  commander.args.push("-");
+}
+
+var reader = read(commander.args[0], commander.newlineDelimited, quantize).then(end).catch(abort),
+    writer = write(commander.out);
+
+function quantize(d, i) {
+  if (commander.precision != null) d = d3.geoQuantize(d, commander.precision);
+  return writer.write(JSON.stringify(d) + "\n");
+}
+
+function end() {
+  return writer.end();
+}
+
+function abort(error) {
+  console.error(error.stack);
+}

node_modules/d3-geo-projection/bin/geostitch

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+var commander = require("commander"),
+    d3 = require("../"),
+    read = require("./read"),
+    write = require("./write");
+
+commander
+    .version(require("../package.json").version)
+    .usage("[options] [file]")
+    .description("Stitch equirectangular GeoJSON in degrees, removing antimeridian and polar cuts.")
+    .option("-o, --out <file>", "output file name; defaults to “-” for stdout", "-")
+    .option("-n, --newline-delimited", "use newline-delimited JSON")
+    .parse(process.argv);
+
+if (commander.args.length === 0) commander.args[0] = "-";
+else if (commander.args.length !== 1) {
+  console.error();
+  console.error("  error: multiple input files");
+  console.error();
+  process.exit(1);
+}
+
+var reader = read(commander.args[0], commander.newlineDelimited, stitch).then(end).catch(abort),
+    writer = write(commander.out);
+
+function stitch(d) {
+  return writer.write(JSON.stringify(d3.geoStitch(d)) + "\n");
+}
+
+function end() {
+  return writer.end();
+}
+
+function abort(error) {
+  console.error(error.stack);
+}

node_modules/d3-geo-projection/bin/read.js

@@ -0,0 +1,39 @@
+var fs = require("fs"),
+    readline = require("readline");
+
+module.exports = function(file, newlineDelimited, callback) {
+  var index = -1,
+      input = file === "-" ? process.stdin : fs.createReadStream(file);
+
+  function readObject() {
+    return new Promise(function(resolve, reject) {
+      var data = [];
+      input
+          .on("data", function(d) { data.push(d); })
+          .on("end", function() { resolve(JSON.parse(Buffer.concat(data))); })
+          .on("error", reject);
+    });
+  }
+
+  function readNewlineDelimitedObjects() {
+    return new Promise(function(resolve, reject) {
+      var queue = Promise.resolve();
+      readline.createInterface({
+        input: input,
+        output: null
+      }).on("line", function(line) {
+        queue = queue.then(function() { return callbackObject(JSON.parse(line)); });
+      }).on("close", function() {
+        queue.then(function() { resolve(); }, reject);
+      }).on("error", reject);
+    });
+  }
+
+  function callbackObject(object) {
+    return callback(object, ++index);
+  }
+
+  return newlineDelimited
+      ? readNewlineDelimitedObjects()
+      : readObject().then(callbackObject);
+};

node_modules/d3-geo-projection/bin/requires.js

@@ -0,0 +1,10 @@
+var resolve = require("./resolve");
+
+module.exports = function(module, sandbox) {
+  var i = module.indexOf("="), name = module;
+  if (i >= 0) name = module.slice(0, i), module = module.slice(i + 1);
+  module = require(resolve(module));
+  if (sandbox[name]) Object.assign(sandbox[name], module);
+  else sandbox[name] = module;
+  return sandbox;
+};

node_modules/d3-geo-projection/bin/resolve.js

@@ -0,0 +1,16 @@
+var child_process = require("child_process"),
+    resolve = require("resolve"),
+    options = {basedir: process.cwd(), paths: []};
+
+module.exports = function(module) {
+  try {
+    return resolve.sync(module, options); // Attempt fast local resolve first.
+  } catch (error) {
+    if (!options.paths.length) {
+      options.paths.push(child_process.execSync("npm root -g").toString().trim());
+      return resolve.sync(module, options);
+    } else {
+      throw error;
+    }
+  }
+};

node_modules/d3-geo-projection/bin/write.js

@@ -0,0 +1,35 @@
+var fs = require("fs");
+
+function handleEpipe(error) {
+  if (error.code === "EPIPE" || error.errno === "EPIPE") {
+    process.exit(0);
+  }
+}
+
+module.exports = function(file) {
+  var output = (file === "-" ? process.stdout : fs.createWriteStream(file)).on("error", handleEpipe),
+      queue = Promise.resolve();
+  return {
+    write: function(data) {
+      return queue = queue.then(function() {
+        return new Promise(function(resolve, reject) {
+          output.write(data, function(error) {
+            if (error) reject(error);
+            else resolve();
+          });
+        });
+      });
+    },
+    end: function() {
+      if (output === process.stdout) return queue;
+      return queue = queue.then(function() {
+        return new Promise(function(resolve, reject) {
+          output.end(function(error) {
+            if (error) reject(error);
+            else resolve();
+          });
+        });
+      });
+    }
+  };
+};

node_modules/d3-geo-projection/node_modules/d3-array/.eslintrc.json

@@ -0,0 +1,15 @@
+{
+  "extends": "eslint:recommended",
+  "parserOptions": {
+    "sourceType": "module",
+    "ecmaVersion": 8
+  },
+  "env": {
+    "es6": true,
+    "node": true,
+    "browser": true
+  },
+  "rules": {
+    "no-cond-assign": 0
+  }
+}

node_modules/d3-geo-projection/node_modules/d3-array/LICENSE

@@ -0,0 +1,27 @@
+Copyright 2010-2016 Mike Bostock
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the author nor the names of contributors may be used to
+  endorse or promote products derived from this software without specific prior
+  written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

node_modules/d3-geo-projection/node_modules/d3-array/README.md

@@ -0,0 +1,382 @@
+# d3-array
+
+Data in JavaScript is often represented by an array, and so one tends to manipulate arrays when visualizing or analyzing data. Some common forms of manipulation include taking a contiguous slice (subset) of an array, filtering an array using a predicate function, and mapping an array to a parallel set of values using a transform function. Before looking at the set of utilities that this module provides, familiarize yourself with the powerful [array methods built-in to JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype).
+
+JavaScript includes **mutation methods** that modify the array:
+
+* [*array*.pop](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) - Remove the last element from the array.
+* [*array*.push](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) - Add one or more elements to the end of the array.
+* [*array*.reverse](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse) - Reverse the order of the elements of the array.
+* [*array*.shift](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) - Remove the first element from the array.
+* [*array*.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) - Sort the elements of the array.
+* [*array*.splice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) - Add or remove elements from the array.
+* [*array*.unshift](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) - Add one or more elements to the front of the array.
+
+There are also **access methods** that return some representation of the array:
+
+* [*array*.concat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) - Join the array with other array(s) or value(s).
+* [*array*.join](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join) - Join all elements of the array into a string.
+* [*array*.slice](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) - Extract a section of the array.
+* [*array*.indexOf](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) - Find the first occurrence of a value within the array.
+* [*array*.lastIndexOf](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) - Find the last occurrence of a value within the array.
+
+And finally **iteration methods** that apply functions to elements in the array:
+
+* [*array*.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) - Create a new array with only the elements for which a predicate is true.
+* [*array*.forEach](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) - Call a function for each element in the array.
+* [*array*.every](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) - See if every element in the array satisfies a predicate.
+* [*array*.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) - Create a new array with the result of calling a function on every element in the array.
+* [*array*.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some) - See if at least one element in the array satisfies a predicate.
+* [*array*.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) - Apply a function to reduce the array to a single value (from left-to-right).
+* [*array*.reduceRight](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) - Apply a function to reduce the array to a single value (from right-to-left).
+
+## Installing
+
+If you use NPM, `npm install d3-array`. Otherwise, download the [latest release](https://github.com/d3/d3-array/releases/latest). You can also load directly from [d3js.org](https://d3js.org), either as a [standalone library](https://d3js.org/d3-array.v1.min.js) or as part of [D3 4.0](https://github.com/d3/d3). AMD, CommonJS, and vanilla environments are supported. In vanilla, a `d3` global is exported:
+
+```html
+<script src="https://d3js.org/d3-array.v1.min.js"></script>
+<script>
+
+var min = d3.min(array);
+
+</script>
+```
+
+[Try d3-array in your browser.](https://tonicdev.com/npm/d3-array)
+
+## API Reference
+
+* [Statistics](#statistics)
+* [Search](#search)
+* [Transformations](#transformations)
+* [Histograms](#histograms)
+* [Histogram Thresholds](#histogram-thresholds)
+
+### Statistics
+
+Methods for computing basic summary statistics.
+
+<a name="min" href="#min">#</a> d3.<b>min</b>(<i>array</i>[, <i>accessor</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/min.js "Source")
+
+Returns the minimum value in the given *array* using natural order. If the array is empty, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling *array*.map(*accessor*) before computing the minimum value.
+
+Unlike the built-in [Math.min](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Math/min), this method ignores undefined, null and NaN values; this is useful for ignoring missing data. In addition, elements are compared using natural order rather than numeric order. For example, the minimum of the strings [“20”, “3”] is “20”, while the minimum of the numbers [20, 3] is 3.
+
+See also [scan](#scan) and [extent](#extent).
+
+<a name="max" href="#max">#</a> d3.<b>max</b>(<i>array</i>[, <i>accessor</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/max.js "Source")
+
+Returns the maximum value in the given *array* using natural order. If the array is empty, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling *array*.map(*accessor*) before computing the maximum value.
+
+Unlike the built-in [Math.max](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Math/max), this method ignores undefined values; this is useful for ignoring missing data. In addition, elements are compared using natural order rather than numeric order. For example, the maximum of the strings [“20”, “3”] is “3”, while the maximum of the numbers [20, 3] is 20.
+
+See also [scan](#scan) and [extent](#extent).
+
+<a name="extent" href="#extent">#</a> d3.<b>extent</b>(<i>array</i>[, <i>accessor</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/extent.js "Source")
+
+Returns the [minimum](#min) and [maximum](#max) value in the given *array* using natural order. If the array is empty, returns [undefined, undefined]. An optional *accessor* function may be specified, which is equivalent to calling *array*.map(*accessor*) before computing the extent.
+
+<a name="sum" href="#sum">#</a> d3.<b>sum</b>(<i>array</i>[, <i>accessor</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/sum.js "Source")
+
+Returns the sum of the given *array* of numbers. If the array is empty, returns 0. An optional *accessor* function may be specified, which is equivalent to calling *array*.map(*accessor*) before computing the sum. This method ignores undefined and NaN values; this is useful for ignoring missing data.
+
+<a name="mean" href="#mean">#</a> d3.<b>mean</b>(<i>array</i>[, <i>accessor</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/mean.js "Source")
+
+Returns the mean of the given *array* of numbers. If the array is empty, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling *array*.map(*accessor*) before computing the mean. This method ignores undefined and NaN values; this is useful for ignoring missing data.
+
+<a name="median" href="#median">#</a> d3.<b>median</b>(<i>array</i>[, <i>accessor</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/median.js "Source")
+
+Returns the median of the given *array* of numbers using the [R-7 method](https://en.wikipedia.org/wiki/Quantile#Estimating_quantiles_from_a_sample). If the array is empty, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling *array*.map(*accessor*) before computing the median. This method ignores undefined and NaN values; this is useful for ignoring missing data.
+
+<a name="quantile" href="#quantile">#</a> d3.<b>quantile</b>(<i>array</i>, <i>p</i>[, <i>accessor</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/quantile.js "Source")
+
+Returns the *p*-quantile of the given **sorted** *array* of numbers, where *p* is a number in the range [0, 1]. For example, the median can be computed using *p* = 0.5, the first quartile at *p* = 0.25, and the third quartile at *p* = 0.75. This particular implementation uses the [R-7 method](http://en.wikipedia.org/wiki/Quantile#Quantiles_of_a_population), which is the default for the R programming language and Excel. For example:
+
+```js
+var a = [0, 10, 30];
+d3.quantile(a, 0); // 0
+d3.quantile(a, 0.5); // 10
+d3.quantile(a, 1); // 30
+d3.quantile(a, 0.25); // 5
+d3.quantile(a, 0.75); // 20
+d3.quantile(a, 0.1); // 2
+```
+
+An optional *accessor* function may be specified, which is equivalent to calling *array*.map(*accessor*) before computing the quantile.
+
+<a name="variance" href="#variance">#</a> d3.<b>variance</b>(<i>array</i>[, <i>accessor</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/variance.js "Source")
+
+Returns an [unbiased estimator of the population variance](http://mathworld.wolfram.com/SampleVariance.html) of the given *array* of numbers. If the array has fewer than two values, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling *array*.map(*accessor*) before computing the variance. This method ignores undefined and NaN values; this is useful for ignoring missing data.
+
+<a name="deviation" href="#deviation">#</a> d3.<b>deviation</b>(<i>array</i>[, <i>accessor</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/deviation.js "Source")
+
+Returns the standard deviation, defined as the square root of the [bias-corrected variance](#variance), of the given *array* of numbers. If the array has fewer than two values, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling *array*.map(*accessor*) before computing the standard deviation. This method ignores undefined and NaN values; this is useful for ignoring missing data.
+
+### Search
+
+Methods for searching arrays for a specific element.
+
+<a name="scan" href="#scan">#</a> d3.<b>scan</b>(<i>array</i>[, <i>comparator</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/scan.js "Source")
+
+Performs a linear scan of the specified *array*, returning the index of the least element according to the specified *comparator*. If the given *array* contains no comparable elements (*i.e.*, the comparator returns NaN when comparing each element to itself), returns undefined. If *comparator* is not specified, it defaults to [ascending](#ascending). For example:
+
+```js
+var array = [{foo: 42}, {foo: 91}];
+d3.scan(array, function(a, b) { return a.foo - b.foo; }); // 0
+d3.scan(array, function(a, b) { return b.foo - a.foo; }); // 1
+```
+
+This function is similar to [min](#min), except it allows the use of a comparator rather than an accessor and it returns the index instead of the accessed value. See also [bisect](#bisect).
+
+<a name="bisectLeft" href="#bisectLeft">#</a> d3.<b>bisectLeft</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) [<>](https://github.com/d3/d3-array/blob/master/src/bisect.js#L6 "Source")
+
+Returns the insertion point for *x* in *array* to maintain sorted order. The arguments *lo* and *hi* may be used to specify a subset of the array which should be considered; by default the entire array is used. If *x* is already present in *array*, the insertion point will be before (to the left of) any existing entries. The return value is suitable for use as the first argument to [splice](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice) assuming that *array* is already sorted. The returned insertion point *i* partitions the *array* into two halves so that all *v* < *x* for *v* in *array*.slice(*lo*, *i*) for the left side and all *v* >= *x* for *v* in *array*.slice(*i*, *hi*) for the right side.
+
+<a name="bisect" href="#bisect">#</a> d3.<b>bisect</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) [<>](https://github.com/d3/d3-array/blob/master/src/bisect.js "Source")<br>
+<a name="bisectRight" href="#bisectRight">#</a> d3.<b>bisectRight</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) [<>](https://github.com/d3/d3-array/blob/master/src/bisect.js#L6 "Source")
+
+Similar to [bisectLeft](#bisectLeft), but returns an insertion point which comes after (to the right of) any existing entries of *x* in *array*. The returned insertion point *i* partitions the *array* into two halves so that all *v* <= *x* for *v* in *array*.slice(*lo*, *i*) for the left side and all *v* > *x* for *v* in *array*.slice(*i*, *hi*) for the right side.
+
+<a name="bisector" href="#bisector">#</a> d3.<b>bisector</b>(<i>accessor</i>) [<>](https://github.com/d3/d3-array/blob/master/src/bisector.js "Source")
+<br><a name="bisector" href="#bisector">#</a> d3.<b>bisector</b>(<i>comparator</i>) [<>](https://github.com/d3/d3-array/blob/master/src/bisector.js "Source")
+
+Returns a new bisector using the specified *accessor* or *comparator* function. This method can be used to bisect arrays of objects instead of being limited to simple arrays of primitives. For example, given the following array of objects:
+
+```js
+var data = [
+  {date: new Date(2011, 1, 1), value: 0.5},
+  {date: new Date(2011, 2, 1), value: 0.6},
+  {date: new Date(2011, 3, 1), value: 0.7},
+  {date: new Date(2011, 4, 1), value: 0.8}
+];
+```
+
+A suitable bisect function could be constructed as:
+
+```js
+var bisectDate = d3.bisector(function(d) { return d.date; }).right;
+```
+
+This is equivalent to specifying a comparator:
+
+```js
+var bisectDate = d3.bisector(function(d, x) { return d.date - x; }).right;
+```
+
+And then applied as *bisectDate*(*array*, *date*), returning an index. Note that the comparator is always passed the search value *x* as the second argument. Use a comparator rather than an accessor if you want values to be sorted in an order different than natural order, such as in descending rather than ascending order.
+
+<a name="bisector_left" href="#bisector_left">#</a> <i>bisector</i>.<b>left</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) [<>](https://github.com/d3/d3-array/blob/master/src/bisector.js#L6 "Source")
+
+Equivalent to [bisectLeft](#bisectLeft), but uses this bisector’s associated comparator.
+
+<a name="bisector_right" href="#bisector_right">#</a> <i>bisector</i>.<b>right</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) [<>](https://github.com/d3/d3-array/blob/master/src/bisector.js#L16 "Source")
+
+Equivalent to [bisectRight](#bisectRight), but uses this bisector’s associated comparator.
+
+<a name="ascending" href="#ascending">#</a> d3.<b>ascending</b>(<i>a</i>, <i>b</i>) [<>](https://github.com/d3/d3-array/blob/master/src/ascending.js "Source")
+
+Returns -1 if *a* is less than *b*, or 1 if *a* is greater than *b*, or 0. This is the comparator function for natural order, and can be used in conjunction with the built-in [*array*.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) method to arrange elements in ascending order. It is implemented as:
+
+```js
+function ascending(a, b) {
+  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}
+```
+
+Note that if no comparator function is specified to the built-in sort method, the default order is lexicographic (alphabetical), not natural! This can lead to surprising behavior when sorting an array of numbers.
+
+<a name="descending" href="#descending">#</a> d3.<b>descending</b>(<i>a</i>, <i>b</i>) [<>](https://github.com/d3/d3-array/blob/master/src/descending.js "Source")
+
+Returns -1 if *a* is greater than *b*, or 1 if *a* is less than *b*, or 0. This is the comparator function for reverse natural order, and can be used in conjunction with the built-in array sort method to arrange elements in descending order.  It is implemented as:
+
+```js
+function descending(a, b) {
+  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}
+```
+
+Note that if no comparator function is specified to the built-in sort method, the default order is lexicographic (alphabetical), not natural! This can lead to surprising behavior when sorting an array of numbers.
+
+### Transformations
+
+Methods for transforming arrays and for generating new arrays.
+
+<a name="cross" href="#cross">#</a> d3.<b>cross</b>(<i>a</i>, <i>b</i>[, <i>reducer</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/cross.js "Source")
+
+Returns the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the two arrays *a* and *b*. For each element *i* in the specified array *a* and each element *j* in the specified array *b*, in order, invokes the specified *reducer* function passing the element *i* and element *j*. If a *reducer* is not specified, it defaults to a function which creates a two-element array for each pair:
+
+```js
+function pair(a, b) {
+  return [a, b];
+}
+```
+
+For example:
+
+```js
+d3.cross([1, 2], ["x", "y"]); // returns [[1, "x"], [1, "y"], [2, "x"], [2, "y"]]
+d3.cross([1, 2], ["x", "y"], (a, b) => a + b); // returns ["1x", "1y", "2x", "2y"]
+```
+
+<a name="merge" href="#merge">#</a> d3.<b>merge</b>(<i>arrays</i>) [<>](https://github.com/d3/d3-array/blob/master/src/merge.js "Source")
+
+Merges the specified *arrays* into a single array. This method is similar to the built-in array concat method; the only difference is that it is more convenient when you have an array of arrays.
+
+```js
+d3.merge([[1], [2, 3]]); // returns [1, 2, 3]
+```
+
+<a name="pairs" href="#pairs">#</a> d3.<b>pairs</b>(<i>array</i>[, <i>reducer</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/pairs.js "Source")
+
+For each adjacent pair of elements in the specified *array*, in order, invokes the specified *reducer* function passing the element *i* and element *i* - 1. If a *reducer* is not specified, it defaults to a function which creates a two-element array for each pair:
+
+```js
+function pair(a, b) {
+  return [a, b];
+}
+```
+
+For example:
+
+```js
+d3.pairs([1, 2, 3, 4]); // returns [[1, 2], [2, 3], [3, 4]]
+d3.pairs([1, 2, 3, 4], (a, b) => b - a); // returns [1, 1, 1];
+```
+
+If the specified array has fewer than two elements, returns the empty array.
+
+<a name="permute" href="#permute">#</a> d3.<b>permute</b>(<i>array</i>, <i>indexes</i>) [<>](https://github.com/d3/d3-array/blob/master/src/permute.js "Source")
+
+Returns a permutation of the specified *array* using the specified array of *indexes*. The returned array contains the corresponding element in array for each index in indexes, in order. For example, permute(["a", "b", "c"], [1, 2, 0])
+returns ["b", "c", "a"]. It is acceptable for the array of indexes to be a different length from the array of elements, and for indexes to be duplicated or omitted.
+
+This method can also be used to extract the values from an object into an array with a stable order. Extracting keyed values in order can be useful for generating data arrays in nested selections. For example:
+
+```js
+var object = {yield: 27, variety: "Manchuria", year: 1931, site: "University Farm"},
+    fields = ["site", "variety", "yield"];
+
+d3.permute(object, fields); // returns ["University Farm", "Manchuria", 27]
+```
+
+<a name="shuffle" href="#shuffle">#</a> d3.<b>shuffle</b>(<i>array</i>[, <i>start</i>[, <i>stop</i>]]) [<>](https://github.com/d3/d3-array/blob/master/src/shuffle.js "Source")
+
+Randomizes the order of the specified *array* in-place using the [Fisher–Yates shuffle](https://bost.ocks.org/mike/shuffle/) and returns the *array*. If *start* is specified, it is the starting index (inclusive) of the *array* to shuffle; if *start* is not specified, it defaults to zero. If *stop* is specified, it is the ending index (exclusive) of the *array* to shuffle; if *stop* is not specified, it defaults to *array*.length. For example, to shuffle the first ten elements of the *array*: shuffle(*array*, 0, 10).
+
+<a name="ticks" href="#ticks">#</a> d3.<b>ticks</b>(<i>start</i>, <i>stop</i>, <i>count</i>) [<>](https://github.com/d3/d3-array/blob/master/src/ticks.js "Source")
+
+Returns an array of approximately *count* + 1 uniformly-spaced, nicely-rounded values between *start* and *stop* (inclusive). Each value is a power of ten multiplied by 1, 2 or 5. See also [d3.tickIncrement](#tickIncrement), [d3.tickStep](#tickStep) and [*linear*.ticks](https://github.com/d3/d3-scale/blob/master/README.md#linear_ticks).
+
+Ticks are inclusive in the sense that they may include the specified *start* and *stop* values if (and only if) they are exact, nicely-rounded values consistent with the inferred [step](#tickStep). More formally, each returned tick *t* satisfies *start* ≤ *t* and *t* ≤ *stop*.
+
+<a name="tickIncrement" href="#tickIncrement">#</a> d3.<b>tickIncrement</b>(<i>start</i>, <i>stop</i>, <i>count</i>) [<>](https://github.com/d3/d3-array/blob/master/src/ticks.js#L16 "Source")
+
+Like [d3.tickStep](#tickStep), except requires that *start* is always less than or equal to *step*, and if the tick step for the given *start*, *stop* and *count* would be less than one, returns the negative inverse tick step instead. This method is always guaranteed to return an integer, and is used by [d3.ticks](#ticks) to avoid guarantee that the returned tick values are represented as precisely as possible in IEEE 754 floating point.
+
+<a name="tickStep" href="#tickStep">#</a> d3.<b>tickStep</b>(<i>start</i>, <i>stop</i>, <i>count</i>) [<>](https://github.com/d3/d3-array/blob/master/src/ticks.js#L16 "Source")
+
+Returns the difference between adjacent tick values if the same arguments were passed to [d3.ticks](#ticks): a nicely-rounded value that is a power of ten multiplied by 1, 2 or 5. Note that due to the limited precision of IEEE 754 floating point, the returned value may not be exact decimals; use [d3-format](https://github.com/d3/d3-format) to format numbers for human consumption.
+
+<a name="range" href="#range">#</a> d3.<b>range</b>([<i>start</i>, ]<i>stop</i>[, <i>step</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/range.js "Source")
+
+Returns an array containing an arithmetic progression, similar to the Python built-in [range](http://docs.python.org/library/functions.html#range). This method is often used to iterate over a sequence of uniformly-spaced numeric values, such as the indexes of an array or the ticks of a linear scale. (See also [d3.ticks](#ticks) for nicely-rounded values.)
+
+If *step* is omitted, it defaults to 1. If *start* is omitted, it defaults to 0. The *stop* value is exclusive; it is not included in the result. If *step* is positive, the last element is the largest *start* + *i* \* *step* less than *stop*; if *step* is negative, the last element is the smallest *start* + *i* \* *step* greater than *stop*. If the returned array would contain an infinite number of values, an empty range is returned.
+
+The arguments are not required to be integers; however, the results are more predictable if they are. The values in the returned array are defined as *start* + *i* \* *step*, where *i* is an integer from zero to one minus the total number of elements in the returned array. For example:
+
+```js
+d3.range(0, 1, 0.2) // [0, 0.2, 0.4, 0.6000000000000001, 0.8]
+```
+
+This unexpected behavior is due to IEEE 754 double-precision floating point, which defines 0.2 * 3 = 0.6000000000000001. Use [d3-format](https://github.com/d3/d3-format) to format numbers for human consumption with appropriate rounding; see also [linear.tickFormat](https://github.com/d3/d3-scale/blob/master/README.md#linear_tickFormat) in [d3-scale](https://github.com/d3/d3-scale).
+
+Likewise, if the returned array should have a specific length, consider using [array.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on an integer range. For example:
+
+```js
+d3.range(0, 1, 1 / 49); // BAD: returns 50 elements!
+d3.range(49).map(function(d) { return d / 49; }); // GOOD: returns 49 elements.
+```
+
+<a name="transpose" href="#transpose">#</a> d3.<b>transpose</b>(<i>matrix</i>) [<>](https://github.com/d3/d3-array/blob/master/src/transpose.js "Source")
+
+Uses the [zip](#zip) operator as a two-dimensional [matrix transpose](http://en.wikipedia.org/wiki/Transpose).
+
+<a name="zip" href="#zip">#</a> d3.<b>zip</b>(<i>arrays…</i>) [<>](https://github.com/d3/d3-array/blob/master/src/zip.js "Source")
+
+Returns an array of arrays, where the *i*th array contains the *i*th element from each of the argument *arrays*. The returned array is truncated in length to the shortest array in *arrays*. If *arrays* contains only a single array, the returned array contains one-element arrays. With no arguments, the returned array is empty.
+
+```js
+d3.zip([1, 2], [3, 4]); // returns [[1, 3], [2, 4]]
+```
+
+### Histograms
+
+[<img src="https://raw.githubusercontent.com/d3/d3-array/master/img/histogram.png" width="480" height="250" alt="Histogram">](http://bl.ocks.org/mbostock/3048450)
+
+Histograms bin many discrete samples into a smaller number of consecutive, non-overlapping intervals. They are often used to visualize the distribution of numerical data.
+
+<a name="histogram" href="#histogram">#</a> d3.<b>histogram</b>() [<>](https://github.com/d3/d3-array/blob/master/src/histogram.js "Source")
+
+Constructs a new histogram generator with the default settings.
+
+<a name="_histogram" href="#_histogram">#</a> <i>histogram</i>(<i>data</i>) [<>](https://github.com/d3/d3-array/blob/master/src/histogram.js#L14 "Source")
+
+Computes the histogram for the given array of *data* samples. Returns an array of bins, where each bin is an array containing the associated elements from the input *data*. Thus, the `length` of the bin is the number of elements in that bin. Each bin has two additional attributes:
+
+* `x0` - the lower bound of the bin (inclusive).
+* `x1` - the upper bound of the bin (exclusive, except for the last bin).
+
+<a name="histogram_value" href="#histogram_value">#</a> <i>histogram</i>.<b>value</b>([<i>value</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/histogram.js#L58 "Source")
+
+If *value* is specified, sets the value accessor to the specified function or constant and returns this histogram generator. If *value* is not specified, returns the current value accessor, which defaults to the identity function.
+
+When a histogram is [generated](#_histogram), the value accessor will be invoked for each element in the input data array, being passed the element `d`, the index `i`, and the array `data` as three arguments. The default value accessor assumes that the input data are orderable (comparable), such as numbers or dates. If your data are not, then you should specify an accessor that returns the corresponding orderable value for a given datum.
+
+This is similar to mapping your data to values before invoking the histogram generator, but has the benefit that the input data remains associated with the returned bins, thereby making it easier to access other fields of the data.
+
+<a name="histogram_domain" href="#histogram_domain">#</a> <i>histogram</i>.<b>domain</b>([<i>domain</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/histogram.js#L62 "Source")
+
+If *domain* is specified, sets the domain accessor to the specified function or array and returns this histogram generator. If *domain* is not specified, returns the current domain accessor, which defaults to [extent](#extent). The histogram domain is defined as an array [*min*, *max*], where *min* is the minimum observable value and *max* is the maximum observable value; both values are inclusive. Any value outside of this domain will be ignored when the histogram is [generated](#_histogram).
+
+For example, if you are using the the histogram in conjunction with a [linear scale](https://github.com/d3/d3-scale/blob/master/README.md#linear-scales) `x`, you might say:
+
+```js
+var histogram = d3.histogram()
+    .domain(x.domain())
+    .thresholds(x.ticks(20));
+```
+
+You can then compute the bins from an array of numbers like so:
+
+```js
+var bins = histogram(numbers);
+```
+
+Note that the domain accessor is invoked on the materialized array of [values](#histogram_value), not on the input data array.
+
+<a name="histogram_thresholds" href="#histogram_thresholds">#</a> <i>histogram</i>.<b>thresholds</b>([<i>count</i>]) [<>](https://github.com/d3/d3-array/blob/master/src/histogram.js#L66 "Source")
+<br><a name="histogram_thresholds" href="#histogram_thresholds">#</a> <i>histogram</i>.<b>thresholds</b>([<i>thresholds</i>])  [<>](https://github.com/d3/d3-array/blob/master/src/histogram.js#L66 "Source")
+
+If *thresholds* is specified, sets the [threshold generator](#histogram-thresholds) to the specified function or array and returns this histogram generator. If *thresholds* is not specified, returns the current threshold generator, which by default implements [Sturges’ formula](#thresholdSturges). (Thus by default, the histogram values must be numbers!) Thresholds are defined as an array of values [*x0*, *x1*, …]. Any value less than *x0* will be placed in the first bin; any value greater than or equal to *x0* but less than *x1* will be placed in the second bin; and so on. Thus, the [generated histogram](#_histogram) will have *thresholds*.length + 1 bins. See [histogram thresholds](#histogram-thresholds) for more information.
+
+Any threshold values outside the [domain](#histogram_domain) are ignored. The first *bin*.x0 is always equal to the minimum domain value, and the last *bin*.x1 is always equal to the maximum domain value.
+
+If a *count* is specified instead of an array of *thresholds*, then the [domain](#histogram_domain) will be uniformly divided into approximately *count* bins; see [ticks](#ticks).
+
+### Histogram Thresholds
+
+These functions are typically not used directly; instead, pass them to [*histogram*.thresholds](#histogram_thresholds). You may also implement your own threshold generator taking three arguments: the array of input [*values*](#histogram_value) derived from the data, and the [observable domain](#histogram_domain) represented as *min* and *max*. The generator may then return either the array of numeric thresholds or the *count* of bins; in the latter case the domain is divided uniformly into approximately *count* bins; see [ticks](#ticks).
+
+<a name="thresholdFreedmanDiaconis" href="#thresholdFreedmanDiaconis">#</a> d3.<b>thresholdFreedmanDiaconis</b>(<i>values</i>, <i>min</i>, <i>max</i>) [<>](https://github.com/d3/d3-array/blob/master/src/threshold/freedmanDiaconis.js "Source")
+
+Returns the number of bins according to the [Freedman–Diaconis rule](https://en.wikipedia.org/wiki/Histogram#Mathematical_definition); the input *values* must be numbers.
+
+<a name="thresholdScott" href="#thresholdScott">#</a> d3.<b>thresholdScott</b>(<i>values</i>, <i>min</i>, <i>max</i>) [<>](https://github.com/d3/d3-array/blob/master/src/threshold/scott.js "Source")
+
+Returns the number of bins according to [Scott’s normal reference rule](https://en.wikipedia.org/wiki/Histogram#Mathematical_definition); the input *values* must be numbers.
+
+<a name="thresholdSturges" href="#thresholdSturges">#</a> d3.<b>thresholdSturges</b>(<i>values</i>) [<>](https://github.com/d3/d3-array/blob/master/src/threshold/sturges.js "Source")
+
+Returns the number of bins according to [Sturges’ formula](https://en.wikipedia.org/wiki/Histogram#Mathematical_definition); the input *values* must be numbers.

node_modules/d3-geo-projection/node_modules/d3-array/dist/d3-array.js

@@ -0,0 +1,590 @@
+// https://d3js.org/d3-array/ v1.2.4 Copyright 2018 Mike Bostock
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+typeof define === 'function' && define.amd ? define(['exports'], factory) :
+(factory((global.d3 = global.d3 || {})));
+}(this, (function (exports) { 'use strict';
+
+function ascending(a, b) {
+  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}
+
+function bisector(compare) {
+  if (compare.length === 1) compare = ascendingComparator(compare);
+  return {
+    left: function(a, x, lo, hi) {
+      if (lo == null) lo = 0;
+      if (hi == null) hi = a.length;
+      while (lo < hi) {
+        var mid = lo + hi >>> 1;
+        if (compare(a[mid], x) < 0) lo = mid + 1;
+        else hi = mid;
+      }
+      return lo;
+    },
+    right: function(a, x, lo, hi) {
+      if (lo == null) lo = 0;
+      if (hi == null) hi = a.length;
+      while (lo < hi) {
+        var mid = lo + hi >>> 1;
+        if (compare(a[mid], x) > 0) hi = mid;
+        else lo = mid + 1;
+      }
+      return lo;
+    }
+  };
+}
+
+function ascendingComparator(f) {
+  return function(d, x) {
+    return ascending(f(d), x);
+  };
+}
+
+var ascendingBisect = bisector(ascending);
+var bisectRight = ascendingBisect.right;
+var bisectLeft = ascendingBisect.left;
+
+function pairs(array, f) {
+  if (f == null) f = pair;
+  var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);
+  while (i < n) pairs[i] = f(p, p = array[++i]);
+  return pairs;
+}
+
+function pair(a, b) {
+  return [a, b];
+}
+
+function cross(values0, values1, reduce) {
+  var n0 = values0.length,
+      n1 = values1.length,
+      values = new Array(n0 * n1),
+      i0,
+      i1,
+      i,
+      value0;
+
+  if (reduce == null) reduce = pair;
+
+  for (i0 = i = 0; i0 < n0; ++i0) {
+    for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) {
+      values[i] = reduce(value0, values1[i1]);
+    }
+  }
+
+  return values;
+}
+
+function descending(a, b) {
+  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}
+
+function number(x) {
+  return x === null ? NaN : +x;
+}
+
+function variance(values, valueof) {
+  var n = values.length,
+      m = 0,
+      i = -1,
+      mean = 0,
+      value,
+      delta,
+      sum = 0;
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (!isNaN(value = number(values[i]))) {
+        delta = value - mean;
+        mean += delta / ++m;
+        sum += delta * (value - mean);
+      }
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (!isNaN(value = number(valueof(values[i], i, values)))) {
+        delta = value - mean;
+        mean += delta / ++m;
+        sum += delta * (value - mean);
+      }
+    }
+  }
+
+  if (m > 1) return sum / (m - 1);
+}
+
+function deviation(array, f) {
+  var v = variance(array, f);
+  return v ? Math.sqrt(v) : v;
+}
+
+function extent(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      min,
+      max;
+
+  if (valueof == null) {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = values[i]) != null && value >= value) {
+        min = max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = values[i]) != null) {
+            if (min > value) min = value;
+            if (max < value) max = value;
+          }
+        }
+      }
+    }
+  }
+
+  else {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = valueof(values[i], i, values)) != null && value >= value) {
+        min = max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = valueof(values[i], i, values)) != null) {
+            if (min > value) min = value;
+            if (max < value) max = value;
+          }
+        }
+      }
+    }
+  }
+
+  return [min, max];
+}
+
+var array = Array.prototype;
+
+var slice = array.slice;
+var map = array.map;
+
+function constant(x) {
+  return function() {
+    return x;
+  };
+}
+
+function identity(x) {
+  return x;
+}
+
+function range(start, stop, step) {
+  start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
+
+  var i = -1,
+      n = Math.max(0, Math.ceil((stop - start) / step)) | 0,
+      range = new Array(n);
+
+  while (++i < n) {
+    range[i] = start + i * step;
+  }
+
+  return range;
+}
+
+var e10 = Math.sqrt(50),
+    e5 = Math.sqrt(10),
+    e2 = Math.sqrt(2);
+
+function ticks(start, stop, count) {
+  var reverse,
+      i = -1,
+      n,
+      ticks,
+      step;
+
+  stop = +stop, start = +start, count = +count;
+  if (start === stop && count > 0) return [start];
+  if (reverse = stop < start) n = start, start = stop, stop = n;
+  if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];
+
+  if (step > 0) {
+    start = Math.ceil(start / step);
+    stop = Math.floor(stop / step);
+    ticks = new Array(n = Math.ceil(stop - start + 1));
+    while (++i < n) ticks[i] = (start + i) * step;
+  } else {
+    start = Math.floor(start * step);
+    stop = Math.ceil(stop * step);
+    ticks = new Array(n = Math.ceil(start - stop + 1));
+    while (++i < n) ticks[i] = (start - i) / step;
+  }
+
+  if (reverse) ticks.reverse();
+
+  return ticks;
+}
+
+function tickIncrement(start, stop, count) {
+  var step = (stop - start) / Math.max(0, count),
+      power = Math.floor(Math.log(step) / Math.LN10),
+      error = step / Math.pow(10, power);
+  return power >= 0
+      ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)
+      : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
+}
+
+function tickStep(start, stop, count) {
+  var step0 = Math.abs(stop - start) / Math.max(0, count),
+      step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),
+      error = step0 / step1;
+  if (error >= e10) step1 *= 10;
+  else if (error >= e5) step1 *= 5;
+  else if (error >= e2) step1 *= 2;
+  return stop < start ? -step1 : step1;
+}
+
+function sturges(values) {
+  return Math.ceil(Math.log(values.length) / Math.LN2) + 1;
+}
+
+function histogram() {
+  var value = identity,
+      domain = extent,
+      threshold = sturges;
+
+  function histogram(data) {
+    var i,
+        n = data.length,
+        x,
+        values = new Array(n);
+
+    for (i = 0; i < n; ++i) {
+      values[i] = value(data[i], i, data);
+    }
+
+    var xz = domain(values),
+        x0 = xz[0],
+        x1 = xz[1],
+        tz = threshold(values, x0, x1);
+
+    // Convert number of thresholds into uniform thresholds.
+    if (!Array.isArray(tz)) {
+      tz = tickStep(x0, x1, tz);
+      tz = range(Math.ceil(x0 / tz) * tz, x1, tz); // exclusive
+    }
+
+    // Remove any thresholds outside the domain.
+    var m = tz.length;
+    while (tz[0] <= x0) tz.shift(), --m;
+    while (tz[m - 1] > x1) tz.pop(), --m;
+
+    var bins = new Array(m + 1),
+        bin;
+
+    // Initialize bins.
+    for (i = 0; i <= m; ++i) {
+      bin = bins[i] = [];
+      bin.x0 = i > 0 ? tz[i - 1] : x0;
+      bin.x1 = i < m ? tz[i] : x1;
+    }
+
+    // Assign data to bins by value, ignoring any outside the domain.
+    for (i = 0; i < n; ++i) {
+      x = values[i];
+      if (x0 <= x && x <= x1) {
+        bins[bisectRight(tz, x, 0, m)].push(data[i]);
+      }
+    }
+
+    return bins;
+  }
+
+  histogram.value = function(_) {
+    return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value;
+  };
+
+  histogram.domain = function(_) {
+    return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain;
+  };
+
+  histogram.thresholds = function(_) {
+    return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;
+  };
+
+  return histogram;
+}
+
+function quantile(values, p, valueof) {
+  if (valueof == null) valueof = number;
+  if (!(n = values.length)) return;
+  if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
+  if (p >= 1) return +valueof(values[n - 1], n - 1, values);
+  var n,
+      i = (n - 1) * p,
+      i0 = Math.floor(i),
+      value0 = +valueof(values[i0], i0, values),
+      value1 = +valueof(values[i0 + 1], i0 + 1, values);
+  return value0 + (value1 - value0) * (i - i0);
+}
+
+function freedmanDiaconis(values, min, max) {
+  values = map.call(values, number).sort(ascending);
+  return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(values, 0.25)) * Math.pow(values.length, -1 / 3)));
+}
+
+function scott(values, min, max) {
+  return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));
+}
+
+function max(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      max;
+
+  if (valueof == null) {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = values[i]) != null && value >= value) {
+        max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = values[i]) != null && value > max) {
+            max = value;
+          }
+        }
+      }
+    }
+  }
+
+  else {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = valueof(values[i], i, values)) != null && value >= value) {
+        max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = valueof(values[i], i, values)) != null && value > max) {
+            max = value;
+          }
+        }
+      }
+    }
+  }
+
+  return max;
+}
+
+function mean(values, valueof) {
+  var n = values.length,
+      m = n,
+      i = -1,
+      value,
+      sum = 0;
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (!isNaN(value = number(values[i]))) sum += value;
+      else --m;
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value;
+      else --m;
+    }
+  }
+
+  if (m) return sum / m;
+}
+
+function median(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      numbers = [];
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (!isNaN(value = number(values[i]))) {
+        numbers.push(value);
+      }
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (!isNaN(value = number(valueof(values[i], i, values)))) {
+        numbers.push(value);
+      }
+    }
+  }
+
+  return quantile(numbers.sort(ascending), 0.5);
+}
+
+function merge(arrays) {
+  var n = arrays.length,
+      m,
+      i = -1,
+      j = 0,
+      merged,
+      array;
+
+  while (++i < n) j += arrays[i].length;
+  merged = new Array(j);
+
+  while (--n >= 0) {
+    array = arrays[n];
+    m = array.length;
+    while (--m >= 0) {
+      merged[--j] = array[m];
+    }
+  }
+
+  return merged;
+}
+
+function min(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      min;
+
+  if (valueof == null) {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = values[i]) != null && value >= value) {
+        min = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = values[i]) != null && min > value) {
+            min = value;
+          }
+        }
+      }
+    }
+  }
+
+  else {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = valueof(values[i], i, values)) != null && value >= value) {
+        min = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = valueof(values[i], i, values)) != null && min > value) {
+            min = value;
+          }
+        }
+      }
+    }
+  }
+
+  return min;
+}
+
+function permute(array, indexes) {
+  var i = indexes.length, permutes = new Array(i);
+  while (i--) permutes[i] = array[indexes[i]];
+  return permutes;
+}
+
+function scan(values, compare) {
+  if (!(n = values.length)) return;
+  var n,
+      i = 0,
+      j = 0,
+      xi,
+      xj = values[j];
+
+  if (compare == null) compare = ascending;
+
+  while (++i < n) {
+    if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) {
+      xj = xi, j = i;
+    }
+  }
+
+  if (compare(xj, xj) === 0) return j;
+}
+
+function shuffle(array, i0, i1) {
+  var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0),
+      t,
+      i;
+
+  while (m) {
+    i = Math.random() * m-- | 0;
+    t = array[m + i0];
+    array[m + i0] = array[i + i0];
+    array[i + i0] = t;
+  }
+
+  return array;
+}
+
+function sum(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      sum = 0;
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (value = +values[i]) sum += value; // Note: zero and null are equivalent.
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (value = +valueof(values[i], i, values)) sum += value;
+    }
+  }
+
+  return sum;
+}
+
+function transpose(matrix) {
+  if (!(n = matrix.length)) return [];
+  for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {
+    for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {
+      row[j] = matrix[j][i];
+    }
+  }
+  return transpose;
+}
+
+function length(d) {
+  return d.length;
+}
+
+function zip() {
+  return transpose(arguments);
+}
+
+exports.bisect = bisectRight;
+exports.bisectRight = bisectRight;
+exports.bisectLeft = bisectLeft;
+exports.ascending = ascending;
+exports.bisector = bisector;
+exports.cross = cross;
+exports.descending = descending;
+exports.deviation = deviation;
+exports.extent = extent;
+exports.histogram = histogram;
+exports.thresholdFreedmanDiaconis = freedmanDiaconis;
+exports.thresholdScott = scott;
+exports.thresholdSturges = sturges;
+exports.max = max;
+exports.mean = mean;
+exports.median = median;
+exports.merge = merge;
+exports.min = min;
+exports.pairs = pairs;
+exports.permute = permute;
+exports.quantile = quantile;
+exports.range = range;
+exports.scan = scan;
+exports.shuffle = shuffle;
+exports.sum = sum;
+exports.ticks = ticks;
+exports.tickIncrement = tickIncrement;
+exports.tickStep = tickStep;
+exports.transpose = transpose;
+exports.variance = variance;
+exports.zip = zip;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

node_modules/d3-geo-projection/node_modules/d3-array/package.json

@@ -0,0 +1,70 @@
+{
+  "_from": "d3-array@1",
+  "_id": "d3-array@1.2.4",
+  "_inBundle": false,
+  "_integrity": "sha512-KHW6M86R+FUPYGb3R5XiYjXPq7VzwxZ22buHhAEVG5ztoEcZZMLov530mmccaqA1GghZArjQV46fuc8kUqhhHw==",
+  "_location": "/d3-geo-projection/d3-array",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "d3-array@1",
+    "name": "d3-array",
+    "escapedName": "d3-array",
+    "rawSpec": "1",
+    "saveSpec": null,
+    "fetchSpec": "1"
+  },
+  "_requiredBy": [
+    "/d3-geo-projection"
+  ],
+  "_resolved": "https://registry.npmjs.org/d3-array/-/d3-array-1.2.4.tgz",
+  "_shasum": "635ce4d5eea759f6f605863dbcfc30edc737f71f",
+  "_spec": "d3-array@1",
+  "_where": "/home/prabhatdev/Documents/opensource/gitHubStats/waka-readme-stats/node_modules/d3-geo-projection",
+  "author": {
+    "name": "Mike Bostock",
+    "url": "http://bost.ocks.org/mike"
+  },
+  "bugs": {
+    "url": "https://github.com/d3/d3-array/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Array manipulation, ordering, searching, summarizing, etc.",
+  "devDependencies": {
+    "eslint": "5",
+    "rollup": "0.64",
+    "rollup-plugin-terser": "1",
+    "seedrandom": "2",
+    "tape": "4"
+  },
+  "homepage": "https://d3js.org/d3-array/",
+  "keywords": [
+    "d3",
+    "d3-module",
+    "histogram",
+    "bisect",
+    "shuffle",
+    "statistics",
+    "search",
+    "sort",
+    "array"
+  ],
+  "license": "BSD-3-Clause",
+  "main": "dist/d3-array.js",
+  "module": "src/index.js",
+  "name": "d3-array",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/d3/d3-array.git"
+  },
+  "scripts": {
+    "postpublish": "git push && git push --tags && cd ../d3.github.com && git pull && cp ../${npm_package_name}/dist/${npm_package_name}.js ${npm_package_name}.v${npm_package_version%%.*}.js && cp ../${npm_package_name}/dist/${npm_package_name}.min.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git add ${npm_package_name}.v${npm_package_version%%.*}.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git commit -m \"${npm_package_name} ${npm_package_version}\" && git push && cd - && 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"
+  },
+  "unpkg": "dist/d3-array.min.js",
+  "version": "1.2.4"
+}

node_modules/d3-geo-projection/node_modules/d3-array/rollup.config.js

@@ -0,0 +1,36 @@
+import {terser} from "rollup-plugin-terser";
+import * as meta from "./package.json";
+
+const config = {
+  input: "src/index.js",
+  external: Object.keys(meta.dependencies || {}).filter(key => /^d3-/.test(key)),
+  output: {
+    file: `dist/${meta.name}.js`,
+    name: "d3",
+    format: "umd",
+    indent: false,
+    extend: true,
+    banner: `// ${meta.homepage} v${meta.version} Copyright ${(new Date).getFullYear()} ${meta.author.name}`,
+    globals: Object.assign({}, ...Object.keys(meta.dependencies || {}).filter(key => /^d3-/.test(key)).map(key => ({[key]: "d3"})))
+  },
+  plugins: []
+};
+
+export default [
+  config,
+  {
+    ...config,
+    output: {
+      ...config.output,
+      file: `dist/${meta.name}.min.js`
+    },
+    plugins: [
+      ...config.plugins,
+      terser({
+        output: {
+          preamble: config.output.banner
+        }
+      })
+    ]
+  }
+];

node_modules/d3-geo-projection/node_modules/d3-array/src/array.js

@@ -0,0 +1,4 @@
+var array = Array.prototype;
+
+export var slice = array.slice;
+export var map = array.map;

node_modules/d3-geo-projection/node_modules/d3-array/src/ascending.js

@@ -0,0 +1,3 @@
+export default function(a, b) {
+  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/bisect.js

@@ -0,0 +1,7 @@
+import ascending from "./ascending";
+import bisector from "./bisector";
+
+var ascendingBisect = bisector(ascending);
+export var bisectRight = ascendingBisect.right;
+export var bisectLeft = ascendingBisect.left;
+export default bisectRight;

node_modules/d3-geo-projection/node_modules/d3-array/src/bisector.js

@@ -0,0 +1,33 @@
+import ascending from "./ascending";
+
+export default function(compare) {
+  if (compare.length === 1) compare = ascendingComparator(compare);
+  return {
+    left: function(a, x, lo, hi) {
+      if (lo == null) lo = 0;
+      if (hi == null) hi = a.length;
+      while (lo < hi) {
+        var mid = lo + hi >>> 1;
+        if (compare(a[mid], x) < 0) lo = mid + 1;
+        else hi = mid;
+      }
+      return lo;
+    },
+    right: function(a, x, lo, hi) {
+      if (lo == null) lo = 0;
+      if (hi == null) hi = a.length;
+      while (lo < hi) {
+        var mid = lo + hi >>> 1;
+        if (compare(a[mid], x) > 0) hi = mid;
+        else lo = mid + 1;
+      }
+      return lo;
+    }
+  };
+}
+
+function ascendingComparator(f) {
+  return function(d, x) {
+    return ascending(f(d), x);
+  };
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/constant.js

@@ -0,0 +1,5 @@
+export default function(x) {
+  return function() {
+    return x;
+  };
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/cross.js

@@ -0,0 +1,21 @@
+import {pair} from "./pairs";
+
+export default function(values0, values1, reduce) {
+  var n0 = values0.length,
+      n1 = values1.length,
+      values = new Array(n0 * n1),
+      i0,
+      i1,
+      i,
+      value0;
+
+  if (reduce == null) reduce = pair;
+
+  for (i0 = i = 0; i0 < n0; ++i0) {
+    for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) {
+      values[i] = reduce(value0, values1[i1]);
+    }
+  }
+
+  return values;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/descending.js

@@ -0,0 +1,3 @@
+export default function(a, b) {
+  return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/deviation.js

@@ -0,0 +1,6 @@
+import variance from "./variance";
+
+export default function(array, f) {
+  var v = variance(array, f);
+  return v ? Math.sqrt(v) : v;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/extent.js

@@ -0,0 +1,37 @@
+export default function(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      min,
+      max;
+
+  if (valueof == null) {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = values[i]) != null && value >= value) {
+        min = max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = values[i]) != null) {
+            if (min > value) min = value;
+            if (max < value) max = value;
+          }
+        }
+      }
+    }
+  }
+
+  else {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = valueof(values[i], i, values)) != null && value >= value) {
+        min = max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = valueof(values[i], i, values)) != null) {
+            if (min > value) min = value;
+            if (max < value) max = value;
+          }
+        }
+      }
+    }
+  }
+
+  return [min, max];
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/histogram.js

@@ -0,0 +1,75 @@
+import {slice} from "./array";
+import bisect from "./bisect";
+import constant from "./constant";
+import extent from "./extent";
+import identity from "./identity";
+import range from "./range";
+import {tickStep} from "./ticks";
+import sturges from "./threshold/sturges";
+
+export default function() {
+  var value = identity,
+      domain = extent,
+      threshold = sturges;
+
+  function histogram(data) {
+    var i,
+        n = data.length,
+        x,
+        values = new Array(n);
+
+    for (i = 0; i < n; ++i) {
+      values[i] = value(data[i], i, data);
+    }
+
+    var xz = domain(values),
+        x0 = xz[0],
+        x1 = xz[1],
+        tz = threshold(values, x0, x1);
+
+    // Convert number of thresholds into uniform thresholds.
+    if (!Array.isArray(tz)) {
+      tz = tickStep(x0, x1, tz);
+      tz = range(Math.ceil(x0 / tz) * tz, x1, tz); // exclusive
+    }
+
+    // Remove any thresholds outside the domain.
+    var m = tz.length;
+    while (tz[0] <= x0) tz.shift(), --m;
+    while (tz[m - 1] > x1) tz.pop(), --m;
+
+    var bins = new Array(m + 1),
+        bin;
+
+    // Initialize bins.
+    for (i = 0; i <= m; ++i) {
+      bin = bins[i] = [];
+      bin.x0 = i > 0 ? tz[i - 1] : x0;
+      bin.x1 = i < m ? tz[i] : x1;
+    }
+
+    // Assign data to bins by value, ignoring any outside the domain.
+    for (i = 0; i < n; ++i) {
+      x = values[i];
+      if (x0 <= x && x <= x1) {
+        bins[bisect(tz, x, 0, m)].push(data[i]);
+      }
+    }
+
+    return bins;
+  }
+
+  histogram.value = function(_) {
+    return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value;
+  };
+
+  histogram.domain = function(_) {
+    return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain;
+  };
+
+  histogram.thresholds = function(_) {
+    return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;
+  };
+
+  return histogram;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/identity.js

@@ -0,0 +1,3 @@
+export default function(x) {
+  return x;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/index.js

@@ -0,0 +1,27 @@
+export {default as bisect, bisectRight, bisectLeft} from "./bisect";
+export {default as ascending} from "./ascending";
+export {default as bisector} from "./bisector";
+export {default as cross} from "./cross";
+export {default as descending} from "./descending";
+export {default as deviation} from "./deviation";
+export {default as extent} from "./extent";
+export {default as histogram} from "./histogram";
+export {default as thresholdFreedmanDiaconis} from "./threshold/freedmanDiaconis";
+export {default as thresholdScott} from "./threshold/scott";
+export {default as thresholdSturges} from "./threshold/sturges";
+export {default as max} from "./max";
+export {default as mean} from "./mean";
+export {default as median} from "./median";
+export {default as merge} from "./merge";
+export {default as min} from "./min";
+export {default as pairs} from "./pairs";
+export {default as permute} from "./permute";
+export {default as quantile} from "./quantile";
+export {default as range} from "./range";
+export {default as scan} from "./scan";
+export {default as shuffle} from "./shuffle";
+export {default as sum} from "./sum";
+export {default as ticks, tickIncrement, tickStep} from "./ticks";
+export {default as transpose} from "./transpose";
+export {default as variance} from "./variance";
+export {default as zip} from "./zip";

node_modules/d3-geo-projection/node_modules/d3-array/src/max.js

@@ -0,0 +1,34 @@
+export default function(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      max;
+
+  if (valueof == null) {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = values[i]) != null && value >= value) {
+        max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = values[i]) != null && value > max) {
+            max = value;
+          }
+        }
+      }
+    }
+  }
+
+  else {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = valueof(values[i], i, values)) != null && value >= value) {
+        max = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = valueof(values[i], i, values)) != null && value > max) {
+            max = value;
+          }
+        }
+      }
+    }
+  }
+
+  return max;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/mean.js

@@ -0,0 +1,25 @@
+import number from "./number";
+
+export default function(values, valueof) {
+  var n = values.length,
+      m = n,
+      i = -1,
+      value,
+      sum = 0;
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (!isNaN(value = number(values[i]))) sum += value;
+      else --m;
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value;
+      else --m;
+    }
+  }
+
+  if (m) return sum / m;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/median.js

@@ -0,0 +1,28 @@
+import ascending from "./ascending";
+import number from "./number";
+import quantile from "./quantile";
+
+export default function(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      numbers = [];
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (!isNaN(value = number(values[i]))) {
+        numbers.push(value);
+      }
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (!isNaN(value = number(valueof(values[i], i, values)))) {
+        numbers.push(value);
+      }
+    }
+  }
+
+  return quantile(numbers.sort(ascending), 0.5);
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/merge.js

@@ -0,0 +1,21 @@
+export default function(arrays) {
+  var n = arrays.length,
+      m,
+      i = -1,
+      j = 0,
+      merged,
+      array;
+
+  while (++i < n) j += arrays[i].length;
+  merged = new Array(j);
+
+  while (--n >= 0) {
+    array = arrays[n];
+    m = array.length;
+    while (--m >= 0) {
+      merged[--j] = array[m];
+    }
+  }
+
+  return merged;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/min.js

@@ -0,0 +1,34 @@
+export default function(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      min;
+
+  if (valueof == null) {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = values[i]) != null && value >= value) {
+        min = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = values[i]) != null && min > value) {
+            min = value;
+          }
+        }
+      }
+    }
+  }
+
+  else {
+    while (++i < n) { // Find the first comparable value.
+      if ((value = valueof(values[i], i, values)) != null && value >= value) {
+        min = value;
+        while (++i < n) { // Compare the remaining values.
+          if ((value = valueof(values[i], i, values)) != null && min > value) {
+            min = value;
+          }
+        }
+      }
+    }
+  }
+
+  return min;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/number.js

@@ -0,0 +1,3 @@
+export default function(x) {
+  return x === null ? NaN : +x;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/pairs.js

@@ -0,0 +1,10 @@
+export default function(array, f) {
+  if (f == null) f = pair;
+  var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n);
+  while (i < n) pairs[i] = f(p, p = array[++i]);
+  return pairs;
+}
+
+export function pair(a, b) {
+  return [a, b];
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/permute.js

@@ -0,0 +1,5 @@
+export default function(array, indexes) {
+  var i = indexes.length, permutes = new Array(i);
+  while (i--) permutes[i] = array[indexes[i]];
+  return permutes;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/quantile.js

@@ -0,0 +1,14 @@
+import number from "./number";
+
+export default function(values, p, valueof) {
+  if (valueof == null) valueof = number;
+  if (!(n = values.length)) return;
+  if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
+  if (p >= 1) return +valueof(values[n - 1], n - 1, values);
+  var n,
+      i = (n - 1) * p,
+      i0 = Math.floor(i),
+      value0 = +valueof(values[i0], i0, values),
+      value1 = +valueof(values[i0 + 1], i0 + 1, values);
+  return value0 + (value1 - value0) * (i - i0);
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/range.js

@@ -0,0 +1,13 @@
+export default function(start, stop, step) {
+  start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
+
+  var i = -1,
+      n = Math.max(0, Math.ceil((stop - start) / step)) | 0,
+      range = new Array(n);
+
+  while (++i < n) {
+    range[i] = start + i * step;
+  }
+
+  return range;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/scan.js

@@ -0,0 +1,20 @@
+import ascending from "./ascending";
+
+export default function(values, compare) {
+  if (!(n = values.length)) return;
+  var n,
+      i = 0,
+      j = 0,
+      xi,
+      xj = values[j];
+
+  if (compare == null) compare = ascending;
+
+  while (++i < n) {
+    if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) {
+      xj = xi, j = i;
+    }
+  }
+
+  if (compare(xj, xj) === 0) return j;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/shuffle.js

@@ -0,0 +1,14 @@
+export default function(array, i0, i1) {
+  var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0),
+      t,
+      i;
+
+  while (m) {
+    i = Math.random() * m-- | 0;
+    t = array[m + i0];
+    array[m + i0] = array[i + i0];
+    array[i + i0] = t;
+  }
+
+  return array;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/sum.js

@@ -0,0 +1,20 @@
+export default function(values, valueof) {
+  var n = values.length,
+      i = -1,
+      value,
+      sum = 0;
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (value = +values[i]) sum += value; // Note: zero and null are equivalent.
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (value = +valueof(values[i], i, values)) sum += value;
+    }
+  }
+
+  return sum;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/threshold/freedmanDiaconis.js

@@ -0,0 +1,9 @@
+import {map} from "../array";
+import ascending from "../ascending";
+import number from "../number";
+import quantile from "../quantile";
+
+export default function(values, min, max) {
+  values = map.call(values, number).sort(ascending);
+  return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(values, 0.25)) * Math.pow(values.length, -1 / 3)));
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/threshold/scott.js

@@ -0,0 +1,5 @@
+import deviation from "../deviation";
+
+export default function(values, min, max) {
+  return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3)));
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/threshold/sturges.js

@@ -0,0 +1,3 @@
+export default function(values) {
+  return Math.ceil(Math.log(values.length) / Math.LN2) + 1;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/ticks.js

@@ -0,0 +1,51 @@
+var e10 = Math.sqrt(50),
+    e5 = Math.sqrt(10),
+    e2 = Math.sqrt(2);
+
+export default function(start, stop, count) {
+  var reverse,
+      i = -1,
+      n,
+      ticks,
+      step;
+
+  stop = +stop, start = +start, count = +count;
+  if (start === stop && count > 0) return [start];
+  if (reverse = stop < start) n = start, start = stop, stop = n;
+  if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];
+
+  if (step > 0) {
+    start = Math.ceil(start / step);
+    stop = Math.floor(stop / step);
+    ticks = new Array(n = Math.ceil(stop - start + 1));
+    while (++i < n) ticks[i] = (start + i) * step;
+  } else {
+    start = Math.floor(start * step);
+    stop = Math.ceil(stop * step);
+    ticks = new Array(n = Math.ceil(start - stop + 1));
+    while (++i < n) ticks[i] = (start - i) / step;
+  }
+
+  if (reverse) ticks.reverse();
+
+  return ticks;
+}
+
+export function tickIncrement(start, stop, count) {
+  var step = (stop - start) / Math.max(0, count),
+      power = Math.floor(Math.log(step) / Math.LN10),
+      error = step / Math.pow(10, power);
+  return power >= 0
+      ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)
+      : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
+}
+
+export function tickStep(start, stop, count) {
+  var step0 = Math.abs(stop - start) / Math.max(0, count),
+      step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),
+      error = step0 / step1;
+  if (error >= e10) step1 *= 10;
+  else if (error >= e5) step1 *= 5;
+  else if (error >= e2) step1 *= 2;
+  return stop < start ? -step1 : step1;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/transpose.js

@@ -0,0 +1,15 @@
+import min from "./min";
+
+export default function(matrix) {
+  if (!(n = matrix.length)) return [];
+  for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {
+    for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {
+      row[j] = matrix[j][i];
+    }
+  }
+  return transpose;
+}
+
+function length(d) {
+  return d.length;
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/variance.js

@@ -0,0 +1,33 @@
+import number from "./number";
+
+export default function(values, valueof) {
+  var n = values.length,
+      m = 0,
+      i = -1,
+      mean = 0,
+      value,
+      delta,
+      sum = 0;
+
+  if (valueof == null) {
+    while (++i < n) {
+      if (!isNaN(value = number(values[i]))) {
+        delta = value - mean;
+        mean += delta / ++m;
+        sum += delta * (value - mean);
+      }
+    }
+  }
+
+  else {
+    while (++i < n) {
+      if (!isNaN(value = number(valueof(values[i], i, values)))) {
+        delta = value - mean;
+        mean += delta / ++m;
+        sum += delta * (value - mean);
+      }
+    }
+  }
+
+  if (m > 1) return sum / (m - 1);
+}

node_modules/d3-geo-projection/node_modules/d3-array/src/zip.js

@@ -0,0 +1,5 @@
+import transpose from "./transpose";
+
+export default function() {
+  return transpose(arguments);
+}

node_modules/d3-geo-projection/node_modules/d3-array/yarn.lock

@@ -0,0 +1,939 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@babel/code-frame@^7.0.0-beta.47":
+  version "7.0.0-rc.3"
+  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.0.0-rc.3.tgz#d77a587401f818a3168700f596e41cd6905947b2"
+  dependencies:
+    "@babel/highlight" "7.0.0-rc.3"
+
+"@babel/highlight@7.0.0-rc.3":
+  version "7.0.0-rc.3"
+  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.0.0-rc.3.tgz#c2ee83f8e5c0c387279a8c48e06fef2e32027004"
+  dependencies:
+    chalk "^2.0.0"
+    esutils "^2.0.2"
+    js-tokens "^4.0.0"
+
+"@types/estree@0.0.39":
+  version "0.0.39"
+  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.39.tgz#e177e699ee1b8c22d23174caaa7422644389509f"
+
+"@types/node@*":
+  version "10.9.1"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-10.9.1.tgz#06f002136fbcf51e730995149050bb3c45ee54e6"
+
+acorn-jsx@^4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-4.1.1.tgz#e8e41e48ea2fe0c896740610ab6a4ffd8add225e"
+  dependencies:
+    acorn "^5.0.3"
+
+acorn@^5.0.3, acorn@^5.6.0:
+  version "5.7.2"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-5.7.2.tgz#91fa871883485d06708800318404e72bfb26dcc5"
+
+ajv-keywords@^3.0.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.2.0.tgz#e86b819c602cf8821ad637413698f1dec021847a"
+
+ajv@^6.0.1, ajv@^6.5.0:
+  version "6.5.3"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.5.3.tgz#71a569d189ecf4f4f321224fecb166f071dd90f9"
+  dependencies:
+    fast-deep-equal "^2.0.1"
+    fast-json-stable-stringify "^2.0.0"
+    json-schema-traverse "^0.4.1"
+    uri-js "^4.2.2"
+
+ansi-escapes@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-3.1.0.tgz#f73207bb81207d75fd6c83f125af26eea378ca30"
+
+ansi-regex@^2.0.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
+
+ansi-regex@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.0.tgz#ed0317c322064f79466c02966bddb605ab37d998"
+
+ansi-styles@^2.2.1:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe"
+
+ansi-styles@^3.2.1:
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
+  dependencies:
+    color-convert "^1.9.0"
+
+argparse@^1.0.7:
+  version "1.0.10"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
+  dependencies:
+    sprintf-js "~1.0.2"
+
+array-union@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/array-union/-/array-union-1.0.2.tgz#9a34410e4f4e3da23dea375be5be70f24778ec39"
+  dependencies:
+    array-uniq "^1.0.1"
+
+array-uniq@^1.0.1:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6"
+
+arrify@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
+
+babel-code-frame@^6.26.0:
+  version "6.26.0"
+  resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.26.0.tgz#63fd43f7dc1e3bb7ce35947db8fe369a3f58c74b"
+  dependencies:
+    chalk "^1.1.3"
+    esutils "^2.0.2"
+    js-tokens "^3.0.2"
+
+balanced-match@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767"
+
+brace-expansion@^1.1.7:
+  version "1.1.11"
+  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
+  dependencies:
+    balanced-match "^1.0.0"
+    concat-map "0.0.1"
+
+buffer-from@^1.0.0:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
+
+caller-path@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/caller-path/-/caller-path-0.1.0.tgz#94085ef63581ecd3daa92444a8fe94e82577751f"
+  dependencies:
+    callsites "^0.2.0"
+
+callsites@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/callsites/-/callsites-0.2.0.tgz#afab96262910a7f33c19a5775825c69f34e350ca"
+
+chalk@^1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98"
+  dependencies:
+    ansi-styles "^2.2.1"
+    escape-string-regexp "^1.0.2"
+    has-ansi "^2.0.0"
+    strip-ansi "^3.0.0"
+    supports-color "^2.0.0"
+
+chalk@^2.0.0, chalk@^2.1.0:
+  version "2.4.1"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.1.tgz#18c49ab16a037b6eb0152cc83e3471338215b66e"
+  dependencies:
+    ansi-styles "^3.2.1"
+    escape-string-regexp "^1.0.5"
+    supports-color "^5.3.0"
+
+chardet@^0.4.0:
+  version "0.4.2"
+  resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.4.2.tgz#b5473b33dc97c424e5d98dc87d55d4d8a29c8bf2"
+
+circular-json@^0.3.1:
+  version "0.3.3"
+  resolved "https://registry.yarnpkg.com/circular-json/-/circular-json-0.3.3.tgz#815c99ea84f6809529d2f45791bdf82711352d66"
+
+cli-cursor@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5"
+  dependencies:
+    restore-cursor "^2.0.0"
+
+cli-width@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-2.2.0.tgz#ff19ede8a9a5e579324147b0c11f0fbcbabed639"
+
+color-convert@^1.9.0:
+  version "1.9.2"
+  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.2.tgz#49881b8fba67df12a96bdf3f56c0aab9e7913147"
+  dependencies:
+    color-name "1.1.1"
+
+color-name@1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.1.tgz#4b1415304cf50028ea81643643bd82ea05803689"
+
+commander@~2.16.0:
+  version "2.16.0"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-2.16.0.tgz#f16390593996ceb4f3eeb020b31d78528f7f8a50"
+
+concat-map@0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
+
+cross-spawn@^6.0.5:
+  version "6.0.5"
+  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
+  dependencies:
+    nice-try "^1.0.4"
+    path-key "^2.0.1"
+    semver "^5.5.0"
+    shebang-command "^1.2.0"
+    which "^1.2.9"
+
+debug@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"
+  dependencies:
+    ms "2.0.0"
+
+deep-equal@~1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/deep-equal/-/deep-equal-1.0.1.tgz#f5d260292b660e084eff4cdbc9f08ad3247448b5"
+
+deep-is@~0.1.3:
+  version "0.1.3"
+  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
+
+define-properties@^1.1.2:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1"
+  dependencies:
+    object-keys "^1.0.12"
+
+defined@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/defined/-/defined-1.0.0.tgz#c98d9bcef75674188e110969151199e39b1fa693"
+
+del@^2.0.2:
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/del/-/del-2.2.2.tgz#c12c981d067846c84bcaf862cff930d907ffd1a8"
+  dependencies:
+    globby "^5.0.0"
+    is-path-cwd "^1.0.0"
+    is-path-in-cwd "^1.0.0"
+    object-assign "^4.0.1"
+    pify "^2.0.0"
+    pinkie-promise "^2.0.0"
+    rimraf "^2.2.8"
+
+doctrine@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-2.1.0.tgz#5cd01fc101621b42c4cd7f5d1a66243716d3f39d"
+  dependencies:
+    esutils "^2.0.2"
+
+es-abstract@^1.5.0:
+  version "1.12.0"
+  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.12.0.tgz#9dbbdd27c6856f0001421ca18782d786bf8a6165"
+  dependencies:
+    es-to-primitive "^1.1.1"
+    function-bind "^1.1.1"
+    has "^1.0.1"
+    is-callable "^1.1.3"
+    is-regex "^1.0.4"
+
+es-to-primitive@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.1.1.tgz#45355248a88979034b6792e19bb81f2b7975dd0d"
+  dependencies:
+    is-callable "^1.1.1"
+    is-date-object "^1.0.1"
+    is-symbol "^1.0.1"
+
+escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
+
+eslint-scope@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-4.0.0.tgz#50bf3071e9338bcdc43331794a0cb533f0136172"
+  dependencies:
+    esrecurse "^4.1.0"
+    estraverse "^4.1.1"
+
+eslint-utils@^1.3.1:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-1.3.1.tgz#9a851ba89ee7c460346f97cf8939c7298827e512"
+
+eslint-visitor-keys@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz#3f3180fb2e291017716acb4c9d6d5b5c34a6a81d"
+
+eslint@5:
+  version "5.4.0"
+  resolved "https://registry.yarnpkg.com/eslint/-/eslint-5.4.0.tgz#d068ec03006bb9e06b429dc85f7e46c1b69fac62"
+  dependencies:
+    ajv "^6.5.0"
+    babel-code-frame "^6.26.0"
+    chalk "^2.1.0"
+    cross-spawn "^6.0.5"
+    debug "^3.1.0"
+    doctrine "^2.1.0"
+    eslint-scope "^4.0.0"
+    eslint-utils "^1.3.1"
+    eslint-visitor-keys "^1.0.0"
+    espree "^4.0.0"
+    esquery "^1.0.1"
+    esutils "^2.0.2"
+    file-entry-cache "^2.0.0"
+    functional-red-black-tree "^1.0.1"
+    glob "^7.1.2"
+    globals "^11.7.0"
+    ignore "^4.0.2"
+    imurmurhash "^0.1.4"
+    inquirer "^5.2.0"
+    is-resolvable "^1.1.0"
+    js-yaml "^3.11.0"
+    json-stable-stringify-without-jsonify "^1.0.1"
+    levn "^0.3.0"
+    lodash "^4.17.5"
+    minimatch "^3.0.4"
+    mkdirp "^0.5.1"
+    natural-compare "^1.4.0"
+    optionator "^0.8.2"
+    path-is-inside "^1.0.2"
+    pluralize "^7.0.0"
+    progress "^2.0.0"
+    regexpp "^2.0.0"
+    require-uncached "^1.0.3"
+    semver "^5.5.0"
+    strip-ansi "^4.0.0"
+    strip-json-comments "^2.0.1"
+    table "^4.0.3"
+    text-table "^0.2.0"
+
+espree@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/espree/-/espree-4.0.0.tgz#253998f20a0f82db5d866385799d912a83a36634"
+  dependencies:
+    acorn "^5.6.0"
+    acorn-jsx "^4.1.1"
+
+esprima@^4.0.0:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
+
+esquery@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.0.1.tgz#406c51658b1f5991a5f9b62b1dc25b00e3e5c708"
+  dependencies:
+    estraverse "^4.0.0"
+
+esrecurse@^4.1.0:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.2.1.tgz#007a3b9fdbc2b3bb87e4879ea19c92fdbd3942cf"
+  dependencies:
+    estraverse "^4.1.0"
+
+estraverse@^4.0.0, estraverse@^4.1.0, estraverse@^4.1.1:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.2.0.tgz#0dee3fed31fcd469618ce7342099fc1afa0bdb13"
+
+esutils@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.2.tgz#0abf4f1caa5bcb1f7a9d8acc6dea4faaa04bac9b"
+
+external-editor@^2.1.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-2.2.0.tgz#045511cfd8d133f3846673d1047c154e214ad3d5"
+  dependencies:
+    chardet "^0.4.0"
+    iconv-lite "^0.4.17"
+    tmp "^0.0.33"
+
+fast-deep-equal@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz#7b05218ddf9667bf7f370bf7fdb2cb15fdd0aa49"
+
+fast-json-stable-stringify@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz#d5142c0caee6b1189f87d3a76111064f86c8bbf2"
+
+fast-levenshtein@~2.0.4:
+  version "2.0.6"
+  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
+
+figures@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/figures/-/figures-2.0.0.tgz#3ab1a2d2a62c8bfb431a0c94cb797a2fce27c962"
+  dependencies:
+    escape-string-regexp "^1.0.5"
+
+file-entry-cache@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-2.0.0.tgz#c392990c3e684783d838b8c84a45d8a048458361"
+  dependencies:
+    flat-cache "^1.2.1"
+    object-assign "^4.0.1"
+
+flat-cache@^1.2.1:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-1.3.0.tgz#d3030b32b38154f4e3b7e9c709f490f7ef97c481"
+  dependencies:
+    circular-json "^0.3.1"
+    del "^2.0.2"
+    graceful-fs "^4.1.2"
+    write "^0.2.1"
+
+for-each@~0.3.3:
+  version "0.3.3"
+  resolved "https://registry.yarnpkg.com/for-each/-/for-each-0.3.3.tgz#69b447e88a0a5d32c3e7084f3f1710034b21376e"
+  dependencies:
+    is-callable "^1.1.3"
+
+fs.realpath@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
+
+function-bind@^1.0.2, function-bind@^1.1.1, function-bind@~1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
+
+functional-red-black-tree@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327"
+
+glob@^7.0.3, glob@^7.0.5, glob@^7.1.2, glob@~7.1.2:
+  version "7.1.2"
+  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.2.tgz#c19c9df9a028702d678612384a6552404c636d15"
+  dependencies:
+    fs.realpath "^1.0.0"
+    inflight "^1.0.4"
+    inherits "2"
+    minimatch "^3.0.4"
+    once "^1.3.0"
+    path-is-absolute "^1.0.0"
+
+globals@^11.7.0:
+  version "11.7.0"
+  resolved "https://registry.yarnpkg.com/globals/-/globals-11.7.0.tgz#a583faa43055b1aca771914bf68258e2fc125673"
+
+globby@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/globby/-/globby-5.0.0.tgz#ebd84667ca0dbb330b99bcfc68eac2bc54370e0d"
+  dependencies:
+    array-union "^1.0.1"
+    arrify "^1.0.0"
+    glob "^7.0.3"
+    object-assign "^4.0.1"
+    pify "^2.0.0"
+    pinkie-promise "^2.0.0"
+
+graceful-fs@^4.1.2:
+  version "4.1.11"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.11.tgz#0e8bdfe4d1ddb8854d64e04ea7c00e2a026e5658"
+
+has-ansi@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/has-ansi/-/has-ansi-2.0.0.tgz#34f5049ce1ecdf2b0649af3ef24e45ed35416d91"
+  dependencies:
+    ansi-regex "^2.0.0"
+
+has-flag@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
+
+has@^1.0.1, has@~1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
+  dependencies:
+    function-bind "^1.1.1"
+
+iconv-lite@^0.4.17:
+  version "0.4.24"
+  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
+  dependencies:
+    safer-buffer ">= 2.1.2 < 3"
+
+ignore@^4.0.2:
+  version "4.0.6"
+  resolved "https://registry.yarnpkg.com/ignore/-/ignore-4.0.6.tgz#750e3db5862087b4737ebac8207ffd1ef27b25fc"
+
+imurmurhash@^0.1.4:
+  version "0.1.4"
+  resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
+
+inflight@^1.0.4:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
+  dependencies:
+    once "^1.3.0"
+    wrappy "1"
+
+inherits@2, inherits@~2.0.3:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de"
+
+inquirer@^5.2.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-5.2.0.tgz#db350c2b73daca77ff1243962e9f22f099685726"
+  dependencies:
+    ansi-escapes "^3.0.0"
+    chalk "^2.0.0"
+    cli-cursor "^2.1.0"
+    cli-width "^2.0.0"
+    external-editor "^2.1.0"
+    figures "^2.0.0"
+    lodash "^4.3.0"
+    mute-stream "0.0.7"
+    run-async "^2.2.0"
+    rxjs "^5.5.2"
+    string-width "^2.1.0"
+    strip-ansi "^4.0.0"
+    through "^2.3.6"
+
+is-callable@^1.1.1, is-callable@^1.1.3:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.1.4.tgz#1e1adf219e1eeb684d691f9d6a05ff0d30a24d75"
+
+is-date-object@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.1.tgz#9aa20eb6aeebbff77fbd33e74ca01b33581d3a16"
+
+is-fullwidth-code-point@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
+
+is-path-cwd@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-1.0.0.tgz#d225ec23132e89edd38fda767472e62e65f1106d"
+
+is-path-in-cwd@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/is-path-in-cwd/-/is-path-in-cwd-1.0.1.tgz#5ac48b345ef675339bd6c7a48a912110b241cf52"
+  dependencies:
+    is-path-inside "^1.0.0"
+
+is-path-inside@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-1.0.1.tgz#8ef5b7de50437a3fdca6b4e865ef7aa55cb48036"
+  dependencies:
+    path-is-inside "^1.0.1"
+
+is-promise@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-2.1.0.tgz#79a2a9ece7f096e80f36d2b2f3bc16c1ff4bf3fa"
+
+is-regex@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"
+  dependencies:
+    has "^1.0.1"
+
+is-resolvable@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/is-resolvable/-/is-resolvable-1.1.0.tgz#fb18f87ce1feb925169c9a407c19318a3206ed88"
+
+is-symbol@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.1.tgz#3cc59f00025194b6ab2e38dbae6689256b660572"
+
+isexe@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
+
+js-tokens@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-3.0.2.tgz#9866df395102130e38f7f996bceb65443209c25b"
+
+js-tokens@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
+
+js-yaml@^3.11.0:
+  version "3.12.0"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.12.0.tgz#eaed656ec8344f10f527c6bfa1b6e2244de167d1"
+  dependencies:
+    argparse "^1.0.7"
+    esprima "^4.0.0"
+
+json-schema-traverse@^0.4.1:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
+
+json-stable-stringify-without-jsonify@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
+
+levn@^0.3.0, levn@~0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee"
+  dependencies:
+    prelude-ls "~1.1.2"
+    type-check "~0.3.2"
+
+lodash@^4.17.4, lodash@^4.17.5, lodash@^4.3.0:
+  version "4.17.10"
+  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.10.tgz#1b7793cf7259ea38fb3661d4d38b3260af8ae4e7"
+
+mimic-fn@^1.0.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.2.0.tgz#820c86a39334640e99516928bd03fca88057d022"
+
+minimatch@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
+  dependencies:
+    brace-expansion "^1.1.7"
+
+minimist@0.0.8:
+  version "0.0.8"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d"
+
+minimist@~1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.0.tgz#a35008b20f41383eec1fb914f4cd5df79a264284"
+
+mkdirp@^0.5.1:
+  version "0.5.1"
+  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903"
+  dependencies:
+    minimist "0.0.8"
+
+ms@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
+
+mute-stream@0.0.7:
+  version "0.0.7"
+  resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.7.tgz#3075ce93bc21b8fab43e1bc4da7e8115ed1e7bab"
+
+natural-compare@^1.4.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
+
+nice-try@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.4.tgz#d93962f6c52f2c1558c0fbda6d512819f1efe1c4"
+
+object-assign@^4.0.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
+
+object-inspect@~1.6.0:
+  version "1.6.0"
+  resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.6.0.tgz#c70b6cbf72f274aab4c34c0c82f5167bf82cf15b"
+
+object-keys@^1.0.12:
+  version "1.0.12"
+  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.0.12.tgz#09c53855377575310cca62f55bb334abff7b3ed2"
+
+once@^1.3.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
+  dependencies:
+    wrappy "1"
+
+onetime@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/onetime/-/onetime-2.0.1.tgz#067428230fd67443b2794b22bba528b6867962d4"
+  dependencies:
+    mimic-fn "^1.0.0"
+
+optionator@^0.8.2:
+  version "0.8.2"
+  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.2.tgz#364c5e409d3f4d6301d6c0b4c05bba50180aeb64"
+  dependencies:
+    deep-is "~0.1.3"
+    fast-levenshtein "~2.0.4"
+    levn "~0.3.0"
+    prelude-ls "~1.1.2"
+    type-check "~0.3.2"
+    wordwrap "~1.0.0"
+
+os-tmpdir@~1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
+
+path-is-absolute@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
+
+path-is-inside@^1.0.1, path-is-inside@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53"
+
+path-key@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40"
+
+path-parse@^1.0.5:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c"
+
+pify@^2.0.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
+
+pinkie-promise@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
+  dependencies:
+    pinkie "^2.0.0"
+
+pinkie@^2.0.0:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
+
+pluralize@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/pluralize/-/pluralize-7.0.0.tgz#298b89df8b93b0221dbf421ad2b1b1ea23fc6777"
+
+prelude-ls@~1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
+
+progress@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.0.tgz#8a1be366bf8fc23db2bd23f10c6fe920b4389d1f"
+
+punycode@^2.1.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
+
+regexpp@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-2.0.0.tgz#b2a7534a85ca1b033bcf5ce9ff8e56d4e0755365"
+
+require-uncached@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/require-uncached/-/require-uncached-1.0.3.tgz#4e0d56d6c9662fd31e43011c4b95aa49955421d3"
+  dependencies:
+    caller-path "^0.1.0"
+    resolve-from "^1.0.0"
+
+resolve-from@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-1.0.1.tgz#26cbfe935d1aeeeabb29bc3fe5aeb01e93d44226"
+
+resolve@~1.7.1:
+  version "1.7.1"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.7.1.tgz#aadd656374fd298aee895bc026b8297418677fd3"
+  dependencies:
+    path-parse "^1.0.5"
+
+restore-cursor@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-2.0.0.tgz#9f7ee287f82fd326d4fd162923d62129eee0dfaf"
+  dependencies:
+    onetime "^2.0.0"
+    signal-exit "^3.0.2"
+
+resumer@~0.0.0:
+  version "0.0.0"
+  resolved "https://registry.yarnpkg.com/resumer/-/resumer-0.0.0.tgz#f1e8f461e4064ba39e82af3cdc2a8c893d076759"
+  dependencies:
+    through "~2.3.4"
+
+rimraf@^2.2.8:
+  version "2.6.2"
+  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.2.tgz#2ed8150d24a16ea8651e6d6ef0f47c4158ce7a36"
+  dependencies:
+    glob "^7.0.5"
+
+rollup-plugin-terser@1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/rollup-plugin-terser/-/rollup-plugin-terser-1.0.1.tgz#ba5f497cbc9aa38ba19d3ee2167c04ea3ed279af"
+  dependencies:
+    "@babel/code-frame" "^7.0.0-beta.47"
+    terser "^3.7.5"
+
+rollup@0.64:
+  version "0.64.1"
+  resolved "https://registry.yarnpkg.com/rollup/-/rollup-0.64.1.tgz#9188ee368e5fcd43ffbc00ec414e72eeb5de87ba"
+  dependencies:
+    "@types/estree" "0.0.39"
+    "@types/node" "*"
+
+run-async@^2.2.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/run-async/-/run-async-2.3.0.tgz#0371ab4ae0bdd720d4166d7dfda64ff7a445a6c0"
+  dependencies:
+    is-promise "^2.1.0"
+
+rxjs@^5.5.2:
+  version "5.5.11"
+  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-5.5.11.tgz#f733027ca43e3bec6b994473be4ab98ad43ced87"
+  dependencies:
+    symbol-observable "1.0.1"
+
+"safer-buffer@>= 2.1.2 < 3":
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
+
+seedrandom@2:
+  version "2.4.4"
+  resolved "https://registry.yarnpkg.com/seedrandom/-/seedrandom-2.4.4.tgz#b25ea98632c73e45f58b77cfaa931678df01f9ba"
+
+semver@^5.5.0:
+  version "5.5.1"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-5.5.1.tgz#7dfdd8814bdb7cabc7be0fb1d734cfb66c940477"
+
+shebang-command@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea"
+  dependencies:
+    shebang-regex "^1.0.0"
+
+shebang-regex@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3"
+
+signal-exit@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d"
+
+slice-ansi@1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-1.0.0.tgz#044f1a49d8842ff307aad6b505ed178bd950134d"
+  dependencies:
+    is-fullwidth-code-point "^2.0.0"
+
+source-map-support@~0.5.6:
+  version "0.5.9"
+  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.9.tgz#41bc953b2534267ea2d605bccfa7bfa3111ced5f"
+  dependencies:
+    buffer-from "^1.0.0"
+    source-map "^0.6.0"
+
+source-map@^0.6.0, source-map@~0.6.1:
+  version "0.6.1"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
+
+sprintf-js@~1.0.2:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
+
+string-width@^2.1.0, string-width@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
+  dependencies:
+    is-fullwidth-code-point "^2.0.0"
+    strip-ansi "^4.0.0"
+
+string.prototype.trim@~1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/string.prototype.trim/-/string.prototype.trim-1.1.2.tgz#d04de2c89e137f4d7d206f086b5ed2fae6be8cea"
+  dependencies:
+    define-properties "^1.1.2"
+    es-abstract "^1.5.0"
+    function-bind "^1.0.2"
+
+strip-ansi@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
+  dependencies:
+    ansi-regex "^2.0.0"
+
+strip-ansi@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-4.0.0.tgz#a8479022eb1ac368a871389b635262c505ee368f"
+  dependencies:
+    ansi-regex "^3.0.0"
+
+strip-json-comments@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
+
+supports-color@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7"
+
+supports-color@^5.3.0:
+  version "5.5.0"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
+  dependencies:
+    has-flag "^3.0.0"
+
+symbol-observable@1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-1.0.1.tgz#8340fc4702c3122df5d22288f88283f513d3fdd4"
+
+table@^4.0.3:
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/table/-/table-4.0.3.tgz#00b5e2b602f1794b9acaf9ca908a76386a7813bc"
+  dependencies:
+    ajv "^6.0.1"
+    ajv-keywords "^3.0.0"
+    chalk "^2.1.0"
+    lodash "^4.17.4"
+    slice-ansi "1.0.0"
+    string-width "^2.1.1"
+
+tape@4:
+  version "4.9.1"
+  resolved "https://registry.yarnpkg.com/tape/-/tape-4.9.1.tgz#1173d7337e040c76fbf42ec86fcabedc9b3805c9"
+  dependencies:
+    deep-equal "~1.0.1"
+    defined "~1.0.0"
+    for-each "~0.3.3"
+    function-bind "~1.1.1"
+    glob "~7.1.2"
+    has "~1.0.3"
+    inherits "~2.0.3"
+    minimist "~1.2.0"
+    object-inspect "~1.6.0"
+    resolve "~1.7.1"
+    resumer "~0.0.0"
+    string.prototype.trim "~1.1.2"
+    through "~2.3.8"
+
+terser@^3.7.5:
+  version "3.8.1"
+  resolved "https://registry.yarnpkg.com/terser/-/terser-3.8.1.tgz#cb70070ac9e0a71add169dfb63c0a64fca2738ac"
+  dependencies:
+    commander "~2.16.0"
+    source-map "~0.6.1"
+    source-map-support "~0.5.6"
+
+text-table@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
+
+through@^2.3.6, through@~2.3.4, through@~2.3.8:
+  version "2.3.8"
+  resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
+
+tmp@^0.0.33:
+  version "0.0.33"
+  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
+  dependencies:
+    os-tmpdir "~1.0.2"
+
+type-check@~0.3.2:
+  version "0.3.2"
+  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72"
+  dependencies:
+    prelude-ls "~1.1.2"
+
+uri-js@^4.2.2:
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.2.2.tgz#94c540e1ff772956e2299507c010aea6c8838eb0"
+  dependencies:
+    punycode "^2.1.0"
+
+which@^1.2.9:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
+  dependencies:
+    isexe "^2.0.0"
+
+wordwrap@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb"
+
+wrappy@1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
+
+write@^0.2.1:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/write/-/write-0.2.1.tgz#5fc03828e264cea3fe91455476f7a3c566cb0757"
+  dependencies:
+    mkdirp "^0.5.1"

node_modules/d3-geo-projection/package.json

@@ -0,0 +1,100 @@
+{
+  "_from": "d3-geo-projection@^2.9.0",
+  "_id": "d3-geo-projection@2.9.0",
+  "_inBundle": false,
+  "_integrity": "sha512-ZULvK/zBn87of5rWAfFMc9mJOipeSo57O+BBitsKIXmU4rTVAnX1kSsJkE0R+TxY8pGNoM1nbyRRE7GYHhdOEQ==",
+  "_location": "/d3-geo-projection",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "d3-geo-projection@^2.9.0",
+    "name": "d3-geo-projection",
+    "escapedName": "d3-geo-projection",
+    "rawSpec": "^2.9.0",
+    "saveSpec": null,
+    "fetchSpec": "^2.9.0"
+  },
+  "_requiredBy": [
+    "/vega-projection"
+  ],
+  "_resolved": "https://registry.npmjs.org/d3-geo-projection/-/d3-geo-projection-2.9.0.tgz",
+  "_shasum": "826db62f748e8ecd67cd00aced4c26a236ec030c",
+  "_spec": "d3-geo-projection@^2.9.0",
+  "_where": "/home/prabhatdev/Documents/opensource/gitHubStats/waka-readme-stats/node_modules/vega-projection",
+  "author": {
+    "name": "Mike Bostock",
+    "url": "https://bost.ocks.org/mike"
+  },
+  "bin": {
+    "geo2svg": "bin/geo2svg",
+    "geograticule": "bin/geograticule",
+    "geoproject": "bin/geoproject",
+    "geoquantize": "bin/geoquantize",
+    "geostitch": "bin/geostitch"
+  },
+  "bugs": {
+    "url": "https://github.com/d3/d3-geo-projection/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Jason Davies",
+      "url": "http://www.jasondavies.com"
+    },
+    {
+      "name": "Philippe Rivière",
+      "url": "https://visionscarto.net"
+    }
+  ],
+  "dependencies": {
+    "commander": "2",
+    "d3-array": "1",
+    "d3-geo": "^1.12.0",
+    "resolve": "^1.1.10"
+  },
+  "deprecated": false,
+  "description": "Extended geographic projections for d3-geo.",
+  "devDependencies": {
+    "canvas": "1",
+    "d3-format": "1",
+    "eslint": "5",
+    "rollup": "0.64",
+    "rollup-plugin-terser": "1",
+    "tape": "4",
+    "topojson-client": "3",
+    "us-atlas": "1",
+    "world-atlas": "1"
+  },
+  "files": [
+    "bin/geo*",
+    "bin/**/*.js",
+    "dist/**/*.js",
+    "src/**/*.js"
+  ],
+  "homepage": "https://d3js.org/d3-geo-projection/",
+  "jsdelivr": "dist/d3-geo-projection.min.js",
+  "keywords": [
+    "d3",
+    "d3-module",
+    "cartography",
+    "projection"
+  ],
+  "license": "BSD-3-Clause",
+  "main": "dist/d3-geo-projection.js",
+  "module": "src/index.js",
+  "name": "d3-geo-projection",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/d3/d3-geo-projection.git"
+  },
+  "scripts": {
+    "postpublish": "git push && git push --tags && cd ../d3.github.com && git pull && cp ../${npm_package_name}/dist/${npm_package_name}.js ${npm_package_name}.v${npm_package_version%%.*}.js && cp ../${npm_package_name}/dist/${npm_package_name}.min.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git add ${npm_package_name}.v${npm_package_version%%.*}.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git commit -m \"${npm_package_name} ${npm_package_version}\" && git push && cd - && 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 && mkdir -p test/output && test/compare-images",
+    "pretest": "rollup -c",
+    "test": "tape 'test/**/*-test.js' && eslint src"
+  },
+  "sideEffects": false,
+  "unpkg": "dist/d3-geo-projection.min.js",
+  "version": "2.9.0"
+}

node_modules/d3-geo-projection/src/airy.js

@@ -0,0 +1,49 @@
+import {geoProjectionMutator as projectionMutator} from "d3-geo";
+import {abs, asin, atan2, cos, degrees, epsilon, halfPi, log, radians, sin, sqrt, tan} from "./math.js";
+
+export function airyRaw(beta) {
+  var tanBeta_2 = tan(beta / 2),
+      b = 2 * log(cos(beta / 2)) / (tanBeta_2 * tanBeta_2);
+
+  function forward(x, y) {
+    var cosx = cos(x),
+        cosy = cos(y),
+        siny = sin(y),
+        cosz = cosy * cosx,
+        k = -((1 - cosz ? log((1 + cosz) / 2) / (1 - cosz) : -0.5) + b / (1 + cosz));
+    return [k * cosy * sin(x), k * siny];
+  }
+
+  forward.invert = function(x, y) {
+    var r = sqrt(x * x + y * y),
+        z = -beta / 2,
+        i = 50, delta;
+    if (!r) return [0, 0];
+    do {
+      var z_2 = z / 2,
+          cosz_2 = cos(z_2),
+          sinz_2 = sin(z_2),
+          tanz_2 = sinz_2 / cosz_2,
+          lnsecz_2 = -log(abs(cosz_2));
+      z -= delta = (2 / tanz_2 * lnsecz_2 - b * tanz_2 - r) / (-lnsecz_2 / (sinz_2 * sinz_2) + 1 - b / (2 * cosz_2 * cosz_2)) * (cosz_2 < 0 ? 0.7 : 1);
+    } while (abs(delta) > epsilon && --i > 0);
+    var sinz = sin(z);
+    return [atan2(x * sinz, r * cos(z)), asin(y * sinz / r)];
+  };
+
+  return forward;
+}
+
+export default function() {
+  var beta = halfPi,
+      m = projectionMutator(airyRaw),
+      p = m(beta);
+
+  p.radius = function(_) {
+    return arguments.length ? m(beta = _ * radians) : beta * degrees;
+  };
+
+  return p
+      .scale(179.976)
+      .clipAngle(147);
+}

node_modules/d3-geo-projection/src/aitoff.js

@@ -0,0 +1,45 @@
+import {geoProjection as projection} from "d3-geo";
+import {abs, acos, cos, epsilon, pi, sin, sinci, sqrt} from "./math.js";
+
+export function aitoffRaw(x, y) {
+  var cosy = cos(y), sincia = sinci(acos(cosy * cos(x /= 2)));
+  return [2 * cosy * sin(x) * sincia, sin(y) * sincia];
+}
+
+// Abort if [x, y] is not within an ellipse centered at [0, 0] with
+// semi-major axis pi and semi-minor axis pi/2.
+aitoffRaw.invert = function(x, y) {
+  if (x * x + 4 * y * y > pi * pi + epsilon) return;
+  var x1 = x, y1 = y, i = 25;
+  do {
+    var sinx = sin(x1),
+        sinx_2 = sin(x1 / 2),
+        cosx_2 = cos(x1 / 2),
+        siny = sin(y1),
+        cosy = cos(y1),
+        sin_2y = sin(2 * y1),
+        sin2y = siny * siny,
+        cos2y = cosy * cosy,
+        sin2x_2 = sinx_2 * sinx_2,
+        c = 1 - cos2y * cosx_2 * cosx_2,
+        e = c ? acos(cosy * cosx_2) * sqrt(f = 1 / c) : f = 0,
+        f,
+        fx = 2 * e * cosy * sinx_2 - x,
+        fy = e * siny - y,
+        dxdx = f * (cos2y * sin2x_2 + e * cosy * cosx_2 * sin2y),
+        dxdy = f * (0.5 * sinx * sin_2y - e * 2 * siny * sinx_2),
+        dydx = f * 0.25 * (sin_2y * sinx_2 - e * siny * cos2y * sinx),
+        dydy = f * (sin2y * cosx_2 + e * sin2x_2 * cosy),
+        z = dxdy * dydx - dydy * dxdx;
+    if (!z) break;
+    var dx = (fy * dxdy - fx * dydy) / z,
+        dy = (fx * dydx - fy * dxdx) / z;
+    x1 -= dx, y1 -= dy;
+  } while ((abs(dx) > epsilon || abs(dy) > epsilon) && --i > 0);
+  return [x1, y1];
+};
+
+export default function() {
+  return projection(aitoffRaw)
+      .scale(152.63);
+}

node_modules/d3-geo-projection/src/armadillo.js

@@ -0,0 +1,83 @@
+import {geoProjectionMutator as projectionMutator} from "d3-geo";
+import {abs, atan2, cos, degrees, epsilon, radians, sin, tan} from "./math.js";
+
+export function armadilloRaw(phi0) {
+  var sinPhi0 = sin(phi0),
+      cosPhi0 = cos(phi0),
+      sPhi0 = phi0 >= 0 ? 1 : -1,
+      tanPhi0 = tan(sPhi0 * phi0),
+      k = (1 + sinPhi0 - cosPhi0) / 2;
+
+  function forward(lambda, phi) {
+    var cosPhi = cos(phi),
+        cosLambda = cos(lambda /= 2);
+    return [
+      (1 + cosPhi) * sin(lambda),
+      (sPhi0 * phi > -atan2(cosLambda, tanPhi0) - 1e-3 ? 0 : -sPhi0 * 10) + k + sin(phi) * cosPhi0 - (1 + cosPhi) * sinPhi0 * cosLambda // TODO D3 core should allow null or [NaN, NaN] to be returned.
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var lambda = 0,
+        phi = 0,
+        i = 50;
+    do {
+      var cosLambda = cos(lambda),
+          sinLambda = sin(lambda),
+          cosPhi = cos(phi),
+          sinPhi = sin(phi),
+          A = 1 + cosPhi,
+          fx = A * sinLambda - x,
+          fy = k + sinPhi * cosPhi0 - A * sinPhi0 * cosLambda - y,
+          dxdLambda = A * cosLambda / 2,
+          dxdPhi = -sinLambda * sinPhi,
+          dydLambda = sinPhi0 * A * sinLambda / 2,
+          dydPhi = cosPhi0 * cosPhi + sinPhi0 * cosLambda * sinPhi,
+          denominator = dxdPhi * dydLambda - dydPhi * dxdLambda,
+          dLambda = (fy * dxdPhi - fx * dydPhi) / denominator / 2,
+          dPhi = (fx * dydLambda - fy * dxdLambda) / denominator;
+      if (abs(dPhi) > 2) dPhi /= 2;
+      lambda -= dLambda, phi -= dPhi;
+    } while ((abs(dLambda) > epsilon || abs(dPhi) > epsilon) && --i > 0);
+    return sPhi0 * phi > -atan2(cos(lambda), tanPhi0) - 1e-3 ? [lambda * 2, phi] : null;
+  };
+
+  return forward;
+}
+
+export default function() {
+  var phi0 = 20 * radians,
+      sPhi0 = phi0 >= 0 ? 1 : -1,
+      tanPhi0 = tan(sPhi0 * phi0),
+      m = projectionMutator(armadilloRaw),
+      p = m(phi0),
+      stream_ = p.stream;
+
+  p.parallel = function(_) {
+    if (!arguments.length) return phi0 * degrees;
+    tanPhi0 = tan((sPhi0 = (phi0 = _ * radians) >= 0 ? 1 : -1) * phi0);
+    return m(phi0);
+  };
+
+  p.stream = function(stream) {
+    var rotate = p.rotate(),
+        rotateStream = stream_(stream),
+        sphereStream = (p.rotate([0, 0]), stream_(stream)),
+        precision = p.precision();
+    p.rotate(rotate);
+    rotateStream.sphere = function() {
+      sphereStream.polygonStart(), sphereStream.lineStart();
+      for (var lambda = sPhi0 * -180; sPhi0 * lambda < 180; lambda += sPhi0 * 90)
+        sphereStream.point(lambda, sPhi0 * 90);
+      if (phi0) while (sPhi0 * (lambda -= 3 * sPhi0 * precision) >= -180) {
+        sphereStream.point(lambda, sPhi0 * -atan2(cos(lambda * radians / 2), tanPhi0) * degrees);
+      }
+      sphereStream.lineEnd(), sphereStream.polygonEnd();
+    };
+    return rotateStream;
+  };
+
+  return p
+      .scale(218.695)
+      .center([0, 28.0974]);
+}

node_modules/d3-geo-projection/src/august.js

@@ -0,0 +1,39 @@
+import {geoProjection as projection} from "d3-geo";
+import {abs, arcosh, arsinh, asin, atan2, cos, cosh, sign, sin, sinh, sqrt, tan} from "./math.js";
+
+export function augustRaw(lambda, phi) {
+  var tanPhi = tan(phi / 2),
+      k = sqrt(1 - tanPhi * tanPhi),
+      c = 1 + k * cos(lambda /= 2),
+      x = sin(lambda) * k / c,
+      y = tanPhi / c,
+      x2 = x * x,
+      y2 = y * y;
+  return [
+    4 / 3 * x * (3 + x2 - 3 * y2),
+    4 / 3 * y * (3 + 3 * x2 - y2)
+  ];
+}
+
+augustRaw.invert = function(x, y) {
+  x *= 3 / 8, y *= 3 / 8;
+  if (!x && abs(y) > 1) return null;
+  var x2 = x * x,
+      y2 = y * y,
+      s = 1 + x2 + y2,
+      sin3Eta = sqrt((s - sqrt(s * s - 4 * y * y)) / 2),
+      eta = asin(sin3Eta) / 3,
+      xi = sin3Eta ? arcosh(abs(y / sin3Eta)) / 3 : arsinh(abs(x)) / 3,
+      cosEta = cos(eta),
+      coshXi = cosh(xi),
+      d = coshXi * coshXi - cosEta * cosEta;
+  return [
+    sign(x) * 2 * atan2(sinh(xi) * cosEta, 0.25 - d),
+    sign(y) * 2 * atan2(coshXi * sin(eta), 0.25 + d)
+  ];
+};
+
+export default function() {
+  return projection(augustRaw)
+      .scale(66.1603);
+}

node_modules/d3-geo-projection/src/baker.js

@@ -0,0 +1,27 @@
+import {geoProjection as projection} from "d3-geo";
+import {abs, atan, cos, epsilon2, exp, halfPi, log, quarterPi, sign, sin, sqrt, sqrt2, tan} from "./math.js";
+
+var sqrt8 = sqrt(8),
+    phi0 = log(1 + sqrt2);
+
+export function bakerRaw(lambda, phi) {
+  var phi0 = abs(phi);
+  return phi0 < quarterPi
+      ? [lambda, log(tan(quarterPi + phi / 2))]
+      : [lambda * cos(phi0) * (2 * sqrt2 - 1 / sin(phi0)), sign(phi) * (2 * sqrt2 * (phi0 - quarterPi) - log(tan(phi0 / 2)))];
+}
+
+bakerRaw.invert = function(x, y) {
+  if ((y0 = abs(y)) < phi0) return [x, 2 * atan(exp(y)) - halfPi];
+  var phi = quarterPi, i = 25, delta, y0;
+  do {
+    var cosPhi_2 = cos(phi / 2), tanPhi_2 = tan(phi / 2);
+    phi -= delta = (sqrt8 * (phi - quarterPi) - log(tanPhi_2) - y0) / (sqrt8 - cosPhi_2 * cosPhi_2 / (2 * tanPhi_2));
+  } while (abs(delta) > epsilon2 && --i > 0);
+  return [x / (cos(phi) * (sqrt8 - 1 / sin(phi))), sign(y) * phi];
+};
+
+export default function() {
+  return projection(bakerRaw)
+      .scale(112.314);
+}

node_modules/d3-geo-projection/src/berghaus.js

@@ -0,0 +1,77 @@
+import {geoProjectionMutator as projectionMutator, geoAzimuthalEquidistantRaw as azimuthalEquidistantRaw} from "d3-geo";
+import {abs, acos, asin, atan, atan2, cos, degrees, halfPi, pi, radians, round, sin, sqrt, tan} from "./math.js";
+
+export function berghausRaw(lobes) {
+  var k = 2 * pi / lobes;
+
+  function forward(lambda, phi) {
+    var p = azimuthalEquidistantRaw(lambda, phi);
+    if (abs(lambda) > halfPi) { // back hemisphere
+      var theta = atan2(p[1], p[0]),
+          r = sqrt(p[0] * p[0] + p[1] * p[1]),
+          theta0 = k * round((theta - halfPi) / k) + halfPi,
+          alpha = atan2(sin(theta -= theta0), 2 - cos(theta)); // angle relative to lobe end
+      theta = theta0 + asin(pi / r * sin(alpha)) - alpha;
+      p[0] = r * cos(theta);
+      p[1] = r * sin(theta);
+    }
+    return p;
+  }
+
+  forward.invert = function(x, y) {
+    var r = sqrt(x * x + y * y);
+    if (r > halfPi) {
+      var theta = atan2(y, x),
+          theta0 = k * round((theta - halfPi) / k) + halfPi,
+          s = theta > theta0 ? -1 : 1,
+          A = r * cos(theta0 - theta),
+          cotAlpha = 1 / tan(s * acos((A - pi) / sqrt(pi * (pi - 2 * A) + r * r)));
+      theta = theta0 + 2 * atan((cotAlpha + s * sqrt(cotAlpha * cotAlpha - 3)) / 3);
+      x = r * cos(theta), y = r * sin(theta);
+    }
+    return azimuthalEquidistantRaw.invert(x, y);
+  };
+
+  return forward;
+}
+
+export default function() {
+  var lobes = 5,
+      m = projectionMutator(berghausRaw),
+      p = m(lobes),
+      projectionStream = p.stream,
+      epsilon = 1e-2,
+      cr = -cos(epsilon * radians),
+      sr = sin(epsilon * radians);
+
+  p.lobes = function(_) {
+    return arguments.length ? m(lobes = +_) : lobes;
+  };
+
+  p.stream = function(stream) {
+    var rotate = p.rotate(),
+        rotateStream = projectionStream(stream),
+        sphereStream = (p.rotate([0, 0]), projectionStream(stream));
+    p.rotate(rotate);
+    rotateStream.sphere = function() {
+      sphereStream.polygonStart(), sphereStream.lineStart();
+      for (var i = 0, delta = 360 / lobes, delta0 = 2 * pi / lobes, phi = 90 - 180 / lobes, phi0 = halfPi; i < lobes; ++i, phi -= delta, phi0 -= delta0) {
+        sphereStream.point(atan2(sr * cos(phi0), cr) * degrees, asin(sr * sin(phi0)) * degrees);
+        if (phi < -90) {
+          sphereStream.point(-90, -180 - phi - epsilon);
+          sphereStream.point(-90, -180 - phi + epsilon);
+        } else {
+          sphereStream.point(90, phi + epsilon);
+          sphereStream.point(90, phi - epsilon);
+        }
+      }
+      sphereStream.lineEnd(), sphereStream.polygonEnd();
+    };
+    return rotateStream;
+  };
+
+  return p
+      .scale(87.8076)
+      .center([0, 17.1875])
+      .clipAngle(180 - 1e-3);
+}

node_modules/d3-geo-projection/src/bertin.js

@@ -0,0 +1,44 @@
+import {geoProjection as projection} from "d3-geo";
+import {hammerRaw} from "./hammer.js";
+import {cos, pi, sin} from "./math.js";
+import {solve2d} from "./newton.js";
+
+// Bertin 1953 as a modified Briesemeister
+// https://bl.ocks.org/Fil/5b9ee9636dfb6ffa53443c9006beb642
+export function bertin1953Raw() {
+  var hammer = hammerRaw(1.68, 2),
+      fu = 1.4, k = 12;
+
+  function forward(lambda, phi) {
+
+    if (lambda + phi < -fu) {
+      var u = (lambda - phi + 1.6) * (lambda + phi + fu) / 8;
+      lambda += u;
+      phi -= 0.8 * u * sin(phi + pi / 2);
+    }
+
+    var r = hammer(lambda, phi);
+
+    var d = (1 - cos(lambda * phi)) / k;
+
+    if (r[1] < 0) {
+      r[0] *= 1 + d;
+    }
+    if (r[1] > 0) {
+      r[1] *= 1 + d / 1.5 * r[0] * r[0];
+    }
+
+    return r;
+  }
+  
+  forward.invert = solve2d(forward);
+  return forward;
+}
+
+export default function() {
+  // this projection should not be rotated
+  return projection(bertin1953Raw())
+    .rotate([-16.5, -42])
+    .scale(176.57)
+    .center([7.93, 0.09]);
+}

node_modules/d3-geo-projection/src/boggs.js

@@ -0,0 +1,26 @@
+import {geoProjection as projection} from "d3-geo";
+import {mollweideBromleyTheta} from "./mollweide.js";
+import {abs, cos, epsilon, pi, quarterPi, sin, sqrt2} from "./math.js";
+
+var k = 2.00276,
+    w = 1.11072;
+
+export function boggsRaw(lambda, phi) {
+  var theta = mollweideBromleyTheta(pi, phi);
+  return [k * lambda / (1 / cos(phi) + w / cos(theta)), (phi + sqrt2 * sin(theta)) / k];
+}
+
+boggsRaw.invert = function(x, y) {
+  var ky = k * y, theta = y < 0 ? -quarterPi : quarterPi, i = 25, delta, phi;
+  do {
+    phi = ky - sqrt2 * sin(theta);
+    theta -= delta = (sin(2 * theta) + 2 * theta - pi * sin(phi)) / (2 * cos(2 * theta) + 2 + pi * cos(phi) * sqrt2 * cos(theta));
+  } while (abs(delta) > epsilon && --i > 0);
+  phi = ky - sqrt2 * sin(theta);
+  return [x * (1 / cos(phi) + w / cos(theta)) / k, phi];
+};
+
+export default function() {
+  return projection(boggsRaw)
+      .scale(160.857);
+}

node_modules/d3-geo-projection/src/bonne.js

@@ -0,0 +1,29 @@
+import parallel1 from "./parallel1.js";
+import {atan2, cos, sin, sqrt, tan} from "./math.js";
+import {sinusoidalRaw} from "./sinusoidal.js";
+
+export function bonneRaw(phi0) {
+  if (!phi0) return sinusoidalRaw;
+  var cotPhi0 = 1 / tan(phi0);
+
+  function forward(lambda, phi) {
+    var rho = cotPhi0 + phi0 - phi,
+        e = rho ? lambda * cos(phi) / rho : rho;
+    return [rho * sin(e), cotPhi0 - rho * cos(e)];
+  }
+
+  forward.invert = function(x, y) {
+    var rho = sqrt(x * x + (y = cotPhi0 - y) * y),
+        phi = cotPhi0 + phi0 - rho;
+    return [rho / cos(phi) * atan2(x, y), phi];
+  };
+
+  return forward;
+}
+
+export default function() {
+  return parallel1(bonneRaw)
+      .scale(123.082)
+      .center([0, 26.1441])
+      .parallel(45);
+}

node_modules/d3-geo-projection/src/bottomley.js

@@ -0,0 +1,34 @@
+import {geoProjectionMutator as projectionMutator} from "d3-geo";
+import {atan2, cos, halfPi, sin, sqrt} from "./math.js";
+
+export function bottomleyRaw(sinPsi) {
+
+  function forward(lambda, phi) {
+    var rho = halfPi - phi,
+        eta = rho ? lambda * sinPsi * sin(rho) / rho : rho;
+    return [rho * sin(eta) / sinPsi, halfPi - rho * cos(eta)];
+  }
+
+  forward.invert = function(x, y) {
+    var x1 = x * sinPsi,
+        y1 = halfPi - y,
+        rho = sqrt(x1 * x1 + y1 * y1),
+        eta = atan2(x1, y1);
+    return [(rho ? rho / sin(rho) : 1) * eta / sinPsi, halfPi - rho];
+  };
+
+  return forward;
+}
+
+export default function() {
+  var sinPsi = 0.5,
+      m = projectionMutator(bottomleyRaw),
+      p = m(sinPsi);
+
+  p.fraction = function(_) {
+    return arguments.length ? m(sinPsi = +_) : sinPsi;
+  };
+
+  return p
+      .scale(158.837);
+}

node_modules/d3-geo-projection/src/bromley.js

@@ -0,0 +1,10 @@
+import {geoProjection as projection} from "d3-geo";
+import {pi} from "./math.js";
+import {mollweideBromleyRaw} from "./mollweide.js";
+
+export var bromleyRaw = mollweideBromleyRaw(1, 4 / pi, pi);
+
+export default function() {
+  return projection(bromleyRaw)
+      .scale(152.63);
+}

node_modules/d3-geo-projection/src/chamberlin.js

@@ -0,0 +1,120 @@
+import {geoCentroid as centroid, geoProjection as projection, geoRotation as rotation} from "d3-geo";
+import {abs, acos, asin, atan2, cos, epsilon, floor, pi, radians, sin, sqrt} from "./math.js";
+import {solve2d} from "./newton.js";
+
+// Azimuthal distance.
+function distance(dPhi, c1, s1, c2, s2, dLambda) {
+  var cosdLambda = cos(dLambda), r;
+  if (abs(dPhi) > 1 || abs(dLambda) > 1) {
+    r = acos(s1 * s2 + c1 * c2 * cosdLambda);
+  } else {
+    var sindPhi = sin(dPhi / 2), sindLambda = sin(dLambda / 2);
+    r = 2 * asin(sqrt(sindPhi * sindPhi + c1 * c2 * sindLambda * sindLambda));
+  }
+  return abs(r) > epsilon ? [r, atan2(c2 * sin(dLambda), c1 * s2 - s1 * c2 * cosdLambda)] : [0, 0];
+}
+
+// Angle opposite a, and contained between sides of lengths b and c.
+function angle(b, c, a) {
+  return acos((b * b + c * c - a * a) / (2 * b * c));
+}
+
+// Normalize longitude.
+function longitude(lambda) {
+  return lambda - 2 * pi * floor((lambda + pi) / (2 * pi));
+}
+
+export function chamberlinRaw(p0, p1, p2) {
+  var points = [
+    [p0[0], p0[1], sin(p0[1]), cos(p0[1])],
+    [p1[0], p1[1], sin(p1[1]), cos(p1[1])],
+    [p2[0], p2[1], sin(p2[1]), cos(p2[1])]
+  ];
+
+  for (var a = points[2], b, i = 0; i < 3; ++i, a = b) {
+    b = points[i];
+    a.v = distance(b[1] - a[1], a[3], a[2], b[3], b[2], b[0] - a[0]);
+    a.point = [0, 0];
+  }
+
+  var beta0 = angle(points[0].v[0], points[2].v[0], points[1].v[0]),
+      beta1 = angle(points[0].v[0], points[1].v[0], points[2].v[0]),
+      beta2 = pi - beta0;
+
+  points[2].point[1] = 0;
+  points[0].point[0] = -(points[1].point[0] = points[0].v[0] / 2);
+
+  var mean = [
+    points[2].point[0] = points[0].point[0] + points[2].v[0] * cos(beta0),
+    2 * (points[0].point[1] = points[1].point[1] = points[2].v[0] * sin(beta0))
+  ];
+
+  function forward(lambda, phi) {
+    var sinPhi = sin(phi),
+        cosPhi = cos(phi),
+        v = new Array(3), i;
+
+    // Compute distance and azimuth from control points.
+    for (i = 0; i < 3; ++i) {
+      var p = points[i];
+      v[i] = distance(phi - p[1], p[3], p[2], cosPhi, sinPhi, lambda - p[0]);
+      if (!v[i][0]) return p.point;
+      v[i][1] = longitude(v[i][1] - p.v[1]);
+    }
+
+    // Arithmetic mean of interception points.
+    var point = mean.slice();
+    for (i = 0; i < 3; ++i) {
+      var j = i == 2 ? 0 : i + 1;
+      var a = angle(points[i].v[0], v[i][0], v[j][0]);
+      if (v[i][1] < 0) a = -a;
+
+      if (!i) {
+        point[0] += v[i][0] * cos(a);
+        point[1] -= v[i][0] * sin(a);
+      } else if (i == 1) {
+        a = beta1 - a;
+        point[0] -= v[i][0] * cos(a);
+        point[1] -= v[i][0] * sin(a);
+      } else {
+        a = beta2 - a;
+        point[0] += v[i][0] * cos(a);
+        point[1] += v[i][0] * sin(a);
+      }
+    }
+
+    point[0] /= 3, point[1] /= 3;
+    return point;
+  }
+
+  return forward;
+}
+
+function pointRadians(p) {
+  return p[0] *= radians, p[1] *= radians, p;
+}
+
+export function chamberlinAfrica() {
+  return chamberlin([0, 22], [45, 22], [22.5, -22])
+      .scale(380)
+      .center([22.5, 2]);
+}
+
+export default function chamberlin(p0, p1, p2) { // TODO order matters!
+  var c = centroid({type: "MultiPoint", coordinates: [p0, p1, p2]}),
+      R = [-c[0], -c[1]],
+      r = rotation(R),
+      f = chamberlinRaw(pointRadians(r(p0)), pointRadians(r(p1)), pointRadians(r(p2)));
+  f.invert = solve2d(f);
+  var p = projection(f).rotate(R),
+      center = p.center;
+
+  delete p.rotate;
+
+  p.center = function(_) {
+    return arguments.length ? center(r(_)) : r.invert(center());
+  };
+
+  return p
+      .clipAngle(90);
+}

node_modules/d3-geo-projection/src/collignon.js

@@ -0,0 +1,18 @@
+import {geoProjection as projection} from "d3-geo";
+import {asin, pi, sin, sqrt, sqrtPi} from "./math.js";
+
+export function collignonRaw(lambda, phi) {
+  var alpha = sqrt(1 - sin(phi));
+  return [(2 / sqrtPi) * lambda * alpha, sqrtPi * (1 - alpha)];
+}
+
+collignonRaw.invert = function(x, y) {
+  var lambda = (lambda = y / sqrtPi - 1) * lambda;
+  return [lambda > 0 ? x * sqrt(pi / lambda) / 2 : 0, asin(1 - lambda)];
+};
+
+export default function() {
+  return projection(collignonRaw)
+      .scale(95.6464)
+      .center([0, 30]);
+}

node_modules/d3-geo-projection/src/craig.js

@@ -0,0 +1,26 @@
+import {asin, atan2, cos, sin, sqrt, tan} from "./math.js";
+import parallel1 from "./parallel1.js";
+
+export function craigRaw(phi0) {
+  var tanPhi0 = tan(phi0);
+
+  function forward(lambda, phi) {
+    return [lambda, (lambda ? lambda / sin(lambda) : 1) * (sin(phi) * cos(lambda) - tanPhi0 * cos(phi))];
+  }
+
+  forward.invert = tanPhi0 ? function(x, y) {
+    if (x) y *= sin(x) / x;
+    var cosLambda = cos(x);
+    return [x, 2 * atan2(sqrt(cosLambda * cosLambda + tanPhi0 * tanPhi0 - y * y) - cosLambda, tanPhi0 - y)];
+  } : function(x, y) {
+    return [x, asin(x ? y * tan(x) / x : y)];
+  };
+
+  return forward;
+}
+
+export default function() {
+  return parallel1(craigRaw)
+      .scale(249.828)
+      .clipAngle(90);
+}

node_modules/d3-geo-projection/src/craster.js

@@ -0,0 +1,18 @@
+import {geoProjection as projection} from "d3-geo";
+import {asin, cos, sin, sqrt, sqrtPi} from "./math.js";
+
+var sqrt3 = sqrt(3);
+
+export function crasterRaw(lambda, phi) {
+  return [sqrt3 * lambda * (2 * cos(2 * phi / 3) - 1) / sqrtPi, sqrt3 * sqrtPi * sin(phi / 3)];
+}
+
+crasterRaw.invert = function(x, y) {
+  var phi = 3 * asin(y / (sqrt3 * sqrtPi));
+  return [sqrtPi * x / (sqrt3 * (2 * cos(2 * phi / 3) - 1)), phi];
+};
+
+export default function() {
+  return projection(crasterRaw)
+      .scale(156.19);
+}

node_modules/d3-geo-projection/src/cylindricalEqualArea.js

@@ -0,0 +1,22 @@
+import {asin, cos, sin} from "./math.js";
+import parallel1 from "./parallel1.js";
+
+export function cylindricalEqualAreaRaw(phi0) {
+  var cosPhi0 = cos(phi0);
+
+  function forward(lambda, phi) {
+    return [lambda * cosPhi0, sin(phi) / cosPhi0];
+  }
+
+  forward.invert = function(x, y) {
+    return [x / cosPhi0, asin(y * cosPhi0)];
+  };
+
+  return forward;
+}
+
+export default function() {
+  return parallel1(cylindricalEqualAreaRaw)
+      .parallel(38.58) // acos(sqrt(width / height / pi)) * radians
+      .scale(195.044); // width / (sqrt(width / height / pi) * 2 * pi)
+}

node_modules/d3-geo-projection/src/cylindricalStereographic.js

@@ -0,0 +1,21 @@
+import {atan, cos, tan} from "./math.js";
+import parallel1 from "./parallel1.js";
+
+export function cylindricalStereographicRaw(phi0) {
+  var cosPhi0 = cos(phi0);
+
+  function forward(lambda, phi) {
+    return [lambda * cosPhi0, (1 + cosPhi0) * tan(phi / 2)];
+  }
+
+  forward.invert = function(x, y) {
+    return [x / cosPhi0, atan(y / (1 + cosPhi0)) * 2];
+  };
+
+  return forward;
+}
+
+export default function() {
+  return parallel1(cylindricalStereographicRaw)
+      .scale(124.75);
+}

node_modules/d3-geo-projection/src/eckert1.js

@@ -0,0 +1,24 @@
+import {geoProjection as projection} from "d3-geo";
+import {abs, pi, sqrt} from "./math.js";
+
+export function eckert1Raw(lambda, phi) {
+  var alpha = sqrt(8 / (3 * pi));
+  return [
+    alpha * lambda * (1 - abs(phi) / pi),
+    alpha * phi
+  ];
+}
+
+eckert1Raw.invert = function(x, y) {
+  var alpha = sqrt(8 / (3 * pi)),
+      phi = y / alpha;
+  return [
+    x / (alpha * (1 - abs(phi) / pi)),
+    phi
+  ];
+};
+
+export default function() {
+  return projection(eckert1Raw)
+      .scale(165.664);
+}

node_modules/d3-geo-projection/src/eckert2.js

@@ -0,0 +1,23 @@
+import {geoProjection as projection} from "d3-geo";
+import {abs, asin, pi, sign, sin, sqrt} from "./math.js";
+
+export function eckert2Raw(lambda, phi) {
+  var alpha = sqrt(4 - 3 * sin(abs(phi)));
+  return [
+    2 / sqrt(6 * pi) * lambda * alpha,
+    sign(phi) * sqrt(2 * pi / 3) * (2 - alpha)
+  ];
+}
+
+eckert2Raw.invert = function(x, y) {
+  var alpha = 2 - abs(y) / sqrt(2 * pi / 3);
+  return [
+    x * sqrt(6 * pi) / (2 * alpha),
+    sign(y) * asin((4 - alpha * alpha) / 3)
+  ];
+};
+
+export default function() {
+  return projection(eckert2Raw)
+      .scale(165.664);
+}

node_modules/d3-geo-projection/src/eckert3.js

@@ -0,0 +1,23 @@
+import {geoProjection as projection} from "d3-geo";
+import {pi, sqrt} from "./math.js";
+
+export function eckert3Raw(lambda, phi) {
+  var k = sqrt(pi * (4 + pi));
+  return [
+    2 / k * lambda * (1 + sqrt(1 - 4 * phi * phi / (pi * pi))),
+    4 / k * phi
+  ];
+}
+
+eckert3Raw.invert = function(x, y) {
+  var k = sqrt(pi * (4 + pi)) / 2;
+  return [
+    x * k / (1 + sqrt(1 - y * y * (4 + pi) / (4 * pi))),
+    y * k / 2
+  ];
+};
+
+export default function() {
+  return projection(eckert3Raw)
+      .scale(180.739);
+}

node_modules/d3-geo-projection/src/eckert4.js

@@ -0,0 +1,30 @@
+import {geoProjection as projection} from "d3-geo";
+import {abs, asin, cos, epsilon, halfPi, pi, sin, sqrt} from "./math.js";
+
+export function eckert4Raw(lambda, phi) {
+  var k = (2 + halfPi) * sin(phi);
+  phi /= 2;
+  for (var i = 0, delta = Infinity; i < 10 && abs(delta) > epsilon; i++) {
+    var cosPhi = cos(phi);
+    phi -= delta = (phi + sin(phi) * (cosPhi + 2) - k) / (2 * cosPhi * (1 + cosPhi));
+  }
+  return [
+    2 / sqrt(pi * (4 + pi)) * lambda * (1 + cos(phi)),
+    2 * sqrt(pi / (4 + pi)) * sin(phi)
+  ];
+}
+
+eckert4Raw.invert = function(x, y) {
+  var A = y * sqrt((4 + pi) / pi) / 2,
+      k = asin(A),
+      c = cos(k);
+  return [
+    x / (2 / sqrt(pi * (4 + pi)) * (1 + c)),
+    asin((k + A * (c + 2)) / (2 + halfPi))
+  ];
+};
+
+export default function() {
+  return projection(eckert4Raw)
+      .scale(180.739);
+}

node_modules/d3-geo-projection/src/eckert5.js

@@ -0,0 +1,23 @@
+import {geoProjection as projection} from "d3-geo";
+import {cos, pi, sqrt} from "./math.js";
+
+export function eckert5Raw(lambda, phi) {
+  return [
+    lambda * (1 + cos(phi)) / sqrt(2 + pi),
+    2 * phi / sqrt(2 + pi)
+  ];
+}
+
+eckert5Raw.invert = function(x, y) {
+  var k = sqrt(2 + pi),
+      phi = y * k / 2;
+  return [
+    k * x / (1 + cos(phi)),
+    phi
+  ];
+};
+
+export default function() {
+  return projection(eckert5Raw)
+      .scale(173.044);
+}

node_modules/d3-geo-projection/src/eckert6.js

@@ -0,0 +1,28 @@
+import {geoProjection as projection} from "d3-geo";
+import {abs, asin, cos, epsilon, halfPi, pi, sin, sqrt} from "./math.js";
+
+export function eckert6Raw(lambda, phi) {
+  var k = (1 + halfPi) * sin(phi);
+  for (var i = 0, delta = Infinity; i < 10 && abs(delta) > epsilon; i++) {
+    phi -= delta = (phi + sin(phi) - k) / (1 + cos(phi));
+  }
+  k = sqrt(2 + pi);
+  return [
+    lambda * (1 + cos(phi)) / k,
+    2 * phi / k
+  ];
+}
+
+eckert6Raw.invert = function(x, y) {
+  var j = 1 + halfPi,
+      k = sqrt(j / 2);
+  return [
+    x * 2 * k / (1 + cos(y *= k)),
+    asin((y + sin(y)) / j)
+  ];
+};
+
+export default function() {
+  return projection(eckert6Raw)
+      .scale(173.044);
+}

node_modules/d3-geo-projection/src/eisenlohr.js

@@ -0,0 +1,70 @@
+import {geoProjection as projection} from "d3-geo";
+import {augustRaw} from "./august.js";
+import {abs, atan, cos, epsilon, halfPi, log, max, min, sin, sqrt, sqrt1_2, sqrt2} from "./math.js";
+
+var eisenlohrK = 3 + 2 * sqrt2;
+
+export function eisenlohrRaw(lambda, phi) {
+  var s0 = sin(lambda /= 2),
+      c0 = cos(lambda),
+      k = sqrt(cos(phi)),
+      c1 = cos(phi /= 2),
+      t = sin(phi) / (c1 + sqrt2 * c0 * k),
+      c = sqrt(2 / (1 + t * t)),
+      v = sqrt((sqrt2 * c1 + (c0 + s0) * k) / (sqrt2 * c1 + (c0 - s0) * k));
+  return [
+    eisenlohrK * (c * (v - 1 / v) - 2 * log(v)),
+    eisenlohrK * (c * t * (v + 1 / v) - 2 * atan(t))
+  ];
+}
+
+eisenlohrRaw.invert = function(x, y) {
+  if (!(p = augustRaw.invert(x / 1.2, y * 1.065))) return null;
+  var lambda = p[0], phi = p[1], i = 20, p;
+  x /= eisenlohrK, y /= eisenlohrK;
+  do {
+    var _0 = lambda / 2,
+        _1 = phi / 2,
+        s0 = sin(_0),
+        c0 = cos(_0),
+        s1 = sin(_1),
+        c1 = cos(_1),
+        cos1 = cos(phi),
+        k = sqrt(cos1),
+        t = s1 / (c1 + sqrt2 * c0 * k),
+        t2 = t * t,
+        c = sqrt(2 / (1 + t2)),
+        v0 = (sqrt2 * c1 + (c0 + s0) * k),
+        v1 = (sqrt2 * c1 + (c0 - s0) * k),
+        v2 = v0 / v1,
+        v = sqrt(v2),
+        vm1v = v - 1 / v,
+        vp1v = v + 1 / v,
+        fx = c * vm1v - 2 * log(v) - x,
+        fy = c * t * vp1v - 2 * atan(t) - y,
+        deltatDeltaLambda = s1 && sqrt1_2 * k * s0 * t2 / s1,
+        deltatDeltaPhi = (sqrt2 * c0 * c1 + k) / (2 * (c1 + sqrt2 * c0 * k) * (c1 + sqrt2 * c0 * k) * k),
+        deltacDeltat = -0.5 * t * c * c * c,
+        deltacDeltaLambda = deltacDeltat * deltatDeltaLambda,
+        deltacDeltaPhi = deltacDeltat * deltatDeltaPhi,
+        A = (A = 2 * c1 + sqrt2 * k * (c0 - s0)) * A * v,
+        deltavDeltaLambda = (sqrt2 * c0 * c1 * k + cos1) / A,
+        deltavDeltaPhi = -(sqrt2 * s0 * s1) / (k * A),
+        deltaxDeltaLambda = vm1v * deltacDeltaLambda - 2 * deltavDeltaLambda / v + c * (deltavDeltaLambda + deltavDeltaLambda / v2),
+        deltaxDeltaPhi = vm1v * deltacDeltaPhi - 2 * deltavDeltaPhi / v + c * (deltavDeltaPhi + deltavDeltaPhi / v2),
+        deltayDeltaLambda = t * vp1v * deltacDeltaLambda - 2 * deltatDeltaLambda / (1 + t2) + c * vp1v * deltatDeltaLambda + c * t * (deltavDeltaLambda - deltavDeltaLambda / v2),
+        deltayDeltaPhi = t * vp1v * deltacDeltaPhi - 2 * deltatDeltaPhi / (1 + t2) + c * vp1v * deltatDeltaPhi + c * t * (deltavDeltaPhi - deltavDeltaPhi / v2),
+        denominator = deltaxDeltaPhi * deltayDeltaLambda - deltayDeltaPhi * deltaxDeltaLambda;
+    if (!denominator) break;
+    var deltaLambda = (fy * deltaxDeltaPhi - fx * deltayDeltaPhi) / denominator,
+        deltaPhi = (fx * deltayDeltaLambda - fy * deltaxDeltaLambda) / denominator;
+    lambda -= deltaLambda;
+    phi = max(-halfPi, min(halfPi, phi - deltaPhi));
+  } while ((abs(deltaLambda) > epsilon || abs(deltaPhi) > epsilon) && --i > 0);
+  return abs(abs(phi) - halfPi) < epsilon ? [0, phi] : i && [lambda, phi];
+};
+
+export default function() {
+  return projection(eisenlohrRaw)
+      .scale(62.5271);
+}

node_modules/d3-geo-projection/src/elliptic.js

@@ -0,0 +1,118 @@
+import {abs, asin, atan, cos, cosh, epsilon, exp, halfPi, log, pi, pow, quarterPi, sign, sin, sinh, sqrt, tan, tanh} from "./math.js";
+
+// Returns [sn, cn, dn](u + iv|m).
+export function ellipticJi(u, v, m) {
+  var a, b, c;
+  if (!u) {
+    b = ellipticJ(v, 1 - m);
+    return [
+      [0, b[0] / b[1]],
+      [1 / b[1], 0],
+      [b[2] / b[1], 0]
+    ];
+  }
+  a = ellipticJ(u, m);
+  if (!v) return [[a[0], 0], [a[1], 0], [a[2], 0]];
+  b = ellipticJ(v, 1 - m);
+  c = b[1] * b[1] + m * a[0] * a[0] * b[0] * b[0];
+  return [
+    [a[0] * b[2] / c, a[1] * a[2] * b[0] * b[1] / c],
+    [a[1] * b[1] / c, -a[0] * a[2] * b[0] * b[2] / c],
+    [a[2] * b[1] * b[2] / c, -m * a[0] * a[1] * b[0] / c]
+  ];
+}
+
+// Returns [sn, cn, dn, ph](u|m).
+export function ellipticJ(u, m) {
+  var ai, b, phi, t, twon;
+  if (m < epsilon) {
+    t = sin(u);
+    b = cos(u);
+    ai = m * (u - t * b) / 4;
+    return [
+      t - ai * b,
+      b + ai * t,
+      1 - m * t * t / 2,
+      u - ai
+    ];
+  }
+  if (m >= 1 - epsilon) {
+    ai = (1 - m) / 4;
+    b = cosh(u);
+    t = tanh(u);
+    phi = 1 / b;
+    twon = b * sinh(u);
+    return [
+      t + ai * (twon - u) / (b * b),
+      phi - ai * t * phi * (twon - u),
+      phi + ai * t * phi * (twon + u),
+      2 * atan(exp(u)) - halfPi + ai * (twon - u) / b
+    ];
+  }
+
+  var a = [1, 0, 0, 0, 0, 0, 0, 0, 0],
+      c = [sqrt(m), 0, 0, 0, 0, 0, 0, 0, 0],
+      i = 0;
+  b = sqrt(1 - m);
+  twon = 1;
+
+  while (abs(c[i] / a[i]) > epsilon && i < 8) {
+    ai = a[i++];
+    c[i] = (ai - b) / 2;
+    a[i] = (ai + b) / 2;
+    b = sqrt(ai * b);
+    twon *= 2;
+  }
+
+  phi = twon * a[i] * u;
+  do {
+    t = c[i] * sin(b = phi) / a[i];
+    phi = (asin(t) + phi) / 2;
+  } while (--i);
+
+  return [sin(phi), t = cos(phi), t / cos(phi - b), phi];
+}
+
+// Calculate F(phi+iPsi|m).
+// See Abramowitz and Stegun, 17.4.11.
+export function ellipticFi(phi, psi, m) {
+  var r = abs(phi),
+      i = abs(psi),
+      sinhPsi = sinh(i);
+  if (r) {
+    var cscPhi = 1 / sin(r),
+        cotPhi2 = 1 / (tan(r) * tan(r)),
+        b = -(cotPhi2 + m * (sinhPsi * sinhPsi * cscPhi * cscPhi) - 1 + m),
+        c = (m - 1) * cotPhi2,
+        cotLambda2 = (-b + sqrt(b * b - 4 * c)) / 2;
+    return [
+      ellipticF(atan(1 / sqrt(cotLambda2)), m) * sign(phi),
+      ellipticF(atan(sqrt((cotLambda2 / cotPhi2 - 1) / m)), 1 - m) * sign(psi)
+    ];
+  }
+  return [
+    0,
+    ellipticF(atan(sinhPsi), 1 - m) * sign(psi)
+  ];
+}
+
+// Calculate F(phi|m) where m = k² = sin²α.
+// See Abramowitz and Stegun, 17.6.7.
+export function ellipticF(phi, m) {
+  if (!m) return phi;
+  if (m === 1) return log(tan(phi / 2 + quarterPi));
+  var a = 1,
+      b = sqrt(1 - m),
+      c = sqrt(m);
+  for (var i = 0; abs(c) > epsilon; i++) {
+    if (phi % pi) {
+      var dPhi = atan(b * tan(phi) / a);
+      if (dPhi < 0) dPhi += pi;
+      phi += dPhi + ~~(phi / pi) * pi;
+    } else phi += phi;
+    c = (a + b) / 2;
+    b = sqrt(a * b);
+    c = ((a = c) - b) / 2;
+  }
+  return phi / (pow(2, i) * a);
+}

node_modules/d3-geo-projection/src/fahey.js

@@ -0,0 +1,19 @@
+import {geoProjection as projection} from "d3-geo";
+import {atan, cos, radians, sqrt, tan} from "./math.js";
+
+var faheyK = cos(35 * radians);
+
+export function faheyRaw(lambda, phi) {
+  var t = tan(phi / 2);
+  return [lambda * faheyK * sqrt(1 - t * t), (1 + faheyK) * t];
+}
+
+faheyRaw.invert = function(x, y) {
+  var t = y / (1 + faheyK);
+  return [x && x / (faheyK * sqrt(1 - t * t)), 2 * atan(t)];
+};
+
+export default function() {
+  return projection(faheyRaw)
+      .scale(137.152);
+}

node_modules/d3-geo-projection/src/foucaut.js

@@ -0,0 +1,17 @@
+import {geoProjection as projection} from "d3-geo";
+import {atan, cos, sqrtPi, tan} from "./math.js";
+
+export function foucautRaw(lambda, phi) {
+  var k = phi / 2, cosk = cos(k);
+  return [ 2 * lambda / sqrtPi * cos(phi) * cosk * cosk, sqrtPi * tan(k)];
+}
+
+foucautRaw.invert = function(x, y) {
+  var k = atan(y / sqrtPi), cosk = cos(k), phi = 2 * k;
+  return [x * sqrtPi / 2 / (cos(phi) * cosk * cosk), phi];
+};
+
+export default function() {
+  return projection(foucautRaw)
+      .scale(135.264);
+}

node_modules/d3-geo-projection/src/foucautSinusoidal.js

@@ -0,0 +1,49 @@
+import {geoProjectionMutator as projectionMutator} from "d3-geo";
+import {cos, halfPi, pi, sin, sqrt} from "./math.js";
+import {solve} from "./newton.js";
+
+export function foucautSinusoidalRaw(alpha) {
+  var beta = 1 - alpha,
+      equatorial = raw(pi, 0)[0] - raw(-pi, 0)[0],
+      polar = raw(0, halfPi)[1] - raw(0, -halfPi)[1],
+      ratio = sqrt(2 * polar / equatorial);
+
+  function raw(lambda, phi) {
+    var cosphi = cos(phi),
+        sinphi = sin(phi);
+    return [
+      cosphi / (beta + alpha * cosphi) * lambda,
+      beta * phi + alpha * sinphi
+    ];
+  }
+
+  function forward(lambda, phi) {
+    var p = raw(lambda, phi);
+    return [p[0] * ratio, p[1] / ratio];
+  }
+
+  function forwardMeridian(phi) {
+    return forward(0, phi)[1];
+  }
+
+  forward.invert = function(x, y) {
+    var phi = solve(forwardMeridian, y),
+        lambda = x / ratio * (alpha + beta / cos(phi));
+    return [lambda, phi];
+  };
+
+  return forward;
+}
+
+export default function() {
+  var alpha = 0.5,
+      m = projectionMutator(foucautSinusoidalRaw),
+      p = m(alpha);
+
+  p.alpha = function(_) {
+    return arguments.length ? m(alpha = +_) : alpha;
+  };
+
+  return p
+      .scale(168.725);
+}

node_modules/d3-geo-projection/src/gilbert.js

@@ -0,0 +1,64 @@
+import {geoEquirectangular, geoOrthographic} from "d3-geo";
+import {asin, atan, degrees, radians, sin, tan} from "./math.js";
+
+function gilbertForward(point) {
+  return [point[0] / 2, asin(tan(point[1] / 2 * radians)) * degrees];
+}
+
+function gilbertInvert(point) {
+  return [point[0] * 2, 2 * atan(sin(point[1] * radians)) * degrees];
+}
+
+export default function(projectionType) {
+  if (projectionType == null) projectionType = geoOrthographic;
+  var projection = projectionType(),
+      equirectangular = geoEquirectangular().scale(degrees).precision(0).clipAngle(null).translate([0, 0]); // antimeridian cutting
+
+  function gilbert(point) {
+    return projection(gilbertForward(point));
+  }
+
+  if (projection.invert) gilbert.invert = function(point) {
+    return gilbertInvert(projection.invert(point));
+  };
+
+  gilbert.stream = function(stream) {
+    var s1 = projection.stream(stream), s0 = equirectangular.stream({
+      point: function(lambda, phi) { s1.point(lambda / 2, asin(tan(-phi / 2 * radians)) * degrees); },
+      lineStart: function() { s1.lineStart(); },
+      lineEnd: function() { s1.lineEnd(); },
+      polygonStart: function() { s1.polygonStart(); },
+      polygonEnd: function() { s1.polygonEnd(); }
+    });
+    s0.sphere = s1.sphere;
+    return s0;
+  };
+
+  function property(name) {
+    gilbert[name] = function() {
+      return arguments.length ? (projection[name].apply(projection, arguments), gilbert) : projection[name]();
+    };
+  }
+
+  gilbert.rotate = function(_) {
+    return arguments.length ? (equirectangular.rotate(_), gilbert) : equirectangular.rotate();
+  };
+
+  gilbert.center = function(_) {
+    return arguments.length ? (projection.center(gilbertForward(_)), gilbert) : gilbertInvert(projection.center());
+  };
+
+  property("angle");
+  property("clipAngle");
+  property("clipExtent");
+  property("fitExtent");
+  property("fitHeight");
+  property("fitSize");
+  property("fitWidth");
+  property("scale");
+  property("translate");
+  property("precision");
+
+  return gilbert
+      .scale(249.5);
+}

node_modules/d3-geo-projection/src/gingery.js

@@ -0,0 +1,146 @@
+import {geoAzimuthalEquidistantRaw as azimuthalEquidistantRaw, geoProjectionMutator as projectionMutator} from "d3-geo";
+import {abs, asin, atan2, cos, degrees, epsilon, epsilon2, halfPi, pi, radians, round, sin, sqrt} from "./math.js";
+
+export function gingeryRaw(rho, n) {
+  var k = 2 * pi / n,
+      rho2 = rho * rho;
+
+  function forward(lambda, phi) {
+    var p = azimuthalEquidistantRaw(lambda, phi),
+        x = p[0],
+        y = p[1],
+        r2 = x * x + y * y;
+
+    if (r2 > rho2) {
+      var r = sqrt(r2),
+          theta = atan2(y, x),
+          theta0 = k * round(theta / k),
+          alpha = theta - theta0,
+          rhoCosAlpha = rho * cos(alpha),
+          k_ = (rho * sin(alpha) - alpha * sin(rhoCosAlpha)) / (halfPi - rhoCosAlpha),
+          s_ = gingeryLength(alpha, k_),
+          e = (pi - rho) / gingeryIntegrate(s_, rhoCosAlpha, pi);
+
+      x = r;
+      var i = 50, delta;
+      do {
+        x -= delta = (rho + gingeryIntegrate(s_, rhoCosAlpha, x) * e - r) / (s_(x) * e);
+      } while (abs(delta) > epsilon && --i > 0);
+
+      y = alpha * sin(x);
+      if (x < halfPi) y -= k_ * (x - halfPi);
+
+      var s = sin(theta0),
+          c = cos(theta0);
+      p[0] = x * c - y * s;
+      p[1] = x * s + y * c;
+    }
+    return p;
+  }
+
+  forward.invert = function(x, y) {
+    var r2 = x * x + y * y;
+    if (r2 > rho2) {
+      var r = sqrt(r2),
+          theta = atan2(y, x),
+          theta0 = k * round(theta / k),
+          dTheta = theta - theta0;
+
+      x = r * cos(dTheta);
+      y = r * sin(dTheta);
+
+      var x_halfPi = x - halfPi,
+          sinx = sin(x),
+          alpha = y / sinx,
+          delta = x < halfPi ? Infinity : 0,
+          i = 10;
+
+      while (true) {
+        var rhosinAlpha = rho * sin(alpha),
+            rhoCosAlpha = rho * cos(alpha),
+            sinRhoCosAlpha = sin(rhoCosAlpha),
+            halfPi_RhoCosAlpha = halfPi - rhoCosAlpha,
+            k_ = (rhosinAlpha - alpha * sinRhoCosAlpha) / halfPi_RhoCosAlpha,
+            s_ = gingeryLength(alpha, k_);
+
+        if (abs(delta) < epsilon2 || !--i) break;
+
+        alpha -= delta = (alpha * sinx - k_ * x_halfPi - y) / (
+          sinx - x_halfPi * 2 * (
+            halfPi_RhoCosAlpha * (rhoCosAlpha + alpha * rhosinAlpha * cos(rhoCosAlpha) - sinRhoCosAlpha) -
+            rhosinAlpha * (rhosinAlpha - alpha * sinRhoCosAlpha)
+          ) / (halfPi_RhoCosAlpha * halfPi_RhoCosAlpha));
+      }
+      r = rho + gingeryIntegrate(s_, rhoCosAlpha, x) * (pi - rho) / gingeryIntegrate(s_, rhoCosAlpha, pi);
+      theta = theta0 + alpha;
+      x = r * cos(theta);
+      y = r * sin(theta);
+    }
+    return azimuthalEquidistantRaw.invert(x, y);
+  };
+
+  return forward;
+}
+
+function gingeryLength(alpha, k) {
+  return function(x) {
+    var y_ = alpha * cos(x);
+    if (x < halfPi) y_ -= k;
+    return sqrt(1 + y_ * y_);
+  };
+}
+
+// Numerical integration: trapezoidal rule.
+function gingeryIntegrate(f, a, b) {
+  var n = 50,
+      h = (b - a) / n,
+      s = f(a) + f(b);
+  for (var i = 1, x = a; i < n; ++i) s += 2 * f(x += h);
+  return s * 0.5 * h;
+}
+
+export default function() {
+  var n = 6,
+      rho = 30 * radians,
+      cRho = cos(rho),
+      sRho = sin(rho),
+      m = projectionMutator(gingeryRaw),
+      p = m(rho, n),
+      stream_ = p.stream,
+      epsilon = 1e-2,
+      cr = -cos(epsilon * radians),
+      sr = sin(epsilon * radians);
+
+  p.radius = function(_) {
+    if (!arguments.length) return rho * degrees;
+    cRho = cos(rho = _ * radians);
+    sRho = sin(rho);
+    return m(rho, n);
+  };
+
+  p.lobes = function(_) {
+    if (!arguments.length) return n;
+    return m(rho, n = +_);
+  };
+
+  p.stream = function(stream) {
+    var rotate = p.rotate(),
+        rotateStream = stream_(stream),
+        sphereStream = (p.rotate([0, 0]), stream_(stream));
+    p.rotate(rotate);
+    rotateStream.sphere = function() {
+      sphereStream.polygonStart(), sphereStream.lineStart();
+      for (var i = 0, delta = 2 * pi / n, phi = 0; i < n; ++i, phi -= delta) {
+        sphereStream.point(atan2(sr * cos(phi), cr) * degrees, asin(sr * sin(phi)) * degrees);
+        sphereStream.point(atan2(sRho * cos(phi - delta / 2), cRho) * degrees, asin(sRho * sin(phi - delta / 2)) * degrees);
+      }
+      sphereStream.lineEnd(), sphereStream.polygonEnd();
+    };
+    return rotateStream;
+  };
+
+  return p
+      .rotate([90, -40])
+      .scale(91.7095)
+      .clipAngle(180 - 1e-3);
+}

node_modules/d3-geo-projection/src/ginzburg4.js

@@ -0,0 +1,9 @@
+import {geoProjection as projection} from "d3-geo";
+import ginzburgPolyconicRaw from "./ginzburgPolyconic.js";
+
+export var ginzburg4Raw = ginzburgPolyconicRaw(2.8284, -1.6988, 0.75432, -0.18071, 1.76003, -0.38914, 0.042555);
+
+export default function() {
+  return projection(ginzburg4Raw)
+      .scale(149.995);
+}

node_modules/d3-geo-projection/src/ginzburg5.js

@@ -0,0 +1,9 @@
+import {geoProjection as projection} from "d3-geo";
+import ginzburgPolyconicRaw from "./ginzburgPolyconic.js";
+
+export var ginzburg5Raw = ginzburgPolyconicRaw(2.583819, -0.835827, 0.170354, -0.038094, 1.543313, -0.411435,0.082742);
+
+export default function() {
+  return projection(ginzburg5Raw)
+      .scale(153.93);
+}

node_modules/d3-geo-projection/src/ginzburg6.js

@@ -0,0 +1,10 @@
+import {geoProjection as projection} from "d3-geo";
+import ginzburgPolyconicRaw from "./ginzburgPolyconic.js";
+import {pi} from "./math.js";
+
+export var ginzburg6Raw = ginzburgPolyconicRaw(5 / 6 * pi, -0.62636, -0.0344, 0, 1.3493, -0.05524, 0, 0.045);
+
+export default function() {
+  return projection(ginzburg6Raw)
+      .scale(130.945);
+}

node_modules/d3-geo-projection/src/ginzburg8.js

@@ -0,0 +1,33 @@
+import {geoProjection as projection} from "d3-geo";
+import {abs, epsilon} from "./math.js";
+
+export function ginzburg8Raw(lambda, phi) {
+  var lambda2 = lambda * lambda,
+      phi2 = phi * phi;
+  return [
+    lambda * (1 - 0.162388 * phi2) * (0.87 - 0.000952426 * lambda2 * lambda2),
+    phi * (1 + phi2 / 12)
+  ];
+}
+
+ginzburg8Raw.invert = function(x, y) {
+  var lambda = x,
+      phi = y,
+      i = 50, delta;
+  do {
+    var phi2 = phi * phi;
+    phi -= delta = (phi * (1 + phi2 / 12) - y) / (1 + phi2 / 4);
+  } while (abs(delta) > epsilon && --i > 0);
+  i = 50;
+  x /= 1 -0.162388 * phi2;
+  do {
+    var lambda4 = (lambda4 = lambda * lambda) * lambda4;
+    lambda -= delta = (lambda * (0.87 - 0.000952426 * lambda4) - x) / (0.87 - 0.00476213 * lambda4);
+  } while (abs(delta) > epsilon && --i > 0);
+  return [lambda, phi];
+};
+
+export default function() {
+  return projection(ginzburg8Raw)
+      .scale(131.747);
+}

node_modules/d3-geo-projection/src/ginzburg9.js

@@ -0,0 +1,9 @@
+import {geoProjection as projection} from "d3-geo";
+import ginzburgPolyconicRaw from "./ginzburgPolyconic.js";
+
+export var ginzburg9Raw = ginzburgPolyconicRaw(2.6516, -0.76534, 0.19123, -0.047094, 1.36289, -0.13965,0.031762);
+
+export default function() {
+  return projection(ginzburg9Raw)
+      .scale(131.087);
+}

node_modules/d3-geo-projection/src/ginzburgPolyconic.js

@@ -0,0 +1,56 @@
+import {abs, asin, cos, epsilon, pi, sin, sqrt} from "./math.js";
+
+export default function(a, b, c, d, e, f, g, h) {
+  if (arguments.length < 8) h = 0;
+
+  function forward(lambda, phi) {
+    if (!phi) return [a * lambda / pi, 0];
+    var phi2 = phi * phi,
+        xB = a + phi2 * (b + phi2 * (c + phi2 * d)),
+        yB = phi * (e - 1 + phi2 * (f - h + phi2 * g)),
+        m = (xB * xB + yB * yB) / (2 * yB),
+        alpha = lambda * asin(xB / m) / pi;
+    return [m * sin(alpha), phi * (1 + phi2 * h) + m * (1 - cos(alpha))];
+  }
+
+  forward.invert = function(x, y) {
+    var lambda = pi * x / a,
+        phi = y,
+        deltaLambda, deltaPhi, i = 50;
+    do {
+      var phi2 = phi * phi,
+          xB = a + phi2 * (b + phi2 * (c + phi2 * d)),
+          yB = phi * (e - 1 + phi2 * (f - h + phi2 * g)),
+          p = xB * xB + yB * yB,
+          q = 2 * yB,
+          m = p / q,
+          m2 = m * m,
+          dAlphadLambda = asin(xB / m) / pi,
+          alpha = lambda * dAlphadLambda,
+          xB2 = xB * xB,
+          dxBdPhi = (2 * b + phi2 * (4 * c + phi2 * 6 * d)) * phi,
+          dyBdPhi = e + phi2 * (3 * f + phi2 * 5 * g),
+          dpdPhi = 2 * (xB * dxBdPhi + yB * (dyBdPhi - 1)),
+          dqdPhi = 2 * (dyBdPhi - 1),
+          dmdPhi = (dpdPhi * q - p * dqdPhi) / (q * q),
+          cosAlpha = cos(alpha),
+          sinAlpha = sin(alpha),
+          mcosAlpha = m * cosAlpha,
+          msinAlpha = m * sinAlpha,
+          dAlphadPhi = ((lambda / pi) * (1 / sqrt(1 - xB2 / m2)) * (dxBdPhi * m - xB * dmdPhi)) / m2,
+          fx = msinAlpha - x,
+          fy = phi * (1 + phi2 * h) + m - mcosAlpha - y,
+          deltaxDeltaPhi = dmdPhi * sinAlpha + mcosAlpha * dAlphadPhi,
+          deltaxDeltaLambda = mcosAlpha * dAlphadLambda,
+          deltayDeltaPhi = 1 + dmdPhi - (dmdPhi * cosAlpha - msinAlpha * dAlphadPhi),
+          deltayDeltaLambda = msinAlpha * dAlphadLambda,
+          denominator = deltaxDeltaPhi * deltayDeltaLambda - deltayDeltaPhi * deltaxDeltaLambda;
+      if (!denominator) break;
+      lambda -= deltaLambda = (fy * deltaxDeltaPhi - fx * deltayDeltaPhi) / denominator;
+      phi -= deltaPhi = (fx * deltayDeltaLambda - fy * deltaxDeltaLambda) / denominator;
+    } while ((abs(deltaLambda) > epsilon || abs(deltaPhi) > epsilon) && --i > 0);
+    return [lambda, phi];
+  };
+
+  return forward;
+}

node_modules/d3-geo-projection/src/gringorten.js

@@ -0,0 +1,147 @@
+import {geoProjection as projection} from "d3-geo";
+import {abs, asin, atan2, cos, sign, epsilon, epsilon2, halfPi, pi, sin, sqrt} from "./math.js";
+import squareRaw from "./square.js";
+
+export function gringortenRaw(lambda, phi) {
+  var sLambda = sign(lambda),
+      sPhi = sign(phi),
+      cosPhi = cos(phi),
+      x = cos(lambda) * cosPhi,
+      y = sin(lambda) * cosPhi,
+      z = sin(sPhi * phi);
+  lambda = abs(atan2(y, z));
+  phi = asin(x);
+  if (abs(lambda - halfPi) > epsilon) lambda %= halfPi;
+  var point = gringortenHexadecant(lambda > pi / 4 ? halfPi - lambda : lambda, phi);
+  if (lambda > pi / 4) z = point[0], point[0] = -point[1], point[1] = -z;
+  return (point[0] *= sLambda, point[1] *= -sPhi, point);
+}
+
+gringortenRaw.invert = function(x, y) {
+  if (abs(x) > 1) x = sign(x) * 2 - x;
+  if (abs(y) > 1) y = sign(y) * 2 - y;
+  var sx = sign(x),
+      sy = sign(y),
+      x0 = -sx * x,
+      y0 = -sy * y,
+      t = y0 / x0 < 1,
+      p = gringortenHexadecantInvert(t ? y0 : x0, t ? x0 : y0),
+      lambda = p[0],
+      phi = p[1],
+      cosPhi = cos(phi);
+  if (t) lambda = -halfPi - lambda;
+  return [sx * (atan2(sin(lambda) * cosPhi, -sin(phi)) + pi), sy * asin(cos(lambda) * cosPhi)];
+};
+
+function gringortenHexadecant(lambda, phi) {
+  if (phi === halfPi) return [0, 0];
+
+  var sinPhi = sin(phi),
+      r = sinPhi * sinPhi,
+      r2 = r * r,
+      j = 1 + r2,
+      k = 1 + 3 * r2,
+      q = 1 - r2,
+      z = asin(1 / sqrt(j)),
+      v = q + r * j * z,
+      p2 = (1 - sinPhi) / v,
+      p = sqrt(p2),
+      a2 = p2 * j,
+      a = sqrt(a2),
+      h = p * q,
+      x,
+      i;
+
+  if (lambda === 0) return [0, -(h + r * a)];
+
+  var cosPhi = cos(phi),
+      secPhi = 1 / cosPhi,
+      drdPhi = 2 * sinPhi * cosPhi,
+      dvdPhi = (-3 * r + z * k) * drdPhi,
+      dp2dPhi = (-v * cosPhi - (1 - sinPhi) * dvdPhi) / (v * v),
+      dpdPhi = (0.5 * dp2dPhi) / p,
+      dhdPhi = q * dpdPhi - 2 * r * p * drdPhi,
+      dra2dPhi = r * j * dp2dPhi + p2 * k * drdPhi,
+      mu = -secPhi * drdPhi,
+      nu = -secPhi * dra2dPhi,
+      zeta = -2 * secPhi * dhdPhi,
+      lambda1 = 4 * lambda / pi,
+      delta;
+
+  // Slower but accurate bisection method.
+  if (lambda > 0.222 * pi || phi < pi / 4 && lambda > 0.175 * pi) {
+    x = (h + r * sqrt(a2 * (1 + r2) - h * h)) / (1 + r2);
+    if (lambda > pi / 4) return [x, x];
+    var x1 = x, x0 = 0.5 * x;
+    x = 0.5 * (x0 + x1), i = 50;
+    do {
+      var g = sqrt(a2 - x * x),
+          f = (x * (zeta + mu * g) + nu * asin(x / a)) - lambda1;
+      if (!f) break;
+      if (f < 0) x0 = x;
+      else x1 = x;
+      x = 0.5 * (x0 + x1);
+    } while (abs(x1 - x0) > epsilon && --i > 0);
+  }
+
+  // Newton-Raphson.
+  else {
+    x = epsilon, i = 25;
+    do {
+      var x2 = x * x,
+          g2 = sqrt(a2 - x2),
+          zetaMug = zeta + mu * g2,
+          f2 = x * zetaMug + nu * asin(x / a) - lambda1,
+          df = zetaMug + (nu - mu * x2) / g2;
+      x -= delta = g2 ? f2 / df : 0;
+    } while (abs(delta) > epsilon && --i > 0);
+  }
+
+  return [x, -h - r * sqrt(a2 - x * x)];
+}
+
+function gringortenHexadecantInvert(x, y) {
+  var x0 = 0,
+      x1 = 1,
+      r = 0.5,
+      i = 50;
+
+  while (true) {
+    var r2 = r * r,
+        sinPhi = sqrt(r),
+        z = asin(1 / sqrt(1 + r2)),
+        v = (1 - r2) + r * (1 + r2) * z,
+        p2 = (1 - sinPhi) / v,
+        p = sqrt(p2),
+        a2 = p2 * (1 + r2),
+        h = p * (1 - r2),
+        g2 = a2 - x * x,
+        g = sqrt(g2),
+        y0 = y + h + r * g;
+    if (abs(x1 - x0) < epsilon2 || --i === 0 || y0 === 0) break;
+    if (y0 > 0) x0 = r;
+    else x1 = r;
+    r = 0.5 * (x0 + x1);
+  }
+
+  if (!i) return null;
+
+  var phi = asin(sinPhi),
+      cosPhi = cos(phi),
+      secPhi = 1 / cosPhi,
+      drdPhi = 2 * sinPhi * cosPhi,
+      dvdPhi = (-3 * r + z * (1 + 3 * r2)) * drdPhi,
+      dp2dPhi = (-v * cosPhi - (1 - sinPhi) * dvdPhi) / (v * v),
+      dpdPhi = 0.5 * dp2dPhi / p,
+      dhdPhi = (1 - r2) * dpdPhi - 2 * r * p * drdPhi,
+      zeta = -2 * secPhi * dhdPhi,
+      mu = -secPhi * drdPhi,
+      nu = -secPhi * (r * (1 + r2) * dp2dPhi + p2 * (1 + 3 * r2) * drdPhi);
+
+  return [pi / 4 * (x * (zeta + mu * g) + nu * asin(x / sqrt(a2))), phi];
+}
+
+export default function() {
+  return projection(squareRaw(gringortenRaw))
+      .scale(239.75);
+}

node_modules/d3-geo-projection/src/guyou.js

@@ -0,0 +1,53 @@
+import {geoProjection as projection} from "d3-geo";
+import {ellipticF, ellipticFi, ellipticJi} from "./elliptic.js";
+import {abs, atan, atan2, cos, exp, halfPi, log, pi, sin, sqrt, sqrt2, tan} from "./math.js";
+import squareRaw from "./square.js";
+
+export function guyouRaw(lambda, phi) {
+  var k_ = (sqrt2 - 1) / (sqrt2 + 1),
+      k = sqrt(1 - k_ * k_),
+      K = ellipticF(halfPi, k * k),
+      f = -1,
+      psi = log(tan(pi / 4 + abs(phi) / 2)),
+      r = exp(f * psi) / sqrt(k_),
+      at = guyouComplexAtan(r * cos(f * lambda), r * sin(f * lambda)),
+      t = ellipticFi(at[0], at[1], k * k);
+  return [-t[1], (phi >= 0 ? 1 : -1) * (0.5 * K - t[0])];
+}
+
+function guyouComplexAtan(x, y) {
+  var x2 = x * x,
+      y_1 = y + 1,
+      t = 1 - x2 - y * y;
+  return [
+   0.5 * ((x >= 0 ? halfPi : -halfPi) - atan2(t, 2 * x)),
+    -0.25 * log(t * t + 4 * x2) +0.5 * log(y_1 * y_1 + x2)
+  ];
+}
+
+function guyouComplexDivide(a, b) {
+  var denominator = b[0] * b[0] + b[1] * b[1];
+  return [
+    (a[0] * b[0] + a[1] * b[1]) / denominator,
+    (a[1] * b[0] - a[0] * b[1]) / denominator
+  ];
+}
+
+guyouRaw.invert = function(x, y) {
+  var k_ = (sqrt2 - 1) / (sqrt2 + 1),
+      k = sqrt(1 - k_ * k_),
+      K = ellipticF(halfPi, k * k),
+      f = -1,
+      j = ellipticJi(0.5 * K - y, -x, k * k),
+      tn = guyouComplexDivide(j[0], j[1]),
+      lambda = atan2(tn[1], tn[0]) / f;
+  return [
+    lambda,
+    2 * atan(exp(0.5 / f * log(k_ * tn[0] * tn[0] + k_ * tn[1] * tn[1]))) - halfPi
+  ];
+};
+
+export default function() {
+  return projection(squareRaw(guyouRaw))
+      .scale(151.496);
+}

node_modules/d3-geo-projection/src/hammer.js

@@ -0,0 +1,51 @@
+import {geoAzimuthalEqualAreaRaw as azimuthalEqualAreaRaw, geoProjectionMutator as projectionMutator} from "d3-geo";
+import {asin, cos, sin} from "./math.js";
+
+export function hammerRaw(A, B) {
+  if (arguments.length < 2) B = A;
+  if (B === 1) return azimuthalEqualAreaRaw;
+  if (B === Infinity) return hammerQuarticAuthalicRaw;
+
+  function forward(lambda, phi) {
+    var coordinates = azimuthalEqualAreaRaw(lambda / B, phi);
+    coordinates[0] *= A;
+    return coordinates;
+  }
+
+  forward.invert = function(x, y) {
+    var coordinates = azimuthalEqualAreaRaw.invert(x / A, y);
+    coordinates[0] *= B;
+    return coordinates;
+  };
+
+  return forward;
+}
+
+function hammerQuarticAuthalicRaw(lambda, phi) {
+  return [
+    lambda * cos(phi) / cos(phi /= 2),
+    2 * sin(phi)
+  ];
+}
+
+hammerQuarticAuthalicRaw.invert = function(x, y) {
+  var phi = 2 * asin(y / 2);
+  return [
+    x * cos(phi / 2) / cos(phi),
+    phi
+  ];
+};
+
+export default function() {
+  var B = 2,
+      m = projectionMutator(hammerRaw),
+      p = m(B);
+
+  p.coefficient = function(_) {
+    if (!arguments.length) return B;
+    return m(B = +_);
+  };
+
+  return p
+    .scale(169.529);
+}

node_modules/d3-geo-projection/src/hammerRetroazimuthal.js

@@ -0,0 +1,109 @@
+import {geoProjectionMutator as projectionMutator, geoCircle} from "d3-geo";
+import {abs, acos, asin, atan2, cos, degrees, epsilon, halfPi, radians, sqrt, sin} from "./math.js";
+
+export function hammerRetroazimuthalRaw(phi0) {
+  var sinPhi0 = sin(phi0),
+      cosPhi0 = cos(phi0),
+      rotate = hammerRetroazimuthalRotation(phi0);
+
+  rotate.invert = hammerRetroazimuthalRotation(-phi0);
+
+  function forward(lambda, phi) {
+    var p = rotate(lambda, phi);
+    lambda = p[0], phi = p[1];
+    var sinPhi = sin(phi),
+        cosPhi = cos(phi),
+        cosLambda = cos(lambda),
+        z = acos(sinPhi0 * sinPhi + cosPhi0 * cosPhi * cosLambda),
+        sinz = sin(z),
+        K = abs(sinz) > epsilon ? z / sinz : 1;
+    return [
+      K * cosPhi0 * sin(lambda),
+      (abs(lambda) > halfPi ? K : -K) // rotate for back hemisphere
+        * (sinPhi0 * cosPhi - cosPhi0 * sinPhi * cosLambda)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var rho = sqrt(x * x + y * y),
+        sinz = -sin(rho),
+        cosz = cos(rho),
+        a = rho * cosz,
+        b = -y * sinz,
+        c = rho * sinPhi0,
+        d = sqrt(a * a + b * b - c * c),
+        phi = atan2(a * c + b * d, b * c - a * d),
+        lambda = (rho > halfPi ? -1 : 1) * atan2(x * sinz, rho * cos(phi) * cosz + y * sin(phi) * sinz);
+    return rotate.invert(lambda, phi);
+  };
+
+  return forward;
+}
+
+// Latitudinal rotation by phi0.
+// Temporary hack until D3 supports arbitrary small-circle clipping origins.
+function hammerRetroazimuthalRotation(phi0) {
+  var sinPhi0 = sin(phi0),
+      cosPhi0 = cos(phi0);
+
+  return function(lambda, phi) {
+    var cosPhi = cos(phi),
+        x = cos(lambda) * cosPhi,
+        y = sin(lambda) * cosPhi,
+        z = sin(phi);
+    return [
+      atan2(y, x * cosPhi0 - z * sinPhi0),
+      asin(z * cosPhi0 + x * sinPhi0)
+    ];
+  };
+}
+
+export default function() {
+  var phi0 = 0,
+      m = projectionMutator(hammerRetroazimuthalRaw),
+      p = m(phi0),
+      rotate_ = p.rotate,
+      stream_ = p.stream,
+      circle = geoCircle();
+
+  p.parallel = function(_) {
+    if (!arguments.length) return phi0 * degrees;
+    var r = p.rotate();
+    return m(phi0 = _ * radians).rotate(r);
+  };
+
+  // Temporary hack; see hammerRetroazimuthalRotation.
+  p.rotate = function(_) {
+    if (!arguments.length) return (_ = rotate_.call(p), _[1] += phi0 * degrees, _);
+    rotate_.call(p, [_[0], _[1] - phi0 * degrees]);
+    circle.center([-_[0], -_[1]]);
+    return p;
+  };
+
+  p.stream = function(stream) {
+    stream = stream_(stream);
+    stream.sphere = function() {
+      stream.polygonStart();
+      var epsilon = 1e-2,
+          ring = circle.radius(90 - epsilon)().coordinates[0],
+          n = ring.length - 1,
+          i = -1,
+          p;
+      stream.lineStart();
+      while (++i < n) stream.point((p = ring[i])[0], p[1]);
+      stream.lineEnd();
+      ring = circle.radius(90 + epsilon)().coordinates[0];
+      n = ring.length - 1;
+      stream.lineStart();
+      while (--i >= 0) stream.point((p = ring[i])[0], p[1]);
+      stream.lineEnd();
+      stream.polygonEnd();
+    };
+    return stream;
+  };
+
+  return p
+      .scale(79.4187)
+      .parallel(45)
+      .clipAngle(180 - 1e-3);
+}

node_modules/d3-geo-projection/src/healpix.js

@@ -0,0 +1,99 @@
+import {range} from "d3-array";
+import {geoStream, geoProjectionMutator as projectionMutator} from "d3-geo";
+import {collignonRaw} from "./collignon.js";
+import {cylindricalEqualAreaRaw} from "./cylindricalEqualArea.js";
+import {abs, asin, degrees, epsilon, floor, max, min, pi, radians, sqrtPi, tau} from "./math.js";
+
+var K = 3,
+    healpixParallel = asin(1 - 1 / K) * degrees,
+    healpixLambert = cylindricalEqualAreaRaw(0);
+
+export function healpixRaw(H) {
+  var phi0 = healpixParallel * radians,
+      dx = collignonRaw(pi, phi0)[0] - collignonRaw(-pi, phi0)[0],
+      y0 = healpixLambert(0, phi0)[1],
+      y1 = collignonRaw(0, phi0)[1],
+      dy1 = sqrtPi - y1,
+      k = tau / H,
+      w = 4 / tau,
+      h = y0 + (dy1 * dy1 * 4) / tau;
+
+  function forward(lambda, phi) {
+    var point,
+        phi2 = abs(phi);
+    if (phi2 > phi0) {
+      var i = min(H - 1, max(0, floor((lambda + pi) / k)));
+      lambda += pi * (H - 1) / H - i * k;
+      point = collignonRaw(lambda, phi2);
+      point[0] = point[0] * tau / dx - tau * (H - 1) / (2 * H) + i * tau / H;
+      point[1] = y0 + (point[1] - y1) * 4 * dy1 / tau;
+      if (phi < 0) point[1] = -point[1];
+    } else {
+      point = healpixLambert(lambda, phi);
+    }
+    point[0] *= w, point[1] /= h;
+    return point;
+  }
+
+  forward.invert = function(x, y) {
+    x /= w, y *= h;
+    var y2 = abs(y);
+    if (y2 > y0) {
+      var i = min(H - 1, max(0, floor((x + pi) / k)));
+      x = (x + pi * (H - 1) / H - i * k) * dx / tau;
+      var point = collignonRaw.invert(x, 0.25 * (y2 - y0) * tau / dy1 + y1);
+      point[0] -= pi * (H - 1) / H - i * k;
+      if (y < 0) point[1] = -point[1];
+      return point;
+    }
+    return healpixLambert.invert(x, y);
+  };
+
+  return forward;
+}
+
+function sphereTop(x, i) {
+  return [x, i & 1 ? 90 - epsilon : healpixParallel];
+}
+
+function sphereBottom(x, i) {
+  return [x, i & 1 ? -90 + epsilon : -healpixParallel];
+}
+
+function sphereNudge(d) {
+  return [d[0] * (1 - epsilon), d[1]];
+}
+
+function sphere(step) {
+  var c = [].concat(
+    range(-180, 180 + step / 2, step).map(sphereTop),
+    range(180, -180 - step / 2, -step).map(sphereBottom)
+  );
+  return {
+    type: "Polygon",
+    coordinates: [step === 180 ? c.map(sphereNudge) : c]
+  };
+}
+
+export default function() {
+  var H = 4,
+      m = projectionMutator(healpixRaw),
+      p = m(H),
+      stream_ = p.stream;
+
+  p.lobes = function(_) {
+    return arguments.length ? m(H = +_) : H;
+  };
+
+  p.stream = function(stream) {
+    var rotate = p.rotate(),
+        rotateStream = stream_(stream),
+        sphereStream = (p.rotate([0, 0]), stream_(stream));
+    p.rotate(rotate);
+    rotateStream.sphere = function() { geoStream(sphere(180 / H), sphereStream); };
+    return rotateStream;
+  };
+
+  return p
+      .scale(239.75);
+}

node_modules/d3-geo-projection/src/hill.js

@@ -0,0 +1,66 @@
+import {geoProjectionMutator as projectionMutator} from "d3-geo";
+import {abs, acos, asin, atan2, cos, epsilon2, halfPi, pi, sin, sqrt} from "./math.js";
+
+export function hillRaw(K) {
+  var L = 1 + K,
+      sinBt = sin(1 / L),
+      Bt = asin(sinBt),
+      A = 2 * sqrt(pi / (B = pi + 4 * Bt * L)),
+      B,
+      rho0 = 0.5 * A * (L + sqrt(K * (2 + K))),
+      K2 = K * K,
+      L2 = L * L;
+
+  function forward(lambda, phi) {
+    var t = 1 - sin(phi),
+        rho,
+        omega;
+    if (t && t < 2) {
+      var theta = halfPi - phi, i = 25, delta;
+      do {
+        var sinTheta = sin(theta),
+            cosTheta = cos(theta),
+            Bt_Bt1 = Bt + atan2(sinTheta, L - cosTheta),
+            C = 1 + L2 - 2 * L * cosTheta;
+        theta -= delta = (theta - K2 * Bt - L * sinTheta + C * Bt_Bt1 -0.5 * t * B) / (2 * L * sinTheta * Bt_Bt1);
+      } while (abs(delta) > epsilon2 && --i > 0);
+      rho = A * sqrt(C);
+      omega = lambda * Bt_Bt1 / pi;
+    } else {
+      rho = A * (K + t);
+      omega = lambda * Bt / pi;
+    }
+    return [
+      rho * sin(omega),
+      rho0 - rho * cos(omega)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var rho2 = x * x + (y -= rho0) * y,
+        cosTheta = (1 + L2 - rho2 / (A * A)) / (2 * L),
+        theta = acos(cosTheta),
+        sinTheta = sin(theta),
+        Bt_Bt1 = Bt + atan2(sinTheta, L - cosTheta);
+    return [
+      asin(x / sqrt(rho2)) * pi / Bt_Bt1,
+      asin(1 - 2 * (theta - K2 * Bt - L * sinTheta + (1 + L2 - 2 * L * cosTheta) * Bt_Bt1) / B)
+    ];
+  };
+
+  return forward;
+}
+
+export default function() {
+  var K = 1,
+      m = projectionMutator(hillRaw),
+      p = m(K);
+
+  p.ratio = function(_) {
+    return arguments.length ? m(K = +_) : K;
+  };
+
+  return p
+      .scale(167.774)
+      .center([0, 18.67]);
+}

node_modules/d3-geo-projection/src/homolosine.js

@@ -0,0 +1,22 @@
+import {geoProjection as projection} from "d3-geo";
+import {abs} from "./math.js";
+import {mollweideRaw} from "./mollweide.js";
+import {sinusoidalRaw} from "./sinusoidal.js";
+import {sinuMollweidePhi, sinuMollweideY} from "./sinuMollweide.js";
+
+export function homolosineRaw(lambda, phi) {
+  return abs(phi) > sinuMollweidePhi
+      ? (lambda = mollweideRaw(lambda, phi), lambda[1] -= phi > 0 ? sinuMollweideY : -sinuMollweideY, lambda)
+      : sinusoidalRaw(lambda, phi);
+}
+
+homolosineRaw.invert = function(x, y) {
+  return abs(y) > sinuMollweidePhi
+      ? mollweideRaw.invert(x, y + (y > 0 ? sinuMollweideY : -sinuMollweideY))
+      : sinusoidalRaw.invert(x, y);
+};
+
+export default function() {
+  return projection(homolosineRaw)
+      .scale(152.63);
+}

node_modules/d3-geo-projection/src/hufnagel.js

@@ -0,0 +1,91 @@
+import { geoProjectionMutator as projectionMutator } from "d3-geo";
+import { asin, cos, degrees, pi, radians, sign, sin, sqrt } from "./math.js";
+import { solve } from "./newton.js";
+
+export function hufnagelRaw(a, b, psiMax, ratio) {
+  var k = sqrt(
+      (4 * pi) /
+        (2 * psiMax +
+          (1 + a - b / 2) * sin(2 * psiMax) +
+          ((a + b) / 2) * sin(4 * psiMax) +
+          (b / 2) * sin(6 * psiMax))
+    ),
+    c = sqrt(
+      ratio *
+        sin(psiMax) *
+        sqrt((1 + a * cos(2 * psiMax) + b * cos(4 * psiMax)) / (1 + a + b))
+    ),
+    M = psiMax * mapping(1);
+
+  function radius(psi) {
+    return sqrt(1 + a * cos(2 * psi) + b * cos(4 * psi));
+  }
+
+  function mapping(t) {
+    var psi = t * psiMax;
+    return (
+      (2 * psi +
+        (1 + a - b / 2) * sin(2 * psi) +
+        ((a + b) / 2) * sin(4 * psi) +
+        (b / 2) * sin(6 * psi)) /
+      psiMax
+    );
+  }
+
+  function inversemapping(psi) {
+    return radius(psi) * sin(psi);
+  }
+
+  var forward = function(lambda, phi) {
+    var psi = psiMax * solve(mapping, (M * sin(phi)) / psiMax, phi / pi);
+    if (isNaN(psi)) psi = psiMax * sign(phi);
+    var kr = k * radius(psi);
+    return [((kr * c * lambda) / pi) * cos(psi), (kr / c) * sin(psi)];
+  };
+
+  forward.invert = function(x, y) {
+    var psi = solve(inversemapping, (y * c) / k);
+    return [
+      (x * pi) / (cos(psi) * k * c * radius(psi)),
+      asin((psiMax * mapping(psi / psiMax)) / M)
+    ];
+  };
+
+  if (psiMax === 0) {
+    k = sqrt(ratio / pi);
+    forward = function(lambda, phi) {
+      return [lambda * k, sin(phi) / k];
+    };
+    forward.invert = function(x, y) {
+      return [x / k, asin(y * k)];
+    };
+  }
+
+  return forward;
+}
+
+export default function() {
+  var a = 1,
+    b = 0,
+    psiMax = 45 * radians,
+    ratio = 2,
+    mutate = projectionMutator(hufnagelRaw),
+    projection = mutate(a, b, psiMax, ratio);
+
+  projection.a = function(_) {
+    return arguments.length ? mutate((a = +_), b, psiMax, ratio) : a;
+  };
+  projection.b = function(_) {
+    return arguments.length ? mutate(a, (b = +_), psiMax, ratio) : b;
+  };
+  projection.psiMax = function(_) {
+    return arguments.length
+      ? mutate(a, b, (psiMax = +_ * radians), ratio)
+      : psiMax * degrees;
+  };
+  projection.ratio = function(_) {
+    return arguments.length ? mutate(a, b, psiMax, (ratio = +_)) : ratio;
+  };
+
+  return projection.scale(180.739);
+}

node_modules/d3-geo-projection/src/hyperelliptical.js

@@ -0,0 +1,73 @@
+import {geoProjectionMutator as projectionMutator} from "d3-geo";
+import {abs, asin, pi, pow, sign, sin} from "./math.js";
+import {integrate} from "./integrate.js";
+
+export function hyperellipticalRaw(alpha, k, gamma) {
+
+  function elliptic (f) {
+    return alpha + (1 - alpha) * pow(1 - pow(f, k), 1 / k);
+  }
+
+  function z(f) {
+    return integrate(elliptic, 0, f, 1e-4);
+  }
+
+  var G = 1 / z(1),
+      n = 1000,
+      m = (1 + 1e-8) * G,
+      approx = [];
+  for (var i = 0; i <= n; i++)
+      approx.push(z(i / n) * m);
+
+  function Y(sinphi) {
+    var rmin = 0, rmax = n, r = n >> 1;
+    do {
+      if (approx[r] > sinphi) rmax = r; else rmin = r;
+      r = (rmin + rmax) >> 1;
+    } while (r > rmin);
+    var u = approx[r + 1] - approx[r];
+    if (u) u = (sinphi - approx[r + 1]) / u;
+    return (r + 1 + u) / n;
+  }
+
+  var ratio = 2 * Y(1) / pi * G / gamma;
+
+  var forward = function(lambda, phi) {
+    var y = Y(abs(sin(phi))),
+        x = elliptic(y) * lambda;
+    y /= ratio;
+    return [ x, (phi >= 0) ? y : -y ];
+  };
+
+  forward.invert = function(x, y) {
+    var phi;
+    y *= ratio;
+    if (abs(y) < 1) phi = sign(y) * asin(z(abs(y)) * G);
+    return [ x / elliptic(abs(y)), phi ];
+  };
+
+  return forward;
+}
+
+export default function() {
+  var alpha = 0,
+      k = 2.5,
+      gamma = 1.183136, // affine = sqrt(2 * gamma / pi) = 0.8679
+      m = projectionMutator(hyperellipticalRaw),
+      p = m(alpha, k, gamma);
+
+  p.alpha = function(_) {
+    return arguments.length ? m(alpha = +_, k, gamma) : alpha;
+  };
+
+  p.k = function(_) {
+    return arguments.length ? m(alpha, k = +_, gamma) : k;
+  };
+
+  p.gamma = function(_) {
+    return arguments.length ? m(alpha, k, gamma = +_) : gamma;
+  };
+
+  return p
+      .scale(152.63);
+}

node_modules/d3-geo-projection/src/index.js

@@ -0,0 +1,97 @@
+export {default as geoAiry, airyRaw as geoAiryRaw} from "./airy";
+export {default as geoAitoff, aitoffRaw as geoAitoffRaw} from "./aitoff";
+export {default as geoArmadillo, armadilloRaw as geoArmadilloRaw} from "./armadillo";
+export {default as geoAugust, augustRaw as geoAugustRaw} from "./august";
+export {default as geoBaker, bakerRaw as geoBakerRaw} from "./baker";
+export {default as geoBerghaus, berghausRaw as geoBerghausRaw} from "./berghaus";
+export {default as geoBertin1953, bertin1953Raw as geoBertin1953Raw} from "./bertin";
+export {default as geoBoggs, boggsRaw as geoBoggsRaw} from "./boggs";
+export {default as geoBonne, bonneRaw as geoBonneRaw} from "./bonne";
+export {default as geoBottomley, bottomleyRaw as geoBottomleyRaw} from "./bottomley";
+export {default as geoBromley, bromleyRaw as geoBromleyRaw} from "./bromley";
+export {default as geoChamberlin, chamberlinRaw as geoChamberlinRaw, chamberlinAfrica as geoChamberlinAfrica} from "./chamberlin";
+export {default as geoCollignon, collignonRaw as geoCollignonRaw} from "./collignon";
+export {default as geoCraig, craigRaw as geoCraigRaw} from "./craig";
+export {default as geoCraster, crasterRaw as geoCrasterRaw} from "./craster";
+export {default as geoCylindricalEqualArea, cylindricalEqualAreaRaw as geoCylindricalEqualAreaRaw} from "./cylindricalEqualArea";
+export {default as geoCylindricalStereographic, cylindricalStereographicRaw as geoCylindricalStereographicRaw} from "./cylindricalStereographic";
+export {default as geoEckert1, eckert1Raw as geoEckert1Raw} from "./eckert1.js";
+export {default as geoEckert2, eckert2Raw as geoEckert2Raw} from "./eckert2.js";
+export {default as geoEckert3, eckert3Raw as geoEckert3Raw} from "./eckert3.js";
+export {default as geoEckert4, eckert4Raw as geoEckert4Raw} from "./eckert4.js";
+export {default as geoEckert5, eckert5Raw as geoEckert5Raw} from "./eckert5.js";
+export {default as geoEckert6, eckert6Raw as geoEckert6Raw} from "./eckert6.js";
+export {default as geoEisenlohr, eisenlohrRaw as geoEisenlohrRaw} from "./eisenlohr.js";
+export {default as geoFahey, faheyRaw as geoFaheyRaw} from "./fahey.js";
+export {default as geoFoucaut, foucautRaw as geoFoucautRaw} from "./foucaut.js";
+export {default as geoFoucautSinusoidal, foucautSinusoidalRaw as geoFoucautSinusoidalRaw} from "./foucautSinusoidal.js";
+export {default as geoGilbert} from "./gilbert.js";
+export {default as geoGingery, gingeryRaw as geoGingeryRaw} from "./gingery.js";
+export {default as geoGinzburg4, ginzburg4Raw as geoGinzburg4Raw} from "./ginzburg4.js";
+export {default as geoGinzburg5, ginzburg5Raw as geoGinzburg5Raw} from "./ginzburg5.js";
+export {default as geoGinzburg6, ginzburg6Raw as geoGinzburg6Raw} from "./ginzburg6.js";
+export {default as geoGinzburg8, ginzburg8Raw as geoGinzburg8Raw} from "./ginzburg8.js";
+export {default as geoGinzburg9, ginzburg9Raw as geoGinzburg9Raw} from "./ginzburg9.js";
+export {default as geoGringorten, gringortenRaw as geoGringortenRaw} from "./gringorten.js";
+export {default as geoGuyou, guyouRaw as geoGuyouRaw} from "./guyou.js";
+export {default as geoHammer, hammerRaw as geoHammerRaw} from "./hammer.js";
+export {default as geoHammerRetroazimuthal, hammerRetroazimuthalRaw as geoHammerRetroazimuthalRaw} from "./hammerRetroazimuthal.js";
+export {default as geoHealpix, healpixRaw as geoHealpixRaw} from "./healpix.js";
+export {default as geoHill, hillRaw as geoHillRaw} from "./hill.js";
+export {default as geoHomolosine, homolosineRaw as geoHomolosineRaw} from "./homolosine.js";
+export {default as geoHufnagel, hufnagelRaw as geoHufnagelRaw} from "./hufnagel.js";
+export {default as geoHyperelliptical, hyperellipticalRaw as geoHyperellipticalRaw} from "./hyperelliptical";
+export {default as geoInterrupt} from "./interrupted/index";
+export {default as geoInterruptedBoggs} from "./interrupted/boggs";
+export {default as geoInterruptedHomolosine} from "./interrupted/homolosine";
+export {default as geoInterruptedMollweide} from "./interrupted/mollweide";
+export {default as geoInterruptedMollweideHemispheres} from "./interrupted/mollweideHemispheres";
+export {default as geoInterruptedSinuMollweide} from "./interrupted/sinuMollweide";
+export {default as geoInterruptedSinusoidal} from "./interrupted/sinusoidal";
+export {default as geoKavrayskiy7, kavrayskiy7Raw as geoKavrayskiy7Raw} from "./kavrayskiy7.js";
+export {default as geoLagrange, lagrangeRaw as geoLagrangeRaw} from "./lagrange.js";
+export {default as geoLarrivee, larriveeRaw as geoLarriveeRaw} from "./larrivee";
+export {default as geoLaskowski, laskowskiRaw as geoLaskowskiRaw} from "./laskowski";
+export {default as geoLittrow, littrowRaw as geoLittrowRaw} from "./littrow.js";
+export {default as geoLoximuthal, loximuthalRaw as geoLoximuthalRaw} from "./loximuthal.js";
+export {default as geoMiller, millerRaw as geoMillerRaw} from "./miller";
+export {default as geoModifiedStereographic, modifiedStereographicRaw as geoModifiedStereographicRaw, modifiedStereographicAlaska as geoModifiedStereographicAlaska, modifiedStereographicGs48 as geoModifiedStereographicGs48, modifiedStereographicGs50 as geoModifiedStereographicGs50, modifiedStereographicMiller as geoModifiedStereographicMiller, modifiedStereographicLee as geoModifiedStereographicLee} from "./modifiedStereographic";
+export {default as geoMollweide, mollweideRaw as geoMollweideRaw} from "./mollweide";
+export {default as geoMtFlatPolarParabolic, mtFlatPolarParabolicRaw as geoMtFlatPolarParabolicRaw} from "./mtFlatPolarParabolic";
+export {default as geoMtFlatPolarQuartic, mtFlatPolarQuarticRaw as geoMtFlatPolarQuarticRaw} from "./mtFlatPolarQuartic";
+export {default as geoMtFlatPolarSinusoidal, mtFlatPolarSinusoidalRaw as geoMtFlatPolarSinusoidalRaw} from "./mtFlatPolarSinusoidal";
+export {geoNaturalEarth1 as geoNaturalEarth, geoNaturalEarth1Raw as geoNaturalEarthRaw} from "d3-geo"; // DEPRECATED moved to d3-geo
+export {default as geoNaturalEarth2, naturalEarth2Raw as geoNaturalEarth2Raw} from "./naturalEarth2";
+export {default as geoNellHammer, nellHammerRaw as geoNellHammerRaw} from "./nellHammer";
+export {default as geoInterruptedQuarticAuthalic} from "./interrupted/quarticAuthalic";
+export {default as geoNicolosi, nicolosiRaw as geoNicolosiRaw} from "./nicolosi";
+export {default as geoPatterson, pattersonRaw as geoPattersonRaw} from "./patterson";
+export {default as geoPolyconic, polyconicRaw as geoPolyconicRaw} from "./polyconic";
+export {default as geoPolyhedral} from "./polyhedral/index.js";
+export {default as geoPolyhedralButterfly} from "./polyhedral/butterfly.js";
+export {default as geoPolyhedralCollignon} from "./polyhedral/collignon.js";
+export {default as geoPolyhedralWaterman} from "./polyhedral/waterman.js";
+export {default as geoProject} from "./project/index";
+export {default as geoGringortenQuincuncial} from "./quincuncial/gringorten.js";
+export {default as geoPeirceQuincuncial} from "./quincuncial/peirce.js";
+export {default as geoPierceQuincuncial} from "./quincuncial/peirce.js"; // DEPRECATED misspelling
+export {default as geoQuantize} from "./quantize";
+export {default as geoQuincuncial} from "./quincuncial/index.js";
+export {default as geoRectangularPolyconic, rectangularPolyconicRaw as geoRectangularPolyconicRaw} from "./rectangularPolyconic";
+export {default as geoRobinson, robinsonRaw as geoRobinsonRaw} from "./robinson";
+export {default as geoSatellite, satelliteRaw as geoSatelliteRaw} from "./satellite";
+export {default as geoSinuMollweide, sinuMollweideRaw as geoSinuMollweideRaw} from "./sinuMollweide";
+export {default as geoSinusoidal, sinusoidalRaw as geoSinusoidalRaw} from "./sinusoidal";
+export {default as geoStitch} from "./stitch";
+export {default as geoTimes, timesRaw as geoTimesRaw} from "./times";
+export {default as geoTwoPointAzimuthal, twoPointAzimuthalRaw as geoTwoPointAzimuthalRaw, twoPointAzimuthalUsa as geoTwoPointAzimuthalUsa} from "./twoPointAzimuthal";
+export {default as geoTwoPointEquidistant, twoPointEquidistantRaw as geoTwoPointEquidistantRaw, twoPointEquidistantUsa as geoTwoPointEquidistantUsa} from "./twoPointEquidistant";
+export {default as geoVanDerGrinten, vanDerGrintenRaw as geoVanDerGrintenRaw} from "./vanDerGrinten";
+export {default as geoVanDerGrinten2, vanDerGrinten2Raw as geoVanDerGrinten2Raw} from "./vanDerGrinten2";
+export {default as geoVanDerGrinten3, vanDerGrinten3Raw as geoVanDerGrinten3Raw} from "./vanDerGrinten3";
+export {default as geoVanDerGrinten4, vanDerGrinten4Raw as geoVanDerGrinten4Raw} from "./vanDerGrinten4";
+export {default as geoWagner, wagner7 as geoWagner7, wagnerRaw as geoWagnerRaw} from "./wagner.js";
+export {default as geoWagner4, wagner4Raw as geoWagner4Raw} from "./wagner4.js";
+export {default as geoWagner6, wagner6Raw as geoWagner6Raw} from "./wagner6.js";
+export {default as geoWiechel, wiechelRaw as geoWiechelRaw} from "./wiechel.js";
+export {default as geoWinkel3, winkel3Raw as geoWinkel3Raw} from "./winkel3";