@jarenjs/core 0.9.2 → 0.34.2

package/dist/types/finance/tvm.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @file Time Value of Money. The five TVM quantities — N,
+ * I/Y, PV, PMT, FV — obey one identity; each function here solves for its
+ * own variable. Sign convention follows the standard cash-flow model
+ * (money in is positive, money out negative), matching Excel/HP-12C:
+ *
+ *   PV·(1+i)^n + PMT·(1 + i·type)·((1+i)^n − 1)/i + FV = 0
+ *
+ * `type` is 0 for an ordinary annuity (payment at period end) or 1 for an
+ * annuity-due (payment at period begin). Rates are per period; a caller
+ * with an annual rate and monthly periods passes `rate/12`.
+ *
+ * Pure and zero-dep except `math/solve` for the iterative `rate`.
+ */
+/**
+ * Future value.
+ * @param {number} rate @param {number} nper @param {number} pmt
+ * @param {number} [pv] @param {number} [type]
+ * @returns {number}
+ */
+export declare function fv(rate: number, nper: number, pmt: number, pv?: number, type?: number): number;
+/**
+ * Present value.
+ * @param {number} rate @param {number} nper @param {number} pmt
+ * @param {number} [fval] @param {number} [type]
+ * @returns {number}
+ */
+export declare function pv(rate: number, nper: number, pmt: number, fval?: number, type?: number): number;
+/**
+ * Payment per period.
+ * @param {number} rate @param {number} nper @param {number} pval
+ * @param {number} [fval] @param {number} [type]
+ * @returns {number}
+ */
+export declare function pmt(rate: number, nper: number, pval: number, fval?: number, type?: number): number;
+/**
+ * Number of periods.
+ * @param {number} rate @param {number} pmtv @param {number} pval
+ * @param {number} [fval] @param {number} [type]
+ * @returns {number}
+ */
+export declare function nper(rate: number, pmtv: number, pval: number, fval?: number, type?: number): number;
+/**
+ * Periodic interest rate, solved iteratively (Newton, bisection
+ * fallback). Returns `NaN` if no rate is found.
+ * @param {number} nperv @param {number} pmtv @param {number} pval
+ * @param {number} [fval] @param {number} [type] @param {number} [guess]
+ * @returns {number}
+ */
+export declare function rate(nperv: number, pmtv: number, pval: number, fval?: number, type?: number, guess?: number): number;

package/dist/types/geo/angle.d.ts

@@ -0,0 +1,4 @@
+/** Radians per degree — multiply degrees by this to get radians. */
+export declare const DEG: number;
+/** Degrees per radian — multiply radians by this to get degrees. */
+export declare const RAD: number;

package/dist/types/geo/bbox.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The bounding box of a list of positions, as `[west, south, east, north]`.
+ * Returns null for an empty list — there is no box that bounds nothing,
+ * and an all-Infinity placeholder would silently intersect everything.
+ * @param {Array<number[]>} positions
+ * @returns {number[] | null}
+ */
+export declare function bboxOfPositions(positions: Array<number[]>): number[] | null;
+/**
+ * Whether two bounding boxes share any area. Boxes that merely touch
+ * along an edge count as intersecting, matching `pointInRing`'s
+ * treatment of a boundary as inside.
+ * @param {number[]} a - [west, south, east, north]
+ * @param {number[]} b
+ * @returns {boolean}
+ */
+export declare function bboxIntersects(a: number[], b: number[]): boolean;
+/**
+ * Whether a bounding box contains a position (edges included).
+ * @param {number[]} box - [west, south, east, north]
+ * @param {number} x - longitude
+ * @param {number} y - latitude
+ * @returns {boolean}
+ */
+export declare function bboxContains(box: number[], x: number, y: number): boolean;
+/**
+ * The smallest box containing both inputs.
+ * @param {number[]} a
+ * @param {number[]} b
+ * @returns {number[]}
+ */
+export declare function bboxUnion(a: number[], b: number[]): number[];

package/dist/types/geo/distance.d.ts

