@math.gl/geospatial 5.0.0-alpha.18 → 5.0.0-alpha.19

package/dist/projection/experimental/entries/projections/stere.cjs

@@ -0,0 +1,684 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/projection/experimental/entries/projections/stere.js
+var stere_exports = {};
+__export(stere_exports, {
+  stereographic: () => stereographic
+});
+module.exports = __toCommonJS(stere_exports);
+
+// dist/projection/experimental/rendering-profile/geographic-bounds.js
+var RADIANS = Math.PI / 180;
+function createAngularRanges(west, south, east, north) {
+  return [
+    [west, south],
+    [east, north]
+  ];
+}
+function normalizeLongitude(longitude) {
+  return longitude >= -180 && longitude < 180 ? longitude : ((longitude + 180) % 360 + 360) % 360 - 180;
+}
+function getLongitudeSpan(bounds) {
+  const span = bounds[2] - bounds[0];
+  return span < 0 ? span + 360 : span;
+}
+function containsGeographicPoint(bounds, point) {
+  const [west, south, east, north] = bounds;
+  const longitude = normalizeLongitude(point[0]);
+  return point[1] >= south && point[1] <= north && (west <= east ? longitude >= west && longitude <= east || longitude === -180 && east === 180 : longitude >= west || longitude <= east);
+}
+function clampGeographicPoint(bounds, point) {
+  let longitude = normalizeLongitude(point[0]);
+  const latitude = Math.max(bounds[1], Math.min(bounds[3], point[1]));
+  if (!containsGeographicPoint(bounds, [longitude, latitude])) {
+    const westDistance = Math.abs(normalizeLongitude(longitude - bounds[0]));
+    const eastDistance = Math.abs(normalizeLongitude(longitude - bounds[2]));
+    longitude = westDistance <= eastDistance ? bounds[0] : bounds[2];
+  }
+  return [longitude, latitude];
+}
+function getAngularRanges(bounds, primeMeridian = 0, origin = 0) {
+  const width = getLongitudeSpan(bounds);
+  const west = bounds[0] * RADIANS - primeMeridian;
+  const middle = west + width * RADIANS / 2;
+  const shift = Math.round((origin - middle) / (2 * Math.PI)) * 2 * Math.PI;
+  return createAngularRanges(width === 360 ? origin - Math.PI : west + shift, bounds[1] * RADIANS, width === 360 ? origin + Math.PI : west + shift + width * RADIANS, bounds[3] * RADIANS);
+}
+
+// dist/projection/experimental/rendering-profile/rendering-profile.js
+function createAngularNormalization(normalize, primeMeridian = 0) {
+  return (point) => {
+    const x = point.x * Math.PI / 180 - primeMeridian;
+    const y = point.y * Math.PI / 180;
+    const native = { x, y, z: point.z };
+    normalize(native);
+    if (native.x !== x)
+      point.x = (native.x + primeMeridian) * 180 / Math.PI;
+    if (native.y !== y)
+      point.y = native.y * 180 / Math.PI;
+  };
+}
+
+// dist/projection/experimental/rendering-profile/rectangular-rendering-profile.js
+function normalizeCoverage(point, coverage, center = 0, over = false) {
+  const span = getLongitudeSpan(coverage);
+  const west = span === 360 ? center - 180 : coverage[0] + Math.round((center - coverage[0] - span / 2) / 360) * 360;
+  const east = west + span;
+  if (over) {
+    point.x = Math.max(west, Math.min(east, point.x));
+    point.y = Math.max(coverage[1], Math.min(coverage[3], point.y));
+    return;
+  }
+  const best = clampGeographicPoint(coverage, [point.x, point.y]);
+  let longitude = best[0];
+  if (best[0] === normalizeLongitude(point.x) && point.x >= west && point.x <= east)
+    longitude = point.x;
+  else if (longitude < west || longitude > east)
+    longitude += Math.round(((west + east) / 2 - longitude) / 360) * 360;
+  const offset = longitude - center;
+  point.x = Math.abs(offset) <= 180 ? longitude : center + normalizeLongitude(offset);
+  point.y = best[1];
+}
+function createRectangleRenderingProfile(resolveBounds, coverage, origin = 0, primeMeridian = 0, over = false) {
+  const center = (origin + primeMeridian) * 180 / Math.PI;
+  return {
+    get bounds() {
+      return resolveBounds(getAngularRanges(coverage, primeMeridian, origin));
+    },
+    normalize(point) {
+      normalizeCoverage(point, coverage, center, over);
+    }
+  };
+}
+
+// dist/projection/experimental/parameters.js
+var DEGREES_TO_RADIANS = Math.PI / 180;
+function numberParameter(parameters, name, fallback) {
+  if (!Object.prototype.hasOwnProperty.call(parameters, name))
+    return fallback;
+  const value = parameters[name];
+  if (typeof value !== "string" || !/^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i.test(value)) {
+    throw new Error(`Invalid numeric PROJ parameter: +${name}`);
+  }
+  const number = Number(value);
+  if (!Number.isFinite(number))
+    throw new Error(`Invalid numeric PROJ parameter: +${name}`);
+  return number;
+}
+function wrapLongitude(longitude, over = false) {
+  if (over || Math.abs(longitude) <= Math.PI)
+    return longitude;
+  const circle = 2 * Math.PI;
+  return ((longitude + Math.PI) % circle + circle) % circle - Math.PI;
+}
+
+// dist/projection/experimental/rendering-profile/spherical-rendering-domain.js
+function geographicVector(longitude, latitude) {
+  return [
+    Math.cos(latitude) * Math.cos(longitude),
+    Math.cos(latitude) * Math.sin(longitude),
+    Math.sin(latitude)
+  ];
+}
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+function trigonometricRoots(a, b, c, low, high) {
+  const radius = Math.hypot(a, b);
+  if (!radius || Math.abs(c) > radius + 1e-14)
+    return [];
+  const angle = Math.atan2(b, a);
+  const offset = Math.acos(Math.max(-1, Math.min(1, c / radius)));
+  const roots = [];
+  for (const phase of [angle - offset, angle + offset]) {
+    for (let k = Math.ceil((low - phase) / (2 * Math.PI)); k <= Math.floor((high - phase) / (2 * Math.PI)); k++) {
+      roots.push(phase + k * 2 * Math.PI);
+    }
+  }
+  return roots;
+}
+function sphericalExtremum(vector, parameters, domain, maximize = true) {
+  const [[west, south], [east, north]] = parameters;
+  const center = (west + east) / 2;
+  const axis = domain ? [Math.cos(domain.latitude), 0, Math.sin(domain.latitude)] : [1, 0, 0];
+  const limit = domain ? Math.cos(domain.distance) : -1;
+  let best = maximize ? -Infinity : Infinity;
+  let point = [NaN, NaN];
+  const consider = (longitude, latitude) => {
+    longitude = center + wrapLongitude(longitude - center);
+    if (longitude < west - 1e-12 || longitude > east + 1e-12 || latitude < south - 1e-12 || latitude > north + 1e-12)
+      return;
+    const position = geographicVector(longitude, latitude);
+    if (domain && dot(axis, position) < limit - 1e-13)
+      return;
+    const value = dot(vector, position);
+    if (maximize ? value > best : value < best) {
+      best = value;
+      point = [longitude, latitude];
+    }
+  };
+  const longitudes = [west, east, ...trigonometricRoots(-vector[1], vector[0], 0, west, east)];
+  for (const longitude of longitudes) {
+    const coefficient = vector[0] * Math.cos(longitude) + vector[1] * Math.sin(longitude);
+    for (const latitude of [
+      south,
+      north,
+      ...trigonometricRoots(vector[2], -coefficient, 0, south, north)
+    ])
+      consider(longitude, latitude);
+  }
+  if (domain) {
+    const [a, , c] = axis;
+    for (const latitude of [south, north]) {
+      for (const longitude of trigonometricRoots(a * Math.cos(latitude), 0, limit - c * Math.sin(latitude), west, east))
+        consider(longitude, latitude);
+    }
+    for (const longitude of [west, east]) {
+      for (const latitude of trigonometricRoots(a * Math.cos(longitude), c, limit, south, north))
+        consider(longitude, latitude);
+    }
+    const parallel = dot(vector, axis);
+    let tangent = vector.map((value, index) => value - parallel * axis[index]);
+    let length = Math.hypot(...tangent);
+    if (length <= 1e-14) {
+      tangent = [-axis[2], 0, axis[0]];
+      length = 1;
+    }
+    if (length > 1e-14) {
+      for (const sign of [-1, 1]) {
+        const position = axis.map((value, index) => value * limit + sign * tangent[index] * Math.sin(domain.distance) / length);
+        consider(Math.atan2(position[1], position[0]), Math.atan2(position[2], Math.hypot(position[0], position[1])));
+      }
+    }
+  }
+  if (!Number.isFinite(best))
+    throw new Error("CRS coverage does not intersect the rendering domain");
+  return { value: best, point };
+}
+function sphericalRange(vector, parameters, domain) {
+  return [
+    sphericalExtremum(vector, parameters, domain, false).value,
+    sphericalExtremum(vector, parameters, domain).value
+  ];
+}
+function sphericalRatioRange(numerator, denominator, constant, parameters, domain) {
+  const n = sphericalRange(numerator, parameters, domain);
+  const d = sphericalRange(denominator, parameters, domain).map((value) => value + constant);
+  if (d[0] <= 0)
+    throw new Error("Projection rendering denominator is not positive");
+  const quotients = n.flatMap((value) => d.map((divisor) => value / divisor));
+  return [false, true].map((maximize) => {
+    let low = Math.min(...quotients), high = Math.max(...quotients);
+    for (let iteration = 0; iteration < 60; iteration++) {
+      const middle = (low + high) / 2;
+      const vector = numerator.map((value, index) => value - middle * denominator[index]);
+      const residual = sphericalExtremum(vector, parameters, domain, maximize).value - middle * constant;
+      if (residual > 0)
+        low = middle;
+      else
+        high = middle;
+    }
+    return maximize ? high : low;
+  });
+}
+
+// dist/projection/experimental/rendering-profile/angular-rendering-profile.js
+function createAngularRenderingProfile(base, maximumDistance, resolveBounds, horizon = Math.PI) {
+  const full = [-180, -90, 180, 90];
+  const create = (coverage, declared) => {
+    const parameters = getAngularRanges(coverage, base.primeMeridian, base.long0);
+    const local = createAngularRanges(parameters[0][0] - base.long0, parameters[0][1], parameters[1][0] - base.long0, parameters[1][1]);
+    const axis = [Math.cos(base.lat0), 0, Math.sin(base.lat0)];
+    const minimum = declared ? sphericalExtremum(axis, local, void 0, false).value : -1;
+    const clipped = !declared || minimum <= Math.cos(horizon) + 1e-13;
+    const domain = clipped ? { latitude: base.lat0, distance: maximumDistance } : void 0;
+    const rectangle = createRectangleRenderingProfile(() => resolveBounds(local, domain), coverage, base.long0, base.primeMeridian);
+    const polar = Math.abs(Math.cos(base.lat0)) < 1e-12;
+    const polarLatitude = (Math.PI / 2 - maximumDistance) * 180 / Math.PI;
+    const normalizeCap = domain && !polar && createAngularNormalization((point) => {
+      const target = geographicVector(point.x - base.long0, point.y);
+      if (target[0] * Math.cos(base.lat0) + target[2] * Math.sin(base.lat0) >= Math.cos(domain.distance) - 1e-14)
+        return;
+      if (Math.hypot(target[0] + axis[0], target[1], target[2] + axis[2]) < 1e-12) {
+        const angle = base.lat0 + domain.distance;
+        const center = (local[0][0] + local[1][0]) / 2;
+        const longitude = center + wrapLongitude((Math.cos(angle) < 0 ? Math.PI : 0) - center);
+        const latitude = Math.atan2(Math.sin(angle), Math.abs(Math.cos(angle)));
+        if (longitude >= local[0][0] && longitude <= local[1][0] && latitude >= local[0][1] && latitude <= local[1][1]) {
+          point.x = longitude + base.long0;
+          point.y = latitude;
+          return;
+        }
+      }
+      const result = sphericalExtremum(target, local, domain);
+      [point.x, point.y] = [result.point[0] + base.long0, result.point[1]];
+    }, base.primeMeridian);
+    return {
+      get bounds() {
+        return resolveBounds(local, domain);
+      },
+      normalize(point) {
+        rectangle.normalize(point);
+        if (domain && polar) {
+          point.y = base.lat0 > 0 ? Math.max(polarLatitude, point.y) : Math.min(-polarLatitude, point.y);
+        } else
+          normalizeCap == null ? void 0 : normalizeCap(point);
+        const center = (base.long0 + base.primeMeridian) * 180 / Math.PI;
+        const offset = point.x - center;
+        if (Math.abs(offset) > 180)
+          point.x = center + normalizeLongitude(offset);
+      }
+    };
+  };
+  return (coverage) => create(coverage ?? full, Boolean(coverage));
+}
+function withAngularRenderingProfile(implementation, base, distance, resolveBounds, horizon = Math.PI) {
+  return {
+    ...implementation,
+    longitudeOrigin: base.long0,
+    getRenderingProfile: createAngularRenderingProfile(base, distance, resolveBounds, horizon)
+  };
+}
+
+// dist/projection/experimental/rendering-profile/rendering-bounds.js
+var ordered = (a, b) => [Math.min(a, b), Math.max(a, b)];
+var add = (a, b) => [a[0] + b[0], a[1] + b[1]];
+var scale = (a, value) => ordered(a[0] * value, a[1] * value);
+var maxAbs = (a) => Math.max(Math.abs(a[0]), Math.abs(a[1]));
+function envelope(x, y) {
+  const padding = (range) => Math.max(1, maxAbs(range)) * 1e-12;
+  if (![...x, ...y].every(Number.isFinite))
+    throw new Error("Projection rendering bounds are not finite");
+  return [
+    [x[0] - padding(x), y[0] - padding(y), 0],
+    [x[1] + padding(x), y[1] + padding(y), 0]
+  ];
+}
+
+// dist/projection/experimental/rendering-profile/azimuthal-rendering-bounds.js
+function sphericalAzimuthalBounds(base, parameters, domain, kind) {
+  const north = [-Math.sin(base.lat0), 0, Math.cos(base.lat0)];
+  const center = [Math.cos(base.lat0), 0, Math.sin(base.lat0)];
+  const east = [0, 1, 0];
+  const constant = kind === "stere" ? 1 : 0;
+  const range = (vector) => kind === "ortho" ? sphericalRange(vector, parameters, domain) : sphericalRatioRange(vector, center, constant, parameters, domain);
+  const factor = base.a * (kind === "stere" ? 2 * base.k0 : 1);
+  return envelope(add([base.x0, base.x0], scale(range(east), factor)), add([base.y0, base.y0], scale(range(north), factor)));
+}
+function ellipsoidalStereographicBounds(base, conformalLatitude, centerLatitude, radius, parameters, domain, longitudeScale = 1, latitudeError = base.e * Math.atanh(base.e)) {
+  const region = createAngularRanges(parameters[0][0] * longitudeScale, conformalLatitude(parameters[0][1]), parameters[1][0] * longitudeScale, conformalLatitude(parameters[1][1]));
+  const padding = 2 * latitudeError + Math.PI * Math.abs(longitudeScale - 1);
+  const capDistance = domain && longitudeScale === 1 ? Math.min(domain.distance + padding, Math.PI - (1 - base.es) * (Math.PI - domain.distance)) : domain && domain.distance + padding;
+  const cap = capDistance && capDistance < Math.PI ? { latitude: centerLatitude, distance: capDistance } : void 0;
+  const center = [Math.cos(centerLatitude), 0, Math.sin(centerLatitude)];
+  const north = [-Math.sin(centerLatitude), 0, Math.cos(centerLatitude)];
+  const longitudeWidth = region[1][0] - region[0][0];
+  const wrapped = longitudeWidth >= 2 * Math.PI ? createAngularRanges(-Math.PI, region[0][1], Math.PI, region[1][1]) : region;
+  const x = sphericalRatioRange([0, 1, 0], center, 1, wrapped, cap);
+  const y = sphericalRatioRange(north, center, 1, wrapped, cap);
+  return envelope(add([base.x0, base.x0], scale(x, radius)), add([base.y0, base.y0], scale(y, radius)));
+}
+
+// dist/projection/experimental/projection-scratch.js
+function createPoint() {
+  return { x: 0, y: 0, z: 0 };
+}
+var ProjectionScratch = class {
+  constructor() {
+    this.point = createPoint();
+    this.points = [this.point];
+    this.active = 0;
+  }
+  get depth() {
+    return this.active;
+  }
+  acquire() {
+    var _a;
+    const index = this.active++;
+    (_a = this.points)[index] || (_a[index] = createPoint());
+    return this.points[index];
+  }
+  release(point) {
+    if (this.active > 0 && this.points[this.active - 1] === point)
+      this.active--;
+  }
+};
+
+// dist/projection/experimental/mutable-projection.js
+function createProjection(forward2, inverse2) {
+  const scratch = new ProjectionScratch();
+  const scalar = (x, y, operation) => {
+    const point = scratch.acquire();
+    try {
+      point.x = x;
+      point.y = y;
+      point.z = 0;
+      operation(point);
+      return [point.x, point.y];
+    } finally {
+      scratch.release(point);
+    }
+  };
+  return {
+    forward(x, y) {
+      return scalar(x, y, forward2);
+    },
+    inverse(x, y) {
+      return scalar(x, y, inverse2);
+    },
+    forwardInPlace: forward2,
+    inverseInPlace: inverse2
+  };
+}
+function projectionOperation(implementation, inverse2, geocentric = false) {
+  const mutable = inverse2 ? implementation.inverseInPlace : implementation.forwardInPlace;
+  if (mutable)
+    return mutable.bind(implementation);
+  if (geocentric) {
+    const operation2 = inverse2 ? implementation.inverse3D : implementation.forward3D;
+    return (point) => {
+      const output = operation2.call(implementation, [point.x, point.y, point.z]);
+      point.x = output[0];
+      point.y = output[1];
+      point.z = output[2];
+    };
+  }
+  const operation = inverse2 ? implementation.inverse : implementation.forward;
+  return (point) => {
+    const output = operation.call(implementation, point.x, point.y);
+    point.x = output[0];
+    point.y = output[1];
+  };
+}
+
+// dist/projection/experimental/kernel.js
+var ORIGIN_PARAMETERS = ["lon_0", "lat_0", "x_0", "y_0"];
+var SCALE_PARAMETERS = ["k", "k_0"];
+function angleParameter(parameters, name, fallback = 0) {
+  const degrees = numberParameter(parameters, name, fallback);
+  if (name !== "lon_0" && Math.abs(degrees) > 90) {
+    throw new Error("Latitude parameter must be between -90 and 90 degrees: +" + name);
+  }
+  return degrees * DEGREES_TO_RADIANS;
+}
+function flagParameter(parameters, name) {
+  const present = Object.prototype.hasOwnProperty.call(parameters, name);
+  if (present && parameters[name] !== void 0)
+    throw new Error("Expected a flag without a value: +" + name);
+  return present;
+}
+function kernelParameters({ semiMajorAxis: a, eccentricitySquared: es, parameters, primeMeridian = 0 }) {
+  const k0 = numberParameter(parameters, "k_0", numberParameter(parameters, "k", 1));
+  if (k0 <= 0)
+    throw new Error("Projection scale must be positive");
+  return {
+    primeMeridian,
+    a,
+    b: a * Math.sqrt(1 - es),
+    es,
+    e: Math.sqrt(es),
+    ep2: es / (1 - es),
+    sphere: es === 0,
+    over: flagParameter(parameters, "over"),
+    long0: angleParameter(parameters, "lon_0"),
+    lat0: angleParameter(parameters, "lat_0"),
+    lat1: angleParameter(parameters, "lat_1"),
+    lat2: angleParameter(parameters, "lat_2", numberParameter(parameters, "lat_1", 0)),
+    lat_ts: angleParameter(parameters, "lat_ts", NaN),
+    x0: numberParameter(parameters, "x_0", 0),
+    y0: numberParameter(parameters, "y_0", 0),
+    k0
+  };
+}
+function bindKernel(name, state, forward2, inverse2, adapt = createProjection) {
+  const run = (operation, point) => {
+    const result = operation(state, point);
+    if (!result || typeof result !== "object" || !Number.isFinite(result.x) || !Number.isFinite(result.y))
+      throw new Error(name + ": coordinate outside projection domain or inverse did not converge");
+    point.x = result.x;
+    point.y = result.y;
+  };
+  return adapt((point) => run(forward2, point), (point) => run(inverse2, point));
+}
+function guardAzimuthalDomain(base, implementation) {
+  const forward2 = projectionOperation(implementation, false);
+  return createProjection((point) => {
+    const longitude = point.x, latitude = point.y;
+    const delta = Math.atan2(Math.sin(longitude - base.long0), Math.cos(longitude - base.long0));
+    const polar = Math.abs(Math.abs(base.lat0) - Math.PI / 2) < 1e-10;
+    if (Math.abs(latitude + base.lat0) < 1e-10 && (polar || Math.abs(Math.abs(delta) - Math.PI) < 1e-10))
+      throw new Error("Azimuthal projection is undefined at the antipode");
+    forward2(point);
+  }, projectionOperation(implementation, true));
+}
+
+// dist/projection/experimental/common/constants.js
+var EPSLN = 1e-10;
+var HALF_PI = Math.PI / 2;
+var FORTPI = Math.PI / 4;
+var TWO_PI = Math.PI * 2;
+var SPI = 3.14159265359;
+var D2R = Math.PI / 180;
+var R2D = 180 / Math.PI;
+var SEC_TO_RAD = Math.PI / (180 * 3600);
+
+// dist/projection/experimental/common/sign.js
+function sign_default(x) {
+  return x < 0 ? -1 : 1;
+}
+
+// dist/projection/experimental/common/msfnz.js
+function msfnz_default(eccent, sinphi, cosphi) {
+  var con = eccent * sinphi;
+  return cosphi / Math.sqrt(1 - con * con);
+}
+
+// dist/projection/experimental/common/tsfnz.js
+function tsfnz_default(eccent, phi, sinphi) {
+  var con = eccent * sinphi;
+  var com = 0.5 * eccent;
+  con = Math.pow((1 - con) / (1 + con), com);
+  return Math.tan(0.5 * (HALF_PI - phi)) / con;
+}
+
+// dist/projection/experimental/common/phi2z.js
+function phi2z_default(eccent, ts) {
+  var eccnth = 0.5 * eccent;
+  var con, dphi;
+  var phi = HALF_PI - 2 * Math.atan(ts);
+  for (var i = 0; i <= 15; i++) {
+    con = eccent * Math.sin(phi);
+    dphi = HALF_PI - 2 * Math.atan(ts * Math.pow((1 - con) / (1 + con), eccnth)) - phi;
+    phi += dphi;
+    if (Math.abs(dphi) <= 1e-10) {
+      return phi;
+    }
+  }
+  return -9999;
+}
+
+// dist/projection/experimental/common/adjust_lon.js
+function adjust_lon_default(x, skipAdjust) {
+  if (skipAdjust) {
+    return x;
+  }
+  return Math.abs(x) <= SPI ? x : x - sign_default(x) * TWO_PI;
+}
+
+// dist/projection/experimental/kernels/stere.js
+function ssfn_(phit, sinphi, eccen) {
+  sinphi *= eccen;
+  return Math.tan(0.5 * (HALF_PI + phit)) * Math.pow((1 - sinphi) / (1 + sinphi), 0.5 * eccen);
+}
+function initialize(state) {
+  state.x0 = state.x0 || 0;
+  state.y0 = state.y0 || 0;
+  state.lat0 = state.lat0 || 0;
+  state.long0 = state.long0 || 0;
+  state.coslat0 = Math.cos(state.lat0);
+  state.sinlat0 = Math.sin(state.lat0);
+  if (state.sphere) {
+    if (!Number.isNaN(state.lat_ts) && Math.abs(state.coslat0) <= EPSLN) {
+      state.k0 = 0.5 * (1 + sign_default(state.lat0) * Math.sin(state.lat_ts));
+    }
+  } else {
+    if (Math.abs(state.coslat0) <= EPSLN) {
+      if (state.lat0 > 0) {
+        state.con = 1;
+      } else {
+        state.con = -1;
+      }
+    }
+    state.cons = Math.sqrt(Math.pow(1 + state.e, 1 + state.e) * Math.pow(1 - state.e, 1 - state.e));
+    if (!Number.isNaN(state.lat_ts) && Math.abs(state.coslat0) <= EPSLN && Math.abs(Math.cos(state.lat_ts)) > EPSLN) {
+      state.k0 = 0.5 * state.cons * msfnz_default(state.e, Math.sin(state.lat_ts), Math.cos(state.lat_ts)) / tsfnz_default(state.e, state.con * state.lat_ts, state.con * Math.sin(state.lat_ts));
+    }
+    state.ms1 = msfnz_default(state.e, state.sinlat0, state.coslat0);
+    state.X0 = 2 * Math.atan(ssfn_(state.lat0, state.sinlat0, state.e)) - HALF_PI;
+    state.cosX0 = Math.cos(state.X0);
+    state.sinX0 = Math.sin(state.X0);
+  }
+}
+function forward(state, p) {
+  var lon = p.x;
+  var lat = p.y;
+  var sinlat = Math.sin(lat);
+  var coslat = Math.cos(lat);
+  var A, X, sinX, cosX, ts, rh;
+  var dlon = adjust_lon_default(lon - state.long0, state.over);
+  if (Math.abs(Math.abs(lon - state.long0) - Math.PI) <= EPSLN && Math.abs(lat + state.lat0) <= EPSLN) {
+    p.x = NaN;
+    p.y = NaN;
+    return p;
+  }
+  if (state.sphere) {
+    A = 2 * state.k0 / (1 + state.sinlat0 * sinlat + state.coslat0 * coslat * Math.cos(dlon));
+    p.x = state.a * A * coslat * Math.sin(dlon) + state.x0;
+    p.y = state.a * A * (state.coslat0 * sinlat - state.sinlat0 * coslat * Math.cos(dlon)) + state.y0;
+    return p;
+  } else {
+    X = 2 * Math.atan(ssfn_(lat, sinlat, state.e)) - HALF_PI;
+    cosX = Math.cos(X);
+    sinX = Math.sin(X);
+    if (Math.abs(state.coslat0) <= EPSLN) {
+      ts = tsfnz_default(state.e, lat * state.con, state.con * sinlat);
+      rh = 2 * state.a * state.k0 * ts / state.cons;
+      p.x = state.x0 + rh * Math.sin(lon - state.long0);
+      p.y = state.y0 - state.con * rh * Math.cos(lon - state.long0);
+      return p;
+    } else if (Math.abs(state.sinlat0) < EPSLN) {
+      A = 2 * state.a * state.k0 / (1 + cosX * Math.cos(dlon));
+      p.y = A * sinX + state.y0;
+    } else {
+      A = 2 * state.a * state.k0 * state.ms1 / (state.cosX0 * (1 + state.sinX0 * sinX + state.cosX0 * cosX * Math.cos(dlon)));
+      p.y = A * (state.cosX0 * sinX - state.sinX0 * cosX * Math.cos(dlon)) + state.y0;
+    }
+    p.x = A * cosX * Math.sin(dlon) + state.x0;
+  }
+  return p;
+}
+function inverse(state, p) {
+  p.x -= state.x0;
+  p.y -= state.y0;
+  var lon, lat, ts, ce, Chi;
+  var rh = Math.sqrt(p.x * p.x + p.y * p.y);
+  if (state.sphere) {
+    var c = 2 * Math.atan(rh / (2 * state.a * state.k0));
+    lon = state.long0;
+    lat = state.lat0;
+    if (rh <= EPSLN) {
+      p.x = lon;
+      p.y = lat;
+      return p;
+    }
+    lat = Math.asin(Math.cos(c) * state.sinlat0 + p.y * Math.sin(c) * state.coslat0 / rh);
+    if (Math.abs(state.coslat0) < EPSLN) {
+      if (state.lat0 > 0) {
+        lon = adjust_lon_default(state.long0 + Math.atan2(p.x, -1 * p.y), state.over);
+      } else {
+        lon = adjust_lon_default(state.long0 + Math.atan2(p.x, p.y), state.over);
+      }
+    } else {
+      lon = adjust_lon_default(state.long0 + Math.atan2(p.x * Math.sin(c), rh * state.coslat0 * Math.cos(c) - p.y * state.sinlat0 * Math.sin(c)), state.over);
+    }
+    p.x = lon;
+    p.y = lat;
+    return p;
+  } else {
+    if (Math.abs(state.coslat0) <= EPSLN) {
+      if (rh <= EPSLN) {
+        lat = state.lat0;
+        lon = state.long0;
+        p.x = lon;
+        p.y = lat;
+        return p;
+      }
+      p.x *= state.con;
+      p.y *= state.con;
+      ts = rh * state.cons / (2 * state.a * state.k0);
+      lat = state.con * phi2z_default(state.e, ts);
+      lon = state.con * adjust_lon_default(state.con * state.long0 + Math.atan2(p.x, -1 * p.y), state.over);
+    } else {
+      ce = 2 * Math.atan(rh * state.cosX0 / (2 * state.a * state.k0 * state.ms1));
+      lon = state.long0;
+      if (rh <= EPSLN) {
+        Chi = state.X0;
+      } else {
+        Chi = Math.asin(Math.cos(ce) * state.sinX0 + p.y * Math.sin(ce) * state.cosX0 / rh);
+        lon = adjust_lon_default(state.long0 + Math.atan2(p.x * Math.sin(ce), rh * state.cosX0 * Math.cos(ce) - p.y * state.sinX0 * Math.sin(ce)), state.over);
+      }
+      lat = -1 * phi2z_default(state.e, Math.tan(0.5 * (HALF_PI + Chi)));
+    }
+  }
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+function createState(base) {
+  const state = {
+    ...base,
+    coslat0: 0,
+    sinlat0: 0,
+    con: 0,
+    cons: 0,
+    ms1: 0,
+    X0: 0,
+    cosX0: 0,
+    sinX0: 0
+  };
+  initialize(state);
+  return state;
+}
+
+// dist/projection/experimental/projections/stere.js
+var stereographic = {
+  name: "stere",
+  aliases: [
+    "Stereographic_South_Pole",
+    "Polar_Stereographic_variant_A",
+    "Polar_Stereographic_variant_B",
+    "Polar_Stereographic"
+  ],
+  parameters: [...ORIGIN_PARAMETERS, ...SCALE_PARAMETERS, "lat_ts"],
+  create(context) {
+    const base = kernelParameters(context);
+    const state = createState(base);
+    const projection = guardAzimuthalDomain(base, bindKernel("stere", state, forward, inverse));
+    return withAngularRenderingProfile(projection, base, 150 * Math.PI / 180, (region, domain) => state.sphere ? sphericalAzimuthalBounds(state, region, domain, "stere") : ellipsoidalStereographicBounds(state, (latitude) => 2 * Math.atan(Math.tan(Math.PI / 4 + latitude / 2) * Math.pow((1 - state.e * Math.sin(latitude)) / (1 + state.e * Math.sin(latitude)), state.e / 2)) - Math.PI / 2, state.X0, 2 * state.a * state.k0 * (Math.abs(state.coslat0) < 1e-10 ? 1 / state.cons : state.ms1 / state.cosX0), region, domain));
+  }
+};
+//# sourceMappingURL=stere.cjs.map