@math.gl/core 5.0.0-alpha.2 → 5.0.0-alpha.20

package/src/spheroid.ts

@@ -0,0 +1,230 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Forward geocentric equations and Hannover inverse moved/adapted from math.gl projection's proj4js 2.22.0 datumUtils.js port. See ../PROJ4-LICENSE.md. Safeguarded compensated nearest-footpoint inverse, thin-exterior/pole fixes and numeric output commit are original math.gl code, qualified with independent mathematics and offline GeographicLib 2.7 (Charles Karney, MIT).
+
+/** Numeric leaf: angles in radians, distances in axis units; no CRS, global config or scratch. */
+import type {SpheroidParameters} from './types';
+export type SpheroidGeometry = SpheroidParameters & {readonly eccentricitySquared: number};
+export type SpheroidPoint = {x: number; y: number; z: number};
+
+const EPSILON = Number.EPSILON;
+
+/** Caller supplies validated positive finite axes and eccentricity. No latitude wrapping. */
+export function spheroidToCartesian(
+  point: SpheroidPoint,
+  geometry: SpheroidGeometry,
+  result: SpheroidPoint = point
+): boolean {
+  const longitude = point.x,
+    latitude = point.y,
+    height = point.z;
+  const {semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es} = geometry;
+  const sin = Math.sin(latitude),
+    cos = Math.abs(latitude) === Math.PI / 2 ? 0 : Math.cos(latitude);
+  // Use the axis ratio for very flat shapes: 1 - es*sin² loses polar precision.
+  const ratio = b / a;
+  const radius = es < 0.9 ? a / Math.sqrt(1 - es * sin * sin) : a / Math.hypot(cos, ratio * sin);
+  const x = (radius + height) * cos * Math.cos(longitude);
+  const y = (radius + height) * cos * Math.sin(longitude);
+  const z = (radius * (es < 0.9 ? 1 - es : ratio * ratio) + height) * sin;
+  return commit(result, x, y, z);
+}
+
+/**
+ * Bounded inverse. Sphere is analytic; ordinary spheroids use the retained Hannover
+ * iteration on exterior points. Interiors and thin-shape exteriors share a safeguarded nearest-footpoint solve.
+ * Equatorial interiors below the evolute cusp have two nearest normals: reject.
+ * false leaves output untouched, including the center and unresolved binary64 cases.
+ * Only exact poles canonicalize longitude; adapters may retain other conventions.
+ */
+export function cartesianToSpheroid(
+  point: SpheroidPoint,
+  geometry: SpheroidGeometry,
+  result: SpheroidPoint = point
+): boolean {
+  const x = point.x,
+    y = point.y,
+    z = point.z;
+  const {semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es} = geometry;
+  const longitude = Math.atan2(y, x);
+  const p = Math.hypot(x, y),
+    rr = Math.hypot(x, y, z);
+  if (!(rr > 0) || !Number.isFinite(rr)) return false;
+  if (es === 0) return commit(result, p === 0 ? 0 : longitude, Math.atan2(z, p), rr - a);
+  if (p === 0) return commit(result, 0, (Math.sign(z) * Math.PI) / 2, Math.abs(z) - b);
+  const horizontal = p / a,
+    vertical = z / b;
+  if (horizontal * horizontal + vertical * vertical < 1 - 16 * EPSILON)
+    return interiorInverse(x, y, z, p, a, b, result);
+  if (es >= 0.9) return interiorInverse(x, y, z, p, a, b, result);
+  const ct = z / rr,
+    st = p / rr;
+  let rx = 1 / Math.sqrt(1 - es * (2 - es) * st * st);
+  let cos = st * (1 - es) * rx,
+    sin = ct * rx;
+  for (let i = 0; i < 30; i++) {
+    const rn = a / Math.sqrt(1 - es * sin * sin);
+    const height = p * cos + z * sin - rn * (1 - es * sin * sin);
+    const rk = (es * rn) / (rn + height);
+    rx = 1 / Math.sqrt(1 - rk * (2 - rk) * st * st);
+    const nextCos = st * (1 - rk) * rx,
+      nextSin = ct * rx;
+    if (Math.abs(nextSin * cos - nextCos * sin) <= 1e-12) {
+      if (!Number.isFinite(height)) break;
+      return commit(result, longitude, Math.atan2(nextSin, Math.abs(nextCos)), height);
+    }
+    cos = nextCos;
+    sin = nextSin;
+  }
+  return interiorInverse(x, y, z, p, a, b, result);
+}
+
+/** Original nearest-normal solve in t = (lambda + b²)/a², avoiding interior cancellation and thin-exterior residual loss.
+ * The positive interval selects the globally nearest branch, rather than a stationary normal.
+ */
+function interiorInverse(
+  x: number,
+  y: number,
+  z: number,
+  p: number,
+  a: number,
+  b: number,
+  result: SpheroidPoint
+): boolean {
+  const longitude = Math.atan2(y, x);
+  const ratio = b / a,
+    ratio2 = ratio * ratio;
+  const horizontal = p / a,
+    vertical = z / a,
+    delta = 1 - ratio2;
+  if (!(ratio2 > 0) || ratio > 1) return false;
+  const aa = a * a,
+    bb = b * b;
+  const ratioError =
+    Number.isFinite(aa) && aa > 0
+      ? (bb -
+          ratio2 * aa +
+          productError(b, b, bb) -
+          ratio2 * productError(a, a, aa) -
+          productError(ratio2, aa, ratio2 * aa)) /
+        aa
+      : 0;
+  const pp = p * p,
+    xx = x * x,
+    yy = y * y,
+    sum = xx + yy;
+  const radiusError =
+    Number.isFinite(pp) && pp > 0
+      ? (sum -
+          pp +
+          sumError(xx, yy, sum) +
+          productError(x, x, xx) +
+          productError(y, y, yy) -
+          productError(p, p, pp)) /
+        (2 * p)
+      : 0;
+  const shift = a * ratio2,
+    distance = p - a,
+    base = distance + shift;
+  const correction =
+    radiusError +
+    sumError(p, -a, distance) +
+    sumError(distance, shift, base) +
+    productError(a, ratio2, shift) +
+    a * ratioError;
+  if (z === 0) {
+    // A rounded hypot can equal the cusp for points just inside it. Include
+    // the radius/axis corrections before selecting a unique equatorial normal.
+    if (base + correction < 0) return false;
+    return commit(result, longitude, 0, distance);
+  }
+  const weighted = Math.abs(vertical) * ratio;
+  let lower = 0,
+    upper = ratio2 + Math.hypot(horizontal, vertical * ratio);
+  if (!Number.isFinite(upper)) return false;
+  // A lower bound near the short-axis singularity prevents thousands of bisections
+  // for deep, nearly equatorial interiors. No subtraction of lambda and -b².
+  let t = Math.max(weighted, horizontal - delta);
+  if (!(t > lower && t < upper)) t = upper / 2;
+  // Below the cusp, a vanishing polar input can make t subnormal. The
+  // limiting vertical footpoint remains well conditioned. Use it only when
+  // its bound t <= abs(z)*ratio/(a*v) is negligible relative to the cusp gap.
+  const gap = -(base + correction) / a;
+  const limiting = Math.sqrt(gap * (horizontal + delta)) / delta;
+  let latitude: number | undefined =
+    gap > 0 && (Math.abs(z) / limiting / a) * ratio <= EPSILON * gap
+      ? Math.atan2((Math.sign(z) * limiting) / ratio, horizontal / delta)
+      : undefined;
+  for (let i = 0; i < 1024 && latitude === undefined; i++) {
+    const equatorial = delta + t;
+    const u = horizontal / equatorial,
+      // Divide by t first: both z/a and a*t can lose precision in the
+      // subnormal range although the near-cusp latitude is representable.
+      verticalAt = z / t / a,
+      v = verticalAt * ratio;
+    const at = a * t,
+      difference = base - at;
+    const offset =
+      (difference + (sumError(base, -at, difference) + correction - productError(a, t, at))) /
+      (a * equatorial);
+    const term = offset * (u + 1);
+    const residual = term + v * v;
+    if (!Number.isFinite(residual)) return false;
+    if (residual > 0) lower = t;
+    else upper = t;
+    const derivative = -2 * ((u * u) / equatorial + (v * v) / t);
+    const next = t - residual / derivative;
+    const candidate = next > lower && next < upper ? next : lower + (upper - lower) / 2;
+    if (
+      Math.abs(residual) <= 4 * EPSILON * (Math.abs(term) + v * v) ||
+      upper - lower <= 4 * EPSILON * t
+    ) {
+      latitude = Math.atan2(verticalAt, u);
+      break;
+    }
+    t = candidate;
+  }
+  return latitude !== undefined && commitNormal(result, longitude, latitude, p, z, a, ratio);
+}
+
+/** Error-free transforms on the finite squared-axis domain used by geometry adapters. */
+function sumError(x: number, y: number, sum: number): number {
+  const part = sum - x;
+  return x - (sum - part) + (y - part);
+}
+function productError(x: number, y: number, product: number): number {
+  const sx = 134217729 * x,
+    sy = 134217729 * y;
+  if (!Number.isFinite(sx) || !Number.isFinite(sy)) return 0;
+  const hx = sx - (sx - x),
+    hy = sy - (sy - y),
+    lx = x - hx,
+    ly = y - hy;
+  return hx * hy - product + hx * ly + lx * hy + lx * ly;
+}
+
+/** Shared signed distance along the solved surface normal. */
+function commitNormal(
+  result: SpheroidPoint,
+  longitude: number,
+  latitude: number,
+  p: number,
+  z: number,
+  a: number,
+  ratio: number
+): boolean {
+  const sin = Math.sin(latitude),
+    cos = Math.cos(latitude);
+  return commit(result, longitude, latitude, p * cos + z * sin - a * Math.hypot(cos, ratio * sin));
+}
+
+/** Values are captured before invoking application setters; recursive writes are safe. */
+function commit(result: SpheroidPoint, x: number, y: number, z: number): boolean {
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return false;
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return true;
+}

