@turf/quadrat-analysis 6.5.0 → 7.0.0-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/README.md +52 -29
  2. package/dist/es/index.js +37 -41
  3. package/dist/js/index.d.ts +1 -1
  4. package/dist/js/index.js +43 -49
  5. package/package.json +13 -12
package/README.md CHANGED
@@ -4,37 +4,41 @@
4
4
 
5
5
  ## quadratAnalysis
6
6
 
7
- Quadrat analysis lays a set of equal-size areas(quadrat) over the study area and counts
7
+ Quadrat analysis lays a set of equal-size areas(quadrat) over the study area and counts
8
8
  the number of features in each quadrat and creates a frequency table.
9
- The table lists the number of quadrats containing no features, the number containing one feature, two features, and so on,
9
+ The table lists the number of quadrats containing no features,
10
+ the number containing one feature, two features, and so on,
10
11
  all the way up to the quadrat containing the most features.
11
12
  The method then creates the frequency table for the random distribution, usually based on a Poisson distribution.
12
- The method uses the distribution to calculate the probability for 0 feature occuring, 1 feature occuring, 2 features, and so on,
13
+ The method uses the distribution to calculate the probability for 0 feature occuring,
14
+ 1 feature occuring, 2 features, and so on,
13
15
  and lists these probabilities in the frequency table.
14
16
  By comparing the two frequency tables, you can see whether the features create a pattern.
15
- If the table for the observed distribution has more quadrats containing many features than the table for the random distribution dose,
16
- then the features create a clustered pattern.
17
+ If the table for the observed distribution has more quadrats containing many features than the
18
+ table for the random distribution dose, then the features create a clustered pattern.
17
19
 
18
20
  It is hard to judge the frequency tables are similar or different just by looking at them.
19
21
  So, we can use serval statistical tests to find out how much the frequency tables differ.
20
- We use Kolmogorov-Smirnov test.This method calculates cumulative probabilities for both distributions,
22
+ We use Kolmogorov-Smirnov test.This method calculates cumulative probabilities for both distributions,
21
23
  and then compares the cumulative probabilities at each class level and selects the largest absolute difference D.
22
24
  Then, the test compares D to the critical value for a confidence level you specify.
23
- If D is greater than the critical value, the difference between the observed distribution and the random distribution is significant.
24
- The greater the value the bigger the difference.
25
+ If D is greater than the critical value, the difference between the observed distribution and
26
+ the random distribution is significant. The greater the value the bigger the difference.
25
27
 
26
28
  Traditionally, squares are used for the shape of the quadrats, in a regular grid(square-grid).
27
- Some researchers suggest that the quadrat size equal twice the size of mean area per feature,
29
+ Some researchers suggest that the quadrat size equal twice the size of mean area per feature,
28
30
  which is simply the area of the study area divided by the number of features.
29
31
 
30
- **Parameters**
32
+ ### Parameters
31
33
 
32
- - `pointFeatureSet` **[FeatureCollection](https://tools.ietf.org/html/rfc7946#section-3.3)<[Point](https://tools.ietf.org/html/rfc7946#section-3.1.2)>** point set to study
33
- - `options` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** optional parameters (optional, default `{}`)
34
- - `options.studyBbox` **bbox?** bbox representing the study area
35
- - `options.confidenceLevel` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)** a confidence level .The unit is percentage . 5 means 95% ,value must be in [K_TABLE](#k_table) (optional, default `20`)
34
+ * `pointFeatureSet` **[FeatureCollection][1]<[Point][2]>** point set to study
35
+ * `options` **[Object][3]** optional parameters (optional, default `{}`)
36
36
 
37
- **Examples**
37
+ * `options.studyBbox` **bbox?** bbox representing the study area
38
+ * `options.confidenceLevel` **[number][4]** a confidence level.
39
+ The unit is percentage . 5 means 95%, value must be in [K_TABLE][5] (optional, default `20`)
40
+
41
+ ### Examples
38
42
 
39
43
  ```javascript
40
44
  var bbox = [-65, 40, -63, 42];
@@ -42,33 +46,52 @@ var dataset = turf.randomPoint(100, { bbox: bbox });
42
46
  var result = turf.quadratAnalysis(dataset);
43
47
  ```
44
48
 
45
- Returns **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** result [QuadratAnalysisResult](#quadratanalysisresult)
49
+ Returns **[Object][3]** result [QuadratAnalysisResult][6]
46
50
 
47
51
  ## K_TABLE
48
52
 
49
53
  the confidence level
50
54
 
51
- **Properties**
55
+ Type: [Object][3]
56
+
57
+ ### Properties
52
58
 
53
- - `20` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)**
54
- - `15` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)**
55
- - `10` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)**
56
- - `5` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)**
57
- - `2` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)**
58
- - `1` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)**
59
+ * `20` **[number][4]**
60
+ * `15` **[number][4]**
61
+ * `10` **[number][4]**
62
+ * `5` **[number][4]**
63
+ * `2` **[number][4]**
64
+ * `1` **[number][4]**
59
65
 
