@konfirm/geojson 1.0.0

package/dist/main.d.ts

@@ -0,0 +1,15 @@
+export { intersect } from './Domain/Utility/Intersect';
+export { distance } from './Domain/Utility/Distance';
+export { SimpleGeometryIterator } from './Domain/Iterator/SimpleGeometry';
+export { Position, isPosition, isStrictPosition } from './Domain/GeoJSON/Concept/Position';
+export { Point, isPoint, isStrictPoint } from './Domain/GeoJSON/Geometry/Point';
+export { MultiPoint, isMultiPoint, isStrictMultiPoint } from './Domain/GeoJSON/Geometry/MultiPoint';
+export { LineString, isLineString, isStrictLineString } from './Domain/GeoJSON/Geometry/LineString';
+export { MultiLineString, isMultiLineString, isStrictMultiLineString } from './Domain/GeoJSON/Geometry/MultiLineString';
+export { Polygon, isPolygon, isStrictPolygon } from './Domain/GeoJSON/Geometry/Polygon';
+export { MultiPolygon, isMultiPolygon, isStrictMultiPolygon } from './Domain/GeoJSON/Geometry/MultiPolygon';
+export { GeometryCollection, isGeometryCollection, isStrictGeometryCollection } from './Domain/GeoJSON/GeometryCollection';
+export { Geometry, isGeometry, isStrictGeometry } from './Domain/GeoJSON/Geometry';
+export { Feature, isFeature, isStrictFeature } from './Domain/GeoJSON/Feature';
+export { FeatureCollection, isFeatureCollection, isStrictFeatureCollection } from './Domain/GeoJSON/FeatureCollection';
+export { GeoJSON, isGeoJSON, isStrictGeoJSON } from './Domain/GeoJSON/GeoJSON';

package/package.json

@@ -0,0 +1,63 @@
+{
+	"name": "@konfirm/geojson",
+	"version": "1.0.0",
+	"description": "GeoJSON implementation",
+	"iife": "dist/geojson.js",
+	"main": "dist/geojson.cjs.js",
+	"module": "dist/geojson.es.js",
+	"types": "dist/geojson.d.ts",
+	"exports": {
+		".": {
+			"types": "./source/main.ts",
+			"import": "./dist/geojson.es.js",
+			"require": "./dist/geojson.cjs.js"
+		}
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/konfirm/geojson.git"
+	},
+	"bugs": {
+		"url": "https://github.com/konfirm/geojson/issues"
+	},
+	"scripts": {
+		"test": "run-script-os",
+		"test:nix": "ts-node node_modules/tape/bin/tape 'test/**/*.ts'",
+		"test:win32": "ts-node node_modules/tape/bin/tape test/**/*.ts",
+		"test:coverage": "run-script-os",
+		"test:coverage:nix": "nyc --reporter=html --require ts-node/register tape 'test/**/*.ts' | tap-arc",
+		"test:coverage:win32": "nyc --reporter=html --require ts-node/register tape test/**/*.ts | tap-arc",
+		"test:pretty": "run-script-os",
+		"test:pretty:nix": "nyc --require ts-node/register tape 'test/**/*.ts' | tap-arc",
+		"test:pretty:win32": "nyc --require ts-node/register tape test/**/*.ts | tap-arc",
+		"prebuild": "tsc --declarationDir temp --declaration true --emitDeclarationOnly true",
+		"build": "rollup -c rollup.config.mjs",
+		"postbuild": "rm -rf temp",
+		"prepublish": "npm run build"
+	},
+	"keywords": [
+		"geojson"
+	],
+	"author": "Rogier Spieker <rogier+npm@konfirm.eu>",
+	"license": "MIT",
+	"devDependencies": {
+		"@rollup/plugin-commonjs": "^24.0.1",
+		"@rollup/plugin-node-resolve": "^15.0.1",
+		"@rollup/plugin-terser": "^0.4.0",
+		"@rollup/plugin-typescript": "^11.0.0",
+		"@types/tape": "^4.13.2",
+		"nyc": "^15.1.0",
+		"rollup": "^3.14.0",
+		"rollup-plugin-dts": "^5.1.1",
+		"run-script-os": "^1.1.6",
+		"tap-arc": "^0.3.5",
+		"tape": "^5.6.3",
+		"template-literal-each": "^3.0.0",
+		"ts-node": "^10.9.1",
+		"tslib": "^2.5.0",
+		"typescript": "^4.9.5"
+	},
+	"dependencies": {
+		"@konfirm/guard": "^2.0.0"
+	}
+}

