@konfirm/geojson 1.0.0 → 1.0.1

package/test/Domain/GeoJSON/Concept/Latitude.ts

@@ -1,56 +0,0 @@
-import test from 'tape';
-import { each } from 'template-literal-each';
-import * as Export from '../../../../source/Domain/GeoJSON/Concept/Latitude';
-import { exported } from '../../../helper/geometry';
-
-exported('Domain/GeoJSON/Concept/Latitude', Export, 'isLatitude', 'isStrictLatitude');
-
-const { isLatitude, isStrictLatitude } = Export;
-
-test('Domain/GeoJSON/Concept/Latitude - isLatitude', (t) => {
-	each`
-		input           | valid
-		----------------|-------
-		${0}            | yes
-		${0.0000000001} | yes
-		${51.9851034}   | yes
-		${-90}          | yes
-		${-90.1}        | yes
-		${90}           | yes
-		${90.1}         | yes
-		${-Infinity}    | no
-		${Infinity}     | no
-		${NaN}          | no
-		${'1234'}       | no
-		${false}        | no
-		${true}         | no
-	`(({ input, valid }) => {
-		t.equal(isLatitude(input), valid === 'yes', `${input} ${valid}`);
-	});
-
-	t.end();
-});
-
-test('Domain/GeoJSON/Concept/Latitude - isStrictLatitude', (t) => {
-	each`
-		input           | valid
-		----------------|-------
-		${0}            | yes
-		${0.0000000001} | yes
-		${51.9851034}   | yes
-		${-90}          | yes
-		${-90.1}        | no
-		${90}           | yes
-		${90.1}         | no
-		${-Infinity}    | no
-		${Infinity}     | no
-		${NaN}          | no
-		${'1234'}       | no
-		${false}        | no
-		${true}         | no
-	`(({ input, valid }) => {
-		t.equal(isStrictLatitude(input), valid === 'yes', `${input} ${valid}`);
-	});
-
-	t.end();
-});

package/test/Domain/GeoJSON/Concept/LinearRing.ts

@@ -1,63 +0,0 @@
-import test from 'tape';
-import { each } from 'template-literal-each';
-import * as Export from '../../../../source/Domain/GeoJSON/Concept/LinearRing';
-import { exported } from '../../../helper/geometry';
-import { coordinates as Italy } from '../../../data/Italy';
-import { coordinates as SanMarino } from '../../../data/SanMarino';
-import { coordinates as HolySee } from '../../../data/HolySee';
-
-exported('Domain/GeoJSON/Concept/LinearRing', Export, 'isLinearRing', 'isStrictLinearRing');
-
-const { isLinearRing, isStrictLinearRing } = Export;
-
-test('Domain/GeoJSON/Concept/LinearRing - isLinearRing', (t) => {
-	each`
-		input                                            | valid
-		-------------------------------------------------|----
-		${undefined}                                     | no
-		${null}                                          | no
-		${'[[1,0],[1,1],[0,1],[1,0]]'}                   | no
-		${[[1, 0], [1, 1], [0, 1], [0, 0.5], [1, 0]]}    | yes
-		${[[1, 0], [0, 0.5], [0, 1], [1, 1], [1, 0]]}    | yes
-		${[[1, 0], [1, 1], [0, 1], [1, 0]]}              | yes
-		${[[1, 0], [1, 1], [0, 1], [0, 0]]}              | no
-		${[[1, 0], [1, 1], [1, 0]]}                      | no
-		${[[1, 0], [1, 0]]}                              | no
-		${[[1, 0]]}                                      | no
-		${[[-181, -91], [0, -91], [0, 91], [-181, -91]]} | yes
-	`(({ input, valid }) => {
-		t.equal(isLinearRing(input), valid === 'yes', `[${input}] isLinearRing ${valid}`);
-	});
-
-	t.ok(Italy.every((polygon) => polygon.every(isLinearRing)), 'coordinates for Italy polygon all match isLinearRing');
-	t.notOk(SanMarino.every(isLinearRing), 'coordinates for SanMarino does not match isLinearRing');
-	t.notOk(HolySee.every(isLinearRing), 'coordinates for HolySee does not match isLinearRing');
-
-	t.end();
-});
-
-test('Domain/GeoJSON/Concept/LinearRing - isStrictLinearRing', (t) => {
-	each`
-		input                                            | valid
-		-------------------------------------------------|----
-		${undefined}                                     | no
-		${null}                                          | no
-		${'[[1,0],[1,1],[0,1],[1,0]]'}                   | no
-		${[[1, 0], [1, 1], [0, 1], [0, 0.5], [1, 0]]}    | yes
-		${[[1, 0], [0, 0.5], [0, 1], [1, 1], [1, 0]]}    | yes
-		${[[1, 0], [1, 1], [0, 1], [1, 0]]}              | yes
-		${[[1, 0], [1, 1], [0, 1], [0, 0]]}              | no
-		${[[1, 0], [1, 1], [1, 0]]}                      | no
-		${[[1, 0], [1, 0]]}                              | no
-		${[[1, 0]]}                                      | no
-		${[[-181, -91], [0, -91], [0, 91], [-181, -91]]} | no
-	`(({ input, valid }) => {
-		t.equal(isStrictLinearRing(input), valid === 'yes', `[${input}] isStrictLinearRing ${valid}`);
-	});
-
-	t.ok(Italy.every((polygon) => polygon.every(isStrictLinearRing)), 'coordinates for Italy polygon all match isStrictLinearRing');
-	t.notOk(SanMarino.every(isStrictLinearRing), 'coordinates for SanMarino does not match isStrictLinearRing');
-	t.notOk(HolySee.every(isStrictLinearRing), 'coordinates for HolySee does not match isStrictLinearRing');
-
-	t.end();
-});