60
66
  ## QuadratAnalysisResult
61
67
 
62
68
  the return type of the quadratAnalysis
63
69
 
64
- Type: [Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)
70
+ Type: [Object][3]
71
+
72
+ ### Properties
73
+
74
+ * `criticalValue` **[number][4]**
75
+ * `maxAbsoluteDifference` **[number][4]**
76
+ * `isRandom` **[boolean][7]**
77
+ * `observedDistribution` **[Array][8]<[number][4]>** the cumulative distribution of observed features,
78
+ the index represents the number of features in the quadrat.
79
+
80
+ [1]: https://tools.ietf.org/html/rfc7946#section-3.3
81
+
82
+ [2]: https://tools.ietf.org/html/rfc7946#section-3.1.2
83
+
84
+ [3]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
85
+
86
+ [4]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
87
+
88
+ [5]: #k_table
89
+
90
+ [6]: #quadratanalysisresult
65
91
 
66
- **Properties**
92
+ [7]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
67
93
 
68
- - `criticalValue` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)**
69
- - `maxAbsoluteDifference` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)**
70
- - `isRandom` **[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)**
71
- - `observedDistribution` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)&lt;[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)>** the cumulative distribution of observed features, the index represents the number of features in the quadrat.
94
+ [8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
72
95
 
73
96
  <!-- This file is automatically generated. Please don't edit it directly:
74
97
  if you find an error, edit the source file (likely index.js), and re-run
package/dist/es/index.js CHANGED
@@ -46,31 +46,29 @@ import squareGrid from "@turf/square-grid";
46
46
  */
47
47
  export default function quadratAnalysis(pointFeatureSet, options) {
48
48
  options = options || {};
49
- var studyBbox = options.studyBbox || turfBBox(pointFeatureSet);
50
- var confidenceLevel = options.confidenceLevel || 20;
51
- var points = pointFeatureSet.features;
49
+ const studyBbox = options.studyBbox || turfBBox(pointFeatureSet);
50
+ const confidenceLevel = options.confidenceLevel || 20;
51
+ const points = pointFeatureSet.features;
52
52
  // create square-grid
53
- var numOfPoints = points.length;
54
- var sizeOfArea = area(bboxPolygon(studyBbox));
55
- var lengthOfSide = Math.sqrt((sizeOfArea / numOfPoints) * 2);
56
- var grid = squareGrid(studyBbox, lengthOfSide, {
53
+ const numOfPoints = points.length;
54
+ const sizeOfArea = area(bboxPolygon(studyBbox));
55
+ const lengthOfSide = Math.sqrt((sizeOfArea / numOfPoints) * 2);
56
+ const grid = squareGrid(studyBbox, lengthOfSide, {
57
57
  units: "meters",
58
58
  });
59
- var quadrats = grid.features;
59
+ const quadrats = grid.features;
60
60
  // count the number of features in each quadrat
61
- var quadratIdDict = {};
62
- for (var i = 0; i < quadrats.length; i++) {
61
+ const quadratIdDict = {};
62
+ for (let i = 0; i < quadrats.length; i++) {
63
63
  quadratIdDict[i] = {
64
64
  box: turfBBox(quadrats[i]),
65
65
  cnt: 0,
66
66
  };
67
67
  }
68
- var sumOfPoint = 0;
69
- for (var _i = 0, points_1 = points; _i < points_1.length; _i++) {
70
- var pt = points_1[_i];
71
- for (var _a = 0, _b = Object.keys(quadratIdDict); _a < _b.length; _a++) {
72
- var key = _b[_a];
73
- var box = quadratIdDict[key].box;
68
+ let sumOfPoint = 0;
69
+ for (const pt of points) {
70
+ for (const key of Object.keys(quadratIdDict)) {
71
+ const box = quadratIdDict[key].box;
74
72
  if (inBBox(getCoord(pt), box)) {
75
73
  quadratIdDict[key].cnt += 1;
76
74
  sumOfPoint += 1;
@@ -79,53 +77,51 @@ export default function quadratAnalysis(pointFeatureSet, options) {
79
77
  }
80
78
  }
81
79
  // the most amount of features in quadrat
82
- var maxCnt = 0;
83
- for (var _c = 0, _d = Object.keys(quadratIdDict); _c < _d.length; _c++) {
84
- var key = _d[_c];
85
- var cnt = quadratIdDict[key].cnt;
80
+ let maxCnt = 0;
81
+ for (const key of Object.keys(quadratIdDict)) {
82
+ const cnt = quadratIdDict[key].cnt;
86
83
  if (cnt > maxCnt) {
87
84
  maxCnt = cnt;
88
85
  }
89
86
  }
90
- var expectedDistribution = [];
91
- var numOfQuadrat = Object.keys(quadratIdDict).length;
92
- var lambda = sumOfPoint / numOfQuadrat;
87
+ const expectedDistribution = [];
88
+ const numOfQuadrat = Object.keys(quadratIdDict).length;
89
+ const lambda = sumOfPoint / numOfQuadrat;
93
90
  // get the cumulative probability of the random distribution
94
- var cumulativeProbility = 0.0;
95
- for (var x = 0; x < maxCnt + 1; x++) {
91
+ let cumulativeProbility = 0.0;
92
+ for (let x = 0; x < maxCnt + 1; x++) {
96
93
  cumulativeProbility +=
97
94
  (Math.exp(-lambda) * Math.pow(lambda, x)) / factorial(x);
98
95
  expectedDistribution.push(cumulativeProbility);
99
96
  }
100
97
  // get the cumulative probability of the observed distribution
101
- var observedDistribution = [];
102
- var cumulativeObservedQuads = 0;
103
- for (var x = 0; x < maxCnt + 1; x++) {
104
- for (var _e = 0, _f = Object.keys(quadratIdDict); _e < _f.length; _e++) {
105
- var key = _f[_e];
98
+ const observedDistribution = [];
99
+ let cumulativeObservedQuads = 0;
100
+ for (let x = 0; x < maxCnt + 1; x++) {
101
+ for (const key of Object.keys(quadratIdDict)) {
106
102
  if (quadratIdDict[key].cnt === x) {
107
103
  cumulativeObservedQuads += 1;
108
104
  }
109
105
  }
110
- var p = cumulativeObservedQuads / numOfQuadrat;
106
+ const p = cumulativeObservedQuads / numOfQuadrat;
111
107
  observedDistribution.push(p);
112
108
  }
113
109
  // get the largest absolute difference between two distributions
114
- var maxDifference = 0;
115
- for (var x = 0; x < maxCnt + 1; x++) {
116
- var difference = Math.abs(expectedDistribution[x] - observedDistribution[x]);
110
+ let maxDifference = 0;
111
+ for (let x = 0; x < maxCnt + 1; x++) {
112
+ const difference = Math.abs(expectedDistribution[x] - observedDistribution[x]);
117
113
  if (difference > maxDifference) {
118
114
  maxDifference = difference;
119
115
  }
120
116
  }
121
- var k = K_TABLE[confidenceLevel];
117
+ const k = K_TABLE[confidenceLevel];
122
118
  // statistical test
123
- var criticalValue = k / Math.sqrt(numOfQuadrat);
124
- var result = {
125
- criticalValue: criticalValue,
119
+ const criticalValue = k / Math.sqrt(numOfQuadrat);
120
+ const result = {
121
+ criticalValue,
126
122
  isRandom: true,
127
123
  maxAbsoluteDifference: maxDifference,
128
- observedDistribution: observedDistribution,
124
+ observedDistribution,
129
125
  };
130
126
  if (maxDifference > criticalValue) {
131
127
  result.isRandom = false;
@@ -142,7 +138,7 @@ export default function quadratAnalysis(pointFeatureSet, options) {
142
138
  * @property {number} 2
143
139
  * @property {number} 1
144
140
  */
145
- var K_TABLE = {
141
+ const K_TABLE = {
146
142
  20: 1.07275,
147
143
  15: 1.13795,
148
144
  10: 1.22385,
@@ -177,7 +173,7 @@ function inBBox(pt, bbox) {
177
173
  * @returns {number} the factorial of num
178
174
  */
179
175
  function factorial(num) {
180
- var f = [];
176
+ const f = [];
181
177
  function inner(n) {
182
178
  if (n === 0 || n === 1) {
183
179
  return 1;
package/dist/js/index.d.ts CHANGED
@@ -1,4 +1,4 @@
1
- import { FeatureCollection, Point } from "@turf/helpers";
1
+ import { FeatureCollection, Point } from "geojson";
2
2
  export interface QuadratAnalysisResult {
3
3
  criticalValue: number;
4
4
  maxAbsoluteDifference: number;
package/dist/js/index.js CHANGED
@@ -1,13 +1,11 @@
1
1
  "use strict";
2
- var __importDefault = (this && this.__importDefault) || function (mod) {
3
- return (mod && mod.__esModule) ? mod : { "default": mod };
4
- };
5
2
  Object.defineProperty(exports, "__esModule", { value: true });
6
- var area_1 = __importDefault(require("@turf/area"));
7
- var bbox_1 = __importDefault(require("@turf/bbox"));
8
- var bbox_polygon_1 = __importDefault(require("@turf/bbox-polygon"));
9
- var invariant_1 = require("@turf/invariant");
10
- var square_grid_1 = __importDefault(require("@turf/square-grid"));
3
+ const tslib_1 = require("tslib");
4
+ const area_1 = tslib_1.__importDefault(require("@turf/area"));
5
+ const bbox_1 = tslib_1.__importDefault(require("@turf/bbox"));
6
+ const bbox_polygon_1 = tslib_1.__importDefault(require("@turf/bbox-polygon"));
7
+ const invariant_1 = require("@turf/invariant");
8
+ const square_grid_1 = tslib_1.__importDefault(require("@turf/square-grid"));
11
9
  /**
12
10
  * Quadrat analysis lays a set of equal-size areas(quadrat) over the study area and counts
13
11
  * the number of features in each quadrat and creates a frequency table.
@@ -51,31 +49,29 @@ var square_grid_1 = __importDefault(require("@turf/square-grid"));
51
49
  */
52
50
  function quadratAnalysis(pointFeatureSet, options) {
53
51
  options = options || {};
54
- var studyBbox = options.studyBbox || bbox_1.default(pointFeatureSet);
55
- var confidenceLevel = options.confidenceLevel || 20;
56
- var points = pointFeatureSet.features;
52
+ const studyBbox = options.studyBbox || bbox_1.default(pointFeatureSet);
53
+ const confidenceLevel = options.confidenceLevel || 20;
54
+ const points = pointFeatureSet.features;
57
55
  // create square-grid
58
- var numOfPoints = points.length;
59
- var sizeOfArea = area_1.default(bbox_polygon_1.default(studyBbox));
60
- var lengthOfSide = Math.sqrt((sizeOfArea / numOfPoints) * 2);
61
- var grid = square_grid_1.default(studyBbox, lengthOfSide, {
56
+ const numOfPoints = points.length;
57
+ const sizeOfArea = area_1.default(bbox_polygon_1.default(studyBbox));
58
+ const lengthOfSide = Math.sqrt((sizeOfArea / numOfPoints) * 2);
59
+ const grid = square_grid_1.default(studyBbox, lengthOfSide, {
62
60
  units: "meters",
63
61
  });
64
- var quadrats = grid.features;
62
+ const quadrats = grid.features;
65
63
  // count the number of features in each quadrat
66
- var quadratIdDict = {};
67
- for (var i = 0; i < quadrats.length; i++) {
64
+ const quadratIdDict = {};
65
+ for (let i = 0; i < quadrats.length; i++) {
68
66
  quadratIdDict[i] = {
69
67
  box: bbox_1.default(quadrats[i]),
70
68
  cnt: 0,
71
69
  };
72
70
  }
73
- var sumOfPoint = 0;
74
- for (var _i = 0, points_1 = points; _i < points_1.length; _i++) {
75
- var pt = points_1[_i];
76
- for (var _a = 0, _b = Object.keys(quadratIdDict); _a < _b.length; _a++) {
77
- var key = _b[_a];
78
- var box = quadratIdDict[key].box;
71
+ let sumOfPoint = 0;
72
+ for (const pt of points) {
73
+ for (const key of Object.keys(quadratIdDict)) {
74
+ const box = quadratIdDict[key].box;
79
75
  if (inBBox(invariant_1.getCoord(pt), box)) {
80
76
  quadratIdDict[key].cnt += 1;
81
77
  sumOfPoint += 1;
@@ -84,53 +80,51 @@ function quadratAnalysis(pointFeatureSet, options) {
84
80
  }
85
81
  }
86
82
  // the most amount of features in quadrat
87
- var maxCnt = 0;
88
- for (var _c = 0, _d = Object.keys(quadratIdDict); _c < _d.length; _c++) {
89
- var key = _d[_c];
90
- var cnt = quadratIdDict[key].cnt;
83
+ let maxCnt = 0;
84
+ for (const key of Object.keys(quadratIdDict)) {
85
+ const cnt = quadratIdDict[key].cnt;
91
86
  if (cnt > maxCnt) {
92
87
  maxCnt = cnt;
93
88
  }
94
89
  }
95
- var expectedDistribution = [];
96
- var numOfQuadrat = Object.keys(quadratIdDict).length;
97
- var lambda = sumOfPoint / numOfQuadrat;
90
+ const expectedDistribution = [];
91
+ const numOfQuadrat = Object.keys(quadratIdDict).length;
92
+ const lambda = sumOfPoint / numOfQuadrat;
98
93
  // get the cumulative probability of the random distribution
99
- var cumulativeProbility = 0.0;
100
- for (var x = 0; x < maxCnt + 1; x++) {
94
+ let cumulativeProbility = 0.0;
95
+ for (let x = 0; x < maxCnt + 1; x++) {
101
96
  cumulativeProbility +=
102
97
  (Math.exp(-lambda) * Math.pow(lambda, x)) / factorial(x);
103
98
  expectedDistribution.push(cumulativeProbility);
104
99
  }
105
100
  // get the cumulative probability of the observed distribution
106
- var observedDistribution = [];
107
- var cumulativeObservedQuads = 0;
108
- for (var x = 0; x < maxCnt + 1; x++) {
109
- for (var _e = 0, _f = Object.keys(quadratIdDict); _e < _f.length; _e++) {
110
- var key = _f[_e];
101
+ const observedDistribution = [];
102
+ let cumulativeObservedQuads = 0;
103
+ for (let x = 0; x < maxCnt + 1; x++) {
104
+ for (const key of Object.keys(quadratIdDict)) {
111
105
  if (quadratIdDict[key].cnt === x) {
112
106
  cumulativeObservedQuads += 1;
113
107
  }
114
108
  }
115
- var p = cumulativeObservedQuads / numOfQuadrat;
109
+ const p = cumulativeObservedQuads / numOfQuadrat;
116
110
  observedDistribution.push(p);
117
111
  }
118
112
  // get the largest absolute difference between two distributions
119
- var maxDifference = 0;
120
- for (var x = 0; x < maxCnt + 1; x++) {
121
- var difference = Math.abs(expectedDistribution[x] - observedDistribution[x]);
113
+ let maxDifference = 0;
114
+ for (let x = 0; x < maxCnt + 1; x++) {
115
+ const difference = Math.abs(expectedDistribution[x] - observedDistribution[x]);
122
116
  if (difference > maxDifference) {
123
117
  maxDifference = difference;
124
118
  }
125
119
  }
126
- var k = K_TABLE[confidenceLevel];
120
+ const k = K_TABLE[confidenceLevel];
127
121
  // statistical test
128
- var criticalValue = k / Math.sqrt(numOfQuadrat);
129
- var result = {
130
- criticalValue: criticalValue,
122
+ const criticalValue = k / Math.sqrt(numOfQuadrat);
123
+ const result = {
124
+ criticalValue,
131
125
  isRandom: true,
132
126
  maxAbsoluteDifference: maxDifference,
133
- observedDistribution: observedDistribution,
127
+ observedDistribution,
134
128
  };
135
129
  if (maxDifference > criticalValue) {
136
130
  result.isRandom = false;
@@ -148,7 +142,7 @@ exports.default = quadratAnalysis;
148
142
  * @property {number} 2
149
143
  * @property {number} 1
150
144
  */
151
- var K_TABLE = {
145
+ const K_TABLE = {
152
146
  20: 1.07275,
153
147
  15: 1.13795,
154
148
  10: 1.22385,
@@ -183,7 +177,7 @@ function inBBox(pt, bbox) {
183
177
  * @returns {number} the factorial of num
184
178
  */
185
179
  function factorial(num) {
186
- var f = [];
180
+ const f = [];
187
181
  function inner(n) {
188
182
  if (n === 0 || n === 1) {
189
183
  return 1;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@turf/quadrat-analysis",
3
- "version": "6.5.0",
3
+ "version": "7.0.0-alpha.0",
4
4
  "description": "turf quadrat-analysis module",
5
5
  "author": "Turf Authors",
6
6
  "contributors": [
@@ -47,7 +47,7 @@
47
47
  "test:tape": "ts-node -r esm test.js"
48
48
  },
49
49
  "devDependencies": {
50
- "@turf/nearest-neighbor-analysis": "^6.5.0",
50
+ "@turf/nearest-neighbor-analysis": "^7.0.0-alpha.0",
51
51
  "@types/tape": "*",
52
52
  "benchmark": "*",
53
53
  "load-json-file": "*",
@@ -59,15 +59,16 @@
59
59
  "write-json-file": "*"
60
60
  },
61
61
  "dependencies": {
62
- "@turf/area": "^6.5.0",
63
- "@turf/bbox": "^6.5.0",
64
- "@turf/bbox-polygon": "^6.5.0",
65
- "@turf/centroid": "^6.5.0",
66
- "@turf/helpers": "^6.5.0",
67
- "@turf/invariant": "^6.5.0",
68
- "@turf/point-grid": "^6.5.0",
69
- "@turf/random": "^6.5.0",
70
- "@turf/square-grid": "^6.5.0"
62
+ "@turf/area": "^7.0.0-alpha.0",
63
+ "@turf/bbox": "^7.0.0-alpha.0",
64
+ "@turf/bbox-polygon": "^7.0.0-alpha.0",
65
+ "@turf/centroid": "^7.0.0-alpha.0",
66
+ "@turf/helpers": "^7.0.0-alpha.0",
67
+ "@turf/invariant": "^7.0.0-alpha.0",
68
+ "@turf/point-grid": "^7.0.0-alpha.0",
69
+ "@turf/random": "^7.0.0-alpha.0",
70
+ "@turf/square-grid": "^7.0.0-alpha.0",
71
+ "tslib": "^2.3.0"
71
72
  },
72
- "gitHead": "5375941072b90d489389db22b43bfe809d5e451e"
73
+ "gitHead": "0edc4c491b999e5ace770a61e1cf549f7c004189"
73
74
  }