package/rollup.config.mjs

@@ -0,0 +1,43 @@
+import { readFileSync } from 'node:fs';
+import typescript from '@rollup/plugin-typescript';
+import { nodeResolve as resolve } from '@rollup/plugin-node-resolve';
+import common from '@rollup/plugin-commonjs';
+import { default as terser } from '@rollup/plugin-terser';
+import declaration from 'rollup-plugin-dts'
+
+const { main, iife, module, types } = JSON.parse(readFileSync('./package.json'));
+
+const defaults = {
+	name: 'GeoJSON',
+	sourcemap: false,
+};
+
+function configure(...args) {
+	return args.reduce((carry, options) => {
+		const basic = { ...defaults, ...options };
+		const min = {
+			...basic,
+			file: basic.file.replace(/(\.[a-z]+)$/, '.min$1'),
+			plugins: [terser({ format: { comments: false } })],
+		};
+
+		return carry.concat(basic, min);
+	}, []);
+}
+
+export default [
+	{
+		input: 'source/main.ts',
+		output: configure(
+			{ file: main, format: 'cjs' },
+			{ file: iife, format: 'iife' },
+			{ file: module, format: 'es' },
+		),
+		plugins: [resolve(), common(), typescript(), common()],
+	},
+	{
+		input: 'temp/main.d.ts',
+		output: { file: types, format: 'es' },
+		plugins: [declaration()],
+	}
+];

package/source/Domain/Constants.ts

@@ -0,0 +1,5 @@
+export const EARTH_RADIUS = 6_371_008.7714;         // mean radius
+export const EARTH_RADIUS_MAJOR = 6_378_137;        // equatorial radius
+export const EARTH_RADIUS_MINOR = 6_356_752.314_245; // semiminor axis
+export const EARTH_FLATTENING = 298.257_223_563;
+export const GPS_SATELLITE_ORBIT = 20_180_000;

package/source/Domain/GeoJSON/Concept/Altitude.ts

@@ -0,0 +1,9 @@
+import { EARTH_RADIUS, GPS_SATELLITE_ORBIT } from "../../Constants";
+import { isNumberBetween, isNumberValue } from "../../Guards/Number";
+
+export type Altitude = number;
+export function isAltitude(value: any): value is Altitude {
+	return isNumberValue(value);
+}
+
+export const isStrictAltitude = isNumberBetween<Altitude>(-EARTH_RADIUS, GPS_SATELLITE_ORBIT);

package/source/Domain/GeoJSON/Concept/BoundingBox.ts

@@ -0,0 +1,31 @@
+import { all, any } from "@konfirm/guard";
+import { isTuple } from "../../Guards/Tuple";
+import { isLongitude, Longitude, isStrictLongitude } from "./Longitude";
+import { isLatitude, Latitude, isStrictLatitude } from "./Latitude";
+import { Altitude, isAltitude, isStrictAltitude } from "./Altitude";
+
+export type BoundingBox
+	= [Longitude, Latitude, Altitude, Longitude, Latitude, Altitude]
+	| [Longitude, Latitude, Longitude, Latitude];
+const isBoundingBoxWithAltitude = all(
+	isTuple(isLongitude, isLatitude, isAltitude, isLongitude, isLatitude, isAltitude),
+	([, s, , , n]) => s <= n
+)
+const isBoundingBoxWithoutAltitude = all(
+	isTuple(isLongitude, isLatitude, isLongitude, isLatitude),
+	([, s, , n]) => s <= n
+)
+export const isBoundingBox = any<BoundingBox>(
+	isBoundingBoxWithAltitude,
+	isBoundingBoxWithoutAltitude
+);
+export const isStrictBoundingBox = any<BoundingBox>(
+	all(
+		isTuple(isStrictLongitude, isStrictLatitude, isStrictAltitude, isStrictLongitude, isStrictLatitude, isStrictAltitude),
+		isBoundingBoxWithAltitude
+	),
+	all(
+		isTuple(isStrictLongitude, isStrictLatitude, isStrictLongitude, isStrictLatitude),
+		isBoundingBoxWithoutAltitude
+	),
+);