package/test/Domain/GeoJSON/Concept/Longitude.ts

@@ -1,56 +0,0 @@
-import test from 'tape';
-import { each } from 'template-literal-each';
-import * as Export from '../../../../source/Domain/GeoJSON/Concept/Longitude';
-import { exported } from '../../../helper/geometry';
-
-exported('Domain/GeoJSON/Concept/Longitude', Export, 'isLongitude', 'isStrictLongitude');
-
-const { isLongitude, isStrictLongitude } = Export;
-
-test('Domain/GeoJSON/Concept/Longitude - isLongitude', (t) => {
-	each`
-		input           | valid
-		----------------|-------
-		${0}            | yes
-		${0.0000000001} | yes
-		${5.8987296}    | yes
-		${-180}         | yes
-		${-180.1}       | yes
-		${180}          | yes
-		${180.1}        | yes
-		${-Infinity}    | no
-		${Infinity}     | no
-		${NaN}          | no
-		${'1234'}       | no
-		${false}        | no
-		${true}         | no
-	`(({ input, valid }) => {
-		t.equal(isLongitude(input), valid === 'yes', `${input} ${valid}`);
-	});
-
-	t.end();
-});
-
-test('Domain/GeoJSON/Concept/Longitude - isStrictLongitude', (t) => {
-	each`
-		input           | valid
-		----------------|-------
-		${0}            | yes
-		${0.0000000001} | yes
-		${5.8987296}    | yes
-		${-180}         | yes
-		${-180.1}       | no
-		${180}          | yes
-		${180.1}        | no
-		${-Infinity}    | no
-		${Infinity}     | no
-		${NaN}          | no
-		${'1234'}       | no
-		${false}        | no
-		${true}         | no
-	`(({ input, valid }) => {
-		t.equal(isStrictLongitude(input), valid === 'yes', `${input} ${valid}`);
-	});
-
-	t.end();
-});

package/test/Domain/GeoJSON/Concept/Position.ts

