@jarenjs/core 0.9.2 → 0.34.0

package/src/geo/valid.js

@@ -0,0 +1,142 @@
+//@ts-check
+
+//#region GeoJSON validity
+// The one-call structural judgment over a GeoJSON value: the boolean
+// twin of the schema artifacts in `@jarenjs/json`. The portable
+// meta-schema states the same grammar declaratively and reports *where*
+// a document fails; the Jaren variant adds winding through `$query`.
+// This predicate exists for the callers that only need yes-or-no — a
+// `format` tester, a guard before an expensive walk — and it includes
+// the invariant the portable schema provably cannot express: that every
+// linear ring closes.
+//
+// The traversal helpers in geojson.js stay judgment-free on purpose (a
+// measurement that also validated would report the same defect twice);
+// this module is where the judgment lives.
+
+import { isRingClosed } from './ring.js';
+
+/**
+ * A position: an array of 2 or 3 finite numbers, longitude in
+ * `[-180, 180]` and latitude in `[-90, 90]` — the same bounds the
+ * meta-schema states, valid because RFC 7946 fixes the reference system
+ * to WGS 84.
+ */
+function isStrictPosition(value) {
+  if (!Array.isArray(value) || value.length < 2 || value.length > 3)
+    return false;
+  const lon = value[0];
+  const lat = value[1];
+  if (typeof lon !== 'number' || !(lon >= -180 && lon <= 180))
+    return false;
+  if (typeof lat !== 'number' || !(lat >= -90 && lat <= 90))
+    return false;
+  return value.length === 2
+    || (typeof value[2] === 'number' && Number.isFinite(value[2]));
+}
+
+function everyPosition(list) {
+  if (!Array.isArray(list))
+    return false;
+  for (let i = 0; i < list.length; i++) {
+    if (!isStrictPosition(list[i]))
+      return false;
+  }
+  return true;
+}
+
+/** A line: two or more positions. */
+function isLine(list) {
+  return Array.isArray(list) && list.length >= 2 && everyPosition(list);
+}
+
+/** A linear ring: four or more positions, first equal to last. */
+function isRing(list) {
+  return Array.isArray(list) && list.length >= 4 && everyPosition(list)
+    && isRingClosed(list);
+}
+
+function everyOf(list, test) {
+  if (!Array.isArray(list))
+    return false;
+  for (let i = 0; i < list.length; i++) {
+    if (!test(list[i]))
+      return false;
+  }
+  return true;
+}
+
+function isRings(list) {
+  return everyOf(list, isRing);
+}
+
+function isGeometryValue(value, depth) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value))
+    return false;
+  switch (value.type) {
+    case 'Point':
+      return isStrictPosition(value.coordinates);
+    case 'MultiPoint':
+      return everyPosition(value.coordinates);
+    case 'LineString':
+      return isLine(value.coordinates);
+    case 'MultiLineString':
+      return everyOf(value.coordinates, isLine);
+    case 'Polygon':
+      return isRings(value.coordinates);
+    case 'MultiPolygon':
+      return everyOf(value.coordinates, isRings);
+    case 'GeometryCollection':
+      // a nesting guard, not a spec rule: RFC 7946 merely discourages
+      // nested collections, but unbounded recursion on hostile input is
+      // a different problem than an unusual document
+      return depth < 8
+        && everyOf(value.geometries, (g) => isGeometryValue(g, depth + 1));
+    default:
+      return false;
+  }
+}
+
+/**
+ * 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 function isValidGeoJson(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value))
+    return false;
+  if (value.type === 'Feature') {
+    // `properties` and `geometry` are required members; both may be null
+    if (!('properties' in value) || !('geometry' in value))
+      return false;
+    if (value.properties !== null
+      && (typeof value.properties !== 'object' || Array.isArray(value.properties)))
+      return false;
+    return value.geometry === null || isGeometryValue(value.geometry, 0);
+  }
+  if (value.type === 'FeatureCollection') {
+    return everyOf(value.features, (f) => f !== null && typeof f === 'object'
+      && !Array.isArray(f) && f.type === 'Feature' && isValidGeoJson(f));
+  }
+  return isGeometryValue(value, 0);
+}
+
+//#endregion

package/src/geo/wkt.js

@@ -0,0 +1,262 @@
+//@ts-check
+
+//#region Well-Known Text
+// A validity tester for WKT (ISO 19125 / OGC Simple Features), the text
+// encoding every spatial database speaks. Nothing here *parses into* a
+// geometry — the suite's representation is GeoJSON, and a WKT string in
+// a JSON document is interchange data passing through — but a schema can
+// still assert that such a string is well-formed, which is what a
+// `format` needs: a plain predicate over the string itself.
+//
+// The grammar is validated strictly: the seven geometry tags, an
+// optional Z/M/ZM dimension modifier, `EMPTY` or a parenthesized body,
+// and a consistent coordinate count per geometry. The dimension rule
+// follows the field rather than the letter of SFA: an unmodified tag
+// accepts 2 or 3 coordinates per point (PostGIS reads `POINT(1 2 3)` as
+// 3D), `Z` and `M` require exactly 3, `ZM` exactly 4 — but whichever
+// count the first point establishes, every following point must match.
+// Polygon rings must close and carry at least four points, as the spec
+// requires. No leading or trailing text is tolerated: a format that
+// trims would accept strings a consumer then fails on.
+
+import {
+  isAsciiLetterCode,
+  isDigitCode,
+  isWhitespaceCode,
+} from '../scan.js';
+
+// character codes
+const LPAREN = 0x28;
+const RPAREN = 0x29;
+const COMMA = 0x2C;
+const PLUS = 0x2B;
+const MINUS = 0x2D;
+const DOT = 0x2E;
+
+function skipWs(text, at) {
+  while (at < text.length && isWhitespaceCode(text.charCodeAt(at)))
+    at++;
+  return at;
+}
+
+/** Read a run of letters, uppercased; returns [word, next] or null. */
+function readWord(text, at) {
+  let end = at;
+  while (end < text.length && isAsciiLetterCode(text.charCodeAt(end)))
+    end++;
+  return end === at ? null : [text.slice(at, end).toUpperCase(), end];
+}
+
+/** Advance past one signed decimal number, or return -1. */
+function scanNumber(text, at) {
+  let i = at;
+  const c = i < text.length ? text.charCodeAt(i) : 0;
+  if (c === PLUS || c === MINUS)
+    i++;
+  let digits = 0;
+  while (i < text.length && isDigitCode(text.charCodeAt(i))) {
+    i++;
+    digits++;
+  }
+  if (i < text.length && text.charCodeAt(i) === DOT) {
+    i++;
+    while (i < text.length && isDigitCode(text.charCodeAt(i))) {
+      i++;
+      digits++;
+    }
+  }
+  if (digits === 0)
+    return -1;
+  const e = i < text.length ? text.charCodeAt(i) : 0;
+  if (e === 0x45 || e === 0x65) { // E e
+    let j = i + 1;
+    const sign = j < text.length ? text.charCodeAt(j) : 0;
+    if (sign === PLUS || sign === MINUS)
+      j++;
+    let exp = 0;
+    while (j < text.length && isDigitCode(text.charCodeAt(j))) {
+      j++;
+      exp++;
+    }
+    if (exp === 0)
+      return -1;
+    i = j;
+  }
+  return i;
+}
+
+/**
+ * One point: `dim.n` coordinates separated by whitespace. A zero `dim.n`
+ * means the modifier allowed 2 or 3, and the first point decides which.
+ * Returns the position after the point, or -1.
+ */
+function scanPoint(text, at, dim) {
+  let i = scanNumber(text, skipWs(text, at));
+  if (i < 0)
+    return -1;
+  let count = 1;
+  for (;;) {
+    const j = skipWs(text, i);
+    if (j === i)
+      break; // numbers must be whitespace-separated
+    const k = scanNumber(text, j);
+    if (k < 0)
+      break;
+    i = k;
+    count++;
+  }
+  if (dim.n === 0) {
+    if (count !== 2 && count !== 3)
+      return -1;
+    dim.n = count;
+  }
+  else if (count !== dim.n) {
+    return -1;
+  }
+  return i;
+}
+
+/**
+ * A parenthesized, comma-separated list validated by `scanItem`, with at
+ * least `min` items. `first` may record where each item's scan started —
+ * the hook ring closure uses. Returns the position after `)`, or -1.
+ */
+function scanList(text, at, dim, min, scanItem, starts) {
+  let i = skipWs(text, at);
+  if (i >= text.length || text.charCodeAt(i) !== LPAREN)
+    return -1;
+  i++;
+  let count = 0;
+  for (;;) {
+    const from = skipWs(text, i);
+    if (starts !== null)
+      starts.push(from);
+    i = scanItem(text, from, dim);
+    if (i < 0)
+      return -1;
+    count++;
+    i = skipWs(text, i);
+    const c = i < text.length ? text.charCodeAt(i) : 0;
+    if (c === COMMA) {
+      i++;
+      continue;
+    }
+    if (c === RPAREN)
+      return count >= min ? i + 1 : -1;
+    return -1;
+  }
+}
+
+/** A point that may also be wrapped in its own parens (MULTIPOINT). */
+function scanMultiPointItem(text, at, dim) {
+  if (at < text.length && text.charCodeAt(at) === LPAREN) {
+    const i = scanPoint(text, at + 1, dim);
+    if (i < 0)
+      return -1;
+    const j = skipWs(text, i);
+    return j < text.length && text.charCodeAt(j) === RPAREN ? j + 1 : -1;
+  }
+  return scanPoint(text, at, dim);
+}
+
+function scanLineStringBody(text, at, dim) {
+  return scanList(text, at, dim, 2, scanPoint, null);
+}
+
+/** A ring: four or more points, and the first equals the last. */
+function scanRing(text, at, dim) {
+  const starts = [];
+  const i = scanList(text, at, dim, 4, scanPoint, starts);
+  if (i < 0)
+    return -1;
+  // compare the first and last point textually by re-scanning both spans
+  const first = pointText(text, starts[0], dim);
+  const last = pointText(text, starts[starts.length - 1], dim);
+  return first !== null && first === last ? i : -1;
+}
+
+/** The point's coordinates as a normalized string, for closure tests. */
+function pointText(text, at, dim) {
+  const end = scanPoint(text, at, dim);
+  if (end < 0)
+    return null;
+  const parts = text.slice(at, end).trim().split(/\s+/);
+  return parts.map(Number).join(',');
+}
+
+function scanPolygonBody(text, at, dim) {
+  return scanList(text, at, dim, 1, scanRing, null);
+}
+
+/**
+ * One tagged geometry: `TAG [Z|M|ZM] (EMPTY | body)`. Returns the
+ * position after it, or -1.
+ */
+function scanGeometry(text, at) {
+  const word = readWord(text, skipWs(text, at));
+  if (word === null)
+    return -1;
+  const [tag, afterTag] = word;
+  let i = afterTag;
+  // an exact count from the modifier, or 0 for "2 or 3, first point decides"
+  const dim = { n: 0 };
+  const mod = readWord(text, skipWs(text, i));
+  if (mod !== null && (mod[0] === 'Z' || mod[0] === 'M' || mod[0] === 'ZM')) {
+    dim.n = mod[0] === 'ZM' ? 4 : 3;
+    i = mod[1];
+  }
+  const empty = readWord(text, skipWs(text, i));
+  if (empty !== null && empty[0] === 'EMPTY')
+    return empty[1];
+
+  switch (tag) {
+    case 'POINT': {
+      const j = skipWs(text, i);
+      if (j >= text.length || text.charCodeAt(j) !== LPAREN)
+        return -1;
+      const k = scanPoint(text, j + 1, dim);
+      if (k < 0)
+        return -1;
+      const l = skipWs(text, k);
+      return l < text.length && text.charCodeAt(l) === RPAREN ? l + 1 : -1;
+    }
+    case 'LINESTRING':
+      return scanLineStringBody(text, i, dim);
+    case 'POLYGON':
+      return scanPolygonBody(text, i, dim);
+    case 'MULTIPOINT':
+      return scanList(text, i, dim, 1, scanMultiPointItem, null);
+    case 'MULTILINESTRING':
+      return scanList(text, i, dim, 1, scanLineStringBody, null);
+    case 'MULTIPOLYGON':
+      return scanList(text, i, dim, 1, scanPolygonBody, null);
+    case 'GEOMETRYCOLLECTION':
+      // members are whole tagged geometries with modifiers of their own
+      return scanList(text, i, dim, 1, (t, a) => scanGeometry(t, a), null);
+    default:
+      return -1;
+  }
+}
+
+/**
+ * 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 function isValidWkt(text) {
+  if (typeof text !== 'string' || text.length === 0 || isWhitespaceCode(text.charCodeAt(0)))
+    return false;
+  return scanGeometry(text, 0) === text.length;
+}
+
+//#endregion

package/src/math/float64.js

@@ -9,6 +9,24 @@ export const mathf64_cos = Math.cos;
 export const mathf64_atan2 = Math.atan2;
 export const mathf64_asin = Math.asin;
 
+// Transcendental completeness. Free `Math.*` aliases, in the
+// module's existing naming style, so downstream packages bind them by
+// import instead of reaching for the global `Math`.
+export const mathf64_tan = Math.tan;
+export const mathf64_acos = Math.acos;
+export const mathf64_atan = Math.atan;
+export const mathf64_sinh = Math.sinh;
+export const mathf64_cosh = Math.cosh;
+export const mathf64_tanh = Math.tanh;
+export const mathf64_cbrt = Math.cbrt;
+export const mathf64_log = Math.log;
+export const mathf64_log2 = Math.log2;
+export const mathf64_log10 = Math.log10;
+export const mathf64_exp = Math.exp;
+export const mathf64_expm1 = Math.expm1;
+export const mathf64_hypot = Math.hypot;
+export const mathf64_sign = Math.sign;
+
 export const mathf64_ceil = Math.ceil;
 export const mathf64_floor = Math.floor;
 export const mathf64_round = Math.round;
@@ -21,6 +39,11 @@ export const mathf64_EPSILON = +0.000001;
 
 export const mathf64_SQRTFIVE = +mathf64_sqrt(5);
 
+export const mathf64_E = +Math.E;
+export const mathf64_LN2 = +Math.LN2;
+export const mathf64_LN10 = +Math.LN10;
+export const mathf64_PHI = +((1 + mathf64_sqrt(5)) / 2);
+
 export const mathf64_PI = +Math.PI;
 export const mathf64_PI2 = +(mathf64_PI * 2);
 export const mathf64_PI1H = +(mathf64_PI / 2);
@@ -151,16 +174,6 @@ export class Float64 {
     return +((value - min) / (max - min));
   }
 
-  static lerp(norm = 0.0, min = 0.0, max = 0.0) {
-    norm = +norm; min = +min; max = +max;
-    return +((max - min) * (norm + min));
-  }
-
-  static map(value = 0.0, smin = 0.0, smax = 0.0, dmin = 0.0, dmax = 0.0) {
-    value = +value; smin = +smin; smax = +smax; dmin = +dmin; dmax = +dmax;
-    return +Float64.lerp(+Float64.norm(value, smin, smax), dmin, dmax);
-  }
-
   /**
    * Clamps a value between a checked boundary.
    * and can therefor handle swapped min/max arguments
@@ -239,6 +252,7 @@ export class Float64 {
   }
 
   static cosHp(r = 0.0) {
+    // High-precision polynomial cosine (Nick's approximation).
     //   template<typename T>
     // inline T cos(T x) noexcept
     // {
@@ -251,7 +265,13 @@ export class Float64 {
     //     #endif
     //     return x;
     // }
-    throw new Error('float64_cosHp is not implemented! r=' + String(r));
+    r = +r;
+    const tp = +(1.0 / +mathf64_PI2);
+    let x = +(+r * tp);
+    x = +(x - +(0.25 + +mathf64_floor(+(x + 0.25))));
+    x = +(x * +(16.0 * +(+mathf64_abs(x) - 0.5)));
+    x = +(x + +(0.225 * x * +(+mathf64_abs(x) - 1.0)));
+    return +x;
   }
 
   static sinMpEx(r = 0.0) {
@@ -313,4 +333,201 @@ export class Float64 {
 
   //#endregion
 
+  //#region transcendental completeness
+
+  /**
+   * The base-e logarithm of `x` in an arbitrary base.
+   * @param {number} base
+   * @param {number} x
+   * @returns {number}
+   */
+  static logBase(base = 0.0, x = 0.0) {
+    return +(+mathf64_log(+x) / +mathf64_log(+base));
+  }
+
+  /**
+   * The sign of `x` (-1, 0 or +1); preserves ±0 and NaN like `Math.sign`.
+   * @param {number} x
+   * @returns {number}
+   */
+  static sign(x = 0.0) {
+    return +mathf64_sign(+x);
+  }
+
+  /**
+   * The Euclidean length of any number of components, overflow-safe.
+   * @param {...number} args
+   * @returns {number}
+   */
+  static hypot(...args) {
+    return +mathf64_hypot(...args);
+  }
+
+  /**
+   * The real `n`-th root of `x` (odd roots of negatives handled).
+   * @param {number} x
+   * @param {number} n
+   * @returns {number}
+   */
+  static nthroot(x = 0.0, n = 0.0) {
+    x = +x; n = +n;
+    if (x < 0.0 && (n % 2.0) !== 0.0) {
+      return +(-mathf64_pow(-x, +(1.0 / n)));
+    }
+    return +mathf64_pow(x, +(1.0 / n));
+  }
+
+  /**
+   * Round `value` to `digits` decimal places (banker-free, half-up).
+   * @param {number} value
+   * @param {number} [digits]
+   * @returns {number}
+   */
+  static roundTo(value = 0.0, digits = 0.0) {
+    value = +value; digits = +digits | 0;
+    if (!isFinite(value)) return +value;
+    const f = +mathf64_pow(10.0, digits);
+    return +(+mathf64_round(+(value * f)) / f);
+  }
+
+  /**
+   * Round `value` to `digits` significant figures (1–100) — the numeric
+   * value of `Number.prototype.toPrecision`, without its exponential
+   * string formatting.
+   * @param {number} value
+   * @param {number} [digits]
+   * @returns {number}
+   */
+  static roundToPrecision(value = 0.0, digits = 1.0) {
+    value = +value; digits = +digits | 0;
+    if (!isFinite(value)) return +value;
+    return +Number(value.toPrecision(digits));
+  }
+
+  /**
+   * The Lanczos approximation of the Gamma function, valid for the whole
+   * real line (poles at non-positive integers return ±Infinity/NaN).
+   * @param {number} x
+   * @returns {number}
+   */
+  static gamma(x = 0.0) {
+    x = +x;
+    // Reflection for the left half-plane: Γ(x)Γ(1-x) = π / sin(πx).
+    if (x < 0.5) {
+      return +(mathf64_PI / +(mathf64_sin(+(mathf64_PI * x)) * +Float64.gamma(+(1.0 - x))));
+    }
+    x -= 1.0;
+    // g=7, n=9 Lanczos coefficients.
+    const g = 7.0;
+    const c = _LANCZOS_G7;
+    let a = +c[0];
+    const t = +(x + g + 0.5);
+    for (let i = 1; i < c.length; i++) {
+      a += +(c[i] / +(x + i));
+    }
+    return +(+mathf64_sqrt(+(2.0 * mathf64_PI)) * +mathf64_pow(t, +(x + 0.5)) * +mathf64_exp(-t) * a);
+  }
+
+  /**
+   * The factorial `n!`. Integer `n` uses an exact product; non-integers
+   * are lifted to `gamma(n + 1)`. Negative integers return NaN.
+   * @param {number} n
+   * @returns {number}
+   */
+  static factorial(n = 0.0) {
+    n = +n;
+    if (n < 0.0 && mathf64_floor(n) === n) return NaN;
+    if (mathf64_floor(n) === n) {
+      let acc = 1.0;
+      for (let i = 2.0; i <= n; i += 1.0) acc *= i;
+      return +acc;
+    }
+    return +Float64.gamma(+(n + 1.0));
+  }
+
+  //#endregion
+
+}
+
+/**
+ * Linear remap of `v` from the source range `[smin, smax]` to the destination
+ * range `[dmin, dmax]`: `dmin + t·(dmax - dmin)` with
+ * `t = (v - smin)/(smax - smin)`. A degenerate source range collapses to
+ * `dmin` rather than dividing by zero, so a constant-valued axis still maps to
+ * a drawable coordinate. Inverted destination ranges are supported, which is
+ * what screen-space y-flips need.
+ *
+ * @param {number} v
+ * @param {number} smin
+ * @param {number} smax
+ * @param {number} dmin
+ * @param {number} dmax
+ * @returns {number}
+ */
+export function remap(v, smin, smax, dmin, dmax) {
+  if (smax === smin) return dmin;
+  return dmin + ((v - smin) / (smax - smin)) * (dmax - dmin);
 }