package/src/types/array-types.ts

@@ -0,0 +1,148 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+// Float16Array is declared in a separate TypeScript library. Preserve this reference so
+// published declarations remain self-contained without changing the target or emitting runtime code.
+// eslint-disable-next-line spaced-comment
+/// <reference lib="es2025.float16" preserve="true" />
+
+/**
+ * Type covering all non-big JavaScript typed arrays, including `Float16Array`.
+ *
+ * @remarks Including `Float16Array` does not guarantee that `globalThis.Float16Array` exists.
+ */
+export type TypedArray =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float16Array
+  | Float32Array
+  | Float64Array;
+
+/**
+ * Type covering constructors for all non-big JavaScript typed arrays, including
+ * `Float16ArrayConstructor`.
+ *
+ * @remarks Including `Float16ArrayConstructor` does not install `globalThis.Float16Array`.
+ */
+export type TypedArrayConstructor =
+  | Int8ArrayConstructor
+  | Uint8ArrayConstructor
+  | Uint8ClampedArrayConstructor
+  | Int16ArrayConstructor
+  | Uint16ArrayConstructor
+  | Int32ArrayConstructor
+  | Uint32ArrayConstructor
+  | Float16ArrayConstructor
+  | Float32ArrayConstructor
+  | Float64ArrayConstructor;
+
+/**
+ * Type covering all big typed arrays
+ */
+export type BigTypedArray = BigInt64Array | BigUint64Array;
+
+/**
+ * Type covering constructors for all big typed arrays
+ */
+export type BigTypedArrayConstructor = BigInt64ArrayConstructor | BigUint64ArrayConstructor;
+
+/**
+ * Type for classic arrays consisting of numbers
+ * @note Included for completeness / orthogonality, prefer `number[]` in actual use
+ */
+export type NumberArray = number[];
+
+/** Array with exactly 1 number */
+export type NumberArray1 = [number];
+
+/** Array with exactly 2 numbers */
+export type NumberArray2 = [number, number];
+
+/** Array with exactly 3 numbers */
+export type NumberArray3 = [number, number, number];
+
+/** Array with exactly 4 numbers */
+export type NumberArray4 = [number, number, number, number];
+
+/** Array with exactly 6 numbers */
+export type NumberArray6 = [number, number, number, number, number, number];
+
+/** Array with exactly 8 numbers */
+export type NumberArray8 = [number, number, number, number, number, number, number, number];
+
+/** Array with exactly 9 numbers */
+export type NumberArray9 = [number, number, number, number, number, number, number, number, number];
+
+/** Array with exactly 12 numbers */
+export type NumberArray12 = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number
+];
+
+/** Array with exactly 16 numbers */
+export type NumberArray16 = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number
+];
+
+/**
+ * Type covering classic arrays consisting of numbers as well as typed arrays
+ */
+export type NumericArray = TypedArray | number[];
+
+/** Array with exactly 1 number, or a typed array */
+export type NumericArray1 = NumberArray1 | TypedArray;
+
+/** Array with exactly 2 numbers, or a typed array */
+export type NumericArray2 = NumberArray2 | TypedArray;
+
+/** Array with exactly 3 numbers, or a typed array */
+export type NumericArray3 = NumberArray3 | TypedArray;
+
+/** Array with exactly 4 numbers, or a typed array */
+export type NumericArray4 = NumberArray4 | TypedArray;
+
+/** Array with exactly 6 numbers, or a typed array */
+export type NumericArray6 = NumberArray6 | TypedArray;
+
+/** Array with exactly 8 numbers, or a typed array */
+export type NumericArray8 = NumberArray8 | TypedArray;
+
+/** Array with exactly 9 numbers, or a typed array */
+export type NumericArray9 = NumberArray9 | TypedArray;
+
+/** Array with exactly 12 numbers, or a typed array */
+export type NumericArray12 = NumberArray12 | TypedArray;
+
+/** Array with exactly 16 numbers, or a typed array */
+export type NumericArray16 = NumberArray16 | TypedArray;