@@ -1,56 +0,0 @@
-import test from 'tape';
-import * as Export from '../../../../source/Domain/GeoJSON/Concept/Position';
-import { coordinates } from '../../../data/HolySee';
-import { exported } from '../../../helper/geometry';
-
-exported('Domain/GeoJSON/Concept/Position', Export, 'isPosition', 'isStrictPosition', 'isEquivalentPosition');
-
-const { isPosition, isStrictPosition, isEquivalentPosition } = Export;
-const altitude = coordinates.map(([lon, lat, alt = 1.23]) => [lon, lat, alt]);
-
-test('Domain/GeoJSON/Concept/Position - isPosition', (t) => {
-	t.ok(coordinates.every(isPosition), 'all coordinates match isPosition');
-	t.ok(altitude.every(isPosition), 'all coordinates with altitude match isPosition');
-
-	t.notOk(isPosition([Infinity, 0, 0]), `[Infinity, 0, 0] is not a Position`);
-	t.notOk(isPosition([0, Infinity, 0]), `[0, Infinity, 0] is not a Position`);
-	t.notOk(isPosition([0, 0, Infinity]), `[0, 0, Infinity] is not a Position`);
-	t.ok(isPosition([0, 0, 0]), `[0, 0, 0] is Position`);
-	t.ok(isPosition([-181, 0, 0]), `[-181, 0, 0] is Position`);
-	t.ok(isPosition([0, -91, 0]), `[0, -91, 0] is Position`);
-	t.ok(isPosition([0, 0, -7000000]), `[0, 0, -7000000] is Position`);
-	t.ok(isPosition([-181, -91, 0]), `[-181, -91, 0] is Position`);
-	t.ok(isPosition([0, -91, -7000000]), `[0, -91, -7000000] is Position`);
-	t.ok(isPosition([-181, 0, -7000000]), `[-181, 0, -7000000] is Position`);
-	t.ok(isPosition([-181, -91, -7000000]), `[-181, -91, -7000000] is Position`);
-
-	t.end();
-});
-
-test('Domain/GeoJSON/Concept/Position - isStrictPosition', (t) => {
-	t.ok(coordinates.every(isStrictPosition), 'all coordinates match isStrictPosition');
-	t.ok(altitude.every(isStrictPosition), 'all coordinates with altitude match isStrictPosition');
-
-	t.notOk(isStrictPosition([Infinity, 0, 0]), `[Infinity, 0, 0] is not a strict Position`);
-	t.notOk(isStrictPosition([0, Infinity, 0]), `[0, Infinity, 0] is not a strict Position`);
-	t.notOk(isStrictPosition([0, 0, Infinity]), `[0, 0, Infinity] is not a strict Position`);
-	t.ok(isStrictPosition([0, 0, 0]), `[0, 0, 0] is strict Position`);
-	t.notOk(isStrictPosition([-181, 0, 0]), `[-181, 0, 0] is not a strict Position`);
-	t.notOk(isStrictPosition([0, -91, 0]), `[0, -91, 0] is not a strict Position`);
-	t.notOk(isStrictPosition([0, 0, -7000000]), `[0, 0, -7000000] is not a strict Position`);
-	t.notOk(isStrictPosition([-181, -91, 0]), `[-181, -91, 0] is not a strict Position`);
-	t.notOk(isStrictPosition([0, -91, -7000000]), `[0, -91, -7000000] is not a strict Position`);
-	t.notOk(isStrictPosition([-181, 0, -7000000]), `[-181, 0, -7000000] is not a strict Position`);
-	t.notOk(isStrictPosition([-181, -91, -7000000]), `[-181, -91, -7000000] is not a strict Position`);
-
-	t.end();
-});
-
-test('Domain/GeoJSON/Concept/Position - isEquivalentPosition', (t) => {
-	t.ok(isEquivalentPosition([1.23456789, 2.3456789], [1.23456789, 2.3456789]), `[1.23456789,2.3456789] and [1.23456789,2.3456789] are equivalent`);
-	t.ok(isEquivalentPosition([1.23456789, 2.3456789, 3.456789], [1.23456789, 2.3456789, 3.456789]), `[1.23456789,2.3456789,3.456789] and [1.23456789,2.3456789,3.456789] are equivalent`);
-	t.notOk(isEquivalentPosition([1.23456789, 2.3456789, 3.456789], [1.23456789, 2.3456789]), `[1.23456789,2.3456789,3.456789] and [1.23456789,2.3456789] are not equivalent`);
-	t.notOk(isEquivalentPosition([1.23456789, 2.3456789], [1.23456789, 2.3456789, , 3.456789]), `[1.23456789,2.3456789] and [1.23456789,2.3456789,,3.456789] are not equivalent`);
-
-	t.end();
-});

