import {
  ModifyFeature_default
} from "./chunk-YNX27GDF.js";
import {
  ol_coordinate_dist2d,
  ol_coordinate_findSegment,
  ol_coordinate_offsetCoords
} from "./chunk-3UNEODO2.js";
import {
  Draw_default
} from "./chunk-MEQVYVYE.js";
import {
  Select_default
} from "./chunk-6DXBPPKF.js";
import {
  Toggle_default
} from "./chunk-NNBJMTCH.js";
import {
  Button_default
} from "./chunk-VCBXDRBT.js";
import {
  Bar_default
} from "./chunk-NMUIRNIP.js";
import {
  Vector_default as Vector_default2
} from "./chunk-PD2E5XZ4.js";
import {
  element_default
} from "./chunk-S3QBQTEW.js";
import "./chunk-V7WRBSQ6.js";
import "./chunk-W7BDJOQY.js";
import {
  Circle_default,
  LineString_default,
  MultiPolygon_default
} from "./chunk-7JXPN73Q.js";
import {
  Feature_default
} from "./chunk-E53S5GN6.js";
import {
  Vector_default
} from "./chunk-T3TT2KJN.js";
import "./chunk-HM3IY3H4.js";
import "./chunk-JFXZSSOM.js";
import "./chunk-ZUI5NXIU.js";
import "./chunk-I4Q72WOW.js";
import {
  Pointer_default
} from "./chunk-RTVPCGIJ.js";
import {
  Interaction_default
} from "./chunk-MSWSBYBR.js";
import {
  click,
  shiftKeyOnly
} from "./chunk-QCJTGAWF.js";
import "./chunk-CAVOO5JW.js";
import "./chunk-VRTURNK3.js";
import "./chunk-2C73OZ6M.js";
import {
  Collection_default
} from "./chunk-M5TTSD4C.js";
import "./chunk-ZCRXKB7J.js";
import "./chunk-RW3V7S4F.js";
import {
  Circle_default as Circle_default2,
  Fill_default,
  RegularShape_default,
  Stroke_default,
  Style_default
} from "./chunk-PAB2HIXK.js";
import "./chunk-I6K7MRGV.js";
import "./chunk-PGWX4545.js";
import "./chunk-AYBYZSAV.js";
import "./chunk-YLJGUH5Z.js";
import {
  LinearRing_default,
  Point_default,
  Polygon_default,
  fromCircle,
  fromExtent
} from "./chunk-AZGMK675.js";
import "./chunk-BHVDQB66.js";
import "./chunk-6EWLK2BW.js";
import "./chunk-6Y7C6NBJ.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 "./chunk-A3RXLHYB.js";
import "./chunk-ZLPTRF2L.js";
import "./chunk-54BTDBAD.js";
import "./chunk-UPTVWZ45.js";
import "./chunk-5XHD7RSF.js";
import "./chunk-Q5ZULJHM.js";
import {
  unByKey
} from "./chunk-NGFXCWUF.js";
import "./chunk-K25ZO44T.js";
import {
  boundingExtent,
  buffer,
  createEmpty,
  extend,
  getCenter
} from "./chunk-SRXHWJOY.js";
import "./chunk-5RHQVMYD.js";
import "./chunk-DC5AMYBS.js";

// node_modules/ol-ext/control/TextButton.js
var ol_control_TextButton = class olcontrolTextButton extends Button_default {
  constructor(options) {
    options = options || {};
    options.className = (options.className || "") + " ol-text-button";
    super(options);
  }
};
var TextButton_default = ol_control_TextButton;

// node_modules/ol-ext/interaction/Delete.js
var ol_interaction_Delete = class olinteractionDelete extends Select_default {
  constructor(options) {
    super(options);
    this.on("select", (function(e) {
      this.getFeatures().clear();
      this.delete(e.selected);
    }).bind(this));
  }
  /** Get vector source of the map
   * @return {Array<ol.source.Vector>}
   */
  _getSources(layers) {
    if (!this.getMap())
      return [];
    if (!layers)
      layers = this.getMap().getLayers();
    var sources = [];
    layers.forEach((function(l) {
      if (l.getLayers) {
        sources = sources.concat(this._getSources(l.getLayers()));
      } else {
        if (l.getSource && l.getSource() instanceof Vector_default2) {
          sources.push(l.getSource());
        }
      }
    }).bind(this));
    return sources;
  }
  /** Delete features: remove the features from the map (from all layers in the map)
   * @param {ol.Collection<ol.Feature>|Array<ol.Feature>} features The features to delete
   * @api
   */
  delete(features) {
    if (features && (features.length || features.getLength())) {
      this.dispatchEvent({ type: "deletestart", features });
      var delFeatures = [];
      this._getSources().forEach(function(source) {
        try {
          features.forEach(function(f) {
            source.removeFeature(f);
            delFeatures.push(f);
          });
        } catch (e) {
        }
      });
      this.dispatchEvent({ type: "deleteend", features: delFeatures });
    }
  }
};
var Delete_default = ol_interaction_Delete;

// node_modules/ol-ext/style/defaultStyle.js
var ol_style_Style_defaultStyle;
(function() {
  var white = [255, 255, 255, 1];
  var blue = [0, 153, 255, 1];
  var width = 3;
  var defaultEditStyle = [
    new Style_default({
      stroke: new Stroke_default({ color: white, width: width + 2 })
    }),
    new Style_default({
      image: new Circle_default2({
        radius: width * 2,
        fill: new Fill_default({ color: blue }),
        stroke: new Stroke_default({ color: white, width: width / 2 })
      }),
      stroke: new Stroke_default({ color: blue, width }),
      fill: new Fill_default({
        color: [255, 255, 255, 0.5]
      })
    })
  ];
  ol_style_Style_defaultStyle = function(edit) {
    if (edit === true) {
      return defaultEditStyle;
    } else {
      edit = edit || {};
      var fill = new Fill_default({
        color: edit.fillColor || "rgba(255,255,255,0.4)"
      });
      var stroke = new Stroke_default({
        color: edit.color || "#3399CC",
        width: 1.25
      });
      var style = new Style_default({
        image: new Circle_default2({
          fill,
          stroke,
          radius: 5
        }),
        fill,
        stroke
      });
      return [style];
    }
  };
})();
var defaultStyle_default = ol_style_Style_defaultStyle;

// node_modules/ol-ext/interaction/Offset.js
var ol_interaction_Offset = class olinteractionOffset extends Pointer_default {
  constructor(options) {
    options = options || {};
    super({
      handleDownEvent: function(e) {
        return self.handleDownEvent_(e);
      },
      handleDragEvent: function(e) {
        return self.handleDragEvent_(e);
      },
      handleMoveEvent: function(e) {
        return self.handleMoveEvent_(e);
      },
      handleUpEvent: function(e) {
        return self.handleUpEvent_(e);
      }
    });
    var self = this;
    this._filter = options.filter;
    this.features_ = options.features;
    this.layers_ = options.layers ? options.layers instanceof Array ? options.layers : [options.layers] : null;
    this.set("duplicate", options.duplicate);
    this.source_ = options.source;
    this._style = typeof options.style === "function" ? options.style : function() {
      if (options.style)
        return options.style;
      else
        return defaultStyle_default(true);
    };
    this.previousCursor_ = false;
  }
  /** Get Feature at pixel
   * @param {ol.MapBrowserEvent} evt Map browser event.
   * @return {any} a feature and the hit point
   * @private
   */
  getFeatureAtPixel_(e) {
    var self = this;
    return this.getMap().forEachFeatureAtPixel(
      e.pixel,
      function(feature, layer) {
        var current;
        if (self._filter && !self._filter(feature, layer))
          return false;
        if (self.layers_) {
          for (var i = 0; i < self.layers_.length; i++) {
            if (self.layers_[i] === layer) {
              current = feature;
              break;
            }
          }
        } else if (self.features_) {
          self.features_.forEach(function(f) {
            if (f === feature) {
              current = feature;
            }
          });
        } else {
          current = feature;
        }
        var typeGeom = current.getGeometry().getType();
        if (current && /Polygon|LineString/.test(typeGeom)) {
          if (typeGeom === "Polygon" && current.getGeometry().getCoordinates().length > 1)
            return false;
          var p = current.getGeometry().getClosestPoint(e.coordinate);
          var dx = p[0] - e.coordinate[0];
          var dy = p[1] - e.coordinate[1];
          var d = Math.sqrt(dx * dx + dy * dy) / e.frameState.viewState.resolution;
          if (d < 5) {
            return {
              feature: current,
              hit: p,
              coordinates: current.getGeometry().getCoordinates(),
              geom: current.getGeometry().clone(),
              geomType: typeGeom
            };
          } else {
            return false;
          }
        } else {
          return false;
        }
      },
      { hitTolerance: 5 }
    );
  }
  /**
   * @param {ol.MapBrowserEvent} e Map browser event.
   * @return {boolean} `true` to start the drag sequence.
   * @private
   */
  handleDownEvent_(e) {
    this.current_ = this.getFeatureAtPixel_(e);
    if (this.current_) {
      this.currentStyle_ = this.current_.feature.getStyle();
      if (this.source_ && (this.get("duplicate") || e.originalEvent.ctrlKey)) {
        this.current_.feature = this.current_.feature.clone();
        this.current_.feature.setStyle(this._style(this.current_.feature));
        this.source_.addFeature(this.current_.feature);
      } else {
        this.current_.feature.setStyle(this._style(this.current_.feature));
        this._modifystart = true;
      }
      this.dispatchEvent({ type: "offsetstart", feature: this.current_.feature, offset: 0 });
      return true;
    } else {
      return false;
    }
  }
  /**
   * @param {ol.MapBrowserEvent} e Map browser event.
   * @private
   */
  handleDragEvent_(e) {
    if (this._modifystart) {
      this.dispatchEvent({ type: "modifystart", features: [this.current_.feature] });
      this._modifystart = false;
    }
    var p = this.current_.geom.getClosestPoint(e.coordinate);
    var d = ol_coordinate_dist2d(p, e.coordinate);
    var seg, v1, v2, offset;
    switch (this.current_.geomType) {
      case "Polygon": {
        seg = ol_coordinate_findSegment(p, this.current_.coordinates[0]).segment;
        if (seg) {
          v1 = [seg[1][0] - seg[0][0], seg[1][1] - seg[0][1]];
          v2 = [e.coordinate[0] - p[0], e.coordinate[1] - p[1]];
          if (v1[0] * v2[1] - v1[1] * v2[0] > 0) {
            d = -d;
          }
          offset = [];
          for (var i = 0; i < this.current_.coordinates.length; i++) {
            offset.push(ol_coordinate_offsetCoords(this.current_.coordinates[i], i == 0 ? d : -d));
          }
          this.current_.feature.setGeometry(new Polygon_default(offset));
        }
        break;
      }
      case "LineString": {
        seg = ol_coordinate_findSegment(p, this.current_.coordinates).segment;
        if (seg) {
          v1 = [seg[1][0] - seg[0][0], seg[1][1] - seg[0][1]];
          v2 = [e.coordinate[0] - p[0], e.coordinate[1] - p[1]];
          if (v1[0] * v2[1] - v1[1] * v2[0] > 0) {
            d = -d;
          }
          offset = ol_coordinate_offsetCoords(this.current_.coordinates, d);
          this.current_.feature.setGeometry(new LineString_default(offset));
        }
        break;
      }
      default: {
        break;
      }
    }
    this.dispatchEvent({ type: "offsetting", feature: this.current_.feature, offset: d, segment: [p, e.coordinate], coordinate: e.coordinate });
  }
  /**
   * @param {ol.MapBrowserEvent} e Map browser event.
   * @private
   */
  handleUpEvent_(e) {
    if (!this._modifystart) {
      this.dispatchEvent({ type: "offsetend", feature: this.current_.feature, coordinate: e.coordinate });
    }
    this.current_.feature.setStyle(this.currentStyle_);
    this.current_ = false;
  }
  /**
   * @param {ol.MapBrowserEvent} e Event.
   * @private
   */
  handleMoveEvent_(e) {
    var f = this.getFeatureAtPixel_(e);
    if (f) {
      if (this.previousCursor_ === false) {
        this.previousCursor_ = e.map.getTargetElement().style.cursor;
      }
      element_default.setCursor(e.map, "pointer");
    } else {
      element_default.setCursor(e.map, this.previousCursor_);
      this.previousCursor_ = false;
    }
  }
};
var Offset_default = ol_interaction_Offset;