package/src/types/bigint.ts

@@ -0,0 +1,74 @@
+// math.gl
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright 2016-2019 The Apache Software Foundation
+// SPDX-FileComment: BigInt availability/fallback structure adapted from Apache Arrow JS util/compat.ts; compared with apache-arrow-4.0.0. See ../../ARROW-NOTICE.txt and ../../APACHE-2.0-LICENSE.txt. Modified to separate availability flags, share errors and narrow exports.
+
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+// BigInt compatibility layer
+// Source comparison: https://github.com/apache/arrow/blob/apache-arrow-4.0.0/js/src/util/compat.ts
+// Requires tsconfig.json: target=esnext or (lib: esnext.bigint)
+// Requires eslint: env: {es2020: true}
+
+const ERR_BIGINT_UNAVAILABLE = 'BigInt is not available in this environment';
+
+function BigIntUnavailable() {
+  throw new Error(ERR_BIGINT_UNAVAILABLE);
+}
+BigIntUnavailable.asIntN = () => {
+  throw new Error(ERR_BIGINT_UNAVAILABLE);
+};
+BigIntUnavailable.asUintN = () => {
+  throw new Error(ERR_BIGINT_UNAVAILABLE);
+};
+
+class BigInt64ArrayUnavailable {
+  static get BYTES_PER_ELEMENT() {
+    return 8;
+  }
+  static of() {
+    throw new Error(ERR_BIGINT_UNAVAILABLE);
+  }
+  static from() {
+    throw new Error(ERR_BIGINT_UNAVAILABLE);
+  }
+  constructor() {
+    throw new Error(ERR_BIGINT_UNAVAILABLE);
+  }
+}
+
+export const BigIntAvailable = typeof BigInt !== 'undefined';
+export const BigInt64ArrayAvailable = typeof BigInt64Array !== 'undefined';
+export const BigUint64ArrayAvailable = typeof BigUint64Array !== 'undefined';
+
+const BigIntCtor = (() => {
+  return BigIntAvailable ? BigInt : BigIntUnavailable;
+})();
+
+const BigInt64ArrayCtor = (() => {
+  return BigInt64ArrayAvailable ? BigInt64Array : BigInt64ArrayUnavailable;
+})();
+
+const BigUint64ArrayCtor = (() => {
+  return BigUint64ArrayAvailable ? BigUint64Array : BigInt64ArrayUnavailable;
+})();
+
+export {BigIntCtor as BigInt};
+export {BigInt64ArrayCtor as BigInt64Array};
+export {BigUint64ArrayCtor as BigUint64Array};

