three-geo-play 1.0.1 → 1.1.0

package/dist/index.js

@@ -1,9 +1,14 @@
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __commonJS = (cb, mod2) => function __require() {
   return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
 };
@@ -28,6 +33,20 @@ var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__
   mod2
 ));
 var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
 
 // ../../node_modules/@protobufjs/aspromise/index.js
 var require_aspromise = __commonJS({
@@ -5447,709 +5466,1081 @@ module.exports = __toCommonJS(index_exports);
 
 // src/style/BuildingLayer.js
 var THREE = __toESM(require("three"));
+var _material, _YOrder, _height, _allowDetails, _isVisible, _BuildingLayer_instances, validateAndWrapMaterial_fn;
 var BuildingLayer = class {
-  #material;
-  #YOrder;
-  #height;
-  #allowDetails;
-  #isVisible = true;
-  #minHeight = 0;
-  #maxHeight = Infinity;
-  #fixToMinHeight = false;
-  constructor(material = null, YOrder = 0.03, minHeight = 0, maxHeight = Infinity, fixToMinHeight = false) {
-    this.#YOrder = YOrder;
-    this.#height = 1e-3;
-    this.#allowDetails = false;
-    this.#minHeight = minHeight;
-    this.#maxHeight = maxHeight;
-    this.#fixToMinHeight = fixToMinHeight;
-    this.#material = this.#validateAndWrapMaterial(material);
+  /**
+   * @param {THREE.Material|null} [material=null] - Material for building faces. Falls back to a default yellow material if invalid.
+   * @param {number} [YOrder=0.03] - Y-axis render order offset.
+   */
+  constructor(material = null, YOrder = 0.03) {
+    __privateAdd(this, _BuildingLayer_instances);
+    /** @type {THREE.Material} */
+    __privateAdd(this, _material);
+    /** @type {number} */
+    __privateAdd(this, _YOrder);
+    /** @type {number} */
+    __privateAdd(this, _height);
+    /** @type {boolean} */
+    __privateAdd(this, _allowDetails);
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible, true);
+    __privateSet(this, _YOrder, YOrder);
+    __privateSet(this, _height, 1e-3);
+    __privateSet(this, _allowDetails, false);
+    __privateSet(this, _material, __privateMethod(this, _BuildingLayer_instances, validateAndWrapMaterial_fn).call(this, material));
   }
+  /**
+   * Whether this layer is rendered.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible);
   }
   set isVisible(value) {
-    this.#isVisible = !!value;
+    __privateSet(this, _isVisible, !!value);
   }
+  /**
+   * The Three.js material applied to building geometry.
+   * Must be a valid {@link THREE.Material}; otherwise a default material is used.
+   * @type {THREE.Material}
+   */
   get material() {
-    return this.#material;
+    return __privateGet(this, _material);
   }
   set material(value) {
-    this.#material = this.#validateAndWrapMaterial(value);
+    __privateSet(this, _material, __privateMethod(this, _BuildingLayer_instances, validateAndWrapMaterial_fn).call(this, value));
   }
+  /**
+   * Y-axis render order offset. Higher values render on top of lower ones.
+   * @type {number}
+   */
   get YOrder() {
-    return this.#YOrder;
+    return __privateGet(this, _YOrder);
   }
   set YOrder(value) {
-    this.#YOrder = value;
+    __privateSet(this, _YOrder, value);
   }
+  /**
+   * Base extrusion height multiplier for buildings without OSM height data.
+   * @type {number}
+   */
   get height() {
-    return this.#height;
+    return __privateGet(this, _height);
   }
   set height(value) {
-    this.#height = value;
+    __privateSet(this, _height, value);
   }
+  /**
+   * If true, enables finer building detail (e.g. roof shapes) when available in tile data.
+   * @type {boolean}
+   */
   get allowDetails() {
-    return this.#allowDetails;
+    return __privateGet(this, _allowDetails);
   }
   set allowDetails(value) {
-    this.#allowDetails = !!value;
+    __privateSet(this, _allowDetails, !!value);
   }
+  /**
+   * Returns this instance regardless of name (BuildingLayer has a single type).
+   * @param {string} _name - Unused.
+   * @returns {BuildingLayer} This instance.
+   */
   getTypeByName(_name) {
     return this;
   }
+  /**
+   * Sets the material and returns this instance for chaining.
+   * @param {THREE.Material} material
+   * @returns {BuildingLayer}
+   */
   setMaterial(material) {
     this.material = material;
     return this;
   }
+  /**
+   * Sets the Y render order and returns this instance for chaining.
+   * @param {number} y
+   * @returns {BuildingLayer}
+   */
   setYOrder(y) {
     this.YOrder = y;
     return this;
   }
+  /**
+   * Sets the base extrusion height and returns this instance for chaining.
+   * @param {number} h
+   * @returns {BuildingLayer}
+   */
   setHeight(h) {
     this.height = h;
     return this;
   }
+  /**
+   * Enables or disables detail rendering and returns this instance for chaining.
+   * @param {boolean} val
+   * @returns {BuildingLayer}
+   */
   setAllowDetails(val) {
     this.allowDetails = val;
     return this;
   }
-  #validateAndWrapMaterial(material) {
-    if (!material || !(material instanceof THREE.Material)) {
-      if (material) {
-        console.warn("ThreeGeoPlay: Invalid material, using default. It must be a valid THREE.Material");
-      }
-      return new THREE.MeshBasicMaterial({
-        color: 16774307,
-        transparent: true,
-        opacity: 0.5,
-        side: THREE.FrontSide,
-        depthWrite: false
-      });
-    }
-    return material;
+};
+_material = new WeakMap();
+_YOrder = new WeakMap();
+_height = new WeakMap();
+_allowDetails = new WeakMap();
+_isVisible = new WeakMap();
+_BuildingLayer_instances = new WeakSet();
+/**
+ * @param {THREE.Material|null} material
+ * @returns {THREE.Material}
+ * @private
+ */
+validateAndWrapMaterial_fn = function(material) {
+  if (!material || !(material instanceof THREE.Material)) {
+    if (material) {
+      console.warn("ThreeGeoPlay: Invalid material, using default. It must be a valid THREE.Material");
+    }
+    return new THREE.MeshBasicMaterial({
+      color: 16774307,
+      transparent: true,
+      opacity: 0.5,
+      side: THREE.FrontSide,
+      depthWrite: false
+    });
   }
+  return material;
 };
 
 // src/style/WaterLayer.js
 var THREE2 = __toESM(require("three"));
+var _isVisible2, _material2, _YOrder2;
 var WaterType = class {
-  #isVisible = false;
-  #material;
-  #YOrder;
+  /**
+   * @param {THREE.Material} material - Three.js material for this water type.
+   * @param {number} YOrder - Y-axis render order offset.
+   */
   constructor(material, YOrder) {
-    this.#material = material;
-    this.#YOrder = YOrder;
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible2, false);
+    /** @type {THREE.Material} */
+    __privateAdd(this, _material2);
+    /** @type {number} */
+    __privateAdd(this, _YOrder2);
+    __privateSet(this, _material2, material);
+    __privateSet(this, _YOrder2, YOrder);
   }
+  /**
+   * Whether this water type is rendered.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible2);
   }
   set isVisible(v) {
-    this.#isVisible = !!v;
+    __privateSet(this, _isVisible2, !!v);
   }
+  /**
+   * Sets visibility (alias for the `isVisible` setter).
+   * @param {boolean} v
+   */
   setVisible(v) {
-    this.#isVisible = !!v;
+    __privateSet(this, _isVisible2, !!v);
   }
+  /**
+   * The Three.js material used to render this water type.
+   * Must be a {@link THREE.Material} instance.
+   * @type {THREE.Material}
+   */
   get material() {
-    return this.#material;
+    return __privateGet(this, _material2);
   }
   set material(m) {
     if (m && !(m instanceof THREE2.Material)) {
       console.warn("ThreeGeoPlay: material must be a THREE.Material instance");
       return;
     }
-    this.#material = m;
+    __privateSet(this, _material2, m);
   }
+  /**
+   * Y-axis render order offset for depth sorting.
+   * @type {number}
+   */
   get YOrder() {
-    return this.#YOrder;
+    return __privateGet(this, _YOrder2);
   }
   set YOrder(v) {
-    this.#YOrder = v;
+    __privateSet(this, _YOrder2, v);
   }
 };
+_isVisible2 = new WeakMap();
+_material2 = new WeakMap();
+_YOrder2 = new WeakMap();
+var _isVisible3, _swimming_pool, _river, _lake, _ocean, _pond, _waterMap, _WaterLayer_instances, allTypes_fn;
 var WaterLayer = class {
-  #isVisible = true;
-  #swimming_pool;
-  #river;
-  #lake;
-  #ocean;
-  #pond;
-  #waterMap;
   constructor() {
-    const mat = (color, transparent = false, opacity = 0.9, extra = {}) => new THREE2.MeshBasicMaterial({
-      color,
-      transparent,
-      opacity,
-      side: THREE2.BackSide,
-      ...extra
-    });
-    this.#swimming_pool = new WaterType(
-      mat(16777215, true, 0.5, { depthWrite: false }),
-      1e-4
-    );
-    this.#river = new WaterType(
-      mat(16737792),
-      12e-5
-    );
-    this.#lake = new WaterType(
-      mat(10279158),
-      14e-5
-    );
-    this.#ocean = new WaterType(
-      mat(10279158),
-      1e-4
-    );
-    this.#pond = new WaterType(
-      mat(3925925),
-      1e-4
-    );
-    this.#waterMap = /* @__PURE__ */ new Map([
-      ["swimming_pool", this.#swimming_pool],
-      ["river", this.#river],
-      ["lake", this.#lake],
-      ["ocean", this.#ocean],
-      ["pond", this.#pond]
-    ]);
+    __privateAdd(this, _WaterLayer_instances);
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible3, true);
+    /** @type {WaterType} */
+    __privateAdd(this, _swimming_pool);
+    /** @type {WaterType} */
+    __privateAdd(this, _river);
+    /** @type {WaterType} */
+    __privateAdd(this, _lake);
+    /** @type {WaterType} */
+    __privateAdd(this, _ocean);
+    /** @type {WaterType} */
+    __privateAdd(this, _pond);
+    /** @type {Map<string, WaterType>} */
+    __privateAdd(this, _waterMap);
+    const mat = (color, transparent = false, opacity = 0.9, extra = {}) => new THREE2.MeshBasicMaterial({ color, transparent, opacity, side: THREE2.BackSide, ...extra });
+    __privateSet(this, _swimming_pool, new WaterType(mat(16777215, true, 0.5, { depthWrite: false }), 1e-4));
+    __privateSet(this, _river, new WaterType(mat(16737792), 12e-5));
+    __privateSet(this, _lake, new WaterType(mat(10279158), 14e-5));
+    __privateSet(this, _ocean, new WaterType(mat(10279158), 1e-4));
+    __privateSet(this, _pond, new WaterType(mat(3925925), 1e-4));
+    __privateSet(this, _waterMap, /* @__PURE__ */ new Map([
+      ["swimming_pool", __privateGet(this, _swimming_pool)],
+      ["river", __privateGet(this, _river)],
+      ["lake", __privateGet(this, _lake)],
+      ["ocean", __privateGet(this, _ocean)],
+      ["pond", __privateGet(this, _pond)]
+    ]));
   }
+  /**
+   * Master visibility toggle. Setting this also propagates to all individual water types.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible3);
   }
   set isVisible(v) {
-    this.#isVisible = !!v;
-    this.#allTypes().forEach((t) => t.setVisible(v));
+    __privateSet(this, _isVisible3, !!v);
+    __privateMethod(this, _WaterLayer_instances, allTypes_fn).call(this).forEach((t) => t.setVisible(v));
   }
+  /** @type {WaterType} */
   get swimming_pool() {
-    return this.#swimming_pool;
+    return __privateGet(this, _swimming_pool);
   }
+  /** @type {WaterType} */
   get river() {
-    return this.#river;
+    return __privateGet(this, _river);
   }
+  /** @type {WaterType} */
   get lake() {
-    return this.#lake;
+    return __privateGet(this, _lake);
   }
+  /** @type {WaterType} */
   get ocean() {
-    return this.#ocean;
+    return __privateGet(this, _ocean);
   }
+  /** @type {WaterType} */
   get pond() {
-    return this.#pond;
+    return __privateGet(this, _pond);
   }
+  /**
+   * Returns a water type by its OSM class name.
+   * @param {'swimming_pool'|'river'|'lake'|'ocean'|'pond'} name - The water class name.
+   * @returns {WaterType|null} The matching type, or `null` if not found.
+   */
   getTypeByName(name) {
-    return this.#waterMap.get(name) ?? null;
+    return __privateGet(this, _waterMap).get(name) ?? null;
   }
+  /**
+   * Replaces the material on every water type with a clone of the provided material.
+   * @param {THREE.Material} material - A valid Three.js material.
+   */
   setAllMaterials(material) {
     if (!(material instanceof THREE2.Material)) {
       console.warn("ThreeGeoPlay: Invalid material, must be a THREE.Material");
       return;
     }
-    this.#allTypes().forEach((t) => {
+    __privateMethod(this, _WaterLayer_instances, allTypes_fn).call(this).forEach((t) => {
       t.material = material.clone();
     });
   }
+  /**
+   * Sets visibility on all individual water types.
+   * @param {boolean} isVisible
+   */
   setVisibleAll(isVisible) {
-    this.#allTypes().forEach((t) => t.setVisible(isVisible));
-  }
-  #allTypes() {
-    return [
-      this.#swimming_pool,
-      this.#river,
-      this.#lake,
-      this.#ocean,
-      this.#pond
-    ];
+    __privateMethod(this, _WaterLayer_instances, allTypes_fn).call(this).forEach((t) => t.setVisible(isVisible));
   }
 };
+_isVisible3 = new WeakMap();
+_swimming_pool = new WeakMap();
+_river = new WeakMap();
+_lake = new WeakMap();
+_ocean = new WeakMap();
+_pond = new WeakMap();
+_waterMap = new WeakMap();
+_WaterLayer_instances = new WeakSet();
+/**
+ * @returns {WaterType[]}
+ * @private
+ */
+allTypes_fn = function() {
+  return [__privateGet(this, _swimming_pool), __privateGet(this, _river), __privateGet(this, _lake), __privateGet(this, _ocean), __privateGet(this, _pond)];
+};
 
 // src/style/LanduseLayer.js
 var THREE3 = __toESM(require("three"));
+var _isVisible4, _material3, _YOrder3;
 var LandUseType = class {
-  #isVisible = false;
-  #material;
-  #YOrder;
+  /**
+   * @param {THREE.Material} material - Three.js material for this land use type.
+   * @param {number} YOrder - Y-axis render order offset.
+   */
   constructor(material, YOrder) {
-    this.#material = material;
-    this.#YOrder = YOrder;
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible4, false);
+    /** @type {THREE.Material} */
+    __privateAdd(this, _material3);
+    /** @type {number} */
+    __privateAdd(this, _YOrder3);
+    __privateSet(this, _material3, material);
+    __privateSet(this, _YOrder3, YOrder);
   }
+  /**
+   * Whether this land use type is rendered.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible4);
   }
   set isVisible(v) {
-    this.#isVisible = !!v;
+    __privateSet(this, _isVisible4, !!v);
   }
+  /**
+   * Sets visibility (alias for the `isVisible` setter).
+   * @param {boolean} v
+   */
   setVisible(v) {
-    this.#isVisible = !!v;
+    __privateSet(this, _isVisible4, !!v);
   }
+  /**
+   * The Three.js material used to render this land use type.
+   * Must be a {@link THREE.Material} instance.
+   * @type {THREE.Material}
+   */
   get material() {
-    return this.#material;
+    return __privateGet(this, _material3);
   }
   set material(m) {
     if (m && !(m instanceof THREE3.Material)) {
       console.warn("ThreeGeoPlay: material must be a THREE.Material instance");
       return;
     }
-    this.#material = m;
+    __privateSet(this, _material3, m);
   }
+  /**
+   * Y-axis render order offset for depth sorting.
+   * @type {number}
+   */
   get YOrder() {
-    return this.#YOrder;
+    return __privateGet(this, _YOrder3);
   }
   set YOrder(v) {
-    this.#YOrder = v;
+    __privateSet(this, _YOrder3, v);
   }
 };