package/source/Domain/GeoJSON/Concept/ExteriorRing.ts

@@ -0,0 +1,12 @@
+import { all } from "@konfirm/guard";
+import { isCounterClockwiseWinding } from "../../Utility/Winding";
+import { isLinearRing, isStrictLinearRing, LinearRing } from "./LinearRing";
+
+export type ExteriorRing = LinearRing;
+export const isExteriorRing = all<ExteriorRing>(
+	isLinearRing,
+);
+export const isStrictExteriorRing = all<ExteriorRing>(
+	isStrictLinearRing,
+	isCounterClockwiseWinding
+);

package/source/Domain/GeoJSON/Concept/GeoJSONObject.ts

@@ -0,0 +1,23 @@
+import { all, Guard, isString, isStructure } from "@konfirm/guard";
+import { BoundingBox, isBoundingBox, isStrictBoundingBox } from "./BoundingBox";
+
+type GeoJSONBase = {
+	type: string;
+	bbox?: BoundingBox;
+	[key: string]: unknown;
+}
+export type GeoJSONObject<T extends GeoJSONBase = GeoJSONBase>
+	= GeoJSONBase
+	& T;
+export function isGeoJSONObject<T extends GeoJSONBase>(type: string): Guard<T> {
+	return isStructure<T>({
+		type: all(isString, (value: any) => value === type),
+		bbox: isBoundingBox,
+	}, 'bbox');
+}
+export function isStrictGeoJSONObject<T extends GeoJSONBase>(type: string): Guard<T> {
+	return isStructure<T>({
+		type: all(isString, (value: any) => value === type),
+		bbox: isStrictBoundingBox,
+	}, 'bbox');
+}

package/source/Domain/GeoJSON/Concept/InteriorRing.ts

@@ -0,0 +1,12 @@
+import { all } from "@konfirm/guard";
+import { isClockwiseWinding } from "../../Utility/Winding";
+import { isLinearRing, isStrictLinearRing, LinearRing } from "./LinearRing";
+
+export type InteriorRing = LinearRing;
+export const isInteriorRing = all<InteriorRing>(
+	isLinearRing,
+);
+export const isStrictInteriorRing = all<InteriorRing>(
+	isStrictLinearRing,
+	isClockwiseWinding
+);

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

@@ -0,0 +1,7 @@
+import { isNumberBetween, isNumberValue } from "../../Guards/Number";
+
+export type Latitude = number;
+export function isLatitude(value: any): value is Latitude {
+	return isNumberValue(value);
+}
+export const isStrictLatitude = isNumberBetween<Latitude>(-90, 90);

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

@@ -0,0 +1,14 @@
+import { all, isArrayOfSize, isArrayOfType } from "@konfirm/guard";
+import { isPosition, isStrictPosition, Position } from "./Position";
+
+export type LinearRing = Array<Position>;
+export const isLinearRing = all<LinearRing>(
+	isArrayOfType(isPosition),
+	isArrayOfSize(4),
+	(value: Array<Position>) => value[value.length - 1].every((v, i) => v === value[0][i])
+);
+export const isStrictLinearRing = all<LinearRing>(
+	isArrayOfType(isStrictPosition),
+	isArrayOfSize(4),
+	(value: Array<Position>) => value[value.length - 1].every((v, i) => v === value[0][i])
+);

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

