@konfirm/geojson 1.0.0

package/test/Domain/Utility/Numeric.ts

@@ -0,0 +1,30 @@
+import test from 'tape';
+import { each } from 'template-literal-each';
+import * as Export from '../../../source/Domain/Utility/Numeric';
+import { exported } from '../../helper/geometry';
+
+exported('Domain/Utility/Numeric', Export, 'bounds');
+
+const { bounds } = Export;
+
+test('Domain/Utility/Numeric - bounds', (t) => {
+	each`
+		value                  | min     | max     | expect
+		-----------------------|---------|---------|--------
+		${1}                   | ${-1}   | ${1}    | ${1}
+		${100}                 | ${-1}   | ${1}    | ${0}
+		${1}                   | ${-1.5} | ${1.5}  | ${1}
+		${1}                   | ${1.5}  | ${-1.5} | ${1}
+		${5.911738872528076}   | ${-180} | ${180}  | ${5.911738872528076}
+		${-354.0882611274719}  | ${-180} | ${180}  | ${5.911738872528076}
+		${365.911738872528076} | ${-180} | ${180}  | ${5.911738872528076}
+		${51.97496770044958}   | ${-90}  | ${90}   | ${51.97496770044958}
+		${-128.02503229955042} | ${-90}  | ${90}   | ${51.97496770044958}
+		${231.97496770044958}  | ${-90}  | ${90}   | ${51.97496770044958}
+	`(({ value, min, max, expect }: any) => {
+		const rotate = bounds(min, max);
+		t.equal(rotate(value), expect, `${value} within bounds ${min} and ${max} is ${expect}`);
+	});
+
+	t.end();
+});

package/test/Domain/Utility/Winding.ts

@@ -0,0 +1,52 @@
+import test from 'tape';
+import { each } from 'template-literal-each';
+import * as Export from '../../../source/Domain/Utility/Winding';
+import { exported } from '../../helper/geometry';
+
+exported('Domain/Utility/Winding', Export, 'isClockwiseWinding', 'isCounterClockwiseWinding');
+
+const { isClockwiseWinding, isCounterClockwiseWinding } = Export;
+
+test('Domain/Utility/Winding - isClockwiseWinding', (t) => {
+	each`
+		position                                    | valid
+		--------------------------------------------|-------
+		${[[0, 0], [1, 0]]}                         | yes
+		${[[0, 0], [1, 0], [1, 1]]}                 | yes
+		${[[0, 0], [1, 0], [1, 1], [0, 1]]}         | yes
+		${[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]} | yes
+		${[[0, 0], [1, 0], [0, 1], [1, 1]]}         | yes
+		${[[0, 0]]}                                 | yes
+		${[[0, 0], [0, 1]]}                         | yes
+		${[[0, 0], [0, 1], [1, 1]]}                 | no
+		${[[0, 0], [0, 1], [1, 1], [1, 0]]}         | no
+		${[[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]} | no
+		${[[1, 1], [0, 1], [1, 0], [0, 0]]}         | yes
+	`(({ position, valid }) => {
+		t.equal(isClockwiseWinding(position), valid === 'yes', `isClockwiseWinding ${JSON.stringify(position)} ${valid}`);
+	});
+
+	t.end();
+});
+
+test('Domain/Utility/Winding - isCounterClockwiseWinding', (t) => {
+	each`
+		position                                    | valid
+		--------------------------------------------|-------
+		${[[0, 0], [1, 0]]}                         | yes
+		${[[0, 0], [1, 0], [1, 1]]}                 | no
+		${[[0, 0], [1, 0], [1, 1], [0, 1]]}         | no
+		${[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]} | no
+		${[[0, 0], [1, 0], [0, 1], [1, 1]]}         | yes
+		${[[0, 0]]}                                 | yes
+		${[[0, 0], [0, 1]]}                         | yes
+		${[[0, 0], [0, 1], [1, 1]]}                 | yes
+		${[[0, 0], [0, 1], [1, 1], [1, 0]]}         | yes
+		${[[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]} | yes
+		${[[1, 1], [0, 1], [1, 0], [0, 0]]}         | yes
+	`(({ position, valid }) => {
+		t.equal(isCounterClockwiseWinding(position), valid === 'yes', `isCounterClockwiseWinding ${JSON.stringify(position)} ${valid}`);
+	});
+
+	t.end();
+});

package/test/README.ts