+_isVisible4 = new WeakMap();
+_material3 = new WeakMap();
+_YOrder3 = new WeakMap();
+var _isVisible5, _farmland, _suburb, _residential, _industrial, _pitch, _university, _retail, _playground, _commercial, _military, _school, _college, _bus_station, _kindergarten, _theme_park, _hospital, _railway, _parking, _recreation_ground, _cemetery, _library, _track, _stadium, _quarter, _zoo, _attraction, _religious, _quarry, _nature_reserve, _protected_area, _landUseMap, _LandUseLayer_instances, allTypes_fn2;
 var LandUseLayer = class {
-  #isVisible = true;
-  #farmland;
-  #suburb;
-  #residential;
-  #industrial;
-  #pitch;
-  #university;
-  #retail;
-  #playground;
-  #commercial;
-  #military;
-  #school;
-  #college;
-  #bus_station;
-  #kindergarten;
-  #theme_park;
-  #hospital;
-  #railway;
-  #parking;
-  #recreation_ground;
-  #cemetery;
-  #library;
-  #track;
-  #stadium;
-  #quarter;
-  #zoo;
-  #attraction;
-  #religious;
-  #quarry;
-  #nature_reserve;
-  #protected_area;
-  #landUseMap;
   constructor() {
+    __privateAdd(this, _LandUseLayer_instances);
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible5, true);
+    /** @type {LandUseType} */
+    __privateAdd(this, _farmland);
+    /** @type {LandUseType} */
+    __privateAdd(this, _suburb);
+    /** @type {LandUseType} */
+    __privateAdd(this, _residential);
+    /** @type {LandUseType} */
+    __privateAdd(this, _industrial);
+    /** @type {LandUseType} */
+    __privateAdd(this, _pitch);
+    /** @type {LandUseType} */
+    __privateAdd(this, _university);
+    /** @type {LandUseType} */
+    __privateAdd(this, _retail);
+    /** @type {LandUseType} */
+    __privateAdd(this, _playground);
+    /** @type {LandUseType} */
+    __privateAdd(this, _commercial);
+    /** @type {LandUseType} */
+    __privateAdd(this, _military);
+    /** @type {LandUseType} */
+    __privateAdd(this, _school);
+    /** @type {LandUseType} */
+    __privateAdd(this, _college);
+    /** @type {LandUseType} */
+    __privateAdd(this, _bus_station);
+    /** @type {LandUseType} */
+    __privateAdd(this, _kindergarten);
+    /** @type {LandUseType} */
+    __privateAdd(this, _theme_park);
+    /** @type {LandUseType} */
+    __privateAdd(this, _hospital);
+    /** @type {LandUseType} */
+    __privateAdd(this, _railway);
+    /** @type {LandUseType} */
+    __privateAdd(this, _parking);
+    /** @type {LandUseType} */
+    __privateAdd(this, _recreation_ground);
+    /** @type {LandUseType} */
+    __privateAdd(this, _cemetery);
+    /** @type {LandUseType} */
+    __privateAdd(this, _library);
+    /** @type {LandUseType} */
+    __privateAdd(this, _track);
+    /** @type {LandUseType} */
+    __privateAdd(this, _stadium);
+    /** @type {LandUseType} */
+    __privateAdd(this, _quarter);
+    /** @type {LandUseType} */
+    __privateAdd(this, _zoo);
+    /** @type {LandUseType} */
+    __privateAdd(this, _attraction);
+    /** @type {LandUseType} */
+    __privateAdd(this, _religious);
+    /** @type {LandUseType} */
+    __privateAdd(this, _quarry);
+    /** @type {LandUseType} */
+    __privateAdd(this, _nature_reserve);
+    /** @type {LandUseType} */
+    __privateAdd(this, _protected_area);
+    /** @type {Map<string, LandUseType>} */
+    __privateAdd(this, _landUseMap);
     const mat = (color) => new THREE3.MeshBasicMaterial({
       color,
       transparent: false,
       side: THREE3.BackSide
     });
-    this.#farmland = new LandUseType(mat(16764057), 29e-5);
-    this.#suburb = new LandUseType(mat(16764057), 3e-4);
-    this.#residential = new LandUseType(mat(7007092), 31e-5);
-    this.#industrial = new LandUseType(mat(8421504), 32e-5);
-    this.#pitch = new LandUseType(mat(65280), 33e-5);
-    this.#university = new LandUseType(mat(255), 34e-5);
-    this.#retail = new LandUseType(mat(16737095), 35e-5);
-    this.#playground = new LandUseType(mat(16766720), 36e-5);
-    this.#commercial = new LandUseType(mat(16729344), 37e-5);
-    this.#military = new LandUseType(mat(6908265), 38e-5);
-    this.#school = new LandUseType(mat(11393254), 39e-5);
-    this.#college = new LandUseType(mat(6970061), 4e-4);
-    this.#bus_station = new LandUseType(mat(32896), 41e-5);
-    this.#kindergarten = new LandUseType(mat(16761035), 42e-5);
-    this.#theme_park = new LandUseType(mat(16738740), 43e-5);
-    this.#hospital = new LandUseType(mat(16711680), 44e-5);
-    this.#railway = new LandUseType(mat(11119017), 45e-5);
-    this.#parking = new LandUseType(mat(4620980), 46e-5);
-    this.#recreation_ground = new LandUseType(mat(10025880), 48e-5);
-    this.#cemetery = new LandUseType(mat(5597999), 49e-5);
-    this.#library = new LandUseType(mat(9055202), 5e-4);
-    this.#track = new LandUseType(mat(9127187), 51e-5);
-    this.#stadium = new LandUseType(mat(16747520), 52e-5);
-    this.#quarter = new LandUseType(mat(11674146), 53e-5);
-    this.#zoo = new LandUseType(mat(2263842), 54e-5);
-    this.#attraction = new LandUseType(mat(16753920), 55e-5);
-    this.#religious = new LandUseType(mat(4915330), 56e-5);
-    this.#quarry = new LandUseType(mat(1553925), 57e-5);
-    this.#nature_reserve = new LandUseType(mat(25600), 58e-5);
-    this.#protected_area = new LandUseType(mat(3329330), 59e-5);
-    this.#landUseMap = /* @__PURE__ */ new Map([
-      ["farmland", this.#farmland],
-      ["suburb", this.#suburb],
-      ["residential", this.#residential],
-      ["industrial", this.#industrial],
-      ["pitch", this.#pitch],
-      ["university", this.#university],
-      ["retail", this.#retail],
-      ["playground", this.#playground],
-      ["commercial", this.#commercial],
-      ["military", this.#military],
-      ["school", this.#school],
-      ["college", this.#college],
-      ["bus_station", this.#bus_station],
-      ["kindergarten", this.#kindergarten],
-      ["theme_park", this.#theme_park],
-      ["hospital", this.#hospital],
-      ["railway", this.#railway],
-      ["parking", this.#parking],
-      ["recreation_ground", this.#recreation_ground],
-      ["cemetery", this.#cemetery],
-      ["library", this.#library],
-      ["track", this.#track],
-      ["stadium", this.#stadium],
-      ["quarter", this.#quarter],
-      ["zoo", this.#zoo],
-      ["attraction", this.#attraction],
-      ["religious", this.#religious],
-      ["quarry", this.#quarry],
-      ["nature_reserve", this.#nature_reserve],
-      ["protected_area", this.#protected_area]
-    ]);
+    __privateSet(this, _farmland, new LandUseType(mat(16764057), 29e-5));
+    __privateSet(this, _suburb, new LandUseType(mat(16764057), 3e-4));
+    __privateSet(this, _residential, new LandUseType(mat(7007092), 31e-5));
+    __privateSet(this, _industrial, new LandUseType(mat(8421504), 32e-5));
+    __privateSet(this, _pitch, new LandUseType(mat(65280), 33e-5));
+    __privateSet(this, _university, new LandUseType(mat(255), 34e-5));
+    __privateSet(this, _retail, new LandUseType(mat(16737095), 35e-5));
+    __privateSet(this, _playground, new LandUseType(mat(16766720), 36e-5));
+    __privateSet(this, _commercial, new LandUseType(mat(16729344), 37e-5));
+    __privateSet(this, _military, new LandUseType(mat(6908265), 38e-5));
+    __privateSet(this, _school, new LandUseType(mat(11393254), 39e-5));
+    __privateSet(this, _college, new LandUseType(mat(6970061), 4e-4));
+    __privateSet(this, _bus_station, new LandUseType(mat(32896), 41e-5));
+    __privateSet(this, _kindergarten, new LandUseType(mat(16761035), 42e-5));
+    __privateSet(this, _theme_park, new LandUseType(mat(16738740), 43e-5));
+    __privateSet(this, _hospital, new LandUseType(mat(16711680), 44e-5));
+    __privateSet(this, _railway, new LandUseType(mat(11119017), 45e-5));
+    __privateSet(this, _parking, new LandUseType(mat(4620980), 46e-5));
+    __privateSet(this, _recreation_ground, new LandUseType(mat(10025880), 48e-5));
+    __privateSet(this, _cemetery, new LandUseType(mat(5597999), 49e-5));
+    __privateSet(this, _library, new LandUseType(mat(9055202), 5e-4));
+    __privateSet(this, _track, new LandUseType(mat(9127187), 51e-5));
+    __privateSet(this, _stadium, new LandUseType(mat(16747520), 52e-5));
+    __privateSet(this, _quarter, new LandUseType(mat(11674146), 53e-5));
+    __privateSet(this, _zoo, new LandUseType(mat(2263842), 54e-5));
+    __privateSet(this, _attraction, new LandUseType(mat(16753920), 55e-5));
+    __privateSet(this, _religious, new LandUseType(mat(4915330), 56e-5));
+    __privateSet(this, _quarry, new LandUseType(mat(1553925), 57e-5));
+    __privateSet(this, _nature_reserve, new LandUseType(mat(25600), 58e-5));
+    __privateSet(this, _protected_area, new LandUseType(mat(3329330), 59e-5));
+    __privateSet(this, _landUseMap, /* @__PURE__ */ new Map([
+      ["farmland", __privateGet(this, _farmland)],
+      ["suburb", __privateGet(this, _suburb)],
+      ["residential", __privateGet(this, _residential)],
+      ["industrial", __privateGet(this, _industrial)],
+      ["pitch", __privateGet(this, _pitch)],
+      ["university", __privateGet(this, _university)],
+      ["retail", __privateGet(this, _retail)],
+      ["playground", __privateGet(this, _playground)],
+      ["commercial", __privateGet(this, _commercial)],
+      ["military", __privateGet(this, _military)],
+      ["school", __privateGet(this, _school)],
+      ["college", __privateGet(this, _college)],
+      ["bus_station", __privateGet(this, _bus_station)],
+      ["kindergarten", __privateGet(this, _kindergarten)],
+      ["theme_park", __privateGet(this, _theme_park)],
+      ["hospital", __privateGet(this, _hospital)],
+      ["railway", __privateGet(this, _railway)],
+      ["parking", __privateGet(this, _parking)],
+      ["recreation_ground", __privateGet(this, _recreation_ground)],
+      ["cemetery", __privateGet(this, _cemetery)],
+      ["library", __privateGet(this, _library)],
+      ["track", __privateGet(this, _track)],
+      ["stadium", __privateGet(this, _stadium)],
+      ["quarter", __privateGet(this, _quarter)],
+      ["zoo", __privateGet(this, _zoo)],
+      ["attraction", __privateGet(this, _attraction)],
+      ["religious", __privateGet(this, _religious)],
+      ["quarry", __privateGet(this, _quarry)],
+      ["nature_reserve", __privateGet(this, _nature_reserve)],
+      ["protected_area", __privateGet(this, _protected_area)]
+    ]));
   }
+  /**
+   * Master visibility toggle. Setting this also propagates to all individual types.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible5);
   }
   set isVisible(v) {
-    this.#isVisible = !!v;
-    this.#allTypes().forEach((t) => t.setVisible(v));
+    __privateSet(this, _isVisible5, !!v);
+    __privateMethod(this, _LandUseLayer_instances, allTypes_fn2).call(this).forEach((t) => t.setVisible(v));
   }
+  /** @type {LandUseType} */
   get farmland() {
-    return this.#farmland;
+    return __privateGet(this, _farmland);
   }
+  /** @type {LandUseType} */
   get suburb() {
-    return this.#suburb;
+    return __privateGet(this, _suburb);
   }
+  /** @type {LandUseType} */
   get residential() {
-    return this.#residential;
+    return __privateGet(this, _residential);
   }
+  /** @type {LandUseType} */
   get industrial() {
-    return this.#industrial;
+    return __privateGet(this, _industrial);
   }
+  /** @type {LandUseType} */
   get pitch() {
-    return this.#pitch;
+    return __privateGet(this, _pitch);
   }
+  /** @type {LandUseType} */
   get university() {
-    return this.#university;
+    return __privateGet(this, _university);
   }
+  /** @type {LandUseType} */
   get retail() {
-    return this.#retail;
+    return __privateGet(this, _retail);
   }
+  /** @type {LandUseType} */
   get playground() {
-    return this.#playground;
+    return __privateGet(this, _playground);
   }
+  /** @type {LandUseType} */
   get commercial() {
-    return this.#commercial;
+    return __privateGet(this, _commercial);
   }
+  /** @type {LandUseType} */
   get military() {
-    return this.#military;
+    return __privateGet(this, _military);
   }
+  /** @type {LandUseType} */
   get school() {
-    return this.#school;
+    return __privateGet(this, _school);
   }
+  /** @type {LandUseType} */
   get college() {
-    return this.#college;
+    return __privateGet(this, _college);
   }
+  /** @type {LandUseType} */
   get bus_station() {
-    return this.#bus_station;
+    return __privateGet(this, _bus_station);
   }
+  /** @type {LandUseType} */
   get kindergarten() {
-    return this.#kindergarten;
+    return __privateGet(this, _kindergarten);
   }
+  /** @type {LandUseType} */
   get theme_park() {
-    return this.#theme_park;
+    return __privateGet(this, _theme_park);
   }
+  /** @type {LandUseType} */
   get hospital() {
-    return this.#hospital;
+    return __privateGet(this, _hospital);
   }
+  /** @type {LandUseType} */
   get railway() {
-    return this.#railway;
+    return __privateGet(this, _railway);
   }
+  /** @type {LandUseType} */
   get parking() {
-    return this.#parking;
+    return __privateGet(this, _parking);
   }
+  /** @type {LandUseType} */
   get recreation_ground() {
-    return this.#recreation_ground;
+    return __privateGet(this, _recreation_ground);
   }
+  /** @type {LandUseType} */
   get cemetery() {
-    return this.#cemetery;
+    return __privateGet(this, _cemetery);
   }
+  /** @type {LandUseType} */
   get library() {
-    return this.#library;
+    return __privateGet(this, _library);
   }
+  /** @type {LandUseType} */
   get track() {
-    return this.#track;
+    return __privateGet(this, _track);
   }
+  /** @type {LandUseType} */
   get stadium() {
-    return this.#stadium;
+    return __privateGet(this, _stadium);
   }
+  /** @type {LandUseType} */
   get quarter() {
-    return this.#quarter;
+    return __privateGet(this, _quarter);
   }
+  /** @type {LandUseType} */
   get zoo() {
-    return this.#zoo;
+    return __privateGet(this, _zoo);
   }
+  /** @type {LandUseType} */
   get attraction() {
-    return this.#attraction;
+    return __privateGet(this, _attraction);
   }
+  /** @type {LandUseType} */
   get religious() {
-    return this.#religious;
+    return __privateGet(this, _religious);
   }
+  /** @type {LandUseType} */
   get quarry() {
-    return this.#quarry;
+    return __privateGet(this, _quarry);
   }
+  /** @type {LandUseType} */
   get nature_reserve() {
-    return this.#nature_reserve;
+    return __privateGet(this, _nature_reserve);
   }
+  /** @type {LandUseType} */
   get protected_area() {
-    return this.#protected_area;
+    return __privateGet(this, _protected_area);
   }
+  /**
+   * Returns a land use type by its OSM class name.
+   * @param {LandUseClassName} name - The OSM land use class name.
+   * @returns {LandUseType|null} The matching type, or `null` if not found.
+   */
   getTypeByName(name) {
-    return this.#landUseMap.get(name) ?? null;
+    return __privateGet(this, _landUseMap).get(name) ?? null;
   }
+  /**
+   * Replaces the material on every land use type with a clone of the provided material.
+   * @param {THREE.Material} material - A valid Three.js material.
+   */
   setAllMaterials(material) {
     if (!(material instanceof THREE3.Material)) {
       console.warn("ThreeGeoPlay: Invalid material");
       return;
     }
-    this.#allTypes().forEach((t) => t.material = material.clone());
+    __privateMethod(this, _LandUseLayer_instances, allTypes_fn2).call(this).forEach((t) => t.material = material.clone());
   }
+  /**
+   * Sets visibility on all individual land use types.
+   * @param {boolean} v
+   */
   setVisibleAll(v) {
-    this.#allTypes().forEach((t) => t.setVisible(v));
-  }
-  #allTypes() {
-    return Array.from(this.#landUseMap.values());
-  }
-  static admittedClasses = /* @__PURE__ */ new Set([
-    "farmland",
-    "suburb",
-    "residential",
-    "industrial",
-    "pitch",
-    "university",
-    "retail",
-    "playground",
-    "commercial",
-    "military",
-    "school",
-    "college",
-    "bus_station",
-    "kindergarten",
-    "theme_park",
-    "hospital",
-    "railway",
-    "parking",
-    "recreation_ground",
-    "cemetery",
-    "library",
-    "track",
-    "stadium",
-    "quarter",
-    "zoo",
-    "attraction",
-    "religious",
-    "quarry",
-    "nature_reserve",
-    "protected_area"
-  ]);
+    __privateMethod(this, _LandUseLayer_instances, allTypes_fn2).call(this).forEach((t) => t.setVisible(v));
+  }
+};
+_isVisible5 = new WeakMap();
+_farmland = new WeakMap();
+_suburb = new WeakMap();
+_residential = new WeakMap();
+_industrial = new WeakMap();
+_pitch = new WeakMap();
+_university = new WeakMap();
+_retail = new WeakMap();
+_playground = new WeakMap();
+_commercial = new WeakMap();
+_military = new WeakMap();
+_school = new WeakMap();
+_college = new WeakMap();
+_bus_station = new WeakMap();
+_kindergarten = new WeakMap();
+_theme_park = new WeakMap();
+_hospital = new WeakMap();
+_railway = new WeakMap();
+_parking = new WeakMap();
+_recreation_ground = new WeakMap();
+_cemetery = new WeakMap();
+_library = new WeakMap();
+_track = new WeakMap();
+_stadium = new WeakMap();
+_quarter = new WeakMap();
+_zoo = new WeakMap();
+_attraction = new WeakMap();
+_religious = new WeakMap();
+_quarry = new WeakMap();
+_nature_reserve = new WeakMap();
+_protected_area = new WeakMap();
+_landUseMap = new WeakMap();
+_LandUseLayer_instances = new WeakSet();
+/**
+ * @returns {LandUseType[]}
+ * @private
+ */
+allTypes_fn2 = function() {
+  return Array.from(__privateGet(this, _landUseMap).values());
 };
+/**
+ * Set of all valid OSM land use class names accepted by this layer.
+ * @type {Set<LandUseClassName>}
+ */
+__publicField(LandUseLayer, "admittedClasses", /* @__PURE__ */ new Set([
+  "farmland",
+  "suburb",
+  "residential",
+  "industrial",
+  "pitch",
+  "university",
+  "retail",
+  "playground",
+  "commercial",
+  "military",
+  "school",
+  "college",
+  "bus_station",
+  "kindergarten",
+  "theme_park",
+  "hospital",
+  "railway",
+  "parking",
+  "recreation_ground",
+  "cemetery",
+  "library",
+  "track",
+  "stadium",
+  "quarter",
+  "zoo",
+  "attraction",
+  "religious",
+  "quarry",
+  "nature_reserve",
+  "protected_area"
+]));
 
 // src/style/LandcoverLayer.js
 var THREE4 = __toESM(require("three"));
+var _isVisible6, _material4, _YOrder4;
 var LandCoverType = class {
-  #isVisible = true;
-  #material;
-  #YOrder;
+  /**
+   * @param {THREE.Material} material - Three.js material for this cover type.
+   * @param {number} YOrder - Y-axis render order offset.
+   */
   constructor(material, YOrder) {
-    this.#material = material;
-    this.#YOrder = YOrder;
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible6, true);
+    /** @type {THREE.Material} */
+    __privateAdd(this, _material4);
+    /** @type {number} */
+    __privateAdd(this, _YOrder4);
+    __privateSet(this, _material4, material);
+    __privateSet(this, _YOrder4, YOrder);
   }
+  /**
+   * Whether this land cover type is rendered.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible6);
   }
   set isVisible(v) {
-    this.#isVisible = !!v;
+    __privateSet(this, _isVisible6, !!v);
   }
+  /**
+   * Sets visibility (alias for the `isVisible` setter).
+   * @param {boolean} v
+   */
   setVisible(v) {
-    this.#isVisible = !!v;
+    __privateSet(this, _isVisible6, !!v);
   }
+  /**
+   * The Three.js material used to render this land cover type.
+   * Must be a {@link THREE.Material} instance.
+   * @type {THREE.Material}
+   */
   get material() {
-    return this.#material;
+    return __privateGet(this, _material4);
   }
   set material(m) {
     if (m && !(m instanceof THREE4.Material)) {
       console.warn("ThreeGeoPlay: material must be a THREE.Material instance");
       return;
     }
-    this.#material = m;
+    __privateSet(this, _material4, m);
   }
+  /**
+   * Y-axis render order offset for depth sorting.
+   * @type {number}
+   */
   get YOrder() {
-    return this.#YOrder;
+    return __privateGet(this, _YOrder4);
   }
   set YOrder(v) {
-    this.#YOrder = v;
+    __privateSet(this, _YOrder4, v);
   }
 };
+_isVisible6 = new WeakMap();
+_material4 = new WeakMap();
+_YOrder4 = new WeakMap();
+var _isVisible7, _sand, _park, _grass, _wood, _wetland, _rock, _farmland2, _landCoverMap, _LandCoverLayer_instances, allTypes_fn3;
 var LandCoverLayer = class {
-  #isVisible = true;
-  #sand;
-  #park;
-  #grass;
-  #wood;
-  #wetland;
-  #rock;
-  #farmland;
-  #landCoverMap;
   constructor() {
+    __privateAdd(this, _LandCoverLayer_instances);
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible7, true);
+    /** @type {LandCoverType} */
+    __privateAdd(this, _sand);
+    /** @type {LandCoverType} */
+    __privateAdd(this, _park);
+    /** @type {LandCoverType} */
+    __privateAdd(this, _grass);
+    /** @type {LandCoverType} */
+    __privateAdd(this, _wood);
+    /** @type {LandCoverType} */
+    __privateAdd(this, _wetland);
+    /** @type {LandCoverType} */
+    __privateAdd(this, _rock);
+    /** @type {LandCoverType} */
+    __privateAdd(this, _farmland2);
+    /** @type {Map<string, LandCoverType>} */
+    __privateAdd(this, _landCoverMap);
     const mat = (color) => new THREE4.MeshBasicMaterial({
       color,
       transparent: false,
       opacity: 0.9,
       side: THREE4.BackSide
     });
-    this.#sand = new LandCoverType(mat(16115033), 21e-5);
-    this.#park = new LandCoverType(mat(1088512), 22e-5);
-    this.#grass = new LandCoverType(mat(1553925), 23e-5);
-    this.#wood = new LandCoverType(mat(1553925), 24e-5);
-    this.#wetland = new LandCoverType(mat(1553925), 25e-5);
-    this.#rock = new LandCoverType(mat(1553925), 26e-5);
-    this.#farmland = new LandCoverType(mat(16764057), 27e-5);
-    this.#landCoverMap = /* @__PURE__ */ new Map([
-      ["sand", this.#sand],
-      ["park", this.#park],
-      ["grass", this.#grass],
-      ["wood", this.#wood],
-      ["wetland", this.#wetland],
-      ["rock", this.#rock],
-      ["farmland", this.#farmland]
-    ]);
+    __privateSet(this, _sand, new LandCoverType(mat(16115033), 21e-5));
+    __privateSet(this, _park, new LandCoverType(mat(1088512), 22e-5));
+    __privateSet(this, _grass, new LandCoverType(mat(1553925), 23e-5));
+    __privateSet(this, _wood, new LandCoverType(mat(1553925), 24e-5));
+    __privateSet(this, _wetland, new LandCoverType(mat(1553925), 25e-5));
+    __privateSet(this, _rock, new LandCoverType(mat(1553925), 26e-5));
+    __privateSet(this, _farmland2, new LandCoverType(mat(16764057), 27e-5));
+    __privateSet(this, _landCoverMap, /* @__PURE__ */ new Map([
+      ["sand", __privateGet(this, _sand)],
+      ["park", __privateGet(this, _park)],
+      ["grass", __privateGet(this, _grass)],
+      ["wood", __privateGet(this, _wood)],
+      ["wetland", __privateGet(this, _wetland)],
+      ["rock", __privateGet(this, _rock)],
+      ["farmland", __privateGet(this, _farmland2)]
+    ]));
   }
+  /**
+   * Master visibility toggle for the entire land cover layer.
+   * Setting this also propagates to all individual cover types.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible7);
   }
   set isVisible(v) {
-    this.#isVisible = !!v;
-    this.#allTypes().forEach((t) => t.setVisible(v));
+    __privateSet(this, _isVisible7, !!v);
+    __privateMethod(this, _LandCoverLayer_instances, allTypes_fn3).call(this).forEach((t) => t.setVisible(v));
   }
+  /** @type {LandCoverType} */
   get sand() {
-    return this.#sand;
+    return __privateGet(this, _sand);
   }
+  /** @type {LandCoverType} */
   get park() {
-    return this.#park;
+    return __privateGet(this, _park);
   }
+  /** @type {LandCoverType} */
   get grass() {
-    return this.#grass;
+    return __privateGet(this, _grass);
   }
+  /** @type {LandCoverType} */
   get wood() {
-    return this.#wood;
+    return __privateGet(this, _wood);
   }
+  /** @type {LandCoverType} */
   get wetland() {
-    return this.#wetland;
+    return __privateGet(this, _wetland);
   }
+  /** @type {LandCoverType} */
   get rock() {
-    return this.#rock;
+    return __privateGet(this, _rock);
   }
+  /** @type {LandCoverType} */
   get farmland() {
-    return this.#farmland;
+    return __privateGet(this, _farmland2);
   }
+  /**
+   * Returns a land cover type by its OSM class name.
+   * @param {'sand'|'park'|'grass'|'wood'|'wetland'|'rock'|'farmland'} name - The land cover class name.
+   * @returns {LandCoverType|null} The matching type, or `null` if not found.
+   */
   getTypeByName(name) {
-    return this.#landCoverMap.get(name) ?? null;
+    return __privateGet(this, _landCoverMap).get(name) ?? null;
   }
+  /**
+   * Replaces the material on every land cover type with a clone of the provided material.
+   * @param {THREE.Material} material - A valid Three.js material to apply to all types.
+   */
   setAllMaterials(material) {
     if (!(material instanceof THREE4.Material)) {
       console.warn("ThreeGeoPlay: Invalid material, must be a THREE.Material");
       return;
     }
-    this.#allTypes().forEach((t) => {
+    __privateMethod(this, _LandCoverLayer_instances, allTypes_fn3).call(this).forEach((t) => {
       t.material = material.clone();
     });
   }
+  /**
+   * Sets visibility on all individual land cover types.
+   * @param {boolean} isVisible
+   */
   setVisibleAll(isVisible) {
-    this.#allTypes().forEach((t) => t.setVisible(isVisible));
-  }
-  #allTypes() {
-    return [
-      this.#sand,
-      this.#park,
-      this.#grass,
-      this.#wood,
-      this.#wetland,
-      this.#rock,
-      this.#farmland
-    ];
+    __privateMethod(this, _LandCoverLayer_instances, allTypes_fn3).call(this).forEach((t) => t.setVisible(isVisible));
   }
 };
+_isVisible7 = new WeakMap();
+_sand = new WeakMap();
+_park = new WeakMap();
+_grass = new WeakMap();
+_wood = new WeakMap();
+_wetland = new WeakMap();
+_rock = new WeakMap();
+_farmland2 = new WeakMap();
+_landCoverMap = new WeakMap();
+_LandCoverLayer_instances = new WeakSet();
+/**
+ * @returns {LandCoverType[]}
+ * @private
+ */
+allTypes_fn3 = function() {
+  return [
+    __privateGet(this, _sand),
+    __privateGet(this, _park),
+    __privateGet(this, _grass),
+    __privateGet(this, _wood),
+    __privateGet(this, _wetland),
+    __privateGet(this, _rock),
+    __privateGet(this, _farmland2)
+  ];
+};
 
 // src/style/TransportationLayer.js
 var THREE5 = __toESM(require("three"));
 function makeRoadMaterial(color) {
-  return new THREE5.MeshBasicMaterial({
-    color,
-    side: THREE5.BackSide,
-    wireframe: false
-  });
+  return new THREE5.MeshBasicMaterial({ color, side: THREE5.BackSide, wireframe: false });
 }
 function makeOutlineMaterial(color) {
-  return new THREE5.MeshBasicMaterial({
-    color,
-    side: THREE5.BackSide
-  });
+  return new THREE5.MeshBasicMaterial({ color, side: THREE5.BackSide });
 }
+var _isVisible8, _outlineWidth, _material5, _outlineMaterial, _YOrder5, _lineWidth;
 var RoadType = class {
-  #isVisible = false;
-  #outlineWidth = null;
-  #material = null;
-  #outlineMaterial = null;
-  #YOrder = 0;
-  #lineWidth = 0;
+  /**
+   * @param {THREE.Material} material - Fill material.
+   * @param {THREE.Material} outlineMaterial - Outline material.
+   * @param {number} YOrder - Y-axis render order offset.
+   * @param {number} lineWidth - Half-width of the rendered road in world units.
+   * @param {boolean} isVisible - Initial visibility.
+   */
   constructor(material, outlineMaterial, YOrder, lineWidth, isVisible) {
-    this.#material = material;
-    this.#outlineMaterial = outlineMaterial;
-    this.#YOrder = YOrder;
-    this.#lineWidth = lineWidth;
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible8, false);
+    /** @type {number|null} */
+    __privateAdd(this, _outlineWidth, null);
+    /** @type {THREE.Material} */
+    __privateAdd(this, _material5, null);
+    /** @type {THREE.Material} */
+    __privateAdd(this, _outlineMaterial, null);
+    /** @type {number} */
+    __privateAdd(this, _YOrder5, 0);
+    /** @type {number} */
+    __privateAdd(this, _lineWidth, 0);
+    __privateSet(this, _material5, material);
+    __privateSet(this, _outlineMaterial, outlineMaterial);
+    __privateSet(this, _YOrder5, YOrder);
+    __privateSet(this, _lineWidth, lineWidth);
     this.isVisible = isVisible;
   }
+  /**
+   * Whether this road type is rendered.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible8);
   }
   set isVisible(v) {
-    this.#isVisible = !!v;
+    __privateSet(this, _isVisible8, !!v);
   }
+  /**
+   * Sets visibility (alias for the `isVisible` setter).
+   * @param {boolean} v
+   */
   setVisible(v) {
-    this.#isVisible = !!v;
+    __privateSet(this, _isVisible8, !!v);
   }
+  /**
+   * The Three.js fill material for this road type.
+   * Must be a {@link THREE.Material} instance.
+   * @type {THREE.Material}
+   */
   get material() {
-    return this.#material;
+    return __privateGet(this, _material5);
   }
   set material(m) {
     if (m && !(m instanceof THREE5.Material)) {
       console.warn("ThreeGeoPlay: material must be a THREE.Material instance");
       return;
     }
-    this.#material = m;
+    __privateSet(this, _material5, m);
   }
+  /**
+   * The Three.js outline material for this road type.
+   * Must be a {@link THREE.Material} instance.
+   * @type {THREE.Material}
+   */
   get outlineMaterial() {
-    return this.#outlineMaterial;
+    return __privateGet(this, _outlineMaterial);
   }
   set outlineMaterial(m) {
     if (m && !(m instanceof THREE5.Material)) {
       console.warn("ThreeGeoPlay: outlineMaterial must be a THREE.Material instance");
       return;
     }
-    this.#outlineMaterial = m;
+    __privateSet(this, _outlineMaterial, m);
   }
+  /**
+   * Y-axis render order offset for depth sorting.
+   * @type {number}
+   */
   get YOrder() {
-    return this.#YOrder;
+    return __privateGet(this, _YOrder5);
   }
   set YOrder(v) {
     if (typeof v !== "number" || isNaN(v)) {
       console.warn(`ThreeGeoPlay: YOrder must be a number (received: ${v})`);
       return;
     }
-    this.#YOrder = v;
+    __privateSet(this, _YOrder5, v);
   }
+  /**
+   * Half-width of the rendered road geometry in world units. Must be ≥ 0.
+   * @type {number}
+   */
   get lineWidth() {
-    return this.#lineWidth;
+    return __privateGet(this, _lineWidth);
   }
   set lineWidth(v) {
     if (typeof v !== "number" || isNaN(v) || v < 0) {
       console.warn(`ThreeGeoPlay: lineWidth must be a non-negative number (received: ${v})`);
       return;
     }
-    this.#lineWidth = v;
+    __privateSet(this, _lineWidth, v);
   }
+  /**
+   * Per-type outline width override in world units.
+   * Set to `null` to fall back to {@link GeneralConfig.outlineWidth}.
+   * @type {number|null}
+   */
   get outlineWidth() {
-    return this.#outlineWidth;
+    return __privateGet(this, _outlineWidth);
   }
   set outlineWidth(num) {
     if (num !== null && (typeof num !== "number" || isNaN(num))) {
@@ -6158,20 +6549,38 @@ var RoadType = class {
     }
     if (num !== null && num < 0) {
       console.warn(`ThreeGeoPlay: outlineWidth cannot be negative (received: ${num}), defaulting to 0`);
-      this.#outlineWidth = 0;
+      __privateSet(this, _outlineWidth, 0);
       return;
     }
-    this.#outlineWidth = num;
+    __privateSet(this, _outlineWidth, num);
   }
+  /**
+   * Clears the per-type outline width override, falling back to {@link GeneralConfig.outlineWidth}.
+   */
   resetOutlineWidth() {
-    this.#outlineWidth = null;
+    __privateSet(this, _outlineWidth, null);
   }
 };
+_isVisible8 = new WeakMap();
+_outlineWidth = new WeakMap();
+_material5 = new WeakMap();
+_outlineMaterial = new WeakMap();
+_YOrder5 = new WeakMap();
+_lineWidth = new WeakMap();
+var _jointSegments, _outlineWidth2;
 var GeneralConfig = class {
-  #jointSegments = 8;
-  #outlineWidth = 0.075;
+  constructor() {
+    /** @type {number} */
+    __privateAdd(this, _jointSegments, 8);
+    /** @type {number} */
+    __privateAdd(this, _outlineWidth2, 0.075);
+  }
+  /**
+   * Number of segments used to round road joints. Minimum is 6.
+   * @type {number}
+   */
   get jointSegments() {
-    return this.#jointSegments;
+    return __privateGet(this, _jointSegments);
   }
   set jointSegments(num) {
     if (typeof num !== "number" || isNaN(num)) {
@@ -6180,13 +6589,18 @@ var GeneralConfig = class {
     }
     if (num < 6) {
       console.warn(`ThreeGeoPlay: jointSegments cannot be less than 6 (received: ${num}), defaulting to 6`);
-      this.#jointSegments = 6;
+      __privateSet(this, _jointSegments, 6);
       return;
     }
-    this.#jointSegments = num;
+    __privateSet(this, _jointSegments, num);
   }
+  /**
+   * Default outline width in world units applied to all road types that have not set their own.
+   * Must be ≥ 0.
+   * @type {number}
+   */
   get outlineWidth() {
-    return this.#outlineWidth;
+    return __privateGet(this, _outlineWidth2);
   }
   set outlineWidth(num) {
     if (typeof num !== "number" || isNaN(num)) {
@@ -6195,208 +6609,321 @@ var GeneralConfig = class {
     }
     if (num < 0) {
       console.warn(`ThreeGeoPlay: outlineWidth cannot be negative (received: ${num}), defaulting to 0`);
-      this.#outlineWidth = 0;
+      __privateSet(this, _outlineWidth2, 0);
       return;
     }
-    this.#outlineWidth = num;
+    __privateSet(this, _outlineWidth2, num);
   }
 };
+_jointSegments = new WeakMap();
+_outlineWidth2 = new WeakMap();
+var _isVisible9, _generalConfig, _primary, _secondary, _tertiary, _minor, _service, _pedestrian, _path, _minor_construction, _rail, _transit, _track2, _trunk, _pier, _primary_construction, _ferry, _secondary_construction, _path_construction, _motorway, _trunk_construction, _service_construction, _TransportationLayer_instances, allRoadTypes_fn, roadTypeMap_fn;
 var TransportationLayer = class {
-  #isVisible = true;
-  #generalConfig = new GeneralConfig();
-  #primary;
-  #secondary;
-  #tertiary;
-  #minor;
-  #service;
-  #pedestrian;
-  #path;
-  #minor_construction;
-  #rail;
-  #transit;
-  #track;
-  #trunk;
-  #pier;
-  #primary_construction;
-  #ferry;
-  #secondary_construction;
-  #path_construction;
-  #motorway;
-  #trunk_construction;
-  #service_construction;
   constructor() {
+    __privateAdd(this, _TransportationLayer_instances);
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible9, true);
+    /** @type {GeneralConfig} */
+    __privateAdd(this, _generalConfig, new GeneralConfig());
+    /** @type {RoadType} */
+    __privateAdd(this, _primary);
+    /** @type {RoadType} */
+    __privateAdd(this, _secondary);
+    /** @type {RoadType} */
+    __privateAdd(this, _tertiary);
+    /** @type {RoadType} */
+    __privateAdd(this, _minor);
+    /** @type {RoadType} */
+    __privateAdd(this, _service);
+    /** @type {RoadType} */
+    __privateAdd(this, _pedestrian);
+    /** @type {RoadType} */
+    __privateAdd(this, _path);
+    /** @type {RoadType} */
+    __privateAdd(this, _minor_construction);
+    /** @type {RoadType} */
+    __privateAdd(this, _rail);
+    /** @type {RoadType} */
+    __privateAdd(this, _transit);
+    /** @type {RoadType} */
+    __privateAdd(this, _track2);
+    /** @type {RoadType} */
+    __privateAdd(this, _trunk);
+    /** @type {RoadType} */
+    __privateAdd(this, _pier);
+    /** @type {RoadType} */
+    __privateAdd(this, _primary_construction);
+    /** @type {RoadType} */
+    __privateAdd(this, _ferry);
+    /** @type {RoadType} */
+    __privateAdd(this, _secondary_construction);
+    /** @type {RoadType} */
+    __privateAdd(this, _path_construction);
+    /** @type {RoadType} */
+    __privateAdd(this, _motorway);
+    /** @type {RoadType} */
+    __privateAdd(this, _trunk_construction);
+    /** @type {RoadType} */
+    __privateAdd(this, _service_construction);
     const delta = 0.25;
     const roadMat = makeRoadMaterial(16711680);
     const outlineMat = makeOutlineMaterial(16776960);
-    this.#motorway = new RoadType(roadMat, outlineMat, 25e-4, 0.55 * delta, true);
-    this.#trunk = new RoadType(roadMat, outlineMat, 24e-4, 0.5 * delta, false);
-    this.#trunk_construction = new RoadType(roadMat, outlineMat, 23e-4, 0.48 * delta, false);
-    this.#primary = new RoadType(roadMat, outlineMat, 22e-4, 0.45 * delta, true);
-    this.#primary_construction = new RoadType(roadMat, outlineMat, 21e-4, 0.43 * delta, false);
-    this.#secondary = new RoadType(roadMat, outlineMat, 2e-3, 0.38 * delta, true);
-    this.#secondary_construction = new RoadType(roadMat, outlineMat, 19e-4, 0.36 * delta, false);
-    this.#tertiary = new RoadType(roadMat, outlineMat, 18e-4, 0.3 * delta, true);
-    this.#minor = new RoadType(roadMat, outlineMat, 17e-4, 0.22 * delta, true);
-    this.#minor_construction = new RoadType(roadMat, outlineMat, 16e-4, 0.2 * delta, false);
-    this.#service = new RoadType(roadMat, outlineMat, 15e-4, 0.16 * delta, true);
-    this.#service_construction = new RoadType(roadMat, outlineMat, 14e-4, 0.15 * delta, false);
-    this.#rail = new RoadType(roadMat, outlineMat, 13e-4, 0.18 * delta, false);
-    this.#transit = new RoadType(roadMat, outlineMat, 13e-4, 0.2 * delta, false);
-    this.#pedestrian = new RoadType(roadMat, outlineMat, 12e-4, 0.12 * delta, false);
-    this.#path = new RoadType(roadMat, outlineMat, 11e-4, 0.08 * delta, true);
-    this.#path_construction = new RoadType(roadMat, outlineMat, 11e-4, 0.08 * delta, false);
-    this.#track = new RoadType(roadMat, outlineMat, 1e-3, 0.1 * delta, false);
-    this.#pier = new RoadType(roadMat, outlineMat, 9e-4, 0.2, false);
-    this.#ferry = new RoadType(roadMat, outlineMat, 8e-4, 0.25, false);
+    __privateSet(this, _motorway, new RoadType(roadMat, outlineMat, 25e-4, 0.55 * delta, true));
+    __privateSet(this, _trunk, new RoadType(roadMat, outlineMat, 24e-4, 0.5 * delta, false));
+    __privateSet(this, _trunk_construction, new RoadType(roadMat, outlineMat, 23e-4, 0.48 * delta, false));
+    __privateSet(this, _primary, new RoadType(roadMat, outlineMat, 22e-4, 0.45 * delta, true));
+    __privateSet(this, _primary_construction, new RoadType(roadMat, outlineMat, 21e-4, 0.43 * delta, false));
+    __privateSet(this, _secondary, new RoadType(roadMat, outlineMat, 2e-3, 0.38 * delta, true));
+    __privateSet(this, _secondary_construction, new RoadType(roadMat, outlineMat, 19e-4, 0.36 * delta, false));
+    __privateSet(this, _tertiary, new RoadType(roadMat, outlineMat, 18e-4, 0.3 * delta, true));
+    __privateSet(this, _minor, new RoadType(roadMat, outlineMat, 17e-4, 0.22 * delta, true));
+    __privateSet(this, _minor_construction, new RoadType(roadMat, outlineMat, 16e-4, 0.2 * delta, false));
+    __privateSet(this, _service, new RoadType(roadMat, outlineMat, 15e-4, 0.16 * delta, true));
+    __privateSet(this, _service_construction, new RoadType(roadMat, outlineMat, 14e-4, 0.15 * delta, false));
+    __privateSet(this, _rail, new RoadType(roadMat, outlineMat, 13e-4, 0.18 * delta, false));
+    __privateSet(this, _transit, new RoadType(roadMat, outlineMat, 13e-4, 0.2 * delta, false));
+    __privateSet(this, _pedestrian, new RoadType(roadMat, outlineMat, 12e-4, 0.12 * delta, false));
+    __privateSet(this, _path, new RoadType(roadMat, outlineMat, 11e-4, 0.08 * delta, true));
+    __privateSet(this, _path_construction, new RoadType(roadMat, outlineMat, 11e-4, 0.08 * delta, false));
+    __privateSet(this, _track2, new RoadType(roadMat, outlineMat, 1e-3, 0.1 * delta, false));
+    __privateSet(this, _pier, new RoadType(roadMat, outlineMat, 9e-4, 0.2, false));
+    __privateSet(this, _ferry, new RoadType(roadMat, outlineMat, 8e-4, 0.25, false));
   }
+  /**
+   * Master visibility toggle for the entire transportation layer.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible9);
   }
+  /**
+   * Shared configuration defaults (joint segments, global outline width).
+   * @type {GeneralConfig}
+   */
   get generalConfig() {
-    return this.#generalConfig;
+    return __privateGet(this, _generalConfig);
   }
+  /** @type {RoadType} */
   get motorway() {
-    return this.#motorway;
+    return __privateGet(this, _motorway);
   }
+  /** @type {RoadType} */
   get trunk() {
-    return this.#trunk;
+    return __privateGet(this, _trunk);
   }
+  /** @type {RoadType} */
   get trunk_construction() {
-    return this.#trunk_construction;
+    return __privateGet(this, _trunk_construction);
   }
+  /** @type {RoadType} */
   get primary() {
-    return this.#primary;
+    return __privateGet(this, _primary);
   }
+  /** @type {RoadType} */
   get primary_construction() {
-    return this.#primary_construction;
+    return __privateGet(this, _primary_construction);
   }
+  /** @type {RoadType} */
   get secondary() {
-    return this.#secondary;
+    return __privateGet(this, _secondary);
   }
+  /** @type {RoadType} */
   get secondary_construction() {
-    return this.#secondary_construction;
+    return __privateGet(this, _secondary_construction);
   }
+  /** @type {RoadType} */
   get tertiary() {
-    return this.#tertiary;
+    return __privateGet(this, _tertiary);
   }
+  /** @type {RoadType} */
   get minor() {
-    return this.#minor;
+    return __privateGet(this, _minor);
   }
+  /** @type {RoadType} */
   get minor_construction() {
-    return this.#minor_construction;
+    return __privateGet(this, _minor_construction);
   }
+  /** @type {RoadType} */
   get service() {
-    return this.#service;
+    return __privateGet(this, _service);
   }
+  /** @type {RoadType} */
   get service_construction() {
-    return this.#service_construction;
+    return __privateGet(this, _service_construction);
   }
+  /** @type {RoadType} */
   get rail() {
-    return this.#rail;
+    return __privateGet(this, _rail);
   }
+  /** @type {RoadType} */
   get transit() {
-    return this.#transit;
+    return __privateGet(this, _transit);
   }
+  /** @type {RoadType} */
   get pedestrian() {
-    return this.#pedestrian;
+    return __privateGet(this, _pedestrian);
   }
+  /** @type {RoadType} */
   get path() {
-    return this.#path;
+    return __privateGet(this, _path);
   }
+  /** @type {RoadType} */
   get path_construction() {
-    return this.#path_construction;
+    return __privateGet(this, _path_construction);
   }
+  /** @type {RoadType} */
   get track() {
-    return this.#track;
+    return __privateGet(this, _track2);
   }
+  /** @type {RoadType} */
   get pier() {
-    return this.#pier;
+    return __privateGet(this, _pier);
   }
+  /** @type {RoadType} */
   get ferry() {
-    return this.#ferry;
+    return __privateGet(this, _ferry);
   }
+  /**
+   * Resolves the effective outline width for a road type:
+   * returns the type's own `outlineWidth` if set, otherwise falls back to
+   * {@link GeneralConfig.outlineWidth}.
+   * @param {RoadType} roadType
+   * @returns {number}
+   */
   resolveOutlineWidth(roadType) {
-    return roadType.outlineWidth ?? this.#generalConfig.outlineWidth;
+    return roadType.outlineWidth ?? __privateGet(this, _generalConfig).outlineWidth;
   }
+  /**
+   * Sets `outlineWidth` on every road type and on `generalConfig`.
+   * @param {number} width
+   */
   setOutlineWidthAll(width) {
-    for (const roadType of this.#allRoadTypes()) {
+    for (const roadType of __privateMethod(this, _TransportationLayer_instances, allRoadTypes_fn).call(this)) {
       roadType.outlineWidth = width;
     }
-    this.#generalConfig.outlineWidth = width;
+    __privateGet(this, _generalConfig).outlineWidth = width;
   }
+  /**
+   * Resets the per-type outline width on all road types (falls back to `generalConfig`).
+   */
   resetOutlineWidthAll() {
-    for (const roadType of this.#allRoadTypes()) {
+    for (const roadType of __privateMethod(this, _TransportationLayer_instances, allRoadTypes_fn).call(this)) {
       roadType.resetOutlineWidth();
     }
   }
+  /**
+   * Sets master layer visibility and propagates to all road types.
+   * @param {boolean} isVisible
+   */
   setVisible(isVisible) {
-    this.#isVisible = !!isVisible;
-    for (const roadType of this.#allRoadTypes()) {
+    __privateSet(this, _isVisible9, !!isVisible);
+    for (const roadType of __privateMethod(this, _TransportationLayer_instances, allRoadTypes_fn).call(this)) {
       roadType.setVisible(isVisible);
     }
   }
+  /**
+   * Replaces the material on every road type with a clone of the provided materials.
+   * @param {THREE.Material} material - Fill material.
+   * @param {THREE.Material} [outlineMaterial] - Optional outline material.
+   */
   setAllMaterials(material, outlineMaterial) {
     if (material && !(material instanceof THREE5.Material)) {
       console.warn("ThreeGeoPlay: Invalid material");
       return;
     }
-    for (const roadType of this.#allRoadTypes()) {
+    for (const roadType of __privateMethod(this, _TransportationLayer_instances, allRoadTypes_fn).call(this)) {
       if (material) roadType.material = material.clone();
       if (outlineMaterial) roadType.outlineMaterial = outlineMaterial.clone();
     }
   }
+  /**
+   * Returns a road type by its OSM class name.
+   * @param {TransportClassName} name - The OSM transport class name.
+   * @returns {RoadType|null} The matching type, or `null` if not found.
+   */
   getTypeByName(name) {
-    return this.#roadTypeMap().get(name) ?? null;
-  }
-  #allRoadTypes() {
-    return [
-      this.#motorway,
-      this.#trunk,
-      this.#trunk_construction,
-      this.#primary,
-      this.#primary_construction,
-      this.#secondary,
-      this.#secondary_construction,
-      this.#tertiary,
-      this.#minor,
-      this.#minor_construction,
-      this.#service,
-      this.#service_construction,
-      this.#rail,
-      this.#transit,
-      this.#pedestrian,
-      this.#path,
-      this.#path_construction,
-      this.#track,
-      this.#pier,
-      this.#ferry
-    ];
-  }
-  #roadTypeMap() {
-    return /* @__PURE__ */ new Map([
-      ["motorway", this.#motorway],
-      ["trunk", this.#trunk],
-      ["trunk_construction", this.#trunk_construction],
-      ["primary", this.#primary],
-      ["primary_construction", this.#primary_construction],
-      ["secondary", this.#secondary],
-      ["secondary_construction", this.#secondary_construction],
-      ["tertiary", this.#tertiary],
-      ["minor", this.#minor],
-      ["minor_construction", this.#minor_construction],
-      ["service", this.#service],
-      ["service_construction", this.#service_construction],
-      ["rail", this.#rail],
-      ["transit", this.#transit],
-      ["pedestrian", this.#pedestrian],
-      ["path", this.#path],
-      ["path_construction", this.#path_construction],
-      ["track", this.#track],
-      ["pier", this.#pier],
-      ["ferry", this.#ferry]
-    ]);
+    return __privateMethod(this, _TransportationLayer_instances, roadTypeMap_fn).call(this).get(name) ?? null;
   }
 };
+_isVisible9 = new WeakMap();
+_generalConfig = new WeakMap();
+_primary = new WeakMap();
+_secondary = new WeakMap();
+_tertiary = new WeakMap();
+_minor = new WeakMap();
+_service = new WeakMap();
+_pedestrian = new WeakMap();
+_path = new WeakMap();
+_minor_construction = new WeakMap();
+_rail = new WeakMap();
+_transit = new WeakMap();
+_track2 = new WeakMap();
+_trunk = new WeakMap();
+_pier = new WeakMap();
+_primary_construction = new WeakMap();
+_ferry = new WeakMap();
+_secondary_construction = new WeakMap();
+_path_construction = new WeakMap();
+_motorway = new WeakMap();
+_trunk_construction = new WeakMap();
+_service_construction = new WeakMap();
+_TransportationLayer_instances = new WeakSet();
+/**
+ * @returns {RoadType[]}
+ * @private
+ */
+allRoadTypes_fn = function() {
+  return [
+    __privateGet(this, _motorway),
+    __privateGet(this, _trunk),
+    __privateGet(this, _trunk_construction),
+    __privateGet(this, _primary),
+    __privateGet(this, _primary_construction),
+    __privateGet(this, _secondary),
+    __privateGet(this, _secondary_construction),
+    __privateGet(this, _tertiary),
+    __privateGet(this, _minor),
+    __privateGet(this, _minor_construction),
+    __privateGet(this, _service),
+    __privateGet(this, _service_construction),
+    __privateGet(this, _rail),
+    __privateGet(this, _transit),
+    __privateGet(this, _pedestrian),
+    __privateGet(this, _path),
+    __privateGet(this, _path_construction),
+    __privateGet(this, _track2),
+    __privateGet(this, _pier),
+    __privateGet(this, _ferry)
+  ];
+};
+/**
+ * @returns {Map<string, RoadType>}
+ * @private
+ */
+roadTypeMap_fn = function() {
+  return /* @__PURE__ */ new Map([
+    ["motorway", __privateGet(this, _motorway)],
+    ["trunk", __privateGet(this, _trunk)],
+    ["trunk_construction", __privateGet(this, _trunk_construction)],
+    ["primary", __privateGet(this, _primary)],
+    ["primary_construction", __privateGet(this, _primary_construction)],
+    ["secondary", __privateGet(this, _secondary)],
+    ["secondary_construction", __privateGet(this, _secondary_construction)],
+    ["tertiary", __privateGet(this, _tertiary)],
+    ["minor", __privateGet(this, _minor)],
+    ["minor_construction", __privateGet(this, _minor_construction)],
+    ["service", __privateGet(this, _service)],
+    ["service_construction", __privateGet(this, _service_construction)],
+    ["rail", __privateGet(this, _rail)],
+    ["transit", __privateGet(this, _transit)],
+    ["pedestrian", __privateGet(this, _pedestrian)],
+    ["path", __privateGet(this, _path)],
+    ["path_construction", __privateGet(this, _path_construction)],
+    ["track", __privateGet(this, _track2)],
+    ["pier", __privateGet(this, _pier)],
+    ["ferry", __privateGet(this, _ferry)]
+  ]);
+};
 
 // src/style/WaterWayLayer.js
 var THREE6 = __toESM(require("three"));
@@ -6412,307 +6939,489 @@ function makeWaterwayMaterial(color, transparent = true, opacity = 0.9) {
   });
 }
 function makeOutlineMaterial2(color) {
-  return new THREE6.MeshBasicMaterial({
-    color,
-    side: THREE6.BackSide
-  });
+  return new THREE6.MeshBasicMaterial({ color, side: THREE6.BackSide });
 }
+var _isVisible10, _material6, _outlineMaterial2, _YOrder6, _outlineWidth3, _lineWidth2;
 var WaterwayType = class {
-  #isVisible = true;
-  #material;
-  #outlineMaterial;
-  #YOrder;
-  #outlineWidth = 0.1;
-  #lineWidth = 1;
+  /**
+   * @param {THREE.Material} material - Fill material.
+   * @param {THREE.Material} outlineMaterial - Outline material.
+   * @param {number} YOrder - Y-axis render order offset.
+   * @param {number} [lineWidth=0] - Half-width of the rendered line in world units.
+   */
   constructor(material, outlineMaterial, YOrder, lineWidth = 0) {
-    this.#material = material;
-    this.#outlineMaterial = outlineMaterial;
-    this.#YOrder = YOrder;
-    this.#lineWidth = lineWidth;
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible10, true);
+    /** @type {THREE.Material} */
+    __privateAdd(this, _material6);
+    /** @type {THREE.Material} */
+    __privateAdd(this, _outlineMaterial2);
+    /** @type {number} */
+    __privateAdd(this, _YOrder6);
+    /** @type {number} */
+    __privateAdd(this, _outlineWidth3, 0.1);
+    /** @type {number} */
+    __privateAdd(this, _lineWidth2, 1);
+    __privateSet(this, _material6, material);
+    __privateSet(this, _outlineMaterial2, outlineMaterial);
+    __privateSet(this, _YOrder6, YOrder);
+    __privateSet(this, _lineWidth2, lineWidth);
   }
+  /**
+   * Whether this waterway type is rendered.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible10);
   }
   set isVisible(v) {
-    this.#isVisible = !!v;
+    __privateSet(this, _isVisible10, !!v);
   }
+  /**
+   * Sets visibility (alias for the `isVisible` setter).
+   * @param {boolean} v
+   */
   setVisible(v) {
-    this.#isVisible = !!v;
+    __privateSet(this, _isVisible10, !!v);
   }
+  /**
+   * The Three.js fill material for this waterway type.
+   * Must be a {@link THREE.Material} instance.
+   * @type {THREE.Material}
+   */
   get material() {
-    return this.#material;
+    return __privateGet(this, _material6);
   }
   set material(m) {
     if (m && !(m instanceof THREE6.Material)) {
       console.warn("GeoPlay: material must be a THREE.Material instance");
       return;
     }
-    this.#material = m;
+    __privateSet(this, _material6, m);
   }
+  /**
+   * The Three.js outline material for this waterway type.
+   * Must be a {@link THREE.Material} instance.
+   * @type {THREE.Material}
+   */
   get outlineMaterial() {
-    return this.#outlineMaterial;
+    return __privateGet(this, _outlineMaterial2);
   }
   set outlineMaterial(m) {
     if (m && !(m instanceof THREE6.Material)) {
       console.warn("GeoPlay: outlineMaterial must be a THREE.Material instance");
       return;
     }
-    this.#outlineMaterial = m;
+    __privateSet(this, _outlineMaterial2, m);
   }
+  /**
+   * Y-axis render order offset for depth sorting.
+   * @type {number}
+   */
   get YOrder() {
-    return this.#YOrder;
+    return __privateGet(this, _YOrder6);
   }
   set YOrder(v) {
-    this.#YOrder = v;
+    __privateSet(this, _YOrder6, v);
   }
+  /**
+   * Half-width of the rendered line in world units. Must be ≥ 0.
+   * @type {number}
+   */
   get lineWidth() {
-    return this.#lineWidth;
+    return __privateGet(this, _lineWidth2);
   }
   set lineWidth(v) {
     if (typeof v !== "number" || isNaN(v) || v < 0) {
       console.warn(`GeoPlay: lineWidth must be a non-negative number (received: ${v})`);
       return;
     }
-    this.#lineWidth = v;
+    __privateSet(this, _lineWidth2, v);
   }
+  /**
+   * Width of the outline in world units. Set to `null` to inherit from the layer default.
+   * @type {number|null}
+   */
   get outlineWidth() {
-    return this.#outlineWidth;
+    return __privateGet(this, _outlineWidth3);
   }
   set outlineWidth(v) {
     if (v !== null && (typeof v !== "number" || isNaN(v) || v < 0)) {
       console.warn(`GeoPlay: outlineWidth must be a non-negative number or null (received: ${v})`);
       return;
     }
-    this.#outlineWidth = v;
+    __privateSet(this, _outlineWidth3, v);
   }
+  /**
+   * Resets `outlineWidth` to `null` so the layer-level default is used instead.
+   */
   resetOutlineWidth() {
-    this.#outlineWidth = null;
+    __privateSet(this, _outlineWidth3, null);
   }
 };
+_isVisible10 = new WeakMap();
+_material6 = new WeakMap();
+_outlineMaterial2 = new WeakMap();
+_YOrder6 = new WeakMap();
+_outlineWidth3 = new WeakMap();
+_lineWidth2 = new WeakMap();
+var _isVisible11, _river2, _stream, _tidal_channel, _flowline, _canal, _drain, _ditch, _pressurised, _waterwayMap, _WaterwayLayer_instances, allWaterways_fn;
 var WaterwayLayer = class {
-  #isVisible = true;
-  #river;
-  #stream;
-  #tidal_channel;
-  #flowline;
-  #canal;
-  #drain;
-  #ditch;
-  #pressurised;
-  #waterwayMap;
   constructor() {
+    __privateAdd(this, _WaterwayLayer_instances);
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible11, true);
+    /** @type {WaterwayType} */
+    __privateAdd(this, _river2);
+    /** @type {WaterwayType} */
+    __privateAdd(this, _stream);
+    /** @type {WaterwayType} */
+    __privateAdd(this, _tidal_channel);
+    /** @type {WaterwayType} */
+    __privateAdd(this, _flowline);
+    /** @type {WaterwayType} */
+    __privateAdd(this, _canal);
+    /** @type {WaterwayType} */
+    __privateAdd(this, _drain);
+    /** @type {WaterwayType} */
+    __privateAdd(this, _ditch);
+    /** @type {WaterwayType} */
+    __privateAdd(this, _pressurised);
+    /** @type {Map<string, WaterwayType>} */
+    __privateAdd(this, _waterwayMap);
     const delta = 0.2;
     const waterMat = makeWaterwayMaterial(2062260);
     const outlineMat = makeOutlineMaterial2(872314);
-    this.#river = new WaterwayType(waterMat, outlineMat, 1e-4, 0.5 * delta);
-    this.#stream = new WaterwayType(waterMat, outlineMat, 12e-5, 0.3 * delta);
-    this.#tidal_channel = new WaterwayType(waterMat, outlineMat, 11e-5, 0.4 * delta);
-    this.#flowline = new WaterwayType(waterMat, outlineMat, 9e-5, 0.2 * delta);
-    this.#canal = new WaterwayType(waterMat, outlineMat, 1e-4, 0.4 * delta);
-    this.#drain = new WaterwayType(waterMat, outlineMat, 8e-5, 0.2 * delta);
-    this.#ditch = new WaterwayType(waterMat, outlineMat, 7e-5, 0.15 * delta);
-    this.#pressurised = new WaterwayType(waterMat, outlineMat, 5e-5, 0.1 * delta);
-    this.#waterwayMap = /* @__PURE__ */ new Map([
-      ["river", this.#river],
-      ["stream", this.#stream],
-      ["tidal_channel", this.#tidal_channel],
-      ["flowline", this.#flowline],
-      ["canal", this.#canal],
-      ["drain", this.#drain],
-      ["ditch", this.#ditch],
-      ["pressurised", this.#pressurised]
-    ]);
+    __privateSet(this, _river2, new WaterwayType(waterMat, outlineMat, 1e-4, 0.5 * delta));
+    __privateSet(this, _stream, new WaterwayType(waterMat, outlineMat, 12e-5, 0.3 * delta));
+    __privateSet(this, _tidal_channel, new WaterwayType(waterMat, outlineMat, 11e-5, 0.4 * delta));
+    __privateSet(this, _flowline, new WaterwayType(waterMat, outlineMat, 9e-5, 0.2 * delta));
+    __privateSet(this, _canal, new WaterwayType(waterMat, outlineMat, 1e-4, 0.4 * delta));
+    __privateSet(this, _drain, new WaterwayType(waterMat, outlineMat, 8e-5, 0.2 * delta));
+    __privateSet(this, _ditch, new WaterwayType(waterMat, outlineMat, 7e-5, 0.15 * delta));
+    __privateSet(this, _pressurised, new WaterwayType(waterMat, outlineMat, 5e-5, 0.1 * delta));
+    __privateSet(this, _waterwayMap, /* @__PURE__ */ new Map([
+      ["river", __privateGet(this, _river2)],
+      ["stream", __privateGet(this, _stream)],
+      ["tidal_channel", __privateGet(this, _tidal_channel)],
+      ["flowline", __privateGet(this, _flowline)],
+      ["canal", __privateGet(this, _canal)],
+      ["drain", __privateGet(this, _drain)],
+      ["ditch", __privateGet(this, _ditch)],
+      ["pressurised", __privateGet(this, _pressurised)]
+    ]));
   }
+  /**
+   * Master visibility toggle. Setting this also propagates to all individual waterway types.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible11);
   }
   set isVisible(v) {
-    this.#isVisible = !!v;
-    this.#allWaterways().forEach((w) => w.setVisible(v));
+    __privateSet(this, _isVisible11, !!v);
+    __privateMethod(this, _WaterwayLayer_instances, allWaterways_fn).call(this).forEach((w) => w.setVisible(v));
   }
+  /** @type {WaterwayType} */
   get river() {
-    return this.#river;
+    return __privateGet(this, _river2);
   }
+  /** @type {WaterwayType} */
   get stream() {
-    return this.#stream;
+    return __privateGet(this, _stream);
   }
+  /** @type {WaterwayType} */
   get tidal_channel() {
-    return this.#tidal_channel;
+    return __privateGet(this, _tidal_channel);
   }
+  /** @type {WaterwayType} */
   get flowline() {
-    return this.#flowline;
+    return __privateGet(this, _flowline);
   }
+  /** @type {WaterwayType} */
   get canal() {
-    return this.#canal;
+    return __privateGet(this, _canal);
   }
+  /** @type {WaterwayType} */
   get drain() {
-    return this.#drain;
+    return __privateGet(this, _drain);
   }
+  /** @type {WaterwayType} */
   get ditch() {
-    return this.#ditch;
+    return __privateGet(this, _ditch);
   }
+  /** @type {WaterwayType} */
   get pressurised() {
-    return this.#pressurised;
+    return __privateGet(this, _pressurised);
   }
+  /**
+   * Returns a waterway type by its OSM class name.
+   * @param {'river'|'stream'|'tidal_channel'|'flowline'|'canal'|'drain'|'ditch'|'pressurised'} name
+   * @returns {WaterwayType|null} The matching type, or `null` if not found.
+   */
   getTypeByName(name) {
-    return this.#waterwayMap.get(name) ?? null;
+    return __privateGet(this, _waterwayMap).get(name) ?? null;
   }
+  /**
+   * Replaces fill and outline materials on every waterway type with clones of the provided materials.
+   * @param {THREE.Material} material - A valid Three.js fill material.
+   * @param {THREE.Material} [outlineMaterial] - Optional outline material.
+   */
   setAllMaterials(material, outlineMaterial) {
     if (!(material instanceof THREE6.Material)) {
       console.warn("GeoPlay: Invalid material, must be THREE.Material");
       return;
     }
-    this.#allWaterways().forEach((w) => {
+    __privateMethod(this, _WaterwayLayer_instances, allWaterways_fn).call(this).forEach((w) => {
       w.material = material.clone();
       if (outlineMaterial) w.outlineMaterial = outlineMaterial.clone();
     });
   }
+  /**
+   * Sets `outlineWidth` on all waterway types.
+   * @param {number} width
+   */
   setOutlineWidthAll(width) {
-    this.#allWaterways().forEach((w) => w.outlineWidth = width);
+    __privateMethod(this, _WaterwayLayer_instances, allWaterways_fn).call(this).forEach((w) => w.outlineWidth = width);
   }
+  /**
+   * Resets `outlineWidth` to `null` on all waterway types (falls back to layer default).
+   */
   resetOutlineWidthAll() {
-    this.#allWaterways().forEach((w) => w.resetOutlineWidth());
+    __privateMethod(this, _WaterwayLayer_instances, allWaterways_fn).call(this).forEach((w) => w.resetOutlineWidth());
   }
+  /**
+   * Sets `lineWidth` on all waterway types.
+   * @param {number} width
+   */
   setLineWidthAll(width) {
-    this.#allWaterways().forEach((w) => w.lineWidth = width);
+    __privateMethod(this, _WaterwayLayer_instances, allWaterways_fn).call(this).forEach((w) => w.lineWidth = width);
   }
+  /**
+   * Sets visibility on all individual waterway types.
+   * @param {boolean} isVisible
+   */
   setVisibleAll(isVisible) {
-    this.#allWaterways().forEach((w) => w.setVisible(isVisible));
-  }
-  #allWaterways() {
-    return [
-      this.#river,
-      this.#stream,
-      this.#tidal_channel,
-      this.#flowline,
-      this.#canal,
-      this.#drain,
-      this.#ditch,
-      this.#pressurised
-    ];
+    __privateMethod(this, _WaterwayLayer_instances, allWaterways_fn).call(this).forEach((w) => w.setVisible(isVisible));
   }
 };
+_isVisible11 = new WeakMap();
+_river2 = new WeakMap();
+_stream = new WeakMap();
+_tidal_channel = new WeakMap();
+_flowline = new WeakMap();
+_canal = new WeakMap();
+_drain = new WeakMap();
+_ditch = new WeakMap();
+_pressurised = new WeakMap();
+_waterwayMap = new WeakMap();
+_WaterwayLayer_instances = new WeakSet();
+/**
+ * @returns {WaterwayType[]}
+ * @private
+ */
+allWaterways_fn = function() {
+  return [
+    __privateGet(this, _river2),
+    __privateGet(this, _stream),
+    __privateGet(this, _tidal_channel),
+    __privateGet(this, _flowline),
+    __privateGet(this, _canal),
+    __privateGet(this, _drain),
+    __privateGet(this, _ditch),
+    __privateGet(this, _pressurised)
+  ];
+};
 
 // src/style/BackgroundLayer.js
 var THREE7 = __toESM(require("three"));
+var _isVisible12, _material7, _YOrder7;
 var BackgroundLayer = class {
-  /** @type {boolean} */
-  #isVisible = false;
-  /** @type {THREE.Material} */
-  #material;
-  /** @type {number} */
-  #YOrder = -0.05;
   constructor() {
-    this.#material = new THREE7.MeshBasicMaterial({
+    /** @type {boolean} */
+    __privateAdd(this, _isVisible12, false);
+    /** @type {THREE.Material} */
+    __privateAdd(this, _material7);
+    /** @type {number} */
+    __privateAdd(this, _YOrder7, -0.05);
+    __privateSet(this, _material7, new THREE7.MeshBasicMaterial({
       color: 15921129,
       transparent: false,
       side: THREE7.FrontSide
-    });
+    }));
   }
+  /**
+   * Whether this layer is visible.
+   * @type {boolean}
+   */
   get isVisible() {
-    return this.#isVisible;
+    return __privateGet(this, _isVisible12);
   }
   set isVisible(v) {
-    this.#isVisible = !!v;
+    __privateSet(this, _isVisible12, !!v);
   }
+  /**
+   * The Three.js material used to render the background.
+   * @type {THREE.Material}
+   */
   get material() {
-    return this.#material;
+    return __privateGet(this, _material7);
   }
   set material(v) {
-    this.#material = v;
+    __privateSet(this, _material7, v);
   }
+  /**
+   * Y-axis render order offset. Lower values render beneath other layers.
+   * @type {number}
+   */
   get YOrder() {
-    return this.#YOrder;
+    return __privateGet(this, _YOrder7);
   }
   set YOrder(v) {
-    this.#YOrder = v;
+    __privateSet(this, _YOrder7, v);
   }
+  /**
+   * Returns this instance regardless of name (background has a single type).
+   * @param {string} _name - Unused.
+   * @returns {BackgroundLayer} This instance.
+   */
   getTypeByName(_name) {
     return this;
   }
 };
+_isVisible12 = new WeakMap();
+_material7 = new WeakMap();
+_YOrder7 = new WeakMap();
 
 // src/style/MapStyle.js
+var _buildingLayer, _waterLayer, _waterwayLayer, _landUseLayer, _landCoverLayer, _transportationLayer, _backgroundLayer;
 var MapStyle = class {
-  #buildingLayer;
-  #waterLayer;
-  #waterwayLayer;
-  #landUseLayer;
-  #landCoverLayer;
-  #transportationLayer;
-  #backgroundLayer;
   constructor() {
-    this.#buildingLayer = new BuildingLayer();
-    this.#waterLayer = new WaterLayer();
-    this.#waterwayLayer = new WaterwayLayer();
-    this.#landUseLayer = new LandUseLayer();
-    this.#landCoverLayer = new LandCoverLayer();
-    this.#transportationLayer = new TransportationLayer();
-    this.#backgroundLayer = new BackgroundLayer();
+    /** @type {BuildingLayer} */
+    __privateAdd(this, _buildingLayer);
+    /** @type {WaterLayer} */
+    __privateAdd(this, _waterLayer);
+    /** @type {WaterwayLayer} */
+    __privateAdd(this, _waterwayLayer);
+    /** @type {LandUseLayer} */
+    __privateAdd(this, _landUseLayer);
+    /** @type {LandCoverLayer} */
+    __privateAdd(this, _landCoverLayer);
+    /** @type {TransportationLayer} */
+    __privateAdd(this, _transportationLayer);
+    /** @type {BackgroundLayer} */
+    __privateAdd(this, _backgroundLayer);
+    __privateSet(this, _buildingLayer, new BuildingLayer());
+    __privateSet(this, _waterLayer, new WaterLayer());
+    __privateSet(this, _waterwayLayer, new WaterwayLayer());
+    __privateSet(this, _landUseLayer, new LandUseLayer());
+    __privateSet(this, _landCoverLayer, new LandCoverLayer());
+    __privateSet(this, _transportationLayer, new TransportationLayer());
+    __privateSet(this, _backgroundLayer, new BackgroundLayer());
   }
+  /**
+   * Retrieves a style layer by its internal name.
+   * @param {'background'|'waterway'|'water'|'landcover'|'landuse'|'building'|'transportation'} layerName
+   * @returns {BackgroundLayer|WaterwayLayer|WaterLayer|LandCoverLayer|LandUseLayer|BuildingLayer|TransportationLayer|null}
+   */
   getStyleLayerByName(layerName) {
     switch (layerName) {
       case "background":
-        return this.#backgroundLayer;
+        return __privateGet(this, _backgroundLayer);
       case "waterway":
-        return this.#waterwayLayer;
+        return __privateGet(this, _waterwayLayer);
       case "water":
-        return this.#waterLayer;
+        return __privateGet(this, _waterLayer);
       case "landcover":
-        return this.#landCoverLayer;
+        return __privateGet(this, _landCoverLayer);
       case "landuse":
-        return this.#landUseLayer;
+        return __privateGet(this, _landUseLayer);
       case "building":
-        return this.#buildingLayer;
+        return __privateGet(this, _buildingLayer);
       case "transportation":
-        return this.#transportationLayer;
+        return __privateGet(this, _transportationLayer);
       default:
         return null;
     }
   }
+  /**
+   * The building extrusion layer.
+   * @type {BuildingLayer}
+   */
   get buildingLayer() {
-    return this.#buildingLayer;
+    return __privateGet(this, _buildingLayer);
   }
   set buildingLayer(layer) {
-    this.#buildingLayer = layer;
+    __privateSet(this, _buildingLayer, layer);
   }
+  /**
+   * The water body layer (lakes, oceans, rivers as polygons).
+   * @type {WaterLayer}
+   */
   get waterLayer() {
-    return this.#waterLayer;
+    return __privateGet(this, _waterLayer);
   }
   set waterLayer(layer) {
-    this.#waterLayer = layer;
+    __privateSet(this, _waterLayer, layer);
   }
+  /**
+   * The waterway layer (rivers, canals, ditches as lines).
+   * @type {WaterwayLayer}
+   */
   get waterwayLayer() {
-    return this.#waterwayLayer;
+    return __privateGet(this, _waterwayLayer);
   }
   set waterwayLayer(layer) {
-    this.#waterwayLayer = layer;
+    __privateSet(this, _waterwayLayer, layer);
   }
+  /**
+   * The land use layer (residential, industrial, parks, etc.).
+   * @type {LandUseLayer}
+   */
   get landUseLayer() {
-    return this.#landUseLayer;
+    return __privateGet(this, _landUseLayer);
   }
   set landUseLayer(layer) {
-    this.#landUseLayer = layer;
+    __privateSet(this, _landUseLayer, layer);
   }
+  /**
+   * The land cover layer (grass, wood, sand, etc.).
+   * @type {LandCoverLayer}
+   */
   get landCoverLayer() {
-    return this.#landCoverLayer;
+    return __privateGet(this, _landCoverLayer);
   }
   set landCoverLayer(layer) {
-    this.#landCoverLayer = layer;
+    __privateSet(this, _landCoverLayer, layer);
   }
+  /**
+   * The transportation layer (roads, rails, paths, etc.).
+   * @type {TransportationLayer}
+   */
   get transportationLayer() {
-    return this.#transportationLayer;
+    return __privateGet(this, _transportationLayer);
   }
   set transportationLayer(layer) {
-    this.#transportationLayer = layer;
+    __privateSet(this, _transportationLayer, layer);
   }
+  /**
+   * The background (base fill) layer rendered beneath all other layers.
+   * @type {BackgroundLayer}
+   */
   get backgroundLayer() {
-    return this.#backgroundLayer;
+    return __privateGet(this, _backgroundLayer);
   }
   set backgroundLayer(layer) {
-    this.#backgroundLayer = layer;
+    __privateSet(this, _backgroundLayer, layer);
   }
 };
+_buildingLayer = new WeakMap();
+_waterLayer = new WeakMap();
+_waterwayLayer = new WeakMap();
+_landUseLayer = new WeakMap();
+_landCoverLayer = new WeakMap();
+_transportationLayer = new WeakMap();
+_backgroundLayer = new WeakMap();
 
 // src/config/MapConfig.js
 var REBUILD_REQUIRED_FIELDS = Object.freeze({
@@ -6723,126 +7432,270 @@ var REBUILD_REQUIRED_FIELDS = Object.freeze({
   originLatLon: true
 });
 var TileLayout = Object.freeze({
+  /** Tiles are loaded in a circular pattern around the origin. */
   CIRCULAR: "circular",
+  /** Tiles are loaded in a square grid around the origin. */
   GRID: "grid"
 });
 var ViewMode = Object.freeze({
+  /**
+   * The map origin automatically follows the target set via
+   * {@link ThreeGeoPlay#setFollowTarget} (defaults to the camera).
+   */
   FOLLOW_TARGET: "follow_target",
+  /**
+   * The map origin is controlled manually via
+   * {@link ThreeGeoPlay#moveMapOriginToLatLon} or
+   * {@link ThreeGeoPlay#moveMapOriginToPosition}.
+   */
   MANUAL: "manual"
 });
+var _pbfTileProviderZXYurl, _zoomLevel, _renderDistance, _tileWorldSize, _tileLayout, _originLatLon, _worldOriginOffset, _viewMode, _mapStyle, _followUpdateIntervalInMs, _showTileBorders, _dirtyFields;
 var MapConfig = class {
-  #pbfTileProviderZXYurl = "https://tile.openstreetmap.org/{z}/{x}/{y}.pbf";
-  #zoomLevel = 18;
-  #renderDistance = 4;
-  #tileWorldSize = 1;
-  #tileLayout = TileLayout.CIRCULAR;
-  #originLatLon = { lat: 41.899689, lon: 12.43779 };
-  #worldOriginOffset = { x: 0, z: 0 };
-  #viewMode = ViewMode.FOLLOW_TARGET;
-  #mapStyle = new MapStyle();
-  #followUpdateIntervalInMs = 0;
-  #showTileBorders = false;
-  #dirtyFields = /* @__PURE__ */ new Set();
+  constructor() {
+    /**
+     * ZXY URL template for the PBF vector tile provider.
+     * Use `{z}`, `{x}`, `{y}` as placeholders.
+     * @type {string}
+     */
+    __privateAdd(this, _pbfTileProviderZXYurl, "https://tile.openstreetmap.org/{z}/{x}/{y}.pbf");
+    /**
+     * OSM zoom level (typically 14–18). Higher values load more detail.
+     * @type {number}
+     */
+    __privateAdd(this, _zoomLevel, 18);
+    /**
+     * Number of tiles to load in each direction from the origin tile.
+     * @type {number}
+     */
+    __privateAdd(this, _renderDistance, 4);
+    /**
+     * World-space size of one tile in Three.js units.
+     * @type {number}
+     */
+    __privateAdd(this, _tileWorldSize, 1);
+    /**
+     * @type {TileLayout}
+     */
+    __privateAdd(this, _tileLayout, TileLayout.CIRCULAR);
+    /**
+     * Geographic coordinates of the map origin.
+     * @type {LatLon}
+     */
+    __privateAdd(this, _originLatLon, { lat: 41.899689, lon: 12.43779 });
+    /**
+     * Additional X/Z offset applied to the world origin in Three.js units.
+     * @type {WorldOffset}
+     */
+    __privateAdd(this, _worldOriginOffset, { x: 0, z: 0 });
+    /**
+     * @type {ViewMode}
+     */
+    __privateAdd(this, _viewMode, ViewMode.FOLLOW_TARGET);
+    /**
+     * @type {MapStyle}
+     */
+    __privateAdd(this, _mapStyle, new MapStyle());
+    /**
+     * Minimum interval in milliseconds between follow-target updates.
+     * `0` means update every frame.
+     * @type {number}
+     */
+    __privateAdd(this, _followUpdateIntervalInMs, 0);
+    /**
+     * When true, draws a visible border around each loaded tile (useful for debugging).
+     * @type {boolean}
+     */
+    __privateAdd(this, _showTileBorders, false);
+    /** @type {Set<string>} */
+    __privateAdd(this, _dirtyFields, /* @__PURE__ */ new Set());
+  }
+  // ─── Dirty-state helpers ──────────────────────────────────────────────────
+  /**
+   * True if any property has been modified since the last {@link flushDirtyState} call.
+   * @type {boolean}
+   * @readonly
+   */
   get _isDirty() {
-    return this.#dirtyFields.size > 0;
+    return __privateGet(this, _dirtyFields).size > 0;
   }
+  /**
+   * The set of field names that have been modified since the last flush.
+   * @type {Set<string>}
+   * @readonly
+   */
   get _dirtyFields() {
-    return this.#dirtyFields;
+    return __privateGet(this, _dirtyFields);
   }
+  /**
+   * True if any dirty field requires a full tile rebuild (new fetch + geometry generation).
+   * @type {boolean}
+   * @readonly
+   */
   get requiresRebuild() {
-    return [...this.#dirtyFields].some((f) => REBUILD_REQUIRED_FIELDS[f] === true);
+    return [...__privateGet(this, _dirtyFields)].some((f) => REBUILD_REQUIRED_FIELDS[f] === true);
   }
+  /**
+   * Scale factor relative to zoom level 18.
+   * Useful for sizing world-space objects consistently across zoom levels.
+   * @type {number}
+   * @readonly
+   */
   get zoomScaleFactor() {
-    return 1 / Math.pow(2, 18 - this.#zoomLevel);
+    return 1 / Math.pow(2, 18 - __privateGet(this, _zoomLevel));
   }
+  /**
+   * Clears the dirty-field set. Called automatically by {@link ThreeGeoPlay#onFrameUpdate}
+   * after processing changes.
+   */
   flushDirtyState() {
-    this.#dirtyFields.clear();
+    __privateGet(this, _dirtyFields).clear();
   }
+  // ─── Properties ──────────────────────────────────────────────────────────
+  /**
+   * ZXY URL template for the PBF tile provider.
+   * Changing this triggers a full tile rebuild.
+   * @type {string}
+   */
   get pbfTileProviderZXYurl() {
-    return this.#pbfTileProviderZXYurl;
+    return __privateGet(this, _pbfTileProviderZXYurl);
   }
   set pbfTileProviderZXYurl(value) {
-    this.#pbfTileProviderZXYurl = value;
-    this.#dirtyFields.add("pbfTileProviderZXYurl");
+    __privateSet(this, _pbfTileProviderZXYurl, value);
+    __privateGet(this, _dirtyFields).add("pbfTileProviderZXYurl");
   }
+  /**
+   * OSM zoom level. Changing this triggers a full tile rebuild.
+   * @type {number}
+   */
   get zoomLevel() {
-    return this.#zoomLevel;
+    return __privateGet(this, _zoomLevel);
   }
   set zoomLevel(value) {
-    this.#zoomLevel = value;
-    this.#dirtyFields.add("zoomLevel");
+    __privateSet(this, _zoomLevel, value);
+    __privateGet(this, _dirtyFields).add("zoomLevel");
   }
+  /**
+   * Number of tiles to load around the origin. Changing this re-applies the tile center.
+   * @type {number}
+   */
   get renderDistance() {
-    return this.#renderDistance;
+    return __privateGet(this, _renderDistance);
   }
   set renderDistance(value) {
-    this.#renderDistance = Math.round(value);
-    this.#dirtyFields.add("renderDistance");
+    __privateSet(this, _renderDistance, Math.round(value));
+    __privateGet(this, _dirtyFields).add("renderDistance");
   }
+  /**
+   * World-space size of one tile in Three.js units. Must be a positive number.
+   * Changing this rescales existing tiles without a full rebuild.
+   * @type {number}
+   */
   get tileWorldSize() {
-    return this.#tileWorldSize;
+    return __privateGet(this, _tileWorldSize);
   }
   set tileWorldSize(value) {
     if (typeof value !== "number" || isNaN(value) || value <= 0) {
       throw new Error(`ThreeGeoPlay : Invalid tileWorldSize: ${value}. Must be a positive number`);
     }
-    this.#tileWorldSize = value;
-    this.#dirtyFields.add("tileWorldSize");
+    __privateSet(this, _tileWorldSize, value);
+    __privateGet(this, _dirtyFields).add("tileWorldSize");
   }
+  /**
+   * Tile loading pattern. Use {@link TileLayout} enum values.
+   * Changing this triggers a full tile rebuild.
+   * @type {TileLayout}
+   */
   get tileLayout() {
-    return this.#tileLayout;
+    return __privateGet(this, _tileLayout);
   }
   set tileLayout(value) {
     if (!Object.values(TileLayout).includes(value)) {
       throw new Error(`ThreeGeoPlay : Invalid tile layout: ${value}. Use TileLayout.CIRCULAR or TileLayout.GRID`);
     }
-    this.#tileLayout = value;
-    this.#dirtyFields.add("tileLayout");
+    __privateSet(this, _tileLayout, value);
+    __privateGet(this, _dirtyFields).add("tileLayout");
   }
+  /**
+   * Geographic coordinates of the map origin.
+   * Changing this triggers a full tile rebuild.
+   * @type {LatLon}
+   */
   get originLatLon() {
-    return this.#originLatLon;
+    return __privateGet(this, _originLatLon);
   }
   set originLatLon(value) {
-    this.#originLatLon = value;
-    this.#dirtyFields.add("originLatLon");
+    __privateSet(this, _originLatLon, value);
+    __privateGet(this, _dirtyFields).add("originLatLon");
   }
+  /**
+   * Additional X/Z offset applied to the world origin.
+   * Changing this triggers a full tile rebuild.
+   * @type {WorldOffset}
+   */
   get worldOriginOffset() {
-    return this.#worldOriginOffset;
+    return __privateGet(this, _worldOriginOffset);
   }
   set worldOriginOffset(value) {
     if (!value || typeof value.x !== "number" || isNaN(value.x) || typeof value.z !== "number" || isNaN(value.z)) {
       throw new Error("Invalid worldOriginOffset: x and z must be valid numbers");
     }
-    this.#worldOriginOffset = { x: value.x, z: value.z };
-    this.#dirtyFields.add("worldOriginOffset");
+    __privateSet(this, _worldOriginOffset, { x: value.x, z: value.z });
+    __privateGet(this, _dirtyFields).add("worldOriginOffset");
   }
+  /**
+   * Camera/map tracking mode. Use {@link ViewMode} enum values.
+   * @type {ViewMode}
+   */
   get viewMode() {
-    return this.#viewMode;
+    return __privateGet(this, _viewMode);
   }
   set viewMode(value) {
     if (!Object.values(ViewMode).includes(value)) {
       throw new Error(`ThreeGeoPlay : Invalid view mode: ${value}. Use ViewMode.FOLLOW_TARGET or ViewMode.MANUAL`);
     }
-    this.#viewMode = value;
-    this.#dirtyFields.add("viewMode");
+    __privateSet(this, _viewMode, value);
+    __privateGet(this, _dirtyFields).add("viewMode");
   }
+  /**
+   * The active {@link MapStyle} instance.
+   * Changing this triggers a material update on all tiles.
+   * @type {MapStyle}
+   */
   get mapStyle() {
-    return this.#mapStyle;
+    return __privateGet(this, _mapStyle);
   }
   set mapStyle(value) {
-    this.#mapStyle = value;
-    this.#dirtyFields.add("mapStyle");
+    __privateSet(this, _mapStyle, value);
+    __privateGet(this, _dirtyFields).add("mapStyle");
   }
+  /**
+   * Minimum interval in milliseconds between follow-target tile updates.
+   * `0` means the map updates every frame.
+   * @type {number}
+   * @readonly
+   */
   get FollowUpdateInterval() {
-    return this.#followUpdateIntervalInMs;
+    return __privateGet(this, _followUpdateIntervalInMs);
   }
+  /**
+   * When true, a visible border is drawn around each loaded tile.
+   * Useful for debugging tile boundaries.
+   * @type {boolean}
+   */
   get showTileBorders() {
-    return this.#showTileBorders;
+    return __privateGet(this, _showTileBorders);
   }
   set showTileBorders(value) {
-    this.#showTileBorders = value;
-    this.#dirtyFields.add("showTileBorders");
+    __privateSet(this, _showTileBorders, value);
+    __privateGet(this, _dirtyFields).add("showTileBorders");
   }
+  /**
+   * Sets the minimum interval between follow-target updates.
+   * Pass `0` to update every frame (default).
+   * @param {number} intervalMs - Interval in milliseconds. Must be ≥ 0.
+   * @throws {Error} If `intervalMs` is not a non-negative number.
+   */
   setFollowUpdateInterval(intervalMs) {
     if (typeof intervalMs !== "number" || isNaN(intervalMs)) {
       throw new Error(`ThreeGeoPlay : Invalid interval: ${intervalMs}. Must be a number`);
@@ -6850,10 +7703,22 @@ var MapConfig = class {
     if (intervalMs < 0) {
       throw new Error(`ThreeGeoPlay : Invalid interval: ${intervalMs}. Must be 0 or positive`);
     }
-    this.#followUpdateIntervalInMs = intervalMs;
-    this.#dirtyFields.add("followUpdateIntervalInMs");
+    __privateSet(this, _followUpdateIntervalInMs, intervalMs);
+    __privateGet(this, _dirtyFields).add("followUpdateIntervalInMs");
   }
 };
+_pbfTileProviderZXYurl = new WeakMap();
+_zoomLevel = new WeakMap();
+_renderDistance = new WeakMap();
+_tileWorldSize = new WeakMap();
+_tileLayout = new WeakMap();
+_originLatLon = new WeakMap();
+_worldOriginOffset = new WeakMap();
+_viewMode = new WeakMap();
+_mapStyle = new WeakMap();
+_followUpdateIntervalInMs = new WeakMap();
+_showTileBorders = new WeakMap();
+_dirtyFields = new WeakMap();
 
 // src/geo_utils/projection.js
 function geoToTileXY(dLon, dLat, zoom) {
@@ -6878,7 +7743,7 @@ function geoToTileXYFloat(dLon, dLat, zoom) {
 // src/utils/fetchTileData.js
 async function fetchTileData(url, tilePosition = null, signal = null) {
   const PERMANENT_ERRORS = /* @__PURE__ */ new Set([401, 403, 404, 410]);
-  if (signal == null ? void 0 : signal.aborted) throw new DOMException("Aborted", "AbortError");
+  if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
   const res = await fetch(url, { signal });
   if (PERMANENT_ERRORS.has(res.status)) return null;
   if (!res.ok) throw new Error(`HTTP error ${res.status}`);
@@ -7067,128 +7932,126 @@ function simplifyLine(line, epsilon) {
 
 // src/utils/TileFeatureCollector.js
 var FeatureGroup = class {
-  identifier;
-  style;
-  layerName = "";
-  featureClass = "";
   constructor(identifier, style) {
+    __publicField(this, "identifier");
+    __publicField(this, "style");
+    __publicField(this, "layerName", "");
+    __publicField(this, "featureClass", "");
     this.identifier = identifier;
     this.style = style;
   }
 };
 var LineGroup = class extends FeatureGroup {
-  lines = [];
+  constructor() {
+    super(...arguments);
+    __publicField(this, "lines", []);
+  }
 };
 var PolygonGroup = class extends FeatureGroup {
-  features = [];
+  constructor() {
+    super(...arguments);
+    __publicField(this, "features", []);
+  }
 };
 var GeomType = Object.freeze({ UNKNOWN: 0, POINT: 1, LINESTRING: 2, POLYGON: 3 });
-var TileFeatureCollector = class _TileFeatureCollector {
-  static unknownSet = /* @__PURE__ */ new Set();
-  #mapconfig = null;
-  #positionXY = null;
+var _mapconfig, _positionXY, _TileFeatureCollector_instances, collectLine_fn, segmentLine_fn, collectPolygon_fn, normalizeRing_fn, resolveStyle_fn, getOrCreate_fn;
+var _TileFeatureCollector = class _TileFeatureCollector {
   constructor(positionXY, mapconfig) {
-    this.#positionXY = positionXY;
-    this.#mapconfig = mapconfig;
+    __privateAdd(this, _TileFeatureCollector_instances);
+    __privateAdd(this, _mapconfig, null);
+    __privateAdd(this, _positionXY, null);
+    __privateSet(this, _positionXY, positionXY);
+    __privateSet(this, _mapconfig, mapconfig);
   }
   collect(protoTile) {
     const lineGroups = [];
     const polygonGroups = [];
     for (const layer of protoTile.layers) {
-      const scale = 1 / layer.extent * this.#mapconfig.tileWorldSize;
+      const scale = 1 / layer.extent * __privateGet(this, _mapconfig).tileWorldSize;
       for (const feature of layer.features) {
         switch (feature.type) {
           case GeomType.LINESTRING:
-            this.#collectLine(layer, feature, scale, lineGroups);
+            __privateMethod(this, _TileFeatureCollector_instances, collectLine_fn).call(this, layer, feature, scale, lineGroups);
             break;
           case GeomType.POLYGON:
-            this.#collectPolygon(layer, feature, scale, polygonGroups);
+            __privateMethod(this, _TileFeatureCollector_instances, collectPolygon_fn).call(this, layer, feature, scale, polygonGroups);
             break;
         }
       }
     }
     return { lineGroups, polygonGroups };
   }
-  #collectLine(layer, feature, scale, lineGroups) {
-    const featureClass = feature.properties.get("class");
-    const style = this.#resolveStyle(layer.name, featureClass);
-    if (!(style == null ? void 0 : style.isVisible)) return;
-    const [tileX, tileY] = this.#positionXY;
-    const group = this.#getOrCreate(
-      LineGroup,
-      `${layer.name}::${featureClass}`,
-      style,
-      layer.name,
-      featureClass,
-      lineGroups
-    );
-    for (const rawLine of parseGeometry(feature.geometry))
-      group.lines.push(this.#segmentLine(rawLine, scale, tileX, tileY));
-  }
-  #segmentLine(rawLine, scale, tileX, tileY) {
-    const simplified = simplifyLine(rawLine, 2);
-    const out = new Float32Array(simplified.length);
-    for (let i = 0; i < simplified.length; i += 2) {
-      out[i] = simplified[i] * scale + tileX;
-      out[i + 1] = simplified[i + 1] * scale + tileY;
-    }
-    return out;
-  }
-  #collectPolygon(layer, feature, scale, polygonGroups) {
-    const featureClass = feature.properties.get("class") ?? layer.name;
-    const style = this.#resolveStyle(layer.name, featureClass);
-    if (!(style == null ? void 0 : style.isVisible)) return;
-    const [tileX, tileY] = this.#positionXY;
-    const group = this.#getOrCreate(
-      PolygonGroup,
-      `${layer.name}::${featureClass}`,
-      style,
-      layer.name,
-      featureClass,
-      polygonGroups
-    );
-    const rings = parseGeometry(feature.geometry).map((ring) => this.#normalizeRing(ring, scale, tileX, tileY));
-    group.features.push({ rings, properties: feature.properties });
+};
+_mapconfig = new WeakMap();
+_positionXY = new WeakMap();
+_TileFeatureCollector_instances = new WeakSet();
+collectLine_fn = function(layer, feature, scale, lineGroups) {
+  const featureClass = feature.properties.get("class");
+  const style = __privateMethod(this, _TileFeatureCollector_instances, resolveStyle_fn).call(this, layer.name, featureClass);
+  if (!style?.isVisible) return;
+  const [tileX, tileY] = __privateGet(this, _positionXY);
+  const group = __privateMethod(this, _TileFeatureCollector_instances, getOrCreate_fn).call(this, LineGroup, `${layer.name}::${featureClass}`, style, layer.name, featureClass, lineGroups);
+  for (const rawLine of parseGeometry(feature.geometry))
+    group.lines.push(__privateMethod(this, _TileFeatureCollector_instances, segmentLine_fn).call(this, rawLine, scale, tileX, tileY));
+};
+segmentLine_fn = function(rawLine, scale, tileX, tileY) {
+  const simplified = simplifyLine(rawLine, 2);
+  const out = new Float32Array(simplified.length);
+  for (let i = 0; i < simplified.length; i += 2) {
+    out[i] = simplified[i] * scale + tileX;
+    out[i + 1] = simplified[i + 1] * scale + tileY;
   }
-  #normalizeRing(rawRing, scale, tileX, tileY) {
-    const out = new Float32Array(rawRing.length);
-    for (let i = 0; i < rawRing.length; i += 2) {
-      out[i] = rawRing[i] * scale + tileX;
-      out[i + 1] = rawRing[i + 1] * scale + tileY;
-    }
-    return out;
+  return out;
+};
+collectPolygon_fn = function(layer, feature, scale, polygonGroups) {
+  const featureClass = feature.properties.get("class") ?? layer.name;
+  const style = __privateMethod(this, _TileFeatureCollector_instances, resolveStyle_fn).call(this, layer.name, featureClass);
+  if (!style?.isVisible) return;
+  const [tileX, tileY] = __privateGet(this, _positionXY);
+  const group = __privateMethod(this, _TileFeatureCollector_instances, getOrCreate_fn).call(this, PolygonGroup, `${layer.name}::${featureClass}`, style, layer.name, featureClass, polygonGroups);
+  const rings = parseGeometry(feature.geometry).map((ring) => __privateMethod(this, _TileFeatureCollector_instances, normalizeRing_fn).call(this, ring, scale, tileX, tileY));
+  group.features.push({ rings, properties: feature.properties });
+};
+normalizeRing_fn = function(rawRing, scale, tileX, tileY) {
+  const out = new Float32Array(rawRing.length);
+  for (let i = 0; i < rawRing.length; i += 2) {
+    out[i] = rawRing[i] * scale + tileX;
+    out[i + 1] = rawRing[i + 1] * scale + tileY;
   }
-  #resolveStyle(layerName, featureClass) {
-    if (layerName === "landuse") {
-      if (featureClass === "grass" || featureClass === "park") {
-        layerName = "landcover";
-      }
-    }
-    if (featureClass === "grass" && layerName === "landuse") {
+  return out;
+};
+resolveStyle_fn = function(layerName, featureClass) {
+  if (layerName === "landuse") {
+    if (featureClass === "grass" || featureClass === "park") {
       layerName = "landcover";
     }
-    const styleLayer = this.#mapconfig.mapStyle.getStyleLayerByName(layerName);
-    if (!styleLayer) {
-      _TileFeatureCollector.unknownSet.add(`[no layer] ${featureClass}/${layerName}`);
-      return null;
-    }
-    const style = styleLayer.getTypeByName ? styleLayer.getTypeByName(featureClass) : styleLayer;
-    if (!style) {
-      _TileFeatureCollector.unknownSet.add(`[no type] ${featureClass}/${layerName}`);
-    }
-    return style ?? null;
   }
-  #getOrCreate(GroupClass, key, style, layerName, featureClass, list) {
-    let group = list.find((g) => g.identifier === key);
-    if (!group) {
-      group = new GroupClass(key, style);
-      group.layerName = layerName;
-      group.featureClass = featureClass;
-      list.push(group);
-    }
-    return group;
+  if (featureClass === "grass" && layerName === "landuse") {
+    layerName = "landcover";
+  }
+  const styleLayer = __privateGet(this, _mapconfig).mapStyle.getStyleLayerByName(layerName);
+  if (!styleLayer) {
+    _TileFeatureCollector.unknownSet.add(`[no layer] ${featureClass}/${layerName}`);
+    return null;
+  }
+  const style = styleLayer.getTypeByName ? styleLayer.getTypeByName(featureClass) : styleLayer;
+  if (!style) {
+    _TileFeatureCollector.unknownSet.add(`[no type] ${featureClass}/${layerName}`);
   }
+  return style ?? null;
 };
+getOrCreate_fn = function(GroupClass, key, style, layerName, featureClass, list) {
+  let group = list.find((g) => g.identifier === key);
+  if (!group) {
+    group = new GroupClass(key, style);
+    group.layerName = layerName;
+    group.featureClass = featureClass;
+    list.push(group);
+  }
+  return group;
+};
+__publicField(_TileFeatureCollector, "unknownSet", /* @__PURE__ */ new Set());
+var TileFeatureCollector = _TileFeatureCollector;
 
 // src/geom_utils/earcut.js
 function earcut(data, holeIndices, dim) {
@@ -7709,372 +8572,351 @@ var TILE_BORDER_MATERIAL = new THREE9.LineBasicMaterial({
   transparent: true,
   opacity: 0.8
 });
+var _positionXY2, _scene, _mapconfig2, _tileData, _borderLines, _Tile_instances, buildBorderLines_fn, buildLineMeshes_fn, getOrCreate_fn2, metaFor_fn, buildPolygonMeshes_fn, buildFlatGroups_fn, buildExtrudedGroups_fn, earcutInto_fn, buildExtrudedVerts_fn, earcutFlat_fn, makeTileClippingPlanes_fn, addMesh_fn;
 var Tile = class {
-  tileMeshes = [];
-  #positionXY = null;
-  #scene = null;
-  #mapconfig = null;
-  #tileData = null;
-  #borderLines = null;
   constructor(positionXY, tileData, scene, mapconfig) {
-    this.#positionXY = positionXY;
-    this.#scene = scene;
-    this.#mapconfig = mapconfig;
-    this.#tileData = tileData;
+    __privateAdd(this, _Tile_instances);
+    __publicField(this, "tileMeshes", []);
+    __privateAdd(this, _positionXY2, null);
+    __privateAdd(this, _scene, null);
+    __privateAdd(this, _mapconfig2, null);
+    __privateAdd(this, _tileData, null);
+    __privateAdd(this, _borderLines, null);
+    __privateSet(this, _positionXY2, positionXY);
+    __privateSet(this, _scene, scene);
+    __privateSet(this, _mapconfig2, mapconfig);
+    __privateSet(this, _tileData, tileData);
   }
   async render() {
     let protoTile;
     try {
-      protoTile = deserializeMVT(this.#tileData);
+      protoTile = deserializeMVT(__privateGet(this, _tileData));
     } catch (err) {
       console.error("ThreeGeoPlay: deserialization error:", err);
       return;
     }
-    const collector = new TileFeatureCollector(this.#positionXY, this.#mapconfig);
+    const collector = new TileFeatureCollector(__privateGet(this, _positionXY2), __privateGet(this, _mapconfig2));
     const result = collector.collect(protoTile);
     if (!result) return;
-    this.#buildLineMeshes(result.lineGroups);
-    this.#buildPolygonMeshes(result.polygonGroups);
-    this.#buildBorderLines();
+    __privateMethod(this, _Tile_instances, buildLineMeshes_fn).call(this, result.lineGroups);
+    __privateMethod(this, _Tile_instances, buildPolygonMeshes_fn).call(this, result.polygonGroups);
+    __privateMethod(this, _Tile_instances, buildBorderLines_fn).call(this);
   }
   updateBorderVisibility() {
-    if (this.#mapconfig.showTileBorders) {
-      if (!this.#borderLines) this.#buildBorderLines();
-    } else if (this.#borderLines) {
-      this.#scene.remove(this.#borderLines);
-      this.#borderLines.geometry.dispose();
-      this.#borderLines = null;
+    if (__privateGet(this, _mapconfig2).showTileBorders) {
+      if (!__privateGet(this, _borderLines)) __privateMethod(this, _Tile_instances, buildBorderLines_fn).call(this);
+    } else if (__privateGet(this, _borderLines)) {
+      __privateGet(this, _scene).remove(__privateGet(this, _borderLines));
+      __privateGet(this, _borderLines).geometry.dispose();
+      __privateSet(this, _borderLines, null);
     }
   }
   scaleMeshes(ratio) {
-    var _a;
     for (const mesh of this.tileMeshes) mesh.scale.multiplyScalar(ratio);
-    (_a = this.#borderLines) == null ? void 0 : _a.scale.multiplyScalar(ratio);
+    __privateGet(this, _borderLines)?.scale.multiplyScalar(ratio);
   }
   refreshMaterials() {
-    var _a;
     for (const mesh of this.tileMeshes) {
       const { featureClass, isOutline, layerName } = mesh.userData;
       if (!featureClass) continue;
-      const style = (_a = this.#mapconfig.mapStyle.getStyleLayerByName(layerName)) == null ? void 0 : _a.getTypeByName(featureClass);
+      const style = __privateGet(this, _mapconfig2).mapStyle.getStyleLayerByName(layerName)?.getTypeByName(featureClass);
       if (!style) continue;
       mesh.material = isOutline ? style.outlineMaterial : style.material;
     }
   }
   destroy() {
-    var _a;
     for (const mesh of this.tileMeshes) {
-      this.#scene.remove(mesh);
-      (_a = mesh.geometry) == null ? void 0 : _a.dispose();
+      __privateGet(this, _scene).remove(mesh);
+      mesh.geometry?.dispose();
     }
-    if (this.#borderLines) {
-      this.#scene.remove(this.#borderLines);
-      this.#borderLines.geometry.dispose();
-      this.#borderLines = null;
+    if (__privateGet(this, _borderLines)) {
+      __privateGet(this, _scene).remove(__privateGet(this, _borderLines));
+      __privateGet(this, _borderLines).geometry.dispose();
+      __privateSet(this, _borderLines, null);
     }
     this.tileMeshes = [];
   }
-  #buildBorderLines() {
-    const [wx, wz] = this.#positionXY;
-    const size = this.#mapconfig.tileWorldSize;
-    const y = 0.01;
-    const corners = new Float32Array([
-      wx,
-      y,
-      wz,
-      wx + size,
-      y,
-      wz,
-      wx + size,
-      y,
-      wz + size,
-      wx,
-      y,
-      wz + size,
-      wx,
-      y,
-      wz
-    ]);
-    const geo = new THREE9.BufferGeometry();
-    geo.setAttribute("position", new THREE9.BufferAttribute(corners, 3));
-    this.#borderLines = new THREE9.Line(geo, TILE_BORDER_MATERIAL);
-    this.#borderLines.visible = this.#mapconfig.showTileBorders;
-    this.#scene.add(this.#borderLines);
-  }
-  #buildLineMeshes(lineGroups) {
-    if (lineGroups.length === 0) return;
-    const tileSize = this.#mapconfig.tileWorldSize;
-    const zoomScale = this.#mapconfig.zoomScaleFactor;
-    const transportationLayer = this.#mapconfig.mapStyle.getStyleLayerByName("transportation");
-    const jointSegs = transportationLayer.generalConfig.jointSegments;
-    const outlineVerts = /* @__PURE__ */ new Map();
-    const fillVerts = /* @__PURE__ */ new Map();
-    for (const group of lineGroups) {
-      const { style, layerName, lines } = group;
-      if (!style.isVisible) continue;
-      const lineWidth = style.lineWidth * tileSize * zoomScale;
-      const roadY = style.YOrder;
-      const outlineWidth = layerName === "transportation" ? transportationLayer.resolveOutlineWidth(style) : style.outlineWidth ?? 0;
-      if (outlineWidth > 0) {
-        const borderWidth = lineWidth + outlineWidth * tileSize * zoomScale;
-        const fillArr = this.#getOrCreate(fillVerts, style.material);
-        const outlineArr = this.#getOrCreate(outlineVerts, style.outlineMaterial);
-        for (const line of lines)
-          transformLineToAccumulators(line, lineWidth, borderWidth, jointSegs, fillArr, outlineArr, roadY, roadY - 0.01);
-      } else {
-        const fillArr = this.#getOrCreate(fillVerts, style.material);
-        for (const line of lines) {
-          for (const poly of transformLineInPolygon(line, lineWidth, jointSegs)) {
-            const n = poly.length / 2;
-            const x0 = poly[0], z0 = poly[1];
-            for (let i = 1; i < n - 1; i++) {
-              fillArr.push(
-                x0,
-                roadY,
-                z0,
-                poly[i * 2],
-                roadY,
-                poly[i * 2 + 1],
-                poly[i * 2 + 2],
-                roadY,
-                poly[i * 2 + 3]
-              );
-            }
+};
+_positionXY2 = new WeakMap();
+_scene = new WeakMap();
+_mapconfig2 = new WeakMap();
+_tileData = new WeakMap();
+_borderLines = new WeakMap();
+_Tile_instances = new WeakSet();
+buildBorderLines_fn = function() {
+  const [wx, wz] = __privateGet(this, _positionXY2);
+  const size = __privateGet(this, _mapconfig2).tileWorldSize;
+  const y = 0.01;
+  const corners = new Float32Array([
+    wx,
+    y,
+    wz,
+    wx + size,
+    y,
+    wz,
+    wx + size,
+    y,
+    wz + size,
+    wx,
+    y,
+    wz + size,
+    wx,
+    y,
+    wz
+  ]);
+  const geo = new THREE9.BufferGeometry();
+  geo.setAttribute("position", new THREE9.BufferAttribute(corners, 3));
+  __privateSet(this, _borderLines, new THREE9.Line(geo, TILE_BORDER_MATERIAL));
+  __privateGet(this, _borderLines).visible = __privateGet(this, _mapconfig2).showTileBorders;
+  __privateGet(this, _scene).add(__privateGet(this, _borderLines));
+};
+buildLineMeshes_fn = function(lineGroups) {
+  if (lineGroups.length === 0) return;
+  const tileSize = __privateGet(this, _mapconfig2).tileWorldSize;
+  const zoomScale = __privateGet(this, _mapconfig2).zoomScaleFactor;
+  const transportationLayer = __privateGet(this, _mapconfig2).mapStyle.getStyleLayerByName("transportation");
+  const jointSegs = transportationLayer.generalConfig.jointSegments;
+  const outlineVerts = /* @__PURE__ */ new Map();
+  const fillVerts = /* @__PURE__ */ new Map();
+  for (const group of lineGroups) {
+    const { style, layerName, lines } = group;
+    if (!style.isVisible) continue;
+    const lineWidth = style.lineWidth * tileSize * zoomScale;
+    const roadY = style.YOrder;
+    const outlineWidth = layerName === "transportation" ? transportationLayer.resolveOutlineWidth(style) : style.outlineWidth ?? 0;
+    if (outlineWidth > 0) {
+      const borderWidth = lineWidth + outlineWidth * tileSize * zoomScale;
+      const fillArr = __privateMethod(this, _Tile_instances, getOrCreate_fn2).call(this, fillVerts, style.material);
+      const outlineArr = __privateMethod(this, _Tile_instances, getOrCreate_fn2).call(this, outlineVerts, style.outlineMaterial);
+      for (const line of lines)
+        transformLineToAccumulators(line, lineWidth, borderWidth, jointSegs, fillArr, outlineArr, roadY, roadY - 0.01);
+    } else {
+      const fillArr = __privateMethod(this, _Tile_instances, getOrCreate_fn2).call(this, fillVerts, style.material);
+      for (const line of lines) {
+        for (const poly of transformLineInPolygon(line, lineWidth, jointSegs)) {
+          const n = poly.length / 2;
+          const x0 = poly[0], z0 = poly[1];
+          for (let i = 1; i < n - 1; i++) {
+            fillArr.push(
+              x0,
+              roadY,
+              z0,
+              poly[i * 2],
+              roadY,
+              poly[i * 2 + 1],
+              poly[i * 2 + 2],
+              roadY,
+              poly[i * 2 + 3]
+            );
           }
         }
       }
     }
-    for (const [mat, verts] of outlineVerts)
-      this.#addMesh(
-        vertsToGeometry(verts),
-        mat,
-        this.#metaFor(mat, lineGroups, true, "featureClass"),
-        this.#metaFor(mat, lineGroups, true, "layerName"),
-        true
-      );
-    for (const [mat, verts] of fillVerts)
-      this.#addMesh(
-        vertsToGeometry(verts),
-        mat,
-        this.#metaFor(mat, lineGroups, false, "featureClass"),
-        this.#metaFor(mat, lineGroups, false, "layerName"),
-        false
-      );
   }
-  #getOrCreate(map, material) {
-    if (!map.has(material)) map.set(material, []);
-    return map.get(material);
-  }
-  #metaFor(mat, groups, isOutline, field) {
-    for (const g of groups)
-      if ((isOutline ? g.style.outlineMaterial : g.style.material) === mat)
-        return g[field];
-    return "";
-  }
-  #buildPolygonMeshes(polygonGroups) {
-    if (polygonGroups.length === 0) return;
-    const [tileX, tileY] = this.#positionXY;
-    const tileSize = this.#mapconfig.tileWorldSize;
-    const clippingPlanes = this.#makeTileClippingPlanes(tileX, tileY, tileSize);
-    const flatGroups = [];
-    const extrudedGroups = [];
-    for (const group of polygonGroups) {
-      if (group.layerName == "transportation") {
-        continue;
-      }
-      if (!group.style.isVisible) continue;
-      if (!group.style.material) {
-        console.warn(`ThreeGeoPlay: material undefined for ${group.featureClass}/${group.layerName}`);
-        continue;
-      }
-      const isBuilding = group.style.material.transparent && group.style.height != null;
-      (isBuilding ? extrudedGroups : flatGroups).push(group);
-    }
-    this.#buildFlatGroups(flatGroups);
-    this.#buildExtrudedGroups(extrudedGroups, clippingPlanes);
-  }
-  #buildFlatGroups(flatGroups) {
-    if (flatGroups.length === 0) return;
-    const accumByMat = /* @__PURE__ */ new Map();
-    for (const { style, layerName, featureClass, features } of flatGroups) {
-      if (!style.isVisible) continue;
-      if (!accumByMat.has(style.material))
-        accumByMat.set(style.material, { verts: [], featureClass, layerName });
-      const { verts } = accumByMat.get(style.material);
-      const y = style.YOrder ?? 0;
-      for (const { rings } of features) {
-        if (rings.length === 0 || rings[0].length < 6) continue;
-        this.#earcutInto(rings, verts, y);
-      }
-    }
-    for (const [mat, { verts, featureClass, layerName }] of accumByMat) {
-      if (verts.length === 0) continue;
-      this.#addMesh(vertsToGeometry(verts), mat, featureClass, layerName, false);
-    }
-  }
-  #buildExtrudedGroups(extrudedGroups, clippingPlanes) {
-    if (extrudedGroups.length === 0) return;
-    const tileSize = this.#mapconfig.tileWorldSize;
-    const accumByMat = /* @__PURE__ */ new Map();
-    for (const { style, layerName, featureClass, features } of extrudedGroups) {
-      if (!style.isVisible) continue;
-      if (!accumByMat.has(style.material)) {
-        const clonedMat = style.material.clone();
-        clonedMat.clippingPlanes = clippingPlanes;
-        accumByMat.set(style.material, { verts: [], clonedMat, featureClass, layerName });
-      }
-      const { verts } = accumByMat.get(style.material);
-      const extrusionScale = (style.height ?? 0.05) * tileSize;
-      const baseYOrder = style.YOrder ?? 0;
-      for (const { rings, properties } of features) {
-        if (rings.length === 0 || rings[0].length < 6) continue;
-        const renderHeight = properties.get("render_height") ?? 10;
-        const renderMinHeight = properties.get("render_min_height") ?? 0;
-        const yTop = baseYOrder + Math.max(0, renderHeight) * extrusionScale;
-        const yBase = baseYOrder + Math.max(0, renderMinHeight) * extrusionScale;
-        this.#buildExtrudedVerts(rings, yBase, yTop, verts);
-      }
-    }
-    for (const [, { verts, clonedMat, featureClass, layerName }] of accumByMat) {
-      if (verts.length === 0) {
-        clonedMat.dispose();
-        continue;
-      }
-      this.#addMesh(vertsToGeometry(verts), clonedMat, featureClass, layerName, false);
-    }
-  }
-  #earcutInto(rings, verts, y) {
-    let flat, holeIndices;
-    if (rings.length === 1) {
-      flat = rings[0];
-      holeIndices = null;
-    } else {
-      holeIndices = [];
-      let totalLen = rings[0].length;
-      for (let i = 1; i < rings.length; i++) {
-        holeIndices.push(totalLen / 2);
-        totalLen += rings[i].length;
-      }
-      flat = new Float32Array(totalLen);
-      let off = 0;
-      for (const ring of rings) {
-        flat.set(ring, off);
-        off += ring.length;
-      }
-    }
-    const indices = earcut(flat, holeIndices, 2);
-    for (const idx of indices) verts.push(flat[idx * 2], y, flat[idx * 2 + 1]);
-  }
-  #buildExtrudedVerts(rings, yBase, yTop, verts) {
-    const { flat, indices } = this.#earcutFlat(rings);
-    for (let i = 0; i < indices.length; i += 3) {
-      const a = indices[i] * 2, b = indices[i + 1] * 2, c = indices[i + 2] * 2;
-      verts.push(flat[c], yTop, flat[c + 1]);
-      verts.push(flat[b], yTop, flat[b + 1]);
-      verts.push(flat[a], yTop, flat[a + 1]);
+  for (const [mat, verts] of outlineVerts)
+    __privateMethod(this, _Tile_instances, addMesh_fn).call(this, vertsToGeometry(verts), mat, __privateMethod(this, _Tile_instances, metaFor_fn).call(this, mat, lineGroups, true, "featureClass"), __privateMethod(this, _Tile_instances, metaFor_fn).call(this, mat, lineGroups, true, "layerName"), true);
+  for (const [mat, verts] of fillVerts)
+    __privateMethod(this, _Tile_instances, addMesh_fn).call(this, vertsToGeometry(verts), mat, __privateMethod(this, _Tile_instances, metaFor_fn).call(this, mat, lineGroups, false, "featureClass"), __privateMethod(this, _Tile_instances, metaFor_fn).call(this, mat, lineGroups, false, "layerName"), false);
+};
+getOrCreate_fn2 = function(map, material) {
+  if (!map.has(material)) map.set(material, []);
+  return map.get(material);
+};
+metaFor_fn = function(mat, groups, isOutline, field) {
+  for (const g of groups)
+    if ((isOutline ? g.style.outlineMaterial : g.style.material) === mat)
+      return g[field];
+  return "";
+};
+buildPolygonMeshes_fn = function(polygonGroups) {
+  if (polygonGroups.length === 0) return;
+  const [tileX, tileY] = __privateGet(this, _positionXY2);
+  const tileSize = __privateGet(this, _mapconfig2).tileWorldSize;
+  const clippingPlanes = __privateMethod(this, _Tile_instances, makeTileClippingPlanes_fn).call(this, tileX, tileY, tileSize);
+  const flatGroups = [];
+  const extrudedGroups = [];
+  for (const group of polygonGroups) {
+    if (group.layerName == "transportation") {
+      continue;
     }
-    for (const ring of rings) {
-      const n = ring.length / 2;
-      for (let i = 0; i < n; i++) {
-        const j = (i + 1) % n;
-        const x0 = ring[i * 2], z0 = ring[i * 2 + 1];
-        const x1 = ring[j * 2], z1 = ring[j * 2 + 1];
-        verts.push(x0, yTop, z0, x1, yBase, z1, x0, yBase, z0);
-        verts.push(x0, yTop, z0, x1, yTop, z1, x1, yBase, z1);
-      }
+    if (!group.style.isVisible) continue;
+    if (!group.style.material) {
+      console.warn(`ThreeGeoPlay: material undefined for ${group.featureClass}/${group.layerName}`);
+      continue;
+    }
+    const isBuilding = group.style.material.transparent && group.style.height != null;
+    (isBuilding ? extrudedGroups : flatGroups).push(group);
+  }
+  __privateMethod(this, _Tile_instances, buildFlatGroups_fn).call(this, flatGroups);
+  __privateMethod(this, _Tile_instances, buildExtrudedGroups_fn).call(this, extrudedGroups, clippingPlanes);
+};
+buildFlatGroups_fn = function(flatGroups) {
+  if (flatGroups.length === 0) return;
+  const accumByMat = /* @__PURE__ */ new Map();
+  for (const { style, layerName, featureClass, features } of flatGroups) {
+    if (!style.isVisible) continue;
+    if (!accumByMat.has(style.material))
+      accumByMat.set(style.material, { verts: [], featureClass, layerName });
+    const { verts } = accumByMat.get(style.material);
+    const y = style.YOrder ?? 0;
+    for (const { rings } of features) {
+      if (rings.length === 0 || rings[0].length < 6) continue;
+      __privateMethod(this, _Tile_instances, earcutInto_fn).call(this, rings, verts, y);
+    }
+  }
+  for (const [mat, { verts, featureClass, layerName }] of accumByMat) {
+    if (verts.length === 0) continue;
+    __privateMethod(this, _Tile_instances, addMesh_fn).call(this, vertsToGeometry(verts), mat, featureClass, layerName, false);
+  }
+};
+buildExtrudedGroups_fn = function(extrudedGroups, clippingPlanes) {
+  if (extrudedGroups.length === 0) return;
+  const tileSize = __privateGet(this, _mapconfig2).tileWorldSize;
+  const accumByMat = /* @__PURE__ */ new Map();
+  for (const { style, layerName, featureClass, features } of extrudedGroups) {
+    if (!style.isVisible) continue;
+    if (!accumByMat.has(style.material)) {
+      const clonedMat = style.material.clone();
+      clonedMat.clippingPlanes = clippingPlanes;
+      accumByMat.set(style.material, { verts: [], clonedMat, featureClass, layerName });
+    }
+    const { verts } = accumByMat.get(style.material);
+    const extrusionScale = (style.height ?? 0.05) * tileSize;
+    const baseYOrder = style.YOrder ?? 0;
+    for (const { rings, properties } of features) {
+      if (rings.length === 0 || rings[0].length < 6) continue;
+      const renderHeight = properties.get("render_height") ?? 10;
+      const renderMinHeight = properties.get("render_min_height") ?? 0;
+      const yTop = baseYOrder + Math.max(0, renderHeight) * extrusionScale;
+      const yBase = baseYOrder + Math.max(0, renderMinHeight) * extrusionScale;
+      __privateMethod(this, _Tile_instances, buildExtrudedVerts_fn).call(this, rings, yBase, yTop, verts);
+    }
+  }
+  for (const [, { verts, clonedMat, featureClass, layerName }] of accumByMat) {
+    if (verts.length === 0) {
+      clonedMat.dispose();
+      continue;
     }
+    __privateMethod(this, _Tile_instances, addMesh_fn).call(this, vertsToGeometry(verts), clonedMat, featureClass, layerName, false);
   }
-  #earcutFlat(rings) {
-    if (rings.length === 1)
-      return { flat: rings[0], indices: earcut(rings[0], null, 2) };
-    const holeIndices = [];
+};
+earcutInto_fn = function(rings, verts, y) {
+  let flat, holeIndices;
+  if (rings.length === 1) {
+    flat = rings[0];
+    holeIndices = null;
+  } else {
+    holeIndices = [];
     let totalLen = rings[0].length;
     for (let i = 1; i < rings.length; i++) {
       holeIndices.push(totalLen / 2);
       totalLen += rings[i].length;
     }
-    const flat = new Float32Array(totalLen);
+    flat = new Float32Array(totalLen);
     let off = 0;
     for (const ring of rings) {
       flat.set(ring, off);
       off += ring.length;
     }
-    return { flat, indices: earcut(flat, holeIndices, 2) };
   }
-  #makeTileClippingPlanes(tileX, tileY, size) {
-    const corners = [
-      new THREE9.Vector3(tileX, 0, tileY + size),
-      new THREE9.Vector3(tileX + size, 0, tileY + size),
-      new THREE9.Vector3(tileX + size, 0, tileY),
-      new THREE9.Vector3(tileX, 0, tileY)
-    ];
-    const up = new THREE9.Vector3(0, 1, 0);
-    return corners.map((a, i) => {
-      const b = corners[(i + 1) % 4];
-      const edge = new THREE9.Vector3().subVectors(b, a);
-      const normal = new THREE9.Vector3().crossVectors(edge, up).normalize().negate();
-      return new THREE9.Plane().setFromNormalAndCoplanarPoint(normal, a);
-    });
-  }
-  #addMesh(geometry, material, featureClass, layerName, isOutline) {
-    const mesh = new THREE9.Mesh(geometry, material);
-    mesh.userData.featureClass = featureClass;
-    mesh.userData.layerName = layerName;
-    mesh.userData.isOutline = isOutline;
-    this.tileMeshes.push(mesh);
-    this.#scene.add(mesh);
+  const indices = earcut(flat, holeIndices, 2);
+  for (const idx of indices) verts.push(flat[idx * 2], y, flat[idx * 2 + 1]);
+};
+buildExtrudedVerts_fn = function(rings, yBase, yTop, verts) {
+  const { flat, indices } = __privateMethod(this, _Tile_instances, earcutFlat_fn).call(this, rings);
+  for (let i = 0; i < indices.length; i += 3) {
+    const a = indices[i] * 2, b = indices[i + 1] * 2, c = indices[i + 2] * 2;
+    verts.push(flat[c], yTop, flat[c + 1]);
+    verts.push(flat[b], yTop, flat[b + 1]);
+    verts.push(flat[a], yTop, flat[a + 1]);
+  }
+  for (const ring of rings) {
+    const n = ring.length / 2;
+    for (let i = 0; i < n; i++) {
+      const j = (i + 1) % n;
+      const x0 = ring[i * 2], z0 = ring[i * 2 + 1];
+      const x1 = ring[j * 2], z1 = ring[j * 2 + 1];
+      verts.push(x0, yTop, z0, x1, yBase, z1, x0, yBase, z0);
+      verts.push(x0, yTop, z0, x1, yTop, z1, x1, yBase, z1);
+    }
   }
 };
+earcutFlat_fn = function(rings) {
+  if (rings.length === 1)
+    return { flat: rings[0], indices: earcut(rings[0], null, 2) };
+  const holeIndices = [];
+  let totalLen = rings[0].length;
+  for (let i = 1; i < rings.length; i++) {
+    holeIndices.push(totalLen / 2);
+    totalLen += rings[i].length;
+  }
+  const flat = new Float32Array(totalLen);
+  let off = 0;
+  for (const ring of rings) {
+    flat.set(ring, off);
+    off += ring.length;
+  }
+  return { flat, indices: earcut(flat, holeIndices, 2) };
+};
+makeTileClippingPlanes_fn = function(tileX, tileY, size) {
+  const corners = [
+    new THREE9.Vector3(tileX, 0, tileY + size),
+    new THREE9.Vector3(tileX + size, 0, tileY + size),
+    new THREE9.Vector3(tileX + size, 0, tileY),
+    new THREE9.Vector3(tileX, 0, tileY)
+  ];
+  const up = new THREE9.Vector3(0, 1, 0);
+  return corners.map((a, i) => {
+    const b = corners[(i + 1) % 4];
+    const edge = new THREE9.Vector3().subVectors(b, a);
+    const normal = new THREE9.Vector3().crossVectors(edge, up).normalize().negate();
+    return new THREE9.Plane().setFromNormalAndCoplanarPoint(normal, a);
+  });
+};
+addMesh_fn = function(geometry, material, featureClass, layerName, isOutline) {
+  const mesh = new THREE9.Mesh(geometry, material);
+  mesh.userData.featureClass = featureClass;
+  mesh.userData.layerName = layerName;
+  mesh.userData.isOutline = isOutline;
+  this.tileMeshes.push(mesh);
+  __privateGet(this, _scene).add(mesh);
+};
 
 // src/map/TileManager.js
 var THREE10 = __toESM(require("three"));
+var _mapConfig, _originLatLon2, _zoomLevel2, _tileProviderUrl, _originTileX, _originTileY, _scene2, _subTileOffsetX, _subTileOffsetY, _lastCenterTileX, _lastCenterTileY, _lastTileWorldSize, _doneTiles, _pendingTiles, _fetchQueue, _activeFetches, _maxConcurrentFetches, _groundMesh, _TileManager_instances, initGroundMesh_fn, updateGroundMesh_fn, applyCenter_fn, drainQueue_fn, fetchTile_fn;
 var TileManager = class {
-  #mapConfig = null;
-  #originLatLon = null;
-  #zoomLevel = null;
-  #tileProviderUrl = null;
-  #originTileX = null;
-  #originTileY = null;
-  #scene = null;
-  #subTileOffsetX = 0;
-  #subTileOffsetY = 0;
-  #lastCenterTileX = null;
-  #lastCenterTileY = null;
-  #lastTileWorldSize = null;
-  #doneTiles = /* @__PURE__ */ new Map();
-  #pendingTiles = /* @__PURE__ */ new Map();
-  #fetchQueue = [];
-  #activeFetches = 0;
-  #maxConcurrentFetches = 100;
-  #groundMesh = null;
   constructor(mapConfig, scene) {
-    this.#mapConfig = mapConfig;
-    this.#originLatLon = mapConfig.originLatLon;
-    this.#zoomLevel = mapConfig.zoomLevel;
-    this.#tileProviderUrl = mapConfig.pbfTileProviderZXYurl;
-    this.#scene = scene;
-    this.#lastTileWorldSize = mapConfig.tileWorldSize;
-    this.#initGroundMesh();
-  }
-  #initGroundMesh() {
-    const style = this.#mapConfig.mapStyle.getStyleLayerByName("background");
-    const material = style == null ? void 0 : style.material;
-    const geo = new THREE10.PlaneGeometry(1, 1);
-    this.#groundMesh = new THREE10.Mesh(geo, material);
-    this.#groundMesh.rotation.x = -Math.PI / 2;
-    this.#groundMesh.position.y = (style == null ? void 0 : style.YOrder) ?? 0;
-    this.#scene.add(this.#groundMesh);
-  }
-  #updateGroundMesh(centerWorldX, centerWorldZ) {
-    if (!this.#groundMesh) return;
-    const size = (this.#mapConfig.renderDistance * 2 + 1) * this.#mapConfig.tileWorldSize;
-    this.#groundMesh.scale.set(size, size, 1);
-    this.#groundMesh.position.x = centerWorldX;
-    this.#groundMesh.position.z = centerWorldZ;
+    __privateAdd(this, _TileManager_instances);
+    __privateAdd(this, _mapConfig, null);
+    __privateAdd(this, _originLatLon2, null);
+    __privateAdd(this, _zoomLevel2, null);
+    __privateAdd(this, _tileProviderUrl, null);
+    __privateAdd(this, _originTileX, null);
+    __privateAdd(this, _originTileY, null);
+    __privateAdd(this, _scene2, null);
+    __privateAdd(this, _subTileOffsetX, 0);
+    __privateAdd(this, _subTileOffsetY, 0);
+    __privateAdd(this, _lastCenterTileX, null);
+    __privateAdd(this, _lastCenterTileY, null);
+    __privateAdd(this, _lastTileWorldSize, null);
+    __privateAdd(this, _doneTiles, /* @__PURE__ */ new Map());
+    __privateAdd(this, _pendingTiles, /* @__PURE__ */ new Map());
+    __privateAdd(this, _fetchQueue, []);
+    __privateAdd(this, _activeFetches, 0);
+    __privateAdd(this, _maxConcurrentFetches, 100);
+    __privateAdd(this, _groundMesh, null);
+    __privateSet(this, _mapConfig, mapConfig);
+    __privateSet(this, _originLatLon2, mapConfig.originLatLon);
+    __privateSet(this, _zoomLevel2, mapConfig.zoomLevel);
+    __privateSet(this, _tileProviderUrl, mapConfig.pbfTileProviderZXYurl);
+    __privateSet(this, _scene2, scene);
+    __privateSet(this, _lastTileWorldSize, mapConfig.tileWorldSize);
+    __privateMethod(this, _TileManager_instances, initGroundMesh_fn).call(this);
   }
   async init() {
-    const { lon, lat } = this.#originLatLon;
-    const zoom = this.#zoomLevel;
+    const { lon, lat } = __privateGet(this, _originLatLon2);
+    const zoom = __privateGet(this, _zoomLevel2);
     if (lon < -180 || lon > 180) console.warn("ThreeGeoPlay: lon out of range [-180, 180]:", lon);
     if (lat < -85.051129 || lat > 85.051129) console.warn("ThreeGeoPlay: lat out of range[-85.05, 85.05]:", lat);
     const [ox, oy] = geoToTileXY(lon, lat, zoom);
@@ -8085,278 +8927,272 @@ var TileManager = class {
     const maxTile = 2 ** zoom;
     if (ox < 0 || oy < 0) console.warn("ThreeGeoPlay: negative tile origin");
     if (ox >= maxTile || oy >= maxTile) console.warn("ThreeGeoPlay: tile origin out of OSM grid");
-    this.#originTileX = ox;
-    this.#originTileY = oy;
+    __privateSet(this, _originTileX, ox);
+    __privateSet(this, _originTileY, oy);
     const [fox, foy] = geoToTileXYFloat(lon, lat, zoom);
-    this.#subTileOffsetX = fox - ox;
-    this.#subTileOffsetY = foy - oy;
-    this.#applyCenter(ox, oy);
+    __privateSet(this, _subTileOffsetX, fox - ox);
+    __privateSet(this, _subTileOffsetY, foy - oy);
+    __privateMethod(this, _TileManager_instances, applyCenter_fn).call(this, ox, oy);
   }
   updateCenter(lat, lon) {
-    const [cx, cy] = geoToTileXY(lon, lat, this.#zoomLevel);
-    this.#applyCenter(cx, cy);
+    const [cx, cy] = geoToTileXY(lon, lat, __privateGet(this, _zoomLevel2));
+    __privateMethod(this, _TileManager_instances, applyCenter_fn).call(this, cx, cy);
   }
   updateCenterFromPosition(x, z) {
-    const { originLatLon, tileWorldSize, zoomLevel, worldOriginOffset: offset } = this.#mapConfig;
+    const { originLatLon, tileWorldSize, zoomLevel, worldOriginOffset: offset } = __privateGet(this, _mapConfig);
     const [ox, oy] = geoToTileXY(originLatLon.lon, originLatLon.lat, zoomLevel);
     const cx = Math.floor(ox + (x - offset.x) / tileWorldSize);
     const cy = Math.floor(oy + (z - offset.z) / tileWorldSize);
-    if (cx === this.#lastCenterTileX && cy === this.#lastCenterTileY) return;
-    this.#lastCenterTileX = cx;
-    this.#lastCenterTileY = cy;
-    this.#applyCenter(cx, cy);
+    if (cx === __privateGet(this, _lastCenterTileX) && cy === __privateGet(this, _lastCenterTileY)) return;
+    __privateSet(this, _lastCenterTileX, cx);
+    __privateSet(this, _lastCenterTileY, cy);
+    __privateMethod(this, _TileManager_instances, applyCenter_fn).call(this, cx, cy);
   }
   updateBorders() {
-    var _a;
-    for (const [, entry] of this.#doneTiles) {
-      (_a = entry.tile) == null ? void 0 : _a.updateBorderVisibility();
+    for (const [, entry] of __privateGet(this, _doneTiles)) {
+      entry.tile?.updateBorderVisibility();
     }
   }
   rescaleTiles(newSize) {
-    var _a;
-    if (!this.#lastTileWorldSize || this.#lastTileWorldSize === newSize) return;
-    const ratio = newSize / this.#lastTileWorldSize;
-    for (const [, entry] of this.#doneTiles) {
-      (_a = entry.tile) == null ? void 0 : _a.scaleMeshes(ratio);
-    }
-    this.#lastTileWorldSize = newSize;
-    if (this.#lastCenterTileX !== null) {
-      const offset = this.#mapConfig.worldOriginOffset;
-      const dx = this.#lastCenterTileX - this.#originTileX;
-      const dy = this.#lastCenterTileY - this.#originTileY;
-      const cx = (dx - this.#subTileOffsetX) * newSize + offset.x;
-      const cz = (dy - this.#subTileOffsetY) * newSize + offset.z;
-      this.#updateGroundMesh(cx, cz);
+    if (!__privateGet(this, _lastTileWorldSize) || __privateGet(this, _lastTileWorldSize) === newSize) return;
+    const ratio = newSize / __privateGet(this, _lastTileWorldSize);
+    for (const [, entry] of __privateGet(this, _doneTiles)) {
+      entry.tile?.scaleMeshes(ratio);
+    }
+    __privateSet(this, _lastTileWorldSize, newSize);
+    if (__privateGet(this, _lastCenterTileX) !== null) {
+      const offset = __privateGet(this, _mapConfig).worldOriginOffset;
+      const dx = __privateGet(this, _lastCenterTileX) - __privateGet(this, _originTileX);
+      const dy = __privateGet(this, _lastCenterTileY) - __privateGet(this, _originTileY);
+      const cx = (dx - __privateGet(this, _subTileOffsetX)) * newSize + offset.x;
+      const cz = (dy - __privateGet(this, _subTileOffsetY)) * newSize + offset.z;
+      __privateMethod(this, _TileManager_instances, updateGroundMesh_fn).call(this, cx, cz);
     }
   }
   applyCenter() {
-    if (this.#lastCenterTileX === null || this.#originTileX === null) {
+    if (__privateGet(this, _lastCenterTileX) === null || __privateGet(this, _originTileX) === null) {
       return;
     }
-    this.#applyCenter(this.#lastCenterTileX, this.#lastCenterTileY);
+    __privateMethod(this, _TileManager_instances, applyCenter_fn).call(this, __privateGet(this, _lastCenterTileX), __privateGet(this, _lastCenterTileY));
   }
   updateMaterials() {
-    var _a;
-    for (const [, entry] of this.#doneTiles) {
-      (_a = entry.tile) == null ? void 0 : _a.refreshMaterials();
-    }
-    const style = this.#mapConfig.mapStyle.getStyleLayerByName("background");
-    if ((style == null ? void 0 : style.material) && this.#groundMesh) {
-      this.#groundMesh.material = style.material;
-    }
-  }
-  #applyCenter(centerTileX, centerTileY) {
-    const renderDistance = this.#mapConfig.renderDistance;
-    const tileWorldSize = this.#mapConfig.tileWorldSize;
-    const offset = this.#mapConfig.worldOriginOffset;
-    const isCircular = this.#mapConfig.tileLayout === TileLayout.CIRCULAR;
-    const r2 = renderDistance * renderDistance;
-    const needed = /* @__PURE__ */ new Map();
-    for (let tx = centerTileX - renderDistance; tx <= centerTileX + renderDistance; tx++) {
-      for (let ty = centerTileY - renderDistance; ty <= centerTileY + renderDistance; ty++) {
-        const cdx = tx - centerTileX;
-        const cdy = ty - centerTileY;
-        if (isCircular) {
-          const cx = centerTileX + 0.5;
-          const cy = centerTileY + 0.5;
-          const nearestX = Math.max(tx, Math.min(cx, tx + 1));
-          const nearestZ = Math.max(ty, Math.min(cy, ty + 1));
-          const dx2 = nearestX - cx;
-          const dz = nearestZ - cy;
-          if (dx2 * dx2 + dz * dz > r2) continue;
-        }
-        const dx = tx - this.#originTileX;
-        const dy = ty - this.#originTileY;
-        const key = `${dx}_${dy}`;
-        const worldX = (dx - this.#subTileOffsetX) * tileWorldSize + offset.x;
-        const worldZ = (dy - this.#subTileOffsetY) * tileWorldSize + offset.z;
-        needed.set(key, { tx, ty, worldX, worldZ, dist: cdx * cdx + cdy * cdy });
-      }
-    }
-    const centerWorldX = (centerTileX - this.#originTileX - this.#subTileOffsetX + 0.5) * tileWorldSize + offset.x;
-    const centerWorldZ = (centerTileY - this.#originTileY - this.#subTileOffsetY + 0.5) * tileWorldSize + offset.z;
-    this.#updateGroundMesh(centerWorldX, centerWorldZ);
-    for (const [key, controller] of this.#pendingTiles) {
-      if (!needed.has(key)) {
-        controller.abort();
-        this.#pendingTiles.delete(key);
-      }
-    }
-    for (const [key, entry] of this.#doneTiles) {
-      if (!needed.has(key)) {
-        entry.dispose();
-        this.#doneTiles.delete(key);
-      }
-    }
-    this.#fetchQueue = [];
-    for (const [key, data] of needed) {
-      if (!this.#doneTiles.has(key) && !this.#pendingTiles.has(key)) {
-        this.#fetchQueue.push({ key, ...data });
-      }
-    }
-    this.#fetchQueue.sort((a, b) => a.dist - b.dist);
-    this.#drainQueue();
-  }
-  #drainQueue() {
-    while (this.#activeFetches < this.#maxConcurrentFetches && this.#fetchQueue.length > 0) {
-      const item = this.#fetchQueue.shift();
-      if (this.#doneTiles.has(item.key) || this.#pendingTiles.has(item.key)) continue;
-      this.#activeFetches++;
-      this.#fetchTile(item);
-    }
-  }
-  async #fetchTile({ key, tx, ty, worldX, worldZ }) {
-    const controller = new AbortController();
-    this.#pendingTiles.set(key, controller);
-    const url = this.#tileProviderUrl.replace("{z}", this.#zoomLevel).replace("{x}", tx).replace("{y}", ty);
-    let result;
+    for (const [, entry] of __privateGet(this, _doneTiles)) {
+      entry.tile?.refreshMaterials();
+    }
+    const style = __privateGet(this, _mapConfig).mapStyle.getStyleLayerByName("background");
+    if (style?.material && __privateGet(this, _groundMesh)) {
+      __privateGet(this, _groundMesh).material = style.material;
+    }
+  }
+  destroy() {
+    for (const [, c] of __privateGet(this, _pendingTiles)) c.abort();
+    for (const [, t] of __privateGet(this, _doneTiles)) t.dispose();
+    __privateGet(this, _pendingTiles).clear();
+    __privateGet(this, _doneTiles).clear();
+    __privateSet(this, _fetchQueue, []);
+    __privateSet(this, _activeFetches, 0);
+    if (__privateGet(this, _groundMesh)) {
+      __privateGet(this, _scene2).remove(__privateGet(this, _groundMesh));
+      __privateGet(this, _groundMesh).geometry.dispose();
+      __privateSet(this, _groundMesh, null);
+    }
+  }
+};
+_mapConfig = new WeakMap();
+_originLatLon2 = new WeakMap();
+_zoomLevel2 = new WeakMap();
+_tileProviderUrl = new WeakMap();
+_originTileX = new WeakMap();
+_originTileY = new WeakMap();
+_scene2 = new WeakMap();
+_subTileOffsetX = new WeakMap();
+_subTileOffsetY = new WeakMap();
+_lastCenterTileX = new WeakMap();
+_lastCenterTileY = new WeakMap();
+_lastTileWorldSize = new WeakMap();
+_doneTiles = new WeakMap();
+_pendingTiles = new WeakMap();
+_fetchQueue = new WeakMap();
+_activeFetches = new WeakMap();
+_maxConcurrentFetches = new WeakMap();
+_groundMesh = new WeakMap();
+_TileManager_instances = new WeakSet();
+initGroundMesh_fn = function() {
+  const style = __privateGet(this, _mapConfig).mapStyle.getStyleLayerByName("background");
+  const material = style?.material;
+  const geo = new THREE10.PlaneGeometry(1, 1);
+  __privateSet(this, _groundMesh, new THREE10.Mesh(geo, material));
+  __privateGet(this, _groundMesh).rotation.x = -Math.PI / 2;
+  __privateGet(this, _groundMesh).position.y = style?.YOrder ?? 0;
+  __privateGet(this, _scene2).add(__privateGet(this, _groundMesh));
+};
+updateGroundMesh_fn = function(centerWorldX, centerWorldZ) {
+  if (!__privateGet(this, _groundMesh)) return;
+  const size = (__privateGet(this, _mapConfig).renderDistance * 2 + 1) * __privateGet(this, _mapConfig).tileWorldSize;
+  __privateGet(this, _groundMesh).scale.set(size, size, 1);
+  __privateGet(this, _groundMesh).position.x = centerWorldX;
+  __privateGet(this, _groundMesh).position.z = centerWorldZ;
+};
+applyCenter_fn = function(centerTileX, centerTileY) {
+  const renderDistance = __privateGet(this, _mapConfig).renderDistance;
+  const tileWorldSize = __privateGet(this, _mapConfig).tileWorldSize;
+  const offset = __privateGet(this, _mapConfig).worldOriginOffset;
+  const isCircular = __privateGet(this, _mapConfig).tileLayout === TileLayout.CIRCULAR;
+  const r2 = renderDistance * renderDistance;
+  const needed = /* @__PURE__ */ new Map();
+  for (let tx = centerTileX - renderDistance; tx <= centerTileX + renderDistance; tx++) {
+    for (let ty = centerTileY - renderDistance; ty <= centerTileY + renderDistance; ty++) {
+      const cdx = tx - centerTileX;
+      const cdy = ty - centerTileY;
+      if (isCircular) {
+        const cx = centerTileX + 0.5;
+        const cy = centerTileY + 0.5;
+        const nearestX = Math.max(tx, Math.min(cx, tx + 1));
+        const nearestZ = Math.max(ty, Math.min(cy, ty + 1));
+        const dx2 = nearestX - cx;
+        const dz = nearestZ - cy;
+        if (dx2 * dx2 + dz * dz > r2) continue;
+      }
+      const dx = tx - __privateGet(this, _originTileX);
+      const dy = ty - __privateGet(this, _originTileY);
+      const key = `${dx}_${dy}`;
+      const worldX = (dx - __privateGet(this, _subTileOffsetX)) * tileWorldSize + offset.x;
+      const worldZ = (dy - __privateGet(this, _subTileOffsetY)) * tileWorldSize + offset.z;
+      needed.set(key, { tx, ty, worldX, worldZ, dist: cdx * cdx + cdy * cdy });
+    }
+  }
+  const centerWorldX = (centerTileX - __privateGet(this, _originTileX) - __privateGet(this, _subTileOffsetX) + 0.5) * tileWorldSize + offset.x;
+  const centerWorldZ = (centerTileY - __privateGet(this, _originTileY) - __privateGet(this, _subTileOffsetY) + 0.5) * tileWorldSize + offset.z;
+  __privateMethod(this, _TileManager_instances, updateGroundMesh_fn).call(this, centerWorldX, centerWorldZ);
+  for (const [key, controller] of __privateGet(this, _pendingTiles)) {
+    if (!needed.has(key)) {
+      controller.abort();
+      __privateGet(this, _pendingTiles).delete(key);
+    }
+  }
+  for (const [key, entry] of __privateGet(this, _doneTiles)) {
+    if (!needed.has(key)) {
+      entry.dispose();
+      __privateGet(this, _doneTiles).delete(key);
+    }
+  }
+  __privateSet(this, _fetchQueue, []);
+  for (const [key, data] of needed) {
+    if (!__privateGet(this, _doneTiles).has(key) && !__privateGet(this, _pendingTiles).has(key)) {
+      __privateGet(this, _fetchQueue).push({ key, ...data });
+    }
+  }
+  __privateGet(this, _fetchQueue).sort((a, b) => a.dist - b.dist);
+  __privateMethod(this, _TileManager_instances, drainQueue_fn).call(this);
+};
+drainQueue_fn = function() {
+  while (__privateGet(this, _activeFetches) < __privateGet(this, _maxConcurrentFetches) && __privateGet(this, _fetchQueue).length > 0) {
+    const item = __privateGet(this, _fetchQueue).shift();
+    if (__privateGet(this, _doneTiles).has(item.key) || __privateGet(this, _pendingTiles).has(item.key)) continue;
+    __privateWrapper(this, _activeFetches)._++;
+    __privateMethod(this, _TileManager_instances, fetchTile_fn).call(this, item);
+  }
+};
+fetchTile_fn = async function({ key, tx, ty, worldX, worldZ }) {
+  const controller = new AbortController();
+  __privateGet(this, _pendingTiles).set(key, controller);
+  const url = __privateGet(this, _tileProviderUrl).replace("{z}", __privateGet(this, _zoomLevel2)).replace("{x}", tx).replace("{y}", ty);
+  let result;
+  try {
     try {
-      try {
-        result = await fetchTileData(url, key, controller.signal);
-      } catch (err) {
-        if (err.name === "AbortError") {
-          return;
-        }
-        console.error(`ThreeGeoPlay: Fetch ${tx}/${ty} failed, retrying in 3 or 5 seconds...`, err);
-        const n = Math.floor(Math.random() * 4) + 3;
-        await new Promise((resolve) => setTimeout(resolve, n * 1e3));
-        if (!this.#pendingTiles.has(key) || controller.signal.aborted) {
-          return;
-        }
-        this.#fetchQueue.unshift({ key, tx, ty, worldX, worldZ, dist: 0 });
+      result = await fetchTileData(url, key, controller.signal);
+    } catch (err) {
+      if (err.name === "AbortError") {
         return;
       }
-      if (!result || this.#doneTiles.has(key) || !this.#pendingTiles.has(key)) {
+      console.error(`ThreeGeoPlay: Fetch ${tx}/${ty} failed, retrying in 3 or 5 seconds...`, err);
+      const n = Math.floor(Math.random() * 4) + 3;
+      await new Promise((resolve) => setTimeout(resolve, n * 1e3));
+      if (!__privateGet(this, _pendingTiles).has(key) || controller.signal.aborted) {
         return;
       }
-      try {
-        const tile = new Tile(
-          [worldX, worldZ],
-          result.payload,
-          this.#scene,
-          this.#mapConfig
-        );
-        await tile.render(controller.signal);
-        this.#doneTiles.set(key, {
-          tile,
-          dispose: () => tile.destroy()
-        });
-      } catch (err) {
-        if (err.name === "AbortError") {
-          return;
-        }
-        console.error(`ThreeGeoPlay: Tile ${tx}/${ty} render failed (no retry)`, err);
-      }
-    } finally {
-      this.#pendingTiles.delete(key);
-      this.#activeFetches--;
-      this.#drainQueue();
+      __privateGet(this, _fetchQueue).unshift({ key, tx, ty, worldX, worldZ, dist: 0 });
+      return;
     }
-  }
-  destroy() {
-    for (const [, c] of this.#pendingTiles) c.abort();
-    for (const [, t] of this.#doneTiles) t.dispose();
-    this.#pendingTiles.clear();
-    this.#doneTiles.clear();
-    this.#fetchQueue = [];
-    this.#activeFetches = 0;
-    if (this.#groundMesh) {
-      this.#scene.remove(this.#groundMesh);
-      this.#groundMesh.geometry.dispose();
-      this.#groundMesh = null;
+    if (!result || __privateGet(this, _doneTiles).has(key) || !__privateGet(this, _pendingTiles).has(key)) {
+      return;
+    }
+    try {
+      const tile = new Tile(
+        [worldX, worldZ],
+        result.payload,
+        __privateGet(this, _scene2),
+        __privateGet(this, _mapConfig)
+      );
+      await tile.render(controller.signal);
+      __privateGet(this, _doneTiles).set(key, {
+        tile,
+        dispose: () => tile.destroy()
+      });
+    } catch (err) {
+      if (err.name === "AbortError") {
+        return;
+      }
+      console.error(`ThreeGeoPlay: Tile ${tx}/${ty} render failed (no retry)`, err);
     }
+  } finally {
+    __privateGet(this, _pendingTiles).delete(key);
+    __privateWrapper(this, _activeFetches)._--;
+    __privateMethod(this, _TileManager_instances, drainQueue_fn).call(this);
   }
 };
 
 // src/ThreeGeoPlay.js
+var _isStarted, _lastTime, _mapConfig2, _mapStyle2, _scene3, _camera, _renderer, _followTarget, _ThreeGeoPlay_instances, validateConstructorParams_fn, validateConfig_fn, validateStyle_fn;
 var ThreeGeoPlay = class {
-  /** @type {boolean} Whether the map has been started */
-  #isStarted = false;
-  #lastTime = Date.now();
-  /** @type {MapConfig} Map configuration instance */
-  #mapConfig = null;
-  /** @type {MapStyle} Map style instance */
-  #mapStyle = null;
-  /** @type {THREE.Scene} Three.js scene */
-  #scene = null;
-  /** @type {THREE.Camera} Three.js camera */
-  #camera = null;
-  /** @type {THREE.WebGLRenderer} Three.js renderer */
-  #renderer = null;
-  /** @type {THREE.Object3D|null} Target object to follow when viewMode is FOLLOW_TARGET (camera by default) */
-  #followTarget = null;
   /**
-   * @param {THREE.Scene} threeScene - Three.js scene
-   * @param {THREE.Camera} threeCamera - Three.js camera
-   * @param {THREE.WebGLRenderer} threeRenderer - Three.js renderer
+   * @param {THREE.Scene}         threeScene    - Three.js scene.
+   * @param {THREE.Camera}        threeCamera   - Three.js camera (also the default follow target).
+   * @param {THREE.WebGLRenderer} threeRenderer - Three.js renderer.
+   * @throws {Error} If any parameter is missing.
    */
   constructor(threeScene, threeCamera, threeRenderer) {
-    this.#validateConstructorParams(threeScene, threeCamera, threeRenderer);
-    this.#scene = threeScene;
-    this.#camera = threeCamera;
-    this.#followTarget = threeCamera;
-    this.#renderer = threeRenderer;
+    __privateAdd(this, _ThreeGeoPlay_instances);
+    /** @type {boolean} */
+    __privateAdd(this, _isStarted, false);
+    /** @type {number} */
+    __privateAdd(this, _lastTime, Date.now());
+    /** @type {MapConfig} */
+    __privateAdd(this, _mapConfig2, null);
+    /** @type {MapStyle} */
+    __privateAdd(this, _mapStyle2, null);
+    /** @type {THREE.Scene} */
+    __privateAdd(this, _scene3, null);
+    /** @type {THREE.Camera} */
+    __privateAdd(this, _camera, null);
+    /** @type {THREE.WebGLRenderer} */
+    __privateAdd(this, _renderer, null);
+    /**
+     * The Three.js Object3D whose position the map tracks in {@link ViewMode.FOLLOW_TARGET} mode.
+     * Defaults to the camera passed to the constructor.
+     * @type {THREE.Object3D}
+     */
+    __privateAdd(this, _followTarget, null);
+    __privateMethod(this, _ThreeGeoPlay_instances, validateConstructorParams_fn).call(this, threeScene, threeCamera, threeRenderer);
+    __privateSet(this, _scene3, threeScene);
+    __privateSet(this, _camera, threeCamera);
+    __privateSet(this, _followTarget, threeCamera);
+    __privateSet(this, _renderer, threeRenderer);
     threeRenderer.localClippingEnabled = true;
-    this.#mapConfig = new MapConfig();
-    this.#mapStyle = new MapStyle();
-  }
-  /**
-   * Validates constructor parameters
-   * @private
-   * @param {THREE.Scene} scene - Three.js scene
-   * @param {THREE.Camera} camera - Three.js camera
-   * @param {THREE.WebGLRenderer} renderer - Three.js renderer
-   * @throws {Error} If any parameter is missing
-   */
-  #validateConstructorParams(scene, camera, renderer) {
-    if (!scene) {
-      throw new Error("ThreeGeoPlay: threeScene is required");
-    }
-    if (!camera) {
-      throw new Error("ThreeGeoPlay: threeCamera is required");
-    }
-    if (!renderer) {
-      throw new Error("ThreeGeoPlay: threeRenderer is required");
-    }
-  }
-  /**
-   * Validates MapConfig instance
-   * @private
-   * @param {MapConfig} config - Configuration to validate
-   * @returns {boolean} True if valid
-   */
-  #validateConfig(config) {
-    if (!config) {
-      return false;
-    }
-    if (!(config instanceof MapConfig)) {
-      console.warn("ThreeGeoPlay: MapConfig must be an instance of MapConfig");
-      return false;
-    }
-    return true;
+    __privateSet(this, _mapConfig2, new MapConfig());
+    __privateSet(this, _mapStyle2, new MapStyle());
   }
+  // ─── Public API ──────────────────────────────────────────────────────────
   /**
-   * Validates MapStyle instance
-   * @private
-   * @param {MapStyle} style - Style to validate
-   * @returns {boolean} True if valid
-   */
-  #validateStyle(style) {
-    if (!style) {
-      return false;
-    }
-    if (!(style instanceof MapStyle)) {
-      console.warn("ThreeGeoPlay: MapStyle must be an instance of MapStyle");
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Set the target object for the map to follow
-   * When viewMode is FOLLOW_TARGET, the map origin will automatically update 
-   * to match this target's position (X-Z plane only, Y-axis ignored)
-   * @param {THREE.Object3D} target - Three.js object to follow (e.g., camera, player mesh)
-   * @throws {Error} If target is not a valid Three.js Object3D
+   * Sets the object the map will follow in {@link ViewMode.FOLLOW_TARGET} mode.
+   * If the current `viewMode` is not `FOLLOW_TARGET` it is switched automatically.
+   *
+   * @param {THREE.Object3D} target - Any Three.js Object3D (mesh, group, camera, …).
+   * @throws {Error} If `target` is not a valid Three.js Object3D with a position.
+   *
+   * @example
+   * const playerMesh = new THREE.Mesh(geometry, material);
+   * geoPlay.setFollowTarget(playerMesh);
    */
   setFollowTarget(target) {
     if (!target) {
@@ -8368,114 +9204,89 @@ var ThreeGeoPlay = class {
     if (!target.position || typeof target.position.x !== "number" || typeof target.position.z !== "number") {
       throw new Error("ThreeGeoPlay: Follow target must have a valid position property with x and z coordinates");
     }
-    this.#followTarget = target;
-    if (this.#mapConfig.viewMode !== ViewMode.FOLLOW_TARGET) {
+    __privateSet(this, _followTarget, target);
+    if (__privateGet(this, _mapConfig2).viewMode !== ViewMode.FOLLOW_TARGET) {
       console.warn("ThreeGeoPlay: ViewMode was not set to FOLLOW_TARGET. Automatically switching to FOLLOW_TARGET mode.");
-      this.#mapConfig.viewMode = ViewMode.FOLLOW_TARGET;
+      __privateGet(this, _mapConfig2).viewMode = ViewMode.FOLLOW_TARGET;
     }
   }
   /**
-   * Manually move map origin to specified geographic coordinates
-   * Works in MANUAL and STATIC modes. In FOLLOW_TARGET mode, this is ignored.
-   * @param {number} lat - Latitude (-90 to 90)
-   * @param {number} lon - Longitude (-180 to 180)
-   * @throws {Error} If coordinates are invalid
-   * @returns {void}
+   * Moves the map origin to the given geographic coordinates.
+   * Only effective in {@link ViewMode.MANUAL} or `STATIC` mode — ignored (with a warning)
+   * in {@link ViewMode.FOLLOW_TARGET}.
+   *
+   * @param {number} lat - Latitude in degrees (−90 … 90).
+   * @param {number} lon - Longitude in degrees (−180 … 180).
+   * @throws {Error} If either coordinate is out of range or not a number.
+   *
+   * @example
+   * geoPlay.getMapConfig().viewMode = ViewMode.MANUAL;
+   * geoPlay.moveMapOriginToLatLon(48.8566, 2.3522); // Paris
    */
   moveMapOriginToLatLon(lat, lon) {
-    if (this.#mapConfig.viewMode === ViewMode.FOLLOW_TARGET) {
+    if (__privateGet(this, _mapConfig2).viewMode === ViewMode.FOLLOW_TARGET) {
       console.warn("ThreeGeoPlay: ViewMode was set to FOLLOW_TARGET. Automatically switching to MANUAL mode.");
       return;
     }
-    if (typeof lat !== "number" || isNaN(lat)) {
-      throw new Error(`Invalid latitude: ${lat}. Must be a number`);
-    }
-    if (lat < -90 || lat > 90) {
-      throw new Error(`Invalid latitude: ${lat}. Must be between -90 and 90`);
-    }
-    if (typeof lon !== "number" || isNaN(lon)) {
-      throw new Error(`Invalid longitude: ${lon}. Must be a number`);
-    }
-    if (lon < -180 || lon > 180) {
-      throw new Error(`Invalid longitude: ${lon}. Must be between -180 and 180`);
-    }
-    this.#mapConfig.originLatLon = { lat, lon };
+    if (typeof lat !== "number" || isNaN(lat)) throw new Error(`Invalid latitude: ${lat}. Must be a number`);
+    if (lat < -90 || lat > 90) throw new Error(`Invalid latitude: ${lat}. Must be between -90 and 90`);
+    if (typeof lon !== "number" || isNaN(lon)) throw new Error(`Invalid longitude: ${lon}. Must be a number`);
+    if (lon < -180 || lon > 180) throw new Error(`Invalid longitude: ${lon}. Must be between -180 and 180`);
+    __privateGet(this, _mapConfig2).originLatLon = { lat, lon };
   }
   /**
-   * Manually move map origin to specified 3D world position
-   * Converts X-Z coordinates to geographic coordinates automatically.
-   * Works in MANUAL and STATIC modes. In FOLLOW_TARGET mode, this is ignored.
-   * @param {number} x - X coordinate in 3D world space
-   * @param {number} z - Z coordinate in 3D world space
-   * @throws {Error} If coordinates are invalid
-   * @returns {void}
+   * Moves the map origin to match the given Three.js world-space X/Z position.
+   * If the current mode is {@link ViewMode.FOLLOW_TARGET} it is automatically
+   * switched to {@link ViewMode.MANUAL}.
+   *
+   * @param {number} x - X coordinate in Three.js world space.
+   * @param {number} z - Z coordinate in Three.js world space.
+   * @throws {Error} If either coordinate is not a valid number.
    */
   moveMapOriginToPosition(x, z) {
-    if (this.#mapConfig.viewMode === ViewMode.FOLLOW_TARGET) {
+    if (__privateGet(this, _mapConfig2).viewMode === ViewMode.FOLLOW_TARGET) {
       console.warn("ThreeGeoPlay: ViewMode was set to FOLLOW_TARGET. Automatically switching to MANUAL mode.");
-      this.#mapConfig.viewMode = ViewMode.MANUAL;
-    }
-    if (typeof x !== "number" || isNaN(x)) {
-      throw new Error(`Invalid x coordinate: ${x}. Must be a number`);
-    }
-    if (typeof z !== "number" || isNaN(z)) {
-      throw new Error(`Invalid z coordinate: ${z}. Must be a number`);
+      __privateGet(this, _mapConfig2).viewMode = ViewMode.MANUAL;
     }
+    if (typeof x !== "number" || isNaN(x)) throw new Error(`Invalid x coordinate: ${x}. Must be a number`);
+    if (typeof z !== "number" || isNaN(z)) throw new Error(`Invalid z coordinate: ${z}. Must be a number`);
   }
   /**
-   * Starts rendering the map into the scene.
-   * Triggers the initial tile fetch and geometry generation based on the current MapConfig.
-   * @throws {Error} If start() has already been called
-   * @returns {void}
+   * Initialises the map, loads the first set of tiles and adds geometry to the scene.
+   * Call this once, after configuring {@link MapConfig} and {@link MapStyle}.
+   *
+   * @throws {Error} If called more than once.
    */
   start() {
-    if (this.#isStarted) {
+    if (__privateGet(this, _isStarted)) {
       console.warn("ThreeGeoPlay: Already started");
       return;
     }
-    this.tileManager = new TileManager(this.#mapConfig, this.#scene);
+    this.tileManager = new TileManager(__privateGet(this, _mapConfig2), __privateGet(this, _scene3));
     this.tileManager.init();
-    this.#isStarted = true;
+    __privateSet(this, _isStarted, true);
   }
   /**
-   * Updates ThreeGeoPlay internal state for the current frame.
-   *
-   * This method **must be called inside the user's Three.js animation loop**
-   * (e.g. inside the function passed to `requestAnimationFrame`).
-   * It is responsible for handling automatic map updates such as
-   * FOLLOW_TARGET tracking and time-based updates.
+   * Processes per-frame updates: applies dirty config changes, updates tile
+   * borders, and (in {@link ViewMode.FOLLOW_TARGET} mode) repositions the map
+   * origin to track the follow target.
    *
-   * If this method is not called every frame, features like
-   * FOLLOW_TARGET mode and interval-based map updates will not work correctly.
+   * **Must be called every frame inside your Three.js animation loop.**
    *
-   * Example usage:
-   *
-   * ```js
+   * @example
    * function animate() {
    *   requestAnimationFrame(animate);
-   *
    *   geoPlay.onFrameUpdate();
-   *
    *   renderer.render(scene, camera);
    * }
-   * ```
-   *
-   * @returns {void}
    */
   onFrameUpdate() {
-    var _a, _b, _c, _d, _e;
-    (_a = this.tileManager) == null ? void 0 : _a.updateBorders();
-    if (this.#mapConfig._isDirty) {
-      const dirty = this.#mapConfig._dirtyFields;
-      if (dirty.has("tileWorldSize")) {
-        (_b = this.tileManager) == null ? void 0 : _b.rescaleTiles(this.#mapConfig.tileWorldSize);
-      }
-      if (dirty.has("renderDistance")) {
-        (_c = this.tileManager) == null ? void 0 : _c.applyCenter();
-      }
-      if (dirty.has("mapStyle")) {
-        (_d = this.tileManager) == null ? void 0 : _d.updateMaterials();
-      }
+    this.tileManager?.updateBorders();
+    if (__privateGet(this, _mapConfig2)._isDirty) {
+      const dirty = __privateGet(this, _mapConfig2)._dirtyFields;
+      if (dirty.has("tileWorldSize")) this.tileManager?.rescaleTiles(__privateGet(this, _mapConfig2).tileWorldSize);
+      if (dirty.has("renderDistance")) this.tileManager?.applyCenter();
+      if (dirty.has("mapStyle")) this.tileManager?.updateMaterials();
       const needsRebuild = [
         "zoomLevel",
         "pbfTileProviderZXYurl",
@@ -8484,96 +9295,146 @@ var ThreeGeoPlay = class {
         "originLatLon"
       ].some((f) => dirty.has(f));
       if (needsRebuild) {
-        (_e = this.tileManager) == null ? void 0 : _e.destroy();
-        this.tileManager = new TileManager(this.#mapConfig, this.#scene);
+        this.tileManager?.destroy();
+        this.tileManager = new TileManager(__privateGet(this, _mapConfig2), __privateGet(this, _scene3));
         this.tileManager.init();
       }
-      this.#mapConfig.flushDirtyState();
+      __privateGet(this, _mapConfig2).flushDirtyState();
     }
-    if (this.#mapConfig.viewMode === ViewMode.FOLLOW_TARGET) {
+    if (__privateGet(this, _mapConfig2).viewMode === ViewMode.FOLLOW_TARGET) {
       const t = Date.now();
-      const interval = this.#mapConfig.FollowUpdateInterval;
-      console.log(this.#mapConfig.FollowUpdateInterval);
-      if (interval === 0 || t - this.#lastTime >= interval) {
-        this.#lastTime = t;
+      const interval = __privateGet(this, _mapConfig2).FollowUpdateInterval;
+      if (interval === 0 || t - __privateGet(this, _lastTime) >= interval) {
+        __privateSet(this, _lastTime, t);
         this.tileManager.updateCenterFromPosition(
-          this.#followTarget.position.x,
-          this.#followTarget.position.z
+          __privateGet(this, _followTarget).position.x,
+          __privateGet(this, _followTarget).position.z
         );
       }
     }
   }
   /**
-   * Gets the current map configuration
-   * @returns {MapConfig} Current map configuration instance
+   * Returns the active {@link MapConfig} instance.
+   * Modify its properties directly to adjust zoom, render distance, tile layout, etc.
+   * @returns {MapConfig}
    */
   getMapConfig() {
-    return this.#mapConfig;
+    return __privateGet(this, _mapConfig2);
   }
   /**
-   * Replaces the current map configuration and applies it immediately.
-   * To update individual settings, modify a MapConfig instance and pass it here.
-   * @param {MapConfig} mapConfig - New map configuration instance
-   * @throws {Error} If config is invalid or not a MapConfig instance
+   * Replaces the entire map configuration.
+   * The new config is applied on the next {@link onFrameUpdate} call.
+   *
+   * @param {MapConfig} mapConfig - A fully constructed {@link MapConfig} instance.
+   * @throws {Error} If `mapConfig` is not a valid {@link MapConfig} instance.
    */
   setMapConfig(mapConfig) {
-    if (!this.#validateConfig(mapConfig)) {
+    if (!__privateMethod(this, _ThreeGeoPlay_instances, validateConfig_fn).call(this, mapConfig)) {
       throw new Error("ThreeGeoPlay: Invalid MapConfig provided");
     }
-    this.#mapConfig = mapConfig;
+    __privateSet(this, _mapConfig2, mapConfig);
   }
   /**
-   * Gets the current map style
-   * @returns {MapStyle} Current map style instance
+   * Returns the active {@link MapStyle} instance.
+   * @returns {MapStyle}
    */
   getMapStyle() {
-    return this.#mapStyle;
+    return __privateGet(this, _mapStyle2);
   }
   /**
-   * Sets a new map style
-   * @param {MapStyle} mapStyle - New map style instance
-   * @throws {Error} If style is invalid or not a MapStyle instance
+   * Replaces the active map style.
+   *
+   * @param {MapStyle} mapStyle - A fully constructed {@link MapStyle} instance.
+   * @throws {Error} If `mapStyle` is not a valid {@link MapStyle} instance.
    */
   setMapStyle(mapStyle) {
-    if (!this.#validateStyle(mapStyle)) {
+    if (!__privateMethod(this, _ThreeGeoPlay_instances, validateStyle_fn).call(this, mapStyle)) {
       throw new Error("ThreeGeoPlay: Invalid MapStyle provided");
     }
-    this.#mapStyle = mapStyle;
+    __privateSet(this, _mapStyle2, mapStyle);
   }
   /**
-   * Gets the Three.js scene
-   * @returns {THREE.Scene} The Three.js scene instance
+   * Returns the Three.js scene passed to the constructor.
+   * @returns {THREE.Scene}
    */
   getScene() {
-    return this.#scene;
+    return __privateGet(this, _scene3);
   }
   /**
-   * Gets the Three.js camera
-   * @returns {THREE.Camera} The Three.js camera instance
+   * Returns the Three.js camera passed to the constructor.
+   * @returns {THREE.Camera}
    */
   getCamera() {
-    return this.#camera;
+    return __privateGet(this, _camera);
   }
   /**
-   * Gets the Three.js renderer
-   * @returns {THREE.WebGLRenderer} The Three.js renderer instance
+   * Returns the Three.js renderer passed to the constructor.
+   * @returns {THREE.WebGLRenderer}
    */
   getRenderer() {
-    return this.#renderer;
+    return __privateGet(this, _renderer);
   }
   /**
-   * Destroys ThreeGeoPlay and cleans up all resources
-   * @returns {void}
+   * Destroys the ThreeGeoPlay instance and releases all held references.
+   * After calling this method the instance must not be used again.
    */
   destroy() {
-    this.#scene = null;
-    this.#camera = null;
-    this.#renderer = null;
-    this.#mapConfig = null;
-    this.#mapStyle = null;
-    this.#lastTime = null;
+    __privateSet(this, _scene3, null);
+    __privateSet(this, _camera, null);
+    __privateSet(this, _renderer, null);
+    __privateSet(this, _mapConfig2, null);
+    __privateSet(this, _mapStyle2, null);
+    __privateSet(this, _lastTime, null);
   }
 };
+_isStarted = new WeakMap();
+_lastTime = new WeakMap();
+_mapConfig2 = new WeakMap();
+_mapStyle2 = new WeakMap();
+_scene3 = new WeakMap();
+_camera = new WeakMap();
+_renderer = new WeakMap();
+_followTarget = new WeakMap();
+_ThreeGeoPlay_instances = new WeakSet();
+// ─── Private helpers ─────────────────────────────────────────────────────
+/**
+ * @param {THREE.Scene}         scene
+ * @param {THREE.Camera}        camera
+ * @param {THREE.WebGLRenderer} renderer
+ * @throws {Error}
+ * @private
+ */
+validateConstructorParams_fn = function(scene, camera, renderer) {
+  if (!scene) throw new Error("ThreeGeoPlay: threeScene is required");
+  if (!camera) throw new Error("ThreeGeoPlay: threeCamera is required");
+  if (!renderer) throw new Error("ThreeGeoPlay: threeRenderer is required");
+};
+/**
+ * @param {MapConfig} config
+ * @returns {boolean}
+ * @private
+ */
+validateConfig_fn = function(config) {
+  if (!config) return false;
+  if (!(config instanceof MapConfig)) {
+    console.warn("ThreeGeoPlay: MapConfig must be an instance of MapConfig");
+    return false;
+  }
+  return true;
+};
+/**
+ * @param {MapStyle} style
+ * @returns {boolean}
+ * @private
+ */
+validateStyle_fn = function(style) {
+  if (!style) return false;
+  if (!(style instanceof MapStyle)) {
+    console.warn("ThreeGeoPlay: MapStyle must be an instance of MapStyle");
+    return false;
+  }
+  return true;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MapConfig,
@@ -8582,4 +9443,3 @@ var ThreeGeoPlay = class {
   TileLayout,
   ViewMode
 });
-//# sourceMappingURL=index.js.map