package/test/Domain/GeoJSON/Feature.ts

@@ -1,9 +0,0 @@
-import * as Export from '../../../source/Domain/GeoJSON/Feature';
-import { runner } from '../../helper/geometry';
-
-runner(
-	'Domain/GeoJSON/Feature',
-	Export,
-	'isFeature',
-	'isStrictFeature',
-);

package/test/Domain/GeoJSON/FeatureCollection.ts

@@ -1,9 +0,0 @@
-import * as Export from '../../../source/Domain/GeoJSON/FeatureCollection';
-import { runner } from '../../helper/geometry';
-
-runner(
-	'Domain/GeoJSON/FeatureCollection',
-	Export,
-	'isFeatureCollection',
-	'isStrictFeatureCollection',
-);

package/test/Domain/GeoJSON/GeoJSON.ts

@@ -1,21 +0,0 @@
-import * as Export from '../../../source/Domain/GeoJSON/GeoJSON';
-import { runner } from '../../helper/geometry';
-
-const types = [
-	'Point',
-	'MultiPoint',
-	'LineString',
-	'MultiLineString',
-	'Polygon',
-	'MultiPolygon',
-	'GeometryCollection',
-	'Feature',
-	'FeatureCollection',
-]
-
-runner(
-	'Domain/GeoJSON/GeoJSON',
-	Export,
-	['isGeoJSON', types],
-	['isStrictGeoJSON', types],
-);

package/test/Domain/GeoJSON/Geometry/LineString.ts

@@ -1,11 +0,0 @@
-import * as Export from '../../../../source/Domain/GeoJSON/Geometry/LineString';
-import { runner } from '../../../helper/geometry';
-
-runner(
-	'Domain/GeoJSON/Geometry/LineString',
-	Export,
-	['isLineStringCoordinates', ['MultiPoint']],
-	'isLineString',
-	['isStrictLineStringCoordinates', ['MultiPoint']],
-	'isStrictLineString',
-);

package/test/Domain/GeoJSON/Geometry/MultiLineString.ts

@@ -1,11 +0,0 @@
-import * as Export from '../../../../source/Domain/GeoJSON/Geometry/MultiLineString';
-import { runner } from '../../../helper/geometry';
-
-runner(
-	'Domain/GeoJSON/Geometry/MultiLineString',
-	Export,
-	['isMultiLineStringCoordinates', ['Polygon']],
-	'isMultiLineString',
-	['isStrictMultiLineStringCoordinates', ['Polygon']],
-	'isStrictMultiLineString',
-);

package/test/Domain/GeoJSON/Geometry/MultiPoint.ts

@@ -1,11 +0,0 @@
-import * as Export from '../../../../source/Domain/GeoJSON/Geometry/MultiPoint';
-import { runner } from '../../../helper/geometry';
-
-runner(
-	'Domain/GeoJSON/Geometry/MultiPoint',
-	Export,
-	['isMultiPointCoordinates', ['LineString']],
-	'isMultiPoint',
-	['isStrictMultiPointCoordinates', ['LineString']],
-	'isStrictMultiPoint',
-);

package/test/Domain/GeoJSON/Geometry/MultiPolygon.ts

@@ -1,11 +0,0 @@
-import * as Export from '../../../../source/Domain/GeoJSON/Geometry/MultiPolygon';
-import { runner } from '../../../helper/geometry';
-
-runner(
-	'Domain/GeoJSON/Geometry/MultiPolygon',
-	Export,
-	'isMultiPolygonCoordinates',
-	'isMultiPolygon',
-	'isStrictMultiPolygonCoordinates',
-	'isStrictMultiPolygon',
-);

package/test/Domain/GeoJSON/Geometry/Point.ts