// node_modules/ol-ext/interaction/Split.js
var ol_interaction_Split = class olinteractionSplit extends Interaction_default {
  constructor(options) {
    if (!options)
      options = {};
    super({
      handleEvent: function(e) {
        switch (e.type) {
          case "singleclick":
            return this.handleDownEvent(e);
          case "pointermove":
            return this.handleMoveEvent(e);
          default:
            return true;
        }
      }
    });
    this.snapDistance_ = options.snapDistance || 25;
    this.tolerance_ = options.tolerance || 1e-10;
    this.cursor_ = options.cursor;
    this.setSources(options.sources);
    if (options.features) {
      if (!this.sources_) this.sources_ = [];
      this.sources_.push(new Vector_default2({ features: options.features }));
    }
    this.filterSplit_ = options.filter || function() {
      return true;
    };
    var white = [255, 255, 255, 1];
    var blue = [0, 153, 255, 1];
    var width = 3;
    var fill = new Fill_default({ color: "rgba(255,255,255,0.4)" });
    var stroke = new Stroke_default({
      color: "#3399CC",
      width: 1.25
    });
    var sketchStyle = [
      new Style_default({
        image: new Circle_default2({
          fill,
          stroke,
          radius: 5
        }),
        fill,
        stroke
      })
    ];
    var featureStyle = [
      new Style_default({
        stroke: new Stroke_default({
          color: white,
          width: width + 2
        })
      }),
      new Style_default({
        image: new Circle_default2({
          radius: 2 * width,
          fill: new Fill_default({
            color: blue
          }),
          stroke: new Stroke_default({
            color: white,
            width: width / 2
          })
        }),
        stroke: new Stroke_default({
          color: blue,
          width
        })
      })
    ];
    if (options.sketchStyle)
      sketchStyle = options.sketchStyle instanceof Array ? options.sketchStyle : [options.sketchStyle];
    if (options.featureStyle)
      featureStyle = options.featureStyle instanceof Array ? options.featureStyle : [options.featureStyle];
    this.overlayLayer_ = new Vector_default({
      source: new Vector_default2({
        useSpatialIndex: false
      }),
      name: "Split overlay",
      displayInLayerSwitcher: false,
      style: function(f) {
        if (f._sketch_)
          return sketchStyle;
        else
          return featureStyle;
      }
    });
  }
  /**
   * Remove the interaction from its current map, if any,  and attach it to a new
   * map, if any. Pass `null` to just remove the interaction from the current map.
   * @param {ol.Map} map Map.
   * @api stable
   */
  setMap(map) {
    if (this.getMap()) {
      this.getMap().removeLayer(this.overlayLayer_);
    }
    super.setMap(map);
    this.overlayLayer_.setMap(map);
  }
  /** Get sources to split features in
   * @return {Array<ol.source.Vector>}
   */
  getSources() {
    if (!this.sources_ && this.getMap()) {
      var sources = [];
      var getSources = function(layers) {
        layers.forEach(function(layer) {
          if (layer.getVisible()) {
            if (layer.getSource && layer.getSource() instanceof Vector_default2) {
              sources.unshift(layer.getSource());
            } else if (layer.getLayers) {
              getSources(layer.getLayers());
            }
          }
        });
      };
      getSources(this.getMap().getLayers());
      return sources;
    }
    return this.sources_ || [];
  }
  /** Set sources to split features in
   * @param {ol.source.Vector|Array<ol.source.Vector>|boolean} [sources] if not defined get all map vector sources
   */
  setSources(sources) {
    this.sources_ = sources ? sources instanceof Array ? sources || false : [sources] : false;
  }
  /** Get closest feature at pixel
   * @param {ol.Pixel}
   * @return {ol.feature}
   * @private
   */
  getClosestFeature(e) {
    var source, f, c, g, d = this.snapDistance_ + 1;
    this.getSources().forEach(function(si) {
      var fi = si.getClosestFeatureToCoordinate(e.coordinate);
      if (fi && fi.getGeometry().splitAt) {
        var ci = fi.getGeometry().getClosestPoint(e.coordinate);
        var gi = new LineString_default([e.coordinate, ci]);
        var di = gi.getLength() / e.frameState.viewState.resolution;
        if (di < d) {
          source = si;
          d = di;
          f = fi;
          g = gi;
          c = ci;
        }
      }
    });
    if (d > this.snapDistance_) {
      return false;
    } else {
      var coord = this.getNearestCoord(c, f.getGeometry().getCoordinates());
      var p = this.getMap().getPixelFromCoordinate(coord);
      if (ol_coordinate_dist2d(e.pixel, p) < this.snapDistance_) {
        c = coord;
      }
      return { source, feature: f, coord: c, link: g };
    }
  }
  /** Get nearest coordinate in a list
  * @param {ol.coordinate} pt the point to find nearest
  * @param {Array<ol.coordinate>} coords list of coordinates
  * @return {ol.coordinate} the nearest coordinate in the list
  */
  getNearestCoord(pt, coords) {
    var d, dm = Number.MAX_VALUE, p0;
    for (var i = 0; i < coords.length; i++) {
      d = ol_coordinate_dist2d(pt, coords[i]);
      if (d < dm) {
        dm = d;
        p0 = coords[i];
      }
    }
    return p0;
  }
  /**
   * @param {ol.MapBrowserEvent} evt Map browser event.
   * @return {boolean} `true` to start the drag sequence.
   */
  handleDownEvent(evt) {
    var current = this.getClosestFeature(evt);
    if (current) {
      var self = this;
      self.overlayLayer_.getSource().clear();
      var split = current.feature.getGeometry().splitAt(current.coord, this.tolerance_);
      var i;
      if (split.length > 1) {
        var tosplit = [];
        for (i = 0; i < split.length; i++) {
          var f = current.feature.clone();
          f.setGeometry(split[i]);
          tosplit.push(f);
        }
        self.dispatchEvent({ type: "beforesplit", original: current.feature, features: tosplit });
        current.source.dispatchEvent({ type: "beforesplit", original: current.feature, features: tosplit });
        current.source.removeFeature(current.feature);
        for (i = 0; i < tosplit.length; i++) {
          current.source.addFeature(tosplit[i]);
        }
        self.dispatchEvent({ type: "aftersplit", original: current.feature, features: tosplit });
        current.source.dispatchEvent({ type: "aftersplit", original: current.feature, features: tosplit });
      }
    }
    return false;
  }
  /**
   * @param {ol.MapBrowserEvent} evt Event.
   */
  handleMoveEvent(e) {
    var map = e.map;
    this.overlayLayer_.getSource().clear();
    var current = this.getClosestFeature(e);
    if (current && this.filterSplit_(current.feature)) {
      var p, l;
      this.overlayLayer_.getSource().addFeature(current.feature);
      p = new Feature_default(new Point_default(current.coord));
      p._sketch_ = true;
      this.overlayLayer_.getSource().addFeature(p);
      l = new Feature_default(current.link);
      l._sketch_ = true;
      this.overlayLayer_.getSource().addFeature(l);
      this.dispatchEvent({
        type: "pointermove",
        coordinate: e.coordinate,
        frameState: e.frameState,
        originalEvent: e.originalEvent,
        map: e.map,
        pixel: e.pixel,
        feature: current.feature,
        linkGeometry: current.link
      });
    } else {
      this.dispatchEvent(e);
    }
    var element = map.getTargetElement();
    if (this.cursor_) {
      if (current) {
        if (element.style.cursor != this.cursor_) {
          this.previousCursor_ = element.style.cursor;
          element_default.setCursor(element, this.cursor_);
        }
      } else if (this.previousCursor_ !== void 0) {
        element_default.setCursor(element, this.previousCursor_);
        this.previousCursor_ = void 0;
      }
    }
  }
};
var Split_default = ol_interaction_Split;

