esri-gl 0.9.0 → 0.10.0

package/dist/IdentifyImage-DWBF8K_a.js

@@ -0,0 +1,4277 @@
+import * as tilebelt from '@mapbox/tilebelt';
+import tileDecode from 'arcgis-pbf-parser';
+
+function cleanTrailingSlash(url) {
+  return url.replace(/\/$/, '');
+}
+/**
+ * Check if an error represents an AbortError (request was cancelled)
+ * Handles various error shapes from different browsers and environments
+ */
+function isAbortError(error) {
+  if (!error) return false;
+  // Standard DOMException check
+  if (typeof DOMException !== 'undefined' && error instanceof DOMException) {
+    return error.name === 'AbortError';
+  }
+  // Error instance checks
+  if (error instanceof Error) {
+    if (error.name === 'AbortError') return true;
+    if (error.message?.toLowerCase().includes('abort')) return true;
+  }
+  // Duck typing for error-like objects
+  const errorObj = error;
+  if (errorObj.name === 'AbortError') return true;
+  if (errorObj.constructor?.name === 'AbortError') return true;
+  // String check
+  const stringified = String(error).toLowerCase();
+  return stringified.includes('abort');
+}
+async function getServiceDetails(url, fetchOptions = {}, token) {
+  const params = new URLSearchParams({
+    f: 'json'
+  });
+  if (token) {
+    params.append('token', token);
+  }
+  const response = await fetch(`${url}?${params.toString()}`, fetchOptions);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch service details: HTTP ${response.status}`);
+  }
+  const data = await response.json();
+  if (data.error) {
+    throw new Error(data.error.message || 'Service returned an error');
+  }
+  return data;
+}
+const POWERED_BY_ESRI_ATTRIBUTION_STRING = 'Powered by <a href="https://www.esri.com">Esri</a>';
+// This requires hooking into some undocumented properties
+function updateAttribution(newAttribution, sourceId, map) {
+  // Accessing undocumented MapLibre/Mapbox internal properties
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const mapWithControls = map;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const attributionController = mapWithControls._controls?.find(c => '_attribHTML' in c);
+  if (!attributionController) return;
+  const customAttribution = attributionController.options?.customAttribution;
+  if (typeof customAttribution === 'string') {
+    if (!customAttribution.includes(POWERED_BY_ESRI_ATTRIBUTION_STRING)) {
+      attributionController.options.customAttribution = `${customAttribution} | ${POWERED_BY_ESRI_ATTRIBUTION_STRING}`;
+    }
+  } else if (customAttribution === undefined) {
+    if (attributionController.options) {
+      attributionController.options.customAttribution = POWERED_BY_ESRI_ATTRIBUTION_STRING;
+    }
+  } else if (Array.isArray(customAttribution)) {
+    if (customAttribution.indexOf(POWERED_BY_ESRI_ATTRIBUTION_STRING) === -1) {
+      customAttribution.push(POWERED_BY_ESRI_ATTRIBUTION_STRING);
+    }
+  }
+  // Accessing undocumented map style properties
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const mapStyle = map.style;
+  if (mapStyle?.sourceCaches?.[sourceId]?._source) {
+    mapStyle.sourceCaches[sourceId]._source.attribution = newAttribution;
+  } else if (mapStyle?._otherSourceCaches?.[sourceId]?._source) {
+    mapStyle._otherSourceCaches[sourceId]._source.attribution = newAttribution;
+  } else {
+    // Source may not be registered in style caches yet (async attribution fetch race).
+    // Silently skip — attribution will be set when the source is ready.
+    return;
+  }
+  // Call undocumented method to update attribution display
+  if (attributionController._updateAttributions) {
+    attributionController._updateAttributions();
+  }
+}
+
+/**
+ * Base Service class for ArcGIS REST API services
+ * Similar to Esri Leaflet's Service class
+ */
+class Service {
+  constructor(options) {
+    Object.defineProperty(this, "options", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_requestQueue", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: []
+    });
+    Object.defineProperty(this, "_authenticating", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: false
+    });
+    Object.defineProperty(this, "_serviceMetadata", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "_map", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_eventListeners", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {}
+    });
+    if (!options.url) {
+      throw new Error('A url must be supplied as part of the service options.');
+    }
+    this.options = {
+      proxy: false,
+      useCors: true,
+      timeout: 0,
+      getAttributionFromService: true,
+      ...options,
+      url: cleanTrailingSlash(options.url)
+    };
+  }
+  /**
+   * Make a GET request
+   */
+  async get(path, params = {}) {
+    return this._request('GET', path, params);
+  }
+  /**
+   * Make a POST request
+   */
+  async post(path, params = {}) {
+    return this._request('POST', path, params);
+  }
+  /**
+   * Make a generic request
+   */
+  async request(path, params = {}) {
+    return this._request('GET', path, params);
+  }
+  /**
+   * Make a request with callback support (public for Tasks)
+   */
+  requestWithCallback(method, path, params, callback) {
+    if (callback) {
+      this._requestWithCallback(method, path, params, callback);
+      return;
+    }
+    return this._request(method, path, params);
+  }
+  /**
+   * Get service metadata
+   */
+  async metadata() {
+    if (this._serviceMetadata) {
+      return this._serviceMetadata;
+    }
+    try {
+      const response = await this._request('GET', '', {
+        f: 'json'
+      });
+      this._serviceMetadata = response;
+      return this._serviceMetadata;
+    } catch (error) {
+      const isTestEnvironment = typeof process !== 'undefined' && process.env?.NODE_ENV === 'test';
+      if (!isTestEnvironment) {
+        console.error('Error fetching service metadata:', error);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Set authentication token
+   */
+  authenticate(token) {
+    this._authenticating = false;
+    this.options.token = token;
+    this._runQueue();
+    return this;
+  }
+  /**
+   * Get request timeout
+   */
+  getTimeout() {
+    return this.options.timeout;
+  }
+  /**
+   * Set request timeout
+   */
+  setTimeout(timeout) {
+    this.options.timeout = timeout;
+    return this;
+  }
+  /**
+   * Set attribution from service metadata
+   */
+  async setAttributionFromService() {
+    if (!this._map) {
+      return;
+    }
+    if (this._serviceMetadata) {
+      updateAttribution(this._serviceMetadata.copyrightText || '', 'service', this._map);
+      return;
+    }
+    try {
+      await this.metadata();
+      if (this._serviceMetadata && typeof this._serviceMetadata === 'object') {
+        const metadata = this._serviceMetadata;
+        updateAttribution(metadata?.copyrightText || '', 'service', this._map);
+      }
+    } catch (error) {
+      console.warn('Could not fetch service attribution:', error);
+    }
+  }
+  /**
+   * Add event listener
+   */
+  on(event, callback) {
+    if (!this._eventListeners[event]) {
+      this._eventListeners[event] = [];
+    }
+    this._eventListeners[event].push(callback);
+    return this;
+  }
+  /**
+   * Remove event listener
+   */
+  off(event, callback) {
+    const listeners = this._eventListeners[event];
+    if (listeners) {
+      const index = listeners.indexOf(callback);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    }
+    return this;
+  }
+  /**
+   * Fire an event
+   */
+  fire(event, data) {
+    const listeners = this._eventListeners[event];
+    if (listeners) {
+      listeners.forEach(callback => callback(data));
+    }
+    return this;
+  }
+  // Private methods
+  _requestWithCallback(method, path, params, callback) {
+    this.fire('requeststart', {
+      url: this.options.url + path,
+      params,
+      method
+    });
+    const wrappedCallback = this._createServiceCallback(method, path, params, (error, response) => {
+      callback(error, response);
+    });
+    let finalParams = {
+      ...params
+    };
+    if (this.options.token) {
+      finalParams.token = this.options.token;
+    }
+    if (this.options.requestParams) {
+      finalParams = {
+        ...finalParams,
+        ...this.options.requestParams
+      };
+    }
+    if (this._authenticating) {
+      this._requestQueue.push([method, path, finalParams, wrappedCallback, this]);
+    } else {
+      this._makeRequest(method, path, finalParams, wrappedCallback);
+    }
+  }
+  async _request(method, path, params) {
+    this.fire('requeststart', {
+      url: this.options.url + path,
+      params,
+      method
+    });
+    return new Promise((resolve, reject) => {
+      const wrappedCallback = this._createServiceCallback(method, path, params, (error, response) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(response);
+        }
+      });
+      let finalParams = {
+        ...params
+      };
+      if (this.options.token) {
+        finalParams.token = this.options.token;
+      }
+      if (this.options.requestParams) {
+        finalParams = {
+          ...finalParams,
+          ...this.options.requestParams
+        };
+      }
+      if (this._authenticating) {
+        this._requestQueue.push([method, path, finalParams, wrappedCallback, this]);
+      } else {
+        this._makeRequest(method, path, finalParams, wrappedCallback);
+      }
+    });
+  }
+  async _makeRequest(method, path, params, callback) {
+    const url = this.options.proxy ? `${this.options.proxy}?${this.options.url}${path}` : `${this.options.url}${path}`;
+    // Set up abort controller for timeout support
+    const controller = new AbortController();
+    let timeoutId;
+    if (this.options.timeout > 0) {
+      timeoutId = setTimeout(() => {
+        controller.abort();
+      }, this.options.timeout);
+    }
+    try {
+      let response;
+      const fetchOptions = {
+        signal: controller.signal
+      };
+      // Add API key header if present
+      if (this.options.apiKey) {
+        fetchOptions.headers = {
+          'X-Esri-Authorization': `Bearer ${this.options.apiKey}`
+        };
+      }
+      if (method === 'POST') {
+        const formData = new FormData();
+        Object.keys(params).forEach(key => {
+          const value = params[key];
+          if (value !== undefined && value !== null) {
+            if (typeof value === 'object') {
+              formData.append(key, JSON.stringify(value));
+            } else {
+              formData.append(key, value.toString());
+            }
+          }
+        });
+        response = await fetch(url, {
+          ...fetchOptions,
+          method: 'POST',
+          body: formData
+        });
+      } else {
+        const searchParams = new URLSearchParams();
+        Object.keys(params).forEach(key => {
+          const value = params[key];
+          if (value !== undefined && value !== null) {
+            if (Array.isArray(value)) {
+              searchParams.append(key, value.join(','));
+            } else if (typeof value === 'object') {
+              searchParams.append(key, JSON.stringify(value));
+            } else {
+              searchParams.append(key, value.toString());
+            }
+          }
+        });
+        const fullUrl = `${url}?${searchParams.toString()}`;
+        response = await fetch(fullUrl, fetchOptions);
+      }
+      if (!response.ok) {
+        const error = new Error(`HTTP error! status: ${response.status}`);
+        error.code = response.status;
+        throw error;
+      }
+      const data = await response.json();
+      // Check for AGOL JSON-level errors (HTTP 200 with error body)
+      if (data && typeof data === 'object' && data.error) {
+        const err = new Error(data.error.message || 'ArcGIS service error');
+        err.code = data.error.code;
+        err.details = data.error.details;
+        callback(err);
+        return;
+      }
+      callback(undefined, data);
+    } catch (error) {
+      // Provide clearer error message for timeout
+      if (error instanceof Error && error.name === 'AbortError' && this.options.timeout > 0) {
+        const timeoutError = new Error(`Request timed out after ${this.options.timeout}ms`);
+        callback(timeoutError);
+      } else {
+        callback(error);
+      }
+    } finally {
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  _createServiceCallback(method, path, params, callback) {
+    return (error, response) => {
+      // Check if error has authentication-related status codes
+      const errorWithCode = error;
+      if (error && (errorWithCode.code === 499 || errorWithCode.code === 498)) {
+        this._authenticating = true;
+        this._requestQueue.push([method, path, params, callback, this]);
+        // Fire event for users to handle re-authentication
+        this.fire('authenticationrequired', {
+          authenticate: token => this.authenticate(token)
+        });
+        // Add authenticate method to error for callback handling
+        const authError = error;
+        authError.authenticate = token => this.authenticate(token);
+        return;
+      }
+      if (error) {
+        this.fire('requesterror', {
+          url: this.options.url + path,
+          params,
+          message: error.message,
+          code: errorWithCode.code,
+          method
+        });
+      } else {
+        this.fire('requestsuccess', {
+          url: this.options.url + path,
+          params,
+          response,
+          method
+        });
+      }
+      this.fire('requestend', {
+        url: this.options.url + path,
+        params,
+        method
+      });
+      callback(error, response);
+    };
+  }
+  _runQueue() {
+    for (let i = this._requestQueue.length - 1; i >= 0; i--) {
+      const request = this._requestQueue[i];
+      const [method, path, params, callback] = request;
+      if (callback) {
+        this._makeRequest(method, path, params, callback);
+      }
+    }
+    this._requestQueue = [];
+  }
+}
+
+class DynamicMapService {
+  constructor(sourceId, map, esriServiceOptions, rasterSrcOptions) {
+    Object.defineProperty(this, "_sourceId", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_map", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_defaultEsriOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_serviceMetadata", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "_pendingUpdate", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "_lastUpdateTime", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 0
+    });
+    Object.defineProperty(this, "_updateDelay", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 50
+    }); // ms debounce to avoid rapid successive aborts
+    Object.defineProperty(this, "rasterSrcOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "esriServiceOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    // Transaction-like updates
+    Object.defineProperty(this, "_pendingUpdates", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    if (!esriServiceOptions.url) {
+      throw new Error('A url must be supplied as part of the esriServiceOptions object.');
+    }
+    esriServiceOptions.url = cleanTrailingSlash(esriServiceOptions.url);
+    this._sourceId = sourceId;
+    this._map = map;
+    this._defaultEsriOptions = {
+      layers: false,
+      layerDefs: false,
+      dynamicLayers: false,
+      format: 'png24',
+      dpi: 96,
+      transparent: true,
+      getAttributionFromService: true
+    };
+    this.rasterSrcOptions = rasterSrcOptions;
+    this.esriServiceOptions = esriServiceOptions;
+    this._createSource();
+    if (this.options.getAttributionFromService) {
+      this.setAttributionFromService().catch(() => {
+        // Silently handle attribution fetch errors to prevent unhandled rejections
+      });
+    }
+  }
+  get options() {
+    return {
+      ...this._defaultEsriOptions,
+      ...this.esriServiceOptions
+    };
+  }
+  get _layersStr() {
+    let lyrs = this.options.layers;
+    if (!lyrs) return false;
+    if (!Array.isArray(lyrs)) lyrs = [lyrs];
+    return `show:${lyrs.join(',')}`;
+  }
+  get _layerDefs() {
+    if (this.options.layerDefs !== false) return JSON.stringify(this.options.layerDefs);
+    return false;
+  }
+  get _time() {
+    if (!this.options.to) return false;
+    let from = this.options.from;
+    let to = this.options.to;
+    if (from instanceof Date) from = from.valueOf();
+    if (to instanceof Date) to = to.valueOf();
+    return `${from},${to}`;
+  }
+  // ArcGIS Dynamic Layer styling parameter (JSON string)
+  get _dynamicLayers() {
+    const dl = this.options.dynamicLayers;
+    if (!dl) return false;
+    try {
+      const normalized = dl.map(l => {
+        const {
+          visible,
+          ...rest
+        } = l;
+        const withSource = {
+          ...rest,
+          // ensure required source exists
+          source: l.source ?? {
+            type: 'mapLayer',
+            mapLayerId: l.id
+          }
+        };
+        // Convert client-friendly 'visible' to ArcGIS 'visibility'
+        if (typeof visible === 'boolean') {
+          withSource.visibility = visible;
+        }
+        return withSource;
+      });
+      const result = JSON.stringify(normalized);
+      return result;
+    } catch {
+      return false;
+    }
+  }
+  get _source() {
+    const tileSize = this.rasterSrcOptions?.tileSize ?? 256;
+    // These are the bare minimum parameters
+    const params = new URLSearchParams({
+      bboxSR: '3857',
+      imageSR: '3857',
+      format: this.options.format,
+      layers: this._layersStr || '',
+      transparent: this.options.transparent.toString(),
+      size: `${tileSize},${tileSize}`,
+      f: 'image'
+    });
+    // These are optional params
+    if (this._time) params.append('time', this._time);
+    if (this._layerDefs) params.append('layerDefs', this._layerDefs);
+    if (this._dynamicLayers) params.append('dynamicLayers', this._dynamicLayers);
+    this._appendTokenIfExists(params);
+    const tileUrl = `${this.options.url}/export?bbox={bbox-epsg-3857}&${params.toString()}`;
+    return {
+      type: 'raster',
+      tiles: [tileUrl],
+      tileSize,
+      ...this.rasterSrcOptions
+    };
+  }
+  _createSource() {
+    // Check if source already exists before adding
+    if (!this._map.getSource(this._sourceId)) {
+      this._map.addSource(this._sourceId, this._source);
+    }
+  }
+  // This requires hooking into some undocumented methods
+  _updateSource() {
+    // Simple debounce: collapse multiple rapid calls (e.g., visibility + labels in same tick)
+    const now = performance.now();
+    if (now - this._lastUpdateTime < this._updateDelay) {
+      if (this._pendingUpdate) cancelAnimationFrame(this._pendingUpdate);
+      this._pendingUpdate = requestAnimationFrame(() => this._updateSourceInternal());
+      return;
+    }
+    this._lastUpdateTime = now;
+    this._updateSourceInternal();
+  }
+  _updateSourceInternal() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const src = this._map.getSource(this._sourceId);
+    if (!src) return;
+    try {
+      // Ensure src.tiles exists before accessing it
+      if (src.tiles && Array.isArray(src.tiles) && this._source.tiles && this._source.tiles.length > 0) {
+        src.tiles[0] = this._source.tiles[0];
+      }
+      src._options = this._source;
+      if (src.setTiles) {
+        // New MapboxGL >= 2.13.0
+        // setTiles may return a promise - handle rejections to prevent console errors
+        const result = src.setTiles(this._source.tiles);
+        if (result && typeof result.catch === 'function') {
+          result.catch(() => {
+            // Silently ignore - setTiles rejections are often abort errors during rapid updates
+            // The outer try/catch will handle any synchronous errors
+          });
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } else if (this._map.style.sourceCaches) {
+        // Old MapboxGL and MaplibreGL
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this._map.style.sourceCaches[this._sourceId].clearTiles();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this._map.style.sourceCaches[this._sourceId].update(this._map.transform);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } else if (this._map.style._otherSourceCaches) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this._map.style._otherSourceCaches[this._sourceId].clearTiles();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this._map.style._otherSourceCaches[this._sourceId].update(this._map.transform);
+      }
+    } catch (error) {
+      // Silently ignore aborted tile operations - MapLibre will retry
+      if (isAbortError(error)) {
+        return;
+      }
+      // Swallow occasional transient errors that can happen during style reloads
+      if (error && error.message?.includes('Source') && error.message?.includes('not found')) {
+        return;
+      }
+      throw error;
+    }
+  }
+  setLayerDefs(obj) {
+    this.esriServiceOptions.layerDefs = obj;
+    this._updateSource();
+  }
+  /**
+   * Replace the entire dynamicLayers array. Server applies these drawing rules.
+   * Note: dynamicLayers overrides default drawing for listed sublayers.
+   */
+  setDynamicLayers(layers) {
+    this.esriServiceOptions.dynamicLayers = layers || false;
+    this._updateSource();
+  }
+  /** Helper to ensure all visible layers are included when using dynamicLayers */
+  _ensureAllVisibleLayers(dynamicLayers) {
+    const visibleLayerIds = this._getVisibleLayerIds();
+    const existingIds = new Set(dynamicLayers.map(dl => dl.id));
+    // Add entries for visible layers that aren't already in dynamicLayers
+    const additional = visibleLayerIds.filter(id => !existingIds.has(id)).map(id => ({
+      id,
+      visible: true
+    }));
+    return [...dynamicLayers, ...additional];
+  }
+  /** Get the list of currently visible layer IDs */
+  _getVisibleLayerIds() {
+    const lyrs = this.options.layers;
+    if (!lyrs) return [];
+    if (!Array.isArray(lyrs)) return [lyrs];
+    return lyrs;
+  }
+  /** Merge/update a sublayer's drawingInfo with provided fields. */
+  setLayerDrawingInfo(layerId, drawingInfo) {
+    const current = this.esriServiceOptions.dynamicLayers || [];
+    const next = Array.isArray(current) ? [...current] : [];
+    const idx = next.findIndex(l => l.id === layerId);
+    if (idx >= 0) {
+      next[idx] = {
+        ...next[idx],
+        drawingInfo: {
+          ...next[idx].drawingInfo,
+          ...drawingInfo
+        }
+      };
+    } else {
+      next.push({
+        id: layerId,
+        drawingInfo
+      });
+    }
+    // Ensure all visible layers are included
+    this.esriServiceOptions.dynamicLayers = this._ensureAllVisibleLayers(next);
+    this._updateSource();
+  }
+  /** Convenience to set a renderer on a sublayer */
+  setLayerRenderer(layerId, renderer) {
+    this.setLayerDrawingInfo(layerId, {
+      renderer
+    });
+  }
+  /** Show/hide a sublayer via dynamicLayers */
+  setLayerVisibility(layerId, visible) {
+    const current = this.esriServiceOptions.dynamicLayers || [];
+    const next = Array.isArray(current) ? [...current] : [];
+    const idx = next.findIndex(l => l.id === layerId);
+    if (idx >= 0) {
+      next[idx] = {
+        ...next[idx],
+        visible
+      };
+    } else {
+      next.push({
+        id: layerId,
+        visible
+      });
+    }
+    // Ensure all visible layers are included
+    this.esriServiceOptions.dynamicLayers = this._ensureAllVisibleLayers(next);
+    this._updateSource();
+  }
+  /** Set a definitionExpression for a sublayer, applied server-side */
+  setLayerDefinition(layerId, definitionExpression) {
+    const current = this.esriServiceOptions.dynamicLayers || [];
+    const next = Array.isArray(current) ? [...current] : [];
+    const idx = next.findIndex(l => l.id === layerId);
+    if (idx >= 0) {
+      next[idx] = {
+        ...next[idx],
+        definitionExpression
+      };
+    } else {
+      next.push({
+        id: layerId,
+        definitionExpression
+      });
+    }
+    // Ensure all visible layers are included
+    this.esriServiceOptions.dynamicLayers = this._ensureAllVisibleLayers(next);
+    this._updateSource();
+  }
+  // Build a SQL where clause and apply as definitionExpression
+  setLayerFilter(layerId, filter) {
+    const where = this._buildWhere(filter);
+    if (where) this.setLayerDefinition(layerId, where);
+  }
+  _appendTokenIfExists(params) {
+    const token = this.esriServiceOptions.token;
+    if (token) {
+      params.append('token', token);
+    }
+  }
+  _escapeValue(val) {
+    if (val === null) return 'NULL';
+    if (val instanceof Date) return `${val.valueOf()}`; // epoch ms for time-enabled services
+    if (typeof val === 'number') return `${val}`;
+    if (typeof val === 'boolean') return val ? '1' : '0';
+    const s = String(val).replace(/'/g, "''");
+    return `'${s}'`;
+  }
+  // Very small, pragmatic builder that covers common cases in types.ts
+  _isGroupFilter(f) {
+    return typeof f !== 'string' && 'op' in f && (f.op === 'AND' || f.op === 'OR') && 'filters' in f && Array.isArray(f.filters);
+  }
+  _isBetweenFilter(f) {
+    return typeof f !== 'string' && 'op' in f && f.op === 'BETWEEN' && 'field' in f && typeof f.field === 'string' && 'from' in f && f.from !== undefined && 'to' in f && f.to !== undefined;
+  }
+  _isInFilter(f) {
+    return typeof f !== 'string' && 'op' in f && f.op === 'IN' && 'field' in f && typeof f.field === 'string' && 'values' in f && Array.isArray(f.values);
+  }
+  _isNullFilter(f) {
+    return typeof f !== 'string' && 'op' in f && (f.op === 'IS NULL' || f.op === 'IS NOT NULL') && 'field' in f && typeof f.field === 'string';
+  }
+  _isComparisonFilter(f) {
+    return typeof f !== 'string' && 'field' in f && typeof f.field === 'string' && 'op' in f && typeof f.op === 'string' && 'value' in f && f.value !== undefined;
+  }
+  _buildWhere(filter) {
+    if (!filter) return undefined;
+    if (typeof filter === 'string') return filter.trim();
+    if (this._isBetweenFilter(filter)) {
+      return `${filter.field} BETWEEN ${this._escapeValue(filter.from)} AND ${this._escapeValue(filter.to)}`;
+    }
+    if (this._isInFilter(filter)) {
+      const vals = filter.values.map(v => this._escapeValue(v)).join(', ');
+      return `${filter.field} IN (${vals})`;
+    }
+    if (this._isNullFilter(filter)) {
+      return `${filter.field} ${filter.op}`;
+    }
+    if (this._isGroupFilter(filter)) {
+      const built = filter.filters.map(f => this._buildWhere(f)).filter(s => Boolean(s));
+      if (!built.length) return undefined;
+      if (built.length === 1) return built[0];
+      return `(${built.join(` ${filter.op} `)})`;
+    }
+    if (this._isComparisonFilter(filter)) {
+      return `${filter.field} ${filter.op} ${this._escapeValue(filter.value)}`;
+    }
+    return undefined;
+  }
+  setLayers(arr) {
+    this.esriServiceOptions.layers = arr;
+    this._updateSource();
+  }
+  setDate(from, to) {
+    this.esriServiceOptions.from = from;
+    this.esriServiceOptions.to = to;
+    this._updateSource();
+  }
+  setToken(token) {
+    this.esriServiceOptions.token = token ?? undefined;
+    this._updateSource();
+  }
+  setAttributionFromService() {
+    if (this._serviceMetadata) {
+      updateAttribution(this._serviceMetadata.copyrightText || '', this._sourceId, this._map);
+      return Promise.resolve();
+    } else {
+      return this.getMetadata().then(() => {
+        updateAttribution(this._serviceMetadata?.copyrightText || '', this._sourceId, this._map);
+      });
+    }
+  }
+  getMetadata() {
+    if (this._serviceMetadata !== null) return Promise.resolve(this._serviceMetadata);
+    return new Promise((resolve, reject) => {
+      getServiceDetails(this.esriServiceOptions.url, this.esriServiceOptions.fetchOptions, this.esriServiceOptions.token).then(data => {
+        this._serviceMetadata = data;
+        resolve(this._serviceMetadata);
+      }).catch(err => reject(err));
+    });
+  }
+  get _layersStrIdentify() {
+    const layersStr = this._layersStr;
+    return layersStr ? layersStr.replace('show', 'visible') : false;
+  }
+  async identify(lnglat, returnGeometry = false) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const canvas = this._map.getCanvas();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const bounds = this._map.getBounds().toArray();
+    const params = new URLSearchParams({
+      sr: '4326',
+      geometryType: 'esriGeometryPoint',
+      geometry: JSON.stringify({
+        x: lnglat.lng,
+        y: lnglat.lat,
+        spatialReference: {
+          wkid: 4326
+        }
+      }),
+      tolerance: '3',
+      returnGeometry: returnGeometry.toString(),
+      imageDisplay: `${canvas.width},${canvas.height},96`,
+      mapExtent: `${bounds[0][0]},${bounds[0][1]},${bounds[1][0]},${bounds[1][1]}`,
+      layers: this._layersStrIdentify || '',
+      f: 'json'
+    });
+    if (this._layerDefs) params.append('layerDefs', this._layerDefs);
+    if (this._dynamicLayers) params.append('dynamicLayers', this._dynamicLayers);
+    if (this._time) params.append('time', this._time);
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${this.esriServiceOptions.url}/identify?${params.toString()}`, this.esriServiceOptions.fetchOptions);
+    if (!response.ok) {
+      throw new Error(`Identify request failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Identify request failed: ${data.error.message}`);
+    }
+    return data;
+  }
+  // ========================================
+  // Advanced Features
+  // ========================================
+  /** Set labeling configuration for a sublayer */
+  setLayerLabels(layerId, labelingInfo) {
+    const current = this.esriServiceOptions.dynamicLayers || [];
+    const next = Array.isArray(current) ? [...current] : [];
+    const idx = next.findIndex(l => l.id === layerId);
+    if (idx >= 0) {
+      next[idx] = {
+        ...next[idx],
+        drawingInfo: {
+          ...next[idx].drawingInfo,
+          labelingInfo: [labelingInfo]
+        }
+      };
+    } else {
+      next.push({
+        id: layerId,
+        drawingInfo: {
+          labelingInfo: [labelingInfo]
+        }
+      });
+    }
+    // Ensure all visible layers are included
+    this.esriServiceOptions.dynamicLayers = this._ensureAllVisibleLayers(next);
+    this._updateSource();
+  }
+  /** Toggle label visibility for a sublayer */
+  setLayerLabelsVisible(layerId, visible) {
+    if (visible) {
+      // If enabling labels but no labeling info exists, set a default
+      const current = this.esriServiceOptions.dynamicLayers || [];
+      const layer = Array.isArray(current) ? current.find(l => l.id === layerId) : null;
+      if (!layer?.drawingInfo?.labelingInfo) {
+        // Set a basic label configuration
+        this.setLayerLabels(layerId, {
+          labelExpression: '[OBJECTID]',
+          // Default to object ID
+          symbol: {
+            type: 'esriTS',
+            color: [0, 0, 0, 255],
+            font: {
+              family: 'Arial',
+              size: 8
+            }
+          }
+        });
+      }
+    } else {
+      // Remove labeling info to disable labels
+      const current = this.esriServiceOptions.dynamicLayers || [];
+      const next = Array.isArray(current) ? [...current] : [];
+      const idx = next.findIndex(l => l.id === layerId);
+      if (idx >= 0) {
+        const drawingInfo = {
+          ...next[idx].drawingInfo
+        };
+        delete drawingInfo.labelingInfo;
+        next[idx] = {
+          ...next[idx],
+          drawingInfo
+        };
+        // Ensure all visible layers are included
+        this.esriServiceOptions.dynamicLayers = this._ensureAllVisibleLayers(next);
+        this._updateSource();
+      }
+    }
+  }
+  /** Set time options for a time-enabled sublayer */
+  setLayerTimeOptions(layerId, timeOptions) {
+    const current = this.esriServiceOptions.dynamicLayers || [];
+    const next = Array.isArray(current) ? [...current] : [];
+    const idx = next.findIndex(l => l.id === layerId);
+    if (idx >= 0) {
+      next[idx] = {
+        ...next[idx],
+        layerTimeOptions: timeOptions
+      };
+    } else {
+      next.push({
+        id: layerId,
+        layerTimeOptions: timeOptions
+      });
+    }
+    // Ensure all visible layers are included
+    this.esriServiceOptions.dynamicLayers = this._ensureAllVisibleLayers(next);
+    this._updateSource();
+  }
+  /** Animate through time periods for time-enabled layers */
+  async animateTime(options) {
+    const {
+      from,
+      to,
+      intervalMs,
+      loop = false,
+      onFrame,
+      onComplete
+    } = options;
+    const totalDuration = to.getTime() - from.getTime();
+    const steps = Math.ceil(totalDuration / intervalMs);
+    return new Promise(resolve => {
+      let currentStep = 0;
+      const animate = () => {
+        if (currentStep >= steps && !loop) {
+          onComplete?.();
+          resolve();
+          return;
+        }
+        const progress = currentStep % steps / steps;
+        const currentTime = new Date(from.getTime() + progress * totalDuration);
+        // Update service time extent
+        this.esriServiceOptions.from = currentTime;
+        this.esriServiceOptions.to = currentTime;
+        this._updateSource();
+        onFrame?.(currentTime, progress);
+        currentStep++;
+        setTimeout(animate, intervalMs);
+      };
+      animate();
+    });
+  }
+  /** Get statistics for a sublayer */
+  async getLayerStatistics(layerId, statisticFields, options = {}) {
+    const queryUrl = `${this.esriServiceOptions.url}/${layerId}/query`;
+    const params = new URLSearchParams({
+      f: 'json',
+      where: options.where || '1=1',
+      outStatistics: JSON.stringify(statisticFields),
+      returnGeometry: 'false'
+    });
+    if (options.groupByFieldsForStatistics) {
+      params.append('groupByFieldsForStatistics', options.groupByFieldsForStatistics);
+    }
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${queryUrl}?${params.toString()}`);
+    if (!response.ok) {
+      throw new Error(`Statistics query failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Statistics query failed: ${data.error.message}`);
+    }
+    return data.features || [];
+  }
+  /** Query features from a specific sublayer */
+  async queryLayerFeatures(layerId, options = {}) {
+    const queryUrl = `${this.esriServiceOptions.url}/${layerId}/query`;
+    const params = new URLSearchParams({
+      f: 'json',
+      where: options.where || '1=1',
+      returnGeometry: options.returnGeometry !== false ? 'true' : 'false',
+      outFields: Array.isArray(options.outFields) ? options.outFields.join(',') : options.outFields || '*'
+    });
+    if (options.geometry) {
+      params.append('geometry', JSON.stringify(options.geometry));
+      params.append('geometryType', options.geometryType || 'esriGeometryEnvelope');
+      params.append('spatialRel', options.spatialRel || 'esriSpatialRelIntersects');
+    }
+    if (options.orderByFields) {
+      params.append('orderByFields', options.orderByFields);
+    }
+    if (options.resultOffset) {
+      params.append('resultOffset', options.resultOffset.toString());
+    }
+    if (options.resultRecordCount) {
+      params.append('resultRecordCount', options.resultRecordCount.toString());
+    }
+    if (options.returnCountOnly) {
+      params.append('returnCountOnly', 'true');
+    }
+    if (options.returnIdsOnly) {
+      params.append('returnIdsOnly', 'true');
+    }
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${queryUrl}?${params.toString()}`);
+    if (!response.ok) {
+      throw new Error(`Layer query failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Layer query failed: ${data.error.message}`);
+    }
+    return data;
+  }
+  /** Export high-resolution map image */
+  async exportMapImage(options) {
+    const exportUrl = `${this.esriServiceOptions.url}/export`;
+    const params = new URLSearchParams({
+      f: 'image',
+      bbox: options.bbox.join(','),
+      size: options.size.join(','),
+      format: options.format || 'png24',
+      transparent: options.transparent !== false ? 'true' : 'false',
+      dpi: (options.dpi || 96).toString(),
+      bboxSR: (options.bboxSR || 3857).toString(),
+      imageSR: (options.imageSR || 3857).toString()
+    });
+    if (options.layerDefs) {
+      params.append('layerDefs', JSON.stringify(options.layerDefs));
+    }
+    if (options.dynamicLayers) {
+      const normalized = this._ensureAllVisibleLayers(options.dynamicLayers);
+      params.append('dynamicLayers', JSON.stringify(normalized));
+    }
+    if (options.gdbVersion) {
+      params.append('gdbVersion', options.gdbVersion);
+    }
+    if (options.historicMoment) {
+      params.append('historicMoment', options.historicMoment.toString());
+    }
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${exportUrl}?${params.toString()}`);
+    if (!response.ok) {
+      throw new Error(`Export failed: ${response.statusText}`);
+    }
+    return response.blob();
+  }
+  /** Generate legend information for layers */
+  async generateLegend(layerIds) {
+    const legendUrl = `${this.esriServiceOptions.url}/legend`;
+    const params = new URLSearchParams({
+      f: 'json'
+    });
+    if (layerIds?.length) {
+      params.append('layers', layerIds.join(','));
+    }
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${legendUrl}?${params.toString()}`);
+    if (!response.ok) {
+      throw new Error(`Legend generation failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Legend generation failed: ${data.error.message}`);
+    }
+    return data.layers || [];
+  }
+  /** Get detailed information about a specific layer */
+  async getLayerInfo(layerId) {
+    const layerUrl = `${this.esriServiceOptions.url}/${layerId}`;
+    const params = new URLSearchParams({
+      f: 'json'
+    });
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${layerUrl}?${params.toString()}`);
+    if (!response.ok) {
+      throw new Error(`Layer info request failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Layer info request failed: ${data.error.message}`);
+    }
+    return data;
+  }
+  /** Get field information for a layer */
+  async getLayerFields(layerId) {
+    const layerInfo = await this.getLayerInfo(layerId);
+    return layerInfo.fields || [];
+  }
+  /** Get spatial extent of a layer */
+  async getLayerExtent(layerId) {
+    const layerInfo = await this.getLayerInfo(layerId);
+    if (!layerInfo.extent) {
+      throw new Error(`No extent available for layer ${layerId}`);
+    }
+    return layerInfo.extent;
+  }
+  /** Discover all layers in the service */
+  async discoverLayers() {
+    const serviceUrl = this.esriServiceOptions.url;
+    const params = new URLSearchParams({
+      f: 'json'
+    });
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${serviceUrl}?${params.toString()}`);
+    if (!response.ok) {
+      throw new Error(`Service discovery failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Service discovery failed: ${data.error.message}`);
+    }
+    return data.layers || [];
+  }
+  /** Apply multiple layer operations in a single update */
+  setBulkLayerProperties(operations) {
+    const current = this.esriServiceOptions.dynamicLayers || [];
+    const next = Array.isArray(current) ? [...current] : [];
+    // Process all operations
+    for (const op of operations) {
+      const idx = next.findIndex(l => l.id === op.layerId);
+      const layer = idx >= 0 ? {
+        ...next[idx]
+      } : {
+        id: op.layerId
+      };
+      switch (op.operation) {
+        case 'visibility':
+          layer.visible = op.value;
+          break;
+        case 'renderer':
+          layer.drawingInfo = {
+            ...layer.drawingInfo,
+            renderer: op.value
+          };
+          break;
+        case 'definition':
+          layer.definitionExpression = op.value;
+          break;
+        case 'filter':
+          {
+            const where = this._buildWhere(op.value);
+            if (where) layer.definitionExpression = where;
+            break;
+          }
+        case 'labels':
+          layer.drawingInfo = {
+            ...layer.drawingInfo,
+            labelingInfo: op.value
+          };
+          break;
+        case 'time':
+          layer.layerTimeOptions = op.value;
+          break;
+      }
+      if (idx >= 0) {
+        next[idx] = layer;
+      } else {
+        next.push(layer);
+      }
+    }
+    // Ensure all visible layers are included
+    this.esriServiceOptions.dynamicLayers = this._ensureAllVisibleLayers(next);
+    this._updateSource();
+  }
+  /** Begin a batch update transaction */
+  beginUpdate() {
+    const current = this.esriServiceOptions.dynamicLayers || [];
+    this._pendingUpdates = Array.isArray(current) ? [...current] : [];
+  }
+  /** Commit all pending updates */
+  commitUpdate() {
+    if (this._pendingUpdates) {
+      this.esriServiceOptions.dynamicLayers = this._ensureAllVisibleLayers(this._pendingUpdates);
+      this._pendingUpdates = null;
+      this._updateSource();
+    }
+  }
+  /** Rollback pending updates */
+  rollbackUpdate() {
+    this._pendingUpdates = null;
+  }
+  /** Check if currently in a transaction */
+  get isInTransaction() {
+    return this._pendingUpdates !== null;
+  }
+  update() {
+    this._updateSource();
+  }
+  remove() {
+    const map = this._map;
+    if (!map || typeof map.removeSource !== 'function') {
+      return;
+    }
+    try {
+      // Guard against map whose style has already been destroyed
+      if (!map.style) return;
+      const mapWithStyle = map;
+      const mapLayerApi = map;
+      const mapSourceApi = map;
+      if (typeof mapWithStyle.getStyle === 'function') {
+        const style = mapWithStyle.getStyle();
+        const layers = style?.layers || [];
+        layers.forEach(layer => {
+          if (layer.source !== this._sourceId) return;
+          if (typeof mapLayerApi.getLayer !== 'function' || typeof mapLayerApi.removeLayer !== 'function') {
+            return;
+          }
+          let hasLayer = false;
+          try {
+            hasLayer = Boolean(mapLayerApi.getLayer(layer.id));
+          } catch {
+            hasLayer = false;
+          }
+          if (!hasLayer) return;
+          try {
+            mapLayerApi.removeLayer(layer.id);
+          } catch (error) {
+            console.warn(`Failed to remove layer ${layer.id} for source ${this._sourceId}:`, error);
+          }
+        });
+      }
+      if (typeof mapSourceApi.getSource === 'function') {
+        let hasSource = false;
+        try {
+          hasSource = Boolean(mapSourceApi.getSource(this._sourceId));
+        } catch {
+          hasSource = false;
+        }
+        if (hasSource) {
+          try {
+            map.removeSource(this._sourceId);
+          } catch (error) {
+            console.warn(`Failed to remove source ${this._sourceId}:`, error);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to remove source ${this._sourceId}:`, error);
+    }
+  }
+}
+
+class TiledMapService {
+  constructor(sourceId, map, esriServiceOptions, rasterSrcOptions) {
+    Object.defineProperty(this, "_sourceId", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_map", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_serviceMetadata", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "rasterSrcOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "esriServiceOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    if (!esriServiceOptions.url) {
+      throw new Error('A url must be supplied as part of the esriServiceOptions object.');
+    }
+    esriServiceOptions.url = cleanTrailingSlash(esriServiceOptions.url);
+    this._sourceId = sourceId;
+    this._map = map;
+    this.rasterSrcOptions = rasterSrcOptions;
+    this.esriServiceOptions = esriServiceOptions;
+    this._createSource();
+    if (esriServiceOptions.getAttributionFromService) {
+      this.setAttributionFromService().catch(() => {
+        // Silently handle attribution fetch errors to prevent unhandled rejections
+      });
+    }
+  }
+  get _source() {
+    return {
+      ...this.rasterSrcOptions,
+      type: 'raster',
+      tiles: [this.esriServiceOptions.token ? `${this.esriServiceOptions.url}/tile/{z}/{y}/{x}?token=${this.esriServiceOptions.token}` : `${this.esriServiceOptions.url}/tile/{z}/{y}/{x}`],
+      tileSize: this.rasterSrcOptions?.tileSize || 256
+    };
+  }
+  _createSource() {
+    // Check if source already exists before adding
+    if (!this._map.getSource(this._sourceId)) {
+      this._map.addSource(this._sourceId, this._source);
+    }
+  }
+  setToken(token) {
+    this.esriServiceOptions.token = token ?? undefined;
+    // Tiled sources need recreation to pick up new URL
+    const src = this._map.getSource(this._sourceId);
+    if (src && src.setTiles) {
+      src.setTiles(this._source.tiles);
+    }
+  }
+  setAttributionFromService() {
+    if (this._serviceMetadata) {
+      updateAttribution(this._serviceMetadata.copyrightText || '', this._sourceId, this._map);
+      return Promise.resolve();
+    } else {
+      return this.getMetadata().then(() => {
+        updateAttribution(this._serviceMetadata?.copyrightText || '', this._sourceId, this._map);
+      });
+    }
+  }
+  getMetadata() {
+    if (this._serviceMetadata !== null) return Promise.resolve(this._serviceMetadata);
+    return new Promise((resolve, reject) => {
+      getServiceDetails(this.esriServiceOptions.url, this.esriServiceOptions.fetchOptions, this.esriServiceOptions.token).then(data => {
+        this._serviceMetadata = data;
+        resolve(data);
+      }).catch(err => reject(err));
+    });
+  }
+  update() {
+    // Tiled sources use static tile URLs and don't support hot-updates.
+    // This is a no-op to satisfy the common service interface.
+  }
+  remove() {
+    // Guard against disposed or invalid map
+    if (!this._map || typeof this._map.removeSource !== 'function') {
+      return;
+    }
+    try {
+      // Guard against map whose style has already been destroyed
+      if (!this._map.style) return;
+      // First, remove any layers that are using this source
+      const mapWithStyle = this._map;
+      if (mapWithStyle.getStyle && typeof mapWithStyle.getLayer === 'function') {
+        const style = mapWithStyle.getStyle();
+        const layers = style?.layers || [];
+        const getLayer = mapWithStyle.getLayer;
+        layers.forEach(layer => {
+          if (layer.source === this._sourceId) {
+            try {
+              if (getLayer(layer.id)) {
+                this._map.removeLayer(layer.id);
+              }
+            } catch {
+              // Layer may already be removed
+            }
+          }
+        });
+      }
+      // Then check if source exists before trying to remove it
+      if (typeof this._map.getSource === 'function') {
+        const source = this._map.getSource(this._sourceId);
+        if (source) {
+          this._map.removeSource(this._sourceId);
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to remove source ${this._sourceId}:`, error);
+    }
+  }
+}
+
+class ImageService {
+  constructor(sourceId, map, esriServiceOptions, rasterSrcOptions) {
+    Object.defineProperty(this, "_sourceId", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_map", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_defaultEsriOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_serviceMetadata", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "rasterSrcOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "esriServiceOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    if (!esriServiceOptions.url) {
+      throw new Error('A url must be supplied as part of the esriServiceOptions object.');
+    }
+    esriServiceOptions.url = cleanTrailingSlash(esriServiceOptions.url);
+    this._sourceId = sourceId;
+    this._map = map;
+    this._defaultEsriOptions = {
+      layers: false,
+      layerDefs: false,
+      dynamicLayers: false,
+      format: 'jpgpng',
+      dpi: 96,
+      transparent: true,
+      getAttributionFromService: true,
+      time: false
+    };
+    this.rasterSrcOptions = rasterSrcOptions;
+    this.esriServiceOptions = esriServiceOptions;
+    this._createSource();
+    if (this.options.getAttributionFromService) {
+      this.setAttributionFromService().catch(() => {
+        // Silently handle attribution fetch errors to prevent unhandled rejections
+      });
+    }
+  }
+  get options() {
+    return {
+      ...this._defaultEsriOptions,
+      ...this.esriServiceOptions
+    };
+  }
+  get _time() {
+    if (!this.options.to) return false;
+    let from = this.options.from;
+    let to = this.options.to;
+    if (from instanceof Date) from = from.valueOf();
+    if (to instanceof Date) to = to.valueOf();
+    return `${from},${to}`;
+  }
+  get _source() {
+    const tileSize = this.rasterSrcOptions?.tileSize ?? 256;
+    // These are the bare minimum parameters
+    const params = new URLSearchParams({
+      bboxSR: '3857',
+      imageSR: '3857',
+      format: this.options.format,
+      size: `${tileSize},${tileSize}`,
+      f: 'image'
+    });
+    // These are optional params
+    if (this._time) params.append('time', this._time);
+    if (this.options.mosaicRule) params.append('mosaicRule', JSON.stringify(this.options.mosaicRule));
+    if (this.options.renderingRule) params.append('renderingRule', JSON.stringify(this.options.renderingRule));
+    if (this.esriServiceOptions.token) {
+      params.append('token', this.esriServiceOptions.token);
+    }
+    return {
+      type: 'raster',
+      tiles: [`${this.options.url}/exportImage?bbox={bbox-epsg-3857}&${params.toString()}`],
+      tileSize,
+      ...this.rasterSrcOptions
+    };
+  }
+  _createSource() {
+    // Check if source already exists before adding
+    if (!this._map.getSource(this._sourceId)) {
+      this._map.addSource(this._sourceId, this._source);
+    }
+  }
+  // This requires hooking into some undocumented methods
+  _updateSource() {
+    const src = this._map.getSource(this._sourceId);
+    if (!src) {
+      // Source not yet added to map, nothing to update
+      return;
+    }
+    src.tiles[0] = this._source.tiles[0];
+    src._options = this._source;
+    if (src.setTiles) {
+      // New MapboxGL >= 2.13.0
+      src.setTiles(this._source.tiles);
+    } else if (this._map.style.sourceCaches) {
+      // Old MapboxGL and MaplibreGL
+      this._map.style.sourceCaches[this._sourceId].clearTiles();
+      this._map.style.sourceCaches[this._sourceId].update(this._map.transform);
+    } else if (this._map.style._otherSourceCaches) {
+      this._map.style._otherSourceCaches[this._sourceId].clearTiles();
+      this._map.style._otherSourceCaches[this._sourceId].update(this._map.transform);
+    }
+  }
+  setDate(from, to) {
+    this.esriServiceOptions.from = from;
+    this.esriServiceOptions.to = to;
+    this._updateSource();
+  }
+  setRenderingRule(rule) {
+    this.esriServiceOptions.renderingRule = rule;
+    this._updateSource();
+  }
+  setMosaicRule(rule) {
+    this.esriServiceOptions.mosaicRule = rule;
+    this._updateSource();
+  }
+  setToken(token) {
+    this.esriServiceOptions.token = token ?? undefined;
+    this._updateSource();
+  }
+  setAttributionFromService() {
+    if (this._serviceMetadata) {
+      updateAttribution(this._serviceMetadata.copyrightText || '', this._sourceId, this._map);
+      return Promise.resolve();
+    } else {
+      return this.getMetadata().then(() => {
+        updateAttribution(this._serviceMetadata?.copyrightText || '', this._sourceId, this._map);
+      });
+    }
+  }
+  getMetadata() {
+    if (this._serviceMetadata !== null) return Promise.resolve(this._serviceMetadata);
+    return new Promise((resolve, reject) => {
+      getServiceDetails(this.esriServiceOptions.url, this.esriServiceOptions.fetchOptions, this.esriServiceOptions.token).then(data => {
+        this._serviceMetadata = data;
+        resolve(this._serviceMetadata);
+      }).catch(err => reject(err));
+    });
+  }
+  async identify(lnglat, returnGeometry = false) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const canvas = this._map.getCanvas();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const bounds = this._map.getBounds().toArray();
+    const params = new URLSearchParams({
+      sr: '4326',
+      geometryType: 'esriGeometryPoint',
+      geometry: JSON.stringify({
+        x: lnglat.lng,
+        y: lnglat.lat,
+        spatialReference: {
+          wkid: 4326
+        }
+      }),
+      tolerance: '3',
+      returnGeometry: returnGeometry.toString(),
+      imageDisplay: `${canvas.width},${canvas.height},96`,
+      mapExtent: `${bounds[0][0]},${bounds[0][1]},${bounds[1][0]},${bounds[1][1]}`,
+      f: 'json'
+    });
+    if (this._time) params.append('time', this._time);
+    if (this.esriServiceOptions.token) {
+      params.append('token', this.esriServiceOptions.token);
+    }
+    const response = await fetch(`${this.esriServiceOptions.url}/identify?${params.toString()}`, this.esriServiceOptions.fetchOptions);
+    if (!response.ok) {
+      throw new Error(`Identify request failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Identify request failed: ${data.error.message}`);
+    }
+    return data;
+  }
+  update() {
+    this._updateSource();
+  }
+  remove() {
+    if (this._map && typeof this._map.removeSource === 'function') {
+      try {
+        // Guard against map whose style has already been destroyed
+        const mapWithStyle = this._map;
+        if (!mapWithStyle.style) return;
+        // First, remove any layers that are using this source
+        if (mapWithStyle.getStyle) {
+          const style = mapWithStyle.getStyle();
+          const layers = style?.layers || [];
+          layers.forEach(layer => {
+            if (layer.source === this._sourceId && this._map.getLayer(layer.id)) {
+              this._map.removeLayer(layer.id);
+            }
+          });
+        }
+        // Then check if source exists before trying to remove it
+        if (this._map.getSource && this._map.getSource(this._sourceId)) {
+          this._map.removeSource(this._sourceId);
+        }
+      } catch (error) {
+        console.warn(`Failed to remove source ${this._sourceId}:`, error);
+      }
+    }
+  }
+}
+
+/**
+ * VectorBasemapStyle supports both modern slash form (arcgis/streets) and legacy colon form (ArcGIS:Streets).
+ * The URL always uses the slash form expected by the Basemap Styles Service.
+ *
+ * Note: MapLibre GL v5+ may show vector tile parsing warnings with some Esri tiles.
+ * These warnings are expected and do not affect map rendering functionality.
+ */
+class VectorBasemapStyle {
+  // Overload signature: (styleName, apiKeyString) or (styleName, options)
+  constructor(styleName, auth) {
+    Object.defineProperty(this, "styleName", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    }); // original user-supplied value (for display / debugging)
+    Object.defineProperty(this, "_canonical", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    }); // normalized slash form used in URL
+    Object.defineProperty(this, "_apiKey", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_token", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_version", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_host", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_format", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_language", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_worldview", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_itemId", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    let opts;
+    if (typeof auth === 'string') {
+      opts = {
+        apiKey: auth
+      };
+    } else {
+      opts = auth || {};
+    }
+    const provided = styleName && styleName.trim() ? styleName : opts.itemId ? '' : 'arcgis/streets';
+    this.styleName = provided;
+    this._canonical = VectorBasemapStyle._toCanonical(provided);
+    this._apiKey = opts.apiKey;
+    this._token = opts.token;
+    this._language = opts.language;
+    this._worldview = opts.worldview;
+    this._itemId = opts.itemId;
+    // Infer version: token => v2, else apiKey => v1
+    this._version = opts.version || (this._token ? 'v2' : 'v1');
+    // Determine host based on version if not overridden
+    this._host = opts.host || (this._version === 'v2' ? 'https://basemapstyles-api.arcgis.com' : 'https://basemaps-api.arcgis.com');
+    // For v2 we default to 'style' so the response is directly consumable by map.setStyle
+    this._format = opts.format || 'style';
+    if (!this._apiKey && !this._token) {
+      // Keep legacy error string for backwards compatibility with existing tests / consumers
+      throw new Error('An Esri API Key must be supplied to consume vector basemap styles');
+    }
+  }
+  get styleUrl() {
+    // Custom style via portal item ID
+    if (this._itemId) {
+      const portalHost = this._host.includes('basemap') ? 'https://www.arcgis.com' : this._host;
+      const params = new URLSearchParams();
+      if (this._token) params.set('token', this._token);
+      if (this._apiKey) params.set('token', this._apiKey);
+      const qs = params.toString();
+      return `${portalHost}/sharing/rest/content/items/${this._itemId}/resources/styles/root.json${qs ? '?' + qs : ''}`;
+    }
+    // v1 pattern: https://basemaps-api.arcgis.com/arcgis/rest/services/styles/{id}?type=style&apiKey=KEY
+    // v2 pattern: https://basemapstyles-api.arcgis.com/arcgis/rest/services/styles/v2/styles/{id}?f=json&token=TOKEN&echoToken=false
+    if (this._version === 'v2') {
+      const params = new URLSearchParams();
+      params.set('f', this._format); // usually 'style'
+      if (this._token) params.set('token', this._token);
+      if (this._language) params.set('language', this._language);
+      if (this._worldview) params.set('worldview', this._worldview);
+      return `${this._host}/arcgis/rest/services/styles/v2/styles/${this._canonical}?${params.toString()}`;
+    }
+    // v1 (apiKey)
+    const params = new URLSearchParams();
+    params.set('type', 'style');
+    if (this._apiKey) params.set('apiKey', this._apiKey);
+    if (this._language) params.set('language', this._language);
+    if (this._worldview) params.set('worldview', this._worldview);
+    return `${this._host}/arcgis/rest/services/styles/v1/styles/${this._canonical}?${params.toString()}`;
+  }
+  setStyle(styleName) {
+    if (!styleName) return;
+    this.styleName = styleName;
+    this._canonical = VectorBasemapStyle._toCanonical(styleName);
+  }
+  update() {}
+  remove() {}
+  /**
+   * Simple wrapper to apply a basemap style to a MapLibre/Mapbox map.
+   *
+   * @param map - MapLibre GL or Mapbox GL map instance with setStyle method
+   * @param styleName - Esri style name (e.g., 'arcgis/streets', 'arcgis/topographic')
+   * @param auth - Authentication options (API key or token)
+   *
+   * @example
+   * // Using API key
+   * VectorBasemapStyle.applyStyle(map, 'arcgis/streets', { apiKey: 'your-api-key' });
+   *
+   * // Using token
+   * VectorBasemapStyle.applyStyle(map, 'arcgis/topographic', { token: 'your-token' });
+   */
+  static applyStyle(map, styleName, auth) {
+    const vectorStyle = new VectorBasemapStyle(styleName, auth);
+    map.setStyle(vectorStyle.styleUrl);
+  }
+  static _toCanonical(name) {
+    if (!name) return 'arcgis/streets';
+    // Already slash form
+    if (name.includes('/')) return name;
+    const lower = name.toLowerCase();
+    if (this.COLON_TO_SLASH[lower]) return this.COLON_TO_SLASH[lower];
+    // If it looks like ArcGIS:Token (legacy) attempt smart conversion
+    if (/^arcgis:/i.test(name)) {
+      const token = name.split(':')[1];
+      if (token) {
+        const slug = token.replace(/([a-z])([A-Z])/g, '$1-$2').replace(/_/g, '-').toLowerCase();
+        return `arcgis/${slug}`;
+      }
+    }
+    return name; // custom enterprise style: leave untouched (caller controls format)
+  }
+}
+// Mapping from legacy colon form to canonical slash form
+Object.defineProperty(VectorBasemapStyle, "COLON_TO_SLASH", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: {
+    'arcgis:streets': 'arcgis/streets',
+    'arcgis:topographic': 'arcgis/topographic',
+    'arcgis:navigation': 'arcgis/navigation',
+    'arcgis:streetsrelief': 'arcgis/streets-relief',
+    'arcgis:darkgray': 'arcgis/dark-gray',
+    'arcgis:lightgray': 'arcgis/light-gray',
+    'arcgis:oceans': 'arcgis/oceans',
+    'arcgis:imagery': 'arcgis/imagery',
+    'arcgis:streetsnight': 'arcgis/streets-night'
+  }
+});
+
+class VectorTileService {
+  constructor(sourceId, map, esriServiceOptions, vectorSrcOptions) {
+    Object.defineProperty(this, "_sourceId", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_map", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_defaultEsriOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_serviceMetadata", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "_defaultStyleData", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "vectorSrcOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "esriServiceOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    if (!esriServiceOptions.url) {
+      throw new Error('A url must be supplied as part of the esriServiceOptions object.');
+    }
+    esriServiceOptions.url = cleanTrailingSlash(esriServiceOptions.url);
+    this._sourceId = sourceId;
+    this._map = map;
+    this._defaultEsriOptions = {
+      useDefaultStyle: true
+    };
+    this.vectorSrcOptions = vectorSrcOptions;
+    this.esriServiceOptions = esriServiceOptions;
+    this._createSource();
+  }
+  get options() {
+    return {
+      ...this._defaultEsriOptions,
+      ...this.esriServiceOptions
+    };
+  }
+  get _tileUrl() {
+    if (this._serviceMetadata === null) return '/tile/{z}/{y}/{x}.pbf';
+    return this._serviceMetadata.tiles?.[0] || '/tile/{z}/{y}/{x}.pbf';
+  }
+  get _source() {
+    return {
+      ...(this.vectorSrcOptions || {}),
+      type: 'vector',
+      tiles: [`${this.options.url}${this._tileUrl}`]
+    };
+  }
+  _createSource() {
+    // Check if source already exists before adding
+    if (!this._map.getSource(this._sourceId)) {
+      this._map.addSource(this._sourceId, this._source);
+    }
+  }
+  _mapToLocalSource(style) {
+    return {
+      type: style.type,
+      source: this._sourceId,
+      'source-layer': style['source-layer'],
+      layout: style.layout,
+      paint: style.paint
+    };
+  }
+  get defaultStyle() {
+    // Consumers should only call after getStyle resolves
+    return this._mapToLocalSource(this._defaultStyleData);
+  }
+  get _styleUrl() {
+    // Return a RELATIVE path which will be prefixed with options.url during fetch
+    // ArcGIS VectorTileServer typically exposes defaultStyles like 'resources/styles/root.json'
+    if (this._serviceMetadata === null) return 'resources/styles/root.json';
+    return this._serviceMetadata.defaultStyles || 'resources/styles/root.json';
+  }
+  getStyle() {
+    // Always resolve the mapped defaultStyle so the 'source' equals this._sourceId
+    if (this._defaultStyleData !== null) return Promise.resolve(this.defaultStyle);
+    return new Promise((resolve, reject) => {
+      const load = () => this._retrieveStyle().then(() => resolve(this.defaultStyle)).catch(error => reject(error));
+      if (this._serviceMetadata === null) {
+        this.getMetadata().then(() => load()).catch(error => reject(error));
+      } else {
+        load();
+      }
+    });
+  }
+  _retrieveStyle() {
+    return new Promise((resolve, reject) => {
+      fetch(`${this.options.url}/${this._styleUrl}`, this.esriServiceOptions.fetchOptions).then(response => {
+        if (!response.ok) throw new Error(`Failed to fetch style: ${response.status}`);
+        return response.json();
+      }).then(data => {
+        if (!data || !Array.isArray(data.layers) || data.layers.length === 0) {
+          throw new Error('VectorTile style document is missing layers.');
+        }
+        // Use the first layer as a simple default style for the demo
+        this._defaultStyleData = data.layers[0];
+        resolve();
+      }).catch(error => reject(error));
+    });
+  }
+  getMetadata() {
+    if (this._serviceMetadata !== null) return Promise.resolve(this._serviceMetadata);
+    return new Promise((resolve, reject) => {
+      getServiceDetails(this.esriServiceOptions.url, this.esriServiceOptions.fetchOptions).then(data => {
+        this._serviceMetadata = data;
+        resolve(this._serviceMetadata);
+      }).catch(err => reject(err));
+    });
+  }
+  update() {
+    // Vector tile services don't need dynamic updates like dynamic services
+  }
+  remove() {
+    const map = this._map;
+    if (!map || typeof map.removeSource !== 'function') {
+      return;
+    }
+    try {
+      // Guard against map whose style has already been destroyed
+      if (!map.style) return;
+      const mapWithStyle = map;
+      const mapLayerApi = map;
+      const mapSourceApi = map;
+      if (typeof mapWithStyle.getStyle === 'function') {
+        const style = mapWithStyle.getStyle();
+        const layers = style?.layers || [];
+        layers.forEach(layer => {
+          if (layer.source !== this._sourceId) return;
+          if (typeof mapLayerApi.getLayer !== 'function' || typeof mapLayerApi.removeLayer !== 'function') {
+            return;
+          }
+          let hasLayer = false;
+          try {
+            hasLayer = Boolean(mapLayerApi.getLayer(layer.id));
+          } catch {
+            hasLayer = false;
+          }
+          if (!hasLayer) return;
+          try {
+            mapLayerApi.removeLayer(layer.id);
+          } catch (error) {
+            console.warn(`Failed to remove layer ${layer.id} for source ${this._sourceId}:`, error);
+          }
+        });
+      }
+      if (typeof mapSourceApi.getSource === 'function') {
+        let hasSource = false;
+        try {
+          hasSource = Boolean(mapSourceApi.getSource(this._sourceId));
+        } catch {
+          hasSource = false;
+        }
+        if (hasSource) {
+          try {
+            map.removeSource(this._sourceId);
+          } catch (error) {
+            console.warn(`Failed to remove source ${this._sourceId}:`, error);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to remove source ${this._sourceId}:`, error);
+    }
+  }
+}
+
+/**
+ * FeatureService - Tile-based feature loading from ArcGIS FeatureServers
+ *
+ * This implementation is based on mapbox-gl-arcgis-featureserver by Rowan Winsemius
+ * @see https://github.com/rowanwins/mapbox-gl-arcgis-featureserver
+ *
+ * Key features:
+ * - Prioritizes PBF format for minimal payload size (requires ArcGIS Server 10.7+)
+ * - Falls back to GeoJSON if PBF is not supported
+ * - Uses tiled requests for efficient data loading
+ * - Client-side feature deduplication
+ * - Service bounds detection and coordinate projection
+ */
+class FeatureService {
+  constructor(sourceId, map, arcgisOptions, geojsonSourceOptions) {
+    Object.defineProperty(this, "_sourceId", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_map", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_tileIndices", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_featureIndices", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_featureCollections", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_esriServiceOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_fallbackProjectionEndpoint", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_serviceMetadata", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "_maxExtent", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_boundEvent", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "_format", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 'pbf'
+    });
+    Object.defineProperty(this, "_sourceReadyResolve", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "_sourceReadyReject", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "_eventListeners", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {}
+    });
+    /**
+     * Promise that resolves when the source has been successfully added to the map
+     * and is ready to receive data.
+     */
+    Object.defineProperty(this, "sourceReady", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    /**
+     * The GeoJSON source options passed to the constructor
+     */
+    Object.defineProperty(this, "geojsonSourceOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    if (!sourceId || !map || !arcgisOptions) {
+      throw new Error('Source id, map and arcgisOptions must be supplied as the first three arguments.');
+    }
+    if (!arcgisOptions.url) {
+      throw new Error('A url must be supplied as part of the esriServiceOptions object.');
+    }
+    this._sourceId = sourceId;
+    this._map = map;
+    // Initialize tile/feature tracking maps
+    this._tileIndices = new globalThis.Map();
+    this._featureIndices = new globalThis.Map();
+    this._featureCollections = new globalThis.Map();
+    // Clean URL and set up options
+    const cleanedUrl = cleanTrailingSlash(arcgisOptions.url);
+    this._esriServiceOptions = {
+      useStaticZoomLevel: false,
+      minZoom: arcgisOptions.useStaticZoomLevel ? 7 : 2,
+      simplifyFactor: 0.3,
+      precision: 8,
+      where: '1=1',
+      to: null,
+      from: null,
+      outFields: '*',
+      setAttributionFromService: true,
+      useServiceBounds: true,
+      projectionEndpoint: `${cleanedUrl.split('rest/services')[0]}rest/services/Geometry/GeometryServer/project`,
+      token: '',
+      fetchOptions: undefined,
+      ...arcgisOptions,
+      url: cleanedUrl
+    };
+    this._fallbackProjectionEndpoint = 'https://tasks.arcgisonline.com/arcgis/rest/services/Geometry/GeometryServer/project';
+    this._maxExtent = [-Infinity, -Infinity, Infinity, Infinity];
+    this.geojsonSourceOptions = geojsonSourceOptions || {};
+    // Create the sourceReady promise
+    this.sourceReady = new Promise((resolve, reject) => {
+      this._sourceReadyResolve = resolve;
+      this._sourceReadyReject = reject;
+    });
+    // Add GeoJSON source to map
+    this._map.addSource(sourceId, {
+      type: 'geojson',
+      data: this._getBlankFc(),
+      ...this.geojsonSourceOptions
+    });
+    // Initialize the service
+    this._initialize();
+  }
+  async _initialize() {
+    try {
+      await this._getServiceMetadata();
+      if (!this.supportsPbf) {
+        if (!this.supportsGeojson) {
+          this._map.removeSource(this._sourceId);
+          const error = new Error('Server does not support PBF or GeoJSON query formats.');
+          if (this._sourceReadyReject) this._sourceReadyReject(error);
+          throw error;
+        }
+        this._format = 'geojson';
+      }
+      if (this._esriServiceOptions.useServiceBounds && this._serviceMetadata?.extent) {
+        const serviceExtent = this._serviceMetadata.extent;
+        if (serviceExtent.spatialReference?.wkid === 4326) {
+          this._setBounds([serviceExtent.xmin, serviceExtent.ymin, serviceExtent.xmax, serviceExtent.ymax]);
+        } else {
+          await this._projectBounds();
+        }
+      }
+      // Ensure unique ID field is included in outFields
+      if (this._esriServiceOptions.outFields !== '*' && this._serviceMetadata?.uniqueIdField?.name) {
+        const currentFields = this._esriServiceOptions.outFields;
+        const uniqueIdField = this._serviceMetadata.uniqueIdField.name;
+        if (typeof currentFields === 'string') {
+          if (!currentFields.includes(uniqueIdField)) {
+            this._esriServiceOptions.outFields = `${currentFields},${uniqueIdField}`;
+          }
+        } else if (Array.isArray(currentFields)) {
+          if (!currentFields.includes(uniqueIdField)) {
+            this._esriServiceOptions.outFields = [...currentFields, uniqueIdField].join(',');
+          }
+        }
+      }
+      this._setAttribution();
+      this.enableRequests();
+      this._clearAndRefreshTiles();
+      if (this._sourceReadyResolve) this._sourceReadyResolve();
+    } catch (error) {
+      const isTestEnvironment = typeof process !== 'undefined' && process.env?.NODE_ENV === 'test';
+      if (!isTestEnvironment) {
+        console.error('Error initializing FeatureService:', error);
+      }
+      if (this._sourceReadyReject && error instanceof Error) {
+        this._sourceReadyReject(error);
+      }
+    }
+  }
+  /**
+   * Remove the source and clean up event listeners
+   */
+  remove() {
+    this.disableRequests();
+    if (this._map && typeof this._map.removeSource === 'function') {
+      try {
+        // Guard against map whose style has already been destroyed
+        const mapWithStyle = this._map;
+        if (!mapWithStyle.style) return;
+        // First, remove any layers that are using this source
+        if (mapWithStyle.getStyle) {
+          const style = mapWithStyle.getStyle();
+          const layers = style?.layers || [];
+          layers.forEach(layer => {
+            if (layer.source === this._sourceId && this._map.getLayer && this._map.getLayer(layer.id)) {
+              this._map.removeLayer(layer.id);
+            }
+          });
+        }
+        if (this._map.getSource && this._map.getSource(this._sourceId)) {
+          this._map.removeSource(this._sourceId);
+        }
+      } catch (error) {
+        console.warn(`Failed to remove source ${this._sourceId}:`, error);
+      }
+    }
+  }
+  /** Alias for remove() for API compatibility */
+  destroySource() {
+    this.remove();
+  }
+  _getBlankFc() {
+    return {
+      type: 'FeatureCollection',
+      features: []
+    };
+  }
+  _setBounds(bounds) {
+    this._maxExtent = bounds;
+  }
+  /** Check if service supports GeoJSON format */
+  get supportsGeojson() {
+    return (this._serviceMetadata?.supportedQueryFormats?.indexOf('geoJSON') ?? -1) > -1;
+  }
+  /** Check if service supports PBF format */
+  get supportsPbf() {
+    return (this._serviceMetadata?.supportedQueryFormats?.indexOf('PBF') ?? -1) > -1;
+  }
+  /** Get the service metadata */
+  get serviceMetadata() {
+    return this._serviceMetadata;
+  }
+  /** Get the source object from the map */
+  get _source() {
+    return this._map.getSource(this._sourceId);
+  }
+  /** Get the current query URL */
+  get _url() {
+    return this._esriServiceOptions.url;
+  }
+  /** Get the esri service options */
+  get esriServiceOptions() {
+    return this._esriServiceOptions;
+  }
+  /** Get default style based on geometry type */
+  get defaultStyle() {
+    const geometryType = String(this._serviceMetadata?.geometryType || 'esriGeometryPoint');
+    const baseStyle = {
+      source: this._sourceId
+    };
+    if (geometryType.includes('Point')) {
+      return {
+        type: 'circle',
+        ...baseStyle,
+        paint: {
+          'circle-radius': 4,
+          'circle-color': '#3b82f6',
+          'circle-stroke-color': '#1e40af',
+          'circle-stroke-width': 1
+        }
+      };
+    } else if (geometryType.includes('Polyline')) {
+      return {
+        type: 'line',
+        ...baseStyle,
+        paint: {
+          'line-color': '#3b82f6',
+          'line-width': 2
+        }
+      };
+    } else if (geometryType.includes('Polygon')) {
+      return {
+        type: 'fill',
+        ...baseStyle,
+        paint: {
+          'fill-color': 'rgba(59, 130, 246, 0.4)',
+          'fill-outline-color': '#1e40af'
+        }
+      };
+    }
+    // Default to circle for unknown geometry types
+    return {
+      type: 'circle',
+      ...baseStyle,
+      paint: {
+        'circle-radius': 4,
+        'circle-color': '#3b82f6',
+        'circle-stroke-color': '#1e40af',
+        'circle-stroke-width': 1
+      }
+    };
+  }
+  /** Get style, fetching metadata if needed */
+  async getStyle() {
+    if (this._serviceMetadata) {
+      return this.defaultStyle;
+    }
+    await this._getServiceMetadata();
+    return this.defaultStyle;
+  }
+  /** Disable map event listeners */
+  disableRequests() {
+    if (this._boundEvent) {
+      this._map.off('moveend', this._boundEvent);
+      this._boundEvent = null;
+    }
+  }
+  /** Enable map event listeners */
+  enableRequests() {
+    this._boundEvent = this._findAndMapData.bind(this);
+    this._map.on('moveend', this._boundEvent);
+  }
+  _clearAndRefreshTiles() {
+    this._tileIndices = new globalThis.Map();
+    this._featureIndices = new globalThis.Map();
+    this._featureCollections = new globalThis.Map();
+    this._findAndMapData();
+  }
+  /**
+   * Set the WHERE clause filter
+   */
+  setWhere(newWhere) {
+    this._esriServiceOptions.where = newWhere;
+    this._clearAndRefreshTiles();
+  }
+  /**
+   * Clear the WHERE clause filter
+   */
+  clearWhere() {
+    this._esriServiceOptions.where = '1=1';
+    this._clearAndRefreshTiles();
+  }
+  /**
+   * Set a date/time filter
+   */
+  setDate(to, from) {
+    this._esriServiceOptions.to = to;
+    this._esriServiceOptions.from = from ?? null;
+    this._clearAndRefreshTiles();
+  }
+  /**
+   * Set the authentication token
+   */
+  setToken(token) {
+    this._esriServiceOptions.token = token ?? '';
+    this._clearAndRefreshTiles();
+  }
+  /**
+   * Set output fields
+   */
+  setOutFields(fields) {
+    this._esriServiceOptions.outFields = Array.isArray(fields) ? fields.join(',') : fields;
+    this._clearAndRefreshTiles();
+  }
+  _createOrGetTileIndex(zoomLevel) {
+    const existingZoomIndex = this._tileIndices.get(zoomLevel);
+    if (existingZoomIndex) return existingZoomIndex;
+    const newIndex = new globalThis.Map();
+    this._tileIndices.set(zoomLevel, newIndex);
+    return newIndex;
+  }
+  _createOrGetFeatureCollection(zoomLevel) {
+    const existingZoomIndex = this._featureCollections.get(zoomLevel);
+    if (existingZoomIndex) return existingZoomIndex;
+    const fc = this._getBlankFc();
+    this._featureCollections.set(zoomLevel, fc);
+    return fc;
+  }
+  _createOrGetFeatureIdIndex(zoomLevel) {
+    const existingFeatureIdIndex = this._featureIndices.get(zoomLevel);
+    if (existingFeatureIdIndex) return existingFeatureIdIndex;
+    const newFeatureIdIndex = new globalThis.Map();
+    this._featureIndices.set(zoomLevel, newFeatureIdIndex);
+    return newFeatureIdIndex;
+  }
+  async _findAndMapData() {
+    const z = this._map.getZoom();
+    if (z < this._esriServiceOptions.minZoom) {
+      return;
+    }
+    const bounds = this._map.getBounds();
+    if (!bounds) return;
+    const boundsArray = bounds.toArray();
+    const primaryTile = tilebelt.bboxToTile([boundsArray[0][0], boundsArray[0][1], boundsArray[1][0], boundsArray[1][1]]);
+    if (this._esriServiceOptions.useServiceBounds) {
+      if (this._maxExtent[0] !== -Infinity && !this._doesTileOverlapBbox(this._maxExtent, boundsArray)) {
+        return;
+      }
+    }
+    // Round to nearest even zoom level to reuse data across zooms
+    const zoomLevel = this._esriServiceOptions.useStaticZoomLevel ? this._esriServiceOptions.minZoom : 2 * Math.floor(z / 2);
+    const zoomLevelIndex = this._createOrGetTileIndex(zoomLevel);
+    const featureIdIndex = this._createOrGetFeatureIdIndex(zoomLevel);
+    const fc = this._createOrGetFeatureCollection(zoomLevel);
+    let tilesToRequest = [];
+    if (primaryTile[2] < zoomLevel) {
+      let candidateTiles = tilebelt.getChildren(primaryTile);
+      let minZoomOfCandidates = candidateTiles[0][2];
+      while (minZoomOfCandidates < zoomLevel) {
+        const newCandidateTiles = [];
+        candidateTiles.forEach(t => {
+          newCandidateTiles.push(...tilebelt.getChildren(t));
+        });
+        candidateTiles = newCandidateTiles;
+        minZoomOfCandidates = candidateTiles[0][2];
+      }
+      for (let index = 0; index < candidateTiles.length; index++) {
+        if (this._doesTileOverlapBbox(candidateTiles[index], boundsArray)) {
+          tilesToRequest.push(candidateTiles[index]);
+        }
+      }
+    } else {
+      tilesToRequest.push(primaryTile);
+    }
+    // Filter out already fetched tiles
+    tilesToRequest = tilesToRequest.filter(tile => {
+      const quadKey = tilebelt.tileToQuadkey(tile);
+      if (zoomLevelIndex.has(quadKey)) {
+        return false;
+      }
+      zoomLevelIndex.set(quadKey, true);
+      return true;
+    });
+    if (tilesToRequest.length === 0) {
+      this._updateFcOnMap(fc);
+      return;
+    }
+    // Calculate tolerance for simplification
+    const mapWidth = Math.abs(boundsArray[1][0] - boundsArray[0][0]);
+    const canvas = this._map.getCanvas();
+    const tolerance = mapWidth / canvas.width * this._esriServiceOptions.simplifyFactor;
+    await this._loadTiles(tilesToRequest, tolerance, featureIdIndex, fc);
+    this._updateFcOnMap(fc);
+  }
+  async _loadTiles(tilesToRequest, tolerance, featureIdIndex, fc) {
+    const promises = tilesToRequest.map(t => this._getTile(t, tolerance));
+    const featureCollections = await Promise.all(promises);
+    featureCollections.forEach(tileFc => {
+      if (tileFc) this._iterateItems(tileFc, featureIdIndex, fc);
+    });
+  }
+  _iterateItems(tileFc, featureIdIndex, fc) {
+    if (!tileFc || !tileFc.features) return;
+    tileFc.features.forEach(feature => {
+      const featureId = feature.id;
+      if (featureId !== undefined && !featureIdIndex.has(featureId)) {
+        fc.features.push(feature);
+        featureIdIndex.set(featureId, true);
+      } else if (featureId === undefined) {
+        // If no ID, just add it (can't deduplicate)
+        fc.features.push(feature);
+      }
+    });
+  }
+  get _time() {
+    if (!this._esriServiceOptions.to) return false;
+    let from = this._esriServiceOptions.from;
+    let to = this._esriServiceOptions.to;
+    if (from instanceof Date) from = from.valueOf();
+    if (to instanceof Date) to = to.valueOf();
+    return `${from ?? ''},${to}`;
+  }
+  async _getTile(tile, tolerance) {
+    const tileBounds = tilebelt.tileToBBOX(tile);
+    const extent = {
+      spatialReference: {
+        latestWkid: 4326,
+        wkid: 4326
+      },
+      xmin: tileBounds[0],
+      ymin: tileBounds[1],
+      xmax: tileBounds[2],
+      ymax: tileBounds[3]
+    };
+    const params = new URLSearchParams({
+      f: this._format,
+      geometry: JSON.stringify(extent),
+      where: this._esriServiceOptions.where,
+      outFields: typeof this._esriServiceOptions.outFields === 'string' ? this._esriServiceOptions.outFields : this._esriServiceOptions.outFields?.join(',') || '*',
+      outSR: '4326',
+      returnZ: 'false',
+      returnM: 'false',
+      precision: this._esriServiceOptions.precision.toString(),
+      quantizationParameters: JSON.stringify({
+        extent,
+        tolerance,
+        mode: 'view'
+      }),
+      resultType: 'tile',
+      spatialRel: 'esriSpatialRelIntersects',
+      geometryType: 'esriGeometryEnvelope',
+      inSR: '4326'
+    });
+    if (this._time) {
+      params.append('time', this._time);
+    }
+    this._appendTokenIfExists(params);
+    try {
+      const response = await fetch(`${this._esriServiceOptions.url}/query?${params.toString()}`, this._esriServiceOptions.fetchOptions);
+      if (!response.ok) {
+        console.warn(`Tile fetch failed: HTTP ${response.status}`);
+        return null;
+      }
+      if (this._format === 'pbf') {
+        const buffer = await response.arrayBuffer();
+        try {
+          const decoded = tileDecode(new Uint8Array(buffer));
+          return decoded.featureCollection;
+        } catch {
+          console.error('Could not parse arcgis buffer. Please check the url you requested.');
+          return null;
+        }
+      } else {
+        const data = await response.json();
+        this._checkAgolError(data);
+        return data;
+      }
+    } catch (error) {
+      this._handleAuthError(error);
+      console.warn('Error fetching tile:', error);
+      return null;
+    }
+  }
+  _updateFcOnMap(fc) {
+    const source = this._map.getSource(this._sourceId);
+    if (source && 'setData' in source) {
+      source.setData(fc);
+    }
+  }
+  _doesTileOverlapBbox(tile, bbox) {
+    const tileBounds = tile.length === 4 ? tile : tilebelt.tileToBBOX(tile);
+    if (tileBounds[2] < bbox[0][0]) return false;
+    if (tileBounds[0] > bbox[1][0]) return false;
+    if (tileBounds[3] < bbox[0][1]) return false;
+    if (tileBounds[1] > bbox[1][1]) return false;
+    return true;
+  }
+  async _getServiceMetadata() {
+    if (this._serviceMetadata !== null) return this._serviceMetadata;
+    const params = new URLSearchParams({
+      f: 'json'
+    });
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${this._esriServiceOptions.url}?${params.toString()}`, this._esriServiceOptions.fetchOptions);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch service metadata: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(JSON.stringify(data.error));
+    }
+    this._serviceMetadata = data;
+    return this._serviceMetadata;
+  }
+  /**
+   * Query features by longitude/latitude with optional radius
+   */
+  async getFeaturesByLonLat(lnglat, radius = 20, returnGeometry = false) {
+    const params = new URLSearchParams({
+      sr: '4326',
+      geometryType: 'esriGeometryPoint',
+      geometry: JSON.stringify({
+        x: lnglat.lng,
+        y: lnglat.lat,
+        spatialReference: {
+          wkid: 4326
+        }
+      }),
+      returnGeometry: returnGeometry.toString(),
+      outFields: '*',
+      spatialRel: 'esriSpatialRelIntersects',
+      units: 'esriSRUnit_Meter',
+      distance: radius.toString(),
+      f: 'geojson'
+    });
+    if (this._time) {
+      params.append('time', this._time);
+    }
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${this._esriServiceOptions.url}/query?${params.toString()}`, this._esriServiceOptions.fetchOptions);
+    if (!response.ok) {
+      throw new Error(`Query failed: HTTP ${response.status}`);
+    }
+    return await response.json();
+  }
+  /**
+   * Query features by object IDs
+   */
+  async getFeaturesByObjectIds(objectIds, returnGeometry = false) {
+    const idsString = Array.isArray(objectIds) ? objectIds.join(',') : objectIds;
+    const params = new URLSearchParams({
+      sr: '4326',
+      objectIds: idsString,
+      returnGeometry: returnGeometry.toString(),
+      outFields: '*',
+      f: 'geojson'
+    });
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${this._esriServiceOptions.url}/query?${params.toString()}`, this._esriServiceOptions.fetchOptions);
+    if (!response.ok) {
+      throw new Error(`Query failed: HTTP ${response.status}`);
+    }
+    return await response.json();
+  }
+  /**
+   * Query features with custom options
+   */
+  async queryFeatures(options) {
+    const queryOptions = {
+      ...this._esriServiceOptions,
+      ...options
+    };
+    const params = new URLSearchParams();
+    params.append('f', 'geojson');
+    params.append('where', queryOptions.where || '1=1');
+    params.append('outFields', typeof queryOptions.outFields === 'string' ? queryOptions.outFields : queryOptions.outFields?.join(',') || '*');
+    params.append('returnGeometry', (queryOptions.returnGeometry !== false).toString());
+    if (queryOptions.geometry) {
+      params.append('geometry', JSON.stringify(queryOptions.geometry));
+      if (queryOptions.geometryType) params.append('geometryType', queryOptions.geometryType);
+      if (queryOptions.spatialRel) params.append('spatialRel', queryOptions.spatialRel);
+      if (queryOptions.inSR) params.append('inSR', queryOptions.inSR);
+    }
+    if (queryOptions.outSR) params.append('outSR', queryOptions.outSR);
+    if (queryOptions.orderByFields) params.append('orderByFields', queryOptions.orderByFields);
+    if (queryOptions.groupByFieldsForStatistics) params.append('groupByFieldsForStatistics', queryOptions.groupByFieldsForStatistics);
+    if (queryOptions.outStatistics && queryOptions.outStatistics.length > 0) params.append('outStatistics', JSON.stringify(queryOptions.outStatistics));
+    if (queryOptions.having) params.append('having', queryOptions.having);
+    if (queryOptions.resultOffset) params.append('resultOffset', queryOptions.resultOffset.toString());
+    if (queryOptions.resultRecordCount) params.append('resultRecordCount', queryOptions.resultRecordCount.toString());
+    if (queryOptions.token) params.append('token', queryOptions.token);
+    try {
+      const response = await fetch(`${this._esriServiceOptions.url}/query?${params.toString()}`, this._esriServiceOptions.fetchOptions);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      return await response.json();
+    } catch (error) {
+      const isTestEnvironment = typeof process !== 'undefined' && process.env?.NODE_ENV === 'test';
+      if (!isTestEnvironment) {
+        console.error('Error querying features:', error);
+      }
+      throw error;
+    }
+  }
+  async _projectBounds() {
+    if (!this._serviceMetadata?.extent) return;
+    const params = new URLSearchParams({
+      geometries: JSON.stringify({
+        geometryType: 'esriGeometryEnvelope',
+        geometries: [this._serviceMetadata.extent]
+      }),
+      inSR: (this._serviceMetadata.extent.spatialReference?.wkid || 4326).toString(),
+      outSR: '4326',
+      f: 'json'
+    });
+    let fetchOptions = this._esriServiceOptions.fetchOptions;
+    if (!this._projectionEndpointIsFallback()) {
+      this._appendTokenIfExists(params);
+    } else {
+      fetchOptions = undefined;
+    }
+    try {
+      const response = await fetch(`${this._esriServiceOptions.projectionEndpoint}?${params.toString()}`, fetchOptions);
+      if (!response.ok) {
+        throw new Error(`Projection failed: HTTP ${response.status}`);
+      }
+      const data = await response.json();
+      if (data.error) {
+        throw new Error(JSON.stringify(data.error));
+      }
+      const extent = data.geometries[0];
+      this._maxExtent = [extent.xmin, extent.ymin, extent.xmax, extent.ymax];
+    } catch (error) {
+      // If projection endpoint fails, try fallback
+      if (!this._projectionEndpointIsFallback()) {
+        this._esriServiceOptions.projectionEndpoint = this._fallbackProjectionEndpoint;
+        await this._projectBounds();
+      } else {
+        console.warn('Could not project service bounds:', error);
+      }
+    }
+  }
+  _projectionEndpointIsFallback() {
+    return this._esriServiceOptions.projectionEndpoint === this._fallbackProjectionEndpoint;
+  }
+  _setAttribution() {
+    if (!this._esriServiceOptions.setAttributionFromService) return;
+    const copyrightText = this._serviceMetadata?.copyrightText;
+    if (copyrightText) {
+      updateAttribution(copyrightText, this._sourceId, this._map);
+    } else {
+      // Add default Esri attribution
+      updateAttribution('', this._sourceId, this._map);
+    }
+  }
+  _appendTokenIfExists(params) {
+    const token = this._esriServiceOptions.token;
+    if (token) {
+      params.append('token', token);
+    }
+  }
+  _getFetchHeaders() {
+    if (this._esriServiceOptions.apiKey) {
+      return {
+        'X-Esri-Authorization': `Bearer ${this._esriServiceOptions.apiKey}`
+      };
+    }
+    return undefined;
+  }
+  _checkAgolError(data) {
+    if (data && typeof data === 'object' && 'error' in data) {
+      const errorData = data.error;
+      const err = new Error(errorData.message || 'ArcGIS service error');
+      err.code = errorData.code;
+      err.details = errorData.details;
+      throw err;
+    }
+  }
+  _handleAuthError(error) {
+    if (error && typeof error === 'object' && 'code' in error) {
+      const code = error.code;
+      if (code === 498 || code === 499) {
+        this._fireEvent('authenticationrequired', {
+          authenticate: token => this.setToken(token)
+        });
+      }
+    }
+  }
+  _fireEvent(event, data) {
+    const listeners = this._eventListeners[event];
+    if (listeners) {
+      listeners.forEach(cb => cb(data));
+    }
+  }
+  /**
+   * Add event listener
+   */
+  on(event, callback) {
+    if (!this._eventListeners[event]) {
+      this._eventListeners[event] = [];
+    }
+    this._eventListeners[event].push(callback);
+    return this;
+  }
+  /**
+   * Remove event listener
+   */
+  off(event, callback) {
+    const listeners = this._eventListeners[event];
+    if (listeners) {
+      const index = listeners.indexOf(callback);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    }
+    return this;
+  }
+  // ========================================
+  // Feature Editing Methods
+  // ========================================
+  /**
+   * Add features to the service
+   */
+  async addFeatures(features, options) {
+    const params = new URLSearchParams({
+      f: 'json',
+      features: JSON.stringify(features)
+    });
+    if (options?.gdbVersion) params.append('gdbVersion', options.gdbVersion);
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${this._esriServiceOptions.url}/addFeatures`, {
+      method: 'POST',
+      body: params,
+      headers: this._getFetchHeaders(),
+      ...this._esriServiceOptions.fetchOptions
+    });
+    if (!response.ok) {
+      throw new Error(`Add features failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    this._checkAgolError(data);
+    return data.addResults;
+  }
+  /**
+   * Update existing features
+   */
+  async updateFeatures(features, options) {
+    const params = new URLSearchParams({
+      f: 'json',
+      features: JSON.stringify(features)
+    });
+    if (options?.gdbVersion) params.append('gdbVersion', options.gdbVersion);
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${this._esriServiceOptions.url}/updateFeatures`, {
+      method: 'POST',
+      body: params,
+      headers: this._getFetchHeaders(),
+      ...this._esriServiceOptions.fetchOptions
+    });
+    if (!response.ok) {
+      throw new Error(`Update features failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    this._checkAgolError(data);
+    return data.updateResults;
+  }
+  /**
+   * Delete features by objectIds or where clause
+   */
+  async deleteFeatures(deleteParams) {
+    const params = new URLSearchParams({
+      f: 'json'
+    });
+    if (deleteParams.objectIds) {
+      params.append('objectIds', deleteParams.objectIds.join(','));
+    }
+    if (deleteParams.where) {
+      params.append('where', deleteParams.where);
+    }
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${this._esriServiceOptions.url}/deleteFeatures`, {
+      method: 'POST',
+      body: params,
+      headers: this._getFetchHeaders(),
+      ...this._esriServiceOptions.fetchOptions
+    });
+    if (!response.ok) {
+      throw new Error(`Delete features failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    this._checkAgolError(data);
+    return data.deleteResults;
+  }
+  /**
+   * Apply multiple edits in a single transaction
+   */
+  async applyEdits(edits, options) {
+    const params = new URLSearchParams({
+      f: 'json'
+    });
+    if (edits.adds) params.append('adds', JSON.stringify(edits.adds));
+    if (edits.updates) params.append('updates', JSON.stringify(edits.updates));
+    if (edits.deletes) params.append('deletes', edits.deletes.join(','));
+    if (options?.gdbVersion) params.append('gdbVersion', options.gdbVersion);
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${this._esriServiceOptions.url}/applyEdits`, {
+      method: 'POST',
+      body: params,
+      headers: this._getFetchHeaders(),
+      ...this._esriServiceOptions.fetchOptions
+    });
+    if (!response.ok) {
+      throw new Error(`Apply edits failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    this._checkAgolError(data);
+    return data;
+  }
+  // ========================================
+  // Attachment Methods
+  // ========================================
+  /**
+   * Query attachments for a feature
+   */
+  async queryAttachments(objectId, options) {
+    const params = new URLSearchParams({
+      f: 'json'
+    });
+    if (options?.globalIds) {
+      params.append('globalIds', options.globalIds.join(','));
+    }
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${this._esriServiceOptions.url}/${objectId}/attachments?${params.toString()}`, {
+      headers: this._getFetchHeaders(),
+      ...this._esriServiceOptions.fetchOptions
+    });
+    if (!response.ok) {
+      throw new Error(`Query attachments failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    this._checkAgolError(data);
+    return data.attachmentInfos || [];
+  }
+  /**
+   * Add an attachment to a feature
+   */
+  async addAttachment(objectId, file, fileName) {
+    const formData = new FormData();
+    formData.append('f', 'json');
+    formData.append('attachment', file, fileName || (file instanceof File ? file.name : 'attachment'));
+    if (this._esriServiceOptions.token) {
+      formData.append('token', this._esriServiceOptions.token);
+    }
+    const headers = {};
+    if (this._esriServiceOptions.apiKey) {
+      headers['X-Esri-Authorization'] = `Bearer ${this._esriServiceOptions.apiKey}`;
+    }
+    const response = await fetch(`${this._esriServiceOptions.url}/${objectId}/addAttachment`, {
+      method: 'POST',
+      body: formData,
+      headers: Object.keys(headers).length > 0 ? headers : undefined
+    });
+    if (!response.ok) {
+      throw new Error(`Add attachment failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    this._checkAgolError(data);
+    return data.addAttachmentResult;
+  }
+  /**
+   * Delete attachments from a feature
+   */
+  async deleteAttachments(objectId, attachmentIds) {
+    const params = new URLSearchParams({
+      f: 'json',
+      attachmentIds: attachmentIds.join(',')
+    });
+    this._appendTokenIfExists(params);
+    const response = await fetch(`${this._esriServiceOptions.url}/${objectId}/deleteAttachments`, {
+      method: 'POST',
+      body: params,
+      headers: this._getFetchHeaders(),
+      ...this._esriServiceOptions.fetchOptions
+    });
+    if (!response.ok) {
+      throw new Error(`Delete attachments failed: HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    this._checkAgolError(data);
+    return data.deleteAttachmentResults;
+  }
+  // Legacy method aliases for backwards compatibility
+  /** @deprecated Use setWhere instead */
+  updateSource() {
+    this._clearAndRefreshTiles();
+  }
+  /** @deprecated Use setWhere instead */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  setLayers(_layers) {
+    // FeatureService doesn't support layers parameter (single layer only)
+    console.warn('setLayers is not applicable to FeatureService. Use the layer URL directly.');
+  }
+  /** @deprecated Use clearWhere instead */
+  setGeometry(geometry, geometryType) {
+    // For compatibility, but recommend using queryFeatures with geometry parameter
+    console.warn('setGeometry is not recommended. Use queryFeatures({ geometry: ... }) for spatial queries.');
+    this._esriServiceOptions.geometry = geometry;
+    if (geometryType) {
+      this._esriServiceOptions.geometryType = geometryType;
+    }
+  }
+  /** @deprecated */
+  clearGeometry() {
+    delete this._esriServiceOptions.geometry;
+    delete this._esriServiceOptions.geometryType;
+  }
+  /** @deprecated Use enableRequests/disableRequests instead */
+  setBoundingBoxFilter(enabled) {
+    if (enabled) {
+      this.enableRequests();
+    } else {
+      this.disableRequests();
+    }
+  }
+  /** @deprecated Use _clearAndRefreshTiles instead */
+  updateData() {
+    this._clearAndRefreshTiles();
+  }
+}
+
+/**
+ * Base Task class for ArcGIS REST API operations
+ * Similar to Esri Leaflet's Task class
+ */
+class Task {
+  constructor(endpoint) {
+    Object.defineProperty(this, "_service", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "options", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "params", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {}
+    });
+    Object.defineProperty(this, "path", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: ''
+    });
+    Object.defineProperty(this, "setters", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {}
+    });
+    // endpoint can be either a url (and options) for an ArcGIS Rest Service or an instance of Service
+    if (endpoint && typeof endpoint === 'object' && 'request' in endpoint) {
+      this._service = endpoint;
+      this.options = {}; // Service will handle its own options
+    } else if (typeof endpoint === 'string') {
+      this.options = {
+        url: cleanTrailingSlash(endpoint)
+      };
+    } else {
+      this.options = {
+        ...endpoint
+      };
+      if (this.options.url) {
+        this.options.url = cleanTrailingSlash(this.options.url);
+      }
+    }
+    // Initialize params if not already set by subclass
+    if (!this.params) {
+      this.params = {};
+    }
+    // Generate setter methods based on the setters object
+    if (this.setters) {
+      for (const setter in this.setters) {
+        const param = this.setters[setter];
+        this[setter] = this.generateSetter(param, this);
+      }
+    }
+  }
+  /**
+   * Generate a method for each methodName:paramName in the setters for this task
+   */
+  generateSetter(param, context) {
+    return function (value) {
+      context.params[param] = value;
+      return context;
+    };
+  }
+  /**
+   * Set authentication token
+   */
+  token(token) {
+    if (this._service) {
+      this._service.authenticate(token);
+    } else {
+      this.params.token = token;
+    }
+    return this;
+  }
+  /**
+   * Set API key (alias for token)
+   */
+  apikey(apikey) {
+    return this.token(apikey);
+  }
+  /**
+   * Set whether to return formatted or unformatted values (ArcGIS Server 10.5+)
+   */
+  format(formatted) {
+    this.params.returnUnformattedValues = !formatted;
+    return this;
+  }
+  /**
+   * Execute the task request with callback (Esri Leaflet style)
+   */
+  run(callback) {
+    if (this.options.requestParams) {
+      Object.assign(this.params, this.options.requestParams);
+    }
+    if (this._service) {
+      this._service.requestWithCallback('POST', this.path, this.params, callback);
+      return;
+    }
+    // Direct request fallback
+    this._request('POST', this.path, this.params, callback);
+  }
+  /**
+   * Execute the task request with Promise
+   */
+  async request() {
+    if (this.options.requestParams) {
+      Object.assign(this.params, this.options.requestParams);
+    }
+    if (this._service) {
+      return this._service.requestWithCallback('POST', this.path, this.params);
+    }
+    return new Promise((resolve, reject) => {
+      this._request('POST', this.path, this.params, (error, response) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(response);
+        }
+      });
+    });
+  }
+  /**
+   * Direct HTTP request (when not using a service)
+   */
+  _request(method, path, params, callback) {
+    if (!this.options.url) {
+      callback(new Error('URL is required for task execution'));
+      return;
+    }
+    // Ensure proper URL construction with path separator
+    const baseUrl = this.options.url.endsWith('/') ? this.options.url.slice(0, -1) : this.options.url;
+    const cleanPath = path.startsWith('/') ? path : `/${path}`;
+    const fullServiceUrl = `${baseUrl}${cleanPath}`;
+    const url = this.options.proxy ? `${this.options.proxy}?${fullServiceUrl}` : fullServiceUrl;
+    // Convert params to URLSearchParams
+    const searchParams = new URLSearchParams();
+    Object.keys(params).forEach(key => {
+      const value = params[key];
+      if (value !== undefined && value !== null) {
+        if (Array.isArray(value)) {
+          searchParams.append(key, value.join(','));
+        } else if (typeof value === 'object') {
+          searchParams.append(key, JSON.stringify(value));
+        } else {
+          searchParams.append(key, value.toString());
+        }
+      }
+    });
+    const fullUrl = method === 'GET' ? `${url}?${searchParams.toString()}` : url;
+    const fetchOptions = {
+      method,
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded'
+      }
+    };
+    if (method === 'POST') {
+      fetchOptions.body = searchParams.toString();
+    }
+    fetch(fullUrl, fetchOptions).then(response => {
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      return response.json();
+    }).then(data => {
+      // Check for AGOL JSON-level errors (HTTP 200 with error body)
+      if (data && typeof data === 'object' && data.error) {
+        const err = new Error(data.error.message || 'ArcGIS service error');
+        err.code = data.error.code;
+        err.details = data.error.details;
+        callback(err);
+        return;
+      }
+      callback(undefined, data);
+    }).catch(error => callback(error));
+  }
+}
+
+/**
+ * Query task for ArcGIS Feature Services
+ * Based on Esri Leaflet's Query functionality
+ */
+class Query extends Task {
+  constructor(options) {
+    super(options);
+    Object.defineProperty(this, "setters", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {
+        offset: 'resultOffset',
+        limit: 'resultRecordCount',
+        fields: 'outFields',
+        precision: 'geometryPrecision',
+        featureIds: 'objectIds',
+        returnGeometry: 'returnGeometry',
+        returnM: 'returnM',
+        transform: 'datumTransformation',
+        token: 'token'
+      }
+    });
+    Object.defineProperty(this, "path", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 'query'
+    });
+    Object.defineProperty(this, "params", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {
+        returnGeometry: true,
+        where: '1=1',
+        outSR: 4326,
+        outFields: '*',
+        f: 'json'
+      }
+    });
+    this.path = 'query';
+    // If options is a QueryOptions object, merge relevant properties into params
+    if (options && typeof options === 'object' && !('request' in options) && typeof options !== 'string') {
+      const queryOptions = options;
+      // Merge query-specific options into params
+      if (queryOptions.where !== undefined) this.params.where = queryOptions.where;
+      if (queryOptions.outFields !== undefined) this.params.outFields = queryOptions.outFields;
+      if (queryOptions.returnGeometry !== undefined) this.params.returnGeometry = queryOptions.returnGeometry;
+      if (queryOptions.spatialRel !== undefined) this.params.spatialRel = queryOptions.spatialRel;
+      if (queryOptions.geometry !== undefined) this.params.geometry = queryOptions.geometry;
+      if (queryOptions.geometryType !== undefined) this.params.geometryType = queryOptions.geometryType;
+      if (queryOptions.inSR !== undefined) this.params.inSR = queryOptions.inSR;
+      if (queryOptions.outSR !== undefined) this.params.outSR = queryOptions.outSR;
+      if (queryOptions.returnDistinctValues !== undefined) this.params.returnDistinctValues = queryOptions.returnDistinctValues;
+      if (queryOptions.returnIdsOnly !== undefined) this.params.returnIdsOnly = queryOptions.returnIdsOnly;
+      if (queryOptions.returnCountOnly !== undefined) this.params.returnCountOnly = queryOptions.returnCountOnly;
+      if (queryOptions.returnExtentOnly !== undefined) this.params.returnExtentOnly = queryOptions.returnExtentOnly;
+      if (queryOptions.orderByFields !== undefined) this.params.orderByFields = queryOptions.orderByFields;
+      if (queryOptions.groupByFieldsForStatistics !== undefined) this.params.groupByFieldsForStatistics = queryOptions.groupByFieldsForStatistics;
+      if (queryOptions.outStatistics !== undefined) this.params.outStatistics = queryOptions.outStatistics;
+      if (queryOptions.resultOffset !== undefined) this.params.resultOffset = queryOptions.resultOffset;
+      if (queryOptions.resultRecordCount !== undefined) this.params.resultRecordCount = queryOptions.resultRecordCount;
+      if (queryOptions.maxAllowableOffset !== undefined) this.params.maxAllowableOffset = queryOptions.maxAllowableOffset;
+      if (queryOptions.geometryPrecision !== undefined) this.params.geometryPrecision = queryOptions.geometryPrecision;
+      if (queryOptions.time !== undefined) this.params.time = queryOptions.time;
+      if (queryOptions.gdbVersion !== undefined) this.params.gdbVersion = queryOptions.gdbVersion;
+      if (queryOptions.historicMoment !== undefined) this.params.historicMoment = queryOptions.historicMoment;
+      if (queryOptions.returnTrueCurves !== undefined) this.params.returnTrueCurves = queryOptions.returnTrueCurves;
+      if (queryOptions.returnZ !== undefined) this.params.returnZ = queryOptions.returnZ;
+      if (queryOptions.returnM !== undefined) this.params.returnM = queryOptions.returnM;
+      if (queryOptions.token !== undefined) this.params.token = queryOptions.token;
+    }
+  }
+  // Spatial relationship methods
+  /**
+   * Returns a feature if its shape is wholly contained within the search geometry
+   */
+  within(geometry) {
+    this._setGeometryParams(geometry);
+    this.params.spatialRel = 'esriSpatialRelContains';
+    return this;
+  }
+  /**
+   * Returns a feature if any spatial relationship is found
+   */
+  intersects(geometry) {
+    this._setGeometryParams(geometry);
+    this.params.spatialRel = 'esriSpatialRelIntersects';
+    return this;
+  }
+  /**
+   * Returns a feature if its shape wholly contains the search geometry
+   */
+  contains(geometry) {
+    this._setGeometryParams(geometry);
+    this.params.spatialRel = 'esriSpatialRelWithin';
+    return this;
+  }
+  /**
+   * Returns a feature if the intersection of the interiors is not empty and has lower dimension
+   */
+  crosses(geometry) {
+    this._setGeometryParams(geometry);
+    this.params.spatialRel = 'esriSpatialRelCrosses';
+    return this;
+  }
+  /**
+   * Returns a feature if the two shapes share a common boundary
+   */
+  touches(geometry) {
+    this._setGeometryParams(geometry);
+    this.params.spatialRel = 'esriSpatialRelTouches';
+    return this;
+  }
+  /**
+   * Returns a feature if the intersection results in same dimension but different from both shapes
+   */
+  overlaps(geometry) {
+    this._setGeometryParams(geometry);
+    this.params.spatialRel = 'esriSpatialRelOverlaps';
+    return this;
+  }
+  /**
+   * Returns a feature if the envelope of the two shapes intersects
+   */
+  bboxIntersects(geometry) {
+    this._setGeometryParams(geometry);
+    this.params.spatialRel = 'esriSpatialRelEnvelopeIntersects';
+    return this;
+  }
+  /**
+   * Nearby search - only valid for ArcGIS Server 10.3+ or ArcGIS Online
+   */
+  nearby(latlng, radius) {
+    this.params.geometry = [latlng.lng, latlng.lat];
+    this.params.geometryType = 'esriGeometryPoint';
+    this.params.spatialRel = 'esriSpatialRelIntersects';
+    this.params.units = 'esriSRUnit_Meter';
+    this.params.distance = radius;
+    this.params.inSR = 4326;
+    return this;
+  }
+  // Query methods
+  /**
+   * Set WHERE clause for the query
+   */
+  where(whereClause) {
+    this.params.where = whereClause;
+    return this;
+  }
+  /**
+   * Set time range for temporal queries
+   */
+  between(start, end) {
+    const startTime = start instanceof Date ? start.valueOf() : start;
+    const endTime = end instanceof Date ? end.valueOf() : end;
+    this.params.time = [startTime, endTime];
+    return this;
+  }
+  /**
+   * Simplify geometries based on map resolution
+   */
+  simplify(map, factor) {
+    const bounds = map.getBounds();
+    const mapWidth = Math.abs(bounds._northEast.lng - bounds._southWest.lng);
+    this.params.maxAllowableOffset = mapWidth / map.getSize().x * factor;
+    return this;
+  }
+  /**
+   * Set order by fields
+   */
+  orderBy(fieldName, order = 'ASC') {
+    const currentOrder = this.params.orderByFields || '';
+    this.params.orderByFields = currentOrder ? `${currentOrder},${fieldName} ${order}` : `${fieldName} ${order}`;
+    return this;
+  }
+  /**
+   * Set specific layer to query (for Map Services)
+   */
+  layer(layerId) {
+    this.path = `${layerId}/query`;
+    return this;
+  }
+  /**
+   * Return only distinct values
+   */
+  distinct() {
+    this.params.returnGeometry = false;
+    this.params.returnDistinctValues = true;
+    return this;
+  }
+  /**
+   * Set pixel size for image services
+   */
+  pixelSize(point) {
+    this.params.pixelSize = [point.x, point.y];
+    return this;
+  }
+  // Execution methods
+  /**
+   * Execute the query and return features
+   */
+  async run() {
+    this._cleanParams();
+    // Use GeoJSON format if supported
+    this.params.f = 'geojson';
+    try {
+      const response = await this.request();
+      return response;
+    } catch {
+      // Fallback to JSON format and convert
+      this.params.f = 'json';
+      const response = await this.request();
+      return this._convertToGeoJSON(response);
+    }
+  }
+  /**
+   * Execute the query with automatic pagination, collecting all pages of results.
+   * Loops while exceededTransferLimit is true, incrementing resultOffset.
+   */
+  async runAll(options) {
+    const maxPages = options?.maxPages ?? 100;
+    const allFeatures = [];
+    let page = 0;
+    let offset = this.params.resultOffset || 0;
+    while (page < maxPages) {
+      this.params.resultOffset = offset;
+      this._cleanParams();
+      this.params.f = 'geojson';
+      const response = await this.request();
+      const features = response.features || [];
+      allFeatures.push(...features);
+      if (!response.exceededTransferLimit || features.length === 0) {
+        break;
+      }
+      offset += features.length;
+      page++;
+    }
+    // Reset offset
+    delete this.params.resultOffset;
+    return {
+      type: 'FeatureCollection',
+      features: allFeatures
+    };
+  }
+  /**
+   * Execute the query and return only the count
+   */
+  async count() {
+    this._cleanParams();
+    this.params.returnCountOnly = true;
+    const response = await this.request();
+    return response.count;
+  }
+  /**
+   * Execute the query and return only feature IDs
+   */
+  async ids() {
+    this._cleanParams();
+    this.params.returnIdsOnly = true;
+    const response = await this.request();
+    return response.objectIds || response.globalIds || [];
+  }
+  /**
+   * Execute the query and return extent bounds (ArcGIS Server 10.3+)
+   */
+  async bounds() {
+    this._cleanParams();
+    this.params.returnExtentOnly = true;
+    const response = await this.request();
+    if (!response.extent) {
+      throw new Error('Invalid bounds returned');
+    }
+    return {
+      _southWest: {
+        lat: response.extent.ymin,
+        lng: response.extent.xmin
+      },
+      _northEast: {
+        lat: response.extent.ymax,
+        lng: response.extent.xmax
+      }
+    };
+  }
+  // Private methods
+  _setGeometryParams(geometry) {
+    this.params.inSR = 4326;
+    const converted = this._setGeometry(geometry);
+    this.params.geometry = converted.geometry;
+    this.params.geometryType = converted.geometryType;
+  }
+  _setGeometry(geometry) {
+    if (!geometry) {
+      return {
+        geometry: null,
+        geometryType: 'esriGeometryPoint'
+      };
+    }
+    // Handle different geometry types
+    if (typeof geometry === 'object' && geometry !== null) {
+      const geom = geometry;
+      if ('lat' in geom && 'lng' in geom) {
+        // Leaflet LatLng-like object
+        return {
+          geometry: {
+            x: geom.lng,
+            y: geom.lat,
+            spatialReference: {
+              wkid: 4326
+            }
+          },
+          geometryType: 'esriGeometryPoint'
+        };
+      }
+      if ('_southWest' in geom && '_northEast' in geom) {
+        // Leaflet Bounds-like object
+        const bounds = geom;
+        return {
+          geometry: {
+            xmin: bounds._southWest.lng,
+            ymin: bounds._southWest.lat,
+            xmax: bounds._northEast.lng,
+            ymax: bounds._northEast.lat,
+            spatialReference: {
+              wkid: 4326
+            }
+          },
+          geometryType: 'esriGeometryEnvelope'
+        };
+      }
+      if ('xmin' in geom && 'ymin' in geom && 'xmax' in geom && 'ymax' in geom) {
+        // Esri envelope geometry
+        return {
+          geometry,
+          geometryType: 'esriGeometryEnvelope'
+        };
+      }
+    }
+    // Default: assume it's already in Esri geometry format
+    return {
+      geometry,
+      geometryType: 'esriGeometryPoint'
+    };
+  }
+  _cleanParams() {
+    delete this.params.returnIdsOnly;
+    delete this.params.returnExtentOnly;
+    delete this.params.returnCountOnly;
+    delete this.params.returnDistinctValues;
+  }
+  _convertToGeoJSON(response) {
+    // Handle cases where features might be undefined or empty
+    const features = (response.features || []).map(feature => ({
+      type: 'Feature',
+      properties: feature.attributes,
+      geometry: feature.geometry || null
+    }));
+    return {
+      type: 'FeatureCollection',
+      features
+    };
+  }
+}
+function query(options) {
+  return new Query(options);
+}
+
+/**
+ * Find task for searching text in ArcGIS Map Services
+ * Based on Esri Leaflet's Find functionality
+ */
+class Find extends Task {
+  constructor(options) {
+    super(options);
+    Object.defineProperty(this, "setters", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {
+        contains: 'contains',
+        text: 'searchText',
+        fields: 'searchFields',
+        spatialReference: 'sr',
+        sr: 'sr',
+        layers: 'layers',
+        returnGeometry: 'returnGeometry',
+        maxAllowableOffset: 'maxAllowableOffset',
+        precision: 'geometryPrecision',
+        dynamicLayers: 'dynamicLayers',
+        returnZ: 'returnZ',
+        returnM: 'returnM',
+        gdbVersion: 'gdbVersion',
+        token: 'token'
+      }
+    });
+    Object.defineProperty(this, "path", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 'find'
+    });
+    Object.defineProperty(this, "params", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {
+        searchText: '',
+        // Required parameter
+        layers: 'all',
+        // Can be 'all' or comma-separated layer IDs
+        contains: true,
+        returnGeometry: true,
+        f: 'json'
+      }
+    });
+    this.path = 'find';
+    // If options is a FindOptions object, merge relevant properties into params
+    if (options && typeof options === 'object' && !('request' in options) && typeof options !== 'string') {
+      const findOptions = options;
+      // Merge find-specific options into params
+      if (findOptions.searchText !== undefined) this.params.searchText = findOptions.searchText;
+      if (findOptions.contains !== undefined) this.params.contains = findOptions.contains;
+      if (findOptions.searchFields !== undefined) {
+        this.params.searchFields = Array.isArray(findOptions.searchFields) ? findOptions.searchFields.join(',') : findOptions.searchFields;
+      }
+      if (findOptions.sr !== undefined) this.params.sr = findOptions.sr;
+      if (findOptions.layers !== undefined) {
+        // Convert array to comma-separated string or use as-is if already string
+        if (Array.isArray(findOptions.layers)) {
+          this.params.layers = findOptions.layers.join(',');
+        } else if (typeof findOptions.layers === 'string') {
+          this.params.layers = findOptions.layers;
+        } else {
+          this.params.layers = findOptions.layers.toString();
+        }
+      }
+      if (findOptions.returnGeometry !== undefined) this.params.returnGeometry = findOptions.returnGeometry;
+      if (findOptions.maxAllowableOffset !== undefined) this.params.maxAllowableOffset = findOptions.maxAllowableOffset;
+      if (findOptions.geometryPrecision !== undefined) this.params.geometryPrecision = findOptions.geometryPrecision;
+      if (findOptions.dynamicLayers !== undefined) this.params.dynamicLayers = findOptions.dynamicLayers;
+      if (findOptions.returnZ !== undefined) this.params.returnZ = findOptions.returnZ;
+      if (findOptions.returnM !== undefined) this.params.returnM = findOptions.returnM;
+      if (findOptions.gdbVersion !== undefined) this.params.gdbVersion = findOptions.gdbVersion;
+      if (findOptions.layerDefs !== undefined) this.params.layerDefs = findOptions.layerDefs;
+      if (findOptions.token !== undefined) this.params.token = findOptions.token;
+    }
+  }
+  /**
+   * Set the text to search for
+   */
+  text(searchText) {
+    this.params.searchText = searchText;
+    return this;
+  }
+  /**
+   * Set the fields to search in
+   */
+  fields(fields) {
+    this.params.searchFields = Array.isArray(fields) ? fields.join(',') : fields;
+    return this;
+  }
+  /**
+   * Set whether the search should contain the text (partial match) or exact match
+   */
+  contains(contains) {
+    this.params.contains = contains;
+    return this;
+  }
+  /**
+   * Set which layers to search in
+   */
+  layers(layers) {
+    if (Array.isArray(layers)) {
+      this.params.layers = layers.join(',');
+    } else {
+      this.params.layers = layers;
+    }
+    return this;
+  }
+  /**
+   * Set layer definitions for filtering specific layers
+   */
+  layerDefs(layerId, whereClause) {
+    const currentLayerDefs = this.params.layerDefs || '';
+    this.params.layerDefs = currentLayerDefs ? `${currentLayerDefs};${layerId}:${whereClause}` : `${layerId}:${whereClause}`;
+    return this;
+  }
+  /**
+   * Simplify geometries based on map resolution
+   */
+  simplify(map, factor) {
+    const bounds = map.getBounds();
+    const mapWidth = Math.abs(bounds.getWest() - bounds.getEast());
+    this.params.maxAllowableOffset = mapWidth / map.getSize().x * factor;
+    return this;
+  }
+  /**
+   * Execute the find operation
+   */
+  async run() {
+    // Always use JSON format for Find API (GeoJSON might not be supported)
+    this.params.f = 'json';
+    try {
+      const response = await this.request();
+      return this._convertToGeoJSON(response);
+    } catch (error) {
+      const isTestEnvironment = typeof process !== 'undefined' && process.env?.NODE_ENV === 'test';
+      if (!isTestEnvironment) {
+        console.error('Find task error:', error);
+      }
+      throw error;
+    }
+  }
+  _convertToGeoJSON(response) {
+    // Handle cases where response is null or results might be undefined, null, or empty
+    const results = response?.results || [];
+    const features = results.map(result => ({
+      type: 'Feature',
+      properties: {
+        ...result.attributes,
+        layerId: result.layerId,
+        layerName: result.layerName,
+        foundFieldName: result.foundFieldName,
+        value: result.value
+      },
+      geometry: this._convertEsriGeometry(result.geometry)
+    }));
+    return {
+      type: 'FeatureCollection',
+      features
+    };
+  }
+  _convertEsriGeometry(esriGeom) {
+    if (!esriGeom || typeof esriGeom !== 'object') return null;
+    const geom = esriGeom;
+    // Point geometry
+    if ('x' in geom && 'y' in geom) {
+      return {
+        type: 'Point',
+        coordinates: [geom.x, geom.y]
+      };
+    }
+    // Polygon geometry
+    if ('rings' in geom && Array.isArray(geom.rings)) {
+      return {
+        type: 'Polygon',
+        coordinates: geom.rings
+      };
+    }
+    // Polyline geometry
+    if ('paths' in geom && Array.isArray(geom.paths)) {
+      const paths = geom.paths;
+      if (paths.length === 1) {
+        // Single path = LineString
+        return {
+          type: 'LineString',
+          coordinates: paths[0]
+        };
+      } else {
+        // Multiple paths = MultiLineString
+        return {
+          type: 'MultiLineString',
+          coordinates: paths
+        };
+      }
+    }
+    // Default: return null for unknown geometry types
+    return null;
+  }
+}
+function find(options) {
+  return new Find(options);
+}
+
+/**
+ * IdentifyFeatures task for performing identify operations against ArcGIS Map Services
+ * Similar to Esri Leaflet's identifyFeatures functionality
+ */
+// Scale constant: at zoom 0 and 96 DPI, the Web Mercator scale denominator
+const SCALE_AT_ZOOM_0 = 559082264.028;
+class IdentifyFeatures extends Task {
+  constructor(options) {
+    // Handle different input types and convert to TaskOptions format
+    let taskOptions;
+    if (typeof options === 'string') {
+      taskOptions = options;
+    } else if (options instanceof Service) {
+      // Extract URL from Service instance
+      taskOptions = {
+        url: options.options.url
+      };
+    } else {
+      // It's IdentifyFeaturesOptions, use as TaskOptions
+      taskOptions = options;
+    }
+    super(taskOptions);
+    Object.defineProperty(this, "setters", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {
+        layers: 'layers',
+        precision: 'geometryPrecision',
+        tolerance: 'tolerance',
+        returnGeometry: 'returnGeometry'
+      }
+    });
+    Object.defineProperty(this, "path", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: '/identify'
+    });
+    Object.defineProperty(this, "params", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {
+        sr: 4326,
+        layers: 'all',
+        tolerance: 3,
+        returnGeometry: true,
+        f: 'json'
+      }
+    });
+    Object.defineProperty(this, "_map", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "_layerScaleRanges", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {}
+    });
+    this.path = '/identify';
+    // Ensure dynamic setters are available even though subclass fields
+    // are initialized after super() runs. This rebinds setter methods.
+    if (this.setters) {
+      for (const [method, param] of Object.entries(this.setters)) {
+        this[method] = this.generateSetter(param, this);
+      }
+    }
+  }
+  /**
+   * Perform identify operation at a point location
+   */
+  at(point) {
+    let geometry;
+    if (Array.isArray(point)) {
+      geometry = {
+        x: point[0],
+        y: point[1],
+        spatialReference: {
+          wkid: 4326
+        }
+      };
+    } else {
+      geometry = {
+        x: point.lng,
+        y: point.lat,
+        spatialReference: {
+          wkid: 4326
+        }
+      };
+    }
+    this.params.geometry = JSON.stringify(geometry);
+    this.params.geometryType = 'esriGeometryPoint';
+    return this;
+  }
+  // Strongly-typed chainable setters for common Identify params
+  layers(value) {
+    this.params.layers = value;
+    return this;
+  }
+  tolerance(value) {
+    this.params.tolerance = value;
+    return this;
+  }
+  returnGeometry(value) {
+    this.params.returnGeometry = value;
+    return this;
+  }
+  precision(value) {
+    this.params.geometryPrecision = value;
+    return this;
+  }
+  /**
+   * Set the map extent and image display for the identify operation.
+   * Also stores the map reference for zoom-based scale filtering.
+   */
+  on(map) {
+    this._map = map;
+    try {
+      const bounds = map.getBounds().toArray();
+      this.params.mapExtent = [bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]].join(',');
+      const canvas = map.getCanvas();
+      this.params.imageDisplay = [canvas.width, canvas.height, 96].join(',');
+    } catch (error) {
+      console.warn('Could not extract map extent and display info:', error);
+    }
+    return this;
+  }
+  /**
+   * Set scale ranges for layers so the identify can skip layers not visible at the current zoom.
+   * ArcGIS uses minScale (zoomed out limit) and maxScale (zoomed in limit).
+   * A value of 0 means no limit.
+   *
+   * @example
+   * identify.layerScales({
+   *   0: { minScale: 1000000, maxScale: 0 },     // Cities: visible below 1:1M
+   *   1: { minScale: 5000000, maxScale: 500000 }, // Highways: visible between 1:5M and 1:500K
+   *   2: { minScale: 0, maxScale: 0 },            // States: always visible
+   * });
+   */
+  layerScales(scales) {
+    this._layerScaleRanges = scales;
+    return this;
+  }
+  /**
+   * Set layer definitions for filtering specific layers
+   */
+  layerDef(layerId, whereClause) {
+    const currentLayerDefs = this.params.layerDefs || '';
+    this.params.layerDefs = currentLayerDefs ? `${currentLayerDefs};${layerId}:${whereClause}` : `${layerId}:${whereClause}`;
+    return this;
+  }
+  /**
+   * Simplify geometries based on map resolution
+   */
+  simplify(map, factor) {
+    const bounds = map.getBounds();
+    const mapWidth = Math.abs(bounds.getWest() - bounds.getEast());
+    this.params.maxAllowableOffset = mapWidth / map.getSize().x * factor;
+    return this;
+  }
+  /**
+   * Get the current map scale from zoom level.
+   * Uses the standard Web Mercator scale formula at 96 DPI.
+   */
+  _getMapScale() {
+    if (!this._map || typeof this._map.getZoom !== 'function') return null;
+    const zoom = this._map.getZoom();
+    return SCALE_AT_ZOOM_0 / Math.pow(2, zoom);
+  }
+  /**
+   * Check if a layer is visible at the given scale.
+   * ArcGIS convention: minScale = most zoomed out (largest number), maxScale = most zoomed in (smallest number).
+   * A value of 0 means no limit in that direction.
+   */
+  _isLayerVisibleAtScale(layerId, scale) {
+    const range = this._layerScaleRanges[layerId];
+    if (!range) return true; // No scale info means always visible
+    if (range.minScale && scale > range.minScale) return false; // Too zoomed out
+    if (range.maxScale && scale < range.maxScale) return false; // Too zoomed in
+    return true;
+  }
+  /**
+   * Filter the layers parameter to only include layers visible at the current scale.
+   * Returns false if no layers are visible (request should be skipped).
+   */
+  _filterLayersByScale() {
+    const scale = this._getMapScale();
+    if (scale === null || Object.keys(this._layerScaleRanges).length === 0) return true;
+    const layersParam = this.params.layers;
+    if (typeof layersParam !== 'string') return true;
+    // Parse layers string: "all", "visible:0,1,2", "top", "visible", "0,1,2"
+    const match = layersParam.match(/^(all|top|visible)(?::(.+))?$/);
+    if (!match) return true;
+    const prefix = match[1];
+    const idsPart = match[2];
+    // If no specific IDs, filter all known layer IDs from scale ranges
+    let layerIds;
+    if (idsPart) {
+      layerIds = idsPart.split(',').map(Number).filter(n => !isNaN(n));
+    } else {
+      layerIds = Object.keys(this._layerScaleRanges).map(Number);
+    }
+    const visibleIds = layerIds.filter(id => this._isLayerVisibleAtScale(id, scale));
+    if (visibleIds.length === 0) return false;
+    // Update layers param with only visible IDs
+    this.params.layers = `${prefix}:${visibleIds.join(',')}`;
+    return true;
+  }
+  /**
+   * Execute the identify operation.
+   * If layer scale ranges are set via `layerScales()` and a map is provided via `on()`,
+   * layers not visible at the current zoom level will be excluded. If no layers are visible,
+   * an empty FeatureCollection is returned without making a network request.
+   */
+  async run() {
+    // Skip request entirely if no layers are visible at the current scale
+    if (!this._filterLayersByScale()) {
+      return {
+        type: 'FeatureCollection',
+        features: []
+      };
+    }
+    try {
+      const response = await this.request();
+      return this._convertToGeoJSON(response);
+    } catch (error) {
+      const isTestEnvironment = typeof process !== 'undefined' && process.env?.NODE_ENV === 'test';
+      if (!isTestEnvironment) {
+        console.error('IdentifyFeatures error:', error);
+      }
+      throw error;
+    }
+  }
+  _convertToGeoJSON(response) {
+    const features = (response.results || []).map(result => {
+      const feature = {
+        type: 'Feature',
+        properties: {
+          ...result.attributes,
+          layerId: result.layerId,
+          layerName: result.layerName,
+          displayFieldName: result.displayFieldName,
+          value: result.value
+        },
+        geometry: result.geometry || null
+      };
+      // Add layerId as a custom property for easier identification
+      const featureWithLayerId = feature;
+      featureWithLayerId.layerId = result.layerId;
+      return feature;
+    });
+    return {
+      type: 'FeatureCollection',
+      features
+    };
+  }
+}
+
+/**
+ * IdentifyImage task for identifying pixel values in ArcGIS Image Services
+ * Based on Esri Leaflet's IdentifyImage functionality
+ */
+class IdentifyImage extends Task {
+  constructor(options) {
+    super(options);
+    Object.defineProperty(this, "setters", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {
+        returnCatalogItems: 'returnCatalogItems',
+        returnGeometry: 'returnGeometry',
+        pixelSize: 'pixelSize',
+        token: 'token'
+      }
+    });
+    Object.defineProperty(this, "path", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 'identify'
+    });
+    Object.defineProperty(this, "params", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: {
+        sr: 4326,
+        returnGeometry: false,
+        returnCatalogItems: false,
+        f: 'json'
+      }
+    });
+    // If options is a IdentifyImageOptions object, merge relevant properties into params
+    if (options && typeof options === 'object' && typeof options !== 'string') {
+      const imageOptions = options;
+      // Merge identify-specific options into params
+      if (imageOptions.geometry !== undefined) this.params.geometry = imageOptions.geometry;
+      if (imageOptions.geometryType !== undefined) this.params.geometryType = imageOptions.geometryType;
+      if (imageOptions.sr !== undefined) this.params.sr = imageOptions.sr;
+      if (imageOptions.mosaic !== undefined) this.params.mosaic = imageOptions.mosaic;
+      if (imageOptions.renderingRules !== undefined) this.params.renderingRules = imageOptions.renderingRules;
+      if (imageOptions.pixelSize !== undefined) this.params.pixelSize = imageOptions.pixelSize;
+      if (imageOptions.returnGeometry !== undefined) this.params.returnGeometry = imageOptions.returnGeometry;
+      if (imageOptions.returnCatalogItems !== undefined) this.params.returnCatalogItems = imageOptions.returnCatalogItems;
+      if (imageOptions.token !== undefined) this.params.token = imageOptions.token;
+      if (imageOptions.f !== undefined) this.params.f = imageOptions.f;
+    }
+  }
+  /**
+   * Identify pixel values at a specific point
+   */
+  at(point) {
+    let geometry;
+    if (Array.isArray(point)) {
+      geometry = {
+        x: point[0],
+        y: point[1],
+        spatialReference: {
+          wkid: 4326
+        }
+      };
+    } else {
+      geometry = {
+        x: point.lng,
+        y: point.lat,
+        spatialReference: {
+          wkid: 4326
+        }
+      };
+    }
+    this.params.geometry = JSON.stringify(geometry);
+    this.params.geometryType = 'esriGeometryPoint';
+    this.params.sr = 4326;
+    return this;
+  }
+  /**
+   * Set custom geometry for identification
+   */
+  geometry(geometry, geometryType) {
+    this.params.geometry = JSON.stringify(geometry);
+    this.params.geometryType = geometryType || 'esriGeometryPoint';
+    return this;
+  }
+  /**
+   * Set pixel size for the identify operation
+   */
+  pixelSize(size) {
+    if (Array.isArray(size)) {
+      this.params.pixelSize = `${size[0]},${size[1]}`;
+    } else {
+      this.params.pixelSize = `${size.x},${size.y}`;
+    }
+    return this;
+  }
+  /**
+   * Set whether to return geometry with results
+   */
+  returnGeometry(returnGeom) {
+    this.params.returnGeometry = returnGeom;
+    return this;
+  }
+  /**
+   * Set whether to return catalog items
+   */
+  returnCatalogItems(returnItems) {
+    this.params.returnCatalogItems = returnItems;
+    return this;
+  }
+  /**
+   * Set mosaic rule for the identify operation
+   */
+  mosaicRule(rule) {
+    this.params.mosaicRule = JSON.stringify(rule);
+    return this;
+  }
+  /**
+   * Set rendering rules for the identify operation
+   */
+  renderingRule(rule) {
+    this.params.renderingRule = JSON.stringify(rule);
+    return this;
+  }
+  /**
+   * Execute the identify operation
+   */
+  async run() {
+    const response = await this.request();
+    // Normalize different response formats
+    let results = [];
+    if (response.results) {
+      results = response.results;
+    } else if (response.value !== undefined || response.values) {
+      // Handle simple value responses
+      results = [{
+        value: response.value || response.values && response.values[0] || '',
+        attributes: response.properties || {}
+      }];
+    }
+    return {
+      results,
+      location: response.location
+    };
+  }
+  /**
+   * Execute and return pixel values as a simple array
+   */
+  async getPixelValues() {
+    const response = await this.run();
+    return response.results.map(result => {
+      if (result.value !== undefined) {
+        const numValue = parseFloat(result.value);
+        return isNaN(numValue) ? result.value : numValue;
+      }
+      return null;
+    });
+  }
+  /**
+   * Execute and return detailed pixel information
+   */
+  async getPixelData() {
+    const response = await this.run();
+    return response.results;
+  }
+}
+function identifyImage(options) {
+  return new IdentifyImage(options);
+}
+
+export { DynamicMapService as D, FeatureService as F, IdentifyFeatures as I, Query as Q, Service as S, Task as T, VectorBasemapStyle as V, Find as a, IdentifyImage as b, ImageService as c, TiledMapService as d, VectorTileService as e, cleanTrailingSlash as f, find as g, getServiceDetails as h, identifyImage as i, query as q, updateAttribution as u };
+//# sourceMappingURL=IdentifyImage-DWBF8K_a.js.map