@@ -1,11 +0,0 @@
-import * as Export from '../../../../source/Domain/GeoJSON/Geometry/Point';
-import { runner } from '../../../helper/geometry';
-
-runner(
-	'Domain/GeoJSON/Geometry/Point',
-	Export,
-	'isPointCoordinates',
-	'isPoint',
-	'isStrictPointCoordinates',
-	'isStrictPoint',
-);

package/test/Domain/GeoJSON/Geometry/Polygon.ts

@@ -1,11 +0,0 @@
-import * as Export from '../../../../source/Domain/GeoJSON/Geometry/Polygon';
-import { runner } from '../../../helper/geometry';
-
-runner(
-	'Domain/GeoJSON/Geometry/Polygon',
-	Export,
-	'isPolygonCoordinates',
-	'isPolygon',
-	'isStrictPolygonCoordinates',
-	'isStrictPolygon',
-);

package/test/Domain/GeoJSON/Geometry.ts

@@ -1,9 +0,0 @@
-import * as Export from '../../../source/Domain/GeoJSON/Geometry';
-import { runner } from '../../helper/geometry';
-
-runner(
-	'Domain/GeoJSON/Geometry',
-	Export,
-	['isGeometry', ['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon']],
-	['isStrictGeometry', ['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon']],
-);

package/test/Domain/GeoJSON/GeometryCollection.ts

@@ -1,9 +0,0 @@
-import * as Export from '../../../source/Domain/GeoJSON/GeometryCollection';
-import { runner } from '../../helper/geometry';
-
-runner(
-	'Domain/GeoJSON/GeometryCollection',
-	Export,
-	'isGeometryCollection',
-	'isStrictGeometryCollection',
-);

package/test/Domain/GeoJSON/GeometryObject.ts

@@ -1,4 +0,0 @@
-import * as Export from '../../../source/Domain/GeoJSON/GeometryObject';
-import { exported } from '../../helper/geometry';
-
-exported('Domain/GeoJSON/GeometryObject', Export, 'isGeometryObject');

package/test/Domain/Guards/Number.ts

@@ -1,49 +0,0 @@
-import test from 'tape';
-import { each } from 'template-literal-each';
-import * as Export from '../../../source/Domain/Guards/Number';
-import { exported } from '../../helper/geometry';
-
-exported('Domain/Guards/Number - exports', Export, 'isNumberValue', 'isNumberBetween');
-
-const { isNumberValue, isNumberBetween } = Export;
-
-test('Domain/Guards/Number - isNumberValue', (t) => {
-	each`
-		input                      | valid
-		---------------------------|-------
-		${123}                     | yes
-		${Number.MAX_SAFE_INTEGER} | yes
-		${Number.MIN_SAFE_INTEGER} | yes
-		${Number.MAX_VALUE}        | yes
-		${Number.MIN_VALUE}        | yes
-		${Math.PI}                 | yes
-		${-Math.PI}                | yes
-		${Infinity}                | no
-		${-Infinity}               | no
-		${NaN}                     | no
-		${'123'}                   | no
-	`(({ input, valid }) => {
-		t.equal(isNumberValue(input), valid === 'yes', `${input} isNumberValue ${valid}`);
-	});
-
-	t.end();
-});
-
-test('Domain/Guards/Number - isNumberBetween', (t) => {
-	each`
-		input        | min    | max          | valid
-		-------------|--------|--------------|-------
-		${1}         | ${0}   | ${2}         | yes
-		${0}         | ${0}   | ${2}         | yes
-		${-1}        | ${0}   | ${2}         | no
-		${Infinity}  | ${0}   | ${undefined} | no
-		${Math.PI}   | ${0}   | ${undefined} | yes
-		${0}         | ${-10} | ${10}        | yes
-	`(({ input, min, max, valid }: any) => {
-		const between = isNumberBetween(min, max);
-
-		t.equal(between(input), valid === 'yes', `${input} is ${valid === 'no' ? 'not ' : ''}between ${min} and ${max}`);
-	});
-
-	t.end();
-});

package/test/Domain/Guards/Tuple.ts