@@ -0,0 +1,67 @@
+/** IUGG mean Earth radius in metres — the sphere GeoJSON distances use. */
+export declare const EARTH_RADIUS = 6371008.8;
+/**
+ * Great-circle distance between two positions, in metres.
+ *
+ * @param {number} lon1 - longitude of the first position, degrees
+ * @param {number} lat1 - latitude of the first position, degrees
+ * @param {number} lon2 - longitude of the second position, degrees
+ * @param {number} lat2 - latitude of the second position, degrees
+ * @param {number} [radius] - sphere radius, to answer in other units
+ * @returns {number} distance in metres (or in `radius`'s unit)
+ * @example
+ * haversineDistance(4.9041, 52.3676, 2.3522, 48.8566); // 429_862 (Amsterdam-Paris)
+ */
+export declare function haversineDistance(lon1: number, lat1: number, lon2: number, lat2: number, radius?: number): number;
+/**
+ * Equirectangular approximation of the distance between two positions,
+ * in metres — the **screening** form.
+ *
+ * Accurate to about 0.02% over a few hundred kilometres and roughly 12%
+ * across a hemisphere, for about a seventh of the cost. Use it to reject
+ * candidates that cannot be within a radius, then confirm the survivors
+ * with `haversineDistance`; do not report it as a measurement.
+ *
+ * @param {number} lon1
+ * @param {number} lat1
+ * @param {number} lon2
+ * @param {number} lat2
+ * @param {number} [radius]
+ * @returns {number} approximate distance
+ */
+export declare function equirectDistance(lon1: number, lat1: number, lon2: number, lat2: number, radius?: number): number;
+/**
+ * Initial bearing from one position to another: degrees clockwise from
+ * true north, in `[0, 360)`.
+ *
+ * This is the bearing at the *start* of the great circle, and it changes
+ * along the path — a course of constant bearing is a rhumb line, which
+ * is a different curve.
+ *
+ * @param {number} lon1
+ * @param {number} lat1
+ * @param {number} lon2
+ * @param {number} lat2
+ * @returns {number} degrees in [0, 360)
+ */
+export declare function initialBearing(lon1: number, lat1: number, lon2: number, lat2: number): number;
+/**
+ * The position reached by travelling `distance` metres from a position
+ * along a constant initial bearing (a great-circle course).
+ *
+ * @param {number} lon - starting longitude, degrees
+ * @param {number} lat - starting latitude, degrees
+ * @param {number} bearing - degrees clockwise from true north
+ * @param {number} distance - metres
+ * @param {number} [radius]
+ * @returns {[number, number]} the destination as a GeoJSON position
+ */
+export declare function destinationPoint(lon: number, lat: number, bearing: number, distance: number, radius?: number): [number, number];
+/**
+ * Total great-circle length of a line of positions, in metres. An empty
+ * or single-position line has length 0.
+ * @param {Array<number[]>} positions - GeoJSON positions
+ * @param {number} [radius]
+ * @returns {number}
+ */
+export declare function lineLength(positions: Array<number[]>, radius?: number): number;

