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

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

@@ -0,0 +1,714 @@
+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/qsc.js
+var qsc_exports = {};
+__export(qsc_exports, {
+  quadrilateralizedSphericalCube: () => quadrilateralizedSphericalCube
+});
+module.exports = __toCommonJS(qsc_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/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/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/rendering-profile/rendering-bounds.js
+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]
+  ];
+}
+function longitudeRange(parameters, origin, over = false) {
+  const low = parameters[0][0] - origin, high = parameters[1][0] - origin;
+  if (over)
+    return [low, high];
+  const span = high - low;
+  if (span >= 2 * Math.PI - 1e-12)
+    return [-Math.PI, Math.PI];
+  let west = wrapLongitude(low);
+  if (span > 0 && Math.abs(west - Math.PI) < 1e-12)
+    west = -Math.PI;
+  const east = west + span;
+  return east > Math.PI + 1e-12 ? [-Math.PI, Math.PI] : [west, Math.min(east, Math.PI)];
+}
+
+// dist/projection/experimental/rendering-profile/geographic-rendering-profile.js
+function createGeographicProfile(parameters, primeMeridian = 0) {
+  const center = numberParameter(parameters, "lon_wrap", 0) * DEGREES_TO_RADIANS;
+  return (coverage) => createRectangleRenderingProfile((ranges) => {
+    const longitude = longitudeRange(ranges, center);
+    return [
+      [center + longitude[0], ranges[0][1], 0],
+      [center + longitude[1], ranges[1][1], 0]
+    ];
+  }, coverage ?? [-180, -90, 180, 90], center, primeMeridian);
+}
+
+// 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 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);
+  });
+}
+
+// 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/kernels/qsc.js
+var FACE_ENUM = {
+  FRONT: 1,
+  RIGHT: 2,
+  BACK: 3,
+  LEFT: 4,
+  TOP: 5,
+  BOTTOM: 6
+};
+var AREA_ENUM = {
+  AREA_0: 1,
+  AREA_1: 2,
+  AREA_2: 3,
+  AREA_3: 4
+};
+function initialize(state) {
+  state.x0 = state.x0 || 0;
+  state.y0 = state.y0 || 0;
+  state.lat0 = state.lat0 || 0;
+  state.long0 = state.long0 || 0;
+  state.lat_ts = state.lat_ts || 0;
+  if (state.lat0 >= HALF_PI - FORTPI / 2) {
+    state.face = FACE_ENUM.TOP;
+  } else if (state.lat0 <= -(HALF_PI - FORTPI / 2)) {
+    state.face = FACE_ENUM.BOTTOM;
+  } else if (Math.abs(state.long0) <= FORTPI) {
+    state.face = FACE_ENUM.FRONT;
+  } else if (Math.abs(state.long0) <= HALF_PI + FORTPI) {
+    state.face = state.long0 > 0 ? FACE_ENUM.RIGHT : FACE_ENUM.LEFT;
+  } else {
+    state.face = FACE_ENUM.BACK;
+  }
+  if (state.es !== 0) {
+    state.one_minus_f = 1 - (state.a - state.b) / state.a;
+    state.one_minus_f_squared = state.one_minus_f * state.one_minus_f;
+  }
+}
+function forward(state, p) {
+  var xy = p;
+  var lat, lon;
+  var theta, phi;
+  var t, mu;
+  var area = 0;
+  p.x -= state.long0;
+  if (state.es !== 0) {
+    lat = Math.atan(state.one_minus_f_squared * Math.tan(p.y));
+  } else {
+    lat = p.y;
+  }
+  lon = p.x;
+  if (state.face === FACE_ENUM.TOP) {
+    phi = HALF_PI - lat;
+    if (lon >= FORTPI && lon <= HALF_PI + FORTPI) {
+      area = AREA_ENUM.AREA_0;
+      theta = lon - HALF_PI;
+    } else if (lon > HALF_PI + FORTPI || lon <= -(HALF_PI + FORTPI)) {
+      area = AREA_ENUM.AREA_1;
+      theta = lon > 0 ? lon - SPI : lon + SPI;
+    } else if (lon > -(HALF_PI + FORTPI) && lon <= -FORTPI) {
+      area = AREA_ENUM.AREA_2;
+      theta = lon + HALF_PI;
+    } else {
+      area = AREA_ENUM.AREA_3;
+      theta = lon;
+    }
+  } else if (state.face === FACE_ENUM.BOTTOM) {
+    phi = HALF_PI + lat;
+    if (lon >= FORTPI && lon <= HALF_PI + FORTPI) {
+      area = AREA_ENUM.AREA_0;
+      theta = -lon + HALF_PI;
+    } else if (lon < FORTPI && lon >= -FORTPI) {
+      area = AREA_ENUM.AREA_1;
+      theta = -lon;
+    } else if (lon < -FORTPI && lon >= -(HALF_PI + FORTPI)) {
+      area = AREA_ENUM.AREA_2;
+      theta = -lon - HALF_PI;
+    } else {
+      area = AREA_ENUM.AREA_3;
+      theta = lon > 0 ? -lon + SPI : -lon - SPI;
+    }
+  } else {
+    var q, r, s;
+    var sinlat, coslat;
+    var sinlon, coslon;
+    if (state.face === FACE_ENUM.RIGHT) {
+      lon = qsc_shift_lon_origin(lon, +HALF_PI);
+    } else if (state.face === FACE_ENUM.BACK) {
+      lon = qsc_shift_lon_origin(lon, +SPI);
+    } else if (state.face === FACE_ENUM.LEFT) {
+      lon = qsc_shift_lon_origin(lon, -HALF_PI);
+    }
+    sinlat = Math.sin(lat);
+    coslat = Math.cos(lat);
+    sinlon = Math.sin(lon);
+    coslon = Math.cos(lon);
+    q = coslat * coslon;
+    r = coslat * sinlon;
+    s = sinlat;
+    if (state.face === FACE_ENUM.FRONT) {
+      phi = Math.acos(q);
+      theta = qsc_fwd_equat_face_theta(phi, s, r);
+    } else if (state.face === FACE_ENUM.RIGHT) {
+      phi = Math.acos(r);
+      theta = qsc_fwd_equat_face_theta(phi, s, -q);
+    } else if (state.face === FACE_ENUM.BACK) {
+      phi = Math.acos(-q);
+      theta = qsc_fwd_equat_face_theta(phi, s, -r);
+    } else if (state.face === FACE_ENUM.LEFT) {
+      phi = Math.acos(-r);
+      theta = qsc_fwd_equat_face_theta(phi, s, q);
+    } else {
+      phi = theta = 0;
+    }
+    if (Math.abs(theta) <= FORTPI) {
+      area = AREA_ENUM.AREA_0;
+    } else if (theta > FORTPI && theta <= HALF_PI + FORTPI) {
+      area = AREA_ENUM.AREA_1;
+      theta -= HALF_PI;
+    } else if (theta > HALF_PI + FORTPI || theta <= -(HALF_PI + FORTPI)) {
+      area = AREA_ENUM.AREA_2;
+      theta = theta >= 0 ? theta - SPI : theta + SPI;
+    } else {
+      area = AREA_ENUM.AREA_3;
+      theta += HALF_PI;
+    }
+  }
+  mu = Math.atan(12 / SPI * (theta + Math.acos(Math.sin(theta) * Math.cos(FORTPI)) - HALF_PI));
+  t = Math.sqrt((1 - Math.cos(phi)) / (Math.cos(mu) * Math.cos(mu)) / (1 - Math.cos(Math.atan(1 / Math.cos(theta)))));
+  if (area === AREA_ENUM.AREA_1) {
+    mu += HALF_PI;
+  } else if (area === AREA_ENUM.AREA_2) {
+    mu += SPI;
+  } else if (area === AREA_ENUM.AREA_3) {
+    mu += 1.5 * SPI;
+  }
+  xy.x = t * Math.cos(mu);
+  xy.y = t * Math.sin(mu);
+  xy.x = xy.x * state.a + state.x0;
+  xy.y = xy.y * state.a + state.y0;
+  return p;
+}
+function inverse(state, p) {
+  var lam = 0, latitude = 0;
+  var mu, nu, cosmu, tannu;
+  var tantheta, theta, cosphi, phi;
+  var t;
+  var area = 0;
+  p.x = (p.x - state.x0) / state.a;
+  p.y = (p.y - state.y0) / state.a;
+  nu = Math.atan(Math.sqrt(p.x * p.x + p.y * p.y));
+  mu = Math.atan2(p.y, p.x);
+  if (p.x >= 0 && p.x >= Math.abs(p.y)) {
+    area = AREA_ENUM.AREA_0;
+  } else if (p.y >= 0 && p.y >= Math.abs(p.x)) {
+    area = AREA_ENUM.AREA_1;
+    mu -= HALF_PI;
+  } else if (p.x < 0 && -p.x >= Math.abs(p.y)) {
+    area = AREA_ENUM.AREA_2;
+    mu = mu < 0 ? mu + SPI : mu - SPI;
+  } else {
+    area = AREA_ENUM.AREA_3;
+    mu += HALF_PI;
+  }
+  t = SPI / 12 * Math.tan(mu);
+  tantheta = Math.sin(t) / (Math.cos(t) - 1 / Math.sqrt(2));
+  theta = Math.atan(tantheta);
+  cosmu = Math.cos(mu);
+  tannu = Math.tan(nu);
+  cosphi = 1 - cosmu * cosmu * tannu * tannu * (1 - Math.cos(Math.atan(1 / Math.cos(theta))));
+  if (cosphi < -1) {
+    cosphi = -1;
+  } else if (cosphi > 1) {
+    cosphi = 1;
+  }
+  if (state.face === FACE_ENUM.TOP) {
+    phi = Math.acos(cosphi);
+    latitude = HALF_PI - phi;
+    if (area === AREA_ENUM.AREA_0) {
+      lam = theta + HALF_PI;
+    } else if (area === AREA_ENUM.AREA_1) {
+      lam = theta < 0 ? theta + SPI : theta - SPI;
+    } else if (area === AREA_ENUM.AREA_2) {
+      lam = theta - HALF_PI;
+    } else {
+      lam = theta;
+    }
+  } else if (state.face === FACE_ENUM.BOTTOM) {
+    phi = Math.acos(cosphi);
+    latitude = phi - HALF_PI;
+    if (area === AREA_ENUM.AREA_0) {
+      lam = -theta + HALF_PI;
+    } else if (area === AREA_ENUM.AREA_1) {
+      lam = -theta;
+    } else if (area === AREA_ENUM.AREA_2) {
+      lam = -theta - HALF_PI;
+    } else {
+      lam = theta < 0 ? -theta - SPI : -theta + SPI;
+    }
+  } else {
+    var q, r, s;
+    q = cosphi;
+    t = q * q;
+    if (t >= 1) {
+      s = 0;
+    } else {
+      s = Math.sqrt(1 - t) * Math.sin(theta);
+    }
+    t += s * s;
+    if (t >= 1) {
+      r = 0;
+    } else {
+      r = Math.sqrt(1 - t);
+    }
+    if (area === AREA_ENUM.AREA_1) {
+      t = r;
+      r = -s;
+      s = t;
+    } else if (area === AREA_ENUM.AREA_2) {
+      r = -r;
+      s = -s;
+    } else if (area === AREA_ENUM.AREA_3) {
+      t = r;
+      r = s;
+      s = -t;
+    }
+    if (state.face === FACE_ENUM.RIGHT) {
+      t = q;
+      q = -r;
+      r = t;
+    } else if (state.face === FACE_ENUM.BACK) {
+      q = -q;
+      r = -r;
+    } else if (state.face === FACE_ENUM.LEFT) {
+      t = q;
+      q = r;
+      r = -t;
+    }
+    latitude = Math.acos(-s) - HALF_PI;
+    lam = Math.atan2(r, q);
+    if (state.face === FACE_ENUM.RIGHT) {
+      lam = qsc_shift_lon_origin(lam, -HALF_PI);
+    } else if (state.face === FACE_ENUM.BACK) {
+      lam = qsc_shift_lon_origin(lam, -SPI);
+    } else if (state.face === FACE_ENUM.LEFT) {
+      lam = qsc_shift_lon_origin(lam, +HALF_PI);
+    }
+  }
+  if (state.es !== 0) {
+    var invert_sign;
+    var tanphi, xa;
+    invert_sign = latitude < 0 ? 1 : 0;
+    tanphi = Math.tan(latitude);
+    xa = state.b / Math.sqrt(tanphi * tanphi + state.one_minus_f_squared);
+    latitude = Math.atan(Math.sqrt(state.a * state.a - xa * xa) / (state.one_minus_f * xa));
+    if (invert_sign) {
+      latitude = -latitude;
+    }
+  }
+  lam += state.long0;
+  p.x = lam;
+  p.y = latitude;
+  return p;
+}
+function qsc_fwd_equat_face_theta(phi, y, x) {
+  return phi < EPSLN ? 0 : Math.atan2(y, x);
+}
+function qsc_shift_lon_origin(lon, offset) {
+  var slon = lon + offset;
+  if (slon < -SPI) {
+    slon += TWO_PI;
+  } else if (slon > +SPI) {
+    slon -= TWO_PI;
+  }
+  return slon;
+}
+function createState(base, options = {}) {
+  const state = { ...base, face: 0, one_minus_f: 0, one_minus_f_squared: 0, ...options };
+  initialize(state);
+  return state;
+}
+
+// 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/projections/qsc.js
+var quadrilateralizedSphericalCube = {
+  name: "qsc",
+  aliases: ["Quadrilateralized Spherical Cube", "Quadrilateralized_Spherical_Cube"],
+  parameters: ["lon_0", "x_0", "y_0", "lat_0"],
+  create(context) {
+    const base = catalogueParameters(context);
+    const primeMeridian = context.primeMeridian ?? 0;
+    const state = createState(base);
+    const implementation = bindCatalogueKernel("qsc", context, state, forward, inverse);
+    const x0 = numberParameter(context.parameters, "x_0", 0);
+    const y0 = numberParameter(context.parameters, "y_0", 0);
+    return {
+      ...implementation,
+      longitudeOrigin: base.long0,
+      getRenderingProfile(coverage) {
+        if (coverage)
+          return createRectangleRenderingProfile((region) => {
+            const latitude = (phi) => base.es ? Math.atan((1 - base.es) * Math.tan(phi)) : phi;
+            const local = createAngularRanges(region[0][0] - base.long0, latitude(region[0][1]), region[1][0] - base.long0, latitude(region[1][1]));
+            const axis = state.face === 5 ? [0, 0, 1] : state.face === 6 ? [0, 0, -1] : [1, 0, 0];
+            const cosine = sphericalRange(axis, local)[0];
+            const radius = base.a * Math.sqrt((1 - cosine) / (0.5 * (1 - Math.SQRT1_2)));
+            return envelope([x0 - radius, x0 + radius], [y0 - radius, y0 + radius]);
+          }, coverage, base.long0, primeMeridian);
+        const defaultBounds = [
+          [x0 - base.a, y0 - base.a, 0],
+          [x0 + base.a, y0 + base.a, 0]
+        ];
+        const normalizeGeographic = createGeographicProfile(context.parameters, primeMeridian)().normalize;
+        const normalizeFace = createAngularNormalization((point) => {
+          const [x, y] = implementation.forward(point.x, point.y);
+          if (Math.abs(x - x0) <= base.a && Math.abs(y - y0) <= base.a)
+            return;
+          [point.x, point.y] = implementation.inverse(x0 + Math.max(-base.a, Math.min(base.a, x - x0)), y0 + Math.max(-base.a, Math.min(base.a, y - y0)));
+        }, primeMeridian);
+        return {
+          bounds: defaultBounds,
+          normalize(point) {
+            normalizeGeographic(point);
+            normalizeFace(point);
+          }
+        };
+      }
+    };
+  }
+};
+//# sourceMappingURL=qsc.cjs.map