@antv/l7-draw/dist/l7-draw.js

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@antv/l7')) :
  typeof define === 'function' && define.amd ? define(['exports', '@antv/l7'], factory) :
  (global = global || self, factory((global.L7 = global.L7 || {}, global.L7.Draw = {}), global.L7));
}(this, (function (exports, l7) { 'use strict';

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
  }

  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }

    return obj;
  }

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      if (enumerableOnly) symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
      keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};

      if (i % 2) {
        ownKeys(Object(source), true).forEach(function (key) {
          _defineProperty(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(Object(source)).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }

    return target;
  }

  function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) _setPrototypeOf(subClass, superClass);
  }

  function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _getPrototypeOf(o);
  }

  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return _setPrototypeOf(o, p);
  }

  function _isNativeReflectConstruct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function _possibleConstructorReturn(self, call) {
    if (call && (typeof call === "object" || typeof call === "function")) {
      return call;
    }

    return _assertThisInitialized(self);
  }

  function _createSuper(Derived) {
    var hasNativeReflectConstruct = _isNativeReflectConstruct();

    return function _createSuperInternal() {
      var Super = _getPrototypeOf(Derived),
          result;

      if (hasNativeReflectConstruct) {
        var NewTarget = _getPrototypeOf(this).constructor;

        result = Reflect.construct(Super, arguments, NewTarget);
      } else {
        result = Super.apply(this, arguments);
      }

      return _possibleConstructorReturn(this, result);
    };
  }

  function _superPropBase(object, property) {
    while (!Object.prototype.hasOwnProperty.call(object, property)) {
      object = _getPrototypeOf(object);
      if (object === null) break;
    }

    return object;
  }

  function _get(target, property, receiver) {
    if (typeof Reflect !== "undefined" && Reflect.get) {
      _get = Reflect.get;
    } else {
      _get = function _get(target, property, receiver) {
        var base = _superPropBase(target, property);

        if (!base) return;
        var desc = Object.getOwnPropertyDescriptor(base, property);

        if (desc.get) {
          return desc.get.call(receiver);
        }

        return desc.value;
      };
    }

    return _get(target, property, receiver || target);
  }

  function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
  }

  function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];

    return arr2;
  }

  function _createForOfIteratorHelper(o, allowArrayLike) {
    var it;

    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
        if (it) o = it;
        var i = 0;

        var F = function () {};

        return {
          s: F,
          n: function () {
            if (i >= o.length) return {
              done: true
            };
            return {
              done: false,
              value: o[i++]
            };
          },
          e: function (e) {
            throw e;
          },
          f: F
        };
      }

      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
    }

    var normalCompletion = true,
        didErr = false,
        err;
    return {
      s: function () {
        it = o[Symbol.iterator]();
      },
      n: function () {
        var step = it.next();
        normalCompletion = step.done;
        return step;
      },
      e: function (e) {
        didErr = true;
        err = e;
      },
      f: function () {
        try {
          if (!normalCompletion && it.return != null) it.return();
        } finally {
          if (didErr) throw err;
        }
      }
    };
  }

  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

  function unwrapExports (x) {
  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
  }

  function createCommonjsModule(fn, module) {
  	return module = { exports: {} }, fn(module, module.exports), module.exports;
  }

  var helpers = createCommonjsModule(function (module, exports) {
  Object.defineProperty(exports, "__esModule", { value: true });
  /**
   * @module helpers
   */
  /**
   * Earth Radius used with the Harvesine formula and approximates using a spherical (non-ellipsoid) Earth.
   *
   * @memberof helpers
   * @type {number}
   */
  exports.earthRadius = 6371008.8;
  /**
   * Unit of measurement factors using a spherical (non-ellipsoid) earth radius.
   *
   * @memberof helpers
   * @type {Object}
   */
  exports.factors = {
      centimeters: exports.earthRadius * 100,
      centimetres: exports.earthRadius * 100,
      degrees: exports.earthRadius / 111325,
      feet: exports.earthRadius * 3.28084,
      inches: exports.earthRadius * 39.370,
      kilometers: exports.earthRadius / 1000,
      kilometres: exports.earthRadius / 1000,
      meters: exports.earthRadius,
      metres: exports.earthRadius,
      miles: exports.earthRadius / 1609.344,
      millimeters: exports.earthRadius * 1000,
      millimetres: exports.earthRadius * 1000,
      nauticalmiles: exports.earthRadius / 1852,
      radians: 1,
      yards: exports.earthRadius / 1.0936,
  };
  /**
   * Units of measurement factors based on 1 meter.
   *
   * @memberof helpers
   * @type {Object}
   */
  exports.unitsFactors = {
      centimeters: 100,
      centimetres: 100,
      degrees: 1 / 111325,
      feet: 3.28084,
      inches: 39.370,
      kilometers: 1 / 1000,
      kilometres: 1 / 1000,
      meters: 1,
      metres: 1,
      miles: 1 / 1609.344,
      millimeters: 1000,
      millimetres: 1000,
      nauticalmiles: 1 / 1852,
      radians: 1 / exports.earthRadius,
      yards: 1 / 1.0936,
  };
  /**
   * Area of measurement factors based on 1 square meter.
   *
   * @memberof helpers
   * @type {Object}
   */
  exports.areaFactors = {
      acres: 0.000247105,
      centimeters: 10000,
      centimetres: 10000,
      feet: 10.763910417,
      inches: 1550.003100006,
      kilometers: 0.000001,
      kilometres: 0.000001,
      meters: 1,
      metres: 1,
      miles: 3.86e-7,
      millimeters: 1000000,
      millimetres: 1000000,
      yards: 1.195990046,
  };
  /**
   * Wraps a GeoJSON {@link Geometry} in a GeoJSON {@link Feature}.
   *
   * @name feature
   * @param {Geometry} geometry input geometry
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the Feature
   * @returns {Feature} a GeoJSON Feature
   * @example
   * var geometry = {
   *   "type": "Point",
   *   "coordinates": [110, 50]
   * };
   *
   * var feature = turf.feature(geometry);
   *
   * //=feature
   */
  function feature(geom, properties, options) {
      if (options === void 0) { options = {}; }
      var feat = { type: "Feature" };
      if (options.id === 0 || options.id) {
          feat.id = options.id;
      }
      if (options.bbox) {
          feat.bbox = options.bbox;
      }
      feat.properties = properties || {};
      feat.geometry = geom;
      return feat;
  }
  exports.feature = feature;
  /**
   * Creates a GeoJSON {@link Geometry} from a Geometry string type & coordinates.
   * For GeometryCollection type use `helpers.geometryCollection`
   *
   * @name geometry
   * @param {string} type Geometry Type
   * @param {Array<any>} coordinates Coordinates
   * @param {Object} [options={}] Optional Parameters
   * @returns {Geometry} a GeoJSON Geometry
   * @example
   * var type = "Point";
   * var coordinates = [110, 50];
   * var geometry = turf.geometry(type, coordinates);
   * // => geometry
   */
  function geometry(type, coordinates, options) {
      switch (type) {
          case "Point": return point(coordinates).geometry;
          case "LineString": return lineString(coordinates).geometry;
          case "Polygon": return polygon(coordinates).geometry;
          case "MultiPoint": return multiPoint(coordinates).geometry;
          case "MultiLineString": return multiLineString(coordinates).geometry;
          case "MultiPolygon": return multiPolygon(coordinates).geometry;
          default: throw new Error(type + " is invalid");
      }
  }
  exports.geometry = geometry;
  /**
   * Creates a {@link Point} {@link Feature} from a Position.
   *
   * @name point
   * @param {Array<number>} coordinates longitude, latitude position (each in decimal degrees)
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the Feature
   * @returns {Feature<Point>} a Point feature
   * @example
   * var point = turf.point([-75.343, 39.984]);
   *
   * //=point
   */
  function point(coordinates, properties, options) {
      if (options === void 0) { options = {}; }
      var geom = {
          type: "Point",
          coordinates: coordinates,
      };
      return feature(geom, properties, options);
  }
  exports.point = point;
  /**
   * Creates a {@link Point} {@link FeatureCollection} from an Array of Point coordinates.
   *
   * @name points
   * @param {Array<Array<number>>} coordinates an array of Points
   * @param {Object} [properties={}] Translate these properties to each Feature
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north]
   * associated with the FeatureCollection
   * @param {string|number} [options.id] Identifier associated with the FeatureCollection
   * @returns {FeatureCollection<Point>} Point Feature
   * @example
   * var points = turf.points([
   *   [-75, 39],
   *   [-80, 45],
   *   [-78, 50]
   * ]);
   *
   * //=points
   */
  function points(coordinates, properties, options) {
      if (options === void 0) { options = {}; }
      return featureCollection(coordinates.map(function (coords) {
          return point(coords, properties);
      }), options);
  }
  exports.points = points;
  /**
   * Creates a {@link Polygon} {@link Feature} from an Array of LinearRings.
   *
   * @name polygon
   * @param {Array<Array<Array<number>>>} coordinates an array of LinearRings
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the Feature
   * @returns {Feature<Polygon>} Polygon Feature
   * @example
   * var polygon = turf.polygon([[[-5, 52], [-4, 56], [-2, 51], [-7, 54], [-5, 52]]], { name: 'poly1' });
   *
   * //=polygon
   */
  function polygon(coordinates, properties, options) {
      if (options === void 0) { options = {}; }
      for (var _i = 0, coordinates_1 = coordinates; _i < coordinates_1.length; _i++) {
          var ring = coordinates_1[_i];
          if (ring.length < 4) {
              throw new Error("Each LinearRing of a Polygon must have 4 or more Positions.");
          }
          for (var j = 0; j < ring[ring.length - 1].length; j++) {
              // Check if first point of Polygon contains two numbers
              if (ring[ring.length - 1][j] !== ring[0][j]) {
                  throw new Error("First and last Position are not equivalent.");
              }
          }
      }
      var geom = {
          type: "Polygon",
          coordinates: coordinates,
      };
      return feature(geom, properties, options);
  }
  exports.polygon = polygon;
  /**
   * Creates a {@link Polygon} {@link FeatureCollection} from an Array of Polygon coordinates.
   *
   * @name polygons
   * @param {Array<Array<Array<Array<number>>>>} coordinates an array of Polygon coordinates
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the FeatureCollection
   * @returns {FeatureCollection<Polygon>} Polygon FeatureCollection
   * @example
   * var polygons = turf.polygons([
   *   [[[-5, 52], [-4, 56], [-2, 51], [-7, 54], [-5, 52]]],
   *   [[[-15, 42], [-14, 46], [-12, 41], [-17, 44], [-15, 42]]],
   * ]);
   *
   * //=polygons
   */
  function polygons(coordinates, properties, options) {
      if (options === void 0) { options = {}; }
      return featureCollection(coordinates.map(function (coords) {
          return polygon(coords, properties);
      }), options);
  }
  exports.polygons = polygons;
  /**
   * Creates a {@link LineString} {@link Feature} from an Array of Positions.
   *
   * @name lineString
   * @param {Array<Array<number>>} coordinates an array of Positions
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the Feature
   * @returns {Feature<LineString>} LineString Feature
   * @example
   * var linestring1 = turf.lineString([[-24, 63], [-23, 60], [-25, 65], [-20, 69]], {name: 'line 1'});
   * var linestring2 = turf.lineString([[-14, 43], [-13, 40], [-15, 45], [-10, 49]], {name: 'line 2'});
   *
   * //=linestring1
   * //=linestring2
   */
  function lineString(coordinates, properties, options) {
      if (options === void 0) { options = {}; }
      if (coordinates.length < 2) {
          throw new Error("coordinates must be an array of two or more positions");
      }
      var geom = {
          type: "LineString",
          coordinates: coordinates,
      };
      return feature(geom, properties, options);
  }
  exports.lineString = lineString;
  /**
   * Creates a {@link LineString} {@link FeatureCollection} from an Array of LineString coordinates.
   *
   * @name lineStrings
   * @param {Array<Array<Array<number>>>} coordinates an array of LinearRings
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north]
   * associated with the FeatureCollection
   * @param {string|number} [options.id] Identifier associated with the FeatureCollection
   * @returns {FeatureCollection<LineString>} LineString FeatureCollection
   * @example
   * var linestrings = turf.lineStrings([
   *   [[-24, 63], [-23, 60], [-25, 65], [-20, 69]],
   *   [[-14, 43], [-13, 40], [-15, 45], [-10, 49]]
   * ]);
   *
   * //=linestrings
   */
  function lineStrings(coordinates, properties, options) {
      if (options === void 0) { options = {}; }
      return featureCollection(coordinates.map(function (coords) {
          return lineString(coords, properties);
      }), options);
  }
  exports.lineStrings = lineStrings;
  /**
   * Takes one or more {@link Feature|Features} and creates a {@link FeatureCollection}.
   *
   * @name featureCollection
   * @param {Feature[]} features input features
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the Feature
   * @returns {FeatureCollection} FeatureCollection of Features
   * @example
   * var locationA = turf.point([-75.343, 39.984], {name: 'Location A'});
   * var locationB = turf.point([-75.833, 39.284], {name: 'Location B'});
   * var locationC = turf.point([-75.534, 39.123], {name: 'Location C'});
   *
   * var collection = turf.featureCollection([
   *   locationA,
   *   locationB,
   *   locationC
   * ]);
   *
   * //=collection
   */
  function featureCollection(features, options) {
      if (options === void 0) { options = {}; }
      var fc = { type: "FeatureCollection" };
      if (options.id) {
          fc.id = options.id;
      }
      if (options.bbox) {
          fc.bbox = options.bbox;
      }
      fc.features = features;
      return fc;
  }
  exports.featureCollection = featureCollection;
  /**
   * Creates a {@link Feature<MultiLineString>} based on a
   * coordinate array. Properties can be added optionally.
   *
   * @name multiLineString
   * @param {Array<Array<Array<number>>>} coordinates an array of LineStrings
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the Feature
   * @returns {Feature<MultiLineString>} a MultiLineString feature
   * @throws {Error} if no coordinates are passed
   * @example
   * var multiLine = turf.multiLineString([[[0,0],[10,10]]]);
   *
   * //=multiLine
   */
  function multiLineString(coordinates, properties, options) {
      if (options === void 0) { options = {}; }
      var geom = {
          type: "MultiLineString",
          coordinates: coordinates,
      };
      return feature(geom, properties, options);
  }
  exports.multiLineString = multiLineString;
  /**
   * Creates a {@link Feature<MultiPoint>} based on a
   * coordinate array. Properties can be added optionally.
   *
   * @name multiPoint
   * @param {Array<Array<number>>} coordinates an array of Positions
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the Feature
   * @returns {Feature<MultiPoint>} a MultiPoint feature
   * @throws {Error} if no coordinates are passed
   * @example
   * var multiPt = turf.multiPoint([[0,0],[10,10]]);
   *
   * //=multiPt
   */
  function multiPoint(coordinates, properties, options) {
      if (options === void 0) { options = {}; }
      var geom = {
          type: "MultiPoint",
          coordinates: coordinates,
      };
      return feature(geom, properties, options);
  }
  exports.multiPoint = multiPoint;
  /**
   * Creates a {@link Feature<MultiPolygon>} based on a
   * coordinate array. Properties can be added optionally.
   *
   * @name multiPolygon
   * @param {Array<Array<Array<Array<number>>>>} coordinates an array of Polygons
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the Feature
   * @returns {Feature<MultiPolygon>} a multipolygon feature
   * @throws {Error} if no coordinates are passed
   * @example
   * var multiPoly = turf.multiPolygon([[[[0,0],[0,10],[10,10],[10,0],[0,0]]]]);
   *
   * //=multiPoly
   *
   */
  function multiPolygon(coordinates, properties, options) {
      if (options === void 0) { options = {}; }
      var geom = {
          type: "MultiPolygon",
          coordinates: coordinates,
      };
      return feature(geom, properties, options);
  }
  exports.multiPolygon = multiPolygon;
  /**
   * Creates a {@link Feature<GeometryCollection>} based on a
   * coordinate array. Properties can be added optionally.
   *
   * @name geometryCollection
   * @param {Array<Geometry>} geometries an array of GeoJSON Geometries
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the Feature
   * @returns {Feature<GeometryCollection>} a GeoJSON GeometryCollection Feature
   * @example
   * var pt = turf.geometry("Point", [100, 0]);
   * var line = turf.geometry("LineString", [[101, 0], [102, 1]]);
   * var collection = turf.geometryCollection([pt, line]);
   *
   * // => collection
   */
  function geometryCollection(geometries, properties, options) {
      if (options === void 0) { options = {}; }
      var geom = {
          type: "GeometryCollection",
          geometries: geometries,
      };
      return feature(geom, properties, options);
  }
  exports.geometryCollection = geometryCollection;
  /**
   * Round number to precision
   *
   * @param {number} num Number
   * @param {number} [precision=0] Precision
   * @returns {number} rounded number
   * @example
   * turf.round(120.4321)
   * //=120
   *
   * turf.round(120.4321, 2)
   * //=120.43
   */
  function round(num, precision) {
      if (precision === void 0) { precision = 0; }
      if (precision && !(precision >= 0)) {
          throw new Error("precision must be a positive number");
      }
      var multiplier = Math.pow(10, precision || 0);
      return Math.round(num * multiplier) / multiplier;
  }
  exports.round = round;
  /**
   * Convert a distance measurement (assuming a spherical Earth) from radians to a more friendly unit.
   * Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
   *
   * @name radiansToLength
   * @param {number} radians in radians across the sphere
   * @param {string} [units="kilometers"] can be degrees, radians, miles, or kilometers inches, yards, metres,
   * meters, kilometres, kilometers.
   * @returns {number} distance
   */
  function radiansToLength(radians, units) {
      if (units === void 0) { units = "kilometers"; }
      var factor = exports.factors[units];
      if (!factor) {
          throw new Error(units + " units is invalid");
      }
      return radians * factor;
  }
  exports.radiansToLength = radiansToLength;
  /**
   * Convert a distance measurement (assuming a spherical Earth) from a real-world unit into radians
   * Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
   *
   * @name lengthToRadians
   * @param {number} distance in real units
   * @param {string} [units="kilometers"] can be degrees, radians, miles, or kilometers inches, yards, metres,
   * meters, kilometres, kilometers.
   * @returns {number} radians
   */
  function lengthToRadians(distance, units) {
      if (units === void 0) { units = "kilometers"; }
      var factor = exports.factors[units];
      if (!factor) {
          throw new Error(units + " units is invalid");
      }
      return distance / factor;
  }
  exports.lengthToRadians = lengthToRadians;
  /**
   * Convert a distance measurement (assuming a spherical Earth) from a real-world unit into degrees
   * Valid units: miles, nauticalmiles, inches, yards, meters, metres, centimeters, kilometres, feet
   *
   * @name lengthToDegrees
   * @param {number} distance in real units
   * @param {string} [units="kilometers"] can be degrees, radians, miles, or kilometers inches, yards, metres,
   * meters, kilometres, kilometers.
   * @returns {number} degrees
   */
  function lengthToDegrees(distance, units) {
      return radiansToDegrees(lengthToRadians(distance, units));
  }
  exports.lengthToDegrees = lengthToDegrees;
  /**
   * Converts any bearing angle from the north line direction (positive clockwise)
   * and returns an angle between 0-360 degrees (positive clockwise), 0 being the north line
   *
   * @name bearingToAzimuth
   * @param {number} bearing angle, between -180 and +180 degrees
   * @returns {number} angle between 0 and 360 degrees
   */
  function bearingToAzimuth(bearing) {
      var angle = bearing % 360;
      if (angle < 0) {
          angle += 360;
      }
      return angle;
  }
  exports.bearingToAzimuth = bearingToAzimuth;
  /**
   * Converts an angle in radians to degrees
   *
   * @name radiansToDegrees
   * @param {number} radians angle in radians
   * @returns {number} degrees between 0 and 360 degrees
   */
  function radiansToDegrees(radians) {
      var degrees = radians % (2 * Math.PI);
      return degrees * 180 / Math.PI;
  }
  exports.radiansToDegrees = radiansToDegrees;
  /**
   * Converts an angle in degrees to radians
   *
   * @name degreesToRadians
   * @param {number} degrees angle between 0 and 360 degrees
   * @returns {number} angle in radians
   */
  function degreesToRadians(degrees) {
      var radians = degrees % 360;
      return radians * Math.PI / 180;
  }
  exports.degreesToRadians = degreesToRadians;
  /**
   * Converts a length to the requested unit.
   * Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
   *
   * @param {number} length to be converted
   * @param {Units} [originalUnit="kilometers"] of the length
   * @param {Units} [finalUnit="kilometers"] returned unit
   * @returns {number} the converted length
   */
  function convertLength(length, originalUnit, finalUnit) {
      if (originalUnit === void 0) { originalUnit = "kilometers"; }
      if (finalUnit === void 0) { finalUnit = "kilometers"; }
      if (!(length >= 0)) {
          throw new Error("length must be a positive number");
      }
      return radiansToLength(lengthToRadians(length, originalUnit), finalUnit);
  }
  exports.convertLength = convertLength;
  /**
   * Converts a area to the requested unit.
   * Valid units: kilometers, kilometres, meters, metres, centimetres, millimeters, acres, miles, yards, feet, inches
   * @param {number} area to be converted
   * @param {Units} [originalUnit="meters"] of the distance
   * @param {Units} [finalUnit="kilometers"] returned unit
   * @returns {number} the converted distance
   */
  function convertArea(area, originalUnit, finalUnit) {
      if (originalUnit === void 0) { originalUnit = "meters"; }
      if (finalUnit === void 0) { finalUnit = "kilometers"; }
      if (!(area >= 0)) {
          throw new Error("area must be a positive number");
      }
      var startFactor = exports.areaFactors[originalUnit];
      if (!startFactor) {
          throw new Error("invalid original units");
      }
      var finalFactor = exports.areaFactors[finalUnit];
      if (!finalFactor) {
          throw new Error("invalid final units");
      }
      return (area / startFactor) * finalFactor;
  }
  exports.convertArea = convertArea;
  /**
   * isNumber
   *
   * @param {*} num Number to validate
   * @returns {boolean} true/false
   * @example
   * turf.isNumber(123)
   * //=true
   * turf.isNumber('foo')
   * //=false
   */
  function isNumber(num) {
      return !isNaN(num) && num !== null && !Array.isArray(num) && !/^\s*$/.test(num);
  }
  exports.isNumber = isNumber;
  /**
   * isObject
   *
   * @param {*} input variable to validate
   * @returns {boolean} true/false
   * @example
   * turf.isObject({elevation: 10})
   * //=true
   * turf.isObject('foo')
   * //=false
   */
  function isObject(input) {
      return (!!input) && (input.constructor === Object);
  }
  exports.isObject = isObject;
  /**
   * Validate BBox
   *
   * @private
   * @param {Array<number>} bbox BBox to validate
   * @returns {void}
   * @throws Error if BBox is not valid
   * @example
   * validateBBox([-180, -40, 110, 50])
   * //=OK
   * validateBBox([-180, -40])
   * //=Error
   * validateBBox('Foo')
   * //=Error
   * validateBBox(5)
   * //=Error
   * validateBBox(null)
   * //=Error
   * validateBBox(undefined)
   * //=Error
   */
  function validateBBox(bbox) {
      if (!bbox) {
          throw new Error("bbox is required");
      }
      if (!Array.isArray(bbox)) {
          throw new Error("bbox must be an Array");
      }
      if (bbox.length !== 4 && bbox.length !== 6) {
          throw new Error("bbox must be an Array of 4 or 6 numbers");
      }
      bbox.forEach(function (num) {
          if (!isNumber(num)) {
              throw new Error("bbox must only contain numbers");
          }
      });
  }
  exports.validateBBox = validateBBox;
  /**
   * Validate Id
   *
   * @private
   * @param {string|number} id Id to validate
   * @returns {void}
   * @throws Error if Id is not valid
   * @example
   * validateId([-180, -40, 110, 50])
   * //=Error
   * validateId([-180, -40])
   * //=Error
   * validateId('Foo')
   * //=OK
   * validateId(5)
   * //=OK
   * validateId(null)
   * //=Error
   * validateId(undefined)
   * //=Error
   */
  function validateId(id) {
      if (!id) {
          throw new Error("id is required");
      }
      if (["string", "number"].indexOf(typeof id) === -1) {
          throw new Error("id must be a number or a string");
      }
  }
  exports.validateId = validateId;
  // Deprecated methods
  function radians2degrees() {
      throw new Error("method has been renamed to `radiansToDegrees`");
  }
  exports.radians2degrees = radians2degrees;
  function degrees2radians() {
      throw new Error("method has been renamed to `degreesToRadians`");
  }
  exports.degrees2radians = degrees2radians;
  function distanceToDegrees() {
      throw new Error("method has been renamed to `lengthToDegrees`");
  }
  exports.distanceToDegrees = distanceToDegrees;
  function distanceToRadians() {
      throw new Error("method has been renamed to `lengthToRadians`");
  }
  exports.distanceToRadians = distanceToRadians;
  function radiansToDistance() {
      throw new Error("method has been renamed to `radiansToLength`");
  }
  exports.radiansToDistance = radiansToDistance;
  function bearingToAngle() {
      throw new Error("method has been renamed to `bearingToAzimuth`");
  }
  exports.bearingToAngle = bearingToAngle;
  function convertDistance() {
      throw new Error("method has been renamed to `convertLength`");
  }
  exports.convertDistance = convertDistance;
  });

  unwrapExports(helpers);
  var helpers_1 = helpers.earthRadius;
  var helpers_2 = helpers.factors;
  var helpers_3 = helpers.unitsFactors;
  var helpers_4 = helpers.areaFactors;
  var helpers_5 = helpers.feature;
  var helpers_6 = helpers.geometry;
  var helpers_7 = helpers.point;
  var helpers_8 = helpers.points;
  var helpers_9 = helpers.polygon;
  var helpers_10 = helpers.polygons;
  var helpers_11 = helpers.lineString;
  var helpers_12 = helpers.lineStrings;
  var helpers_13 = helpers.featureCollection;
  var helpers_14 = helpers.multiLineString;
  var helpers_15 = helpers.multiPoint;
  var helpers_16 = helpers.multiPolygon;
  var helpers_17 = helpers.geometryCollection;
  var helpers_18 = helpers.round;
  var helpers_19 = helpers.radiansToLength;
  var helpers_20 = helpers.lengthToRadians;
  var helpers_21 = helpers.lengthToDegrees;
  var helpers_22 = helpers.bearingToAzimuth;
  var helpers_23 = helpers.radiansToDegrees;
  var helpers_24 = helpers.degreesToRadians;
  var helpers_25 = helpers.convertLength;
  var helpers_26 = helpers.convertArea;
  var helpers_27 = helpers.isNumber;
  var helpers_28 = helpers.isObject;
  var helpers_29 = helpers.validateBBox;
  var helpers_30 = helpers.validateId;
  var helpers_31 = helpers.radians2degrees;
  var helpers_32 = helpers.degrees2radians;
  var helpers_33 = helpers.distanceToDegrees;
  var helpers_34 = helpers.distanceToRadians;
  var helpers_35 = helpers.radiansToDistance;
  var helpers_36 = helpers.bearingToAngle;
  var helpers_37 = helpers.convertDistance;

  var DrawEvent;

  (function (DrawEvent) {
    DrawEvent["CREATE"] = "draw.create";
    DrawEvent["DELETE"] = "draw.delete";
    DrawEvent["Move"] = "draw.move";
    DrawEvent["Edit"] = "draw.edit";
    DrawEvent["UPDATE"] = "draw.update";
    DrawEvent["CHANGE"] = "draw.change";
    DrawEvent["SELECTION_CHANGE"] = "draw.selectionchange";
    DrawEvent["MODE_CHANGE"] = "draw.modechange";
    DrawEvent["ACTIONABLE"] = "draw.actionable";
    DrawEvent["RENDER"] = "draw.render";
    DrawEvent["COMBINE_FEATURES"] = "draw.combine";
    DrawEvent["UNCOMBINE_FEATURES"] = "draw.uncombine";
  })(DrawEvent || (DrawEvent = {}));

  var DrawModes;

  (function (DrawModes) {
    DrawModes["DRAW_Circle"] = "draw_circle";
    DrawModes["DRAW_Rect"] = "draw_react";
    DrawModes["DRAW_LINE_STRING"] = "draw_line_string";
    DrawModes["DRAW_POLYGON"] = "draw_polygon";
    DrawModes["DRAW_POINT"] = "draw_point";
    DrawModes["SIMPLE_SELECT"] = "simple_select";
    DrawModes["DIRECT_SELECT"] = "direct_select";
    DrawModes["STATIC"] = "static";
  })(DrawModes || (DrawModes = {}));

  var FeatureType;

  (function (FeatureType) {
    FeatureType["FEATURE"] = "Feature";
    FeatureType["POLYGON"] = "Polygon";
    FeatureType["LINE_STRING"] = "LineString";
    FeatureType["POINT"] = "Point";
    FeatureType["FEATURE_COLLECTION"] = "FeatureCollection";
    FeatureType["MULTI_PREFIX"] = "Multi";
    FeatureType["MULTI_POINT"] = "MultiPoint";
    FeatureType["MULTI_LINE_STRING"] = "MultiLineString";
    FeatureType["MULTI_POLYGON"] = "MultiPolygon";
  })(FeatureType || (FeatureType = {}));

  var invariant = createCommonjsModule(function (module, exports) {
  Object.defineProperty(exports, "__esModule", { value: true });

  /**
   * Unwrap a coordinate from a Point Feature, Geometry or a single coordinate.
   *
   * @name getCoord
   * @param {Array<number>|Geometry<Point>|Feature<Point>} coord GeoJSON Point or an Array of numbers
   * @returns {Array<number>} coordinates
   * @example
   * var pt = turf.point([10, 10]);
   *
   * var coord = turf.getCoord(pt);
   * //= [10, 10]
   */
  function getCoord(coord) {
      if (!coord) {
          throw new Error("coord is required");
      }
      if (!Array.isArray(coord)) {
          if (coord.type === "Feature" && coord.geometry !== null && coord.geometry.type === "Point") {
              return coord.geometry.coordinates;
          }
          if (coord.type === "Point") {
              return coord.coordinates;
          }
      }
      if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
          return coord;
      }
      throw new Error("coord must be GeoJSON Point or an Array of numbers");
  }
  exports.getCoord = getCoord;
  /**
   * Unwrap coordinates from a Feature, Geometry Object or an Array
   *
   * @name getCoords
   * @param {Array<any>|Geometry|Feature} coords Feature, Geometry Object or an Array
   * @returns {Array<any>} coordinates
   * @example
   * var poly = turf.polygon([[[119.32, -8.7], [119.55, -8.69], [119.51, -8.54], [119.32, -8.7]]]);
   *
   * var coords = turf.getCoords(poly);
   * //= [[[119.32, -8.7], [119.55, -8.69], [119.51, -8.54], [119.32, -8.7]]]
   */
  function getCoords(coords) {
      if (Array.isArray(coords)) {
          return coords;
      }
      // Feature
      if (coords.type === "Feature") {
          if (coords.geometry !== null) {
              return coords.geometry.coordinates;
          }
      }
      else {
          // Geometry
          if (coords.coordinates) {
              return coords.coordinates;
          }
      }
      throw new Error("coords must be GeoJSON Feature, Geometry Object or an Array");
  }
  exports.getCoords = getCoords;
  /**
   * Checks if coordinates contains a number
   *
   * @name containsNumber
   * @param {Array<any>} coordinates GeoJSON Coordinates
   * @returns {boolean} true if Array contains a number
   */
  function containsNumber(coordinates) {
      if (coordinates.length > 1 && helpers.isNumber(coordinates[0]) && helpers.isNumber(coordinates[1])) {
          return true;
      }
      if (Array.isArray(coordinates[0]) && coordinates[0].length) {
          return containsNumber(coordinates[0]);
      }
      throw new Error("coordinates must only contain numbers");
  }
  exports.containsNumber = containsNumber;
  /**
   * Enforce expectations about types of GeoJSON objects for Turf.
   *
   * @name geojsonType
   * @param {GeoJSON} value any GeoJSON object
   * @param {string} type expected GeoJSON type
   * @param {string} name name of calling function
   * @throws {Error} if value is not the expected type.
   */
  function geojsonType(value, type, name) {
      if (!type || !name) {
          throw new Error("type and name required");
      }
      if (!value || value.type !== type) {
          throw new Error("Invalid input to " + name + ": must be a " + type + ", given " + value.type);
      }
  }
  exports.geojsonType = geojsonType;
  /**
   * Enforce expectations about types of {@link Feature} inputs for Turf.
   * Internally this uses {@link geojsonType} to judge geometry types.
   *
   * @name featureOf
   * @param {Feature} feature a feature with an expected geometry type
   * @param {string} type expected GeoJSON type
   * @param {string} name name of calling function
   * @throws {Error} error if value is not the expected type.
   */
  function featureOf(feature, type, name) {
      if (!feature) {
          throw new Error("No feature passed");
      }
      if (!name) {
          throw new Error(".featureOf() requires a name");
      }
      if (!feature || feature.type !== "Feature" || !feature.geometry) {
          throw new Error("Invalid input to " + name + ", Feature with geometry required");
      }
      if (!feature.geometry || feature.geometry.type !== type) {
          throw new Error("Invalid input to " + name + ": must be a " + type + ", given " + feature.geometry.type);
      }
  }
  exports.featureOf = featureOf;
  /**
   * Enforce expectations about types of {@link FeatureCollection} inputs for Turf.
   * Internally this uses {@link geojsonType} to judge geometry types.
   *
   * @name collectionOf
   * @param {FeatureCollection} featureCollection a FeatureCollection for which features will be judged
   * @param {string} type expected GeoJSON type
   * @param {string} name name of calling function
   * @throws {Error} if value is not the expected type.
   */
  function collectionOf(featureCollection, type, name) {
      if (!featureCollection) {
          throw new Error("No featureCollection passed");
      }
      if (!name) {
          throw new Error(".collectionOf() requires a name");
      }
      if (!featureCollection || featureCollection.type !== "FeatureCollection") {
          throw new Error("Invalid input to " + name + ", FeatureCollection required");
      }
      for (var _i = 0, _a = featureCollection.features; _i < _a.length; _i++) {
          var feature = _a[_i];
          if (!feature || feature.type !== "Feature" || !feature.geometry) {
              throw new Error("Invalid input to " + name + ", Feature with geometry required");
          }
          if (!feature.geometry || feature.geometry.type !== type) {
              throw new Error("Invalid input to " + name + ": must be a " + type + ", given " + feature.geometry.type);
          }
      }
  }
  exports.collectionOf = collectionOf;
  /**
   * Get Geometry from Feature or Geometry Object
   *
   * @param {Feature|Geometry} geojson GeoJSON Feature or Geometry Object
   * @returns {Geometry|null} GeoJSON Geometry Object
   * @throws {Error} if geojson is not a Feature or Geometry Object
   * @example
   * var point = {
   *   "type": "Feature",
   *   "properties": {},
   *   "geometry": {
   *     "type": "Point",
   *     "coordinates": [110, 40]
   *   }
   * }
   * var geom = turf.getGeom(point)
   * //={"type": "Point", "coordinates": [110, 40]}
   */
  function getGeom(geojson) {
      if (geojson.type === "Feature") {
          return geojson.geometry;
      }
      return geojson;
  }
  exports.getGeom = getGeom;
  /**
   * Get GeoJSON object's type, Geometry type is prioritize.
   *
   * @param {GeoJSON} geojson GeoJSON object
   * @param {string} [name="geojson"] name of the variable to display in error message
   * @returns {string} GeoJSON type
   * @example
   * var point = {
   *   "type": "Feature",
   *   "properties": {},
   *   "geometry": {
   *     "type": "Point",
   *     "coordinates": [110, 40]
   *   }
   * }
   * var geom = turf.getType(point)
   * //="Point"
   */
  function getType(geojson, name) {
      if (geojson.type === "FeatureCollection") {
          return "FeatureCollection";
      }
      if (geojson.type === "GeometryCollection") {
          return "GeometryCollection";
      }
      if (geojson.type === "Feature" && geojson.geometry !== null) {
          return geojson.geometry.type;
      }
      return geojson.type;
  }
  exports.getType = getType;
  });

  unwrapExports(invariant);
  var invariant_1 = invariant.getCoord;
  var invariant_2 = invariant.getCoords;
  var invariant_3 = invariant.containsNumber;
  var invariant_4 = invariant.geojsonType;
  var invariant_5 = invariant.featureOf;
  var invariant_6 = invariant.collectionOf;
  var invariant_7 = invariant.getGeom;
  var invariant_8 = invariant.getType;

  var destination_1 = createCommonjsModule(function (module, exports) {
  Object.defineProperty(exports, "__esModule", { value: true });
  // http://en.wikipedia.org/wiki/Haversine_formula
  // http://www.movable-type.co.uk/scripts/latlong.html


  /**
   * Takes a {@link Point} and calculates the location of a destination point given a distance in
   * degrees, radians, miles, or kilometers; and bearing in degrees.
   * This uses the [Haversine formula](http://en.wikipedia.org/wiki/Haversine_formula) to account for global curvature.
   *
   * @name destination
   * @param {Coord} origin starting point
   * @param {number} distance distance from the origin point
   * @param {number} bearing ranging from -180 to 180
   * @param {Object} [options={}] Optional parameters
   * @param {string} [options.units='kilometers'] miles, kilometers, degrees, or radians
   * @param {Object} [options.properties={}] Translate properties to Point
   * @returns {Feature<Point>} destination point
   * @example
   * var point = turf.point([-75.343, 39.984]);
   * var distance = 50;
   * var bearing = 90;
   * var options = {units: 'miles'};
   *
   * var destination = turf.destination(point, distance, bearing, options);
   *
   * //addToMap
   * var addToMap = [point, destination]
   * destination.properties['marker-color'] = '#f00';
   * point.properties['marker-color'] = '#0f0';
   */
  function destination(origin, distance, bearing, options) {
      if (options === void 0) { options = {}; }
      // Handle input
      var coordinates1 = invariant.getCoord(origin);
      var longitude1 = helpers.degreesToRadians(coordinates1[0]);
      var latitude1 = helpers.degreesToRadians(coordinates1[1]);
      var bearingRad = helpers.degreesToRadians(bearing);
      var radians = helpers.lengthToRadians(distance, options.units);
      // Main
      var latitude2 = Math.asin(Math.sin(latitude1) * Math.cos(radians) +
          Math.cos(latitude1) * Math.sin(radians) * Math.cos(bearingRad));
      var longitude2 = longitude1 + Math.atan2(Math.sin(bearingRad) * Math.sin(radians) * Math.cos(latitude1), Math.cos(radians) - Math.sin(latitude1) * Math.sin(latitude2));
      var lng = helpers.radiansToDegrees(longitude2);
      var lat = helpers.radiansToDegrees(latitude2);
      return helpers.point([lng, lat], options.properties);
  }
  exports.default = destination;
  });

  unwrapExports(destination_1);

  var circle_1 = createCommonjsModule(function (module, exports) {
  Object.defineProperty(exports, "__esModule", { value: true });


  /**
   * Takes a {@link Point} and calculates the circle polygon given a radius in degrees, radians, miles, or kilometers; and steps for precision.
   *
   * @name circle
   * @param {Feature<Point>|number[]} center center point
   * @param {number} radius radius of the circle
   * @param {Object} [options={}] Optional parameters
   * @param {number} [options.steps=64] number of steps
   * @param {string} [options.units='kilometers'] miles, kilometers, degrees, or radians
   * @param {Object} [options.properties={}] properties
   * @returns {Feature<Polygon>} circle polygon
   * @example
   * var center = [-75.343, 39.984];
   * var radius = 5;
   * var options = {steps: 10, units: 'kilometers', properties: {foo: 'bar'}};
   * var circle = turf.circle(center, radius, options);
   *
   * //addToMap
   * var addToMap = [turf.point(center), circle]
   */
  function circle(center, radius, options) {
      if (options === void 0) { options = {}; }
      // default params
      var steps = options.steps || 64;
      var properties = options.properties ? options.properties : (!Array.isArray(center) && center.type === 'Feature' && center.properties) ? center.properties : {};
      // main
      var coordinates = [];
      for (var i = 0; i < steps; i++) {
          coordinates.push(destination_1.default(center, radius, i * -360 / steps, options).geometry.coordinates);
      }
      coordinates.push(coordinates[0]);
      return helpers.polygon([coordinates], properties);
  }
  exports.default = circle;
  });

  var turfCircle = unwrapExports(circle_1);

  var distance_1 = createCommonjsModule(function (module, exports) {
  Object.defineProperty(exports, "__esModule", { value: true });


  //http://en.wikipedia.org/wiki/Haversine_formula
  //http://www.movable-type.co.uk/scripts/latlong.html
  /**
   * Calculates the distance between two {@link Point|points} in degrees, radians, miles, or kilometers.
   * This uses the [Haversine formula](http://en.wikipedia.org/wiki/Haversine_formula) to account for global curvature.
   *
   * @name distance
   * @param {Coord} from origin point
   * @param {Coord} to destination point
   * @param {Object} [options={}] Optional parameters
   * @param {string} [options.units='kilometers'] can be degrees, radians, miles, or kilometers
   * @returns {number} distance between the two points
   * @example
   * var from = turf.point([-75.343, 39.984]);
   * var to = turf.point([-75.534, 39.123]);
   * var options = {units: 'miles'};
   *
   * var distance = turf.distance(from, to, options);
   *
   * //addToMap
   * var addToMap = [from, to];
   * from.properties.distance = distance;
   * to.properties.distance = distance;
   */
  function distance(from, to, options) {
      if (options === void 0) { options = {}; }
      var coordinates1 = invariant.getCoord(from);
      var coordinates2 = invariant.getCoord(to);
      var dLat = helpers.degreesToRadians((coordinates2[1] - coordinates1[1]));
      var dLon = helpers.degreesToRadians((coordinates2[0] - coordinates1[0]));
      var lat1 = helpers.degreesToRadians(coordinates1[1]);
      var lat2 = helpers.degreesToRadians(coordinates2[1]);
      var a = Math.pow(Math.sin(dLat / 2), 2) +
          Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1) * Math.cos(lat2);
      return helpers.radiansToLength(2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)), options.units);
  }
  exports.default = distance;
  });

  var turfDistance = unwrapExports(distance_1);

  function createCircle(center, endPoint, options) {
    var radius = turfDistance(helpers_7(center), helpers_7(endPoint), options);
    var feature = turfCircle(center, radius, {
      units: options.units,
      steps: options.steps,
      properties: _objectSpread2(_objectSpread2({}, options), {}, {
        active: true,
        type: 'circle',
        radius: radius,
        startPoint: {
          lng: center[0],
          lat: center[1]
        },
        endPoint: {
          lng: endPoint[0],
          lat: endPoint[1]
        }
      })
    });
    return feature;
  }
  function createRect(startPoint, endPoint, options) {
    var minX = Math.min(startPoint[0], endPoint[0]);
    var minY = Math.min(startPoint[1], endPoint[1]);
    var maxX = Math.max(startPoint[0], endPoint[0]);
    var maxY = Math.max(startPoint[1], endPoint[1]);
    var feature = {
      type: 'Feature',
      properties: _objectSpread2({
        type: 'rect',
        active: true,
        startPoint: {
          lng: startPoint[0],
          lat: startPoint[1]
        },
        endPoint: {
          lng: endPoint[0],
          lat: endPoint[1]
        }
      }, options),
      geometry: {
        type: 'Polygon',
        coordinates: [[[minX, minY], [minX, maxY], [maxX, maxY], [maxX, minY], [minX, minY]]]
      }
    };
    return feature;
  }
  function createPolygon(points, options) {
    var coords = points.map(function (p) {
      return [p.lng, p.lat];
    });

    if (points.length < 2) {
      return helpers_7(coords[0], options);
    } else if (points.length < 3) {
      return helpers_11(coords, options);
    } else {
      coords.push(coords[0]);
      return helpers_9([coords], options);
    }
  }
  function createLine(points, options) {
    var coords = points.map(function (p) {
      return [p.lng, p.lat];
    });

    if (points.length < 2) {
      return helpers_7(coords[0], options);
    } else {
      return helpers_11(coords, options);
    }
  }
  function createPoint(points) {
    var features = points.map(function (p, index) {
      return helpers_7([p.lng, p.lat], {
        active: true,
        id: index.toString()
      });
    });
    return helpers_13(features);
  }

  function moveFeatures (features, delta) {
    features.forEach(function (feature) {
      var geometry = feature.geometry;
      var nextCoord;
      var type = geometry.type,
          coordinates = geometry.coordinates;

      switch (type) {
        case FeatureType.POINT:
          nextCoord = movePoint(coordinates, delta);
          break;

        case FeatureType.LINE_STRING:
        case FeatureType.MULTI_POINT:
          nextCoord = moveRing(coordinates, delta);
          break;

        case FeatureType.POLYGON:
        case FeatureType.MULTI_LINE_STRING:
          nextCoord = moveMultiPolygon(coordinates, delta);
          break;

        case FeatureType.MULTI_POLYGON:
          nextCoord = coordinates.map(function (mult) {
            return moveMultiPolygon(mult, delta);
          });
          break;
      }

      if (nextCoord) {
        geometry.coordinates = nextCoord;
      }
    });
    return features;
  }
  function movePoint(coord, delta) {
    return [coord[0] + delta.lng, coord[1] + delta.lat];
  }
  function moveRing(coords, delta) {
    return coords.map(function (coord) {
      return movePoint(coord, delta);
    });
  }
  function moveMultiPolygon(mult, delta) {
    return mult.map(function (ring) {
      return moveRing(ring, delta);
    });
  }

  function renderFeature(fe, style) {
    var _fe$features$, _fe$features$$geometr;

    var type = (_fe$features$ = fe.features[0]) === null || _fe$features$ === void 0 ? void 0 : (_fe$features$$geometr = _fe$features$.geometry) === null || _fe$features$$geometr === void 0 ? void 0 : _fe$features$$geometr.type;
    var layers;

    switch (type) {
      case 'Point':
        layers = drawPoint(fe, style.point);
        break;

      case 'LineString':
        layers = drawLine(fe, style.line);
        break;

      case 'Polygon':
        layers = drawPolyon(fe, style.polygon);
        break;
    }

    return layers;
  }

  function drawPoint(fe, style) {
    var layer = new l7.PointLayer({
      zIndex: 2,
      pickingBuffer: 3
    }).source(fe).shape('circle').color(style.color).size(style.size).style(style.style);
    return [layer];
  }

  function drawLine(fe, style) {
    var layer = new l7.LineLayer({
      pickingBuffer: 3
    }).source(fe).shape('line').color(style.color).size(style.size).style(style.style);
    return [layer];
  }

  function drawPolyon(fe, style) {
    var fill = new l7.PolygonLayer().source(fe).shape('fill').color(style.color).size(style.size).style({
      opacity: style.style.opacity
    });
    var line = new l7.PolygonLayer().source(fe).shape('line').color(style.style.stroke).size(style.style.strokeWidth).style({
      opacity: style.style.strokeOpacity,
      lineType: style.style.lineType,
      dashArray: style.style.dashArray
    });
    return [fill, line];
  }

  var BaseRenderLayer = /*#__PURE__*/function () {
    function BaseRenderLayer(draw) {
      _classCallCheck(this, BaseRenderLayer);

      this.drawLayers = [];
      this.draw = draw;
    }

    _createClass(BaseRenderLayer, [{
      key: "update",
      value: function update(feature) {
        if (this.drawLayers.length > 0) {
          this.updateData(feature);
        }

        this.removeLayers();
        var style = this.draw.getStyle('normal');
        this.drawLayers = renderFeature(feature, style);
        this.addLayers();
      }
    }, {
      key: "on",
      value: function on(type, handler) {
        var layer = this.drawLayers[0];
        layer.on(type, handler);
      }
    }, {
      key: "off",
      value: function off(type, handler) {
        var layer = this.drawLayers[0];
        layer.off(type, handler);
      }
    }, {
      key: "emit",
      value: function emit(type, e) {
        var layer = this.drawLayers[0];
        layer.emit(type, e);
      }
    }, {
      key: "updateData",
      value: function updateData(data) {
        if (this.drawLayers.length === 0) {
          this.update(data);
        }

        this.drawLayers.forEach(function (layer) {
          return layer.setData(data);
        });
      }
    }, {
      key: "destroy",
      value: function destroy() {
        this.removeLayers();
      }
    }, {
      key: "removeLayers",
      value: function removeLayers() {
        var _this = this;

        if (this.drawLayers.length !== 0) {
          this.drawLayers.forEach(function (layer) {
            return _this.draw.scene.removeLayer(layer);
          });
        }
      }
    }, {
      key: "addLayers",
      value: function addLayers() {
        var _this2 = this;

        this.drawLayers.forEach(function (layer) {
          return _this2.draw.scene.addLayer(layer);
        });
      }
    }, {
      key: "show",
      value: function show() {
        this.drawLayers.forEach(function (layer) {
          return layer.show();
        });
      }
    }, {
      key: "hide",
      value: function hide() {
        this.drawLayers.forEach(function (layer) {
          return layer.hide();
        });
      }
    }]);

    return BaseRenderLayer;
  }();

  var DrawLayer = /*#__PURE__*/function (_BaseRender) {
    _inherits(DrawLayer, _BaseRender);

    var _super = _createSuper(DrawLayer);

    function DrawLayer() {
      var _this;

      _classCallCheck(this, DrawLayer);

      _this = _super.apply(this, arguments);

      _this.onMouseMove = function (e) {
        _this.draw.setCursor('move');

        _this.draw.selectMode.enable();
      };

      _this.onUnMouseMove = function (e) {
        _this.draw.resetCursor();

        _this.draw.selectMode.disable();
      };

      _this.onClick = function (e) {
        _this.draw.selectMode.disable();

        _this.draw.editMode.enable();

        _this.disableSelect();

        _this.draw.resetCursor();

        _this.enableEdit();

        _this.draw.setCurrentFeature(e.feature);

        _this.draw.emit(DrawEvent.MODE_CHANGE, DrawModes.DIRECT_SELECT);
      };

      _this.onUnClick = function (e) {
        _this.draw.selectMode.disable();

        _this.draw.editMode.disable();

        _this.draw.source.setFeatureUnActive(_this.draw.getCurrentFeature());

        _this.disableSelect();

        _this.disableEdit();

        _this.hide();

        _this.draw.emit(DrawEvent.MODE_CHANGE, DrawModes.STATIC);
      };

      return _this;
    }

    _createClass(DrawLayer, [{
      key: "update",
      value: function update(feature) {
        this.removeLayers();
        var style = this.draw.getStyle('active');
        this.drawLayers = renderFeature(feature, style);
        this.addLayers();
      }
    }, {
      key: "enableSelect",
      value: function enableSelect() {
        this.show();

        if (this.isEnableDrag) {
          return;
        }

        var layer = this.drawLayers[0];
        layer.on('mouseenter', this.onMouseMove);
        layer.on('mouseout', this.onUnMouseMove);

        if (this.draw.editEnable) {
          layer.on('click', this.onClick);
        }

        layer.on('unclick', this.onUnClick);
        this.isEnableDrag = true;
      }
    }, {
      key: "disableSelect",
      value: function disableSelect() {
        if (!this.isEnableDrag) {
          return;
        }

        var layer = this.drawLayers[0];
        layer.off('mouseenter', this.onMouseMove);
        layer.off('mouseout', this.onUnMouseMove);
        layer.off('click', this.onClick);
        layer.off('unclick', this.onUnClick);
        this.isEnableDrag = false;
      }
    }, {
      key: "enableEdit",
      value: function enableEdit() {
        if (this.isEnableEdit) {
          return;
        }

        var layer = this.drawLayers[0];
        layer.on('unclick', this.onUnClick);
        this.isEnableDrag = true;
      }
    }, {
      key: "disableEdit",
      value: function disableEdit() {
        if (!this.isEnableEdit) {
          return;
        }

        var layer = this.drawLayers[0];
        layer.off('unclick', this.onUnClick);
        this.isEnableDrag = false;
      }
    }]);

    return DrawLayer;
  }(BaseRenderLayer);

  var DrawResultLayer = /*#__PURE__*/function (_BaseRender) {
    _inherits(DrawResultLayer, _BaseRender);

    var _super = _createSuper(DrawResultLayer);

    function DrawResultLayer() {
      var _this;

      _classCallCheck(this, DrawResultLayer);

      _this = _super.apply(this, arguments);

      _this.onClick = function (e) {
        _this.draw.source.setFeatureUnActive(_this.draw.getCurrentFeature());

        _this.draw.setCurrentFeature(e.feature);

        _this.draw.source.setFeatureActive(e.feature);

        _this.updateData(_this.draw.source.data);

        _this.draw.emit(DrawEvent.MODE_CHANGE, DrawModes.SIMPLE_SELECT);
      };

      _this.onDeleteClick = function (e) {
        _this.draw.source.removeFeature(e.feature);

        _this.updateData(_this.draw.source.data);
      };

      return _this;
    }

    _createClass(DrawResultLayer, [{
      key: "update",
      value: function update(feature) {
        if (this.drawLayers.length > 0) {
          this.updateData(feature);
          return;
        }

        this.removeLayers();
        var style = this.draw.getStyle('normal');
        this.drawLayers = renderFeature(feature, style);
        this.addFilter();
        this.addLayers();
      }
    }, {
      key: "enableSelect",
      value: function enableSelect() {
        if (this.isEnableDrag) {
          return;
        }

        if (!this.draw.selectEnable) {
          return;
        }

        var layer = this.drawLayers[0];
        layer.on('click', this.onClick);
        this.isEnableDrag = true;
      }
    }, {
      key: "disableSelect",
      value: function disableSelect() {
        if (!this.isEnableDrag) {
          return;
        }

        var layer = this.drawLayers[0];
        layer.off('click', this.onClick);
        this.isEnableDrag = false;
      }
    }, {
      key: "enableDelete",
      value: function enableDelete() {
        this.disableSelect();
        var layer = this.drawLayers[0];
        layer.on('click', this.onDeleteClick);
      }
    }, {
      key: "disableDelete",
      value: function disableDelete() {
        var layer = this.drawLayers[0];
        layer.off('click', this.onDeleteClick);
      }
    }, {
      key: "addFilter",
      value: function addFilter() {
        this.drawLayers.forEach(function (layer) {
          return layer.filter('active', function (active) {
            return !active;
          });
        });
      }
    }]);

    return DrawResultLayer;
  }(BaseRenderLayer);

  var DrawVertexLayer = /*#__PURE__*/function (_BaseRender) {
    _inherits(DrawVertexLayer, _BaseRender);

    var _super = _createSuper(DrawVertexLayer);

    function DrawVertexLayer() {
      var _this;

      _classCallCheck(this, DrawVertexLayer);

      _this = _super.apply(this, arguments);

      _this.onMouseEnter = function (e) {
        _this.draw.setCursor('move');

        _this.draw.setCurrentVertex(e.feature);

        _this.draw.editMode.enable();
      };

      _this.onMouseOut = function (e) {
        _this.draw.resetCursor();

        _this.draw.editMode.disable();
      };

      _this.onClick = function (e) {
        _this.draw.setCurrentVertex(e.feature);

        _this.draw.editMode.enable();
      };

      return _this;
    }

    _createClass(DrawVertexLayer, [{
      key: "update",
      value: function update(feature) {
        this.removeLayers();
        var style = this.draw.getStyle('active');
        this.drawLayers = renderFeature(feature, style);
        this.addLayers();
      }
    }, {
      key: "enableSelect",
      value: function enableSelect() {
        return;
      }
    }, {
      key: "disableSelect",
      value: function disableSelect() {
        return;
      }
    }, {
      key: "enableEdit",
      value: function enableEdit() {
        if (this.isEnableEdit) {
          return;
        }

        var layer = this.drawLayers[0];
        layer.on('mouseenter', this.onMouseEnter);
        layer.on('mouseout', this.onMouseOut);
        layer.on('click', this.onClick);
        this.isEnableEdit = true;
      }
    }, {
      key: "disableEdit",
      value: function disableEdit() {
        if (!this.isEnableEdit) {
          return;
        }

        var layer = this.drawLayers[0];
        layer.off('mouseenter', this.onMouseEnter);
        layer.off('mouseout', this.onMouseOut);
        layer.off('click', this.onClick);
        this.isEnableEdit = false;
      }
    }]);

    return DrawVertexLayer;
  }(BaseRenderLayer);

  var eventemitter3 = createCommonjsModule(function (module) {

  var has = Object.prototype.hasOwnProperty
    , prefix = '~';

  /**
   * Constructor to create a storage for our `EE` objects.
   * An `Events` instance is a plain object whose properties are event names.
   *
   * @constructor
   * @private
   */
  function Events() {}

  //
  // We try to not inherit from `Object.prototype`. In some engines creating an
  // instance in this way is faster than calling `Object.create(null)` directly.
  // If `Object.create(null)` is not supported we prefix the event names with a
  // character to make sure that the built-in object properties are not
  // overridden or used as an attack vector.
  //
  if (Object.create) {
    Events.prototype = Object.create(null);

    //
    // This hack is needed because the `__proto__` property is still inherited in
    // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
    //
    if (!new Events().__proto__) prefix = false;
  }

  /**
   * Representation of a single event listener.
   *
   * @param {Function} fn The listener function.
   * @param {*} context The context to invoke the listener with.
   * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
   * @constructor
   * @private
   */
  function EE(fn, context, once) {
    this.fn = fn;
    this.context = context;
    this.once = once || false;
  }

  /**
   * Add a listener for a given event.
   *
   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn The listener function.
   * @param {*} context The context to invoke the listener with.
   * @param {Boolean} once Specify if the listener is a one-time listener.
   * @returns {EventEmitter}
   * @private
   */
  function addListener(emitter, event, fn, context, once) {
    if (typeof fn !== 'function') {
      throw new TypeError('The listener must be a function');
    }

    var listener = new EE(fn, context || emitter, once)
      , evt = prefix ? prefix + event : event;

    if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
    else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
    else emitter._events[evt] = [emitter._events[evt], listener];

    return emitter;
  }

  /**
   * Clear event by name.
   *
   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
   * @param {(String|Symbol)} evt The Event name.
   * @private
   */
  function clearEvent(emitter, evt) {
    if (--emitter._eventsCount === 0) emitter._events = new Events();
    else delete emitter._events[evt];
  }

  /**
   * Minimal `EventEmitter` interface that is molded against the Node.js
   * `EventEmitter` interface.
   *
   * @constructor
   * @public
   */
  function EventEmitter() {
    this._events = new Events();
    this._eventsCount = 0;
  }

  /**
   * Return an array listing the events for which the emitter has registered
   * listeners.
   *
   * @returns {Array}
   * @public
   */
  EventEmitter.prototype.eventNames = function eventNames() {
    var names = []
      , events
      , name;

    if (this._eventsCount === 0) return names;

    for (name in (events = this._events)) {
      if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
    }

    if (Object.getOwnPropertySymbols) {
      return names.concat(Object.getOwnPropertySymbols(events));
    }

    return names;
  };

  /**
   * Return the listeners registered for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @returns {Array} The registered listeners.
   * @public
   */
  EventEmitter.prototype.listeners = function listeners(event) {
    var evt = prefix ? prefix + event : event
      , handlers = this._events[evt];

    if (!handlers) return [];
    if (handlers.fn) return [handlers.fn];

    for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
      ee[i] = handlers[i].fn;
    }

    return ee;
  };

  /**
   * Return the number of listeners listening to a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @returns {Number} The number of listeners.
   * @public
   */
  EventEmitter.prototype.listenerCount = function listenerCount(event) {
    var evt = prefix ? prefix + event : event
      , listeners = this._events[evt];

    if (!listeners) return 0;
    if (listeners.fn) return 1;
    return listeners.length;
  };

  /**
   * Calls each of the listeners registered for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @returns {Boolean} `true` if the event had listeners, else `false`.
   * @public
   */
  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
    var evt = prefix ? prefix + event : event;

    if (!this._events[evt]) return false;

    var listeners = this._events[evt]
      , len = arguments.length
      , args
      , i;

    if (listeners.fn) {
      if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);

      switch (len) {
        case 1: return listeners.fn.call(listeners.context), true;
        case 2: return listeners.fn.call(listeners.context, a1), true;
        case 3: return listeners.fn.call(listeners.context, a1, a2), true;
        case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
        case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
        case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
      }

      for (i = 1, args = new Array(len -1); i < len; i++) {
        args[i - 1] = arguments[i];
      }

      listeners.fn.apply(listeners.context, args);
    } else {
      var length = listeners.length
        , j;

      for (i = 0; i < length; i++) {
        if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);

        switch (len) {
          case 1: listeners[i].fn.call(listeners[i].context); break;
          case 2: listeners[i].fn.call(listeners[i].context, a1); break;
          case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
          case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
          default:
            if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
              args[j - 1] = arguments[j];
            }

            listeners[i].fn.apply(listeners[i].context, args);
        }
      }
    }

    return true;
  };

  /**
   * Add a listener for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn The listener function.
   * @param {*} [context=this] The context to invoke the listener with.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.on = function on(event, fn, context) {
    return addListener(this, event, fn, context, false);
  };

  /**
   * Add a one-time listener for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn The listener function.
   * @param {*} [context=this] The context to invoke the listener with.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.once = function once(event, fn, context) {
    return addListener(this, event, fn, context, true);
  };

  /**
   * Remove the listeners of a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn Only remove the listeners that match this function.
   * @param {*} context Only remove the listeners that have this context.
   * @param {Boolean} once Only remove one-time listeners.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
    var evt = prefix ? prefix + event : event;

    if (!this._events[evt]) return this;
    if (!fn) {
      clearEvent(this, evt);
      return this;
    }

    var listeners = this._events[evt];

    if (listeners.fn) {
      if (
        listeners.fn === fn &&
        (!once || listeners.once) &&
        (!context || listeners.context === context)
      ) {
        clearEvent(this, evt);
      }
    } else {
      for (var i = 0, events = [], length = listeners.length; i < length; i++) {
        if (
          listeners[i].fn !== fn ||
          (once && !listeners[i].once) ||
          (context && listeners[i].context !== context)
        ) {
          events.push(listeners[i]);
        }
      }

      //
      // Reset the array, or remove it completely if we have no more listeners.
      //
      if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
      else clearEvent(this, evt);
    }

    return this;
  };

  /**
   * Remove all listeners, or those of the specified event.
   *
   * @param {(String|Symbol)} [event] The event name.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
    var evt;

    if (event) {
      evt = prefix ? prefix + event : event;
      if (this._events[evt]) clearEvent(this, evt);
    } else {
      this._events = new Events();
      this._eventsCount = 0;
    }

    return this;
  };

  //
  // Alias methods names because people roll like that.
  //
  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
  EventEmitter.prototype.addListener = EventEmitter.prototype.on;

  //
  // Expose the prefix.
  //
  EventEmitter.prefixed = prefix;

  //
  // Allow `EventEmitter` to be imported as module namespace.
  //
  EventEmitter.EventEmitter = EventEmitter;

  //
  // Expose the module.
  //
  {
    module.exports = EventEmitter;
  }
  });
  var eventemitter3_1 = eventemitter3.EventEmitter;

  /**
   * Removes all key-value entries from the list cache.
   *
   * @private
   * @name clear
   * @memberOf ListCache
   */
  function listCacheClear() {
    this.__data__ = [];
    this.size = 0;
  }

  var _listCacheClear = listCacheClear;

  /**
   * Performs a
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * comparison between two values to determine if they are equivalent.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   * @example
   *
   * var object = { 'a': 1 };
   * var other = { 'a': 1 };
   *
   * _.eq(object, object);
   * // => true
   *
   * _.eq(object, other);
   * // => false
   *
   * _.eq('a', 'a');
   * // => true
   *
   * _.eq('a', Object('a'));
   * // => false
   *
   * _.eq(NaN, NaN);
   * // => true
   */
  function eq(value, other) {
    return value === other || (value !== value && other !== other);
  }

  var eq_1 = eq;

  /**
   * Gets the index at which the `key` is found in `array` of key-value pairs.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} key The key to search for.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
  function assocIndexOf(array, key) {
    var length = array.length;
    while (length--) {
      if (eq_1(array[length][0], key)) {
        return length;
      }
    }
    return -1;
  }

  var _assocIndexOf = assocIndexOf;

  /** Used for built-in method references. */
  var arrayProto = Array.prototype;

  /** Built-in value references. */
  var splice = arrayProto.splice;

  /**
   * Removes `key` and its value from the list cache.
   *
   * @private
   * @name delete
   * @memberOf ListCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function listCacheDelete(key) {
    var data = this.__data__,
        index = _assocIndexOf(data, key);

    if (index < 0) {
      return false;
    }
    var lastIndex = data.length - 1;
    if (index == lastIndex) {
      data.pop();
    } else {
      splice.call(data, index, 1);
    }
    --this.size;
    return true;
  }

  var _listCacheDelete = listCacheDelete;

  /**
   * Gets the list cache value for `key`.
   *
   * @private
   * @name get
   * @memberOf ListCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function listCacheGet(key) {
    var data = this.__data__,
        index = _assocIndexOf(data, key);

    return index < 0 ? undefined : data[index][1];
  }

  var _listCacheGet = listCacheGet;

  /**
   * Checks if a list cache value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf ListCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function listCacheHas(key) {
    return _assocIndexOf(this.__data__, key) > -1;
  }

  var _listCacheHas = listCacheHas;

  /**
   * Sets the list cache `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf ListCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the list cache instance.
   */
  function listCacheSet(key, value) {
    var data = this.__data__,
        index = _assocIndexOf(data, key);

    if (index < 0) {
      ++this.size;
      data.push([key, value]);
    } else {
      data[index][1] = value;
    }
    return this;
  }

  var _listCacheSet = listCacheSet;

  /**
   * Creates an list cache object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function ListCache(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;

    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }

  // Add methods to `ListCache`.
  ListCache.prototype.clear = _listCacheClear;
  ListCache.prototype['delete'] = _listCacheDelete;
  ListCache.prototype.get = _listCacheGet;
  ListCache.prototype.has = _listCacheHas;
  ListCache.prototype.set = _listCacheSet;

  var _ListCache = ListCache;

  /**
   * Removes all key-value entries from the stack.
   *
   * @private
   * @name clear
   * @memberOf Stack
   */
  function stackClear() {
    this.__data__ = new _ListCache;
    this.size = 0;
  }

  var _stackClear = stackClear;

  /**
   * Removes `key` and its value from the stack.
   *
   * @private
   * @name delete
   * @memberOf Stack
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function stackDelete(key) {
    var data = this.__data__,
        result = data['delete'](key);

    this.size = data.size;
    return result;
  }

  var _stackDelete = stackDelete;

  /**
   * Gets the stack value for `key`.
   *
   * @private
   * @name get
   * @memberOf Stack
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function stackGet(key) {
    return this.__data__.get(key);
  }

  var _stackGet = stackGet;

  /**
   * Checks if a stack value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf Stack
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function stackHas(key) {
    return this.__data__.has(key);
  }

  var _stackHas = stackHas;

  /** Detect free variable `global` from Node.js. */
  var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;

  var _freeGlobal = freeGlobal;

  /** Detect free variable `self`. */
  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

  /** Used as a reference to the global object. */
  var root = _freeGlobal || freeSelf || Function('return this')();

  var _root = root;

  /** Built-in value references. */
  var Symbol$1 = _root.Symbol;

  var _Symbol = Symbol$1;

  /** Used for built-in method references. */
  var objectProto = Object.prototype;

  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;

  /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
  var nativeObjectToString = objectProto.toString;

  /** Built-in value references. */
  var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;

  /**
   * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
   *
   * @private
   * @param {*} value The value to query.
   * @returns {string} Returns the raw `toStringTag`.
   */
  function getRawTag(value) {
    var isOwn = hasOwnProperty.call(value, symToStringTag),
        tag = value[symToStringTag];

    try {
      value[symToStringTag] = undefined;
      var unmasked = true;
    } catch (e) {}

    var result = nativeObjectToString.call(value);
    if (unmasked) {
      if (isOwn) {
        value[symToStringTag] = tag;
      } else {
        delete value[symToStringTag];
      }
    }
    return result;
  }

  var _getRawTag = getRawTag;

  /** Used for built-in method references. */
  var objectProto$1 = Object.prototype;

  /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
  var nativeObjectToString$1 = objectProto$1.toString;

  /**
   * Converts `value` to a string using `Object.prototype.toString`.
   *
   * @private
   * @param {*} value The value to convert.
   * @returns {string} Returns the converted string.
   */
  function objectToString(value) {
    return nativeObjectToString$1.call(value);
  }

  var _objectToString = objectToString;

  /** `Object#toString` result references. */
  var nullTag = '[object Null]',
      undefinedTag = '[object Undefined]';

  /** Built-in value references. */
  var symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined;

  /**
   * The base implementation of `getTag` without fallbacks for buggy environments.
   *
   * @private
   * @param {*} value The value to query.
   * @returns {string} Returns the `toStringTag`.
   */
  function baseGetTag(value) {
    if (value == null) {
      return value === undefined ? undefinedTag : nullTag;
    }
    return (symToStringTag$1 && symToStringTag$1 in Object(value))
      ? _getRawTag(value)
      : _objectToString(value);
  }

  var _baseGetTag = baseGetTag;

  /**
   * Checks if `value` is the
   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
   * @example
   *
   * _.isObject({});
   * // => true
   *
   * _.isObject([1, 2, 3]);
   * // => true
   *
   * _.isObject(_.noop);
   * // => true
   *
   * _.isObject(null);
   * // => false
   */
  function isObject(value) {
    var type = typeof value;
    return value != null && (type == 'object' || type == 'function');
  }

  var isObject_1 = isObject;

  /** `Object#toString` result references. */
  var asyncTag = '[object AsyncFunction]',
      funcTag = '[object Function]',
      genTag = '[object GeneratorFunction]',
      proxyTag = '[object Proxy]';

  /**
   * Checks if `value` is classified as a `Function` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
   * @example
   *
   * _.isFunction(_);
   * // => true
   *
   * _.isFunction(/abc/);
   * // => false
   */
  function isFunction(value) {
    if (!isObject_1(value)) {
      return false;
    }
    // The use of `Object#toString` avoids issues with the `typeof` operator
    // in Safari 9 which returns 'object' for typed arrays and other constructors.
    var tag = _baseGetTag(value);
    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
  }

  var isFunction_1 = isFunction;

  /** Used to detect overreaching core-js shims. */
  var coreJsData = _root['__core-js_shared__'];

  var _coreJsData = coreJsData;

  /** Used to detect methods masquerading as native. */
  var maskSrcKey = (function() {
    var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || '');
    return uid ? ('Symbol(src)_1.' + uid) : '';
  }());

  /**
   * Checks if `func` has its source masked.
   *
   * @private
   * @param {Function} func The function to check.
   * @returns {boolean} Returns `true` if `func` is masked, else `false`.
   */
  function isMasked(func) {
    return !!maskSrcKey && (maskSrcKey in func);
  }

  var _isMasked = isMasked;

  /** Used for built-in method references. */
  var funcProto = Function.prototype;

  /** Used to resolve the decompiled source of functions. */
  var funcToString = funcProto.toString;

  /**
   * Converts `func` to its source code.
   *
   * @private
   * @param {Function} func The function to convert.
   * @returns {string} Returns the source code.
   */
  function toSource(func) {
    if (func != null) {
      try {
        return funcToString.call(func);
      } catch (e) {}
      try {
        return (func + '');
      } catch (e) {}
    }
    return '';
  }

  var _toSource = toSource;

  /**
   * Used to match `RegExp`
   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
   */
  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

  /** Used to detect host constructors (Safari). */
  var reIsHostCtor = /^\[object .+?Constructor\]$/;

  /** Used for built-in method references. */
  var funcProto$1 = Function.prototype,
      objectProto$2 = Object.prototype;

  /** Used to resolve the decompiled source of functions. */
  var funcToString$1 = funcProto$1.toString;

  /** Used to check objects for own properties. */
  var hasOwnProperty$1 = objectProto$2.hasOwnProperty;

  /** Used to detect if a method is native. */
  var reIsNative = RegExp('^' +
    funcToString$1.call(hasOwnProperty$1).replace(reRegExpChar, '\\$&')
    .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
  );

  /**
   * The base implementation of `_.isNative` without bad shim checks.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a native function,
   *  else `false`.
   */
  function baseIsNative(value) {
    if (!isObject_1(value) || _isMasked(value)) {
      return false;
    }
    var pattern = isFunction_1(value) ? reIsNative : reIsHostCtor;
    return pattern.test(_toSource(value));
  }

  var _baseIsNative = baseIsNative;

  /**
   * Gets the value at `key` of `object`.
   *
   * @private
   * @param {Object} [object] The object to query.
   * @param {string} key The key of the property to get.
   * @returns {*} Returns the property value.
   */
  function getValue(object, key) {
    return object == null ? undefined : object[key];
  }

  var _getValue = getValue;

  /**
   * Gets the native function at `key` of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {string} key The key of the method to get.
   * @returns {*} Returns the function if it's native, else `undefined`.
   */
  function getNative(object, key) {
    var value = _getValue(object, key);
    return _baseIsNative(value) ? value : undefined;
  }

  var _getNative = getNative;

  /* Built-in method references that are verified to be native. */
  var Map = _getNative(_root, 'Map');

  var _Map = Map;

  /* Built-in method references that are verified to be native. */
  var nativeCreate = _getNative(Object, 'create');

  var _nativeCreate = nativeCreate;

  /**
   * Removes all key-value entries from the hash.
   *
   * @private
   * @name clear
   * @memberOf Hash
   */
  function hashClear() {
    this.__data__ = _nativeCreate ? _nativeCreate(null) : {};
    this.size = 0;
  }

  var _hashClear = hashClear;

  /**
   * Removes `key` and its value from the hash.
   *
   * @private
   * @name delete
   * @memberOf Hash
   * @param {Object} hash The hash to modify.
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function hashDelete(key) {
    var result = this.has(key) && delete this.__data__[key];
    this.size -= result ? 1 : 0;
    return result;
  }

  var _hashDelete = hashDelete;

  /** Used to stand-in for `undefined` hash values. */
  var HASH_UNDEFINED = '__lodash_hash_undefined__';

  /** Used for built-in method references. */
  var objectProto$3 = Object.prototype;

  /** Used to check objects for own properties. */
  var hasOwnProperty$2 = objectProto$3.hasOwnProperty;

  /**
   * Gets the hash value for `key`.
   *
   * @private
   * @name get
   * @memberOf Hash
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function hashGet(key) {
    var data = this.__data__;
    if (_nativeCreate) {
      var result = data[key];
      return result === HASH_UNDEFINED ? undefined : result;
    }
    return hasOwnProperty$2.call(data, key) ? data[key] : undefined;
  }

  var _hashGet = hashGet;

  /** Used for built-in method references. */
  var objectProto$4 = Object.prototype;

  /** Used to check objects for own properties. */
  var hasOwnProperty$3 = objectProto$4.hasOwnProperty;

  /**
   * Checks if a hash value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf Hash
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function hashHas(key) {
    var data = this.__data__;
    return _nativeCreate ? (data[key] !== undefined) : hasOwnProperty$3.call(data, key);
  }

  var _hashHas = hashHas;

  /** Used to stand-in for `undefined` hash values. */
  var HASH_UNDEFINED$1 = '__lodash_hash_undefined__';

  /**
   * Sets the hash `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf Hash
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the hash instance.
   */
  function hashSet(key, value) {
    var data = this.__data__;
    this.size += this.has(key) ? 0 : 1;
    data[key] = (_nativeCreate && value === undefined) ? HASH_UNDEFINED$1 : value;
    return this;
  }

  var _hashSet = hashSet;

  /**
   * Creates a hash object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function Hash(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;

    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }

  // Add methods to `Hash`.
  Hash.prototype.clear = _hashClear;
  Hash.prototype['delete'] = _hashDelete;
  Hash.prototype.get = _hashGet;
  Hash.prototype.has = _hashHas;
  Hash.prototype.set = _hashSet;

  var _Hash = Hash;

  /**
   * Removes all key-value entries from the map.
   *
   * @private
   * @name clear
   * @memberOf MapCache
   */
  function mapCacheClear() {
    this.size = 0;
    this.__data__ = {
      'hash': new _Hash,
      'map': new (_Map || _ListCache),
      'string': new _Hash
    };
  }

  var _mapCacheClear = mapCacheClear;

  /**
   * Checks if `value` is suitable for use as unique object key.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
   */
  function isKeyable(value) {
    var type = typeof value;
    return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
      ? (value !== '__proto__')
      : (value === null);
  }

  var _isKeyable = isKeyable;

  /**
   * Gets the data for `map`.
   *
   * @private
   * @param {Object} map The map to query.
   * @param {string} key The reference key.
   * @returns {*} Returns the map data.
   */
  function getMapData(map, key) {
    var data = map.__data__;
    return _isKeyable(key)
      ? data[typeof key == 'string' ? 'string' : 'hash']
      : data.map;
  }

  var _getMapData = getMapData;

  /**
   * Removes `key` and its value from the map.
   *
   * @private
   * @name delete
   * @memberOf MapCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
  function mapCacheDelete(key) {
    var result = _getMapData(this, key)['delete'](key);
    this.size -= result ? 1 : 0;
    return result;
  }

  var _mapCacheDelete = mapCacheDelete;

  /**
   * Gets the map value for `key`.
   *
   * @private
   * @name get
   * @memberOf MapCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
  function mapCacheGet(key) {
    return _getMapData(this, key).get(key);
  }

  var _mapCacheGet = mapCacheGet;

  /**
   * Checks if a map value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf MapCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
  function mapCacheHas(key) {
    return _getMapData(this, key).has(key);
  }

  var _mapCacheHas = mapCacheHas;

  /**
   * Sets the map `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf MapCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the map cache instance.
   */
  function mapCacheSet(key, value) {
    var data = _getMapData(this, key),
        size = data.size;

    data.set(key, value);
    this.size += data.size == size ? 0 : 1;
    return this;
  }

  var _mapCacheSet = mapCacheSet;

  /**
   * Creates a map cache object to store key-value pairs.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function MapCache(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;

    this.clear();
    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }

  // Add methods to `MapCache`.
  MapCache.prototype.clear = _mapCacheClear;
  MapCache.prototype['delete'] = _mapCacheDelete;
  MapCache.prototype.get = _mapCacheGet;
  MapCache.prototype.has = _mapCacheHas;
  MapCache.prototype.set = _mapCacheSet;

  var _MapCache = MapCache;

  /** Used as the size to enable large array optimizations. */
  var LARGE_ARRAY_SIZE = 200;

  /**
   * Sets the stack `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf Stack
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the stack cache instance.
   */
  function stackSet(key, value) {
    var data = this.__data__;
    if (data instanceof _ListCache) {
      var pairs = data.__data__;
      if (!_Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
        pairs.push([key, value]);
        this.size = ++data.size;
        return this;
      }
      data = this.__data__ = new _MapCache(pairs);
    }
    data.set(key, value);
    this.size = data.size;
    return this;
  }

  var _stackSet = stackSet;

  /**
   * Creates a stack cache object to store key-value pairs.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
  function Stack(entries) {
    var data = this.__data__ = new _ListCache(entries);
    this.size = data.size;
  }

  // Add methods to `Stack`.
  Stack.prototype.clear = _stackClear;
  Stack.prototype['delete'] = _stackDelete;
  Stack.prototype.get = _stackGet;
  Stack.prototype.has = _stackHas;
  Stack.prototype.set = _stackSet;

  var _Stack = Stack;

  var defineProperty = (function() {
    try {
      var func = _getNative(Object, 'defineProperty');
      func({}, '', {});
      return func;
    } catch (e) {}
  }());

  var _defineProperty$1 = defineProperty;

  /**
   * The base implementation of `assignValue` and `assignMergeValue` without
   * value checks.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {string} key The key of the property to assign.
   * @param {*} value The value to assign.
   */
  function baseAssignValue(object, key, value) {
    if (key == '__proto__' && _defineProperty$1) {
      _defineProperty$1(object, key, {
        'configurable': true,
        'enumerable': true,
        'value': value,
        'writable': true
      });
    } else {
      object[key] = value;
    }
  }

  var _baseAssignValue = baseAssignValue;

  /**
   * This function is like `assignValue` except that it doesn't assign
   * `undefined` values.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {string} key The key of the property to assign.
   * @param {*} value The value to assign.
   */
  function assignMergeValue(object, key, value) {
    if ((value !== undefined && !eq_1(object[key], value)) ||
        (value === undefined && !(key in object))) {
      _baseAssignValue(object, key, value);
    }
  }

  var _assignMergeValue = assignMergeValue;

  /**
   * Creates a base function for methods like `_.forIn` and `_.forOwn`.
   *
   * @private
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {Function} Returns the new base function.
   */
  function createBaseFor(fromRight) {
    return function(object, iteratee, keysFunc) {
      var index = -1,
          iterable = Object(object),
          props = keysFunc(object),
          length = props.length;

      while (length--) {
        var key = props[fromRight ? length : ++index];
        if (iteratee(iterable[key], key, iterable) === false) {
          break;
        }
      }
      return object;
    };
  }

  var _createBaseFor = createBaseFor;

  /**
   * The base implementation of `baseForOwn` which iterates over `object`
   * properties returned by `keysFunc` and invokes `iteratee` for each property.
   * Iteratee functions may exit iteration early by explicitly returning `false`.
   *
   * @private
   * @param {Object} object The object to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @param {Function} keysFunc The function to get the keys of `object`.
   * @returns {Object} Returns `object`.
   */
  var baseFor = _createBaseFor();

  var _baseFor = baseFor;

  var _cloneBuffer = createCommonjsModule(function (module, exports) {
  /** Detect free variable `exports`. */
  var freeExports =  exports && !exports.nodeType && exports;

  /** Detect free variable `module`. */
  var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;

  /** Detect the popular CommonJS extension `module.exports`. */
  var moduleExports = freeModule && freeModule.exports === freeExports;

  /** Built-in value references. */
  var Buffer = moduleExports ? _root.Buffer : undefined,
      allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;

  /**
   * Creates a clone of  `buffer`.
   *
   * @private
   * @param {Buffer} buffer The buffer to clone.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Buffer} Returns the cloned buffer.
   */
  function cloneBuffer(buffer, isDeep) {
    if (isDeep) {
      return buffer.slice();
    }
    var length = buffer.length,
        result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);

    buffer.copy(result);
    return result;
  }

  module.exports = cloneBuffer;
  });

  /** Built-in value references. */
  var Uint8Array = _root.Uint8Array;

  var _Uint8Array = Uint8Array;

  /**
   * Creates a clone of `arrayBuffer`.
   *
   * @private
   * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
   * @returns {ArrayBuffer} Returns the cloned array buffer.
   */
  function cloneArrayBuffer(arrayBuffer) {
    var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
    new _Uint8Array(result).set(new _Uint8Array(arrayBuffer));
    return result;
  }

  var _cloneArrayBuffer = cloneArrayBuffer;

  /**
   * Creates a clone of `typedArray`.
   *
   * @private
   * @param {Object} typedArray The typed array to clone.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the cloned typed array.
   */
  function cloneTypedArray(typedArray, isDeep) {
    var buffer = isDeep ? _cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
    return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
  }

  var _cloneTypedArray = cloneTypedArray;

  /**
   * Copies the values of `source` to `array`.
   *
   * @private
   * @param {Array} source The array to copy values from.
   * @param {Array} [array=[]] The array to copy values to.
   * @returns {Array} Returns `array`.
   */
  function copyArray(source, array) {
    var index = -1,
        length = source.length;

    array || (array = Array(length));
    while (++index < length) {
      array[index] = source[index];
    }
    return array;
  }

  var _copyArray = copyArray;

  /** Built-in value references. */
  var objectCreate = Object.create;

  /**
   * The base implementation of `_.create` without support for assigning
   * properties to the created object.
   *
   * @private
   * @param {Object} proto The object to inherit from.
   * @returns {Object} Returns the new object.
   */
  var baseCreate = (function() {
    function object() {}
    return function(proto) {
      if (!isObject_1(proto)) {
        return {};
      }
      if (objectCreate) {
        return objectCreate(proto);
      }
      object.prototype = proto;
      var result = new object;
      object.prototype = undefined;
      return result;
    };
  }());

  var _baseCreate = baseCreate;

  /**
   * Creates a unary function that invokes `func` with its argument transformed.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {Function} transform The argument transform.
   * @returns {Function} Returns the new function.
   */
  function overArg(func, transform) {
    return function(arg) {
      return func(transform(arg));
    };
  }

  var _overArg = overArg;

  /** Built-in value references. */
  var getPrototype = _overArg(Object.getPrototypeOf, Object);

  var _getPrototype = getPrototype;

  /** Used for built-in method references. */
  var objectProto$5 = Object.prototype;

  /**
   * Checks if `value` is likely a prototype object.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
   */
  function isPrototype(value) {
    var Ctor = value && value.constructor,
        proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$5;

    return value === proto;
  }

  var _isPrototype = isPrototype;

  /**
   * Initializes an object clone.
   *
   * @private
   * @param {Object} object The object to clone.
   * @returns {Object} Returns the initialized clone.
   */
  function initCloneObject(object) {
    return (typeof object.constructor == 'function' && !_isPrototype(object))
      ? _baseCreate(_getPrototype(object))
      : {};
  }

  var _initCloneObject = initCloneObject;

  /**
   * Checks if `value` is object-like. A value is object-like if it's not `null`
   * and has a `typeof` result of "object".
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
   * @example
   *
   * _.isObjectLike({});
   * // => true
   *
   * _.isObjectLike([1, 2, 3]);
   * // => true
   *
   * _.isObjectLike(_.noop);
   * // => false
   *
   * _.isObjectLike(null);
   * // => false
   */
  function isObjectLike(value) {
    return value != null && typeof value == 'object';
  }

  var isObjectLike_1 = isObjectLike;

  /** `Object#toString` result references. */
  var argsTag = '[object Arguments]';

  /**
   * The base implementation of `_.isArguments`.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
   */
  function baseIsArguments(value) {
    return isObjectLike_1(value) && _baseGetTag(value) == argsTag;
  }

  var _baseIsArguments = baseIsArguments;

  /** Used for built-in method references. */
  var objectProto$6 = Object.prototype;

  /** Used to check objects for own properties. */
  var hasOwnProperty$4 = objectProto$6.hasOwnProperty;

  /** Built-in value references. */
  var propertyIsEnumerable = objectProto$6.propertyIsEnumerable;

  /**
   * Checks if `value` is likely an `arguments` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
   *  else `false`.
   * @example
   *
   * _.isArguments(function() { return arguments; }());
   * // => true
   *
   * _.isArguments([1, 2, 3]);
   * // => false
   */
  var isArguments = _baseIsArguments(function() { return arguments; }()) ? _baseIsArguments : function(value) {
    return isObjectLike_1(value) && hasOwnProperty$4.call(value, 'callee') &&
      !propertyIsEnumerable.call(value, 'callee');
  };

  var isArguments_1 = isArguments;

  /**
   * Checks if `value` is classified as an `Array` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array, else `false`.
   * @example
   *
   * _.isArray([1, 2, 3]);
   * // => true
   *
   * _.isArray(document.body.children);
   * // => false
   *
   * _.isArray('abc');
   * // => false
   *
   * _.isArray(_.noop);
   * // => false
   */
  var isArray = Array.isArray;

  var isArray_1 = isArray;

  /** Used as references for various `Number` constants. */
  var MAX_SAFE_INTEGER = 9007199254740991;

  /**
   * Checks if `value` is a valid array-like length.
   *
   * **Note:** This method is loosely based on
   * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
   * @example
   *
   * _.isLength(3);
   * // => true
   *
   * _.isLength(Number.MIN_VALUE);
   * // => false
   *
   * _.isLength(Infinity);
   * // => false
   *
   * _.isLength('3');
   * // => false
   */
  function isLength(value) {
    return typeof value == 'number' &&
      value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
  }

  var isLength_1 = isLength;

  /**
   * Checks if `value` is array-like. A value is considered array-like if it's
   * not a function and has a `value.length` that's an integer greater than or
   * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
   * @example
   *
   * _.isArrayLike([1, 2, 3]);
   * // => true
   *
   * _.isArrayLike(document.body.children);
   * // => true
   *
   * _.isArrayLike('abc');
   * // => true
   *
   * _.isArrayLike(_.noop);
   * // => false
   */
  function isArrayLike(value) {
    return value != null && isLength_1(value.length) && !isFunction_1(value);
  }

  var isArrayLike_1 = isArrayLike;

  /**
   * This method is like `_.isArrayLike` except that it also checks if `value`
   * is an object.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array-like object,
   *  else `false`.
   * @example
   *
   * _.isArrayLikeObject([1, 2, 3]);
   * // => true
   *
   * _.isArrayLikeObject(document.body.children);
   * // => true
   *
   * _.isArrayLikeObject('abc');
   * // => false
   *
   * _.isArrayLikeObject(_.noop);
   * // => false
   */
  function isArrayLikeObject(value) {
    return isObjectLike_1(value) && isArrayLike_1(value);
  }

  var isArrayLikeObject_1 = isArrayLikeObject;

  /**
   * This method returns `false`.
   *
   * @static
   * @memberOf _
   * @since 4.13.0
   * @category Util
   * @returns {boolean} Returns `false`.
   * @example
   *
   * _.times(2, _.stubFalse);
   * // => [false, false]
   */
  function stubFalse() {
    return false;
  }

  var stubFalse_1 = stubFalse;

  var isBuffer_1 = createCommonjsModule(function (module, exports) {
  /** Detect free variable `exports`. */
  var freeExports =  exports && !exports.nodeType && exports;

  /** Detect free variable `module`. */
  var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;

  /** Detect the popular CommonJS extension `module.exports`. */
  var moduleExports = freeModule && freeModule.exports === freeExports;

  /** Built-in value references. */
  var Buffer = moduleExports ? _root.Buffer : undefined;

  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;

  /**
   * Checks if `value` is a buffer.
   *
   * @static
   * @memberOf _
   * @since 4.3.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
   * @example
   *
   * _.isBuffer(new Buffer(2));
   * // => true
   *
   * _.isBuffer(new Uint8Array(2));
   * // => false
   */
  var isBuffer = nativeIsBuffer || stubFalse_1;

  module.exports = isBuffer;
  });

  /** `Object#toString` result references. */
  var objectTag = '[object Object]';

  /** Used for built-in method references. */
  var funcProto$2 = Function.prototype,
      objectProto$7 = Object.prototype;

  /** Used to resolve the decompiled source of functions. */
  var funcToString$2 = funcProto$2.toString;

  /** Used to check objects for own properties. */
  var hasOwnProperty$5 = objectProto$7.hasOwnProperty;

  /** Used to infer the `Object` constructor. */
  var objectCtorString = funcToString$2.call(Object);

  /**
   * Checks if `value` is a plain object, that is, an object created by the
   * `Object` constructor or one with a `[[Prototype]]` of `null`.
   *
   * @static
   * @memberOf _
   * @since 0.8.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   * }
   *
   * _.isPlainObject(new Foo);
   * // => false
   *
   * _.isPlainObject([1, 2, 3]);
   * // => false
   *
   * _.isPlainObject({ 'x': 0, 'y': 0 });
   * // => true
   *
   * _.isPlainObject(Object.create(null));
   * // => true
   */
  function isPlainObject(value) {
    if (!isObjectLike_1(value) || _baseGetTag(value) != objectTag) {
      return false;
    }
    var proto = _getPrototype(value);
    if (proto === null) {
      return true;
    }
    var Ctor = hasOwnProperty$5.call(proto, 'constructor') && proto.constructor;
    return typeof Ctor == 'function' && Ctor instanceof Ctor &&
      funcToString$2.call(Ctor) == objectCtorString;
  }

  var isPlainObject_1 = isPlainObject;

  /** `Object#toString` result references. */
  var argsTag$1 = '[object Arguments]',
      arrayTag = '[object Array]',
      boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      errorTag = '[object Error]',
      funcTag$1 = '[object Function]',
      mapTag = '[object Map]',
      numberTag = '[object Number]',
      objectTag$1 = '[object Object]',
      regexpTag = '[object RegExp]',
      setTag = '[object Set]',
      stringTag = '[object String]',
      weakMapTag = '[object WeakMap]';

  var arrayBufferTag = '[object ArrayBuffer]',
      dataViewTag = '[object DataView]',
      float32Tag = '[object Float32Array]',
      float64Tag = '[object Float64Array]',
      int8Tag = '[object Int8Array]',
      int16Tag = '[object Int16Array]',
      int32Tag = '[object Int32Array]',
      uint8Tag = '[object Uint8Array]',
      uint8ClampedTag = '[object Uint8ClampedArray]',
      uint16Tag = '[object Uint16Array]',
      uint32Tag = '[object Uint32Array]';

  /** Used to identify `toStringTag` values of typed arrays. */
  var typedArrayTags = {};
  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
  typedArrayTags[uint32Tag] = true;
  typedArrayTags[argsTag$1] = typedArrayTags[arrayTag] =
  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
  typedArrayTags[errorTag] = typedArrayTags[funcTag$1] =
  typedArrayTags[mapTag] = typedArrayTags[numberTag] =
  typedArrayTags[objectTag$1] = typedArrayTags[regexpTag] =
  typedArrayTags[setTag] = typedArrayTags[stringTag] =
  typedArrayTags[weakMapTag] = false;

  /**
   * The base implementation of `_.isTypedArray` without Node.js optimizations.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
   */
  function baseIsTypedArray(value) {
    return isObjectLike_1(value) &&
      isLength_1(value.length) && !!typedArrayTags[_baseGetTag(value)];
  }

  var _baseIsTypedArray = baseIsTypedArray;

  /**
   * The base implementation of `_.unary` without support for storing metadata.
   *
   * @private
   * @param {Function} func The function to cap arguments for.
   * @returns {Function} Returns the new capped function.
   */
  function baseUnary(func) {
    return function(value) {
      return func(value);
    };
  }

  var _baseUnary = baseUnary;

  var _nodeUtil = createCommonjsModule(function (module, exports) {
  /** Detect free variable `exports`. */
  var freeExports =  exports && !exports.nodeType && exports;

  /** Detect free variable `module`. */
  var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;

  /** Detect the popular CommonJS extension `module.exports`. */
  var moduleExports = freeModule && freeModule.exports === freeExports;

  /** Detect free variable `process` from Node.js. */
  var freeProcess = moduleExports && _freeGlobal.process;

  /** Used to access faster Node.js helpers. */
  var nodeUtil = (function() {
    try {
      // Use `util.types` for Node.js 10+.
      var types = freeModule && freeModule.require && freeModule.require('util').types;

      if (types) {
        return types;
      }

      // Legacy `process.binding('util')` for Node.js < 10.
      return freeProcess && freeProcess.binding && freeProcess.binding('util');
    } catch (e) {}
  }());

  module.exports = nodeUtil;
  });

  /* Node.js helper references. */
  var nodeIsTypedArray = _nodeUtil && _nodeUtil.isTypedArray;

  /**
   * Checks if `value` is classified as a typed array.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
   * @example
   *
   * _.isTypedArray(new Uint8Array);
   * // => true
   *
   * _.isTypedArray([]);
   * // => false
   */
  var isTypedArray = nodeIsTypedArray ? _baseUnary(nodeIsTypedArray) : _baseIsTypedArray;

  var isTypedArray_1 = isTypedArray;

  /**
   * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
   *
   * @private
   * @param {Object} object The object to query.
   * @param {string} key The key of the property to get.
   * @returns {*} Returns the property value.
   */
  function safeGet(object, key) {
    if (key === 'constructor' && typeof object[key] === 'function') {
      return;
    }

    if (key == '__proto__') {
      return;
    }

    return object[key];
  }

  var _safeGet = safeGet;

  /** Used for built-in method references. */
  var objectProto$8 = Object.prototype;

  /** Used to check objects for own properties. */
  var hasOwnProperty$6 = objectProto$8.hasOwnProperty;

  /**
   * Assigns `value` to `key` of `object` if the existing value is not equivalent
   * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons.
   *
   * @private
   * @param {Object} object The object to modify.
   * @param {string} key The key of the property to assign.
   * @param {*} value The value to assign.
   */
  function assignValue(object, key, value) {
    var objValue = object[key];
    if (!(hasOwnProperty$6.call(object, key) && eq_1(objValue, value)) ||
        (value === undefined && !(key in object))) {
      _baseAssignValue(object, key, value);
    }
  }

  var _assignValue = assignValue;

  /**
   * Copies properties of `source` to `object`.
   *
   * @private
   * @param {Object} source The object to copy properties from.
   * @param {Array} props The property identifiers to copy.
   * @param {Object} [object={}] The object to copy properties to.
   * @param {Function} [customizer] The function to customize copied values.
   * @returns {Object} Returns `object`.
   */
  function copyObject(source, props, object, customizer) {
    var isNew = !object;
    object || (object = {});

    var index = -1,
        length = props.length;

    while (++index < length) {
      var key = props[index];

      var newValue = customizer
        ? customizer(object[key], source[key], key, object, source)
        : undefined;

      if (newValue === undefined) {
        newValue = source[key];
      }
      if (isNew) {
        _baseAssignValue(object, key, newValue);
      } else {
        _assignValue(object, key, newValue);
      }
    }
    return object;
  }

  var _copyObject = copyObject;

  /**
   * The base implementation of `_.times` without support for iteratee shorthands
   * or max array length checks.
   *
   * @private
   * @param {number} n The number of times to invoke `iteratee`.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns the array of results.
   */
  function baseTimes(n, iteratee) {
    var index = -1,
        result = Array(n);

    while (++index < n) {
      result[index] = iteratee(index);
    }
    return result;
  }

  var _baseTimes = baseTimes;

  /** Used as references for various `Number` constants. */
  var MAX_SAFE_INTEGER$1 = 9007199254740991;

  /** Used to detect unsigned integer values. */
  var reIsUint = /^(?:0|[1-9]\d*)$/;

  /**
   * Checks if `value` is a valid array-like index.
   *
   * @private
   * @param {*} value The value to check.
   * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
   * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
   */
  function isIndex(value, length) {
    var type = typeof value;
    length = length == null ? MAX_SAFE_INTEGER$1 : length;

    return !!length &&
      (type == 'number' ||
        (type != 'symbol' && reIsUint.test(value))) &&
          (value > -1 && value % 1 == 0 && value < length);
  }

  var _isIndex = isIndex;

  /** Used for built-in method references. */
  var objectProto$9 = Object.prototype;

  /** Used to check objects for own properties. */
  var hasOwnProperty$7 = objectProto$9.hasOwnProperty;

  /**
   * Creates an array of the enumerable property names of the array-like `value`.
   *
   * @private
   * @param {*} value The value to query.
   * @param {boolean} inherited Specify returning inherited property names.
   * @returns {Array} Returns the array of property names.
   */
  function arrayLikeKeys(value, inherited) {
    var isArr = isArray_1(value),
        isArg = !isArr && isArguments_1(value),
        isBuff = !isArr && !isArg && isBuffer_1(value),
        isType = !isArr && !isArg && !isBuff && isTypedArray_1(value),
        skipIndexes = isArr || isArg || isBuff || isType,
        result = skipIndexes ? _baseTimes(value.length, String) : [],
        length = result.length;

    for (var key in value) {
      if ((inherited || hasOwnProperty$7.call(value, key)) &&
          !(skipIndexes && (
             // Safari 9 has enumerable `arguments.length` in strict mode.
             key == 'length' ||
             // Node.js 0.10 has enumerable non-index properties on buffers.
             (isBuff && (key == 'offset' || key == 'parent')) ||
             // PhantomJS 2 has enumerable non-index properties on typed arrays.
             (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
             // Skip index properties.
             _isIndex(key, length)
          ))) {
        result.push(key);
      }
    }
    return result;
  }

  var _arrayLikeKeys = arrayLikeKeys;

  /**
   * This function is like
   * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
   * except that it includes inherited enumerable properties.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   */
  function nativeKeysIn(object) {
    var result = [];
    if (object != null) {
      for (var key in Object(object)) {
        result.push(key);
      }
    }
    return result;
  }

  var _nativeKeysIn = nativeKeysIn;

  /** Used for built-in method references. */
  var objectProto$a = Object.prototype;

  /** Used to check objects for own properties. */
  var hasOwnProperty$8 = objectProto$a.hasOwnProperty;

  /**
   * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   */
  function baseKeysIn(object) {
    if (!isObject_1(object)) {
      return _nativeKeysIn(object);
    }
    var isProto = _isPrototype(object),
        result = [];

    for (var key in object) {
      if (!(key == 'constructor' && (isProto || !hasOwnProperty$8.call(object, key)))) {
        result.push(key);
      }
    }
    return result;
  }

  var _baseKeysIn = baseKeysIn;

  /**
   * Creates an array of the own and inherited enumerable property names of `object`.
   *
   * **Note:** Non-object values are coerced to objects.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Object
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.keysIn(new Foo);
   * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
   */
  function keysIn(object) {
    return isArrayLike_1(object) ? _arrayLikeKeys(object, true) : _baseKeysIn(object);
  }

  var keysIn_1 = keysIn;

  /**
   * Converts `value` to a plain object flattening inherited enumerable string
   * keyed properties of `value` to own properties of the plain object.
   *
   * @static
   * @memberOf _
   * @since 3.0.0
   * @category Lang
   * @param {*} value The value to convert.
   * @returns {Object} Returns the converted plain object.
   * @example
   *
   * function Foo() {
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.assign({ 'a': 1 }, new Foo);
   * // => { 'a': 1, 'b': 2 }
   *
   * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
   * // => { 'a': 1, 'b': 2, 'c': 3 }
   */
  function toPlainObject(value) {
    return _copyObject(value, keysIn_1(value));
  }

  var toPlainObject_1 = toPlainObject;

  /**
   * A specialized version of `baseMerge` for arrays and objects which performs
   * deep merges and tracks traversed objects enabling objects with circular
   * references to be merged.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @param {string} key The key of the value to merge.
   * @param {number} srcIndex The index of `source`.
   * @param {Function} mergeFunc The function to merge values.
   * @param {Function} [customizer] The function to customize assigned values.
   * @param {Object} [stack] Tracks traversed source values and their merged
   *  counterparts.
   */
  function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
    var objValue = _safeGet(object, key),
        srcValue = _safeGet(source, key),
        stacked = stack.get(srcValue);

    if (stacked) {
      _assignMergeValue(object, key, stacked);
      return;
    }
    var newValue = customizer
      ? customizer(objValue, srcValue, (key + ''), object, source, stack)
      : undefined;

    var isCommon = newValue === undefined;

    if (isCommon) {
      var isArr = isArray_1(srcValue),
          isBuff = !isArr && isBuffer_1(srcValue),
          isTyped = !isArr && !isBuff && isTypedArray_1(srcValue);

      newValue = srcValue;
      if (isArr || isBuff || isTyped) {
        if (isArray_1(objValue)) {
          newValue = objValue;
        }
        else if (isArrayLikeObject_1(objValue)) {
          newValue = _copyArray(objValue);
        }
        else if (isBuff) {
          isCommon = false;
          newValue = _cloneBuffer(srcValue, true);
        }
        else if (isTyped) {
          isCommon = false;
          newValue = _cloneTypedArray(srcValue, true);
        }
        else {
          newValue = [];
        }
      }
      else if (isPlainObject_1(srcValue) || isArguments_1(srcValue)) {
        newValue = objValue;
        if (isArguments_1(objValue)) {
          newValue = toPlainObject_1(objValue);
        }
        else if (!isObject_1(objValue) || isFunction_1(objValue)) {
          newValue = _initCloneObject(srcValue);
        }
      }
      else {
        isCommon = false;
      }
    }
    if (isCommon) {
      // Recursively merge objects and arrays (susceptible to call stack limits).
      stack.set(srcValue, newValue);
      mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
      stack['delete'](srcValue);
    }
    _assignMergeValue(object, key, newValue);
  }

  var _baseMergeDeep = baseMergeDeep;

  /**
   * The base implementation of `_.merge` without support for multiple sources.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @param {number} srcIndex The index of `source`.
   * @param {Function} [customizer] The function to customize merged values.
   * @param {Object} [stack] Tracks traversed source values and their merged
   *  counterparts.
   */
  function baseMerge(object, source, srcIndex, customizer, stack) {
    if (object === source) {
      return;
    }
    _baseFor(source, function(srcValue, key) {
      stack || (stack = new _Stack);
      if (isObject_1(srcValue)) {
        _baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
      }
      else {
        var newValue = customizer
          ? customizer(_safeGet(object, key), srcValue, (key + ''), object, source, stack)
          : undefined;

        if (newValue === undefined) {
          newValue = srcValue;
        }
        _assignMergeValue(object, key, newValue);
      }
    }, keysIn_1);
  }

  var _baseMerge = baseMerge;

  /**
   * This method returns the first argument it receives.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Util
   * @param {*} value Any value.
   * @returns {*} Returns `value`.
   * @example
   *
   * var object = { 'a': 1 };
   *
   * console.log(_.identity(object) === object);
   * // => true
   */
  function identity(value) {
    return value;
  }

  var identity_1 = identity;

  /**
   * A faster alternative to `Function#apply`, this function invokes `func`
   * with the `this` binding of `thisArg` and the arguments of `args`.
   *
   * @private
   * @param {Function} func The function to invoke.
   * @param {*} thisArg The `this` binding of `func`.
   * @param {Array} args The arguments to invoke `func` with.
   * @returns {*} Returns the result of `func`.
   */
  function apply(func, thisArg, args) {
    switch (args.length) {
      case 0: return func.call(thisArg);
      case 1: return func.call(thisArg, args[0]);
      case 2: return func.call(thisArg, args[0], args[1]);
      case 3: return func.call(thisArg, args[0], args[1], args[2]);
    }
    return func.apply(thisArg, args);
  }

  var _apply = apply;

  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeMax = Math.max;

  /**
   * A specialized version of `baseRest` which transforms the rest array.
   *
   * @private
   * @param {Function} func The function to apply a rest parameter to.
   * @param {number} [start=func.length-1] The start position of the rest parameter.
   * @param {Function} transform The rest array transform.
   * @returns {Function} Returns the new function.
   */
  function overRest(func, start, transform) {
    start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
    return function() {
      var args = arguments,
          index = -1,
          length = nativeMax(args.length - start, 0),
          array = Array(length);

      while (++index < length) {
        array[index] = args[start + index];
      }
      index = -1;
      var otherArgs = Array(start + 1);
      while (++index < start) {
        otherArgs[index] = args[index];
      }
      otherArgs[start] = transform(array);
      return _apply(func, this, otherArgs);
    };
  }

  var _overRest = overRest;

  /**
   * Creates a function that returns `value`.
   *
   * @static
   * @memberOf _
   * @since 2.4.0
   * @category Util
   * @param {*} value The value to return from the new function.
   * @returns {Function} Returns the new constant function.
   * @example
   *
   * var objects = _.times(2, _.constant({ 'a': 1 }));
   *
   * console.log(objects);
   * // => [{ 'a': 1 }, { 'a': 1 }]
   *
   * console.log(objects[0] === objects[1]);
   * // => true
   */
  function constant(value) {
    return function() {
      return value;
    };
  }

  var constant_1 = constant;

  /**
   * The base implementation of `setToString` without support for hot loop shorting.
   *
   * @private
   * @param {Function} func The function to modify.
   * @param {Function} string The `toString` result.
   * @returns {Function} Returns `func`.
   */
  var baseSetToString = !_defineProperty$1 ? identity_1 : function(func, string) {
    return _defineProperty$1(func, 'toString', {
      'configurable': true,
      'enumerable': false,
      'value': constant_1(string),
      'writable': true
    });
  };

  var _baseSetToString = baseSetToString;

  /** Used to detect hot functions by number of calls within a span of milliseconds. */
  var HOT_COUNT = 800,
      HOT_SPAN = 16;

  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeNow = Date.now;

  /**
   * Creates a function that'll short out and invoke `identity` instead
   * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
   * milliseconds.
   *
   * @private
   * @param {Function} func The function to restrict.
   * @returns {Function} Returns the new shortable function.
   */
  function shortOut(func) {
    var count = 0,
        lastCalled = 0;

    return function() {
      var stamp = nativeNow(),
          remaining = HOT_SPAN - (stamp - lastCalled);

      lastCalled = stamp;
      if (remaining > 0) {
        if (++count >= HOT_COUNT) {
          return arguments[0];
        }
      } else {
        count = 0;
      }
      return func.apply(undefined, arguments);
    };
  }

  var _shortOut = shortOut;

  /**
   * Sets the `toString` method of `func` to return `string`.
   *
   * @private
   * @param {Function} func The function to modify.
   * @param {Function} string The `toString` result.
   * @returns {Function} Returns `func`.
   */
  var setToString = _shortOut(_baseSetToString);

  var _setToString = setToString;

  /**
   * The base implementation of `_.rest` which doesn't validate or coerce arguments.
   *
   * @private
   * @param {Function} func The function to apply a rest parameter to.
   * @param {number} [start=func.length-1] The start position of the rest parameter.
   * @returns {Function} Returns the new function.
   */
  function baseRest(func, start) {
    return _setToString(_overRest(func, start, identity_1), func + '');
  }

  var _baseRest = baseRest;

  /**
   * Checks if the given arguments are from an iteratee call.
   *
   * @private
   * @param {*} value The potential iteratee value argument.
   * @param {*} index The potential iteratee index or key argument.
   * @param {*} object The potential iteratee object argument.
   * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
   *  else `false`.
   */
  function isIterateeCall(value, index, object) {
    if (!isObject_1(object)) {
      return false;
    }
    var type = typeof index;
    if (type == 'number'
          ? (isArrayLike_1(object) && _isIndex(index, object.length))
          : (type == 'string' && index in object)
        ) {
      return eq_1(object[index], value);
    }
    return false;
  }

  var _isIterateeCall = isIterateeCall;

  /**
   * Creates a function like `_.assign`.
   *
   * @private
   * @param {Function} assigner The function to assign values.
   * @returns {Function} Returns the new assigner function.
   */
  function createAssigner(assigner) {
    return _baseRest(function(object, sources) {
      var index = -1,
          length = sources.length,
          customizer = length > 1 ? sources[length - 1] : undefined,
          guard = length > 2 ? sources[2] : undefined;

      customizer = (assigner.length > 3 && typeof customizer == 'function')
        ? (length--, customizer)
        : undefined;

      if (guard && _isIterateeCall(sources[0], sources[1], guard)) {
        customizer = length < 3 ? undefined : customizer;
        length = 1;
      }
      object = Object(object);
      while (++index < length) {
        var source = sources[index];
        if (source) {
          assigner(object, source, index, customizer);
        }
      }
      return object;
    });
  }

  var _createAssigner = createAssigner;

  /**
   * This method is like `_.assign` except that it recursively merges own and
   * inherited enumerable string keyed properties of source objects into the
   * destination object. Source properties that resolve to `undefined` are
   * skipped if a destination value exists. Array and plain object properties
   * are merged recursively. Other objects and value types are overridden by
   * assignment. Source objects are applied from left to right. Subsequent
   * sources overwrite property assignments of previous sources.
   *
   * **Note:** This method mutates `object`.
   *
   * @static
   * @memberOf _
   * @since 0.5.0
   * @category Object
   * @param {Object} object The destination object.
   * @param {...Object} [sources] The source objects.
   * @returns {Object} Returns `object`.
   * @example
   *
   * var object = {
   *   'a': [{ 'b': 2 }, { 'd': 4 }]
   * };
   *
   * var other = {
   *   'a': [{ 'c': 3 }, { 'e': 5 }]
   * };
   *
   * _.merge(object, other);
   * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
   */
  var merge = _createAssigner(function(object, source, srcIndex) {
    _baseMerge(object, source, srcIndex);
  });

  var merge_1 = merge;

  /**
   * A specialized version of `_.forEach` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} iteratee The function invoked per iteration.
   * @returns {Array} Returns `array`.
   */
  function arrayEach(array, iteratee) {
    var index = -1,
        length = array == null ? 0 : array.length;

    while (++index < length) {
      if (iteratee(array[index], index, array) === false) {
        break;
      }
    }
    return array;
  }

  var _arrayEach = arrayEach;

  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeKeys = _overArg(Object.keys, Object);

  var _nativeKeys = nativeKeys;

  /** Used for built-in method references. */
  var objectProto$b = Object.prototype;

  /** Used to check objects for own properties. */
  var hasOwnProperty$9 = objectProto$b.hasOwnProperty;

  /**
   * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   */
  function baseKeys(object) {
    if (!_isPrototype(object)) {
      return _nativeKeys(object);
    }
    var result = [];
    for (var key in Object(object)) {
      if (hasOwnProperty$9.call(object, key) && key != 'constructor') {
        result.push(key);
      }
    }
    return result;
  }

  var _baseKeys = baseKeys;

  /**
   * Creates an array of the own enumerable property names of `object`.
   *
   * **Note:** Non-object values are coerced to objects. See the
   * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
   * for more details.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Object
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   *   this.b = 2;
   * }
   *
   * Foo.prototype.c = 3;
   *
   * _.keys(new Foo);
   * // => ['a', 'b'] (iteration order is not guaranteed)
   *
   * _.keys('hi');
   * // => ['0', '1']
   */
  function keys(object) {
    return isArrayLike_1(object) ? _arrayLikeKeys(object) : _baseKeys(object);
  }

  var keys_1 = keys;

  /**
   * The base implementation of `_.assign` without support for multiple sources
   * or `customizer` functions.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @returns {Object} Returns `object`.
   */
  function baseAssign(object, source) {
    return object && _copyObject(source, keys_1(source), object);
  }

  var _baseAssign = baseAssign;

  /**
   * The base implementation of `_.assignIn` without support for multiple sources
   * or `customizer` functions.
   *
   * @private
   * @param {Object} object The destination object.
   * @param {Object} source The source object.
   * @returns {Object} Returns `object`.
   */
  function baseAssignIn(object, source) {
    return object && _copyObject(source, keysIn_1(source), object);
  }

  var _baseAssignIn = baseAssignIn;

  /**
   * A specialized version of `_.filter` for arrays without support for
   * iteratee shorthands.
   *
   * @private
   * @param {Array} [array] The array to iterate over.
   * @param {Function} predicate The function invoked per iteration.
   * @returns {Array} Returns the new filtered array.
   */
  function arrayFilter(array, predicate) {
    var index = -1,
        length = array == null ? 0 : array.length,
        resIndex = 0,
        result = [];

    while (++index < length) {
      var value = array[index];
      if (predicate(value, index, array)) {
        result[resIndex++] = value;
      }
    }
    return result;
  }

  var _arrayFilter = arrayFilter;

  /**
   * This method returns a new empty array.
   *
   * @static
   * @memberOf _
   * @since 4.13.0
   * @category Util
   * @returns {Array} Returns the new empty array.
   * @example
   *
   * var arrays = _.times(2, _.stubArray);
   *
   * console.log(arrays);
   * // => [[], []]
   *
   * console.log(arrays[0] === arrays[1]);
   * // => false
   */
  function stubArray() {
    return [];
  }

  var stubArray_1 = stubArray;

  /** Used for built-in method references. */
  var objectProto$c = Object.prototype;

  /** Built-in value references. */
  var propertyIsEnumerable$1 = objectProto$c.propertyIsEnumerable;

  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeGetSymbols = Object.getOwnPropertySymbols;

  /**
   * Creates an array of the own enumerable symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of symbols.
   */
  var getSymbols = !nativeGetSymbols ? stubArray_1 : function(object) {
    if (object == null) {
      return [];
    }
    object = Object(object);
    return _arrayFilter(nativeGetSymbols(object), function(symbol) {
      return propertyIsEnumerable$1.call(object, symbol);
    });
  };

  var _getSymbols = getSymbols;

  /**
   * Copies own symbols of `source` to `object`.
   *
   * @private
   * @param {Object} source The object to copy symbols from.
   * @param {Object} [object={}] The object to copy symbols to.
   * @returns {Object} Returns `object`.
   */
  function copySymbols(source, object) {
    return _copyObject(source, _getSymbols(source), object);
  }

  var _copySymbols = copySymbols;

  /**
   * Appends the elements of `values` to `array`.
   *
   * @private
   * @param {Array} array The array to modify.
   * @param {Array} values The values to append.
   * @returns {Array} Returns `array`.
   */
  function arrayPush(array, values) {
    var index = -1,
        length = values.length,
        offset = array.length;

    while (++index < length) {
      array[offset + index] = values[index];
    }
    return array;
  }

  var _arrayPush = arrayPush;

  /* Built-in method references for those with the same name as other `lodash` methods. */
  var nativeGetSymbols$1 = Object.getOwnPropertySymbols;

  /**
   * Creates an array of the own and inherited enumerable symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of symbols.
   */
  var getSymbolsIn = !nativeGetSymbols$1 ? stubArray_1 : function(object) {
    var result = [];
    while (object) {
      _arrayPush(result, _getSymbols(object));
      object = _getPrototype(object);
    }
    return result;
  };

  var _getSymbolsIn = getSymbolsIn;

  /**
   * Copies own and inherited symbols of `source` to `object`.
   *
   * @private
   * @param {Object} source The object to copy symbols from.
   * @param {Object} [object={}] The object to copy symbols to.
   * @returns {Object} Returns `object`.
   */
  function copySymbolsIn(source, object) {
    return _copyObject(source, _getSymbolsIn(source), object);
  }

  var _copySymbolsIn = copySymbolsIn;

  /**
   * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
   * `keysFunc` and `symbolsFunc` to get the enumerable property names and
   * symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Function} keysFunc The function to get the keys of `object`.
   * @param {Function} symbolsFunc The function to get the symbols of `object`.
   * @returns {Array} Returns the array of property names and symbols.
   */
  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
    var result = keysFunc(object);
    return isArray_1(object) ? result : _arrayPush(result, symbolsFunc(object));
  }

  var _baseGetAllKeys = baseGetAllKeys;

  /**
   * Creates an array of own enumerable property names and symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names and symbols.
   */
  function getAllKeys(object) {
    return _baseGetAllKeys(object, keys_1, _getSymbols);
  }

  var _getAllKeys = getAllKeys;

  /**
   * Creates an array of own and inherited enumerable property names and
   * symbols of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @returns {Array} Returns the array of property names and symbols.
   */
  function getAllKeysIn(object) {
    return _baseGetAllKeys(object, keysIn_1, _getSymbolsIn);
  }

  var _getAllKeysIn = getAllKeysIn;

  /* Built-in method references that are verified to be native. */
  var DataView = _getNative(_root, 'DataView');

  var _DataView = DataView;

  /* Built-in method references that are verified to be native. */
  var Promise = _getNative(_root, 'Promise');

  var _Promise = Promise;

  /* Built-in method references that are verified to be native. */
  var Set = _getNative(_root, 'Set');

  var _Set = Set;

  /* Built-in method references that are verified to be native. */
  var WeakMap = _getNative(_root, 'WeakMap');

  var _WeakMap = WeakMap;

  /** `Object#toString` result references. */
  var mapTag$1 = '[object Map]',
      objectTag$2 = '[object Object]',
      promiseTag = '[object Promise]',
      setTag$1 = '[object Set]',
      weakMapTag$1 = '[object WeakMap]';

  var dataViewTag$1 = '[object DataView]';

  /** Used to detect maps, sets, and weakmaps. */
  var dataViewCtorString = _toSource(_DataView),
      mapCtorString = _toSource(_Map),
      promiseCtorString = _toSource(_Promise),
      setCtorString = _toSource(_Set),
      weakMapCtorString = _toSource(_WeakMap);

  /**
   * Gets the `toStringTag` of `value`.
   *
   * @private
   * @param {*} value The value to query.
   * @returns {string} Returns the `toStringTag`.
   */
  var getTag = _baseGetTag;

  // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
  if ((_DataView && getTag(new _DataView(new ArrayBuffer(1))) != dataViewTag$1) ||
      (_Map && getTag(new _Map) != mapTag$1) ||
      (_Promise && getTag(_Promise.resolve()) != promiseTag) ||
      (_Set && getTag(new _Set) != setTag$1) ||
      (_WeakMap && getTag(new _WeakMap) != weakMapTag$1)) {
    getTag = function(value) {
      var result = _baseGetTag(value),
          Ctor = result == objectTag$2 ? value.constructor : undefined,
          ctorString = Ctor ? _toSource(Ctor) : '';

      if (ctorString) {
        switch (ctorString) {
          case dataViewCtorString: return dataViewTag$1;
          case mapCtorString: return mapTag$1;
          case promiseCtorString: return promiseTag;
          case setCtorString: return setTag$1;
          case weakMapCtorString: return weakMapTag$1;
        }
      }
      return result;
    };
  }

  var _getTag = getTag;

  /** Used for built-in method references. */
  var objectProto$d = Object.prototype;

  /** Used to check objects for own properties. */
  var hasOwnProperty$a = objectProto$d.hasOwnProperty;

  /**
   * Initializes an array clone.
   *
   * @private
   * @param {Array} array The array to clone.
   * @returns {Array} Returns the initialized clone.
   */
  function initCloneArray(array) {
    var length = array.length,
        result = new array.constructor(length);

    // Add properties assigned by `RegExp#exec`.
    if (length && typeof array[0] == 'string' && hasOwnProperty$a.call(array, 'index')) {
      result.index = array.index;
      result.input = array.input;
    }
    return result;
  }

  var _initCloneArray = initCloneArray;

  /**
   * Creates a clone of `dataView`.
   *
   * @private
   * @param {Object} dataView The data view to clone.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the cloned data view.
   */
  function cloneDataView(dataView, isDeep) {
    var buffer = isDeep ? _cloneArrayBuffer(dataView.buffer) : dataView.buffer;
    return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
  }

  var _cloneDataView = cloneDataView;

  /** Used to match `RegExp` flags from their coerced string values. */
  var reFlags = /\w*$/;

  /**
   * Creates a clone of `regexp`.
   *
   * @private
   * @param {Object} regexp The regexp to clone.
   * @returns {Object} Returns the cloned regexp.
   */
  function cloneRegExp(regexp) {
    var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
    result.lastIndex = regexp.lastIndex;
    return result;
  }

  var _cloneRegExp = cloneRegExp;

  /** Used to convert symbols to primitives and strings. */
  var symbolProto = _Symbol ? _Symbol.prototype : undefined,
      symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;

  /**
   * Creates a clone of the `symbol` object.
   *
   * @private
   * @param {Object} symbol The symbol object to clone.
   * @returns {Object} Returns the cloned symbol object.
   */
  function cloneSymbol(symbol) {
    return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
  }

  var _cloneSymbol = cloneSymbol;

  /** `Object#toString` result references. */
  var boolTag$1 = '[object Boolean]',
      dateTag$1 = '[object Date]',
      mapTag$2 = '[object Map]',
      numberTag$1 = '[object Number]',
      regexpTag$1 = '[object RegExp]',
      setTag$2 = '[object Set]',
      stringTag$1 = '[object String]',
      symbolTag = '[object Symbol]';

  var arrayBufferTag$1 = '[object ArrayBuffer]',
      dataViewTag$2 = '[object DataView]',
      float32Tag$1 = '[object Float32Array]',
      float64Tag$1 = '[object Float64Array]',
      int8Tag$1 = '[object Int8Array]',
      int16Tag$1 = '[object Int16Array]',
      int32Tag$1 = '[object Int32Array]',
      uint8Tag$1 = '[object Uint8Array]',
      uint8ClampedTag$1 = '[object Uint8ClampedArray]',
      uint16Tag$1 = '[object Uint16Array]',
      uint32Tag$1 = '[object Uint32Array]';

  /**
   * Initializes an object clone based on its `toStringTag`.
   *
   * **Note:** This function only supports cloning values with tags of
   * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
   *
   * @private
   * @param {Object} object The object to clone.
   * @param {string} tag The `toStringTag` of the object to clone.
   * @param {boolean} [isDeep] Specify a deep clone.
   * @returns {Object} Returns the initialized clone.
   */
  function initCloneByTag(object, tag, isDeep) {
    var Ctor = object.constructor;
    switch (tag) {
      case arrayBufferTag$1:
        return _cloneArrayBuffer(object);

      case boolTag$1:
      case dateTag$1:
        return new Ctor(+object);

      case dataViewTag$2:
        return _cloneDataView(object, isDeep);

      case float32Tag$1: case float64Tag$1:
      case int8Tag$1: case int16Tag$1: case int32Tag$1:
      case uint8Tag$1: case uint8ClampedTag$1: case uint16Tag$1: case uint32Tag$1:
        return _cloneTypedArray(object, isDeep);

      case mapTag$2:
        return new Ctor;

      case numberTag$1:
      case stringTag$1:
        return new Ctor(object);

      case regexpTag$1:
        return _cloneRegExp(object);

      case setTag$2:
        return new Ctor;

      case symbolTag:
        return _cloneSymbol(object);
    }
  }

  var _initCloneByTag = initCloneByTag;

  /** `Object#toString` result references. */
  var mapTag$3 = '[object Map]';

  /**
   * The base implementation of `_.isMap` without Node.js optimizations.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a map, else `false`.
   */
  function baseIsMap(value) {
    return isObjectLike_1(value) && _getTag(value) == mapTag$3;
  }

  var _baseIsMap = baseIsMap;

  /* Node.js helper references. */
  var nodeIsMap = _nodeUtil && _nodeUtil.isMap;

  /**
   * Checks if `value` is classified as a `Map` object.
   *
   * @static
   * @memberOf _
   * @since 4.3.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a map, else `false`.
   * @example
   *
   * _.isMap(new Map);
   * // => true
   *
   * _.isMap(new WeakMap);
   * // => false
   */
  var isMap = nodeIsMap ? _baseUnary(nodeIsMap) : _baseIsMap;

  var isMap_1 = isMap;

  /** `Object#toString` result references. */
  var setTag$3 = '[object Set]';

  /**
   * The base implementation of `_.isSet` without Node.js optimizations.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a set, else `false`.
   */
  function baseIsSet(value) {
    return isObjectLike_1(value) && _getTag(value) == setTag$3;
  }

  var _baseIsSet = baseIsSet;

  /* Node.js helper references. */
  var nodeIsSet = _nodeUtil && _nodeUtil.isSet;

  /**
   * Checks if `value` is classified as a `Set` object.
   *
   * @static
   * @memberOf _
   * @since 4.3.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a set, else `false`.
   * @example
   *
   * _.isSet(new Set);
   * // => true
   *
   * _.isSet(new WeakSet);
   * // => false
   */
  var isSet = nodeIsSet ? _baseUnary(nodeIsSet) : _baseIsSet;

  var isSet_1 = isSet;

  /** Used to compose bitmasks for cloning. */
  var CLONE_DEEP_FLAG = 1,
      CLONE_FLAT_FLAG = 2,
      CLONE_SYMBOLS_FLAG = 4;

  /** `Object#toString` result references. */
  var argsTag$2 = '[object Arguments]',
      arrayTag$1 = '[object Array]',
      boolTag$2 = '[object Boolean]',
      dateTag$2 = '[object Date]',
      errorTag$1 = '[object Error]',
      funcTag$2 = '[object Function]',
      genTag$1 = '[object GeneratorFunction]',
      mapTag$4 = '[object Map]',
      numberTag$2 = '[object Number]',
      objectTag$3 = '[object Object]',
      regexpTag$2 = '[object RegExp]',
      setTag$4 = '[object Set]',
      stringTag$2 = '[object String]',
      symbolTag$1 = '[object Symbol]',
      weakMapTag$2 = '[object WeakMap]';

  var arrayBufferTag$2 = '[object ArrayBuffer]',
      dataViewTag$3 = '[object DataView]',
      float32Tag$2 = '[object Float32Array]',
      float64Tag$2 = '[object Float64Array]',
      int8Tag$2 = '[object Int8Array]',
      int16Tag$2 = '[object Int16Array]',
      int32Tag$2 = '[object Int32Array]',
      uint8Tag$2 = '[object Uint8Array]',
      uint8ClampedTag$2 = '[object Uint8ClampedArray]',
      uint16Tag$2 = '[object Uint16Array]',
      uint32Tag$2 = '[object Uint32Array]';

  /** Used to identify `toStringTag` values supported by `_.clone`. */
  var cloneableTags = {};
  cloneableTags[argsTag$2] = cloneableTags[arrayTag$1] =
  cloneableTags[arrayBufferTag$2] = cloneableTags[dataViewTag$3] =
  cloneableTags[boolTag$2] = cloneableTags[dateTag$2] =
  cloneableTags[float32Tag$2] = cloneableTags[float64Tag$2] =
  cloneableTags[int8Tag$2] = cloneableTags[int16Tag$2] =
  cloneableTags[int32Tag$2] = cloneableTags[mapTag$4] =
  cloneableTags[numberTag$2] = cloneableTags[objectTag$3] =
  cloneableTags[regexpTag$2] = cloneableTags[setTag$4] =
  cloneableTags[stringTag$2] = cloneableTags[symbolTag$1] =
  cloneableTags[uint8Tag$2] = cloneableTags[uint8ClampedTag$2] =
  cloneableTags[uint16Tag$2] = cloneableTags[uint32Tag$2] = true;
  cloneableTags[errorTag$1] = cloneableTags[funcTag$2] =
  cloneableTags[weakMapTag$2] = false;

  /**
   * The base implementation of `_.clone` and `_.cloneDeep` which tracks
   * traversed objects.
   *
   * @private
   * @param {*} value The value to clone.
   * @param {boolean} bitmask The bitmask flags.
   *  1 - Deep clone
   *  2 - Flatten inherited properties
   *  4 - Clone symbols
   * @param {Function} [customizer] The function to customize cloning.
   * @param {string} [key] The key of `value`.
   * @param {Object} [object] The parent object of `value`.
   * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
   * @returns {*} Returns the cloned value.
   */
  function baseClone(value, bitmask, customizer, key, object, stack) {
    var result,
        isDeep = bitmask & CLONE_DEEP_FLAG,
        isFlat = bitmask & CLONE_FLAT_FLAG,
        isFull = bitmask & CLONE_SYMBOLS_FLAG;

    if (customizer) {
      result = object ? customizer(value, key, object, stack) : customizer(value);
    }
    if (result !== undefined) {
      return result;
    }
    if (!isObject_1(value)) {
      return value;
    }
    var isArr = isArray_1(value);
    if (isArr) {
      result = _initCloneArray(value);
      if (!isDeep) {
        return _copyArray(value, result);
      }
    } else {
      var tag = _getTag(value),
          isFunc = tag == funcTag$2 || tag == genTag$1;

      if (isBuffer_1(value)) {
        return _cloneBuffer(value, isDeep);
      }
      if (tag == objectTag$3 || tag == argsTag$2 || (isFunc && !object)) {
        result = (isFlat || isFunc) ? {} : _initCloneObject(value);
        if (!isDeep) {
          return isFlat
            ? _copySymbolsIn(value, _baseAssignIn(result, value))
            : _copySymbols(value, _baseAssign(result, value));
        }
      } else {
        if (!cloneableTags[tag]) {
          return object ? value : {};
        }
        result = _initCloneByTag(value, tag, isDeep);
      }
    }
    // Check for circular references and return its corresponding clone.
    stack || (stack = new _Stack);
    var stacked = stack.get(value);
    if (stacked) {
      return stacked;
    }
    stack.set(value, result);

    if (isSet_1(value)) {
      value.forEach(function(subValue) {
        result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
      });
    } else if (isMap_1(value)) {
      value.forEach(function(subValue, key) {
        result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
      });
    }

    var keysFunc = isFull
      ? (isFlat ? _getAllKeysIn : _getAllKeys)
      : (isFlat ? keysIn_1 : keys_1);

    var props = isArr ? undefined : keysFunc(value);
    _arrayEach(props || value, function(subValue, key) {
      if (props) {
        key = subValue;
        subValue = value[key];
      }
      // Recursively populate clone (susceptible to call stack limits).
      _assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
    });
    return result;
  }

  var _baseClone = baseClone;

  /** Used to compose bitmasks for cloning. */
  var CLONE_DEEP_FLAG$1 = 1,
      CLONE_SYMBOLS_FLAG$1 = 4;

  /**
   * This method is like `_.clone` except that it recursively clones `value`.
   *
   * @static
   * @memberOf _
   * @since 1.0.0
   * @category Lang
   * @param {*} value The value to recursively clone.
   * @returns {*} Returns the deep cloned value.
   * @see _.clone
   * @example
   *
   * var objects = [{ 'a': 1 }, { 'b': 2 }];
   *
   * var deep = _.cloneDeep(objects);
   * console.log(deep[0] === objects[0]);
   * // => false
   */
  function cloneDeep(value) {
    return _baseClone(value, CLONE_DEEP_FLAG$1 | CLONE_SYMBOLS_FLAG$1);
  }

  var cloneDeep_1 = cloneDeep;

  var DrawSource = /*#__PURE__*/function () {
    function DrawSource(data) {
      _classCallCheck(this, DrawSource);

      this.data = data || this.getDefaultData();
    }

    _createClass(DrawSource, [{
      key: "addFeature",
      value: function addFeature(feature) {
        this.data.features.push(feature);
      }
    }, {
      key: "getData",
      value: function getData() {
        var features = cloneDeep_1(this.data.features).map(function (feature) {
          var _feature$properties, _feature$properties2;

          feature.properties = {
            id: feature === null || feature === void 0 ? void 0 : (_feature$properties = feature.properties) === null || _feature$properties === void 0 ? void 0 : _feature$properties.id,
            type: feature === null || feature === void 0 ? void 0 : (_feature$properties2 = feature.properties) === null || _feature$properties2 === void 0 ? void 0 : _feature$properties2.type
          };
          return feature;
        });
        return {
          type: 'FeatureCollection',
          features: features
        };
      }
    }, {
      key: "getFeature",
      value: function getFeature(id) {
        var result = this.data.features.find(function (fe) {
          var _fe$properties;

          return (fe === null || fe === void 0 ? void 0 : (_fe$properties = fe.properties) === null || _fe$properties === void 0 ? void 0 : _fe$properties.id) === id;
        });
        return result;
      }
    }, {
      key: "removeAllFeatures",
      value: function removeAllFeatures() {
        this.data = this.getDefaultData();
      }
    }, {
      key: "removeFeature",
      value: function removeFeature(feature) {
        var index = this.getFeatureIndex(feature);

        if (index !== undefined) {
          this.data.features.splice(index, 1);
        }
      }
    }, {
      key: "setFeatureActive",
      value: function setFeatureActive(feature) {
        var _feature$properties3;

        var fe = this.getFeature(feature === null || feature === void 0 ? void 0 : (_feature$properties3 = feature.properties) === null || _feature$properties3 === void 0 ? void 0 : _feature$properties3.id);

        if (fe && fe.properties) {
          fe.properties.active = true;
        }
      }
    }, {
      key: "setFeatureUnActive",
      value: function setFeatureUnActive(feature) {
        var _feature$properties4;

        var fe = this.getFeature(feature === null || feature === void 0 ? void 0 : (_feature$properties4 = feature.properties) === null || _feature$properties4 === void 0 ? void 0 : _feature$properties4.id);

        if (fe && fe.properties) {
          fe.properties.active = false;
        }
      }
    }, {
      key: "clearFeatureActive",
      value: function clearFeatureActive() {
        this.data.features.forEach(function (fe) {
          if (fe && fe.properties) {
            fe.properties.active = false;
          }
        });
      }
    }, {
      key: "updateFeature",
      value: function updateFeature(feature) {
        this.removeFeature(feature);
        this.addFeature(feature);
      }
    }, {
      key: "destroy",
      value: function destroy() {
        this.data = this.getDefaultData();
      }
    }, {
      key: "getDefaultData",
      value: function getDefaultData() {
        return {
          type: 'FeatureCollection',
          features: []
        };
      }
    }, {
      key: "getFeatureIndex",
      value: function getFeatureIndex(feature) {
        return this.data.features.findIndex(function (fe) {
          var _fe$properties2, _feature$properties5;

          return (fe === null || fe === void 0 ? void 0 : (_fe$properties2 = fe.properties) === null || _fe$properties2 === void 0 ? void 0 : _fe$properties2.id) === (feature === null || feature === void 0 ? void 0 : (_feature$properties5 = feature.properties) === null || _feature$properties5 === void 0 ? void 0 : _feature$properties5.id);
        });
      }
    }]);

    return DrawSource;
  }();

  var LayerStyles = {
    active: {
      point: {
        type: 'PointLayer',
        shape: 'circle',
        color: '#fbb03b',
        size: 5,
        style: {
          stroke: '#fff',
          strokeWidth: 2
        }
      },
      line: {
        type: 'LineLayer',
        shape: 'line',
        color: '#fbb03b',
        size: 1,
        style: {
          opacity: 1,
          lineType: 'dash',
          dashArray: [2, 2]
        }
      },
      polygon: {
        shape: 'fill',
        color: '#fbb03b',
        style: {
          opacity: 0.1,
          stroke: '#fbb03b',
          strokeWidth: 1,
          strokeOpacity: 1,
          lineType: 'dash',
          dashArray: [2, 2]
        }
      }
    },
    normal: {
      polygon: {
        type: 'PolygonLayer',
        shape: 'fill',
        color: '#3bb2d0',
        style: {
          opacity: 0.1,
          stroke: '#3bb2d0',
          strokeWidth: 1,
          strokeOpacity: 1,
          lineType: 'solid',
          dashArray: [2, 2]
        }
      },
      line: {
        type: 'LineLayer',
        shape: 'line',
        size: 1,
        color: '#3bb2d0',
        style: {
          opacity: 1
        }
      },
      point: {
        type: 'PointLayer',
        shape: 'circle',
        color: '#3bb2d0',
        size: 3,
        style: {
          stroke: '#fff',
          strokeWidth: 2
        }
      }
    },
    normal_point: {
      type: 'PointLayer',
      shape: 'circle',
      color: '#3bb2d0',
      size: 3,
      style: {
        stroke: '#fff',
        strokeWidth: 2
      }
    },
    mid_point: {
      point: {
        type: 'PointLayer',
        shape: 'circle',
        color: '#fbb03b',
        size: 3,
        style: {}
      }
    }
  };

  var DrawFeatureId = 0;

  var DrawMode = /*#__PURE__*/function (_EventEmitter) {
    _inherits(DrawMode, _EventEmitter);

    var _super = _createSuper(DrawMode);

    function DrawMode(scene) {
      var _this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, DrawMode);

      _this = _super.call(this);
      _this.isEnable = false;
      _this.options = {
        style: LayerStyles
      };
      _this.drawStatus = 'Drawing';
      var data = options.data;
      _this.scene = scene;
      _this.source = new DrawSource(data);
      _this.options = merge_1(_this.options, _this.getDefaultOptions(), options);
      _this.title = _this.getOption('title');
      return _this;
    }

    _createClass(DrawMode, [{
      key: "enable",
      value: function enable() {
        if (this.isEnable) {
          return;
        } // @ts-ignore


        this.scene.setMapStatus({
          dragEnable: false
        });
        this.scene.on('dragstart', this.onDragStart);
        this.scene.on('dragging', this.onDragging);
        this.scene.on('dragend', this.onDragEnd);
        this.scene.on('click', this.onClick);
        this.setCursor(this.getOption('cursor'));
        this.isEnable = true;
      }
    }, {
      key: "disable",
      value: function disable() {
        if (!this.isEnable) {
          return;
        }

        this.scene.off('dragstart', this.onDragStart);
        this.scene.off('dragging', this.onDragging);
        this.scene.off('dragend', this.onDragEnd);
        this.scene.off('click', this.onClick);
        this.resetCursor(); // @ts-ignore

        this.scene.setMapStatus({
          dragEnable: true
        });
        this.isEnable = false;
      }
    }, {
      key: "setCurrentFeature",
      value: function setCurrentFeature(feature) {
        this.currentFeature = feature;
        this.source.setFeatureActive(feature);
      }
    }, {
      key: "setCurrentVertex",
      value: function setCurrentVertex(feature) {
        this.currentVertex = feature;
      }
    }, {
      key: "deleteCurrentFeature",
      value: function deleteCurrentFeature() {
        throw new Error('子类未实现该方法');
      }
    }, {
      key: "getCurrentVertex",
      value: function getCurrentVertex() {
        return this.currentVertex;
      }
    }, {
      key: "getCurrentFeature",
      value: function getCurrentFeature() {
        return this.currentFeature;
      }
    }, {
      key: "getOption",
      value: function getOption(key) {
        return this.options[key];
      }
    }, {
      key: "getStyle",
      value: function getStyle(id) {
        return this.getOption('style')[id];
      }
    }, {
      key: "getUniqId",
      value: function getUniqId() {
        return DrawFeatureId++;
      }
    }, {
      key: "setCursor",
      value: function setCursor(cursor) {
        var container = this.scene.getMapCanvasContainer();

        if (container) {
          container.style.cursor = cursor;
        }
      }
    }, {
      key: "resetCursor",
      value: function resetCursor() {
        var container = this.scene.getMapCanvasContainer();

        if (container) {
          container.removeAttribute('style');
        }
      }
    }, {
      key: "destroy",
      value: function destroy() {
        DrawFeatureId = 0;
        this.removeAllListeners();
        this.disable();
      }
    }, {
      key: "getDefaultOptions",
      value: function getDefaultOptions() {
        return {};
      }
    }, {
      key: "onClick",
      value: function onClick(e) {
        return null;
      }
    }]);

    return DrawMode;
  }(eventemitter3_1);

  var DrawDelete = /*#__PURE__*/function (_DrawFeature) {
    _inherits(DrawDelete, _DrawFeature);

    var _super = _createSuper(DrawDelete);

    // 绘制完成之后显示
    function DrawDelete(scene) {
      var _this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, DrawDelete);

      _this = _super.call(this, scene, options);

      _this.onDragging = function (e) {
        return;
      };

      _this.onDragEnd = function () {
        throw new Error('Method not implemented.');
      };

      _this.onClick = function () {
        return null;
      };

      return _this;
    }

    _createClass(DrawDelete, [{
      key: "enable",
      value: function enable() {
        this.emit(DrawEvent.DELETE, '');
      }
    }, {
      key: "disable",
      value: function disable() {
        return null;
      }
    }, {
      key: "getDefaultOptions",
      value: function getDefaultOptions() {
        return _objectSpread2(_objectSpread2({}, _get(_getPrototypeOf(DrawDelete.prototype), "getDefaultOptions", this).call(this)), {}, {
          title: '删除图形'
        });
      }
    }, {
      key: "onDragStart",
      value: function onDragStart(e) {
        throw new Error('Method not implemented.');
      }
    }]);

    return DrawDelete;
  }(DrawMode);

  var DrawEdit = /*#__PURE__*/function (_DrawFeature) {
    _inherits(DrawEdit, _DrawFeature);

    var _super = _createSuper(DrawEdit);

    // 绘制完成之后显示
    function DrawEdit(scene) {
      var _this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, DrawEdit);

      _this = _super.call(this, scene, options);

      _this.onDragStart = function (e) {// @ts-ignore
      };

      _this.onDragging = function (e) {
        _this.endPoint = e.lngLat;

        _this.emit(DrawEvent.Edit, _this.endPoint);

        return;
      };

      _this.onDragEnd = function () {
        _this.emit(DrawEvent.UPDATE, _this.currentFeature);

        _this.resetCursor();

        _this.disable();
      };

      _this.onClick = function () {
        return null;
      };

      return _this;
    }

    _createClass(DrawEdit, [{
      key: "setEditFeature",
      value: function setEditFeature(feature) {
        this.currentFeature = feature;
      }
    }, {
      key: "getDefaultOptions",
      value: function getDefaultOptions() {
        return {
          steps: 64,
          units: 'kilometres',
          cursor: 'move'
        };
      }
    }]);

    return DrawEdit;
  }(DrawMode);

  var DrawSelect = /*#__PURE__*/function (_DrawFeature) {
    _inherits(DrawSelect, _DrawFeature);

    var _super = _createSuper(DrawSelect);

    // 绘制完成之后显示
    function DrawSelect(scene) {
      var _this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, DrawSelect);

      _this = _super.call(this, scene, options);

      _this.onDragStart = function (e) {
        _this.scene.setMapStatus({
          dragEnable: false
        });

        _this.dragStartPoint = e.lngLat;
      };

      _this.onDragging = function (e) {
        var delta = {
          lng: e.lngLat.lng - _this.dragStartPoint.lng,
          lat: e.lngLat.lat - _this.dragStartPoint.lat
        };

        _this.emit(DrawEvent.Move, delta);

        _this.dragStartPoint = e.lngLat;
        return;
      };

      _this.onDragEnd = function () {
        _this.emit(DrawEvent.UPDATE, _this.currentFeature);
      };

      _this.onClick = function () {
        return null;
      };

      return _this;
    }

    _createClass(DrawSelect, [{
      key: "setSelectedFeature",
      value: function setSelectedFeature(feature) {
        this.currentFeature = feature;
      }
    }, {
      key: "getDefaultOptions",
      value: function getDefaultOptions() {
        return {
          steps: 64,
          units: 'kilometers',
          cursor: 'move'
        };
      }
    }]);

    return DrawSelect;
  }(DrawMode);

  var DrawFeature = /*#__PURE__*/function (_DrawMode) {
    _inherits(DrawFeature, _DrawMode);

    var _super = _createSuper(DrawFeature);

    function DrawFeature(scene) {
      var _this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, DrawFeature);

      _this = _super.call(this, scene, options);

      _this.onModeChange = function (mode) {
        var _this$currentFeature, _this$currentFeature$, _this$currentFeature2, _this$currentFeature3;

        switch (mode) {
          case DrawModes.DIRECT_SELECT:
            if (!_this.editEnable) {
              return;
            }

            _this.editMode.enable();

            _this.editMode.setEditFeature(_this.currentFeature);

            _this.drawLayer.updateData(helpers_13([_this.currentFeature]));

            _this.drawVertexLayer.updateData(helpers_13((_this$currentFeature = _this.currentFeature) === null || _this$currentFeature === void 0 ? void 0 : (_this$currentFeature$ = _this$currentFeature.properties) === null || _this$currentFeature$ === void 0 ? void 0 : _this$currentFeature$.pointFeatures));

            _this.drawVertexLayer.show();

            _this.drawVertexLayer.enableEdit();

            _this.showOtherLayer();

            _this.drawStatus = 'DrawEdit';
            break;

          case DrawModes.SIMPLE_SELECT:
            if (!_this.selectEnable) {
              _this.drawLayer.hide();

              _this.drawVertexLayer.hide();

              _this.hideOtherLayer();

              _this.emit(DrawEvent.MODE_CHANGE, DrawModes.STATIC);

              return;
            }

            _this.selectMode.setSelectedFeature(_this.currentFeature);

            _this.selectMode.enable();

            _this.drawLayer.updateData( // TODO:导入数据不能正常使用
            helpers_13([_this.currentFeature]));

            _this.drawLayer.enableSelect();

            _this.drawVertexLayer.updateData(helpers_13((_this$currentFeature2 = _this.currentFeature) === null || _this$currentFeature2 === void 0 ? void 0 : (_this$currentFeature3 = _this$currentFeature2.properties) === null || _this$currentFeature3 === void 0 ? void 0 : _this$currentFeature3.pointFeatures));

            _this.drawVertexLayer.disableEdit();

            _this.drawVertexLayer.show();

            _this.drawLayer.show();

            _this.showOtherLayer();

            _this.drawStatus = 'DrawSelected';
            break;

          case DrawModes.STATIC:
            _this.source.updateFeature(_this.currentFeature);

            _this.selectMode.disable();

            _this.editMode.disable();

            _this.source.clearFeatureActive();

            _this.drawVertexLayer.hide();

            _this.drawVertexLayer.disableEdit();

            _this.hideOtherLayer();

            _this.normalLayer.update(_this.source.data);

            _this.normalLayer.enableSelect();

            _this.drawStatus = 'DrawFinish';
            break;
        }
      };

      _this.onDrawCreate = function (feature) {
        _this.source.addFeature(feature);
      };

      _this.onDrawUpdate = function (feature) {
        _this.source.updateFeature(_this.currentFeature);

        _this.emit(DrawEvent.UPDATE, _this.currentFeature);
      };

      _this.onDrawMove = function (delta) {
        if (_this.drawStatus === 'DrawSelected') {
          _this.moveFeature(delta);
        }
      };

      _this.onDrawEdit = function (endpoint) {
        _this.editFeature(endpoint);
      };

      _this.onDrawDelete = function () {
        if (_this.drawStatus === 'DrawSelected') {
          _this.clear();

          _this.source.removeFeature(_this.currentFeature);

          _this.normalLayer.update(_this.source.data);

          _this.drawLayer.disableSelect();

          _this.selectMode.disable();

          _this.currentFeature = null; // this.drawStatus = 'DrawDelete';
        }
      };

      _this.addKeyDownEvent = function (event) {
        // tslint:disable-next-line:no-arg
        var e = event || window.event;

        if (e && e.keyCode === 8) {
          _this.deleteMode.enable();
        }
      };

      _this.drawLayer = new DrawLayer(_assertThisInitialized(_this));
      _this.drawVertexLayer = new DrawVertexLayer(_assertThisInitialized(_this));
      _this.normalLayer = new DrawResultLayer(_assertThisInitialized(_this));
      _this.selectEnable = _this.getOption('selectEnable');
      _this.editEnable = _this.getOption('editEnable'); // this.editLayer = new EditLayer(this);

      _this.selectMode = new DrawSelect(_this.scene, {});
      _this.editMode = new DrawEdit(_this.scene, {});
      _this.deleteMode = new DrawDelete(_this.scene, {});

      _this.selectMode.on(DrawEvent.UPDATE, _this.onDrawUpdate);

      _this.selectMode.on(DrawEvent.Move, _this.onDrawMove);

      _this.editMode.on(DrawEvent.MODE_CHANGE, _this.onModeChange);

      _this.editMode.on(DrawEvent.UPDATE, _this.onDrawUpdate);

      _this.editMode.on(DrawEvent.Edit, _this.onDrawEdit);

      _this.selectMode.on(DrawEvent.MODE_CHANGE, _this.onModeChange);

      _this.deleteMode.on(DrawEvent.DELETE, _this.onDrawDelete);

      _this.on(DrawEvent.CREATE, _this.onDrawCreate);

      _this.on(DrawEvent.MODE_CHANGE, _this.onModeChange);

      document.addEventListener('keydown', _this.addKeyDownEvent);

      if (_this.options.data && _this.initData()) {
        _this.normalLayer.update(_this.source.data);

        _this.normalLayer.enableSelect();
      }

      return _this;
    }

    _createClass(DrawFeature, [{
      key: "setCurrentFeature",
      value: function setCurrentFeature(feature) {
        this.currentFeature = feature; // @ts-ignore

        this.pointFeatures = feature.properties.pointFeatures;
        this.source.setFeatureActive(feature);
      }
    }, {
      key: "deleteCurrentFeature",
      value: function deleteCurrentFeature() {
        this.deleteMode.enable();
      }
    }, {
      key: "disableLayer",
      value: function disableLayer() {
        // this.emit(DrawEvent.MODE_CHANGE, DrawModes.STATIC);
        this.drawLayer.disableSelect();
      }
    }, {
      key: "enableLayer",
      value: function enableLayer() {
        this.drawLayer.enableSelect();
      }
    }, {
      key: "getData",
      value: function getData() {
        return this.source.getData();
      }
    }, {
      key: "removeAllData",
      value: function removeAllData() {
        this.source.removeAllFeatures();
        this.currentFeature = null;
        this.drawLayer.hide();
        this.drawVertexLayer.hide();
        this.normalLayer.hide();
        this.hideOtherLayer();
      }
    }, {
      key: "clear",
      value: function clear() {
        this.drawLayer.disableSelect();
        this.drawLayer.disableEdit();
        this.drawLayer.hide();
        this.drawVertexLayer.hide();
        this.hideOtherLayer();
        this.emit(DrawEvent.MODE_CHANGE, DrawModes.STATIC);
      }
    }, {
      key: "reset",
      value: function reset() {
        this.drawLayer.show();
        this.drawVertexLayer.show();
        this.showOtherLayer();
      }
    }, {
      key: "addVertex",
      value: function addVertex(feature) {
        throw new Error('子类未实现该方法');
      }
    }, {
      key: "onRemove",
      value: function onRemove() {
        this.destroy();
        this.selectMode.destroy();
        this.editMode.destroy();
        this.source.destroy();
        this.drawLayer.destroy();
        this.drawVertexLayer.destroy();
        this.normalLayer.destroy();
        document.removeEventListener('keydown', this.addKeyDownEvent);
      }
    }, {
      key: "getDefaultOptions",
      value: function getDefaultOptions() {
        return {
          steps: 64,
          units: 'kilometers',
          cursor: 'crosshair',
          editEnable: true,
          selectEnable: true
        };
      }
    }, {
      key: "initData",
      value: function initData() {
        return false;
      }
    }, {
      key: "addDrawPopup",
      value: function addDrawPopup(lnglat, dis) {
        var popup = new l7.Popup({
          anchor: 'left',
          closeButton: false
        }).setLnglat(lnglat).setText("\u534A\u5F84:".concat(dis.toFixed(2), "\u5343\u7C73"));
        this.scene.addPopup(popup);
        this.popup = popup;
      }
    }]);

    return DrawFeature;
  }(DrawMode);

  var DrawCircle = /*#__PURE__*/function (_DrawFeature) {
    _inherits(DrawCircle, _DrawFeature);

    var _super = _createSuper(DrawCircle);

    function DrawCircle(scene) {
      var _this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, DrawCircle);

      _this = _super.call(this, scene, options);

      _this.onDragStart = function (e) {
        if (_this.drawStatus !== 'Drawing') {
          _this.drawLayer.emit('unclick', null);
        }

        _this.startPoint = e.lngLat;

        _this.setCursor('grabbing');

        _this.initCenterLayer();

        _this.centerLayer.setData([_this.startPoint]);
      };

      _this.onDragging = function (e) {
        _this.endPoint = e.lngLat;

        var feature = _this.createFeature();

        var properties = feature.properties;

        _this.drawLayer.update(helpers_13([feature]));

        _this.drawVertexLayer.update(helpers_13(properties.pointFeatures));
      };

      _this.onDragEnd = function () {
        var feature = _this.createFeature("".concat(_this.getUniqId()));

        var properties = feature.properties;

        _this.drawLayer.update(helpers_13([feature]));

        _this.drawVertexLayer.update(helpers_13(properties.pointFeatures));

        _this.emit(DrawEvent.CREATE, _this.currentFeature);

        _this.emit(DrawEvent.MODE_CHANGE, DrawModes.SIMPLE_SELECT);

        _this.disable();
      };

      _this.type = 'circle';
      return _this;
    }

    _createClass(DrawCircle, [{
      key: "drawFinish",
      value: function drawFinish() {
        return null;
      }
    }, {
      key: "setCurrentFeature",
      value: function setCurrentFeature(feature) {
        this.currentFeature = feature; // @ts-ignore

        this.pointFeatures = feature.properties.pointFeatures; // @ts-ignore

        this.startPoint = feature.properties.startPoint; // @ts-ignore

        this.endPoint = feature.properties.endPoint;
        this.source.setFeatureActive(feature);
      }
    }, {
      key: "getDefaultOptions",
      value: function getDefaultOptions() {
        return _objectSpread2(_objectSpread2({}, _get(_getPrototypeOf(DrawCircle.prototype), "getDefaultOptions", this).call(this)), {}, {
          title: '绘制圆'
        });
      }
    }, {
      key: "moveFeature",
      value: function moveFeature(delta) {
        var newFeature = moveFeatures([this.currentFeature], delta);
        this.drawLayer.updateData(helpers_13(newFeature));
        var newPointFeture = moveFeatures(this.pointFeatures, delta);
        this.drawVertexLayer.updateData(helpers_13(newPointFeture));
        var newStartPoint = movePoint([this.startPoint.lng, this.startPoint.lat], delta);
        this.startPoint = {
          lat: newStartPoint[1],
          lng: newStartPoint[0]
        };
        var newEndPoint = movePoint([this.endPoint.lng, this.endPoint.lat], delta);
        var endPointObj = {
          lat: newEndPoint[1],
          lng: newEndPoint[0]
        };
        newFeature[0].properties = _objectSpread2(_objectSpread2({}, newFeature[0].properties), {}, {
          startPoint: this.startPoint,
          endPoint: endPointObj,
          pointFeatures: newPointFeture
        });
        this.centerLayer.setData([this.startPoint]);
        this.setCurrentFeature(newFeature[0]);

        var changeFeature = _objectSpread2({}, newFeature[0]);

        this.emit(DrawEvent.CHANGE, changeFeature);
      }
    }, {
      key: "createFeature",
      value: function createFeature() {
        var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '0';
        var points = createPoint([this.endPoint]);
        var feature = createCircle([this.startPoint.lng, this.startPoint.lat], [this.endPoint.lng, this.endPoint.lat], {
          pointFeatures: points.features,
          units: this.getOption('units'),
          steps: this.getOption('steps'),
          id: id
        });
        this.setCurrentFeature(feature);
        return feature;
      }
    }, {
      key: "editFeature",
      value: function editFeature(endPoint) {
        this.endPoint = endPoint;
        var newFeature = this.createFeature();
        var properties = newFeature.properties;
        this.drawLayer.updateData(helpers_13([newFeature]));
        this.drawVertexLayer.updateData(helpers_13(properties.pointFeatures));
        this.emit(DrawEvent.CHANGE, helpers_13([newFeature]).features[0]);
      }
    }, {
      key: "showOtherLayer",
      value: function showOtherLayer() {
        var _this$currentFeature, _this$currentFeature$;

        this.centerLayer.setData([(_this$currentFeature = this.currentFeature) === null || _this$currentFeature === void 0 ? void 0 : (_this$currentFeature$ = _this$currentFeature.properties) === null || _this$currentFeature$ === void 0 ? void 0 : _this$currentFeature$.startPoint]);
        this.centerLayer.show();
      }
    }, {
      key: "hideOtherLayer",
      value: function hideOtherLayer() {
        if (this.currentFeature) {
          this.centerLayer.hide();
        }
      }
    }, {
      key: "initCenterLayer",
      value: function initCenterLayer() {
        var centerStyle = this.getStyle('active').point;
        var layer = new l7.PointLayer().source([this.startPoint], {
          parser: {
            type: 'json',
            x: 'lng',
            y: 'lat'
          }
        }).shape('circle').color(centerStyle.color).size(centerStyle.size).style(centerStyle.style);
        this.scene.addLayer(layer);
        this.centerLayer = layer;
      }
    }]);

    return DrawCircle;
  }(DrawFeature);

  /**
   * Earth Radius used with the Harvesine formula and approximates using a spherical (non-ellipsoid) Earth.
   */

  /**
   * Converts an angle in radians to degrees
   *
   * @name radiansToDegrees
   * @param {number} radians angle in radians
   * @returns {number} degrees between 0 and 360 degrees
   */
  function radiansToDegrees(radians) {
      if (radians === null || radians === undefined) throw new Error('radians is required');

      var degrees = radians % (2 * Math.PI);
      return degrees * 180 / Math.PI;
  }

  /**
   * Converts an angle in degrees to radians
   *
   * @name degreesToRadians
   * @param {number} degrees angle between 0 and 360 degrees
   * @returns {number} angle in radians
   */
  function degreesToRadians(degrees) {
      if (degrees === null || degrees === undefined) throw new Error('degrees is required');

      var radians = degrees % 360;
      return radians * Math.PI / 180;
  }

  /**
   * isObject
   *
   * @param {*} input variable to validate
   * @returns {boolean} true/false
   * @example
   * turf.isObject({elevation: 10})
   * //=true
   * turf.isObject('foo')
   * //=false
   */
  function isObject$1(input) {
      return (!!input) && (input.constructor === Object);
  }

  /**
   * Unwrap a coordinate from a Point Feature, Geometry or a single coordinate.
   *
   * @name getCoord
   * @param {Array<number>|Geometry<Point>|Feature<Point>} coord GeoJSON Point or an Array of numbers
   * @returns {Array<number>} coordinates
   * @example
   * var pt = turf.point([10, 10]);
   *
   * var coord = turf.getCoord(pt);
   * //= [10, 10]
   */
  function getCoord(coord) {
      if (!coord) throw new Error('coord is required');
      if (coord.type === 'Feature' && coord.geometry !== null && coord.geometry.type === 'Point') return coord.geometry.coordinates;
      if (coord.type === 'Point') return coord.coordinates;
      if (Array.isArray(coord) && coord.length >= 2 && coord[0].length === undefined && coord[1].length === undefined) return coord;

      throw new Error('coord must be GeoJSON Point or an Array of numbers');
  }

  //http://en.wikipedia.org/wiki/Haversine_formula
  //http://www.movable-type.co.uk/scripts/latlong.html

  /**
   * Takes two {@link Point|points} and finds the geographic bearing between them,
   * i.e. the angle measured in degrees from the north line (0 degrees)
   *
   * @name bearing
   * @param {Coord} start starting Point
   * @param {Coord} end ending Point
   * @param {Object} [options={}] Optional parameters
   * @param {boolean} [options.final=false] calculates the final bearing if true
   * @returns {number} bearing in decimal degrees, between -180 and 180 degrees (positive clockwise)
   * @example
   * var point1 = turf.point([-75.343, 39.984]);
   * var point2 = turf.point([-75.534, 39.123]);
   *
   * var bearing = turf.bearing(point1, point2);
   *
   * //addToMap
   * var addToMap = [point1, point2]
   * point1.properties['marker-color'] = '#f00'
   * point2.properties['marker-color'] = '#0f0'
   * point1.properties.bearing = bearing
   */
  function bearing(start, end, options) {
      // Optional parameters
      options = options || {};
      if (!isObject$1(options)) throw new Error('options is invalid');
      var final = options.final;

      // Reverse calculation
      if (final === true) return calculateFinalBearing(start, end);

      var coordinates1 = getCoord(start);
      var coordinates2 = getCoord(end);

      var lon1 = degreesToRadians(coordinates1[0]);
      var lon2 = degreesToRadians(coordinates2[0]);
      var lat1 = degreesToRadians(coordinates1[1]);
      var lat2 = degreesToRadians(coordinates2[1]);
      var a = Math.sin(lon2 - lon1) * Math.cos(lat2);
      var b = Math.cos(lat1) * Math.sin(lat2) -
          Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon2 - lon1);

      return radiansToDegrees(Math.atan2(a, b));
  }

  /**
   * Calculates Final Bearing
   *
   * @private
   * @param {Coord} start starting Point
   * @param {Coord} end ending Point
   * @returns {number} bearing
   */
  function calculateFinalBearing(start, end) {
      // Swap start & end
      var bear = bearing(end, start);
      bear = (bear + 180) % 360;
      return bear;
  }

  /**
   * Earth Radius used with the Harvesine formula and approximates using a spherical (non-ellipsoid) Earth.
   */
  var earthRadius = 6371008.8;

  /**
   * Unit of measurement factors using a spherical (non-ellipsoid) earth radius.
   */
  var factors = {
      meters: earthRadius,
      metres: earthRadius,
      millimeters: earthRadius * 1000,
      millimetres: earthRadius * 1000,
      centimeters: earthRadius * 100,
      centimetres: earthRadius * 100,
      kilometers: earthRadius / 1000,
      kilometres: earthRadius / 1000,
      miles: earthRadius / 1609.344,
      nauticalmiles: earthRadius / 1852,
      inches: earthRadius * 39.370,
      yards: earthRadius / 1.0936,
      feet: earthRadius * 3.28084,
      radians: 1,
      degrees: earthRadius / 111325,
  };

  /**
   * Wraps a GeoJSON {@link Geometry} in a GeoJSON {@link Feature}.
   *
   * @name feature
   * @param {Geometry} geometry input geometry
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the Feature
   * @returns {Feature} a GeoJSON Feature
   * @example
   * var geometry = {
   *   "type": "Point",
   *   "coordinates": [110, 50]
   * };
   *
   * var feature = turf.feature(geometry);
   *
   * //=feature
   */
  function feature(geometry, properties, options) {
      // Optional Parameters
      options = options || {};
      if (!isObject$2(options)) throw new Error('options is invalid');
      var bbox = options.bbox;
      var id = options.id;

      // Validation
      if (geometry === undefined) throw new Error('geometry is required');
      if (properties && properties.constructor !== Object) throw new Error('properties must be an Object');
      if (bbox) validateBBox(bbox);
      if (id) validateId(id);

      // Main
      var feat = {type: 'Feature'};
      if (id) feat.id = id;
      if (bbox) feat.bbox = bbox;
      feat.properties = properties || {};
      feat.geometry = geometry;
      return feat;
  }

  /**
   * Creates a {@link Point} {@link Feature} from a Position.
   *
   * @name point
   * @param {Array<number>} coordinates longitude, latitude position (each in decimal degrees)
   * @param {Object} [properties={}] an Object of key-value pairs to add as properties
   * @param {Object} [options={}] Optional Parameters
   * @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
   * @param {string|number} [options.id] Identifier associated with the Feature
   * @returns {Feature<Point>} a Point feature
   * @example
   * var point = turf.point([-75.343, 39.984]);
   *
   * //=point
   */
  function point(coordinates, properties, options) {
      if (!coordinates) throw new Error('coordinates is required');
      if (!Array.isArray(coordinates)) throw new Error('coordinates must be an Array');
      if (coordinates.length < 2) throw new Error('coordinates must be at least 2 numbers long');
      if (!isNumber(coordinates[0]) || !isNumber(coordinates[1])) throw new Error('coordinates must contain numbers');

      return feature({
          type: 'Point',
          coordinates: coordinates
      }, properties, options);
  }

  /**
   * Convert a distance measurement (assuming a spherical Earth) from radians to a more friendly unit.
   * Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
   *
   * @name radiansToLength
   * @param {number} radians in radians across the sphere
   * @param {string} [units='kilometers'] can be degrees, radians, miles, or kilometers inches, yards, metres, meters, kilometres, kilometers.
   * @returns {number} distance
   */
  function radiansToLength(radians, units) {
      if (radians === undefined || radians === null) throw new Error('radians is required');

      if (units && typeof units !== 'string') throw new Error('units must be a string');
      var factor = factors[units || 'kilometers'];
      if (!factor) throw new Error(units + ' units is invalid');
      return radians * factor;
  }

  /**
   * Convert a distance measurement (assuming a spherical Earth) from a real-world unit into radians
   * Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
   *
   * @name lengthToRadians
   * @param {number} distance in real units
   * @param {string} [units='kilometers'] can be degrees, radians, miles, or kilometers inches, yards, metres, meters, kilometres, kilometers.
   * @returns {number} radians
   */
  function lengthToRadians(distance, units) {
      if (distance === undefined || distance === null) throw new Error('distance is required');

      if (units && typeof units !== 'string') throw new Error('units must be a string');
      var factor = factors[units || 'kilometers'];
      if (!factor) throw new Error(units + ' units is invalid');
      return distance / factor;
  }

  /**
   * Converts an angle in radians to degrees
   *
   * @name radiansToDegrees
   * @param {number} radians angle in radians
   * @returns {number} degrees between 0 and 360 degrees
   */
  function radiansToDegrees$1(radians) {
      if (radians === null || radians === undefined) throw new Error('radians is required');

      var degrees = radians % (2 * Math.PI);
      return degrees * 180 / Math.PI;
  }

  /**
   * Converts an angle in degrees to radians
   *
   * @name degreesToRadians
   * @param {number} degrees angle between 0 and 360 degrees
   * @returns {number} angle in radians
   */
  function degreesToRadians$1(degrees) {
      if (degrees === null || degrees === undefined) throw new Error('degrees is required');

      var radians = degrees % 360;
      return radians * Math.PI / 180;
  }

  /**
   * isNumber
   *
   * @param {*} num Number to validate
   * @returns {boolean} true/false
   * @example
   * turf.isNumber(123)
   * //=true
   * turf.isNumber('foo')
   * //=false
   */
  function isNumber(num) {
      return !isNaN(num) && num !== null && !Array.isArray(num);
  }

  /**
   * isObject
   *
   * @param {*} input variable to validate
   * @returns {boolean} true/false
   * @example
   * turf.isObject({elevation: 10})
   * //=true
   * turf.isObject('foo')
   * //=false
   */
  function isObject$2(input) {
      return (!!input) && (input.constructor === Object);
  }

  /**
   * Validate BBox
   *
   * @private
   * @param {Array<number>} bbox BBox to validate
   * @returns {void}
   * @throws Error if BBox is not valid
   * @example
   * validateBBox([-180, -40, 110, 50])
   * //=OK
   * validateBBox([-180, -40])
   * //=Error
   * validateBBox('Foo')
   * //=Error
   * validateBBox(5)
   * //=Error
   * validateBBox(null)
   * //=Error
   * validateBBox(undefined)
   * //=Error
   */
  function validateBBox(bbox) {
      if (!bbox) throw new Error('bbox is required');
      if (!Array.isArray(bbox)) throw new Error('bbox must be an Array');
      if (bbox.length !== 4 && bbox.length !== 6) throw new Error('bbox must be an Array of 4 or 6 numbers');
      bbox.forEach(function (num) {
          if (!isNumber(num)) throw new Error('bbox must only contain numbers');
      });
  }

  /**
   * Validate Id
   *
   * @private
   * @param {string|number} id Id to validate
   * @returns {void}
   * @throws Error if Id is not valid
   * @example
   * validateId([-180, -40, 110, 50])
   * //=Error
   * validateId([-180, -40])
   * //=Error
   * validateId('Foo')
   * //=OK
   * validateId(5)
   * //=OK
   * validateId(null)
   * //=Error
   * validateId(undefined)
   * //=Error
   */
  function validateId(id) {
      if (!id) throw new Error('id is required');
      if (['string', 'number'].indexOf(typeof id) === -1) throw new Error('id must be a number or a string');
  }

  /**
   * Unwrap a coordinate from a Point Feature, Geometry or a single coordinate.
   *
   * @name getCoord
   * @param {Array<number>|Geometry<Point>|Feature<Point>} coord GeoJSON Point or an Array of numbers
   * @returns {Array<number>} coordinates
   * @example
   * var pt = turf.point([10, 10]);
   *
   * var coord = turf.getCoord(pt);
   * //= [10, 10]
   */
  function getCoord$1(coord) {
      if (!coord) throw new Error('coord is required');
      if (coord.type === 'Feature' && coord.geometry !== null && coord.geometry.type === 'Point') return coord.geometry.coordinates;
      if (coord.type === 'Point') return coord.coordinates;
      if (Array.isArray(coord) && coord.length >= 2 && coord[0].length === undefined && coord[1].length === undefined) return coord;

      throw new Error('coord must be GeoJSON Point or an Array of numbers');
  }

  //http://en.wikipedia.org/wiki/Haversine_formula
  //http://www.movable-type.co.uk/scripts/latlong.html
  /**
   * Takes a {@link Point} and calculates the location of a destination point given a distance in degrees, radians, miles, or kilometers; and bearing in degrees. This uses the [Haversine formula](http://en.wikipedia.org/wiki/Haversine_formula) to account for global curvature.
   *
   * @name destination
   * @param {Coord} origin starting point
   * @param {number} distance distance from the origin point
   * @param {number} bearing ranging from -180 to 180
   * @param {Object} [options={}] Optional parameters
   * @param {string} [options.units='kilometers'] miles, kilometers, degrees, or radians
   * @param {Object} [options.properties={}] Translate properties to Point
   * @returns {Feature<Point>} destination point
   * @example
   * var point = turf.point([-75.343, 39.984]);
   * var distance = 50;
   * var bearing = 90;
   * var options = {units: 'miles'};
   *
   * var destination = turf.destination(point, distance, bearing, options);
   *
   * //addToMap
   * var addToMap = [point, destination]
   * destination.properties['marker-color'] = '#f00';
   * point.properties['marker-color'] = '#0f0';
   */
  function destination(origin, distance, bearing, options) {
      // Optional parameters
      options = options || {};
      if (!isObject$2(options)) throw new Error('options is invalid');
      var units = options.units;
      var properties = options.properties;

      // Handle input
      var coordinates1 = getCoord$1(origin);
      var longitude1 = degreesToRadians$1(coordinates1[0]);
      var latitude1 = degreesToRadians$1(coordinates1[1]);
      var bearing_rad = degreesToRadians$1(bearing);
      var radians = lengthToRadians(distance, units);

      // Main
      var latitude2 = Math.asin(Math.sin(latitude1) * Math.cos(radians) +
          Math.cos(latitude1) * Math.sin(radians) * Math.cos(bearing_rad));
      var longitude2 = longitude1 + Math.atan2(Math.sin(bearing_rad) * Math.sin(radians) * Math.cos(latitude1),
          Math.cos(radians) - Math.sin(latitude1) * Math.sin(latitude2));
      var lng = radiansToDegrees$1(longitude2);
      var lat = radiansToDegrees$1(latitude2);

      return point([lng, lat], properties);
  }

  //http://en.wikipedia.org/wiki/Haversine_formula
  //http://www.movable-type.co.uk/scripts/latlong.html

  /**
   * Calculates the distance between two {@link Point|points} in degrees, radians,
   * miles, or kilometers. This uses the
   * [Haversine formula](http://en.wikipedia.org/wiki/Haversine_formula)
   * to account for global curvature.
   *
   * @name distance
   * @param {Coord} from origin point
   * @param {Coord} to destination point
   * @param {Object} [options={}] Optional parameters
   * @param {string} [options.units='kilometers'] can be degrees, radians, miles, or kilometers
   * @returns {number} distance between the two points
   * @example
   * var from = turf.point([-75.343, 39.984]);
   * var to = turf.point([-75.534, 39.123]);
   * var options = {units: 'miles'};
   *
   * var distance = turf.distance(from, to, options);
   *
   * //addToMap
   * var addToMap = [from, to];
   * from.properties.distance = distance;
   * to.properties.distance = distance;
   */
  function distance(from, to, options) {
      // Optional parameters
      options = options || {};
      if (!isObject$2(options)) throw new Error('options is invalid');
      var units = options.units;

      var coordinates1 = getCoord$1(from);
      var coordinates2 = getCoord$1(to);
      var dLat = degreesToRadians$1((coordinates2[1] - coordinates1[1]));
      var dLon = degreesToRadians$1((coordinates2[0] - coordinates1[0]));
      var lat1 = degreesToRadians$1(coordinates1[1]);
      var lat2 = degreesToRadians$1(coordinates2[1]);

      var a = Math.pow(Math.sin(dLat / 2), 2) +
            Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1) * Math.cos(lat2);

      return radiansToLength(2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)), units);
  }

  /**
   * Takes two {@link Point|points} and returns a point midway between them.
   * The midpoint is calculated geodesically, meaning the curvature of the earth is taken into account.
   *
   * @name midpoint
   * @param {Coord} point1 first point
   * @param {Coord} point2 second point
   * @returns {Feature<Point>} a point midway between `pt1` and `pt2`
   * @example
   * var point1 = turf.point([144.834823, -37.771257]);
   * var point2 = turf.point([145.14244, -37.830937]);
   *
   * var midpoint = turf.midpoint(point1, point2);
   *
   * //addToMap
   * var addToMap = [point1, point2, midpoint];
   * midpoint.properties['marker-color'] = '#f00';
   */
  function midpoint(point1, point2) {
      var dist = distance(point1, point2);
      var heading = bearing(point1, point2);
      var midpoint = destination(point1, dist / 2, heading);

      return midpoint;
  }

  var DrawVertexLayer$1 = /*#__PURE__*/function (_BaseRender) {
    _inherits(DrawVertexLayer, _BaseRender);

    var _super = _createSuper(DrawVertexLayer);

    function DrawVertexLayer() {
      var _this;

      _classCallCheck(this, DrawVertexLayer);

      _this = _super.apply(this, arguments);

      _this.onMouseEnter = function (e) {
        _this.draw.setCursor('pointer');
      };

      _this.onMouseOut = function (e) {
        _this.draw.resetCursor();
      };

      _this.onClick = function (e) {
        _this.draw.addVertex(e.feature); // 添加一个顶点 1.更新顶点 2.更新重点

      };

      return _this;
    }

    _createClass(DrawVertexLayer, [{
      key: "update",
      value: function update(pointFeatures) {
        this.removeLayers();
        var midFeatures = this.calcMidPointData(pointFeatures);
        var style = this.draw.getStyle('mid_point');
        this.drawLayers = renderFeature(midFeatures, style);
        this.addLayers();
        this.enableEdit();
      }
    }, {
      key: "updateData",
      value: function updateData(data) {
        var midFeatures = this.calcMidPointData(data);
        this.drawLayers.forEach(function (layer) {
          return layer.setData(midFeatures);
        });
      }
    }, {
      key: "enableEdit",
      value: function enableEdit() {
        var layer = this.drawLayers[0];
        layer.on('mouseenter', this.onMouseEnter);
        layer.on('mouseout', this.onMouseOut);
        layer.on('click', this.onClick);
      }
    }, {
      key: "disableEdit",
      value: function disableEdit() {
        var layer = this.drawLayers[0];
        layer.off('mouseenter', this.onMouseEnter);
        layer.off('mouseout', this.onMouseOut);
        layer.off('click', this.onClick);
      }
    }, {
      key: "calcMidPointData",
      value: function calcMidPointData(fe) {
        var _this2 = this;

        var midFeatures = [];
        fe.features.forEach(function (item, index) {
          var preFeature = item;

          if (_this2.draw.type === 'line' && index === fe.features.length - 1) {
            return;
          }

          var nextFeature = index !== fe.features.length - 1 ? fe.features[index + 1] : fe.features[0]; // @ts-ignore

          var point = midpoint(preFeature, nextFeature); // @ts-ignore

          point.properties.id = index;
          midFeatures.push(point);
        });
        return helpers_13(midFeatures);
      }
    }]);

    return DrawVertexLayer;
  }(BaseRenderLayer);

  var DrawPolygon = /*#__PURE__*/function (_DrawFeature) {
    _inherits(DrawPolygon, _DrawFeature);

    var _super = _createSuper(DrawPolygon);

    function DrawPolygon(scene) {
      var _this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, DrawPolygon);

      _this = _super.call(this, scene, options);
      _this.points = [];

      _this.onDragStart = function (e) {
        return null;
      };

      _this.onDragging = function (e) {
        return null;
      };

      _this.onDragEnd = function () {
        return null;
      };

      _this.onClick = function (e) {
        if (_this.drawStatus !== 'Drawing') {
          _this.drawLayer.emit('unclick', null);
        }

        var lngLat = e.lngLat || e.lnglat;
        _this.endPoint = lngLat;

        _this.points.push(lngLat);

        var feature = _this.createFeature(_this.points);

        var pointfeatures = createPoint([_this.points[0], _this.endPoint]);

        _this.drawLayer.update(helpers_13([feature]));

        _this.drawVertexLayer.update(helpers_13(pointfeatures.features));

        _this.onDraw();
      };

      _this.onMouseMove = function (e) {
        var lngLat = e.lngLat || e.lnglat;

        if (_this.points.length === 0) {
          return;
        }

        var tmpPoints = _this.points.slice();

        tmpPoints.push(lngLat);

        var feature = _this.createFeature(tmpPoints);

        _this.drawLayer.update(helpers_13([feature]));
      };

      _this.onDblClick = function (e) {
        var lngLat = e.lngLat || e.lnglat;

        if (_this.points.length < 2) {
          return;
        }

        _this.points.push(lngLat);

        _this.drawFinish();
      };

      _this.onDraw = function () {
        _this.drawVertexLayer.on('mousemove', function (e) {
          _this.setCursor('pointer');
        });

        _this.drawVertexLayer.on('mouseout', function () {
          _this.setCursor('crosshair');
        });

        _this.drawVertexLayer.on('click', function () {
          _this.resetCursor();

          _this.drawFinish();
        });
      };

      _this.type = 'polygon';
      _this.drawMidVertexLayer = new DrawVertexLayer$1(_assertThisInitialized(_this));

      _this.on(DrawEvent.MODE_CHANGE, _this.addMidLayerEvent);

      return _this;
    }

    _createClass(DrawPolygon, [{
      key: "enable",
      value: function enable() {
        _get(_getPrototypeOf(DrawPolygon.prototype), "enable", this).call(this);

        this.scene.on('mousemove', this.onMouseMove);
        this.scene.on('dblclick', this.onDblClick); // 关闭双击放大
      }
    }, {
      key: "disable",
      value: function disable() {
        _get(_getPrototypeOf(DrawPolygon.prototype), "disable", this).call(this);

        this.scene.off('mousemove', this.onMouseMove);
        this.scene.off('dblclick', this.onDblClick);
      }
    }, {
      key: "drawFinish",
      value: function drawFinish() {
        this.points = this.points.reverse();
        var feature = this.createFeature(this.points);
        var properties = feature.properties;
        this.drawLayer.update(helpers_13([feature]));
        this.drawVertexLayer.update(helpers_13(properties.pointFeatures)); // @ts-ignore

        this.emit(DrawEvent.CREATE, this.currentFeature);
        this.emit(DrawEvent.MODE_CHANGE, DrawModes.SIMPLE_SELECT);
        this.points = [];
        this.disable();
      }
    }, {
      key: "addVertex",
      value: function addVertex(vertex) {
        var _vertex$geometry, _feature$geometry;

        // @ts-ignore
        var id = vertex.properties.id;
        var coord = vertex === null || vertex === void 0 ? void 0 : (_vertex$geometry = vertex.geometry) === null || _vertex$geometry === void 0 ? void 0 : _vertex$geometry.coordinates;
        var feature = this.currentFeature;
        var type = feature === null || feature === void 0 ? void 0 : (_feature$geometry = feature.geometry) === null || _feature$geometry === void 0 ? void 0 : _feature$geometry.type;
        var points = [];

        if (type === 'Polygon') {
          var _feature$geometry2;

          var coords = feature === null || feature === void 0 ? void 0 : (_feature$geometry2 = feature.geometry) === null || _feature$geometry2 === void 0 ? void 0 : _feature$geometry2.coordinates;
          coords[0].splice(id + 1, 0, coord);

          for (var i = 0; i < coords[0].length - 1; i++) {
            points.push({
              lng: coords[0][i][0],
              lat: coords[0][i][1]
            });
          }
        } else {
          var _feature$geometry3;

          var _coords = feature === null || feature === void 0 ? void 0 : (_feature$geometry3 = feature.geometry) === null || _feature$geometry3 === void 0 ? void 0 : _feature$geometry3.coordinates;

          _coords.splice(id + 1, 0, coord);

          var _iterator = _createForOfIteratorHelper(_coords),
              _step;

          try {
            for (_iterator.s(); !(_step = _iterator.n()).done;) {
              var coor = _step.value;
              points.push({
                lng: coor[0],
                lat: coor[1]
              });
            }
          } catch (err) {
            _iterator.e(err);
          } finally {
            _iterator.f();
          }
        }

        var pointfeatures = createPoint(points);
        this.pointFeatures = pointfeatures.features;
        this.drawLayer.updateData(helpers_13([feature]));
        this.drawVertexLayer.updateData(pointfeatures);
        this.drawMidVertexLayer.updateData(helpers_13(this.pointFeatures)); // @ts-ignore

        feature.properties.pointFeatures = pointfeatures.features;
        this.setCurrentFeature(feature);
      }
    }, {
      key: "getDefaultOptions",
      value: function getDefaultOptions() {
        return _objectSpread2(_objectSpread2({}, _get(_getPrototypeOf(DrawPolygon.prototype), "getDefaultOptions", this).call(this)), {}, {
          title: '绘制多边形'
        });
      }
    }, {
      key: "moveFeature",
      value: function moveFeature(delta) {
        var newFeature = moveFeatures([this.currentFeature], delta);
        var newPointFeture = moveFeatures(this.pointFeatures, delta);
        this.drawLayer.updateData(helpers_13(newFeature));
        this.drawVertexLayer.updateData(helpers_13(newPointFeture));
        newFeature[0].properties = _objectSpread2(_objectSpread2({}, newFeature[0].properties), {}, {
          pointFeatures: newPointFeture
        });
        this.setCurrentFeature(newFeature[0]);
      }
    }, {
      key: "createFeature",
      value: function createFeature(points, id) {
        var active = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
        var pointfeatures = createPoint(points);
        this.pointFeatures = pointfeatures.features;
        var feature = createPolygon(points, {
          id: id || this.getUniqId(),
          type: 'polygon',
          active: active,
          pointFeatures: this.pointFeatures
        });
        this.setCurrentFeature(feature);
        return feature;
      }
    }, {
      key: "editFeature",
      value: function editFeature(vertex) {
        var selectVertexed = this.currentVertex;

        if (selectVertexed === null) {
          return;
        } else {
          var _this$currentFeature;

          // @ts-ignore
          var id = selectVertexed.properties.id * 1; // @ts-ignore

          selectVertexed.geometry.coordinates = [vertex.lng, vertex.lat]; // @ts-ignore

          this.pointFeatures[id].geometry.coordinates = [vertex.lng, vertex.lat];
          this.drawVertexLayer.updateData(helpers_13(this.pointFeatures));
          this.drawMidVertexLayer.updateData(helpers_13(this.pointFeatures));
          this.editPolygonVertex(id, vertex);
          this.drawLayer.updateData(helpers_13([this.currentFeature]));
          var feature = this.currentFeature;
          feature.properties = _objectSpread2(_objectSpread2({}, (_this$currentFeature = this.currentFeature) === null || _this$currentFeature === void 0 ? void 0 : _this$currentFeature.properties), {}, {
            pointFeatures: this.pointFeatures
          });
          this.setCurrentFeature(feature);
        }
      }
    }, {
      key: "showOtherLayer",
      value: function showOtherLayer() {
        // if (this.editMode.isEnable) {
        //   this.drawMidVertexLayer.update(featureCollection(this.pointFeatures));
        //   this.drawMidVertexLayer.show();
        // }
        return null;
      }
    }, {
      key: "hideOtherLayer",
      value: function hideOtherLayer() {
        return null;
      }
    }, {
      key: "addMidLayerEvent",
      value: function addMidLayerEvent(mode) {
        switch (mode) {
          case DrawModes.DIRECT_SELECT:
            this.drawMidVertexLayer.update(helpers_13(this.pointFeatures));
            this.drawMidVertexLayer.show();
            break;

          case DrawModes.STATIC:
            this.drawMidVertexLayer.hide();
            break;
        }
      }
    }, {
      key: "initData",
      value: function initData() {
        var _this2 = this;

        var features = [];
        this.source.data.features.forEach(function (feature) {
          if (feature.geometry.type === 'Polygon') {
            var _feature$properties;

            var points = feature.geometry.coordinates[0].map(function (coord) {
              return {
                lng: coord[0],
                lat: coord[1]
              };
            });
            features.push(_this2.createFeature(points.slice(1), feature === null || feature === void 0 ? void 0 : (_feature$properties = feature.properties) === null || _feature$properties === void 0 ? void 0 : _feature$properties.id, false));
          }
        });
        this.source.data.features = features;
        return true;
      }
    }, {
      key: "editPolygonVertex",
      value: function editPolygonVertex(id, vertex) {
        var _feature$geometry4;

        var feature = this.currentFeature;
        var type = feature === null || feature === void 0 ? void 0 : (_feature$geometry4 = feature.geometry) === null || _feature$geometry4 === void 0 ? void 0 : _feature$geometry4.type;

        if (type === 'Polygon') {
          var _feature$geometry5;

          var coords = feature === null || feature === void 0 ? void 0 : (_feature$geometry5 = feature.geometry) === null || _feature$geometry5 === void 0 ? void 0 : _feature$geometry5.coordinates;
          coords[0][id] = [vertex.lng, vertex.lat];

          if (-id === 0) {
            coords[0][coords[0].length - 1] = [vertex.lng, vertex.lat];
          }
        } else {
          var _feature$geometry6;

          var _coords2 = feature === null || feature === void 0 ? void 0 : (_feature$geometry6 = feature.geometry) === null || _feature$geometry6 === void 0 ? void 0 : _feature$geometry6.coordinates;

          _coords2[id] = [vertex.lng, vertex.lat];
        }

        this.setCurrentFeature(feature);
        this.drawLayer.updateData(helpers_13([this.currentFeature]));
      }
    }]);

    return DrawPolygon;
  }(DrawFeature);

  var DrawLine = /*#__PURE__*/function (_DrawPolygon) {
    _inherits(DrawLine, _DrawPolygon);

    var _super = _createSuper(DrawLine);

    function DrawLine(scene) {
      var _this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, DrawLine);

      _this = _super.call(this, scene, options);
      _this.type = 'line';
      return _this;
    }

    _createClass(DrawLine, [{
      key: "getDefaultOptions",
      value: function getDefaultOptions() {
        return _objectSpread2(_objectSpread2({}, _get(_getPrototypeOf(DrawLine.prototype), "getDefaultOptions", this).call(this)), {}, {
          title: '绘制线'
        });
      }
    }, {
      key: "moveFeature",
      value: function moveFeature(delta) {
        var newFeature = moveFeatures([this.currentFeature], delta);
        var newPointFeture = moveFeatures(this.pointFeatures, delta);
        this.drawLayer.updateData(helpers_13(newFeature));
        this.drawVertexLayer.updateData(helpers_13(newPointFeture));
        this.currentFeature = newFeature[0];
        this.pointFeatures = newPointFeture;
        return this.currentFeature;
      }
    }, {
      key: "createFeature",
      value: function createFeature(points, id) {
        var active = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
        var pointfeatures = createPoint(points);
        this.pointFeatures = pointfeatures.features;
        var feature = createLine(points, {
          id: id || this.getUniqId(),
          type: 'line',
          active: active,
          pointFeatures: this.pointFeatures
        });
        this.setCurrentFeature(feature);
        return feature;
      }
    }, {
      key: "initData",
      value: function initData() {
        var _this2 = this;

        var features = [];
        this.source.data.features.forEach(function (feature) {
          if (feature.geometry.type === 'LineString') {
            var _feature$properties;

            // @ts-ignore
            var points = feature.geometry.coordinates.map(function (coord) {
              return {
                lng: coord[0],
                lat: coord[1]
              };
            });
            features.push(_this2.createFeature(points, feature === null || feature === void 0 ? void 0 : (_feature$properties = feature.properties) === null || _feature$properties === void 0 ? void 0 : _feature$properties.id, false));
          }
        });
        this.source.data.features = features;
        return true;
      }
    }]);

    return DrawLine;
  }(DrawPolygon);

  var DrawPoint = /*#__PURE__*/function (_DrawFeature) {
    _inherits(DrawPoint, _DrawFeature);

    var _super = _createSuper(DrawPoint);

    function DrawPoint(scene) {
      var _this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, DrawPoint);

      _this = _super.call(this, scene, options);

      _this.onDragStart = function (e) {
        return null;
      };

      _this.onDragging = function (e) {
        return null;
      };

      _this.onDragEnd = function () {
        return null;
      };

      _this.onClick = function (e) {
        if (_this.drawStatus !== 'Drawing') {
          _this.drawLayer.emit('unclick', null);
        }

        var lngLat = e.lngLat || e.lnglat;

        var feature = _this.createFeature(lngLat);

        _this.drawLayer.update(helpers_13([feature]));

        _this.drawVertexLayer.update(helpers_13([feature]));

        _this.drawFinish();
      };

      _this.type = 'point';
      return _this;
    }

    _createClass(DrawPoint, [{
      key: "drawFinish",
      value: function drawFinish() {
        this.emit(DrawEvent.CREATE, this.currentFeature);
        this.emit(DrawEvent.MODE_CHANGE, DrawModes.SIMPLE_SELECT);
        this.disable();
      }
    }, {
      key: "getDefaultOptions",
      value: function getDefaultOptions() {
        return _objectSpread2(_objectSpread2({}, _get(_getPrototypeOf(DrawPoint.prototype), "getDefaultOptions", this).call(this)), {}, {
          title: '绘制点'
        });
      }
    }, {
      key: "moveFeature",
      value: function moveFeature(delta) {
        var newFeature = moveFeatures([this.currentFeature], delta);
        this.drawLayer.updateData(helpers_13(newFeature));
        this.drawVertexLayer.updateData(helpers_13(newFeature));
        this.currentFeature = newFeature[0];
        this.pointFeatures = newFeature;
        this.currentFeature.properties = _objectSpread2(_objectSpread2({}, this.currentFeature.properties), {}, {
          pointFeatures: newFeature
        });
        return this.currentFeature;
      }
    }, {
      key: "createFeature",
      value: function createFeature(p, id) {
        var active = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
        var feature = helpers_7([p.lng, p.lat], {
          id: id || this.getUniqId(),
          type: 'point',
          active: active,
          pointFeatures: [helpers_7([p.lng, p.lat])]
        });
        this.setCurrentFeature(feature);
        return feature;
      }
    }, {
      key: "initData",
      value: function initData() {
        var _this2 = this;

        var features = [];
        this.source.data.features.forEach(function (feature) {
          if (feature.geometry.type === 'Point') {
            var _feature$properties;

            var p = {
              lng: feature.geometry.coordinates[0],
              lat: feature.geometry.coordinates[1]
            };
            features.push(_this2.createFeature(p, feature === null || feature === void 0 ? void 0 : (_feature$properties = feature.properties) === null || _feature$properties === void 0 ? void 0 : _feature$properties.id, false));
          }
        });
        this.source.data.features = features;
        return true;
      }
    }, {
      key: "editFeature",
      value: function editFeature(endPoint) {
        this.createFeature(endPoint);
      }
    }, {
      key: "showOtherLayer",
      value: function showOtherLayer() {
        return null;
      }
    }, {
      key: "hideOtherLayer",
      value: function hideOtherLayer() {
        return null;
      }
    }]);

    return DrawPoint;
  }(DrawFeature);

  var DrawRect = /*#__PURE__*/function (_DrawCircle) {
    _inherits(DrawRect, _DrawCircle);

    var _super = _createSuper(DrawRect);

    function DrawRect(scene) {
      var _this;

      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, DrawRect);

      _this = _super.call(this, scene, options);
      _this.type = 'rect';
      return _this;
    }

    _createClass(DrawRect, [{
      key: "drawFinish",
      value: function drawFinish() {
        return null;
      }
    }, {
      key: "getDefaultOptions",
      value: function getDefaultOptions() {
        return _objectSpread2(_objectSpread2({}, _get(_getPrototypeOf(DrawRect.prototype), "getDefaultOptions", this).call(this)), {}, {
          title: '绘制矩形'
        });
      }
    }, {
      key: "createFeature",
      value: function createFeature() {
        var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '0';
        var points = createPoint([this.endPoint]);
        var feature = createRect([this.startPoint.lng, this.startPoint.lat], [this.endPoint.lng, this.endPoint.lat], {
          id: id,
          pointFeatures: points.features
        });
        this.setCurrentFeature(feature);
        return feature;
      }
    }]);

    return DrawRect;
  }(DrawCircle);

  function styleInject(css, ref) {
    if ( ref === void 0 ) ref = {};
    var insertAt = ref.insertAt;

    if (!css || typeof document === 'undefined') { return; }

    var head = document.head || document.getElementsByTagName('head')[0];
    var style = document.createElement('style');
    style.type = 'text/css';

    if (insertAt === 'top') {
      if (head.firstChild) {
        head.insertBefore(style, head.firstChild);
      } else {
        head.appendChild(style);
      }
    } else {
      head.appendChild(style);
    }

    if (style.styleSheet) {
      style.styleSheet.cssText = css;
    } else {
      style.appendChild(document.createTextNode(css));
    }
  }

  var css = ".l7-control-draw {\n  border-radius: 4px;\n  background: #fff;\n  box-shadow: 0 0 0 1px rgba(0, 0, 0, 0.1);\n  display: flex;\n}\n.l7-control-draw button {\n  background-repeat: no-repeat;\n  background-position: center;\n  background-size: 20px 20px;\n  background-color: #fff;\n  width: 30px;\n  height: 30px;\n  display: block;\n  padding: 0;\n  outline: none;\n  border: 0;\n  margin: 1px;\n  box-sizing: border-box;\n  cursor: pointer;\n}\n.l7-control-draw button:not(:disabled):hover {\n  background-color: rgba(0, 0, 0, 0.05);\n}\n.l7-control-draw button:focus {\n  box-shadow: 0 0 2px 2px #0096ff;\n}\n.l7-control-draw .draw-point {\n  background-image: url('data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBzdGFuZGFsb25lPSJubyI/PjwhRE9DVFlQRSBzdmcgUFVCTElDICItLy9XM0MvL0RURCBTVkcgMS4xLy9FTiIgImh0dHA6Ly93d3cudzMub3JnL0dyYXBoaWNzL1NWRy8xLjEvRFREL3N2ZzExLmR0ZCI+PHN2ZyB0PSIxNTg1NjYxMTY0NjA0IiBjbGFzcz0iaWNvbiIgdmlld0JveD0iMCAwIDExOTQgMTAyNCIgdmVyc2lvbj0iMS4xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHAtaWQ9IjI5MzUiIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iMTQ5LjI1IiBoZWlnaHQ9IjEyOCI+PGRlZnM+PHN0eWxlIHR5cGU9InRleHQvY3NzIj48L3N0eWxlPjwvZGVmcz48cGF0aCBkPSJNNjA5LjUzNiA3MDcuMDcyYTE5NS4wNzIgMTk1LjA3MiAwIDEgMSAwLTM5MC4xNDQgMTk1LjA3MiAxOTUuMDcyIDAgMCAxIDAgMzkwLjE0NHoiIGZpbGw9IiMyYzJjMmMiIHAtaWQ9IjI5MzYiPjwvcGF0aD48cGF0aCBkPSJNMTA0OC40MDUzMzMgNDE0LjQ2NGExNDYuMjYxMzMzIDE0Ni4yNjEzMzMgMCAxIDEgMC0yOTIuNTIyNjY3IDE0Ni4yNjEzMzMgMTQ2LjI2MTMzMyAwIDAgMSAwIDI5Mi41MjI2Njd6TTE3MC42NjY2NjcgOTk5LjU5NDY2N2ExNDYuMjYxMzMzIDE0Ni4yNjEzMzMgMCAxIDEgMC0yOTIuNTIyNjY3IDE0Ni4yNjEzMzMgMTQ2LjI2MTMzMyAwIDAgMSAwIDI5Mi41MjI2Njd6IG0wLTY4Mi42NjY2NjdBMTQ2LjI2MTMzMyAxNDYuMjYxMzMzIDAgMSAxIDE3MC42NjY2NjcgMjQuNDA1MzMzYTE0Ni4yNjEzMzMgMTQ2LjI2MTMzMyAwIDAgMSAwIDI5Mi41MjI2Njd6IiBmaWxsPSIjMmMyYzJjIiBwLWlkPSIyOTM3Ij48L3BhdGg+PC9zdmc+');\n}\n.l7-control-draw .draw-line {\n  background-image: url('data:image/svg+xml;base64,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');\n}\n.l7-control-draw .draw-polygon {\n  background-image: url('data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBzdGFuZGFsb25lPSJubyI/PjwhRE9DVFlQRSBzdmcgUFVCTElDICItLy9XM0MvL0RURCBTVkcgMS4xLy9FTiIgImh0dHA6Ly93d3cudzMub3JnL0dyYXBoaWNzL1NWRy8xLjEvRFREL3N2ZzExLmR0ZCI+PHN2ZyB0PSIxNTg1NjI5MzI3Nzc1IiBjbGFzcz0iaWNvbiIgdmlld0JveD0iMCAwIDEwMjQgMTAyNCIgdmVyc2lvbj0iMS4xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHAtaWQ9IjE3MzkiIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iMTI4IiBoZWlnaHQ9IjEyOCI+PGRlZnM+PHN0eWxlIHR5cGU9InRleHQvY3NzIj48L3N0eWxlPjwvZGVmcz48cGF0aCBkPSJNNDIxLjE0OSA5OTAuNDA0bC0xNDMuMzE4LTEzNy4xNS00My42NzktNDEuNzY0TDMxLjg0OSA2MTcuODUzbDIzNC4wNzQtNDg1LjQ4OCAxMjUuMTQxIDE3LjAyNiAxMDMuNjE0IDE0LjA0MS04LjA1NyA1OS40NTYtMTAzLjYzLTE0LjA0My04MS45Ni0xMS4xNTEtOTguMTAzIDIwMy40MzItOTguMTA1IDIwMy41MTkgMTcwLjgwNiAxNjMuNDkgNDMuNjgxIDQxLjc2NiAzNi4xNTcgMzQuNjE2IDc1LjY5OCA3Mi40IDM2LjUyOS0xOS42MjEgNTUuNzE4LTI5Ljk3MSA1MS43MDctMjcuNzM2IDUxLjgzNC0yNy45NjcgMTcuMTEtOS4xMTQgMTcuMTg4LTkuMyAzNC40NzYtMTguNDggMTcuMjM5LTkuMyAzNC41NDItMTguNTA1IDE3LjMxNS05LjM4NyAxNy4yNTYtOS4yMDEgNDYuOTgtMjUuMjkzLTQuOTk1LTI3LjM3NS04LjgzNi00OC45NjYtMTUuMzQxLTg0Ljg5MSA1OS4wNDQtMTAuNjcgMTUuMzQyIDg0Ljg5OCA4LjgyNyA0OC45MTggMTIuODMxIDcwLjMyOC0zMy43MTcgMTguMDQ5LTUxLjgyNyAyNy45MDQtMTcuMjM2IDkuMTktMTcuMjcyIDkuMzY1LTM0LjQ5MyAxOC40NzgtMzQuNTMxIDE4LjU3Ni0xNy4yMTMgOS4yMi0xNy4yOTIgOS4zNTYtMTcuMDk3IDkuMTA2LTE3LjIxOCA5LjMzNXoiIGZpbGw9IiMzRTNBMzkiIHAtaWQ9IjE3NDAiPjwvcGF0aD48cGF0aCBkPSJNNzUyLjUyNCA1NS40MzRoNjB2MzcwLjMyM2gtNjB6IiBmaWxsPSIjM0UzQTM5IiBwLWlkPSIxNzQxIj48L3BhdGg+PHBhdGggZD0iTTU5Ny4zODUgMjA1LjY5N2gzNzAuMjc5djYwSDU5Ny4zODV6IiBmaWxsPSIjM0UzQTM5IiBwLWlkPSIxNzQyIj48L3BhdGg+PC9zdmc+');\n}\n.l7-control-draw .draw-rect {\n  background-image: url('data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBzdGFuZGFsb25lPSJubyI/PjwhRE9DVFlQRSBzdmcgUFVCTElDICItLy9XM0MvL0RURCBTVkcgMS4xLy9FTiIgImh0dHA6Ly93d3cudzMub3JnL0dyYXBoaWNzL1NWRy8xLjEvRFREL3N2ZzExLmR0ZCI+PHN2ZyB0PSIxNTg1NjI5Mjk5NTYxIiBjbGFzcz0iaWNvbiIgdmlld0JveD0iMCAwIDEwMjQgMTAyNCIgdmVyc2lvbj0iMS4xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHAtaWQ9IjEwMDEiIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iMTI4IiBoZWlnaHQ9IjEyOCI+PGRlZnM+PHN0eWxlIHR5cGU9InRleHQvY3NzIj48L3N0eWxlPjwvZGVmcz48cGF0aCBkPSJNNzY1LjIzNCA2OS40MTdoNjB2MzcwLjYwNWgtNjB6IiBmaWxsPSIjM0UzQTM5IiBwLWlkPSIxMDAyIj48L3BhdGg+PHBhdGggZD0iTTYxNC4xOTMgMjE5LjgwN2gzNjIuMTI4djYwSDYxNC4xOTN6IiBmaWxsPSIjM0UzQTM5IiBwLWlkPSIxMDAzIj48L3BhdGg+PHBhdGggZD0iTTgyNS4yMzQgOTc1LjkzNkg4OS44MTlWMjI0LjcwN2gzNjcuNzA4djYwSDE0OS44MTl2NjMxLjIyOWg2MTUuNDE1VjYwMC4yOTloNjB6IiBmaWxsPSIjM0UzQTM5IiBwLWlkPSIxMDA0Ij48L3BhdGg+PC9zdmc+');\n}\n.l7-control-draw .draw-circle {\n  background-image: url('data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBzdGFuZGFsb25lPSJubyI/PjwhRE9DVFlQRSBzdmcgUFVCTElDICItLy9XM0MvL0RURCBTVkcgMS4xLy9FTiIgImh0dHA6Ly93d3cudzMub3JnL0dyYXBoaWNzL1NWRy8xLjEvRFREL3N2ZzExLmR0ZCI+PHN2ZyB0PSIxNTg1NjI5MjYwMDI2IiBjbGFzcz0iaWNvbiIgdmlld0JveD0iMCAwIDEwMjQgMTAyNCIgdmVyc2lvbj0iMS4xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHAtaWQ9IjI3NzYiIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iMTI4IiBoZWlnaHQ9IjEyOCI+PGRlZnM+PHN0eWxlIHR5cGU9InRleHQvY3NzIj48L3N0eWxlPjwvZGVmcz48cGF0aCBkPSJNNTEyIDg4MS4wNjY2NjdBMzY5LjA2NjY2NyAzNjkuMDY2NjY3IDAgMSAxIDg4MS4wNjY2NjcgNTEyIDM2OS40OTMzMzMgMzY5LjQ5MzMzMyAwIDAgMSA1MTIgODgxLjA2NjY2N3ogbTAtNjgyLjY2NjY2N0EzMTMuNiAzMTMuNiAwIDEgMCA4MjUuNiA1MTIgMzE0LjAyNjY2NyAzMTQuMDI2NjY3IDAgMCAwIDUxMiAxOTguNHoiIGZpbGw9IiIgcC1pZD0iMjc3NyI+PC9wYXRoPjwvc3ZnPg==');\n}\n.l7-control-draw .draw-delete {\n  background-image: url('data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBzdGFuZGFsb25lPSJubyI/PjwhRE9DVFlQRSBzdmcgUFVCTElDICItLy9XM0MvL0RURCBTVkcgMS4xLy9FTiIgImh0dHA6Ly93d3cudzMub3JnL0dyYXBoaWNzL1NWRy8xLjEvRFREL3N2ZzExLmR0ZCI+PHN2ZyB0PSIxNTg1NzMwNDEyNjU0IiBjbGFzcz0iaWNvbiIgdmlld0JveD0iMCAwIDEwMjQgMTAyNCIgdmVyc2lvbj0iMS4xIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHAtaWQ9IjQ4MDQiIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB3aWR0aD0iMTI4IiBoZWlnaHQ9IjEyOCI+PGRlZnM+PHN0eWxlIHR5cGU9InRleHQvY3NzIj48L3N0eWxlPjwvZGVmcz48cGF0aCBkPSJNMjEzLjMzMzMzMyAyODIuODM3MzMzYzAtMjAuNjkzMzMzIDE2LjE3MDY2Ny0zNy40MTg2NjcgMzYuMDk2LTM3LjQxODY2NmgxODAuNDh2LTM3LjM3NmMwLTIwLjY1MDY2NyAxNi4yMTMzMzMtMzcuMzc2IDM2LjEzODY2Ny0zNy4zNzZoNzIuMTkyYzE5Ljk2OCAwIDM2LjEzODY2NyAxNi43MjUzMzMgMzYuMTM4NjY3IDM3LjM3NnYzNy4zNzZoMTgwLjQ4YzE5Ljk2OCAwIDM2LjA5NiAxNi43MjUzMzMgMzYuMDk2IDM3LjQxODY2NnYzNy4zNzZIMjEzLjMzMzMzM3YtMzcuMzc2eiBtNTQxLjUyNTMzNCAxMTIuMTI4djQyMC45OTJjMCAyMC42MDgtMTYuMTI4IDM3LjM3Ni0zNi4wOTYgMzcuMzc2SDI4NS41MjUzMzNjLTE5LjkyNTMzMyAwLTM2LjA5Ni0xNi43NjgtMzYuMDk2LTM3LjM3NlYzNTcuNTQ2NjY3aDUwNS40MjkzMzR2MzcuMzc2ek0zOTMuODU2IDQ2OS43NmMwLTIwLjY1MDY2Ny0xNi4xNzA2NjctMzcuNDE4NjY3LTM2LjA5Ni0zNy40MTg2NjctMTkuOTY4IDAtMzYuMTM4NjY3IDE2Ljc2OC0zNi4xMzg2NjcgMzcuNDE4NjY3djI3MS40MDI2NjdjMCAyMC42NTA2NjcgMTYuMjEzMzMzIDM3LjQxODY2NyAzNi4xMzg2NjcgMzcuNDE4NjY2IDE5LjkyNTMzMyAwIDM2LjA5Ni0xNi43NjggMzYuMDk2LTM3LjQxODY2NlY0NjkuNzZ6IG0xNDQuMzg0IDBjMC0yMC42NTA2NjctMTYuMTI4LTM3LjQxODY2Ny0zNi4wOTYtMzcuNDE4NjY3LTE5LjkyNTMzMyAwLTM2LjA5NiAxNi43NjgtMzYuMDk2IDM3LjQxODY2N3YyNzEuNDAyNjY3YzAgMjAuNjUwNjY3IDE2LjE3MDY2NyAzNy40MTg2NjcgMzYuMDk2IDM3LjQxODY2NiAxOS45NjggMCAzNi4wOTYtMTYuNzY4IDM2LjA5Ni0zNy40MTg2NjZWNDY5Ljc2eiBtMTQ0LjQyNjY2NyAwYzAtMjAuNjUwNjY3LTE2LjE3MDY2Ny0zNy40MTg2NjctMzYuMDk2LTM3LjQxODY2Ny0xOS45NjggMC0zNi4wOTYgMTYuNzY4LTM2LjA5NiAzNy40MTg2Njd2MjcxLjQwMjY2N2MwIDIwLjY1MDY2NyAxNi4xMjggMzcuNDE4NjY3IDM2LjA5NiAzNy40MTg2NjYgMTkuOTI1MzMzIDAgMzYuMDk2LTE2Ljc2OCAzNi4wOTYtMzcuNDE4NjY2VjQ2OS43NnoiIHAtaWQ9IjQ4MDUiPjwvcGF0aD48L3N2Zz4=');\n}\n.horizontal {\n  flex-direction: row;\n}\n.horizontal button:focus:first-child {\n  border-radius: 4px 0px 0px 4px;\n}\n.horizontal button:focus:last-child {\n  border-radius: 0px 4px 4px 4px;\n}\n.horizontal button + button {\n  border-left: 1px solid #eee;\n}\n.vertical {\n  flex-direction: column;\n}\n.vertical button:focus:first-child {\n  border-radius: 4px 4px 0 0;\n}\n.vertical button:focus:last-child {\n  border-radius: 0px 0px 4px 4px;\n}\n.vertical button + button {\n  border-top: 1px solid #eee;\n}\n";
  styleInject(css);

  var DrawType = {
    point: DrawPoint,
    line: DrawLine,
    polygon: DrawPolygon,
    circle: DrawCircle,
    rect: DrawRect
  };
  var DrawControl = /*#__PURE__*/function (_Control) {
    _inherits(DrawControl, _Control);

    var _super = _createSuper(DrawControl);

    function DrawControl(scene, options) {
      var _this;

      _classCallCheck(this, DrawControl);

      _this = _super.call(this, options);
      _this.draw = {};

      _this.onButtonClick = function (type, e) {
        for (var draw in _this.draw) {
          if (draw === type) {
            _this.draw[draw].enable();
          } else {
            _this.draw[draw].disable();
          }
        }
      };

      _this.onDeleteMode = function (type, e) {
        e.stopPropagation();

        if (!_this.currentDraw) {
          return;
        }

        _this.currentDraw.deleteMode.enable();

        return false;
      };

      _this.onModeChange = function (type, mode) {
        if (mode === DrawModes.SIMPLE_SELECT) {
          _this.currentDraw = _this.draw[type];
        }
      };

      _this.scene = scene;
      return _this;
    }

    _createClass(DrawControl, [{
      key: "getDefault",
      value: function getDefault() {
        return {
          position: l7.PositionType.TOPLEFT,
          controls: {
            point: true,
            line: true,
            polygon: true,
            rect: true,
            circle: true,
            delete: true
          },
          name: 'draw'
        };
      }
    }, {
      key: "onAdd",
      value: function onAdd() {
        var layout = this.controlOption.layout;
        var controlClass = 'l7-control-draw' + ' ' + layout;
        var controls = this.controlOption.controls;
        var container = l7.DOM.create('div', controlClass);
        this.addControls(controls, container); // 代理每个绘制组件的事件

        this.addControlEvent(); // 监听组件 选中, 编辑

        return container;
      }
    }, {
      key: "onRemove",
      value: function onRemove() {
        for (var draw in this.draw) {
          if (this.draw[draw]) {
            this.draw[draw].destroy();
          }
        }
      }
    }, {
      key: "getDraw",
      value: function getDraw(type) {
        var controls = this.controlOption.controls;

        if (controls[type]) {
          return this.draw[type];
        }

        return null;
      }
    }, {
      key: "getAllData",
      value: function getAllData() {
        var res = {};

        for (var draw in this.draw) {
          if (this.draw[draw]) {
            res[draw] = this.draw[draw].getData();
          }
        }

        return res;
      }
    }, {
      key: "removeAllData",
      value: function removeAllData() {
        for (var draw in this.draw) {
          if (this.draw[draw]) {
            this.draw[draw].removeAllData();
          }
        }
      }
    }, {
      key: "addControls",
      value: function addControls(controls, container) {
        var style = this.controlOption.style;

        for (var type in controls) {
          if (DrawType[type] && controls[type] !== false) {
            var drawOption = helpers_28(controls[type]) ? controls[type] : {};

            if (style) {
              drawOption.style = style;
            }

            var draw = new DrawType[type](this.scene, drawOption);
            draw.on(DrawEvent.MODE_CHANGE, this.onModeChange.bind(null, type));
            this.draw[type] = draw;
            this.createButton(draw.title, 'draw-' + type, container, 'click', this.onButtonClick.bind(null, type));
          } else if (type === 'delete' && controls[type] !== false) {
            var _draw = new DrawDelete(this.scene);

            _draw.on(DrawEvent.MODE_CHANGE, this.onModeChange.bind(null, type));

            this.createButton(_draw.title, 'draw-' + type, container, 'mousedown', this.onDeleteMode.bind(null, type));
          }
        }
      }
    }, {
      key: "addControlEvent",
      value: function addControlEvent() {
        var _this2 = this;

        var _loop = function _loop(draw) {
          if (_this2.draw[draw]) {
            ['draw.create', 'draw.update', 'draw.delete'].forEach(function (type) {
              _this2.draw[draw].on(type, function (feature) {
                _this2.emit(type, {
                  drawType: draw,
                  feature: feature
                });
              });
            });
          }
        };

        for (var draw in this.draw) {
          _loop(draw);
        }
      }
    }, {
      key: "createButton",
      value: function createButton(tile, className, container, eventType, fn) {
        var link = l7.DOM.create('button', className, container);
        link.title = tile;
        link.addEventListener(eventType, fn, false);
        return link;
      }
    }]);

    return DrawControl;
  }(l7.Control);

  exports.DrawCircle = DrawCircle;
  exports.DrawControl = DrawControl;
  exports.DrawDelete = DrawDelete;
  exports.DrawFeature = DrawFeature;
  exports.DrawLine = DrawLine;
  exports.DrawMode = DrawMode;
  exports.DrawPoint = DrawPoint;
  exports.DrawPolygon = DrawPolygon;
  exports.DrawRect = DrawRect;

  Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=l7-draw.js.map