package/dist/types/geo/geohash.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Encode a position as a geohash string.
+ *
+ * @param {number} lon - longitude, degrees
+ * @param {number} lat - latitude, degrees
+ * @param {number} [precision] - characters, 1-12 (default 9, about 5 m)
+ * @returns {string}
+ * @example
+ * geohashEncode(4.9041, 52.3676, 5); // 'u173z' (Amsterdam)
+ */
+export declare function geohashEncode(lon: number, lat: number, precision?: number): string;
+/**
+ * Whether a string is a well-formed geohash: non-empty and every
+ * character in the base-32 alphabet (lowercase; `a`, `i`, `l` and `o`
+ * are deliberately absent from it). Any length is valid — each
+ * character only names a finer cell.
+ * @param {string} hash
+ * @returns {boolean}
+ * @example
+ * isValidGeohash('u173z'); // true (Amsterdam)
+ * isValidGeohash('u17a');  // false ('a' is not in the alphabet)
+ */
+export declare function isValidGeohash(hash: string): boolean;
+/**
+ * The bounding box of a geohash cell, as `[west, south, east, north]`.
+ * Returns null for a string containing a character outside the base-32
+ * alphabet (`a`, `i`, `l` and `o` are deliberately absent).
+ * @param {string} hash
+ * @returns {number[] | null}
+ */
+export declare function geohashBounds(hash: string): number[] | null;
+/**
+ * The centre of a geohash cell, as a GeoJSON position. Null for an
+ * invalid hash.
+ *
+ * Decoding is lossy by construction — a hash names a cell, not a point —
+ * so this is the cell's centre and the error is bounded by
+ * {@link geohashCellSize}.
+ *
+ * @param {string} hash
+ * @returns {[number, number] | null}
+ */
+export declare function geohashDecode(hash: string): [number, number] | null;
+/**
+ * Approximate cell size at a precision, as `[lonWidth, latHeight]` in
+ * degrees. Null outside 1-12.
+ * @param {number} precision
+ * @returns {number[] | null}
+ */
+export declare function geohashCellSize(precision: number): number[] | null;
+/**
+ * The eight geohash cells surrounding one, plus the cell itself, as a
+ * nine-element array. Cells that would fall off the poles are omitted,
+ * so the result may be shorter.
+ *
+ * This is what makes a prefix search safe near a boundary: two points
+ * metres apart can sit in different cells, so a proximity query tests
+ * the neighbourhood rather than the single cell.
+ *
+ * @param {string} hash
+ * @returns {string[]}
+ */
+export declare function geohashNeighbours(hash: string): string[];

package/dist/types/geo/geojson.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Whether a value looks like a bare position: an array of at least two
+ * finite numbers.
+ * @param {any} value
+ * @returns {boolean}
+ */
+export declare function isPosition(value: any): boolean;
+/**
+ * The geometry inside a value: the value itself when it is already one,
+ * a Feature's `geometry`, or null when there is none (including a
+ * Feature whose geometry is legitimately null).
+ *
+ * A FeatureCollection has no single geometry and yields null — use
+ * {@link eachPosition} or {@link bboxOf}, which handle collections.
+ *
+ * @param {any} value
+ * @returns {object | null}
+ */
+export declare function geometryOf(value: any): object | null;
+/**
+ * Call `visit(position)` for every position in a GeoJSON value, in
+ * document order. Accepts a bare position, a geometry, a Feature, a
+ * FeatureCollection or a GeometryCollection.
+ * @param {any} value
+ * @param {(position: number[]) => void} visit
+ */
+export declare function eachPosition(value: any, visit: (position: number[]) => void): void;
+/**
+ * The bounding box of any GeoJSON value, as `[west, south, east, north]`.
+ * Null when the value contains no positions.
+ *
+ * A `bbox` member already present on the value is ignored: it is an
+ * optimization the producer may have got wrong, and recomputing is the
+ * only way to be sure.
+ *
+ * @param {any} value
+ * @returns {number[] | null}
+ */
+export declare function bboxOf(value: any): number[] | null;
+/**
+ * Every position of a GeoJSON value, flattened into one array.
+ * @param {any} value
+ * @returns {Array<number[]>}
+ */
+export declare function positionsOf(value: any): Array<number[]>;
+/**
+ * Geodesic area of a value in square metres: the sum over its polygons
+ * of the exterior ring's area less its holes'. Anything with no surface
+ * — a point, a line — has area 0 rather than being an error.
+ * @param {any} value
+ * @param {number} [radius]
+ * @returns {number}
+ */
+export declare function geometryArea(value: any, radius?: number): number;
+/**
+ * Great-circle length of a value in metres: the sum of its line
+ * lengths, and of its polygon ring perimeters. A point has length 0.
+ * @param {any} value
+ * @param {number} [radius]
+ * @returns {number}
+ */
+export declare function geometryLength(value: any, radius?: number): number;
+/**
+ * The centroid of a value's positions, as a GeoJSON position. Null when
+ * there are none.
+ *
+ * This is the mean of the vertices, NOT the area-weighted centre of
+ * mass: it is the cheap answer, it always lies in the convex hull, and
+ * for a concave shape it can fall outside the polygon. Labelling and
+ * clustering want this; a physics centre of mass does not.
+ *
+ * @param {any} value
+ * @returns {[number, number] | null}
+ */
+export declare function centroidOf(value: any): [number, number] | null;
+/**
+ * Whether a position lies inside a value's surface. Only polygons have
+ * an inside, so a point or a line always answers false.
+ * @param {any} value - a Polygon, MultiPolygon, Feature or collection
+ * @param {number} lon
+ * @param {number} lat
+ * @returns {boolean}
+ */
+export declare function containsPosition(value: any, lon: number, lat: number): boolean;
+/**
+ * The distance in metres between two GeoJSON values, measured between
+ * their **representative positions**: a bare position or Point is
+ * itself, anything else is its centroid. Null when either side has no
+ * positions.
+ *
+ * This is deliberately not the minimum distance between two shapes,
+ * which needs point-to-segment geodesics and is a different (and much
+ * larger) piece of work. Callers wanting "how far is this point from
+ * that region" should test containment first.
+ *
+ * @param {any} a
+ * @param {any} b
+ * @param {number} [radius]
+ * @returns {number | null}
+ */
+export declare function geoDistance(a: any, b: any, radius?: number): number | null;
+/**
+ * Whether every linear ring of a value is closed — the invariant the
+ * portable GeoJSON schema cannot express. True for values with no rings.
+ * @param {any} value
+ * @returns {boolean}
+ */
+export declare function ringsClosed(value: any): boolean;

