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

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

@@ -0,0 +1,887 @@
+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/etmerc.js
+var etmerc_exports = {};
+__export(etmerc_exports, {
+  extendedTransverseMercator: () => extendedTransverseMercator
+});
+module.exports = __toCommonJS(etmerc_exports);
+
+// 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(forward3, inverse3) {
+  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, forward3);
+    },
+    inverse(x, y) {
+      return scalar(x, y, inverse3);
+    },
+    forwardInPlace: forward3,
+    inverseInPlace: inverse3
+  };
+}
+
+// dist/projection/experimental/flat-projection.js
+function createFlatProjection(forward3, inverse3) {
+  return {
+    ...createProjection(forward3, inverse3),
+    createForwardFlat(context) {
+      return this.forwardInPlace === forward3 ? createFlatOperation(forward3, false, context) : void 0;
+    },
+    createInverseFlat(context) {
+      return this.inverseInPlace === inverse3 ? createFlatOperation(inverse3, true, context) : void 0;
+    }
+  };
+}
+function createFlatOperation(project, inverse3, { inputScale, outputScale }) {
+  const scratch = new ProjectionScratch();
+  return (coordinates, dimension) => {
+    const point = scratch.acquire();
+    try {
+      const float32 = coordinates instanceof Float32Array;
+      for (let offset = 0; offset < coordinates.length; offset += dimension) {
+        point.x = coordinates[offset];
+        point.y = coordinates[offset + 1];
+        point.z = dimension >= 3 ? coordinates[offset + 2] : 0;
+        if (!Number.isFinite(point.x) || !Number.isFinite(point.y) || !Number.isFinite(point.z))
+          throw new Error("Coordinates must contain finite x, y and optional z values");
+        if (inputScale !== 1) {
+          point.x *= inputScale;
+          point.y *= inputScale;
+        }
+        if (inverse3)
+          project(point);
+        if (Math.abs(point.y) > Math.PI / 2 || !Number.isFinite(point.x) || !Number.isFinite(point.y))
+          throw new Error("Coordinate is outside the geographic domain");
+        point.x += 0;
+        point.x -= 0;
+        if (!inverse3)
+          project(point);
+        if (outputScale !== 1) {
+          point.x /= outputScale;
+          point.y /= outputScale;
+        }
+        if (!Number.isFinite(point.x) || !Number.isFinite(point.y))
+          throw new Error("Projection produced non-finite coordinates");
+        if (float32 && (Math.abs(point.x) > 34028234663852886e22 || Math.abs(point.y) > 34028234663852886e22))
+          throw new Error("Projected coordinate exceeds Float32 range");
+        coordinates[offset] = point.x;
+        coordinates[offset + 1] = point.y;
+      }
+    } finally {
+      scratch.release(point);
+    }
+  };
+}
+
+// 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/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)];
+}
+function transverseBounds(project, parameters, origin, over = false, equator = 0) {
+  const longitude = longitudeRange(parameters, origin, over);
+  if (maxAbs(longitude) > Math.PI / 6 + 1e-12)
+    throw new Error("Unsupported transverse rendering coverage");
+  const longitudes = [
+    longitude[0],
+    longitude[1],
+    Math.max(longitude[0], Math.min(longitude[1], 0))
+  ];
+  const latitudes = [
+    parameters[0][1],
+    parameters[1][1],
+    Math.max(parameters[0][1], Math.min(parameters[1][1], equator))
+  ];
+  const points = longitudes.flatMap((x) => latitudes.map((y) => project(origin + x, y)));
+  return envelope([Math.min(...points.map((p) => p[0])), Math.max(...points.map((p) => p[0]))], [Math.min(...points.map((p) => p[1])), Math.max(...points.map((p) => p[1]))]);
+}
+
+// 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 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];
+}
+function createRectangleRenderingProfile(resolveBounds2, coverage, origin = 0, primeMeridian = 0, over = false) {
+  const center = (origin + primeMeridian) * 180 / Math.PI;
+  return {
+    get bounds() {
+      return resolveBounds2(getAngularRanges(coverage, primeMeridian, origin));
+    },
+    normalize(point) {
+      normalizeCoverage(point, coverage, center, over);
+    }
+  };
+}
+function createRegionsRenderingProfile(resolveBounds2, regions, origin, primeMeridian, over) {
+  const profile = combineRenderingProfiles(regions, (region) => createRectangleRenderingProfile(resolveBounds2, region, origin, primeMeridian, over));
+  if (!profile)
+    throw new Error("CRS coverage does not intersect the rendering target");
+  return profile;
+}
+function withRectangleRenderingProfile(implementation, parameters, resolveBounds2, primeMeridian = 0, over = false) {
+  const origin = (parameters[0][0] + parameters[1][0]) / 2;
+  const defaults = getGeographicBounds(parameters, primeMeridian);
+  const center = (origin + primeMeridian) * 180 / Math.PI;
+  return {
+    ...implementation,
+    longitudeOrigin: origin,
+    getRenderingProfile(coverage) {
+      if (!coverage)
+        return {
+          bounds: resolveBounds2(parameters),
+          normalize(point) {
+            normalizeCoverage(point, defaults, center, over);
+          }
+        };
+      try {
+        const profile = createRectangleRenderingProfile(resolveBounds2, coverage, origin, primeMeridian, over);
+        const bounds = profile.bounds;
+        return { bounds, normalize: profile.normalize };
+      } catch {
+        return createRegionsRenderingProfile(resolveBounds2, intersectGeographicBounds(coverage, defaults), origin, primeMeridian, over);
+      }
+    }
+  };
+}
+
+// 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, forward3, inverse3, 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(forward3, point), (point) => run(inverse3, point));
+}
+
+// dist/projection/experimental/common/sinh.js
+function sinh_default(x) {
+  var r = Math.exp(x);
+  r = (r - 1 / r) / 2;
+  return r;
+}
+
+// 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/common/log1py.js
+function log1py_default(x) {
+  var y = 1 + x;
+  var z = y - 1;
+  return z === 0 ? x : x * Math.log(y) / z;
+}
+
+// dist/projection/experimental/common/asinhy.js
+function asinhy_default(x) {
+  var y = Math.abs(x);
+  y = log1py_default(y * (1 + y / (hypot_default(1, y) + 1)));
+  return x < 0 ? -y : y;
+}
+
+// dist/projection/experimental/common/gatg.js
+function gatg_default(pp, B) {
+  var cos_2B = 2 * Math.cos(2 * B);
+  var i = pp.length - 1;
+  var h1 = pp[i];
+  var h2 = 0;
+  var h;
+  while (--i >= 0) {
+    h = -h2 + cos_2B * h1 + pp[i];
+    h2 = h1;
+    h1 = h;
+  }
+  return B + h * Math.sin(2 * B);
+}
+
+// dist/projection/experimental/common/clens.js
+function clens_default(pp, arg_r) {
+  var r = 2 * Math.cos(arg_r);
+  var i = pp.length - 1;
+  var hr1 = pp[i];
+  var hr2 = 0;
+  var hr;
+  while (--i >= 0) {
+    hr = -hr2 + r * hr1 + pp[i];
+    hr2 = hr1;
+    hr1 = hr;
+  }
+  return Math.sin(arg_r) * hr;
+}
+
+// dist/projection/experimental/common/cosh.js
+function cosh_default(x) {
+  var r = Math.exp(x);
+  r = (r + 1 / r) / 2;
+  return r;
+}
+
+// dist/projection/experimental/common/clens_cmplx.js
+function clens_cmplx_default(pp, arg_r, arg_i, output) {
+  var sin_arg_r = Math.sin(arg_r);
+  var cos_arg_r = Math.cos(arg_r);
+  var sinh_arg_i = sinh_default(arg_i);
+  var cosh_arg_i = cosh_default(arg_i);
+  var r = 2 * cos_arg_r * cosh_arg_i;
+  var i = -2 * sin_arg_r * sinh_arg_i;
+  var j = pp.length - 1;
+  var hr = pp[j];
+  var hi1 = 0;
+  var hr1 = 0;
+  var hi = 0;
+  var hr2;
+  var hi2;
+  while (--j >= 0) {
+    hr2 = hr1;
+    hi2 = hi1;
+    hr1 = hr;
+    hi1 = hi;
+    hr = -hr2 + r * hr1 - i * hi1 + pp[j];
+    hi = -hi2 + i * hr1 + r * hi1;
+  }
+  r = sin_arg_r * cosh_arg_i;
+  i = cos_arg_r * sinh_arg_i;
+  output.x = r * hr - i * hi;
+  output.y = r * hi + i * hr;
+}
+
+// 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/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/etmerc.js
+function initialize(state) {
+  state.x0 = state.x0 !== void 0 ? state.x0 : 0;
+  state.y0 = state.y0 !== void 0 ? state.y0 : 0;
+  state.long0 = state.long0 !== void 0 ? state.long0 : 0;
+  state.lat0 = state.lat0 !== void 0 ? state.lat0 : 0;
+  state.k0 = state.k0 !== void 0 ? state.k0 : 1;
+  state.cgb = [];
+  state.cbg = [];
+  state.utg = [];
+  state.gtu = [];
+  var f = state.es / (1 + Math.sqrt(1 - state.es));
+  var n = f / (2 - f);
+  var np = n;
+  state.cgb[0] = n * (2 + n * (-2 / 3 + n * (-2 + n * (116 / 45 + n * (26 / 45 + n * (-2854 / 675))))));
+  state.cbg[0] = n * (-2 + n * (2 / 3 + n * (4 / 3 + n * (-82 / 45 + n * (32 / 45 + n * (4642 / 4725))))));
+  np = np * n;
+  state.cgb[1] = np * (7 / 3 + n * (-8 / 5 + n * (-227 / 45 + n * (2704 / 315 + n * (2323 / 945)))));
+  state.cbg[1] = np * (5 / 3 + n * (-16 / 15 + n * (-13 / 9 + n * (904 / 315 + n * (-1522 / 945)))));
+  np = np * n;
+  state.cgb[2] = np * (56 / 15 + n * (-136 / 35 + n * (-1262 / 105 + n * (73814 / 2835))));
+  state.cbg[2] = np * (-26 / 15 + n * (34 / 21 + n * (8 / 5 + n * (-12686 / 2835))));
+  np = np * n;
+  state.cgb[3] = np * (4279 / 630 + n * (-332 / 35 + n * (-399572 / 14175)));
+  state.cbg[3] = np * (1237 / 630 + n * (-12 / 5 + n * (-24832 / 14175)));
+  np = np * n;
+  state.cgb[4] = np * (4174 / 315 + n * (-144838 / 6237));
+  state.cbg[4] = np * (-734 / 315 + n * (109598 / 31185));
+  np = np * n;
+  state.cgb[5] = np * (601676 / 22275);
+  state.cbg[5] = np * (444337 / 155925);
+  np = Math.pow(n, 2);
+  state.Qn = state.k0 / (1 + n) * (1 + np * (1 / 4 + np * (1 / 64 + np / 256)));
+  state.utg[0] = n * (-0.5 + n * (2 / 3 + n * (-37 / 96 + n * (1 / 360 + n * (81 / 512 + n * (-96199 / 604800))))));
+  state.gtu[0] = n * (0.5 + n * (-2 / 3 + n * (5 / 16 + n * (41 / 180 + n * (-127 / 288 + n * (7891 / 37800))))));
+  state.utg[1] = np * (-1 / 48 + n * (-1 / 15 + n * (437 / 1440 + n * (-46 / 105 + n * (1118711 / 3870720)))));
+  state.gtu[1] = np * (13 / 48 + n * (-3 / 5 + n * (557 / 1440 + n * (281 / 630 + n * (-1983433 / 1935360)))));
+  np = np * n;
+  state.utg[2] = np * (-17 / 480 + n * (37 / 840 + n * (209 / 4480 + n * (-5569 / 90720))));
+  state.gtu[2] = np * (61 / 240 + n * (-103 / 140 + n * (15061 / 26880 + n * (167603 / 181440))));
+  np = np * n;
+  state.utg[3] = np * (-4397 / 161280 + n * (11 / 504 + n * (830251 / 7257600)));
+  state.gtu[3] = np * (49561 / 161280 + n * (-179 / 168 + n * (6601661 / 7257600)));
+  np = np * n;
+  state.utg[4] = np * (-4583 / 161280 + n * (108847 / 3991680));
+  state.gtu[4] = np * (34729 / 80640 + n * (-3418889 / 1995840));
+  np = np * n;
+  state.utg[5] = np * (-20648693 / 638668800);
+  state.gtu[5] = np * (212378941 / 319334400);
+  var Z = gatg_default(state.cbg, state.lat0);
+  state.Zb = -state.Qn * (Z + clens_default(state.gtu, 2 * Z));
+}
+function forward(state, p) {
+  var Ce = adjust_lon_default(p.x - state.long0, state.over);
+  var Cn = p.y;
+  Cn = gatg_default(state.cbg, Cn);
+  var sin_Cn = Math.sin(Cn);
+  var cos_Cn = Math.cos(Cn);
+  var sin_Ce = Math.sin(Ce);
+  var cos_Ce = Math.cos(Ce);
+  Cn = Math.atan2(sin_Cn, cos_Ce * cos_Cn);
+  Ce = Math.atan2(sin_Ce * cos_Cn, hypot_default(sin_Cn, cos_Cn * cos_Ce));
+  Ce = asinhy_default(Math.tan(Ce));
+  clens_cmplx_default(state.gtu, 2 * Cn, 2 * Ce, p);
+  Cn = Cn + p.x;
+  Ce = Ce + p.y;
+  var x;
+  var y;
+  if (Math.abs(Ce) <= 2.623395162778) {
+    x = state.a * (state.Qn * Ce) + state.x0;
+    y = state.a * (state.Qn * Cn + state.Zb) + state.y0;
+  } else {
+    x = Infinity;
+    y = Infinity;
+  }
+  p.x = x;
+  p.y = y;
+  return p;
+}
+function inverse(state, p) {
+  var Ce = (p.x - state.x0) * (1 / state.a);
+  var Cn = (p.y - state.y0) * (1 / state.a);
+  Cn = (Cn - state.Zb) / state.Qn;
+  Ce = Ce / state.Qn;
+  var lon;
+  var lat;
+  if (Math.abs(Ce) <= 2.623395162778) {
+    clens_cmplx_default(state.utg, 2 * Cn, 2 * Ce, p);
+    Cn = Cn + p.x;
+    Ce = Ce + p.y;
+    Ce = Math.atan(sinh_default(Ce));
+    var sin_Cn = Math.sin(Cn);
+    var cos_Cn = Math.cos(Cn);
+    var sin_Ce = Math.sin(Ce);
+    var cos_Ce = Math.cos(Ce);
+    Cn = Math.atan2(sin_Cn * cos_Ce, hypot_default(sin_Ce, cos_Ce * cos_Cn));
+    Ce = Math.atan2(sin_Ce, cos_Ce * cos_Cn);
+    lon = adjust_lon_default(Ce + state.long0, state.over);
+    lat = gatg_default(state.cgb, Cn);
+  } else {
+    lon = Infinity;
+    lat = Infinity;
+  }
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+function createState(base) {
+  const state = {
+    ...base,
+    cgb: [],
+    cbg: [],
+    utg: [],
+    gtu: [],
+    Qn: 0,
+    Zb: 0
+  };
+  initialize(state);
+  return state;
+}
+
+// dist/projection/experimental/common/pj_enfn.js
+var C00 = 1;
+var C02 = 0.25;
+var C04 = 0.046875;
+var C06 = 0.01953125;
+var C08 = 0.01068115234375;
+var C22 = 0.75;
+var C44 = 0.46875;
+var C46 = 0.013020833333333334;
+var C48 = 0.007120768229166667;
+var C66 = 0.3645833333333333;
+var C68 = 0.005696614583333333;
+var C88 = 0.3076171875;
+function pj_enfn_default(es) {
+  var en = [];
+  en[0] = C00 - es * (C02 + es * (C04 + es * (C06 + es * C08)));
+  en[1] = es * (C22 - es * (C04 + es * (C06 + es * C08)));
+  var t = es * es;
+  en[2] = t * (C44 - es * (C46 + es * C48));
+  t *= es;
+  en[3] = t * (C66 - es * C68);
+  en[4] = t * es * C88;
+  return en;
+}
+
+// dist/projection/experimental/common/pj_mlfn.js
+function pj_mlfn_default(phi, sphi, cphi, en) {
+  cphi *= sphi;
+  sphi *= sphi;
+  return en[0] * phi - cphi * (en[1] + sphi * (en[2] + sphi * (en[3] + sphi * en[4])));
+}
+
+// dist/projection/experimental/common/pj_inv_mlfn.js
+var MAX_ITER = 20;
+function pj_inv_mlfn_default(arg, es, en) {
+  var k = 1 / (1 - es);
+  var phi = arg;
+  for (var i = MAX_ITER; i; --i) {
+    var s = Math.sin(phi);
+    var t = 1 - es * s * s;
+    t = (pj_mlfn_default(phi, s, Math.cos(phi), en) - arg) * (t * Math.sqrt(t)) * k;
+    phi -= t;
+    if (Math.abs(t) < EPSLN) {
+      return phi;
+    }
+  }
+  return phi;
+}
+
+// dist/projection/experimental/kernels/tmerc.js
+function initialize2(state) {
+  state.x0 = state.x0 !== void 0 ? state.x0 : 0;
+  state.y0 = state.y0 !== void 0 ? state.y0 : 0;
+  state.long0 = state.long0 !== void 0 ? state.long0 : 0;
+  state.lat0 = state.lat0 !== void 0 ? state.lat0 : 0;
+  if (state.es) {
+    state.en = pj_enfn_default(state.es);
+    state.ml0 = pj_mlfn_default(state.lat0, Math.sin(state.lat0), Math.cos(state.lat0), state.en);
+  }
+}
+function forward2(state, p) {
+  var lon = p.x;
+  var lat = p.y;
+  var delta_lon = adjust_lon_default(lon - state.long0, state.over);
+  var con;
+  var x, y;
+  var sin_phi = Math.sin(lat);
+  var cos_phi = Math.cos(lat);
+  if (!state.es) {
+    var b = cos_phi * Math.sin(delta_lon);
+    if (Math.abs(Math.abs(b) - 1) < EPSLN) {
+      return 93;
+    } else {
+      x = 0.5 * state.a * state.k0 * Math.log((1 + b) / (1 - b)) + state.x0;
+      y = cos_phi * Math.cos(delta_lon) / Math.sqrt(1 - Math.pow(b, 2));
+      b = Math.abs(y);
+      if (b >= 1) {
+        if (b - 1 > EPSLN) {
+          return 93;
+        } else {
+          y = 0;
+        }
+      } else {
+        y = Math.acos(y);
+      }
+      if (lat < 0) {
+        y = -y;
+      }
+      y = state.a * state.k0 * (y - state.lat0) + state.y0;
+    }
+  } else {
+    var al = cos_phi * delta_lon;
+    var als = Math.pow(al, 2);
+    var c = state.ep2 * Math.pow(cos_phi, 2);
+    var cs = Math.pow(c, 2);
+    var tq = Math.abs(cos_phi) > EPSLN ? Math.tan(lat) : 0;
+    var t = Math.pow(tq, 2);
+    var ts = Math.pow(t, 2);
+    con = 1 - state.es * Math.pow(sin_phi, 2);
+    al = al / Math.sqrt(con);
+    var ml = pj_mlfn_default(lat, sin_phi, cos_phi, state.en);
+    x = state.a * (state.k0 * al * (1 + als / 6 * (1 - t + c + als / 20 * (5 - 18 * t + ts + 14 * c - 58 * t * c + als / 42 * (61 + 179 * ts - ts * t - 479 * t))))) + state.x0;
+    y = state.a * (state.k0 * (ml - state.ml0 + sin_phi * delta_lon * al / 2 * (1 + als / 12 * (5 - t + 9 * c + 4 * cs + als / 30 * (61 + ts - 58 * t + 270 * c - 330 * t * c + als / 56 * (1385 + 543 * ts - ts * t - 3111 * t)))))) + state.y0;
+  }
+  p.x = x;
+  p.y = y;
+  return p;
+}
+function inverse2(state, p) {
+  var con, phi;
+  var lat, lon;
+  var x = (p.x - state.x0) * (1 / state.a);
+  var y = (p.y - state.y0) * (1 / state.a);
+  if (!state.es) {
+    var f = Math.exp(x / state.k0);
+    var g = 0.5 * (f - 1 / f);
+    var temp = state.lat0 + y / state.k0;
+    var h = Math.cos(temp);
+    con = Math.sqrt((1 - Math.pow(h, 2)) / (1 + Math.pow(g, 2)));
+    lat = Math.asin(con);
+    if (Math.sin(temp) < 0) {
+      lat = -lat;
+    }
+    if (g === 0 && h === 0) {
+      lon = 0;
+    } else {
+      lon = adjust_lon_default(Math.atan2(g, h) + state.long0, state.over);
+    }
+  } else {
+    con = state.ml0 + y / state.k0;
+    phi = pj_inv_mlfn_default(con, state.es, state.en);
+    if (Math.abs(phi) < HALF_PI) {
+      var sin_phi = Math.sin(phi);
+      var cos_phi = Math.cos(phi);
+      var tan_phi = Math.abs(cos_phi) > EPSLN ? Math.tan(phi) : 0;
+      var c = state.ep2 * Math.pow(cos_phi, 2);
+      var cs = Math.pow(c, 2);
+      var t = Math.pow(tan_phi, 2);
+      var ts = Math.pow(t, 2);
+      con = 1 - state.es * Math.pow(sin_phi, 2);
+      var d = x * Math.sqrt(con) / state.k0;
+      var ds = Math.pow(d, 2);
+      con = con * tan_phi;
+      lat = phi - con * ds / (1 - state.es) * 0.5 * (1 - ds / 12 * (5 + 3 * t - 9 * c * t + c - 4 * cs - ds / 30 * (61 + 90 * t - 252 * c * t + 45 * ts + 46 * c - ds / 56 * (1385 + 3633 * t + 4095 * ts + 1574 * ts * t))));
+      lon = adjust_lon_default(state.long0 + d * (1 - ds / 6 * (1 + 2 * t + c - ds / 20 * (5 + 28 * t + 24 * ts + 8 * c * t + 6 * c - ds / 42 * (61 + 662 * t + 1320 * ts + 720 * ts * t)))) / cos_phi, state.over);
+    } else {
+      lat = HALF_PI * sign_default(y);
+      lon = 0;
+    }
+  }
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+function createState2(base) {
+  const state = {
+    ...base,
+    en: [],
+    ml0: 0
+  };
+  initialize2(state);
+  return state;
+}
+
+// dist/projection/experimental/projections/transverse-mercator.js
+function createTransverseMercator(context) {
+  const base = kernelParameters(context);
+  const render = (implementation) => withRectangleRenderingProfile(implementation, createAngularRanges(base.long0 - Math.PI / 6, -Math.PI / 2, base.long0 + Math.PI / 6, Math.PI / 2), (ranges) => transverseBounds(implementation.forward, ranges, base.long0, base.over), base.primeMeridian, base.over);
+  if (flagParameter(context.parameters, "approx")) {
+    return render({
+      ...bindKernel("tmerc +approx", createState2(base), forward2, inverse2, createFlatProjection)
+    });
+  }
+  if (base.sphere)
+    throw new Error("Spherical transverse Mercator requires +approx");
+  return render({
+    ...bindKernel("etmerc", createState(base), forward, inverse, createFlatProjection)
+  });
+}
+var transverseMercator = {
+  name: "tmerc",
+  aliases: [
+    "Fast_Transverse_Mercator",
+    "Fast Transverse Mercator",
+    "Transverse_Mercator",
+    "Transverse Mercator",
+    "Gauss Kruger",
+    "Gauss_Kruger"
+  ],
+  parameters: [...ORIGIN_PARAMETERS, ...SCALE_PARAMETERS, "approx"],
+  flags: ["approx"],
+  create: createTransverseMercator
+};
+var extendedTransverseMercator = {
+  name: "etmerc",
+  aliases: ["Extended_Transverse_Mercator", "Extended Transverse Mercator"],
+  parameters: [...ORIGIN_PARAMETERS, ...SCALE_PARAMETERS, "approx"],
+  flags: ["approx"],
+  create: createTransverseMercator
+};
+//# sourceMappingURL=etmerc.cjs.map