github login

dashboard/src/components/values-form/RangeSlider.tsx

@@ -0,0 +1,74 @@
+import React, { ChangeEvent, Component } from "react";
+import Slider from '@material-ui/core/Slider';
+import styled from "styled-components";
+
+type PropsType = {
+};
+
+type StateType = {
+};
+
+export default class RangeSelector extends Component<PropsType, StateType> {
+  state = {
+  };
+
+  render() {
+    return (
+      <StyledInputRow>
+        <Label>
+          asdfasdf
+        </Label>
+        <Slider
+          value={12}
+          onChange={() => console.log('huh')}
+          valueLabelDisplay="auto"
+          aria-labelledby="range-slider"
+        />
+      </StyledInputRow>
+    );
+  }
+}
+
+const Required = styled.div`
+  margin-left: 8px;
+  color: #fc4976;
+`;
+
+const Unit = styled.div`
+  margin-left: 8px;
+`;
+
+const InputWrapper = styled.div`
+  display: flex;
+  margin-bottom: -1px;
+  align-items: center;
+`;
+
+const Input = styled.input`
+  outline: none;
+  border: none;
+  font-size: 13px;
+  background: #ffffff11;
+  border: 1px solid #ffffff55;
+  border-radius: 3px;
+  width: ${(props: { disabled: boolean; width: string }) =>
+    props.width ? props.width : "270px"};
+  color: ${(props: { disabled: boolean; width: string }) =>
+    props.disabled ? "#ffffff44" : "white"};
+  padding: 5px 10px;
+  height: 35px;
+`;
+
+const Label = styled.div`
+  color: #ffffff;
+  margin-bottom: 10px;
+  display: flex;
+  align-items: center;
+  font-size: 13px;
+  font-family: "Work Sans", sans-serif;
+`;
+
+const StyledInputRow = styled.div`
+  margin-bottom: 15px;
+  margin-top: 20px;
+`;

dashboard/src/main/Main.tsx

@@ -127,10 +127,8 @@ export default class Main extends Component<PropsType, StateType> {
           render={() => {
             if (this.state.isLoggedIn) {
               return <Redirect to="/dashboard" />;
-            } else if (this.state.initialized) {
-              return <Redirect to="/login" />;
             } else {
-              return <Redirect to="/register" />;
+              return <Redirect to="/login" />;
             }
           }}
         />

dashboard/src/main/Register.tsx

@@ -275,7 +275,7 @@ const Prompt = styled.div`
 const Logo = styled.img`
   width: 140px;
   margin-top: 50px;
-  margin-bottom: 55px;
+  margin-bottom: 60px;
   user-select: none;
 `;
 

dashboard/src/main/home/cluster-dashboard/expanded-chart/ExpandedChart.tsx

@@ -22,6 +22,7 @@ import ValuesForm from "components/values-form/ValuesForm";
 import RevisionSection from "./RevisionSection";
 import ValuesYaml from "./ValuesYaml";
 import GraphSection from "./GraphSection";
+import MetricsSection from "./MetricsSection";
 import ListSection from "./ListSection";
 import StatusSection from "./status/StatusSection";
 import SettingsSection from "./SettingsSection";
@@ -280,6 +281,8 @@ export default class ExpandedChart extends Component<PropsType, StateType> {
     let chart = currentChart;
 
     switch (currentTab) {
+      case "metrics":
+        return <MetricsSection currentChart={chart} />;
       case "status":
         return <StatusSection currentChart={chart} selectors={podSelectors} />;
       case "settings":
@@ -365,6 +368,7 @@ export default class ExpandedChart extends Component<PropsType, StateType> {
     // Append universal tabs
     tabOptions.push(
       { label: "Status", value: "status" },
+      // { label: "Metrics", value: "metrics" },
       { label: "Chart Overview", value: "graph" }
     );
 

dashboard/src/main/home/cluster-dashboard/expanded-chart/GraphSection.tsx

@@ -51,4 +51,6 @@ const StyledGraphSection = styled.div`
   height: 100%;
   background: #ffffff11;
   font-size: 13px;
+  border-radius: 5px;
+  overflow: hidden;
 `;

dashboard/src/main/home/cluster-dashboard/expanded-chart/MetricsSection.tsx

@@ -0,0 +1,43 @@
+import React, { Component } from "react";
+import styled from "styled-components";
+import yaml from "js-yaml";
+
+import { Context } from "shared/Context";
+import { ResourceType, ChartType } from "shared/types";
+
+import Loading from "components/Loading";
+import ResourceTab from "components/ResourceTab";
+import YamlEditor from "components/YamlEditor";
+
+type PropsType = {
+  currentChart: ChartType;
+};
+
+type StateType = {
+};
+
+export default class ListSection extends Component<PropsType, StateType> {
+  state = {
+  }
+
+  render() {
+    return (
+      <StyledMetricsSection>
+
+      </StyledMetricsSection>
+    );
+  }
+}
+
+ListSection.contextType = Context;
+
+const StyledMetricsSection = styled.div`
+  width: 100%;
+  height: 100%;
+  background: #20222700;
+  display: flex;
+  position: relative;
+  font-size: 13px;
+  border-radius: 5px;
+  overflow: hidden;
+`;

node_modules/.bin/csv2json

@@ -0,0 +1 @@
+../d3-dsv/bin/dsv2json

node_modules/.bin/csv2tsv

@@ -0,0 +1 @@
+../d3-dsv/bin/dsv2dsv

node_modules/.bin/dsv2dsv

@@ -0,0 +1 @@
+../d3-dsv/bin/dsv2dsv

node_modules/.bin/dsv2json

@@ -0,0 +1 @@
+../d3-dsv/bin/dsv2json

node_modules/.bin/json2csv

@@ -0,0 +1 @@
+../d3-dsv/bin/json2dsv

node_modules/.bin/json2dsv

@@ -0,0 +1 @@
+../d3-dsv/bin/json2dsv

node_modules/.bin/json2tsv

@@ -0,0 +1 @@
+../d3-dsv/bin/json2dsv

node_modules/.bin/tsv2csv

@@ -0,0 +1 @@
+../d3-dsv/bin/dsv2dsv

node_modules/.bin/tsv2json

@@ -0,0 +1 @@
+../d3-dsv/bin/dsv2json

node_modules/@types/d3-array/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-array/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-array`
+
+# Summary
+This package contains type definitions for D3JS d3-array module (https://github.com/d3/d3-array).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-array.
+
+### Additional Details
+ * Last updated: Mon, 25 Jan 2021 20:28:35 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [Tom Wanzek](https://github.com/tomwanzek), [denisname](https://github.com/denisname), [Hugues Stefanski](https://github.com/ledragon), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-array/index.d.ts

@@ -0,0 +1,1077 @@
+// Type definitions for D3JS d3-array module 2.9
+// Project: https://github.com/d3/d3-array, https://d3js.org/d3-array
+// Definitions by: Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 Tom Wanzek <https://github.com/tomwanzek>
+//                 denisname <https://github.com/denisname>
+//                 Hugues Stefanski <https://github.com/ledragon>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Last module patch version validated against: 2.9.1
+
+// --------------------------------------------------------------------------
+// Shared Types and Interfaces
+// --------------------------------------------------------------------------
+
+/**
+ * Administrivia: JavaScript primitive types and Date
+ */
+export type Primitive = number | string | boolean | Date;
+
+/**
+ * Administrivia: anything with a valueOf(): number method is comparable, so we allow it in numeric operations
+ */
+export interface Numeric {
+    valueOf(): number;
+}
+
+// --------------------------------------------------------------------------------------
+// Statistics
+// --------------------------------------------------------------------------------------
+
+/**
+ * Return the minimum value in the array using natural order.
+ */
+export function min(iterable: Iterable<string>): string | undefined;
+
+/**
+ * Return the minimum value in the array using natural order.
+ */
+export function min<T extends Numeric>(iterable: Iterable<T>): T | undefined;
+/**
+ * Return the minimum value in the array using natural order.
+ */
+export function min<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null
+): string | undefined;
+/**
+ * Return the minimum value in the array using natural order.
+ */
+export function min<T, U extends Numeric>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null
+): U | undefined;
+
+/**
+ * Return the index of the minimum value in the array using natural order.
+ */
+export function minIndex<T>(iterable: Iterable<T>): number;
+/**
+ * Return the index of the minimum value in the array using natural order and a projection function to map values.
+ */
+export function minIndex<TDatum, U>(
+    iterable: Iterable<TDatum>,
+    accessor: (datum: TDatum, index: number, array: Iterable<TDatum>) => U | undefined | null
+): number;
+/**
+ * Return the index of the minimum value in the array using natural order.
+ */
+export function minIndex<T>(iterable: Iterable<T>): number;
+
+/**
+ * Return the maximum value in the array of strings using natural order.
+ */
+export function max(iterable: Iterable<string>): string | undefined;
+/**
+ * Return the maximum value in the array of numbers using natural order.
+ */
+export function max<T extends Numeric>(iterable: Iterable<T>): T | undefined;
+/**
+ * Return the maximum value in the array using natural order and a projection function to map values to strings.
+ */
+export function max<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null
+): string | undefined;
+/**
+ * Return the maximum value in the array using natural order and a projection function to map values to easily-sorted values.
+ */
+export function max<T, U extends Numeric>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null
+): U | undefined;
+
+/**
+ * Return the index of the maximum value in the array using natural order.
+ */
+export function maxIndex<T>(iterable: Iterable<T>): number;
+/**
+ * Return the index of the maximum value in the array using natural order and a projection function to map values.
+ */
+export function maxIndex<TDatum, U>(
+    iterable: Iterable<TDatum>,
+    accessor: (datum: TDatum, index: number, array: Iterable<TDatum>) => U | undefined | null
+): number;
+
+/**
+ * Return the min and max simultaneously.
+ */
+export function extent(iterable: Iterable<string>): [string, string] | [undefined, undefined];
+/**
+ * Return the min and max simultaneously.
+ */
+export function extent<T extends Numeric>(iterable: Iterable<T>): [T, T] | [undefined, undefined];
+/**
+ * Return the min and max simultaneously.
+ */
+export function extent<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => string | undefined | null
+): [string, string] | [undefined, undefined];
+/**
+ * Return the min and max simultaneously.
+ */
+export function extent<T, U extends Numeric>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => U | undefined | null
+): [U, U] | [undefined, undefined];
+
+/**
+ * Compute the sum of an array of numbers.
+ */
+export function sum<T extends Numeric>(iterable: Iterable<T | undefined | null>): number;
+/**
+ * Compute the sum of an array, using the given accessor to convert values to numbers.
+ */
+export function sum<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null
+): number;
+
+/**
+ * Return the mean of an array of numbers
+ */
+export function mean<T extends Numeric>(iterable: Iterable<T | undefined | null>): number | undefined;
+/**
+ * Return the mean of an array of numbers
+ */
+export function mean<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null
+): number | undefined;
+
+/**
+ * Return the median of an array of numbers
+ */
+export function median<T extends Numeric>(iterable: Iterable<T | undefined | null>): number | undefined;
+/**
+ * Return the median of an array of numbers
+ */
+export function median<T>(
+    iterable: Iterable<T>,
+    accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null
+): number | undefined;
+
+/**
+ * Returns the cumulative sum of the given iterable of numbers, as a Float64Array of the same length.
+ * If the iterable contains no numbers, returns zeros.
+ * An optional accessor function may be specified, which is equivalent to calling Array.from before computing the cumulative sum.
+ * This method ignores undefined and NaN values; this is useful for ignoring missing data.
+ */
+export function cumsum<T extends Numeric>(iterable: Iterable<T | undefined | null>): Float64Array;
+/**
+ * Returns the cumulative sum of the given iterable of numbers, as a Float64Array of the same length.
+ * If the iterable contains no numbers, returns zeros.
+ * An optional accessor function may be specified, which is equivalent to calling Array.from before computing the cumulative sum.
+ * This method ignores undefined and NaN values; this is useful for ignoring missing data.
+ */
+export function cumsum<T>(
+    iterable: Iterable<T>,
+    accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null
+): Float64Array;
+
+/**
+ * Returns the p-quantile of the given iterable of numbers, where p is a number in the range [0, 1].
+ *
+ * An optional accessor function may be specified, which is equivalent to calling array.map(accessor) before computing the quantile.
+ */
+export function quantile<T extends Numeric>(iterable: Iterable<T | undefined | null>, p: number): number | undefined;
+/**
+ * Returns the p-quantile of the given iterable of numbers, where p is a number in the range [0, 1].
+ *
+ * An optional accessor function may be specified, which is equivalent to calling array.map(accessor) before computing the quantile.
+ */
+export function quantile<T>(
+    iterable: Iterable<T>,
+    p: number,
+    accessor: (element: T, i: number, array: Iterable<T>) => number | undefined | null
+): number | undefined;
+
+/**
+ * Similar to quantile, but expects the input to be a sorted array of values.
+ * In contrast with quantile, the accessor is only called on the elements needed to compute the quantile.
+ */
+export function quantileSorted<T extends Numeric>(
+    array: Array<T | undefined | null>,
+    p: number
+): number | undefined;
+/**
+ * Similar to quantile, but expects the input to be a sorted array of values.
+ * In contrast with quantile, the accessor is only called on the elements needed to compute the quantile.
+ */
+export function quantileSorted<T>(
+    array: T[],
+    p: number,
+    accessor: (element: T, i: number, array: T[]) => number | undefined | null
+): number | undefined;
+
+/**
+ * Returns an unbiased estimator of the population variance of the given iterable of numbers using Welford’s algorithm.
+ * If the iterable has fewer than two numbers, returns undefined.
+ * An optional accessor function may be specified, which is equivalent to calling Array.from before computing the variance.
+ * This method ignores undefined and NaN values; this is useful for ignoring missing data.
+ */
+export function variance<T extends Numeric>(iterable: Iterable<T | undefined | null>): number | undefined;
+/**
+ * Returns an unbiased estimator of the population variance of the given iterable of numbers using Welford’s algorithm.
+ * If the iterable has fewer than two numbers, returns undefined.
+ * An optional accessor function may be specified, which is equivalent to calling Array.from before computing the variance.
+ * This method ignores undefined and NaN values; this is useful for ignoring missing data.
+ */
+export function variance<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null
+): number | undefined;
+
+/**
+ * Compute the standard deviation, defined as the square root of the bias-corrected variance, of the given array of numbers.
+ */
+export function deviation<T extends Numeric>(iterable: Iterable<T | undefined | null>): number | undefined;
+/**
+ * Compute the standard deviation, defined as the square root of the bias-corrected variance, of the given array,
+ * using the given accessor to convert values to numbers.
+ */
+export function deviation<T>(
+    iterable: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null
+): number | undefined;
+
+/**
+ * Returns a full precision summation of the given values.
+ * Although slower, d3.fsum can replace d3.sum wherever greater precision is needed. Uses d3.Adder.
+ */
+export function fsum<T extends Numeric>(values: Iterable<T | undefined | null>): number;
+/**
+ * Returns a full precision summation of the given values.
+ * Although slower, d3.fsum can replace d3.sum wherever greater precision is needed. Uses d3.Adder.
+ */
+export function fsum<T>(
+    values: Iterable<T>,
+    accessor: (datum: T, index: number, array: Iterable<T>) => number | undefined | null
+): number;
+
+export class Adder {
+    /**
+     * Creates a full precision adder for IEEE 754 floating point numbers, setting its initial value to 0.
+     */
+    constructor();
+
+    /**
+     * Adds the specified number to the adder’s current value and returns the adder.
+     */
+    add(number: number): Adder;
+
+    /**
+     * Returns the IEEE 754 double precision representation of the adder’s current value.
+     * Most useful as the short-hand notation +adder.
+     */
+    valueOf(): number;
+}
+
+// --------------------------------------------------------------------------------------
+// Search
+// --------------------------------------------------------------------------------------
+
+/**
+ * Returns the least element of the specified iterable.
+ */
+export function least<T>(iterable: Iterable<T>): T | undefined;
+/**
+ * Returns the least element of the specified iterable according to the specified comparator.
+ */
+export function least<T>(iterable: Iterable<T>, comparator: (a: T, b: T) => number): T | undefined;
+/**
+ * Returns the least element of the specified iterable according to the specified accessor.
+ */
+export function least<T, U>(iterable: Iterable<T>, accessor: (a: T) => U): T | undefined;
+
+/**
+ * Returns the index of the least element of the specified iterable according to the specified comparator.
+ */
+export function leastIndex<T>(iterable: Iterable<T>): number | undefined;
+/**
+ * Returns the index of the least element of the specified iterable according to the specified comparator.
+ */
+export function leastIndex<T>(iterable: Iterable<T>, comparator: (a: T, b: T) => number): number | undefined;
+/**
+ * Returns the index of the least element of the specified iterable according to the specified accessor.
+ */
+export function leastIndex<T, U>(iterable: Iterable<T>, accessor: (a: T) => U): number | undefined;
+
+/**
+ * Returns the greatest element of the specified iterable according to the specified comparator or accessor.
+ * If the given iterable 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.
+ */
+export function greatest<T>(iterable: Iterable<T>): T | undefined;
+/**
+ * Returns the greatest element of the specified iterable according to the specified comparator or accessor.
+ * If the given iterable 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.
+ */
+export function greatest<T>(iterable: Iterable<T>, comparator: (a: T, b: T) => number): T | undefined;
+/**
+ * Returns the greatest element of the specified iterable according to the specified comparator or accessor.
+ * If the given iterable 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.
+ */
+export function greatest<T, U>(iterable: Iterable<T>, accessor: (a: T) => U): T | undefined;
+
+/**
+ * Returns the index of the greatest element of the specified iterable according to the specified comparator or accessor.
+ * If the given iterable contains no comparable elements (i.e., the comparator returns NaN when comparing each element to itself), returns -1.
+ * If comparator is not specified, it defaults to ascending.
+ */
+export function greatestIndex<T>(iterable: Iterable<T>): number | undefined;
+/**
+ * Returns the index of the greatest element of the specified iterable according to the specified comparator or accessor.
+ * If the given iterable contains no comparable elements (i.e., the comparator returns NaN when comparing each element to itself), returns -1.
+ * If comparator is not specified, it defaults to ascending.
+ */
+export function greatestIndex<T>(iterable: Iterable<T>, comparator: (a: T, b: T) => number): number | undefined;
+/**
+ * Returns the index of the greatest element of the specified iterable according to the specified comparator or accessor.
+ * If the given iterable contains no comparable elements (i.e., the comparator returns NaN when comparing each element to itself), returns -1.
+ * If comparator is not specified, it defaults to ascending.
+ */
+export function greatestIndex<T, U>(iterable: Iterable<T>, accessor: (a: T) => U): number | undefined;
+
+export function bisectLeft(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
+export function bisectLeft(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
+export function bisectLeft(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
+
+export function bisectRight(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
+export function bisectRight(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
+export function bisectRight(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
+
+export function bisectCenter(array: ArrayLike<number>, x: number, lo?: number, hi?: number): number;
+export function bisectCenter(array: ArrayLike<string>, x: string, lo?: number, hi?: number): number;
+export function bisectCenter(array: ArrayLike<Date>, x: Date, lo?: number, hi?: number): number;
+
+export const bisect: typeof bisectRight;
+
+export interface Bisector<T, U> {
+    left(array: ArrayLike<T>, x: U, lo?: number, hi?: number): number;
+    right(array: ArrayLike<T>, x: U, lo?: number, hi?: number): number;
+    center(array: ArrayLike<T>, x: U, lo?: number, hi?: number): number;
+}
+
+export function bisector<T, U>(comparator: (a: T, b: U) => number): Bisector<T, U>;
+export function bisector<T, U>(accessor: (x: T) => U): Bisector<T, U>;
+
+/**
+ * Rearranges items so that all items in the [left, k] are the smallest. The k-th element will have the (k - left + 1)-th smallest value in [left, right].
+ *
+ * @param array The array to partially sort (in place).
+ * @param k The middle index for partial sorting.
+ */
+export function quickselect<T>(array: ArrayLike<T>, k: number): T[];
+/**
+ * Rearranges items so that all items in the [left, k] are the smallest. The k-th element will have the (k - left + 1)-th smallest value in [left, right].
+ *
+ * @param array The array to partially sort (in place).
+ * @param k The middle index for partial sorting.
+ * @param left The left index of the range to sort.
+ */
+export function quickselect<T>(array: ArrayLike<T>, k: number, left: number): T[];
+/**
+ * Rearranges items so that all items in the [left, k] are the smallest. The k-th element will have the (k - left + 1)-th smallest value in [left, right].
+ *
+ * @param array The array to partially sort (in place).
+ * @param k The middle index for partial sorting.
+ * @param left The left index of the range to sort.
+ * @param right The right index.
+ */
+export function quickselect<T>(array: ArrayLike<T>, k: number, left: number, right: number): T[];
+/**
+ * Rearranges items so that all items in the [left, k] are the smallest. The k-th element will have the (k - left + 1)-th smallest value in [left, right].
+ *
+ * @param array The array to partially sort (in place).
+ * @param k The middle index for partial sorting.
+ * @param left The left index of the range to sort.
+ * @param right The right index.
+ * @param compare The compare function.
+ */
+export function quickselect<T>(array: ArrayLike<T>, k: number, left: number, right: number, compare: (a: Primitive | undefined, b: Primitive | undefined) => number): T[];
+
+// NB. this is limited to primitive values due to D3's use of the <, >, and >= operators. Results get weird for object instances.
+/**
+ * Compares two primitive values for sorting (in ascending order).
+ */
+export function ascending(a: Primitive | undefined, b: Primitive | undefined): number;
+
+// NB. this is limited to primitive values due to D3's use of the <, >, and >= operators. Results get weird for object instances.
+/**
+ * Compares two primitive values for sorting (in descending order).
+ */
+export function descending(a: Primitive | undefined, b: Primitive | undefined): number;
+
+// --------------------------------------------------------------------------------------
+// Transformations
+// --------------------------------------------------------------------------------------
+
+/**
+ * Groups the specified array of values into a Map from key to array of value.
+ *
+ * @param iterable The array to group.
+ * @param key The key function.
+ */
+export function group<TObject, TKey>(iterable: Iterable<TObject>, key: (value: TObject) => TKey): Map<TKey, TObject[]>;
+/**
+ * Groups the specified array of values into a Map from key to array of value.
+ *
+ * @param iterable The array to group.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ */
+export function group<TObject, TKey1, TKey2>(
+    iterable: Iterable<TObject>,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2
+): Map<TKey1, Map<TKey2, TObject[]>>;
+/**
+ * Groups the specified array of values into a Map from key to array of value.
+ *
+ * @param iterable The array to group.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ * @param key3 The third key function.
+ */
+export function group<TObject, TKey1, TKey2, TKey3>(
+    iterable: Iterable<TObject>,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2,
+    key3: (value: TObject) => TKey3
+): Map<TKey1, Map<TKey2, Map<TKey3, TObject[]>>>;
+
+/**
+ * Equivalent to group, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The array to group.
+ * @param key The key function.
+ */
+export function groups<TObject, TKey>(
+    iterable: Iterable<TObject>,
+    key: (value: TObject) => TKey
+): Array<[TKey, TObject[]]>;
+/**
+ * Equivalent to group, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The array to group.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ */
+export function groups<TObject, TKey1, TKey2>(
+    iterable: Iterable<TObject>,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2
+): Array<[TKey1, Array<[TKey2, TObject[]]>]>;
+/**
+ * Equivalent to group, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The array to group.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ * @param key3 The third key function.
+ */
+export function groups<TObject, TKey1, TKey2, TKey3>(
+    iterable: Iterable<TObject>,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2,
+    key3: (value: TObject) => TKey3
+): Array<[TKey1, Array<[TKey2, Array<[TKey3, TObject[]]>]>]>;
+
+/**
+ * Equivalent to group but returns a unique value per compound key instead of an array, throwing if the key is not unique.
+ *
+ * @param iterable The array to group.
+ * @param key The key function.
+ */
+export function index<TObject, TKey>(iterable: Iterable<TObject>, key: (value: TObject) => TKey): Map<TKey, TObject>;
+/**
+ * Equivalent to group but returns a unique value per compound key instead of an array, throwing if the key is not unique.
+ *
+ * @param iterable The array to group.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ */
+export function index<TObject, TKey1, TKey2>(
+    iterable: Iterable<TObject>,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2
+): Map<TKey1, Map<TKey2, TObject>>;
+/**
+ * Equivalent to group but returns a unique value per compound key instead of an array, throwing if the key is not unique.
+ *
+ * @param iterable The array to group.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ * @param key3 The third key function.
+ */
+export function index<TObject, TKey1, TKey2, TKey3>(
+    iterable: Iterable<TObject>,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2,
+    key3: (value: TObject) => TKey3
+): Map<TKey1, Map<TKey2, Map<TKey3, TObject>>>;
+
+/**
+ * Equivalent to index, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The array to group.
+ * @param key The key function.
+ */
+export function indexes<TObject, TKey>(
+    iterable: Iterable<TObject>,
+    key: (value: TObject) => TKey
+): Array<[TKey, TObject]>;
+/**
+ * Equivalent to index, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The array to group.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ */
+export function indexes<TObject, TKey1, TKey2>(
+    iterable: Iterable<TObject>,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2
+): Array<[TKey1, Array<[TKey2, TObject]>]>;
+/**
+ * Equivalent to index, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The array to group.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ * @param key3 The third key function.
+ */
+export function indexes<TObject, TKey1, TKey2, TKey3>(
+    iterable: Iterable<TObject>,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2,
+    key3: (value: TObject) => TKey3
+): Array<[TKey1, Array<[TKey2, Array<[TKey3, TObject]>]>]>;
+
+/**
+ * Groups and reduces the specified array of values into a Map from key to value.
+ *
+ * @param iterable The array to group.
+ * @param reduce The reduce function.
+ * @param key The key function.
+ */
+export function rollup<TObject, TReduce, TKey>(
+    iterable: Iterable<TObject>,
+    reduce: (value: TObject[]) => TReduce,
+    key: (value: TObject) => TKey
+): Map<TKey, TReduce>;
+/**
+ * Groups and reduces the specified array of values into a Map from key to value.
+ *
+ * @param iterable The array to group.
+ * @param reduce The reduce function.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ */
+export function rollup<TObject, TReduce, TKey1, TKey2>(
+    iterable: Iterable<TObject>,
+    reduce: (value: TObject[]) => TReduce,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2
+): Map<TKey1, Map<TKey2, TReduce>>;
+/**
+ * Groups and reduces the specified array of values into a Map from key to value.
+ *
+ * @param iterable The array to group.
+ * @param reduce The reduce function.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ * @param key3 The third key function.
+ */
+export function rollup<TObject, TReduce, TKey1, TKey2, TKey3>(
+    iterable: Iterable<TObject>,
+    reduce: (value: TObject[]) => TReduce,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2,
+    key3: (value: TObject) => TKey3
+): Map<TKey1, Map<TKey2, Map<TKey3, TReduce>>>;
+
+/**
+ * Equivalent to rollup, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The array to group.
+ * @param reduce The reduce function.
+ * @param key The key function.
+ */
+export function rollups<TObject, TReduce, TKey>(
+    iterable: Iterable<TObject>,
+    reduce: (value: TObject[]) => TReduce,
+    key: (value: TObject) => TKey
+): Array<[TKey, TReduce]>;
+/**
+ * Equivalent to rollup, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The array to group.
+ * @param reduce The reduce function.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ */
+export function rollups<TObject, TReduce, TKey1, TKey2>(
+    iterable: Iterable<TObject>,
+    reduce: (value: TObject[]) => TReduce,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2
+): Array<[TKey1, Array<[TKey2, TReduce]>]>;
+/**
+ * Equivalent to rollup, but returns nested arrays instead of nested maps.
+ *
+ * @param iterable The array to group.
+ * @param reduce The reduce function.
+ * @param key1 The first key function.
+ * @param key2 The second key function.
+ * @param key3 The third key function.
+ */
+export function rollups<TObject, TReduce, TKey1, TKey2, TKey3>(
+    iterable: Iterable<TObject>,
+    reduce: (value: TObject[]) => TReduce,
+    key1: (value: TObject) => TKey1,
+    key2: (value: TObject) => TKey2,
+    key3: (value: TObject) => TKey3
+): Array<[TKey1, Array<[TKey2, Array<[TKey3, TReduce]>]>]>;
+
+/**
+ * Returns the number of valid number values (i.e., not null, NaN, or undefined) in the specified iterable; accepts an accessor.
+ *
+ * @param iterable Input array.
+ */
+export function count<TObject>(iterable: Iterable<TObject>): number;
+/**
+ * Returns the number of valid number values (i.e., not null, NaN, or undefined) in the specified iterable; accepts an accessor.
+ *
+ * @param iterable Input array.
+ * @param accessor Accesor method.
+ */
+export function count<TObject>(
+    iterable: Iterable<TObject>,
+    accessor: (a: TObject, b: TObject) => number | null | undefined
+): number;
+
+/**
+ * Returns the 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,
+ * it creates a two-element array for each pair.
+ *
+ * @param a First input array.
+ * @param b Second input array.
+ */
+export function cross<S, T>(a: Iterable<S>, b: Iterable<T>): Array<[S, T]>;
+
+/**
+ * Returns the 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.
+ *
+ * @param a First input array.
+ * @param b Second input array.
+ * @param reducer A reducer function taking as input an element from "a" and "b" and returning a reduced value.
+ */
+export function cross<S, T, U>(a: Iterable<S>, b: Iterable<T>, reducer: (a: S, b: T) => U): U[];
+
+/**
+ * Merges the specified arrays into a single array.
+ */
+export function merge<T>(iterables: Iterable<Iterable<T>>): T[];
+
+/**
+ * For each adjacent pair of elements in the specified array, returns a new array of tuples of elements i and i - 1.
+ * Returns the empty array if the input array has fewer than two elements.
+ *
+ * @param iterable Array of input elements
+ */
+export function pairs<T>(iterable: Iterable<T>): Array<[T, T]>;
+/**
+ * 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.
+ * Returns the resulting array of pair-wise reduced elements.
+ * Returns the empty array if the input array has fewer than two elements.
+ *
+ * @param iterable Array of input elements
+ * @param reducer A reducer function taking as input to adjacent elements of the input array and returning a reduced value.
+ */
+export function pairs<T, U>(iterable: Iterable<T>, reducer: (a: T, b: T) => U): U[];
+
+/**
+ * Returns a permutation of the specified source object (or array) using the specified iterable of keys.
+ * The returned array contains the corresponding property of the source object for each key in keys, in order.
+ * For example, `permute(["a", "b", "c"], [1, 2, 0]) // ["b", "c", "a"]`
+ *
+ * It is acceptable to have more keys than source elements, and for keys to be duplicated or omitted.
+ */
+export function permute<T>(source: { [key: number]: T; }, keys: Iterable<number>): T[];
+/**
+ * Extract the values from an object into an array with a stable order. For example:
+ * `var object = {yield: 27, year: 1931, site: "University Farm"};`
+ * `d3.permute(object, ["site", "yield"]); // ["University Farm", 27]`
+ */
+export function permute<T, K extends keyof T>(source: T, keys: Iterable<K>): Array<T[K]>;
+
+/**
+ * Randomizes the order of the specified array using the Fisher–Yates shuffle.
+ */
+export function shuffle<T>(array: T[], lo?: number, hi?: number): T[];
+export function shuffle(array: Int8Array, lo?: number, hi?: number): Int8Array;
+export function shuffle(array: Uint8Array, lo?: number, hi?: number): Uint8Array;
+export function shuffle(array: Uint8ClampedArray, lo?: number, hi?: number): Uint8ClampedArray;
+export function shuffle(array: Int16Array, lo?: number, hi?: number): Int16Array;
+export function shuffle(array: Uint16Array, lo?: number, hi?: number): Uint16Array;
+export function shuffle(array: Int32Array, lo?: number, hi?: number): Int32Array;
+export function shuffle(array: Uint32Array, lo?: number, hi?: number): Uint32Array;
+export function shuffle(array: Float32Array, lo?: number, hi?: number): Float32Array;
+export function shuffle(array: Float64Array, lo?: number, hi?: number): Float64Array;
+
+/**
+ * Returns a shuffle function given the specified random source.
+ */
+export function shuffler(random: () => number): typeof shuffle;
+
+/**
+ * Generate 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, d3.tickStep and 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. More formally, each returned tick t satisfies start ≤ t and t ≤ stop.
+ *
+ * @param start Start value for ticks
+ * @param stop Stop value for ticks
+ * @param count count + 1 is the approximate number of ticks to be returned by d3.ticks.
+ */
+export function ticks(start: number, stop: number, count: number): number[];
+
+/**
+ * Returns the difference between adjacent tick values if the same arguments were passed to d3.ticks:
+ * a nicely-rounded value that is a power of ten multiplied by 1, 2 or 5.
+ *
+ * Like d3.tickStep, except requires that start is always less than or equal to stop, 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 to avoid guarantee that the returned tick values
+ * are represented as precisely as possible in IEEE 754 floating point.
+ *
+ * @param start Start value for ticks
+ * @param stop Stop value for ticks
+ * @param count count + 1 is the approximate number of ticks to be returned by d3.ticks.
+ */
+export function tickIncrement(start: number, stop: number, count: number): number;
+
+/**
+ * Returns the difference between adjacent tick values if the same arguments were passed to d3.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 to format numbers for human consumption.
+ *
+ * @param start Start value for ticks
+ * @param stop Stop value for ticks
+ * @param count count + 1 is the approximate number of ticks to be returned by d3.ticks.
+ */
+export function tickStep(start: number, stop: number, count: number): number;
+
+/**
+ * Returns a new interval [niceStart, niceStop] covering the given interval [start, stop] and where niceStart and niceStop are guaranteed to align with the corresponding tick step.
+ * Like d3.tickIncrement, this requires that start is less than or equal to stop.
+ *
+ * @param start Start value for ticks
+ * @param stop Stop value for ticks
+ * @param count count + 1 is the approximate number of ticks to be returned by d3.ticks.
+ */
+export function nice(start: number, stop: number, count: number): [number, number];
+
+/**
+ * Generates a 0-based numeric sequence. The output range does not include 'stop'.
+ */
+export function range(stop: number): number[];
+/**
+ * Generates a numeric sequence starting from the given start and stop values. 'step' defaults to 1. The output range does not include 'stop'.
+ */
+export function range(start: number, stop: number, step?: number): number[];
+
+/**
+ * Transpose a matrix provided in Array of Arrays format.
+ */
+export function transpose<T>(matrix: ArrayLike<ArrayLike<T>>): T[][];
+
+/**
+ * Returns an array of arrays, where the ith array contains the ith 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.
+ */
+export function zip<T>(...arrays: Array<ArrayLike<T>>): T[][];
+
+// --------------------------------------------------------------------------------------
+// Iterables
+// --------------------------------------------------------------------------------------
+
+/**
+ * Returns true if the given test function returns true for every value in the given iterable.
+ * This method returns as soon as test returns a non-truthy value or all values are iterated over.
+ * Equivalent to array.every.
+ */
+export function every<T>(
+    iterable: Iterable<T>,
+    test: (value: T, index: number, iterable: Iterable<T>) => unknown
+): boolean;
+
+/**
+ * Returns true if the given test function returns true for any value in the given iterable.
+ * This method returns as soon as test returns a truthy value or all values are iterated over.
+ * Equivalent to array.some.
+ */
+export function some<T>(
+    iterable: Iterable<T>,
+    test: (value: T, index: number, iterable: Iterable<T>) => unknown
+): boolean;
+
+/**
+ * Returns a new array containing the values from iterable, in order, for which the given test function returns true.
+ * Equivalent to array.filter.
+ */
+export function filter<T>(
+    iterable: Iterable<T>,
+    test: (value: T, index: number, iterable: Iterable<T>) => unknown
+): T[];
+
+/**
+ * Returns a new array containing the mapped values from iterable, in order, as defined by given mapper function.
+ * Equivalent to array.map and Array.from.
+ */
+export function map<T, U>(iterable: Iterable<T>, mapper: (value: T, index: number, iterable: Iterable<T>) => U): U[];
+
+/**
+ * Returns the reduced value defined by given reducer function, which is repeatedly invoked for each value in iterable, being passed the current reduced value and the next value.
+ * Equivalent to array.reduce.
+ */
+export function reduce<T>(
+    iterable: Iterable<T>,
+    reducer: (previousValue: T, currentValue: T, currentIndex: number, iterable: Iterable<T>) => T,
+    initialValue?: T
+): T;
+/**
+ * Returns the reduced value defined by given reducer function, which is repeatedly invoked for each value in iterable, being passed the current reduced value and the next value.
+ * Equivalent to array.reduce.
+ */
+export function reduce<T, U>(
+    iterable: Iterable<T>,
+    reducer: (previousValue: U, currentValue: T, currentIndex: number, iterable: Iterable<T>) => U,
+    initialValue: U
+): U;
+
+/**
+ * Returns an array containing the values in the given iterable in reverse order.
+ * Equivalent to array.reverse, except that it does not mutate the given iterable.
+ */
+export function reverse<T>(iterable: Iterable<T>): T[];
+
+/**
+ * Returns an array containing the values in the given iterable in the sorted order defined by the given comparator function.
+ * If comparator is not specified, it defaults to d3.ascending.
+ * Equivalent to array.sort, except that it does not mutate the given iterable, and the comparator defaults to natural order instead of lexicographic order.
+ */
+export function sort<T>(iterable: Iterable<T>, comparator?: (a: T, b: T) => number): T[];
+/**
+ * Returns an array containing the values in the given iterable in the sorted order defined by the given accessor function.
+ * This is equivalent to a comparator using natural order.
+ * The accessor is only invoked once per element, and thus may be nondeterministic.
+ */
+export function sort<T>(iterable: Iterable<T>, accessor: (a: T) => unknown): T[];
+
+// --------------------------------------------------------------------------------------
+// Sets
+// --------------------------------------------------------------------------------------
+
+/**
+ * Returns a new Set containing every value in iterable that is not in any of the others iterables.
+ */
+export function difference<T>(iterable: Iterable<T>, ...others: Array<Iterable<T>>): Set<T>;
+
+/**
+ * Returns a new Set containing every (distinct) value that appears in any of the given iterables.
+ * The order of values in the returned Set is based on their first occurrence in the given iterables.
+ */
+export function union<T>(...iterables: Array<Iterable<T>>): Set<T>;
+
+/**
+ * Returns a new Set containing every (distinct) value that appears in all of the given iterables.
+ * The order of values in the returned Set is based on their first occurrence in the given iterables.
+ */
+export function intersection<T>(...iterables: Array<Iterable<T>>): Set<T>;
+
+/**
+ * Returns true if a is a superset of b: if every value in the given iterable b is also in the given iterable a.
+ */
+export function superset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+
+/**
+ * Returns true if a is a subset of b: if every value in the given iterable a is also in the given iterable b.
+ */
+export function subset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+
+/**
+ * Returns true if a and b are disjoint: if a and b contain no shared value.
+ */
+export function disjoint<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+
+// --------------------------------------------------------------------------------------
+// Bins
+// --------------------------------------------------------------------------------------
+
+export interface Bin<Datum, Value extends number | Date | undefined> extends Array<Datum> {
+    x0: Value | undefined;
+    x1: Value | undefined;
+}
+
+/**
+ * Type definition for threshold generator which returns the count of recommended thresholds
+ */
+export type ThresholdCountGenerator<Value extends number | undefined = number | undefined> =
+    (values: ArrayLike<Value>, min: number, max: number) => number;
+
+/**
+ * Type definition for threshold generator which returns an array of recommended numbers thresholds
+ */
+export type ThresholdNumberArrayGenerator<Value extends number | undefined> =
+    (values: ArrayLike<Value>, min: number, max: number) => Value[];
+
+/**
+ * Type definition for threshold generator which returns an array of recommended dates thresholds
+ */
+export type ThresholdDateArrayGenerator<Value extends Date | undefined> =
+    (values: ArrayLike<Value>, min: Date, max: Date) => Value[];
+
+export interface HistogramCommon<Datum, Value extends number | Date | undefined> {
+    (data: ArrayLike<Datum>): Array<Bin<Datum, Value>>;
+
+    value(): (d: Datum, i: number, data: ArrayLike<Datum>) => Value;
+    value(valueAccessor: (d: Datum, i: number, data: ArrayLike<Datum>) => Value): this;
+}
+
+export interface HistogramGeneratorDate<Datum, Value extends Date | undefined> extends HistogramCommon<Datum, Date> {
+    domain(): (values: ArrayLike<Value>) => [Date, Date];
+    domain(domain: [Date, Date]): this;
+    domain(domainAccessor: (values: ArrayLike<Value>) => [Date, Date]): this;
+
+    thresholds(): ThresholdDateArrayGenerator<Value>;
+    /**
+     * Set the array of values to be used as thresholds in determining the bins.
+     *
+     * Any threshold values outside the 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.
+     *
+     * @param thresholds Array of threshold values used for binning. The elements must
+     * be of the same type as the materialized values of the histogram.
+     */
+    thresholds(thresholds: ArrayLike<Value>): this;
+    /**
+     * Set a threshold accessor function, which returns the array of values to be used as
+     * thresholds in determining the bins.
+     *
+     * Any threshold values outside the 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.
+     *
+     * @param thresholds A function which accepts as arguments the array of materialized values, and
+     * optionally the domain minimum and maximum. The function calculates and returns the array of values to be used as
+     * thresholds in determining the bins.
+     */
+    thresholds(thresholds: ThresholdDateArrayGenerator<Value>): this;
+}
+
+export interface HistogramGeneratorNumber<Datum, Value extends number | undefined> extends HistogramCommon<Datum, Value> {
+    domain(): (values: Iterable<Value>) => [number, number] | [undefined, undefined];
+    domain(domain: [number, number]): this;
+    domain(domainAccessor: (values: Iterable<Value>) => [number, number] | [undefined, undefined]): this;
+
+    thresholds(): ThresholdCountGenerator<Value> | ThresholdNumberArrayGenerator<Value>;
+    /**
+     * Divide the domain uniformly into approximately count bins. IMPORTANT: This threshold
+     * setting approach only works, when the materialized values are numbers!
+     *
+     * Any threshold values outside the 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.
+     *
+     * @param count The desired number of uniform bins.
+     */
+    thresholds(count: number): this;
+    /**
+     * Set a threshold accessor function, which returns the desired number of bins.
+     * Divides the domain uniformly into approximately count bins. IMPORTANT: This threshold
+     * setting approach only works, when the materialized values are numbers!
+     *
+     * Any threshold values outside the 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.
+     *
+     * @param count A function which accepts as arguments the array of materialized values, and
+     * optionally the domain minimum and maximum. The function calculates and returns the suggested
+     * number of bins.
+     */
+    thresholds(count: ThresholdCountGenerator<Value>): this;
+    /**
+     * Set the array of values to be used as thresholds in determining the bins.
+     *
+     * Any threshold values outside the 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.
+     *
+     * @param thresholds Array of threshold values used for binning. The elements must
+     * be of the same type as the materialized values of the histogram.
+     */
+    thresholds(thresholds: ArrayLike<Value>): this;
+    /**
+     * Set a threshold accessor function, which returns the array of values to be used as
+     * thresholds in determining the bins.
+     *
+     * Any threshold values outside the 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.
+     *
+     * @param thresholds A function which accepts as arguments the array of materialized values, and
+     * optionally the domain minimum and maximum. The function calculates and returns the array of values to be used as
+     * thresholds in determining the bins.
+     */
+    thresholds(thresholds: ThresholdNumberArrayGenerator<Value>): this;
+}
+
+/**
+ * @deprecated. Use bin instead.
+ */
+export function histogram(): HistogramGeneratorNumber<number, number>;
+
+/**
+ * @deprecated Use bin instead.
+ */
+export function histogram<Datum, Value extends number | undefined>(): HistogramGeneratorNumber<Datum, Value>;
+
+/**
+ * @deprecated Use bin instead.
+ */
+export function histogram<Datum, Value extends Date | undefined>(): HistogramGeneratorDate<Datum, Value>;
+
+export function bin(): HistogramGeneratorNumber<number, number>;
+export function bin<Datum, Value extends number | undefined>(): HistogramGeneratorNumber<Datum, Value>;
+export function bin<Datum, Value extends Date | undefined>(): HistogramGeneratorDate<Datum, Value>;
+
+// --------------------------------------------------------------------------------------
+// Histogram Thresholds
+// --------------------------------------------------------------------------------------
+
+export function thresholdFreedmanDiaconis(values: ArrayLike<number | undefined>, min: number, max: number): number; // of type ThresholdCountGenerator
+
+export function thresholdScott(values: ArrayLike<number | undefined>, min: number, max: number): number; // of type ThresholdCountGenerator
+
+export function thresholdSturges(values: ArrayLike<number | undefined>): number; // of type ThresholdCountGenerator

node_modules/@types/d3-array/package.json

@@ -0,0 +1,74 @@
+{
+  "_from": "@types/d3-array@*",
+  "_id": "@types/d3-array@2.9.0",
+  "_inBundle": false,
+  "_integrity": "sha512-sdBMGfNvLUkBypPMEhOcKcblTQfgHbqbYrUqRE31jOwdDHBJBxz4co2MDAq93S4Cp++phk4UiwoEg/1hK3xXAQ==",
+  "_location": "/@types/d3-array",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-array@*",
+    "name": "@types/d3-array",
+    "escapedName": "@types%2fd3-array",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3",
+    "/@types/d3-contour"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-2.9.0.tgz",
+  "_shasum": "fb6c3d7d7640259e68771cd90cc5db5ac1a1a012",
+  "_spec": "@types/d3-array@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "denisname",
+      "url": "https://github.com/denisname"
+    },
+    {
+      "name": "Hugues Stefanski",
+      "url": "https://github.com/ledragon"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-array module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-array",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-array"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.4",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "5e37c7e4cb5ba25736f56a266d1bbba7f9b64b9a3a10bf6c277247fd26fd9ccc",
+  "version": "2.9.0"
+}

node_modules/@types/d3-axis/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-axis/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-axis`
+
+# Summary
+This package contains type definitions for D3JS d3-axis module (https://github.com/d3/d3-axis/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-axis.
+
+### Additional Details
+ * Last updated: Wed, 30 Sep 2020 21:08:20 GMT
+ * Dependencies: [@types/d3-selection](https://npmjs.com/package/@types/d3-selection)
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-axis/index.d.ts

@@ -0,0 +1,335 @@
+// Type definitions for D3JS d3-axis module 2.0
+// Project: https://github.com/d3/d3-axis/, https://d3js.org/d3-axis
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+// Last module patch version validated against: 2.0.0
+
+import { Selection, TransitionLike } from 'd3-selection';
+
+// --------------------------------------------------------------------------
+// Shared Types and Interfaces
+// --------------------------------------------------------------------------
+
+/**
+ * A helper type to alias elements which can serve as a domain for an axis.
+ */
+export type AxisDomain = number | string | Date | { valueOf(): number};
+
+/**
+ * A helper interface to describe the minimal contract to be met by a time interval
+ * which can be passed into the Axis.ticks(...) or Axis.tickArguments(...) methods when
+ * creating time series axes. Under normal circumstances the argument will be of type
+ * TimeInterval or CountableTimeInterval as defined in d3-time.
+ * NB: This helper interface has been created to avoid tight coupling of d3-axis to
+ * d3-time at the level of definition files. I.e. d3-time is not a
+ * dependency of d3-axis in the D3 Javascript implementation. This minimal contract
+ * is based on an analysis of how d3-axis passes a time interval argument into a time scale,
+ * if a time scale was set using Axis.scale(...). And in turn on how a time scale uses
+ * the time interval when creating ticks from it.
+ */
+export interface AxisTimeInterval {
+    range(start: Date, stop: Date, step?: number): Date[];
+}
+
+/**
+ * A helper interface to which a scale passed into axis must conform (at a minimum)
+ * for axis to use the scale without error.
+ */
+export interface AxisScale<Domain> {
+    (x: Domain): number | undefined;
+    domain(): Domain[];
+    range(): number[];
+    copy(): this;
+    bandwidth?(): number;
+    // TODO: Reconsider the below, note that the compiler does not differentiate the overloads w.r.t. optionality
+    // ticks?(count?: number): Domain[];
+    // ticks?(count?: AxisTimeInterval): Date[];
+    // tickFormat?(count?: number, specifier?: string): ((d: number) => string);
+    // tickFormat?(count?: number | AxisTimeInterval, specifier?: string): ((d: Date) => string);
+}
+
+/**
+ * A helper type to alias elements which can serve as a container for an axis.
+ */
+export type AxisContainerElement = SVGSVGElement | SVGGElement;
+
+/**
+ * Interface defining an axis generator. The generic <Domain> is the type of the axis domain.
+ */
+export interface Axis<Domain> {
+    /**
+     * Render the axis to the given context.
+     *
+     * @param context A selection of SVG containers (either SVG or G elements).
+     */
+    (context: Selection<SVGSVGElement, any, any, any> | Selection<SVGGElement, any, any, any>): void;
+
+    /**
+     * Render the axis to the given context.
+     *
+     * @param context A transition defined on SVG containers (either SVG or G elements).
+     */
+    (context: TransitionLike<SVGSVGElement, any> | TransitionLike<SVGGElement, any>): void;
+
+    /**
+     * Gets the current scale underlying the axis.
+     */
+    scale<A extends AxisScale<Domain>>(): A;
+
+    /**
+     * Sets the scale and returns the axis.
+     *
+     * @param scale The scale to be used for axis generation.
+     */
+    scale(scale: AxisScale<Domain>): this;
+
+    /**
+     * Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
+     *
+     * This method has no effect if the scale does not implement scale.ticks, as with band and point scales.
+     *
+     * This method is also a convenience function for axis.tickArguments.
+     *
+     * @param count Number of ticks that should be rendered.
+     * @param specifier An optional format specifier to customize how the tick values are formatted.
+     */
+    ticks(count: number, specifier?: string): this;
+
+    /**
+     * Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
+     * Use with a TIME SCALE ONLY.
+     *
+     * This method is also a convenience function for axis.tickArguments.
+     *
+     * @param interval A time interval used to generate date-based ticks. This is typically a TimeInterval/CountableTimeInterval as defined
+     * in d3-time. E.g. as obtained by passing in d3.timeMinute.every(15).
+     * @param specifier An optional format specifier to customize how the tick values are formatted.
+     */
+    ticks(interval: AxisTimeInterval, specifier?: string): this;
+
+    /**
+     * Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
+     *
+     * The meaning of the arguments depends on the axis’ scale type: most commonly, the arguments are a suggested count for the number of ticks
+     * (or a time interval for time scales), and an optional format specifier to customize how the tick values are formatted.
+     *
+     * This method has no effect if the scale does not implement scale.ticks, as with band and point scales.
+     *
+     * To set the tick values explicitly, use axis.tickValues. To set the tick format explicitly, use axis.tickFormat.
+     *
+     * This method is also a convenience function for axis.tickArguments.
+     */
+    ticks(arg0: any, ...args: any[]): this;
+
+    /**
+     * Get an array containing the currently set arguments to be passed into scale.ticks and scale.tickFormat, which defaults to the empty array.
+     */
+    tickArguments(): any[];
+
+    /**
+     * Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
+     *
+     * This method has no effect if the scale does not implement scale.ticks, as with band and point scales.
+     * To set the tick values explicitly, use axis.tickValues. To set the tick format explicitly, use axis.tickFormat.
+     *
+     * See also axis.ticks.
+     *
+     * @param args An array containing a single element representing the count, i.e. number of ticks to be rendered.
+     */
+    tickArguments(args: [number]): this;
+
+    /**
+     * Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
+     *
+     * This method has no effect if the scale does not implement scale.ticks, as with band and point scales.
+     * To set the tick values explicitly, use axis.tickValues. To set the tick format explicitly, use axis.tickFormat.
+     *
+     * See also axis.ticks.
+     *
+     * @param args An array containing two elements. The first element represents the count, i.e. number of ticks to be rendered. The second
+     * element is a string representing the format specifier to customize how the tick values are formatted.
+     */
+    tickArguments(args: [number, string]): this;
+
+    /**
+     * Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
+     * Use with a TIME SCALE ONLY.
+     *
+     * See also axis.ticks.
+     *
+     * @param args An array containing a single element representing a time interval used to generate date-based ticks.
+     * This is typically a TimeInterval/CountableTimeInterval as defined in d3-time. E.g. as obtained by passing in d3.timeMinute.every(15).
+     */
+    tickArguments(args: [AxisTimeInterval]): this;
+
+    /**
+     * Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
+     * Use with a TIME SCALE ONLY.
+     *
+     * See also axis.ticks.
+     *
+     * @param args An array containing two elements. The first element represents a time interval used to generate date-based ticks.
+     * This is typically a TimeInterval/CountableTimeInterval as defined in d3-time. E.g. as obtained by passing in d3.timeMinute.every(15).
+     * The second element is a string representing the format specifier to customize how the tick values are formatted.
+     */
+    tickArguments(args: [AxisTimeInterval, string]): this;
+
+    /**
+     * Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
+     *
+     * This method has no effect if the scale does not implement scale.ticks, as with band and point scales.
+     * To set the tick values explicitly, use axis.tickValues. To set the tick format explicitly, use axis.tickFormat.
+     *
+     * See also axis.ticks.
+     *
+     * @param args An array with arguments suitable for the scale to be used for tick generation.
+     */
+    tickArguments(args: any[]): this;
+
+    /**
+     * Returns the current tick values, which defaults to null.
+     */
+    tickValues(): Domain[] | null;
+
+    /**
+     * Specified values to be used for ticks rather than using the scale’s automatic tick generator.
+     * The explicit tick values take precedent over the tick arguments set by axis.tickArguments.
+     * However, any tick arguments will still be passed to the scale’s tickFormat function if a
+     * tick format is not also set.
+     *
+     * @param values An array with values from the Domain of the scale underlying the axis.
+     */
+    tickValues(values: Domain[]): this;
+
+    /**
+     * Clears any previously-set explicit tick values and reverts back to the scale’s tick generator.
+     *
+     * @param values null
+     */
+    tickValues(values: null): this;
+
+    /**
+     * Returns the currently set tick format function, which defaults to null.
+     */
+    tickFormat(): ((domainValue: Domain, index: number) => string) | null;
+
+    /**
+     * Sets the tick format function and returns the axis.
+     *
+     * @param format A function mapping a value from the axis Domain to a formatted string
+     * for display purposes. When invoked, the format function is also passed a second argument representing the zero-based index
+     * of the tick label in the array of generated tick labels.
+     */
+    tickFormat(format: (domainValue: Domain, index: number) => string): this;
+
+    /**
+     * Reset the tick format function. A null format indicates that the scale’s
+     * default formatter should be used, which is generated by calling scale.tickFormat.
+     * In this case, the arguments specified by axis.tickArguments
+     * are likewise passed to scale.tickFormat.
+     *
+     * @param format null
+     */
+    tickFormat(format: null): this;
+
+    /**
+     * Get the current inner tick size, which defaults to 6.
+     */
+    tickSize(): number;
+    /**
+     * Set the inner and outer tick size to the specified value and return the axis.
+     *
+     * @param size Tick size in pixels (Default is 6).
+     */
+    tickSize(size: number): this;
+
+    /**
+     * Get the current inner tick size, which defaults to 6.
+     * The inner tick size controls the length of the tick lines,
+     * offset from the native position of the axis.
+     */
+    tickSizeInner(): number;
+
+    /**
+     * Set the inner tick size to the specified value and return the axis.
+     * The inner tick size controls the length of the tick lines,
+     * offset from the native position of the axis.
+     *
+     * @param size Tick size in pixels (Default is 6).
+     */
+    tickSizeInner(size: number): this;
+
+    /**
+     * Get the current outer tick size, which defaults to 6.
+     * The outer tick size controls the length of the square ends of the domain path,
+     * offset from the native position of the axis. Thus, the “outer ticks” are not actually
+     * ticks but part of the domain path, and their position is determined by the associated
+     * scale’s domain extent. Thus, outer ticks may overlap with the first or last inner tick.
+     * An outer tick size of 0 suppresses the square ends of the domain path,
+     * instead producing a straight line.
+     */
+    tickSizeOuter(): number;
+
+    /**
+     * Set the current outer tick size and return the axis.
+     * The outer tick size controls the length of the square ends of the domain path,
+     * offset from the native position of the axis. Thus, the “outer ticks” are not actually
+     * ticks but part of the domain path, and their position is determined by the associated
+     * scale’s domain extent. Thus, outer ticks may overlap with the first or last inner tick.
+     * An outer tick size of 0 suppresses the square ends of the domain path,
+     * instead producing a straight line.
+     *
+     * @param size Tick size in pixels (Default is 6).
+     */
+    tickSizeOuter(size: number): this;
+
+    /**
+     * Get the current padding, which defaults to 3.
+     */
+    tickPadding(): number;
+
+    /**
+     * Set the current padding and return the axis.
+     *
+     * @param padding Padding in pixels (Default is 3).
+     */
+    tickPadding(padding: number): this;
+}
+
+/**
+ * Constructs a new top-oriented axis generator for the given scale, with empty tick arguments,
+ * a tick size of 6 and padding of 3. In this orientation, ticks are drawn above the horizontal domain path.
+ *
+ * @param scale The scale to be used for axis generation.
+ */
+export function axisTop<Domain extends AxisDomain>(scale: AxisScale<Domain>): Axis<Domain>;
+
+/**
+ * Constructs a new right-oriented axis generator for the given scale, with empty tick arguments,
+ * a tick size of 6 and padding of 3. In this orientation, ticks are drawn to the right of the vertical domain path.
+ *
+ * @param scale The scale to be used for axis generation.
+ */
+export function axisRight<Domain extends AxisDomain>(scale: AxisScale<Domain>): Axis<Domain>;
+
+/**
+ * Constructs a new bottom-oriented axis generator for the given scale, with empty tick arguments,
+ * a tick size of 6 and padding of 3. In this orientation, ticks are drawn below the horizontal domain path.
+ *
+ * @param scale The scale to be used for axis generation.
+ */
+export function axisBottom<Domain extends AxisDomain>(scale: AxisScale<Domain>): Axis<Domain>;
+
+/**
+ * Constructs a new left-oriented axis generator for the given scale, with empty tick arguments,
+ * a tick size of 6 and padding of 3. In this orientation, ticks are drawn to the left of the vertical domain path.
+ *
+ * @param scale The scale to be used for axis generation.
+ */
+export function axisLeft<Domain extends AxisDomain>(scale: AxisScale<Domain>): Axis<Domain>;

node_modules/@types/d3-axis/package.json

@@ -0,0 +1,71 @@
+{
+  "_from": "@types/d3-axis@*",
+  "_id": "@types/d3-axis@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-gUdlEwGBLl3tXGiBnBNmNzph9W3bCfa4tBgWZD60Z1eDQKTY4zyCAcZ3LksignGfKawYatmDYcBdjJ5h/54sqA==",
+  "_location": "/@types/d3-axis",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-axis@*",
+    "name": "@types/d3-axis",
+    "escapedName": "@types%2fd3-axis",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-axis/-/d3-axis-2.0.0.tgz",
+  "_shasum": "a3e7534d3c399c20ba42ec3093dd2a385659366e",
+  "_spec": "@types/d3-axis@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "denisname",
+      "url": "https://github.com/denisname"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {
+    "@types/d3-selection": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-axis module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-axis",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-axis"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "85781c87bbf7c5e1c9524ef35159bd37eee78dd4ed546e3344f0b3044f73e6b2",
+  "version": "2.0.0"
+}

node_modules/@types/d3-brush/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-brush/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-brush`
+
+# Summary
+This package contains type definitions for D3JS d3-brush module (https://github.com/d3/d3-brush/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-brush.
+
+### Additional Details
+ * Last updated: Wed, 30 Sep 2020 21:08:20 GMT
+ * Dependencies: [@types/d3-selection](https://npmjs.com/package/@types/d3-selection)
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-brush/index.d.ts

@@ -0,0 +1,305 @@
+// Type definitions for D3JS d3-brush module 2.1
+// Project: https://github.com/d3/d3-brush/, https://d3js.org/d3-brush
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+// Last module patch version validated against: 2.1.0
+
+import { Selection, TransitionLike, ValueFn } from 'd3-selection';
+
+/**
+ * Type alias for a BrushSelection. For a two-dimensional brush, it must be defined as [[x0, y0], [x1, y1]],
+ * where x0 is the minimum x-value, y0 is the minimum y-value, x1 is the maximum x-value, and y1 is the maximum y-value.
+ * For an x-brush, it must be defined as [x0, x1]; for a y-brush, it must be defined as [y0, y1].
+ */
+export type BrushSelection = [[number, number], [number, number]] | [number, number];
+
+/**
+ * A D3 brush behavior
+ *
+ * The generic refers to the type of the datum for the group element on which brush behavior is defined.
+ */
+export interface BrushBehavior<Datum> {
+    /**
+     * Applies the brush to the specified group, which must be a selection of SVG G elements.
+     * This function is typically not invoked directly, and is instead invoked via selection.call.
+     *
+     * For details see: {@link https://github.com/d3/d3-brush#_brush}
+     *
+     * @param group A D3 selection of SVG G elements.
+     * @param args Optional arguments to be passed in.
+     */
+    (group: Selection<SVGGElement, Datum, any, any>, ...args: any[]): void;
+    /**
+     * Clear the active selection of the brush on the specified SVG G element(s) selection.
+     *
+     * @param group A D3 selection of SVG G elements.
+     * @param selection Use null to clear the active brush selection.
+     */
+    move(group: Selection<SVGGElement, Datum, any, any>, selection: null): void;
+    /**
+     * Sets the active selection of the brush on the specified SVG G element(s) selection
+     * to the provided array.
+     *
+     * @param group A D3 selection of SVG G elements.
+     * @param selection An array specifying the new active brush selection. For a two-dimensional brush,
+     * it must be defined as [[x0, y0], [x1, y1]], where x0 is the minimum x-value, y0 is the minimum y-value,
+     * x1 is the maximum x-value, and y1 is the maximum y-value. For an x-brush, it must be defined as [x0, x1];
+     * for a y-brush, it must be defined as [y0, y1].
+     */
+    move(group: Selection<SVGGElement, Datum, any, any>, selection: BrushSelection): void;
+    /**
+     * Sets the active selection of the brush on the specified SVG G element(s) selection
+     * based on the array returned by a value function invoked for each selection element.
+     *
+     * @param group A D3 selection of SVG G elements.
+     * @param selection A selection value function which is evaluated for each selected element,
+     * in order, being passed the current datum (d), the current index (i), and the current group (nodes),
+     * with this as the current DOM element. The function returns an array specifying the new active brush selection.
+     * For a two-dimensional brush, it must be defined as [[x0, y0], [x1, y1]], where x0 is the minimum x-value, y0 is the minimum y-value,
+     * x1 is the maximum x-value, and y1 is the maximum y-value. For an x-brush, it must be defined as [x0, x1];
+     * for a y-brush, it must be defined as [y0, y1].
+     */
+    move(group: Selection<SVGGElement, Datum, any, any>, selection: ValueFn<SVGGElement, Datum, BrushSelection>): void;
+    /**
+     * Clear the active selection of the brush on the specified SVG G element(s) transition.
+     *
+     * @param group A D3 transition on SVG G elements.
+     * @param selection Use null to clear the active brush selection.
+     */
+    move(group: Selection<SVGGElement, Datum, any, any>, selection: null): void;
+    /**
+     * Sets the active selection of the brush on the specified SVG G element(s) transition
+     * to the provided array.
+     *
+     * @param group A D3 transition on SVG G elements.
+     * @param selection An array specifying the new active brush selection. For a two-dimensional brush,
+     * it must be defined as [[x0, y0], [x1, y1]], where x0 is the minimum x-value, y0 is the minimum y-value,
+     * x1 is the maximum x-value, and y1 is the maximum y-value. For an x-brush, it must be defined as [x0, x1];
+     * for a y-brush, it must be defined as [y0, y1].
+     */
+    move(group: TransitionLike<SVGGElement, Datum>, selection: BrushSelection): void;
+    /**
+     * Sets the active selection of the brush on the specified SVG G element(s) transition
+     * based on the array returned by a value function invoked for each transitioning element.
+     *
+     * @param group A D3 transition on SVG G elements.
+     * @param selection A selection value function which is evaluated for each selected element,
+     * in order, being passed the current datum (d), the current index (i), and the current group (nodes),
+     * with this as the current DOM element. The function returns an array specifying the new active brush selection.
+     * For a two-dimensional brush, it must be defined as [[x0, y0], [x1, y1]], where x0 is the minimum x-value, y0 is the minimum y-value,
+     * x1 is the maximum x-value, and y1 is the maximum y-value. For an x-brush, it must be defined as [x0, x1];
+     * for a y-brush, it must be defined as [y0, y1].
+     */
+    move(group: TransitionLike<SVGGElement, Datum>, selection: ValueFn<SVGGElement, Datum, BrushSelection>): void;
+
+    /**
+     * Clear the active selection of the brush on the specified SVG G element(s) selection.
+     *
+     * @param group A D3 selection of SVG G elements.
+     */
+    clear(group: Selection<SVGGElement, Datum, any, any>): void;
+
+    /**
+     * Returns the current extent accessor.
+     */
+    extent(): ValueFn<SVGGElement, Datum, [[number, number], [number, number]]>;
+    /**
+     * Set the brushable extent to the specified array of points and returns this brush.
+     *
+     * The brush extent determines the size of the invisible overlay and also constrains the brush selection;
+     * the brush selection cannot go outside the brush extent.
+     *
+     * @param extent array of points [[x0, y0], [x1, y1]], where [x0, y0] is the top-left corner
+     * and [x1, y1] is the bottom-right corner.
+     */
+    extent(extent: [[number, number], [number, number]]): this;
+    /**
+     * Set the brushable extent to the specified array of points returned by the accessor function
+     * evaluated for each element in the selection/transition and returns this brush.
+     *
+     * The brush extent determines the size of the invisible overlay and also constrains the brush selection;
+     * the brush selection cannot go outside the brush extent.
+     *
+     * @param extent An extent accessor function which is evaluated for each selected element,
+     * in order, being passed the current datum (d), the current index (i), and the current group (nodes),
+     * with this as the current DOM element. The function returns an array of points [[x0, y0], [x1, y1]],
+     * where [x0, y0] is the top-left corner and [x1, y1] is the bottom-right corner.
+     */
+    extent(extent: ValueFn<SVGGElement, Datum, [[number, number], [number, number]]>): this;
+
+    /**
+     * Returns the current filter function.
+     */
+    filter(): (this: SVGGElement, event: any, d: Datum) => boolean;
+    /**
+     * Sets the filter to the specified filter function and returns the brush.
+     *
+     * If the filter returns falsey, the initiating event is ignored and no brush gesture is started.
+     * Thus, the filter determines which input events are ignored. The default filter ignores mousedown events on secondary buttons,
+     * since those buttons are typically intended for other purposes, such as the context menu.
+     *
+     * @param filterFn A filter function which is evaluated for each selected element,
+     * in order, being passed the current event `event` and datum `d`, with the `this` context as the current DOM element.
+     * The function returns a boolean value.
+     */
+    filter(filterFn: (this: SVGGElement, event: any, d: Datum) => boolean): this;
+
+    /**
+     * Returns the current touch support detector, which defaults to a function returning true,
+     * if the "ontouchstart" event is supported on the current element.
+     */
+    touchable(): ValueFn<SVGGElement, Datum, boolean>;
+    /**
+     * Sets the touch support detector to the specified boolean value and returns the brush.
+     *
+     * Touch event listeners are only registered if the detector returns truthy for the corresponding element when the brush is applied.
+     * The default detector works well for most browsers that are capable of touch input, but not all; Chrome’s mobile device emulator, for example,
+     * fails detection.
+     *
+     * @param touchable A boolean value. true when touch event listeners should be applied to the corresponding element, otherwise false.
+     */
+    touchable(touchable: boolean): this;
+    /**
+     * Sets the touch support detector to the specified function and returns the drag behavior.
+     *
+     * Touch event listeners are only registered if the detector returns truthy for the corresponding element when the brush is applied.
+     * The default detector works well for most browsers that are capable of touch input, but not all; Chrome’s mobile device emulator, for example,
+     * fails detection.
+     *
+     * @param touchable A touch support detector function, which returns true when touch event listeners should be applied to the corresponding element.
+     * The function is evaluated for each selected element to which the brush was applied, in order, being passed the current datum (d),
+     * the current index (i), and the current group (nodes), with this as the current DOM element. The function returns a boolean value.
+     */
+    touchable(touchable: ValueFn<SVGGElement, Datum, boolean>): this;
+
+    /**
+     * Returns the current key modifiers flag.
+     */
+    keyModifiers(): boolean;
+    /**
+     * Sets the key modifiers flag and returns the brush.
+     *
+     * The key modifiers flag determines whether the brush listens to key events during brushing.
+     * The default value is true.
+     *
+     * @param modifiers New value for key modifiers flag.
+     */
+    keyModifiers(modifiers: boolean): this;
+
+    /**
+     * Returns the current handle size, which defaults to six.
+     */
+    handleSize(): number;
+    /**
+     * Sets the size of the brush handles to the specified number and returns the brush.
+     *
+     * This method must be called before applying the brush to a selection;
+     * changing the handle size does not affect brushes that were previously rendered.
+     * The default size is 6.
+     *
+     * @param size Size of the handle.
+     */
+    handleSize(size: number): this;
+
+    /**
+     * Returns the first currently-assigned listener matching the specified typenames, if any.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace.
+     * Each typename is a type, optionally followed by a period (.) and a name, such as "brush.foo"" and "brush.bar";
+     * the name allows multiple listeners to be registered for the same type. The type must be one of the following:
+     * start (at the start of a brush gesture, such as on mousedown), brush (when the brush moves, such as on mousemove), or
+     * end (at the end of a brush gesture, such as on mouseup.)
+     */
+    on(typenames: string): ((this: SVGGElement, event: any, d: Datum) => void) | undefined;
+    /**
+     * Removes the current event listeners for the specified typenames, if any.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace.
+     * Each typename is a type, optionally followed by a period (.) and a name, such as "brush.foo"" and "brush.bar";
+     * the name allows multiple listeners to be registered for the same type. The type must be one of the following:
+     * start (at the start of a brush gesture, such as on mousedown), brush (when the brush moves, such as on mousemove), or
+     * end (at the end of a brush gesture, such as on mouseup.)
+     * @param listener Use null to remove the listener.
+     */
+    on(typenames: string, listener: null): this;
+    /**
+     * Sets the event listener for the specified typenames and returns the brush.
+     * If an event listener was already registered for the same type and name,
+     * the existing listener is removed before the new listener is added.
+     * When a specified event is dispatched, each listener will be invoked with the same context and arguments as selection.on listeners.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace.
+     * Each typename is a type, optionally followed by a period (.) and a name, such as "brush.foo"" and "brush.bar";
+     * the name allows multiple listeners to be registered for the same type. The type must be one of the following:
+     * start (at the start of a brush gesture, such as on mousedown), brush (when the brush moves, such as on mousemove), or
+     * end (at the end of a brush gesture, such as on mouseup.)
+     * @param listener An event listener function which is evaluated for each selected element,
+     * in order, being passed the current event `event` and datum `d`, with the `this` context as the current DOM element.
+     */
+    on(typenames: string, listener: (this: SVGGElement, event: any, d: Datum) => void): this;
+}
+
+/**
+ * Create a new two-dimensional brush.
+ *
+ * The generic "Datum" refers to the type of the data of the selected svg:g element to
+ * which the returned BrushBehavior will be applied.
+ */
+export function brush<Datum>(): BrushBehavior<Datum>;
+/**
+ * Creates a new one-dimensional brush along the x-dimension.
+ *
+ * The generic "Datum" refers to the type of the data of the selected svg:g element to
+ * which the returned BrushBehavior will be applied.
+ */
+export function brushX<Datum>(): BrushBehavior<Datum>;
+/**
+ * Creates a new one-dimensional brush along the y-dimension.
+ *
+ * The generic "Datum" refers to the type of the data of the selected svg:g element to
+ * which the returned BrushBehavior will be applied.
+ */
+export function brushY<Datum>(): BrushBehavior<Datum>;
+
+/**
+ * Return the current brush selection for the specified node. Internally, an element’s brush state is stored as element.__brush;
+ * however, you should use this method rather than accessing it directly. If the given node has no selection, returns null.
+ * Otherwise, the selection is defined as an array of numbers.
+ *
+ * @param node The node for which the brush selection should be returned.
+ */
+export function brushSelection(node: SVGGElement): BrushSelection | null;
+
+/**
+ * D3 brush event
+ *
+ * The generic refers to the type of the datum for the group element on which brush was defined.
+ */
+export interface D3BrushEvent<Datum> {
+    /**
+     * The BrushBehavior associated with the event
+     */
+    target: BrushBehavior<Datum>;
+    /**
+     * The event type for the BrushEvent
+     */
+    type: 'start' | 'brush' | 'end' | string; // Leave failsafe string type for cases like 'brush.foo'
+    /**
+     * The current brush selection associated with the event.
+     * This is null when the selection is empty.
+     */
+    selection: BrushSelection | null;
+    /**
+     * The underlying input event, such as mousemove or touchmove.
+     */
+    sourceEvent: any;
+    /**
+     * The mode of the brush.
+     */
+    mode: 'drag' | 'space' | 'handle' | 'center';
+}

node_modules/@types/d3-brush/package.json

@@ -0,0 +1,67 @@
+{
+  "_from": "@types/d3-brush@*",
+  "_id": "@types/d3-brush@2.1.0",
+  "_inBundle": false,
+  "_integrity": "sha512-rLQqxQeXWF4ArXi81GlV8HBNwJw9EDpz0jcWvvzv548EDE4tXrayBTOHYi/8Q4FZ/Df8PGXFzxpAVQmJMjOtvQ==",
+  "_location": "/@types/d3-brush",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-brush@*",
+    "name": "@types/d3-brush",
+    "escapedName": "@types%2fd3-brush",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-brush/-/d3-brush-2.1.0.tgz",
+  "_shasum": "c51ad1ab93887b23be7637d2100540f1df0dac00",
+  "_spec": "@types/d3-brush@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {
+    "@types/d3-selection": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-brush module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-brush",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-brush"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "c323f9cc900bd875792c02e47c16f142c269d6da2553ab3b7625bda2557ff3aa",
+  "version": "2.1.0"
+}

node_modules/@types/d3-chord/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-chord/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-chord`
+
+# Summary
+This package contains type definitions for D3JS d3-chord module (https://github.com/d3/d3-chord/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-chord.
+
+### Additional Details
+ * Last updated: Tue, 29 Sep 2020 23:28:18 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-chord/index.d.ts

@@ -0,0 +1,475 @@
+// Type definitions for D3JS d3-chord module 2.0
+// Project: https://github.com/d3/d3-chord/, https://d3js.org/d3-chord
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+// Last module patch version validated against: 2.0.0
+
+// ---------------------------------------------------------------------
+// Chord
+// ---------------------------------------------------------------------
+
+/**
+ * A chord subgroup serving as source or target of a chord between two nodes i an j (where i may be equal to j).
+ */
+export interface ChordSubgroup {
+    /**
+     * Start angle of the chord subgroup in radians
+     */
+    startAngle: number;
+
+    /***
+     * End angle of the chord subgroup in radians
+     */
+    endAngle: number;
+
+    /**
+     * The flow value in matrix[i][j] from node i to node j
+     */
+    value: number;
+
+    /**
+     * The node index i
+     */
+    index: number;
+}
+
+/**
+ * A chord represents the combined bidirectional flow between two nodes i and j (where i may be equal to j)
+ */
+export interface Chord {
+    /**
+     * Chord subgroup constituting the source of Chord
+     */
+    source: ChordSubgroup;
+    /**
+     * Chord subgroup constituting the Target of Chord
+     */
+    target: ChordSubgroup;
+}
+
+/**
+ * A chord group for a given node i representing the combined outflow for node i,
+ * corresponding to the elements matrix[i][0 … n - 1].
+ */
+export interface ChordGroup {
+    /**
+     * The start angle of the chord group in radians
+     */
+    startAngle: number;
+
+    /**
+     * The end angle of the chord group in radians
+     */
+    endAngle: number;
+
+    /**
+     * The total outgoing flow value for node i
+     */
+    value: number;
+
+    /**
+     * The node index i
+     */
+    index: number;
+}
+
+/**
+ * An array of chords, where each chord represents the combined bidirectional flow between two nodes i and j (where i may be equal to j).
+ * The chords are based on a (n x n) matrix of flows between nodes.
+ *
+ * The chords are typically passed to d3.ribbon to display the network relationships.
+ * The returned array includes only chord objects for which the value matrix[i][j] or matrix[j][i] is non-zero.
+ * Furthermore, the returned array only contains unique chords: a given chord ij represents the bidirectional flow from i to j and from j to i,
+ * and does not contain a duplicate chord ji; i and j are chosen such that the chord’s source always represents the larger of matrix[i][j] and matrix[j][i].
+ * In other words, chord.source.index equals chord.target.subindex, chord.source.subindex equals chord.target.index,
+ * chord.source.value is greater than or equal to chord.target.value, and chord.source.value is always greater than zero.
+ */
+export interface Chords extends Array<Chord> {
+    /**
+     * An array of length n, where each group represents the combined outflow for node i,
+     * corresponding to the elements matrix[i][0 … n - 1]
+     */
+    groups: ChordGroup[];
+}
+
+/**
+ * A D3 chord diagram Layout to visualize relationships or network flow with an aesthetically-pleasing circular layout.
+ *
+ * The relationships are represented as a square matrix of size n×n, where the matrix represents the directed flow amongst a network (a complete digraph) of n nodes.
+ */
+export interface ChordLayout {
+    /**
+     * Computes the chord layout for the specified square matrix of size n×n, where the matrix represents the directed flow amongst a network (a complete digraph) of n nodes.
+     *
+     * @param matrix An (n x n) matrix representing the directed flow amongst a network (a complete digraph) of n nodes.The given matrix must be an array of length n,
+     * where each element matrix[i] is an array of n numbers, where each matrix[i][j] represents the flow from the ith node in the network to the jth node.
+     * Each number matrix[i][j] must be nonnegative, though it can be zero if there is no flow from node i to node j.
+     */
+    (matrix: number[][]): Chords;
+
+    /**
+     * Returns the current pad angle in radians, which defaults to zero.
+     */
+    padAngle(): number;
+    /**
+     * Sets the pad angle between adjacent groups to the specified number in radians and returns this chord layout.
+     *
+     * The default is zero.
+     *
+     * @param angle Pad angle between adjacent groups in radians.
+     */
+    padAngle(angle: number): this;
+
+    /**
+     * Returns the current group comparator, which defaults to null.
+     */
+    sortGroups(): ((a: number, b: number) => number) | null;
+    /**
+     * Removes the current group comparator and returns this chord layout.
+     *
+     * @param compare Use null to remove the current comparator function, if any.
+     */
+    sortGroups(compare: null): this;
+    /**
+     * Sets the group comparator to the specified function and returns this chord layout.
+     *
+     * If the group comparator is non-null, it is used to sort the groups by their total outflow. See also d3.ascending and d3.descending.
+     *
+     * @param compare A comparator function, e.g. d3.ascending or d3.descending.
+     */
+    sortGroups(compare: (a: number, b: number) => number): this;
+
+    /**
+     * Returns the current subgroup comparator, which defaults to null.
+     */
+    sortSubgroups(): ((a: number, b: number) => number) | null;
+    /**
+     * Removes the current subgroup comparator and returns this chord layout.
+     *
+     * @param compare Use null to remove the current comparator function, if any.
+     */
+    sortSubgroups(compare: null): this;
+    /**
+     * Sets the subgroup comparator to the specified function and returns this chord layout.
+     *
+     * If the subgroup comparator is non-null, it is used to sort the subgroups corresponding to matrix[i][0 … n - 1]
+     * for a given group i by their total outflow. See also d3.ascending and d3.descending.
+     *
+     * @param compare A comparator function, e.g. d3.ascending or d3.descending.
+     */
+    sortSubgroups(compare: (a: number, b: number) => number): this;
+
+    /**
+     * Returns the current chord comparator, which defaults to null.
+     */
+    sortChords(): ((a: number, b: number) => number) | null;
+    /**
+     * Removes the current chord comparator and returns this chord layout.
+     *
+     * @param compare Use null to remove the current comparator function, if any.
+     */
+    sortChords(compare: null): this;
+    /**
+     * Sets the chord comparator to the specified function and returns this chord layout.
+     *
+     * If the chord comparator is non-null, it is used to sort the chords by their combined flow; this only affects the z-order of the chords.
+     * See also d3.ascending and d3.descending.
+     *
+     * @param compare A comparator function, e.g. d3.ascending or d3.descending.
+     */
+    sortChords(compare: (a: number, b: number) => number): this;
+}
+
+/**
+ * Constructs a new chord diagram layout with the default settings.
+ */
+export function chord(): ChordLayout;
+
+/**
+ * See https://observablehq.com/@d3/directed-chord-diagram.
+ */
+export function chordDirected(): ChordLayout;
+
+/**
+ * ...
+ */
+export function chordTranspose(): ChordLayout;
+
+// ---------------------------------------------------------------------
+// Ribbon
+// ---------------------------------------------------------------------
+
+/**
+ * A minimal interface to support the default accessors used by RibbonGenerator for properties of
+ * source and target objects of a Ribbon.
+ *
+ * (Corresponds to ChordSubgroup)
+ */
+export interface RibbonSubgroup {
+    /**
+     * Start angle of the ribbon subgroup in radians
+     */
+    startAngle: number;
+    /**
+     * End angle of the ribbon subgroup in radians
+     */
+    endAngle: number;
+    /**
+     * Radius of the ribbon subgroup
+     */
+    radius: number;
+}
+
+/**
+ * A minimal interface to support the default source and target accessors used by RibbonGenerator.
+ * (Corresponds to Chord)
+ */
+export interface Ribbon {
+    /**
+     * Ribbon subgroup constituting the source of the Ribbon
+     */
+    source: RibbonSubgroup;
+    /**
+     * Ribbon subgroup constituting the target of the Ribbon
+     */
+    target: RibbonSubgroup;
+}
+
+/**
+ *
+ * A ribbon generator to support rendering of chords in a chord diagram.
+ *
+ * The first generic corresponds to the type of the "this" context within which the ribbon generator and its accessor functions will be invoked.
+ *
+ * The second generic corresponds to the datum type representing a chord for which the ribbon is to be generated. The default type is Ribbon.
+ *
+ * The third generic corresponds to the datum type of the chord subgroup, i.e. source or target of the cord. The default type is RibbonSubgroup.
+ */
+export interface RibbonGenerator<This, RibbonDatum, RibbonSubgroupDatum> {
+    /**
+     * Generates a ribbon for the given arguments.
+     *
+     * IMPORTANT: If the ribbon generator has been configured with a rendering context,
+     * then the ribbon is rendered to this context as a sequence of path method calls and this function returns void.
+     *
+     * The "this" context within which this function is invoked, will be the context within which the accessor methods of the generator are invoked.
+     * All arguments passed into this function, will be passed to the accessor functions of the generator.
+     *
+     * @param d The datum representing the chord for which the ribbon is to be generated.
+     */
+    (this: This, d: RibbonDatum, ...args: any[]): void;
+    /**
+     * Generates a ribbon for the given arguments.
+     *
+     * IMPORTANT: If the rendering context of the ribbon generator is null,
+     * then the ribbon is returned as a path data string.
+     *
+     * The "this" context within which this function is invoked, will be the context within which the accessor methods of the generator are invoked.
+     * All arguments passed into this function, will be passed to the accessor functions of the generator.
+     *
+     * @param d The datum representing the chord for which the ribbon is to be generated.
+     */
+    (this: This, d: RibbonDatum, ...args: any[]): string | null;
+
+    /**
+     * Returns the current source accessor, which defaults to a function returning the "source" property of the first argument passed into the accessor.
+     */
+    source(): (this: This, d: RibbonDatum, ...args: any[]) => RibbonSubgroupDatum;
+    /**
+     * Sets the source accessor to the specified function and returns this ribbon generator.
+     *
+     * @param source An accessor function returning the source datum of the chord. The accessor function is invoked in the same "this" context as the generator was invoked in and
+     * receives the same arguments that were passed into the ribbon generator.
+     */
+    source(source: (this: This, d: RibbonDatum, ...args: any[]) => RibbonSubgroupDatum): this;
+
+    /**
+     * Returns the current target accessor, which defaults to a function returning the "target" property of the first argument passed into the accessor.
+     */
+    target(): (this: This, d: RibbonDatum, ...args: any[]) => RibbonSubgroupDatum;
+    /**
+     * Sets the target accessor to the specified function and returns this ribbon generator.
+     *
+     * @param target An accessor function returning the target datum of the chord. The accessor function is invoked in the same "this" context as the generator was invoked in and
+     * receives the same arguments that were passed into the ribbon generator.
+     */
+    target(target: (this: This, d: RibbonDatum, ...args: any[]) => RibbonSubgroupDatum): this;
+
+    /**
+     * Returns the current radius accessor, which defaults to a function returning the "radius" property (assumed to be a number) of the source or
+     * target object returned by the source or target accessor, respectively.
+     */
+    radius(): (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number;
+    /**
+     * Sets the radius to a fixed number and returns this ribbon generator.
+     *
+     * @param radius A fixed numeric value for the radius.
+     */
+    radius(radius: number): this;
+    /**
+     * Sets the radius accessor to the specified function and returns this ribbon generator.
+     *
+     * @param radius An accessor function which is invoked for the source and target of the chord. The accessor function is invoked in the same "this" context as the generator was invoked in and
+     * receives as the first argument the source or target object returned by the respective source or target accessor function of the generator.
+     * It is also passed any additional arguments that were passed into the generator, with the exception of the first element representing the chord datum itself.
+     * The function returns the radius value.
+     */
+    radius(radius: (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number): this;
+
+    /**
+     * Returns the current source radius accessor, which defaults to a function returning the "radius" property (assumed to be a number) of the source or
+     * target object returned by the source or target accessor, respectively.
+     */
+    sourceRadius(): (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number;
+    /**
+     * Sets the source radius to a fixed number and returns this ribbon generator.
+     *
+     * @param radius A fixed numeric value for the source radius.
+     */
+    sourceRadius(radius: number): this;
+    /**
+     * Sets the source radius accessor to the specified function and returns this ribbon generator.
+     *
+     * @param radius An accessor function which is invoked for the source and target of the chord. The accessor function is invoked in the same "this" context as the generator was invoked in and
+     * receives as the first argument the source or target object returned by the respective source or target accessor function of the generator.
+     * It is also passed any additional arguments that were passed into the generator, with the exception of the first element representing the chord datum itself.
+     * The function returns the source radius value.
+     */
+    sourceRadius(radius: (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number): this;
+
+    /**
+     * Returns the current target radius accessor, which defaults to a function returning the "radius" property (assumed to be a number) of the source or
+     * target object returned by the source or target accessor, respectively.
+     */
+    targetRadius(): (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number;
+    /**
+     * Sets the target radius to a fixed number and returns this ribbon generator.
+     *
+     * @param radius A fixed numeric value for the target radius.
+     */
+    targetRadius(radius: number): this;
+    /**
+     * Sets the target radius accessor to the specified function and returns this ribbon generator.
+     *
+     * @param radius An accessor function which is invoked for the source and target of the chord. The accessor function is invoked in the same "this" context as the generator was invoked in and
+     * receives as the first argument the source or target object returned by the respective source or target accessor function of the generator.
+     * It is also passed any additional arguments that were passed into the generator, with the exception of the first element representing the chord datum itself.
+     * The function returns the target radius value.
+     */
+    targetRadius(radius: (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number): this;
+
+    /**
+     * Returns the current start angle accessor, which defaults to a function returning the "startAngle" property (assumed to be a number in radians) of the source or
+     * target object returned by the source or target accessor, respectively.
+     */
+    startAngle(): (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number;
+    /**
+     * Sets the start angle to a fixed number in radians and returns this ribbon generator.
+     *
+     * @param angle A fixed numeric value for the start angle in radians.
+     */
+    startAngle(angle: number): this;
+    /**
+     * Sets the start angle accessor to the specified function and returns this ribbon generator.
+     *
+     * @param angle An accessor function which is invoked for the source and target of the chord. The accessor function is invoked in the same "this" context as the generator was invoked in and
+     * receives as the first argument the source or target object returned by the respective source or target accessor function of the generator.
+     * It is also passed any additional arguments that were passed into the generator, with the exception of the first element representing the chord datum itself.
+     * The function returns the start angle in radians.
+     */
+    startAngle(angle: (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number): this;
+
+    /**
+     * Returns the current end angle accessor, which defaults to a function returning the "endAngle" property (assumed to be a number in radians) of the source or
+     * target object returned by the source or target accessor, respectively.
+     */
+    endAngle(): (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number;
+    /**
+     * Sets the end angle to a fixed number in radians and returns this ribbon generator.
+     *
+     * @param angle A fixed numeric value for the end angle in radians.
+     */
+    endAngle(angle: number): this;
+    /**
+     * Sets the end angle accessor to the specified function and returns this ribbon generator.
+     *
+     * @param angle An accessor function which is invoked for the source and target of the chord. The accessor function is invoked in the same "this" context as the generator was invoked in and
+     * receives as the first argument the source or target object returned by the respective source or target accessor function of the generator.
+     * It is also passed any additional arguments that were passed into the generator, with the exception of the first element representing the chord datum itself.
+     * The function returns the end angle in radians.
+     */
+    endAngle(angle: (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number): this;
+
+    /**
+     * Returns the current pad angle accessor, which defaults to a function returning 0.
+     */
+    padAngle(): (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number;
+    /**
+     * Sets the pad angle to a fixed number in radians and returns this ribbon generator.
+     *
+     * @param angle A fixed numeric value for the pad angle in radians.
+     */
+    padAngle(angle: number): this;
+    /**
+     * Sets the pad angle accessor to the specified function and returns this ribbon generator.
+     *
+     * @param angle An accessor function which is invoked for the source and target of the chord. The accessor function is invoked in the same "this" context as the generator was invoked in and
+     * receives as the first argument the source or target object returned by the respective source or target accessor function of the generator.
+     * It is also passed any additional arguments that were passed into the generator, with the exception of the first element representing the chord datum itself.
+     * The function returns the pad angle in radians.
+     */
+    padAngle(angle: (this: This, d: RibbonSubgroupDatum, ...args: any[]) => number): this;
+
+    /**
+     * Returns the current rendering context, which defaults to null.
+     */
+    context(): CanvasRenderingContext2D | null;
+    /**
+     * Sets the rendering context and returns this ribbon generator.
+     *
+     * If the context is not null, then the generated ribbon is rendered to this context as a sequence of path method calls.
+     *
+     * @param context The rendering context.
+     */
+    context(context: CanvasRenderingContext2D): this;
+    /**
+     * Sets the rendering context to null and returns this ribbon generator.
+     *
+     * A path data string representing the generated ribbon will be returned when the generator is invoked with data. See also d3-path.
+     *
+     * @param context null, to remove rendering context.
+     */
+    context(context: null): this;
+}
+
+/**
+ * Creates a new ribbon generator with the default settings.
+ */
+export function ribbon(): RibbonGenerator<any, Ribbon, RibbonSubgroup>;
+/**
+ * Creates a new ribbon generator with the default settings.
+ *
+ * Accessor functions must be configured for the ribbon generator, should the datum types differ from the defaults.
+ *
+ * The first generic corresponds to the datum type representing a chord for which the ribbon is to be generated. The default type is Chord.
+ *
+ * The second generic corresponds to the datum type of the chord subgroup, i.e. source or target of the cord. The default type is ChordSubgroup.
+ */
+export function ribbon<Datum, SubgroupDatum>(): RibbonGenerator<any, Datum, SubgroupDatum>;
+/**
+ * Creates a new ribbon generator with the default settings.
+ *
+ * Accessor functions must be configured for the ribbon generator, should the datum types differ from the defaults.
+ *
+ * The first generic corresponds to the type of the "this" context within which the ribbon generator and its accessor functions will be invoked.
+ *
+ * The second generic corresponds to the datum type representing a chord for which the ribbon is to be generated. The default type is Chord.
+ *
+ * The third generic corresponds to the datum type of the chord subgroup, i.e. source or target of the cord. The default type is ChordSubgroup.
+ */
+export function ribbon<This, Datum, SubgroupDatum>(): RibbonGenerator<This, Datum, SubgroupDatum>;

node_modules/@types/d3-chord/package.json

@@ -0,0 +1,65 @@
+{
+  "_from": "@types/d3-chord@*",
+  "_id": "@types/d3-chord@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-3nHsLY7lImpZlM/hrPeDqqW2a+lRXXoHsG54QSurDGihZAIE/doQlohs0evoHrWOJqXyn4A4xbSVEtXnMEZZiw==",
+  "_location": "/@types/d3-chord",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-chord@*",
+    "name": "@types/d3-chord",
+    "escapedName": "@types%2fd3-chord",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-chord/-/d3-chord-2.0.0.tgz",
+  "_shasum": "8d7085e2828418f2c5087e512f276559499bacfd",
+  "_spec": "@types/d3-chord@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-chord module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-chord",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-chord"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "c6d91027dd6ddac803cc4ec0a6e2d88e2a2aad1ceffec36e95076881731e0ac8",
+  "version": "2.0.0"
+}

node_modules/@types/d3-color/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-color/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-color`
+
+# Summary
+This package contains type definitions for D3JS d3-color module (https://github.com/d3/d3-color/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-color.
+
+### Additional Details
+ * Last updated: Tue, 17 Nov 2020 23:36:35 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), [Hugues Stefanski](https://github.com/ledragon), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-color/index.d.ts

@@ -0,0 +1,623 @@
+// Type definitions for D3JS d3-color module 2.0
+// Project: https://github.com/d3/d3-color/, https://d3js.org/d3-color
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
+//                 Hugues Stefanski <https://github.com/ledragon>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Last module patch version validated against: 2.0.0
+
+// ---------------------------------------------------------------------------
+// Shared Type Definitions and Interfaces
+// ---------------------------------------------------------------------------
+
+/**
+ * Type allowing for color objects from a specified color space
+ */
+export type ColorSpaceObject = RGBColor | HSLColor | LabColor | HCLColor | CubehelixColor;
+
+/**
+ * A helper interface of methods common to color objects (including colors defined outside the d3-color standard module,
+ * e.g. in d3-hsv). This interface
+ */
+export interface ColorCommonInstance {
+    /**
+     * Returns true if and only if the color is displayable on standard hardware.
+     * For example, this returns false for an RGB color if any channel value is less than zero or greater than 255, or if the opacity is not in the range [0, 1].
+     */
+    displayable(): boolean;
+    /**
+     * Returns a string representing this color according to the CSS Object Model specification,
+     * such as rgb(247, 234, 186) or rgba(247, 234, 186, 0.2).
+     * If this color is not displayable, a suitable displayable color is returned instead.
+     * For example, RGB channel values greater than 255 are clamped to 255.
+     */
+    toString(): string;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1. The behavior of this method is dependent on the implementing color space.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1. The behavior of this method is dependent on the implementing color space.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB equivalent of this color. For RGB colors, that’s "this".
+     */
+    rgb(): RGBColor;
+    /**
+     * Returns a hexadecimal string representing this color.
+     * If this color is not displayable, a suitable displayable color is returned instead.
+     * For example, RGB channel values greater than 255 are clamped to 255.
+     */
+    hex(): string;
+}
+
+/**
+ * A Color object which serves as a base class for
+ * colorspace-specific sub-class implementations.
+ */
+export interface Color {
+    /**
+     * Returns true if and only if the color is displayable on standard hardware.
+     * For example, this returns false for an RGB color if any channel value is less than zero or greater than 255, or if the opacity is not in the range [0, 1].
+     */
+    displayable(): boolean; // Note: While this method is used in prototyping for colors of specific colorspaces, it should not be called directly, as 'this.rgb' would not be implemented on Color
+    /**
+     * Returns a string representing this color according to the CSS Object Model specification,
+     * such as rgb(247, 234, 186) or rgba(247, 234, 186, 0.2).
+     * If this color is not displayable, a suitable displayable color is returned instead.
+     * For example, RGB channel values greater than 255 are clamped to 255.
+     */
+    toString(): string; // Note: While this method is used in prototyping for colors of specific colorspaces, it should not be called directly, as 'this.rgb' would not be implemented on Color
+    /**
+     * Returns a hexadecimal string representing this color in RGB space, such as #f7eaba.
+     * If this color is not displayable, a suitable displayable color is returned instead.
+     * For example, RGB channel values greater than 255 are clamped to 255.
+     */
+    formatHex(): string;
+    /**
+     * Returns a string representing this color according to the CSS Color Module Level 3 specification, such as hsl(257, 50%, 80%) or hsla(257, 50%, 80%, 0.2).
+     * If this color is not displayable, a suitable displayable color is returned instead by clamping S and L channel values to the interval [0, 100].
+     */
+    formatHsl(): string;
+    /**
+     * Returns a string representing this color according to the CSS Object Model specification, such as rgb(247, 234, 186) or rgba(247, 234, 186, 0.2).
+     * If this color is not displayable, a suitable displayable color is returned instead by clamping RGB channel values to the interval [0, 255].
+     */
+    formatRgb(): string;
+    /**
+     * @deprecated Use color.formatHex.
+     */
+    hex(): string;
+}
+
+/**
+ * A Color factory object, which may also be used with instanceof to test if an object is a color instance.
+ */
+export interface ColorFactory extends Function {
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an RGB or HSL color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): RGBColor | HSLColor | null;
+    /**
+     * Converts the provided color instance and returns an RGB or HSL color.
+     *
+     * @param color A permissible color space instance.
+     */
+    (color: ColorSpaceObject | ColorCommonInstance): RGBColor | HSLColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: Color;
+}
+
+/**
+ * An RGB color object.
+ */
+export interface RGBColor extends Color {
+    /**
+     * Value of red channel
+     */
+    r: number;
+    /**
+     * Value of green channel
+     */
+    g: number;
+    /**
+     * Value of blue channel
+     */
+    b: number;
+    /**
+     * Opacity value
+     */
+    opacity: number;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB equivalent of this color.
+     */
+    rgb(): this;
+    /**
+     * Returns a copy of this color.
+     *
+     * @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
+     */
+    copy(values?: { r?: number; g?: number; b?: number; opacity?: number }): this;
+}
+
+/**
+ * An RGB color factory object, which may also be used with instanceof to test if an object
+ * is an RGB color instance.
+ */
+export interface RGBColorFactory extends Function {
+    /**
+     * Constructs a new RGB color based on the specified channel values and opacity.
+     *
+     * @param r Red channel value.
+     * @param g Green channel value.
+     * @param b Blue channel value.
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (r: number, g: number, b: number, opacity?: number): RGBColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an RGB color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): RGBColor;
+    /**
+     * Converts the provided color instance and returns an RGB color. The color instance is converted to the RGB color space using color.rgb.
+     * Note that unlike color.rgb this method always returns a new instance, even if color is already an RGB color.
+     *
+     * @param color A permissible color space instance.
+     */
+    (color: ColorSpaceObject | ColorCommonInstance): RGBColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: RGBColor;
+}
+
+/**
+ * An HSL color object.
+ */
+export interface HSLColor extends Color {
+    /**
+     * Hue channel value.
+     */
+    h: number;
+    /**
+     * Saturation channel value.
+     */
+    s: number;
+    /**
+     * Lightness channel value.
+     */
+    l: number;
+    /**
+     * Opacity value.
+     */
+    opacity: number;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB color equivalent of this color.
+     */
+    rgb(): RGBColor;
+    /**
+     * Returns a copy of this color.
+     *
+     * @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
+     */
+    copy(values?: { h?: number; s?: number; l?: number; opacity?: number }): this;
+}
+
+/**
+ * An HSL color factory object, which may also be used with instanceof to test if an object
+ * is an HSL color instance.
+ */
+export interface HSLColorFactory extends Function {
+    /**
+     * Constructs a new HSL color based on the specified channel values and opacity.
+     *
+     * @param h Hue channel value.
+     * @param s Saturation channel value.
+     * @param l Lightness channel value.
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (h: number, s: number, l: number, opacity?: number): HSLColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an HSL color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): HSLColor;
+    /**
+     * Converts the provided color instance and returns an HSL color.
+     * The color instance is converted to the RGB color space using color.rgb and then converted to HSL.
+     * (Colors already in the HSL color space skip the conversion to RGB.)
+     *
+     * @param color A permissible color space instance.
+     */
+    (color: ColorSpaceObject | ColorCommonInstance): HSLColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: HSLColor;
+}
+
+/**
+ * A Lab (CIELAB) color object.
+ */
+export interface LabColor extends Color {
+    /**
+     * Lightness typically in the range [0, 100].
+     */
+    l: number;
+    /**
+     * Position between red/magenta and green typically in [-160, +160].
+     */
+    a: number;
+    /**
+     * Position between yellow and blue typically in [-160, +160].
+     */
+    b: number;
+    /**
+     * Opacity value
+     */
+    opacity: number;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB color equivalent of this color.
+     */
+    rgb(): RGBColor;
+    /**
+     * Returns a copy of this color.
+     *
+     * @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
+     */
+    copy(values?: { l?: number; a?: number; b?: number; opacity?: number }): this;
+}
+
+/**
+ * A Lab (CIELAB) color factory object, which may also be used with instanceof to test if an object
+ * is a Lab color instance.
+ */
+export interface LabColorFactory extends Function {
+    /**
+     * Constructs a new CIELAB color based on the specified channel values and opacity.
+     *
+     * @param l Lightness typically in the range [0, 100].
+     * @param a Position between red/magenta and green typically in [-160, +160].
+     * @param b Position between yellow and blue typically in [-160, +160].
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (l: number, a: number, b: number, opacity?: number): LabColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning a Lab color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): LabColor;
+    /**
+     * Converts the provided color instance and returns a Lab color.
+     * The color instance is converted to the RGB color space using color.rgb and then converted to CIELAB.
+     * (Colors already in the Lab color space skip the conversion to RGB,
+     * and colors in the HCL color space are converted directly to CIELAB.)
+     *
+     * @param color A permissible color space instance.
+     */
+    (color: ColorSpaceObject | ColorCommonInstance): LabColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: LabColor;
+}
+
+/**
+ * A gray color factory for Lab (CIELAB) colors.
+ */
+export type GrayColorFactory =
+    /**
+     * Constructs a new CIELAB color with the specified l value and a = b = 0.
+     *
+     * @param l Lightness typically in the range [0, 100].
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (l: number, opacity?: number) => LabColor;
+
+/**
+ * An HCL (CIELCH) color object.
+ */
+export interface HCLColor extends Color {
+    /**
+     * Hue channel value typically in [0, 360).
+     */
+    h: number;
+    /**
+     * Chroma channel value typically in [0, 230].
+     */
+    c: number;
+    /**
+     * Luminance channel value typically in the range [0, 100].
+     */
+    l: number;
+    /**
+     * Opacity value
+     */
+    opacity: number;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB color equivalent of this color.
+     */
+    rgb(): RGBColor;
+    /**
+     * Returns a copy of this color.
+     *
+     * @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
+     */
+    copy(values?: { h?: number; c?: number; l?: number; opacity?: number }): this;
+}
+
+/**
+ * An HCL (CIELCH) color factory object, which may also be used with instanceof to test if an object
+ * is an HCL color instance.
+ */
+export interface HCLColorFactory extends Function {
+    /**
+     * Constructs a new HCL color based on the specified channel values and opacity.
+     *
+     * @param h Hue channel value typically in [0, 360).
+     * @param c Chroma channel value typically in [0, 230].
+     * @param l Luminance channel value typically in the range [0, 100].
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (h: number, c: number, l: number, opacity?: number): HCLColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an HCL color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): HCLColor;
+    /**
+     * Converts the provided color instance and returns an HCL color.
+     * The color instance is converted to the RGB color space using color.rgb and then converted to HCL.
+     * (Colors already in the HCL color space skip the conversion to RGB,
+     * and colors in the Lab color space are converted directly to HCL.)
+     *
+     * @param color A permissible color space instance.
+     */
+    (color: ColorSpaceObject | ColorCommonInstance): HCLColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: HCLColor;
+}
+
+/**
+ * An LCH (CIELCH) color factory function to create an HCL color object.
+ */
+export interface LCHColorFactory {
+    /**
+     * Constructs a new HCL color based on the specified channel values and opacity.
+     *
+     * @param l Luminance channel value typically in the range [0, 100].
+     * @param c Chroma channel value typically in [0, 230].
+     * @param h Hue channel value typically in [0, 360).
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (l: number, c: number, h: number, opacity?: number): HCLColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an HCL color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): HCLColor;
+    /**
+     * Converts the provided color instance and returns an HCL color.
+     * The color instance is converted to the RGB color space using color.rgb and then converted to HCL.
+     * (Colors already in the HCL color space skip the conversion to RGB,
+     * and colors in the Lab color space are converted directly to HCL.)
+     *
+     * @param color A permissible color space instance.
+     */
+    (color: ColorSpaceObject | ColorCommonInstance): HCLColor;
+}
+
+/**
+ * Dave Green’s Cubehelix color object.
+ */
+export interface CubehelixColor extends Color {
+    /**
+     * Hue channel value.
+     */
+    h: number;
+    /**
+     * Saturation channel value.
+     */
+    s: number;
+    /**
+     * Lightness channel value.
+     */
+    l: number;
+    /**
+     * Opacity value.
+     */
+    opacity: number;
+    /**
+     * Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much brighter the returned color should be.
+     */
+    brighter(k?: number): this;
+    /**
+     * Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
+     * If k is not specified, it defaults to 1.
+     *
+     * @param k A color space dependent number to determine, how much darker the returned color should be.
+     */
+    darker(k?: number): this;
+    /**
+     * Returns the RGB color equivalent of this color.
+     */
+    rgb(): RGBColor;
+    /**
+     * Returns a copy of this color.
+     *
+     * @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
+     */
+    copy(values?: { h?: number; s?: number; l?: number; opacity?: number }): this;
+}
+
+/**
+ * A color factory object for Dave Green's Cubehelix colors, which may also be used with instanceof to test if an object
+ * is a Cubehelix color instance.
+ */
+export interface CubehelixColorFactory extends Function {
+    /**
+     * Constructs a new Cubehelix color based on the specified channel values and opacity.
+     *
+     * @param h Hue channel value.
+     * @param s Saturation channel value.
+     * @param l Lightness channel value.
+     * @param opacity Optional opacity value, defaults to 1.
+     */
+    (h: number, s: number, l: number, opacity?: number): CubehelixColor;
+    /**
+     * Parses the specified CSS Color Module Level 3 specifier string, returning an Cubehelix color.
+     * If the specifier was not valid, null is returned.
+     *
+     * @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
+     */
+    (cssColorSpecifier: string): CubehelixColor;
+    /**
+     * Converts the provided color instance and returns a Cubehelix color.
+     * The color instance is specified, it is converted to the RGB color space using color.rgb and then converted to Cubehelix.
+     * (Colors already in the Cubehelix color space skip the conversion to RGB.)
+     *
+     * @param color A permissible color space instance.
+     */
+    (color: ColorSpaceObject | ColorCommonInstance): CubehelixColor;
+    /**
+     * Prototype of the factory, which can be used for instanceof testing
+     */
+    readonly prototype: CubehelixColor;
+}
+
+// --------------------------------------------------------------------------
+// Color object factories
+// --------------------------------------------------------------------------
+
+/**
+ * A Color factory object, which may also be used with instanceof to test if an object is a color instance.
+ */
+export const color: ColorFactory;
+
+/**
+ * An RGB color factory object, which may also be used with instanceof to test if an object
+ * is an RGB color instance.
+ */
+export const rgb: RGBColorFactory;
+
+/**
+ * An HSL color factory object, which may also be used with instanceof to test if an object
+ * is an HSL color instance.
+ */
+export const hsl: HSLColorFactory;
+
+/**
+ * A Lab (CIELAB) color factory object, which may also be used with instanceof to test if an object
+ * is a Lab color instance.
+ */
+export const lab: LabColorFactory;
+
+/**
+ * A gray color factory for Lab (CIELAB) colors.
+ */
+export const gray: GrayColorFactory;
+
+/**
+ * An HCL (CIELCH) color factory object, which may also be used with instanceof to test if an object
+ * is an HCL color instance.
+ */
+export const hcl: HCLColorFactory;
+
+/**
+ * An LCH (CIELCH) color factory function to create an HCL color object.
+ */
+export const lch: LCHColorFactory;
+
+/**
+ * A color factory object for Dave Green's Cubehelix colors, which may also be used with instanceof to test if an object
+ * is a Cubehelix color instance.
+ */
+export const cubehelix: CubehelixColorFactory;

node_modules/@types/d3-color/package.json

@@ -0,0 +1,74 @@
+{
+  "_from": "@types/d3-color@*",
+  "_id": "@types/d3-color@2.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-u7LTCL7RnaavFSmob2rIAJLNwu50i6gFwY9cHFr80BrQURYQBRkJ+Yv47nA3Fm7FeRhdWTiVTeqvSeOuMAOzBQ==",
+  "_location": "/@types/d3-color",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-color@*",
+    "name": "@types/d3-color",
+    "escapedName": "@types%2fd3-color",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3",
+    "/@types/d3-interpolate"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-2.0.1.tgz",
+  "_shasum": "570ea7f8b853461301804efa52bd790a640a26db",
+  "_spec": "@types/d3-color@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "denisname",
+      "url": "https://github.com/denisname"
+    },
+    {
+      "name": "Hugues Stefanski",
+      "url": "https://github.com/ledragon"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-color module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-color",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-color"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "3251bfbf910cbe82bce73848c691d5022f25a80161c20f9f647bf8a714633289",
+  "version": "2.0.1"
+}

node_modules/@types/d3-contour/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-contour/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-contour`
+
+# Summary
+This package contains type definitions for d3-contour (https://d3js.org/d3-contour/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-contour.
+
+### Additional Details
+ * Last updated: Wed, 30 Sep 2020 00:21:14 GMT
+ * Dependencies: [@types/geojson](https://npmjs.com/package/@types/geojson), [@types/d3-array](https://npmjs.com/package/@types/d3-array)
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Hugues Stefanski](https://github.com/Ledragon), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-contour/index.d.ts

@@ -0,0 +1,271 @@
+// Type definitions for d3-contour 2.0
+// Project: https://d3js.org/d3-contour/
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Hugues Stefanski <https://github.com/Ledragon>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+// Last module patch version validated against: 2.0.0
+
+import { MultiPolygon } from 'geojson';
+import { ThresholdNumberArrayGenerator, ThresholdCountGenerator } from 'd3-array';
+
+/**
+ * An extended GeoJSON MultiPolygon representing a contour.
+ */
+export interface ContourMultiPolygon extends MultiPolygon {
+    /**
+     * Threshold value of the contour.
+     */
+    value: number;
+}
+
+/**
+ * A contour generator which computes contour polygons by applying marching squares to a rectangular array of numeric values.
+ *
+ * For each threshold value, the contour generator constructs a GeoJSON MultiPolygon geometry object representing the area
+ * where the input values are greater than or equal to the threshold value.
+ * The geometry is in planar coordinates, where ⟨i + 0.5, j + 0.5⟩ corresponds to element i + jn in the input values array.
+ *
+ */
+export interface Contours {
+    /**
+     * Computes the contours for the given array of values, returning an array of GeoJSON MultiPolygon geometry objects.
+     * Each geometry object represents the area where the input values are greater than or equal to the corresponding threshold value;
+     * the threshold value for each geometry object is exposed as geometry.value.
+     *
+     * The returned geometry objects are typically passed to d3.geoPath to display,
+     * using null or d3.geoIdentity as the associated projection
+     *
+     * @param values Array of input values. The input values must be an array of length n×m where [n, m] is the contour generator’s size;
+     * furthermore, each values[i + jn] must represent the value at the position ⟨i, j⟩.
+     */
+    (values: number[]): ContourMultiPolygon[];
+
+    /**
+     * Computes a single contour, returning a GeoJSON MultiPolygon geometry object.
+     * This geometry object represents the area where the input values are greater than or equal to the given threshold value;
+     * the threshold value for the geometry object is exposed as geometry.value.
+     *
+     * @param values  Array of input values. The input values must be an array of length n×m where [n, m] is the contour generator’s size;
+     * furthermore, each values[i + jn] must represent the value at the position ⟨i, j⟩.
+     * @param threshold Threshold value.
+     */
+    contour(values: number[], threshold: number): ContourMultiPolygon;
+
+    /**
+     * Return the expected size of the input values grid, which defaults to [1,1].
+     */
+    size(): [number, number];
+    /**
+     * Sets the expected size of the input values grid to the contour generator and returns the contour generator.
+     *
+     * @param size Size of the input values grid specified as an array [n, m]
+     * where n is the number of columns in the grid and m is the number of rows; n and m must be positive integers.
+     */
+    size(size: [number, number]): this;
+
+    /**
+     * Returns the current smoothing flag, which defaults to true.
+     */
+    smooth(): boolean;
+    /**
+     * Sets whether or not the generated contour polygons are smoothed using linear interpolation and returns the contour generator.
+     *
+     * @param smooth Flag to enable linear interpolation. The default is "true".
+     */
+    smooth(smooth: boolean): this;
+
+    /**
+     * Returns the current threshold generator, which by default implements Sturges’ formula.
+     */
+    thresholds(): ThresholdCountGenerator<number> | ThresholdNumberArrayGenerator<number>;
+    /**
+     * Sets the threshold generator to use the specified count and returns this contour generator.
+     * The input values’ extent will be uniformly divided into approximately count bins.
+     *
+     * @param count Expected number of threshold bins.
+     */
+    thresholds(count: number): this;
+    /**
+     * Sets the threshold generator to the specified array and returns this contour generator.
+     *
+     * Thresholds are defined as an array of values [x0, x1, …].
+     * The first generated contour corresponds to the area where the input values are greater than or equal to x0;
+     * the second contour corresponds to the area where the input values are greater than or equal to x1, and so on.
+     * Thus, there is exactly one generated MultiPolygon geometry object for each specified threshold value;
+     * the threshold value is exposed as geometry.value.
+     *
+     * @param thresholds Array of thresholds to use.
+     */
+    thresholds(thresholds: number[]): this;
+    /**
+     * Sets the threshold generator to the specified function and returns this contour generator.
+     *
+     * Thresholds are defined as an array of values [x0, x1, …].
+     * The first generated contour corresponds to the area where the input values are greater than or equal to x0;
+     * the second contour corresponds to the area where the input values are greater than or equal to x1, and so on.
+     * Thus, there is exactly one generated MultiPolygon geometry object for each specified threshold value;
+     * the threshold value is exposed as geometry.value.
+     *
+     * @param thresholds A threshold generator function. The threshold generator function is passed the array of input values
+     * as its argument and returns either an array of calculated thresholds, or the count of thresholds to use.
+     */
+    thresholds(thresholds: ThresholdCountGenerator<number> | ThresholdNumberArrayGenerator<number>): this;
+}
+
+/**
+ * Construct a new contour generator with the default settings.
+ */
+export function contours(): Contours;
+
+/**
+ * A contour generator for density estimates.
+ *
+ * The generic refers to the data type of an element in the data array
+ * used with the density contour generator. If omitted, the default setting assumes that,
+ * the elements of the data array used with the density contour generator are two-element arrays.
+ * The first element corresponds to the x-dimension, the second to the y-dimension.
+ */
+export interface ContourDensity<Datum = [number, number]> {
+    /**
+     * Estimates the density contours for the given array of data, returning an array of GeoJSON MultiPolygon geometry objects.
+     * Each geometry object represents the area where the estimated number of points per square pixel is greater than or equal to
+     * the corresponding threshold value; the threshold value for each geometry object is exposed as geometry.value.
+     * The returned geometry objects are typically passed to d3.geoPath to display, using null or d3.geoIdentity as the associated projection.
+     * See also d3.contours.
+     *
+     * The x- and y-coordinate for each data point are computed using density.x and density.y.
+     * The generated contours are only accurate within the estimator’s defined size.
+     *
+     * @param data Array of input data.
+     */
+    (data: Datum[]): ContourMultiPolygon[];
+
+    /**
+     * Returns the current x-coordinate accessor.
+     * The default x-coordinate accessor is a functions which accepts as input a two-element array of numbers
+     * and returns the element at index 0.
+     */
+    x(): (d: Datum) => number;
+    /**
+     * Sets the x-coordinate accessor and returns the density contour estimator.
+     *
+     * @param x An x-coordinate accessor function, which accepts as input an element of the input data array and returns the
+     * x-coordinate.
+     */
+    x(x: (d: Datum) => number): this;
+
+    /**
+     * Returns the current y-coordinate accessor.
+     * The default y-coordinate accessor is a functions which accepts as input a two-element array of numbers
+     * and returns the element at index 1.
+     */
+    y(): (d: Datum) => number;
+    /**
+     * Sets the y-coordinate accessor and returns the density contour estimator.
+     *
+     * @param y An y-coordinate accessor function, which accepts as input an element of the input data array and returns the
+     * y-coordinate.
+     */
+    y(y: (d: Datum) => number): this;
+
+    /**
+     * Returns the current point weight accessor.
+     */
+    weight(): (d: Datum) => number;
+
+    /**
+     * Sets the point weight accessor and returns the density contour estimator.
+     *
+     * @param weight A point weight accessor function.
+     */
+    weight(weight: (d: Datum) => number): this;
+
+    /**
+     * Returns the current size, which defaults to [960, 500].
+     */
+    size(): [number, number];
+    /**
+     * Sets the size of the density estimator to the specified bounds and returns the density contour estimator.
+     *
+     * @param size The size is specified as an array [width, height], where width is the maximum x-value and height is the maximum y-value.
+     */
+    size(size: [number, number]): this;
+
+    /**
+     * Returns the current cell size, which defaults to 4.
+     */
+    cellSize(): number;
+    /**
+     * Sets the size of individual cells in the underlying bin grid to the specified positive integer and returns the density contour estimator.
+     *
+     * The cell size is rounded down to the nearest power of two. Smaller cells produce more detailed contour polygons, but are more expensive to compute.
+     *
+     * @param cellSize Cell size, a positive integer.
+     */
+    cellSize(cellSize: number): this;
+
+    /**
+     * Returns the current threshold generator, which by default generates about twenty nicely-rounded density thresholds.
+     */
+    thresholds(): ThresholdCountGenerator<number> | ThresholdNumberArrayGenerator<number>;
+    /**
+     * Sets the threshold generator to use the specified count and returns this density contour estimator.
+     * Approximately count uniformly-spaced nicely-rounded thresholds will be generated.
+     *
+     * @param count Expected number of thresholds.
+     */
+    thresholds(count: number): this;
+    /**
+     * Sets the threshold generator to the specified array and returns this density contour estimator.
+     *
+     * Thresholds are defined as an array of values [x0, x1, …]. The first generated density contour corresponds to the area
+     * where the estimated density is greater than or equal to x0; the second contour corresponds to the area
+     * where the estimated density is greater than or equal to x1, and so on.
+     * Thus, there is exactly one generated MultiPolygon geometry object for each specified threshold value;
+     *  the threshold value is exposed as geometry.value. The first value x0 should typically be greater than zero.
+     *
+     * @param thresholds Array of thresholds to use.
+     */
+    thresholds(thresholds: number[]): this;
+    /**
+     * Sets the threshold generator to the specified function and returns this density contour estimator.
+     *
+     * Thresholds are defined as an array of values [x0, x1, …]. The first generated density contour corresponds to the area
+     * where the estimated density is greater than or equal to x0; the second contour corresponds to the area
+     * where the estimated density is greater than or equal to x1, and so on.
+     * Thus, there is exactly one generated MultiPolygon geometry object for each specified threshold value;
+     *  the threshold value is exposed as geometry.value. The first value x0 should typically be greater than zero.
+     *
+     * @param thresholds A threshold generator function. The threshold generator function is passed the array of input values
+     * as its argument and returns either an array of calculated thresholds, or the count of thresholds to use.
+     */
+    thresholds(thresholds: ThresholdCountGenerator<number> | ThresholdNumberArrayGenerator<number>): this;
+
+    /**
+     * Returns the current bandwidth, which defaults to 20.4939….
+     */
+    bandwidth(): number;
+    /**
+     * Sets the bandwidth (the standard deviation) of the Gaussian kernel and returns the density contour estimator.
+     *
+     * @param bandwidth Bandwidth (the standard deviation) of the Gaussian kernel.
+     * The specified bandwidth is currently rounded to the nearest supported value by this implementation, and must be nonnegative.
+     */
+    bandwidth(bandwidth: number): this;
+}
+
+/**
+ * Construct a new contour generator for density estimates.
+ *
+ * The generic refers to the data type of an element in the data array
+ * used with the density contour generator. If omitted, the default setting assumes that,
+ * the elements of the data array used with the density contour generator are two-element arrays.
+ * The first element corresponds to the x-dimension, the second to the y-dimension.
+ *
+ * Important: ensure that the x- and y-accessor functions are configured to
+ * match the data type used for the generic Datum.
+ */
+export function contourDensity<Datum = [number, number]>(): ContourDensity<Datum>;

node_modules/@types/d3-contour/package.json

@@ -0,0 +1,64 @@
+{
+  "_from": "@types/d3-contour@*",
+  "_id": "@types/d3-contour@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-PS9UO6zBQqwHXsocbpdzZFONgK1oRUgWtjjh/iz2vM06KaXLInLiKZ9e3OLBRerc1cU2uJYpO+8zOnb6frvCGQ==",
+  "_location": "/@types/d3-contour",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-contour@*",
+    "name": "@types/d3-contour",
+    "escapedName": "@types%2fd3-contour",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-contour/-/d3-contour-2.0.0.tgz",
+  "_shasum": "6e079f281b29a8df3fcbd3ec193f2cf1d0b4a584",
+  "_spec": "@types/d3-contour@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Hugues Stefanski",
+      "url": "https://github.com/Ledragon"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {
+    "@types/d3-array": "*",
+    "@types/geojson": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for d3-contour",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-contour",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-contour"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "7123b12c344628c9bd63511b686c01fbb7150af62d10d94b3e9a5796d7909e24",
+  "version": "2.0.0"
+}

node_modules/@types/d3-delaunay/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-delaunay/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-delaunay`
+
+# Summary
+This package contains type definitions for d3-delaunay (https://github.com/d3/d3-delaunay).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-delaunay.
+
+### Additional Details
+ * Last updated: Wed, 30 Sep 2020 16:01:38 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Bradley Odell](https://github.com/BTOdell), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-delaunay/index.d.ts

@@ -0,0 +1,315 @@
+// Type definitions for d3-delaunay 5.3
+// Project: https://github.com/d3/d3-delaunay
+// Definitions by: Bradley Odell <https://github.com/BTOdell>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/**
+ * Delaunay triangulation
+ */
+export class Delaunay<P> {
+    /**
+     * Returns the Delaunay triangulation for the given flat array [x0, y0, x1, y1, …] of points.
+     */
+    constructor(points: ArrayLike<number>);
+
+    /**
+     * Returns the Delaunay triangulation for the given array or iterable of points where each point is an array in the form: [x, y].
+     */
+    static from(points: ArrayLike<Delaunay.Point>|Iterable<Delaunay.Point>): Delaunay<Delaunay.Point>;
+    /**
+     * Returns the Delaunay triangulation for the given array or iterable of points.
+     * Otherwise, the getX and getY functions are invoked for each point in order, and must return the respective x- and y-coordinate for each point.
+     * If that is specified, the functions getX and getY are invoked with that as this.
+     * (See Array.from for reference.)
+     */
+    static from<P>(points: ArrayLike<P>|Iterable<P>,
+                   getX: Delaunay.GetCoordinate<P, ArrayLike<P>|Iterable<P>>,
+                   getY: Delaunay.GetCoordinate<P, ArrayLike<P>|Iterable<P>>,
+                   that?: any): Delaunay<P>;
+
+    /**
+     * The coordinates of the points as an array [x0, y0, x1, y1, ...].
+     * Typically, this is a Float64Array, however you can use any array-like type in the constructor.
+     */
+    points: ArrayLike<number>;
+
+    /**
+     * The halfedge indices as an Int32Array [j0, j1, ...].
+     * For each index 0 <= i < halfedges.length, there is a halfedge from triangle vertex j = halfedges[i] to triangle vertex i.
+     */
+    halfedges: Int32Array;
+
+    /**
+     * An Int32Array of point indexes that form the convex hull in counterclockwise order.
+     * If the points are collinear, returns them ordered.
+     */
+    hull: Uint32Array;
+
+    /**
+     * The triangle vertex indices as an Uint32Array [i0, j0, k0, i1, j1, k1, ...].
+     * Each contiguous triplet of indices i, j, k forms a counterclockwise triangle.
+     * The coordinates of the triangle's points can be found by going through 'points'.
+     */
+    triangles: Uint32Array;
+
+    /**
+     * The incoming halfedge indexes as a Int32Array [e0, e1, e2, ...].
+     * For each point i, inedges[i] is the halfedge index e of an incoming halfedge.
+     * For coincident points, the halfedge index is -1; for points on the convex hull, the incoming halfedge is on the convex hull; for other points, the choice of incoming halfedge is arbitrary.
+     */
+    inedges: Int32Array;
+
+    /**
+     * Returns the index of the input point that is closest to the specified point ⟨x, y⟩.
+     * The search is started at the specified point i. If i is not specified, it defaults to zero.
+     */
+    find(x: number, y: number, i?: number): number;
+
+    /**
+     * Returns an iterable over the indexes of the neighboring points to the specified point i.
+     * The iterable is empty if i is a coincident point.
+     */
+    neighbors(i: number): IterableIterator<number>;
+
+    /**
+     * Renders the edges of the Delaunay triangulation to an SVG path string.
+     */
+    render(): string;
+    /**
+     * Renders the edges of the Delaunay triangulation to the specified context.
+     * The specified context must implement the context.moveTo and context.lineTo methods from the CanvasPathMethods API.
+     */
+    render(context: Delaunay.MoveContext & Delaunay.LineContext): void;
+
+    /**
+     * Renders the convex hull of the Delaunay triangulation to an SVG path string.
+     */
+    renderHull(): string;
+    /**
+     * Renders the convex hull of the Delaunay triangulation to the specified context.
+     * The specified context must implement the context.moveTo and context.lineTo methods from the CanvasPathMethods API.
+     */
+    renderHull(context: Delaunay.MoveContext & Delaunay.LineContext): void;
+
+    /**
+     * Renders triangle i of the Delaunay triangulation to an SVG path string.
+     */
+    renderTriangle(i: number): string;
+    /**
+     * Renders triangle i of the Delaunay triangulation to the specified context.
+     * The specified context must implement the context.moveTo, context.lineTo and context.closePath methods from the CanvasPathMethods API.
+     */
+    renderTriangle(i: number, context: Delaunay.MoveContext & Delaunay.LineContext & Delaunay.ClosableContext): void;
+
+    /**
+     * Renders the input points of the Delaunay triangulation to an SVG path string as circles with radius 2.
+     */
+    renderPoints(): string;
+    /**
+     * Renders the input points of the Delaunay triangulation to an SVG path string as circles with the specified radius.
+     */
+    renderPoints(context: undefined, radius: number): string;
+    /**
+     * Renders the input points of the Delaunay triangulation to the specified context as circles with the specified radius.
+     * If radius is not specified, it defaults to 2.
+     * The specified context must implement the context.moveTo and context.arc methods from the CanvasPathMethods API.
+     */
+    renderPoints(context: Delaunay.MoveContext & Delaunay.ArcContext, radius?: number): void;
+
+    /**
+     * Returns the closed polygon [[x0, y0], [x1, y1], ..., [x0, y0]] representing the convex hull.
+     */
+    hullPolygon(): Delaunay.Polygon;
+
+    /**
+     * Returns the closed polygon [[x0, y0], [x1, y1], [x2, y2], [x0, y0]] representing the triangle i.
+     */
+    trianglePolygon(i: number): Delaunay.Triangle;
+    /**
+     * Returns an iterable over the polygons for each triangle, in order.
+     */
+    trianglePolygons(): IterableIterator<Delaunay.Triangle>;
+
+    /**
+     * Updates the triangulation after the points have been modified in-place.
+     */
+    update(): this;
+
+    /**
+     * Returns the Voronoi diagram for the associated points.
+     * When rendering, the diagram will be clipped to the specified bounds = [xmin, ymin, xmax, ymax].
+     * If bounds is not specified, it defaults to [0, 0, 960, 500].
+     * See To Infinity and Back Again for an interactive explanation of Voronoi cell clipping.
+     */
+    voronoi(bounds?: Delaunay.Bounds): Voronoi<P>;
+}
+
+export namespace Delaunay {
+    /**
+     * A point represented as an array tuple [x, y].
+     */
+    type Point = number[];
+
+    /**
+     * A closed polygon [[x0, y0], [x1, y1], [x2, y2], [x0, y0]] representing a triangle.
+     */
+    type Triangle = Point[];
+
+    /**
+     * A closed polygon [[x0, y0], [x1, y1], ..., [x0, y0]].
+     */
+    type Polygon = Point[];
+
+    /**
+     * A rectangular area [x, y, width, height].
+     */
+    type Bounds = number[];
+
+    /**
+     * A function to extract a x- or y-coordinate from the specified point.
+     */
+    type GetCoordinate<P, PS> = (point: P, i: number, points: PS) => number;
+
+    /**
+     * An interface for the rect() method of the CanvasPathMethods API.
+     */
+    interface RectContext {
+        /**
+         * rect() method of the CanvasPathMethods API.
+         */
+        rect(x: number, y: number, width: number, height: number): void;
+    }
+
+    /**
+     * An interface for the moveTo() method of the CanvasPathMethods API.
+     */
+    interface MoveContext {
+        /**
+         * moveTo() method of the CanvasPathMethods API.
+         */
+        moveTo(x: number, y: number): void;
+    }
+
+    /**
+     * An interface for the lineTo() method of the CanvasPathMethods API.
+     */
+    interface LineContext {
+        /**
+         * lineTo() method of the CanvasPathMethods API.
+         */
+        lineTo(x: number, y: number): void;
+    }
+
+    /**
+     * An interface for the arc() method of the CanvasPathMethods API.
+     */
+    interface ArcContext {
+        /**
+         * arc() method of the CanvasPathMethods API.
+         */
+        arc(x: number, y: number, radius: number,
+            startAngle: number, endAngle: number,
+            counterclockwise?: boolean): void;
+    }
+
+    /**
+     * An interface for the closePath() method of the CanvasPathMethods API.
+     */
+    interface ClosableContext {
+        /**
+         * closePath() method of the CanvasPathMethods API.
+         */
+        closePath(): void;
+    }
+}
+
+/**
+ * Voronoi regions
+ */
+export class Voronoi<P> {
+    /**
+     * The Voronoi diagram’s associated Delaunay triangulation.
+     */
+    delaunay: Delaunay<P>;
+
+    /**
+     * The circumcenters of the Delaunay triangles [cx0, cy0, cx1, cy1, ...].
+     * Each contiguous pair of coordinates cx, cy is the circumcenter for the corresponding triangle.
+     * These circumcenters form the coordinates of the Voronoi cell polygons.
+     */
+    circumcenters: Float64Array;
+
+    /**
+     * An array [vx0, vy0, wx0, wy0, ...] where each non-zero quadruple describes an open (infinite) cell
+     * on the outer hull, giving the directions of two open half-lines.
+     */
+    vectors: Float64Array;
+
+    /**
+     * The bounds of the viewport [xmin, ymin, xmax, ymax] for rendering the Voronoi diagram.
+     * These values only affect the rendering methods (voronoi.render, voronoi.renderBounds, cell.render).
+     */
+    xmin: number;
+    ymin: number;
+    xmax: number;
+    ymax: number;
+
+    /**
+     * Returns true if the cell with the specified index i contains the specified point ⟨x, y⟩.
+     * (This method is not affected by the associated Voronoi diagram’s viewport bounds.)
+     */
+    contains(i: number, x: number, y: number): boolean;
+
+    /**
+     * Returns an iterable over the indexes of the cells that share a common edge with the specified cell i.
+     * Voronoi neighbors are always neighbors on the Delaunay graph, but the converse is false when the common edge has been clipped out by the Voronoi diagram’s viewport.
+     */
+    neighbors(i: number): Iterable<number>;
+
+    /**
+     * Renders the mesh of Voronoi cells to an SVG path string.
+     */
+    render(): string;
+    /**
+     * Renders the mesh of Voronoi cells to the specified context.
+     * The specified context must implement the context.moveTo and context.lineTo methods from the CanvasPathMethods API.
+     */
+    render(context: Delaunay.MoveContext & Delaunay.LineContext): void;
+
+    /**
+     * Renders the viewport extent to an SVG path string.
+     */
+    renderBounds(): string;
+    /**
+     * Renders the viewport extent to the specified context.
+     * The specified context must implement the context.rect method from the CanvasPathMethods API.
+     * Equivalent to context.rect(voronoi.xmin, voronoi.ymin, voronoi.xmax - voronoi.xmin, voronoi.ymax - voronoi.ymin).
+     */
+    renderBounds(context: Delaunay.RectContext): void;
+
+    /**
+     * Renders the cell with the specified index i to an SVG path string.
+     */
+    renderCell(i: number): string;
+    /**
+     * Renders the cell with the specified index i to the specified context.
+     * The specified context must implement the context.moveTo, context.lineTo, and context.closePath methods from the CanvasPathMethods API.
+     */
+    renderCell(i: number, context: Delaunay.MoveContext & Delaunay.LineContext & Delaunay.ClosableContext): void;
+
+    /**
+     * Returns an iterable over the non-empty polygons for each cell, with the cell index as property.
+     */
+    cellPolygons(): IterableIterator<Delaunay.Polygon & { index: number }>;
+
+    /**
+     * Returns the convex, closed polygon [[x0, y0], [x1, y1], ..., [x0, y0]] representing the cell for the specified point i.
+     */
+    cellPolygon(i: number): Delaunay.Polygon;
+
+    /**
+     * Updates the Voronoi diagram and underlying triangulation after the points have been modified in-place — useful for Lloyd’s relaxation.
+     */
+    update(): this;
+}

node_modules/@types/d3-delaunay/package.json

@@ -0,0 +1,57 @@
+{
+  "_from": "@types/d3-delaunay@*",
+  "_id": "@types/d3-delaunay@5.3.0",
+  "_inBundle": false,
+  "_integrity": "sha512-gJYcGxLu0xDZPccbUe32OUpeaNtd1Lz0NYJtko6ZLMyG2euF4pBzrsQXms67LHZCDFzzszw+dMhSL/QAML3bXw==",
+  "_location": "/@types/d3-delaunay",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-delaunay@*",
+    "name": "@types/d3-delaunay",
+    "escapedName": "@types%2fd3-delaunay",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-delaunay/-/d3-delaunay-5.3.0.tgz",
+  "_shasum": "416169bb5c67a510c87b55d092a404fcab49def3",
+  "_spec": "@types/d3-delaunay@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Bradley Odell",
+      "url": "https://github.com/BTOdell"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for d3-delaunay",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-delaunay",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-delaunay"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "28792a7ce88d8b1dff264016993cdf6420cec30827d8ee93f9d6fc874835d525",
+  "version": "5.3.0"
+}

node_modules/@types/d3-dispatch/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-dispatch/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-dispatch`
+
+# Summary
+This package contains type definitions for D3JS d3-dispatch module (https://github.com/d3/d3-dispatch/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-dispatch.
+
+### Additional Details
+ * Last updated: Wed, 30 Sep 2020 21:08:21 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-dispatch/index.d.ts

@@ -0,0 +1,75 @@
+// Type definitions for D3JS d3-dispatch module 2.0
+// Project: https://github.com/d3/d3-dispatch/, https://d3js.org/d3-dispatch
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Last module patch version validated against: 2.0.0
+
+export interface Dispatch<T extends object> {
+    /**
+     * Like `function.apply`, invokes each registered callback for the specified type,
+     * passing the callback the specified arguments, with `that` as the `this` context.
+     *
+     * @param type A specified event type.
+     * @param that The `this` context for the callback.
+     * @param args Additional arguments to be passed to the callback.
+     * @throws "unknown type" on unknown event type.
+     */
+    apply(type: string, that?: T, args?: any[]): void;
+
+    /**
+     * Like `function.call`, invokes each registered callback for the specified type,
+     * passing the callback the specified arguments, with `that` as the `this` context.
+     * See dispatch.apply for more information.
+     *
+     * @param type A specified event type.
+     * @param that The `this` context for the callback.
+     * @param args Additional arguments to be passed to the callback.
+     * @throws "unknown type" on unknown event type.
+     */
+     call(type: string, that?: T, ...args: any[]): void;
+
+    /**
+     * Returns a copy of this dispatch object.
+     * Changes to this dispatch do not affect the returned copy and vice versa.
+     */
+    copy(): Dispatch<T>;
+
+    /**
+     * Returns the callback for the specified typenames, if any.
+     * If multiple typenames are specified, the first matching callback is returned.
+     *
+     * @param types An event typename.
+     * @param callback A callback.
+     */
+    on(typenames: string): ((this: T, ...args: any[]) => void) | undefined;
+    /**
+     * Removes the callback for the specified typenames.
+     * To remove all callbacks for a given name `foo`, say `dispatch.on(".foo", null).`
+     *
+     * @param types An event typename.
+     */
+    on(typenames: string, callback: null): this;
+    /**
+     * Adds the callback for the specified typenames.
+     * The callback is registered for the specified (fully-qualified) typenames.
+     * If a callback was already registered for the given typenames,
+     * the existing callback is removed before the new callback is added.
+     *
+     * @param types An event typename.
+     * @param callback A callback.
+     */
+    on(typenames: string, callback: (this: T, ...args: any[]) => void): this;
+}
+
+/**
+ * Creates a new dispatch for the specified event types. Each type is a string, such as "start" or "end".
+ *
+ * @param types The event types.
+ * @throws "illegal type" on empty string or duplicated event types.
+ */
+export function dispatch<T extends object>(...types: string[]): Dispatch<T>;

node_modules/@types/d3-dispatch/package.json

@@ -0,0 +1,69 @@
+{
+  "_from": "@types/d3-dispatch@*",
+  "_id": "@types/d3-dispatch@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-Sh0KW6z/d7uxssD7K4s4uCSzlEG/+SP+U47q098NVdOfFvUKNTvKAIV4XqjxsUuhE/854ARAREHOxkr9gQOCyg==",
+  "_location": "/@types/d3-dispatch",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-dispatch@*",
+    "name": "@types/d3-dispatch",
+    "escapedName": "@types%2fd3-dispatch",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-dispatch/-/d3-dispatch-2.0.0.tgz",
+  "_shasum": "1f8803041b73b81f2c751e026b7bb63dd5f24ce0",
+  "_spec": "@types/d3-dispatch@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "denisname",
+      "url": "https://github.com/denisname"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-dispatch module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-dispatch",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-dispatch"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "b4c60d7052afc30d4c515de55d0ef8b87680866b4245f23ac4cc9b1be1f128a0",
+  "version": "2.0.0"
+}

node_modules/@types/d3-drag/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-drag/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-drag`
+
+# Summary
+This package contains type definitions for D3JS d3-drag module (https://github.com/d3/d3-drag/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-drag.
+
+### Additional Details
+ * Last updated: Wed, 30 Sep 2020 21:08:21 GMT
+ * Dependencies: [@types/d3-selection](https://npmjs.com/package/@types/d3-selection)
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-drag/index.d.ts

@@ -0,0 +1,398 @@
+// Type definitions for D3JS d3-drag module 2.0
+// Project: https://github.com/d3/d3-drag/, https://d3js.org/d3-drag
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+// Last module patch version validated against: 2.0.0
+
+import { Selection, ValueFn } from 'd3-selection';
+
+// --------------------------------------------------------------------------
+// Shared Type Definitions and Interfaces
+// --------------------------------------------------------------------------
+
+/**
+ * DraggedElementBaseType serves as an alias for the 'minimal' data type which can be selected
+ * without 'd3-drag' (and related code in 'd3-selection') trying to use properties internally which would otherwise not
+ * be supported.
+ */
+export type DraggedElementBaseType = Element;
+
+/**
+ * Container element type usable for mouse/touch functions
+ */
+export type DragContainerElement = HTMLElement | SVGSVGElement | SVGGElement; // HTMLElement includes HTMLCanvasElement
+
+/**
+ * The subject datum should at a minimum expose x and y properties, so that the relative position
+ * of the subject and the pointer can be preserved during the drag gesture.
+ */
+export interface SubjectPosition {
+    /**
+     * x-coordinate
+     */
+    x: number;
+    /**
+     * y-coordinate
+     */
+    y: number;
+}
+
+/**
+ * A D3 Drag Behavior
+ *
+ * The first generic refers to the type of element to be dragged.
+ * The second generic refers to the type of the datum of the dragged element.
+ * The third generic refers to the type of the drag behavior subject.
+ *
+ * The subject of a drag gesture represents the thing being dragged.
+ * It is computed when an initiating input event is received,
+ * such as a mousedown or touchstart, immediately before the drag gesture starts.
+ * The subject is then exposed as event.subject on subsequent drag events for this gesture.
+ *
+ * The default subject is the datum of the element in the originating selection (see drag)
+ * that received the initiating input event; if this datum is undefined,
+ * an object representing the coordinates of the pointer is created.
+ * When dragging circle elements in SVG, the default subject is thus the datum of the circle being dragged.
+ * With Canvas, the default subject is the canvas element’s datum (regardless of where on the canvas you click).
+ * In this case, a custom subject accessor would be more appropriate,
+ * such as one that picks the closest circle to the mouse within a given search radius.
+ */
+export interface DragBehavior<GElement extends DraggedElementBaseType, Datum, Subject> extends Function {
+    /**
+     * Applies the drag behavior to the selected elements.
+     * This function is typically not invoked directly, and is instead invoked via selection.call.
+     *
+     * For details see: {@link https://github.com/d3/d3-drag#_drag}
+     *
+     * @param selection A D3 selection of elements.
+     * @param args Optional arguments to be passed in.
+     */
+    (selection: Selection<GElement, Datum, any, any>, ...args: any[]): void;
+
+    /**
+     * Returns the current container accessor function.
+     */
+    container(): ValueFn<GElement, Datum, DragContainerElement>;
+    /**
+     * Sets the container accessor to the specified function and returns the drag behavior.
+     *
+     * The container of a drag gesture determines the coordinate system of subsequent drag events, affecting event.x and event.y.
+     * The element returned by the container accessor is subsequently passed to d3.pointer to determine the local coordinates of the pointer.
+     *
+     * The default container accessor returns the parent node of the element in the originating selection (see drag)
+     * that received the initiating input event. This is often appropriate when dragging SVG or HTML elements,
+     * since those elements are typically positioned relative to a parent. For dragging graphical elements with a Canvas,
+     * however, you may want to redefine the container as the initiating element itself, using "this" in the accessor
+     * function.
+     *
+     * @param accessor A container accessor function which is evaluated for each selected element,
+     * in order, being passed the current datum (d), the current index (i), and the current group (nodes),
+     * with this as the current DOM element. The function returns the container element.
+     */
+    container(accessor: ValueFn<GElement, Datum, DragContainerElement>): this;
+    /**
+     * Sets the container accessor to the specified object and returns the drag behavior.
+     *
+     * The container of a drag gesture determines the coordinate system of subsequent drag events, affecting event.x and event.y.
+     * The element returned by the container accessor is subsequently passed to d3.pointer to determine the local coordinates of the pointer.
+     *
+     * The default container accessor returns the parent node of the element in the originating selection (see drag)
+     * that received the initiating input event. This is often appropriate when dragging SVG or HTML elements,
+     * since those elements are typically positioned relative to a parent. For dragging graphical elements with a Canvas,
+     * however, you may want to redefine the container as the initiating element itself, such as drag.container(canvas).
+     *
+     * @param container Container element for the drag gesture.
+     */
+    container(container: DragContainerElement): this;
+
+    /**
+     * Returns the current filter function.
+     */
+    filter(): (this: GElement, event: any, d: Datum) => boolean;
+    /**
+     * Sets the event filter to the specified filter function and returns the drag behavior.
+     *
+     * If the filter returns falsey, the initiating event is ignored and no drag gesture is started.
+     * Thus, the filter determines which input events are ignored. The default filter ignores mousedown events on secondary buttons,
+     * since those buttons are typically intended for other purposes, such as the context menu.
+     *
+     * @param filterFn A filter function which is evaluated for each selected element,
+     * in order, being passed the current event (event) and datum d, with the this context as the current DOM element.
+     * The function returns a boolean value.
+     */
+    filter(filterFn: (this: GElement, event: any, d: Datum) => boolean): this;
+
+    /**
+     * Returns the current touch support detector, which defaults to a function returning true,
+     * if the "ontouchstart" event is supported on the current element.
+     */
+    touchable(): ValueFn<GElement, Datum, boolean>;
+    /**
+     * Sets the touch support detector to the specified boolean value and returns the drag behavior.
+     *
+     * Touch event listeners are only registered if the detector returns truthy for the corresponding element when the drag behavior is applied.
+     * The default detector works well for most browsers that are capable of touch input, but not all; Chrome’s mobile device emulator, for example,
+     * fails detection.
+     *
+     * @param touchable A boolean value. true when touch event listeners should be applied to the corresponding element, otherwise false.
+     */
+    touchable(touchable: boolean): this;
+    /**
+     * Sets the touch support detector to the specified function and returns the drag behavior.
+     *
+     * Touch event listeners are only registered if the detector returns truthy for the corresponding element when the drag behavior is applied.
+     * The default detector works well for most browsers that are capable of touch input, but not all; Chrome’s mobile device emulator, for example,
+     * fails detection.
+     *
+     * @param touchable A touch support detector function, which returns true when touch event listeners should be applied to the corresponding element.
+     * The function is evaluated for each selected element to which the drag behavior was applied, in order, being passed the current datum (d),
+     * the current index (i), and the current group (nodes), with this as the current DOM element. The function returns a boolean value.
+     */
+    touchable(touchable: ValueFn<GElement, Datum, boolean>): this;
+
+    /**
+     *  Returns the current subject accessor functions.
+     */
+    subject(): (this: GElement, event: any, d: Datum) => Subject;
+    /**
+     * Sets the subject accessor to the specified function and returns the drag behavior.
+     *
+     * The subject of a drag gesture represents the thing being dragged.
+     * It is computed when an initiating input event is received,
+     * such as a mousedown or touchstart, immediately before the drag gesture starts.
+     * The subject is then exposed as event.subject on subsequent drag events for this gesture.
+     *
+     * The default subject is the datum of the element in the originating selection (see drag)
+     * that received the initiating input event; if this datum is undefined,
+     * an object representing the coordinates of the pointer is created.
+     * When dragging circle elements in SVG, the default subject is thus the datum of the circle being dragged.
+     * With Canvas, the default subject is the canvas element’s datum (regardless of where on the canvas you click).
+     * In this case, a custom subject accessor would be more appropriate,
+     * such as one that picks the closest circle to the mouse within a given search radius.
+     *
+     * The subject of a drag gesture may not be changed after the gesture starts.
+     *
+     * During the evaluation of the subject accessor, event is a beforestart drag event.
+     * Use event.sourceEvent to access the initiating input event and event.identifier to access the touch identifier.
+     * The event.x and event.y are relative to the container, and are computed using d3.pointer.
+     *
+     * @param accessor An extent accessor function which is evaluated for each selected element,
+     * in order, being passed the current event (`event`) and datum `d`, with the `this` context as the current DOM element.
+     * The returned subject should be an object that exposes x and y properties,
+     * so that the relative position of the subject and the pointer can be preserved during the drag gesture.
+     * If the subject is null or undefined, no drag gesture is started for this pointer;
+     * however, other starting touches may yet start drag gestures.
+     */
+    subject(accessor: (this: GElement, event: any, d: Datum) => Subject): this;
+
+    /**
+     * Return the current click distance threshold, which defaults to zero.
+     */
+    clickDistance(): number;
+    /**
+     * Set the maximum distance that the mouse can move between mousedown and mouseup that will trigger
+     * a subsequent click event. If at any point between mousedown and mouseup the mouse is greater than or equal to
+     * distance from its position on mousedown, the click event following mouseup will be suppressed.
+     *
+     * @param distance The distance threshold between mousedown and mouseup measured in client coordinates (event.clientX and event.clientY).
+     * The default is zero.
+     */
+    clickDistance(distance: number): this;
+
+    /**
+     * Return the first currently-assigned listener matching the specified typenames, if any.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace.
+     * Each typename is a type, optionally followed by a period (.) and a name, such as "drag.foo"" and "drag.bar";
+     * the name allows multiple listeners to be registered for the same type. The type must be one of the following:
+     * start (after a new pointer becomes active [on mousedown or touchstart]), drag (after an active pointer moves [on mousemove or touchmove], or
+     * end (after an active pointer becomes inactive [on mouseup, touchend or touchcancel].)
+     */
+    on(typenames: string): ((this: GElement, event: any, d: Datum) => void) | undefined;
+    /**
+     * Remove the current event listeners for the specified typenames, if any, return the drag behavior.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace.
+     * Each typename is a type, optionally followed by a period (.) and a name, such as "drag.foo"" and "drag.bar";
+     * the name allows multiple listeners to be registered for the same type. The type must be one of the following:
+     * start (after a new pointer becomes active [on mousedown or touchstart]), drag (after an active pointer moves [on mousemove or touchmove], or
+     * end (after an active pointer becomes inactive [on mouseup, touchend or touchcancel].)
+     * @param listener Use null to remove the listener.
+     */
+    on(typenames: string, listener: null): this;
+    /**
+     * Set the event listener for the specified typenames and return the drag behavior.
+     * If an event listener was already registered for the same type and name,
+     * the existing listener is removed before the new listener is added.
+     * When a specified event is dispatched, each listener will be invoked with the same context and arguments as selection.on listeners.
+     *
+     * Changes to registered listeners via drag.on during a drag gesture do not affect the current drag gesture.
+     * Instead, you must use event.on, which also allows you to register temporary event listeners for the current drag gesture.
+     * Separate events are dispatched for each active pointer during a drag gesture.
+     * For example, if simultaneously dragging multiple subjects with multiple fingers, a start event is dispatched for each finger,
+     * even if both fingers start touching simultaneously.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace.
+     * Each typename is a type, optionally followed by a period (.) and a name, such as "drag.foo"" and "drag.bar";
+     * the name allows multiple listeners to be registered for the same type. The type must be one of the following:
+     * start (after a new pointer becomes active [on mousedown or touchstart]), drag (after an active pointer moves [on mousemove or touchmove], or
+     * end (after an active pointer becomes inactive [on mouseup, touchend or touchcancel].)
+     * @param listener An event listener function which is evaluated for each selected element,
+     * in order, being passed the current event (event) and datum d, with the this context as the current DOM element.
+     */
+    on(typenames: string, listener: (this: GElement, event: any, d: Datum) => void): this;
+}
+
+/**
+ * Creates a new drag behavior. The returned behavior, drag, is both an object and a function, and is
+ * typically applied to selected elements via selection.call.
+ *
+ * Use this signature when using the default subject accessor.
+ *
+ * The first generic refers to the type of element to be dragged.
+ * The second generic refers to the type of the datum of the dragged element.
+ */
+export function drag<GElement extends DraggedElementBaseType, Datum>(): DragBehavior<GElement, Datum, Datum | SubjectPosition>;
+/**
+ * Creates a new drag behavior. The returned behavior, drag, is both an object and a function, and is
+ * typically applied to selected elements via selection.call.
+ *
+ * Use this signature when using a custom subject accessor.
+ *
+ * The first generic refers to the type of element to be dragged.
+ * The second generic refers to the type of the datum of the dragged element.
+ * The third generic refers to the type of the drag behavior subject.
+ */
+export function drag<GElement extends DraggedElementBaseType, Datum, Subject>(): DragBehavior<GElement, Datum, Subject>;
+
+/**
+ * D3 Drag event
+ *
+ * The first generic refers to the type of element to be dragged.
+ * The second generic refers to the type of the datum of the dragged element.
+ * The third generic refers to the type of the drag behavior subject.
+ */
+export interface D3DragEvent<GElement extends DraggedElementBaseType, Datum, Subject> {
+    /**
+     * The DragBehavior associated with the event
+     */
+    target: DragBehavior<GElement, Datum, Subject>;
+    /**
+     * The event type for the DragEvent
+     */
+    type: 'start' | 'drag' | 'end' | string;  // Leave failsafe string type for cases like 'drag.foo'
+    /**
+     * The drag subject, defined by drag.subject.
+     */
+    subject: Subject;
+    /**
+     * The new x-coordinate of the subject, relative to the container
+     */
+    x: number;
+    /**
+     * The new y-coordinate of the subject, relative to the container
+     */
+    y: number;
+    /**
+     * The change in x-coordinate since the previous drag event.
+     */
+    dx: number;
+    /**
+     * The change in y-coordinate since the previous drag event.
+     */
+    dy: number;
+    /**
+     * The string “mouse”, or a numeric touch identifier.
+     */
+    identifier: 'mouse' | number;
+    /**
+     * The number of currently active drag gestures (on start and end, not including this one).
+     *
+     * The event.active field is useful for detecting the first start event and the last end event
+     * in a sequence of concurrent drag gestures: it is zero when the first drag gesture starts,
+     * and zero when the last drag gesture ends.
+     */
+    active: number;
+    /**
+     * The underlying input event, such as mousemove or touchmove.
+     */
+    sourceEvent: any;
+    /**
+     * Return the first currently-assigned listener matching the specified typenames, if any.
+     *
+     * Equivalent to drag.on, but only applies to the current drag gesture. Before the drag gesture starts,
+     * a copy of the current drag event listeners is made. This copy is bound to the current drag gesture
+     * and modified by event.on. This is useful for temporary listeners that only receive events for the current drag gesture.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace.
+     * Each typename is a type, optionally followed by a period (.) and a name, such as "drag.foo"" and "drag.bar";
+     * the name allows multiple listeners to be registered for the same type. The type must be one of the following:
+     * start (after a new pointer becomes active [on mousedown or touchstart]), drag (after an active pointer moves [on mousemove or touchmove], or
+     * end (after an active pointer becomes inactive [on mouseup, touchend or touchcancel].)
+     */
+    on(typenames: string): ((this: GElement, event: any, d: Datum) => void) | undefined;
+    /**
+     * Remove the current event listeners for the specified typenames, if any, return the drag behavior.
+     *
+     * Equivalent to drag.on, but only applies to the current drag gesture. Before the drag gesture starts,
+     * a copy of the current drag event listeners is made. This copy is bound to the current drag gesture
+     * and modified by event.on. This is useful for temporary listeners that only receive events for the current drag gesture.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace.
+     * Each typename is a type, optionally followed by a period (.) and a name, such as "drag.foo"" and "drag.bar";
+     * the name allows multiple listeners to be registered for the same type. The type must be one of the following:
+     * start (after a new pointer becomes active [on mousedown or touchstart]), drag (after an active pointer moves [on mousemove or touchmove], or
+     * end (after an active pointer becomes inactive [on mouseup, touchend or touchcancel].)
+     * @param listener Use null to remove the listener.
+     */
+    on(typenames: string, listener: null): this;
+    /**
+     * Set the event listener for the specified typenames and return the drag behavior.
+     * If an event listener was already registered for the same type and name,
+     * the existing listener is removed before the new listener is added.
+     * When a specified event is dispatched, each listener will be invoked with the same context and arguments as selection.on listeners.
+     *
+     * Equivalent to drag.on, but only applies to the current drag gesture. Before the drag gesture starts,
+     * a copy of the current drag event listeners is made. This copy is bound to the current drag gesture
+     * and modified by event.on. This is useful for temporary listeners that only receive events for the current drag gesture.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace.
+     * Each typename is a type, optionally followed by a period (.) and a name, such as "drag.foo"" and "drag.bar";
+     * the name allows multiple listeners to be registered for the same type. The type must be one of the following:
+     * start (after a new pointer becomes active [on mousedown or touchstart]), drag (after an active pointer moves [on mousemove or touchmove], or
+     * end (after an active pointer becomes inactive [on mouseup, touchend or touchcancel].)
+     * @param listener An event listener function which is evaluated for each selected element,
+     * in order, being passed the current event (event) and datum d, with the this context as the current DOM element.
+     */
+    on(typenames: string, listener: (this: GElement, event: any, d: Datum) => void): this;
+}
+
+/**
+ * Prevents native drag-and-drop and text selection on the specified window.
+ * As an alternative to preventing the default action of mousedown events,
+ * this method prevents undesirable default actions following mousedown. In supported browsers,
+ * this means capturing dragstart and selectstart events, preventing the associated default actions,
+ * and immediately stopping their propagation. In browsers that do not support selection events,
+ * the user-select CSS property is set to none on the document element.
+ * This method is intended to be called on mousedown, followed by d3.dragEnable on mouseup.
+ *
+ * @param window The window for which drag should be disabled.
+ */
+export function dragDisable(window: Window): void;
+
+/**
+ * Allows native drag-and-drop and text selection on the specified window; undoes the effect of d3.dragDisable.
+ * This method is intended to be called on mouseup, preceded by d3.dragDisable on mousedown.
+ * If noclick is true, this method also temporarily suppresses click events.
+ * The suppression of click events expires after a zero-millisecond timeout,
+ * such that it only suppress the click event that would immediately follow the current mouseup event, if any.
+ *
+ * @param window The window for which drag should be (re-)enabled.
+ * @param noClick An optional flag. If noclick is true, this method also temporarily suppresses click events.
+ */
+export function dragEnable(window: Window, noClick?: boolean): void;

node_modules/@types/d3-drag/package.json

@@ -0,0 +1,67 @@
+{
+  "_from": "@types/d3-drag@*",
+  "_id": "@types/d3-drag@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-VaUJPjbMnDn02tcRqsHLRAX5VjcRIzCjBfeXTLGe6QjMn5JccB5Cz4ztMRXMJfkbC45ovgJFWuj6DHvWMX1thA==",
+  "_location": "/@types/d3-drag",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-drag@*",
+    "name": "@types/d3-drag",
+    "escapedName": "@types%2fd3-drag",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-2.0.0.tgz",
+  "_shasum": "ef66acc422576fbe10b8bd66af45a9fb8525199a",
+  "_spec": "@types/d3-drag@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {
+    "@types/d3-selection": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-drag module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-drag",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-drag"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "a507a6ffc8633f02243959099bb6e35dd79621c66191c734cdb27672623cd1af",
+  "version": "2.0.0"
+}

node_modules/@types/d3-dsv/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-dsv/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-dsv`
+
+# Summary
+This package contains type definitions for D3JS d3-dsv module (https://github.com/d3/d3-dsv/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-dsv.
+
+### Additional Details
+ * Last updated: Thu, 14 Jan 2021 17:03:37 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-dsv/index.d.ts

@@ -0,0 +1,495 @@
+// Type definitions for D3JS d3-dsv module 2.0
+// Project: https://github.com/d3/d3-dsv/, https://d3js.org/d3-dsv
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+// Last module patch version validated against: 2.0.0
+
+// ------------------------------------------------------------------------------------------
+// Shared Types and Interfaces
+// ------------------------------------------------------------------------------------------
+
+/**
+ * An object representing a DSV parsed row with values represented as strings.
+ * When the DSV content is not well-structured and some column-values are missing, `undefined` is used as value.
+ */
+export type DSVRowString<Columns extends string = string> = {
+    [key in Columns]: string | undefined;
+};
+
+/**
+ * An object in raw format before parsing, that is with only string values.
+ * When the DSV content is not well-structured and some column-values are missing, `undefined` is used as value.
+ */
+export type DSVRaw<T extends object> = {
+    [key in keyof T]: string | undefined;
+};
+
+/**
+ * An object representing a DSV parsed row with values represented as an arbitrary datatype, depending
+ * on the performed parsed row mapping.
+ *
+ * @deprecated Use `object` instead.
+ */
+export interface DSVRowAny {
+    [key: string]: any;
+}
+
+/**
+ * An array object representing all deserialized rows. The array is enhanced with a property listing
+ * the names of the parsed columns.
+ */
+export interface DSVRowArray<Columns extends string = string> extends Array<DSVRowString<Columns>> {
+    /**
+     * List of column names.
+     */
+    columns: Columns[];
+}
+
+/**
+ * An array object representing all parsed rows. The array is enhanced with a property listing
+ * the names of the parsed columns.
+ */
+export interface DSVParsedArray<T> extends Array<T> {
+    /**
+     * List of column names.
+     */
+    columns: Array<keyof T>;
+}
+
+// ------------------------------------------------------------------------------------------
+// CSV Parsers and Formatters
+// ------------------------------------------------------------------------------------------
+
+// csvParse(...) ============================================================================
+
+/**
+ * Parses the specified string, which must be in the comma-separated values format, returning an array of objects representing the parsed rows.
+ *
+ * Unlike csvParseRows, this method requires that the first line of the CSV content contains a comma-separated list of column names;
+ * these column names become the attributes on the returned objects.
+ *
+ * The returned array also exposes a columns property containing the column names in input order (in contrast to Object.keys, whose iteration order is arbitrary).
+ *
+ * Equivalent to `dsvFormat(",").parse`.
+ * Note: requires unsafe-eval content security policy.
+ *
+ * @param csvString A string, which must be in the comma-separated values format.
+ */
+// tslint:disable-next-line:no-unnecessary-generics
+export function csvParse<Columns extends string>(csvString: string): DSVRowArray<Columns>;
+/**
+ * Parses the specified string, which must be in the comma-separated values format, returning an array of objects representing the parsed rows.
+ *
+ * Unlike csvParseRows, this method requires that the first line of the CSV content contains a comma-separated list of column names;
+ * these column names become the attributes on the returned objects.
+ *
+ * The returned array also exposes a columns property containing the column names in input order (in contrast to Object.keys, whose iteration order is arbitrary).
+ *
+ * Equivalent to `dsvFormat(",").parse`.
+ * Note: requires unsafe-eval content security policy.
+ *
+ * @param csvString A string, which must be in the comma-separated values format.
+ * @param row A row conversion function which is invoked for each row, being passed an object representing the current row (d),
+ * the index (i) starting at zero for the first non-header row, and the array of column names. If the returned value is null or undefined,
+ * the row is skipped and will be omitted from the array returned by dsv.parse; otherwise, the returned value defines the corresponding row object.
+ * In effect, row is similar to applying a map and filter operator to the returned rows.
+ */
+export function csvParse<ParsedRow extends object, Columns extends string>(
+    csvString: string,
+    row: (rawRow: DSVRowString<Columns>, index: number, columns: Columns[]) => ParsedRow | undefined | null
+): DSVParsedArray<ParsedRow>;
+
+// csvParseRows(...) ========================================================================
+
+/**
+ * Parses the specified string, which must be in the comma-separated values format, returning an array of arrays representing the parsed rows.
+ *
+ * Unlike csvParse, this method treats the header line as a standard row, and should be used whenever CSV content does not contain a header.
+ * Each row is represented as an array rather than an object. Rows may have variable length.
+ *
+ * If a row conversion function is not specified, field values are strings. For safety, there is no automatic conversion to numbers, dates, or other types.
+ * In some cases, JavaScript may coerce strings to numbers for you automatically (for example, using the + operator), but better is to specify a row conversion function.
+ *
+ * Equivalent to `dsvFormat(",").parseRows`.
+ *
+ * @param csvString A string, which must be in the comma-separated values format.
+ */
+export function csvParseRows(csvString: string): string[][];
+/**
+ * Parses the specified string, which must be in the comma-separated values format, returning an array of arrays representing the parsed rows.
+ *
+ * Unlike csvParse, this method treats the header line as a standard row, and should be used whenever CSV content does not contain a header.
+ * Each row is represented as an array rather than an object. Rows may have variable length.
+ *
+ * Equivalent to `dsvFormat(",").parseRows`.
+ *
+ * @param csvString A string, which must be in the comma-separated values format.
+ * @param row A row conversion function which is invoked for each row, being passed an array representing the current row (d), the index (i)
+ * starting at zero for the first row, and the array of column names. If the returned value is null or undefined,
+ * the row is skipped and will be omitted from the array returned by dsv.parse; otherwise, the returned value defines the corresponding row object.
+ * In effect, row is similar to applying a map and filter operator to the returned rows.
+ */
+export function csvParseRows<ParsedRow extends object>(
+    csvString: string,
+    row: (rawRow: string[], index: number) => ParsedRow | undefined | null
+): ParsedRow[];
+
+// csvFormat(...) ============================================================================
+
+/**
+ * Formats the specified array of object rows as comma-separated values, returning a string.
+ * This operation is the inverse of csvParse. Each row will be separated by a newline (\n),
+ * and each column within each row will be separated by the comma-delimiter.
+ * Values that contain either the comma-delimiter, a double-quote (") or a newline will be escaped using double-quotes.
+ *
+ * If columns is not specified, the list of column names that forms the header row is determined by the union of all properties on all objects in rows;
+ * the order of columns is nondeterministic.
+ *
+ * Equivalent to `dsvFormat(",").format`.
+ *
+ * @param rows Array of object rows.
+ * @param columns An array of strings representing the column names.
+ */
+export function csvFormat<T extends object>(rows: readonly T[], columns?: ReadonlyArray<keyof T>): string;
+
+// csvFormatBody(...) ============================================================================
+
+/**
+ * Equivalent to dsvFormat(",").formatBody.
+ *
+ * @param rows Array of object rows.
+ * @param columns An array of strings representing the column names.
+ */
+export function csvFormatBody<T extends object>(rows: readonly T[], columns?: ReadonlyArray<keyof T>): string;
+
+// csvFormatRows(...) ========================================================================
+
+/**
+ * Formats the specified array of array of string rows as comma-separated values, returning a string.
+ * This operation is the reverse of csvParseRows. Each row will be separated by a newline (\n),
+ * and each column within each row will be separated by the comma-delimiter.
+ * Values that contain either the comma-delimiter, a double-quote (") or a newline will be escaped using double-quotes.
+ *
+ * To convert an array of objects to an array of arrays while explicitly specifying the columns, use array.map.
+ * If you like, you can also array.concat this result with an array of column names to generate the first row.
+ *
+ * Equivalent to `dsvFormat(",").formatRows`.
+ *
+ * @param rows An array of array of string rows.
+ */
+export function csvFormatRows(rows: readonly string[][]): string;
+
+// csvFormatRow(...) ========================================================================
+
+/**
+ * Equivalent to dsvFormat(",").formatRow.
+ *
+ * @param row An array of strings representing a row.
+ */
+export function csvFormatRow(row: readonly string[]): string;
+
+// csvFormatValue(...) ========================================================================
+
+/**
+ * Equivalent to dsvFormat(",").formatValue.
+ *
+ * @param value A value.
+ */
+export function csvFormatValue(value: string): string;
+
+// ------------------------------------------------------------------------------------------
+// TSV Parsers and Formatters
+// ------------------------------------------------------------------------------------------
+
+// tsvParse(...) ============================================================================
+
+/**
+ * Parses the specified string, which must be in the tab-separated values format, returning an array of objects representing the parsed rows.
+ *
+ * Unlike tsvParseRows, this method requires that the first line of the TSV content contains a tab-separated list of column names;
+ * these column names become the attributes on the returned objects.
+ *
+ * The returned array also exposes a columns property containing the column names in input order (in contrast to Object.keys, whose iteration order is arbitrary).
+ *
+ * Equivalent to `dsvFormat("\t").parse`.
+ * Note: requires unsafe-eval content security policy.
+ *
+ * @param tsvString A string, which must be in the tab-separated values format.
+ */
+// tslint:disable-next-line:no-unnecessary-generics
+export function tsvParse<Columns extends string>(tsvString: string): DSVRowArray<Columns>;
+/**
+ * Parses the specified string, which must be in the tab-separated values format, returning an array of objects representing the parsed rows.
+ *
+ * Unlike tsvParseRows, this method requires that the first line of the TSV content contains a tab-separated list of column names;
+ * these column names become the attributes on the returned objects.
+ *
+ * The returned array also exposes a columns property containing the column names in input order (in contrast to Object.keys, whose iteration order is arbitrary).
+ *
+ * Equivalent to `dsvFormat("\t").parse`.
+ * Note: requires unsafe-eval content security policy.
+ *
+ * @param tsvString A string, which must be in the tab-separated values format.
+ * @param row A row conversion function which is invoked for each row, being passed an object representing the current row (d),
+ * the index (i) starting at zero for the first non-header row, and the array of column names. If the returned value is null or undefined,
+ * the row is skipped and will be omitted from the array returned by dsv.parse; otherwise, the returned value defines the corresponding row object.
+ * In effect, row is similar to applying a map and filter operator to the returned rows.
+ */
+export function tsvParse<ParsedRow extends object, Columns extends string>(
+    tsvString: string,
+    row: (rawRow: DSVRowString<Columns>, index: number, columns: Columns[]) => ParsedRow | undefined | null
+): DSVParsedArray<ParsedRow>;
+
+// tsvParseRows(...) ========================================================================
+
+/**
+ * Parses the specified string, which must be in the tab-separated values format, returning an array of arrays representing the parsed rows.
+ *
+ * Unlike tsvParse, this method treats the header line as a standard row, and should be used whenever TSV content does not contain a header.
+ * Each row is represented as an array rather than an object. Rows may have variable length.
+ *
+ * If a row conversion function is not specified, field values are strings. For safety, there is no automatic conversion to numbers, dates, or other types.
+ * In some cases, JavaScript may coerce strings to numbers for you automatically (for example, using the + operator), but better is to specify a row conversion function.
+ *
+ * Equivalent to `dsvFormat("\t").parseRows`.
+ *
+ * @param tsvString A string, which must be in the tab-separated values format.
+ */
+export function tsvParseRows(tsvString: string): string[][];
+/**
+ * Parses the specified string, which must be in the tab-separated values format, returning an array of arrays representing the parsed rows.
+ *
+ * Unlike tsvParse, this method treats the header line as a standard row, and should be used whenever TSV content does not contain a header.
+ * Each row is represented as an array rather than an object. Rows may have variable length.
+ *
+ * Equivalent to `dsvFormat("\t").parseRows`.
+ *
+ * @param tsvString A string, which must be in the tab-separated values format.
+ * @param row A row conversion function which is invoked for each row, being passed an array representing the current row (d), the index (i)
+ * starting at zero for the first row, and the array of column names. If the returned value is null or undefined,
+ * the row is skipped and will be omitted from the array returned by dsv.parse; otherwise, the returned value defines the corresponding row object.
+ * In effect, row is similar to applying a map and filter operator to the returned rows.
+ */
+export function tsvParseRows<ParsedRow extends object>(
+    tsvString: string,
+    row: (rawRow: string[], index: number) => ParsedRow | undefined | null
+): ParsedRow[];
+
+// tsvFormat(...) ============================================================================
+
+/**
+ * Formats the specified array of object rows as tab-separated values, returning a string.
+ * This operation is the inverse of tsvParse. Each row will be separated by a newline (\n),
+ * and each column within each row will be separated by the tab-delimiter.
+ * Values that contain either the tab-delimiter, a double-quote (") or a newline will be escaped using double-quotes.
+ *
+ * If columns is not specified, the list of column names that forms the header row is determined by the union of all properties on all objects in rows;
+ * the order of columns is nondeterministic.
+ *
+ * Equivalent to `dsvFormat("\t").format`.
+ *
+ * @param rows Array of object rows.
+ * @param columns An array of strings representing the column names.
+ */
+export function tsvFormat<T extends object>(rows: readonly T[], columns?: ReadonlyArray<keyof T>): string;
+
+// tsvFormatBody(...) ============================================================================
+
+/**
+ * Equivalent to dsvFormat("\t").formatBody.
+ *
+ * @param rows Array of object rows.
+ * @param columns An array of strings representing the column names.
+ */
+export function tsvFormatBody<T extends object>(rows: readonly T[], columns?: ReadonlyArray<keyof T>): string;
+
+// tsvFormatRows(...) ========================================================================
+
+/**
+ * Formats the specified array of array of string rows as tab-separated values, returning a string.
+ * This operation is the reverse of tsvParseRows. Each row will be separated by a newline (\n),
+ * and each column within each row will be separated by the tab-delimiter.
+ * Values that contain either the tab-delimiter, a double-quote (") or a newline will be escaped using double-quotes.
+ *
+ * To convert an array of objects to an array of arrays while explicitly specifying the columns, use array.map.
+ * If you like, you can also array.concat this result with an array of column names to generate the first row.
+ *
+ * Equivalent to `dsvFormat("\t").formatRows`.
+ *
+ * @param rows An array of array of string rows.
+ */
+export function tsvFormatRows(rows: readonly string[][]): string;
+
+// tsvFormatRow(...) ========================================================================
+
+/**
+ * Equivalent to dsvFormat("\t").formatRow.
+ *
+ * @param row An array of strings representing a row.
+ */
+export function tsvFormatRow(row: readonly string[]): string;
+
+// tsvFormatValue(...) ========================================================================
+
+/**
+ * Equivalent to dsvFormat("\t").formatValue.
+ *
+ * @param value A value.
+ */
+export function tsvFormatValue(value: string): string;
+
+// ------------------------------------------------------------------------------------------
+// DSV Generalized Parsers and Formatters
+// ------------------------------------------------------------------------------------------
+
+/**
+ * A DSV parser and formatter
+ */
+export interface DSV {
+    /**
+     * Parses the specified string, which must be in the delimiter-separated values format with the appropriate delimiter, returning an array of objects representing the parsed rows.
+     *
+     * Unlike dsv.parseRows, this method requires that the first line of the DSV content contains a delimiter-separated list of column names;
+     * these column names become the attributes on the returned objects.
+     *
+     * The returned array also exposes a columns property containing the column names in input order (in contrast to Object.keys, whose iteration order is arbitrary).
+     *
+     * If the column names are not unique, only the last value is returned for each name; to access all values, use dsv.parseRows instead.
+     *
+     * Note: requires unsafe-eval content security policy.
+     *
+     * @param dsvString A string, which must be in the delimiter-separated values format with the appropriate delimiter.
+     */
+    // tslint:disable-next-line:no-unnecessary-generics
+    parse<Columns extends string>(dsvString: string): DSVRowArray<Columns>;
+    /**
+     * Parses the specified string, which must be in the delimiter-separated values format with the appropriate delimiter, returning an array of objects representing the parsed rows.
+     *
+     * Unlike dsv.parseRows, this method requires that the first line of the DSV content contains a delimiter-separated list of column names;
+     * these column names become the attributes on the returned objects.
+     *
+     * The returned array also exposes a columns property containing the column names in input order (in contrast to Object.keys, whose iteration order is arbitrary).
+     *
+     * If the column names are not unique, only the last value is returned for each name; to access all values, use dsv.parseRows instead.
+     *
+     * Note: requires unsafe-eval content security policy.
+     *
+     * @param dsvString A string, which must be in the delimiter-separated values format with the appropriate delimiter.
+     * @param row A row conversion function which is invoked for each row, being passed an object representing the current row (d),
+     * the index (i) starting at zero for the first non-header row, and the array of column names. If the returned value is null or undefined,
+     * the row is skipped and will be omitted from the array returned by dsv.parse; otherwise, the returned value defines the corresponding row object.
+     * In effect, row is similar to applying a map and filter operator to the returned rows.
+     */
+    parse<ParsedRow extends object, Columns extends string>(
+        dsvString: string,
+        row: (rawRow: DSVRowString<Columns>, index: number, columns: Columns[]) => ParsedRow | undefined | null
+    ): DSVParsedArray<ParsedRow>;
+
+    /**
+     * Parses the specified string, which must be in the delimiter-separated values format with the appropriate delimiter, returning an array of arrays representing the parsed rows.
+     *
+     * Unlike dsv.parse, this method treats the header line as a standard row, and should be used whenever DSV content does not contain a header.
+     * Each row is represented as an array rather than an object. Rows may have variable length.
+     *
+     * If a row conversion function is not specified, field values are strings. For safety, there is no automatic conversion to numbers, dates, or other types.
+     * In some cases, JavaScript may coerce strings to numbers for you automatically (for example, using the + operator), but better is to specify a row conversion function.
+     *
+     * @param dsvString A string, which must be in the delimiter-separated values format with the appropriate delimiter.
+     */
+    parseRows(dsvString: string): string[][];
+    /**
+     * Parses the specified string, which must be in the delimiter-separated values format with the appropriate delimiter, returning an array of arrays representing the parsed rows.
+     *
+     * Unlike dsv.parse, this method treats the header line as a standard row, and should be used whenever DSV content does not contain a header.
+     * Each row is represented as an array rather than an object. Rows may have variable length.
+     *
+     * @param dsvString A string, which must be in the delimiter-separated values format with the appropriate delimiter.
+     * @param row A row conversion function which is invoked for each row, being passed an array representing the current row (d), the index (i)
+     * starting at zero for the first row, and the array of column names. If the returned value is null or undefined,
+     * the row is skipped and will be omitted from the array returned by dsv.parse; otherwise, the returned value defines the corresponding row object.
+     * In effect, row is similar to applying a map and filter operator to the returned rows.
+     */
+    parseRows<ParsedRow extends object>(
+        dsvString: string,
+        row: (rawRow: string[], index: number) => ParsedRow | undefined | null
+    ): ParsedRow[];
+
+    /**
+     * Formats the specified array of object rows as delimiter-separated values, returning a string.
+     * This operation is the inverse of dsv.parse. Each row will be separated by a newline (\n),
+     * and each column within each row will be separated by the delimiter (such as a comma, ,).
+     * Values that contain either the delimiter, a double-quote (") or a newline will be escaped using double-quotes.
+     *
+     * If columns is not specified, the list of column names that forms the header row is determined by the union of all properties on all objects in rows;
+     * the order of columns is nondeterministic.
+     *
+     * @param rows Array of object rows.
+     * @param columns An array of strings representing the column names.
+     */
+    format<T extends object>(rows: readonly T[], columns?: ReadonlyArray<keyof T>): string;
+
+    /**
+     * Equivalent to dsv.format, but omits the header row.
+     * This is useful, for example, when appending rows to an existing file.
+     *
+     * @param rows Array of object rows.
+     * @param columns An array of strings representing the column names.
+     */
+    formatBody<T extends object>(rows: readonly T[], columns?: ReadonlyArray<keyof T>): string;
+
+    /**
+     * Formats the specified array of array of string rows as delimiter-separated values, returning a string.
+     * This operation is the reverse of dsv.parseRows. Each row will be separated by a newline (\n),
+     * and each column within each row will be separated by the delimiter (such as a comma, ,).
+     * Values that contain either the delimiter, a double-quote (") or a newline will be escaped using double-quotes.
+     *
+     * To convert an array of objects to an array of arrays while explicitly specifying the columns, use array.map.
+     * If you like, you can also array.concat this result with an array of column names to generate the first row.
+     *
+     * @param rows An array of array of string rows.
+     */
+    formatRows(rows: readonly string[][]): string;
+
+    /**
+     * Formats a single array row of strings as delimiter-separated values, returning a string.
+     * Each column within the row will be separated by the delimiter (such as a comma, ,).
+     * Values that contain either the delimiter, a double-quote (") or a newline will be escaped using double-quotes.
+     *
+     * @param row An array of strings representing a row.
+     */
+    formatRow(row: readonly string[]): string;
+
+    /**
+     * Format a single value or string as a delimiter-separated value, returning a string.
+     * A value that contains either the delimiter, a double-quote (") or a newline will be escaped using double-quotes.
+     *
+     * @param value A value.
+     */
+    formatValue(value: string): string;
+}
+
+/**
+ * Constructs a new DSV parser and formatter for the specified delimiter.
+ *
+ * @param delimiter A delimiter character. The delimiter must be a single character (i.e., a single 16-bit code unit);
+ * so, ASCII delimiters are fine, but emoji delimiters are not.
+ */
+export function dsvFormat(delimiter: string): DSV;
+
+/**
+ * Infers the types of values on the object and coerces them accordingly, returning the mutated object.
+ * This function is intended to be used as a row accessor function in conjunction with dsv.parse and dsv.parseRows.
+ *
+ * @param object An object (or array) representing a parsed row
+ */
+export function autoType<ParsedRow extends object | undefined | null, Columns extends string>(
+    // tslint:disable-next-line:no-unnecessary-generics
+    object: DSVRowString<Columns> | readonly string[]
+// tslint:disable-next-line:no-unnecessary-generics
+): ParsedRow;

node_modules/@types/d3-dsv/package.json

@@ -0,0 +1,70 @@
+{
+  "_from": "@types/d3-dsv@*",
+  "_id": "@types/d3-dsv@2.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-wovgiG9Mgkr/SZ/m/c0m+RwrIT4ozsuCWeLxJyoObDWsie2DeQT4wzMdHZPR9Ya5oZLQT3w3uSl0NehG0+0dCA==",
+  "_location": "/@types/d3-dsv",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-dsv@*",
+    "name": "@types/d3-dsv",
+    "escapedName": "@types%2fd3-dsv",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3",
+    "/@types/d3-fetch"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-dsv/-/d3-dsv-2.0.1.tgz",
+  "_shasum": "44ce09b025cf365d27cbe11fc13cd10954369627",
+  "_spec": "@types/d3-dsv@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "denisname",
+      "url": "https://github.com/denisname"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-dsv module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-dsv",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-dsv"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.4",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "a5e82c51ab81e4b968d902303d588ee5e43a9440da17253984de7ecde0903d80",
+  "version": "2.0.1"
+}

node_modules/@types/d3-ease/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-ease/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-ease`
+
+# Summary
+This package contains type definitions for D3JS d3-ease module (https://github.com/d3/d3-ease/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-ease.
+
+### Additional Details
+ * Last updated: Wed, 30 Sep 2020 20:01:29 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), and [Nathan Bierema](https://github.com/Methuselah06).

node_modules/@types/d3-ease/index.d.ts

@@ -0,0 +1,324 @@
+// Type definitions for D3JS d3-ease module 2.0
+// Project: https://github.com/d3/d3-ease/, https://d3js.org/d3-ease
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 Nathan Bierema <https://github.com/Methuselah06>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Last module patch version validated against: 2.0.0
+
+// --------------------------------------------------------------------------
+// Easing Functions
+// --------------------------------------------------------------------------
+
+/**
+ * Linear easing; the identity function; linear(t) returns t.
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeLinear(normalizedTime: number): number;
+
+/**
+ * Symmetric quadratic easing; scales quadIn for t in [0, 0.5] and quadOut for t in [0.5, 1]. Also equivalent to poly.exponent(2).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeQuad(normalizedTime: number): number;
+
+/**
+ * Quadratic easing; equivalent to polyIn.exponent(2).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeQuadIn(normalizedTime: number): number;
+
+/**
+ * Reverse quadratic easing; equivalent to 1 - quadIn(1 - t). Also equivalent to polyOut.exponent(2).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeQuadOut(normalizedTime: number): number;
+
+/**
+ * Symmetric quadratic easing; scales quadIn for t in [0, 0.5] and quadOut for t in [0.5, 1]. Also equivalent to poly.exponent(2).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeQuadInOut(normalizedTime: number): number;
+
+/**
+ * Symmetric cubic easing; scales cubicIn for t in [0, 0.5] and cubicOut for t in [0.5, 1]. Also equivalent to poly.exponent(3).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeCubic(normalizedTime: number): number;
+
+/**
+ * Cubic easing; equivalent to polyIn.exponent(3).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeCubicIn(normalizedTime: number): number;
+
+/**
+ * Reverse cubic easing; equivalent to 1 - cubicIn(1 - t). Also equivalent to polyOut.exponent(3).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeCubicOut(normalizedTime: number): number;
+
+/**
+ * Symmetric cubic easing; scales cubicIn for t in [0, 0.5] and cubicOut for t in [0.5, 1]. Also equivalent to poly.exponent(3).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeCubicInOut(normalizedTime: number): number;
+
+/**
+ * Polynomial easing function factory
+ */
+export interface PolynomialEasingFactory {
+    /**
+     * Calculate eased time.
+     * @param normalizedTime Normalized time typically in the range [0, 1]
+     */
+    (normalizedTime: number): number;
+    /**
+     * Returns a new polynomial easing with the specified exponent e.
+     * If the exponent is not specified, it defaults to 3, equivalent to cubic.
+     *
+     * @param e Exponent for polynomial easing.
+     */
+    exponent(e: number): PolynomialEasingFactory;
+}
+
+/**
+ * Symmetric polynomial easing/easing factory; scales polyIn for t in [0, 0.5] and polyOut for t in [0.5, 1].
+ * If the exponent is not specified, it defaults to 3, equivalent to cubic.
+ */
+export const easePoly: PolynomialEasingFactory;
+/**
+ * Polynomial easing/easing factory; raises t to the specified exponent.
+ * If the exponent is not specified, it defaults to 3, equivalent to cubicIn.
+ */
+export const easePolyIn: PolynomialEasingFactory;
+
+/**
+ * Reverse polynomial easing/easing factory; equivalent to 1 - polyIn(1 - t).
+ * If the exponent is not specified, it defaults to 3, equivalent to cubicOut.
+ */
+export const easePolyOut: PolynomialEasingFactory;
+
+/**
+ * Symmetric polynomial easing/easing factory; scales polyIn for t in [0, 0.5] and polyOut for t in [0.5, 1].
+ * If the exponent is not specified, it defaults to 3, equivalent to cubic.
+ */
+export const easePolyInOut: PolynomialEasingFactory;
+
+/**
+ * Symmetric sinusoidal easing; scales sinIn for t in [0, 0.5] and sinOut for t in [0.5, 1].
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeSin(normalizedTime: number): number;
+
+/**
+ * Sinusoidal easing; returns sin(t).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeSinIn(normalizedTime: number): number;
+
+/**
+ * Reverse sinusoidal easing; equivalent to 1 - sinIn(1 - t).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeSinOut(normalizedTime: number): number;
+
+/**
+ * Symmetric sinusoidal easing; scales sinIn for t in [0, 0.5] and sinOut for t in [0.5, 1].
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeSinInOut(normalizedTime: number): number;
+
+/**
+ * Symmetric exponential easing; scales expIn for t in [0, 0.5] and expOut for t in [0.5, 1].
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeExp(normalizedTime: number): number;
+
+/**
+ * Exponential easing; raises 2 to the exponent 10 * (t - 1).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeExpIn(normalizedTime: number): number;
+
+/**
+ * Reverse exponential easing; equivalent to 1 - expIn(1 - t).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeExpOut(normalizedTime: number): number;
+
+/**
+ * Symmetric exponential easing; scales expIn for t in [0, 0.5] and expOut for t in [0.5, 1].
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeExpInOut(normalizedTime: number): number;
+
+/**
+ * Symmetric circular easing; scales circleIn for t in [0, 0.5] and circleOut for t in [0.5, 1].
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeCircle(normalizedTime: number): number;
+
+/**
+ * Circular easing.
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeCircleIn(normalizedTime: number): number;
+
+/**
+ * Reverse circular easing; equivalent to 1 - circleIn(1 - t).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeCircleOut(normalizedTime: number): number;
+
+/**
+ * Symmetric circular easing; scales circleIn for t in [0, 0.5] and circleOut for t in [0.5, 1].
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeCircleInOut(normalizedTime: number): number;
+
+/**
+ * Reverse bounce easing; equivalent to 1 - bounceIn(1 - t).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeBounce(normalizedTime: number): number;
+
+/**
+ * Bounce easing, like a rubber ball.
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeBounceIn(normalizedTime: number): number;
+
+/**
+ * Reverse bounce easing; equivalent to 1 - bounceIn(1 - t).
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeBounceOut(normalizedTime: number): number;
+
+/**
+ * Symmetric bounce easing; scales bounceIn for t in [0, 0.5] and bounceOut for t in [0.5, 1].
+ *
+ * @param normalizedTime Normalized time typically in the range [0, 1]
+ */
+export function easeBounceInOut(normalizedTime: number): number;
+
+/**
+ * Anticipatory easing function factory
+ */
+export interface BackEasingFactory {
+    /**
+     * Calculate eased time.
+     * @param normalizedTime Normalized time typically in the range [0, 1]
+     */
+    (normalizedTime: number): number;
+    /**
+     * Returns a new back easing with the specified overshoot s.
+     * The degree of overshoot is configurable; if not specified, it defaults to 1.70158.
+     *
+     * @param s Overshoot parameter
+     */
+    overshoot(s: number): BackEasingFactory;
+}
+
+/**
+ * Symmetric anticipatory easing; scales backIn for t in [0, 0.5] and backOut for t in [0.5, 1].
+ * The degree of overshoot is configurable; it not specified, it defaults to 1.70158.
+ */
+export const easeBack: BackEasingFactory;
+
+/**
+ * Anticipatory easing, like a dancer bending their knees before jumping off the floor.
+ * The degree of overshoot is configurable; it not specified, it defaults to 1.70158.
+ */
+export const easeBackIn: BackEasingFactory;
+
+/**
+ * Reverse anticipatory easing; equivalent to 1 - backIn(1 - t).
+ * The degree of overshoot is configurable; it not specified, it defaults to 1.70158.
+ */
+export const easeBackOut: BackEasingFactory;
+
+/**
+ * Symmetric anticipatory easing; scales backIn for t in [0, 0.5] and backOut for t in [0.5, 1].
+ * The degree of overshoot is configurable; it not specified, it defaults to 1.70158.
+ */
+export const easeBackInOut: BackEasingFactory;
+
+/**
+ * Elastic easing function factory
+ */
+export interface ElasticEasingFactory {
+    /**
+     * Calculate eased time.
+     * @param normalizedTime Normalized time typically in the range [0, 1]
+     */
+    (normalizedTime: number): number;
+    /**
+     * Returns a new elastic easing with the specified amplitude a.
+     * Defaults to 1,if not specified.
+     *
+     * @param a Amplitude for elastic easing.
+     */
+    amplitude(a: number): ElasticEasingFactory;
+    /**
+     * Returns a new elastic easing with the specified amplitude a.
+     * Defaults to 0.3,if not specified.
+     *
+     * @param p Period for elastic easing.
+     */
+    period(p: number): ElasticEasingFactory;
+}
+
+/**
+ * Reverse elastic easing; equivalent to 1 - elasticIn(1 - t).
+ * The amplitude and period of the oscillation are configurable;
+ * if not specified, they default to 1 and 0.3, respectively.
+ */
+export const easeElastic: ElasticEasingFactory;
+
+/**
+ * Elastic easing, like a rubber band.
+ * The amplitude and period of the oscillation are configurable;
+ * if not specified, they default to 1 and 0.3, respectively.
+ */
+export const easeElasticIn: ElasticEasingFactory;
+
+/**
+ * Reverse elastic easing; equivalent to 1 - elasticIn(1 - t).
+ * The amplitude and period of the oscillation are configurable;
+ * if not specified, they default to 1 and 0.3, respectively.
+ */
+export const easeElasticOut: ElasticEasingFactory;
+
+/**
+ * Symmetric elastic easing; scales elasticIn for t in [0, 0.5] and elasticOut for t in [0.5, 1].
+ * The amplitude and period of the oscillation are configurable;
+ * if not specified, they default to 1 and 0.3, respectively.
+ */
+export const easeElasticInOut: ElasticEasingFactory;

node_modules/@types/d3-ease/package.json

@@ -0,0 +1,65 @@
+{
+  "_from": "@types/d3-ease@*",
+  "_id": "@types/d3-ease@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-6aZrTyX5LG+ptofVHf+gTsThLRY1nhLotJjgY4drYqk1OkJMu2UvuoZRlPw2fffjRHeYepue3/fxTufqKKmvsA==",
+  "_location": "/@types/d3-ease",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-ease@*",
+    "name": "@types/d3-ease",
+    "escapedName": "@types%2fd3-ease",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-2.0.0.tgz",
+  "_shasum": "798cbd9908d26cfe9f1a295a3a75164da9a3666e",
+  "_spec": "@types/d3-ease@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah06"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-ease module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-ease",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-ease"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "1b1fb5ed1cad09724be509843e9519a56b36924c6293d6372575bccb7a00e6fd",
+  "version": "2.0.0"
+}

node_modules/@types/d3-fetch/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-fetch/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-fetch`
+
+# Summary
+This package contains type definitions for d3-fetch (https://d3js.org/d3-fetch/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-fetch.
+
+### Additional Details
+ * Last updated: Thu, 01 Oct 2020 22:50:45 GMT
+ * Dependencies: [@types/d3-dsv](https://npmjs.com/package/@types/d3-dsv)
+ * Global values: none
+
+# Credits
+These definitions were written by [Hugues Stefanski](https://github.com/ledragon), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-fetch/index.d.ts

@@ -0,0 +1,283 @@
+// Type definitions for d3-fetch 2.0
+// Project: https://d3js.org/d3-fetch/
+// Definitions by: Hugues Stefanski <https://github.com/ledragon>
+//                 denisname <https://github.com/denisname>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+// Last module patch version validated against: 2.0.0
+
+import { DSVParsedArray, DSVRowArray, DSVRowString } from "d3-dsv";
+
+/**
+ * Fetches the binary file at the specified input URL and returns it as a Promise of a Blob.
+ * If init is specified, it is passed along to the underlying call to fetch.
+ *
+ * @param url A valid URL string.
+ * @param init An optional request initialization object.
+ */
+export function blob(url: string, init?: RequestInit): Promise<Blob>;
+
+/**
+ * Fetches the binary file at the specified input URL and returns it as a Promise of an ArrayBuffer.
+ * If init is specified, it is passed along to the underlying call to fetch.
+ *
+ * @param url A valid URL string.
+ * @param init An optional request initialization object.
+ */
+export function buffer(url: string, init?: RequestInit): Promise<ArrayBuffer>;
+
+/**
+ * Fetches the CSV file at the specified input URL and returns
+ * a promise of an array of objects representing the parsed rows. The values of the properties of the parsed row
+ * objects are represented as strings.
+ *
+ * If init is specified, it is passed along to the underlying call to fetch.
+ *
+ * The generic parameter describes the column names as a union of string literal types.
+ *
+ * @param url A valid URL string.
+ * @param init An optional request initialization object.
+ */
+export function csv<Columns extends string>(
+    url: string,
+    init?: RequestInit
+): Promise<DSVRowArray<Columns>>;
+/**
+ * Fetches the CSV file at the specified input URL and returns
+ * a promise of an array of objects representing the parsed rows.
+ *
+ * The specified row conversion function is used to map and filter row objects to a more-specific representation;
+ * see dsv.csvParse for details.
+ *
+ * The first generic parameter describes the type of the object representation of a parsed row.
+ * The second generic parameter describes the column names as a union of string literal types.
+ *
+ * @param url A valid URL string.
+ * @param row A row conversion function which is invoked for each row, being passed an object representing the current row (d),
+ * the index (i) starting at zero for the first non-header row, and the array of column names. If the returned value is null or undefined,
+ * the row is skipped and will be omitted from the array returned by dsv.csvParse; otherwise, the returned value defines the corresponding row object.
+ * In effect, row is similar to applying a map and filter operator to the returned rows.
+ */
+export function csv<ParsedRow extends object, Columns extends string = string>(
+    url: string,
+    row: (rawRow: DSVRowString<Columns>, index: number, columns: Columns[]) => ParsedRow | undefined | null
+): Promise<DSVParsedArray<ParsedRow>>;
+/**
+ * Fetches the CSV file at the specified input URL and returns
+ * a promise of an array of objects representing the parsed rows.
+ *
+ * The init object is passed along to the underlying call to fetch.
+ *
+ * The specified row conversion function is used to map and filter row objects to a more-specific representation;
+ * see dsv.csvParse for details.
+ *
+ * The first generic parameter describes the type of the object representation of a parsed row.
+ * The second generic parameter describes the column names as a union of string literal types.
+ *
+ * @param url A valid URL string.
+ * @param init An request initialization object.
+ * @param row A row conversion function which is invoked for each row, being passed an object representing the current row (d),
+ * the index (i) starting at zero for the first non-header row, and the array of column names. If the returned value is null or undefined,
+ * the row is skipped and will be omitted from the array returned by dsv.csvParse; otherwise, the returned value defines the corresponding row object.
+ * In effect, row is similar to applying a map and filter operator to the returned rows.
+ */
+export function csv<ParsedRow extends object, Columns extends string = string>(
+    url: string,
+    init: RequestInit,
+    row: (rawRow: DSVRowString<Columns>, index: number, columns: Columns[]) => ParsedRow | undefined | null
+): Promise<DSVParsedArray<ParsedRow>>;
+
+/**
+ * Fetches the DSV file with the specified delimiter character at the specified input URL and returns
+ * a promise of an array of objects representing the parsed rows. The values of the properties of the parsed row
+ * objects are represented as strings.
+ *
+ * If init is specified, it is passed along to the underlying call to fetch.
+ *
+ * The generic parameter describes the column names as a union of string literal types.
+ *
+ * @param delimiter The delimiter character used in the DSV file to be fetched.
+ * @param url A valid URL string.
+ * @param init An optional request initialization object.
+ */
+export function dsv<Columns extends string>(
+    delimiter: string,
+    url: string,
+    init?: RequestInit
+): Promise<DSVRowArray<Columns>>;
+/**
+ * Fetches the DSV file with the specified delimiter character at the specified input URL and returns
+ * a promise of an array of objects representing the parsed rows.
+ *
+ * The specified row conversion function is used to map and filter row objects to a more-specific representation;
+ * see dsv.parse for details.
+ *
+ * The first generic parameter describes the type of the object representation of a parsed row.
+ * The second generic parameter describes the column names as a union of string literal types.
+ *
+ * @param delimiter The delimiter character used in the DSV file to be fetched.
+ * @param url A valid URL string.
+ * @param row A row conversion function which is invoked for each row, being passed an object representing the current row (d),
+ * the index (i) starting at zero for the first non-header row, and the array of column names. If the returned value is null or undefined,
+ * the row is skipped and will be omitted from the array returned by dsv.parse; otherwise, the returned value defines the corresponding row object.
+ * In effect, row is similar to applying a map and filter operator to the returned rows.
+ */
+export function dsv<ParsedRow extends object, Columns extends string = string>(
+    delimiter: string,
+    url: string,
+    row: (rawRow: DSVRowString<Columns>, index: number, columns: Columns[]) => ParsedRow | undefined | null
+): Promise<DSVParsedArray<ParsedRow>>;
+/**
+ * Fetches the DSV file with the specified delimiter character at the specified input URL and returns
+ * a promise of an array of objects representing the parsed rows.
+ *
+ * The init object is passed along to the underlying call to fetch.
+ *
+ * The specified row conversion function is used to map and filter row objects to a more-specific representation;
+ * see dsv.parse for details.
+ *
+ * The first generic parameter describes the type of the object representation of a parsed row.
+ * The second generic parameter describes the column names as a union of string literal types.
+ *
+ * @param delimiter The delimiter character used in the DSV file to be fetched.
+ * @param url A valid URL string.
+ * @param init An request initialization object.
+ * @param row A row conversion function which is invoked for each row, being passed an object representing the current row (d),
+ * the index (i) starting at zero for the first non-header row, and the array of column names. If the returned value is null or undefined,
+ * the row is skipped and will be omitted from the array returned by dsv.parse; otherwise, the returned value defines the corresponding row object.
+ * In effect, row is similar to applying a map and filter operator to the returned rows.
+ */
+export function dsv<ParsedRow extends object, Columns extends string = string>(
+    delimiter: string,
+    url: string,
+    init: RequestInit,
+    row: (rawRow: DSVRowString<Columns>, index: number, columns: Columns[]) => ParsedRow | undefined | null
+): Promise<DSVParsedArray<ParsedRow>>;
+
+/**
+ * Fetches the file at the specified input URL as text, parses it as HTML and returns a Promise of an HTML DOM Document.
+ *
+ * If init is specified, it is passed along to the underlying call to fetch.
+ *
+ * @param url A valid URL string.
+ * @param init An optional request initialization object.
+ */
+export function html(url: string, init?: RequestInit): Promise<Document>;
+
+/**
+ * Fetches the image at the specified input URL and returns a promise of an HTML image element.
+ *
+ * If init is specified, sets any additional properties on the image before loading.
+ *
+ * @param url A valid URL string.
+ * @param init An optional object of image properties to set.
+ */
+export function image(url: string, init?: Partial<HTMLImageElement>): Promise<HTMLImageElement>;
+
+/**
+ * Fetches the json file at the specified input URL and returns it as a Promise of a parsed JSON object.
+ *
+ * If init is specified, it is passed along to the underlying call to fetch.
+ *
+ * If the server returns a status code of [204 No Content](https://developer.mozilla.org/docs/Web/HTTP/Status/204)
+ * or [205 Reset Content](https://developer.mozilla.org/docs/Web/HTTP/Status/205), the promise resolves to `undefined`.
+ *
+ * The generic parameter describes the type of the object parsed from the returned JSON.
+ *
+ * @param url A valid URL string.
+ * @param init An optional request initialization object.
+ */
+export function json<ParsedJSONObject extends any>(url: string, init?: RequestInit): Promise<ParsedJSONObject | undefined>;
+
+/**
+ * Fetches the file at the specified input URL as text, parses it as SVG and returns a Promise of an SVG Document.
+ *
+ * If init is specified, it is passed along to the underlying call to fetch.
+ *
+ * @param url A valid URL string.
+ * @param init An optional request initialization object.
+ */
+export function svg(url: string, init?: RequestInit): Promise<Document>;
+
+/**
+ * Fetches the text file at the specified input URL and returns it as a Promise of a string.
+ *
+ * If init is specified, it is passed along to the underlying call to fetch.
+ *
+ * @param url A valid URL string.
+ * @param init An optional request initialization object.
+ */
+export function text(url: string, init?: RequestInit): Promise<string>;
+
+/**
+ * Fetches the TSV file at the specified input URL and returns
+ * a promise of an array of objects representing the parsed rows.
+ *
+ * If init is specified, it is passed along to the underlying call to fetch.
+ *
+ * The generic parameter describes the column names as a union of string literal types.
+ *
+ * @param url A valid URL string.
+ * @param init An optional request initialization object.
+ */
+export function tsv<Columns extends string>(
+    url: string,
+    init?: RequestInit
+): Promise<DSVRowArray<Columns>>;
+/**
+ * Fetches the TSV file at the specified input URL and returns
+ * a promise of an array of objects representing the parsed rows. The values of the properties of the parsed row
+ * objects are represented as strings.
+ *
+ * The specified row conversion function is used to map and filter row objects to a more-specific representation;
+ * see dsv.tsvParse for details.
+ *
+ * The first generic parameter describes the type of the object representation of a parsed row.
+ * The second generic parameter describes the column names as a union of string literal types.
+ *
+ * @param url A valid URL string.
+ * @param row A row conversion function which is invoked for each row, being passed an object representing the current row (d),
+ * the index (i) starting at zero for the first non-header row, and the array of column names. If the returned value is null or undefined,
+ * the row is skipped and will be omitted from the array returned by dsv.tsvParse; otherwise, the returned value defines the corresponding row object.
+ * In effect, row is similar to applying a map and filter operator to the returned rows.
+ */
+export function tsv<ParsedRow extends object, Columns extends string = string>(
+    url: string,
+    row: (rawRow: DSVRowString<Columns>, index: number, columns: Columns[]) => ParsedRow | undefined | null
+): Promise<DSVParsedArray<ParsedRow>>;
+/**
+ * Fetches the TSV file at the specified input URL and returns
+ * a promise of an array of objects representing the parsed rows.
+ *
+ * The init object is passed along to the underlying call to fetch.
+ *
+ * The specified row conversion function is used to map and filter row objects to a more-specific representation;
+ * see dsv.tsvParse for details.
+ *
+ * The first generic parameter describes the type of the object representation of a parsed row.
+ * The second generic parameter describes the column names as a union of string literal types.
+ *
+ * @param url A valid URL string.
+ * @param init An request initialization object.
+ * @param row A row conversion function which is invoked for each row, being passed an object representing the current row (d),
+ * the index (i) starting at zero for the first non-header row, and the array of column names. If the returned value is null or undefined,
+ * the row is skipped and will be omitted from the array returned by dsv.tsvParse; otherwise, the returned value defines the corresponding row object.
+ * In effect, row is similar to applying a map and filter operator to the returned rows.
+ */
+export function tsv<ParsedRow extends object, Columns extends string = string>(
+    url: string,
+    init: RequestInit,
+    row: (rawRow: DSVRowString<Columns>, index: number, columns: Columns[]) => ParsedRow | undefined | null
+): Promise<DSVParsedArray<ParsedRow>>;
+
+/**
+ * Fetches the file at the specified input URL as text, parses it as XML and returns a Promise of an XML Document.
+ *
+ * If init is specified, it is passed along to the underlying call to fetch.
+ *
+ * @param url A valid URL string.
+ * @param init An optional request initialization object.
+ */
+export function xml(url: string, init?: RequestInit): Promise<XMLDocument>;

node_modules/@types/d3-fetch/package.json

@@ -0,0 +1,63 @@
+{
+  "_from": "@types/d3-fetch@*",
+  "_id": "@types/d3-fetch@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-WnLepGtxepFfXRdPI8I5FTgNiHn9p4vMTTqaNCzJJfAswXx0rOY2jjeolzEU063em3iJmGZ+U79InnEeFOrCRw==",
+  "_location": "/@types/d3-fetch",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-fetch@*",
+    "name": "@types/d3-fetch",
+    "escapedName": "@types%2fd3-fetch",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-fetch/-/d3-fetch-2.0.0.tgz",
+  "_shasum": "580846256ed0011b36a08ebb36924e0dff70e27e",
+  "_spec": "@types/d3-fetch@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Hugues Stefanski",
+      "url": "https://github.com/ledragon"
+    },
+    {
+      "name": "denisname",
+      "url": "https://github.com/denisname"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {
+    "@types/d3-dsv": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for d3-fetch",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-fetch",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-fetch"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "446ad6b27703e6727241f190a846cae2e474e20680f81d7de480d83a7d5d987f",
+  "version": "2.0.0"
+}

node_modules/@types/d3-force/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-force/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-force`
+
+# Summary
+This package contains type definitions for D3JS d3-force module (https://github.com/d3/d3-force/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-force.
+
+### Additional Details
+ * Last updated: Thu, 01 Oct 2020 22:50:46 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-force/index.d.ts

@@ -0,0 +1,1281 @@
+// Type definitions for D3JS d3-force module 2.1
+// Project: https://github.com/d3/d3-force/, https://d3js.org/d3-force
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Last module patch version validated against: 2.1.1
+
+// -----------------------------------------------------------------------
+// Force Simulation
+// -----------------------------------------------------------------------
+
+/**
+ * The base data structure for the datum of a Simulation Node.
+ * The optional properties contained in this data structure are internally assigned
+ * by the Simulation upon (re-)initialization.
+ *
+ * When defining a data type to use for node data, it should be an extension of this interface
+ * and respect the already "earmarked" properties used by the simulation.
+ *
+ * IMPORTANT: Prior to initialization, the following properties are optional: index, x, y, vx, and vy.
+ * After initialization they will be defined. The optional properties fx and fy are ONLY defined,
+ * if the node's position has been fixed.
+ */
+export interface SimulationNodeDatum {
+    /**
+     * Node’s zero-based index into nodes array. This property is set during the initialization process of a simulation.
+     */
+    index?: number;
+    /**
+     * Node’s current x-position
+     */
+    x?: number;
+    /**
+     * Node’s current y-position
+     */
+    y?: number;
+    /**
+     * Node’s current x-velocity
+     */
+    vx?: number;
+    /**
+     * Node’s current y-velocity
+     */
+    vy?: number;
+    /**
+     * Node’s fixed x-position (if position was fixed)
+     */
+    fx?: number | null;
+    /**
+     * Node’s fixed y-position (if position was fixed)
+     */
+    fy?: number | null;
+}
+
+/**
+ * The base data structure for the datum of a Simulation Link, as used by ForceLink.
+ * The optional properties contained in this data structure are internally assigned
+ * by when initializing with ForceLink.links(...)
+ *
+ *
+ * IMPORTANT: The source and target properties may be internally mutated in type during the
+ * ForceLink initialization process (possibly being changed from a node index in the nodes array,
+ * or a node id string to the simulation node object which was mapped in using the current
+ * ForceLink.id(...) accessor function.)
+ */
+export interface SimulationLinkDatum<NodeDatum extends SimulationNodeDatum> {
+    /**
+     * Link’s source node.
+     * For convenience, a link’s source and target properties may be initialized using numeric or string identifiers rather than object references; see link.id.
+     * When the link force is initialized (or re-initialized, as when the nodes or links change), any link.source or link.target property which is not an object
+     * is replaced by an object reference to the corresponding node with the given identifier.
+     * After initialization, the source property represents the source node object.
+     */
+    source: NodeDatum | string | number;
+    /**
+     * Link’s source link
+     * For convenience, a link’s source and target properties may be initialized using numeric or string identifiers rather than object references; see link.id.
+     * When the link force is initialized (or re-initialized, as when the nodes or links change), any link.source or link.target property which is not an object
+     * is replaced by an object reference to the corresponding node with the given identifier.
+     * After initialization, the target property represents the target node object.
+     */
+    target: NodeDatum | string | number;
+    /**
+     * The zero-based index into the links array. Internally generated when calling ForceLink.links(...)
+     */
+    index?: number;
+}
+
+/**
+ * A Force Simulation
+ *
+ * The first generic refers to the type of the datum associated with a node in the simulation.
+ * The second generic refers to the type of the datum associated with a link in the simulation, if applicable.
+ *
+ */
+export interface Simulation<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined> {
+    /**
+     * Restart the simulation’s internal timer and return the simulation.
+     * In conjunction with simulation.alphaTarget or simulation.alpha, this method can be used to “reheat” the simulation during interaction,
+     * such as when dragging a node, or to resume the simulation after temporarily pausing it with simulation.stop.
+     */
+    restart(): this;
+
+    /**
+     * Stop the simulation’s internal timer, if it is running, and return the simulation. If the timer is already stopped, this method does nothing.
+     * This method is useful for running the simulation manually; see simulation.tick.
+     */
+    stop(): this;
+
+    /**
+     * Manually steps the simulation by the specified number of *iterations*, and returns the simulation. If *iterations* is not specified, it defaults to 1 (single step).
+     *
+     * For each iteration, it increments the current alpha by (alphaTarget - alpha) × alphaDecay; then invokes each registered force, passing the new alpha;
+     * then decrements each node’s velocity by velocity × velocityDecay; lastly increments each node’s position by velocity.
+     *
+     * This method does not dispatch events; events are only dispatched by the internal timer when the simulation is started automatically upon
+     * creation or by calling simulation.restart. The natural number of ticks when the simulation is started is
+     * ⌈log(alphaMin) / log(1 - alphaDecay)⌉; by default, this is 300.
+     */
+    tick(iterations?: number): void;
+
+    /**
+     * Returns the simulation’s array of nodes as specified to the constructor.
+     */
+    nodes(): NodeDatum[];
+    /**
+     * Set the simulation’s nodes to the specified array of objects, initialize their positions and velocities if necessary,
+     * and then re-initialize any bound forces; Returns the simulation.
+     *
+     * Each node must be an object. The following properties are assigned by the simulation:
+     * - index (the node’s zero-based index into nodes)
+     * - x (the node’s current x-position)
+     * - y (the node’s current y-position)
+     * - vx (the node’s current x-velocity)
+     * - vy (the node’s current y-velocity)
+     *
+     * The position [x,y] and velocity [vx,vy] may be subsequently modified by forces and by the simulation.
+     * If either vx or vy is NaN, the velocity is initialized to [0,0]. If either x or y is NaN, the position is initialized in a phyllotaxis arrangement,
+     * so chosen to ensure a deterministic, uniform distribution.
+     *
+     * To fix a node in a given position, you may specify two additional properties:
+     * - fx (the node’s fixed x-position)
+     * - fy (the node’s fixed y-position)
+     *
+     * At the end of each tick, after the application of any forces, a node with a defined node.fx has node.x reset to this value and node.vx set to zero;
+     * likewise, a node with a defined node.fy has node.y reset to this value and node.vy set to zero.
+     * To unfix a node that was previously fixed, set node.fx and node.fy to null, or delete these properties.
+     *
+     * If the specified array of nodes is modified, such as when nodes are added to or removed from the simulation,
+     * this method must be called again with the new (or changed) array to notify the simulation and bound forces of the change;
+     * the simulation does not make a defensive copy of the specified array.
+     */
+    nodes(nodesData: NodeDatum[]): this;
+
+    /**
+     * Return the current alpha of the simulation, which defaults to 1.
+     *
+     * alpha is roughly analogous to temperature in simulated annealing.
+     * It decreases over time as the simulation “cools down”.
+     * When alpha reaches alphaMin, the simulation stops; see simulation.restart.
+     */
+    alpha(): number;
+    /**
+     * Set the current alpha to the specified number in the range [0,1] and return this simulation.
+     * The default is 1.
+     *
+     * alpha is roughly analogous to temperature in simulated annealing.
+     * It decreases over time as the simulation “cools down”.
+     * When alpha reaches alphaMin, the simulation stops; see simulation.restart.
+     *
+     * @param alpha Current alpha of simulation.
+     */
+    alpha(alpha: number): this;
+
+    /**
+     * Return the current minimum alpha value, which defaults to 0.001.
+     */
+    alphaMin(): number;
+    /**
+     * Set the minimum alpha to the specified number in the range [0,1] and return this simulation.
+     * The default is 0.001. The simulation’s internal timer stops when the current alpha is less than the minimum alpha.
+     * The default alpha decay rate of ~0.0228 corresponds to 300 iterations.
+     *
+     * @param min Minimum alpha of simulation.
+     */
+    alphaMin(min: number): this;
+
+    /**
+     * Return the current alpha decay rate, which defaults to 0.0228… = 1 - pow(0.001, 1 / 300) where 0.001 is the default minimum alpha.
+     */
+    alphaDecay(): number;
+    /**
+     * Set the alpha decay rate to the specified number in the range [0,1] and return this simulation.
+     * The default is 0.0228… = 1 - pow(0.001, 1 / 300) where 0.001 is the default minimum alpha.
+     *
+     * The alpha decay rate determines how quickly the current alpha interpolates towards the desired target alpha;
+     * since the default target alpha is zero, by default this controls how quickly the simulation cools.
+     * Higher decay rates cause the simulation to stabilize more quickly, but risk getting stuck in a local minimum;
+     * lower values cause the simulation to take longer to run, but typically converge on a better layout.
+     * To have the simulation run forever at the current alpha, set the decay rate to zero;
+     * alternatively, set a target alpha greater than the minimum alpha.
+     *
+     * @param decay Alpha decay rate.
+     */
+    alphaDecay(decay: number): this;
+
+    /**
+     * Returns the current target alpha value, which defaults to 0.
+     */
+    alphaTarget(): number;
+    /**
+     * Set the current target alpha to the specified number in the range [0,1] and return this simulation.
+     * The default is 0.
+     *
+     * @param target Alpha target value.
+     */
+    alphaTarget(target: number): this;
+
+    /**
+     * Return the current target alpha value, which defaults to 0.4.
+     */
+    velocityDecay(): number;
+    /**
+     * Set the velocity decay factor to the specified number in the range [0,1] and return this simulation.
+     * The default is 0.4.
+     *
+     * The decay factor is akin to atmospheric friction; after the application of any forces during a tick,
+     * each node’s velocity is multiplied by 1 - decay. As with lowering the alpha decay rate,
+     * less velocity decay may converge on a better solution, but risks numerical instabilities and oscillation.
+     *
+     * @param decay Velocity Decay.
+     */
+    velocityDecay(decay: number): this;
+
+    /**
+     * Return the force with the specified name, or undefined if there is no such force.
+     * (By default, new simulations have no forces.)
+     *
+     * Given that it is in general not known, what type of force has been registered under
+     * a specified name, use the generic to cast the result to the appropriate type, if known.
+     *
+     * @param name Name of the registered force.
+     */
+    force<F extends Force<NodeDatum, LinkDatum>>(name: string): F| undefined;
+    /**
+     * Remove a previously registered force.
+     *
+     * @param name Name of the registered force.
+     * @param force Use null to remove force.
+     */
+    force(name: string, force: null): this;
+    /**
+     * Assign the force for the specified name and return this simulation.
+     * (By default, new simulations have no forces.)
+     *
+     * @param name Name to register the force under.
+     * @param force A force to use with the simulation.
+     */
+    force(name: string, force: Force<NodeDatum, LinkDatum>): this;
+
+    /**
+     * Return the node closest to the position [x,y] with the given search radius.
+     * If radius is not specified, it defaults to infinity.
+     * If there is no node within the search area, returns undefined.
+     *
+     * @param x x-coordinate
+     * @param y y-coordinate
+     * @param radius Optional search radius. Defaults to infinity.
+     */
+    find(x: number, y: number, radius?: number): NodeDatum | undefined;
+
+    /**
+     * Returns this simulation’s current random source which defaults to a fixed-seed linear congruential generator.
+     * See also random.source.
+     */
+    randomSource(): () => number;
+    /**
+     * Sets the function used to generate random numbers; this should be a function that returns a number between 0 (inclusive) and 1 (exclusive).
+     *
+     * @param source The function used to generate random numbers.
+     */
+    randomSource(source: () => number): this;
+
+    /**
+     * Return the first currently-assigned listener matching the specified typenames, if any.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace. Each typename is a type,
+     * optionally followed by a period (.) and a name, such as "tick.foo" and "tick.bar"; the name allows multiple listeners to be registered for the same type.
+     * The type must be one of the following: "tick" (after each tick of the simulation’s internal timer) or
+     * "end" (after the simulation’s timer stops when alpha < alphaMin).
+     */
+    on(typenames: 'tick' | 'end' | string): ((this: Simulation<NodeDatum, LinkDatum>) => void) | undefined;
+    /**
+     * Remove the current event listeners for the specified typenames, if any, return the simulation.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace. Each typename is a type,
+     * optionally followed by a period (.) and a name, such as "tick.foo" and "tick.bar"; the name allows multiple listeners to be registered for the same type.
+     * The type must be one of the following: "tick" (after each tick of the simulation’s internal timer) or
+     * "end" (after the simulation’s timer stops when alpha < alphaMin).
+     * @param listener Use null to remove the listener.
+     */
+    on(typenames: 'tick' | 'end' | string, listener: null): this;
+    /**
+     * Set the event listener for the specified typenames and return this simulation.
+     * If an event listener was already registered for the same type and name,
+     * the existing listener is removed before the new listener is added.
+     * When a specified event is dispatched, each listener will be invoked with the this context as the simulation.
+     *
+     * The type must be one of the following:
+     * - tick [after each tick of the simulation’s internal timer]
+     * - end [after the simulation’s timer stops when alpha < alphaMin]
+     *
+     * Note that tick events are not dispatched when simulation.tick is called manually;
+     * events are only dispatched by the internal timer and are intended for interactive rendering of the simulation.
+     * To affect the simulation, register forces instead of modifying nodes’ positions or velocities inside a tick event listener.
+     *
+     * @param typenames The typenames is a string containing one or more typename separated by whitespace. Each typename is a type,
+     * optionally followed by a period (.) and a name, such as "tick.foo" and "tick.bar"; the name allows multiple listeners to be registered for the same type.
+     * The type must be one of the following: "tick" (after each tick of the simulation’s internal timer) or
+     * "end" (after the simulation’s timer stops when alpha < alphaMin).
+     * @param listener An event listener function which is invoked with the this context of the simulation.
+     */
+    on(typenames: 'tick' | 'end' | string, listener: (this: this) => void): this;
+}
+
+/**
+ * Create a new simulation with the specified array of nodes and no forces.
+ * If nodes is not specified, it defaults to the empty array.
+ * The simulator starts automatically; use simulation.on to listen for tick events as the simulation runs.
+ * If you wish to run the simulation manually instead, call simulation.stop, and then call simulation.tick as desired.
+ *
+ * Use this signature, when creating a simulation WITHOUT link force(s).
+ *
+ * The generic refers to the type of the data for a node.
+ *
+ * @param nodesData Optional array of nodes data, defaults to empty array.
+ */
+export function forceSimulation<NodeDatum extends SimulationNodeDatum>(nodesData?: NodeDatum[]): Simulation<NodeDatum, undefined>;
+/**
+ * Create a new simulation with the specified array of nodes and no forces.
+ * If nodes is not specified, it defaults to the empty array.
+ * The simulator starts automatically; use simulation.on to listen for tick events as the simulation runs.
+ * If you wish to run the simulation manually instead, call simulation.stop, and then call simulation.tick as desired.
+ *
+ * Use this signature, when creating a simulation WITH link force(s).
+ *
+ * The first generic refers to the type of data for a node.
+ * The second generic refers to the type of data for a link.
+ *
+ * @param nodesData Optional array of nodes data, defaults to empty array.
+ */
+export function forceSimulation<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum>>(nodesData?: NodeDatum[]): Simulation<NodeDatum, LinkDatum>;
+
+// ----------------------------------------------------------------------
+// Forces
+// ----------------------------------------------------------------------
+
+/**
+ * A force is simply a function that modifies nodes’ positions or velocities; in this context, a force can apply a classical physical force such as electrical charge or gravity,
+ * or it can resolve a geometric constraint, such as keeping nodes within a bounding box or keeping linked nodes a fixed distance apart.
+ *
+ * Forces typically read the node’s current position [x,y] and then add to (or subtract from) the node’s velocity [vx,vy].
+ * However, forces may also “peek ahead” to the anticipated next position of the node, [x + vx,y + vy]; this is necessary for resolving geometric constraints through iterative relaxation.
+ * Forces may also modify the position directly, which is sometimes useful to avoid adding energy to the simulation, such as when recentering the simulation in the viewport.
+ *
+ * Forces may optionally implement force.initialize to receive the simulation’s array of nodes.
+ */
+export interface Force<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum> | undefined> {
+    /**
+     * Apply this force, optionally observing the specified alpha.
+     * Typically, the force is applied to the array of nodes previously passed to force.initialize,
+     * however, some forces may apply to a subset of nodes, or behave differently.
+     * For example, d3.forceLink applies to the source and target of each link.
+     */
+    (alpha: number): void;
+    /**
+     * Supplies the array of nodes and random source to this force. This method is called when a force is bound to a simulation via simulation.force
+     * and when the simulation’s nodes change via simulation.nodes.
+     *
+     * A force may perform necessary work during initialization, such as evaluating per-node parameters, to avoid repeatedly performing work during each application of the force.
+     */
+    initialize?(nodes: NodeDatum[], random: () => number): void;
+}
+
+// Centering ------------------------------------------------------------
+
+/**
+ * The centering force translates nodes uniformly so that the mean position of all nodes
+ * (the center of mass if all nodes have equal weight) is at the given position [x,y].
+ * This force modifies the positions of nodes on each application; it does not modify velocities,
+ * as doing so would typically cause the nodes to overshoot and oscillate around the desired center.
+ * This force helps keeps nodes in the center of the viewport, and unlike the positioning force,
+ * it does not distort their relative positions.
+ *
+ * The generic refers to the type of data for a node.
+ */
+export interface ForceCenter<NodeDatum extends SimulationNodeDatum> extends Force<NodeDatum, any> {
+    /**
+     * Supplies the array of nodes and random source to this force. This method is called when a force is bound to a simulation via simulation.force
+     * and when the simulation’s nodes change via simulation.nodes.
+     *
+     * A force may perform necessary work during initialization, such as evaluating per-node parameters, to avoid repeatedly performing work during each application of the force.
+     */
+    initialize(nodes: NodeDatum[], random: () => number): void;
+
+    /**
+     * Return the current x-coordinate of the centering position, which defaults to zero.
+     */
+    x(): number;
+    /**
+     * Set the x-coordinate of the centering position.
+     *
+     * @param x x-coordinate.
+     */
+    x(x: number): this;
+
+    /**
+     * Return the current y-coordinate of the centering position, which defaults to zero.
+     */
+    y(): number;
+    /**
+     * Set the y-coordinate of the centering position.
+     *
+     * @param y y-coordinate.
+     */
+    y(y: number): this;
+
+    /**
+     * Returns the force’s current strength, which defaults to 1.
+     */
+    strength(): number;
+
+    /**
+     * Sets the centering force’s strength.
+     * A reduced strength of e.g. 0.05 softens the movements on interactive graphs in which new nodes enter or exit the graph.
+     * @param strength The centering force's strength.
+     */
+    strength(strength: number): this;
+}
+
+/**
+ * Create a new centering force with the specified x- and y- coordinates.
+ * If x and y are not specified, they default to [0,0].
+ *
+ * The centering force translates nodes uniformly so that the mean position of all nodes
+ * (the center of mass if all nodes have equal weight) is at the given position [x,y].
+ * This force modifies the positions of nodes on each application; it does not modify velocities,
+ * as doing so would typically cause the nodes to overshoot and oscillate around the desired center.
+ * This force helps keeps nodes in the center of the viewport, and unlike the positioning force,
+ * it does not distort their relative positions.
+ *
+ * The generic refers to the type of data for a node.
+ *
+ * @param x An optional x-coordinate for the centering position, defaults to 0.
+ * @param y An optional y-coordinate for the centering position, defaults to 0.
+ */
+export function forceCenter<NodeDatum extends SimulationNodeDatum>(x?: number, y?: number): ForceCenter<NodeDatum>;
+
+// Collision ------------------------------------------------------------
+
+/**
+ * The collision force treats nodes as circles with a given radius, rather than points, and prevents nodes from overlapping.
+ * More formally, two nodes a and b are separated so that the distance between a and b is at least radius(a) + radius(b).
+ * To reduce jitter, this is by default a “soft” constraint with a configurable strength and iteration count.
+ *
+ * The generic refers to the type of data for a node.
+ */
+export interface ForceCollide<NodeDatum extends SimulationNodeDatum> extends Force<NodeDatum, any> {
+    /**
+     * Supplies the array of nodes and random source to this force. This method is called when a force is bound to a simulation via simulation.force
+     * and when the simulation’s nodes change via simulation.nodes.
+     *
+     * A force may perform necessary work during initialization, such as evaluating per-node parameters, to avoid repeatedly performing work during each application of the force.
+     */
+    initialize(nodes: NodeDatum[], random: () => number): void;
+
+    /**
+     * Returns the current radius accessor function.
+     */
+    radius(): (node: NodeDatum, i: number, nodes: NodeDatum[]) => number;
+    /**
+     * Set the radius used in collision detection to a constant number for each node.
+     *
+     * The constant is internally wrapped into a radius accessor function.
+     *
+     * The radius accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the radius of each node is only recomputed
+     * when the force is initialized or when this method is called with a new radius, and not on every application of the force.
+     *
+     * @param radius A constant radius for each node.
+     */
+    radius(radius: number): this;
+    /**
+     * Set the radius accessor function determining the radius for each node in collision detection.
+     *
+     * The radius accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the radius of each node is only recomputed
+     * when the force is initialized or when this method is called with a new radius, and not on every application of the force.
+     *
+     * @param radius A radius accessor function which is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The function returns a radius.
+     */
+    radius(radius: (node: NodeDatum, i: number, nodes: NodeDatum[]) => number): this;
+
+    /**
+     * Return the current strength, which defaults to 1.
+     */
+    strength(): number;
+    /**
+     * Set the force strength to the specified number in the range [0,1] and return this force.
+     * The default strength is 0.7.
+     *
+     * Overlapping nodes are resolved through iterative relaxation.
+     * For each node, the other nodes that are anticipated to overlap at the next tick (using the anticipated positions [x + vx,y + vy]) are determined;
+     * the node’s velocity is then modified to push the node out of each overlapping node.
+     * The change in velocity is dampened by the force’s strength such that the resolution of simultaneous overlaps can be blended together to find a stable solution.
+     *
+     * @param strength Strength.
+     */
+    strength(strength: number): this;
+
+    /**
+     * Return the current iteration count which defaults to 1.
+     */
+    iterations(): number;
+    /**
+     * Sets the number of iterations per application to the specified number and return this force.
+     *
+     * Increasing the number of iterations greatly increases the rigidity of the constraint and avoids partial overlap of nodes,
+     * but also increases the runtime cost to evaluate the force.
+     *
+     * @param iterations Number of iterations.
+     */
+    iterations(iterations: number): this;
+}
+
+/**
+ * Creates a new circle collision force with the default radius one for all nodes.
+ *
+ * The collision force treats nodes as circles with a given radius, rather than points, and prevents nodes from overlapping.
+ * More formally, two nodes a and b are separated so that the distance between a and b is at least radius(a) + radius(b).
+ * To reduce jitter, this is by default a “soft” constraint with a configurable strength and iteration count.
+ *
+ * The generic refers to the type of data for a node.
+ */
+export function forceCollide<NodeDatum extends SimulationNodeDatum>(): ForceCollide<NodeDatum>;
+/**
+ * Create a new circle collision force with the specified constant radius for all nodes.
+ *
+ * The collision force treats nodes as circles with a given radius, rather than points, and prevents nodes from overlapping.
+ * More formally, two nodes a and b are separated so that the distance between a and b is at least radius(a) + radius(b).
+ * To reduce jitter, this is by default a “soft” constraint with a configurable strength and iteration count.
+ *
+ * The generic refers to the type of data for a node.
+ *
+ * @param radius A constant radius for each node.
+ */
+export function forceCollide<NodeDatum extends SimulationNodeDatum>(radius: number): ForceCollide<NodeDatum>;
+/**
+ * Creates a new circle collision force with the specified radius accessor function.
+ *
+ * The collision force treats nodes as circles with a given radius, rather than points, and prevents nodes from overlapping.
+ * More formally, two nodes a and b are separated so that the distance between a and b is at least radius(a) + radius(b).
+ * To reduce jitter, this is by default a “soft” constraint with a configurable strength and iteration count.
+ *
+ * The radius accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+ * The resulting number is then stored internally, such that the radius of each node is only recomputed
+ * when the force is initialized or when this method is called with a new radius, and not on every application of the force.
+ *
+ * @param radius A radius accessor function which is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+ * The function returns a radius.
+ */
+export function forceCollide<NodeDatum extends SimulationNodeDatum>(radius: (node: NodeDatum, i: number, nodes: NodeDatum[]) => number): ForceCollide<NodeDatum>;
+
+// Link ----------------------------------------------------------------
+
+/**
+ * The link force pushes linked nodes together or apart according to the desired link distance.
+ * The strength of the force is proportional to the difference between the linked nodes’ distance and the target distance, similar to a spring force.
+ *
+ * The first generic refers to the type of data for a node.
+ * The second generic refers to the type of data for a link.
+ */
+export interface ForceLink<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum>> extends Force<NodeDatum, LinkDatum> {
+    /**
+     * Supplies the array of nodes and random source to this force. This method is called when a force is bound to a simulation via simulation.force
+     * and when the simulation’s nodes change via simulation.nodes.
+     *
+     * A force may perform necessary work during initialization, such as evaluating per-node parameters, to avoid repeatedly performing work during each application of the force.
+     */
+    initialize(nodes: NodeDatum[], random: () => number): void;
+
+    /**
+     * Return the current array of links, which defaults to the empty array.
+     *
+     */
+    links(): LinkDatum[];
+    /**
+     * Set the array of links associated with this force, recompute the distance and strength parameters for each link, and return this force.
+     *
+     * Each link is an object with the following properties:
+     * * source - the link’s source node; see simulation.nodes
+     * * target - the link’s target node; see simulation.nodes
+     * * index - the zero-based index into links, assigned by this method
+     *
+     * For convenience, a link’s source and target properties may be initialized using numeric or string identifiers rather than object references; see link.id.
+     * When the link force is initialized (or re-initialized, as when the nodes or links change), any link.source or link.target property which is not an object
+     * is replaced by an object reference to the corresponding node with the given identifier.
+     * If the specified array of links is modified, such as when links are added to or removed from the simulation,
+     * this method must be called again with the new (or changed) array to notify the force of the change;
+     * the force does not make a defensive copy of the specified array.
+     *
+     * @param links An array of link data.
+     */
+    links(links: LinkDatum[]): this;
+
+    /**
+     * Return the current node id accessor, which defaults to the numeric node.index.
+     */
+    id(): (node: NodeDatum, i: number, nodesData: NodeDatum[]) => (string | number);
+    /**
+     * Set the node id accessor to the specified function and return this force.
+     *
+     * The default id accessor allows each link’s source and target to be specified as a zero-based index
+     * into the nodes array.
+     *
+     * The id accessor is invoked for each node whenever the force is initialized,
+     * as when the nodes or links change, being passed the node, the zero-based index of the node in the node array, and the node array.
+     *
+     * @param id A node id accessor function which is invoked for each node in the simulation,
+     * being passed the node, the zero-based index of the node in the node array, and the node array. It returns a string to represent the node id which can be used
+     * for matching link source and link target strings during the ForceLink initialization.
+     */
+    id(id: (node: NodeDatum, i: number, nodesData: NodeDatum[]) => string): this;
+
+    /**
+     * Return the current distance accessor, which defaults to implying a default distance of 30.
+     */
+    distance(): (link: LinkDatum, i: number, links: LinkDatum[]) => number;
+    /**
+     * Set the distance accessor to use the specified constant number for all links,
+     * re-evaluates the distance accessor for each link, and returns this force.
+     *
+     * The constant is internally wrapped into a distance accessor function.
+     *
+     * The distance accessor is invoked for each link, being passed the link, its zero-based index and the complete array of links.
+     * The resulting number is then stored internally, such that the distance of each link is only recomputed when the force is initialized or
+     * when this method is called with a new distance, and not on every application of the force.
+     *
+     * @param distance The constant distance to be used for all links.
+     */
+    distance(distance: number): this;
+    /**
+     * Set the distance accessor to use the specified function,
+     * re-evaluates the distance accessor for each link, and returns this force.
+     *
+     * The distance accessor is invoked for each link, being passed the link, its zero-based index and the complete array of links.
+     * The resulting number is then stored internally, such that the distance of each link is only recomputed when the force is initialized or
+     * when this method is called with a new distance, and not on every application of the force.
+     *
+     * @param distance A distance accessor function which is invoked for each link being passed the link,
+     * its zero-based index and the complete array of links. It returns the distance.
+     */
+    distance(distance: (link: LinkDatum, i: number, links: LinkDatum[]) => number): this;
+
+    /**
+     * Return the current strength accessor.
+     * For details regarding the default behavior see: {@link https://github.com/d3/d3-force#link_strength}
+     */
+    strength(): (link: LinkDatum, i: number, links: LinkDatum[]) => number;
+    /**
+     * Set the strength accessor to use the specified constant number for all links,
+     * re-evaluates the strength accessor for each link, and returns this force.
+     *
+     * The constant is internally wrapped into a strength accessor function.
+     *
+     * The strength accessor is invoked for each link, being passed the link, its zero-based index and the complete array of links.
+     * The resulting number is then stored internally, such that the strength of each link is only recomputed
+     * when the force is initialized or when this method is called with a new strength, and not on every application of the force.
+     *
+     * @param strength The constant strength to be used for all links.
+     */
+    strength(strength: number): this;
+    /**
+     * Set the strength accessor to use the specified function,
+     * re-evaluates the strength accessor for each link, and returns this force.
+     *
+     * The strength accessor is invoked for each link, being passed the link, its zero-based index and the complete array of links.
+     * The resulting number is then stored internally, such that the strength of each link is only recomputed
+     * when the force is initialized or when this method is called with a new strength, and not on every application of the force.
+     *
+     * @param strength A distance accessor function which is invoked for each link being passed the link,
+     * its zero-based index and the complete array of links. It returns the strength.
+     */
+    strength(strength: (link: LinkDatum, i: number, links: LinkDatum[]) => number): this;
+
+    /**
+     * Return the current iteration count which defaults to 1.
+     */
+    iterations(): number;
+    /**
+     * Sets the number of iterations per application to the specified number and return this force.
+     *
+     * Increasing the number of iterations greatly increases the rigidity of the constraint and is useful for complex structures such as lattices,
+     * but also increases the runtime cost to evaluate the force.
+     *
+     * @param iterations Number of iterations.
+     */
+    iterations(iterations: number): this;
+}
+
+/**
+ * Creates a new link force with the defaulting links to an empty array.
+ *
+ * The link force pushes linked nodes together or apart according to the desired link distance.
+ * The strength of the force is proportional to the difference between the linked nodes’ distance and the target distance, similar to a spring force.
+ *
+ * The first generic refers to the type of data for a node.
+ * The second generic refers to the type of data for a link.
+ */
+export function forceLink<NodeDatum extends SimulationNodeDatum, LinksDatum extends SimulationLinkDatum<NodeDatum>>(): ForceLink<NodeDatum, LinksDatum>;
+/**
+ * Creates a new link force with the specified links array.
+ *
+ * The link force pushes linked nodes together or apart according to the desired link distance.
+ * The strength of the force is proportional to the difference between the linked nodes’ distance and the target distance, similar to a spring force.
+ *
+ * The first generic refers to the type of data for a node.
+ * The second generic refers to the type of data for a link.
+ *
+ * @param links An array of link data.
+ */
+export function forceLink<NodeDatum extends SimulationNodeDatum, LinksDatum extends SimulationLinkDatum<NodeDatum>>(links: LinksDatum[]): ForceLink<NodeDatum, LinksDatum>;
+
+// Many Body ----------------------------------------------------------------
+
+/**
+ * The many-body (or n-body) force applies mutually amongst all nodes. It can be used to simulate gravity (attraction) if the strength is positive,
+ * or electrostatic charge (repulsion) if the strength is negative. This implementation uses quadtrees and the Barnes–Hut approximation to greatly
+ * improve performance; the accuracy can be customized using the theta parameter.
+ *
+ * Unlike links, which only affect two linked nodes, the charge force is global: every node affects every other node, even if they are on disconnected subgraphs.
+ *
+ * The generic refers to the type of data for a node.
+ */
+export interface ForceManyBody<NodeDatum extends SimulationNodeDatum> extends Force<NodeDatum, any> {
+    /**
+     * Supplies the array of nodes and random source to this force. This method is called when a force is bound to a simulation via simulation.force
+     * and when the simulation’s nodes change via simulation.nodes.
+     *
+     * A force may perform necessary work during initialization, such as evaluating per-node parameters, to avoid repeatedly performing work during each application of the force.
+     */
+    initialize(nodes: NodeDatum[], random: () => number): void;
+
+    /**
+     * Return the current strength accessor.
+     *
+     * For details regarding the default behavior see: {@link https://github.com/d3/d3-force#manyBody_strength}
+     */
+    strength(): (d: NodeDatum, i: number, data: NodeDatum[]) => number;
+    /**
+     * Set the strength accessor to the specified constant strength for all nodes, re-evaluates the strength accessor for each node, and
+     * returns this force.
+     *
+     * A positive value causes nodes to attract each other, similar to gravity, while a negative value causes nodes to repel each other,
+     * similar to electrostatic charge.
+     *
+     * The default represents a constant value of -30.
+     *
+     * The constant is internally wrapped into a strength accessor function.
+     *
+     * The strength accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the strength of each node is only recomputed when the force is initialized or
+     * when this method is called with a new strength, and not on every application of the force.
+     *
+     * @param strength The constant strength to be used for all nodes.
+     */
+    strength(strength: number): this;
+    /**
+     * Set the strength accessor to the specified function, re-evaluates the strength accessor for each node, and
+     * returns this force.
+     *
+     * A positive value causes nodes to attract each other, similar to gravity, while a negative value causes nodes to repel each other,
+     * similar to electrostatic charge.
+     *
+     * The default represents a constant value of -30.
+     *
+     * The strength accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the strength of each node is only recomputed when the force is initialized or
+     * when this method is called with a new strength, and not on every application of the force.
+     *
+     * @param strength A strength accessor function which is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The function returns the strength.
+     */
+    strength(strength: (d: NodeDatum, i: number, data: NodeDatum[]) => number): this;
+
+    /**
+     * Return the current value of the Barnes–Hut approximation criterion , which defaults to 0.9
+     */
+    theta(): number;
+    /**
+     * Set the Barnes–Hut approximation criterion to the specified number and returns this force.
+     *
+     * To accelerate computation, this force implements the Barnes–Hut approximation which takes O(n log n) per application
+     * where n is the number of nodes. For each application, a quadtree stores the current node positions;
+     * then for each node, the combined force of all other nodes on the given node is computed.
+     * For a cluster of nodes that is far away, the charge force can be approximated by treating the cluster as a single, larger node.
+     * The theta parameter determines the accuracy of the approximation:
+     * if the ratio w / l of the width w of the quadtree cell to the distance l from the node to the cell’s center of mass is less than theta,
+     * all nodes in the given cell are treated as a single node rather than individually.
+     *
+     * The default value is 0.9.
+     *
+     * @param theta Value for the theta parameter.
+     */
+    theta(theta: number): this;
+
+    /**
+     * Returns the current minimum distance over which this force is considered, which defaults to 1.
+     */
+    distanceMin(): number;
+    /**
+     * Sets the minimum distance between nodes over which this force is considered.
+     *
+     * A minimum distance establishes an upper bound on the strength of the force between two nearby nodes, avoiding instability.
+     * In particular, it avoids an infinitely-strong force if two nodes are exactly coincident; in this case, the direction of the force is random.
+     *
+     * The default value is 1.
+     *
+     * @param distance The minimum distance between nodes over which this force is considered.
+     */
+    distanceMin(distance: number): this;
+
+    /**
+     * Returns the current maximum distance over which this force is considered, which defaults to infinity.
+     */
+    distanceMax(): number;
+    /**
+     * Sets the maximum distance between nodes over which this force is considered.
+     *
+     * Specifying a finite maximum distance improves performance and produces a more localized layout.
+     *
+     * The default value is infinity.
+     *
+     * @param distance The maximum distance between nodes over which this force is considered.
+     */
+    distanceMax(distance: number): this;
+}
+
+/**
+ * Creates a new many-body force with the default parameters.
+ *
+ * The many-body (or n-body) force applies mutually amongst all nodes. It can be used to simulate gravity (attraction) if the strength is positive,
+ * or electrostatic charge (repulsion) if the strength is negative. This implementation uses quadtrees and the Barnes–Hut approximation to greatly
+ * improve performance; the accuracy can be customized using the theta parameter.
+ *
+ * Unlike links, which only affect two linked nodes, the charge force is global: every node affects every other node, even if they are on disconnected subgraphs.
+ *
+ * The generic refers to the type of data for a node.
+ */
+export function forceManyBody<NodeDatum extends SimulationNodeDatum>(): ForceManyBody<NodeDatum>;
+
+// Positioning ----------------------------------------------------------------
+
+/**
+ * The x-positioning force pushes nodes towards a desired position along the given dimension with a configurable strength.
+ * The strength of the force is proportional to the one-dimensional distance between the node’s position and the target position.
+ * While this force can be used to position individual nodes, it is intended primarily for global forces that apply to all (or most) nodes.
+ *
+ * The generic refers to the type of data for a node.
+ */
+export interface ForceX<NodeDatum extends SimulationNodeDatum> extends Force<NodeDatum, any> {
+    /**
+     * Supplies the array of nodes and random source to this force. This method is called when a force is bound to a simulation via simulation.force
+     * and when the simulation’s nodes change via simulation.nodes.
+     *
+     * A force may perform necessary work during initialization, such as evaluating per-node parameters, to avoid repeatedly performing work during each application of the force.
+     */
+    initialize(nodes: NodeDatum[], random: () => number): void;
+
+    /**
+     *  Returns the current strength accessor, which defaults to a constant strength for all nodes of 0.1.
+     */
+    strength(): (d: NodeDatum, i: number, data: NodeDatum[]) => number;
+    /**
+     * Set the strength accessor to the specified constant strength for all nodes, re-evaluates the strength accessor for each node, and returns this force.
+     *
+     * The strength determines how much to increment the node’s x-velocity: (x - node.x) × strength.
+     *
+     * For example, a value of 0.1 indicates that the node should move a tenth of the way from its current x-position to the target x-position with each application.
+     * Higher values moves nodes more quickly to the target position, often at the expense of other forces or constraints.
+     *
+     * A value outside the range [0,1] is not recommended.
+     *
+     * The constant is internally wrapped into a strength accessor function.
+     *
+     * The strength accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the strength of each node is only recomputed when the force is initialized or
+     * when this method is called with a new strength, and not on every application of the force.
+     *
+     * @param strength Constant value of strength to be used for all nodes.
+     */
+    strength(strength: number): this;
+    /**
+     * Set the strength accessor to the specified function, re-evaluates the strength accessor for each node, and returns this force.
+     *
+     * The strength determines how much to increment the node’s x-velocity: (x - node.x) × strength.
+     *
+     * For example, a value of 0.1 indicates that the node should move a tenth of the way from its current x-position to the target x-position with each application.
+     * Higher values moves nodes more quickly to the target position, often at the expense of other forces or constraints.
+     *
+     * A value outside the range [0,1] is not recommended.
+     *
+     * The strength accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the strength of each node is only recomputed when the force is initialized or
+     * when this method is called with a new strength, and not on every application of the force.
+     *
+     * @param strength A strength accessor function which is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The function returns the strength.
+     */
+    strength(strength: (d: NodeDatum, i: number, data: NodeDatum[]) => number): this;
+
+    /**
+     * Return the current x-accessor, which defaults to a function returning 0 for all nodes.
+     */
+    x(): (d: NodeDatum, i: number, data: NodeDatum[]) => number;
+    /**
+     * Set the x-coordinate accessor to the specified number, re-evaluates the x-accessor for each node,
+     * and returns this force.
+     *
+     * The constant is internally wrapped into an x-coordinate accessor function.
+     *
+     * The x-accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the target x-coordinate of each node is only recomputed when the force is initialized or
+     * when this method is called with a new x, and not on every application of the force.
+     *
+     * @param x Constant x-coordinate to be used for all nodes.
+     */
+    x(x: number): this;
+    /**
+     * Set the x-coordinate accessor to the specified function, re-evaluates the x-accessor for each node,
+     * and returns this force.
+     *
+     * The x-accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the target x-coordinate of each node is only recomputed when the force is initialized or
+     * when this method is called with a new x, and not on every application of the force.
+     *
+     * @param x A x-coordinate accessor function which is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The function returns the x-coordinate.
+     */
+    x(x: (d: NodeDatum, i: number, data: NodeDatum[]) => number): this;
+}
+
+/**
+ * Create a new positioning force along the x-axis towards the given position x which is defaulted to a constant 0 for all nodes.
+ *
+ * The x-positioning force pushes nodes towards a desired position along the given dimension with a configurable strength.
+ * The strength of the force is proportional to the one-dimensional distance between the node’s position and the target position.
+ * While this force can be used to position individual nodes, it is intended primarily for global forces that apply to all (or most) nodes.
+ *
+ * The generic refers to the type of data for a node.
+ */
+export function forceX<NodeDatum extends SimulationNodeDatum>(): ForceX<NodeDatum>;
+/**
+ * Create a new positioning force along the x-axis towards the given position x which is constant for all nodes.
+ *
+ * The x-positioning force pushes nodes towards a desired position along the given dimension with a configurable strength.
+ * The strength of the force is proportional to the one-dimensional distance between the node’s position and the target position.
+ * While this force can be used to position individual nodes, it is intended primarily for global forces that apply to all (or most) nodes.
+ *
+ * The generic refers to the type of data for a node.
+ *
+ * @param x Constant x-coordinate to be used for all nodes.
+ */
+export function forceX<NodeDatum extends SimulationNodeDatum>(x: number): ForceX<NodeDatum>;
+/**
+ * Create a new positioning force along the x-axis towards the position x given by evaluating the specified x-coordinate accessor
+ * for each node.
+ *
+ * The x-positioning force pushes nodes towards a desired position along the given dimension with a configurable strength.
+ * The strength of the force is proportional to the one-dimensional distance between the node’s position and the target position.
+ * While this force can be used to position individual nodes, it is intended primarily for global forces that apply to all (or most) nodes.
+ *
+ * The generic refers to the type of data for a node.
+ *
+ * @param x A x-coordinate accessor function which is invoked for each node in the simulation, being passed the node and its zero-based index.
+ * The function returns the x-coordinate.
+ */
+export function forceX<NodeDatum extends SimulationNodeDatum>(x: (d: NodeDatum, i: number, data: NodeDatum[]) => number): ForceX<NodeDatum>;
+
+/**
+ * The y-positioning force pushes nodes towards a desired position along the given dimension with a configurable strength.
+ * The strength of the force is proportional to the one-dimensional distance between the node’s position and the target position.
+ * While this force can be used to position individual nodes, it is intended primarily for global forces that apply to all (or most) nodes.
+ *
+ * The generic refers to the type of data for a node.
+ */
+export interface ForceY<NodeDatum extends SimulationNodeDatum> extends Force<NodeDatum, any> {
+    /**
+     * Supplies the array of nodes and random source to this force. This method is called when a force is bound to a simulation via simulation.force
+     * and when the simulation’s nodes change via simulation.nodes.
+     *
+     * A force may perform necessary work during initialization, such as evaluating per-node parameters, to avoid repeatedly performing work during each application of the force.
+     */
+    initialize(nodes: NodeDatum[], random: () => number): void;
+
+    /**
+     *  Returns the current strength accessor, which defaults to a constant strength for all nodes of 0.1.
+     */
+    strength(): (d: NodeDatum, i: number, data: NodeDatum[]) => number;
+    /**
+     * Set the strength accessor to the specified constant strength for all nodes, re-evaluates the strength accessor for each node, and returns this force.
+     *
+     * The strength determines how much to increment the node’s y-velocity: (y - node.y) × strength.
+     *
+     * For example, a value of 0.1 indicates that the node should move a tenth of the way from its current y-position to the target y-position with each application.
+     * Higher values moves nodes more quickly to the target position, often at the expense of other forces or constraints.
+     *
+     * A value outside the range [0,1] is not recommended.
+     *
+     * The constant is internally wrapped into a strength accessor function.
+     *
+     * The strength accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the strength of each node is only recomputed when the force is initialized or
+     * when this method is called with a new strength, and not on every application of the force.
+     *
+     * @param strength Constant value of strength to be used for all nodes.
+     */
+    strength(strength: number): this;
+    /**
+     * Set the strength accessor to the specified function, re-evaluates the strength accessor for each node, and returns this force.
+     *
+     * The strength determines how much to increment the node’s y-velocity: (y - node.y) × strength.
+     *
+     * For example, a value of 0.1 indicates that the node should move a tenth of the way from its current y-position to the target y-position with each application.
+     * Higher values moves nodes more quickly to the target position, often at the expense of other forces or constraints.
+     *
+     * A value outside the range [0,1] is not recommended.
+     *
+     * The strength accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the strength of each node is only recomputed when the force is initialized or
+     * when this method is called with a new strength, and not on every application of the force.
+     *
+     * @param strength A strength accessor function which is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The function returns the strength.
+     */
+    strength(strength: (d: NodeDatum, i: number, data: NodeDatum[]) => number): this;
+
+    /**
+     * Return the current y-accessor, which defaults to a function returning 0 for all nodes.
+     */
+    y(): (d: NodeDatum, i: number, data: NodeDatum[]) => number;
+    /**
+     * Set the y-coordinate accessor to the specified number, re-evaluates the y-accessor for each node,
+     * and returns this force.
+     *
+     * The constant is internally wrapped into a y-coordinate accessor function.
+     *
+     * The y-accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the target y-coordinate of each node is only recomputed when the force is initialized or
+     * when this method is called with a new y, and not on every application of the force.
+     *
+     * @param y Constant y-coordinate to be used for all nodes.
+     */
+    y(y: number): this;
+    /**
+     * Set the y-coordinate accessor to the specified function, re-evaluates the y-accessor for each node,
+     * and returns this force.
+     *
+     * The y-accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the target y-coordinate of each node is only recomputed when the force is initialized or
+     * when this method is called with a new y, and not on every application of the force.
+     *
+     * @param y A y-coordinate accessor function which is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The function returns the y-coordinate.
+     */
+    y(y: (d: NodeDatum, i: number, data: NodeDatum[]) => number): this;
+}
+
+/**
+ * Create a new positioning force along the y-axis towards the given position y which is defaulted to a constant 0 for all nodes.
+ *
+ * The y-positioning force pushes nodes towards a desired position along the given dimension with a configurable strength.
+ * The strength of the force is proportional to the one-dimensional distance between the node’s position and the target position.
+ * While this force can be used to position individual nodes, it is intended primarily for global forces that apply to all (or most) nodes.
+ *
+ * The generic refers to the type of data for a node.
+ */
+export function forceY<NodeDatum extends SimulationNodeDatum>(): ForceY<NodeDatum>;
+/**
+ * Create a new positioning force along the y-axis towards the given position y which is constant for all nodes.
+ *
+ * The y-positioning force pushes nodes towards a desired position along the given dimension with a configurable strength.
+ * The strength of the force is proportional to the one-dimensional distance between the node’s position and the target position.
+ * While this force can be used to position individual nodes, it is intended primarily for global forces that apply to all (or most) nodes.
+ *
+ * The generic refers to the type of data for a node.
+ *
+ * @param y Constant y-coordinate to be used for all nodes.
+ */
+export function forceY<NodeDatum extends SimulationNodeDatum>(y: number): ForceY<NodeDatum>;
+/**
+ * Create a new positioning force along the y-axis towards the position y given by evaluating the specified y-coordinate accessor
+ * for each node.
+ *
+ * The y-positioning force pushes nodes towards a desired position along the given dimension with a configurable strength.
+ * The strength of the force is proportional to the one-dimensional distance between the node’s position and the target position.
+ * While this force can be used to position individual nodes, it is intended primarily for global forces that apply to all (or most) nodes.
+ *
+ * The generic refers to the type of data for a node.
+ *
+ * @param y A y-coordinate accessor function which is invoked for each node in the simulation, being passed the node and its zero-based index.
+ * The function returns the y-coordinate.
+ */
+export function forceY<NodeDatum extends SimulationNodeDatum>(y: (d: NodeDatum, i: number, data: NodeDatum[]) => number): ForceY<NodeDatum>;
+
+/**
+ * The radial force is similar to the x- and y-positioning forces, except it pushes nodes towards the closest point on a given circle.
+ * The circle is of the specified radius centered at ⟨x,y⟩. If x and y are not specified, they default to ⟨0,0⟩.
+ * The strength of the force is proportional to the one-dimensional distance between the node’s position and the target position.
+ * While this force can be used to position individual nodes, it is intended primarily for global forces that apply to all (or most) nodes.
+ *
+ * The generic refers to the type of data for a node.
+ */
+export interface ForceRadial<NodeDatum extends SimulationNodeDatum> extends Force<NodeDatum, any> {
+    /**
+     * Assigns the array of nodes and random source to this force. This method is called when a force is bound to a simulation via simulation.force
+     * and when the simulation’s nodes change via simulation.nodes.
+     *
+     * A force may perform necessary work during initialization, such as evaluating per-node parameters, to avoid repeatedly performing work during each application of the force.
+     */
+    initialize(nodes: NodeDatum[], random: () => number): void;
+
+    /**
+     *  Returns the current strength accessor, which defaults to a constant strength for all nodes of 0.1.
+     */
+    strength(): (d: NodeDatum, i: number, data: NodeDatum[]) => number;
+    /**
+     * Set the strength accessor to the specified constant strength for all nodes, re-evaluates the strength accessor for each node, and returns this force.
+     *
+     * The strength determines how much to increment the node’s x-velocity: (x - node.x) × strength.
+     *
+     * For example, a value of 0.1 indicates that the node should move a tenth of the way from its current x-position to the target x-position with each application.
+     * Higher values moves nodes more quickly to the target position, often at the expense of other forces or constraints.
+     *
+     * A value outside the range [0,1] is not recommended.
+     *
+     * The constant is internally wrapped into a strength accessor function.
+     *
+     * The strength accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the strength of each node is only recomputed when the force is initialized or
+     * when this method is called with a new strength, and not on every application of the force.
+     *
+     * @param strength Constant value of strength to be used for all nodes.
+     */
+    strength(strength: number): this;
+    /**
+     * Set the strength accessor to the specified function, re-evaluates the strength accessor for each node, and returns this force.
+     *
+     * The strength determines how much to increment the node’s x-velocity: (x - node.x) × strength.
+     *
+     * For example, a value of 0.1 indicates that the node should move a tenth of the way from its current x-position to the target x-position with each application.
+     * Higher values moves nodes more quickly to the target position, often at the expense of other forces or constraints.
+     *
+     * A value outside the range [0,1] is not recommended.
+     *
+     * The strength accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the strength of each node is only recomputed when the force is initialized or
+     * when this method is called with a new strength, and not on every application of the force.
+     *
+     * @param strength A strength accessor function which is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The function returns the strength.
+     */
+    strength(strength: (d: NodeDatum, i: number, data: NodeDatum[]) => number): this;
+
+    /**
+     * Return the current radius accessor for the circle.
+     */
+    radius(): (d: NodeDatum, i: number, data: NodeDatum[]) => number;
+    /**
+     * Set the radius accessor for the circle to the specified number, re-evaluates the radius accessor for each node,
+     * and returns this force.
+     *
+     * The constant is internally wrapped into a radius accessor function.
+     *
+     * The radius accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that radius of the circle for each node is only recomputed when the force is initialized or
+     * when this method is called with a new radius, and not on every application of the force.
+     *
+     * @param radius Constant radius of the circle to be used for all nodes.
+     */
+    radius(radius: number): this;
+    /**
+     * Set the radius accessor for the circle to the specified function, re-evaluates the radius accessor for each node,
+     * and returns this force.
+     *
+     * The radius accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that radius of the circle for each node is only recomputed when the force is initialized or
+     * when this method is called with a new radius, and not on every application of the force.
+     *
+     * @param radius A radius accessor function for the circle which is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The function returns the radius of the circle.
+     */
+    radius(radius: (d: NodeDatum, i: number, data: NodeDatum[]) => number): this;
+
+    /**
+     * Return the current x-accessor for the circle center, which defaults to a function returning 0 for all nodes.
+     */
+    x(): (d: NodeDatum, i: number, data: NodeDatum[]) => number;
+    /**
+     * Set the x-coordinate accessor for the circle center to the specified number, re-evaluates the x-accessor for each node,
+     * and returns this force.
+     *
+     * The constant is internally wrapped into an x-coordinate accessor function.
+     *
+     * The x-accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the x-coordinate of the circle center for each node is only recomputed when the force is initialized or
+     * when this method is called with a new x, and not on every application of the force.
+     *
+     * @param x Constant x-coordinate of the circle center to be used for all nodes.
+     */
+    x(x: number): this;
+    /**
+     * Set the x-coordinate accessor to the specified function, re-evaluates the x-accessor for each node,
+     * and returns this force.
+     *
+     * The x-accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the x-coordinate of the circle center for each node is only recomputed when the force is initialized or
+     * when this method is called with a new x, and not on every application of the force.
+     *
+     * @param x A x-coordinate accessor function for the circle center which is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The function returns the x-coordinate of the circle center.
+     */
+    x(x: (d: NodeDatum, i: number, data: NodeDatum[]) => number): this;
+
+    /**
+     * Return the current y-accessor for the circle center, which defaults to a function returning 0 for all nodes.
+     */
+    y(): (d: NodeDatum, i: number, data: NodeDatum[]) => number;
+    /**
+     * Set the y-coordinate accessor for the circle center to the specified number, re-evaluates the y-accessor for each node,
+     * and returns this force.
+     *
+     * The constant is internally wrapped into an y-coordinate accessor function.
+     *
+     * The y-accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the y-coordinate of the circle center for each node is only recomputed when the force is initialized or
+     * when this method is called with a new y, and not on every application of the force.
+     *
+     * @param y Constant y-coordinate of the circle center to be used for all nodes.
+     */
+    y(y: number): this;
+    /**
+     * Set the y-coordinate accessor to the specified function, re-evaluates the y-accessor for each node,
+     * and returns this force.
+     *
+     * The y-accessor is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The resulting number is then stored internally, such that the y-coordinate of the circle center for each node is only recomputed when the force is initialized or
+     * when this method is called with a new y, and not on every application of the force.
+     *
+     * @param y A y-coordinate accessor function for the circle center which is invoked for each node in the simulation, being passed the node, its zero-based index and the complete array of nodes.
+     * The function returns the y-coordinate of the circle center.
+     */
+    y(y: (d: NodeDatum, i: number, data: NodeDatum[]) => number): this;
+}
+
+/**
+ * Create a new radial positioning force towards a circle of the specified radius centered at ⟨x,y⟩.
+ * If x and y are not specified, they default to ⟨0,0⟩.
+ *
+ * The strength of the force is proportional to the one-dimensional distance between the node’s position and the target position.
+ * While this force can be used to position individual nodes, it is intended primarily for global forces that apply to all (or most) nodes.
+ *
+ * The generic refers to the type of data for a node.
+ */
+export function forceRadial<NodeDatum extends SimulationNodeDatum>(radius: number | ((d: NodeDatum, i: number, data: NodeDatum[]) => number),
+    x?: number | ((d: NodeDatum, i: number, data: NodeDatum[]) => number), y?: number | ((d: NodeDatum, i: number, data: NodeDatum[]) => number)): ForceRadial<NodeDatum>;

node_modules/@types/d3-force/package.json

@@ -0,0 +1,69 @@
+{
+  "_from": "@types/d3-force@*",
+  "_id": "@types/d3-force@2.1.0",
+  "_inBundle": false,
+  "_integrity": "sha512-LGDtC2YADu8OBniq9EBx/MOsXsMcJbEkmfSpXuz6oVdRamB+3CLCiq5EKFPEILGZQckkilGFq1ZTJ7kc289k+Q==",
+  "_location": "/@types/d3-force",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-force@*",
+    "name": "@types/d3-force",
+    "escapedName": "@types%2fd3-force",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-force/-/d3-force-2.1.0.tgz",
+  "_shasum": "6a2210f04d02a0862c6b069de91bad904143e7b5",
+  "_spec": "@types/d3-force@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "denisname",
+      "url": "https://github.com/denisname"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-force module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-force",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-force"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "7354a8e672ae9b7a9148fd4f20439bd13a5b8ac1b5b5fe1af0de47774f73edaa",
+  "version": "2.1.0"
+}

node_modules/@types/d3-format/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-format/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-format`
+
+# Summary
+This package contains type definitions for D3JS d3-format module (https://github.com/d3/d3-format/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-format.
+
+### Additional Details
+ * Last updated: Wed, 30 Sep 2020 20:01:29 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-format/index.d.ts

@@ -0,0 +1,348 @@
+// Type definitions for D3JS d3-format module 2.0
+// Project: https://github.com/d3/d3-format/, https://d3js.org/d3-format
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Last module patch version validated against: 2.0.0
+
+/**
+ * Specification of locale to use when creating a new FormatLocaleObject
+ */
+export interface FormatLocaleDefinition {
+    /**
+     * The decimal point (e.g., ".")
+     */
+    decimal: string;
+    /**
+     * The group separator (e.g., ","). Note that the thousands property is a misnomer, as
+     * the grouping definition allows groups other than thousands.
+     */
+    thousands: string;
+    /**
+     * The array of group sizes (e.g., [3]), cycled as needed.
+     */
+    grouping: number[];
+    /**
+     * The currency prefix and suffix (e.g., ["$", ""]).
+     */
+    currency: [string, string];
+    /**
+     * An optional array of ten strings to replace the numerals 0-9.
+     */
+    numerals?: string[];
+    /**
+     * An optional symbol to replace the `percent` suffix; the percent suffix (defaults to "%").
+     */
+    percent?: string;
+    /**
+     * Optional; the minus sign (defaults to "−").
+     */
+    minus?: string;
+    /**
+     * Optional; the not-a-number value (defaults "NaN").
+     */
+    nan?: string;
+}
+
+/**
+ * A Format Locale Object
+ */
+export interface FormatLocaleObject {
+    /**
+     * Returns a new format function for the given string specifier. The returned function
+     * takes a number as the only argument, and returns a string representing the formatted number.
+     *
+     * @param specifier A Specifier string.
+     * @throws Error on invalid format specifier.
+     */
+    format(specifier: string): (n: number | { valueOf(): number }) => string;
+
+    /**
+     * Returns a new format function for the given string specifier. The returned function
+     * takes a number as the only argument, and returns a string representing the formatted number.
+     * The returned function will convert values to the units of the appropriate SI prefix for the
+     * specified numeric reference value before formatting in fixed point notation.
+     *
+     * @param specifier A Specifier string.
+     * @param value The reference value to determine the appropriate SI prefix.
+     * @throws Error on invalid format specifier.
+     */
+    formatPrefix(specifier: string, value: number): (n: number | { valueOf(): number }) => string;
+}
+
+/**
+ * A Format Specifier
+ *
+ * For details see: {@link https://github.com/d3/d3-format#locale_format}
+ */
+export interface FormatSpecifierObject {
+    /**
+     * fill can be any character. The presence of a fill character is signaled by the align character following it.
+     */
+    fill?: string;
+    /**
+     * Alignment used for format, as set by choosing one of the following:
+     *
+     * '>' - Forces the field to be right-aligned within the available space. (Default behavior).
+     * '<' - Forces the field to be left-aligned within the available space.
+     * '^' - Forces the field to be centered within the available space.
+     * '=' - Like '>', but with any sign and symbol to the left of any padding.
+     */
+    align?: string;
+    /**
+     * The sign can be:
+     *
+     * '-' - nothing for positive and a minus sign for negative. (Default behavior.)
+     * '+' - a plus sign for positive and a minus sign for negative.
+     * '(' - nothing for positive and parentheses for negative.
+     * ' ' (space) - a space for positive and a minus sign for negative.
+     *
+     */
+    sign?: string;
+    /**
+     * The symbol can be:
+     *
+     * '$' - apply currency symbols per the locale definition.
+     * '#' - for binary, octal, or hexadecimal notation, prefix by 0b, 0o, or 0x, respectively.
+     * '' (none) - no symbol. (Default behavior.)
+     */
+    symbol?: string;
+    /**
+     * The zero (0) option enables zero-padding; this implicitly sets fill to 0 and align to =.
+     */
+    zero?: string;
+    /**
+     * The width defines the minimum field width;
+     * if not specified, then the width will be determined by the content.
+     */
+    width?: string;
+    /**
+     * The comma (,) option enables the use of a group separator, such as a comma for thousands.
+     */
+    comma?: string;
+    /**
+     * Depending on the type, the precision either indicates the number of digits that follow the decimal point (types 'f' and '%'),
+     * or the number of significant digits (types '' (none), 'e', 'g', 'r', 's' and 'p'). If the precision is not specified,
+     * it defaults to 6 for all types except '' (none), which defaults to 12.
+     * Precision is ignored for integer formats (types 'b', 'o', 'd', 'x', 'X' and 'c').
+     *
+     * See precisionFixed and precisionRound for help picking an appropriate precision.
+     */
+    precision?: string;
+    /**
+     * The '~' option trims insignificant trailing zeros across all format types.
+     * This is most commonly used in conjunction with types 'r', 'e', 's' and '%'.
+     */
+    trim?: string;
+    /**
+     * The available type values are:
+     *
+     * 'e' - exponent notation.
+     * 'f' - fixed point notation.
+     * 'g' - either decimal or exponent notation, rounded to significant digits.
+     * 'r' - decimal notation, rounded to significant digits.
+     * 's' - decimal notation with an SI prefix, rounded to significant digits.
+     * '%' - multiply by 100, and then decimal notation with a percent sign.
+     * 'p' - multiply by 100, round to significant digits, and then decimal notation with a percent sign.
+     * 'b' - binary notation, rounded to integer.
+     * 'o' - octal notation, rounded to integer.
+     * 'd' - decimal notation, rounded to integer.
+     * 'x' - hexadecimal notation, using lower-case letters, rounded to integer.
+     * 'X' - hexadecimal notation, using upper-case letters, rounded to integer.
+     * 'c' - converts the integer to the corresponding unicode character before printing.
+     *
+     * The type '' (none) is also supported as shorthand for '~g' (with a default precision of 12 instead of 6), and
+     * the type 'n' is shorthand for ',g'. For the 'g', 'n' and '' (none) types,
+     * decimal notation is used if the resulting string would have precision or fewer digits; otherwise, exponent notation is used.
+     */
+    type?: string;
+}
+
+/**
+ * Create a new locale-based object which exposes format(...) and formatPrefix(...)
+ * methods for the specified locale.
+ *
+ * @param locale A Format locale definition.
+ */
+export function formatLocale(locale: FormatLocaleDefinition): FormatLocaleObject;
+
+/**
+ * Create a new locale-based object which exposes format(...) and formatPrefix(...)
+ * methods for the specified locale definition. The specified locale definition will be
+ * set as the new default locale definition.
+ *
+ * @param defaultLocale A Format locale definition to be used as default.
+ */
+export function formatDefaultLocale(defaultLocale: FormatLocaleDefinition): FormatLocaleObject;
+
+/**
+ * Returns a new format function for the given string specifier. The returned function
+ * takes a number as the only argument, and returns a string representing the formatted number.
+ *
+ * Uses the current default locale.
+ *
+ * The general form of a specifier is [[fill]align][sign][symbol][0][width][,][.precision][~][type].
+ * For reference, an explanation of the segments of the specifier string, refer to the FormatSpecifier interface properties.
+ *
+ * @param specifier A Specifier string.
+ * @throws Error on invalid format specifier.
+ */
+export function format(specifier: string): (n: number | { valueOf(): number }) => string;
+
+/**
+ * Returns a new format function for the given string specifier. The returned function
+ * takes a number as the only argument, and returns a string representing the formatted number.
+ * The returned function will convert values to the units of the appropriate SI prefix for the
+ * specified numeric reference value before formatting in fixed point notation.
+ *
+ * Uses the current default locale.
+ *
+ * The general form of a specifier is [[fill]align][sign][symbol][0][width][,][.precision][~][type].
+ * For reference, an explanation of the segments of the specifier string, refer to the FormatSpecifier interface properties.
+ *
+ * @param specifier A Specifier string.
+ * @param value The reference value to determine the appropriate SI prefix.
+ * @throws Error on invalid format specifier.
+ */
+export function formatPrefix(specifier: string, value: number): (n: number | { valueOf(): number }) => string;
+
+/**
+ * A Format Specifier
+ *
+ * For details see: {@link https://github.com/d3/d3-format#locale_format}
+ */
+export class FormatSpecifier {
+    /**
+     * Given the specified specifier object, returning an object with exposed fields that correspond to the format specification mini-language and a toString method that reconstructs the specifier.
+     * @param specifier A specifier object.
+     */
+    constructor(specifier: FormatSpecifierObject);
+    /**
+     * fill can be any character. The presence of a fill character is signaled by the align character following it.
+     */
+    fill: string;
+    /**
+     * Alignment used for format, as set by choosing one of the following:
+     *
+     * '>' - Forces the field to be right-aligned within the available space. (Default behavior).
+     * '<' - Forces the field to be left-aligned within the available space.
+     * '^' - Forces the field to be centered within the available space.
+     * '=' - Like '>', but with any sign and symbol to the left of any padding.
+     */
+    align: '>' | '<' | '^' | '=';
+    /**
+     * The sign can be:
+     *
+     * '-' - nothing for positive and a minus sign for negative. (Default behavior.)
+     * '+' - a plus sign for positive and a minus sign for negative.
+     * '(' - nothing for positive and parentheses for negative.
+     * ' ' (space) - a space for positive and a minus sign for negative.
+     *
+     */
+    sign: '-' | '+' | '(' | ' ';
+    /**
+     * The symbol can be:
+     *
+     * '$' - apply currency symbols per the locale definition.
+     * '#' - for binary, octal, or hexadecimal notation, prefix by 0b, 0o, or 0x, respectively.
+     * '' (none) - no symbol. (Default behavior.)
+     */
+    symbol: '$' | '#' | '';
+    /**
+     * The zero (0) option enables zero-padding; this implicitly sets fill to 0 and align to =.
+     */
+    zero: boolean;
+    /**
+     * The width defines the minimum field width;
+     * if not specified, then the width will be determined by the content.
+     */
+    width: number | undefined;
+    /**
+     * The comma (,) option enables the use of a group separator, such as a comma for thousands.
+     */
+    comma: boolean;
+    /**
+     * Depending on the type, the precision either indicates the number of digits that follow the decimal point (types 'f' and '%'),
+     * or the number of significant digits (types '' (none), 'e', 'g', 'r', 's' and 'p'). If the precision is not specified,
+     * it defaults to 6 for all types except '' (none), which defaults to 12.
+     * Precision is ignored for integer formats (types 'b', 'o', 'd', 'x', 'X' and 'c').
+     *
+     * See precisionFixed and precisionRound for help picking an appropriate precision.
+     */
+    precision: number | undefined;
+    /**
+     * The '~' option trims insignificant trailing zeros across all format types.
+     * This is most commonly used in conjunction with types 'r', 'e', 's' and '%'.
+     */
+    trim: boolean;
+    /**
+     * The available type values are:
+     *
+     * 'e' - exponent notation.
+     * 'f' - fixed point notation.
+     * 'g' - either decimal or exponent notation, rounded to significant digits.
+     * 'r' - decimal notation, rounded to significant digits.
+     * 's' - decimal notation with an SI prefix, rounded to significant digits.
+     * '%' - multiply by 100, and then decimal notation with a percent sign.
+     * 'p' - multiply by 100, round to significant digits, and then decimal notation with a percent sign.
+     * 'b' - binary notation, rounded to integer.
+     * 'o' - octal notation, rounded to integer.
+     * 'd' - decimal notation, rounded to integer.
+     * 'x' - hexadecimal notation, using lower-case letters, rounded to integer.
+     * 'X' - hexadecimal notation, using upper-case letters, rounded to integer.
+     * 'c' - converts the integer to the corresponding unicode character before printing.
+     *
+     * The type '' (none) is also supported as shorthand for '~g' (with a default precision of 12 instead of 6), and
+     * the type 'n' is shorthand for ',g'. For the 'g', 'n' and '' (none) types,
+     * decimal notation is used if the resulting string would have precision or fewer digits; otherwise, exponent notation is used.
+     */
+    type: 'e' | 'f' | 'g' | 'r' | 's' | '%' | 'p' | 'b' | 'o' | 'd' | 'x' | 'X' | 'c' | '' | 'n';
+    /**
+     * Return the object as a specifier string.
+     */
+    toString(): string;
+}
+
+/**
+ * Parses the specified specifier, returning an object with exposed fields that correspond to the
+ * format specification mini-language and a toString method that reconstructs the specifier.
+ *
+ * The general form of a specifier is [[fill]align][sign][symbol][0][width][,][.precision][~][type].
+ * For reference, an explanation of the segments of the specifier string, refer to the FormatSpecifier interface properties.
+ *
+ * @param specifier A specifier string.
+ * @throws Error on invalid format specifier.
+ */
+export function formatSpecifier(specifier: string): FormatSpecifier;
+
+/**
+ * Returns a suggested decimal precision for fixed point notation given the specified numeric step value.
+ *
+ * @param step The step represents the minimum absolute difference between values that will be formatted.
+ * (This assumes that the values to be formatted are also multiples of step.)
+ */
+export function precisionFixed(step: number): number;
+
+/**
+ * Returns a suggested decimal precision for use with locale.formatPrefix given the specified
+ * numeric step and reference value.
+ *
+ * @param step The step represents the minimum absolute difference between values that will be formatted.
+ * (This assumes that the values to be formatted are also multiples of step.)
+ * @param value Reference value determines which SI prefix will be used.
+ */
+export function precisionPrefix(step: number, value: number): number;
+
+/**
+ * Returns a suggested decimal precision for format types that round to significant digits
+ * given the specified numeric step and max values.
+ *
+ * @param step The step represents the minimum absolute difference between values that will be formatted.
+ * (This assumes that the values to be formatted are also multiples of step.)
+ * @param max max represents the largest absolute value that will be formatted.
+ */
+export function precisionRound(step: number, max: number): number;

node_modules/@types/d3-format/package.json

@@ -0,0 +1,69 @@
+{
+  "_from": "@types/d3-format@*",
+  "_id": "@types/d3-format@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-uagdkftxnGkO4pZw5jEYOM5ZnZOEsh7z8j11Qxk85UkB2RzfUUxRl7R9VvvJZHwKn8l+x+rpS77Nusq7FkFmIg==",
+  "_location": "/@types/d3-format",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-format@*",
+    "name": "@types/d3-format",
+    "escapedName": "@types%2fd3-format",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-format/-/d3-format-2.0.0.tgz",
+  "_shasum": "607d261cb268f0a027f100575491031539a40ee6",
+  "_spec": "@types/d3-format@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "denisname",
+      "url": "https://github.com/denisname"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-format module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-format",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-format"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "9a1967d3d986da14ecf3b4e54f54098011c0b1ee8ac0be5ca6272a716aee8e3e",
+  "version": "2.0.0"
+}

node_modules/@types/d3-geo/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-geo/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-geo`
+
+# Summary
+This package contains type definitions for D3JS d3-geo module (https://github.com/d3/d3-geo/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-geo.
+
+### Additional Details
+ * Last updated: Wed, 30 Sep 2020 21:08:22 GMT
+ * Dependencies: [@types/geojson](https://npmjs.com/package/@types/geojson)
+ * Global values: none
+
+# Credits
+These definitions were written by [Hugues Stefanski](https://github.com/ledragon), [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-geo/index.d.ts

@@ -0,0 +1,1782 @@
+// Type definitions for D3JS d3-geo module 2.0
+// Project: https://github.com/d3/d3-geo/, https://d3js.org/d3-geo
+// Definitions by: Hugues Stefanski <https://github.com/ledragon>
+//                 Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+// Last module patch version validated against: 2.0.1
+
+import * as GeoJSON from 'geojson';
+
+// ----------------------------------------------------------------------
+// Shared Interfaces and Types
+// ----------------------------------------------------------------------
+
+/**
+ * A basic geometry for a sphere, which is supported by d3-geo
+ * beyond the GeoJSON geometries.
+ */
+export interface GeoSphere {
+    /**
+     * Sphere geometry type
+     */
+    type: 'Sphere';
+}
+
+/**
+ * Type Alias for GeoJSON Geometry Object and GeoSphere additional
+ * geometry supported by d3-geo
+ */
+export type GeoGeometryObjects = GeoJSON.GeometryObject | GeoSphere;
+
+/**
+ * A GeoJSON-style GeometryCollection which supports GeoJSON geometry objects
+ * and additionally GeoSphere.
+ *
+ * The generic refers to the type(s) of d3-geo geometry objects contained in the collection.
+ */
+export interface ExtendedGeometryCollection<GeometryType extends GeoGeometryObjects = GeoGeometryObjects> {
+    type: string;
+    bbox?: number[];
+    crs?: {
+        type: string;
+        properties: any;
+    };
+    geometries: GeometryType[];
+}
+
+/**
+ * A GeoJSON-style Feature which support features built on GeoJSON GeometryObjects
+ * or GeoSphere.
+ *
+ * The first generic refers to the type(s) of d3-geo geometry objects underlying the ExtendedFeature.
+ * Unless explicitly ruled out, the geometry value is nullable.
+ *
+ * The second generic refers to the data type of the properties of the ExtendedFeature. Unless explicitly ruled out,
+ * the properties value is nullable.
+ */
+export interface ExtendedFeature<
+    GeometryType extends GeoGeometryObjects | null = GeoGeometryObjects | null,
+    Properties extends GeoJSON.GeoJsonProperties = GeoJSON.GeoJsonProperties
+    > extends GeoJSON.GeoJsonObject {
+    geometry: GeometryType;
+    properties: Properties;
+    id?: string | number;
+}
+
+/**
+ * A GeoJSON-style FeatureCollection which supports GeoJSON features
+ * and features built on GeoSphere
+ *
+ * The generic refers to the type of ExtendedFeature contained in the ExtendedFeatureCollection.
+ */
+export interface ExtendedFeatureCollection<FeatureType extends ExtendedFeature = ExtendedFeature> extends GeoJSON.GeoJsonObject {
+    features: FeatureType[];
+}
+
+/**
+ * Type Alias for permissible objects which can be used with d3-geo
+ * methods
+ */
+export type GeoPermissibleObjects = GeoGeometryObjects | ExtendedGeometryCollection | ExtendedFeature | ExtendedFeatureCollection;
+
+// ----------------------------------------------------------------------
+// Spherical Math
+// ----------------------------------------------------------------------
+
+/**
+ * Returns the spherical area of the specified feature in steradians.
+ * This is the spherical equivalent of path.area.
+ *
+ * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+ */
+export function geoArea(object: ExtendedFeature): number;
+/**
+ * Returns the spherical area of the specified feature collection in steradians.
+ * This is the spherical equivalent of path.area.
+ *
+ * @param object A geographic feature collection supported by d3-geo (An extension of GeoJSON feature).
+ */
+export function geoArea(object: ExtendedFeatureCollection): number;
+/**
+ * Returns the spherical area of the specified GeoJson Geometry Object or GeoSphere object in steradians.
+ * This is the spherical equivalent of path.area.
+ *
+ * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+ */
+export function geoArea(object: GeoGeometryObjects): number;
+/**
+ * Returns the spherical area of the specified geographic geometry collection in steradians.
+ * This is the spherical equivalent of path.area.
+ *
+ * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+ */
+export function geoArea(object: ExtendedGeometryCollection): number;
+
+/**
+ * Returns the spherical bounding box for the specified feature. The bounding box is represented by a two-dimensional array: [[left, bottom], [right, top]],
+ * where left is the minimum longitude, bottom is the minimum latitude, right is maximum longitude, and top is the maximum latitude. All coordinates are given in degrees.
+ * (Note that in projected planar coordinates, the minimum latitude is typically the maximum y-value, and the maximum latitude is typically the minimum y-value.)
+ * This is the spherical equivalent of path.bounds.
+ *
+ * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+ */
+export function geoBounds(object: ExtendedFeature): [[number, number], [number, number]];
+/**
+ * Returns the spherical bounding box for the specified feature collection. The bounding box is represented by a two-dimensional array: [[left, bottom], [right, top]],
+ * where left is the minimum longitude, bottom is the minimum latitude, right is maximum longitude, and top is the maximum latitude. All coordinates are given in degrees.
+ * (Note that in projected planar coordinates, the minimum latitude is typically the maximum y-value, and the maximum latitude is typically the minimum y-value.)
+ * This is the spherical equivalent of path.bounds.
+ *
+ * @param object A geographic feature collection supported by d3-geo (An extension of GeoJSON feature).
+ */
+export function geoBounds(object: ExtendedFeatureCollection): [[number, number], [number, number]];
+/**
+ * Returns the spherical bounding box for the specified GeoJson Geometry Object or GeoSphere object. The bounding box is represented by a two-dimensional array: [[left, bottom], [right, top]],
+ * where left is the minimum longitude, bottom is the minimum latitude, right is maximum longitude, and top is the maximum latitude. All coordinates are given in degrees.
+ * (Note that in projected planar coordinates, the minimum latitude is typically the maximum y-value, and the maximum latitude is typically the minimum y-value.)
+ * This is the spherical equivalent of path.bounds.
+ *
+ * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+ */
+export function geoBounds(object: GeoGeometryObjects): [[number, number], [number, number]];
+/**
+ * Returns the spherical bounding box for the specified geometry collection. The bounding box is represented by a two-dimensional array: [[left, bottom], [right, top]],
+ * where left is the minimum longitude, bottom is the minimum latitude, right is maximum longitude, and top is the maximum latitude. All coordinates are given in degrees.
+ * (Note that in projected planar coordinates, the minimum latitude is typically the maximum y-value, and the maximum latitude is typically the minimum y-value.)
+ * This is the spherical equivalent of path.bounds.
+ *
+ * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+ */
+export function geoBounds(object: ExtendedGeometryCollection): [[number, number], [number, number]];
+
+/**
+ * Returns the spherical centroid of the specified feature in steradians.
+ * This is the spherical equivalent of path.centroid.
+ *
+ * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+ */
+export function geoCentroid(object: ExtendedFeature): [number, number];
+/**
+ * Returns the spherical centroid of the specified feature collection in steradians.
+ * This is the spherical equivalent of path.centroid.
+ *
+ * @param object A geographic feature collection supported by d3-geo (An extension of GeoJSON feature).
+ */
+export function geoCentroid(object: ExtendedFeatureCollection): [number, number];
+/**
+ * Returns the spherical centroid of the specified GeoJson Geometry Object or GeoSphere object in steradians.
+ * This is the spherical equivalent of path.centroid.
+ *
+ * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+ */
+export function geoCentroid(object: GeoGeometryObjects): [number, number];
+/**
+ * Returns the spherical centroid of the specified geographic geometry collection in steradians.
+ * This is the spherical equivalent of path.centroid.
+ *
+ * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+ */
+export function geoCentroid(object: ExtendedGeometryCollection): [number, number];
+
+/**
+ * Returns true if and only if the specified GeoJSON object contains the specified point, or false if the object does not contain the point.
+ * The point must be specified as a two-element array [longitude, latitude] in degrees. For Point and MultiPoint geometries, an exact test is used;
+ * for a Sphere, true is always returned; for other geometries, an epsilon threshold is applied.
+ *
+ * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+ * @param point Point specified as a two-element array [longitude, latitude] in degrees.
+ */
+export function geoContains(object: ExtendedFeature, point: [number, number]): boolean;
+/**
+ * Returns true if and only if the specified GeoJSON object contains the specified point, or false if the object does not contain the point.
+ * The point must be specified as a two-element array [longitude, latitude] in degrees. For Point and MultiPoint geometries, an exact test is used;
+ * for a Sphere, true is always returned; for other geometries, an epsilon threshold is applied.
+ *
+ * @param object A geographic feature collection supported by d3-geo (An extension of GeoJSON feature).
+ * @param point Point specified as a two-element array [longitude, latitude] in degrees.
+ */
+export function geoContains(object: ExtendedFeatureCollection, point: [number, number]): boolean;
+/**
+ * Returns true if and only if the specified GeoJSON object contains the specified point, or false if the object does not contain the point.
+ * The point must be specified as a two-element array [longitude, latitude] in degrees. For Point and MultiPoint geometries, an exact test is used;
+ * for a Sphere, true is always returned; for other geometries, an epsilon threshold is applied.
+ *
+ * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+ * @param point Point specified as a two-element array [longitude, latitude] in degrees.
+ */
+export function geoContains(object: GeoGeometryObjects, point: [number, number]): boolean;
+/**
+ * Returns true if and only if the specified GeoJSON object contains the specified point, or false if the object does not contain the point.
+ * The point must be specified as a two-element array [longitude, latitude] in degrees. For Point and MultiPoint geometries, an exact test is used;
+ * for a Sphere, true is always returned; for other geometries, an epsilon threshold is applied.
+ *
+ * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+ * @param point Point specified as a two-element array [longitude, latitude] in degrees.
+ */
+export function geoContains(object: ExtendedGeometryCollection, point: [number, number]): boolean;
+
+/**
+ * Returns the great-arc distance in radians between the two points a and b.
+ * Each point must be specified as a two-element array [longitude, latitude] in degrees.
+ *
+ * @param a Point specified as a two-element array [longitude, latitude] in degrees.
+ * @param b Point specified as a two-element array [longitude, latitude] in degrees.
+ */
+export function geoDistance(a: [number, number], b: [number, number]): number;
+
+/**
+ * Returns the great-arc length of the specified feature in radians. For polygons, returns the perimeter of the exterior ring plus that of any interior rings.
+ * This is the spherical equivalent of path.measure.
+ *
+ * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+ */
+export function geoLength(object: ExtendedFeature): number;
+/**
+ * Returns the great-arc length of the specified feature collection in radians. For polygons, returns the perimeter of the exterior ring plus that of any interior rings.
+ * This is the spherical equivalent of path.measure.
+ *
+ * @param object A geographic feature collection supported by d3-geo (An extension of GeoJSON feature).
+ */
+export function geoLength(object: ExtendedFeatureCollection): number;
+/**
+ * Returns the great-arc length of the specified GeoJson Geometry Object or GeoSphere object in radians. For polygons, returns the perimeter of the exterior ring plus that of any interior rings.
+ * This is the spherical equivalent of path.measure.
+ *
+ * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+ */
+export function geoLength(object: GeoGeometryObjects): number;
+/**
+ * Returns the great-arc length of the specified geographic geometry collection in radians For polygons, returns the perimeter of the exterior ring plus that of any interior rings.
+ * This is the spherical equivalent of path.measure..
+ *
+ * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+ */
+export function geoLength(object: ExtendedGeometryCollection): number;
+
+/**
+ * Returns an interpolator function given two points a and b.
+ * Each point must be specified as a two-element array [longitude, latitude] in degrees.
+ *
+ * @param a Point specified as a two-element array [longitude, latitude] in degrees.
+ * @param b Point specified as a two-element array [longitude, latitude] in degrees.
+ */
+export function geoInterpolate(a: [number, number], b: [number, number]): (t: number) => [number, number];
+
+/**
+ * A Geo Rotation
+ */
+export interface GeoRotation {
+    /**
+     * Returns a new array [longitude, latitude] in degrees representing the rotated point of the given point.
+     *
+     * @param point The point must be specified as a two-element array [longitude, latitude] in degrees.
+     */
+    (point: [number, number]): [number, number];
+
+    /**
+     * Returns a new array [longitude, latitude] in degrees representing the point of the given rotated point; the inverse of rotation.
+     *
+     * @param point The rotated point must be specified as a two-element array [longitude, latitude] in degrees.
+     */
+    invert(point: [number, number]): [number, number];
+}
+
+/**
+ * Returns a rotation function for the given angles.
+ *
+ * @param angles  A two- or three-element array of numbers [lambda, phi, gamma] specifying the rotation angles in degrees about each spherical axis.
+ * (These correspond to yaw, pitch and roll.) If the rotation angle gamma is omitted, it defaults to 0.
+ */
+export function geoRotation(angles: [number, number] | [number, number, number]): GeoRotation;
+
+// ----------------------------------------------------------------------
+// Spherical Shapes
+// ----------------------------------------------------------------------
+
+// geoCircle ============================================================
+
+/**
+ * A new circle generator
+ *
+ * The first generic corresponds to the "this"-context within which the geo circle generator will be invoked.
+ *
+ * The second generic corresponds to the type of the Datum which will be passed into the geo circle generator.
+ */
+export interface GeoCircleGenerator<This = any, Datum = any> {
+    /**
+     * Returns a new GeoJSON geometry object of type “Polygon” approximating a circle on the surface of a sphere,
+     * with the current center, radius and precision. Any arguments are passed to the accessors.
+     */
+    (this: This, d?: Datum, ...args: any[]): GeoJSON.Polygon;
+
+    /**
+     * Returns the current center accessor, which defaults to a function returning [0, 0].
+     */
+    center(): ((this: This, d: Datum, ...args: any[]) => [number, number]);
+    /**
+     * Sets the circle center to the specified point [longitude, latitude] in degrees, and returns this circle generator.
+     *
+     * @param center Center point specified as [longitude, latitude] in degrees.
+     */
+    center(center: [number, number]): this;
+    /**
+     * Sets the circle center to the specified center point accessor function, and returns this circle generator.
+     *
+     * @param center An accessor function which will be invoked whenever a circle is generated, being passed any arguments passed to the circle generator.
+     * It returns the center point specified as [longitude, latitude] in degrees.
+     */
+    center(center: ((this: This, d: Datum, ...args: any[]) => [number, number])): this;
+
+    /**
+     * Returns the current radius accessor, which defaults to a function returning 90.
+     */
+    radius(): ((this: This, d: Datum, ...args: any[]) => number);
+    /**
+     * Sets the circle radius to the specified angle in degrees, and returns this circle generator.
+     *
+     * @param radius Circle radius as the specified angle in degrees.
+     */
+    radius(radius: number): this;
+    /**
+     * Sets the circle radius to the specified radius accessor function, and returns this circle generator.
+     *
+     * @param radius An accessor function which will be invoked whenever a circle is generated, being passed any arguments passed to the circle generator.
+     * It returns the radius as the specified angle in degrees.
+     */
+    radius(radius: ((this: This, d: Datum, ...args: any[]) => number)): this;
+
+    /**
+     * Returns the current precision accessor, which defaults to a function returning 6.
+     */
+    precision(): ((this: This, d: Datum, ...args: any[]) => number);
+    /**
+     * Sets the circle precision to the specified angle in degrees, and returns this circle generator.
+     *
+     * Small circles do not follow great arcs and thus the generated polygon is only an approximation.
+     * Specifying a smaller precision angle improves the accuracy of the approximate polygon, but also increase the cost to generate and render it.
+     *
+     * @param precision Precision as specified angle in degrees.
+     */
+    precision(precision: number): this;
+    /**
+     * Sets the circle precision to the precision accessor function, and returns this circle generator.
+     *
+     * Small circles do not follow great arcs and thus the generated polygon is only an approximation.
+     * Specifying a smaller precision angle improves the accuracy of the approximate polygon, but also increase the cost to generate and render it.
+     *
+     * @param precision An accessor function which will be invoked whenever a circle is generated, being passed any arguments passed to the circle generator.
+     * It returns the precision as the specified angle in degrees.
+     */
+    precision(precision: (this: This, d: Datum, ...args: any[]) => number): this;
+}
+
+/**
+ * Returns a new geo circle generator
+ */
+export function geoCircle(): GeoCircleGenerator;
+/**
+ * Returns a new geo circle generator
+ *
+ * The generic corresponds to the data type of the first argument passed into the geo circle generator and its accessor functions.
+ */
+export function geoCircle<Datum>(): GeoCircleGenerator<any, Datum>;
+/**
+ * Returns a new geo circle generator
+ *
+ * The first generic corresponds to the "this" context within which the geo circle generator and its accessors will be invoked.
+ *
+ * The second generic corresponds to the data type of the first argument passed into the geo circle generator and its accessor functions.
+ */
+export function geoCircle<This, Datum>(): GeoCircleGenerator<This, Datum>;
+
+// geoGraticule ============================================================
+
+/**
+ * A Feature generator for graticules: a uniform grid of meridians and parallels for showing projection distortion.
+ * The default graticule has meridians and parallels every 10° between ±80° latitude; for the polar regions, there are meridians every 90°.
+ */
+export interface GeoGraticuleGenerator {
+    /**
+     * Returns a GeoJSON MultiLineString geometry object representing all meridians and parallels for this graticule.
+     */
+    (): GeoJSON.MultiLineString;
+
+    /**
+     * Returns an array of GeoJSON LineString geometry objects, one for each meridian or parallel for this graticule.
+     */
+    lines(): GeoJSON.LineString[];
+
+    /**
+     * Returns a GeoJSON Polygon geometry object representing the outline of this graticule, i.e. along the meridians and parallels defining its extent.
+     */
+    outline(): GeoJSON.Polygon;
+
+    /**
+     * Returns the current minor extent, which defaults to ⟨⟨-180°, -80° - ε⟩, ⟨180°, 80° + ε⟩⟩.
+     */
+    extent(): [[number, number], [number, number]];
+    /**
+     * Sets the major and minor extents of this graticule.
+     *
+     * @param extent Extent to use for major and minor extent of graticule.
+     */
+    extent(extent: [[number, number], [number, number]]): this;
+
+    /**
+     * Returns the current major extent, which defaults to ⟨⟨-180°, -90° + ε⟩, ⟨180°, 90° - ε⟩⟩.
+     */
+    extentMajor(): [[number, number], [number, number]];
+    /**
+     * Sets the major extent of this graticule.
+     *
+     * @param extent Major extent of graticule.
+     */
+    extentMajor(extent: [[number, number], [number, number]]): this;
+
+    /**
+     * Returns the current minor extent, which defaults to  ⟨⟨-180°, -80° - ε⟩, ⟨180°, 80° + ε⟩⟩.
+     */
+    extentMinor(): [[number, number], [number, number]];
+    /**
+     * Sets the minor extent of this graticule.
+     *
+     * @param extent Minor extent of graticule.
+     */
+    extentMinor(extent: [[number, number], [number, number]]): this;
+
+    /**
+     * Returns the current minor step, which defaults to ⟨10°, 10°⟩.
+     */
+    step(): [number, number];
+    /**
+     * Sets the major and minor step for this graticule
+     *
+     * @param step Major and minor step to use for this graticule.
+     */
+    step(step: [number, number]): this;
+
+    /**
+     * Returns the current major step, which defaults to ⟨90°, 360°⟩.
+     */
+    stepMajor(): [number, number];
+    /**
+     * Sets the major step for this graticule.
+     *
+     * @param step Major step.
+     */
+    stepMajor(step: [number, number]): this;
+
+    /**
+     * Returns the current major step, which defaults to ⟨10°, 10°⟩.
+     */
+    stepMinor(): [number, number];
+    /**
+     * Sets the minor step for this graticule.
+     *
+     * @param step Minor step.
+     */
+    stepMinor(step: [number, number]): this;
+
+    /**
+     * Returns the current precision, which defaults to 2.5°.
+     */
+    precision(): number;
+    /**
+     * Sets the precision for this graticule, in degrees.
+     *
+     * @param angle Precision in degrees.
+     */
+    precision(angle: number): this;
+}
+
+/**
+ * Constructs a feature generator for creating graticules: a uniform grid of meridians and parallels for showing projection distortion.
+ * The default graticule has meridians and parallels every 10° between ±80° latitude; for the polar regions, there are meridians every 90°.
+ */
+export function geoGraticule(): GeoGraticuleGenerator;
+
+/**
+ * A convenience method for directly generating the default 10° global graticule as a GeoJSON MultiLineString geometry object.
+ */
+export function geoGraticule10(): GeoJSON.MultiLineString;
+
+// ----------------------------------------------------------------------
+// Projections
+// ----------------------------------------------------------------------
+
+/**
+ * A D3 geo stream. D3 transforms geometry using a sequence of function calls, rather than materializing intermediate representations, to minimize overhead.
+ * Streams must implement several methods to receive input geometry. Streams are inherently stateful; the meaning of a point depends on whether the point is inside of a line,
+ * and likewise a line is distinguished from a ring by a polygon. Despite the name “stream”, these method calls are currently synchronous.
+ */
+export interface GeoStream {
+    /**
+     * Indicates the end of a line or ring. Within a polygon, indicates the end of a ring.
+     * Unlike GeoJSON, the redundant closing coordinate of a ring is not indicated via point, and instead is implied via lineEnd within a polygon.
+     */
+    lineEnd(): void;
+
+    /**
+     * Indicates the start of a line or ring. Within a polygon, indicates the start of a ring. The first ring of a polygon is the exterior ring, and is typically clockwise.
+     * Any subsequent rings indicate holes in the polygon, and are typically counterclockwise.
+     */
+    lineStart(): void;
+
+    /**
+     * Indicates a point with the specified coordinates x and y (and optionally z). The coordinate system is unspecified and implementation-dependent;
+     * for example, projection streams require spherical coordinates in degrees as input. Outside the context of a polygon or line,
+     * a point indicates a point geometry object (Point or MultiPoint). Within a line or polygon ring, the point indicates a control point.
+     *
+     * @param x x-coordinate of point.
+     * @param y y-coordinate of point.
+     * @param z Optional z-coordinate of point.
+     */
+    point(x: number, y: number, z?: number): void;
+
+    /**
+     * Indicates the end of a polygon.
+     */
+    polygonEnd(): void;
+
+    /**
+     * Indicates the start of a polygon. The first line of a polygon indicates the exterior ring, and any subsequent lines indicate interior holes.
+     */
+    polygonStart(): void;
+
+    /**
+     * Indicates the sphere (the globe; the unit sphere centered at ⟨0,0,0⟩).
+     */
+    sphere?(): void;
+}
+
+// geoStream(...) =======================================================
+
+/**
+ * Streams the specified GeoJSON object to the specified projection stream. While both features and geometry objects are supported as input,
+ * the stream interface only describes the geometry, and thus additional feature properties are not visible to streams.
+ *
+ * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+ * @param stream A projection stream.
+ */
+export function geoStream(object: ExtendedFeature, stream: GeoStream): void;
+
+/**
+ * Streams the specified GeoJSON object to the specified projection stream. While both features and geometry objects are supported as input,
+ * the stream interface only describes the geometry, and thus additional feature properties are not visible to streams.
+ *
+ * @param object A geographic feature collection supported by d3-geo (An extension of GeoJSON feature).
+ * @param stream A projection stream.
+ */
+export function geoStream(object: ExtendedFeatureCollection, stream: GeoStream): void;
+
+/**
+ * Streams the specified GeoJSON object to the specified projection stream. While both features and geometry objects are supported as input,
+ * the stream interface only describes the geometry, and thus additional feature properties are not visible to streams.
+ *
+ * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+ * @param stream A projection stream.
+ */
+export function geoStream(object: GeoGeometryObjects, stream: GeoStream): void;
+
+/**
+ * Streams the specified GeoJSON object to the specified projection stream. While both features and geometry objects are supported as input,
+ * the stream interface only describes the geometry, and thus additional feature properties are not visible to streams.
+ *
+ * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+ * @param stream A projection stream.
+ */
+export function geoStream(object: ExtendedGeometryCollection, stream: GeoStream): void;
+
+// ----------------------------------------------------------------------
+// Projections
+// ----------------------------------------------------------------------
+
+/**
+ * Raw projections are point transformation functions that are used to implement custom projections; they typically passed to d3.geoProjection or d3.geoProjectionMutator.
+ * They are exposed here to facilitate the derivation of related projections.
+ * Raw projections take spherical coordinates [lambda, phi] in radians (not degrees!) and return a point [x, y], typically in the unit square centered around the origin.
+ */
+export interface GeoRawProjection {
+    /**
+     * Projects the specified point [lambda, phi] in radians, returning a new point [x, y] in unitless coordinates.
+     * @param lambda Spherical lambda coordinate in radians.
+     * @param phi Spherical phi coordinate in radians.
+     */
+    (lambda: number, phi: number): [number, number];
+
+    /**
+     * Inverts the projected point [x, y] in unitless coordinates, returning an unprojected point in spherical coordinates [lambda, phi] in radians.
+     * @param x x-coordinate (unitless).
+     * @param y y-coordinate (unitless).
+     */
+    invert?(x: number, y: number): [number, number];
+}
+
+/**
+ * An object implementing a stream method
+ */
+export interface GeoStreamWrapper {
+    /**
+     * Returns a projection stream for the specified output stream. Any input geometry is projected before being streamed to the output stream.
+     * A typical projection involves several geometry transformations: the input geometry is first converted to radians, rotated on three axes,
+     * clipped to the small circle or cut along the antimeridian, and lastly projected to the plane with adaptive resampling, scale and translation.
+     *
+     * @param stream An input stream
+     */
+    stream(stream: GeoStream): GeoStream;
+}
+
+/**
+ * A Geographic Projection to transform spherical polygonal geometry to planar polygonal geometry.
+ * D3 provides implementations of several classes of standard projections:
+ *
+ * - Azimuthal
+ * - Composite
+ * - Conic
+ * - Cylindrical
+ *
+ * For many more projections, see d3-geo-projection. You can implement custom projections using d3.geoProjection or d3.geoProjectionMutator.
+ */
+export interface GeoProjection extends GeoStreamWrapper {
+    /**
+     * Returns a new array [x, y] (typically in pixels) representing the projected point of the given point.
+     * The point must be specified as a two-element array [longitude, latitude] in degrees.
+     * May return null if the specified point has no defined projected position, such as when the point is outside the clipping bounds of the projection.
+     *
+     * @param point A point specified as a two-dimensional array [longitude, latitude] in degrees.
+     */
+    (point: [number, number]): [number, number] | null;
+
+    /**
+     * Returns a new array [longitude, latitude] in degrees representing the unprojected point of the given projected point.
+     * May return null if the specified point has no defined projected position, such as when the point is outside the clipping bounds of the projection.
+     *
+     * @param point The projected point, specified as a two-element array [x, y] (typically in pixels).
+     */
+    invert?(point: [number, number]): [number, number] | null;
+
+    /**
+     * Returns the current spherical clipping function.
+     * Pre-clipping occurs in geographic coordinates. Cutting along the antimeridian line,
+     * or clipping along a small circle are the most common strategies.
+     */
+    preclip(): (stream: GeoStream) => GeoStream;
+    /**
+     * Sets the projection’s spherical clipping to the specified function and returns the projection.
+     * Pre-clipping occurs in geographic coordinates. Cutting along the antimeridian line, or clipping along a small circle are the most common strategies.
+     *
+     * @param preclip A spherical clipping function. Clipping functions are implemented as transformations of a projection stream.
+     * Pre-clipping operates on spherical coordinates, in radians.
+     */
+    preclip(preclip: (stream: GeoStream) => GeoStream): this;
+
+    /**
+     * Returns the current cartesian clipping function.
+     * Post-clipping occurs on the plane, when a projection is bounded to a certain extent such as a rectangle.
+     */
+    postclip(): (stream: GeoStream) => GeoStream;
+    /**
+     * Sets the projection’s cartesian clipping to the specified function and returns the projection.
+     *
+     * @param postclip A cartesian clipping function. Clipping functions are implemented as transformations of a projection stream.
+     * Post-clipping operates on planar coordinates, in pixels.
+     */
+    postclip(postclip: (stream: GeoStream) => GeoStream): this;
+
+    /**
+     * Returns the current clip angle which defaults to null.
+     *
+     * null switches to antimeridian cutting rather than small-circle clipping.
+     */
+    clipAngle(): number | null;
+    /**
+     * Switches to antimeridian cutting rather than small-circle clipping.
+     * See also projection.preclip, d3.geoClipAntimeridian, d3.geoClipCircle.
+     *
+     * @param angle Set to null to switch to antimeridian cutting.
+     */
+    clipAngle(angle: null): this;
+    /**
+     * Sets the projection’s clipping circle radius to the specified angle in degrees and returns the projection.
+     * Small-circle clipping is independent of viewport clipping via projection.clipExtent.
+     *
+     * See also projection.preclip, d3.geoClipAntimeridian, d3.geoClipCircle.
+     *
+     * @param angle Angle in degrees.
+     */
+    clipAngle(angle: number): this;
+
+    /**
+     * Returns the current viewport clip extent which defaults to null.
+     */
+    clipExtent(): [[number, number], [number, number]] | null;
+    /**
+     * Sets the clip extent to null and returns the projection.
+     * With a clip extent of null, no viewport clipping is performed.
+     *
+     * Viewport clipping is independent of small-circle clipping via projection.clipAngle.
+     *
+     * See also projection.postclip, d3.geoClipRectangle.
+     *
+     * @param extent Set to null to disable viewport clipping.
+     */
+    clipExtent(extent: null): this;
+    /**
+     * Sets the projection’s viewport clip extent to the specified bounds in pixels and returns the projection.
+     * The extent bounds are specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left-side of the viewport, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     *
+     * Viewport clipping is independent of small-circle clipping via projection.clipAngle.
+     *
+     * See also projection.postclip, d3.geoClipRectangle.
+     *
+     * @param extent The extent bounds are specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left-side of the viewport, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     */
+    clipExtent(extent: [[number, number], [number, number]]): this;
+
+    /**
+     * Returns the current scale factor; the default scale is projection-specific.
+     *
+     * The scale factor corresponds linearly to the distance between projected points; however, absolute scale factors are not equivalent across projections.
+     */
+    scale(): number;
+    /**
+     * Sets the projection’s scale factor to the specified value and returns the projection.
+     * The scale factor corresponds linearly to the distance between projected points; however, absolute scale factors are not equivalent across projections.
+     *
+     * @param scale Scale factor to be used for the projection; the default scale is projection-specific.
+     */
+    scale(scale: number): this;
+
+    /**
+     * Returns the current translation offset which defaults to [480, 250] and places ⟨0°,0°⟩ at the center of a 960×500 area.
+     * The translation offset determines the pixel coordinates of the projection’s center.
+     */
+    translate(): [number, number];
+    /**
+     * Sets the projection’s translation offset to the specified two-element array [tx, ty] and returns the projection.
+     * The translation offset determines the pixel coordinates of the projection’s center. The default translation offset places ⟨0°,0°⟩ at the center of a 960×500 area.
+     *
+     * @param point A two-element array [tx, ty] specifying the translation offset. The default translation offset of defaults to [480, 250] places ⟨0°,0°⟩ at the center of a 960×500 area.
+     */
+    translate(point: [number, number]): this;
+
+    /**
+     * Returns the current center of the projection, which defaults to ⟨0°,0°⟩.
+     */
+    center(): [number, number];
+    /**
+     * Sets the projection’s center to the specified center,
+     * a two-element array of longitude and latitude in degrees and returns the projection.
+     * The default is ⟨0°,0°⟩.
+     *
+     * @param point A point specified as a two-dimensional array [longitude, latitude] in degrees.
+     */
+    center(point: [number, number]): this;
+
+    /**
+     * Returns the projection’s current angle, which defaults to 0°.
+     */
+    angle(): number;
+    /**
+     * Sets the projection’s post-projection planar rotation angle to the specified angle in degrees and returns the projection.
+     * @param angle The new rotation angle of the projection.
+     */
+    angle(angle: number): this;
+
+    /**
+     * Returns true if x-reflection is enabled, which defaults to false.
+     */
+    reflectX(): boolean;
+    /**
+     * Sets whether or not the x-dimension is reflected (negated) in the output.
+     * @param reflect Whether or not the x-dimension is reflected (negated) in the output.
+     */
+    reflectX(reflect: boolean): this;
+
+    /**
+     * Returns true if y-reflection is enabled, which defaults to false.
+     */
+    reflectY(): boolean;
+    /**
+     * Sets whether or not the y-dimension is reflected (negated) in the output.
+     * @param reflect Whether or not the y-dimension is reflected (negated) in the output.
+     */
+    reflectY(reflect: boolean): this;
+
+    /**
+     * Returns the current rotation [lambda, phi, gamma] specifying the rotation angles in degrees about each spherical axis.
+     * (These correspond to yaw, pitch and roll.) which defaults [0, 0, 0].
+     */
+    rotate(): [number, number, number];
+
+    /**
+     * Sets the projection’s three-axis rotation to the specified angles, which must be a two- or three-element array of numbers.
+     *
+     * @param angles  A two- or three-element array of numbers [lambda, phi, gamma] specifying the rotation angles in degrees about each spherical axis.
+     * (These correspond to yaw, pitch and roll.) If the rotation angle gamma is omitted, it defaults to 0.
+     */
+    rotate(angles: [number, number] | [number, number, number]): this;
+
+    /**
+     * Returns the projection’s current resampling precision which defaults to square root of 0.5.
+     * This value corresponds to the Douglas–Peucker distance.
+     */
+    precision(): number;
+    /**
+     * Sets the threshold for the projection’s adaptive resampling to the specified value in pixels and returns the projection.
+     * This value corresponds to the Douglas–Peucker distance.
+     *
+     * @param precision A numeric value in pixels to use as the threshold for the projection’s adaptive resampling.
+     */
+    precision(precision: number): this;
+
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic feature in the center of the given extent.
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param extent The extent, specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left side of the bounding box, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+     */
+    fitExtent(extent: [[number, number], [number, number]], object: ExtendedFeature): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic feature collection in the center of the given extent.
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param extent The extent, specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left side of the bounding box, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     * @param object A geographic feature collection supported by d3-geo (An extension of GeoJSON feature collection).
+     */
+    fitExtent(extent: [[number, number], [number, number]], object: ExtendedFeatureCollection): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic geometry object in the center of the given extent.
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param extent The extent, specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left side of the bounding box, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+     */
+    fitExtent(extent: [[number, number], [number, number]], object: GeoGeometryObjects): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic geometry collection in the center of the given extent.
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param extent The extent, specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left side of the bounding box, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+     */
+    fitExtent(extent: [[number, number], [number, number]], object: ExtendedGeometryCollection): this;
+
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic feature in the center of an extent with the given size and top-left corner of [0, 0].
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param size The size of the extent, specified as an array [width, height].
+     * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+     */
+    fitSize(size: [number, number], object: ExtendedFeature): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic feature collection in the center of an extent with the given size and top-left corner of [0, 0].
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param size The size of the extent, specified as an array [width, height].
+     * @param object A geographic feature collection supported by d3-geo (An extension of GeoJSON feature collection).
+     */
+    fitSize(size: [number, number], object: ExtendedFeatureCollection): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic geometry object in the center of an extent with the given size and top-left corner of [0, 0].
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param size The size of the extent, specified as an array [width, height].
+     * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+     */
+    fitSize(size: [number, number], object: GeoGeometryObjects): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic geometry collection in the center of an extent with the given size and top-left corner of [0, 0].
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param size The size of the extent, specified as an array [width, height].
+     * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+     */
+    fitSize(size: [number, number], object: ExtendedGeometryCollection): this;
+
+    /**
+     * A convenience method for projection.fitSize where the height is automatically chosen from the aspect ratio of object and the given constraint on width.
+     *
+     * @param width The width of the extent.
+     * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+     */
+    fitWidth(width: number, object: ExtendedFeature): this;
+    /**
+     * A convenience method for projection.fitSize where the height is automatically chosen from the aspect ratio of object and the given constraint on width.
+     *
+     * @param width The width of the extent.
+     * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+     */
+    fitWidth(width: number, object: ExtendedFeatureCollection): this;
+    /**
+     * A convenience method for projection.fitSize where the height is automatically chosen from the aspect ratio of object and the given constraint on width.
+     *
+     * @param width The width of the extent.
+     * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+     */
+    fitWidth(width: number, object: GeoGeometryObjects): this;
+    /**
+     * A convenience method for projection.fitSize where the height is automatically chosen from the aspect ratio of object and the given constraint on width.
+     *
+     * @param width The width of the extent.
+     * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+     */
+    fitWidth(width: number, object: ExtendedGeometryCollection): this;
+
+    /**
+     * A convenience method for projection.fitSize where the width is automatically chosen from the aspect ratio of object and the given constraint on height.
+     *
+     * @param height The height of the extent.
+     * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+     */
+    fitHeight(height: number, object: ExtendedFeature): this;
+    /**
+     * A convenience method for projection.fitSize where the width is automatically chosen from the aspect ratio of object and the given constraint on height.
+     *
+     * @param height The height of the extent.
+     * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+     */
+    fitHeight(height: number, object: ExtendedFeatureCollection): this;
+    /**
+     * A convenience method for projection.fitSize where the width is automatically chosen from the aspect ratio of object and the given constraint on height.
+     *
+     * @param height The height of the extent.
+     * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+     */
+    fitHeight(height: number, object: GeoGeometryObjects): this;
+    /**
+     * A convenience method for projection.fitSize where the width is automatically chosen from the aspect ratio of object and the given constraint on height.
+     *
+     * @param height The height of the extent.
+     * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+     */
+    fitHeight(height: number, object: ExtendedGeometryCollection): this;
+}
+
+/**
+ * A Conic Projection
+ */
+export interface GeoConicProjection extends GeoProjection {
+    /**
+     * Return the standard parallels for the conic projection in degrees.
+     */
+    parallels(): [number, number];
+    /**
+     * Set the standard parallels for the conic projection in degrees and return the projection.
+     *
+     * @param value A two-dimensional array representing the standard parallels in degrees.
+     */
+    parallels(value: [number, number]): this;
+}
+
+// geoPath ==============================================================
+
+/**
+ * A minimal rendering context for a GeoPath generator. The minimum implemented
+ * methods are a subset of the CanvasRenderingContext2D API.
+ *
+ * For reference to the CanvasRenderingContext2D see https://developer.mozilla.org/en/docs/Web/API/CanvasRenderingContext2D
+ */
+export interface GeoContext {
+    /**
+     * Adds an arc to the path with center point (x, y) and radius r starting at startAngle and ending at endAngle.
+     * The arc is drawn in clockwise direction by default.
+     *
+     * @param x x-coordinate of arc center point.
+     * @param y y-coordinate of arc center point.
+     * @param radius Radius of arc.
+     * @param startAngle The starting angle of the arc, measured clockwise from the positive x axis and expressed in radians.
+     * @param endAngle The end angle of the arc, measured clockwise from the positive x axis and expressed in radians.
+     * @param anticlockwise Optional boolean flag, if true the arc is drawn counter-clockwise between the two angles.
+     */
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
+
+    /**
+     * Start a new path by emptying the list of sub-paths.
+     */
+    beginPath(): void;
+
+    /**
+     * Causes the point of the pen to move back to the start of the current sub-path.
+     * It tries to draw a straight line from the current point to the start.
+     * If the shape has already been closed or has only one point, this function does nothing.
+     */
+    closePath(): void;
+
+    /**
+     * Connects the last point in the sub-path to the x, y coordinates with a straight line (but does not actually draw it).
+     *
+     * @param x The x-coordinate for the end of the line.
+     * @param y The y-coordinate for the end of the line.
+     */
+    lineTo(x: number, y: number): void;
+
+    /**
+     * Move the starting point of a new sub-path to the (x, y) coordinates.
+     *
+     * @param x The x-coordinate for the new starting point.
+     * @param y The y-coordinate for the new starting point.
+     */
+    moveTo(x: number, y: number): void;
+}
+
+/**
+ * A Geo Path generator
+ *
+ * The first generic corresponds to the "this"-context within which the geo path generator will be invoked.
+ * This could be e.g. the DOMElement bound to "this" when using selection.attr("d", ...) with the path generator.
+ *
+ * The second generic corresponds to the type of the DatumObject which will be passed into the geo path generator for rendering.
+ */
+export interface GeoPath<This = any, DatumObject extends GeoPermissibleObjects = GeoPermissibleObjects> {
+    /**
+     * Renders the given object, which may be any GeoJSON feature or geometry object:
+     *
+     * + Point - a single position.
+     * + MultiPoint - an array of positions.
+     * + LineString - an array of positions forming a continuous line.
+     * + MultiLineString - an array of arrays of positions forming several lines.
+     * + Polygon - an array of arrays of positions forming a polygon (possibly with holes).
+     * + MultiPolygon - a multidimensional array of positions forming multiple polygons.
+     * + GeometryCollection - an array of geometry objects.
+     * + Feature - a feature containing one of the above geometry objects.
+     * + FeatureCollection - an array of feature objects.
+     *
+     * The type Sphere is also supported, which is useful for rendering the outline of the globe; a sphere has no coordinates.
+     *
+     *
+     * Any additional arguments are passed along to the pointRadius accessor.
+     *
+     * IMPORTANT: If the rendering context of the geoPath generator is null,
+     * then the geoPath is returned as an SVG path data string.
+     *
+     * Separate path elements are typically slower than a single path element. However, distinct path elements are useful for styling and interaction (e.g., click or mouseover).
+     * Canvas rendering (see path.context) is typically faster than SVG, but requires more effort to implement styling and interaction.
+     *
+     * The first generic type of the GeoPath generator used, must correspond to the "this" context bound to the function upon invocation.
+     *
+     * @param object An object to be rendered.
+     */
+    (this: This, object: DatumObject, ...args: any[]): string | null;
+    /**
+     * Renders the given object, which may be any GeoJSON feature or geometry object:
+     *
+     * + Point - a single position.
+     * + MultiPoint - an array of positions.
+     * + LineString - an array of positions forming a continuous line.
+     * + MultiLineString - an array of arrays of positions forming several lines.
+     * + Polygon - an array of arrays of positions forming a polygon (possibly with holes).
+     * + MultiPolygon - a multidimensional array of positions forming multiple polygons.
+     * + GeometryCollection - an array of geometry objects.
+     * + Feature - a feature containing one of the above geometry objects.
+     * + FeatureCollection - an array of feature objects.
+     *
+     * The type Sphere is also supported, which is useful for rendering the outline of the globe; a sphere has no coordinates.
+     *
+     *
+     * Any additional arguments are passed along to the pointRadius accessor.
+     *
+     * IMPORTANT: If the geoPath generator has been configured with a rendering context,
+     * then the geoPath is rendered to this context as a sequence of path method calls and this function returns void.
+     *
+     * Separate path elements are typically slower than a single path element. However, distinct path elements are useful for styling and interaction (e.g., click or mouseover).
+     * Canvas rendering (see path.context) is typically faster than SVG, but requires more effort to implement styling and interaction.
+     *
+     * The first generic type of the GeoPath generator used, must correspond to the "this" context bound to the function upon invocation.
+     *
+     * @param object An object to be rendered.
+     */
+    (this: This, object: DatumObject, ...args: any[]): void;
+
+    /**
+     * Returns the projected planar area (typically in square pixels) for the specified GeoJSON object.
+     * Point, MultiPoint, LineString and MultiLineString geometries have zero area. For Polygon and MultiPolygon geometries,
+     * this method first computes the area of the exterior ring, and then subtracts the area of any interior holes.
+     * This method observes any clipping performed by the projection; see projection.clipAngle and projection.clipExtent. This is the planar equivalent of d3.geoArea.
+     *
+     * @param object An object for which the area is to be calculated.
+     */
+    area(object: DatumObject): number;
+
+    /**
+     * Returns the projected planar bounding box (typically in pixels) for the specified GeoJSON object.
+     * The bounding box is represented by a two-dimensional array: [[x₀, y₀], [x₁, y₁]], where x₀ is the minimum x-coordinate, y₀ is the minimum y-coordinate,
+     * x₁ is maximum x-coordinate, and y₁ is the maximum y-coordinate.
+     *
+     * This is handy for, say, zooming in to a particular feature. (Note that in projected planar coordinates,
+     * the minimum latitude is typically the maximum y-value, and the maximum latitude is typically the minimum y-value.)
+     * This method observes any clipping performed by the projection; see projection.clipAngle and projection.clipExtent. This is the planar equivalent of d3.geoBounds.
+     *
+     * @param object An object for which the bounds are to be calculated.
+     */
+    bounds(object: DatumObject): [[number, number], [number, number]];
+
+    /**
+     * Returns the projected planar centroid (typically in pixels) for the specified GeoJSON object.
+     * This is handy for, say, labeling state or county boundaries, or displaying a symbol map.
+     * For example, a noncontiguous cartogram might scale each state around its centroid.
+     * This method observes any clipping performed by the projection; see projection.clipAngle and projection.clipExtent. This is the planar equivalent of d3.geoCentroid.
+     *
+     * @param object An object for which the centroid is to be calculated.
+     */
+    centroid(object: DatumObject): [number, number];
+
+    /**
+     * Returns the projected planar length (typically in pixels) for the specified GeoJSON object.
+     * Point and MultiPoint geometries have zero length. For Polygon and MultiPolygon geometries, this method computes the summed length of all rings.
+     *
+     * This method observes any clipping performed by the projection; see projection.clipAngle and projection.clipExtent. This is the planar equivalent of d3.geoLength.
+     *
+     * @param object An object for which the measure is to be calculated.
+     */
+    measure(object: DatumObject): number;
+
+    /**
+     * Returns the current render context which defaults to null.
+     *
+     * Use the generic to cast the return type of the rendering context, if it is known for a specific application.
+     */
+    context<C extends GeoContext | null>(): C;
+
+    /**
+     * Set the current rendering context to null and return the path generator.
+     * The path generator will return an SVG path string;
+     *
+     * @param context Null to remove the current rendering context, if any.
+     */
+    context(context: null): this;
+
+    /**
+     * Set the current rendering context and return the path generator.
+     * The path generator will render to the specified context.
+     *
+     * @param context Rendering context to be used by the path generator.
+     * The context must at least implement GeoContext, a subset of the CanvasRenderingContext2D API.
+     */
+    context(context: GeoContext): this;
+
+    /**
+     * Get the current projection. The generic parameter can be used to cast the result to the
+     * correct, known type of the projection, e.g. GeoProjection or GeoConicProjection. Otherwise,
+     * the return type defaults to the minimum type requirement for a projection which
+     * can be passed into a GeoPath.
+     *
+     * Use the generic to cast the return type of the projection, if it is known for a specific application.
+     */
+    projection<P extends GeoConicProjection | GeoProjection | GeoStreamWrapper | null>(): P;
+
+    /**
+     * Set the projection to the identity projection.
+     *
+     * @param projection Use null to set the identity projection.
+     */
+    projection(projection: null): this;
+
+    /**
+     * Set the current projection to be used with the geo path generator.
+     *
+     * The given projection is typically one of D3’s built-in geographic projections;
+     * however, any object that exposes a projection.stream function can be used, enabling the use of custom projections.
+     * See D3’s transforms for more examples of arbitrary geometric transformations.
+     *
+     * @param projection A projection.
+     */
+    projection(projection: GeoProjection): this;
+
+    /**
+     * Set the projection to be used with the geo path generator to a custom projection.
+     * Custom projections must minimally contain a stream method.
+     *
+     * The given projection is typically one of D3’s built-in geographic projections;
+     * however, any object that exposes a projection.stream function can be used, enabling the use of custom projections.
+     * See D3’s transforms for more examples of arbitrary geometric transformations.
+     *
+     * @param projection A wrapper object exposing, at a minimum a "stream" method to be used for custom projections.
+     */
+    projection(projection: GeoStreamWrapper): this;
+
+    /**
+     * Returns the current radius or radius accessor used to determine the radius for the display of Point and MultiPoint geometries.
+     * The default is a constant radius of 4.5.
+     */
+    pointRadius(): ((this: This, object: DatumObject, ...args: any[]) => number) | number;
+
+    /**
+     * Sets the radius used to display Point and MultiPoint geometries to the specified number and return the geo path generator.
+     *
+     * @param value Fixed radius value.
+     */
+    pointRadius(value: number): this;
+
+    /**
+     * Sets the radius used to display Point and MultiPoint geometries to use the specified radius accessor function.
+     *
+     * While the radius is commonly specified as a number constant, it may also be specified as a function which is computed per feature,
+     * being passed the any arguments passed to the path generator. For example, if your GeoJSON data has additional properties,
+     * you might access those properties inside the radius function to vary the point size;
+     * alternatively, you could d3.symbol and a projection for greater flexibility.
+     *
+     * @param value A value accessor function for the radius which is evaluated for each path to be rendered.
+     * The value accessor function is invoked within the "this" context in which the path generator is used.
+     * It is passed the object to be rendered, and any additional arguments which have been passed into the call to the render function of the path generator.
+     */
+    pointRadius(value: (this: This, object: DatumObject, ...args: any[]) => number): this;
+}
+
+/**
+ * Creates a new geographic path generator.
+ *
+ * The default projection is the null projection. The null projection represents the identity transformation, i.e.
+ * the input geometry is not projected and is instead rendered directly in raw coordinates.
+ * This can be useful for fast rendering of pre-projected geometry, or for fast rendering of the equirectangular projection.
+ *
+ * The default context is null, which implies that the path generator will return an SVG path string.
+ *
+ * @param projection An (optional) current projection to be used. Typically this is one of D3’s built-in geographic projections;
+ * however, any object that exposes a projection.stream function can be used, enabling the use of custom projections.
+ * See D3’s transforms for more examples of arbitrary geometric transformations. Setting the projection to "null" uses the identity projection. The default  value is "null", the identity projection.
+ * @param context An (optional) rendering context to be used. If a context is provided, it must at least implement the interface described by GeoContext, a subset of the CanvasRenderingContext2D API.
+ * Setting the context to "null" means that the path generator will return an SVG path string representing the to be rendered object. The default is "null".
+ */
+export function geoPath(projection?: GeoProjection | GeoStreamWrapper | null, context?: GeoContext | null): GeoPath;
+/**
+ * Creates a new geographic path generator with the default settings.
+ *
+ * The default projection is the null projection. The null projection represents the identity transformation:
+ * the input geometry is not projected and is instead rendered directly in raw coordinates.
+ * This can be useful for fast rendering of pre-projected geometry, or for fast rendering of the equirectangular projection.
+ *
+ * The default context is null, which implies that the path generator will return an SVG path string.
+ *
+ * The generic corresponds to the type of the DatumObject which will be passed into the geo path generator for rendering
+ *
+ * @param projection An (optional) current projection to be used. Typically this is one of D3’s built-in geographic projections;
+ * however, any object that exposes a projection.stream function can be used, enabling the use of custom projections.
+ * See D3’s transforms for more examples of arbitrary geometric transformations. Setting the projection to "null" uses the identity projection. The default  value is "null", the identity projection.
+ * @param context An (optional) rendering context to be used. If a context is provided, it must at least implement the interface described by GeoContext, a subset of the CanvasRenderingContext2D API.
+ * Setting the context to "null" means that the path generator will return an SVG path string representing the to be rendered object. The default is "null".
+ */
+export function geoPath<DatumObject extends GeoPermissibleObjects>(projection?: GeoProjection | GeoStreamWrapper | null, context?: GeoContext | null): GeoPath<any, DatumObject>;
+/**
+ * Creates a new geographic path generator with the default settings.
+ *
+ * The default projection is the null projection. The null projection represents the identity transformation:
+ * the input geometry is not projected and is instead rendered directly in raw coordinates.
+ * This can be useful for fast rendering of pre-projected geometry, or for fast rendering of the equirectangular projection.
+ *
+ * The default context is null, which implies that the path generator will return an SVG path string.
+ *
+ * The first generic corresponds to the "this"-context within which the geo path generator will be invoked.
+ * This could be e.g. the DOMElement bound to "this" when using selection.attr("d", ...) with the path generator.
+ *
+ * The second generic corresponds to the type of the DatumObject which will be passed into the geo path generator for rendering.
+ *
+ * @param projection An (optional) current projection to be used. Typically this is one of D3’s built-in geographic projections;
+ * however, any object that exposes a projection.stream function can be used, enabling the use of custom projections.
+ * See D3’s transforms for more examples of arbitrary geometric transformations. Setting the projection to "null" uses the identity projection. The default  value is "null", the identity projection.
+ * @param context An (optional) rendering context to be used. If a context is provided, it must at least implement the interface described by GeoContext, a subset of the CanvasRenderingContext2D API.
+ * Setting the context to "null" means that the path generator will return an SVG path string representing the to be rendered object. The default is "null".
+ */
+export function geoPath<This, DatumObject extends GeoPermissibleObjects>(projection?: GeoProjection | GeoStreamWrapper | null, context?: GeoContext | null): GeoPath<This, DatumObject>;
+
+// geoProjection ==========================================================
+
+/**
+ * Constructs a new projection from the specified raw projection, project.
+ * The project function takes the longitude and latitude of a given point in radians,
+ * often referred to as lambda (λ) and phi (φ), and returns a two-element array [x, y] representing its unit projection.
+ * The project function does not need to scale or translate the point, as these are applied automatically by projection.scale, projection.translate, and projection.center.
+ * Likewise, the project function does not need to perform any spherical rotation, as projection.rotate is applied prior to projection.
+ *
+ * If the project function exposes an invert method, the returned projection will also expose projection.invert.
+ */
+export function geoProjection(project: GeoRawProjection): GeoProjection;
+
+// geoProjectionMutator ====================================================
+
+/**
+ * Constructs a new projection from the specified raw projection factory and returns a mutate function to call whenever the raw projection changes.
+ * The factory must return a raw projection. The returned mutate function returns the wrapped projection.
+ *
+ * When creating a mutable projection, the mutate function is typically not exposed.
+ */
+export function geoProjectionMutator(factory: (...args: any[]) => GeoRawProjection): () => GeoProjection;
+
+// Pre-Defined Projections and Raw Projections =============================
+
+// Azimuthal Projections ---------------------------------------------------
+
+/**
+ * The azimuthal equal-area projection.
+ */
+export function geoAzimuthalEqualArea(): GeoProjection;
+
+/**
+ * The raw azimuthal equal-area projection.
+ */
+export function geoAzimuthalEqualAreaRaw(): GeoRawProjection;
+
+/**
+ * The azimuthal equidistant projection.
+ */
+export function geoAzimuthalEquidistant(): GeoProjection;
+/**
+ * The raw azimuthal equidistant projection.
+ */
+export function geoAzimuthalEquidistantRaw(): GeoRawProjection;
+
+/**
+ * The gnomonic projection.
+ */
+export function geoGnomonic(): GeoProjection;
+
+/**
+ * The raw gnomonic projection.
+ */
+export function geoGnomonicRaw(): GeoRawProjection;
+
+/**
+ * The orthographic projection.
+ */
+export function geoOrthographic(): GeoProjection;
+
+/**
+ * The raw orthographic projection.
+ */
+export function geoOrthographicRaw(): GeoRawProjection;
+
+/**
+ * The stereographic projection.
+ */
+export function geoStereographic(): GeoProjection;
+
+/**
+ * The raw stereographic projection.
+ */
+export function geoStereographicRaw(): GeoRawProjection;
+
+/**
+ * The Equal Eartch projection, by Bojan Šavrič et al., 2018.
+ */
+export function geoEqualEarth(): GeoProjection;
+
+/**
+ * The raw Equal Earth projection, by Bojan Šavrič et al., 2018.
+ */
+export function geoEqualEarthRaw(): GeoRawProjection;
+
+// Composite Projections ---------------------------------------------------
+
+/**
+ * A U.S.-centric composite projection of three d3.geoConicEqualArea projections: d3.geoAlbers is used for the lower forty-eight states,
+ * and separate conic equal-area projections are used for Alaska and Hawaii. Note that the scale for Alaska is diminished: it is projected at 0.35× its true relative area.
+ *
+ * Composite consist of several projections that are composed into a single display. The constituent projections have fixed clip, center and rotation,
+ * and thus composite projections do not support projection.center, projection.rotate, projection.clipAngle, or projection.clipExtent.
+ */
+export function geoAlbersUsa(): GeoProjection;
+
+// Conic Projections -------------------------------------------------------
+
+/**
+ * The Albers’ equal area-conic projection. This is a U.S.-centric configuration of d3.geoConicEqualArea.
+ */
+export function geoAlbers(): GeoConicProjection;
+
+/**
+ * The conic conformal projection. The parallels default to [30°, 30°] resulting in flat top.
+ */
+export function geoConicConformal(): GeoConicProjection;
+
+/**
+ * The raw conic conformal projection.
+ */
+export function geoConicConformalRaw(phi0: number, phi1: number): GeoRawProjection;
+
+/**
+ * The Albers’ equal-area conic projection.
+ */
+export function geoConicEqualArea(): GeoConicProjection;
+
+/**
+ * The raw Albers’ equal-area conic projection.
+ */
+export function geoConicEqualAreaRaw(phi0: number, phi1: number): GeoRawProjection;
+
+/**
+ * The conic equidistant projection.
+ */
+export function geoConicEquidistant(): GeoConicProjection;
+
+/**
+ * The raw conic equidistant projection.
+ */
+export function geoConicEquidistantRaw(phi0: number, phi1: number): GeoRawProjection;
+
+// Cylindrical Projections ------------------------------------------------
+
+/**
+ * The equirectangular (plate carrée) projection.
+ */
+export function geoEquirectangular(): GeoProjection;
+
+/**
+ * The raw equirectangular (plate carrée) projection.
+ */
+export function geoEquirectangularRaw(): GeoRawProjection;
+
+/**
+ * The spherical Mercator projection.
+ * Defines a default projection.clipExtent such that the world is projected to a square, clipped to approximately ±85° latitude.
+ */
+export function geoMercator(): GeoProjection;
+/**
+ * The raw spherical Mercator projection.
+ */
+export function geoMercatorRaw(): GeoRawProjection;
+
+/**
+ * The transverse spherical Mercator projection.
+ * Defines a default projection.clipExtent such that the world is projected to a square, clipped to approximately ±85° latitude.
+ */
+export function geoTransverseMercator(): GeoProjection;
+
+/**
+ * The raw transverse spherical Mercator projection.
+ */
+export function geoTransverseMercatorRaw(): GeoRawProjection;
+
+/**
+ * The Natural Earth projection is a pseudocylindrical projection designed by Tom Patterson. It is neither conformal nor equal-area, but appealing to the eye for small-scale maps of the whole world.
+ */
+export function geoNaturalEarth1(): GeoProjection;
+
+/**
+ * The raw pseudo-cylindircal Natural Earth projection.
+ */
+export function geoNaturalEarth1Raw(): GeoRawProjection;
+
+// ----------------------------------------------------------------------
+// Projection Transforms
+// ----------------------------------------------------------------------
+
+// geoTransform(...) ====================================================
+
+/**
+ * A Prototype interface which serves as a template for the implementation of a geometric transform using geoTransform(...)
+ * It serves as a reference for the custom methods which can be passed into geoTransform as argument to crete a generalized
+ * transform projection.
+ */
+export interface GeoTransformPrototype {
+    /**
+     * Indicates the end of a line or ring. Within a polygon, indicates the end of a ring.
+     * Unlike GeoJSON, the redundant closing coordinate of a ring is not indicated via point, and instead is implied via lineEnd within a polygon.
+     */
+    lineEnd?(this: this & { stream: GeoStream }): void;
+    /**
+     * Indicates the start of a line or ring. Within a polygon, indicates the start of a ring. The first ring of a polygon is the exterior ring, and is typically clockwise.
+     * Any subsequent rings indicate holes in the polygon, and are typically counterclockwise.
+     */
+    lineStart?(this: this & { stream: GeoStream }): void;
+    /**
+     * Indicates a point with the specified coordinates x and y (and optionally z). The coordinate system is unspecified and implementation-dependent;
+     * for example, projection streams require spherical coordinates in degrees as input. Outside the context of a polygon or line,
+     * a point indicates a point geometry object (Point or MultiPoint). Within a line or polygon ring, the point indicates a control point.
+     *
+     * @param x x-coordinate of point.
+     * @param y y-coordinate of point.
+     * @param z Optional z-coordinate of point.
+     */
+    point?(this: this & { stream: GeoStream }, x: number, y: number, z?: number): void;
+    /**
+     * Indicates the end of a polygon.
+     */
+    polygonEnd?(this: this & { stream: GeoStream }): void;
+    /**
+     * Indicates the start of a polygon. The first line of a polygon indicates the exterior ring, and any subsequent lines indicate interior holes.
+     */
+    polygonStart?(this: this & { stream: GeoStream }): void;
+    /**
+     * Indicates the sphere (the globe; the unit sphere centered at ⟨0,0,0⟩).
+     */
+    sphere?(this: this & { stream: GeoStream }): void;
+}
+
+// TODO: Review whether GeoStreamWrapper should be included into return value union type, i.e. ({ stream: (s: GeoStream) => (T & GeoStream & GeoStreamWrapper)})?
+// It probably should be omitted for purposes of this API. The stream method added to (T & GeoStream) is more of a private member used internally to
+// implement the Transform factory
+
+/**
+ * Defines an arbitrary transform using the methods defined on the specified methods object.
+ * Any undefined methods will use pass-through methods that propagate inputs to the output stream.
+ *
+ * @param methods An object with custom method implementations, which are used to create a transform projection.
+ */
+export function geoTransform<T extends GeoTransformPrototype>(methods: T): { stream(s: GeoStream): T & GeoStream };
+
+// geoIdentity() =================================================================
+
+/**
+ * @deprecated Misspelled name. Use GeoIdentityTransform.
+ */
+export type GeoIdentityTranform = GeoIdentityTransform;
+
+/**
+ * Geo Identity Transform
+ */
+export interface GeoIdentityTransform extends GeoStreamWrapper {
+    /**
+     * Returns a new array [x, y] (typically in pixels) representing the projected point of the given point.
+     * The point must be specified as a two-element array [longitude, latitude] in degrees.
+     * May return null if the specified point has no defined projected position, such as when the point is outside the clipping bounds of the projection.
+     *
+     * @param point A point specified as a two-dimensional array [longitude, latitude] in degrees.
+     */
+    (point: [number, number]): [number, number] | null;
+
+    /**
+     * Returns a new array [longitude, latitude] in degrees representing the unprojected point of the given projected point.
+     * May return null if the specified point has no defined projected position, such as when the point is outside the clipping bounds of the projection.
+     *
+     * @param point The projected point, specified as a two-element array [x, y] (typically in pixels).
+     */
+    invert(point: [number, number]): [number, number] | null;
+
+    /**
+     * Returns the current cartesian clipping function.
+     * Post-clipping occurs on the plane, when a projection is bounded to a certain extent such as a rectangle.
+     */
+    postclip(): (stream: GeoStream) => GeoStream;
+    /**
+     * Sets the projection’s cartesian clipping to the specified function and returns the projection.
+     *
+     * @param postclip A cartesian clipping function. Clipping functions are implemented as transformations of a projection stream.
+     * Post-clipping operates on planar coordinates, in pixels.
+     */
+    postclip(postclip: (stream: GeoStream) => GeoStream): this;
+
+    /**
+     * Returns the current scale factor.
+     *
+     * The scale factor corresponds linearly to the distance between projected points; however, absolute scale factors are not equivalent across projections.
+     */
+    scale(): number;
+    /**
+     * Sets the projection’s scale factor to the specified value and returns the projection.
+     * The scale factor corresponds linearly to the distance between projected points; however, absolute scale factors are not equivalent across projections.
+     *
+     * @param scale Scale factor to be used for the projection.
+     */
+    scale(scale: number): this;
+
+    /**
+     * Returns the current translation offset.
+     * The translation offset determines the pixel coordinates of the projection’s center.
+     */
+    translate(): [number, number];
+    /**
+     * Sets the projection’s translation offset to the specified two-element array [tx, ty] and returns the projection.
+     * The translation offset determines the pixel coordinates of the projection’s center.
+     *
+     * @param point A two-element array [tx, ty] specifying the translation offset.
+     */
+    translate(point: [number, number]): this;
+
+    /**
+     * Returns the projection’s current angle, which defaults to 0°.
+     */
+    angle(): number;
+    /**
+     * Sets the projection’s post-projection planar rotation angle to the specified angle in degrees and returns the projection.
+     * @param angle The new rotation angle of the projection.
+     */
+    angle(angle: number): this;
+
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic feature in the center of the given extent.
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param extent The extent, specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left side of the bounding box, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+     */
+    fitExtent(extent: [[number, number], [number, number]], object: ExtendedFeature): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic feature collection in the center of the given extent.
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param extent The extent, specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left side of the bounding box, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     * @param object A geographic feature collection supported by d3-geo (An extension of GeoJSON feature collection).
+     */
+    fitExtent(extent: [[number, number], [number, number]], object: ExtendedFeatureCollection): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic geometry object in the center of the given extent.
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param extent The extent, specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left side of the bounding box, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+     */
+    fitExtent(extent: [[number, number], [number, number]], object: GeoGeometryObjects): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic geometry collection in the center of the given extent.
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param extent The extent, specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left side of the bounding box, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+     */
+    fitExtent(extent: [[number, number], [number, number]], object: ExtendedGeometryCollection): this;
+
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic feature in the center of an extent with the given size and top-left corner of [0, 0].
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param size The size of the extent, specified as an array [width, height].
+     * @param object A geographic feature supported by d3-geo (An extension of GeoJSON feature).
+     */
+    fitSize(size: [number, number], object: ExtendedFeature): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic feature collection in the center of an extent with the given size and top-left corner of [0, 0].
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param size The size of the extent, specified as an array [width, height].
+     * @param object A geographic feature collection supported by d3-geo (An extension of GeoJSON feature collection).
+     */
+    fitSize(size: [number, number], object: ExtendedFeatureCollection): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic geometry object in the center of an extent with the given size and top-left corner of [0, 0].
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param size The size of the extent, specified as an array [width, height].
+     * @param object A GeoJson Geometry Object or GeoSphere object supported by d3-geo (An extension of GeoJSON).
+     */
+    fitSize(size: [number, number], object: GeoGeometryObjects): this;
+    /**
+     * Sets the projection’s scale and translate to fit the specified geographic geometry collection in the center of an extent with the given size and top-left corner of [0, 0].
+     * Returns the projection.
+     *
+     * Any clip extent is ignored when determining the new scale and translate. The precision used to compute the bounding box of the given object is computed at an effective scale of 150.
+     *
+     * @param size The size of the extent, specified as an array [width, height].
+     * @param object A geographic geometry collection supported by d3-geo (An extension of GeoJSON geometry collection).
+     */
+    fitSize(size: [number, number], object: ExtendedGeometryCollection): this;
+
+    /**
+     * Returns the current viewport clip extent which defaults to null.
+     */
+    clipExtent(): [[number, number], [number, number]] | null;
+    /**
+     * Sets the clip extent to null and returns the projection.
+     * With a clip extent of null, no viewport clipping is performed.
+     *
+     * Viewport clipping is independent of small-circle clipping via projection.clipAngle.
+     *
+     * @param extent Set to null to disable viewport clipping.
+     */
+    clipExtent(extent: null): this;
+    /**
+     * Sets the projection’s viewport clip extent to the specified bounds in pixels and returns the projection.
+     * The extent bounds are specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left-side of the viewport, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     *
+     * Viewport clipping is independent of small-circle clipping via projection.clipAngle.
+     *
+     * @param extent The extent bounds are specified as an array [[x₀, y₀], [x₁, y₁]], where x₀ is the left-side of the viewport, y₀ is the top, x₁ is the right and y₁ is the bottom.
+     */
+    clipExtent(extent: [[number, number], [number, number]]): this;
+
+    /**
+     * Returns true if x-reflection is enabled, which defaults to false.
+     */
+    reflectX(): boolean;
+    /**
+     * Sets whether or not the x-dimension is reflected (negated) in the output.
+     *
+     * @param reflect true = reflect x-dimension, false = do not reflect x-dimension.
+     */
+    reflectX(reflect: boolean): this;
+
+    /**
+     * Returns true if y-reflection is enabled, which defaults to false.
+     */
+    reflectY(): boolean;
+    /**
+     * Sets whether or not the y-dimension is reflected (negated) in the output.
+     *
+     * This is especially useful for transforming from standard spatial reference systems,
+     * which treat positive y as pointing up, to display coordinate systems such as Canvas and SVG,
+     * which treat positive y as pointing down.
+     *
+     * @param reflect true = reflect y-dimension, false = do not reflect y-dimension.
+     */
+    reflectY(reflect: boolean): this;
+}
+
+/**
+ * Returns the identity transform which can be used to scale, translate and clip planar geometry.
+ */
+export function geoIdentity(): GeoIdentityTransform;
+
+// ----------------------------------------------------------------------
+// Clipping Functions
+// ----------------------------------------------------------------------
+
+/**
+ * A clipping function transforming a stream such that geometries (lines or polygons) that cross the antimeridian line are cut in two, one on each side.
+ * Typically used for pre-clipping.
+ */
+export const geoClipAntimeridian: ((stream: GeoStream) => GeoStream);
+
+/**
+ * Generates a clipping function transforming a stream such that geometries are bounded by a small circle of radius angle around the projection’s center.
+ * Typically used for pre-clipping.
+ *
+ * @param angle A clipping angle.
+ */
+export function geoClipCircle(angle: number): (stream: GeoStream) => GeoStream;
+
+/**
+ * Generates a clipping function transforming a stream such that geometries are bounded by a rectangle of coordinates [[x0, y0], [x1, y1]].
+ * Typically used for post-clipping.
+ *
+ * @param x0 x0 coordinate.
+ * @param y0 y0 coordinate.
+ * @param x1 x1 coordinate.
+ * @param y1 y1 coordinate.
+ */
+export function geoClipRectangle(x0: number, y0: number, x1: number, y1: number): (stream: GeoStream) => GeoStream;

node_modules/@types/d3-geo/package.json

@@ -0,0 +1,71 @@
+{
+  "_from": "@types/d3-geo@*",
+  "_id": "@types/d3-geo@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-DHHgYXW36lnAEQMYU2udKVOxxljHrn2EdOINeSC9jWCAXwOnGn7A19B8sNsHqgpu4F7O2bSD7//cqBXD3W0Deg==",
+  "_location": "/@types/d3-geo",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-geo@*",
+    "name": "@types/d3-geo",
+    "escapedName": "@types%2fd3-geo",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-geo/-/d3-geo-2.0.0.tgz",
+  "_shasum": "6f179512343c2d30e06acde190abfacf44b2d264",
+  "_spec": "@types/d3-geo@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Hugues Stefanski",
+      "url": "https://github.com/ledragon"
+    },
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {
+    "@types/geojson": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-geo module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-geo",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-geo"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "642a3d4a764ea31e9b8189bf76709d1ab369ef98751de493a08ecc17f101459e",
+  "version": "2.0.0"
+}

node_modules/@types/d3-hierarchy/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-hierarchy/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-hierarchy`
+
+# Summary
+This package contains type definitions for D3JS d3-hierarchy module (https://github.com/d3/d3-hierarchy/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-hierarchy.
+
+### Additional Details
+ * Last updated: Wed, 30 Sep 2020 00:01:32 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-hierarchy/index.d.ts

@@ -0,0 +1,875 @@
+// Type definitions for D3JS d3-hierarchy module 2.0
+// Project: https://github.com/d3/d3-hierarchy/, https://d3js.org/d3-hierarchy
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Last module patch version validated against: 2.0.0
+
+// -----------------------------------------------------------------------
+// Hierarchy
+// -----------------------------------------------------------------------
+
+export interface HierarchyLink<Datum> {
+    /**
+     * The source of the link.
+     */
+    source: HierarchyNode<Datum>;
+
+    /**
+     * The target of the link.
+     */
+    target: HierarchyNode<Datum>;
+}
+
+export interface HierarchyNode<Datum> {
+    /**
+     * The associated data, as specified to the constructor.
+     */
+    data: Datum;
+
+    /**
+     * Zero for the root node, and increasing by one for each descendant generation.
+     */
+    readonly depth: number;
+
+    /**
+     * Zero for leaf nodes, and the greatest distance from any descendant leaf for internal nodes.
+     */
+    readonly height: number;
+
+    /**
+     * The parent node, or null for the root node.
+     */
+    parent: this | null;
+
+    /**
+     * An array of child nodes, if any; undefined for leaf nodes.
+     */
+    children?: this[];
+
+    /**
+     * Aggregated numeric value as calculated by `sum(value)` or `count()`, if previously invoked.
+     */
+    readonly value?: number;
+
+    /**
+     * Optional node id string set by `StratifyOperator`, if hierarchical data was created from tabular data using stratify().
+     */
+    readonly id?: string;
+
+    /**
+     * Returns the array of ancestors nodes, starting with this node, then followed by each parent up to the root.
+     */
+    ancestors(): this[];
+
+    /**
+     * Returns the array of descendant nodes, starting with this node, then followed by each child in topological order.
+     */
+    descendants(): this[];
+
+    /**
+     * Returns the array of leaf nodes in traversal order; leaves are nodes with no children.
+     */
+    leaves(): this[];
+
+    /**
+     * Returns the first node in the hierarchy from this node for which the specified filter returns a truthy value. undefined if no such node is found.
+     * @param filter Filter.
+     */
+    find(filter: (node: this) => boolean): this | undefined;
+
+    /**
+     * Returns the shortest path through the hierarchy from this node to the specified target node.
+     * The path starts at this node, ascends to the least common ancestor of this node and the target node, and then descends to the target node.
+     *
+     * @param target The target node.
+     */
+    path(target: this): this[];
+
+    /**
+     * Returns an array of links for this node, where each link is an object that defines source and target properties.
+     * The source of each link is the parent node, and the target is a child node.
+     */
+    links(): Array<HierarchyLink<Datum>>;
+
+    /**
+     * Evaluates the specified value function for this node and each descendant in post-order traversal, and returns this node.
+     * The `node.value` property of each node is set to the numeric value returned by the specified function plus the combined value of all descendants.
+     *
+     * @param value The value function is passed the node’s data, and must return a non-negative number.
+     */
+    sum(value: (d: Datum) => number): this;
+
+    /**
+     * Computes the number of leaves under this node and assigns it to `node.value`, and similarly for every descendant of node.
+     * If this node is a leaf, its count is one. Returns this node.
+     */
+    count(): this;
+
+    /**
+     * Sorts the children of this node, if any, and each of this node’s descendants’ children,
+     * in pre-order traversal using the specified compare function, and returns this node.
+     *
+     * @param compare The compare function is passed two nodes a and b to compare.
+     * If a should be before b, the function must return a value less than zero;
+     * if b should be before a, the function must return a value greater than zero;
+     * otherwise, the relative order of a and b are not specified. See `array.sort` for more.
+     */
+    sort(compare: (a: this, b: this) => number): this;
+
+    /**
+     * Returns an iterator over the node’s descendants in breadth-first order.
+     */
+    [Symbol.iterator](): Iterator<this>;
+
+    /**
+     * Invokes the specified function for node and each descendant in breadth-first order,
+     * such that a given node is only visited if all nodes of lesser depth have already been visited,
+     * as well as all preceding nodes of the same depth.
+     *
+     * @param func The specified function is passed the current descendant, the zero-based traversal index, and this node.
+     * @param that If that is specified, it is the this context of the callback.
+     */
+    each<T = undefined>(func: (this: T, node: this, index: number, thisNode: this) => void, that?: T): this;
+
+    /**
+     * Invokes the specified function for node and each descendant in post-order traversal,
+     * such that a given node is only visited after all of its descendants have already been visited.
+     *
+     * @param func The specified function is passed the current descendant, the zero-based traversal index, and this node.
+     * @param that If that is specified, it is the this context of the callback.
+     *
+     */
+    eachAfter<T = undefined>(func: (this: T, node: this, index: number, thisNode: this) => void, that?: T): this;
+
+    /**
+     * Invokes the specified function for node and each descendant in pre-order traversal,
+     * such that a given node is only visited after all of its ancestors have already been visited.
+     *
+     * @param func The specified function is passed the current descendant, the zero-based traversal index, and this node.
+     * @param that If that is specified, it is the this context of the callback.
+     */
+    eachBefore<T = undefined>(func: (this: T, node: this, index: number, thisNode: this) => void, that?: T): this;
+
+    /**
+     * Return a deep copy of the subtree starting at this node. The returned deep copy shares the same data, however.
+     * The returned node is the root of a new tree; the returned node’s parent is always null and its depth is always zero.
+     */
+    copy(): this;
+}
+
+/**
+ * Constructs a root node from the specified hierarchical data.
+ *
+ * @param data The root specified data.
+ * If *data* is a Map, it is implicitly converted to the entry [undefined, *data*],
+ * and the children accessor instead defaults to `(d) => Array.isArray(d) ? d[1] : null;`.
+ * @param children The specified children accessor function is invoked for each datum, starting with the root data,
+ * and must return an iterable of data representing the children, if any.
+ * If children is not specified, it defaults to: `(d) => d.children`.
+ */
+export function hierarchy<Datum>(data: Datum, children?: (d: Datum) => (Iterable<Datum> | null | undefined)): HierarchyNode<Datum>;
+
+// -----------------------------------------------------------------------
+// Stratify
+// -----------------------------------------------------------------------
+
+export interface StratifyOperator<Datum> {
+    /**
+     * Generates a new hierarchy from the specified tabular data. Each node in the returned object has a shallow copy of the properties
+     * from the corresponding data object, excluding the following reserved properties: id, parentId, children.
+     *
+     * @param data The root specified data.
+     * @throws Error on missing id, ambiguous id, cycle, multiple roots or no root.
+     */
+    (data: Datum[]): HierarchyNode<Datum>;
+
+    /**
+     * Returns the current id accessor, which defaults to: `(d) => d.id`.
+     */
+    id(): (d: Datum, i: number, data: Datum[]) => (string | null | '' | undefined);
+    /**
+     * Sets the id accessor to the given function.
+     * The id accessor is invoked for each element in the input data passed to the stratify operator.
+     * The returned string is then used to identify the node's relationships in conjunction with the parent id.
+     * For leaf nodes, the id may be undefined, null or the empty string; otherwise, the id must be unique.
+     *
+     * @param id The id accessor.
+     */
+    id(id: (d: Datum, i: number, data: Datum[]) => (string | null | '' | undefined)): this;
+
+    /**
+     * Returns the current parent id accessor, which defaults to: `(d) => d.parentId`.
+     */
+    parentId(): (d: Datum, i: number, data: Datum[]) => (string | null | '' | undefined);
+    /**
+     * Sets the parent id accessor to the given function.
+     * The parent id accessor is invoked for each element in the input data passed to the stratify operator.
+     * The returned string is then used to identify the node's relationships in conjunction with the id.
+     * For the root node, the parent id should be undefined, null or the empty string.
+     * There must be exactly one root node in the input data, and no circular relationships.
+     *
+     * @param parentId The parent id accessor.
+     */
+    parentId(parentId: (d: Datum, i: number, data: Datum[]) => (string | null | '' | undefined)): this;
+}
+
+/**
+ * Constructs a new stratify operator with the default settings.
+ */
+export function stratify<Datum>(): StratifyOperator<Datum>;
+
+// -----------------------------------------------------------------------
+// Cluster
+// -----------------------------------------------------------------------
+
+export interface HierarchyPointLink<Datum> {
+    /**
+     * The source of the link.
+     */
+    source: HierarchyPointNode<Datum>;
+
+    /**
+     * The target of the link.
+     */
+    target: HierarchyPointNode<Datum>;
+}
+
+export interface HierarchyPointNode<Datum> extends HierarchyNode<Datum> {
+    /**
+     * The x-coordinate of the node.
+     */
+    x: number;
+
+    /**
+     * The y-coordinate of the node.
+     */
+    y: number;
+
+    /**
+     * Returns an array of links for this node, where each link is an object that defines source and target properties.
+     * The source of each link is the parent node, and the target is a child node.
+     */
+    links(): Array<HierarchyPointLink<Datum>>;
+}
+
+export interface ClusterLayout<Datum> {
+    /**
+     * Lays out the specified root hierarchy.
+     * You may want to call `root.sort` before passing the hierarchy to the cluster layout.
+     *
+     * @param root The specified root hierarchy.
+     */
+    (root: HierarchyNode<Datum>): HierarchyPointNode<Datum>;
+
+    /**
+     * Returns the current layout size, which defaults to [1, 1]. A layout size of null indicates that a node size will be used instead.
+     */
+    size(): [number, number] | null;
+    /**
+     * Sets this cluster layout’s size to the specified [width, height] array and returns the cluster layout.
+     * The size represent an arbitrary coordinate system; for example, to produce a radial layout,
+     * a size of [360, radius] corresponds to a breadth of 360° and a depth of radius.
+     *
+     * @param size The specified two-element size array.
+     */
+    size(size: [number, number]): this;
+
+    /**
+     * Returns the current node size, which defaults to null. A node size of null indicates that a layout size will be used instead.
+     */
+    nodeSize(): [number, number] | null;
+    /**
+     * Sets this cluster layout’s node size to the specified [width, height] array and returns this cluster layout.
+     * When a node size is specified, the root node is always positioned at <0, 0>.
+     *
+     * @param size The specified two-element size array.
+     */
+    nodeSize(size: [number, number]): this;
+
+    /**
+     * Returns the current separation accessor, which defaults to: `(a, b) => a.parent == b.parent ? 1 : 2`.
+     */
+    separation(): (a: HierarchyPointNode<Datum>, b: HierarchyPointNode<Datum>) => number;
+    /**
+     * Sets the separation accessor to the specified function and returns this cluster layout.
+     * The separation accessor is used to separate neighboring leaves.
+     *
+     * @param separation The separation function is passed two leaves a and b, and must return the desired separation.
+     * The nodes are typically siblings, though the nodes may be more distantly related if the layout decides to place such nodes adjacent.
+     */
+    separation(separation: (a: HierarchyPointNode<Datum>, b: HierarchyPointNode<Datum>) => number): this;
+}
+
+/**
+ * Creates a new cluster layout with default settings.
+ */
+export function cluster<Datum>(): ClusterLayout<Datum>;
+
+// -----------------------------------------------------------------------
+// Tree
+// -----------------------------------------------------------------------
+
+export interface TreeLayout<Datum> {
+    /**
+     * Lays out the specified root hierarchy.
+     * You may want to call `root.sort` before passing the hierarchy to the tree layout.
+     *
+     * @param root The specified root hierarchy.
+     */
+    (root: HierarchyNode<Datum>): HierarchyPointNode<Datum>;
+
+    /**
+     * Returns the current layout size, which defaults to [1, 1]. A layout size of null indicates that a node size will be used instead.
+     */
+    size(): [number, number] | null;
+    /**
+     * Sets this tree layout’s size to the specified [width, height] array and returns the tree layout.
+     * The size represent an arbitrary coordinate system; for example, to produce a radial layout,
+     * a size of [360, radius] corresponds to a breadth of 360° and a depth of radius.
+     *
+     * @param size The specified two-element size array.
+     */
+    size(size: [number, number]): this;
+
+    /**
+     * Returns the current node size, which defaults to null. A node size of null indicates that a layout size will be used instead.
+     */
+    nodeSize(): [number, number] | null;
+    /**
+     * Sets this tree layout’s node size to the specified [width, height] array and returns this tree layout.
+     * When a node size is specified, the root node is always positioned at <0, 0>.
+     *
+     * @param size The specified two-element size array.
+     */
+    nodeSize(size: [number, number]): this;
+
+    /**
+     * Returns the current separation accessor, which defaults to: `(a, b) => a.parent == b.parent ? 1 : 2`.
+     */
+    separation(): (a: HierarchyPointNode<Datum>, b: HierarchyPointNode<Datum>) => number;
+    /**
+     * Sets the separation accessor to the specified function and returns this tree layout.
+     * The separation accessor is used to separate neighboring nodes.
+     *
+     * @param separation The separation function is passed two nodes a and b, and must return the desired separation.
+     * The nodes are typically siblings, though the nodes may be more distantly related if the layout decides to place such nodes adjacent.
+     */
+    separation(separation: (a: HierarchyPointNode<Datum>, b: HierarchyPointNode<Datum>) => number): this;
+}
+
+/**
+ * Creates a new tree layout with default settings.
+ */
+export function tree<Datum>(): TreeLayout<Datum>;
+
+// -----------------------------------------------------------------------
+// Treemap
+// -----------------------------------------------------------------------
+
+export interface HierarchyRectangularLink<Datum> {
+    /**
+     * The source of the link.
+     */
+    source: HierarchyRectangularNode<Datum>;
+
+    /**
+     * The target of the link.
+     */
+    target: HierarchyRectangularNode<Datum>;
+}
+
+export interface HierarchyRectangularNode<Datum> extends HierarchyNode<Datum> {
+    /**
+     * The left edge of the rectangle.
+     */
+    x0: number;
+
+    /**
+     * The top edge of the rectangle
+     */
+    y0: number;
+
+    /**
+     * The right edge of the rectangle.
+     */
+    x1: number;
+
+    /**
+     * The bottom edge of the rectangle.
+     */
+    y1: number;
+
+    /**
+     * Returns an array of links for this node, where each link is an object that defines source and target properties.
+     * The source of each link is the parent node, and the target is a child node.
+     */
+    links(): Array<HierarchyRectangularLink<Datum>>;
+}
+
+export interface TreemapLayout<Datum> {
+    /**
+     * Lays out the specified root hierarchy.
+     * You must call `root.sum` before passing the hierarchy to the treemap layout.
+     * You probably also want to call `root.sort` to order the hierarchy before computing the layout.
+     *
+     * @param root The specified root hierarchy.
+     */
+    (root: HierarchyNode<Datum>): HierarchyRectangularNode<Datum>;
+
+    /**
+     * Returns the current tiling method, which defaults to `d3.treemapSquarify` with the golden ratio.
+     */
+    tile(): (node: HierarchyRectangularNode<Datum>, x0: number, y0: number, x1: number, y1: number) => void;
+    /**
+     * Sets the tiling method to the specified function and returns this treemap layout.
+     *
+     * @param tile The specified tiling function.
+     */
+    tile(tile: (node: HierarchyRectangularNode<Datum>, x0: number, y0: number, x1: number, y1: number) => void): this;
+
+    /**
+     * Returns the current size, which defaults to [1, 1].
+     */
+    size(): [number, number];
+    /**
+     * Sets this treemap layout’s size to the specified [width, height] array and returns this treemap layout.
+     *
+     * @param size The specified two-element size array.
+     */
+    size(size: [number, number]): this;
+
+    /**
+     * Returns the current rounding state, which defaults to false.
+     */
+    round(): boolean;
+    /**
+     * Enables or disables rounding according to the given boolean and returns this treemap layout.
+     *
+     * @param round The specified boolean flag.
+     */
+    round(round: boolean): this;
+
+    /**
+     * Returns the current inner padding function.
+     */
+    padding(): (node: HierarchyRectangularNode<Datum>) => number;
+    /**
+     * Sets the inner and outer padding to the specified number and returns this treemap layout.
+     *
+     * @param padding The specified padding value.
+     */
+    padding(padding: number): this;
+    /**
+     * Sets the inner and outer padding to the specified function and returns this treemap layout.
+     *
+     * @param padding The specified padding function.
+     */
+    padding(padding: (node: HierarchyRectangularNode<Datum>) => number): this;
+
+    /**
+     * Returns the current inner padding function, which defaults to the constant zero.
+     */
+    paddingInner(): (node: HierarchyRectangularNode<Datum>) => number;
+    /**
+     * Sets the inner padding to the specified number and returns this treemap layout.
+     * The inner padding is used to separate a node’s adjacent children.
+     *
+     * @param padding The specified inner padding value.
+     */
+    paddingInner(padding: number): this;
+    /**
+     * Sets the inner padding to the specified function and returns this treemap layout.
+     * The function is invoked for each node with children, being passed the current node.
+     * The inner padding is used to separate a node’s adjacent children.
+     *
+     * @param padding The specified inner padding function.
+     */
+    paddingInner(padding: (node: HierarchyRectangularNode<Datum>) => number): this;
+
+    /**
+     * Returns the current top padding function.
+     */
+    paddingOuter(): (node: HierarchyRectangularNode<Datum>) => number;
+    /**
+     * Sets the top, right, bottom and left padding to the specified function and returns this treemap layout.
+     *
+     * @param padding The specified padding outer value.
+     */
+    paddingOuter(padding: number): this;
+    /**
+     * Sets the top, right, bottom and left padding to the specified function and returns this treemap layout.
+     *
+     * @param padding The specified padding outer function.
+     */
+    paddingOuter(padding: (node: HierarchyRectangularNode<Datum>) => number): this;
+
+    /**
+     * Returns the current top padding function, which defaults to the constant zero.
+     */
+    paddingTop(): (node: HierarchyRectangularNode<Datum>) => number;
+    /**
+     * Sets the top padding to the specified number and returns this treemap layout.
+     * The top padding is used to separate the top edge of a node from its children.
+     *
+     * @param padding The specified top padding value.
+     */
+    paddingTop(padding: number): this;
+    /**
+     * Sets the top padding to the specified function and returns this treemap layout.
+     * The function is invoked for each node with children, being passed the current node.
+     * The top padding is used to separate the top edge of a node from its children.
+     *
+     * @param padding The specified top padding function.
+     */
+    paddingTop(padding: (node: HierarchyRectangularNode<Datum>) => number): this;
+
+    /**
+     * Returns the current right padding function, which defaults to the constant zero.
+     */
+    paddingRight(): (node: HierarchyRectangularNode<Datum>) => number;
+    /**
+     * Sets the right padding to the specified number and returns this treemap layout.
+     * The right padding is used to separate the right edge of a node from its children.
+     *
+     * @param padding The specified right padding value.
+     */
+    paddingRight(padding: number): this;
+    /**
+     * Sets the right padding to the specified function and returns this treemap layout.
+     * The function is invoked for each node with children, being passed the current node.
+     * The right padding is used to separate the right edge of a node from its children.
+     *
+     * @param padding The specified right padding function.
+     */
+    paddingRight(padding: (node: HierarchyRectangularNode<Datum>) => number): this;
+
+    /**
+     * Returns the current bottom padding function, which defaults to the constant zero.
+     */
+    paddingBottom(): (node: HierarchyRectangularNode<Datum>) => number;
+    /**
+     * Sets the bottom padding to the specified number and returns this treemap layout.
+     * The bottom padding is used to separate the bottom edge of a node from its children.
+     *
+     * @param padding The specified bottom padding value.
+     */
+    paddingBottom(padding: number): this;
+    /**
+     * Sets the bottom padding to the specified function and returns this treemap layout.
+     * The function is invoked for each node with children, being passed the current node.
+     * The bottom padding is used to separate the bottom edge of a node from its children.
+     *
+     * @param padding The specified bottom padding function.
+     */
+    paddingBottom(padding: (node: HierarchyRectangularNode<Datum>) => number): this;
+
+    /**
+     * Returns the current left padding function, which defaults to the constant zero.
+     */
+    paddingLeft(): (node: HierarchyRectangularNode<Datum>) => number;
+    /**
+     * Sets the left padding to the specified number and returns this treemap layout.
+     * The left padding is used to separate the left edge of a node from its children.
+     *
+     * @param padding The specified left padding value.
+     */
+    paddingLeft(padding: number): this;
+    /**
+     * Sets the left padding to the specified function and returns this treemap layout.
+     * The function is invoked for each node with children, being passed the current node.
+     * The left padding is used to separate the left edge of a node from its children.
+     *
+     * @param padding The specified left padding function.
+     */
+    paddingLeft(padding: (node: HierarchyRectangularNode<Datum>) => number): this;
+}
+
+/**
+ * Creates a new treemap layout with default settings.
+ */
+export function treemap<Datum>(): TreemapLayout<Datum>;
+
+// Tiling functions ------------------------------------------------------
+
+/**
+ * Recursively partitions the specified nodes into an approximately-balanced binary tree,
+ * choosing horizontal partitioning for wide rectangles and vertical partitioning for tall rectangles.
+ */
+export function treemapBinary(node: HierarchyRectangularNode<any>, x0: number, y0: number, x1: number, y1: number): void;
+
+/**
+ * Divides the rectangular area specified by x0, y0, x1, y1 horizontally according the value of each of the specified node’s children.
+ * The children are positioned in order, starting with the left edge (x0) of the given rectangle.
+ * If the sum of the children’s values is less than the specified node’s value (i.e., if the specified node has a non-zero internal value),
+ * the remaining empty space will be positioned on the right edge (x1) of the given rectangle.
+ */
+export function treemapDice(node: HierarchyRectangularNode<any>, x0: number, y0: number, x1: number, y1: number): void;
+
+/**
+ * Divides the rectangular area specified by x0, y0, x1, y1 vertically according the value of each of the specified node’s children.
+ * The children are positioned in order, starting with the top edge (y0) of the given rectangle.
+ * If the sum of the children’s values is less than the specified node’s value (i.e., if the specified node has a non-zero internal value),
+ * the remaining empty space will be positioned on the bottom edge (y1) of the given rectangle.
+ */
+export function treemapSlice(node: HierarchyRectangularNode<any>, x0: number, y0: number, x1: number, y1: number): void;
+
+/**
+ * If the specified node has odd depth, delegates to treemapSlice; otherwise delegates to treemapDice.
+ */
+export function treemapSliceDice(node: HierarchyRectangularNode<any>, x0: number, y0: number, x1: number, y1: number): void;
+
+// TODO: Test Factory code
+export interface RatioSquarifyTilingFactory {
+    (node: HierarchyRectangularNode<any>, x0: number, y0: number, x1: number, y1: number): void;
+
+    /**
+     * Specifies the desired aspect ratio of the generated rectangles.
+     * Note that the orientation of the generated rectangles (tall or wide) is not implied by the ratio.
+     * Furthermore, the rectangles ratio are not guaranteed to have the exact specified aspect ratio.
+     * If not specified, the aspect ratio defaults to the golden ratio, φ = (1 + sqrt(5)) / 2, per Kong et al.
+     *
+     * @param ratio The specified ratio value greater than or equal to one.
+     */
+    ratio(ratio: number): RatioSquarifyTilingFactory;
+}
+
+/**
+ * Implements the squarified treemap algorithm by Bruls et al., which seeks to produce rectangles of a given aspect ratio.
+ */
+export const treemapSquarify: RatioSquarifyTilingFactory;
+
+/**
+ * Like `d3.treemapSquarify`, except preserves the topology (node adjacencies) of the previous layout computed by `d3.treemapResquarify`,
+ * if there is one and it used the same target aspect ratio. This tiling method is good for animating changes to treemaps because
+ * it only changes node sizes and not their relative positions, thus avoiding distracting shuffling and occlusion.
+ * The downside of a stable update, however, is a suboptimal layout for subsequent updates: only the first layout uses the Bruls et al. squarified algorithm.
+ */
+export const treemapResquarify: RatioSquarifyTilingFactory;
+
+// -----------------------------------------------------------------------
+// Partition
+// -----------------------------------------------------------------------
+
+export interface PartitionLayout<Datum> {
+    /**
+     * Lays out the specified root hierarchy.
+     * You must call `root.sum` before passing the hierarchy to the partition layout.
+     * You probably also want to call `root.sort` to order the hierarchy before computing the layout.
+     *
+     * @param root The specified root hierarchy.
+     */
+    (root: HierarchyNode<Datum>): HierarchyRectangularNode<Datum>;
+
+    /**
+     * Returns the current size, which defaults to [1, 1].
+     */
+    size(): [number, number];
+    /**
+     * Sets this partition layout’s size to the specified [width, height] array and returns this partition layout.
+     *
+     * @param size The specified two-element size array.
+     */
+    size(size: [number, number]): this;
+
+    /**
+     * Returns the current rounding state, which defaults to false.
+     */
+    round(): boolean;
+    /**
+     * Enables or disables rounding according to the given boolean and returns this partition layout.
+     *
+     * @param round The specified boolean flag.
+     */
+    round(round: boolean): this;
+
+    /**
+     * Returns the current padding, which defaults to zero.
+     */
+    padding(): number;
+    /**
+     * Sets the padding to the specified number and returns this partition layout.
+     * The padding is used to separate a node’s adjacent children.
+     *
+     * @param padding The specified padding value.
+     */
+    padding(padding: number): this;
+}
+
+/**
+ * Creates a new partition layout with the default settings.
+ */
+export function partition<Datum>(): PartitionLayout<Datum>;
+
+// -----------------------------------------------------------------------
+// Pack
+// -----------------------------------------------------------------------
+
+export interface HierarchyCircularLink<Datum> {
+    /**
+     * The source of the link.
+     */
+    source: HierarchyCircularNode<Datum>;
+
+    /**
+     * The target of the link.
+     */
+    target: HierarchyCircularNode<Datum>;
+}
+
+export interface HierarchyCircularNode<Datum> extends HierarchyNode<Datum> {
+    /**
+     * The x-coordinate of the circle’s center.
+     */
+    x: number;
+
+    /**
+     * The y-coordinate of the circle’s center.
+     */
+    y: number;
+
+    /**
+     * The radius of the circle.
+     */
+    r: number;
+
+    /**
+     * Returns an array of links for this node, where each link is an object that defines source and target properties.
+     * The source of each link is the parent node, and the target is a child node.
+     */
+    links(): Array<HierarchyCircularLink<Datum>>;
+}
+
+export interface PackLayout<Datum> {
+    /**
+     * Lays out the specified root hierarchy.
+     * You must call `root.sum` before passing the hierarchy to the pack layout.
+     * You probably also want to call `root.sort` to order the hierarchy before computing the layout.
+     *
+     * @param root The specified root hierarchy.
+     */
+    (root: HierarchyNode<Datum>): HierarchyCircularNode<Datum>;
+
+    /**
+     * Returns the current radius accessor, which defaults to null.
+     */
+    radius(): null | ((node: HierarchyCircularNode<Datum>) => number);
+    /**
+     * Sets the pack layout’s radius accessor to the specified function and returns this pack layout.
+     * If the radius accessor is null, the radius of each leaf circle is derived from the leaf `node.value` (computed by `node.sum`);
+     * the radii are then scaled proportionally to fit the layout size.
+     * If the radius accessor is not null, the radius of each leaf circle is specified exactly by the function.
+     *
+     * @param radius The specified radius accessor.
+     */
+    radius(radius: null | ((node: HierarchyCircularNode<Datum>) => number)): this;
+
+    /**
+     * Returns the current size, which defaults to [1, 1].
+     */
+    size(): [number, number];
+    /**
+     * Sets this pack layout’s size to the specified [width, height] array and returns this pack layout.
+     *
+     * @param size The specified two-element size array.
+     */
+    size(size: [number, number]): this;
+
+    /**
+     * Returns the current padding accessor, which defaults to the constant zero.
+     */
+    padding(): (node: HierarchyCircularNode<Datum>) => number;
+    /**
+     * Sets this pack layout’s padding accessor to the specified number and returns this pack layout.
+     * Returns the current padding accessor, which defaults to the constant zero.
+     *
+     * When siblings are packed, tangent siblings will be separated by approximately the specified padding;
+     * the enclosing parent circle will also be separated from its children by approximately the specified padding.
+     * If an explicit radius is not specified, the padding is approximate because a two-pass algorithm
+     * is needed to fit within the layout size: the circles are first packed without padding;
+     * a scaling factor is computed and applied to the specified padding; and lastly the circles are re-packed with padding.
+     *
+     * @param padding The specified padding value.
+     */
+    padding(padding: number): this;
+    /**
+     * Sets this pack layout’s padding accessor to the specified function and returns this pack layout.
+     * Returns the current padding accessor, which defaults to the constant zero.
+     *
+     * When siblings are packed, tangent siblings will be separated by approximately the specified padding;
+     * the enclosing parent circle will also be separated from its children by approximately the specified padding.
+     * If an explicit radius is not specified, the padding is approximate because a two-pass algorithm
+     * is needed to fit within the layout size: the circles are first packed without padding;
+     * a scaling factor is computed and applied to the specified padding; and lastly the circles are re-packed with padding.
+     *
+     * @param padding The specified padding function.
+     */
+    padding(padding: (node: HierarchyCircularNode<Datum>) => number): this;
+}
+
+/**
+ * Creates a new pack layout with the default settings.
+ */
+export function pack<Datum>(): PackLayout<Datum>;
+
+// -----------------------------------------------------------------------
+// Pack Siblings and Enclosure
+// -----------------------------------------------------------------------
+
+export interface PackRadius {
+    /**
+     * The radius of the circle.
+     */
+    r: number;
+
+    /**
+     * The x-coordinate of the circle’s center.
+     */
+    x?: number;
+
+    /**
+     * The y-coordinate of the circle’s center.
+     */
+    y?: number;
+}
+
+export interface PackCircle {
+    /**
+     * The radius of the circle.
+     */
+    r: number;
+
+    /**
+     * The x-coordinate of the circle’s center.
+     */
+    x: number;
+
+    /**
+     * The y-coordinate of the circle’s center.
+     */
+    y: number;
+}
+
+// TODO: Since packSiblings manipulates the circles array in place, technically the x and y properties
+// are optional on invocation, but will be created after execution for each entry.
+
+/**
+ * Packs the specified array of circles, each of which must have a `circle.r` property specifying the circle’s radius.
+ * The circles are positioned according to the front-chain packing algorithm by Wang et al.
+ *
+ * @param circles The specified array of circles to pack.
+ */
+export function packSiblings<Datum extends PackRadius>(circles: Datum[]): Array<Datum & PackCircle>;
+
+/**
+ * Computes the smallest circle that encloses the specified array of circles, each of which must have
+ * a `circle.r` property specifying the circle’s radius, and `circle.x` and `circle.y` properties specifying the circle’s center.
+ * The enclosing circle is computed using the Matoušek-Sharir-Welzl algorithm. (See also Apollonius’ Problem.)
+ *
+ * @param circles The specified array of circles to pack.
+ */
+export function packEnclose<Datum extends PackCircle>(circles: Datum[]): PackCircle;

node_modules/@types/d3-hierarchy/package.json

@@ -0,0 +1,69 @@
+{
+  "_from": "@types/d3-hierarchy@*",
+  "_id": "@types/d3-hierarchy@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-YxdskUvwzqggpnSnDQj4KVkicgjpkgXn/g/9M9iGsiToLS3nG6Ytjo1FoYhYVAAElV/fJBGVL3cQ9Hb7tcv+lw==",
+  "_location": "/@types/d3-hierarchy",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-hierarchy@*",
+    "name": "@types/d3-hierarchy",
+    "escapedName": "@types%2fd3-hierarchy",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-hierarchy/-/d3-hierarchy-2.0.0.tgz",
+  "_shasum": "92079d9dbcec1dfe2736fb050a8bf916e5850a1c",
+  "_spec": "@types/d3-hierarchy@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "denisname",
+      "url": "https://github.com/denisname"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-hierarchy module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-hierarchy",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-hierarchy"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "cfe92c70e946538e00274633e3a290ba14b60ad16f3d3231aa62fe19bf2c12b2",
+  "version": "2.0.0"
+}

node_modules/@types/d3-interpolate/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-interpolate/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-interpolate`
+
+# Summary
+This package contains type definitions for D3JS d3-interpolate module (https://github.com/d3/d3-interpolate/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-interpolate.
+
+### Additional Details
+ * Last updated: Thu, 01 Oct 2020 22:50:46 GMT
+ * Dependencies: [@types/d3-color](https://npmjs.com/package/@types/d3-color)
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-interpolate/index.d.ts

@@ -0,0 +1,374 @@
+// Type definitions for D3JS d3-interpolate module 2.0
+// Project: https://github.com/d3/d3-interpolate/, https://d3js.org/d3-interpolate
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+// Last module patch version validated against: 2.0.1
+
+import { ColorCommonInstance } from 'd3-color';
+
+// ---------------------------------------------------------------------------
+// Shared Type Definitions and Interfaces
+// ---------------------------------------------------------------------------
+
+export interface ZoomInterpolator extends Function {
+    (t: number): ZoomView;
+    /**
+     * Recommended duration of zoom transition in milliseconds.
+     */
+    duration: number;
+
+    /**
+     * Given a zoom interpolator, returns a new zoom interpolator using the specified curvature rho.
+     * When rho is close to 0, the interpolator is almost linear.
+     * The default curvature is sqrt(2).
+     * @param rho
+     */
+    rho(rho: number): this;
+}
+
+export interface ColorGammaInterpolationFactory extends Function {
+    (a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
+    /**
+     * Returns a new interpolator factory of the same type using the specified *gamma*.
+     * For example, to interpolate from purple to orange with a gamma of 2.2 in RGB space: `d3.interpolateRgb.gamma(2.2)("purple", "orange")`.
+     * See Eric Brasseur’s article, [Gamma error in picture scaling](https://web.archive.org/web/20160112115812/http://www.4p8.com/eric.brasseur/gamma.html), for more on gamma correction.
+     */
+    gamma(g: number): ColorGammaInterpolationFactory;
+}
+
+/**
+ * Type zoomView is used to represent a numeric array with three elements.
+ * In order of appearance the elements correspond to:
+ * - cx: *x*-coordinate of the center of the viewport
+ * - cy: *y*-coordinate of the center of the viewport
+ * - width: size of the viewport
+ */
+export type ZoomView = [number, number, number];
+
+export type TypedArray =
+    | Int8Array
+    | Uint8Array
+    | Int16Array
+    | Uint16Array
+    | Int32Array
+    | Uint32Array
+    | Uint8ClampedArray
+    | Float32Array
+    | Float64Array;
+
+export type NumberArray = TypedArray | DataView;
+
+// ---------------------------------------------------------------------------
+// Interpolation Function Factories
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns an `null` constant interpolator.
+ */
+export function interpolate(a: any, b: null): ((t: number) => null);
+/**
+ * Returns an boolean constant interpolator of value `b`.
+ */
+export function interpolate(a: any, b: boolean): ((t: number) => boolean);
+/**
+ * Returns a `interpolateNumber` interpolator.
+ */
+export function interpolate(a: number | { valueOf(): number }, b: number): ((t: number) => number);
+/**
+ * Returns a `interpolateRgb` interpolator.
+ */
+export function interpolate(a: string | ColorCommonInstance, b: ColorCommonInstance): ((t: number) => string);
+/**
+ * Returns a `interpolateDate` interpolator.
+ */
+export function interpolate(a: Date, b: Date): ((t: number) => Date);
+/**
+ * Returns a `interpolateNumberArray` interpolator.
+ */
+export function interpolate<T extends NumberArray>(a: NumberArray | number[], b: T): ((t: number) => T);
+/**
+ * Returns a `interpolateString` interpolator. If `b` is a string coercible to a color use use `interpolateRgb`.
+ */
+export function interpolate(a: string | { toString(): string }, b: string): ((t: number) => string);
+/**
+ * Returns a `interpolateArray` interpolator.
+ */
+export function interpolate<U extends any[]>(a: any[], b: U): ((t: number) => U);
+/**
+ * Returns a `interpolateNumber` interpolator.
+ */
+export function interpolate(a: number | { valueOf(): number }, b: { valueOf(): number }): ((t: number) => number);
+/**
+ * Returns a `interpolateObject` interpolator.
+ */
+export function interpolate<U extends object>(a: any, b: U): ((t: number) => U);
+
+/**
+ * Returns an interpolator between the two numbers `a` and `b`.
+ * The returned interpolator is equivalent to: `(t) => a * (1 - t) + b * t`.
+ */
+export function interpolateNumber(a: number | { valueOf(): number }, b: number | { valueOf(): number }): ((t: number) => number);
+
+/**
+ * Returns an interpolator between the two numbers `a` and `b`; the interpolator is similar to `interpolateNumber`,
+ * except it will round the resulting value to the nearest integer.
+ */
+export function interpolateRound(a: number | { valueOf(): number }, b: number | { valueOf(): number }): ((t: number) => number);
+
+/**
+ * Returns an interpolator between the two strings `a` and `b`.
+ * The string interpolator finds numbers embedded in `a` and `b`, where each number is of the form understood by JavaScript.
+ * A few examples of numbers that will be detected within a string: `-1`, `42`, `3.14159`, and `6.0221413e+23`.
+ *
+ * For each number embedded in `b`, the interpolator will attempt to find a corresponding number in `a`.
+ * If a corresponding number is found, a numeric interpolator is created using `interpolateNumber`.
+ * The remaining parts of the string `b` are used as a template.
+ *
+ * For example, if `a` is `"300 12px sans-serif"`, and `b` is `"500 36px Comic-Sans"`, two embedded numbers are found.
+ * The remaining static parts (of string `b`) are a space between the two numbers (`" "`), and the suffix (`"px Comic-Sans"`).
+ * The result of the interpolator at `t` = 0.5 is `"400 24px Comic-Sans"`.
+ */
+export function interpolateString(a: string | { toString(): string }, b: string | { toString(): string }): ((t: number) => string);
+
+/**
+ * Returns an interpolator between the two dates `a` and `b`.
+ *
+ * Note: *no defensive copy* of the returned date is created; the same Date instance is returned for every evaluation of the interpolator.
+ * No copy is made for performance reasons; interpolators are often part of the inner loop of animated transitions.
+ */
+export function interpolateDate(a: Date, b: Date): ((t: number) => Date);
+
+export type ArrayInterpolator<A extends any[]> = ((t: number) => A);
+
+/**
+ * Returns an interpolator between the two arrays `a` and `b`. Internally, an array template is created that is the same length in `b`.
+ * For each element in `b`, if there exists a corresponding element in `a`, a generic interpolator is created for the two elements using `interpolate`.
+ * If there is no such element, the static value from `b` is used in the template.
+ * Then, for the given parameter `t`, the template’s embedded interpolators are evaluated. The updated array template is then returned.
+ *
+ * For example, if `a` is the array `[0, 1]` and `b` is the array `[1, 10, 100]`, then the result of the interpolator for `t = 0.5` is the array `[0.5, 5.5, 100]`.
+ *
+ * Note: *no defensive copy* of the template array is created; modifications of the returned array may adversely affect subsequent evaluation of the interpolator.
+ * No copy is made for performance reasons; interpolators are often part of the inner loop of animated transitions.
+ */
+export function interpolateArray<A extends any[]>(a: any[], b: A): ArrayInterpolator<A>;
+/**
+ * interpolateNumberArray is called
+ */
+export function interpolateArray<T extends NumberArray>(a: NumberArray | number[], b: T): ((t: number) => T);
+
+/**
+ * Returns an interpolator between the two arrays of numbers a and b.
+ * Internally, an array template is created that is the same type and length as b.
+ * For each element in b, if there exists a corresponding element in a, the values are directly interpolated in the array template.
+ * If there is no such element, the static value from b is copied.
+ * The updated array template is then returned.
+ *
+ * Note: For performance reasons, no defensive copy is made of the template array and the arguments a and b; modifications of these arrays may affect subsequent evaluation of the interpolator.
+ */
+export function interpolateNumberArray<T extends NumberArray | number[]>(a: NumberArray | number[], b: T): ((t: number) => T);
+
+/**
+ * Returns an interpolator between the two objects `a` and `b`. Internally, an object template is created that has the same properties as `b`.
+ * For each property in `b`, if there exists a corresponding property in `a`, a generic interpolator is created for the two elements using `interpolate`.
+ * If there is no such property, the static value from `b` is used in the template.
+ * Then, for the given parameter `t`, the template's embedded interpolators are evaluated and the updated object template is then returned.
+ *
+ * For example, if `a` is the object `{x: 0, y: 1}` and `b` is the object `{x: 1, y: 10, z: 100}`, the result of the interpolator for `t = 0.5` is the object `{x: 0.5, y: 5.5, z: 100}`.
+ *
+ * Note: *no defensive copy* of the template object is created; modifications of the returned object may adversely affect subsequent evaluation of the interpolator.
+ * No copy is made for performance reasons; interpolators are often part of the inner loop of animated transitions.
+ */
+export function interpolateObject<U extends object>(a: any, b: U): ((t: number) => U);
+
+/**
+ * Returns an interpolator between the two 2D CSS transforms represented by `a` and `b`.
+ * Each transform is decomposed to a standard representation of translate, rotate, *x*-skew and scale; these component transformations are then interpolated.
+ * This behavior is standardized by CSS: see [matrix decomposition for animation](http://www.w3.org/TR/css3-2d-transforms/#matrix-decomposition).
+ */
+export function interpolateTransformCss(a: string, b: string): ((t: number) => string);
+
+/**
+ * Returns an interpolator between the two 2D SVG transforms represented by `a` and `b`.
+ * Each transform is decomposed to a standard representation of translate, rotate, *x*-skew and scale; these component transformations are then interpolated.
+ * This behavior is standardized by CSS: see [matrix decomposition for animation](http://www.w3.org/TR/css3-2d-transforms/#matrix-decomposition).
+ */
+export function interpolateTransformSvg(a: string, b: string): ((t: number) => string);
+
+/**
+ * Returns an interpolator between the two views `a` and `b` of a two-dimensional plane,
+ * based on [“Smooth and efficient zooming and panning”](http://www.win.tue.nl/~vanwijk/zoompan.pdf).
+ * Each view is defined as an array of three numbers: *cx*, *cy* and *width*.
+ * The first two coordinates *cx*, *cy* represent the center of the viewport; the last coordinate *width* represents the size of the viewport.
+ *
+ * The returned interpolator exposes a *duration* property which encodes the recommended transition duration in milliseconds.
+ * This duration is based on the path length of the curved trajectory through *x,y* space.
+ * If you want to a slower or faster transition, multiply this by an arbitrary scale factor (*V* as described in the original paper).
+ */
+export function interpolateZoom(a: ZoomView, b: ZoomView): ZoomInterpolator;
+
+/**
+ * Returns a discrete interpolator for the given array of values. The returned interpolator maps `t` in `[0, 1 / n)` to values[0],
+ * `t` in `[1 / n, 2 / n)` to `values[1]`, and so on, where `n = values.length`. In effect, this is a lightweight quantize scale with a fixed domain of [0, 1].
+ */
+export function interpolateDiscrete<T>(values: T[]): ((t: number) => T);
+
+// Sampling ------------------------------------------------------------------
+
+/**
+ * Returns `n` uniformly-spaced samples from the specified `interpolator`, where `n` is an integer greater than one.
+ * The first sample is always at `t = 0`, and the last sample is always at `t = 1`.
+ * This can be useful in generating a fixed number of samples from a given interpolator,
+ * such as to derive the range of a [quantize scale](https://github.com/d3/d3-scale#quantize-scales) from a [continuous interpolator](https://github.com/d3/d3-scale#interpolateWarm).
+ *
+ * Caution: this method will not work with interpolators that do not return defensive copies of their output,
+ * such as `d3.interpolateArray`, `d3.interpolateDate` and `d3.interpolateObject`. For those interpolators, you must wrap the interpolator and create a copy for each returned value.
+ */
+export function quantize<T>(interpolator: ((t: number) => T), n: number): T[];
+
+// Color Spaces
+
+/**
+ * Returns an RGB color space interpolator between the two colors `a` and `b` with a configurable gamma. If the gamma is not specified, it defaults to 1.0.
+ * The colors `a` and `b` need not be in RGB; they will be converted to RGB using [`d3.rgb`](https://github.com/d3/d3-color#rgb). The return value of the interpolator is an RGB string.
+ */
+export const interpolateRgb: ColorGammaInterpolationFactory;
+
+/**
+ * Returns a uniform nonrational B-spline interpolator through the specified array of *colors*, which are converted to RGB color space.
+ * Implicit control points are generated such that the interpolator returns `colors[0]` at `t = 0` and `colors[colors.length - 1]` at `t = 1`.
+ * Opacity interpolation is not currently supported. See also `d3.interpolateBasis`, and see [d3-scale-chromatic](https://github.com/d3/d3-scale-chromatic) for examples.
+ */
+export function interpolateRgbBasis(colors: Array<string | ColorCommonInstance>): ((t: number) => string);
+
+/**
+ * Returns a uniform nonrational B-spline interpolator through the specified array of colors, which are converted to RGB color space.
+ * The control points are implicitly repeated such that the resulting spline has cyclical C² continuity when repeated around `t` in [0,1];
+ * this is useful, for example, to create cyclical color scales. Opacity interpolation is not currently supported.
+ * See also `d3.interpolateBasisClosed, and see [d3-scale-chromatic](https://github.com/d3/d3-scale-chromatic) for examples.
+ */
+export function interpolateRgbBasisClosed(colors: Array<string | ColorCommonInstance>): ((t: number) => string);
+
+/**
+ * Returns an HSL color space interpolator between the two colors *a* and *b*. The colors *a* and *b* need not be in HSL;
+ * they will be converted to HSL using `d3.hsl`. If either color’s hue or saturation is NaN, the opposing color’s channel value is used.
+ * The shortest path between hues is used. The return value of the interpolator is an RGB string.
+ */
+export function interpolateHsl(a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
+
+/**
+ * Like `interpolateHsl`, but does not use the shortest path between hues.
+ */
+export function interpolateHslLong(a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
+
+/**
+ * Returns a Lab color space interpolator between the two colors *a* and *b*. The colors *a* and *b* need not be in Lab;
+ * they will be converted to Lab using `d3.lab`. The return value of the interpolator is an RGB string.
+ */
+export function interpolateLab(a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
+
+/**
+ * Returns an HCL color space interpolator between the two colors `a` and `b`. The colors `a` and `b` need not be in HCL;
+ * they will be converted to HCL using `d3.hcl`. If either color’s hue or chroma is NaN, the opposing color’s channel value is used.
+ * The shortest path between hues is used. The return value of the interpolator is an RGB string.
+ */
+export function interpolateHcl(a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
+
+/**
+ * Like `interpolateHcl`, but does not use the shortest path between hues.
+ */
+export function interpolateHclLong(a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
+
+/**
+ * Returns a Cubehelix color space interpolator between the two colors `a` and `b` using a configurable `gamma`.
+ * If the gamma is not specified, it defaults to 1.0. The colors `a` and `b` need not be in Cubehelix;
+ * they will be converted to Cubehelix using [`d3.cubehelix`](https://github.com/d3/d3-color#cubehelix).
+ * If either color’s hue or saturation is NaN, the opposing color’s channel value is used. The shortest path between hues is used. The return value of the interpolator is an RGB string.
+ */
+export const interpolateCubehelix: ColorGammaInterpolationFactory;
+
+/**
+ * Like `interpolateCubehelix`, but does not use the shortest path between hues.
+ */
+export const interpolateCubehelixLong: ColorGammaInterpolationFactory;
+
+/**
+ * Returns an interpolator between the two hue angles `a` and `b`. If either hue is NaN, the opposing value is used.
+ * The shortest path between hues is used. The return value of the interpolator is a number in `[0, 360)`.
+ */
+export function interpolateHue(a: number, b: number): ((t: number) => number);
+
+// Splines -------------------------------------------------------------------
+
+/**
+ * Returns a uniform nonrational B-spline interpolator through the specified array of `values`, which must be numbers.
+ * Implicit control points are generated such that the interpolator returns `values[0]` at `t` = 0 and `values[values.length - 1]` at `t` = 1.
+ * See also [`d3.curveBasis`](https://github.com/d3/d3-shape#curveBasis).
+ */
+export function interpolateBasis(splineNodes: number[]): ((t: number) => number);
+
+/**
+ * Returns a uniform nonrational B-spline interpolator through the specified array of `values`, which must be numbers.
+ * The control points are implicitly repeated such that the resulting one-dimensional spline has cyclical C² continuity when repeated around `t` in [0,1].
+ * See also [`d3.curveBasisClosed`](https://github.com/d3/d3-shape#curveBasisClosed).
+ */
+export function interpolateBasisClosed(splineNodes: number[]): ((t: number) => number);
+
+// Piecewise -----------------------------------------------------------------
+
+/**
+ * Returns a piecewise zoom interpolator, composing zoom interpolators for each adjacent pair of zoom view.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through three different zoom views: `d3.piecewise(d3.interpolateZoom, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
+ *
+ * interpolate defaults to d3.interpolate.
+ */
+export function piecewise(values: ZoomView[]): ZoomInterpolator;
+/**
+ * Returns a piecewise zoom interpolator, composing zoom interpolators for each adjacent pair of zoom view.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through three different zoom views: `d3.piecewise(d3.interpolateZoom, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
+ */
+export function piecewise(interpolate: (a: ZoomView, b: ZoomView) => ZoomInterpolator, values: ZoomView[]): ZoomInterpolator;
+
+/**
+ * Returns a piecewise array interpolator, composing array interpolators for each adjacent pair of arrays.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through three different arrays: `d3.piecewise(d3.interpolateArray, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
+ *
+ * interpolate defaults to d3.interpolate.
+ */
+export function piecewise<A extends any[]>(values: A[]): ArrayInterpolator<A>;
+/**
+ * Returns a piecewise array interpolator, composing array interpolators for each adjacent pair of arrays.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through three different arrays: `d3.piecewise(d3.interpolateArray, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
+ */
+export function piecewise<A extends any[]>(interpolate: (a: any[], b: A) => ArrayInterpolator<A>, values: A[]): ArrayInterpolator<A>;
+
+/**
+ * Returns a piecewise interpolator, composing interpolators for each adjacent pair of values.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through red, green and blue: `d3.piecewise(d3.interpolateRgb.gamma(2.2), ["red", "green", "blue"])`.
+ *
+ * interpolate defaults to d3.interpolate.
+ */
+export function piecewise<TData>(values: TData[]): (t: number) => any;
+/**
+ * Returns a piecewise interpolator, composing interpolators for each adjacent pair of values.
+ * The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
+ * and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
+ * For example, to blend through red, green and blue: `d3.piecewise(d3.interpolateRgb.gamma(2.2), ["red", "green", "blue"])`.
+ */
+export function piecewise<TData, Interpolator>(interpolate: (a: TData, b: TData) => Interpolator, values: TData[]): (t: number) => any;

node_modules/@types/d3-interpolate/package.json

@@ -0,0 +1,72 @@
+{
+  "_from": "@types/d3-interpolate@*",
+  "_id": "@types/d3-interpolate@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-Wt1v2zTlEN8dSx8hhx6MoOhWQgTkz0Ukj7owAEIOF2QtI0e219paFX9rf/SLOr/UExWb1TcUzatU8zWwFby6gg==",
+  "_location": "/@types/d3-interpolate",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-interpolate@*",
+    "name": "@types/d3-interpolate",
+    "escapedName": "@types%2fd3-interpolate",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3",
+    "/@types/d3-zoom"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-2.0.0.tgz",
+  "_shasum": "325029216dc722c1c68c33ccda759f1209d35823",
+  "_spec": "@types/d3-interpolate@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "denisname",
+      "url": "https://github.com/denisname"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {
+    "@types/d3-color": "*"
+  },
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-interpolate module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-interpolate",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-interpolate"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "923883425b2304561287ef57e6bcd2ec24835182fb190424f5acdd3365c9b93d",
+  "version": "2.0.0"
+}

node_modules/@types/d3-path/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-path/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-path`
+
+# Summary
+This package contains type definitions for D3JS d3-path module (https://github.com/d3/d3-path/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-path.
+
+### Additional Details
+ * Last updated: Tue, 29 Sep 2020 22:54:46 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-path/index.d.ts

@@ -0,0 +1,109 @@
+// Type definitions for D3JS d3-path module 2.0
+// Project: https://github.com/d3/d3-path/, https://d3js.org/d3-path
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Last module patch version validated against: 2.0.0
+
+/**
+ * A D3 path serializer implementing CanvasPathMethods
+ */
+export interface Path {
+    /**
+     * Move to the specified point ⟨x, y⟩. Equivalent to context.moveTo and SVG’s “moveto” command.
+     *
+     * @param x x-Coordinate of point to move to
+     * @param y y-Coordinate of point to move to
+     */
+    moveTo(x: number, y: number): void;
+
+    /**
+     * Ends the current subpath and causes an automatic straight line to be drawn from the current point to the initial point of the current subpath.
+     * Equivalent to context.closePath and SVG’s “closepath” command.
+     */
+    closePath(): void;
+
+    /**
+     * Draws a straight line from the current point to the specified point ⟨x, y⟩.
+     * Equivalent to context.lineTo and SVG’s “lineto” command.
+     *
+     * @param x x-Coordinate of point to draw the line to
+     * @param y y-Coordinate of point to draw the line to
+     */
+    lineTo(x: number, y: number): void;
+
+    /**
+     * Draws a quadratic Bézier segment from the current point to the specified point ⟨x, y⟩, with the specified control point ⟨cpx, cpy⟩.
+     * Equivalent to context.quadraticCurveTo and SVG’s quadratic Bézier curve commands.
+     *
+     * @param cpx x-Coordinate of the control point for the quadratic Bézier curve
+     * @param cpy y-Coordinate of the control point for the quadratic Bézier curve
+     * @param x x-Coordinate of point to draw the curve to
+     * @param y y-Coordinate of point to draw the curve to
+     */
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+
+    /**
+     * Draws a cubic Bézier segment from the current point to the specified point ⟨x, y⟩, with the specified control points ⟨cpx1, cpy1⟩ and ⟨cpx2, cpy2⟩.
+     * Equivalent to context.bezierCurveTo and SVG’s cubic Bézier curve commands.
+     *
+     * @param cpx1 x-Coordinate of the first control point for the Bézier curve
+     * @param cpy1 y-Coordinate of the first control point for the Bézier curve
+     * @param cpx2 x-Coordinate of the second control point for the Bézier curve
+     * @param cpy2 y-Coordinate of the second control point for the Bézier curve
+     * @param x x-Coordinate of point to draw the curve to
+     * @param y y-Coordinate of point to draw the curve to
+     */
+    bezierCurveTo(cpx1: number, cpy1: number, cpx2: number, cpy2: number, x: number, y: number): void;
+
+    /**
+     * Draws a circular arc segment with the specified radius that starts tangent to the line between the current point and the specified point ⟨x1, y1⟩
+     * and ends tangent to the line between the specified points ⟨x1, y1⟩ and ⟨x2, y2⟩. If the first tangent point is not equal to the current point,
+     * a straight line is drawn between the current point and the first tangent point. Equivalent to context.arcTo and uses SVG’s elliptical arc curve commands.
+     *
+     * @param x1 x-Coordinate of the first tangent point
+     * @param y1 y-Coordinate of the first tangent point
+     * @param x2 x-Coordinate of the second tangent point
+     * @param y2 y-Coordinate of the second tangent point
+     * @param r  Radius of the arc segment
+     */
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+
+    /**
+     * Draws a circular arc segment with the specified center ⟨x, y⟩, radius, startAngle and endAngle. If anticlockwise is true,
+     * the arc is drawn in the anticlockwise direction; otherwise, it is drawn in the clockwise direction.
+     * If the current point is not equal to the starting point of the arc, a straight line is drawn from the current point to the start of the arc.
+     * Equivalent to context.arc and uses SVG’s elliptical arc curve commands.
+     *
+     * @param x x-Coordinate of the center point of the arc segment
+     * @param y y-Coordinate of the center point of the arc segment
+     * @param startAngle Start angle of arc segment
+     * @param endAngle End angle of arc segment
+     * @param anticlockwise Flag indicating directionality (true = anti-clockwise, false = clockwise)
+     */
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
+
+    /**
+     * Creates a new subpath containing just the four points ⟨x, y⟩, ⟨x + w, y⟩, ⟨x + w, y + h⟩, ⟨x, y + h⟩,
+     * with those four points connected by straight lines, and then marks the subpath as closed. Equivalent to context.rect and uses SVG’s “lineto” commands.
+     *
+     * @param x x-Coordinate of starting point for drawing the rectangle
+     * @param y y-Coordinate of starting point for drawing the rectangle
+     * @param w Width of rectangle
+     * @param h Height of rectangle
+     */
+    rect(x: number, y: number, w: number, h: number): void;
+
+    /**
+     * Returns the string representation of this path according to SVG’s path data specification.
+     */
+    toString(): string;
+}
+
+/**
+ * Construct a D3 Path serializer
+ */
+export function path(): Path;

node_modules/@types/d3-path/package.json

@@ -0,0 +1,65 @@
+{
+  "_from": "@types/d3-path@*",
+  "_id": "@types/d3-path@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-tXcR/9OtDdeCIsyl6eTNHC3XOAOdyc6ceF3QGBXOd9jTcK+ex/ecr00p9L9362e/op3UEPpxrToi1FHrtTSj7Q==",
+  "_location": "/@types/d3-path",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-path@*",
+    "name": "@types/d3-path",
+    "escapedName": "@types%2fd3-path",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-2.0.0.tgz",
+  "_shasum": "dcc7f5ecadf52b0c0c39f6c1def3733195e4b199",
+  "_spec": "@types/d3-path@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-path module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-path",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-path"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "34d85285ab3085a42eac4c2722a5ecea0e4f64894c7914f42b6c6f534cfe60e8",
+  "version": "2.0.0"
+}

node_modules/@types/d3-polygon/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-polygon/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-polygon`
+
+# Summary
+This package contains type definitions for D3JS d3-polygon module (https://github.com/d3/d3-polygon/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-polygon.
+
+### Additional Details
+ * Last updated: Tue, 29 Sep 2020 22:54:47 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-polygon/index.d.ts

@@ -0,0 +1,49 @@
+// Type definitions for D3JS d3-polygon module 2.0
+// Project: https://github.com/d3/d3-polygon/, https://d3js.org/d3-polygon
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Last module patch version validated against: 2.0.0
+
+/**
+ * Returns the signed area of the specified polygon. If the vertices of the polygon are in counterclockwise order
+ * (assuming a coordinate system where the origin <0,0> is in the top-left corner), the returned area is positive;
+ * otherwise it is negative, or zero.
+ *
+ * @param polygon Array of coordinates <x0, y0>, <x1, y1> and so on.
+ */
+export function polygonArea(polygon: Array<[number, number]>): number;
+
+/**
+ * Returns the centroid of the specified polygon.
+ *
+ * @param polygon Array of coordinates <x0, y0>, <x1, y1> and so on.
+ */
+export function polygonCentroid(polygon: Array<[number, number]>): [number, number];
+
+/**
+ * Returns the convex hull of the specified points using Andrew’s monotone chain algorithm.
+ * The returned hull is represented as an array containing a subset of the input points arranged in
+ * counterclockwise order. Returns null if points has fewer than three elements.
+ *
+ * @param points Array of coordinates <x0, y0>, <x1, y1> and so on.
+ */
+export function polygonHull(points: Array<[number, number]>): Array<[number, number]> | null;
+
+/**
+ * Returns true if and only if the specified point is inside the specified polygon.
+ *
+ * @param polygon Array of coordinates <x0, y0>, <x1, y1> and so on.
+ * @param point Coordinates of point <x, y>.
+ */
+export function polygonContains(polygon: Array<[number, number]>, point: [number, number]): boolean;
+
+/**
+ * Returns the length of the perimeter of the specified polygon.
+ *
+ * @param polygon Array of coordinates <x0, y0>, <x1, y1> and so on.
+ */
+export function polygonLength(polygon: Array<[number, number]>): number;

node_modules/@types/d3-polygon/package.json

@@ -0,0 +1,65 @@
+{
+  "_from": "@types/d3-polygon@*",
+  "_id": "@types/d3-polygon@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-fISnMd8ePED1G4aa4V974Jmt+ajHSgPoxMa2D0ULxMybpx0Vw4WEzhQEaMIrL3hM8HVRcKTx669I+dTy/4PhAw==",
+  "_location": "/@types/d3-polygon",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-polygon@*",
+    "name": "@types/d3-polygon",
+    "escapedName": "@types%2fd3-polygon",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-polygon/-/d3-polygon-2.0.0.tgz",
+  "_shasum": "8b1df0a1358016e62c4961b01e8dc8e5ab4c64e5",
+  "_spec": "@types/d3-polygon@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-polygon module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-polygon",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-polygon"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "4a02cb931240583f233d3b5bad187adc21689f18632ec9068b4be99be7070499",
+  "version": "2.0.0"
+}

node_modules/@types/d3-quadtree/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-quadtree/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-quadtree`
+
+# Summary
+This package contains type definitions for D3JS d3-quadtree module (https://github.com/d3/d3-quadtree/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-quadtree.
+
+### Additional Details
+ * Last updated: Wed, 30 Sep 2020 21:08:22 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-quadtree/index.d.ts

@@ -0,0 +1,209 @@
+// Type definitions for D3JS d3-quadtree module 2.0
+// Project: https://github.com/d3/d3-quadtree/, https://d3js.org/d3-quadtree
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+// Last module patch version validated against: 2.0.0
+
+/**
+ * Leaf node of the quadtree.
+ */
+export interface QuadtreeLeaf<T> {
+    /**
+     * The data associated with this point, as passed to quadtree.add.
+     */
+    data: T;
+
+    /**
+     * The next datum in this leaf, if any.
+     */
+    next?: QuadtreeLeaf<T>;
+
+    /**
+     * The length property may be used to distinguish leaf nodes from internal nodes: it is undefined for leaf nodes, and 4 for internal nodes.
+     */
+    length?: undefined;
+}
+
+/**
+ * Internal nodes of the quadtree are represented as four-element arrays in left-to-right, top-to-bottom order:
+ *
+ * 0 - the top-left quadrant, if any.
+ * 1 - the top-right quadrant, if any.
+ * 2 - the bottom-left quadrant, if any.
+ * 3 - the bottom-right quadrant, if any.
+ *
+ * A child quadrant may be undefined if it is empty.
+ */
+export interface QuadtreeInternalNode<T> extends Array<QuadtreeInternalNode<T> | QuadtreeLeaf<T> | undefined> {
+    /**
+     * The length property may be used to distinguish leaf nodes from internal nodes: it is undefined for leaf nodes, and 4 for internal nodes.
+     */
+    length: 4;
+}
+
+export interface Quadtree<T> {
+    /**
+     * Returns the current x-accessor, which defaults to: `x(d) => d[0]`.
+     */
+    x(): (d: T) => number;
+    /**
+     * Sets the current x-coordinate accessor and returns the quadtree.
+     * The x-accessors must be consistent, returning the same value given the same input.
+     *
+     * @param x The x-coordinate accessor.
+     */
+    x(x: (d: T) => number): this;
+
+    /**
+     * Returns the current y-accessor, which defaults to: `y(d) => d[1]`.
+     */
+    y(): (d: T) => number;
+    /**
+     * Sets the current y-coordinate accessor and returns the quadtree.
+     * The y-accessors must be consistent, returning the same value given the same input.
+     *
+     * @param y The y-coordinate accessor.
+     */
+    y(y: (d: T) => number): this;
+
+    /**
+     * Returns the quadtree's current extent `[[x0, y0], [x1, y1]]`,
+     * where `x0` and `y0` are the inclusive lower bounds and `x1` and `y1` are the inclusive upper bounds,
+     * or `undefined` if the quadtree has no extent.
+     */
+    extent(): [[number, number], [number, number]] | undefined;
+    /**
+     * Expands the quadtree to cover the specified points `[[x0, y0], [x1, y1]]` and returns the quadtree.
+     * The extent may also be expanded by calling `quadtree.cover` or `quadtree.add`.
+     *
+     * @param extend The specified points to cover.
+     */
+    extent(extend: [[number, number], [number, number]]): this;
+
+    /**
+     * Expands the quadtree to cover the specified point ⟨x,y⟩, and returns the quadtree.
+     * * If the quadtree’s extent already covers the specified point, this method does nothing.
+     * * If the quadtree has an extent, the extent is repeatedly doubled to cover the specified point, wrapping the root node as necessary.
+     * * If the quadtree is empty, the extent is initialized to the extent `[[⌊x⌋, ⌊y⌋], [⌈x⌉, ⌈y⌉]]`.
+     * Rounding is necessary such that if the extent is later doubled, the boundaries of existing quadrants do not change due to floating point error.
+     *
+     * @param x The x-coordinate for the specified point to cover.
+     * @param y The y-coordinate for the specified point to cover.
+     */
+    cover(x: number, y: number): this;
+
+    /**
+     * Adds the specified datum to the quadtree, deriving its coordinates ⟨x,y⟩ using the current x- and y-accessors, and returns the quadtree.
+     * If the new point is outside the current extent of the quadtree, the quadtree is automatically expanded to cover the new point.
+     *
+     * @param datum The specified datum to add.
+     */
+    add(datum: T): this;
+
+    /**
+     * Adds the specified array of data to the quadtree, deriving each element’s coordinates ⟨x,y⟩ using the current x- and y-accessors, and return this quadtree.
+     * This is approximately equivalent to calling quadtree.add repeatedly.
+     * However, this method results in a more compact quadtree because the extent of the data is computed first before adding the data.
+     *
+     * @param data The specified array of data to add.
+     */
+    addAll(data: T[]): this;
+
+    /**
+     * Removes the specified datum to the quadtree, deriving its coordinates ⟨x,y⟩ using the current x- and y-accessors, and returns the quadtree.
+     * If the specified datum does not exist in this quadtree, this method does nothing.
+     *
+     * @param datum The specified datum to remove.
+     */
+    remove(datum: T): this;
+
+    /**
+     * Removes the specified data to the quadtree, deriving their coordinates ⟨x,y⟩ using the current x- and y-accessors, and returns the quadtree.
+     * If a specified datum does not exist in this quadtree, it is ignored.
+     *
+     * @param data The specified array of data to remove.
+     */
+    removeAll(data: T[]): this;
+
+    /**
+     * Returns a copy of the quadtree. All nodes in the returned quadtree are identical copies of the corresponding node in the quadtree;
+     * however, any data in the quadtree is shared by reference and not copied.
+     */
+    copy(): Quadtree<T>;
+
+    /**
+     * Returns the root node of the quadtree.
+     */
+    root(): QuadtreeInternalNode<T> | QuadtreeLeaf<T>;
+
+    /**
+     * Returns an array of all data in the quadtree.
+     */
+    data(): T[];
+
+    /**
+     * Returns the total number of data in the quadtree.
+     */
+    size(): number;
+
+    /**
+     * Returns the datum closest to the position ⟨x,y⟩ with the given search radius. If radius is not specified, it defaults to infinity.
+     * If there is no datum within the search area, returns undefined.
+     *
+     * @param x The x-coordinate for the search position.
+     * @param y The y-coordinate for the search position.
+     * @param radius The optional search radius.
+     */
+    find(x: number, y: number, radius?: number): T | undefined;
+
+    /**
+     * Visits each node in the quadtree in pre-order traversal, invoking the specified callback with arguments `node`, `x0`, `y0`, `x1`, `y1` for each node,
+     * where `node` is the node being visited, ⟨x0, y0⟩ are the lower bounds of the node, and ⟨x1, y1⟩ are the upper bounds, and returns the quadtree.
+     *
+     * If the callback returns true for a given node, then the children of that node are not visited; otherwise, all child nodes are visited.
+     * This can be used to quickly visit only parts of the tree.
+     * Note, however, that child quadrants are always visited in sibling order: top-left, top-right, bottom-left, bottom-right.
+     * In cases such as search, visiting siblings in a specific order may be faster.
+     *
+     * @param callback The callback invoked for each node.
+     */
+    visit(callback: (node: QuadtreeInternalNode<T> | QuadtreeLeaf<T>, x0: number, y0: number, x1: number, y1: number) => void | boolean): this;
+
+    /**
+     * Visits each node in the quadtree in post-order traversal, invoking the specified callback with arguments `node`, `x0`, `y0`, `x1`, `y1` for each node,
+     * where `node` is the node being visited, ⟨x0, y0⟩ are the lower bounds of the node, and ⟨x1, y1⟩ are the upper bounds, and returns the quadtree.
+     *
+     * @param callback The callback invoked for each node.
+     */
+    visitAfter(callback: (node: QuadtreeInternalNode<T> | QuadtreeLeaf<T>, x0: number, y0: number, x1: number, y1: number) => void): this;
+}
+
+/**
+ * Creates a new, empty quadtree with an empty extent and the default x- and y-accessors.
+ *
+ * The generic refers to the data type. If omitted, the default setting assumes that,
+ * the data used with the quadtree are two-element arrays.
+ * The first element corresponds to the x-dimension, the second to the y-dimension.
+ * When using another type, The x- and y-accessors must be specified.
+ */
+export function quadtree<T = [number, number]>(): Quadtree<T>;
+/**
+ * Creates a new quadtree with the specified array of data.
+ * If `x` and `y` are also specified, sets the x- and y- accessors to the specified functions before adding the specified array of data to the quadtree, otherwise use the default x- and y-accessors.
+ *
+ * The generic refers to the data type. If omitted, the default setting assumes that,
+ * the data used with the quadtree are two-element arrays.
+ * The first element corresponds to the x-dimension, the second to the y-dimension.
+ * When using another type, The x- and y-accessors must be specified.
+ *
+ * @param data The specified array of data to add.
+ * @param x The x-coordinate accessor.
+ * @param y The y-coordinate accessor.
+ */
+export function quadtree<T = [number, number]>(data: T[], x?: (d: T) => number, y?: (d: T) => number): Quadtree<T>;

node_modules/@types/d3-quadtree/package.json

@@ -0,0 +1,69 @@
+{
+  "_from": "@types/d3-quadtree@*",
+  "_id": "@types/d3-quadtree@2.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-YZuJuGBnijD0H+98xMJD4oZXgv/umPXy5deu3IimYTPGH3Kr8Th6iQUff0/6S80oNBD7KtOuIHwHUCymUiRoeQ==",
+  "_location": "/@types/d3-quadtree",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-quadtree@*",
+    "name": "@types/d3-quadtree",
+    "escapedName": "@types%2fd3-quadtree",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-quadtree/-/d3-quadtree-2.0.0.tgz",
+  "_shasum": "b17e953dc061e083966075bba0d3a9a259812150",
+  "_spec": "@types/d3-quadtree@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "denisname",
+      "url": "https://github.com/denisname"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-quadtree module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-quadtree",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-quadtree"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "2f53ca6658f60fffcccdd5b3298c4dfd7dfc1a2a4c3c100aa6d0a47a58fa2cf2",
+  "version": "2.0.0"
+}

node_modules/@types/d3-random/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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/@types/d3-random/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/d3-random`
+
+# Summary
+This package contains type definitions for D3JS d3-random module (https://github.com/d3/d3-random/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-random.
+
+### Additional Details
+ * Last updated: Thu, 01 Oct 2020 22:50:46 GMT
+ * Dependencies: none
+ * Global values: none
+
+# Credits
+These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), and [Nathan Bierema](https://github.com/Methuselah96).

node_modules/@types/d3-random/index.d.ts

@@ -0,0 +1,319 @@
+// Type definitions for D3JS d3-random module 2.2
+// Project: https://github.com/d3/d3-random/, https://d3js.org/d3-random
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 Nathan Bierema <https://github.com/Methuselah96>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Last module patch version validated against: 2.2.2
+
+export interface RandomNumberGenerationSource {
+    /**
+     * Returns the same type of function for generating random numbers but where the given random number
+     * generator source is used as the source of randomness instead of Math.random.
+     * This is useful when a seeded random number generator is preferable to Math.random.
+     *
+     * @param source Source (pseudo-)random number generator implementing the Math.random interface.
+     * The given random number generator must implement the same interface as Math.random and
+     * only return values in the range [0, 1).
+     */
+    source(source: () => number): this;
+}
+
+/**
+ * A configurable random number generator for the uniform distribution.
+ */
+export interface RandomUniform extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with a uniform distribution.
+     * The minimum allowed value of a returned number is min (inclusive), and the maximum is max (exclusive).
+     * Min defaults to 0; if max is not specified, it defaults to 1.
+     *
+     * @param max The maximum allowed value of a returned number, defaults to 1.
+     */
+    (max?: number): () => number;
+    /**
+     * Returns a function for generating random numbers with a uniform distribution.
+     * The minimum allowed value of a returned number is min (inclusive), and the maximum is max (exclusive).
+     *
+     * @param min The minimum allowed value of a returned number.
+     * @param max The maximum allowed value of a returned number.
+     */
+    // tslint:disable-next-line:unified-signatures
+    (min: number, max: number): () => number;
+}
+
+export const randomUniform: RandomUniform;
+
+/**
+ * A configurable random integer generator for the uniform distribution.
+ */
+export interface RandomInt extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random integers with a uniform distribution.
+     * The minimum allowed value of a returned number is ⌊min⌋ (inclusive), and the maximum is ⌊max - 1⌋ (inclusive)
+     * Min defaults to 0.
+     *
+     * @param max The maximum allowed value of a returned number.
+     */
+    (max: number): () => number;
+    /**
+     * Returns a function for generating random integers with a uniform distribution.
+     * The minimum allowed value of a returned number is ⌊min⌋ (inclusive), and the maximum is ⌊max - 1⌋ (inclusive)
+     *
+     * @param min The minimum allowed value of a returned number.
+     * @param max The maximum allowed value of a returned number.
+     */
+    // tslint:disable-next-line:unified-signatures
+    (min: number, max: number): () => number;
+}
+
+export const randomInt: RandomInt;
+
+/**
+ * A configurable random number generator for the normal (Gaussian) distribution.
+ */
+export interface RandomNormal extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with a normal (Gaussian) distribution.
+     * The expected value of the generated numbers is mu, with the given standard deviation sigma.
+     * If mu is not specified, it defaults to 0; if sigma is not specified, it defaults to 1.
+     *
+     * @param mu Expected value, defaults to 0.
+     * @param sigma Standard deviation, defaults to 1.
+     */
+    (mu?: number, sigma?: number): () => number;
+}
+
+export const randomNormal: RandomNormal;
+
+/**
+ * A configurable random number generator for the log-normal distribution.
+ */
+export interface RandomLogNormal extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with a log-normal distribution. The expected value of the random variable’s natural logarithm is mu,
+     * with the given standard deviation sigma. If mu is not specified, it defaults to 0; if sigma is not specified, it defaults to 1.
+     *
+     * @param mu Expected value, defaults to 0.
+     * @param sigma Standard deviation, defaults to 1.
+     */
+    (mu?: number, sigma?: number): () => number;
+}
+
+export const randomLogNormal: RandomLogNormal;
+
+/**
+ * A configurable random number generator for the Bates distribution.
+ */
+export interface RandomBates extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with a Bates distribution with n independent variables.
+     * The case of fractional n is handled as with d3.randomIrwinHall, and d3.randomBates(0) is equivalent to d3.randomUniform().
+     *
+     * @param n Number of independent random variables to use.
+     */
+    (n: number): () => number;
+}
+
+export const randomBates: RandomBates;
+
+/**
+ * A configurable random number generator for the Irwin–Hall distribution.
+ */
+export interface RandomIrwinHall extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with an Irwin–Hall distribution with n independent variables.
+     * If the fractional part of n is non-zero, this is treated as adding d3.randomUniform() times that fractional part to the integral part.
+     *
+     * @param n Number of independent random variables to use.
+     */
+    (n: number): () => number;
+}
+
+export const randomIrwinHall: RandomIrwinHall;
+
+/**
+ * A configurable random number generator for the exponential distribution.
+ */
+export interface RandomExponential extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with an exponential distribution with the rate lambda;
+     * equivalent to time between events in a Poisson process with a mean of 1 / lambda.
+     *
+     * @param lambda Expected time between events.
+     */
+    (lambda: number): () => number;
+}
+
+export const randomExponential: RandomExponential;
+
+/**
+ * A configurable random number generator with an Pareto distribution.
+ */
+export interface RandomPareto extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with a Pareto distribution with the shape alpha.
+     * The value alpha must be a positive value.
+     *
+     * @param alpha alpha
+     */
+    (alpha: number): () => number;
+}
+
+export const randomPareto: RandomPareto;
+
+/**
+ * A configurable random 0 or 1 generator according to a Bernoulli distribution.
+ */
+export interface RandomBernoulli extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating either 1 or 0 according to a Bernoulli distribution with 1 being returned with success probability p and 0 with failure probability q = 1 - p.
+     * The value p is in the range [0, 1].
+     *
+     * @param p p
+     */
+    (p: number): () => number;
+}
+
+export const randomBernoulli: RandomBernoulli;
+
+/**
+ * A configurable random number generator with a geometric distribution.
+ */
+export interface RandomGeometric extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating numbers with a geometric distribution with success probability p.
+     * The value p is in the range [0, 1].
+     *
+     * @param p Success probability
+     */
+    (p: number): () => number;
+}
+
+export const randomGeometric: RandomGeometric;
+
+/**
+ * A configurable random number generator with a binomial distribution.
+ */
+export interface RandomBinomial extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating numbers with a geometric distribution with success probability p.
+     * The value p is in the range (0, 1].
+     *
+     * @param p Success probability
+     */
+    (p: number): () => number;
+}
+
+export const randomBinomial: RandomBinomial;
+
+/**
+ * A configurable random number generator with a gamma distribution.
+ */
+export interface RandomGamma extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with a gamma distribution with k the shape parameter and theta the scale parameter.
+     * The value k must be a positive value; if theta is not specified, it defaults to 1.
+     *
+     * @param k Shape parameter
+     * @param theta Scale paramter
+     */
+    (k: number, theta?: number): () => number;
+}
+
+export const randomGamma: RandomGamma;
+
+/**
+ * A configurable random number generator with a beta distribution.
+ */
+export interface RandomBeta extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with a beta distribution with alpha and beta shape parameters, which must both be positive.
+     *
+     * @param alpha Shape parameter
+     * @param beta Shape paramter
+     */
+    (alpha: number, beta: number): () => number;
+}
+
+export const randomBeta: RandomBeta;
+
+/**
+ * A configurable random number generator with one of the generalized extreme value distributions.
+ */
+export interface RandomWeibull extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with one of the generalized extreme value distributions, depending on k:
+     * If k is positive, the Weibull distribution with shape parameter k
+     * If k is zero, the Gumbel distribution
+     * If k is negative, the Fréchet distribution with shape parameter −k
+     * In all three cases, a is the location parameter and b is the scale parameter.
+     * If a is not specified, it defaults to 0; if b is not specified, it defaults to 1.
+     *
+     * @param k Shape parameter
+     * @param a Location parameter
+     * @param b Scale parameter
+     */
+    (k: number, a?: number, b?: number): () => number;
+}
+
+export const randomWeibull: RandomWeibull;
+
+/**
+ * A configurable random number generator with a Cauchy distribution.
+ */
+export interface RandomCauchy extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with a Cauchy distribution.
+     * a and b have the same meanings and default values as in d3.randomWeibull.
+     *
+     * @param a Location parameter
+     * @param b Scale parameter
+     */
+    (a?: number, b?: number): () => number;
+}
+
+export const randomCauchy: RandomCauchy;
+
+/**
+ * A configurable random number generator with a logistic distribution.
+ */
+export interface RandomLogistic extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with a logistic distribution.
+     * a and b have the same meanings and default values as in d3.randomWeibull.
+     *
+     * @param a Location parameter
+     * @param b Scale parameter
+     */
+    (a?: number, b?: number): () => number;
+}
+
+export const randomLogistic: RandomLogistic;
+
+/**
+ * A configurable random number generator with a Poisson distribution.
+ */
+export interface RandomPoisson extends RandomNumberGenerationSource {
+    /**
+     * Returns a function for generating random numbers with a Poisson distribution with mean lambda.
+     *
+     * @param lambda Mean
+     */
+    (lambda: number): () => number;
+}
+
+export const randomPoisson: RandomPoisson;
+
+/**
+ * Returns a linear congruential generator; this function can be called repeatedly to obtain pseudorandom values well-distributed on the interval [0,1) and with a long period (up to 1 billion numbers), similar to Math.random.
+ * A seed can be specified as a real number in the interval [0,1) or as any integer.
+ * In the latter case, only the lower 32 bits are considered.
+ * Two generators instanced with the same seed generate the same sequence, allowing to create reproducible pseudo-random experiments.
+ * If the seed is not specified, one is chosen using Math.random.
+ *
+ * @param seed A seed that is either a real number in the interval [0,1) or any integer.
+ */
+export function randomLcg(seed?: number): () => number;

node_modules/@types/d3-random/package.json

@@ -0,0 +1,65 @@
+{
+  "_from": "@types/d3-random@*",
+  "_id": "@types/d3-random@2.2.0",
+  "_inBundle": false,
+  "_integrity": "sha512-Hjfj9m68NmYZzushzEG7etPvKH/nj9b9s9+qtkNG3/dbRBjQZQg1XS6nRuHJcCASTjxXlyXZnKu2gDxyQIIu9A==",
+  "_location": "/@types/d3-random",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "@types/d3-random@*",
+    "name": "@types/d3-random",
+    "escapedName": "@types%2fd3-random",
+    "scope": "@types",
+    "rawSpec": "*",
+    "saveSpec": null,
+    "fetchSpec": "*"
+  },
+  "_requiredBy": [
+    "/@types/d3"
+  ],
+  "_resolved": "https://registry.npmjs.org/@types/d3-random/-/d3-random-2.2.0.tgz",
+  "_shasum": "fc44cabb966917459490b758f31f5359adeabe5b",
+  "_spec": "@types/d3-random@*",
+  "_where": "/Users/jusrhee/Documents/porter/node_modules/@types/d3",
+  "bugs": {
+    "url": "https://github.com/DefinitelyTyped/DefinitelyTyped/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Tom Wanzek",
+      "url": "https://github.com/tomwanzek"
+    },
+    {
+      "name": "Alex Ford",
+      "url": "https://github.com/gustavderdrache"
+    },
+    {
+      "name": "Boris Yankov",
+      "url": "https://github.com/borisyankov"
+    },
+    {
+      "name": "Nathan Bierema",
+      "url": "https://github.com/Methuselah96"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "TypeScript definitions for D3JS d3-random module",
+  "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped#readme",
+  "license": "MIT",
+  "main": "",
+  "name": "@types/d3-random",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+    "directory": "types/d3-random"
+  },
+  "scripts": {},
+  "typeScriptVersion": "3.2",
+  "types": "index.d.ts",
+  "typesPublisherContentHash": "af0d8e42b24af78b77b57c456320dcc2cd68d706314381dedecad1cdb2067f44",
+  "version": "2.2.0"
+}

node_modules/@types/d3-scale-chromatic/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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