geojs 1.8.5 → 1.8.8

package/geo.js

@@ -41,13 +41,11 @@ module.exports = geo_action;
 
 /***/ }),
 
-/***/ 7800:
+/***/ 5784:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 var $ = __webpack_require__(5638);
 
-var inherit = __webpack_require__(5699);
-
 var geo_event = __webpack_require__(5108);
 
 var geo_action = __webpack_require__(7839);
@@ -56,16 +54,6 @@ var transform = __webpack_require__(6853);
 
 var util = __webpack_require__(4634);
 
-var registerAnnotation = (__webpack_require__(4647).registerAnnotation);
-
-var lineFeature = __webpack_require__(4708);
-
-var markerFeature = __webpack_require__(7098);
-
-var pointFeature = __webpack_require__(2557);
-
-var polygonFeature = __webpack_require__(4343);
-
 var textFeature = __webpack_require__(9757);
 
 var annotationId = 0;
@@ -1542,186 +1530,282 @@ function continuousVerticesProcessAction(m_this, evt, name) {
   }
 }
 /**
- * Rectangle annotation specification.  Extends {@link geo.annotation.spec}.
+ * Return a function that can be used as a selectionConstraint that requires
+ * that the aspect ratio of a rectangle-like selection is a specific value or
+ * range of values.
  *
- * @typedef {object} geo.rectangleAnnotation.spec
- * @extends geo.annotation.spec
- * @property {geo.geoPosition[]} [corners] A list of four corners in map gcs
- *    coordinates.  These must be in order around the perimeter of the
- *    rectangle (in either direction).
- * @property {geo.geoPosition[]} [coordinates] An alternate name for `corners`.
- * @property {geo.polygonFeature.styleSpec} [style] The style to apply to a
- *    finished rectangle.  This uses styles for {@link geo.polygonFeature}.
- * @property {geo.polygonFeature.styleSpec} [editStyle] The style to apply to a
- *    rectangle in edit mode.
- * @property {number|number[]|function} [constraint] If specified, an aspect
- *    ratio or list of aspect ratios to constraint the rectangle to.  If a
- *    function, a selection constraint function to call to adjust the
- *    rectangle.
+ * @param {number|number[]|geo.geoSize|geo.geoSize[]} ratio Either a single
+ *   aspect ratio, a single size, or a list of allowed aspect ratios and sizes.
+ *   For instance, 1 will require that the selection square, 2 would require
+ *   that it is twice as wide as tall, [2, 1/2] would allow it to be twice as
+ *   wide or half as wide as it is tall.  Sizes (e.g., {width: 400, height:
+ *   500}) snap to that size.
+ * @returns {function} A function that can be passed to the mapIterator
+ *   selectionConstraint or to an annotation constraint function.
  */
 
+
+function constrainAspectRatio(ratio) {
+  var ratios = Array.isArray(ratio) ? ratio : [ratio];
+  /**
+   * Constrain a mouse action or annotation action to a list of aspect ratios.
+   *
+   * @param {geo.geoPosition} pos Mouse or new location in map gcs.
+   * @param {geo.geoPosition} origin Origin in map gcs when the activity
+   *    started.
+   * @param {geo.geoPosition} [corners] If specified, an array of corner
+   *    locations in mapgcs.  This may be modified.
+   * @param {string?} [mode] 'edge', 'vertex' or falsy.  A falsy value implies
+   *    this is just the most recent point in the annotation, otherwise it is
+   *    the portion of the annotation being modified.
+   * @param {number} [ang] A list of angles of each side of the polygon
+   *    represented by corners or the original annotation.
+   * @param {integer} [index] The specific vertex or edge that is being
+   *    modified.
+   * @returns {object} An object with the ``origin`` (this is what is passed
+   *    in), a new position as ``pos``, and the updated corners as ``corners``.
+   */
+
+  function constraintFunction(pos, origin, corners, mode, ang, index) {
+    var newpos = pos;
+    var best;
+
+    if (!corners) {
+      corners = [{
+        x: origin.x,
+        y: origin.y
+      }, {
+        x: pos.x,
+        y: origin.y
+      }, {
+        x: pos.x,
+        y: pos.y
+      }, {
+        x: origin.x,
+        y: pos.y
+      }];
+    }
+
+    if (mode) {
+      /* Edit a vertex or edge */
+      var i1 = (index + 1) % 4;
+      var i2 = (index + 2) % 4;
+      var i3 = (index + 3) % 4;
+      var dist1 = Math.pow(Math.pow(corners[index].x - corners[i1].x, 2) + Math.pow(corners[index].y - corners[i1].y, 2), 0.5);
+      var dist3 = Math.pow(Math.pow(corners[index].x - corners[i3].x, 2) + Math.pow(corners[index].y - corners[i3].y, 2), 0.5);
+      var area = Math.abs(dist1 * dist3);
+      var shape, edge;
+      ratios.forEach(function (ratio) {
+        var width, height;
+
+        if (ratio.width) {
+          width = ratio.width;
+          height = ratio.height;
+        } else {
+          width = Math.pow(area * ratio, 0.5);
+          height = width / ratio;
+        }
+
+        if (width !== height && !(index % 2)) {
+          var _ref = [height, width];
+          width = _ref[0];
+          height = _ref[1];
+        }
+
+        var score = Math.pow(width - dist3, 2) + Math.pow(height - dist1, 2);
+
+        if (best === undefined || score < best) {
+          best = score;
+          shape = {
+            w: width,
+            h: height
+          };
+        }
+      });
+      var ang1 = ang[i1];
+      var delta1 = {
+        x: -shape.w * Math.cos(ang1),
+        y: -shape.w * Math.sin(ang1)
+      };
+      var ang2 = ang[index];
+      var delta2 = {
+        x: -shape.h * Math.cos(ang2),
+        y: -shape.h * Math.sin(ang2)
+      };
+
+      switch (mode) {
+        case 'vertex':
+          corners[index].x = corners[i2].x + delta1.x + delta2.x;
+          corners[index].y = corners[i2].y + delta1.y + delta2.y;
+          corners[i1].x = corners[i2].x + delta1.x;
+          corners[i1].y = corners[i2].y + delta1.y;
+          corners[i3].x = corners[i2].x + delta2.x;
+          corners[i3].y = corners[i2].y + delta2.y;
+          break;
+
+        case 'edge':
+          edge = {
+            x: (corners[i2].x + corners[i3].x) * 0.5,
+            y: (corners[i2].y + corners[i3].y) * 0.5
+          };
+          corners[i2].x = edge.x + delta2.x / 2;
+          corners[i2].y = edge.y + delta2.y / 2;
+          corners[index].x = edge.x + delta1.x - delta2.x / 2;
+          corners[index].y = edge.y + delta1.y - delta2.y / 2;
+          corners[i1].x = edge.x + delta1.x + delta2.x / 2;
+          corners[i1].y = edge.y + delta1.y + delta2.y / 2;
+          corners[i3].x = edge.x - delta2.x / 2;
+          corners[i3].y = edge.y - delta2.y / 2;
+          break;
+      }
+    } else {
+      /* Not in edit vertex or edge mode */
+      var _area = Math.abs((pos.x - origin.x) * (pos.y - origin.y));
+
+      ratios.forEach(function (ratio) {
+        var width, height;
+
+        if (ratio.width) {
+          width = ratio.width;
+          height = ratio.height;
+        } else {
+          width = Math.pow(_area * ratio, 0.5);
+          height = width / ratio;
+        }
+
+        var adjusted = {
+          x: origin.x + Math.sign(pos.x - origin.x) * width,
+          y: origin.y + Math.sign(pos.y - origin.y) * height
+        };
+        var score = Math.pow(adjusted.x - pos.x, 2) + Math.pow(adjusted.y - pos.y, 2);
+
+        if (best === undefined || score < best) {
+          best = score;
+          newpos = adjusted;
+        }
+      });
+      corners[0].y = corners[1].y = origin.y;
+      corners[0].x = corners[3].x = origin.x;
+      corners[1].x = corners[2].x = newpos.x;
+      corners[2].y = corners[3].y = newpos.y;
+    }
+
+    return {
+      corners: corners,
+      origin: origin,
+      pos: newpos
+    };
+  }
+
+  return constraintFunction;
+}
+
+module.exports = {
+  state: annotationState,
+  actionOwner: annotationActionOwner,
+  annotation: annotation,
+  _editHandleFeatureLevel: editHandleFeatureLevel,
+  defaultEditHandleStyle: defaultEditHandleStyle,
+  constrainAspectRatio: constrainAspectRatio,
+  // these aren't exposed in index.js
+  annotationActionOwner: annotationActionOwner,
+  continuousVerticesActions: continuousVerticesActions,
+  continuousVerticesProcessAction: continuousVerticesProcessAction
+};
+
+/***/ }),
+
+/***/ 7196:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var $ = __webpack_require__(5638);
+
+var inherit = __webpack_require__(5699);
+
+var registerAnnotation = (__webpack_require__(4647).registerAnnotation);
+
+var markerFeature = __webpack_require__(7098);
+
+var ellipseAnnotation = __webpack_require__(7505);
 /**
- * Rectangle annotation class.
+ * Circle annotation class.
  *
- * Rectangles are always rendered as polygons.  This could be changed -- if no
- * stroke is specified, the quad feature would be sufficient and work on more
- * renderers.
+ * Circles are a subset of rectangles with a fixed aspect ratio.
  *
  * @class
- * @alias geo.rectangleAnnotation
+ * @alias geo.circleAnnotation
  * @extends geo.annotation
  *
- * @param {geo.rectangleAnnotation.spec?} [args] Options for the annotation.
- * @param {string} [annotationName='rectangle'] Override the annotation name.
+ * @param {geo.circleAnnotation.spec?} [args] Options for the annotation.
+ * @param {string} [annotationName='circle'] Override the annotation name.
  */
 
 
-var rectangleAnnotation = function rectangleAnnotation(args, annotationName) {
+var circleAnnotation = function circleAnnotation(args, annotationName) {
   'use strict';
 
-  if (!(this instanceof rectangleAnnotation)) {
-    return new rectangleAnnotation(args, annotationName);
+  args = $.extend({}, args, {
+    constraint: 1
+  });
+
+  if (!(this instanceof circleAnnotation)) {
+    return new circleAnnotation(args, annotationName);
   }
 
-  args = $.extend(true, {}, {
-    style: {
-      fill: true,
-      fillColor: {
-        r: 0,
-        g: 1,
-        b: 0
-      },
-      fillOpacity: 0.25,
-      polygon: function polygon(d) {
-        return d.polygon;
-      },
-      stroke: true,
-      strokeColor: {
-        r: 0,
-        g: 0,
-        b: 0
-      },
-      strokeOpacity: 1,
-      strokeWidth: 3,
-      uniformPolygon: true
-    },
-    highlightStyle: {
-      fillColor: {
-        r: 0,
-        g: 1,
-        b: 1
-      },
-      fillOpacity: 0.5,
-      strokeWidth: 5
-    },
-    createStyle: {
-      fillColor: {
-        r: 0.3,
-        g: 0.3,
-        b: 0.3
-      },
-      fillOpacity: 0.25,
-      strokeColor: {
-        r: 0,
-        g: 0,
-        b: 1
-      }
-    }
-  }, args || {});
-  args.corners = args.corners || args.coordinates || [];
-  delete args.coordinates;
-  annotation.call(this, annotationName || 'rectangle', args);
-  var m_this = this,
-      s_actions = this.actions,
-      s_processEditAction = this.processEditAction;
-  /**
-   * Return actions needed for the specified state of this annotation.
-   *
-   * @param {string} [state] The state to return actions for.  Defaults to
-   *    the current state.
-   * @returns {geo.actionRecord[]} A list of actions.
-   */
+  ellipseAnnotation.call(this, args, annotationName || 'circle');
+};
 
-  this.actions = function (state) {
-    if (!state) {
-      state = m_this.state();
-    }
+inherit(circleAnnotation, ellipseAnnotation);
+var circleRequiredFeatures = {};
+circleRequiredFeatures[markerFeature.capabilities.feature] = true;
+registerAnnotation('circle', circleAnnotation, circleRequiredFeatures);
+module.exports = circleAnnotation;
 
-    switch (state) {
-      case annotationState.create:
-        return [{
-          action: geo_action.annotation_rectangle,
-          name: 'rectangle create',
-          owner: annotationActionOwner,
-          input: 'left',
-          modifiers: {
-            shift: false,
-            ctrl: false
-          },
-          selectionRectangle: true,
-          selectionConstraint: this._selectionConstraint
-        }];
+/***/ }),
 
-      default:
-        return s_actions.apply(m_this, arguments);
-    }
-  };
-  /**
-   * Process any actions for this annotation.
-   *
-   * @param {geo.event} evt The action event.
-   * @returns {boolean|string} `true` to update the annotation, `'done'` if the
-   *    annotation was completed (changed from create to done state),
-   *    `'remove'` if the annotation should be removed, falsy to not update
-   *    anything.
-   */
+/***/ 7505:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
+var $ = __webpack_require__(5638);
 
