diff --git a/modules/core/difference.js b/modules/core/difference.js
index a00f0f0ce..e897fb983 100644
--- a/modules/core/difference.js
+++ b/modules/core/difference.js
@@ -5,7 +5,7 @@ import _values from 'lodash-es/values';
 
 
 /*
-    iD.Difference represents the difference between two graphs.
+    iD.coreDifference 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
diff --git a/test/spec/actions/copy_entities.js b/test/spec/actions/copy_entities.js
index f6ac256f3..87508b438 100644
--- a/test/spec/actions/copy_entities.js
+++ b/test/spec/actions/copy_entities.js
@@ -1,24 +1,24 @@
 describe('iD.actionCopyEntities', function () {
     it('copies a node', function () {
-        var a = iD.osmNode({id: 'a'}),
-            base = iD.coreGraph([a]),
-            head = iD.actionCopyEntities(['a'], base)(base),
-            diff = iD.Difference(base, head),
-            created = diff.created();
+        var a = iD.osmNode({id: 'a'});
+        var base = iD.coreGraph([a]);
+        var head = iD.actionCopyEntities(['a'], base)(base);
+        var diff = iD.coreDifference(base, head);
+        var created = diff.created();
 
         expect(head.hasEntity('a')).to.be.ok;
         expect(created).to.have.length(1);
     });
 
     it('copies a way', function () {
-        var a = iD.osmNode({id: 'a'}),
-            b = iD.osmNode({id: 'b'}),
-            w = iD.osmWay({id: 'w', nodes: ['a', 'b']}),
-            base = iD.coreGraph([a, b, w]),
-            action = iD.actionCopyEntities(['w'], base),
-            head = action(base),
-            diff = iD.Difference(base, head),
-            created = diff.created();
+        var a = iD.osmNode({id: 'a'});
+        var b = iD.osmNode({id: 'b'});
+        var w = iD.osmWay({id: 'w', nodes: ['a', 'b']});
+        var base = iD.coreGraph([a, b, w]);
+        var action = iD.actionCopyEntities(['w'], base);
+        var head = action(base);
+        var diff = iD.coreDifference(base, head);
+        var created = diff.created();
 
         expect(head.hasEntity('w')).to.be.ok;
         expect(created).to.have.length(3);
@@ -26,13 +26,13 @@ describe('iD.actionCopyEntities', function () {
 
     it('copies multiple nodes', function () {
         var base = iD.coreGraph([
-                iD.osmNode({id: 'a'}),
-                iD.osmNode({id: 'b'})
-            ]),
-            action = iD.actionCopyEntities(['a', 'b'], base),
-            head = action(base),
-            diff = iD.Difference(base, head),
-            created = diff.created();
+            iD.osmNode({id: 'a'}),
+            iD.osmNode({id: 'b'})
+        ]);
+        var action = iD.actionCopyEntities(['a', 'b'], base);
+        var head = action(base);
+        var diff = iD.coreDifference(base, head);
+        var created = diff.created();
 
         expect(head.hasEntity('a')).to.be.ok;
         expect(head.hasEntity('b')).to.be.ok;
@@ -41,29 +41,27 @@ describe('iD.actionCopyEntities', function () {
 
     it('copies multiple ways, keeping the same connections', function () {
         var base = iD.coreGraph([
-                iD.osmNode({id: 'a'}),
-                iD.osmNode({id: 'b'}),
-                iD.osmNode({id: 'c'}),
-                iD.osmWay({id: 'w1', nodes: ['a', 'b']}),
-                iD.osmWay({id: 'w2', nodes: ['b', 'c']})
-            ]),
-            action = iD.actionCopyEntities(['w1', 'w2'], base),
-            head = action(base),
-            diff = iD.Difference(base, head),
-            created = diff.created();
+            iD.osmNode({id: 'a'}),
+            iD.osmNode({id: 'b'}),
+            iD.osmNode({id: 'c'}),
+            iD.osmWay({id: 'w1', nodes: ['a', 'b']}),
+            iD.osmWay({id: 'w2', nodes: ['b', 'c']})
+        ]);
+        var action = iD.actionCopyEntities(['w1', 'w2'], base);
+        var head = action(base);
+        var diff = iD.coreDifference(base, head);
+        var created = diff.created();
 
         expect(created).to.have.length(5);
         expect(action.copies().w1.nodes[1]).to.eql(action.copies().w2.nodes[0]);
     });
 
     it('obtains source entities from an alternate graph', function () {
-        var a = iD.osmNode({id: 'a'}),
-            old = iD.coreGraph([a]),
-            base = iD.coreGraph(),
-            action = iD.actionCopyEntities(['a'], old),
-            head = action(base),
-            diff = iD.Difference(base, head);
-            diff.created();
+        var a = iD.osmNode({id: 'a'});
+        var old = iD.coreGraph([a]);
+        var base = iD.coreGraph();
+        var action = iD.actionCopyEntities(['a'], old);
+        var head = action(base);
 
         expect(head.hasEntity('a')).not.to.be.ok;
         expect(Object.keys(action.copies())).to.have.length(1);
diff --git a/test/spec/core/difference.js b/test/spec/core/difference.js
index 97ca0eaaf..8c27eb5e3 100644
--- a/test/spec/core/difference.js
+++ b/test/spec/core/difference.js
@@ -1,152 +1,152 @@
-describe('iD.Difference', function () {
+describe('iD.coreDifference', function () {
     describe('#changes', function () {
         it('includes created entities', function () {
-            var node = iD.osmNode({id: 'n'}),
-                base = iD.coreGraph(),
-                head = base.replace(node),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode({id: 'n'});
+            var base = iD.coreGraph();
+            var head = base.replace(node);
+            var diff = iD.coreDifference(base, head);
             expect(diff.changes()).to.eql({n: {base: undefined, head: node}});
         });
 
         it('includes undone created entities', function () {
-            var node = iD.osmNode({id: 'n'}),
-                base = iD.coreGraph(),
-                head = base.replace(node),
-                diff = iD.Difference(head, base);
+            var node = iD.osmNode({id: 'n'});
+            var base = iD.coreGraph();
+            var head = base.replace(node);
+            var diff = iD.coreDifference(head, base);
             expect(diff.changes()).to.eql({n: {base: node, head: undefined}});
         });
 
         it('includes modified entities', function () {
-            var n1 = iD.osmNode({id: 'n'}),
-                n2 = n1.update({ tags: { yes: 'no' } }),
-                base = iD.coreGraph([n1]),
-                head = base.replace(n2),
-                diff = iD.Difference(base, head);
+            var n1 = iD.osmNode({id: 'n'});
+            var n2 = n1.update({ tags: { yes: 'no' } });
+            var base = iD.coreGraph([n1]);
+            var head = base.replace(n2);
+            var diff = iD.coreDifference(base, head);
             expect(diff.changes()).to.eql({n: {base: n1, head: n2}});
         });
 
         it('includes undone modified entities', function () {
-            var n1 = iD.osmNode({id: 'n'}),
-                n2 = n1.update({ tags: { yes: 'no' } }),
-                base = iD.coreGraph([n1]),
-                head = base.replace(n2),
-                diff = iD.Difference(head, base);
+            var n1 = iD.osmNode({id: 'n'});
+            var n2 = n1.update({ tags: { yes: 'no' } });
+            var base = iD.coreGraph([n1]);
+            var head = base.replace(n2);
+            var diff = iD.coreDifference(head, base);
             expect(diff.changes()).to.eql({n: {base: n2, head: n1}});
         });
 
         it('doesn\'t include updated but identical entities', function () {
-            var n1 = iD.osmNode({id: 'n'}),
-                n2 = n1.update(),
-                base = iD.coreGraph([n1]),
-                head = base.replace(n2),
-                diff = iD.Difference(base, head);
+            var n1 = iD.osmNode({id: 'n'});
+            var n2 = n1.update();
+            var base = iD.coreGraph([n1]);
+            var head = base.replace(n2);
+            var diff = iD.coreDifference(base, head);
             expect(diff.changes()).to.eql({});
         });
 
         it('includes deleted entities', function () {
-            var node = iD.osmNode({id: 'n'}),
-                base = iD.coreGraph([node]),
-                head = base.remove(node),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode({id: 'n'});
+            var base = iD.coreGraph([node]);
+            var head = base.remove(node);
+            var diff = iD.coreDifference(base, head);
             expect(diff.changes()).to.eql({n: {base: node, head: undefined}});
         });
 
         it('includes undone deleted entities', function () {
-            var node = iD.osmNode({id: 'n'}),
-                base = iD.coreGraph([node]),
-                head = base.remove(node),
-                diff = iD.Difference(head, base);
+            var node = iD.osmNode({id: 'n'});
+            var base = iD.coreGraph([node]);
+            var head = base.remove(node);
+            var diff = iD.coreDifference(head, base);
             expect(diff.changes()).to.eql({n: {base: undefined, head: node}});
         });
 
         it('doesn\'t include created entities that were subsequently deleted', function () {
-            var node = iD.osmNode(),
-                base = iD.coreGraph(),
-                head = base.replace(node).remove(node),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode();
+            var base = iD.coreGraph();
+            var head = base.replace(node).remove(node);
+            var diff = iD.coreDifference(base, head);
             expect(diff.changes()).to.eql({});
         });
 
         it('doesn\'t include created entities that were subsequently reverted', function () {
-            var node = iD.osmNode({id: 'n-1'}),
-                base = iD.coreGraph(),
-                head = base.replace(node).revert('n-1'),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode({id: 'n-1'});
+            var base = iD.coreGraph();
+            var head = base.replace(node).revert('n-1');
+            var diff = iD.coreDifference(base, head);
             expect(diff.changes()).to.eql({});
         });
 
         it('doesn\'t include modified entities that were subsequently reverted', function () {
-            var n1 = iD.osmNode({id: 'n'}),
-                n2 = n1.update({ tags: { yes: 'no' } }),
-                base = iD.coreGraph([n1]),
-                head = base.replace(n2).revert('n'),
-                diff = iD.Difference(base, head);
+            var n1 = iD.osmNode({id: 'n'});
+            var n2 = n1.update({ tags: { yes: 'no' } });
+            var base = iD.coreGraph([n1]);
+            var head = base.replace(n2).revert('n');
+            var diff = iD.coreDifference(base, head);
             expect(diff.changes()).to.eql({});
         });
 
         it('doesn\'t include deleted entities that were subsequently reverted', function () {
-            var node = iD.osmNode({id: 'n'}),
-                base = iD.coreGraph([node]),
-                head = base.remove(node).revert('n'),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode({id: 'n'});
+            var base = iD.coreGraph([node]);
+            var head = base.remove(node).revert('n');
+            var diff = iD.coreDifference(base, head);
             expect(diff.changes()).to.eql({});
         });
     });
 
     describe('#extantIDs', function () {
         it('includes the ids of created entities', function () {
-            var node = iD.osmNode({id: 'n'}),
-                base = iD.coreGraph(),
-                head = base.replace(node),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode({id: 'n'});
+            var base = iD.coreGraph();
+            var head = base.replace(node);
+            var diff = iD.coreDifference(base, head);
             expect(diff.extantIDs()).to.eql(['n']);
         });
 
         it('includes the ids of modified entities', function () {
-            var n1 = iD.osmNode({id: 'n'}),
-                n2 = n1.move([1, 2]),
-                base = iD.coreGraph([n1]),
-                head = base.replace(n2),
-                diff = iD.Difference(base, head);
+            var n1 = iD.osmNode({id: 'n'});
+            var n2 = n1.move([1, 2]);
+            var base = iD.coreGraph([n1]);
+            var head = base.replace(n2);
+            var diff = iD.coreDifference(base, head);
             expect(diff.extantIDs()).to.eql(['n']);
         });
 
         it('omits the ids of deleted entities', function () {
-            var node = iD.osmNode({id: 'n'}),
-                base = iD.coreGraph([node]),
-                head = base.remove(node),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode({id: 'n'});
+            var base = iD.coreGraph([node]);
+            var head = base.remove(node);
+            var diff = iD.coreDifference(base, head);
             expect(diff.extantIDs()).to.eql([]);
         });
     });
 
     describe('#created', function () {
         it('returns an array of created entities', function () {
-            var node = iD.osmNode({id: 'n'}),
-                base = iD.coreGraph(),
-                head = base.replace(node),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode({id: 'n'});
+            var base = iD.coreGraph();
+            var head = base.replace(node);
+            var diff = iD.coreDifference(base, head);
             expect(diff.created()).to.eql([node]);
         });
     });
 
     describe('#modified', function () {
         it('returns an array of modified entities', function () {
-            var n1 = iD.osmNode({id: 'n'}),
-                n2 = n1.move([1, 2]),
-                base = iD.coreGraph([n1]),
-                head = base.replace(n2),
-                diff = iD.Difference(base, head);
+            var n1 = iD.osmNode({id: 'n'});
+            var n2 = n1.move([1, 2]);
+            var base = iD.coreGraph([n1]);
+            var head = base.replace(n2);
+            var diff = iD.coreDifference(base, head);
             expect(diff.modified()).to.eql([n2]);
         });
     });
 
     describe('#deleted', function () {
         it('returns an array of deleted entities', function () {
-            var node = iD.osmNode({id: 'n'}),
-                base = iD.coreGraph([node]),
-                head = base.remove(node),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode({id: 'n'});
+            var base = iD.coreGraph([node]);
+            var head = base.remove(node);
+            var diff = iD.coreDifference(base, head);
             expect(diff.deleted()).to.eql([node]);
         });
     });
@@ -160,9 +160,9 @@ describe('iD.Difference', function () {
         ]);
 
         it('reports a created way as created', function() {
-            var way = iD.osmWay({id: '+'}),
-                head = base.replace(way),
-                diff = iD.Difference(base, head);
+            var way = iD.osmWay({id: '+'});
+            var head = base.replace(way);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'created',
@@ -172,9 +172,9 @@ describe('iD.Difference', function () {
         });
 
         it('reports a deleted way as deleted', function() {
-            var way = base.entity('-'),
-                head = base.remove(way),
-                diff = iD.Difference(base, head);
+            var way = base.entity('-');
+            var head = base.remove(way);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'deleted',
@@ -184,9 +184,9 @@ describe('iD.Difference', function () {
         });
 
         it('reports a modified way as modified', function() {
-            var way = base.entity('-').mergeTags({highway: 'primary'}),
-                head = base.replace(way),
-                diff = iD.Difference(base, head);
+            var way = base.entity('-').mergeTags({highway: 'primary'});
+            var head = base.replace(way);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'modified',
@@ -196,9 +196,9 @@ describe('iD.Difference', function () {
         });
 
         it('reports a way as modified when a member vertex is moved', function() {
-            var vertex = base.entity('b').move([0,3]),
-                head = base.replace(vertex),
-                diff = iD.Difference(base, head);
+            var vertex = base.entity('b').move([0,3]);
+            var head = base.replace(vertex);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'modified',
@@ -208,10 +208,10 @@ describe('iD.Difference', function () {
         });
 
         it('reports a way as modified when a member vertex is added', function() {
-            var vertex = iD.osmNode({id: 'c'}),
-                way = base.entity('-').addNode('c'),
-                head = base.replace(vertex).replace(way),
-                diff = iD.Difference(base, head);
+            var vertex = iD.osmNode({id: 'c'});
+            var way = base.entity('-').addNode('c');
+            var head = base.replace(vertex).replace(way);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'modified',
@@ -221,9 +221,9 @@ describe('iD.Difference', function () {
         });
 
         it('reports a way as modified when a member vertex is removed', function() {
-            var way = base.entity('-').removeNode('b'),
-                head = base.replace(way),
-                diff = iD.Difference(base, head);
+            var way = base.entity('-').removeNode('b');
+            var head = base.replace(way);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'modified',
@@ -233,10 +233,10 @@ describe('iD.Difference', function () {
         });
 
         it('reports a created way containing a moved vertex as being created', function() {
-            var vertex = base.entity('b').move([0,3]),
-                way = iD.osmWay({id: '+', nodes: ['b']}),
-                head = base.replace(way).replace(vertex),
-                diff = iD.Difference(base, head);
+            var vertex = base.entity('b').move([0,3]);
+            var way = iD.osmWay({id: '+', nodes: ['b']});
+            var head = base.replace(way).replace(vertex);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'created',
@@ -250,10 +250,10 @@ describe('iD.Difference', function () {
         });
 
         it('reports a created way with a created vertex as being created', function() {
-            var vertex = iD.osmNode({id: 'c'}),
-                way = iD.osmWay({id: '+', nodes: ['c']}),
-                head = base.replace(vertex).replace(way),
-                diff = iD.Difference(base, head);
+            var vertex = iD.osmNode({id: 'c'});
+            var way = iD.osmWay({id: '+', nodes: ['c']});
+            var head = base.replace(vertex).replace(way);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'created',
@@ -263,9 +263,9 @@ describe('iD.Difference', function () {
         });
 
         it('reports a vertex as modified when it has tags and they are changed', function() {
-            var vertex = base.entity('a').mergeTags({highway: 'traffic_signals'}),
-                head = base.replace(vertex),
-                diff = iD.Difference(base, head);
+            var vertex = base.entity('a').mergeTags({highway: 'traffic_signals'});
+            var head = base.replace(vertex);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'modified',
@@ -275,9 +275,9 @@ describe('iD.Difference', function () {
         });
 
         it('reports a vertex as modified when it has tags and is moved', function() {
-            var vertex = base.entity('a').move([1, 2]),
-                head = base.replace(vertex),
-                diff = iD.Difference(base, head);
+            var vertex = base.entity('a').move([1, 2]);
+            var head = base.replace(vertex);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'modified',
@@ -291,9 +291,9 @@ describe('iD.Difference', function () {
         });
 
         it('does not report a vertex as modified when it is moved and has no-op tag changes', function() {
-            var vertex = base.entity('b').update({tags: {}, loc: [1, 2]}),
-                head = base.replace(vertex),
-                diff = iD.Difference(base, head);
+            var vertex = base.entity('b').update({tags: {}, loc: [1, 2]});
+            var head = base.replace(vertex);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'modified',
@@ -303,9 +303,9 @@ describe('iD.Difference', function () {
         });
 
         it('reports a vertex as deleted when it had tags', function() {
-            var vertex = base.entity('v'),
-                head = base.remove(vertex),
-                diff = iD.Difference(base, head);
+            var vertex = base.entity('v');
+            var head = base.remove(vertex);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'deleted',
@@ -315,10 +315,10 @@ describe('iD.Difference', function () {
         });
 
         it('reports a vertex as created when it has tags', function() {
-            var vertex = iD.osmNode({id: 'c', tags: {crossing: 'marked'}}),
-                way = base.entity('-').addNode('c'),
-                head = base.replace(way).replace(vertex),
-                diff = iD.Difference(base, head);
+            var vertex = iD.osmNode({id: 'c', tags: {crossing: 'marked'}});
+            var way = base.entity('-').addNode('c');
+            var head = base.replace(way).replace(vertex);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.summary()).to.eql([{
                 changeType: 'modified',
@@ -334,107 +334,107 @@ describe('iD.Difference', function () {
 
     describe('#complete', function () {
         it('includes created entities', function () {
-            var node = iD.osmNode({id: 'n'}),
-                base = iD.coreGraph(),
-                head = base.replace(node),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode({id: 'n'});
+            var base = iD.coreGraph();
+            var head = base.replace(node);
+            var diff = iD.coreDifference(base, head);
             expect(diff.complete().n).to.equal(node);
         });
 
         it('includes modified entities', function () {
-            var n1 = iD.osmNode({id: 'n'}),
-                n2 = n1.move([1, 2]),
-                base = iD.coreGraph([n1]),
-                head = base.replace(n2),
-                diff = iD.Difference(base, head);
+            var n1 = iD.osmNode({id: 'n'});
+            var n2 = n1.move([1, 2]);
+            var base = iD.coreGraph([n1]);
+            var head = base.replace(n2);
+            var diff = iD.coreDifference(base, head);
             expect(diff.complete().n).to.equal(n2);
         });
 
         it('includes deleted entities', function () {
-            var node = iD.osmNode({id: 'n'}),
-                base = iD.coreGraph([node]),
-                head = base.remove(node),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode({id: 'n'});
+            var base = iD.coreGraph([node]);
+            var head = base.remove(node);
+            var diff = iD.coreDifference(base, head);
             expect(diff.complete()).to.eql({n: undefined});
         });
 
         it('includes nodes added to a way', function () {
-            var n1 = iD.osmNode({id: 'n1'}),
-                n2 = iD.osmNode({id: 'n2'}),
-                w1 = iD.osmWay({id: 'w', nodes: ['n1']}),
-                w2 = w1.addNode('n2'),
-                base = iD.coreGraph([n1, n2, w1]),
-                head = base.replace(w2),
-                diff = iD.Difference(base, head);
+            var n1 = iD.osmNode({id: 'n1'});
+            var n2 = iD.osmNode({id: 'n2'});
+            var w1 = iD.osmWay({id: 'w', nodes: ['n1']});
+            var w2 = w1.addNode('n2');
+            var base = iD.coreGraph([n1, n2, w1]);
+            var head = base.replace(w2);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.complete().n2).to.equal(n2);
         });
 
         it('includes nodes removed from a way', function () {
-            var n1 = iD.osmNode({id: 'n1'}),
-                n2 = iD.osmNode({id: 'n2'}),
-                w1 = iD.osmWay({id: 'w', nodes: ['n1', 'n2']}),
-                w2 = w1.removeNode('n2'),
-                base = iD.coreGraph([n1, n2, w1]),
-                head = base.replace(w2),
-                diff = iD.Difference(base, head);
+            var n1 = iD.osmNode({id: 'n1'});
+            var n2 = iD.osmNode({id: 'n2'});
+            var w1 = iD.osmWay({id: 'w', nodes: ['n1', 'n2']});
+            var w2 = w1.removeNode('n2');
+            var base = iD.coreGraph([n1, n2, w1]);
+            var head = base.replace(w2);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.complete().n2).to.equal(n2);
         });
 
         it('includes parent ways of modified nodes', function () {
-            var n1   = iD.osmNode({id: 'n'}),
-                n2   = n1.move([1, 2]),
-                way  = iD.osmWay({id: 'w', nodes: ['n']}),
-                base = iD.coreGraph([n1, way]),
-                head = base.replace(n2),
-                diff = iD.Difference(base, head);
+            var n1   = iD.osmNode({id: 'n'});
+            var n2   = n1.move([1, 2]);
+            var way  = iD.osmWay({id: 'w', nodes: ['n']});
+            var base = iD.coreGraph([n1, way]);
+            var head = base.replace(n2);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.complete().w).to.equal(way);
         });
 
         it('includes parent relations of modified entities', function () {
-            var n1   = iD.osmNode({id: 'n'}),
-                n2   = n1.move([1, 2]),
-                rel  = iD.osmRelation({id: 'r', members: [{id: 'n'}]}),
-                base = iD.coreGraph([n1, rel]),
-                head = base.replace(n2),
-                diff = iD.Difference(base, head);
+            var n1   = iD.osmNode({id: 'n'});
+            var n2   = n1.move([1, 2]);
+            var rel  = iD.osmRelation({id: 'r', members: [{id: 'n'}]});
+            var base = iD.coreGraph([n1, rel]);
+            var head = base.replace(n2);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.complete().r).to.equal(rel);
         });
 
         it('includes parent relations of modified entities, recursively', function () {
-            var n1   = iD.osmNode({id: 'n'}),
-                n2   = n1.move([1, 2]),
-                rel1 = iD.osmRelation({id: 'r1', members: [{id: 'n'}]}),
-                rel2 = iD.osmRelation({id: 'r2', members: [{id: 'r1'}]}),
-                base = iD.coreGraph([n1, rel1, rel2]),
-                head = base.replace(n2),
-                diff = iD.Difference(base, head);
+            var n1   = iD.osmNode({id: 'n'});
+            var n2   = n1.move([1, 2]);
+            var rel1 = iD.osmRelation({id: 'r1', members: [{id: 'n'}]});
+            var rel2 = iD.osmRelation({id: 'r2', members: [{id: 'r1'}]});
+            var base = iD.coreGraph([n1, rel1, rel2]);
+            var head = base.replace(n2);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.complete().r2).to.equal(rel2);
         });
 
         it('includes parent relations of parent ways of modified nodes', function () {
-            var n1   = iD.osmNode({id: 'n'}),
-                n2   = n1.move([1, 2]),
-                way  = iD.osmWay({id: 'w', nodes: ['n']}),
-                rel  = iD.osmRelation({id: 'r', members: [{id: 'w'}]}),
-                base = iD.coreGraph([n1, way, rel]),
-                head = base.replace(n2),
-                diff = iD.Difference(base, head);
+            var n1   = iD.osmNode({id: 'n'});
+            var n2   = n1.move([1, 2]);
+            var way  = iD.osmWay({id: 'w', nodes: ['n']});
+            var rel  = iD.osmRelation({id: 'r', members: [{id: 'w'}]});
+            var base = iD.coreGraph([n1, way, rel]);
+            var head = base.replace(n2);
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.complete().r).to.equal(rel);
         });
 
         it('copes with recursive relations', function () {
-            var node = iD.osmNode({id: 'n'}),
-                rel1 = iD.osmRelation({id: 'r1', members: [{id: 'n'}, {id: 'r2'}]}),
-                rel2 = iD.osmRelation({id: 'r2', members: [{id: 'r1'}]}),
-                base = iD.coreGraph([node, rel1, rel2]),
-                head = base.replace(node.move([1, 2])),
-                diff = iD.Difference(base, head);
+            var node = iD.osmNode({id: 'n'});
+            var rel1 = iD.osmRelation({id: 'r1', members: [{id: 'n'}, {id: 'r2'}]});
+            var rel2 = iD.osmRelation({id: 'r2', members: [{id: 'r1'}]});
+            var base = iD.coreGraph([node, rel1, rel2]);
+            var head = base.replace(node.move([1, 2]));
+            var diff = iD.coreDifference(base, head);
 
             expect(diff.complete()).to.be.ok;
         });