import {
  element_default
} from "./chunk-S3QBQTEW.js";
import "./chunk-I4Q72WOW.js";
import "./chunk-RTVPCGIJ.js";
import "./chunk-MSWSBYBR.js";
import "./chunk-QCJTGAWF.js";
import "./chunk-CAVOO5JW.js";
import {
  Control_default
} from "./chunk-VRTURNK3.js";
import "./chunk-2C73OZ6M.js";
import "./chunk-M5TTSD4C.js";
import "./chunk-ZCRXKB7J.js";
import "./chunk-RW3V7S4F.js";
import "./chunk-PAB2HIXK.js";
import "./chunk-I6K7MRGV.js";
import "./chunk-PGWX4545.js";
import "./chunk-AYBYZSAV.js";
import "./chunk-YLJGUH5Z.js";
import "./chunk-AZGMK675.js";
import "./chunk-BHVDQB66.js";
import "./chunk-6EWLK2BW.js";
import "./chunk-5D2XPBR2.js";
import "./chunk-SHUBVYN4.js";
import "./chunk-FM44FOIC.js";
import "./chunk-LMC3RO5P.js";
import "./chunk-X52LGBOS.js";
import "./chunk-QFCIXVZ3.js";
import {
  transform
} from "./chunk-A3RXLHYB.js";
import "./chunk-ZLPTRF2L.js";
import "./chunk-54BTDBAD.js";
import "./chunk-UPTVWZ45.js";
import "./chunk-5XHD7RSF.js";
import {
  Object_default
} from "./chunk-Q5ZULJHM.js";
import {
  unByKey
} from "./chunk-NGFXCWUF.js";
import "./chunk-K25ZO44T.js";
import "./chunk-SRXHWJOY.js";
import "./chunk-5RHQVMYD.js";
import "./chunk-DC5AMYBS.js";