package/dist/types/geo/index-tree.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Interleave the low 16 bits of x and y into a Hilbert distance.
+ * Boxes ordered by this stay spatially clustered, which is what makes
+ * the packed parents tight.
+ *
+ * Bit-parallel: all sixteen levels of the per-bit quadrant rotation run
+ * at once as mask arithmetic (the public-domain transform from
+ * rawrunprotected/hilbert_curves), which is what makes computing 100k of
+ * these a millisecond instead of the build's dominant cost. The values
+ * are identical to the classical per-bit walk of the curve.
+ *
+ * @param {number} x - 0..65535
+ * @param {number} y - 0..65535
+ * @returns {number}
+ */
+export declare function hilbertDistance(x: number, y: number): number;
+export type BboxIndex = {
+    /**
+     * - how many boxes were indexed
+     */
+    size: number;
+    /**
+     *   the indexes of every box whose bounds overlap the query box
+     */
+    search: (minX: number, minY: number, maxX: number, maxY: number) => number[];
+};
+/**
+ * A queryable static index over bounding boxes.
+ * @typedef {Object} BboxIndex
+ * @property {number} size - how many boxes were indexed
+ * @property {(minX: number, minY: number, maxX: number, maxY: number) => number[]} search
+ *   the indexes of every box whose bounds overlap the query box
+ */
+/**
+ * Build a static index over `[west, south, east, north]` boxes.
+ *
+ * The returned `search` yields **candidate** indexes into the original
+ * array: every box that truly overlaps is included, and boxes that merely
+ * share a tree node may be too. Confirm each with the exact test.
+ *
+ * A null entry (a value with no positions, so no box) is indexed as a
+ * degenerate box that overlaps nothing, so it can never be a candidate
+ * while the array indexes stay aligned with the caller's data.
+ *
+ * @param {Array<number[] | null>} boxes
+ * @param {number} [nodeSize] - children per node
+ * @returns {BboxIndex}
+ * @example
+ * const index = createBboxIndex(regions.map(bboxOf));
+ * for (const i of index.search(...bboxOf(point))) confirm(regions[i]);
+ */
+export declare function createBboxIndex(boxes: Array<number[] | null>, nodeSize?: number): BboxIndex;

package/dist/types/geo/index.d.ts

@@ -0,0 +1,11 @@
+export * from './predicates.js';
+export * from './distance.js';
+export * from './ring.js';
+export * from './bbox.js';
+export * from './geohash.js';
+export * from './geojson.js';
+export * from './valid.js';
+export * from './wkt.js';
+export * from './index-tree.js';
+export * from './mercator.js';
+export * from './simplify.js';