@@ -0,0 +1,123 @@
+import test from 'tape';
+import { distance, Feature, FeatureCollection, GeometryCollection, intersect, LineString, MultiLineString, MultiPoint, Point, SimpleGeometryIterator } from '../source/main';
+
+test('README - intersect', (t) => {
+    const point: Point = {
+        type: 'Point',
+        coordinates: [1, 1],
+    };
+    const feature: Feature = {
+        type: 'Feature',
+        properties: {
+            name: 'triangle'
+        },
+        geometry: {
+            type: 'Polygon',
+            coordinates: [[[0, 0], [0, 2], [2, 1], [0, 0]]],
+        },
+    }
+
+    t.true(intersect(point, feature), 'point intersects feature');
+    t.true(intersect(feature, point), 'feature intersects point');
+
+    t.end();
+});
+
+test('README - distance', (t) => {
+    const a: Feature = {
+        type: 'Feature',
+        properties: {
+            name: 'Amsterdam Airport Schiphol',
+        },
+        geometry: {
+            type: 'Point',
+            coordinates: [4.763889, 52.308333],
+        },
+    };
+    const b: Feature = {
+        type: 'Feature',
+        properties: {
+            name: 'New York John F. Kennedy International Airport'
+        },
+        geometry: {
+            type: 'Point',
+            coordinates: [-73.778889, 40.639722],
+        },
+    };
+
+    t.equal(distance(a, b), 8829424.604594177, 'distance from a to b using default formula is 8829424.604594177');
+    t.equal(distance(a, b, 'cartesian'), 8829424.604594177, 'distance from a to b using cartesian formula is 8829424.604594177');
+    t.equal(distance(a, b, 'haversine'), 5847546.425707642, 'distance from a to b using haversine formula is 5847546.425707642');
+    t.equal(distance(a, b, 'vincenty'), 5863355.371234315, 'distance from a to b using vincenty formula is 5863355.371234315');
+
+    t.end();
+});
+
+test('README - SimpleGeometryIterator', (t) => {
+    const point: Point = {
+        type: 'Point',
+        coordinates: [5.903949737548828, 51.991936460056515],
+    };
+    const multipoint: MultiPoint = {
+        type: 'MultiPoint',
+        coordinates: [
+            [5.896482467651367, 52.00039200820837],
+            [5.888843536376953, 51.99912377779024],
+        ],
+    };
+    const linestring: LineString = {
+        type: 'LineString',
+        coordinates: [
+            [5.9077370166778564, 51.9944435645134],
+            [5.90764045715332, 51.994209045542206],
+            [5.907415151596069, 51.99408683094357],
+        ],
+    };
+    const multilinestring: MultiLineString = {
+        type: 'MultiLineString',
+        coordinates: [
+            [
+                [5.905205011367797, 51.99430813821511],
+                [5.905086994171143, 51.994261894995034],
+                [5.905033349990845, 51.99414958983319],
+                [5.9051138162612915, 51.994116558849626]
+            ],
+            [
+                [5.904818773269653, 51.993825885143515],
+                [5.905521512031555, 51.993551725259614],
+                [5.905789732933044, 51.99358805979856],
+            ],
+        ],
+    };
+    const geometrycollection: GeometryCollection = {
+        type: 'GeometryCollection',
+        geometries: [point],
+    };
+    const featurecollection: FeatureCollection = {
+        type: 'FeatureCollection',
+        features: [
+            {
+                type: 'Feature',
+                properties: {},
+                geometry: linestring,
+            },
+            {
+                type: 'Feature',
+                properties: {},
+                geometry: multilinestring,
+            },
+        ]
+    };
+
+    const expectation = []
+        .concat(multipoint.coordinates.map((coordinates) => ({ type: 'Point', coordinates })))
+        .concat(point)
+        .concat(linestring)
+        .concat(multilinestring.coordinates.map((coordinates) => ({ type: 'LineString', coordinates })));
+    const simplified = [...new SimpleGeometryIterator(multipoint, geometrycollection, featurecollection)];
+
+    console.dir(simplified);
+    t.deepEqual(simplified, expectation, 'provides all geometries in order');
+
+    t.end();
+});

package/test/data/Distance.ts

