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

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

@@ -0,0 +1,703 @@
+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/geos.js
+var geos_exports = {};
+__export(geos_exports, {
+  geostationary: () => geostationary
+});
+module.exports = __toCommonJS(geos_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 createGeographicBounds(west, south, east, north) {
+  if (![west, south, east, north].every(Number.isFinite) || south < -90 || north > 90 || south > north || east - west < -360 || east - west > 360 + 1e-10)
+    throw new Error("Invalid geographic coverage");
+  if (east - west >= 360 - 1e-10)
+    return [-180, south, 180, north];
+  const wrappedEast = normalizeLongitude(east);
+  return [
+    normalizeLongitude(west),
+    south,
+    wrappedEast === -180 && east > west ? 180 : wrappedEast,
+    north
+  ];
+}
+function getLongitudeSpan(bounds) {
+  const span = bounds[2] - bounds[0];
+  return span < 0 ? span + 360 : span;
+}
+function splitGeographicBounds(bounds) {
+  const [west, south, east, north] = bounds;
+  return west <= east ? [bounds] : [
+    [west, south, 180, north],
+    [-180, south, east, north]
+  ];
+}
+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 intersectGeographicBounds(a, b) {
+  const south = Math.max(a[1], b[1]), north = Math.min(a[3], b[3]);
+  if (south > north)
+    return [];
+  const intervals = [];
+  for (const left of splitGeographicBounds(a))
+    for (const right of splitGeographicBounds(b)) {
+      const west = Math.max(left[0], right[0]), east = Math.min(left[2], right[2]);
+      if (west <= east)
+        intervals.push([west, east]);
+      else if (left[2] === 180 && right[0] === -180 || right[2] === 180 && left[0] === -180)
+        intervals.push([-180, -180]);
+    }
+  intervals.sort((left, right) => left[0] - right[0]);
+  const merged = [];
+  for (const interval of intervals) {
+    const last = merged[merged.length - 1];
+    if (last && interval[0] <= last[1])
+      last[1] = Math.max(last[1], interval[1]);
+    else
+      merged.push([...interval]);
+  }
+  if (merged.length > 1 && merged[0][0] === -180 && merged[merged.length - 1][1] === 180) {
+    const first = merged.shift(), last = merged.pop();
+    return [
+      [last[0], south, first[1], north],
+      ...merged.map(([west, east]) => [west, south, east, north])
+    ];
+  }
+  return merged.map(([west, east]) => [west, south, east, north]);
+}
+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);
+}
+function getGeographicBounds(ranges, primeMeridian = 0) {
+  return createGeographicBounds((ranges[0][0] + primeMeridian) / RADIANS, ranges[0][1] / RADIANS, (ranges[1][0] + primeMeridian) / RADIANS, ranges[1][1] / RADIANS);
+}
+function unionRenderingBounds(bounds) {
+  if (!bounds.length)
+    throw new Error("CRS coverage does not intersect the rendering target");
+  return [
+    [0, 1, 2].map((axis) => Math.min(...bounds.map((pair) => pair[0][axis]))),
+    [0, 1, 2].map((axis) => Math.max(...bounds.map((pair) => pair[1][axis])))
+  ];
+}
+
+// dist/projection/experimental/rendering-profile/rendering-profile.js
+function resolveBounds(profile) {
+  var _a;
+  const bounds = profile.bounds;
+  if (bounds.some((corner) => corner.some((value) => !Number.isFinite(value))))
+    throw new Error("Projection rendering bounds must be finite");
+  return { bounds, normalize: (_a = profile.normalize) == null ? void 0 : _a.bind(profile) };
+}
+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;
+  };
+}
+function combineRenderingProfiles(regions, getProfile) {
+  const profiles = [];
+  for (const region of regions) {
+    const profile = getProfile(region);
+    if (profile !== null)
+      profiles.push(resolveBounds(profile));
+  }
+  if (!profiles.length)
+    return null;
+  if (profiles.length === 1)
+    return profiles[0];
+  return {
+    bounds: unionRenderingBounds(profiles.map((profile) => profile.bounds)),
+    normalize(point) {
+      var _a;
+      let bestX = point.x, bestY = point.y, best = Infinity;
+      for (const profile of profiles) {
+        const candidate = { x: point.x, y: point.y, z: point.z };
+        (_a = profile.normalize) == null ? void 0 : _a.call(profile, candidate);
+        const distance = Math.sin((candidate.y - point.y) * Math.PI / 360) ** 2 + Math.cos(point.y * Math.PI / 180) * Math.cos(candidate.y * Math.PI / 180) * Math.sin((candidate.x - point.x) * Math.PI / 360) ** 2;
+        if (distance < best) {
+          best = distance;
+          bestX = candidate.x;
+          bestY = candidate.y;
+        }
+      }
+      point.x = bestX;
+      point.y = bestY;
+    }
+  };
+}
+
+// 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];
+}
+
+// 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
+  ];
+}
+
+// dist/projection/experimental/rendering-profile/rendering-bounds.js
+var add = (a, b) => [a[0] + b[0], a[1] + b[1]];
+function multiply(a, b) {
+  const values = [a[0] * b[0], a[0] * b[1], a[1] * b[0], a[1] * b[1]];
+  return [Math.min(...values), Math.max(...values)];
+}
+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/geostationary-rendering-profile.js
+function createGeostationaryProfile(base, height, sweepX = false) {
+  const radius = 1 + height / base.a;
+  const visibleRadius = radius / (1 + 1e-10);
+  const longitudeLimit = (latitude) => Math.acos(Math.min(1, Math.sqrt(1 - base.es * Math.sin(latitude) ** 2) / (visibleRadius * Math.cos(latitude))));
+  const latitudeLimit = (longitude) => {
+    const squared = (visibleRadius * Math.cos(longitude)) ** 2;
+    return Math.asin(Math.sqrt(Math.max(0, (squared - 1) / (squared - base.es))));
+  };
+  const fullX = height * Math.asin(1 / radius);
+  const fullY = height * Math.atan(Math.sqrt((1 - base.es) / (radius * radius - 1)));
+  const create = (coverage, declared) => {
+    const closestLatitude = Math.max(coverage[0][1], Math.min(coverage[1][1], 0));
+    const maximumLongitude = longitudeLimit(closestLatitude);
+    const west = Math.max(coverage[0][0] - base.long0, -maximumLongitude);
+    const east = Math.min(coverage[1][0] - base.long0, maximumLongitude);
+    const maxLatitude = latitudeLimit(Math.max(west, Math.min(east, 0)));
+    const south = Math.max(coverage[0][1], -maxLatitude), north = Math.min(coverage[1][1], maxLatitude);
+    if (east < west || north < south)
+      return null;
+    const region = createAngularRanges(west, south, east, north);
+    const geographicCoverage = getGeographicBounds(createAngularRanges(west + base.long0, south, east + base.long0, north), base.primeMeridian);
+    const center = (base.long0 + base.primeMeridian) * 180 / Math.PI;
+    const normalizeLimb = createAngularNormalization((point) => {
+      const longitude = Math.max(west, Math.min(east, wrapLongitude(point.x - base.long0)));
+      const limit = latitudeLimit(longitude);
+      const latitude = Math.max(Math.max(south, -limit), Math.min(Math.min(north, limit), point.y));
+      if (longitude !== point.x - base.long0)
+        point.x = longitude + base.long0;
+      point.y = latitude;
+    }, base.primeMeridian);
+    return {
+      get bounds() {
+        if (!declared)
+          return envelope([base.x0 - fullX, base.x0 + fullX], [base.y0 - fullY, base.y0 + fullY]);
+        const sin = sphericalRange([0, 0, 1], region);
+        const n = [1, 1 / Math.sqrt(1 - base.es * Math.max(sin[0] ** 2, sin[1] ** 2))];
+        const x = multiply(sphericalRange([1, 0, 0], region), n);
+        const y = multiply(sphericalRange([0, 1, 0], region), n);
+        const z = multiply(sin, [1 - base.es, (1 - base.es) * n[1]]);
+        const denominators = [radius - Math.min(1, x[1]), radius - Math.max(1 / radius, x[0])];
+        const angleRange = (range, other, maximum, orthogonal) => {
+          const minimumOther = other[0] <= 0 && other[1] >= 0 ? 0 : Math.min(Math.abs(other[0]), Math.abs(other[1]));
+          const ds = orthogonal ? [
+            Math.hypot(denominators[0], minimumOther),
+            Math.hypot(denominators[1], Math.max(Math.abs(other[0]), Math.abs(other[1])))
+          ] : denominators;
+          const values = range.flatMap((value) => ds.map((d) => height * Math.atan(value / d)));
+          return [
+            Math.max(-maximum, Math.min(...values)),
+            Math.min(maximum, Math.max(...values))
+          ];
+        };
+        return envelope(add([base.x0, base.x0], angleRange(y, z, fullX, sweepX)), add([base.y0, base.y0], angleRange(z, y, fullY, !sweepX)));
+      },
+      normalize(point) {
+        normalizeCoverage(point, geographicCoverage, center);
+        normalizeLimb(point);
+      }
+    };
+  };
+  const extent = getGeographicBounds(createAngularRanges(base.long0 - longitudeLimit(0), -latitudeLimit(0), base.long0 + longitudeLimit(0), latitudeLimit(0)), base.primeMeridian);
+  return (coverage) => {
+    const regions = coverage ? intersectGeographicBounds(coverage, extent) : [extent];
+    const profile = combineRenderingProfiles(regions, (region) => create(getAngularRanges(region, base.primeMeridian, base.long0), Boolean(coverage)));
+    if (!profile)
+      throw new Error("CRS coverage does not intersect the satellite limb");
+    return profile;
+  };
+}
+
+// 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
+  };
+}
+
+// dist/projection/experimental/kernel.js
+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));
+}
+
+// dist/projection/experimental/catalogue-kernel.js
+function catalogueParameters(context) {
+  const base = kernelParameters(context);
+  return { ...base, x0: 0, y0: 0, lat_ts: Number.isNaN(base.lat_ts) ? 0 : base.lat_ts };
+}
+function catalogueBoundsParameters(state, context) {
+  return {
+    ...state,
+    x0: numberParameter(context.parameters, "x_0", 0),
+    y0: numberParameter(context.parameters, "y_0", 0)
+  };
+}
+function bindCatalogueKernel(name, context, state, forward2, inverse2, guard) {
+  const kernel = bindKernel(name, state, forward2, inverse2);
+  const x0 = numberParameter(context.parameters, "x_0", 0), y0 = numberParameter(context.parameters, "y_0", 0);
+  return createProjection((point) => {
+    guard == null ? void 0 : guard(point.x, point.y);
+    kernel.forwardInPlace(point);
+    point.x += x0;
+    point.y += y0;
+  }, (point) => {
+    point.x -= x0;
+    point.y -= y0;
+    kernel.inverseInPlace(point);
+  });
+}
+function horizonGuard(base, minimumCosine = 0, includeBoundary = false) {
+  return (longitude, latitude) => {
+    const cosine = Math.sin(base.lat0) * Math.sin(latitude) + Math.cos(base.lat0) * Math.cos(latitude) * Math.cos(longitude - base.long0);
+    if (includeBoundary ? cosine < minimumCosine - 1e-14 : cosine <= minimumCosine + 1e-14)
+      throw new Error("Coordinate is outside the visible projection horizon");
+  };
+}
+
+// dist/projection/experimental/common/hypot.js
+function hypot_default(x, y) {
+  x = Math.abs(x);
+  y = Math.abs(y);
+  var a = Math.max(x, y);
+  var b = Math.min(x, y) / (a ? a : 1);
+  return a * Math.sqrt(1 + Math.pow(b, 2));
+}
+
+// dist/projection/experimental/kernels/geos.js
+function initialize(state) {
+  state.flip_axis = state.sweep === "x" ? 1 : 0;
+  state.h = Number(state.h);
+  state.radius_g_1 = state.h / state.a;
+  if (state.radius_g_1 <= 0 || state.radius_g_1 > 1e10) {
+    throw new Error();
+  }
+  state.radius_g = 1 + state.radius_g_1;
+  state.C = state.radius_g * state.radius_g - 1;
+  if (state.es !== 0) {
+    var one_es = 1 - state.es;
+    var rone_es = 1 / one_es;
+    state.radius_p = Math.sqrt(one_es);
+    state.radius_p2 = one_es;
+    state.radius_p_inv2 = rone_es;
+    state.shape = "ellipse";
+  } else {
+    state.radius_p = 1;
+    state.radius_p2 = 1;
+    state.radius_p_inv2 = 1;
+    state.shape = "sphere";
+  }
+}
+function forward(state, p) {
+  var lon = p.x;
+  var lat = p.y;
+  var tmp, v_x, v_y, v_z;
+  lon = lon - state.long0;
+  if (state.shape === "ellipse") {
+    lat = Math.atan(state.radius_p2 * Math.tan(lat));
+    var r = state.radius_p / hypot_default(state.radius_p * Math.cos(lat), Math.sin(lat));
+    v_x = r * Math.cos(lon) * Math.cos(lat);
+    v_y = r * Math.sin(lon) * Math.cos(lat);
+    v_z = r * Math.sin(lat);
+    if ((state.radius_g - v_x) * v_x - v_y * v_y - v_z * v_z * state.radius_p_inv2 < 0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+    tmp = state.radius_g - v_x;
+    if (state.flip_axis) {
+      p.x = state.radius_g_1 * Math.atan(v_y / hypot_default(v_z, tmp));
+      p.y = state.radius_g_1 * Math.atan(v_z / tmp);
+    } else {
+      p.x = state.radius_g_1 * Math.atan(v_y / tmp);
+      p.y = state.radius_g_1 * Math.atan(v_z / hypot_default(v_y, tmp));
+    }
+  } else if (state.shape === "sphere") {
+    tmp = Math.cos(lat);
+    v_x = Math.cos(lon) * tmp;
+    v_y = Math.sin(lon) * tmp;
+    v_z = Math.sin(lat);
+    tmp = state.radius_g - v_x;
+    if (state.flip_axis) {
+      p.x = state.radius_g_1 * Math.atan(v_y / hypot_default(v_z, tmp));
+      p.y = state.radius_g_1 * Math.atan(v_z / tmp);
+    } else {
+      p.x = state.radius_g_1 * Math.atan(v_y / tmp);
+      p.y = state.radius_g_1 * Math.atan(v_z / hypot_default(v_y, tmp));
+    }
+  }
+  p.x = p.x * state.a;
+  p.y = p.y * state.a;
+  return p;
+}
+function inverse(state, p) {
+  var v_x = -1;
+  var v_y = 0;
+  var v_z = 0;
+  var a, b, det, k;
+  p.x = p.x / state.a;
+  p.y = p.y / state.a;
+  if (state.shape === "ellipse") {
+    if (state.flip_axis) {
+      v_z = Math.tan(p.y / state.radius_g_1);
+      v_y = Math.tan(p.x / state.radius_g_1) * hypot_default(1, v_z);
+    } else {
+      v_y = Math.tan(p.x / state.radius_g_1);
+      v_z = Math.tan(p.y / state.radius_g_1) * hypot_default(1, v_y);
+    }
+    var v_zp = v_z / state.radius_p;
+    a = v_y * v_y + v_zp * v_zp + v_x * v_x;
+    b = 2 * state.radius_g * v_x;
+    det = b * b - 4 * a * state.C;
+    if (det < 0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+    k = (-b - Math.sqrt(det)) / (2 * a);
+    v_x = state.radius_g + k * v_x;
+    v_y *= k;
+    v_z *= k;
+    p.x = Math.atan2(v_y, v_x);
+    p.y = Math.atan(v_z * Math.cos(p.x) / v_x);
+    p.y = Math.atan(state.radius_p_inv2 * Math.tan(p.y));
+  } else if (state.shape === "sphere") {
+    if (state.flip_axis) {
+      v_z = Math.tan(p.y / state.radius_g_1);
+      v_y = Math.tan(p.x / state.radius_g_1) * Math.sqrt(1 + v_z * v_z);
+    } else {
+      v_y = Math.tan(p.x / state.radius_g_1);
+      v_z = Math.tan(p.y / state.radius_g_1) * Math.sqrt(1 + v_y * v_y);
+    }
+    a = v_y * v_y + v_z * v_z + v_x * v_x;
+    b = 2 * state.radius_g * v_x;
+    det = b * b - 4 * a * state.C;
+    if (det < 0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+    k = (-b - Math.sqrt(det)) / (2 * a);
+    v_x = state.radius_g + k * v_x;
+    v_y *= k;
+    v_z *= k;
+    p.x = Math.atan2(v_y, v_x);
+    p.y = Math.atan(v_z * Math.cos(p.x) / v_x);
+  }
+  p.x = p.x + state.long0;
+  return p;
+}
+function createState(base, options = {}) {
+  const state = {
+    ...base,
+    flip_axis: 0,
+    sweep: "",
+    h: 0,
+    radius_g_1: 0,
+    radius_g: 0,
+    C: 0,
+    radius_p: 0,
+    radius_p2: 0,
+    radius_p_inv2: 0,
+    shape: "",
+    ...options
+  };
+  initialize(state);
+  return state;
+}
+
+// dist/projection/experimental/projections/geos.js
+var geostationary = {
+  name: "geos",
+  aliases: ["Geostationary Satellite View", "Geostationary_Satellite"],
+  parameters: ["lon_0", "x_0", "y_0", "h", "sweep"],
+  create(context) {
+    const base = catalogueParameters(context);
+    const h = numberParameter(context.parameters, "h", NaN);
+    if (!Number.isFinite(h) || h <= 0)
+      throw new Error("Geostationary projection requires positive h");
+    const sweep = context.parameters["sweep"] || "y";
+    if (!["x", "y"].includes(sweep))
+      throw new Error("Geostationary sweep must be x or y");
+    const state = createState(base, { h, sweep });
+    const projection = bindCatalogueKernel("geos", context, state, forward, inverse, base.sphere ? horizonGuard({ ...base, lat0: 0 }, 1 / (1 + h / base.a), true) : void 0);
+    return {
+      ...projection,
+      longitudeOrigin: base.long0,
+      getRenderingProfile: createGeostationaryProfile(catalogueBoundsParameters(base, context), h, sweep === "x")
+    };
+  }
+};
+//# sourceMappingURL=geos.cjs.map