-  this.processAction = function (evt) {
-    var layer = m_this.layer();
+var inherit = __webpack_require__(5699);
 
-    if (m_this.state() !== annotationState.create || !layer || evt.event !== geo_event.actionselection || evt.state.action !== geo_action.annotation_rectangle) {
-      return;
-    }
+var registerAnnotation = (__webpack_require__(4647).registerAnnotation);
 
-    var map = layer.map(),
-        corners = [
-    /* Keep in map gcs, not interface gcs to avoid wrapping issues */
-    map.displayToGcs({
-      x: evt.lowerLeft.x,
-      y: evt.lowerLeft.y
-    }, null), map.displayToGcs({
-      x: evt.lowerLeft.x,
-      y: evt.upperRight.y
-    }, null), map.displayToGcs({
-      x: evt.upperRight.x,
-      y: evt.upperRight.y
-    }, null), map.displayToGcs({
-      x: evt.upperRight.x,
-      y: evt.lowerLeft.y
-    }, null)];
+var markerFeature = __webpack_require__(7098);
 
-    if (this._selectionConstraint && evt.mouse && evt.state.origin) {
-      this._selectionConstraint(evt.mouse.mapgcs, evt.state.origin.mapgcs, corners);
-    }
-    /* Don't keep rectangles that have nearly zero area in display pixels */
+var annotationState = (__webpack_require__(5784).state);
 
+var rectangleAnnotation = __webpack_require__(3442);
+/**
+ * Ellipse annotation class.
+ *
+ * Ellipses are always rendered as markers.
+ *
+ * @class
+ * @alias geo.ellipseAnnotation
+ * @extends geo.annotation
+ *
+ * @param {geo.ellipseAnnotation.spec?} [args] Options for the annotation.
+ * @param {string} [annotationName='ellipse'] Override the annotation name.
+ */
 
-    if (layer.displayDistance(corners[0], null, corners[1], null) * layer.displayDistance(corners[0], null, corners[3], null) < 0.01) {
-      return 'remove';
-    }
 
-    m_this.options('corners', corners);
-    m_this.state(annotationState.done);
-    return 'done';
-  };
+var ellipseAnnotation = function ellipseAnnotation(args, annotationName) {
+  'use strict';
+
+  if (!(this instanceof ellipseAnnotation)) {
+    return new ellipseAnnotation(args, annotationName);
+  }
+
+  rectangleAnnotation.call(this, args, annotationName || 'ellipse');
+  var m_this = this;
   /**
    * Get a list of renderable features for this annotation.
    *
    * @returns {array} An array of features.
    */
 
-
   this.features = function () {
     var opt = m_this.options(),
         state = m_this.state(),
@@ -1729,10 +1813,27 @@ var rectangleAnnotation = function rectangleAnnotation(args, annotationName) {
     features = [];
 
     if (opt.corners && opt.corners.length >= 4) {
+      var style = m_this.styleForState(state);
+      var w = Math.pow(Math.pow(opt.corners[0].x - opt.corners[1].x, 2) + Math.pow(opt.corners[0].y - opt.corners[1].y, 2), 0.5);
+      var h = Math.pow(Math.pow(opt.corners[0].x - opt.corners[3].x, 2) + Math.pow(opt.corners[0].y - opt.corners[3].y, 2), 0.5);
+      var radius = Math.max(w, h) / 2 / m_this.layer().map().unitsPerPixel(0);
+      var aspect = w ? h / w : 1e20;
+      var rotation = -Math.atan2(opt.corners[1].y - opt.corners[0].y, opt.corners[1].x - opt.corners[0].x);
       features = [{
-        polygon: {
-          polygon: opt.corners,
-          style: m_this.styleForState(state)
+        marker: {
+          x: (opt.corners[0].x + opt.corners[1].x + opt.corners[2].x + opt.corners[3].x) / 4,
+          y: (opt.corners[0].y + opt.corners[1].y + opt.corners[2].y + opt.corners[3].y) / 4,
+          style: $.extend({}, style, {
+            radius: radius,
+            symbolValue: aspect,
+            rotation: rotation,
+            strokeOffset: 0,
+            radiusIncludesStroke: false,
+            scaleWithZoom: markerFeature.scaleMode.fill,
+            rotateWithMap: true,
+            strokeOpacity: style.stroke === false ? 0 : style.strokeOpacity,
+            fillOpacity: style.fill === false ? 0 : style.fillOpacity
+          })
         }
       }];
     }
@@ -1743,467 +1844,107 @@ var rectangleAnnotation = function rectangleAnnotation(args, annotationName) {
 
     return features;
   };
-  /**
-   * Get and optionally set coordinates associated with this annotation in the
-   * map gcs coordinate system.
-   *
-   * @param {geo.geoPosition[]} [coordinates] An optional array of coordinates
-   *  to set.
-   * @returns {geo.geoPosition[]} The current array of coordinates.
-   */
-
+};
 
-  this._coordinates = function (coordinates) {
-    if (coordinates && coordinates.length >= 4) {
-      m_this.options('corners', coordinates.slice(0, 4));
-      /* Should we ensure that the four points form a rectangle in the current
-       * projection, though this might not be rectangular in another gcs? */
-    }
+inherit(ellipseAnnotation, rectangleAnnotation);
+var ellipseRequiredFeatures = {};
+ellipseRequiredFeatures[markerFeature.capabilities.feature] = true;
+registerAnnotation('ellipse', ellipseAnnotation, ellipseRequiredFeatures);
+module.exports = ellipseAnnotation;
 
-    return m_this.options('corners');
-  };
+/***/ }),
 
-  this._coordinateOption = 'corners';
-  /**
-   * Return the coordinates to be stored in a geojson geometry object.
-   *
-   * @param {string|geo.transform|null} [gcs] `undefined` to use the interface
-   *    gcs, `null` to use the map gcs, or any other transform.
-   * @returns {array} An array of flattened coordinates in the interface gcs
-   *    coordinate system.  `undefined` if this annotation is incomplete.
-   */
+/***/ 4213:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
-  this._geojsonCoordinates = function (gcs) {
-    var src = m_this.coordinates(gcs);
+var annotation = __webpack_require__(5784);
+/**
+ * @namespace geo.annotation
+ */
 
-    if (!src || m_this.state() === annotationState.create || src.length < 4) {
-      return;
-    }
 
-    var coord = [];
+module.exports = {
+  state: annotation.state,
+  actionOwner: annotation.actionOwner,
+  annotation: annotation.annotation,
+  _editHandleFeatureLevel: annotation._editHandleFeatureLevel,
+  defaultEditHandleStyle: annotation.defaultEditHandleStyle,
+  constrainAspectRatio: annotation.constrainAspectRatio,
+  baseAnnotation: annotation,
+  circleAnnotation: __webpack_require__(7196),
+  ellipseAnnotation: __webpack_require__(7505),
+  lineAnnotation: __webpack_require__(3984),
+  pointAnnotation: __webpack_require__(8296),
+  polygonAnnotation: __webpack_require__(56),
+  rectangleAnnotation: __webpack_require__(3442),
+  squareAnnotation: __webpack_require__(4932)
+};
 
-    for (var i = 0; i < 4; i += 1) {
-      coord.push([src[i].x, src[i].y]);
-    }
+/***/ }),
 
-    coord.push([src[0].x, src[0].y]);
-    return [coord];
-  };
-  /**
-   * Return the geometry type that is used to store this annotation in geojson.
-   *
-   * @returns {string} A geojson geometry type.
-   */
+/***/ 3984:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
+var $ = __webpack_require__(5638);
 
-  this._geojsonGeometryType = function () {
-    return 'Polygon';
-  };
-  /**
-   * Return a list of styles that should be preserved in a geojson
-   * representation of the annotation.
-   *
-   * @returns {string[]} A list of style names to store.
-   */
+var inherit = __webpack_require__(5699);
 
+var registerAnnotation = (__webpack_require__(4647).registerAnnotation);
 
-  this._geojsonStyles = function () {
-    return ['fill', 'fillColor', 'fillOpacity', 'lineCap', 'lineJoin', 'stroke', 'strokeColor', 'strokeOffset', 'strokeOpacity', 'strokeWidth'];
-  };
-  /**
-   * Set three corners based on an initial corner and a mouse event.
-   *
-   * @param {geo.geoPosition} corners An array of four corners to update.
-   * @param {geo.event} evt The mouse move event.
-   */
+var lineFeature = __webpack_require__(4708);
 
+var annotation = (__webpack_require__(5784).annotation);
 
-  this._setCornersFromMouse = function (corners, evt) {
-    var map = m_this.layer().map(),
-        c0 = map.gcsToDisplay({
-      x: corners[0].x,
-      y: corners[0].y
-    }, null),
-        c2 = map.gcsToDisplay(evt.mapgcs, null),
-        c1 = {
-      x: c2.x,
-      y: c0.y
-    },
-        c3 = {
-      x: c0.x,
-      y: c2.y
-    };
-    corners[2] = $.extend({}, evt.mapgcs);
-    corners[1] = map.displayToGcs(c1, null);
-    corners[3] = map.displayToGcs(c3, null);
+var annotationState = (__webpack_require__(5784).state);
 
-    if (this._selectionConstraint) {
-      this._selectionConstraint(evt.mapgcs, corners[0], corners);
-    }
-  };
-  /**
-   * Handle a mouse move on this annotation.
-   *
-   * @param {geo.event} evt The mouse move event.
-   * @returns {boolean} Truthy to update the annotation, falsy to not
-   *    update anything.
-   */
+var continuousVerticesActions = (__webpack_require__(5784).continuousVerticesActions);
 
+var continuousVerticesProcessAction = (__webpack_require__(5784).continuousVerticesProcessAction);
+/**
+ * Line annotation specification.  Extends {@link geo.annotation.spec}.
+ *
+ * @typedef {object} geo.lineAnnotation.spec
+ * @extends geo.annotation.spec
+ * @property {geo.geoPosition[]} [vertices] A list of vertices in map gcs
+ *    coordinates.
+ * @property {geo.geoPosition[]} [coordinates] An alternate name for
+ *    `vertices`.
+ * @property {geo.lineFeature.styleSpec} [style] The style to apply to a
+ *    finished line.  This uses styles for {@link geo.lineFeature}.
+ * @property {geo.lineFeature.styleSpec} [editStyle] The style to apply to a
+ *    line in edit mode.
+ */
 