@@ -0,0 +1,51 @@
+import { GeoJSON } from '../../source/Domain/GeoJSON/GeoJSON';
+import { Polygon } from '../../source/Domain/GeoJSON/Geometry/Polygon';
+
+const poly: Polygon = {
+    type: 'Polygon',
+    coordinates: [
+        [[0, 0], [0, 7], [2, 7], [2, 5], [4, 5], [4, 7], [7, 7], [7, 5], [9, 5], [9, 7], [11, 7], [11, 0], [0, 0]],
+        [[2, 2], [5, 2], [5, 4], [2, 4], [2, 2]],
+        [[7, 2], [9, 2], [9, 4], [7, 4], [7, 2]],
+    ]
+};
+export const shapes: Array<{ a: GeoJSON, b: GeoJSON, cartesian: number, haversine: number, vincenty: number }> = [
+    { a: { type: 'Point', coordinates: [0, 0] }, b: { type: 'Point', coordinates: [1, 0] }, cartesian: 111195.07973436874, haversine: 111195.07973436874, vincenty: 111319.49079322325 },
+    { a: { type: 'Point', coordinates: [0, 0] }, b: { type: 'Point', coordinates: [1, 1] }, cartesian: 157253.589829502, haversine: 157249.5977681334, vincenty: 156899.56829129544 },
+
+    { a: { type: 'Point', coordinates: [1, 1] }, b: { type: 'LineString', coordinates: [[0, 2], [2, 2]] }, cartesian: 111195.07973436874, haversine: 111195.07973436874, vincenty: 110575.06481449273 },
+    { a: { type: 'Point', coordinates: [1, 1] }, b: { type: 'LineString', coordinates: [[0, 0], [2, 2]] }, cartesian: 0, haversine: 0, vincenty: 0 },
+    { a: { type: 'Point', coordinates: [3, 3] }, b: { type: 'LineString', coordinates: [[0, 0], [2, 2]] }, cartesian: 157253.589829502, haversine: 157177.7682119375, vincenty: 156829.3291160335 },
+    { a: { type: 'Point', coordinates: [0, 1] }, b: { type: 'LineString', coordinates: [[0, 0], [2, 2]] }, cartesian: 78626.794914751, haversine: 78623.30209761004, vincenty: 78448.3205183003 },
+    { a: { type: 'Point', coordinates: [1, 0] }, b: { type: 'LineString', coordinates: [[0, 0], [2, 2]] }, cartesian: 78626.794914751, haversine: 78626.29592703035, vincenty: 78451.24803121673 },
+
+    { a: { type: 'MultiPoint', coordinates: [[9, 9], [1, 0]] }, b: { type: 'LineString', coordinates: [[0, 0], [2, 2]] }, cartesian: 78626.794914751, haversine: 78626.29592703035, vincenty: 78451.24803121673 },
+    { a: { type: 'Point', coordinates: [1, 0] }, b: { type: 'MultiLineString', coordinates: [[[100, 100], [200, 200]], [[0, 0], [2, 2]]] }, cartesian: 78626.794914751, haversine: 78626.29592703035, vincenty: 78451.24803121673 },
+    { a: { type: 'MultiPoint', coordinates: [[9, 9], [1, 0]] }, b: { type: 'MultiLineString', coordinates: [[[100, 100], [200, 200]], [[0, 0], [2, 2]]] }, cartesian: 78626.794914751, haversine: 78626.29592703035, vincenty: 78451.24803121673 },
+
+    { a: { type: 'Point', coordinates: [2, 2] }, b: { type: 'Polygon', coordinates: [[[0, 0], [0, 4], [4, 4], [4, 0], [0, 0]]] }, cartesian: 0, haversine: 0, vincenty: 0 },
+    { a: { type: 'Point', coordinates: [5, 2] }, b: { type: 'Polygon', coordinates: [[[0, 0], [0, 4], [4, 4], [4, 0], [0, 0]]] }, cartesian: 111195.07973436874, haversine: 111127.34097821356, vincenty: 111252.12980016059 },
+    { a: { type: 'Point', coordinates: [2, 2] }, b: { type: 'Polygon', coordinates: [[[0, 0], [0, 4], [4, 4], [4, 0], [0, 0]], [[1, 1], [3, 1], [3, 3], [1, 3], [1, 1]]] }, cartesian: 111195.07973436874, haversine: 111127.34097821356, vincenty: 110575.06481449273 },
+
+    { a: { type: 'LineString', coordinates: [[0, 0], [2, 0]] }, b: { type: 'LineString', coordinates: [[0, 2], [0, 0]] }, cartesian: 0, haversine: 0, vincenty: 0 },
+    { a: { type: 'LineString', coordinates: [[0, 0], [2, 0]] }, b: { type: 'LineString', coordinates: [[1, 2], [1, 0]] }, cartesian: 0, haversine: 0, vincenty: 0 },
+    { a: { type: 'LineString', coordinates: [[0, 0], [2, 0]] }, b: { type: 'LineString', coordinates: [[3, 2], [3, 0]] }, cartesian: 111195.07973436874, haversine: 111195.07973436874, vincenty: 111319.49079322327 },
+    { a: { type: 'LineString', coordinates: [[0, 0], [2, 0]] }, b: { type: 'LineString', coordinates: [[1, 1], [1, 3]] }, cartesian: 111195.07973436874, haversine: 111195.07973436874, vincenty: 110574.38855795695 },
+    { a: { type: 'LineString', coordinates: [[0, 0], [2, 0]] }, b: { type: 'LineString', coordinates: [[1, 1], [3, 3]] }, cartesian: 111195.07973436874, haversine: 111195.07973436874, vincenty: 110574.38855795695 },
+    { a: { type: 'LineString', coordinates: [[0, 0], [2, 2]] }, b: { type: 'LineString', coordinates: [[2, 0], [0, 2]] }, cartesian: 0, haversine: 0, vincenty: 0 },
+    { a: { type: 'LineString', coordinates: [[0, 0], [2, 0], [2, 2]] }, b: { type: 'LineString', coordinates: [[0, 2], [0, 0]] }, cartesian: 0, haversine: 0, vincenty: 0 },
+
+    { a: { type: 'LineString', coordinates: [[2, 2], [3, 2]] }, b: { type: 'Polygon', coordinates: [[[0, 0], [0, 4], [4, 4], [4, 0], [0, 0]]] }, cartesian: 0, haversine: 0, vincenty: 0 },
+    { a: { type: 'LineString', coordinates: [[1, 1], [10, 1]] }, b: poly, cartesian: 0, haversine: 0, vincenty: 0 },
+    { a: { type: 'LineString', coordinates: [[1, 3], [4, 3]] }, b: poly, cartesian: 0, haversine: 0, vincenty: 0 },
+    { a: { type: 'LineString', coordinates: [[3, 3], [4, 3]] }, b: poly, cartesian: 111195.07973436874, haversine: 111042.6868815999, vincenty: 110576.41652430617 },
+    { a: { type: 'LineString', coordinates: [[7.5, 3], [8.5, 3]] }, b: poly, cartesian: 55597.53986718437, haversine: 55521.344888509884, vincenty: 55583.97477025055 },
+    { a: { type: 'LineString', coordinates: [[3, 6], [3, 9]] }, b: poly, cartesian: 111195.07973436874, haversine: 110366.22766612672, vincenty: 110495.20453687456 },
+
+    { a: { type: 'Polygon', coordinates: [[[0, 0], [0, 9], [9, 9], [9, 0], [0, 0]]] }, b: { type: 'Polygon', coordinates: [[[2, 2], [2, 7], [7, 7], [7, 2], [2, 2]]] }, cartesian: 0, haversine: 0, vincenty: 0 },
+    { a: { type: 'Polygon', coordinates: [[[0, 0], [0, 9], [9, 9], [9, 0], [0, 0]], [[1, 1], [8, 1], [8, 8], [1, 8], [1, 1]]] }, b: { type: 'Polygon', coordinates: [[[2, 2], [2, 7], [7, 7], [7, 2], [2, 2]]] }, cartesian: 111195.07973436874, haversine: 110366.22766612672, vincenty: 110495.20453687456 },
+
+    // // Impossible <-> Possible
+    { a: { type: 'Impossible', coordinates: [0, 0] } as any, b: { type: 'Point', coordinates: [0, 0] }, cartesian: Infinity, haversine: Infinity, vincenty: Infinity },
+    { a: { type: 'Point', coordinates: [0, 0] }, b: { type: 'Impossible', coordinates: [0, 0] } as any, cartesian: Infinity, haversine: Infinity, vincenty: Infinity },
+];