// node_modules/ol-ext/interaction/Transform.js
var ol_interaction_Transform = class olinteractionTransform extends Pointer_default {
  constructor(options) {
    options = options || {};
    super({
      handleDownEvent: function(e) {
        return self.handleDownEvent_(e);
      },
      handleDragEvent: function(e) {
        return this.handleDragEvent_(e);
      },
      handleMoveEvent: function(e) {
        return this.handleMoveEvent_(e);
      },
      handleUpEvent: function(e) {
        return this.handleUpEvent_(e);
      }
    });
    var self = this;
    this.selection_ = new Collection_default();
    this.handles_ = new Collection_default();
    this.overlayLayer_ = new Vector_default({
      source: new Vector_default2({
        features: this.handles_,
        useSpatialIndex: false,
        wrapX: false
        // For vector editing across the -180° and 180° meridians to work properly, this should be set to false
      }),
      name: "Transform overlay",
      displayInLayerSwitcher: false,
      // Return the style according to the handle type
      style: function(feature) {
        return self.style[(feature.get("handle") || "default") + (feature.get("constraint") || "") + (feature.get("option") || "")];
      },
      updateWhileAnimating: true,
      updateWhileInteracting: true
    });
    this.features_ = options.features;
    if (typeof options.filter === "function")
      this._filter = options.filter;
    this.layers_ = options.layers ? options.layers instanceof Array ? options.layers : [options.layers] : null;
    this._handleEvent = options.condition || function() {
      return true;
    };
    this.addFn_ = options.addCondition || function() {
      return false;
    };
    this.setPointRadius(options.pointRadius);
    this.set("translateFeature", options.translateFeature !== false);
    this.set("translate", options.translate !== false);
    this.set("translateBBox", options.translateBBox === true);
    this.set("stretch", options.stretch !== false);
    this.set("scale", options.scale !== false);
    this.set("rotate", options.rotate !== false);
    this.set("keepAspectRatio", options.keepAspectRatio || function(e) {
      return e.originalEvent.shiftKey;
    });
    this.set("modifyCenter", options.modifyCenter || function(e) {
      return e.originalEvent.metaKey || e.originalEvent.ctrlKey;
    });
    this.set("noFlip", options.noFlip || false);
    this.set("selection", options.selection !== false);
    this.set("hitTolerance", options.hitTolerance || 0);
    this.set("enableRotatedTransform", options.enableRotatedTransform || false);
    this.set("keepRectangle", options.keepRectangle || false);
    this.set("buffer", options.buffer || 0);
    this.on("propertychange", function() {
      this.drawSketch_();
    });
    this.setDefaultStyle();
    if (options.select) {
      this.on("change:active", (function(e) {
        if (this.getActive()) {
          this.setSelection(options.select.getFeatures().getArray());
        } else {
          options.select.getFeatures().extend(this.selection_);
          this.selection_.forEach(function(f) {
            options.select.getFeatures().push(f);
          });
          this.select(null);
        }
      }).bind(this));
    } else {
      this.on("change:active", (function(e) {
        this.select(null);
      }).bind(this));
    }
  }
  /**
   * Remove the interaction from its current map, if any,  and attach it to a new
   * map, if any. Pass `null` to just remove the interaction from the current map.
   * @param {ol.Map} map Map.
   * @api stable
   */
  setMap(map) {
    var oldMap = this.getMap();
    if (oldMap) {
      oldMap.removeLayer(this.overlayLayer_);
      if (this.previousCursor_) {
        element_default.setCursor(oldMap, this.previousCursor_);
      }
      this.previousCursor_ = void 0;
    }
    super.setMap(map);
    this.overlayLayer_.setMap(map);
    if (map === null) {
      this.select(null);
    }
    if (map !== null) {
      this.isTouch = /touch/.test(map.getViewport().className);
      this.setDefaultStyle();
    }
  }
  /**
   * Activate/deactivate interaction
   * @param {bool}
   * @api stable
   */
  setActive(b) {
    if (this.overlayLayer_) this.overlayLayer_.setVisible(b);
    super.setActive(b);
  }
  /** Set default sketch style
   * @param {Object} [options]
   *  @param {ol_style_Stroke} [stroke] stroke style for selection rectangle, default red dash
   *  @param {ol_style_Fill} [fill] fill style for selection rectangle, default red
   *  @param {ol_style_Stroke} [pointStroke] stroke style for handles, default red
   *  @param {ol_style_Fill} [pointFill] fill style for handles, default white
   */
  setDefaultStyle(options) {
    options = options || {};
    var stroke = options.pointStroke || new Stroke_default({ color: [255, 0, 0, 1], width: 1 });
    var strokedash = options.stroke || new Stroke_default({ color: [255, 0, 0, 1], width: 1, lineDash: [4, 4] });
    var fill0 = options.fill || new Fill_default({ color: [255, 0, 0, 0.01] });
    var fill = options.pointFill || new Fill_default({ color: [255, 255, 255, 0.8] });
    var circle = new RegularShape_default({
      fill,
      stroke,
      radius: this.isTouch ? 12 : 6,
      displacement: this.isTouch ? [24, -24] : [12, -12],
      points: 15
    });
    if (!circle.setDisplacement)
      circle.getAnchor()[0] = this.isTouch ? -10 : -5;
    var bigpt = new RegularShape_default({
      fill,
      stroke,
      radius: this.isTouch ? 16 : 8,
      points: 4,
      angle: Math.PI / 4
    });
    var smallpt = new RegularShape_default({
      fill,
      stroke,
      radius: this.isTouch ? 12 : 6,
      points: 4,
      angle: Math.PI / 4
    });
    function createStyle(img, stroke2, fill2) {
      return [new Style_default({ image: img, stroke: stroke2, fill: fill2 })];
    }
    this.style = {
      "default": createStyle(bigpt, strokedash, fill0),
      "translate": createStyle(bigpt, stroke, fill),
      "rotate": createStyle(circle, stroke, fill),
      "rotate0": createStyle(bigpt, stroke, fill),
      "scale": createStyle(bigpt, stroke, fill),
      "scale1": createStyle(bigpt, stroke, fill),
      "scale2": createStyle(bigpt, stroke, fill),
      "scale3": createStyle(bigpt, stroke, fill),
      "scalev": createStyle(smallpt, stroke, fill),
      "scaleh1": createStyle(smallpt, stroke, fill),
      "scalev2": createStyle(smallpt, stroke, fill),
      "scaleh3": createStyle(smallpt, stroke, fill)
    };
    this.drawSketch_();
  }
  /**
   * Set sketch style.
   * @param {style} style Style name: 'default','translate','rotate','rotate0','scale','scale1','scale2','scale3','scalev','scaleh1','scalev2','scaleh3'
   * @param {ol.style.Style|Array<ol.style.Style>} olstyle
   * @api stable
   */
  setStyle(style, olstyle) {
    if (!olstyle)
      return;
    if (olstyle instanceof Array)
      this.style[style] = olstyle;
    else
      this.style[style] = [olstyle];
    for (var i = 0; i < this.style[style].length; i++) {
      var im = this.style[style][i].getImage();
      if (im) {
        if (style == "rotate") {
          im.getAnchor()[0] = -5;
        }
        if (this.isTouch)
          im.setScale(1.8);
      }
      var tx = this.style[style][i].getText();
      if (tx) {
        if (style == "rotate")
          tx.setOffsetX(this.isTouch ? 14 : 7);
        if (this.isTouch)
          tx.setScale(1.8);
      }
    }
    this.drawSketch_();
  }
  /** Get Feature at pixel
   * @param {ol.Pixel}
   * @return {ol.feature}
   * @private
   */
  getFeatureAtPixel_(pixel) {
    var self = this;
    return this.getMap().forEachFeatureAtPixel(
      pixel,
      function(feature, layer) {
        var found = false;
        if (!layer) {
          if (feature === self.bbox_) {
            if (self.get("translateBBox")) {
              return { feature, handle: "translate", constraint: "", option: "" };
            } else {
              return false;
            }
          }
          self.handles_.forEach(function(f) {
            if (f === feature)
              found = true;
          });
          if (found)
            return { feature, handle: feature.get("handle"), constraint: feature.get("constraint"), option: feature.get("option") };
        }
        if (!self.get("selection")) {
          if (self.selection_.getArray().some(function(f) {
            return feature === f;
          })) {
            return { feature };
          }
          return null;
        }
        if (self._filter) {
          if (self._filter(feature, layer))
            return { feature };
          else
            return null;
        } else if (self.layers_) {
          for (var i = 0; i < self.layers_.length; i++) {
            if (self.layers_[i] === layer)
              return { feature };
          }
          return null;
        } else if (self.features_) {
          self.features_.forEach(function(f) {
            if (f === feature)
              found = true;
          });
          if (found)
            return { feature };
          else
            return null;
        } else
          return { feature };
      },
      { hitTolerance: this.get("hitTolerance") }
    ) || {};
  }
  /** Rotate feature from map view rotation
   * @param {ol.Feature} f the feature
   * @param {boolean} clone clone resulting geom
   * @param {ol.geom.Geometry} rotated geometry
   */
  getGeometryRotateToZero_(f, clone) {
    var origGeom = f.getGeometry();
    var viewRotation = this.getMap().getView().getRotation();
    if (viewRotation === 0 || !this.get("enableRotatedTransform")) {
      return clone ? origGeom.clone() : origGeom;
    }
    var rotGeom = origGeom.clone();
    rotGeom.rotate(viewRotation * -1, this.getMap().getView().getCenter());
    return rotGeom;
  }
  /** Test if rectangle
   * @param {ol.Geometry} geom
   * @returns {boolean}
   * @private
   */
  _isRectangle(geom) {
    if (this.get("keepRectangle") && geom.getType() === "Polygon") {
      var coords = geom.getCoordinates()[0];
      return coords.length === 5;
    }
    return false;
  }
  /** Draw transform sketch
  * @param {boolean} draw only the center
  */
  drawSketch_(center) {
    var i, f, geom;
    var keepRectangle = this.selection_.item(0) && this._isRectangle(this.selection_.item(0).getGeometry());
    this.overlayLayer_.getSource().clear();
    if (!this.selection_.getLength())
      return;
    var viewRotation = this.getMap().getView().getRotation();
    var ext = this.getGeometryRotateToZero_(this.selection_.item(0)).getExtent();
    var coords;
    if (keepRectangle) {
      coords = this.getGeometryRotateToZero_(this.selection_.item(0)).getCoordinates()[0].slice(0, 4);
      coords.unshift(coords[3]);
    }
    ext = buffer(ext, this.get("buffer"));
    this.selection_.forEach((function(f2) {
      var extendExt = this.getGeometryRotateToZero_(f2).getExtent();
      extend(ext, extendExt);
    }).bind(this));
    var ptRadius = this.selection_.getLength() === 1 ? this._pointRadius(this.selection_.item(0)) : 0;
    if (ptRadius && !(ptRadius instanceof Array))
      ptRadius = [ptRadius, ptRadius];
    if (center === true) {
      if (!this.ispt_) {
        this.overlayLayer_.getSource().addFeature(new Feature_default({ geometry: new Point_default(this.center_), handle: "rotate0" }));
        geom = fromExtent(ext);
        if (this.get("enableRotatedTransform") && viewRotation !== 0) {
          geom.rotate(viewRotation, this.getMap().getView().getCenter());
        }
        f = this.bbox_ = new Feature_default(geom);
        this.overlayLayer_.getSource().addFeature(f);
      }
    } else {
      if (this.ispt_) {
        var p = this.getMap().getPixelFromCoordinate(getCenter(ext));
        if (p) {
          var dx = ptRadius ? ptRadius[0] || 10 : 10;
          var dy = ptRadius ? ptRadius[1] || 10 : 10;
          ext = boundingExtent([
            this.getMap().getCoordinateFromPixel([p[0] - dx, p[1] - dy]),
            this.getMap().getCoordinateFromPixel([p[0] + dx, p[1] + dy])
          ]);
        }
      }
      geom = keepRectangle ? new Polygon_default([coords]) : fromExtent(ext);
      if (this.get("enableRotatedTransform") && viewRotation !== 0) {
        geom.rotate(viewRotation, this.getMap().getView().getCenter());
      }
      f = this.bbox_ = new Feature_default(geom);
      var features = [];
      var g = geom.getCoordinates()[0];
      if (!this.ispt_ || ptRadius) {
        features.push(f);
        if (!this.iscircle_ && !this.ispt_ && this.get("stretch") && this.get("scale"))
          for (i = 0; i < g.length - 1; i++) {
            f = new Feature_default({ geometry: new Point_default([(g[i][0] + g[i + 1][0]) / 2, (g[i][1] + g[i + 1][1]) / 2]), handle: "scale", constraint: i % 2 ? "h" : "v", option: i });
            features.push(f);
          }
        if (this.get("scale"))
          for (i = 0; i < g.length - 1; i++) {
            f = new Feature_default({ geometry: new Point_default(g[i]), handle: "scale", option: i });
            features.push(f);
          }
        if (this.get("translate") && !this.get("translateFeature")) {
          f = new Feature_default({ geometry: new Point_default([(g[0][0] + g[2][0]) / 2, (g[0][1] + g[2][1]) / 2]), handle: "translate" });
          features.push(f);
        }
      }
      if (!this.iscircle_ && this.get("rotate")) {
        f = new Feature_default({ geometry: new Point_default(g[3]), handle: "rotate" });
        features.push(f);
      }
      this.overlayLayer_.getSource().addFeatures(features);
    }
  }
  /** Select a feature to transform
  * @param {ol.Feature} feature the feature to transform
  * @param {boolean} add true to add the feature to the selection, default false
  */
  select(feature, add) {
    if (!feature) {
      if (this.selection_) {
        this.selection_.clear();
        this.drawSketch_();
      }
      return;
    }
    if (!feature.getGeometry || !feature.getGeometry()) return;
    if (add) {
      this.selection_.push(feature);
    } else {
      var index = this.selection_.getArray().indexOf(feature);
      this.selection_.removeAt(index);
    }
    this.ispt_ = this.selection_.getLength() === 1 ? this.selection_.item(0).getGeometry().getType() == "Point" : false;
    this.iscircle_ = this.selection_.getLength() === 1 ? this.selection_.item(0).getGeometry().getType() == "Circle" : false;
    this.drawSketch_();
    this.watchFeatures_();
    this.dispatchEvent({ type: "select", feature, features: this.selection_ });
  }
  /** Update the selection collection.
  * @param {ol.Collection<ol.Feature>} features the features to transform
  */
  setSelection(features) {
    this.selection_.clear();
    features.forEach((function(feature) {
      this.selection_.push(feature);
    }).bind(this));
    this.ispt_ = this.selection_.getLength() === 1 ? this.selection_.item(0).getGeometry().getType() == "Point" : false;
    this.iscircle_ = this.selection_.getLength() === 1 ? this.selection_.item(0).getGeometry().getType() == "Circle" : false;
    this.drawSketch_();
    this.watchFeatures_();
    this.dispatchEvent({ type: "select", features: this.selection_ });
  }
  /** Watch selected features
   * @private
   */
  watchFeatures_() {
    if (this._featureListeners) {
      this._featureListeners.forEach(function(l) {
        unByKey(l);
      });
    }
    this._featureListeners = [];
    this.selection_.forEach((function(f) {
      this._featureListeners.push(
        f.on("change", (function() {
          if (!this.isUpdating_) {
            this.drawSketch_();
          }
        }).bind(this))
      );
    }).bind(this));
  }
  /**
   * @param {ol.MapBrowserEvent} evt Map browser event.
   * @return {boolean} `true` to start the drag sequence.
   * @private
   */
  handleDownEvent_(evt) {
    if (!this._handleEvent(evt, this.selection_))
      return;
    var sel = this.getFeatureAtPixel_(evt.pixel);
    var feature = sel.feature;
    if (this.selection_.getLength() && this.selection_.getArray().indexOf(feature) >= 0 && (this.ispt_ && this.get("translate") || this.get("translateFeature"))) {
      sel.handle = "translate";
    }
    if (sel.handle) {
      this.mode_ = sel.handle;
      this.opt_ = sel.option;
      this.constraint_ = sel.constraint;
      var viewRotation = this.getMap().getView().getRotation();
      this.coordinate_ = feature.get("handle") ? feature.getGeometry().getCoordinates() : evt.coordinate;
      this.pixel_ = this.getMap().getCoordinateFromPixel(this.coordinate_);
      this.geoms_ = [];
      this.rotatedGeoms_ = [];
      var extent = createEmpty();
      var rotExtent = createEmpty();
      this.hasChanged_ = false;
      for (var i = 0, f; f = this.selection_.item(i); i++) {
        this.geoms_.push(f.getGeometry().clone());
        extent = extend(extent, f.getGeometry().getExtent());
        if (this.get("enableRotatedTransform") && viewRotation !== 0) {
          var rotGeom = this.getGeometryRotateToZero_(f, true);
          this.rotatedGeoms_.push(rotGeom);
          rotExtent = extend(rotExtent, rotGeom.getExtent());
        }
      }
      this.extent_ = fromExtent(extent).getCoordinates()[0];
      if (this.get("enableRotatedTransform") && viewRotation !== 0) {
        this.rotatedExtent_ = fromExtent(rotExtent).getCoordinates()[0];
      }
      if (this.mode_ === "rotate") {
        this.center_ = this.getCenter() || getCenter(extent);
        var element = evt.map.getTargetElement();
        element_default.setCursor(element, this.Cursors.rotate0);
        this.previousCursor_ = element.style.cursor;
      } else {
        this.center_ = getCenter(extent);
      }
      this.angle_ = Math.atan2(this.center_[1] - evt.coordinate[1], this.center_[0] - evt.coordinate[0]);
      this.dispatchEvent({
        type: this.mode_ + "start",
        feature: this.selection_.item(0),
        features: this.selection_,
        pixel: evt.pixel,
        coordinate: evt.coordinate
      });
      return true;
    } else if (this.get("selection")) {
      if (feature) {
        if (!this.addFn_(evt))
          this.selection_.clear();
        var index = this.selection_.getArray().indexOf(feature);
        if (index < 0)
          this.selection_.push(feature);
        else
          this.selection_.removeAt(index);
      } else {
        this.selection_.clear();
      }
      this.ispt_ = this.selection_.getLength() === 1 ? this.selection_.item(0).getGeometry().getType() == "Point" : false;
      this.iscircle_ = this.selection_.getLength() === 1 ? this.selection_.item(0).getGeometry().getType() == "Circle" : false;
      this.drawSketch_();
      this.watchFeatures_();
      this.dispatchEvent({ type: "select", feature, features: this.selection_, pixel: evt.pixel, coordinate: evt.coordinate });
      return false;
    }
  }
  /**
   * Get the rotation center
   * @return {ol.coordinate|undefined}
   */
  getCenter() {
    return this.get("center");
  }
  /**
   * Set the rotation center
   * @param {ol.coordinate|undefined} c the center point, default center on the objet
   */
  setCenter(c) {
    return this.set("center", c);
  }
  /**
   * @param {ol.MapBrowserEvent} evt Map browser event.
   * @private
   */
  handleDragEvent_(evt) {
    if (!this._handleEvent(evt, this.features_))
      return;
    var viewRotation = this.getMap().getView().getRotation();
    var i, j, f, geometry;
    var pt0 = [this.coordinate_[0], this.coordinate_[1]];
    var pt = [evt.coordinate[0], evt.coordinate[1]];
    this.isUpdating_ = true;
    this.hasChanged_ = true;
    switch (this.mode_) {
      case "rotate": {
        var a = Math.atan2(this.center_[1] - pt[1], this.center_[0] - pt[0]);
        if (!this.ispt) {
          for (i = 0, f; f = this.selection_.item(i); i++) {
            geometry = this.geoms_[i].clone();
            geometry.rotate(a - this.angle_, this.center_);
            if (geometry.getType() == "Circle")
              geometry.setCenterAndRadius(geometry.getCenter(), geometry.getRadius());
            f.setGeometry(geometry);
          }
        }
        this.drawSketch_(true);
        this.dispatchEvent({
          type: "rotating",
          feature: this.selection_.item(0),
          features: this.selection_,
          angle: a - this.angle_,
          pixel: evt.pixel,
          coordinate: evt.coordinate
        });
        break;
      }
      case "translate": {
        var deltaX = pt[0] - pt0[0];
        var deltaY = pt[1] - pt0[1];
        for (i = 0, f; f = this.selection_.item(i); i++) {
          f.getGeometry().translate(deltaX, deltaY);
        }
        this.handles_.forEach(function(f2) {
          f2.getGeometry().translate(deltaX, deltaY);
        });
        this.coordinate_ = evt.coordinate;
        this.dispatchEvent({
          type: "translating",
          feature: this.selection_.item(0),
          features: this.selection_,
          delta: [deltaX, deltaY],
          pixel: evt.pixel,
          coordinate: evt.coordinate
        });
        break;
      }
      case "scale": {
        var center = this.center_;
        if (this.get("modifyCenter")(evt)) {
          var extentCoordinates = this.extent_;
          if (this.get("enableRotatedTransform") && viewRotation !== 0) {
            extentCoordinates = this.rotatedExtent_;
          }
          center = extentCoordinates[(Number(this.opt_) + 2) % 4];
        }
        var keepRectangle = this.geoms_.length == 1 && this._isRectangle(this.geoms_[0]);
        var stretch = this.constraint_;
        var opt = this.opt_;
        var downCoordinate = this.coordinate_;
        var dragCoordinate = evt.coordinate;
        if (this.get("enableRotatedTransform") && viewRotation !== 0) {
          var downPoint = new Point_default(this.coordinate_);
          downPoint.rotate(viewRotation * -1, center);
          downCoordinate = downPoint.getCoordinates();
          var dragPoint = new Point_default(evt.coordinate);
          dragPoint.rotate(viewRotation * -1, center);
          dragCoordinate = dragPoint.getCoordinates();
        }
        var scx = (dragCoordinate[0] - center[0]) / (downCoordinate[0] - center[0]);
        var scy = (dragCoordinate[1] - center[1]) / (downCoordinate[1] - center[1]);
        var displacementVector = [dragCoordinate[0] - downCoordinate[0], dragCoordinate[1] - downCoordinate[1]];
        if (this.get("enableRotatedTransform") && viewRotation !== 0) {
          var centerPoint = new Point_default(center);
          centerPoint.rotate(viewRotation * -1, this.getMap().getView().getCenter());
          center = centerPoint.getCoordinates();
        }
        if (this.get("noFlip")) {
          if (scx < 0)
            scx = -scx;
          if (scy < 0)
            scy = -scy;
        }
        if (this.constraint_) {
          if (this.constraint_ == "h")
            scx = 1;
          else
            scy = 1;
        } else {
          if (this.get("keepAspectRatio")(evt)) {
            scx = scy = Math.min(scx, scy);
          }
        }
        for (i = 0, f; f = this.selection_.item(i); i++) {
          geometry = viewRotation === 0 || !this.get("enableRotatedTransform") ? this.geoms_[i].clone() : this.rotatedGeoms_[i].clone();
          geometry.applyTransform((function(g1, g2, dim) {
            if (dim < 2) return g2;
            if (!keepRectangle) {
              for (j = 0; j < g1.length; j += dim) {
                if (scx != 1)
                  g2[j] = center[0] + (g1[j] - center[0]) * scx;
                if (scy != 1)
                  g2[j + 1] = center[1] + (g1[j + 1] - center[1]) * scy;
              }
            } else {
              var pointArray = [[6], [0, 8], [2], [4]];
              var pointA = [g1[0], g1[1]];
              var pointB = [g1[2], g1[3]];
              var pointC = [g1[4], g1[5]];
              var pointD = [g1[6], g1[7]];
              var pointA1 = [g1[8], g1[9]];
              if (stretch) {
                var base = opt % 2 === 0 ? this._countVector(pointA, pointB) : this._countVector(pointD, pointA);
                var projectedVector = this._projectVectorOnVector(displacementVector, base);
                var nextIndex = opt + 1 < pointArray.length ? opt + 1 : 0;
                var coordsToChange = [...pointArray[opt], ...pointArray[nextIndex]];
                for (j = 0; j < g1.length; j += dim) {
                  g2[j] = coordsToChange.includes(j) ? g1[j] + projectedVector[0] : g1[j];
                  g2[j + 1] = coordsToChange.includes(j) ? g1[j + 1] + projectedVector[1] : g1[j + 1];
                }
              } else {
                var projectedLeft, projectedRight;
                switch (opt) {
                  case 0:
                    displacementVector = this._countVector(pointD, dragCoordinate);
                    projectedLeft = this._projectVectorOnVector(displacementVector, this._countVector(pointC, pointD));
                    projectedRight = this._projectVectorOnVector(displacementVector, this._countVector(pointA, pointD));
                    [g2[0], g2[1]] = this._movePoint(pointA, projectedLeft);
                    [g2[4], g2[5]] = this._movePoint(pointC, projectedRight);
                    [g2[6], g2[7]] = this._movePoint(pointD, displacementVector);
                    [g2[8], g2[9]] = this._movePoint(pointA1, projectedLeft);
                    break;
                  case 1:
                    displacementVector = this._countVector(pointA, dragCoordinate);
                    projectedLeft = this._projectVectorOnVector(displacementVector, this._countVector(pointD, pointA));
                    projectedRight = this._projectVectorOnVector(displacementVector, this._countVector(pointB, pointA));
                    [g2[0], g2[1]] = this._movePoint(pointA, displacementVector);
                    [g2[2], g2[3]] = this._movePoint(pointB, projectedLeft);
                    [g2[6], g2[7]] = this._movePoint(pointD, projectedRight);
                    [g2[8], g2[9]] = this._movePoint(pointA1, displacementVector);
                    break;
                  case 2:
                    displacementVector = this._countVector(pointB, dragCoordinate);
                    projectedLeft = this._projectVectorOnVector(displacementVector, this._countVector(pointA, pointB));
                    projectedRight = this._projectVectorOnVector(displacementVector, this._countVector(pointC, pointB));
                    [g2[0], g2[1]] = this._movePoint(pointA, projectedRight);
                    [g2[2], g2[3]] = this._movePoint(pointB, displacementVector);
                    [g2[4], g2[5]] = this._movePoint(pointC, projectedLeft);
                    [g2[8], g2[9]] = this._movePoint(pointA1, projectedRight);
                    break;
                  case 3:
                    displacementVector = this._countVector(pointC, dragCoordinate);
                    projectedLeft = this._projectVectorOnVector(displacementVector, this._countVector(pointB, pointC));
                    projectedRight = this._projectVectorOnVector(displacementVector, this._countVector(pointD, pointC));
                    [g2[2], g2[3]] = this._movePoint(pointB, projectedRight);
                    [g2[4], g2[5]] = this._movePoint(pointC, displacementVector);
                    [g2[6], g2[7]] = this._movePoint(pointD, projectedLeft);
                    break;
                }
              }
            }
            if (geometry.getType() == "Circle") geometry.setCenterAndRadius(geometry.getCenter(), geometry.getRadius());
            return g2;
          }).bind(this));
          if (this.get("enableRotatedTransform") && viewRotation !== 0) {
            geometry.rotate(viewRotation, this.getMap().getView().getCenter());
          }
          f.setGeometry(geometry);
        }
        this.drawSketch_();
        this.dispatchEvent({
          type: "scaling",
          feature: this.selection_.item(0),
          features: this.selection_,
          scale: [scx, scy],
          pixel: evt.pixel,
          coordinate: evt.coordinate
        });
        break;
      }
      default:
        break;
    }
    this.isUpdating_ = false;
  }
  /**
   * @param {ol.MapBrowserEvent} evt Event.
   * @private
   */
  handleMoveEvent_(evt) {
    if (!this._handleEvent(evt, this.features_))
      return;
    if (!this.mode_) {
      var sel = this.getFeatureAtPixel_(evt.pixel);
      var element = evt.map.getTargetElement();
      if (sel.feature) {
        var c = sel.handle ? this.Cursors[(sel.handle || "default") + (sel.constraint || "") + (sel.option || "")] : this.Cursors.select;
        if (this.previousCursor_ === void 0) {
          this.previousCursor_ = element.style.cursor;
        }
        element_default.setCursor(element, c);
      } else {
        if (this.previousCursor_ !== void 0) {
          element_default.setCursor(element, this.previousCursor_);
        }
        this.previousCursor_ = void 0;
      }
    }
  }
  /**
   * @param {ol.MapBrowserEvent} evt Map browser event.
   * @return {boolean} `false` to stop the drag sequence.
   */
  handleUpEvent_(evt) {
    if (this.mode_ === "rotate") {
      var element = evt.map.getTargetElement();
      element_default.setCursor(element, this.Cursors.default);
      this.previousCursor_ = void 0;
    }
    this.dispatchEvent({
      type: this.mode_ + "end",
      feature: this.selection_.item(0),
      features: this.selection_,
      oldgeom: this.geoms_[0],
      oldgeoms: this.geoms_,
      // handle changes
      transformed: this.hasChanged_
    });
    this.drawSketch_();
    this.hasChanged_ = false;
    this.mode_ = null;
    return false;
  }
  /** Set the point radius to calculate handles on points
   *  @param {number|Array<number>|function} [pointRadius=0] radius for points or a function that takes a feature and returns the radius (or [radiusX, radiusY]). If not null show handles to transform the points
   */
  setPointRadius(pointRadius) {
    if (typeof pointRadius === "function") {
      this._pointRadius = pointRadius;
    } else {
      this._pointRadius = function() {
        return pointRadius;
      };
    }
  }
  /** Get the features that are selected for transform
   * @return ol.Collection
   */
  getFeatures() {
    return this.selection_;
  }
  /**
   * @private
   */
  _projectVectorOnVector(displacement_vector, base) {
    var k = (displacement_vector[0] * base[0] + displacement_vector[1] * base[1]) / (base[0] * base[0] + base[1] * base[1]);
    return [base[0] * k, base[1] * k];
  }
  /**
   * @private
   */
  _countVector(start, end) {
    return [end[0] - start[0], end[1] - start[1]];
  }
  /**
   * @private
   */
  _movePoint(point, displacementVector) {
    return [point[0] + displacementVector[0], point[1] + displacementVector[1]];
  }
};
ol_interaction_Transform.prototype.Cursors = {
  "default": "auto",
  "select": "pointer",
  "translate": "move",
  "rotate": "move",
  "rotate0": "move",
  "scale": "nesw-resize",
  "scale1": "nwse-resize",
  "scale2": "nesw-resize",
  "scale3": "nwse-resize",
  "scalev": "ew-resize",
  "scaleh1": "ns-resize",
  "scalev2": "ew-resize",
  "scaleh3": "ns-resize"
};
var Transform_default = ol_interaction_Transform;