package/dist/types/geo/mercator.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The latitude where Web Mercator's y reaches the edge of its square.
+ * Poleward of this the projection is unbounded.
+ */
+export declare const MERCATOR_MAX_LAT = 85.05112877980659;
+/**
+ * Project a position into the Web Mercator unit square: x and y both in
+ * `[0, 1]`, with **y increasing southward** so the result is already in
+ * screen order and a renderer needs no flip.
+ *
+ * Latitude is clamped, longitude is not: a latitude past the Mercator
+ * limit has a defensible answer (the edge) while a longitude past ±180
+ * is simply invalid under RFC 7946, and folding it silently into range
+ * would move a shape to the wrong side of the world rather than let the
+ * defect show.
+ *
+ * @param {number} lon - longitude in degrees, `[-180, 180]`
+ * @param {number} lat - latitude in degrees, clamped to ±85.051129
+ * @returns {[number, number]} `[x, y]` in the unit square
+ * @example
+ * projectMercator(0, 0);      // [0.5, 0.5] — null island is the centre
+ * projectMercator(-180, 85.05112877980659); // [0, 0] — the north-west corner
+ */
+export declare function projectMercator(lon: number, lat: number): [number, number];
+/**
+ * The inverse of {@link projectMercator}: a unit-square point back to a
+ * position. Needed to turn a click or a viewport corner back into
+ * longitude and latitude.
+ *
+ * @param {number} x - 0..1
+ * @param {number} y - 0..1, increasing southward
+ * @returns {[number, number]} `[longitude, latitude]` in degrees
+ */
+export declare function unprojectMercator(x: number, y: number): [number, number];
+/**
+ * A projection fitted to a geographic bounding box: the transform that
+ * maps positions inside `bbox` into `[0, 1]` on both axes, **without
+ * distorting the aspect ratio**, centring whichever axis has room left
+ * over.
+ *
+ * Stretching a map to fill its frame is the single most common way to
+ * make one look wrong, so the fit is uniform by construction and the
+ * spare room becomes margin rather than distortion. `aspect` is the
+ * width:height ratio of the frame the result will be drawn into: the fit
+ * happens in a box `aspect` wide and 1 tall, then x is divided back down
+ * so both outputs are in `[0, 1]` — the same unit-square convention the
+ * treemap uses, where the renderer maps height from width by the same
+ * ratio.
+ *
+ * @param {number[]} bbox - `[west, south, east, north]`
+ * @param {number} [aspect] - frame width:height (default 1, a square)
+ * @returns {(lon: number, lat: number) => [number, number]}
+ * @example
+ * const fit = fitMercator([4, 52, 5, 53], 1.6);
+ * fit(4.5, 52.5); // near [0.5, 0.5] whatever the box's shape
+ */
+export declare function fitMercator(bbox: number[], aspect?: number): (lon: number, lat: number) => [number, number];

package/dist/types/geo/predicates.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The orientation of the triple (a, b, c): **positive** when c lies to
+ * the left of the directed line a->b (counter-clockwise), **negative**
+ * when it lies to the right, and **exactly zero** when the three points
+ * are collinear.
+ *
+ * The sign is always correct. The magnitude is twice the signed area of
+ * the triangle, but only approximately — callers must use this for its
+ * sign, and `ringArea` for a measurement.
+ *
+ * Coordinates are raw numbers rather than vector objects so a GeoJSON
+ * position (`[lon, lat]`) can be passed straight through.
+ *
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} cx
+ * @param {number} cy
+ * @returns {number} positive, negative, or zero
+ * @example
+ * orient2d(0, 0, 1, 0, 0, 1);  // > 0 — (0,1) is left of the x axis
+ * orient2d(0, 0, 1, 0, 0, -1); // < 0
+ * orient2d(0, 0, 2, 2, 1, 1);  // 0 — exactly collinear
+ */
+export declare function orient2d(ax: number, ay: number, bx: number, by: number, cx: number, cy: number): number;
+/**
+ * The same determinant without the exact fallback: fast, and **wrong on
+ * near-collinear input**.
+ *
+ * This exists for the one case where that is acceptable — a bounding
+ * pre-filter whose answer is checked by `orient2d` afterwards. Anything
+ * that decides containment, winding or intersection must use `orient2d`;
+ * a wrong sign there is a wrong answer, not a rounding error.
+ *
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} cx
+ * @param {number} cy
+ * @returns {number}
+ */
+export declare function orient2dFast(ax: number, ay: number, bx: number, by: number, cx: number, cy: number): number;