+
+/**
+ * The "nice" axis step — 1, 2 or 5 times a power of ten — that covers `span`
+ * in roughly `count` steps, so a tick sequence reads as 0/2/4/6 rather than
+ * 0/1.7/3.4. `count` is floored at 1; pass a pre-divided per-step span and
+ * leave it at its default to get the ladder alone.
+ *
+ * The ladder is pure arithmetic with no domain guard: it is the caller who
+ * knows what a non-positive or non-finite `span` means for its axis, and
+ * different axes answer that differently.
+ *
+ * @param {number} span the domain span to cover
+ * @param {number} [count] desired number of steps (floored at 1)
+ * @returns {number}
+ */
+export function niceStep(span, count = 1) {
+  const raw = span / Math.max(1, count);
+  const base = Math.pow(10, Math.floor(Math.log10(raw)));
+  const unit = raw / base;
+  const factor = unit < 1.5 ? 1 : unit < 3 ? 2 : unit < 7 ? 5 : 10;
+  return factor * base;
+}
+
+/**
+ * Clamp a value into the unit interval `[0, 1]` — the fraction every
+ * unit-space geometry stage emits. `NaN` passes through as `NaN` rather
+ * than collapsing to a boundary, so a non-finite input stays visible to
+ * the caller instead of silently rendering at an edge; callers that want a
+ * drawable coordinate regardless guard with `Number.isFinite` first.
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+export function clamp01(v) {
+  return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+
+/**
+ * Geometric mean — the honest average of ratios (a 10× and a 0.1×
+ * average to parity, where an arithmetic mean would claim 5×).
+ * Non-finite and non-positive entries are skipped; `null` when nothing
+ * usable remains.
+ * @param {number[]} values
+ * @returns {number|null}
+ */
+export function geoMean(values) {
+  const usable = values.filter((v) => Number.isFinite(v) && v > 0);
+  if (usable.length === 0) return null;
+  return Math.exp(usable.reduce((sum, v) => sum + Math.log(v), 0) / usable.length);
+}
+
+/** Lanczos g=7 coefficients (shared, allocation-free). */
+const _LANCZOS_G7 = [
+  0.99999999999980993,
+  676.5203681218851,
+  -1259.1392167224028,
+  771.32342877765313,
+  -176.61502916214059,
+  12.507343278686905,
+  -0.13857109526572012,
+  9.9843695780195716e-6,
+  1.5056327351493116e-7,
+];