// node_modules/ol-ext/interaction/DrawRegular.js
var ol_interaction_DrawRegular = class olinteractionDrawRegular extends Interaction_default {
  constructor(options) {
    options = options || {};
    super({
      handleEvent: function(e) {
        return self.handleEvent_(e);
      }
    });
    var self = this;
    this.squaredClickTolerance_ = options.clickTolerance ? options.clickTolerance * options.clickTolerance : 36;
    this.maxCircleCoordinates_ = options.maxCircleCoordinates || 100;
    this.features_ = options.features;
    this.source_ = options.source;
    this.conditionFn_ = options.condition;
    this.squareFn_ = options.squareCondition;
    this.centeredFn_ = options.centerCondition;
    this.canRotate_ = options.canRotate !== false;
    this.geometryName_ = options.geometryName || "geometry";
    this.setSides(options.sides);
    var defaultStyle = defaultStyle_default(true);
    this.sketch_ = new Collection_default();
    this.overlayLayer_ = new Vector_default({
      source: new Vector_default2({
        features: this.sketch_,
        useSpatialIndex: false
      }),
      name: "DrawRegular overlay",
      displayInLayerSwitcher: false,
      style: options.style || defaultStyle
    });
  }
  /**
   * Remove the interaction from its current map, if any,  and attach it to a new
   * map, if any. Pass `null` to just remove the interaction from the current map.
   * @param {ol.Map} map Map.
   * @api stable
   */
  setMap(map) {
    if (this.getMap()) this.getMap().removeLayer(this.overlayLayer_);
    super.setMap(map);
    this.overlayLayer_.setMap(map);
  }
  /**
   * Activate/deactivate the interaction
   * @param {boolean}
   * @api stable
   */
  setActive(b) {
    this.reset();
    super.setActive(b);
  }
  /**
   * Reset the interaction
   * @api stable
   */
  reset() {
    if (this.overlayLayer_) this.overlayLayer_.getSource().clear();
    this.started_ = false;
  }
  /**
   * Set the number of sides.
   * @param {int} number of sides.
   * @api stable
   */
  setSides(nb) {
    nb = parseInt(nb);
    this.sides_ = nb > 2 ? nb : 0;
  }
  /**
   * Allow rotation when centered + square
   * @param {bool}
   * @api stable
   */
  canRotate(b) {
    if (b === true || b === false)
      this.canRotate_ = b;
    return this.canRotate_;
  }
  /**
   * Get the number of sides.
   * @return {int} number of sides.
   * @api stable
   */
  getSides() {
    return this.sides_;
  }
  /** Get geom of the current drawing
  * @return {ol.geom.Polygon | ol.geom.Point}
  */
  getGeom_() {
    this.overlayLayer_.getSource().clear();
    if (!this.center_)
      return false;
    var g;
    if (this.coord_) {
      var center = this.center_;
      var coord = this.coord_;
      var d, dmax, r, circle, centerPx;
      if (!this.sides_ && this.square_ && !this.centered_) {
        center = [(coord[0] + center[0]) / 2, (coord[1] + center[1]) / 2];
        d = [coord[0] - center[0], coord[1] - center[1]];
        r = Math.sqrt(d[0] * d[0] + d[1] * d[1]);
        circle = new Circle_default(center, r, "XY");
        centerPx = this.getMap().getPixelFromCoordinate(center);
        dmax = Math.max(100, Math.abs(centerPx[0] - this.coordPx_[0]), Math.abs(centerPx[1] - this.coordPx_[1]));
        dmax = Math.min(this.maxCircleCoordinates_, Math.round(dmax / 3));
        return fromCircle(circle, dmax, 0);
      } else {
        var hasrotation = this.canRotate_ && this.centered_ && this.square_;
        d = [coord[0] - center[0], coord[1] - center[1]];
        if (this.square_ && !hasrotation) {
          var dm = Math.max(Math.abs(d[0]), Math.abs(d[1]));
          coord = [
            center[0] + (d[0] > 0 ? dm : -dm),
            center[1] + (d[1] > 0 ? dm : -dm)
          ];
        }
        r = Math.sqrt(d[0] * d[0] + d[1] * d[1]);
        if (r > 0) {
          circle = new Circle_default(center, r, "XY");
          var a;
          if (hasrotation)
            a = Math.atan2(d[1], d[0]);
          else
            a = this.startAngle[this.sides_] || this.startAngle["default"];
          if (this.sides_) {
            g = fromCircle(circle, this.sides_, a);
          } else {
            centerPx = this.getMap().getPixelFromCoordinate(this.center_);
            dmax = Math.max(100, Math.abs(centerPx[0] - this.coordPx_[0]), Math.abs(centerPx[1] - this.coordPx_[1]));
            dmax = Math.min(this.maxCircleCoordinates_, Math.round(dmax / (this.centered_ ? 3 : 5)));
            g = fromCircle(circle, dmax, 0);
          }
          if (hasrotation)
            return g;
          var ext = g.getExtent();
          if (!this.centered_)
            center = this.center_;
          else
            center = [2 * this.center_[0] - this.coord_[0], 2 * this.center_[1] - this.coord_[1]];
          var scx = (center[0] - coord[0]) / (ext[0] - ext[2]);
          var scy = (center[1] - coord[1]) / (ext[1] - ext[3]);
          if (this.square_) {
            var sc = Math.min(Math.abs(scx), Math.abs(scy));
            scx = Math.sign(scx) * sc;
            scy = Math.sign(scy) * sc;
          }
          var t = [center[0] - ext[0] * scx, center[1] - ext[1] * scy];
          g.applyTransform(function(g1, g2, dim) {
            for (var i = 0; i < g1.length; i += dim) {
              g2[i] = g1[i] * scx + t[0];
              g2[i + 1] = g1[i + 1] * scy + t[1];
            }
            return g2;
          });
          return g;
        }
      }
    }
    return new Point_default(this.center_);
  }
  /** Draw sketch
  * @return {ol.Feature} The feature being drawn.
  */
  drawSketch_(evt) {
    this.overlayLayer_.getSource().clear();
    if (evt) {
      this.square_ = this.squareFn_ ? this.squareFn_(evt) : evt.originalEvent.shiftKey;
      this.centered_ = this.centeredFn_ ? this.centeredFn_(evt) : evt.originalEvent.metaKey || evt.originalEvent.ctrlKey;
      var g = this.getGeom_();
      if (g) {
        var f = this.feature_;
        if (g.getType() === "Polygon")
          f.getGeometry().setCoordinates(g.getCoordinates());
        this.overlayLayer_.getSource().addFeature(f);
        if (this.coord_ && this.square_ && (this.canRotate_ && this.centered_ && this.coord_ || !this.sides_ && !this.centered_)) {
          this.overlayLayer_.getSource().addFeature(new Feature_default(new LineString_default([this.center_, this.coord_])));
        }
        return f;
      }
    }
  }
  /** Draw sketch (Point)
  */
  drawPoint_(pt, noclear) {
    if (!noclear) {
      this.overlayLayer_.getSource().clear();
    }
    this.overlayLayer_.getSource().addFeature(new Feature_default(new Point_default(pt)));
  }
  /**
   * @param {ol.MapBrowserEvent} evt Map browser event.
   */
  handleEvent_(evt) {
    var dx, dy;
    this._eventTime = /* @__PURE__ */ new Date();
    switch (evt.type) {
      case "pointerdown": {
        if (this.conditionFn_ && !this.conditionFn_(evt)) break;
        this.downPx_ = evt.pixel;
        this.start_(evt);
        var dt = 500;
        this._longTouch = false;
        setTimeout((function() {
          this._longTouch = /* @__PURE__ */ new Date() - this._eventTime > 0.9 * dt;
          if (this._longTouch)
            this.handleMoveEvent_(evt);
        }).bind(this), dt);
        this.lastEvent = evt.type;
        break;
      }
      case "pointerup": {
        if (this.started_ && this.coord_) {
          dx = this.downPx_[0] - evt.pixel[0];
          dy = this.downPx_[1] - evt.pixel[1];
          if (dx * dx + dy * dy <= this.squaredClickTolerance_) {
            if (this.lastEvent == "pointerdown" || this.lastEvent == "pointermove" || this.lastEvent == "keydown") {
              this.end_(evt);
            } else {
              dx = this.upPx_[0] - evt.pixel[0];
              dy = this.upPx_[1] - evt.pixel[1];
              if (dx * dx + dy * dy <= this.squaredClickTolerance_) {
                this.end_(evt);
              } else {
                this.handleMoveEvent_(evt);
                this.drawPoint_(evt.coordinate, true);
              }
            }
          }
        }
        this.upPx_ = evt.pixel;
        break;
      }
      case "pointerdrag": {
        if (this.started_) {
          var centerPx = this.getMap().getPixelFromCoordinate(this.center_);
          dx = centerPx[0] - evt.pixel[0];
          dy = centerPx[1] - evt.pixel[1];
          if (dx * dx + dy * dy <= this.squaredClickTolerance_) {
            this.reset();
          }
        }
        return !this._longTouch;
      }
      case "pointermove": {
        if (this.started_) {
          dx = this.downPx_[0] - evt.pixel[0];
          dy = this.downPx_[1] - evt.pixel[1];
          if (dx * dx + dy * dy > this.squaredClickTolerance_) {
            this.handleMoveEvent_(evt);
            this.lastEvent = evt.type;
          }
        } else {
          this.drawPoint_(evt.coordinate);
        }
        break;
      }
      default: {
        if (this.started_ && (evt.type === "click" || evt.type === "singleclick" || evt.type === "dblclick")) {
          return false;
        }
        this.lastEvent = evt.type;
        break;
      }
    }
    return true;
  }
  /** Stop drawing.
   */
  finishDrawing() {
    if (this.started_ && this.coord_) {
      this.end_({ pixel: this.upPx_, coordinate: this.coord_ });
    }
  }
  /**
   * @param {ol.MapBrowserEvent} evt Event.
   */
  handleMoveEvent_(evt) {
    if (this.started_) {
      this.coord_ = evt.coordinate;
      this.coordPx_ = evt.pixel;
      var f = this.drawSketch_(evt);
      this.dispatchEvent({
        type: "drawing",
        feature: f,
        pixel: evt.pixel,
        startCoordinate: this.center_,
        coordinate: evt.coordinate,
        square: this.square_,
        centered: this.centered_
      });
    } else {
      this.drawPoint_(evt.coordinate);
    }
  }
  /** Start an new draw
   * @param {ol.MapBrowserEvent} evt Map browser event.
   * @return {boolean} `false` to stop the drag sequence.
   */
  start_(evt) {
    if (!this.started_) {
      this.started_ = true;
      this.center_ = evt.coordinate;
      this.coord_ = null;
      var f = this.feature_ = new Feature_default({});
      f.setGeometryName(this.geometryName_ || "geometry");
      f.setGeometry(new Polygon_default([[evt.coordinate, evt.coordinate, evt.coordinate]]));
      this.drawSketch_(evt);
      this.dispatchEvent({ type: "drawstart", feature: f, pixel: evt.pixel, coordinate: evt.coordinate });
    } else {
      this.coord_ = evt.coordinate;
    }
  }
  /** End drawing
   * @param {ol.MapBrowserEvent} evt Map browser event.
   * @return {boolean} `false` to stop the drag sequence.
   */
  end_(evt) {
    this.coord_ = evt.coordinate;
    this.started_ = false;
    if (this.coord_ && (this.center_[0] !== this.coord_[0] || this.center_[1] !== this.coord_[1])) {
      var f = this.feature_;
      f.setGeometry(this.getGeom_());
      if (this.source_)
        this.source_.addFeature(f);
      else if (this.features_)
        this.features_.push(f);
      this.dispatchEvent({ type: "drawend", feature: f, pixel: evt.pixel, coordinate: evt.coordinate, square: this.square_, centered: this.centered_ });
    } else {
      this.dispatchEvent({ type: "drawcancel", feature: null, pixel: evt.pixel, coordinate: evt.coordinate, square: this.square_, centered: this.centered_ });
    }
    this.center_ = this.coord_ = null;
    this.drawSketch_();
  }
};
ol_interaction_DrawRegular.prototype.startAngle = {
  "default": Math.PI / 2,
  3: -Math.PI / 2,
  4: Math.PI / 4
};
var DrawRegular_default = ol_interaction_DrawRegular;

