@math.gl/polygon 3.5.6 → 3.6.0-alpha.1

package/dist/polygon-utils.js

@@ -0,0 +1,140 @@
+/* eslint-disable max-statements, max-depth, complexity, no-unused-expressions */
+import { equals } from '@math.gl/core';
+export var WINDING;
+(function (WINDING) {
+    WINDING[WINDING["CLOCKWISE"] = 1] = "CLOCKWISE";
+    WINDING[WINDING["COUNTER_CLOCKWISE"] = -1] = "COUNTER_CLOCKWISE";
+})(WINDING || (WINDING = {}));
+/**
+ * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
+ * Note: points are modified in-place.
+ * @param points An array that represents points of the polygon.
+ * @param direction Requested winding direction. 1 is for clockwise, -1 for counterclockwise winding direction.
+ * @param options Parameters of the polygon.
+ * @return Returns true if the winding direction was changed.
+ */
+export function modifyPolygonWindingDirection(points, direction, options = {}) {
+    const windingDirection = getPolygonWindingDirection(points, options);
+    if (windingDirection !== direction) {
+        reversePolygon(points, options);
+        return true;
+    }
+    return false;
+}
+/**
+ * Returns winding direction of the polygon.
+ * @param points An array that represents points of the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Winding direction of the polygon.
+ */
+export function getPolygonWindingDirection(points, options = {}) {
+    return Math.sign(getPolygonSignedArea(points, options));
+}
+/**
+ * Returns signed area of the polygon.
+ * @param points An array that represents points of the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Signed area of the polygon.
+ * https://en.wikipedia.org/wiki/Shoelace_formula
+ */
+export function getPolygonSignedArea(points, options = {}) {
+    const { start = 0, end = points.length } = options;
+    const dim = options.size || 2;
+    let area = 0;
+    for (let i = start, j = end - dim; i < end; i += dim) {
+        area += (points[i] - points[j]) * (points[i + 1] + points[j + 1]);
+        j = i;
+    }
+    return area / 2;
+}
+/**
+ * Calls the visitor callback for each segment in the polygon.
+ * @param points An array that represents points of the polygon
+ * @param visitor A callback to call for each segment.
+ * @param options Parameters of the polygon.
+ */
+export function forEachSegmentInPolygon(points, visitor, options = {}) {
+    const { start = 0, end = points.length, size = 2, isClosed } = options;
+    const numPoints = (end - start) / size;
+    for (let i = 0; i < numPoints - 1; ++i) {
+        visitor(points[start + i * size], points[start + i * size + 1], points[start + (i + 1) * size], points[start + (i + 1) * size + 1], i, i + 1);
+    }
+    const endPointIndex = start + (numPoints - 1) * size;
+    const isClosedEx = isClosed ||
+        (equals(points[start], points[endPointIndex]) &&
+            equals(points[start + 1], points[endPointIndex + 1]));
+    if (!isClosedEx) {
+        visitor(points[endPointIndex], points[endPointIndex + 1], points[start], points[start + 1], numPoints - 1, 0);
+    }
+}
+function reversePolygon(points, options) {
+    const { start = 0, end = points.length, size = 2 } = options;
+    const numPoints = (end - start) / size;
+    const numSwaps = Math.floor(numPoints / 2);
+    for (let i = 0; i < numSwaps; ++i) {
+        const b1 = start + i * size;
+        const b2 = start + (numPoints - 1 - i) * size;
+        for (let j = 0; j < size; ++j) {
+            const tmp = points[b1 + j];
+            points[b1 + j] = points[b2 + j];
+            points[b2 + j] = tmp;
+        }
+    }
+}
+/**
+ * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
+ * Note: points are modified in-place.
+ * @param points Array of points that represent the polygon.
+ * @param direction Requested winding direction. 1 is for clockwise, -1 for counterclockwise winding direction.
+ * @param options Parameters of the polygon.
+ * @return Returns true if the winding direction was changed.
+ */
+export function modifyPolygonWindingDirectionPoints(points, direction, options = {}) {
+    const currentDirection = getPolygonWindingDirectionPoints(points, options);
+    if (currentDirection !== direction) {
+        points.reverse();
+        return true;
+    }
+    return false;
+}
+/**
+ * Returns winding direction of the polygon.
+ * @param points Array of points that represent the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Winding direction of the polygon.
+ */
+export function getPolygonWindingDirectionPoints(points, options = {}) {
+    return Math.sign(getPolygonSignedAreaPoints(points, options));
+}
+/**
+ * Returns signed area of the polygon.
+ * @param points Array of points that represent the polygon.
+ * @param options Parameters of the polygon.
+ * @returns Signed area of the polygon.
+ */
+export function getPolygonSignedAreaPoints(points, options = {}) {
+    // https://en.wikipedia.org/wiki/Shoelace_formula
+    const { start = 0, end = points.length } = options;
+    let area = 0;
+    for (let i = start, j = end - 1; i < end; ++i) {
+        area += (points[i][0] - points[j][0]) * (points[i][1] + points[j][1]);
+        j = i;
+    }
+    return area / 2;
+}
+/**
+ * Calls visitor callback for each segment in the polygon.
+ * @param points Array of points that represent the polygon.
+ * @param visitor A callback to call for each segment.
+ * @param options Parameters of the polygon.
+ */
+export function forEachSegmentInPolygonPoints(points, visitor, options = {}) {
+    const { start = 0, end = points.length, isClosed } = options;
+    for (let i = start; i < end - 1; ++i) {
+        visitor(points[i], points[i + 1], i, i + 1);
+    }
+    const isClosedEx = isClosed || equals(points[end - 1], points[0]);
+    if (!isClosedEx) {
+        visitor(points[end - 1], points[0], end - 1, 0);
+    }
+}