@@ -1,27 +0,0 @@
-import { isBoolean, isNumber, isString } from '@konfirm/guard';
-import test from 'tape';
-import * as Export from '../../../source/Domain/Guards/Tuple';
-import { exported } from '../../helper/geometry';
-
-exported('Domain/Guards/Tuple - exports', Export, 'isTuple');
-
-const { isTuple } = Export;
-
-test('Domain/Guards/Tuple - isTuple', (t) => {
-	const snn = isTuple(isString, isNumber, isNumber);
-	const bsn = isTuple(isBoolean, isString, isNumber);
-
-	t.notOk(snn(['abc']), `['abc'] does not match isTuple(isString, isNumber, isNumber)`);
-	t.notOk(snn(['abc', 123]), `['abc', 123] does not match isTuple(isString, isNumber, isNumber)`);
-	t.ok(snn(['abc', 123, 456]), `['abc', 123, 456] matches isTuple(isString, isNumber, isNumber)`);
-	t.notOk(snn(['abc', 123, true]), `['abc', 123, true] does not match isTuple(isString, isNumber, isNumber)`);
-	t.notOk(snn(['abc', false, 123]), `['abc', false, 123] does not match isTuple(isString, isNumber, isNumber)`);
-	t.notOk(snn(['abc', 123, 456, 789]), `['abc', 456, 789, 123] does not match isTuple(isString, isNumber, isNumber)`);
-
-	t.notOk(bsn(['abc', 123]), `['abc', 123] does not match isTuple(isBoolean, isString, isNumber)`);
-	t.notOk(bsn(['abc', false, 123]), `['abc', false, 123] does not match isTuple(isBoolean, isString, isNumber)`);
-	t.ok(bsn([true, 'abc', 123]), `[true, 'abc', 123] matches isTuple(isBoolean, isString, isNumber)`);
-	t.ok(bsn([false, 'abc', 123]), `[false, 'abc', 123] matches isTuple(isBoolean, isString, isNumber)`);
-
-	t.end();
-});

package/test/Domain/Iterator/IterablePair.ts

