ts-maps 0.2.7 → 0.3.1

package/dist/core-map/geo/index.js

@@ -0,0 +1,1204 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/core-map/core/Util.ts
+var exports_Util = {};
+__export(exports_Util, {
+  wrapNum: () => wrapNum,
+  throttle: () => throttle,
+  template: () => template,
+  stamp: () => stamp,
+  splitWords: () => splitWords,
+  setOptions: () => setOptions,
+  setLastId: () => setLastId,
+  noop: () => noop,
+  lastId: () => lastId,
+  formatNum: () => formatNum,
+  falseFn: () => falseFn
+});
+function stamp(obj) {
+  if (!("_tsmap_id" in obj)) {
+    obj._tsmap_id = ++lastId;
+  }
+  return obj._tsmap_id;
+}
+function setLastId(id) {
+  lastId = id;
+}
+function throttle(fn, time, context) {
+  let lock = false;
+  let queuedArgs = false;
+  function later() {
+    lock = false;
+    if (queuedArgs) {
+      wrapperFn.apply(context, queuedArgs);
+      queuedArgs = false;
+    }
+  }
+  function wrapperFn(...args) {
+    if (lock) {
+      queuedArgs = args;
+    } else {
+      fn.apply(context, args);
+      setTimeout(later, time);
+      lock = true;
+    }
+  }
+  return wrapperFn;
+}
+function wrapNum(x, range, includeMax) {
+  const max = range[1];
+  const min = range[0];
+  const d = max - min;
+  return x === max && includeMax ? x : ((x - min) % d + d) % d + min;
+}
+function falseFn(..._args) {
+  return false;
+}
+function formatNum(num, precision) {
+  if (precision === false)
+    return num;
+  const pow = 10 ** (precision === undefined ? 6 : precision);
+  return Math.round(num * pow) / pow;
+}
+function splitWords(str) {
+  return str.trim().split(/\s+/);
+}
+function setOptions(obj, options) {
+  if (!Object.hasOwn(obj, "options")) {
+    obj.options = obj.options ? Object.create(obj.options) : {};
+  }
+  if (options) {
+    for (const i in options) {
+      if (Object.hasOwn(options, i)) {
+        obj.options[i] = options[i];
+      }
+    }
+  }
+  return obj.options;
+}
+function template(str, data) {
+  return str.replace(templateRe, (match, key) => {
+    const k = key.trim();
+    let value = data[k];
+    if (value === undefined)
+      throw new Error(`No value provided for variable ${match}`);
+    else if (typeof value === "function")
+      value = value(data);
+    return value;
+  });
+}
+function noop() {}
+var lastId = 0, templateRe;
+var init_Util = __esm(() => {
+  templateRe = /\{([^{}]+)\}/g;
+});
+
+// src/core-map/geometry/Point.ts
+class Point {
+  x;
+  y;
+  constructor(x, y, round) {
+    const valid = Point.validate(x, y);
+    if (!valid) {
+      throw new Error(`Invalid Point object: (${x}, ${y})`);
+    }
+    let _x;
+    let _y;
+    if (x instanceof Point) {
+      return x;
+    } else if (Array.isArray(x)) {
+      _x = x[0];
+      _y = x[1];
+    } else if (typeof x === "object" && x !== null && "x" in x && "y" in x) {
+      _x = x.x;
+      _y = x.y;
+    } else {
+      _x = x;
+      _y = y;
+    }
+    this.x = round ? Math.round(_x) : _x;
+    this.y = round ? Math.round(_y) : _y;
+  }
+  static validate(x, y) {
+    if (x instanceof Point || Array.isArray(x))
+      return true;
+    if (x && typeof x === "object" && "x" in x && "y" in x)
+      return true;
+    if ((x || x === 0) && (y || y === 0))
+      return true;
+    return false;
+  }
+  clone() {
+    const p = new Point(0, 0);
+    p.x = this.x;
+    p.y = this.y;
+    return p;
+  }
+  add(point) {
+    return this.clone()._add(new Point(point));
+  }
+  _add(point) {
+    this.x += point.x;
+    this.y += point.y;
+    return this;
+  }
+  subtract(point) {
+    return this.clone()._subtract(new Point(point));
+  }
+  _subtract(point) {
+    this.x -= point.x;
+    this.y -= point.y;
+    return this;
+  }
+  divideBy(num) {
+    return this.clone()._divideBy(num);
+  }
+  _divideBy(num) {
+    this.x /= num;
+    this.y /= num;
+    return this;
+  }
+  multiplyBy(num) {
+    return this.clone()._multiplyBy(num);
+  }
+  _multiplyBy(num) {
+    this.x *= num;
+    this.y *= num;
+    return this;
+  }
+  scaleBy(point) {
+    return new Point(this.x * point.x, this.y * point.y);
+  }
+  unscaleBy(point) {
+    return new Point(this.x / point.x, this.y / point.y);
+  }
+  round() {
+    return this.clone()._round();
+  }
+  _round() {
+    this.x = Math.round(this.x);
+    this.y = Math.round(this.y);
+    return this;
+  }
+  floor() {
+    return this.clone()._floor();
+  }
+  _floor() {
+    this.x = Math.floor(this.x);
+    this.y = Math.floor(this.y);
+    return this;
+  }
+  ceil() {
+    return this.clone()._ceil();
+  }
+  _ceil() {
+    this.x = Math.ceil(this.x);
+    this.y = Math.ceil(this.y);
+    return this;
+  }
+  trunc() {
+    return this.clone()._trunc();
+  }
+  _trunc() {
+    this.x = Math.trunc(this.x);
+    this.y = Math.trunc(this.y);
+    return this;
+  }
+  distanceTo(point) {
+    const p = new Point(point);
+    const x = p.x - this.x;
+    const y = p.y - this.y;
+    return Math.sqrt(x * x + y * y);
+  }
+  equals(point) {
+    const p = new Point(point);
+    return p.x === this.x && p.y === this.y;
+  }
+  contains(point) {
+    const p = new Point(point);
+    return Math.abs(p.x) <= Math.abs(this.x) && Math.abs(p.y) <= Math.abs(this.y);
+  }
+  toString() {
+    return `Point(${formatNum(this.x)}, ${formatNum(this.y)})`;
+  }
+}
+function toPoint(x, y, round) {
+  if (x instanceof Point)
+    return x;
+  if (Array.isArray(x))
+    return new Point(x[0], x[1]);
+  if (x === undefined || x === null)
+    return x;
+  if (typeof x === "object" && "x" in x && "y" in x)
+    return new Point(x.x, x.y);
+  return new Point(x, y, round);
+}
+var init_Point = __esm(() => {
+  init_Util();
+});
+
+// src/core-map/geometry/Bounds.ts
+class Bounds {
+  min;
+  max;
+  constructor(a, b) {
+    if (!a)
+      return;
+    if (a instanceof Bounds) {
+      return a;
+    }
+    const points = b ? [a, b] : a;
+    for (const point of points) {
+      this.extend(point);
+    }
+  }
+  extend(obj) {
+    let min2;
+    let max2;
+    if (!obj)
+      return this;
+    if (obj instanceof Point || Array.isArray(obj) && typeof obj[0] === "number" || obj && "x" in obj) {
+      min2 = max2 = toPoint(obj);
+    } else {
+      const b = new Bounds(obj);
+      min2 = b.min;
+      max2 = b.max;
+      if (!min2 || !max2)
+        return this;
+    }
+    if (!this.min && !this.max) {
+      this.min = min2.clone();
+      this.max = max2.clone();
+    } else {
+      this.min.x = Math.min(min2.x, this.min.x);
+      this.max.x = Math.max(max2.x, this.max.x);
+      this.min.y = Math.min(min2.y, this.min.y);
+      this.max.y = Math.max(max2.y, this.max.y);
+    }
+    return this;
+  }
+  getCenter(round) {
+    return new Point((this.min.x + this.max.x) / 2, (this.min.y + this.max.y) / 2, round);
+  }
+  getBottomLeft() {
+    return new Point(this.min.x, this.max.y);
+  }
+  getTopRight() {
+    return new Point(this.max.x, this.min.y);
+  }
+  getTopLeft() {
+    return this.min;
+  }
+  getBottomRight() {
+    return this.max;
+  }
+  getSize() {
+    return this.max.subtract(this.min);
+  }
+  contains(obj) {
+    let min, max;
+    let target = obj;
+    if (Array.isArray(target) && typeof target[0] === "number" || target instanceof Point) {
+      target = toPoint(target);
+    } else {
+      target = new Bounds(target);
+    }
+    if (target instanceof Bounds) {
+      min = target.min;
+      max = target.max;
+    } else {
+      min = max = target;
+    }
+    return min.x >= this.min.x && max.x <= this.max.x && min.y >= this.min.y && max.y <= this.max.y;
+  }
+  intersects(bounds) {
+    const b = new Bounds(bounds);
+    const min = this.min;
+    const max = this.max;
+    const min2 = b.min;
+    const max2 = b.max;
+    const xIntersects = max2.x >= min.x && min2.x <= max.x;
+    const yIntersects = max2.y >= min.y && min2.y <= max.y;
+    return xIntersects && yIntersects;
+  }
+  overlaps(bounds) {
+    const b = new Bounds(bounds);
+    const min = this.min;
+    const max = this.max;
+    const min2 = b.min;
+    const max2 = b.max;
+    const xOverlaps = max2.x > min.x && min2.x < max.x;
+    const yOverlaps = max2.y > min.y && min2.y < max.y;
+    return xOverlaps && yOverlaps;
+  }
+  isValid() {
+    return !!(this.min && this.max);
+  }
+  pad(bufferRatio) {
+    const min = this.min;
+    const max = this.max;
+    const heightBuffer = Math.abs(min.x - max.x) * bufferRatio;
+    const widthBuffer = Math.abs(min.y - max.y) * bufferRatio;
+    return new Bounds(new Point(min.x - heightBuffer, min.y - widthBuffer), new Point(max.x + heightBuffer, max.y + widthBuffer));
+  }
+  equals(bounds) {
+    if (!bounds)
+      return false;
+    const b = new Bounds(bounds);
+    return this.min.equals(b.getTopLeft()) && this.max.equals(b.getBottomRight());
+  }
+}
+function toBounds(a, b) {
+  if (!a || a instanceof Bounds)
+    return a;
+  return new Bounds(a, b);
+}
+var init_Bounds = __esm(() => {
+  init_Point();
+});
+
+// src/core-map/geo/LatLngBounds.ts
+class LatLngBounds {
+  _southWest;
+  _northEast;
+  constructor(corner1, corner2) {
+    if (!corner1)
+      return;
+    if (corner1 instanceof LatLngBounds) {
+      return corner1;
+    }
+    const latlngs = corner2 ? [corner1, corner2] : corner1;
+    for (const latlng of latlngs)
+      this.extend(latlng);
+  }
+  extend(obj) {
+    const sw = this._southWest;
+    const ne = this._northEast;
+    let sw2, ne2;
+    if (obj instanceof LatLng) {
+      sw2 = obj;
+      ne2 = obj;
+    } else if (obj instanceof LatLngBounds) {
+      sw2 = obj._southWest;
+      ne2 = obj._northEast;
+      if (!sw2 || !ne2)
+        return this;
+    } else {
+      if (!obj)
+        return this;
+      if (LatLng.validate(obj))
+        return this.extend(new LatLng(obj));
+      return this.extend(new LatLngBounds(obj));
+    }
+    if (!sw && !ne) {
+      this._southWest = new LatLng(sw2.lat, sw2.lng);
+      this._northEast = new LatLng(ne2.lat, ne2.lng);
+    } else {
+      sw.lat = Math.min(sw2.lat, sw.lat);
+      sw.lng = Math.min(sw2.lng, sw.lng);
+      ne.lat = Math.max(ne2.lat, ne.lat);
+      ne.lng = Math.max(ne2.lng, ne.lng);
+    }
+    return this;
+  }
+  pad(bufferRatio) {
+    const sw = this._southWest;
+    const ne = this._northEast;
+    const heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio;
+    const widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
+    return new LatLngBounds(new LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer), new LatLng(ne.lat + heightBuffer, ne.lng + widthBuffer));
+  }
+  getCenter() {
+    return new LatLng((this._southWest.lat + this._northEast.lat) / 2, (this._southWest.lng + this._northEast.lng) / 2);
+  }
+  getSouthWest() {
+    return this._southWest;
+  }
+  getNorthEast() {
+    return this._northEast;
+  }
+  getNorthWest() {
+    return new LatLng(this.getNorth(), this.getWest());
+  }
+  getSouthEast() {
+    return new LatLng(this.getSouth(), this.getEast());
+  }
+  getWest() {
+    return this._southWest.lng;
+  }
+  getSouth() {
+    return this._southWest.lat;
+  }
+  getEast() {
+    return this._northEast.lng;
+  }
+  getNorth() {
+    return this._northEast.lat;
+  }
+  contains(obj) {
+    let target = obj;
+    if (LatLng.validate(target))
+      target = new LatLng(target);
+    else
+      target = new LatLngBounds(target);
+    const sw = this._southWest;
+    const ne = this._northEast;
+    let sw2, ne2;
+    if (target instanceof LatLngBounds) {
+      sw2 = target.getSouthWest();
+      ne2 = target.getNorthEast();
+    } else {
+      sw2 = ne2 = target;
+    }
+    return sw2.lat >= sw.lat && ne2.lat <= ne.lat && sw2.lng >= sw.lng && ne2.lng <= ne.lng;
+  }
+  intersects(bounds) {
+    const b = new LatLngBounds(bounds);
+    const sw = this._southWest;
+    const ne = this._northEast;
+    const sw2 = b.getSouthWest();
+    const ne2 = b.getNorthEast();
+    const latIntersects = ne2.lat >= sw.lat && sw2.lat <= ne.lat;
+    const lngIntersects = ne2.lng >= sw.lng && sw2.lng <= ne.lng;
+    return latIntersects && lngIntersects;
+  }
+  overlaps(bounds) {
+    const b = new LatLngBounds(bounds);
+    const sw = this._southWest;
+    const ne = this._northEast;
+    const sw2 = b.getSouthWest();
+    const ne2 = b.getNorthEast();
+    const latOverlaps = ne2.lat > sw.lat && sw2.lat < ne.lat;
+    const lngOverlaps = ne2.lng > sw.lng && sw2.lng < ne.lng;
+    return latOverlaps && lngOverlaps;
+  }
+  toBBoxString() {
+    return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(",");
+  }
+  equals(bounds, maxMargin) {
+    if (!bounds)
+      return false;
+    const b = new LatLngBounds(bounds);
+    return this._southWest.equals(b.getSouthWest(), maxMargin) && this._northEast.equals(b.getNorthEast(), maxMargin);
+  }
+  isValid() {
+    return !!(this._southWest && this._northEast);
+  }
+}
+function toLatLngBounds(a, b) {
+  if (a instanceof LatLngBounds)
+    return a;
+  return new LatLngBounds(a, b);
+}
+var init_LatLngBounds = __esm(() => {
+  init_LatLng();
+});
+
+// src/core-map/geo/crs/CRS.ts
+class CRS {
+  static projection = undefined;
+  static transformation = undefined;
+  static code;
+  static wrapLng;
+  static wrapLat;
+  static infinite = false;
+  static latLngToPoint(latlng, zoom) {
+    const projectedPoint = this.projection.project(latlng);
+    const scale = this.scale(zoom);
+    return this.transformation._transform(projectedPoint, scale);
+  }
+  static pointToLatLng(point, zoom) {
+    const scale = this.scale(zoom);
+    const untransformedPoint = this.transformation.untransform(point, scale);
+    return this.projection.unproject(untransformedPoint);
+  }
+  static project(latlng) {
+    return this.projection.project(latlng);
+  }
+  static unproject(point) {
+    return this.projection.unproject(point);
+  }
+  static scale(zoom) {
+    return 256 * 2 ** zoom;
+  }
+  static zoom(scale) {
+    return Math.log(scale / 256) / Math.LN2;
+  }
+  static getProjectedBounds(zoom) {
+    if (this.infinite)
+      return null;
+    const b = this.projection.bounds;
+    const s = this.scale(zoom);
+    const min = this.transformation.transform(b.min, s);
+    const max = this.transformation.transform(b.max, s);
+    return new Bounds(min, max);
+  }
+  static distance(_a, _b) {
+    return 0;
+  }
+  static wrapLatLng(latlng) {
+    const ll = new LatLng(latlng);
+    const lng = this.wrapLng ? wrapNum(ll.lng, this.wrapLng, true) : ll.lng;
+    const lat = this.wrapLat ? wrapNum(ll.lat, this.wrapLat, true) : ll.lat;
+    const alt = ll.alt;
+    return new LatLng(lat, lng, alt);
+  }
+  static wrapLatLngBounds(bounds) {
+    const b = new LatLngBounds(bounds);
+    const center = b.getCenter();
+    const newCenter = this.wrapLatLng(center);
+    const latShift = center.lat - newCenter.lat;
+    const lngShift = center.lng - newCenter.lng;
+    if (latShift === 0 && lngShift === 0)
+      return b;
+    const sw = b.getSouthWest();
+    const ne = b.getNorthEast();
+    const newSw = new LatLng(sw.lat - latShift, sw.lng - lngShift);
+    const newNe = new LatLng(ne.lat - latShift, ne.lng - lngShift);
+    return new LatLngBounds(newSw, newNe);
+  }
+}
+var init_CRS = __esm(() => {
+  init_Util();
+  init_Bounds();
+  init_LatLng();
+  init_LatLngBounds();
+});
+
+// src/core-map/geo/crs/EarthCRS.ts
+var EarthCRS;
+var init_EarthCRS = __esm(() => {
+  init_CRS();
+  EarthCRS = class EarthCRS extends CRS {
+    static wrapLng = [-180, 180];
+    static R = 6371000;
+    static distance(latlng1, latlng2) {
+      const rad = Math.PI / 180;
+      const lat1 = latlng1.lat * rad;
+      const lat2 = latlng2.lat * rad;
+      const sinDLat = Math.sin((latlng2.lat - latlng1.lat) * rad / 2);
+      const sinDLon = Math.sin((latlng2.lng - latlng1.lng) * rad / 2);
+      const a = sinDLat * sinDLat + Math.cos(lat1) * Math.cos(lat2) * sinDLon * sinDLon;
+      const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+      return this.R * c;
+    }
+  };
+});
+
+// src/core-map/geo/LatLng.ts
+class LatLng {
+  lat;
+  lng;
+  alt;
+  constructor(lat, lng, alt) {
+    const valid = LatLng.validate(lat, lng, alt);
+    if (!valid)
+      throw new Error(`Invalid LatLng object: (${lat}, ${lng})`);
+    let _lat, _lng, _alt;
+    if (lat instanceof LatLng) {
+      return lat;
+    } else if (Array.isArray(lat) && typeof lat[0] !== "object") {
+      if (lat.length === 3) {
+        _lat = lat[0];
+        _lng = lat[1];
+        _alt = lat[2];
+      } else {
+        _lat = lat[0];
+        _lng = lat[1];
+      }
+    } else if (typeof lat === "object" && lat !== null && "lat" in lat) {
+      const o = lat;
+      _lat = o.lat;
+      _lng = "lng" in o ? o.lng : o.lon;
+      _alt = o.alt;
+    } else {
+      _lat = lat;
+      _lng = lng;
+      _alt = alt;
+    }
+    this.lat = +_lat;
+    this.lng = +_lng;
+    if (_alt !== undefined)
+      this.alt = +_alt;
+  }
+  static validate(lat, lng, _alt) {
+    if (lat instanceof LatLng || typeof lat === "object" && lat !== null && "lat" in lat)
+      return true;
+    if (lat && Array.isArray(lat) && typeof lat[0] !== "object") {
+      if (lat.length === 3 || lat.length === 2)
+        return true;
+      return false;
+    }
+    if ((lat || lat === 0) && (lng || lng === 0))
+      return true;
+    return false;
+  }
+  equals(obj, maxMargin) {
+    if (!obj)
+      return false;
+    const other = new LatLng(obj);
+    const margin = Math.max(Math.abs(this.lat - other.lat), Math.abs(this.lng - other.lng));
+    return margin <= (maxMargin ?? 0.000000001);
+  }
+  toString(precision) {
+    return `LatLng(${formatNum(this.lat, precision)}, ${formatNum(this.lng, precision)})`;
+  }
+  distanceTo(other) {
+    return EarthCRS.distance(this, new LatLng(other));
+  }
+  wrap() {
+    return EarthCRS.wrapLatLng(this);
+  }
+  toBounds(sizeInMeters) {
+    const latAccuracy = 180 * sizeInMeters / 40075017;
+    const lngAccuracy = latAccuracy / Math.cos(Math.PI / 180 * this.lat);
+    return new LatLngBounds([this.lat - latAccuracy, this.lng - lngAccuracy], [this.lat + latAccuracy, this.lng + lngAccuracy]);
+  }
+  clone() {
+    const latlng = new LatLng(0, 0);
+    latlng.lat = this.lat;
+    latlng.lng = this.lng;
+    latlng.alt = this.alt;
+    return latlng;
+  }
+}
+function toLatLng(a, b, c) {
+  if (a instanceof LatLng)
+    return a;
+  if (a === null || a === undefined)
+    return a;
+  return new LatLng(a, b, c);
+}
+var init_LatLng = __esm(() => {
+  init_Util();
+  init_EarthCRS();
+  init_LatLngBounds();
+});
+
+// src/core-map/geo/elevation.ts
+function decodeMapboxRGB(r, g, b) {
+  return -1e4 + (r * 65536 + g * 256 + b) * 0.1;
+}
+function decodeTerrariumRGB(r, g, b) {
+  return r * 256 + g + b / 256 - 32768;
+}
+function getElevationDecoder(encoding) {
+  return encoding === "terrarium" ? decodeTerrariumRGB : decodeMapboxRGB;
+}
+function decodeElevationGrid(pixels, encoding = "mapbox") {
+  const n = pixels.length / 4 | 0;
+  const elev = new Float32Array(n);
+  const decode = getElevationDecoder(encoding);
+  for (let i = 0, p = 0;i < n; i++, p += 4)
+    elev[i] = decode(pixels[p], pixels[p + 1], pixels[p + 2]);
+  return elev;
+}
+function sampleElevationBilinear(elev, size, u, v) {
+  const cu = clamp(u, 0, size - 1);
+  const cv = clamp(v, 0, size - 1);
+  const x0 = Math.floor(cu);
+  const y0 = Math.floor(cv);
+  const x1 = Math.min(size - 1, x0 + 1);
+  const y1 = Math.min(size - 1, y0 + 1);
+  const fx = cu - x0;
+  const fy = cv - y0;
+  const e00 = elev[y0 * size + x0];
+  const e10 = elev[y0 * size + x1];
+  const e01 = elev[y1 * size + x0];
+  const e11 = elev[y1 * size + x1];
+  const a = e00 * (1 - fx) + e10 * fx;
+  const b = e01 * (1 - fx) + e11 * fx;
+  return a * (1 - fy) + b * fy;
+}
+function clamp(v, lo, hi) {
+  return v < lo ? lo : v > hi ? hi : v;
+}
+
+// src/core-map/geo/terrainMesh.ts
+function buildTerrainMesh(opts) {
+  const demSize = opts.demSize;
+  if (demSize < 2)
+    throw new RangeError("demSize must be >= 2");
+  if (opts.elevation.length < demSize * demSize)
+    throw new RangeError(`elevation array is too small for demSize=${demSize}`);
+  const tileSize = opts.tileSize ?? demSize;
+  const resolution = Math.max(1, Math.floor(opts.resolution ?? 32));
+  const exaggeration = opts.exaggeration ?? 1;
+  const upm = opts.unitsPerMeter ?? 1;
+  const verticesPerSide = resolution + 1;
+  const vertexCount = verticesPerSide * verticesPerSide;
+  const positions = new Float32Array(vertexCount * 6);
+  const step = tileSize / resolution;
+  const demStep = (demSize - 1) / resolution;
+  for (let j = 0;j < verticesPerSide; j++) {
+    const y = j * step;
+    const dv = j * demStep;
+    for (let i = 0;i < verticesPerSide; i++) {
+      const x = i * step;
+      const du = i * demStep;
+      const metres = sampleElevationBilinear(opts.elevation, demSize, du, dv);
+      const z = metres * exaggeration * upm;
+      const vi = (j * verticesPerSide + i) * 6;
+      positions[vi] = x;
+      positions[vi + 1] = y;
+      positions[vi + 2] = z;
+      positions[vi + 3] = 0;
+      positions[vi + 4] = 0;
+      positions[vi + 5] = 1;
+    }
+  }
+  for (let j = 0;j < verticesPerSide; j++) {
+    for (let i = 0;i < verticesPerSide; i++) {
+      const im = Math.max(0, i - 1);
+      const ip = Math.min(verticesPerSide - 1, i + 1);
+      const jm = Math.max(0, j - 1);
+      const jp = Math.min(verticesPerSide - 1, j + 1);
+      const zL = positions[(j * verticesPerSide + im) * 6 + 2];
+      const zR = positions[(j * verticesPerSide + ip) * 6 + 2];
+      const zU = positions[(jm * verticesPerSide + i) * 6 + 2];
+      const zD = positions[(jp * verticesPerSide + i) * 6 + 2];
+      const dx = (ip - im) * step || 1;
+      const dy = (jp - jm) * step || 1;
+      const nx = -(zR - zL) / dx;
+      const ny = -(zD - zU) / dy;
+      const nz = 1;
+      const len = Math.hypot(nx, ny, nz) || 1;
+      const base = (j * verticesPerSide + i) * 6;
+      positions[base + 3] = nx / len;
+      positions[base + 4] = ny / len;
+      positions[base + 5] = nz / len;
+    }
+  }
+  const indices = new Uint32Array(resolution * resolution * 6);
+  let idx = 0;
+  for (let j = 0;j < resolution; j++) {
+    for (let i = 0;i < resolution; i++) {
+      const a = j * verticesPerSide + i;
+      const b = a + 1;
+      const c = a + verticesPerSide;
+      const d = c + 1;
+      indices[idx++] = a;
+      indices[idx++] = c;
+      indices[idx++] = b;
+      indices[idx++] = b;
+      indices[idx++] = c;
+      indices[idx++] = d;
+    }
+  }
+  return {
+    positions,
+    indices,
+    vertexCount,
+    indexCount: indices.length,
+    resolution
+  };
+}
+var init_terrainMesh = () => {};
+
+// src/core-map/geo/TerrainSource.ts
+class TerrainSource {
+  constructor(opts) {
+    this._tiles = new Map;
+    this._opts = {
+      demSize: opts?.demSize ?? 256,
+      encoding: opts?.encoding ?? "mapbox",
+      meshResolution: opts?.meshResolution ?? 32,
+      exaggeration: opts?.exaggeration ?? 1
+    };
+  }
+  get demSize() {
+    return this._opts.demSize;
+  }
+  get encoding() {
+    return this._opts.encoding;
+  }
+  get meshResolution() {
+    return this._opts.meshResolution;
+  }
+  get exaggeration() {
+    return this._opts.exaggeration;
+  }
+  setExaggeration(v) {
+    if (!Number.isFinite(v))
+      throw new RangeError("exaggeration must be a finite number");
+    this._opts.exaggeration = v;
+  }
+  addTilePixels(coord, pixels) {
+    const expected = this._opts.demSize * this._opts.demSize * 4;
+    if (pixels.length < expected)
+      throw new RangeError(`pixel buffer too small: got ${pixels.length}, need ${expected}`);
+    this._tiles.set(key(coord), decodeElevationGrid(pixels, this._opts.encoding));
+  }
+  addTileElevation(coord, elevation) {
+    const expected = this._opts.demSize * this._opts.demSize;
+    if (elevation.length < expected)
+      throw new RangeError(`elevation grid too small: got ${elevation.length}, need ${expected}`);
+    this._tiles.set(key(coord), elevation);
+  }
+  hasTile(coord) {
+    return this._tiles.has(key(coord));
+  }
+  getTile(coord) {
+    return this._tiles.get(key(coord));
+  }
+  deleteTile(coord) {
+    this._tiles.delete(key(coord));
+  }
+  clear() {
+    this._tiles.clear();
+  }
+  size() {
+    return this._tiles.size;
+  }
+  queryElevation(lng, lat, preferredZoom) {
+    const latC = clamp2(lat, -85.05112878, 85.05112878);
+    const startZ = Math.max(0, Math.floor(preferredZoom));
+    for (let z = startZ;z >= 0; z--) {
+      const tx = lngToTileX(lng, z);
+      const ty = latToTileY(latC, z);
+      const tile = this._tiles.get(key({ z, x: tx, y: ty }));
+      if (!tile)
+        continue;
+      const pxX = lngToPixel(lng, z) - tx * this._opts.demSize;
+      const pxY = latToPixel(latC, z) - ty * this._opts.demSize;
+      return sampleElevationBilinear(tile, this._opts.demSize, pxX, pxY);
+    }
+    return null;
+  }
+}
+function key(c) {
+  return `${c.z}/${c.x}/${c.y}`;
+}
+function clamp2(v, lo, hi) {
+  return v < lo ? lo : v > hi ? hi : v;
+}
+function lngToTileX(lng, z) {
+  return Math.floor((lng + 180) / 360 * 2 ** z);
+}
+function latToTileY(lat, z) {
+  const rad = lat * Math.PI / 180;
+  return Math.floor((1 - Math.log(Math.tan(rad) + 1 / Math.cos(rad)) / Math.PI) / 2 * 2 ** z);
+}
+function lngToPixel(lng, z) {
+  return (lng + 180) / 360 * 2 ** z * 256;
+}
+function latToPixel(lat, z) {
+  const rad = lat * Math.PI / 180;
+  return (1 - Math.log(Math.tan(rad) + 1 / Math.cos(rad)) / Math.PI) / 2 * 2 ** z * 256;
+}
+var init_TerrainSource = () => {};
+
+// src/core-map/geo/projection/Projection.SphericalMercator.ts
+var earthRadius = 6378137, SphericalMercator;
+var init_Projection_SphericalMercator = __esm(() => {
+  init_Bounds();
+  init_Point();
+  init_LatLng();
+  SphericalMercator = {
+    R: earthRadius,
+    MAX_LATITUDE: 85.0511287798,
+    project(latlng) {
+      const ll = new LatLng(latlng);
+      const d = Math.PI / 180;
+      const max = this.MAX_LATITUDE;
+      const lat = Math.max(Math.min(max, ll.lat), -max);
+      const sin = Math.sin(lat * d);
+      return new Point(this.R * ll.lng * d, this.R * Math.log((1 + sin) / (1 - sin)) / 2);
+    },
+    unproject(point) {
+      const p = new Point(point);
+      const d = 180 / Math.PI;
+      return new LatLng((2 * Math.atan(Math.exp(p.y / this.R)) - Math.PI / 2) * d, p.x * d / this.R);
+    },
+    bounds: (() => {
+      const d = earthRadius * Math.PI;
+      return new Bounds([-d, -d], [d, d]);
+    })()
+  };
+});
+
+// src/core-map/geometry/Transformation.ts
+class Transformation {
+  _a;
+  _b;
+  _c;
+  _d;
+  constructor(a, b, c, d) {
+    if (Array.isArray(a)) {
+      this._a = a[0];
+      this._b = a[1];
+      this._c = a[2];
+      this._d = a[3];
+      return;
+    }
+    this._a = a;
+    this._b = b;
+    this._c = c;
+    this._d = d;
+  }
+  transform(point, scale) {
+    return this._transform(point.clone(), scale);
+  }
+  _transform(point, scale) {
+    scale ||= 1;
+    point.x = scale * (this._a * point.x + this._b);
+    point.y = scale * (this._c * point.y + this._d);
+    return point;
+  }
+  untransform(point, scale) {
+    scale ||= 1;
+    return new Point((point.x / scale - this._b) / this._a, (point.y / scale - this._d) / this._c);
+  }
+}
+function toTransformation(a, b, c, d) {
+  return new Transformation(a, b, c, d);
+}
+var init_Transformation = __esm(() => {
+  init_Point();
+});
+
+// src/core-map/geo/crs/EPSG3857.ts
+var EPSG3857, EPSG900913;
+var init_EPSG3857 = __esm(() => {
+  init_Transformation();
+  init_Projection_SphericalMercator();
+  init_EarthCRS();
+  EPSG3857 = class EPSG3857 extends EarthCRS {
+    static code = "EPSG:3857";
+    static projection = SphericalMercator;
+    static transformation = (() => {
+      const scale = 0.5 / (Math.PI * SphericalMercator.R);
+      return new Transformation(scale, 0.5, -scale, 0.5);
+    })();
+  };
+  EPSG900913 = class EPSG900913 extends EPSG3857 {
+    static code = "EPSG:900913";
+  };
+});
+
+// src/core-map/geo/index.ts
+init_LatLng();
+init_LatLngBounds();
+init_terrainMesh();
+init_TerrainSource();
+
+// src/core-map/geo/projection/index.ts
+var exports_projection = {};
+__export(exports_projection, {
+  SphericalMercator: () => SphericalMercator,
+  Mercator: () => Mercator,
+  LonLat: () => LonLat,
+  Globe: () => Globe
+});
+
+// src/core-map/geo/projection/Projection.Globe.ts
+init_LatLng();
+init_Projection_SphericalMercator();
+var earthRadius2 = SphericalMercator.R;
+function latLngToUnitSphere(latlng) {
+  const ll = new LatLng(latlng);
+  const phi = ll.lat * Math.PI / 180;
+  const lambda = ll.lng * Math.PI / 180;
+  const cosPhi = Math.cos(phi);
+  return {
+    x: cosPhi * Math.sin(lambda),
+    y: Math.sin(phi),
+    z: cosPhi * Math.cos(lambda)
+  };
+}
+function unitSphereToLatLng(v) {
+  const r = Math.hypot(v.x, v.y, v.z) || 1;
+  const phi = Math.asin(Math.max(-1, Math.min(1, v.y / r)));
+  const lambda = Math.atan2(v.x, v.z);
+  return new LatLng(phi * 180 / Math.PI, lambda * 180 / Math.PI);
+}
+function globeMix(zoom, start, end) {
+  if (zoom <= start)
+    return 1;
+  if (zoom >= end)
+    return 0;
+  const t = (zoom - start) / (end - start);
+  return 1 - t * t * (3 - 2 * t);
+}
+var Globe = {
+  R: earthRadius2,
+  GLOBE_START_ZOOM: 5.5,
+  GLOBE_END_ZOOM: 6,
+  project(latlng) {
+    return SphericalMercator.project(latlng);
+  },
+  unproject(point) {
+    return SphericalMercator.unproject(point);
+  },
+  bounds: SphericalMercator.bounds,
+  toSphere: latLngToUnitSphere,
+  fromSphere: unitSphereToLatLng,
+  globeToMercatorMix(zoom) {
+    return globeMix(zoom, this.GLOBE_START_ZOOM, this.GLOBE_END_ZOOM);
+  }
+};
+// src/core-map/geo/projection/Projection.LonLat.ts
+init_Bounds();
+init_Point();
+init_LatLng();
+var LonLat = {
+  project(latlng) {
+    const ll = new LatLng(latlng);
+    return new Point(ll.lng, ll.lat);
+  },
+  unproject(point) {
+    const p = new Point(point);
+    return new LatLng(p.y, p.x);
+  },
+  bounds: new Bounds([-180, -90], [180, 90])
+};
+// src/core-map/geo/projection/Projection.Mercator.ts
+init_Bounds();
+init_Point();
+init_LatLng();
+var earthRadius3 = 6378137;
+var Mercator = {
+  R: earthRadius3,
+  R_MINOR: 6356752.314245179,
+  bounds: new Bounds([-20037508.34279, -15496570.73972], [20037508.34279, 18764656.23138]),
+  project(latlng) {
+    const ll = new LatLng(latlng);
+    const d = Math.PI / 180;
+    const r = this.R;
+    const tmp = this.R_MINOR / r;
+    const e = Math.sqrt(1 - tmp * tmp);
+    let y = ll.lat * d;
+    const con = e * Math.sin(y);
+    const ts = Math.tan(Math.PI / 4 - y / 2) / ((1 - con) / (1 + con)) ** (e / 2);
+    y = -r * Math.log(Math.max(ts, 0.0000000001));
+    return new Point(ll.lng * d * r, y);
+  },
+  unproject(point) {
+    const p = new Point(point);
+    const d = 180 / Math.PI;
+    const r = this.R;
+    const tmp = this.R_MINOR / r;
+    const e = Math.sqrt(1 - tmp * tmp);
+    const ts = Math.exp(-p.y / r);
+    let phi = Math.PI / 2 - 2 * Math.atan(ts);
+    let dphi = 0.1;
+    for (let i = 0;i < 15 && Math.abs(dphi) > 0.0000001; i++) {
+      let con = e * Math.sin(phi);
+      con = ((1 - con) / (1 + con)) ** (e / 2);
+      dphi = Math.PI / 2 - 2 * Math.atan(ts * con) - phi;
+      phi += dphi;
+    }
+    return new LatLng(phi * d, p.x * d / r);
+  }
+};
+
+// src/core-map/geo/projection/index.ts
+init_Projection_SphericalMercator();
+
+// src/core-map/geo/crs/index.ts
+init_CRS();
+init_EarthCRS();
+
+// src/core-map/geo/crs/EPSG3395.ts
+init_Transformation();
+init_EarthCRS();
+
+class EPSG3395 extends EarthCRS {
+  static code = "EPSG:3395";
+  static projection = Mercator;
+  static transformation = (() => {
+    const scale = 0.5 / (Math.PI * Mercator.R);
+    return new Transformation(scale, 0.5, -scale, 0.5);
+  })();
+}
+
+// src/core-map/geo/crs/index.ts
+init_EPSG3857();
+
+// src/core-map/geo/crs/EPSG4326.ts
+init_Transformation();
+init_EarthCRS();
+
+class EPSG4326 extends EarthCRS {
+  static code = "EPSG:4326";
+  static projection = LonLat;
+  static transformation = new Transformation(1 / 180, 1, -1 / 180, 0.5);
+}
+// src/core-map/geo/crs/SimpleCRS.ts
+init_Transformation();
+init_CRS();
+
+class SimpleCRS extends CRS {
+  static projection = LonLat;
+  static transformation = new Transformation(1, 0, -1, 0);
+  static infinite = true;
+  static scale(zoom) {
+    return 2 ** zoom;
+  }
+  static zoom(scale) {
+    return Math.log(scale) / Math.LN2;
+  }
+  static distance(latlng1, latlng2) {
+    const dx = latlng2.lng - latlng1.lng;
+    const dy = latlng2.lat - latlng1.lat;
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+}
+export {
+  toLatLngBounds,
+  toLatLng,
+  sampleElevationBilinear,
+  getElevationDecoder,
+  decodeTerrariumRGB,
+  decodeMapboxRGB,
+  decodeElevationGrid,
+  buildTerrainMesh,
+  TerrainSource,
+  SimpleCRS,
+  exports_projection as Projection,
+  LatLngBounds,
+  LatLng,
+  EarthCRS,
+  EPSG900913,
+  EPSG4326,
+  EPSG3857,
+  EPSG3395,
+  CRS
+};