@@ -0,0 +1,7 @@
+import { isNumberBetween, isNumberValue } from "../../Guards/Number";
+
+export type Longitude = number;
+export function isLongitude(value: any): value is Longitude {
+	return isNumberValue(value);
+}
+export const isStrictLongitude = isNumberBetween<Longitude>(-180, 180);

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

@@ -0,0 +1,18 @@
+import { any } from "@konfirm/guard";
+import { isTuple } from "../../Guards/Tuple";
+import { Altitude, isAltitude, isStrictAltitude } from "./Altitude";
+import { isLatitude, isStrictLatitude, Latitude } from "./Latitude";
+import { isLongitude, isStrictLongitude, Longitude } from "./Longitude";
+
+export type Position = [Longitude, Latitude, Altitude?];
+export const isPosition = any<Position>(
+	isTuple(isLongitude, isLatitude),
+	isTuple(isLongitude, isLatitude, isAltitude)
+);
+export const isStrictPosition = any<Position>(
+	isTuple(isStrictLongitude, isStrictLatitude),
+	isTuple(isStrictLongitude, isStrictLatitude, isStrictAltitude),
+);
+export function isEquivalentPosition(one: any, two: any): boolean {
+	return isPosition(one) && isPosition(two) && one.length === two.length && one.every((v, i) => v === two[i]);
+}

package/source/Domain/GeoJSON/Feature.ts

@@ -0,0 +1,24 @@
+import { all, any, isNULL, isObject, isStructure } from "@konfirm/guard";
+import { GeoJSONObject, isGeoJSONObject } from "./Concept/GeoJSONObject";
+import { Geometry, isGeometry, isStrictGeometry } from "./Geometry";
+import { GeometryCollection, isGeometryCollection, isStrictGeometryCollection } from "./GeometryCollection";
+
+export type Feature = GeoJSONObject<{
+	type: 'Feature';
+	geometry: Geometry | GeometryCollection;
+	properties: { [key: string]: unknown } | null;
+}>
+export const isFeature = all<Feature>(
+	isGeoJSONObject('Feature'),
+	isStructure({
+		geometry: any(isGeometry, isGeometryCollection),
+		properties: any(isNULL, isObject)
+	})
+);
+export const isStrictFeature = all<Feature>(
+	isGeoJSONObject('Feature'),
+	isStructure({
+		geometry: any(isStrictGeometry, isStrictGeometryCollection),
+		properties: any(isNULL, isObject)
+	})
+);

package/source/Domain/GeoJSON/FeatureCollection.ts

@@ -0,0 +1,16 @@
+import { all, isArrayOfType, isKeyOfType } from "@konfirm/guard";
+import { Feature, isFeature, isStrictFeature } from "./Feature";
+import { GeoJSONObject, isGeoJSONObject } from "./Concept/GeoJSONObject";
+
+export type FeatureCollection = GeoJSONObject<{
+	type: 'FeatureCollection';
+	features: Array<Feature>;
+}>
+export const isFeatureCollection = all<FeatureCollection>(
+	isGeoJSONObject('FeatureCollection'),
+	isKeyOfType('features', isArrayOfType(isFeature))
+);
+export const isStrictFeatureCollection = all<FeatureCollection>(
+	isGeoJSONObject('FeatureCollection'),
+	isKeyOfType('features', isArrayOfType(isStrictFeature))
+);

package/source/Domain/GeoJSON/GeoJSON.ts

@@ -0,0 +1,9 @@
+import { any } from "@konfirm/guard";
+import { Feature, isFeature, isStrictFeature } from "./Feature";
+import { FeatureCollection, isFeatureCollection, isStrictFeatureCollection } from "./FeatureCollection";
+import { GeometryCollection, isGeometryCollection, isStrictGeometryCollection } from "./GeometryCollection";
+import { Geometry, isGeometry, isStrictGeometry } from "./Geometry";
+
+export type GeoJSON = Geometry | GeometryCollection | Feature | FeatureCollection;
+export const isGeoJSON = any<GeoJSON>(isGeometry, isGeometryCollection, isFeature, isFeatureCollection);
+export const isStrictGeoJSON = any<GeoJSON>(isStrictGeometry, isStrictGeometryCollection, isStrictFeature, isStrictFeatureCollection);

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