package/test/data/HolySee.ts

@@ -0,0 +1,74 @@
+import { Feature, LineString, MultiPoint, Polygon } from "../../source/main";
+
+export const coordinates: MultiPoint['coordinates'] = [
+	[12.455663681030273, 41.90628554165478],
+	[12.457637786865234, 41.90582242096741],
+	[12.45750904083252, 41.90323527118919],
+	[12.458131313323975, 41.90296377408531],
+	[12.458367347717285, 41.902388835231],
+	[12.458345890045166, 41.90171806669123],
+	[12.457981109619139, 41.90131879635783],
+	[12.457423210144043, 41.90115908752542],
+	[12.456929683685303, 41.90119102932384],
+	[12.456543445587156, 41.901414621465506],
+	[12.456221580505371, 41.90165418360565],
+	[12.454354763031006, 41.90144656313615],
+	[12.454376220703125, 41.900695929652535],
+	[12.454547882080078, 41.90034456626665],
+	[12.454526424407959, 41.90020082614245],
+	[12.452874183654785, 41.900472334994284],
+	[12.452852725982666, 41.900296652927864],
+	[12.451672554016113, 41.900376508472526],
+	[12.450792789459227, 41.900616074507326],
+	[12.450792789459227, 41.90082369767715],
+	[12.448797225952148, 41.900983407348406],
+	[12.44873285293579, 41.90080772668804],
+	[12.44802474975586, 41.900663987606414],
+	[12.44776725769043, 41.90082369767715],
+	[12.447960376739502, 41.90099937829354],
+	[12.446715831756592, 41.901765978963454],
+	[12.446565628051758, 41.90163821282425],
+	[12.44577169418335, 41.90195762769289],
+	[12.446587085723877, 41.902356894031726],
+	[12.446801662445067, 41.902213158437355],
+	[12.44776725769043, 41.903011685422804],
+	[12.447617053985596, 41.903107507989986],
+	[12.448325157165526, 41.90371438090925],
+	[12.448668479919434, 41.903650499820955],
+	[12.44901180267334, 41.904672589563994],
+	[12.448861598968506, 41.904768409638564],
+	[12.44899034500122, 41.90511974868156],
+	[12.44922637939453, 41.905199598194436],
+	[12.449419498443604, 41.90507183892591],
+	[12.450535297393799, 41.905870330159836],
+	[12.450342178344727, 41.906014057521375],
+	[12.450470924377441, 41.90649314638965],
+	[12.451286315917969, 41.90657299418483],
+	[12.451479434967041, 41.90636538970964],
+	[12.453067302703857, 41.906716719964486],
+	[12.453818321228027, 41.906812536971195],
+	[12.453839778900146, 41.90698820110995],
+	[12.455449104309082, 41.90737146664404],
+];
+export const multipoint: MultiPoint = {
+	type: 'MultiPoint',
+	coordinates,
+};
+export const linestring: LineString = {
+	type: 'LineString',
+	coordinates,
+};
+export const polygon: Polygon = {
+	type: 'Polygon',
+	coordinates: [coordinates.concat([coordinates[0]])]
+};
+export const feature: Feature = {
+	type: 'Feature',
+	properties: {
+		name: 'Vatican Obelisk',
+	},
+	geometry: {
+		type: 'Point',
+		coordinates: [12.457240819931028, 41.90221715109714],
+	},
+};

package/test/data/Intersect.ts