// node_modules/ol-ext/control/Search.js
var ol_control_Search = class olcontrolSearch extends Control_default {
  constructor(options) {
    options = options || {};
    var classNames = (options.className || "") + " ol-search" + (options.target ? "" : " ol-unselectable ol-control");
    var element = element_default.create("DIV", {
      className: classNames
    });
    super({
      element,
      target: options.target
    });
    var self = this;
    if (options.typing == void 0) {
      options.typing = 300;
    }
    this._classname = options.className || "search";
    if (options.collapsed !== false) element.classList.add("ol-collapsed");
    if (!options.target) {
      this.button = document.createElement("button");
      this.button.setAttribute("type", "button");
      this.button.setAttribute("title", options.title || options.label || "Search");
      this.button.addEventListener("click", function() {
        element.classList.toggle("ol-collapsed");
        if (!element.classList.contains("ol-collapsed")) {
          element.querySelector("input.search").focus();
          var listElements = element.querySelectorAll("li");
          for (var i = 0; i < listElements.length; i++) {
            listElements[i].classList.remove("select");
          }
          if (!input.value) {
            self.drawList_();
          }
        }
      });
      element.appendChild(this.button);
    }
    if (options.inputLabel) {
      var label = document.createElement("LABEL");
      label.innerText = options.inputLabel;
      element.appendChild(label);
    }
    var tout, cur = "";
    var input = this._input = document.createElement("INPUT");
    input.setAttribute("type", "search");
    input.setAttribute("class", "search");
    input.setAttribute("autocomplete", "off");
    input.setAttribute("placeholder", options.placeholder || "Search...");
    input.addEventListener("change", function(e) {
      self.dispatchEvent({ type: "change:input", input: e, value: input.value });
    });
    var doSearch = function(e) {
      var li = element.querySelector("ul.autocomplete li.select");
      var val = input.value;
      if (e.key == "ArrowDown" || e.key == "ArrowUp" || e.key == "Down" || e.key == "Up") {
        if (li) {
          var newli = /Down/.test(e.key) ? li.nextElementSibling : li.previousElementSibling;
          if (newli && !newli.classList.contains("copy")) {
            li.classList.remove("select");
            newli.classList.add("select");
            input.value = newli.innerText;
          }
        } else {
          li = element.querySelector("ul.autocomplete li");
          if (li) {
            li.classList.add("select");
            input.value = li.innerText;
          }
        }
      } else if (e.type == "input") {
        if (!val) {
          setTimeout(function() {
            self.drawList_();
          }, 200);
        }
        if (li) {
          input.value = val = "";
          li.classList.remove("select");
        }
      } else if (li && (e.type === "search" || e.key === "Enter")) {
        if (element.classList.contains("ol-control")) {
          input.blur();
        }
        li.classList.remove("select");
        cur = val;
        self._handleSelect(self._list[li.getAttribute("data-search")]);
      } else if (e.type === "search" || e.key === "Enter" || cur != val && options.typing >= 0) {
        cur = val;
        if (cur) {
          if (tout) {
            clearTimeout(tout);
          }
          var minLength = self.get("minLength");
          tout = setTimeout(function() {
            if (cur.length >= minLength) {
              var s = self.autocomplete(cur, function(auto) {
                self.drawList_(auto);
              });
              if (s) {
                self.drawList_(s);
              }
            } else {
              self.drawList_();
            }
          }, options.typing);
        } else {
          self.drawList_();
        }
      } else {
        li = element.querySelector("ul.autocomplete li");
        if (li) li.classList.remove("select");
      }
    };
    input.addEventListener("keyup", doSearch);
    input.addEventListener("search", doSearch);
    input.addEventListener("cut", doSearch);
    input.addEventListener("paste", doSearch);
    input.addEventListener("input", doSearch);
    if (!options.noCollapse) {
      input.addEventListener("blur", (function() {
        setTimeout((function() {
          if (input !== document.activeElement) {
            element.classList.add("ol-collapsed");
            this.set("reverse", false);
            element.classList.remove("ol-revers");
          }
        }).bind(this), 200);
      }).bind(this));
      input.addEventListener("focus", (function() {
        if (!this.get("reverse")) {
          element.classList.remove("ol-collapsed");
          element.classList.remove("ol-revers");
        }
      }).bind(this));
      input.addEventListener("keydown", (function() {
        this.set("reverse", false);
        element.classList.remove("ol-collapsed");
        element.classList.remove("ol-revers");
      }).bind(this));
    }
    element.appendChild(input);
    if (options.reverse) {
      var reverse = element_default.create("BUTTON", {
        type: "button",
        class: "ol-revers",
        title: options.reverseTitle || "click on the map",
        on: {
          focus: (function() {
            if (!this.get("reverse")) {
              this.set("reverse", !this.get("reverse"));
              input.focus();
              element.classList.add("ol-revers");
            } else {
              this.set("reverse", false);
            }
          }).bind(this)
        }
      });
      element.appendChild(reverse);
    }
    var ul = document.createElement("ul");
    ul.classList.add("autocomplete");
    element.appendChild(ul);
    if (typeof options.getTitle == "function") this.getTitle = options.getTitle;
    if (typeof options.autocomplete == "function") this.autocomplete = options.autocomplete;
    this.set("copy", options.copy);
    this.set("minLength", options.minLength || 1);
    this.set("maxItems", options.maxItems || 10);
    this.set("maxHistory", options.maxHistory || options.maxItems || 10);
    if (options.onselect)
      this.on("select", options.onselect);
    if (options.centerOnSelect) {
      this.on("select", (function(e) {
        var map = this.getMap();
        if (map) {
          map.getView().setCenter(e.coordinate);
        }
      }).bind(this));
    }
    if (options.zoomOnSelect) {
      this.on("select", (function(e) {
        var map = this.getMap();
        if (map) {
          map.getView().setCenter(e.coordinate);
          if (map.getView().getZoom() < options.zoomOnSelect)
            map.getView().setZoom(options.zoomOnSelect);
        }
      }).bind(this));
    }
    this.restoreHistory();
    this.drawList_();
  }
  /**
   * Remove the control from its current map and attach it to the new map.
   * Subclasses may set up event handlers to get notified about changes to
   * the map here.
   * @param {ol.Map} map Map.
   * @api stable
   */
  setMap(map) {
    if (this._listener) unByKey(this._listener);
    this._listener = null;
    super.setMap(map);
    if (map) {
      this._listener = map.on("click", this._handleClick.bind(this));
    }
  }
  /** Collapse the search
   * @param {boolean} [b=true]
   * @api
   */
  collapse(b) {
    if (b === false)
      this.element.classList.remove("ol-collapsed");
    else
      this.element.classList.add("ol-collapsed");
  }
  /** Get the input field
  *	@return {Element}
  *	@api
  */
  getInputField() {
    return this._input;
  }
  /** Returns the text to be displayed in the menu
   *	@param {any} f feature to be displayed
   *	@return {string} the text to be displayed in the index, default f.name
   *	@api
   */
  getTitle(f) {
    return f.name || "No title";
  }
  /** Returns title as text
   *	@param {any} f feature to be displayed
   *	@return {string}
   *	@api
   */
  _getTitleTxt(f) {
    return element_default.create("DIV", {
      html: this.getTitle(f)
    }).innerText;
  }
  /** Force search to refresh
   */
  search() {
    var search = this.element.querySelector("input.search");
    this._triggerCustomEvent("search", search);
  }
  /** Reverse geocode
   * @param {Object} event
   *  @param {ol.coordinate} event.coordinate
   * @private
   */
  _handleClick(e) {
    if (this.get("reverse")) {
      document.activeElement.blur();
      this.reverseGeocode(e.coordinate);
    }
  }
  /** Reverse geocode
   * @param {ol.coordinate} coord
   * @param {function | undefined} cback a callback function, default trigger a select event
   * @api
   */
  reverseGeocode() {
  }
  /** Trigger custom event on elemebt
   * @param {*} eventName
   * @param {*} element
   * @private
   */
  _triggerCustomEvent(eventName, element) {
    element_default.dispatchEvent(eventName, element);
  }
  /** Set the input value in the form (for initialisation purpose)
  *	@param {string} value
  *	@param {boolean} search to start a search
  *	@api
  */
  setInput(value, search) {
    var input = this.element.querySelector("input.search");
    input.value = value;
    if (search)
      this._triggerCustomEvent("keyup", input);
  }
  /** A line has been clicked in the menu > dispatch event
   * @param {any} f the feature, as passed in the autocomplete
   * @param {boolean} reverse true if reverse geocode
   * @param {ol.coordinate} coord
   * @param {*} options options passed to the event
   *	@api
   */
  select(f, reverse, coord, options) {
    var event = { type: "select", search: f, reverse: !!reverse, coordinate: coord };
    if (options) {
      for (var i in options) {
        event[i] = options[i];
      }
    }
    this.dispatchEvent(event);
  }
  /**
   * Save history and select
   * @param {*} f
   * @param {boolean} reverse true if reverse geocode
   * @param {*} options options send in the event
   * @private
   */
  _handleSelect(f, reverse, options) {
    if (!f)
      return;
    var hist = this.get("history");
    var i;
    try {
      var fstr = JSON.stringify(f);
      for (i = hist.length - 1; i >= 0; i--) {
        if (!hist[i] || JSON.stringify(hist[i]) === fstr) {
          hist.splice(i, 1);
        }
      }
    } catch (e) {
      for (i = hist.length - 1; i >= 0; i--) {
        if (hist[i] === f) {
          hist.splice(i, 1);
        }
      }
    }
    hist.unshift(f);
    var size = Math.max(0, this.get("maxHistory") || 10) || 0;
    while (hist.length > size) {
      hist.pop();
    }
    this.saveHistory();
    this.select(f, reverse, null, options);
    if (reverse) {
      this.setInput(this._getTitleTxt(f));
      this.drawList_();
      setTimeout((function() {
        this.collapse(false);
      }).bind(this), 300);
    }
  }
  /** Save history (in the localstorage)
   */
  saveHistory() {
    try {
      if (this.get("maxHistory") >= 0) {
        localStorage["ol@search-" + this._classname] = JSON.stringify(this.get("history"));
      } else {
        localStorage.removeItem("ol@search-" + this._classname);
      }
    } catch (e) {
      console.warn("Failed to access localStorage...");
    }
  }
  /** Restore history (from the localstorage)
   */
  restoreHistory() {
    if (this._history[this._classname]) {
      this.set("history", this._history[this._classname]);
    } else {
      try {
        this._history[this._classname] = JSON.parse(localStorage["ol@search-" + this._classname]);
        this.set("history", this._history[this._classname]);
      } catch (e) {
        this.set("history", []);
      }
    }
  }
  /**
   * Remove previous history
   */
  clearHistory() {
    this.set("history", []);
    this.saveHistory();
    this.drawList_();
  }
  /**
   * Get history table
   */
  getHistory() {
    return this.get("history");
  }
  /** Autocomplete function
  * @param {string} s search string
  * @param {function} cback a callback function that takes an array to display in the autocomplete field (for asynchronous search)
  * @return {Array|false} an array of search solutions or false if the array is send with the cback argument (asnchronous)
  * @api
  */
  autocomplete(s, cback) {
    cback([]);
    return false;
  }
  /** Draw the list
  * @param {Array} auto an array of search result
  * @private
  */
  drawList_(auto) {
    var self = this;
    var ul = this.element.querySelector("ul.autocomplete");
    ul.innerHTML = "";
    this._list = [];
    if (!auto) {
      var input = this.element.querySelector("input.search");
      var value = input.value;
      if (!value) {
        auto = this.get("history");
      } else {
        return;
      }
      ul.setAttribute("class", "autocomplete history");
    } else {
      ul.setAttribute("class", "autocomplete");
    }
    var li, max = Math.min(self.get("maxItems"), auto.length);
    for (var i = 0; i < max; i++) {
      if (auto[i]) {
        if (!i || !self.equalFeatures(auto[i], auto[i - 1])) {
          li = document.createElement("LI");
          li.setAttribute("data-search", this._list.length);
          this._list.push(auto[i]);
          li.addEventListener("click", function(e) {
            self._handleSelect(self._list[e.currentTarget.getAttribute("data-search")]);
          });
          var title = self.getTitle(auto[i]);
          if (title instanceof Element)
            li.appendChild(title);
          else
            li.innerHTML = title;
          ul.appendChild(li);
        }
      }
    }
    if (max && this.get("copy")) {
      li = document.createElement("LI");
      li.classList.add("copy");
      li.innerHTML = this.get("copy");
      ul.appendChild(li);
    }
  }
  /** Test if 2 features are equal
   * @param {any} f1
   * @param {any} f2
   * @return {boolean}
   */
  equalFeatures() {
    return false;
  }
};
ol_control_Search.prototype._history = {};
var Search_default = ol_control_Search;