@@ -0,0 +1,12 @@
+import { Guard } from "../../Guards/Utility";
+import { GeometryObject, isGeometryObject } from "../GeometryObject";
+import { isMultiPointCoordinates, isStrictMultiPointCoordinates, MultiPoint } from "./MultiPoint";
+
+export type LineString = GeometryObject<{
+	type: 'LineString';
+	coordinates: MultiPoint['coordinates'];
+}>
+export const isLineStringCoordinates = isMultiPointCoordinates;
+export const isLineString: Guard<LineString> = isGeometryObject<LineString>('LineString', isLineStringCoordinates);
+export const isStrictLineStringCoordinates = isStrictMultiPointCoordinates;
+export const isStrictLineString: Guard<LineString> = isGeometryObject<LineString>('LineString', isStrictLineStringCoordinates);

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

@@ -0,0 +1,9 @@
+import { isArrayOfType } from "@konfirm/guard";
+import { isGeometryObject, MultiGeometryObject } from "../GeometryObject";
+import { isLineStringCoordinates, isStrictLineStringCoordinates, LineString } from "./LineString";
+
+export type MultiLineString = MultiGeometryObject<LineString>;
+export const isMultiLineStringCoordinates = isArrayOfType(isLineStringCoordinates);
+export const isMultiLineString = isGeometryObject<MultiLineString>('MultiLineString', isMultiLineStringCoordinates);
+export const isStrictMultiLineStringCoordinates = isArrayOfType(isStrictLineStringCoordinates);
+export const isStrictMultiLineString = isGeometryObject<MultiLineString>('MultiLineString', isStrictMultiLineStringCoordinates);

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

@@ -0,0 +1,10 @@
+import { isArrayOfType } from "@konfirm/guard";
+import { Guard } from "../../Guards/Utility";
+import { isGeometryObject, MultiGeometryObject } from "../GeometryObject";
+import { isPointCoordinates, isStrictPointCoordinates, Point } from "./Point";
+
+export type MultiPoint = MultiGeometryObject<Point>
+export const isMultiPointCoordinates: Guard<MultiPoint['coordinates']> = isArrayOfType(isPointCoordinates)
+export const isMultiPoint = isGeometryObject<MultiPoint>('MultiPoint', isMultiPointCoordinates);
+export const isStrictMultiPointCoordinates: Guard<MultiPoint['coordinates']> = isArrayOfType(isStrictPointCoordinates)
+export const isStrictMultiPoint = isGeometryObject<MultiPoint>('MultiPoint', isStrictMultiPointCoordinates);

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

@@ -0,0 +1,9 @@
+import { isArrayOfType } from "@konfirm/guard";
+import { isGeometryObject, MultiGeometryObject } from "../GeometryObject";
+import { isPolygonCoordinates, isStrictPolygonCoordinates, Polygon } from "./Polygon";
+
+export type MultiPolygon = MultiGeometryObject<Polygon>
+export const isMultiPolygonCoordinates = isArrayOfType(isPolygonCoordinates);
+export const isMultiPolygon = isGeometryObject<MultiPolygon>('MultiPolygon', isMultiPolygonCoordinates);
+export const isStrictMultiPolygonCoordinates = isArrayOfType(isStrictPolygonCoordinates);
+export const isStrictMultiPolygon = isGeometryObject<MultiPolygon>('MultiPolygon', isStrictMultiPolygonCoordinates);

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