package/dist/polygon.d.ts

@@ -0,0 +1,40 @@
+import type { SegmentVisitorPoints } from './polygon-utils';
+export declare type PolygonOptions = {
+    start?: number;
+    end?: number;
+    size?: number;
+    isClosed?: boolean;
+};
+export default class Polygon {
+    points: any;
+    isFlatArray: boolean;
+    options: PolygonOptions;
+    constructor(points: any, options?: PolygonOptions);
+    /**
+     * Returns signed area of the polygon.
+     * @returns Signed area of the polygon.
+     */
+    getSignedArea(): number;
+    /**
+     * Returns absolute area of the polygon.
+     * @returns Absolute area of the polygon.
+     */
+    getArea(): number;
+    /**
+     * Returns winding direction of the polygon.
+     * @returns Winding direction of the polygon. 1 is for clockwise, -1 for counterclockwise winding direction.
+     */
+    getWindingDirection(): number;
+    /**
+     * Calls the visitor callback for each segment in the polygon.
+     * @param visitor A callback to call for each segment.
+     */
+    forEachSegment(visitor: SegmentVisitorPoints): void;
+    /**
+     * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
+     * @param direction Requested winding direction. 1 is for clockwise, -1 for counterclockwise winding direction.
+     * @return Returns true if the winding direction was changed.
+     */
+    modifyWindingDirection(direction: number): boolean;
+}
+//# sourceMappingURL=polygon.d.ts.map

package/dist/polygon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon.d.ts","sourceRoot":"","sources":["../src/polygon.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,iBAAiB,CAAC;AAW1D,oBAAY,cAAc,GAAG;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,OAAO;IAC1B,MAAM,MAAC;IACP,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,cAAc,CAAC;gBAEZ,MAAM,KAAA,EAAmB,OAAO,GAAE,cAAmB;IAcjE;;;OAGG;IACH,aAAa,IAAI,MAAM;IAMvB;;;OAGG;IACH,OAAO,IAAI,MAAM;IAIjB;;;OAGG;IACH,mBAAmB,IAAI,MAAM;IAI7B;;;OAGG;IACH,cAAc,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI;IAgBnD;;;;OAIG;IACH,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;CAMnD"}

package/dist/polygon.js