-  this.mouseMove = function (evt) {
-    if (m_this.state() !== annotationState.create) {
-      return;
-    }
-
-    var corners = m_this.options('corners');
-
-    if (corners.length) {
-      m_this._setCornersFromMouse(corners, evt);
-
-      return true;
-    }
-  };
-  /**
-   * Handle a mouse click on this annotation.  If the event is processed,
-   * evt.handled should be set to `true` to prevent further processing.
-   *
-   * @param {geo.event} evt The mouse click event.
-   * @returns {boolean|string} `true` to update the annotation, `'done'` if
-   *    the annotation was completed (changed from create to done state),
-   *    `'remove'` if the annotation should be removed, falsy to not update
-   *    anything.
-   */
-
-
-  this.mouseClick = function (evt) {
-    var layer = m_this.layer();
-
-    if (m_this.state() !== annotationState.create || !layer) {
-      return;
-    }
-
-    if (!evt.buttonsDown.left && !evt.buttonsDown.right) {
-      return;
-    }
-
-    var corners = m_this.options('corners');
-
-    if (evt.buttonsDown.right && !corners.length) {
-      return;
-    }
-
-    evt.handled = true;
-
-    if (corners.length) {
-      m_this._setCornersFromMouse(corners, evt);
-      /* Don't keep rectangles that have nearly zero area in display pixels */
-
-
-      if (layer.displayDistance(corners[0], null, corners[1], null) * layer.displayDistance(corners[0], null, corners[3], null) < 0.01) {
-        return 'remove';
-      }
-
-      m_this.state(annotationState.done);
-      return 'done';
-    }
-
-    if (evt.buttonsDown.left) {
-      corners.push($.extend({}, evt.mapgcs));
-      corners.push($.extend({}, evt.mapgcs));
-      corners.push($.extend({}, evt.mapgcs));
-      corners.push($.extend({}, evt.mapgcs));
-      return true;
-    }
-  };
-  /**
-   * Process any edit actions for this annotation.
-   *
-   * @param {geo.event} evt The action event.
-   * @returns {boolean|string} `true` to update the annotation, falsy to not
-   *    update anything.
-   */
-
-
-  this.processEditAction = function (evt) {
-    var start = m_this._editHandle.startCoordinates,
-        delta = {
-      x: evt.mouse.mapgcs.x - evt.state.origin.mapgcs.x,
-      y: evt.mouse.mapgcs.y - evt.state.origin.mapgcs.y
-    },
-        type = m_this._editHandle.handle.type,
-        index = m_this._editHandle.handle.index,
-        ang = [Math.atan2(start[1].y - start[0].y, start[1].x - start[0].x), Math.atan2(start[2].y - start[1].y, start[2].x - start[1].x), Math.atan2(start[3].y - start[2].y, start[3].x - start[2].x), Math.atan2(start[0].y - start[3].y, start[0].x - start[3].x)],
-        corners,
-        delta1,
-        delta2,
-        ang1,
-        ang2; // an angle can be zero because it is horizontal or undefined.  If opposite
-    // angles are both zero, this is a degenerate rectangle (a line or a point)
-
-    if (!ang[0] && !ang[1] && !ang[2] && !ang[3]) {
-      ang[1] = Math.PI / 2;
-      ang[2] = Math.PI;
-      ang[3] = -Math.PI / 2;
-    }
-
-    if (!ang[0] && !ang[2]) {
-      ang[0] = ang[1] - Math.PI / 2;
-      ang[2] = ang[1] + Math.PI / 2;
-    }
-
-    if (!ang[1] && !ang[3]) {
-      ang[1] = ang[2] - Math.PI / 2;
-      ang[3] = ang[2] + Math.PI / 2;
-    }
-
-    switch (type) {
-      case 'vertex':
-        corners = start.map(function (elem) {
-          return {
-            x: elem.x,
-            y: elem.y
-          };
-        });
-        ang1 = ang[(index + 1) % 4];
-        delta1 = {
-          x: (delta.x * Math.cos(ang1) + delta.y * Math.sin(ang1)) * Math.cos(ang1),
-          y: (delta.y * Math.sin(ang1) + delta.x * Math.cos(ang1)) * Math.sin(ang1)
-        };
-        ang2 = ang[index];
-        delta2 = {
-          x: (delta.x * Math.cos(ang2) + delta.y * Math.sin(ang2)) * Math.cos(ang2),
-          y: (delta.y * Math.sin(ang2) + delta.x * Math.cos(ang2)) * Math.sin(ang2)
-        };
-        corners[index].x += delta.x;
-        corners[index].y += delta.y;
-        corners[(index + 1) % 4].x += delta1.x;
-        corners[(index + 1) % 4].y += delta1.y;
-        corners[(index + 3) % 4].x += delta2.x;
-        corners[(index + 3) % 4].y += delta2.y;
-
-        if (this._selectionConstraint) {
-          corners = this._selectionConstraint(evt.mouse.mapgcs, evt.state.origin.mapgcs, corners, 'vertex', ang, index).corners;
-        }
-
-        m_this.options('corners', corners);
-        return true;
-
-      case 'edge':
-        corners = start.map(function (elem) {
-          return {
-            x: elem.x,
-            y: elem.y
-          };
-        });
-        ang1 = ang[(index + 1) % 4];
-        delta = {
-          x: (delta.x * Math.cos(ang1) + delta.y * Math.sin(ang1)) * Math.cos(ang1),
-          y: (delta.y * Math.sin(ang1) + delta.x * Math.cos(ang1)) * Math.sin(ang1)
-        };
-        corners[index].x += delta.x;
-        corners[index].y += delta.y;
-        corners[(index + 1) % 4].x += delta.x;
-        corners[(index + 1) % 4].y += delta.y;
-
-        if (this._selectionConstraint) {
-          corners = this._selectionConstraint(evt.mouse.mapgcs, evt.state.origin.mapgcs, corners, 'edge', ang, index).corners;
-        }
-
-        m_this.options('corners', corners);
-        return true;
-    }
-
-    return s_processEditAction.apply(m_this, arguments);
-  };
-};
-
-inherit(rectangleAnnotation, annotation);
-var rectangleRequiredFeatures = {};
-rectangleRequiredFeatures[polygonFeature.capabilities.feature] = true;
-registerAnnotation('rectangle', rectangleAnnotation, rectangleRequiredFeatures);
 /**
- * Square annotation class.
- *
- * Squares are a subset of rectangles with a fixed aspect ratio.
- *
- * @class
- * @alias geo.squareAnnotation
- * @extends geo.annotation
- *
- * @param {geo.squareAnnotation.spec?} [args] Options for the annotation.
- * @param {string} [annotationName='square'] Override the annotation name.
- */
-
-var squareAnnotation = function squareAnnotation(args, annotationName) {
-  'use strict';
-
-  args = $.extend({}, args, {
-    constraint: 1
-  });
-
-  if (!(this instanceof squareAnnotation)) {
-    return new squareAnnotation(args, annotationName);
-  }
-
-  rectangleAnnotation.call(this, args, annotationName || 'square');
-};
-
-inherit(squareAnnotation, rectangleAnnotation);
-var squareRequiredFeatures = {};
-squareRequiredFeatures[polygonFeature.capabilities.feature] = true;
-registerAnnotation('square', squareAnnotation, squareRequiredFeatures);
-/**
- * Ellipse annotation class.
- *
- * Ellipses are always rendered as markers.
- *
- * @class
- * @alias geo.ellipseAnnotation
- * @extends geo.annotation
- *
- * @param {geo.ellipseAnnotation.spec?} [args] Options for the annotation.
- * @param {string} [annotationName='ellipse'] Override the annotation name.
- */
-
-var ellipseAnnotation = function ellipseAnnotation(args, annotationName) {
-  'use strict';
-
-  if (!(this instanceof ellipseAnnotation)) {
-    return new ellipseAnnotation(args, annotationName);
-  }
-
-  rectangleAnnotation.call(this, args, annotationName || 'ellipse');
-  var m_this = this;
-  /**
-   * Get a list of renderable features for this annotation.
-   *
-   * @returns {array} An array of features.
-   */
-
-  this.features = function () {
-    var opt = m_this.options(),
-        state = m_this.state(),
-        features;
-    features = [];
-
-    if (opt.corners && opt.corners.length >= 4) {
-      var style = m_this.styleForState(state);
-      var w = Math.pow(Math.pow(opt.corners[0].x - opt.corners[1].x, 2) + Math.pow(opt.corners[0].y - opt.corners[1].y, 2), 0.5);
-      var h = Math.pow(Math.pow(opt.corners[0].x - opt.corners[3].x, 2) + Math.pow(opt.corners[0].y - opt.corners[3].y, 2), 0.5);
-      var radius = Math.max(w, h) / 2 / m_this.layer().map().unitsPerPixel(0);
-      var aspect = w ? h / w : 1e20;
-      var rotation = -Math.atan2(opt.corners[1].y - opt.corners[0].y, opt.corners[1].x - opt.corners[0].x);
-      features = [{
-        marker: {
-          x: (opt.corners[0].x + opt.corners[1].x + opt.corners[2].x + opt.corners[3].x) / 4,
-          y: (opt.corners[0].y + opt.corners[1].y + opt.corners[2].y + opt.corners[3].y) / 4,
-          style: $.extend({}, style, {
-            radius: radius,
-            symbolValue: aspect,
-            rotation: rotation,
-            strokeOffset: 0,
-            radiusIncludesStroke: false,
-            scaleWithZoom: markerFeature.scaleMode.fill,
-            rotateWithMap: true,
-            strokeOpacity: style.stroke === false ? 0 : style.strokeOpacity,
-            fillOpacity: style.fill === false ? 0 : style.fillOpacity
-          })
-        }
-      }];
-    }
-
-    if (state === annotationState.edit) {
-      m_this._addEditHandles(features, opt.corners);
-    }
-
-    return features;
-  };
-};
-
-inherit(ellipseAnnotation, rectangleAnnotation);
-var ellipseRequiredFeatures = {};
-ellipseRequiredFeatures[markerFeature.capabilities.feature] = true;
-registerAnnotation('ellipse', ellipseAnnotation, ellipseRequiredFeatures);
-/**
- * Circle annotation class.
- *
- * Circles are a subset of rectangles with a fixed aspect ratio.
+ * Line annotation class.
  *
  * @class
- * @alias geo.circleAnnotation
+ * @alias geo.lineAnnotation
  * @extends geo.annotation
  *
- * @param {geo.circleAnnotation.spec?} [args] Options for the annotation.
- * @param {string} [annotationName='circle'] Override the annotation name.
- */
-
-var circleAnnotation = function circleAnnotation(args, annotationName) {
-  'use strict';
-
-  args = $.extend({}, args, {
-    constraint: 1
-  });
-
-  if (!(this instanceof circleAnnotation)) {
-    return new circleAnnotation(args, annotationName);
-  }
-
-  ellipseAnnotation.call(this, args, annotationName || 'circle');
-};
-
-inherit(circleAnnotation, ellipseAnnotation);
-var circleRequiredFeatures = {};
-circleRequiredFeatures[markerFeature.capabilities.feature] = true;
-registerAnnotation('circle', circleAnnotation, circleRequiredFeatures);
-/**
- * Polygon annotation specification.  Extends {@link geo.annotation.spec}.
- *
- * @typedef {object} geo.polygonAnnotation.spec
- * @extends geo.annotation.spec
- * @property {geo.geoPosition[]} [vertices] A list of vertices in map gcs
- *    coordinates.  These must be in order around the perimeter of the polygon
- *    (in either direction).
- * @property {geo.geoPosition[]} [coordinates] An alternate name for
- *    `vertices`.
- * @property {geo.polygonFeature.styleSpec} [style] The style to apply to a
- *    finished polygon.  This uses styles for {@link geo.polygonFeature}.
- * @property {geo.polygonFeature.styleSpec} [editStyle] The style to apply to ai
- *    polygon in edit mode.
+ * @param {geo.lineAnnotation.spec?} [args] Options for the annotation.
  */
 
-/**
- * Polygon annotation class
- *
- * When complete, polygons are rendered as polygons.  During creation they are
- * rendered as lines and polygons.
- *
- * @class
- * @alias geo.polygonAnnotation
- * @extends geo.annotation
- *
- * @param {geo.polygonAnnotation.spec?} [args] Options for the annotation.
- */
 