package/src/types/bounds-types.ts

@@ -0,0 +1,29 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** 2 dimensional bounds [[minX, minY], [maxX, maxY]] */
+export type Bounds2D = [[number, number], [number, number]];
+
+/** 3 dimensional bounds [[minX, minY, minZ], [maxX, maxY, maxZ]] */
+export type Bounds3D = [[number, number, number], [number, number, number]];
+
+/** 2 or 3 dimensional bounds [[minX, minY], [maxX, maxY]] or [[minX, minY, minZ], [maxX, maxY, maxZ]] */
+export type Bounds =
+  | [[number, number], [number, number]]
+  | [[number, number, number], [number, number, number]];
+
+/** Checks if a `Bounds` is a `Bounds2D` */
+export function isBounds2D(bounds: Bounds): bounds is Bounds2D {
+  return bounds.length === 2 && bounds[0].length === 2 && bounds[1].length === 2;
+}
+
+/** Accepts 2D and 3D bounds and returns a 2D bound, truncating 3D dimension if necessary */
+export function getBounds2D(bounds: Bounds): Bounds2D {
+  return isBounds2D(bounds)
+    ? bounds
+    : [
+        [bounds[0][0], bounds[0][1]],
+        [bounds[1][0], bounds[1][1]]
+      ];
+}

