diff --git a/js/lib/id/actions.js b/js/lib/id/actions.js
deleted file mode 100644
index 8882a2386..000000000
--- a/js/lib/id/actions.js
+++ /dev/null
@@ -1,2209 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (factory((global.iD = global.iD || {}, global.iD.actions = global.iD.actions || {})));
-}(this, function (exports) { 'use strict';
-
-  function AddEntity(way) {
-      return function(graph) {
-          return graph.replace(way);
-      };
-  }
-
-  function AddMember(relationId, member, memberIndex) {
-      return function(graph) {
-          var relation = graph.entity(relationId);
-
-          if (isNaN(memberIndex) && member.type === 'way') {
-              var members = relation.indexedMembers();
-              members.push(member);
-
-              var joined = iD.geo.joinWays(members, graph);
-              for (var i = 0; i < joined.length; i++) {
-                  var segment = joined[i];
-                  for (var j = 0; j < segment.length && segment.length >= 2; j++) {
-                      if (segment[j] !== member)
-                          continue;
-
-                      if (j === 0) {
-                          memberIndex = segment[j + 1].index;
-                      } else if (j === segment.length - 1) {
-                          memberIndex = segment[j - 1].index + 1;
-                      } else {
-                          memberIndex = Math.min(segment[j - 1].index + 1, segment[j + 1].index + 1);
-                      }
-                  }
-              }
-          }
-
-          return graph.replace(relation.addMember(member, memberIndex));
-      };
-  }
-
-  function AddMidpoint(midpoint, node) {
-      return function(graph) {
-          graph = graph.replace(node.move(midpoint.loc));
-
-          var parents = _.intersection(
-              graph.parentWays(graph.entity(midpoint.edge[0])),
-              graph.parentWays(graph.entity(midpoint.edge[1])));
-
-          parents.forEach(function(way) {
-              for (var i = 0; i < way.nodes.length - 1; i++) {
-                  if (iD.geo.edgeEqual([way.nodes[i], way.nodes[i + 1]], midpoint.edge)) {
-                      graph = graph.replace(graph.entity(way.id).addNode(node.id, i + 1));
-
-                      // Add only one midpoint on doubled-back segments,
-                      // turning them into self-intersections.
-                      return;
-                  }
-              }
-          });
-
-          return graph;
-      };
-  }
-
-  // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/AddNodeToWayAction.as
-  function AddVertex(wayId, nodeId, index) {
-      return function(graph) {
-          return graph.replace(graph.entity(wayId).addNode(nodeId, index));
-      };
-  }
-
-  function ChangeMember(relationId, member, memberIndex) {
-      return function(graph) {
-          return graph.replace(graph.entity(relationId).updateMember(member, memberIndex));
-      };
-  }
-
-  function ChangePreset(entityId, oldPreset, newPreset) {
-      return function(graph) {
-          var entity = graph.entity(entityId),
-              geometry = entity.geometry(graph),
-              tags = entity.tags;
-
-          if (oldPreset) tags = oldPreset.removeTags(tags, geometry);
-          if (newPreset) tags = newPreset.applyTags(tags, geometry);
-
-          return graph.replace(entity.update({tags: tags}));
-      };
-  }
-
-  function ChangeTags(entityId, tags) {
-      return function(graph) {
-          var entity = graph.entity(entityId);
-          return graph.replace(entity.update({tags: tags}));
-      };
-  }
-
-  function Circularize(wayId, projection, maxAngle) {
-      maxAngle = (maxAngle || 20) * Math.PI / 180;
-
-      var action = function(graph) {
-          var way = graph.entity(wayId);
-
-          if (!way.isConvex(graph)) {
-              graph = action.makeConvex(graph);
-          }
-
-          var nodes = _.uniq(graph.childNodes(way)),
-              keyNodes = nodes.filter(function(n) { return graph.parentWays(n).length !== 1; }),
-              points = nodes.map(function(n) { return projection(n.loc); }),
-              keyPoints = keyNodes.map(function(n) { return projection(n.loc); }),
-              centroid = (points.length === 2) ? iD.geo.interp(points[0], points[1], 0.5) : d3.geom.polygon(points).centroid(),
-              radius = d3.median(points, function(p) { return iD.geo.euclideanDistance(centroid, p); }),
-              sign = d3.geom.polygon(points).area() > 0 ? 1 : -1,
-              ids;
-
-          // we need atleast two key nodes for the algorithm to work
-          if (!keyNodes.length) {
-              keyNodes = [nodes[0]];
-              keyPoints = [points[0]];
-          }
-
-          if (keyNodes.length === 1) {
-              var index = nodes.indexOf(keyNodes[0]),
-                  oppositeIndex = Math.floor((index + nodes.length / 2) % nodes.length);
-
-              keyNodes.push(nodes[oppositeIndex]);
-              keyPoints.push(points[oppositeIndex]);
-          }
-
-          // key points and nodes are those connected to the ways,
-          // they are projected onto the circle, inbetween nodes are moved
-          // to constant intervals between key nodes, extra inbetween nodes are
-          // added if necessary.
-          for (var i = 0; i < keyPoints.length; i++) {
-              var nextKeyNodeIndex = (i + 1) % keyNodes.length,
-                  startNode = keyNodes[i],
-                  endNode = keyNodes[nextKeyNodeIndex],
-                  startNodeIndex = nodes.indexOf(startNode),
-                  endNodeIndex = nodes.indexOf(endNode),
-                  numberNewPoints = -1,
-                  indexRange = endNodeIndex - startNodeIndex,
-                  distance, totalAngle, eachAngle, startAngle, endAngle,
-                  angle, loc, node, j,
-                  inBetweenNodes = [];
-
-              if (indexRange < 0) {
-                  indexRange += nodes.length;
-              }
-
-              // position this key node
-              distance = iD.geo.euclideanDistance(centroid, keyPoints[i]);
-              if (distance === 0) { distance = 1e-4; }
-              keyPoints[i] = [
-                  centroid[0] + (keyPoints[i][0] - centroid[0]) / distance * radius,
-                  centroid[1] + (keyPoints[i][1] - centroid[1]) / distance * radius];
-              graph = graph.replace(keyNodes[i].move(projection.invert(keyPoints[i])));
-
-              // figure out the between delta angle we want to match to
-              startAngle = Math.atan2(keyPoints[i][1] - centroid[1], keyPoints[i][0] - centroid[0]);
-              endAngle = Math.atan2(keyPoints[nextKeyNodeIndex][1] - centroid[1], keyPoints[nextKeyNodeIndex][0] - centroid[0]);
-              totalAngle = endAngle - startAngle;
-
-              // detects looping around -pi/pi
-              if (totalAngle * sign > 0) {
-                  totalAngle = -sign * (2 * Math.PI - Math.abs(totalAngle));
-              }
-
-              do {
-                  numberNewPoints++;
-                  eachAngle = totalAngle / (indexRange + numberNewPoints);
-              } while (Math.abs(eachAngle) > maxAngle);
-
-              // move existing points
-              for (j = 1; j < indexRange; j++) {
-                  angle = startAngle + j * eachAngle;
-                  loc = projection.invert([
-                      centroid[0] + Math.cos(angle)*radius,
-                      centroid[1] + Math.sin(angle)*radius]);
-
-                  node = nodes[(j + startNodeIndex) % nodes.length].move(loc);
-                  graph = graph.replace(node);
-              }
-
-              // add new inbetween nodes if necessary
-              for (j = 0; j < numberNewPoints; j++) {
-                  angle = startAngle + (indexRange + j) * eachAngle;
-                  loc = projection.invert([
-                      centroid[0] + Math.cos(angle) * radius,
-                      centroid[1] + Math.sin(angle) * radius]);
-
-                  node = iD.Node({loc: loc});
-                  graph = graph.replace(node);
-
-                  nodes.splice(endNodeIndex + j, 0, node);
-                  inBetweenNodes.push(node.id);
-              }
-
-              // Check for other ways that share these keyNodes..
-              // If keyNodes are adjacent in both ways,
-              // we can add inBetween nodes to that shared way too..
-              if (indexRange === 1 && inBetweenNodes.length) {
-                  var startIndex1 = way.nodes.lastIndexOf(startNode.id),
-                      endIndex1 = way.nodes.lastIndexOf(endNode.id),
-                      wayDirection1 = (endIndex1 - startIndex1);
-                  if (wayDirection1 < -1) { wayDirection1 = 1; }
-
-                  /* eslint-disable no-loop-func */
-                  _.each(_.without(graph.parentWays(keyNodes[i]), way), function(sharedWay) {
-                      if (sharedWay.areAdjacent(startNode.id, endNode.id)) {
-                          var startIndex2 = sharedWay.nodes.lastIndexOf(startNode.id),
-                              endIndex2 = sharedWay.nodes.lastIndexOf(endNode.id),
-                              wayDirection2 = (endIndex2 - startIndex2),
-                              insertAt = endIndex2;
-                          if (wayDirection2 < -1) { wayDirection2 = 1; }
-
-                          if (wayDirection1 !== wayDirection2) {
-                              inBetweenNodes.reverse();
-                              insertAt = startIndex2;
-                          }
-                          for (j = 0; j < inBetweenNodes.length; j++) {
-                              sharedWay = sharedWay.addNode(inBetweenNodes[j], insertAt + j);
-                          }
-                          graph = graph.replace(sharedWay);
-                      }
-                  });
-                  /* eslint-enable no-loop-func */
-              }
-
-          }
-
-          // update the way to have all the new nodes
-          ids = nodes.map(function(n) { return n.id; });
-          ids.push(ids[0]);
-
-          way = way.update({nodes: ids});
-          graph = graph.replace(way);
-
-          return graph;
-      };
-
-      action.makeConvex = function(graph) {
-          var way = graph.entity(wayId),
-              nodes = _.uniq(graph.childNodes(way)),
-              points = nodes.map(function(n) { return projection(n.loc); }),
-              sign = d3.geom.polygon(points).area() > 0 ? 1 : -1,
-              hull = d3.geom.hull(points);
-
-          // D3 convex hulls go counterclockwise..
-          if (sign === -1) {
-              nodes.reverse();
-              points.reverse();
-          }
-
-          for (var i = 0; i < hull.length - 1; i++) {
-              var startIndex = points.indexOf(hull[i]),
-                  endIndex = points.indexOf(hull[i+1]),
-                  indexRange = (endIndex - startIndex);
-
-              if (indexRange < 0) {
-                  indexRange += nodes.length;
-              }
-
-              // move interior nodes to the surface of the convex hull..
-              for (var j = 1; j < indexRange; j++) {
-                  var point = iD.geo.interp(hull[i], hull[i+1], j / indexRange),
-                      node = nodes[(j + startIndex) % nodes.length].move(projection.invert(point));
-                  graph = graph.replace(node);
-              }
-          }
-          return graph;
-      };
-
-      action.disabled = function(graph) {
-          if (!graph.entity(wayId).isClosed())
-              return 'not_closed';
-      };
-
-      return action;
-  }
-
-  function DeleteMultiple(ids) {
-      var actions = {
-          way: DeleteWay,
-          node: DeleteNode,
-          relation: DeleteRelation
-      };
-
-      var action = function(graph) {
-          ids.forEach(function(id) {
-              if (graph.hasEntity(id)) { // It may have been deleted aready.
-                  graph = actions[graph.entity(id).type](id)(graph);
-              }
-          });
-
-          return graph;
-      };
-
-      action.disabled = function(graph) {
-          for (var i = 0; i < ids.length; i++) {
-              var id = ids[i],
-                  disabled = actions[graph.entity(id).type](id).disabled(graph);
-              if (disabled) return disabled;
-          }
-      };
-
-      return action;
-  }
-
-  // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/DeleteRelationAction.as
-  function DeleteRelation(relationId) {
-      function deleteEntity(entity, graph) {
-          return !graph.parentWays(entity).length &&
-              !graph.parentRelations(entity).length &&
-              !entity.hasInterestingTags();
-      }
-
-      var action = function(graph) {
-          var relation = graph.entity(relationId);
-
-          graph.parentRelations(relation)
-              .forEach(function(parent) {
-                  parent = parent.removeMembersWithID(relationId);
-                  graph = graph.replace(parent);
-
-                  if (parent.isDegenerate()) {
-                      graph = DeleteRelation(parent.id)(graph);
-                  }
-              });
-
-          _.uniq(_.map(relation.members, 'id')).forEach(function(memberId) {
-              graph = graph.replace(relation.removeMembersWithID(memberId));
-
-              var entity = graph.entity(memberId);
-              if (deleteEntity(entity, graph)) {
-                  graph = DeleteMultiple([memberId])(graph);
-              }
-          });
-
-          return graph.remove(relation);
-      };
-
-      action.disabled = function(graph) {
-          if (!graph.entity(relationId).isComplete(graph))
-              return 'incomplete_relation';
-      };
-
-      return action;
-  }
-
-  // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/DeleteWayAction.as
-  function DeleteWay(wayId) {
-      function deleteNode(node, graph) {
-          return !graph.parentWays(node).length &&
-              !graph.parentRelations(node).length &&
-              !node.hasInterestingTags();
-      }
-
-      var action = function(graph) {
-          var way = graph.entity(wayId);
-
-          graph.parentRelations(way)
-              .forEach(function(parent) {
-                  parent = parent.removeMembersWithID(wayId);
-                  graph = graph.replace(parent);
-
-                  if (parent.isDegenerate()) {
-                      graph = DeleteRelation(parent.id)(graph);
-                  }
-              });
-
-          _.uniq(way.nodes).forEach(function(nodeId) {
-              graph = graph.replace(way.removeNode(nodeId));
-
-              var node = graph.entity(nodeId);
-              if (deleteNode(node, graph)) {
-                  graph = graph.remove(node);
-              }
-          });
-
-          return graph.remove(way);
-      };
-
-      action.disabled = function(graph) {
-          var disabled = false;
-
-          graph.parentRelations(graph.entity(wayId)).forEach(function(parent) {
-              var type = parent.tags.type,
-                  role = parent.memberById(wayId).role || 'outer';
-              if (type === 'route' || type === 'boundary' || (type === 'multipolygon' && role === 'outer')) {
-                  disabled = 'part_of_relation';
-              }
-          });
-
-          return disabled;
-      };
-
-      return action;
-  }
-
-  // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/DeleteNodeAction.as
-  function DeleteNode(nodeId) {
-      var action = function(graph) {
-          var node = graph.entity(nodeId);
-
-          graph.parentWays(node)
-              .forEach(function(parent) {
-                  parent = parent.removeNode(nodeId);
-                  graph = graph.replace(parent);
-
-                  if (parent.isDegenerate()) {
-                      graph = DeleteWay(parent.id)(graph);
-                  }
-              });
-
-          graph.parentRelations(node)
-              .forEach(function(parent) {
-                  parent = parent.removeMembersWithID(nodeId);
-                  graph = graph.replace(parent);
-
-                  if (parent.isDegenerate()) {
-                      graph = DeleteRelation(parent.id)(graph);
-                  }
-              });
-
-          return graph.remove(node);
-      };
-
-      action.disabled = function() {
-          return false;
-      };
-
-      return action;
-  }
-
-  // Connect the ways at the given nodes.
-  //
-  // The last node will survive. All other nodes will be replaced with
-  // the surviving node in parent ways, and then removed.
-  //
-  // Tags and relation memberships of of non-surviving nodes are merged
-  // to the survivor.
-  //
-  // This is the inverse of `iD.actions.Disconnect`.
-  //
-  // Reference:
-  //   https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/MergeNodesAction.as
-  //   https://github.com/openstreetmap/josm/blob/mirror/src/org/openstreetmap/josm/actions/MergeNodesAction.java
-  //
-  function Connect(nodeIds) {
-      return function(graph) {
-          var survivor = graph.entity(_.last(nodeIds));
-
-          for (var i = 0; i < nodeIds.length - 1; i++) {
-              var node = graph.entity(nodeIds[i]);
-
-              /* eslint-disable no-loop-func */
-              graph.parentWays(node).forEach(function(parent) {
-                  if (!parent.areAdjacent(node.id, survivor.id)) {
-                      graph = graph.replace(parent.replaceNode(node.id, survivor.id));
-                  }
-              });
-
-              graph.parentRelations(node).forEach(function(parent) {
-                  graph = graph.replace(parent.replaceMember(node, survivor));
-              });
-              /* eslint-enable no-loop-func */
-
-              survivor = survivor.mergeTags(node.tags);
-              graph = DeleteNode(node.id)(graph);
-          }
-
-          graph = graph.replace(survivor);
-
-          return graph;
-      };
-  }
-
-  function CopyEntities(ids, fromGraph) {
-      var copies = {};
-
-      var action = function(graph) {
-          ids.forEach(function(id) {
-              fromGraph.entity(id).copy(fromGraph, copies);
-          });
-
-          for (var id in copies) {
-              graph = graph.replace(copies[id]);
-          }
-
-          return graph;
-      };
-
-      action.copies = function() {
-          return copies;
-      };
-
-      return action;
-  }
-
-  function DeleteMember(relationId, memberIndex) {
-      return function(graph) {
-          var relation = graph.entity(relationId)
-              .removeMember(memberIndex);
-
-          graph = graph.replace(relation);
-
-          if (relation.isDegenerate())
-              graph = DeleteRelation(relation.id)(graph);
-
-          return graph;
-      };
-  }
-
-  function DeprecateTags(entityId) {
-      return function(graph) {
-          var entity = graph.entity(entityId),
-              newtags = _.clone(entity.tags),
-              change = false,
-              rule;
-
-          // This handles deprecated tags with a single condition
-          for (var i = 0; i < iD.data.deprecated.length; i++) {
-
-              rule = iD.data.deprecated[i];
-              var match = _.toPairs(rule.old)[0],
-                  replacements = rule.replace ? _.toPairs(rule.replace) : null;
-
-              if (entity.tags[match[0]] && match[1] === '*') {
-
-                  var value = entity.tags[match[0]];
-                  if (replacements && !newtags[replacements[0][0]]) {
-                      newtags[replacements[0][0]] = value;
-                  }
-                  delete newtags[match[0]];
-                  change = true;
-
-              } else if (entity.tags[match[0]] === match[1]) {
-                  newtags = _.assign({}, rule.replace || {}, _.omit(newtags, match[0]));
-                  change = true;
-              }
-          }
-
-          if (change) {
-              return graph.replace(entity.update({tags: newtags}));
-          } else {
-              return graph;
-          }
-      };
-  }
-
-  function DiscardTags(difference) {
-      return function(graph) {
-          function discardTags(entity) {
-              if (!_.isEmpty(entity.tags)) {
-                  var tags = {};
-                  _.each(entity.tags, function(v, k) {
-                      if (v) tags[k] = v;
-                  });
-
-                  graph = graph.replace(entity.update({
-                      tags: _.omit(tags, iD.data.discarded)
-                  }));
-              }
-          }
-
-          difference.modified().forEach(discardTags);
-          difference.created().forEach(discardTags);
-
-          return graph;
-      };
-  }
-
-  // Disconect the ways at the given node.
-  //
-  // Optionally, disconnect only the given ways.
-  //
-  // For testing convenience, accepts an ID to assign to the (first) new node.
-  // Normally, this will be undefined and the way will automatically
-  // be assigned a new ID.
-  //
-  // This is the inverse of `iD.actions.Connect`.
-  //
-  // Reference:
-  //   https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/UnjoinNodeAction.as
-  //   https://github.com/openstreetmap/josm/blob/mirror/src/org/openstreetmap/josm/actions/UnGlueAction.java
-  //
-  function Disconnect(nodeId, newNodeId) {
-      var wayIds;
-
-      var action = function(graph) {
-          var node = graph.entity(nodeId),
-              connections = action.connections(graph);
-
-          connections.forEach(function(connection) {
-              var way = graph.entity(connection.wayID),
-                  newNode = iD.Node({id: newNodeId, loc: node.loc, tags: node.tags});
-
-              graph = graph.replace(newNode);
-              if (connection.index === 0 && way.isArea()) {
-                  // replace shared node with shared node..
-                  graph = graph.replace(way.replaceNode(way.nodes[0], newNode.id));
-              } else {
-                  // replace shared node with multiple new nodes..
-                  graph = graph.replace(way.updateNode(newNode.id, connection.index));
-              }
-          });
-
-          return graph;
-      };
-
-      action.connections = function(graph) {
-          var candidates = [],
-              keeping = false,
-              parentWays = graph.parentWays(graph.entity(nodeId));
-
-          parentWays.forEach(function(way) {
-              if (wayIds && wayIds.indexOf(way.id) === -1) {
-                  keeping = true;
-                  return;
-              }
-              if (way.isArea() && (way.nodes[0] === nodeId)) {
-                  candidates.push({wayID: way.id, index: 0});
-              } else {
-                  way.nodes.forEach(function(waynode, index) {
-                      if (waynode === nodeId) {
-                          candidates.push({wayID: way.id, index: index});
-                      }
-                  });
-              }
-          });
-
-          return keeping ? candidates : candidates.slice(1);
-      };
-
-      action.disabled = function(graph) {
-          var connections = action.connections(graph);
-          if (connections.length === 0 || (wayIds && wayIds.length !== connections.length))
-              return 'not_connected';
-
-          var parentWays = graph.parentWays(graph.entity(nodeId)),
-              seenRelationIds = {},
-              sharedRelation;
-
-          parentWays.forEach(function(way) {
-              if (wayIds && wayIds.indexOf(way.id) === -1)
-                  return;
-
-              var relations = graph.parentRelations(way);
-              relations.forEach(function(relation) {
-                  if (relation.id in seenRelationIds) {
-                      sharedRelation = relation;
-                  } else {
-                      seenRelationIds[relation.id] = true;
-                  }
-              });
-          });
-
-          if (sharedRelation)
-              return 'relation';
-      };
-
-      action.limitWays = function(_) {
-          if (!arguments.length) return wayIds;
-          wayIds = _;
-          return action;
-      };
-
-      return action;
-  }
-
-  // Join ways at the end node they share.
-  //
-  // This is the inverse of `iD.actions.Split`.
-  //
-  // Reference:
-  //   https://github.com/systemed/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/MergeWaysAction.as
-  //   https://github.com/openstreetmap/josm/blob/mirror/src/org/openstreetmap/josm/actions/CombineWayAction.java
-  //
-  function Join(ids) {
-
-      function groupEntitiesByGeometry(graph) {
-          var entities = ids.map(function(id) { return graph.entity(id); });
-          return _.extend({line: []}, _.groupBy(entities, function(entity) { return entity.geometry(graph); }));
-      }
-
-      var action = function(graph) {
-          var ways = ids.map(graph.entity, graph),
-              survivor = ways[0];
-
-          // Prefer to keep an existing way.
-          for (var i = 0; i < ways.length; i++) {
-              if (!ways[i].isNew()) {
-                  survivor = ways[i];
-                  break;
-              }
-          }
-
-          var joined = iD.geo.joinWays(ways, graph)[0];
-
-          survivor = survivor.update({nodes: _.map(joined.nodes, 'id')});
-          graph = graph.replace(survivor);
-
-          joined.forEach(function(way) {
-              if (way.id === survivor.id)
-                  return;
-
-              graph.parentRelations(way).forEach(function(parent) {
-                  graph = graph.replace(parent.replaceMember(way, survivor));
-              });
-
-              survivor = survivor.mergeTags(way.tags);
-
-              graph = graph.replace(survivor);
-              graph = DeleteWay(way.id)(graph);
-          });
-
-          return graph;
-      };
-
-      action.disabled = function(graph) {
-          var geometries = groupEntitiesByGeometry(graph);
-          if (ids.length < 2 || ids.length !== geometries.line.length)
-              return 'not_eligible';
-
-          var joined = iD.geo.joinWays(ids.map(graph.entity, graph), graph);
-          if (joined.length > 1)
-              return 'not_adjacent';
-
-          var nodeIds = _.map(joined[0].nodes, 'id').slice(1, -1),
-              relation,
-              tags = {},
-              conflicting = false;
-
-          joined[0].forEach(function(way) {
-              var parents = graph.parentRelations(way);
-              parents.forEach(function(parent) {
-                  if (parent.isRestriction() && parent.members.some(function(m) { return nodeIds.indexOf(m.id) >= 0; }))
-                      relation = parent;
-              });
-
-              for (var k in way.tags) {
-                  if (!(k in tags)) {
-                      tags[k] = way.tags[k];
-                  } else if (tags[k] && iD.interestingTag(k) && tags[k] !== way.tags[k]) {
-                      conflicting = true;
-                  }
-              }
-          });
-
-          if (relation)
-              return 'restriction';
-
-          if (conflicting)
-              return 'conflicting_tags';
-      };
-
-      return action;
-  }
-
-  function Merge(ids) {
-      function groupEntitiesByGeometry(graph) {
-          var entities = ids.map(function(id) { return graph.entity(id); });
-          return _.extend({point: [], area: [], line: [], relation: []},
-              _.groupBy(entities, function(entity) { return entity.geometry(graph); }));
-      }
-
-      var action = function(graph) {
-          var geometries = groupEntitiesByGeometry(graph),
-              target = geometries.area[0] || geometries.line[0],
-              points = geometries.point;
-
-          points.forEach(function(point) {
-              target = target.mergeTags(point.tags);
-
-              graph.parentRelations(point).forEach(function(parent) {
-                  graph = graph.replace(parent.replaceMember(point, target));
-              });
-
-              graph = graph.remove(point);
-          });
-
-          graph = graph.replace(target);
-
-          return graph;
-      };
-
-      action.disabled = function(graph) {
-          var geometries = groupEntitiesByGeometry(graph);
-          if (geometries.point.length === 0 ||
-              (geometries.area.length + geometries.line.length) !== 1 ||
-              geometries.relation.length !== 0)
-              return 'not_eligible';
-      };
-
-      return action;
-  }
-
-  function MergePolygon(ids, newRelationId) {
-
-      function groupEntities(graph) {
-          var entities = ids.map(function (id) { return graph.entity(id); });
-          return _.extend({
-                  closedWay: [],
-                  multipolygon: [],
-                  other: []
-              }, _.groupBy(entities, function(entity) {
-                  if (entity.type === 'way' && entity.isClosed()) {
-                      return 'closedWay';
-                  } else if (entity.type === 'relation' && entity.isMultipolygon()) {
-                      return 'multipolygon';
-                  } else {
-                      return 'other';
-                  }
-              }));
-      }
-
-      var action = function(graph) {
-          var entities = groupEntities(graph);
-
-          // An array representing all the polygons that are part of the multipolygon.
-          //
-          // Each element is itself an array of objects with an id property, and has a
-          // locs property which is an array of the locations forming the polygon.
-          var polygons = entities.multipolygon.reduce(function(polygons, m) {
-              return polygons.concat(iD.geo.joinWays(m.members, graph));
-          }, []).concat(entities.closedWay.map(function(d) {
-              var member = [{id: d.id}];
-              member.nodes = graph.childNodes(d);
-              return member;
-          }));
-
-          // contained is an array of arrays of boolean values,
-          // where contained[j][k] is true iff the jth way is
-          // contained by the kth way.
-          var contained = polygons.map(function(w, i) {
-              return polygons.map(function(d, n) {
-                  if (i === n) return null;
-                  return iD.geo.polygonContainsPolygon(
-                      _.map(d.nodes, 'loc'),
-                      _.map(w.nodes, 'loc'));
-              });
-          });
-
-          // Sort all polygons as either outer or inner ways
-          var members = [],
-              outer = true;
-
-          while (polygons.length) {
-              extractUncontained(polygons);
-              polygons = polygons.filter(isContained);
-              contained = contained.filter(isContained).map(filterContained);
-          }
-
-          function isContained(d, i) {
-              return _.some(contained[i]);
-          }
-
-          function filterContained(d) {
-              return d.filter(isContained);
-          }
-
-          function extractUncontained(polygons) {
-              polygons.forEach(function(d, i) {
-                  if (!isContained(d, i)) {
-                      d.forEach(function(member) {
-                          members.push({
-                              type: 'way',
-                              id: member.id,
-                              role: outer ? 'outer' : 'inner'
-                          });
-                      });
-                  }
-              });
-              outer = !outer;
-          }
-
-          // Move all tags to one relation
-          var relation = entities.multipolygon[0] ||
-              iD.Relation({ id: newRelationId, tags: { type: 'multipolygon' }});
-
-          entities.multipolygon.slice(1).forEach(function(m) {
-              relation = relation.mergeTags(m.tags);
-              graph = graph.remove(m);
-          });
-
-          entities.closedWay.forEach(function(way) {
-              function isThisOuter(m) {
-                  return m.id === way.id && m.role !== 'inner';
-              }
-              if (members.some(isThisOuter)) {
-                  relation = relation.mergeTags(way.tags);
-                  graph = graph.replace(way.update({ tags: {} }));
-              }
-          });
-
-          return graph.replace(relation.update({
-              members: members,
-              tags: _.omit(relation.tags, 'area')
-          }));
-      };
-
-      action.disabled = function(graph) {
-          var entities = groupEntities(graph);
-          if (entities.other.length > 0 ||
-              entities.closedWay.length + entities.multipolygon.length < 2)
-              return 'not_eligible';
-          if (!entities.multipolygon.every(function(r) { return r.isComplete(graph); }))
-              return 'incomplete_relation';
-      };
-
-      return action;
-  }
-
-  function MergeRemoteChanges(id, localGraph, remoteGraph, formatUser) {
-      var option = 'safe',  // 'safe', 'force_local', 'force_remote'
-          conflicts = [];
-
-      function user(d) {
-          return _.isFunction(formatUser) ? formatUser(d) : d;
-      }
-
-
-      function mergeLocation(remote, target) {
-          function pointEqual(a, b) {
-              var epsilon = 1e-6;
-              return (Math.abs(a[0] - b[0]) < epsilon) && (Math.abs(a[1] - b[1]) < epsilon);
-          }
-
-          if (option === 'force_local' || pointEqual(target.loc, remote.loc)) {
-              return target;
-          }
-          if (option === 'force_remote') {
-              return target.update({loc: remote.loc});
-          }
-
-          conflicts.push(t('merge_remote_changes.conflict.location', { user: user(remote.user) }));
-          return target;
-      }
-
-
-      function mergeNodes(base, remote, target) {
-          if (option === 'force_local' || _.isEqual(target.nodes, remote.nodes)) {
-              return target;
-          }
-          if (option === 'force_remote') {
-              return target.update({nodes: remote.nodes});
-          }
-
-          var ccount = conflicts.length,
-              o = base.nodes || [],
-              a = target.nodes || [],
-              b = remote.nodes || [],
-              nodes = [],
-              hunks = Diff3.diff3_merge(a, o, b, true);
-
-          for (var i = 0; i < hunks.length; i++) {
-              var hunk = hunks[i];
-              if (hunk.ok) {
-                  nodes.push.apply(nodes, hunk.ok);
-              } else {
-                  // for all conflicts, we can assume c.a !== c.b
-                  // because `diff3_merge` called with `true` option to exclude false conflicts..
-                  var c = hunk.conflict;
-                  if (_.isEqual(c.o, c.a)) {  // only changed remotely
-                      nodes.push.apply(nodes, c.b);
-                  } else if (_.isEqual(c.o, c.b)) {  // only changed locally
-                      nodes.push.apply(nodes, c.a);
-                  } else {       // changed both locally and remotely
-                      conflicts.push(t('merge_remote_changes.conflict.nodelist', { user: user(remote.user) }));
-                      break;
-                  }
-              }
-          }
-
-          return (conflicts.length === ccount) ? target.update({nodes: nodes}) : target;
-      }
-
-
-      function mergeChildren(targetWay, children, updates, graph) {
-          function isUsed(node, targetWay) {
-              var parentWays = _.map(graph.parentWays(node), 'id');
-              return node.hasInterestingTags() ||
-                  _.without(parentWays, targetWay.id).length > 0 ||
-                  graph.parentRelations(node).length > 0;
-          }
-
-          var ccount = conflicts.length;
-
-          for (var i = 0; i < children.length; i++) {
-              var id = children[i],
-                  node = graph.hasEntity(id);
-
-              // remove unused childNodes..
-              if (targetWay.nodes.indexOf(id) === -1) {
-                  if (node && !isUsed(node, targetWay)) {
-                      updates.removeIds.push(id);
-                  }
-                  continue;
-              }
-
-              // restore used childNodes..
-              var local = localGraph.hasEntity(id),
-                  remote = remoteGraph.hasEntity(id),
-                  target;
-
-              if (option === 'force_remote' && remote && remote.visible) {
-                  updates.replacements.push(remote);
-
-              } else if (option === 'force_local' && local) {
-                  target = iD.Entity(local);
-                  if (remote) {
-                      target = target.update({ version: remote.version });
-                  }
-                  updates.replacements.push(target);
-
-              } else if (option === 'safe' && local && remote && local.version !== remote.version) {
-                  target = iD.Entity(local, { version: remote.version });
-                  if (remote.visible) {
-                      target = mergeLocation(remote, target);
-                  } else {
-                      conflicts.push(t('merge_remote_changes.conflict.deleted', { user: user(remote.user) }));
-                  }
-
-                  if (conflicts.length !== ccount) break;
-                  updates.replacements.push(target);
-              }
-          }
-
-          return targetWay;
-      }
-
-
-      function updateChildren(updates, graph) {
-          for (var i = 0; i < updates.replacements.length; i++) {
-              graph = graph.replace(updates.replacements[i]);
-          }
-          if (updates.removeIds.length) {
-              graph = DeleteMultiple(updates.removeIds)(graph);
-          }
-          return graph;
-      }
-
-
-      function mergeMembers(remote, target) {
-          if (option === 'force_local' || _.isEqual(target.members, remote.members)) {
-              return target;
-          }
-          if (option === 'force_remote') {
-              return target.update({members: remote.members});
-          }
-
-          conflicts.push(t('merge_remote_changes.conflict.memberlist', { user: user(remote.user) }));
-          return target;
-      }
-
-
-      function mergeTags(base, remote, target) {
-          function ignoreKey(k) {
-              return _.includes(iD.data.discarded, k);
-          }
-
-          if (option === 'force_local' || _.isEqual(target.tags, remote.tags)) {
-              return target;
-          }
-          if (option === 'force_remote') {
-              return target.update({tags: remote.tags});
-          }
-
-          var ccount = conflicts.length,
-              o = base.tags || {},
-              a = target.tags || {},
-              b = remote.tags || {},
-              keys = _.reject(_.union(_.keys(o), _.keys(a), _.keys(b)), ignoreKey),
-              tags = _.clone(a),
-              changed = false;
-
-          for (var i = 0; i < keys.length; i++) {
-              var k = keys[i];
-
-              if (o[k] !== b[k] && a[k] !== b[k]) {    // changed remotely..
-                  if (o[k] !== a[k]) {      // changed locally..
-                      conflicts.push(t('merge_remote_changes.conflict.tags',
-                          { tag: k, local: a[k], remote: b[k], user: user(remote.user) }));
-
-                  } else {                  // unchanged locally, accept remote change..
-                      if (b.hasOwnProperty(k)) {
-                          tags[k] = b[k];
-                      } else {
-                          delete tags[k];
-                      }
-                      changed = true;
-                  }
-              }
-          }
-
-          return (changed && conflicts.length === ccount) ? target.update({tags: tags}) : target;
-      }
-
-
-      //  `graph.base()` is the common ancestor of the two graphs.
-      //  `localGraph` contains user's edits up to saving
-      //  `remoteGraph` contains remote edits to modified nodes
-      //  `graph` must be a descendent of `localGraph` and may include
-      //      some conflict resolution actions performed on it.
-      //
-      //                  --- ... --- `localGraph` -- ... -- `graph`
-      //                 /
-      //  `graph.base()` --- ... --- `remoteGraph`
-      //
-      var action = function(graph) {
-          var updates = { replacements: [], removeIds: [] },
-              base = graph.base().entities[id],
-              local = localGraph.entity(id),
-              remote = remoteGraph.entity(id),
-              target = iD.Entity(local, { version: remote.version });
-
-          // delete/undelete
-          if (!remote.visible) {
-              if (option === 'force_remote') {
-                  return DeleteMultiple([id])(graph);
-
-              } else if (option === 'force_local') {
-                  if (target.type === 'way') {
-                      target = mergeChildren(target, _.uniq(local.nodes), updates, graph);
-                      graph = updateChildren(updates, graph);
-                  }
-                  return graph.replace(target);
-
-              } else {
-                  conflicts.push(t('merge_remote_changes.conflict.deleted', { user: user(remote.user) }));
-                  return graph;  // do nothing
-              }
-          }
-
-          // merge
-          if (target.type === 'node') {
-              target = mergeLocation(remote, target);
-
-          } else if (target.type === 'way') {
-              // pull in any child nodes that may not be present locally..
-              graph.rebase(remoteGraph.childNodes(remote), [graph], false);
-              target = mergeNodes(base, remote, target);
-              target = mergeChildren(target, _.union(local.nodes, remote.nodes), updates, graph);
-
-          } else if (target.type === 'relation') {
-              target = mergeMembers(remote, target);
-          }
-
-          target = mergeTags(base, remote, target);
-
-          if (!conflicts.length) {
-              graph = updateChildren(updates, graph).replace(target);
-          }
-
-          return graph;
-      };
-
-      action.withOption = function(opt) {
-          option = opt;
-          return action;
-      };
-
-      action.conflicts = function() {
-          return conflicts;
-      };
-
-      return action;
-  }
-
-  // https://github.com/openstreetmap/josm/blob/mirror/src/org/openstreetmap/josm/command/MoveCommand.java
-  // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/MoveNodeAction.as
-  function Move(moveIds, tryDelta, projection, cache) {
-      var delta = tryDelta;
-
-      function vecAdd(a, b) { return [a[0] + b[0], a[1] + b[1]]; }
-      function vecSub(a, b) { return [a[0] - b[0], a[1] - b[1]]; }
-
-      function setupCache(graph) {
-          function canMove(nodeId) {
-              var parents = _.map(graph.parentWays(graph.entity(nodeId)), 'id');
-              if (parents.length < 3) return true;
-
-              // Don't move a vertex where >2 ways meet, unless all parentWays are moving too..
-              var parentsMoving = _.all(parents, function(id) { return cache.moving[id]; });
-              if (!parentsMoving) delete cache.moving[nodeId];
-
-              return parentsMoving;
-          }
-
-          function cacheEntities(ids) {
-              _.each(ids, function(id) {
-                  if (cache.moving[id]) return;
-                  cache.moving[id] = true;
-
-                  var entity = graph.hasEntity(id);
-                  if (!entity) return;
-
-                  if (entity.type === 'node') {
-                      cache.nodes.push(id);
-                      cache.startLoc[id] = entity.loc;
-                  } else if (entity.type === 'way') {
-                      cache.ways.push(id);
-                      cacheEntities(entity.nodes);
-                  } else {
-                      cacheEntities(_.map(entity.members, 'id'));
-                  }
-              });
-          }
-
-          function cacheIntersections(ids) {
-              function isEndpoint(way, id) { return !way.isClosed() && !!way.affix(id); }
-
-              _.each(ids, function(id) {
-                  // consider only intersections with 1 moved and 1 unmoved way.
-                  _.each(graph.childNodes(graph.entity(id)), function(node) {
-                      var parents = graph.parentWays(node);
-                      if (parents.length !== 2) return;
-
-                      var moved = graph.entity(id),
-                          unmoved = _.find(parents, function(way) { return !cache.moving[way.id]; });
-                      if (!unmoved) return;
-
-                      // exclude ways that are overly connected..
-                      if (_.intersection(moved.nodes, unmoved.nodes).length > 2) return;
-
-                      if (moved.isArea() || unmoved.isArea()) return;
-
-                      cache.intersection[node.id] = {
-                          nodeId: node.id,
-                          movedId: moved.id,
-                          unmovedId: unmoved.id,
-                          movedIsEP: isEndpoint(moved, node.id),
-                          unmovedIsEP: isEndpoint(unmoved, node.id)
-                      };
-                  });
-              });
-          }
-
-
-          if (!cache) {
-              cache = {};
-          }
-          if (!cache.ok) {
-              cache.moving = {};
-              cache.intersection = {};
-              cache.replacedVertex = {};
-              cache.startLoc = {};
-              cache.nodes = [];
-              cache.ways = [];
-
-              cacheEntities(moveIds);
-              cacheIntersections(cache.ways);
-              cache.nodes = _.filter(cache.nodes, canMove);
-
-              cache.ok = true;
-          }
-      }
-
-
-      // Place a vertex where the moved vertex used to be, to preserve way shape..
-      function replaceMovedVertex(nodeId, wayId, graph, delta) {
-          var way = graph.entity(wayId),
-              moved = graph.entity(nodeId),
-              movedIndex = way.nodes.indexOf(nodeId),
-              len, prevIndex, nextIndex;
-
-          if (way.isClosed()) {
-              len = way.nodes.length - 1;
-              prevIndex = (movedIndex + len - 1) % len;
-              nextIndex = (movedIndex + len + 1) % len;
-          } else {
-              len = way.nodes.length;
-              prevIndex = movedIndex - 1;
-              nextIndex = movedIndex + 1;
-          }
-
-          var prev = graph.hasEntity(way.nodes[prevIndex]),
-              next = graph.hasEntity(way.nodes[nextIndex]);
-
-          // Don't add orig vertex at endpoint..
-          if (!prev || !next) return graph;
-
-          var key = wayId + '_' + nodeId,
-              orig = cache.replacedVertex[key];
-          if (!orig) {
-              orig = iD.Node();
-              cache.replacedVertex[key] = orig;
-              cache.startLoc[orig.id] = cache.startLoc[nodeId];
-          }
-
-          var start, end;
-          if (delta) {
-              start = projection(cache.startLoc[nodeId]);
-              end = projection.invert(vecAdd(start, delta));
-          } else {
-              end = cache.startLoc[nodeId];
-          }
-          orig = orig.move(end);
-
-          var angle = Math.abs(iD.geo.angle(orig, prev, projection) -
-                  iD.geo.angle(orig, next, projection)) * 180 / Math.PI;
-
-          // Don't add orig vertex if it would just make a straight line..
-          if (angle > 175 && angle < 185) return graph;
-
-          // Don't add orig vertex if another point is already nearby (within 10m)
-          if (iD.geo.sphericalDistance(prev.loc, orig.loc) < 10 ||
-              iD.geo.sphericalDistance(orig.loc, next.loc) < 10) return graph;
-
-          // moving forward or backward along way?
-          var p1 = [prev.loc, orig.loc, moved.loc, next.loc].map(projection),
-              p2 = [prev.loc, moved.loc, orig.loc, next.loc].map(projection),
-              d1 = iD.geo.pathLength(p1),
-              d2 = iD.geo.pathLength(p2),
-              insertAt = (d1 < d2) ? movedIndex : nextIndex;
-
-          // moving around closed loop?
-          if (way.isClosed() && insertAt === 0) insertAt = len;
-
-          way = way.addNode(orig.id, insertAt);
-          return graph.replace(orig).replace(way);
-      }
-
-      // Reorder nodes around intersections that have moved..
-      function unZorroIntersection(intersection, graph) {
-          var vertex = graph.entity(intersection.nodeId),
-              way1 = graph.entity(intersection.movedId),
-              way2 = graph.entity(intersection.unmovedId),
-              isEP1 = intersection.movedIsEP,
-              isEP2 = intersection.unmovedIsEP;
-
-          // don't move the vertex if it is the endpoint of both ways.
-          if (isEP1 && isEP2) return graph;
-
-          var nodes1 = _.without(graph.childNodes(way1), vertex),
-              nodes2 = _.without(graph.childNodes(way2), vertex);
-
-          if (way1.isClosed() && way1.first() === vertex.id) nodes1.push(nodes1[0]);
-          if (way2.isClosed() && way2.first() === vertex.id) nodes2.push(nodes2[0]);
-
-          var edge1 = !isEP1 && iD.geo.chooseEdge(nodes1, projection(vertex.loc), projection),
-              edge2 = !isEP2 && iD.geo.chooseEdge(nodes2, projection(vertex.loc), projection),
-              loc;
-
-          // snap vertex to nearest edge (or some point between them)..
-          if (!isEP1 && !isEP2) {
-              var epsilon = 1e-4, maxIter = 10;
-              for (var i = 0; i < maxIter; i++) {
-                  loc = iD.geo.interp(edge1.loc, edge2.loc, 0.5);
-                  edge1 = iD.geo.chooseEdge(nodes1, projection(loc), projection);
-                  edge2 = iD.geo.chooseEdge(nodes2, projection(loc), projection);
-                  if (Math.abs(edge1.distance - edge2.distance) < epsilon) break;
-              }
-          } else if (!isEP1) {
-              loc = edge1.loc;
-          } else {
-              loc = edge2.loc;
-          }
-
-          graph = graph.replace(vertex.move(loc));
-
-          // if zorro happened, reorder nodes..
-          if (!isEP1 && edge1.index !== way1.nodes.indexOf(vertex.id)) {
-              way1 = way1.removeNode(vertex.id).addNode(vertex.id, edge1.index);
-              graph = graph.replace(way1);
-          }
-          if (!isEP2 && edge2.index !== way2.nodes.indexOf(vertex.id)) {
-              way2 = way2.removeNode(vertex.id).addNode(vertex.id, edge2.index);
-              graph = graph.replace(way2);
-          }
-
-          return graph;
-      }
-
-
-      function cleanupIntersections(graph) {
-          _.each(cache.intersection, function(obj) {
-              graph = replaceMovedVertex(obj.nodeId, obj.movedId, graph, delta);
-              graph = replaceMovedVertex(obj.nodeId, obj.unmovedId, graph, null);
-              graph = unZorroIntersection(obj, graph);
-          });
-
-          return graph;
-      }
-
-      // check if moving way endpoint can cross an unmoved way, if so limit delta..
-      function limitDelta(graph) {
-          _.each(cache.intersection, function(obj) {
-              if (!obj.movedIsEP) return;
-
-              var node = graph.entity(obj.nodeId),
-                  start = projection(node.loc),
-                  end = vecAdd(start, delta),
-                  movedNodes = graph.childNodes(graph.entity(obj.movedId)),
-                  movedPath = _.map(_.map(movedNodes, 'loc'),
-                      function(loc) { return vecAdd(projection(loc), delta); }),
-                  unmovedNodes = graph.childNodes(graph.entity(obj.unmovedId)),
-                  unmovedPath = _.map(_.map(unmovedNodes, 'loc'), projection),
-                  hits = iD.geo.pathIntersections(movedPath, unmovedPath);
-
-              for (var i = 0; i < hits.length; i++) {
-                  if (_.isEqual(hits[i], end)) continue;
-                  var edge = iD.geo.chooseEdge(unmovedNodes, end, projection);
-                  delta = vecSub(projection(edge.loc), start);
-              }
-          });
-      }
-
-
-      var action = function(graph) {
-          if (delta[0] === 0 && delta[1] === 0) return graph;
-
-          setupCache(graph);
-
-          if (!_.isEmpty(cache.intersection)) {
-              limitDelta(graph);
-          }
-
-          _.each(cache.nodes, function(id) {
-              var node = graph.entity(id),
-                  start = projection(node.loc),
-                  end = vecAdd(start, delta);
-              graph = graph.replace(node.move(projection.invert(end)));
-          });
-
-          if (!_.isEmpty(cache.intersection)) {
-              graph = cleanupIntersections(graph);
-          }
-
-          return graph;
-      };
-
-      action.disabled = function(graph) {
-          function incompleteRelation(id) {
-              var entity = graph.entity(id);
-              return entity.type === 'relation' && !entity.isComplete(graph);
-          }
-
-          if (_.some(moveIds, incompleteRelation))
-              return 'incomplete_relation';
-      };
-
-      action.delta = function() {
-          return delta;
-      };
-
-      return action;
-  }
-
-  // https://github.com/openstreetmap/josm/blob/mirror/src/org/openstreetmap/josm/command/MoveCommand.java
-  // https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/MoveNodeAction.as
-  function MoveNode(nodeId, loc) {
-      return function(graph) {
-          return graph.replace(graph.entity(nodeId).move(loc));
-      };
-  }
-
-  function Noop() {
-      return function(graph) {
-          return graph;
-      };
-  }
-
-  /*
-   * Based on https://github.com/openstreetmap/potlatch2/blob/master/net/systemeD/potlatch2/tools/Quadrilateralise.as
-   */
-
-  function Orthogonalize(wayId, projection) {
-      var threshold = 12, // degrees within right or straight to alter
-          lowerThreshold = Math.cos((90 - threshold) * Math.PI / 180),
-          upperThreshold = Math.cos(threshold * Math.PI / 180);
-
-      var action = function(graph) {
-          var way = graph.entity(wayId),
-              nodes = graph.childNodes(way),
-              points = _.uniq(nodes).map(function(n) { return projection(n.loc); }),
-              corner = {i: 0, dotp: 1},
-              epsilon = 1e-4,
-              i, j, score, motions;
-
-          if (nodes.length === 4) {
-              for (i = 0; i < 1000; i++) {
-                  motions = points.map(calcMotion);
-                  points[corner.i] = addPoints(points[corner.i],motions[corner.i]);
-                  score = corner.dotp;
-                  if (score < epsilon) {
-                      break;
-                  }
-              }
-
-              graph = graph.replace(graph.entity(nodes[corner.i].id)
-                  .move(projection.invert(points[corner.i])));
-          } else {
-              var best,
-                  originalPoints = _.clone(points);
-              score = Infinity;
-
-              for (i = 0; i < 1000; i++) {
-                  motions = points.map(calcMotion);
-                  for (j = 0; j < motions.length; j++) {
-                      points[j] = addPoints(points[j],motions[j]);
-                  }
-                  var newScore = squareness(points);
-                  if (newScore < score) {
-                      best = _.clone(points);
-                      score = newScore;
-                  }
-                  if (score < epsilon) {
-                      break;
-                  }
-              }
-
-              points = best;
-
-              for (i = 0; i < points.length; i++) {
-                  // only move the points that actually moved
-                  if (originalPoints[i][0] !== points[i][0] || originalPoints[i][1] !== points[i][1]) {
-                      graph = graph.replace(graph.entity(nodes[i].id)
-                          .move(projection.invert(points[i])));
-                  }
-              }
-
-              // remove empty nodes on straight sections
-              for (i = 0; i < points.length; i++) {
-                  var node = nodes[i];
-
-                  if (graph.parentWays(node).length > 1 ||
-                      graph.parentRelations(node).length ||
-                      node.hasInterestingTags()) {
-
-                      continue;
-                  }
-
-                  var dotp = normalizedDotProduct(i, points);
-                  if (dotp < -1 + epsilon) {
-                      graph = DeleteNode(nodes[i].id)(graph);
-                  }
-              }
-          }
-
-          return graph;
-
-          function calcMotion(b, i, array) {
-              var a = array[(i - 1 + array.length) % array.length],
-                  c = array[(i + 1) % array.length],
-                  p = subtractPoints(a, b),
-                  q = subtractPoints(c, b),
-                  scale, dotp;
-
-              scale = 2 * Math.min(iD.geo.euclideanDistance(p, [0, 0]), iD.geo.euclideanDistance(q, [0, 0]));
-              p = normalizePoint(p, 1.0);
-              q = normalizePoint(q, 1.0);
-
-              dotp = filterDotProduct(p[0] * q[0] + p[1] * q[1]);
-
-              // nasty hack to deal with almost-straight segments (angle is closer to 180 than to 90/270).
-              if (array.length > 3) {
-                  if (dotp < -0.707106781186547) {
-                      dotp += 1.0;
-                  }
-              } else if (dotp && Math.abs(dotp) < corner.dotp) {
-                  corner.i = i;
-                  corner.dotp = Math.abs(dotp);
-              }
-
-              return normalizePoint(addPoints(p, q), 0.1 * dotp * scale);
-          }
-      };
-
-      function squareness(points) {
-          return points.reduce(function(sum, val, i, array) {
-              var dotp = normalizedDotProduct(i, array);
-
-              dotp = filterDotProduct(dotp);
-              return sum + 2.0 * Math.min(Math.abs(dotp - 1.0), Math.min(Math.abs(dotp), Math.abs(dotp + 1)));
-          }, 0);
-      }
-
-      function normalizedDotProduct(i, points) {
-          var a = points[(i - 1 + points.length) % points.length],
-              b = points[i],
-              c = points[(i + 1) % points.length],
-              p = subtractPoints(a, b),
-              q = subtractPoints(c, b);
-
-          p = normalizePoint(p, 1.0);
-          q = normalizePoint(q, 1.0);
-
-          return p[0] * q[0] + p[1] * q[1];
-      }
-
-      function subtractPoints(a, b) {
-          return [a[0] - b[0], a[1] - b[1]];
-      }
-
-      function addPoints(a, b) {
-          return [a[0] + b[0], a[1] + b[1]];
-      }
-
-      function normalizePoint(point, scale) {
-          var vector = [0, 0];
-          var length = Math.sqrt(point[0] * point[0] + point[1] * point[1]);
-          if (length !== 0) {
-              vector[0] = point[0] / length;
-              vector[1] = point[1] / length;
-          }
-
-          vector[0] *= scale;
-          vector[1] *= scale;
-
-          return vector;
-      }
-
-      function filterDotProduct(dotp) {
-          if (lowerThreshold > Math.abs(dotp) || Math.abs(dotp) > upperThreshold) {
-              return dotp;
-          }
-
-          return 0;
-      }
-
-      action.disabled = function(graph) {
-          var way = graph.entity(wayId),
-              nodes = graph.childNodes(way),
-              points = _.uniq(nodes).map(function(n) { return projection(n.loc); });
-
-          if (squareness(points)) {
-              return false;
-          }
-
-          return 'not_squarish';
-      };
-
-      return action;
-  }
-
-  // Split a way at the given node.
-  //
-  // Optionally, split only the given ways, if multiple ways share
-  // the given node.
-  //
-  // This is the inverse of `iD.actions.Join`.
-  //
-  // For testing convenience, accepts an ID to assign to the new way.
-  // Normally, this will be undefined and the way will automatically
-  // be assigned a new ID.
-  //
-  // Reference:
-  //   https://github.com/systemed/potlatch2/blob/master/net/systemeD/halcyon/connection/actions/SplitWayAction.as
-  //
-  function Split(nodeId, newWayIds) {
-      var wayIds;
-
-      // if the way is closed, we need to search for a partner node
-      // to split the way at.
-      //
-      // The following looks for a node that is both far away from
-      // the initial node in terms of way segment length and nearby
-      // in terms of beeline-distance. This assures that areas get
-      // split on the most "natural" points (independent of the number
-      // of nodes).
-      // For example: bone-shaped areas get split across their waist
-      // line, circles across the diameter.
-      function splitArea(nodes, idxA, graph) {
-          var lengths = new Array(nodes.length),
-              length,
-              i,
-              best = 0,
-              idxB;
-
-          function wrap(index) {
-              return iD.util.wrap(index, nodes.length);
-          }
-
-          function dist(nA, nB) {
-              return iD.geo.sphericalDistance(graph.entity(nA).loc, graph.entity(nB).loc);
-          }
-
-          // calculate lengths
-          length = 0;
-          for (i = wrap(idxA+1); i !== idxA; i = wrap(i+1)) {
-              length += dist(nodes[i], nodes[wrap(i-1)]);
-              lengths[i] = length;
-          }
-
-          length = 0;
-          for (i = wrap(idxA-1); i !== idxA; i = wrap(i-1)) {
-              length += dist(nodes[i], nodes[wrap(i+1)]);
-              if (length < lengths[i])
-                  lengths[i] = length;
-          }
-
-          // determine best opposite node to split
-          for (i = 0; i < nodes.length; i++) {
-              var cost = lengths[i] / dist(nodes[idxA], nodes[i]);
-              if (cost > best) {
-                  idxB = i;
-                  best = cost;
-              }
-          }
-
-          return idxB;
-      }
-
-      function split(graph, wayA, newWayId) {
-          var wayB = iD.Way({id: newWayId, tags: wayA.tags}),
-              nodesA,
-              nodesB,
-              isArea = wayA.isArea(),
-              isOuter = iD.geo.isSimpleMultipolygonOuterMember(wayA, graph);
-
-          if (wayA.isClosed()) {
-              var nodes = wayA.nodes.slice(0, -1),
-                  idxA = _.indexOf(nodes, nodeId),
-                  idxB = splitArea(nodes, idxA, graph);
-
-              if (idxB < idxA) {
-                  nodesA = nodes.slice(idxA).concat(nodes.slice(0, idxB + 1));
-                  nodesB = nodes.slice(idxB, idxA + 1);
-              } else {
-                  nodesA = nodes.slice(idxA, idxB + 1);
-                  nodesB = nodes.slice(idxB).concat(nodes.slice(0, idxA + 1));
-              }
-          } else {
-              var idx = _.indexOf(wayA.nodes, nodeId, 1);
-              nodesA = wayA.nodes.slice(0, idx + 1);
-              nodesB = wayA.nodes.slice(idx);
-          }
-
-          wayA = wayA.update({nodes: nodesA});
-          wayB = wayB.update({nodes: nodesB});
-
-          graph = graph.replace(wayA);
-          graph = graph.replace(wayB);
-
-          graph.parentRelations(wayA).forEach(function(relation) {
-              if (relation.isRestriction()) {
-                  var via = relation.memberByRole('via');
-                  if (via && wayB.contains(via.id)) {
-                      relation = relation.updateMember({id: wayB.id}, relation.memberById(wayA.id).index);
-                      graph = graph.replace(relation);
-                  }
-              } else {
-                  if (relation === isOuter) {
-                      graph = graph.replace(relation.mergeTags(wayA.tags));
-                      graph = graph.replace(wayA.update({tags: {}}));
-                      graph = graph.replace(wayB.update({tags: {}}));
-                  }
-
-                  var member = {
-                      id: wayB.id,
-                      type: 'way',
-                      role: relation.memberById(wayA.id).role
-                  };
-
-                  graph = AddMember(relation.id, member)(graph);
-              }
-          });
-
-          if (!isOuter && isArea) {
-              var multipolygon = iD.Relation({
-                  tags: _.extend({}, wayA.tags, {type: 'multipolygon'}),
-                  members: [
-                      {id: wayA.id, role: 'outer', type: 'way'},
-                      {id: wayB.id, role: 'outer', type: 'way'}
-                  ]});
-
-              graph = graph.replace(multipolygon);
-              graph = graph.replace(wayA.update({tags: {}}));
-              graph = graph.replace(wayB.update({tags: {}}));
-          }
-
-          return graph;
-      }
-
-      var action = function(graph) {
-          var candidates = action.ways(graph);
-          for (var i = 0; i < candidates.length; i++) {
-              graph = split(graph, candidates[i], newWayIds && newWayIds[i]);
-          }
-          return graph;
-      };
-
-      action.ways = function(graph) {
-          var node = graph.entity(nodeId),
-              parents = graph.parentWays(node),
-              hasLines = _.some(parents, function(parent) { return parent.geometry(graph) === 'line'; });
-
-          return parents.filter(function(parent) {
-              if (wayIds && wayIds.indexOf(parent.id) === -1)
-                  return false;
-
-              if (!wayIds && hasLines && parent.geometry(graph) !== 'line')
-                  return false;
-
-              if (parent.isClosed()) {
-                  return true;
-              }
-
-              for (var i = 1; i < parent.nodes.length - 1; i++) {
-                  if (parent.nodes[i] === nodeId) {
-                      return true;
-                  }
-              }
-
-              return false;
-          });
-      };
-
-      action.disabled = function(graph) {
-          var candidates = action.ways(graph);
-          if (candidates.length === 0 || (wayIds && wayIds.length !== candidates.length))
-              return 'not_eligible';
-      };
-
-      action.limitWays = function(_) {
-          if (!arguments.length) return wayIds;
-          wayIds = _;
-          return action;
-      };
-
-      return action;
-  }
-
-  // Create a restriction relation for `turn`, which must have the following structure:
-  //
-  //     {
-  //         from: { node: <node ID>, way: <way ID> },
-  //         via:  { node: <node ID> },
-  //         to:   { node: <node ID>, way: <way ID> },
-  //         restriction: <'no_right_turn', 'no_left_turn', etc.>
-  //     }
-  //
-  // This specifies a restriction of type `restriction` when traveling from
-  // `from.node` in `from.way` toward `to.node` in `to.way` via `via.node`.
-  // (The action does not check that these entities form a valid intersection.)
-  //
-  // If `restriction` is not provided, it is automatically determined by
-  // iD.geo.inferRestriction.
-  //
-  // If necessary, the `from` and `to` ways are split. In these cases, `from.node`
-  // and `to.node` are used to determine which portion of the split ways become
-  // members of the restriction.
-  //
-  // For testing convenience, accepts an ID to assign to the new relation.
-  // Normally, this will be undefined and the relation will automatically
-  // be assigned a new ID.
-  //
-  function RestrictTurn(turn, projection, restrictionId) {
-      return function(graph) {
-          var from = graph.entity(turn.from.way),
-              via  = graph.entity(turn.via.node),
-              to   = graph.entity(turn.to.way);
-
-          function isClosingNode(way, nodeId) {
-              return nodeId === way.first() && nodeId === way.last();
-          }
-
-          function split(toOrFrom) {
-              var newID = toOrFrom.newID || iD.Way().id;
-              graph = Split(via.id, [newID])
-                  .limitWays([toOrFrom.way])(graph);
-
-              var a = graph.entity(newID),
-                  b = graph.entity(toOrFrom.way);
-
-              if (a.nodes.indexOf(toOrFrom.node) !== -1) {
-                  return [a, b];
-              } else {
-                  return [b, a];
-              }
-          }
-
-          if (!from.affix(via.id) || isClosingNode(from, via.id)) {
-              if (turn.from.node === turn.to.node) {
-                  // U-turn
-                  from = to = split(turn.from)[0];
-              } else if (turn.from.way === turn.to.way) {
-                  // Straight-on or circular
-                  var s = split(turn.from);
-                  from = s[0];
-                  to   = s[1];
-              } else {
-                  // Other
-                  from = split(turn.from)[0];
-              }
-          }
-
-          if (!to.affix(via.id) || isClosingNode(to, via.id)) {
-              to = split(turn.to)[0];
-          }
-
-          return graph.replace(iD.Relation({
-              id: restrictionId,
-              tags: {
-                  type: 'restriction',
-                  restriction: turn.restriction ||
-                      iD.geo.inferRestriction(
-                          graph,
-                          turn.from,
-                          turn.via,
-                          turn.to,
-                          projection)
-              },
-              members: [
-                  {id: from.id, type: 'way',  role: 'from'},
-                  {id: via.id,  type: 'node', role: 'via'},
-                  {id: to.id,   type: 'way',  role: 'to'}
-              ]
-          }));
-      };
-  }
-
-  /*
-    Order the nodes of a way in reverse order and reverse any direction dependent tags
-    other than `oneway`. (We assume that correcting a backwards oneway is the primary
-    reason for reversing a way.)
-
-    The following transforms are performed:
-
-      Keys:
-            *:right=* ⟺ *:left=*
-          *:forward=* ⟺ *:backward=*
-         direction=up ⟺ direction=down
-           incline=up ⟺ incline=down
-              *=right ⟺ *=left
-
-      Relation members:
-         role=forward ⟺ role=backward
-           role=north ⟺ role=south
-            role=east ⟺ role=west
-
-     In addition, numeric-valued `incline` tags are negated.
-
-     The JOSM implementation was used as a guide, but transformations that were of unclear benefit
-     or adjusted tags that don't seem to be used in practice were omitted.
-
-     References:
-        http://wiki.openstreetmap.org/wiki/Forward_%26_backward,_left_%26_right
-        http://wiki.openstreetmap.org/wiki/Key:direction#Steps
-        http://wiki.openstreetmap.org/wiki/Key:incline
-        http://wiki.openstreetmap.org/wiki/Route#Members
-        http://josm.openstreetmap.de/browser/josm/trunk/src/org/openstreetmap/josm/corrector/ReverseWayTagCorrector.java
-   */
-  function Reverse(wayId, options) {
-      var replacements = [
-              [/:right$/, ':left'], [/:left$/, ':right'],
-              [/:forward$/, ':backward'], [/:backward$/, ':forward']
-          ],
-          numeric = /^([+\-]?)(?=[\d.])/,
-          roleReversals = {
-              forward: 'backward',
-              backward: 'forward',
-              north: 'south',
-              south: 'north',
-              east: 'west',
-              west: 'east'
-          };
-
-      function reverseKey(key) {
-          for (var i = 0; i < replacements.length; ++i) {
-              var replacement = replacements[i];
-              if (replacement[0].test(key)) {
-                  return key.replace(replacement[0], replacement[1]);
-              }
-          }
-          return key;
-      }
-
-      function reverseValue(key, value) {
-          if (key === 'incline' && numeric.test(value)) {
-              return value.replace(numeric, function(_, sign) { return sign === '-' ? '' : '-'; });
-          } else if (key === 'incline' || key === 'direction') {
-              return {up: 'down', down: 'up'}[value] || value;
-          } else if (options && options.reverseOneway && key === 'oneway') {
-              return {yes: '-1', '1': '-1', '-1': 'yes'}[value] || value;
-          } else {
-              return {left: 'right', right: 'left'}[value] || value;
-          }
-      }
-
-      return function(graph) {
-          var way = graph.entity(wayId),
-              nodes = way.nodes.slice().reverse(),
-              tags = {}, key, role;
-
-          for (key in way.tags) {
-              tags[reverseKey(key)] = reverseValue(key, way.tags[key]);
-          }
-
-          graph.parentRelations(way).forEach(function(relation) {
-              relation.members.forEach(function(member, index) {
-                  if (member.id === way.id && (role = roleReversals[member.role])) {
-                      relation = relation.updateMember({role: role}, index);
-                      graph = graph.replace(relation);
-                  }
-              });
-          });
-
-          return graph.replace(way.update({nodes: nodes, tags: tags}));
-      };
-  }
-
-  function Revert(id) {
-
-      var action = function(graph) {
-          var entity = graph.hasEntity(id),
-              base = graph.base().entities[id];
-
-          if (entity && !base) {    // entity will be removed..
-              if (entity.type === 'node') {
-                  graph.parentWays(entity)
-                      .forEach(function(parent) {
-                          parent = parent.removeNode(id);
-                          graph = graph.replace(parent);
-
-                          if (parent.isDegenerate()) {
-                              graph = DeleteWay(parent.id)(graph);
-                          }
-                      });
-              }
-
-              graph.parentRelations(entity)
-                  .forEach(function(parent) {
-                      parent = parent.removeMembersWithID(id);
-                      graph = graph.replace(parent);
-
-                      if (parent.isDegenerate()) {
-                          graph = DeleteRelation(parent.id)(graph);
-                      }
-                  });
-          }
-
-          return graph.revert(id);
-      };
-
-      return action;
-  }
-
-  function RotateWay(wayId, pivot, angle, projection) {
-      return function(graph) {
-          return graph.update(function(graph) {
-              var way = graph.entity(wayId);
-
-              _.uniq(way.nodes).forEach(function(id) {
-
-                  var node = graph.entity(id),
-                      point = projection(node.loc),
-                      radial = [0,0];
-
-                  radial[0] = point[0] - pivot[0];
-                  radial[1] = point[1] - pivot[1];
-
-                  point = [
-                      radial[0] * Math.cos(angle) - radial[1] * Math.sin(angle) + pivot[0],
-                      radial[0] * Math.sin(angle) + radial[1] * Math.cos(angle) + pivot[1]
-                  ];
-
-                  graph = graph.replace(node.move(projection.invert(point)));
-
-              });
-
-          });
-      };
-  }
-
-  /*
-   * Based on https://github.com/openstreetmap/potlatch2/net/systemeD/potlatch2/tools/Straighten.as
-   */
-
-  function Straighten(wayId, projection) {
-      function positionAlongWay(n, s, e) {
-          return ((n[0] - s[0]) * (e[0] - s[0]) + (n[1] - s[1]) * (e[1] - s[1]))/
-                  (Math.pow(e[0] - s[0], 2) + Math.pow(e[1] - s[1], 2));
-      }
-
-      var action = function(graph) {
-          var way = graph.entity(wayId),
-              nodes = graph.childNodes(way),
-              points = nodes.map(function(n) { return projection(n.loc); }),
-              startPoint = points[0],
-              endPoint = points[points.length-1],
-              toDelete = [],
-              i;
-
-          for (i = 1; i < points.length-1; i++) {
-              var node = nodes[i],
-                  point = points[i];
-
-              if (graph.parentWays(node).length > 1 ||
-                  graph.parentRelations(node).length ||
-                  node.hasInterestingTags()) {
-
-                  var u = positionAlongWay(point, startPoint, endPoint),
-                      p0 = startPoint[0] + u * (endPoint[0] - startPoint[0]),
-                      p1 = startPoint[1] + u * (endPoint[1] - startPoint[1]);
-
-                  graph = graph.replace(graph.entity(node.id)
-                      .move(projection.invert([p0, p1])));
-              } else {
-                  // safe to delete
-                  if (toDelete.indexOf(node) === -1) {
-                      toDelete.push(node);
-                  }
-              }
-          }
-
-          for (i = 0; i < toDelete.length; i++) {
-              graph = DeleteNode(toDelete[i].id)(graph);
-          }
-
-          return graph;
-      };
-
-      action.disabled = function(graph) {
-          // check way isn't too bendy
-          var way = graph.entity(wayId),
-              nodes = graph.childNodes(way),
-              points = nodes.map(function(n) { return projection(n.loc); }),
-              startPoint = points[0],
-              endPoint = points[points.length-1],
-              threshold = 0.2 * Math.sqrt(Math.pow(startPoint[0] - endPoint[0], 2) + Math.pow(startPoint[1] - endPoint[1], 2)),
-              i;
-
-          if (threshold === 0) {
-              return 'too_bendy';
-          }
-
-          for (i = 1; i < points.length-1; i++) {
-              var point = points[i],
-                  u = positionAlongWay(point, startPoint, endPoint),
-                  p0 = startPoint[0] + u * (endPoint[0] - startPoint[0]),
-                  p1 = startPoint[1] + u * (endPoint[1] - startPoint[1]),
-                  dist = Math.sqrt(Math.pow(p0 - point[0], 2) + Math.pow(p1 - point[1], 2));
-
-              // to bendy if point is off by 20% of total start/end distance in projected space
-              if (isNaN(dist) || dist > threshold) {
-                  return 'too_bendy';
-              }
-          }
-      };
-
-      return action;
-  }
-
-  // Remove the effects of `turn.restriction` on `turn`, which must have the
-  // following structure:
-  //
-  //     {
-  //         from: { node: <node ID>, way: <way ID> },
-  //         via:  { node: <node ID> },
-  //         to:   { node: <node ID>, way: <way ID> },
-  //         restriction: <relation ID>
-  //     }
-  //
-  // In the simple case, `restriction` is a reference to a `no_*` restriction
-  // on the turn itself. In this case, it is simply deleted.
-  //
-  // The more complex case is where `restriction` references an `only_*`
-  // restriction on a different turn in the same intersection. In that case,
-  // that restriction is also deleted, but at the same time restrictions on
-  // the turns other than the first two are created.
-  //
-  function UnrestrictTurn(turn) {
-      return function(graph) {
-          return DeleteRelation(turn.restriction)(graph);
-      };
-  }
-
-  exports.AddEntity = AddEntity;
-  exports.AddMember = AddMember;
-  exports.AddMidpoint = AddMidpoint;
-  exports.AddVertex = AddVertex;
-  exports.ChangeMember = ChangeMember;
-  exports.ChangePreset = ChangePreset;
-  exports.ChangeTags = ChangeTags;
-  exports.Circularize = Circularize;
-  exports.Connect = Connect;
-  exports.CopyEntities = CopyEntities;
-  exports.DeleteMember = DeleteMember;
-  exports.DeleteMultiple = DeleteMultiple;
-  exports.DeleteNode = DeleteNode;
-  exports.DeleteRelation = DeleteRelation;
-  exports.DeleteWay = DeleteWay;
-  exports.DeprecateTags = DeprecateTags;
-  exports.DiscardTags = DiscardTags;
-  exports.Disconnect = Disconnect;
-  exports.Join = Join;
-  exports.Merge = Merge;
-  exports.MergePolygon = MergePolygon;
-  exports.MergeRemoteChanges = MergeRemoteChanges;
-  exports.Move = Move;
-  exports.MoveNode = MoveNode;
-  exports.Noop = Noop;
-  exports.Orthogonalize = Orthogonalize;
-  exports.RestrictTurn = RestrictTurn;
-  exports.Reverse = Reverse;
-  exports.Revert = Revert;
-  exports.RotateWay = RotateWay;
-  exports.Split = Split;
-  exports.Straighten = Straighten;
-  exports.UnrestrictTurn = UnrestrictTurn;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
\ No newline at end of file
diff --git a/js/lib/id/behavior.js b/js/lib/id/behavior.js
deleted file mode 100644
index b81bfc77f..000000000
--- a/js/lib/id/behavior.js
+++ /dev/null
@@ -1,1394 +0,0 @@
-(function (global, factory) {
-   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-   typeof define === 'function' && define.amd ? define(['exports'], factory) :
-   (factory((global.iD = global.iD || {}, global.iD.behavior = global.iD.behavior || {})));
-}(this, function (exports) { 'use strict';
-
-   function Edit(context) {
-       function edit() {
-           context.map()
-               .minzoom(context.minEditableZoom());
-       }
-
-       edit.off = function() {
-           context.map()
-               .minzoom(0);
-       };
-
-       return edit;
-   }
-
-   /*
-      The hover behavior adds the `.hover` class on mouseover to all elements to which
-      the identical datum is bound, and removes it on mouseout.
-
-      The :hover pseudo-class is insufficient for iD's purposes because a datum's visual
-      representation may consist of several elements scattered throughout the DOM hierarchy.
-      Only one of these elements can have the :hover pseudo-class, but all of them will
-      have the .hover class.
-    */
-   function Hover() {
-       var dispatch = d3.dispatch('hover'),
-           selection,
-           altDisables,
-           target;
-
-       function keydown() {
-           if (altDisables && d3.event.keyCode === d3.keybinding.modifierCodes.alt) {
-               dispatch.hover(null);
-               selection.selectAll('.hover')
-                   .classed('hover-suppressed', true)
-                   .classed('hover', false);
-           }
-       }
-
-       function keyup() {
-           if (altDisables && d3.event.keyCode === d3.keybinding.modifierCodes.alt) {
-               dispatch.hover(target ? target.id : null);
-               selection.selectAll('.hover-suppressed')
-                   .classed('hover-suppressed', false)
-                   .classed('hover', true);
-           }
-       }
-
-       var hover = function(__) {
-           selection = __;
-
-           function enter(d) {
-               if (d === target) return;
-
-               target = d;
-
-               selection.selectAll('.hover')
-                   .classed('hover', false);
-               selection.selectAll('.hover-suppressed')
-                   .classed('hover-suppressed', false);
-
-               if (target instanceof iD.Entity) {
-                   var selector = '.' + target.id;
-
-                   if (target.type === 'relation') {
-                       target.members.forEach(function(member) {
-                           selector += ', .' + member.id;
-                       });
-                   }
-
-                   var suppressed = altDisables && d3.event && d3.event.altKey;
-
-                   selection.selectAll(selector)
-                       .classed(suppressed ? 'hover-suppressed' : 'hover', true);
-
-                   dispatch.hover(target.id);
-               } else {
-                   dispatch.hover(null);
-               }
-           }
-
-           var down;
-
-           function mouseover() {
-               if (down) return;
-               var target = d3.event.target;
-               enter(target ? target.__data__ : null);
-           }
-
-           function mouseout() {
-               if (down) return;
-               var target = d3.event.relatedTarget;
-               enter(target ? target.__data__ : null);
-           }
-
-           function mousedown() {
-               down = true;
-               d3.select(window)
-                   .on('mouseup.hover', mouseup);
-           }
-
-           function mouseup() {
-               down = false;
-           }
-
-           selection
-               .on('mouseover.hover', mouseover)
-               .on('mouseout.hover', mouseout)
-               .on('mousedown.hover', mousedown)
-               .on('mouseup.hover', mouseup);
-
-           d3.select(window)
-               .on('keydown.hover', keydown)
-               .on('keyup.hover', keyup);
-       };
-
-       hover.off = function(selection) {
-           selection.selectAll('.hover')
-               .classed('hover', false);
-           selection.selectAll('.hover-suppressed')
-               .classed('hover-suppressed', false);
-
-           selection
-               .on('mouseover.hover', null)
-               .on('mouseout.hover', null)
-               .on('mousedown.hover', null)
-               .on('mouseup.hover', null);
-
-           d3.select(window)
-               .on('keydown.hover', null)
-               .on('keyup.hover', null)
-               .on('mouseup.hover', null);
-       };
-
-       hover.altDisables = function(_) {
-           if (!arguments.length) return altDisables;
-           altDisables = _;
-           return hover;
-       };
-
-       return d3.rebind(hover, dispatch, 'on');
-   }
-
-   function Tail() {
-       var text,
-           container,
-           xmargin = 25,
-           tooltipSize = [0, 0],
-           selectionSize = [0, 0];
-
-       function tail(selection) {
-           if (!text) return;
-
-           d3.select(window)
-               .on('resize.tail', function() { selectionSize = selection.dimensions(); });
-
-           function show() {
-               container.style('display', 'block');
-               tooltipSize = container.dimensions();
-           }
-
-           function mousemove() {
-               if (container.style('display') === 'none') show();
-               var xoffset = ((d3.event.clientX + tooltipSize[0] + xmargin) > selectionSize[0]) ?
-                   -tooltipSize[0] - xmargin : xmargin;
-               container.classed('left', xoffset > 0);
-               iD.util.setTransform(container, d3.event.clientX + xoffset, d3.event.clientY);
-           }
-
-           function mouseleave() {
-               if (d3.event.relatedTarget !== container.node()) {
-                   container.style('display', 'none');
-               }
-           }
-
-           function mouseenter() {
-               if (d3.event.relatedTarget !== container.node()) {
-                   show();
-               }
-           }
-
-           container = d3.select(document.body)
-               .append('div')
-               .style('display', 'none')
-               .attr('class', 'tail tooltip-inner');
-
-           container.append('div')
-               .text(text);
-
-           selection
-               .on('mousemove.tail', mousemove)
-               .on('mouseenter.tail', mouseenter)
-               .on('mouseleave.tail', mouseleave);
-
-           container
-               .on('mousemove.tail', mousemove);
-
-           tooltipSize = container.dimensions();
-           selectionSize = selection.dimensions();
-       }
-
-       tail.off = function(selection) {
-           if (!text) return;
-
-           container
-               .on('mousemove.tail', null)
-               .remove();
-
-           selection
-               .on('mousemove.tail', null)
-               .on('mouseenter.tail', null)
-               .on('mouseleave.tail', null);
-
-           d3.select(window)
-               .on('resize.tail', null);
-       };
-
-       tail.text = function(_) {
-           if (!arguments.length) return text;
-           text = _;
-           return tail;
-       };
-
-       return tail;
-   }
-
-   function Draw(context) {
-       var event = d3.dispatch('move', 'click', 'clickWay',
-               'clickNode', 'undo', 'cancel', 'finish'),
-           keybinding = d3.keybinding('draw'),
-           hover = Hover(context)
-               .altDisables(true)
-               .on('hover', context.ui().sidebar.hover),
-           tail = Tail(),
-           edit = Edit(context),
-           closeTolerance = 4,
-           tolerance = 12,
-           mouseLeave = false,
-           lastMouse = null,
-           cached = Draw;
-
-       function datum() {
-           if (d3.event.altKey) return {};
-
-           if (d3.event.type === 'keydown') {
-               return (lastMouse && lastMouse.target.__data__) || {};
-           } else {
-               return d3.event.target.__data__ || {};
-           }
-       }
-
-       function mousedown() {
-
-           function point() {
-               var p = context.container().node();
-               return touchId !== null ? d3.touches(p).filter(function(p) {
-                   return p.identifier === touchId;
-               })[0] : d3.mouse(p);
-           }
-
-           var element = d3.select(this),
-               touchId = d3.event.touches ? d3.event.changedTouches[0].identifier : null,
-               t1 = +new Date(),
-               p1 = point();
-
-           element.on('mousemove.draw', null);
-
-           d3.select(window).on('mouseup.draw', function() {
-               var t2 = +new Date(),
-                   p2 = point(),
-                   dist = iD.geo.euclideanDistance(p1, p2);
-
-               element.on('mousemove.draw', mousemove);
-               d3.select(window).on('mouseup.draw', null);
-
-               if (dist < closeTolerance || (dist < tolerance && (t2 - t1) < 500)) {
-                   // Prevent a quick second click
-                   d3.select(window).on('click.draw-block', function() {
-                       d3.event.stopPropagation();
-                   }, true);
-
-                   context.map().dblclickEnable(false);
-
-                   window.setTimeout(function() {
-                       context.map().dblclickEnable(true);
-                       d3.select(window).on('click.draw-block', null);
-                   }, 500);
-
-                   click();
-               }
-           });
-       }
-
-       function mousemove() {
-           lastMouse = d3.event;
-           event.move(datum());
-       }
-
-       function mouseenter() {
-           mouseLeave = false;
-       }
-
-       function mouseleave() {
-           mouseLeave = true;
-       }
-
-       function click() {
-           var d = datum();
-           if (d.type === 'way') {
-               var dims = context.map().dimensions(),
-                   mouse = context.mouse(),
-                   pad = 5,
-                   trySnap = mouse[0] > pad && mouse[0] < dims[0] - pad &&
-                       mouse[1] > pad && mouse[1] < dims[1] - pad;
-
-               if (trySnap) {
-                   var choice = iD.geo.chooseEdge(context.childNodes(d), context.mouse(), context.projection),
-                       edge = [d.nodes[choice.index - 1], d.nodes[choice.index]];
-                   event.clickWay(choice.loc, edge);
-               } else {
-                   event.click(context.map().mouseCoordinates());
-               }
-
-           } else if (d.type === 'node') {
-               event.clickNode(d);
-
-           } else {
-               event.click(context.map().mouseCoordinates());
-           }
-       }
-
-       function space() {
-           var currSpace = context.mouse();
-           if (cached.disableSpace && cached.lastSpace) {
-               var dist = iD.geo.euclideanDistance(cached.lastSpace, currSpace);
-               if (dist > tolerance) {
-                   cached.disableSpace = false;
-               }
-           }
-
-           if (cached.disableSpace || mouseLeave || !lastMouse) return;
-
-           // user must move mouse or release space bar to allow another click
-           cached.lastSpace = currSpace;
-           cached.disableSpace = true;
-
-           d3.select(window).on('keyup.space-block', function() {
-               cached.disableSpace = false;
-               d3.select(window).on('keyup.space-block', null);
-           });
-
-           d3.event.preventDefault();
-           click();
-       }
-
-       function backspace() {
-           d3.event.preventDefault();
-           event.undo();
-       }
-
-       function del() {
-           d3.event.preventDefault();
-           event.cancel();
-       }
-
-       function ret() {
-           d3.event.preventDefault();
-           event.finish();
-       }
-
-       function draw(selection) {
-           context.install(hover);
-           context.install(edit);
-
-           if (!context.inIntro() && !cached.usedTails[tail.text()]) {
-               context.install(tail);
-           }
-
-           keybinding
-               .on('⌫', backspace)
-               .on('⌦', del)
-               .on('⎋', ret)
-               .on('↩', ret)
-               .on('space', space)
-               .on('⌥space', space);
-
-           selection
-               .on('mouseenter.draw', mouseenter)
-               .on('mouseleave.draw', mouseleave)
-               .on('mousedown.draw', mousedown)
-               .on('mousemove.draw', mousemove);
-
-           d3.select(document)
-               .call(keybinding);
-
-           return draw;
-       }
-
-       draw.off = function(selection) {
-           context.ui().sidebar.hover.cancel();
-           context.uninstall(hover);
-           context.uninstall(edit);
-
-           if (!context.inIntro() && !cached.usedTails[tail.text()]) {
-               context.uninstall(tail);
-               cached.usedTails[tail.text()] = true;
-           }
-
-           selection
-               .on('mouseenter.draw', null)
-               .on('mouseleave.draw', null)
-               .on('mousedown.draw', null)
-               .on('mousemove.draw', null);
-
-           d3.select(window)
-               .on('mouseup.draw', null);
-               // note: keyup.space-block, click.draw-block should remain
-
-           d3.select(document)
-               .call(keybinding.off);
-       };
-
-       draw.tail = function(_) {
-           tail.text(_);
-           return draw;
-       };
-
-       return d3.rebind(draw, event, 'on');
-   }
-
-   Draw.usedTails = {};
-   Draw.disableSpace = false;
-   Draw.lastSpace = null;
-
-   function AddWay(context) {
-       var event = d3.dispatch('start', 'startFromWay', 'startFromNode'),
-           draw = Draw(context);
-
-       var addWay = function(surface) {
-           draw.on('click', event.start)
-               .on('clickWay', event.startFromWay)
-               .on('clickNode', event.startFromNode)
-               .on('cancel', addWay.cancel)
-               .on('finish', addWay.cancel);
-
-           context.map()
-               .dblclickEnable(false);
-
-           surface.call(draw);
-       };
-
-       addWay.off = function(surface) {
-           surface.call(draw.off);
-       };
-
-       addWay.cancel = function() {
-           window.setTimeout(function() {
-               context.map().dblclickEnable(true);
-           }, 1000);
-
-           context.enter(iD.modes.Browse(context));
-       };
-
-       addWay.tail = function(text) {
-           draw.tail(text);
-           return addWay;
-       };
-
-       return d3.rebind(addWay, event, 'on');
-   }
-
-   function Breathe(){
-       var duration = 800,
-           selector = '.selected.shadow, .selected .shadow',
-           selected = d3.select(null),
-           classed = '',
-           params = {},
-           done;
-
-       function reset(selection) {
-           selection
-               .style('stroke-opacity', null)
-               .style('stroke-width', null)
-               .style('fill-opacity', null)
-               .style('r', null);
-       }
-
-       function setAnimationParams(transition, fromTo) {
-           transition
-               .style('stroke-opacity', function(d) { return params[d.id][fromTo].opacity; })
-               .style('stroke-width', function(d) { return params[d.id][fromTo].width; })
-               .style('fill-opacity', function(d) { return params[d.id][fromTo].opacity; })
-               .style('r', function(d) { return params[d.id][fromTo].width; });
-       }
-
-       function calcAnimationParams(selection) {
-           selection
-               .call(reset)
-               .each(function(d) {
-                   var s = d3.select(this),
-                       tag = s.node().tagName,
-                       p = {'from': {}, 'to': {}},
-                       opacity, width;
-
-                   // determine base opacity and width
-                   if (tag === 'circle') {
-                       opacity = parseFloat(s.style('fill-opacity') || 0.5);
-                       width = parseFloat(s.style('r') || 15.5);
-                   } else {
-                       opacity = parseFloat(s.style('stroke-opacity') || 0.7);
-                       width = parseFloat(s.style('stroke-width') || 10);
-                   }
-
-                   // calculate from/to interpolation params..
-                   p.tag = tag;
-                   p.from.opacity = opacity * 0.6;
-                   p.to.opacity = opacity * 1.25;
-                   p.from.width = width * 0.9;
-                   p.to.width = width * (tag === 'circle' ? 1.5 : 1.25);
-                   params[d.id] = p;
-               });
-       }
-
-       function run(surface, fromTo) {
-           var toFrom = (fromTo === 'from' ? 'to': 'from'),
-               currSelected = surface.selectAll(selector),
-               currClassed = surface.attr('class'),
-               n = 0;
-
-           if (done || currSelected.empty()) {
-               selected.call(reset);
-               return;
-           }
-
-           if (!_.isEqual(currSelected, selected) || currClassed !== classed) {
-               selected.call(reset);
-               classed = currClassed;
-               selected = currSelected.call(calcAnimationParams);
-           }
-
-           selected
-               .transition()
-               .call(setAnimationParams, fromTo)
-               .duration(duration)
-               .each(function() { ++n; })
-               .each('end', function() {
-                   if (!--n) {  // call once
-                       surface.call(run, toFrom);
-                   }
-               });
-       }
-
-       var breathe = function(surface) {
-           done = false;
-           d3.timer(function() {
-               if (done) return true;
-
-               var currSelected = surface.selectAll(selector);
-               if (currSelected.empty()) return false;
-
-               surface.call(run, 'from');
-               return true;
-           }, 200);
-       };
-
-       breathe.off = function() {
-           done = true;
-           d3.timer.flush();
-           selected
-               .transition()
-               .call(reset)
-               .duration(0);
-       };
-
-       return breathe;
-   }
-
-   function Copy(context) {
-       var keybinding = d3.keybinding('copy');
-
-       function groupEntities(ids, graph) {
-           var entities = ids.map(function (id) { return graph.entity(id); });
-           return _.extend({relation: [], way: [], node: []},
-               _.groupBy(entities, function(entity) { return entity.type; }));
-       }
-
-       function getDescendants(id, graph, descendants) {
-           var entity = graph.entity(id),
-               i, children;
-
-           descendants = descendants || {};
-
-           if (entity.type === 'relation') {
-               children = _.map(entity.members, 'id');
-           } else if (entity.type === 'way') {
-               children = entity.nodes;
-           } else {
-               children = [];
-           }
-
-           for (i = 0; i < children.length; i++) {
-               if (!descendants[children[i]]) {
-                   descendants[children[i]] = true;
-                   descendants = getDescendants(children[i], graph, descendants);
-               }
-           }
-
-           return descendants;
-       }
-
-       function doCopy() {
-           d3.event.preventDefault();
-           if (context.inIntro()) return;
-
-           var graph = context.graph(),
-               selected = groupEntities(context.selectedIDs(), graph),
-               canCopy = [],
-               skip = {},
-               i, entity;
-
-           for (i = 0; i < selected.relation.length; i++) {
-               entity = selected.relation[i];
-               if (!skip[entity.id] && entity.isComplete(graph)) {
-                   canCopy.push(entity.id);
-                   skip = getDescendants(entity.id, graph, skip);
-               }
-           }
-           for (i = 0; i < selected.way.length; i++) {
-               entity = selected.way[i];
-               if (!skip[entity.id]) {
-                   canCopy.push(entity.id);
-                   skip = getDescendants(entity.id, graph, skip);
-               }
-           }
-           for (i = 0; i < selected.node.length; i++) {
-               entity = selected.node[i];
-               if (!skip[entity.id]) {
-                   canCopy.push(entity.id);
-               }
-           }
-
-           context.copyIDs(canCopy);
-       }
-
-       function copy() {
-           keybinding.on(iD.ui.cmd('⌘C'), doCopy);
-           d3.select(document).call(keybinding);
-           return copy;
-       }
-
-       copy.off = function() {
-           d3.select(document).call(keybinding.off);
-       };
-
-       return copy;
-   }
-
-   /*
-       `iD.behavior.drag` is like `d3.behavior.drag`, with the following differences:
-
-       * The `origin` function is expected to return an [x, y] tuple rather than an
-         {x, y} object.
-       * The events are `start`, `move`, and `end`.
-         (https://github.com/mbostock/d3/issues/563)
-       * The `start` event is not dispatched until the first cursor movement occurs.
-         (https://github.com/mbostock/d3/pull/368)
-       * The `move` event has a `point` and `delta` [x, y] tuple properties rather
-         than `x`, `y`, `dx`, and `dy` properties.
-       * The `end` event is not dispatched if no movement occurs.
-       * An `off` function is available that unbinds the drag's internal event handlers.
-       * Delegation is supported via the `delegate` function.
-
-    */
-   function drag() {
-       function d3_eventCancel() {
-         d3.event.stopPropagation();
-         d3.event.preventDefault();
-       }
-
-       var event = d3.dispatch('start', 'move', 'end'),
-           origin = null,
-           selector = '',
-           filter = null,
-           event_, target, surface;
-
-       event.of = function(thiz, argumentz) {
-         return function(e1) {
-           var e0 = e1.sourceEvent = d3.event;
-           e1.target = drag;
-           d3.event = e1;
-           try {
-             event[e1.type].apply(thiz, argumentz);
-           } finally {
-             d3.event = e0;
-           }
-         };
-       };
-
-       var d3_event_userSelectProperty = iD.util.prefixCSSProperty('UserSelect'),
-           d3_event_userSelectSuppress = d3_event_userSelectProperty ?
-               function () {
-                   var selection = d3.selection(),
-                       select = selection.style(d3_event_userSelectProperty);
-                   selection.style(d3_event_userSelectProperty, 'none');
-                   return function () {
-                       selection.style(d3_event_userSelectProperty, select);
-                   };
-               } :
-               function (type) {
-                   var w = d3.select(window).on('selectstart.' + type, d3_eventCancel);
-                   return function () {
-                       w.on('selectstart.' + type, null);
-                   };
-               };
-
-       function mousedown() {
-           target = this;
-           event_ = event.of(target, arguments);
-           var eventTarget = d3.event.target,
-               touchId = d3.event.touches ? d3.event.changedTouches[0].identifier : null,
-               offset,
-               origin_ = point(),
-               started = false,
-               selectEnable = d3_event_userSelectSuppress(touchId !== null ? 'drag-' + touchId : 'drag');
-
-           var w = d3.select(window)
-               .on(touchId !== null ? 'touchmove.drag-' + touchId : 'mousemove.drag', dragmove)
-               .on(touchId !== null ? 'touchend.drag-' + touchId : 'mouseup.drag', dragend, true);
-
-           if (origin) {
-               offset = origin.apply(target, arguments);
-               offset = [offset[0] - origin_[0], offset[1] - origin_[1]];
-           } else {
-               offset = [0, 0];
-           }
-
-           if (touchId === null) d3.event.stopPropagation();
-
-           function point() {
-               var p = target.parentNode || surface;
-               return touchId !== null ? d3.touches(p).filter(function(p) {
-                   return p.identifier === touchId;
-               })[0] : d3.mouse(p);
-           }
-
-           function dragmove() {
-
-               var p = point(),
-                   dx = p[0] - origin_[0],
-                   dy = p[1] - origin_[1];
-
-               if (dx === 0 && dy === 0)
-                   return;
-
-               if (!started) {
-                   started = true;
-                   event_({
-                       type: 'start'
-                   });
-               }
-
-               origin_ = p;
-               d3_eventCancel();
-
-               event_({
-                   type: 'move',
-                   point: [p[0] + offset[0],  p[1] + offset[1]],
-                   delta: [dx, dy]
-               });
-           }
-
-           function dragend() {
-               if (started) {
-                   event_({
-                       type: 'end'
-                   });
-
-                   d3_eventCancel();
-                   if (d3.event.target === eventTarget) w.on('click.drag', click, true);
-               }
-
-               w.on(touchId !== null ? 'touchmove.drag-' + touchId : 'mousemove.drag', null)
-                   .on(touchId !== null ? 'touchend.drag-' + touchId : 'mouseup.drag', null);
-               selectEnable();
-           }
-
-           function click() {
-               d3_eventCancel();
-               w.on('click.drag', null);
-           }
-       }
-
-       function drag(selection) {
-           var matchesSelector = iD.util.prefixDOMProperty('matchesSelector'),
-               delegate = mousedown;
-
-           if (selector) {
-               delegate = function() {
-                   var root = this,
-                       target = d3.event.target;
-                   for (; target && target !== root; target = target.parentNode) {
-                       if (target[matchesSelector](selector) &&
-                               (!filter || filter(target.__data__))) {
-                           return mousedown.call(target, target.__data__);
-                       }
-                   }
-               };
-           }
-
-           selection.on('mousedown.drag' + selector, delegate)
-               .on('touchstart.drag' + selector, delegate);
-       }
-
-       drag.off = function(selection) {
-           selection.on('mousedown.drag' + selector, null)
-               .on('touchstart.drag' + selector, null);
-       };
-
-       drag.delegate = function(_) {
-           if (!arguments.length) return selector;
-           selector = _;
-           return drag;
-       };
-
-       drag.filter = function(_) {
-           if (!arguments.length) return origin;
-           filter = _;
-           return drag;
-       };
-
-       drag.origin = function (_) {
-           if (!arguments.length) return origin;
-           origin = _;
-           return drag;
-       };
-
-       drag.cancel = function() {
-           d3.select(window)
-               .on('mousemove.drag', null)
-               .on('mouseup.drag', null);
-           return drag;
-       };
-
-       drag.target = function() {
-           if (!arguments.length) return target;
-           target = arguments[0];
-           event_ = event.of(target, Array.prototype.slice.call(arguments, 1));
-           return drag;
-       };
-
-       drag.surface = function() {
-           if (!arguments.length) return surface;
-           surface = arguments[0];
-           return drag;
-       };
-
-       return d3.rebind(drag, event, 'on');
-   }
-
-   function DrawWay(context, wayId, index, mode, baseGraph) {
-       var way = context.entity(wayId),
-           isArea = context.geometry(wayId) === 'area',
-           finished = false,
-           annotation = t((way.isDegenerate() ?
-               'operations.start.annotation.' :
-               'operations.continue.annotation.') + context.geometry(wayId)),
-           draw = Draw(context);
-
-       var startIndex = typeof index === 'undefined' ? way.nodes.length - 1 : 0,
-           start = iD.Node({loc: context.graph().entity(way.nodes[startIndex]).loc}),
-           end = iD.Node({loc: context.map().mouseCoordinates()}),
-           segment = iD.Way({
-               nodes: typeof index === 'undefined' ? [start.id, end.id] : [end.id, start.id],
-               tags: _.clone(way.tags)
-           });
-
-       var f = context[way.isDegenerate() ? 'replace' : 'perform'];
-       if (isArea) {
-           f(iD.actions.AddEntity(end),
-               iD.actions.AddVertex(wayId, end.id, index));
-       } else {
-           f(iD.actions.AddEntity(start),
-               iD.actions.AddEntity(end),
-               iD.actions.AddEntity(segment));
-       }
-
-       function move(datum) {
-           var loc;
-
-           if (datum.type === 'node' && datum.id !== end.id) {
-               loc = datum.loc;
-
-           } else if (datum.type === 'way' && datum.id !== segment.id) {
-               var dims = context.map().dimensions(),
-                   mouse = context.mouse(),
-                   pad = 5,
-                   trySnap = mouse[0] > pad && mouse[0] < dims[0] - pad &&
-                       mouse[1] > pad && mouse[1] < dims[1] - pad;
-
-               if (trySnap) {
-                   loc = iD.geo.chooseEdge(context.childNodes(datum), context.mouse(), context.projection).loc;
-               }
-           }
-
-           if (!loc) {
-               loc = context.map().mouseCoordinates();
-           }
-
-           context.replace(iD.actions.MoveNode(end.id, loc));
-       }
-
-       function undone() {
-           finished = true;
-           context.enter(iD.modes.Browse(context));
-       }
-
-       function setActiveElements() {
-           var active = isArea ? [wayId, end.id] : [segment.id, start.id, end.id];
-           context.surface().selectAll(iD.util.entitySelector(active))
-               .classed('active', true);
-       }
-
-       var drawWay = function(surface) {
-           draw.on('move', move)
-               .on('click', drawWay.add)
-               .on('clickWay', drawWay.addWay)
-               .on('clickNode', drawWay.addNode)
-               .on('undo', context.undo)
-               .on('cancel', drawWay.cancel)
-               .on('finish', drawWay.finish);
-
-           context.map()
-               .dblclickEnable(false)
-               .on('drawn.draw', setActiveElements);
-
-           setActiveElements();
-
-           surface.call(draw);
-
-           context.history()
-               .on('undone.draw', undone);
-       };
-
-       drawWay.off = function(surface) {
-           if (!finished)
-               context.pop();
-
-           context.map()
-               .on('drawn.draw', null);
-
-           surface.call(draw.off)
-               .selectAll('.active')
-               .classed('active', false);
-
-           context.history()
-               .on('undone.draw', null);
-       };
-
-       function ReplaceTemporaryNode(newNode) {
-           return function(graph) {
-               if (isArea) {
-                   return graph
-                       .replace(way.addNode(newNode.id, index))
-                       .remove(end);
-
-               } else {
-                   return graph
-                       .replace(graph.entity(wayId).addNode(newNode.id, index))
-                       .remove(end)
-                       .remove(segment)
-                       .remove(start);
-               }
-           };
-       }
-
-       // Accept the current position of the temporary node and continue drawing.
-       drawWay.add = function(loc) {
-
-           // prevent duplicate nodes
-           var last = context.hasEntity(way.nodes[way.nodes.length - (isArea ? 2 : 1)]);
-           if (last && last.loc[0] === loc[0] && last.loc[1] === loc[1]) return;
-
-           var newNode = iD.Node({loc: loc});
-
-           context.replace(
-               iD.actions.AddEntity(newNode),
-               ReplaceTemporaryNode(newNode),
-               annotation);
-
-           finished = true;
-           context.enter(mode);
-       };
-
-       // Connect the way to an existing way.
-       drawWay.addWay = function(loc, edge) {
-           var previousEdge = startIndex ?
-               [way.nodes[startIndex], way.nodes[startIndex - 1]] :
-               [way.nodes[0], way.nodes[1]];
-
-           // Avoid creating duplicate segments
-           if (!isArea && iD.geo.edgeEqual(edge, previousEdge))
-               return;
-
-           var newNode = iD.Node({ loc: loc });
-
-           context.perform(
-               iD.actions.AddMidpoint({ loc: loc, edge: edge}, newNode),
-               ReplaceTemporaryNode(newNode),
-               annotation);
-
-           finished = true;
-           context.enter(mode);
-       };
-
-       // Connect the way to an existing node and continue drawing.
-       drawWay.addNode = function(node) {
-
-           // Avoid creating duplicate segments
-           if (way.areAdjacent(node.id, way.nodes[way.nodes.length - 1])) return;
-
-           context.perform(
-               ReplaceTemporaryNode(node),
-               annotation);
-
-           finished = true;
-           context.enter(mode);
-       };
-
-       // Finish the draw operation, removing the temporary node. If the way has enough
-       // nodes to be valid, it's selected. Otherwise, return to browse mode.
-       drawWay.finish = function() {
-           context.pop();
-           finished = true;
-
-           window.setTimeout(function() {
-               context.map().dblclickEnable(true);
-           }, 1000);
-
-           if (context.hasEntity(wayId)) {
-               context.enter(
-                   iD.modes.Select(context, [wayId])
-                       .suppressMenu(true)
-                       .newFeature(true));
-           } else {
-               context.enter(iD.modes.Browse(context));
-           }
-       };
-
-       // Cancel the draw operation and return to browse, deleting everything drawn.
-       drawWay.cancel = function() {
-           context.perform(
-               d3.functor(baseGraph),
-               t('operations.cancel_draw.annotation'));
-
-           window.setTimeout(function() {
-               context.map().dblclickEnable(true);
-           }, 1000);
-
-           finished = true;
-           context.enter(iD.modes.Browse(context));
-       };
-
-       drawWay.tail = function(text) {
-           draw.tail(text);
-           return drawWay;
-       };
-
-       return drawWay;
-   }
-
-   function Hash(context) {
-       var s0 = null, // cached location.hash
-           lat = 90 - 1e-8; // allowable latitude range
-
-       var parser = function(map, s) {
-           var q = iD.util.stringQs(s);
-           var args = (q.map || '').split('/').map(Number);
-           if (args.length < 3 || args.some(isNaN)) {
-               return true; // replace bogus hash
-           } else if (s !== formatter(map).slice(1)) {
-               map.centerZoom([args[1],
-                   Math.min(lat, Math.max(-lat, args[2]))], args[0]);
-           }
-       };
-
-       var formatter = function(map) {
-           var mode = context.mode(),
-               center = map.center(),
-               zoom = map.zoom(),
-               precision = Math.max(0, Math.ceil(Math.log(zoom) / Math.LN2)),
-               q = _.omit(iD.util.stringQs(location.hash.substring(1)), 'comment'),
-               newParams = {};
-
-           if (mode && mode.id === 'browse') {
-               delete q.id;
-           } else {
-               var selected = context.selectedIDs().filter(function(id) {
-                   return !context.entity(id).isNew();
-               });
-               if (selected.length) {
-                   newParams.id = selected.join(',');
-               }
-           }
-
-           newParams.map = zoom.toFixed(2) +
-                   '/' + center[0].toFixed(precision) +
-                   '/' + center[1].toFixed(precision);
-
-           return '#' + iD.util.qsString(_.assign(q, newParams), true);
-       };
-
-       function update() {
-           if (context.inIntro()) return;
-           var s1 = formatter(context.map());
-           if (s0 !== s1) location.replace(s0 = s1); // don't recenter the map!
-       }
-
-       var throttledUpdate = _.throttle(update, 500);
-
-       function hashchange() {
-           if (location.hash === s0) return; // ignore spurious hashchange events
-           if (parser(context.map(), (s0 = location.hash).substring(1))) {
-               update(); // replace bogus hash
-           }
-       }
-
-       function hash() {
-           context.map()
-               .on('move.hash', throttledUpdate);
-
-           context
-               .on('enter.hash', throttledUpdate);
-
-           d3.select(window)
-               .on('hashchange.hash', hashchange);
-
-           if (location.hash) {
-               var q = iD.util.stringQs(location.hash.substring(1));
-               if (q.id) context.zoomToEntity(q.id.split(',')[0], !q.map);
-               if (q.comment) context.storage('comment', q.comment);
-               hashchange();
-               if (q.map) hash.hadHash = true;
-           }
-       }
-
-       hash.off = function() {
-           throttledUpdate.cancel();
-
-           context.map()
-               .on('move.hash', null);
-
-           context
-               .on('enter.hash', null);
-
-           d3.select(window)
-               .on('hashchange.hash', null);
-
-           location.hash = '';
-       };
-
-       return hash;
-   }
-
-   function Lasso(context) {
-
-       var behavior = function(selection) {
-           var lasso;
-
-           function mousedown() {
-               var button = 0;  // left
-               if (d3.event.button === button && d3.event.shiftKey === true) {
-                   lasso = null;
-
-                   selection
-                       .on('mousemove.lasso', mousemove)
-                       .on('mouseup.lasso', mouseup);
-
-                   d3.event.stopPropagation();
-               }
-           }
-
-           function mousemove() {
-               if (!lasso) {
-                   lasso = iD.ui.Lasso(context);
-                   context.surface().call(lasso);
-               }
-
-               lasso.p(context.mouse());
-           }
-
-           function normalize(a, b) {
-               return [
-                   [Math.min(a[0], b[0]), Math.min(a[1], b[1])],
-                   [Math.max(a[0], b[0]), Math.max(a[1], b[1])]];
-           }
-
-           function lassoed() {
-               if (!lasso) return [];
-
-               var graph = context.graph(),
-                   bounds = lasso.extent().map(context.projection.invert),
-                   extent = iD.geo.Extent(normalize(bounds[0], bounds[1]));
-
-               return _.map(context.intersects(extent).filter(function(entity) {
-                   return entity.type === 'node' &&
-                       iD.geo.pointInPolygon(context.projection(entity.loc), lasso.coordinates) &&
-                       !context.features().isHidden(entity, graph, entity.geometry(graph));
-               }), 'id');
-           }
-
-           function mouseup() {
-               selection
-                   .on('mousemove.lasso', null)
-                   .on('mouseup.lasso', null);
-
-               if (!lasso) return;
-
-               var ids = lassoed();
-               lasso.close();
-
-               if (ids.length) {
-                   context.enter(iD.modes.Select(context, ids));
-               }
-           }
-
-           selection
-               .on('mousedown.lasso', mousedown);
-       };
-
-       behavior.off = function(selection) {
-           selection.on('mousedown.lasso', null);
-       };
-
-       return behavior;
-   }
-
-   function Paste(context) {
-       var keybinding = d3.keybinding('paste');
-
-       function omitTag(v, k) {
-           return (
-               k === 'phone' ||
-               k === 'fax' ||
-               k === 'email' ||
-               k === 'website' ||
-               k === 'url' ||
-               k === 'note' ||
-               k === 'description' ||
-               k.indexOf('name') !== -1 ||
-               k.indexOf('wiki') === 0 ||
-               k.indexOf('addr:') === 0 ||
-               k.indexOf('contact:') === 0
-           );
-       }
-
-       function doPaste() {
-           d3.event.preventDefault();
-           if (context.inIntro()) return;
-
-           var baseGraph = context.graph(),
-               mouse = context.mouse(),
-               projection = context.projection,
-               viewport = iD.geo.Extent(projection.clipExtent()).polygon();
-
-           if (!iD.geo.pointInPolygon(mouse, viewport)) return;
-
-           var extent = iD.geo.Extent(),
-               oldIDs = context.copyIDs(),
-               oldGraph = context.copyGraph(),
-               newIDs = [];
-
-           if (!oldIDs.length) return;
-
-           var action = iD.actions.CopyEntities(oldIDs, oldGraph);
-           context.perform(action);
-
-           var copies = action.copies();
-           for (var id in copies) {
-               var oldEntity = oldGraph.entity(id),
-                   newEntity = copies[id];
-
-               extent._extend(oldEntity.extent(oldGraph));
-               newIDs.push(newEntity.id);
-               context.perform(iD.actions.ChangeTags(newEntity.id, _.omit(newEntity.tags, omitTag)));
-           }
-
-           // Put pasted objects where mouse pointer is..
-           var center = projection(extent.center()),
-               delta = [ mouse[0] - center[0], mouse[1] - center[1] ];
-
-           context.perform(iD.actions.Move(newIDs, delta, projection));
-           context.enter(iD.modes.Move(context, newIDs, baseGraph));
-       }
-
-       function paste() {
-           keybinding.on(iD.ui.cmd('⌘V'), doPaste);
-           d3.select(document).call(keybinding);
-           return paste;
-       }
-
-       paste.off = function() {
-           d3.select(document).call(keybinding.off);
-       };
-
-       return paste;
-   }
-
-   function Select(context) {
-       function keydown() {
-           if (d3.event && d3.event.shiftKey) {
-               context.surface()
-                   .classed('behavior-multiselect', true);
-           }
-       }
-
-       function keyup() {
-           if (!d3.event || !d3.event.shiftKey) {
-               context.surface()
-                   .classed('behavior-multiselect', false);
-           }
-       }
-
-       function click() {
-           var datum = d3.event.target.__data__,
-               lasso = d3.select('#surface .lasso').node(),
-               mode = context.mode();
-
-           if (!(datum instanceof iD.Entity)) {
-               if (!d3.event.shiftKey && !lasso && mode.id !== 'browse')
-                   context.enter(iD.modes.Browse(context));
-
-           } else if (!d3.event.shiftKey && !lasso) {
-               // Avoid re-entering Select mode with same entity.
-               if (context.selectedIDs().length !== 1 || context.selectedIDs()[0] !== datum.id) {
-                   context.enter(iD.modes.Select(context, [datum.id]));
-               } else {
-                   mode.suppressMenu(false).reselect();
-               }
-           } else if (context.selectedIDs().indexOf(datum.id) >= 0) {
-               var selectedIDs = _.without(context.selectedIDs(), datum.id);
-               context.enter(selectedIDs.length ?
-                   iD.modes.Select(context, selectedIDs) :
-                   iD.modes.Browse(context));
-
-           } else {
-               context.enter(iD.modes.Select(context, context.selectedIDs().concat([datum.id])));
-           }
-       }
-
-       var behavior = function(selection) {
-           d3.select(window)
-               .on('keydown.select', keydown)
-               .on('keyup.select', keyup);
-
-           selection.on('click.select', click);
-
-           keydown();
-       };
-
-       behavior.off = function(selection) {
-           d3.select(window)
-               .on('keydown.select', null)
-               .on('keyup.select', null);
-
-           selection.on('click.select', null);
-
-           keyup();
-       };
-
-       return behavior;
-   }
-
-   exports.AddWay = AddWay;
-   exports.Breathe = Breathe;
-   exports.Copy = Copy;
-   exports.drag = drag;
-   exports.DrawWay = DrawWay;
-   exports.Draw = Draw;
-   exports.Edit = Edit;
-   exports.Hash = Hash;
-   exports.Hover = Hover;
-   exports.Lasso = Lasso;
-   exports.Paste = Paste;
-   exports.Select = Select;
-   exports.Tail = Tail;
-
-   Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
\ No newline at end of file
diff --git a/js/lib/id/core.js b/js/lib/id/core.js
deleted file mode 100644
index 4552438f1..000000000
--- a/js/lib/id/core.js
+++ /dev/null
@@ -1,2259 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (factory((global.iD = global.iD || {})));
-}(this, function (exports) { 'use strict';
-
-    function interestingTag(key) {
-        return key !== 'attribution' &&
-            key !== 'created_by' &&
-            key !== 'source' &&
-            key !== 'odbl' &&
-            key.indexOf('tiger:') !== 0;
-
-    }
-
-    var oneWayTags = {
-        'aerialway': {
-            'chair_lift': true,
-            'mixed_lift': true,
-            't-bar': true,
-            'j-bar': true,
-            'platter': true,
-            'rope_tow': true,
-            'magic_carpet': true,
-            'yes': true
-        },
-        'highway': {
-            'motorway': true,
-            'motorway_link': true
-        },
-        'junction': {
-            'roundabout': true
-        },
-        'man_made': {
-            'piste:halfpipe': true
-        },
-        'piste:type': {
-            'downhill': true,
-            'sled': true,
-            'yes': true
-        },
-        'waterway': {
-            'river': true,
-            'stream': true
-        }
-    };
-
-    var pavedTags = {
-        'surface': {
-            'paved': true,
-            'asphalt': true,
-            'concrete': true
-        },
-        'tracktype': {
-            'grade1': true
-        }
-    };
-
-    function Entity(attrs) {
-        // For prototypal inheritance.
-        if (this instanceof Entity) return;
-
-        // Create the appropriate subtype.
-        if (attrs && attrs.type) {
-            return Entity[attrs.type].apply(this, arguments);
-        } else if (attrs && attrs.id) {
-            return Entity[Entity.id.type(attrs.id)].apply(this, arguments);
-        }
-
-        // Initialize a generic Entity (used only in tests).
-        return (new Entity()).initialize(arguments);
-    }
-
-    Entity.id = function(type) {
-        return Entity.id.fromOSM(type, Entity.id.next[type]--);
-    };
-
-    Entity.id.next = {node: -1, way: -1, relation: -1};
-
-    Entity.id.fromOSM = function(type, id) {
-        return type[0] + id;
-    };
-
-    Entity.id.toOSM = function(id) {
-        return id.slice(1);
-    };
-
-    Entity.id.type = function(id) {
-        return {'n': 'node', 'w': 'way', 'r': 'relation'}[id[0]];
-    };
-
-    // A function suitable for use as the second argument to d3.selection#data().
-    Entity.key = function(entity) {
-        return entity.id + 'v' + (entity.v || 0);
-    };
-
-    Entity.prototype = {
-        tags: {},
-
-        initialize: function(sources) {
-            for (var i = 0; i < sources.length; ++i) {
-                var source = sources[i];
-                for (var prop in source) {
-                    if (Object.prototype.hasOwnProperty.call(source, prop)) {
-                        if (source[prop] === undefined) {
-                            delete this[prop];
-                        } else {
-                            this[prop] = source[prop];
-                        }
-                    }
-                }
-            }
-
-            if (!this.id && this.type) {
-                this.id = Entity.id(this.type);
-            }
-            if (!this.hasOwnProperty('visible')) {
-                this.visible = true;
-            }
-
-            if (iD.debug) {
-                Object.freeze(this);
-                Object.freeze(this.tags);
-
-                if (this.loc) Object.freeze(this.loc);
-                if (this.nodes) Object.freeze(this.nodes);
-                if (this.members) Object.freeze(this.members);
-            }
-
-            return this;
-        },
-
-        copy: function(resolver, copies) {
-            if (copies[this.id])
-                return copies[this.id];
-
-            var copy = Entity(this, {id: undefined, user: undefined, version: undefined});
-            copies[this.id] = copy;
-
-            return copy;
-        },
-
-        osmId: function() {
-            return Entity.id.toOSM(this.id);
-        },
-
-        isNew: function() {
-            return this.osmId() < 0;
-        },
-
-        update: function(attrs) {
-            return Entity(this, attrs, {v: 1 + (this.v || 0)});
-        },
-
-        mergeTags: function(tags) {
-            var merged = _.clone(this.tags), changed = false;
-            for (var k in tags) {
-                var t1 = merged[k],
-                    t2 = tags[k];
-                if (!t1) {
-                    changed = true;
-                    merged[k] = t2;
-                } else if (t1 !== t2) {
-                    changed = true;
-                    merged[k] = _.union(t1.split(/;\s*/), t2.split(/;\s*/)).join(';');
-                }
-            }
-            return changed ? this.update({tags: merged}) : this;
-        },
-
-        intersects: function(extent, resolver) {
-            return this.extent(resolver).intersects(extent);
-        },
-
-        isUsed: function(resolver) {
-            return _.without(Object.keys(this.tags), 'area').length > 0 ||
-                resolver.parentRelations(this).length > 0;
-        },
-
-        hasInterestingTags: function() {
-            return _.keys(this.tags).some(interestingTag);
-        },
-
-        isHighwayIntersection: function() {
-            return false;
-        },
-
-        deprecatedTags: function() {
-            var tags = _.toPairs(this.tags);
-            var deprecated = {};
-
-            iD.data.deprecated.forEach(function(d) {
-                var match = _.toPairs(d.old)[0];
-                tags.forEach(function(t) {
-                    if (t[0] === match[0] &&
-                        (t[1] === match[1] || match[1] === '*')) {
-                        deprecated[t[0]] = t[1];
-                    }
-                });
-            });
-
-            return deprecated;
-        }
-    };
-
-    function Way() {
-        if (!(this instanceof Way)) {
-            return (new Way()).initialize(arguments);
-        } else if (arguments.length) {
-            this.initialize(arguments);
-        }
-    }
-
-    Entity.way = Way;
-
-    Way.prototype = Object.create(Entity.prototype);
-
-    _.extend(Way.prototype, {
-        type: 'way',
-        nodes: [],
-
-        copy: function(resolver, copies) {
-            if (copies[this.id])
-                return copies[this.id];
-
-            var copy = Entity.prototype.copy.call(this, resolver, copies);
-
-            var nodes = this.nodes.map(function(id) {
-                return resolver.entity(id).copy(resolver, copies).id;
-            });
-
-            copy = copy.update({nodes: nodes});
-            copies[this.id] = copy;
-
-            return copy;
-        },
-
-        extent: function(resolver) {
-            return resolver.transient(this, 'extent', function() {
-                var extent = iD.geo.Extent();
-                for (var i = 0; i < this.nodes.length; i++) {
-                    var node = resolver.hasEntity(this.nodes[i]);
-                    if (node) {
-                        extent._extend(node.extent());
-                    }
-                }
-                return extent;
-            });
-        },
-
-        first: function() {
-            return this.nodes[0];
-        },
-
-        last: function() {
-            return this.nodes[this.nodes.length - 1];
-        },
-
-        contains: function(node) {
-            return this.nodes.indexOf(node) >= 0;
-        },
-
-        affix: function(node) {
-            if (this.nodes[0] === node) return 'prefix';
-            if (this.nodes[this.nodes.length - 1] === node) return 'suffix';
-        },
-
-        layer: function() {
-            // explicit layer tag, clamp between -10, 10..
-            if (this.tags.layer !== undefined) {
-                return Math.max(-10, Math.min(+(this.tags.layer), 10));
-            }
-
-            // implied layer tag..
-            if (this.tags.location === 'overground') return 1;
-            if (this.tags.location === 'underground') return -1;
-            if (this.tags.location === 'underwater') return -10;
-
-            if (this.tags.power === 'line') return 10;
-            if (this.tags.power === 'minor_line') return 10;
-            if (this.tags.aerialway) return 10;
-            if (this.tags.bridge) return 1;
-            if (this.tags.cutting) return -1;
-            if (this.tags.tunnel) return -1;
-            if (this.tags.waterway) return -1;
-            if (this.tags.man_made === 'pipeline') return -10;
-            if (this.tags.boundary) return -10;
-            return 0;
-        },
-
-        isOneWay: function() {
-            // explicit oneway tag..
-            if (['yes', '1', '-1'].indexOf(this.tags.oneway) !== -1) { return true; }
-            if (['no', '0'].indexOf(this.tags.oneway) !== -1) { return false; }
-
-            // implied oneway tag..
-            for (var key in this.tags) {
-                if (key in oneWayTags && (this.tags[key] in oneWayTags[key]))
-                    return true;
-            }
-            return false;
-        },
-
-        isClosed: function() {
-            return this.nodes.length > 0 && this.first() === this.last();
-        },
-
-        isConvex: function(resolver) {
-            if (!this.isClosed() || this.isDegenerate()) return null;
-
-            var nodes = _.uniq(resolver.childNodes(this)),
-                coords = _.map(nodes, 'loc'),
-                curr = 0, prev = 0;
-
-            for (var i = 0; i < coords.length; i++) {
-                var o = coords[(i+1) % coords.length],
-                    a = coords[i],
-                    b = coords[(i+2) % coords.length],
-                    res = iD.geo.cross(o, a, b);
-
-                curr = (res > 0) ? 1 : (res < 0) ? -1 : 0;
-                if (curr === 0) {
-                    continue;
-                } else if (prev && curr !== prev) {
-                    return false;
-                }
-                prev = curr;
-            }
-            return true;
-        },
-
-        isArea: function() {
-            if (this.tags.area === 'yes')
-                return true;
-            if (!this.isClosed() || this.tags.area === 'no')
-                return false;
-            for (var key in this.tags)
-                if (key in iD.areaKeys && !(this.tags[key] in iD.areaKeys[key]))
-                    return true;
-            return false;
-        },
-
-        isDegenerate: function() {
-            return _.uniq(this.nodes).length < (this.isArea() ? 3 : 2);
-        },
-
-        areAdjacent: function(n1, n2) {
-            for (var i = 0; i < this.nodes.length; i++) {
-                if (this.nodes[i] === n1) {
-                    if (this.nodes[i - 1] === n2) return true;
-                    if (this.nodes[i + 1] === n2) return true;
-                }
-            }
-            return false;
-        },
-
-        geometry: function(graph) {
-            return graph.transient(this, 'geometry', function() {
-                return this.isArea() ? 'area' : 'line';
-            });
-        },
-
-        addNode: function(id, index) {
-            var nodes = this.nodes.slice();
-            nodes.splice(index === undefined ? nodes.length : index, 0, id);
-            return this.update({nodes: nodes});
-        },
-
-        updateNode: function(id, index) {
-            var nodes = this.nodes.slice();
-            nodes.splice(index, 1, id);
-            return this.update({nodes: nodes});
-        },
-
-        replaceNode: function(needle, replacement) {
-            if (this.nodes.indexOf(needle) < 0)
-                return this;
-
-            var nodes = this.nodes.slice();
-            for (var i = 0; i < nodes.length; i++) {
-                if (nodes[i] === needle) {
-                    nodes[i] = replacement;
-                }
-            }
-            return this.update({nodes: nodes});
-        },
-
-        removeNode: function(id) {
-            var nodes = [];
-
-            for (var i = 0; i < this.nodes.length; i++) {
-                var node = this.nodes[i];
-                if (node !== id && nodes[nodes.length - 1] !== node) {
-                    nodes.push(node);
-                }
-            }
-
-            // Preserve circularity
-            if (this.nodes.length > 1 && this.first() === id && this.last() === id && nodes[nodes.length - 1] !== nodes[0]) {
-                nodes.push(nodes[0]);
-            }
-
-            return this.update({nodes: nodes});
-        },
-
-        asJXON: function(changeset_id) {
-            var r = {
-                way: {
-                    '@id': this.osmId(),
-                    '@version': this.version || 0,
-                    nd: _.map(this.nodes, function(id) {
-                        return { keyAttributes: { ref: Entity.id.toOSM(id) } };
-                    }),
-                    tag: _.map(this.tags, function(v, k) {
-                        return { keyAttributes: { k: k, v: v } };
-                    })
-                }
-            };
-            if (changeset_id) r.way['@changeset'] = changeset_id;
-            return r;
-        },
-
-        asGeoJSON: function(resolver) {
-            return resolver.transient(this, 'GeoJSON', function() {
-                var coordinates = _.map(resolver.childNodes(this), 'loc');
-                if (this.isArea() && this.isClosed()) {
-                    return {
-                        type: 'Polygon',
-                        coordinates: [coordinates]
-                    };
-                } else {
-                    return {
-                        type: 'LineString',
-                        coordinates: coordinates
-                    };
-                }
-            });
-        },
-
-        area: function(resolver) {
-            return resolver.transient(this, 'area', function() {
-                var nodes = resolver.childNodes(this);
-
-                var json = {
-                    type: 'Polygon',
-                    coordinates: [_.map(nodes, 'loc')]
-                };
-
-                if (!this.isClosed() && nodes.length) {
-                    json.coordinates[0].push(nodes[0].loc);
-                }
-
-                var area = d3.geo.area(json);
-
-                // Heuristic for detecting counterclockwise winding order. Assumes
-                // that OpenStreetMap polygons are not hemisphere-spanning.
-                if (area > 2 * Math.PI) {
-                    json.coordinates[0] = json.coordinates[0].reverse();
-                    area = d3.geo.area(json);
-                }
-
-                return isNaN(area) ? 0 : area;
-            });
-        }
-    });
-
-    function Relation() {
-        if (!(this instanceof Relation)) {
-            return (new Relation()).initialize(arguments);
-        } else if (arguments.length) {
-            this.initialize(arguments);
-        }
-    }
-    Entity.relation = Relation;
-
-    Relation.prototype = Object.create(Entity.prototype);
-
-    Relation.creationOrder = function(a, b) {
-        var aId = parseInt(Entity.id.toOSM(a.id), 10);
-        var bId = parseInt(Entity.id.toOSM(b.id), 10);
-
-        if (aId < 0 || bId < 0) return aId - bId;
-        return bId - aId;
-    };
-
-    _.extend(Relation.prototype, {
-        type: 'relation',
-        members: [],
-
-        copy: function(resolver, copies) {
-            if (copies[this.id])
-                return copies[this.id];
-
-            var copy = Entity.prototype.copy.call(this, resolver, copies);
-
-            var members = this.members.map(function(member) {
-                return _.extend({}, member, {id: resolver.entity(member.id).copy(resolver, copies).id});
-            });
-
-            copy = copy.update({members: members});
-            copies[this.id] = copy;
-
-            return copy;
-        },
-
-        extent: function(resolver, memo) {
-            return resolver.transient(this, 'extent', function() {
-                if (memo && memo[this.id]) return iD.geo.Extent();
-                memo = memo || {};
-                memo[this.id] = true;
-
-                var extent = iD.geo.Extent();
-                for (var i = 0; i < this.members.length; i++) {
-                    var member = resolver.hasEntity(this.members[i].id);
-                    if (member) {
-                        extent._extend(member.extent(resolver, memo));
-                    }
-                }
-                return extent;
-            });
-        },
-
-        geometry: function(graph) {
-            return graph.transient(this, 'geometry', function() {
-                return this.isMultipolygon() ? 'area' : 'relation';
-            });
-        },
-
-        isDegenerate: function() {
-            return this.members.length === 0;
-        },
-
-        // Return an array of members, each extended with an 'index' property whose value
-        // is the member index.
-        indexedMembers: function() {
-            var result = new Array(this.members.length);
-            for (var i = 0; i < this.members.length; i++) {
-                result[i] = _.extend({}, this.members[i], {index: i});
-            }
-            return result;
-        },
-
-        // Return the first member with the given role. A copy of the member object
-        // is returned, extended with an 'index' property whose value is the member index.
-        memberByRole: function(role) {
-            for (var i = 0; i < this.members.length; i++) {
-                if (this.members[i].role === role) {
-                    return _.extend({}, this.members[i], {index: i});
-                }
-            }
-        },
-
-        // Return the first member with the given id. A copy of the member object
-        // is returned, extended with an 'index' property whose value is the member index.
-        memberById: function(id) {
-            for (var i = 0; i < this.members.length; i++) {
-                if (this.members[i].id === id) {
-                    return _.extend({}, this.members[i], {index: i});
-                }
-            }
-        },
-
-        // Return the first member with the given id and role. A copy of the member object
-        // is returned, extended with an 'index' property whose value is the member index.
-        memberByIdAndRole: function(id, role) {
-            for (var i = 0; i < this.members.length; i++) {
-                if (this.members[i].id === id && this.members[i].role === role) {
-                    return _.extend({}, this.members[i], {index: i});
-                }
-            }
-        },
-
-        addMember: function(member, index) {
-            var members = this.members.slice();
-            members.splice(index === undefined ? members.length : index, 0, member);
-            return this.update({members: members});
-        },
-
-        updateMember: function(member, index) {
-            var members = this.members.slice();
-            members.splice(index, 1, _.extend({}, members[index], member));
-            return this.update({members: members});
-        },
-
-        removeMember: function(index) {
-            var members = this.members.slice();
-            members.splice(index, 1);
-            return this.update({members: members});
-        },
-
-        removeMembersWithID: function(id) {
-            var members = _.reject(this.members, function(m) { return m.id === id; });
-            return this.update({members: members});
-        },
-
-        // Wherever a member appears with id `needle.id`, replace it with a member
-        // with id `replacement.id`, type `replacement.type`, and the original role,
-        // unless a member already exists with that id and role. Return an updated
-        // relation.
-        replaceMember: function(needle, replacement) {
-            if (!this.memberById(needle.id))
-                return this;
-
-            var members = [];
-
-            for (var i = 0; i < this.members.length; i++) {
-                var member = this.members[i];
-                if (member.id !== needle.id) {
-                    members.push(member);
-                } else if (!this.memberByIdAndRole(replacement.id, member.role)) {
-                    members.push({id: replacement.id, type: replacement.type, role: member.role});
-                }
-            }
-
-            return this.update({members: members});
-        },
-
-        asJXON: function(changeset_id) {
-            var r = {
-                relation: {
-                    '@id': this.osmId(),
-                    '@version': this.version || 0,
-                    member: _.map(this.members, function(member) {
-                        return { keyAttributes: { type: member.type, role: member.role, ref: Entity.id.toOSM(member.id) } };
-                    }),
-                    tag: _.map(this.tags, function(v, k) {
-                        return { keyAttributes: { k: k, v: v } };
-                    })
-                }
-            };
-            if (changeset_id) r.relation['@changeset'] = changeset_id;
-            return r;
-        },
-
-        asGeoJSON: function(resolver) {
-            return resolver.transient(this, 'GeoJSON', function () {
-                if (this.isMultipolygon()) {
-                    return {
-                        type: 'MultiPolygon',
-                        coordinates: this.multipolygon(resolver)
-                    };
-                } else {
-                    return {
-                        type: 'FeatureCollection',
-                        properties: this.tags,
-                        features: this.members.map(function (member) {
-                            return _.extend({role: member.role}, resolver.entity(member.id).asGeoJSON(resolver));
-                        })
-                    };
-                }
-            });
-        },
-
-        area: function(resolver) {
-            return resolver.transient(this, 'area', function() {
-                return d3.geo.area(this.asGeoJSON(resolver));
-            });
-        },
-
-        isMultipolygon: function() {
-            return this.tags.type === 'multipolygon';
-        },
-
-        isComplete: function(resolver) {
-            for (var i = 0; i < this.members.length; i++) {
-                if (!resolver.hasEntity(this.members[i].id)) {
-                    return false;
-                }
-            }
-            return true;
-        },
-
-        isRestriction: function() {
-            return !!(this.tags.type && this.tags.type.match(/^restriction:?/));
-        },
-
-        // Returns an array [A0, ... An], each Ai being an array of node arrays [Nds0, ... Ndsm],
-        // where Nds0 is an outer ring and subsequent Ndsi's (if any i > 0) being inner rings.
-        //
-        // This corresponds to the structure needed for rendering a multipolygon path using a
-        // `evenodd` fill rule, as well as the structure of a GeoJSON MultiPolygon geometry.
-        //
-        // In the case of invalid geometries, this function will still return a result which
-        // includes the nodes of all way members, but some Nds may be unclosed and some inner
-        // rings not matched with the intended outer ring.
-        //
-        multipolygon: function(resolver) {
-            var outers = this.members.filter(function(m) { return 'outer' === (m.role || 'outer'); }),
-                inners = this.members.filter(function(m) { return 'inner' === m.role; });
-
-            outers = iD.geo.joinWays(outers, resolver);
-            inners = iD.geo.joinWays(inners, resolver);
-
-            outers = outers.map(function(outer) { return _.map(outer.nodes, 'loc'); });
-            inners = inners.map(function(inner) { return _.map(inner.nodes, 'loc'); });
-
-            var result = outers.map(function(o) {
-                // Heuristic for detecting counterclockwise winding order. Assumes
-                // that OpenStreetMap polygons are not hemisphere-spanning.
-                return [d3.geo.area({type: 'Polygon', coordinates: [o]}) > 2 * Math.PI ? o.reverse() : o];
-            });
-
-            function findOuter(inner) {
-                var o, outer;
-
-                for (o = 0; o < outers.length; o++) {
-                    outer = outers[o];
-                    if (iD.geo.polygonContainsPolygon(outer, inner))
-                        return o;
-                }
-
-                for (o = 0; o < outers.length; o++) {
-                    outer = outers[o];
-                    if (iD.geo.polygonIntersectsPolygon(outer, inner))
-                        return o;
-                }
-            }
-
-            for (var i = 0; i < inners.length; i++) {
-                var inner = inners[i];
-
-                if (d3.geo.area({type: 'Polygon', coordinates: [inner]}) < 2 * Math.PI) {
-                    inner = inner.reverse();
-                }
-
-                var o = findOuter(inners[i]);
-                if (o !== undefined)
-                    result[o].push(inners[i]);
-                else
-                    result.push([inners[i]]); // Invalid geometry
-            }
-
-            return result;
-        }
-    });
-
-    function Node() {
-        if (!(this instanceof Node)) {
-            return (new Node()).initialize(arguments);
-        } else if (arguments.length) {
-            this.initialize(arguments);
-        }
-    }
-
-    Entity.node = Node;
-
-    Node.prototype = Object.create(Entity.prototype);
-
-    _.extend(Node.prototype, {
-        type: 'node',
-
-        extent: function() {
-            return new iD.geo.Extent(this.loc);
-        },
-
-        geometry: function(graph) {
-            return graph.transient(this, 'geometry', function() {
-                return graph.isPoi(this) ? 'point' : 'vertex';
-            });
-        },
-
-        move: function(loc) {
-            return this.update({loc: loc});
-        },
-
-        isIntersection: function(resolver) {
-            return resolver.transient(this, 'isIntersection', function() {
-                return resolver.parentWays(this).filter(function(parent) {
-                    return (parent.tags.highway ||
-                        parent.tags.waterway ||
-                        parent.tags.railway ||
-                        parent.tags.aeroway) &&
-                        parent.geometry(resolver) === 'line';
-                }).length > 1;
-            });
-        },
-
-        isHighwayIntersection: function(resolver) {
-            return resolver.transient(this, 'isHighwayIntersection', function() {
-                return resolver.parentWays(this).filter(function(parent) {
-                    return parent.tags.highway && parent.geometry(resolver) === 'line';
-                }).length > 1;
-            });
-        },
-
-        asJXON: function(changeset_id) {
-            var r = {
-                node: {
-                    '@id': this.osmId(),
-                    '@lon': this.loc[0],
-                    '@lat': this.loc[1],
-                    '@version': (this.version || 0),
-                    tag: _.map(this.tags, function(v, k) {
-                        return { keyAttributes: { k: k, v: v } };
-                    })
-                }
-            };
-            if (changeset_id) r.node['@changeset'] = changeset_id;
-            return r;
-        },
-
-        asGeoJSON: function() {
-            return {
-                type: 'Point',
-                coordinates: this.loc
-            };
-        }
-    });
-
-    function Connection(useHttps) {
-        if (typeof useHttps !== 'boolean') {
-          useHttps = window.location.protocol === 'https:';
-        }
-
-        var event = d3.dispatch('authenticating', 'authenticated', 'auth', 'loading', 'loaded'),
-            protocol = useHttps ? 'https:' : 'http:',
-            url = protocol + '//www.openstreetmap.org',
-            connection = {},
-            inflight = {},
-            loadedTiles = {},
-            tileZoom = 16,
-            oauth = osmAuth({
-                url: protocol + '//www.openstreetmap.org',
-                oauth_consumer_key: '5A043yRSEugj4DJ5TljuapfnrflWDte8jTOcWLlT',
-                oauth_secret: 'aB3jKq1TRsCOUrfOIZ6oQMEDmv2ptV76PA54NGLL',
-                loading: authenticating,
-                done: authenticated
-            }),
-            ndStr = 'nd',
-            tagStr = 'tag',
-            memberStr = 'member',
-            nodeStr = 'node',
-            wayStr = 'way',
-            relationStr = 'relation',
-            userDetails,
-            off;
-
-
-        connection.changesetURL = function(changesetId) {
-            return url + '/changeset/' + changesetId;
-        };
-
-        connection.changesetsURL = function(center, zoom) {
-            var precision = Math.max(0, Math.ceil(Math.log(zoom) / Math.LN2));
-            return url + '/history#map=' +
-                Math.floor(zoom) + '/' +
-                center[1].toFixed(precision) + '/' +
-                center[0].toFixed(precision);
-        };
-
-        connection.entityURL = function(entity) {
-            return url + '/' + entity.type + '/' + entity.osmId();
-        };
-
-        connection.userURL = function(username) {
-            return url + '/user/' + username;
-        };
-
-        connection.loadFromURL = function(url, callback) {
-            function done(err, dom) {
-                return callback(err, parse(dom));
-            }
-            return d3.xml(url).get(done);
-        };
-
-        connection.loadEntity = function(id, callback) {
-            var type = Entity.id.type(id),
-                osmID = Entity.id.toOSM(id);
-
-            connection.loadFromURL(
-                url + '/api/0.6/' + type + '/' + osmID + (type !== 'node' ? '/full' : ''),
-                function(err, entities) {
-                    if (callback) callback(err, {data: entities});
-                });
-        };
-
-        connection.loadEntityVersion = function(id, version, callback) {
-            var type = Entity.id.type(id),
-                osmID = Entity.id.toOSM(id);
-
-            connection.loadFromURL(
-                url + '/api/0.6/' + type + '/' + osmID + '/' + version,
-                function(err, entities) {
-                    if (callback) callback(err, {data: entities});
-                });
-        };
-
-        connection.loadMultiple = function(ids, callback) {
-            _.each(_.groupBy(_.uniq(ids), Entity.id.type), function(v, k) {
-                var type = k + 's',
-                    osmIDs = _.map(v, Entity.id.toOSM);
-
-                _.each(_.chunk(osmIDs, 150), function(arr) {
-                    connection.loadFromURL(
-                        url + '/api/0.6/' + type + '?' + type + '=' + arr.join(),
-                        function(err, entities) {
-                            if (callback) callback(err, {data: entities});
-                        });
-                });
-            });
-        };
-
-        function authenticating() {
-            event.authenticating();
-        }
-
-        function authenticated() {
-            event.authenticated();
-        }
-
-        function getLoc(attrs) {
-            var lon = attrs.lon && attrs.lon.value,
-                lat = attrs.lat && attrs.lat.value;
-            return [parseFloat(lon), parseFloat(lat)];
-        }
-
-        function getNodes(obj) {
-            var elems = obj.getElementsByTagName(ndStr),
-                nodes = new Array(elems.length);
-            for (var i = 0, l = elems.length; i < l; i++) {
-                nodes[i] = 'n' + elems[i].attributes.ref.value;
-            }
-            return nodes;
-        }
-
-        function getTags(obj) {
-            var elems = obj.getElementsByTagName(tagStr),
-                tags = {};
-            for (var i = 0, l = elems.length; i < l; i++) {
-                var attrs = elems[i].attributes;
-                tags[attrs.k.value] = attrs.v.value;
-            }
-            return tags;
-        }
-
-        function getMembers(obj) {
-            var elems = obj.getElementsByTagName(memberStr),
-                members = new Array(elems.length);
-            for (var i = 0, l = elems.length; i < l; i++) {
-                var attrs = elems[i].attributes;
-                members[i] = {
-                    id: attrs.type.value[0] + attrs.ref.value,
-                    type: attrs.type.value,
-                    role: attrs.role.value
-                };
-            }
-            return members;
-        }
-
-        function getVisible(attrs) {
-            return (!attrs.visible || attrs.visible.value !== 'false');
-        }
-
-        var parsers = {
-            node: function nodeData(obj) {
-                var attrs = obj.attributes;
-                return new Node({
-                    id: Entity.id.fromOSM(nodeStr, attrs.id.value),
-                    loc: getLoc(attrs),
-                    version: attrs.version.value,
-                    user: attrs.user && attrs.user.value,
-                    tags: getTags(obj),
-                    visible: getVisible(attrs)
-                });
-            },
-
-            way: function wayData(obj) {
-                var attrs = obj.attributes;
-                return new Way({
-                    id: Entity.id.fromOSM(wayStr, attrs.id.value),
-                    version: attrs.version.value,
-                    user: attrs.user && attrs.user.value,
-                    tags: getTags(obj),
-                    nodes: getNodes(obj),
-                    visible: getVisible(attrs)
-                });
-            },
-
-            relation: function relationData(obj) {
-                var attrs = obj.attributes;
-                return new Relation({
-                    id: Entity.id.fromOSM(relationStr, attrs.id.value),
-                    version: attrs.version.value,
-                    user: attrs.user && attrs.user.value,
-                    tags: getTags(obj),
-                    members: getMembers(obj),
-                    visible: getVisible(attrs)
-                });
-            }
-        };
-
-        function parse(dom) {
-            if (!dom || !dom.childNodes) return;
-
-            var root = dom.childNodes[0],
-                children = root.childNodes,
-                entities = [];
-
-            for (var i = 0, l = children.length; i < l; i++) {
-                var child = children[i],
-                    parser = parsers[child.nodeName];
-                if (parser) {
-                    entities.push(parser(child));
-                }
-            }
-
-            return entities;
-        }
-
-        connection.authenticated = function() {
-            return oauth.authenticated();
-        };
-
-        // Generate Changeset XML. Returns a string.
-        connection.changesetJXON = function(tags) {
-            return {
-                osm: {
-                    changeset: {
-                        tag: _.map(tags, function(value, key) {
-                            return { '@k': key, '@v': value };
-                        }),
-                        '@version': 0.6,
-                        '@generator': 'iD'
-                    }
-                }
-            };
-        };
-
-        // Generate [osmChange](http://wiki.openstreetmap.org/wiki/OsmChange)
-        // XML. Returns a string.
-        connection.osmChangeJXON = function(changeset_id, changes) {
-            function nest(x, order) {
-                var groups = {};
-                for (var i = 0; i < x.length; i++) {
-                    var tagName = Object.keys(x[i])[0];
-                    if (!groups[tagName]) groups[tagName] = [];
-                    groups[tagName].push(x[i][tagName]);
-                }
-                var ordered = {};
-                order.forEach(function(o) {
-                    if (groups[o]) ordered[o] = groups[o];
-                });
-                return ordered;
-            }
-
-            function rep(entity) {
-                return entity.asJXON(changeset_id);
-            }
-
-            return {
-                osmChange: {
-                    '@version': 0.6,
-                    '@generator': 'iD',
-                    'create': nest(changes.created.map(rep), ['node', 'way', 'relation']),
-                    'modify': nest(changes.modified.map(rep), ['node', 'way', 'relation']),
-                    'delete': _.extend(nest(changes.deleted.map(rep), ['relation', 'way', 'node']), {'@if-unused': true})
-                }
-            };
-        };
-
-        connection.changesetTags = function(comment, imageryUsed) {
-            var detected = iD.detect(),
-                tags = {
-                    created_by: 'iD ' + iD.version,
-                    imagery_used: imageryUsed.join(';').substr(0, 255),
-                    host: (window.location.origin + window.location.pathname).substr(0, 255),
-                    locale: detected.locale
-                };
-
-            if (comment) {
-                tags.comment = comment.substr(0, 255);
-            }
-
-            return tags;
-        };
-
-        connection.putChangeset = function(changes, comment, imageryUsed, callback) {
-            oauth.xhr({
-                    method: 'PUT',
-                    path: '/api/0.6/changeset/create',
-                    options: { header: { 'Content-Type': 'text/xml' } },
-                    content: JXON.stringify(connection.changesetJXON(connection.changesetTags(comment, imageryUsed)))
-                }, function(err, changeset_id) {
-                    if (err) return callback(err);
-                    oauth.xhr({
-                        method: 'POST',
-                        path: '/api/0.6/changeset/' + changeset_id + '/upload',
-                        options: { header: { 'Content-Type': 'text/xml' } },
-                        content: JXON.stringify(connection.osmChangeJXON(changeset_id, changes))
-                    }, function(err) {
-                        if (err) return callback(err);
-                        // POST was successful, safe to call the callback.
-                        // Still attempt to close changeset, but ignore response because #2667
-                        // Add delay to allow for postgres replication #1646 #2678
-                        window.setTimeout(function() { callback(null, changeset_id); }, 2500);
-                        oauth.xhr({
-                            method: 'PUT',
-                            path: '/api/0.6/changeset/' + changeset_id + '/close',
-                            options: { header: { 'Content-Type': 'text/xml' } }
-                        }, d3.functor(true));
-                    });
-                });
-        };
-
-        connection.userDetails = function(callback) {
-            if (userDetails) {
-                callback(undefined, userDetails);
-                return;
-            }
-
-            function done(err, user_details) {
-                if (err) return callback(err);
-
-                var u = user_details.getElementsByTagName('user')[0],
-                    img = u.getElementsByTagName('img'),
-                    image_url = '';
-
-                if (img && img[0] && img[0].getAttribute('href')) {
-                    image_url = img[0].getAttribute('href');
-                }
-
-                userDetails = {
-                    display_name: u.attributes.display_name.value,
-                    image_url: image_url,
-                    id: u.attributes.id.value
-                };
-
-                callback(undefined, userDetails);
-            }
-
-            oauth.xhr({ method: 'GET', path: '/api/0.6/user/details' }, done);
-        };
-
-        connection.userChangesets = function(callback) {
-            connection.userDetails(function(err, user) {
-                if (err) return callback(err);
-
-                function done(changesets) {
-                    callback(undefined, Array.prototype.map.call(changesets.getElementsByTagName('changeset'),
-                        function (changeset) {
-                            return { tags: getTags(changeset) };
-                        }));
-                }
-
-                d3.xml(url + '/api/0.6/changesets?user=' + user.id).get()
-                    .on('load', done)
-                    .on('error', callback);
-            });
-        };
-
-        connection.status = function(callback) {
-            function done(capabilities) {
-                var apiStatus = capabilities.getElementsByTagName('status');
-                callback(undefined, apiStatus[0].getAttribute('api'));
-            }
-            d3.xml(url + '/api/capabilities').get()
-                .on('load', done)
-                .on('error', callback);
-        };
-
-        function abortRequest(i) { i.abort(); }
-
-        connection.tileZoom = function(_) {
-            if (!arguments.length) return tileZoom;
-            tileZoom = _;
-            return connection;
-        };
-
-        connection.loadTiles = function(projection, dimensions, callback) {
-
-            if (off) return;
-
-            var s = projection.scale() * 2 * Math.PI,
-                z = Math.max(Math.log(s) / Math.log(2) - 8, 0),
-                ts = 256 * Math.pow(2, z - tileZoom),
-                origin = [
-                    s / 2 - projection.translate()[0],
-                    s / 2 - projection.translate()[1]];
-
-            var tiles = d3.geo.tile()
-                .scaleExtent([tileZoom, tileZoom])
-                .scale(s)
-                .size(dimensions)
-                .translate(projection.translate())()
-                .map(function(tile) {
-                    var x = tile[0] * ts - origin[0],
-                        y = tile[1] * ts - origin[1];
-
-                    return {
-                        id: tile.toString(),
-                        extent: iD.geo.Extent(
-                            projection.invert([x, y + ts]),
-                            projection.invert([x + ts, y]))
-                    };
-                });
-
-            function bboxUrl(tile) {
-                return url + '/api/0.6/map?bbox=' + tile.extent.toParam();
-            }
-
-            _.filter(inflight, function(v, i) {
-                var wanted = _.find(tiles, function(tile) {
-                    return i === tile.id;
-                });
-                if (!wanted) delete inflight[i];
-                return !wanted;
-            }).map(abortRequest);
-
-            tiles.forEach(function(tile) {
-                var id = tile.id;
-
-                if (loadedTiles[id] || inflight[id]) return;
-
-                if (_.isEmpty(inflight)) {
-                    event.loading();
-                }
-
-                inflight[id] = connection.loadFromURL(bboxUrl(tile), function(err, parsed) {
-                    loadedTiles[id] = true;
-                    delete inflight[id];
-
-                    if (callback) callback(err, _.extend({data: parsed}, tile));
-
-                    if (_.isEmpty(inflight)) {
-                        event.loaded();
-                    }
-                });
-            });
-        };
-
-        connection.switch = function(options) {
-            url = options.url;
-            oauth.options(_.extend({
-                loading: authenticating,
-                done: authenticated
-            }, options));
-            event.auth();
-            connection.flush();
-            return connection;
-        };
-
-        connection.toggle = function(_) {
-            off = !_;
-            return connection;
-        };
-
-        connection.flush = function() {
-            userDetails = undefined;
-            _.forEach(inflight, abortRequest);
-            loadedTiles = {};
-            inflight = {};
-            return connection;
-        };
-
-        connection.loadedTiles = function(_) {
-            if (!arguments.length) return loadedTiles;
-            loadedTiles = _;
-            return connection;
-        };
-
-        connection.logout = function() {
-            userDetails = undefined;
-            oauth.logout();
-            event.auth();
-            return connection;
-        };
-
-        connection.authenticate = function(callback) {
-            userDetails = undefined;
-            function done(err, res) {
-                event.auth();
-                if (callback) callback(err, res);
-            }
-            return oauth.authenticate(done);
-        };
-
-        return d3.rebind(connection, event, 'on');
-    }
-
-    /*
-        iD.Difference represents the difference between two graphs.
-        It knows how to calculate the set of entities that were
-        created, modified, or deleted, and also contains the logic
-        for recursively extending a difference to the complete set
-        of entities that will require a redraw, taking into account
-        child and parent relationships.
-     */
-    function Difference(base, head) {
-        var changes = {}, length = 0;
-
-        function changed(h, b) {
-            return h !== b && !_.isEqual(_.omit(h, 'v'), _.omit(b, 'v'));
-        }
-
-        _.each(head.entities, function(h, id) {
-            var b = base.entities[id];
-            if (changed(h, b)) {
-                changes[id] = {base: b, head: h};
-                length++;
-            }
-        });
-
-        _.each(base.entities, function(b, id) {
-            var h = head.entities[id];
-            if (!changes[id] && changed(h, b)) {
-                changes[id] = {base: b, head: h};
-                length++;
-            }
-        });
-
-        function addParents(parents, result) {
-            for (var i = 0; i < parents.length; i++) {
-                var parent = parents[i];
-
-                if (parent.id in result)
-                    continue;
-
-                result[parent.id] = parent;
-                addParents(head.parentRelations(parent), result);
-            }
-        }
-
-        var difference = {};
-
-        difference.length = function() {
-            return length;
-        };
-
-        difference.changes = function() {
-            return changes;
-        };
-
-        difference.extantIDs = function() {
-            var result = [];
-            _.each(changes, function(change, id) {
-                if (change.head) result.push(id);
-            });
-            return result;
-        };
-
-        difference.modified = function() {
-            var result = [];
-            _.each(changes, function(change) {
-                if (change.base && change.head) result.push(change.head);
-            });
-            return result;
-        };
-
-        difference.created = function() {
-            var result = [];
-            _.each(changes, function(change) {
-                if (!change.base && change.head) result.push(change.head);
-            });
-            return result;
-        };
-
-        difference.deleted = function() {
-            var result = [];
-            _.each(changes, function(change) {
-                if (change.base && !change.head) result.push(change.base);
-            });
-            return result;
-        };
-
-        difference.summary = function() {
-            var relevant = {};
-
-            function addEntity(entity, graph, changeType) {
-                relevant[entity.id] = {
-                    entity: entity,
-                    graph: graph,
-                    changeType: changeType
-                };
-            }
-
-            function addParents(entity) {
-                var parents = head.parentWays(entity);
-                for (var j = parents.length - 1; j >= 0; j--) {
-                    var parent = parents[j];
-                    if (!(parent.id in relevant)) addEntity(parent, head, 'modified');
-                }
-            }
-
-            _.each(changes, function(change) {
-                if (change.head && change.head.geometry(head) !== 'vertex') {
-                    addEntity(change.head, head, change.base ? 'modified' : 'created');
-
-                } else if (change.base && change.base.geometry(base) !== 'vertex') {
-                    addEntity(change.base, base, 'deleted');
-
-                } else if (change.base && change.head) { // modified vertex
-                    var moved    = !_.isEqual(change.base.loc,  change.head.loc),
-                        retagged = !_.isEqual(change.base.tags, change.head.tags);
-
-                    if (moved) {
-                        addParents(change.head);
-                    }
-
-                    if (retagged || (moved && change.head.hasInterestingTags())) {
-                        addEntity(change.head, head, 'modified');
-                    }
-
-                } else if (change.head && change.head.hasInterestingTags()) { // created vertex
-                    addEntity(change.head, head, 'created');
-
-                } else if (change.base && change.base.hasInterestingTags()) { // deleted vertex
-                    addEntity(change.base, base, 'deleted');
-                }
-            });
-
-            return d3.values(relevant);
-        };
-
-        difference.complete = function(extent) {
-            var result = {}, id, change;
-
-            for (id in changes) {
-                change = changes[id];
-
-                var h = change.head,
-                    b = change.base,
-                    entity = h || b;
-
-                if (extent &&
-                    (!h || !h.intersects(extent, head)) &&
-                    (!b || !b.intersects(extent, base)))
-                    continue;
-
-                result[id] = h;
-
-                if (entity.type === 'way') {
-                    var nh = h ? h.nodes : [],
-                        nb = b ? b.nodes : [],
-                        diff, i;
-
-                    diff = _.difference(nh, nb);
-                    for (i = 0; i < diff.length; i++) {
-                        result[diff[i]] = head.hasEntity(diff[i]);
-                    }
-
-                    diff = _.difference(nb, nh);
-                    for (i = 0; i < diff.length; i++) {
-                        result[diff[i]] = head.hasEntity(diff[i]);
-                    }
-                }
-
-                addParents(head.parentWays(entity), result);
-                addParents(head.parentRelations(entity), result);
-            }
-
-            return result;
-        };
-
-        return difference;
-    }
-
-    function Graph(other, mutable) {
-        if (!(this instanceof Graph)) return new Graph(other, mutable);
-
-        if (other instanceof Graph) {
-            var base = other.base();
-            this.entities = _.assign(Object.create(base.entities), other.entities);
-            this._parentWays = _.assign(Object.create(base.parentWays), other._parentWays);
-            this._parentRels = _.assign(Object.create(base.parentRels), other._parentRels);
-
-        } else {
-            this.entities = Object.create({});
-            this._parentWays = Object.create({});
-            this._parentRels = Object.create({});
-            this.rebase(other || [], [this]);
-        }
-
-        this.transients = {};
-        this._childNodes = {};
-        this.frozen = !mutable;
-    }
-
-    Graph.prototype = {
-        hasEntity: function(id) {
-            return this.entities[id];
-        },
-
-        entity: function(id) {
-            var entity = this.entities[id];
-            if (!entity) {
-                throw new Error('entity ' + id + ' not found');
-            }
-            return entity;
-        },
-
-        transient: function(entity, key, fn) {
-            var id = entity.id,
-                transients = this.transients[id] ||
-                (this.transients[id] = {});
-
-            if (transients[key] !== undefined) {
-                return transients[key];
-            }
-
-            transients[key] = fn.call(entity);
-
-            return transients[key];
-        },
-
-        parentWays: function(entity) {
-            var parents = this._parentWays[entity.id],
-                result = [];
-
-            if (parents) {
-                for (var i = 0; i < parents.length; i++) {
-                    result.push(this.entity(parents[i]));
-                }
-            }
-            return result;
-        },
-
-        isPoi: function(entity) {
-            var parentWays = this._parentWays[entity.id];
-            return !parentWays || parentWays.length === 0;
-        },
-
-        isShared: function(entity) {
-            var parentWays = this._parentWays[entity.id];
-            return parentWays && parentWays.length > 1;
-        },
-
-        parentRelations: function(entity) {
-            var parents = this._parentRels[entity.id],
-                result = [];
-
-            if (parents) {
-                for (var i = 0; i < parents.length; i++) {
-                    result.push(this.entity(parents[i]));
-                }
-            }
-            return result;
-        },
-
-        childNodes: function(entity) {
-            if (this._childNodes[entity.id]) return this._childNodes[entity.id];
-            if (!entity.nodes) return [];
-
-            var nodes = [];
-            for (var i = 0; i < entity.nodes.length; i++) {
-                nodes[i] = this.entity(entity.nodes[i]);
-            }
-
-            if (iD.debug) Object.freeze(nodes);
-
-            this._childNodes[entity.id] = nodes;
-            return this._childNodes[entity.id];
-        },
-
-        base: function() {
-            return {
-                'entities': iD.util.getPrototypeOf(this.entities),
-                'parentWays': iD.util.getPrototypeOf(this._parentWays),
-                'parentRels': iD.util.getPrototypeOf(this._parentRels)
-            };
-        },
-
-        // Unlike other graph methods, rebase mutates in place. This is because it
-        // is used only during the history operation that merges newly downloaded
-        // data into each state. To external consumers, it should appear as if the
-        // graph always contained the newly downloaded data.
-        rebase: function(entities, stack, force) {
-            var base = this.base(),
-                i, j, k, id;
-
-            for (i = 0; i < entities.length; i++) {
-                var entity = entities[i];
-
-                if (!entity.visible || (!force && base.entities[entity.id]))
-                    continue;
-
-                // Merging data into the base graph
-                base.entities[entity.id] = entity;
-                this._updateCalculated(undefined, entity, base.parentWays, base.parentRels);
-
-                // Restore provisionally-deleted nodes that are discovered to have an extant parent
-                if (entity.type === 'way') {
-                    for (j = 0; j < entity.nodes.length; j++) {
-                        id = entity.nodes[j];
-                        for (k = 1; k < stack.length; k++) {
-                            var ents = stack[k].entities;
-                            if (ents.hasOwnProperty(id) && ents[id] === undefined) {
-                                delete ents[id];
-                            }
-                        }
-                    }
-                }
-            }
-
-            for (i = 0; i < stack.length; i++) {
-                stack[i]._updateRebased();
-            }
-        },
-
-        _updateRebased: function() {
-            var base = this.base(),
-                i, k, child, id, keys;
-
-            keys = Object.keys(this._parentWays);
-            for (i = 0; i < keys.length; i++) {
-                child = keys[i];
-                if (base.parentWays[child]) {
-                    for (k = 0; k < base.parentWays[child].length; k++) {
-                        id = base.parentWays[child][k];
-                        if (!this.entities.hasOwnProperty(id) && !_.includes(this._parentWays[child], id)) {
-                            this._parentWays[child].push(id);
-                        }
-                    }
-                }
-            }
-
-            keys = Object.keys(this._parentRels);
-            for (i = 0; i < keys.length; i++) {
-                child = keys[i];
-                if (base.parentRels[child]) {
-                    for (k = 0; k < base.parentRels[child].length; k++) {
-                        id = base.parentRels[child][k];
-                        if (!this.entities.hasOwnProperty(id) && !_.includes(this._parentRels[child], id)) {
-                            this._parentRels[child].push(id);
-                        }
-                    }
-                }
-            }
-
-            this.transients = {};
-
-            // this._childNodes is not updated, under the assumption that
-            // ways are always downloaded with their child nodes.
-        },
-
-        // Updates calculated properties (parentWays, parentRels) for the specified change
-        _updateCalculated: function(oldentity, entity, parentWays, parentRels) {
-
-            parentWays = parentWays || this._parentWays;
-            parentRels = parentRels || this._parentRels;
-
-            var type = entity && entity.type || oldentity && oldentity.type,
-                removed, added, ways, rels, i;
-
-
-            if (type === 'way') {
-
-                // Update parentWays
-                if (oldentity && entity) {
-                    removed = _.difference(oldentity.nodes, entity.nodes);
-                    added = _.difference(entity.nodes, oldentity.nodes);
-                } else if (oldentity) {
-                    removed = oldentity.nodes;
-                    added = [];
-                } else if (entity) {
-                    removed = [];
-                    added = entity.nodes;
-                }
-                for (i = 0; i < removed.length; i++) {
-                    parentWays[removed[i]] = _.without(parentWays[removed[i]], oldentity.id);
-                }
-                for (i = 0; i < added.length; i++) {
-                    ways = _.without(parentWays[added[i]], entity.id);
-                    ways.push(entity.id);
-                    parentWays[added[i]] = ways;
-                }
-
-            } else if (type === 'relation') {
-
-                // Update parentRels
-                if (oldentity && entity) {
-                    removed = _.difference(oldentity.members, entity.members);
-                    added = _.difference(entity.members, oldentity);
-                } else if (oldentity) {
-                    removed = oldentity.members;
-                    added = [];
-                } else if (entity) {
-                    removed = [];
-                    added = entity.members;
-                }
-                for (i = 0; i < removed.length; i++) {
-                    parentRels[removed[i].id] = _.without(parentRels[removed[i].id], oldentity.id);
-                }
-                for (i = 0; i < added.length; i++) {
-                    rels = _.without(parentRels[added[i].id], entity.id);
-                    rels.push(entity.id);
-                    parentRels[added[i].id] = rels;
-                }
-            }
-        },
-
-        replace: function(entity) {
-            if (this.entities[entity.id] === entity)
-                return this;
-
-            return this.update(function() {
-                this._updateCalculated(this.entities[entity.id], entity);
-                this.entities[entity.id] = entity;
-            });
-        },
-
-        remove: function(entity) {
-            return this.update(function() {
-                this._updateCalculated(entity, undefined);
-                this.entities[entity.id] = undefined;
-            });
-        },
-
-        revert: function(id) {
-            var baseEntity = this.base().entities[id],
-                headEntity = this.entities[id];
-
-            if (headEntity === baseEntity)
-                return this;
-
-            return this.update(function() {
-                this._updateCalculated(headEntity, baseEntity);
-                delete this.entities[id];
-            });
-        },
-
-        update: function() {
-            var graph = this.frozen ? Graph(this, true) : this;
-
-            for (var i = 0; i < arguments.length; i++) {
-                arguments[i].call(graph, graph);
-            }
-
-            if (this.frozen) graph.frozen = true;
-
-            return graph;
-        },
-
-        // Obliterates any existing entities
-        load: function(entities) {
-            var base = this.base();
-            this.entities = Object.create(base.entities);
-
-            for (var i in entities) {
-                this.entities[i] = entities[i];
-                this._updateCalculated(base.entities[i], this.entities[i]);
-            }
-
-            return this;
-        }
-    };
-
-    function Tree(head) {
-        var rtree = rbush(),
-            rectangles = {};
-
-        function entityRectangle(entity) {
-            var rect = entity.extent(head).rectangle();
-            rect.id = entity.id;
-            rectangles[entity.id] = rect;
-            return rect;
-        }
-
-        function updateParents(entity, insertions, memo) {
-            head.parentWays(entity).forEach(function(way) {
-                if (rectangles[way.id]) {
-                    rtree.remove(rectangles[way.id]);
-                    insertions[way.id] = way;
-                }
-                updateParents(way, insertions, memo);
-            });
-
-            head.parentRelations(entity).forEach(function(relation) {
-                if (memo[entity.id]) return;
-                memo[entity.id] = true;
-                if (rectangles[relation.id]) {
-                    rtree.remove(rectangles[relation.id]);
-                    insertions[relation.id] = relation;
-                }
-                updateParents(relation, insertions, memo);
-            });
-        }
-
-        var tree = {};
-
-        tree.rebase = function(entities, force) {
-            var insertions = {};
-
-            for (var i = 0; i < entities.length; i++) {
-                var entity = entities[i];
-
-                if (!entity.visible)
-                    continue;
-
-                if (head.entities.hasOwnProperty(entity.id) || rectangles[entity.id]) {
-                    if (!force) {
-                        continue;
-                    } else if (rectangles[entity.id]) {
-                        rtree.remove(rectangles[entity.id]);
-                    }
-                }
-
-                insertions[entity.id] = entity;
-                updateParents(entity, insertions, {});
-            }
-
-            rtree.load(_.map(insertions, entityRectangle));
-
-            return tree;
-        };
-
-        tree.intersects = function(extent, graph) {
-            if (graph !== head) {
-                var diff = Difference(head, graph),
-                    insertions = {};
-
-                head = graph;
-
-                diff.deleted().forEach(function(entity) {
-                    rtree.remove(rectangles[entity.id]);
-                    delete rectangles[entity.id];
-                });
-
-                diff.modified().forEach(function(entity) {
-                    rtree.remove(rectangles[entity.id]);
-                    insertions[entity.id] = entity;
-                    updateParents(entity, insertions, {});
-                });
-
-                diff.created().forEach(function(entity) {
-                    insertions[entity.id] = entity;
-                });
-
-                rtree.load(_.map(insertions, entityRectangle));
-            }
-
-            return rtree.search(extent.rectangle()).map(function(rect) {
-                return head.entity(rect.id);
-            });
-        };
-
-        return tree;
-    }
-
-    function History(context) {
-        var stack, index, tree,
-            imageryUsed = ['Bing'],
-            dispatch = d3.dispatch('change', 'undone', 'redone'),
-            lock = iD.util.SessionMutex('lock');
-
-        function perform(actions) {
-            actions = Array.prototype.slice.call(actions);
-
-            var annotation;
-
-            if (!_.isFunction(_.last(actions))) {
-                annotation = actions.pop();
-            }
-
-            var graph = stack[index].graph;
-            for (var i = 0; i < actions.length; i++) {
-                graph = actions[i](graph);
-            }
-
-            return {
-                graph: graph,
-                annotation: annotation,
-                imageryUsed: imageryUsed
-            };
-        }
-
-        function change(previous) {
-            var difference = Difference(previous, history.graph());
-            dispatch.change(difference);
-            return difference;
-        }
-
-        // iD uses namespaced keys so multiple installations do not conflict
-        function getKey(n) {
-            return 'iD_' + window.location.origin + '_' + n;
-        }
-
-        var history = {
-            graph: function() {
-                return stack[index].graph;
-            },
-
-            base: function() {
-                return stack[0].graph;
-            },
-
-            merge: function(entities, extent) {
-                stack[0].graph.rebase(entities, _.map(stack, 'graph'), false);
-                tree.rebase(entities, false);
-
-                dispatch.change(undefined, extent);
-            },
-
-            perform: function() {
-                var previous = stack[index].graph;
-
-                stack = stack.slice(0, index + 1);
-                stack.push(perform(arguments));
-                index++;
-
-                return change(previous);
-            },
-
-            replace: function() {
-                var previous = stack[index].graph;
-
-                // assert(index == stack.length - 1)
-                stack[index] = perform(arguments);
-
-                return change(previous);
-            },
-
-            pop: function() {
-                var previous = stack[index].graph;
-
-                if (index > 0) {
-                    index--;
-                    stack.pop();
-                    return change(previous);
-                }
-            },
-
-            // Same as calling pop and then perform
-            overwrite: function() {
-                var previous = stack[index].graph;
-
-                if (index > 0) {
-                    index--;
-                    stack.pop();
-                }
-                stack = stack.slice(0, index + 1);
-                stack.push(perform(arguments));
-                index++;
-
-                return change(previous);
-            },
-
-            undo: function() {
-                var previous = stack[index].graph;
-
-                // Pop to the next annotated state.
-                while (index > 0) {
-                    index--;
-                    if (stack[index].annotation) break;
-                }
-
-                dispatch.undone();
-                return change(previous);
-            },
-
-            redo: function() {
-                var previous = stack[index].graph;
-
-                while (index < stack.length - 1) {
-                    index++;
-                    if (stack[index].annotation) break;
-                }
-
-                dispatch.redone();
-                return change(previous);
-            },
-
-            undoAnnotation: function() {
-                var i = index;
-                while (i >= 0) {
-                    if (stack[i].annotation) return stack[i].annotation;
-                    i--;
-                }
-            },
-
-            redoAnnotation: function() {
-                var i = index + 1;
-                while (i <= stack.length - 1) {
-                    if (stack[i].annotation) return stack[i].annotation;
-                    i++;
-                }
-            },
-
-            intersects: function(extent) {
-                return tree.intersects(extent, stack[index].graph);
-            },
-
-            difference: function() {
-                var base = stack[0].graph,
-                    head = stack[index].graph;
-                return Difference(base, head);
-            },
-
-            changes: function(action) {
-                var base = stack[0].graph,
-                    head = stack[index].graph;
-
-                if (action) {
-                    head = action(head);
-                }
-
-                var difference = Difference(base, head);
-
-                return {
-                    modified: difference.modified(),
-                    created: difference.created(),
-                    deleted: difference.deleted()
-                };
-            },
-
-            validate: function(changes) {
-                return _(iD.validations)
-                    .map(function(fn) { return fn()(changes, stack[index].graph); })
-                    .flatten()
-                    .value();
-            },
-
-            hasChanges: function() {
-                return this.difference().length() > 0;
-            },
-
-            imageryUsed: function(sources) {
-                if (sources) {
-                    imageryUsed = sources;
-                    return history;
-                } else {
-                    return _(stack.slice(1, index + 1))
-                        .map('imageryUsed')
-                        .flatten()
-                        .uniq()
-                        .without(undefined, 'Custom')
-                        .value();
-                }
-            },
-
-            reset: function() {
-                stack = [{graph: Graph()}];
-                index = 0;
-                tree = Tree(stack[0].graph);
-                dispatch.change();
-                return history;
-            },
-
-            toJSON: function() {
-                if (!this.hasChanges()) return;
-
-                var allEntities = {},
-                    baseEntities = {},
-                    base = stack[0];
-
-                var s = stack.map(function(i) {
-                    var modified = [], deleted = [];
-
-                    _.forEach(i.graph.entities, function(entity, id) {
-                        if (entity) {
-                            var key = Entity.key(entity);
-                            allEntities[key] = entity;
-                            modified.push(key);
-                        } else {
-                            deleted.push(id);
-                        }
-
-                        // make sure that the originals of changed or deleted entities get merged
-                        // into the base of the stack after restoring the data from JSON.
-                        if (id in base.graph.entities) {
-                            baseEntities[id] = base.graph.entities[id];
-                        }
-                        // get originals of parent entities too
-                        _.forEach(base.graph._parentWays[id], function(parentId) {
-                            if (parentId in base.graph.entities) {
-                                baseEntities[parentId] = base.graph.entities[parentId];
-                            }
-                        });
-                    });
-
-                    var x = {};
-
-                    if (modified.length) x.modified = modified;
-                    if (deleted.length) x.deleted = deleted;
-                    if (i.imageryUsed) x.imageryUsed = i.imageryUsed;
-                    if (i.annotation) x.annotation = i.annotation;
-
-                    return x;
-                });
-
-                return JSON.stringify({
-                    version: 3,
-                    entities: _.values(allEntities),
-                    baseEntities: _.values(baseEntities),
-                    stack: s,
-                    nextIDs: Entity.id.next,
-                    index: index
-                });
-            },
-
-            fromJSON: function(json, loadChildNodes) {
-                var h = JSON.parse(json),
-                    loadComplete = true;
-
-                Entity.id.next = h.nextIDs;
-                index = h.index;
-
-                if (h.version === 2 || h.version === 3) {
-                    var allEntities = {};
-
-                    h.entities.forEach(function(entity) {
-                        allEntities[Entity.key(entity)] = Entity(entity);
-                    });
-
-                    if (h.version === 3) {
-                        // This merges originals for changed entities into the base of
-                        // the stack even if the current stack doesn't have them (for
-                        // example when iD has been restarted in a different region)
-                        var baseEntities = h.baseEntities.map(function(d) { return Entity(d); });
-                        stack[0].graph.rebase(baseEntities, _.map(stack, 'graph'), true);
-                        tree.rebase(baseEntities, true);
-
-                        // When we restore a modified way, we also need to fetch any missing
-                        // childnodes that would normally have been downloaded with it.. #2142
-                        if (loadChildNodes) {
-                            var missing =  _(baseEntities)
-                                    .filter({ type: 'way' })
-                                    .map('nodes')
-                                    .flatten()
-                                    .uniq()
-                                    .reject(function(n) { return stack[0].graph.hasEntity(n); })
-                                    .value();
-
-                            if (!_.isEmpty(missing)) {
-                                loadComplete = false;
-                                context.redrawEnable(false);
-
-                                var loading = iD.ui.Loading(context).blocking(true);
-                                context.container().call(loading);
-
-                                var childNodesLoaded = function(err, result) {
-                                    if (!err) {
-                                        var visible = _.groupBy(result.data, 'visible');
-                                        if (!_.isEmpty(visible.true)) {
-                                            missing = _.difference(missing, _.map(visible.true, 'id'));
-                                            stack[0].graph.rebase(visible.true, _.map(stack, 'graph'), true);
-                                            tree.rebase(visible.true, true);
-                                        }
-
-                                        // fetch older versions of nodes that were deleted..
-                                        _.each(visible.false, function(entity) {
-                                            context.connection()
-                                                .loadEntityVersion(entity.id, +entity.version - 1, childNodesLoaded);
-                                        });
-                                    }
-
-                                    if (err || _.isEmpty(missing)) {
-                                        loading.close();
-                                        context.redrawEnable(true);
-                                        dispatch.change();
-                                    }
-                                };
-
-                                context.connection().loadMultiple(missing, childNodesLoaded);
-                            }
-                        }
-                    }
-
-                    stack = h.stack.map(function(d) {
-                        var entities = {}, entity;
-
-                        if (d.modified) {
-                            d.modified.forEach(function(key) {
-                                entity = allEntities[key];
-                                entities[entity.id] = entity;
-                            });
-                        }
-
-                        if (d.deleted) {
-                            d.deleted.forEach(function(id) {
-                                entities[id] = undefined;
-                            });
-                        }
-
-                        return {
-                            graph: Graph(stack[0].graph).load(entities),
-                            annotation: d.annotation,
-                            imageryUsed: d.imageryUsed
-                        };
-                    });
-
-                } else { // original version
-                    stack = h.stack.map(function(d) {
-                        var entities = {};
-
-                        for (var i in d.entities) {
-                            var entity = d.entities[i];
-                            entities[i] = entity === 'undefined' ? undefined : Entity(entity);
-                        }
-
-                        d.graph = Graph(stack[0].graph).load(entities);
-                        return d;
-                    });
-                }
-
-                if (loadComplete) {
-                    dispatch.change();
-                }
-
-                return history;
-            },
-
-            save: function() {
-                if (lock.locked()) context.storage(getKey('saved_history'), history.toJSON() || null);
-                return history;
-            },
-
-            clearSaved: function() {
-                context.debouncedSave.cancel();
-                if (lock.locked()) context.storage(getKey('saved_history'), null);
-                return history;
-            },
-
-            lock: function() {
-                return lock.lock();
-            },
-
-            unlock: function() {
-                lock.unlock();
-            },
-
-            // is iD not open in another window and it detects that
-            // there's a history stored in localStorage that's recoverable?
-            restorableChanges: function() {
-                return lock.locked() && !!context.storage(getKey('saved_history'));
-            },
-
-            // load history from a version stored in localStorage
-            restore: function() {
-                if (!lock.locked()) return;
-
-                var json = context.storage(getKey('saved_history'));
-                if (json) history.fromJSON(json, true);
-            },
-
-            _getKey: getKey
-
-        };
-
-        history.reset();
-
-        return d3.rebind(history, dispatch, 'on');
-    }
-
-    exports.Connection = Connection;
-    exports.Difference = Difference;
-    exports.Entity = Entity;
-    exports.Graph = Graph;
-    exports.History = History;
-    exports.Node = Node;
-    exports.Relation = Relation;
-    exports.oneWayTags = oneWayTags;
-    exports.pavedTags = pavedTags;
-    exports.interestingTag = interestingTag;
-    exports.Tree = Tree;
-    exports.Way = Way;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
\ No newline at end of file
diff --git a/js/lib/id/geo.js b/js/lib/id/geo.js
deleted file mode 100644
index 000fb46de..000000000
--- a/js/lib/id/geo.js
+++ /dev/null
@@ -1,1569 +0,0 @@
-(function (global, factory) {
-   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-   typeof define === 'function' && define.amd ? define(['exports'], factory) :
-   (factory((global.iD = global.iD || {}, global.iD.geo = global.iD.geo || {})));
-}(this, function (exports) { 'use strict';
-
-   function Extent(min, max) {
-       if (!(this instanceof Extent)) return new Extent(min, max);
-       if (min instanceof Extent) {
-           return min;
-       } else if (min && min.length === 2 && min[0].length === 2 && min[1].length === 2) {
-           this[0] = min[0];
-           this[1] = min[1];
-       } else {
-           this[0] = min        || [ Infinity,  Infinity];
-           this[1] = max || min || [-Infinity, -Infinity];
-       }
-   }
-
-   Extent.prototype = new Array(2);
-
-   _.extend(Extent.prototype, {
-       equals: function (obj) {
-           return this[0][0] === obj[0][0] &&
-               this[0][1] === obj[0][1] &&
-               this[1][0] === obj[1][0] &&
-               this[1][1] === obj[1][1];
-       },
-
-       extend: function(obj) {
-           if (!(obj instanceof Extent)) obj = new Extent(obj);
-           return Extent([Math.min(obj[0][0], this[0][0]),
-                                 Math.min(obj[0][1], this[0][1])],
-                                [Math.max(obj[1][0], this[1][0]),
-                                 Math.max(obj[1][1], this[1][1])]);
-       },
-
-       _extend: function(extent) {
-           this[0][0] = Math.min(extent[0][0], this[0][0]);
-           this[0][1] = Math.min(extent[0][1], this[0][1]);
-           this[1][0] = Math.max(extent[1][0], this[1][0]);
-           this[1][1] = Math.max(extent[1][1], this[1][1]);
-       },
-
-       area: function() {
-           return Math.abs((this[1][0] - this[0][0]) * (this[1][1] - this[0][1]));
-       },
-
-       center: function() {
-           return [(this[0][0] + this[1][0]) / 2,
-                   (this[0][1] + this[1][1]) / 2];
-       },
-
-       rectangle: function() {
-           return [this[0][0], this[0][1], this[1][0], this[1][1]];
-       },
-
-       polygon: function() {
-           return [
-               [this[0][0], this[0][1]],
-               [this[0][0], this[1][1]],
-               [this[1][0], this[1][1]],
-               [this[1][0], this[0][1]],
-               [this[0][0], this[0][1]]
-           ];
-       },
-
-       contains: function(obj) {
-           if (!(obj instanceof Extent)) obj = new Extent(obj);
-           return obj[0][0] >= this[0][0] &&
-                  obj[0][1] >= this[0][1] &&
-                  obj[1][0] <= this[1][0] &&
-                  obj[1][1] <= this[1][1];
-       },
-
-       intersects: function(obj) {
-           if (!(obj instanceof Extent)) obj = new Extent(obj);
-           return obj[0][0] <= this[1][0] &&
-                  obj[0][1] <= this[1][1] &&
-                  obj[1][0] >= this[0][0] &&
-                  obj[1][1] >= this[0][1];
-       },
-
-       intersection: function(obj) {
-           if (!this.intersects(obj)) return new Extent();
-           return new Extent([Math.max(obj[0][0], this[0][0]),
-                                     Math.max(obj[0][1], this[0][1])],
-                                    [Math.min(obj[1][0], this[1][0]),
-                                     Math.min(obj[1][1], this[1][1])]);
-       },
-
-       percentContainedIn: function(obj) {
-           if (!(obj instanceof Extent)) obj = new Extent(obj);
-           var a1 = this.intersection(obj).area(),
-               a2 = this.area();
-
-           if (a1 === Infinity || a2 === Infinity || a1 === 0 || a2 === 0) {
-               return 0;
-           } else {
-               return a1 / a2;
-           }
-       },
-
-       padByMeters: function(meters) {
-           var dLat = metersToLat(meters),
-               dLon = metersToLon(meters, this.center()[1]);
-           return Extent(
-                   [this[0][0] - dLon, this[0][1] - dLat],
-                   [this[1][0] + dLon, this[1][1] + dLat]);
-       },
-
-       toParam: function() {
-           return this.rectangle().join(',');
-       }
-
-   });
-
-   function interestingTag(key) {
-       return key !== 'attribution' &&
-           key !== 'created_by' &&
-           key !== 'source' &&
-           key !== 'odbl' &&
-           key.indexOf('tiger:') !== 0;
-
-   }
-
-   var oneWayTags = {
-       'aerialway': {
-           'chair_lift': true,
-           'mixed_lift': true,
-           't-bar': true,
-           'j-bar': true,
-           'platter': true,
-           'rope_tow': true,
-           'magic_carpet': true,
-           'yes': true
-       },
-       'highway': {
-           'motorway': true,
-           'motorway_link': true
-       },
-       'junction': {
-           'roundabout': true
-       },
-       'man_made': {
-           'piste:halfpipe': true
-       },
-       'piste:type': {
-           'downhill': true,
-           'sled': true,
-           'yes': true
-       },
-       'waterway': {
-           'river': true,
-           'stream': true
-       }
-   };
-
-   function Entity(attrs) {
-       // For prototypal inheritance.
-       if (this instanceof Entity) return;
-
-       // Create the appropriate subtype.
-       if (attrs && attrs.type) {
-           return Entity[attrs.type].apply(this, arguments);
-       } else if (attrs && attrs.id) {
-           return Entity[Entity.id.type(attrs.id)].apply(this, arguments);
-       }
-
-       // Initialize a generic Entity (used only in tests).
-       return (new Entity()).initialize(arguments);
-   }
-
-   Entity.id = function(type) {
-       return Entity.id.fromOSM(type, Entity.id.next[type]--);
-   };
-
-   Entity.id.next = {node: -1, way: -1, relation: -1};
-
-   Entity.id.fromOSM = function(type, id) {
-       return type[0] + id;
-   };
-
-   Entity.id.toOSM = function(id) {
-       return id.slice(1);
-   };
-
-   Entity.id.type = function(id) {
-       return {'n': 'node', 'w': 'way', 'r': 'relation'}[id[0]];
-   };
-
-   // A function suitable for use as the second argument to d3.selection#data().
-   Entity.key = function(entity) {
-       return entity.id + 'v' + (entity.v || 0);
-   };
-
-   Entity.prototype = {
-       tags: {},
-
-       initialize: function(sources) {
-           for (var i = 0; i < sources.length; ++i) {
-               var source = sources[i];
-               for (var prop in source) {
-                   if (Object.prototype.hasOwnProperty.call(source, prop)) {
-                       if (source[prop] === undefined) {
-                           delete this[prop];
-                       } else {
-                           this[prop] = source[prop];
-                       }
-                   }
-               }
-           }
-
-           if (!this.id && this.type) {
-               this.id = Entity.id(this.type);
-           }
-           if (!this.hasOwnProperty('visible')) {
-               this.visible = true;
-           }
-
-           if (iD.debug) {
-               Object.freeze(this);
-               Object.freeze(this.tags);
-
-               if (this.loc) Object.freeze(this.loc);
-               if (this.nodes) Object.freeze(this.nodes);
-               if (this.members) Object.freeze(this.members);
-           }
-
-           return this;
-       },
-
-       copy: function(resolver, copies) {
-           if (copies[this.id])
-               return copies[this.id];
-
-           var copy = Entity(this, {id: undefined, user: undefined, version: undefined});
-           copies[this.id] = copy;
-
-           return copy;
-       },
-
-       osmId: function() {
-           return Entity.id.toOSM(this.id);
-       },
-
-       isNew: function() {
-           return this.osmId() < 0;
-       },
-
-       update: function(attrs) {
-           return Entity(this, attrs, {v: 1 + (this.v || 0)});
-       },
-
-       mergeTags: function(tags) {
-           var merged = _.clone(this.tags), changed = false;
-           for (var k in tags) {
-               var t1 = merged[k],
-                   t2 = tags[k];
-               if (!t1) {
-                   changed = true;
-                   merged[k] = t2;
-               } else if (t1 !== t2) {
-                   changed = true;
-                   merged[k] = _.union(t1.split(/;\s*/), t2.split(/;\s*/)).join(';');
-               }
-           }
-           return changed ? this.update({tags: merged}) : this;
-       },
-
-       intersects: function(extent, resolver) {
-           return this.extent(resolver).intersects(extent);
-       },
-
-       isUsed: function(resolver) {
-           return _.without(Object.keys(this.tags), 'area').length > 0 ||
-               resolver.parentRelations(this).length > 0;
-       },
-
-       hasInterestingTags: function() {
-           return _.keys(this.tags).some(interestingTag);
-       },
-
-       isHighwayIntersection: function() {
-           return false;
-       },
-
-       deprecatedTags: function() {
-           var tags = _.toPairs(this.tags);
-           var deprecated = {};
-
-           iD.data.deprecated.forEach(function(d) {
-               var match = _.toPairs(d.old)[0];
-               tags.forEach(function(t) {
-                   if (t[0] === match[0] &&
-                       (t[1] === match[1] || match[1] === '*')) {
-                       deprecated[t[0]] = t[1];
-                   }
-               });
-           });
-
-           return deprecated;
-       }
-   };
-
-   function Way() {
-       if (!(this instanceof Way)) {
-           return (new Way()).initialize(arguments);
-       } else if (arguments.length) {
-           this.initialize(arguments);
-       }
-   }
-
-   Entity.way = Way;
-
-   Way.prototype = Object.create(Entity.prototype);
-
-   _.extend(Way.prototype, {
-       type: 'way',
-       nodes: [],
-
-       copy: function(resolver, copies) {
-           if (copies[this.id])
-               return copies[this.id];
-
-           var copy = Entity.prototype.copy.call(this, resolver, copies);
-
-           var nodes = this.nodes.map(function(id) {
-               return resolver.entity(id).copy(resolver, copies).id;
-           });
-
-           copy = copy.update({nodes: nodes});
-           copies[this.id] = copy;
-
-           return copy;
-       },
-
-       extent: function(resolver) {
-           return resolver.transient(this, 'extent', function() {
-               var extent = Extent();
-               for (var i = 0; i < this.nodes.length; i++) {
-                   var node = resolver.hasEntity(this.nodes[i]);
-                   if (node) {
-                       extent._extend(node.extent());
-                   }
-               }
-               return extent;
-           });
-       },
-
-       first: function() {
-           return this.nodes[0];
-       },
-
-       last: function() {
-           return this.nodes[this.nodes.length - 1];
-       },
-
-       contains: function(node) {
-           return this.nodes.indexOf(node) >= 0;
-       },
-
-       affix: function(node) {
-           if (this.nodes[0] === node) return 'prefix';
-           if (this.nodes[this.nodes.length - 1] === node) return 'suffix';
-       },
-
-       layer: function() {
-           // explicit layer tag, clamp between -10, 10..
-           if (this.tags.layer !== undefined) {
-               return Math.max(-10, Math.min(+(this.tags.layer), 10));
-           }
-
-           // implied layer tag..
-           if (this.tags.location === 'overground') return 1;
-           if (this.tags.location === 'underground') return -1;
-           if (this.tags.location === 'underwater') return -10;
-
-           if (this.tags.power === 'line') return 10;
-           if (this.tags.power === 'minor_line') return 10;
-           if (this.tags.aerialway) return 10;
-           if (this.tags.bridge) return 1;
-           if (this.tags.cutting) return -1;
-           if (this.tags.tunnel) return -1;
-           if (this.tags.waterway) return -1;
-           if (this.tags.man_made === 'pipeline') return -10;
-           if (this.tags.boundary) return -10;
-           return 0;
-       },
-
-       isOneWay: function() {
-           // explicit oneway tag..
-           if (['yes', '1', '-1'].indexOf(this.tags.oneway) !== -1) { return true; }
-           if (['no', '0'].indexOf(this.tags.oneway) !== -1) { return false; }
-
-           // implied oneway tag..
-           for (var key in this.tags) {
-               if (key in oneWayTags && (this.tags[key] in oneWayTags[key]))
-                   return true;
-           }
-           return false;
-       },
-
-       isClosed: function() {
-           return this.nodes.length > 0 && this.first() === this.last();
-       },
-
-       isConvex: function(resolver) {
-           if (!this.isClosed() || this.isDegenerate()) return null;
-
-           var nodes = _.uniq(resolver.childNodes(this)),
-               coords = _.map(nodes, 'loc'),
-               curr = 0, prev = 0;
-
-           for (var i = 0; i < coords.length; i++) {
-               var o = coords[(i+1) % coords.length],
-                   a = coords[i],
-                   b = coords[(i+2) % coords.length],
-                   res = cross(o, a, b);
-
-               curr = (res > 0) ? 1 : (res < 0) ? -1 : 0;
-               if (curr === 0) {
-                   continue;
-               } else if (prev && curr !== prev) {
-                   return false;
-               }
-               prev = curr;
-           }
-           return true;
-       },
-
-       isArea: function() {
-           if (this.tags.area === 'yes')
-               return true;
-           if (!this.isClosed() || this.tags.area === 'no')
-               return false;
-           for (var key in this.tags)
-               if (key in iD.areaKeys && !(this.tags[key] in iD.areaKeys[key]))
-                   return true;
-           return false;
-       },
-
-       isDegenerate: function() {
-           return _.uniq(this.nodes).length < (this.isArea() ? 3 : 2);
-       },
-
-       areAdjacent: function(n1, n2) {
-           for (var i = 0; i < this.nodes.length; i++) {
-               if (this.nodes[i] === n1) {
-                   if (this.nodes[i - 1] === n2) return true;
-                   if (this.nodes[i + 1] === n2) return true;
-               }
-           }
-           return false;
-       },
-
-       geometry: function(graph) {
-           return graph.transient(this, 'geometry', function() {
-               return this.isArea() ? 'area' : 'line';
-           });
-       },
-
-       addNode: function(id, index) {
-           var nodes = this.nodes.slice();
-           nodes.splice(index === undefined ? nodes.length : index, 0, id);
-           return this.update({nodes: nodes});
-       },
-
-       updateNode: function(id, index) {
-           var nodes = this.nodes.slice();
-           nodes.splice(index, 1, id);
-           return this.update({nodes: nodes});
-       },
-
-       replaceNode: function(needle, replacement) {
-           if (this.nodes.indexOf(needle) < 0)
-               return this;
-
-           var nodes = this.nodes.slice();
-           for (var i = 0; i < nodes.length; i++) {
-               if (nodes[i] === needle) {
-                   nodes[i] = replacement;
-               }
-           }
-           return this.update({nodes: nodes});
-       },
-
-       removeNode: function(id) {
-           var nodes = [];
-
-           for (var i = 0; i < this.nodes.length; i++) {
-               var node = this.nodes[i];
-               if (node !== id && nodes[nodes.length - 1] !== node) {
-                   nodes.push(node);
-               }
-           }
-
-           // Preserve circularity
-           if (this.nodes.length > 1 && this.first() === id && this.last() === id && nodes[nodes.length - 1] !== nodes[0]) {
-               nodes.push(nodes[0]);
-           }
-
-           return this.update({nodes: nodes});
-       },
-
-       asJXON: function(changeset_id) {
-           var r = {
-               way: {
-                   '@id': this.osmId(),
-                   '@version': this.version || 0,
-                   nd: _.map(this.nodes, function(id) {
-                       return { keyAttributes: { ref: Entity.id.toOSM(id) } };
-                   }),
-                   tag: _.map(this.tags, function(v, k) {
-                       return { keyAttributes: { k: k, v: v } };
-                   })
-               }
-           };
-           if (changeset_id) r.way['@changeset'] = changeset_id;
-           return r;
-       },
-
-       asGeoJSON: function(resolver) {
-           return resolver.transient(this, 'GeoJSON', function() {
-               var coordinates = _.map(resolver.childNodes(this), 'loc');
-               if (this.isArea() && this.isClosed()) {
-                   return {
-                       type: 'Polygon',
-                       coordinates: [coordinates]
-                   };
-               } else {
-                   return {
-                       type: 'LineString',
-                       coordinates: coordinates
-                   };
-               }
-           });
-       },
-
-       area: function(resolver) {
-           return resolver.transient(this, 'area', function() {
-               var nodes = resolver.childNodes(this);
-
-               var json = {
-                   type: 'Polygon',
-                   coordinates: [_.map(nodes, 'loc')]
-               };
-
-               if (!this.isClosed() && nodes.length) {
-                   json.coordinates[0].push(nodes[0].loc);
-               }
-
-               var area = d3.geo.area(json);
-
-               // Heuristic for detecting counterclockwise winding order. Assumes
-               // that OpenStreetMap polygons are not hemisphere-spanning.
-               if (area > 2 * Math.PI) {
-                   json.coordinates[0] = json.coordinates[0].reverse();
-                   area = d3.geo.area(json);
-               }
-
-               return isNaN(area) ? 0 : area;
-           });
-       }
-   });
-
-   function Relation() {
-       if (!(this instanceof Relation)) {
-           return (new Relation()).initialize(arguments);
-       } else if (arguments.length) {
-           this.initialize(arguments);
-       }
-   }
-   Entity.relation = Relation;
-
-   Relation.prototype = Object.create(Entity.prototype);
-
-   Relation.creationOrder = function(a, b) {
-       var aId = parseInt(Entity.id.toOSM(a.id), 10);
-       var bId = parseInt(Entity.id.toOSM(b.id), 10);
-
-       if (aId < 0 || bId < 0) return aId - bId;
-       return bId - aId;
-   };
-
-   _.extend(Relation.prototype, {
-       type: 'relation',
-       members: [],
-
-       copy: function(resolver, copies) {
-           if (copies[this.id])
-               return copies[this.id];
-
-           var copy = Entity.prototype.copy.call(this, resolver, copies);
-
-           var members = this.members.map(function(member) {
-               return _.extend({}, member, {id: resolver.entity(member.id).copy(resolver, copies).id});
-           });
-
-           copy = copy.update({members: members});
-           copies[this.id] = copy;
-
-           return copy;
-       },
-
-       extent: function(resolver, memo) {
-           return resolver.transient(this, 'extent', function() {
-               if (memo && memo[this.id]) return Extent();
-               memo = memo || {};
-               memo[this.id] = true;
-
-               var extent = Extent();
-               for (var i = 0; i < this.members.length; i++) {
-                   var member = resolver.hasEntity(this.members[i].id);
-                   if (member) {
-                       extent._extend(member.extent(resolver, memo));
-                   }
-               }
-               return extent;
-           });
-       },
-
-       geometry: function(graph) {
-           return graph.transient(this, 'geometry', function() {
-               return this.isMultipolygon() ? 'area' : 'relation';
-           });
-       },
-
-       isDegenerate: function() {
-           return this.members.length === 0;
-       },
-
-       // Return an array of members, each extended with an 'index' property whose value
-       // is the member index.
-       indexedMembers: function() {
-           var result = new Array(this.members.length);
-           for (var i = 0; i < this.members.length; i++) {
-               result[i] = _.extend({}, this.members[i], {index: i});
-           }
-           return result;
-       },
-
-       // Return the first member with the given role. A copy of the member object
-       // is returned, extended with an 'index' property whose value is the member index.
-       memberByRole: function(role) {
-           for (var i = 0; i < this.members.length; i++) {
-               if (this.members[i].role === role) {
-                   return _.extend({}, this.members[i], {index: i});
-               }
-           }
-       },
-
-       // Return the first member with the given id. A copy of the member object
-       // is returned, extended with an 'index' property whose value is the member index.
-       memberById: function(id) {
-           for (var i = 0; i < this.members.length; i++) {
-               if (this.members[i].id === id) {
-                   return _.extend({}, this.members[i], {index: i});
-               }
-           }
-       },
-
-       // Return the first member with the given id and role. A copy of the member object
-       // is returned, extended with an 'index' property whose value is the member index.
-       memberByIdAndRole: function(id, role) {
-           for (var i = 0; i < this.members.length; i++) {
-               if (this.members[i].id === id && this.members[i].role === role) {
-                   return _.extend({}, this.members[i], {index: i});
-               }
-           }
-       },
-
-       addMember: function(member, index) {
-           var members = this.members.slice();
-           members.splice(index === undefined ? members.length : index, 0, member);
-           return this.update({members: members});
-       },
-
-       updateMember: function(member, index) {
-           var members = this.members.slice();
-           members.splice(index, 1, _.extend({}, members[index], member));
-           return this.update({members: members});
-       },
-
-       removeMember: function(index) {
-           var members = this.members.slice();
-           members.splice(index, 1);
-           return this.update({members: members});
-       },
-
-       removeMembersWithID: function(id) {
-           var members = _.reject(this.members, function(m) { return m.id === id; });
-           return this.update({members: members});
-       },
-
-       // Wherever a member appears with id `needle.id`, replace it with a member
-       // with id `replacement.id`, type `replacement.type`, and the original role,
-       // unless a member already exists with that id and role. Return an updated
-       // relation.
-       replaceMember: function(needle, replacement) {
-           if (!this.memberById(needle.id))
-               return this;
-
-           var members = [];
-
-           for (var i = 0; i < this.members.length; i++) {
-               var member = this.members[i];
-               if (member.id !== needle.id) {
-                   members.push(member);
-               } else if (!this.memberByIdAndRole(replacement.id, member.role)) {
-                   members.push({id: replacement.id, type: replacement.type, role: member.role});
-               }
-           }
-
-           return this.update({members: members});
-       },
-
-       asJXON: function(changeset_id) {
-           var r = {
-               relation: {
-                   '@id': this.osmId(),
-                   '@version': this.version || 0,
-                   member: _.map(this.members, function(member) {
-                       return { keyAttributes: { type: member.type, role: member.role, ref: Entity.id.toOSM(member.id) } };
-                   }),
-                   tag: _.map(this.tags, function(v, k) {
-                       return { keyAttributes: { k: k, v: v } };
-                   })
-               }
-           };
-           if (changeset_id) r.relation['@changeset'] = changeset_id;
-           return r;
-       },
-
-       asGeoJSON: function(resolver) {
-           return resolver.transient(this, 'GeoJSON', function () {
-               if (this.isMultipolygon()) {
-                   return {
-                       type: 'MultiPolygon',
-                       coordinates: this.multipolygon(resolver)
-                   };
-               } else {
-                   return {
-                       type: 'FeatureCollection',
-                       properties: this.tags,
-                       features: this.members.map(function (member) {
-                           return _.extend({role: member.role}, resolver.entity(member.id).asGeoJSON(resolver));
-                       })
-                   };
-               }
-           });
-       },
-
-       area: function(resolver) {
-           return resolver.transient(this, 'area', function() {
-               return d3.geo.area(this.asGeoJSON(resolver));
-           });
-       },
-
-       isMultipolygon: function() {
-           return this.tags.type === 'multipolygon';
-       },
-
-       isComplete: function(resolver) {
-           for (var i = 0; i < this.members.length; i++) {
-               if (!resolver.hasEntity(this.members[i].id)) {
-                   return false;
-               }
-           }
-           return true;
-       },
-
-       isRestriction: function() {
-           return !!(this.tags.type && this.tags.type.match(/^restriction:?/));
-       },
-
-       // Returns an array [A0, ... An], each Ai being an array of node arrays [Nds0, ... Ndsm],
-       // where Nds0 is an outer ring and subsequent Ndsi's (if any i > 0) being inner rings.
-       //
-       // This corresponds to the structure needed for rendering a multipolygon path using a
-       // `evenodd` fill rule, as well as the structure of a GeoJSON MultiPolygon geometry.
-       //
-       // In the case of invalid geometries, this function will still return a result which
-       // includes the nodes of all way members, but some Nds may be unclosed and some inner
-       // rings not matched with the intended outer ring.
-       //
-       multipolygon: function(resolver) {
-           var outers = this.members.filter(function(m) { return 'outer' === (m.role || 'outer'); }),
-               inners = this.members.filter(function(m) { return 'inner' === m.role; });
-
-           outers = joinWays(outers, resolver);
-           inners = joinWays(inners, resolver);
-
-           outers = outers.map(function(outer) { return _.map(outer.nodes, 'loc'); });
-           inners = inners.map(function(inner) { return _.map(inner.nodes, 'loc'); });
-
-           var result = outers.map(function(o) {
-               // Heuristic for detecting counterclockwise winding order. Assumes
-               // that OpenStreetMap polygons are not hemisphere-spanning.
-               return [d3.geo.area({type: 'Polygon', coordinates: [o]}) > 2 * Math.PI ? o.reverse() : o];
-           });
-
-           function findOuter(inner) {
-               var o, outer;
-
-               for (o = 0; o < outers.length; o++) {
-                   outer = outers[o];
-                   if (polygonContainsPolygon(outer, inner))
-                       return o;
-               }
-
-               for (o = 0; o < outers.length; o++) {
-                   outer = outers[o];
-                   if (polygonIntersectsPolygon(outer, inner))
-                       return o;
-               }
-           }
-
-           for (var i = 0; i < inners.length; i++) {
-               var inner = inners[i];
-
-               if (d3.geo.area({type: 'Polygon', coordinates: [inner]}) < 2 * Math.PI) {
-                   inner = inner.reverse();
-               }
-
-               var o = findOuter(inners[i]);
-               if (o !== undefined)
-                   result[o].push(inners[i]);
-               else
-                   result.push([inners[i]]); // Invalid geometry
-           }
-
-           return result;
-       }
-   });
-
-   function Node() {
-       if (!(this instanceof Node)) {
-           return (new Node()).initialize(arguments);
-       } else if (arguments.length) {
-           this.initialize(arguments);
-       }
-   }
-
-   Entity.node = Node;
-
-   Node.prototype = Object.create(Entity.prototype);
-
-   _.extend(Node.prototype, {
-       type: 'node',
-
-       extent: function() {
-           return new Extent(this.loc);
-       },
-
-       geometry: function(graph) {
-           return graph.transient(this, 'geometry', function() {
-               return graph.isPoi(this) ? 'point' : 'vertex';
-           });
-       },
-
-       move: function(loc) {
-           return this.update({loc: loc});
-       },
-
-       isIntersection: function(resolver) {
-           return resolver.transient(this, 'isIntersection', function() {
-               return resolver.parentWays(this).filter(function(parent) {
-                   return (parent.tags.highway ||
-                       parent.tags.waterway ||
-                       parent.tags.railway ||
-                       parent.tags.aeroway) &&
-                       parent.geometry(resolver) === 'line';
-               }).length > 1;
-           });
-       },
-
-       isHighwayIntersection: function(resolver) {
-           return resolver.transient(this, 'isHighwayIntersection', function() {
-               return resolver.parentWays(this).filter(function(parent) {
-                   return parent.tags.highway && parent.geometry(resolver) === 'line';
-               }).length > 1;
-           });
-       },
-
-       asJXON: function(changeset_id) {
-           var r = {
-               node: {
-                   '@id': this.osmId(),
-                   '@lon': this.loc[0],
-                   '@lat': this.loc[1],
-                   '@version': (this.version || 0),
-                   tag: _.map(this.tags, function(v, k) {
-                       return { keyAttributes: { k: k, v: v } };
-                   })
-               }
-           };
-           if (changeset_id) r.node['@changeset'] = changeset_id;
-           return r;
-       },
-
-       asGeoJSON: function() {
-           return {
-               type: 'Point',
-               coordinates: this.loc
-           };
-       }
-   });
-
-   function Turn(turn) {
-       if (!(this instanceof Turn))
-           return new Turn(turn);
-       _.extend(this, turn);
-   }
-
-   function Intersection(graph, vertexId) {
-       var vertex = graph.entity(vertexId),
-           parentWays = graph.parentWays(vertex),
-           coincident = [],
-           highways = {};
-
-       function addHighway(way, adjacentNodeId) {
-           if (highways[adjacentNodeId]) {
-               coincident.push(adjacentNodeId);
-           } else {
-               highways[adjacentNodeId] = way;
-           }
-       }
-
-       // Pre-split ways that would need to be split in
-       // order to add a restriction. The real split will
-       // happen when the restriction is added.
-       parentWays.forEach(function(way) {
-           if (!way.tags.highway || way.isArea() || way.isDegenerate())
-               return;
-
-           var isFirst = (vertexId === way.first()),
-               isLast = (vertexId === way.last()),
-               isAffix = (isFirst || isLast),
-               isClosingNode = (isFirst && isLast);
-
-           if (isAffix && !isClosingNode) {
-               var index = (isFirst ? 1 : way.nodes.length - 2);
-               addHighway(way, way.nodes[index]);
-
-           } else {
-               var splitIndex, wayA, wayB, indexA, indexB;
-               if (isClosingNode) {
-                   splitIndex = Math.ceil(way.nodes.length / 2);  // split at midpoint
-                   wayA = Way({id: way.id + '-a', tags: way.tags, nodes: way.nodes.slice(0, splitIndex)});
-                   wayB = Way({id: way.id + '-b', tags: way.tags, nodes: way.nodes.slice(splitIndex)});
-                   indexA = 1;
-                   indexB = way.nodes.length - 2;
-               } else {
-                   splitIndex = _.indexOf(way.nodes, vertex.id, 1);  // split at vertexid
-                   wayA = Way({id: way.id + '-a', tags: way.tags, nodes: way.nodes.slice(0, splitIndex + 1)});
-                   wayB = Way({id: way.id + '-b', tags: way.tags, nodes: way.nodes.slice(splitIndex)});
-                   indexA = splitIndex - 1;
-                   indexB = splitIndex + 1;
-               }
-               graph = graph.replace(wayA).replace(wayB);
-               addHighway(wayA, way.nodes[indexA]);
-               addHighway(wayB, way.nodes[indexB]);
-           }
-       });
-
-       // remove any ways from this intersection that are coincident
-       // (i.e. any adjacent node used by more than one intersecting way)
-       coincident.forEach(function (n) {
-           delete highways[n];
-       });
-
-
-       var intersection = {
-           highways: highways,
-           ways: _.values(highways),
-           graph: graph
-       };
-
-       intersection.adjacentNodeId = function(fromWayId) {
-           return _.find(_.keys(highways), function(k) {
-               return highways[k].id === fromWayId;
-           });
-       };
-
-       intersection.turns = function(fromNodeId) {
-           var start = highways[fromNodeId];
-           if (!start)
-               return [];
-
-           if (start.first() === vertex.id && start.tags.oneway === 'yes')
-               return [];
-           if (start.last() === vertex.id && start.tags.oneway === '-1')
-               return [];
-
-           function withRestriction(turn) {
-               graph.parentRelations(graph.entity(turn.from.way)).forEach(function(relation) {
-                   if (relation.tags.type !== 'restriction')
-                       return;
-
-                   var f = relation.memberByRole('from'),
-                       t = relation.memberByRole('to'),
-                       v = relation.memberByRole('via');
-
-                   if (f && f.id === turn.from.way &&
-                       v && v.id === turn.via.node &&
-                       t && t.id === turn.to.way) {
-                       turn.restriction = relation.id;
-                   } else if (/^only_/.test(relation.tags.restriction) &&
-                       f && f.id === turn.from.way &&
-                       v && v.id === turn.via.node &&
-                       t && t.id !== turn.to.way) {
-                       turn.restriction = relation.id;
-                       turn.indirect_restriction = true;
-                   }
-               });
-
-               return Turn(turn);
-           }
-
-           var from = {
-                   node: fromNodeId,
-                   way: start.id.split(/-(a|b)/)[0]
-               },
-               via = { node: vertex.id },
-               turns = [];
-
-           _.each(highways, function(end, adjacentNodeId) {
-               if (end === start)
-                   return;
-
-               // backward
-               if (end.first() !== vertex.id && end.tags.oneway !== 'yes') {
-                   turns.push(withRestriction({
-                       from: from,
-                       via: via,
-                       to: {
-                           node: adjacentNodeId,
-                           way: end.id.split(/-(a|b)/)[0]
-                       }
-                   }));
-               }
-
-               // forward
-               if (end.last() !== vertex.id && end.tags.oneway !== '-1') {
-                   turns.push(withRestriction({
-                       from: from,
-                       via: via,
-                       to: {
-                           node: adjacentNodeId,
-                           way: end.id.split(/-(a|b)/)[0]
-                       }
-                   }));
-               }
-
-           });
-
-           // U-turn
-           if (start.tags.oneway !== 'yes' && start.tags.oneway !== '-1') {
-               turns.push(withRestriction({
-                   from: from,
-                   via: via,
-                   to: from,
-                   u: true
-               }));
-           }
-
-           return turns;
-       };
-
-       return intersection;
-   }
-
-
-   function inferRestriction(graph, from, via, to, projection) {
-       var fromWay = graph.entity(from.way),
-           fromNode = graph.entity(from.node),
-           toWay = graph.entity(to.way),
-           toNode = graph.entity(to.node),
-           viaNode = graph.entity(via.node),
-           fromOneWay = (fromWay.tags.oneway === 'yes' && fromWay.last() === via.node) ||
-               (fromWay.tags.oneway === '-1' && fromWay.first() === via.node),
-           toOneWay = (toWay.tags.oneway === 'yes' && toWay.first() === via.node) ||
-               (toWay.tags.oneway === '-1' && toWay.last() === via.node),
-           angle = getAngle(viaNode, fromNode, projection) -
-                   getAngle(viaNode, toNode, projection);
-
-       angle = angle * 180 / Math.PI;
-
-       while (angle < 0)
-           angle += 360;
-
-       if (fromNode === toNode)
-           return 'no_u_turn';
-       if ((angle < 23 || angle > 336) && fromOneWay && toOneWay)
-           return 'no_u_turn';
-       if (angle < 158)
-           return 'no_right_turn';
-       if (angle > 202)
-           return 'no_left_turn';
-
-       return 'no_straight_on';
-   }
-
-   // For fixing up rendering of multipolygons with tags on the outer member.
-   // https://github.com/openstreetmap/iD/issues/613
-   function isSimpleMultipolygonOuterMember(entity, graph) {
-       if (entity.type !== 'way')
-           return false;
-
-       var parents = graph.parentRelations(entity);
-       if (parents.length !== 1)
-           return false;
-
-       var parent = parents[0];
-       if (!parent.isMultipolygon() || Object.keys(parent.tags).length > 1)
-           return false;
-
-       var members = parent.members, member;
-       for (var i = 0; i < members.length; i++) {
-           member = members[i];
-           if (member.id === entity.id && member.role && member.role !== 'outer')
-               return false; // Not outer member
-           if (member.id !== entity.id && (!member.role || member.role === 'outer'))
-               return false; // Not a simple multipolygon
-       }
-
-       return parent;
-   }
-
-   function simpleMultipolygonOuterMember(entity, graph) {
-       if (entity.type !== 'way')
-           return false;
-
-       var parents = graph.parentRelations(entity);
-       if (parents.length !== 1)
-           return false;
-
-       var parent = parents[0];
-       if (!parent.isMultipolygon() || Object.keys(parent.tags).length > 1)
-           return false;
-
-       var members = parent.members, member, outerMember;
-       for (var i = 0; i < members.length; i++) {
-           member = members[i];
-           if (!member.role || member.role === 'outer') {
-               if (outerMember)
-                   return false; // Not a simple multipolygon
-               outerMember = member;
-           }
-       }
-
-       return outerMember && graph.hasEntity(outerMember.id);
-   }
-
-   // Join `array` into sequences of connecting ways.
-   //
-   // Segments which share identical start/end nodes will, as much as possible,
-   // be connected with each other.
-   //
-   // The return value is a nested array. Each constituent array contains elements
-   // of `array` which have been determined to connect. Each consitituent array
-   // also has a `nodes` property whose value is an ordered array of member nodes,
-   // with appropriate order reversal and start/end coordinate de-duplication.
-   //
-   // Members of `array` must have, at minimum, `type` and `id` properties.
-   // Thus either an array of `iD.Way`s or a relation member array may be
-   // used.
-   //
-   // If an member has a `tags` property, its tags will be reversed via
-   // `iD.actions.Reverse` in the output.
-   //
-   // Incomplete members (those for which `graph.hasEntity(element.id)` returns
-   // false) and non-way members are ignored.
-   //
-   function joinWays(array, graph) {
-       var joined = [], member, current, nodes, first, last, i, how, what;
-
-       array = array.filter(function(member) {
-           return member.type === 'way' && graph.hasEntity(member.id);
-       });
-
-       function resolve(member) {
-           return graph.childNodes(graph.entity(member.id));
-       }
-
-       function reverse(member) {
-           return member.tags ? iD.actions.Reverse(member.id, {reverseOneway: true})(graph).entity(member.id) : member;
-       }
-
-       while (array.length) {
-           member = array.shift();
-           current = [member];
-           current.nodes = nodes = resolve(member).slice();
-           joined.push(current);
-
-           while (array.length && _.first(nodes) !== _.last(nodes)) {
-               first = _.first(nodes);
-               last  = _.last(nodes);
-
-               for (i = 0; i < array.length; i++) {
-                   member = array[i];
-                   what = resolve(member);
-
-                   if (last === _.first(what)) {
-                       how  = nodes.push;
-                       what = what.slice(1);
-                       break;
-                   } else if (last === _.last(what)) {
-                       how  = nodes.push;
-                       what = what.slice(0, -1).reverse();
-                       member = reverse(member);
-                       break;
-                   } else if (first === _.last(what)) {
-                       how  = nodes.unshift;
-                       what = what.slice(0, -1);
-                       break;
-                   } else if (first === _.first(what)) {
-                       how  = nodes.unshift;
-                       what = what.slice(1).reverse();
-                       member = reverse(member);
-                       break;
-                   } else {
-                       what = how = null;
-                   }
-               }
-
-               if (!what)
-                   break; // No more joinable ways.
-
-               how.apply(current, [member]);
-               how.apply(nodes, what);
-
-               array.splice(i, 1);
-           }
-       }
-
-       return joined;
-   }
-
-   /*
-       Bypasses features of D3's default projection stream pipeline that are unnecessary:
-       * Antimeridian clipping
-       * Spherical rotation
-       * Resampling
-   */
-   function RawMercator() {
-       var project = d3.geo.mercator.raw,
-           k = 512 / Math.PI, // scale
-           x = 0, y = 0, // translate
-           clipExtent = [[0, 0], [0, 0]];
-
-       function projection(point) {
-           point = project(point[0] * Math.PI / 180, point[1] * Math.PI / 180);
-           return [point[0] * k + x, y - point[1] * k];
-       }
-
-       projection.invert = function(point) {
-           point = project.invert((point[0] - x) / k, (y - point[1]) / k);
-           return point && [point[0] * 180 / Math.PI, point[1] * 180 / Math.PI];
-       };
-
-       projection.scale = function(_) {
-           if (!arguments.length) return k;
-           k = +_;
-           return projection;
-       };
-
-       projection.translate = function(_) {
-           if (!arguments.length) return [x, y];
-           x = +_[0];
-           y = +_[1];
-           return projection;
-       };
-
-       projection.clipExtent = function(_) {
-           if (!arguments.length) return clipExtent;
-           clipExtent = _;
-           return projection;
-       };
-
-       projection.stream = d3.geo.transform({
-           point: function(x, y) {
-               x = projection([x, y]);
-               this.stream.point(x[0], x[1]);
-           }
-       }).stream;
-
-       return projection;
-   }
-
-   function roundCoords(c) {
-       return [Math.floor(c[0]), Math.floor(c[1])];
-   }
-
-   function interp(p1, p2, t) {
-       return [p1[0] + (p2[0] - p1[0]) * t,
-               p1[1] + (p2[1] - p1[1]) * t];
-   }
-
-   // 2D cross product of OA and OB vectors, i.e. z-component of their 3D cross product.
-   // Returns a positive value, if OAB makes a counter-clockwise turn,
-   // negative for clockwise turn, and zero if the points are collinear.
-   function cross(o, a, b) {
-       return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
-   }
-
-   // http://jsperf.com/id-dist-optimization
-   function euclideanDistance(a, b) {
-       var x = a[0] - b[0], y = a[1] - b[1];
-       return Math.sqrt((x * x) + (y * y));
-   }
-
-   // using WGS84 polar radius (6356752.314245179 m)
-   // const = 2 * PI * r / 360
-   function latToMeters(dLat) {
-       return dLat * 110946.257617;
-   }
-
-   // using WGS84 equatorial radius (6378137.0 m)
-   // const = 2 * PI * r / 360
-   function lonToMeters(dLon, atLat) {
-       return Math.abs(atLat) >= 90 ? 0 :
-           dLon * 111319.490793 * Math.abs(Math.cos(atLat * (Math.PI/180)));
-   }
-
-   // using WGS84 polar radius (6356752.314245179 m)
-   // const = 2 * PI * r / 360
-   function metersToLat(m) {
-       return m / 110946.257617;
-   }
-
-   // using WGS84 equatorial radius (6378137.0 m)
-   // const = 2 * PI * r / 360
-   function metersToLon(m, atLat) {
-       return Math.abs(atLat) >= 90 ? 0 :
-           m / 111319.490793 / Math.abs(Math.cos(atLat * (Math.PI/180)));
-   }
-
-   function offsetToMeters(offset) {
-       var equatRadius = 6356752.314245179,
-           polarRadius = 6378137.0,
-           tileSize = 256;
-
-       return [
-           offset[0] * 2 * Math.PI * equatRadius / tileSize,
-           -offset[1] * 2 * Math.PI * polarRadius / tileSize
-       ];
-   }
-
-   function metersToOffset(meters) {
-       var equatRadius = 6356752.314245179,
-           polarRadius = 6378137.0,
-           tileSize = 256;
-
-       return [
-           meters[0] * tileSize / (2 * Math.PI * equatRadius),
-           -meters[1] * tileSize / (2 * Math.PI * polarRadius)
-       ];
-   }
-
-   // Equirectangular approximation of spherical distances on Earth
-   function sphericalDistance(a, b) {
-       var x = lonToMeters(a[0] - b[0], (a[1] + b[1]) / 2),
-           y = latToMeters(a[1] - b[1]);
-       return Math.sqrt((x * x) + (y * y));
-   }
-
-   function edgeEqual(a, b) {
-       return (a[0] === b[0] && a[1] === b[1]) ||
-           (a[0] === b[1] && a[1] === b[0]);
-   }
-
-   // Return the counterclockwise angle in the range (-pi, pi)
-   // between the positive X axis and the line intersecting a and b.
-   function getAngle(a, b, projection) {
-       a = projection(a.loc);
-       b = projection(b.loc);
-       return Math.atan2(b[1] - a[1], b[0] - a[0]);
-   }
-
-   // Choose the edge with the minimal distance from `point` to its orthogonal
-   // projection onto that edge, if such a projection exists, or the distance to
-   // the closest vertex on that edge. Returns an object with the `index` of the
-   // chosen edge, the chosen `loc` on that edge, and the `distance` to to it.
-   function chooseEdge(nodes, point, projection) {
-       var dist = euclideanDistance,
-           points = nodes.map(function(n) { return projection(n.loc); }),
-           min = Infinity,
-           idx, loc;
-
-       function dot(p, q) {
-           return p[0] * q[0] + p[1] * q[1];
-       }
-
-       for (var i = 0; i < points.length - 1; i++) {
-           var o = points[i],
-               s = [points[i + 1][0] - o[0],
-                    points[i + 1][1] - o[1]],
-               v = [point[0] - o[0],
-                    point[1] - o[1]],
-               proj = dot(v, s) / dot(s, s),
-               p;
-
-           if (proj < 0) {
-               p = o;
-           } else if (proj > 1) {
-               p = points[i + 1];
-           } else {
-               p = [o[0] + proj * s[0], o[1] + proj * s[1]];
-           }
-
-           var d = dist(p, point);
-           if (d < min) {
-               min = d;
-               idx = i + 1;
-               loc = projection.invert(p);
-           }
-       }
-
-       return {
-           index: idx,
-           distance: min,
-           loc: loc
-       };
-   }
-
-   // Return the intersection point of 2 line segments.
-   // From https://github.com/pgkelley4/line-segments-intersect
-   // This uses the vector cross product approach described below:
-   //  http://stackoverflow.com/a/565282/786339
-   function lineIntersection(a, b) {
-       function subtractPoints(point1, point2) {
-           return [point1[0] - point2[0], point1[1] - point2[1]];
-       }
-       function crossProduct(point1, point2) {
-           return point1[0] * point2[1] - point1[1] * point2[0];
-       }
-
-       var p = [a[0][0], a[0][1]],
-           p2 = [a[1][0], a[1][1]],
-           q = [b[0][0], b[0][1]],
-           q2 = [b[1][0], b[1][1]],
-           r = subtractPoints(p2, p),
-           s = subtractPoints(q2, q),
-           uNumerator = crossProduct(subtractPoints(q, p), r),
-           denominator = crossProduct(r, s);
-
-       if (uNumerator && denominator) {
-           var u = uNumerator / denominator,
-               t = crossProduct(subtractPoints(q, p), s) / denominator;
-
-           if ((t >= 0) && (t <= 1) && (u >= 0) && (u <= 1)) {
-               return interp(p, p2, t);
-           }
-       }
-
-       return null;
-   }
-
-   function pathIntersections(path1, path2) {
-       var intersections = [];
-       for (var i = 0; i < path1.length - 1; i++) {
-           for (var j = 0; j < path2.length - 1; j++) {
-               var a = [ path1[i], path1[i+1] ],
-                   b = [ path2[j], path2[j+1] ],
-                   hit = lineIntersection(a, b);
-               if (hit) intersections.push(hit);
-           }
-       }
-       return intersections;
-   }
-
-   // Return whether point is contained in polygon.
-   //
-   // `point` should be a 2-item array of coordinates.
-   // `polygon` should be an array of 2-item arrays of coordinates.
-   //
-   // From https://github.com/substack/point-in-polygon.
-   // ray-casting algorithm based on
-   // http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
-   //
-   function pointInPolygon(point, polygon) {
-       var x = point[0],
-           y = point[1],
-           inside = false;
-
-       for (var i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-           var xi = polygon[i][0], yi = polygon[i][1];
-           var xj = polygon[j][0], yj = polygon[j][1];
-
-           var intersect = ((yi > y) !== (yj > y)) &&
-               (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
-           if (intersect) inside = !inside;
-       }
-
-       return inside;
-   }
-
-   function polygonContainsPolygon(outer, inner) {
-       return _.every(inner, function(point) {
-           return pointInPolygon(point, outer);
-       });
-   }
-
-   function polygonIntersectsPolygon(outer, inner, checkSegments) {
-       function testSegments(outer, inner) {
-           for (var i = 0; i < outer.length - 1; i++) {
-               for (var j = 0; j < inner.length - 1; j++) {
-                   var a = [ outer[i], outer[i+1] ],
-                       b = [ inner[j], inner[j+1] ];
-                   if (lineIntersection(a, b)) return true;
-               }
-           }
-           return false;
-       }
-
-       function testPoints(outer, inner) {
-           return _.some(inner, function(point) {
-               return pointInPolygon(point, outer);
-           });
-       }
-
-      return testPoints(outer, inner) || (!!checkSegments && testSegments(outer, inner));
-   }
-
-   function pathLength(path) {
-       var length = 0,
-           dx, dy;
-       for (var i = 0; i < path.length - 1; i++) {
-           dx = path[i][0] - path[i + 1][0];
-           dy = path[i][1] - path[i + 1][1];
-           length += Math.sqrt(dx * dx + dy * dy);
-       }
-       return length;
-   }
-
-   exports.roundCoords = roundCoords;
-   exports.interp = interp;
-   exports.cross = cross;
-   exports.euclideanDistance = euclideanDistance;
-   exports.latToMeters = latToMeters;
-   exports.lonToMeters = lonToMeters;
-   exports.metersToLat = metersToLat;
-   exports.metersToLon = metersToLon;
-   exports.offsetToMeters = offsetToMeters;
-   exports.metersToOffset = metersToOffset;
-   exports.sphericalDistance = sphericalDistance;
-   exports.edgeEqual = edgeEqual;
-   exports.angle = getAngle;
-   exports.chooseEdge = chooseEdge;
-   exports.lineIntersection = lineIntersection;
-   exports.pathIntersections = pathIntersections;
-   exports.pointInPolygon = pointInPolygon;
-   exports.polygonContainsPolygon = polygonContainsPolygon;
-   exports.polygonIntersectsPolygon = polygonIntersectsPolygon;
-   exports.pathLength = pathLength;
-   exports.Extent = Extent;
-   exports.Intersection = Intersection;
-   exports.Turn = Turn;
-   exports.inferRestriction = inferRestriction;
-   exports.isSimpleMultipolygonOuterMember = isSimpleMultipolygonOuterMember;
-   exports.simpleMultipolygonOuterMember = simpleMultipolygonOuterMember;
-   exports.joinWays = joinWays;
-   exports.RawMercator = RawMercator;
-
-   Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
\ No newline at end of file
diff --git a/js/lib/id/modes.js b/js/lib/id/modes.js
deleted file mode 100644
index cb2d1f28c..000000000
--- a/js/lib/id/modes.js
+++ /dev/null
@@ -1,1340 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (factory((global.iD = global.iD || {}, global.iD.modes = global.iD.modes || {})));
-}(this, function (exports) { 'use strict';
-
-    function AddArea(context) {
-        var mode = {
-            id: 'add-area',
-            button: 'area',
-            title: t('modes.add_area.title'),
-            description: t('modes.add_area.description'),
-            key: '3'
-        };
-
-        var behavior = iD.behavior.AddWay(context)
-                .tail(t('modes.add_area.tail'))
-                .on('start', start)
-                .on('startFromWay', startFromWay)
-                .on('startFromNode', startFromNode),
-            defaultTags = {area: 'yes'};
-
-        function start(loc) {
-            var graph = context.graph(),
-                node = iD.Node({loc: loc}),
-                way = iD.Way({tags: defaultTags});
-
-            context.perform(
-                iD.actions.AddEntity(node),
-                iD.actions.AddEntity(way),
-                iD.actions.AddVertex(way.id, node.id),
-                iD.actions.AddVertex(way.id, node.id));
-
-            context.enter(iD.modes.DrawArea(context, way.id, graph));
-        }
-
-        function startFromWay(loc, edge) {
-            var graph = context.graph(),
-                node = iD.Node({loc: loc}),
-                way = iD.Way({tags: defaultTags});
-
-            context.perform(
-                iD.actions.AddEntity(node),
-                iD.actions.AddEntity(way),
-                iD.actions.AddVertex(way.id, node.id),
-                iD.actions.AddVertex(way.id, node.id),
-                iD.actions.AddMidpoint({ loc: loc, edge: edge }, node));
-
-            context.enter(iD.modes.DrawArea(context, way.id, graph));
-        }
-
-        function startFromNode(node) {
-            var graph = context.graph(),
-                way = iD.Way({tags: defaultTags});
-
-            context.perform(
-                iD.actions.AddEntity(way),
-                iD.actions.AddVertex(way.id, node.id),
-                iD.actions.AddVertex(way.id, node.id));
-
-            context.enter(iD.modes.DrawArea(context, way.id, graph));
-        }
-
-        mode.enter = function() {
-            context.install(behavior);
-        };
-
-        mode.exit = function() {
-            context.uninstall(behavior);
-        };
-
-        return mode;
-    }
-
-    function AddLine(context) {
-        var mode = {
-            id: 'add-line',
-            button: 'line',
-            title: t('modes.add_line.title'),
-            description: t('modes.add_line.description'),
-            key: '2'
-        };
-
-        var behavior = iD.behavior.AddWay(context)
-            .tail(t('modes.add_line.tail'))
-            .on('start', start)
-            .on('startFromWay', startFromWay)
-            .on('startFromNode', startFromNode);
-
-        function start(loc) {
-            var baseGraph = context.graph(),
-                node = iD.Node({loc: loc}),
-                way = iD.Way();
-
-            context.perform(
-                iD.actions.AddEntity(node),
-                iD.actions.AddEntity(way),
-                iD.actions.AddVertex(way.id, node.id));
-
-            context.enter(iD.modes.DrawLine(context, way.id, baseGraph));
-        }
-
-        function startFromWay(loc, edge) {
-            var baseGraph = context.graph(),
-                node = iD.Node({loc: loc}),
-                way = iD.Way();
-
-            context.perform(
-                iD.actions.AddEntity(node),
-                iD.actions.AddEntity(way),
-                iD.actions.AddVertex(way.id, node.id),
-                iD.actions.AddMidpoint({ loc: loc, edge: edge }, node));
-
-            context.enter(iD.modes.DrawLine(context, way.id, baseGraph));
-        }
-
-        function startFromNode(node) {
-            var baseGraph = context.graph(),
-                way = iD.Way();
-
-            context.perform(
-                iD.actions.AddEntity(way),
-                iD.actions.AddVertex(way.id, node.id));
-
-            context.enter(iD.modes.DrawLine(context, way.id, baseGraph));
-        }
-
-        mode.enter = function() {
-            context.install(behavior);
-        };
-
-        mode.exit = function() {
-            context.uninstall(behavior);
-        };
-
-        return mode;
-    }
-
-    function AddPoint(context) {
-        var mode = {
-            id: 'add-point',
-            button: 'point',
-            title: t('modes.add_point.title'),
-            description: t('modes.add_point.description'),
-            key: '1'
-        };
-
-        var behavior = iD.behavior.Draw(context)
-            .tail(t('modes.add_point.tail'))
-            .on('click', add)
-            .on('clickWay', addWay)
-            .on('clickNode', addNode)
-            .on('cancel', cancel)
-            .on('finish', cancel);
-
-        function add(loc) {
-            var node = iD.Node({loc: loc});
-
-            context.perform(
-                iD.actions.AddEntity(node),
-                t('operations.add.annotation.point'));
-
-            context.enter(
-                iD.modes.Select(context, [node.id])
-                    .suppressMenu(true)
-                    .newFeature(true));
-        }
-
-        function addWay(loc) {
-            add(loc);
-        }
-
-        function addNode(node) {
-            add(node.loc);
-        }
-
-        function cancel() {
-            context.enter(iD.modes.Browse(context));
-        }
-
-        mode.enter = function() {
-            context.install(behavior);
-        };
-
-        mode.exit = function() {
-            context.uninstall(behavior);
-        };
-
-        return mode;
-    }
-
-    function Browse(context) {
-        var mode = {
-            button: 'browse',
-            id: 'browse',
-            title: t('modes.browse.title'),
-            description: t('modes.browse.description')
-        }, sidebar;
-
-        var behaviors = [
-            iD.behavior.Paste(context),
-            iD.behavior.Hover(context)
-                .on('hover', context.ui().sidebar.hover),
-            iD.behavior.Select(context),
-            iD.behavior.Lasso(context),
-            iD.modes.DragNode(context).behavior];
-
-        mode.enter = function() {
-            behaviors.forEach(function(behavior) {
-                context.install(behavior);
-            });
-
-            // Get focus on the body.
-            if (document.activeElement && document.activeElement.blur) {
-                document.activeElement.blur();
-            }
-
-            if (sidebar) {
-                context.ui().sidebar.show(sidebar);
-            } else {
-                context.ui().sidebar.select(null);
-            }
-        };
-
-        mode.exit = function() {
-            context.ui().sidebar.hover.cancel();
-            behaviors.forEach(function(behavior) {
-                context.uninstall(behavior);
-            });
-
-            if (sidebar) {
-                context.ui().sidebar.hide();
-            }
-        };
-
-        mode.sidebar = function(_) {
-            if (!arguments.length) return sidebar;
-            sidebar = _;
-            return mode;
-        };
-
-        return mode;
-    }
-
-    function DragNode(context) {
-        var mode = {
-            id: 'drag-node',
-            button: 'browse'
-        };
-
-        var nudgeInterval,
-            activeIDs,
-            wasMidpoint,
-            cancelled,
-            selectedIDs = [],
-            hover = iD.behavior.Hover(context)
-                .altDisables(true)
-                .on('hover', context.ui().sidebar.hover),
-            edit = iD.behavior.Edit(context);
-
-        function edge(point, size) {
-            var pad = [30, 100, 30, 100];
-            if (point[0] > size[0] - pad[0]) return [-10, 0];
-            else if (point[0] < pad[2]) return [10, 0];
-            else if (point[1] > size[1] - pad[1]) return [0, -10];
-            else if (point[1] < pad[3]) return [0, 10];
-            return null;
-        }
-
-        function startNudge(nudge) {
-            if (nudgeInterval) window.clearInterval(nudgeInterval);
-            nudgeInterval = window.setInterval(function() {
-                context.pan(nudge);
-            }, 50);
-        }
-
-        function stopNudge() {
-            if (nudgeInterval) window.clearInterval(nudgeInterval);
-            nudgeInterval = null;
-        }
-
-        function moveAnnotation(entity) {
-            return t('operations.move.annotation.' + entity.geometry(context.graph()));
-        }
-
-        function connectAnnotation(entity) {
-            return t('operations.connect.annotation.' + entity.geometry(context.graph()));
-        }
-
-        function origin(entity) {
-            return context.projection(entity.loc);
-        }
-
-        function start(entity) {
-            cancelled = d3.event.sourceEvent.shiftKey ||
-                context.features().hasHiddenConnections(entity, context.graph());
-
-            if (cancelled) return behavior.cancel();
-
-            wasMidpoint = entity.type === 'midpoint';
-            if (wasMidpoint) {
-                var midpoint = entity;
-                entity = iD.Node();
-                context.perform(iD.actions.AddMidpoint(midpoint, entity));
-
-                 var vertex = context.surface()
-                    .selectAll('.' + entity.id);
-                 behavior.target(vertex.node(), entity);
-
-            } else {
-                context.perform(
-                    iD.actions.Noop());
-            }
-
-            activeIDs = _.map(context.graph().parentWays(entity), 'id');
-            activeIDs.push(entity.id);
-
-            context.enter(mode);
-        }
-
-        function datum() {
-            if (d3.event.sourceEvent.altKey) {
-                return {};
-            }
-
-            return d3.event.sourceEvent.target.__data__ || {};
-        }
-
-        // via https://gist.github.com/shawnbot/4166283
-        function childOf(p, c) {
-            if (p === c) return false;
-            while (c && c !== p) c = c.parentNode;
-            return c === p;
-        }
-
-        function move(entity) {
-            if (cancelled) return;
-            d3.event.sourceEvent.stopPropagation();
-
-            var nudge = childOf(context.container().node(),
-                d3.event.sourceEvent.toElement) &&
-                edge(d3.event.point, context.map().dimensions());
-
-            if (nudge) startNudge(nudge);
-            else stopNudge();
-
-            var loc = context.projection.invert(d3.event.point);
-
-            var d = datum();
-            if (d.type === 'node' && d.id !== entity.id) {
-                loc = d.loc;
-            } else if (d.type === 'way' && !d3.select(d3.event.sourceEvent.target).classed('fill')) {
-                loc = iD.geo.chooseEdge(context.childNodes(d), context.mouse(), context.projection).loc;
-            }
-
-            context.replace(
-                iD.actions.MoveNode(entity.id, loc),
-                moveAnnotation(entity));
-        }
-
-        function end(entity) {
-            if (cancelled) return;
-
-            var d = datum();
-
-            if (d.type === 'way') {
-                var choice = iD.geo.chooseEdge(context.childNodes(d), context.mouse(), context.projection);
-                context.replace(
-                    iD.actions.AddMidpoint({ loc: choice.loc, edge: [d.nodes[choice.index - 1], d.nodes[choice.index]] }, entity),
-                    connectAnnotation(d));
-
-            } else if (d.type === 'node' && d.id !== entity.id) {
-                context.replace(
-                    iD.actions.Connect([d.id, entity.id]),
-                    connectAnnotation(d));
-
-            } else if (wasMidpoint) {
-                context.replace(
-                    iD.actions.Noop(),
-                    t('operations.add.annotation.vertex'));
-
-            } else {
-                context.replace(
-                    iD.actions.Noop(),
-                    moveAnnotation(entity));
-            }
-
-            var reselection = selectedIDs.filter(function(id) {
-                return context.graph().hasEntity(id);
-            });
-
-            if (reselection.length) {
-                context.enter(
-                    iD.modes.Select(context, reselection)
-                        .suppressMenu(true));
-            } else {
-                context.enter(iD.modes.Browse(context));
-            }
-        }
-
-        function cancel() {
-            behavior.cancel();
-            context.enter(iD.modes.Browse(context));
-        }
-
-        function setActiveElements() {
-            context.surface().selectAll(iD.util.entitySelector(activeIDs))
-                .classed('active', true);
-        }
-
-        var behavior = iD.behavior.drag()
-            .delegate('g.node, g.point, g.midpoint')
-            .surface(context.surface().node())
-            .origin(origin)
-            .on('start', start)
-            .on('move', move)
-            .on('end', end);
-
-        mode.enter = function() {
-            context.install(hover);
-            context.install(edit);
-
-            context.history()
-                .on('undone.drag-node', cancel);
-
-            context.map()
-                .on('drawn.drag-node', setActiveElements);
-
-            setActiveElements();
-        };
-
-        mode.exit = function() {
-            context.ui().sidebar.hover.cancel();
-            context.uninstall(hover);
-            context.uninstall(edit);
-
-            context.history()
-                .on('undone.drag-node', null);
-
-            context.map()
-                .on('drawn.drag-node', null);
-
-            context.surface()
-                .selectAll('.active')
-                .classed('active', false);
-
-            stopNudge();
-        };
-
-        mode.selectedIDs = function(_) {
-            if (!arguments.length) return selectedIDs;
-            selectedIDs = _;
-            return mode;
-        };
-
-        mode.behavior = behavior;
-
-        return mode;
-    }
-
-    function DrawArea(context, wayId, baseGraph) {
-        var mode = {
-            button: 'area',
-            id: 'draw-area'
-        };
-
-        var behavior;
-
-        mode.enter = function() {
-            var way = context.entity(wayId),
-                headId = way.nodes[way.nodes.length - 2],
-                tailId = way.first();
-
-            behavior = iD.behavior.DrawWay(context, wayId, -1, mode, baseGraph)
-                .tail(t('modes.draw_area.tail'));
-
-            var addNode = behavior.addNode;
-
-            behavior.addNode = function(node) {
-                if (node.id === headId || node.id === tailId) {
-                    behavior.finish();
-                } else {
-                    addNode(node);
-                }
-            };
-
-            context.install(behavior);
-        };
-
-        mode.exit = function() {
-            context.uninstall(behavior);
-        };
-
-        mode.selectedIDs = function() {
-            return [wayId];
-        };
-
-        return mode;
-    }
-
-    function DrawLine(context, wayId, baseGraph, affix) {
-        var mode = {
-            button: 'line',
-            id: 'draw-line'
-        };
-
-        var behavior;
-
-        mode.enter = function() {
-            var way = context.entity(wayId),
-                index = (affix === 'prefix') ? 0 : undefined,
-                headId = (affix === 'prefix') ? way.first() : way.last();
-
-            behavior = iD.behavior.DrawWay(context, wayId, index, mode, baseGraph)
-                .tail(t('modes.draw_line.tail'));
-
-            var addNode = behavior.addNode;
-
-            behavior.addNode = function(node) {
-                if (node.id === headId) {
-                    behavior.finish();
-                } else {
-                    addNode(node);
-                }
-            };
-
-            context.install(behavior);
-        };
-
-        mode.exit = function() {
-            context.uninstall(behavior);
-        };
-
-        mode.selectedIDs = function() {
-            return [wayId];
-        };
-
-        return mode;
-    }
-
-    function Move(context, entityIDs, baseGraph) {
-        var mode = {
-            id: 'move',
-            button: 'browse'
-        };
-
-        var keybinding = d3.keybinding('move'),
-            edit = iD.behavior.Edit(context),
-            annotation = entityIDs.length === 1 ?
-                t('operations.move.annotation.' + context.geometry(entityIDs[0])) :
-                t('operations.move.annotation.multiple'),
-            cache,
-            origin,
-            nudgeInterval;
-
-        function vecSub(a, b) { return [a[0] - b[0], a[1] - b[1]]; }
-
-        function edge(point, size) {
-            var pad = [30, 100, 30, 100];
-            if (point[0] > size[0] - pad[0]) return [-10, 0];
-            else if (point[0] < pad[2]) return [10, 0];
-            else if (point[1] > size[1] - pad[1]) return [0, -10];
-            else if (point[1] < pad[3]) return [0, 10];
-            return null;
-        }
-
-        function startNudge(nudge) {
-            if (nudgeInterval) window.clearInterval(nudgeInterval);
-            nudgeInterval = window.setInterval(function() {
-                context.pan(nudge);
-
-                var currMouse = context.mouse(),
-                    origMouse = context.projection(origin),
-                    delta = vecSub(vecSub(currMouse, origMouse), nudge),
-                    action = iD.actions.Move(entityIDs, delta, context.projection, cache);
-
-                context.overwrite(action, annotation);
-
-            }, 50);
-        }
-
-        function stopNudge() {
-            if (nudgeInterval) window.clearInterval(nudgeInterval);
-            nudgeInterval = null;
-        }
-
-        function move() {
-            var currMouse = context.mouse(),
-                origMouse = context.projection(origin),
-                delta = vecSub(currMouse, origMouse),
-                action = iD.actions.Move(entityIDs, delta, context.projection, cache);
-
-            context.overwrite(action, annotation);
-
-            var nudge = edge(currMouse, context.map().dimensions());
-            if (nudge) startNudge(nudge);
-            else stopNudge();
-        }
-
-        function finish() {
-            d3.event.stopPropagation();
-            context.enter(iD.modes.Select(context, entityIDs).suppressMenu(true));
-            stopNudge();
-        }
-
-        function cancel() {
-            if (baseGraph) {
-                while (context.graph() !== baseGraph) context.pop();
-                context.enter(iD.modes.Browse(context));
-            } else {
-                context.pop();
-                context.enter(iD.modes.Select(context, entityIDs).suppressMenu(true));
-            }
-            stopNudge();
-        }
-
-        function undone() {
-            context.enter(iD.modes.Browse(context));
-        }
-
-        mode.enter = function() {
-            origin = context.map().mouseCoordinates();
-            cache = {};
-
-            context.install(edit);
-
-            context.perform(
-                iD.actions.Noop(),
-                annotation);
-
-            context.surface()
-                .on('mousemove.move', move)
-                .on('click.move', finish);
-
-            context.history()
-                .on('undone.move', undone);
-
-            keybinding
-                .on('⎋', cancel)
-                .on('↩', finish);
-
-            d3.select(document)
-                .call(keybinding);
-        };
-
-        mode.exit = function() {
-            stopNudge();
-
-            context.uninstall(edit);
-
-            context.surface()
-                .on('mousemove.move', null)
-                .on('click.move', null);
-
-            context.history()
-                .on('undone.move', null);
-
-            keybinding.off();
-        };
-
-        return mode;
-    }
-
-    function RotateWay(context, wayId) {
-        var mode = {
-            id: 'rotate-way',
-            button: 'browse'
-        };
-
-        var keybinding = d3.keybinding('rotate-way'),
-            edit = iD.behavior.Edit(context);
-
-        mode.enter = function() {
-            context.install(edit);
-
-            var annotation = t('operations.rotate.annotation.' + context.geometry(wayId)),
-                way = context.graph().entity(wayId),
-                nodes = _.uniq(context.graph().childNodes(way)),
-                points = nodes.map(function(n) { return context.projection(n.loc); }),
-                pivot = d3.geom.polygon(points).centroid(),
-                angle;
-
-            context.perform(
-                iD.actions.Noop(),
-                annotation);
-
-            function rotate() {
-
-                var mousePoint = context.mouse(),
-                    newAngle = Math.atan2(mousePoint[1] - pivot[1], mousePoint[0] - pivot[0]);
-
-                if (typeof angle === 'undefined') angle = newAngle;
-
-                context.replace(
-                    iD.actions.RotateWay(wayId, pivot, newAngle - angle, context.projection),
-                    annotation);
-
-                angle = newAngle;
-            }
-
-            function finish() {
-                d3.event.stopPropagation();
-                context.enter(iD.modes.Select(context, [wayId])
-                    .suppressMenu(true));
-            }
-
-            function cancel() {
-                context.pop();
-                context.enter(iD.modes.Select(context, [wayId])
-                    .suppressMenu(true));
-            }
-
-            function undone() {
-                context.enter(iD.modes.Browse(context));
-            }
-
-            context.surface()
-                .on('mousemove.rotate-way', rotate)
-                .on('click.rotate-way', finish);
-
-            context.history()
-                .on('undone.rotate-way', undone);
-
-            keybinding
-                .on('⎋', cancel)
-                .on('↩', finish);
-
-            d3.select(document)
-                .call(keybinding);
-        };
-
-        mode.exit = function() {
-            context.uninstall(edit);
-
-            context.surface()
-                .on('mousemove.rotate-way', null)
-                .on('click.rotate-way', null);
-
-            context.history()
-                .on('undone.rotate-way', null);
-
-            keybinding.off();
-        };
-
-        return mode;
-    }
-
-    function Save(context) {
-        var ui = iD.ui.Commit(context)
-                .on('cancel', cancel)
-                .on('save', save);
-
-        function cancel() {
-            context.enter(iD.modes.Browse(context));
-        }
-
-        function save(e, tryAgain) {
-            function withChildNodes(ids, graph) {
-                return _.uniq(_.reduce(ids, function(result, id) {
-                    var e = graph.entity(id);
-                    if (e.type === 'way') {
-                        try {
-                            var cn = graph.childNodes(e);
-                            result.push.apply(result, _.map(_.filter(cn, 'version'), 'id'));
-                        } catch (err) {
-                            /* eslint-disable no-console */
-                            if (typeof console !== 'undefined') console.error(err);
-                            /* eslint-enable no-console */
-                        }
-                    }
-                    return result;
-                }, _.clone(ids)));
-            }
-
-            var loading = iD.ui.Loading(context).message(t('save.uploading')).blocking(true),
-                history = context.history(),
-                origChanges = history.changes(iD.actions.DiscardTags(history.difference())),
-                localGraph = context.graph(),
-                remoteGraph = iD.Graph(history.base(), true),
-                modified = _.filter(history.difference().summary(), {changeType: 'modified'}),
-                toCheck = _.map(_.map(modified, 'entity'), 'id'),
-                toLoad = withChildNodes(toCheck, localGraph),
-                conflicts = [],
-                errors = [];
-
-            if (!tryAgain) history.perform(iD.actions.Noop());  // checkpoint
-            context.container().call(loading);
-
-            if (toCheck.length) {
-                context.connection().loadMultiple(toLoad, loaded);
-            } else {
-                finalize();
-            }
-
-
-            // Reload modified entities into an alternate graph and check for conflicts..
-            function loaded(err, result) {
-                if (errors.length) return;
-
-                if (err) {
-                    errors.push({
-                        msg: err.responseText,
-                        details: [ t('save.status_code', { code: err.status }) ]
-                    });
-                    showErrors();
-
-                } else {
-                    var loadMore = [];
-                    _.each(result.data, function(entity) {
-                        remoteGraph.replace(entity);
-                        toLoad = _.without(toLoad, entity.id);
-
-                        // Because loadMultiple doesn't download /full like loadEntity,
-                        // need to also load children that aren't already being checked..
-                        if (!entity.visible) return;
-                        if (entity.type === 'way') {
-                            loadMore.push.apply(loadMore,
-                                _.difference(entity.nodes, toCheck, toLoad, loadMore));
-                        } else if (entity.type === 'relation' && entity.isMultipolygon()) {
-                            loadMore.push.apply(loadMore,
-                                _.difference(_.map(entity.members, 'id'), toCheck, toLoad, loadMore));
-                        }
-                    });
-
-                    if (loadMore.length) {
-                        toLoad.push.apply(toLoad, loadMore);
-                        context.connection().loadMultiple(loadMore, loaded);
-                    }
-
-                    if (!toLoad.length) {
-                        checkConflicts();
-                    }
-                }
-            }
-
-
-            function checkConflicts() {
-                function choice(id, text, action) {
-                    return { id: id, text: text, action: function() { history.replace(action); } };
-                }
-                function formatUser(d) {
-                    return '<a href="' + context.connection().userURL(d) + '" target="_blank">' + d + '</a>';
-                }
-                function entityName(entity) {
-                    return iD.util.displayName(entity) || (iD.util.displayType(entity.id) + ' ' + entity.id);
-                }
-
-                function compareVersions(local, remote) {
-                    if (local.version !== remote.version) return false;
-
-                    if (local.type === 'way') {
-                        var children = _.union(local.nodes, remote.nodes);
-
-                        for (var i = 0; i < children.length; i++) {
-                            var a = localGraph.hasEntity(children[i]),
-                                b = remoteGraph.hasEntity(children[i]);
-
-                            if (a && b && a.version !== b.version) return false;
-                        }
-                    }
-
-                    return true;
-                }
-
-                _.each(toCheck, function(id) {
-                    var local = localGraph.entity(id),
-                        remote = remoteGraph.entity(id);
-
-                    if (compareVersions(local, remote)) return;
-
-                    var action = iD.actions.MergeRemoteChanges,
-                        merge = action(id, localGraph, remoteGraph, formatUser);
-
-                    history.replace(merge);
-
-                    var mergeConflicts = merge.conflicts();
-                    if (!mergeConflicts.length) return;  // merged safely
-
-                    var forceLocal = action(id, localGraph, remoteGraph).withOption('force_local'),
-                        forceRemote = action(id, localGraph, remoteGraph).withOption('force_remote'),
-                        keepMine = t('save.conflict.' + (remote.visible ? 'keep_local' : 'restore')),
-                        keepTheirs = t('save.conflict.' + (remote.visible ? 'keep_remote' : 'delete'));
-
-                    conflicts.push({
-                        id: id,
-                        name: entityName(local),
-                        details: mergeConflicts,
-                        chosen: 1,
-                        choices: [
-                            choice(id, keepMine, forceLocal),
-                            choice(id, keepTheirs, forceRemote)
-                        ]
-                    });
-                });
-
-                finalize();
-            }
-
-
-            function finalize() {
-                if (conflicts.length) {
-                    conflicts.sort(function(a,b) { return b.id.localeCompare(a.id); });
-                    showConflicts();
-                } else if (errors.length) {
-                    showErrors();
-                } else {
-                    var changes = history.changes(iD.actions.DiscardTags(history.difference()));
-                    if (changes.modified.length || changes.created.length || changes.deleted.length) {
-                        context.connection().putChangeset(
-                            changes,
-                            e.comment,
-                            history.imageryUsed(),
-                            function(err, changeset_id) {
-                                if (err) {
-                                    errors.push({
-                                        msg: err.responseText,
-                                        details: [ t('save.status_code', { code: err.status }) ]
-                                    });
-                                    showErrors();
-                                } else {
-                                    history.clearSaved();
-                                    success(e, changeset_id);
-                                    // Add delay to allow for postgres replication #1646 #2678
-                                    window.setTimeout(function() {
-                                        loading.close();
-                                        context.flush();
-                                    }, 2500);
-                                }
-                            });
-                    } else {        // changes were insignificant or reverted by user
-                        loading.close();
-                        context.flush();
-                        cancel();
-                    }
-                }
-            }
-
-
-            function showConflicts() {
-                var selection = context.container()
-                    .select('#sidebar')
-                    .append('div')
-                    .attr('class','sidebar-component');
-
-                loading.close();
-
-                selection.call(iD.ui.Conflicts(context)
-                    .list(conflicts)
-                    .on('download', function() {
-                        var data = JXON.stringify(context.connection().osmChangeJXON('CHANGEME', origChanges)),
-                            win = window.open('data:text/xml,' + encodeURIComponent(data), '_blank');
-                        win.focus();
-                    })
-                    .on('cancel', function() {
-                        history.pop();
-                        selection.remove();
-                    })
-                    .on('save', function() {
-                        for (var i = 0; i < conflicts.length; i++) {
-                            if (conflicts[i].chosen === 1) {  // user chose "keep theirs"
-                                var entity = context.hasEntity(conflicts[i].id);
-                                if (entity && entity.type === 'way') {
-                                    var children = _.uniq(entity.nodes);
-                                    for (var j = 0; j < children.length; j++) {
-                                        history.replace(iD.actions.Revert(children[j]));
-                                    }
-                                }
-                                history.replace(iD.actions.Revert(conflicts[i].id));
-                            }
-                        }
-
-                        selection.remove();
-                        save(e, true);
-                    })
-                );
-            }
-
-
-            function showErrors() {
-                var selection = iD.ui.confirm(context.container());
-
-                history.pop();
-                loading.close();
-
-                selection
-                    .select('.modal-section.header')
-                    .append('h3')
-                    .text(t('save.error'));
-
-                addErrors(selection, errors);
-                selection.okButton();
-            }
-
-
-            function addErrors(selection, data) {
-                var message = selection
-                    .select('.modal-section.message-text');
-
-                var items = message
-                    .selectAll('.error-container')
-                    .data(data);
-
-                var enter = items.enter()
-                    .append('div')
-                    .attr('class', 'error-container');
-
-                enter
-                    .append('a')
-                    .attr('class', 'error-description')
-                    .attr('href', '#')
-                    .classed('hide-toggle', true)
-                    .text(function(d) { return d.msg || t('save.unknown_error_details'); })
-                    .on('click', function() {
-                        var error = d3.select(this),
-                            detail = d3.select(this.nextElementSibling),
-                            exp = error.classed('expanded');
-
-                        detail.style('display', exp ? 'none' : 'block');
-                        error.classed('expanded', !exp);
-
-                        d3.event.preventDefault();
-                    });
-
-                var details = enter
-                    .append('div')
-                    .attr('class', 'error-detail-container')
-                    .style('display', 'none');
-
-                details
-                    .append('ul')
-                    .attr('class', 'error-detail-list')
-                    .selectAll('li')
-                    .data(function(d) { return d.details || []; })
-                    .enter()
-                    .append('li')
-                    .attr('class', 'error-detail-item')
-                    .text(function(d) { return d; });
-
-                items.exit()
-                    .remove();
-            }
-
-        }
-
-
-        function success(e, changeset_id) {
-            context.enter(iD.modes.Browse(context)
-                .sidebar(iD.ui.Success(context)
-                    .changeset({
-                        id: changeset_id,
-                        comment: e.comment
-                    })
-                    .on('cancel', function() {
-                        context.ui().sidebar.hide();
-                    })));
-        }
-
-        var mode = {
-            id: 'save'
-        };
-
-        mode.enter = function() {
-            context.connection().authenticate(function(err) {
-                if (err) {
-                    cancel();
-                } else {
-                    context.ui().sidebar.show(ui);
-                }
-            });
-        };
-
-        mode.exit = function() {
-            context.ui().sidebar.hide();
-        };
-
-        return mode;
-    }
-
-    function Select(context, selectedIDs) {
-        var mode = {
-            id: 'select',
-            button: 'browse'
-        };
-
-        var keybinding = d3.keybinding('select'),
-            timeout = null,
-            behaviors = [
-                iD.behavior.Copy(context),
-                iD.behavior.Paste(context),
-                iD.behavior.Breathe(context),
-                iD.behavior.Hover(context),
-                iD.behavior.Select(context),
-                iD.behavior.Lasso(context),
-                iD.modes.DragNode(context)
-                    .selectedIDs(selectedIDs)
-                    .behavior],
-            inspector,
-            radialMenu,
-            newFeature = false,
-            suppressMenu = false;
-
-        var wrap = context.container()
-            .select('.inspector-wrap');
-
-
-        function singular() {
-            if (selectedIDs.length === 1) {
-                return context.hasEntity(selectedIDs[0]);
-            }
-        }
-
-        function closeMenu() {
-            if (radialMenu) {
-                context.surface().call(radialMenu.close);
-            }
-        }
-
-        function positionMenu() {
-            if (suppressMenu || !radialMenu) { return; }
-
-            var entity = singular();
-            if (entity && context.geometry(entity.id) === 'relation') {
-                suppressMenu = true;
-            } else if (entity && entity.type === 'node') {
-                radialMenu.center(context.projection(entity.loc));
-            } else {
-                var point = context.mouse(),
-                    viewport = iD.geo.Extent(context.projection.clipExtent()).polygon();
-                if (iD.geo.pointInPolygon(point, viewport)) {
-                    radialMenu.center(point);
-                } else {
-                    suppressMenu = true;
-                }
-            }
-        }
-
-        function showMenu() {
-            closeMenu();
-            if (!suppressMenu && radialMenu) {
-                context.surface().call(radialMenu);
-            }
-        }
-
-        function toggleMenu() {
-            if (d3.select('.radial-menu').empty()) {
-                showMenu();
-            } else {
-                closeMenu();
-            }
-        }
-
-        mode.selectedIDs = function() {
-            return selectedIDs;
-        };
-
-        mode.reselect = function() {
-            var surfaceNode = context.surface().node();
-            if (surfaceNode.focus) { // FF doesn't support it
-                surfaceNode.focus();
-            }
-
-            positionMenu();
-            showMenu();
-        };
-
-        mode.newFeature = function(_) {
-            if (!arguments.length) return newFeature;
-            newFeature = _;
-            return mode;
-        };
-
-        mode.suppressMenu = function(_) {
-            if (!arguments.length) return suppressMenu;
-            suppressMenu = _;
-            return mode;
-        };
-
-        mode.enter = function() {
-            function update() {
-                closeMenu();
-                if (_.some(selectedIDs, function(id) { return !context.hasEntity(id); })) {
-                    // Exit mode if selected entity gets undone
-                    context.enter(iD.modes.Browse(context));
-                }
-            }
-
-            function dblclick() {
-                var target = d3.select(d3.event.target),
-                    datum = target.datum();
-
-                if (datum instanceof iD.Way && !target.classed('fill')) {
-                    var choice = iD.geo.chooseEdge(context.childNodes(datum), context.mouse(), context.projection),
-                        node = iD.Node();
-
-                    var prev = datum.nodes[choice.index - 1],
-                        next = datum.nodes[choice.index];
-
-                    context.perform(
-                        iD.actions.AddMidpoint({loc: choice.loc, edge: [prev, next]}, node),
-                        t('operations.add.annotation.vertex'));
-
-                    d3.event.preventDefault();
-                    d3.event.stopPropagation();
-                }
-            }
-
-            function selectElements(drawn) {
-                var entity = singular();
-                if (entity && context.geometry(entity.id) === 'relation') {
-                    suppressMenu = true;
-                    return;
-                }
-
-                var selection = context.surface()
-                        .selectAll(iD.util.entityOrMemberSelector(selectedIDs, context.graph()));
-
-                if (selection.empty()) {
-                    if (drawn) {  // Exit mode if selected DOM elements have disappeared..
-                        context.enter(iD.modes.Browse(context));
-                    }
-                } else {
-                    selection
-                        .classed('selected', true);
-                }
-            }
-
-            function esc() {
-                if (!context.inIntro()) {
-                    context.enter(iD.modes.Browse(context));
-                }
-            }
-
-
-            behaviors.forEach(function(behavior) {
-                context.install(behavior);
-            });
-
-            var operations = _.without(d3.values(iD.operations), iD.operations.Delete)
-                    .map(function(o) { return o(selectedIDs, context); })
-                    .filter(function(o) { return o.available(); });
-
-            operations.unshift(iD.operations.Delete(selectedIDs, context));
-
-            keybinding
-                .on('⎋', esc, true)
-                .on('space', toggleMenu);
-
-            operations.forEach(function(operation) {
-                operation.keys.forEach(function(key) {
-                    keybinding.on(key, function() {
-                        if (!(context.inIntro() || operation.disabled())) {
-                            operation();
-                        }
-                    });
-                });
-            });
-
-            d3.select(document)
-                .call(keybinding);
-
-            radialMenu = iD.ui.RadialMenu(context, operations);
-
-            context.ui().sidebar
-                .select(singular() ? singular().id : null, newFeature);
-
-            context.history()
-                .on('undone.select', update)
-                .on('redone.select', update);
-
-            context.map()
-                .on('move.select', closeMenu)
-                .on('drawn.select', selectElements);
-
-            selectElements();
-
-            var show = d3.event && !suppressMenu;
-
-            if (show) {
-                positionMenu();
-            }
-
-            timeout = window.setTimeout(function() {
-                if (show) {
-                    showMenu();
-                }
-
-                context.surface()
-                    .on('dblclick.select', dblclick);
-            }, 200);
-
-            if (selectedIDs.length > 1) {
-                var entities = iD.ui.SelectionList(context, selectedIDs);
-                context.ui().sidebar.show(entities);
-            }
-        };
-
-        mode.exit = function() {
-            if (timeout) window.clearTimeout(timeout);
-
-            if (inspector) wrap.call(inspector.close);
-
-            behaviors.forEach(function(behavior) {
-                context.uninstall(behavior);
-            });
-
-            keybinding.off();
-            closeMenu();
-            radialMenu = undefined;
-
-            context.history()
-                .on('undone.select', null)
-                .on('redone.select', null);
-
-            context.surface()
-                .on('dblclick.select', null)
-                .selectAll('.selected')
-                .classed('selected', false);
-
-            context.map().on('drawn.select', null);
-            context.ui().sidebar.hide();
-        };
-
-        return mode;
-    }
-
-    exports.AddArea = AddArea;
-    exports.AddLine = AddLine;
-    exports.AddPoint = AddPoint;
-    exports.Browse = Browse;
-    exports.DragNode = DragNode;
-    exports.DrawArea = DrawArea;
-    exports.DrawLine = DrawLine;
-    exports.Move = Move;
-    exports.RotateWay = RotateWay;
-    exports.Save = Save;
-    exports.Select = Select;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
\ No newline at end of file
diff --git a/js/lib/id/operations.js b/js/lib/id/operations.js
deleted file mode 100644
index 03f0ee699..000000000
--- a/js/lib/id/operations.js
+++ /dev/null
@@ -1,540 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (factory((global.iD = global.iD || {}, global.iD.operations = global.iD.operations || {})));
-}(this, function (exports) { 'use strict';
-
-    function Circularize(selectedIDs, context) {
-        var entityId = selectedIDs[0],
-            entity = context.entity(entityId),
-            extent = entity.extent(context.graph()),
-            geometry = context.geometry(entityId),
-            action = iD.actions.Circularize(entityId, context.projection);
-
-        var operation = function() {
-            var annotation = t('operations.circularize.annotation.' + geometry);
-            context.perform(action, annotation);
-        };
-
-        operation.available = function() {
-            return selectedIDs.length === 1 &&
-                entity.type === 'way' &&
-                _.uniq(entity.nodes).length > 1;
-        };
-
-        operation.disabled = function() {
-            var reason;
-            if (extent.percentContainedIn(context.extent()) < 0.8) {
-                reason = 'too_large';
-            } else if (context.hasHiddenConnections(entityId)) {
-                reason = 'connected_to_hidden';
-            }
-            return action.disabled(context.graph()) || reason;
-        };
-
-        operation.tooltip = function() {
-            var disable = operation.disabled();
-            return disable ?
-                t('operations.circularize.' + disable) :
-                t('operations.circularize.description.' + geometry);
-        };
-
-        operation.id = 'circularize';
-        operation.keys = [t('operations.circularize.key')];
-        operation.title = t('operations.circularize.title');
-
-        return operation;
-    }
-
-    function Continue(selectedIDs, context) {
-        var graph = context.graph(),
-            entities = selectedIDs.map(function(id) { return graph.entity(id); }),
-            geometries = _.extend({line: [], vertex: []},
-                _.groupBy(entities, function(entity) { return entity.geometry(graph); })),
-            vertex = geometries.vertex[0];
-
-        function candidateWays() {
-            return graph.parentWays(vertex).filter(function(parent) {
-                return parent.geometry(graph) === 'line' &&
-                    parent.affix(vertex.id) &&
-                    (geometries.line.length === 0 || geometries.line[0] === parent);
-            });
-        }
-
-        var operation = function() {
-            var candidate = candidateWays()[0];
-            context.enter(iD.modes.DrawLine(
-                context,
-                candidate.id,
-                context.graph(),
-                candidate.affix(vertex.id)));
-        };
-
-        operation.available = function() {
-            return geometries.vertex.length === 1 && geometries.line.length <= 1 &&
-                !context.features().hasHiddenConnections(vertex, context.graph());
-        };
-
-        operation.disabled = function() {
-            var candidates = candidateWays();
-            if (candidates.length === 0)
-                return 'not_eligible';
-            if (candidates.length > 1)
-                return 'multiple';
-        };
-
-        operation.tooltip = function() {
-            var disable = operation.disabled();
-            return disable ?
-                t('operations.continue.' + disable) :
-                t('operations.continue.description');
-        };
-
-        operation.id = 'continue';
-        operation.keys = [t('operations.continue.key')];
-        operation.title = t('operations.continue.title');
-
-        return operation;
-    }
-
-    function Delete(selectedIDs, context) {
-        var action = iD.actions.DeleteMultiple(selectedIDs);
-
-        var operation = function() {
-            var annotation,
-                nextSelectedID;
-
-            if (selectedIDs.length > 1) {
-                annotation = t('operations.delete.annotation.multiple', {n: selectedIDs.length});
-
-            } else {
-                var id = selectedIDs[0],
-                    entity = context.entity(id),
-                    geometry = context.geometry(id),
-                    parents = context.graph().parentWays(entity),
-                    parent = parents[0];
-
-                annotation = t('operations.delete.annotation.' + geometry);
-
-                // Select the next closest node in the way.
-                if (geometry === 'vertex' && parents.length === 1 && parent.nodes.length > 2) {
-                    var nodes = parent.nodes,
-                        i = nodes.indexOf(id);
-
-                    if (i === 0) {
-                        i++;
-                    } else if (i === nodes.length - 1) {
-                        i--;
-                    } else {
-                        var a = iD.geo.sphericalDistance(entity.loc, context.entity(nodes[i - 1]).loc),
-                            b = iD.geo.sphericalDistance(entity.loc, context.entity(nodes[i + 1]).loc);
-                        i = a < b ? i - 1 : i + 1;
-                    }
-
-                    nextSelectedID = nodes[i];
-                }
-            }
-
-            if (nextSelectedID && context.hasEntity(nextSelectedID)) {
-                context.enter(iD.modes.Select(context, [nextSelectedID]));
-            } else {
-                context.enter(iD.modes.Browse(context));
-            }
-
-            context.perform(
-                action,
-                annotation);
-        };
-
-        operation.available = function() {
-            return true;
-        };
-
-        operation.disabled = function() {
-            var reason;
-            if (_.some(selectedIDs, context.hasHiddenConnections)) {
-                reason = 'connected_to_hidden';
-            }
-            return action.disabled(context.graph()) || reason;
-        };
-
-        operation.tooltip = function() {
-            var disable = operation.disabled();
-            return disable ?
-                t('operations.delete.' + disable) :
-                t('operations.delete.description');
-        };
-
-        operation.id = 'delete';
-        operation.keys = [iD.ui.cmd('⌘⌫'), iD.ui.cmd('⌘⌦')];
-        operation.title = t('operations.delete.title');
-
-        return operation;
-    }
-
-    function Disconnect(selectedIDs, context) {
-        var vertices = _.filter(selectedIDs, function vertex(entityId) {
-            return context.geometry(entityId) === 'vertex';
-        });
-
-        var entityId = vertices[0],
-            action = iD.actions.Disconnect(entityId);
-
-        if (selectedIDs.length > 1) {
-            action.limitWays(_.without(selectedIDs, entityId));
-        }
-
-        var operation = function() {
-            context.perform(action, t('operations.disconnect.annotation'));
-        };
-
-        operation.available = function() {
-            return vertices.length === 1;
-        };
-
-        operation.disabled = function() {
-            var reason;
-            if (_.some(selectedIDs, context.hasHiddenConnections)) {
-                reason = 'connected_to_hidden';
-            }
-            return action.disabled(context.graph()) || reason;
-        };
-
-        operation.tooltip = function() {
-            var disable = operation.disabled();
-            return disable ?
-                t('operations.disconnect.' + disable) :
-                t('operations.disconnect.description');
-        };
-
-        operation.id = 'disconnect';
-        operation.keys = [t('operations.disconnect.key')];
-        operation.title = t('operations.disconnect.title');
-
-        return operation;
-    }
-
-    function Merge(selectedIDs, context) {
-        var join = iD.actions.Join(selectedIDs),
-            merge = iD.actions.Merge(selectedIDs),
-            mergePolygon = iD.actions.MergePolygon(selectedIDs);
-
-        var operation = function() {
-            var annotation = t('operations.merge.annotation', {n: selectedIDs.length}),
-                action;
-
-            if (!join.disabled(context.graph())) {
-                action = join;
-            } else if (!merge.disabled(context.graph())) {
-                action = merge;
-            } else {
-                action = mergePolygon;
-            }
-
-            context.perform(action, annotation);
-            context.enter(iD.modes.Select(context, selectedIDs.filter(function(id) { return context.hasEntity(id); }))
-                .suppressMenu(true));
-        };
-
-        operation.available = function() {
-            return selectedIDs.length >= 2;
-        };
-
-        operation.disabled = function() {
-            return join.disabled(context.graph()) &&
-                merge.disabled(context.graph()) &&
-                mergePolygon.disabled(context.graph());
-        };
-
-        operation.tooltip = function() {
-            var j = join.disabled(context.graph()),
-                m = merge.disabled(context.graph()),
-                p = mergePolygon.disabled(context.graph());
-
-            if (j === 'restriction' && m && p)
-                return t('operations.merge.restriction', {relation: context.presets().item('type/restriction').name()});
-
-            if (p === 'incomplete_relation' && j && m)
-                return t('operations.merge.incomplete_relation');
-
-            if (j && m && p)
-                return t('operations.merge.' + j);
-
-            return t('operations.merge.description');
-        };
-
-        operation.id = 'merge';
-        operation.keys = [t('operations.merge.key')];
-        operation.title = t('operations.merge.title');
-
-        return operation;
-    }
-
-    function Move(selectedIDs, context) {
-        var extent = selectedIDs.reduce(function(extent, id) {
-                return extent.extend(context.entity(id).extent(context.graph()));
-            }, iD.geo.Extent());
-
-        var operation = function() {
-            context.enter(iD.modes.Move(context, selectedIDs));
-        };
-
-        operation.available = function() {
-            return selectedIDs.length > 1 ||
-                context.entity(selectedIDs[0]).type !== 'node';
-        };
-
-        operation.disabled = function() {
-            var reason;
-            if (extent.area() && extent.percentContainedIn(context.extent()) < 0.8) {
-                reason = 'too_large';
-            } else if (_.some(selectedIDs, context.hasHiddenConnections)) {
-                reason = 'connected_to_hidden';
-            }
-            return iD.actions.Move(selectedIDs).disabled(context.graph()) || reason;
-        };
-
-        operation.tooltip = function() {
-            var disable = operation.disabled();
-            return disable ?
-                t('operations.move.' + disable) :
-                t('operations.move.description');
-        };
-
-        operation.id = 'move';
-        operation.keys = [t('operations.move.key')];
-        operation.title = t('operations.move.title');
-
-        return operation;
-    }
-
-    function Orthogonalize(selectedIDs, context) {
-        var entityId = selectedIDs[0],
-            entity = context.entity(entityId),
-            extent = entity.extent(context.graph()),
-            geometry = context.geometry(entityId),
-            action = iD.actions.Orthogonalize(entityId, context.projection);
-
-        var operation = function() {
-            var annotation = t('operations.orthogonalize.annotation.' + geometry);
-            context.perform(action, annotation);
-        };
-
-        operation.available = function() {
-            return selectedIDs.length === 1 &&
-                entity.type === 'way' &&
-                entity.isClosed() &&
-                _.uniq(entity.nodes).length > 2;
-        };
-
-        operation.disabled = function() {
-            var reason;
-            if (extent.percentContainedIn(context.extent()) < 0.8) {
-                reason = 'too_large';
-            } else if (context.hasHiddenConnections(entityId)) {
-                reason = 'connected_to_hidden';
-            }
-            return action.disabled(context.graph()) || reason;
-        };
-
-        operation.tooltip = function() {
-            var disable = operation.disabled();
-            return disable ?
-                t('operations.orthogonalize.' + disable) :
-                t('operations.orthogonalize.description.' + geometry);
-        };
-
-        operation.id = 'orthogonalize';
-        operation.keys = [t('operations.orthogonalize.key')];
-        operation.title = t('operations.orthogonalize.title');
-
-        return operation;
-    }
-
-    function Reverse(selectedIDs, context) {
-        var entityId = selectedIDs[0];
-
-        var operation = function() {
-            context.perform(
-                iD.actions.Reverse(entityId),
-                t('operations.reverse.annotation'));
-        };
-
-        operation.available = function() {
-            return selectedIDs.length === 1 &&
-                context.geometry(entityId) === 'line';
-        };
-
-        operation.disabled = function() {
-            return false;
-        };
-
-        operation.tooltip = function() {
-            return t('operations.reverse.description');
-        };
-
-        operation.id = 'reverse';
-        operation.keys = [t('operations.reverse.key')];
-        operation.title = t('operations.reverse.title');
-
-        return operation;
-    }
-
-    function Rotate(selectedIDs, context) {
-        var entityId = selectedIDs[0],
-            entity = context.entity(entityId),
-            extent = entity.extent(context.graph()),
-            geometry = context.geometry(entityId);
-
-        var operation = function() {
-            context.enter(iD.modes.RotateWay(context, entityId));
-        };
-
-        operation.available = function() {
-            if (selectedIDs.length !== 1 || entity.type !== 'way')
-                return false;
-            if (geometry === 'area')
-                return true;
-            if (entity.isClosed() &&
-                context.graph().parentRelations(entity).some(function(r) { return r.isMultipolygon(); }))
-                return true;
-            return false;
-        };
-
-        operation.disabled = function() {
-            if (extent.percentContainedIn(context.extent()) < 0.8) {
-                return 'too_large';
-            } else if (context.hasHiddenConnections(entityId)) {
-                return 'connected_to_hidden';
-            } else {
-                return false;
-            }
-        };
-
-        operation.tooltip = function() {
-            var disable = operation.disabled();
-            return disable ?
-                t('operations.rotate.' + disable) :
-                t('operations.rotate.description');
-        };
-
-        operation.id = 'rotate';
-        operation.keys = [t('operations.rotate.key')];
-        operation.title = t('operations.rotate.title');
-
-        return operation;
-    }
-
-    function Split(selectedIDs, context) {
-        var vertices = _.filter(selectedIDs, function vertex(entityId) {
-            return context.geometry(entityId) === 'vertex';
-        });
-
-        var entityId = vertices[0],
-            action = iD.actions.Split(entityId);
-
-        if (selectedIDs.length > 1) {
-            action.limitWays(_.without(selectedIDs, entityId));
-        }
-
-        var operation = function() {
-            var annotation;
-
-            var ways = action.ways(context.graph());
-            if (ways.length === 1) {
-                annotation = t('operations.split.annotation.' + context.geometry(ways[0].id));
-            } else {
-                annotation = t('operations.split.annotation.multiple', {n: ways.length});
-            }
-
-            var difference = context.perform(action, annotation);
-            context.enter(iD.modes.Select(context, difference.extantIDs()));
-        };
-
-        operation.available = function() {
-            return vertices.length === 1;
-        };
-
-        operation.disabled = function() {
-            var reason;
-            if (_.some(selectedIDs, context.hasHiddenConnections)) {
-                reason = 'connected_to_hidden';
-            }
-            return action.disabled(context.graph()) || reason;
-        };
-
-        operation.tooltip = function() {
-            var disable = operation.disabled();
-            if (disable) {
-                return t('operations.split.' + disable);
-            }
-
-            var ways = action.ways(context.graph());
-            if (ways.length === 1) {
-                return t('operations.split.description.' + context.geometry(ways[0].id));
-            } else {
-                return t('operations.split.description.multiple');
-            }
-        };
-
-        operation.id = 'split';
-        operation.keys = [t('operations.split.key')];
-        operation.title = t('operations.split.title');
-
-        return operation;
-    }
-
-    function Straighten(selectedIDs, context) {
-        var entityId = selectedIDs[0],
-            action = iD.actions.Straighten(entityId, context.projection);
-
-        function operation() {
-            var annotation = t('operations.straighten.annotation');
-            context.perform(action, annotation);
-        }
-
-        operation.available = function() {
-            var entity = context.entity(entityId);
-            return selectedIDs.length === 1 &&
-                entity.type === 'way' &&
-                !entity.isClosed() &&
-                _.uniq(entity.nodes).length > 2;
-        };
-
-        operation.disabled = function() {
-            var reason;
-            if (context.hasHiddenConnections(entityId)) {
-                reason = 'connected_to_hidden';
-            }
-            return action.disabled(context.graph()) || reason;
-        };
-
-        operation.tooltip = function() {
-            var disable = operation.disabled();
-            return disable ?
-                t('operations.straighten.' + disable) :
-                t('operations.straighten.description');
-        };
-
-        operation.id = 'straighten';
-        operation.keys = [t('operations.straighten.key')];
-        operation.title = t('operations.straighten.title');
-
-        return operation;
-    }
-
-    exports.Circularize = Circularize;
-    exports.Continue = Continue;
-    exports.Delete = Delete;
-    exports.Disconnect = Disconnect;
-    exports.Merge = Merge;
-    exports.Move = Move;
-    exports.Orthogonalize = Orthogonalize;
-    exports.Reverse = Reverse;
-    exports.Rotate = Rotate;
-    exports.Split = Split;
-    exports.Straighten = Straighten;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
\ No newline at end of file
diff --git a/js/lib/id/presets.js b/js/lib/id/presets.js
deleted file mode 100644
index d337183b5..000000000
--- a/js/lib/id/presets.js
+++ /dev/null
@@ -1,481 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (factory((global.iD = global.iD || {}, global.iD.presets = global.iD.presets || {})));
-}(this, function (exports) { 'use strict';
-
-    function Collection(collection) {
-        var maxSearchResults = 50,
-            maxSuggestionResults = 10;
-
-        var presets = {
-
-            collection: collection,
-
-            item: function(id) {
-                return _.find(collection, function(d) {
-                    return d.id === id;
-                });
-            },
-
-            matchGeometry: function(geometry) {
-                return Collection(collection.filter(function(d) {
-                    return d.matchGeometry(geometry);
-                }));
-            },
-
-            search: function(value, geometry) {
-                if (!value) return this;
-
-                value = value.toLowerCase();
-
-                var searchable = _.filter(collection, function(a) {
-                        return a.searchable !== false && a.suggestion !== true;
-                    }),
-                    suggestions = _.filter(collection, function(a) {
-                        return a.suggestion === true;
-                    });
-
-                function leading(a) {
-                    var index = a.indexOf(value);
-                    return index === 0 || a[index - 1] === ' ';
-                }
-
-                // matches value to preset.name
-                var leading_name = _.filter(searchable, function(a) {
-                        return leading(a.name().toLowerCase());
-                    }).sort(function(a, b) {
-                        var i = a.name().toLowerCase().indexOf(value) - b.name().toLowerCase().indexOf(value);
-                        if (i === 0) return a.name().length - b.name().length;
-                        else return i;
-                    });
-
-                // matches value to preset.terms values
-                var leading_terms = _.filter(searchable, function(a) {
-                        return _.some(a.terms() || [], leading);
-                    });
-
-                // matches value to preset.tags values
-                var leading_tag_values = _.filter(searchable, function(a) {
-                        return _.some(_.without(_.values(a.tags || {}), '*'), leading);
-                    });
-
-
-                // finds close matches to value in preset.name
-                var levenstein_name = searchable.map(function(a) {
-                        return {
-                            preset: a,
-                            dist: iD.util.editDistance(value, a.name().toLowerCase())
-                        };
-                    }).filter(function(a) {
-                        return a.dist + Math.min(value.length - a.preset.name().length, 0) < 3;
-                    }).sort(function(a, b) {
-                        return a.dist - b.dist;
-                    }).map(function(a) {
-                        return a.preset;
-                    });
-
-                // finds close matches to value in preset.terms
-                var leventstein_terms = _.filter(searchable, function(a) {
-                        return _.some(a.terms() || [], function(b) {
-                            return iD.util.editDistance(value, b) + Math.min(value.length - b.length, 0) < 3;
-                        });
-                    });
-
-                function suggestionName(name) {
-                    var nameArray = name.split(' - ');
-                    if (nameArray.length > 1) {
-                        name = nameArray.slice(0, nameArray.length-1).join(' - ');
-                    }
-                    return name.toLowerCase();
-                }
-
-                var leading_suggestions = _.filter(suggestions, function(a) {
-                        return leading(suggestionName(a.name()));
-                    }).sort(function(a, b) {
-                        a = suggestionName(a.name());
-                        b = suggestionName(b.name());
-                        var i = a.indexOf(value) - b.indexOf(value);
-                        if (i === 0) return a.length - b.length;
-                        else return i;
-                    });
-
-                var leven_suggestions = suggestions.map(function(a) {
-                        return {
-                            preset: a,
-                            dist: iD.util.editDistance(value, suggestionName(a.name()))
-                        };
-                    }).filter(function(a) {
-                        return a.dist + Math.min(value.length - suggestionName(a.preset.name()).length, 0) < 1;
-                    }).sort(function(a, b) {
-                        return a.dist - b.dist;
-                    }).map(function(a) {
-                        return a.preset;
-                    });
-
-                var other = presets.item(geometry);
-
-                var results = leading_name.concat(
-                                leading_terms,
-                                leading_tag_values,
-                                leading_suggestions.slice(0, maxSuggestionResults+5),
-                                levenstein_name,
-                                leventstein_terms,
-                                leven_suggestions.slice(0, maxSuggestionResults)
-                            ).slice(0, maxSearchResults-1);
-
-                return Collection(_.uniq(
-                        results.concat(other)
-                    ));
-            }
-        };
-
-        return presets;
-    }
-
-    function Category(id, category, all) {
-        category = _.clone(category);
-
-        category.id = id;
-
-        category.members = Collection(category.members.map(function(id) {
-            return all.item(id);
-        }));
-
-        category.matchGeometry = function(geometry) {
-            return category.geometry.indexOf(geometry) >= 0;
-        };
-
-        category.matchScore = function() { return -1; };
-
-        category.name = function() {
-            return t('presets.categories.' + id + '.name', {'default': id});
-        };
-
-        category.terms = function() {
-            return [];
-        };
-
-        return category;
-    }
-
-    function Field(id, field) {
-        field = _.clone(field);
-
-        field.id = id;
-
-        field.matchGeometry = function(geometry) {
-            return !field.geometry || field.geometry === geometry;
-        };
-
-        field.t = function(scope, options) {
-            return t('presets.fields.' + id + '.' + scope, options);
-        };
-
-        field.label = function() {
-            return field.t('label', {'default': id});
-        };
-
-        var placeholder = field.placeholder;
-        field.placeholder = function() {
-            return field.t('placeholder', {'default': placeholder});
-        };
-
-        return field;
-    }
-
-    function Preset(id, preset, fields) {
-        preset = _.clone(preset);
-
-        preset.id = id;
-        preset.fields = (preset.fields || []).map(getFields);
-        preset.geometry = (preset.geometry || []);
-
-        function getFields(f) {
-            return fields[f];
-        }
-
-        preset.matchGeometry = function(geometry) {
-            return preset.geometry.indexOf(geometry) >= 0;
-        };
-
-        var matchScore = preset.matchScore || 1;
-        preset.matchScore = function(entity) {
-            var tags = preset.tags,
-                score = 0;
-
-            for (var t in tags) {
-                if (entity.tags[t] === tags[t]) {
-                    score += matchScore;
-                } else if (tags[t] === '*' && t in entity.tags) {
-                    score += matchScore / 2;
-                } else {
-                    return -1;
-                }
-            }
-
-            return score;
-        };
-
-        preset.t = function(scope, options) {
-            return t('presets.presets.' + id + '.' + scope, options);
-        };
-
-        var name = preset.name;
-        preset.name = function() {
-            if (preset.suggestion) {
-                id = id.split('/');
-                id = id[0] + '/' + id[1];
-                return name + ' - ' + t('presets.presets.' + id + '.name');
-            }
-            return preset.t('name', {'default': name});
-        };
-
-        preset.terms = function() {
-            return preset.t('terms', {'default': ''}).toLowerCase().trim().split(/\s*,+\s*/);
-        };
-
-        preset.isFallback = function() {
-            var tagCount = Object.keys(preset.tags).length;
-            return tagCount === 0 || (tagCount === 1 && preset.tags.hasOwnProperty('area'));
-        };
-
-        preset.reference = function(geometry) {
-            var key = Object.keys(preset.tags)[0],
-                value = preset.tags[key];
-
-            if (geometry === 'relation' && key === 'type') {
-                return { rtype: value };
-            } else if (value === '*') {
-                return { key: key };
-            } else {
-                return { key: key, value: value };
-            }
-        };
-
-        var removeTags = preset.removeTags || preset.tags;
-        preset.removeTags = function(tags, geometry) {
-            tags = _.omit(tags, _.keys(removeTags));
-
-            for (var f in preset.fields) {
-                var field = preset.fields[f];
-                if (field.matchGeometry(geometry) && field.default === tags[field.key]) {
-                    delete tags[field.key];
-                }
-            }
-
-            delete tags.area;
-            return tags;
-        };
-
-        var applyTags = preset.addTags || preset.tags;
-        preset.applyTags = function(tags, geometry) {
-            var k;
-
-            tags = _.clone(tags);
-
-            for (k in applyTags) {
-                if (applyTags[k] === '*') {
-                    tags[k] = 'yes';
-                } else {
-                    tags[k] = applyTags[k];
-                }
-            }
-
-            // Add area=yes if necessary.
-            // This is necessary if the geometry is already an area (e.g. user drew an area) AND any of:
-            // 1. chosen preset could be either an area or a line (`barrier=city_wall`)
-            // 2. chosen preset doesn't have a key in areaKeys (`railway=station`)
-            if (geometry === 'area') {
-                var needsAreaTag = true;
-                if (preset.geometry.indexOf('line') === -1) {
-                    for (k in applyTags) {
-                        if (k in iD.areaKeys) {
-                            needsAreaTag = false;
-                            break;
-                        }
-                    }
-                }
-                if (needsAreaTag) {
-                    tags.area = 'yes';
-                }
-            }
-
-            for (var f in preset.fields) {
-                var field = preset.fields[f];
-                if (field.matchGeometry(geometry) && field.key && !tags[field.key] && field.default) {
-                    tags[field.key] = field.default;
-                }
-            }
-
-            return tags;
-        };
-
-        return preset;
-    }
-
-    function presets() {
-        // an iD.presets.Collection with methods for
-        // loading new data and returning defaults
-
-        var all = Collection([]),
-            defaults = { area: all, line: all, point: all, vertex: all, relation: all },
-            fields = {},
-            universal = [],
-            recent = Collection([]);
-
-        // Index of presets by (geometry, tag key).
-        var index = {
-            point: {},
-            vertex: {},
-            line: {},
-            area: {},
-            relation: {}
-        };
-
-        all.match = function(entity, resolver) {
-            var geometry = entity.geometry(resolver),
-                geometryMatches = index[geometry],
-                best = -1,
-                match;
-
-            for (var k in entity.tags) {
-                var keyMatches = geometryMatches[k];
-                if (!keyMatches) continue;
-
-                for (var i = 0; i < keyMatches.length; i++) {
-                    var score = keyMatches[i].matchScore(entity);
-                    if (score > best) {
-                        best = score;
-                        match = keyMatches[i];
-                    }
-                }
-            }
-
-            return match || all.item(geometry);
-        };
-
-        // Because of the open nature of tagging, iD will never have a complete
-        // list of tags used in OSM, so we want it to have logic like "assume
-        // that a closed way with an amenity tag is an area, unless the amenity
-        // is one of these specific types". This function computes a structure
-        // that allows testing of such conditions, based on the presets designated
-        // as as supporting (or not supporting) the area geometry.
-        //
-        // The returned object L is a whitelist/blacklist of tags. A closed way
-        // with a tag (k, v) is considered to be an area if `k in L && !(v in L[k])`
-        // (see `iD.Way#isArea()`). In other words, the keys of L form the whitelist,
-        // and the subkeys form the blacklist.
-        all.areaKeys = function() {
-            var areaKeys = {},
-                ignore = ['barrier', 'highway', 'footway', 'railway', 'type'],
-                presets = _.reject(all.collection, 'suggestion');
-
-            // whitelist
-            presets.forEach(function(d) {
-                for (var key in d.tags) break;
-                if (!key) return;
-                if (ignore.indexOf(key) !== -1) return;
-
-                if (d.geometry.indexOf('area') !== -1) {
-                    areaKeys[key] = areaKeys[key] || {};
-                }
-            });
-
-            // blacklist
-            presets.forEach(function(d) {
-                for (var key in d.tags) break;
-                if (!key) return;
-                if (ignore.indexOf(key) !== -1) return;
-
-                var value = d.tags[key];
-                if (d.geometry.indexOf('area') === -1 &&
-                    d.geometry.indexOf('line') !== -1 &&
-                    key in areaKeys && value !== '*') {
-                    areaKeys[key][value] = true;
-                }
-            });
-
-            return areaKeys;
-        };
-
-        all.load = function(d) {
-
-            if (d.fields) {
-                _.forEach(d.fields, function(d, id) {
-                    fields[id] = Field(id, d);
-                    if (d.universal) universal.push(fields[id]);
-                });
-            }
-
-            if (d.presets) {
-                _.forEach(d.presets, function(d, id) {
-                    all.collection.push(Preset(id, d, fields));
-                });
-            }
-
-            if (d.categories) {
-                _.forEach(d.categories, function(d, id) {
-                    all.collection.push(Category(id, d, all));
-                });
-            }
-
-            if (d.defaults) {
-                var getItem = _.bind(all.item, all);
-                defaults = {
-                    area: Collection(d.defaults.area.map(getItem)),
-                    line: Collection(d.defaults.line.map(getItem)),
-                    point: Collection(d.defaults.point.map(getItem)),
-                    vertex: Collection(d.defaults.vertex.map(getItem)),
-                    relation: Collection(d.defaults.relation.map(getItem))
-                };
-            }
-
-            for (var i = 0; i < all.collection.length; i++) {
-                var preset = all.collection[i],
-                    geometry = preset.geometry;
-
-                for (var j = 0; j < geometry.length; j++) {
-                    var g = index[geometry[j]];
-                    for (var k in preset.tags) {
-                        (g[k] = g[k] || []).push(preset);
-                    }
-                }
-            }
-
-            return all;
-        };
-
-        all.field = function(id) {
-            return fields[id];
-        };
-
-        all.universal = function() {
-            return universal;
-        };
-
-        all.defaults = function(geometry, n) {
-            var rec = recent.matchGeometry(geometry).collection.slice(0, 4),
-                def = _.uniq(rec.concat(defaults[geometry].collection)).slice(0, n - 1);
-            return Collection(_.uniq(rec.concat(def).concat(all.item(geometry))));
-        };
-
-        all.choose = function(preset) {
-            if (!preset.isFallback()) {
-                recent = Collection(_.uniq([preset].concat(recent.collection)));
-            }
-            return all;
-        };
-
-        return all;
-    }
-
-    exports.Category = Category;
-    exports.Collection = Collection;
-    exports.Field = Field;
-    exports.Preset = Preset;
-    exports.presets = presets;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
\ No newline at end of file
diff --git a/js/lib/id/renderer.js b/js/lib/id/renderer.js
deleted file mode 100644
index 7e7f836d5..000000000
--- a/js/lib/id/renderer.js
+++ /dev/null
@@ -1,1587 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (factory((global.iD = global.iD || {})));
-}(this, function (exports) { 'use strict';
-
-    function BackgroundSource(data) {
-        var source = _.clone(data),
-            offset = [0, 0],
-            name = source.name,
-            best = !!source.best;
-
-        source.scaleExtent = data.scaleExtent || [0, 20];
-        source.overzoom = data.overzoom !== false;
-
-        source.offset = function(_) {
-            if (!arguments.length) return offset;
-            offset = _;
-            return source;
-        };
-
-        source.nudge = function(_, zoomlevel) {
-            offset[0] += _[0] / Math.pow(2, zoomlevel);
-            offset[1] += _[1] / Math.pow(2, zoomlevel);
-            return source;
-        };
-
-        source.name = function() {
-            return name;
-        };
-
-        source.best = function() {
-            return best;
-        };
-
-        source.area = function() {
-            if (!data.polygon) return Number.MAX_VALUE;  // worldwide
-            var area = d3.geo.area({ type: 'MultiPolygon', coordinates: [ data.polygon ] });
-            return isNaN(area) ? 0 : area;
-        };
-
-        source.imageryUsed = function() {
-            return source.id || name;
-        };
-
-        source.url = function(coord) {
-            return data.template
-                .replace('{x}', coord[0])
-                .replace('{y}', coord[1])
-                // TMS-flipped y coordinate
-                .replace(/\{[t-]y\}/, Math.pow(2, coord[2]) - coord[1] - 1)
-                .replace(/\{z(oom)?\}/, coord[2])
-                .replace(/\{switch:([^}]+)\}/, function(s, r) {
-                    var subdomains = r.split(',');
-                    return subdomains[(coord[0] + coord[1]) % subdomains.length];
-                })
-                .replace('{u}', function() {
-                    var u = '';
-                    for (var zoom = coord[2]; zoom > 0; zoom--) {
-                        var b = 0;
-                        var mask = 1 << (zoom - 1);
-                        if ((coord[0] & mask) !== 0) b++;
-                        if ((coord[1] & mask) !== 0) b += 2;
-                        u += b.toString();
-                    }
-                    return u;
-                });
-        };
-
-        source.intersects = function(extent) {
-            extent = extent.polygon();
-            return !data.polygon || data.polygon.some(function(polygon) {
-                return iD.geo.polygonIntersectsPolygon(polygon, extent, true);
-            });
-        };
-
-        source.validZoom = function(z) {
-            return source.scaleExtent[0] <= z &&
-                (source.overzoom || source.scaleExtent[1] > z);
-        };
-
-        source.isLocatorOverlay = function() {
-            return name === 'Locator Overlay';
-        };
-
-        source.copyrightNotices = function() {};
-
-        return source;
-    }
-
-    BackgroundSource.Bing = function(data, dispatch) {
-        // http://msdn.microsoft.com/en-us/library/ff701716.aspx
-        // http://msdn.microsoft.com/en-us/library/ff701701.aspx
-
-        data.template = 'https://ecn.t{switch:0,1,2,3}.tiles.virtualearth.net/tiles/a{u}.jpeg?g=587&mkt=en-gb&n=z';
-
-        var bing = BackgroundSource(data),
-            key = 'Arzdiw4nlOJzRwOz__qailc8NiR31Tt51dN2D7cm57NrnceZnCpgOkmJhNpGoppU', // Same as P2 and JOSM
-            url = 'https://dev.virtualearth.net/REST/v1/Imagery/Metadata/Aerial?include=ImageryProviders&key=' +
-                key + '&jsonp={callback}',
-            providers = [];
-
-        d3.jsonp(url, function(json) {
-            providers = json.resourceSets[0].resources[0].imageryProviders.map(function(provider) {
-                return {
-                    attribution: provider.attribution,
-                    areas: provider.coverageAreas.map(function(area) {
-                        return {
-                            zoom: [area.zoomMin, area.zoomMax],
-                            extent: iD.geo.Extent([area.bbox[1], area.bbox[0]], [area.bbox[3], area.bbox[2]])
-                        };
-                    })
-                };
-            });
-            dispatch.change();
-        });
-
-        bing.copyrightNotices = function(zoom, extent) {
-            zoom = Math.min(zoom, 21);
-            return providers.filter(function(provider) {
-                return _.some(provider.areas, function(area) {
-                    return extent.intersects(area.extent) &&
-                        area.zoom[0] <= zoom &&
-                        area.zoom[1] >= zoom;
-                });
-            }).map(function(provider) {
-                return provider.attribution;
-            }).join(', ');
-        };
-
-        bing.logo = 'bing_maps.png';
-        bing.terms_url = 'https://blog.openstreetmap.org/2010/11/30/microsoft-imagery-details';
-
-        return bing;
-    };
-
-    BackgroundSource.None = function() {
-        var source = BackgroundSource({id: 'none', template: ''});
-
-        source.name = function() {
-            return t('background.none');
-        };
-
-        source.imageryUsed = function() {
-            return 'None';
-        };
-
-        source.area = function() {
-            return -1;
-        };
-
-        return source;
-    };
-
-    BackgroundSource.Custom = function(template) {
-        var source = BackgroundSource({id: 'custom', template: template});
-
-        source.name = function() {
-            return t('background.custom');
-        };
-
-        source.imageryUsed = function() {
-            return 'Custom (' + template + ')';
-        };
-
-        source.area = function() {
-            return -2;
-        };
-
-        return source;
-    };
-
-    function TileLayer(context) {
-        var tileSize = 256,
-            tile = d3.geo.tile(),
-            projection,
-            cache = {},
-            tileOrigin,
-            z,
-            transformProp = iD.util.prefixCSSProperty('Transform'),
-            source = d3.functor('');
-
-
-        // blacklist overlay tiles around Null Island..
-        function nearNullIsland(x, y, z) {
-            if (z >= 7) {
-                var center = Math.pow(2, z - 1),
-                    width = Math.pow(2, z - 6),
-                    min = center - (width / 2),
-                    max = center + (width / 2) - 1;
-                return x >= min && x <= max && y >= min && y <= max;
-            }
-            return false;
-        }
-
-        function tileSizeAtZoom(d, z) {
-            var epsilon = 0.002;
-            return ((tileSize * Math.pow(2, z - d[2])) / tileSize) + epsilon;
-        }
-
-        function atZoom(t, distance) {
-            var power = Math.pow(2, distance);
-            return [
-                Math.floor(t[0] * power),
-                Math.floor(t[1] * power),
-                t[2] + distance];
-        }
-
-        function lookUp(d) {
-            for (var up = -1; up > -d[2]; up--) {
-                var tile = atZoom(d, up);
-                if (cache[source.url(tile)] !== false) {
-                    return tile;
-                }
-            }
-        }
-
-        function uniqueBy(a, n) {
-            var o = [], seen = {};
-            for (var i = 0; i < a.length; i++) {
-                if (seen[a[i][n]] === undefined) {
-                    o.push(a[i]);
-                    seen[a[i][n]] = true;
-                }
-            }
-            return o;
-        }
-
-        function addSource(d) {
-            d.push(source.url(d));
-            return d;
-        }
-
-        // Update tiles based on current state of `projection`.
-        function background(selection) {
-            tile.scale(projection.scale() * 2 * Math.PI)
-                .translate(projection.translate());
-
-            tileOrigin = [
-                projection.scale() * Math.PI - projection.translate()[0],
-                projection.scale() * Math.PI - projection.translate()[1]];
-
-            z = Math.max(Math.log(projection.scale() * 2 * Math.PI) / Math.log(2) - 8, 0);
-
-            render(selection);
-        }
-
-        // Derive the tiles onscreen, remove those offscreen and position them.
-        // Important that this part not depend on `projection` because it's
-        // rentered when tiles load/error (see #644).
-        function render(selection) {
-            var requests = [];
-            var showDebug = context.getDebug('tile') && !source.overlay;
-
-            if (source.validZoom(z)) {
-                tile().forEach(function(d) {
-                    addSource(d);
-                    if (d[3] === '') return;
-                    if (typeof d[3] !== 'string') return; // Workaround for chrome crash https://github.com/openstreetmap/iD/issues/2295
-                    requests.push(d);
-                    if (cache[d[3]] === false && lookUp(d)) {
-                        requests.push(addSource(lookUp(d)));
-                    }
-                });
-
-                requests = uniqueBy(requests, 3).filter(function(r) {
-                    if (!!source.overlay && nearNullIsland(r[0], r[1], r[2])) {
-                        return false;
-                    }
-                    // don't re-request tiles which have failed in the past
-                    return cache[r[3]] !== false;
-                });
-            }
-
-            var pixelOffset = [
-                source.offset()[0] * Math.pow(2, z),
-                source.offset()[1] * Math.pow(2, z)
-            ];
-
-            function load(d) {
-                cache[d[3]] = true;
-                d3.select(this)
-                    .on('error', null)
-                    .on('load', null)
-                    .classed('tile-loaded', true);
-                render(selection);
-            }
-
-            function error(d) {
-                cache[d[3]] = false;
-                d3.select(this)
-                    .on('error', null)
-                    .on('load', null)
-                    .remove();
-                render(selection);
-            }
-
-            function imageTransform(d) {
-                var _ts = tileSize * Math.pow(2, z - d[2]);
-                var scale = tileSizeAtZoom(d, z);
-                return 'translate(' +
-                    ((d[0] * _ts) - tileOrigin[0] + pixelOffset[0]) + 'px,' +
-                    ((d[1] * _ts) - tileOrigin[1] + pixelOffset[1]) + 'px)' +
-                    'scale(' + scale + ',' + scale + ')';
-            }
-
-            function debugTransform(d) {
-                var _ts = tileSize * Math.pow(2, z - d[2]);
-                var scale = tileSizeAtZoom(d, z);
-                return 'translate(' +
-                    ((d[0] * _ts) - tileOrigin[0] + pixelOffset[0] + scale * (tileSize / 4)) + 'px,' +
-                    ((d[1] * _ts) - tileOrigin[1] + pixelOffset[1] + scale * (tileSize / 2)) + 'px)';
-            }
-
-            var image = selection
-                .selectAll('img')
-                .data(requests, function(d) { return d[3]; });
-
-            image.exit()
-                .style(transformProp, imageTransform)
-                .classed('tile-removing', true)
-                .each(function() {
-                    var tile = d3.select(this);
-                    window.setTimeout(function() {
-                        if (tile.classed('tile-removing')) {
-                            tile.remove();
-                        }
-                    }, 300);
-                });
-
-            image.enter().append('img')
-                .attr('class', 'tile')
-                .attr('src', function(d) { return d[3]; })
-                .on('error', error)
-                .on('load', load);
-
-            image
-                .style(transformProp, imageTransform)
-                .classed('tile-debug', showDebug)
-                .classed('tile-removing', false);
-
-
-            var debug = selection.selectAll('.tile-label-debug')
-                .data(showDebug ? requests : [], function(d) { return d[3]; });
-
-            debug.exit()
-                .remove();
-
-            debug.enter()
-                .append('div')
-                .attr('class', 'tile-label-debug');
-
-            debug
-                .text(function(d) { return d[2] + ' / ' + d[0] + ' / ' + d[1]; })
-                .style(transformProp, debugTransform);
-        }
-
-        background.projection = function(_) {
-            if (!arguments.length) return projection;
-            projection = _;
-            return background;
-        };
-
-        background.dimensions = function(_) {
-            if (!arguments.length) return tile.size();
-            tile.size(_);
-            return background;
-        };
-
-        background.source = function(_) {
-            if (!arguments.length) return source;
-            source = _;
-            cache = {};
-            tile.scaleExtent(source.scaleExtent);
-            return background;
-        };
-
-        return background;
-    }
-
-    function Background(context) {
-        var dispatch = d3.dispatch('change'),
-            baseLayer = TileLayer(context).projection(context.projection),
-            overlayLayers = [],
-            backgroundSources;
-
-
-        function findSource(id) {
-            return _.find(backgroundSources, function(d) {
-                return d.id && d.id === id;
-            });
-        }
-
-
-        function background(selection) {
-            var base = selection.selectAll('.layer-background')
-                .data([0]);
-
-            base.enter()
-                .insert('div', '.layer-data')
-                .attr('class', 'layer layer-background');
-
-            base.call(baseLayer);
-
-            var overlays = selection.selectAll('.layer-overlay')
-                .data(overlayLayers, function(d) { return d.source().name(); });
-
-            overlays.enter()
-                .insert('div', '.layer-data')
-                .attr('class', 'layer layer-overlay');
-
-            overlays.each(function(layer) {
-                d3.select(this).call(layer);
-            });
-
-            overlays.exit()
-                .remove();
-        }
-
-
-        background.updateImagery = function() {
-            var b = background.baseLayerSource(),
-                o = overlayLayers.map(function (d) { return d.source().id; }).join(','),
-                meters = iD.geo.offsetToMeters(b.offset()),
-                epsilon = 0.01,
-                x = +meters[0].toFixed(2),
-                y = +meters[1].toFixed(2),
-                q = iD.util.stringQs(location.hash.substring(1));
-
-            var id = b.id;
-            if (id === 'custom') {
-                id = 'custom:' + b.template;
-            }
-
-            if (id) {
-                q.background = id;
-            } else {
-                delete q.background;
-            }
-
-            if (o) {
-                q.overlays = o;
-            } else {
-                delete q.overlays;
-            }
-
-            if (Math.abs(x) > epsilon || Math.abs(y) > epsilon) {
-                q.offset = x + ',' + y;
-            } else {
-                delete q.offset;
-            }
-
-            location.replace('#' + iD.util.qsString(q, true));
-
-            var imageryUsed = [b.imageryUsed()];
-
-            overlayLayers.forEach(function (d) {
-                var source = d.source();
-                if (!source.isLocatorOverlay()) {
-                    imageryUsed.push(source.imageryUsed());
-                }
-            });
-
-            var gpx = context.layers().layer('gpx');
-            if (gpx && gpx.enabled() && gpx.hasGpx()) {
-                imageryUsed.push('Local GPX');
-            }
-
-            var mapillary_images = context.layers().layer('mapillary-images');
-            if (mapillary_images && mapillary_images.enabled()) {
-                imageryUsed.push('Mapillary Images');
-            }
-
-            var mapillary_signs = context.layers().layer('mapillary-signs');
-            if (mapillary_signs && mapillary_signs.enabled()) {
-                imageryUsed.push('Mapillary Signs');
-            }
-
-            context.history().imageryUsed(imageryUsed);
-        };
-
-        background.sources = function(extent) {
-            return backgroundSources.filter(function(source) {
-                return source.intersects(extent);
-            });
-        };
-
-        background.dimensions = function(_) {
-            baseLayer.dimensions(_);
-
-            overlayLayers.forEach(function(layer) {
-                layer.dimensions(_);
-            });
-        };
-
-        background.baseLayerSource = function(d) {
-            if (!arguments.length) return baseLayer.source();
-            baseLayer.source(d);
-            dispatch.change();
-            background.updateImagery();
-            return background;
-        };
-
-        background.bing = function() {
-            background.baseLayerSource(findSource('Bing'));
-        };
-
-        background.showsLayer = function(d) {
-            return d === baseLayer.source() ||
-                (d.id === 'custom' && baseLayer.source().id === 'custom') ||
-                overlayLayers.some(function(l) { return l.source() === d; });
-        };
-
-        background.overlayLayerSources = function() {
-            return overlayLayers.map(function (l) { return l.source(); });
-        };
-
-        background.toggleOverlayLayer = function(d) {
-            var layer;
-
-            for (var i = 0; i < overlayLayers.length; i++) {
-                layer = overlayLayers[i];
-                if (layer.source() === d) {
-                    overlayLayers.splice(i, 1);
-                    dispatch.change();
-                    background.updateImagery();
-                    return;
-                }
-            }
-
-            layer = TileLayer(context)
-                .source(d)
-                .projection(context.projection)
-                .dimensions(baseLayer.dimensions());
-
-            overlayLayers.push(layer);
-            dispatch.change();
-            background.updateImagery();
-        };
-
-        background.nudge = function(d, zoom) {
-            baseLayer.source().nudge(d, zoom);
-            dispatch.change();
-            background.updateImagery();
-            return background;
-        };
-
-        background.offset = function(d) {
-            if (!arguments.length) return baseLayer.source().offset();
-            baseLayer.source().offset(d);
-            dispatch.change();
-            background.updateImagery();
-            return background;
-        };
-
-        background.load = function(imagery) {
-            function parseMap(qmap) {
-                if (!qmap) return false;
-                var args = qmap.split('/').map(Number);
-                if (args.length < 3 || args.some(isNaN)) return false;
-                return iD.geo.Extent([args[1], args[2]]);
-            }
-
-            var q = iD.util.stringQs(location.hash.substring(1)),
-                chosen = q.background || q.layer,
-                extent = parseMap(q.map),
-                best;
-
-            backgroundSources = imagery.map(function(source) {
-                if (source.type === 'bing') {
-                    return BackgroundSource.Bing(source, dispatch);
-                } else {
-                    return BackgroundSource(source);
-                }
-            });
-
-            backgroundSources.unshift(BackgroundSource.None());
-
-            if (!chosen && extent) {
-                best = _.find(this.sources(extent), function(s) { return s.best(); });
-            }
-
-            if (chosen && chosen.indexOf('custom:') === 0) {
-                background.baseLayerSource(BackgroundSource.Custom(chosen.replace(/^custom:/, '')));
-            } else {
-                background.baseLayerSource(findSource(chosen) || best || findSource('Bing') || backgroundSources[1] || backgroundSources[0]);
-            }
-
-            var locator = _.find(backgroundSources, function(d) {
-                return d.overlay && d.default;
-            });
-
-            if (locator) {
-                background.toggleOverlayLayer(locator);
-            }
-
-            var overlays = (q.overlays || '').split(',');
-            overlays.forEach(function(overlay) {
-                overlay = findSource(overlay);
-                if (overlay) {
-                    background.toggleOverlayLayer(overlay);
-                }
-            });
-
-            if (q.gpx) {
-                var gpx = context.layers().layer('gpx');
-                if (gpx) {
-                    gpx.url(q.gpx);
-                }
-            }
-
-            if (q.offset) {
-                var offset = q.offset.replace(/;/g, ',').split(',').map(function(n) {
-                    return !isNaN(n) && n;
-                });
-
-                if (offset.length === 2) {
-                    background.offset(iD.geo.metersToOffset(offset));
-                }
-            }
-        };
-
-        return d3.rebind(background, dispatch, 'on');
-    }
-
-    function Features(context) {
-        var traffic_roads = {
-            'motorway': true,
-            'motorway_link': true,
-            'trunk': true,
-            'trunk_link': true,
-            'primary': true,
-            'primary_link': true,
-            'secondary': true,
-            'secondary_link': true,
-            'tertiary': true,
-            'tertiary_link': true,
-            'residential': true,
-            'unclassified': true,
-            'living_street': true
-        };
-
-        var service_roads = {
-            'service': true,
-            'road': true,
-            'track': true
-        };
-
-        var paths = {
-            'path': true,
-            'footway': true,
-            'cycleway': true,
-            'bridleway': true,
-            'steps': true,
-            'pedestrian': true,
-            'corridor': true
-        };
-
-        var past_futures = {
-            'proposed': true,
-            'construction': true,
-            'abandoned': true,
-            'dismantled': true,
-            'disused': true,
-            'razed': true,
-            'demolished': true,
-            'obliterated': true
-        };
-
-        var dispatch = d3.dispatch('change', 'redraw'),
-            _cullFactor = 1,
-            _cache = {},
-            _features = {},
-            _stats = {},
-            _keys = [],
-            _hidden = [];
-
-        function update() {
-            _hidden = features.hidden();
-            dispatch.change();
-            dispatch.redraw();
-        }
-
-        function defineFeature(k, filter, max) {
-            _keys.push(k);
-            _features[k] = {
-                filter: filter,
-                enabled: true,   // whether the user wants it enabled..
-                count: 0,
-                currentMax: (max || Infinity),
-                defaultMax: (max || Infinity),
-                enable: function() { this.enabled = true; this.currentMax = this.defaultMax; },
-                disable: function() { this.enabled = false; this.currentMax = 0; },
-                hidden: function() { return !context.editable() || this.count > this.currentMax * _cullFactor; },
-                autoHidden: function() { return this.hidden() && this.currentMax > 0; }
-            };
-        }
-
-
-        defineFeature('points', function isPoint(entity, resolver, geometry) {
-            return geometry === 'point';
-        }, 200);
-
-        defineFeature('traffic_roads', function isTrafficRoad(entity) {
-            return traffic_roads[entity.tags.highway];
-        });
-
-        defineFeature('service_roads', function isServiceRoad(entity) {
-            return service_roads[entity.tags.highway];
-        });
-
-        defineFeature('paths', function isPath(entity) {
-            return paths[entity.tags.highway];
-        });
-
-        defineFeature('buildings', function isBuilding(entity) {
-            return (
-                !!entity.tags['building:part'] ||
-                (!!entity.tags.building && entity.tags.building !== 'no') ||
-                entity.tags.amenity === 'shelter' ||
-                entity.tags.parking === 'multi-storey' ||
-                entity.tags.parking === 'sheds' ||
-                entity.tags.parking === 'carports' ||
-                entity.tags.parking === 'garage_boxes'
-            );
-        }, 250);
-
-        defineFeature('landuse', function isLanduse(entity, resolver, geometry) {
-            return geometry === 'area' &&
-                !_features.buildings.filter(entity) &&
-                !_features.water.filter(entity);
-        });
-
-        defineFeature('boundaries', function isBoundary(entity) {
-            return !!entity.tags.boundary;
-        });
-
-        defineFeature('water', function isWater(entity) {
-            return (
-                !!entity.tags.waterway ||
-                entity.tags.natural === 'water' ||
-                entity.tags.natural === 'coastline' ||
-                entity.tags.natural === 'bay' ||
-                entity.tags.landuse === 'pond' ||
-                entity.tags.landuse === 'basin' ||
-                entity.tags.landuse === 'reservoir' ||
-                entity.tags.landuse === 'salt_pond'
-            );
-        });
-
-        defineFeature('rail', function isRail(entity) {
-            return (
-                !!entity.tags.railway ||
-                entity.tags.landuse === 'railway'
-            ) && !(
-                traffic_roads[entity.tags.highway] ||
-                service_roads[entity.tags.highway] ||
-                paths[entity.tags.highway]
-            );
-        });
-
-        defineFeature('power', function isPower(entity) {
-            return !!entity.tags.power;
-        });
-
-        // contains a past/future tag, but not in active use as a road/path/cycleway/etc..
-        defineFeature('past_future', function isPastFuture(entity) {
-            if (
-                traffic_roads[entity.tags.highway] ||
-                service_roads[entity.tags.highway] ||
-                paths[entity.tags.highway]
-            ) { return false; }
-
-            var strings = Object.keys(entity.tags);
-
-            for (var i = 0; i < strings.length; i++) {
-                var s = strings[i];
-                if (past_futures[s] || past_futures[entity.tags[s]]) { return true; }
-            }
-            return false;
-        });
-
-        // Lines or areas that don't match another feature filter.
-        // IMPORTANT: The 'others' feature must be the last one defined,
-        //   so that code in getMatches can skip this test if `hasMatch = true`
-        defineFeature('others', function isOther(entity, resolver, geometry) {
-            return (geometry === 'line' || geometry === 'area');
-        });
-
-
-        function features() {}
-
-        features.features = function() {
-            return _features;
-        };
-
-        features.keys = function() {
-            return _keys;
-        };
-
-        features.enabled = function(k) {
-            if (!arguments.length) {
-                return _.filter(_keys, function(k) { return _features[k].enabled; });
-            }
-            return _features[k] && _features[k].enabled;
-        };
-
-        features.disabled = function(k) {
-            if (!arguments.length) {
-                return _.reject(_keys, function(k) { return _features[k].enabled; });
-            }
-            return _features[k] && !_features[k].enabled;
-        };
-
-        features.hidden = function(k) {
-            if (!arguments.length) {
-                return _.filter(_keys, function(k) { return _features[k].hidden(); });
-            }
-            return _features[k] && _features[k].hidden();
-        };
-
-        features.autoHidden = function(k) {
-            if (!arguments.length) {
-                return _.filter(_keys, function(k) { return _features[k].autoHidden(); });
-            }
-            return _features[k] && _features[k].autoHidden();
-        };
-
-        features.enable = function(k) {
-            if (_features[k] && !_features[k].enabled) {
-                _features[k].enable();
-                update();
-            }
-        };
-
-        features.disable = function(k) {
-            if (_features[k] && _features[k].enabled) {
-                _features[k].disable();
-                update();
-            }
-        };
-
-        features.toggle = function(k) {
-            if (_features[k]) {
-                (function(f) { return f.enabled ? f.disable() : f.enable(); }(_features[k]));
-                update();
-            }
-        };
-
-        features.resetStats = function() {
-            _.each(_features, function(f) { f.count = 0; });
-            dispatch.change();
-        };
-
-        features.gatherStats = function(d, resolver, dimensions) {
-            var needsRedraw = false,
-                type = _.groupBy(d, function(ent) { return ent.type; }),
-                entities = [].concat(type.relation || [], type.way || [], type.node || []),
-                currHidden, geometry, matches;
-
-            _.each(_features, function(f) { f.count = 0; });
-
-            // adjust the threshold for point/building culling based on viewport size..
-            // a _cullFactor of 1 corresponds to a 1000x1000px viewport..
-            _cullFactor = dimensions[0] * dimensions[1] / 1000000;
-
-            for (var i = 0; i < entities.length; i++) {
-                geometry = entities[i].geometry(resolver);
-                if (!(geometry === 'vertex' || geometry === 'relation')) {
-                    matches = Object.keys(features.getMatches(entities[i], resolver, geometry));
-                    for (var j = 0; j < matches.length; j++) {
-                        _features[matches[j]].count++;
-                    }
-                }
-            }
-
-            currHidden = features.hidden();
-            if (currHidden !== _hidden) {
-                _hidden = currHidden;
-                needsRedraw = true;
-                dispatch.change();
-            }
-
-            return needsRedraw;
-        };
-
-        features.stats = function() {
-            _.each(_keys, function(k) { _stats[k] = _features[k].count; });
-            return _stats;
-        };
-
-        features.clear = function(d) {
-            for (var i = 0; i < d.length; i++) {
-                features.clearEntity(d[i]);
-            }
-        };
-
-        features.clearEntity = function(entity) {
-            delete _cache[iD.Entity.key(entity)];
-        };
-
-        features.reset = function() {
-            _cache = {};
-        };
-
-        features.getMatches = function(entity, resolver, geometry) {
-            if (geometry === 'vertex' || geometry === 'relation') return {};
-
-            var ent = iD.Entity.key(entity);
-            if (!_cache[ent]) {
-                _cache[ent] = {};
-            }
-
-            if (!_cache[ent].matches) {
-                var matches = {},
-                    hasMatch = false;
-
-                for (var i = 0; i < _keys.length; i++) {
-                    if (_keys[i] === 'others') {
-                        if (hasMatch) continue;
-
-                        // Multipolygon members:
-                        // If an entity...
-                        //   1. is a way that hasn't matched other "interesting" feature rules,
-                        //   2. and it belongs to a single parent multipolygon relation
-                        // ...then match whatever feature rules the parent multipolygon has matched.
-                        // see #2548, #2887
-                        //
-                        // IMPORTANT:
-                        // For this to work, getMatches must be called on relations before ways.
-                        //
-                        if (entity.type === 'way') {
-                            var parents = features.getParents(entity, resolver, geometry);
-                            if (parents.length === 1 && parents[0].isMultipolygon()) {
-                                var pkey = iD.Entity.key(parents[0]);
-                                if (_cache[pkey] && _cache[pkey].matches) {
-                                    matches = _.clone(_cache[pkey].matches);
-                                    continue;
-                                }
-                            }
-                        }
-                    }
-
-                    if (_features[_keys[i]].filter(entity, resolver, geometry)) {
-                        matches[_keys[i]] = hasMatch = true;
-                    }
-                }
-                _cache[ent].matches = matches;
-            }
-
-            return _cache[ent].matches;
-        };
-
-        features.getParents = function(entity, resolver, geometry) {
-            if (geometry === 'point') return [];
-
-            var ent = iD.Entity.key(entity);
-            if (!_cache[ent]) {
-                _cache[ent] = {};
-            }
-
-            if (!_cache[ent].parents) {
-                var parents = [];
-                if (geometry === 'vertex') {
-                    parents = resolver.parentWays(entity);
-                } else {   // 'line', 'area', 'relation'
-                    parents = resolver.parentRelations(entity);
-                }
-                _cache[ent].parents = parents;
-            }
-            return _cache[ent].parents;
-        };
-
-        features.isHiddenFeature = function(entity, resolver, geometry) {
-            if (!_hidden.length) return false;
-            if (!entity.version) return false;
-
-            var matches = features.getMatches(entity, resolver, geometry);
-
-            for (var i = 0; i < _hidden.length; i++) {
-                if (matches[_hidden[i]]) return true;
-            }
-            return false;
-        };
-
-        features.isHiddenChild = function(entity, resolver, geometry) {
-            if (!_hidden.length) return false;
-            if (!entity.version || geometry === 'point') return false;
-
-            var parents = features.getParents(entity, resolver, geometry);
-            if (!parents.length) return false;
-
-            for (var i = 0; i < parents.length; i++) {
-                if (!features.isHidden(parents[i], resolver, parents[i].geometry(resolver))) {
-                    return false;
-                }
-            }
-            return true;
-        };
-
-        features.hasHiddenConnections = function(entity, resolver) {
-            if (!_hidden.length) return false;
-            var childNodes, connections;
-
-            if (entity.type === 'midpoint') {
-                childNodes = [resolver.entity(entity.edge[0]), resolver.entity(entity.edge[1])];
-                connections = [];
-            } else {
-                childNodes = entity.nodes ? resolver.childNodes(entity) : [];
-                connections = features.getParents(entity, resolver, entity.geometry(resolver));
-            }
-
-            // gather ways connected to child nodes..
-            connections = _.reduce(childNodes, function(result, e) {
-                return resolver.isShared(e) ? _.union(result, resolver.parentWays(e)) : result;
-            }, connections);
-
-            return connections.length ? _.some(connections, function(e) {
-                return features.isHidden(e, resolver, e.geometry(resolver));
-            }) : false;
-        };
-
-        features.isHidden = function(entity, resolver, geometry) {
-            if (!_hidden.length) return false;
-            if (!entity.version) return false;
-
-            var fn = (geometry === 'vertex' ? features.isHiddenChild : features.isHiddenFeature);
-            return fn(entity, resolver, geometry);
-        };
-
-        features.filter = function(d, resolver) {
-            if (!_hidden.length) return d;
-
-            var result = [];
-            for (var i = 0; i < d.length; i++) {
-                var entity = d[i];
-                if (!features.isHidden(entity, resolver, entity.geometry(resolver))) {
-                    result.push(entity);
-                }
-            }
-            return result;
-        };
-
-        return d3.rebind(features, dispatch, 'on');
-    }
-
-    function Map(context) {
-        var dimensions = [1, 1],
-            dispatch = d3.dispatch('move', 'drawn'),
-            projection = context.projection,
-            zoom = d3.behavior.zoom()
-                .translate(projection.translate())
-                .scale(projection.scale() * 2 * Math.PI)
-                .scaleExtent([1024, 256 * Math.pow(2, 24)])
-                .on('zoom', zoomPan),
-            dblclickEnabled = true,
-            redrawEnabled = true,
-            transformStart,
-            transformed = false,
-            easing = false,
-            minzoom = 0,
-            drawLayers = iD.svg.Layers(projection, context),
-            drawPoints = iD.svg.Points(projection, context),
-            drawVertices = iD.svg.Vertices(projection, context),
-            drawLines = iD.svg.Lines(projection),
-            drawAreas = iD.svg.Areas(projection),
-            drawMidpoints = iD.svg.Midpoints(projection, context),
-            drawLabels = iD.svg.Labels(projection, context),
-            supersurface,
-            wrapper,
-            surface,
-            mouse,
-            mousemove;
-
-        function map(selection) {
-            context
-                .on('change.map', redraw);
-            context.history()
-                .on('change.map', redraw);
-            context.background()
-                .on('change.map', redraw);
-            context.features()
-                .on('redraw.map', redraw);
-            drawLayers
-                .on('change.map', function() {
-                    context.background().updateImagery();
-                    redraw();
-                });
-
-            selection
-                .on('dblclick.map', dblClick)
-                .call(zoom);
-
-            supersurface = selection.append('div')
-                .attr('id', 'supersurface')
-                .call(iD.util.setTransform, 0, 0);
-
-            // Need a wrapper div because Opera can't cope with an absolutely positioned
-            // SVG element: http://bl.ocks.org/jfirebaugh/6fbfbd922552bf776c16
-            wrapper = supersurface
-                .append('div')
-                .attr('class', 'layer layer-data');
-
-            map.surface = surface = wrapper
-                .call(drawLayers)
-                .selectAll('.surface')
-                .attr('id', 'surface');
-
-            surface
-                .on('mousedown.zoom', function() {
-                    if (d3.event.button === 2) {
-                        d3.event.stopPropagation();
-                    }
-                }, true)
-                .on('mouseup.zoom', function() {
-                    if (resetTransform()) redraw();
-                })
-                .on('mousemove.map', function() {
-                    mousemove = d3.event;
-                })
-                .on('mouseover.vertices', function() {
-                    if (map.editable() && !transformed) {
-                        var hover = d3.event.target.__data__;
-                        surface.call(drawVertices.drawHover, context.graph(), hover, map.extent(), map.zoom());
-                        dispatch.drawn({full: false});
-                    }
-                })
-                .on('mouseout.vertices', function() {
-                    if (map.editable() && !transformed) {
-                        var hover = d3.event.relatedTarget && d3.event.relatedTarget.__data__;
-                        surface.call(drawVertices.drawHover, context.graph(), hover, map.extent(), map.zoom());
-                        dispatch.drawn({full: false});
-                    }
-                });
-
-
-            supersurface
-                .call(context.background());
-
-
-            context.on('enter.map', function() {
-                if (map.editable() && !transformed) {
-                    var all = context.intersects(map.extent()),
-                        filter = d3.functor(true),
-                        graph = context.graph();
-
-                    all = context.features().filter(all, graph);
-                    surface
-                        .call(drawVertices, graph, all, filter, map.extent(), map.zoom())
-                        .call(drawMidpoints, graph, all, filter, map.trimmedExtent());
-                    dispatch.drawn({full: false});
-                }
-            });
-
-            map.dimensions(selection.dimensions());
-
-            drawLabels.supersurface(supersurface);
-        }
-
-        function pxCenter() {
-            return [dimensions[0] / 2, dimensions[1] / 2];
-        }
-
-        function drawVector(difference, extent) {
-            var graph = context.graph(),
-                features = context.features(),
-                all = context.intersects(map.extent()),
-                data, filter;
-
-            if (difference) {
-                var complete = difference.complete(map.extent());
-                data = _.compact(_.values(complete));
-                filter = function(d) { return d.id in complete; };
-                features.clear(data);
-
-            } else {
-                // force a full redraw if gatherStats detects that a feature
-                // should be auto-hidden (e.g. points or buildings)..
-                if (features.gatherStats(all, graph, dimensions)) {
-                    extent = undefined;
-                }
-
-                if (extent) {
-                    data = context.intersects(map.extent().intersection(extent));
-                    var set = d3.set(_.map(data, 'id'));
-                    filter = function(d) { return set.has(d.id); };
-
-                } else {
-                    data = all;
-                    filter = d3.functor(true);
-                }
-            }
-
-            data = features.filter(data, graph);
-
-            surface
-                .call(drawVertices, graph, data, filter, map.extent(), map.zoom())
-                .call(drawLines, graph, data, filter)
-                .call(drawAreas, graph, data, filter)
-                .call(drawMidpoints, graph, data, filter, map.trimmedExtent())
-                .call(drawLabels, graph, data, filter, dimensions, !difference && !extent)
-                .call(drawPoints, graph, data, filter);
-
-            dispatch.drawn({full: true});
-        }
-
-        function editOff() {
-            context.features().resetStats();
-            surface.selectAll('.layer-osm *').remove();
-            dispatch.drawn({full: true});
-        }
-
-        function dblClick() {
-            if (!dblclickEnabled) {
-                d3.event.preventDefault();
-                d3.event.stopImmediatePropagation();
-            }
-        }
-
-        function zoomPan() {
-            if (Math.log(d3.event.scale) / Math.LN2 - 8 < minzoom) {
-                surface.interrupt();
-                iD.ui.flash(context.container())
-                    .select('.content')
-                    .text(t('cannot_zoom'));
-                setZoom(context.minEditableZoom(), true);
-                queueRedraw();
-                dispatch.move(map);
-                return;
-            }
-
-            projection
-                .translate(d3.event.translate)
-                .scale(d3.event.scale / (2 * Math.PI));
-
-            var scale = d3.event.scale / transformStart[0],
-                tX = (d3.event.translate[0] / scale - transformStart[1][0]) * scale,
-                tY = (d3.event.translate[1] / scale - transformStart[1][1]) * scale;
-
-            transformed = true;
-            iD.util.setTransform(supersurface, tX, tY, scale);
-            queueRedraw();
-
-            dispatch.move(map);
-        }
-
-        function resetTransform() {
-            if (!transformed) return false;
-
-            surface.selectAll('.radial-menu').interrupt().remove();
-            iD.util.setTransform(supersurface, 0, 0);
-            transformed = false;
-            return true;
-        }
-
-        function redraw(difference, extent) {
-            if (!surface || !redrawEnabled) return;
-
-            clearTimeout(timeoutId);
-
-            // If we are in the middle of a zoom/pan, we can't do differenced redraws.
-            // It would result in artifacts where differenced entities are redrawn with
-            // one transform and unchanged entities with another.
-            if (resetTransform()) {
-                difference = extent = undefined;
-            }
-
-            var zoom = String(~~map.zoom());
-            if (surface.attr('data-zoom') !== zoom) {
-                surface.attr('data-zoom', zoom)
-                    .classed('low-zoom', zoom <= 16);
-            }
-
-            if (!difference) {
-                supersurface.call(context.background());
-            }
-
-            // OSM
-            if (map.editable()) {
-                context.loadTiles(projection, dimensions);
-                drawVector(difference, extent);
-            } else {
-                editOff();
-            }
-
-            wrapper
-                .call(drawLayers);
-
-            transformStart = [
-                projection.scale() * 2 * Math.PI,
-                projection.translate().slice()];
-
-            return map;
-        }
-
-        var timeoutId;
-        function queueRedraw() {
-            timeoutId = setTimeout(function() { redraw(); }, 750);
-        }
-
-        function pointLocation(p) {
-            var translate = projection.translate(),
-                scale = projection.scale() * 2 * Math.PI;
-            return [(p[0] - translate[0]) / scale, (p[1] - translate[1]) / scale];
-        }
-
-        function locationPoint(l) {
-            var translate = projection.translate(),
-                scale = projection.scale() * 2 * Math.PI;
-            return [l[0] * scale + translate[0], l[1] * scale + translate[1]];
-        }
-
-        map.mouse = function() {
-            var e = mousemove || d3.event, s;
-            while ((s = e.sourceEvent)) e = s;
-            return mouse(e);
-        };
-
-        map.mouseCoordinates = function() {
-            return projection.invert(map.mouse());
-        };
-
-        map.dblclickEnable = function(_) {
-            if (!arguments.length) return dblclickEnabled;
-            dblclickEnabled = _;
-            return map;
-        };
-
-        map.redrawEnable = function(_) {
-            if (!arguments.length) return redrawEnabled;
-            redrawEnabled = _;
-            return map;
-        };
-
-        function interpolateZoom(_) {
-            var k = projection.scale(),
-                t = projection.translate();
-
-            surface.node().__chart__ = {
-                x: t[0],
-                y: t[1],
-                k: k * 2 * Math.PI
-            };
-
-            setZoom(_);
-            projection.scale(k).translate(t);  // undo setZoom projection changes
-
-            zoom.event(surface.transition());
-        }
-
-        function setZoom(_, force) {
-            if (_ === map.zoom() && !force)
-                return false;
-            var scale = 256 * Math.pow(2, _),
-                center = pxCenter(),
-                l = pointLocation(center);
-            scale = Math.max(1024, Math.min(256 * Math.pow(2, 24), scale));
-            projection.scale(scale / (2 * Math.PI));
-            zoom.scale(scale);
-            var t = projection.translate();
-            l = locationPoint(l);
-            t[0] += center[0] - l[0];
-            t[1] += center[1] - l[1];
-            projection.translate(t);
-            zoom.translate(projection.translate());
-            return true;
-        }
-
-        function setCenter(_) {
-            var c = map.center();
-            if (_[0] === c[0] && _[1] === c[1])
-                return false;
-            var t = projection.translate(),
-                pxC = pxCenter(),
-                ll = projection(_);
-            projection.translate([
-                t[0] - ll[0] + pxC[0],
-                t[1] - ll[1] + pxC[1]]);
-            zoom.translate(projection.translate());
-            return true;
-        }
-
-        map.pan = function(d) {
-            var t = projection.translate();
-            t[0] += d[0];
-            t[1] += d[1];
-            projection.translate(t);
-            zoom.translate(projection.translate());
-            dispatch.move(map);
-            return redraw();
-        };
-
-        map.dimensions = function(_) {
-            if (!arguments.length) return dimensions;
-            var center = map.center();
-            dimensions = _;
-            drawLayers.dimensions(dimensions);
-            context.background().dimensions(dimensions);
-            projection.clipExtent([[0, 0], dimensions]);
-            mouse = iD.util.fastMouse(supersurface.node());
-            setCenter(center);
-            return redraw();
-        };
-
-        function zoomIn(integer) {
-          interpolateZoom(~~map.zoom() + integer);
-        }
-
-        function zoomOut(integer) {
-          interpolateZoom(~~map.zoom() - integer);
-        }
-
-        map.zoomIn = function() { zoomIn(1); };
-        map.zoomInFurther = function() { zoomIn(4); };
-
-        map.zoomOut = function() { zoomOut(1); };
-        map.zoomOutFurther = function() { zoomOut(4); };
-
-        map.center = function(loc) {
-            if (!arguments.length) {
-                return projection.invert(pxCenter());
-            }
-
-            if (setCenter(loc)) {
-                dispatch.move(map);
-            }
-
-            return redraw();
-        };
-
-        map.zoom = function(z) {
-            if (!arguments.length) {
-                return Math.max(Math.log(projection.scale() * 2 * Math.PI) / Math.LN2 - 8, 0);
-            }
-
-            if (z < minzoom) {
-                surface.interrupt();
-                iD.ui.flash(context.container())
-                    .select('.content')
-                    .text(t('cannot_zoom'));
-                z = context.minEditableZoom();
-            }
-
-            if (setZoom(z)) {
-                dispatch.move(map);
-            }
-
-            return redraw();
-        };
-
-        map.zoomTo = function(entity, zoomLimits) {
-            var extent = entity.extent(context.graph());
-            if (!isFinite(extent.area())) return;
-
-            var zoom = map.trimmedExtentZoom(extent);
-            zoomLimits = zoomLimits || [context.minEditableZoom(), 20];
-            map.centerZoom(extent.center(), Math.min(Math.max(zoom, zoomLimits[0]), zoomLimits[1]));
-        };
-
-        map.centerZoom = function(loc, z) {
-            var centered = setCenter(loc),
-                zoomed   = setZoom(z);
-
-            if (centered || zoomed) {
-                dispatch.move(map);
-            }
-
-            return redraw();
-        };
-
-        map.centerEase = function(loc2, duration) {
-            duration = duration || 250;
-
-            surface.one('mousedown.ease', function() {
-                map.cancelEase();
-            });
-
-            if (easing) {
-                map.cancelEase();
-            }
-
-            var t1 = Date.now(),
-                t2 = t1 + duration,
-                loc1 = map.center(),
-                ease = d3.ease('cubic-in-out');
-
-            easing = true;
-
-            d3.timer(function() {
-                if (!easing) return true;  // cancelled ease
-
-                var tNow = Date.now();
-                if (tNow > t2) {
-                    tNow = t2;
-                    easing = false;
-                }
-
-                var locNow = iD.geo.interp(loc1, loc2, ease((tNow - t1) / duration));
-                setCenter(locNow);
-
-                d3.event = {
-                    scale: zoom.scale(),
-                    translate: zoom.translate()
-                };
-
-                zoomPan();
-                return !easing;
-            });
-
-            return map;
-        };
-
-        map.cancelEase = function() {
-            easing = false;
-            d3.timer.flush();
-            return map;
-        };
-
-        map.extent = function(_) {
-            if (!arguments.length) {
-                return new iD.geo.Extent(projection.invert([0, dimensions[1]]),
-                                     projection.invert([dimensions[0], 0]));
-            } else {
-                var extent = iD.geo.Extent(_);
-                map.centerZoom(extent.center(), map.extentZoom(extent));
-            }
-        };
-
-        map.trimmedExtent = function(_) {
-            if (!arguments.length) {
-                var headerY = 60, footerY = 30, pad = 10;
-                return new iD.geo.Extent(projection.invert([pad, dimensions[1] - footerY - pad]),
-                        projection.invert([dimensions[0] - pad, headerY + pad]));
-            } else {
-                var extent = iD.geo.Extent(_);
-                map.centerZoom(extent.center(), map.trimmedExtentZoom(extent));
-            }
-        };
-
-        function calcZoom(extent, dim) {
-            var tl = projection([extent[0][0], extent[1][1]]),
-                br = projection([extent[1][0], extent[0][1]]);
-
-            // Calculate maximum zoom that fits extent
-            var hFactor = (br[0] - tl[0]) / dim[0],
-                vFactor = (br[1] - tl[1]) / dim[1],
-                hZoomDiff = Math.log(Math.abs(hFactor)) / Math.LN2,
-                vZoomDiff = Math.log(Math.abs(vFactor)) / Math.LN2,
-                newZoom = map.zoom() - Math.max(hZoomDiff, vZoomDiff);
-
-            return newZoom;
-        }
-
-        map.extentZoom = function(_) {
-            return calcZoom(iD.geo.Extent(_), dimensions);
-        };
-
-        map.trimmedExtentZoom = function(_) {
-            var trimY = 120, trimX = 40,
-                trimmed = [dimensions[0] - trimX, dimensions[1] - trimY];
-            return calcZoom(iD.geo.Extent(_), trimmed);
-        };
-
-        map.editable = function() {
-            return map.zoom() >= context.minEditableZoom();
-        };
-
-        map.minzoom = function(_) {
-            if (!arguments.length) return minzoom;
-            minzoom = _;
-            return map;
-        };
-
-        map.layers = drawLayers;
-
-        return d3.rebind(map, dispatch, 'on');
-    }
-
-    exports.BackgroundSource = BackgroundSource;
-    exports.Background = Background;
-    exports.Features = Features;
-    exports.Map = Map;
-    exports.TileLayer = TileLayer;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
\ No newline at end of file
diff --git a/js/lib/id/util.js b/js/lib/id/util.js
deleted file mode 100644
index c038fdfd6..000000000
--- a/js/lib/id/util.js
+++ /dev/null
@@ -1,272 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (factory((global.iD = global.iD || {}, global.iD.util = global.iD.util || {})));
-}(this, function (exports) { 'use strict';
-
-    function tagText(entity) {
-        return d3.entries(entity.tags).map(function(e) {
-            return e.key + '=' + e.value;
-        }).join(', ');
-    }
-
-    function entitySelector(ids) {
-        return ids.length ? '.' + ids.join(',.') : 'nothing';
-    }
-
-    function entityOrMemberSelector(ids, graph) {
-        var s = entitySelector(ids);
-
-        ids.forEach(function(id) {
-            var entity = graph.hasEntity(id);
-            if (entity && entity.type === 'relation') {
-                entity.members.forEach(function(member) {
-                    s += ',.' + member.id;
-                });
-            }
-        });
-
-        return s;
-    }
-
-    function displayName(entity) {
-        var localeName = 'name:' + iD.detect().locale.toLowerCase().split('-')[0];
-        return entity.tags[localeName] || entity.tags.name || entity.tags.ref;
-    }
-
-    function displayType(id) {
-        return {
-            n: t('inspector.node'),
-            w: t('inspector.way'),
-            r: t('inspector.relation')
-        }[id.charAt(0)];
-    }
-
-    function stringQs(str) {
-        return str.split('&').reduce(function(obj, pair){
-            var parts = pair.split('=');
-            if (parts.length === 2) {
-                obj[parts[0]] = (null === parts[1]) ? '' : decodeURIComponent(parts[1]);
-            }
-            return obj;
-        }, {});
-    }
-
-    function qsString(obj, noencode) {
-        function softEncode(s) {
-          // encode everything except special characters used in certain hash parameters:
-          // "/" in map states, ":", ",", {" and "}" in background
-          return encodeURIComponent(s).replace(/(%2F|%3A|%2C|%7B|%7D)/g, decodeURIComponent);
-        }
-        return Object.keys(obj).sort().map(function(key) {
-            return encodeURIComponent(key) + '=' + (
-                noencode ? softEncode(obj[key]) : encodeURIComponent(obj[key]));
-        }).join('&');
-    }
-
-    function prefixDOMProperty(property) {
-        var prefixes = ['webkit', 'ms', 'moz', 'o'],
-            i = -1,
-            n = prefixes.length,
-            s = document.body;
-
-        if (property in s)
-            return property;
-
-        property = property.substr(0, 1).toUpperCase() + property.substr(1);
-
-        while (++i < n)
-            if (prefixes[i] + property in s)
-                return prefixes[i] + property;
-
-        return false;
-    }
-
-    function prefixCSSProperty(property) {
-        var prefixes = ['webkit', 'ms', 'Moz', 'O'],
-            i = -1,
-            n = prefixes.length,
-            s = document.body.style;
-
-        if (property.toLowerCase() in s)
-            return property.toLowerCase();
-
-        while (++i < n)
-            if (prefixes[i] + property in s)
-                return '-' + prefixes[i].toLowerCase() + property.replace(/([A-Z])/g, '-$1').toLowerCase();
-
-        return false;
-    }
-
-
-    var transformProperty;
-    function setTransform(el, x, y, scale) {
-        var prop = transformProperty = transformProperty || prefixCSSProperty('Transform'),
-            translate = iD.detect().opera ?
-                'translate('   + x + 'px,' + y + 'px)' :
-                'translate3d(' + x + 'px,' + y + 'px,0)';
-        return el.style(prop, translate + (scale ? ' scale(' + scale + ')' : ''));
-    }
-
-    function getStyle(selector) {
-        for (var i = 0; i < document.styleSheets.length; i++) {
-            var rules = document.styleSheets[i].rules || document.styleSheets[i].cssRules || [];
-            for (var k = 0; k < rules.length; k++) {
-                var selectorText = rules[k].selectorText && rules[k].selectorText.split(', ');
-                if (_.includes(selectorText, selector)) {
-                    return rules[k];
-                }
-            }
-        }
-    }
-
-    function editDistance(a, b) {
-        if (a.length === 0) return b.length;
-        if (b.length === 0) return a.length;
-        var matrix = [];
-        for (var i = 0; i <= b.length; i++) { matrix[i] = [i]; }
-        for (var j = 0; j <= a.length; j++) { matrix[0][j] = j; }
-        for (i = 1; i <= b.length; i++) {
-            for (j = 1; j <= a.length; j++) {
-                if (b.charAt(i-1) === a.charAt(j-1)) {
-                    matrix[i][j] = matrix[i-1][j-1];
-                } else {
-                    matrix[i][j] = Math.min(matrix[i-1][j-1] + 1, // substitution
-                        Math.min(matrix[i][j-1] + 1, // insertion
-                        matrix[i-1][j] + 1)); // deletion
-                }
-            }
-        }
-        return matrix[b.length][a.length];
-    }
-
-    // a d3.mouse-alike which
-    // 1. Only works on HTML elements, not SVG
-    // 2. Does not cause style recalculation
-    function fastMouse(container) {
-        var rect = container.getBoundingClientRect(),
-            rectLeft = rect.left,
-            rectTop = rect.top,
-            clientLeft = +container.clientLeft,
-            clientTop = +container.clientTop;
-        return function(e) {
-            return [
-                e.clientX - rectLeft - clientLeft,
-                e.clientY - rectTop - clientTop];
-        };
-    }
-
-    /* eslint-disable no-proto */
-    var getPrototypeOf = Object.getPrototypeOf || function(obj) { return obj.__proto__; };
-    /* eslint-enable no-proto */
-
-    function asyncMap(inputs, func, callback) {
-        var remaining = inputs.length,
-            results = [],
-            errors = [];
-
-        inputs.forEach(function(d, i) {
-            func(d, function done(err, data) {
-                errors[i] = err;
-                results[i] = data;
-                remaining--;
-                if (!remaining) callback(errors, results);
-            });
-        });
-    }
-
-    // wraps an index to an interval [0..length-1]
-    function wrap(index, length) {
-        if (index < 0)
-            index += Math.ceil(-index/length)*length;
-        return index % length;
-    }
-
-    // A per-domain session mutex backed by a cookie and dead man's
-    // switch. If the session crashes, the mutex will auto-release
-    // after 5 seconds.
-
-    function SessionMutex(name) {
-        var mutex = {},
-            intervalID;
-
-        function renew() {
-            var expires = new Date();
-            expires.setSeconds(expires.getSeconds() + 5);
-            document.cookie = name + '=1; expires=' + expires.toUTCString();
-        }
-
-        mutex.lock = function() {
-            if (intervalID) return true;
-            var cookie = document.cookie.replace(new RegExp('(?:(?:^|.*;)\\s*' + name + '\\s*\\=\\s*([^;]*).*$)|^.*$'), '$1');
-            if (cookie) return false;
-            renew();
-            intervalID = window.setInterval(renew, 4000);
-            return true;
-        };
-
-        mutex.unlock = function() {
-            if (!intervalID) return;
-            document.cookie = name + '=; expires=Thu, 01 Jan 1970 00:00:00 GMT';
-            clearInterval(intervalID);
-            intervalID = null;
-        };
-
-        mutex.locked = function() {
-            return !!intervalID;
-        };
-
-        return mutex;
-    }
-
-    function SuggestNames(preset, suggestions) {
-        preset = preset.id.split('/', 2);
-        var k = preset[0],
-            v = preset[1];
-
-        return function(value, callback) {
-            var result = [];
-            if (value && value.length > 2) {
-                if (suggestions[k] && suggestions[k][v]) {
-                    for (var sugg in suggestions[k][v]) {
-                        var dist = iD.util.editDistance(value, sugg.substring(0, value.length));
-                        if (dist < 3) {
-                            result.push({
-                                title: sugg,
-                                value: sugg,
-                                dist: dist
-                            });
-                        }
-                    }
-                }
-                result.sort(function(a, b) {
-                    return a.dist - b.dist;
-                });
-            }
-            result = result.slice(0,3);
-            callback(result);
-        };
-    }
-
-    exports.tagText = tagText;
-    exports.entitySelector = entitySelector;
-    exports.entityOrMemberSelector = entityOrMemberSelector;
-    exports.displayName = displayName;
-    exports.displayType = displayType;
-    exports.stringQs = stringQs;
-    exports.qsString = qsString;
-    exports.prefixDOMProperty = prefixDOMProperty;
-    exports.prefixCSSProperty = prefixCSSProperty;
-    exports.setTransform = setTransform;
-    exports.getStyle = getStyle;
-    exports.editDistance = editDistance;
-    exports.fastMouse = fastMouse;
-    exports.getPrototypeOf = getPrototypeOf;
-    exports.asyncMap = asyncMap;
-    exports.wrap = wrap;
-    exports.SessionMutex = SessionMutex;
-    exports.SuggestNames = SuggestNames;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
\ No newline at end of file
diff --git a/js/lib/id/validations.js b/js/lib/id/validations.js
deleted file mode 100644
index 3aaf8c271..000000000
--- a/js/lib/id/validations.js
+++ /dev/null
@@ -1,121 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (factory((global.iD = global.iD || {}, global.iD.validations = global.iD.validations || {})));
-}(this, function (exports) { 'use strict';
-
-    function DeprecatedTag() {
-
-        var validation = function(changes) {
-            var warnings = [];
-            for (var i = 0; i < changes.created.length; i++) {
-                var change = changes.created[i],
-                    deprecatedTags = change.deprecatedTags();
-
-                if (!_.isEmpty(deprecatedTags)) {
-                    var tags = iD.util.tagText({ tags: deprecatedTags });
-                    warnings.push({
-                        id: 'deprecated_tags',
-                        message: t('validations.deprecated_tags', { tags: tags }),
-                        entity: change
-                    });
-                }
-            }
-            return warnings;
-        };
-
-        return validation;
-    }
-
-    function ManyDeletions() {
-        var threshold = 100;
-
-        var validation = function(changes) {
-            var warnings = [];
-            if (changes.deleted.length > threshold) {
-                warnings.push({
-                    id: 'many_deletions',
-                    message: t('validations.many_deletions', { n: changes.deleted.length })
-                });
-            }
-            return warnings;
-        };
-
-        return validation;
-    }
-
-    function MissingTag() {
-
-        // Slightly stricter check than Entity#isUsed (#3091)
-        function hasTags(entity, graph) {
-            return _.without(Object.keys(entity.tags), 'area', 'name').length > 0 ||
-                graph.parentRelations(entity).length > 0;
-        }
-
-        var validation = function(changes, graph) {
-            var warnings = [];
-            for (var i = 0; i < changes.created.length; i++) {
-                var change = changes.created[i],
-                    geometry = change.geometry(graph);
-
-                if ((geometry === 'point' || geometry === 'line' || geometry === 'area') && !hasTags(change, graph)) {
-                    warnings.push({
-                        id: 'missing_tag',
-                        message: t('validations.untagged_' + geometry),
-                        tooltip: t('validations.untagged_' + geometry + '_tooltip'),
-                        entity: change
-                    });
-                }
-            }
-            return warnings;
-        };
-
-        return validation;
-    }
-
-    function TagSuggestsArea() {
-
-        // https://github.com/openstreetmap/josm/blob/mirror/src/org/
-        // openstreetmap/josm/data/validation/tests/UnclosedWays.java#L80
-        function tagSuggestsArea(tags) {
-            if (_.isEmpty(tags)) return false;
-
-            var presence = ['landuse', 'amenities', 'tourism', 'shop'];
-            for (var i = 0; i < presence.length; i++) {
-                if (tags[presence[i]] !== undefined) {
-                    return presence[i] + '=' + tags[presence[i]];
-                }
-            }
-
-            if (tags.building && tags.building === 'yes') return 'building=yes';
-        }
-
-        var validation = function(changes, graph) {
-            var warnings = [];
-            for (var i = 0; i < changes.created.length; i++) {
-                var change = changes.created[i],
-                    geometry = change.geometry(graph),
-                    suggestion = (geometry === 'line' ? tagSuggestsArea(change.tags) : undefined);
-
-                if (suggestion) {
-                    warnings.push({
-                        id: 'tag_suggests_area',
-                        message: t('validations.tag_suggests_area', { tag: suggestion }),
-                        entity: change
-                    });
-                }
-            }
-            return warnings;
-        };
-
-        return validation;
-    }
-
-    exports.DeprecatedTag = DeprecatedTag;
-    exports.ManyDeletions = ManyDeletions;
-    exports.MissingTag = MissingTag;
-    exports.TagSuggestsArea = TagSuggestsArea;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
\ No newline at end of file