-var polygonAnnotation = function polygonAnnotation(args) {
+var lineAnnotation = function lineAnnotation(args) {
   'use strict';
 
-  if (!(this instanceof polygonAnnotation)) {
-    return new polygonAnnotation(args);
+  if (!(this instanceof lineAnnotation)) {
+    return new lineAnnotation(args);
   }
 
   args = $.extend(true, {}, {
     style: {
-      fill: true,
-      fillColor: {
-        r: 0,
-        g: 1,
-        b: 0
+      line: function line(d) {
+        /* Return an array that has the same number of items as we have
+         * vertices. */
+        return Array.apply(null, Array(m_this.options('vertices').length)).map(function () {
+          return d;
+        });
       },
-      fillOpacity: 0.25,
-      polygon: function polygon(d) {
-        return d.polygon;
+      position: function position(d, i) {
+        return m_this.options('vertices')[i];
       },
-      stroke: true,
       strokeColor: {
         r: 0,
         g: 0,
@@ -2211,59 +1952,44 @@ var polygonAnnotation = function polygonAnnotation(args) {
       },
       strokeOpacity: 1,
       strokeWidth: 3,
-      uniformPolygon: true
+      closed: false,
+      lineCap: 'butt',
+      lineJoin: 'miter'
     },
     highlightStyle: {
-      fillColor: {
-        r: 0,
-        g: 1,
-        b: 1
-      },
-      fillOpacity: 0.5,
       strokeWidth: 5
     },
     createStyle: {
-      closed: false,
-      fillColor: {
-        r: 0.3,
-        g: 0.3,
-        b: 0.3
-      },
-      fillOpacity: 0.25,
       line: function line(d) {
-        var coord = m_this._coordinates();
         /* Return an array that has the same number of items as we have
          * vertices. */
-
-
-        return Array.apply(null, Array((coord.outer || coord).length)).map(function () {
+        return Array.apply(null, Array(m_this.options('vertices').length)).map(function () {
           return d;
         });
       },
       position: function position(d, i) {
-        if (d.x !== undefined) {
-          return d.x;
-        }
-
         return m_this.options('vertices')[i];
       },
-      stroke: false,
       strokeColor: {
         r: 0,
         g: 0,
         b: 1
-      }
+      },
+      strokeOpacity: 1,
+      strokeWidth: 3,
+      closed: false,
+      lineCap: 'butt',
+      lineJoin: 'miter'
     }
   }, args || {});
   args.vertices = args.vertices || args.coordinates || [];
   delete args.coordinates;
-  annotation.call(this, 'polygon', args);
+  annotation.call(this, 'line', args);
   var m_this = this,
-      s_actions = this.actions;
+      s_actions = this.actions,
+      s_processEditAction = this.processEditAction;
   /**
-   * Get a list of renderable features for this annotation.  When the polygon
-   * is done, this is just a single polygon.  During creation this can be a
-   * polygon and line at z-levels 1 and 2.
+   * Get a list of renderable features for this annotation.
    *
    * @returns {array} An array of features.
    */
@@ -2271,43 +1997,28 @@ var polygonAnnotation = function polygonAnnotation(args) {
   this.features = function () {
     var opt = m_this.options(),
         state = m_this.state(),
-        style = m_this.styleForState(state),
         features;
 
     switch (state) {
       case annotationState.create:
-        features = [];
-
-        if (opt.vertices && (opt.vertices.outer || opt.vertices.length >= 3)) {
-          features[1] = {
-            polygon: {
-              polygon: opt.vertices,
-              style: style
-            }
-          };
-        }
-
-        if (opt.vertices && opt.vertices.length >= 2) {
-          features[2] = {
-            line: {
-              line: opt.vertices,
-              style: style
-            }
-          };
-        }
-
+        features = [{
+          line: {
+            line: opt.vertices,
+            style: m_this.styleForState(state)
+          }
+        }];
         break;
 
       default:
         features = [{
-          polygon: {
-            polygon: opt.vertices,
-            style: style
+          line: {
+            line: opt.vertices,
+            style: m_this.styleForState(state)
           }
         }];
 
         if (state === annotationState.edit) {
-          m_this._addEditHandles(features, opt.vertices);
+          m_this._addEditHandles(features, opt.vertices, undefined, !m_this.style('closed'));
         }
 
         break;
@@ -2396,7 +2107,7 @@ var polygonAnnotation = function polygonAnnotation(args) {
             end = true;
           }
         } else if (vertices.length >= 2 && layer.displayDistance(vertices[0], null, evt.map, 'display') <= layer.options('finalPointProximity')) {
-          end = true;
+          end = 'close';
         } else {
           vertices[vertices.length - 1] = evt.mapgcs;
         }
@@ -2413,11 +2124,12 @@ var polygonAnnotation = function polygonAnnotation(args) {
     }
 
     if (end) {
-      if (vertices.length < 4) {
+      if (vertices.length < 3) {
         return 'remove';
       }
 
       vertices.pop();
+      m_this.options('style').closed = end === 'close';
       m_this.state(annotationState.done);
       return 'done';
     }
@@ -2425,30 +2137,375 @@ var polygonAnnotation = function polygonAnnotation(args) {
     return !skip;
   };
   /**
-   * Return actions needed for the specified state of this annotation.
+   * Return actions needed for the specified state of this annotation.
+   *
+   * @param {string} [state] The state to return actions for.  Defaults to
+   *    the current state.
+   * @returns {geo.actionRecord[]} A list of actions.
+   */
+
+
+  this.actions = function (state) {
+    return continuousVerticesActions(m_this, s_actions, state, 'line', arguments);
+  };
+  /**
+   * Process any actions for this annotation.
+   *
+   * @param {geo.event} evt The action event.
+   * @returns {boolean|string} `true` to update the annotation, `'done'` if the
+   *    annotation was completed (changed from create to done state),
+   *    `'remove'` if the annotation should be removed, falsy to not update
+   *    anything.
+   */
+
+
+  this.processAction = function (evt) {
+    return continuousVerticesProcessAction(m_this, evt, 'line');
+  };
+  /**
+   * Return the coordinates to be stored in a geojson geometry object.
+   *
+   * @param {string|geo.transform|null} [gcs] `undefined` to use the interface
+   *    gcs, `null` to use the map gcs, or any other transform.
+   * @returns {array} An array of flattened coordinates in the interface gcs
+   *    coordinate system.  `undefined` if this annotation is incomplete.
+   */
+
+
+  this._geojsonCoordinates = function (gcs) {
+    var src = m_this.coordinates(gcs);
+
+    if (!src || src.length < 2 || m_this.state() === annotationState.create) {
+      return;
+    }
+
+    var coord = [];
+
+    for (var i = 0; i < src.length; i += 1) {
+      coord.push([src[i].x, src[i].y]);
+    }
+
+    return coord;
+  };
+  /**
+   * Return the geometry type that is used to store this annotation in geojson.
+   *
+   * @returns {string} A geojson geometry type.
+   */
+
+
+  this._geojsonGeometryType = function () {
+    return 'LineString';
+  };
+  /**
+   * Return a list of styles that should be preserved in a geojson
+   * representation of the annotation.
+   *
+   * @returns {string[]} A list of style names to store.
+   */
+
+
+  this._geojsonStyles = function () {
+    return ['closed', 'lineCap', 'lineJoin', 'strokeColor', 'strokeOffset', 'strokeOpacity', 'strokeWidth'];
+  };
+  /**
+   * Process any edit actions for this annotation.
+   *
+   * @param {geo.event} evt The action event.
+   * @returns {boolean|string} `true` to update the annotation, falsy to not
+   *    update anything.
+   */
+
+
+  this.processEditAction = function (evt) {
+    switch (m_this._editHandle.handle.type) {
+      case 'vertex':
+        return m_this._processEditActionVertex(evt, true);
+    }
+
+    return s_processEditAction.apply(m_this, arguments);
+  };
+  /**
+   * Handle a mouse click on this annotation when in edit mode.  If the event
+   * is processed, evt.handled should be set to `true` to prevent further
+   * processing.
+   *
+   * @param {geo.event} evt The mouse click event.
+   * @returns {boolean|string} `true` to update the annotation, `'done'` if
+   *    the annotation was completed (changed from create to done state),
+   *    `'remove'` if the annotation should be removed, falsy to not update
+   *    anything.
+   */
+
+
+  this.mouseClickEdit = function (evt) {
+    // if we get a left double click on an edge on a closed line, break the
+    // line at that edge
+    var layer = m_this.layer(),
+        handle = m_this._editHandle,
+        split; // ensure we are in edit mode and this is a left click
+
+    if (m_this.state() !== annotationState.edit || !layer || !evt.buttonsDown.left) {
+      return;
+    } // ensure this is an edge on a closed line
+
+
+    if (!handle || !handle.handle.selected || handle.handle.type !== 'edge' || !m_this.options('style').closed) {
+      return;
+    }
+
+    evt.handled = true;
+
+    if (m_this._lastClick && evt.time - m_this._lastClick < layer.options('dblClickTime')) {
+      split = true;
+    }
+
+    m_this._lastClick = evt.time;
+
+    if (split) {
+      var index = handle.handle.index,
+          curPts = m_this._coordinates(),
+          pts = curPts.slice(index + 1).concat(curPts.slice(0, index + 1));
+
+      m_this._coordinates(pts);
+
+      m_this.options('style').closed = false;
+      handle.handle.index = undefined;
+      return true;
+    }
+  };
+};
+
+inherit(lineAnnotation, annotation);
+var lineRequiredFeatures = {};
+lineRequiredFeatures[lineFeature.capabilities.basic] = [annotationState.create];
+registerAnnotation('line', lineAnnotation, lineRequiredFeatures);
+module.exports = lineAnnotation;
+
+/***/ }),
+
+/***/ 8296:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var $ = __webpack_require__(5638);
+
+var inherit = __webpack_require__(5699);
+
+var util = __webpack_require__(4634);
+
+var registerAnnotation = (__webpack_require__(4647).registerAnnotation);
+
+var pointFeature = __webpack_require__(2557);
+
+var annotation = (__webpack_require__(5784).annotation);
+
+var annotationState = (__webpack_require__(5784).state);
+/**
+ * Point annotation specification.  Extends {@link geo.annotation.spec}.
+ *
+ * @typedef {object} geo.pointAnnotation.spec
+ * @extends geo.annotation.spec
+ * @property {geo.geoPosition} [position] A coordinate in map gcs coordinates.
+ * @property {geo.geoPosition[]} [coordinates] An array with one coordinate to
+ *    use in place of `position`.
+ * @property {geo.pointFeature.styleSpec} [style] The style to apply to a
+ *    finished point.  This uses styles for {@link geo.pointFeature}.
+ * @property {boolean|number} [style.scaled=false] If `false`, the point is not
+ *    scaled with zoom level.  If `true`, the radius is based on the zoom level
+ *    at first instantiation.  If a number, the radius is used at the `scaled`
+ *    zoom level.
+ * @property {geo.pointFeature.styleSpec} [editStyle] The style to apply to a
+ *    point in edit mode.
+ */
+
+/**
+ * Point annotation class.
+ *
+ * @class
+ * @alias geo.pointAnnotation
+ * @extends geo.annotation
+ *
+ * @param {geo.pointAnnotation.spec?} [args] Options for the annotation.
+ */
+
+
+var pointAnnotation = function pointAnnotation(args) {
+  'use strict';
+
+  if (!(this instanceof pointAnnotation)) {
+    return new pointAnnotation(args);
+  }
+
+  args = $.extend(true, {}, {
+    style: {
+      fill: true,
+      fillColor: {
+        r: 0,
+        g: 1,
+        b: 0
+      },
+      fillOpacity: 0.25,
+      radius: 10,
+      scaled: false,
+      stroke: true,
+      strokeColor: {
+        r: 0,
+        g: 0,
+        b: 0
+      },
+      strokeOpacity: 1,
+      strokeWidth: 3
+    },
+    createStyle: {
+      fillColor: {
+        r: 0.3,
+        g: 0.3,
+        b: 0.3
+      },
+      fillOpacity: 0.25,
+      strokeColor: {
+        r: 0,
+        g: 0,
+        b: 1
+      }
+    },
+    highlightStyle: {
+      fillColor: {
+        r: 0,
+        g: 1,
+        b: 1
+      },
+      fillOpacity: 0.5,
+      strokeWidth: 5
+    }
+  }, args || {});
+  args.position = args.position || (args.coordinates ? args.coordinates[0] : undefined);
+  delete args.coordinates;
+  annotation.call(this, 'point', args);
+  var m_this = this;
+  /**
+   * Get a list of renderable features for this annotation.
+   *
+   * @returns {array} An array of features.
+   */
+
+  this.features = function () {
+    var opt = m_this.options(),
+        state = m_this.state(),
+        features,
+        style,
+        scaleOnZoom;
+
+    switch (state) {
+      case annotationState.create:
+        features = [];
+        break;
+
+      default:
+        style = m_this.styleForState(state);
+
+        if (opt.style.scaled || opt.style.scaled === 0) {
+          if (opt.style.scaled === true) {
+            opt.style.scaled = m_this.layer().map().zoom();
+          }
+
+          style = $.extend({}, style, {
+            radius: function radius() {
+              var radius = opt.style.radius,
+                  zoom = m_this.layer().map().zoom();
+
+              if (util.isFunction(radius)) {
+                radius = radius.apply(m_this, arguments);
+              }
+
+              radius *= Math.pow(2, zoom - opt.style.scaled);
+              return radius;
+            }
+          });
+          scaleOnZoom = true;
+        }
+
+        features = [{
+          point: {
+            x: opt.position.x,
+            y: opt.position.y,
+            style: style,
+            scaleOnZoom: scaleOnZoom
+          }
+        }];
+
+        if (state === annotationState.edit) {
+          m_this._addEditHandles(features, [opt.position], {
+            edge: false,
+            center: false,
+            resize: false,
+            rotate: false
+          });
+        }
+
+        break;
+    }
+
+    return features;
+  };
+  /**
+   * Get and optionally set coordinates associated with this annotation in the
+   * map gcs coordinate system.
+   *
+   * @param {geo.geoPosition[]} [coordinates] An optional array of coordinates
+   *  to set.
+   * @returns {geo.geoPosition[]} The current array of coordinates.
+   */
+
+
+  this._coordinates = function (coordinates) {
+    if (coordinates && coordinates.length >= 1) {
+      m_this.options('position', coordinates[0]);
+    }
+
+    if (m_this.state() === annotationState.create) {
+      return [];
+    }
+
+    return [m_this.options('position')];
+  };
+
+  this._coordinateOption = 'position';
+  /**
+   * Handle a mouse click on this annotation.  If the event is processed,
+   * evt.handled should be set to `true` to prevent further processing.
    *
-   * @param {string} [state] The state to return actions for.  Defaults to
-   *    the current state.
-   * @returns {geo.actionRecord[]} A list of actions.
+   * @param {geo.event} evt The mouse click event.
+   * @returns {boolean|string} `true` to update the annotation, `'done'` if
+   *    the annotation was completed (changed from create to done state),
+   *    `'remove'` if the annotation should be removed, falsy to not update
+   *    anything.
    */
 
+  this.mouseClick = function (evt) {
+    if (m_this.state() !== annotationState.create) {
+      return;
+    }
+
+    if (!evt.buttonsDown.left) {
+      return;
+    }
 
-  this.actions = function (state) {
-    return continuousVerticesActions(m_this, s_actions, state, 'polygon', arguments);
+    evt.handled = true;
+    m_this.options('position', evt.mapgcs);
+    m_this.state(annotationState.done);
+    return 'done';
   };
   /**
-   * Process any actions for this annotation.
+   * Return a list of styles that should be preserved in a geojson
+   * representation of the annotation.
    *
-   * @param {geo.event} evt The action event.
-   * @returns {boolean|string} `true` to update the annotation, `'done'` if the
-   *    annotation was completed (changed from create to done state),
-   *    `'remove'` if the annotation should be removed, falsy to not update
-   *    anything.
+   * @returns {string[]} A list of style names to store.
    */
 
 
-  this.processAction = function (evt) {
-    return continuousVerticesProcessAction(m_this, evt, 'polygon');
+  this._geojsonStyles = function () {
+    return ['fill', 'fillColor', 'fillOpacity', 'radius', 'scaled', 'stroke', 'strokeColor', 'strokeOpacity', 'strokeWidth'];
   };
   /**
    * Return the coordinates to be stored in a geojson geometry object.
@@ -2463,32 +2520,11 @@ var polygonAnnotation = function polygonAnnotation(args) {
   this._geojsonCoordinates = function (gcs) {
     var src = m_this.coordinates(gcs);
 
-    if (!src || !src.outer && src.length < 3 || m_this.state() === annotationState.create) {
+    if (!src || m_this.state() === annotationState.create || src.length < 1 || src[0] === undefined) {
       return;
     }
 
-    var coord = [];
-
-    if (!src.outer) {
-      coord = [src.map(function (pt) {
-        return [pt.x, pt.y];
-      })];
-      coord[0].push(coord[0][0].slice());
-    } else {
-      coord = [src.outer.map(function (pt) {
-        return [pt.x, pt.y];
-      })];
-      coord[0].push(coord[0][0].slice());
-      (src.inner || []).forEach(function (h) {
-        var poly = h.map(function (pt) {
-          return [pt.x, pt.y];
-        });
-        poly.push(poly[0].slice());
-        coord.push(poly);
-      });
-    }
-
-    return coord;
+    return [src[0].x, src[0].y];
   };
   /**
    * Return the geometry type that is used to store this annotation in geojson.
@@ -2498,70 +2534,88 @@ var polygonAnnotation = function polygonAnnotation(args) {
 
 
   this._geojsonGeometryType = function () {
-    return 'Polygon';
+    return 'Point';
   };
-  /**
-   * Return a list of styles that should be preserved in a geojson
-   * representation of the annotation.
-   *
-   * @returns {string[]} A list of style names to store.
-   */
+};
 
+inherit(pointAnnotation, annotation);
+var pointRequiredFeatures = {};
+pointRequiredFeatures[pointFeature.capabilities.feature] = true;
+registerAnnotation('point', pointAnnotation, pointRequiredFeatures);
+module.exports = pointAnnotation;
 
-  this._geojsonStyles = function () {
-    return ['fill', 'fillColor', 'fillOpacity', 'lineCap', 'lineJoin', 'stroke', 'strokeColor', 'strokeOffset', 'strokeOpacity', 'strokeWidth'];
-  };
-};
+/***/ }),
 
-inherit(polygonAnnotation, annotation);
-var polygonRequiredFeatures = {};
-polygonRequiredFeatures[polygonFeature.capabilities.feature] = true;
-polygonRequiredFeatures[lineFeature.capabilities.basic] = [annotationState.create];
-registerAnnotation('polygon', polygonAnnotation, polygonRequiredFeatures);
+/***/ 56:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var $ = __webpack_require__(5638);
+
+var inherit = __webpack_require__(5699);
+
+var registerAnnotation = (__webpack_require__(4647).registerAnnotation);
+
+var lineFeature = __webpack_require__(4708);
+
+var polygonFeature = __webpack_require__(4343);
+
+var annotation = (__webpack_require__(5784).annotation);
+
+var annotationState = (__webpack_require__(5784).state);
+
+var continuousVerticesActions = (__webpack_require__(5784).continuousVerticesActions);
+
+var continuousVerticesProcessAction = (__webpack_require__(5784).continuousVerticesProcessAction);
 /**
- * Line annotation specification.  Extends {@link geo.annotation.spec}.
+ * Polygon annotation specification.  Extends {@link geo.annotation.spec}.
  *
- * @typedef {object} geo.lineAnnotation.spec
+ * @typedef {object} geo.polygonAnnotation.spec
  * @extends geo.annotation.spec
  * @property {geo.geoPosition[]} [vertices] A list of vertices in map gcs
- *    coordinates.
+ *    coordinates.  These must be in order around the perimeter of the polygon
+ *    (in either direction).
  * @property {geo.geoPosition[]} [coordinates] An alternate name for
  *    `vertices`.
- * @property {geo.lineFeature.styleSpec} [style] The style to apply to a
- *    finished line.  This uses styles for {@link geo.lineFeature}.
- * @property {geo.lineFeature.styleSpec} [editStyle] The style to apply to a
- *    line in edit mode.
+ * @property {geo.polygonFeature.styleSpec} [style] The style to apply to a
+ *    finished polygon.  This uses styles for {@link geo.polygonFeature}.
+ * @property {geo.polygonFeature.styleSpec} [editStyle] The style to apply to ai
+ *    polygon in edit mode.
  */
 
 /**
- * Line annotation class.
+ * Polygon annotation class
+ *
+ * When complete, polygons are rendered as polygons.  During creation they are
+ * rendered as lines and polygons.
  *
  * @class
- * @alias geo.lineAnnotation
+ * @alias geo.polygonAnnotation
  * @extends geo.annotation
  *
- * @param {geo.lineAnnotation.spec?} [args] Options for the annotation.
+ * @param {geo.polygonAnnotation.spec?} [args] Options for the annotation.
  */
 
-var lineAnnotation = function lineAnnotation(args) {
+
+var polygonAnnotation = function polygonAnnotation(args) {
   'use strict';
 
-  if (!(this instanceof lineAnnotation)) {
-    return new lineAnnotation(args);
+  if (!(this instanceof polygonAnnotation)) {
+    return new polygonAnnotation(args);
   }
 
   args = $.extend(true, {}, {
     style: {
-      line: function line(d) {
-        /* Return an array that has the same number of items as we have
-         * vertices. */
-        return Array.apply(null, Array(m_this.options('vertices').length)).map(function () {
-          return d;
-        });
+      fill: true,
+      fillColor: {
+        r: 0,
+        g: 1,
+        b: 0
       },
-      position: function position(d, i) {
-        return m_this.options('vertices')[i];
+      fillOpacity: 0.25,
+      polygon: function polygon(d) {
+        return d.polygon;
       },
+      stroke: true,
       strokeColor: {
         r: 0,
         g: 0,
@@ -2569,44 +2623,59 @@ var lineAnnotation = function lineAnnotation(args) {
       },
       strokeOpacity: 1,
       strokeWidth: 3,
-      closed: false,
-      lineCap: 'butt',
-      lineJoin: 'miter'
+      uniformPolygon: true
     },
     highlightStyle: {
+      fillColor: {
+        r: 0,
+        g: 1,
+        b: 1
+      },
+      fillOpacity: 0.5,
       strokeWidth: 5
     },
     createStyle: {
+      closed: false,
+      fillColor: {
+        r: 0.3,
+        g: 0.3,
+        b: 0.3
+      },
+      fillOpacity: 0.25,
       line: function line(d) {
+        var coord = m_this._coordinates();
         /* Return an array that has the same number of items as we have
          * vertices. */
-        return Array.apply(null, Array(m_this.options('vertices').length)).map(function () {
+
+
+        return Array.apply(null, Array((coord.outer || coord).length)).map(function () {
           return d;
         });
       },
       position: function position(d, i) {
+        if (d.x !== undefined) {
+          return d.x;
+        }
+
         return m_this.options('vertices')[i];
       },
+      stroke: false,
       strokeColor: {
         r: 0,
         g: 0,
         b: 1
-      },
-      strokeOpacity: 1,
-      strokeWidth: 3,
-      closed: false,
-      lineCap: 'butt',
-      lineJoin: 'miter'
+      }
     }
   }, args || {});
   args.vertices = args.vertices || args.coordinates || [];
   delete args.coordinates;
-  annotation.call(this, 'line', args);
+  annotation.call(this, 'polygon', args);
   var m_this = this,
-      s_actions = this.actions,
-      s_processEditAction = this.processEditAction;
+      s_actions = this.actions;
   /**
-   * Get a list of renderable features for this annotation.
+   * Get a list of renderable features for this annotation.  When the polygon
+   * is done, this is just a single polygon.  During creation this can be a
+   * polygon and line at z-levels 1 and 2.
    *
    * @returns {array} An array of features.
    */
@@ -2614,28 +2683,43 @@ var lineAnnotation = function lineAnnotation(args) {
   this.features = function () {
     var opt = m_this.options(),
         state = m_this.state(),
+        style = m_this.styleForState(state),
         features;
 
     switch (state) {
       case annotationState.create:
-        features = [{
-          line: {
-            line: opt.vertices,
-            style: m_this.styleForState(state)
-          }
-        }];
+        features = [];
+
+        if (opt.vertices && (opt.vertices.outer || opt.vertices.length >= 3)) {
+          features[1] = {
+            polygon: {
+              polygon: opt.vertices,
+              style: style
+            }
+          };
+        }
+
+        if (opt.vertices && opt.vertices.length >= 2) {
+          features[2] = {
+            line: {
+              line: opt.vertices,
+              style: style
+            }
+          };
+        }
+
         break;
 
       default:
         features = [{
-          line: {
-            line: opt.vertices,
-            style: m_this.styleForState(state)
+          polygon: {
+            polygon: opt.vertices,
+            style: style
           }
         }];
 
         if (state === annotationState.edit) {
-          m_this._addEditHandles(features, opt.vertices, undefined, !m_this.style('closed'));
+          m_this._addEditHandles(features, opt.vertices);
         }
 
         break;
@@ -2724,7 +2808,7 @@ var lineAnnotation = function lineAnnotation(args) {
             end = true;
           }
         } else if (vertices.length >= 2 && layer.displayDistance(vertices[0], null, evt.map, 'display') <= layer.options('finalPointProximity')) {
-          end = 'close';
+          end = true;
         } else {
           vertices[vertices.length - 1] = evt.mapgcs;
         }
@@ -2741,12 +2825,11 @@ var lineAnnotation = function lineAnnotation(args) {
     }
 
     if (end) {
-      if (vertices.length < 3) {
+      if (vertices.length < 4) {
         return 'remove';
       }
 
       vertices.pop();
-      m_this.options('style').closed = end === 'close';
       m_this.state(annotationState.done);
       return 'done';
     }
@@ -2763,7 +2846,7 @@ var lineAnnotation = function lineAnnotation(args) {
 
 
   this.actions = function (state) {
-    return continuousVerticesActions(m_this, s_actions, state, 'line', arguments);
+    return continuousVerticesActions(m_this, s_actions, state, 'polygon', arguments);
   };
   /**
    * Process any actions for this annotation.
@@ -2777,7 +2860,7 @@ var lineAnnotation = function lineAnnotation(args) {
 
 
   this.processAction = function (evt) {
-    return continuousVerticesProcessAction(m_this, evt, 'line');
+    return continuousVerticesProcessAction(m_this, evt, 'polygon');
   };
   /**
    * Return the coordinates to be stored in a geojson geometry object.
@@ -2792,14 +2875,29 @@ var lineAnnotation = function lineAnnotation(args) {
   this._geojsonCoordinates = function (gcs) {
     var src = m_this.coordinates(gcs);
 
-    if (!src || src.length < 2 || m_this.state() === annotationState.create) {
+    if (!src || !src.outer && src.length < 3 || m_this.state() === annotationState.create) {
       return;
     }
 
     var coord = [];
 
-    for (var i = 0; i < src.length; i += 1) {
-      coord.push([src[i].x, src[i].y]);
+    if (!src.outer) {
+      coord = [src.map(function (pt) {
+        return [pt.x, pt.y];
+      })];
+      coord[0].push(coord[0][0].slice());
+    } else {
+      coord = [src.outer.map(function (pt) {
+        return [pt.x, pt.y];
+      })];
+      coord[0].push(coord[0][0].slice());
+      (src.inner || []).forEach(function (h) {
+        var poly = h.map(function (pt) {
+          return [pt.x, pt.y];
+        });
+        poly.push(poly[0].slice());
+        coord.push(poly);
+      });
     }
 
     return coord;
@@ -2812,7 +2910,7 @@ var lineAnnotation = function lineAnnotation(args) {
 
 
   this._geojsonGeometryType = function () {
-    return 'LineString';
+    return 'Polygon';
   };
   /**
    * Return a list of styles that should be preserved in a geojson
@@ -2823,113 +2921,79 @@ var lineAnnotation = function lineAnnotation(args) {
 
 
   this._geojsonStyles = function () {
-    return ['closed', 'lineCap', 'lineJoin', 'strokeColor', 'strokeOffset', 'strokeOpacity', 'strokeWidth'];
-  };
-  /**
-   * Process any edit actions for this annotation.
-   *
-   * @param {geo.event} evt The action event.
-   * @returns {boolean|string} `true` to update the annotation, falsy to not
-   *    update anything.
-   */
-
-
-  this.processEditAction = function (evt) {
-    switch (m_this._editHandle.handle.type) {
-      case 'vertex':
-        return m_this._processEditActionVertex(evt, true);
-    }
-
-    return s_processEditAction.apply(m_this, arguments);
+    return ['fill', 'fillColor', 'fillOpacity', 'lineCap', 'lineJoin', 'stroke', 'strokeColor', 'strokeOffset', 'strokeOpacity', 'strokeWidth'];
   };
-  /**
-   * Handle a mouse click on this annotation when in edit mode.  If the event
-   * is processed, evt.handled should be set to `true` to prevent further
-   * processing.
-   *
-   * @param {geo.event} evt The mouse click event.
-   * @returns {boolean|string} `true` to update the annotation, `'done'` if
-   *    the annotation was completed (changed from create to done state),
-   *    `'remove'` if the annotation should be removed, falsy to not update
-   *    anything.
-   */
+};
 
+inherit(polygonAnnotation, annotation);
+var polygonRequiredFeatures = {};
+polygonRequiredFeatures[polygonFeature.capabilities.feature] = true;
+polygonRequiredFeatures[lineFeature.capabilities.basic] = [annotationState.create];
+registerAnnotation('polygon', polygonAnnotation, polygonRequiredFeatures);
+module.exports = polygonAnnotation;
 
-  this.mouseClickEdit = function (evt) {
-    // if we get a left double click on an edge on a closed line, break the
-    // line at that edge
-    var layer = m_this.layer(),
-        handle = m_this._editHandle,
-        split; // ensure we are in edit mode and this is a left click
+/***/ }),
 
-    if (m_this.state() !== annotationState.edit || !layer || !evt.buttonsDown.left) {
-      return;
-    } // ensure this is an edge on a closed line
+/***/ 3442:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
+var $ = __webpack_require__(5638);
 
-    if (!handle || !handle.handle.selected || handle.handle.type !== 'edge' || !m_this.options('style').closed) {
-      return;
-    }
+var inherit = __webpack_require__(5699);
 
-    evt.handled = true;
+var geo_event = __webpack_require__(5108);
 
-    if (m_this._lastClick && evt.time - m_this._lastClick < layer.options('dblClickTime')) {
-      split = true;
-    }
+var geo_action = __webpack_require__(7839);
 
-    m_this._lastClick = evt.time;
+var registerAnnotation = (__webpack_require__(4647).registerAnnotation);
 
-    if (split) {
-      var index = handle.handle.index,
-          curPts = m_this._coordinates(),
-          pts = curPts.slice(index + 1).concat(curPts.slice(0, index + 1));
+var polygonFeature = __webpack_require__(4343);
 
-      m_this._coordinates(pts);
+var annotation = (__webpack_require__(5784).annotation);
 
-      m_this.options('style').closed = false;
-      handle.handle.index = undefined;
-      return true;
-    }
-  };
-};
+var annotationState = (__webpack_require__(5784).state);
 
-inherit(lineAnnotation, annotation);
-var lineRequiredFeatures = {};
-lineRequiredFeatures[lineFeature.capabilities.basic] = [annotationState.create];
-registerAnnotation('line', lineAnnotation, lineRequiredFeatures);
+var annotationActionOwner = (__webpack_require__(5784).annotationActionOwner);
 /**
- * Point annotation specification.  Extends {@link geo.annotation.spec}.
+ * Rectangle annotation specification.  Extends {@link geo.annotation.spec}.
  *
- * @typedef {object} geo.pointAnnotation.spec
+ * @typedef {object} geo.rectangleAnnotation.spec
  * @extends geo.annotation.spec
- * @property {geo.geoPosition} [position] A coordinate in map gcs coordinates.
- * @property {geo.geoPosition[]} [coordinates] An array with one coordinate to
- *    use in place of `position`.
- * @property {geo.pointFeature.styleSpec} [style] The style to apply to a
- *    finished point.  This uses styles for {@link geo.pointFeature}.
- * @property {boolean|number} [style.scaled=false] If `false`, the point is not
- *    scaled with zoom level.  If `true`, the radius is based on the zoom level
- *    at first instantiation.  If a number, the radius is used at the `scaled`
- *    zoom level.
- * @property {geo.pointFeature.styleSpec} [editStyle] The style to apply to a
- *    point in edit mode.
+ * @property {geo.geoPosition[]} [corners] A list of four corners in map gcs
+ *    coordinates.  These must be in order around the perimeter of the
+ *    rectangle (in either direction).
+ * @property {geo.geoPosition[]} [coordinates] An alternate name for `corners`.
+ * @property {geo.polygonFeature.styleSpec} [style] The style to apply to a
+ *    finished rectangle.  This uses styles for {@link geo.polygonFeature}.
+ * @property {geo.polygonFeature.styleSpec} [editStyle] The style to apply to a
+ *    rectangle in edit mode.
+ * @property {number|number[]|function} [constraint] If specified, an aspect
+ *    ratio or list of aspect ratios to constraint the rectangle to.  If a
+ *    function, a selection constraint function to call to adjust the
+ *    rectangle.
  */
 
 /**
- * Point annotation class.
+ * Rectangle annotation class.
+ *
+ * Rectangles are always rendered as polygons.  This could be changed -- if no
+ * stroke is specified, the quad feature would be sufficient and work on more
+ * renderers.
  *
  * @class
- * @alias geo.pointAnnotation
+ * @alias geo.rectangleAnnotation
  * @extends geo.annotation
  *
- * @param {geo.pointAnnotation.spec?} [args] Options for the annotation.
+ * @param {geo.rectangleAnnotation.spec?} [args] Options for the annotation.
+ * @param {string} [annotationName='rectangle'] Override the annotation name.
  */
 
-var pointAnnotation = function pointAnnotation(args) {
+
+var rectangleAnnotation = function rectangleAnnotation(args, annotationName) {
   'use strict';
 
-  if (!(this instanceof pointAnnotation)) {
-    return new pointAnnotation(args);
+  if (!(this instanceof rectangleAnnotation)) {
+    return new rectangleAnnotation(args, annotationName);
   }
 
   args = $.extend(true, {}, {
@@ -2941,8 +3005,9 @@ var pointAnnotation = function pointAnnotation(args) {
         b: 0
       },
       fillOpacity: 0.25,
-      radius: 10,
-      scaled: false,
+      polygon: function polygon(d) {
+        return d.polygon;
+      },
       stroke: true,
       strokeColor: {
         r: 0,
@@ -2950,7 +3015,17 @@ var pointAnnotation = function pointAnnotation(args) {
         b: 0
       },
       strokeOpacity: 1,
-      strokeWidth: 3
+      strokeWidth: 3,
+      uniformPolygon: true
+    },
+    highlightStyle: {
+      fillColor: {
+        r: 0,
+        g: 1,
+        b: 1
+      },
+      fillOpacity: 0.5,
+      strokeWidth: 5
     },
     createStyle: {
       fillColor: {
@@ -2964,82 +3039,119 @@ var pointAnnotation = function pointAnnotation(args) {
         g: 0,
         b: 1
       }
-    },
-    highlightStyle: {
-      fillColor: {
-        r: 0,
-        g: 1,
-        b: 1
-      },
-      fillOpacity: 0.5,
-      strokeWidth: 5
     }
   }, args || {});
-  args.position = args.position || (args.coordinates ? args.coordinates[0] : undefined);
+  args.corners = args.corners || args.coordinates || [];
   delete args.coordinates;
-  annotation.call(this, 'point', args);
-  var m_this = this;
+  annotation.call(this, annotationName || 'rectangle', args);
+  var m_this = this,
+      s_actions = this.actions,
+      s_processEditAction = this.processEditAction;
   /**
-   * Get a list of renderable features for this annotation.
+   * Return actions needed for the specified state of this annotation.
    *
-   * @returns {array} An array of features.
+   * @param {string} [state] The state to return actions for.  Defaults to
+   *    the current state.
+   * @returns {geo.actionRecord[]} A list of actions.
    */
 
-  this.features = function () {
-    var opt = m_this.options(),
-        state = m_this.state(),
-        features,
-        style,
-        scaleOnZoom;
+  this.actions = function (state) {
+    if (!state) {
+      state = m_this.state();
+    }
 
     switch (state) {
       case annotationState.create:
-        features = [];
-        break;
+        return [{
+          action: geo_action.annotation_rectangle,
+          name: 'rectangle create',
+          owner: annotationActionOwner,
+          input: 'left',
+          modifiers: {
+            shift: false,
+            ctrl: false
+          },
+          selectionRectangle: true,
+          selectionConstraint: this._selectionConstraint
+        }];
 
       default:
-        style = m_this.styleForState(state);
+        return s_actions.apply(m_this, arguments);
+    }
+  };
+  /**
+   * Process any actions for this annotation.
+   *
+   * @param {geo.event} evt The action event.
+   * @returns {boolean|string} `true` to update the annotation, `'done'` if the
+   *    annotation was completed (changed from create to done state),
+   *    `'remove'` if the annotation should be removed, falsy to not update
+   *    anything.
+   */
 
-        if (opt.style.scaled || opt.style.scaled === 0) {
-          if (opt.style.scaled === true) {
-            opt.style.scaled = m_this.layer().map().zoom();
-          }
 
-          style = $.extend({}, style, {
-            radius: function radius() {
-              var radius = opt.style.radius,
-                  zoom = m_this.layer().map().zoom();
+  this.processAction = function (evt) {
+    var layer = m_this.layer();
 
-              if (util.isFunction(radius)) {
-                radius = radius.apply(m_this, arguments);
-              }
+    if (m_this.state() !== annotationState.create || !layer || evt.event !== geo_event.actionselection || evt.state.action !== geo_action.annotation_rectangle) {
+      return;
+    }
+
+    var map = layer.map(),
+        corners = [
+    /* Keep in map gcs, not interface gcs to avoid wrapping issues */
+    map.displayToGcs({
+      x: evt.lowerLeft.x,
+      y: evt.lowerLeft.y
+    }, null), map.displayToGcs({
+      x: evt.lowerLeft.x,
+      y: evt.upperRight.y
+    }, null), map.displayToGcs({
+      x: evt.upperRight.x,
+      y: evt.upperRight.y
+    }, null), map.displayToGcs({
+      x: evt.upperRight.x,
+      y: evt.lowerLeft.y
+    }, null)];
+
+    if (this._selectionConstraint && evt.mouse && evt.state.origin) {
+      this._selectionConstraint(evt.mouse.mapgcs, evt.state.origin.mapgcs, corners);
+    }
+    /* Don't keep rectangles that have nearly zero area in display pixels */
+
+
+    if (layer.displayDistance(corners[0], null, corners[1], null) * layer.displayDistance(corners[0], null, corners[3], null) < 0.01) {
+      return 'remove';
+    }
+
+    m_this.options('corners', corners);
+    m_this.state(annotationState.done);
+    return 'done';
+  };
+  /**
+   * Get a list of renderable features for this annotation.
+   *
+   * @returns {array} An array of features.
+   */
 
-              radius *= Math.pow(2, zoom - opt.style.scaled);
-              return radius;
-            }
-          });
-          scaleOnZoom = true;
-        }
 
-        features = [{
-          point: {
-            x: opt.position.x,
-            y: opt.position.y,
-            style: style,
-            scaleOnZoom: scaleOnZoom
-          }
-        }];
+  this.features = function () {
+    var opt = m_this.options(),
+        state = m_this.state(),
+        features;
+    features = [];
 
-        if (state === annotationState.edit) {
-          m_this._addEditHandles(features, [opt.position], {
-            edge: false,
-            center: false,
-            resize: false,
-            rotate: false
-          });
+    if (opt.corners && opt.corners.length >= 4) {
+      features = [{
+        polygon: {
+          polygon: opt.corners,
+          style: m_this.styleForState(state)
         }
+      }];
+    }
 
-        break;
+    if (state === annotationState.edit) {
+      m_this._addEditHandles(features, opt.corners);
     }
 
     return features;
@@ -3055,42 +3167,50 @@ var pointAnnotation = function pointAnnotation(args) {
 
 
   this._coordinates = function (coordinates) {
-    if (coordinates && coordinates.length >= 1) {
-      m_this.options('position', coordinates[0]);
-    }
-
-    if (m_this.state() === annotationState.create) {
-      return [];
+    if (coordinates && coordinates.length >= 4) {
+      m_this.options('corners', coordinates.slice(0, 4));
+      /* Should we ensure that the four points form a rectangle in the current
+       * projection, though this might not be rectangular in another gcs? */
     }
 
-    return [m_this.options('position')];
+    return m_this.options('corners');
   };
 
-  this._coordinateOption = 'position';
+  this._coordinateOption = 'corners';
   /**
-   * Handle a mouse click on this annotation.  If the event is processed,
-   * evt.handled should be set to `true` to prevent further processing.
+   * Return the coordinates to be stored in a geojson geometry object.
    *
-   * @param {geo.event} evt The mouse click event.
-   * @returns {boolean|string} `true` to update the annotation, `'done'` if
-   *    the annotation was completed (changed from create to done state),
-   *    `'remove'` if the annotation should be removed, falsy to not update
-   *    anything.
+   * @param {string|geo.transform|null} [gcs] `undefined` to use the interface
+   *    gcs, `null` to use the map gcs, or any other transform.
+   * @returns {array} An array of flattened coordinates in the interface gcs
+   *    coordinate system.  `undefined` if this annotation is incomplete.
    */
 
-  this.mouseClick = function (evt) {
-    if (m_this.state() !== annotationState.create) {
+  this._geojsonCoordinates = function (gcs) {
+    var src = m_this.coordinates(gcs);
+
+    if (!src || m_this.state() === annotationState.create || src.length < 4) {
       return;
     }
 
-    if (!evt.buttonsDown.left) {
-      return;
+    var coord = [];
+
+    for (var i = 0; i < 4; i += 1) {
+      coord.push([src[i].x, src[i].y]);
     }
 
-    evt.handled = true;
-    m_this.options('position', evt.mapgcs);
-    m_this.state(annotationState.done);
-    return 'done';
+    coord.push([src[0].x, src[0].y]);
+    return [coord];
+  };
+  /**
+   * Return the geometry type that is used to store this annotation in geojson.
+   *
+   * @returns {string} A geojson geometry type.
+   */
+
+
+  this._geojsonGeometryType = function () {
+    return 'Polygon';
   };
   /**
    * Return a list of styles that should be preserved in a geojson
@@ -3101,207 +3221,269 @@ var pointAnnotation = function pointAnnotation(args) {
 
 
   this._geojsonStyles = function () {
-    return ['fill', 'fillColor', 'fillOpacity', 'radius', 'scaled', 'stroke', 'strokeColor', 'strokeOpacity', 'strokeWidth'];
+    return ['fill', 'fillColor', 'fillOpacity', 'lineCap', 'lineJoin', 'stroke', 'strokeColor', 'strokeOffset', 'strokeOpacity', 'strokeWidth'];
   };
   /**
-   * Return the coordinates to be stored in a geojson geometry object.
+   * Set three corners based on an initial corner and a mouse event.
    *
-   * @param {string|geo.transform|null} [gcs] `undefined` to use the interface
-   *    gcs, `null` to use the map gcs, or any other transform.
-   * @returns {array} An array of flattened coordinates in the interface gcs
-   *    coordinate system.  `undefined` if this annotation is incomplete.
+   * @param {geo.geoPosition} corners An array of four corners to update.
+   * @param {geo.event} evt The mouse move event.
    */
 
 
-  this._geojsonCoordinates = function (gcs) {
-    var src = m_this.coordinates(gcs);
+  this._setCornersFromMouse = function (corners, evt) {
+    var map = m_this.layer().map(),
+        c0 = map.gcsToDisplay({
+      x: corners[0].x,
+      y: corners[0].y
+    }, null),
+        c2 = map.gcsToDisplay(evt.mapgcs, null),
+        c1 = {
+      x: c2.x,
+      y: c0.y
+    },
+        c3 = {
+      x: c0.x,
+      y: c2.y
+    };
+    corners[2] = $.extend({}, evt.mapgcs);
+    corners[1] = map.displayToGcs(c1, null);
+    corners[3] = map.displayToGcs(c3, null);
 
-    if (!src || m_this.state() === annotationState.create || src.length < 1 || src[0] === undefined) {
+    if (this._selectionConstraint) {
+      this._selectionConstraint(evt.mapgcs, corners[0], corners);
+    }
+  };
+  /**
+   * Handle a mouse move on this annotation.
+   *
+   * @param {geo.event} evt The mouse move event.
+   * @returns {boolean} Truthy to update the annotation, falsy to not
+   *    update anything.
+   */
+
+
+  this.mouseMove = function (evt) {
+    if (m_this.state() !== annotationState.create) {
       return;
     }
 
-    return [src[0].x, src[0].y];
+    var corners = m_this.options('corners');
+
+    if (corners.length) {
+      m_this._setCornersFromMouse(corners, evt);
+
+      return true;
+    }
   };
   /**
-   * Return the geometry type that is used to store this annotation in geojson.
+   * Handle a mouse click on this annotation.  If the event is processed,
+   * evt.handled should be set to `true` to prevent further processing.
    *
-   * @returns {string} A geojson geometry type.
+   * @param {geo.event} evt The mouse click event.
+   * @returns {boolean|string} `true` to update the annotation, `'done'` if
+   *    the annotation was completed (changed from create to done state),
+   *    `'remove'` if the annotation should be removed, falsy to not update
+   *    anything.
    */
 
 
-  this._geojsonGeometryType = function () {
-    return 'Point';
-  };
-};
+  this.mouseClick = function (evt) {
+    var layer = m_this.layer();
 
-inherit(pointAnnotation, annotation);
-var pointRequiredFeatures = {};
-pointRequiredFeatures[pointFeature.capabilities.feature] = true;
-registerAnnotation('point', pointAnnotation, pointRequiredFeatures);
-/**
- * Return a function that can be used as a selectionConstraint that requires
- * that the aspect ratio of a rectangle-like selection is a specific value or
- * range of values.
- *
- * @param {number|number[]} ratio Either a single aspect ratio or a list of
- *   allowed aspect ratios.  For instance, 1 will require that the selection
- *   square, 2 would require that it is twice as wide as tall, [2, 1/2] would
- *   allow it to be twice as wide or half as wide as it is tall.
- * @returns {function} A function that can be passed to the mapIterator
- *   selectionConstraint or to an annotation constraint function.
- */
+    if (m_this.state() !== annotationState.create || !layer) {
+      return;
+    }
 
-function constrainAspectRatio(ratio) {
-  var ratios = Array.isArray(ratio) ? ratio : [ratio];
+    if (!evt.buttonsDown.left && !evt.buttonsDown.right) {
+      return;
+    }
+
+    var corners = m_this.options('corners');
+
+    if (evt.buttonsDown.right && !corners.length) {
+      return;
+    }
+
+    evt.handled = true;
+
+    if (corners.length) {
+      m_this._setCornersFromMouse(corners, evt);
+      /* Don't keep rectangles that have nearly zero area in display pixels */
+
+
+      if (layer.displayDistance(corners[0], null, corners[1], null) * layer.displayDistance(corners[0], null, corners[3], null) < 0.01) {
+        return 'remove';
+      }
+
+      m_this.state(annotationState.done);
+      return 'done';
+    }
+
+    if (evt.buttonsDown.left) {
+      corners.push($.extend({}, evt.mapgcs));
+      corners.push($.extend({}, evt.mapgcs));
+      corners.push($.extend({}, evt.mapgcs));
+      corners.push($.extend({}, evt.mapgcs));
+      return true;
+    }
+  };
   /**
-   * Constrain a mouse action or annotation action to a list of aspect ratios.
+   * Process any edit actions for this annotation.
    *
-   * @param {geo.geoPosition} pos Mouse or new location in map gcs.
-   * @param {geo.geoPosition} origin Origin in map gcs when the activity
-   *    started.
-   * @param {geo.geoPosition} [corners] If specified, an array of corner
-   *    locations in mapgcs.  This may be modified.
-   * @param {string?} [mode] 'edge', 'vertex' or falsy.  A falsy value implies
-   *    this is just the most recent point in the annotation, otherwise it is
-   *    the portion of the annotation being modified.
-   * @param {number} [ang] A list of angles of each side of the polygon
-   *    represented by corners or the original annotation.
-   * @param {integer} [index] The specific vertex or edge that is being
-   *    modified.
-   * @returns {object} An object with the ``origin`` (this is what is passed
-   *    in), a new position as ``pos``, and the updated corners as ``corners``.
+   * @param {geo.event} evt The action event.
+   * @returns {boolean|string} `true` to update the annotation, falsy to not
+   *    update anything.
    */
 
-  function constraintFunction(pos, origin, corners, mode, ang, index) {
-    var newpos = pos;
-    var best;
 
-    if (!corners) {
-      corners = [{
-        x: origin.x,
-        y: origin.y
-      }, {
-        x: pos.x,
-        y: origin.y
-      }, {
-        x: pos.x,
-        y: pos.y
-      }, {
-        x: origin.x,
-        y: pos.y
-      }];
+  this.processEditAction = function (evt) {
+    var start = m_this._editHandle.startCoordinates,
+        delta = {
+      x: evt.mouse.mapgcs.x - evt.state.origin.mapgcs.x,
+      y: evt.mouse.mapgcs.y - evt.state.origin.mapgcs.y
+    },
+        type = m_this._editHandle.handle.type,
+        index = m_this._editHandle.handle.index,
+        ang = [Math.atan2(start[1].y - start[0].y, start[1].x - start[0].x), Math.atan2(start[2].y - start[1].y, start[2].x - start[1].x), Math.atan2(start[3].y - start[2].y, start[3].x - start[2].x), Math.atan2(start[0].y - start[3].y, start[0].x - start[3].x)],
+        corners,
+        delta1,
+        delta2,
+        ang1,
+        ang2; // an angle can be zero because it is horizontal or undefined.  If opposite
+    // angles are both zero, this is a degenerate rectangle (a line or a point)
+
+    if (!ang[0] && !ang[1] && !ang[2] && !ang[3]) {
+      ang[1] = Math.PI / 2;
+      ang[2] = Math.PI;
+      ang[3] = -Math.PI / 2;
     }
 
-    if (mode) {
-      /* Edit a vertex or edge */
-      var i1 = (index + 1) % 4;
-      var i2 = (index + 2) % 4;
-      var i3 = (index + 3) % 4;
-      var dist1 = Math.pow(Math.pow(corners[index].x - corners[i1].x, 2) + Math.pow(corners[index].y - corners[i1].y, 2), 0.5);
-      var dist3 = Math.pow(Math.pow(corners[index].x - corners[i3].x, 2) + Math.pow(corners[index].y - corners[i3].y, 2), 0.5);
-      var area = Math.abs(dist1 * dist3);
-      var shape, edge;
-      ratios.forEach(function (ratio) {
-        if (ratio !== 1 && !(index % 2)) {
-          ratio = 1.0 / ratio;
-        }
+    if (!ang[0] && !ang[2]) {
+      ang[0] = ang[1] - Math.PI / 2;
+      ang[2] = ang[1] + Math.PI / 2;
+    }
 
-        var width = Math.pow(area * ratio, 0.5);
-        var score = Math.pow(width - dist3, 2) + Math.pow(width / ratio - dist1, 2);
+    if (!ang[1] && !ang[3]) {
+      ang[1] = ang[2] - Math.PI / 2;
+      ang[3] = ang[2] + Math.PI / 2;
+    }
 
-        if (best === undefined || score < best) {
-          best = score;
-          shape = {
-            w: width,
-            h: width / ratio
+    switch (type) {
+      case 'vertex':
+        corners = start.map(function (elem) {
+          return {
+            x: elem.x,
+            y: elem.y
           };
+        });
+        ang1 = ang[(index + 1) % 4];
+        delta1 = {
+          x: (delta.x * Math.cos(ang1) + delta.y * Math.sin(ang1)) * Math.cos(ang1),
+          y: (delta.y * Math.sin(ang1) + delta.x * Math.cos(ang1)) * Math.sin(ang1)
+        };
+        ang2 = ang[index];
+        delta2 = {
+          x: (delta.x * Math.cos(ang2) + delta.y * Math.sin(ang2)) * Math.cos(ang2),
+          y: (delta.y * Math.sin(ang2) + delta.x * Math.cos(ang2)) * Math.sin(ang2)
+        };
+        corners[index].x += delta.x;
+        corners[index].y += delta.y;
+        corners[(index + 1) % 4].x += delta1.x;
+        corners[(index + 1) % 4].y += delta1.y;
+        corners[(index + 3) % 4].x += delta2.x;
+        corners[(index + 3) % 4].y += delta2.y;
+
+        if (this._selectionConstraint) {
+          corners = this._selectionConstraint(evt.mouse.mapgcs, evt.state.origin.mapgcs, corners, 'vertex', ang, index).corners;
         }
-      });
-      var ang1 = ang[i1];
-      var delta1 = {
-        x: -shape.w * Math.cos(ang1),
-        y: -shape.w * Math.sin(ang1)
-      };
-      var ang2 = ang[index];
-      var delta2 = {
-        x: -shape.h * Math.cos(ang2),
-        y: -shape.h * Math.sin(ang2)
-      };
 
-      switch (mode) {
-        case 'vertex':
-          corners[index].x = corners[i2].x + delta1.x + delta2.x;
-          corners[index].y = corners[i2].y + delta1.y + delta2.y;
-          corners[i1].x = corners[i2].x + delta1.x;
-          corners[i1].y = corners[i2].y + delta1.y;
-          corners[i3].x = corners[i2].x + delta2.x;
-          corners[i3].y = corners[i2].y + delta2.y;
-          break;
+        m_this.options('corners', corners);
+        return true;
 
-        case 'edge':
-          edge = {
-            x: (corners[i2].x + corners[i3].x) * 0.5,
-            y: (corners[i2].y + corners[i3].y) * 0.5
+      case 'edge':
+        corners = start.map(function (elem) {
+          return {
+            x: elem.x,
+            y: elem.y
           };
-          corners[i2].x = edge.x + delta2.x / 2;
-          corners[i2].y = edge.y + delta2.y / 2;
-          corners[index].x = edge.x + delta1.x - delta2.x / 2;
-          corners[index].y = edge.y + delta1.y - delta2.y / 2;
-          corners[i1].x = edge.x + delta1.x + delta2.x / 2;
-          corners[i1].y = edge.y + delta1.y + delta2.y / 2;
-          corners[i3].x = edge.x - delta2.x / 2;
-          corners[i3].y = edge.y - delta2.y / 2;
-          break;
-      }
-    } else {
-      /* Not in edit vertex or edge mode */
-      var _area = Math.abs((pos.x - origin.x) * (pos.y - origin.y));
-
-      ratios.forEach(function (ratio) {
-        var width = Math.pow(_area * ratio, 0.5);
-        var adjusted = {
-          x: origin.x + Math.sign(pos.x - origin.x) * width,
-          y: origin.y + Math.sign(pos.y - origin.y) * width / ratio
+        });
+        ang1 = ang[(index + 1) % 4];
+        delta = {
+          x: (delta.x * Math.cos(ang1) + delta.y * Math.sin(ang1)) * Math.cos(ang1),
+          y: (delta.y * Math.sin(ang1) + delta.x * Math.cos(ang1)) * Math.sin(ang1)
         };
-        var score = Math.pow(adjusted.x - pos.x, 2) + Math.pow(adjusted.y - pos.y, 2);
+        corners[index].x += delta.x;
+        corners[index].y += delta.y;
+        corners[(index + 1) % 4].x += delta.x;
+        corners[(index + 1) % 4].y += delta.y;
 
-        if (best === undefined || score < best) {
-          best = score;
-          newpos = adjusted;
+        if (this._selectionConstraint) {
+          corners = this._selectionConstraint(evt.mouse.mapgcs, evt.state.origin.mapgcs, corners, 'edge', ang, index).corners;
         }
-      });
-      corners[0].y = corners[1].y = origin.y;
-      corners[0].x = corners[3].x = origin.x;
-      corners[1].x = corners[2].x = newpos.x;
-      corners[2].y = corners[3].y = newpos.y;
+
+        m_this.options('corners', corners);
+        return true;
     }
 
-    return {
-      corners: corners,
-      origin: origin,
-      pos: newpos
-    };
-  }
+    return s_processEditAction.apply(m_this, arguments);
+  };
+};
 
-  return constraintFunction;
-}
+inherit(rectangleAnnotation, annotation);
+var rectangleRequiredFeatures = {};
+rectangleRequiredFeatures[polygonFeature.capabilities.feature] = true;
+registerAnnotation('rectangle', rectangleAnnotation, rectangleRequiredFeatures);
+module.exports = rectangleAnnotation;
 
-module.exports = {
-  state: annotationState,
-  actionOwner: annotationActionOwner,
-  annotation: annotation,
-  lineAnnotation: lineAnnotation,
-  pointAnnotation: pointAnnotation,
-  polygonAnnotation: polygonAnnotation,
-  rectangleAnnotation: rectangleAnnotation,
-  squareAnnotation: squareAnnotation,
-  ellipseAnnotation: ellipseAnnotation,
-  circleAnnotation: circleAnnotation,
-  _editHandleFeatureLevel: editHandleFeatureLevel,
-  defaultEditHandleStyle: defaultEditHandleStyle,
-  constrainAspectRatio: constrainAspectRatio
+/***/ }),
+
+/***/ 4932:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var $ = __webpack_require__(5638);
+
+var inherit = __webpack_require__(5699);
+
+var registerAnnotation = (__webpack_require__(4647).registerAnnotation);
+
+var polygonFeature = __webpack_require__(4343);
+
+var rectangleAnnotation = __webpack_require__(3442);
+/**
+ * Square annotation class.
+ *
+ * Squares are a subset of rectangles with a fixed aspect ratio.
+ *
+ * @class
+ * @alias geo.squareAnnotation
+ * @extends geo.annotation
+ *
+ * @param {geo.squareAnnotation.spec?} [args] Options for the annotation.
+ * @param {string} [annotationName='square'] Override the annotation name.
+ */
+
+
+var squareAnnotation = function squareAnnotation(args, annotationName) {
+  'use strict';
+
+  args = $.extend({}, args, {
+    constraint: 1
+  });
+
+  if (!(this instanceof squareAnnotation)) {
+    return new squareAnnotation(args, annotationName);
+  }
+
+  rectangleAnnotation.call(this, args, annotationName || 'square');
 };
 
+inherit(squareAnnotation, rectangleAnnotation);
+var squareRequiredFeatures = {};
+squareRequiredFeatures[polygonFeature.capabilities.feature] = true;
+registerAnnotation('square', squareAnnotation, squareRequiredFeatures);
+module.exports = squareAnnotation;
+
 /***/ }),
 
 /***/ 836:
@@ -3311,7 +3493,7 @@ var inherit = __webpack_require__(5699);
 
 var featureLayer = __webpack_require__(3715);
 
-var geo_annotation = __webpack_require__(7800);
+var geo_annotation = __webpack_require__(4213);
 
 var geo_event = __webpack_require__(5108);
 
@@ -11860,9 +12042,7 @@ var graphFeature = function graphFeature(arg) {
 
     }, arg.style === undefined ? {} : arg.style);
     m_this.style(defaultStyle);
-    m_this.nodes(function (d) {
-      return d;
-    });
+    m_this.nodes(util.identityFunction);
     return m_this;
   };
   /**
@@ -12284,6 +12464,8 @@ var inherit = __webpack_require__(5699);
 var feature = __webpack_require__(6837);
 
 var transform = __webpack_require__(6853);
+
+var util = __webpack_require__(4634);
 /**
  * Heatmap feature specification.
  *
@@ -12362,10 +12544,7 @@ var heatmapFeature = function heatmapFeature(arg) {
       m_gcsPosition,
       s_init = this._init;
   this.featureType = 'heatmap';
-
-  m_position = arg.position || function (d) {
-    return d;
-  };
+  m_position = arg.position || util.identityFunction;
 
   m_intensity = arg.intensity || function (d) {
     return 1;
@@ -12816,7 +12995,6 @@ $.htmlPrefilter = function (html) {
 __webpack_require__(8701);
 
 module.exports = $.extend({
-  annotation: __webpack_require__(7800),
   annotationLayer: __webpack_require__(836),
   camera: __webpack_require__(9986),
   choroplethFeature: __webpack_require__(8719),
@@ -12862,6 +13040,7 @@ module.exports = $.extend({
   inherit: __webpack_require__(5699),
   version: __webpack_require__(2978),
   sha: __webpack_require__(5381),
+  annotation: __webpack_require__(4213),
   util: __webpack_require__(4634),
   jQuery: $,
   canvas: __webpack_require__(7562),
@@ -15486,12 +15665,8 @@ var lineFeature = function lineFeature(arg) {
     });
     /* Set the reduced lines as the data and use simple accessors. */
 
-    m_this.style('position', function (d) {
-      return d;
-    });
-    m_this.style('line', function (d) {
-      return d;
-    });
+    m_this.style('position', util.identityFunction);
+    m_this.style('line', util.identityFunction);
     m_this.data(data);
     return m_this;
   };
@@ -15519,9 +15694,7 @@ var lineFeature = function lineFeature(arg) {
       // Values of 2 and above appear smoothest.
       antialiasing: 2.0,
       closed: false,
-      line: function line(d) {
-        return d;
-      },
+      line: util.identityFunction,
       position: function position(d) {
         return Array.isArray(d) ? {
           x: d[0],
@@ -23142,9 +23315,7 @@ var pixelmapFeature = function pixelmapFeature(arg) {
           a: 1
         };
       },
-      position: function position(d) {
-        return d;
-      }
+      position: util.identityFunction
     }, arg.style === undefined ? {} : arg.style);
 
     if (arg.position !== undefined) {
@@ -24840,12 +25011,8 @@ var polygonFeature = function polygonFeature(arg) {
     });
     /* Set the reduced polgons as the data and use simple accessors. */
 
-    m_this.style('position', function (d) {
-      return d;
-    });
-    m_this.style('polygon', function (d) {
-      return d;
-    });
+    m_this.style('position', util.identityFunction);
+    m_this.style('polygon', util.identityFunction);
     m_this.data(data);
     return m_this;
   };
@@ -24941,9 +25108,7 @@ var polygonFeature = function polygonFeature(arg) {
         b: 1.0
       },
       strokeOpacity: 1.0,
-      polygon: function polygon(d) {
-        return d;
-      },
+      polygon: util.identityFunction,
       position: function position(d) {
         return Array.isArray(d) ? {
           x: d[0],
@@ -25832,9 +25997,7 @@ var quadFeature = function quadFeature(arg) {
       video: function video(d) {
         return d.video;
       },
-      position: function position(d) {
-        return d;
-      }
+      position: util.identityFunction
     }, arg.style === undefined ? {} : arg.style);
 
     if (arg.position !== undefined) {
@@ -26871,7 +27034,7 @@ module.exports = sceneObject;
  * @constant
  * @type {string}
  */
-module.exports = "c8c9edda606de6cb2990b41bfdfe2c4a82c885cb";
+module.exports = "e4988e06092d4bee858b11f2d0109a6bfe77dfbb";
 
 /***/ }),
 
@@ -32745,12 +32908,8 @@ var trackFeature = function trackFeature(arg) {
     arg = arg || {};
     s_init.call(m_this, arg);
     var style = $.extend(true, {}, {
-      track: function track(d) {
-        return d;
-      },
-      position: function position(d) {
-        return d;
-      },
+      track: util.identityFunction,
+      position: util.identityFunction,
       time: function time(d, i) {
         return d.t !== undefined ? d.t : i;
       }
@@ -32825,7 +32984,7 @@ var maxTransformCacheSize = 10;
 /* A RegExp to detect if two transforms only different by the middle axis's
  * direction. */
 
-var axisPattern = /^(.* |)\\+axis=e(n|s)u(| .*)$/;
+var axisPattern = /^(.* |)\+axis=e(n|s)u(| .*)$/;
 var affinePattern = /(^|\s)\+(s[1-3][1-3]|[xyz]off)=\S/;
 /**
  * This purpose of this class is to provide a generic interface for computing
@@ -33739,6 +33898,22 @@ transform.vincentyDistance = function (pt1, pt2, gcs, baseGcs, ellipsoid, maxIte
     alpha2: Math.atan2(cosU1 * Math.sin(lambda), -sinU1 * cosU2 + cosU1 * sinU2 * Math.cos(lambda))
   };
 };
+/**
+ * Return a boolean indicating if the projections only differ in their y
+ * coordinate.
+ *
+ * @param {string} srcPrj The source projection.
+ * @param {string} tgtPrj The destination projection.
+ * @returns {boolean} truthy if only the y coordinate is different between
+ *    projections.
+ */
+
+
+transform.onlyInvertedY = function (srcPrj, tgtPrj) {
+  var smatch = srcPrj.match(axisPattern),
+      tmatch = tgtPrj.match(axisPattern);
+  return smatch && tmatch && smatch[1] === tmatch[1] && smatch[3] === tmatch[3];
+};
 /* Expose proj4 to make it easier to debug */
 
 
@@ -33826,6 +34001,15 @@ module.exports = transform;
  * @property {number} [z=0] Altitude coordinate, often zero.
  */
 
+/**
+ * Represention of a size in gcs coordinates.
+ *
+ * @typedef geo.geoSize
+ * @type {object}
+ * @property {number} width Width in gcs coordinates.
+ * @property {number} height Height in gcs coordinates.
+ */
+
 /**
  * Represention of a size in pixels.
  *
@@ -38372,6 +38556,17 @@ var util = {
 
     return value !== null && value !== undefined && (type === 'object' || type === 'function');
   },
+
+  /**
+   * Return the first value passed to the function.  Using this function for
+   * identity calls can allow some code to bypass making such a call entirely.
+   *
+   * @param {*} d Any value.
+   * @returns {*} The passed value.
+   */
+  identityFunction: function identityFunction(d) {
+    return d;
+  },
   ///////////////////////////////////////////////////////////////////////////
 
   /*
@@ -39201,6 +39396,8 @@ module.exports = {
 var inherit = __webpack_require__(5699);
 
 var feature = __webpack_require__(6837);
+
+var util = __webpack_require__(4634);
 /**
  * Object specification for a graph feature.
  *
@@ -39327,9 +39524,7 @@ var vectorFeature = function vectorFeature(arg) {
         y: 0,
         z: 0
       },
-      delta: function delta(d) {
-        return d;
-      },
+      delta: util.identityFunction,
       scale: null // size scaling factor (null -> renderer decides)
 
     }, arg.style === undefined ? {} : arg.style);
@@ -39361,7 +39556,7 @@ module.exports = vectorFeature;
  * @constant
  * @type {string}
  */
-module.exports = "1.8.5";
+module.exports = "1.8.8";
 
 /***/ }),
 
@@ -40592,6 +40787,9 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
       negStrokeOffset: 0
     }],
         v = vert[1],
+        target_gcs = m_this.gcs(),
+        map_gcs = m_this.layer().map().gcs(),
+        simpleInverse = transform.onlyInvertedY(target_gcs, map_gcs),
         pos,
         posIdx3,
         firstpos,
@@ -40655,6 +40853,7 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
     if (!onlyStyle) {
       var position = [],
           posFunc = m_this.position();
+      posFunc = posFunc === util.identityFunction ? null : posFunc;
       lineItemList = new Array(data.length);
       closed = new Array(data.length);
 
@@ -40670,9 +40869,9 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
         numSegments += lineItem.length - 1;
 
         for (j = 0; j < lineItem.length; j += 1) {
-          pos = posFunc(lineItem[j], j, d, i);
+          pos = posFunc ? posFunc(lineItem[j], j, d, i) : lineItem[j];
           position.push(pos.x);
-          position.push(pos.y);
+          position.push(simpleInverse ? -pos.y : pos.y);
           position.push(pos.z || 0.0);
 
           if (!j) {
@@ -40695,7 +40894,10 @@ var webgl_lineFeature = function webgl_lineFeature(arg) {
         }
       }
 
-      position = transform.transformCoordinates(m_this.gcs(), m_this.layer().map().gcs(), position, 3);
+      if (!simpleInverse) {
+        position = transform.transformCoordinates(target_gcs, map_gcs, position, 3);
+      }
+
       m_origin = new Float32Array(m_this.style.get('origin')(position));
 
       if (m_origin[0] || m_origin[1] || m_origin[2]) {
@@ -43219,6 +43421,7 @@ var webgl_polygonFeature = function webgl_polygonFeature(arg) {
         items = [],
         target_gcs = m_this.gcs(),
         map_gcs = m_this.layer().map().gcs(),
+        simpleInverse = transform.onlyInvertedY(target_gcs, map_gcs),
         numPts = 0,
         geom = m_mapper.geometryData(),
         color,
@@ -43245,10 +43448,12 @@ var webgl_polygonFeature = function webgl_polygonFeature(arg) {
 
     if (!onlyStyle) {
       posFunc = m_this.style.get('position');
+      posFunc = posFunc === util.identityFunction ? null : posFunc;
       polyFunc = m_this.style.get('polygon');
+      polyFunc = polyFunc === util.identityFunction ? null : polyFunc;
       m_this.data().forEach(function (item, itemIndex) {
         var polygon, outer, geometry, c;
-        polygon = polyFunc(item, itemIndex);
+        polygon = polyFunc ? polyFunc(item, itemIndex) : item;
 
         if (!polygon) {
           return;
@@ -43267,9 +43472,9 @@ var webgl_polygonFeature = function webgl_polygonFeature(arg) {
         geometry = new Array(outer.length * 3);
 
         for (i = d3 = 0; i < outer.length; i += 1, d3 += 3) {
-          c = posFunc(outer[i], i, item, itemIndex);
+          c = posFunc ? posFunc(outer[i], i, item, itemIndex) : outer[i];
           geometry[d3] = c.x;
-          geometry[d3 + 1] = c.y; // ignore the z values until we support them
+          geometry[d3 + 1] = simpleInverse ? -c.y : c.y; // ignore the z values until we support them
 
           geometry[d3 + 2] = 0; // c.z || 0;
         }
@@ -43291,9 +43496,9 @@ var webgl_polygonFeature = function webgl_polygonFeature(arg) {
             geometry.holes.push(d3 / 3);
 
             for (i = 0; i < hole.length; i += 1, d3 += 3) {
-              c = posFunc(hole[i], i, item, itemIndex);
+              c = posFunc ? posFunc(hole[i], i, item, itemIndex) : hole[i];
               geometry.vertices[d3] = c.x;
-              geometry.vertices[d3 + 1] = c.y; // ignore the z values until we support them
+              geometry.vertices[d3 + 1] = simpleInverse ? -c.y : c.y; // ignore the z values until we support them
 
               geometry.vertices[d3 + 2] = 0; // c.z || 0;
             }
@@ -43301,7 +43506,10 @@ var webgl_polygonFeature = function webgl_polygonFeature(arg) {
         } // transform to map gcs
 
 
-        geometry.vertices = transform.transformCoordinates(target_gcs, map_gcs, geometry.vertices, geometry.dimensions);
+        if (!simpleInverse) {
+          geometry.vertices = transform.transformCoordinates(target_gcs, map_gcs, geometry.vertices, geometry.dimensions);
+        }
+
         record = {
           // triangulate
           triangles: earcut(geometry.vertices, geometry.holes, geometry.dimensions),