@@ -0,0 +1,12 @@
+import { GeometryObject, isGeometryObject } from "../GeometryObject";
+import { isPosition, isStrictPosition, Position } from "../Concept/Position";
+import { Guard } from "../../Guards/Utility";
+
+export type Point = GeometryObject<{
+	type: 'Point';
+	coordinates: Position;
+}>
+export const isPointCoordinates: Guard<Point['coordinates']> = isPosition;
+export const isPoint: Guard<Point> = isGeometryObject<Point>('Point', isPointCoordinates);
+export const isStrictPointCoordinates: Guard<Point['coordinates']> = isStrictPosition;
+export const isStrictPoint: Guard<Point> = isGeometryObject<Point>('Point', isStrictPointCoordinates);

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

@@ -0,0 +1,20 @@
+import { all, isArrayOfType } from "@konfirm/guard";
+import { GeometryObject, isGeometryObject } from "../GeometryObject";
+import { ExteriorRing, isExteriorRing } from "../Concept/ExteriorRing";
+import { InteriorRing, isInteriorRing } from "../Concept/InteriorRing";
+import { isLinearRing, isStrictLinearRing } from "../Concept/LinearRing";
+
+export type Polygon = GeometryObject<{
+	type: 'Polygon';
+	coordinates: [ExteriorRing, ...Array<InteriorRing>];
+}>
+export const isPolygonCoordinates = all(
+	isArrayOfType(isLinearRing)
+);
+export const isPolygon = isGeometryObject<Polygon>('Polygon', isPolygonCoordinates);
+export const isStrictPolygonCoordinates = all(
+	isArrayOfType(isStrictLinearRing),
+	(value: any) => isExteriorRing(value[0]),
+	(value: any) => value.slice(1).every(isInteriorRing)
+);
+export const isStrictPolygon = isGeometryObject<Polygon>('Polygon', isStrictPolygonCoordinates);

package/source/Domain/GeoJSON/Geometry.ts

@@ -0,0 +1,11 @@
+import { any } from "@konfirm/guard";
+import { isLineString, isStrictLineString, LineString } from "./Geometry/LineString";
+import { isMultiLineString, isStrictMultiLineString, MultiLineString } from "./Geometry/MultiLineString";
+import { isMultiPoint, isStrictMultiPoint, MultiPoint } from "./Geometry/MultiPoint";
+import { isMultiPolygon, isStrictMultiPolygon, MultiPolygon } from "./Geometry/MultiPolygon";
+import { isPoint, isStrictPoint, Point } from "./Geometry/Point";
+import { isPolygon, isStrictPolygon, Polygon } from "./Geometry/Polygon";
+
+export type Geometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon;
+export const isGeometry = any<Geometry>(isPoint, isMultiPoint, isLineString, isMultiLineString, isPolygon, isMultiPolygon);
+export const isStrictGeometry = any<Geometry>(isStrictPoint, isStrictMultiPoint, isStrictLineString, isStrictMultiLineString, isStrictPolygon, isStrictMultiPolygon);

package/source/Domain/GeoJSON/GeometryCollection.ts

@@ -0,0 +1,23 @@
+import { all, any, isArrayOfType, isKeyOfType } from "@konfirm/guard";
+import { GeoJSONObject, isGeoJSONObject } from "./Concept/GeoJSONObject";
+import { Geometry, isGeometry, isStrictGeometry } from "./Geometry";
+
+export type GeometryCollection = GeoJSONObject<{
+	type: 'GeometryCollection';
+	geometries: Array<Geometry | GeometryCollection>;
+}>;
+
+const isGeometryCollectionObject = all<GeometryCollection>(
+	isGeoJSONObject('GeometryCollection'),
+	isKeyOfType('geometries', isArrayOfType(any(isGeometry, isGeometryCollection)))
+);
+const isStrictGeometryCollectionObject = all<GeometryCollection>(
+	isGeoJSONObject('GeometryCollection'),
+	isKeyOfType('geometries', isArrayOfType(any(isStrictGeometry, isStrictGeometryCollection)))
+);
+export function isGeometryCollection(value: any): value is GeometryCollection {
+	return isGeometryCollectionObject(value)
+}
+export function isStrictGeometryCollection(value: any): value is GeometryCollection {
+	return isStrictGeometryCollectionObject(value)
+}

