@konfirm/geojson 1.0.0

package/dist/geojson.cjs.js

@@ -0,0 +1,655 @@
+'use strict';
+
+function segments(line) {
+    return line.slice(1).map((point, index) => [line[index], point]);
+}
+
+const EARTH_RADIUS = 6371008.7714; // mean radius
+const EARTH_RADIUS_MAJOR = 6378137; // equatorial radius
+const EARTH_RADIUS_MINOR = 6356752.314245; // semiminor axis
+const EARTH_FLATTENING = 298.257223563;
+const GPS_SATELLITE_ORBIT = 20180000;
+
+const D2R = Math.PI / 180;
+const π = Math.PI;
+function constrain(value, min, max) {
+    return Math.max(Math.min(value, max), min);
+}
+function squared(n) {
+    return n * n;
+}
+function rad(n) {
+    return n * D2R;
+}
+const EARTH_RADIUS_MAJOR_SQUARED = squared(EARTH_RADIUS_MAJOR);
+const EARTH_RADIUS_MINOR_SQUARED = squared(EARTH_RADIUS_MINOR);
+const EARTH_RADIUS_FACTOR = (EARTH_RADIUS_MAJOR_SQUARED - EARTH_RADIUS_MINOR_SQUARED) / EARTH_RADIUS_MINOR_SQUARED;
+const EARTH_INVERSE_FLATTENING = 1 / EARTH_FLATTENING;
+const PointToPoint = {
+    cartesian([λa, φa], [λb, φb]) {
+        return EARTH_RADIUS * rad(Math.sqrt(squared(λb - λa) + squared(φb - φa)));
+    },
+    haversine([λa, φa], [λb, φb]) {
+        //https://www.movable-type.co.uk/scripts/latlong.html
+        const Δ = squared(Math.sin(rad(φb - φa) / 2)) + Math.cos(rad(φa)) * Math.cos(rad(φb)) * squared(Math.sin(rad(λb - λa) / 2));
+        return EARTH_RADIUS * Math.atan2(Math.sqrt(Δ), Math.sqrt(1 - Δ)) * 2;
+    },
+    vincenty(...points) {
+        //https://www.movable-type.co.uk/scripts/latlong-vincenty.html
+        const [[λ1, φ1], [λ2, φ2]] = points.map((p) => p.map(rad));
+        const L = λ2 - λ1; // L = difference in longitude, U = reduced latitude, defined by tan U = (1-f)·tanφ.
+        const tanU1 = (1 - EARTH_INVERSE_FLATTENING) * Math.tan(φ1), cosU1 = 1 / Math.sqrt((1 + tanU1 * tanU1)), sinU1 = tanU1 * cosU1;
+        const tanU2 = (1 - EARTH_INVERSE_FLATTENING) * Math.tan(φ2), cosU2 = 1 / Math.sqrt((1 + tanU2 * tanU2)), sinU2 = tanU2 * cosU2;
+        const antipodal = Math.abs(L) > π / 2 || Math.abs(φ2 - φ1) > π / 2;
+        let λ = L;
+        let sinλ = null;
+        let cosλ = null; // λ = difference in longitude on an auxiliary sphere
+        let σ = antipodal ? π : 0;
+        let sinσ = 0;
+        let cosσ = antipodal ? -1 : 1;
+        let sinSqσ = null; // σ = angular distance P₁ P₂ on the sphere
+        let cos2σₘ = 1; // σₘ = angular distance on the sphere from the equator to the midpoint of the line
+        let cosSqα = 1; // α = azimuth of the geodesic at the equator
+        let λʹ = null;
+        let iterations = 0;
+        do {
+            sinλ = Math.sin(λ);
+            cosλ = Math.cos(λ);
+            sinSqσ = (cosU2 * sinλ) ** 2 + (cosU1 * sinU2 - sinU1 * cosU2 * cosλ) ** 2;
+            if (Math.abs(sinSqσ) < 1e-24)
+                break; // co-incident/antipodal points (σ < ≈0.006mm)
+            sinσ = Math.sqrt(sinSqσ);
+            cosσ = sinU1 * sinU2 + cosU1 * cosU2 * cosλ;
+            σ = Math.atan2(sinσ, cosσ);
+            const sinα = cosU1 * cosU2 * sinλ / sinσ;
+            cosSqα = 1 - sinα * sinα;
+            cos2σₘ = (cosSqα != 0) ? (cosσ - 2 * sinU1 * sinU2 / cosSqα) : 0; // on equatorial line cos²α = 0 (§6)
+            const C = EARTH_INVERSE_FLATTENING / 16 * cosSqα * (4 + EARTH_INVERSE_FLATTENING * (4 - 3 * cosSqα));
+            λʹ = λ;
+            λ = L + (1 - C) * EARTH_INVERSE_FLATTENING * sinα * (σ + C * sinσ * (cos2σₘ + C * cosσ * (-1 + 2 * cos2σₘ * cos2σₘ)));
+            // TODO: add tests
+            // const iterationCheck = antipodal ? Math.abs(λ) - π : Math.abs(λ);
+            // if (iterationCheck > π) throw new EvalError('λ > π');
+        } while (Math.abs(λ - λʹ) > 1e-12 && ++iterations < 1000); // TV: 'iterate until negligible change in λ' (≈0.006mm)
+        // TODO: add tests
+        // if (iterations >= 1000) throw new EvalError('Vincenty formula failed to converge');
+        const uSq = cosSqα * EARTH_RADIUS_FACTOR;
+        const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+        const B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+        const Δσ = B * sinσ * (cos2σₘ + B / 4 * (cosσ * (-1 + 2 * cos2σₘ * cos2σₘ) - B / 6 * cos2σₘ * (-3 + 4 * sinσ * sinσ) * (-3 + 4 * cos2σₘ * cos2σₘ)));
+        return EARTH_RADIUS_MINOR * A * (σ - Δσ);
+    },
+};
+function getClosestPointOnLineByPoint(point, line) {
+    const [[px, py], [ax, ay], [bx, by]] = [point, ...line];
+    const [abx, aby] = [bx - ax, by - ay];
+    const [apx, apy] = [px - ax, py - ay];
+    const t = constrain((apx * abx + apy * aby) / (abx * abx + aby * aby), 0, 1);
+    return t === 0 || t === 1 ? line[t] : [ax + abx * t, ay + aby * t];
+}
+function getDistanceOfPointToPoint(a, b, calculation) {
+    const calc = typeof calculation === 'function' ? calculation : PointToPoint[calculation];
+    if (typeof calc === 'function') {
+        return calc(a, b);
+    }
+    throw new Error(`Not a PointToPoint calculation function ${calculation}`);
+}
+function getDistanceOfPointToLine(point, line, calculation) {
+    return getDistanceOfPointToPoint(point, getClosestPointOnLineByPoint(point, line), calculation);
+}
+function getDistanceOfLineToLine(a, b, calculation) {
+    return isLinesCrossing(a, b)
+        ? 0
+        : Math.min(...a.map((a) => getDistanceOfPointToLine(a, b, calculation)), ...b.map((b) => getDistanceOfPointToLine(b, a, calculation)));
+}
+function isLinesCrossing(a, b) {
+    const [[a1x, a1y], [a2x, a2y]] = a;
+    const [[b1x, b1y], [b2x, b2y]] = b;
+    const [s1x, s1y, s2x, s2y] = [a2x - a1x, a2y - a1y, b2x - b1x, b2y - b1y];
+    const s = (-s1y * (a1x - b1x) + s1x * (a1y - b1y)) / (-s2x * s1y + s1x * s2y);
+    const t = (s2x * (a1y - b1y) - s2y * (a1x - b1x)) / (-s2x * s1y + s1x * s2y);
+    return s >= 0 && s <= 1 && t >= 0 && t <= 1;
+}
+function isPointOnLine(point, line, threshold = 1e-14) {
+    return getDistanceOfPointToLine(point, line, 'cartesian') < threshold;
+}
+function isPointInRing(p, ring) {
+    const { length } = ring;
+    const odd = ring
+        .reduce((odd, a, i) => {
+        const b = ring[(length + i - 1) % length];
+        return (a[1] < p[1] && b[1] >= p[1] || b[1] < p[1] && a[1] >= p[1]) && (a[0] <= p[0] || b[0] <= p[0])
+            ? odd ^ Number(a[0] + (p[1] - a[1]) / (b[1] - a[1]) * (b[0] - a[0]) < p[0])
+            : odd;
+    }, 0);
+    return odd !== 0 || ring.slice(1).some((a, index) => isPointOnLine(p, [ring[index], a]));
+}
+
+/**
+ * Iterator class to turn any GeoJSON structure into one or more SimpleGeometry (Point | LineString | Polygon) objects
+ *
+ * @export
+ * @class SimpleGeometryIterator
+ */
+class SimpleGeometryIterator {
+    /**
+     *  Creates an instance of SimpleGeometryIterator
+     *
+     * @param {...[GeoJSON, ...Array<GeoJSON>]} inputs
+     * @memberof SimpleGeometryIterator
+     */
+    constructor(...inputs) {
+        this.inputs = [];
+        this.inputs = inputs;
+    }
+    /**
+     * Generator yielding all SimpleGeometry objects from the provided GeoJSON structure(s)
+     *
+     * @return {*}  {Iterator<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    *[Symbol.iterator]() {
+        for (const input of this.inputs) {
+            for (const simple of this.unwrap(input)) {
+                yield simple;
+            }
+        }
+    }
+    /**
+     * unwrap any GeoJSON object into one or more SimpleGeometry object
+     *
+     * @private
+     * @param {GeoJSON} geo
+     * @return {*}  {Iterable<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    *unwrap(geo) {
+        geo.type in this
+            ? yield* this[geo.type](geo)
+            : yield geo;
+    }
+    /**
+     * Generate the geometries in a GeometryCollection
+     *
+     * @private
+     * @param {GeometryCollection} { geometries }
+     * @return {*}  {Iterable<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    *GeometryCollection({ geometries }) {
+        for (const geometry of geometries) {
+            yield* this.unwrap(geometry);
+        }
+    }
+    /**
+     * Generate the geometries of the Feature object(s) in a FeatureCollection
+     *
+     * @private
+     * @param {FeatureCollection} { features }
+     * @return {*}  {Iterable<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    *FeatureCollection({ features }) {
+        for (const { geometry } of features) {
+            yield* this.unwrap(geometry);
+        }
+    }
+    /**
+     * Generate the geometry of a Feature object
+     *
+     * @private
+     * @param {Feature} { geometry }
+     * @return {*}  {Iterable<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    *Feature({ geometry }) {
+        yield* this.unwrap(geometry);
+    }
+    /**
+     * Generate Point objects from a MultiPoint object
+     *
+     * @private
+     * @param {MultiPoint} multi
+     * @return {*}  {Iterable<Point>}
+     * @memberof SimpleGeometryIterator
+     */
+    *MultiPoint(multi) {
+        for (const coordinates of multi.coordinates) {
+            yield { type: 'Point', coordinates };
+        }
+    }
+    /**
+     * Generate LineString objects from a MultiLineString object
+     *
+     * @private
+     * @param {MultiLineString} multi
+     * @return {*}  {Iterable<LineString>}
+     * @memberof SimpleGeometryIterator
+     */
+    *MultiLineString(multi) {
+        for (const coordinates of multi.coordinates) {
+            yield { type: 'LineString', coordinates };
+        }
+    }
+    /**
+     * Generate Polygon objects from a MultiPolygon object
+     *
+     * @private
+     * @param {MultiPolygon} multi
+     * @return {*}  {Iterable<Polygon>}
+     * @memberof SimpleGeometryIterator
+     */
+    *MultiPolygon(multi) {
+        for (const coordinates of multi.coordinates) {
+            yield { type: 'Polygon', coordinates };
+        }
+    }
+}
+
+/**
+ * Iterator class which traverses all value pairs of two or more Iterable instances
+ *
+ * @export
+ * @class IterablePairIterator
+ * @template T
+ */
+class IterablePairIterator {
+    /**
+     * Constructs a new instance of IterablePairIterator
+     *
+     * @param iterators
+     */
+    constructor(...iterators) {
+        this.iterators = [];
+        this.iterators = iterators;
+    }
+    /**
+     * Generator yielding all value pairs from the provided iterators
+     *
+     * @return {*}  {Iterator<[T, T]>}
+     * @memberof IterablePairIterator
+     */
+    *[Symbol.iterator]() {
+        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
+     */
+    pairs(source) {
+        return source.map((a, i) => source.slice(i + 1).map((b) => [a, b])).flat();
+    }
+}
+
+const geometries$1 = {
+    PointPoint(a, b) {
+        return a.length >= 2 && b.length >= 2 && a.slice(0, 2).every((v, i) => v === b[i]);
+    },
+    LineStringPoint(a, b) {
+        return a.some((a) => this.PointPoint(a, b)) || segments(a).some((line) => isPointOnLine(b, line));
+    },
+    LineStringLineString(a, b) {
+        const lines = segments(b);
+        return segments(a).some((a) => lines.some((b) => isLinesCrossing(a, b)));
+    },
+    PolygonPoint([exterior, ...interior], b) {
+        return (this.LineStringPoint(exterior, b) || isPointInRing(b, exterior)) && (!interior.length || interior.every((ring) => !isPointInRing(b, ring)));
+    },
+    PolygonLineString(a, b) {
+        return a.some((ring) => this.LineStringLineString(ring, b)) || b.some((point) => this.PolygonPoint(a, point));
+    },
+    PolygonPolygon(a, b) {
+        return b.some((b1) => this.PolygonLineString(a, b1) || b1.some((b2) => this.PolygonPoint(a, b2)))
+            || a.some((a1) => this.PolygonLineString(b, a1) || a1.some((a2) => this.PolygonPoint(b, a2)));
+    },
+};
+function intersect(a, b) {
+    for (const [itA, itB] of new IterablePairIterator(new SimpleGeometryIterator(a), new SimpleGeometryIterator(b))) {
+        if ((itA.type + itB.type in geometries$1 && geometries$1[itA.type + itB.type](itA.coordinates, itB.coordinates)) || (itB.type + itA.type in geometries$1 && geometries$1[itB.type + itA.type](itB.coordinates, itA.coordinates))) {
+            return true;
+        }
+    }
+    return false;
+}
+
+const geometries = {
+    PointPoint(a, b, calculation) {
+        return getDistanceOfPointToPoint(a, b, calculation);
+    },
+    LineStringPoint(a, b, calculation) {
+        return Math.min(...segments(a).map((line) => getDistanceOfPointToLine(b, line, calculation)));
+    },
+    LineStringLineString(a, b, calculation) {
+        const sa = segments(a);
+        const sb = segments(b);
+        return sa.reduce((carry, a) => sb.reduce((carry, b) => carry > 0 ? Math.min(carry, getDistanceOfLineToLine(a, b, calculation)) : carry, carry), Infinity);
+    },
+    PolygonPoint([exterior, ...interior], b, calculation) {
+        if (isPointInRing(b, exterior)) {
+            const [excluded] = interior.filter((ring) => isPointInRing(b, ring));
+            return excluded ? this.LineStringPoint(excluded, b, calculation) : 0;
+        }
+        return this.LineStringPoint(exterior, b, calculation);
+    },
+    PolygonLineString(a, b, calculation) {
+        const [exterior, ...interior] = a;
+        const line = segments(b);
+        const ring = b.some((b) => isPointInRing(b, exterior))
+            ? interior.find((a) => b.every((b) => isPointInRing(b, a)))
+            : exterior;
+        return ring
+            ? Math.min(...segments(ring).map((a) => Math.min(...line.map((b) => getDistanceOfLineToLine(a, b, calculation)))))
+            : 0;
+    },
+    PolygonPolygon(a, b, calculation) {
+        return Math.min(this.PolygonLineString(a, b[0], calculation), this.PolygonLineString(b, a[0], calculation));
+    },
+};
+function distance(a, b, calculation = 'cartesian') {
+    return Math.min(...[...new IterablePairIterator(new SimpleGeometryIterator(a), new SimpleGeometryIterator(b))].map(([a, b]) => {
+        return a.type + b.type in geometries
+            ? geometries[a.type + b.type](a.coordinates, b.coordinates, calculation)
+            : b.type + a.type in geometries
+                ? geometries[b.type + a.type](b.coordinates, a.coordinates, calculation)
+                : Infinity;
+    }));
+}
+
+class TypeMapper {
+    constructor(mapping = {}) {
+        this.mapping = Object.keys(mapping)
+            .map((key) => (value) => mapping[key](value) ? key : undefined)
+            .concat((value) => typeof value);
+    }
+    map(value) {
+        return this.mapping.reduce((carry, map) => carry || map(value), undefined);
+    }
+}
+
+class ValueMapper {
+    constructor(types = new TypeMapper(), mapping = {}) {
+        this.types = types;
+        this.mapping = mapping;
+    }
+    map(value) {
+        const type = this.types.map(value);
+        const map = (value) => this.map(value);
+        return type in this.mapping
+            ? this.mapping[type](value, map)
+            : (value === null || value === void 0 ? void 0 : value.toString()) || 'undefined';
+    }
+}
+
+const types = new TypeMapper({
+    date: (value) => value instanceof Date,
+    regexp: (value) => value instanceof RegExp,
+    array: (value) => Array.isArray(value),
+    null: (value) => value === null,
+});
+new ValueMapper(types, {
+    string: (value) => value ? `"${value}"` : 'EmptyString',
+    date: (value, map) => map(value.toISOString()),
+    object: (value, map) => {
+        const string = String(value);
+        if (/^\[([a-z]+) \1\]$/i.test(string)) {
+            const mapped = Object.keys(value)
+                .map((key) => `${key}:${map(value[key])}`);
+            return `{${mapped.join(',')}}`;
+        }
+        return string;
+    },
+    array: (value, map) => `[${value.map(map).join(',')}]`,
+    null: () => 'NULL',
+    undefined: () => 'Undefined',
+    function: (value) => {
+        const { constructor: { name: cname }, name } = value;
+        const [, async, generator, func] = cname.match(/^(async)?(generator)?(function)$/i);
+        const [, stype, sname] = value.toString().match(/^(?:async)?(?:[\s\*]+)?(class|function)?(?:[\s\*]+)?([a-z_]\w*)?\s*[\(\{]?/i);
+        const parts = []
+            .concat(stype && !(name || sname) ? 'anonymous' : [])
+            .concat(name && !stype && sname ? 'shorthand' : [])
+            .concat(async || [], generator || [])
+            .concat(!(stype || sname) ? 'arrow' : [])
+            .concat(stype || func)
+            .map((key) => key[0].toUpperCase() + key.slice(1));
+        return [parts.join('')].concat(name || []).join(' ');
+    },
+});
+
+/**
+ * Create a guard verifying the given value matches the specified type
+ */
+function is(type) {
+    return (value) => typeof value === type;
+}
+/**
+ * Create a guard verifying the given value matches any of the validators
+ */
+function any(...checks) {
+    return (value) => checks.some((check) => check(value));
+}
+/**
+ * Create a guard verifying the given value matches all of the validators
+ */
+function all(...checks) {
+    return (value) => checks.every((check) => check(value));
+}
+/**
+ * Create a guard verifying the given value matches none of the validators
+ */
+function not(...checks) {
+    return (value) => checks.every((check) => !check(value));
+}
+
+/**
+ * Guard verifying the value is a array
+ */
+const isArray = (value) => Array.isArray(value);
+/**
+ * Guard verifying the value is a null
+ */
+const isNULL = (value) => value === null;
+/**
+ * Guard verifying the value is a number
+ */
+const isNumber = is('number');
+/**
+ * Guard verifying the value is a object
+ */
+const isObject = all(not(isArray), not(isNULL), is('object'));
+/**
+ * Guard verifying the value is a string
+ */
+const isString = is('string');
+
+/**
+ * Guard verifying the value to be an array containing only elements matching the validators
+ */
+function isArrayOfType(...validators) {
+    const check = all(...validators);
+    return all(isArray, (value) => value.every(check));
+}
+/**
+ * Guard verifying the value to be an array with a length between the given boundaries
+ */
+function isArrayOfSize(min, max = Infinity) {
+    return all(isArray, (value) => value.length >= min && value.length <= max);
+}
+
+/**
+ * Creates a guard verifying the value is an object and has the given key
+ */
+function isKey(key) {
+    return all(isObject, (value) => key in value);
+}
+/**
+ * Creates a guard verifying the value is an object and has the given key matching the validators
+ */
+function isKeyOfType(key, ...validators) {
+    return all(isKey(key), (value) => validators.every((check) => check(value[key])));
+}
+/**
+ * Creates a guard verifying the value is an object and doesn't have the key or has the given key matching the validators
+ */
+function isOptionalKeyOfType(key, ...validators) {
+    return any(all(isObject, not(isKey(key))), isKeyOfType(key, ...validators));
+}
+/**
+ * Creates a guard verifying the value is an object matching at least the structure
+ */
+function isStructure(struct, ...options) {
+    const optional = options.reduce((carry, key) => carry.concat(key), []);
+    const validators = Object.keys(struct)
+        .map((key) => (optional.includes(key) ? isOptionalKeyOfType : isKeyOfType)(key, struct[key]));
+    return all(isObject, ...validators);
+}
+
+function isTuple(...rules) {
+    return (value) => isArray(value) && value.length === rules.length && rules.every((rule, index) => rule(value[index]));
+}
+
+function isNumberValue(value) {
+    return isNumber(value) && Number.isFinite(value);
+}
+function isNumberBetween(a, b = Infinity) {
+    const min = Math.min(a, b);
+    const max = Math.max(a, b);
+    return (value) => isNumberValue(value) && value >= min && value <= max;
+}
+
+function isAltitude(value) {
+    return isNumberValue(value);
+}
+const isStrictAltitude = isNumberBetween(-EARTH_RADIUS, GPS_SATELLITE_ORBIT);
+
+function isLatitude(value) {
+    return isNumberValue(value);
+}
+const isStrictLatitude = isNumberBetween(-90, 90);
+
+function isLongitude(value) {
+    return isNumberValue(value);
+}
+const isStrictLongitude = isNumberBetween(-180, 180);
+
+const isPosition = any(isTuple(isLongitude, isLatitude), isTuple(isLongitude, isLatitude, isAltitude));
+const isStrictPosition = any(isTuple(isStrictLongitude, isStrictLatitude), isTuple(isStrictLongitude, isStrictLatitude, isStrictAltitude));
+
+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);
+const isBoundingBox = any(isBoundingBoxWithAltitude, isBoundingBoxWithoutAltitude);
+
+function isGeoJSONObject(type) {
+    return isStructure({
+        type: all(isString, (value) => value === type),
+        bbox: isBoundingBox,
+    }, 'bbox');
+}
+
+function isGeometryObject(type, isCoordinates) {
+    return all(isGeoJSONObject(type), isKeyOfType('coordinates', isCoordinates));
+}
+
+const isPointCoordinates = isPosition;
+const isPoint = isGeometryObject('Point', isPointCoordinates);
+const isStrictPointCoordinates = isStrictPosition;
+const isStrictPoint = isGeometryObject('Point', isStrictPointCoordinates);
+
+const isMultiPointCoordinates = isArrayOfType(isPointCoordinates);
+const isMultiPoint = isGeometryObject('MultiPoint', isMultiPointCoordinates);
+const isStrictMultiPointCoordinates = isArrayOfType(isStrictPointCoordinates);
+const isStrictMultiPoint = isGeometryObject('MultiPoint', isStrictMultiPointCoordinates);
+
+const isLineStringCoordinates = isMultiPointCoordinates;
+const isLineString = isGeometryObject('LineString', isLineStringCoordinates);
+const isStrictLineStringCoordinates = isStrictMultiPointCoordinates;
+const isStrictLineString = isGeometryObject('LineString', isStrictLineStringCoordinates);
+
+const isMultiLineStringCoordinates = isArrayOfType(isLineStringCoordinates);
+const isMultiLineString = isGeometryObject('MultiLineString', isMultiLineStringCoordinates);
+const isStrictMultiLineStringCoordinates = isArrayOfType(isStrictLineStringCoordinates);
+const isStrictMultiLineString = isGeometryObject('MultiLineString', isStrictMultiLineStringCoordinates);
+
+isArrayOfType(isPosition);
+
+const isLinearRing = all(isArrayOfType(isPosition), isArrayOfSize(4), (value) => value[value.length - 1].every((v, i) => v === value[0][i]));
+const isStrictLinearRing = all(isArrayOfType(isStrictPosition), isArrayOfSize(4), (value) => value[value.length - 1].every((v, i) => v === value[0][i]));
+
+const isExteriorRing = all(isLinearRing);
+
+const isInteriorRing = all(isLinearRing);
+
+const isPolygonCoordinates = all(isArrayOfType(isLinearRing));
+const isPolygon = isGeometryObject('Polygon', isPolygonCoordinates);
+const isStrictPolygonCoordinates = all(isArrayOfType(isStrictLinearRing), (value) => isExteriorRing(value[0]), (value) => value.slice(1).every(isInteriorRing));
+const isStrictPolygon = isGeometryObject('Polygon', isStrictPolygonCoordinates);
+
+const isMultiPolygonCoordinates = isArrayOfType(isPolygonCoordinates);
+const isMultiPolygon = isGeometryObject('MultiPolygon', isMultiPolygonCoordinates);
+const isStrictMultiPolygonCoordinates = isArrayOfType(isStrictPolygonCoordinates);
+const isStrictMultiPolygon = isGeometryObject('MultiPolygon', isStrictMultiPolygonCoordinates);
+
+const isGeometry = any(isPoint, isMultiPoint, isLineString, isMultiLineString, isPolygon, isMultiPolygon);
+const isStrictGeometry = any(isStrictPoint, isStrictMultiPoint, isStrictLineString, isStrictMultiLineString, isStrictPolygon, isStrictMultiPolygon);
+
+const isGeometryCollectionObject = all(isGeoJSONObject('GeometryCollection'), isKeyOfType('geometries', isArrayOfType(any(isGeometry, isGeometryCollection))));
+const isStrictGeometryCollectionObject = all(isGeoJSONObject('GeometryCollection'), isKeyOfType('geometries', isArrayOfType(any(isStrictGeometry, isStrictGeometryCollection))));
+function isGeometryCollection(value) {
+    return isGeometryCollectionObject(value);
+}
+function isStrictGeometryCollection(value) {
+    return isStrictGeometryCollectionObject(value);
+}
+
+const isFeature = all(isGeoJSONObject('Feature'), isStructure({
+    geometry: any(isGeometry, isGeometryCollection),
+    properties: any(isNULL, isObject)
+}));
+const isStrictFeature = all(isGeoJSONObject('Feature'), isStructure({
+    geometry: any(isStrictGeometry, isStrictGeometryCollection),
+    properties: any(isNULL, isObject)
+}));
+
+const isFeatureCollection = all(isGeoJSONObject('FeatureCollection'), isKeyOfType('features', isArrayOfType(isFeature)));
+const isStrictFeatureCollection = all(isGeoJSONObject('FeatureCollection'), isKeyOfType('features', isArrayOfType(isStrictFeature)));
+
+const isGeoJSON = any(isGeometry, isGeometryCollection, isFeature, isFeatureCollection);
+const isStrictGeoJSON = any(isStrictGeometry, isStrictGeometryCollection, isStrictFeature, isStrictFeatureCollection);
+
+exports.SimpleGeometryIterator = SimpleGeometryIterator;
+exports.distance = distance;
+exports.intersect = intersect;
+exports.isFeature = isFeature;
+exports.isFeatureCollection = isFeatureCollection;
+exports.isGeoJSON = isGeoJSON;
+exports.isGeometry = isGeometry;
+exports.isGeometryCollection = isGeometryCollection;
+exports.isLineString = isLineString;
+exports.isMultiLineString = isMultiLineString;
+exports.isMultiPoint = isMultiPoint;
+exports.isMultiPolygon = isMultiPolygon;
+exports.isPoint = isPoint;
+exports.isPolygon = isPolygon;
+exports.isPosition = isPosition;
+exports.isStrictFeature = isStrictFeature;
+exports.isStrictFeatureCollection = isStrictFeatureCollection;
+exports.isStrictGeoJSON = isStrictGeoJSON;
+exports.isStrictGeometry = isStrictGeometry;
+exports.isStrictGeometryCollection = isStrictGeometryCollection;
+exports.isStrictLineString = isStrictLineString;
+exports.isStrictMultiLineString = isStrictMultiLineString;
+exports.isStrictMultiPoint = isStrictMultiPoint;
+exports.isStrictMultiPolygon = isStrictMultiPolygon;
+exports.isStrictPoint = isStrictPoint;
+exports.isStrictPolygon = isStrictPolygon;
+exports.isStrictPosition = isStrictPosition;

package/dist/geojson.cjs.min.js

@@ -0,0 +1 @@
+"use strict";function t(t){return t.slice(1).map(((n,e)=>[t[e],n]))}const n=6371008.7714,e=6356752.314245,o=Math.PI/180,i=Math.PI;function r(t){return t*t}function s(t){return t*o}const c=r(6378137),a=r(e),u=(c-a)/a,l=1/298.257223563,p={cartesian:([t,e],[o,i])=>n*s(Math.sqrt(r(o-t)+r(i-e))),haversine([t,e],[o,i]){const c=r(Math.sin(s(i-e)/2))+Math.cos(s(e))*Math.cos(s(i))*r(Math.sin(s(o-t)/2));return n*Math.atan2(Math.sqrt(c),Math.sqrt(1-c))*2},vincenty(...t){const[[n,o],[r,c]]=t.map((t=>t.map(s))),a=r-n,p=.9966471893352525*Math.tan(o),y=1/Math.sqrt(1+p*p),g=p*y,h=.9966471893352525*Math.tan(c),f=1/Math.sqrt(1+h*h),m=h*f,P=Math.abs(a)>i/2||Math.abs(c-o)>i/2;let S=a,M=null,d=null,x=P?i:0,L=0,b=P?-1:1,w=null,v=1,C=1,F=null,G=0;do{if(M=Math.sin(S),d=Math.cos(S),w=(f*M)**2+(y*m-g*f*d)**2,Math.abs(w)<1e-24)break;L=Math.sqrt(w),b=g*m+y*f*d,x=Math.atan2(L,b);const t=y*f*M/L;C=1-t*t,v=0!=C?b-2*g*m/C:0;const n=.00020955066654671753*C*(4+l*(4-3*C));F=S,S=a+(1-n)*l*t*(x+n*L*(v+n*b*(2*v*v-1)))}while(Math.abs(S-F)>1e-12&&++G<1e3);const j=C*u,$=j/1024*(256+j*(j*(74-47*j)-128));return e*(1+j/16384*(4096+j*(j*(320-175*j)-768)))*(x-$*L*(v+$/4*(b*(2*v*v-1)-$/6*v*(4*L*L-3)*(4*v*v-3))))}};function y(t,n){const[[e,o],[i,r],[s,c]]=[t,...n],[a,u]=[s-i,c-r],[l,p]=[e-i,o-r],y=(g=(l*a+p*u)/(a*a+u*u),h=0,f=1,Math.max(Math.min(g,f),h));var g,h,f;return 0===y||1===y?n[y]:[i+a*y,r+u*y]}function g(t,n,e){const o="function"==typeof e?e:p[e];if("function"==typeof o)return o(t,n);throw new Error(`Not a PointToPoint calculation function ${e}`)}function h(t,n,e){return g(t,y(t,n),e)}function f(t,n,e){return m(t,n)?0:Math.min(...t.map((t=>h(t,n,e))),...n.map((n=>h(n,t,e))))}function m(t,n){const[[e,o],[i,r]]=t,[[s,c],[a,u]]=n,[l,p,y,g]=[i-e,r-o,a-s,u-c],h=(-p*(e-s)+l*(o-c))/(-y*p+l*g),f=(y*(o-c)-g*(e-s))/(-y*p+l*g);return h>=0&&h<=1&&f>=0&&f<=1}function P(t,n,e=1e-14){return h(t,n,"cartesian")<e}function S(t,n){const{length:e}=n;return 0!==n.reduce(((o,i,r)=>{const s=n[(e+r-1)%e];return(i[1]<t[1]&&s[1]>=t[1]||s[1]<t[1]&&i[1]>=t[1])&&(i[0]<=t[0]||s[0]<=t[0])?o^Number(i[0]+(t[1]-i[1])/(s[1]-i[1])*(s[0]-i[0])<t[0]):o}),0)||n.slice(1).some(((e,o)=>P(t,[n[o],e])))}class M{constructor(...t){this.inputs=[],this.inputs=t}*[Symbol.iterator](){for(const t of this.inputs)for(const n of this.unwrap(t))yield n}*unwrap(t){t.type in this?yield*this[t.type](t):yield t}*GeometryCollection({geometries:t}){for(const n of t)yield*this.unwrap(n)}*FeatureCollection({features:t}){for(const{geometry:n}of t)yield*this.unwrap(n)}*Feature({geometry:t}){yield*this.unwrap(t)}*MultiPoint(t){for(const n of t.coordinates)yield{type:"Point",coordinates:n}}*MultiLineString(t){for(const n of t.coordinates)yield{type:"LineString",coordinates:n}}*MultiPolygon(t){for(const n of t.coordinates)yield{type:"Polygon",coordinates:n}}}class d{constructor(...t){this.iterators=[],this.iterators=t}*[Symbol.iterator](){for(const[t,n]of this.pairs(this.iterators))for(const e of t)for(const t of n)yield[e,t]}pairs(t){return t.map(((n,e)=>t.slice(e+1).map((t=>[n,t])))).flat()}}const x={PointPoint:(t,n)=>t.length>=2&&n.length>=2&&t.slice(0,2).every(((t,e)=>t===n[e])),LineStringPoint(n,e){return n.some((t=>this.PointPoint(t,e)))||t(n).some((t=>P(e,t)))},LineStringLineString(n,e){const o=t(e);return t(n).some((t=>o.some((n=>m(t,n)))))},PolygonPoint([t,...n],e){return(this.LineStringPoint(t,e)||S(e,t))&&(!n.length||n.every((t=>!S(e,t))))},PolygonLineString(t,n){return t.some((t=>this.LineStringLineString(t,n)))||n.some((n=>this.PolygonPoint(t,n)))},PolygonPolygon(t,n){return n.some((n=>this.PolygonLineString(t,n)||n.some((n=>this.PolygonPoint(t,n)))))||t.some((t=>this.PolygonLineString(n,t)||t.some((t=>this.PolygonPoint(n,t)))))}};const L={PointPoint:(t,n,e)=>g(t,n,e),LineStringPoint:(n,e,o)=>Math.min(...t(n).map((t=>h(e,t,o)))),LineStringLineString(n,e,o){const i=t(n),r=t(e);return i.reduce(((t,n)=>r.reduce(((t,e)=>t>0?Math.min(t,f(n,e,o)):t),t)),1/0)},PolygonPoint([t,...n],e,o){if(S(e,t)){const[t]=n.filter((t=>S(e,t)));return t?this.LineStringPoint(t,e,o):0}return this.LineStringPoint(t,e,o)},PolygonLineString(n,e,o){const[i,...r]=n,s=t(e),c=e.some((t=>S(t,i)))?r.find((t=>e.every((n=>S(n,t))))):i;return c?Math.min(...t(c).map((t=>Math.min(...s.map((n=>f(t,n,o))))))):0},PolygonPolygon(t,n,e){return Math.min(this.PolygonLineString(t,n[0],e),this.PolygonLineString(n,t[0],e))}};class b{constructor(t={}){this.mapping=Object.keys(t).map((n=>e=>t[n](e)?n:void 0)).concat((t=>typeof t))}map(t){return this.mapping.reduce(((n,e)=>n||e(t)),void 0)}}const w=new b({date:t=>t instanceof Date,regexp:t=>t instanceof RegExp,array:t=>Array.isArray(t),null:t=>null===t});function v(t){return n=>typeof n===t}function C(...t){return n=>t.some((t=>t(n)))}function F(...t){return n=>t.every((t=>t(n)))}function G(...t){return n=>t.every((t=>!t(n)))}new class{constructor(t=new b,n={}){this.types=t,this.mapping=n}map(t){const n=this.types.map(t);return n in this.mapping?this.mapping[n](t,(t=>this.map(t))):(null==t?void 0:t.toString())||"undefined"}}(w,{string:t=>t?`"${t}"`:"EmptyString",date:(t,n)=>n(t.toISOString()),object:(t,n)=>{const e=String(t);if(/^\[([a-z]+) \1\]$/i.test(e)){return`{${Object.keys(t).map((e=>`${e}:${n(t[e])}`)).join(",")}}`}return e},array:(t,n)=>`[${t.map(n).join(",")}]`,null:()=>"NULL",undefined:()=>"Undefined",function:t=>{const{constructor:{name:n},name:e}=t,[,o,i,r]=n.match(/^(async)?(generator)?(function)$/i),[,s,c]=t.toString().match(/^(?:async)?(?:[\s\*]+)?(class|function)?(?:[\s\*]+)?([a-z_]\w*)?\s*[\(\{]?/i);return[[].concat(!s||e||c?[]:"anonymous").concat(e&&!s&&c?"shorthand":[]).concat(o||[],i||[]).concat(s||c?[]:"arrow").concat(s||r).map((t=>t[0].toUpperCase()+t.slice(1))).join("")].concat(e||[]).join(" ")}});const j=t=>Array.isArray(t),$=t=>null===t,q=v("number"),N=F(G(j),G($),v("object")),O=v("string");function k(...t){const n=F(...t);return F(j,(t=>t.every(n)))}function A(t,n=1/0){return F(j,(e=>e.length>=t&&e.length<=n))}function I(t){return F(N,(n=>t in n))}function E(t,...n){return F(I(t),(e=>n.every((n=>n(e[t])))))}function U(t,...n){return C(F(N,G(I(t))),E(t,...n))}function z(t,...n){const e=n.reduce(((t,n)=>t.concat(n)),[]),o=Object.keys(t).map((n=>(e.includes(n)?U:E)(n,t[n])));return F(N,...o)}function J(...t){return n=>j(n)&&n.length===t.length&&t.every(((t,e)=>t(n[e])))}function D(t){return q(t)&&Number.isFinite(t)}function R(t,n=1/0){const e=Math.min(t,n),o=Math.max(t,n);return t=>D(t)&&t>=e&&t<=o}function T(t){return D(t)}const _=R(-6371008.7714,2018e4);function B(t){return D(t)}const H=R(-90,90);function K(t){return D(t)}const Q=R(-180,180),V=C(J(K,B),J(K,B,T)),W=C(J(Q,H),J(Q,H,_)),X=C(F(J(K,B,T,K,B,T),(([,t,,,n])=>t<=n)),F(J(K,B,K,B),(([,t,,n])=>t<=n)));function Y(t){return z({type:F(O,(n=>n===t)),bbox:X},"bbox")}function Z(t,n){return F(Y(t),E("coordinates",n))}const tt=V,nt=Z("Point",tt),et=W,ot=Z("Point",et),it=k(tt),rt=Z("MultiPoint",it),st=k(et),ct=Z("MultiPoint",st),at=it,ut=Z("LineString",at),lt=st,pt=Z("LineString",lt),yt=Z("MultiLineString",k(at)),gt=Z("MultiLineString",k(lt));k(V);const ht=F(k(V),A(4),(t=>t[t.length-1].every(((n,e)=>n===t[0][e])))),ft=F(k(W),A(4),(t=>t[t.length-1].every(((n,e)=>n===t[0][e])))),mt=F(ht),Pt=F(ht),St=F(k(ht)),Mt=Z("Polygon",St),dt=F(k(ft),(t=>mt(t[0])),(t=>t.slice(1).every(Pt))),xt=Z("Polygon",dt),Lt=Z("MultiPolygon",k(St)),bt=Z("MultiPolygon",k(dt)),wt=C(nt,rt,ut,yt,Mt,Lt),vt=C(ot,ct,pt,gt,xt,bt),Ct=F(Y("GeometryCollection"),E("geometries",k(C(wt,Gt)))),Ft=F(Y("GeometryCollection"),E("geometries",k(C(vt,jt))));function Gt(t){return Ct(t)}function jt(t){return Ft(t)}const $t=F(Y("Feature"),z({geometry:C(wt,Gt),properties:C($,N)})),qt=F(Y("Feature"),z({geometry:C(vt,jt),properties:C($,N)})),Nt=F(Y("FeatureCollection"),E("features",k($t))),Ot=F(Y("FeatureCollection"),E("features",k(qt))),kt=C(wt,Gt,$t,Nt),At=C(vt,jt,qt,Ot);exports.SimpleGeometryIterator=M,exports.distance=function(t,n,e="cartesian"){return Math.min(...[...new d(new M(t),new M(n))].map((([t,n])=>t.type+n.type in L?L[t.type+n.type](t.coordinates,n.coordinates,e):n.type+t.type in L?L[n.type+t.type](n.coordinates,t.coordinates,e):1/0)))},exports.intersect=function(t,n){for(const[e,o]of new d(new M(t),new M(n)))if(e.type+o.type in x&&x[e.type+o.type](e.coordinates,o.coordinates)||o.type+e.type in x&&x[o.type+e.type](o.coordinates,e.coordinates))return!0;return!1},exports.isFeature=$t,exports.isFeatureCollection=Nt,exports.isGeoJSON=kt,exports.isGeometry=wt,exports.isGeometryCollection=Gt,exports.isLineString=ut,exports.isMultiLineString=yt,exports.isMultiPoint=rt,exports.isMultiPolygon=Lt,exports.isPoint=nt,exports.isPolygon=Mt,exports.isPosition=V,exports.isStrictFeature=qt,exports.isStrictFeatureCollection=Ot,exports.isStrictGeoJSON=At,exports.isStrictGeometry=vt,exports.isStrictGeometryCollection=jt,exports.isStrictLineString=pt,exports.isStrictMultiLineString=gt,exports.isStrictMultiPoint=ct,exports.isStrictMultiPolygon=bt,exports.isStrictPoint=ot,exports.isStrictPolygon=xt,exports.isStrictPosition=W;