// node_modules/ol-ext/util/Ajax.js
var ol_ext_Ajax = class olextAjax extends Object_default {
  constructor(options) {
    options = options || {};
    super();
    this._auth = options.auth;
    this.set("dataType", options.dataType || "JSON");
  }
  /** Helper for get
   * @param {*} options
   *  @param {string} options.url
   *  @param {string} options.auth Authorisation as btoa("username:password");
   *  @param {string} options.dataType The type of data that you're expecting back from the server, default JSON
   *  @param {string} options.success
   *  @param {string} options.error
   *  @param {*} options.options get options
   */
  static get(options) {
    var ajax = new ol_ext_Ajax(options);
    if (options.success)
      ajax.on("success", function(e) {
        options.success(e.response, e);
      });
    if (options.error)
      ajax.on("error", function(e) {
        options.error(e);
      });
    ajax.send(options.url, options.data, options.options);
  }
  /** Helper to get cors header
   * @param {string} url
   * @param {string} callback
   */
  static getCORS(url, callback) {
    var request = new XMLHttpRequest();
    request.open("GET", url, true);
    request.send();
    request.onreadystatechange = function() {
      if (this.readyState == this.HEADERS_RECEIVED) {
        callback(request.getResponseHeader("Access-Control-Allow-Origin"));
      }
    };
  }
  /** Send an ajax request (GET)
   * @fires success
   * @fires error
   * @param {string} url
   * @param {*} data Data to send to the server as key / value
   * @param {*} options a set of options that are returned in the
   *  @param {boolean} options.abort false to prevent aborting the current request, default true
   */
  send(url, data, options) {
    options = options || {};
    var self = this;
    var encode = options.encode !== false;
    if (encode)
      url = encodeURI(url);
    var parameters = "";
    for (var index in data) {
      if (data.hasOwnProperty(index) && data[index] !== void 0) {
        parameters += (parameters ? "&" : "?") + index + "=" + (encode ? encodeURIComponent(data[index]) : data[index]);
      }
    }
    if (this._request && options.abort !== false) {
      this._request.abort();
    }
    var ajax = this._request = new XMLHttpRequest();
    ajax.open("GET", url + parameters, true);
    if (options.timeout)
      ajax.timeout = options.timeout;
    if (this._auth) {
      ajax.setRequestHeader("Authorization", "Basic " + this._auth);
    }
    this.dispatchEvent({ type: "loadstart" });
    ajax.onload = function() {
      self._request = null;
      self.dispatchEvent({ type: "loadend" });
      if (this.status >= 200 && this.status < 400) {
        var response;
        try {
          switch (self.get("dataType")) {
            case "JSON": {
              response = JSON.parse(this.response);
              break;
            }
            default: {
              response = this.response;
            }
          }
        } catch (e) {
          self.dispatchEvent({
            type: "error",
            status: 0,
            statusText: "parsererror",
            error: e,
            options,
            jqXHR: this
          });
          return;
        }
        self.dispatchEvent({
          type: "success",
          response,
          status: this.status,
          statusText: this.statusText,
          options,
          jqXHR: this
        });
      } else {
        self.dispatchEvent({
          type: "error",
          status: this.status,
          statusText: this.statusText,
          options,
          jqXHR: this
        });
      }
    };
    ajax.ontimeout = function() {
      self._request = null;
      self.dispatchEvent({ type: "loadend" });
      self.dispatchEvent({
        type: "error",
        status: this.status,
        statusText: "Timeout",
        options,
        jqXHR: this
      });
    };
    ajax.onerror = function() {
      self._request = null;
      self.dispatchEvent({ type: "loadend" });
      self.dispatchEvent({
        type: "error",
        status: this.status,
        statusText: this.statusText,
        options,
        jqXHR: this
      });
    };
    ajax.send();
  }
};
var Ajax_default = ol_ext_Ajax;