package/source/Domain/GeoJSON/GeometryObject.ts

@@ -0,0 +1,20 @@
+import { all, Guard, isKeyOfType, Validator } from "@konfirm/guard";
+import { GeoJSONObject, isGeoJSONObject } from "./Concept/GeoJSONObject";
+
+type GeometryBase = GeoJSONObject & {
+	coordinates: Array<unknown>;
+}
+
+export type GeometryObject<T extends GeometryBase>
+	= Omit<GeometryBase, 'coordinates'>
+	& T;
+export type MultiGeometryObject<T extends GeometryBase> = GeometryObject<{
+	type: `Multi${T['type']}`;
+	coordinates: Array<T['coordinates']>;
+}>;
+export function isGeometryObject<T extends GeometryBase>(type: string, isCoordinates: Validator): Guard<T> {
+	return all<T>(
+		isGeoJSONObject(type),
+		isKeyOfType('coordinates', isCoordinates)
+	);
+}

package/source/Domain/Guards/Number.ts

@@ -0,0 +1,13 @@
+import { isNumber } from '@konfirm/guard';
+import { Guard } from './Utility';
+
+export function isNumberValue<T extends number>(value: any): value is T {
+	return isNumber(value) && Number.isFinite(value);
+}
+
+export function isNumberBetween<T extends number>(a: number, b: number = Infinity): Guard<T> {
+	const min = Math.min(a, b);
+	const max = Math.max(a, b);
+
+	return (value: any): value is T => isNumberValue(value) && value >= min && value <= max;
+}

package/source/Domain/Guards/Tuple.ts

@@ -0,0 +1,6 @@
+import { isArray, Validator } from "@konfirm/guard";
+import { Guard } from './Utility';
+
+export function isTuple<T extends Array<unknown>>(...rules: Array<Validator>): Guard<T> {
+	return (value: any): value is T => isArray(value) && value.length === rules.length && rules.every((rule, index) => rule(value[index]));
+}

package/source/Domain/Guards/Utility.ts

@@ -0,0 +1 @@
+export type Guard<T> = (value: any) => value is T;

package/source/Domain/Iterator/IterablePair.ts

@@ -0,0 +1,47 @@
+/**
+ * Iterator class which traverses all value pairs of two or more Iterable instances
+ *
+ * @export
+ * @class IterablePairIterator
+ * @template T
+ */
+export class IterablePairIterator<T = unknown> {
+    private readonly iterators: Array<Iterable<T>> = [];
+
+    /**
+     * Constructs a new instance of IterablePairIterator
+     * 
+     * @param iterators 
+     */
+    constructor(...iterators: [Iterable<T>, Iterable<T>, ...Array<Iterable<T>>]) {
+        this.iterators = iterators;
+    }
+
+    /**
+     * Generator yielding all value pairs from the provided iterators
+     *
+     * @return {*}  {Iterator<[T, T]>}
+     * @memberof IterablePairIterator
+     */
+    *[Symbol.iterator](): Iterator<[T, T]> {
+        for (const [a, b] of this.pairs(this.iterators)) {
+            for (const one of a) {
+                for (const two of b) {
+                    yield [one, two];
+                }
+            }
+        }
+    }
+
+    /**
+     * Create unique Iterator<T> combinations to traverse over
+     *
+     * @private
+     * @param {Array<Iterable<T>>} source
+     * @return {*}  {Array<[Iterable<T>, Iterable<T>]>}
+     * @memberof IterablePairIterator
+     */
+    private pairs(source: Array<Iterable<T>>): Array<[Iterable<T>, Iterable<T>]> {
+        return source.map((a, i) => source.slice(i + 1).map((b) => [a, b])).flat() as Array<[Iterable<T>, Iterable<T>]>;
+    }
+}