@@ -1,203 +0,0 @@
-import test from 'tape';
-import * as Export from '../../../source/Domain/Iterator/IterablePair';
-import { SimpleGeometryIterator } from '../../../source/Domain/Iterator/SimpleGeometry';
-import { Point } from '../../../source/Domain/GeoJSON/Geometry/Point';
-import { MultiPoint } from '../../../source/Domain/GeoJSON/Geometry/MultiPoint';
-import { LineString } from '../../../source/Domain/GeoJSON/Geometry/LineString';
-import { MultiLineString } from '../../../source/Domain/GeoJSON/Geometry/MultiLineString';
-import { Polygon } from '../../../source/Domain/GeoJSON/Geometry/Polygon';
-import { MultiPolygon } from '../../../source/Domain/GeoJSON/Geometry/MultiPolygon';
-import { GeometryCollection } from '../../../source/Domain/GeoJSON/GeometryCollection';
-import { Feature } from '../../../source/Domain/GeoJSON/Feature';
-import { FeatureCollection } from '../../../source/Domain/GeoJSON/FeatureCollection';
-import { explain, exported } from '../../helper/geometry';
-
-const point: Point = { type: 'Point', coordinates: [0, 0] };
-const multipoint: MultiPoint = { type: 'MultiPoint', coordinates: [[1, 1], [2, 2]] };
-const linestring: LineString = { type: 'LineString', coordinates: [[3, 3], [4, 4]] };
-const multilinestring: MultiLineString = { type: 'MultiLineString', coordinates: [[[5, 5], [6, 6]], [[7, 7], [8, 8]], [[9, 9], [10, 10]]] };
-const polygon: Polygon = { type: 'Polygon', coordinates: [[[0, 0], [0, 3], [3, 3], [3, 0], [0, 0]], [[1, 1], [2, 1], [2, 2], [1, 2], [1, 1]]] };
-const multipolygon: MultiPolygon = { type: 'MultiPolygon', coordinates: [[[[4, 4], [4, 5], [5, 5], [5, 4], [4, 4]]], [[[0, 0], [0, 3], [3, 3], [3, 0], [0, 0]], [[1, 1], [2, 1], [2, 2], [1, 2], [1, 1]]]] };
-const geometrycollection: GeometryCollection = { type: 'GeometryCollection', geometries: [point, multipoint] };
-const feature: Feature = { type: 'Feature', properties: null, geometry: linestring };
-const featurecollection: FeatureCollection = {
-    type: 'FeatureCollection', features: [
-        { type: 'Feature', properties: null, geometry: multilinestring },
-        { type: 'Feature', properties: null, geometry: polygon },
-        { type: 'Feature', properties: null, geometry: multipolygon },
-    ]
-};
-
-exported('Domain/Iterator/IterablePair', Export, 'IterablePairIterator');
-
-const { IterablePairIterator } = Export;
-
-test('Domain/Iterator/IterablePair - implements Symbol.iterator', (t) => {
-    const iterator = new IterablePairIterator(new SimpleGeometryIterator(point), new SimpleGeometryIterator(multipoint));
-
-    t.ok(Symbol.iterator in iterator, 'SimpleGeometryIterator implements Symbol.iterator');
-
-    t.end();
-});
-
-test('Domain/Iterator/IterablePair - Point with MultiPoint', (t) => {
-    const iterator = new IterablePairIterator(new SimpleGeometryIterator(point), new SimpleGeometryIterator(multipoint));
-    const expanded = [...iterator];
-    const expected = [
-        [point, { type: 'Point', coordinates: [1, 1] }],
-        [point, { type: 'Point', coordinates: [2, 2] }],
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} combinations`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `combination is ${explain(expect[0])} with ${explain(expect[1])}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Iterator/IterablePair - MultiPoint with LineString', (t) => {
-    const iterator = new IterablePairIterator(new SimpleGeometryIterator(multipoint), new SimpleGeometryIterator(linestring));
-    const expanded = [...iterator];
-    const expected = [
-        [{ type: 'Point', coordinates: [1, 1] }, linestring],
-        [{ type: 'Point', coordinates: [2, 2] }, linestring],
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} combinations`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `combination is ${explain(expect[0])} with ${explain(expect[1])}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Iterator/IterablePair - MultiPoint with MultiLineString', (t) => {
-    const iterator = new IterablePairIterator(new SimpleGeometryIterator(multipoint), new SimpleGeometryIterator(multilinestring));
-    const expanded = [...iterator];
-    const expected = [
-        [{ type: 'Point', coordinates: [1, 1] }, { type: 'LineString', coordinates: [[5, 5], [6, 6]] }],
-        [{ type: 'Point', coordinates: [1, 1] }, { type: 'LineString', coordinates: [[7, 7], [8, 8]] }],
-        [{ type: 'Point', coordinates: [1, 1] }, { type: 'LineString', coordinates: [[9, 9], [10, 10]] }],
-        [{ type: 'Point', coordinates: [2, 2] }, { type: 'LineString', coordinates: [[5, 5], [6, 6]] }],
-        [{ type: 'Point', coordinates: [2, 2] }, { type: 'LineString', coordinates: [[7, 7], [8, 8]] }],
-        [{ type: 'Point', coordinates: [2, 2] }, { type: 'LineString', coordinates: [[9, 9], [10, 10]] }],
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} combinations`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `combination is ${explain(expect[0])} with ${explain(expect[1])}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Iterator/IterablePair - MultiLineString with Polygon', (t) => {
-    const iterator = new IterablePairIterator(new SimpleGeometryIterator(multilinestring), new SimpleGeometryIterator(polygon));
-    const expanded = [...iterator];
-    const expected = [
-        [{ type: 'LineString', coordinates: [[5, 5], [6, 6]] }, polygon],
-        [{ type: 'LineString', coordinates: [[7, 7], [8, 8]] }, polygon],
-        [{ type: 'LineString', coordinates: [[9, 9], [10, 10]] }, polygon],
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} combinations`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `combination is ${explain(expect[0])} with ${explain(expect[1])}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Iterator/IterablePair - Polygon with MultiPolygon', (t) => {
-    const iterator = new IterablePairIterator(new SimpleGeometryIterator(polygon), new SimpleGeometryIterator(multipolygon));
-    const expanded = [...iterator];
-    const expected = [
-        [polygon, { type: 'Polygon', coordinates: [[[4, 4], [4, 5], [5, 5], [5, 4], [4, 4]]] }],
-        [polygon, { type: 'Polygon', coordinates: [[[0, 0], [0, 3], [3, 3], [3, 0], [0, 0]], [[1, 1], [2, 1], [2, 2], [1, 2], [1, 1]]] }],
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} combinations`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `combination is ${explain(expect[0])} with ${explain(expect[1])}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Iterator/IterablePair - Polygon with Feature', (t) => {
-    const iterator = new IterablePairIterator(new SimpleGeometryIterator(polygon), new SimpleGeometryIterator(feature));
-    const expanded = [...iterator];
-    const expected = [
-        [polygon, linestring],
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} combinations`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `combination is ${explain(expect[0])} with ${explain(expect[1])}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Iterator/IterablePair - GeometryCollection with FeatureCollection', (t) => {
-    const iterator = new IterablePairIterator(new SimpleGeometryIterator(geometrycollection), new SimpleGeometryIterator(featurecollection));
-    const expanded = [...iterator];
-    const expected = [
-        [point, { type: 'LineString', coordinates: [[5, 5], [6, 6]] }],
-        [point, { type: 'LineString', coordinates: [[7, 7], [8, 8]] }],
-        [point, { type: 'LineString', coordinates: [[9, 9], [10, 10]] }],
-        [point, polygon],
-        [point, { type: 'Polygon', coordinates: [[[4, 4], [4, 5], [5, 5], [5, 4], [4, 4]]] }],
-        [point, { type: 'Polygon', coordinates: [[[0, 0], [0, 3], [3, 3], [3, 0], [0, 0]], [[1, 1], [2, 1], [2, 2], [1, 2], [1, 1]]] }],
-
-        [{ type: 'Point', coordinates: [1, 1] }, { type: 'LineString', coordinates: [[5, 5], [6, 6]] }],
-        [{ type: 'Point', coordinates: [1, 1] }, { type: 'LineString', coordinates: [[7, 7], [8, 8]] }],
-        [{ type: 'Point', coordinates: [1, 1] }, { type: 'LineString', coordinates: [[9, 9], [10, 10]] }],
-        [{ type: 'Point', coordinates: [1, 1] }, polygon],
-        [{ type: 'Point', coordinates: [1, 1] }, { type: 'Polygon', coordinates: [[[4, 4], [4, 5], [5, 5], [5, 4], [4, 4]]] }],
-        [{ type: 'Point', coordinates: [1, 1] }, { type: 'Polygon', coordinates: [[[0, 0], [0, 3], [3, 3], [3, 0], [0, 0]], [[1, 1], [2, 1], [2, 2], [1, 2], [1, 1]]] }],
-
-        [{ type: 'Point', coordinates: [2, 2] }, { type: 'LineString', coordinates: [[5, 5], [6, 6]] }],
-        [{ type: 'Point', coordinates: [2, 2] }, { type: 'LineString', coordinates: [[7, 7], [8, 8]] }],
-        [{ type: 'Point', coordinates: [2, 2] }, { type: 'LineString', coordinates: [[9, 9], [10, 10]] }],
-        [{ type: 'Point', coordinates: [2, 2] }, polygon],
-        [{ type: 'Point', coordinates: [2, 2] }, { type: 'Polygon', coordinates: [[[4, 4], [4, 5], [5, 5], [5, 4], [4, 4]]] }],
-        [{ type: 'Point', coordinates: [2, 2] }, { type: 'Polygon', coordinates: [[[0, 0], [0, 3], [3, 3], [3, 0], [0, 0]], [[1, 1], [2, 1], [2, 2], [1, 2], [1, 1]]] }],
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} combinations`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `combination is ${explain(expect[0])} with ${explain(expect[1])}`);
-    }
-
-    t.end();
-});