From dd66824cd16ee7233245e1c0d4c6df32290e11ed Mon Sep 17 00:00:00 2001
From: djmaze <djmaze@djmaze.lan>
Date: Wed, 9 Sep 2020 18:45:33 +0200
Subject: [PATCH] Added the modified Squire HTML editor

---
 vendors/squire/LICENSE             |   21 +
 vendors/squire/README.md           |  503 ++++
 vendors/squire/build/squire-raw.js | 4521 ++++++++++++++++++++++++++++
 vendors/squire/build/squire.js     |    1 +
 4 files changed, 5046 insertions(+)
 create mode 100644 vendors/squire/LICENSE
 create mode 100644 vendors/squire/README.md
 create mode 100644 vendors/squire/build/squire-raw.js
 create mode 100644 vendors/squire/build/squire.js

diff --git a/vendors/squire/LICENSE b/vendors/squire/LICENSE
new file mode 100644
index 000000000..06cfb7473
--- /dev/null
+++ b/vendors/squire/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2011–2014 by Neil Jenkins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
diff --git a/vendors/squire/README.md b/vendors/squire/README.md
new file mode 100644
index 000000000..5c11d5beb
--- /dev/null
+++ b/vendors/squire/README.md
@@ -0,0 +1,503 @@
+Squire
+======
+
+Squire is an HTML5 rich text editor, which provides powerful cross-browser normalisation in a flexible lightweight package (only 16.5KB of JS after minification and gzip, with no dependencies!).
+
+It was designed to handle email composition for the [Fastmail](https://www.fastmail.com) web app. The most important consequence of this (and where Squire differs from most other modern rich text editors) is that it must handle arbitrary HTML, because it may be used to forward or quote emails from third-parties and must be able to preserve their HTML without breaking the formatting. This means that it can't use a more structured (but limited) internal data model (as most other modern HTML editors do) and the HTML remains the source-of-truth. The other consequence is excellent handling of multiple levels of blockquotes.
+
+Squire was designed to be integrated with your own UI framework, and so does not provide its own UI toolbar, widgets or overlays. Instead, you get a component you can insert in place of a `<textarea>` and manipulate programatically, allowing you to integrate seamlessly with the rest of your application and lose the bloat of having two UI toolkits loaded.
+
+Squire supports all reasonably recent, and even moderately old, browsers (even IE11, although this is not tested much these days).
+
+In addition to its use at [Fastmail](https://www.fastmail.com), it is also currently used in production at [ProtonMail](https://protonmail.com/), [StartMail](https://startmail.com/), [Tutanota](https://tutanota.com), [Zoho Mail](https://www.zoho.com/mail/) and [Superhuman](https://superhuman.com/), as well as other non-mail apps (drop me a line if you're using Squire elsewhere, I'm always interested to hear about it!).
+
+An example UI integration can be tried at http://neilj.github.io/Squire/. Please note though, this is an out-of-date version of Squire and a slightly buggy implementation written by an intern many years ago. For a demo of the latest version with a production-level UI integration, [sign up for a free Fastmail trial](https://www.fastmail.com/signup/) :). There's also a very bare-bones integration in the repo; just clone it and open `Demo.html`. If you are reporting a bug, please report the steps to reproduce using `Demo.html`, to make sure it's not a bug in your integration.
+
+Installation and usage
+----------------------
+
+1. Copy the contents of the `build/` directory onto your server.
+2. Edit the `<style>` block in document.html to add the default styles you
+   would like the editor to use (or link to an external stylesheet).
+3. In your application, instead of a `<textarea>`, use an
+   `<iframe src="path/to/document.html">`.
+4. In your JS, attach an event listener to the [`load` event](https://developer.mozilla.org/en-US/docs/Web/Events/load) of the iframe. When
+   this fires you can grab a reference to the editor object through
+   `iframe.contentWindow.editor`.
+5. Use the API below with the `editor` object to set and get data and integrate
+   with your application or framework.
+
+### Using Squire without an iframe.
+
+Squire can also be used without an iframe for the document. To use it this way:
+
+1. Add a `<script>` tag to load in `build/squire.js` (or `squire-raw.js` for the debuggable unminified version).
+2. Get a reference to the DOM node in the document that you want to make into the rich textarea, e.g. `node = document.getElementById( 'editor-div' )`.
+3. Call `editor = new Squire( node )`. This will instantiate a new Squire instance. Please note, this will remove any current children of the node; you must use the `setHTML` command after initialising to set any content.
+
+You can have multiple squire instances in a single page without issue. If you are using the editor as part of a long lived single-page app, be sure to call `editor.destroy()` once you have finished using an instance to ensure it doesn't leak resources.
+
+### Security
+
+Malicious HTML can be a source of XSS and other security issues. I highly recommended you use [DOMPurify](https://github.com/cure53/DOMPurify) with Squire to prevent these security issues. If DOMPurify is included in the page (with the standard global variable), Squire will automatically sanitise any HTML passed in via `setHTML` or `insertHTML` (which includes HTML the user pastes from the clipboard).
+
+You can override this by setting properties on the config object (the second argument passed to the constructor, see below). The properties are:
+
+* **isSetHTMLSanitized**: `Boolean`
+  Should the HTML passed via calls to `setHTML` be passed to the sanitizer? If your app always sanitizes the HTML in some other way before calling this, you may wish to set this to `false` to avoid the overhead.
+* **isInsertedHTMLSanitized**: `Boolean` (defaults to `true`) – Should the HTML passed via calls to `insertHTML` be passed to the sanitizer? This includes when the user pastes from the clipboard. Since you cannot control what other apps put on the clipboard, it is highly recommended you do not set this to `false`.
+* **sanitizeToDOMFragment**: `(html: String, isPaste: Boolean, self: Squire) -> DOMFragment`
+  A custom sanitization function. This will be called instead of the default call to DOMPurify to sanitize the potentially dangerous HTML. It is passed three arguments: the first is the string of HTML, the second is a boolean indicating if this content has come from the clipboard, rather than an explicit call by your own code, the third is the squire instance. It must return a DOM Fragment node belonging to the same document as the editor's root node, with the contents being clean DOM nodes to set/insert.
+
+Advanced usage
+--------------
+
+Squire provides an engine that handles the heavy work for you, making it easy to add extra features. With the `changeFormat` method you can easily add or remove any inline formatting you wish. And the `modifyBlocks` method can be used to make complicated block-level changes in a relatively easy manner.
+
+If you load the library into a top-level document (rather than an iframe), or load it in an iframe without the `data-squireinit="true"` attribute on its `<html>` element, it will not turn the page into an editable document, but will instead add a constructor named `Squire` to the global scope.
+
+You can also require the NPM package [squire-rte](https://www.npmjs.com/package/squire-rte) to import `Squire` in a modular program without adding names to the global namespace.
+
+Call `new Squire( document )`, with the `document` from an iframe to instantiate multiple rich text areas on the same page efficiently. Note, for compatibility with all browsers (particularly Firefox), you MUST wait for the iframe's `onload` event to fire before instantiating Squire.
+
+If you need more commands than in the simple API, I suggest you check out the source code (it's not very long), and see how a lot of the other API methods are implemented in terms of these two methods.
+
+The general philosophy of Squire is to allow the browser to do as much as it can (which unfortunately is not very much), but take control anywhere it deviates from what is required, or there are significant cross-browser differences. As such, the [`document.execCommand`](https://developer.mozilla.org/en-US/docs/Web/API/Document/execCommand) method is not used at all; instead all formatting is done via custom functions, and certain keys, such as 'enter' and 'backspace' are handled by the editor.
+
+### Setting the default block style
+
+By default, the editor will use a `<div>` for blank lines, as most users have been conditioned by Microsoft Word to expect <kbd>Enter</kbd> to act like pressing <kbd>return</kbd> on a typewriter. If you would like to use `<p>` tags (or anything else) for the default block type instead, you can pass a config object as the second parameter to the squire constructor. You can also
+pass a set of attributes to apply to each default block:
+
+    var editor = new Squire( document, {
+        blockTag: 'P',
+        blockAttributes: { style: 'font-size: 16px;' }
+    })
+
+If using the simple setup, call `editor.setConfig(…);` with your
+config object instead. Be sure to do this *before* calling `editor.setHTML()`.
+
+### Determining button state
+
+If you are adding a UI to Squire, you'll probably want to show a button in different states depending on whether a particular style is active in the current selection or not. For example, a "Bold" button would be in a depressed state if the text under the cursor is already bold.
+
+The efficient way to determine the state for most buttons is to monitor the "pathChange" event in the editor, and determine the state from the new path. If the selection goes across nodes, you will need to call the `hasFormat` method for each of your buttons to determine whether the styles are active. See the `getPath` and `hasFormat` documentation for more information.
+
+License
+-------
+
+Squire is released under the MIT license. See LICENSE for full license.
+
+API
+---
+
+### addEventListener
+
+Attach an event listener to the editor. The handler can be either a function or an object with a `handleEvent` method. This function or method will be called whenever the event fires, with an event object as the sole argument. The following events may be observed:
+
+* **focus**: The editor gained focus.
+* **blur**: The editor lost focus
+* **keydown**: Standard [DOM keydown event](https://developer.mozilla.org/en-US/docs/Web/Events/keydown).
+* **keypress**: Standard [DOM keypress event](https://developer.mozilla.org/en-US/docs/Web/Events/keypress).
+* **keyup**: Standard [DOM keyup event](https://developer.mozilla.org/en-US/docs/Web/Events/keyup).
+* **input**: The user inserted, deleted or changed the style of some text; in other words, the result for `editor.getHTML()` will have changed.
+* **pathChange**: The path (see getPath documentation) to the cursor has changed. The new path is available as the `path` property on the event object.
+* **select**: The user selected some text.
+* **cursor**: The user cleared their selection or moved the cursor to a
+  different position.
+* **undoStateChange**: The availability of undo and/or redo has changed. The event object has two boolean properties, `canUndo` and `canRedo` to let you know the new state.
+* **willPaste**: The user is pasting content into the document. The content that will be inserted is available as either the `fragment` property on the event object, or the `text` property for plain text being inserted into a `<pre>`. You can modify this text/fragment in your event handler to change what will be pasted. You can also call the `preventDefault` on the event object to cancel the paste operation.
+
+The method takes two arguments:
+
+* **type**: The event to listen for. e.g. 'focus'.
+* **handler**: The callback function to invoke
+
+Returns self (the Squire instance).
+
+### removeEventListener
+
+Remove an event listener attached via the addEventListener method.
+
+The method takes two arguments:
+
+* **type**: The event type the handler was registered for.
+* **handler**: The handler to remove.
+
+Returns self (the Squire instance).
+
+### setKeyHandler
+
+Adds or removes a keyboard shortcut. You can use this to override the default keyboard shortcuts (e.g. Ctrl-B for bold – see the bottom of KeyHandlers.js for the list).
+
+This method takes two arguments:
+
+* **key**: The key to handle, including any modifiers in alphabetical order. e.g. `"alt-ctrl-meta-shift-enter"`
+* **fn**: The function to be called when this key is pressed, or `null` if removing a key handler. The function will be passed three arguments when called:
+  * **self**: A reference to the Squire instance.
+  * **event**: The key event object.
+  * **range**: A Range object representing the current selection.
+
+Returns self (the Squire instance).
+
+### focus
+
+Focuses the editor.
+
+The method takes no arguments.
+
+Returns self (the Squire instance).
+
+### blur
+
+Removes focus from the editor.
+
+The method takes no arguments.
+
+Returns self (the Squire instance).
+
+### getDocument
+
+Returns the `document` object of the editable area. May be useful to do transformations outside the realm of the API.
+
+### getHTML
+
+Returns the HTML value of the editor in its current state. This value is equivalent to the contents of the `<body>` tag and does not include any surrounding boilerplate.
+
+### setHTML
+
+Sets the HTML value for the editor. The value supplied should not contain `<body>` tags or anything outside of that.
+
+The method takes one argument:
+
+* **html**: The html to set.
+
+Returns self (the Squire instance).
+
+### getSelectedText
+
+Returns the text currently selected in the editor.
+
+### insertImage
+
+Inserts an image at the current cursor location.
+
+The method takes two arguments:
+
+* **src**: The source path for the image.
+* **attributes**: (optional) An object containing other attributes to set on the `<img>` node. e.g. `{ class: 'class-name' }`. Any `src` attribute will be overwritten by the url given as the first argument.
+
+Returns a reference to the newly inserted image element.
+
+### insertHTML
+
+Inserts an HTML fragment at the current cursor location, or replaces the selection if selected. The value supplied should not contain `<body>` tags or anything outside of that.
+
+The method takes one argument:
+
+* **html**: The html to insert.
+
+Returns self (the Squire instance).
+
+### getPath
+
+Returns the path through the DOM tree from the `<body>` element to the current current cursor position. This is a string consisting of the tag, id, class, font, and color names in CSS format. For example `BODY>BLOCKQUOTE>DIV#id>STRONG>SPAN.font[fontFamily=Arial,sans-serif]>EM`. If a selection has been made, so different parts of the selection may have different paths, the value will be `(selection)`. The path is useful for efficiently determining the current formatting for bold, italic, underline etc, and thus determining button state. If a selection has been made, you can has the `hasFormat` method instead to get the current state for the properties you care about.
+
+### getFontInfo
+
+Returns an object containing the active font family, size, colour and background colour for the the current cursor position, if any are set. The property names are respectively `family`, `size`, `color` and `backgroundColor`. It looks at style attributes to detect this, so will not detect `<FONT>` tags or non-inline styles. If a selection across multiple elements has been made, it will return an empty object.
+
+### createRange
+
+Creates a range in the document belonging to the editor. Takes 4 arguments, matching the [W3C Range properties](https://developer.mozilla.org/en-US/docs/Web/API/Range) they set:
+
+* **startContainer**
+* **startOffset**
+* **endContainer** (optional; if not collapsed)
+* **endOffset** (optional; if not collapsed)
+
+### getCursorPosition
+
+Returns a bounding client rect (top/left/right/bottom properties relative to
+the viewport) for the current selection/cursor.
+
+### getSelection
+
+Returns a [W3C Range object](https://developer.mozilla.org/en-US/docs/Web/API/Range) representing the current selection/cursor position.
+
+### setSelection
+
+Changes the current selection/cursor position.
+
+The method takes one argument:
+
+* **range**: The [W3C Range object](https://developer.mozilla.org/en-US/docs/Web/API/Range) representing the desired selection.
+
+Returns self (the Squire instance).
+
+### moveCursorToStart
+
+Removes any current selection and moves the cursor to the very beginning of the
+document.
+
+Returns self (the Squire instance).
+
+### moveCursorToEnd
+
+Removes any current selection and moves the cursor to the very end of the
+document.
+
+Returns self (the Squire instance).
+
+### saveUndoState
+
+Saves an undo checkpoint with the current editor state. Methods that modify the
+state (e.g. bold/setHighlightColour/modifyBlocks) will automatically save undo
+checkpoints; you only need this method if you want to modify the DOM outside of
+one of these methods, and you want to save an undo checkpoint first.
+
+Returns self (the Squire instance).
+
+### undo
+
+Undoes the most recent change.
+
+Returns self (the Squire instance).
+
+### redo
+
+If the user has just undone a change, this will reapply that change.
+
+Returns self (the Squire instance).
+
+### hasFormat
+
+Queries the editor for whether a particular format is applied anywhere in the current selection.
+
+The method takes two arguments:
+
+* **tag**: The tag of the format
+* **attributes**: (optional) Any attributes the format.
+
+Returns `true` if the entire selection is contained within an element with the specified tag and attributes, otherwise returns `false`.
+
+### bold
+
+Makes any non-bold currently selected text bold (by wrapping it in a `<b>` tag).
+
+Returns self (the Squire instance).
+
+### italic
+
+Makes any non-italic currently selected text italic (by wrapping it in an `<i>` tag).
+
+Returns self (the Squire instance).
+
+### underline
+
+Makes any non-underlined currently selected text underlined (by wrapping it in a `<u>` tag).
+
+Returns self (the Squire instance).
+
+### removeBold
+
+Removes any bold formatting from the selected text.
+
+Returns self (the Squire instance).
+
+### removeItalic
+
+Removes any italic formatting from the selected text.
+
+Returns self (the Squire instance).
+
+### removeUnderline
+
+Removes any underline formatting from the selected text.
+
+Returns self (the Squire instance).
+
+### makeLink
+
+Makes the currently selected text a link. If no text is selected, the URL or email will be inserted as text at the current cursor point and made into a link.
+
+This method takes two arguments:
+
+* **url**: The url or email to link to.
+* **attributes**: (optional) An object containing other attributes to set on the `<a>` node. e.g. `{ target: '_blank' }`. Any `href` attribute will be overwritten by the url given as the first argument.
+
+Returns self (the Squire instance).
+
+### removeLink
+
+Removes any link that is currently at least partially selected.
+
+Returns self (the Squire instance).
+
+### setFontFace
+
+Sets the font face for the selected text.
+
+This method takes one argument:
+
+* **font**: A comma-separated list of fonts (in order of preference) to set.
+
+Returns self (the Squire instance).
+
+### setFontSize
+
+Sets the font size for the selected text.
+
+This method takes one argument:
+
+* **size**: A size to set. Any CSS [length value](https://developer.mozilla.org/en-US/docs/Web/CSS/length) or [absolute-size value](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_values_syntax#syntax-absolute-size) is accepted, e.g. '13px', or 'small'.
+
+Returns self (the Squire instance).
+
+### setTextColour
+
+Sets the colour of the selected text.
+
+This method takes one argument:
+
+* **colour**: The colour to set. Any [CSS colour value](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value) is accepted, e.g. '#f00', or 'hsl(0,0,0)'.
+
+Returns self (the Squire instance).
+
+### setHighlightColour
+
+Sets the colour of the background of the selected text.
+
+This method takes one argument:
+
+* **colour**: The colour to set. Any [CSS colour value](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value) is accepted, e.g. '#f00', or 'hsl(0,0,0)'.
+
+Returns self (the Squire instance).
+
+### setTextAlignment
+
+Sets the text alignment in all blocks at least partially contained by the selection.
+
+This method takes one argument:
+
+* **alignment**: The direction to align to. Can be 'left', 'right', 'center' or 'justify'.
+
+Returns self (the Squire instance).
+
+### setTextDirection
+
+Sets the text direction in all blocks at least partially contained by the selection.
+
+This method takes one argument:
+
+* **direction**: The text direction. Can be 'ltr' or 'rtl'.
+
+Returns self (the Squire instance).
+
+### forEachBlock
+
+Executes a function on each block in the current selection, or until the function returns a truthy value.
+
+This method takes two arguments:
+
+* **fn** The function to execute on each block node at least partially contained in the current selection. The function will be called with the block node as the only argument.
+* **mutates** A boolean indicating whether your function may modify anything in the document in any way.
+
+Returns self (the Squire instance).
+
+### modifyBlocks
+
+Extracts a portion of the DOM tree (up to the block boundaries of the current selection), modifies it and then reinserts it and merges the edges. See the code for examples if you're interested in using this function.
+
+This method takes one argument:
+
+* **modify** The function to apply to the extracted DOM tree; gets a document fragment as a sole argument. `this` is bound to the Squire instance. Should return the node or fragment to be reinserted in the DOM.
+
+Returns self (the Squire instance).
+
+### increaseQuoteLevel
+
+Increases by 1 the quote level (number of `<blockquote>` tags wrapping) all blocks at least partially selected.
+
+Returns self (the Squire instance).
+
+### decreaseQuoteLevel
+
+Decreases by 1 the quote level (number of `<blockquote>` tags wrapping) all blocks at least partially selected.
+
+Returns self (the Squire instance).
+
+### makeUnorderedList
+
+Changes all at-least-partially selected blocks to be part of an unordered list.
+
+Returns self (the Squire instance).
+
+### makeOrderedList
+
+Changes all at-least-partially selected blocks to be part of an ordered list.
+
+Returns self (the Squire instance).
+
+### removeList
+
+Changes any at-least-partially selected blocks which are part of a list to no longer be part of a list.
+
+Returns self (the Squire instance).
+
+### increaseListLevel
+
+Increases by 1 the nesting level of any at-least-partially selected blocks which are part of a list.
+
+Returns self (the Squire instance).
+
+### decreaseListLevel
+
+Decreases by 1 the nesting level of any at-least-partially selected blocks which are part of a list.
+
+Returns self (the Squire instance).
+
+### code
+
+If no selection, or selection across blocks, converts the block to a `<pre>` to format the text as fixed-width. If a selection within a single block is present, wraps that in `<code>` tags for inline formatting instead.
+
+Returns self (the Squire instance).
+
+### removeCode
+
+If inside a `<pre>`, converts that to the default block type instead. Otherwise, removes any `<code>` tags.
+
+Returns self (the Squire instance).
+
+### toggleCode
+
+If inside a `<pre>` or `<code>`, calls `removeCode()`, otherwise callse `code()`.
+
+Returns self (the Squire instance).
+
+### removeAllFormatting
+
+Removes all formatting from the selection. Block elements (list items, table cells, etc.) are kept as separate blocks.
+
+Returns self (the Squire instance).
+
+### changeFormat
+
+Change the **inline** formatting of the current selection. This is a high-level method which is used to implement the bold, italic etc. helper methods. THIS METHOD IS ONLY FOR USE WITH INLINE TAGS, NOT BLOCK TAGS. It takes 4 arguments:
+
+1. An object describing the formatting to add, or `null` if you only wish to remove formatting. If supplied, this object should have a `tag` property with the string name of the tag to wrap around the selected text (e.g. `"STRONG"`) and optionally an `attributes` property, consisting of an object of attributes to apply to the tag (e.g. `{"class": "bold"}`).
+2. An object describing the formatting to remove, in the same format as the object given to add formatting, or `null` if you only wish to add formatting.
+3. A Range object with the range to apply the formatting changes to (or `null`/omit to apply to current selection).
+4. A boolean (defaults to `false` if omitted). If `true`, any formatting nodes that cover at least part of the selected range will be removed entirely (so will potentially be removed from text outside the selected range as well). If `false`, the formatting nodes will continue to apply to any text outside the selection. This is useful, for example, when removing links. If any of the text in the selection is part of a link, the whole link is removed, rather than the link continuing to apply to bits of text outside the selection.
+
+### modifyDocument
+
+Takes in a function that can modify the document without the modifications being treated as input.
+
+This is useful when the document needs to be changed programmatically, but those changes should not raise input events or modify the undo state.
+
+### linkRegExp
+
+This is the regular expression used to automatically mark up links when inserting HTML or after pressing space. You can change it if you want to use a custom regular expression for detecting links, or set to `null` to turn off link detection.
+
+
diff --git a/vendors/squire/build/squire-raw.js b/vendors/squire/build/squire-raw.js
new file mode 100644
index 000000000..3d5997b2d
--- /dev/null
+++ b/vendors/squire/build/squire-raw.js
@@ -0,0 +1,4521 @@
+/* Copyright © 2011-2015 by Neil Jenkins. MIT Licensed. */
+/* eslint max-len: 0 */
+
+( doc => {
+
+"use strict";
+
+const
+	DOCUMENT_POSITION_PRECEDING = 2, // Node.DOCUMENT_POSITION_PRECEDING
+	ELEMENT_NODE = 1,                // Node.ELEMENT_NODE,
+	TEXT_NODE = 3,                   // Node.TEXT_NODE,
+	DOCUMENT_NODE = 9,               // Node.DOCUMENT_NODE,
+	DOCUMENT_FRAGMENT_NODE = 11,     // Node.DOCUMENT_FRAGMENT_NODE,
+	SHOW_ELEMENT = 1,                // NodeFilter.SHOW_ELEMENT,
+	SHOW_TEXT = 4,                   // NodeFilter.SHOW_TEXT,
+
+	START_TO_START = 0, // Range.START_TO_START
+	START_TO_END = 1,   // Range.START_TO_END
+	END_TO_END = 2,     // Range.END_TO_END
+	END_TO_START = 3,   // Range.END_TO_START
+
+	ZWS = '\u200B',
+	NBSP = '\u00A0',
+
+	win = doc.defaultView,
+
+	ua = navigator.userAgent,
+
+	isMac = /Mac OS X/.test( ua ),
+	isWin = /Windows NT/.test( ua ),
+	isIOS = /iP(?:ad|hone|od)/.test( ua ) ||
+	( isMac && !!navigator.maxTouchPoints ),
+
+	isGecko = /Gecko\//.test( ua ),
+	isEdge = /Edge\//.test( ua ),
+	isWebKit = !isEdge && /WebKit\//.test( ua ),
+
+	ctrlKey = isMac ? 'meta-' : 'ctrl-',
+	osKey = isMac ? 'metaKey' : 'ctrlKey',
+
+	// Use [^ \t\r\n] instead of \S so that nbsp does not count as white-space
+	notWS = /[^ \t\r\n]/,
+
+	indexOf = (array, value) => Array.prototype.indexOf.call(array, value),
+
+	typeToBitArray = {
+		// ELEMENT_NODE
+		1: 1,
+		// ATTRIBUTE_NODE
+		2: 2,
+		// TEXT_NODE
+		3: 4,
+		// COMMENT_NODE
+		8: 128,
+		// DOCUMENT_NODE
+		9: 256,
+		// DOCUMENT_FRAGMENT_NODE
+		11: 1024
+	},
+
+//	blockElementNames = /^(?:ADDRESS|ARTICLE|ASIDE|BLOCKQUOTE|CANVAS|DETAILS|DIALOG|DIV|D[DLT]|FIELDSET|FIG(CAPTION|URE)|FOOTER|FORM|H[1-6]|HEADER|HGROUP|HR|LI|MAIN|NAV|OL|P|PRE|SECTION|TABLE|UL|VIDEO)$/,
+	inlineNodeNames = /^(?:#text|A|ABBR|ACRONYM|B|BR|BDI|BDO|CITE|CODE|DATA|DEL|DFN|EM|FONT|HR|IMG|INPUT|INS|KBD|Q|RP|RT|RUBY|SAMP|SMALL|SPAN|STRIKE|STRONG|SUB|SUP|TIME|U|VAR|WBR)$/,
+
+	leafNodeNames = {
+		BR: 1,
+		HR: 1,
+		IMG: 1
+	},
+
+	UNKNOWN = 0,
+	INLINE = 1,
+	BLOCK = 2,
+	CONTAINER = 3,
+
+	isLeaf = node => node.nodeType === ELEMENT_NODE && !!leafNodeNames[ node.nodeName ],
+
+	getNodeCategory = node => {
+		switch ( node.nodeType ) {
+		case TEXT_NODE:
+			return INLINE;
+		case ELEMENT_NODE:
+		case DOCUMENT_FRAGMENT_NODE:
+			if ( nodeCategoryCache.has( node ) ) {
+				return nodeCategoryCache.get( node );
+			}
+			break;
+		default:
+			return UNKNOWN;
+		}
+
+		let nodeCategory;
+		if ( !Array.prototype.every.call( node.childNodes, isInline ) ) {
+			// Malformed HTML can have block tags inside inline tags. Need to treat
+			// these as containers rather than inline. See #239.
+			nodeCategory = CONTAINER;
+		} else if ( inlineNodeNames.test( node.nodeName ) ) {
+			nodeCategory = INLINE;
+		} else /*if ( blockElementNames.test( node.nodeName ) )*/ {
+			nodeCategory = BLOCK;
+		}
+		nodeCategoryCache.set( node, nodeCategory );
+		return nodeCategory;
+	},
+	isInline = node => getNodeCategory( node ) === INLINE,
+	isBlock = node => getNodeCategory( node ) === BLOCK,
+	isContainer = node => getNodeCategory( node ) === CONTAINER,
+	getBlockWalker = ( node, root ) => {
+		let walker = doc.createTreeWalker( root, SHOW_ELEMENT, isBlock );
+		walker.currentNode = node;
+		return walker;
+	},
+	getPreviousBlock = ( node, root ) => {
+		node = getBlockWalker( node, root ).previousNode();
+		return node !== root ? node : null;
+	},
+	getNextBlock = ( node, root ) => {
+		node = getBlockWalker( node, root ).nextNode();
+		return node !== root ? node : null;
+	},
+
+	isEmptyBlock = block => !block.textContent && !block.querySelector( 'IMG' ),
+
+	areAlike = ( node, node2 ) => {
+		return !isLeaf( node ) && (
+			node.nodeType === node2.nodeType &&
+			node.nodeName === node2.nodeName &&
+			node.nodeName !== 'A' &&
+			node.className === node2.className &&
+			( ( !node.style && !node2.style ) ||
+			  node.style.cssText === node2.style.cssText )
+		);
+	},
+	hasTagAttributes = ( node, tag, attributes ) => {
+		if ( node.nodeName !== tag ) {
+			return false;
+		}
+		for ( let attr in attributes ) {
+			if ( node.getAttribute( attr ) !== attributes[ attr ] ) {
+				return false;
+			}
+		}
+		return true;
+	},
+	getClosest = ( node, root, selector ) => {
+		node = (!node || node.closest ? node : node.parentElement);
+		node = node && node.closest(selector);
+		return (node && root.contains(node)) ? node : null;
+	},
+	getNearest = ( node, root, tag, attributes ) => {
+		while ( node && node !== root ) {
+			if ( hasTagAttributes( node, tag, attributes ) ) {
+				return node;
+			}
+			node = node.parentNode;
+		}
+		return null;
+	},
+
+	getPath = ( node, root, config ) => {
+		let path = '';
+		let id, className, classNames, dir, styleNames;
+		if ( node && node !== root ) {
+			path = getPath( node.parentNode, root, config );
+			if ( node.nodeType === ELEMENT_NODE ) {
+				path += ( path ? '>' : '' ) + node.nodeName;
+				if ( id = node.id ) {
+					path += '#' + id;
+				}
+				if ( className = node.className.trim() ) {
+					classNames = className.split( /\s+/ );
+					classNames.sort();
+					path += '.';
+					path += classNames.join( '.' );
+				}
+				if ( dir = node.dir ) {
+					path += '[dir=' + dir + ']';
+				}
+				if ( classNames ) {
+					styleNames = config.classNames;
+					if ( indexOf( classNames, styleNames.highlight ) > -1 ) {
+						path += '[backgroundColor=' +
+							node.style.backgroundColor.replace( / /g,'' ) + ']';
+					}
+					if ( indexOf( classNames, styleNames.colour ) > -1 ) {
+						path += '[color=' +
+							node.style.color.replace( / /g,'' ) + ']';
+					}
+					if ( indexOf( classNames, styleNames.fontFamily ) > -1 ) {
+						path += '[fontFamily=' +
+							node.style.fontFamily.replace( / /g,'' ) + ']';
+					}
+					if ( indexOf( classNames, styleNames.fontSize ) > -1 ) {
+						path += '[fontSize=' + node.style.fontSize + ']';
+					}
+				}
+			}
+		}
+		return path;
+	},
+
+	getLength = node => {
+		let nodeType = node.nodeType;
+		return nodeType === ELEMENT_NODE || nodeType === DOCUMENT_FRAGMENT_NODE ?
+			node.childNodes.length : node.length || 0;
+	},
+
+	empty = node => {
+		let frag = doc.createDocumentFragment(),
+			childNodes = node.childNodes;
+		childNodes && frag.append( ...childNodes );
+		return frag;
+	},
+
+	createElement = ( doc, tag, props, children ) => {
+		let el = doc.createElement( tag ),
+			attr, value;
+		if ( props instanceof Array ) {
+			children = props;
+			props = null;
+		}
+		if ( props ) {
+			for ( attr in props ) {
+				value = props[ attr ];
+				if ( value !== undefined ) {
+					el.setAttribute( attr, value );
+				}
+			}
+		}
+		children && el.append( ...children );
+		return el;
+	},
+
+	fixCursor = ( node, root ) => {
+		// In Webkit and Gecko, block level elements are collapsed and
+		// unfocusable if they have no content. To remedy this, a <BR> must be
+		// inserted. In Opera and IE, we just need a textnode in order for the
+		// cursor to appear.
+		let self = root.__squire__;
+		let originalNode = node;
+		let fixer, child;
+
+		if ( node === root ) {
+			if ( !( child = node.firstChild ) || child.nodeName === 'BR' ) {
+				fixer = self.createDefaultBlock();
+				if ( child ) {
+					child.replaceWith( fixer );
+				}
+				else {
+					node.append( fixer );
+				}
+				node = fixer;
+				fixer = null;
+			}
+		}
+
+		if ( node.nodeType === TEXT_NODE ) {
+			return originalNode;
+		}
+
+		if ( isInline( node ) ) {
+			child = node.firstChild;
+			while ( isWebKit && child &&
+					child.nodeType === TEXT_NODE && !child.data ) {
+				node.removeChild( child );
+				child = node.firstChild;
+			}
+			if ( !child ) {
+				if ( isWebKit ) {
+					fixer = doc.createTextNode( ZWS );
+					self._didAddZWS();
+				} else {
+					fixer = doc.createTextNode( '' );
+				}
+			}
+		} else if ( !node.querySelector( 'BR' ) ) {
+			fixer = createElement( doc, 'BR' );
+			while ( ( child = node.lastElementChild ) && !isInline( child ) ) {
+				node = child;
+			}
+		}
+		if ( fixer ) {
+			try {
+				node.append( fixer );
+			} catch ( error ) {
+				self.didError({
+					name: 'Squire: fixCursor – ' + error,
+					message: 'Parent: ' + node.nodeName + '/' + node.innerHTML +
+						' appendChild: ' + fixer.nodeName
+				});
+			}
+		}
+
+		return originalNode;
+	},
+
+	// Recursively examine container nodes and wrap any inline children.
+	fixContainer = ( container, root ) => {
+		let children = container.childNodes;
+		let wrapper = null;
+		let i, l, child, isBR;
+
+		for ( i = 0, l = children.length; i < l; ++i ) {
+			child = children[i];
+			isBR = child.nodeName === 'BR';
+			if ( !isBR && isInline( child ) ) {
+				if ( !wrapper ) {
+					 wrapper = createElement( doc, 'div' );
+				}
+				wrapper.append( child );
+				--i;
+				--l;
+			} else if ( isBR || wrapper ) {
+				if ( !wrapper ) {
+					wrapper = createElement( doc, 'div' );
+				}
+				fixCursor( wrapper, root );
+				if ( isBR ) {
+					child.replaceWith( wrapper );
+				} else {
+					child.before( wrapper  );
+					++i;
+					++l;
+				}
+				wrapper = null;
+			}
+			if ( isContainer( child ) ) {
+				fixContainer( child, root );
+			}
+		}
+		if ( wrapper ) {
+			container.append( fixCursor( wrapper, root ) );
+		}
+		return container;
+	},
+
+	split = ( node, offset, stopNode, root ) => {
+		let nodeType = node.nodeType,
+			parent, clone, next;
+		if ( nodeType === TEXT_NODE && node !== stopNode ) {
+			return split(
+				node.parentNode, node.splitText( offset ), stopNode, root );
+		}
+		if ( nodeType === ELEMENT_NODE ) {
+			if ( typeof( offset ) === 'number' ) {
+				offset = offset < node.childNodes.length ?
+					node.childNodes[ offset ] : null;
+			}
+			if ( node === stopNode ) {
+				return offset;
+			}
+
+			// Clone node without children
+			parent = node.parentNode;
+			clone = node.cloneNode( false );
+
+			// Add right-hand siblings to the clone
+			while ( offset ) {
+				next = offset.nextSibling;
+				clone.append( offset );
+				offset = next;
+			}
+
+			// Maintain li numbering if inside a quote.
+			if ( node.nodeName === 'OL' &&
+					getClosest( node, root, 'BLOCKQUOTE' ) ) {
+				clone.start = ( +node.start || 1 ) + node.childNodes.length - 1;
+			}
+
+			// DO NOT NORMALISE. This may undo the fixCursor() call
+			// of a node lower down the tree!
+
+			// We need something in the element in order for the cursor to appear.
+			fixCursor( node, root );
+			fixCursor( clone, root );
+
+			// Inject clone after original node
+			node.after( clone );
+
+			// Keep on splitting up the tree
+			return split( parent, clone, stopNode, root );
+		}
+		return offset;
+	},
+
+	_mergeInlines = ( node, fakeRange ) => {
+		let children = node.childNodes,
+			l = children.length,
+			frags = [],
+			child, prev;
+		while ( l-- ) {
+			child = children[l];
+			prev = l && children[ l - 1 ];
+			if ( l && isInline( child ) && areAlike( child, prev ) &&
+					!leafNodeNames[ child.nodeName ] ) {
+				if ( fakeRange.startContainer === child ) {
+					fakeRange.startContainer = prev;
+					fakeRange.startOffset += getLength( prev );
+				}
+				if ( fakeRange.endContainer === child ) {
+					fakeRange.endContainer = prev;
+					fakeRange.endOffset += getLength( prev );
+				}
+				if ( fakeRange.startContainer === node ) {
+					if ( fakeRange.startOffset > l ) {
+						--fakeRange.startOffset;
+					}
+					else if ( fakeRange.startOffset === l ) {
+						fakeRange.startContainer = prev;
+						fakeRange.startOffset = getLength( prev );
+					}
+				}
+				if ( fakeRange.endContainer === node ) {
+					if ( fakeRange.endOffset > l ) {
+						--fakeRange.endOffset;
+					}
+					else if ( fakeRange.endOffset === l ) {
+						fakeRange.endContainer = prev;
+						fakeRange.endOffset = getLength( prev );
+					}
+				}
+				child.remove();
+				if ( child.nodeType === TEXT_NODE ) {
+					prev.appendData( child.data );
+				}
+				else {
+					frags.push( empty( child ) );
+				}
+			}
+			else if ( child.nodeType === ELEMENT_NODE ) {
+				child.append(...frags.reverse());
+				frags = [];
+				_mergeInlines( child, fakeRange );
+			}
+		}
+	},
+
+	mergeInlines = ( node, range ) => {
+		if ( node.nodeType === TEXT_NODE ) {
+			node = node.parentNode;
+		}
+		if ( node.nodeType === ELEMENT_NODE ) {
+			let fakeRange = {
+				startContainer: range.startContainer,
+				startOffset: range.startOffset,
+				endContainer: range.endContainer,
+				endOffset: range.endOffset
+			};
+			_mergeInlines( node, fakeRange );
+			range.setStart( fakeRange.startContainer, fakeRange.startOffset );
+			range.setEnd( fakeRange.endContainer, fakeRange.endOffset );
+		}
+	},
+
+	mergeWithBlock = ( block, next, range, root ) => {
+		let container = next;
+		let parent, last, offset;
+		while ( ( parent = container.parentNode ) &&
+				parent !== root &&
+				parent.nodeType === ELEMENT_NODE &&
+				parent.childNodes.length === 1 ) {
+			container = parent;
+		}
+		container.remove();
+
+		offset = block.childNodes.length;
+
+		// Remove extra <BR> fixer if present.
+		last = block.lastChild;
+		if ( last && last.nodeName === 'BR' ) {
+			block.removeChild( last );
+			--offset;
+		}
+
+		block.append( empty( next ) );
+
+		range.setStart( block, offset );
+		range.collapse( true );
+		mergeInlines( block, range );
+	},
+
+	mergeContainers = ( node, root ) => {
+		let prev = node.previousSibling,
+			first = node.firstChild,
+			isListItem = ( node.nodeName === 'LI' ),
+			needsFix, block;
+
+		// Do not merge LIs, unless it only contains a UL
+		if ( isListItem && ( !first || !/^[OU]L$/.test( first.nodeName ) ) ) {
+			return;
+		}
+
+		if ( prev && areAlike( prev, node ) ) {
+			if ( !isContainer( prev ) ) {
+				if ( isListItem ) {
+					block = createElement( doc, 'DIV' );
+					block.append( empty( prev ) );
+					prev.append( block );
+				} else {
+					return;
+				}
+			}
+			node.remove();
+			needsFix = !isContainer( node );
+			prev.append( empty( node ) );
+			if ( needsFix ) {
+				fixContainer( prev, root );
+			}
+			if ( first ) {
+				mergeContainers( first, root );
+			}
+		} else if ( isListItem ) {
+			prev = createElement( doc, 'DIV' );
+			first.before( prev );
+			fixCursor( prev, root );
+		}
+	},
+
+	getNodeBefore = ( node, offset ) => {
+		let children = node.childNodes;
+		while ( offset && node.nodeType === ELEMENT_NODE ) {
+			node = children[ offset - 1 ];
+			children = node.childNodes;
+			offset = children.length;
+		}
+		return node;
+	},
+
+	getNodeAfter = ( node, offset ) => {
+		if ( node.nodeType === ELEMENT_NODE ) {
+			let children = node.childNodes;
+			if ( offset < children.length ) {
+				node = children[ offset ];
+			} else {
+				while ( node && !node.nextSibling ) {
+					node = node.parentNode;
+				}
+				if ( node ) { node = node.nextSibling; }
+			}
+		}
+		return node;
+	},
+
+	insertNodeInRange = ( range, node ) => {
+		// Insert at start.
+		let startContainer = range.startContainer,
+			startOffset = range.startOffset,
+			endContainer = range.endContainer,
+			endOffset = range.endOffset,
+			parent, children, childCount, afterSplit;
+
+		// If part way through a text node, split it.
+		if ( startContainer.nodeType === TEXT_NODE ) {
+			parent = startContainer.parentNode;
+			children = parent.childNodes;
+			if ( startOffset === startContainer.length ) {
+				startOffset = indexOf( children, startContainer ) + 1;
+				if ( range.collapsed ) {
+					endContainer = parent;
+					endOffset = startOffset;
+				}
+			} else {
+				if ( startOffset ) {
+					afterSplit = startContainer.splitText( startOffset );
+					if ( endContainer === startContainer ) {
+						endOffset -= startOffset;
+						endContainer = afterSplit;
+					}
+					else if ( endContainer === parent ) {
+						++endOffset;
+					}
+					startContainer = afterSplit;
+				}
+				startOffset = indexOf( children, startContainer );
+			}
+			startContainer = parent;
+		} else {
+			children = startContainer.childNodes;
+		}
+
+		childCount = children.length;
+
+		if ( startOffset === childCount ) {
+			startContainer.append( node );
+		} else {
+			children[ startOffset ].before( node );
+		}
+
+		if ( startContainer === endContainer ) {
+			endOffset += children.length - childCount;
+		}
+
+		range.setStart( startContainer, startOffset );
+		range.setEnd( endContainer, endOffset );
+	},
+
+	extractContentsOfRange = ( range, common, root ) => {
+		let startContainer = range.startContainer,
+			startOffset = range.startOffset,
+			endContainer = range.endContainer,
+			endOffset = range.endOffset;
+
+		if ( !common ) {
+			common = range.commonAncestorContainer;
+		}
+
+		if ( common.nodeType === TEXT_NODE ) {
+			common = common.parentNode;
+		}
+
+		let endNode = split( endContainer, endOffset, common, root ),
+			startNode = split( startContainer, startOffset, common, root ),
+			frag = doc.createDocumentFragment(),
+			next, before, after, beforeText, afterText;
+
+		// End node will be null if at end of child nodes list.
+		while ( startNode !== endNode ) {
+			next = startNode.nextSibling;
+			frag.append( startNode );
+			startNode = next;
+		}
+
+		startContainer = common;
+		startOffset = endNode ?
+			indexOf( common.childNodes, endNode ) :
+			common.childNodes.length;
+
+		// Merge text nodes if adjacent. IE10 in particular will not focus
+		// between two text nodes
+		after = common.childNodes[ startOffset ];
+		before = after && after.previousSibling;
+		if ( before &&
+				before.nodeType === TEXT_NODE &&
+				after.nodeType === TEXT_NODE ) {
+			startContainer = before;
+			startOffset = before.length;
+			beforeText = before.data;
+			afterText = after.data;
+
+			// If we now have two adjacent spaces, the second one needs to become
+			// a nbsp, otherwise the browser will swallow it due to HTML whitespace
+			// collapsing.
+			if ( beforeText.charAt( beforeText.length - 1 ) === ' ' &&
+					afterText.charAt( 0 ) === ' ' ) {
+				afterText = NBSP + afterText.slice( 1 ); // nbsp
+			}
+			before.appendData( afterText );
+			after.remove();
+		}
+
+		range.setStart( startContainer, startOffset );
+		range.collapse( true );
+
+		fixCursor( common, root );
+
+		return frag;
+	},
+
+	deleteContentsOfRange = ( range, root ) => {
+		let startBlock = getStartBlockOfRange( range, root );
+		let endBlock = getEndBlockOfRange( range, root );
+		let needsMerge = ( startBlock !== endBlock );
+		let frag, child;
+
+		// Move boundaries up as much as possible without exiting block,
+		// to reduce need to split.
+		moveRangeBoundariesDownTree( range );
+		moveRangeBoundariesUpTree( range, startBlock, endBlock, root );
+
+		// Remove selected range
+		frag = extractContentsOfRange( range, null, root );
+
+		// Move boundaries back down tree as far as possible.
+		moveRangeBoundariesDownTree( range );
+
+		// If we split into two different blocks, merge the blocks.
+		if ( needsMerge ) {
+			// endBlock will have been split, so need to refetch
+			endBlock = getEndBlockOfRange( range, root );
+			if ( startBlock && endBlock && startBlock !== endBlock ) {
+				mergeWithBlock( startBlock, endBlock, range, root );
+			}
+		}
+
+		// Ensure block has necessary children
+		if ( startBlock ) {
+			fixCursor( startBlock, root );
+		}
+
+		// Ensure root has a block-level element in it.
+		child = root.firstChild;
+		if ( !child || child.nodeName === 'BR' ) {
+			fixCursor( root, root );
+			range.selectNodeContents( root.firstChild );
+		} else {
+			range.collapse( true );
+		}
+		return frag;
+	},
+
+	// Contents of range will be deleted.
+	// After method, range will be around inserted content
+	insertTreeFragmentIntoRange = ( range, frag, root ) => {
+		let firstInFragIsInline = frag.firstChild && isInline( frag.firstChild );
+		let node, block, blockContentsAfterSplit, stopPoint, container, offset;
+		let replaceBlock, firstBlockInFrag, nodeAfterSplit, nodeBeforeSplit;
+		let tempRange;
+
+		// Fixup content: ensure no top-level inline, and add cursor fix elements.
+		fixContainer( frag, root );
+		node = frag;
+		while ( ( node = getNextBlock( node, root ) ) ) {
+			fixCursor( node, root );
+		}
+
+		// Delete any selected content.
+		if ( !range.collapsed ) {
+			deleteContentsOfRange( range, root );
+		}
+
+		// Move range down into text nodes.
+		moveRangeBoundariesDownTree( range );
+		range.collapse( false ); // collapse to end
+
+		// Where will we split up to? First blockquote parent, otherwise root.
+		stopPoint = getClosest( range.endContainer, root, 'BLOCKQUOTE' ) || root;
+
+		// Merge the contents of the first block in the frag with the focused block.
+		// If there are contents in the block after the focus point, collect this
+		// up to insert in the last block later. This preserves the style that was
+		// present in this bit of the page.
+		//
+		// If the block being inserted into is empty though, replace it instead of
+		// merging if the fragment had block contents.
+		// e.g. <blockquote><p>Foo</p></blockquote>
+		// This seems a reasonable approximation of user intent.
+
+		block = getStartBlockOfRange( range, root );
+		firstBlockInFrag = getNextBlock( frag, frag );
+		replaceBlock = !firstInFragIsInline && !!block && isEmptyBlock( block );
+		if ( block && firstBlockInFrag && !replaceBlock &&
+				// Don't merge table cells or PRE elements into block
+				!getClosest( firstBlockInFrag, frag, 'PRE,TABLE' ) ) {
+			moveRangeBoundariesUpTree( range, block, block, root );
+			range.collapse( true ); // collapse to start
+			container = range.endContainer;
+			offset = range.endOffset;
+			// Remove trailing <br> – we don't want this considered content to be
+			// inserted again later
+			cleanupBRs( block, root, false );
+			if ( isInline( container ) ) {
+				// Split up to block parent.
+				nodeAfterSplit = split(
+					container, offset, getPreviousBlock( container, root ), root );
+				container = nodeAfterSplit.parentNode;
+				offset = indexOf( container.childNodes, nodeAfterSplit );
+			}
+			if ( /*isBlock( container ) && */offset !== getLength( container ) ) {
+				// Collect any inline contents of the block after the range point
+				blockContentsAfterSplit = doc.createDocumentFragment();
+				while ( ( node = container.childNodes[ offset ] ) ) {
+					blockContentsAfterSplit.append( node );
+				}
+			}
+			// And merge the first block in.
+			mergeWithBlock( container, firstBlockInFrag, range, root );
+
+			// And where we will insert
+			offset = indexOf( container.parentNode.childNodes, container ) + 1;
+			container = container.parentNode;
+			range.setEnd( container, offset );
+		}
+
+		// Is there still any content in the fragment?
+		if ( getLength( frag ) ) {
+			if ( replaceBlock ) {
+				range.setEndBefore( block );
+				range.collapse( false );
+				block.remove();
+			}
+			moveRangeBoundariesUpTree( range, stopPoint, stopPoint, root );
+			// Now split after block up to blockquote (if a parent) or root
+			nodeAfterSplit = split(
+				range.endContainer, range.endOffset, stopPoint, root );
+			nodeBeforeSplit = nodeAfterSplit ?
+				nodeAfterSplit.previousSibling :
+				stopPoint.lastChild;
+			nodeAfterSplit.before( frag  );
+			if ( nodeAfterSplit ) {
+				range.setEndBefore( nodeAfterSplit );
+			} else {
+				range.setEnd( stopPoint, getLength( stopPoint ) );
+			}
+			block = getEndBlockOfRange( range, root );
+
+			// Get a reference that won't be invalidated if we merge containers.
+			moveRangeBoundariesDownTree( range );
+			container = range.endContainer;
+			offset = range.endOffset;
+
+			// Merge inserted containers with edges of split
+			if ( nodeAfterSplit && isContainer( nodeAfterSplit ) ) {
+				mergeContainers( nodeAfterSplit, root );
+			}
+			nodeAfterSplit = nodeBeforeSplit && nodeBeforeSplit.nextSibling;
+			if ( nodeAfterSplit && isContainer( nodeAfterSplit ) ) {
+				mergeContainers( nodeAfterSplit, root );
+			}
+			range.setEnd( container, offset );
+		}
+
+		// Insert inline content saved from before.
+		if ( blockContentsAfterSplit ) {
+			tempRange = range.cloneRange();
+			mergeWithBlock( block, blockContentsAfterSplit, tempRange, root );
+			range.setEnd( tempRange.endContainer, tempRange.endOffset );
+		}
+		moveRangeBoundariesDownTree( range );
+	},
+
+	isNodeContainedInRange = ( range, node, partial ) => {
+		let nodeRange = doc.createRange();
+
+		nodeRange.selectNode( node );
+
+		if ( partial ) {
+			// Node must not finish before range starts or start after range
+			// finishes.
+			let nodeEndBeforeStart = ( range.compareBoundaryPoints(
+					END_TO_START, nodeRange ) > -1 ),
+				nodeStartAfterEnd = ( range.compareBoundaryPoints(
+					START_TO_END, nodeRange ) < 1 );
+			return ( !nodeEndBeforeStart && !nodeStartAfterEnd );
+		}
+		else {
+			// Node must start after range starts and finish before range
+			// finishes
+			let nodeStartAfterStart = ( range.compareBoundaryPoints(
+					START_TO_START, nodeRange ) < 1 ),
+				nodeEndBeforeEnd = ( range.compareBoundaryPoints(
+					END_TO_END, nodeRange ) > -1 );
+			return ( nodeStartAfterStart && nodeEndBeforeEnd );
+		}
+	},
+
+	moveRangeBoundariesDownTree = range => {
+		let startContainer = range.startContainer,
+			startOffset = range.startOffset,
+			endContainer = range.endContainer,
+			endOffset = range.endOffset,
+			maySkipBR = true,
+			child;
+
+		while ( startContainer.nodeType !== TEXT_NODE ) {
+			child = startContainer.childNodes[ startOffset ];
+			if ( !child || isLeaf( child ) ) {
+				break;
+			}
+			startContainer = child;
+			startOffset = 0;
+		}
+		if ( endOffset ) {
+			while ( endContainer.nodeType !== TEXT_NODE ) {
+				child = endContainer.childNodes[ endOffset - 1 ];
+				if ( !child || isLeaf( child ) ) {
+					if ( maySkipBR && child && child.nodeName === 'BR' ) {
+						--endOffset;
+						maySkipBR = false;
+						continue;
+					}
+					break;
+				}
+				endContainer = child;
+				endOffset = getLength( endContainer );
+			}
+		} else {
+			while ( endContainer.nodeType !== TEXT_NODE ) {
+				child = endContainer.firstChild;
+				if ( !child || isLeaf( child ) ) {
+					break;
+				}
+				endContainer = child;
+			}
+		}
+
+		// If collapsed, this algorithm finds the nearest text node positions
+		// *outside* the range rather than inside, but also it flips which is
+		// assigned to which.
+		if ( range.collapsed ) {
+			range.setStart( endContainer, endOffset );
+			range.setEnd( startContainer, startOffset );
+		} else {
+			range.setStart( startContainer, startOffset );
+			range.setEnd( endContainer, endOffset );
+		}
+	},
+
+	moveRangeBoundariesUpTree = ( range, startMax, endMax, root ) => {
+		let startContainer = range.startContainer;
+		let startOffset = range.startOffset;
+		let endContainer = range.endContainer;
+		let endOffset = range.endOffset;
+		let maySkipBR = true;
+		let parent;
+
+		if ( !startMax ) {
+			startMax = range.commonAncestorContainer;
+		}
+		if ( !endMax ) {
+			endMax = startMax;
+		}
+
+		while ( !startOffset &&
+				startContainer !== startMax &&
+				startContainer !== root ) {
+			parent = startContainer.parentNode;
+			startOffset = indexOf( parent.childNodes, startContainer );
+			startContainer = parent;
+		}
+
+		while ( true ) {
+			if ( endContainer === endMax || endContainer === root ) {
+				break;
+			}
+			if ( maySkipBR &&
+					endContainer.nodeType !== TEXT_NODE &&
+					endContainer.childNodes[ endOffset ] &&
+					endContainer.childNodes[ endOffset ].nodeName === 'BR' ) {
+				++endOffset;
+				maySkipBR = false;
+			}
+			if ( endOffset !== getLength( endContainer ) ) {
+				break;
+			}
+			parent = endContainer.parentNode;
+			endOffset = indexOf( parent.childNodes, endContainer ) + 1;
+			endContainer = parent;
+		}
+
+		range.setStart( startContainer, startOffset );
+		range.setEnd( endContainer, endOffset );
+	},
+
+	moveRangeBoundaryOutOf = ( range, nodeName, root ) => {
+		let parent = getClosest( range.endContainer, root, 'A' );
+		if ( parent ) {
+			let clone = range.cloneRange();
+			parent = parent.parentNode;
+			moveRangeBoundariesUpTree( clone, parent, parent, root );
+			if ( clone.endContainer === parent ) {
+				range.setStart( clone.endContainer, clone.endOffset );
+				range.setEnd( clone.endContainer, clone.endOffset );
+			}
+		}
+		return range;
+	},
+
+	// Returns the first block at least partially contained by the range,
+	// or null if no block is contained by the range.
+	getStartBlockOfRange = ( range, root ) => {
+		let container = range.startContainer,
+			block;
+
+		// If inline, get the containing block.
+		if ( isInline( container ) ) {
+			block = getPreviousBlock( container, root );
+		} else if ( container !== root && isBlock( container ) ) {
+			block = container;
+		} else {
+			block = getNodeBefore( container, range.startOffset );
+			block = getNextBlock( block, root );
+		}
+		// Check the block actually intersects the range
+		return block && isNodeContainedInRange( range, block, true ) ? block : null;
+	},
+
+	// Returns the last block at least partially contained by the range,
+	// or null if no block is contained by the range.
+	getEndBlockOfRange = ( range, root ) => {
+		let container = range.endContainer,
+			block, child;
+
+		// If inline, get the containing block.
+		if ( isInline( container ) ) {
+			block = getPreviousBlock( container, root );
+		} else if ( container !== root && isBlock( container ) ) {
+			block = container;
+		} else {
+			block = getNodeAfter( container, range.endOffset );
+			if ( !block || !root.contains( block ) ) {
+				block = root;
+				while ( child = block.lastChild ) {
+					block = child;
+				}
+			}
+			block = getPreviousBlock( block, root );
+		}
+		// Check the block actually intersects the range
+		return block && isNodeContainedInRange( range, block, true ) ? block : null;
+	},
+
+	newContentWalker = root => doc.createTreeWalker( root,
+		SHOW_TEXT|SHOW_ELEMENT,
+		node => node.nodeType === TEXT_NODE ? notWS.test( node.data ) : node.nodeName === 'IMG'
+	),
+
+	rangeDoesStartAtBlockBoundary = ( range, root ) => {
+		let startContainer = range.startContainer;
+		let startOffset = range.startOffset;
+		let nodeAfterCursor;
+
+		// If in the middle or end of a text node, we're not at the boundary.
+		if ( startContainer.nodeType === TEXT_NODE ) {
+			if ( startOffset ) {
+				return false;
+			}
+			nodeAfterCursor = startContainer;
+		} else {
+			nodeAfterCursor = getNodeAfter( startContainer, startOffset );
+			if ( nodeAfterCursor && !root.contains( nodeAfterCursor ) ) {
+				nodeAfterCursor = null;
+			}
+			// The cursor was right at the end of the document
+			if ( !nodeAfterCursor ) {
+				nodeAfterCursor = getNodeBefore( startContainer, startOffset );
+				if ( nodeAfterCursor.nodeType === TEXT_NODE &&
+						nodeAfterCursor.length ) {
+					return false;
+				}
+			}
+		}
+
+		// Otherwise, look for any previous content in the same block.
+		contentWalker = newContentWalker(getStartBlockOfRange( range, root ));
+		contentWalker.currentNode = nodeAfterCursor;
+
+		return !contentWalker.previousNode();
+	},
+
+	rangeDoesEndAtBlockBoundary = ( range, root ) => {
+		let endContainer = range.endContainer,
+			endOffset = range.endOffset,
+			length;
+
+		// Otherwise, look for any further content in the same block.
+		contentWalker = newContentWalker(getStartBlockOfRange( range, root ));
+
+		// If in a text node with content, and not at the end, we're not
+		// at the boundary
+		if ( endContainer.nodeType === TEXT_NODE ) {
+			length = endContainer.data.length;
+			if ( length && endOffset < length ) {
+				return false;
+			}
+			contentWalker.currentNode = endContainer;
+		} else {
+			contentWalker.currentNode = getNodeBefore( endContainer, endOffset );
+		}
+
+		return !contentWalker.nextNode();
+	},
+
+	expandRangeToBlockBoundaries = ( range, root ) => {
+		let start = getStartBlockOfRange( range, root ),
+			end = getEndBlockOfRange( range, root ),
+			parent;
+
+		if ( start && end ) {
+			parent = start.parentNode;
+			range.setStart( parent, indexOf( parent.childNodes, start ) );
+			parent = end.parentNode;
+			range.setEnd( parent, indexOf( parent.childNodes, end ) + 1 );
+		}
+	};
+
+
+let contentWalker,
+	nodeCategoryCache = new WeakMap();
+
+// Previous node in post-order.
+TreeWalker.prototype.previousPONode = function () {
+	let current = this.currentNode,
+		root = this.root,
+		nodeType = this.nodeType,
+		filter = this.filter,
+		node;
+	while ( true ) {
+		node = current.lastChild;
+		while ( !node && current && current !== root) {
+			node = current.previousSibling;
+			if ( !node ) { current = current.parentNode; }
+		}
+		if ( !node ) {
+			return null;
+		}
+		if ( ( typeToBitArray[ node.nodeType ] & nodeType ) && filter( node ) ) {
+			this.currentNode = node;
+			return node;
+		}
+		current = node;
+	}
+};
+
+let onKey = function ( event ) {
+	if ( event.defaultPrevented ) {
+		return;
+	}
+
+	let key = event.key.toLowerCase(),
+		modifiers = '',
+		range = this.getSelection();
+
+	// We need to apply the backspace/delete handlers regardless of
+	// control key modifiers.
+	if ( key !== 'backspace' && key !== 'delete' ) {
+		if ( event.altKey  ) { modifiers += 'alt-'; }
+		if ( event[osKey] ) { modifiers += ctrlKey; }
+		if ( event.shiftKey ) { modifiers += 'shift-'; }
+	}
+	// However, on Windows, shift-delete is apparently "cut" (WTF right?), so
+	// we want to let the browser handle shift-delete in this situation.
+	if ( isWin && event.shiftKey && key === 'delete' ) {
+		modifiers += 'shift-';
+	}
+
+	key = modifiers + key;
+
+	if ( this._keyHandlers[ key ] ) {
+		this._keyHandlers[ key ]( this, event, range );
+	// !event.isComposing stops us from blatting Kana-Kanji conversion in Safari
+	} else if ( !range.collapsed && !event.isComposing &&
+			!event[osKey] &&
+			key.length === 1 ) {
+		// Record undo checkpoint.
+		this.saveUndoState( range );
+		// Delete the selection
+		deleteContentsOfRange( range, this._root );
+		this._ensureBottomLine();
+		this.setSelection( range );
+		this._updatePath( range, true );
+	}
+};
+
+let mapKeyTo = method => ( self, event ) => {
+	event.preventDefault();
+	self[ method ]();
+};
+
+let mapKeyToFormat = ( tag, remove ) => {
+	remove = remove || null;
+	return ( self, event ) => {
+		event.preventDefault();
+		let range = self.getSelection();
+		if ( self.hasFormat( tag, null, range ) ) {
+			self.changeFormat( null, { tag: tag }, range );
+		} else {
+			self.changeFormat( { tag: tag }, remove, range );
+		}
+	};
+};
+
+// If you delete the content inside a span with a font styling, Webkit will
+// replace it with a <font> tag (!). If you delete all the text inside a
+// link in Opera, it won't delete the link. Let's make things consistent. If
+// you delete all text inside an inline tag, remove the inline tag.
+let afterDelete = ( self, range ) => {
+	try {
+		if ( !range ) { range = self.getSelection(); }
+		let node = range.startContainer,
+			parent;
+		// Climb the tree from the focus point while we are inside an empty
+		// inline element
+		if ( node.nodeType === TEXT_NODE ) {
+			node = node.parentNode;
+		}
+		parent = node;
+		while ( isInline( parent ) &&
+				( !parent.textContent || parent.textContent === ZWS ) ) {
+			node = parent;
+			parent = node.parentNode;
+		}
+		// If focused in empty inline element
+		if ( node !== parent ) {
+			// Move focus to just before empty inline(s)
+			range.setStart( parent,
+				indexOf( parent.childNodes, node ) );
+			range.collapse( true );
+			// Remove empty inline(s)
+			parent.removeChild( node );
+			// Fix cursor in block
+			if ( !isBlock( parent ) ) {
+				parent = getPreviousBlock( parent, self._root );
+			}
+			fixCursor( parent, self._root );
+			// Move cursor into text node
+			moveRangeBoundariesDownTree( range );
+		}
+		// If you delete the last character in the sole <div> in Chrome,
+		// it removes the div and replaces it with just a <br> inside the
+		// root. Detach the <br>; the _ensureBottomLine call will insert a new
+		// block.
+		if ( node === self._root &&
+				( node = node.firstChild ) && node.nodeName === 'BR' ) {
+			node.remove();
+		}
+		self._ensureBottomLine();
+		self.setSelection( range );
+		self._updatePath( range, true );
+	} catch ( error ) {
+		self.didError( error );
+	}
+};
+
+let detachUneditableNode = ( node, root ) => {
+	let parent;
+	while (( parent = node.parentNode )) {
+		if ( parent === root || parent.isContentEditable ) {
+			break;
+		}
+		node = parent;
+	}
+	node.remove();
+};
+
+let handleEnter = ( self, shiftKey, range ) => {
+	let root = self._root;
+	let block, parent, node, offset, nodeAfterSplit;
+
+	// Save undo checkpoint and add any links in the preceding section.
+	// Remove any zws so we don't think there's content in an empty
+	// block.
+	self._recordUndoState( range );
+	if ( self._config.addLinks ) {
+		addLinks( range.startContainer, root, self );
+	}
+	self._removeZWS();
+	self._getRangeAndRemoveBookmark( range );
+
+	// Selected text is overwritten, therefore delete the contents
+	// to collapse selection.
+	if ( !range.collapsed ) {
+		deleteContentsOfRange( range, root );
+	}
+
+	block = getStartBlockOfRange( range, root );
+
+	// Inside a PRE, insert literal newline, unless on blank line.
+	if ( block && ( parent = getClosest( block, root, 'PRE' ) ) ) {
+		moveRangeBoundariesDownTree( range );
+		node = range.startContainer;
+		offset = range.startOffset;
+		if ( node.nodeType !== TEXT_NODE ) {
+			node = doc.createTextNode( '' );
+			parent.insertBefore( node, parent.firstChild );
+		}
+		// If blank line: split and insert default block
+		if ( !shiftKey &&
+				( node.data.charAt( offset - 1 ) === '\n' ||
+					rangeDoesStartAtBlockBoundary( range, root ) ) &&
+				( node.data.charAt( offset ) === '\n' ||
+					rangeDoesEndAtBlockBoundary( range, root ) ) ) {
+			node.deleteData( offset && offset - 1, offset ? 2 : 1 );
+			nodeAfterSplit =
+				split( node, offset && offset - 1, root, root );
+			node = nodeAfterSplit.previousSibling;
+			if ( !node.textContent ) {
+				node.remove();
+			}
+			node = self.createDefaultBlock();
+			nodeAfterSplit.before( node );
+			if ( !nodeAfterSplit.textContent ) {
+				nodeAfterSplit.remove();
+			}
+			range.setStart( node, 0 );
+		} else {
+			node.insertData( offset, '\n' );
+			fixCursor( parent, root );
+			// Firefox bug: if you set the selection in the text node after
+			// the new line, it draws the cursor before the line break still
+			// but if you set the selection to the equivalent position
+			// in the parent, it works.
+			if ( node.length === offset + 1 ) {
+				range.setStartAfter( node );
+			} else {
+				range.setStart( node, offset + 1 );
+			}
+		}
+		range.collapse( true );
+		self.setSelection( range );
+		self._updatePath( range, true );
+		self._docWasChanged();
+		return;
+	}
+
+	// If this is a malformed bit of document or in a table;
+	// just play it safe and insert a <br>.
+	if ( !block || shiftKey || /^T[HD]$/.test( block.nodeName ) ) {
+		// If inside an <a>, move focus out
+		moveRangeBoundaryOutOf( range, 'A', root );
+		insertNodeInRange( range, self.createElement( 'BR' ) );
+		range.collapse( false );
+		self.setSelection( range );
+		self._updatePath( range, true );
+		return;
+	}
+
+	// If in a list, we'll split the LI instead.
+	block = getClosest( block, root, 'LI' ) || block;
+
+	if ( isEmptyBlock( block ) && ( parent = getClosest( block, root, 'UL,OL,BLOCKQUOTE' ) ) ) {
+		return 'BLOCKQUOTE' === parent.nodeName
+			// Break blockquote
+			? self.modifyBlocks( (/* frag */) => self.createDefaultBlock( createBookmarkNodes( self ) ), range )
+			// Break list
+			: self.decreaseListLevel( range );
+	}
+
+	// Otherwise, split at cursor point.
+	nodeAfterSplit = splitBlock( self, block,
+		range.startContainer, range.startOffset );
+
+	// Clean up any empty inlines if we hit enter at the beginning of the block
+	removeZWS( block );
+	removeEmptyInlines( block );
+	fixCursor( block, root );
+
+	// Focus cursor
+	// If there's a <b>/<i> etc. at the beginning of the split
+	// make sure we focus inside it.
+	while ( nodeAfterSplit.nodeType === ELEMENT_NODE ) {
+		let child = nodeAfterSplit.firstChild,
+			next;
+
+		// Don't continue links over a block break; unlikely to be the
+		// desired outcome.
+		if ( nodeAfterSplit.nodeName === 'A' &&
+				( !nodeAfterSplit.textContent ||
+					nodeAfterSplit.textContent === ZWS ) ) {
+			child = doc.createTextNode( '' );
+			nodeAfterSplit.replaceWith( child );
+			nodeAfterSplit = child;
+			break;
+		}
+
+		while ( child && child.nodeType === TEXT_NODE && !child.data ) {
+			next = child.nextSibling;
+			if ( !next || next.nodeName === 'BR' ) {
+				break;
+			}
+			child.remove();
+			child = next;
+		}
+
+		// 'BR's essentially don't count; they're a browser hack.
+		// If you try to select the contents of a 'BR', FF will not let
+		// you type anything!
+		if ( !child || child.nodeName === 'BR' ||
+				child.nodeType === TEXT_NODE ) {
+			break;
+		}
+		nodeAfterSplit = child;
+	}
+	range = self.createRange( nodeAfterSplit, 0 );
+	self.setSelection( range );
+	self._updatePath( range, true );
+};
+
+let keyHandlers = {
+	// This song and dance is to force iOS to do enable the shift key
+	// automatically on enter. When you do the DOM split manipulation yourself,
+	// WebKit doesn't reset the IME state and so presents auto-complete options
+	// as though you were continuing to type on the previous line, and doesn't
+	// auto-enable the shift key. The old trick of blurring and focussing
+	// again no longer works in iOS 13, and I tried various execCommand options
+	// but they didn't seem to do anything. The only solution I've found is to
+	// let iOS handle the enter key, then after it's done that reset the HTML
+	// to what it was before and handle it properly in Squire; the IME state of
+	// course doesn't reset so you end up in the correct state!
+	enter: isIOS ? ( self, event, range ) => {
+		self._saveRangeToBookmark( range );
+		let html = self._getHTML();
+		let restoreAndDoEnter = () => {
+			self.removeEventListener( 'keyup', restoreAndDoEnter );
+			self._setHTML( html );
+			range = self._getRangeAndRemoveBookmark();
+			// Ignore the shift key on iOS, as this is for auto-capitalisation.
+			handleEnter( self, false, range );
+		};
+		self.addEventListener( 'keyup', restoreAndDoEnter );
+	} : ( self, event, range ) => {
+		event.preventDefault();
+		handleEnter( self, event.shiftKey, range );
+	},
+
+	'shift-enter': ( self, event, range ) => self._keyHandlers.enter( self, event, range ),
+
+	backspace: ( self, event, range ) => {
+		let root = self._root;
+		self._removeZWS();
+		// Record undo checkpoint.
+		self.saveUndoState( range );
+		// If not collapsed, delete contents
+		if ( !range.collapsed ) {
+			event.preventDefault();
+			deleteContentsOfRange( range, root );
+			afterDelete( self, range );
+		}
+		// If at beginning of block, merge with previous
+		else if ( rangeDoesStartAtBlockBoundary( range, root ) ) {
+			event.preventDefault();
+			let current = getStartBlockOfRange( range, root );
+			let previous;
+			if ( !current ) {
+				return;
+			}
+			// In case inline data has somehow got between blocks.
+			fixContainer( current.parentNode, root );
+			// Now get previous block
+			previous = getPreviousBlock( current, root );
+			// Must not be at the very beginning of the text area.
+			if ( previous ) {
+				// If not editable, just delete whole block.
+				if ( !previous.isContentEditable ) {
+					detachUneditableNode( previous, root );
+					return;
+				}
+				// Otherwise merge.
+				mergeWithBlock( previous, current, range, root );
+				// If deleted line between containers, merge newly adjacent
+				// containers.
+				current = previous.parentNode;
+				while ( current !== root && !current.nextSibling ) {
+					current = current.parentNode;
+				}
+				if ( current !== root && ( current = current.nextSibling ) ) {
+					mergeContainers( current, root );
+				}
+				self.setSelection( range );
+			}
+			// If at very beginning of text area, allow backspace
+			// to break lists/blockquote.
+			else if ( current ) {
+				let parent = getClosest( current, root, 'UL,OL,BLOCKQUOTE' );
+				if (parent) {
+					return ( 'BLOCKQUOTE' === parent.nodeName )
+						// Break blockquote
+						? self.modifyBlocks( decreaseBlockQuoteLevel, range )
+						// Break list
+						: self.decreaseListLevel( range );
+				}
+				self.setSelection( range );
+				self._updatePath( range, true );
+			}
+		}
+		// Otherwise, leave to browser but check afterwards whether it has
+		// left behind an empty inline tag.
+		else {
+			self.setSelection( range );
+			setTimeout( () => afterDelete( self ), 0 );
+		}
+	},
+	'delete': ( self, event, range ) => {
+		let root = self._root;
+		let current, next, originalRange,
+			cursorContainer, cursorOffset, nodeAfterCursor;
+		self._removeZWS();
+		// Record undo checkpoint.
+		self.saveUndoState( range );
+		// If not collapsed, delete contents
+		if ( !range.collapsed ) {
+			event.preventDefault();
+			deleteContentsOfRange( range, root );
+			afterDelete( self, range );
+		}
+		// If at end of block, merge next into this block
+		else if ( rangeDoesEndAtBlockBoundary( range, root ) ) {
+			event.preventDefault();
+			current = getStartBlockOfRange( range, root );
+			if ( !current ) {
+				return;
+			}
+			// In case inline data has somehow got between blocks.
+			fixContainer( current.parentNode, root );
+			// Now get next block
+			next = getNextBlock( current, root );
+			// Must not be at the very end of the text area.
+			if ( next ) {
+				// If not editable, just delete whole block.
+				if ( !next.isContentEditable ) {
+					detachUneditableNode( next, root );
+					return;
+				}
+				// Otherwise merge.
+				mergeWithBlock( current, next, range, root );
+				// If deleted line between containers, merge newly adjacent
+				// containers.
+				next = current.parentNode;
+				while ( next !== root && !next.nextSibling ) {
+					next = next.parentNode;
+				}
+				if ( next !== root && ( next = next.nextSibling ) ) {
+					mergeContainers( next, root );
+				}
+				self.setSelection( range );
+				self._updatePath( range, true );
+			}
+		}
+		// Otherwise, leave to browser but check afterwards whether it has
+		// left behind an empty inline tag.
+		else {
+			// But first check if the cursor is just before an IMG tag. If so,
+			// delete it ourselves, because the browser won't if it is not
+			// inline.
+			originalRange = range.cloneRange();
+			moveRangeBoundariesUpTree( range, root, root, root );
+			cursorContainer = range.endContainer;
+			cursorOffset = range.endOffset;
+			if ( cursorContainer.nodeType === ELEMENT_NODE ) {
+				nodeAfterCursor = cursorContainer.childNodes[ cursorOffset ];
+				if ( nodeAfterCursor && nodeAfterCursor.nodeName === 'IMG' ) {
+					event.preventDefault();
+					nodeAfterCursor.remove();
+					moveRangeBoundariesDownTree( range );
+					afterDelete( self, range );
+					return;
+				}
+			}
+			self.setSelection( originalRange );
+			setTimeout( () => afterDelete( self ), 0 );
+		}
+	},
+	tab: ( self, event, range ) => {
+		let root = self._root;
+		let node, parent;
+		self._removeZWS();
+		// If no selection and at start of block
+		if ( range.collapsed && rangeDoesStartAtBlockBoundary( range, root ) ) {
+			node = getStartBlockOfRange( range, root );
+			// Iterate through the block's parents
+			while ( ( parent = node.parentNode ) ) {
+				// If we find a UL or OL (so are in a list, node must be an LI)
+				if ( parent.nodeName === 'UL' || parent.nodeName === 'OL' ) {
+					// Then increase the list level
+					event.preventDefault();
+					self.increaseListLevel( range );
+					break;
+				}
+				node = parent;
+			}
+		}
+	},
+	'shift-tab': ( self, event, range ) => {
+		let root = self._root;
+		let node;
+		self._removeZWS();
+		// If no selection and at start of block
+		if ( range.collapsed && rangeDoesStartAtBlockBoundary( range, root ) ) {
+			// Break list
+			node = range.startContainer;
+			if ( getClosest( node, root, 'UL,OL' ) ) {
+				event.preventDefault();
+				self.decreaseListLevel( range );
+			}
+		}
+	},
+	space: ( self, _, range ) => {
+		let node;
+		let root = self._root;
+		self._recordUndoState( range );
+		if ( self._config.addLinks ) {
+			addLinks( range.startContainer, root, self );
+		}
+		self._getRangeAndRemoveBookmark( range );
+
+		// If the cursor is at the end of a link (<a>foo|</a>) then move it
+		// outside of the link (<a>foo</a>|) so that the space is not part of
+		// the link text.
+		node = range.endContainer;
+		if ( range.collapsed && range.endOffset === getLength( node ) ) {
+			do {
+				if ( node.nodeName === 'A' ) {
+					range.setStartAfter( node );
+					break;
+				}
+			} while ( !node.nextSibling &&
+				( node = node.parentNode ) && node !== root );
+		}
+		// Delete the selection if not collapsed
+		if ( !range.collapsed ) {
+			deleteContentsOfRange( range, root );
+			self._ensureBottomLine();
+			self.setSelection( range );
+			self._updatePath( range, true );
+		}
+
+		self.setSelection( range );
+	},
+	arrowleft: self => self._removeZWS(),
+	arrowright: self => self._removeZWS()
+};
+
+// System standard for page up/down on Mac is to just scroll, not move the
+// cursor. On Linux/Windows, it should move the cursor, but some browsers don't
+// implement this natively. Override to support it.
+function _moveCursorTo( self, toStart ) {
+	let root = self._root,
+		range = self.createRange( root, toStart ? 0 : root.childNodes.length );
+	moveRangeBoundariesDownTree( range );
+	self.setSelection( range );
+	return self;
+}
+if ( !isMac ) {
+	keyHandlers.pageup = self => _moveCursorTo( self, true );
+	keyHandlers.pagedown = self => _moveCursorTo( self, false );
+}
+
+const changeIndentationLevel = direction => ( self, event ) => {
+	event.preventDefault();
+	self.changeIndentationLevel(direction);
+};
+
+const toggleList = ( type, methodIfNotInList ) => ( self, event ) => {
+	event.preventDefault();
+	let parent = self.getSelectionClosest('UL,OL');
+	if (parent && type == parent.nodeName) {
+		self.removeList();
+	} else {
+		self[ methodIfNotInList ]();
+	}
+};
+
+keyHandlers[ ctrlKey + 'b' ] = mapKeyToFormat( 'B' );
+keyHandlers[ ctrlKey + 'i' ] = mapKeyToFormat( 'I' );
+keyHandlers[ ctrlKey + 'u' ] = mapKeyToFormat( 'U' );
+keyHandlers[ ctrlKey + 'shift-7' ] = mapKeyToFormat( 'S' );
+keyHandlers[ ctrlKey + 'shift-5' ] = mapKeyToFormat( 'SUB', { tag: 'SUP' } );
+keyHandlers[ ctrlKey + 'shift-6' ] = mapKeyToFormat( 'SUP', { tag: 'SUB' } );
+keyHandlers[ ctrlKey + 'shift-8' ] = toggleList( 'UL', 'makeUnorderedList' );
+keyHandlers[ ctrlKey + 'shift-9' ] = toggleList( 'OL', 'makeOrderedList' );
+keyHandlers[ ctrlKey + '[' ] = changeIndentationLevel( 'decrease' );
+keyHandlers[ ctrlKey + ']' ] = changeIndentationLevel( 'increase' );
+keyHandlers[ ctrlKey + 'd' ] = mapKeyTo( 'toggleCode' );
+keyHandlers[ ctrlKey + 'y' ] = mapKeyTo( 'redo' );
+keyHandlers[ ctrlKey + 'z' ] = mapKeyTo( 'undo' );
+keyHandlers[ ctrlKey + 'shift-z' ] = mapKeyTo( 'redo' );
+
+let fontSizes = {
+	1: 10,
+	2: 13,
+	3: 16,
+	4: 18,
+	5: 24,
+	6: 32,
+	7: 48
+};
+
+let styleToSemantic = {
+	fontWeight: {
+		regexp: /^bold|^700/i,
+		replace: doc => createElement( doc, 'B' )
+	},
+	fontStyle: {
+		regexp: /^italic/i,
+		replace: doc => createElement( doc, 'I' )
+	},
+	fontFamily: {
+		regexp: notWS,
+		replace: ( doc, classNames, family ) => createElement( doc, 'SPAN', {
+			'class': classNames.fontFamily,
+			style: 'font-family:' + family
+		})
+	},
+	fontSize: {
+		regexp: notWS,
+		replace: ( doc, classNames, size ) => createElement( doc, 'SPAN', {
+			'class': classNames.fontSize,
+			style: 'font-size:' + size
+		})
+	},
+	textDecoration: {
+		regexp: /^underline/i,
+		replace: doc => createElement( doc, 'U' )
+	}
+/*
+	textDecoration: {
+		regexp: /^line-through/i,
+		replace: doc => createElement( doc, 'S' )
+	}
+*/
+};
+
+let replaceWithTag = tag => node => {
+	let el = createElement( doc, tag );
+	Array.prototype.forEach.call( node.attributes, attr => el.setAttribute( attr.name, attr.value ) );
+	node.replaceWith( el );
+	el.append( empty( node ) );
+	return el;
+};
+
+let replaceStyles = ( node, parent, config ) => {
+	let style = node.style;
+	let attr, converter, css, newTreeBottom, newTreeTop, el;
+
+	for ( attr in styleToSemantic ) {
+		converter = styleToSemantic[ attr ];
+		css = style[ attr ];
+		if ( css && converter.regexp.test( css ) ) {
+			el = converter.replace( doc, config.classNames, css );
+			if ( el.nodeName === node.nodeName &&
+					el.className === node.className ) {
+				continue;
+			}
+			if ( !newTreeTop ) {
+				newTreeTop = el;
+			}
+			if ( newTreeBottom ) {
+				newTreeBottom.append( el );
+			}
+			newTreeBottom = el;
+			node.style[ attr ] = '';
+		}
+	}
+
+	if ( newTreeTop ) {
+		newTreeBottom.append( empty( node ) );
+		node.append( newTreeTop );
+	}
+
+	return newTreeBottom || node;
+};
+
+let stylesRewriters = {
+	SPAN: replaceStyles,
+	STRONG: replaceWithTag( 'B' ),
+	EM: replaceWithTag( 'I' ),
+	INS: replaceWithTag( 'U' ),
+	STRIKE: replaceWithTag( 'S' ),
+	FONT: ( node, parent, config ) => {
+		let face = node.face;
+		let size = node.size;
+		let colour = node.color;
+		let classNames = config.classNames;
+		let fontSpan, sizeSpan, colourSpan;
+		let newTreeBottom, newTreeTop;
+		if ( face ) {
+			fontSpan = createElement( doc, 'SPAN', {
+				'class': classNames.fontFamily,
+				style: 'font-family:' + face
+			});
+			newTreeTop = fontSpan;
+			newTreeBottom = fontSpan;
+		}
+		if ( size ) {
+			sizeSpan = createElement( doc, 'SPAN', {
+				'class': classNames.fontSize,
+				style: 'font-size:' + fontSizes[ size ] + 'px'
+			});
+			if ( !newTreeTop ) {
+				newTreeTop = sizeSpan;
+			}
+			if ( newTreeBottom ) {
+				newTreeBottom.append( sizeSpan );
+			}
+			newTreeBottom = sizeSpan;
+		}
+		if ( colour && /^#?([\dA-F]{3}){1,2}$/i.test( colour ) ) {
+			if ( colour.charAt( 0 ) !== '#' ) {
+				colour = '#' + colour;
+			}
+			colourSpan = createElement( doc, 'SPAN', {
+				'class': classNames.colour,
+				style: 'color:' + colour
+			});
+			if ( !newTreeTop ) {
+				newTreeTop = colourSpan;
+			}
+			if ( newTreeBottom ) {
+				newTreeBottom.append( colourSpan );
+			}
+			newTreeBottom = colourSpan;
+		}
+		if ( !newTreeTop ) {
+			newTreeTop = newTreeBottom = createElement( doc, 'SPAN' );
+		}
+		node.replaceWith( newTreeTop );
+		newTreeBottom.append( empty( node ) );
+		return newTreeBottom;
+	},
+	TT: ( node, parent, config ) => {
+		let el = createElement( doc, 'SPAN', {
+			'class': config.classNames.fontFamily,
+			style: 'font-family:menlo,consolas,"courier new",monospace'
+		});
+		node.replaceWith( el );
+		el.append( empty( node ) );
+		return el;
+	}
+};
+
+let allowedBlock = /^(?:A(?:DDRESS|RTICLE|SIDE|UDIO)|BLOCKQUOTE|CAPTION|D(?:[DLT]|IV)|F(?:IGURE|IGCAPTION|OOTER)|H[1-6]|HEADER|L(?:ABEL|EGEND|I)|O(?:L|UTPUT)|P(?:RE)?|SECTION|T(?:ABLE|BODY|D|FOOT|H|HEAD|R)|COL(?:GROUP)?|UL)$/;
+
+let blacklist = /^(?:HEAD|META|STYLE)/;
+
+/*
+	Two purposes:
+
+	1. Remove nodes we don't want, such as weird <o:p> tags, comment nodes
+	   and whitespace nodes.
+	2. Convert inline tags into our preferred format.
+*/
+let cleanTree = ( node, config, preserveWS ) => {
+	let children = node.childNodes,
+		nonInlineParent, i, l, child, nodeName, nodeType, rewriter, childLength,
+		startsWithWS, endsWithWS, data, sibling;
+
+	nonInlineParent = node;
+	while ( isInline( nonInlineParent ) ) {
+		nonInlineParent = nonInlineParent.parentNode;
+	}
+	let walker = doc.createTreeWalker( nonInlineParent, SHOW_TEXT|SHOW_ELEMENT );
+
+	for ( i = 0, l = children.length; i < l; ++i ) {
+		child = children[i];
+		nodeName = child.nodeName;
+		nodeType = child.nodeType;
+		rewriter = stylesRewriters[ nodeName ];
+		if ( nodeType === ELEMENT_NODE ) {
+			childLength = child.childNodes.length;
+			if ( rewriter ) {
+				child = rewriter( child, node, config );
+			} else if ( blacklist.test( nodeName ) ) {
+				node.removeChild( child );
+				--i;
+				--l;
+				continue;
+			} else if ( !allowedBlock.test( nodeName ) && !isInline( child ) ) {
+				--i;
+				l += childLength - 1;
+				child.replaceWith( empty( child ) );
+				continue;
+			}
+			if ( childLength ) {
+				cleanTree( child, config,
+					preserveWS || ( nodeName === 'PRE' ) );
+			}
+		} else {
+			if ( nodeType === TEXT_NODE ) {
+				data = child.data;
+				startsWithWS = !notWS.test( data.charAt( 0 ) );
+				endsWithWS = !notWS.test( data.charAt( data.length - 1 ) );
+				if ( preserveWS || ( !startsWithWS && !endsWithWS ) ) {
+					continue;
+				}
+				// Iterate through the nodes; if we hit some other content
+				// before the start of a new block we don't trim
+				if ( startsWithWS ) {
+					walker.currentNode = child;
+					while ( sibling = walker.previousPONode() ) {
+						nodeName = sibling.nodeName;
+						if ( nodeName === 'IMG' ||
+								( nodeName === '#text' &&
+									notWS.test( sibling.data ) ) ) {
+							break;
+						}
+						if ( !isInline( sibling ) ) {
+							sibling = null;
+							break;
+						}
+					}
+					data = data.replace( /^[ \t\r\n]+/g, sibling ? ' ' : '' );
+				}
+				if ( endsWithWS ) {
+					walker.currentNode = child;
+					while ( sibling = walker.nextNode() ) {
+						if ( nodeName === 'IMG' ||
+								( nodeName === '#text' &&
+									notWS.test( sibling.data ) ) ) {
+							break;
+						}
+						if ( !isInline( sibling ) ) {
+							sibling = null;
+							break;
+						}
+					}
+					data = data.replace( /[ \t\r\n]+$/g, sibling ? ' ' : '' );
+				}
+				if ( data ) {
+					child.data = data;
+					continue;
+				}
+			}
+			node.removeChild( child );
+			--i;
+			--l;
+		}
+	}
+	return node;
+};
+
+// ---
+
+let removeEmptyInlines = node => {
+	let children = node.childNodes,
+		l = children.length,
+		child;
+	while ( l-- ) {
+		child = children[l];
+		if ( child.nodeType === ELEMENT_NODE && !isLeaf( child ) ) {
+			removeEmptyInlines( child );
+			if ( isInline( child ) && !child.firstChild ) {
+				node.removeChild( child );
+			}
+		} else if ( child.nodeType === TEXT_NODE && !child.data ) {
+			node.removeChild( child );
+		}
+	}
+};
+
+// ---
+
+let notWSTextNode = node => node.nodeType === ELEMENT_NODE ? node.nodeName === 'BR' : notWS.test( node.data );
+let isLineBreak = ( br, isLBIfEmptyBlock ) => {
+	let block = br.parentNode;
+	let walker;
+	while ( isInline( block ) ) {
+		block = block.parentNode;
+	}
+	walker = doc.createTreeWalker( block, SHOW_ELEMENT|SHOW_TEXT, notWSTextNode );
+	walker.currentNode = br;
+	return !!walker.nextNode() ||
+		( isLBIfEmptyBlock && !walker.previousNode() );
+};
+
+// <br> elements are treated specially, and differently depending on the
+// browser, when in rich text editor mode. When adding HTML from external
+// sources, we must remove them, replacing the ones that actually affect
+// line breaks by wrapping the inline text in a <div>. Browsers that want <br>
+// elements at the end of each block will then have them added back in a later
+// fixCursor method call.
+let cleanupBRs = ( node, root, keepForBlankLine ) => {
+	let brs = node.querySelectorAll( 'BR' );
+	let brBreaksLine = [];
+	let l = brs.length;
+	let i, br, parent;
+
+	// Must calculate whether the <br> breaks a line first, because if we
+	// have two <br>s next to each other, after the first one is converted
+	// to a block split, the second will be at the end of a block and
+	// therefore seem to not be a line break. But in its original context it
+	// was, so we should also convert it to a block split.
+	for ( i = 0; i < l; ++i ) {
+		brBreaksLine[i] = isLineBreak( brs[i], keepForBlankLine );
+	}
+	while ( l-- ) {
+		br = brs[l];
+		// Cleanup may have removed it
+		parent = br.parentNode;
+		if ( !parent ) { continue; }
+		// If it doesn't break a line, just remove it; it's not doing
+		// anything useful. We'll add it back later if required by the
+		// browser. If it breaks a line, wrap the content in div tags
+		// and replace the brs.
+		if ( !brBreaksLine[l] ) {
+			br.remove();
+		} else if ( !isInline( parent ) ) {
+			fixContainer( parent, root );
+		}
+	}
+};
+
+// The (non-standard but supported enough) innerText property is based on the
+// render tree in Firefox and possibly other browsers, so we must insert the
+// DOM node into the document to ensure the text part is correct.
+let setClipboardData =
+		( event, contents, root, willCutCopy, toPlainText, plainTextOnly ) => {
+	let clipboardData = event.clipboardData;
+	let body = doc.body;
+	let node = createElement( doc, 'div' );
+	let html, text;
+
+	node.append( contents );
+
+	html = node.innerHTML;
+	if ( willCutCopy ) {
+		html = willCutCopy( html );
+	}
+
+	if ( toPlainText ) {
+		text = toPlainText( html );
+	} else {
+		// Firefox will add an extra new line for BRs at the end of block when
+		// calculating innerText, even though they don't actually affect
+		// display, so we need to remove them first.
+		cleanupBRs( node, root, true );
+		node.setAttribute( 'style',
+			'position:fixed;overflow:hidden;bottom:100%;right:100%;' );
+		body.append( node );
+		text = node.innerText || node.textContent;
+		text = text.replace( NBSP, ' ' ); // Replace nbsp with regular space
+		body.removeChild( node );
+	}
+	// Firefox (and others?) returns unix line endings (\n) even on Windows.
+	// If on Windows, normalise to \r\n, since Notepad and some other crappy
+	// apps do not understand just \n.
+	if ( isWin ) {
+		text = text.replace( /\r?\n/g, '\r\n' );
+	}
+
+	if ( !plainTextOnly && text !== html ) {
+		clipboardData.setData( 'text/html', html );
+	}
+	clipboardData.setData( 'text/plain', text );
+	event.preventDefault();
+};
+
+let onCut = function ( event ) {
+	let range = this.getSelection();
+	let root = this._root;
+	let self = this;
+	let startBlock, endBlock, copyRoot, contents, parent, newContents;
+
+	// Nothing to do
+	if ( range.collapsed ) {
+		event.preventDefault();
+		return;
+	}
+
+	// Save undo checkpoint
+	this.saveUndoState( range );
+
+	// Edge only seems to support setting plain text as of 2016-03-11.
+	if ( !isEdge && event.clipboardData ) {
+		// Clipboard content should include all parents within block, or all
+		// parents up to root if selection across blocks
+		startBlock = getStartBlockOfRange( range, root );
+		endBlock = getEndBlockOfRange( range, root );
+		copyRoot = ( ( startBlock === endBlock ) && startBlock ) || root;
+		// Extract the contents
+		contents = deleteContentsOfRange( range, root );
+		// Add any other parents not in extracted content, up to copy root
+		parent = range.commonAncestorContainer;
+		if ( parent.nodeType === TEXT_NODE ) {
+			parent = parent.parentNode;
+		}
+		while ( parent && parent !== copyRoot ) {
+			newContents = parent.cloneNode( false );
+			newContents.append( contents );
+			contents = newContents;
+			parent = parent.parentNode;
+		}
+		// Set clipboard data
+		setClipboardData(
+			event, contents, root, this._config.willCutCopy, null, false );
+	} else {
+		setTimeout( () => {
+			try {
+				// If all content removed, ensure div at start of root.
+				self._ensureBottomLine();
+			} catch ( error ) {
+				self.didError( error );
+			}
+		}, 0 );
+	}
+
+	this.setSelection( range );
+};
+
+let _onCopy = ( event, range, root, willCutCopy, toPlainText, plainTextOnly ) => {
+	let startBlock, endBlock, copyRoot, contents, parent, newContents;
+	// Edge only seems to support setting plain text as of 2016-03-11.
+	if ( !isEdge && event.clipboardData ) {
+		// Clipboard content should include all parents within block, or all
+		// parents up to root if selection across blocks
+		startBlock = getStartBlockOfRange( range, root );
+		endBlock = getEndBlockOfRange( range, root );
+		copyRoot = ( ( startBlock === endBlock ) && startBlock ) || root;
+		// Clone range to mutate, then move up as high as possible without
+		// passing the copy root node.
+		range = range.cloneRange();
+		moveRangeBoundariesDownTree( range );
+		moveRangeBoundariesUpTree( range, copyRoot, copyRoot, root );
+		// Extract the contents
+		contents = range.cloneContents();
+		// Add any other parents not in extracted content, up to copy root
+		parent = range.commonAncestorContainer;
+		if ( parent.nodeType === TEXT_NODE ) {
+			parent = parent.parentNode;
+		}
+		while ( parent && parent !== copyRoot ) {
+			newContents = parent.cloneNode( false );
+			newContents.append( contents );
+			contents = newContents;
+			parent = parent.parentNode;
+		}
+		// Set clipboard data
+		setClipboardData( event, contents, root, willCutCopy, toPlainText, plainTextOnly );
+	}
+};
+
+let onCopy = function ( event ) {
+	_onCopy(
+		event,
+		this.getSelection(),
+		this._root,
+		this._config.willCutCopy,
+		null,
+		false
+	);
+};
+
+// Need to monitor for shift key like this, as event.shiftKey is not available
+// in paste event.
+function monitorShiftKey ( event ) {
+	this.isShiftDown = event.shiftKey;
+}
+
+let onPaste = function ( event ) {
+	let clipboardData = event.clipboardData;
+	let items = clipboardData && clipboardData.items;
+	let choosePlain = this.isShiftDown;
+	let fireDrop = false;
+	let hasRTF = false;
+	let hasImage = false;
+	let plainItem = null;
+	let htmlItem = null;
+	let self = this;
+	let l, item, type, types, data;
+
+	// Current HTML5 Clipboard interface
+	// ---------------------------------
+	// https://html.spec.whatwg.org/multipage/interaction.html
+	if ( items ) {
+		l = items.length;
+		while ( l-- ) {
+			item = items[l];
+			type = item.type;
+			if ( type === 'text/html' ) {
+				htmlItem = item;
+			// iOS copy URL gives you type text/uri-list which is just a list
+			// of 1 or more URLs separated by new lines. Can just treat as
+			// plain text.
+			} else if ( type === 'text/plain' || type === 'text/uri-list' ) {
+				plainItem = item;
+			} else if ( type === 'text/rtf' ) {
+				hasRTF = true;
+			} else if ( /^image\/.*/.test( type ) ) {
+				hasImage = true;
+			}
+		}
+
+		// Treat image paste as a drop of an image file. When you copy
+		// an image in Chrome/Firefox (at least), it copies the image data
+		// but also an HTML version (referencing the original URL of the image)
+		// and a plain text version.
+		//
+		// However, when you copy in Excel, you get html, rtf, text, image;
+		// in this instance you want the html version! So let's try using
+		// the presence of text/rtf as an indicator to choose the html version
+		// over the image.
+		if ( hasImage && !( hasRTF && htmlItem ) ) {
+			event.preventDefault();
+			this.fireEvent( 'dragover', {
+				dataTransfer: clipboardData,
+				/*jshint loopfunc: true */
+				preventDefault: () => fireDrop = true
+				/*jshint loopfunc: false */
+			});
+			if ( fireDrop ) {
+				this.fireEvent( 'drop', {
+					dataTransfer: clipboardData
+				});
+			}
+			return;
+		}
+
+		// Edge only provides access to plain text as of 2016-03-11 and gives no
+		// indication there should be an HTML part. However, it does support
+		// access to image data, so we check for that first. Otherwise though,
+		// fall through to fallback clipboard handling methods
+		if ( !isEdge ) {
+			event.preventDefault();
+			if ( htmlItem && ( !choosePlain || !plainItem ) ) {
+				htmlItem.getAsString( html => self.insertHTML( html, true ) );
+			} else if ( plainItem ) {
+				plainItem.getAsString( text => self.insertPlainText( text, true ) );
+			}
+			return;
+		}
+	}
+
+	// Old interface
+	// -------------
+
+	// Safari (and indeed many other OS X apps) copies stuff as text/rtf
+	// rather than text/html; even from a webpage in Safari. The only way
+	// to get an HTML version is to fallback to letting the browser insert
+	// the content. Same for getting image data. *Sigh*.
+	//
+	// Firefox is even worse: it doesn't even let you know that there might be
+	// an RTF version on the clipboard, but it will also convert to HTML if you
+	// let the browser insert the content. I've filed
+	// https://bugzilla.mozilla.org/show_bug.cgi?id=1254028
+	types = clipboardData && clipboardData.types;
+	if ( !isEdge && types && (
+			indexOf( types, 'text/html' ) > -1 || (
+				!isGecko &&
+				indexOf( types, 'text/plain' ) > -1 &&
+				indexOf( types, 'text/rtf' ) < 0 )
+			)) {
+		event.preventDefault();
+		// Abiword on Linux copies a plain text and html version, but the HTML
+		// version is the empty string! So always try to get HTML, but if none,
+		// insert plain text instead. On iOS, Facebook (and possibly other
+		// apps?) copy links as type text/uri-list, but also insert a **blank**
+		// text/plain item onto the clipboard. Why? Who knows.
+		if ( !choosePlain && ( data = clipboardData.getData( 'text/html' ) ) ) {
+			this.insertHTML( data, true );
+		} else if (
+				( data = clipboardData.getData( 'text/plain' ) ) ||
+				( data = clipboardData.getData( 'text/uri-list' ) ) ) {
+			this.insertPlainText( data, true );
+		}
+		return;
+	}
+
+	// No interface. Includes all versions of IE :(
+	// --------------------------------------------
+
+	let body = doc.body,
+		range = this.getSelection(),
+		startContainer = range.startContainer,
+		startOffset = range.startOffset,
+		endContainer = range.endContainer,
+		endOffset = range.endOffset;
+
+	// We need to position the pasteArea in the visible portion of the screen
+	// to stop the browser auto-scrolling.
+	let pasteArea = this.createElement( 'DIV', {
+		contenteditable: 'true',
+		style: 'position:fixed; overflow:hidden; top:0; right:100%; width:1px; height:1px;'
+	});
+	body.append( pasteArea );
+	range.selectNodeContents( pasteArea );
+	this.setSelection( range );
+
+	// A setTimeout of 0 means this is added to the back of the
+	// single javascript thread, so it will be executed after the
+	// paste event.
+	setTimeout( () => {
+		try {
+			// Get the pasted content and clean
+			let html = '',
+				next = pasteArea,
+				first, range;
+
+			// #88: Chrome can apparently split the paste area if certain
+			// content is inserted; gather them all up.
+			while ( pasteArea = next ) {
+				next = pasteArea.nextSibling;
+				pasteArea.remove();
+				// Safari and IE like putting extra divs around things.
+				first = pasteArea.firstChild;
+				if ( first && first === pasteArea.lastChild &&
+						first.nodeName === 'DIV' ) {
+					pasteArea = first;
+				}
+				html += pasteArea.innerHTML;
+			}
+
+			range = self.createRange(
+				startContainer, startOffset, endContainer, endOffset );
+			self.setSelection( range );
+
+			if ( html ) {
+				self.insertHTML( html, true );
+			}
+		} catch ( error ) {
+			self.didError( error );
+		}
+	}, 0 );
+};
+
+// On Windows you can drag an drop text. We can't handle this ourselves, because
+// as far as I can see, there's no way to get the drop insertion point. So just
+// save an undo state and hope for the best.
+let onDrop = function ( event ) {
+	let types = event.dataTransfer.types;
+	let l = types.length;
+	let hasPlain = false;
+	let hasHTML = false;
+	while ( l-- ) {
+		switch ( types[l] ) {
+		case 'text/plain':
+			hasPlain = true;
+			break;
+		case 'text/html':
+			hasHTML = true;
+			break;
+		default:
+			return;
+		}
+	}
+	if ( hasHTML || hasPlain ) {
+		this.saveUndoState();
+	}
+};
+
+function mergeObjects ( base, extras, mayOverride ) {
+	let prop, value;
+	if ( !base ) {
+		base = {};
+	}
+	if ( extras ) {
+		for ( prop in extras ) {
+			if ( mayOverride || !( prop in base ) ) {
+				value = extras[ prop ];
+				base[ prop ] = ( value && value.constructor === Object ) ?
+					mergeObjects( base[ prop ], value, mayOverride ) :
+					value;
+			}
+		}
+	}
+	return base;
+}
+
+function Squire ( root, config ) {
+	if ( root.nodeType === DOCUMENT_NODE ) {
+		root = root.body;
+	}
+	let mutation;
+
+	this._root = root;
+
+	this._events = {};
+
+	this._isFocused = false;
+	this._lastRange = null;
+
+	this._hasZWS = false;
+
+	this._lastAnchorNode = null;
+	this._lastFocusNode = null;
+	this._path = '';
+	this._willUpdatePath = false;
+
+	const selectionchange = () => {
+		if (root.contains(doc.activeElement)) {
+			let self = this;
+			if ( self._isFocused && !self._willUpdatePath ) {
+				self._willUpdatePath = true;
+				setTimeout( function () {
+					self._willUpdatePath = false;
+					self._updatePath( self.getSelection() );
+				}, 0 );
+			}
+		} else {
+			this.removeEventListener('selectionchange', selectionchange);
+		}
+	};
+	this.addEventListener('selectstart', () => this.addEventListener('selectionchange', selectionchange));
+
+	this._undoIndex = -1;
+	this._undoStack = [];
+	this._undoStackLength = 0;
+	this._isInUndoState = false;
+	this._ignoreChange = false;
+	this._ignoreAllChanges = false;
+
+	mutation = new MutationObserver( ()=>this._docWasChanged() );
+	mutation.observe( root, {
+		childList: true,
+		attributes: true,
+		characterData: true,
+		subtree: true
+	});
+	this._mutation = mutation;
+
+	// On blur, restore focus except if the user taps or clicks to focus a
+	// specific point. Can't actually use click event because focus happens
+	// before click, so use mousedown/touchstart
+	this._restoreSelection = false;
+	// https://caniuse.com/mdn-api_document_pointerup_event
+	this.addEventListener( 'blur', () => this._restoreSelection = true )
+		.addEventListener( 'pointerdown mousedown touchstart', () => this._restoreSelection = false )
+		.addEventListener( 'focus', () => this._restoreSelection && this.setSelection( this._lastRange ) )
+		.addEventListener( 'cut', onCut )
+		.addEventListener( 'copy', onCopy )
+		.addEventListener( 'keydown keyup', monitorShiftKey )
+		.addEventListener( 'paste', onPaste )
+		.addEventListener( 'drop', onDrop )
+		.addEventListener( 'keydown', onKey )
+		.addEventListener( 'pointerup keyup mouseup touchend', ()=>this.getSelection() );
+
+	// Add key handlers
+	this._keyHandlers = Object.create( keyHandlers );
+
+	// Override default properties
+	this.setConfig( config );
+
+	root.setAttribute( 'contenteditable', 'true' );
+	// Grammarly breaks the editor, *sigh*
+	root.setAttribute( 'data-gramm', 'false' );
+
+	// Remove Firefox's built-in controls
+	try {
+		doc.execCommand( 'enableObjectResizing', false, 'false' );
+		doc.execCommand( 'enableInlineTableEditing', false, 'false' );
+	} catch ( error ) {}
+
+	root.__squire__ = this;
+
+	// Need to register instance before calling setHTML, so that the fixCursor
+	// function can lookup any default block tag options set.
+	this.setHTML( '' );
+}
+
+let proto = Squire.prototype;
+
+let sanitizeToDOMFragment = ( html ) => {
+	let frag = html ? win.DOMPurify.sanitize( html, {
+		ALLOW_UNKNOWN_PROTOCOLS: true,
+		WHOLE_DOCUMENT: false,
+		RETURN_DOM: true,
+		RETURN_DOM_FRAGMENT: true
+	}) : null;
+	return frag ? doc.importNode( frag, true ) : doc.createDocumentFragment();
+};
+
+proto.setConfig = function ( config ) {
+	config = mergeObjects({
+		blockTag: 'DIV',
+		blockAttributes: null,
+		tagAttributes: {
+			blockquote: null,
+			ul: null,
+			ol: null,
+			li: null,
+			a: null
+		},
+		classNames: {
+			colour: 'colour',
+			fontFamily: 'font',
+			fontSize: 'size',
+			highlight: 'highlight'
+		},
+		leafNodeNames: leafNodeNames,
+		undo: {
+			documentSizeThreshold: -1, // -1 means no threshold
+			undoLimit: -1 // -1 means no limit
+		},
+		isInsertedHTMLSanitized: true,
+		isSetHTMLSanitized: true,
+		sanitizeToDOMFragment: win.DOMPurify && win.DOMPurify.isSupported ? sanitizeToDOMFragment : null,
+		willCutCopy: null,
+		addLinks: true
+	}, config, true );
+
+	// Users may specify block tag in lower case
+	config.blockTag = config.blockTag.toUpperCase();
+
+	this._config = config;
+
+	return this;
+};
+
+proto.createElement = function ( tag, props, children ) {
+	return createElement( doc, tag, props, children );
+};
+
+proto.createDefaultBlock = function ( children ) {
+	let config = this._config;
+	return fixCursor(
+		this.createElement( config.blockTag, config.blockAttributes, children ),
+		this._root
+	);
+};
+
+proto.didError = error => console.error( error );
+
+proto.getRoot = function () {
+	return this._root;
+};
+
+proto.modifyDocument = function ( modificationCallback ) {
+	let mutation = this._mutation;
+	if ( mutation ) {
+		if ( mutation.takeRecords().length ) {
+			this._docWasChanged();
+		}
+		mutation.disconnect();
+	}
+
+	this._ignoreAllChanges = true;
+	modificationCallback();
+	this._ignoreAllChanges = false;
+
+	if ( mutation ) {
+		mutation.observe( this._root, {
+			childList: true,
+			attributes: true,
+			characterData: true,
+			subtree: true
+		});
+		this._ignoreChange = false;
+	}
+};
+
+// --- Events ---
+
+// Subscribing to these events won't automatically add a listener to the
+// document node, since these events are fired in a custom manner by the
+// editor code.
+let customEvents = {
+	pathChange: 1, select: 1, input: 1, undoStateChange: 1
+};
+
+proto.fireEvent = function ( type, event ) {
+	let handlers = this._events[ type ];
+	let isFocused, l, obj;
+	// UI code, especially modal views, may be monitoring for focus events and
+	// immediately removing focus. In certain conditions, this can cause the
+	// focus event to fire after the blur event, which can cause an infinite
+	// loop. So we detect whether we're actually focused/blurred before firing.
+	if ( /^(?:focus|blur)/.test( type ) ) {
+		isFocused = this._root === doc.activeElement;
+		if ( type === 'focus' ) {
+			if ( !isFocused || this._isFocused ) {
+				return this;
+			}
+			this._isFocused = true;
+		} else {
+			if ( isFocused || !this._isFocused ) {
+				return this;
+			}
+			this._isFocused = false;
+		}
+	}
+	if ( handlers ) {
+		if ( !event ) {
+			event = {};
+		}
+		if ( event.type !== type ) {
+			event.type = type;
+		}
+		// Clone handlers array, so any handlers added/removed do not affect it.
+		handlers = handlers.slice();
+		l = handlers.length;
+		while ( l-- ) {
+			obj = handlers[l];
+			try {
+				if ( obj.handleEvent ) {
+					obj.handleEvent( event );
+				} else {
+					obj.call( this, event );
+				}
+			} catch ( error ) {
+				error.details = 'Squire: fireEvent error. Event type: ' + type;
+				this.didError( error );
+			}
+		}
+	}
+	return this;
+};
+
+proto.destroy = function () {
+	let events = this._events;
+	let type;
+
+	for ( type in events ) {
+		this.removeEventListener( type );
+	}
+	if ( this._mutation ) {
+		this._mutation.disconnect();
+	}
+	delete this._root.__squire__;
+
+	// Destroy undo stack
+	this._undoIndex = -1;
+	this._undoStack = [];
+	this._undoStackLength = 0;
+};
+
+proto.handleEvent = function ( event ) {
+	this.fireEvent( event.type, event );
+};
+
+proto.addEventListener = function ( type, fn ) {
+	type.split(/\s+/).forEach(type=>{
+		let handlers = this._events[ type ],
+			target = this._root;
+		if ( !fn ) {
+			this.didError({
+				name: 'Squire: addEventListener with null or undefined fn',
+				message: 'Event type: ' + type
+			});
+			return this;
+		}
+		if ( !handlers ) {
+			handlers = this._events[ type ] = [];
+			if ( !customEvents[ type ] ) {
+				if ( type === 'selectionchange' ) {
+					target = doc;
+				}
+				target.addEventListener( type, this, true );
+			}
+		}
+		handlers.push( fn );
+	});
+	return this;
+};
+
+proto.removeEventListener = function ( type, fn ) {
+	let handlers = this._events[ type ];
+	let target = this._root;
+	let l;
+	if ( handlers ) {
+		if ( fn ) {
+			l = handlers.length;
+			while ( l-- ) {
+				if ( handlers[l] === fn ) {
+					handlers.splice( l, 1 );
+				}
+			}
+		} else {
+			handlers.length = 0;
+		}
+		if ( !handlers.length ) {
+			delete this._events[ type ];
+			if ( !customEvents[ type ] ) {
+				if ( type === 'selectionchange' ) {
+					target = doc;
+				}
+				target.removeEventListener( type, this, true );
+			}
+		}
+	}
+	return this;
+};
+
+// --- Selection and Path ---
+
+proto.createRange =
+		function ( range, startOffset, endContainer, endOffset ) {
+	if ( range instanceof win.Range ) {
+		return range.cloneRange();
+	}
+	let domRange = doc.createRange();
+	domRange.setStart( range, startOffset );
+	if ( endContainer ) {
+		domRange.setEnd( endContainer, endOffset );
+	} else {
+		domRange.setEnd( range, startOffset );
+	}
+	return domRange;
+};
+
+proto.getCursorPosition = function ( range ) {
+	if ( ( !range && !( range = this.getSelection() ) ) ||
+			!range.getBoundingClientRect ) {
+		return null;
+	}
+	// Get the bounding rect
+	let rect = range.getBoundingClientRect();
+	let node, parent;
+	if ( rect && !rect.top ) {
+		this._ignoreChange = true;
+		node = doc.createElement( 'SPAN' );
+		node.textContent = ZWS;
+		insertNodeInRange( range, node );
+		rect = node.getBoundingClientRect();
+		parent = node.parentNode;
+		parent.removeChild( node );
+		mergeInlines( parent, range );
+	}
+	return rect;
+};
+
+proto.setSelection = function ( range ) {
+	if ( range ) {
+		this._lastRange = range;
+		// If we're setting selection, that automatically, and synchronously, // triggers a focus event. So just store the selection and mark it as
+		// needing restore on focus.
+		if ( !this._isFocused ) {
+			this._restoreSelection = true;
+		} else {
+			// iOS bug: if you don't focus the iframe before setting the
+			// selection, you can end up in a state where you type but the input
+			// doesn't get directed into the contenteditable area but is instead
+			// lost in a black hole. Very strange.
+			if ( isIOS ) {
+				win.focus();
+			}
+			let sel = win.getSelection();
+			if ( sel && sel.setBaseAndExtent ) {
+				sel.setBaseAndExtent(
+					range.startContainer,
+					range.startOffset,
+					range.endContainer,
+					range.endOffset,
+				);
+			} else if ( sel ) {
+				// This is just for IE11
+				sel.removeAllRanges();
+				sel.addRange( range );
+			}
+		}
+	}
+	return this;
+};
+
+proto.getSelection = function () {
+	let sel = win.getSelection();
+	let root = this._root;
+	let range, startContainer, endContainer, node;
+	// If not focused, always rely on cached range; another function may
+	// have set it but the DOM is not modified until focus again
+	if ( this._isFocused && sel && sel.rangeCount ) {
+		range = sel.getRangeAt( 0 ).cloneRange();
+		startContainer = range.startContainer;
+		endContainer = range.endContainer;
+		// FF can return the range as being inside an <img>. WTF?
+		if ( startContainer && isLeaf( startContainer ) ) {
+			range.setStartBefore( startContainer );
+		}
+		if ( endContainer && isLeaf( endContainer ) ) {
+			range.setEndBefore( endContainer );
+		}
+	}
+	if ( range && root.contains( range.commonAncestorContainer ) ) {
+		this._lastRange = range;
+	} else {
+		range = this._lastRange;
+		node = range.commonAncestorContainer;
+		// Check the editor is in the live document; if not, the range has
+		// probably been rewritten by the browser and is bogus
+		if ( !doc.contains( node ) ) {
+			range = null;
+		}
+	}
+	return range || this.createRange( root.firstChild, 0 );
+};
+
+proto.getSelectionClosest = function (selector) {
+	let range = this.getSelection();
+	return range && getClosest(range.commonAncestorContainer, this._root, selector);
+};
+
+proto.selectionContains = function (selector) {
+	let range = this.getSelection(),
+		node = range && range.commonAncestorContainer;
+	if (node && !range.collapsed) {
+		node = node.querySelector ? node : node.parentElement;
+		// TODO: startContainer / endContainer for real selection match?
+		return !!(node && node.querySelector(selector));
+	}
+	return false;
+};
+
+proto.getSelectedText = function () {
+	let range = this.getSelection();
+	if ( !range || range.collapsed ) {
+		return '';
+	}
+	let walker = doc.createTreeWalker(
+		range.commonAncestorContainer,
+		SHOW_TEXT|SHOW_ELEMENT,
+		node => isNodeContainedInRange( range, node, true )
+	);
+	let startContainer = range.startContainer;
+	let endContainer = range.endContainer;
+	let node = walker.currentNode = startContainer;
+	let textContent = '';
+	let addedTextInBlock = false;
+	let value;
+
+	if ( !walker.filter( node ) ) {
+		node = walker.nextNode();
+	}
+
+	while ( node ) {
+		if ( node.nodeType === TEXT_NODE ) {
+			value = node.data;
+			if ( value && ( /\S/.test( value ) ) ) {
+				if ( node === endContainer ) {
+					value = value.slice( 0, range.endOffset );
+				}
+				if ( node === startContainer ) {
+					value = value.slice( range.startOffset );
+				}
+				textContent += value;
+				addedTextInBlock = true;
+			}
+		} else if ( node.nodeName === 'BR' ||
+				addedTextInBlock && !isInline( node ) ) {
+			textContent += '\n';
+			addedTextInBlock = false;
+		}
+		node = walker.nextNode();
+	}
+
+	return textContent;
+};
+
+proto.getPath = function () {
+	return this._path;
+};
+
+// --- Workaround for browsers that can't focus empty text nodes ---
+
+// WebKit bug: https://bugs.webkit.org/show_bug.cgi?id=15256
+
+// Walk down the tree starting at the root and remove any ZWS. If the node only
+// contained ZWS space then remove it too. We may want to keep one ZWS node at
+// the bottom of the tree so the block can be selected. Define that node as the
+// keepNode.
+let removeZWS = ( root, keepNode ) => {
+	let walker = doc.createTreeWalker( root, SHOW_TEXT );
+	let parent, node, index;
+	while ( node = walker.nextNode() ) {
+		while ( ( index = node.data.indexOf( ZWS ) ) > -1  &&
+				( !keepNode || node.parentNode !== keepNode ) ) {
+			if ( node.length === 1 ) {
+				do {
+					parent = node.parentNode;
+					parent.removeChild( node );
+					node = parent;
+					walker.currentNode = parent;
+				} while ( isInline( node ) && !getLength( node ) );
+				break;
+			} else {
+				node.deleteData( index, 1 );
+			}
+		}
+	}
+};
+
+proto._didAddZWS = function () {
+	this._hasZWS = true;
+};
+proto._removeZWS = function () {
+	if ( !this._hasZWS ) {
+		return;
+	}
+	removeZWS( this._root );
+	this._hasZWS = false;
+};
+
+// --- Path change events ---
+
+proto._updatePath = function ( range, force ) {
+	if ( !range ) {
+		return;
+	}
+	let anchor = range.startContainer,
+		focus = range.endContainer,
+		newPath;
+	if ( force || anchor !== this._lastAnchorNode ||
+			focus !== this._lastFocusNode ) {
+		this._lastAnchorNode = anchor;
+		this._lastFocusNode = focus;
+		newPath = ( anchor && focus ) ? ( anchor === focus ) ?
+			getPath( focus, this._root, this._config ) : '(selection)' : '';
+		if ( this._path !== newPath ) {
+			this._path = newPath;
+			this.fireEvent( 'pathChange', { path: newPath } );
+		}
+	}
+	this.fireEvent( range.collapsed ? 'cursor' : 'select', {
+		range: range
+	});
+};
+
+// --- Focus ---
+
+proto.focus = function () {
+	this._root.focus({ preventScroll: true });
+	return this;
+};
+
+proto.blur = function () {
+	this._root.blur();
+	return this;
+};
+
+// --- Bookmarking ---
+
+let startSelectionId = 'squire-selection-start';
+let endSelectionId = 'squire-selection-end';
+
+const createBookmarkNodes = self => [
+	self.createElement( 'INPUT', {
+		id: startSelectionId,
+		type: 'hidden'
+	}),
+	self.createElement( 'INPUT', {
+		id: endSelectionId,
+		type: 'hidden'
+	})
+];
+
+proto._saveRangeToBookmark = function ( range ) {
+	let [startNode, endNode] = createBookmarkNodes(this),
+		temp;
+
+	insertNodeInRange( range, startNode );
+	range.collapse( false );
+	insertNodeInRange( range, endNode );
+
+	// In a collapsed range, the start is sometimes inserted after the end!
+	if ( startNode.compareDocumentPosition( endNode ) &
+			DOCUMENT_POSITION_PRECEDING ) {
+		startNode.id = endSelectionId;
+		endNode.id = startSelectionId;
+		temp = startNode;
+		startNode = endNode;
+		endNode = temp;
+	}
+
+	range.setStartAfter( startNode );
+	range.setEndBefore( endNode );
+};
+
+proto._getRangeAndRemoveBookmark = function ( range ) {
+	let root = this._root,
+		start = root.querySelector( '#' + startSelectionId ),
+		end = root.querySelector( '#' + endSelectionId );
+
+	if ( start && end ) {
+		let startContainer = start.parentNode,
+			endContainer = end.parentNode,
+			startOffset = indexOf( startContainer.childNodes, start ),
+			endOffset = indexOf( endContainer.childNodes, end );
+
+		if ( startContainer === endContainer ) {
+			--endOffset;
+		}
+
+		start.remove();
+		end.remove();
+
+		if ( !range ) {
+			range = doc.createRange();
+		}
+		range.setStart( startContainer, startOffset );
+		range.setEnd( endContainer, endOffset );
+
+		// Merge any text nodes we split
+		mergeInlines( startContainer, range );
+		if ( startContainer !== endContainer ) {
+			mergeInlines( endContainer, range );
+		}
+
+		// If we didn't split a text node, we should move into any adjacent
+		// text node to current selection point
+		if ( range.collapsed ) {
+			startContainer = range.startContainer;
+			if ( startContainer.nodeType === TEXT_NODE ) {
+				endContainer = startContainer.childNodes[ range.startOffset ];
+				if ( !endContainer || endContainer.nodeType !== TEXT_NODE ) {
+					endContainer =
+						startContainer.childNodes[ range.startOffset - 1 ];
+				}
+				if ( endContainer && endContainer.nodeType === TEXT_NODE ) {
+					range.setStart( endContainer, 0 );
+					range.collapse( true );
+				}
+			}
+		}
+	}
+	return range || null;
+};
+
+// --- Undo ---
+
+proto._keyUpDetectChange = event => {
+	let code = event.keyCode;
+	// Presume document was changed if:
+	// 1. A modifier key (other than shift) wasn't held down
+	// 2. The key pressed is not in range 16<=x<=20 (control keys)
+	// 3. The key pressed is not in range 33<=x<=45 (navigation keys)
+	if ( !event[osKey] && !event.altKey &&
+			( code < 16 || code > 20 ) &&
+			( code < 33 || code > 45 ) ) {
+		this._docWasChanged();
+	}
+};
+
+proto._docWasChanged = function () {
+	nodeCategoryCache = new WeakMap();
+	if ( this._ignoreAllChanges ) {
+		return;
+	}
+
+	if ( this._ignoreChange ) {
+		this._ignoreChange = false;
+		return;
+	}
+	if ( this._isInUndoState ) {
+		this._isInUndoState = false;
+		this.fireEvent( 'undoStateChange', {
+			canUndo: true,
+			canRedo: false
+		});
+	}
+	this.fireEvent( 'input' );
+};
+
+// Leaves bookmark
+proto._recordUndoState = function ( range, replace ) {
+	// Don't record if we're already in an undo state
+	if ( !this._isInUndoState|| replace ) {
+		// Advance pointer to new position
+		let undoIndex = this._undoIndex;
+		let undoStack = this._undoStack;
+		let undoConfig = this._config.undo;
+		let undoThreshold = undoConfig.documentSizeThreshold;
+		let undoLimit = undoConfig.undoLimit;
+		let html;
+
+		if ( !replace ) {
+			++undoIndex;
+		}
+
+		// Truncate stack if longer (i.e. if has been previously undone)
+		if ( undoIndex < this._undoStackLength ) {
+			undoStack.length = this._undoStackLength = undoIndex;
+		}
+
+		// Get data
+		if ( range ) {
+			this._saveRangeToBookmark( range );
+		}
+		html = this._getHTML();
+
+		// If this document is above the configured size threshold,
+		// limit the number of saved undo states.
+		// Threshold is in bytes, JS uses 2 bytes per character
+		if ( undoThreshold > -1 && html.length * 2 > undoThreshold ) {
+			if ( undoLimit > -1 && undoIndex > undoLimit ) {
+				undoStack.splice( 0, undoIndex - undoLimit );
+				undoIndex = undoLimit;
+				this._undoStackLength = undoLimit;
+			}
+		}
+
+		// Save data
+		undoStack[ undoIndex ] = html;
+		this._undoIndex = undoIndex;
+		++this._undoStackLength;
+		this._isInUndoState = true;
+	}
+};
+
+proto.saveUndoState = function ( range ) {
+	if ( range === undefined ) {
+		range = this.getSelection();
+	}
+	this._recordUndoState( range, this._isInUndoState );
+	this._getRangeAndRemoveBookmark( range );
+
+	return this;
+};
+
+proto.undo = function () {
+	// Sanity check: must not be at beginning of the history stack
+	if ( this._undoIndex !== 0 || !this._isInUndoState ) {
+		// Make sure any changes since last checkpoint are saved.
+		this._recordUndoState( this.getSelection(), false );
+
+		--this._undoIndex;
+		this._setHTML( this._undoStack[ this._undoIndex ] );
+		let range = this._getRangeAndRemoveBookmark();
+		if ( range ) {
+			this.setSelection( range );
+		}
+		this._isInUndoState = true;
+		this.fireEvent( 'undoStateChange', {
+			canUndo: this._undoIndex !== 0,
+			canRedo: true
+		});
+		this.fireEvent( 'input' );
+	}
+	return this;
+};
+
+proto.redo = function () {
+	// Sanity check: must not be at end of stack and must be in an undo
+	// state.
+	let undoIndex = this._undoIndex,
+		undoStackLength = this._undoStackLength;
+	if ( undoIndex + 1 < undoStackLength && this._isInUndoState ) {
+		++this._undoIndex;
+		this._setHTML( this._undoStack[ this._undoIndex ] );
+		let range = this._getRangeAndRemoveBookmark();
+		if ( range ) {
+			this.setSelection( range );
+		}
+		this.fireEvent( 'undoStateChange', {
+			canUndo: true,
+			canRedo: undoIndex + 2 < undoStackLength
+		});
+		this.fireEvent( 'input' );
+	}
+	return this;
+};
+
+// --- Inline formatting ---
+
+// Looks for matching tag and attributes, so won't work
+// if <strong> instead of <b> etc.
+proto.hasFormat = function ( tag, attributes, range ) {
+	// 1. Normalise the arguments and get selection
+	tag = tag.toUpperCase();
+	if ( !attributes ) { attributes = {}; }
+	if ( !range && !( range = this.getSelection() ) ) {
+		return false;
+	}
+
+	// Sanitize range to prevent weird IE artifacts
+	if ( !range.collapsed &&
+			range.startContainer.nodeType === TEXT_NODE &&
+			range.startOffset === range.startContainer.length &&
+			range.startContainer.nextSibling ) {
+		range.setStartBefore( range.startContainer.nextSibling );
+	}
+	if ( !range.collapsed &&
+			range.endContainer.nodeType === TEXT_NODE &&
+			range.endOffset === 0 &&
+			range.endContainer.previousSibling ) {
+		range.setEndAfter( range.endContainer.previousSibling );
+	}
+
+	// If the common ancestor is inside the tag we require, we definitely
+	// have the format.
+	let root = this._root;
+	let common = range.commonAncestorContainer;
+	let walker, node;
+	if ( getNearest( common, root, tag, attributes ) ) {
+		return true;
+	}
+
+	// If common ancestor is a text node and doesn't have the format, we
+	// definitely don't have it.
+	if ( common.nodeType === TEXT_NODE ) {
+		return false;
+	}
+
+	// Otherwise, check each text node at least partially contained within
+	// the selection and make sure all of them have the format we want.
+	walker = doc.createTreeWalker( common, SHOW_TEXT, node => isNodeContainedInRange( range, node, true ) );
+
+	let seenNode = false;
+	while ( node = walker.nextNode() ) {
+		if ( !getNearest( node, root, tag, attributes ) ) {
+			return false;
+		}
+		seenNode = true;
+	}
+
+	return seenNode;
+};
+
+// Extracts the font-family and font-size (if any) of the element
+// holding the cursor. If there's a selection, returns an empty object.
+proto.getFontInfo = function ( range ) {
+	let fontInfo = {
+		color: undefined,
+		backgroundColor: undefined,
+		family: undefined,
+		size: undefined
+	};
+	let seenAttributes = 0;
+	let element, style, attr;
+
+	if ( !range && !( range = this.getSelection() ) ) {
+		return fontInfo;
+	}
+
+	element = range.commonAncestorContainer;
+	if ( range.collapsed || element.nodeType === TEXT_NODE ) {
+		if ( element.nodeType === TEXT_NODE ) {
+			element = element.parentNode;
+		}
+		while ( seenAttributes < 4 && element ) {
+			if ( style = element.style ) {
+				if ( !fontInfo.color && ( attr = style.color ) ) {
+					fontInfo.color = attr;
+					++seenAttributes;
+				}
+				if ( !fontInfo.backgroundColor &&
+						( attr = style.backgroundColor ) ) {
+					fontInfo.backgroundColor = attr;
+					++seenAttributes;
+				}
+				if ( !fontInfo.family && ( attr = style.fontFamily ) ) {
+					fontInfo.family = attr;
+					++seenAttributes;
+				}
+				if ( !fontInfo.size && ( attr = style.fontSize ) ) {
+					fontInfo.size = attr;
+					++seenAttributes;
+				}
+			}
+			element = element.parentNode;
+		}
+	}
+	return fontInfo;
+};
+
+proto._addFormat = function ( tag, attributes, range ) {
+	// If the range is collapsed we simply insert the node by wrapping
+	// it round the range and focus it.
+	let root = this._root;
+	let el, walker, startContainer, endContainer, startOffset, endOffset,
+		node, needsFormat, block;
+
+	if ( range.collapsed ) {
+		el = fixCursor( this.createElement( tag, attributes ), root );
+		insertNodeInRange( range, el );
+		range.setStart( el.firstChild, el.firstChild.length );
+		range.collapse( true );
+
+		// Clean up any previous formats that may have been set on this block
+		// that are unused.
+		block = el;
+		while ( isInline( block ) ) {
+			block = block.parentNode;
+		}
+		removeZWS( block, el );
+	}
+	// Otherwise we find all the textnodes in the range (splitting
+	// partially selected nodes) and if they're not already formatted
+	// correctly we wrap them in the appropriate tag.
+	else {
+		// Create an iterator to walk over all the text nodes under this
+		// ancestor which are in the range and not already formatted
+		// correctly.
+		//
+		// In Blink/WebKit, empty blocks may have no text nodes, just a <br>.
+		// Therefore we wrap this in the tag as well, as this will then cause it
+		// to apply when the user types something in the block, which is
+		// presumably what was intended.
+		//
+		// IMG tags are included because we may want to create a link around
+		// them, and adding other styles is harmless.
+		walker = doc.createTreeWalker(
+			range.commonAncestorContainer,
+			SHOW_TEXT|SHOW_ELEMENT,
+			node => ( node.nodeType === TEXT_NODE ||
+						node.nodeName === 'BR' ||
+						node.nodeName === 'IMG'
+					) && isNodeContainedInRange( range, node, true )
+		);
+
+		// Start at the beginning node of the range and iterate through
+		// all the nodes in the range that need formatting.
+		startContainer = range.startContainer;
+		startOffset = range.startOffset;
+		endContainer = range.endContainer;
+		endOffset = range.endOffset;
+
+		// Make sure we start with a valid node.
+		walker.currentNode = startContainer;
+		if ( !walker.filter( startContainer ) ) {
+			startContainer = walker.nextNode();
+			startOffset = 0;
+		}
+
+		// If there are no interesting nodes in the selection, abort
+		if ( !startContainer ) {
+			return range;
+		}
+
+		do {
+			node = walker.currentNode;
+			needsFormat = !getNearest( node, root, tag, attributes );
+			if ( needsFormat ) {
+				// <br> can never be a container node, so must have a text node
+				// if node == (end|start)Container
+				if ( node === endContainer && node.length > endOffset ) {
+					node.splitText( endOffset );
+				}
+				if ( node === startContainer && startOffset ) {
+					node = node.splitText( startOffset );
+					if ( endContainer === startContainer ) {
+						endContainer = node;
+						endOffset -= startOffset;
+					}
+					startContainer = node;
+					startOffset = 0;
+				}
+				el = this.createElement( tag, attributes );
+				node.replaceWith( el );
+				el.append( node );
+			}
+		} while ( walker.nextNode() );
+
+		// If we don't finish inside a text node, offset may have changed.
+		if ( endContainer.nodeType !== TEXT_NODE ) {
+			if ( node.nodeType === TEXT_NODE ) {
+				endContainer = node;
+				endOffset = node.length;
+			} else {
+				// If <br>, we must have just wrapped it, so it must have only
+				// one child
+				endContainer = node.parentNode;
+				endOffset = 1;
+			}
+		}
+
+		// Now set the selection to as it was before
+		range = this.createRange(
+			startContainer, startOffset, endContainer, endOffset );
+	}
+	return range;
+};
+
+proto._removeFormat = function ( tag, attributes, range, partial ) {
+	// Add bookmark
+	this._saveRangeToBookmark( range );
+
+	// We need a node in the selection to break the surrounding
+	// formatted text.
+	let fixer;
+	if ( range.collapsed ) {
+		if ( isWebKit ) {
+			fixer = doc.createTextNode( ZWS );
+			this._didAddZWS();
+		} else {
+			fixer = doc.createTextNode( '' );
+		}
+		insertNodeInRange( range, fixer );
+	}
+
+	// Find block-level ancestor of selection
+	let root = range.commonAncestorContainer;
+	while ( isInline( root ) ) {
+		root = root.parentNode;
+	}
+
+	// Find text nodes inside formatTags that are not in selection and
+	// add an extra tag with the same formatting.
+	let startContainer = range.startContainer,
+		startOffset = range.startOffset,
+		endContainer = range.endContainer,
+		endOffset = range.endOffset,
+		toWrap = [],
+		examineNode = function ( node, exemplar ) {
+			// If the node is completely contained by the range then
+			// we're going to remove all formatting so ignore it.
+			if ( isNodeContainedInRange( range, node, false ) ) {
+				return;
+			}
+
+			let isText = ( node.nodeType === TEXT_NODE ),
+				child, next;
+
+			// If not at least partially contained, wrap entire contents
+			// in a clone of the tag we're removing and we're done.
+			if ( !isNodeContainedInRange( range, node, true ) ) {
+				// Ignore bookmarks and empty text nodes
+				if ( node.nodeName !== 'INPUT' &&
+						( !isText || node.data ) ) {
+					toWrap.push([ exemplar, node ]);
+				}
+				return;
+			}
+
+			// Split any partially selected text nodes.
+			if ( isText ) {
+				if ( node === endContainer && endOffset !== node.length ) {
+					toWrap.push([ exemplar, node.splitText( endOffset ) ]);
+				}
+				if ( node === startContainer && startOffset ) {
+					node.splitText( startOffset );
+					toWrap.push([ exemplar, node ]);
+				}
+			}
+			// If not a text node, recurse onto all children.
+			// Beware, the tree may be rewritten with each call
+			// to examineNode, hence find the next sibling first.
+			else {
+				for ( child = node.firstChild; child; child = next ) {
+					next = child.nextSibling;
+					examineNode( child, exemplar );
+				}
+			}
+		},
+		formatTags = Array.prototype.filter.call(
+			root.getElementsByTagName( tag ), function ( el ) {
+				return isNodeContainedInRange( range, el, true ) &&
+					hasTagAttributes( el, tag, attributes );
+			}
+		);
+
+	if ( !partial ) {
+		formatTags.forEach( function ( node ) {
+			examineNode( node, node );
+		});
+	}
+
+	// Now wrap unselected nodes in the tag
+	toWrap.forEach( function ( item ) {
+		// [ exemplar, node ] tuple
+		let el = item[0].cloneNode( false ),
+			node = item[1];
+		node.replaceWith( el );
+		el.append( node );
+	});
+	// and remove old formatting tags.
+	formatTags.forEach( function ( el ) {
+		el.replaceWith( empty( el ) );
+	});
+
+	// Merge adjacent inlines:
+	this._getRangeAndRemoveBookmark( range );
+	if ( fixer ) {
+		range.collapse( false );
+	}
+	mergeInlines( root, range );
+
+	return range;
+};
+
+proto.changeFormat = function ( add, remove, range, partial ) {
+	// Normalise the arguments and get selection
+	if ( !range && !( range = this.getSelection() ) ) {
+		return this;
+	}
+
+	// Save undo checkpoint
+	this.saveUndoState( range );
+
+	if ( remove ) {
+		range = this._removeFormat( remove.tag.toUpperCase(),
+			remove.attributes || {}, range, partial );
+	}
+	if ( add ) {
+		range = this._addFormat( add.tag.toUpperCase(),
+			add.attributes || {}, range );
+	}
+
+	this.setSelection( range );
+	this._updatePath( range, true );
+
+	return this;
+};
+
+// --- Block formatting ---
+
+let tagAfterSplit = {
+	DT:  'DD',
+	DD:  'DT',
+	LI:  'LI',
+	PRE: 'PRE'
+};
+
+let splitBlock = ( self, block, node, offset ) => {
+	let splitTag = tagAfterSplit[ block.nodeName ],
+		splitProperties = null,
+		nodeAfterSplit = split( node, offset, block.parentNode, self._root ),
+		config = self._config;
+
+	if ( !splitTag ) {
+		splitTag = config.blockTag;
+		splitProperties = config.blockAttributes;
+	}
+
+	// Make sure the new node is the correct type.
+	if ( !hasTagAttributes( nodeAfterSplit, splitTag, splitProperties ) ) {
+		block = createElement( doc,
+			splitTag, splitProperties );
+		if ( nodeAfterSplit.dir ) {
+			block.dir = nodeAfterSplit.dir;
+		}
+		nodeAfterSplit.replaceWith( block );
+		block.append( empty( nodeAfterSplit ) );
+		nodeAfterSplit = block;
+	}
+	return nodeAfterSplit;
+};
+
+proto.forEachBlock = function ( fn, mutates, range ) {
+	if ( !range && !( range = this.getSelection() ) ) {
+		return this;
+	}
+
+	// Save undo checkpoint
+	if ( mutates ) {
+		this.saveUndoState( range );
+	}
+
+	let root = this._root;
+	let start = getStartBlockOfRange( range, root );
+	let end = getEndBlockOfRange( range, root );
+	if ( start && end ) {
+		do {
+			if ( fn( start ) || start === end ) { break; }
+		} while ( start = getNextBlock( start, root ) );
+	}
+
+	if ( mutates ) {
+		this.setSelection( range );
+
+		// Path may have changed
+		this._updatePath( range, true );
+	}
+	return this;
+};
+
+proto.modifyBlocks = function ( modify, range ) {
+	if ( !range && !( range = this.getSelection() ) ) {
+		return this;
+	}
+
+	// 1. Save undo checkpoint and bookmark selection
+	this._recordUndoState( range, this._isInUndoState );
+
+	let root = this._root;
+	let frag;
+
+	// 2. Expand range to block boundaries
+	expandRangeToBlockBoundaries( range, root );
+
+	// 3. Remove range.
+	moveRangeBoundariesUpTree( range, root, root, root );
+	frag = extractContentsOfRange( range, root, root );
+
+	// 4. Modify tree of fragment and reinsert.
+	insertNodeInRange( range, modify.call( this, frag ) );
+
+	// 5. Merge containers at edges
+	if ( range.endOffset < range.endContainer.childNodes.length ) {
+		mergeContainers( range.endContainer.childNodes[ range.endOffset ], root );
+	}
+	mergeContainers( range.startContainer.childNodes[ range.startOffset ], root );
+
+	// 6. Restore selection
+	this._getRangeAndRemoveBookmark( range );
+	this.setSelection( range );
+	this._updatePath( range, true );
+
+	return this;
+};
+
+let increaseBlockQuoteLevel = function ( frag ) {
+	return this.createElement( 'BLOCKQUOTE',
+		this._config.tagAttributes.blockquote, [
+			frag
+		]);
+};
+
+let decreaseBlockQuoteLevel = function ( frag ) {
+	var blockquotes = frag.querySelectorAll( 'blockquote' );
+	Array.prototype.filter.call( blockquotes, el =>
+		!getClosest( el.parentNode, frag, 'BLOCKQUOTE' )
+	).forEach( el => el.replaceWith( empty( el ) ) );
+	return frag;
+};
+
+let makeList = ( self, frag, type ) => {
+	let walker = getBlockWalker( frag, self._root ),
+		node, tag, prev, newLi,
+		tagAttributes = self._config.tagAttributes,
+		listAttrs = tagAttributes[ type.toLowerCase() ],
+		listItemAttrs = tagAttributes.li;
+
+	while ( node = walker.nextNode() ) {
+		if ( node.parentNode.nodeName === 'LI' ) {
+			node = node.parentNode;
+			walker.currentNode = node.lastChild;
+		}
+		if ( node.nodeName !== 'LI' ) {
+			newLi = self.createElement( 'LI', listItemAttrs );
+			if ( node.dir ) {
+				newLi.dir = node.dir;
+			}
+
+			// Have we replaced the previous block with a new <ul>/<ol>?
+			if ( ( prev = node.previousSibling ) && prev.nodeName === type ) {
+				prev.append( newLi );
+				node.remove();
+			}
+			// Otherwise, replace this block with the <ul>/<ol>
+			else {
+				node.replaceWith(
+					self.createElement( type, listAttrs, [
+						newLi
+					])
+				);
+			}
+			newLi.append( empty( node ) );
+			walker.currentNode = newLi;
+		} else {
+			node = node.parentNode;
+			tag = node.nodeName;
+			if ( tag !== type && ( /^[OU]L$/.test( tag ) ) ) {
+				node.replaceWith(
+					self.createElement( type, listAttrs, [ empty( node ) ] )
+				);
+			}
+		}
+	}
+};
+
+let makeUnorderedList = function ( frag ) {
+	makeList( this, frag, 'UL' );
+	return frag;
+};
+
+let makeOrderedList = function ( frag ) {
+	makeList( this, frag, 'OL' );
+	return frag;
+};
+
+let removeList = function ( frag ) {
+	let lists = frag.querySelectorAll( 'UL, OL' ),
+		items =  frag.querySelectorAll( 'LI' ),
+		root = this._root,
+		i, l, list, listFrag, item;
+	for ( i = 0, l = lists.length; i < l; ++i ) {
+		list = lists[i];
+		listFrag = empty( list );
+		fixContainer( listFrag, root );
+		list.replaceWith( listFrag );
+	}
+
+	for ( i = 0, l = items.length; i < l; ++i ) {
+		item = items[i];
+		if ( isBlock( item ) ) {
+			item.replaceWith(
+				this.createDefaultBlock([ empty( item ) ])
+			);
+		} else {
+			fixContainer( item, root );
+			item.replaceWith( empty( item ) );
+		}
+	}
+	return frag;
+};
+
+let getListSelection = ( range, root ) => {
+	// Get start+end li in single common ancestor
+	let list = range.commonAncestorContainer;
+	let startLi = range.startContainer;
+	let endLi = range.endContainer;
+	while ( list && list !== root && !/^[OU]L$/.test( list.nodeName ) ) {
+		list = list.parentNode;
+	}
+	if ( !list || list === root ) {
+		return null;
+	}
+	if ( startLi === list ) {
+		startLi = startLi.childNodes[ range.startOffset ];
+	}
+	if ( endLi === list ) {
+		endLi = endLi.childNodes[ range.endOffset ];
+	}
+	while ( startLi && startLi.parentNode !== list ) {
+		startLi = startLi.parentNode;
+	}
+	while ( endLi && endLi.parentNode !== list ) {
+		endLi = endLi.parentNode;
+	}
+	return [ list, startLi, endLi ];
+};
+
+proto.increaseListLevel = function ( range ) {
+	if ( !range && !( range = this.getSelection() ) ) {
+		return this.focus();
+	}
+
+	let root = this._root;
+	let listSelection = getListSelection( range, root );
+	if ( !listSelection ) {
+		return this.focus();
+	}
+
+	let list = listSelection[0];
+	let startLi = listSelection[1];
+	let endLi = listSelection[2];
+	if ( !startLi || startLi === list.firstChild ) {
+		return this.focus();
+	}
+
+	// Save undo checkpoint and bookmark selection
+	this._recordUndoState( range, this._isInUndoState );
+
+	// Increase list depth
+	let type = list.nodeName;
+	let newParent = startLi.previousSibling;
+	let listAttrs, next;
+	if ( newParent.nodeName !== type ) {
+		listAttrs = this._config.tagAttributes[ type.toLowerCase() ];
+		newParent = this.createElement( type, listAttrs );
+		startLi.before( newParent );
+	}
+	do {
+		next = startLi === endLi ? null : startLi.nextSibling;
+		newParent.append( startLi );
+	} while ( ( startLi = next ) );
+	next = newParent.nextSibling;
+	if ( next ) {
+		mergeContainers( next, root );
+	}
+
+	// Restore selection
+	this._getRangeAndRemoveBookmark( range );
+	this.setSelection( range );
+	this._updatePath( range, true );
+
+	return this.focus();
+};
+
+proto.decreaseListLevel = function ( range ) {
+	if ( !range && !( range = this.getSelection() ) ) {
+		return this.focus();
+	}
+
+	let root = this._root;
+	let listSelection = getListSelection( range, root );
+	if ( !listSelection ) {
+		return this.focus();
+	}
+
+	let list = listSelection[0];
+	let startLi = listSelection[1];
+	let endLi = listSelection[2];
+	let newParent, next, insertBefore, makeNotList;
+	if ( !startLi ) {
+		startLi = list.firstChild;
+	}
+	if ( !endLi ) {
+		endLi = list.lastChild;
+	}
+
+	// Save undo checkpoint and bookmark selection
+	this._recordUndoState( range, this._isInUndoState );
+
+	if ( startLi ) {
+		// Find the new parent list node
+		newParent = list.parentNode;
+
+		// Split list if necesary
+		insertBefore = !endLi.nextSibling ?
+			list.nextSibling :
+			split( list, endLi.nextSibling, newParent, root );
+
+		if ( newParent !== root && newParent.nodeName === 'LI' ) {
+			newParent = newParent.parentNode;
+			while ( insertBefore ) {
+				next = insertBefore.nextSibling;
+				endLi.append( insertBefore );
+				insertBefore = next;
+			}
+			insertBefore = list.parentNode.nextSibling;
+		}
+
+		makeNotList = !/^[OU]L$/.test( newParent.nodeName );
+		do {
+			next = startLi === endLi ? null : startLi.nextSibling;
+			list.removeChild( startLi );
+			if ( makeNotList && startLi.nodeName === 'LI' ) {
+				startLi = this.createDefaultBlock([ empty( startLi ) ]);
+			}
+			newParent.insertBefore( startLi, insertBefore );
+		} while (( startLi = next ));
+	}
+
+	if ( !list.firstChild ) {
+		list.remove();
+	}
+
+	if ( insertBefore ) {
+		mergeContainers( insertBefore, root );
+	}
+
+	// Restore selection
+	this._getRangeAndRemoveBookmark( range );
+	this.setSelection( range );
+	this._updatePath( range, true );
+
+	return this.focus();
+};
+
+proto._ensureBottomLine = function () {
+	let root = this._root;
+	let last = root.lastElementChild;
+	if ( !last ||
+			last.nodeName !== this._config.blockTag || !isBlock( last ) ) {
+		root.append( this.createDefaultBlock() );
+	}
+};
+
+// --- Keyboard interaction ---
+
+proto.setKeyHandler = function ( key, fn ) {
+	this._keyHandlers[ key ] = fn;
+	return this;
+};
+
+// --- Get/Set data ---
+
+proto._getHTML = function () {
+	return this._root.innerHTML;
+};
+
+proto._setHTML = function ( html ) {
+	let root = this._root;
+	let node = root;
+	node.innerHTML = html;
+	do {
+		fixCursor( node, root );
+	} while ( node = getNextBlock( node, root ) );
+	this._ignoreChange = true;
+};
+
+proto.getHTML = function ( withBookMark ) {
+	let html, range;
+	if ( withBookMark && ( range = this.getSelection() ) ) {
+		this._saveRangeToBookmark( range );
+	}
+	html = this._getHTML().replace( /\u200B/g, '' );
+	if ( range ) {
+		this._getRangeAndRemoveBookmark( range );
+	}
+	return html;
+};
+
+proto.setHTML = function ( html ) {
+	let config = this._config;
+	let sanitizeToDOMFragment = config.isSetHTMLSanitized ?
+			config.sanitizeToDOMFragment : null;
+	let root = this._root;
+	let div, frag, child;
+
+	// Parse HTML into DOM tree
+	if ( typeof sanitizeToDOMFragment === 'function' ) {
+		frag = sanitizeToDOMFragment( html, false, this );
+	} else {
+		div = this.createElement( 'DIV' );
+		div.innerHTML = html;
+		frag = doc.createDocumentFragment();
+		frag.append( empty( div ) );
+	}
+
+	cleanTree( frag, config );
+	cleanupBRs( frag, root, false );
+
+	fixContainer( frag, root );
+
+	// Fix cursor
+	let node = frag;
+	while ( node = getNextBlock( node, root ) ) {
+		fixCursor( node, root );
+	}
+
+	// Don't fire an input event
+	this._ignoreChange = true;
+
+	// Remove existing root children
+	while ( child = root.lastChild ) {
+		root.removeChild( child );
+	}
+
+	// And insert new content
+	root.append( frag );
+	fixCursor( root, root );
+
+	// Reset the undo stack
+	this._undoIndex = -1;
+	this._undoStack.length = 0;
+	this._undoStackLength = 0;
+	this._isInUndoState = false;
+
+	// Record undo state
+	let range = this._getRangeAndRemoveBookmark() ||
+		this.createRange( root.firstChild, 0 );
+	this.saveUndoState( range );
+	// IE will also set focus when selecting text so don't use
+	// setSelection. Instead, just store it in lastSelection, so if
+	// anything calls getSelection before first focus, we have a range
+	// to return.
+	this._lastRange = range;
+	this._restoreSelection = true;
+	this._updatePath( range, true );
+
+	return this;
+};
+
+proto.insertElement = function ( el, range ) {
+	if ( !range ) {
+		range = this.getSelection();
+	}
+	range.collapse( true );
+	if ( isInline( el ) ) {
+		insertNodeInRange( range, el );
+		range.setStartAfter( el );
+	} else {
+		// Get containing block node.
+		let root = this._root;
+		let splitNode = getStartBlockOfRange( range, root ) || root;
+		let parent, nodeAfterSplit;
+		// While at end of container node, move up DOM tree.
+		while ( splitNode !== root && !splitNode.nextSibling ) {
+			splitNode = splitNode.parentNode;
+		}
+		// If in the middle of a container node, split up to root.
+		if ( splitNode !== root ) {
+			parent = splitNode.parentNode;
+			nodeAfterSplit = split( parent, splitNode.nextSibling, root, root );
+		}
+		if ( nodeAfterSplit ) {
+			nodeAfterSplit.before( el );
+		} else {
+			root.append( el );
+			// Insert blank line below block.
+			nodeAfterSplit = this.createDefaultBlock();
+			root.append( nodeAfterSplit );
+		}
+		range.setStart( nodeAfterSplit, 0 );
+		range.setEnd( nodeAfterSplit, 0 );
+		moveRangeBoundariesDownTree( range );
+	}
+	this.focus();
+	this.setSelection( range );
+	this._updatePath( range );
+
+	return this;
+};
+
+proto.insertImage = function ( src, attributes ) {
+	let img = this.createElement( 'IMG', mergeObjects({
+		src: src
+	}, attributes, true ));
+	this.insertElement( img );
+	return img;
+};
+
+proto.linkRegExp = /\b(?:((?:(?:ht|f)tps?:\/\/|www\d{0,3}[.]|[a-z0-9][a-z0-9.-]*[.][a-z]{2,}\/)(?:[^\s()<>]+|\([^\s()<>]+\))+(?:[^\s?&`!()[\]{};:'".,<>«»“”‘’]|\([^\s()<>]+\)))|([\w\-.%+]+@(?:[\w-]+\.)+[a-z]{2,}\b(?:[?][^&?\s]+=[^\s?&`!()[\]{};:'".,<>«»“”‘’]+(?:&[^&?\s]+=[^\s?&`!()[\]{};:'".,<>«»“”‘’]+)*)?))/i;
+
+let addLinks = ( frag, root, self ) => {
+	let walker = doc.createTreeWalker( frag, SHOW_TEXT, node => !getClosest( node, root, 'A' ));
+	let linkRegExp = self.linkRegExp;
+	let defaultAttributes = self._config.tagAttributes.a;
+	let node, data, match, index, endIndex, child;
+	if ( !linkRegExp ) {
+		return;
+	}
+	while (( node = walker.nextNode() )) {
+		data = node.data;
+		while (( match = linkRegExp.exec( data ) )) {
+			index = match.index;
+			endIndex = index + match[0].length;
+			if ( index ) {
+				child = doc.createTextNode( data.slice( 0, index ) );
+				node.before( child );
+			}
+			child = self.createElement( 'A', mergeObjects({
+				href: match[1] ?
+					/^(?:ht|f)tps?:/i.test( match[1] ) ?
+						match[1] :
+						'http://' + match[1] :
+					'mailto:' + match[0]
+			}, defaultAttributes, false ));
+			child.textContent = data.slice( index, endIndex );
+			node.before( child );
+			node.data = data = data.slice( endIndex );
+		}
+	}
+};
+
+// Insert HTML at the cursor location. If the selection is not collapsed
+// insertTreeFragmentIntoRange will delete the selection so that it is replaced
+// by the html being inserted.
+proto.insertHTML = function ( html, isPaste ) {
+	let config = this._config;
+	let sanitizeToDOMFragment = config.isInsertedHTMLSanitized ?
+			config.sanitizeToDOMFragment : null;
+	let range = this.getSelection();
+	let startFragmentIndex, endFragmentIndex;
+	let div, frag, root, node, event;
+
+	// Edge doesn't just copy the fragment, but includes the surrounding guff
+	// including the full <head> of the page. Need to strip this out. If
+	// available use DOMPurify to parse and sanitise.
+	if ( typeof sanitizeToDOMFragment === 'function' ) {
+		frag = sanitizeToDOMFragment( html, isPaste, this );
+	} else {
+		if ( isPaste ) {
+			startFragmentIndex = html.indexOf( '<!--StartFragment-->' );
+			endFragmentIndex = html.lastIndexOf( '<!--EndFragment-->' );
+			if ( startFragmentIndex > -1 && endFragmentIndex > -1 ) {
+				html = html.slice( startFragmentIndex + 20, endFragmentIndex );
+			}
+		}
+		// Wrap with <tr> if html contains dangling <td> tags
+		if ( /<\/td>((?!<\/tr>)[\s\S])*$/i.test( html ) ) {
+			html = '<TR>' + html + '</TR>';
+		}
+		// Wrap with <table> if html contains dangling <tr> tags
+		if ( /<\/tr>((?!<\/table>)[\s\S])*$/i.test( html ) ) {
+			html = '<TABLE>' + html + '</TABLE>';
+		}
+		// Parse HTML into DOM tree
+		div = this.createElement( 'DIV' );
+		div.innerHTML = html;
+		frag = doc.createDocumentFragment();
+		frag.append( empty( div ) );
+	}
+
+	// Record undo checkpoint
+	this.saveUndoState( range );
+
+	try {
+		root = this._root;
+		node = frag;
+		event = {
+			fragment: frag,
+			preventDefault: function () {
+				this.defaultPrevented = true;
+			},
+			defaultPrevented: false
+		};
+
+		addLinks( frag, frag, this );
+		cleanTree( frag, config );
+		cleanupBRs( frag, root, false );
+		removeEmptyInlines( frag );
+		frag.normalize();
+
+		while ( node = getNextBlock( node, frag ) ) {
+			fixCursor( node, root );
+		}
+
+		if ( isPaste ) {
+			this.fireEvent( 'willPaste', event );
+		}
+
+		if ( !event.defaultPrevented ) {
+			insertTreeFragmentIntoRange( range, event.fragment, root );
+			range.collapse( false );
+
+			// After inserting the fragment, check whether the cursor is inside
+			// an <a> element and if so if there is an equivalent cursor
+			// position after the <a> element. If there is, move it there.
+			moveRangeBoundaryOutOf( range, 'A', root );
+
+			this._ensureBottomLine();
+		}
+
+		this.setSelection( range );
+		this._updatePath( range, true );
+		// Safari sometimes loses focus after paste. Weird.
+		if ( isPaste ) {
+			this.focus();
+		}
+	} catch ( error ) {
+		this.didError( error );
+	}
+	return this;
+};
+
+let escapeHTML = text => text.replace( '&', '&amp;' )
+   .replace( '<', '&lt;' )
+   .replace( '>', '&gt;' )
+   .replace( '"', '&quot;' );
+
+proto.insertPlainText = function ( plainText, isPaste ) {
+	let range = this.getSelection();
+	if ( range.collapsed &&
+			getClosest( range.startContainer, this._root, 'PRE' ) ) {
+		let node = range.startContainer;
+		let offset = range.startOffset;
+		let text, event;
+		if ( !node || node.nodeType !== TEXT_NODE ) {
+			text = doc.createTextNode( '' );
+			node.childNodes[ offset ].before( text );
+			node = text;
+			offset = 0;
+		}
+		event = {
+			text: plainText,
+			preventDefault: function () {
+				this.defaultPrevented = true;
+			},
+			defaultPrevented: false
+		};
+		if ( isPaste ) {
+			this.fireEvent( 'willPaste', event );
+		}
+
+		if ( !event.defaultPrevented ) {
+			plainText = event.text;
+			node.insertData( offset, plainText );
+			range.setStart( node, offset + plainText.length );
+			range.collapse( true );
+		}
+		this.setSelection( range );
+		return this;
+	}
+	let lines = plainText.split( '\n' );
+	let config = this._config;
+	let tag = config.blockTag;
+	let attributes = config.blockAttributes;
+	let closeBlock  = '</' + tag + '>';
+	let openBlock = '<' + tag;
+	let attr, i, l, line;
+
+	for ( attr in attributes ) {
+		openBlock += ' ' + attr + '="' +
+			escapeHTML( attributes[ attr ] ) +
+		'"';
+	}
+	openBlock += '>';
+
+	for ( i = 0, l = lines.length; i < l; ++i ) {
+		line = lines[i];
+		line = escapeHTML( line ).replace( / (?= )/g, '&nbsp;' );
+		// We don't wrap the first line in the block, so if it gets inserted
+		// into a blank line it keeps that line's formatting.
+		// Wrap each line in <div></div>
+		if ( i ) {
+			line = openBlock + ( line || '<BR>' ) + closeBlock;
+		}
+		lines[i] = line;
+	}
+	return this.insertHTML( lines.join( '' ), isPaste );
+};
+
+// --- Formatting ---
+
+let command = ( method, arg, arg2 ) => function () {
+	this[ method ]( arg, arg2 );
+	return this.focus();
+};
+
+proto.addStyles = function ( styles ) {
+	if ( styles ) {
+		let head = doc.documentElement.firstChild,
+			style = this.createElement( 'STYLE', {
+				type: 'text/css'
+			});
+		style.append( doc.createTextNode( styles ) );
+		head.append( style );
+	}
+	return this;
+};
+
+proto.bold = command( 'changeFormat', { tag: 'B' } );
+proto.italic = command( 'changeFormat', { tag: 'I' } );
+proto.underline = command( 'changeFormat', { tag: 'U' } );
+proto.strikethrough = command( 'changeFormat', { tag: 'S' } );
+proto.subscript = command( 'changeFormat', { tag: 'SUB' }, { tag: 'SUP' } );
+proto.superscript = command( 'changeFormat', { tag: 'SUP' }, { tag: 'SUB' } );
+
+proto.removeBold = command( 'changeFormat', null, { tag: 'B' } );
+proto.removeItalic = command( 'changeFormat', null, { tag: 'I' } );
+proto.removeUnderline = command( 'changeFormat', null, { tag: 'U' } );
+proto.removeStrikethrough = command( 'changeFormat', null, { tag: 'S' } );
+proto.removeSubscript = command( 'changeFormat', null, { tag: 'SUB' } );
+proto.removeSuperscript = command( 'changeFormat', null, { tag: 'SUP' } );
+
+proto.makeLink = function ( url, attributes ) {
+	let range = this.getSelection();
+	if ( range.collapsed ) {
+		let protocolEnd = url.indexOf( ':' ) + 1;
+		if ( protocolEnd ) {
+			while ( url[ protocolEnd ] === '/' ) { ++protocolEnd; }
+		}
+		insertNodeInRange(
+			range,
+			doc.createTextNode( url.slice( protocolEnd ) )
+		);
+	}
+	attributes = mergeObjects(
+		mergeObjects({
+			href: url
+		}, attributes, true ),
+		this._config.tagAttributes.a,
+		false
+	);
+
+	this.changeFormat({
+		tag: 'A',
+		attributes: attributes
+	}, {
+		tag: 'A'
+	}, range );
+	return this.focus();
+};
+proto.removeLink = function () {
+	this.changeFormat( null, {
+		tag: 'A'
+	}, this.getSelection(), true );
+	return this.focus();
+};
+
+proto.setFontFace = function ( name ) {
+	let className = this._config.classNames.fontFamily;
+	this.changeFormat( name ? {
+		tag: 'SPAN',
+		attributes: {
+			'class': className,
+			style: 'font-family: ' + name + ', sans-serif;'
+		}
+	} : null, {
+		tag: 'SPAN',
+		attributes: { 'class': className }
+	});
+	return this.focus();
+};
+proto.setFontSize = function ( size ) {
+	let className = this._config.classNames.fontSize;
+	this.changeFormat( size ? {
+		tag: 'SPAN',
+		attributes: {
+			'class': className,
+			style: 'font-size: ' +
+				( typeof size === 'number' ? size + 'px' : size )
+		}
+	} : null, {
+		tag: 'SPAN',
+		attributes: { 'class': className }
+	});
+	return this.focus();
+};
+
+proto.setTextColour = function ( colour ) {
+	let className = this._config.classNames.colour;
+	this.changeFormat( colour ? {
+		tag: 'SPAN',
+		attributes: {
+			'class': className,
+			style: 'color:' + colour
+		}
+	} : null, {
+		tag: 'SPAN',
+		attributes: { 'class': className }
+	});
+	return this.focus();
+};
+
+proto.setHighlightColour = function ( colour ) {
+	let className = this._config.classNames.highlight;
+	this.changeFormat( colour ? {
+		tag: 'SPAN',
+		attributes: {
+			'class': className,
+			style: 'background-color:' + colour
+		}
+	} : colour, {
+		tag: 'SPAN',
+		attributes: { 'class': className }
+	});
+	return this.focus();
+};
+
+proto.setTextAlignment = function ( alignment ) {
+	this.forEachBlock( function ( block ) {
+		let className = block.className
+			.split( /\s+/ )
+			.filter( function ( klass ) {
+				return !!klass && !/^align/.test( klass );
+			})
+			.join( ' ' );
+		if ( alignment ) {
+			block.className = className + ' align-' + alignment;
+			block.style.textAlign = alignment;
+		} else {
+			block.className = className;
+			block.style.textAlign = '';
+		}
+	}, true );
+	return this.focus();
+};
+
+proto.setTextDirection = function ( direction ) {
+	this.forEachBlock( function ( block ) {
+		if ( direction ) {
+			block.dir = direction;
+		} else {
+			block.removeAttribute( 'dir' );
+		}
+	}, true );
+	return this.focus();
+};
+
+// ---
+
+let addPre = function ( frag ) {
+	let root = this._root;
+	let output = doc.createDocumentFragment();
+	let walker = getBlockWalker( frag, root );
+	let node;
+	// 1. Extract inline content; drop all blocks and contains.
+	while (( node = walker.nextNode() )) {
+		// 2. Replace <br> with \n in content
+		let nodes = node.querySelectorAll( 'BR' );
+		let brBreaksLine = [];
+		let l = nodes.length;
+		let i, br;
+
+		// Must calculate whether the <br> breaks a line first, because if we
+		// have two <br>s next to each other, after the first one is converted
+		// to a block split, the second will be at the end of a block and
+		// therefore seem to not be a line break. But in its original context it
+		// was, so we should also convert it to a block split.
+		for ( i = 0; i < l; ++i ) {
+			brBreaksLine[i] = isLineBreak( nodes[i], false );
+		}
+		while ( l-- ) {
+			br = nodes[l];
+			if ( !brBreaksLine[l] ) {
+				br.remove();
+			} else {
+				br.replaceWith( doc.createTextNode( '\n' ) );
+			}
+		}
+		// 3. Remove <code>; its format clashes with <pre>
+		nodes = node.querySelectorAll( 'CODE' );
+		l = nodes.length;
+		while ( l-- ) {
+			nodes[l].remove();
+		}
+		if ( output.childNodes.length ) {
+			output.append( doc.createTextNode( '\n' ) );
+		}
+		output.append( empty( node ) );
+	}
+	// 4. Replace nbsp with regular sp
+	walker = doc.createTreeWalker( output, SHOW_TEXT );
+	while (( node = walker.nextNode() )) {
+		node.data = node.data.replace( NBSP, ' ' ); // nbsp -> sp
+	}
+	output.normalize();
+	return fixCursor( this.createElement( 'PRE',
+		this._config.tagAttributes.pre, [
+			output
+		]), root );
+};
+
+let removePre = function ( frag ) {
+	let root = this._root;
+	let pres = frag.querySelectorAll( 'PRE' );
+	let l = pres.length;
+	let pre, walker, node, value, contents, index;
+	while ( l-- ) {
+		pre = pres[l];
+		walker = doc.createTreeWalker( pre, SHOW_TEXT );
+		while (( node = walker.nextNode() )) {
+			value = node.data;
+			value = value.replace( / (?= )/g, NBSP ); // sp -> nbsp
+			contents = doc.createDocumentFragment();
+			while (( index = value.indexOf( '\n' ) ) > -1 ) {
+				contents.append(
+					doc.createTextNode( value.slice( 0, index ) )
+				);
+				contents.append( doc.createElement( 'BR' ) );
+				value = value.slice( index + 1 );
+			}
+			node.before( contents );
+			node.data = value;
+		}
+		fixContainer( pre, root );
+		pre.replaceWith( empty( pre ) );
+	}
+	return frag;
+};
+
+proto.code = function () {
+	let range = this.getSelection();
+	if ( range.collapsed || isContainer( range.commonAncestorContainer ) ) {
+		this.modifyBlocks( addPre, range );
+	} else {
+		this.changeFormat({
+			tag: 'CODE',
+			attributes: this._config.tagAttributes.code
+		}, null, range );
+	}
+	return this.focus();
+};
+
+proto.removeCode = function () {
+	let range = this.getSelection();
+	let ancestor = range.commonAncestorContainer;
+	let inPre = getClosest( ancestor, this._root, 'PRE' );
+	if ( inPre ) {
+		this.modifyBlocks( removePre, range );
+	} else {
+		this.changeFormat( null, { tag: 'CODE' }, range );
+	}
+	return this.focus();
+};
+
+proto.toggleCode = function () {
+	if ( this.hasFormat( 'PRE' ) || this.hasFormat( 'CODE' ) ) {
+		this.removeCode();
+	} else {
+		this.code();
+	}
+	return this;
+};
+
+// ---
+
+function removeFormatting ( self, root, clean ) {
+	let node, next;
+	for ( node = root.firstChild; node; node = next ) {
+		next = node.nextSibling;
+		if ( isInline( node ) ) {
+			if ( node.nodeType === TEXT_NODE || node.nodeName === 'BR' || node.nodeName === 'IMG' ) {
+				clean.append( node );
+				continue;
+			}
+		} else if ( isBlock( node ) ) {
+			clean.append( self.createDefaultBlock([
+				removeFormatting(
+					self, node, doc.createDocumentFragment() )
+			]));
+			continue;
+		}
+		removeFormatting( self, node, clean );
+	}
+	return clean;
+}
+
+proto.removeAllFormatting = function ( range ) {
+	if ( !range && !( range = this.getSelection() ) || range.collapsed ) {
+		return this;
+	}
+
+	let root = this._root;
+	let stopNode = range.commonAncestorContainer;
+	while ( stopNode && !isBlock( stopNode ) ) {
+		stopNode = stopNode.parentNode;
+	}
+	if ( !stopNode ) {
+		expandRangeToBlockBoundaries( range, root );
+		stopNode = root;
+	}
+	if ( stopNode.nodeType === TEXT_NODE ) {
+		return this;
+	}
+
+	// Record undo point
+	this.saveUndoState( range );
+
+	// Avoid splitting where we're already at edges.
+	moveRangeBoundariesUpTree( range, stopNode, stopNode, root );
+
+	// Split the selection up to the block, or if whole selection in same
+	// block, expand range boundaries to ends of block and split up to root.
+	let startContainer = range.startContainer;
+	let startOffset = range.startOffset;
+	let endContainer = range.endContainer;
+	let endOffset = range.endOffset;
+
+	// Split end point first to avoid problems when end and start
+	// in same container.
+	let formattedNodes = doc.createDocumentFragment();
+	let cleanNodes = doc.createDocumentFragment();
+	let nodeAfterSplit = split( endContainer, endOffset, stopNode, root );
+	let nodeInSplit = split( startContainer, startOffset, stopNode, root );
+	let nextNode, childNodes;
+
+	// Then replace contents in split with a cleaned version of the same:
+	// blocks become default blocks, text and leaf nodes survive, everything
+	// else is obliterated.
+	while ( nodeInSplit !== nodeAfterSplit ) {
+		nextNode = nodeInSplit.nextSibling;
+		formattedNodes.append( nodeInSplit );
+		nodeInSplit = nextNode;
+	}
+	removeFormatting( this, formattedNodes, cleanNodes );
+	cleanNodes.normalize();
+	nodeInSplit = cleanNodes.firstChild;
+	nextNode = cleanNodes.lastChild;
+
+	// Restore selection
+	childNodes = stopNode.childNodes;
+	if ( nodeInSplit ) {
+		nodeAfterSplit.before( cleanNodes );
+		startOffset = indexOf( childNodes, nodeInSplit );
+		endOffset = indexOf( childNodes, nextNode ) + 1;
+	} else {
+		startOffset = indexOf( childNodes, nodeAfterSplit );
+		endOffset = startOffset;
+	}
+
+	// Merge text nodes at edges, if possible
+	range.setStart( stopNode, startOffset );
+	range.setEnd( stopNode, endOffset );
+	mergeInlines( stopNode, range );
+
+	// And move back down the tree
+	moveRangeBoundariesDownTree( range );
+
+	this.setSelection( range );
+	this._updatePath( range, true );
+
+	return this.focus();
+};
+
+proto.increaseQuoteLevel = command( 'modifyBlocks', increaseBlockQuoteLevel );
+proto.decreaseQuoteLevel = command( 'modifyBlocks', decreaseBlockQuoteLevel );
+
+proto.changeIndentationLevel = function (direction) {
+	let parent = this.getSelectionClosest('UL,OL,BLOCKQUOTE');
+	if (parent || 'increase' === direction) {
+		let method = ( !parent || 'BLOCKQUOTE' === parent.nodeName ) ? 'Quote' : 'List';
+		this[ direction + method + 'Level' ]();
+	}
+};
+
+proto.makeUnorderedList = command( 'modifyBlocks', makeUnorderedList );
+proto.makeOrderedList = command( 'modifyBlocks', makeOrderedList );
+proto.removeList = command( 'modifyBlocks', removeList );
+
+win.Squire = Squire;
+
+})( document );
diff --git a/vendors/squire/build/squire.js b/vendors/squire/build/squire.js
new file mode 100644
index 000000000..8e499e707
--- /dev/null
+++ b/vendors/squire/build/squire.js
@@ -0,0 +1 @@
+(e=>{"use strict";const t=3,n=9,o=e.defaultView,i=navigator.userAgent,r=/Mac OS X/.test(i),s=/Windows NT/.test(i),a=/iP(?:ad|hone|od)/.test(i)||r&&!!navigator.maxTouchPoints,l=/Gecko\//.test(i),d=/Edge\//.test(i),c=!d&&/WebKit\//.test(i),h=r?"meta-":"ctrl-",f=r?"metaKey":"ctrlKey",u=/[^ \t\r\n]/,p=(e,t)=>Array.prototype.indexOf.call(e,t),g={1:1,2:2,3:4,8:128,9:256,11:1024},m=/^(?:#text|A|ABBR|ACRONYM|B|BR|BDI|BDO|CITE|CODE|DATA|DEL|DFN|EM|FONT|HR|IMG|INPUT|INS|KBD|Q|RP|RT|RUBY|SAMP|SMALL|SPAN|STRIKE|STRONG|SUB|SUP|TIME|U|VAR|WBR)$/,S={BR:1,HR:1,IMG:1},N=e=>1===e.nodeType&&!!S[e.nodeName],_=e=>{switch(e.nodeType){case t:return 1;case 1:case 11:if(ie.has(e))return ie.get(e);break;default:return 0}let n;return n=Array.prototype.every.call(e.childNodes,C)?m.test(e.nodeName)?1:2:3,ie.set(e,n),n},C=e=>1===_(e),v=e=>2===_(e),T=e=>3===_(e),y=(t,n)=>{let o=e.createTreeWalker(n,1,v);return o.currentNode=t,o},E=(e,t)=>(e=y(e,t).previousNode())!==t?e:null,L=(e,t)=>(e=y(e,t).nextNode())!==t?e:null,b=e=>!e.textContent&&!e.querySelector("IMG"),k=(e,t)=>!N(e)&&e.nodeType===t.nodeType&&e.nodeName===t.nodeName&&"A"!==e.nodeName&&e.className===t.className&&(!e.style&&!t.style||e.style.cssText===t.style.cssText),O=(e,t,n)=>{if(e.nodeName!==t)return!1;for(let t in n)if(e.getAttribute(t)!==n[t])return!1;return!0},x=(e,t,n)=>(e=(e=!e||e.closest?e:e.parentElement)&&e.closest(n))&&t.contains(e)?e:null,A=(e,t,n,o)=>{for(;e&&e!==t;){if(O(e,n,o))return e;e=e.parentNode}return null},R=(e,t,n)=>{let o,i,r,s,a,l="";return e&&e!==t&&(l=R(e.parentNode,t,n),1===e.nodeType&&(l+=(l?">":"")+e.nodeName,(o=e.id)&&(l+="#"+o),(i=e.className.trim())&&((r=i.split(/\s+/)).sort(),l+=".",l+=r.join(".")),(s=e.dir)&&(l+="[dir="+s+"]"),r&&(a=n.classNames,p(r,a.highlight)>-1&&(l+="[backgroundColor="+e.style.backgroundColor.replace(/ /g,"")+"]"),p(r,a.colour)>-1&&(l+="[color="+e.style.color.replace(/ /g,"")+"]"),p(r,a.fontFamily)>-1&&(l+="[fontFamily="+e.style.fontFamily.replace(/ /g,"")+"]"),p(r,a.fontSize)>-1&&(l+="[fontSize="+e.style.fontSize+"]")))),l},B=e=>{let t=e.nodeType;return 1===t||11===t?e.childNodes.length:e.length||0},D=t=>{let n=e.createDocumentFragment(),o=t.childNodes;return o&&n.append(...o),n},U=(e,t,n,o)=>{let i,r,s=e.createElement(t);if(n instanceof Array&&(o=n,n=null),n)for(i in n)void 0!==(r=n[i])&&s.setAttribute(i,r);return o&&s.append(...o),s},P=(n,o)=>{let i,r,s=o.__squire__,a=n;if(n===o&&((r=n.firstChild)&&"BR"!==r.nodeName||(i=s.createDefaultBlock(),r?r.replaceWith(i):n.append(i),n=i,i=null)),n.nodeType===t)return a;if(C(n)){for(r=n.firstChild;c&&r&&r.nodeType===t&&!r.data;)n.removeChild(r),r=n.firstChild;r||(c?(i=e.createTextNode("​"),s._didAddZWS()):i=e.createTextNode(""))}else if(!n.querySelector("BR"))for(i=U(e,"BR");(r=n.lastElementChild)&&!C(r);)n=r;if(i)try{n.append(i)}catch(e){s.didError({name:"Squire: fixCursor – "+e,message:"Parent: "+n.nodeName+"/"+n.innerHTML+" appendChild: "+i.nodeName})}return a},I=(t,n)=>{let o,i,r,s,a=t.childNodes,l=null;for(o=0,i=a.length;o<i;++o)!(s="BR"===(r=a[o]).nodeName)&&C(r)?(l||(l=U(e,"div")),l.append(r),--o,--i):(s||l)&&(l||(l=U(e,"div")),P(l,n),s?r.replaceWith(l):(r.before(l),++o,++i),l=null),T(r)&&I(r,n);return l&&t.append(P(l,n)),t},F=(e,n,o,i)=>{let r,s,a,l=e.nodeType;if(l===t&&e!==o)return F(e.parentNode,e.splitText(n),o,i);if(1===l){if("number"==typeof n&&(n=n<e.childNodes.length?e.childNodes[n]:null),e===o)return n;for(r=e.parentNode,s=e.cloneNode(!1);n;)a=n.nextSibling,s.append(n),n=a;return"OL"===e.nodeName&&x(e,i,"BLOCKQUOTE")&&(s.start=(+e.start||1)+e.childNodes.length-1),P(e,i),P(s,i),e.after(s),F(r,s,o,i)}return n},W=(e,n)=>{let o,i,r=e.childNodes,s=r.length,a=[];for(;s--;)o=r[s],i=s&&r[s-1],s&&C(o)&&k(o,i)&&!S[o.nodeName]?(n.startContainer===o&&(n.startContainer=i,n.startOffset+=B(i)),n.endContainer===o&&(n.endContainer=i,n.endOffset+=B(i)),n.startContainer===e&&(n.startOffset>s?--n.startOffset:n.startOffset===s&&(n.startContainer=i,n.startOffset=B(i))),n.endContainer===e&&(n.endOffset>s?--n.endOffset:n.endOffset===s&&(n.endContainer=i,n.endOffset=B(i))),o.remove(),o.nodeType===t?i.appendData(o.data):a.push(D(o))):1===o.nodeType&&(o.append(...a.reverse()),a=[],W(o,n))},M=(e,n)=>{if(e.nodeType===t&&(e=e.parentNode),1===e.nodeType){let t={startContainer:n.startContainer,startOffset:n.startOffset,endContainer:n.endContainer,endOffset:n.endOffset};W(e,t),n.setStart(t.startContainer,t.startOffset),n.setEnd(t.endContainer,t.endOffset)}},w=(e,t,n,o)=>{let i,r,s,a=t;for(;(i=a.parentNode)&&i!==o&&1===i.nodeType&&1===i.childNodes.length;)a=i;a.remove(),s=e.childNodes.length,(r=e.lastChild)&&"BR"===r.nodeName&&(e.removeChild(r),--s),e.append(D(t)),n.setStart(e,s),n.collapse(!0),M(e,n)},H=(t,n)=>{let o,i,r=t.previousSibling,s=t.firstChild,a="LI"===t.nodeName;if(!a||s&&/^[OU]L$/.test(s.nodeName))if(r&&k(r,t)){if(!T(r)){if(!a)return;(i=U(e,"DIV")).append(D(r)),r.append(i)}t.remove(),o=!T(t),r.append(D(t)),o&&I(r,n),s&&H(s,n)}else a&&(r=U(e,"DIV"),s.before(r),P(r,n))},z=(e,t)=>{let n=e.childNodes;for(;t&&1===e.nodeType;)t=(n=(e=n[t-1]).childNodes).length;return e},q=(e,t)=>{if(1===e.nodeType){let n=e.childNodes;if(t<n.length)e=n[t];else{for(;e&&!e.nextSibling;)e=e.parentNode;e&&(e=e.nextSibling)}}return e},K=(e,n)=>{let o,i,r,s,a=e.startContainer,l=e.startOffset,d=e.endContainer,c=e.endOffset;a.nodeType===t?(i=(o=a.parentNode).childNodes,l===a.length?(l=p(i,a)+1,e.collapsed&&(d=o,c=l)):(l&&(s=a.splitText(l),d===a?(c-=l,d=s):d===o&&++c,a=s),l=p(i,a)),a=o):i=a.childNodes,l===(r=i.length)?a.append(n):i[l].before(n),a===d&&(c+=i.length-r),e.setStart(a,l),e.setEnd(d,c)},G=(n,o,i)=>{let r=n.startContainer,s=n.startOffset,a=n.endContainer,l=n.endOffset;o||(o=n.commonAncestorContainer),o.nodeType===t&&(o=o.parentNode);let d,c,h,f,u,g=F(a,l,o,i),m=F(r,s,o,i),S=e.createDocumentFragment();for(;m!==g;)d=m.nextSibling,S.append(m),m=d;return r=o,s=g?p(o.childNodes,g):o.childNodes.length,(c=(h=o.childNodes[s])&&h.previousSibling)&&c.nodeType===t&&h.nodeType===t&&(r=c,s=c.length,f=c.data,u=h.data," "===f.charAt(f.length-1)&&" "===u.charAt(0)&&(u=" "+u.slice(1)),c.appendData(u),h.remove()),n.setStart(r,s),n.collapse(!0),P(o,i),S},Q=(e,t)=>{let n,o,i=Y(e,t),r=X(e,t),s=i!==r;return $(e),V(e,i,r,t),n=G(e,null,t),$(e),s&&(r=X(e,t),i&&r&&i!==r&&w(i,r,e,t)),i&&P(i,t),(o=t.firstChild)&&"BR"!==o.nodeName?e.collapse(!0):(P(t,t),e.selectNodeContents(t.firstChild)),n},Z=(t,n,o)=>{let i=e.createRange();if(i.selectNode(n),o){let e=t.compareBoundaryPoints(3,i)>-1,n=t.compareBoundaryPoints(1,i)<1;return!e&&!n}{let e=t.compareBoundaryPoints(0,i)<1,n=t.compareBoundaryPoints(2,i)>-1;return e&&n}},$=e=>{let n,o=e.startContainer,i=e.startOffset,r=e.endContainer,s=e.endOffset,a=!0;for(;o.nodeType!==t&&(n=o.childNodes[i])&&!N(n);)o=n,i=0;if(s)for(;r.nodeType!==t;){if(!(n=r.childNodes[s-1])||N(n)){if(a&&n&&"BR"===n.nodeName){--s,a=!1;continue}break}s=B(r=n)}else for(;r.nodeType!==t&&(n=r.firstChild)&&!N(n);)r=n;e.collapsed?(e.setStart(r,s),e.setEnd(o,i)):(e.setStart(o,i),e.setEnd(r,s))},V=(e,n,o,i)=>{let r,s=e.startContainer,a=e.startOffset,l=e.endContainer,d=e.endOffset,c=!0;for(n||(n=e.commonAncestorContainer),o||(o=n);!a&&s!==n&&s!==i;)r=s.parentNode,a=p(r.childNodes,s),s=r;for(;l!==o&&l!==i&&(c&&l.nodeType!==t&&l.childNodes[d]&&"BR"===l.childNodes[d].nodeName&&(++d,c=!1),d===B(l));)r=l.parentNode,d=p(r.childNodes,l)+1,l=r;e.setStart(s,a),e.setEnd(l,d)},j=(e,t,n)=>{let o=x(e.endContainer,n,"A");if(o){let t=e.cloneRange();o=o.parentNode,V(t,o,o,n),t.endContainer===o&&(e.setStart(t.endContainer,t.endOffset),e.setEnd(t.endContainer,t.endOffset))}return e},Y=(e,t)=>{let n,o=e.startContainer;return C(o)?n=E(o,t):o!==t&&v(o)?n=o:(n=z(o,e.startOffset),n=L(n,t)),n&&Z(e,n,!0)?n:null},X=(e,t)=>{let n,o,i=e.endContainer;if(C(i))n=E(i,t);else if(i!==t&&v(i))n=i;else{if(!(n=q(i,e.endOffset))||!t.contains(n))for(n=t;o=n.lastChild;)n=o;n=E(n,t)}return n&&Z(e,n,!0)?n:null},J=n=>e.createTreeWalker(n,5,e=>e.nodeType===t?u.test(e.data):"IMG"===e.nodeName),ee=(e,n)=>{let o,i=e.startContainer,r=e.startOffset;if(i.nodeType===t){if(r)return!1;o=i}else if((o=q(i,r))&&!n.contains(o)&&(o=null),!o&&(o=z(i,r)).nodeType===t&&o.length)return!1;return(oe=J(Y(e,n))).currentNode=o,!oe.previousNode()},te=(e,n)=>{let o,i=e.endContainer,r=e.endOffset;if(oe=J(Y(e,n)),i.nodeType===t){if((o=i.data.length)&&r<o)return!1;oe.currentNode=i}else oe.currentNode=z(i,r);return!oe.nextNode()},ne=(e,t)=>{let n,o=Y(e,t),i=X(e,t);o&&i&&(n=o.parentNode,e.setStart(n,p(n.childNodes,o)),n=i.parentNode,e.setEnd(n,p(n.childNodes,i)+1))};let oe,ie=new WeakMap;TreeWalker.prototype.previousPONode=function(){let e,t=this.currentNode,n=this.root,o=this.nodeType,i=this.filter;for(;;){for(e=t.lastChild;!e&&t&&t!==n;)(e=t.previousSibling)||(t=t.parentNode);if(!e)return null;if(g[e.nodeType]&o&&i(e))return this.currentNode=e,e;t=e}};let re=function(e){if(e.defaultPrevented)return;let t=e.key.toLowerCase(),n="",o=this.getSelection();"backspace"!==t&&"delete"!==t&&(e.altKey&&(n+="alt-"),e[f]&&(n+=h),e.shiftKey&&(n+="shift-")),s&&e.shiftKey&&"delete"===t&&(n+="shift-"),t=n+t,this._keyHandlers[t]?this._keyHandlers[t](this,e,o):o.collapsed||e.isComposing||e[f]||1!==t.length||(this.saveUndoState(o),Q(o,this._root),this._ensureBottomLine(),this.setSelection(o),this._updatePath(o,!0))},se=e=>(t,n)=>{n.preventDefault(),t[e]()},ae=(e,t)=>(t=t||null,(n,o)=>{o.preventDefault();let i=n.getSelection();n.hasFormat(e,null,i)?n.changeFormat(null,{tag:e},i):n.changeFormat({tag:e},t,i)}),le=(e,n)=>{try{n||(n=e.getSelection());let o,i=n.startContainer;for(i.nodeType===t&&(i=i.parentNode),o=i;C(o)&&(!o.textContent||"​"===o.textContent);)o=(i=o).parentNode;i!==o&&(n.setStart(o,p(o.childNodes,i)),n.collapse(!0),o.removeChild(i),v(o)||(o=E(o,e._root)),P(o,e._root),$(n)),i===e._root&&(i=i.firstChild)&&"BR"===i.nodeName&&i.remove(),e._ensureBottomLine(),e.setSelection(n),e._updatePath(n,!0)}catch(t){e.didError(t)}},de=(e,t)=>{let n;for(;(n=e.parentNode)&&n!==t&&!n.isContentEditable;)e=n;e.remove()},ce=(n,o,i)=>{let r,s,a,l,d,c=n._root;if(n._recordUndoState(i),n._config.addLinks&&Ke(i.startContainer,c,n),n._removeZWS(),n._getRangeAndRemoveBookmark(i),i.collapsed||Q(i,c),(r=Y(i,c))&&(s=x(r,c,"PRE")))return $(i),a=i.startContainer,l=i.startOffset,a.nodeType!==t&&(a=e.createTextNode(""),s.insertBefore(a,s.firstChild)),o||"\n"!==a.data.charAt(l-1)&&!ee(i,c)||"\n"!==a.data.charAt(l)&&!te(i,c)?(a.insertData(l,"\n"),P(s,c),a.length===l+1?i.setStartAfter(a):i.setStart(a,l+1)):(a.deleteData(l&&l-1,l?2:1),(a=(d=F(a,l&&l-1,c,c)).previousSibling).textContent||a.remove(),a=n.createDefaultBlock(),d.before(a),d.textContent||d.remove(),i.setStart(a,0)),i.collapse(!0),n.setSelection(i),n._updatePath(i,!0),void n._docWasChanged();if(!r||o||/^T[HD]$/.test(r.nodeName))return j(i,0,c),K(i,n.createElement("BR")),i.collapse(!1),n.setSelection(i),void n._updatePath(i,!0);if(r=x(r,c,"LI")||r,b(r)&&(s=x(r,c,"UL,OL,BLOCKQUOTE")))return"BLOCKQUOTE"===s.nodeName?n.modifyBlocks(()=>n.createDefaultBlock(We(n)),i):n.decreaseListLevel(i);for(d=we(n,r,i.startContainer,i.startOffset),Fe(r),Te(r),P(r,c);1===d.nodeType;){let n,o=d.firstChild;if("A"===d.nodeName&&(!d.textContent||"​"===d.textContent)){o=e.createTextNode(""),d.replaceWith(o),d=o;break}for(;o&&o.nodeType===t&&!o.data&&(n=o.nextSibling)&&"BR"!==n.nodeName;)o.remove(),o=n;if(!o||"BR"===o.nodeName||o.nodeType===t)break;d=o}i=n.createRange(d,0),n.setSelection(i),n._updatePath(i,!0)},he={enter:a?(e,t,n)=>{e._saveRangeToBookmark(n);let o=e._getHTML(),i=()=>{e.removeEventListener("keyup",i),e._setHTML(o),n=e._getRangeAndRemoveBookmark(),ce(e,!1,n)};e.addEventListener("keyup",i)}:(e,t,n)=>{t.preventDefault(),ce(e,t.shiftKey,n)},"shift-enter":(e,t,n)=>e._keyHandlers.enter(e,t,n),backspace:(e,t,n)=>{let o=e._root;if(e._removeZWS(),e.saveUndoState(n),n.collapsed)if(ee(n,o)){t.preventDefault();let i,r=Y(n,o);if(!r)return;if(I(r.parentNode,o),i=E(r,o)){if(!i.isContentEditable)return void de(i,o);for(w(i,r,n,o),r=i.parentNode;r!==o&&!r.nextSibling;)r=r.parentNode;r!==o&&(r=r.nextSibling)&&H(r,o),e.setSelection(n)}else if(r){let t=x(r,o,"UL,OL,BLOCKQUOTE");if(t)return"BLOCKQUOTE"===t.nodeName?e.modifyBlocks(He,n):e.decreaseListLevel(n);e.setSelection(n),e._updatePath(n,!0)}}else e.setSelection(n),setTimeout(()=>le(e),0);else t.preventDefault(),Q(n,o),le(e,n)},delete:(e,t,n)=>{let o,i,r,s,a,l,d=e._root;if(e._removeZWS(),e.saveUndoState(n),n.collapsed)if(te(n,d)){if(t.preventDefault(),!(o=Y(n,d)))return;if(I(o.parentNode,d),i=L(o,d)){if(!i.isContentEditable)return void de(i,d);for(w(o,i,n,d),i=o.parentNode;i!==d&&!i.nextSibling;)i=i.parentNode;i!==d&&(i=i.nextSibling)&&H(i,d),e.setSelection(n),e._updatePath(n,!0)}}else{if(r=n.cloneRange(),V(n,d,d,d),s=n.endContainer,a=n.endOffset,1===s.nodeType&&(l=s.childNodes[a])&&"IMG"===l.nodeName)return t.preventDefault(),l.remove(),$(n),void le(e,n);e.setSelection(r),setTimeout(()=>le(e),0)}else t.preventDefault(),Q(n,d),le(e,n)},tab:(e,t,n)=>{let o,i,r=e._root;if(e._removeZWS(),n.collapsed&&ee(n,r))for(o=Y(n,r);i=o.parentNode;){if("UL"===i.nodeName||"OL"===i.nodeName){t.preventDefault(),e.increaseListLevel(n);break}o=i}},"shift-tab":(e,t,n)=>{let o,i=e._root;e._removeZWS(),n.collapsed&&ee(n,i)&&(o=n.startContainer,x(o,i,"UL,OL")&&(t.preventDefault(),e.decreaseListLevel(n)))},space:(e,t,n)=>{let o,i=e._root;if(e._recordUndoState(n),e._config.addLinks&&Ke(n.startContainer,i,e),e._getRangeAndRemoveBookmark(n),o=n.endContainer,n.collapsed&&n.endOffset===B(o))do{if("A"===o.nodeName){n.setStartAfter(o);break}}while(!o.nextSibling&&(o=o.parentNode)&&o!==i);n.collapsed||(Q(n,i),e._ensureBottomLine(),e.setSelection(n),e._updatePath(n,!0)),e.setSelection(n)},arrowleft:e=>e._removeZWS(),arrowright:e=>e._removeZWS()};function fe(e,t){let n=e._root,o=e.createRange(n,t?0:n.childNodes.length);return $(o),e.setSelection(o),e}r||(he.pageup=(e=>fe(e,!0)),he.pagedown=(e=>fe(e,!1)));const ue=e=>(t,n)=>{n.preventDefault(),t.changeIndentationLevel(e)},pe=(e,t)=>(n,o)=>{o.preventDefault();let i=n.getSelectionClosest("UL,OL");i&&e==i.nodeName?n.removeList():n[t]()};he[h+"b"]=ae("B"),he[h+"i"]=ae("I"),he[h+"u"]=ae("U"),he[h+"shift-7"]=ae("S"),he[h+"shift-5"]=ae("SUB",{tag:"SUP"}),he[h+"shift-6"]=ae("SUP",{tag:"SUB"}),he[h+"shift-8"]=pe("UL","makeUnorderedList"),he[h+"shift-9"]=pe("OL","makeOrderedList"),he[h+"["]=ue("decrease"),he[h+"]"]=ue("increase"),he[h+"d"]=se("toggleCode"),he[h+"y"]=se("redo"),he[h+"z"]=se("undo"),he[h+"shift-z"]=se("redo");let ge={1:10,2:13,3:16,4:18,5:24,6:32,7:48},me={fontWeight:{regexp:/^bold|^700/i,replace:e=>U(e,"B")},fontStyle:{regexp:/^italic/i,replace:e=>U(e,"I")},fontFamily:{regexp:u,replace:(e,t,n)=>U(e,"SPAN",{class:t.fontFamily,style:"font-family:"+n})},fontSize:{regexp:u,replace:(e,t,n)=>U(e,"SPAN",{class:t.fontSize,style:"font-size:"+n})},textDecoration:{regexp:/^underline/i,replace:e=>U(e,"U")}},Se=t=>n=>{let o=U(e,t);return Array.prototype.forEach.call(n.attributes,e=>o.setAttribute(e.name,e.value)),n.replaceWith(o),o.append(D(n)),o},Ne={SPAN:(t,n,o)=>{let i,r,s,a,l,d,c=t.style;for(i in me)if(r=me[i],(s=c[i])&&r.regexp.test(s)){if((d=r.replace(e,o.classNames,s)).nodeName===t.nodeName&&d.className===t.className)continue;l||(l=d),a&&a.append(d),a=d,t.style[i]=""}return l&&(a.append(D(t)),t.append(l)),a||t},STRONG:Se("B"),EM:Se("I"),INS:Se("U"),STRIKE:Se("S"),FONT:(t,n,o)=>{let i,r,s,a,l,d=t.face,c=t.size,h=t.color,f=o.classNames;return d&&(l=i=U(e,"SPAN",{class:f.fontFamily,style:"font-family:"+d}),a=i),c&&(r=U(e,"SPAN",{class:f.fontSize,style:"font-size:"+ge[c]+"px"}),l||(l=r),a&&a.append(r),a=r),h&&/^#?([\dA-F]{3}){1,2}$/i.test(h)&&("#"!==h.charAt(0)&&(h="#"+h),s=U(e,"SPAN",{class:f.colour,style:"color:"+h}),l||(l=s),a&&a.append(s),a=s),l||(l=a=U(e,"SPAN")),t.replaceWith(l),a.append(D(t)),a},TT:(t,n,o)=>{let i=U(e,"SPAN",{class:o.classNames.fontFamily,style:'font-family:menlo,consolas,"courier new",monospace'});return t.replaceWith(i),i.append(D(t)),i}},_e=/^(?:A(?:DDRESS|RTICLE|SIDE|UDIO)|BLOCKQUOTE|CAPTION|D(?:[DLT]|IV)|F(?:IGURE|IGCAPTION|OOTER)|H[1-6]|HEADER|L(?:ABEL|EGEND|I)|O(?:L|UTPUT)|P(?:RE)?|SECTION|T(?:ABLE|BODY|D|FOOT|H|HEAD|R)|COL(?:GROUP)?|UL)$/,Ce=/^(?:HEAD|META|STYLE)/,ve=(n,o,i)=>{let r,s,a,l,d,c,h,f,p,g,m,S,N=n.childNodes;for(r=n;C(r);)r=r.parentNode;let _=e.createTreeWalker(r,5);for(s=0,a=N.length;s<a;++s)if(d=(l=N[s]).nodeName,c=l.nodeType,h=Ne[d],1===c){if(f=l.childNodes.length,h)l=h(l,n,o);else{if(Ce.test(d)){n.removeChild(l),--s,--a;continue}if(!_e.test(d)&&!C(l)){--s,a+=f-1,l.replaceWith(D(l));continue}}f&&ve(l,o,i||"PRE"===d)}else{if(c===t){if(m=l.data,p=!u.test(m.charAt(0)),g=!u.test(m.charAt(m.length-1)),i||!p&&!g)continue;if(p){for(_.currentNode=l;(S=_.previousPONode())&&!("IMG"===(d=S.nodeName)||"#text"===d&&u.test(S.data));)if(!C(S)){S=null;break}m=m.replace(/^[ \t\r\n]+/g,S?" ":"")}if(g){for(_.currentNode=l;(S=_.nextNode())&&!("IMG"===d||"#text"===d&&u.test(S.data));)if(!C(S)){S=null;break}m=m.replace(/[ \t\r\n]+$/g,S?" ":"")}if(m){l.data=m;continue}}n.removeChild(l),--s,--a}return n},Te=e=>{let n,o=e.childNodes,i=o.length;for(;i--;)1!==(n=o[i]).nodeType||N(n)?n.nodeType!==t||n.data||e.removeChild(n):(Te(n),C(n)&&!n.firstChild&&e.removeChild(n))},ye=e=>1===e.nodeType?"BR"===e.nodeName:u.test(e.data),Ee=(t,n)=>{let o,i=t.parentNode;for(;C(i);)i=i.parentNode;return(o=e.createTreeWalker(i,5,ye)).currentNode=t,!!o.nextNode()||n&&!o.previousNode()},Le=(e,t,n)=>{let o,i,r,s=e.querySelectorAll("BR"),a=[],l=s.length;for(o=0;o<l;++o)a[o]=Ee(s[o],n);for(;l--;)(r=(i=s[l]).parentNode)&&(a[l]?C(r)||I(r,t):i.remove())},be=(t,n,o,i,r,a)=>{let l,d,c=t.clipboardData,h=e.body,f=U(e,"div");f.append(n),l=f.innerHTML,i&&(l=i(l)),r?d=r(l):(Le(f,o,!0),f.setAttribute("style","position:fixed;overflow:hidden;bottom:100%;right:100%;"),h.append(f),d=(d=f.innerText||f.textContent).replace(" "," "),h.removeChild(f)),s&&(d=d.replace(/\r?\n/g,"\r\n")),a||d===l||c.setData("text/html",l),c.setData("text/plain",d),t.preventDefault()},ke=function(e){let n,o,i,r,s,a,l=this.getSelection(),c=this._root,h=this;if(l.collapsed)e.preventDefault();else{if(this.saveUndoState(l),!d&&e.clipboardData){for(i=(n=Y(l,c))===(o=X(l,c))&&n||c,r=Q(l,c),(s=l.commonAncestorContainer).nodeType===t&&(s=s.parentNode);s&&s!==i;)(a=s.cloneNode(!1)).append(r),r=a,s=s.parentNode;be(e,r,c,this._config.willCutCopy,null,!1)}else setTimeout(()=>{try{h._ensureBottomLine()}catch(e){h.didError(e)}},0);this.setSelection(l)}},Oe=function(e){((e,n,o,i,r,s)=>{let a,l,c,h,f,u;if(!d&&e.clipboardData){for(c=(a=Y(n,o))===(l=X(n,o))&&a||o,n=n.cloneRange(),$(n),V(n,c,c,o),h=n.cloneContents(),(f=n.commonAncestorContainer).nodeType===t&&(f=f.parentNode);f&&f!==c;)(u=f.cloneNode(!1)).append(h),h=u,f=f.parentNode;be(e,h,o,i,r,s)}})(e,this.getSelection(),this._root,this._config.willCutCopy,null,!1)};function xe(e){this.isShiftDown=e.shiftKey}let Ae=function(t){let n,o,i,r,s,a=t.clipboardData,c=a&&a.items,h=this.isShiftDown,f=!1,u=!1,g=!1,m=null,S=null,N=this;if(c){for(n=c.length;n--;)"text/html"===(i=(o=c[n]).type)?S=o:"text/plain"===i||"text/uri-list"===i?m=o:"text/rtf"===i?u=!0:/^image\/.*/.test(i)&&(g=!0);if(g&&(!u||!S))return t.preventDefault(),this.fireEvent("dragover",{dataTransfer:a,preventDefault:()=>f=!0}),void(f&&this.fireEvent("drop",{dataTransfer:a}));if(!d)return t.preventDefault(),void(!S||h&&m?m&&m.getAsString(e=>N.insertPlainText(e,!0)):S.getAsString(e=>N.insertHTML(e,!0)))}if(r=a&&a.types,!d&&r&&(p(r,"text/html")>-1||!l&&p(r,"text/plain")>-1&&p(r,"text/rtf")<0))return t.preventDefault(),void(!h&&(s=a.getData("text/html"))?this.insertHTML(s,!0):((s=a.getData("text/plain"))||(s=a.getData("text/uri-list")))&&this.insertPlainText(s,!0));let _=e.body,C=this.getSelection(),v=C.startContainer,T=C.startOffset,y=C.endContainer,E=C.endOffset,L=this.createElement("DIV",{contenteditable:"true",style:"position:fixed; overflow:hidden; top:0; right:100%; width:1px; height:1px;"});_.append(L),C.selectNodeContents(L),this.setSelection(C),setTimeout(()=>{try{let e,t,n="",o=L;for(;L=o;)o=L.nextSibling,L.remove(),(e=L.firstChild)&&e===L.lastChild&&"DIV"===e.nodeName&&(L=e),n+=L.innerHTML;t=N.createRange(v,T,y,E),N.setSelection(t),n&&N.insertHTML(n,!0)}catch(e){N.didError(e)}},0)},Re=function(e){let t=e.dataTransfer.types,n=t.length,o=!1,i=!1;for(;n--;)switch(t[n]){case"text/plain":o=!0;break;case"text/html":i=!0;break;default:return}(i||o)&&this.saveUndoState()};function Be(e,t,n){let o,i;if(e||(e={}),t)for(o in t)!n&&o in e||(i=t[o],e[o]=i&&i.constructor===Object?Be(e[o],i,n):i);return e}function De(t,o){let i;t.nodeType===n&&(t=t.body),this._root=t,this._events={},this._isFocused=!1,this._lastRange=null,this._hasZWS=!1,this._lastAnchorNode=null,this._lastFocusNode=null,this._path="",this._willUpdatePath=!1;const r=()=>{if(t.contains(e.activeElement)){let e=this;e._isFocused&&!e._willUpdatePath&&(e._willUpdatePath=!0,setTimeout(function(){e._willUpdatePath=!1,e._updatePath(e.getSelection())},0))}else this.removeEventListener("selectionchange",r)};this.addEventListener("selectstart",()=>this.addEventListener("selectionchange",r)),this._undoIndex=-1,this._undoStack=[],this._undoStackLength=0,this._isInUndoState=!1,this._ignoreChange=!1,this._ignoreAllChanges=!1,(i=new MutationObserver(()=>this._docWasChanged())).observe(t,{childList:!0,attributes:!0,characterData:!0,subtree:!0}),this._mutation=i,this._restoreSelection=!1,this.addEventListener("blur",()=>this._restoreSelection=!0).addEventListener("pointerdown mousedown touchstart",()=>this._restoreSelection=!1).addEventListener("focus",()=>this._restoreSelection&&this.setSelection(this._lastRange)).addEventListener("cut",ke).addEventListener("copy",Oe).addEventListener("keydown keyup",xe).addEventListener("paste",Ae).addEventListener("drop",Re).addEventListener("keydown",re).addEventListener("pointerup keyup mouseup touchend",()=>this.getSelection()),this._keyHandlers=Object.create(he),this.setConfig(o),t.setAttribute("contenteditable","true"),t.setAttribute("data-gramm","false");try{e.execCommand("enableObjectResizing",!1,"false"),e.execCommand("enableInlineTableEditing",!1,"false")}catch(e){}t.__squire__=this,this.setHTML("")}let Ue=De.prototype,Pe=t=>{let n=t?o.DOMPurify.sanitize(t,{ALLOW_UNKNOWN_PROTOCOLS:!0,WHOLE_DOCUMENT:!1,RETURN_DOM:!0,RETURN_DOM_FRAGMENT:!0}):null;return n?e.importNode(n,!0):e.createDocumentFragment()};Ue.setConfig=function(e){return(e=Be({blockTag:"DIV",blockAttributes:null,tagAttributes:{blockquote:null,ul:null,ol:null,li:null,a:null},classNames:{colour:"colour",fontFamily:"font",fontSize:"size",highlight:"highlight"},leafNodeNames:S,undo:{documentSizeThreshold:-1,undoLimit:-1},isInsertedHTMLSanitized:!0,isSetHTMLSanitized:!0,sanitizeToDOMFragment:o.DOMPurify&&o.DOMPurify.isSupported?Pe:null,willCutCopy:null,addLinks:!0},e,!0)).blockTag=e.blockTag.toUpperCase(),this._config=e,this},Ue.createElement=function(t,n,o){return U(e,t,n,o)},Ue.createDefaultBlock=function(e){let t=this._config;return P(this.createElement(t.blockTag,t.blockAttributes,e),this._root)},Ue.didError=(e=>console.error(e)),Ue.getRoot=function(){return this._root},Ue.modifyDocument=function(e){let t=this._mutation;t&&(t.takeRecords().length&&this._docWasChanged(),t.disconnect()),this._ignoreAllChanges=!0,e(),this._ignoreAllChanges=!1,t&&(t.observe(this._root,{childList:!0,attributes:!0,characterData:!0,subtree:!0}),this._ignoreChange=!1)};let Ie={pathChange:1,select:1,input:1,undoStateChange:1};Ue.fireEvent=function(t,n){let o,i,r,s=this._events[t];if(/^(?:focus|blur)/.test(t))if(o=this._root===e.activeElement,"focus"===t){if(!o||this._isFocused)return this;this._isFocused=!0}else{if(o||!this._isFocused)return this;this._isFocused=!1}if(s)for(n||(n={}),n.type!==t&&(n.type=t),i=(s=s.slice()).length;i--;){r=s[i];try{r.handleEvent?r.handleEvent(n):r.call(this,n)}catch(e){e.details="Squire: fireEvent error. Event type: "+t,this.didError(e)}}return this},Ue.destroy=function(){let e,t=this._events;for(e in t)this.removeEventListener(e);this._mutation&&this._mutation.disconnect(),delete this._root.__squire__,this._undoIndex=-1,this._undoStack=[],this._undoStackLength=0},Ue.handleEvent=function(e){this.fireEvent(e.type,e)},Ue.addEventListener=function(t,n){return t.split(/\s+/).forEach(t=>{let o=this._events[t],i=this._root;if(!n)return this.didError({name:"Squire: addEventListener with null or undefined fn",message:"Event type: "+t}),this;o||(o=this._events[t]=[],Ie[t]||("selectionchange"===t&&(i=e),i.addEventListener(t,this,!0))),o.push(n)}),this},Ue.removeEventListener=function(t,n){let o,i=this._events[t],r=this._root;if(i){if(n)for(o=i.length;o--;)i[o]===n&&i.splice(o,1);else i.length=0;i.length||(delete this._events[t],Ie[t]||("selectionchange"===t&&(r=e),r.removeEventListener(t,this,!0)))}return this},Ue.createRange=function(t,n,i,r){if(t instanceof o.Range)return t.cloneRange();let s=e.createRange();return s.setStart(t,n),i?s.setEnd(i,r):s.setEnd(t,n),s},Ue.getCursorPosition=function(t){if(!t&&!(t=this.getSelection())||!t.getBoundingClientRect)return null;let n,o,i=t.getBoundingClientRect();return i&&!i.top&&(this._ignoreChange=!0,(n=e.createElement("SPAN")).textContent="​",K(t,n),i=n.getBoundingClientRect(),(o=n.parentNode).removeChild(n),M(o,t)),i},Ue.setSelection=function(e){if(e)if(this._lastRange=e,this._isFocused){a&&o.focus();let t=o.getSelection();t&&t.setBaseAndExtent?t.setBaseAndExtent(e.startContainer,e.startOffset,e.endContainer,e.endOffset):t&&(t.removeAllRanges(),t.addRange(e))}else this._restoreSelection=!0;return this},Ue.getSelection=function(){let t,n,i,r,s=o.getSelection(),a=this._root;return this._isFocused&&s&&s.rangeCount&&(n=(t=s.getRangeAt(0).cloneRange()).startContainer,i=t.endContainer,n&&N(n)&&t.setStartBefore(n),i&&N(i)&&t.setEndBefore(i)),t&&a.contains(t.commonAncestorContainer)?this._lastRange=t:(r=(t=this._lastRange).commonAncestorContainer,e.contains(r)||(t=null)),t||this.createRange(a.firstChild,0)},Ue.getSelectionClosest=function(e){let t=this.getSelection();return t&&x(t.commonAncestorContainer,this._root,e)},Ue.selectionContains=function(e){let t=this.getSelection(),n=t&&t.commonAncestorContainer;return!(!n||t.collapsed)&&!(!(n=n.querySelector?n:n.parentElement)||!n.querySelector(e))},Ue.getSelectedText=function(){let n=this.getSelection();if(!n||n.collapsed)return"";let o,i=e.createTreeWalker(n.commonAncestorContainer,5,e=>Z(n,e,!0)),r=n.startContainer,s=n.endContainer,a=i.currentNode=r,l="",d=!1;for(i.filter(a)||(a=i.nextNode());a;)a.nodeType===t?(o=a.data)&&/\S/.test(o)&&(a===s&&(o=o.slice(0,n.endOffset)),a===r&&(o=o.slice(n.startOffset)),l+=o,d=!0):("BR"===a.nodeName||d&&!C(a))&&(l+="\n",d=!1),a=i.nextNode();return l},Ue.getPath=function(){return this._path};let Fe=(t,n)=>{let o,i,r,s=e.createTreeWalker(t,4);for(;i=s.nextNode();)for(;(r=i.data.indexOf("​"))>-1&&(!n||i.parentNode!==n);){if(1===i.length){do{(o=i.parentNode).removeChild(i),i=o,s.currentNode=o}while(C(i)&&!B(i));break}i.deleteData(r,1)}};Ue._didAddZWS=function(){this._hasZWS=!0},Ue._removeZWS=function(){this._hasZWS&&(Fe(this._root),this._hasZWS=!1)},Ue._updatePath=function(e,t){if(!e)return;let n,o=e.startContainer,i=e.endContainer;(t||o!==this._lastAnchorNode||i!==this._lastFocusNode)&&(this._lastAnchorNode=o,this._lastFocusNode=i,n=o&&i?o===i?R(i,this._root,this._config):"(selection)":"",this._path!==n&&(this._path=n,this.fireEvent("pathChange",{path:n}))),this.fireEvent(e.collapsed?"cursor":"select",{range:e})},Ue.focus=function(){return this._root.focus({preventScroll:!0}),this},Ue.blur=function(){return this._root.blur(),this};const We=e=>[e.createElement("INPUT",{id:"squire-selection-start",type:"hidden"}),e.createElement("INPUT",{id:"squire-selection-end",type:"hidden"})];Ue._saveRangeToBookmark=function(e){let t,[n,o]=We(this);K(e,n),e.collapse(!1),K(e,o),2&n.compareDocumentPosition(o)&&(n.id="squire-selection-end",o.id="squire-selection-start",t=n,n=o,o=t),e.setStartAfter(n),e.setEndBefore(o)},Ue._getRangeAndRemoveBookmark=function(n){let o=this._root,i=o.querySelector("#squire-selection-start"),r=o.querySelector("#squire-selection-end");if(i&&r){let o=i.parentNode,s=r.parentNode,a=p(o.childNodes,i),l=p(s.childNodes,r);o===s&&--l,i.remove(),r.remove(),n||(n=e.createRange()),n.setStart(o,a),n.setEnd(s,l),M(o,n),o!==s&&M(s,n),n.collapsed&&(o=n.startContainer).nodeType===t&&((s=o.childNodes[n.startOffset])&&s.nodeType===t||(s=o.childNodes[n.startOffset-1]),s&&s.nodeType===t&&(n.setStart(s,0),n.collapse(!0)))}return n||null},Ue._keyUpDetectChange=(e=>{let t=e.keyCode;!e[f]&&!e.altKey&&(t<16||t>20)&&(t<33||t>45)&&this._docWasChanged()}),Ue._docWasChanged=function(){ie=new WeakMap,this._ignoreAllChanges||(this._ignoreChange?this._ignoreChange=!1:(this._isInUndoState&&(this._isInUndoState=!1,this.fireEvent("undoStateChange",{canUndo:!0,canRedo:!1})),this.fireEvent("input")))},Ue._recordUndoState=function(e,t){if(!this._isInUndoState||t){let n,o=this._undoIndex,i=this._undoStack,r=this._config.undo,s=r.documentSizeThreshold,a=r.undoLimit;t||++o,o<this._undoStackLength&&(i.length=this._undoStackLength=o),e&&this._saveRangeToBookmark(e),n=this._getHTML(),s>-1&&2*n.length>s&&a>-1&&o>a&&(i.splice(0,o-a),o=a,this._undoStackLength=a),i[o]=n,this._undoIndex=o,++this._undoStackLength,this._isInUndoState=!0}},Ue.saveUndoState=function(e){return void 0===e&&(e=this.getSelection()),this._recordUndoState(e,this._isInUndoState),this._getRangeAndRemoveBookmark(e),this},Ue.undo=function(){if(0!==this._undoIndex||!this._isInUndoState){this._recordUndoState(this.getSelection(),!1),--this._undoIndex,this._setHTML(this._undoStack[this._undoIndex]);let e=this._getRangeAndRemoveBookmark();e&&this.setSelection(e),this._isInUndoState=!0,this.fireEvent("undoStateChange",{canUndo:0!==this._undoIndex,canRedo:!0}),this.fireEvent("input")}return this},Ue.redo=function(){let e=this._undoIndex,t=this._undoStackLength;if(e+1<t&&this._isInUndoState){++this._undoIndex,this._setHTML(this._undoStack[this._undoIndex]);let n=this._getRangeAndRemoveBookmark();n&&this.setSelection(n),this.fireEvent("undoStateChange",{canUndo:!0,canRedo:e+2<t}),this.fireEvent("input")}return this},Ue.hasFormat=function(n,o,i){if(n=n.toUpperCase(),o||(o={}),!i&&!(i=this.getSelection()))return!1;!i.collapsed&&i.startContainer.nodeType===t&&i.startOffset===i.startContainer.length&&i.startContainer.nextSibling&&i.setStartBefore(i.startContainer.nextSibling),!i.collapsed&&i.endContainer.nodeType===t&&0===i.endOffset&&i.endContainer.previousSibling&&i.setEndAfter(i.endContainer.previousSibling);let r,s,a=this._root,l=i.commonAncestorContainer;if(A(l,a,n,o))return!0;if(l.nodeType===t)return!1;r=e.createTreeWalker(l,4,e=>Z(i,e,!0));let d=!1;for(;s=r.nextNode();){if(!A(s,a,n,o))return!1;d=!0}return d},Ue.getFontInfo=function(e){let n,o,i,r={color:void 0,backgroundColor:void 0,family:void 0,size:void 0},s=0;if(!e&&!(e=this.getSelection()))return r;if(n=e.commonAncestorContainer,e.collapsed||n.nodeType===t)for(n.nodeType===t&&(n=n.parentNode);s<4&&n;)(o=n.style)&&(!r.color&&(i=o.color)&&(r.color=i,++s),!r.backgroundColor&&(i=o.backgroundColor)&&(r.backgroundColor=i,++s),!r.family&&(i=o.fontFamily)&&(r.family=i,++s),!r.size&&(i=o.fontSize)&&(r.size=i,++s)),n=n.parentNode;return r},Ue._addFormat=function(n,o,i){let r,s,a,l,d,c,h,f,u,p=this._root;if(i.collapsed){for(r=P(this.createElement(n,o),p),K(i,r),i.setStart(r.firstChild,r.firstChild.length),i.collapse(!0),u=r;C(u);)u=u.parentNode;Fe(u,r)}else{if(s=e.createTreeWalker(i.commonAncestorContainer,5,e=>(e.nodeType===t||"BR"===e.nodeName||"IMG"===e.nodeName)&&Z(i,e,!0)),a=i.startContainer,d=i.startOffset,l=i.endContainer,c=i.endOffset,s.currentNode=a,s.filter(a)||(a=s.nextNode(),d=0),!a)return i;do{h=s.currentNode,(f=!A(h,p,n,o))&&(h===l&&h.length>c&&h.splitText(c),h===a&&d&&(h=h.splitText(d),l===a&&(l=h,c-=d),a=h,d=0),r=this.createElement(n,o),h.replaceWith(r),r.append(h))}while(s.nextNode());l.nodeType!==t&&(h.nodeType===t?(l=h,c=h.length):(l=h.parentNode,c=1)),i=this.createRange(a,d,l,c)}return i},Ue._removeFormat=function(n,o,i,r){let s;this._saveRangeToBookmark(i),i.collapsed&&(c?(s=e.createTextNode("​"),this._didAddZWS()):s=e.createTextNode(""),K(i,s));let a=i.commonAncestorContainer;for(;C(a);)a=a.parentNode;let l=i.startContainer,d=i.startOffset,h=i.endContainer,f=i.endOffset,u=[],p=function(e,n){if(Z(i,e,!1))return;let o,r,s=e.nodeType===t;if(Z(i,e,!0))if(s)e===h&&f!==e.length&&u.push([n,e.splitText(f)]),e===l&&d&&(e.splitText(d),u.push([n,e]));else for(o=e.firstChild;o;o=r)r=o.nextSibling,p(o,n);else"INPUT"===e.nodeName||s&&!e.data||u.push([n,e])},g=Array.prototype.filter.call(a.getElementsByTagName(n),function(e){return Z(i,e,!0)&&O(e,n,o)});return r||g.forEach(function(e){p(e,e)}),u.forEach(function(e){let t=e[0].cloneNode(!1),n=e[1];n.replaceWith(t),t.append(n)}),g.forEach(function(e){e.replaceWith(D(e))}),this._getRangeAndRemoveBookmark(i),s&&i.collapse(!1),M(a,i),i},Ue.changeFormat=function(e,t,n,o){return n||(n=this.getSelection())?(this.saveUndoState(n),t&&(n=this._removeFormat(t.tag.toUpperCase(),t.attributes||{},n,o)),e&&(n=this._addFormat(e.tag.toUpperCase(),e.attributes||{},n)),this.setSelection(n),this._updatePath(n,!0),this):this};let Me={DT:"DD",DD:"DT",LI:"LI",PRE:"PRE"},we=(t,n,o,i)=>{let r=Me[n.nodeName],s=null,a=F(o,i,n.parentNode,t._root),l=t._config;return r||(r=l.blockTag,s=l.blockAttributes),O(a,r,s)||(n=U(e,r,s),a.dir&&(n.dir=a.dir),a.replaceWith(n),n.append(D(a)),a=n),a};Ue.forEachBlock=function(e,t,n){if(!n&&!(n=this.getSelection()))return this;t&&this.saveUndoState(n);let o=this._root,i=Y(n,o),r=X(n,o);if(i&&r)do{if(e(i)||i===r)break}while(i=L(i,o));return t&&(this.setSelection(n),this._updatePath(n,!0)),this},Ue.modifyBlocks=function(e,t){if(!t&&!(t=this.getSelection()))return this;this._recordUndoState(t,this._isInUndoState);let n,o=this._root;return ne(t,o),V(t,o,o,o),n=G(t,o,o),K(t,e.call(this,n)),t.endOffset<t.endContainer.childNodes.length&&H(t.endContainer.childNodes[t.endOffset],o),H(t.startContainer.childNodes[t.startOffset],o),this._getRangeAndRemoveBookmark(t),this.setSelection(t),this._updatePath(t,!0),this};let He=function(e){var t=e.querySelectorAll("blockquote");return Array.prototype.filter.call(t,t=>!x(t.parentNode,e,"BLOCKQUOTE")).forEach(e=>e.replaceWith(D(e))),e},ze=(e,t,n)=>{let o,i,r,s,a=y(t,e._root),l=e._config.tagAttributes,d=l[n.toLowerCase()],c=l.li;for(;o=a.nextNode();)"LI"===o.parentNode.nodeName&&(o=o.parentNode,a.currentNode=o.lastChild),"LI"!==o.nodeName?(s=e.createElement("LI",c),o.dir&&(s.dir=o.dir),(r=o.previousSibling)&&r.nodeName===n?(r.append(s),o.remove()):o.replaceWith(e.createElement(n,d,[s])),s.append(D(o)),a.currentNode=s):(i=(o=o.parentNode).nodeName)!==n&&/^[OU]L$/.test(i)&&o.replaceWith(e.createElement(n,d,[D(o)]))},qe=(e,t)=>{let n=e.commonAncestorContainer,o=e.startContainer,i=e.endContainer;for(;n&&n!==t&&!/^[OU]L$/.test(n.nodeName);)n=n.parentNode;if(!n||n===t)return null;for(o===n&&(o=o.childNodes[e.startOffset]),i===n&&(i=i.childNodes[e.endOffset]);o&&o.parentNode!==n;)o=o.parentNode;for(;i&&i.parentNode!==n;)i=i.parentNode;return[n,o,i]};Ue.increaseListLevel=function(e){if(!e&&!(e=this.getSelection()))return this.focus();let t=this._root,n=qe(e,t);if(!n)return this.focus();let o=n[0],i=n[1],r=n[2];if(!i||i===o.firstChild)return this.focus();this._recordUndoState(e,this._isInUndoState);let s,a,l=o.nodeName,d=i.previousSibling;d.nodeName!==l&&(s=this._config.tagAttributes[l.toLowerCase()],d=this.createElement(l,s),i.before(d));do{a=i===r?null:i.nextSibling,d.append(i)}while(i=a);return(a=d.nextSibling)&&H(a,t),this._getRangeAndRemoveBookmark(e),this.setSelection(e),this._updatePath(e,!0),this.focus()},Ue.decreaseListLevel=function(e){if(!e&&!(e=this.getSelection()))return this.focus();let t=this._root,n=qe(e,t);if(!n)return this.focus();let o,i,r,s,a=n[0],l=n[1],d=n[2];if(l||(l=a.firstChild),d||(d=a.lastChild),this._recordUndoState(e,this._isInUndoState),l){if(o=a.parentNode,r=d.nextSibling?F(a,d.nextSibling,o,t):a.nextSibling,o!==t&&"LI"===o.nodeName){for(o=o.parentNode;r;)i=r.nextSibling,d.append(r),r=i;r=a.parentNode.nextSibling}s=!/^[OU]L$/.test(o.nodeName);do{i=l===d?null:l.nextSibling,a.removeChild(l),s&&"LI"===l.nodeName&&(l=this.createDefaultBlock([D(l)])),o.insertBefore(l,r)}while(l=i)}return a.firstChild||a.remove(),r&&H(r,t),this._getRangeAndRemoveBookmark(e),this.setSelection(e),this._updatePath(e,!0),this.focus()},Ue._ensureBottomLine=function(){let e=this._root,t=e.lastElementChild;t&&t.nodeName===this._config.blockTag&&v(t)||e.append(this.createDefaultBlock())},Ue.setKeyHandler=function(e,t){return this._keyHandlers[e]=t,this},Ue._getHTML=function(){return this._root.innerHTML},Ue._setHTML=function(e){let t=this._root,n=t;n.innerHTML=e;do{P(n,t)}while(n=L(n,t));this._ignoreChange=!0},Ue.getHTML=function(e){let t,n;return e&&(n=this.getSelection())&&this._saveRangeToBookmark(n),t=this._getHTML().replace(/\u200B/g,""),n&&this._getRangeAndRemoveBookmark(n),t},Ue.setHTML=function(t){let n,o,i,r=this._config,s=r.isSetHTMLSanitized?r.sanitizeToDOMFragment:null,a=this._root;"function"==typeof s?o=s(t,!1,this):((n=this.createElement("DIV")).innerHTML=t,(o=e.createDocumentFragment()).append(D(n))),ve(o,r),Le(o,a,!1),I(o,a);let l=o;for(;l=L(l,a);)P(l,a);for(this._ignoreChange=!0;i=a.lastChild;)a.removeChild(i);a.append(o),P(a,a),this._undoIndex=-1,this._undoStack.length=0,this._undoStackLength=0,this._isInUndoState=!1;let d=this._getRangeAndRemoveBookmark()||this.createRange(a.firstChild,0);return this.saveUndoState(d),this._lastRange=d,this._restoreSelection=!0,this._updatePath(d,!0),this},Ue.insertElement=function(e,t){if(t||(t=this.getSelection()),t.collapse(!0),C(e))K(t,e),t.setStartAfter(e);else{let n,o,i=this._root,r=Y(t,i)||i;for(;r!==i&&!r.nextSibling;)r=r.parentNode;r!==i&&(n=r.parentNode,o=F(n,r.nextSibling,i,i)),o?o.before(e):(i.append(e),o=this.createDefaultBlock(),i.append(o)),t.setStart(o,0),t.setEnd(o,0),$(t)}return this.focus(),this.setSelection(t),this._updatePath(t),this},Ue.insertImage=function(e,t){let n=this.createElement("IMG",Be({src:e},t,!0));return this.insertElement(n),n},Ue.linkRegExp=/\b(?:((?:(?:ht|f)tps?:\/\/|www\d{0,3}[.]|[a-z0-9][a-z0-9.-]*[.][a-z]{2,}\/)(?:[^\s()<>]+|\([^\s()<>]+\))+(?:[^\s?&`!()[\]{};:'".,<>«»“”‘’]|\([^\s()<>]+\)))|([\w\-.%+]+@(?:[\w-]+\.)+[a-z]{2,}\b(?:[?][^&?\s]+=[^\s?&`!()[\]{};:'".,<>«»“”‘’]+(?:&[^&?\s]+=[^\s?&`!()[\]{};:'".,<>«»“”‘’]+)*)?))/i;let Ke=(t,n,o)=>{let i,r,s,a,l,d,c=e.createTreeWalker(t,4,e=>!x(e,n,"A")),h=o.linkRegExp,f=o._config.tagAttributes.a;if(h)for(;i=c.nextNode();)for(r=i.data;s=h.exec(r);)l=(a=s.index)+s[0].length,a&&(d=e.createTextNode(r.slice(0,a)),i.before(d)),(d=o.createElement("A",Be({href:s[1]?/^(?:ht|f)tps?:/i.test(s[1])?s[1]:"http://"+s[1]:"mailto:"+s[0]},f,!1))).textContent=r.slice(a,l),i.before(d),i.data=r=r.slice(l)};Ue.insertHTML=function(t,n){let o,i,r,s,a,l,d,c=this._config,h=c.isInsertedHTMLSanitized?c.sanitizeToDOMFragment:null,f=this.getSelection();"function"==typeof h?s=h(t,n,this):(n&&(o=t.indexOf("\x3c!--StartFragment--\x3e"),i=t.lastIndexOf("\x3c!--EndFragment--\x3e"),o>-1&&i>-1&&(t=t.slice(o+20,i))),/<\/td>((?!<\/tr>)[\s\S])*$/i.test(t)&&(t="<TR>"+t+"</TR>"),/<\/tr>((?!<\/table>)[\s\S])*$/i.test(t)&&(t="<TABLE>"+t+"</TABLE>"),(r=this.createElement("DIV")).innerHTML=t,(s=e.createDocumentFragment()).append(D(r))),this.saveUndoState(f);try{for(a=this._root,l=s,d={fragment:s,preventDefault:function(){this.defaultPrevented=!0},defaultPrevented:!1},Ke(s,s,this),ve(s,c),Le(s,a,!1),Te(s),s.normalize();l=L(l,s);)P(l,a);n&&this.fireEvent("willPaste",d),d.defaultPrevented||(((t,n,o)=>{let i,r,s,a,l,d,c,h,f,u,g,m=n.firstChild&&C(n.firstChild);for(I(n,o),i=n;i=L(i,o);)P(i,o);if(t.collapsed||Q(t,o),$(t),t.collapse(!1),a=x(t.endContainer,o,"BLOCKQUOTE")||o,r=Y(t,o),h=L(n,n),c=!m&&!!r&&b(r),r&&h&&!c&&!x(h,n,"PRE,TABLE")){if(V(t,r,r,o),t.collapse(!0),l=t.endContainer,d=t.endOffset,Le(r,o,!1),C(l)&&(l=(f=F(l,d,E(l,o),o)).parentNode,d=p(l.childNodes,f)),d!==B(l))for(s=e.createDocumentFragment();i=l.childNodes[d];)s.append(i);w(l,h,t,o),d=p(l.parentNode.childNodes,l)+1,l=l.parentNode,t.setEnd(l,d)}B(n)&&(c&&(t.setEndBefore(r),t.collapse(!1),r.remove()),V(t,a,a,o),u=(f=F(t.endContainer,t.endOffset,a,o))?f.previousSibling:a.lastChild,f.before(n),f?t.setEndBefore(f):t.setEnd(a,B(a)),r=X(t,o),$(t),l=t.endContainer,d=t.endOffset,f&&T(f)&&H(f,o),(f=u&&u.nextSibling)&&T(f)&&H(f,o),t.setEnd(l,d)),s&&(g=t.cloneRange(),w(r,s,g,o),t.setEnd(g.endContainer,g.endOffset)),$(t)})(f,d.fragment,a),f.collapse(!1),j(f,0,a),this._ensureBottomLine()),this.setSelection(f),this._updatePath(f,!0),n&&this.focus()}catch(e){this.didError(e)}return this};let Ge=e=>e.replace("&","&amp;").replace("<","&lt;").replace(">","&gt;").replace('"',"&quot;");Ue.insertPlainText=function(n,o){let i=this.getSelection();if(i.collapsed&&x(i.startContainer,this._root,"PRE")){let r,s,a=i.startContainer,l=i.startOffset;return a&&a.nodeType===t||(r=e.createTextNode(""),a.childNodes[l].before(r),a=r,l=0),s={text:n,preventDefault:function(){this.defaultPrevented=!0},defaultPrevented:!1},o&&this.fireEvent("willPaste",s),s.defaultPrevented||(n=s.text,a.insertData(l,n),i.setStart(a,l+n.length),i.collapse(!0)),this.setSelection(i),this}let r,s,a,l,d=n.split("\n"),c=this._config,h=c.blockTag,f=c.blockAttributes,u="</"+h+">",p="<"+h;for(r in f)p+=" "+r+'="'+Ge(f[r])+'"';for(p+=">",s=0,a=d.length;s<a;++s)l=d[s],l=Ge(l).replace(/ (?= )/g,"&nbsp;"),s&&(l=p+(l||"<BR>")+u),d[s]=l;return this.insertHTML(d.join(""),o)};let Qe=(e,t,n)=>(function(){return this[e](t,n),this.focus()});Ue.addStyles=function(t){if(t){let n=e.documentElement.firstChild,o=this.createElement("STYLE",{type:"text/css"});o.append(e.createTextNode(t)),n.append(o)}return this},Ue.bold=Qe("changeFormat",{tag:"B"}),Ue.italic=Qe("changeFormat",{tag:"I"}),Ue.underline=Qe("changeFormat",{tag:"U"}),Ue.strikethrough=Qe("changeFormat",{tag:"S"}),Ue.subscript=Qe("changeFormat",{tag:"SUB"},{tag:"SUP"}),Ue.superscript=Qe("changeFormat",{tag:"SUP"},{tag:"SUB"}),Ue.removeBold=Qe("changeFormat",null,{tag:"B"}),Ue.removeItalic=Qe("changeFormat",null,{tag:"I"}),Ue.removeUnderline=Qe("changeFormat",null,{tag:"U"}),Ue.removeStrikethrough=Qe("changeFormat",null,{tag:"S"}),Ue.removeSubscript=Qe("changeFormat",null,{tag:"SUB"}),Ue.removeSuperscript=Qe("changeFormat",null,{tag:"SUP"}),Ue.makeLink=function(t,n){let o=this.getSelection();if(o.collapsed){let n=t.indexOf(":")+1;if(n)for(;"/"===t[n];)++n;K(o,e.createTextNode(t.slice(n)))}return n=Be(Be({href:t},n,!0),this._config.tagAttributes.a,!1),this.changeFormat({tag:"A",attributes:n},{tag:"A"},o),this.focus()},Ue.removeLink=function(){return this.changeFormat(null,{tag:"A"},this.getSelection(),!0),this.focus()},Ue.setFontFace=function(e){let t=this._config.classNames.fontFamily;return this.changeFormat(e?{tag:"SPAN",attributes:{class:t,style:"font-family: "+e+", sans-serif;"}}:null,{tag:"SPAN",attributes:{class:t}}),this.focus()},Ue.setFontSize=function(e){let t=this._config.classNames.fontSize;return this.changeFormat(e?{tag:"SPAN",attributes:{class:t,style:"font-size: "+("number"==typeof e?e+"px":e)}}:null,{tag:"SPAN",attributes:{class:t}}),this.focus()},Ue.setTextColour=function(e){let t=this._config.classNames.colour;return this.changeFormat(e?{tag:"SPAN",attributes:{class:t,style:"color:"+e}}:null,{tag:"SPAN",attributes:{class:t}}),this.focus()},Ue.setHighlightColour=function(e){let t=this._config.classNames.highlight;return this.changeFormat(e?{tag:"SPAN",attributes:{class:t,style:"background-color:"+e}}:e,{tag:"SPAN",attributes:{class:t}}),this.focus()},Ue.setTextAlignment=function(e){return this.forEachBlock(function(t){let n=t.className.split(/\s+/).filter(function(e){return!!e&&!/^align/.test(e)}).join(" ");e?(t.className=n+" align-"+e,t.style.textAlign=e):(t.className=n,t.style.textAlign="")},!0),this.focus()},Ue.setTextDirection=function(e){return this.forEachBlock(function(t){e?t.dir=e:t.removeAttribute("dir")},!0),this.focus()};let Ze=function(t){let n,o=this._root,i=e.createDocumentFragment(),r=y(t,o);for(;n=r.nextNode();){let t,o,r=n.querySelectorAll("BR"),s=[],a=r.length;for(t=0;t<a;++t)s[t]=Ee(r[t],!1);for(;a--;)o=r[a],s[a]?o.replaceWith(e.createTextNode("\n")):o.remove();for(a=(r=n.querySelectorAll("CODE")).length;a--;)r[a].remove();i.childNodes.length&&i.append(e.createTextNode("\n")),i.append(D(n))}for(r=e.createTreeWalker(i,4);n=r.nextNode();)n.data=n.data.replace(" "," ");return i.normalize(),P(this.createElement("PRE",this._config.tagAttributes.pre,[i]),o)},$e=function(t){let n,o,i,r,s,a,l=this._root,d=t.querySelectorAll("PRE"),c=d.length;for(;c--;){for(n=d[c],o=e.createTreeWalker(n,4);i=o.nextNode();){for(r=(r=i.data).replace(/ (?= )/g," "),s=e.createDocumentFragment();(a=r.indexOf("\n"))>-1;)s.append(e.createTextNode(r.slice(0,a))),s.append(e.createElement("BR")),r=r.slice(a+1);i.before(s),i.data=r}I(n,l),n.replaceWith(D(n))}return t};Ue.code=function(){let e=this.getSelection();return e.collapsed||T(e.commonAncestorContainer)?this.modifyBlocks(Ze,e):this.changeFormat({tag:"CODE",attributes:this._config.tagAttributes.code},null,e),this.focus()},Ue.removeCode=function(){let e=this.getSelection(),t=e.commonAncestorContainer;return x(t,this._root,"PRE")?this.modifyBlocks($e,e):this.changeFormat(null,{tag:"CODE"},e),this.focus()},Ue.toggleCode=function(){return this.hasFormat("PRE")||this.hasFormat("CODE")?this.removeCode():this.code(),this},Ue.removeAllFormatting=function(n){if(!n&&!(n=this.getSelection())||n.collapsed)return this;let o=this._root,i=n.commonAncestorContainer;for(;i&&!v(i);)i=i.parentNode;if(i||(ne(n,o),i=o),i.nodeType===t)return this;this.saveUndoState(n),V(n,i,i,o);let r,s,a=n.startContainer,l=n.startOffset,d=n.endContainer,c=n.endOffset,h=e.createDocumentFragment(),f=e.createDocumentFragment(),u=F(d,c,i,o),g=F(a,l,i,o);for(;g!==u;)r=g.nextSibling,h.append(g),g=r;return function n(o,i,r){let s,a;for(s=i.firstChild;s;s=a){if(a=s.nextSibling,C(s)){if(s.nodeType===t||"BR"===s.nodeName||"IMG"===s.nodeName){r.append(s);continue}}else if(v(s)){r.append(o.createDefaultBlock([n(o,s,e.createDocumentFragment())]));continue}n(o,s,r)}return r}(this,h,f),f.normalize(),g=f.firstChild,r=f.lastChild,s=i.childNodes,g?(u.before(f),l=p(s,g),c=p(s,r)+1):c=l=p(s,u),n.setStart(i,l),n.setEnd(i,c),M(i,n),$(n),this.setSelection(n),this._updatePath(n,!0),this.focus()},Ue.increaseQuoteLevel=Qe("modifyBlocks",function(e){return this.createElement("BLOCKQUOTE",this._config.tagAttributes.blockquote,[e])}),Ue.decreaseQuoteLevel=Qe("modifyBlocks",He),Ue.changeIndentationLevel=function(e){let t=this.getSelectionClosest("UL,OL,BLOCKQUOTE");if(t||"increase"===e){this[e+(t&&"BLOCKQUOTE"!==t.nodeName?"List":"Quote")+"Level"]()}},Ue.makeUnorderedList=Qe("modifyBlocks",function(e){return ze(this,e,"UL"),e}),Ue.makeOrderedList=Qe("modifyBlocks",function(e){return ze(this,e,"OL"),e}),Ue.removeList=Qe("modifyBlocks",function(e){let t,n,o,i,r,s=e.querySelectorAll("UL, OL"),a=e.querySelectorAll("LI"),l=this._root;for(t=0,n=s.length;t<n;++t)o=s[t],i=D(o),I(i,l),o.replaceWith(i);for(t=0,n=a.length;t<n;++t)r=a[t],v(r)?r.replaceWith(this.createDefaultBlock([D(r)])):(I(r,l),r.replaceWith(D(r)));return e}),o.Squire=De})(document);