diff --git a/.eslintrc b/.eslintrc
index 8ca14f48b..112e4cae2 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -12,6 +12,7 @@
   },
   "env": {
     "browser": true,
+    "es6": true,
     "mocha": true,
     "node": true
   },
diff --git a/docs/Readme.md b/docs/Readme.md
index 81f41b995..c790b8848 100644
--- a/docs/Readme.md
+++ b/docs/Readme.md
@@ -30,7 +30,7 @@
 ## Slate Core
 
 * [Block](./reference/slate/block.md)
-* [Change](./reference/slate/change.md)
+* [Commands](./reference/slate/commands.md)
 * [Data](./reference/slate/data.md)
 * [Decoration](./reference/slate/decoration.md)
 * [Document](./reference/slate/document.md)
diff --git a/docs/guides/commands-and-queries.md b/docs/guides/commands-and-queries.md
index 8ae07ae8d..27262c0c7 100644
--- a/docs/guides/commands-and-queries.md
+++ b/docs/guides/commands-and-queries.md
@@ -1,6 +1,6 @@
 # Commands & Queries
 
-All commands to a Slate editor's value, whether it's the `selection`, `document`, `history`, etc. happen via "commands" that are applied to a [`Change`](../reference/slate/change.md).
+All commands to a Slate editor's value, whether it's the `selection`, `document`, `history`, etc. happen via "commands".
 
 Under the covers, Slate takes care of converting each command into a set of low-level [operations](../reference/slate/operation.md) that are applied to produce a new value. This is what makes collaborative editing implementations possible. But you don't have to worry about that, because it happens automatically.
 
@@ -17,7 +17,7 @@ And if the API for commands was verbose, or if it required lots of in between st
 To solve this, Slate has very expressive, chainable commands. Like this:
 
 ```js
-change
+editor
   .focus()
   .moveToRangeOfDocument()
   .delete()
@@ -85,30 +85,29 @@ When you decide you want to make a change to the Slate value, you're almost alwa
 
 ### 1. In Slate Handlers
 
-The first place, is inside a Slate-controlled event handler, like `onKeyDown` or `onPaste`. These handlers take a signature of `event, change, next`. That `change` argument is a [`Change`](../reference/slate/change.md) object that you can manipulate. For example...
+The first place, is inside a Slate-controlled event handler, like `onKeyDown` or `onPaste`. These handlers take a signature of `event, editor, next`. For example...
 
 ```js
-function onKeyDown(event, change, next) {
+function onKeyDown(event, editor, next) {
   if (event.key == 'Enter') {
-    change.splitBlock()
+    editor.splitBlock()
+  } else {
+    return next()
   }
 }
 ```
 
-Any commands you call will be applied, and when the event handler stack is finished resolving, the editor will automatically update with those commands.
+Any commands you call will be applied immediately to the `editor` object, and flushed to the `onChange` handler on the next tick.
 
 ### 2. From Custom Node Components
 
-The second place is inside a custom node component. For example, you might have an `<Image>` component and you want to make a change when the image is clicked.
-
-In that case, you'll need to use the `change()` method on the Slate [`<Editor>`](../reference/slate-react/editor.md) which you have available as `props.editor`. For example...
+The second place is inside a custom node component. For example, you might have an `<Image>` component and you want to make a change when the image is clicked. For example...
 
 ```js
 class Image extends React.Component {
   onClick = event => {
-    this.props.editor.change(change => {
-      change.removeNodeByKey(this.props.node.key)
-    })
+    const { editor, node } = this.props
+    editor.removeNodeByKey(node.key)
   }
 
   render() {
@@ -117,7 +116,7 @@ class Image extends React.Component {
 }
 ```
 
-The `editor.change()` method will create a new [`Change`](../reference/slate/change.md) object for you, based on the editor's current plugins and value. You can then call any commands you want, and the new value will be applied to the editor.
+The `<Image>` node component will be passed the `editor` and the `node` it represents as props, so you can use these to trigger commands.
 
 ### 3. From Schema Rules
 
@@ -130,9 +129,9 @@ The third place you may perform change operations—for more complex use cases
       nodes: [{
         match: { type: 'item' }
       }],
-      normalize: (change, error) => {
+      normalize: (editor, error) => {
         if (error.code == 'child_type_invalid') {
-          change.wrapBlockByKey(error.child.key, 'item')
+          editor.wrapBlockByKey(error.child.key, 'item')
         }
       }
     }
@@ -140,7 +139,7 @@ The third place you may perform change operations—for more complex use cases
 }
 ```
 
-When a rule's validation fails, Slate passes a [`Change`](../reference/slate/change.md) object to the `normalize` function of the rule, if one exists. You can use this object to apply the commands necessary to make your document valid on the next normalization pass.
+When a rule's validation fails, Slate passes the editor to the `normalize` function of the rule, if one exists. You can use these normalizing funcrtions to apply the commands necessary to make your document valid on the next normalization pass.
 
 ### 4. From Outside Slate
 
@@ -148,25 +147,28 @@ The last place is from outside of Slate. Sometimes you'll have components that l
 editor in the render tree, and you'll need to explicitly pass them a reference to the Slate `editor` to run changes. In React you do this with the `ref={}` prop...
 
 ```js
-<Editor ref={this.editor = editor} ...>
+<Editor
+  ref={editor => this.editor = editor}
+  ...
+/>
 ```
 
-Which gives you a reference to the Slate editor. And from there you can use the same `editor.change` syntax from above to apply changes.
+Which gives you a reference to the Slate editor. And from there you can use the same commands syntax from above to apply changes.
 
 ## Running Queries
 
 Queries are similar to commands, but instead of manipulating the current value of the editor, they return information about the current value, or a specific node, etc.
 
-By default, Slate only defines two queries: `isAtomic` for marks and decorations, and `isVoid` for nodes. You can access them directly on the change object:
+By default, Slate only defines two queries: `isAtomic` for marks and decorations, and `isVoid` for nodes. You can access them directly on the editor:
 
 ```js
-const isVoid = change.isVoid(node)
+const isVoid = editor.isVoid(node)
 ```
 
 But you can also define your own queries that are specific to your schema. For example, you might use a query to determine whether the "bold" mark is active...
 
 ```js
-const isBold = change.isBoldActive(value)
+const isBold = editor.isBoldActive(value)
 ```
 
 And then use that information to mark the <kbd>bold</kbd> button in your editor's toolbar as active or not.
@@ -175,17 +177,17 @@ And then use that information to mark the <kbd>bold</kbd> button in your editor'
 
 In addition to using the built-in commands, if your editor is of any complexity you'll want to write your own reusable commands. That way, you can reuse a single `insertImage` change instead of constantly writing `insertBlock(...args)`.
 
-To do that, you can define commands in your own Slate plugin, which will be made available as methods on the `change` object specific to your editor. For example, here are two simple block inserting commands...
+To do that, you can define commands in your own Slate plugin, which will be made available as methods on the `editor` object. For example, here are two simple block inserting commands...
 
 ```js
 const yourPlugin = {
   commands: {
-    insertParagraph(change) {
-      change.insertBlock('paragraph')
+    insertParagraph(editor) {
+      editor.insertBlock('paragraph')
     },
 
-    insertImage(change, src) {
-      change.insertBlock({
+    insertImage(editor, src) {
+      editor.insertBlock({
         type: 'image',
         data: { src },
       })
@@ -197,7 +199,7 @@ const yourPlugin = {
 Notice how rewriting that image inserting logic multiple times without having it encapsulated in a single function would get tedious. Now with those change functions defined, you can reuse them!
 
 ```js
-change.insertImage('https://google.com/logo.png')
+editor.insertImage('https://google.com/logo.png')
 ```
 
 And any arguments you pass in are sent to your custom command functions.
@@ -214,10 +216,10 @@ const yourPlugin = {
 }
 ```
 
-And then you can use them:
+And then you can use them right from the `editor` instance:
 
 ```js
-change.getActiveListItem()
+editor.getActiveListItem()
 ```
 
 This reusability is key to being able to organize your commands and queries, and compose them together to create more advanced behaviors.
diff --git a/docs/guides/plugins.md b/docs/guides/plugins.md
index 60cdb5947..21bf9dcf3 100644
--- a/docs/guides/plugins.md
+++ b/docs/guides/plugins.md
@@ -17,16 +17,18 @@ So a basic plugin might look like this:
 ```js
 export default function MySlatePlugin(options) {
   return {
-    onKeyDown(event, change, next) {
+    onKeyDown(event, editor, next) {
       if (event.key == options.key) {
-        change.blur()
-        return true
+        editor.blur()
+      } else {
+        return next()
       }
     },
-    onClick(event, change, next) {
-      if (change.value.selection.isBlurred) {
-        change.moveToRangeOfDocument().focus()
-        return true
+    onClick(event, editor, next) {
+      if (editor.value.selection.isBlurred) {
+        editor.moveToRangeOfDocument().focus()
+      } else {
+        return next()
       }
     },
   }
@@ -37,8 +39,6 @@ It focuses the editor and selects everything when it is clicked, and it blurs th
 
 Notice how it's able to define a set of behaviors, reacting to different events, that work together to form a single "feature" in the editor. That's what makes Slate's plugins a powerful form of encapsulation.
 
-Also notice how it returns `true`. This is a convention that allows other plugins in the stack to know that an event has been "handled" and that they can abort without duplicating logic.
-
 ## The Plugins "Stack"
 
 Slate's editor takes a list of plugins as one of its arguments. We refer to this list as the plugins "stack". It is very similar to "middleware" from Express or Koa, except instead of just a single stack of handler functions, there are multiple stacks for each type of request.
@@ -120,9 +120,11 @@ For example, you may have a simple `Hotkey` plugin that makes binding behaviors
 ```js
 function Hotkey(hotkey, fn) {
   return {
-    onKeyDown(event, change, editor) {
+    onKeyDown(event, editor, next) {
       if (isHotkey(hotkey, event)) {
-        change.call(fn)
+        editor.command(fn)
+      } else {
+        return next()
       }
     },
   }
@@ -134,7 +136,7 @@ That pseudo-code allows you to encapsulate the hotkey-binding logic in one place
 ```js
 const plugins = [
   ...,
-  Hotkey('cmd+b', change => change.addMark('bold')),
+  Hotkey('cmd+b', editor => editor.addMark('bold')),
 ]
 ```
 
diff --git a/docs/guides/rendering.md b/docs/guides/rendering.md
index 336ea0ef6..cfe6b9db7 100644
--- a/docs/guides/rendering.md
+++ b/docs/guides/rendering.md
@@ -13,7 +13,7 @@ Using custom components for the nodes and marks is the most common rendering nee
 The function is called with the node's props, including `props.node` which is the node itself. You can use these to determine what to render. For example, you can render nodes using simple HTML elements:
 
 ```js
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   const { node, attributes, children } = props
 
   switch (node.type) {
@@ -36,7 +36,7 @@ function renderNode(props, next) {
 You don't have to use simple HTML elements, you can use your own custom React components too:
 
 ```js
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   switch (props.node.type) {
     case 'paragraph':
       return <ParagraphComponent {...props} />
@@ -55,7 +55,7 @@ And you can just as easily put that `renderNode` logic into a plugin, and pass t
 ```js
 function SomeRenderingPlugin() {
   return {
-    renderNode(props, next) {
+    renderNode(props, editor, next) {
       ...
     }
   }
@@ -75,7 +75,7 @@ const plugins = [
 Marks work the same way, except they invoke the `renderMark` function. Like so:
 
 ```js
-function renderMark(props, next) {
+function renderMark(props, editor, next) {
   const { children, mark, attributes } = props
   switch (mark.type) {
     case 'bold':
@@ -107,8 +107,8 @@ By default Slate will render a placeholder for you which mimics the native DOM `
 However sometimes you want to customize things. Or maybe you want to render placeholders inside specific blocks like inside an image caption. To do that, you can define your own `renderPlaceholder` function:
 
 ```js
-function renderPlaceholder(props, next) {
-  const { node, editor } = props
+function renderPlaceholder(props, editor, next) {
+  const { node } = props
   if (node.object != 'block') return next()
   if (node.type != 'caption') return next()
   if (node.text != '') return next()
@@ -138,7 +138,7 @@ Not only can you control the rendering behavior of the components inside the edi
 This sounds weird, but it can be pretty useful if you want to render additional top-level elements from inside a plugin. To do so, you use the `renderEditor` function:
 
 ```js
-function renderEditor(props, next) {
+function renderEditor(props, editor, next) {
   const { editor } = props
   const wordCount = countWords(editor.value.text)
   const children = next()
diff --git a/docs/guides/schemas.md b/docs/guides/schemas.md
index 2c28d28ff..6eae3a9ce 100644
--- a/docs/guides/schemas.md
+++ b/docs/guides/schemas.md
@@ -73,9 +73,9 @@ const schema = {
     nodes: [{
       match: [{ type: 'paragraph' }, { type: 'image' }],
     }],
-    normalize: (change, error) => {
+    normalize: (editor, error) => {
       if (error.code == 'child_type_invalid') {
-        change.setNodeByKey(error.child.key, { type: 'paragraph' })
+        editor.setNodeByKey(error.child.key, { type: 'paragraph' })
       }
     }
   },
@@ -100,13 +100,13 @@ Sometimes though, the declarative validation syntax isn't fine-grained enough to
 When you define a `normalizeNode` function, you either return nothing if the node's already valid, or you return a normalizer function that will make the node valid if it isn't. Here's an example:
 
 ```js
-function normalizeNode(node, next) {
+function normalizeNode(node, editor, next) {
   const { nodes } = node
   if (node.object !== 'block') return next()
   if (nodes.size !== 3) return next()
   if (nodes.first().object !== 'text') return next()
   if (nodes.last().object !== 'text') return next()
-  return change => change.removeNodeByKey(node.key)
+  return () => editor.removeNodeByKey(node.key)
 }
 ```
 
diff --git a/docs/reference/slate-react/editor.md b/docs/reference/slate-react/editor.md
index 8427912f9..fc13a484d 100644
--- a/docs/reference/slate-react/editor.md
+++ b/docs/reference/slate-react/editor.md
@@ -159,64 +159,3 @@ const plugins = [
 ### `schema`
 
 To see how these properties behave, check out the [Plugins reference](./plugins.md).
-
-## Instance Methods
-
-### `blur`
-
-`blur() => Void`
-
-Programmatically blur the editor.
-
-### `change`
-
-`change(fn) => Void`
-`change(fn, ...args) => Void`
-
-Programmatically invoke a change `fn` on the editor. The function will be invoked with a new `change` object representing the editor's current value.
-
-If extra `...args` are passed in, the change `fn` will be invoked with `(change, ...args)`, so you can use this as a shorthand for performing single-function changes.
-
-### `command`
-
-`command(name, ...args) => Void`
-
-Invoke a command by `name` on the editor with `args`.
-
-### `event`
-
-`event(handler, event, ...args) => Any`
-
-Programmatically invoke an `event` on the editor. This isn't something you should normally use except in test environments.
-
-### `focus`
-
-`focus() => Void`
-
-Programmatically focus the editor.
-
-### `query`
-
-`query(name, ...args) => Any`
-
-Invoke a query by `name` on the editor with `args`, returning its result.
-
-### `run`
-
-`run(key, ...args) => Any`
-
-Run the middleware stack by `key` with `args`, returning its result.
-
-## Instance Properties
-
-### `readOnly`
-
-`Boolean`
-
-Whether the editor is currently read-only or not.
-
-### `value`
-
-`Value`
-
-The editor's current value.
diff --git a/docs/reference/slate-react/plugins.md b/docs/reference/slate-react/plugins.md
index 9e4541498..316f9e79e 100644
--- a/docs/reference/slate-react/plugins.md
+++ b/docs/reference/slate-react/plugins.md
@@ -29,19 +29,19 @@ In addition to the [core plugin hooks](../slate/plugins.md), when using `slate-r
 }
 ```
 
-The event hooks have a signature of `(event, change, next)`—the `event` is a React object that you are used to from React's event handlers.
+The event hooks have a signature of `(event, editor, next)`—the `event` is a React object that you are used to from React's event handlers.
 
-The rendering hooks are just like render props common to other React API's, and receive `(props, next)`. For more information, see the [Rendering](./rendering.md) reference.
+The rendering hooks are just like render props common to other React API's, and receive `(props, editor, next)`. For more information, see the [Rendering](./rendering.md) reference.
 
 ### `decorateNode`
 
-`Function decorateNode(node: Node, next: Function) => Array<Decoration>|Void`
+`Function decorateNode(node: Node, editor: Editor, next: Function) => Array<Decoration>|Void`
 
 The `decorateNode` hook takes a `node` and returns an array of decorations with marks to be applied to the node when it is rendered.
 
 ### `onBeforeInput`
 
-`Function onBeforeInput(event: Event, change: Change, next: Function) => Boolean`
+`Function onBeforeInput(event: Event, editor: Editor, next: Function) => Boolean`
 
 This handler is called right before a string of text is inserted into the `contenteditable` element.
 
@@ -49,37 +49,37 @@ Make sure to `event.preventDefault()` if you do not want the default insertion b
 
 ### `onBlur`
 
-`Function onBlur(event: Event, change: Change, next: Function) => Boolean`
+`Function onBlur(event: Event, editor: Editor, next: Function) => Boolean`
 
 This handler is called when the editor's `contenteditable` element is blurred.
 
 ### `onFocus`
 
-`Function onFocus(event: Event, change: Change, next: Function) => Boolean`
+`Function onFocus(event: Event, editor: Editor, next: Function) => Boolean`
 
 This handler is called when the editor's `contenteditable` element is focused.
 
 ### `onCopy`
 
-`Function onCopy(event: Event, change: Change, next: Function) => Boolean`
+`Function onCopy(event: Event, editor: Editor, next: Function) => Boolean`
 
 This handler is called when there is a copy event in the editor's `contenteditable` element.
 
 ### `onCut`
 
-`Function onCut(event: Event, change: Change, next: Function) => Boolean`
+`Function onCut(event: Event, editor: Editor, next: Function) => Boolean`
 
 This handler is equivalent to the `onCopy` handler.
 
 ### `onDrop`
 
-`Function onDrop(event: Event, change: Change, next: Function) => Boolean`
+`Function onDrop(event: Event, editor: Editor, next: Function) => Boolean`
 
 This handler is called when the user drops content into the `contenteditable` element. The event is already prevented by default, so you must define a value change to have any affect occur.
 
 ### `onKeyDown`
 
-`Function onKeyDown(event: Event, change: Change, next: Function) => Boolean`
+`Function onKeyDown(event: Event, editor: Editor, next: Function) => Boolean`
 
 This handler is called when any key is pressed in the `contenteditable` element, before any action is taken.
 
@@ -87,19 +87,19 @@ Make sure to `event.preventDefault()` if you do not want the default insertion b
 
 ### `onKeyUp`
 
-`Function onKeyUp(event: Event, change: Change, next: Function) => Boolean`
+`Function onKeyUp(event: Event, editor: Editor, next: Function) => Boolean`
 
 This handler is called when any key is released in the `contenteditable` element.
 
 ### `onPaste`
 
-`Function onPaste(event: Event, change: Change, next: Function) => Boolean`
+`Function onPaste(event: Event, editor: Editor, next: Function) => Boolean`
 
 This handler is called when the user pastes content into the `contenteditable` element. The event is already prevented by default, so you must define a value change to have any affect occur.
 
 ### `onSelect`
 
-`Function onSelect(event: Event, change: Change, next: Function) => Boolean`
+`Function onSelect(event: Event, editor: Editor, next: Function) => Boolean`
 
 This handler is called whenever the native DOM selection changes.
 
@@ -107,13 +107,13 @@ This handler is called whenever the native DOM selection changes.
 
 ### `renderEditor`
 
-`Function renderEditor(props: Object, next: Function) => ReactNode|Void`
+`Function renderEditor(props: Object, editor: Editor, next: Function) => ReactNode|Void`
 
 The `renderEditor` property allows you to define higher-order-component-like behavior. It is passed all of the properties of the editor, including `props.children`. You can then choose to wrap the existing `children` in any custom elements or proxy the properties however you choose. This can be useful for rendering toolbars, styling the editor, rendering validation, etc. Remember that the `renderEditor` function has to render `props.children` for editor's content to render.
 
 ### `renderMark`
 
-`Function renderMark(props: Object, next: Function) => ReactNode|Void`
+`Function renderMark(props: Object, editor: Editor, next: Function) => ReactNode|Void`
 
 Render a `Mark` with `props`. The `props` object contains:
 
@@ -134,7 +134,7 @@ You must spread the `props.attributes` onto the top-level DOM node you use to re
 
 ### `renderNode`
 
-`Function renderNode(props: Object, next: Function) => ReactNode|Void`
+`Function renderNode(props: Object, editor: Editor, next: Function) => ReactNode|Void`
 
 Render a `Node` with `props`. The `props` object contains:
 
@@ -155,7 +155,7 @@ You must spread the `props.attributes` onto the top-level DOM node you use to re
 
 ### `renderPlaceholder`
 
-`Function renderPlaceholder(props: Object, next: Function) => ReactNode|Void`
+`Function renderPlaceholder(props: Object, editor: Editor, next: Function) => ReactNode|Void`
 
 Render the placeholder that is shown when the editor has no `value`. The `props` object contains:
 
@@ -170,6 +170,6 @@ The `placeholder` prop that was passed to the editor can be found at `editor.pro
 
 ### `shouldNodeComponentUpdate`
 
-`Function shouldNodeComponentUpdate(previousProps: Object, props: Object, next: Function) => Boolean|Void`
+`Function shouldNodeComponentUpdate(previousProps: Object, props: Object, editor: Editor, next: Function) => Boolean|Void`
 
 If this function returns `true`, it can force updating the node's component where otherwise it wouldn't for performance.
diff --git a/docs/reference/slate-react/rendering.md b/docs/reference/slate-react/rendering.md
index 4ab023a02..7a4fd0677 100644
--- a/docs/reference/slate-react/rendering.md
+++ b/docs/reference/slate-react/rendering.md
@@ -56,9 +56,7 @@ const value = editor.value
 ```
 
 ```js
-editor.change(change => {
-  change.moveToRangeOfDocument().delete()
-})
+editor.moveToRangeOfDocument().delete()
 ```
 
 ### `isSelected`
diff --git a/docs/reference/slate-react/utils.md b/docs/reference/slate-react/utils.md
index e8115f402..b926d491f 100644
--- a/docs/reference/slate-react/utils.md
+++ b/docs/reference/slate-react/utils.md
@@ -24,8 +24,7 @@ React-specific utility functions for Slate that may be useful in certain use cas
 During a cut or copy event, sets `fragment` as the Slate document fragment to be copied.
 
 ```js
-function onCopy(event, change, next) {
-  const { editor } = change
+function onCopy(event, editor, next) {
   const fragment = // ... create a fragment from a set of nodes ...
 
   if (fragment) {
@@ -38,14 +37,13 @@ function onCopy(event, change, next) {
 Note that calling `cloneFragment` should be the last thing you do in your event handler. If you change the window selection after calling `cloneFragment`, the browser may copy the wrong content. If you need to perform an action after calling `cloneFragment`, wrap it in `requestAnimationFrame`:
 
 ```js
-function onCut(event, change, next) {
-  const { editor } = change
+function onCut(event, editor, next) {
   const fragment = // ... create a fragment from a set of nodes ...
 
   if (fragment) {
     cloneFragment(event, editor, fragment)
     window.requestAnimationFrame(() => {
-      editor.change(change => change.delete())
+      editor.delete()
     })
     return true
   }
@@ -73,8 +71,8 @@ function componentDidUpdate() {
 Find the DOM range from a Slate [`Range`](../slate/range.md).
 
 ```js
-function onChange(change) {
-  const { value } = change
+function onChange(editor) {
+  const { value } = editor
   const range = findDOMRange(value.selection)
   // Do something with the DOM `range`...
 }
@@ -119,7 +117,7 @@ function onSomeNativeEvent() {
 Get the affected Slate range from a DOM `event` and Slate `editor`.
 
 ```js
-function onDrop(event, change, next) {
+function onDrop(event, editor, next) {
   const targetRange = getEventRange(event, editor)
   // Do something at the drop `targetRange`...
 }
@@ -132,7 +130,7 @@ function onDrop(event, change, next) {
 Get the Slate-related data from a DOM `event` and Slate `value`.
 
 ```js
-function onDrop(event, change, next) {
+function onDrop(event, editor, next) {
   const transfer = getEventTransfer(event)
   const { type, node } = transfer
 
@@ -149,8 +147,8 @@ function onDrop(event, change, next) {
 Sets the Slate-related `data` with `type` on an `event`. The `type` must be one of the types Slate recognizes: `'fragment'`, `'html'`, `'node'`, `'rich'`, or `'text'`.
 
 ```js
-function onDragStart(event, change, next) {
-  const { value } = change
+function onDragStart(event, editor, next) {
+  const { value } = editor
   const { startNode } = value
   setEventTransfer(event, 'node', startNode)
 }
diff --git a/docs/reference/slate/change.md b/docs/reference/slate/commands.md
similarity index 63%
rename from docs/reference/slate/change.md
rename to docs/reference/slate/commands.md
index b34a74a5e..c0d6651a3 100644
--- a/docs/reference/slate/change.md
+++ b/docs/reference/slate/commands.md
@@ -1,149 +1,40 @@
-# `Change`
+# Commands
 
-A change allows you to define a series of changes you'd like to make to the current [`Value`](./value.md).
+The core `Editor` ships with a bunch of built-in commands that provide common behaviors for rich text editors.
 
-All changes are performed through `Change` objects, so that a history of changes can be preserved for use in undo/redo operations, and to make collaborative editing possible.
+## Current Selection Commands
 
-## Properties
-
-### `editor`
-
-`Editor`
-
-A reference to the editor the change is being made in.
-
-### `object`
-
-`String`
-
-A string with a value of `'change'`.
-
-### `value`
-
-`Value`
-
-A [`Value`](./value.md) with the change's current operations applied. Each time you run a new change function this property will be updated.
-
-## Methods
-
-### `call`
-
-`call(fn: Function, ...args) => Change`
-
-This method calls the provided function with the current instance of the `Change` object as the first argument and passes through the remaining `args`.
-
-The purpose of `call` is to enable custom change methods to exist and called in a chain. For example:
-
-```js
-function addBoldMark(change) {
-  change.addMark('bold_mark')
-}
-
-function insertParagraph(change) {
-  change.insertBlock('paragraph_block')
-}
-
-function onSomeEvent(event, change) {
-  change
-    .call(insertParagraph)
-    .insertText('Some text...')
-    .extendToStartOfBlock()
-    .call(addBoldMark)
-    .collapseToEnd()
-}
-```
-
-### `normalize`
-
-`normalize() => Void`
-
-This method normalizes the document with the value's schema. This should run automatically-you should not need to call this method unless you have manually disabled normalization (and you should rarely, if ever, need to manually disable normalization). The vast majority of changes, whether by the user or invoked programmatically, will run `normalize` by default to ensure the document is always in adherence to its schema.
-
-> 🤖 If you must use this method, use it sparingly and strategically. Calling this method can be very expensive as it will run normalization on all of the nodes in your document.
-
-### `withoutNormalizing`
-
-`withoutNormalizing(fn: Function) => Change`
-
-This method calls the provided function with the current instance of the `Change` object as the first argument. Normalization does not occur while the fuction is executing, and is instead deferred to be be run immediately after it completes.
-
-This method can be used to allow a sequence of change operations that should not be interrupted by normalization. For example:
-
-```js
-function removeManyNodes(node) {
-  const toRemove = node.nodes.filter(n => n.object != 'block')
-  if (!toRemove.size) return
-
-  change.withoutNormalizing(() => {
-    toRemove.forEach(child => {
-      change.removeNodeByKey(child.key)
-    })
-  })
-}
-```
-
-### `withoutSaving`
-
-`withoutSaving(fn: Function) => Change`
-
-By default all new operations are saved to the editor's history. If you have changes that you don't want to show up in the history when the user presses <kbd>cmd+z</kbd>, you can use `withoutSaving` to skip those changes.
-
-```js
-change.withoutSaving(() => {
-  change.setValue({ decorations })
-})
-```
-
-However, be sure you know what you are doing because this will create changes that cannot be undone by the user, and might result in confusing behaviors.
-
-### `withoutMerging`
-
-`withoutMerging(fn: Function) => Change`
-
-Usually, all of the operations in a `Change` are grouped into a single save point in the editor's history. However, sometimes you may want more control over this, to be able to create distinct save points in a single change. To do that, you can use the `withoutMerging` helper.
-
-## Full Value Change
-
-### `setValue`
-
-`setValue(properties: Object, [options: Object]) => Change` <br/>
-`setValue(value: Value, [options: Object]) => Change` (see warning below)
-
-Set the entire `value` using either a `properties` object or a `Value` object. Can be used to set `value.data` and other properties that cannot otherwise be easily set using the available methods.
-
-## Current Selection Changes
-
-These changes act on the `document` based on the current `selection`. They are equivalent to calling the [Document Range Changes](#document-range-changes) with the current selection as the `range` argument, but they are there for convenience, since you often want to act with the current selection, as a user would.
+These commands act on the `document` based on the current `selection`. They are equivalent to calling the [Document Range Commands](#document-range-commands) with the current selection as the `range` argument, but they are there for convenience, since you often want to act with the current selection, as a user would.
 
 ### `addMark`
 
-`addMark(mark: Mark) => Change` <br/>
-`addMark(properties: Object) => Change` <br/>
-`addMark(type: String) => Change`
+`addMark(mark: Mark) => Editor` <br/>
+`addMark(properties: Object) => Editor` <br/>
+`addMark(type: String) => Editor`
 
 Add a [`mark`](./mark.md) to the characters in the current selection. For convenience, you can pass a `type` string or `properties` object to implicitly create a [`Mark`](./mark.md) of that type.
 
 ### `delete`
 
-`delete() => Change`
+`delete() => Editor`
 
 Delete everything in the current selection.
 
 ### `insertBlock`
 
-`insertBlock(block: Block) => Change` <br/>
-`insertBlock(properties: Object) => Change` <br/>
-`insertBlock(type: String) => Change`
+`insertBlock(block: Block) => Editor` <br/>
+`insertBlock(properties: Object) => Editor` <br/>
+`insertBlock(type: String) => Editor`
 
 ### `deleteBackward`
 
-`deleteBackward(n: Number) => Change`
+`deleteBackward(n: Number) => Editor`
 
 Delete backward `n` characters at the current cursor. If the selection is expanded, this method is equivalent to a regular [`delete()`](#delete). `n` defaults to `1`.
 
 ### `deleteForward`
 
-`deleteForward(n: Number) => Change`
+`deleteForward(n: Number) => Editor`
 
 Delete forward `n` characters at the current cursor. If the selection is expanded, this method is equivalent to a regular [`delete()`](#delete). `n` defaults to `1`.
 
@@ -151,375 +42,375 @@ Insert a new block at the same level as the current block, splitting the current
 
 ### `insertFragment`
 
-`insertFragment(fragment: Document) => Change`
+`insertFragment(fragment: Document) => Editor`
 
 Insert a [`fragment`](./document.md) at the current selection. If the selection is expanded, it will be deleted first.
 
 ### `insertInline`
 
-`insertInline(inline: Inline) => Change` <br/>
-`insertInline(properties: Object) => Change`
+`insertInline(inline: Inline) => Editor` <br/>
+`insertInline(properties: Object) => Editor`
 
 Insert a new inline at the current cursor position, splitting the text to make room if it is non-empty. If the selection is expanded, it will be deleted first.
 
 ### `insertText`
 
-`insertText(text: String) => Change`
+`insertText(text: String) => Editor`
 
 Insert a string of `text` at the current selection. If the selection is expanded, it will be deleted first.
 
 ### `setBlocks`
 
-`setBlocks(properties: Object) => Change` <br/>
-`setBlocks(type: String) => Change`
+`setBlocks(properties: Object) => Editor` <br/>
+`setBlocks(type: String) => Editor`
 
 Set the `properties` of the [`Blocks`](./block.md) in the current selection. For convenience, you can pass a `type` string to set the blocks' type only.
 
 ### `setInlines`
 
-`setInlines(properties: Object) => Change` <br/>
-`setInlines(type: String) => Change`
+`setInlines(properties: Object) => Editor` <br/>
+`setInlines(type: String) => Editor`
 
 Set the `properties` of the [`Inlines`](./inline.md) nodes in the current selection. For convenience, you can pass a `type` string to set the inline nodes' type only.
 
 ### `splitBlock`
 
-`splitBlock(depth: Number) => Change`
+`splitBlock(depth: Number) => Editor`
 
 Split the [`Block`](./block.md) in the current selection by `depth` levels. If the selection is expanded, it will be deleted first. `depth` defaults to `1`.
 
 ### `splitInline`
 
-`splitInline(depth: Number) => Change`
+`splitInline(depth: Number) => Editor`
 
 Split the [`Inline`](./inline.md) node in the current selection by `depth` levels. If the selection is expanded, it will be deleted first. `depth` defaults to `Infinity`.
 
 ### `removeMark`
 
-`removeMark(mark: Mark) => Change` <br/>
-`removeMark(properties: Object) => Change` <br/>
-`removeMark(type: String) => Change`
+`removeMark(mark: Mark) => Editor` <br/>
+`removeMark(properties: Object) => Editor` <br/>
+`removeMark(type: String) => Editor`
 
 Remove a [`mark`](./mark.md) from the characters in the current selection. For convenience, you can pass a `type` string or `properties` object to implicitly create a [`Mark`](./mark.md) of that type.
 
 ### `replaceMark`
 
-`replaceMark(oldMark: Mark, newMark: Mark) => Change` <br/>
-`replaceMark(oldProperties: Object, newProperties: Object) => Change` <br/>
-`replaceMark(oldType: String, newType: String) => Change`
+`replaceMark(oldMark: Mark, newMark: Mark) => Editor` <br/>
+`replaceMark(oldProperties: Object, newProperties: Object) => Editor` <br/>
+`replaceMark(oldType: String, newType: String) => Editor`
 
 Replace a [`mark`](./mark.md) in the characters in the current selection. For convenience, you can pass a `type` string or `properties` object to implicitly create a [`Mark`](./mark.md) of that type.
 
 ### `toggleMark`
 
-`toggleMark(mark: Mark) => Change` <br/>
-`toggleMark(properties: Object) => Change` <br/>
-`toggleMark(type: String) => Change`
+`toggleMark(mark: Mark) => Editor` <br/>
+`toggleMark(properties: Object) => Editor` <br/>
+`toggleMark(type: String) => Editor`
 
 Add or remove a [`mark`](./mark.md) from the characters in the current selection, depending on it already exists on any or not. For convenience, you can pass a `type` string or `properties` object to implicitly create a [`Mark`](./mark.md) of that type.
 
 ### `unwrapBlock`
 
-`unwrapBlock(type: String) => Change` <br/>
-`unwrapBlock(properties: Object) => Change` <br />
+`unwrapBlock(type: String) => Editor` <br/>
+`unwrapBlock(properties: Object) => Editor` <br />
 
 Unwrap all [`Block`](./block.md) nodes in the current selection that match a `type` and/or `data`.
 
 ### `unwrapInline`
 
-`unwrapInline(type: String) => Change` <br/>
-`unwrapInline(properties: Object) => Change` <br/>
+`unwrapInline(type: String) => Editor` <br/>
+`unwrapInline(properties: Object) => Editor` <br/>
 
 Unwrap all [`Inline`](./inline.md) nodes in the current selection that match a `type` and/or `data`.
 
 ### `wrapBlock`
 
-`wrapBlock(type: String) => Change` <br/>
-`wrapBlock(properties: Object) => Change` <br/>
+`wrapBlock(type: String) => Editor` <br/>
+`wrapBlock(properties: Object) => Editor` <br/>
 
 Wrap the [`Block`](./block.md) nodes in the current selection with a new [`Block`](./block.md) node of `type`, with optional `data`.
 
 ### `wrapInline`
 
-`wrapInline(type: String) => Change` <br />
-`wrapInline(properties: Object) => Change` <br />
+`wrapInline(type: String) => Editor` <br />
+`wrapInline(properties: Object) => Editor` <br />
 
 Wrap the [`Inline`](./inline.md) nodes in the current selection with a new [`Inline`](./inline.md) node of `type`, with optional `data`.
 
 ### `wrapText`
 
-`wrapText(prefix: String, [suffix: String]) => Change`
+`wrapText(prefix: String, [suffix: String]) => Editor`
 
 Surround the text in the current selection with `prefix` and `suffix` strings. If the `suffix` is ommitted, the `prefix` will be used instead.
 
-## Selection Changes
+## Selection Commands
 
-These changes change the current `selection`, without touching the `document`.
+These commands change the current `selection`, without touching the `document`.
 
 ### `blur`
 
-`blur() => Change`
+`blur() => Editor`
 
 Blur the current selection.
 
 ### `deselect`
 
-`deselect() => Change`
+`deselect() => Editor`
 
 Unset the selection.
 
 ### `flip`
 
-`flip() => Change`
+`flip() => Editor`
 
 Flip the selection.
 
 ### `focus`
 
-`focus() => Change`
+`focus() => Editor`
 
 Focus the current selection.
 
 ### `move{Point}Backward`
 
-`move{Point}Backward(n: Number) => Change`
+`move{Point}Backward(n: Number) => Editor`
 
 Move the `{Point}` of the selection backward `n` characters. Where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`. You can also omit `{Point}` to move both the anchor and focus points at the same time.
 
 ### `move{Point}Forward`
 
-`move{Point}Forward(n: Number) => Change`
+`move{Point}Forward(n: Number) => Editor`
 
 Move the `{Point}` of the selection forward `n` characters. Where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`. You can also omit `{Point}` to move both the anchor and focus points at the same time.
 
 ### `move{Point}To`
 
-`moveTo(path: List, offset: Number) => Change`
-`moveTo(key: String, offset: Number) => Change`
-`moveTo(offset: Number) => Change`
+`moveTo(path: List, offset: Number) => Editor`
+`moveTo(key: String, offset: Number) => Editor`
+`moveTo(offset: Number) => Editor`
 
 Move the `{Point}` of the selection to a new `path` or `key` and `offset`. Where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`. You can also omit `{Point}` to move both the anchor and focus points at the same time.
 
 ### `moveTo{Point}`
 
-`moveTo{Point}() => Change`
+`moveTo{Point}() => Editor`
 
 Collapse the current selection to one of its points. Where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`.
 
 ### `move{Point}To{Edge}OfBlock`
 
-`move{Point}To{Edge}OfBlock() => Change`
+`move{Point}To{Edge}OfBlock() => Editor`
 
 Move the current selection to the `{Edge}` of the closest block parent. Where `{Edge}` is either `Start` or `End`. And where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`. You can also omit `{Point}` to move both the anchor and focus points at the same time.
 
 ### `move{Point}To{Edge}OfDocument`
 
-`move{Point}To{Edge}OfDocument() => Change`
+`move{Point}To{Edge}OfDocument() => Editor`
 
 Move the current selection to the `{Edge}` of the document. Where `{Edge}` is either `Start` or `End`. And where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`. You can also omit `{Point}` to move both the anchor and focus points at the same time.
 
 ### `move{Point}To{Edge}OfInline`
 
-`move{Point}To{Edge}OfInline() => Change`
+`move{Point}To{Edge}OfInline() => Editor`
 
 Move the current selection to the `{Edge}` of the closest inline parent. Where `{Edge}` is either `Start` or `End`. And where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`. You can also omit `{Point}` to move both the anchor and focus points at the same time.
 
 ### `move{Point}To{Edge}OfNode`
 
-`move{Point}To{Edge}OfNode(node: Node) => Change`
+`move{Point}To{Edge}OfNode(node: Node) => Editor`
 
 Move the current selection to the `{Edge}` of a `node`. Where `{Edge}` is either `Start` or `End`. And where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`. You can also omit `{Point}` to move both the anchor and focus points at the same time.
 
 ### `move{Point}To{Edge}OfText`
 
-`move{Point}To{Edge}OfText() => Change`
+`move{Point}To{Edge}OfText() => Editor`
 
 Move the current selection to the `{Edge}` of the current text node. Where `{Edge}` is either `Start` or `End`. And where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`. You can also omit `{Point}` to move both the anchor and focus points at the same time.
 
 ### `move{Point}To{Edge}Of{Direction}Block`
 
-`move{Point}To{Edge}Of{Direction}Block() => Change`
+`move{Point}To{Edge}Of{Direction}Block() => Editor`
 
 Move the current selection to the `{Edge}` of the closest block parent. Where `{Edge}` is either `Start` or `End`. And where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`. You can also omit `{Point}` to move both the anchor and focus points at the same time.
 
 ### `move{Point}To{Edge}Of{Direction}Inline`
 
-`move{Point}To{Edge}Of{Direction}Inline() => Change`
+`move{Point}To{Edge}Of{Direction}Inline() => Editor`
 
 Move the current selection to the `{Edge}` of the closest inline parent. Where `{Edge}` is either `Start` or `End`. And where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`. You can also omit `{Point}` to move both the anchor and focus points at the same time.
 
 ### `move{Point}To{Edge}Of{Direction}Text`
 
-`move{Point}To{Edge}Of{Direction}Text() => Change`
+`move{Point}To{Edge}Of{Direction}Text() => Editor`
 
 Move the current selection to the `{Edge}` of the current text node. Where `{Edge}` is either `Start` or `End`. And where `{Point}` is either `Anchor`, `Focus`, `Start` or `End`. You can also omit `{Point}` to move both the anchor and focus points at the same time.
 
 ### `moveToRangeOf`
 
-`moveToRangeOf(node: Node) => Change`
+`moveToRangeOf(node: Node) => Editor`
 
 Move the current selection's anchor point to the start of a `node` and its focus point to the end of the `node`.
 
 ### `moveToRangeOfDocument`
 
-`moveToRangeOfDocument() => Change`
+`moveToRangeOfDocument() => Editor`
 
 Move the current selection's anchor point to the start of the document and its focus point to the end of the document, selecting everything.
 
 ### `select`
 
-`select(properties: Range || Object) => Change`
+`select(properties: Range || Object) => Editor`
 
 Set the current selection to a range with merged `properties`. The `properties` can either be a [`Range`](./range.md) object or a plain JavaScript object of selection properties.
 
-## Document Range Changes
+## Document Range Commands
 
-These changes act on a specific [`Range`](./range.md) of the document.
+These commands act on a specific [`Range`](./range.md) of the document.
 
 ### `addMarkAtRange`
 
-`addMarkAtRange(range: Range, mark: Mark) => Change` <br/>
-`addMarkAtRange(range: Range, properties: Object) => Change` <br/>
-`addMarkAtRange(range: Range, type: String) => Change`
+`addMarkAtRange(range: Range, mark: Mark) => Editor` <br/>
+`addMarkAtRange(range: Range, properties: Object) => Editor` <br/>
+`addMarkAtRange(range: Range, type: String) => Editor`
 
 Add a [`mark`](./mark.md) to the characters in a `range`. For convenience, you can pass a `type` string or `properties` object to implicitly create a [`Mark`](./mark.md) of that type.
 
 ### `deleteAtRange`
 
-`deleteAtRange(range: Range, ) => Change`
+`deleteAtRange(range: Range, ) => Editor`
 
 Delete everything in a `range`.
 
 ### `deleteBackwardAtRange`
 
-`deleteBackwardAtRange(range: Range, n: Number) => Change`
+`deleteBackwardAtRange(range: Range, n: Number) => Editor`
 
 Delete backward `n` characters at a `range`. If the `range` is expanded, this method is equivalent to a regular [`delete()`](#delete). `n` defaults to `1`.
 
 ### `deleteForwardAtRange`
 
-`deleteForwardAtRange(range: Range, n: Number) => Change`
+`deleteForwardAtRange(range: Range, n: Number) => Editor`
 
 Delete forward `n` characters at a `range`. If the `range` is expanded, this method is equivalent to a regular [`delete()`](#delete). `n` defaults to `1`.
 
 ### `insertBlockAtRange`
 
-`insertBlockAtRange(range: Range, block: Block) => Change` <br/>
-`insertBlockAtRange(range: Range, properties: Object) => Change` <br/>
-`insertBlockAtRange(range: Range, type: String) => Change`
+`insertBlockAtRange(range: Range, block: Block) => Editor` <br/>
+`insertBlockAtRange(range: Range, properties: Object) => Editor` <br/>
+`insertBlockAtRange(range: Range, type: String) => Editor`
 
 Insert a new block at the same level as the leaf block at a `range`, splitting the current block to make room if it is non-empty. If the selection is expanded, it will be deleted first.
 
 ### `insertFragmentAtRange`
 
-`insertFragmentAtRange(range: Range, fragment: Document) => Change`
+`insertFragmentAtRange(range: Range, fragment: Document) => Editor`
 
 Insert a [`fragment`](./document.md) at a `range`. If the selection is expanded, it will be deleted first.
 
 ### `insertInlineAtRange`
 
-`insertInlineAtRange(range: Range, inline: Inline) => Change` <br/>
-`insertInlineAtRange(range: Range, properties: Object) => Change`
+`insertInlineAtRange(range: Range, inline: Inline) => Editor` <br/>
+`insertInlineAtRange(range: Range, properties: Object) => Editor`
 
 Insert a new inline at a `range`, splitting the text to make room if it is non-empty. If the selection is expanded, it will be deleted first.
 
 ### `insertTextAtRange`
 
-`insertTextAtRange(range: Range, text: String) => Change`
+`insertTextAtRange(range: Range, text: String) => Editor`
 
 Insert a string of `text` at a `range`. If the selection is expanded, it will be deleted first.
 
 ### `setBlocksAtRange`
 
-`setBlocksAtRange(range: Range, properties: Object) => Change` <br/>
-`setBlocks(range: Range, type: String) => Change`
+`setBlocksAtRange(range: Range, properties: Object) => Editor` <br/>
+`setBlocks(range: Range, type: String) => Editor`
 
 Set the `properties` of the [`Blocks`](./block.md) in a `range`. For convenience, you can pass a `type` string to set the blocks' type only.
 
 ### `setInlinesAtRange`
 
-`setInlinesAtRange(range: Range, properties: Object) => Change` <br/>
-`setInlines(range: Range, type: String) => Change`
+`setInlinesAtRange(range: Range, properties: Object) => Editor` <br/>
+`setInlines(range: Range, type: String) => Editor`
 
 Set the `properties` of the [`Inlines`](./inline.md) nodes in a `range`. For convenience, you can pass a `type` string to set the inline nodes' type only.
 
 ### `splitBlockAtRange`
 
-`splitBlockAtRange(range: Range, depth: Number) => Change`
+`splitBlockAtRange(range: Range, depth: Number) => Editor`
 
 Split the [`Block`](./block.md) in a `range` by `depth` levels. If the selection is expanded, it will be deleted first. `depth` defaults to `1`.
 
 ### `splitInlineAtRange`
 
-`splitInlineAtRange(range: Range, depth: Number) => Change`
+`splitInlineAtRange(range: Range, depth: Number) => Editor`
 
 Split the [`Inline`](./inline.md) node in a `range` by `depth` levels. If the selection is expanded, it will be deleted first. `depth` defaults to `Infinity`.
 
 ### `removeMarkAtRange`
 
-`removeMarkAtRange(range: Range, mark: Mark) => Change` <br/>
-`removeMarkAtRange(range: Range, properties: Object) => Change` <br/>
-`removeMarkAtRange(range: Range, type: String) => Change`
+`removeMarkAtRange(range: Range, mark: Mark) => Editor` <br/>
+`removeMarkAtRange(range: Range, properties: Object) => Editor` <br/>
+`removeMarkAtRange(range: Range, type: String) => Editor`
 
 Remove a [`mark`](./mark.md) from the characters in a `range`. For convenience, you can pass a `type` string or `properties` object to implicitly create a [`Mark`](./mark.md) of that type.
 
 ### `toggleMarkAtRange`
 
-`toggleMarkAtRange(range: Range, mark: Mark) => Change` <br/>
-`toggleMarkAtRange(range: Range, properties: Object) => Change` <br/>
-`toggleMarkAtRange(range: Range, type: String) => Change`
+`toggleMarkAtRange(range: Range, mark: Mark) => Editor` <br/>
+`toggleMarkAtRange(range: Range, properties: Object) => Editor` <br/>
+`toggleMarkAtRange(range: Range, type: String) => Editor`
 
 Add or remove a [`mark`](./mark.md) from the characters in a `range`, depending on whether any of them already have the mark. For convenience, you can pass a `type` string or `properties` object to implicitly create a [`Mark`](./mark.md) of that type.
 
 ### `unwrapBlockAtRange`
 
-`unwrapBlockAtRange(range: Range, properties: Object) => Change` <br/>
-`unwrapBlockAtRange(range: Range, type: String) => Change`
+`unwrapBlockAtRange(range: Range, properties: Object) => Editor` <br/>
+`unwrapBlockAtRange(range: Range, type: String) => Editor`
 
 Unwrap all [`Block`](./block.md) nodes in a `range` that match `properties`. For convenience, you can pass a `type` string or `properties` object.
 
 ### `unwrapInlineAtRange`
 
-`unwrapInlineAtRange(range: Range, properties: Object) => Change` <br/>
-`unwrapInlineAtRange(range: Range, type: String) => Change`
+`unwrapInlineAtRange(range: Range, properties: Object) => Editor` <br/>
+`unwrapInlineAtRange(range: Range, type: String) => Editor`
 
 Unwrap all [`Inline`](./inline.md) nodes in a `range` that match `properties`. For convenience, you can pass a `type` string or `properties` object.
 
 ### `wrapBlockAtRange`
 
-`wrapBlockAtRange(range: Range, properties: Object) => Change` <br/>
-`wrapBlockAtRange(range: Range, type: String) => Change`
+`wrapBlockAtRange(range: Range, properties: Object) => Editor` <br/>
+`wrapBlockAtRange(range: Range, type: String) => Editor`
 
 Wrap the [`Block`](./block.md) nodes in a `range` with a new [`Block`](./block.md) node with `properties`. For convenience, you can pass a `type` string or `properties` object.
 
 ### `wrapInlineAtRange`
 
-`wrapInlineAtRange(range: Range, properties: Object) => Change` <br/>
-`wrapInlineAtRange(range: Range, type: String) => Change`
+`wrapInlineAtRange(range: Range, properties: Object) => Editor` <br/>
+`wrapInlineAtRange(range: Range, type: String) => Editor`
 
 Wrap the [`Inline`](./inline.md) nodes in a `range` with a new [`Inline`](./inline.md) node with `properties`. For convenience, you can pass a `type` string or `properties` object.
 
 ### `wrapTextAtRange`
 
-`wrapTextAtRange(range: Range, prefix: String, [suffix: String]) => Change`
+`wrapTextAtRange(range: Range, prefix: String, [suffix: String]) => Editor`
 
 Surround the text in a `range` with `prefix` and `suffix` strings. If the `suffix` is ommitted, the `prefix` will be used instead.
 
-## Node Changes
+## Node Commands
 
-These changes are lower-level, and act on a specific node by its `key` or `path`. They're often used in your custom components because you'll have access to `props.node`.
+These commands are lower-level, and act on a specific node by its `key` or `path`. They're often used in your custom components because you'll have access to `props.node`.
 
 ### `addMarkByKey/Path`
 
-`addMarkByKey(key: String, offset: Number, length: Number, mark: Mark) => Change`
-`addMarkByPath(path: List, offset: Number, length: Number, mark: Mark) => Change`
+`addMarkByKey(key: String, offset: Number, length: Number, mark: Mark) => Editor`
+`addMarkByPath(path: List, offset: Number, length: Number, mark: Mark) => Editor`
 
 Add a `mark` to `length` characters starting at an `offset` in a [`Node`](./node.md) by its `key` or `path`.
 
 ### `insertNodeByKey/Path`
 
-`insertNodeByKey(key: String, index: Number, node: Node) => Change`
-`insertNodeByPath(path: List, index: Number, node: Node) => Change`
+`insertNodeByKey(key: String, index: Number, node: Node) => Editor`
+`insertNodeByPath(path: List, index: Number, node: Node) => Editor`
 
 Insert a `node` at `index` inside a parent [`Node`](./node.md) by its `key` or `path`.
 
@@ -532,144 +423,190 @@ Insert a [`Fragment`](./fragment.md) at `index` inside a parent [`Node`](./node.
 
 ### `insertTextByKey/Path`
 
-`insertTextByKey(key: String, offset: Number, text: String, [marks: Set]) => Change`
-`insertTextByPath(path: List, offset: Number, text: String, [marks: Set]) => Change`
+`insertTextByKey(key: String, offset: Number, text: String, [marks: Set]) => Editor`
+`insertTextByPath(path: List, offset: Number, text: String, [marks: Set]) => Editor`
 
 Insert `text` at an `offset` in a [`Text Node`](./text.md) by its `key` with optional `marks`.
 
 ### `mergeNodeByKey/Path`
 
-`mergeNodeByKey(key: String) => Change`
-`mergeNodeByPath(path: List) => Change`
+`mergeNodeByKey(key: String) => Editor`
+`mergeNodeByPath(path: List) => Editor`
 
 Merge a [`Node`](./node.md) by its `key` or `path` with its previous sibling.
 
 ### `moveNodeByKey/Path`
 
-`moveNodeByKey(key: String, newKey: String, newIndex: Number) => Change`
-`moveNodeByPath(path: List, newKey: String, newIndex: Number) => Change`
+`moveNodeByKey(key: String, newKey: String, newIndex: Number) => Editor`
+`moveNodeByPath(path: List, newKey: String, newIndex: Number) => Editor`
 
 Move a [`Node`](./node.md) by its `key` or `path` to a new parent node with its `newKey` and at a `newIndex`.
 
 ### `removeMarkByKey/Path`
 
-`removeMarkByKey(key: String, offset: Number, length: Number, mark: Mark) => Change`
-`removeMarkByPath(path: List, offset: Number, length: Number, mark: Mark) => Change`
+`removeMarkByKey(key: String, offset: Number, length: Number, mark: Mark) => Editor`
+`removeMarkByPath(path: List, offset: Number, length: Number, mark: Mark) => Editor`
 
 Remove a `mark` from `length` characters starting at an `offset` in a [`Node`](./node.md) by its `key` or `path`.
 
 ### `removeNodeByKey/Path`
 
-`removeNodeByKey(key: String) => Change`
-`removeNodeByPath(path: List) => Change`
+`removeNodeByKey(key: String) => Editor`
+`removeNodeByPath(path: List) => Editor`
 
 Remove a [`Node`](./node.md) from the document by its `key` or `path`.
 
 ### `replaceNodeByKey/Path`
 
-`replaceNodeByKey(key: String, node: Node) => Change`
-`replaceNodeByPath(path: List, node: Node) => Change`
+`replaceNodeByKey(key: String, node: Node) => Editor`
+`replaceNodeByPath(path: List, node: Node) => Editor`
 
 Replace a [`Node`](./node.md) in the document with a new [`Node`](./node.md) by its `key` or `path`.
 
 ### `removeTextByKey/Path`
 
-`removeTextByKey(key: String, offset: Number, length: Number) => Change`
-`removeTextByPath(path: List, offset: Number, length: Number) => Change`
+`removeTextByKey(key: String, offset: Number, length: Number) => Editor`
+`removeTextByPath(path: List, offset: Number, length: Number) => Editor`
 
 Remove `length` characters of text starting at an `offset` in a [`Node`](./node.md) by its `key` or `path`.
 
 ### `setMarkByKey/Path`
 
-`setMarkByKey(key: String, offset: Number, length: Number, mark: Mark, properties: Object) => Change`
-`setMarkByPath(path: List, offset: Number, length: Number, mark: Mark, properties: Object) => Change`
+`setMarkByKey(key: String, offset: Number, length: Number, mark: Mark, properties: Object) => Editor`
+`setMarkByPath(path: List, offset: Number, length: Number, mark: Mark, properties: Object) => Editor`
 
 Set a dictionary of `properties` on a [`mark`](./mark.md) on a [`Node`](./node.md) by its `key` or `path`.
 
 ### `setNodeByKey/Path`
 
-`setNodeByKey(key: String, properties: Object) => Change` <br/>
-`setNodeByKey(key: String, type: String) => Change`
-`setNodeByPath(path: List, properties: Object) => Change` <br/>
-`setNodeByPath(path: List, type: String) => Change`
+`setNodeByKey(key: String, properties: Object) => Editor` <br/>
+`setNodeByKey(key: String, type: String) => Editor`
+`setNodeByPath(path: List, properties: Object) => Editor` <br/>
+`setNodeByPath(path: List, type: String) => Editor`
 
 Set a dictionary of `properties` on a [`Node`](./node.md) by its `key` or `path`. For convenience, you can pass a `type` string or `properties` object.
 
 ### `splitNodeByKey/Path`
 
-`splitNodeByKey(key: String, offset: Number) => Change`
-`splitNodeByPath(path: List, offset: Number) => Change`
+`splitNodeByKey(key: String, offset: Number) => Editor`
+`splitNodeByPath(path: List, offset: Number) => Editor`
 
 Split a node by its `key` or `path` at an `offset`.
 
 ### `unwrapInlineByKey/Path`
 
-`unwrapInlineByKey(key: String, properties: Object) => Change` <br/>
-`unwrapInlineByKey(key: String, type: String) => Change`
-`unwrapInlineByPath(path: List, properties: Object) => Change` <br/>
-`unwrapInlineByPath(path: List, type: String) => Change`
+`unwrapInlineByKey(key: String, properties: Object) => Editor` <br/>
+`unwrapInlineByKey(key: String, type: String) => Editor`
+`unwrapInlineByPath(path: List, properties: Object) => Editor` <br/>
+`unwrapInlineByPath(path: List, type: String) => Editor`
 
 Unwrap all inner content of an [`Inline`](./inline.md) node by its `key` or `path` that match `properties`. For convenience, you can pass a `type` string or `properties` object.
 
 ### `unwrapBlockByKey/Path`
 
-`unwrapBlockByKey(key: String, properties: Object) => Change` <br/>
-`unwrapBlockByKey(key: String, type: String) => Change`
-`unwrapBlockByPath(path: List, properties: Object) => Change` <br/>
-`unwrapBlockByPath(path: List, type: String) => Change`
+`unwrapBlockByKey(key: String, properties: Object) => Editor` <br/>
+`unwrapBlockByKey(key: String, type: String) => Editor`
+`unwrapBlockByPath(path: List, properties: Object) => Editor` <br/>
+`unwrapBlockByPath(path: List, type: String) => Editor`
 
 Unwrap all inner content of a [`Block`](./block.md) node by its `key` or `path` that match `properties`. For convenience, you can pass a `type` string or `properties` object.
 
 ### `unwrapNodeByKey/Path`
 
-`unwrapNodeByKey(key: String) => Change`
-`unwrapNodeByPath(path: List) => Change`
+`unwrapNodeByKey(key: String) => Editor`
+`unwrapNodeByPath(path: List) => Editor`
 
 Unwrap a single node from its parent. If the node is surrounded with siblings, its parent will be split. If the node is the only child, the parent is removed, and simply replaced by the node itself. Cannot unwrap a root node.
 
 ### `wrapBlockByKey/Path`
 
-`wrapBlockByKey(key: String, properties: Object) => Change` <br/>
-`wrapBlockByKey(key: String, type: String) => Change`
-`wrapBlockByPath(path: List, properties: Object) => Change` <br/>
-`wrapBlockByPath(path: List, type: String) => Change`
+`wrapBlockByKey(key: String, properties: Object) => Editor` <br/>
+`wrapBlockByKey(key: String, type: String) => Editor`
+`wrapBlockByPath(path: List, properties: Object) => Editor` <br/>
+`wrapBlockByPath(path: List, type: String) => Editor`
 
 Wrap the given node in a [`Block`](./block.md) node that match `properties`. For convenience, you can pass a `type` string or `properties` object.
 
 ### `wrapInlineByKey/Path`
 
-`wrapInlineByKey(key: String, properties: Object) => Change` <br/>
-`wrapInlineByKey(key: String, type: String) => Change`
-`wrapInlineByPath(path: List, properties: Object) => Change` <br/>
-`wrapInlineByPath(path: List, type: String) => Change`
+`wrapInlineByKey(key: String, properties: Object) => Editor` <br/>
+`wrapInlineByKey(key: String, type: String) => Editor`
+`wrapInlineByPath(path: List, properties: Object) => Editor` <br/>
+`wrapInlineByPath(path: List, type: String) => Editor`
 
 Wrap the given node in a [`Inline`](./inline.md) node that match `properties`. For convenience, you can pass a `type` string or `properties` object.
 
 ### `wrapNodeByKey/Path`
 
-`wraNodeByKey(key: String, parent: Node) => Change` <br/>
-`wraNodeByPath(path: List, parent: Node) => Change` <br/>
+`wraNodeByKey(key: String, parent: Node) => Editor` <br/>
+`wraNodeByPath(path: List, parent: Node) => Editor` <br/>
 
 Wrap the node with the specified key with the parent [`Node`](./node.md). This will clear all children of the parent.
 
-## History Changes
+## History Commands
 
-These changes use the history to undo/redo previously made changes.
+These commands use the history to undo/redo previously made changes.
 
 ### `redo`
 
-`redo() => Change`
+`redo() => Editor`
 
 Move forward one step in the history.
 
 ### `undo`
 
-`undo() => Change`
+`undo() => Editor`
 
 Move backward one step in the history.
 
 ### `snapshotSelection`
 
-`snapshotSelection() => Change`
+`snapshotSelection() => Editor`
 
 Snapshot `value.selection` for `undo` purposes, useful with delete operations like `change.removeNodeByKey(focusBlock.key).undo()`.
+
+## Miscellaneous Commands
+
+### `normalize`
+
+`normalize() => Editor`
+
+This method normalizes the document with the value's schema. This should run automatically-you should not need to call this method unless you have manually disabled normalization (and you should rarely, if ever, need to manually disable normalization). The vast majority of changes, whether by the user or invoked programmatically, will run `normalize` by default to ensure the document is always in adherence to its schema.
+
+> 🤖 If you must use this method, use it sparingly and strategically. Calling this method can be very expensive as it will run normalization on all of the nodes in your document.
+
+### `withoutNormalizing`
+
+`withoutNormalizing(fn: Function) => Editor`
+
+This method calls the provided function with the current instance of the `Change` object as the first argument. Normalization does not occur while the fuction is executing, and is instead deferred to be be run immediately after it completes.
+
+This method can be used to allow a sequence of change operations that should not be interrupted by normalization. For example:
+
+```js
+editor.withoutNormalizing(() => {
+  node.nodes.filter(n => n.object != 'block').forEach(child => {
+    editor.removeNodeByKey(child.key)
+  })
+})
+```
+
+### `withoutSaving`
+
+`withoutSaving(fn: Function) => Editor`
+
+By default all new operations are saved to the editor's history. If you have changes that you don't want to show up in the history when the user presses <kbd>cmd+z</kbd>, you can use `withoutSaving` to skip those changes.
+
+```js
+change.withoutSaving(() => {
+  change.setDecorations(decorations)
+})
+```
+
+However, be sure you know what you are doing because this will create changes that cannot be undone by the user, and might result in confusing behaviors.
+
+### `withoutMerging`
+
+`withoutMerging(fn: Function) => Editor`
+
+Usually, all of the operations in a `Change` are grouped into a single save point in the editor's history. However, sometimes you may want more control over this, to be able to create distinct save points in a single change. To do that, you can use the `withoutMerging` helper.
diff --git a/docs/reference/slate/editor.md b/docs/reference/slate/editor.md
index 556d77e73..f3a04d068 100644
--- a/docs/reference/slate/editor.md
+++ b/docs/reference/slate/editor.md
@@ -23,7 +23,13 @@ new Editor({
 
 `Function onChange(change: Change)`
 
-A change handler that will be called with the `change` that applied the change. When the `onChange` handler is called, the `editor.value` will already reflect the new state.
+A change handler that will be called asynchronously with the `change` that applied the change. When the `onChange` handler is called, the `editor.value` will already reflect the new state.
+
+### `operations`
+
+`List<Operation>`
+
+An immutable list of [`Operation`](./operation.md) models that have already been applied to the editor in the current change. As soon as the first operation is added, the `onChange` is queued to run on the next tick.
 
 ### `plugins`
 
@@ -47,67 +53,100 @@ A [`Value`](../slate/value.md) object representing the current value of the edit
 
 ## Methods
 
-### `change`
-
-`change(fn) => Void`
-`change(fn, ...args) => Void`
-
-Programmatically invoke a change `fn` on the editor. The function will be invoked with a new `change` object representing the editor's current value.
-
-If extra `...args` are passed in, the change `fn` will be invoked with `(change, ...args)`, so you can use this as a shorthand for performing single-function changes.
-
 ### `command`
 
-`command(name, ...args) => Void`
+`command(type: String, ...args) => Editor`
+`command(fn: Function, ...args) => Editor`
 
-Invoke a command by `name` on the editor with `args`.
+```js
+editor.command('insertText', 'word')
+editor.command((editor, text) => { ... }, 'word')
+```
 
-### `event`
+Invoke a command by `type` on the editor with `args`.
 
-`event(handler, event, ...args) => Any`
+Alternatively, the `type` argument can be a function, which will be invoked with `(editor, ...args)`. This is helpful in situations where you want write one-off commands with customized logic.
 
-Programmatically invoke an `event` on the editor. This isn't something you should normally use except in test environments.
+### `flush`
 
-### `focus`
+`flush() => Editor`
 
-`focus() => Void`
+```js
+editor.flush()
+```
 
-Programmatically focus the editor.
+Synchronously flush the current changes to editor, calling `onChange`.
+
+> 🤖 In normal operation you never need to use this method! However, it can be helpful for writing tests to be able to keep the entire test synchronous.
 
 ### `query`
 
-`query(name, ...args) => Any`
+`query(type: String, ...args) => Any`
+`query(fn: Function, ...args) => Editor`
 
-Invoke a query by `name` on the editor with `args`, returning its result.
+```js
+editor.query('isLinkActive')
+editor.query(editor => { ... })
+```
+
+Invoke a query by `type` on the editor with `args`, returning its result.
+
+Alternatively, the `type` argument can be a function, which will be invoked with `(editor, ...args)`. This is helpful in situations where you want write one-off queries with customized logic.
 
 ### `registerCommand`
 
-`registerCommand(command: String) => Void`
+`registerCommand(type: String) => Void`
 
-Register a new `command` by name with the editor. This will make the command available as a method on the editor's `Change` objects.
+```js
+editor.registerCommand('insertLink')
+```
+
+Add a new command by `type` with the editor. This will make the command available as a top-level method on the `editor`.
+
+> 🤖 Note that this method only registers the command with the editor, creating the top-level command method. It does not define the queries behaviors, which are defined with the `onCommand` middleware.
 
 ### `registerQuery`
 
-`registerQuery(query: String) => Void`
+`registerQuery(type: String) => Void`
 
-Register a new `query` by name with the editor. This will make the query available as a method on the editor's `Change` objects.
+```js
+editor.registerQuery('isLinkActive')
+```
+
+Add a new query by `type` with the editor. This will make the query available as a top-level method on the `editor`.
+
+> 🤖 Note that this method only registers the query with the editor, creating the top-level query method. It does not define the queries behaviors, which are defined with the `onQuery` middleware.
 
 ### `run`
 
 `run(key, ...args) => Any`
 
+```js
+editor.run('onKeyDown', { key: 'Tab', ... })
+```
+
 Run the middleware stack by `key` with `args`, returning its result.
 
+> 🤖 In normal operation you never need to use this method! However, it's useful for writing tests to be able to simulate plugin behaviors.
+
 ### `setReadOnly`
 
 `setReadOnly(readOnly: Boolean) => Editor`
 
+```js
+editor.setReadOnly(true)
+```
+
 Set the editor's `readOnly` state.
 
 ### `setValue`
 
 `setValue(value: Value, options: Object) => Editor`
 
+```js
+editor.setValue(value)
+```
+
 Set the editor's `value` state.
 
 You can optionally provide a `normalize` option to either for the editor to completely re-normalize the new value based on its schema or not. By default, the editor will re-normalize only if the value is not equal to its previously seen value (which it knows was normalized).
diff --git a/docs/reference/slate/operation.md b/docs/reference/slate/operation.md
index 0abcc55a5..925a4151a 100644
--- a/docs/reference/slate/operation.md
+++ b/docs/reference/slate/operation.md
@@ -2,7 +2,7 @@
 
 An operation is the lowest-level description of a specific change to a part of Slate's value. They are designed to be collaborative-editing friendly.
 
-All of the [`Change`](./change.md) methods result in operations being created and applied to a [`Value`](./value.md) They're accessible via the `change.operations` property.
+All of the [`Commands`](./commands.md) methods result in operations being created and applied to a [`Value`](./value.md) They're accessible via the `editor.operations` property.
 
 There are a handful of Slate operation types. The goal is to have the fewest possible types, while still maintaining the necessary semantics for collaborative editing to work.
 
diff --git a/docs/reference/slate/plugins.md b/docs/reference/slate/plugins.md
index 634724951..8bce44ed6 100644
--- a/docs/reference/slate/plugins.md
+++ b/docs/reference/slate/plugins.md
@@ -23,17 +23,17 @@ When a hook is triggered, the middleware function is passed a set of arguments,
 
 ### `normalizeNode`
 
-`Function normalizeNode(node: Node, next: Function) => Function(change: Change)|Void`
+`Function normalizeNode(node: Node, editor: Editor, next: Function) => Function(editor: Editor)|Void`
 
 The `normalizeNode` hook takes a `node` and either returns `undefined` if the node is valid, or a change function that normalizes the node into a valid state if not.
 
 ### `onChange`
 
-`onChange(change: Change, next: Function) => Void`
+`onChange(editor: Editor, next: Function) => Void`
 
 ```js
 {
-  onChange(change, next) {
+  onChange(editor, next) {
     ...
     return next()
   }
@@ -44,11 +44,11 @@ The `onChange` hook is called whenever a new change is about to be applied to an
 
 ### `onCommand`
 
-`onCommand(command: Object, change: Change, ) => Void`
+`onCommand(command: Object, editor: Editor, next: Function) => Void`
 
 ```js
 {
-  onCommand(command, change, next) {
+  onCommand(command, editor, next) {
     const { type, args } = command
 
     if (type === 'wrapQuote') {
@@ -90,11 +90,11 @@ The `onConstruct` hook is called when a new instance of `Editor` is created. Thi
 
 ### `onQuery`
 
-`onQuery(query: Object, next: Function) => Void`
+`onQuery(query: Object, editor: Editor, next: Function) => Void`
 
 ```js
 {
-  onQuery(query, next) {
+  onQuery(query, editor, next) {
     const { type, args } = query
 
     if (type === 'getActiveList') {
@@ -119,7 +119,7 @@ The `onQuery` hook is a low-level way to have access to all of the queries passi
 
 ### `validateNode`
 
-`Function validateNode(node: Node, next: Function) => SlateError|Void`
+`Function validateNode(node: Node, editor: Editor, next: Function) => SlateError|Void`
 
 The `validateNode` hook takes a `node` and either returns `undefined` if the node is valid, or a `SlateError` object if it is invalid.
 
@@ -142,16 +142,16 @@ In addition to the middleware functions, Slate also provides three shorthands wh
 ```js
 {
   commands: {
-    setHeader(change, level) {
-      change.setBlocks({ type: 'header', data: { level }})
+    setHeader(editor, level) {
+      editor.setBlocks({ type: 'header', data: { level }})
     }
   }
 }
 ```
 
-The `commands` shorthand defines a set of custom commands that are made available in the editor, and as first-class methods on the `change` objects created by the editor.
+The `commands` shorthand defines a set of custom commands that are made available in the editor, and as first-class methods on the `editor`.
 
-Each command has a signature of `(change, ...args)`.
+Each command has a signature of `(editor, ...args)`.
 
 ### `queries`
 
@@ -167,7 +167,7 @@ Each command has a signature of `(change, ...args)`.
 }
 ```
 
-The `queries` shorthand defines a set of custom queries that are made available in the editor, and as first-class methods on the `change` objects created by the editor.
+The `queries` shorthand defines a set of custom queries that are made available in the editor, and as first-class methods on the `editor`.
 
 Each query has a signature of `(editor, ...args)`.
 
diff --git a/docs/reference/slate/schema.md b/docs/reference/slate/schema.md
index 16fc04d65..7175bffd2 100644
--- a/docs/reference/slate/schema.md
+++ b/docs/reference/slate/schema.md
@@ -211,17 +211,17 @@ Will validate a node's marks. The `marks` definitions can declare the `type` pro
 
 ### `normalize`
 
-`normalize(change: Change, error: SlateError) => Void`
+`normalize(editor: Editor, error: SlateError) => Void`
 
 ```js
 {
-  normalize: (change, error) => {
+  normalize: (editor, error) => {
     switch (error.code) {
       case 'child_object_invalid':
-        change.wrapBlockByKey(error.child.key, 'paragraph')
+        editor.wrapBlockByKey(error.child.key, 'paragraph')
         return
       case 'child_type_invalid':
-        change.setNodeByKey(error.child.key, 'paragraph')
+        editor.setNodeByKey(error.child.key, 'paragraph')
         return
     }
   }
@@ -288,7 +288,7 @@ Will validate a node's text with a regex or function.
 
 ## Errors
 
-When supplying your own `normalize` property for a schema rule, it will be called with `(change, error)`. The error `code` will be one of a set of potential code strings, and it will contain additional helpful properties depending on the type of error.
+When supplying your own `normalize` property for a schema rule, it will be called with `(editor, error)`. The error `code` will be one of a set of potential code strings, and it will contain additional helpful properties depending on the type of error.
 
 ### `'child_object_invalid'`
 
diff --git a/docs/walkthroughs/adding-event-handlers.md b/docs/walkthroughs/adding-event-handlers.md
index 5106725e1..fb115d324 100644
--- a/docs/walkthroughs/adding-event-handlers.md
+++ b/docs/walkthroughs/adding-event-handlers.md
@@ -41,7 +41,7 @@ class App extends React.Component {
   }
 
   // Define a new handler which prints the key that was pressed.
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     console.log(event.key)
     return next()
   }
@@ -74,7 +74,7 @@ class App extends React.Component {
     this.setState({ value })
   }
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     // Return with no changes if the keypress is not '&'
     if (event.key !== '&') return next()
 
@@ -82,7 +82,7 @@ class App extends React.Component {
     event.preventDefault()
 
     // Change the value by inserting 'and' at the cursor's position.
-    change.insertText('and')
+    editor.insertText('and')
     return true
   }
 
@@ -100,7 +100,7 @@ class App extends React.Component {
 
 With that added, try typing `&`, and you should see it suddenly become `and` instead!
 
-This offers a sense of what can be done with Slate's event handlers. Each one will be called with the `event` object, and a `change` object that lets you perform changes to the editor's value. Simple!
+This offers a sense of what can be done with Slate's event handlers. Each one will be called with the `event` object, and the `editor` that lets you perform commands. Simple!
 
 <br/>
 <p align="center"><strong>Next:</strong><br/><a href="./defining-custom-block-nodes.md">Defining Custom Block Nodes</a></p>
diff --git a/docs/walkthroughs/applying-custom-formatting.md b/docs/walkthroughs/applying-custom-formatting.md
index 3f413b60e..5c492c211 100644
--- a/docs/walkthroughs/applying-custom-formatting.md
+++ b/docs/walkthroughs/applying-custom-formatting.md
@@ -20,12 +20,12 @@ class App extends React.Component {
     this.setState({ value })
   }
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     if (event.key != '`' || !event.ctrlKey) return next()
     event.preventDefault()
-    const isCode = change.value.blocks.some(block => block.type == 'code')
+    const isCode = editor.value.blocks.some(block => block.type == 'code')
 
-    change.setBlocks(isCode ? 'paragraph' : 'code')
+    editor.setBlocks(isCode ? 'paragraph' : 'code')
     return true
   }
 
@@ -40,7 +40,7 @@ class App extends React.Component {
     )
   }
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     switch (props.node.type) {
       case 'code':
         return <CodeNode {...props} />
@@ -63,7 +63,7 @@ class App extends React.Component {
     this.setState({ value })
   }
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     if (!event.ctrlKey) return next()
 
     // Decide what to do based on the key code...
@@ -71,15 +71,13 @@ class App extends React.Component {
       // When "B" is pressed, add a "bold" mark to the text.
       case 'b': {
         event.preventDefault()
-        change.addMark('bold')
-        return true
+        editor.addMark('bold')
       }
       // When "`" is pressed, keep our existing code block logic.
       case '`': {
-        const isCode = change.value.blocks.some(block => block.type == 'code')
+        const isCode = editor.value.blocks.some(block => block.type == 'code')
         event.preventDefault()
-        change.setBlocks(isCode ? 'paragraph' : 'code')
-        return true
+        editor.setBlocks(isCode ? 'paragraph' : 'code')
       }
       // Otherwise, let other plugins handle it.
       default: {
@@ -99,7 +97,7 @@ class App extends React.Component {
     )
   }
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     switch (props.node.type) {
       case 'code':
         return <CodeNode {...props} />
@@ -139,20 +137,18 @@ class App extends React.Component {
     this.setState({ value })
   }
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     if (!event.ctrlKey) return next()
 
     switch (event.key) {
       case 'b': {
         event.preventDefault()
-        change.toggleMark('bold')
-        return true
+        editor.toggleMark('bold')
       }
       case '`': {
-        const isCode = change.value.blocks.some(block => block.type == 'code')
+        const isCode = editor.value.blocks.some(block => block.type == 'code')
         event.preventDefault()
-        change.setBlocks(isCode ? 'paragraph' : 'code')
-        return true
+        editor.setBlocks(isCode ? 'paragraph' : 'code')
       }
       default: {
         return next()
@@ -173,7 +169,7 @@ class App extends React.Component {
     )
   }
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     switch (props.node.type) {
       case 'code':
         return <CodeNode {...props} />
@@ -183,7 +179,7 @@ class App extends React.Component {
   }
 
   // Add a `renderMark` method to render marks.
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     switch (props.mark.type) {
       case 'bold':
         return <BoldMark {...props} />
diff --git a/docs/walkthroughs/defining-custom-block-nodes.md b/docs/walkthroughs/defining-custom-block-nodes.md
index 936f64cf9..20a5148af 100644
--- a/docs/walkthroughs/defining-custom-block-nodes.md
+++ b/docs/walkthroughs/defining-custom-block-nodes.md
@@ -20,11 +20,10 @@ class App extends React.Component {
     this.setState({ value })
   }
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     if (event.key != '&') return next()
     event.preventDefault()
-    change.insertText('and')
-    return true
+    editor.insertText('and')
   }
 
   render() {
@@ -82,11 +81,10 @@ class App extends React.Component {
     this.setState({ value })
   }
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     if (event.key != '&') return next()
     event.preventDefault()
-    change.insertText('and')
-    return true
+    editor.insertText('and')
   }
 
   render() {
@@ -102,7 +100,7 @@ class App extends React.Component {
   }
 
   // Add a `renderNode` method to render a `CodeNode` for code blocks.
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     switch (props.node.type) {
       case 'code':
         return <CodeNode {...props} />
@@ -133,7 +131,7 @@ class App extends React.Component {
     this.setState({ value })
   }
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     // Return with no changes if it's not the "`" key with ctrl pressed.
     if (event.key != '`' || !event.ctrlKey) return next()
 
@@ -141,8 +139,7 @@ class App extends React.Component {
     event.preventDefault()
 
     // Otherwise, set the currently selected blocks type to "code".
-    change.setBlocks('code')
-    return true
+    editor.setBlocks('code')
   }
 
   render() {
@@ -156,7 +153,7 @@ class App extends React.Component {
     )
   }
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     switch (props.node.type) {
       case 'code':
         return <CodeNode {...props} />
@@ -191,17 +188,16 @@ class App extends React.Component {
     this.setState({ value })
   }
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     if (event.key != '`' || !event.ctrlKey) return next()
 
     event.preventDefault()
 
     // Determine whether any of the currently selected blocks are code blocks.
-    const isCode = change.value.blocks.some(block => block.type == 'code')
+    const isCode = editor.value.blocks.some(block => block.type == 'code')
 
     // Toggle the block type depending on `isCode`.
-    change.setBlocks(isCode ? 'paragraph' : 'code')
-    return true
+    editor.setBlocks(isCode ? 'paragraph' : 'code')
   }
 
   render() {
@@ -215,7 +211,7 @@ class App extends React.Component {
     )
   }
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     switch (props.node.type) {
       case 'code':
         return <CodeNode {...props} />
diff --git a/docs/walkthroughs/saving-and-loading-html-content.md b/docs/walkthroughs/saving-and-loading-html-content.md
index fba88efa5..7817469fd 100644
--- a/docs/walkthroughs/saving-and-loading-html-content.md
+++ b/docs/walkthroughs/saving-and-loading-html-content.md
@@ -264,7 +264,7 @@ class App extends React.Component {
     )
   }
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     switch (props.node.type) {
       case 'code':
         return (
@@ -286,7 +286,7 @@ class App extends React.Component {
   }
 
   // Add a `renderMark` method to render marks.
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     const { mark, attributes } = props
     switch (mark.type) {
       case 'bold':
diff --git a/docs/walkthroughs/using-plugins.md b/docs/walkthroughs/using-plugins.md
index 0837389aa..628aa00f9 100644
--- a/docs/walkthroughs/using-plugins.md
+++ b/docs/walkthroughs/using-plugins.md
@@ -22,11 +22,10 @@ class App extends React.Component {
     this.setState({ value })
   }
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     if (event.key != 'b' || !event.ctrlKey) return next()
     event.preventDefault()
-    change.toggleMark('bold')
-    return true
+    editor.toggleMark('bold')
   }
 
   render() {
@@ -40,7 +39,7 @@ class App extends React.Component {
     )
   }
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     switch (props.mark.type) {
       case 'bold':
         return <strong {...props.attributes}>{props.children}</strong>
@@ -72,7 +71,7 @@ function MarkHotkey(options) {
 
   // Return our "plugin" object, containing the `onKeyDown` handler.
   return {
-    onKeyDown(event, change, next) {
+    onKeyDown(event, editor, next) {
       // If it doesn't match our `key`, let other plugins handle it.
       if (!event.ctrlKey || event.key != key) return next()
 
@@ -80,8 +79,7 @@ function MarkHotkey(options) {
       event.preventDefault()
 
       // Toggle the mark `type`.
-      change.toggleMark(type)
-      return true
+      editor.toggleMark(type)
     },
   }
 }
@@ -122,7 +120,7 @@ class App extends React.Component {
     )
   }
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     switch (props.mark.type) {
       case 'bold':
         return <strong>{props.children}</strong>
@@ -167,7 +165,7 @@ class App extends React.Component {
     )
   }
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     switch (props.mark.type) {
       case 'bold':
         return <strong>{props.children}</strong>
diff --git a/examples/check-lists/index.js b/examples/check-lists/index.js
index c4cbd6355..4b79b42ca 100644
--- a/examples/check-lists/index.js
+++ b/examples/check-lists/index.js
@@ -51,7 +51,7 @@ class CheckListItem extends React.Component {
   onChange = event => {
     const checked = event.target.checked
     const { editor, node } = this.props
-    editor.change(c => c.setNodeByKey(node.key, { data: { checked } }))
+    editor.setNodeByKey(node.key, { data: { checked } })
   }
 
   /**
@@ -124,7 +124,7 @@ class CheckLists extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     switch (props.node.type) {
       case 'check-list-item':
         return <CheckListItem {...props} />
@@ -136,7 +136,7 @@ class CheckLists extends React.Component {
   /**
    * On change, save the new value.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -153,15 +153,15 @@ class CheckLists extends React.Component {
    * then turn it back into a paragraph.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  onKeyDown = (event, change, next) => {
-    const { value } = change
+  onKeyDown = (event, editor, next) => {
+    const { value } = editor
 
     if (event.key == 'Enter' && value.startBlock.type == 'check-list-item') {
-      change.splitBlock().setBlocks({ data: { checked: false } })
+      editor.splitBlock().setBlocks({ data: { checked: false } })
       return
     }
 
@@ -171,7 +171,7 @@ class CheckLists extends React.Component {
       value.startBlock.type == 'check-list-item' &&
       value.selection.startOffset == 0
     ) {
-      change.setBlocks('paragraph')
+      editor.setBlocks('paragraph')
       return
     }
 
diff --git a/examples/code-highlighting/index.js b/examples/code-highlighting/index.js
index 208637b05..9589e43f3 100644
--- a/examples/code-highlighting/index.js
+++ b/examples/code-highlighting/index.js
@@ -17,9 +17,7 @@ function CodeBlock(props) {
   const language = node.data.get('language')
 
   function onChange(event) {
-    editor.change(c =>
-      c.setNodeByKey(node.key, { data: { language: event.target.value } })
-    )
+    editor.setNodeByKey(node.key, { data: { language: event.target.value } })
   }
 
   return (
@@ -106,7 +104,7 @@ class CodeHighlighting extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     switch (props.node.type) {
       case 'code':
         return <CodeBlock {...props} />
@@ -124,7 +122,7 @@ class CodeHighlighting extends React.Component {
    * @return {Element}
    */
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     const { children, mark, attributes } = props
 
     switch (mark.type) {
@@ -160,7 +158,7 @@ class CodeHighlighting extends React.Component {
   /**
    * On change, save the new value.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -171,17 +169,16 @@ class CodeHighlighting extends React.Component {
    * On key down inside code blocks, insert soft new lines.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
-   * @return {Change}
    */
 
-  onKeyDown = (event, change, next) => {
-    const { value } = change
+  onKeyDown = (event, editor, next) => {
+    const { value } = editor
     const { startBlock } = value
 
     if (event.key === 'Enter' && startBlock.type === 'code') {
-      change.insertText('\n')
+      editor.insertText('\n')
       return
     }
 
@@ -195,7 +192,7 @@ class CodeHighlighting extends React.Component {
    * @return {Array}
    */
 
-  decorateNode = (node, next) => {
+  decorateNode = (node, editor, next) => {
     const others = next() || []
     if (node.type != 'code') return others
 
diff --git a/examples/embeds/index.js b/examples/embeds/index.js
index 7595bef28..e4c05d52c 100644
--- a/examples/embeds/index.js
+++ b/examples/embeds/index.js
@@ -62,7 +62,7 @@ class Embeds extends React.Component {
    * @param {Function} next
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     switch (props.node.type) {
       case 'video':
         return <Video {...props} />
@@ -74,7 +74,7 @@ class Embeds extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
diff --git a/examples/embeds/video.js b/examples/embeds/video.js
index c001938bc..8b4fa0f7d 100644
--- a/examples/embeds/video.js
+++ b/examples/embeds/video.js
@@ -16,7 +16,7 @@ class Video extends React.Component {
   onChange = e => {
     const video = e.target.value
     const { node, editor } = this.props
-    editor.change(c => c.setNodeByKey(node.key, { data: { video } }))
+    editor.setNodeByKey(node.key, { data: { video } })
   }
 
   /**
diff --git a/examples/emojis/index.js b/examples/emojis/index.js
index f7b5744cf..ccf2c9544 100644
--- a/examples/emojis/index.js
+++ b/examples/emojis/index.js
@@ -128,7 +128,7 @@ class Emojis extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     const { attributes, children, node, isFocused } = props
 
     switch (node.type) {
@@ -159,7 +159,7 @@ class Emojis extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -175,15 +175,10 @@ class Emojis extends React.Component {
   onClickEmoji = (e, code) => {
     e.preventDefault()
 
-    this.editor.change(change => {
-      change
-        .insertInline({
-          type: 'emoji',
-          data: { code },
-        })
-        .moveToStartOfNextText()
-        .focus()
-    })
+    this.editor
+      .insertInline({ type: 'emoji', data: { code } })
+      .moveToStartOfNextText()
+      .focus()
   }
 }
 
diff --git a/examples/forced-layout/index.js b/examples/forced-layout/index.js
index b47aad316..a75e6c065 100644
--- a/examples/forced-layout/index.js
+++ b/examples/forced-layout/index.js
@@ -16,15 +16,15 @@ const schema = {
       { match: { type: 'title' }, min: 1, max: 1 },
       { match: { type: 'paragraph' }, min: 1 },
     ],
-    normalize: (change, { code, node, child, index }) => {
+    normalize: (editor, { code, node, child, index }) => {
       switch (code) {
         case 'child_type_invalid': {
           const type = index === 0 ? 'title' : 'paragraph'
-          return change.setNodeByKey(child.key, type)
+          return editor.setNodeByKey(child.key, type)
         }
         case 'child_required': {
           const block = Block.create(index === 0 ? 'title' : 'paragraph')
-          return change.insertNodeByKey(node.key, index, block)
+          return editor.insertNodeByKey(node.key, index, block)
         }
       }
     },
@@ -75,7 +75,7 @@ class ForcedLayout extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     const { attributes, children, node } = props
 
     switch (node.type) {
@@ -91,7 +91,7 @@ class ForcedLayout extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
diff --git a/examples/history/index.js b/examples/history/index.js
index ae800b8b2..a041deead 100644
--- a/examples/history/index.js
+++ b/examples/history/index.js
@@ -68,7 +68,7 @@ class History extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -82,7 +82,7 @@ class History extends React.Component {
 
   onClickRedo = event => {
     event.preventDefault()
-    this.editor.change(change => change.redo())
+    this.editor.redo()
   }
 
   /**
@@ -92,7 +92,7 @@ class History extends React.Component {
 
   onClickUndo = event => {
     event.preventDefault()
-    this.editor.change(change => change.undo())
+    this.editor.undo()
   }
 }
 
diff --git a/examples/hovering-menu/index.js b/examples/hovering-menu/index.js
index aeca6ec57..ab6af014c 100644
--- a/examples/hovering-menu/index.js
+++ b/examples/hovering-menu/index.js
@@ -87,7 +87,7 @@ class HoverMenu extends React.Component {
   onClickMark(event, type) {
     const { editor } = this.props
     event.preventDefault()
-    editor.change(change => change.toggleMark(type))
+    editor.toggleMark(type)
   }
 }
 
@@ -176,8 +176,7 @@ class HoveringMenu extends React.Component {
    * @return {Element}
    */
 
-  renderEditor = (props, next) => {
-    const { editor } = props
+  renderEditor = (props, editor, next) => {
     const children = next()
     return (
       <React.Fragment>
@@ -196,7 +195,7 @@ class HoveringMenu extends React.Component {
    * @return {Element}
    */
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     const { children, mark, attributes } = props
 
     switch (mark.type) {
@@ -216,7 +215,7 @@ class HoveringMenu extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
diff --git a/examples/huge-document/index.js b/examples/huge-document/index.js
index 24acad1ae..95c349de0 100644
--- a/examples/huge-document/index.js
+++ b/examples/huge-document/index.js
@@ -78,7 +78,7 @@ class HugeDocument extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     const { attributes, children, node } = props
 
     switch (node.type) {
@@ -98,7 +98,7 @@ class HugeDocument extends React.Component {
    * @return {Element}
    */
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     const { children, mark, attributes } = props
 
     switch (mark.type) {
@@ -118,7 +118,7 @@ class HugeDocument extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
diff --git a/examples/images/index.js b/examples/images/index.js
index 4cd7a501e..333f47396 100644
--- a/examples/images/index.js
+++ b/examples/images/index.js
@@ -35,17 +35,17 @@ function isImage(url) {
 /**
  * A change function to standardize inserting images.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {String} src
  * @param {Range} target
  */
 
-function insertImage(change, src, target) {
+function insertImage(editor, src, target) {
   if (target) {
-    change.select(target)
+    editor.select(target)
   }
 
-  change.insertBlock({
+  editor.insertBlock({
     type: 'image',
     data: { src },
   })
@@ -60,11 +60,11 @@ function insertImage(change, src, target) {
 const schema = {
   document: {
     last: { type: 'paragraph' },
-    normalize: (change, { code, node, child }) => {
+    normalize: (editor, { code, node, child }) => {
       switch (code) {
         case 'last_child_type_invalid': {
           const paragraph = Block.create('paragraph')
-          return change.insertNodeByKey(node.key, node.nodes.size, paragraph)
+          return editor.insertNodeByKey(node.key, node.nodes.size, paragraph)
         }
       }
     },
@@ -138,7 +138,7 @@ class Images extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     const { attributes, node, isFocused } = props
 
     switch (node.type) {
@@ -156,7 +156,7 @@ class Images extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -173,19 +173,18 @@ class Images extends React.Component {
     event.preventDefault()
     const src = window.prompt('Enter the URL of the image:')
     if (!src) return
-    this.editor.change(insertImage, src)
+    this.editor.command(insertImage, src)
   }
 
   /**
    * On drop, insert the image wherever it is dropped.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  onDropOrPaste = (event, change, next) => {
-    const { editor } = change
+  onDropOrPaste = (event, editor, next) => {
     const target = getEventRange(event, editor)
     if (!target && event.type === 'drop') return next()
 
@@ -199,9 +198,7 @@ class Images extends React.Component {
         if (mime !== 'image') continue
 
         reader.addEventListener('load', () => {
-          editor.change(c => {
-            c.call(insertImage, reader.result, target)
-          })
+          editor.command(insertImage, reader.result, target)
         })
 
         reader.readAsDataURL(file)
@@ -212,7 +209,7 @@ class Images extends React.Component {
     if (type === 'text') {
       if (!isUrl(text)) return next()
       if (!isImage(text)) return next()
-      change.call(insertImage, text, target)
+      editor.command(insertImage, text, target)
       return
     }
 
diff --git a/examples/input-tester/index.js b/examples/input-tester/index.js
index 0248fe153..b7db8aa63 100644
--- a/examples/input-tester/index.js
+++ b/examples/input-tester/index.js
@@ -231,7 +231,7 @@ class InputTester extends React.Component {
     )
   }
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     const { attributes, children, node } = props
 
     switch (node.type) {
@@ -252,7 +252,7 @@ class InputTester extends React.Component {
     }
   }
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     const { attributes, children, mark } = props
 
     switch (mark.type) {
diff --git a/examples/links/index.js b/examples/links/index.js
index 596de29b1..50cdfb86f 100644
--- a/examples/links/index.js
+++ b/examples/links/index.js
@@ -9,27 +9,27 @@ import { Button, Icon, Toolbar } from '../components'
 /**
  * A change helper to standardize wrapping links.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {String} href
  */
 
-function wrapLink(change, href) {
-  change.wrapInline({
+function wrapLink(editor, href) {
+  editor.wrapInline({
     type: 'link',
     data: { href },
   })
 
-  change.moveToEnd()
+  editor.moveToEnd()
 }
 
 /**
  * A change helper to standardize unwrapping links.
  *
- * @param {Change} change
+ * @param {Editor} editor
  */
 
-function unwrapLink(change) {
-  change.unwrapInline('link')
+function unwrapLink(editor) {
+  editor.unwrapInline('link')
 }
 
 /**
@@ -105,7 +105,7 @@ class Links extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     const { attributes, children, node } = props
 
     switch (node.type) {
@@ -128,7 +128,7 @@ class Links extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -145,51 +145,50 @@ class Links extends React.Component {
   onClickLink = event => {
     event.preventDefault()
 
-    this.editor.change(change => {
-      const { value } = change
-      const hasLinks = this.hasLinks()
+    const { editor } = this
+    const { value } = editor
+    const hasLinks = this.hasLinks()
 
-      if (hasLinks) {
-        change.call(unwrapLink)
-      } else if (value.selection.isExpanded) {
-        const href = window.prompt('Enter the URL of the link:')
+    if (hasLinks) {
+      editor.command(unwrapLink)
+    } else if (value.selection.isExpanded) {
+      const href = window.prompt('Enter the URL of the link:')
 
-        if (href === null) {
-          return
-        }
-
-        change.call(wrapLink, href)
-      } else {
-        const href = window.prompt('Enter the URL of the link:')
-
-        if (href === null) {
-          return
-        }
-
-        const text = window.prompt('Enter the text for the link:')
-
-        if (text === null) {
-          return
-        }
-
-        change
-          .insertText(text)
-          .moveFocusBackward(text.length)
-          .call(wrapLink, href)
+      if (href === null) {
+        return
       }
-    })
+
+      editor.command(wrapLink, href)
+    } else {
+      const href = window.prompt('Enter the URL of the link:')
+
+      if (href === null) {
+        return
+      }
+
+      const text = window.prompt('Enter the text for the link:')
+
+      if (text === null) {
+        return
+      }
+
+      editor
+        .insertText(text)
+        .moveFocusBackward(text.length)
+        .command(wrapLink, href)
+    }
   }
 
   /**
    * On paste, if the text is a link, wrap the selection in a link.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  onPaste = (event, change, next) => {
-    if (change.value.selection.isCollapsed) return next()
+  onPaste = (event, editor, next) => {
+    if (editor.value.selection.isCollapsed) return next()
 
     const transfer = getEventTransfer(event)
     const { type, text } = transfer
@@ -197,10 +196,10 @@ class Links extends React.Component {
     if (!isUrl(text)) return next()
 
     if (this.hasLinks()) {
-      change.call(unwrapLink)
+      editor.command(unwrapLink)
     }
 
-    change.call(wrapLink, text)
+    editor.command(wrapLink, text)
   }
 }
 
diff --git a/examples/markdown-preview/index.js b/examples/markdown-preview/index.js
index b78785f58..295bcd0a9 100644
--- a/examples/markdown-preview/index.js
+++ b/examples/markdown-preview/index.js
@@ -58,7 +58,7 @@ class MarkdownPreview extends React.Component {
    * @return {Element}
    */
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     const { children, mark, attributes } = props
 
     switch (mark.type) {
@@ -137,7 +137,7 @@ class MarkdownPreview extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -152,7 +152,7 @@ class MarkdownPreview extends React.Component {
    * @return {Array}
    */
 
-  decorateNode(node, next) {
+  decorateNode(node, editor, next) {
     const others = next() || []
     if (node.object != 'block') return others
 
diff --git a/examples/markdown-shortcuts/index.js b/examples/markdown-shortcuts/index.js
index d5273de32..d435a8374 100644
--- a/examples/markdown-shortcuts/index.js
+++ b/examples/markdown-shortcuts/index.js
@@ -81,7 +81,7 @@ class MarkdownShortcuts extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     const { attributes, children, node } = props
 
     switch (node.type) {
@@ -111,7 +111,7 @@ class MarkdownShortcuts extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -122,18 +122,18 @@ class MarkdownShortcuts extends React.Component {
    * On key down, check for our specific key shortcuts.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     switch (event.key) {
       case ' ':
-        return this.onSpace(event, change, next)
+        return this.onSpace(event, editor, next)
       case 'Backspace':
-        return this.onBackspace(event, change, next)
+        return this.onBackspace(event, editor, next)
       case 'Enter':
-        return this.onEnter(event, change, next)
+        return this.onEnter(event, editor, next)
       default:
         return next()
     }
@@ -144,12 +144,12 @@ class MarkdownShortcuts extends React.Component {
    * node into the shortcut's corresponding type.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  onSpace = (event, change, next) => {
-    const { value } = change
+  onSpace = (event, editor, next) => {
+    const { value } = editor
     const { selection } = value
     if (selection.isExpanded) return next()
 
@@ -161,13 +161,13 @@ class MarkdownShortcuts extends React.Component {
     if (type == 'list-item' && startBlock.type == 'list-item') return next()
     event.preventDefault()
 
-    change.setBlocks(type)
+    editor.setBlocks(type)
 
     if (type == 'list-item') {
-      change.wrapBlock('bulleted-list')
+      editor.wrapBlock('bulleted-list')
     }
 
-    change.moveFocusToStartOfNode(startBlock).delete()
+    editor.moveFocusToStartOfNode(startBlock).delete()
   }
 
   /**
@@ -175,12 +175,12 @@ class MarkdownShortcuts extends React.Component {
    * paragraph node.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  onBackspace = (event, change, next) => {
-    const { value } = change
+  onBackspace = (event, editor, next) => {
+    const { value } = editor
     const { selection } = value
     if (selection.isExpanded) return next()
     if (selection.start.offset != 0) return next()
@@ -189,10 +189,10 @@ class MarkdownShortcuts extends React.Component {
     if (startBlock.type == 'paragraph') return next()
 
     event.preventDefault()
-    change.setBlocks('paragraph')
+    editor.setBlocks('paragraph')
 
     if (startBlock.type == 'list-item') {
-      change.unwrapBlock('bulleted-list')
+      editor.unwrapBlock('bulleted-list')
     }
   }
 
@@ -201,19 +201,19 @@ class MarkdownShortcuts extends React.Component {
    * create a new paragraph below it.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  onEnter = (event, change, next) => {
-    const { value } = change
+  onEnter = (event, editor, next) => {
+    const { value } = editor
     const { selection } = value
     const { start, end, isExpanded } = selection
     if (isExpanded) return next()
 
     const { startBlock } = value
     if (start.offset == 0 && startBlock.text.length == 0)
-      return this.onBackspace(event, change, next)
+      return this.onBackspace(event, editor, next)
     if (end.offset != startBlock.text.length) return next()
 
     if (
@@ -229,7 +229,7 @@ class MarkdownShortcuts extends React.Component {
     }
 
     event.preventDefault()
-    change.splitBlock().setBlocks('paragraph')
+    editor.splitBlock().setBlocks('paragraph')
   }
 }
 
diff --git a/examples/mentions/index.js b/examples/mentions/index.js
index fc4b02de4..6a2f045ab 100644
--- a/examples/mentions/index.js
+++ b/examples/mentions/index.js
@@ -131,7 +131,7 @@ class MentionsExample extends React.Component {
     )
   }
 
-  renderMark(props, next) {
+  renderMark(props, editor, next) {
     if (props.mark.type === CONTEXT_MARK_TYPE) {
       return (
         // Adding the className here is important so taht the `Suggestions`
@@ -145,7 +145,7 @@ class MentionsExample extends React.Component {
     return next()
   }
 
-  renderNode(props, next) {
+  renderNode(props, editor, next) {
     const { attributes, node } = props
 
     if (node.type === USER_MENTION_NODE_TYPE) {
@@ -205,7 +205,7 @@ class MentionsExample extends React.Component {
   /**
    * On change, save the new `value`.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = change => {
@@ -240,7 +240,7 @@ class MentionsExample extends React.Component {
         })
       }
 
-      return change.withoutSaving(() => change.setValue({ decorations }))
+      return change.withoutSaving(() => change.setDecorations(decorations))
     }
 
     this.setState({ value: change.value })
diff --git a/examples/paste-html/index.js b/examples/paste-html/index.js
index 004dd2ad6..cd89c76d9 100644
--- a/examples/paste-html/index.js
+++ b/examples/paste-html/index.js
@@ -203,7 +203,7 @@ class PasteHtml extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     const { attributes, children, node, isFocused } = props
 
     switch (node.type) {
@@ -260,7 +260,7 @@ class PasteHtml extends React.Component {
    * @return {Element}
    */
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     const { children, mark, attributes } = props
 
     switch (mark.type) {
@@ -280,7 +280,7 @@ class PasteHtml extends React.Component {
   /**
    * On change, save the new value.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -291,14 +291,14 @@ class PasteHtml extends React.Component {
    * On paste, deserialize the HTML and then insert the fragment.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
-  onPaste = (event, change, next) => {
+  onPaste = (event, editor, next) => {
     const transfer = getEventTransfer(event)
     if (transfer.type != 'html') return next()
     const { document } = serializer.deserialize(transfer.html)
-    change.insertFragment(document)
+    editor.insertFragment(document)
   }
 }
 
diff --git a/examples/plain-text/index.js b/examples/plain-text/index.js
index 916683b76..650c670ed 100644
--- a/examples/plain-text/index.js
+++ b/examples/plain-text/index.js
@@ -41,7 +41,7 @@ class PlainText extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
diff --git a/examples/plugins/collapse-on-escape.js b/examples/plugins/collapse-on-escape.js
index 46805d79e..e0d37425f 100644
--- a/examples/plugins/collapse-on-escape.js
+++ b/examples/plugins/collapse-on-escape.js
@@ -1,11 +1,11 @@
 export default function CollapseOnEscape(options = {}) {
   return {
-    onKeyDown(event, change, next) {
-      const { value } = change
+    onKeyDown(event, editor, next) {
+      const { value } = editor
       const { selection } = value
 
       if (event.key === 'Escape' && selection.isExpanded) {
-        change.moveToEnd()
+        editor.moveToEnd()
       } else {
         return next()
       }
diff --git a/examples/plugins/index.js b/examples/plugins/index.js
index 7915e658d..010d27220 100644
--- a/examples/plugins/index.js
+++ b/examples/plugins/index.js
@@ -52,7 +52,7 @@ The third is an example of using the plugin.render property to create a higher-o
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
diff --git a/examples/plugins/soft-break.js b/examples/plugins/soft-break.js
index 4c432c867..67b28d258 100644
--- a/examples/plugins/soft-break.js
+++ b/examples/plugins/soft-break.js
@@ -1,8 +1,8 @@
 export default function SoftBreak(options = {}) {
   return {
-    onKeyDown(event, change, next) {
+    onKeyDown(event, editor, next) {
       if (event.key === 'Enter') {
-        change.insertText('\n')
+        editor.insertText('\n')
       } else {
         next()
       }
diff --git a/examples/plugins/word-count.js b/examples/plugins/word-count.js
index 250d95c8e..72497515b 100644
--- a/examples/plugins/word-count.js
+++ b/examples/plugins/word-count.js
@@ -10,7 +10,7 @@ const WordCounter = styled('span')`
 
 export default function WordCount(options) {
   return {
-    renderEditor(props, next) {
+    renderEditor(props, editor, next) {
       const children = next()
       const wordCount = props.value.document
         .getBlocks()
diff --git a/examples/read-only/index.js b/examples/read-only/index.js
index 9f59d2f2b..732c6642a 100644
--- a/examples/read-only/index.js
+++ b/examples/read-only/index.js
@@ -42,7 +42,7 @@ class ReadOnly extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
diff --git a/examples/rich-text/index.js b/examples/rich-text/index.js
index c7f64ee10..c3db889c7 100644
--- a/examples/rich-text/index.js
+++ b/examples/rich-text/index.js
@@ -166,7 +166,7 @@ class RichTextExample extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     const { attributes, children, node } = props
 
     switch (node.type) {
@@ -194,7 +194,7 @@ class RichTextExample extends React.Component {
    * @return {Element}
    */
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     const { children, mark, attributes } = props
 
     switch (mark.type) {
@@ -214,7 +214,7 @@ class RichTextExample extends React.Component {
   /**
    * On change, save the new `value`.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -225,11 +225,11 @@ class RichTextExample extends React.Component {
    * On key down, if it's a formatting command toggle a mark.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @return {Change}
    */
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     let mark
 
     if (isBoldHotkey(event)) {
@@ -245,7 +245,7 @@ class RichTextExample extends React.Component {
     }
 
     event.preventDefault()
-    change.toggleMark(mark)
+    editor.toggleMark(mark)
   }
 
   /**
@@ -257,10 +257,7 @@ class RichTextExample extends React.Component {
 
   onClickMark = (event, type) => {
     event.preventDefault()
-
-    this.editor.change(change => {
-      change.toggleMark(type)
-    })
+    this.editor.toggleMark(type)
   }
 
   /**
@@ -273,46 +270,45 @@ class RichTextExample extends React.Component {
   onClickBlock = (event, type) => {
     event.preventDefault()
 
-    this.editor.change(change => {
-      const { value } = change
-      const { document } = value
+    const { editor } = this
+    const { value } = editor
+    const { document } = value
 
-      // Handle everything but list buttons.
-      if (type != 'bulleted-list' && type != 'numbered-list') {
-        const isActive = this.hasBlock(type)
-        const isList = this.hasBlock('list-item')
+    // Handle everything but list buttons.
+    if (type != 'bulleted-list' && type != 'numbered-list') {
+      const isActive = this.hasBlock(type)
+      const isList = this.hasBlock('list-item')
 
-        if (isList) {
-          change
-            .setBlocks(isActive ? DEFAULT_NODE : type)
-            .unwrapBlock('bulleted-list')
-            .unwrapBlock('numbered-list')
-        } else {
-          change.setBlocks(isActive ? DEFAULT_NODE : type)
-        }
+      if (isList) {
+        editor
+          .setBlocks(isActive ? DEFAULT_NODE : type)
+          .unwrapBlock('bulleted-list')
+          .unwrapBlock('numbered-list')
       } else {
-        // Handle the extra wrapping required for list buttons.
-        const isList = this.hasBlock('list-item')
-        const isType = value.blocks.some(block => {
-          return !!document.getClosest(block.key, parent => parent.type == type)
-        })
-
-        if (isList && isType) {
-          change
-            .setBlocks(DEFAULT_NODE)
-            .unwrapBlock('bulleted-list')
-            .unwrapBlock('numbered-list')
-        } else if (isList) {
-          change
-            .unwrapBlock(
-              type == 'bulleted-list' ? 'numbered-list' : 'bulleted-list'
-            )
-            .wrapBlock(type)
-        } else {
-          change.setBlocks('list-item').wrapBlock(type)
-        }
+        editor.setBlocks(isActive ? DEFAULT_NODE : type)
       }
-    })
+    } else {
+      // Handle the extra wrapping required for list buttons.
+      const isList = this.hasBlock('list-item')
+      const isType = value.blocks.some(block => {
+        return !!document.getClosest(block.key, parent => parent.type == type)
+      })
+
+      if (isList && isType) {
+        editor
+          .setBlocks(DEFAULT_NODE)
+          .unwrapBlock('bulleted-list')
+          .unwrapBlock('numbered-list')
+      } else if (isList) {
+        editor
+          .unwrapBlock(
+            type == 'bulleted-list' ? 'numbered-list' : 'bulleted-list'
+          )
+          .wrapBlock(type)
+      } else {
+        editor.setBlocks('list-item').wrapBlock(type)
+      }
+    }
   }
 }
 
diff --git a/examples/rtl/index.js b/examples/rtl/index.js
index ca21a83ae..e19d7ba6f 100644
--- a/examples/rtl/index.js
+++ b/examples/rtl/index.js
@@ -46,7 +46,7 @@ class RTL extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     const { attributes, children, node } = props
 
     switch (node.type) {
@@ -60,7 +60,7 @@ class RTL extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -71,13 +71,13 @@ class RTL extends React.Component {
    * On key down, if it's <shift-enter> add a soft break.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     if (event.key == 'Enter' && event.shiftKey) {
       event.preventDefault()
-      change.insertText('\n')
+      editor.insertText('\n')
       return
     }
 
diff --git a/examples/search-highlighting/index.js b/examples/search-highlighting/index.js
index dd43cfcdc..e00e98b13 100644
--- a/examples/search-highlighting/index.js
+++ b/examples/search-highlighting/index.js
@@ -108,7 +108,7 @@ class SearchHighlighting extends React.Component {
    * @return {Element}
    */
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     const { children, mark, attributes } = props
 
     switch (mark.type) {
@@ -126,7 +126,7 @@ class SearchHighlighting extends React.Component {
   /**
    * On change, save the new `value`.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -140,35 +140,34 @@ class SearchHighlighting extends React.Component {
    */
 
   onInputChange = event => {
-    this.editor.change(change => {
-      const { value } = change
-      const string = event.target.value
-      const texts = value.document.getTexts()
-      const decorations = []
+    const { editor } = this
+    const { value } = editor
+    const string = event.target.value
+    const texts = value.document.getTexts()
+    const decorations = []
 
-      texts.forEach(node => {
-        const { key, text } = node
-        const parts = text.split(string)
-        let offset = 0
+    texts.forEach(node => {
+      const { key, text } = node
+      const parts = text.split(string)
+      let offset = 0
 
-        parts.forEach((part, i) => {
-          if (i != 0) {
-            decorations.push({
-              anchor: { key, offset: offset - string.length },
-              focus: { key, offset },
-              mark: { type: 'highlight' },
-            })
-          }
+      parts.forEach((part, i) => {
+        if (i != 0) {
+          decorations.push({
+            anchor: { key, offset: offset - string.length },
+            focus: { key, offset },
+            mark: { type: 'highlight' },
+          })
+        }
 
-          offset = offset + part.length + string.length
-        })
+        offset = offset + part.length + string.length
       })
+    })
 
-      // Make the change to decorations without saving it into the undo history,
-      // so that there isn't a confusing behavior when undoing.
-      change.withoutSaving(() => {
-        change.setValue({ decorations })
-      })
+    // Make the change to decorations without saving it into the undo history,
+    // so that there isn't a confusing behavior when undoing.
+    editor.withoutSaving(() => {
+      editor.setDecorations(decorations)
     })
   }
 }
diff --git a/examples/syncing-operations/index.js b/examples/syncing-operations/index.js
index eafde0f58..1dc7023d9 100644
--- a/examples/syncing-operations/index.js
+++ b/examples/syncing-operations/index.js
@@ -56,7 +56,7 @@ class SyncingEditor extends React.Component {
 
   applyOperations = operations => {
     this.remote = true
-    this.editor.change(change => change.applyOperations(operations))
+    operations.forEach(o => this.editor.applyOperation(o))
     this.remote = false
   }
 
@@ -136,7 +136,7 @@ class SyncingEditor extends React.Component {
    * @return {Element}
    */
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     const { children, mark, attributes } = props
 
     switch (mark.type) {
@@ -157,7 +157,7 @@ class SyncingEditor extends React.Component {
    * On change, save the new `value`. And if it's a local change, call the
    * passed-in `onChange` handler.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Object} options
    */
 
@@ -173,11 +173,11 @@ class SyncingEditor extends React.Component {
    * On key down, if it's a formatting command toggle a mark.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @return {Change}
    */
 
-  onKeyDown = (event, change, next) => {
+  onKeyDown = (event, editor, next) => {
     let mark
 
     if (isBoldHotkey(event)) {
@@ -193,7 +193,7 @@ class SyncingEditor extends React.Component {
     }
 
     event.preventDefault()
-    change.toggleMark(mark)
+    editor.toggleMark(mark)
   }
 
   /**
@@ -205,7 +205,7 @@ class SyncingEditor extends React.Component {
 
   onClickMark = (event, type) => {
     event.preventDefault()
-    this.editor.change(change => change.toggleMark(type))
+    this.editor.toggleMark(type)
   }
 }
 
@@ -250,7 +250,7 @@ class SyncingOperationsExample extends React.Component {
       .toJS()
 
     setTimeout(() => {
-      this.two.applyOperations(ops)
+      ops.forEach(o => this.two.applyOperation(o))
     })
   }
 
@@ -266,7 +266,7 @@ class SyncingOperationsExample extends React.Component {
       .toJS()
 
     setTimeout(() => {
-      this.one.applyOperations(ops)
+      ops.forEach(o => this.one.applyOperation(o))
     })
   }
 }
diff --git a/examples/syncing-operations/value.json b/examples/syncing-operations/value.json
index bf57ba79d..080e255d2 100644
--- a/examples/syncing-operations/value.json
+++ b/examples/syncing-operations/value.json
@@ -38,7 +38,7 @@
                   "They achieve this by sending any document-altering operations to each other whenever a change occurs, and then applying them locally with "
               },
               {
-                "text": "change.applyOperations()",
+                "text": "editor.applyOperation()",
                 "marks": [
                   {
                     "type": "code"
diff --git a/examples/tables/index.js b/examples/tables/index.js
index 93dce9682..45ab68549 100644
--- a/examples/tables/index.js
+++ b/examples/tables/index.js
@@ -50,7 +50,7 @@ class Tables extends React.Component {
    * @return {Element}
    */
 
-  renderNode = (props, next) => {
+  renderNode = (props, editor, next) => {
     const { attributes, children, node } = props
 
     switch (node.type) {
@@ -76,7 +76,7 @@ class Tables extends React.Component {
    * @return {Element}
    */
 
-  renderMark = (props, next) => {
+  renderMark = (props, editor, next) => {
     const { children, mark, attributes } = props
 
     switch (mark.type) {
@@ -91,11 +91,11 @@ class Tables extends React.Component {
    * On backspace, do nothing if at the start of a table cell.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
-  onBackspace = (event, change, next) => {
-    const { value } = change
+  onBackspace = (event, editor, next) => {
+    const { value } = editor
     const { selection } = value
     if (selection.start.offset != 0) return next()
     event.preventDefault()
@@ -104,7 +104,7 @@ class Tables extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -115,11 +115,11 @@ class Tables extends React.Component {
    * On delete, do nothing if at the end of a table cell.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
-  onDelete = (event, change, next) => {
-    const { value } = change
+  onDelete = (event, editor, next) => {
+    const { value } = editor
     const { selection } = value
     if (selection.end.offset != value.startText.text.length) return next()
     event.preventDefault()
@@ -129,12 +129,12 @@ class Tables extends React.Component {
    * On paste or drop, only support plain text for this example.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
-  onDropOrPaste = (event, change, next) => {
+  onDropOrPaste = (event, editor, next) => {
     const transfer = getEventTransfer(event)
-    const { value } = change
+    const { value } = editor
     const { text = '' } = transfer
 
     if (value.startBlock.type !== 'table-cell') {
@@ -147,17 +147,17 @@ class Tables extends React.Component {
 
     const lines = text.split('\n')
     const { document } = Plain.deserialize(lines[0] || '')
-    change.insertFragment(document)
+    editor.insertFragment(document)
   }
 
   /**
    * On return, do nothing if inside a table cell.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
-  onEnter = (event, change, next) => {
+  onEnter = (event, editor, next) => {
     event.preventDefault()
   }
 
@@ -165,11 +165,11 @@ class Tables extends React.Component {
    * On key down, check for our specific key shortcuts.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
-  onKeyDown = (event, change, next) => {
-    const { value } = change
+  onKeyDown = (event, editor, next) => {
+    const { value } = editor
     const { document, selection } = value
     const { start, isCollapsed } = selection
     const startNode = document.getDescendant(start.key)
@@ -193,11 +193,11 @@ class Tables extends React.Component {
 
     switch (event.key) {
       case 'Backspace':
-        return this.onBackspace(event, change, next)
+        return this.onBackspace(event, editor, next)
       case 'Delete':
-        return this.onDelete(event, change, next)
+        return this.onDelete(event, editor, next)
       case 'Enter':
-        return this.onEnter(event, change, next)
+        return this.onEnter(event, editor, next)
       default:
         return next()
     }
diff --git a/examples/versions/index.js b/examples/versions/index.js
index 7efbcad60..aae492326 100644
--- a/examples/versions/index.js
+++ b/examples/versions/index.js
@@ -13,13 +13,13 @@ import { Button, Icon, Toolbar } from '../components'
  */
 
 const commands = {
-  resetHistory(change) {
-    const { value } = change
+  resetHistory(editor) {
+    const { value } = editor
     const { data } = value
     const newData = data.set('undos', List()).set('redos', List())
 
-    change.withoutSaving(() => {
-      change.setValue({ data: newData })
+    editor.withoutSaving(() => {
+      editor.setData(newData)
     })
   },
 }
@@ -103,7 +103,7 @@ class Versions extends React.Component {
   /**
    * On change.
    *
-   * @param {Change} change
+   * @param {Editor} editor
    */
 
   onChange = ({ value }) => {
@@ -129,32 +129,31 @@ class Versions extends React.Component {
    */
 
   setVersion = n => {
+    const { editor } = this
     const { versions, v } = this.state
     const isForward = n > v
     if (n === v) return
 
-    this.editor.change(change => {
-      let operations
+    let operations
 
-      if (isForward) {
-        operations = versions
-          .slice(v + 1, n + 1)
-          .map(vers => vers.operations)
-          .flat()
-      } else {
-        operations = versions
-          .slice(n + 1, v + 1)
-          .map(vers => vers.operations)
-          .flat()
-          .reverse()
-          .map(op => op.invert())
-      }
+    if (isForward) {
+      operations = versions
+        .slice(v + 1, n + 1)
+        .map(vers => vers.operations)
+        .flat()
+    } else {
+      operations = versions
+        .slice(n + 1, v + 1)
+        .map(vers => vers.operations)
+        .flat()
+        .reverse()
+        .map(op => op.invert())
+    }
 
-      change.withoutNormalizing(() => {
-        change.withoutSaving(() => {
-          change.applyOperations(operations)
-          change.resetHistory()
-        })
+    editor.withoutNormalizing(() => {
+      editor.withoutSaving(() => {
+        operations.forEach(op => editor.applyOperation(op))
+        editor.resetHistory()
       })
     })
 
@@ -190,9 +189,7 @@ class Versions extends React.Component {
         }
       },
       () => {
-        this.editor.change(change => {
-          change.resetHistory()
-        })
+        this.editor.resetHistory()
       }
     )
   }
diff --git a/packages/slate-react/Changelog.md b/packages/slate-react/Changelog.md
index a0e7c60e2..e6e7a2a97 100644
--- a/packages/slate-react/Changelog.md
+++ b/packages/slate-react/Changelog.md
@@ -14,13 +14,13 @@ This document maintains a list of changes to the `slate-react` package with each
 
 ```js
 // Previously, you'd return `undefined` to continue.
-function onKeyDown(event, change, editor) {
+function onKeyDown(event, editor, next) {
   if (event.key !== 'Enter') return
   ...
 }
 
 // Now, you call `next()` to continue...
-function onKeyDown(event, change, next) {
+function onKeyDown(event, editor, next) {
   if (event.key !== 'Enter') return next()
   ...
 }
@@ -29,7 +29,7 @@ function onKeyDown(event, change, next) {
 While that may seem inconvenient, it opens up an entire new behavior, which is deferring to the plugins later in the stack to see if they "handle" a specific case, and if not, handling it yourself:
 
 ```js
-function onKeyDown(event, change, next) {
+function onKeyDown(event, editor, next) {
   if (event.key === 'Enter') {
     const handled = next()
     if (handled) return handled
@@ -45,7 +45,7 @@ Under the covers, the `schema`, `commands` and `queries` concept are all impleme
 
 ```js
 const plugin = {
-  onCommand(command, change, next) {
+  onCommand(command, editor, next) {
     ...
   }
 }
@@ -62,7 +62,7 @@ This allows you to actually listen in to all commands, and override individual b
 **The `editor` object is no longer passed to event handlers.** Previously, the third argument to event handlers would be the React `editor` instance. However, now that `Change` objects contain a direct reference to the editor, you can access this on `change.editor` instead.
 
 ```js
-function onKeyDown(event, change, next) {
+function onKeyDown(event, editor, next) {
   const { editor } = change
   ...
 }
@@ -206,7 +206,7 @@ In its place is the new `next` argument, which allows you to choose to defer to
 
 ###### BREAKING
 
-**The `data` argument to event handlers has been removed.** Previously event handlers had a signature of `(event, data, change, editor)`, but now they have a signature of just `(event, change, editor)`. This leads to simpler internal Slate logic, and less complex relationship dependencies between plugins. All of the information inside the old `data` argument can be accessed via the similar properties on the `event` argument, or via the `getEventRange`, `getEventTransfer` and `setEventTransfer` helpers.
+**The `data` argument to event handlers has been removed.** Previously event handlers had a signature of `(event, data, change, editor)`, but now they have a signature of just `(event, editor, next)`. This leads to simpler internal Slate logic, and less complex relationship dependencies between plugins. All of the information inside the old `data` argument can be accessed via the similar properties on the `event` argument, or via the `getEventRange`, `getEventTransfer` and `setEventTransfer` helpers.
 
 ###### NEW
 
diff --git a/packages/slate-react/src/components/editor.js b/packages/slate-react/src/components/editor.js
index 2d487b0c9..717f9fb52 100644
--- a/packages/slate-react/src/components/editor.js
+++ b/packages/slate-react/src/components/editor.js
@@ -99,7 +99,7 @@ class Editor extends React.Component {
     this.tmp.updates++
 
     if (this.props.autoFocus) {
-      this.change(c => c.focus())
+      this.focus()
     }
 
     if (this.tmp.change) {
@@ -121,20 +121,6 @@ class Editor extends React.Component {
     }
   }
 
-  /**
-   * On controller change, call `onChange` or queue the change for flushing.
-   *
-   * @param {Change} change
-   */
-
-  onControllerChange = change => {
-    if (this.tmp.mounted) {
-      this.props.onChange(change)
-    } else {
-      this.tmp.change = change
-    }
-  }
-
   /**
    * Render the editor.
    *
@@ -181,8 +167,21 @@ class Editor extends React.Component {
 
     this.tmp.resolves++
     const react = ReactPlugin(this.props)
-    const attrs = { onChange: this.onControllerChange, plugins: [react] }
-    this.controller = new Controller(attrs, { editor: this, normalize: false })
+
+    const onChange = change => {
+      if (this.tmp.mounted) {
+        this.props.onChange(change)
+      } else {
+        this.tmp.change = change
+      }
+    }
+
+    this.controller = new Controller(
+      { plugins: [react], onChange },
+      { controller: this, construct: false }
+    )
+
+    this.controller.run('onConstruct')
   })
 
   /**
@@ -190,6 +189,10 @@ class Editor extends React.Component {
    * can be passed in its place to plugins.
    */
 
+  get operations() {
+    return this.controller.operations
+  }
+
   get readOnly() {
     return this.controller.readOnly
   }
@@ -198,59 +201,91 @@ class Editor extends React.Component {
     return this.controller.value
   }
 
-  change = (...args) => {
-    return this.controller.change(...args)
+  applyOperation(...args) {
+    return this.controller.applyOperation(...args)
   }
 
-  command = (...args) => {
+  command(...args) {
     return this.controller.command(...args)
   }
 
-  event = (...args) => {
-    return this.controller.event(...args)
+  normalize(...args) {
+    return this.controller.normalize(...args)
   }
 
-  onChange = (...args) => {
-    return this.controller.onChange(...args)
-  }
-
-  query = (...args) => {
+  query(...args) {
     return this.controller.query(...args)
   }
 
-  run = (...args) => {
+  registerCommand(...args) {
+    return this.controller.registerCommand(...args)
+  }
+
+  registerQuery(...args) {
+    return this.controller.registerQuery(...args)
+  }
+
+  run(...args) {
     return this.controller.run(...args)
   }
 
-  /**
-   * Mimic the API of a DOM input/textarea, to maintain a React-like interface.
-   */
-
-  blur = () => {
-    this.change(c => c.blur())
-  }
-
-  focus = () => {
-    this.change(c => c.focus())
+  withoutNormalizing(...args) {
+    return this.controller.withoutNormalizing(...args)
   }
 
   /**
    * Deprecated.
    */
 
+  get editor() {
+    return this.controller.editor
+  }
+
   get schema() {
     invariant(
       false,
-      'As of Slate 0.42.0, the `editor.schema` property no longer exists, and its functionality has been folded into the editor itself. Use the `editor` instead.'
+      'As of Slate 0.42, the `editor.schema` property no longer exists, and its functionality has been folded into the editor itself. Use the `editor` instead.'
     )
   }
 
   get stack() {
     invariant(
       false,
-      'As of Slate 0.42.0, the `editor.stack` property no longer exists, and its functionality has been folded into the editor itself. Use the `editor` instead.'
+      'As of Slate 0.42, the `editor.stack` property no longer exists, and its functionality has been folded into the editor itself. Use the `editor` instead.'
     )
   }
+
+  call(...args) {
+    return this.controller.call(...args)
+  }
+
+  change(...args) {
+    return this.controller.change(...args)
+  }
+
+  onChange(...args) {
+    return this.controller.onChange(...args)
+  }
+
+  applyOperations(...args) {
+    return this.controller.applyOperations(...args)
+  }
+
+  setOperationFlag(...args) {
+    return this.controller.setOperationFlag(...args)
+  }
+
+  getFlag(...args) {
+    return this.controller.getFlag(...args)
+  }
+
+  unsetOperationFlag(...args) {
+    return this.controller.unsetOperationFlag(...args)
+  }
+
+  withoutNormalization(...args) {
+    return this.controller.withoutNormalization(...args)
+  }
 }
 
 /**
diff --git a/packages/slate-react/src/plugins/after.js b/packages/slate-react/src/plugins/after.js
index fe9bc1e66..1508905a3 100644
--- a/packages/slate-react/src/plugins/after.js
+++ b/packages/slate-react/src/plugins/after.js
@@ -36,12 +36,12 @@ function AfterPlugin(options = {}) {
    * On before input.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onBeforeInput(event, change, next) {
-    const { editor, value } = change
+  function onBeforeInput(event, editor, next) {
+    const { value } = editor
     const isSynthetic = !!event.nativeEvent
 
     // If the event is synthetic, it's React's polyfill of `beforeinput` that
@@ -49,7 +49,7 @@ function AfterPlugin(options = {}) {
     // gets triggered for character insertions, so we can just insert directly.
     if (isSynthetic) {
       event.preventDefault()
-      change.insertText(event.data)
+      editor.insertText(event.data)
       return next()
     }
 
@@ -71,29 +71,29 @@ function AfterPlugin(options = {}) {
       case 'deleteContent':
       case 'deleteContentBackward':
       case 'deleteContentForward': {
-        change.deleteAtRange(range)
+        editor.deleteAtRange(range)
         break
       }
 
       case 'deleteWordBackward': {
-        change.deleteWordBackwardAtRange(range)
+        editor.deleteWordBackwardAtRange(range)
         break
       }
 
       case 'deleteWordForward': {
-        change.deleteWordForwardAtRange(range)
+        editor.deleteWordForwardAtRange(range)
         break
       }
 
       case 'deleteSoftLineBackward':
       case 'deleteHardLineBackward': {
-        change.deleteLineBackwardAtRange(range)
+        editor.deleteLineBackwardAtRange(range)
         break
       }
 
       case 'deleteSoftLineForward':
       case 'deleteHardLineForward': {
-        change.deleteLineForwardAtRange(range)
+        editor.deleteLineForwardAtRange(range)
         break
       }
 
@@ -105,9 +105,9 @@ function AfterPlugin(options = {}) {
         )
 
         if (hasVoidParent) {
-          change.moveToStartOfNextText()
+          editor.moveToStartOfNextText()
         } else {
-          change.splitBlockAtRange(range)
+          editor.splitBlockAtRange(range)
         }
 
         break
@@ -127,12 +127,12 @@ function AfterPlugin(options = {}) {
 
         if (text == null) break
 
-        change.insertTextAtRange(range, text, selection.marks)
+        editor.insertTextAtRange(range, text, selection.marks)
 
         // If the text was successfully inserted, and the selection had marks
         // on it, unset the selection's marks.
-        if (selection.marks && value.document != change.value.document) {
-          change.select({ marks: null })
+        if (selection.marks && value.document != editor.value.document) {
+          editor.select({ marks: null })
         }
 
         break
@@ -146,13 +146,13 @@ function AfterPlugin(options = {}) {
    * On blur.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onBlur(event, change, next) {
+  function onBlur(event, editor, next) {
     debug('onBlur', { event })
-    change.blur()
+    editor.blur()
     next()
   }
 
@@ -160,12 +160,11 @@ function AfterPlugin(options = {}) {
    * On click.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onClick(event, change, next) {
-    const { editor } = change
+  function onClick(event, editor, next) {
     if (editor.readOnly) return next()
 
     const { value } = editor
@@ -177,14 +176,14 @@ function AfterPlugin(options = {}) {
 
     const ancestors = document.getAncestors(node.key)
     const isVoid =
-      node && (change.isVoid(node) || ancestors.some(a => change.isVoid(a)))
+      node && (editor.isVoid(node) || ancestors.some(a => editor.isVoid(a)))
 
     if (isVoid) {
       // COMPAT: In Chrome & Safari, selections that are at the zero offset of
       // an inline node will be automatically replaced to be at the last offset
       // of a previous inline node, which screws us up, so we always want to set
       // it to the end of the node. (2016/11/29)
-      change.focus().moveToEndOfNode(node)
+      editor.focus().moveToEndOfNode(node)
     }
 
     next()
@@ -194,13 +193,12 @@ function AfterPlugin(options = {}) {
    * On copy.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onCopy(event, change, next) {
+  function onCopy(event, editor, next) {
     debug('onCopy', { event })
-    const { editor } = change
     cloneFragment(event, editor)
     next()
   }
@@ -209,31 +207,30 @@ function AfterPlugin(options = {}) {
    * On cut.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onCut(event, change, next) {
+  function onCut(event, editor, next) {
     debug('onCut', { event })
-    const { editor } = change
 
     // Once the fake cut content has successfully been added to the clipboard,
     // delete the content in the current selection.
     cloneFragment(event, editor, () => {
       // If user cuts a void block node or a void inline node,
       // manually removes it since selection is collapsed in this case.
-      const { value } = change
+      const { value } = editor
       const { endBlock, endInline, selection } = value
       const { isCollapsed } = selection
-      const isVoidBlock = endBlock && change.isVoid(endBlock) && isCollapsed
-      const isVoidInline = endInline && change.isVoid(endInline) && isCollapsed
+      const isVoidBlock = endBlock && editor.isVoid(endBlock) && isCollapsed
+      const isVoidInline = endInline && editor.isVoid(endInline) && isCollapsed
 
       if (isVoidBlock) {
-        editor.change(c => c.removeNodeByKey(endBlock.key))
+        editor.editor(c => c.removeNodeByKey(endBlock.key))
       } else if (isVoidInline) {
-        editor.change(c => c.removeNodeByKey(endInline.key))
+        editor.editor(c => c.removeNodeByKey(endInline.key))
       } else {
-        editor.change(c => c.delete())
+        editor.editor(c => c.delete())
       }
     })
 
@@ -244,11 +241,11 @@ function AfterPlugin(options = {}) {
    * On drag end.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onDragEnd(event, change, next) {
+  function onDragEnd(event, editor, next) {
     debug('onDragEnd', { event })
     isDraggingInternally = null
     next()
@@ -258,32 +255,31 @@ function AfterPlugin(options = {}) {
    * On drag start.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onDragStart(event, change, next) {
+  function onDragStart(event, editor, next) {
     debug('onDragStart', { event })
 
     isDraggingInternally = true
 
-    const { editor } = change
     const { value } = editor
     const { document } = value
     const node = findNode(event.target, editor)
     const ancestors = document.getAncestors(node.key)
     const isVoid =
-      node && (change.isVoid(node) || ancestors.some(a => change.isVoid(a)))
+      node && (editor.isVoid(node) || ancestors.some(a => editor.isVoid(a)))
     const selectionIncludesNode = value.blocks.some(
       block => block.key === node.key
     )
 
     // If a void block is dragged and is not selected, select it (necessary for local drags).
     if (isVoid && !selectionIncludesNode) {
-      change.moveToRangeOfNode(node)
+      editor.moveToRangeOfNode(node)
     }
 
-    const fragment = change.value.fragment
+    const fragment = editor.value.fragment
     const encoded = Base64.serializeNode(fragment)
     setEventTransfer(event, 'fragment', encoded)
     next()
@@ -293,12 +289,12 @@ function AfterPlugin(options = {}) {
    * On drop.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onDrop(event, change, next) {
-    const { editor, value } = change
+  function onDrop(event, editor, next) {
+    const { value } = editor
     const { document, selection } = value
     const window = getWindow(event.target)
     let target = getEventRange(event, editor)
@@ -309,7 +305,7 @@ function AfterPlugin(options = {}) {
     const transfer = getEventTransfer(event)
     const { type, fragment, text } = transfer
 
-    change.focus()
+    editor.focus()
 
     // If the drag is internal and the target is after the selection, it
     // needs to account for the selection's content being deleted.
@@ -326,10 +322,10 @@ function AfterPlugin(options = {}) {
     }
 
     if (isDraggingInternally) {
-      change.delete()
+      editor.delete()
     }
 
-    change.select(target)
+    editor.select(target)
 
     if (type == 'text' || type == 'html') {
       const { anchor } = target
@@ -344,19 +340,19 @@ function AfterPlugin(options = {}) {
           hasVoidParent = document.hasVoidParent(n.key, editor)
         }
 
-        if (n) change.moveToStartOfNode(n)
+        if (n) editor.moveToStartOfNode(n)
       }
 
       if (text) {
         text.split('\n').forEach((line, i) => {
-          if (i > 0) change.splitBlock()
-          change.insertText(line)
+          if (i > 0) editor.splitBlock()
+          editor.insertText(line)
         })
       }
     }
 
     if (type == 'fragment') {
-      change.insertFragment(fragment)
+      editor.insertFragment(fragment)
     }
 
     // COMPAT: React's onSelect event breaks after an onDrop event
@@ -383,13 +379,13 @@ function AfterPlugin(options = {}) {
    * On input.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onInput(event, change, next) {
+  function onInput(event, editor, next) {
     const window = getWindow(event.target)
-    const { editor, value } = change
+    const { value } = editor
 
     // Get the selection point.
     const native = window.getSelection()
@@ -443,7 +439,7 @@ function AfterPlugin(options = {}) {
     entire = document.resolveRange(entire)
 
     // Change the current value to have the leaf's text replaced.
-    change.insertTextAtRange(entire, textContent, leaf.marks).select(corrected)
+    editor.insertTextAtRange(entire, textContent, leaf.marks).select(corrected)
     next()
   }
 
@@ -451,14 +447,14 @@ function AfterPlugin(options = {}) {
    * On key down.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onKeyDown(event, change, next) {
+  function onKeyDown(event, editor, next) {
     debug('onKeyDown', { event })
 
-    const { editor, value } = change
+    const { value } = editor
     const { document, selection } = value
     const hasVoidParent = document.hasVoidParent(selection.start.path, editor)
 
@@ -467,40 +463,40 @@ function AfterPlugin(options = {}) {
     // preserve native autocorrect behavior, so they shouldn't be handled here.
     if (Hotkeys.isSplitBlock(event) && !IS_IOS) {
       return hasVoidParent
-        ? change.moveToStartOfNextText()
-        : change.splitBlock()
+        ? editor.moveToStartOfNextText()
+        : editor.splitBlock()
     }
 
     if (Hotkeys.isDeleteBackward(event) && !IS_IOS) {
-      return change.deleteCharBackward()
+      return editor.deleteCharBackward()
     }
 
     if (Hotkeys.isDeleteForward(event) && !IS_IOS) {
-      return change.deleteCharForward()
+      return editor.deleteCharForward()
     }
 
     if (Hotkeys.isDeleteLineBackward(event)) {
-      return change.deleteLineBackward()
+      return editor.deleteLineBackward()
     }
 
     if (Hotkeys.isDeleteLineForward(event)) {
-      return change.deleteLineForward()
+      return editor.deleteLineForward()
     }
 
     if (Hotkeys.isDeleteWordBackward(event)) {
-      return change.deleteWordBackward()
+      return editor.deleteWordBackward()
     }
 
     if (Hotkeys.isDeleteWordForward(event)) {
-      return change.deleteWordForward()
+      return editor.deleteWordForward()
     }
 
     if (Hotkeys.isRedo(event)) {
-      return change.redo()
+      return editor.redo()
     }
 
     if (Hotkeys.isUndo(event)) {
-      return change.undo()
+      return editor.undo()
     }
 
     // COMPAT: Certain browsers don't handle the selection updates properly. In
@@ -508,22 +504,22 @@ function AfterPlugin(options = {}) {
     // selection isn't properly collapsed. (2017/10/17)
     if (Hotkeys.isMoveLineBackward(event)) {
       event.preventDefault()
-      return change.moveToStartOfBlock()
+      return editor.moveToStartOfBlock()
     }
 
     if (Hotkeys.isMoveLineForward(event)) {
       event.preventDefault()
-      return change.moveToEndOfBlock()
+      return editor.moveToEndOfBlock()
     }
 
     if (Hotkeys.isExtendLineBackward(event)) {
       event.preventDefault()
-      return change.moveFocusToStartOfBlock()
+      return editor.moveFocusToStartOfBlock()
     }
 
     if (Hotkeys.isExtendLineForward(event)) {
       event.preventDefault()
-      return change.moveFocusToEndOfBlock()
+      return editor.moveFocusToEndOfBlock()
     }
 
     // COMPAT: If a void node is selected, or a zero-width text node adjacent to
@@ -533,30 +529,30 @@ function AfterPlugin(options = {}) {
       event.preventDefault()
 
       if (!selection.isCollapsed) {
-        return change.moveToStart()
+        return editor.moveToStart()
       }
 
-      return change.moveBackward()
+      return editor.moveBackward()
     }
 
     if (Hotkeys.isMoveForward(event)) {
       event.preventDefault()
 
       if (!selection.isCollapsed) {
-        return change.moveToEnd()
+        return editor.moveToEnd()
       }
 
-      return change.moveForward()
+      return editor.moveForward()
     }
 
     if (Hotkeys.isMoveWordBackward(event)) {
       event.preventDefault()
-      return change.moveWordBackward()
+      return editor.moveWordBackward()
     }
 
     if (Hotkeys.isMoveWordForward(event)) {
       event.preventDefault()
-      return change.moveWordForward()
+      return editor.moveWordForward()
     }
 
     if (Hotkeys.isExtendBackward(event)) {
@@ -566,7 +562,7 @@ function AfterPlugin(options = {}) {
 
       if (hasVoidParent || isPreviousInVoid || startText.text == '') {
         event.preventDefault()
-        return change.moveFocusBackward()
+        return editor.moveFocusBackward()
       }
     }
 
@@ -577,7 +573,7 @@ function AfterPlugin(options = {}) {
 
       if (hasVoidParent || isNextInVoid || startText.text == '') {
         event.preventDefault()
-        return change.moveFocusForward()
+        return editor.moveFocusForward()
       }
     }
 
@@ -588,31 +584,31 @@ function AfterPlugin(options = {}) {
    * On paste.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onPaste(event, change, next) {
+  function onPaste(event, editor, next) {
     debug('onPaste', { event })
 
-    const { value } = change
+    const { value } = editor
     const transfer = getEventTransfer(event)
     const { type, fragment, text } = transfer
 
     if (type == 'fragment') {
-      change.insertFragment(fragment)
+      editor.insertFragment(fragment)
     }
 
     if (type == 'text' || type == 'html') {
       if (!text) return next()
       const { document, selection, startBlock } = value
-      if (change.isVoid(startBlock)) return next()
+      if (editor.isVoid(startBlock)) return next()
 
       const defaultBlock = startBlock
       const defaultMarks = document.getInsertMarksAtRange(selection)
       const frag = Plain.deserialize(text, { defaultBlock, defaultMarks })
         .document
-      change.insertFragment(frag)
+      editor.insertFragment(frag)
     }
 
     next()
@@ -622,21 +618,21 @@ function AfterPlugin(options = {}) {
    * On select.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onSelect(event, change, next) {
+  function onSelect(event, editor, next) {
     debug('onSelect', { event })
 
     const window = getWindow(event.target)
-    const { editor, value } = change
+    const { value } = editor
     const { document } = value
     const native = window.getSelection()
 
     // If there are no ranges, the editor was blurred natively.
     if (!native.rangeCount) {
-      change.blur()
+      editor.blur()
       return
     }
 
@@ -661,10 +657,10 @@ function AfterPlugin(options = {}) {
     // selection, go with `0`. (2017/09/07)
     if (
       anchorBlock &&
-      !change.isVoid(anchorBlock) &&
+      !editor.isVoid(anchorBlock) &&
       anchor.offset == 0 &&
       focusBlock &&
-      change.isVoid(focusBlock) &&
+      editor.isVoid(focusBlock) &&
       focus.offset != 0
     ) {
       range = range.setFocus(focus.setOffset(0))
@@ -675,7 +671,7 @@ function AfterPlugin(options = {}) {
     // standardizes the behavior, since it's indistinguishable to the user.
     if (
       anchorInline &&
-      !change.isVoid(anchorInline) &&
+      !editor.isVoid(anchorInline) &&
       anchor.offset == anchorText.text.length
     ) {
       const block = document.getClosestBlock(anchor.key)
@@ -685,7 +681,7 @@ function AfterPlugin(options = {}) {
 
     if (
       focusInline &&
-      !change.isVoid(focusInline) &&
+      !editor.isVoid(focusInline) &&
       focus.offset == focusText.text.length
     ) {
       const block = document.getClosestBlock(focus.key)
@@ -697,10 +693,10 @@ function AfterPlugin(options = {}) {
     selection = selection.setIsFocused(true)
 
     // Preserve active marks from the current selection.
-    // They will be cleared by `change.select` if the selection actually moved.
+    // They will be cleared by `editor.select` if the selection actually moved.
     selection = selection.set('marks', value.selection.marks)
 
-    change.select(selection)
+    editor.select(selection)
     next()
   }
 
diff --git a/packages/slate-react/src/plugins/before.js b/packages/slate-react/src/plugins/before.js
index 2a68b04d2..933edfeb2 100644
--- a/packages/slate-react/src/plugins/before.js
+++ b/packages/slate-react/src/plugins/before.js
@@ -36,12 +36,11 @@ function BeforePlugin() {
    * On before input.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onBeforeInput(event, change, next) {
-    const { editor } = change
+  function onBeforeInput(event, editor, next) {
     const isSynthetic = !!event.nativeEvent
     if (editor.readOnly) return
 
@@ -58,12 +57,11 @@ function BeforePlugin() {
    * On blur.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onBlur(event, change, next) {
-    const { editor } = change
+  function onBlur(event, editor, next) {
     if (isCopying) return
     if (editor.readOnly) return
 
@@ -94,7 +92,7 @@ function BeforePlugin() {
       // editable section of an element that isn't a void node (eg. a list item
       // of the check list example).
       const node = findNode(relatedTarget, editor)
-      if (el.contains(relatedTarget) && node && !change.isVoid(node)) return
+      if (el.contains(relatedTarget) && node && !editor.isVoid(node)) return
     }
 
     debug('onBlur', { event })
@@ -105,12 +103,11 @@ function BeforePlugin() {
    * On composition end.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onCompositionEnd(event, change, next) {
-    const { editor } = change
+  function onCompositionEnd(event, editor, next) {
     const n = compositionCount
 
     // The `count` check here ensures that if another composition starts
@@ -137,11 +134,11 @@ function BeforePlugin() {
    * On click.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onClick(event, change, next) {
+  function onClick(event, editor, next) {
     debug('onClick', { event })
     next()
   }
@@ -150,14 +147,13 @@ function BeforePlugin() {
    * On composition start.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onCompositionStart(event, change, next) {
+  function onCompositionStart(event, editor, next) {
     isComposing = true
     compositionCount++
-    const { editor } = change
 
     // HACK: we need to re-render the editor here so that it will update its
     // placeholder in case one is currently rendered. This should be handled
@@ -167,7 +163,7 @@ function BeforePlugin() {
       editor.setState({ isComposing: true })
     }
 
-    const { value } = change
+    const { value } = editor
     const { selection } = value
 
     if (!selection.isCollapsed) {
@@ -178,7 +174,7 @@ function BeforePlugin() {
       // (because it cannot find <span> nodes in DOM). This is a workaround that
       // erases selection as soon as composition starts and preventing <spans>
       // to be dropped.
-      change.delete()
+      editor.delete()
     }
 
     debug('onCompositionStart', { event })
@@ -189,11 +185,11 @@ function BeforePlugin() {
    * On copy.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onCopy(event, change, next) {
+  function onCopy(event, editor, next) {
     const window = getWindow(event.target)
     isCopying = true
     window.requestAnimationFrame(() => (isCopying = false))
@@ -206,12 +202,11 @@ function BeforePlugin() {
    * On cut.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onCut(event, change, next) {
-    const { editor } = change
+  function onCut(event, editor, next) {
     if (editor.readOnly) return
 
     const window = getWindow(event.target)
@@ -226,11 +221,11 @@ function BeforePlugin() {
    * On drag end.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onDragEnd(event, change, next) {
+  function onDragEnd(event, editor, next) {
     isDragging = false
     debug('onDragEnd', { event })
     next()
@@ -240,11 +235,11 @@ function BeforePlugin() {
    * On drag enter.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onDragEnter(event, change, next) {
+  function onDragEnter(event, editor, next) {
     debug('onDragEnter', { event })
     next()
   }
@@ -253,11 +248,11 @@ function BeforePlugin() {
    * On drag exit.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onDragExit(event, change, next) {
+  function onDragExit(event, editor, next) {
     debug('onDragExit', { event })
     next()
   }
@@ -266,11 +261,11 @@ function BeforePlugin() {
    * On drag leave.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onDragLeave(event, change, next) {
+  function onDragLeave(event, editor, next) {
     debug('onDragLeave', { event })
     next()
   }
@@ -279,18 +274,17 @@ function BeforePlugin() {
    * On drag over.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onDragOver(event, change, next) {
+  function onDragOver(event, editor, next) {
     // If the target is inside a void node, and only in this case,
     // call `preventDefault` to signal that drops are allowed.
     // When the target is editable, dropping is already allowed by
     // default, and calling `preventDefault` hides the cursor.
-    const { editor } = change
     const node = findNode(event.target, editor)
-    if (change.isVoid(node)) event.preventDefault()
+    if (editor.isVoid(node)) event.preventDefault()
 
     // COMPAT: IE won't call onDrop on contentEditables unless the
     // default dragOver is prevented:
@@ -319,11 +313,11 @@ function BeforePlugin() {
    * On drag start.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onDragStart(event, change, next) {
+  function onDragStart(event, editor, next) {
     isDragging = true
     debug('onDragStart', { event })
     next()
@@ -333,12 +327,11 @@ function BeforePlugin() {
    * On drop.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onDrop(event, change, next) {
-    const { editor } = change
+  function onDrop(event, editor, next) {
     if (editor.readOnly) return
 
     // Prevent default so the DOM's value isn't corrupted.
@@ -352,12 +345,11 @@ function BeforePlugin() {
    * On focus.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onFocus(event, change, next) {
-    const { editor } = change
+  function onFocus(event, editor, next) {
     if (isCopying) return
     if (editor.readOnly) return
 
@@ -383,13 +375,13 @@ function BeforePlugin() {
    * On input.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onInput(event, change, next) {
+  function onInput(event, editor, next) {
     if (isComposing) return
-    if (change.value.selection.isBlurred) return
+    if (editor.value.selection.isBlurred) return
     debug('onInput', { event })
     next()
   }
@@ -398,12 +390,11 @@ function BeforePlugin() {
    * On key down.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onKeyDown(event, change, next) {
-    const { editor } = change
+  function onKeyDown(event, editor, next) {
     if (editor.readOnly) return
 
     // When composing, we need to prevent all hotkeys from executing while
@@ -415,7 +406,7 @@ function BeforePlugin() {
     }
 
     // Certain hotkeys have native editing behaviors in `contenteditable`
-    // elements which will change the DOM and cause our value to be out of sync,
+    // elements which will editor the DOM and cause our value to be out of sync,
     // so they need to always be prevented.
     if (
       !IS_IOS &&
@@ -443,12 +434,11 @@ function BeforePlugin() {
    * On paste.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onPaste(event, change, next) {
-    const { editor } = change
+  function onPaste(event, editor, next) {
     if (editor.readOnly) return
 
     // Prevent defaults so the DOM state isn't corrupted.
@@ -462,15 +452,14 @@ function BeforePlugin() {
    * On select.
    *
    * @param {Event} event
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onSelect(event, change, next) {
+  function onSelect(event, editor, next) {
     if (isCopying) return
     if (isComposing) return
 
-    const { editor } = change
     if (editor.readOnly) return
 
     // Save the new `activeElement`.
diff --git a/packages/slate-react/src/plugins/react.js b/packages/slate-react/src/plugins/react.js
index 5ba82be06..500b1e823 100644
--- a/packages/slate-react/src/plugins/react.js
+++ b/packages/slate-react/src/plugins/react.js
@@ -41,14 +41,13 @@ function ReactPlugin(options = {}) {
    * @return {Object}
    */
 
-  function renderEditor(props, next) {
-    const { editor } = props
+  function renderEditor(props, editor, next) {
     return (
       <Content
-        onEvent={editor.event}
         autoCorrect={props.autoCorrect}
         className={props.className}
         editor={editor}
+        onEvent={(handler, event) => editor.run(handler, event)}
         readOnly={props.readOnly}
         role={props.role}
         spellCheck={props.spellCheck}
@@ -63,11 +62,12 @@ function ReactPlugin(options = {}) {
    * Render node.
    *
    * @param {Object} props
+   * @param {Editor} editor
    * @param {Function} next
    * @return {Element}
    */
 
-  function renderNode(props, next) {
+  function renderNode(props, editor, next) {
     const { attributes, children, node } = props
     const { object } = node
     if (object != 'block' && object != 'inline') return null
@@ -89,8 +89,8 @@ function ReactPlugin(options = {}) {
    * @return {Element}
    */
 
-  function renderPlaceholder(props, next) {
-    const { editor, node } = props
+  function renderPlaceholder(props, editor, next) {
+    const { node } = props
     if (!editor.props.placeholder) return null
     if (editor.state.isComposing) return null
     if (node.object != 'block') return null
diff --git a/packages/slate-react/test/rendering/fixtures/custom-block-blurred.js b/packages/slate-react/test/rendering/fixtures/custom-block-blurred.js
index de0428de0..2e187140f 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-block-blurred.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-block-blurred.js
@@ -11,7 +11,7 @@ function Image(props) {
   })
 }
 
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   switch (props.node.type) {
     case 'image':
       return Image(props)
diff --git a/packages/slate-react/test/rendering/fixtures/custom-block-focused.js b/packages/slate-react/test/rendering/fixtures/custom-block-focused.js
index 182fcbb20..fcb7ce635 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-block-focused.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-block-focused.js
@@ -11,7 +11,7 @@ function Image(props) {
   })
 }
 
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   switch (props.node.type) {
     case 'image':
       return Image(props)
diff --git a/packages/slate-react/test/rendering/fixtures/custom-block-multiple.js b/packages/slate-react/test/rendering/fixtures/custom-block-multiple.js
index 46d703f0d..7f7134d65 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-block-multiple.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-block-multiple.js
@@ -11,7 +11,7 @@ function Code(props) {
   )
 }
 
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   switch (props.node.type) {
     case 'code':
       return Code(props)
diff --git a/packages/slate-react/test/rendering/fixtures/custom-block-selected.js b/packages/slate-react/test/rendering/fixtures/custom-block-selected.js
index 0acc2e9f9..690afda21 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-block-selected.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-block-selected.js
@@ -11,7 +11,7 @@ function Image(props) {
   })
 }
 
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   switch (props.node.type) {
     case 'image':
       return Image(props)
diff --git a/packages/slate-react/test/rendering/fixtures/custom-block-void.js b/packages/slate-react/test/rendering/fixtures/custom-block-void.js
index def5e945f..fc776a86c 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-block-void.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-block-void.js
@@ -10,7 +10,7 @@ function Image(props) {
   })
 }
 
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   switch (props.node.type) {
     case 'image':
       return Image(props)
diff --git a/packages/slate-react/test/rendering/fixtures/custom-decorator.js b/packages/slate-react/test/rendering/fixtures/custom-decorator.js
index 27ff5b0cf..42c41ab58 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-decorator.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-decorator.js
@@ -26,7 +26,7 @@ function Bold(props) {
   return React.createElement('strong', { ...props.attributes }, props.children)
 }
 
-function renderMark(props, next) {
+function renderMark(props, editor, next) {
   switch (props.mark.type) {
     case 'bold':
       return Bold(props)
diff --git a/packages/slate-react/test/rendering/fixtures/custom-inline-multiple.js b/packages/slate-react/test/rendering/fixtures/custom-inline-multiple.js
index c0c8e02ca..00c114351 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-inline-multiple.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-inline-multiple.js
@@ -11,7 +11,7 @@ function Link(props) {
   )
 }
 
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   switch (props.node.type) {
     case 'link':
       return Link(props)
diff --git a/packages/slate-react/test/rendering/fixtures/custom-inline-void.js b/packages/slate-react/test/rendering/fixtures/custom-inline-void.js
index 35b18eee4..add9d1c85 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-inline-void.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-inline-void.js
@@ -7,7 +7,7 @@ function Emoji(props) {
   return React.createElement('img', props.attributes)
 }
 
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   switch (props.node.type) {
     case 'emoji':
       return Emoji(props)
diff --git a/packages/slate-react/test/rendering/fixtures/custom-inline.js b/packages/slate-react/test/rendering/fixtures/custom-inline.js
index 7d89d2c3a..dd10eaea2 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-inline.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-inline.js
@@ -11,7 +11,7 @@ function Link(props) {
   )
 }
 
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   switch (props.node.type) {
     case 'link':
       return Link(props)
diff --git a/packages/slate-react/test/rendering/fixtures/custom-mark.js b/packages/slate-react/test/rendering/fixtures/custom-mark.js
index 07b723abd..6cc4cbdb4 100644
--- a/packages/slate-react/test/rendering/fixtures/custom-mark.js
+++ b/packages/slate-react/test/rendering/fixtures/custom-mark.js
@@ -7,7 +7,7 @@ function Bold(props) {
   return React.createElement('strong', { ...props.attributes }, props.children)
 }
 
-function renderMark(props, next) {
+function renderMark(props, editor, next) {
   switch (props.mark.type) {
     case 'bold':
       return Bold(props)
diff --git a/packages/slate-react/test/rendering/fixtures/readonly-custom-block-void.js b/packages/slate-react/test/rendering/fixtures/readonly-custom-block-void.js
index 02844f373..569fb366f 100644
--- a/packages/slate-react/test/rendering/fixtures/readonly-custom-block-void.js
+++ b/packages/slate-react/test/rendering/fixtures/readonly-custom-block-void.js
@@ -10,7 +10,7 @@ function Image(props) {
   })
 }
 
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   switch (props.node.type) {
     case 'image':
       return Image(props)
diff --git a/packages/slate-react/test/rendering/fixtures/readonly-custom-inline-void.js b/packages/slate-react/test/rendering/fixtures/readonly-custom-inline-void.js
index f790f8f59..6910331d9 100644
--- a/packages/slate-react/test/rendering/fixtures/readonly-custom-inline-void.js
+++ b/packages/slate-react/test/rendering/fixtures/readonly-custom-inline-void.js
@@ -7,7 +7,7 @@ function Emoji(props) {
   return React.createElement('img', props.attributes)
 }
 
-function renderNode(props, next) {
+function renderNode(props, editor, next) {
   switch (props.node.type) {
     case 'emoji':
       return Emoji(props)
diff --git a/packages/slate/Changelog.md b/packages/slate/Changelog.md
index 578e76886..f96279531 100644
--- a/packages/slate/Changelog.md
+++ b/packages/slate/Changelog.md
@@ -88,13 +88,13 @@ Taken together, commands and queries offer a better way for plugins to manage th
 
 ```js
 // Previously, you'd return `undefined` to continue.
-function onKeyDown(event, change, editor) {
+function onKeyDown(event, editor, next) {
   if (event.key !== 'Enter') return
   ...
 }
 
 // Now, you call `next()` to continue...
-function onKeyDown(event, change, next) {
+function onKeyDown(event, editor, next) {
   if (event.key !== 'Enter') return next()
   ...
 }
@@ -103,7 +103,7 @@ function onKeyDown(event, change, next) {
 While that may seem inconvenient, it opens up an entire new behavior, which is deferring to the plugins later in the stack to see if they "handle" a specific case, and if not, handling it yourself:
 
 ```js
-function onKeyDown(event, change, next) {
+function onKeyDown(event, editor, next) {
   if (event.key === 'Enter') {
     const handled = next()
     if (handled) return handled
@@ -119,7 +119,7 @@ Under the covers, the `schema`, `commands` and `queries` concept are all impleme
 
 ```js
 const plugin = {
-  onCommand(command, change, next) {
+  onCommand(command, editor, next) {
     ...
   }
 }
diff --git a/packages/slate/Readme.md b/packages/slate/Readme.md
index 29bd38050..47ac3a1b6 100644
--- a/packages/slate/Readme.md
+++ b/packages/slate/Readme.md
@@ -1,10 +1 @@
-This package contains the core logic of Slate. It's separated further into a series of directories:
-
-* [**Changes**](./src/changes) — containing the changes that are used to alter a Slate document.
-* [**Constants**](./src/constants) — containing constants that are used in Slate's codebase.
-* [**Models**](./src/models) — containing the models that define Slate's data structure.
-* [**Operations**](./src/operations) — containing the low-level operations that create Slate changes.
-* [**Schemas**](./src/schemas) - containing the core schema that ships with Slate by default.
-* [**Utils**](./src/utils) — containing a few private convenience modules.
-
-Feel free to poke around in each of them to learn more!
+This package contains the core logic of Slate. Feel free to poke around to learn more!
diff --git a/packages/slate/src/commands/at-current-range.js b/packages/slate/src/commands/at-current-range.js
index 983c7ffee..574b8768e 100644
--- a/packages/slate/src/commands/at-current-range.js
+++ b/packages/slate/src/commands/at-current-range.js
@@ -34,16 +34,16 @@ const PROXY_TRANSFORMS = [
 ]
 
 PROXY_TRANSFORMS.forEach(method => {
-  Commands[method] = (change, ...args) => {
-    const { value } = change
+  Commands[method] = (editor, ...args) => {
+    const { value } = editor
     const { selection } = value
     const methodAtRange = `${method}AtRange`
-    change[methodAtRange](selection, ...args)
+    editor[methodAtRange](selection, ...args)
 
     if (method.match(/Backward$/)) {
-      change.moveToStart()
+      editor.moveToStart()
     } else if (method.match(/Forward$/)) {
-      change.moveToEnd()
+      editor.moveToEnd()
     }
   }
 })
@@ -51,85 +51,85 @@ PROXY_TRANSFORMS.forEach(method => {
 /**
  * Add a `mark` to the characters in the current selection.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Mark} mark
  */
 
-Commands.addMark = (change, mark) => {
+Commands.addMark = (editor, mark) => {
   mark = Mark.create(mark)
-  const { value } = change
+  const { value } = editor
   const { document, selection } = value
 
   if (selection.isExpanded) {
-    change.addMarkAtRange(selection, mark)
+    editor.addMarkAtRange(selection, mark)
   } else if (selection.marks) {
     const marks = selection.marks.add(mark)
     const sel = selection.set('marks', marks)
-    change.select(sel)
+    editor.select(sel)
   } else {
     const marks = document.getActiveMarksAtRange(selection).add(mark)
     const sel = selection.set('marks', marks)
-    change.select(sel)
+    editor.select(sel)
   }
 }
 
 /**
  * Add a list of `marks` to the characters in the current selection.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Mark} mark
  */
 
-Commands.addMarks = (change, marks) => {
-  marks.forEach(mark => change.addMark(mark))
+Commands.addMarks = (editor, marks) => {
+  marks.forEach(mark => editor.addMark(mark))
 }
 
 /**
  * Delete at the current selection.
  *
- * @param {Change} change
+ * @param {Editor} editor
  */
 
-Commands.delete = change => {
-  const { value } = change
+Commands.delete = editor => {
+  const { value } = editor
   const { selection } = value
-  change.deleteAtRange(selection)
+  editor.deleteAtRange(selection)
 
   // Ensure that the selection is collapsed to the start, because in certain
   // cases when deleting across inline nodes, when splitting the inline node the
   // end point of the selection will end up after the split point.
-  change.moveToStart()
+  editor.moveToStart()
 }
 
 /**
  * Insert a `block` at the current selection.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {String|Object|Block} block
  */
 
-Commands.insertBlock = (change, block) => {
+Commands.insertBlock = (editor, block) => {
   block = Block.create(block)
-  const { value } = change
+  const { value } = editor
   const { selection } = value
-  change.insertBlockAtRange(selection, block)
+  editor.insertBlockAtRange(selection, block)
 
   // If the node was successfully inserted, update the selection.
-  const node = change.value.document.getNode(block.key)
-  if (node) change.moveToEndOfNode(node)
+  const node = editor.value.document.getNode(block.key)
+  if (node) editor.moveToEndOfNode(node)
 }
 
 /**
  * Insert a `fragment` at the current selection.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Document} fragment
  */
 
-Commands.insertFragment = (change, fragment) => {
+Commands.insertFragment = (editor, fragment) => {
   if (!fragment.nodes.size) return
 
-  let { value } = change
+  let { value } = editor
   let { document, selection } = value
   const { start, end } = selection
   const { startText, endText, startInline } = value
@@ -146,116 +146,116 @@ Commands.insertFragment = (change, fragment) => {
   const isInserting =
     firstChild.hasBlockChildren() || lastChild.hasBlockChildren()
 
-  change.insertFragmentAtRange(selection, fragment)
-  value = change.value
+  editor.insertFragmentAtRange(selection, fragment)
+  value = editor.value
   document = value.document
 
   const newTexts = document.getTexts().filter(n => !keys.includes(n.key))
   const newText = isAppending ? newTexts.last() : newTexts.takeLast(2).first()
 
   if (newText && (lastInline || isInserting)) {
-    change.select(selection.moveToEndOfNode(newText))
+    editor.select(selection.moveToEndOfNode(newText))
   } else if (newText) {
-    change.select(
+    editor.select(
       selection.moveToStartOfNode(newText).moveForward(lastText.text.length)
     )
   } else {
-    change.select(selection.moveToStart().moveForward(lastText.text.length))
+    editor.select(selection.moveToStart().moveForward(lastText.text.length))
   }
 }
 
 /**
  * Insert an `inline` at the current selection.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {String|Object|Inline} inline
  */
 
-Commands.insertInline = (change, inline) => {
+Commands.insertInline = (editor, inline) => {
   inline = Inline.create(inline)
-  const { value } = change
+  const { value } = editor
   const { selection } = value
-  change.insertInlineAtRange(selection, inline)
+  editor.insertInlineAtRange(selection, inline)
 
   // If the node was successfully inserted, update the selection.
-  const node = change.value.document.getNode(inline.key)
-  if (node) change.moveToEndOfNode(node)
+  const node = editor.value.document.getNode(inline.key)
+  if (node) editor.moveToEndOfNode(node)
 }
 
 /**
  * Insert a string of `text` with optional `marks` at the current selection.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {String} text
  * @param {Set<Mark>} marks (optional)
  */
 
-Commands.insertText = (change, text, marks) => {
-  const { value } = change
+Commands.insertText = (editor, text, marks) => {
+  const { value } = editor
   const { document, selection } = value
   marks = marks || selection.marks || document.getInsertMarksAtRange(selection)
-  change.insertTextAtRange(selection, text, marks)
+  editor.insertTextAtRange(selection, text, marks)
 
   // If the text was successfully inserted, and the selection had marks on it,
   // unset the selection's marks.
-  if (selection.marks && document != change.value.document) {
-    change.select({ marks: null })
+  if (selection.marks && document != editor.value.document) {
+    editor.select({ marks: null })
   }
 }
 
 /**
  * Remove a `mark` from the characters in the current selection.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Mark} mark
  */
 
-Commands.removeMark = (change, mark) => {
+Commands.removeMark = (editor, mark) => {
   mark = Mark.create(mark)
-  const { value } = change
+  const { value } = editor
   const { document, selection } = value
 
   if (selection.isExpanded) {
-    change.removeMarkAtRange(selection, mark)
+    editor.removeMarkAtRange(selection, mark)
   } else if (selection.marks) {
     const marks = selection.marks.remove(mark)
     const sel = selection.set('marks', marks)
-    change.select(sel)
+    editor.select(sel)
   } else {
     const marks = document.getActiveMarksAtRange(selection).remove(mark)
     const sel = selection.set('marks', marks)
-    change.select(sel)
+    editor.select(sel)
   }
 }
 
 /**
  * Replace an `oldMark` with a `newMark` in the characters in the current selection.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Mark} oldMark
  * @param {Mark} newMark
  */
 
-Commands.replaceMark = (change, oldMark, newMark) => {
-  change.removeMark(oldMark)
-  change.addMark(newMark)
+Commands.replaceMark = (editor, oldMark, newMark) => {
+  editor.removeMark(oldMark)
+  editor.addMark(newMark)
 }
 
 /**
  * Split the block node at the current selection, to optional `depth`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Number} depth (optional)
  */
 
-Commands.splitBlock = (change, depth = 1) => {
-  const { value } = change
+Commands.splitBlock = (editor, depth = 1) => {
+  const { value } = editor
   const { selection, document } = value
   const marks = selection.marks || document.getInsertMarksAtRange(selection)
-  change.splitBlockAtRange(selection, depth).moveToEnd()
+  editor.splitBlockAtRange(selection, depth).moveToEnd()
 
   if (marks && marks.size !== 0) {
-    change.select({ marks })
+    editor.select({ marks })
   }
 }
 
@@ -263,48 +263,48 @@ Commands.splitBlock = (change, depth = 1) => {
  * Add or remove a `mark` from the characters in the current selection,
  * depending on whether it's already there.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Mark} mark
  */
 
-Commands.toggleMark = (change, mark) => {
+Commands.toggleMark = (editor, mark) => {
   mark = Mark.create(mark)
-  const { value } = change
+  const { value } = editor
   const exists = value.activeMarks.has(mark)
 
   if (exists) {
-    change.removeMark(mark)
+    editor.removeMark(mark)
   } else {
-    change.addMark(mark)
+    editor.addMark(mark)
   }
 }
 
 /**
  * Wrap the current selection with prefix/suffix.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {String} prefix
  * @param {String} suffix
  */
 
-Commands.wrapText = (change, prefix, suffix = prefix) => {
-  const { value } = change
+Commands.wrapText = (editor, prefix, suffix = prefix) => {
+  const { value } = editor
   const { selection } = value
-  change.wrapTextAtRange(selection, prefix, suffix)
+  editor.wrapTextAtRange(selection, prefix, suffix)
 
   // If the selection was collapsed, it will have moved the start offset too.
   if (selection.isCollapsed) {
-    change.moveStartBackward(prefix.length)
+    editor.moveStartBackward(prefix.length)
   }
 
   // Adding the suffix will have pushed the end of the selection further on, so
   // we need to move it back to account for this.
-  change.moveEndBackward(suffix.length)
+  editor.moveEndBackward(suffix.length)
 
   // There's a chance that the selection points moved "through" each other,
   // resulting in a now-incorrect selection direction.
-  if (selection.isForward != change.value.selection.isForward) {
-    change.flip()
+  if (selection.isForward != editor.value.selection.isForward) {
+    editor.flip()
   }
 }
 
diff --git a/packages/slate/src/commands/at-range.js b/packages/slate/src/commands/at-range.js
index 53d30f3ac..3ac5f96aa 100644
--- a/packages/slate/src/commands/at-range.js
+++ b/packages/slate/src/commands/at-range.js
@@ -16,20 +16,20 @@ const Commands = {}
 /**
  * Add a new `mark` to the characters at `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Mixed} mark
  */
 
-Commands.addMarkAtRange = (change, range, mark) => {
+Commands.addMarkAtRange = (editor, range, mark) => {
   if (range.isCollapsed) return
 
-  const { value } = change
+  const { value } = editor
   const { document } = value
   const { start, end } = range
   const texts = document.getTextsAtRange(range)
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     texts.forEach(node => {
       const { key } = node
       let index = 0
@@ -39,7 +39,7 @@ Commands.addMarkAtRange = (change, range, mark) => {
       if (key == end.key) length = end.offset
       if (key == start.key && key == end.key) length = end.offset - start.offset
 
-      change.addMarkByKey(key, index, length, mark)
+      editor.addMarkByKey(key, index, length, mark)
     })
   })
 }
@@ -47,28 +47,28 @@ Commands.addMarkAtRange = (change, range, mark) => {
 /**
  * Add a list of `marks` to the characters at `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Array<Mixed>} mark
  */
 
-Commands.addMarksAtRange = (change, range, marks) => {
-  marks.forEach(mark => change.addMarkAtRange(range, mark))
+Commands.addMarksAtRange = (editor, range, marks) => {
+  marks.forEach(mark => editor.addMarkAtRange(range, mark))
 }
 
 /**
  * Delete everything in a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  */
 
-Commands.deleteAtRange = (change, range) => {
+Commands.deleteAtRange = (editor, range) => {
   // Snapshot the selection, which creates an extra undo save point, so that
   // when you undo a delete, the expanded selection will be retained.
-  change.snapshotSelection()
+  editor.snapshotSelection()
 
-  const { editor, value } = change
+  const { value } = editor
   const { start, end } = range
   let startKey = start.key
   let startOffset = start.offset
@@ -98,14 +98,14 @@ Commands.deleteAtRange = (change, range) => {
     isEndVoid = document.hasVoidParent(endKey, editor)
   }
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     // If the start node is inside a void node, remove the void node and update
     // the starting point to be right after it, continuously until the start point
     // is not a void, or until the entire range is handled.
     while (isStartVoid) {
       const startVoid = document.getClosestVoid(startKey, editor)
       const nextText = document.getNextText(startKey)
-      change.removeNodeByKey(startVoid.key)
+      editor.removeNodeByKey(startVoid.key)
 
       // If the start and end keys are the same, we're done.
       if (startKey == endKey) return
@@ -114,7 +114,7 @@ Commands.deleteAtRange = (change, range) => {
       if (!nextText) return
 
       // Continue...
-      document = change.value.document
+      document = editor.value.document
       startKey = nextText.key
       startOffset = 0
       isStartVoid = document.hasVoidParent(startKey, editor)
@@ -126,10 +126,10 @@ Commands.deleteAtRange = (change, range) => {
     while (isEndVoid) {
       const endVoid = document.getClosestVoid(endKey, editor)
       const prevText = document.getPreviousText(endKey)
-      change.removeNodeByKey(endVoid.key)
+      editor.removeNodeByKey(endVoid.key)
 
       // Continue...
-      document = change.value.document
+      document = editor.value.document
       endKey = prevText.key
       endOffset = prevText.text.length
       isEndVoid = document.hasVoidParent(endKey, editor)
@@ -138,14 +138,14 @@ Commands.deleteAtRange = (change, range) => {
     // If the start and end key are the same, and it was a hanging selection, we
     // can just remove the entire block.
     if (startKey == endKey && isHanging) {
-      change.removeNodeByKey(startBlock.key)
+      editor.removeNodeByKey(startBlock.key)
       return
     } else if (startKey == endKey) {
       // Otherwise, if it wasn't hanging, we're inside a single text node, so we can
       // simply remove the text in the range.
       const index = startOffset
       const length = endOffset - startOffset
-      change.removeTextByKey(startKey, index, length)
+      editor.removeTextByKey(startKey, index, length)
       return
     } else {
       // Otherwise, we need to recursively remove text and nodes inside the start
@@ -179,7 +179,7 @@ Commands.deleteAtRange = (change, range) => {
         const afters = parent.nodes.slice(index + 1)
 
         afters.reverse().forEach(node => {
-          change.removeNodeByKey(node.key)
+          editor.removeNodeByKey(node.key)
         })
 
         child = parent
@@ -191,7 +191,7 @@ Commands.deleteAtRange = (change, range) => {
       const middles = ancestor.nodes.slice(startChildIndex + 1, endChildIndex)
 
       middles.reverse().forEach(node => {
-        change.removeNodeByKey(node.key)
+        editor.removeNodeByKey(node.key)
       })
 
       // Remove the nodes before the end text node in the tree.
@@ -203,7 +203,7 @@ Commands.deleteAtRange = (change, range) => {
         const befores = parent.nodes.slice(0, index)
 
         befores.reverse().forEach(node => {
-          change.removeNodeByKey(node.key)
+          editor.removeNodeByKey(node.key)
         })
 
         child = parent
@@ -211,22 +211,22 @@ Commands.deleteAtRange = (change, range) => {
 
       // Remove any overlapping text content from the leaf text nodes.
       if (startLength != 0) {
-        change.removeTextByKey(startKey, startOffset, startLength)
+        editor.removeTextByKey(startKey, startOffset, startLength)
       }
 
       if (endLength != 0) {
-        change.removeTextByKey(endKey, 0, endOffset)
+        editor.removeTextByKey(endKey, 0, endOffset)
       }
 
       // If the start and end blocks aren't the same, move and merge the end block
       // into the start block.
       if (startBlock.key != endBlock.key) {
-        document = change.value.document
+        document = editor.value.document
         const lonely = document.getFurthestOnlyChildAncestor(endBlock.key)
 
         // Move the end block to be right after the start block.
         if (endParentIndex != startParentIndex + 1) {
-          change.moveNodeByKey(
+          editor.moveNodeByKey(
             endBlock.key,
             startParent.key,
             startParentIndex + 1
@@ -236,14 +236,14 @@ Commands.deleteAtRange = (change, range) => {
         // If the selection is hanging, just remove the start block, otherwise
         // merge the end block into it.
         if (isHanging) {
-          change.removeNodeByKey(startBlock.key)
+          editor.removeNodeByKey(startBlock.key)
         } else {
-          change.mergeNodeByKey(endBlock.key)
+          editor.mergeNodeByKey(endBlock.key)
         }
 
         // If nested empty blocks are left over above the end block, remove them.
         if (lonely) {
-          change.removeNodeByKey(lonely.key)
+          editor.removeNodeByKey(lonely.key)
         }
       }
     }
@@ -253,12 +253,12 @@ Commands.deleteAtRange = (change, range) => {
 /**
  * Delete backward until the character boundary at a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  */
 
-Commands.deleteCharBackwardAtRange = (change, range) => {
-  const { value } = change
+Commands.deleteCharBackwardAtRange = (editor, range) => {
+  const { value } = editor
   const { document } = value
   const { start } = range
   const startBlock = document.getClosestBlock(start.key)
@@ -266,35 +266,35 @@ Commands.deleteCharBackwardAtRange = (change, range) => {
   const o = offset + start.offset
   const { text } = startBlock
   const n = TextUtils.getCharOffsetBackward(text, o)
-  change.deleteBackwardAtRange(range, n)
+  editor.deleteBackwardAtRange(range, n)
 }
 
 /**
  * Delete backward until the line boundary at a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  */
 
-Commands.deleteLineBackwardAtRange = (change, range) => {
-  const { value } = change
+Commands.deleteLineBackwardAtRange = (editor, range) => {
+  const { value } = editor
   const { document } = value
   const { start } = range
   const startBlock = document.getClosestBlock(start.key)
   const offset = startBlock.getOffset(start.key)
   const o = offset + start.offset
-  change.deleteBackwardAtRange(range, o)
+  editor.deleteBackwardAtRange(range, o)
 }
 
 /**
  * Delete backward until the word boundary at a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  */
 
-Commands.deleteWordBackwardAtRange = (change, range) => {
-  const { value } = change
+Commands.deleteWordBackwardAtRange = (editor, range) => {
+  const { value } = editor
   const { document } = value
   const { start } = range
   const startBlock = document.getClosestBlock(start.key)
@@ -302,26 +302,26 @@ Commands.deleteWordBackwardAtRange = (change, range) => {
   const o = offset + start.offset
   const { text } = startBlock
   const n = o === 0 ? 1 : TextUtils.getWordOffsetBackward(text, o)
-  change.deleteBackwardAtRange(range, n)
+  editor.deleteBackwardAtRange(range, n)
 }
 
 /**
  * Delete backward `n` characters at a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Number} n (optional)
  */
 
-Commands.deleteBackwardAtRange = (change, range, n = 1) => {
+Commands.deleteBackwardAtRange = (editor, range, n = 1) => {
   if (n === 0) return
-  const { editor, value } = change
+  const { value } = editor
   const { document } = value
   const { start, focus } = range
 
   // If the range is expanded, perform a regular delete instead.
   if (range.isExpanded) {
-    change.deleteAtRange(range)
+    editor.deleteAtRange(range)
     return
   }
 
@@ -329,7 +329,7 @@ Commands.deleteBackwardAtRange = (change, range, n = 1) => {
 
   // If there is a void parent, delete it.
   if (voidParent) {
-    change.removeNodeByKey(voidParent.key)
+    editor.removeNodeByKey(voidParent.key)
     return
   }
 
@@ -338,11 +338,11 @@ Commands.deleteBackwardAtRange = (change, range, n = 1) => {
   // If the closest is not void, but empty, remove it
   if (
     block &&
-    !change.isVoid(block) &&
+    !editor.isVoid(block) &&
     block.text === '' &&
     document.nodes.size !== 1
   ) {
-    change.removeNodeByKey(block.key)
+    editor.removeNodeByKey(block.key)
     return
   }
 
@@ -362,7 +362,7 @@ Commands.deleteBackwardAtRange = (change, range, n = 1) => {
 
     // If the previous text node has a void parent, remove it.
     if (prevVoid) {
-      change.removeNodeByKey(prevVoid.key)
+      editor.removeNodeByKey(prevVoid.key)
       return
     }
 
@@ -370,7 +370,7 @@ Commands.deleteBackwardAtRange = (change, range, n = 1) => {
     // inside the current block, we need to merge the two blocks together.
     if (n == 1 && prevBlock != block) {
       range = range.moveAnchorTo(prev.key, prev.text.length)
-      change.deleteAtRange(range)
+      editor.deleteAtRange(range)
       return
     }
   }
@@ -379,7 +379,7 @@ Commands.deleteBackwardAtRange = (change, range, n = 1) => {
   // just remove the characters backwards inside the current node.
   if (n < focus.offset) {
     range = range.moveFocusBackward(n)
-    change.deleteAtRange(range)
+    editor.deleteAtRange(range)
     return
   }
 
@@ -401,18 +401,18 @@ Commands.deleteBackwardAtRange = (change, range, n = 1) => {
   }
 
   range = range.moveAnchorTo(node.key, offset)
-  change.deleteAtRange(range)
+  editor.deleteAtRange(range)
 }
 
 /**
  * Delete forward until the character boundary at a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  */
 
-Commands.deleteCharForwardAtRange = (change, range) => {
-  const { value } = change
+Commands.deleteCharForwardAtRange = (editor, range) => {
+  const { value } = editor
   const { document } = value
   const { start } = range
   const startBlock = document.getClosestBlock(start.key)
@@ -420,35 +420,35 @@ Commands.deleteCharForwardAtRange = (change, range) => {
   const o = offset + start.offset
   const { text } = startBlock
   const n = TextUtils.getCharOffsetForward(text, o)
-  change.deleteForwardAtRange(range, n)
+  editor.deleteForwardAtRange(range, n)
 }
 
 /**
  * Delete forward until the line boundary at a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  */
 
-Commands.deleteLineForwardAtRange = (change, range) => {
-  const { value } = change
+Commands.deleteLineForwardAtRange = (editor, range) => {
+  const { value } = editor
   const { document } = value
   const { start } = range
   const startBlock = document.getClosestBlock(start.key)
   const offset = startBlock.getOffset(start.key)
   const o = offset + start.offset
-  change.deleteForwardAtRange(range, startBlock.text.length - o)
+  editor.deleteForwardAtRange(range, startBlock.text.length - o)
 }
 
 /**
  * Delete forward until the word boundary at a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  */
 
-Commands.deleteWordForwardAtRange = (change, range) => {
-  const { value } = change
+Commands.deleteWordForwardAtRange = (editor, range) => {
+  const { value } = editor
   const { document } = value
   const { start } = range
   const startBlock = document.getClosestBlock(start.key)
@@ -457,26 +457,26 @@ Commands.deleteWordForwardAtRange = (change, range) => {
   const { text } = startBlock
   const wordOffset = TextUtils.getWordOffsetForward(text, o)
   const n = wordOffset === 0 ? 1 : wordOffset
-  change.deleteForwardAtRange(range, n)
+  editor.deleteForwardAtRange(range, n)
 }
 
 /**
  * Delete forward `n` characters at a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Number} n (optional)
  */
 
-Commands.deleteForwardAtRange = (change, range, n = 1) => {
+Commands.deleteForwardAtRange = (editor, range, n = 1) => {
   if (n === 0) return
-  const { editor, value } = change
+  const { value } = editor
   const { document } = value
   const { start, focus } = range
 
   // If the range is expanded, perform a regular delete instead.
   if (range.isExpanded) {
-    change.deleteAtRange(range)
+    editor.deleteAtRange(range)
     return
   }
 
@@ -484,7 +484,7 @@ Commands.deleteForwardAtRange = (change, range, n = 1) => {
 
   // If the node has a void parent, delete it.
   if (voidParent) {
-    change.removeNodeByKey(voidParent.key)
+    editor.removeNodeByKey(voidParent.key)
     return
   }
 
@@ -493,15 +493,15 @@ Commands.deleteForwardAtRange = (change, range, n = 1) => {
   // If the closest is not void, but empty, remove it
   if (
     block &&
-    !change.isVoid(block) &&
+    !editor.isVoid(block) &&
     block.text === '' &&
     document.nodes.size !== 1
   ) {
     const nextBlock = document.getNextBlock(block.key)
-    change.removeNodeByKey(block.key)
+    editor.removeNodeByKey(block.key)
 
     if (nextBlock && nextBlock.key) {
-      change.moveToStartOfNode(nextBlock)
+      editor.moveToStartOfNode(nextBlock)
     }
 
     return
@@ -523,7 +523,7 @@ Commands.deleteForwardAtRange = (change, range, n = 1) => {
 
     // If the next text node has a void parent, remove it.
     if (nextVoid) {
-      change.removeNodeByKey(nextVoid.key)
+      editor.removeNodeByKey(nextVoid.key)
       return
     }
 
@@ -531,7 +531,7 @@ Commands.deleteForwardAtRange = (change, range, n = 1) => {
     // inside the current block, we need to merge the two blocks together.
     if (n == 1 && nextBlock != block) {
       range = range.moveFocusTo(next.key, 0)
-      change.deleteAtRange(range)
+      editor.deleteAtRange(range)
       return
     }
   }
@@ -541,7 +541,7 @@ Commands.deleteForwardAtRange = (change, range, n = 1) => {
   // inside the current node.
   if (n <= text.text.length - focus.offset) {
     range = range.moveFocusForward(n)
-    change.deleteAtRange(range)
+    editor.deleteAtRange(range)
     return
   }
 
@@ -563,26 +563,26 @@ Commands.deleteForwardAtRange = (change, range, n = 1) => {
   }
 
   range = range.moveFocusTo(node.key, offset)
-  change.deleteAtRange(range)
+  editor.deleteAtRange(range)
 }
 
 /**
  * Insert a `block` node at `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Block|String|Object} block
  */
 
-Commands.insertBlockAtRange = (change, range, block) => {
+Commands.insertBlockAtRange = (editor, range, block) => {
   block = Block.create(block)
 
   if (range.isExpanded) {
-    change.deleteAtRange(range)
+    editor.deleteAtRange(range)
     range = range.moveToStart()
   }
 
-  const { value } = change
+  const { value } = editor
   const { document } = value
   const { start } = range
   let startKey = start.key
@@ -592,17 +592,17 @@ Commands.insertBlockAtRange = (change, range, block) => {
   const parent = document.getParent(startBlock.key)
   const index = parent.nodes.indexOf(startBlock)
 
-  if (change.isVoid(startBlock)) {
+  if (editor.isVoid(startBlock)) {
     const extra = start.isAtEndOfNode(startBlock) ? 1 : 0
-    change.insertNodeByKey(parent.key, index + extra, block)
+    editor.insertNodeByKey(parent.key, index + extra, block)
   } else if (!startInline && startBlock.text === '') {
-    change.insertNodeByKey(parent.key, index + 1, block)
+    editor.insertNodeByKey(parent.key, index + 1, block)
   } else if (start.isAtStartOfNode(startBlock)) {
-    change.insertNodeByKey(parent.key, index, block)
+    editor.insertNodeByKey(parent.key, index, block)
   } else if (start.isAtEndOfNode(startBlock)) {
-    change.insertNodeByKey(parent.key, index + 1, block)
+    editor.insertNodeByKey(parent.key, index + 1, block)
   } else {
-    if (startInline && change.isVoid(startInline)) {
+    if (startInline && editor.isVoid(startInline)) {
       const atEnd = start.isAtEndOfNode(startInline)
       const siblingText = atEnd
         ? document.getNextText(startKey)
@@ -616,9 +616,9 @@ Commands.insertBlockAtRange = (change, range, block) => {
       startOffset = splitRange.start.offset
     }
 
-    change.withoutNormalizing(() => {
-      change.splitDescendantsByKey(startBlock.key, startKey, startOffset)
-      change.insertNodeByKey(parent.key, index + 1, block)
+    editor.withoutNormalizing(() => {
+      editor.splitDescendantsByKey(startBlock.key, startKey, startOffset)
+      editor.insertNodeByKey(parent.key, index + 1, block)
     })
   }
 }
@@ -626,21 +626,21 @@ Commands.insertBlockAtRange = (change, range, block) => {
 /**
  * Insert a `fragment` at a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Document} fragment
  */
 
-Commands.insertFragmentAtRange = (change, range, fragment) => {
-  change.withoutNormalizing(() => {
+Commands.insertFragmentAtRange = (editor, range, fragment) => {
+  editor.withoutNormalizing(() => {
     // If the range is expanded, delete it first.
     if (range.isExpanded) {
-      change.deleteAtRange(range)
+      editor.deleteAtRange(range)
 
-      if (change.value.document.getDescendant(range.start.key)) {
+      if (editor.value.document.getDescendant(range.start.key)) {
         range = range.moveToStart()
       } else {
-        range = range.moveTo(range.end.key, 0).normalize(change.value.document)
+        range = range.moveTo(range.end.key, 0).normalize(editor.value.document)
       }
     }
 
@@ -655,7 +655,7 @@ Commands.insertFragmentAtRange = (change, range, fragment) => {
 
     // Calculate a few things...
     const { start } = range
-    const { value } = change
+    const { value } = editor
     let { document } = value
     let startText = document.getDescendant(start.key)
     let startBlock = document.getClosestBlock(startText.key)
@@ -671,8 +671,8 @@ Commands.insertFragmentAtRange = (change, range, fragment) => {
     const insertionNode = findInsertionNode(fragment, document, startBlock.key)
 
     // If the fragment only contains a void block, use `insertBlock` instead.
-    if (firstBlock === lastBlock && change.isVoid(firstBlock)) {
-      change.insertBlockAtRange(range, firstBlock)
+    if (firstBlock === lastBlock && editor.isVoid(firstBlock)) {
+      editor.insertBlockAtRange(range, firstBlock)
       return
     }
 
@@ -683,7 +683,7 @@ Commands.insertFragmentAtRange = (change, range, fragment) => {
       (firstChild.hasBlockChildren() || lastChild.hasBlockChildren())
     ) {
       fragment.nodes.reverse().forEach(node => {
-        change.insertBlockAtRange(range, node)
+        editor.insertBlockAtRange(range, node)
       })
       return
     }
@@ -702,17 +702,17 @@ Commands.insertFragmentAtRange = (change, range, fragment) => {
 
       excludingLonelyChild.nodes.forEach((node, i) => {
         const newIndex = startIndex + i + 1
-        change.insertNodeByKey(parent.key, newIndex, node)
+        editor.insertNodeByKey(parent.key, newIndex, node)
       })
     }
 
     // Check if we need to split the node.
     if (start.offset != 0) {
-      change.splitDescendantsByKey(startChild.key, start.key, start.offset)
+      editor.splitDescendantsByKey(startChild.key, start.key, start.offset)
     }
 
     // Update our variables with the new value.
-    document = change.value.document
+    document = editor.value.document
     startText = document.getDescendant(start.key)
     startBlock = document.getClosestBlock(start.key)
     startChild = startBlock.getFurthestAncestor(startText.key)
@@ -731,15 +731,15 @@ Commands.insertFragmentAtRange = (change, range, fragment) => {
 
       nextNodes.forEach((node, i) => {
         const newIndex = lastIndex + i
-        change.moveNodeByKey(node.key, lastBlock.key, newIndex)
+        editor.moveNodeByKey(node.key, lastBlock.key, newIndex)
       })
     }
 
     // If the starting block is empty, we replace it entirely with the first block
     // of the fragment, since this leads to a more expected behavior for the user.
-    if (!change.isVoid(startBlock) && startBlock.text === '') {
-      change.removeNodeByKey(startBlock.key)
-      change.insertNodeByKey(parent.key, index, firstBlock)
+    if (!editor.isVoid(startBlock) && startBlock.text === '') {
+      editor.removeNodeByKey(startBlock.key)
+      editor.insertNodeByKey(parent.key, index, firstBlock)
     } else {
       // Otherwise, we maintain the starting block, and insert all of the first
       // block's inline nodes into it at the split point.
@@ -749,7 +749,7 @@ Commands.insertFragmentAtRange = (change, range, fragment) => {
       firstBlock.nodes.forEach((inline, i) => {
         const o = start.offset == 0 ? 0 : 1
         const newIndex = inlineIndex + i + o
-        change.insertNodeByKey(startBlock.key, newIndex, inline)
+        editor.insertNodeByKey(startBlock.key, newIndex, inline)
       })
     }
   })
@@ -786,45 +786,45 @@ const findInsertionNode = (fragment, document, startKey) => {
 /**
  * Insert an `inline` node at `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Inline|String|Object} inline
  */
 
-Commands.insertInlineAtRange = (change, range, inline) => {
+Commands.insertInlineAtRange = (editor, range, inline) => {
   inline = Inline.create(inline)
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     if (range.isExpanded) {
-      change.deleteAtRange(range)
+      editor.deleteAtRange(range)
       range = range.moveToStart()
     }
 
-    const { value } = change
+    const { value } = editor
     const { document } = value
     const { start } = range
     const parent = document.getParent(start.key)
     const startText = document.assertDescendant(start.key)
     const index = parent.nodes.indexOf(startText)
 
-    if (change.isVoid(parent)) return
+    if (editor.isVoid(parent)) return
 
-    change.splitNodeByKey(start.key, start.offset)
-    change.insertNodeByKey(parent.key, index + 1, inline)
+    editor.splitNodeByKey(start.key, start.offset)
+    editor.insertNodeByKey(parent.key, index + 1, inline)
   })
 }
 
 /**
  * Insert `text` at a `range`, with optional `marks`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {String} text
  * @param {Set<Mark>} marks (optional)
  */
 
-Commands.insertTextAtRange = (change, range, text, marks) => {
-  const { value } = change
+Commands.insertTextAtRange = (editor, range, text, marks) => {
+  const { value } = editor
   const { document } = value
   const { start } = range
   let key = start.key
@@ -832,15 +832,15 @@ Commands.insertTextAtRange = (change, range, text, marks) => {
   const path = start.path
   const parent = document.getParent(start.key)
 
-  if (change.isVoid(parent)) {
+  if (editor.isVoid(parent)) {
     return
   }
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     if (range.isExpanded) {
-      change.deleteAtRange(range)
+      editor.deleteAtRange(range)
 
-      const startText = change.value.document.getNode(path)
+      const startText = editor.value.document.getNode(path)
 
       // Update range start after delete
       if (startText && startText.key !== key) {
@@ -848,27 +848,27 @@ Commands.insertTextAtRange = (change, range, text, marks) => {
       }
     }
 
-    change.insertTextByKey(key, offset, text, marks)
+    editor.insertTextByKey(key, offset, text, marks)
   })
 }
 
 /**
  * Remove an existing `mark` to the characters at `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Mark|String} mark (optional)
  */
 
-Commands.removeMarkAtRange = (change, range, mark) => {
+Commands.removeMarkAtRange = (editor, range, mark) => {
   if (range.isCollapsed) return
 
-  const { value } = change
+  const { value } = editor
   const { document } = value
   const texts = document.getTextsAtRange(range)
   const { start, end } = range
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     texts.forEach(node => {
       const { key } = node
       let index = 0
@@ -878,7 +878,7 @@ Commands.removeMarkAtRange = (change, range, mark) => {
       if (key == end.key) length = end.offset
       if (key == start.key && key == end.key) length = end.offset - start.offset
 
-      change.removeMarkByKey(key, index, length, mark)
+      editor.removeMarkByKey(key, index, length, mark)
     })
   })
 }
@@ -886,13 +886,13 @@ Commands.removeMarkAtRange = (change, range, mark) => {
 /**
  * Set the `properties` of block nodes in a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Object|String} properties
  */
 
-Commands.setBlocksAtRange = (change, range, properties) => {
-  const { editor, value } = change
+Commands.setBlocksAtRange = (editor, range, properties) => {
+  const { value } = editor
   const { document } = value
   const blocks = document.getBlocksAtRange(range)
 
@@ -915,9 +915,9 @@ Commands.setBlocksAtRange = (change, range, properties) => {
   // If it's a hanging selection, ignore the last block.
   const sets = isHanging ? blocks.slice(0, -1) : blocks
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     sets.forEach(block => {
-      change.setNodeByKey(block.key, properties)
+      editor.setNodeByKey(block.key, properties)
     })
   })
 }
@@ -925,19 +925,19 @@ Commands.setBlocksAtRange = (change, range, properties) => {
 /**
  * Set the `properties` of inline nodes in a `range`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Object|String} properties
  */
 
-Commands.setInlinesAtRange = (change, range, properties) => {
-  const { value } = change
+Commands.setInlinesAtRange = (editor, range, properties) => {
+  const { value } = editor
   const { document } = value
   const inlines = document.getInlinesAtRange(range)
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     inlines.forEach(inline => {
-      change.setNodeByKey(inline.key, properties)
+      editor.setNodeByKey(inline.key, properties)
     })
   })
 }
@@ -945,14 +945,14 @@ Commands.setInlinesAtRange = (change, range, properties) => {
 /**
  * Split the block nodes at a `range`, to optional `height`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Number} height (optional)
  */
 
-Commands.splitBlockAtRange = (change, range, height = 1) => {
+Commands.splitBlockAtRange = (editor, range, height = 1) => {
   const { start, end } = range
-  let { value } = change
+  let { value } = editor
   let { document } = value
   let node = document.assertDescendant(start.key)
   let parent = document.getClosestBlock(node.key)
@@ -964,10 +964,10 @@ Commands.splitBlockAtRange = (change, range, height = 1) => {
     h++
   }
 
-  change.withoutNormalizing(() => {
-    change.splitDescendantsByKey(node.key, start.key, start.offset)
+  editor.withoutNormalizing(() => {
+    editor.splitDescendantsByKey(node.key, start.key, start.offset)
 
-    value = change.value
+    value = editor.value
     document = value.document
 
     if (range.isExpanded) {
@@ -981,7 +981,7 @@ Commands.splitBlockAtRange = (change, range, height = 1) => {
       }
 
       range = document.resolveRange(range)
-      change.deleteAtRange(range)
+      editor.deleteAtRange(range)
     }
   })
 }
@@ -989,19 +989,19 @@ Commands.splitBlockAtRange = (change, range, height = 1) => {
 /**
  * Split the inline nodes at a `range`, to optional `height`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Number} height (optional)
  */
 
-Commands.splitInlineAtRange = (change, range, height = Infinity) => {
+Commands.splitInlineAtRange = (editor, range, height = Infinity) => {
   if (range.isExpanded) {
-    change.deleteAtRange(range)
+    editor.deleteAtRange(range)
     range = range.moveToStart()
   }
 
   const { start } = range
-  const { value } = change
+  const { value } = editor
   const { document } = value
   let node = document.assertDescendant(start.key)
   let parent = document.getClosestInline(node.key)
@@ -1013,47 +1013,47 @@ Commands.splitInlineAtRange = (change, range, height = Infinity) => {
     h++
   }
 
-  change.splitDescendantsByKey(node.key, start.key, start.offset)
+  editor.splitDescendantsByKey(node.key, start.key, start.offset)
 }
 
 /**
  * Add or remove a `mark` from the characters at `range`, depending on whether
  * it's already there.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Mixed} mark
  */
 
-Commands.toggleMarkAtRange = (change, range, mark) => {
+Commands.toggleMarkAtRange = (editor, range, mark) => {
   if (range.isCollapsed) return
 
   mark = Mark.create(mark)
 
-  const { value } = change
+  const { value } = editor
   const { document } = value
   const marks = document.getActiveMarksAtRange(range)
   const exists = marks.some(m => m.equals(mark))
 
   if (exists) {
-    change.removeMarkAtRange(range, mark)
+    editor.removeMarkAtRange(range, mark)
   } else {
-    change.addMarkAtRange(range, mark)
+    editor.addMarkAtRange(range, mark)
   }
 }
 
 /**
  * Unwrap all of the block nodes in a `range` from a block with `properties`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {String|Object} properties
  */
 
-Commands.unwrapBlockAtRange = (change, range, properties) => {
+Commands.unwrapBlockAtRange = (editor, range, properties) => {
   properties = Node.createProperties(properties)
 
-  const { value } = change
+  const { value } = editor
   let { document } = value
   const blocks = document.getBlocksAtRange(range)
   const wrappers = blocks
@@ -1071,7 +1071,7 @@ Commands.unwrapBlockAtRange = (change, range, properties) => {
     .toOrderedSet()
     .toList()
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     wrappers.forEach(block => {
       const first = block.nodes.first()
       const last = block.nodes.last()
@@ -1087,36 +1087,36 @@ Commands.unwrapBlockAtRange = (change, range, properties) => {
 
       if (first == firstMatch && last == lastMatch) {
         block.nodes.forEach((child, i) => {
-          change.moveNodeByKey(child.key, parent.key, index + i)
+          editor.moveNodeByKey(child.key, parent.key, index + i)
         })
 
-        change.removeNodeByKey(block.key)
+        editor.removeNodeByKey(block.key)
       } else if (last == lastMatch) {
         block.nodes.skipUntil(n => n == firstMatch).forEach((child, i) => {
-          change.moveNodeByKey(child.key, parent.key, index + 1 + i)
+          editor.moveNodeByKey(child.key, parent.key, index + 1 + i)
         })
       } else if (first == firstMatch) {
         block.nodes
           .takeUntil(n => n == lastMatch)
           .push(lastMatch)
           .forEach((child, i) => {
-            change.moveNodeByKey(child.key, parent.key, index + i)
+            editor.moveNodeByKey(child.key, parent.key, index + i)
           })
       } else {
         const firstText = firstMatch.getFirstText()
 
-        change.splitDescendantsByKey(block.key, firstText.key, 0)
+        editor.splitDescendantsByKey(block.key, firstText.key, 0)
 
-        document = change.value.document
+        document = editor.value.document
 
         children.forEach((child, i) => {
           if (i == 0) {
             const extra = child
             child = document.getNextBlock(child.key)
-            change.removeNodeByKey(extra.key)
+            editor.removeNodeByKey(extra.key)
           }
 
-          change.moveNodeByKey(child.key, parent.key, index + 1 + i)
+          editor.moveNodeByKey(child.key, parent.key, index + 1 + i)
         })
       }
     })
@@ -1126,15 +1126,15 @@ Commands.unwrapBlockAtRange = (change, range, properties) => {
 /**
  * Unwrap the inline nodes in a `range` from an inline with `properties`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {String|Object} properties
  */
 
-Commands.unwrapInlineAtRange = (change, range, properties) => {
+Commands.unwrapInlineAtRange = (editor, range, properties) => {
   properties = Node.createProperties(properties)
 
-  const { value } = change
+  const { value } = editor
   const { document } = value
   const texts = document.getTextsAtRange(range)
   const inlines = texts
@@ -1152,16 +1152,16 @@ Commands.unwrapInlineAtRange = (change, range, properties) => {
     .toOrderedSet()
     .toList()
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     inlines.forEach(inline => {
-      const parent = change.value.document.getParent(inline.key)
+      const parent = editor.value.document.getParent(inline.key)
       const index = parent.nodes.indexOf(inline)
 
       inline.nodes.forEach((child, i) => {
-        change.moveNodeByKey(child.key, parent.key, index + i)
+        editor.moveNodeByKey(child.key, parent.key, index + i)
       })
 
-      change.removeNodeByKey(inline.key)
+      editor.removeNodeByKey(inline.key)
     })
   })
 }
@@ -1169,16 +1169,16 @@ Commands.unwrapInlineAtRange = (change, range, properties) => {
 /**
  * Wrap all of the blocks in a `range` in a new `block`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Block|Object|String} block
  */
 
-Commands.wrapBlockAtRange = (change, range, block) => {
+Commands.wrapBlockAtRange = (editor, range, block) => {
   block = Block.create(block)
   block = block.set('nodes', block.nodes.clear())
 
-  const { value } = change
+  const { value } = editor
   const { document } = value
 
   const blocks = document.getBlocksAtRange(range)
@@ -1219,13 +1219,13 @@ Commands.wrapBlockAtRange = (change, range, block) => {
     index = parent.nodes.indexOf(siblings.first())
   }
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     // Inject the new block node into the parent.
-    change.insertNodeByKey(parent.key, index, block)
+    editor.insertNodeByKey(parent.key, index, block)
 
     // Move the sibling nodes into the new block node.
     siblings.forEach((node, i) => {
-      change.moveNodeByKey(node.key, block.key, i)
+      editor.moveNodeByKey(node.key, block.key, i)
     })
   })
 }
@@ -1233,13 +1233,13 @@ Commands.wrapBlockAtRange = (change, range, block) => {
 /**
  * Wrap the text and inlines in a `range` in a new `inline`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {Inline|Object|String} inline
  */
 
-Commands.wrapInlineAtRange = (change, range, inline) => {
-  const { value } = change
+Commands.wrapInlineAtRange = (editor, range, inline) => {
+  const { value } = editor
   let { document } = value
   const { start, end } = range
 
@@ -1247,11 +1247,11 @@ Commands.wrapInlineAtRange = (change, range, inline) => {
     // Wrapping an inline void
     const inlineParent = document.getClosestInline(start.key)
 
-    if (!change.isVoid(inlineParent)) {
+    if (!editor.isVoid(inlineParent)) {
       return
     }
 
-    return change.wrapInlineByKey(inlineParent.key, inline)
+    return editor.wrapInlineByKey(inlineParent.key, inline)
   }
 
   inline = Inline.create(inline)
@@ -1265,13 +1265,13 @@ Commands.wrapInlineAtRange = (change, range, inline) => {
   let startChild = startBlock.getFurthestAncestor(start.key)
   let endChild = endBlock.getFurthestAncestor(end.key)
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     if (!startInline || startInline != endInline) {
-      change.splitDescendantsByKey(endChild.key, end.key, end.offset)
-      change.splitDescendantsByKey(startChild.key, start.key, start.offset)
+      editor.splitDescendantsByKey(endChild.key, end.key, end.offset)
+      editor.splitDescendantsByKey(startChild.key, start.key, start.offset)
     }
 
-    document = change.value.document
+    document = editor.value.document
     startBlock = document.getDescendant(startBlock.key)
     endBlock = document.getDescendant(endBlock.key)
     startChild = startBlock.getFurthestAncestor(start.key)
@@ -1287,7 +1287,7 @@ Commands.wrapInlineAtRange = (change, range, inline) => {
         .splitText(end.offset - start.offset)[0]
 
       inline = inline.set('nodes', List([text]))
-      change.insertInlineAtRange(range, inline)
+      editor.insertInlineAtRange(range, inline)
 
       const inlinekey = inline.getFirstText().key
       const rng = {
@@ -1301,9 +1301,9 @@ Commands.wrapInlineAtRange = (change, range, inline) => {
         },
         isFocused: true,
       }
-      change.select(rng)
+      editor.select(rng)
     } else if (startBlock == endBlock) {
-      document = change.value.document
+      document = editor.value.document
       startBlock = document.getClosestBlock(start.key)
       startChild = startBlock.getFurthestAncestor(start.key)
 
@@ -1320,10 +1320,10 @@ Commands.wrapInlineAtRange = (change, range, inline) => {
 
       const node = inline.regenerateKey()
 
-      change.insertNodeByKey(startBlock.key, startInnerIndex, node)
+      editor.insertNodeByKey(startBlock.key, startInnerIndex, node)
 
       inlines.forEach((child, i) => {
-        change.moveNodeByKey(child.key, node.key, i)
+        editor.moveNodeByKey(child.key, node.key, i)
       })
     } else {
       const startInlines = startBlock.nodes.slice(startIndex + 1)
@@ -1331,23 +1331,23 @@ Commands.wrapInlineAtRange = (change, range, inline) => {
       const startNode = inline.regenerateKey()
       const endNode = inline.regenerateKey()
 
-      change.insertNodeByKey(startBlock.key, startIndex + 1, startNode)
-      change.insertNodeByKey(endBlock.key, endIndex, endNode)
+      editor.insertNodeByKey(startBlock.key, startIndex + 1, startNode)
+      editor.insertNodeByKey(endBlock.key, endIndex, endNode)
 
       startInlines.forEach((child, i) => {
-        change.moveNodeByKey(child.key, startNode.key, i)
+        editor.moveNodeByKey(child.key, startNode.key, i)
       })
 
       endInlines.forEach((child, i) => {
-        change.moveNodeByKey(child.key, endNode.key, i)
+        editor.moveNodeByKey(child.key, endNode.key, i)
       })
 
       blocks.slice(1, -1).forEach(block => {
         const node = inline.regenerateKey()
-        change.insertNodeByKey(block.key, 0, node)
+        editor.insertNodeByKey(block.key, 0, node)
 
         block.nodes.forEach((child, i) => {
-          change.moveNodeByKey(child.key, node.key, i)
+          editor.moveNodeByKey(child.key, node.key, i)
         })
       })
     }
@@ -1357,13 +1357,13 @@ Commands.wrapInlineAtRange = (change, range, inline) => {
 /**
  * Wrap the text in a `range` in a prefix/suffix.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Range} range
  * @param {String} prefix
  * @param {String} suffix (optional)
  */
 
-Commands.wrapTextAtRange = (change, range, prefix, suffix = prefix) => {
+Commands.wrapTextAtRange = (editor, range, prefix, suffix = prefix) => {
   const { start, end } = range
   const startRange = range.moveToStart()
   let endRange = range.moveToEnd()
@@ -1372,9 +1372,9 @@ Commands.wrapTextAtRange = (change, range, prefix, suffix = prefix) => {
     endRange = endRange.moveForward(prefix.length)
   }
 
-  change.withoutNormalizing(() => {
-    change.insertTextAtRange(startRange, prefix, [])
-    change.insertTextAtRange(endRange, suffix, [])
+  editor.withoutNormalizing(() => {
+    editor.insertTextAtRange(startRange, prefix, [])
+    editor.insertTextAtRange(endRange, suffix, [])
   })
 }
 
diff --git a/packages/slate/src/commands/by-path.js b/packages/slate/src/commands/by-path.js
index c3615e6c1..5333e7aef 100644
--- a/packages/slate/src/commands/by-path.js
+++ b/packages/slate/src/commands/by-path.js
@@ -15,16 +15,16 @@ const Commands = {}
 /**
  * Add mark to text at `offset` and `length` in node by `path`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Number} offset
  * @param {Number} length
  * @param {Mixed} mark
  */
 
-Commands.addMarkByPath = (change, path, offset, length, mark) => {
+Commands.addMarkByPath = (editor, path, offset, length, mark) => {
   mark = Mark.create(mark)
-  const { value } = change
+  const { value } = editor
   const { document } = value
   const node = document.assertNode(path)
   const leaves = node.getLeaves()
@@ -60,37 +60,37 @@ Commands.addMarkByPath = (change, path, offset, length, mark) => {
     })
   })
 
-  change.applyOperations(operations)
+  operations.forEach(op => editor.applyOperation(op))
 }
 
 /**
  * Insert a `fragment` at `index` in a node by `path`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Number} index
  * @param {Fragment} fragment
  */
 
-Commands.insertFragmentByPath = (change, path, index, fragment) => {
+Commands.insertFragmentByPath = (editor, path, index, fragment) => {
   fragment.nodes.forEach((node, i) => {
-    change.insertNodeByPath(path, index + i, node)
+    editor.insertNodeByPath(path, index + i, node)
   })
 }
 
 /**
  * Insert a `node` at `index` in a node by `path`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Number} index
  * @param {Node} node
  */
 
-Commands.insertNodeByPath = (change, path, index, node) => {
-  const { value } = change
+Commands.insertNodeByPath = (editor, path, index, node) => {
+  const { value } = editor
 
-  change.applyOperation({
+  editor.applyOperation({
     type: 'insert_node',
     value,
     path: path.concat(index),
@@ -101,15 +101,15 @@ Commands.insertNodeByPath = (change, path, index, node) => {
 /**
  * Insert `text` at `offset` in node by `path`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Number} offset
  * @param {String} text
  * @param {Set<Mark>} marks (optional)
  */
 
-Commands.insertTextByPath = (change, path, offset, text, marks) => {
-  const { value } = change
+Commands.insertTextByPath = (editor, path, offset, text, marks) => {
+  const { value } = editor
   const { decorations, document } = value
   const node = document.assertNode(path)
   marks = marks || node.getMarksAtIndex(offset)
@@ -119,7 +119,7 @@ Commands.insertTextByPath = (change, path, offset, text, marks) => {
 
   const decs = decorations.filter(dec => {
     const { start, end, mark } = dec
-    const isAtomic = change.isAtomic(mark)
+    const isAtomic = editor.isAtomic(mark)
     if (!isAtomic) return true
     if (start.key !== key) return true
 
@@ -132,10 +132,10 @@ Commands.insertTextByPath = (change, path, offset, text, marks) => {
   })
 
   if (updated) {
-    change.setValue({ decorations: decs })
+    editor.setDecorations(decs)
   }
 
-  change.applyOperation({
+  editor.applyOperation({
     type: 'insert_text',
     value,
     path,
@@ -148,12 +148,12 @@ Commands.insertTextByPath = (change, path, offset, text, marks) => {
 /**
  * Merge a node by `path` with the previous node.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  */
 
-Commands.mergeNodeByPath = (change, path) => {
-  const { value } = change
+Commands.mergeNodeByPath = (editor, path) => {
+  const { value } = editor
   const { document } = value
   const original = document.getDescendant(path)
   const previous = document.getPreviousSibling(path)
@@ -167,7 +167,7 @@ Commands.mergeNodeByPath = (change, path) => {
   const position =
     previous.object == 'text' ? previous.text.length : previous.nodes.size
 
-  change.applyOperation({
+  editor.applyOperation({
     type: 'merge_node',
     value,
     path,
@@ -185,22 +185,22 @@ Commands.mergeNodeByPath = (change, path) => {
 /**
  * Move a node by `path` to a new parent by `newPath` and `index`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {String} newPath
  * @param {Number} index
  */
 
-Commands.moveNodeByPath = (change, path, newPath, newIndex) => {
-  const { value } = change
+Commands.moveNodeByPath = (editor, path, newPath, newIndex) => {
+  const { value } = editor
 
   // If the operation path and newPath are the same,
   // this should be considered a NOOP
   if (PathUtils.isEqual(path, newPath)) {
-    return change
+    return editor
   }
 
-  change.applyOperation({
+  editor.applyOperation({
     type: 'move_node',
     value,
     path,
@@ -211,16 +211,16 @@ Commands.moveNodeByPath = (change, path, newPath, newIndex) => {
 /**
  * Remove mark from text at `offset` and `length` in node by `path`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Number} offset
  * @param {Number} length
  * @param {Mark} mark
  */
 
-Commands.removeMarkByPath = (change, path, offset, length, mark) => {
+Commands.removeMarkByPath = (editor, path, offset, length, mark) => {
   mark = Mark.create(mark)
-  const { value } = change
+  const { value } = editor
   const { document } = value
   const node = document.assertNode(path)
   const leaves = node.getLeaves()
@@ -256,25 +256,25 @@ Commands.removeMarkByPath = (change, path, offset, length, mark) => {
     })
   })
 
-  change.applyOperations(operations)
+  operations.forEach(op => editor.applyOperation(op))
 }
 
 /**
  * Remove all `marks` from node by `path`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  */
 
-Commands.removeAllMarksByPath = (change, path) => {
-  const { state } = change
+Commands.removeAllMarksByPath = (editor, path) => {
+  const { state } = editor
   const { document } = state
   const node = document.assertNode(path)
   const texts = node.object === 'text' ? [node] : node.getTextsAsArray()
 
   texts.forEach(text => {
     text.getMarksAsArray().forEach(mark => {
-      change.removeMarkByKey(text.key, 0, text.text.length, mark)
+      editor.removeMarkByKey(text.key, 0, text.text.length, mark)
     })
   })
 }
@@ -282,16 +282,16 @@ Commands.removeAllMarksByPath = (change, path) => {
 /**
  * Remove a node by `path`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  */
 
-Commands.removeNodeByPath = (change, path) => {
-  const { value } = change
+Commands.removeNodeByPath = (editor, path) => {
+  const { value } = editor
   const { document } = value
   const node = document.assertNode(path)
 
-  change.applyOperation({
+  editor.applyOperation({
     type: 'remove_node',
     value,
     path,
@@ -302,14 +302,14 @@ Commands.removeNodeByPath = (change, path) => {
 /**
  * Remove text at `offset` and `length` in node by `path`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Number} offset
  * @param {Number} length
  */
 
-Commands.removeTextByPath = (change, path, offset, length) => {
-  const { value } = change
+Commands.removeTextByPath = (editor, path, offset, length) => {
+  const { value } = editor
   const { decorations, document } = value
   const node = document.assertNode(path)
   const leaves = node.getLeaves()
@@ -322,7 +322,7 @@ Commands.removeTextByPath = (change, path, offset, length) => {
 
   const decs = decorations.filter(dec => {
     const { start, end, mark } = dec
-    const isAtomic = change.isAtomic(mark)
+    const isAtomic = editor.isAtomic(mark)
     if (!isAtomic) return true
     if (start.key !== key) return true
 
@@ -340,7 +340,7 @@ Commands.removeTextByPath = (change, path, offset, length) => {
   })
 
   if (updated) {
-    change.setValue({ decorations: decs })
+    editor.setDecorations(decs)
   }
 
   const removals = []
@@ -373,31 +373,31 @@ Commands.removeTextByPath = (change, path, offset, length) => {
   })
 
   // Apply in reverse order, so subsequent removals don't impact previous ones.
-  change.applyOperations(removals.reverse())
+  removals.reverse().forEach(op => editor.applyOperation(op))
 }
 
 /**
 `* Replace a `node` with another `node`
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Object|Node} node
  */
 
-Commands.replaceNodeByPath = (change, path, newNode) => {
+Commands.replaceNodeByPath = (editor, path, newNode) => {
   newNode = Node.create(newNode)
   const index = path.last()
   const parentPath = PathUtils.lift(path)
 
-  change.withoutNormalizing(() => {
-    change.removeNodeByPath(path)
-    change.insertNodeByPath(parentPath, index, newNode)
+  editor.withoutNormalizing(() => {
+    editor.removeNodeByPath(path)
+    editor.insertNodeByPath(parentPath, index, newNode)
   })
 }
 
 /**
  * Replace A Length of Text with another string or text
- * @param {Change} change
+ * @param {Editor} editor
  * @param {String} key
  * @param {Number} offset
  * @param {Number} length
@@ -405,8 +405,8 @@ Commands.replaceNodeByPath = (change, path, newNode) => {
  * @param {Set<Mark>} marks (optional)
  */
 
-Commands.replaceTextByPath = (change, path, offset, length, text, marks) => {
-  const { document } = change.value
+Commands.replaceTextByPath = (editor, path, offset, length, text, marks) => {
+  const { document } = editor.value
   const node = document.assertNode(path)
 
   if (length + offset > node.text.length) {
@@ -420,8 +420,8 @@ Commands.replaceTextByPath = (change, path, offset, length, text, marks) => {
 
   let activeMarks = document.getActiveMarksAtRange(range)
 
-  change.withoutNormalizing(() => {
-    change.removeTextByPath(path, offset, length)
+  editor.withoutNormalizing(() => {
+    editor.removeTextByPath(path, offset, length)
 
     if (!marks) {
       // Do not use mark at index when marks and activeMarks are both empty
@@ -436,26 +436,26 @@ Commands.replaceTextByPath = (change, path, offset, length, text, marks) => {
       marks = activeMarks.merge(marks)
     }
 
-    change.insertTextByPath(path, offset, text, marks)
+    editor.insertTextByPath(path, offset, text, marks)
   })
 }
 
 /**
  * Set `properties` on mark on text at `offset` and `length` in node by `path`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Number} offset
  * @param {Number} length
  * @param {Mark} mark
  */
 
-Commands.setMarkByPath = (change, path, offset, length, mark, properties) => {
+Commands.setMarkByPath = (editor, path, offset, length, mark, properties) => {
   mark = Mark.create(mark)
   properties = Mark.createProperties(properties)
-  const { value } = change
+  const { value } = editor
 
-  change.applyOperation({
+  editor.applyOperation({
     type: 'set_mark',
     value,
     path,
@@ -469,18 +469,18 @@ Commands.setMarkByPath = (change, path, offset, length, mark, properties) => {
 /**
  * Set `properties` on a node by `path`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Object|String} properties
  */
 
-Commands.setNodeByPath = (change, path, properties) => {
+Commands.setNodeByPath = (editor, path, properties) => {
   properties = Node.createProperties(properties)
-  const { value } = change
+  const { value } = editor
   const { document } = value
   const node = document.assertNode(path)
 
-  change.applyOperation({
+  editor.applyOperation({
     type: 'set_node',
     value,
     path,
@@ -492,36 +492,36 @@ Commands.setNodeByPath = (change, path, properties) => {
 /**
  * Insert `text` at `offset` in node by `path`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {String} text
  * @param {Set<Mark>} marks (optional)
  */
 
-Commands.setTextByPath = (change, path, text, marks) => {
-  const { value } = change
+Commands.setTextByPath = (editor, path, text, marks) => {
+  const { value } = editor
   const { document } = value
   const node = document.assertNode(path)
   const end = node.text.length
-  change.replaceTextByPath(path, 0, end, text, marks)
+  editor.replaceTextByPath(path, 0, end, text, marks)
 }
 
 /**
  * Split a node by `path` at `position`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Number} position
  * @param {Object} options
  */
 
-Commands.splitNodeByPath = (change, path, position, options = {}) => {
+Commands.splitNodeByPath = (editor, path, position, options = {}) => {
   const { target = null } = options
-  const { value } = change
+  const { value } = editor
   const { document } = value
   const node = document.getDescendant(path)
 
-  change.applyOperation({
+  editor.applyOperation({
     type: 'split_node',
     value,
     path,
@@ -537,19 +537,19 @@ Commands.splitNodeByPath = (change, path, position, options = {}) => {
 /**
  * Split a node deeply down the tree by `path`, `textPath` and `textOffset`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Array} textPath
  * @param {Number} textOffset
  */
 
-Commands.splitDescendantsByPath = (change, path, textPath, textOffset) => {
+Commands.splitDescendantsByPath = (editor, path, textPath, textOffset) => {
   if (path.equals(textPath)) {
-    change.splitNodeByPath(textPath, textOffset)
+    editor.splitNodeByPath(textPath, textOffset)
     return
   }
 
-  const { value } = change
+  const { value } = editor
   const { document } = value
   const node = document.assertNode(path)
   const text = document.assertNode(textPath)
@@ -562,12 +562,12 @@ Commands.splitDescendantsByPath = (change, path, textPath, textOffset) => {
   let previous
   let index
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     nodes.forEach(n => {
       const prevIndex = index == null ? null : index
       index = previous ? n.nodes.indexOf(previous) + 1 : textOffset
       previous = n
-      change.splitNodeByKey(n.key, index, { target: prevIndex })
+      editor.splitNodeByKey(n.key, index, { target: prevIndex })
     })
   })
 }
@@ -575,37 +575,37 @@ Commands.splitDescendantsByPath = (change, path, textPath, textOffset) => {
 /**
  * Unwrap content from an inline parent with `properties`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Object|String} properties
  */
 
-Commands.unwrapInlineByPath = (change, path, properties) => {
-  const { value } = change
+Commands.unwrapInlineByPath = (editor, path, properties) => {
+  const { value } = editor
   const { document, selection } = value
   const node = document.assertNode(path)
   const first = node.getFirstText()
   const last = node.getLastText()
   const range = selection.moveToRangeOfNode(first, last)
-  change.unwrapInlineAtRange(range, properties)
+  editor.unwrapInlineAtRange(range, properties)
 }
 
 /**
  * Unwrap content from a block parent with `properties`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Object|String} properties
  */
 
-Commands.unwrapBlockByPath = (change, path, properties) => {
-  const { value } = change
+Commands.unwrapBlockByPath = (editor, path, properties) => {
+  const { value } = editor
   const { document, selection } = value
   const node = document.assertNode(path)
   const first = node.getFirstText()
   const last = node.getLastText()
   const range = selection.moveToRangeOfNode(first, last)
-  change.unwrapBlockAtRange(range, properties)
+  editor.unwrapBlockAtRange(range, properties)
 }
 
 /**
@@ -615,12 +615,12 @@ Commands.unwrapBlockByPath = (change, path, properties) => {
  * split. If the node is the only child, the parent is removed, and
  * simply replaced by the node itself.  Cannot unwrap a root node.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  */
 
-Commands.unwrapNodeByPath = (change, path) => {
-  const { value } = change
+Commands.unwrapNodeByPath = (editor, path) => {
+  const { value } = editor
   const { document } = value
   document.assertNode(path)
 
@@ -632,19 +632,19 @@ Commands.unwrapNodeByPath = (change, path) => {
   const isFirst = index === 0
   const isLast = index === parent.nodes.size - 1
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     if (parent.nodes.size === 1) {
-      change.moveNodeByPath(path, grandPath, parentIndex + 1)
-      change.removeNodeByPath(parentPath)
+      editor.moveNodeByPath(path, grandPath, parentIndex + 1)
+      editor.removeNodeByPath(parentPath)
     } else if (isFirst) {
-      change.moveNodeByPath(path, grandPath, parentIndex)
+      editor.moveNodeByPath(path, grandPath, parentIndex)
     } else if (isLast) {
-      change.moveNodeByPath(path, grandPath, parentIndex + 1)
+      editor.moveNodeByPath(path, grandPath, parentIndex + 1)
     } else {
       let updatedPath = PathUtils.increment(path, 1, parentPath.size - 1)
       updatedPath = updatedPath.set(updatedPath.size - 1, 0)
-      change.splitNodeByPath(parentPath, index)
-      change.moveNodeByPath(updatedPath, grandPath, parentIndex + 1)
+      editor.splitNodeByPath(parentPath, index)
+      editor.moveNodeByPath(updatedPath, grandPath, parentIndex + 1)
     }
   })
 }
@@ -653,87 +653,87 @@ Commands.unwrapNodeByPath = (change, path) => {
  * Unwrap all of the children of a node, by removing the node and replacing it
  * with the children in the tree.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  */
 
-Commands.unwrapChildrenByPath = (change, path) => {
+Commands.unwrapChildrenByPath = (editor, path) => {
   path = PathUtils.create(path)
-  const { value } = change
+  const { value } = editor
   const { document } = value
   const node = document.assertNode(path)
   const parentPath = PathUtils.lift(path)
   const index = path.last()
   const { nodes } = node
 
-  change.withoutNormalizing(() => {
+  editor.withoutNormalizing(() => {
     nodes.reverse().forEach((child, i) => {
       const childIndex = nodes.size - i - 1
       const childPath = path.push(childIndex)
-      change.moveNodeByPath(childPath, parentPath, index + 1)
+      editor.moveNodeByPath(childPath, parentPath, index + 1)
     })
 
-    change.removeNodeByPath(path)
+    editor.removeNodeByPath(path)
   })
 }
 
 /**
  * Wrap a node in a block with `properties`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Block|Object|String} block
  */
 
-Commands.wrapBlockByPath = (change, path, block) => {
+Commands.wrapBlockByPath = (editor, path, block) => {
   block = Block.create(block)
   block = block.set('nodes', block.nodes.clear())
   const parentPath = PathUtils.lift(path)
   const index = path.last()
   const newPath = PathUtils.increment(path)
 
-  change.withoutNormalizing(() => {
-    change.insertNodeByPath(parentPath, index, block)
-    change.moveNodeByPath(newPath, path, 0)
+  editor.withoutNormalizing(() => {
+    editor.insertNodeByPath(parentPath, index, block)
+    editor.moveNodeByPath(newPath, path, 0)
   })
 }
 
 /**
  * Wrap a node in an inline with `properties`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Block|Object|String} inline
  */
 
-Commands.wrapInlineByPath = (change, path, inline) => {
+Commands.wrapInlineByPath = (editor, path, inline) => {
   inline = Inline.create(inline)
   inline = inline.set('nodes', inline.nodes.clear())
   const parentPath = PathUtils.lift(path)
   const index = path.last()
   const newPath = PathUtils.increment(path)
 
-  change.withoutNormalizing(() => {
-    change.insertNodeByPath(parentPath, index, inline)
-    change.moveNodeByPath(newPath, path, 0)
+  editor.withoutNormalizing(() => {
+    editor.insertNodeByPath(parentPath, index, inline)
+    editor.moveNodeByPath(newPath, path, 0)
   })
 }
 
 /**
  * Wrap a node by `path` with `node`.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Array} path
  * @param {Node|Object} node
  */
 
-Commands.wrapNodeByPath = (change, path, node) => {
+Commands.wrapNodeByPath = (editor, path, node) => {
   node = Node.create(node)
 
   if (node.object === 'block') {
-    change.wrapBlockByPath(path, node)
+    editor.wrapBlockByPath(path, node)
   } else if (node.object === 'inline') {
-    change.wrapInlineByPath(path, node)
+    editor.wrapInlineByPath(path, node)
   }
 }
 
@@ -767,30 +767,30 @@ const COMMANDS = [
 ]
 
 for (const method of COMMANDS) {
-  Commands[`${method}ByKey`] = (change, key, ...args) => {
-    const { value } = change
+  Commands[`${method}ByKey`] = (editor, key, ...args) => {
+    const { value } = editor
     const { document } = value
     const path = document.assertPath(key)
-    change[`${method}ByPath`](path, ...args)
+    editor[`${method}ByPath`](path, ...args)
   }
 }
 
 // Moving nodes takes two keys, so it's slightly different.
-Commands.moveNodeByKey = (change, key, newKey, ...args) => {
-  const { value } = change
+Commands.moveNodeByKey = (editor, key, newKey, ...args) => {
+  const { value } = editor
   const { document } = value
   const path = document.assertPath(key)
   const newPath = document.assertPath(newKey)
-  change.moveNodeByPath(path, newPath, ...args)
+  editor.moveNodeByPath(path, newPath, ...args)
 }
 
 // Splitting descendants takes two keys, so it's slightly different.
-Commands.splitDescendantsByKey = (change, key, textKey, ...args) => {
-  const { value } = change
+Commands.splitDescendantsByKey = (editor, key, textKey, ...args) => {
+  const { value } = editor
   const { document } = value
   const path = document.assertPath(key)
   const textPath = document.assertPath(textKey)
-  change.splitDescendantsByPath(path, textPath, ...args)
+  editor.splitDescendantsByPath(path, textPath, ...args)
 }
 
 /**
diff --git a/packages/slate/src/commands/on-history.js b/packages/slate/src/commands/on-history.js
index c9f6c1a32..65c241997 100644
--- a/packages/slate/src/commands/on-history.js
+++ b/packages/slate/src/commands/on-history.js
@@ -12,14 +12,14 @@ const Commands = {}
 /**
  * Save an `operation` into the history.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Object} operation
  */
 
-Commands.save = (change, operation) => {
-  const { operations, value } = change
+Commands.save = (editor, operation) => {
+  const { operations, value } = editor
   const { data } = value
-  let { save, merge } = change.tmp
+  let { save, merge } = editor.tmp
   if (save === false) return
 
   let undos = data.get('undos') || List()
@@ -27,7 +27,7 @@ Commands.save = (change, operation) => {
   const lastOperation = lastBatch && lastBatch.last()
 
   // If `merge` is non-commital, and this is not the first operation in a new
-  // change, then merge, otherwise merge based on the last operation.
+  // editor, then merge, otherwise merge based on the last operation.
   if (merge == null) {
     if (operations.size !== 0) {
       merge = true
@@ -53,28 +53,28 @@ Commands.save = (change, operation) => {
   }
 
   // Clear the redos and update the history.
-  change.withoutSaving(() => {
+  editor.withoutSaving(() => {
     const redos = List()
     const newData = data.set('undos', undos).set('redos', redos)
-    change.setValue({ data: newData })
+    editor.setData(newData)
   })
 }
 
 /**
  * Redo to the next value in the history.
  *
- * @param {Change} change
+ * @param {Editor} editor
  */
 
-Commands.redo = change => {
-  const { value } = change
+Commands.redo = editor => {
+  const { value } = editor
   const { data } = value
   let redos = data.get('redos') || List()
   let undos = data.get('undos') || List()
   const batch = redos.last()
   if (!batch) return
 
-  change.withoutSaving(() => {
+  editor.withoutSaving(() => {
     // Replay the batch of operations.
     batch.forEach(op => {
       const { type, properties } = op
@@ -85,32 +85,32 @@ Commands.redo = change => {
         op = op.set('properties', omit(properties, 'isFocused'))
       }
 
-      change.applyOperation(op)
+      editor.applyOperation(op)
     })
 
     // Shift the next value into the undo stack.
     redos = redos.pop()
     undos = undos.push(batch)
     const newData = data.set('undos', undos).set('redos', redos)
-    change.setValue({ data: newData })
+    editor.setData(newData)
   })
 }
 
 /**
  * Undo the previous operations in the history.
  *
- * @param {Change} change
+ * @param {Editor} editor
  */
 
-Commands.undo = change => {
-  const { value } = change
+Commands.undo = editor => {
+  const { value } = editor
   const { data } = value
   let redos = data.get('redos') || List()
   let undos = data.get('undos') || List()
   const batch = undos.last()
   if (!batch) return
 
-  change.withoutSaving(() => {
+  editor.withoutSaving(() => {
     // Replay the inverse of the previous operations.
     batch
       .slice()
@@ -125,14 +125,14 @@ Commands.undo = change => {
           inverse = inverse.set('properties', omit(properties, 'isFocused'))
         }
 
-        change.applyOperation(inverse)
+        editor.applyOperation(inverse)
       })
 
     // Shift the previous operations into the redo stack.
     redos = redos.push(batch)
     undos = undos.pop()
     const newData = data.set('undos', undos).set('redos', redos)
-    change.setValue({ data: newData })
+    editor.setData(newData)
   })
 }
 
@@ -140,30 +140,30 @@ Commands.undo = change => {
  * Apply a series of changes inside a synchronous `fn`, without merging any of
  * the new operations into previous save point in the history.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Function} fn
  */
 
-Commands.withoutMerging = (change, fn) => {
-  const value = change.tmp.merge
-  change.tmp.merge = false
-  fn(change)
-  change.tmp.merge = value
+Commands.withoutMerging = (editor, fn) => {
+  const value = editor.tmp.merge
+  editor.tmp.merge = false
+  fn(editor)
+  editor.tmp.merge = value
 }
 
 /**
  * Apply a series of changes inside a synchronous `fn`, without saving any of
  * their operations into the history.
  *
- * @param {Change}
+ * @param {Editor} editor
  * @param {Function} fn
  */
 
-Commands.withoutSaving = (change, fn) => {
-  const value = change.tmp.save
-  change.tmp.save = false
-  fn(change)
-  change.tmp.save = value
+Commands.withoutSaving = (editor, fn) => {
+  const value = editor.tmp.save
+  editor.tmp.save = false
+  fn(editor)
+  editor.tmp.save = value
 }
 
 /**
diff --git a/packages/slate/src/commands/on-selection.js b/packages/slate/src/commands/on-selection.js
index 13336b006..245c07f6d 100644
--- a/packages/slate/src/commands/on-selection.js
+++ b/packages/slate/src/commands/on-selection.js
@@ -6,591 +6,591 @@ import TextUtils from '../utils/text-utils'
 
 const Commands = {}
 
-Commands.blur = change => {
-  change.select({ isFocused: false })
+Commands.blur = editor => {
+  editor.select({ isFocused: false })
 }
 
-Commands.deselect = change => {
+Commands.deselect = editor => {
   const range = Selection.create()
-  change.select(range)
+  editor.select(range)
 }
 
-Commands.focus = change => {
-  change.select({ isFocused: true })
+Commands.focus = editor => {
+  editor.select({ isFocused: true })
 }
 
-Commands.flip = change => {
-  change.call(proxy, 'flip')
+Commands.flip = editor => {
+  editor.command(proxy, 'flip')
 }
 
-Commands.moveAnchorBackward = (change, ...args) => {
-  change.call(pointBackward, 'anchor', ...args)
+Commands.moveAnchorBackward = (editor, ...args) => {
+  editor.command(pointBackward, 'anchor', ...args)
 }
 
-Commands.moveAnchorWordBackward = (change, ...args) => {
-  change.call(pointWordBackward, 'anchor', ...args)
+Commands.moveAnchorWordBackward = (editor, ...args) => {
+  editor.command(pointWordBackward, 'anchor', ...args)
 }
 
-Commands.moveAnchorForward = (change, ...args) => {
-  change.call(pointForward, 'anchor', ...args)
+Commands.moveAnchorForward = (editor, ...args) => {
+  editor.command(pointForward, 'anchor', ...args)
 }
 
-Commands.moveAnchorWordForward = (change, ...args) => {
-  change.call(pointWordForward, 'anchor', ...args)
+Commands.moveAnchorWordForward = (editor, ...args) => {
+  editor.command(pointWordForward, 'anchor', ...args)
 }
 
-Commands.moveAnchorTo = (change, ...args) => {
-  change.call(proxy, 'moveAnchorTo', ...args)
+Commands.moveAnchorTo = (editor, ...args) => {
+  editor.command(proxy, 'moveAnchorTo', ...args)
 }
 
-Commands.moveAnchorToEndOfBlock = change => {
-  change.call(pointEdgeObject, 'anchor', 'end', 'block')
+Commands.moveAnchorToEndOfBlock = editor => {
+  editor.command(pointEdgeObject, 'anchor', 'end', 'block')
 }
 
-Commands.moveAnchorToEndOfInline = change => {
-  change.call(pointEdgeObject, 'anchor', 'end', 'inline')
+Commands.moveAnchorToEndOfInline = editor => {
+  editor.command(pointEdgeObject, 'anchor', 'end', 'inline')
 }
 
-Commands.moveAnchorToEndOfDocument = change => {
-  change.moveAnchorToEndOfNode(change.value.document).moveToAnchor()
+Commands.moveAnchorToEndOfDocument = editor => {
+  editor.moveAnchorToEndOfNode(editor.value.document).moveToAnchor()
 }
 
-Commands.moveAnchorToEndOfNextBlock = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'end', 'next', 'block')
+Commands.moveAnchorToEndOfNextBlock = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'end', 'next', 'block')
 }
 
-Commands.moveAnchorToEndOfNextInline = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'end', 'next', 'inline')
+Commands.moveAnchorToEndOfNextInline = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'end', 'next', 'inline')
 }
 
-Commands.moveAnchorToEndOfNextText = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'end', 'next', 'text')
+Commands.moveAnchorToEndOfNextText = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'end', 'next', 'text')
 }
 
-Commands.moveAnchorToEndOfNode = (change, ...args) => {
-  change.call(proxy, 'moveAnchorToEndOfNode', ...args)
+Commands.moveAnchorToEndOfNode = (editor, ...args) => {
+  editor.command(proxy, 'moveAnchorToEndOfNode', ...args)
 }
 
-Commands.moveAnchorToEndOfPreviousBlock = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'end', 'previous', 'block')
+Commands.moveAnchorToEndOfPreviousBlock = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'end', 'previous', 'block')
 }
 
-Commands.moveAnchorToEndOfPreviousInline = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'end', 'previous', 'inline')
+Commands.moveAnchorToEndOfPreviousInline = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'end', 'previous', 'inline')
 }
 
-Commands.moveAnchorToEndOfPreviousText = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'end', 'previous', 'text')
+Commands.moveAnchorToEndOfPreviousText = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'end', 'previous', 'text')
 }
 
-Commands.moveAnchorToEndOfText = change => {
-  change.call(pointEdgeObject, 'anchor', 'end', 'text')
+Commands.moveAnchorToEndOfText = editor => {
+  editor.command(pointEdgeObject, 'anchor', 'end', 'text')
 }
 
-Commands.moveAnchorToStartOfBlock = change => {
-  change.call(pointEdgeObject, 'anchor', 'start', 'block')
+Commands.moveAnchorToStartOfBlock = editor => {
+  editor.command(pointEdgeObject, 'anchor', 'start', 'block')
 }
 
-Commands.moveAnchorToStartOfDocument = change => {
-  change.moveAnchorToStartOfNode(change.value.document).moveToAnchor()
+Commands.moveAnchorToStartOfDocument = editor => {
+  editor.moveAnchorToStartOfNode(editor.value.document).moveToAnchor()
 }
 
-Commands.moveAnchorToStartOfInline = change => {
-  change.call(pointEdgeObject, 'anchor', 'start', 'inline')
+Commands.moveAnchorToStartOfInline = editor => {
+  editor.command(pointEdgeObject, 'anchor', 'start', 'inline')
 }
 
-Commands.moveAnchorToStartOfNextBlock = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'start', 'next', 'block')
+Commands.moveAnchorToStartOfNextBlock = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'start', 'next', 'block')
 }
 
-Commands.moveAnchorToStartOfNextInline = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'start', 'next', 'inline')
+Commands.moveAnchorToStartOfNextInline = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'start', 'next', 'inline')
 }
 
-Commands.moveAnchorToStartOfNextText = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'start', 'next', 'text')
+Commands.moveAnchorToStartOfNextText = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'start', 'next', 'text')
 }
 
-Commands.moveAnchorToStartOfNode = (change, ...args) => {
-  change.call(proxy, 'moveAnchorToStartOfNode', ...args)
+Commands.moveAnchorToStartOfNode = (editor, ...args) => {
+  editor.command(proxy, 'moveAnchorToStartOfNode', ...args)
 }
 
-Commands.moveAnchorToStartOfPreviousBlock = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'start', 'previous', 'block')
+Commands.moveAnchorToStartOfPreviousBlock = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'start', 'previous', 'block')
 }
 
-Commands.moveAnchorToStartOfPreviousInline = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'start', 'previous', 'inline')
+Commands.moveAnchorToStartOfPreviousInline = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'start', 'previous', 'inline')
 }
 
-Commands.moveAnchorToStartOfPreviousText = change => {
-  change.call(pointEdgeSideObject, 'anchor', 'start', 'previous', 'text')
+Commands.moveAnchorToStartOfPreviousText = editor => {
+  editor.command(pointEdgeSideObject, 'anchor', 'start', 'previous', 'text')
 }
 
-Commands.moveAnchorToStartOfText = change => {
-  change.call(pointEdgeObject, 'anchor', 'start', 'text')
+Commands.moveAnchorToStartOfText = editor => {
+  editor.command(pointEdgeObject, 'anchor', 'start', 'text')
 }
 
-Commands.moveBackward = (change, ...args) => {
-  change.moveAnchorBackward(...args).moveFocusBackward(...args)
+Commands.moveBackward = (editor, ...args) => {
+  editor.moveAnchorBackward(...args).moveFocusBackward(...args)
 }
 
-Commands.moveWordBackward = (change, ...args) => {
-  change.moveFocusWordBackward(...args).moveToFocus()
+Commands.moveWordBackward = (editor, ...args) => {
+  editor.moveFocusWordBackward(...args).moveToFocus()
 }
 
-Commands.moveEndBackward = (change, ...args) => {
-  change.call(pointBackward, 'end', ...args)
+Commands.moveEndBackward = (editor, ...args) => {
+  editor.command(pointBackward, 'end', ...args)
 }
 
-Commands.moveEndWordBackward = (change, ...args) => {
-  change.call(pointWordBackward, 'end', ...args)
+Commands.moveEndWordBackward = (editor, ...args) => {
+  editor.command(pointWordBackward, 'end', ...args)
 }
 
-Commands.moveEndForward = (change, ...args) => {
-  change.call(pointForward, 'end', ...args)
+Commands.moveEndForward = (editor, ...args) => {
+  editor.command(pointForward, 'end', ...args)
 }
 
-Commands.moveEndWordForward = (change, ...args) => {
-  change.call(pointWordForward, 'end', ...args)
+Commands.moveEndWordForward = (editor, ...args) => {
+  editor.command(pointWordForward, 'end', ...args)
 }
 
-Commands.moveEndTo = (change, ...args) => {
-  change.call(proxy, 'moveEndTo', ...args)
+Commands.moveEndTo = (editor, ...args) => {
+  editor.command(proxy, 'moveEndTo', ...args)
 }
 
-Commands.moveEndToEndOfBlock = change => {
-  change.call(pointEdgeObject, 'end', 'end', 'block')
+Commands.moveEndToEndOfBlock = editor => {
+  editor.command(pointEdgeObject, 'end', 'end', 'block')
 }
 
-Commands.moveEndToEndOfDocument = change => {
-  change.moveEndToEndOfNode(change.value.document).moveToEnd()
+Commands.moveEndToEndOfDocument = editor => {
+  editor.moveEndToEndOfNode(editor.value.document).moveToEnd()
 }
 
-Commands.moveEndToEndOfInline = change => {
-  change.call(pointEdgeObject, 'end', 'end', 'inline')
+Commands.moveEndToEndOfInline = editor => {
+  editor.command(pointEdgeObject, 'end', 'end', 'inline')
 }
 
-Commands.moveEndToEndOfNextBlock = change => {
-  change.call(pointEdgeSideObject, 'end', 'end', 'next', 'block')
+Commands.moveEndToEndOfNextBlock = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'end', 'next', 'block')
 }
 
-Commands.moveEndToEndOfNextInline = change => {
-  change.call(pointEdgeSideObject, 'end', 'end', 'next', 'inline')
+Commands.moveEndToEndOfNextInline = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'end', 'next', 'inline')
 }
 
-Commands.moveEndToEndOfNextText = change => {
-  change.call(pointEdgeSideObject, 'end', 'end', 'next', 'text')
+Commands.moveEndToEndOfNextText = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'end', 'next', 'text')
 }
 
-Commands.moveEndToEndOfNode = (change, ...args) => {
-  change.call(proxy, 'moveEndToEndOfNode', ...args)
+Commands.moveEndToEndOfNode = (editor, ...args) => {
+  editor.command(proxy, 'moveEndToEndOfNode', ...args)
 }
 
-Commands.moveEndToEndOfPreviousBlock = change => {
-  change.call(pointEdgeSideObject, 'end', 'end', 'previous', 'block')
+Commands.moveEndToEndOfPreviousBlock = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'end', 'previous', 'block')
 }
 
-Commands.moveEndToEndOfPreviousInline = change => {
-  change.call(pointEdgeSideObject, 'end', 'end', 'previous', 'inline')
+Commands.moveEndToEndOfPreviousInline = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'end', 'previous', 'inline')
 }
 
-Commands.moveEndToEndOfPreviousText = change => {
-  change.call(pointEdgeSideObject, 'end', 'end', 'previous', 'text')
+Commands.moveEndToEndOfPreviousText = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'end', 'previous', 'text')
 }
 
-Commands.moveEndToEndOfText = change => {
-  change.call(pointEdgeObject, 'end', 'end', 'text')
+Commands.moveEndToEndOfText = editor => {
+  editor.command(pointEdgeObject, 'end', 'end', 'text')
 }
 
-Commands.moveEndToStartOfBlock = change => {
-  change.call(pointEdgeObject, 'end', 'start', 'block')
+Commands.moveEndToStartOfBlock = editor => {
+  editor.command(pointEdgeObject, 'end', 'start', 'block')
 }
 
-Commands.moveEndToStartOfDocument = change => {
-  change.moveEndToStartOfNode(change.value.document).moveToEnd()
+Commands.moveEndToStartOfDocument = editor => {
+  editor.moveEndToStartOfNode(editor.value.document).moveToEnd()
 }
 
-Commands.moveEndToStartOfInline = change => {
-  change.call(pointEdgeObject, 'end', 'start', 'inline')
+Commands.moveEndToStartOfInline = editor => {
+  editor.command(pointEdgeObject, 'end', 'start', 'inline')
 }
 
-Commands.moveEndToStartOfNextBlock = change => {
-  change.call(pointEdgeSideObject, 'end', 'start', 'next', 'block')
+Commands.moveEndToStartOfNextBlock = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'start', 'next', 'block')
 }
 
-Commands.moveEndToStartOfNextInline = change => {
-  change.call(pointEdgeSideObject, 'end', 'start', 'next', 'inline')
+Commands.moveEndToStartOfNextInline = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'start', 'next', 'inline')
 }
 
-Commands.moveEndToStartOfNextText = change => {
-  change.call(pointEdgeSideObject, 'end', 'start', 'next', 'text')
+Commands.moveEndToStartOfNextText = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'start', 'next', 'text')
 }
 
-Commands.moveEndToStartOfNode = (change, ...args) => {
-  change.call(proxy, 'moveEndToStartOfNode', ...args)
+Commands.moveEndToStartOfNode = (editor, ...args) => {
+  editor.command(proxy, 'moveEndToStartOfNode', ...args)
 }
 
-Commands.moveEndToStartOfPreviousBlock = change => {
-  change.call(pointEdgeSideObject, 'end', 'start', 'previous', 'block')
+Commands.moveEndToStartOfPreviousBlock = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'start', 'previous', 'block')
 }
 
-Commands.moveEndToStartOfPreviousInline = change => {
-  change.call(pointEdgeSideObject, 'end', 'start', 'previous', 'inline')
+Commands.moveEndToStartOfPreviousInline = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'start', 'previous', 'inline')
 }
 
-Commands.moveEndToStartOfPreviousText = change => {
-  change.call(pointEdgeSideObject, 'end', 'start', 'previous', 'text')
+Commands.moveEndToStartOfPreviousText = editor => {
+  editor.command(pointEdgeSideObject, 'end', 'start', 'previous', 'text')
 }
 
-Commands.moveEndToStartOfText = change => {
-  change.call(pointEdgeObject, 'end', 'start', 'text')
+Commands.moveEndToStartOfText = editor => {
+  editor.command(pointEdgeObject, 'end', 'start', 'text')
 }
 
-Commands.moveFocusBackward = (change, ...args) => {
-  change.call(pointBackward, 'focus', ...args)
+Commands.moveFocusBackward = (editor, ...args) => {
+  editor.command(pointBackward, 'focus', ...args)
 }
 
-Commands.moveFocusWordBackward = (change, ...args) => {
-  change.call(pointWordBackward, 'focus', ...args)
+Commands.moveFocusWordBackward = (editor, ...args) => {
+  editor.command(pointWordBackward, 'focus', ...args)
 }
 
-Commands.moveFocusForward = (change, ...args) => {
-  change.call(pointForward, 'focus', ...args)
+Commands.moveFocusForward = (editor, ...args) => {
+  editor.command(pointForward, 'focus', ...args)
 }
 
-Commands.moveFocusWordForward = (change, ...args) => {
-  change.call(pointWordForward, 'focus', ...args)
+Commands.moveFocusWordForward = (editor, ...args) => {
+  editor.command(pointWordForward, 'focus', ...args)
 }
 
-Commands.moveFocusTo = (change, ...args) => {
-  change.call(proxy, 'moveFocusTo', ...args)
+Commands.moveFocusTo = (editor, ...args) => {
+  editor.command(proxy, 'moveFocusTo', ...args)
 }
 
-Commands.moveFocusToEndOfBlock = change => {
-  change.call(pointEdgeObject, 'focus', 'end', 'block')
+Commands.moveFocusToEndOfBlock = editor => {
+  editor.command(pointEdgeObject, 'focus', 'end', 'block')
 }
 
-Commands.moveFocusToEndOfDocument = change => {
-  change.moveFocusToEndOfNode(change.value.document).moveToFocus()
+Commands.moveFocusToEndOfDocument = editor => {
+  editor.moveFocusToEndOfNode(editor.value.document).moveToFocus()
 }
 
-Commands.moveFocusToEndOfInline = change => {
-  change.call(pointEdgeObject, 'focus', 'end', 'inline')
+Commands.moveFocusToEndOfInline = editor => {
+  editor.command(pointEdgeObject, 'focus', 'end', 'inline')
 }
 
-Commands.moveFocusToEndOfNextBlock = change => {
-  change.call(pointEdgeSideObject, 'focus', 'end', 'next', 'block')
+Commands.moveFocusToEndOfNextBlock = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'end', 'next', 'block')
 }
 
-Commands.moveFocusToEndOfNextInline = change => {
-  change.call(pointEdgeSideObject, 'focus', 'end', 'next', 'inline')
+Commands.moveFocusToEndOfNextInline = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'end', 'next', 'inline')
 }
 
-Commands.moveFocusToEndOfNextText = change => {
-  change.call(pointEdgeSideObject, 'focus', 'end', 'next', 'text')
+Commands.moveFocusToEndOfNextText = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'end', 'next', 'text')
 }
 
-Commands.moveFocusToEndOfNode = (change, ...args) => {
-  change.call(proxy, 'moveFocusToEndOfNode', ...args)
+Commands.moveFocusToEndOfNode = (editor, ...args) => {
+  editor.command(proxy, 'moveFocusToEndOfNode', ...args)
 }
 
-Commands.moveFocusToEndOfPreviousBlock = change => {
-  change.call(pointEdgeSideObject, 'focus', 'end', 'previous', 'block')
+Commands.moveFocusToEndOfPreviousBlock = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'end', 'previous', 'block')
 }
 
-Commands.moveFocusToEndOfPreviousInline = change => {
-  change.call(pointEdgeSideObject, 'focus', 'end', 'previous', 'inline')
+Commands.moveFocusToEndOfPreviousInline = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'end', 'previous', 'inline')
 }
 
-Commands.moveFocusToEndOfPreviousText = change => {
-  change.call(pointEdgeSideObject, 'focus', 'end', 'previous', 'text')
+Commands.moveFocusToEndOfPreviousText = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'end', 'previous', 'text')
 }
 
-Commands.moveFocusToEndOfText = change => {
-  change.call(pointEdgeObject, 'focus', 'end', 'text')
+Commands.moveFocusToEndOfText = editor => {
+  editor.command(pointEdgeObject, 'focus', 'end', 'text')
 }
 
-Commands.moveFocusToStartOfBlock = change => {
-  change.call(pointEdgeObject, 'focus', 'start', 'block')
+Commands.moveFocusToStartOfBlock = editor => {
+  editor.command(pointEdgeObject, 'focus', 'start', 'block')
 }
 
-Commands.moveFocusToStartOfDocument = change => {
-  change.moveFocusToStartOfNode(change.value.document).moveToFocus()
+Commands.moveFocusToStartOfDocument = editor => {
+  editor.moveFocusToStartOfNode(editor.value.document).moveToFocus()
 }
 
-Commands.moveFocusToStartOfInline = change => {
-  change.call(pointEdgeObject, 'focus', 'start', 'inline')
+Commands.moveFocusToStartOfInline = editor => {
+  editor.command(pointEdgeObject, 'focus', 'start', 'inline')
 }
 
-Commands.moveFocusToStartOfNextBlock = change => {
-  change.call(pointEdgeSideObject, 'focus', 'start', 'next', 'block')
+Commands.moveFocusToStartOfNextBlock = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'start', 'next', 'block')
 }
 
-Commands.moveFocusToStartOfNextInline = change => {
-  change.call(pointEdgeSideObject, 'focus', 'start', 'next', 'inline')
+Commands.moveFocusToStartOfNextInline = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'start', 'next', 'inline')
 }
 
-Commands.moveFocusToStartOfNextText = change => {
-  change.call(pointEdgeSideObject, 'focus', 'start', 'next', 'text')
+Commands.moveFocusToStartOfNextText = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'start', 'next', 'text')
 }
 
-Commands.moveFocusToStartOfNode = (change, ...args) => {
-  change.call(proxy, 'moveFocusToStartOfNode', ...args)
+Commands.moveFocusToStartOfNode = (editor, ...args) => {
+  editor.command(proxy, 'moveFocusToStartOfNode', ...args)
 }
 
-Commands.moveFocusToStartOfPreviousBlock = change => {
-  change.call(pointEdgeSideObject, 'focus', 'start', 'previous', 'block')
+Commands.moveFocusToStartOfPreviousBlock = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'start', 'previous', 'block')
 }
 
-Commands.moveFocusToStartOfPreviousInline = change => {
-  change.call(pointEdgeSideObject, 'focus', 'start', 'previous', 'inline')
+Commands.moveFocusToStartOfPreviousInline = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'start', 'previous', 'inline')
 }
 
-Commands.moveFocusToStartOfPreviousText = change => {
-  change.call(pointEdgeSideObject, 'focus', 'start', 'previous', 'text')
+Commands.moveFocusToStartOfPreviousText = editor => {
+  editor.command(pointEdgeSideObject, 'focus', 'start', 'previous', 'text')
 }
 
-Commands.moveFocusToStartOfText = change => {
-  change.call(pointEdgeObject, 'focus', 'start', 'text')
+Commands.moveFocusToStartOfText = editor => {
+  editor.command(pointEdgeObject, 'focus', 'start', 'text')
 }
 
-Commands.moveForward = (change, ...args) => {
-  change.moveAnchorForward(...args).moveFocusForward(...args)
+Commands.moveForward = (editor, ...args) => {
+  editor.moveAnchorForward(...args).moveFocusForward(...args)
 }
 
-Commands.moveWordForward = (change, ...args) => {
-  change.moveFocusWordForward(...args).moveToFocus(...args)
+Commands.moveWordForward = (editor, ...args) => {
+  editor.moveFocusWordForward(...args).moveToFocus(...args)
 }
 
-Commands.moveStartBackward = (change, ...args) => {
-  change.call(pointBackward, 'start', ...args)
+Commands.moveStartBackward = (editor, ...args) => {
+  editor.command(pointBackward, 'start', ...args)
 }
 
-Commands.moveStartWordBackward = (change, ...args) => {
-  change.call(pointWordBackward, 'start', ...args)
+Commands.moveStartWordBackward = (editor, ...args) => {
+  editor.command(pointWordBackward, 'start', ...args)
 }
 
-Commands.moveStartForward = (change, ...args) => {
-  change.call(pointForward, 'start', ...args)
+Commands.moveStartForward = (editor, ...args) => {
+  editor.command(pointForward, 'start', ...args)
 }
 
-Commands.moveStartWordForward = (change, ...args) => {
-  change.call(pointWordForward, 'start', ...args)
+Commands.moveStartWordForward = (editor, ...args) => {
+  editor.command(pointWordForward, 'start', ...args)
 }
 
-Commands.moveStartTo = (change, ...args) => {
-  change.call(proxy, 'moveStartTo', ...args)
+Commands.moveStartTo = (editor, ...args) => {
+  editor.command(proxy, 'moveStartTo', ...args)
 }
 
-Commands.moveStartToEndOfBlock = change => {
-  change.call(pointEdgeObject, 'start', 'end', 'block')
+Commands.moveStartToEndOfBlock = editor => {
+  editor.command(pointEdgeObject, 'start', 'end', 'block')
 }
 
-Commands.moveStartToEndOfDocument = change => {
-  change.moveStartToEndOfNode(change.value.document).moveToStart()
+Commands.moveStartToEndOfDocument = editor => {
+  editor.moveStartToEndOfNode(editor.value.document).moveToStart()
 }
 
-Commands.moveStartToEndOfInline = change => {
-  change.call(pointEdgeObject, 'start', 'end', 'inline')
+Commands.moveStartToEndOfInline = editor => {
+  editor.command(pointEdgeObject, 'start', 'end', 'inline')
 }
 
-Commands.moveStartToEndOfNextBlock = change => {
-  change.call(pointEdgeSideObject, 'start', 'end', 'next', 'block')
+Commands.moveStartToEndOfNextBlock = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'end', 'next', 'block')
 }
 
-Commands.moveStartToEndOfNextInline = change => {
-  change.call(pointEdgeSideObject, 'start', 'end', 'next', 'inline')
+Commands.moveStartToEndOfNextInline = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'end', 'next', 'inline')
 }
 
-Commands.moveStartToEndOfNextText = change => {
-  change.call(pointEdgeSideObject, 'start', 'end', 'next', 'text')
+Commands.moveStartToEndOfNextText = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'end', 'next', 'text')
 }
 
-Commands.moveStartToEndOfNode = (change, ...args) => {
-  change.call(proxy, 'moveStartToEndOfNode', ...args)
+Commands.moveStartToEndOfNode = (editor, ...args) => {
+  editor.command(proxy, 'moveStartToEndOfNode', ...args)
 }
 
-Commands.moveStartToEndOfPreviousBlock = change => {
-  change.call(pointEdgeSideObject, 'start', 'end', 'previous', 'block')
+Commands.moveStartToEndOfPreviousBlock = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'end', 'previous', 'block')
 }
 
-Commands.moveStartToEndOfPreviousInline = change => {
-  change.call(pointEdgeSideObject, 'start', 'end', 'previous', 'inline')
+Commands.moveStartToEndOfPreviousInline = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'end', 'previous', 'inline')
 }
 
-Commands.moveStartToEndOfPreviousText = change => {
-  change.call(pointEdgeSideObject, 'start', 'end', 'previous', 'text')
+Commands.moveStartToEndOfPreviousText = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'end', 'previous', 'text')
 }
 
-Commands.moveStartToEndOfText = change => {
-  change.call(pointEdgeObject, 'start', 'end', 'text')
+Commands.moveStartToEndOfText = editor => {
+  editor.command(pointEdgeObject, 'start', 'end', 'text')
 }
 
-Commands.moveStartToStartOfBlock = change => {
-  change.call(pointEdgeObject, 'start', 'start', 'block')
+Commands.moveStartToStartOfBlock = editor => {
+  editor.command(pointEdgeObject, 'start', 'start', 'block')
 }
 
-Commands.moveStartToStartOfDocument = change => {
-  change.moveStartToStartOfNode(change.value.document).moveToStart()
+Commands.moveStartToStartOfDocument = editor => {
+  editor.moveStartToStartOfNode(editor.value.document).moveToStart()
 }
 
-Commands.moveStartToStartOfInline = change => {
-  change.call(pointEdgeObject, 'start', 'start', 'inline')
+Commands.moveStartToStartOfInline = editor => {
+  editor.command(pointEdgeObject, 'start', 'start', 'inline')
 }
 
-Commands.moveStartToStartOfNextBlock = change => {
-  change.call(pointEdgeSideObject, 'start', 'start', 'next', 'block')
+Commands.moveStartToStartOfNextBlock = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'start', 'next', 'block')
 }
 
-Commands.moveStartToStartOfNextInline = change => {
-  change.call(pointEdgeSideObject, 'start', 'start', 'next', 'inline')
+Commands.moveStartToStartOfNextInline = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'start', 'next', 'inline')
 }
 
-Commands.moveStartToStartOfNextText = change => {
-  change.call(pointEdgeSideObject, 'start', 'start', 'next', 'text')
+Commands.moveStartToStartOfNextText = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'start', 'next', 'text')
 }
 
-Commands.moveStartToStartOfNode = (change, ...args) => {
-  change.call(proxy, 'moveStartToStartOfNode', ...args)
+Commands.moveStartToStartOfNode = (editor, ...args) => {
+  editor.command(proxy, 'moveStartToStartOfNode', ...args)
 }
 
-Commands.moveStartToStartOfPreviousBlock = change => {
-  change.call(pointEdgeSideObject, 'start', 'start', 'previous', 'block')
+Commands.moveStartToStartOfPreviousBlock = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'start', 'previous', 'block')
 }
 
-Commands.moveStartToStartOfPreviousInline = change => {
-  change.call(pointEdgeSideObject, 'start', 'start', 'previous', 'inline')
+Commands.moveStartToStartOfPreviousInline = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'start', 'previous', 'inline')
 }
 
-Commands.moveStartToStartOfPreviousText = change => {
-  change.call(pointEdgeSideObject, 'start', 'start', 'previous', 'text')
+Commands.moveStartToStartOfPreviousText = editor => {
+  editor.command(pointEdgeSideObject, 'start', 'start', 'previous', 'text')
 }
 
-Commands.moveStartToStartOfText = change => {
-  change.call(pointEdgeObject, 'start', 'start', 'text')
+Commands.moveStartToStartOfText = editor => {
+  editor.command(pointEdgeObject, 'start', 'start', 'text')
 }
 
-Commands.moveTo = (change, ...args) => {
-  change.call(proxy, 'moveTo', ...args)
+Commands.moveTo = (editor, ...args) => {
+  editor.command(proxy, 'moveTo', ...args)
 }
 
-Commands.moveToAnchor = change => {
-  change.call(proxy, 'moveToAnchor')
+Commands.moveToAnchor = editor => {
+  editor.command(proxy, 'moveToAnchor')
 }
 
-Commands.moveToEnd = change => {
-  change.call(proxy, 'moveToEnd')
+Commands.moveToEnd = editor => {
+  editor.command(proxy, 'moveToEnd')
 }
 
-Commands.moveToEndOfBlock = change => {
-  change.moveEndToEndOfBlock().moveToEnd()
+Commands.moveToEndOfBlock = editor => {
+  editor.moveEndToEndOfBlock().moveToEnd()
 }
 
-Commands.moveToEndOfDocument = change => {
-  change.moveEndToEndOfNode(change.value.document).moveToEnd()
+Commands.moveToEndOfDocument = editor => {
+  editor.moveEndToEndOfNode(editor.value.document).moveToEnd()
 }
 
-Commands.moveToEndOfInline = change => {
-  change.moveEndToEndOfInline().moveToEnd()
+Commands.moveToEndOfInline = editor => {
+  editor.moveEndToEndOfInline().moveToEnd()
 }
 
-Commands.moveToEndOfNextBlock = change => {
-  change.moveEndToEndOfNextBlock().moveToEnd()
+Commands.moveToEndOfNextBlock = editor => {
+  editor.moveEndToEndOfNextBlock().moveToEnd()
 }
 
-Commands.moveToEndOfNextInline = change => {
-  change.moveEndToEndOfNextInline().moveToEnd()
+Commands.moveToEndOfNextInline = editor => {
+  editor.moveEndToEndOfNextInline().moveToEnd()
 }
 
-Commands.moveToEndOfNextText = change => {
-  change.moveEndToEndOfNextText().moveToEnd()
+Commands.moveToEndOfNextText = editor => {
+  editor.moveEndToEndOfNextText().moveToEnd()
 }
 
-Commands.moveToEndOfNode = (change, ...args) => {
-  change.call(proxy, 'moveToEndOfNode', ...args)
+Commands.moveToEndOfNode = (editor, ...args) => {
+  editor.command(proxy, 'moveToEndOfNode', ...args)
 }
 
-Commands.moveToEndOfPreviousBlock = change => {
-  change.moveStartToEndOfPreviousBlock().moveToStart()
+Commands.moveToEndOfPreviousBlock = editor => {
+  editor.moveStartToEndOfPreviousBlock().moveToStart()
 }
 
-Commands.moveToEndOfPreviousInline = change => {
-  change.moveStartToEndOfPreviousInline().moveToStart()
+Commands.moveToEndOfPreviousInline = editor => {
+  editor.moveStartToEndOfPreviousInline().moveToStart()
 }
 
-Commands.moveToEndOfPreviousText = change => {
-  change.moveStartToEndOfPreviousText().moveToStart()
+Commands.moveToEndOfPreviousText = editor => {
+  editor.moveStartToEndOfPreviousText().moveToStart()
 }
 
-Commands.moveToEndOfText = change => {
-  change.moveEndToEndOfText().moveToEnd()
+Commands.moveToEndOfText = editor => {
+  editor.moveEndToEndOfText().moveToEnd()
 }
 
-Commands.moveToFocus = change => {
-  change.call(proxy, 'moveToFocus')
+Commands.moveToFocus = editor => {
+  editor.command(proxy, 'moveToFocus')
 }
 
-Commands.moveToRangeOfDocument = change => {
-  change.moveToRangeOfNode(change.value.document)
+Commands.moveToRangeOfDocument = editor => {
+  editor.moveToRangeOfNode(editor.value.document)
 }
 
-Commands.moveToRangeOfNode = (change, ...args) => {
-  change.call(proxy, 'moveToRangeOfNode', ...args)
+Commands.moveToRangeOfNode = (editor, ...args) => {
+  editor.command(proxy, 'moveToRangeOfNode', ...args)
 }
 
-Commands.moveToStart = change => {
-  change.call(proxy, 'moveToStart')
+Commands.moveToStart = editor => {
+  editor.command(proxy, 'moveToStart')
 }
 
-Commands.moveToStartOfBlock = change => {
-  change.moveStartToStartOfBlock().moveToStart()
+Commands.moveToStartOfBlock = editor => {
+  editor.moveStartToStartOfBlock().moveToStart()
 }
 
-Commands.moveToStartOfDocument = change => {
-  change.moveStartToStartOfNode(change.value.document).moveToStart()
+Commands.moveToStartOfDocument = editor => {
+  editor.moveStartToStartOfNode(editor.value.document).moveToStart()
 }
 
-Commands.moveToStartOfInline = change => {
-  change.moveStartToStartOfInline().moveToStart()
+Commands.moveToStartOfInline = editor => {
+  editor.moveStartToStartOfInline().moveToStart()
 }
 
-Commands.moveToStartOfNextBlock = change => {
-  change.moveEndToStartOfNextBlock().moveToEnd()
+Commands.moveToStartOfNextBlock = editor => {
+  editor.moveEndToStartOfNextBlock().moveToEnd()
 }
 
-Commands.moveToStartOfNextInline = change => {
-  change.moveEndToStartOfNextInline().moveToEnd()
+Commands.moveToStartOfNextInline = editor => {
+  editor.moveEndToStartOfNextInline().moveToEnd()
 }
 
-Commands.moveToStartOfNextText = change => {
-  change.moveEndToStartOfNextText().moveToEnd()
+Commands.moveToStartOfNextText = editor => {
+  editor.moveEndToStartOfNextText().moveToEnd()
 }
 
-Commands.moveToStartOfNode = (change, ...args) => {
-  change.call(proxy, 'moveToStartOfNode', ...args)
+Commands.moveToStartOfNode = (editor, ...args) => {
+  editor.command(proxy, 'moveToStartOfNode', ...args)
 }
 
-Commands.moveToStartOfPreviousBlock = change => {
-  change.moveStartToStartOfPreviousBlock().moveToStart()
+Commands.moveToStartOfPreviousBlock = editor => {
+  editor.moveStartToStartOfPreviousBlock().moveToStart()
 }
 
-Commands.moveToStartOfPreviousInline = change => {
-  change.moveStartToStartOfPreviousInline().moveToStart()
+Commands.moveToStartOfPreviousInline = editor => {
+  editor.moveStartToStartOfPreviousInline().moveToStart()
 }
 
-Commands.moveToStartOfPreviousText = change => {
-  change.moveStartToStartOfPreviousText().moveToStart()
+Commands.moveToStartOfPreviousText = editor => {
+  editor.moveStartToStartOfPreviousText().moveToStart()
 }
 
-Commands.moveToStartOfText = change => {
-  change.moveStartToStartOfText().moveToStart()
+Commands.moveToStartOfText = editor => {
+  editor.moveStartToStartOfText().moveToStart()
 }
 
-Commands.select = (change, properties, options = {}) => {
+Commands.select = (editor, properties, options = {}) => {
   properties = Selection.createProperties(properties)
   const { snapshot = false } = options
-  const { value } = change
+  const { value } = editor
   const { document, selection } = value
   const props = {}
   let next = selection.setProperties(properties)
@@ -609,7 +609,7 @@ Commands.select = (change, properties, options = {}) => {
   }
 
   // If the selection moves, clear any marks, unless the new selection
-  // properties change the marks in some way.
+  // properties editor the marks in some way.
   if (selection.marks && !props.marks && (props.anchor || props.focus)) {
     props.marks = null
   }
@@ -619,7 +619,7 @@ Commands.select = (change, properties, options = {}) => {
     return
   }
 
-  change.applyOperation(
+  editor.applyOperation(
     {
       type: 'set_selection',
       value,
@@ -630,25 +630,25 @@ Commands.select = (change, properties, options = {}) => {
   )
 }
 
-Commands.setAnchor = (change, ...args) => {
-  change.call(proxy, 'setAnchor', ...args)
+Commands.setAnchor = (editor, ...args) => {
+  editor.command(proxy, 'setAnchor', ...args)
 }
 
-Commands.setEnd = (change, ...args) => {
-  change.call(proxy, 'setEnd', ...args)
+Commands.setEnd = (editor, ...args) => {
+  editor.command(proxy, 'setEnd', ...args)
 }
 
-Commands.setFocus = (change, ...args) => {
-  change.call(proxy, 'setFocus', ...args)
+Commands.setFocus = (editor, ...args) => {
+  editor.command(proxy, 'setFocus', ...args)
 }
 
-Commands.setStart = (change, ...args) => {
-  change.call(proxy, 'setStart', ...args)
+Commands.setStart = (editor, ...args) => {
+  editor.command(proxy, 'setStart', ...args)
 }
 
-Commands.snapshotSelection = change => {
-  change.withoutMerging(() => {
-    change.select(change.value.selection, { snapshot: true })
+Commands.snapshotSelection = editor => {
+  editor.withoutMerging(() => {
+    editor.select(editor.value.selection, { snapshot: true })
   })
 }
 
@@ -656,26 +656,26 @@ Commands.snapshotSelection = change => {
  * Helpers.
  */
 
-function proxy(change, method, ...args) {
-  const range = change.value.selection[method](...args)
-  change.select(range)
+function proxy(editor, method, ...args) {
+  const range = editor.value.selection[method](...args)
+  editor.select(range)
 }
 
-function pointEdgeObject(change, point, edge, object) {
+function pointEdgeObject(editor, point, edge, object) {
   const Point = point.slice(0, 1).toUpperCase() + point.slice(1)
   const Edge = edge.slice(0, 1).toUpperCase() + edge.slice(1)
   const Object = object.slice(0, 1).toUpperCase() + object.slice(1)
   const method = `move${Point}To${Edge}OfNode`
   const getNode = object == 'text' ? 'getNode' : `getClosest${Object}`
-  const { value } = change
+  const { value } = editor
   const { document, selection } = value
   const p = selection[point]
   const node = document[getNode](p.key)
   if (!node) return
-  change[method](node)
+  editor[method](node)
 }
 
-function pointEdgeSideObject(change, point, edge, side, object) {
+function pointEdgeSideObject(editor, point, edge, side, object) {
   const Point = point.slice(0, 1).toUpperCase() + point.slice(1)
   const Edge = edge.slice(0, 1).toUpperCase() + edge.slice(1)
   const Side = side.slice(0, 1).toUpperCase() + side.slice(1)
@@ -683,22 +683,22 @@ function pointEdgeSideObject(change, point, edge, side, object) {
   const method = `move${Point}To${Edge}OfNode`
   const getNode = object == 'text' ? 'getNode' : `getClosest${Object}`
   const getDirectionNode = `get${Side}${Object}`
-  const { value } = change
+  const { value } = editor
   const { document, selection } = value
   const p = selection[point]
   const node = document[getNode](p.key)
   if (!node) return
   const target = document[getDirectionNode](node.key)
   if (!target) return
-  change[method](target)
+  editor[method](target)
 }
 
-function pointBackward(change, point, n = 1) {
+function pointBackward(editor, point, n = 1) {
   if (n === 0) return
-  if (n < 0) return pointForward(change, point, -n)
+  if (n < 0) return pointForward(editor, point, -n)
 
   const Point = point.slice(0, 1).toUpperCase() + point.slice(1)
-  const { editor, value } = change
+  const { value } = editor
   const { document, selection } = value
   const p = selection[point]
   const hasVoidParent = document.hasVoidParent(p.path, editor)
@@ -706,7 +706,7 @@ function pointBackward(change, point, n = 1) {
   // what is this?
   if (!hasVoidParent && p.offset - n >= 0) {
     const range = selection[`move${Point}Backward`](n)
-    change.select(range)
+    editor.select(range)
     return
   }
 
@@ -717,21 +717,21 @@ function pointBackward(change, point, n = 1) {
   const isInBlock = block.hasNode(previous.key)
   const isPreviousInVoid =
     previous && document.hasVoidParent(previous.key, editor)
-  change[`move${Point}ToEndOfNode`](previous)
+  editor[`move${Point}ToEndOfNode`](previous)
 
   // when is this called?
   if (!hasVoidParent && !isPreviousInVoid && isInBlock) {
-    const range = change.value.selection[`move${Point}Backward`](n)
-    change.select(range)
+    const range = editor.value.selection[`move${Point}Backward`](n)
+    editor.select(range)
   }
 }
 
-function pointForward(change, point, n = 1) {
+function pointForward(editor, point, n = 1) {
   if (n === 0) return
-  if (n < 0) return pointBackward(change, point, -n)
+  if (n < 0) return pointBackward(editor, point, -n)
 
   const Point = point.slice(0, 1).toUpperCase() + point.slice(1)
-  const { editor, value } = change
+  const { value } = editor
   const { document, selection } = value
   const p = selection[point]
   const text = document.getNode(p.path)
@@ -740,7 +740,7 @@ function pointForward(change, point, n = 1) {
   // what is this?
   if (!hasVoidParent && p.offset + n <= text.text.length) {
     const range = selection[`move${Point}Forward`](n)
-    change.select(range)
+    editor.select(range)
     return
   }
 
@@ -750,17 +750,17 @@ function pointForward(change, point, n = 1) {
   const block = document.getClosestBlock(p.path)
   const isInBlock = block.hasNode(next.key)
   const isNextInVoid = document.hasVoidParent(next.key, editor)
-  change[`move${Point}ToStartOfNode`](next)
+  editor[`move${Point}ToStartOfNode`](next)
 
   // when is this called?
   if (!hasVoidParent && !isNextInVoid && isInBlock) {
-    const range = change.value.selection[`move${Point}Forward`](n)
-    change.select(range)
+    const range = editor.value.selection[`move${Point}Forward`](n)
+    editor.select(range)
   }
 }
 
-function pointWordBackward(change, pointName) {
-  const { value } = change
+function pointWordBackward(editor, pointName) {
+  const { value } = editor
   const { document, selection } = value
   const point = selection[pointName]
   const block = document.getClosestBlock(point.key)
@@ -768,11 +768,11 @@ function pointWordBackward(change, pointName) {
   const o = offset + point.offset
   const { text } = block
   const n = TextUtils.getWordOffsetBackward(text, o)
-  change.call(pointBackward, pointName, n > 0 ? n : 1)
+  editor.command(pointBackward, pointName, n > 0 ? n : 1)
 }
 
-function pointWordForward(change, pointName) {
-  const { value } = change
+function pointWordForward(editor, pointName) {
+  const { value } = editor
   const { document, selection } = value
   const point = selection[pointName]
   const block = document.getClosestBlock(point.key)
@@ -780,7 +780,7 @@ function pointWordForward(change, pointName) {
   const o = offset + point.offset
   const { text } = block
   const n = TextUtils.getWordOffsetForward(text, o)
-  change.call(pointForward, pointName, n > 0 ? n : 1)
+  editor.command(pointForward, pointName, n > 0 ? n : 1)
 }
 
 export default Commands
diff --git a/packages/slate/src/commands/on-value.js b/packages/slate/src/commands/on-value.js
index c3496da0e..0ee0d7fdd 100644
--- a/packages/slate/src/commands/on-value.js
+++ b/packages/slate/src/commands/on-value.js
@@ -11,15 +11,33 @@ const Commands = {}
 /**
  * Set `properties` on the value.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {Object|Value} properties
  */
 
-Commands.setValue = (change, properties) => {
-  properties = Value.createProperties(properties)
-  const { value } = change
+Commands.setData = (editor, data = {}) => {
+  const properties = Value.createProperties({ data })
+  const { value } = editor
 
-  change.applyOperation({
+  editor.applyOperation({
+    type: 'set_value',
+    properties,
+    value,
+  })
+}
+
+/**
+ * Set `properties` on the value.
+ *
+ * @param {Editor} editor
+ * @param {Object|Value} properties
+ */
+
+Commands.setDecorations = (editor, decorations = []) => {
+  const properties = Value.createProperties({ decorations })
+  const { value } = editor
+
+  editor.applyOperation({
     type: 'set_value',
     properties,
     value,
diff --git a/packages/slate/src/controllers/change.js b/packages/slate/src/controllers/change.js
deleted file mode 100644
index a26a0c5b0..000000000
--- a/packages/slate/src/controllers/change.js
+++ /dev/null
@@ -1,395 +0,0 @@
-import Debug from 'debug'
-import isPlainObject from 'is-plain-object'
-import warning from 'tiny-warning'
-import { List } from 'immutable'
-
-import Operation from '../models/operation'
-import PathUtils from '../utils/path-utils'
-
-/**
- * Debug.
- *
- * @type {Function}
- */
-
-const debug = Debug('slate:change')
-
-/**
- * Change.
- *
- * @type {Change}
- */
-
-class Change {
-  /**
-   * Create a new `Change` with `attrs`.
-   *
-   * @param {Object} attrs
-   *   @property {Value} value
-   */
-
-  constructor(attrs) {
-    const { editor, value } = attrs
-    this.editor = editor
-    this.value = value
-    this.operations = new List()
-
-    this.tmp = {
-      dirty: [],
-      merge: null,
-      normalize: true,
-      save: true,
-    }
-  }
-
-  /**
-   * Apply an `operation` to the current value, saving the operation to the
-   * history if needed.
-   *
-   * @param {Operation|Object} operation
-   * @return {Change}
-   */
-
-  applyOperation(operation) {
-    const { operations } = this
-    let value = this.value
-
-    // Add in the current `value` in case the operation was serialized.
-    if (isPlainObject(operation)) {
-      operation = { ...operation, value }
-    }
-
-    operation = Operation.create(operation)
-
-    // Save the operation into the history. Since `save` is a command, we need
-    // to do it without normalizing, since it would have side effects.
-    this.withoutNormalizing(() => {
-      this.save(operation)
-      value = this.value
-    })
-
-    // Apply the operation to the value.
-    debug('apply', { operation })
-    value = operation.apply(value)
-
-    // Get the paths of the affected nodes, and mark them as dirty.
-    const newDirtyPaths = getDirtyPaths(operation)
-    const dirty = this.tmp.dirty.reduce((memo, path) => {
-      path = PathUtils.create(path)
-      const transformed = PathUtils.transform(path, operation)
-      memo = memo.concat(transformed.toArray())
-      return memo
-    }, newDirtyPaths)
-
-    this.tmp.dirty = dirty
-
-    // Update the mutable change object.
-    this.value = value
-    this.operations = operations.push(operation)
-    return this
-  }
-
-  /**
-   * Apply a series of `operations` to the current value.
-   *
-   * @param {Array|List} operations
-   * @return {Change}
-   */
-
-  applyOperations(operations) {
-    operations.forEach(op => this.applyOperation(op))
-    return this
-  }
-
-  /**
-   * Call a change `fn` with arguments.
-   *
-   * @param {Function} fn
-   * @param {Mixed} ...args
-   * @return {Change}
-   */
-
-  call(fn, ...args) {
-    fn(this, ...args)
-    this.normalizeDirtyPaths()
-    return this
-  }
-
-  /**
-   * Run a `command` with `args`.
-   *
-   * @param {String} command
-   * @param {Any} ...args
-   * @return {Change}
-   */
-
-  command(command, ...args) {
-    const { editor } = this
-    editor.command(command, ...args)
-    return this
-  }
-
-  /**
-   * Run a `query` with `args`.
-   *
-   * @param {String} query
-   * @param {Any} ...args
-   * @return {Change}
-   */
-
-  query(query, ...args) {
-    const { editor } = this
-    return editor.query(query, ...args)
-  }
-
-  /**
-   * Normalize all of the nodes in the document from scratch.
-   *
-   * @return {Change}
-   */
-
-  normalize() {
-    const { value } = this
-    let { document } = value
-    const table = document.getKeysToPathsTable()
-    const paths = Object.values(table).map(PathUtils.create)
-    this.tmp.dirty = this.tmp.dirty.concat(paths)
-    this.normalizeDirtyPaths()
-
-    const { selection } = value
-    document = value.document
-
-    if (selection.isUnset && document.nodes.size) {
-      this.moveToStartOfDocument()
-    }
-
-    return this
-  }
-
-  /**
-   * Normalize any new "dirty" paths that have been added to the change.
-   *
-   * @return {Change}
-   */
-
-  normalizeDirtyPaths() {
-    if (!this.tmp.normalize) {
-      return this
-    }
-
-    while (this.tmp.dirty.length) {
-      const path = this.tmp.dirty.pop()
-      this.normalizeNodeByPath(path)
-    }
-
-    return this
-  }
-
-  /**
-   * Normalize the node at a specific `path`.
-   *
-   * @param {Array} path
-   * @return {Change}
-   */
-
-  normalizeNodeByPath(path) {
-    const { editor, value } = this
-    let { document } = value
-    let node = document.assertNode(path)
-    let iterations = 0
-    const max = 1000 + (node.object === 'text' ? 1 : node.nodes.size)
-
-    const iterate = () => {
-      const fn = node.normalize(editor)
-      if (!fn) return
-
-      // Run the normalize `fn` to fix the node.
-      fn(this)
-
-      // Attempt to re-find the node by path, or by key if it has changed
-      // locations in the tree continue iterating.
-      document = this.value.document
-      const { key } = node
-      let found = document.getDescendant(path)
-
-      if (found && found.key === key) {
-        node = found
-      } else {
-        found = document.getDescendant(key)
-
-        if (found) {
-          node = found
-          path = document.getPath(key)
-        } else {
-          // If it no longer exists by key, it was removed, so abort.
-          return
-        }
-      }
-
-      // Increment the iterations counter, and check to make sure that we haven't
-      // exceeded the max. Without this check, it's easy for the `normalize`
-      // function of a schema rule to be written incorrectly and for an infinite
-      // invalid loop to occur.
-      iterations++
-
-      if (iterations > max) {
-        throw new Error(
-          'A schema rule could not be normalized after sufficient iterations. This is usually due to a `rule.normalize` or `plugin.normalizeNode` function of a schema being incorrectly written, causing an infinite loop.'
-        )
-      }
-
-      // Otherwise, iterate again.
-      iterate()
-    }
-
-    this.withoutNormalizing(() => {
-      iterate()
-    })
-
-    return this
-  }
-
-  /**
-   * Apply a series of changes inside a synchronous `fn`, deferring
-   * normalization until after the function has finished executing.
-   *
-   * @param {Function} fn
-   * @return {Change}
-   */
-
-  withoutNormalizing(fn) {
-    const value = this.tmp.normalize
-    this.tmp.normalize = false
-    fn(this)
-    this.tmp.normalize = value
-    this.normalizeDirtyPaths()
-    return this
-  }
-
-  /**
-   * Deprecated.
-   */
-
-  setOperationFlag(key, value) {
-    warning(
-      false,
-      'As of slate@0.41.0 the `change.setOperationFlag` method has been deprecated.'
-    )
-
-    this.tmp[key] = value
-    return this
-  }
-
-  getFlag(key, options = {}) {
-    warning(
-      false,
-      'As of slate@0.41.0 the `change.getFlag` method has been deprecated.'
-    )
-
-    return options[key] !== undefined ? options[key] : this.tmp[key]
-  }
-
-  unsetOperationFlag(key) {
-    warning(
-      false,
-      'As of slate@0.41.0 the `change.unsetOperationFlag` method has been deprecated.'
-    )
-
-    delete this.tmp[key]
-    return this
-  }
-
-  withoutNormalization(fn) {
-    warning(
-      false,
-      'As of slate@0.41.0 the `change.withoutNormalization` helper has been renamed to `change.withoutNormalizing`.'
-    )
-
-    return this.withoutNormalizing(fn)
-  }
-}
-
-/**
- * Get the "dirty" paths for a given `operation`.
- *
- * @param {Operation} operation
- * @return {Array}
- */
-
-function getDirtyPaths(operation) {
-  const { type, node, path, newPath } = operation
-
-  switch (type) {
-    case 'add_mark':
-    case 'insert_text':
-    case 'remove_mark':
-    case 'remove_text':
-    case 'set_mark':
-    case 'set_node': {
-      const ancestors = PathUtils.getAncestors(path).toArray()
-      return [...ancestors, path]
-    }
-
-    case 'insert_node': {
-      const table = node.getKeysToPathsTable()
-      const paths = Object.values(table).map(p => path.concat(p))
-      const ancestors = PathUtils.getAncestors(path).toArray()
-      return [...ancestors, path, ...paths]
-    }
-
-    case 'split_node': {
-      const ancestors = PathUtils.getAncestors(path).toArray()
-      const nextPath = PathUtils.increment(path)
-      return [...ancestors, path, nextPath]
-    }
-
-    case 'merge_node': {
-      const ancestors = PathUtils.getAncestors(path).toArray()
-      const previousPath = PathUtils.decrement(path)
-      return [...ancestors, previousPath]
-    }
-
-    case 'move_node': {
-      let parentPath = PathUtils.lift(path)
-      let newParentPath = PathUtils.lift(newPath)
-
-      if (PathUtils.isEqual(path, newPath)) {
-        return []
-      }
-
-      // HACK: this clause only exists because the `move_path` logic isn't
-      // consistent when it deals with siblings.
-      if (!PathUtils.isSibling(path, newPath)) {
-        if (newParentPath.size && PathUtils.isYounger(path, newPath)) {
-          newParentPath = PathUtils.decrement(newParentPath, 1, path.size - 1)
-        }
-
-        if (parentPath.size && PathUtils.isYounger(newPath, path)) {
-          parentPath = PathUtils.increment(parentPath, 1, newPath.size - 1)
-        }
-      }
-
-      const oldAncestors = PathUtils.getAncestors(parentPath).toArray()
-      const newAncestors = PathUtils.getAncestors(newParentPath).toArray()
-
-      return [...oldAncestors, parentPath, ...newAncestors, newParentPath]
-    }
-
-    case 'remove_node': {
-      const ancestors = PathUtils.getAncestors(path).toArray()
-      return [...ancestors]
-    }
-
-    default: {
-      return []
-    }
-  }
-}
-
-/**
- * Export.
- *
- * @type {Change}
- */
-
-export default Change
diff --git a/packages/slate/src/controllers/editor.js b/packages/slate/src/controllers/editor.js
index 4021ebef0..64ebe170d 100644
--- a/packages/slate/src/controllers/editor.js
+++ b/packages/slate/src/controllers/editor.js
@@ -1,9 +1,13 @@
 import Debug from 'debug'
 import invariant from 'tiny-invariant'
+import isPlainObject from 'is-plain-object'
+import warning from 'tiny-warning'
+import { List } from 'immutable'
 
-import AbstractChange from './change'
-import CorePlugin from '../plugins/core'
 import CommandsPlugin from '../plugins/commands'
+import CorePlugin from '../plugins/core'
+import Operation from '../models/operation'
+import PathUtils from '../utils/path-utils'
 import QueriesPlugin from '../plugins/queries'
 import SchemaPlugin from '../plugins/schema'
 import Value from '../models/value'
@@ -31,7 +35,7 @@ class Editor {
    */
 
   constructor(attrs = {}, options = {}) {
-    const { editor = this } = options
+    const { controller = this, construct = true } = options
     const {
       onChange = () => {},
       plugins = [],
@@ -39,141 +43,213 @@ class Editor {
       value = Value.create(),
     } = attrs
 
-    this.Change = class Change extends AbstractChange {}
-    this.editor = editor
+    this.controller = controller
     this.middleware = {}
     this.onChange = onChange
+    this.operations = List()
     this.readOnly = null
     this.value = null
 
     this.tmp = {
-      change: null,
-      isChanging: false,
+      dirty: [],
+      flushing: false,
+      merge: null,
+      normalize: true,
+      save: true,
     }
 
     const core = CorePlugin({ plugins })
     registerPlugin(this, core)
 
-    this.run('onConstruct', this)
-
-    this.setReadOnly(readOnly)
-    this.setValue(value, options)
+    if (construct) {
+      this.run('onConstruct')
+      this.setReadOnly(readOnly)
+      this.setValue(value, options)
+    }
   }
 
   /**
-   * Perform a change on the editor, passing `...args` to `change.call`.
+   * Apply an `operation` to the editor, updating its value.
    *
-   * @param {Any} ...args
+   * @param {Operation|Object} operation
+   * @return {Editor}
    */
 
-  change(...args) {
-    const { Change, editor, value } = this
-    const { isChanging } = this.tmp
-    const change = isChanging ? this.tmp.change : new Change({ value, editor })
+  applyOperation(operation) {
+    const { operations, controller } = this
+    let value = this.value
 
-    try {
-      this.tmp.change = change
-      this.tmp.isChanging = true
-      change.call(...args)
-    } catch (error) {
-      throw error
-    } finally {
-      this.tmp.isChanging = isChanging
+    // Add in the current `value` in case the operation was serialized.
+    if (isPlainObject(operation)) {
+      operation = { ...operation, value }
     }
 
-    // If this isn't the top-most change function, exit to let it finish.
-    if (isChanging === true) {
-      return
+    operation = Operation.create(operation)
+
+    // Save the operation into the history. Since `save` is a command, we need
+    // to do it without normalizing, since it would have side effects.
+    this.withoutNormalizing(() => {
+      controller.save(operation)
+      value = this.value
+    })
+
+    // Apply the operation to the value.
+    debug('apply', { operation })
+    this.value = operation.apply(value)
+    this.operations = operations.push(operation)
+
+    // Get the paths of the affected nodes, and mark them as dirty.
+    const newDirtyPaths = getDirtyPaths(operation)
+    const dirty = this.tmp.dirty.reduce((memo, path) => {
+      path = PathUtils.create(path)
+      const transformed = PathUtils.transform(path, operation)
+      memo = memo.concat(transformed.toArray())
+      return memo
+    }, newDirtyPaths)
+
+    this.tmp.dirty = dirty
+
+    // If we're not already, queue the flushing process on the next tick.
+    if (!this.tmp.flushing) {
+      this.tmp.flushing = true
+      Promise.resolve().then(() => this.flush())
     }
 
-    // If the change doesn't define any operations to apply, abort.
-    if (change.operations.size === 0) {
-      return
-    }
+    return controller
+  }
 
-    this.run('onChange', change)
+  /**
+   * Flush the editor's current change.
+   *
+   * @return {Editor}
+   */
 
-    // Call the provided `onChange` handler.
-    this.value = change.value
+  flush() {
+    this.run('onChange')
+    const { value, operations, controller } = this
+    const change = { value, operations }
+    this.operations = List()
+    this.tmp.flushing = false
     this.onChange(change)
+    return controller
   }
 
   /**
-   * Trigger a `command` with `...args`.
+   * Trigger a command by `type` with `...args`.
    *
-   * @param {String} command
+   * @param {String|Function} type
    * @param {Any} ...args
+   * @return {Editor}
    */
 
-  command(command, ...args) {
-    debug('command', { command, args })
+  command(type, ...args) {
+    const { controller } = this
 
-    this.change(change => {
-      const obj = { type: command, args }
-      this.run('onCommand', obj, change)
-    })
+    if (typeof type === 'function') {
+      type(controller, ...args)
+      normalizeDirtyPaths(this)
+      return controller
+    }
+
+    debug('command', { type, args })
+    const obj = { type, args }
+    this.run('onCommand', obj)
+    normalizeDirtyPaths(this)
+    return controller
   }
 
   /**
-   * Process an `event` by running it through the stack.
+   * Normalize all of the nodes in the document from scratch.
    *
-   * @param {String} handler
-   * @param {Event} event
+   * @return {Editor}
    */
 
-  event(handler, event) {
-    debug('event', { handler, event })
+  normalize() {
+    const { value, controller } = this
+    let { document } = value
+    const table = document.getKeysToPathsTable()
+    const paths = Object.values(table).map(PathUtils.create)
+    this.tmp.dirty = this.tmp.dirty.concat(paths)
+    normalizeDirtyPaths(this)
 
-    this.change(change => {
-      this.run(handler, event, change)
-    })
+    const { selection } = value
+    document = value.document
+
+    if (selection.isUnset && document.nodes.size) {
+      controller.moveToStartOfDocument()
+    }
+
+    return controller
   }
 
   /**
-   * Ask a `query` with `...args`.
+   * Ask a query by `type` with `...args`.
    *
-   * @param {String} query
+   * @param {String|Function} type
    * @param {Any} ...args
+   * @return {Any}
    */
 
-  query(query, ...args) {
-    debug('query', { query, args })
+  query(type, ...args) {
+    const { controller } = this
 
-    const { editor } = this
-    const obj = { type: query, args }
-    return this.run('onQuery', obj, editor)
+    if (typeof type === 'function') {
+      return type(controller, ...args)
+    }
+
+    debug('query', { type, args })
+    const obj = { type, args }
+    return this.run('onQuery', obj)
   }
 
   /**
-   * Register a `command` with the editor.
+   * Register a command `type` with the editor.
    *
-   * @param {String} command
+   * @param {String} type
+   * @return {Editor}
    */
 
-  registerCommand(command) {
-    const { Change } = this
-    if (Change.prototype[command]) return
+  registerCommand(type) {
+    const { controller } = this
 
-    Change.prototype[command] = function(...args) {
-      const change = this.command(command, ...args)
-      return change
+    if (type in controller && controller[type].__command) {
+      return controller
     }
+
+    invariant(
+      !(type in controller),
+      `You cannot register a \`${type}\` command because it would overwrite an existing property of the \`Editor\`.`
+    )
+
+    const method = (...args) => this.command(type, ...args)
+    controller[type] = method
+    method.__command = true
+    return controller
   }
 
   /**
-   * Register a `query` with the editor.
+   * Register a query `type` with the editor.
    *
-   * @param {String} query
+   * @param {String} type
+   * @return {Editor}
    */
 
-  registerQuery(query) {
-    const { Change } = this
-    if (Change.prototype[query]) return
+  registerQuery(type) {
+    const { controller } = this
 
-    Change.prototype[query] = function(...args) {
-      const ret = this.query(query, ...args)
-      return ret
+    if (type in controller && controller[type].__query) {
+      return controller
     }
+
+    invariant(
+      !(type in controller),
+      `You cannot register a \`${type}\` query because it would overwrite an existing property of the \`Editor\`.`
+    )
+
+    const method = (...args) => this.query(type, ...args)
+    controller[type] = method
+    method.__query = true
+    return controller
   }
 
   /**
@@ -185,18 +261,19 @@ class Editor {
    */
 
   run(key, ...args) {
-    const middleware = this.middleware[key] || []
+    const { controller, middleware } = this
+    const fns = middleware[key] || []
     let i = 0
 
     function next(...overrides) {
-      const fn = middleware[i++]
+      const fn = fns[i++]
       if (!fn) return
 
       if (overrides.length) {
         args = overrides
       }
 
-      const ret = fn(...args, next)
+      const ret = fn(...args, controller, next)
       return ret
     }
 
@@ -204,7 +281,7 @@ class Editor {
       get() {
         invariant(
           false,
-          'As of Slate 0.42.0, the `editor` is no longer passed as the third argument to event handlers. You can access it via `change.editor` instead.'
+          'As of Slate 0.42, the `editor` is no longer passed as the third argument to event handlers. You can access it via `change.editor` instead.'
         )
       },
     })
@@ -213,7 +290,7 @@ class Editor {
       get() {
         invariant(
           false,
-          'As of Slate 0.42.0, the `editor` is no longer passed as the third argument to event handlers. You can access it via `change.editor` instead.'
+          'As of Slate 0.42, the `editor` is no longer passed as the third argument to event handlers. You can access it via `change.editor` instead.'
         )
       },
     })
@@ -222,7 +299,7 @@ class Editor {
       get() {
         invariant(
           false,
-          'As of Slate 0.42.0, the `editor` is no longer passed as the third argument to event handlers. You can access it via `change.editor` instead.'
+          'As of Slate 0.42, the `editor` is no longer passed as the third argument to event handlers. You can access it via `change.editor` instead.'
         )
       },
     })
@@ -231,7 +308,7 @@ class Editor {
       get() {
         invariant(
           false,
-          'As of Slate 0.42.0, the `editor` is no longer passed as the third argument to event handlers. You can access it via `change.editor` instead.'
+          'As of Slate 0.42, the `editor` is no longer passed as the third argument to event handlers. You can access it via `change.editor` instead.'
         )
       },
     })
@@ -240,7 +317,7 @@ class Editor {
       get() {
         invariant(
           false,
-          'As of Slate 0.42.0, the `editor` is no longer passed as the third argument to event handlers. You can access it via `change.editor` instead.'
+          'As of Slate 0.42, the `editor` is no longer passed as the third argument to event handlers. You can access it via `change.editor` instead.'
         )
       },
     })
@@ -273,11 +350,265 @@ class Editor {
     this.value = value
 
     if (normalize) {
-      this.change(change => change.normalize())
+      this.normalize()
     }
 
     return this
   }
+
+  /**
+   * Apply a series of changes inside a synchronous `fn`, deferring
+   * normalization until after the function has finished executing.
+   *
+   * @param {Function} fn
+   * @return {Editor}
+   */
+
+  withoutNormalizing(fn) {
+    const { controller } = this
+    const value = this.tmp.normalize
+    this.tmp.normalize = false
+    fn(controller)
+    this.tmp.normalize = value
+    normalizeDirtyPaths(this)
+    return controller
+  }
+
+  /**
+   * Deprecated.
+   */
+
+  get editor() {
+    warning(
+      false,
+      "As of Slate 0.43 the `change` object has been replaced with `editor`, so you don't need to access `change.editor`."
+    )
+
+    return this.controller
+  }
+
+  change(fn, ...args) {
+    warning(
+      false,
+      'As of Slate 0.43 the `change` object has been replaced with `editor`, so the `editor.change()` method is deprecated.`'
+    )
+
+    fn(this.controller, ...args)
+  }
+
+  call(fn, ...args) {
+    warning(
+      false,
+      'As of Slate 0.43 the `editor.command(fn)` method has been deprecated, please use `editor.command(fn)` instead.'
+    )
+
+    fn(this.controller, ...args)
+    return this.controller
+  }
+
+  applyOperations(operations) {
+    warning(
+      false,
+      'As of Slate 0.43 the `applyOperations` method is deprecated, please apply each operation in a loop instead.'
+    )
+
+    operations.forEach(op => this.applyOperation(op))
+    return this.controller
+  }
+
+  setOperationFlag(key, value) {
+    warning(
+      false,
+      'As of slate@0.41 the `change.setOperationFlag` method has been deprecated.'
+    )
+
+    this.tmp[key] = value
+    return this
+  }
+
+  getFlag(key, options = {}) {
+    warning(
+      false,
+      'As of slate@0.41 the `change.getFlag` method has been deprecated.'
+    )
+
+    return options[key] !== undefined ? options[key] : this.tmp[key]
+  }
+
+  unsetOperationFlag(key) {
+    warning(
+      false,
+      'As of slate@0.41 the `change.unsetOperationFlag` method has been deprecated.'
+    )
+
+    delete this.tmp[key]
+    return this
+  }
+
+  withoutNormalization(fn) {
+    warning(
+      false,
+      'As of slate@0.41 the `change.withoutNormalization` helper has been renamed to `change.withoutNormalizing`.'
+    )
+
+    return this.withoutNormalizing(fn)
+  }
+}
+
+/**
+ * Get the "dirty" paths for a given `operation`.
+ *
+ * @param {Operation} operation
+ * @return {Array}
+ */
+
+function getDirtyPaths(operation) {
+  const { type, node, path, newPath } = operation
+
+  switch (type) {
+    case 'add_mark':
+    case 'insert_text':
+    case 'remove_mark':
+    case 'remove_text':
+    case 'set_mark':
+    case 'set_node': {
+      const ancestors = PathUtils.getAncestors(path).toArray()
+      return [...ancestors, path]
+    }
+
+    case 'insert_node': {
+      const table = node.getKeysToPathsTable()
+      const paths = Object.values(table).map(p => path.concat(p))
+      const ancestors = PathUtils.getAncestors(path).toArray()
+      return [...ancestors, path, ...paths]
+    }
+
+    case 'split_node': {
+      const ancestors = PathUtils.getAncestors(path).toArray()
+      const nextPath = PathUtils.increment(path)
+      return [...ancestors, path, nextPath]
+    }
+
+    case 'merge_node': {
+      const ancestors = PathUtils.getAncestors(path).toArray()
+      const previousPath = PathUtils.decrement(path)
+      return [...ancestors, previousPath]
+    }
+
+    case 'move_node': {
+      let parentPath = PathUtils.lift(path)
+      let newParentPath = PathUtils.lift(newPath)
+
+      if (PathUtils.isEqual(path, newPath)) {
+        return []
+      }
+
+      // HACK: this clause only exists because the `move_path` logic isn't
+      // consistent when it deals with siblings.
+      if (!PathUtils.isSibling(path, newPath)) {
+        if (newParentPath.size && PathUtils.isYounger(path, newPath)) {
+          newParentPath = PathUtils.decrement(newParentPath, 1, path.size - 1)
+        }
+
+        if (parentPath.size && PathUtils.isYounger(newPath, path)) {
+          parentPath = PathUtils.increment(parentPath, 1, newPath.size - 1)
+        }
+      }
+
+      const oldAncestors = PathUtils.getAncestors(parentPath).toArray()
+      const newAncestors = PathUtils.getAncestors(newParentPath).toArray()
+
+      return [...oldAncestors, parentPath, ...newAncestors, newParentPath]
+    }
+
+    case 'remove_node': {
+      const ancestors = PathUtils.getAncestors(path).toArray()
+      return [...ancestors]
+    }
+
+    default: {
+      return []
+    }
+  }
+}
+
+/**
+ * Normalize any new "dirty" paths that have been added to the change.
+ *
+ * @param {Editor}
+ */
+
+function normalizeDirtyPaths(editor) {
+  if (!editor.tmp.normalize) {
+    return
+  }
+
+  while (editor.tmp.dirty.length) {
+    const path = editor.tmp.dirty.pop()
+    normalizeNodeByPath(editor, path)
+  }
+}
+
+/**
+ * Normalize the node at a specific `path`.
+ *
+ * @param {Editor} editor
+ * @param {Array} path
+ */
+
+function normalizeNodeByPath(editor, path) {
+  const { controller, value } = editor
+  let { document } = value
+  let node = document.assertNode(path)
+  let iterations = 0
+  const max = 1000 + (node.object === 'text' ? 1 : node.nodes.size)
+
+  const iterate = () => {
+    const fn = node.normalize(controller)
+    if (!fn) return
+
+    // Run the normalize `fn` to fix the node.
+    fn(controller)
+
+    // Attempt to re-find the node by path, or by key if it has changed
+    // locations in the tree continue iterating.
+    document = editor.value.document
+    const { key } = node
+    let found = document.getDescendant(path)
+
+    if (found && found.key === key) {
+      node = found
+    } else {
+      found = document.getDescendant(key)
+
+      if (found) {
+        node = found
+        path = document.getPath(key)
+      } else {
+        // If it no longer exists by key, it was removed, so abort.
+        return
+      }
+    }
+
+    // Increment the iterations counter, and check to make sure that we haven't
+    // exceeded the max. Without this check, it's easy for the `normalize`
+    // function of a schema rule to be written incorrectly and for an infinite
+    // invalid loop to occur.
+    iterations++
+
+    if (iterations > max) {
+      throw new Error(
+        'A schema rule could not be normalized after sufficient iterations. This is usually due to a `rule.normalize` or `plugin.normalizeNode` function of a schema being incorrectly written, causing an infinite loop.'
+      )
+    }
+
+    // Otherwise, iterate again.
+    iterate()
+  }
+
+  editor.withoutNormalizing(() => {
+    iterate()
+  })
 }
 
 /**
diff --git a/packages/slate/src/index.js b/packages/slate/src/index.js
index cc44ec829..8b85a6afe 100644
--- a/packages/slate/src/index.js
+++ b/packages/slate/src/index.js
@@ -5,7 +5,7 @@ import './interfaces/element'
 import './interfaces/range'
 
 import Block from './models/block'
-import Change from './controllers/change'
+import Change from './models/change'
 import Data from './models/data'
 import Decoration from './models/decoration'
 import Document from './models/document'
diff --git a/packages/slate/src/interfaces/object.js b/packages/slate/src/interfaces/object.js
index 8d65d6c90..8ed2b4e71 100644
--- a/packages/slate/src/interfaces/object.js
+++ b/packages/slate/src/interfaces/object.js
@@ -1,5 +1,5 @@
 import Block from '../models/block'
-import Change from '../controllers/change'
+import Change from '../models/change'
 import Decoration from '../models/decoration'
 import Document from '../models/document'
 import Editor from '../controllers/editor'
diff --git a/packages/slate/src/models/change.js b/packages/slate/src/models/change.js
new file mode 100644
index 000000000..5a4362d6d
--- /dev/null
+++ b/packages/slate/src/models/change.js
@@ -0,0 +1,88 @@
+import isPlainObject from 'is-plain-object'
+import { Record } from 'immutable'
+
+import Operation from './operation'
+import Value from './value'
+
+/**
+ * Default properties.
+ *
+ * @type {Object}
+ */
+
+const DEFAULTS = {
+  operations: undefined,
+  value: undefined,
+}
+
+/**
+ * Change.
+ *
+ * @type {Change}
+ */
+
+class Change extends Record(DEFAULTS) {
+  /**
+   * Create a new `Change` with `attrs`.
+   *
+   * @param {Object|Change} attrs
+   * @return {Change}
+   */
+
+  static create(attrs = {}) {
+    if (Change.isChange(attrs)) {
+      return attrs
+    }
+
+    if (isPlainObject(attrs)) {
+      return Change.fromJSON(attrs)
+    }
+
+    throw new Error(
+      `\`Change.create\` only accepts objects or changes, but you passed it: ${attrs}`
+    )
+  }
+
+  /**
+   * Create a `Change` from a JSON `object`.
+   *
+   * @param {Object} object
+   * @return {Change}
+   */
+
+  static fromJSON(object) {
+    const { value, operations = [] } = object
+
+    const change = new Change({
+      value: Value.create(value),
+      operations: Operation.createList(operations),
+    })
+
+    return change
+  }
+
+  /**
+   * Return a JSON representation of the change.
+   *
+   * @param {Object} options
+   * @return {Object}
+   */
+
+  toJSON(options = {}) {
+    const object = {
+      object: this.object,
+      value: this.value.toJSON(options),
+      operations: this.operations.toArray().map(o => o.toJSON(options)),
+    }
+
+    return object
+  }
+}
+
+/**
+ * Export.
+ *
+ * @type {Change}
+ */
+
+export default Change
diff --git a/packages/slate/src/plugins/commands.js b/packages/slate/src/plugins/commands.js
index c66b9b61c..b6d2b252f 100644
--- a/packages/slate/src/plugins/commands.js
+++ b/packages/slate/src/plugins/commands.js
@@ -10,15 +10,15 @@ function CommandsPlugin(commands = {}) {
    * On command, if it exists in our list of commands, call it.
    *
    * @param {Object} command
-   * @param {Change} change
+   * @param {Editor} editor
    * @param {Function} next
    */
 
-  function onCommand(command, change, next) {
+  function onCommand(command, editor, next) {
     const { type, args } = command
     const fn = commands[type]
     if (!fn) return next()
-    change.call(fn, ...args)
+    editor.command(fn, ...args)
   }
 
   /**
diff --git a/packages/slate/src/plugins/core.js b/packages/slate/src/plugins/core.js
index 782b6c097..7f924f261 100644
--- a/packages/slate/src/plugins/core.js
+++ b/packages/slate/src/plugins/core.js
@@ -97,11 +97,11 @@ function CorePlugin(options = {}) {
       {
         match: [{ object: 'block' }, { object: 'inline' }],
         nodes: [{ min: 1 }],
-        normalize: (change, error) => {
+        normalize: (editor, error) => {
           const { code, node } = error
 
           if (code === 'child_required') {
-            change.insertNodeByKey(node.key, 0, Text.create())
+            editor.insertNodeByKey(node.key, 0, Text.create())
           }
         },
       },
@@ -111,7 +111,7 @@ function CorePlugin(options = {}) {
         match: { object: 'block' },
         first: [{ object: 'block' }, { object: 'text' }],
         last: [{ object: 'block' }, { object: 'text' }],
-        normalize: (change, error) => {
+        normalize: (editor, error) => {
           const { code, node } = error
           const text = Text.create()
           let i
@@ -124,7 +124,7 @@ function CorePlugin(options = {}) {
             return
           }
 
-          change.insertNodeByKey(node.key, i, text)
+          editor.insertNodeByKey(node.key, i, text)
         },
       },
       {
@@ -133,7 +133,7 @@ function CorePlugin(options = {}) {
         last: [{ object: 'block' }, { object: 'text' }],
         previous: [{ object: 'block' }, { object: 'text' }],
         next: [{ object: 'block' }, { object: 'text' }],
-        normalize: (change, error) => {
+        normalize: (editor, error) => {
           const { code, node, index } = error
           const text = Text.create()
           let i
@@ -150,7 +150,7 @@ function CorePlugin(options = {}) {
             return
           }
 
-          change.insertNodeByKey(node.key, i, text)
+          editor.insertNodeByKey(node.key, i, text)
         },
       },
 
@@ -158,11 +158,11 @@ function CorePlugin(options = {}) {
       {
         match: { object: 'text' },
         next: [{ object: 'block' }, { object: 'inline' }],
-        normalize: (change, error) => {
+        normalize: (editor, error) => {
           const { code, next } = error
 
           if (code === 'next_sibling_object_invalid') {
-            change.mergeNodeByKey(next.key)
+            editor.mergeNodeByKey(next.key)
           }
         },
       },
diff --git a/packages/slate/src/plugins/schema.js b/packages/slate/src/plugins/schema.js
index 8c08866e8..cdd7adffb 100644
--- a/packages/slate/src/plugins/schema.js
+++ b/packages/slate/src/plugins/schema.js
@@ -87,27 +87,28 @@ function SchemaPlugin(schema) {
    * fix the invalid node, or void if the node is valid.
    *
    * @param {Node} node
+   * @param {Editor} editor
    * @param {Function} next
    * @return {Function|Void}
    */
 
-  function normalizeNode(node, next) {
-    const error = validateNode(node, () => {})
+  function normalizeNode(node, editor, next) {
+    const error = validateNode(node, editor, () => {})
     if (!error) return next()
 
-    return change => {
+    return () => {
       const { rule } = error
-      const { size } = change.operations
+      const { size } = editor.operations
 
       // First run the user-provided `normalize` function if one exists...
       if (rule.normalize) {
-        rule.normalize(change, error)
+        rule.normalize(editor, error)
       }
 
-      // If the `normalize` function did not add any operations to the change
+      // If the `normalize` function did not add any operations to the editor
       // object, it can't have normalized, so run the default one.
-      if (change.operations.size === size) {
-        defaultNormalize(change, error)
+      if (editor.operations.size === size) {
+        defaultNormalize(editor, error)
       }
     }
   }
@@ -117,11 +118,12 @@ function SchemaPlugin(schema) {
    * invalid.
    *
    * @param {Node} node
+   * @param {Editor} editor
    * @param {Function} next
    * @return {Error|Void}
    */
 
-  function validateNode(node, next) {
+  function validateNode(node, editor, next) {
     const matches = schemaRules.filter(r => testRules(node, r.match))
     const failure = validateRules(node, matches, schemaRules, { every: true })
     if (!failure) return next()
@@ -150,11 +152,11 @@ function SchemaPlugin(schema) {
 /**
  * Normalize an invalid value with `error` with default remedies.
  *
- * @param {Change} change
+ * @param {Editor} editor
  * @param {SlateError} error
  */
 
-function defaultNormalize(change, error) {
+function defaultNormalize(editor, error) {
   const { code, node, child, next, previous, key, mark } = error
 
   switch (code) {
@@ -168,8 +170,8 @@ function defaultNormalize(change, error) {
       return child.object === 'text' &&
         node.object === 'block' &&
         node.nodes.size === 1
-        ? change.removeNodeByKey(node.key)
-        : change.removeNodeByKey(child.key)
+        ? editor.removeNodeByKey(node.key)
+        : editor.removeNodeByKey(child.key)
     }
 
     case 'previous_sibling_object_invalid':
@@ -177,8 +179,8 @@ function defaultNormalize(change, error) {
       return previous.object === 'text' &&
         node.object === 'block' &&
         node.nodes.size === 1
-        ? change.removeNodeByKey(node.key)
-        : change.removeNodeByKey(previous.key)
+        ? editor.removeNodeByKey(node.key)
+        : editor.removeNodeByKey(previous.key)
     }
 
     case 'next_sibling_object_invalid':
@@ -186,8 +188,8 @@ function defaultNormalize(change, error) {
       return next.object === 'text' &&
         node.object === 'block' &&
         node.nodes.size === 1
-        ? change.removeNodeByKey(node.key)
-        : change.removeNodeByKey(next.key)
+        ? editor.removeNodeByKey(node.key)
+        : editor.removeNodeByKey(next.key)
     }
 
     case 'child_required':
@@ -195,24 +197,24 @@ function defaultNormalize(change, error) {
     case 'parent_object_invalid':
     case 'parent_type_invalid': {
       return node.object === 'document'
-        ? node.nodes.forEach(n => change.removeNodeByKey(n.key))
-        : change.removeNodeByKey(node.key)
+        ? node.nodes.forEach(n => editor.removeNodeByKey(n.key))
+        : editor.removeNodeByKey(node.key)
     }
 
     case 'node_data_invalid': {
       return node.data.get(key) === undefined && node.object !== 'document'
-        ? change.removeNodeByKey(node.key)
-        : change.setNodeByKey(node.key, { data: node.data.delete(key) })
+        ? editor.removeNodeByKey(node.key)
+        : editor.setNodeByKey(node.key, { data: node.data.delete(key) })
     }
 
     case 'node_mark_invalid': {
       return node
         .getTexts()
-        .forEach(t => change.removeMarkByKey(t.key, 0, t.text.length, mark))
+        .forEach(t => editor.removeMarkByKey(t.key, 0, t.text.length, mark))
     }
 
     default: {
-      return change.removeNodeByKey(node.key)
+      return editor.removeNodeByKey(node.key)
     }
   }
 }
diff --git a/packages/slate/test/changes/at-range/insert-text-at-range/non-matching-section-and-range.js b/packages/slate/test/changes/at-range/insert-text-at-range/non-matching-section-and-range.js
index 90588d57f..4e20ae91c 100644
--- a/packages/slate/test/changes/at-range/insert-text-at-range/non-matching-section-and-range.js
+++ b/packages/slate/test/changes/at-range/insert-text-at-range/non-matching-section-and-range.js
@@ -4,13 +4,13 @@ import { Point, Range } from 'slate'
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  const { key } = change.value.document.getFirstText()
+export default function(editor) {
+  const { key } = editor.value.document.getFirstText()
   const range = new Range({
     anchor: new Point({ key, offset: 0 }),
     focus: new Point({ key, offset: 3 }),
   })
-  change.insertTextAtRange(range, 'That')
+  editor.insertTextAtRange(range, 'That')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-mark/across-blocks.js b/packages/slate/test/commands/at-current-range/add-mark/across-blocks.js
index 11f760cb4..6313a2d70 100644
--- a/packages/slate/test/commands/at-current-range/add-mark/across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/add-mark/across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMark('bold')
+export default function(editor) {
+  editor.addMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-mark/across-inlines.js b/packages/slate/test/commands/at-current-range/add-mark/across-inlines.js
index 6b89d38ae..72e42acca 100644
--- a/packages/slate/test/commands/at-current-range/add-mark/across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/add-mark/across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMark('bold')
+export default function(editor) {
+  editor.addMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-mark/collapsed-selection.js b/packages/slate/test/commands/at-current-range/add-mark/collapsed-selection.js
index c8991b0d0..30ca0b13a 100644
--- a/packages/slate/test/commands/at-current-range/add-mark/collapsed-selection.js
+++ b/packages/slate/test/commands/at-current-range/add-mark/collapsed-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMark('bold').insertText('a')
+export default function(editor) {
+  editor.addMark('bold').insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-mark/existing-marks.js b/packages/slate/test/commands/at-current-range/add-mark/existing-marks.js
index afdd2635e..f5da4604d 100644
--- a/packages/slate/test/commands/at-current-range/add-mark/existing-marks.js
+++ b/packages/slate/test/commands/at-current-range/add-mark/existing-marks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMark('bold')
+export default function(editor) {
+  editor.addMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-mark/first-character.js b/packages/slate/test/commands/at-current-range/add-mark/first-character.js
index 6c5cdc8ae..fe192cbaf 100644
--- a/packages/slate/test/commands/at-current-range/add-mark/first-character.js
+++ b/packages/slate/test/commands/at-current-range/add-mark/first-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMark('bold')
+export default function(editor) {
+  editor.addMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-mark/last-character.js b/packages/slate/test/commands/at-current-range/add-mark/last-character.js
index f53697732..cae140cd5 100644
--- a/packages/slate/test/commands/at-current-range/add-mark/last-character.js
+++ b/packages/slate/test/commands/at-current-range/add-mark/last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMark('bold')
+export default function(editor) {
+  editor.addMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-mark/middle-character.js b/packages/slate/test/commands/at-current-range/add-mark/middle-character.js
index 2b0982a25..fdfa9e4f0 100644
--- a/packages/slate/test/commands/at-current-range/add-mark/middle-character.js
+++ b/packages/slate/test/commands/at-current-range/add-mark/middle-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMark('bold')
+export default function(editor) {
+  editor.addMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-mark/whole-word.js b/packages/slate/test/commands/at-current-range/add-mark/whole-word.js
index a32a95c24..2940b00d4 100644
--- a/packages/slate/test/commands/at-current-range/add-mark/whole-word.js
+++ b/packages/slate/test/commands/at-current-range/add-mark/whole-word.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMark('bold')
+export default function(editor) {
+  editor.addMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-mark/with-mark-object.js b/packages/slate/test/commands/at-current-range/add-mark/with-mark-object.js
index 02f8b1973..5ef6c4b74 100644
--- a/packages/slate/test/commands/at-current-range/add-mark/with-mark-object.js
+++ b/packages/slate/test/commands/at-current-range/add-mark/with-mark-object.js
@@ -4,8 +4,8 @@ import h from '../../../helpers/h'
 
 import { Mark } from 'slate'
 
-export default function(change) {
-  change.addMark(
+export default function(editor) {
+  editor.addMark(
     Mark.create({
       type: 'bold',
       data: { thing: 'value' },
diff --git a/packages/slate/test/commands/at-current-range/add-mark/with-plain-object.js b/packages/slate/test/commands/at-current-range/add-mark/with-plain-object.js
index 60291bcae..69773eef1 100644
--- a/packages/slate/test/commands/at-current-range/add-mark/with-plain-object.js
+++ b/packages/slate/test/commands/at-current-range/add-mark/with-plain-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMark({
+export default function(editor) {
+  editor.addMark({
     type: 'bold',
     data: { thing: 'value' },
   })
diff --git a/packages/slate/test/commands/at-current-range/add-marks/across-blocks.js b/packages/slate/test/commands/at-current-range/add-marks/across-blocks.js
index 9b1bef99b..a8a976e57 100644
--- a/packages/slate/test/commands/at-current-range/add-marks/across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/add-marks/across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMarks(['bold', 'italic'])
+export default function(editor) {
+  editor.addMarks(['bold', 'italic'])
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-marks/across-inlines.js b/packages/slate/test/commands/at-current-range/add-marks/across-inlines.js
index 76667c7e4..209cb7ac3 100644
--- a/packages/slate/test/commands/at-current-range/add-marks/across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/add-marks/across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMarks(['bold', 'italic'])
+export default function(editor) {
+  editor.addMarks(['bold', 'italic'])
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-marks/across-marks.js b/packages/slate/test/commands/at-current-range/add-marks/across-marks.js
index af787038a..00a4f9697 100644
--- a/packages/slate/test/commands/at-current-range/add-marks/across-marks.js
+++ b/packages/slate/test/commands/at-current-range/add-marks/across-marks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMarks(['underline'])
+export default function(editor) {
+  editor.addMarks(['underline'])
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-marks/collapsed-selection.js b/packages/slate/test/commands/at-current-range/add-marks/collapsed-selection.js
index 39cc194dd..961cce6e0 100644
--- a/packages/slate/test/commands/at-current-range/add-marks/collapsed-selection.js
+++ b/packages/slate/test/commands/at-current-range/add-marks/collapsed-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMarks(['bold', 'italic']).insertText('a')
+export default function(editor) {
+  editor.addMarks(['bold', 'italic']).insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-marks/first-character.js b/packages/slate/test/commands/at-current-range/add-marks/first-character.js
index 20db8ef85..b3673cac3 100644
--- a/packages/slate/test/commands/at-current-range/add-marks/first-character.js
+++ b/packages/slate/test/commands/at-current-range/add-marks/first-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMarks(['bold', 'italic'])
+export default function(editor) {
+  editor.addMarks(['bold', 'italic'])
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-marks/inside-mark.js b/packages/slate/test/commands/at-current-range/add-marks/inside-mark.js
index 8ba16a851..c351d2301 100644
--- a/packages/slate/test/commands/at-current-range/add-marks/inside-mark.js
+++ b/packages/slate/test/commands/at-current-range/add-marks/inside-mark.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMarks(['bold', 'underline'])
+export default function(editor) {
+  editor.addMarks(['bold', 'underline'])
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-marks/last-character.js b/packages/slate/test/commands/at-current-range/add-marks/last-character.js
index 6b6205131..07972f827 100644
--- a/packages/slate/test/commands/at-current-range/add-marks/last-character.js
+++ b/packages/slate/test/commands/at-current-range/add-marks/last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMarks(['bold', 'italic'])
+export default function(editor) {
+  editor.addMarks(['bold', 'italic'])
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-marks/middle-character.js b/packages/slate/test/commands/at-current-range/add-marks/middle-character.js
index ac96b7e35..8078f9c95 100644
--- a/packages/slate/test/commands/at-current-range/add-marks/middle-character.js
+++ b/packages/slate/test/commands/at-current-range/add-marks/middle-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMarks(['bold', 'italic'])
+export default function(editor) {
+  editor.addMarks(['bold', 'italic'])
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-marks/whole-word.js b/packages/slate/test/commands/at-current-range/add-marks/whole-word.js
index eba575791..e9b004b10 100644
--- a/packages/slate/test/commands/at-current-range/add-marks/whole-word.js
+++ b/packages/slate/test/commands/at-current-range/add-marks/whole-word.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.addMarks(['bold', 'italic'])
+export default function(editor) {
+  editor.addMarks(['bold', 'italic'])
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-marks/with-mark-object.js b/packages/slate/test/commands/at-current-range/add-marks/with-mark-object.js
index d8d0c4366..7ffc49879 100644
--- a/packages/slate/test/commands/at-current-range/add-marks/with-mark-object.js
+++ b/packages/slate/test/commands/at-current-range/add-marks/with-mark-object.js
@@ -4,7 +4,7 @@ import h from '../../../helpers/h'
 
 import { Mark } from 'slate'
 
-export default function(change) {
+export default function(editor) {
   const marks = []
 
   marks.push(
@@ -21,7 +21,7 @@ export default function(change) {
     })
   )
 
-  change.addMarks(marks)
+  editor.addMarks(marks)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/add-marks/with-plain-object.js b/packages/slate/test/commands/at-current-range/add-marks/with-plain-object.js
index acbdbf5fd..8ad161bd1 100644
--- a/packages/slate/test/commands/at-current-range/add-marks/with-plain-object.js
+++ b/packages/slate/test/commands/at-current-range/add-marks/with-plain-object.js
@@ -2,7 +2,7 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
+export default function(editor) {
   const marks = []
 
   marks.push({
@@ -15,7 +15,7 @@ export default function(change) {
     data: { thing2: 'value2' },
   })
 
-  change.addMarks(marks)
+  editor.addMarks(marks)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/empty-after-void-block.js b/packages/slate/test/commands/at-current-range/delete-backward/empty-after-void-block.js
index 3b60f3b75..b43f35ab3 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/empty-after-void-block.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/empty-after-void-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/first-character.js b/packages/slate/test/commands/at-current-range/delete-backward/first-character.js
index ded9ed370..a2ee54c63 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/first-character.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/first-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/inline-after.js b/packages/slate/test/commands/at-current-range/delete-backward/inline-after.js
index a4c9b00d0..4a0de145b 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/inline-after.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/inline-after.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/inline-before.js b/packages/slate/test/commands/at-current-range/delete-backward/inline-before.js
index 41ab7461d..0c0948025 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/inline-before.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/inline-before.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/inline-end.js b/packages/slate/test/commands/at-current-range/delete-backward/inline-end.js
index bbc07648c..b0947e12c 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/inline-end.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/inline-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/inline-inside.js b/packages/slate/test/commands/at-current-range/delete-backward/inline-inside.js
index 5db6d9f1a..1399c13b4 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/inline-inside.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/inline-inside.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/join-blocks-with-inline-void.js b/packages/slate/test/commands/at-current-range/delete-backward/join-blocks-with-inline-void.js
index e7eac5d12..74d48786f 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/join-blocks-with-inline-void.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/join-blocks-with-inline-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/join-blocks-with-inline.js b/packages/slate/test/commands/at-current-range/delete-backward/join-blocks-with-inline.js
index c25ab3cd5..391e0de75 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/join-blocks-with-inline.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/join-blocks-with-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/join-blocks.js b/packages/slate/test/commands/at-current-range/delete-backward/join-blocks.js
index 514565144..02ffd93dc 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/join-blocks.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/join-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/join-nested-blocks.js b/packages/slate/test/commands/at-current-range/delete-backward/join-nested-blocks.js
index de7c3b174..bb195d601 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/join-nested-blocks.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/join-nested-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/last-character.js b/packages/slate/test/commands/at-current-range/delete-backward/last-character.js
index 199d98b59..27f0377fa 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/last-character.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/middle-character.js b/packages/slate/test/commands/at-current-range/delete-backward/middle-character.js
index 7009b5bd5..4e1b02ef6 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/middle-character.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/middle-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/multiple-characters.js b/packages/slate/test/commands/at-current-range/delete-backward/multiple-characters.js
index 6250fd527..0c1c0fb39 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/multiple-characters.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/multiple-characters.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward(3)
+export default function(editor) {
+  editor.deleteBackward(3)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/single-non-void-block.js b/packages/slate/test/commands/at-current-range/delete-backward/single-non-void-block.js
index 816545ef7..d6fc986ce 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/single-non-void-block.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/single-non-void-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/single-void-block.js b/packages/slate/test/commands/at-current-range/delete-backward/single-void-block.js
index c22734117..a3d1fb79d 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/single-void-block.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/single-void-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-backward/start-of-document.js b/packages/slate/test/commands/at-current-range/delete-backward/start-of-document.js
index 59e800f76..0e2306178 100644
--- a/packages/slate/test/commands/at-current-range/delete-backward/start-of-document.js
+++ b/packages/slate/test/commands/at-current-range/delete-backward/start-of-document.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteBackward()
+export default function(editor) {
+  editor.deleteBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-backward/inline-after-emoji.js b/packages/slate/test/commands/at-current-range/delete-char-backward/inline-after-emoji.js
index b535832f6..06f0bda1a 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-backward/inline-after-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-backward/inline-after-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharBackward()
+export default function(editor) {
+  editor.deleteCharBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-backward/inline-end-emoji.js b/packages/slate/test/commands/at-current-range/delete-char-backward/inline-end-emoji.js
index 46d2f19b2..033a61027 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-backward/inline-end-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-backward/inline-end-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharBackward()
+export default function(editor) {
+  editor.deleteCharBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-backward/inline-inside-emoji.js b/packages/slate/test/commands/at-current-range/delete-char-backward/inline-inside-emoji.js
index b85c2ccda..2989465bb 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-backward/inline-inside-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-backward/inline-inside-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharBackward()
+export default function(editor) {
+  editor.deleteCharBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-backward/inline-only-emoji.js b/packages/slate/test/commands/at-current-range/delete-char-backward/inline-only-emoji.js
index f51880f7a..d83c039a3 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-backward/inline-only-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-backward/inline-only-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharBackward()
+export default function(editor) {
+  editor.deleteCharBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-backward/text-end.js b/packages/slate/test/commands/at-current-range/delete-char-backward/text-end.js
index 21ed969f9..6803158a5 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-backward/text-end.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-backward/text-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharBackward()
+export default function(editor) {
+  editor.deleteCharBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-backward/text-middle.js b/packages/slate/test/commands/at-current-range/delete-char-backward/text-middle.js
index f320ce47b..112924bc2 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-backward/text-middle.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-backward/text-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharBackward()
+export default function(editor) {
+  editor.deleteCharBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-backward/text-start.js b/packages/slate/test/commands/at-current-range/delete-char-backward/text-start.js
index e9d2309ee..77b5fa515 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-backward/text-start.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-backward/text-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharBackward()
+export default function(editor) {
+  editor.deleteCharBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-forward/inline-before-emoji.js b/packages/slate/test/commands/at-current-range/delete-char-forward/inline-before-emoji.js
index 82a88a377..a50875d7a 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-forward/inline-before-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-forward/inline-before-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharForward()
+export default function(editor) {
+  editor.deleteCharForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-forward/inline-middle-emoji.js b/packages/slate/test/commands/at-current-range/delete-char-forward/inline-middle-emoji.js
index a8cb79f15..54f473c71 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-forward/inline-middle-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-forward/inline-middle-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharForward()
+export default function(editor) {
+  editor.deleteCharForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-forward/inline-start-emoji.js b/packages/slate/test/commands/at-current-range/delete-char-forward/inline-start-emoji.js
index c17394cda..8a7879fe5 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-forward/inline-start-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-forward/inline-start-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharForward()
+export default function(editor) {
+  editor.deleteCharForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-forward/text-last.js b/packages/slate/test/commands/at-current-range/delete-char-forward/text-last.js
index 2200c5468..d1015aeae 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-forward/text-last.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-forward/text-last.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharForward()
+export default function(editor) {
+  editor.deleteCharForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-forward/text-middle.js b/packages/slate/test/commands/at-current-range/delete-char-forward/text-middle.js
index 4cac26a63..4492bf3ac 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-forward/text-middle.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-forward/text-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharForward()
+export default function(editor) {
+  editor.deleteCharForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-char-forward/text-start.js b/packages/slate/test/commands/at-current-range/delete-char-forward/text-start.js
index 7d56bc20a..aa032f760 100644
--- a/packages/slate/test/commands/at-current-range/delete-char-forward/text-start.js
+++ b/packages/slate/test/commands/at-current-range/delete-char-forward/text-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteCharForward()
+export default function(editor) {
+  editor.deleteCharForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/before-inline-sibling.js b/packages/slate/test/commands/at-current-range/delete-forward/before-inline-sibling.js
index 7bba5592b..9fa865a27 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/before-inline-sibling.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/before-inline-sibling.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/empty-before-void-block.js b/packages/slate/test/commands/at-current-range/delete-forward/empty-before-void-block.js
index 3ac76c0c5..14eb1665c 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/empty-before-void-block.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/empty-before-void-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/end-of-document.js b/packages/slate/test/commands/at-current-range/delete-forward/end-of-document.js
index b8efee8b1..1efa8b0a4 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/end-of-document.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/end-of-document.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/first-character.js b/packages/slate/test/commands/at-current-range/delete-forward/first-character.js
index c660e43c8..4eaa7b07d 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/first-character.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/first-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/inside-inline-sibling.js b/packages/slate/test/commands/at-current-range/delete-forward/inside-inline-sibling.js
index 3bcfe8056..4b315e99d 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/inside-inline-sibling.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/inside-inline-sibling.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/join-blocks-with-inline-void.js b/packages/slate/test/commands/at-current-range/delete-forward/join-blocks-with-inline-void.js
index f1338635f..ecc2c9e8b 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/join-blocks-with-inline-void.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/join-blocks-with-inline-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/join-blocks-with-inline.js b/packages/slate/test/commands/at-current-range/delete-forward/join-blocks-with-inline.js
index 0b9e04603..17020811b 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/join-blocks-with-inline.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/join-blocks-with-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/join-blocks.js b/packages/slate/test/commands/at-current-range/delete-forward/join-blocks.js
index 7d072bfdf..c2b159ce0 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/join-blocks.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/join-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/join-nested-blocks.js b/packages/slate/test/commands/at-current-range/delete-forward/join-nested-blocks.js
index cc0bbe9fb..7601a8478 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/join-nested-blocks.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/join-nested-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/last-character.js b/packages/slate/test/commands/at-current-range/delete-forward/last-character.js
index fc87dd2e4..4b064c43a 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/last-character.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/middle-character.js b/packages/slate/test/commands/at-current-range/delete-forward/middle-character.js
index 6870506b7..ff46f74a3 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/middle-character.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/middle-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/multiple-characters.js b/packages/slate/test/commands/at-current-range/delete-forward/multiple-characters.js
index dc5e413cf..b072f0577 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/multiple-characters.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/multiple-characters.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward(3)
+export default function(editor) {
+  editor.deleteForward(3)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/single-non-void-block.js b/packages/slate/test/commands/at-current-range/delete-forward/single-non-void-block.js
index 3f3ab1e45..09610e8ce 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/single-non-void-block.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/single-non-void-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/single-void-block.js b/packages/slate/test/commands/at-current-range/delete-forward/single-void-block.js
index bba2bded3..5aa4333e5 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/single-void-block.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/single-void-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-forward/start-text-middle-inline.js b/packages/slate/test/commands/at-current-range/delete-forward/start-text-middle-inline.js
index 8a038852e..3b2d842bb 100644
--- a/packages/slate/test/commands/at-current-range/delete-forward/start-text-middle-inline.js
+++ b/packages/slate/test/commands/at-current-range/delete-forward/start-text-middle-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteForward()
+export default function(editor) {
+  editor.deleteForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-backward/inline-middle-emoji.js b/packages/slate/test/commands/at-current-range/delete-line-backward/inline-middle-emoji.js
index 95edeaecc..4eac3d271 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-backward/inline-middle-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-backward/inline-middle-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineBackward()
+export default function(editor) {
+  editor.deleteLineBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-backward/inline-multi-voids.js b/packages/slate/test/commands/at-current-range/delete-line-backward/inline-multi-voids.js
index 97d721cfe..2117ac46f 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-backward/inline-multi-voids.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-backward/inline-multi-voids.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineBackward()
+export default function(editor) {
+  editor.deleteLineBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-backward/inline-void-first.js b/packages/slate/test/commands/at-current-range/delete-line-backward/inline-void-first.js
index 6499e7f4d..0d198c9d2 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-backward/inline-void-first.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-backward/inline-void-first.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineBackward()
+export default function(editor) {
+  editor.deleteLineBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-backward/text-end.js b/packages/slate/test/commands/at-current-range/delete-line-backward/text-end.js
index 80d67d796..a590f6af9 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-backward/text-end.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-backward/text-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineBackward()
+export default function(editor) {
+  editor.deleteLineBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-backward/text-start.js b/packages/slate/test/commands/at-current-range/delete-line-backward/text-start.js
index 982542398..4bc9eb2ed 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-backward/text-start.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-backward/text-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineBackward()
+export default function(editor) {
+  editor.deleteLineBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-backward/word-middle.js b/packages/slate/test/commands/at-current-range/delete-line-backward/word-middle.js
index 595a7f16d..ae089f93d 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-backward/word-middle.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-backward/word-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineBackward()
+export default function(editor) {
+  editor.deleteLineBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-forward/inline-middle-emoji.js b/packages/slate/test/commands/at-current-range/delete-line-forward/inline-middle-emoji.js
index d940fd1f5..bf1ba9289 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-forward/inline-middle-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-forward/inline-middle-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineForward()
+export default function(editor) {
+  editor.deleteLineForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-forward/inline-multi-voids.js b/packages/slate/test/commands/at-current-range/delete-line-forward/inline-multi-voids.js
index 81f2c883d..669a13af5 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-forward/inline-multi-voids.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-forward/inline-multi-voids.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineForward()
+export default function(editor) {
+  editor.deleteLineForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-forward/inline-void-end.js b/packages/slate/test/commands/at-current-range/delete-line-forward/inline-void-end.js
index 24c03bcdc..d5da2d466 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-forward/inline-void-end.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-forward/inline-void-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineForward()
+export default function(editor) {
+  editor.deleteLineForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-forward/text-end.js b/packages/slate/test/commands/at-current-range/delete-line-forward/text-end.js
index 8d15e5d78..5679ff8bd 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-forward/text-end.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-forward/text-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineForward()
+export default function(editor) {
+  editor.deleteLineForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-forward/text-start.js b/packages/slate/test/commands/at-current-range/delete-line-forward/text-start.js
index 726cae8c0..0b2986435 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-forward/text-start.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-forward/text-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineForward()
+export default function(editor) {
+  editor.deleteLineForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-line-forward/word-middle.js b/packages/slate/test/commands/at-current-range/delete-line-forward/word-middle.js
index 5fcd63ef7..93bcb6627 100644
--- a/packages/slate/test/commands/at-current-range/delete-line-forward/word-middle.js
+++ b/packages/slate/test/commands/at-current-range/delete-line-forward/word-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteLineForward()
+export default function(editor) {
+  editor.deleteLineForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-word-backward/inline-after-emoji.js b/packages/slate/test/commands/at-current-range/delete-word-backward/inline-after-emoji.js
index e8919708a..e5dabbdaf 100644
--- a/packages/slate/test/commands/at-current-range/delete-word-backward/inline-after-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-word-backward/inline-after-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteWordBackward()
+export default function(editor) {
+  editor.deleteWordBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-word-backward/inline-middle-emoji.js b/packages/slate/test/commands/at-current-range/delete-word-backward/inline-middle-emoji.js
index 3671b1130..95fa1d3ae 100644
--- a/packages/slate/test/commands/at-current-range/delete-word-backward/inline-middle-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-word-backward/inline-middle-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteWordBackward()
+export default function(editor) {
+  editor.deleteWordBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-word-backward/join-blocks.js b/packages/slate/test/commands/at-current-range/delete-word-backward/join-blocks.js
index 88075c003..498fe79c3 100644
--- a/packages/slate/test/commands/at-current-range/delete-word-backward/join-blocks.js
+++ b/packages/slate/test/commands/at-current-range/delete-word-backward/join-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteWordBackward()
+export default function(editor) {
+  editor.deleteWordBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-word-backward/text-end.js b/packages/slate/test/commands/at-current-range/delete-word-backward/text-end.js
index 31e2b116d..92dc1be8e 100644
--- a/packages/slate/test/commands/at-current-range/delete-word-backward/text-end.js
+++ b/packages/slate/test/commands/at-current-range/delete-word-backward/text-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteWordBackward()
+export default function(editor) {
+  editor.deleteWordBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-word-backward/word-middle.js b/packages/slate/test/commands/at-current-range/delete-word-backward/word-middle.js
index 151c21935..0e45bf385 100644
--- a/packages/slate/test/commands/at-current-range/delete-word-backward/word-middle.js
+++ b/packages/slate/test/commands/at-current-range/delete-word-backward/word-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteWordBackward()
+export default function(editor) {
+  editor.deleteWordBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-word-forward/inline-after-emoji.js b/packages/slate/test/commands/at-current-range/delete-word-forward/inline-after-emoji.js
index 4258d8c39..ac602faf2 100644
--- a/packages/slate/test/commands/at-current-range/delete-word-forward/inline-after-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-word-forward/inline-after-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteWordForward()
+export default function(editor) {
+  editor.deleteWordForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-word-forward/inline-middle-emoji.js b/packages/slate/test/commands/at-current-range/delete-word-forward/inline-middle-emoji.js
index 3af8e0c47..abe7e59ef 100644
--- a/packages/slate/test/commands/at-current-range/delete-word-forward/inline-middle-emoji.js
+++ b/packages/slate/test/commands/at-current-range/delete-word-forward/inline-middle-emoji.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteWordForward()
+export default function(editor) {
+  editor.deleteWordForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-word-forward/join-blocks.js b/packages/slate/test/commands/at-current-range/delete-word-forward/join-blocks.js
index 2651be7fa..2ae78fab1 100644
--- a/packages/slate/test/commands/at-current-range/delete-word-forward/join-blocks.js
+++ b/packages/slate/test/commands/at-current-range/delete-word-forward/join-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteWordForward()
+export default function(editor) {
+  editor.deleteWordForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-word-forward/word-middle.js b/packages/slate/test/commands/at-current-range/delete-word-forward/word-middle.js
index 9a892b831..0db74ee73 100644
--- a/packages/slate/test/commands/at-current-range/delete-word-forward/word-middle.js
+++ b/packages/slate/test/commands/at-current-range/delete-word-forward/word-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteWordForward()
+export default function(editor) {
+  editor.deleteWordForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete-word-forward/word-start.js b/packages/slate/test/commands/at-current-range/delete-word-forward/word-start.js
index d1d4bd846..68dc1869a 100644
--- a/packages/slate/test/commands/at-current-range/delete-word-forward/word-start.js
+++ b/packages/slate/test/commands/at-current-range/delete-word-forward/word-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.deleteWordForward()
+export default function(editor) {
+  editor.deleteWordForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/across-blocks-inlines.js b/packages/slate/test/commands/at-current-range/delete/across-blocks-inlines.js
index 44570cae8..28b09929f 100644
--- a/packages/slate/test/commands/at-current-range/delete/across-blocks-inlines.js
+++ b/packages/slate/test/commands/at-current-range/delete/across-blocks-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/across-depths.js b/packages/slate/test/commands/at-current-range/delete/across-depths.js
index d7c722ac2..855c24b5d 100644
--- a/packages/slate/test/commands/at-current-range/delete/across-depths.js
+++ b/packages/slate/test/commands/at-current-range/delete/across-depths.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/across-nested-blocks.js b/packages/slate/test/commands/at-current-range/delete/across-nested-blocks.js
index 0d10323a2..eed09a668 100644
--- a/packages/slate/test/commands/at-current-range/delete/across-nested-blocks.js
+++ b/packages/slate/test/commands/at-current-range/delete/across-nested-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/across-texts-and-inlines.js b/packages/slate/test/commands/at-current-range/delete/across-texts-and-inlines.js
index d57ebc9d1..2a33fe9a6 100644
--- a/packages/slate/test/commands/at-current-range/delete/across-texts-and-inlines.js
+++ b/packages/slate/test/commands/at-current-range/delete/across-texts-and-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/before-inline-sibling.js b/packages/slate/test/commands/at-current-range/delete/before-inline-sibling.js
index b9122478b..506d5b150 100644
--- a/packages/slate/test/commands/at-current-range/delete/before-inline-sibling.js
+++ b/packages/slate/test/commands/at-current-range/delete/before-inline-sibling.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/first-character.js b/packages/slate/test/commands/at-current-range/delete/first-character.js
index c25036a52..4889fa5a9 100644
--- a/packages/slate/test/commands/at-current-range/delete/first-character.js
+++ b/packages/slate/test/commands/at-current-range/delete/first-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/hanging-selection-multiple-blocks.js b/packages/slate/test/commands/at-current-range/delete/hanging-selection-multiple-blocks.js
index dc3d6409a..bffde4769 100644
--- a/packages/slate/test/commands/at-current-range/delete/hanging-selection-multiple-blocks.js
+++ b/packages/slate/test/commands/at-current-range/delete/hanging-selection-multiple-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/hanging-selection-single-block.js b/packages/slate/test/commands/at-current-range/delete/hanging-selection-single-block.js
index 1fe732486..7717f136b 100644
--- a/packages/slate/test/commands/at-current-range/delete/hanging-selection-single-block.js
+++ b/packages/slate/test/commands/at-current-range/delete/hanging-selection-single-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/inside-inline-sibling.js b/packages/slate/test/commands/at-current-range/delete/inside-inline-sibling.js
index 3355048f8..56641decc 100644
--- a/packages/slate/test/commands/at-current-range/delete/inside-inline-sibling.js
+++ b/packages/slate/test/commands/at-current-range/delete/inside-inline-sibling.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/join-blocks-and-trim.js b/packages/slate/test/commands/at-current-range/delete/join-blocks-and-trim.js
index 2a1e64779..6b0276cef 100644
--- a/packages/slate/test/commands/at-current-range/delete/join-blocks-and-trim.js
+++ b/packages/slate/test/commands/at-current-range/delete/join-blocks-and-trim.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/join-blocks-with-inlines.js b/packages/slate/test/commands/at-current-range/delete/join-blocks-with-inlines.js
index 87ad29f98..2d8595746 100644
--- a/packages/slate/test/commands/at-current-range/delete/join-blocks-with-inlines.js
+++ b/packages/slate/test/commands/at-current-range/delete/join-blocks-with-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/join-blocks.js b/packages/slate/test/commands/at-current-range/delete/join-blocks.js
index e1554ec5e..1f1d874a2 100644
--- a/packages/slate/test/commands/at-current-range/delete/join-blocks.js
+++ b/packages/slate/test/commands/at-current-range/delete/join-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/join-double-nested-blocks.js b/packages/slate/test/commands/at-current-range/delete/join-double-nested-blocks.js
index 1ecdb0443..23910db1b 100644
--- a/packages/slate/test/commands/at-current-range/delete/join-double-nested-blocks.js
+++ b/packages/slate/test/commands/at-current-range/delete/join-double-nested-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/join-nested-blocks.js b/packages/slate/test/commands/at-current-range/delete/join-nested-blocks.js
index f4dfb063d..06e09d25e 100644
--- a/packages/slate/test/commands/at-current-range/delete/join-nested-blocks.js
+++ b/packages/slate/test/commands/at-current-range/delete/join-nested-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/last-character.js b/packages/slate/test/commands/at-current-range/delete/last-character.js
index ccb9cd9d4..a33fe1533 100644
--- a/packages/slate/test/commands/at-current-range/delete/last-character.js
+++ b/packages/slate/test/commands/at-current-range/delete/last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/middle-character.js b/packages/slate/test/commands/at-current-range/delete/middle-character.js
index 00d6f67ef..6b8debfb4 100644
--- a/packages/slate/test/commands/at-current-range/delete/middle-character.js
+++ b/packages/slate/test/commands/at-current-range/delete/middle-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/nested-block.js b/packages/slate/test/commands/at-current-range/delete/nested-block.js
index 3488b7c7c..499fe9f11 100644
--- a/packages/slate/test/commands/at-current-range/delete/nested-block.js
+++ b/packages/slate/test/commands/at-current-range/delete/nested-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-only-non-void.js b/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-only-non-void.js
index 090207500..596f57668 100644
--- a/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-only-non-void.js
+++ b/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-only-non-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void-and-up-to-start-of-void.js b/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void-and-up-to-start-of-void.js
index 4061fdbd8..4b2cd5dd2 100644
--- a/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void-and-up-to-start-of-void.js
+++ b/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void-and-up-to-start-of-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void-and-void.js b/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void-and-void.js
index 4061fdbd8..4b2cd5dd2 100644
--- a/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void-and-void.js
+++ b/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void-and-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void.js b/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void.js
index b36e52852..bdbabd43b 100644
--- a/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void.js
+++ b/packages/slate/test/commands/at-current-range/delete/non-void-block-as-first-with-void-siblings-partially-non-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/non-void-triple.js b/packages/slate/test/commands/at-current-range/delete/non-void-triple.js
index 1b964b9cb..adf54cde1 100644
--- a/packages/slate/test/commands/at-current-range/delete/non-void-triple.js
+++ b/packages/slate/test/commands/at-current-range/delete/non-void-triple.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-all.js b/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-all.js
index fe1bb05cf..89ff8d78a 100644
--- a/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-all.js
+++ b/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-all.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-backward-selection-all.js b/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-backward-selection-all.js
index 867c87843..74c2facff 100644
--- a/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-backward-selection-all.js
+++ b/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-backward-selection-all.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-only-void.js b/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-only-void.js
index 4b50127eb..d536b1381 100644
--- a/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-only-void.js
+++ b/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-only-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-select-void-and-next-word.js b/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-select-void-and-next-word.js
index 06376f6df..b724d3714 100644
--- a/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-select-void-and-next-word.js
+++ b/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-select-void-and-next-word.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-select-void-end-and-next-word.js b/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-select-void-end-and-next-word.js
index 06376f6df..b724d3714 100644
--- a/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-select-void-end-and-next-word.js
+++ b/packages/slate/test/commands/at-current-range/delete/void-block-as-first-with-non-void-siblings-select-void-end-and-next-word.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/void-block-as-only.js b/packages/slate/test/commands/at-current-range/delete/void-block-as-only.js
index f7a459a33..1fe3d9c58 100644
--- a/packages/slate/test/commands/at-current-range/delete/void-block-as-only.js
+++ b/packages/slate/test/commands/at-current-range/delete/void-block-as-only.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/void-blocks-as-first-with-non-void-siblings-only-first-void.js b/packages/slate/test/commands/at-current-range/delete/void-blocks-as-first-with-non-void-siblings-only-first-void.js
index 019ec3295..8321662ca 100644
--- a/packages/slate/test/commands/at-current-range/delete/void-blocks-as-first-with-non-void-siblings-only-first-void.js
+++ b/packages/slate/test/commands/at-current-range/delete/void-blocks-as-first-with-non-void-siblings-only-first-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/void-blocks-as-first-with-non-void-siblings-only-voids.js b/packages/slate/test/commands/at-current-range/delete/void-blocks-as-first-with-non-void-siblings-only-voids.js
index 23ab7e734..b4a0f7e81 100644
--- a/packages/slate/test/commands/at-current-range/delete/void-blocks-as-first-with-non-void-siblings-only-voids.js
+++ b/packages/slate/test/commands/at-current-range/delete/void-blocks-as-first-with-non-void-siblings-only-voids.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/void-inline-as-first-with-non-void-block-next.js b/packages/slate/test/commands/at-current-range/delete/void-inline-as-first-with-non-void-block-next.js
index bf474ef84..5b3bbdc94 100644
--- a/packages/slate/test/commands/at-current-range/delete/void-inline-as-first-with-non-void-block-next.js
+++ b/packages/slate/test/commands/at-current-range/delete/void-inline-as-first-with-non-void-block-next.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/void-inline-as-first-with-non-void-sibling.js b/packages/slate/test/commands/at-current-range/delete/void-inline-as-first-with-non-void-sibling.js
index c6057e166..65f48ed6d 100644
--- a/packages/slate/test/commands/at-current-range/delete/void-inline-as-first-with-non-void-sibling.js
+++ b/packages/slate/test/commands/at-current-range/delete/void-inline-as-first-with-non-void-sibling.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/void-inline-as-last-with-non-void-previous-siblings.js b/packages/slate/test/commands/at-current-range/delete/void-inline-as-last-with-non-void-previous-siblings.js
index 5d3d79227..245c4e9ec 100644
--- a/packages/slate/test/commands/at-current-range/delete/void-inline-as-last-with-non-void-previous-siblings.js
+++ b/packages/slate/test/commands/at-current-range/delete/void-inline-as-last-with-non-void-previous-siblings.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/whole-inline.js b/packages/slate/test/commands/at-current-range/delete/whole-inline.js
index 7e93ef2c3..602317162 100644
--- a/packages/slate/test/commands/at-current-range/delete/whole-inline.js
+++ b/packages/slate/test/commands/at-current-range/delete/whole-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/delete/whole-word.js b/packages/slate/test/commands/at-current-range/delete/whole-word.js
index 2d7a97adc..3aaee3add 100644
--- a/packages/slate/test/commands/at-current-range/delete/whole-word.js
+++ b/packages/slate/test/commands/at-current-range/delete/whole-word.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.delete()
+export default function(editor) {
+  editor.delete()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-block/block-end.js b/packages/slate/test/commands/at-current-range/insert-block/block-end.js
index 85949f0b7..896a4a08d 100644
--- a/packages/slate/test/commands/at-current-range/insert-block/block-end.js
+++ b/packages/slate/test/commands/at-current-range/insert-block/block-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertBlock('quote')
+export default function(editor) {
+  editor.insertBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-block/block-middle.js b/packages/slate/test/commands/at-current-range/insert-block/block-middle.js
index aa91b5ab5..2f93cf7fd 100644
--- a/packages/slate/test/commands/at-current-range/insert-block/block-middle.js
+++ b/packages/slate/test/commands/at-current-range/insert-block/block-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertBlock('quote')
+export default function(editor) {
+  editor.insertBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-block/block-start.js b/packages/slate/test/commands/at-current-range/insert-block/block-start.js
index 2933cb3e7..1b31d9cb3 100644
--- a/packages/slate/test/commands/at-current-range/insert-block/block-start.js
+++ b/packages/slate/test/commands/at-current-range/insert-block/block-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertBlock('quote')
+export default function(editor) {
+  editor.insertBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-block/is-empty.js b/packages/slate/test/commands/at-current-range/insert-block/is-empty.js
index 2c79230ce..86692e8d7 100644
--- a/packages/slate/test/commands/at-current-range/insert-block/is-empty.js
+++ b/packages/slate/test/commands/at-current-range/insert-block/is-empty.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertBlock('quote')
+export default function(editor) {
+  editor.insertBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-block/is-inline-void.js b/packages/slate/test/commands/at-current-range/insert-block/is-inline-void.js
index feabe111c..d7f3f9f6c 100644
--- a/packages/slate/test/commands/at-current-range/insert-block/is-inline-void.js
+++ b/packages/slate/test/commands/at-current-range/insert-block/is-inline-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertBlock('quote')
+export default function(editor) {
+  editor.insertBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-block/is-void-end.js b/packages/slate/test/commands/at-current-range/insert-block/is-void-end.js
index 0781baf72..a484aab8a 100644
--- a/packages/slate/test/commands/at-current-range/insert-block/is-void-end.js
+++ b/packages/slate/test/commands/at-current-range/insert-block/is-void-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertBlock('quote')
+export default function(editor) {
+  editor.insertBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-block/is-void-start.js b/packages/slate/test/commands/at-current-range/insert-block/is-void-start.js
index ec663c430..18bf5ed60 100644
--- a/packages/slate/test/commands/at-current-range/insert-block/is-void-start.js
+++ b/packages/slate/test/commands/at-current-range/insert-block/is-void-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertBlock('quote')
+export default function(editor) {
+  editor.insertBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-block/with-block.js b/packages/slate/test/commands/at-current-range/insert-block/with-block.js
index 71764622c..a3ab20bf1 100644
--- a/packages/slate/test/commands/at-current-range/insert-block/with-block.js
+++ b/packages/slate/test/commands/at-current-range/insert-block/with-block.js
@@ -3,8 +3,8 @@
 import h from '../../../helpers/h'
 import { Block } from 'slate'
 
-export default function(change) {
-  change.insertBlock(Block.create({ type: 'quote' }))
+export default function(editor) {
+  editor.insertBlock(Block.create({ type: 'quote' }))
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-block/with-object.js b/packages/slate/test/commands/at-current-range/insert-block/with-object.js
index 63ac5f3be..f2999cd71 100644
--- a/packages/slate/test/commands/at-current-range/insert-block/with-object.js
+++ b/packages/slate/test/commands/at-current-range/insert-block/with-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertBlock({ type: 'quote' })
+export default function(editor) {
+  editor.insertBlock({ type: 'quote' })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/end-block-multiple-blocks.js b/packages/slate/test/commands/at-current-range/insert-fragment/end-block-multiple-blocks.js
index 1fc24e5ba..fdfa818d2 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/end-block-multiple-blocks.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/end-block-multiple-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>one</quote>
       <quote>two</quote>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/end-block.js b/packages/slate/test/commands/at-current-range/insert-fragment/end-block.js
index f8f3fb054..f7da4747d 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/end-block.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/end-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>fragment</quote>
     </document>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/end-inline.js b/packages/slate/test/commands/at-current-range/insert-fragment/end-inline.js
index b1aa3f4da..12329bfe7 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/end-inline.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/end-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>fragment</quote>
     </document>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/fragment-multiple-blocks.js b/packages/slate/test/commands/at-current-range/insert-fragment/fragment-multiple-blocks.js
index 6c8e5106a..cf03f6846 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/fragment-multiple-blocks.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/fragment-multiple-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>one</quote>
       <quote>two</quote>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/fragment-nested-blocks.js b/packages/slate/test/commands/at-current-range/insert-fragment/fragment-nested-blocks.js
index 6247a6735..872c722c1 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/fragment-nested-blocks.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/fragment-nested-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>
         <quote>one</quote>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/hanging-selection-single-block.js b/packages/slate/test/commands/at-current-range/insert-fragment/hanging-selection-single-block.js
index 7fe430cd0..dd1179544 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/hanging-selection-single-block.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/hanging-selection-single-block.js
@@ -10,8 +10,8 @@ const fragment = (
   </document>
 )
 
-export default function(change) {
-  change.insertFragment(fragment)
+export default function(editor) {
+  editor.insertFragment(fragment)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/merge-deep-nested.js b/packages/slate/test/commands/at-current-range/insert-fragment/merge-deep-nested.js
index f96c6ddcf..950c19ef9 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/merge-deep-nested.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/merge-deep-nested.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <code>
         <quote>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/merge-lists.js b/packages/slate/test/commands/at-current-range/insert-fragment/merge-lists.js
index e5f77feaf..d55ea091e 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/merge-lists.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/merge-lists.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <list>
         <item>3</item>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/middle-block.js b/packages/slate/test/commands/at-current-range/insert-fragment/middle-block.js
index d0c180f4d..02221340a 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/middle-block.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/middle-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>fragment</quote>
     </document>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/middle-inline-fragment-inline.js b/packages/slate/test/commands/at-current-range/insert-fragment/middle-inline-fragment-inline.js
index 29fd0f2e2..c4723fb98 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/middle-inline-fragment-inline.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/middle-inline-fragment-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>
         <hashtag>fragment</hashtag>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/middle-inline.js b/packages/slate/test/commands/at-current-range/insert-fragment/middle-inline.js
index e79895968..0baadba0c 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/middle-inline.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/middle-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>fragment</quote>
     </document>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/nested-block-fragment-nested-blocks.js b/packages/slate/test/commands/at-current-range/insert-fragment/nested-block-fragment-nested-blocks.js
index 0ba73cfa1..728a5794f 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/nested-block-fragment-nested-blocks.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/nested-block-fragment-nested-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>
         <quote>one</quote>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/start-block-multiple-blocks.js b/packages/slate/test/commands/at-current-range/insert-fragment/start-block-multiple-blocks.js
index c6a9fabc2..f8779423d 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/start-block-multiple-blocks.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/start-block-multiple-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>one</quote>
       <quote>two</quote>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/start-block.js b/packages/slate/test/commands/at-current-range/insert-fragment/start-block.js
index 4abd37ba8..5f3f69173 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/start-block.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/start-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>fragment</quote>
     </document>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/start-inline.js b/packages/slate/test/commands/at-current-range/insert-fragment/start-inline.js
index bba53262e..4437ae281 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/start-inline.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/start-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>fragment</quote>
     </document>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/start-second-block.js b/packages/slate/test/commands/at-current-range/insert-fragment/start-second-block.js
index 1f2d1a744..07af46350 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/start-second-block.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/start-second-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>fragment</quote>
     </document>
diff --git a/packages/slate/test/commands/at-current-range/insert-fragment/with-delete-across-blocks.js b/packages/slate/test/commands/at-current-range/insert-fragment/with-delete-across-blocks.js
index ccd65d49a..8673e1bfe 100644
--- a/packages/slate/test/commands/at-current-range/insert-fragment/with-delete-across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/insert-fragment/with-delete-across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragment(
+export default function(editor) {
+  editor.insertFragment(
     <document>
       <quote>fragment</quote>
     </document>
diff --git a/packages/slate/test/commands/at-current-range/insert-inline/block-end.js b/packages/slate/test/commands/at-current-range/insert-inline/block-end.js
index 5164f3801..f41588b0f 100644
--- a/packages/slate/test/commands/at-current-range/insert-inline/block-end.js
+++ b/packages/slate/test/commands/at-current-range/insert-inline/block-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertInline('emoji')
+export default function(editor) {
+  editor.insertInline('emoji')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-inline/block-middle.js b/packages/slate/test/commands/at-current-range/insert-inline/block-middle.js
index 84e75a104..e688b20ca 100644
--- a/packages/slate/test/commands/at-current-range/insert-inline/block-middle.js
+++ b/packages/slate/test/commands/at-current-range/insert-inline/block-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertInline('emoji')
+export default function(editor) {
+  editor.insertInline('emoji')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-inline/block-start.js b/packages/slate/test/commands/at-current-range/insert-inline/block-start.js
index 1197e8db5..491b45b5a 100644
--- a/packages/slate/test/commands/at-current-range/insert-inline/block-start.js
+++ b/packages/slate/test/commands/at-current-range/insert-inline/block-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertInline('emoji')
+export default function(editor) {
+  editor.insertInline('emoji')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-inline/inline-middle.js b/packages/slate/test/commands/at-current-range/insert-inline/inline-middle.js
index 480fb087e..324dbed10 100644
--- a/packages/slate/test/commands/at-current-range/insert-inline/inline-middle.js
+++ b/packages/slate/test/commands/at-current-range/insert-inline/inline-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertInline('emoji')
+export default function(editor) {
+  editor.insertInline('emoji')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-inline/is-empty.js b/packages/slate/test/commands/at-current-range/insert-inline/is-empty.js
index a3f803840..8dd2e4c61 100644
--- a/packages/slate/test/commands/at-current-range/insert-inline/is-empty.js
+++ b/packages/slate/test/commands/at-current-range/insert-inline/is-empty.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertInline('emoji')
+export default function(editor) {
+  editor.insertInline('emoji')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-inline/is-void.js b/packages/slate/test/commands/at-current-range/insert-inline/is-void.js
index 05e65b24e..9c459ce13 100644
--- a/packages/slate/test/commands/at-current-range/insert-inline/is-void.js
+++ b/packages/slate/test/commands/at-current-range/insert-inline/is-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertInline('emoji')
+export default function(editor) {
+  editor.insertInline('emoji')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-inline/with-inline.js b/packages/slate/test/commands/at-current-range/insert-inline/with-inline.js
index 1f4933ae0..00bbc9911 100644
--- a/packages/slate/test/commands/at-current-range/insert-inline/with-inline.js
+++ b/packages/slate/test/commands/at-current-range/insert-inline/with-inline.js
@@ -3,8 +3,8 @@
 import h from '../../../helpers/h'
 import { Inline } from 'slate'
 
-export default function(change) {
-  change.insertInline(Inline.create('emoji'))
+export default function(editor) {
+  editor.insertInline(Inline.create('emoji'))
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/after-mark.js b/packages/slate/test/commands/at-current-range/insert-text/after-mark.js
index 90e4bc46b..f373ed006 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/after-mark.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/after-mark.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('a')
+export default function(editor) {
+  editor.insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/before-mark.js b/packages/slate/test/commands/at-current-range/insert-text/before-mark.js
index c568f4a2d..9a8e064b7 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/before-mark.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/before-mark.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('a')
+export default function(editor) {
+  editor.insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/blocks-with-overlapping-marks.js b/packages/slate/test/commands/at-current-range/insert-text/blocks-with-overlapping-marks.js
index 579226956..1282da352 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/blocks-with-overlapping-marks.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/blocks-with-overlapping-marks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('is ')
+export default function(editor) {
+  editor.insertText('is ')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/during-mark.js b/packages/slate/test/commands/at-current-range/insert-text/during-mark.js
index f30165b02..313d41607 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/during-mark.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/during-mark.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('a')
+export default function(editor) {
+  editor.insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/empty-block-with-mark.js b/packages/slate/test/commands/at-current-range/insert-text/empty-block-with-mark.js
index 4596489d4..dce2c70c0 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/empty-block-with-mark.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/empty-block-with-mark.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('Cat')
+export default function(editor) {
+  editor.insertText('Cat')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/expanded-with-mark.js b/packages/slate/test/commands/at-current-range/insert-text/expanded-with-mark.js
index 25a25d2d4..ae473c606 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/expanded-with-mark.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/expanded-with-mark.js
@@ -6,9 +6,9 @@ import h from '../../../helpers/h'
  * This test makes sure a normalization happens on insertText on expandedRange
  */
 
-export default function(change) {
-  change.insertText('a')
-  change.insertText('b')
+export default function(editor) {
+  editor.insertText('a')
+  editor.insertText('b')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/first-character.js b/packages/slate/test/commands/at-current-range/insert-text/first-character.js
index d8d02a9df..bf7a9383b 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/first-character.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/first-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('a')
+export default function(editor) {
+  editor.insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/first-space.js b/packages/slate/test/commands/at-current-range/insert-text/first-space.js
index 92817174c..ac295ca68 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/first-space.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/first-space.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText(' ')
+export default function(editor) {
+  editor.insertText(' ')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/first-words.js b/packages/slate/test/commands/at-current-range/insert-text/first-words.js
index 585c1ec88..a9b5b01cb 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/first-words.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/first-words.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('a few words')
+export default function(editor) {
+  editor.insertText('a few words')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/hanging-selection-multiple-blocks.js b/packages/slate/test/commands/at-current-range/insert-text/hanging-selection-multiple-blocks.js
index abbbb1145..66a8a4bfb 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/hanging-selection-multiple-blocks.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/hanging-selection-multiple-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('a')
+export default function(editor) {
+  editor.insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/hanging-selection-single-block.js b/packages/slate/test/commands/at-current-range/insert-text/hanging-selection-single-block.js
index 1dcd13263..cda360d16 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/hanging-selection-single-block.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/hanging-selection-single-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('a')
+export default function(editor) {
+  editor.insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/inside-void.js b/packages/slate/test/commands/at-current-range/insert-text/inside-void.js
index 79640d8c8..3fe3bb209 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/inside-void.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/inside-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('a')
+export default function(editor) {
+  editor.insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/last-character.js b/packages/slate/test/commands/at-current-range/insert-text/last-character.js
index 902a342d4..c19622375 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/last-character.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('a')
+export default function(editor) {
+  editor.insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/last-space.js b/packages/slate/test/commands/at-current-range/insert-text/last-space.js
index b5a045735..eeafc13e8 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/last-space.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/last-space.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText(' ')
+export default function(editor) {
+  editor.insertText(' ')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/last-words.js b/packages/slate/test/commands/at-current-range/insert-text/last-words.js
index b144919c4..190d20aad 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/last-words.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/last-words.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText(' a few words')
+export default function(editor) {
+  editor.insertText(' a few words')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/middle-character.js b/packages/slate/test/commands/at-current-range/insert-text/middle-character.js
index 86f7e1f6f..feae12a02 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/middle-character.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/middle-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText('a')
+export default function(editor) {
+  editor.insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/middle-space.js b/packages/slate/test/commands/at-current-range/insert-text/middle-space.js
index f63eae718..31be79924 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/middle-space.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/middle-space.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText(' ')
+export default function(editor) {
+  editor.insertText(' ')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/middle-words.js b/packages/slate/test/commands/at-current-range/insert-text/middle-words.js
index dcb8a21e6..176cfd65f 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/middle-words.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/middle-words.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertText(' a few words ')
+export default function(editor) {
+  editor.insertText(' a few words ')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/insert-text/with-marks.js b/packages/slate/test/commands/at-current-range/insert-text/with-marks.js
index 610b7d1b7..45945f651 100644
--- a/packages/slate/test/commands/at-current-range/insert-text/with-marks.js
+++ b/packages/slate/test/commands/at-current-range/insert-text/with-marks.js
@@ -3,9 +3,9 @@
 import h from '../../../helpers/h'
 import { Mark } from 'slate'
 
-export default function(change) {
+export default function(editor) {
   const marks = Mark.createSet([{ type: 'bold' }])
-  change.insertText('a', marks)
+  editor.insertText('a', marks)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/remove-mark/across-blocks.js b/packages/slate/test/commands/at-current-range/remove-mark/across-blocks.js
index 61b29470e..c93a989af 100644
--- a/packages/slate/test/commands/at-current-range/remove-mark/across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/remove-mark/across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeMark('bold')
+export default function(editor) {
+  editor.removeMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/remove-mark/across-inlines.js b/packages/slate/test/commands/at-current-range/remove-mark/across-inlines.js
index 32bb08b7d..fa75848da 100644
--- a/packages/slate/test/commands/at-current-range/remove-mark/across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/remove-mark/across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeMark('bold')
+export default function(editor) {
+  editor.removeMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/remove-mark/collapsed-selection.js b/packages/slate/test/commands/at-current-range/remove-mark/collapsed-selection.js
index 86c3a6c70..25a33d698 100644
--- a/packages/slate/test/commands/at-current-range/remove-mark/collapsed-selection.js
+++ b/packages/slate/test/commands/at-current-range/remove-mark/collapsed-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change
+export default function(editor) {
+  editor
     .addMark('bold')
     .removeMark('bold')
     .insertText('a')
diff --git a/packages/slate/test/commands/at-current-range/remove-mark/existing-marks.js b/packages/slate/test/commands/at-current-range/remove-mark/existing-marks.js
index aa5d2f511..c1b788f26 100644
--- a/packages/slate/test/commands/at-current-range/remove-mark/existing-marks.js
+++ b/packages/slate/test/commands/at-current-range/remove-mark/existing-marks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeMark('bold')
+export default function(editor) {
+  editor.removeMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/remove-mark/first-character.js b/packages/slate/test/commands/at-current-range/remove-mark/first-character.js
index 9b9bc8052..e1cf38f14 100644
--- a/packages/slate/test/commands/at-current-range/remove-mark/first-character.js
+++ b/packages/slate/test/commands/at-current-range/remove-mark/first-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeMark('bold')
+export default function(editor) {
+  editor.removeMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/remove-mark/last-character.js b/packages/slate/test/commands/at-current-range/remove-mark/last-character.js
index 283e0c473..53877ca98 100644
--- a/packages/slate/test/commands/at-current-range/remove-mark/last-character.js
+++ b/packages/slate/test/commands/at-current-range/remove-mark/last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeMark('bold')
+export default function(editor) {
+  editor.removeMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/remove-mark/middle-character.js b/packages/slate/test/commands/at-current-range/remove-mark/middle-character.js
index 5589a7b3e..617065c3c 100644
--- a/packages/slate/test/commands/at-current-range/remove-mark/middle-character.js
+++ b/packages/slate/test/commands/at-current-range/remove-mark/middle-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeMark('bold')
+export default function(editor) {
+  editor.removeMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/remove-mark/whole-word.js b/packages/slate/test/commands/at-current-range/remove-mark/whole-word.js
index 27b98093e..e109a378b 100644
--- a/packages/slate/test/commands/at-current-range/remove-mark/whole-word.js
+++ b/packages/slate/test/commands/at-current-range/remove-mark/whole-word.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeMark('bold')
+export default function(editor) {
+  editor.removeMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/remove-mark/with-mark-object.js b/packages/slate/test/commands/at-current-range/remove-mark/with-mark-object.js
index a7ac946ab..21112acaa 100644
--- a/packages/slate/test/commands/at-current-range/remove-mark/with-mark-object.js
+++ b/packages/slate/test/commands/at-current-range/remove-mark/with-mark-object.js
@@ -3,8 +3,8 @@
 import h from '../../../helpers/h'
 import { Mark } from 'slate'
 
-export default function(change) {
-  change.removeMark(
+export default function(editor) {
+  editor.removeMark(
     Mark.create({
       type: 'bold',
       data: { thing: 'value' },
diff --git a/packages/slate/test/commands/at-current-range/remove-mark/with-plain-object.js b/packages/slate/test/commands/at-current-range/remove-mark/with-plain-object.js
index 29e501305..8889a75bf 100644
--- a/packages/slate/test/commands/at-current-range/remove-mark/with-plain-object.js
+++ b/packages/slate/test/commands/at-current-range/remove-mark/with-plain-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeMark({
+export default function(editor) {
+  editor.removeMark({
     type: 'bold',
     data: { thing: 'value' },
   })
diff --git a/packages/slate/test/commands/at-current-range/replace-mark/across-blocks.js b/packages/slate/test/commands/at-current-range/replace-mark/across-blocks.js
index 3252075c4..c41b6aa25 100644
--- a/packages/slate/test/commands/at-current-range/replace-mark/across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/replace-mark/across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceMark('italic', 'bold')
+export default function(editor) {
+  editor.replaceMark('italic', 'bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/replace-mark/across-inlines.js b/packages/slate/test/commands/at-current-range/replace-mark/across-inlines.js
index 8ea3f0dd7..cad6123d9 100644
--- a/packages/slate/test/commands/at-current-range/replace-mark/across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/replace-mark/across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceMark('italic', 'bold')
+export default function(editor) {
+  editor.replaceMark('italic', 'bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/replace-mark/collapsed-selection.js b/packages/slate/test/commands/at-current-range/replace-mark/collapsed-selection.js
index e34a739aa..70a1d5994 100644
--- a/packages/slate/test/commands/at-current-range/replace-mark/collapsed-selection.js
+++ b/packages/slate/test/commands/at-current-range/replace-mark/collapsed-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceMark('italic', 'bold').insertText('a')
+export default function(editor) {
+  editor.replaceMark('italic', 'bold').insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/replace-mark/existing-marks.js b/packages/slate/test/commands/at-current-range/replace-mark/existing-marks.js
index 867641f3e..31be675fc 100644
--- a/packages/slate/test/commands/at-current-range/replace-mark/existing-marks.js
+++ b/packages/slate/test/commands/at-current-range/replace-mark/existing-marks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceMark('italic', 'bold')
+export default function(editor) {
+  editor.replaceMark('italic', 'bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/replace-mark/first-character.js b/packages/slate/test/commands/at-current-range/replace-mark/first-character.js
index c005a36fd..07ebac88f 100644
--- a/packages/slate/test/commands/at-current-range/replace-mark/first-character.js
+++ b/packages/slate/test/commands/at-current-range/replace-mark/first-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceMark('italic', 'bold')
+export default function(editor) {
+  editor.replaceMark('italic', 'bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/replace-mark/last-character.js b/packages/slate/test/commands/at-current-range/replace-mark/last-character.js
index 884f0f3bf..69fff7d3b 100644
--- a/packages/slate/test/commands/at-current-range/replace-mark/last-character.js
+++ b/packages/slate/test/commands/at-current-range/replace-mark/last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceMark('italic', 'bold')
+export default function(editor) {
+  editor.replaceMark('italic', 'bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/replace-mark/middle-character.js b/packages/slate/test/commands/at-current-range/replace-mark/middle-character.js
index eb191a9c4..b52ff4c60 100644
--- a/packages/slate/test/commands/at-current-range/replace-mark/middle-character.js
+++ b/packages/slate/test/commands/at-current-range/replace-mark/middle-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceMark('italic', 'bold')
+export default function(editor) {
+  editor.replaceMark('italic', 'bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/replace-mark/whole-word.js b/packages/slate/test/commands/at-current-range/replace-mark/whole-word.js
index 41bbda069..23f73ce23 100644
--- a/packages/slate/test/commands/at-current-range/replace-mark/whole-word.js
+++ b/packages/slate/test/commands/at-current-range/replace-mark/whole-word.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceMark('italic', 'bold')
+export default function(editor) {
+  editor.replaceMark('italic', 'bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/replace-mark/with-mark-object.js b/packages/slate/test/commands/at-current-range/replace-mark/with-mark-object.js
index 17fb2c16e..67abdd618 100644
--- a/packages/slate/test/commands/at-current-range/replace-mark/with-mark-object.js
+++ b/packages/slate/test/commands/at-current-range/replace-mark/with-mark-object.js
@@ -4,8 +4,8 @@ import h from '../../../helpers/h'
 
 import { Mark } from 'slate'
 
-export default function(change) {
-  change.replaceMark(
+export default function(editor) {
+  editor.replaceMark(
     'italic',
     Mark.create({
       type: 'bold',
diff --git a/packages/slate/test/commands/at-current-range/replace-mark/with-plain-object.js b/packages/slate/test/commands/at-current-range/replace-mark/with-plain-object.js
index 65d5d4910..b1fb752b6 100644
--- a/packages/slate/test/commands/at-current-range/replace-mark/with-plain-object.js
+++ b/packages/slate/test/commands/at-current-range/replace-mark/with-plain-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceMark('italic', {
+export default function(editor) {
+  editor.replaceMark('italic', {
     type: 'bold',
     data: { thing: 'value' },
   })
diff --git a/packages/slate/test/commands/at-current-range/set-block/across-blocks.js b/packages/slate/test/commands/at-current-range/set-block/across-blocks.js
index 2e1b9d3ab..2a9586302 100644
--- a/packages/slate/test/commands/at-current-range/set-block/across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/set-block/across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setBlocks({ type: 'code' })
+export default function(editor) {
+  editor.setBlocks({ type: 'code' })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-block/across-inlines.js b/packages/slate/test/commands/at-current-range/set-block/across-inlines.js
index dec1bd489..af3e3035c 100644
--- a/packages/slate/test/commands/at-current-range/set-block/across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/set-block/across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setBlocks({ type: 'code' })
+export default function(editor) {
+  editor.setBlocks({ type: 'code' })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-block/data-only.js b/packages/slate/test/commands/at-current-range/set-block/data-only.js
index 6e3f2a1ee..89fa4f6d8 100644
--- a/packages/slate/test/commands/at-current-range/set-block/data-only.js
+++ b/packages/slate/test/commands/at-current-range/set-block/data-only.js
@@ -4,8 +4,8 @@ import h from '../../../helpers/h'
 
 import { Data } from 'slate'
 
-export default function(change) {
-  change.setBlocks({ data: Data.create({ thing: 'value' }) })
+export default function(editor) {
+  editor.setBlocks({ data: Data.create({ thing: 'value' }) })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-block/hanging-selection.js b/packages/slate/test/commands/at-current-range/set-block/hanging-selection.js
index 148562871..35c96c497 100644
--- a/packages/slate/test/commands/at-current-range/set-block/hanging-selection.js
+++ b/packages/slate/test/commands/at-current-range/set-block/hanging-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setBlocks({ type: 'code' })
+export default function(editor) {
+  editor.setBlocks({ type: 'code' })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-block/nested-block.js b/packages/slate/test/commands/at-current-range/set-block/nested-block.js
index cb1849f13..c5f499c14 100644
--- a/packages/slate/test/commands/at-current-range/set-block/nested-block.js
+++ b/packages/slate/test/commands/at-current-range/set-block/nested-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setBlocks({ type: 'code' })
+export default function(editor) {
+  editor.setBlocks({ type: 'code' })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-block/single-block-string-shorthand.js b/packages/slate/test/commands/at-current-range/set-block/single-block-string-shorthand.js
index 279a5ee18..085fca84c 100644
--- a/packages/slate/test/commands/at-current-range/set-block/single-block-string-shorthand.js
+++ b/packages/slate/test/commands/at-current-range/set-block/single-block-string-shorthand.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setBlocks('code')
+export default function(editor) {
+  editor.setBlocks('code')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-block/single-block.js b/packages/slate/test/commands/at-current-range/set-block/single-block.js
index 9b1edebbb..44aac8167 100644
--- a/packages/slate/test/commands/at-current-range/set-block/single-block.js
+++ b/packages/slate/test/commands/at-current-range/set-block/single-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setBlocks({ type: 'code' })
+export default function(editor) {
+  editor.setBlocks({ type: 'code' })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-block/with-data-as-map.js b/packages/slate/test/commands/at-current-range/set-block/with-data-as-map.js
index a82ba77bb..414083d82 100644
--- a/packages/slate/test/commands/at-current-range/set-block/with-data-as-map.js
+++ b/packages/slate/test/commands/at-current-range/set-block/with-data-as-map.js
@@ -3,8 +3,8 @@
 import h from '../../../helpers/h'
 import { Data } from 'slate'
 
-export default function(change) {
-  change.setBlocks({
+export default function(editor) {
+  editor.setBlocks({
     type: 'code',
     data: Data.create({ thing: 'value' }),
   })
diff --git a/packages/slate/test/commands/at-current-range/set-block/with-data-as-object.js b/packages/slate/test/commands/at-current-range/set-block/with-data-as-object.js
index e191ae392..6366cf1e0 100644
--- a/packages/slate/test/commands/at-current-range/set-block/with-data-as-object.js
+++ b/packages/slate/test/commands/at-current-range/set-block/with-data-as-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setBlocks({
+export default function(editor) {
+  editor.setBlocks({
     type: 'code',
     data: { thing: 'value' },
   })
diff --git a/packages/slate/test/commands/at-current-range/set-block/with-is-void.js b/packages/slate/test/commands/at-current-range/set-block/with-is-void.js
index 8849f604f..7a6c73b82 100644
--- a/packages/slate/test/commands/at-current-range/set-block/with-is-void.js
+++ b/packages/slate/test/commands/at-current-range/set-block/with-is-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setBlocks('image')
+export default function(editor) {
+  editor.setBlocks('image')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-inline/across-inlines.js b/packages/slate/test/commands/at-current-range/set-inline/across-inlines.js
index fd23cf450..d287269a9 100644
--- a/packages/slate/test/commands/at-current-range/set-inline/across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/set-inline/across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setInlines({ type: 'hashtag' })
+export default function(editor) {
+  editor.setInlines({ type: 'hashtag' })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-inline/data-only.js b/packages/slate/test/commands/at-current-range/set-inline/data-only.js
index 6b223997c..77048e014 100644
--- a/packages/slate/test/commands/at-current-range/set-inline/data-only.js
+++ b/packages/slate/test/commands/at-current-range/set-inline/data-only.js
@@ -3,8 +3,8 @@
 import h from '../../../helpers/h'
 import { Data } from 'slate'
 
-export default function(change) {
-  change.setInlines({ data: Data.create({ thing: 'value' }) })
+export default function(editor) {
+  editor.setInlines({ data: Data.create({ thing: 'value' }) })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-inline/nested-inline.js b/packages/slate/test/commands/at-current-range/set-inline/nested-inline.js
index fa753b21c..9b968f579 100644
--- a/packages/slate/test/commands/at-current-range/set-inline/nested-inline.js
+++ b/packages/slate/test/commands/at-current-range/set-inline/nested-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setInlines({ type: 'comment' })
+export default function(editor) {
+  editor.setInlines({ type: 'comment' })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-inline/single-inline-string-shorthand.js b/packages/slate/test/commands/at-current-range/set-inline/single-inline-string-shorthand.js
index 971014d29..5d681b0c0 100644
--- a/packages/slate/test/commands/at-current-range/set-inline/single-inline-string-shorthand.js
+++ b/packages/slate/test/commands/at-current-range/set-inline/single-inline-string-shorthand.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setInlines('hashtag')
+export default function(editor) {
+  editor.setInlines('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-inline/single-inline.js b/packages/slate/test/commands/at-current-range/set-inline/single-inline.js
index f24f1e226..576cb4085 100644
--- a/packages/slate/test/commands/at-current-range/set-inline/single-inline.js
+++ b/packages/slate/test/commands/at-current-range/set-inline/single-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setInlines({ type: 'hashtag' })
+export default function(editor) {
+  editor.setInlines({ type: 'hashtag' })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/set-inline/with-data-object.js b/packages/slate/test/commands/at-current-range/set-inline/with-data-object.js
index 8bd2dc920..3f2c9b7c0 100644
--- a/packages/slate/test/commands/at-current-range/set-inline/with-data-object.js
+++ b/packages/slate/test/commands/at-current-range/set-inline/with-data-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setInlines({
+export default function(editor) {
+  editor.setInlines({
     type: 'hashtag',
     data: { thing: 'value' },
   })
diff --git a/packages/slate/test/commands/at-current-range/set-inline/with-data.js b/packages/slate/test/commands/at-current-range/set-inline/with-data.js
index 616ab8ae6..bae0b4812 100644
--- a/packages/slate/test/commands/at-current-range/set-inline/with-data.js
+++ b/packages/slate/test/commands/at-current-range/set-inline/with-data.js
@@ -3,8 +3,8 @@
 import h from '../../../helpers/h'
 import { Data } from 'slate'
 
-export default function(change) {
-  change.setInlines({
+export default function(editor) {
+  editor.setInlines({
     type: 'hashtag',
     data: Data.create({ thing: 'value' }),
   })
diff --git a/packages/slate/test/commands/at-current-range/set-inline/with-is-void.js b/packages/slate/test/commands/at-current-range/set-inline/with-is-void.js
index e96029e7b..94de528c5 100644
--- a/packages/slate/test/commands/at-current-range/set-inline/with-is-void.js
+++ b/packages/slate/test/commands/at-current-range/set-inline/with-is-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setInlines('emoji')
+export default function(editor) {
+  editor.setInlines('emoji')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/after-inline-void.js b/packages/slate/test/commands/at-current-range/split-block/after-inline-void.js
index b859f83f7..4c19a6b00 100644
--- a/packages/slate/test/commands/at-current-range/split-block/after-inline-void.js
+++ b/packages/slate/test/commands/at-current-range/split-block/after-inline-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock()
+export default function(editor) {
+  editor.splitBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/after-inline.js b/packages/slate/test/commands/at-current-range/split-block/after-inline.js
index 7c1d142e3..dcd9da6f3 100644
--- a/packages/slate/test/commands/at-current-range/split-block/after-inline.js
+++ b/packages/slate/test/commands/at-current-range/split-block/after-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock()
+export default function(editor) {
+  editor.splitBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/before-inline.js b/packages/slate/test/commands/at-current-range/split-block/before-inline.js
index ee71fe69d..a761ffa31 100644
--- a/packages/slate/test/commands/at-current-range/split-block/before-inline.js
+++ b/packages/slate/test/commands/at-current-range/split-block/before-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock()
+export default function(editor) {
+  editor.splitBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/block-end.js b/packages/slate/test/commands/at-current-range/split-block/block-end.js
index 655f721fe..d350bcc3b 100644
--- a/packages/slate/test/commands/at-current-range/split-block/block-end.js
+++ b/packages/slate/test/commands/at-current-range/split-block/block-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock()
+export default function(editor) {
+  editor.splitBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/block-middle.js b/packages/slate/test/commands/at-current-range/split-block/block-middle.js
index cc2f15d6f..639a81d3c 100644
--- a/packages/slate/test/commands/at-current-range/split-block/block-middle.js
+++ b/packages/slate/test/commands/at-current-range/split-block/block-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock()
+export default function(editor) {
+  editor.splitBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/block-start.js b/packages/slate/test/commands/at-current-range/split-block/block-start.js
index 5effb8315..c1da8e03e 100644
--- a/packages/slate/test/commands/at-current-range/split-block/block-start.js
+++ b/packages/slate/test/commands/at-current-range/split-block/block-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock()
+export default function(editor) {
+  editor.splitBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/depth.js b/packages/slate/test/commands/at-current-range/split-block/depth.js
index f32e09a8f..941aa623c 100644
--- a/packages/slate/test/commands/at-current-range/split-block/depth.js
+++ b/packages/slate/test/commands/at-current-range/split-block/depth.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock(Infinity)
+export default function(editor) {
+  editor.splitBlock(Infinity)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/with-delete-across-blocks-and-inlines.js b/packages/slate/test/commands/at-current-range/split-block/with-delete-across-blocks-and-inlines.js
index dd0c629b0..82b412814 100644
--- a/packages/slate/test/commands/at-current-range/split-block/with-delete-across-blocks-and-inlines.js
+++ b/packages/slate/test/commands/at-current-range/split-block/with-delete-across-blocks-and-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock()
+export default function(editor) {
+  editor.splitBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/with-delete-across-blocks.js b/packages/slate/test/commands/at-current-range/split-block/with-delete-across-blocks.js
index 432384140..3419c3007 100644
--- a/packages/slate/test/commands/at-current-range/split-block/with-delete-across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/split-block/with-delete-across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock()
+export default function(editor) {
+  editor.splitBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/with-delete-hanging-selection.js b/packages/slate/test/commands/at-current-range/split-block/with-delete-hanging-selection.js
index 96f269c1d..f969343c3 100644
--- a/packages/slate/test/commands/at-current-range/split-block/with-delete-hanging-selection.js
+++ b/packages/slate/test/commands/at-current-range/split-block/with-delete-hanging-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock()
+export default function(editor) {
+  editor.splitBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/with-delete.js b/packages/slate/test/commands/at-current-range/split-block/with-delete.js
index b1ad8aa29..fababb74f 100644
--- a/packages/slate/test/commands/at-current-range/split-block/with-delete.js
+++ b/packages/slate/test/commands/at-current-range/split-block/with-delete.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock()
+export default function(editor) {
+  editor.splitBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/with-inline.js b/packages/slate/test/commands/at-current-range/split-block/with-inline.js
index 07aa141ea..d838c30b6 100644
--- a/packages/slate/test/commands/at-current-range/split-block/with-inline.js
+++ b/packages/slate/test/commands/at-current-range/split-block/with-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitBlock()
+export default function(editor) {
+  editor.splitBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-block/with-marks.js b/packages/slate/test/commands/at-current-range/split-block/with-marks.js
index e9f808591..808e5d053 100644
--- a/packages/slate/test/commands/at-current-range/split-block/with-marks.js
+++ b/packages/slate/test/commands/at-current-range/split-block/with-marks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change
+export default function(editor) {
+  editor
     .addMark('italic')
     .splitBlock()
     .insertText('cat is cute')
diff --git a/packages/slate/test/commands/at-current-range/split-inline/block-end.js b/packages/slate/test/commands/at-current-range/split-inline/block-end.js
index dd4a70c41..47b4768da 100644
--- a/packages/slate/test/commands/at-current-range/split-inline/block-end.js
+++ b/packages/slate/test/commands/at-current-range/split-inline/block-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitInline()
+export default function(editor) {
+  editor.splitInline()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-inline/block-middle.js b/packages/slate/test/commands/at-current-range/split-inline/block-middle.js
index 9d39f69b4..42b0b048b 100644
--- a/packages/slate/test/commands/at-current-range/split-inline/block-middle.js
+++ b/packages/slate/test/commands/at-current-range/split-inline/block-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitInline()
+export default function(editor) {
+  editor.splitInline()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-inline/block-start.js b/packages/slate/test/commands/at-current-range/split-inline/block-start.js
index a9331565d..2ba9c0aac 100644
--- a/packages/slate/test/commands/at-current-range/split-inline/block-start.js
+++ b/packages/slate/test/commands/at-current-range/split-inline/block-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitInline()
+export default function(editor) {
+  editor.splitInline()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-inline/depth.js b/packages/slate/test/commands/at-current-range/split-inline/depth.js
index b3371c3b4..cc683c532 100644
--- a/packages/slate/test/commands/at-current-range/split-inline/depth.js
+++ b/packages/slate/test/commands/at-current-range/split-inline/depth.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitInline(1)
+export default function(editor) {
+  editor.splitInline(1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-inline/with-delete.js b/packages/slate/test/commands/at-current-range/split-inline/with-delete.js
index ef129c711..bead5d226 100644
--- a/packages/slate/test/commands/at-current-range/split-inline/with-delete.js
+++ b/packages/slate/test/commands/at-current-range/split-inline/with-delete.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitInline()
+export default function(editor) {
+  editor.splitInline()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/split-inline/with-marks.js b/packages/slate/test/commands/at-current-range/split-inline/with-marks.js
index 95cbaf94a..f4cc1891a 100644
--- a/packages/slate/test/commands/at-current-range/split-inline/with-marks.js
+++ b/packages/slate/test/commands/at-current-range/split-inline/with-marks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitInline()
+export default function(editor) {
+  editor.splitInline()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-across-blocks.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-across-blocks.js
index 47f0a8b69..842c745db 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-across-inlines.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-across-inlines.js
index e59b0b3a6..581aa66c5 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-collapsed-selection-beginning.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-collapsed-selection-beginning.js
index 7d3973076..e5ce25434 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-collapsed-selection-beginning.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-collapsed-selection-beginning.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold').insertText('a')
+export default function(editor) {
+  editor.toggleMark('bold').insertText('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-collapsed-selection.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-collapsed-selection.js
index 47b3e0071..09941779f 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-collapsed-selection.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-collapsed-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold').insertText('s')
+export default function(editor) {
+  editor.toggleMark('bold').insertText('s')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-existing-marks-partially-marked.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-existing-marks-partially-marked.js
index e95459321..f787a0390 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-existing-marks-partially-marked.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-existing-marks-partially-marked.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-existing-marks.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-existing-marks.js
index 583f69d8d..f994c10bc 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-existing-marks.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-existing-marks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-first-character.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-first-character.js
index 343e309db..7d646fa2f 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-first-character.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-first-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-last-character.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-last-character.js
index 9e9617e8e..bec3395d4 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-last-character.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-middle-character.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-middle-character.js
index a26ff9b98..8badf33a6 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-middle-character.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-middle-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-partially-marked.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-partially-marked.js
index 176d62cbb..5851b3cb4 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-partially-marked.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-partially-marked.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-whole-word.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-whole-word.js
index 733e751c3..973a94263 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-whole-word.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-whole-word.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-with-mark-object.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-with-mark-object.js
index 0a3d3aa3d..2ba4bcc8b 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-with-mark-object.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-with-mark-object.js
@@ -3,8 +3,8 @@
 import h from '../../../helpers/h'
 import { Mark } from 'slate'
 
-export default function(change) {
-  change.toggleMark(
+export default function(editor) {
+  editor.toggleMark(
     Mark.create({
       type: 'bold',
       data: { thing: 'value' },
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/add-with-plain-object.js b/packages/slate/test/commands/at-current-range/toggle-mark/add-with-plain-object.js
index a172d8138..e4549dfa9 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/add-with-plain-object.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/add-with-plain-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark({
+export default function(editor) {
+  editor.toggleMark({
     type: 'bold',
     data: { thing: 'value' },
   })
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/remove-across-blocks.js b/packages/slate/test/commands/at-current-range/toggle-mark/remove-across-blocks.js
index 5405a205f..61c2be543 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/remove-across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/remove-across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/remove-across-inlines.js b/packages/slate/test/commands/at-current-range/toggle-mark/remove-across-inlines.js
index f40bf80bb..1e702b01f 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/remove-across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/remove-across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/remove-collapsed-selection-beginning.js b/packages/slate/test/commands/at-current-range/toggle-mark/remove-collapsed-selection-beginning.js
index 73d9d91f4..52f1716f7 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/remove-collapsed-selection-beginning.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/remove-collapsed-selection-beginning.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change
+export default function(editor) {
+  editor
     .toggleMark('bold')
     .toggleMark('bold')
     .insertText('a')
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/remove-collapsed-selection.js b/packages/slate/test/commands/at-current-range/toggle-mark/remove-collapsed-selection.js
index a9c6bf8f3..2711ff73b 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/remove-collapsed-selection.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/remove-collapsed-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change
+export default function(editor) {
+  editor
     .toggleMark('bold')
     .toggleMark('bold')
     .insertText('s')
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/remove-existing-marks.js b/packages/slate/test/commands/at-current-range/toggle-mark/remove-existing-marks.js
index 4db3ace9e..68c2cdcb9 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/remove-existing-marks.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/remove-existing-marks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/remove-first-character.js b/packages/slate/test/commands/at-current-range/toggle-mark/remove-first-character.js
index 09d28d045..acc77aa16 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/remove-first-character.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/remove-first-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/remove-last-character.js b/packages/slate/test/commands/at-current-range/toggle-mark/remove-last-character.js
index 7d858e7ee..602c38c30 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/remove-last-character.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/remove-last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/remove-middle-character.js b/packages/slate/test/commands/at-current-range/toggle-mark/remove-middle-character.js
index 73359b548..4d744eaab 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/remove-middle-character.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/remove-middle-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/remove-whole-word.js b/packages/slate/test/commands/at-current-range/toggle-mark/remove-whole-word.js
index ad3a01073..68e37a2bc 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/remove-whole-word.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/remove-whole-word.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark('bold')
+export default function(editor) {
+  editor.toggleMark('bold')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/remove-with-mark-object.js b/packages/slate/test/commands/at-current-range/toggle-mark/remove-with-mark-object.js
index 5cb1274ec..c847401f3 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/remove-with-mark-object.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/remove-with-mark-object.js
@@ -3,8 +3,8 @@
 import h from '../../../helpers/h'
 import { Mark } from 'slate'
 
-export default function(change) {
-  change.toggleMark(
+export default function(editor) {
+  editor.toggleMark(
     Mark.create({
       type: 'bold',
       data: { thing: 'value' },
diff --git a/packages/slate/test/commands/at-current-range/toggle-mark/remove-with-plain-object.js b/packages/slate/test/commands/at-current-range/toggle-mark/remove-with-plain-object.js
index edc7b37dc..f3c1e9965 100644
--- a/packages/slate/test/commands/at-current-range/toggle-mark/remove-with-plain-object.js
+++ b/packages/slate/test/commands/at-current-range/toggle-mark/remove-with-plain-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.toggleMark({
+export default function(editor) {
+  editor.toggleMark({
     type: 'bold',
     data: { thing: 'value' },
   })
diff --git a/packages/slate/test/commands/at-current-range/unwrap-block/across-blocks.js b/packages/slate/test/commands/at-current-range/unwrap-block/across-blocks.js
index 939f66d0c..08d4e19b0 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-block/across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-block/across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapBlock('quote')
+export default function(editor) {
+  editor.unwrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-block/across-inlines.js b/packages/slate/test/commands/at-current-range/unwrap-block/across-inlines.js
index 2abe0fc0e..5f93b1333 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-block/across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-block/across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapBlock('quote')
+export default function(editor) {
+  editor.unwrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-block/ending-child-blocks.js b/packages/slate/test/commands/at-current-range/unwrap-block/ending-child-blocks.js
index c72d2d403..67fbe782b 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-block/ending-child-blocks.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-block/ending-child-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapBlock('quote')
+export default function(editor) {
+  editor.unwrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-block/middle-child-blocks-with-backward-selection.js b/packages/slate/test/commands/at-current-range/unwrap-block/middle-child-blocks-with-backward-selection.js
index 89ebd89eb..f2e39d3b2 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-block/middle-child-blocks-with-backward-selection.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-block/middle-child-blocks-with-backward-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapBlock('quote')
+export default function(editor) {
+  editor.unwrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-block/middle-child-blocks.js b/packages/slate/test/commands/at-current-range/unwrap-block/middle-child-blocks.js
index 329851a8f..bd6ea1765 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-block/middle-child-blocks.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-block/middle-child-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapBlock('quote')
+export default function(editor) {
+  editor.unwrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-block/nested-block.js b/packages/slate/test/commands/at-current-range/unwrap-block/nested-block.js
index 71ac9e33e..d73bb1845 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-block/nested-block.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-block/nested-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapBlock('quote')
+export default function(editor) {
+  editor.unwrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-block/single-block.js b/packages/slate/test/commands/at-current-range/unwrap-block/single-block.js
index 76d337c69..98a53e04e 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-block/single-block.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-block/single-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapBlock('quote')
+export default function(editor) {
+  editor.unwrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-block/starting-child-blocks.js b/packages/slate/test/commands/at-current-range/unwrap-block/starting-child-blocks.js
index 952fc027d..03a9bb642 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-block/starting-child-blocks.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-block/starting-child-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapBlock('quote')
+export default function(editor) {
+  editor.unwrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-block/with-object.js b/packages/slate/test/commands/at-current-range/unwrap-block/with-object.js
index 20a75f4a8..c800d2b78 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-block/with-object.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-block/with-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapBlock({
+export default function(editor) {
+  editor.unwrapBlock({
     type: 'quote',
     data: { thing: 'value' },
   })
diff --git a/packages/slate/test/commands/at-current-range/unwrap-inline/across-blocks.js b/packages/slate/test/commands/at-current-range/unwrap-inline/across-blocks.js
index c84ce8bd4..d0d989dc0 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-inline/across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-inline/across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapInline('hashtag')
+export default function(editor) {
+  editor.unwrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-inline/across-inlines-and-text.js b/packages/slate/test/commands/at-current-range/unwrap-inline/across-inlines-and-text.js
index 62eae7967..3f7893357 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-inline/across-inlines-and-text.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-inline/across-inlines-and-text.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapInline('link')
+export default function(editor) {
+  editor.unwrapInline('link')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-inline/across-inlines.js b/packages/slate/test/commands/at-current-range/unwrap-inline/across-inlines.js
index 26d5539c6..5c5c1befd 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-inline/across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-inline/across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapInline('hashtag')
+export default function(editor) {
+  editor.unwrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-inline/nested-block.js b/packages/slate/test/commands/at-current-range/unwrap-inline/nested-block.js
index e079059bf..30c8131a5 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-inline/nested-block.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-inline/nested-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapInline('hashtag')
+export default function(editor) {
+  editor.unwrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-inline/only-one.js b/packages/slate/test/commands/at-current-range/unwrap-inline/only-one.js
index c00aea811..888179bbb 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-inline/only-one.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-inline/only-one.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapInline('hashtag')
+export default function(editor) {
+  editor.unwrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-inline/single-block.js b/packages/slate/test/commands/at-current-range/unwrap-inline/single-block.js
index 2cde7ee57..1ae187648 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-inline/single-block.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-inline/single-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapInline('hashtag')
+export default function(editor) {
+  editor.unwrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/unwrap-inline/with-object.js b/packages/slate/test/commands/at-current-range/unwrap-inline/with-object.js
index d73cd71b0..f376598ac 100644
--- a/packages/slate/test/commands/at-current-range/unwrap-inline/with-object.js
+++ b/packages/slate/test/commands/at-current-range/unwrap-inline/with-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapInline({
+export default function(editor) {
+  editor.unwrapInline({
     type: 'hashtag',
     data: { thing: 'value' },
   })
diff --git a/packages/slate/test/commands/at-current-range/wrap-block/across-blocks.js b/packages/slate/test/commands/at-current-range/wrap-block/across-blocks.js
index 5f4b03835..785981fb8 100644
--- a/packages/slate/test/commands/at-current-range/wrap-block/across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/wrap-block/across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapBlock('quote')
+export default function(editor) {
+  editor.wrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-block/across-inlines.js b/packages/slate/test/commands/at-current-range/wrap-block/across-inlines.js
index e841260b7..36de8165c 100644
--- a/packages/slate/test/commands/at-current-range/wrap-block/across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/wrap-block/across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapBlock('quote')
+export default function(editor) {
+  editor.wrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-block/nested-block.js b/packages/slate/test/commands/at-current-range/wrap-block/nested-block.js
index 215789d0c..17e0cfa56 100644
--- a/packages/slate/test/commands/at-current-range/wrap-block/nested-block.js
+++ b/packages/slate/test/commands/at-current-range/wrap-block/nested-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapBlock('quote')
+export default function(editor) {
+  editor.wrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-block/single-block.js b/packages/slate/test/commands/at-current-range/wrap-block/single-block.js
index 60bcc250a..2bef52d06 100644
--- a/packages/slate/test/commands/at-current-range/wrap-block/single-block.js
+++ b/packages/slate/test/commands/at-current-range/wrap-block/single-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapBlock('quote')
+export default function(editor) {
+  editor.wrapBlock('quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-block/with-object.js b/packages/slate/test/commands/at-current-range/wrap-block/with-object.js
index 30d14dd4e..34b300cab 100644
--- a/packages/slate/test/commands/at-current-range/wrap-block/with-object.js
+++ b/packages/slate/test/commands/at-current-range/wrap-block/with-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapBlock({
+export default function(editor) {
+  editor.wrapBlock({
     type: 'quote',
     data: { thing: 'value' },
   })
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/across-blocks.js b/packages/slate/test/commands/at-current-range/wrap-inline/across-blocks.js
index 43cb2fdbf..8942c1074 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline('hashtag')
+export default function(editor) {
+  editor.wrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/across-inlines.js b/packages/slate/test/commands/at-current-range/wrap-inline/across-inlines.js
index a897590d0..f3afbd1f9 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline('hashtag')
+export default function(editor) {
+  editor.wrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/inline-void.js b/packages/slate/test/commands/at-current-range/wrap-inline/inline-void.js
index c9ba3be84..1414ed677 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/inline-void.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/inline-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline({
+export default function(editor) {
+  editor.wrapInline({
     type: 'link',
   })
 }
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-begining.js b/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-begining.js
index 62a56a788..b1815c3c6 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-begining.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-begining.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline('hashtag')
+export default function(editor) {
+  editor.wrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-end.js b/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-end.js
index f314bac3a..6ebaf14b0 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-end.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline('hashtag')
+export default function(editor) {
+  editor.wrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-with-marks.js b/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-with-marks.js
index a38663e38..f9784adf0 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-with-marks.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines-with-marks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline('hashtag')
+export default function(editor) {
+  editor.wrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines.js b/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines.js
index 2cdccecdb..28ceca42f 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/inside-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline('hashtag')
+export default function(editor) {
+  editor.wrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/nested-block.js b/packages/slate/test/commands/at-current-range/wrap-inline/nested-block.js
index d7a0d1cc7..98feb35b3 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/nested-block.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/nested-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline('hashtag')
+export default function(editor) {
+  editor.wrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/single-block.js b/packages/slate/test/commands/at-current-range/wrap-inline/single-block.js
index 771687e7f..4023946ba 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/single-block.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/single-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline('hashtag')
+export default function(editor) {
+  editor.wrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/twice.js b/packages/slate/test/commands/at-current-range/wrap-inline/twice.js
index b031b6200..7beabbca7 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/twice.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/twice.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline('link').wrapInline('hashtag')
+export default function(editor) {
+  editor.wrapInline('link').wrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/whole-block.js b/packages/slate/test/commands/at-current-range/wrap-inline/whole-block.js
index 5843ad9fd..c1c4f2a81 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/whole-block.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/whole-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline('hashtag')
+export default function(editor) {
+  editor.wrapInline('hashtag')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-inline/with-object.js b/packages/slate/test/commands/at-current-range/wrap-inline/with-object.js
index c851b4225..a6e4bf030 100644
--- a/packages/slate/test/commands/at-current-range/wrap-inline/with-object.js
+++ b/packages/slate/test/commands/at-current-range/wrap-inline/with-object.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapInline({
+export default function(editor) {
+  editor.wrapInline({
     type: 'hashtag',
     data: { thing: 'value' },
   })
diff --git a/packages/slate/test/commands/at-current-range/wrap-text/across-blocks.js b/packages/slate/test/commands/at-current-range/wrap-text/across-blocks.js
index 254b6e047..4d1039652 100644
--- a/packages/slate/test/commands/at-current-range/wrap-text/across-blocks.js
+++ b/packages/slate/test/commands/at-current-range/wrap-text/across-blocks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapText('[[', ']]')
+export default function(editor) {
+  editor.wrapText('[[', ']]')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-text/across-inlines.js b/packages/slate/test/commands/at-current-range/wrap-text/across-inlines.js
index fd62cf5c3..8a12a34f5 100644
--- a/packages/slate/test/commands/at-current-range/wrap-text/across-inlines.js
+++ b/packages/slate/test/commands/at-current-range/wrap-text/across-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapText('[[', ']]')
+export default function(editor) {
+  editor.wrapText('[[', ']]')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-text/backwards-selection.js b/packages/slate/test/commands/at-current-range/wrap-text/backwards-selection.js
index 67fb004d8..ca249e8e5 100644
--- a/packages/slate/test/commands/at-current-range/wrap-text/backwards-selection.js
+++ b/packages/slate/test/commands/at-current-range/wrap-text/backwards-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapText('[[', ']]')
+export default function(editor) {
+  editor.wrapText('[[', ']]')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-text/empty-block.js b/packages/slate/test/commands/at-current-range/wrap-text/empty-block.js
index 038b6c83e..64dc0b98e 100644
--- a/packages/slate/test/commands/at-current-range/wrap-text/empty-block.js
+++ b/packages/slate/test/commands/at-current-range/wrap-text/empty-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapText('[[', ']]')
+export default function(editor) {
+  editor.wrapText('[[', ']]')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-text/end-of-block.js b/packages/slate/test/commands/at-current-range/wrap-text/end-of-block.js
index a90cd9226..24517cd3f 100644
--- a/packages/slate/test/commands/at-current-range/wrap-text/end-of-block.js
+++ b/packages/slate/test/commands/at-current-range/wrap-text/end-of-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapText('[[', ']]')
+export default function(editor) {
+  editor.wrapText('[[', ']]')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-text/middle-of-block.js b/packages/slate/test/commands/at-current-range/wrap-text/middle-of-block.js
index f9f681d62..dc8dc31b0 100644
--- a/packages/slate/test/commands/at-current-range/wrap-text/middle-of-block.js
+++ b/packages/slate/test/commands/at-current-range/wrap-text/middle-of-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapText('[[', ']]')
+export default function(editor) {
+  editor.wrapText('[[', ']]')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-text/start-of-block.js b/packages/slate/test/commands/at-current-range/wrap-text/start-of-block.js
index 7b63bcde1..779b91a15 100644
--- a/packages/slate/test/commands/at-current-range/wrap-text/start-of-block.js
+++ b/packages/slate/test/commands/at-current-range/wrap-text/start-of-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapText('[[', ']]')
+export default function(editor) {
+  editor.wrapText('[[', ']]')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-text/whole-block.js b/packages/slate/test/commands/at-current-range/wrap-text/whole-block.js
index d47a1cb24..72746f4a0 100644
--- a/packages/slate/test/commands/at-current-range/wrap-text/whole-block.js
+++ b/packages/slate/test/commands/at-current-range/wrap-text/whole-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapText('[[', ']]')
+export default function(editor) {
+  editor.wrapText('[[', ']]')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/at-current-range/wrap-text/without-suffix.js b/packages/slate/test/commands/at-current-range/wrap-text/without-suffix.js
index c76e99143..1849b07fc 100644
--- a/packages/slate/test/commands/at-current-range/wrap-text/without-suffix.js
+++ b/packages/slate/test/commands/at-current-range/wrap-text/without-suffix.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapText('**')
+export default function(editor) {
+  editor.wrapText('**')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-fragment-by-key/end-of-target.js b/packages/slate/test/commands/by-key/insert-fragment-by-key/end-of-target.js
index 64911e972..ee7cda6bb 100644
--- a/packages/slate/test/commands/by-key/insert-fragment-by-key/end-of-target.js
+++ b/packages/slate/test/commands/by-key/insert-fragment-by-key/end-of-target.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragmentByKey(
+export default function(editor) {
+  editor.insertFragmentByKey(
     'a',
     1,
     <document>
diff --git a/packages/slate/test/commands/by-key/insert-fragment-by-key/middle-of-target.js b/packages/slate/test/commands/by-key/insert-fragment-by-key/middle-of-target.js
index abdb43c4d..b786649ff 100644
--- a/packages/slate/test/commands/by-key/insert-fragment-by-key/middle-of-target.js
+++ b/packages/slate/test/commands/by-key/insert-fragment-by-key/middle-of-target.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragmentByKey(
+export default function(editor) {
+  editor.insertFragmentByKey(
     'a',
     1,
     <document>
diff --git a/packages/slate/test/commands/by-key/insert-fragment-by-key/start-of-target.js b/packages/slate/test/commands/by-key/insert-fragment-by-key/start-of-target.js
index d3185732b..f00014582 100644
--- a/packages/slate/test/commands/by-key/insert-fragment-by-key/start-of-target.js
+++ b/packages/slate/test/commands/by-key/insert-fragment-by-key/start-of-target.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertFragmentByKey(
+export default function(editor) {
+  editor.insertFragmentByKey(
     'a',
     0,
     <document>
diff --git a/packages/slate/test/commands/by-key/insert-node-by-key/block.js b/packages/slate/test/commands/by-key/insert-node-by-key/block.js
index 4cc7b911e..44af310c3 100644
--- a/packages/slate/test/commands/by-key/insert-node-by-key/block.js
+++ b/packages/slate/test/commands/by-key/insert-node-by-key/block.js
@@ -3,8 +3,8 @@
 import h from '../../../helpers/h'
 import { Block } from 'slate'
 
-export default function(change) {
-  change.insertNodeByKey('a', 0, Block.create('paragraph'))
+export default function(editor) {
+  editor.insertNodeByKey('a', 0, Block.create('paragraph'))
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-node-by-key/duplicate.js b/packages/slate/test/commands/by-key/insert-node-by-key/duplicate.js
index 72dfecb97..8374a5b69 100644
--- a/packages/slate/test/commands/by-key/insert-node-by-key/duplicate.js
+++ b/packages/slate/test/commands/by-key/insert-node-by-key/duplicate.js
@@ -2,9 +2,9 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  const node = change.value.document.getBlocks().first()
-  change.insertNodeByKey('a', 0, node)
+export default function(editor) {
+  const node = editor.value.document.getBlocks().first()
+  editor.insertNodeByKey('a', 0, node)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-node-by-key/inline.js b/packages/slate/test/commands/by-key/insert-node-by-key/inline.js
index f7d3096c8..9e4c64034 100644
--- a/packages/slate/test/commands/by-key/insert-node-by-key/inline.js
+++ b/packages/slate/test/commands/by-key/insert-node-by-key/inline.js
@@ -3,8 +3,8 @@
 import h from '../../../helpers/h'
 import { Inline } from 'slate'
 
-export default function(change) {
-  change.insertNodeByKey('a', 0, Inline.create('emoji'))
+export default function(editor) {
+  editor.insertNodeByKey('a', 0, Inline.create('emoji'))
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/decoration-after-atomic.js b/packages/slate/test/commands/by-key/insert-text-by-key/decoration-after-atomic.js
index 3c51a7e75..3d4b1ff11 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/decoration-after-atomic.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/decoration-after-atomic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 4, 'x')
+export default function(editor) {
+  editor.insertTextByKey('a', 4, 'x')
 }
 
 export const options = {
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/decoration-before-atomic.js b/packages/slate/test/commands/by-key/insert-text-by-key/decoration-before-atomic.js
index 5532a1e75..be17eee6b 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/decoration-before-atomic.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/decoration-before-atomic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 1, 'x')
+export default function(editor) {
+  editor.insertTextByKey('a', 1, 'x')
 }
 
 export const options = {
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/decoration-middle-atomic.js b/packages/slate/test/commands/by-key/insert-text-by-key/decoration-middle-atomic.js
index e9bbc0ce5..fbaf854ee 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/decoration-middle-atomic.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/decoration-middle-atomic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 2, 'x')
+export default function(editor) {
+  editor.insertTextByKey('a', 2, 'x')
 }
 
 export const options = {
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/selection-after.js b/packages/slate/test/commands/by-key/insert-text-by-key/selection-after.js
index efb437180..9f44b51db 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/selection-after.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/selection-after.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 4, 'x')
+export default function(editor) {
+  editor.insertTextByKey('a', 4, 'x')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/selection-before.js b/packages/slate/test/commands/by-key/insert-text-by-key/selection-before.js
index 77ad74bc4..dcbdf6ffb 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/selection-before.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/selection-before.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 0, 'x')
+export default function(editor) {
+  editor.insertTextByKey('a', 0, 'x')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/selection-end.js b/packages/slate/test/commands/by-key/insert-text-by-key/selection-end.js
index 73f3f7254..f199d056d 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/selection-end.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/selection-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 3, 'x')
+export default function(editor) {
+  editor.insertTextByKey('a', 3, 'x')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/selection-middle.js b/packages/slate/test/commands/by-key/insert-text-by-key/selection-middle.js
index f72d3b44f..42f04c49c 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/selection-middle.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/selection-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 2, 'x')
+export default function(editor) {
+  editor.insertTextByKey('a', 2, 'x')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/selection-start.js b/packages/slate/test/commands/by-key/insert-text-by-key/selection-start.js
index 40d66fe48..8fc097c50 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/selection-start.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/selection-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 1, 'x')
+export default function(editor) {
+  editor.insertTextByKey('a', 1, 'x')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/start-text.js b/packages/slate/test/commands/by-key/insert-text-by-key/start-text.js
index 463083c12..bac3ecd80 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/start-text.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/start-text.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 0, 'a')
+export default function(editor) {
+  editor.insertTextByKey('a', 0, 'a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/text-end.js b/packages/slate/test/commands/by-key/insert-text-by-key/text-end.js
index 90611a173..c562a83b2 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/text-end.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/text-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 4, 'x')
+export default function(editor) {
+  editor.insertTextByKey('a', 4, 'x')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/text-middle-with-marks.js b/packages/slate/test/commands/by-key/insert-text-by-key/text-middle-with-marks.js
index eaaa50c95..3248450ff 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/text-middle-with-marks.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/text-middle-with-marks.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 2, 'x', [{ type: 'bold' }])
+export default function(editor) {
+  editor.insertTextByKey('a', 2, 'x', [{ type: 'bold' }])
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/insert-text-by-key/text-middle.js b/packages/slate/test/commands/by-key/insert-text-by-key/text-middle.js
index a8bbefd7e..aa29046c0 100644
--- a/packages/slate/test/commands/by-key/insert-text-by-key/text-middle.js
+++ b/packages/slate/test/commands/by-key/insert-text-by-key/text-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.insertTextByKey('a', 2, 'x')
+export default function(editor) {
+  editor.insertTextByKey('a', 2, 'x')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/merge-node-by-key/block.js b/packages/slate/test/commands/by-key/merge-node-by-key/block.js
index 17e385eb6..8ff3a64de 100644
--- a/packages/slate/test/commands/by-key/merge-node-by-key/block.js
+++ b/packages/slate/test/commands/by-key/merge-node-by-key/block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.mergeNodeByKey('a')
+export default function(editor) {
+  editor.mergeNodeByKey('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/move-node-by-key/block.js b/packages/slate/test/commands/by-key/move-node-by-key/block.js
index 56d574eee..8ace0a473 100644
--- a/packages/slate/test/commands/by-key/move-node-by-key/block.js
+++ b/packages/slate/test/commands/by-key/move-node-by-key/block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveNodeByKey('a', 'b', 1)
+export default function(editor) {
+  editor.moveNodeByKey('a', 'b', 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/move-node-by-key/inline.js b/packages/slate/test/commands/by-key/move-node-by-key/inline.js
index ecf556b22..bf661259e 100644
--- a/packages/slate/test/commands/by-key/move-node-by-key/inline.js
+++ b/packages/slate/test/commands/by-key/move-node-by-key/inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveNodeByKey('a', 'b', 3)
+export default function(editor) {
+  editor.moveNodeByKey('a', 'b', 3)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/move-node-by-key/text.js b/packages/slate/test/commands/by-key/move-node-by-key/text.js
index 7aab1c000..ec1cc4c92 100644
--- a/packages/slate/test/commands/by-key/move-node-by-key/text.js
+++ b/packages/slate/test/commands/by-key/move-node-by-key/text.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveNodeByKey('a', 'b', 1)
+export default function(editor) {
+  editor.moveNodeByKey('a', 'b', 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/move-node-by-key/to-sibling.js b/packages/slate/test/commands/by-key/move-node-by-key/to-sibling.js
index f9ede1fef..0af8b2761 100644
--- a/packages/slate/test/commands/by-key/move-node-by-key/to-sibling.js
+++ b/packages/slate/test/commands/by-key/move-node-by-key/to-sibling.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveNodeByKey('a', 'b', 1)
+export default function(editor) {
+  editor.moveNodeByKey('a', 'b', 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-node-by-key/block.js b/packages/slate/test/commands/by-key/remove-node-by-key/block.js
index 07373ad79..cd42f9a50 100644
--- a/packages/slate/test/commands/by-key/remove-node-by-key/block.js
+++ b/packages/slate/test/commands/by-key/remove-node-by-key/block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeNodeByKey('a')
+export default function(editor) {
+  editor.removeNodeByKey('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-node-by-key/inline.js b/packages/slate/test/commands/by-key/remove-node-by-key/inline.js
index 18a38770e..02773dbaa 100644
--- a/packages/slate/test/commands/by-key/remove-node-by-key/inline.js
+++ b/packages/slate/test/commands/by-key/remove-node-by-key/inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeNodeByKey('a')
+export default function(editor) {
+  editor.removeNodeByKey('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-node-by-key/selection-inside.js b/packages/slate/test/commands/by-key/remove-node-by-key/selection-inside.js
index de92168c5..b6f88b17c 100644
--- a/packages/slate/test/commands/by-key/remove-node-by-key/selection-inside.js
+++ b/packages/slate/test/commands/by-key/remove-node-by-key/selection-inside.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeNodeByKey('a')
+export default function(editor) {
+  editor.removeNodeByKey('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-node-by-key/text.js b/packages/slate/test/commands/by-key/remove-node-by-key/text.js
index 6446f4ecc..827f27bd3 100644
--- a/packages/slate/test/commands/by-key/remove-node-by-key/text.js
+++ b/packages/slate/test/commands/by-key/remove-node-by-key/text.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeNodeByKey('a')
+export default function(editor) {
+  editor.removeNodeByKey('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/adjacent-non-void-inlines.js b/packages/slate/test/commands/by-key/remove-text-by-key/adjacent-non-void-inlines.js
index 106f14188..a114e1343 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/adjacent-non-void-inlines.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/adjacent-non-void-inlines.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 0, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 0, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/decoration-after-atomic.js b/packages/slate/test/commands/by-key/remove-text-by-key/decoration-after-atomic.js
index bd4d22d7f..0067d3785 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/decoration-after-atomic.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/decoration-after-atomic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 3, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 3, 1)
 }
 
 export const options = {
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/decoration-before-atomic.js b/packages/slate/test/commands/by-key/remove-text-by-key/decoration-before-atomic.js
index ba7e3d864..c2c4388f3 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/decoration-before-atomic.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/decoration-before-atomic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 0, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 0, 1)
 }
 
 export const options = {
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/decoration-middle-atomic.js b/packages/slate/test/commands/by-key/remove-text-by-key/decoration-middle-atomic.js
index 52d05f3e9..e3b68c90e 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/decoration-middle-atomic.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/decoration-middle-atomic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 2, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 2, 1)
 }
 
 export const options = {
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/inline-last-character.js b/packages/slate/test/commands/by-key/remove-text-by-key/inline-last-character.js
index 8b7fa7bd5..5837b1cc2 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/inline-last-character.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/inline-last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 0, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 0, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/inline-nested-last-character.js b/packages/slate/test/commands/by-key/remove-text-by-key/inline-nested-last-character.js
index 78fc02667..129f2b399 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/inline-nested-last-character.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/inline-nested-last-character.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 0, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 0, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/inline-void.js b/packages/slate/test/commands/by-key/remove-text-by-key/inline-void.js
index dbaa9f680..f5f426b63 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/inline-void.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/inline-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 0, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 0, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/inline.js b/packages/slate/test/commands/by-key/remove-text-by-key/inline.js
index 2dc429e2a..248ba2052 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/inline.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 3, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 3, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/next-void-inline.js b/packages/slate/test/commands/by-key/remove-text-by-key/next-void-inline.js
index 4a88c9f6a..302957a9a 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/next-void-inline.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/next-void-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 0, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 0, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/previous-void-inline.js b/packages/slate/test/commands/by-key/remove-text-by-key/previous-void-inline.js
index ab8a92fa1..937f21c7c 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/previous-void-inline.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/previous-void-inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 0, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 0, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/selection-after.js b/packages/slate/test/commands/by-key/remove-text-by-key/selection-after.js
index ec3741498..a7ee4b967 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/selection-after.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/selection-after.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 3, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 3, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/selection-before.js b/packages/slate/test/commands/by-key/remove-text-by-key/selection-before.js
index 842a77cf0..071d5577b 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/selection-before.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/selection-before.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 0, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 0, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/selection-middle.js b/packages/slate/test/commands/by-key/remove-text-by-key/selection-middle.js
index f909d2450..bb6e4e778 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/selection-middle.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/selection-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 2, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 2, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/selection-start.js b/packages/slate/test/commands/by-key/remove-text-by-key/selection-start.js
index 75c2f2326..27b849419 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/selection-start.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/selection-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 2, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 2, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/remove-text-by-key/text.js b/packages/slate/test/commands/by-key/remove-text-by-key/text.js
index c38a3aa1f..cc4acc14f 100644
--- a/packages/slate/test/commands/by-key/remove-text-by-key/text.js
+++ b/packages/slate/test/commands/by-key/remove-text-by-key/text.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.removeTextByKey('a', 3, 1)
+export default function(editor) {
+  editor.removeTextByKey('a', 3, 1)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/replace-node-by-key/block.js b/packages/slate/test/commands/by-key/replace-node-by-key/block.js
index 3b4294986..5dcd16492 100644
--- a/packages/slate/test/commands/by-key/replace-node-by-key/block.js
+++ b/packages/slate/test/commands/by-key/replace-node-by-key/block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceNodeByKey('a', { object: 'block', type: 'quote' })
+export default function(editor) {
+  editor.replaceNodeByKey('a', { object: 'block', type: 'quote' })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/replace-node-by-key/inline.js b/packages/slate/test/commands/by-key/replace-node-by-key/inline.js
index 8f16ebc14..864ad926f 100644
--- a/packages/slate/test/commands/by-key/replace-node-by-key/inline.js
+++ b/packages/slate/test/commands/by-key/replace-node-by-key/inline.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceNodeByKey('a', {
+export default function(editor) {
+  editor.replaceNodeByKey('a', {
     object: 'inline',
     type: 'emoji',
   })
diff --git a/packages/slate/test/commands/by-key/replace-node-by-key/text.js b/packages/slate/test/commands/by-key/replace-node-by-key/text.js
index 11aafe268..f191093aa 100644
--- a/packages/slate/test/commands/by-key/replace-node-by-key/text.js
+++ b/packages/slate/test/commands/by-key/replace-node-by-key/text.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.replaceNodeByKey('a', { object: 'text', leaves: [{ text: 'three' }] })
+export default function(editor) {
+  editor.replaceNodeByKey('a', { object: 'text', leaves: [{ text: 'three' }] })
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-active-marks-with-data.js b/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-active-marks-with-data.js
index 9234de03f..d6316901f 100644
--- a/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-active-marks-with-data.js
+++ b/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-active-marks-with-data.js
@@ -2,10 +2,10 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  const { anchor } = change.value.selection
+export default function(editor) {
+  const { anchor } = editor.value.selection
 
-  change.replaceTextByKey(anchor.key, anchor.offset, 3, 'cat is cute', [
+  editor.replaceTextByKey(anchor.key, anchor.offset, 3, 'cat is cute', [
     { type: 'font-size', data: { size: 16 } },
   ])
 }
diff --git a/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-active-marks.js b/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-active-marks.js
index b7007322c..e04f282b1 100644
--- a/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-active-marks.js
+++ b/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-active-marks.js
@@ -2,9 +2,9 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  const { anchor } = change.value.selection
-  change.replaceTextByKey(anchor.key, anchor.offset, 3, 'cat is cute')
+export default function(editor) {
+  const { anchor } = editor.value.selection
+  editor.replaceTextByKey(anchor.key, anchor.offset, 3, 'cat is cute')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-mark-and-active-mark.js b/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-mark-and-active-mark.js
index 2159f4ea8..c88d7040f 100644
--- a/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-mark-and-active-mark.js
+++ b/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-mark-and-active-mark.js
@@ -2,10 +2,10 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  const { anchor } = change.value.selection
+export default function(editor) {
+  const { anchor } = editor.value.selection
 
-  change.replaceTextByKey(anchor.key, anchor.offset, 3, 'cat is cute', [
+  editor.replaceTextByKey(anchor.key, anchor.offset, 3, 'cat is cute', [
     { type: 'italic' },
   ])
 }
diff --git a/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-node-index-mark.js b/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-node-index-mark.js
index f12c80607..5cea7912f 100644
--- a/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-node-index-mark.js
+++ b/packages/slate/test/commands/by-key/replace-text-by-key/replace-with-node-index-mark.js
@@ -2,9 +2,9 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  const { anchor } = change.value.selection
-  change.replaceTextByKey(anchor.key, anchor.offset, 3, 'cat is cute')
+export default function(editor) {
+  const { anchor } = editor.value.selection
+  editor.replaceTextByKey(anchor.key, anchor.offset, 3, 'cat is cute')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/replace-text-by-key/replace-without-any-marks.js b/packages/slate/test/commands/by-key/replace-text-by-key/replace-without-any-marks.js
index a489ca787..f03bfc83a 100644
--- a/packages/slate/test/commands/by-key/replace-text-by-key/replace-without-any-marks.js
+++ b/packages/slate/test/commands/by-key/replace-text-by-key/replace-without-any-marks.js
@@ -2,9 +2,9 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  const { anchor } = change.value.selection
-  change.replaceTextByKey(anchor.key, anchor.offset, 3, 'cat is cute')
+export default function(editor) {
+  const { anchor } = editor.value.selection
+  editor.replaceTextByKey(anchor.key, anchor.offset, 3, 'cat is cute')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/set-mark-by-key/with-data.js b/packages/slate/test/commands/by-key/set-mark-by-key/with-data.js
index cbb57aef7..52a28708f 100644
--- a/packages/slate/test/commands/by-key/set-mark-by-key/with-data.js
+++ b/packages/slate/test/commands/by-key/set-mark-by-key/with-data.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setMarkByKey(
+export default function(editor) {
+  editor.setMarkByKey(
     'a',
     0,
     2,
diff --git a/packages/slate/test/commands/by-key/set-node-by-key/block.js b/packages/slate/test/commands/by-key/set-node-by-key/block.js
index b6d907342..3d3dfcc8b 100644
--- a/packages/slate/test/commands/by-key/set-node-by-key/block.js
+++ b/packages/slate/test/commands/by-key/set-node-by-key/block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setNodeByKey('a', {
+export default function(editor) {
+  editor.setNodeByKey('a', {
     type: 'quote',
     data: { thing: false },
   })
diff --git a/packages/slate/test/commands/by-key/set-node-by-key/inline-with-is-void.js b/packages/slate/test/commands/by-key/set-node-by-key/inline-with-is-void.js
index 07b690dc7..872fd2f12 100644
--- a/packages/slate/test/commands/by-key/set-node-by-key/inline-with-is-void.js
+++ b/packages/slate/test/commands/by-key/set-node-by-key/inline-with-is-void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setNodeByKey('a', 'emoji')
+export default function(editor) {
+  editor.setNodeByKey('a', 'emoji')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/set-node-by-key/string-shorthand.js b/packages/slate/test/commands/by-key/set-node-by-key/string-shorthand.js
index 755593220..7611833c3 100644
--- a/packages/slate/test/commands/by-key/set-node-by-key/string-shorthand.js
+++ b/packages/slate/test/commands/by-key/set-node-by-key/string-shorthand.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setNodeByKey('a', 'quote')
+export default function(editor) {
+  editor.setNodeByKey('a', 'quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/set-text-by-key/replace-with-string-and-mark.js b/packages/slate/test/commands/by-key/set-text-by-key/replace-with-string-and-mark.js
index ba9829154..60268f44a 100644
--- a/packages/slate/test/commands/by-key/set-text-by-key/replace-with-string-and-mark.js
+++ b/packages/slate/test/commands/by-key/set-text-by-key/replace-with-string-and-mark.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setTextByKey(change.value.selection.anchor.key, 'cat is cute', [
+export default function(editor) {
+  editor.setTextByKey(editor.value.selection.anchor.key, 'cat is cute', [
     { type: 'bold' },
     { type: 'italic' },
   ])
diff --git a/packages/slate/test/commands/by-key/set-text-by-key/replace-with-string.js b/packages/slate/test/commands/by-key/set-text-by-key/replace-with-string.js
index 7ecfd3ea4..1f0cb1029 100644
--- a/packages/slate/test/commands/by-key/set-text-by-key/replace-with-string.js
+++ b/packages/slate/test/commands/by-key/set-text-by-key/replace-with-string.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setTextByKey(change.value.selection.anchor.key, 'cat is cute')
+export default function(editor) {
+  editor.setTextByKey(editor.value.selection.anchor.key, 'cat is cute')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/split-descendants-by-key/block-with-selection.js b/packages/slate/test/commands/by-key/split-descendants-by-key/block-with-selection.js
index 5be2b996f..e27de4527 100644
--- a/packages/slate/test/commands/by-key/split-descendants-by-key/block-with-selection.js
+++ b/packages/slate/test/commands/by-key/split-descendants-by-key/block-with-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitDescendantsByKey('a', 'b', 2)
+export default function(editor) {
+  editor.splitDescendantsByKey('a', 'b', 2)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/split-descendants-by-key/block.js b/packages/slate/test/commands/by-key/split-descendants-by-key/block.js
index 630283af3..ffd42fd0f 100644
--- a/packages/slate/test/commands/by-key/split-descendants-by-key/block.js
+++ b/packages/slate/test/commands/by-key/split-descendants-by-key/block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitDescendantsByKey('a', 'b', 2)
+export default function(editor) {
+  editor.splitDescendantsByKey('a', 'b', 2)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/split-node-by-key/block-with-selection.js b/packages/slate/test/commands/by-key/split-node-by-key/block-with-selection.js
index c5ac39e0d..2d08f628e 100644
--- a/packages/slate/test/commands/by-key/split-node-by-key/block-with-selection.js
+++ b/packages/slate/test/commands/by-key/split-node-by-key/block-with-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitNodeByKey('a', 2)
+export default function(editor) {
+  editor.splitNodeByKey('a', 2)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/split-node-by-key/block.js b/packages/slate/test/commands/by-key/split-node-by-key/block.js
index 9c68b6cbe..d764a41a1 100644
--- a/packages/slate/test/commands/by-key/split-node-by-key/block.js
+++ b/packages/slate/test/commands/by-key/split-node-by-key/block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.splitNodeByKey('a', 2)
+export default function(editor) {
+  editor.splitNodeByKey('a', 2)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/unwrap-block-by-key/single-block.js b/packages/slate/test/commands/by-key/unwrap-block-by-key/single-block.js
index 5f6e15506..5ec04af08 100644
--- a/packages/slate/test/commands/by-key/unwrap-block-by-key/single-block.js
+++ b/packages/slate/test/commands/by-key/unwrap-block-by-key/single-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapBlockByKey('a', 'quote')
+export default function(editor) {
+  editor.unwrapBlockByKey('a', 'quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/unwrap-children-by-key/block-multiple.js b/packages/slate/test/commands/by-key/unwrap-children-by-key/block-multiple.js
index 756a21c10..833674325 100644
--- a/packages/slate/test/commands/by-key/unwrap-children-by-key/block-multiple.js
+++ b/packages/slate/test/commands/by-key/unwrap-children-by-key/block-multiple.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapChildrenByKey('a')
+export default function(editor) {
+  editor.unwrapChildrenByKey('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/unwrap-children-by-key/block.js b/packages/slate/test/commands/by-key/unwrap-children-by-key/block.js
index b89dbc481..7ef551d67 100644
--- a/packages/slate/test/commands/by-key/unwrap-children-by-key/block.js
+++ b/packages/slate/test/commands/by-key/unwrap-children-by-key/block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapChildrenByKey('a')
+export default function(editor) {
+  editor.unwrapChildrenByKey('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/unwrap-inline-by-key/single-block.js b/packages/slate/test/commands/by-key/unwrap-inline-by-key/single-block.js
index c223c3ec9..3b562b986 100644
--- a/packages/slate/test/commands/by-key/unwrap-inline-by-key/single-block.js
+++ b/packages/slate/test/commands/by-key/unwrap-inline-by-key/single-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapInlineByKey('a', 'link')
+export default function(editor) {
+  editor.unwrapInlineByKey('a', 'link')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/unwrap-node-by-key/block.js b/packages/slate/test/commands/by-key/unwrap-node-by-key/block.js
index 91d6a06a6..9eba8fb00 100644
--- a/packages/slate/test/commands/by-key/unwrap-node-by-key/block.js
+++ b/packages/slate/test/commands/by-key/unwrap-node-by-key/block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapNodeByKey('a')
+export default function(editor) {
+  editor.unwrapNodeByKey('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/unwrap-node-by-key/first-block.js b/packages/slate/test/commands/by-key/unwrap-node-by-key/first-block.js
index 3482fdda6..8fce8e56b 100644
--- a/packages/slate/test/commands/by-key/unwrap-node-by-key/first-block.js
+++ b/packages/slate/test/commands/by-key/unwrap-node-by-key/first-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapNodeByKey('a')
+export default function(editor) {
+  editor.unwrapNodeByKey('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/unwrap-node-by-key/last-block.js b/packages/slate/test/commands/by-key/unwrap-node-by-key/last-block.js
index 87a69a40d..357ec8bdd 100644
--- a/packages/slate/test/commands/by-key/unwrap-node-by-key/last-block.js
+++ b/packages/slate/test/commands/by-key/unwrap-node-by-key/last-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapNodeByKey('a')
+export default function(editor) {
+  editor.unwrapNodeByKey('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/unwrap-node-by-key/middle-block.js b/packages/slate/test/commands/by-key/unwrap-node-by-key/middle-block.js
index c46a020cc..3d27882f7 100644
--- a/packages/slate/test/commands/by-key/unwrap-node-by-key/middle-block.js
+++ b/packages/slate/test/commands/by-key/unwrap-node-by-key/middle-block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.unwrapNodeByKey('a')
+export default function(editor) {
+  editor.unwrapNodeByKey('a')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/wrap-block-by-key/block.js b/packages/slate/test/commands/by-key/wrap-block-by-key/block.js
index f046378c9..7f12ccfa5 100644
--- a/packages/slate/test/commands/by-key/wrap-block-by-key/block.js
+++ b/packages/slate/test/commands/by-key/wrap-block-by-key/block.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapBlockByKey('a', 'quote')
+export default function(editor) {
+  editor.wrapBlockByKey('a', 'quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-key/wrap-block-by-key/text.js b/packages/slate/test/commands/by-key/wrap-block-by-key/text.js
index 0966708a1..bfdb50409 100644
--- a/packages/slate/test/commands/by-key/wrap-block-by-key/text.js
+++ b/packages/slate/test/commands/by-key/wrap-block-by-key/text.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.wrapBlockByKey('a', 'quote')
+export default function(editor) {
+  editor.wrapBlockByKey('a', 'quote')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/by-path/move-node-by-path/path-equals-new-path.js b/packages/slate/test/commands/by-path/move-node-by-path/path-equals-new-path.js
index 148145a4e..f18c2ced2 100644
--- a/packages/slate/test/commands/by-path/move-node-by-path/path-equals-new-path.js
+++ b/packages/slate/test/commands/by-path/move-node-by-path/path-equals-new-path.js
@@ -7,12 +7,12 @@ import assert from 'assert'
 const pathA = PathUtils.create([0])
 const pathB = PathUtils.create([1])
 
-export default function(change) {
-  change.moveNodeByPath(pathA, pathA, 0)
-  change.moveNodeByPath(pathA, pathA, 1)
-  change.moveNodeByPath(pathB, pathB, 0)
-  change.moveNodeByPath(pathB, pathB, 1)
-  assert(change.operations.size === 0)
+export default function(editor) {
+  editor.moveNodeByPath(pathA, pathA, 0)
+  editor.moveNodeByPath(pathA, pathA, 1)
+  editor.moveNodeByPath(pathB, pathB, 0)
+  editor.moveNodeByPath(pathB, pathB, 1)
+  assert(editor.operations.size === 0)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/general/call/call-no-arguments.js b/packages/slate/test/commands/general/call/call-no-arguments.js
deleted file mode 100644
index 4bf2b927d..000000000
--- a/packages/slate/test/commands/general/call/call-no-arguments.js
+++ /dev/null
@@ -1,34 +0,0 @@
-/** @jsx h */
-
-import h from '../../../helpers/h'
-
-function insertImageBlock(change, blockType) {
-  change.insertBlock('image')
-}
-
-export default function(change) {
-  change.call(insertImageBlock)
-}
-
-export const input = (
-  <value>
-    <document>
-      <paragraph>
-        <cursor />one
-      </paragraph>
-      <paragraph>two</paragraph>
-    </document>
-  </value>
-)
-
-export const output = (
-  <value>
-    <document>
-      <image>
-        <cursor />
-      </image>
-      <paragraph>one</paragraph>
-      <paragraph>two</paragraph>
-    </document>
-  </value>
-)
diff --git a/packages/slate/test/commands/general/call/call-with-arguments.js b/packages/slate/test/commands/general/call/call-with-arguments.js
index ff579d912..8256fe19d 100644
--- a/packages/slate/test/commands/general/call/call-with-arguments.js
+++ b/packages/slate/test/commands/general/call/call-with-arguments.js
@@ -2,12 +2,12 @@
 
 import h from '../../../helpers/h'
 
-function insertBlockByType(change, blockType) {
-  change.insertBlock({ type: blockType })
+function insertBlockByType(editor, blockType) {
+  editor.insertBlock({ type: blockType })
 }
 
-export default function(change) {
-  change.call(insertBlockByType, 'image')
+export default function(editor) {
+  editor.command(insertBlockByType, 'image')
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/blur/basic.js b/packages/slate/test/commands/on-selection/blur/basic.js
index 43543532e..2cc05373e 100644
--- a/packages/slate/test/commands/on-selection/blur/basic.js
+++ b/packages/slate/test/commands/on-selection/blur/basic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.blur()
+export default function(editor) {
+  editor.blur()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/focus/basic.js b/packages/slate/test/commands/on-selection/focus/basic.js
index de85a697b..c812b73a1 100644
--- a/packages/slate/test/commands/on-selection/focus/basic.js
+++ b/packages/slate/test/commands/on-selection/focus/basic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.focus()
+export default function(editor) {
+  editor.focus()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-anchor-backward/default.js b/packages/slate/test/commands/on-selection/move-anchor-backward/default.js
index 72301aa65..e8f50e791 100644
--- a/packages/slate/test/commands/on-selection/move-anchor-backward/default.js
+++ b/packages/slate/test/commands/on-selection/move-anchor-backward/default.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveAnchorBackward()
+export default function(editor) {
+  editor.moveAnchorBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-anchor-backward/from-collapsed.js b/packages/slate/test/commands/on-selection/move-anchor-backward/from-collapsed.js
index 36d2638d1..e6a25108b 100644
--- a/packages/slate/test/commands/on-selection/move-anchor-backward/from-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-anchor-backward/from-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveAnchorBackward()
+export default function(editor) {
+  editor.moveAnchorBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-anchor-backward/out-of-reverse.js b/packages/slate/test/commands/on-selection/move-anchor-backward/out-of-reverse.js
index 6c0aca315..1ee9c3af7 100644
--- a/packages/slate/test/commands/on-selection/move-anchor-backward/out-of-reverse.js
+++ b/packages/slate/test/commands/on-selection/move-anchor-backward/out-of-reverse.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveAnchorBackward(8)
+export default function(editor) {
+  editor.moveAnchorBackward(8)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-anchor-backward/param.js b/packages/slate/test/commands/on-selection/move-anchor-backward/param.js
index efb6eeefa..8fd1f5702 100644
--- a/packages/slate/test/commands/on-selection/move-anchor-backward/param.js
+++ b/packages/slate/test/commands/on-selection/move-anchor-backward/param.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveAnchorBackward(3)
+export default function(editor) {
+  editor.moveAnchorBackward(3)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-anchor-forward/default.js b/packages/slate/test/commands/on-selection/move-anchor-forward/default.js
index 238d85153..c101b62e0 100644
--- a/packages/slate/test/commands/on-selection/move-anchor-forward/default.js
+++ b/packages/slate/test/commands/on-selection/move-anchor-forward/default.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveAnchorForward()
+export default function(editor) {
+  editor.moveAnchorForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-anchor-forward/from-collapsed.js b/packages/slate/test/commands/on-selection/move-anchor-forward/from-collapsed.js
index 2a905b8a5..51b5f0811 100644
--- a/packages/slate/test/commands/on-selection/move-anchor-forward/from-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-anchor-forward/from-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveAnchorForward()
+export default function(editor) {
+  editor.moveAnchorForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-anchor-forward/into-reverse.js b/packages/slate/test/commands/on-selection/move-anchor-forward/into-reverse.js
index b17088d95..e22c1128b 100644
--- a/packages/slate/test/commands/on-selection/move-anchor-forward/into-reverse.js
+++ b/packages/slate/test/commands/on-selection/move-anchor-forward/into-reverse.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveAnchorForward(8)
+export default function(editor) {
+  editor.moveAnchorForward(8)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-anchor-forward/param.js b/packages/slate/test/commands/on-selection/move-anchor-forward/param.js
index 78ca98dd8..782c2d0bb 100644
--- a/packages/slate/test/commands/on-selection/move-anchor-forward/param.js
+++ b/packages/slate/test/commands/on-selection/move-anchor-forward/param.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveAnchorForward(3)
+export default function(editor) {
+  editor.moveAnchorForward(3)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-backward/default.js b/packages/slate/test/commands/on-selection/move-backward/default.js
index e8a18e6e2..3ea3b5aa4 100644
--- a/packages/slate/test/commands/on-selection/move-backward/default.js
+++ b/packages/slate/test/commands/on-selection/move-backward/default.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveBackward()
+export default function(editor) {
+  editor.moveBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-backward/expanded.js b/packages/slate/test/commands/on-selection/move-backward/expanded.js
index 24a76f4d1..9926bc144 100644
--- a/packages/slate/test/commands/on-selection/move-backward/expanded.js
+++ b/packages/slate/test/commands/on-selection/move-backward/expanded.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveBackward()
+export default function(editor) {
+  editor.moveBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-backward/param.js b/packages/slate/test/commands/on-selection/move-backward/param.js
index 5300f5fff..79206535d 100644
--- a/packages/slate/test/commands/on-selection/move-backward/param.js
+++ b/packages/slate/test/commands/on-selection/move-backward/param.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveBackward(6)
+export default function(editor) {
+  editor.moveBackward(6)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-backward/reversed.js b/packages/slate/test/commands/on-selection/move-backward/reversed.js
index a1488d56c..5524964a1 100644
--- a/packages/slate/test/commands/on-selection/move-backward/reversed.js
+++ b/packages/slate/test/commands/on-selection/move-backward/reversed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveBackward()
+export default function(editor) {
+  editor.moveBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-end-backward/default.js b/packages/slate/test/commands/on-selection/move-end-backward/default.js
index d07b1d982..2402755a7 100644
--- a/packages/slate/test/commands/on-selection/move-end-backward/default.js
+++ b/packages/slate/test/commands/on-selection/move-end-backward/default.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveEndBackward()
+export default function(editor) {
+  editor.moveEndBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-end-backward/from-collapsed.js b/packages/slate/test/commands/on-selection/move-end-backward/from-collapsed.js
index 60833f6c5..cb9946136 100644
--- a/packages/slate/test/commands/on-selection/move-end-backward/from-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-end-backward/from-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveEndBackward()
+export default function(editor) {
+  editor.moveEndBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-end-backward/into-reverse.js b/packages/slate/test/commands/on-selection/move-end-backward/into-reverse.js
index d6942db78..dcd163afb 100644
--- a/packages/slate/test/commands/on-selection/move-end-backward/into-reverse.js
+++ b/packages/slate/test/commands/on-selection/move-end-backward/into-reverse.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveEndBackward(6)
+export default function(editor) {
+  editor.moveEndBackward(6)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-end-backward/out-of-reverse.js b/packages/slate/test/commands/on-selection/move-end-backward/out-of-reverse.js
index 63dc248a2..d8c49466f 100644
--- a/packages/slate/test/commands/on-selection/move-end-backward/out-of-reverse.js
+++ b/packages/slate/test/commands/on-selection/move-end-backward/out-of-reverse.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveEndBackward(7)
+export default function(editor) {
+  editor.moveEndBackward(7)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-end-backward/param.js b/packages/slate/test/commands/on-selection/move-end-backward/param.js
index 6105a6293..6516746d9 100644
--- a/packages/slate/test/commands/on-selection/move-end-backward/param.js
+++ b/packages/slate/test/commands/on-selection/move-end-backward/param.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveEndBackward(3)
+export default function(editor) {
+  editor.moveEndBackward(3)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-end-backward/reversed.js b/packages/slate/test/commands/on-selection/move-end-backward/reversed.js
index ad96af0f5..bf83a7a94 100644
--- a/packages/slate/test/commands/on-selection/move-end-backward/reversed.js
+++ b/packages/slate/test/commands/on-selection/move-end-backward/reversed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveEndBackward()
+export default function(editor) {
+  editor.moveEndBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-end-forward/default.js b/packages/slate/test/commands/on-selection/move-end-forward/default.js
index 603514047..796dedcbb 100644
--- a/packages/slate/test/commands/on-selection/move-end-forward/default.js
+++ b/packages/slate/test/commands/on-selection/move-end-forward/default.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveEndForward()
+export default function(editor) {
+  editor.moveEndForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-end-forward/from-collapsed.js b/packages/slate/test/commands/on-selection/move-end-forward/from-collapsed.js
index e1138a4f7..9de3fa3a4 100644
--- a/packages/slate/test/commands/on-selection/move-end-forward/from-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-end-forward/from-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveEndForward()
+export default function(editor) {
+  editor.moveEndForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-end-forward/param.js b/packages/slate/test/commands/on-selection/move-end-forward/param.js
index 57ea918d2..8433f9de6 100644
--- a/packages/slate/test/commands/on-selection/move-end-forward/param.js
+++ b/packages/slate/test/commands/on-selection/move-end-forward/param.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveEndForward(3)
+export default function(editor) {
+  editor.moveEndForward(3)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-end-forward/reversed.js b/packages/slate/test/commands/on-selection/move-end-forward/reversed.js
index 68b74ad6c..2680e9880 100644
--- a/packages/slate/test/commands/on-selection/move-end-forward/reversed.js
+++ b/packages/slate/test/commands/on-selection/move-end-forward/reversed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveEndForward()
+export default function(editor) {
+  editor.moveEndForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-focus-backward/default.js b/packages/slate/test/commands/on-selection/move-focus-backward/default.js
index e87b12d25..25f5e6452 100644
--- a/packages/slate/test/commands/on-selection/move-focus-backward/default.js
+++ b/packages/slate/test/commands/on-selection/move-focus-backward/default.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveFocusBackward()
+export default function(editor) {
+  editor.moveFocusBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-focus-backward/from-collapsed.js b/packages/slate/test/commands/on-selection/move-focus-backward/from-collapsed.js
index 1ff052be3..af91c7df4 100644
--- a/packages/slate/test/commands/on-selection/move-focus-backward/from-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-focus-backward/from-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveFocusBackward()
+export default function(editor) {
+  editor.moveFocusBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-focus-backward/into-reverse.js b/packages/slate/test/commands/on-selection/move-focus-backward/into-reverse.js
index fcfc2c1a8..9780661c7 100644
--- a/packages/slate/test/commands/on-selection/move-focus-backward/into-reverse.js
+++ b/packages/slate/test/commands/on-selection/move-focus-backward/into-reverse.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveFocusBackward(10)
+export default function(editor) {
+  editor.moveFocusBackward(10)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-focus-backward/param.js b/packages/slate/test/commands/on-selection/move-focus-backward/param.js
index 57f37ab64..a17daac78 100644
--- a/packages/slate/test/commands/on-selection/move-focus-backward/param.js
+++ b/packages/slate/test/commands/on-selection/move-focus-backward/param.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveFocusBackward(6)
+export default function(editor) {
+  editor.moveFocusBackward(6)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-focus-forward/default.js b/packages/slate/test/commands/on-selection/move-focus-forward/default.js
index 9174f6f20..5100dfed6 100644
--- a/packages/slate/test/commands/on-selection/move-focus-forward/default.js
+++ b/packages/slate/test/commands/on-selection/move-focus-forward/default.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveFocusForward()
+export default function(editor) {
+  editor.moveFocusForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-focus-forward/from-collapsed.js b/packages/slate/test/commands/on-selection/move-focus-forward/from-collapsed.js
index 51e555784..6d474b4cd 100644
--- a/packages/slate/test/commands/on-selection/move-focus-forward/from-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-focus-forward/from-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveFocusForward()
+export default function(editor) {
+  editor.moveFocusForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-focus-forward/out-of-reverse.js b/packages/slate/test/commands/on-selection/move-focus-forward/out-of-reverse.js
index 487fda569..018f12470 100644
--- a/packages/slate/test/commands/on-selection/move-focus-forward/out-of-reverse.js
+++ b/packages/slate/test/commands/on-selection/move-focus-forward/out-of-reverse.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveFocusForward(7)
+export default function(editor) {
+  editor.moveFocusForward(7)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-focus-forward/param.js b/packages/slate/test/commands/on-selection/move-focus-forward/param.js
index 413dcea1a..bdb83b1f8 100644
--- a/packages/slate/test/commands/on-selection/move-focus-forward/param.js
+++ b/packages/slate/test/commands/on-selection/move-focus-forward/param.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveFocusForward(4)
+export default function(editor) {
+  editor.moveFocusForward(4)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-forward/default.js b/packages/slate/test/commands/on-selection/move-forward/default.js
index 857b1e478..396f0df13 100644
--- a/packages/slate/test/commands/on-selection/move-forward/default.js
+++ b/packages/slate/test/commands/on-selection/move-forward/default.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveForward()
+export default function(editor) {
+  editor.moveForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-forward/expanded.js b/packages/slate/test/commands/on-selection/move-forward/expanded.js
index 9f760af00..633134b5f 100644
--- a/packages/slate/test/commands/on-selection/move-forward/expanded.js
+++ b/packages/slate/test/commands/on-selection/move-forward/expanded.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveForward()
+export default function(editor) {
+  editor.moveForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-forward/param.js b/packages/slate/test/commands/on-selection/move-forward/param.js
index 73dd38d98..7c83f7f99 100644
--- a/packages/slate/test/commands/on-selection/move-forward/param.js
+++ b/packages/slate/test/commands/on-selection/move-forward/param.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveForward(6)
+export default function(editor) {
+  editor.moveForward(6)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-forward/reversed.js b/packages/slate/test/commands/on-selection/move-forward/reversed.js
index b00f6cd29..8f6cf8618 100644
--- a/packages/slate/test/commands/on-selection/move-forward/reversed.js
+++ b/packages/slate/test/commands/on-selection/move-forward/reversed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveForward()
+export default function(editor) {
+  editor.moveForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-start-backward/default.js b/packages/slate/test/commands/on-selection/move-start-backward/default.js
index 20a44992d..17c2e58e5 100644
--- a/packages/slate/test/commands/on-selection/move-start-backward/default.js
+++ b/packages/slate/test/commands/on-selection/move-start-backward/default.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveStartBackward()
+export default function(editor) {
+  editor.moveStartBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-start-backward/from-collapsed.js b/packages/slate/test/commands/on-selection/move-start-backward/from-collapsed.js
index a94dcaeeb..39cc5354d 100644
--- a/packages/slate/test/commands/on-selection/move-start-backward/from-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-start-backward/from-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveStartBackward()
+export default function(editor) {
+  editor.moveStartBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-start-backward/param.js b/packages/slate/test/commands/on-selection/move-start-backward/param.js
index bdaf7833c..41a8dbd41 100644
--- a/packages/slate/test/commands/on-selection/move-start-backward/param.js
+++ b/packages/slate/test/commands/on-selection/move-start-backward/param.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveStartBackward(3)
+export default function(editor) {
+  editor.moveStartBackward(3)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-start-backward/reversed.js b/packages/slate/test/commands/on-selection/move-start-backward/reversed.js
index 03287292f..d02cb02b5 100644
--- a/packages/slate/test/commands/on-selection/move-start-backward/reversed.js
+++ b/packages/slate/test/commands/on-selection/move-start-backward/reversed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveStartBackward()
+export default function(editor) {
+  editor.moveStartBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-start-forward/default.js b/packages/slate/test/commands/on-selection/move-start-forward/default.js
index 9dc1c57ff..5129aed22 100644
--- a/packages/slate/test/commands/on-selection/move-start-forward/default.js
+++ b/packages/slate/test/commands/on-selection/move-start-forward/default.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveStartForward()
+export default function(editor) {
+  editor.moveStartForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-start-forward/from-collapsed.js b/packages/slate/test/commands/on-selection/move-start-forward/from-collapsed.js
index 797e444ce..73a3b354f 100644
--- a/packages/slate/test/commands/on-selection/move-start-forward/from-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-start-forward/from-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveStartForward()
+export default function(editor) {
+  editor.moveStartForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-start-forward/into-reverse.js b/packages/slate/test/commands/on-selection/move-start-forward/into-reverse.js
index 649321b9d..14daf3ab0 100644
--- a/packages/slate/test/commands/on-selection/move-start-forward/into-reverse.js
+++ b/packages/slate/test/commands/on-selection/move-start-forward/into-reverse.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveStartForward(8)
+export default function(editor) {
+  editor.moveStartForward(8)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-start-forward/out-of-reverse.js b/packages/slate/test/commands/on-selection/move-start-forward/out-of-reverse.js
index b70fa04e6..8e2034d71 100644
--- a/packages/slate/test/commands/on-selection/move-start-forward/out-of-reverse.js
+++ b/packages/slate/test/commands/on-selection/move-start-forward/out-of-reverse.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveStartForward(7)
+export default function(editor) {
+  editor.moveStartForward(7)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-start-forward/param.js b/packages/slate/test/commands/on-selection/move-start-forward/param.js
index b8d78d86d..1613d92fc 100644
--- a/packages/slate/test/commands/on-selection/move-start-forward/param.js
+++ b/packages/slate/test/commands/on-selection/move-start-forward/param.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveStartForward(3)
+export default function(editor) {
+  editor.moveStartForward(3)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-start-forward/reversed.js b/packages/slate/test/commands/on-selection/move-start-forward/reversed.js
index 7f6691bb7..7280da5fc 100644
--- a/packages/slate/test/commands/on-selection/move-start-forward/reversed.js
+++ b/packages/slate/test/commands/on-selection/move-start-forward/reversed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveStartForward()
+export default function(editor) {
+  editor.moveStartForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-anchor/already-collapsed.js b/packages/slate/test/commands/on-selection/move-to-anchor/already-collapsed.js
index 4fb1ffb32..95cef63ed 100644
--- a/packages/slate/test/commands/on-selection/move-to-anchor/already-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-to-anchor/already-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToAnchor()
+export default function(editor) {
+  editor.moveToAnchor()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-anchor/basic.js b/packages/slate/test/commands/on-selection/move-to-anchor/basic.js
index c0095c12b..6c13ddb8e 100644
--- a/packages/slate/test/commands/on-selection/move-to-anchor/basic.js
+++ b/packages/slate/test/commands/on-selection/move-to-anchor/basic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToAnchor()
+export default function(editor) {
+  editor.moveToAnchor()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-block/end.js b/packages/slate/test/commands/on-selection/move-to-end-of-block/end.js
index 0e01b3ff4..7b93cc124 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-block/end.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-block/end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfBlock()
+export default function(editor) {
+  editor.moveToEndOfBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-block/middle.js b/packages/slate/test/commands/on-selection/move-to-end-of-block/middle.js
index 4e11d78cf..f96bd52ad 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-block/middle.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-block/middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfBlock()
+export default function(editor) {
+  editor.moveToEndOfBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-block/start.js b/packages/slate/test/commands/on-selection/move-to-end-of-block/start.js
index 5cdf44f3f..37a41c2a2 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-block/start.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-block/start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfBlock()
+export default function(editor) {
+  editor.moveToEndOfBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-document/block-end.js b/packages/slate/test/commands/on-selection/move-to-end-of-document/block-end.js
index 8378e1dc5..c7672915e 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-document/block-end.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-document/block-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfDocument()
+export default function(editor) {
+  editor.moveToEndOfDocument()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-document/block-middle.js b/packages/slate/test/commands/on-selection/move-to-end-of-document/block-middle.js
index ed2fcdfbb..619c00f54 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-document/block-middle.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-document/block-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfDocument()
+export default function(editor) {
+  editor.moveToEndOfDocument()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-document/block-start.js b/packages/slate/test/commands/on-selection/move-to-end-of-document/block-start.js
index 5154aa2c3..9fb25f445 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-document/block-start.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-document/block-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfDocument()
+export default function(editor) {
+  editor.moveToEndOfDocument()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-document/document-end.js b/packages/slate/test/commands/on-selection/move-to-end-of-document/document-end.js
index eca2d354d..30c46b593 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-document/document-end.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-document/document-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfDocument()
+export default function(editor) {
+  editor.moveToEndOfDocument()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-document/document-start.js b/packages/slate/test/commands/on-selection/move-to-end-of-document/document-start.js
index 1ba8de8c1..7b977f865 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-document/document-start.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-document/document-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfDocument()
+export default function(editor) {
+  editor.moveToEndOfDocument()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-end.js b/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-end.js
index 5be3d9771..364aa0da4 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-end.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfNextBlock()
+export default function(editor) {
+  editor.moveToEndOfNextBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-middle.js b/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-middle.js
index a57c79eee..35a0b5551 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-middle.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfNextBlock()
+export default function(editor) {
+  editor.moveToEndOfNextBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-start.js b/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-start.js
index 4d9ddd121..3519ffddf 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-start.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-next-block/block-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfNextBlock()
+export default function(editor) {
+  editor.moveToEndOfNextBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-next-block/document-end.js b/packages/slate/test/commands/on-selection/move-to-end-of-next-block/document-end.js
index 6b676c7b4..654d12c7a 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-next-block/document-end.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-next-block/document-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfNextBlock()
+export default function(editor) {
+  editor.moveToEndOfNextBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-next-block/document-start.js b/packages/slate/test/commands/on-selection/move-to-end-of-next-block/document-start.js
index 4e9218bd5..c7e1ee2cd 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-next-block/document-start.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-next-block/document-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfNextBlock()
+export default function(editor) {
+  editor.moveToEndOfNextBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-end.js b/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-end.js
index a7d4b4993..72b32c6b5 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-end.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfPreviousBlock()
+export default function(editor) {
+  editor.moveToEndOfPreviousBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-middle.js b/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-middle.js
index 183e3735b..12d8833e8 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-middle.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfPreviousBlock()
+export default function(editor) {
+  editor.moveToEndOfPreviousBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-start.js b/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-start.js
index 225b4301b..d19a01796 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-start.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/block-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfPreviousBlock()
+export default function(editor) {
+  editor.moveToEndOfPreviousBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/document-end.js b/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/document-end.js
index 68ce9437a..776916ec6 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/document-end.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/document-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfPreviousBlock()
+export default function(editor) {
+  editor.moveToEndOfPreviousBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/document-start.js b/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/document-start.js
index cea496f37..d634c10b9 100644
--- a/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/document-start.js
+++ b/packages/slate/test/commands/on-selection/move-to-end-of-previous-block/document-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEndOfPreviousBlock()
+export default function(editor) {
+  editor.moveToEndOfPreviousBlock()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end/already-collapsed.js b/packages/slate/test/commands/on-selection/move-to-end/already-collapsed.js
index 3a9da49a1..0497a15ca 100644
--- a/packages/slate/test/commands/on-selection/move-to-end/already-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-to-end/already-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEnd()
+export default function(editor) {
+  editor.moveToEnd()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end/basic.js b/packages/slate/test/commands/on-selection/move-to-end/basic.js
index d097bb376..7ba9601d9 100644
--- a/packages/slate/test/commands/on-selection/move-to-end/basic.js
+++ b/packages/slate/test/commands/on-selection/move-to-end/basic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEnd()
+export default function(editor) {
+  editor.moveToEnd()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-end/void.js b/packages/slate/test/commands/on-selection/move-to-end/void.js
index d9d71e037..f9e0b3927 100644
--- a/packages/slate/test/commands/on-selection/move-to-end/void.js
+++ b/packages/slate/test/commands/on-selection/move-to-end/void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToEnd()
+export default function(editor) {
+  editor.moveToEnd()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-focus/already-collapsed.js b/packages/slate/test/commands/on-selection/move-to-focus/already-collapsed.js
index 07c938880..dfa4da920 100644
--- a/packages/slate/test/commands/on-selection/move-to-focus/already-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-to-focus/already-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToFocus()
+export default function(editor) {
+  editor.moveToFocus()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-focus/basic.js b/packages/slate/test/commands/on-selection/move-to-focus/basic.js
index fcf66407a..7eb994cdd 100644
--- a/packages/slate/test/commands/on-selection/move-to-focus/basic.js
+++ b/packages/slate/test/commands/on-selection/move-to-focus/basic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToFocus()
+export default function(editor) {
+  editor.moveToFocus()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-range-of-document/basic.js b/packages/slate/test/commands/on-selection/move-to-range-of-document/basic.js
index 902a895b2..fa1a2af6a 100644
--- a/packages/slate/test/commands/on-selection/move-to-range-of-document/basic.js
+++ b/packages/slate/test/commands/on-selection/move-to-range-of-document/basic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToRangeOfDocument()
+export default function(editor) {
+  editor.moveToRangeOfDocument()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-start-of-document/block-end.js b/packages/slate/test/commands/on-selection/move-to-start-of-document/block-end.js
index e595595b5..580d7b69d 100644
--- a/packages/slate/test/commands/on-selection/move-to-start-of-document/block-end.js
+++ b/packages/slate/test/commands/on-selection/move-to-start-of-document/block-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToStartOfDocument()
+export default function(editor) {
+  editor.moveToStartOfDocument()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-start-of-document/block-middle.js b/packages/slate/test/commands/on-selection/move-to-start-of-document/block-middle.js
index 47c8eab22..1eecfe86d 100644
--- a/packages/slate/test/commands/on-selection/move-to-start-of-document/block-middle.js
+++ b/packages/slate/test/commands/on-selection/move-to-start-of-document/block-middle.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToStartOfDocument()
+export default function(editor) {
+  editor.moveToStartOfDocument()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-start-of-document/block-start.js b/packages/slate/test/commands/on-selection/move-to-start-of-document/block-start.js
index 6601d04bb..0f6b42280 100644
--- a/packages/slate/test/commands/on-selection/move-to-start-of-document/block-start.js
+++ b/packages/slate/test/commands/on-selection/move-to-start-of-document/block-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToStartOfDocument()
+export default function(editor) {
+  editor.moveToStartOfDocument()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-start-of-document/document-end.js b/packages/slate/test/commands/on-selection/move-to-start-of-document/document-end.js
index d30990744..8e19a5f09 100644
--- a/packages/slate/test/commands/on-selection/move-to-start-of-document/document-end.js
+++ b/packages/slate/test/commands/on-selection/move-to-start-of-document/document-end.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToStartOfDocument()
+export default function(editor) {
+  editor.moveToStartOfDocument()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-start-of-document/document-start.js b/packages/slate/test/commands/on-selection/move-to-start-of-document/document-start.js
index db47c449d..88bf21d8d 100644
--- a/packages/slate/test/commands/on-selection/move-to-start-of-document/document-start.js
+++ b/packages/slate/test/commands/on-selection/move-to-start-of-document/document-start.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToStartOfDocument()
+export default function(editor) {
+  editor.moveToStartOfDocument()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-start/already-collapsed.js b/packages/slate/test/commands/on-selection/move-to-start/already-collapsed.js
index d36a55573..3d1788c3f 100644
--- a/packages/slate/test/commands/on-selection/move-to-start/already-collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-to-start/already-collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToStart()
+export default function(editor) {
+  editor.moveToStart()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-start/basic.js b/packages/slate/test/commands/on-selection/move-to-start/basic.js
index 3bc38680b..228f2e75f 100644
--- a/packages/slate/test/commands/on-selection/move-to-start/basic.js
+++ b/packages/slate/test/commands/on-selection/move-to-start/basic.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToStart()
+export default function(editor) {
+  editor.moveToStart()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-to-start/void.js b/packages/slate/test/commands/on-selection/move-to-start/void.js
index 70fc2cd2e..19350a6c0 100644
--- a/packages/slate/test/commands/on-selection/move-to-start/void.js
+++ b/packages/slate/test/commands/on-selection/move-to-start/void.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveToStart()
+export default function(editor) {
+  editor.moveToStart()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-word-backward/collapsed.js b/packages/slate/test/commands/on-selection/move-word-backward/collapsed.js
index 051397248..0829afcf3 100644
--- a/packages/slate/test/commands/on-selection/move-word-backward/collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-word-backward/collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveWordBackward()
+export default function(editor) {
+  editor.moveWordBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-word-backward/expanded.js b/packages/slate/test/commands/on-selection/move-word-backward/expanded.js
index 4e2064415..f76559fe0 100644
--- a/packages/slate/test/commands/on-selection/move-word-backward/expanded.js
+++ b/packages/slate/test/commands/on-selection/move-word-backward/expanded.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveWordBackward()
+export default function(editor) {
+  editor.moveWordBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-word-backward/reversed.js b/packages/slate/test/commands/on-selection/move-word-backward/reversed.js
index 4b97448dc..78aba90d1 100644
--- a/packages/slate/test/commands/on-selection/move-word-backward/reversed.js
+++ b/packages/slate/test/commands/on-selection/move-word-backward/reversed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveWordBackward()
+export default function(editor) {
+  editor.moveWordBackward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-word-forward/collapsed.js b/packages/slate/test/commands/on-selection/move-word-forward/collapsed.js
index 80ea11801..bf8606d0f 100644
--- a/packages/slate/test/commands/on-selection/move-word-forward/collapsed.js
+++ b/packages/slate/test/commands/on-selection/move-word-forward/collapsed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveWordForward()
+export default function(editor) {
+  editor.moveWordForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-word-forward/expanded.js b/packages/slate/test/commands/on-selection/move-word-forward/expanded.js
index 486c7a09e..3c3ab8fc9 100644
--- a/packages/slate/test/commands/on-selection/move-word-forward/expanded.js
+++ b/packages/slate/test/commands/on-selection/move-word-forward/expanded.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveWordForward()
+export default function(editor) {
+  editor.moveWordForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/move-word-forward/reversed.js b/packages/slate/test/commands/on-selection/move-word-forward/reversed.js
index c5f1bdc85..b8c0a3d69 100644
--- a/packages/slate/test/commands/on-selection/move-word-forward/reversed.js
+++ b/packages/slate/test/commands/on-selection/move-word-forward/reversed.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.moveWordForward()
+export default function(editor) {
+  editor.moveWordForward()
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-selection/select/with-object.js b/packages/slate/test/commands/on-selection/select/with-object.js
index e28572910..9019e63a7 100644
--- a/packages/slate/test/commands/on-selection/select/with-object.js
+++ b/packages/slate/test/commands/on-selection/select/with-object.js
@@ -2,11 +2,11 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  const { value } = change
+export default function(editor) {
+  const { value } = editor
   const { startText } = value
 
-  change.select({
+  editor.select({
     anchor: {
       key: startText.key,
       offset: 0,
diff --git a/packages/slate/test/commands/on-selection/select/with-selection.js b/packages/slate/test/commands/on-selection/select/with-selection.js
index f3a52bf19..e14872067 100644
--- a/packages/slate/test/commands/on-selection/select/with-selection.js
+++ b/packages/slate/test/commands/on-selection/select/with-selection.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  const { value } = change
+export default function(editor) {
+  const { value } = editor
   const { selection, startText } = value
   const range = selection.setProperties({
     anchor: {
@@ -16,7 +16,7 @@ export default function(change) {
     },
   })
 
-  change.select(range)
+  editor.select(range)
 }
 
 export const input = (
diff --git a/packages/slate/test/commands/on-state/set-data/simple.js b/packages/slate/test/commands/on-state/set-data/simple.js
index ec07d76cd..f8b142c92 100644
--- a/packages/slate/test/commands/on-state/set-data/simple.js
+++ b/packages/slate/test/commands/on-state/set-data/simple.js
@@ -2,8 +2,8 @@
 
 import h from '../../../helpers/h'
 
-export default function(change) {
-  change.setValue({ data: { thing: 'value' } })
+export default function(editor) {
+  editor.setData({ thing: 'value' })
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/add-mark-across-blocks.js b/packages/slate/test/history/undo/add-mark-across-blocks.js
index aa0fb3af4..310c6f1eb 100644
--- a/packages/slate/test/history/undo/add-mark-across-blocks.js
+++ b/packages/slate/test/history/undo/add-mark-across-blocks.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.addMark('bold')
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.addMark('bold')
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/add-mark-across-marks.js b/packages/slate/test/history/undo/add-mark-across-marks.js
index b125bd02f..3036f95a5 100644
--- a/packages/slate/test/history/undo/add-mark-across-marks.js
+++ b/packages/slate/test/history/undo/add-mark-across-marks.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.addMark('bold')
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.addMark('bold')
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/add-mark-across-same-mark.js b/packages/slate/test/history/undo/add-mark-across-same-mark.js
index 1fba6210a..aa1e5cb0b 100644
--- a/packages/slate/test/history/undo/add-mark-across-same-mark.js
+++ b/packages/slate/test/history/undo/add-mark-across-same-mark.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.addMark('bold')
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.addMark('bold')
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/add-mark.js b/packages/slate/test/history/undo/add-mark.js
index dd05733b5..bb2cd613e 100644
--- a/packages/slate/test/history/undo/add-mark.js
+++ b/packages/slate/test/history/undo/add-mark.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.addMark('bold')
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.addMark('bold')
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/delete-across-blocks.js b/packages/slate/test/history/undo/delete-across-blocks.js
index c8d0b2fcd..08574322d 100644
--- a/packages/slate/test/history/undo/delete-across-blocks.js
+++ b/packages/slate/test/history/undo/delete-across-blocks.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.delete()
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.delete()
+  editor.flush().undo()
 }
 
 // the paragraph and code blocks have some random data
diff --git a/packages/slate/test/history/undo/delete-across-inlines.js b/packages/slate/test/history/undo/delete-across-inlines.js
index b393f5220..ff6642291 100644
--- a/packages/slate/test/history/undo/delete-across-inlines.js
+++ b/packages/slate/test/history/undo/delete-across-inlines.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.delete()
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.delete()
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/delete-across-marks.js b/packages/slate/test/history/undo/delete-across-marks.js
index f15bdf427..bf1220eab 100644
--- a/packages/slate/test/history/undo/delete-across-marks.js
+++ b/packages/slate/test/history/undo/delete-across-marks.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.delete()
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.delete()
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/delete.js b/packages/slate/test/history/undo/delete.js
index 9edf1ff5a..13f496e49 100644
--- a/packages/slate/test/history/undo/delete.js
+++ b/packages/slate/test/history/undo/delete.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.delete()
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.delete()
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/insert-block.js b/packages/slate/test/history/undo/insert-block.js
index 0983dc776..409599402 100644
--- a/packages/slate/test/history/undo/insert-block.js
+++ b/packages/slate/test/history/undo/insert-block.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.insertBlock('quote')
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.insertBlock('quote')
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/insert-text-contiguous.js b/packages/slate/test/history/undo/insert-text-contiguous.js
index 268674685..8dca965c9 100644
--- a/packages/slate/test/history/undo/insert-text-contiguous.js
+++ b/packages/slate/test/history/undo/insert-text-contiguous.js
@@ -3,21 +3,10 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.insertText('t')
-  })
-
-  editor.change(change => {
-    change.insertText('w')
-  })
-
-  editor.change(change => {
-    change.insertText('o')
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.insertText('t')
+  editor.flush().insertText('w')
+  editor.flush().insertText('o')
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/insert-text-not-contiguous.js b/packages/slate/test/history/undo/insert-text-not-contiguous.js
index c737946cf..92bfe1f5a 100644
--- a/packages/slate/test/history/undo/insert-text-not-contiguous.js
+++ b/packages/slate/test/history/undo/insert-text-not-contiguous.js
@@ -3,21 +3,19 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.insertText('t')
-  })
+  editor.insertText('t')
 
-  editor.change(change => {
-    change.moveBackward(1).insertText('w')
-  })
+  editor
+    .flush()
+    .moveBackward(1)
+    .insertText('w')
 
-  editor.change(change => {
-    change.moveBackward(1).insertText('o')
-  })
+  editor
+    .flush()
+    .moveBackward(1)
+    .insertText('o')
 
-  editor.change(change => {
-    change.undo()
-  })
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/insert-text.js b/packages/slate/test/history/undo/insert-text.js
index 48e6dc79c..a3dbff1e8 100644
--- a/packages/slate/test/history/undo/insert-text.js
+++ b/packages/slate/test/history/undo/insert-text.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.insertText('text')
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.insertText('text')
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/move-node-affecting-path.js b/packages/slate/test/history/undo/move-node-affecting-path.js
index 97f5951c5..830815e38 100644
--- a/packages/slate/test/history/undo/move-node-affecting-path.js
+++ b/packages/slate/test/history/undo/move-node-affecting-path.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.moveNodeByKey('c', 'd', 1)
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.moveNodeByKey('c', 'd', 1)
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/move-node-before-itself.js b/packages/slate/test/history/undo/move-node-before-itself.js
index f7aa88bda..0bc82fb7d 100644
--- a/packages/slate/test/history/undo/move-node-before-itself.js
+++ b/packages/slate/test/history/undo/move-node-before-itself.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.moveNodeByKey('h', 'a', 0)
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.moveNodeByKey('h', 'a', 0)
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/move-node-by-key.js b/packages/slate/test/history/undo/move-node-by-key.js
index 358e27800..e16f0423c 100644
--- a/packages/slate/test/history/undo/move-node-by-key.js
+++ b/packages/slate/test/history/undo/move-node-by-key.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.moveNodeByKey('b', 'a', 1)
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.moveNodeByKey('b', 'a', 1)
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/remove-mark.js b/packages/slate/test/history/undo/remove-mark.js
index 18a07026f..cc643bc92 100644
--- a/packages/slate/test/history/undo/remove-mark.js
+++ b/packages/slate/test/history/undo/remove-mark.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.removeMark('bold')
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.removeMark('bold')
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/remove-node-by-key.js b/packages/slate/test/history/undo/remove-node-by-key.js
index 1efb03e50..d099bb99e 100644
--- a/packages/slate/test/history/undo/remove-node-by-key.js
+++ b/packages/slate/test/history/undo/remove-node-by-key.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.removeNodeByKey('a')
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.removeNodeByKey('a')
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/remove-text.js b/packages/slate/test/history/undo/remove-text.js
index 3253610cf..695b770e7 100644
--- a/packages/slate/test/history/undo/remove-text.js
+++ b/packages/slate/test/history/undo/remove-text.js
@@ -3,16 +3,12 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change
-      .moveAnchorForward(4)
-      .moveFocusForward(7)
-      .delete()
-  })
+  editor
+    .moveAnchorForward(4)
+    .moveFocusForward(7)
+    .delete()
 
-  editor.change(change => {
-    change.undo()
-  })
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/set-node-by-key-with-data.js b/packages/slate/test/history/undo/set-node-by-key-with-data.js
index bf5ee2a6b..02a97b635 100644
--- a/packages/slate/test/history/undo/set-node-by-key-with-data.js
+++ b/packages/slate/test/history/undo/set-node-by-key-with-data.js
@@ -3,15 +3,11 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.setNodeByKey('a', {
-      data: { thing: 'value' },
-    })
+  editor.setNodeByKey('a', {
+    data: { thing: 'value' },
   })
 
-  editor.change(change => {
-    change.undo()
-  })
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/split-node-by-key-block.js b/packages/slate/test/history/undo/split-node-by-key-block.js
index 508886a42..906a4ded4 100644
--- a/packages/slate/test/history/undo/split-node-by-key-block.js
+++ b/packages/slate/test/history/undo/split-node-by-key-block.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.splitNodeByKey('a', 2)
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.splitNodeByKey('a', 2)
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/unwrap-node-by-key.js b/packages/slate/test/history/undo/unwrap-node-by-key.js
index bb7d7d5c2..62893ea09 100644
--- a/packages/slate/test/history/undo/unwrap-node-by-key.js
+++ b/packages/slate/test/history/undo/unwrap-node-by-key.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.unwrapNodeByKey('a')
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.unwrapNodeByKey('a')
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/history/undo/wrap-inline-across-blocks.js b/packages/slate/test/history/undo/wrap-inline-across-blocks.js
index 4b3000cc9..3338911eb 100644
--- a/packages/slate/test/history/undo/wrap-inline-across-blocks.js
+++ b/packages/slate/test/history/undo/wrap-inline-across-blocks.js
@@ -3,13 +3,8 @@
 import h from '../../helpers/h'
 
 export default function(editor) {
-  editor.change(change => {
-    change.wrapInline('hashtag')
-  })
-
-  editor.change(change => {
-    change.undo()
-  })
+  editor.wrapInline('hashtag')
+  editor.flush().undo()
 }
 
 export const input = (
diff --git a/packages/slate/test/index.js b/packages/slate/test/index.js
index 2a37a268d..f33cc35f2 100644
--- a/packages/slate/test/index.js
+++ b/packages/slate/test/index.js
@@ -91,10 +91,7 @@ describe('slate', () => {
     }
 
     editor.setValue(input)
-
-    editor.change(change => {
-      change.applyOperations(operations)
-    })
+    operations.forEach(op => editor.applyOperation(op))
 
     const actual = editor.value.toJSON(opts)
 
@@ -113,7 +110,7 @@ describe('slate', () => {
     const opts = { preserveSelection: true, ...options }
 
     editor.setValue(input)
-    editor.change(fn)
+    fn(editor)
     const actual = editor.value.toJSON(opts)
 
     editor.setValue(output)
diff --git a/packages/slate/test/schema/custom/child-kind-invalid-custom-optional-first.js b/packages/slate/test/schema/custom/child-kind-invalid-custom-optional-first.js
index 2d5071f56..8434c4da5 100644
--- a/packages/slate/test/schema/custom/child-kind-invalid-custom-optional-first.js
+++ b/packages/slate/test/schema/custom/child-kind-invalid-custom-optional-first.js
@@ -17,11 +17,11 @@ export const schema = {
           min: 1,
         },
       ],
-      normalize: (change, error) => {
+      normalize: (editor, error) => {
         const { code, child } = error
 
         if (code === 'child_object_invalid') {
-          change.wrapBlockByKey(child.key, 'paragraph')
+          editor.wrapBlockByKey(child.key, 'paragraph')
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/child-kind-invalid-custom.js b/packages/slate/test/schema/custom/child-kind-invalid-custom.js
index 5a99d6401..7c213da52 100644
--- a/packages/slate/test/schema/custom/child-kind-invalid-custom.js
+++ b/packages/slate/test/schema/custom/child-kind-invalid-custom.js
@@ -11,9 +11,9 @@ export const schema = {
           match: [{ object: 'block' }],
         },
       ],
-      normalize: (change, { code, child }) => {
+      normalize: (editor, { code, child }) => {
         if (code == 'child_object_invalid') {
-          change.wrapBlockByKey(child.key, 'paragraph')
+          editor.wrapBlockByKey(child.key, 'paragraph')
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/child-required-custom.js b/packages/slate/test/schema/custom/child-required-custom.js
index 24ae25ea7..1b91aad90 100644
--- a/packages/slate/test/schema/custom/child-required-custom.js
+++ b/packages/slate/test/schema/custom/child-required-custom.js
@@ -12,9 +12,9 @@ export const schema = {
           min: 2,
         },
       ],
-      normalize: (change, { code, node, index }) => {
+      normalize: (editor, { code, node, index }) => {
         if (code == 'child_required') {
-          change.insertNodeByKey(node.key, index, {
+          editor.insertNodeByKey(node.key, index, {
             object: 'block',
             type: 'paragraph',
           })
diff --git a/packages/slate/test/schema/custom/child-type-invalid-custom.js b/packages/slate/test/schema/custom/child-type-invalid-custom.js
index d8a204d4b..6d2bdbc6f 100644
--- a/packages/slate/test/schema/custom/child-type-invalid-custom.js
+++ b/packages/slate/test/schema/custom/child-type-invalid-custom.js
@@ -11,9 +11,9 @@ export const schema = {
           match: [{ type: 'paragraph' }],
         },
       ],
-      normalize: (change, { code, child }) => {
+      normalize: (editor, { code, child }) => {
         if (code == 'child_type_invalid') {
-          change.wrapBlockByKey(child.key, 'paragraph')
+          editor.wrapBlockByKey(child.key, 'paragraph')
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/child-unknown-custom.js b/packages/slate/test/schema/custom/child-unknown-custom.js
index a3508a513..ba61aff84 100644
--- a/packages/slate/test/schema/custom/child-unknown-custom.js
+++ b/packages/slate/test/schema/custom/child-unknown-custom.js
@@ -12,16 +12,16 @@ export const schema = {
           max: 1,
         },
       ],
-      normalize: (change, { code, node, child }) => {
+      normalize: (editor, { code, node, child }) => {
         if (code == 'child_unknown') {
           const previous = node.getPreviousSibling(child.key)
           const offset = previous.nodes.size
 
           child.nodes.forEach((n, i) =>
-            change.moveNodeByKey(n.key, previous.key, offset + i)
+            editor.moveNodeByKey(n.key, previous.key, offset + i)
           )
 
-          change.removeNodeByKey(child.key)
+          editor.removeNodeByKey(child.key)
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/first-child-kind-invalid-custom.js b/packages/slate/test/schema/custom/first-child-kind-invalid-custom.js
index 7604b90f4..687555bae 100644
--- a/packages/slate/test/schema/custom/first-child-kind-invalid-custom.js
+++ b/packages/slate/test/schema/custom/first-child-kind-invalid-custom.js
@@ -7,9 +7,9 @@ export const schema = {
     paragraph: {},
     quote: {
       first: [{ object: 'block' }],
-      normalize: (change, { code, child }) => {
+      normalize: (editor, { code, child }) => {
         if (code == 'first_child_object_invalid') {
-          change.wrapBlockByKey(child.key, 'paragraph')
+          editor.wrapBlockByKey(child.key, 'paragraph')
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/first-child-type-invalid-custom.js b/packages/slate/test/schema/custom/first-child-type-invalid-custom.js
index 40bd49406..7ebed2fab 100644
--- a/packages/slate/test/schema/custom/first-child-type-invalid-custom.js
+++ b/packages/slate/test/schema/custom/first-child-type-invalid-custom.js
@@ -7,9 +7,9 @@ export const schema = {
     paragraph: {},
     quote: {
       first: [{ type: 'paragraph' }],
-      normalize: (change, { code, child }) => {
+      normalize: (editor, { code, child }) => {
         if (code == 'first_child_type_invalid') {
-          change.wrapBlockByKey(child.key, 'paragraph')
+          editor.wrapBlockByKey(child.key, 'paragraph')
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/last-child-kind-invalid-custom.js b/packages/slate/test/schema/custom/last-child-kind-invalid-custom.js
index 777d7575a..3083baf2d 100644
--- a/packages/slate/test/schema/custom/last-child-kind-invalid-custom.js
+++ b/packages/slate/test/schema/custom/last-child-kind-invalid-custom.js
@@ -7,9 +7,9 @@ export const schema = {
     paragraph: {},
     quote: {
       last: [{ object: 'block' }],
-      normalize: (change, { code, child }) => {
+      normalize: (editor, { code, child }) => {
         if (code == 'last_child_object_invalid') {
-          change.wrapBlockByKey(child.key, 'paragraph')
+          editor.wrapBlockByKey(child.key, 'paragraph')
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/last-child-type-invalid-custom.js b/packages/slate/test/schema/custom/last-child-type-invalid-custom.js
index 7474a1398..f2aeeed59 100644
--- a/packages/slate/test/schema/custom/last-child-type-invalid-custom.js
+++ b/packages/slate/test/schema/custom/last-child-type-invalid-custom.js
@@ -7,9 +7,9 @@ export const schema = {
     paragraph: {},
     quote: {
       last: [{ type: 'paragraph' }],
-      normalize: (change, { code, child }) => {
+      normalize: (editor, { code, child }) => {
         if (code == 'last_child_type_invalid') {
-          change.wrapBlockByKey(child.key, 'paragraph')
+          editor.wrapBlockByKey(child.key, 'paragraph')
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/next-kind-invalid-custom.js b/packages/slate/test/schema/custom/next-kind-invalid-custom.js
index 96e8efa0c..107acaf9d 100644
--- a/packages/slate/test/schema/custom/next-kind-invalid-custom.js
+++ b/packages/slate/test/schema/custom/next-kind-invalid-custom.js
@@ -6,9 +6,9 @@ export const schema = {
   blocks: {
     image: {
       next: [{ object: 'inline' }, { object: 'text' }],
-      normalize: (change, { code, next }) => {
+      normalize: (editor, { code, next }) => {
         if (code == 'next_sibling_object_invalid') {
-          change.unwrapBlockByKey(next.key, 'paragraph')
+          editor.unwrapBlockByKey(next.key, 'paragraph')
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/next-type-invalid-custom.js b/packages/slate/test/schema/custom/next-type-invalid-custom.js
index bed770c40..6e3903696 100644
--- a/packages/slate/test/schema/custom/next-type-invalid-custom.js
+++ b/packages/slate/test/schema/custom/next-type-invalid-custom.js
@@ -6,9 +6,9 @@ export const schema = {
   blocks: {
     paragraph: {
       next: [{ type: 'paragraph' }],
-      normalize: (change, { code, next }) => {
+      normalize: (editor, { code, next }) => {
         if (code == 'next_sibling_type_invalid') {
-          change.wrapBlockByKey(next.key, 'paragraph')
+          editor.wrapBlockByKey(next.key, 'paragraph')
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/node-data-invalid-custom.js b/packages/slate/test/schema/custom/node-data-invalid-custom.js
index 5e2b7560b..29dc6829d 100644
--- a/packages/slate/test/schema/custom/node-data-invalid-custom.js
+++ b/packages/slate/test/schema/custom/node-data-invalid-custom.js
@@ -8,9 +8,9 @@ export const schema = {
       data: {
         thing: v => v == 'value',
       },
-      normalize: (change, { code, node, key }) => {
+      normalize: (editor, { code, node, key }) => {
         if (code == 'node_data_invalid') {
-          change.setNodeByKey(node.key, { data: { thing: 'value' } })
+          editor.setNodeByKey(node.key, { data: { thing: 'value' } })
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/node-mark-invalid-custom.js b/packages/slate/test/schema/custom/node-mark-invalid-custom.js
index a8fd5047e..8ae745019 100644
--- a/packages/slate/test/schema/custom/node-mark-invalid-custom.js
+++ b/packages/slate/test/schema/custom/node-mark-invalid-custom.js
@@ -6,9 +6,9 @@ export const schema = {
   blocks: {
     paragraph: {
       marks: [{ type: 'bold' }],
-      normalize: (change, { code, node }) => {
+      normalize: (editor, { code, node }) => {
         if (code == 'node_mark_invalid') {
-          node.nodes.forEach(n => change.removeNodeByKey(n.key))
+          node.nodes.forEach(n => editor.removeNodeByKey(n.key))
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/node-text-invalid-custom.js b/packages/slate/test/schema/custom/node-text-invalid-custom.js
index 8874b70db..7b53be394 100644
--- a/packages/slate/test/schema/custom/node-text-invalid-custom.js
+++ b/packages/slate/test/schema/custom/node-text-invalid-custom.js
@@ -6,9 +6,9 @@ export const schema = {
   blocks: {
     paragraph: {
       text: /^\d*$/,
-      normalize: (change, { code, node }) => {
+      normalize: (editor, { code, node }) => {
         if (code == 'node_text_invalid') {
-          node.nodes.forEach(n => change.removeNodeByKey(n.key))
+          node.nodes.forEach(n => editor.removeNodeByKey(n.key))
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/parent-kind-invalid-custom.js b/packages/slate/test/schema/custom/parent-kind-invalid-custom.js
index 4288c5720..c35c4ad7f 100644
--- a/packages/slate/test/schema/custom/parent-kind-invalid-custom.js
+++ b/packages/slate/test/schema/custom/parent-kind-invalid-custom.js
@@ -6,9 +6,9 @@ export const schema = {
   blocks: {
     paragraph: {
       parent: { object: 'document' },
-      normalize: (change, { code, node }) => {
+      normalize: (editor, { code, node }) => {
         if (code == 'parent_object_invalid') {
-          change.unwrapNodeByKey(node.key)
+          editor.unwrapNodeByKey(node.key)
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/parent-type-invalid-custom.js b/packages/slate/test/schema/custom/parent-type-invalid-custom.js
index aa3376f01..f1bdf6fa5 100644
--- a/packages/slate/test/schema/custom/parent-type-invalid-custom.js
+++ b/packages/slate/test/schema/custom/parent-type-invalid-custom.js
@@ -7,9 +7,9 @@ export const schema = {
     list: {},
     item: {
       parent: { type: 'list' },
-      normalize: (change, { code, node }) => {
+      normalize: (editor, { code, node }) => {
         if (code == 'parent_type_invalid') {
-          change.wrapBlockByKey(node.key, 'list')
+          editor.wrapBlockByKey(node.key, 'list')
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/previous-kind-invalid-custom.js b/packages/slate/test/schema/custom/previous-kind-invalid-custom.js
index 55ed0426a..88a49afdc 100644
--- a/packages/slate/test/schema/custom/previous-kind-invalid-custom.js
+++ b/packages/slate/test/schema/custom/previous-kind-invalid-custom.js
@@ -6,9 +6,9 @@ export const schema = {
   blocks: {
     image: {
       previous: [{ object: 'inline' }, { object: 'text' }],
-      normalize: (change, { code, previous }) => {
+      normalize: (editor, { code, previous }) => {
         if (code == 'previous_sibling_object_invalid') {
-          change.unwrapBlockByKey(previous.key, 'paragraph')
+          editor.unwrapBlockByKey(previous.key, 'paragraph')
         }
       },
     },
diff --git a/packages/slate/test/schema/custom/previous-type-invalid-custom.js b/packages/slate/test/schema/custom/previous-type-invalid-custom.js
index 8db09550e..2bd516db6 100644
--- a/packages/slate/test/schema/custom/previous-type-invalid-custom.js
+++ b/packages/slate/test/schema/custom/previous-type-invalid-custom.js
@@ -6,11 +6,11 @@ export const schema = {
   blocks: {
     paragraph: {
       previous: [{ type: 'paragraph' }],
-      normalize: (change, error) => {
+      normalize: (editor, error) => {
         const { code, previous } = error
 
         if (code === 'previous_sibling_type_invalid') {
-          change.wrapBlockByKey(previous.key, 'paragraph')
+          editor.wrapBlockByKey(previous.key, 'paragraph')
         }
       },
     },