@@ -0,0 +1,300 @@
+import * as Italy from './Italy';
+import * as HolySee from './HolySee';
+import * as SanMarino from './SanMarino';
+import { Feature, FeatureCollection, GeoJSON, GeometryCollection, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon } from '../../source/main';
+import { Geometry } from '../../source/Domain/GeoJSON/Geometry';
+
+const relative = {
+    outside1: [
+        [12.444055080413818, 41.90334706377874],
+        [12.447037696838379, 41.904784379636986],
+        [12.449805736541746, 41.90735549729274],
+        [12.45450496673584, 41.9085372185006]
+    ],
+    outside2: [
+        [12.456951141357422, 41.910597193707545],
+        [12.456693649291992, 41.90660493327494],
+        [12.45896816253662, 41.906509115956666],
+        [12.458603382110596, 41.903139448813754]
+    ],
+    partial: [
+        [12.457487583160399, 41.90226107033812],
+        [12.458195686340332, 41.90229301158531],
+        [12.464332580566406, 41.90246868815924]
+    ],
+    inside1: [
+        [12.45425820350647, 41.903925986557695],
+        [12.454848289489746, 41.90402979284584],
+        [12.455030679702759, 41.90410964372185],
+        [12.457063794136047, 41.90400583756355]
+    ],
+    inside2: [
+        [12.454526424407959, 41.90458076185763],
+        [12.454580068588257, 41.90358661866875]
+    ]
+};
+
+function center(...points: Array<Array<number>>): Point['coordinates'] {
+    const s = 1e15;
+    const c = s * points.length;
+    const [x, y] = points
+        .reduce(([x1, y1], [x2, y2]) => [x1 + (x2 * s), y1 + (y2 * s)], [0, 0]);
+
+    return [x / c, y / c];
+}
+
+function geometry<T extends Geometry>(type: T['type'], coordinates: Array<unknown>): T {
+    return {
+        type,
+        coordinates: coordinates.slice() as T['coordinates'],
+    } as T;
+}
+
+function geometryCollection(...geometries: Array<Geometry | GeometryCollection>): GeometryCollection {
+    return {
+        type: 'GeometryCollection',
+        geometries,
+    };
+}
+
+function feature(geometry: Geometry): Feature {
+    return {
+        type: 'Feature',
+        properties: null,
+        geometry,
+    };
+}
+
+function featureCollection(...features: Array<Feature | Geometry>): FeatureCollection {
+    return {
+        type: 'FeatureCollection',
+        features: features.map((geo) => geo.type === 'Feature' ? geo : feature(geo)),
+    };
+}
+
+export const shapes: Array<{ a: GeoJSON, b: GeoJSON, intersect: boolean }> = [
+    // Point <-> Point
+    { a: geometry<Point>('Point', relative.inside1[0]), b: geometry<Point>('Point', relative.inside1[0]), intersect: true },
+    { a: geometry<Point>('Point', relative.inside1[0]), b: geometry<Point>('Point', relative.inside1[1]), intersect: false },
+
+    // MultiPoint <-> Point
+    { a: geometry<MultiPoint>('MultiPoint', relative.inside1), b: geometry<Point>('Point', relative.inside1[0]), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', relative.inside1), b: geometry<Point>('Point', center(relative.inside1[0], relative.inside1[1])), intersect: false },
+    { a: geometry<MultiPoint>('MultiPoint', relative.inside1), b: geometry<Point>('Point', center(relative.inside2[0], relative.inside2[1])), intersect: false },
+    { a: geometry<MultiPoint>('MultiPoint', relative.inside1), b: geometry<Point>('Point', relative.inside2[1]), intersect: false },
+
+    // LineString <-> Point
+    { a: geometry<LineString>('LineString', relative.inside1), b: geometry<Point>('Point', relative.inside1[0]), intersect: true },
+    { a: geometry<LineString>('LineString', relative.inside1), b: geometry<Point>('Point', center(relative.inside1[0], relative.inside1[1])), intersect: true },
+    { a: geometry<LineString>('LineString', relative.inside1), b: geometry<Point>('Point', center(relative.inside2[0], relative.inside2[1])), intersect: false },
+    { a: geometry<LineString>('LineString', relative.inside1), b: geometry<Point>('Point', relative.inside2[1]), intersect: false },
+
+    // MultiLineString <-> Point
+    { a: geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.inside1]), b: geometry<Point>('Point', relative.inside1[0]), intersect: true },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.inside1]), b: geometry<Point>('Point', center(relative.inside1[0], relative.inside1[1])), intersect: true },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.inside1]), b: geometry<Point>('Point', center(relative.inside2[0], relative.inside2[1])), intersect: false },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.inside1]), b: geometry<Point>('Point', relative.inside2[1]), intersect: false },
+
+    // Polygon <-> Point
+    { a: HolySee.polygon, b: geometry<Point>('Point', relative.inside1[0]), intersect: true },
+    { a: HolySee.polygon, b: geometry<Point>('Point', relative.outside1[0]), intersect: false },
+    { a: SanMarino.polygon, b: geometry<Point>('Point', relative.inside1[0]), intersect: false },
+    { a: geometry<Polygon>('Polygon', Italy.coordinates[0]), b: geometry<Point>('Point', relative.inside1[0]), intersect: false },
+    { a: geometry<Polygon>('Polygon', Italy.coordinates[0]), b: geometry<Point>('Point', relative.outside1[0]), intersect: true },
+
+    // MultiPolygon <-> Point
+    { a: Italy.multipolygon, b: geometry<Point>('Point', relative.inside1[0]), intersect: false },
+    { a: Italy.multipolygon, b: geometry<Point>('Point', relative.inside2[0]), intersect: false },
+    { a: Italy.multipolygon, b: geometry<Point>('Point', relative.outside1[0]), intersect: true },
+    { a: Italy.multipolygon, b: geometry<Point>('Point', relative.outside2[0]), intersect: true },
+    {
+        a: geometry<MultiPolygon>('MultiPolygon', [[[[8, 8], [8, 9], [9, 9], [9, 8], [8, 8]]], [[[0, 0], [0, 7], [7, 7], [7, 0], [0, 0]]]]),
+        b: geometry<Point>('Point', [3, 3]),
+        intersect: true,
+    },
+
+    // GeometryCollection <-> Point
+    { a: geometryCollection(geometry<Point>('Point', relative.inside1[0])), b: geometry<Point>('Point', relative.inside1[0]), intersect: true },
+    { a: geometryCollection(geometry<MultiPoint>('MultiPoint', relative.inside1)), b: geometry<Point>('Point', relative.inside2[1]), intersect: false },
+
+    // Feature <-> Point
+    { a: feature(Italy.multipolygon), b: geometry<Point>('Point', relative.outside1[0]), intersect: true },
+    { a: feature(HolySee.polygon), b: geometry<Point>('Point', relative.outside1[0]), intersect: false },
+
+    // FeatureCollection <-> Point
+    { a: featureCollection(geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.inside1])), b: geometry<Point>('Point', relative.inside1[0]), intersect: true },
+    { a: featureCollection(geometry<MultiPoint>('MultiPoint', relative.inside1)), b: geometry<Point>('Point', relative.inside2[1]), intersect: false },
+
+
+    // MultiPoint <-> MultiPoint
+    { a: geometry<MultiPoint>('MultiPoint', [relative.inside1[0], relative.inside1[1]]), b: geometry<MultiPoint>('MultiPoint', [relative.inside1[1], relative.inside1[2]]), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', [relative.outside1[0], relative.outside1[1]]), b: geometry<MultiPoint>('MultiPoint', [relative.outside1[1], relative.outside1[2]]), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', [relative.inside1[0], relative.inside1[1]]), b: geometry<MultiPoint>('MultiPoint', [relative.inside1[2], relative.inside1[3]]), intersect: false },
+    { a: geometry<MultiPoint>('MultiPoint', relative.inside1), b: geometry<MultiPoint>('MultiPoint', relative.inside2), intersect: false },
+
+    // MultiPoint <-> LineString
+    { a: geometry<MultiPoint>('MultiPoint', [relative.inside1[0], relative.inside1[1]]), b: geometry<LineString>('LineString', [relative.inside1[1], relative.inside1[2]]), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', [relative.outside1[0], relative.outside1[1]]), b: geometry<LineString>('LineString', [relative.outside1[1], relative.outside1[2]]), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', [relative.outside1[0], center(relative.outside1[0], relative.outside1[1])]), b: geometry<LineString>('LineString', relative.outside1), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', [relative.inside1[0], relative.inside1[1]]), b: geometry<LineString>('LineString', [relative.inside1[2], relative.inside1[3]]), intersect: false },
+    { a: geometry<MultiPoint>('MultiPoint', relative.inside1), b: geometry<LineString>('LineString', relative.inside2), intersect: false },
+
+    // MultiPoint <-> MultiLineString
+    { a: geometry<MultiPoint>('MultiPoint', [relative.inside1[0], relative.inside1[1]]), b: geometry<MultiLineString>('MultiLineString', [[relative.inside1[1], relative.inside1[2]], relative.outside1]), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', [relative.outside1[0], relative.outside1[1]]), b: geometry<MultiLineString>('MultiLineString', [[relative.outside1[1], relative.outside1[2]], relative.inside2]), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', [relative.outside1[0], center(relative.outside1[0], relative.outside1[1])]), b: geometry<MultiLineString>('MultiLineString', [relative.inside1, relative.outside1]), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', [relative.inside1[0], relative.inside1[1]]), b: geometry<MultiLineString>('MultiLineString', [relative.inside2, relative.outside1]), intersect: false },
+    { a: geometry<MultiPoint>('MultiPoint', relative.inside1), b: geometry<MultiLineString>('MultiLineString', [relative.inside2, relative.outside1]), intersect: false },
+
+    // MultiPoint <-> Polygon
+    { a: geometry<MultiPoint>('MultiPoint', relative.inside1), b: HolySee.polygon, intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', relative.partial), b: HolySee.polygon, intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', relative.outside1), b: HolySee.polygon, intersect: false },
+
+    // MultiPoint <-> MultiPolygon
+    { a: geometry<MultiPoint>('MultiPoint', relative.partial), b: Italy.multipolygon, intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', relative.outside1), b: Italy.multipolygon, intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', relative.inside1), b: Italy.multipolygon, intersect: false },
+
+    // MultiPoint <-> GeometryCollection
+    { a: geometry<MultiPoint>('MultiPoint', relative.partial), b: geometryCollection(Italy.multipolygon), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', relative.outside1), b: geometryCollection(HolySee.polygon), intersect: false },
+
+    // MultiPoint <-> Feature
+    { a: geometry<MultiPoint>('MultiPoint', [relative.inside1[0], relative.inside1[1]]), b: feature(geometry<MultiPoint>('MultiPoint', [relative.inside1[1], relative.inside1[2]])), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', relative.inside1), b: feature(geometry<MultiLineString>('MultiLineString', [relative.inside2, relative.outside1])), intersect: false },
+
+    // MultiPoint <-> FeatureCollection
+    { a: geometry<MultiPoint>('MultiPoint', [relative.inside1[0], relative.inside1[1]]), b: featureCollection(geometry<MultiPoint>('MultiPoint', [relative.inside1[1], relative.inside1[2]])), intersect: true },
+    { a: geometry<MultiPoint>('MultiPoint', relative.inside1), b: featureCollection(Italy.multipolygon), intersect: false },
+
+
+    // LineString <-> LineString
+    { a: geometry<LineString>('LineString', relative.inside1), b: geometry<LineString>('LineString', relative.inside2), intersect: true },
+    { a: geometry<LineString>('LineString', relative.inside1), b: geometry<LineString>('LineString', relative.outside1), intersect: false },
+    { a: geometry<LineString>('LineString', relative.inside1), b: geometry<LineString>('LineString', relative.outside2), intersect: false },
+
+    // Polygon <-> LineString
+    { a: HolySee.polygon, b: geometry<LineString>('LineString', relative.inside2), intersect: true },
+    { a: HolySee.polygon, b: geometry<LineString>('LineString', relative.partial), intersect: true },
+    { a: HolySee.polygon, b: geometry<LineString>('LineString', relative.outside2), intersect: false },
+
+    // MultiPolygon <-> LineString
+    { a: Italy.multipolygon, b: geometry<LineString>('LineString', relative.partial), intersect: true },
+    { a: Italy.multipolygon, b: geometry<LineString>('LineString', relative.outside2), intersect: true },
+    { a: Italy.multipolygon, b: geometry<LineString>('LineString', relative.inside2), intersect: false },
+
+    // GeometryCollection <-> LineString
+    { a: geometryCollection(geometry<LineString>('LineString', relative.inside1)), b: geometry<LineString>('LineString', relative.inside2), intersect: true },
+    { a: geometryCollection(HolySee.polygon), b: geometry<LineString>('LineString', relative.outside2), intersect: false },
+
+    // Feature <-> LineString
+    { a: feature(HolySee.polygon), b: geometry<LineString>('LineString', relative.inside2), intersect: true },
+    { a: feature(geometry<LineString>('LineString', relative.inside1)), b: geometry<LineString>('LineString', relative.outside1), intersect: false },
+
+    // FeatureCollection <-> LineString
+    { a: featureCollection(HolySee.polygon), b: geometry<LineString>('LineString', relative.partial), intersect: true },
+    { a: featureCollection(Italy.multipolygon), b: geometry<LineString>('LineString', relative.inside2), intersect: false },
+
+
+    // MultiLineString <-> LineString
+    { a: geometry<MultiLineString>('MultiLineString', [relative.partial, relative.inside1]), b: geometry<LineString>('LineString', relative.inside2), intersect: true },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.partial, relative.outside1]), b: geometry<LineString>('LineString', relative.inside2), intersect: false },
+
+    // MultiLineString <-> MultiLineString
+    { a: geometry<MultiLineString>('MultiLineString', [relative.partial, relative.inside2]), b: geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.inside1]), intersect: true },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.outside2]), b: geometry<MultiLineString>('MultiLineString', [relative.inside1, relative.inside2]), intersect: false },
+
+    // MultiLineString <-> Polygon
+    { a: geometry<MultiLineString>('MultiLineString', [relative.inside1, relative.outside2]), b: HolySee.polygon, intersect: true },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.partial, relative.outside2]), b: HolySee.polygon, intersect: true },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.outside2]), b: HolySee.polygon, intersect: false },
+
+    // MultiLineString <-> MultiPolygon
+    { a: geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.outside2]), b: Italy.multipolygon, intersect: true },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.outside2, relative.partial]), b: Italy.multipolygon, intersect: true },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.inside1, relative.inside2]), b: Italy.multipolygon, intersect: false },
+
+    // MultiLineString <-> GeometryCollection
+    { a: geometry<MultiLineString>('MultiLineString', [relative.partial, relative.inside2]), b: geometryCollection(geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.inside1])), intersect: true },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.inside1, relative.inside2]), b: geometryCollection(Italy.multipolygon), intersect: false },
+
+    // MultiLineString <-> Feature
+    { a: geometry<MultiLineString>('MultiLineString', [relative.partial, relative.inside1]), b: feature(geometry<LineString>('LineString', relative.inside2)), intersect: true },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.outside2]), b: feature(HolySee.polygon), intersect: false },
+
+    // MultiLineString <-> FeatureCollection
+    { a: geometry<MultiLineString>('MultiLineString', [relative.inside1, relative.inside2]), b: featureCollection(Italy.multipolygon), intersect: false },
+    { a: geometry<MultiLineString>('MultiLineString', [relative.outside1, relative.outside2]), b: featureCollection(geometry<MultiLineString>('MultiLineString', [relative.inside1, relative.inside2])), intersect: false },
+
+
+    // Polygon <-> Polygon
+    { a: geometry<Polygon>('Polygon', [Italy.coordinates[0][0]]), b: HolySee.polygon, intersect: true },
+    { a: geometry<Polygon>('Polygon', [Italy.coordinates[0][0]]), b: SanMarino.polygon, intersect: true },
+    { a: SanMarino.polygon, b: HolySee.polygon, intersect: false },
+
+    // Polygon <-> MultiPolygon
+    { a: HolySee.polygon, b: geometry<MultiPolygon>('MultiPolygon', [[Italy.coordinates[0][0]], [Italy.coordinates[1]]]), intersect: true },
+    { a: SanMarino.polygon, b: geometry<MultiPolygon>('MultiPolygon', [[Italy.coordinates[0][0]], [Italy.coordinates[1]]]), intersect: true },
+    { a: geometry<Polygon>('Polygon', Italy.coordinates[1]), b: geometry<MultiPolygon>('MultiPolygon', [HolySee.polygon.coordinates, SanMarino.polygon.coordinates]), intersect: false },
+
+    // Polygon <-> GeometryCollection
+    { a: geometry<Polygon>('Polygon', [Italy.coordinates[0][0]]), b: geometryCollection(HolySee.polygon), intersect: true },
+    { a: SanMarino.polygon, b: geometryCollection(HolySee.polygon), intersect: false },
+
+    // Polygon <-> Feature
+    { a: HolySee.polygon, b: feature(geometry<MultiPolygon>('MultiPolygon', [[Italy.coordinates[0][0]], [Italy.coordinates[1]]])), intersect: true },
+    { a: geometry<Polygon>('Polygon', Italy.coordinates[1]), b: feature(geometry<MultiPolygon>('MultiPolygon', [HolySee.polygon.coordinates, SanMarino.polygon.coordinates])), intersect: false },
+
+    // Polygon <-> FeatureCollection
+    { a: geometry<Polygon>('Polygon', [Italy.coordinates[0][0]]), b: featureCollection(SanMarino.polygon), intersect: true },
+    { a: SanMarino.polygon, b: featureCollection(HolySee.polygon), intersect: false },
+
+
+    // MultiPolygon <-> MultiPolygon
+    { a: Italy.multipolygon, b: geometry<MultiPolygon>('MultiPolygon', [HolySee.polygon.coordinates, SanMarino.polygon.coordinates]), intersect: true },
+    { a: geometry<MultiPolygon>('MultiPolygon', [HolySee.polygon.coordinates, SanMarino.polygon.coordinates]), b: geometry<MultiPolygon>('MultiPolygon', Italy.coordinates.slice(1)), intersect: false },
+
+    // MultiPolygon <-> GeometryCollection
+    { a: Italy.multipolygon, b: geometryCollection(geometry<MultiPolygon>('MultiPolygon', [HolySee.polygon.coordinates, SanMarino.polygon.coordinates])), intersect: true },
+    { a: geometry<MultiPolygon>('MultiPolygon', [HolySee.polygon.coordinates, SanMarino.polygon.coordinates]), b: geometryCollection(geometry<MultiPolygon>('MultiPolygon', Italy.coordinates.slice(1))), intersect: false },
+
+    // MultiPolygon <-> Feature
+    { a: Italy.multipolygon, b: feature(geometry<MultiPolygon>('MultiPolygon', [HolySee.polygon.coordinates, SanMarino.polygon.coordinates])), intersect: true },
+    { a: geometry<MultiPolygon>('MultiPolygon', [HolySee.polygon.coordinates, SanMarino.polygon.coordinates]), b: feature(geometry<MultiPolygon>('MultiPolygon', Italy.coordinates.slice(1))), intersect: false },
+
+    // MultiPolygon <-> FeatureCollection];
+    { a: Italy.multipolygon, b: featureCollection(geometry<MultiPolygon>('MultiPolygon', [HolySee.polygon.coordinates, SanMarino.polygon.coordinates])), intersect: true },
+    { a: geometry<MultiPolygon>('MultiPolygon', [HolySee.polygon.coordinates, SanMarino.polygon.coordinates]), b: featureCollection(geometry<MultiPolygon>('MultiPolygon', Italy.coordinates.slice(1))), intersect: false },
+
+
+    // GeometryCollection <-> GeometryCollection
+    { a: geometryCollection(geometry<Point>('Point', relative.outside1[1])), b: geometryCollection(geometry<LineString>('LineString', relative.outside1)), intersect: true },
+    { a: geometryCollection(geometry<Point>('Point', relative.outside1[1])), b: geometryCollection(geometry<LineString>('LineString', relative.outside2)), intersect: false },
+
+    // GeometryCollection <-> Feature
+    { a: geometryCollection(geometry<Point>('Point', relative.outside1[1])), b: feature(geometry<LineString>('LineString', relative.outside1)), intersect: true },
+    { a: geometryCollection(geometry<Point>('Point', relative.outside1[1])), b: feature(geometry<LineString>('LineString', relative.outside2)), intersect: false },
+
+    // GeometryCollection <-> FeatureCollection
+    { a: geometryCollection(geometry<Point>('Point', relative.outside1[1])), b: featureCollection(geometry<LineString>('LineString', relative.outside1)), intersect: true },
+    { a: geometryCollection(geometry<Point>('Point', relative.outside1[1])), b: featureCollection(geometry<LineString>('LineString', relative.outside2)), intersect: false },
+
+
+    // Feature <-> Feature
+    { a: feature(geometry<Point>('Point', relative.outside1[1])), b: feature(geometry<LineString>('LineString', relative.outside1)), intersect: true },
+    { a: feature(geometry<Point>('Point', relative.outside1[1])), b: feature(geometry<LineString>('LineString', relative.outside2)), intersect: false },
+
+    // Feature <-> FeatureCollection
+    { a: feature(geometry<Point>('Point', relative.outside1[1])), b: featureCollection(geometry<LineString>('LineString', relative.outside1)), intersect: true },
+    { a: feature(geometry<Point>('Point', relative.outside1[1])), b: featureCollection(geometry<LineString>('LineString', relative.outside2)), intersect: false },
+
+
+    // FeatureCollection <-> FeatureCollection
+    { a: featureCollection(geometry<Point>('Point', relative.outside1[1])), b: featureCollection(geometry<LineString>('LineString', relative.outside1)), intersect: true },
+    { a: featureCollection(geometry<Point>('Point', relative.outside1[1])), b: featureCollection(geometry<LineString>('LineString', relative.outside2)), intersect: false },
+
+    // Impossible <-> Possible
+    { a: { type: 'Impossible', coordinates: [0, 0] } as any, b: geometry<Point>('Point', [0, 0]), intersect: false },
+    { a: geometry<Point>('Point', [0, 0]), b: { type: 'Impossible', coordinates: [0, 0] } as any, intersect: false },
+];