@@ -0,0 +1,67 @@
+/* eslint-disable no-undef, no-console */
+import { isArray } from '@math.gl/core';
+import { getPolygonSignedArea, forEachSegmentInPolygon, modifyPolygonWindingDirection, getPolygonSignedAreaPoints, forEachSegmentInPolygonPoints, modifyPolygonWindingDirectionPoints } from './polygon-utils';
+export default class Polygon {
+    constructor(points /* : number[] */, options = {}) {
+        this.points = points;
+        this.isFlatArray = !isArray(points[0]);
+        this.options = {
+            start: options.start || 0,
+            end: options.end || points.length,
+            size: options.size || 2,
+            isClosed: options.isClosed
+        };
+        Object.freeze(this);
+    }
+    /**
+     * Returns signed area of the polygon.
+     * @returns Signed area of the polygon.
+     */
+    getSignedArea() {
+        if (this.isFlatArray)
+            return getPolygonSignedArea(this.points, this.options);
+        return getPolygonSignedAreaPoints(this.points, this.options);
+    }
+    /**
+     * Returns absolute area of the polygon.
+     * @returns Absolute area of the polygon.
+     */
+    getArea() {
+        return Math.abs(this.getSignedArea());
+    }
+    /**
+     * Returns winding direction of the polygon.
+     * @returns Winding direction of the polygon. 1 is for clockwise, -1 for counterclockwise winding direction.
+     */
+    getWindingDirection() {
+        return Math.sign(this.getSignedArea());
+    }
+    /**
+     * Calls the visitor callback for each segment in the polygon.
+     * @param visitor A callback to call for each segment.
+     */
+    forEachSegment(visitor) {
+        if (this.isFlatArray) {
+            forEachSegmentInPolygon(this.points, 
+            // eslint-disable-next-line max-params
+            (x1, y1, x2, y2, i1, i2) => {
+                // TODO @igorDykhta original visitor uses arrays for each point, but with flat arrays performance degrades if we allocate points for each segment
+                visitor([x1, y1], [x2, y2], i1, i2);
+            }, this.options);
+        }
+        else {
+            forEachSegmentInPolygonPoints(this.points, visitor, this.options);
+        }
+    }
+    /**
+     * Checks winding direction of the polygon and reverses the polygon in case of opposite winding direction.
+     * @param direction Requested winding direction. 1 is for clockwise, -1 for counterclockwise winding direction.
+     * @return Returns true if the winding direction was changed.
+     */
+    modifyWindingDirection(direction) {
+        if (this.isFlatArray) {
+            return modifyPolygonWindingDirection(this.points, direction, this.options);
+        }
+        return modifyPolygonWindingDirectionPoints(this.points, direction, this.options);
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function push(target: any, source: any): boolean;
+export declare function copy(target: any, source: any): void;
+export declare function getPointAtIndex(positions: any, index: any, size: any, offset: any, out?: any[]): any[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,IAAI,CAAC,MAAM,KAAA,EAAE,MAAM,KAAA,WAsBlC;AAED,wBAAgB,IAAI,CAAC,MAAM,KAAA,EAAE,MAAM,KAAA,QAKlC;AAED,wBAAgB,eAAe,CAAC,SAAS,KAAA,EAAE,KAAK,KAAA,EAAE,IAAI,KAAA,EAAE,MAAM,KAAA,EAAE,GAAG,QAAK,SAMvE"}

package/dist/utils.js

@@ -0,0 +1,34 @@
+export function push(target, source) {
+    const size = source.length;
+    const startIndex = target.length;
+    // dedupe, if source is the same point as the last vertex
+    if (startIndex > 0) {
+        let isDuplicate = true;
+        for (let i = 0; i < size; i++) {
+            if (target[startIndex - size + i] !== source[i]) {
+                isDuplicate = false;
+                break;
+            }
+        }
+        if (isDuplicate) {
+            return false;
+        }
+    }
+    for (let i = 0; i < size; i++) {
+        target[startIndex + i] = source[i];
+    }
+    return true;
+}
+export function copy(target, source) {
+    const size = source.length;
+    for (let i = 0; i < size; i++) {
+        target[i] = source[i];
+    }
+}
+export function getPointAtIndex(positions, index, size, offset, out = []) {
+    const startI = offset + index * size;
+    for (let i = 0; i < size; i++) {
+        out[i] = positions[startI + i];
+    }
+    return out;
+}

package/package.json

@@ -5,7 +5,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.5.6",
+  "version": "3.6.0-alpha.1",
   "keywords": [
     "webgl",
     "javascript",
@@ -17,6 +17,7 @@
     "type": "git",
     "url": "https://github.com/uber-web/math.gl.git"
   },
+  "types": "dist/index.d.ts",
   "main": "dist/es5/index.js",
   "module": "dist/esm/index.js",
   "files": [
@@ -24,7 +25,7 @@
     "src"
   ],
   "dependencies": {
-    "@math.gl/core": "3.5.6"
+    "@math.gl/core": "3.6.0-alpha.1"
   },
-  "gitHead": "0e69c70ff2e6373fed84d303cbf8198a6972944f"
+  "gitHead": "45386981340895bf201c2ebb76257c9bbffd8ff6"
 }

package/src/{cut-by-grid.js → cut-by-grid.ts}

@@ -2,7 +2,23 @@
 import {bitCode, intersect} from './lineclip';
 import {getPointAtIndex, copy, push} from './utils';
 
-export function cutPolylineByGrid(positions, options = {}) {
+export type Polygon = {
+  positions: Array<number>;
+  holeIndices?: Array<number>;
+  vertexTypes?: Array<number>;
+};
+
+export function cutPolylineByGrid(
+  positions: Array<number>,
+  options?: {
+    size?: number;
+    broken?: boolean;
+    gridResolution?: number;
+    gridOffset?: [number, number];
+    startIndex?: number;
+    endIndex?: number;
+  }
+): Array<number> | Array<Array<number>> {
   const {
     size = 2,
     broken = false,
@@ -10,7 +26,7 @@ export function cutPolylineByGrid(positions, options = {}) {
     gridOffset = [0, 0],
     startIndex = 0,
     endIndex = positions.length
-  } = options;
+  } = options || {};
   const numPoints = (endIndex - startIndex) / size;
   let part = [];
   const result = [part];
@@ -64,12 +80,21 @@ function concatInPlace(arr1, arr2) {
   return arr1;
 }
 
-export function cutPolygonByGrid(positions, holeIndices, options = {}) {
+export function cutPolygonByGrid(
+  positions: Array<number>,
+  holeIndices: Array<number> | null = null,
+  options?: {
+    size?: number;
+    gridResolution?: number;
+    gridOffset?: [number, number];
+    edgeTypes?: boolean;
+  }
+): Array<Polygon> {
   if (!positions.length) {
     // input is empty
     return [];
   }
-  const {size = 2, gridResolution = 10, gridOffset = [0, 0], edgeTypes = false} = options;
+  const {size = 2, gridResolution = 10, gridOffset = [0, 0], edgeTypes = false} = options || {};
   const result = [];
   const queue = [
     {
@@ -88,6 +113,7 @@ export function cutPolygonByGrid(positions, holeIndices, options = {}) {
     // Get the bounding box of the outer polygon
     getBoundingBox(pos, size, holes[0] || pos.length, bbox);
     cell = getGridCell(bbox[0], gridResolution, gridOffset, cell);
+    // @ts-expect-error
     const code = bitCode(bbox[1], cell);
 
     if (code) {
@@ -120,9 +146,11 @@ export function cutPolygonByGrid(positions, holeIndices, options = {}) {
       // Polygon fits in a single cell, no more processing required
       const polygon = {positions: pos};
       if (edgeTypes) {
+        // @ts-expect-error
         polygon.edgeTypes = types;
       }
       if (holes.length) {
+        // @ts-expect-error
         polygon.holeIndices = holes;
       }
 

package/src/{cut-by-mercator-bounds.js → cut-by-mercator-bounds.ts}

@@ -1,12 +1,21 @@
 import {cutPolylineByGrid, cutPolygonByGrid} from './cut-by-grid';
 import {getPointAtIndex, push} from './utils';
+import type {Polygon} from './cut-by-grid';
 
 // https://en.wikipedia.org/wiki/Web_Mercator_projection
 const DEFAULT_MAX_LATITUDE = 85.051129;
 
-// https://user-images.githubusercontent.com/2059298/78465769-938b7a00-76ae-11ea-9b95-1f4c26425ab9.png
-export function cutPolylineByMercatorBounds(positions, options = {}) {
-  const {size = 2, startIndex = 0, endIndex = positions.length, normalize = true} = options;
+/** https://user-images.githubusercontent.com/2059298/78465769-938b7a00-76ae-11ea-9b95-1f4c26425ab9.png */
+export function cutPolylineByMercatorBounds(
+  positions: Array<number>,
+  options?: {
+    size?: number;
+    startIndex?: number;
+    endIndex?: number;
+    normalize?: boolean;
+  }
+): Array<number> {
+  const {size = 2, startIndex = 0, endIndex = positions.length, normalize = true} = options || {};
 
   // Remap longitudes so that each segment takes the shorter path
   const newPositions = positions.slice(startIndex, endIndex);
@@ -26,12 +35,22 @@ export function cutPolylineByMercatorBounds(positions, options = {}) {
       shiftLongitudesIntoRange(part, size);
     }
   }
+  // @ts-expect-error
   return parts;
 }
 
-// https://user-images.githubusercontent.com/2059298/78465770-94241080-76ae-11ea-809a-6a8534dac1d9.png
-export function cutPolygonByMercatorBounds(positions, holeIndices, options = {}) {
-  const {size = 2, normalize = true, edgeTypes = false} = options;
+/** https://user-images.githubusercontent.com/2059298/78465770-94241080-76ae-11ea-809a-6a8534dac1d9.png */
+export function cutPolygonByMercatorBounds(
+  positions: Array<number>,
+  holeIndices: Array<number> | null = null,
+  options?: {
+    size?: number;
+    normalize?: boolean;
+    maxLatitude?: number;
+    edgeTypes?: boolean;
+  }
+): Array<Polygon> {
+  const {size = 2, normalize = true, edgeTypes = false} = options || {};
   holeIndices = holeIndices || [];
   const newPositions = [];
   const newHoleIndices = [];
@@ -59,7 +78,7 @@ export function cutPolygonByMercatorBounds(positions, holeIndices, options = {})
     wrapLongitudesForShortestPath(newPositions, size, targetStartIndex, targetIndex);
 
     // Handle the case when the ring contains a pole
-    insertPoleVertices(newPositions, size, targetStartIndex, targetIndex, options.maxLatitude);
+    insertPoleVertices(newPositions, size, targetStartIndex, targetIndex, options?.maxLatitude);
 
     srcStartIndex = srcEndIndex;
     newHoleIndices[ringIndex] = targetIndex;

package/src/{earcut.js → earcut.ts}

@@ -26,12 +26,24 @@
 
 import {getPolygonSignedArea} from './polygon-utils';
 
-export function earcut(data, holeIndices, dim, areas) {
-  dim = dim || 2;
-
+/**
+ * Computes a triangulation of a polygon
+ * @param positions a flat array of the vertex positions that define the polygon.
+ * @param holeIndices an array of hole indices if any (e.g. [5, 8] for a 12-vertex input would mean one hole with vertices 5–7 and another with 8–11).
+ * @param dim the number of elements in each vertex. Size `2` will interpret `positions` as `[x0, y0, x1, y1, ...]` and size `3` will interpret `positions` as `[x0, y0, z0, x1, y1, z1, ...]`. Default `2`.
+ * @param areas areas of outer polygon and holes as computed by `getPolygonSignedArea()`. Can be optionally supplied to speed up triangulation
+ * @returns array of indices into the `positions` array that describes the triangulation of the polygon
+ * Adapted from https://github.com/mapbox/earcut
+ */
+export function earcut(
+  positions: number[],
+  holeIndices?: number[],
+  dim: number = 2,
+  areas?: number[]
+): number[] {
   const hasHoles = holeIndices && holeIndices.length;
-  const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-  let outerNode = linkedList(data, 0, outerLen, dim, true, areas && areas[0]);
+  const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
+  let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0]);
   const triangles = [];
 
   if (!outerNode || outerNode.next === outerNode.prev) return triangles;
@@ -44,16 +56,16 @@ export function earcut(data, holeIndices, dim, areas) {
   let x;
   let y;
 
-  if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim, areas);
+  if (hasHoles) outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas);
 
   // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
-  if (data.length > 80 * dim) {
-    minX = maxX = data[0];
-    minY = maxY = data[1];
+  if (positions.length > 80 * dim) {
+    minX = maxX = positions[0];
+    minY = maxY = positions[1];
 
     for (let i = dim; i < outerLen; i += dim) {
-      x = data[i];
-      y = data[i + 1];
+      x = positions[i];
+      y = positions[i + 1];
       if (x < minX) minX = x;
       if (y < minY) minY = y;
       if (x > maxX) maxX = x;
@@ -96,7 +108,7 @@ function linkedList(data, start, end, dim, clockwise, area) {
 }
 
 // eliminate colinear or duplicate points
-function filterPoints(start, end) {
+function filterPoints(start, end?) {
   if (!start) return start;
   if (!end) end = start;
 
@@ -119,7 +131,7 @@ function filterPoints(start, end) {
 }
 
 // main ear slicing loop which triangulates a polygon (given as a linked list)
-function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass?) {
   if (!ear) return;
 
   // interlink polygon nodes in z-order

package/src/{lineclip.js → lineclip.ts}

@@ -20,14 +20,26 @@
 
  */
 
-/* eslint-disable max-statements, max-depth */
+/* eslint-disable max-statements, max-depth, complexity */
 
 import {push, copy, getPointAtIndex} from './utils';
 
-// Cohen-Sutherland line clipping algorithm, adapted to efficiently
-// handle polylines rather than just segments
-export function clipPolyline(positions, bbox, options = {}) {
-  const {size = 2, startIndex = 0, endIndex = positions.length} = options;
+type BoundingBox = [number, number, number, number];
+
+/**
+ * Cohen-Sutherland line clipping algorithm, adapted to efficiently
+ * handle polylines rather than just segments
+ */
+export function clipPolyline(
+  positions: number[],
+  bbox: BoundingBox,
+  options?: {
+    size?: number;
+    startIndex?: number;
+    endIndex?: number;
+  }
+): number[][] {
+  const {size = 2, startIndex = 0, endIndex = positions.length} = options || {};
   const numPoints = (endIndex - startIndex) / size;
   const result = [];
   let part = [];
@@ -86,11 +98,21 @@ export function clipPolyline(positions, bbox, options = {}) {
   return result;
 }
 
-// Sutherland-Hodgeman polygon clipping algorithm
-// polygon must be closed (first vertex == last vertex)
-export function clipPolygon(positions, bbox, options = {}) {
-  const {size = 2, endIndex = positions.length} = options;
-  let {startIndex = 0} = options;
+/**
+ * Sutherland-Hodgeman polygon clipping algorithm
+ * polygon must be closed (first vertex == last vertex)
+ */
+export function clipPolygon(
+  positions: number[],
+  bbox: BoundingBox,
+  options?: {
+    size?: number;
+    startIndex?: number;
+    endIndex?: number;
+  }
+): number[] {
+  const {size = 2, endIndex = positions.length} = options || {};
+  let {startIndex = 0} = options || {};
   let numPoints = (endIndex - startIndex) / size;
   let result;
   let p;
@@ -128,9 +150,15 @@ export function clipPolygon(positions, bbox, options = {}) {
   return result;
 }
 
-// intersect a segment against one of the 4 lines that make up the bbox
+/** intersect a segment against one of the 4 lines that make up the bbox */
 
-export function intersect(a, b, edge, bbox, out = []) {
+export function intersect(
+  a: number[],
+  b: number[],
+  edge: number,
+  bbox: BoundingBox,
+  out: number[] = []
+): number[] {
   let t;
   // Forces out[snapI] to be on the bbox edge
   // Interpolation introduces precision issue which may cause lineclip to be
@@ -161,14 +189,14 @@ export function intersect(a, b, edge, bbox, out = []) {
   return out;
 }
 
-// bit code reflects the point position relative to the bbox:
-
-//         left  mid  right
-//    top  1001  1000  1010
-//    mid  0001  0000  0010
-// bottom  0101  0100  0110
-
-export function bitCode(p, bbox) {
+/**
+ * bit code reflects the point position relative to the bbox:
+ *         left  mid  right
+ *    top  1001  1000  1010
+ *    mid  0001  0000  0010
+ * bottom  0101  0100  0110
+ */
+export function bitCode(p: number[], bbox: BoundingBox): number {
   let code = 0;
 
   if (p[0] < bbox[0]) code |= 1;