geojs 1.8.4 → 1.8.7

package/src/{annotation.js → annotation/annotation.js}

@@ -1,15 +1,9 @@
 var $ = require('jquery');
-var inherit = require('./inherit');
-var geo_event = require('./event');
-var geo_action = require('./action');
-var transform = require('./transform');
-var util = require('./util');
-var registerAnnotation = require('./registry').registerAnnotation;
-var lineFeature = require('./lineFeature');
-var markerFeature = require('./markerFeature');
-var pointFeature = require('./pointFeature');
-var polygonFeature = require('./polygonFeature');
-var textFeature = require('./textFeature');
+var geo_event = require('../event');
+var geo_action = require('../action');
+var transform = require('../transform');
+var util = require('../util');
+var textFeature = require('../textFeature');
 
 var annotationId = 0;
 
@@ -1267,1358 +1261,17 @@ function continuousVerticesProcessAction(m_this, evt, name) {
   }
 }
 
-/**
- * Rectangle annotation specification.  Extends {@link geo.annotation.spec}.
- *
- * @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.
- */
-
-/**
- * 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.rectangleAnnotation
- * @extends geo.annotation
- *
- * @param {geo.rectangleAnnotation.spec?} [args] Options for the annotation.
- * @param {string} [annotationName='rectangle'] Override the annotation name.
- */
-var rectangleAnnotation = function (args, annotationName) {
-  'use strict';
-  if (!(this instanceof rectangleAnnotation)) {
-    return new rectangleAnnotation(args, annotationName);
-  }
-
-  args = $.extend(true, {}, {
-    style: {
-      fill: true,
-      fillColor: {r: 0, g: 1, b: 0},
-      fillOpacity: 0.25,
-      polygon: function (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.
-   */
-  this.actions = function (state) {
-    if (!state) {
-      state = m_this.state();
-    }
-    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.
-   */
-  this.processAction = function (evt) {
-    var layer = m_this.layer();
-    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.
-   */
-  this.features = function () {
-    var opt = m_this.options(),
-        state = m_this.state(),
-        features;
-    features = [];
-    if (opt.corners && opt.corners.length >= 4) {
-      features = [{
-        polygon: {
-          polygon: opt.corners,
-          style: m_this.styleForState(state)
-        }
-      }];
-    }
-    if (state === annotationState.edit) {
-      m_this._addEditHandles(features, opt.corners);
-    }
-    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? */
-    }
-    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.
-   */
-  this._geojsonCoordinates = function (gcs) {
-    var src = m_this.coordinates(gcs);
-    if (!src || m_this.state() === annotationState.create || src.length < 4) {
-      return;
-    }
-    var coord = [];
-    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.
-   */
-  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.
-   */
-  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.
-   */
-  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 (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;
-    }
-    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 (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 (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) {
-      const style = m_this.styleForState(state);
-      const w = ((opt.corners[0].x - opt.corners[1].x) ** 2 + (opt.corners[0].y - opt.corners[1].y) ** 2) ** 0.5;
-      const h = ((opt.corners[0].x - opt.corners[3].x) ** 2 + (opt.corners[0].y - opt.corners[3].y) ** 2) ** 0.5;
-      const radius = Math.max(w, h) / 2 / m_this.layer().map().unitsPerPixel(0);
-      const aspect = w ? h / w : 1e20;
-      const 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.
- *
- * @class
- * @alias geo.circleAnnotation
- * @extends geo.annotation
- *
- * @param {geo.circleAnnotation.spec?} [args] Options for the annotation.
- * @param {string} [annotationName='circle'] Override the annotation name.
- */
-var circleAnnotation = function (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.
- */
-
-/**
- * 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 (args) {
-  'use strict';
-  if (!(this instanceof polygonAnnotation)) {
-    return new polygonAnnotation(args);
-  }
-
-  args = $.extend(true, {}, {
-    style: {
-      fill: true,
-      fillColor: {r: 0, g: 1, b: 0},
-      fillOpacity: 0.25,
-      polygon: function (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: {
-      closed: false,
-      fillColor: {r: 0.3, g: 0.3, b: 0.3},
-      fillOpacity: 0.25,
-      line: function (d) {
-        const 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 d; });
-      },
-      position: function (d, i) {
-        if (d.x !== undefined) {
-          return d.x;
-        }
-        return m_this.options('vertices')[i];
-      },
-      stroke: false,
-      strokeColor: {r: 0, g: 0, b: 1}
-    }
-  }, args || {});
-  args.vertices = args.vertices || args.coordinates || [];
-  delete args.coordinates;
-  annotation.call(this, 'polygon', args);
-
-  var m_this = this,
-      s_actions = this.actions;
-
-  /**
-   * 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.
-   */
-  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
-            }
-          };
-        }
-        break;
-      default:
-        features = [{
-          polygon: {
-            polygon: opt.vertices,
-            style: style
-          }
-        }];
-        if (state === annotationState.edit) {
-          m_this._addEditHandles(features, opt.vertices);
-        }
-        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) {
-      m_this.options('vertices', coordinates);
-    }
-    return m_this.options('vertices');
-  };
-
-  /**
-   * 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;
-    }
-    var vertices = m_this.options('vertices');
-    if (vertices.length) {
-      vertices[vertices.length - 1] = evt.mapgcs;
-      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;
-    }
-    var end = !!evt.buttonsDown.right, skip;
-    if (!evt.buttonsDown.left && !evt.buttonsDown.right) {
-      return;
-    }
-    var vertices = m_this.options('vertices');
-    if (evt.buttonsDown.right && !vertices.length) {
-      return;
-    }
-    evt.handled = true;
-    if (evt.buttonsDown.left) {
-      if (vertices.length) {
-        if (vertices.length >= 2 && layer.displayDistance(
-          vertices[vertices.length - 2], null, evt.map, 'display') <=
-          layer.options('adjacentPointProximity')) {
-          skip = true;
-          if (m_this._lastClick &&
-              evt.time - m_this._lastClick < layer.options('dblClickTime')) {
-            end = true;
-          }
-        } else if (vertices.length >= 2 && layer.displayDistance(
-          vertices[0], null, evt.map, 'display') <=
-          layer.options('finalPointProximity')) {
-          end = true;
-        } else {
-          vertices[vertices.length - 1] = evt.mapgcs;
-        }
-      } else {
-        vertices.push(evt.mapgcs);
-      }
-      if (!end && !skip) {
-        vertices.push(evt.mapgcs);
-      }
-      m_this._lastClick = evt.time;
-      m_this._lastClickVertexCount = vertices.length;
-    }
-    if (end) {
-      if (vertices.length < 4) {
-        return 'remove';
-      }
-      vertices.pop();
-      m_this.state(annotationState.done);
-      return 'done';
-    }
-    return !skip;
-  };
-
-  /**
-   * 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, 'polygon', 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, 'polygon');
-  };
-
-  /**
-   * 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.outer && src.length < 3) || m_this.state() === annotationState.create) {
-      return;
-    }
-    var coord = [];
-    if (!src.outer) {
-      coord = [src.map((pt) => [pt.x, pt.y])];
-      coord[0].push(coord[0][0].slice());
-    } else {
-      coord = [src.outer.map((pt) => [pt.x, pt.y])];
-      coord[0].push(coord[0][0].slice());
-      (src.inner || []).forEach((h) => {
-        const poly = h.map((pt) => [pt.x, pt.y]);
-        poly.push(poly[0].slice());
-        coord.push(poly);
-      });
-    }
-    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
-   * representation of the annotation.
-   *
-   * @returns {string[]} A list of style names to store.
-   */
-  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);
-
-/**
- * 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.
- */
-
-/**
- * Line annotation class.
- *
- * @class
- * @alias geo.lineAnnotation
- * @extends geo.annotation
- *
- * @param {geo.lineAnnotation.spec?} [args] Options for the annotation.
- */
-var lineAnnotation = function (args) {
-  'use strict';
-  if (!(this instanceof lineAnnotation)) {
-    return new lineAnnotation(args);
-  }
-
-  args = $.extend(true, {}, {
-    style: {
-      line: function (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; });
-      },
-      position: function (d, i) {
-        return m_this.options('vertices')[i];
-      },
-      strokeColor: {r: 0, g: 0, b: 0},
-      strokeOpacity: 1,
-      strokeWidth: 3,
-      closed: false,
-      lineCap: 'butt',
-      lineJoin: 'miter'
-    },
-    highlightStyle: {
-      strokeWidth: 5
-    },
-    createStyle: {
-      line: function (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; });
-      },
-      position: function (d, i) {
-        return m_this.options('vertices')[i];
-      },
-      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);
-
-  var m_this = this,
-      s_actions = this.actions,
-      s_processEditAction = this.processEditAction;
-
-  /**
-   * 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;
-    switch (state) {
-      case annotationState.create:
-        features = [{
-          line: {
-            line: opt.vertices,
-            style: m_this.styleForState(state)
-          }
-        }];
-        break;
-      default:
-        features = [{
-          line: {
-            line: opt.vertices,
-            style: m_this.styleForState(state)
-          }
-        }];
-        if (state === annotationState.edit) {
-          m_this._addEditHandles(features, opt.vertices, undefined, !m_this.style('closed'));
-        }
-        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) {
-      m_this.options('vertices', coordinates);
-    }
-    return m_this.options('vertices');
-  };
-
-  /**
-   * 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;
-    }
-    var vertices = m_this.options('vertices');
-    if (vertices.length) {
-      vertices[vertices.length - 1] = evt.mapgcs;
-      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;
-    }
-    var end = !!evt.buttonsDown.right, skip;
-    if (!evt.buttonsDown.left && !evt.buttonsDown.right) {
-      return;
-    }
-    var vertices = m_this.options('vertices');
-    if (evt.buttonsDown.right && !vertices.length) {
-      return;
-    }
-    evt.handled = true;
-    if (evt.buttonsDown.left) {
-      if (vertices.length) {
-        if (vertices.length >= 2 && layer.displayDistance(
-          vertices[vertices.length - 2], null, evt.map, 'display') <=
-          layer.options('adjacentPointProximity')) {
-          skip = true;
-          if (m_this._lastClick &&
-              evt.time - m_this._lastClick < layer.options('dblClickTime')) {
-            end = true;
-          }
-        } else if (vertices.length >= 2 && layer.displayDistance(
-          vertices[0], null, evt.map, 'display') <=
-          layer.options('finalPointProximity')) {
-          end = 'close';
-        } else {
-          vertices[vertices.length - 1] = evt.mapgcs;
-        }
-      } else {
-        vertices.push(evt.mapgcs);
-      }
-      if (!end && !skip) {
-        vertices.push(evt.mapgcs);
-      }
-      m_this._lastClick = evt.time;
-      m_this._lastClickVertexCount = vertices.length;
-    }
-    if (end) {
-      if (vertices.length < 3) {
-        return 'remove';
-      }
-      vertices.pop();
-      m_this.options('style').closed = end === 'close';
-      m_this.state(annotationState.done);
-      return 'done';
-    }
-    return !skip;
-  };
-
-  /**
-   * 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);
-
-/**
- * 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 (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 () {
-              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 {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;
-    }
-    evt.handled = true;
-    m_this.options('position', evt.mapgcs);
-    m_this.state(annotationState.done);
-    return 'done';
-  };
-
-  /**
-   * 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 [
-      'fill', 'fillColor', 'fillOpacity', 'radius', 'scaled', 'stroke',
-      'strokeColor', 'strokeOpacity', 'strokeWidth'];
-  };
-
-  /**
-   * 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 || m_this.state() === annotationState.create || src.length < 1 || src[0] === undefined) {
-      return;
-    }
-    return [src[0].x, src[0].y];
-  };
-
-  /**
-   * Return the geometry type that is used to store this annotation in geojson.
-   *
-   * @returns {string} A geojson geometry type.
-   */
-  this._geojsonGeometryType = function () {
-    return 'Point';
-  };
-};
-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.
+ * @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.
  */
@@ -2664,16 +1317,23 @@ function constrainAspectRatio(ratio) {
       const area = Math.abs(dist1 * dist3);
       let shape, edge;
       ratios.forEach((ratio) => {
-        if (ratio !== 1 && !(index % 2)) {
-          ratio = 1.0 / ratio;
+        let width, height;
+        if (ratio.width) {
+          width = ratio.width;
+          height = ratio.height;
+        } else {
+          width = (area * ratio) ** 0.5;
+          height = width / ratio;
+        }
+        if (width !== height && !(index % 2)) {
+          [width, height] = [height, width];
         }
-        const width = (area * ratio) ** 0.5;
-        const score = (width - dist3) ** 2 + (width / ratio - dist1) ** 2;
+        const score = (width - dist3) ** 2 + (height - dist1) ** 2;
         if (best === undefined || score < best) {
           best = score;
           shape = {
             w: width,
-            h: width / ratio
+            h: height
           };
         }
       });
@@ -2715,10 +1375,17 @@ function constrainAspectRatio(ratio) {
       /* Not in edit vertex or edge mode */
       const area = Math.abs((pos.x - origin.x) * (pos.y - origin.y));
       ratios.forEach((ratio) => {
-        const width = (area * ratio) ** 0.5;
+        let width, height;
+        if (ratio.width) {
+          width = ratio.width;
+          height = ratio.height;
+        } else {
+          width = (area * ratio) ** 0.5;
+          height = width / ratio;
+        }
         const adjusted = {
           x: origin.x + Math.sign(pos.x - origin.x) * width,
-          y: origin.y + Math.sign(pos.y - origin.y) * width / ratio
+          y: origin.y + Math.sign(pos.y - origin.y) * height
         };
         const score = (adjusted.x - pos.x) ** 2 + (adjusted.y - pos.y) ** 2;
         if (best === undefined || score < best) {
@@ -2745,14 +1412,11 @@ 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
+  defaultEditHandleStyle,
+  constrainAspectRatio,
+  // these aren't exposed in index.js
+  annotationActionOwner,
+  continuousVerticesActions,
+  continuousVerticesProcessAction
 };