package/src/types/float16.ts

@@ -0,0 +1,47 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {TypedArrayConstructor} from './array-types';
+import {getTypedArrayName} from './typed-array-brand';
+
+/**
+ * Checks for native Float16Array values, including arrays from other realms.
+ * Does not identify Uint16Array binary16 storage as a decoded Float16Array.
+ * Does not require a Float16Array constructor in the current realm.
+ */
+export function isFloat16Array(value: unknown): value is Float16Array {
+  return getTypedArrayName(value) === 'Float16Array';
+}
+
+/**
+ * The native `Float16Array` constructor exposed by the current JavaScript runtime.
+ *
+ * @remarks This is `undefined` when the runtime does not provide `Float16Array`. The value is
+ * captured when this module is evaluated, so a polyfill must be installed before importing
+ * `@math.gl/core/types`.
+ */
+export const NativeFloat16ArrayConstructor: TypedArrayConstructor | undefined =
+  globalThis.Float16Array;
+
+/**
+ * Returns the typed array constructor used for half-precision storage.
+ *
+ * @returns The native `Float16Array` constructor when available, otherwise `Uint16Array`.
+ * @remarks The `Uint16Array` fallback stores encoded IEEE 754 binary16 bit patterns. Unlike a
+ * native `Float16Array`, it does not encode numeric assignments or decode values when read.
+ */
+export function getFloat16ArrayConstructor(): TypedArrayConstructor {
+  return NativeFloat16ArrayConstructor ?? Uint16Array;
+}
+
+/**
+ * Checks whether a value is the native `Float16Array` constructor for the current runtime.
+ *
+ * @param value The value to test.
+ * @returns `true` when `value` matches `NativeFloat16ArrayConstructor`. Returns `false` for the
+ * `Uint16Array` fallback.
+ */
+export function isFloat16ArrayConstructor(value: unknown): boolean {
+  return Boolean(NativeFloat16ArrayConstructor && value === NativeFloat16ArrayConstructor);
+}