package/dist/types/geo/ring.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Whether a ring is closed: its last position repeats its first.
+ *
+ * Compares longitude and latitude only. A position may legally carry a
+ * third element (altitude), and RFC 7946 does not require it to match
+ * for the ring to close.
+ *
+ * @param {Array<number[]>} ring - positions
+ * @returns {boolean}
+ * @example
+ * isRingClosed([[0,0],[1,0],[1,1],[0,0]]); // true
+ * isRingClosed([[0,0],[1,0],[1,1]]);       // false
+ */
+export declare function isRingClosed(ring: Array<number[]>): boolean;
+/**
+ * Twice the signed planar area of a ring (the shoelace sum), in squared
+ * degrees. **Positive is counter-clockwise.**
+ *
+ * The sign is the useful part and is exact for the purpose: it is a sum
+ * of `orient2d` determinants about the ring's first vertex, so a ring
+ * whose vertices are near-collinear still winds the way this says. The
+ * magnitude is a planar quantity in degree-space and is NOT an area on
+ * the Earth — use `sphericalRingArea` for that.
+ *
+ * @param {Array<number[]>} ring - positions
+ * @returns {number} twice the signed area; positive = counter-clockwise
+ */
+export declare function ringSignedArea(ring: Array<number[]>): number;
+/**
+ * The winding direction of a ring: `1` counter-clockwise, `-1`
+ * clockwise, `0` degenerate (zero area).
+ *
+ * RFC 7946 section 3.1.6 requires exterior rings to be counter-clockwise
+ * and holes clockwise — the right-hand rule. Parsers are told to accept
+ * non-conforming data, so this reports rather than rejects.
+ *
+ * @param {Array<number[]>} ring - positions
+ * @returns {number} 1, -1 or 0
+ */
+export declare function ringWinding(ring: Array<number[]>): number;
+/**
+ * Geodesic area of a ring on the sphere, in square metres, always
+ * non-negative.
+ *
+ * Uses the spherical excess of the polygon (the standard formula for a
+ * ring of great-circle edges), so unlike `ringSignedArea` this is a real
+ * measurement. Accurate to the sphere approximation — under half a
+ * percent, the same bound as `haversineDistance`.
+ *
+ * @param {Array<number[]>} ring - positions
+ * @param {number} [radius]
+ * @returns {number} square metres
+ */
+export declare function sphericalRingArea(ring: Array<number[]>, radius?: number): number;
+/**
+ * Whether a position lies inside a ring, by the even-odd (crossing)
+ * rule. A position exactly on an edge or vertex counts as **inside**,
+ * which is the convention that makes adjacent polygons tile without
+ * gaps.
+ *
+ * The ray cast runs in the ring's own coordinate space, so this is a
+ * planar test on longitude/latitude. That is what GeoJSON consumers
+ * mean by containment, and it is correct for any ring that does not
+ * cross the antimeridian — which RFC 7946 tells producers to cut.
+ *
+ * @param {number} x - longitude
+ * @param {number} y - latitude
+ * @param {Array<number[]>} ring - positions
+ * @returns {boolean}
+ */
+export declare function pointInRing(x: number, y: number, ring: Array<number[]>): boolean;
+/**
+ * Whether a position lies inside a polygon: inside its exterior ring and
+ * outside every hole.
+ * @param {number} x - longitude
+ * @param {number} y - latitude
+ * @param {Array<Array<number[]>>} rings - a GeoJSON Polygon's coordinates
+ * @returns {boolean}
+ */
+export declare function pointInPolygon(x: number, y: number, rings: Array<Array<number[]>>): boolean;

