@heycys/gallery 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,55 @@
+{
+    "name": "@types/d3-color",
+    "version": "3.1.3",
+    "description": "TypeScript definitions for d3-color",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-color",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Tom Wanzek",
+            "githubUsername": "tomwanzek",
+            "url": "https://github.com/tomwanzek"
+        },
+        {
+            "name": "Alex Ford",
+            "githubUsername": "gustavderdrache",
+            "url": "https://github.com/gustavderdrache"
+        },
+        {
+            "name": "Boris Yankov",
+            "githubUsername": "borisyankov",
+            "url": "https://github.com/borisyankov"
+        },
+        {
+            "name": "denisname",
+            "githubUsername": "denisname",
+            "url": "https://github.com/denisname"
+        },
+        {
+            "name": "Hugues Stefanski",
+            "githubUsername": "ledragon",
+            "url": "https://github.com/ledragon"
+        },
+        {
+            "name": "Nathan Bierema",
+            "githubUsername": "Methuselah96",
+            "url": "https://github.com/Methuselah96"
+        },
+        {
+            "name": "Fil",
+            "githubUsername": "Fil",
+            "url": "https://github.com/Fil"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/d3-color"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "89cf9357324cddaa31cfb539b1c33d118648ed55319f2a0d26f24b004975a947",
+    "typeScriptVersion": "4.5"
+}

package/vendor/types/@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

package/vendor/types/@types/d3-contour/index.d.ts

@@ -0,0 +1,222 @@
+// Last module patch version validated against: 3.0.1
+
+import { ThresholdCountGenerator, ThresholdNumberArrayGenerator } from "d3-array";
+import { MultiPolygon } from "geojson";
+
+/**
+ * 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 the specified function or 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.
+     * If a count is specified instead of an array of thresholds, then the input values’ extent will be uniformly divided into approximately count bins; see d3.ticks.
+     */
+    thresholds(
+        thresholds: number | number[] | 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 the specified function or array and returns this contour generator.
+     * 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.
+     * If a count is specified instead of an array of thresholds, then approximately count uniformly-spaced nicely-rounded thresholds will be generated; see d3.ticks.
+     */
+    thresholds(
+        thresholds: number | number[] | 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.
+ */
+// eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+export function contourDensity<Datum = [number, number]>(): ContourDensity<Datum>;

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

@@ -0,0 +1,38 @@
+{
+    "name": "@types/d3-contour",
+    "version": "3.0.6",
+    "description": "TypeScript definitions for d3-contour",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-contour",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Tom Wanzek",
+            "githubUsername": "tomwanzek",
+            "url": "https://github.com/tomwanzek"
+        },
+        {
+            "name": "Hugues Stefanski",
+            "githubUsername": "Ledragon",
+            "url": "https://github.com/Ledragon"
+        },
+        {
+            "name": "Nathan Bierema",
+            "githubUsername": "Methuselah96",
+            "url": "https://github.com/Methuselah96"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/d3-contour"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/d3-array": "*",
+        "@types/geojson": "*"
+    },
+    "typesPublisherContentHash": "a2a836bf53d1aa8ce0ab664fbae003884449208333886bc8a93937935bc3df4e",
+    "typeScriptVersion": "4.5"
+}

package/vendor/types/@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

package/vendor/types/@types/d3-delaunay/index.d.ts

@@ -0,0 +1,316 @@
+/**
+ * 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, 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, number, number, 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;
+}