package/src/types/index.ts

@@ -0,0 +1,45 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export type {
+  // typed arrays
+  TypedArray,
+  TypedArrayConstructor,
+  BigTypedArray,
+  BigTypedArrayConstructor,
+  // numeric arrays (sized number arrays)
+  NumberArray,
+  NumberArray1,
+  NumberArray2,
+  NumberArray3,
+  NumberArray4,
+  NumberArray6,
+  NumberArray8,
+  NumberArray9,
+  NumberArray12,
+  NumberArray16,
+  // numeric arrays (sized number arrays or typed arrays)
+  NumericArray,
+  NumericArray1,
+  NumericArray2,
+  NumericArray3,
+  NumericArray4,
+  NumericArray6,
+  NumericArray8,
+  NumericArray9,
+  NumericArray12,
+  NumericArray16
+} from './array-types';
+
+export {isTypedArray, isUint16Array, isNumberArray, isNumericArray} from './is-array';
+export {
+  NativeFloat16ArrayConstructor,
+  getFloat16ArrayConstructor,
+  isFloat16ArrayConstructor,
+  isFloat16Array
+} from './float16';
+
+export type {Bounds, Bounds2D, Bounds3D} from './bounds-types';
+
+export type {SpheroidParameters} from './spheroid';

package/src/types/is-array.ts

@@ -0,0 +1,41 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {TypedArray, NumericArray, NumberArray} from './array-types';
+import {getTypedArrayName} from './typed-array-brand';
+
+/** Checks for unsigned 16-bit samples, including typed arrays from other realms. */
+export function isUint16Array(value: unknown): value is Uint16Array {
+  return getTypedArrayName(value) === 'Uint16Array';
+}
+
+/**
+ * Check is an array is a typed array
+ * @param value value to be tested
+ * @returns input with type narrowed to TypedArray, or null
+ */
+export function isTypedArray(value: unknown): value is TypedArray {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+
+/**
+ * Check is an array is an array of numbers)
+ * @param value value to be tested
+ * @returns input with type narrowed to NumberArray, or null
+ */
+export function isNumberArray(value: unknown): value is NumberArray {
+  if (Array.isArray(value)) {
+    return value.length === 0 || typeof value[0] === 'number';
+  }
+  return false;
+}
+
+/**
+ * Check is an array is a numeric array (typed array or array of numbers)
+ * @param value value to be tested
+ * @returns input with type narrowed to NumericArray, or null
+ */
+export function isNumericArray(value: unknown): value is NumericArray {
+  return isTypedArray(value) || isNumberArray(value);
+}

package/src/types/spheroid.ts

@@ -0,0 +1,11 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** Geometry of a sphere or oblate spheroid, in metres. No datum, axes or epoch metadata.
+ * Both axes must be finite and positive, with semiMinorAxis <= semiMajorAxis.
+ */
+export type SpheroidParameters = {
+  readonly semiMajorAxis: number;
+  readonly semiMinorAxis: number;
+};

package/src/types/typed-array-brand.ts

@@ -0,0 +1,14 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+// Use the intrinsic getter so constructor and Symbol.toStringTag overrides cannot
+// disguise a typed array's element type. It also works for arrays from other realms.
+const typedArrayTagGetter = Object.getOwnPropertyDescriptor(
+  Object.getPrototypeOf(Uint8Array.prototype),
+  Symbol.toStringTag
+)!.get!;
+
+export function getTypedArrayName(value: unknown): string | undefined {
+  return ArrayBuffer.isView(value) ? typedArrayTagGetter.call(value) : undefined;
+}

package/src/types.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export * from './types/index';

package/src/vec2.ts

@@ -1,5 +1,5 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 export * from './gl-matrix/vec2';

package/src/vec3.ts

@@ -1,5 +1,5 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 export * from './gl-matrix/vec3';

package/src/vec4.ts

@@ -1,5 +1,5 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 export * from './gl-matrix/vec4';