package/dist/types/geo/simplify.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Simplify a line with the Douglas-Peucker algorithm, keeping every
+ * vertex further than `tolerance` from the line its neighbours describe.
+ *
+ * The first and last positions always survive, so a **ring stays closed**
+ * — simplification can never turn a valid polygon into an invalid one.
+ * Positions are returned by reference, not copied, so any third element
+ * (altitude) rides along untouched.
+ *
+ * @param {Array<number[]>} line - positions
+ * @param {number} tolerance - in the input's own coordinate units
+ * @returns {Array<number[]>} a new array; the input is not modified
+ * @example
+ * simplifyLine([[0,0],[1,0.001],[2,0]], 0.01); // [[0,0],[2,0]]
+ * simplifyLine([[0,0],[1,1],[2,0]], 0.01);     // all three: the corner carries the shape
+ */
+export declare function simplifyLine(line: Array<number[]>, tolerance: number): Array<number[]>;
+/**
+ * Simplify a linear ring, refusing to destroy it.
+ *
+ * A ring needs four positions to bound a surface, so when the tolerance
+ * would leave fewer the ring is returned **unsimplified** rather than
+ * degenerate. Dropping a small island entirely is a defensible rendering
+ * choice, but silently emitting a two-vertex "polygon" is not — a caller
+ * wanting the island gone should filter by area first.
+ *
+ * @param {Array<number[]>} ring - positions, first === last
+ * @param {number} tolerance
+ * @returns {Array<number[]>}
+ */
+export declare function simplifyRing(ring: Array<number[]>, tolerance: number): Array<number[]>;

package/dist/types/geo/valid.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Whether a value is a structurally valid GeoJSON object: one of the
+ * seven geometry types, a Feature, or a FeatureCollection, with the
+ * coordinate nesting its `type` requires, positions of 2 or 3 numbers
+ * inside the WGS 84 bounds, and **every linear ring closed** — the
+ * invariant a JSON Schema cannot state.
+ *
+ * This is the shallow twin of the schema artifacts in `@jarenjs/json`:
+ * it answers yes or no in one call, where the meta-schema reports what
+ * failed and where, and the Jaren-extended variant also checks winding.
+ * Foreign members and a `bbox` are ignored rather than judged, exactly
+ * as the meta-schema leaves them open.
+ *
+ * @param {any} value
+ * @returns {boolean}
+ * @example
+ * isValidGeoJson({ type: 'Point', coordinates: [4.9, 52.4] });        // true
+ * isValidGeoJson({ type: 'Polygon',
+ *   coordinates: [[[0,0],[1,0],[1,1],[0,0]]] });                      // true
+ * isValidGeoJson({ type: 'Polygon',
+ *   coordinates: [[[0,0],[1,0],[1,1],[2,2]]] });                      // false (open ring)
+ * isValidGeoJson({ type: 'Point', coordinates: [52.4, 4.9, 0, 0] });  // false (4 axes)
+ */
+export declare function isValidGeoJson(value: any): boolean;

package/dist/types/geo/wkt.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Whether a string is a well-formed WKT geometry: one of the seven
+ * tagged types, `EMPTY` or a body whose nesting matches the tag, a
+ * coordinate count consistent with the `Z`/`M`/`ZM` modifier and with
+ * itself, closed polygon rings, and nothing before or after.
+ *
+ * @param {string} text
+ * @returns {boolean}
+ * @example
+ * isValidWkt('POINT (4.9041 52.3676)');                  // true
+ * isValidWkt('POLYGON ((0 0, 4 0, 4 4, 0 0))');          // true (closed)
+ * isValidWkt('POLYGON ((0 0, 4 0, 4 4, 1 1))');          // false (open ring)
+ * isValidWkt('POINT Z (1 2)');                           // false (Z wants 3)
+ * isValidWkt('LINESTRING (0 0, 1 1 1)');                 // false (mixed dimension)
+ */
+export declare function isValidWkt(text: string): boolean;