// node_modules/ol-ext/control/SearchJSON.js
var ol_control_SearchJSON = class olcontrolSearchJSON extends Search_default {
  constructor(options) {
    options = options || {};
    options.className = options.className || "JSON";
    delete options.autocomplete;
    options.minLength = options.minLength || 3;
    options.typing = options.typing || 800;
    super(options);
    var url = options.url || "";
    if (window.location.protocol === "https:") {
      var parser = document.createElement("a");
      parser.href = url;
      parser.protocol = window.location.protocol;
      url = parser.href;
    }
    this.set("url", url);
    this._ajax = new Ajax_default({ dataType: "JSON", auth: options.authentication });
    this._ajax.on("success", (function(resp) {
      if (resp.status >= 200 && resp.status < 400) {
        if (typeof this._callback === "function")
          this._callback(resp.response);
      } else {
        if (typeof this._callback === "function")
          this._callback(false, "error");
        console.log("AJAX ERROR", arguments);
      }
    }).bind(this));
    this._ajax.on("error", (function() {
      if (typeof this._callback === "function")
        this._callback(false, "error");
      console.log("AJAX ERROR", arguments);
    }).bind(this));
    this._ajax.on("loadstart", (function() {
      this.element.classList.add("searching");
    }).bind(this));
    this._ajax.on("loadend", (function() {
      this.element.classList.remove("searching");
    }).bind(this));
    if (typeof options.handleResponse === "function")
      this.handleResponse = options.handleResponse;
  }
  /** Send ajax request
   * @param {string} url
   * @param {*} data
   * @param {function} cback a callback function that takes an array of {name, feature} to display in the autocomplete field
   */
  ajax(url, data, cback, options) {
    options = options || {};
    this._callback = cback;
    this._ajax.set("dataType", options.dataType || "JSON");
    this._ajax.send(url, data, options);
  }
  /** Autocomplete function (ajax request to the server)
   * @param {string} s search string
   * @param {function} cback a callback function that takes an array of {name, feature} to display in the autocomplete field
   */
  autocomplete(s, cback) {
    var data = this.requestData(s);
    var url = encodeURI(this.get("url"));
    this.ajax(url, data, function(resp) {
      if (typeof cback === "function")
        cback(this.handleResponse(resp));
    });
  }
  /**
   * @param {string} s the search string
   * @return {Object} request data (as key:value)
   * @api
   */
  requestData(s) {
    return { q: s };
  }
  /**
   * Handle server response to pass the features array to the display list
   * @param {any} response server response
   * @return {Array<any>} an array of feature
   * @api
   */
  handleResponse(response) {
    return response;
  }
};
var SearchJSON_default = ol_control_SearchJSON;