// node_modules/ol-ext/interaction/DrawHole.js
var ol_interaction_DrawHole = class olinteractionDrawHole extends Draw_default {
  constructor(options) {
    options = options || {};
    var _geometryFn = function(coordinates, geometry) {
      var coord = coordinates[0].pop();
      if (!this.getPolygon() || this.getPolygon().intersectsCoordinate(coord)) {
        this.lastOKCoord = [coord[0], coord[1]];
      }
      coordinates[0].push([this.lastOKCoord[0], this.lastOKCoord[1]]);
      if (geometry) {
        geometry.setCoordinates([coordinates[0].concat([coordinates[0][0]])]);
      } else {
        geometry = new Polygon_default(coordinates);
      }
      return geometry;
    };
    var geomFn = options.geometryFunction;
    if (geomFn) {
      options.geometryFunction = function(c, g, p) {
        g = _geometryFn.bind(this)(c, g);
        return geomFn.bind(this)(c, g, p);
      };
    } else {
      options.geometryFunction = _geometryFn;
    }
    options.type = "Polygon";
    super(options);
    this._select = new Select_default({ style: options.style });
    this._select.setActive(false);
    if (options.layers) {
      if (typeof options.layers === "function") {
        this.layers_ = options.layers;
      } else if (options.layers.indexOf) {
        this.layers_ = function(l) {
          return options.layers.indexOf(l) >= 0;
        };
      }
    }
    if (typeof options.featureFilter === "function") {
      this._features = options.featureFilter;
    } else if (options.featureFilter) {
      var features = options.featureFilter;
      this._features = function(f) {
        if (features.indexOf) {
          return !!features[features.indexOf(f)];
        } else {
          return !!features.item(features.getArray().indexOf(f));
        }
      };
    } else {
      this._features = function() {
        return true;
      };
    }
    this.on("drawstart", this._startDrawing.bind(this));
    this.on("drawend", this._finishDrawing.bind(this));
  }
  /**
   * Remove the interaction from its current map, if any,  and attach it to a new
   * map, if any. Pass `null` to just remove the interaction from the current map.
   * @param {ol.Map} map Map.
   * @api stable
   */
  setMap(map) {
    if (this.getMap()) this.getMap().removeInteraction(this._select);
    if (map) map.addInteraction(this._select);
    super.setMap.call(this, map);
  }
  /**
   * Activate/deactivate the interaction
   * @param {boolean}
   * @api stable
   */
  setActive(b) {
    if (this._select) this._select.getFeatures().clear();
    super.setActive.call(this, b);
  }
  /**
   * Remove last point of the feature currently being drawn
   * (test if points to remove before).
   */
  removeLastPoint() {
    if (this._feature && this._feature.getGeometry().getCoordinates()[0].length > 2) {
      super.removeLastPoint.call(this);
    }
  }
  /**
   * Get the current polygon to hole
   * @return {ol.Feature}
   */
  getPolygon() {
    return this._polygon;
  }
  /**
   * Get current feature to add a hole and start drawing
   * @param {ol_interaction_Draw.Event} e
   * @private
   */
  _startDrawing(e) {
    var map = this.getMap();
    this._feature = e.feature;
    var coord = e.feature.getGeometry().getCoordinates()[0][0];
    this._current = null;
    map.forEachFeatureAtPixel(
      map.getPixelFromCoordinate(coord),
      (function(feature, layer) {
        if (!this._current && this._features(feature, layer)) {
          var poly = feature.getGeometry();
          if (poly.getType() === "Polygon" && poly.intersectsCoordinate(coord)) {
            this._polygonIndex = false;
            this._polygon = poly;
            this._current = feature;
          } else if (poly.getType() === "MultiPolygon" && poly.intersectsCoordinate(coord)) {
            for (var i = 0, p; p = poly.getPolygon(i); i++) {
              if (p.intersectsCoordinate(coord)) {
                this._polygonIndex = i;
                this._polygon = p;
                this._current = feature;
                break;
              }
            }
          }
        }
      }).bind(this),
      {
        layerFilter: this.layers_
      }
    );
    this._select.getFeatures().clear();
    if (!this._current) {
      this.setActive(false);
      this.setActive(true);
    } else {
      this._select.getFeatures().push(this._current);
    }
  }
  /**
   * Stop drawing and add the sketch feature to the target feature.
   * @param {ol_interaction_Draw.Event} e
   * @private
   */
  _finishDrawing(e) {
    e.hole = e.feature;
    e.feature = this._select.getFeatures().item(0);
    this.dispatchEvent({ type: "modifystart", features: [this._current] });
    var c = e.hole.getGeometry().getCoordinates()[0];
    if (c.length > 3) {
      if (this._polygonIndex !== false) {
        var geom = e.feature.getGeometry();
        var newGeom = new MultiPolygon_default([]);
        for (var i = 0, pi; pi = geom.getPolygon(i); i++) {
          if (i === this._polygonIndex) {
            pi.appendLinearRing(new LinearRing_default(c));
            newGeom.appendPolygon(pi);
          } else {
            newGeom.appendPolygon(pi);
          }
        }
        e.feature.setGeometry(newGeom);
      } else {
        this.getPolygon().appendLinearRing(new LinearRing_default(c));
      }
    }
    this.dispatchEvent({ type: "modifyend", features: [this._current] });
    this._feature = null;
    this._select.getFeatures().clear();
  }
  /**
   * Function that is called when a geometry's coordinates are updated.
   * @param {Array<ol.coordinate>} coordinates
   * @param {ol_geom_Polygon} geometry
   * @return {ol_geom_Polygon}
   * @private
   */
  _geometryFn(coordinates, geometry) {
    var coord = coordinates[0].pop();
    if (!this.getPolygon() || this.getPolygon().intersectsCoordinate(coord)) {
      this.lastOKCoord = [coord[0], coord[1]];
    }
    coordinates[0].push([this.lastOKCoord[0], this.lastOKCoord[1]]);
    if (geometry) {
      geometry.setCoordinates([coordinates[0].concat([coordinates[0][0]])]);
    } else {
      geometry = new Polygon_default(coordinates);
    }
    return geometry;
  }
};
var DrawHole_default = ol_interaction_DrawHole;