// node_modules/ol-ext/control/SearchNominatim.js
var ol_control_SearchNominatim = class olcontrolSearchNominatim extends SearchJSON_default {
  constructor(options) {
    options = options || {};
    options.className = options.className || "nominatim";
    options.typing = options.typing || -1;
    options.url = options.url || "https://nominatim.openstreetmap.org/search";
    options.copy = '<a href="http://www.openstreetmap.org/copyright" target="new">&copy; OpenStreetMap contributors</a>';
    super(options);
    this.set("polygon", options.polygon);
    this.set("viewbox", options.viewbox);
    this.set("bounded", options.bounded);
  }
  /** Returns the text to be displayed in the menu
   *	@param {ol.Feature} f the feature
  *	@return {string} the text to be displayed in the index
  *	@api
  */
  getTitle(f) {
    var info = [];
    if (f.class)
      info.push(f.class);
    if (f.type)
      info.push(f.type);
    var title = f.display_name + (info.length ? "<i>" + info.join(" - ") + "</i>" : "");
    if (f.icon)
      title = "<img src='" + f.icon + "' />" + title;
    return title;
  }
  /**
   * @param {string} s the search string
   * @return {Object} request data (as key:value)
   * @api
   */
  requestData(s) {
    var data = {
      format: "json",
      addressdetails: 1,
      q: s,
      polygon_geojson: this.get("polygon") ? 1 : 0,
      bounded: this.get("bounded") ? 1 : 0,
      limit: this.get("maxItems")
    };
    if (this.get("viewbox"))
      data.viewbox = this.get("viewbox");
    return data;
  }
  /** A ligne has been clicked in the menu > dispatch event
   *	@param {any} f the feature, as passed in the autocomplete
  *	@api
  */
  select(f) {
    var c = [Number(f.lon), Number(f.lat)];
    try {
      c = transform(c, "EPSG:4326", this.getMap().getView().getProjection());
    } catch (e) {
    }
    this.dispatchEvent({ type: "select", search: f, coordinate: c });
  }
  /** Reverse geocode
   * @param {ol.coordinate} coord
   * @api
   */
  reverseGeocode(coord, cback) {
    var lonlat = transform(coord, this.getMap().getView().getProjection(), "EPSG:4326");
    this.ajax(
      this.get("url").replace("search", "reverse"),
      { lon: lonlat[0], lat: lonlat[1], format: "json" },
      (function(resp) {
        if (cback) {
          cback.call(this, [resp]);
        } else {
          if (resp && !resp.error) {
            this._handleSelect(resp, true);
          }
        }
      }).bind(this)
    );
  }
  /**
   * Handle server response to pass the features array to the display list
   * @param {any} response server response
   * @return {Array<any>} an array of feature
   * @api
   */
  handleResponse(response) {
    return response.results || response;
  }
  /**/
};
var SearchNominatim_default = ol_control_SearchNominatim;
export {
  SearchNominatim_default as default
};
//# sourceMappingURL=ol-ext_control_SearchNominatim.js.map