// node_modules/ol-ext/control/EditBar.js
var ol_control_EditBar = class olcontrolEditBar extends Bar_default {
  constructor(options) {
    options = options || {};
    options.interactions = options.interactions || {};
    super({
      className: (options.className ? options.className + " " : "") + "ol-editbar",
      toggleOne: true,
      target: options.target
    });
    this._source = options.source;
    this._interactions = {};
    this._setSelectInteraction(options);
    if (options.edition !== false)
      this._setEditInteraction(options);
    this._setModifyInteraction(options);
  }
  /**
   * Set the map instance the control is associated with
   * and add its controls associated to this map.
   * @param {_ol_Map_} map The map instance.
   */
  setMap(map) {
    if (this.getMap()) {
      if (this._interactions.Delete)
        this.getMap().removeInteraction(this._interactions.Delete);
      if (this._interactions.ModifySelect)
        this.getMap().removeInteraction(this._interactions.ModifySelect);
    }
    super.setMap(map);
    if (this.getMap()) {
      if (this._interactions.Delete)
        this.getMap().addInteraction(this._interactions.Delete);
      if (this._interactions.ModifySelect)
        this.getMap().addInteraction(this._interactions.ModifySelect);
    }
  }
  /** Get an interaction associated with the bar
   * @param {string} name
   */
  getInteraction(name) {
    return this._interactions[name];
  }
  /** Get the option title */
  _getTitle(option) {
    if (option) {
      if (option.get)
        return option.get("title");
      else if (typeof option === "string")
        return option;
      else
        return option.title;
    }
  }
  /** Add selection tool:
   * 1. a toggle control with a select interaction
   * 2. an option bar to delete / get information on the selected feature
   * @private
   */
  _setSelectInteraction(options) {
    var self = this;
    var sbar = new Bar_default();
    var selectCtrl;
    if (options.interactions.Delete !== false) {
      if (options.interactions.Delete instanceof Delete_default) {
        this._interactions.Delete = options.interactions.Delete;
      } else {
        this._interactions.Delete = new Delete_default();
      }
      var del = this._interactions.Delete;
      del.setActive(false);
      if (this.getMap())
        this.getMap().addInteraction(del);
      sbar.addControl(new Button_default({
        className: "ol-delete",
        title: this._getTitle(options.interactions.Delete) || "Delete",
        name: "Delete",
        handleClick: function(e) {
          del.delete(selectCtrl.getInteraction().getFeatures());
          var evt = {
            type: "select",
            selected: [],
            deselected: selectCtrl.getInteraction().getFeatures().getArray().slice(),
            mapBrowserEvent: e.mapBrowserEvent
          };
          selectCtrl.getInteraction().getFeatures().clear();
          selectCtrl.getInteraction().dispatchEvent(evt);
        }
      }));
    }
    if (options.interactions.Info !== false) {
      sbar.addControl(new Button_default({
        className: "ol-info",
        name: "Info",
        title: this._getTitle(options.interactions.Info) || "Show informations",
        handleClick: function() {
          self.dispatchEvent({
            type: "info",
            features: selectCtrl.getInteraction().getFeatures()
          });
        }
      }));
    }
    if (options.interactions.Select !== false) {
      if (options.interactions.Select instanceof Select_default) {
        this._interactions.Select = options.interactions.Select;
      } else {
        this._interactions.Select = new Select_default({
          condition: click
        });
      }
      var sel = this._interactions.Select;
      selectCtrl = new Toggle_default({
        className: "ol-selection",
        name: "Select",
        title: this._getTitle(options.interactions.Select) || "Select",
        interaction: sel,
        bar: sbar.getControls().length ? sbar : void 0,
        autoActivate: true,
        active: true
      });
      this.addControl(selectCtrl);
      sel.on("change:active", (function() {
        if (!sel.getActive()) {
          sel.getFeatures().clear();
        }
      }).bind(this));
    }
  }
  /** Add editing tools
   * @private
   */
  _setEditInteraction(options) {
    if (options.interactions.DrawPoint !== false) {
      if (options.interactions.DrawPoint instanceof Draw_default) {
        this._interactions.DrawPoint = options.interactions.DrawPoint;
      } else {
        this._interactions.DrawPoint = new Draw_default({
          type: "Point",
          source: this._source
        });
      }
      var pedit = new Toggle_default({
        className: "ol-drawpoint",
        name: "DrawPoint",
        title: this._getTitle(options.interactions.DrawPoint) || "Point",
        interaction: this._interactions.DrawPoint
      });
      this.addControl(pedit);
    }
    if (options.interactions.DrawLine !== false) {
      if (options.interactions.DrawLine instanceof Draw_default) {
        this._interactions.DrawLine = options.interactions.DrawLine;
      } else {
        this._interactions.DrawLine = new Draw_default({
          type: "LineString",
          source: this._source,
          // Count inserted points
          geometryFunction: function(coordinates, geometry) {
            if (geometry)
              geometry.setCoordinates(coordinates);
            else
              geometry = new LineString_default(coordinates);
            this.nbpts = geometry.getCoordinates().length;
            return geometry;
          }
        });
      }
      var ledit;
      if (options.drawOptions !== false) {
        ledit = new Toggle_default({
          className: "ol-drawline",
          title: this._getTitle(options.interactions.DrawLine) || "LineString",
          name: "DrawLine",
          interaction: this._interactions.DrawLine,
          // Options bar associated with the control
          bar: new Bar_default({
            controls: [
              new TextButton_default({
                html: this._getTitle(options.interactions.UndoDraw) || "undo",
                title: this._getTitle(options.interactions.UndoDraw) || "delete last point",
                handleClick: function() {
                  if (ledit.getInteraction().nbpts > 1)
                    ledit.getInteraction().removeLastPoint();
                }
              }),
              new TextButton_default({
                html: this._getTitle(options.interactions.FinishDraw) || "finish",
                title: this._getTitle(options.interactions.FinishDraw) || "finish",
                handleClick: function() {
                  if (ledit.getInteraction().nbpts > 2)
                    ledit.getInteraction().finishDrawing();
                }
              })
            ]
          })
        });
      } else {
        ledit = new Toggle_default({
          className: "ol-drawline",
          title: this._getTitle(options.interactions.DrawLine) || "LineString",
          name: "DrawLine",
          interaction: this._interactions.DrawLine
        });
      }
      this.addControl(ledit);
    }
    if (options.interactions.DrawPolygon !== false) {
      if (options.interactions.DrawPolygon instanceof Draw_default) {
        this._interactions.DrawPolygon = options.interactions.DrawPolygon;
      } else {
        this._interactions.DrawPolygon = new Draw_default({
          type: "Polygon",
          source: this._source,
          // Count inserted points
          geometryFunction: function(coordinates, geometry) {
            this.nbpts = coordinates[0].length;
            if (geometry)
              geometry.setCoordinates([coordinates[0].concat([coordinates[0][0]])]);
            else
              geometry = new Polygon_default(coordinates);
            return geometry;
          }
        });
      }
      this._setDrawPolygon(
        "ol-drawpolygon",
        this._interactions.DrawPolygon,
        this._getTitle(options.interactions.DrawPolygon) || "Polygon",
        "DrawPolygon",
        options
      );
    }
    if (options.interactions.DrawHole !== false) {
      if (options.interactions.DrawHole instanceof DrawHole_default) {
        this._interactions.DrawHole = options.interactions.DrawHole;
      } else {
        this._interactions.DrawHole = new DrawHole_default();
      }
      this._setDrawPolygon(
        "ol-drawhole",
        this._interactions.DrawHole,
        this._getTitle(options.interactions.DrawHole) || "Hole",
        "DrawHole",
        options
      );
    }
    if (options.interactions.DrawRegular !== false) {
      var label = { pts: "pts", circle: "circle" };
      if (options.interactions.DrawRegular instanceof DrawRegular_default) {
        this._interactions.DrawRegular = options.interactions.DrawRegular;
        label.pts = this._interactions.DrawRegular.get("ptsLabel") || label.pts;
        label.circle = this._interactions.DrawRegular.get("circleLabel") || label.circle;
      } else {
        this._interactions.DrawRegular = new DrawRegular_default({
          source: this._source,
          sides: 4
        });
        if (options.interactions.DrawRegular) {
          label.pts = options.interactions.DrawRegular.ptsLabel || label.pts;
          label.circle = options.interactions.DrawRegular.circleLabel || label.circle;
        }
      }
      var regular = this._interactions.DrawRegular;
      var div = document.createElement("div");
      var down = element_default.create("DIV", { parent: div });
      element_default.addListener(down, ["click", "touchstart"], (function() {
        var sides = regular.getSides() - 1;
        if (sides < 2)
          sides = 2;
        regular.setSides(sides);
        text.textContent = sides > 2 ? sides + " " + label.pts : label.circle;
      }).bind(this));
      var text = element_default.create("TEXT", { html: "4 " + label.pts, parent: div });
      var up = element_default.create("DIV", { parent: div });
      element_default.addListener(up, ["click", "touchstart"], (function() {
        var sides = regular.getSides() + 1;
        if (sides < 3)
          sides = 3;
        regular.setSides(sides);
        text.textContent = sides + " " + label.pts;
      }).bind(this));
      var ctrl = new Toggle_default({
        className: "ol-drawregular",
        title: this._getTitle(options.interactions.DrawRegular) || "Regular",
        name: "DrawRegular",
        interaction: this._interactions.DrawRegular,
        // Options bar associated with the control
        bar: new Bar_default({
          controls: [
            new TextButton_default({
              html: div
            })
          ]
        })
      });
      this.addControl(ctrl);
    }
  }
  /**
   * @private
   */
  _setDrawPolygon(className, interaction, title, name, options) {
    var fedit;
    if (options.drawOptions !== false) {
      fedit = new Toggle_default({
        className,
        name,
        title,
        interaction,
        // Options bar associated with the control
        bar: new Bar_default({
          controls: [
            new TextButton_default({
              html: this._getTitle(options.interactions.UndoDraw) || "undo",
              title: this._getTitle(options.interactions.UndoDraw) || "undo last point",
              handleClick: function() {
                if (fedit.getInteraction().nbpts > 1)
                  fedit.getInteraction().removeLastPoint();
              }
            }),
            new TextButton_default({
              html: this._getTitle(options.interactions.FinishDraw) || "finish",
              title: this._getTitle(options.interactions.FinishDraw) || "finish",
              handleClick: function() {
                if (fedit.getInteraction().nbpts > 3)
                  fedit.getInteraction().finishDrawing();
              }
            })
          ]
        })
      });
    } else {
      fedit = new Toggle_default({
        className,
        name,
        title,
        interaction
      });
    }
    this.addControl(fedit);
    return fedit;
  }
  /** Add modify tools
   * @private
   */
  _setModifyInteraction(options) {
    if (options.interactions.ModifySelect !== false && options.interactions.Select !== false) {
      if (options.interactions.ModifySelect instanceof ModifyFeature_default) {
        this._interactions.ModifySelect = options.interactions.ModifySelect;
      } else {
        this._interactions.ModifySelect = new ModifyFeature_default({
          features: this.getInteraction("Select").getFeatures()
        });
      }
      if (this.getMap())
        this.getMap().addInteraction(this._interactions.ModifySelect);
      this._interactions.ModifySelect.setActive(this._interactions.Select.getActive());
      this._interactions.Select.on("change:active", (function() {
        this._interactions.ModifySelect.setActive(this._interactions.Select.getActive());
      }).bind(this));
    }
    if (options.interactions.Transform !== false) {
      if (options.interactions.Transform instanceof Transform_default) {
        this._interactions.Transform = options.interactions.Transform;
      } else {
        this._interactions.Transform = new Transform_default({
          select: this._interactions.Select,
          addCondition: shiftKeyOnly
        });
        if (this._interactions.Select) {
          this._interactions.Transform.on("change:active", (function() {
            if (!this._interactions.Select.getActive()) {
              this._interactions.Select.getFeatures().clear();
            }
          }).bind(this));
        }
      }
      var transform = new Toggle_default({
        html: "<i></i>",
        className: "ol-transform",
        title: this._getTitle(options.interactions.Transform) || "Transform",
        name: "Transform",
        interaction: this._interactions.Transform
      });
      this.addControl(transform);
    }
    if (options.interactions.Split !== false) {
      if (options.interactions.Split instanceof Split_default) {
        this._interactions.Split = options.interactions.Split;
      } else {
        this._interactions.Split = new Split_default({
          sources: this._source
        });
      }
      var split = new Toggle_default({
        className: "ol-split",
        title: this._getTitle(options.interactions.Split) || "Split",
        name: "Split",
        interaction: this._interactions.Split
      });
      this.addControl(split);
    }
    if (options.interactions.Offset !== false) {
      if (options.interactions.Offset instanceof Offset_default) {
        this._interactions.Offset = options.interactions.Offset;
      } else {
        this._interactions.Offset = new Offset_default({
          source: this._source
        });
      }
      var offset = new Toggle_default({
        html: "<i></i>",
        className: "ol-offset",
        title: this._getTitle(options.interactions.Offset) || "Offset",
        name: "Offset",
        interaction: this._interactions.Offset
      });
      this.addControl(offset);
    }
  }
};
var EditBar_default = ol_control_EditBar;
export {
  EditBar_default as default
};
//# sourceMappingURL=ol-ext_control_EditBar.js.map