tinymce-rails 4.3.7 → 4.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c9f2676e96cc3a5dad5574f8ab53d712cf89871
-  data.tar.gz: adac5380dc67f0f9460a8b871e80dac9bb77da4a
+  metadata.gz: 93901d87a045935cc28a6792994235e6128db919
+  data.tar.gz: f5adf4ad22f9bd5fca01a2137d62bc40055e2245
 SHA512:
-  metadata.gz: 3d941436b663ba7487505ebf2c6e65dac9123c223e6ba7636d87199b719394c8338704b10193a67a110077c255b6b53b2e14d2d0512838ca4f420abcafb81387
-  data.tar.gz: 0ec890ac6b33b76bd862cf061dde2659897bdc0f1263d849be630d90a82f2583151c9fcb2f9021c65db288555ae9d0c65ba778b315333e2012a1ac841dc528a0
+  metadata.gz: 5add811679fa66c7f4002b391ded25baa216ff442f661cabc0e1364d08160c129d1a2f48be30571b9260b8168213ecac9fb8fb5aba130f186fac9e77a2a93a25
+  data.tar.gz: 917fb5ba654b40f5e641b4bf01113f3ae1902b5b0a2fac8180be40415524a4348009c5f4b27756e4634fe1f8b7fce2c8796e128ff807d264ccc65594a3bc3208

data/app/assets/source/tinymce/tinymce.js

@@ -1,4 +1,4 @@
-// 4.3.7 (2016-03-02)
+// 4.3.8 (2016-03-15)
 
 /**
  * Compiled inline version. (Library mode)
@@ -12121,8 +12121,8 @@ define("tinymce/html/Schema", [
 				});
 			}
 
-			// Add default alt attribute for images
-			elements.img.attributesDefault = [{name: 'alt', value: ''}];
+			// Add default alt attribute for images, removed since alt="" is treated as presentational.
+			// elements.img.attributesDefault = [{name: 'alt', value: ''}];
 
 			// Remove these if they are empty by default
 			each(split('ol ul sub sup blockquote span font a table tbody tr strong em b i'), function(name) {
@@ -15211,6 +15211,7 @@ define("tinymce/dom/ControlSelection", [
 			rootClass + ' div.mce-resizehandle {' +
 				'position: absolute;' +
 				'border: 1px solid black;' +
+				'box-sizing: box-sizing;' +
 				'background: #FFF;' +
 				'width: 7px;' +
 				'height: 7px;' +
@@ -18728,12 +18729,26 @@ define("tinymce/Formatter", [
 
 				alignleft: [
 					{selector: 'figure.image', collapsed: false, classes: 'align-left', ceFalseOverride: true},
-					{selector: 'figure,p,h1,h2,h3,h4,h5,h6,td,th,tr,div,ul,ol,li', styles: {textAlign: 'left'}, defaultBlock: 'div'},
+					{
+						selector: 'figure,p,h1,h2,h3,h4,h5,h6,td,th,tr,div,ul,ol,li',
+						styles: {
+							textAlign: 'left'
+						},
+						inherit: false,
+						defaultBlock: 'div'
+					},
 					{selector: 'img,table', collapsed: false, styles: {'float': 'left'}}
 				],
 
 				aligncenter: [
-					{selector: 'figure,p,h1,h2,h3,h4,h5,h6,td,th,tr,div,ul,ol,li', styles: {textAlign: 'center'}, defaultBlock: 'div'},
+					{
+						selector: 'figure,p,h1,h2,h3,h4,h5,h6,td,th,tr,div,ul,ol,li',
+						styles: {
+							textAlign: 'center'
+						},
+						inherit: false,
+						defaultBlock: 'div'
+					},
 					{selector: 'figure.image', collapsed: false, classes: 'align-center', ceFalseOverride: true},
 					{selector: 'img', collapsed: false, styles: {display: 'block', marginLeft: 'auto', marginRight: 'auto'}},
 					{selector: 'table', collapsed: false, styles: {marginLeft: 'auto', marginRight: 'auto'}}
@@ -18741,12 +18756,26 @@ define("tinymce/Formatter", [
 
 				alignright: [
 					{selector: 'figure.image', collapsed: false, classes: 'align-right', ceFalseOverride: true},
-					{selector: 'figure,p,h1,h2,h3,h4,h5,h6,td,th,tr,div,ul,ol,li', styles: {textAlign: 'right'}, defaultBlock: 'div'},
+					{
+						selector: 'figure,p,h1,h2,h3,h4,h5,h6,td,th,tr,div,ul,ol,li',
+						styles: {
+							textAlign: 'right'
+						},
+						inherit: false,
+						defaultBlock: 'div'
+					},
 					{selector: 'img,table', collapsed: false, styles: {'float': 'right'}}
 				],
 
 				alignjustify: [
-					{selector: 'figure,p,h1,h2,h3,h4,h5,h6,td,th,tr,div,ul,ol,li', styles: {textAlign: 'justify'}, defaultBlock: 'div'}
+					{
+						selector: 'figure,p,h1,h2,h3,h4,h5,h6,td,th,tr,div,ul,ol,li',
+						styles: {
+							textAlign: 'justify'
+						},
+						inherit: false,
+						defaultBlock: 'div'
+					}
 				],
 
 				bold: [
@@ -18911,6 +18940,20 @@ define("tinymce/Formatter", [
 			return formats;
 		}
 
+		function matchesUnInheritedFormatSelector(node, name) {
+			var formatList = get(name);
+
+			if (formatList) {
+				for (var i = 0; i < formatList.length; i++) {
+					if (formatList[i].inherit === false && dom.is(node, formatList[i].selector)) {
+						return true;
+					}
+				}
+			}
+
+			return false;
+		}
+
 		function getTextDecoration(node) {
 			var decoration;
 
@@ -18981,10 +19024,15 @@ define("tinymce/Formatter", [
 				}
 			}
 
+			// This converts: <p>[a</p><p>]b</p> -> <p>[a]</p><p>b</p>
 			function adjustSelectionToVisibleSelection() {
 				function findSelectionEnd(start, end) {
 					var walker = new TreeWalker(end);
-					for (node = walker.current(); node; node = walker.prev()) {
+					for (node = walker.prev2(); node; node = walker.prev2()) {
+						if (node.nodeType == 3 && node.data.length > 0) {
+							return node;
+						}
+
 						if (node.childNodes.length > 1 || node == start || node.tagName == 'BR') {
 							return node;
 						}
@@ -18999,7 +19047,7 @@ define("tinymce/Formatter", [
 
 				if (start != end && rng.endOffset === 0) {
 					var newEnd = findSelectionEnd(start, end);
-					var endOffset = newEnd.nodeType == 3 ? newEnd.length : newEnd.childNodes.length;
+					var endOffset = newEnd.nodeType == 3 ? newEnd.data.length : newEnd.childNodes.length;
 
 					rng.setEnd(newEnd, endOffset);
 				}
@@ -19669,6 +19717,10 @@ define("tinymce/Formatter", [
 
 				// Find first node with similar format settings
 				node = dom.getParent(node, function(node) {
+					if (matchesUnInheritedFormatSelector(node, name)) {
+						return true;
+					}
+
 					return node.parentNode === root || !!matchNode(node, name, vars, true);
 				});
 
@@ -19802,6 +19854,10 @@ define("tinymce/Formatter", [
 								matchedFormats[format] = callbacks;
 								return false;
 							}
+
+							if (matchesUnInheritedFormatSelector(node, format)) {
+								return false;
+							}
 						});
 					});
 
@@ -22172,10 +22228,10 @@ define("tinymce/ForceBlocks", [], function() {
 	};
 });
 
-// Included from: js/tinymce/classes/EditorCommands.js
+// Included from: js/tinymce/classes/caret/CaretUtils.js
 
 /**
- * EditorCommands.js
+ * CaretUtils.js
  *
  * Released under LGPL License.
  * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
@@ -22185,371 +22241,897 @@ define("tinymce/ForceBlocks", [], function() {
  */
 
 /**
- * This class enables you to add custom editor commands and it contains
- * overrides for native browser commands to address various bugs and issues.
+ * Utility functions shared by the caret logic.
  *
- * @class tinymce.EditorCommands
+ * @private
+ * @class tinymce.caret.CaretUtils
  */
-define("tinymce/EditorCommands", [
-	"tinymce/html/Serializer",
-	"tinymce/Env",
-	"tinymce/util/Tools",
-	"tinymce/dom/ElementUtils",
-	"tinymce/dom/RangeUtils",
-	"tinymce/dom/TreeWalker"
-], function(Serializer, Env, Tools, ElementUtils, RangeUtils, TreeWalker) {
-	// Added for compression purposes
-	var each = Tools.each, extend = Tools.extend;
-	var map = Tools.map, inArray = Tools.inArray, explode = Tools.explode;
-	var isIE = Env.ie, isOldIE = Env.ie && Env.ie < 11;
-	var TRUE = true, FALSE = false;
-
-	return function(editor) {
-		var dom, selection, formatter,
-			commands = {state: {}, exec: {}, value: {}},
-			settings = editor.settings,
-			bookmark;
-
-		editor.on('PreInit', function() {
-			dom = editor.dom;
-			selection = editor.selection;
-			settings = editor.settings;
-			formatter = editor.formatter;
-		});
-
-		/**
-		 * Executes the specified command.
-		 *
-		 * @method execCommand
-		 * @param {String} command Command to execute.
-		 * @param {Boolean} ui Optional user interface state.
-		 * @param {Object} value Optional value for command.
-		 * @param {Object} args Optional extra arguments to the execCommand.
-		 * @return {Boolean} true/false if the command was found or not.
-		 */
-		function execCommand(command, ui, value, args) {
-			var func, customCommand, state = 0;
+define("tinymce/caret/CaretUtils", [
+	"tinymce/util/Fun",
+	"tinymce/dom/TreeWalker",
+	"tinymce/dom/NodeType",
+	"tinymce/caret/CaretPosition",
+	"tinymce/caret/CaretContainer",
+	"tinymce/caret/CaretCandidate"
+], function(Fun, TreeWalker, NodeType, CaretPosition, CaretContainer, CaretCandidate) {
+	var isContentEditableTrue = NodeType.isContentEditableTrue,
+		isContentEditableFalse = NodeType.isContentEditableFalse,
+		isBlockLike = NodeType.matchStyleValues('display', 'block table table-cell table-caption'),
+		isCaretContainer = CaretContainer.isCaretContainer,
+		curry = Fun.curry,
+		isElement = NodeType.isElement,
+		isCaretCandidate = CaretCandidate.isCaretCandidate;
 
-			if (!/^(mceAddUndoLevel|mceEndUndoLevel|mceBeginUndoLevel|mceRepaint)$/.test(command) && (!args || !args.skip_focus)) {
-				editor.focus();
-			}
+	function isForwards(direction) {
+		return direction > 0;
+	}
 
-			args = editor.fire('BeforeExecCommand', {command: command, ui: ui, value: value});
-			if (args.isDefaultPrevented()) {
-				return false;
-			}
+	function isBackwards(direction) {
+		return direction < 0;
+	}
 
-			customCommand = command.toLowerCase();
-			if ((func = commands.exec[customCommand])) {
-				func(customCommand, ui, value);
-				editor.fire('ExecCommand', {command: command, ui: ui, value: value});
-				return true;
-			}
+	function findNode(node, direction, predicateFn, rootNode, shallow) {
+		var walker = new TreeWalker(node, rootNode);
 
-			// Plugin commands
-			each(editor.plugins, function(p) {
-				if (p.execCommand && p.execCommand(command, ui, value)) {
-					editor.fire('ExecCommand', {command: command, ui: ui, value: value});
-					state = true;
-					return false;
+		if (isBackwards(direction)) {
+			if (isContentEditableFalse(node)) {
+				node = walker.prev(true);
+				if (predicateFn(node)) {
+					return node;
 				}
-			});
-
-			if (state) {
-				return state;
 			}
 
-			// Theme commands
-			if (editor.theme && editor.theme.execCommand && editor.theme.execCommand(command, ui, value)) {
-				editor.fire('ExecCommand', {command: command, ui: ui, value: value});
-				return true;
+			while ((node = walker.prev(shallow))) {
+				if (predicateFn(node)) {
+					return node;
+				}
 			}
+		}
 
-			// Browser commands
-			try {
-				state = editor.getDoc().execCommand(command, ui, value);
-			} catch (ex) {
-				// Ignore old IE errors
+		if (isForwards(direction)) {
+			if (isContentEditableFalse(node)) {
+				node = walker.next(true);
+				if (predicateFn(node)) {
+					return node;
+				}
 			}
 
-			if (state) {
-				editor.fire('ExecCommand', {command: command, ui: ui, value: value});
-				return true;
+			while ((node = walker.next(shallow))) {
+				if (predicateFn(node)) {
+					return node;
+				}
 			}
-
-			return false;
 		}
 
-		/**
-		 * Queries the current state for a command for example if the current selection is "bold".
-		 *
-		 * @method queryCommandState
-		 * @param {String} command Command to check the state of.
-		 * @return {Boolean/Number} true/false if the selected contents is bold or not, -1 if it's not found.
-		 */
-		function queryCommandState(command) {
-			var func;
+		return null;
+	}
 
-			// Is hidden then return undefined
-			if (editor._isHidden()) {
-				return;
+	function getEditingHost(node, rootNode) {
+		for (node = node.parentNode; node && node != rootNode; node = node.parentNode) {
+			if (isContentEditableTrue(node)) {
+				return node;
 			}
+		}
 
-			command = command.toLowerCase();
-			if ((func = commands.state[command])) {
-				return func(command);
-			}
+		return rootNode;
+	}
 
-			// Browser commands
-			try {
-				return editor.getDoc().queryCommandState(command);
-			} catch (ex) {
-				// Fails sometimes see bug: 1896577
+	function getParentBlock(node, rootNode) {
+		while (node && node != rootNode) {
+			if (isBlockLike(node)) {
+				return node;
 			}
 
-			return false;
+			node = node.parentNode;
 		}
 
-		/**
-		 * Queries the command value for example the current fontsize.
-		 *
-		 * @method queryCommandValue
-		 * @param {String} command Command to check the value of.
-		 * @return {Object} Command value of false if it's not found.
-		 */
-		function queryCommandValue(command) {
-			var func;
+		return null;
+	}
 
-			// Is hidden then return undefined
-			if (editor._isHidden()) {
-				return;
-			}
+	function isInSameBlock(caretPosition1, caretPosition2, rootNode) {
+		return getParentBlock(caretPosition1.container(), rootNode) == getParentBlock(caretPosition2.container(), rootNode);
+	}
 
-			command = command.toLowerCase();
-			if ((func = commands.value[command])) {
-				return func(command);
-			}
+	function isInSameEditingHost(caretPosition1, caretPosition2, rootNode) {
+		return getEditingHost(caretPosition1.container(), rootNode) == getEditingHost(caretPosition2.container(), rootNode);
+	}
 
-			// Browser commands
-			try {
-				return editor.getDoc().queryCommandValue(command);
-			} catch (ex) {
-				// Fails sometimes see bug: 1896577
-			}
+	function getChildNodeAtRelativeOffset(relativeOffset, caretPosition) {
+		var container, offset;
+
+		if (!caretPosition) {
+			return null;
 		}
 
-		/**
-		 * Adds commands to the command collection.
-		 *
-		 * @method addCommands
-		 * @param {Object} command_list Name/value collection with commands to add, the names can also be comma separated.
-		 * @param {String} type Optional type to add, defaults to exec. Can be value or state as well.
-		 */
-		function addCommands(command_list, type) {
-			type = type || 'exec';
+		container = caretPosition.container();
+		offset = caretPosition.offset();
 
-			each(command_list, function(callback, command) {
-				each(command.toLowerCase().split(','), function(command) {
-					commands[type][command] = callback;
-				});
-			});
+		if (!isElement(container)) {
+			return null;
 		}
 
-		function addCommand(command, callback, scope) {
-			command = command.toLowerCase();
-			commands.exec[command] = function(command, ui, value, args) {
-				return callback.call(scope || editor, ui, value, args);
-			};
-		}
+		return container.childNodes[offset + relativeOffset];
+	}
 
-		/**
-		 * Returns true/false if the command is supported or not.
-		 *
-		 * @method queryCommandSupported
-		 * @param {String} command Command that we check support for.
-		 * @return {Boolean} true/false if the command is supported or not.
-		 */
-		function queryCommandSupported(command) {
-			command = command.toLowerCase();
+	function beforeAfter(before, node) {
+		var range = node.ownerDocument.createRange();
 
-			if (commands.exec[command]) {
-				return true;
-			}
+		if (before) {
+			range.setStartBefore(node);
+			range.setEndBefore(node);
+		} else {
+			range.setStartAfter(node);
+			range.setEndAfter(node);
+		}
 
-			// Browser commands
-			try {
-				return editor.getDoc().queryCommandSupported(command);
-			} catch (ex) {
-				// Fails sometimes see bug: 1896577
-			}
+		return range;
+	}
 
-			return false;
-		}
+	function isNodesInSameBlock(rootNode, node1, node2) {
+		return getParentBlock(node1, rootNode) == getParentBlock(node2, rootNode);
+	}
 
-		function addQueryStateHandler(command, callback, scope) {
-			command = command.toLowerCase();
-			commands.state[command] = function() {
-				return callback.call(scope || editor);
-			};
-		}
+	function lean(left, rootNode, node) {
+		var sibling, siblingName;
 
-		function addQueryValueHandler(command, callback, scope) {
-			command = command.toLowerCase();
-			commands.value[command] = function() {
-				return callback.call(scope || editor);
-			};
+		if (left) {
+			siblingName = 'previousSibling';
+		} else {
+			siblingName = 'nextSibling';
 		}
 
-		function hasCustomCommand(command) {
-			command = command.toLowerCase();
-			return !!commands.exec[command];
-		}
+		while (node && node != rootNode) {
+			sibling = node[siblingName];
 
-		// Expose public methods
-		extend(this, {
-			execCommand: execCommand,
-			queryCommandState: queryCommandState,
-			queryCommandValue: queryCommandValue,
-			queryCommandSupported: queryCommandSupported,
-			addCommands: addCommands,
-			addCommand: addCommand,
-			addQueryStateHandler: addQueryStateHandler,
-			addQueryValueHandler: addQueryValueHandler,
-			hasCustomCommand: hasCustomCommand
-		});
+			if (isCaretContainer(sibling)) {
+				sibling = sibling[siblingName];
+			}
 
-		// Private methods
+			if (isContentEditableFalse(sibling)) {
+				if (isNodesInSameBlock(rootNode, sibling, node)) {
+					return sibling;
+				}
 
-		function execNativeCommand(command, ui, value) {
-			if (ui === undefined) {
-				ui = FALSE;
+				break;
 			}
 
-			if (value === undefined) {
-				value = null;
+			if (isCaretCandidate(sibling)) {
+				break;
 			}
 
-			return editor.getDoc().execCommand(command, ui, value);
+			node = node.parentNode;
 		}
 
-		function isFormatMatch(name) {
-			return formatter.match(name);
-		}
+		return null;
+	}
 
-		function toggleFormat(name, value) {
-			formatter.toggle(name, value ? {value: value} : undefined);
-			editor.nodeChanged();
-		}
+	var before = curry(beforeAfter, true);
+	var after = curry(beforeAfter, false);
 
-		function storeSelection(type) {
-			bookmark = selection.getBookmark(type);
-		}
+	function normalizeRange(direction, rootNode, range) {
+		var node, container, offset, location;
+		var leanLeft = curry(lean, true, rootNode);
+		var leanRight = curry(lean, false, rootNode);
 
-		function restoreSelection() {
-			selection.moveToBookmark(bookmark);
-		}
+		container = range.startContainer;
+		offset = range.startOffset;
 
-		// Add execCommand overrides
-		addCommands({
-			// Ignore these, added for compatibility
-			'mceResetDesignMode,mceBeginUndoLevel': function() {},
+		if (CaretContainer.isCaretContainerBlock(container)) {
+			if (!isElement(container)) {
+				container = container.parentNode;
+			}
 
-			// Add undo manager logic
-			'mceEndUndoLevel,mceAddUndoLevel': function() {
-				editor.undoManager.add();
-			},
+			location = container.getAttribute('data-mce-caret');
 
-			'Cut,Copy,Paste': function(command) {
-				var doc = editor.getDoc(), failed;
+			if (location == 'before') {
+				node = container.nextSibling;
+				if (isContentEditableFalse(node)) {
+					return before(node);
+				}
+			}
 
-				// Try executing the native command
-				try {
-					execNativeCommand(command);
-				} catch (ex) {
-					// Command failed
-					failed = TRUE;
+			if (location == 'after') {
+				node = container.previousSibling;
+				if (isContentEditableFalse(node)) {
+					return after(node);
 				}
+			}
+		}
 
-				// Present alert message about clipboard access not being available
-				if (failed || !doc.queryCommandSupported(command)) {
-					var msg = editor.translate(
-						"Your browser doesn't support direct access to the clipboard. " +
-						"Please use the Ctrl+X/C/V keyboard shortcuts instead."
-					);
+		if (!range.collapsed) {
+			return range;
+		}
 
-					if (Env.mac) {
-						msg = msg.replace(/Ctrl\+/g, '\u2318+');
+		if (NodeType.isText(container)) {
+			if (isCaretContainer(container)) {
+				if (direction === 1) {
+					node = leanRight(container);
+					if (node) {
+						return before(node);
 					}
 
-					editor.notificationManager.open({text: msg, type: 'error'});
+					node = leanLeft(container);
+					if (node) {
+						return after(node);
+					}
 				}
-			},
 
-			// Override unlink command
-			unlink: function() {
-				if (selection.isCollapsed()) {
-					var elm = selection.getNode();
-					if (elm.tagName == 'A') {
-						editor.dom.remove(elm, true);
+				if (direction === -1) {
+					node = leanLeft(container);
+					if (node) {
+						return after(node);
 					}
 
-					return;
+					node = leanRight(container);
+					if (node) {
+						return before(node);
+					}
 				}
 
-				formatter.remove("link");
-			},
-
-			// Override justify commands to use the text formatter engine
-			'JustifyLeft,JustifyCenter,JustifyRight,JustifyFull,JustifyNone': function(command) {
-				var align = command.substring(7);
+				return range;
+			}
 
-				if (align == 'full') {
-					align = 'justify';
+			if (CaretContainer.endsWithCaretContainer(container) && offset >= container.data.length - 1) {
+				if (direction === 1) {
+					node = leanRight(container);
+					if (node) {
+						return before(node);
+					}
 				}
 
-				// Remove all other alignments first
-				each('left,center,right,justify'.split(','), function(name) {
-					if (align != name) {
-						formatter.remove('align' + name);
-					}
-				});
+				return range;
+			}
 
-				if (align != 'none') {
-					toggleFormat('align' + align);
+			if (CaretContainer.startsWithCaretContainer(container) && offset <= 1) {
+				if (direction === -1) {
+					node = leanLeft(container);
+					if (node) {
+						return after(node);
+					}
 				}
-			},
 
-			// Override list commands to fix WebKit bug
-			'InsertUnorderedList,InsertOrderedList': function(command) {
-				var listElm, listParent;
+				return range;
+			}
 
-				execNativeCommand(command);
+			if (offset === container.data.length) {
+				node = leanRight(container);
+				if (node) {
+					return before(node);
+				}
 
-				// WebKit produces lists within block elements so we need to split them
-				// we will replace the native list creation logic to custom logic later on
-				// TODO: Remove this when the list creation logic is removed
-				listElm = dom.getParent(selection.getNode(), 'ol,ul');
-				if (listElm) {
-					listParent = listElm.parentNode;
+				return range;
+			}
 
-					// If list is within a text block then split that block
-					if (/^(H[1-6]|P|ADDRESS|PRE)$/.test(listParent.nodeName)) {
-						storeSelection();
-						dom.split(listParent, listElm);
-						restoreSelection();
-					}
+			if (offset === 0) {
+				node = leanLeft(container);
+				if (node) {
+					return after(node);
 				}
-			},
 
-			// Override commands to use the text formatter engine
-			'Bold,Italic,Underline,Strikethrough,Superscript,Subscript': function(command) {
-				toggleFormat(command);
-			},
+				return range;
+			}
+		}
 
-			// Override commands to use the text formatter engine
-			'ForeColor,HiliteColor,FontName': function(command, ui, value) {
-				toggleFormat(command, value);
-			},
+		return range;
+	}
+
+	function isNextToContentEditableFalse(relativeOffset, caretPosition) {
+		return isContentEditableFalse(getChildNodeAtRelativeOffset(relativeOffset, caretPosition));
+	}
+
+	return {
+		isForwards: isForwards,
+		isBackwards: isBackwards,
+		findNode: findNode,
+		getEditingHost: getEditingHost,
+		getParentBlock: getParentBlock,
+		isInSameBlock: isInSameBlock,
+		isInSameEditingHost: isInSameEditingHost,
+		isBeforeContentEditableFalse: curry(isNextToContentEditableFalse, 0),
+		isAfterContentEditableFalse: curry(isNextToContentEditableFalse, -1),
+		normalizeRange: normalizeRange
+	};
+});
+
+// Included from: js/tinymce/classes/caret/CaretWalker.js
+
+/**
+ * CaretWalker.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This module contains logic for moving around a virtual caret in logical order within a DOM element.
+ *
+ * It ignores the most obvious invalid caret locations such as within a script element or within a
+ * contentEditable=false element but it will return locations that isn't possible to render visually.
+ *
+ * @private
+ * @class tinymce.caret.CaretWalker
+ * @example
+ * var caretWalker = new CaretWalker(rootElm);
+ *
+ * var prevLogicalCaretPosition = caretWalker.prev(CaretPosition.fromRangeStart(range));
+ * var nextLogicalCaretPosition = caretWalker.next(CaretPosition.fromRangeEnd(range));
+ */
+define("tinymce/caret/CaretWalker", [
+	"tinymce/dom/NodeType",
+	"tinymce/caret/CaretCandidate",
+	"tinymce/caret/CaretPosition",
+	"tinymce/caret/CaretUtils",
+	"tinymce/util/Arr",
+	"tinymce/util/Fun"
+], function(NodeType, CaretCandidate, CaretPosition, CaretUtils, Arr, Fun) {
+	var isContentEditableFalse = NodeType.isContentEditableFalse,
+		isText = NodeType.isText,
+		isElement = NodeType.isElement,
+		isForwards = CaretUtils.isForwards,
+		isBackwards = CaretUtils.isBackwards,
+		isCaretCandidate = CaretCandidate.isCaretCandidate,
+		isAtomic = CaretCandidate.isAtomic,
+		isEditableCaretCandidate = CaretCandidate.isEditableCaretCandidate;
+
+	function getParents(node, rootNode) {
+		var parents = [];
+
+		while (node && node != rootNode) {
+			parents.push(node);
+			node = node.parentNode;
+		}
+
+		return parents;
+	}
+
+	function nodeAtIndex(container, offset) {
+		if (container.hasChildNodes() && offset < container.childNodes.length) {
+			return container.childNodes[offset];
+		}
+
+		return null;
+	}
+
+	function getCaretCandidatePosition(direction, node) {
+		if (isForwards(direction)) {
+			if (isCaretCandidate(node.previousSibling) && !isText(node.previousSibling)) {
+				return CaretPosition.before(node);
+			}
+
+			if (isText(node)) {
+				return CaretPosition(node, 0);
+			}
+		}
+
+		if (isBackwards(direction)) {
+			if (isCaretCandidate(node.nextSibling) && !isText(node.nextSibling)) {
+				return CaretPosition.after(node);
+			}
+
+			if (isText(node)) {
+				return CaretPosition(node, node.data.length);
+			}
+		}
+
+		if (isBackwards(direction)) {
+			return CaretPosition.after(node);
+		}
+
+		return CaretPosition.before(node);
+	}
+
+	function findCaretPosition(direction, startCaretPosition, rootNode) {
+		var container, offset, node, nextNode, innerNode,
+			rootContentEditableFalseElm, caretPosition;
+
+		if (!isElement(rootNode) || !startCaretPosition) {
+			return null;
+		}
+
+		caretPosition = startCaretPosition;
+		container = caretPosition.container();
+		offset = caretPosition.offset();
+
+		if (isText(container)) {
+			if (isBackwards(direction) && offset > 0) {
+				return CaretPosition(container, --offset);
+			}
+
+			if (isForwards(direction) && offset < container.length) {
+				return CaretPosition(container, ++offset);
+			}
+
+			node = container;
+		} else {
+			if (isBackwards(direction) && offset > 0) {
+				nextNode = nodeAtIndex(container, offset - 1);
+				if (isCaretCandidate(nextNode)) {
+					if (!isAtomic(nextNode)) {
+						innerNode = CaretUtils.findNode(nextNode, direction, isEditableCaretCandidate, nextNode);
+						if (innerNode) {
+							if (isText(innerNode)) {
+								return CaretPosition(innerNode, innerNode.data.length);
+							}
+
+							return CaretPosition.after(innerNode);
+						}
+					}
+
+					if (isText(nextNode)) {
+						return CaretPosition(nextNode, nextNode.data.length);
+					}
+
+					return CaretPosition.before(nextNode);
+				}
+			}
+
+			if (isForwards(direction) && offset < container.childNodes.length) {
+				nextNode = nodeAtIndex(container, offset);
+				if (isCaretCandidate(nextNode)) {
+					if (!isAtomic(nextNode)) {
+						innerNode = CaretUtils.findNode(nextNode, direction, isEditableCaretCandidate, nextNode);
+						if (innerNode) {
+							if (isText(innerNode)) {
+								return CaretPosition(innerNode, 0);
+							}
+
+							return CaretPosition.before(innerNode);
+						}
+					}
+
+					if (isText(nextNode)) {
+						return CaretPosition(nextNode, 0);
+					}
+
+					return CaretPosition.after(nextNode);
+				}
+			}
+
+			node = caretPosition.getNode();
+		}
+
+		if ((isForwards(direction) && caretPosition.isAtEnd()) || (isBackwards(direction) && caretPosition.isAtStart())) {
+			node = CaretUtils.findNode(node, direction, Fun.constant(true), rootNode, true);
+			if (isEditableCaretCandidate(node)) {
+				return getCaretCandidatePosition(direction, node);
+			}
+		}
+
+		nextNode = CaretUtils.findNode(node, direction, isEditableCaretCandidate, rootNode);
+
+		rootContentEditableFalseElm = Arr.last(Arr.filter(getParents(container, rootNode), isContentEditableFalse));
+		if (rootContentEditableFalseElm && (!nextNode || !rootContentEditableFalseElm.contains(nextNode))) {
+			if (isForwards(direction)) {
+				caretPosition = CaretPosition.after(rootContentEditableFalseElm);
+			} else {
+				caretPosition = CaretPosition.before(rootContentEditableFalseElm);
+			}
+
+			return caretPosition;
+		}
+
+		if (nextNode) {
+			return getCaretCandidatePosition(direction, nextNode);
+		}
+
+		return null;
+	}
+
+	return function(rootNode) {
+		return {
+			/**
+			 * Returns the next logical caret position from the specificed input
+			 * caretPoisiton or null if there isn't any more positions left for example
+			 * at the end specified root element.
+			 *
+			 * @method next
+			 * @param {tinymce.caret.CaretPosition} caretPosition Caret position to start from.
+			 * @return {tinymce.caret.CaretPosition} CaretPosition or null if no position was found.
+			 */
+			next: function(caretPosition) {
+				return findCaretPosition(1, caretPosition, rootNode);
+			},
+
+			/**
+			 * Returns the previous logical caret position from the specificed input
+			 * caretPoisiton or null if there isn't any more positions left for example
+			 * at the end specified root element.
+			 *
+			 * @method prev
+			 * @param {tinymce.caret.CaretPosition} caretPosition Caret position to start from.
+			 * @return {tinymce.caret.CaretPosition} CaretPosition or null if no position was found.
+			 */
+			prev: function(caretPosition) {
+				return findCaretPosition(-1, caretPosition, rootNode);
+			}
+		};
+	};
+});
+
+// Included from: js/tinymce/classes/EditorCommands.js
+
+/**
+ * EditorCommands.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * This class enables you to add custom editor commands and it contains
+ * overrides for native browser commands to address various bugs and issues.
+ *
+ * @class tinymce.EditorCommands
+ */
+define("tinymce/EditorCommands", [
+	"tinymce/html/Serializer",
+	"tinymce/Env",
+	"tinymce/util/Tools",
+	"tinymce/dom/ElementUtils",
+	"tinymce/dom/RangeUtils",
+	"tinymce/dom/TreeWalker",
+	"tinymce/caret/CaretWalker",
+	"tinymce/caret/CaretPosition",
+	"tinymce/dom/NodeType"
+], function(Serializer, Env, Tools, ElementUtils, RangeUtils, TreeWalker, CaretWalker, CaretPosition, NodeType) {
+	// Added for compression purposes
+	var each = Tools.each, extend = Tools.extend;
+	var map = Tools.map, inArray = Tools.inArray, explode = Tools.explode;
+	var isIE = Env.ie, isOldIE = Env.ie && Env.ie < 11;
+	var TRUE = true, FALSE = false, isTableCell = NodeType.matchNodeNames('td th');
+
+	return function(editor) {
+		var dom, selection, formatter,
+			commands = {state: {}, exec: {}, value: {}},
+			settings = editor.settings,
+			bookmark;
+
+		editor.on('PreInit', function() {
+			dom = editor.dom;
+			selection = editor.selection;
+			settings = editor.settings;
+			formatter = editor.formatter;
+		});
+
+		/**
+		 * Executes the specified command.
+		 *
+		 * @method execCommand
+		 * @param {String} command Command to execute.
+		 * @param {Boolean} ui Optional user interface state.
+		 * @param {Object} value Optional value for command.
+		 * @param {Object} args Optional extra arguments to the execCommand.
+		 * @return {Boolean} true/false if the command was found or not.
+		 */
+		function execCommand(command, ui, value, args) {
+			var func, customCommand, state = 0;
+
+			if (!/^(mceAddUndoLevel|mceEndUndoLevel|mceBeginUndoLevel|mceRepaint)$/.test(command) && (!args || !args.skip_focus)) {
+				editor.focus();
+			}
+
+			args = editor.fire('BeforeExecCommand', {command: command, ui: ui, value: value});
+			if (args.isDefaultPrevented()) {
+				return false;
+			}
+
+			customCommand = command.toLowerCase();
+			if ((func = commands.exec[customCommand])) {
+				func(customCommand, ui, value);
+				editor.fire('ExecCommand', {command: command, ui: ui, value: value});
+				return true;
+			}
+
+			// Plugin commands
+			each(editor.plugins, function(p) {
+				if (p.execCommand && p.execCommand(command, ui, value)) {
+					editor.fire('ExecCommand', {command: command, ui: ui, value: value});
+					state = true;
+					return false;
+				}
+			});
+
+			if (state) {
+				return state;
+			}
+
+			// Theme commands
+			if (editor.theme && editor.theme.execCommand && editor.theme.execCommand(command, ui, value)) {
+				editor.fire('ExecCommand', {command: command, ui: ui, value: value});
+				return true;
+			}
+
+			// Browser commands
+			try {
+				state = editor.getDoc().execCommand(command, ui, value);
+			} catch (ex) {
+				// Ignore old IE errors
+			}
+
+			if (state) {
+				editor.fire('ExecCommand', {command: command, ui: ui, value: value});
+				return true;
+			}
+
+			return false;
+		}
+
+		/**
+		 * Queries the current state for a command for example if the current selection is "bold".
+		 *
+		 * @method queryCommandState
+		 * @param {String} command Command to check the state of.
+		 * @return {Boolean/Number} true/false if the selected contents is bold or not, -1 if it's not found.
+		 */
+		function queryCommandState(command) {
+			var func;
+
+			// Is hidden then return undefined
+			if (editor._isHidden()) {
+				return;
+			}
+
+			command = command.toLowerCase();
+			if ((func = commands.state[command])) {
+				return func(command);
+			}
+
+			// Browser commands
+			try {
+				return editor.getDoc().queryCommandState(command);
+			} catch (ex) {
+				// Fails sometimes see bug: 1896577
+			}
+
+			return false;
+		}
+
+		/**
+		 * Queries the command value for example the current fontsize.
+		 *
+		 * @method queryCommandValue
+		 * @param {String} command Command to check the value of.
+		 * @return {Object} Command value of false if it's not found.
+		 */
+		function queryCommandValue(command) {
+			var func;
+
+			// Is hidden then return undefined
+			if (editor._isHidden()) {
+				return;
+			}
+
+			command = command.toLowerCase();
+			if ((func = commands.value[command])) {
+				return func(command);
+			}
+
+			// Browser commands
+			try {
+				return editor.getDoc().queryCommandValue(command);
+			} catch (ex) {
+				// Fails sometimes see bug: 1896577
+			}
+		}
+
+		/**
+		 * Adds commands to the command collection.
+		 *
+		 * @method addCommands
+		 * @param {Object} command_list Name/value collection with commands to add, the names can also be comma separated.
+		 * @param {String} type Optional type to add, defaults to exec. Can be value or state as well.
+		 */
+		function addCommands(command_list, type) {
+			type = type || 'exec';
+
+			each(command_list, function(callback, command) {
+				each(command.toLowerCase().split(','), function(command) {
+					commands[type][command] = callback;
+				});
+			});
+		}
+
+		function addCommand(command, callback, scope) {
+			command = command.toLowerCase();
+			commands.exec[command] = function(command, ui, value, args) {
+				return callback.call(scope || editor, ui, value, args);
+			};
+		}
+
+		/**
+		 * Returns true/false if the command is supported or not.
+		 *
+		 * @method queryCommandSupported
+		 * @param {String} command Command that we check support for.
+		 * @return {Boolean} true/false if the command is supported or not.
+		 */
+		function queryCommandSupported(command) {
+			command = command.toLowerCase();
+
+			if (commands.exec[command]) {
+				return true;
+			}
+
+			// Browser commands
+			try {
+				return editor.getDoc().queryCommandSupported(command);
+			} catch (ex) {
+				// Fails sometimes see bug: 1896577
+			}
+
+			return false;
+		}
+
+		function addQueryStateHandler(command, callback, scope) {
+			command = command.toLowerCase();
+			commands.state[command] = function() {
+				return callback.call(scope || editor);
+			};
+		}
+
+		function addQueryValueHandler(command, callback, scope) {
+			command = command.toLowerCase();
+			commands.value[command] = function() {
+				return callback.call(scope || editor);
+			};
+		}
+
+		function hasCustomCommand(command) {
+			command = command.toLowerCase();
+			return !!commands.exec[command];
+		}
+
+		// Expose public methods
+		extend(this, {
+			execCommand: execCommand,
+			queryCommandState: queryCommandState,
+			queryCommandValue: queryCommandValue,
+			queryCommandSupported: queryCommandSupported,
+			addCommands: addCommands,
+			addCommand: addCommand,
+			addQueryStateHandler: addQueryStateHandler,
+			addQueryValueHandler: addQueryValueHandler,
+			hasCustomCommand: hasCustomCommand
+		});
+
+		// Private methods
+
+		function execNativeCommand(command, ui, value) {
+			if (ui === undefined) {
+				ui = FALSE;
+			}
+
+			if (value === undefined) {
+				value = null;
+			}
+
+			return editor.getDoc().execCommand(command, ui, value);
+		}
+
+		function isFormatMatch(name) {
+			return formatter.match(name);
+		}
+
+		function toggleFormat(name, value) {
+			formatter.toggle(name, value ? {value: value} : undefined);
+			editor.nodeChanged();
+		}
+
+		function storeSelection(type) {
+			bookmark = selection.getBookmark(type);
+		}
+
+		function restoreSelection() {
+			selection.moveToBookmark(bookmark);
+		}
+
+		// Add execCommand overrides
+		addCommands({
+			// Ignore these, added for compatibility
+			'mceResetDesignMode,mceBeginUndoLevel': function() {},
+
+			// Add undo manager logic
+			'mceEndUndoLevel,mceAddUndoLevel': function() {
+				editor.undoManager.add();
+			},
+
+			'Cut,Copy,Paste': function(command) {
+				var doc = editor.getDoc(), failed;
+
+				// Try executing the native command
+				try {
+					execNativeCommand(command);
+				} catch (ex) {
+					// Command failed
+					failed = TRUE;
+				}
+
+				// Present alert message about clipboard access not being available
+				if (failed || !doc.queryCommandSupported(command)) {
+					var msg = editor.translate(
+						"Your browser doesn't support direct access to the clipboard. " +
+						"Please use the Ctrl+X/C/V keyboard shortcuts instead."
+					);
+
+					if (Env.mac) {
+						msg = msg.replace(/Ctrl\+/g, '\u2318+');
+					}
+
+					editor.notificationManager.open({text: msg, type: 'error'});
+				}
+			},
+
+			// Override unlink command
+			unlink: function() {
+				if (selection.isCollapsed()) {
+					var elm = selection.getNode();
+					if (elm.tagName == 'A') {
+						editor.dom.remove(elm, true);
+					}
+
+					return;
+				}
+
+				formatter.remove("link");
+			},
+
+			// Override justify commands to use the text formatter engine
+			'JustifyLeft,JustifyCenter,JustifyRight,JustifyFull,JustifyNone': function(command) {
+				var align = command.substring(7);
+
+				if (align == 'full') {
+					align = 'justify';
+				}
+
+				// Remove all other alignments first
+				each('left,center,right,justify'.split(','), function(name) {
+					if (align != name) {
+						formatter.remove('align' + name);
+					}
+				});
+
+				if (align != 'none') {
+					toggleFormat('align' + align);
+				}
+			},
+
+			// Override list commands to fix WebKit bug
+			'InsertUnorderedList,InsertOrderedList': function(command) {
+				var listElm, listParent;
+
+				execNativeCommand(command);
+
+				// WebKit produces lists within block elements so we need to split them
+				// we will replace the native list creation logic to custom logic later on
+				// TODO: Remove this when the list creation logic is removed
+				listElm = dom.getParent(selection.getNode(), 'ol,ul');
+				if (listElm) {
+					listParent = listElm.parentNode;
+
+					// If list is within a text block then split that block
+					if (/^(H[1-6]|P|ADDRESS|PRE)$/.test(listParent.nodeName)) {
+						storeSelection();
+						dom.split(listParent, listElm);
+						restoreSelection();
+					}
+				}
+			},
+
+			// Override commands to use the text formatter engine
+			'Bold,Italic,Underline,Strikethrough,Superscript,Subscript': function(command) {
+				toggleFormat(command);
+			},
+
+			// Override commands to use the text formatter engine
+			'ForeColor,HiliteColor,FontName': function(command, ui, value) {
+				toggleFormat(command, value);
+			},
 
 			FontSize: function(command, ui, value) {
 				var fontClasses, fontSizes;
@@ -22704,7 +23286,7 @@ define("tinymce/EditorCommands", [
 				}
 
 				function moveSelectionToMarker(marker) {
-					var parentEditableFalseElm;
+					var parentEditableFalseElm, parentNode, nextRng;
 
 					function getContentEditableFalseParent(node) {
 						var root = editor.getBody();
@@ -22754,8 +23336,34 @@ define("tinymce/EditorCommands", [
 						rng.setEndBefore(marker);
 					}
 
+					function findNextCaretRng(rng) {
+						var caretPos = CaretPosition.fromRangeStart(rng);
+						var caretWalker = new CaretWalker(editor.getBody());
+
+						caretPos = caretWalker.next(caretPos);
+						if (caretPos) {
+							return caretPos.toRange();
+						}
+					}
+
 					// Remove the marker node and set the new range
+					parentNode = marker.parentNode;
 					dom.remove(marker);
+
+					if (dom.isEmpty(parentNode) && dom.isBlock(parentNode)) {
+						editor.$(parentNode).empty();
+
+						rng.setStart(parentNode, 0);
+						rng.setEnd(parentNode, 0);
+
+						if (!isTableCell(parentNode) && (nextRng = findNextCaretRng(rng))) {
+							rng = nextRng;
+							dom.remove(parentNode);
+						} else {
+							dom.add(parentNode, dom.create('br', {'data-mce-bogus': '1'}));
+						}
+					}
+
 					selection.setRng(rng);
 				}
 
@@ -29518,6 +30126,7 @@ define("tinymce/ui/Window", [
 
 			setTimeout(function() {
 				self.classes.add('in');
+				self.fire('open');
 			}, 0);
 
 			self._super();
@@ -32626,499 +33235,71 @@ define("tinymce/EditorObservable", [
 		},
 
 		/**
-		 * Toggles a native event on/off this is called by the EventDispatcher when
-		 * the first native event handler is added and when the last native event handler is removed.
-		 *
-		 * @private
-		 */
-		toggleNativeEvent: function(name, state) {
-			var self = this;
-
-			// Never bind focus/blur since the FocusManager fakes those
-			if (name == "focus" || name == "blur") {
-				return;
-			}
-
-			if (state) {
-				if (self.initialized) {
-					bindEventDelegate(self, name);
-				} else {
-					if (!self._pendingNativeEvents) {
-						self._pendingNativeEvents = [name];
-					} else {
-						self._pendingNativeEvents.push(name);
-					}
-				}
-			} else if (self.initialized) {
-				self.dom.unbind(getEventTarget(self, name), name, self.delegates[name]);
-				delete self.delegates[name];
-			}
-		},
-
-		/**
-		 * Unbinds all native event handlers that means delegates, custom events bound using the Events API etc.
-		 *
-		 * @private
-		 */
-		unbindAllNativeEvents: function() {
-			var self = this, name;
-
-			if (self.delegates) {
-				for (name in self.delegates) {
-					self.dom.unbind(getEventTarget(self, name), name, self.delegates[name]);
-				}
-
-				delete self.delegates;
-			}
-
-			if (!self.inline) {
-				self.getBody().onload = null;
-				self.dom.unbind(self.getWin());
-				self.dom.unbind(self.getDoc());
-			}
-
-			self.dom.unbind(self.getBody());
-			self.dom.unbind(self.getContainer());
-		}
-	};
-
-	EditorObservable = Tools.extend({}, Observable, EditorObservable);
-
-	return EditorObservable;
-});
-
-// Included from: js/tinymce/classes/Mode.js
-
-/**
- * Mode.js
- *
- * Released under LGPL License.
- * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
- *
- * License: http://www.tinymce.com/license
- * Contributing: http://www.tinymce.com/contributing
- */
-
-/**
- * Mode switcher logic.
- *
- * @private
- * @class tinymce.Mode
- */
-define("tinymce/Mode", [], function() {
-	function setEditorCommandState(editor, cmd, state) {
-		try {
-			editor.getDoc().execCommand(cmd, false, state);
-		} catch (ex) {
-			// Ignore
-		}
-	}
-
-	function setMode(editor, mode) {
-		var currentMode = editor.readonly ? 'readonly' : 'design';
-
-		if (mode == currentMode) {
-			return;
-		}
-
-		if (mode == 'readonly') {
-			editor.selection.controlSelection.hideResizeRect();
-			editor.readonly = true;
-			editor.getBody().contentEditable = false;
-		} else {
-			editor.readonly = false;
-			editor.getBody().contentEditable = true;
-			setEditorCommandState(editor, "StyleWithCSS", false);
-			setEditorCommandState(editor, "enableInlineTableEditing", false);
-			setEditorCommandState(editor, "enableObjectResizing", false);
-			editor.focus();
-			editor.nodeChanged();
-		}
-
-		// Event is NOT preventable
-		editor.fire('SwitchMode', {mode: mode});
-	}
-
-	return {
-		setMode: setMode
-	};
-});
-
-// Included from: js/tinymce/classes/Shortcuts.js
-
-/**
- * Shortcuts.js
- *
- * Released under LGPL License.
- * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
- *
- * License: http://www.tinymce.com/license
- * Contributing: http://www.tinymce.com/contributing
- */
-
-/**
- * Contains all logic for handling of keyboard shortcuts.
- *
- * @class tinymce.Shortcuts
- * @example
- * editor.shortcuts.add('ctrl+a', function() {});
- * editor.shortcuts.add('meta+a', function() {}); // "meta" maps to Command on Mac and Ctrl on PC
- * editor.shortcuts.add('ctrl+alt+a', function() {});
- * editor.shortcuts.add('access+a', function() {}); // "access" maps to ctrl+alt on Mac and shift+alt on PC
- */
-define("tinymce/Shortcuts", [
-	"tinymce/util/Tools",
-	"tinymce/Env"
-], function(Tools, Env) {
-	var each = Tools.each, explode = Tools.explode;
-
-	var keyCodeLookup = {
-		"f9": 120,
-		"f10": 121,
-		"f11": 122
-	};
-
-	var modifierNames = Tools.makeMap('alt,ctrl,shift,meta,access');
-
-	return function(editor) {
-		var self = this, shortcuts = {};
-
-		function createShortcut(pattern, desc, cmdFunc, scope) {
-			var id, key, shortcut;
-
-			shortcut = {
-				func: cmdFunc,
-				scope: scope || editor,
-				desc: editor.translate(desc)
-			};
-
-			// Parse modifiers and keys ctrl+alt+b for example
-			each(explode(pattern, '+'), function(value) {
-				if (value in modifierNames) {
-					shortcut[value] = true;
-				} else {
-					// Allow numeric keycodes like ctrl+219 for ctrl+[
-					if (/^[0-9]{2,}$/.test(value)) {
-						shortcut.keyCode = parseInt(value, 10);
-					} else {
-						shortcut.charCode = value.charCodeAt(0);
-						shortcut.keyCode = keyCodeLookup[value] || value.toUpperCase().charCodeAt(0);
-					}
-				}
-			});
-
-			// Generate unique id for modifier combination and set default state for unused modifiers
-			id = [shortcut.keyCode];
-			for (key in modifierNames) {
-				if (shortcut[key]) {
-					id.push(key);
-				} else {
-					shortcut[key] = false;
-				}
-			}
-			shortcut.id = id.join(',');
-
-			// Handle special access modifier differently depending on Mac/Win
-			if (shortcut.access) {
-				shortcut.alt = true;
-
-				if (Env.mac) {
-					shortcut.ctrl = true;
-				} else {
-					shortcut.shift = true;
-				}
-			}
-
-			// Handle special meta modifier differently depending on Mac/Win
-			if (shortcut.meta) {
-				if (Env.mac) {
-					shortcut.meta = true;
-				} else {
-					shortcut.ctrl = true;
-					shortcut.meta = false;
-				}
-			}
-
-			return shortcut;
-		}
-
-		editor.on('keyup keypress keydown', function(e) {
-			if ((e.altKey || e.ctrlKey || e.metaKey) && !e.isDefaultPrevented()) {
-				each(shortcuts, function(shortcut) {
-					if (shortcut.ctrl != e.ctrlKey || shortcut.meta != e.metaKey) {
-						return;
-					}
-
-					if (shortcut.alt != e.altKey || shortcut.shift != e.shiftKey) {
-						return;
-					}
-
-					if (e.keyCode == shortcut.keyCode || (e.charCode && e.charCode == shortcut.charCode)) {
-						e.preventDefault();
-
-						if (e.type == "keydown") {
-							shortcut.func.call(shortcut.scope);
-						}
-
-						return true;
-					}
-				});
-			}
-		});
-
-		/**
-		 * Adds a keyboard shortcut for some command or function.
-		 *
-		 * @method addShortcut
-		 * @param {String} pattern Shortcut pattern. Like for example: ctrl+alt+o.
-		 * @param {String} desc Text description for the command.
-		 * @param {String/Function} cmdFunc Command name string or function to execute when the key is pressed.
-		 * @param {Object} scope Optional scope to execute the function in.
-		 * @return {Boolean} true/false state if the shortcut was added or not.
-		 */
-		self.add = function(pattern, desc, cmdFunc, scope) {
-			var cmd;
-
-			cmd = cmdFunc;
-
-			if (typeof cmdFunc === 'string') {
-				cmdFunc = function() {
-					editor.execCommand(cmd, false, null);
-				};
-			} else if (Tools.isArray(cmd)) {
-				cmdFunc = function() {
-					editor.execCommand(cmd[0], cmd[1], cmd[2]);
-				};
-			}
-
-			each(explode(pattern.toLowerCase()), function(pattern) {
-				var shortcut = createShortcut(pattern, desc, cmdFunc, scope);
-				shortcuts[shortcut.id] = shortcut;
-			});
-
-			return true;
-		};
-
-		/**
-		 * Remove a keyboard shortcut by pattern.
-		 *
-		 * @method remove
-		 * @param {String} pattern Shortcut pattern. Like for example: ctrl+alt+o.
-		 * @return {Boolean} true/false state if the shortcut was removed or not.
-		 */
-		self.remove = function(pattern) {
-			var shortcut = createShortcut(pattern);
-
-			if (shortcuts[shortcut.id]) {
-				delete shortcuts[shortcut.id];
-				return true;
-			}
-
-			return false;
-		};
-	};
-});
-
-// Included from: js/tinymce/classes/file/Uploader.js
-
-/**
- * Uploader.js
- *
- * Released under LGPL License.
- * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
- *
- * License: http://www.tinymce.com/license
- * Contributing: http://www.tinymce.com/contributing
- */
-
-/**
- * Upload blobs or blob infos to the specified URL or handler.
- *
- * @private
- * @class tinymce.file.Uploader
- * @example
- * var uploader = new Uploader({
- *     url: '/upload.php',
- *     basePath: '/base/path',
- *     credentials: true,
- *     handler: function(data, success, failure) {
- *         ...
- *     }
- * });
- *
- * uploader.upload(blobInfos).then(function(result) {
- *     ...
- * });
- */
-define("tinymce/file/Uploader", [
-	"tinymce/util/Promise",
-	"tinymce/util/Tools",
-	"tinymce/util/Fun"
-], function(Promise, Tools, Fun) {
-	return function(settings) {
-		var cachedPromises = {};
-
-		function fileName(blobInfo) {
-			var ext, extensions;
-
-			extensions = {
-				'image/jpeg': 'jpg',
-				'image/jpg': 'jpg',
-				'image/gif': 'gif',
-				'image/png': 'png'
-			};
-
-			ext = extensions[blobInfo.blob().type.toLowerCase()] || 'dat';
-
-			return blobInfo.id() + '.' + ext;
-		}
-
-		function pathJoin(path1, path2) {
-			if (path1) {
-				return path1.replace(/\/$/, '') + '/' + path2.replace(/^\//, '');
-			}
-
-			return path2;
-		}
-
-		function blobInfoToData(blobInfo) {
-			return {
-				id: blobInfo.id,
-				blob: blobInfo.blob,
-				base64: blobInfo.base64,
-				filename: Fun.constant(fileName(blobInfo))
-			};
-		}
-
-		function defaultHandler(blobInfo, success, failure, openNotification) {
-			var xhr, formData, notification;
-
-			xhr = new XMLHttpRequest();
-			xhr.open('POST', settings.url);
-			xhr.withCredentials = settings.credentials;
-
-			notification = openNotification();
-
-			xhr.upload.onprogress = function(e) {
-				var percentLoaded = Math.round(e.loaded / e.total * 100);
-				notification.progressBar.value(percentLoaded);
-			};
-
-			xhr.onerror = function() {
-				notification.close();
-				failure("Image upload failed due to a XHR Transport error. Code: " + xhr.status);
-			};
-
-			xhr.onload = function() {
-				var json;
-
-				notification.close();
-
-				if (xhr.status != 200) {
-					failure("HTTP Error: " + xhr.status);
-					return;
-				}
-
-				json = JSON.parse(xhr.responseText);
-
-				if (!json || typeof json.location != "string") {
-					failure("Invalid JSON: " + xhr.responseText);
-					return;
-				}
-
-				success(pathJoin(settings.basePath, json.location));
-			};
-
-			formData = new FormData();
-			formData.append('file', blobInfo.blob(), fileName(blobInfo));
-
-			xhr.send(formData);
-		}
-
-		function noUpload() {
-			return new Promise(function(resolve) {
-				resolve([]);
-			});
-		}
-
-		function interpretResult(promise) {
-			return promise.then(function(result) {
-				return result;
-			})['catch'](function(error) {
-				return error;
-			});
-		}
-
-		function registerPromise(handler, id, blobInfo) {
-			var response = handler(blobInfo);
-			var promise = interpretResult(response);
-			delete cachedPromises[id];
-			cachedPromises[id] = promise;
-			return promise;
-		}
-
-		function collectUploads(blobInfos, uploadBlobInfo) {
-			return Tools.map(blobInfos, function(blobInfo) {
-				var id = blobInfo.id();
-				return cachedPromises[id] ? cachedPromises[id] : registerPromise(uploadBlobInfo, id, blobInfo);
-			});
-		}
+		 * Toggles a native event on/off this is called by the EventDispatcher when
+		 * the first native event handler is added and when the last native event handler is removed.
+		 *
+		 * @private
+		 */
+		toggleNativeEvent: function(name, state) {
+			var self = this;
 
-		function uploadBlobs(blobInfos, openNotification) {
-			function uploadBlobInfo(blobInfo) {
-				return new Promise(function(resolve) {
-					var handler = settings.handler;
+			// Never bind focus/blur since the FocusManager fakes those
+			if (name == "focus" || name == "blur") {
+				return;
+			}
 
-					try {
-						handler(blobInfoToData(blobInfo), function(url) {
-							resolve({
-								url: url,
-								blobInfo: blobInfo,
-								status: true
-							});
-						}, function(failure) {
-							resolve({
-								url: '',
-								blobInfo: blobInfo,
-								status: false,
-								error: failure
-							});
-						}, openNotification);
-					} catch (ex) {
-						resolve({
-							url: '',
-							blobInfo: blobInfo,
-							status: false,
-							error: ex.message
-						});
+			if (state) {
+				if (self.initialized) {
+					bindEventDelegate(self, name);
+				} else {
+					if (!self._pendingNativeEvents) {
+						self._pendingNativeEvents = [name];
+					} else {
+						self._pendingNativeEvents.push(name);
 					}
-				});
+				}
+			} else if (self.initialized) {
+				self.dom.unbind(getEventTarget(self, name), name, self.delegates[name]);
+				delete self.delegates[name];
 			}
+		},
 
-			var promises = collectUploads(blobInfos, uploadBlobInfo);
-			return Promise.all(promises);
-		}
+		/**
+		 * Unbinds all native event handlers that means delegates, custom events bound using the Events API etc.
+		 *
+		 * @private
+		 */
+		unbindAllNativeEvents: function() {
+			var self = this, name;
 
-		function upload(blobInfos, openNotification) {
-			return (!settings.url && settings.handler === defaultHandler) ? noUpload() : uploadBlobs(blobInfos, openNotification);
-		}
+			if (self.delegates) {
+				for (name in self.delegates) {
+					self.dom.unbind(getEventTarget(self, name), name, self.delegates[name]);
+				}
 
-		settings = Tools.extend({
-			credentials: false,
-			// We are adding a notify argument to this (at the moment, until it doesn't work)
-			handler: defaultHandler
-		}, settings);
+				delete self.delegates;
+			}
 
-		return {
-			upload: upload
-		};
+			if (!self.inline) {
+				self.getBody().onload = null;
+				self.dom.unbind(self.getWin());
+				self.dom.unbind(self.getDoc());
+			}
+
+			self.dom.unbind(self.getBody());
+			self.dom.unbind(self.getContainer());
+		}
 	};
+
+	EditorObservable = Tools.extend({}, Observable, EditorObservable);
+
+	return EditorObservable;
 });
 
-// Included from: js/tinymce/classes/file/Conversions.js
+// Included from: js/tinymce/classes/Mode.js
 
 /**
- * Conversions.js
+ * Mode.js
  *
  * Released under LGPL License.
  * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
@@ -33128,106 +33309,90 @@ define("tinymce/file/Uploader", [
  */
 
 /**
- * Converts blob/uris back and forth.
+ * Mode switcher logic.
  *
  * @private
- * @class tinymce.file.Conversions
+ * @class tinymce.Mode
  */
-define("tinymce/file/Conversions", [
-	"tinymce/util/Promise"
-], function(Promise) {
-	function blobUriToBlob(url) {
-		return new Promise(function(resolve) {
-			var xhr = new XMLHttpRequest();
-
-			xhr.open('GET', url, true);
-			xhr.responseType = 'blob';
-
-			xhr.onload = function() {
-				if (this.status == 200) {
-					resolve(this.response);
-				}
-			};
-
-			xhr.send();
-		});
-	}
-
-	function parseDataUri(uri) {
-		var type, matches;
-
-		uri = decodeURIComponent(uri).split(',');
-
-		matches = /data:([^;]+)/.exec(uri[0]);
-		if (matches) {
-			type = matches[1];
+define("tinymce/Mode", [], function() {
+	function setEditorCommandState(editor, cmd, state) {
+		try {
+			editor.getDoc().execCommand(cmd, false, state);
+		} catch (ex) {
+			// Ignore
 		}
-
-		return {
-			type: type,
-			data: uri[1]
-		};
 	}
 
-	function dataUriToBlob(uri) {
-		return new Promise(function(resolve) {
-			var str, arr, i;
+	function clickBlocker(editor) {
+		var target, handler;
 
-			uri = parseDataUri(uri);
+		target = editor.getBody();
 
-			// Might throw error if data isn't proper base64
-			try {
-				str = atob(uri.data);
-			} catch (e) {
-				resolve(new Blob([]));
-				return;
+		handler = function(e) {
+			if (editor.dom.getParents(e.target, 'a').length > 0) {
+				e.preventDefault();
 			}
+		};
 
-			arr = new Uint8Array(str.length);
+		editor.dom.bind(target, 'click', handler);
 
-			for (i = 0; i < arr.length; i++) {
-				arr[i] = str.charCodeAt(i);
+		return {
+			unbind: function() {
+				editor.dom.unbind(target, 'click', handler);
 			}
-
-			resolve(new Blob([arr], {type: uri.type}));
-		});
+		};
 	}
 
-	function uriToBlob(url) {
-		if (url.indexOf('blob:') === 0) {
-			return blobUriToBlob(url);
+	function toggleReadOnly(editor, state) {
+		if (editor._clickBlocker) {
+			editor._clickBlocker.unbind();
+			editor._clickBlocker = null;
 		}
 
-		if (url.indexOf('data:') === 0) {
-			return dataUriToBlob(url);
+		if (state) {
+			editor._clickBlocker = clickBlocker(editor);
+			editor.selection.controlSelection.hideResizeRect();
+			editor.readonly = true;
+			editor.getBody().contentEditable = false;
+		} else {
+			editor.readonly = false;
+			editor.getBody().contentEditable = true;
+			setEditorCommandState(editor, "StyleWithCSS", false);
+			setEditorCommandState(editor, "enableInlineTableEditing", false);
+			setEditorCommandState(editor, "enableObjectResizing", false);
+			editor.focus();
+			editor.nodeChanged();
 		}
-
-		return null;
 	}
 
-	function blobToDataUri(blob) {
-		return new Promise(function(resolve) {
-			var reader = new FileReader();
+	function setMode(editor, mode) {
+		var currentMode = editor.readonly ? 'readonly' : 'design';
 
-			reader.onloadend = function() {
-				resolve(reader.result);
-			};
+		if (mode == currentMode) {
+			return;
+		}
 
-			reader.readAsDataURL(blob);
-		});
+		if (editor.initialized) {
+			toggleReadOnly(editor, mode == 'readonly');
+		} else {
+			editor.on('init', function() {
+				toggleReadOnly(editor, mode == 'readonly');
+			});
+		}
+
+		// Event is NOT preventable
+		editor.fire('SwitchMode', {mode: mode});
 	}
 
 	return {
-		uriToBlob: uriToBlob,
-		blobToDataUri: blobToDataUri,
-		parseDataUri: parseDataUri
+		setMode: setMode
 	};
 });
 
-// Included from: js/tinymce/classes/file/ImageScanner.js
+// Included from: js/tinymce/classes/Shortcuts.js
 
 /**
- * ImageScanner.js
+ * Shortcuts.js
  *
  * Released under LGPL License.
  * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
@@ -33237,220 +33402,172 @@ define("tinymce/file/Conversions", [
  */
 
 /**
- * Finds images with data uris or blob uris. If data uris are found it will convert them into blob uris.
+ * Contains all logic for handling of keyboard shortcuts.
  *
- * @private
- * @class tinymce.file.ImageScanner
+ * @class tinymce.Shortcuts
+ * @example
+ * editor.shortcuts.add('ctrl+a', function() {});
+ * editor.shortcuts.add('meta+a', function() {}); // "meta" maps to Command on Mac and Ctrl on PC
+ * editor.shortcuts.add('ctrl+alt+a', function() {});
+ * editor.shortcuts.add('access+a', function() {}); // "access" maps to ctrl+alt on Mac and shift+alt on PC
  */
-define("tinymce/file/ImageScanner", [
-	"tinymce/util/Promise",
-	"tinymce/util/Arr",
-	"tinymce/util/Fun",
-	"tinymce/file/Conversions",
+define("tinymce/Shortcuts", [
+	"tinymce/util/Tools",
 	"tinymce/Env"
-], function(Promise, Arr, Fun, Conversions, Env) {
-	var count = 0;
+], function(Tools, Env) {
+	var each = Tools.each, explode = Tools.explode;
 
-	return function(blobCache) {
-		var cachedPromises = {};
+	var keyCodeLookup = {
+		"f9": 120,
+		"f10": 121,
+		"f11": 122
+	};
 
-		function findAll(elm, predicate) {
-			var images, promises;
+	var modifierNames = Tools.makeMap('alt,ctrl,shift,meta,access');
 
-			function imageToBlobInfo(img, resolve) {
-				var base64, blobInfo;
+	return function(editor) {
+		var self = this, shortcuts = {};
 
-				if (img.src.indexOf('blob:') === 0) {
-					blobInfo = blobCache.getByUri(img.src);
+		function createShortcut(pattern, desc, cmdFunc, scope) {
+			var id, key, shortcut;
 
-					if (blobInfo) {
-						resolve({
-							image: img,
-							blobInfo: blobInfo
-						});
-					}
+			shortcut = {
+				func: cmdFunc,
+				scope: scope || editor,
+				desc: editor.translate(desc)
+			};
 
-					return;
+			// Parse modifiers and keys ctrl+alt+b for example
+			each(explode(pattern, '+'), function(value) {
+				if (value in modifierNames) {
+					shortcut[value] = true;
+				} else {
+					// Allow numeric keycodes like ctrl+219 for ctrl+[
+					if (/^[0-9]{2,}$/.test(value)) {
+						shortcut.keyCode = parseInt(value, 10);
+					} else {
+						shortcut.charCode = value.charCodeAt(0);
+						shortcut.keyCode = keyCodeLookup[value] || value.toUpperCase().charCodeAt(0);
+					}
 				}
+			});
 
-				base64 = Conversions.parseDataUri(img.src).data;
-				blobInfo = blobCache.findFirst(function(cachedBlobInfo) {
-					return cachedBlobInfo.base64() === base64;
-				});
-
-				if (blobInfo) {
-					resolve({
-						image: img,
-						blobInfo: blobInfo
-					});
+			// Generate unique id for modifier combination and set default state for unused modifiers
+			id = [shortcut.keyCode];
+			for (key in modifierNames) {
+				if (shortcut[key]) {
+					id.push(key);
 				} else {
-					Conversions.uriToBlob(img.src).then(function(blob) {
-						var blobInfoId = 'blobid' + (count++),
-							blobInfo = blobCache.create(blobInfoId, blob, base64);
-
-						blobCache.add(blobInfo);
-
-						resolve({
-							image: img,
-							blobInfo: blobInfo
-						});
-					});
+					shortcut[key] = false;
 				}
 			}
+			shortcut.id = id.join(',');
 
-			if (!predicate) {
-				predicate = Fun.constant(true);
-			}
-
-			images = Arr.filter(elm.getElementsByTagName('img'), function(img) {
-				var src = img.src;
-
-				if (!Env.fileApi) {
-					return false;
-				}
-
-				if (img.hasAttribute('data-mce-bogus')) {
-					return false;
-				}
+			// Handle special access modifier differently depending on Mac/Win
+			if (shortcut.access) {
+				shortcut.alt = true;
 
-				if (img.hasAttribute('data-mce-placeholder')) {
-					return false;
+				if (Env.mac) {
+					shortcut.ctrl = true;
+				} else {
+					shortcut.shift = true;
 				}
+			}
 
-				if (!src || src == Env.transparentSrc) {
-					return false;
+			// Handle special meta modifier differently depending on Mac/Win
+			if (shortcut.meta) {
+				if (Env.mac) {
+					shortcut.meta = true;
+				} else {
+					shortcut.ctrl = true;
+					shortcut.meta = false;
 				}
+			}
 
-				if (src.indexOf('blob:') === 0) {
-					return true;
-				}
+			return shortcut;
+		}
 
-				if (src.indexOf('data:') === 0) {
-					return predicate(img);
-				}
+		editor.on('keyup keypress keydown', function(e) {
+			if ((e.altKey || e.ctrlKey || e.metaKey) && !e.isDefaultPrevented()) {
+				each(shortcuts, function(shortcut) {
+					if (shortcut.ctrl != e.ctrlKey || shortcut.meta != e.metaKey) {
+						return;
+					}
 
-				return false;
-			});
+					if (shortcut.alt != e.altKey || shortcut.shift != e.shiftKey) {
+						return;
+					}
 
-			promises = Arr.map(images, function(img) {
-				var newPromise;
+					if (e.keyCode == shortcut.keyCode || (e.charCode && e.charCode == shortcut.charCode)) {
+						e.preventDefault();
 
-				if (cachedPromises[img.src]) {
-					// Since the cached promise will return the cached image
-					// We need to wrap it and resolve with the actual image
-					return new Promise(function(resolve) {
-						cachedPromises[img.src].then(function(imageInfo) {
-							resolve({
-								image: img,
-								blobInfo: imageInfo.blobInfo
-							});
-						});
-					});
-				}
+						if (e.type == "keydown") {
+							shortcut.func.call(shortcut.scope);
+						}
 
-				newPromise = new Promise(function(resolve) {
-					imageToBlobInfo(img, resolve);
-				}).then(function(result) {
-					delete cachedPromises[result.image.src];
-					return result;
-				})['catch'](function(error) {
-					delete cachedPromises[img.src];
-					return error;
+						return true;
+					}
 				});
+			}
+		});
 
-				cachedPromises[img.src] = newPromise;
-
-				return newPromise;
-			});
-
-			return Promise.all(promises);
-		}
-
-		return {
-			findAll: findAll
-		};
-	};
-});
-
-// Included from: js/tinymce/classes/file/BlobCache.js
-
-/**
- * BlobCache.js
- *
- * Released under LGPL License.
- * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
- *
- * License: http://www.tinymce.com/license
- * Contributing: http://www.tinymce.com/contributing
- */
-
-/**
- * Hold blob info objects where a blob has extra internal information.
- *
- * @private
- * @class tinymce.file.BlobCache
- */
-define("tinymce/file/BlobCache", [
-	"tinymce/util/Arr",
-	"tinymce/util/Fun"
-], function(Arr, Fun) {
-	return function() {
-		var cache = [], constant = Fun.constant;
+		/**
+		 * Adds a keyboard shortcut for some command or function.
+		 *
+		 * @method addShortcut
+		 * @param {String} pattern Shortcut pattern. Like for example: ctrl+alt+o.
+		 * @param {String} desc Text description for the command.
+		 * @param {String/Function} cmdFunc Command name string or function to execute when the key is pressed.
+		 * @param {Object} scope Optional scope to execute the function in.
+		 * @return {Boolean} true/false state if the shortcut was added or not.
+		 */
+		self.add = function(pattern, desc, cmdFunc, scope) {
+			var cmd;
 
-		function create(id, blob, base64) {
-			return {
-				id: constant(id),
-				blob: constant(blob),
-				base64: constant(base64),
-				blobUri: constant(URL.createObjectURL(blob))
-			};
-		}
+			cmd = cmdFunc;
 
-		function add(blobInfo) {
-			if (!get(blobInfo.id())) {
-				cache.push(blobInfo);
+			if (typeof cmdFunc === 'string') {
+				cmdFunc = function() {
+					editor.execCommand(cmd, false, null);
+				};
+			} else if (Tools.isArray(cmd)) {
+				cmdFunc = function() {
+					editor.execCommand(cmd[0], cmd[1], cmd[2]);
+				};
 			}
-		}
 
-		function get(id) {
-			return findFirst(function(cachedBlobInfo) {
-				return cachedBlobInfo.id() === id;
+			each(explode(pattern.toLowerCase()), function(pattern) {
+				var shortcut = createShortcut(pattern, desc, cmdFunc, scope);
+				shortcuts[shortcut.id] = shortcut;
 			});
-		}
-
-		function findFirst(predicate) {
-			return Arr.filter(cache, predicate)[0];
-		}
 
-		function getByUri(blobUri) {
-			return findFirst(function(blobInfo) {
-				return blobInfo.blobUri() == blobUri;
-			});
-		}
+			return true;
+		};
 
-		function destroy() {
-			Arr.each(cache, function(cachedBlobInfo) {
-				URL.revokeObjectURL(cachedBlobInfo.blobUri());
-			});
+		/**
+		 * Remove a keyboard shortcut by pattern.
+		 *
+		 * @method remove
+		 * @param {String} pattern Shortcut pattern. Like for example: ctrl+alt+o.
+		 * @return {Boolean} true/false state if the shortcut was removed or not.
+		 */
+		self.remove = function(pattern) {
+			var shortcut = createShortcut(pattern);
 
-			cache = [];
-		}
+			if (shortcuts[shortcut.id]) {
+				delete shortcuts[shortcut.id];
+				return true;
+			}
 
-		return {
-			create: create,
-			add: add,
-			get: get,
-			getByUri: getByUri,
-			findFirst: findFirst,
-			destroy: destroy
+			return false;
 		};
 	};
 });
 
-// Included from: js/tinymce/classes/EditorUpload.js
+// Included from: js/tinymce/classes/file/Uploader.js
 
 /**
- * EditorUpload.js
+ * Uploader.js
  *
  * Released under LGPL License.
  * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
@@ -33460,191 +33577,193 @@ define("tinymce/file/BlobCache", [
  */
 
 /**
- * Handles image uploads, updates undo stack and patches over various internal functions.
+ * Upload blobs or blob infos to the specified URL or handler.
+ *
+ * @private
+ * @class tinymce.file.Uploader
+ * @example
+ * var uploader = new Uploader({
+ *     url: '/upload.php',
+ *     basePath: '/base/path',
+ *     credentials: true,
+ *     handler: function(data, success, failure) {
+ *         ...
+ *     }
+ * });
  *
- * @private
- * @class tinymce.EditorUpload
+ * uploader.upload(blobInfos).then(function(result) {
+ *     ...
+ * });
  */
-define("tinymce/EditorUpload", [
-	"tinymce/util/Arr",
-	"tinymce/file/Uploader",
-	"tinymce/file/ImageScanner",
-	"tinymce/file/BlobCache"
-], function(Arr, Uploader, ImageScanner, BlobCache) {
-	return function(editor) {
-		var blobCache = new BlobCache(), uploader, imageScanner, settings = editor.settings;
+define("tinymce/file/Uploader", [
+	"tinymce/util/Promise",
+	"tinymce/util/Tools",
+	"tinymce/util/Fun"
+], function(Promise, Tools, Fun) {
+	return function(settings) {
+		var cachedPromises = {};
 
-		function aliveGuard(callback) {
-			return function(result) {
-				if (editor.selection) {
-					return callback(result);
-				}
+		function fileName(blobInfo) {
+			var ext, extensions;
 
-				return [];
+			extensions = {
+				'image/jpeg': 'jpg',
+				'image/jpg': 'jpg',
+				'image/gif': 'gif',
+				'image/png': 'png'
 			};
-		}
-
-		// Replaces strings without regexps to avoid FF regexp to big issue
-		function replaceString(content, search, replace) {
-			var index = 0;
 
-			do {
-				index = content.indexOf(search, index);
-
-				if (index !== -1) {
-					content = content.substring(0, index) + replace + content.substr(index + search.length);
-					index += replace.length - search.length + 1;
-				}
-			} while (index !== -1);
+			ext = extensions[blobInfo.blob().type.toLowerCase()] || 'dat';
 
-			return content;
+			return blobInfo.id() + '.' + ext;
 		}
 
-		function replaceImageUrl(content, targetUrl, replacementUrl) {
-			content = replaceString(content, 'src="' + targetUrl + '"', 'src="' + replacementUrl + '"');
-			content = replaceString(content, 'data-mce-src="' + targetUrl + '"', 'data-mce-src="' + replacementUrl + '"');
-
-			return content;
-		}
+		function pathJoin(path1, path2) {
+			if (path1) {
+				return path1.replace(/\/$/, '') + '/' + path2.replace(/^\//, '');
+			}
 
-		function replaceUrlInUndoStack(targetUrl, replacementUrl) {
-			Arr.each(editor.undoManager.data, function(level) {
-				level.content = replaceImageUrl(level.content, targetUrl, replacementUrl);
-			});
+			return path2;
 		}
 
-		function openNotification() {
-			return editor.notificationManager.open({
-				text: editor.translate('Image uploading...'),
-				type: 'info',
-				timeout: -1,
-				progressBar: true
-			});
+		function blobInfoToData(blobInfo) {
+			return {
+				id: blobInfo.id,
+				blob: blobInfo.blob,
+				base64: blobInfo.base64,
+				filename: Fun.constant(fileName(blobInfo))
+			};
 		}
 
-		function uploadImages(callback) {
-			if (!uploader) {
-				uploader = new Uploader({
-					url: settings.images_upload_url,
-					basePath: settings.images_upload_base_path,
-					credentials: settings.images_upload_credentials,
-					handler: settings.images_upload_handler
-				});
-			}
+		function defaultHandler(blobInfo, success, failure, openNotification) {
+			var xhr, formData, notification;
 
-			return scanForImages().then(aliveGuard(function(imageInfos) {
-				var blobInfos;
+			xhr = new XMLHttpRequest();
+			xhr.open('POST', settings.url);
+			xhr.withCredentials = settings.credentials;
 
-				blobInfos = Arr.map(imageInfos, function(imageInfo) {
-					return imageInfo.blobInfo;
-				});
+			notification = openNotification();
 
-				return uploader.upload(blobInfos, openNotification).then(aliveGuard(function(result) {
-					result = Arr.map(result, function(uploadInfo, index) {
-						var image = imageInfos[index].image;
+			xhr.upload.onprogress = function(e) {
+				var percentLoaded = Math.round(e.loaded / e.total * 100);
+				notification.progressBar.value(percentLoaded);
+			};
 
-						if (uploadInfo.status) {
-							replaceUrlInUndoStack(image.src, uploadInfo.url);
+			xhr.onerror = function() {
+				notification.close();
+				failure("Image upload failed due to a XHR Transport error. Code: " + xhr.status);
+			};
 
-							editor.$(image).attr({
-								src: uploadInfo.url,
-								'data-mce-src': editor.convertURL(uploadInfo.url, 'src')
-							});
-						}
+			xhr.onload = function() {
+				var json;
 
-						return {
-							element: image,
-							status: uploadInfo.status
-						};
-					});
+				notification.close();
 
-					if (callback) {
-						callback(result);
-					}
+				if (xhr.status != 200) {
+					failure("HTTP Error: " + xhr.status);
+					return;
+				}
 
-					return result;
-				}));
-			}));
-		}
+				json = JSON.parse(xhr.responseText);
 
-		function uploadImagesAuto(callback) {
-			if (settings.automatic_uploads !== false) {
-				return uploadImages(callback);
-			}
-		}
+				if (!json || typeof json.location != "string") {
+					failure("Invalid JSON: " + xhr.responseText);
+					return;
+				}
 
-		function scanForImages() {
-			if (!imageScanner) {
-				imageScanner = new ImageScanner(blobCache);
-			}
+				success(pathJoin(settings.basePath, json.location));
+			};
 
-			return imageScanner.findAll(editor.getBody(), settings.images_dataimg_filter).then(aliveGuard(function(result) {
-				Arr.each(result, function(resultItem) {
-					replaceUrlInUndoStack(resultItem.image.src, resultItem.blobInfo.blobUri());
-					resultItem.image.src = resultItem.blobInfo.blobUri();
-				});
+			formData = new FormData();
+			formData.append('file', blobInfo.blob(), fileName(blobInfo));
 
-				return result;
-			}));
+			xhr.send(formData);
 		}
 
-		function destroy() {
-			blobCache.destroy();
-			imageScanner = uploader = null;
+		function noUpload() {
+			return new Promise(function(resolve) {
+				resolve([]);
+			});
 		}
 
-		function replaceBlobWithBase64(content) {
-			return content.replace(/src="(blob:[^"]+)"/g, function(match, blobUri) {
-				var blobInfo = blobCache.getByUri(blobUri);
-
-				if (!blobInfo) {
-					blobInfo = Arr.reduce(editor.editorManager.editors, function(result, editor) {
-						return result || editor.editorUpload.blobCache.getByUri(blobUri);
-					}, null);
-				}
+		function interpretResult(promise) {
+			return promise.then(function(result) {
+				return result;
+			})['catch'](function(error) {
+				return error;
+			});
+		}
 
-				if (blobInfo) {
-					return 'src="data:' + blobInfo.blob().type + ';base64,' + blobInfo.base64() + '"';
-				}
+		function registerPromise(handler, id, blobInfo) {
+			var response = handler(blobInfo);
+			var promise = interpretResult(response);
+			delete cachedPromises[id];
+			cachedPromises[id] = promise;
+			return promise;
+		}
 
-				return match;
+		function collectUploads(blobInfos, uploadBlobInfo) {
+			return Tools.map(blobInfos, function(blobInfo) {
+				var id = blobInfo.id();
+				return cachedPromises[id] ? cachedPromises[id] : registerPromise(uploadBlobInfo, id, blobInfo);
 			});
 		}
 
-		editor.on('setContent', function() {
-			if (editor.settings.automatic_uploads !== false) {
-				uploadImagesAuto();
-			} else {
-				scanForImages();
+		function uploadBlobs(blobInfos, openNotification) {
+			function uploadBlobInfo(blobInfo) {
+				return new Promise(function(resolve) {
+					var handler = settings.handler;
+
+					try {
+						handler(blobInfoToData(blobInfo), function(url) {
+							resolve({
+								url: url,
+								blobInfo: blobInfo,
+								status: true
+							});
+						}, function(failure) {
+							resolve({
+								url: '',
+								blobInfo: blobInfo,
+								status: false,
+								error: failure
+							});
+						}, openNotification);
+					} catch (ex) {
+						resolve({
+							url: '',
+							blobInfo: blobInfo,
+							status: false,
+							error: ex.message
+						});
+					}
+				});
 			}
-		});
 
-		editor.on('RawSaveContent', function(e) {
-			e.content = replaceBlobWithBase64(e.content);
-		});
+			var promises = collectUploads(blobInfos, uploadBlobInfo);
+			return Promise.all(promises);
+		}
 
-		editor.on('getContent', function(e) {
-			if (e.source_view || e.format == 'raw') {
-				return;
-			}
+		function upload(blobInfos, openNotification) {
+			return (!settings.url && settings.handler === defaultHandler) ? noUpload() : uploadBlobs(blobInfos, openNotification);
+		}
 
-			e.content = replaceBlobWithBase64(e.content);
-		});
+		settings = Tools.extend({
+			credentials: false,
+			// We are adding a notify argument to this (at the moment, until it doesn't work)
+			handler: defaultHandler
+		}, settings);
 
 		return {
-			blobCache: blobCache,
-			uploadImages: uploadImages,
-			uploadImagesAuto: uploadImagesAuto,
-			scanForImages: scanForImages,
-			destroy: destroy
+			upload: upload
 		};
 	};
 });
 
-// Included from: js/tinymce/classes/caret/CaretUtils.js
+// Included from: js/tinymce/classes/file/Conversions.js
 
 /**
- * CaretUtils.js
+ * Conversions.js
  *
  * Released under LGPL License.
  * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
@@ -33654,302 +33773,254 @@ define("tinymce/EditorUpload", [
  */
 
 /**
- * Utility functions shared by the caret logic.
+ * Converts blob/uris back and forth.
  *
  * @private
- * @class tinymce.caret.CaretUtils
+ * @class tinymce.file.Conversions
  */
-define("tinymce/caret/CaretUtils", [
-	"tinymce/util/Fun",
-	"tinymce/dom/TreeWalker",
-	"tinymce/dom/NodeType",
-	"tinymce/caret/CaretPosition",
-	"tinymce/caret/CaretContainer",
-	"tinymce/caret/CaretCandidate"
-], function(Fun, TreeWalker, NodeType, CaretPosition, CaretContainer, CaretCandidate) {
-	var isContentEditableTrue = NodeType.isContentEditableTrue,
-		isContentEditableFalse = NodeType.isContentEditableFalse,
-		isBlockLike = NodeType.matchStyleValues('display', 'block table table-cell table-caption'),
-		isCaretContainer = CaretContainer.isCaretContainer,
-		curry = Fun.curry,
-		isElement = NodeType.isElement,
-		isCaretCandidate = CaretCandidate.isCaretCandidate;
-
-	function isForwards(direction) {
-		return direction > 0;
-	}
-
-	function isBackwards(direction) {
-		return direction < 0;
-	}
+define("tinymce/file/Conversions", [
+	"tinymce/util/Promise"
+], function(Promise) {
+	function blobUriToBlob(url) {
+		return new Promise(function(resolve) {
+			var xhr = new XMLHttpRequest();
 
-	function findNode(node, direction, predicateFn, rootNode, shallow) {
-		var walker = new TreeWalker(node, rootNode);
+			xhr.open('GET', url, true);
+			xhr.responseType = 'blob';
 
-		if (isBackwards(direction)) {
-			if (isContentEditableFalse(node)) {
-				node = walker.prev(true);
-				if (predicateFn(node)) {
-					return node;
+			xhr.onload = function() {
+				if (this.status == 200) {
+					resolve(this.response);
 				}
-			}
+			};
 
-			while ((node = walker.prev(shallow))) {
-				if (predicateFn(node)) {
-					return node;
-				}
-			}
-		}
+			xhr.send();
+		});
+	}
 
-		if (isForwards(direction)) {
-			if (isContentEditableFalse(node)) {
-				node = walker.next(true);
-				if (predicateFn(node)) {
-					return node;
-				}
-			}
+	function parseDataUri(uri) {
+		var type, matches;
 
-			while ((node = walker.next(shallow))) {
-				if (predicateFn(node)) {
-					return node;
-				}
-			}
+		uri = decodeURIComponent(uri).split(',');
+
+		matches = /data:([^;]+)/.exec(uri[0]);
+		if (matches) {
+			type = matches[1];
 		}
 
-		return null;
+		return {
+			type: type,
+			data: uri[1]
+		};
 	}
 
-	function getEditingHost(node, rootNode) {
-		for (node = node.parentNode; node && node != rootNode; node = node.parentNode) {
-			if (isContentEditableTrue(node)) {
-				return node;
-			}
-		}
+	function dataUriToBlob(uri) {
+		return new Promise(function(resolve) {
+			var str, arr, i;
 
-		return rootNode;
-	}
+			uri = parseDataUri(uri);
 
-	function getParentBlock(node, rootNode) {
-		while (node && node != rootNode) {
-			if (isBlockLike(node)) {
-				return node;
+			// Might throw error if data isn't proper base64
+			try {
+				str = atob(uri.data);
+			} catch (e) {
+				resolve(new Blob([]));
+				return;
 			}
 
-			node = node.parentNode;
-		}
-
-		return null;
-	}
+			arr = new Uint8Array(str.length);
 
-	function isInSameBlock(caretPosition1, caretPosition2, rootNode) {
-		return getParentBlock(caretPosition1.container(), rootNode) == getParentBlock(caretPosition2.container(), rootNode);
-	}
+			for (i = 0; i < arr.length; i++) {
+				arr[i] = str.charCodeAt(i);
+			}
 
-	function isInSameEditingHost(caretPosition1, caretPosition2, rootNode) {
-		return getEditingHost(caretPosition1.container(), rootNode) == getEditingHost(caretPosition2.container(), rootNode);
+			resolve(new Blob([arr], {type: uri.type}));
+		});
 	}
 
-	function getChildNodeAtRelativeOffset(relativeOffset, caretPosition) {
-		var container, offset;
-
-		if (!caretPosition) {
-			return null;
+	function uriToBlob(url) {
+		if (url.indexOf('blob:') === 0) {
+			return blobUriToBlob(url);
 		}
 
-		container = caretPosition.container();
-		offset = caretPosition.offset();
-
-		if (!isElement(container)) {
-			return null;
+		if (url.indexOf('data:') === 0) {
+			return dataUriToBlob(url);
 		}
 
-		return container.childNodes[offset + relativeOffset];
+		return null;
 	}
 
-	function beforeAfter(before, node) {
-		var range = node.ownerDocument.createRange();
-
-		if (before) {
-			range.setStartBefore(node);
-			range.setEndBefore(node);
-		} else {
-			range.setStartAfter(node);
-			range.setEndAfter(node);
-		}
+	function blobToDataUri(blob) {
+		return new Promise(function(resolve) {
+			var reader = new FileReader();
 
-		return range;
-	}
+			reader.onloadend = function() {
+				resolve(reader.result);
+			};
 
-	function isNodesInSameBlock(rootNode, node1, node2) {
-		return getParentBlock(node1, rootNode) == getParentBlock(node2, rootNode);
+			reader.readAsDataURL(blob);
+		});
 	}
 
-	function lean(left, rootNode, node) {
-		var sibling, siblingName;
-
-		if (left) {
-			siblingName = 'previousSibling';
-		} else {
-			siblingName = 'nextSibling';
-		}
-
-		while (node && node != rootNode) {
-			sibling = node[siblingName];
+	return {
+		uriToBlob: uriToBlob,
+		blobToDataUri: blobToDataUri,
+		parseDataUri: parseDataUri
+	};
+});
 
-			if (isCaretContainer(sibling)) {
-				sibling = sibling[siblingName];
-			}
+// Included from: js/tinymce/classes/file/ImageScanner.js
 
-			if (isContentEditableFalse(sibling)) {
-				if (isNodesInSameBlock(rootNode, sibling, node)) {
-					return sibling;
-				}
+/**
+ * ImageScanner.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
 
-				break;
-			}
+/**
+ * Finds images with data uris or blob uris. If data uris are found it will convert them into blob uris.
+ *
+ * @private
+ * @class tinymce.file.ImageScanner
+ */
+define("tinymce/file/ImageScanner", [
+	"tinymce/util/Promise",
+	"tinymce/util/Arr",
+	"tinymce/util/Fun",
+	"tinymce/file/Conversions",
+	"tinymce/Env"
+], function(Promise, Arr, Fun, Conversions, Env) {
+	var count = 0;
 
-			if (isCaretCandidate(sibling)) {
-				break;
-			}
+	return function(blobCache) {
+		var cachedPromises = {};
 
-			node = node.parentNode;
-		}
+		function findAll(elm, predicate) {
+			var images, promises;
 
-		return null;
-	}
+			function imageToBlobInfo(img, resolve) {
+				var base64, blobInfo;
 
-	var before = curry(beforeAfter, true);
-	var after = curry(beforeAfter, false);
+				if (img.src.indexOf('blob:') === 0) {
+					blobInfo = blobCache.getByUri(img.src);
 
-	function normalizeRange(direction, rootNode, range) {
-		var node, container, offset, location;
-		var leanLeft = curry(lean, true, rootNode);
-		var leanRight = curry(lean, false, rootNode);
+					if (blobInfo) {
+						resolve({
+							image: img,
+							blobInfo: blobInfo
+						});
+					}
 
-		container = range.startContainer;
-		offset = range.startOffset;
+					return;
+				}
 
-		if (CaretContainer.isCaretContainerBlock(container)) {
-			if (!isElement(container)) {
-				container = container.parentNode;
-			}
+				base64 = Conversions.parseDataUri(img.src).data;
+				blobInfo = blobCache.findFirst(function(cachedBlobInfo) {
+					return cachedBlobInfo.base64() === base64;
+				});
 
-			location = container.getAttribute('data-mce-caret');
+				if (blobInfo) {
+					resolve({
+						image: img,
+						blobInfo: blobInfo
+					});
+				} else {
+					Conversions.uriToBlob(img.src).then(function(blob) {
+						var blobInfoId = 'blobid' + (count++),
+							blobInfo = blobCache.create(blobInfoId, blob, base64);
 
-			if (location == 'before') {
-				node = container.nextSibling;
-				if (isContentEditableFalse(node)) {
-					return before(node);
-				}
-			}
+						blobCache.add(blobInfo);
 
-			if (location == 'after') {
-				node = container.previousSibling;
-				if (isContentEditableFalse(node)) {
-					return after(node);
+						resolve({
+							image: img,
+							blobInfo: blobInfo
+						});
+					});
 				}
 			}
-		}
 
-		if (!range.collapsed) {
-			return range;
-		}
+			if (!predicate) {
+				predicate = Fun.constant(true);
+			}
 
-		if (NodeType.isText(container)) {
-			if (isCaretContainer(container)) {
-				if (direction === 1) {
-					node = leanRight(container);
-					if (node) {
-						return before(node);
-					}
+			images = Arr.filter(elm.getElementsByTagName('img'), function(img) {
+				var src = img.src;
 
-					node = leanLeft(container);
-					if (node) {
-						return after(node);
-					}
+				if (!Env.fileApi) {
+					return false;
 				}
 
-				if (direction === -1) {
-					node = leanLeft(container);
-					if (node) {
-						return after(node);
-					}
-
-					node = leanRight(container);
-					if (node) {
-						return before(node);
-					}
+				if (img.hasAttribute('data-mce-bogus')) {
+					return false;
 				}
 
-				return range;
-			}
-
-			if (CaretContainer.endsWithCaretContainer(container) && offset >= container.data.length - 1) {
-				if (direction === 1) {
-					node = leanRight(container);
-					if (node) {
-						return before(node);
-					}
+				if (img.hasAttribute('data-mce-placeholder')) {
+					return false;
 				}
 
-				return range;
-			}
-
-			if (CaretContainer.startsWithCaretContainer(container) && offset <= 1) {
-				if (direction === -1) {
-					node = leanLeft(container);
-					if (node) {
-						return after(node);
-					}
+				if (!src || src == Env.transparentSrc) {
+					return false;
 				}
 
-				return range;
-			}
+				if (src.indexOf('blob:') === 0) {
+					return true;
+				}
 
-			if (offset === container.data.length) {
-				node = leanRight(container);
-				if (node) {
-					return before(node);
+				if (src.indexOf('data:') === 0) {
+					return predicate(img);
 				}
 
-				return range;
-			}
+				return false;
+			});
 
-			if (offset === 0) {
-				node = leanLeft(container);
-				if (node) {
-					return after(node);
+			promises = Arr.map(images, function(img) {
+				var newPromise;
+
+				if (cachedPromises[img.src]) {
+					// Since the cached promise will return the cached image
+					// We need to wrap it and resolve with the actual image
+					return new Promise(function(resolve) {
+						cachedPromises[img.src].then(function(imageInfo) {
+							resolve({
+								image: img,
+								blobInfo: imageInfo.blobInfo
+							});
+						});
+					});
 				}
 
-				return range;
-			}
-		}
+				newPromise = new Promise(function(resolve) {
+					imageToBlobInfo(img, resolve);
+				}).then(function(result) {
+					delete cachedPromises[result.image.src];
+					return result;
+				})['catch'](function(error) {
+					delete cachedPromises[img.src];
+					return error;
+				});
 
-		return range;
-	}
+				cachedPromises[img.src] = newPromise;
 
-	function isNextToContentEditableFalse(relativeOffset, caretPosition) {
-		return isContentEditableFalse(getChildNodeAtRelativeOffset(relativeOffset, caretPosition));
-	}
+				return newPromise;
+			});
 
-	return {
-		isForwards: isForwards,
-		isBackwards: isBackwards,
-		findNode: findNode,
-		getEditingHost: getEditingHost,
-		getParentBlock: getParentBlock,
-		isInSameBlock: isInSameBlock,
-		isInSameEditingHost: isInSameEditingHost,
-		isBeforeContentEditableFalse: curry(isNextToContentEditableFalse, 0),
-		isAfterContentEditableFalse: curry(isNextToContentEditableFalse, -1),
-		normalizeRange: normalizeRange
+			return Promise.all(promises);
+		}
+
+		return {
+			findAll: findAll
+		};
 	};
 });
 
-// Included from: js/tinymce/classes/caret/CaretWalker.js
+// Included from: js/tinymce/classes/file/BlobCache.js
 
 /**
- * CaretWalker.js
+ * BlobCache.js
  *
  * Released under LGPL License.
  * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
@@ -33959,207 +34030,258 @@ define("tinymce/caret/CaretUtils", [
  */
 
 /**
- * This module contains logic for moving around a virtual caret in logical order within a DOM element.
- *
- * It ignores the most obvious invalid caret locations such as within a script element or within a
- * contentEditable=false element but it will return locations that isn't possible to render visually.
+ * Hold blob info objects where a blob has extra internal information.
  *
  * @private
- * @class tinymce.caret.CaretWalker
- * @example
- * var caretWalker = new CaretWalker(rootElm);
- *
- * var prevLogicalCaretPosition = caretWalker.prev(CaretPosition.fromRangeStart(range));
- * var nextLogicalCaretPosition = caretWalker.next(CaretPosition.fromRangeEnd(range));
+ * @class tinymce.file.BlobCache
  */
-define("tinymce/caret/CaretWalker", [
-	"tinymce/dom/NodeType",
-	"tinymce/caret/CaretCandidate",
-	"tinymce/caret/CaretPosition",
-	"tinymce/caret/CaretUtils",
+define("tinymce/file/BlobCache", [
 	"tinymce/util/Arr",
 	"tinymce/util/Fun"
-], function(NodeType, CaretCandidate, CaretPosition, CaretUtils, Arr, Fun) {
-	var isContentEditableFalse = NodeType.isContentEditableFalse,
-		isText = NodeType.isText,
-		isElement = NodeType.isElement,
-		isForwards = CaretUtils.isForwards,
-		isBackwards = CaretUtils.isBackwards,
-		isCaretCandidate = CaretCandidate.isCaretCandidate,
-		isAtomic = CaretCandidate.isAtomic,
-		isEditableCaretCandidate = CaretCandidate.isEditableCaretCandidate;
+], function(Arr, Fun) {
+	return function() {
+		var cache = [], constant = Fun.constant;
 
-	function getParents(node, rootNode) {
-		var parents = [];
+		function create(id, blob, base64) {
+			return {
+				id: constant(id),
+				blob: constant(blob),
+				base64: constant(base64),
+				blobUri: constant(URL.createObjectURL(blob))
+			};
+		}
 
-		while (node && node != rootNode) {
-			parents.push(node);
-			node = node.parentNode;
+		function add(blobInfo) {
+			if (!get(blobInfo.id())) {
+				cache.push(blobInfo);
+			}
 		}
 
-		return parents;
-	}
+		function get(id) {
+			return findFirst(function(cachedBlobInfo) {
+				return cachedBlobInfo.id() === id;
+			});
+		}
 
-	function nodeAtIndex(container, offset) {
-		if (container.hasChildNodes() && offset < container.childNodes.length) {
-			return container.childNodes[offset];
+		function findFirst(predicate) {
+			return Arr.filter(cache, predicate)[0];
 		}
 
-		return null;
-	}
+		function getByUri(blobUri) {
+			return findFirst(function(blobInfo) {
+				return blobInfo.blobUri() == blobUri;
+			});
+		}
 
-	function getCaretCandidatePosition(direction, node) {
-		if (isForwards(direction)) {
-			if (isCaretCandidate(node.previousSibling) && !isText(node.previousSibling)) {
-				return CaretPosition.before(node);
-			}
+		function destroy() {
+			Arr.each(cache, function(cachedBlobInfo) {
+				URL.revokeObjectURL(cachedBlobInfo.blobUri());
+			});
 
-			if (isText(node)) {
-				return CaretPosition(node, 0);
-			}
+			cache = [];
 		}
 
-		if (isBackwards(direction)) {
-			if (isCaretCandidate(node.nextSibling) && !isText(node.nextSibling)) {
-				return CaretPosition.after(node);
-			}
+		return {
+			create: create,
+			add: add,
+			get: get,
+			getByUri: getByUri,
+			findFirst: findFirst,
+			destroy: destroy
+		};
+	};
+});
 
-			if (isText(node)) {
-				return CaretPosition(node, node.data.length);
-			}
+// Included from: js/tinymce/classes/EditorUpload.js
+
+/**
+ * EditorUpload.js
+ *
+ * Released under LGPL License.
+ * Copyright (c) 1999-2015 Ephox Corp. All rights reserved
+ *
+ * License: http://www.tinymce.com/license
+ * Contributing: http://www.tinymce.com/contributing
+ */
+
+/**
+ * Handles image uploads, updates undo stack and patches over various internal functions.
+ *
+ * @private
+ * @class tinymce.EditorUpload
+ */
+define("tinymce/EditorUpload", [
+	"tinymce/util/Arr",
+	"tinymce/file/Uploader",
+	"tinymce/file/ImageScanner",
+	"tinymce/file/BlobCache"
+], function(Arr, Uploader, ImageScanner, BlobCache) {
+	return function(editor) {
+		var blobCache = new BlobCache(), uploader, imageScanner, settings = editor.settings;
+
+		function aliveGuard(callback) {
+			return function(result) {
+				if (editor.selection) {
+					return callback(result);
+				}
+
+				return [];
+			};
 		}
 
-		if (isBackwards(direction)) {
-			return CaretPosition.after(node);
+		// Replaces strings without regexps to avoid FF regexp to big issue
+		function replaceString(content, search, replace) {
+			var index = 0;
+
+			do {
+				index = content.indexOf(search, index);
+
+				if (index !== -1) {
+					content = content.substring(0, index) + replace + content.substr(index + search.length);
+					index += replace.length - search.length + 1;
+				}
+			} while (index !== -1);
+
+			return content;
 		}
 
-		return CaretPosition.before(node);
-	}
+		function replaceImageUrl(content, targetUrl, replacementUrl) {
+			content = replaceString(content, 'src="' + targetUrl + '"', 'src="' + replacementUrl + '"');
+			content = replaceString(content, 'data-mce-src="' + targetUrl + '"', 'data-mce-src="' + replacementUrl + '"');
 
-	function findCaretPosition(direction, startCaretPosition, rootNode) {
-		var container, offset, node, nextNode, innerNode,
-			rootContentEditableFalseElm, caretPosition;
+			return content;
+		}
 
-		if (!isElement(rootNode) || !startCaretPosition) {
-			return null;
+		function replaceUrlInUndoStack(targetUrl, replacementUrl) {
+			Arr.each(editor.undoManager.data, function(level) {
+				level.content = replaceImageUrl(level.content, targetUrl, replacementUrl);
+			});
 		}
 
-		caretPosition = startCaretPosition;
-		container = caretPosition.container();
-		offset = caretPosition.offset();
+		function openNotification() {
+			return editor.notificationManager.open({
+				text: editor.translate('Image uploading...'),
+				type: 'info',
+				timeout: -1,
+				progressBar: true
+			});
+		}
 
-		if (isText(container)) {
-			if (isBackwards(direction) && offset > 0) {
-				return CaretPosition(container, --offset);
+		function uploadImages(callback) {
+			if (!uploader) {
+				uploader = new Uploader({
+					url: settings.images_upload_url,
+					basePath: settings.images_upload_base_path,
+					credentials: settings.images_upload_credentials,
+					handler: settings.images_upload_handler
+				});
 			}
 
-			if (isForwards(direction) && offset < container.length) {
-				return CaretPosition(container, ++offset);
-			}
+			return scanForImages().then(aliveGuard(function(imageInfos) {
+				var blobInfos;
 
-			node = container;
-		} else {
-			if (isBackwards(direction) && offset > 0) {
-				nextNode = nodeAtIndex(container, offset - 1);
-				if (isCaretCandidate(nextNode)) {
-					if (!isAtomic(nextNode)) {
-						innerNode = CaretUtils.findNode(nextNode, direction, isEditableCaretCandidate, nextNode);
-						if (innerNode) {
-							if (isText(innerNode)) {
-								return CaretPosition(innerNode, innerNode.data.length);
-							}
+				blobInfos = Arr.map(imageInfos, function(imageInfo) {
+					return imageInfo.blobInfo;
+				});
 
-							return CaretPosition.after(innerNode);
-						}
-					}
+				return uploader.upload(blobInfos, openNotification).then(aliveGuard(function(result) {
+					result = Arr.map(result, function(uploadInfo, index) {
+						var image = imageInfos[index].image;
 
-					if (isText(nextNode)) {
-						return CaretPosition(nextNode, nextNode.data.length);
-					}
+						if (uploadInfo.status) {
+							replaceUrlInUndoStack(image.src, uploadInfo.url);
 
-					return CaretPosition.before(nextNode);
-				}
-			}
+							editor.$(image).attr({
+								src: uploadInfo.url,
+								'data-mce-src': editor.convertURL(uploadInfo.url, 'src')
+							});
+						}
 
-			if (isForwards(direction) && offset < container.childNodes.length) {
-				nextNode = nodeAtIndex(container, offset);
-				if (isCaretCandidate(nextNode)) {
-					if (!isAtomic(nextNode)) {
-						innerNode = CaretUtils.findNode(nextNode, direction, isEditableCaretCandidate, nextNode);
-						if (innerNode) {
-							if (isText(innerNode)) {
-								return CaretPosition(innerNode, 0);
-							}
+						return {
+							element: image,
+							status: uploadInfo.status
+						};
+					});
 
-							return CaretPosition.before(innerNode);
-						}
+					if (callback) {
+						callback(result);
 					}
 
-					if (isText(nextNode)) {
-						return CaretPosition(nextNode, 0);
-					}
+					return result;
+				}));
+			}));
+		}
 
-					return CaretPosition.after(nextNode);
-				}
+		function uploadImagesAuto(callback) {
+			if (settings.automatic_uploads !== false) {
+				return uploadImages(callback);
 			}
-
-			node = caretPosition.getNode();
 		}
 
-		if ((isForwards(direction) && caretPosition.isAtEnd()) || (isBackwards(direction) && caretPosition.isAtStart())) {
-			node = CaretUtils.findNode(node, direction, Fun.constant(true), rootNode, true);
-			if (isEditableCaretCandidate(node)) {
-				return getCaretCandidatePosition(direction, node);
+		function scanForImages() {
+			if (!imageScanner) {
+				imageScanner = new ImageScanner(blobCache);
 			}
-		}
 
-		nextNode = CaretUtils.findNode(node, direction, isEditableCaretCandidate, rootNode);
+			return imageScanner.findAll(editor.getBody(), settings.images_dataimg_filter).then(aliveGuard(function(result) {
+				Arr.each(result, function(resultItem) {
+					replaceUrlInUndoStack(resultItem.image.src, resultItem.blobInfo.blobUri());
+					resultItem.image.src = resultItem.blobInfo.blobUri();
+				});
 
-		rootContentEditableFalseElm = Arr.last(Arr.filter(getParents(container, rootNode), isContentEditableFalse));
-		if (rootContentEditableFalseElm && (!nextNode || !rootContentEditableFalseElm.contains(nextNode))) {
-			if (isForwards(direction)) {
-				caretPosition = CaretPosition.after(rootContentEditableFalseElm);
-			} else {
-				caretPosition = CaretPosition.before(rootContentEditableFalseElm);
-			}
+				return result;
+			}));
+		}
 
-			return caretPosition;
+		function destroy() {
+			blobCache.destroy();
+			imageScanner = uploader = null;
 		}
 
-		if (nextNode) {
-			return getCaretCandidatePosition(direction, nextNode);
+		function replaceBlobWithBase64(content) {
+			return content.replace(/src="(blob:[^"]+)"/g, function(match, blobUri) {
+				var blobInfo = blobCache.getByUri(blobUri);
+
+				if (!blobInfo) {
+					blobInfo = Arr.reduce(editor.editorManager.editors, function(result, editor) {
+						return result || editor.editorUpload.blobCache.getByUri(blobUri);
+					}, null);
+				}
+
+				if (blobInfo) {
+					return 'src="data:' + blobInfo.blob().type + ';base64,' + blobInfo.base64() + '"';
+				}
+
+				return match;
+			});
 		}
 
-		return null;
-	}
+		editor.on('setContent', function() {
+			if (editor.settings.automatic_uploads !== false) {
+				uploadImagesAuto();
+			} else {
+				scanForImages();
+			}
+		});
 
-	return function(rootNode) {
-		return {
-			/**
-			 * Returns the next logical caret position from the specificed input
-			 * caretPoisiton or null if there isn't any more positions left for example
-			 * at the end specified root element.
-			 *
-			 * @method next
-			 * @param {tinymce.caret.CaretPosition} caretPosition Caret position to start from.
-			 * @return {tinymce.caret.CaretPosition} CaretPosition or null if no position was found.
-			 */
-			next: function(caretPosition) {
-				return findCaretPosition(1, caretPosition, rootNode);
-			},
+		editor.on('RawSaveContent', function(e) {
+			e.content = replaceBlobWithBase64(e.content);
+		});
 
-			/**
-			 * Returns the previous logical caret position from the specificed input
-			 * caretPoisiton or null if there isn't any more positions left for example
-			 * at the end specified root element.
-			 *
-			 * @method prev
-			 * @param {tinymce.caret.CaretPosition} caretPosition Caret position to start from.
-			 * @return {tinymce.caret.CaretPosition} CaretPosition or null if no position was found.
-			 */
-			prev: function(caretPosition) {
-				return findCaretPosition(-1, caretPosition, rootNode);
+		editor.on('getContent', function(e) {
+			if (e.source_view || e.format == 'raw') {
+				return;
 			}
+
+			e.content = replaceBlobWithBase64(e.content);
+		});
+
+		return {
+			blobCache: blobCache,
+			uploadImages: uploadImages,
+			uploadImagesAuto: uploadImagesAuto,
+			scanForImages: scanForImages,
+			destroy: destroy
 		};
 	};
 });
@@ -35877,10 +35999,11 @@ define("tinymce/Editor", [
 	 * @param {tinymce.EditorManager} editorManager EditorManager instance.
 	 */
 	function Editor(id, settings, editorManager) {
-		var self = this, documentBaseUrl, baseUri;
+		var self = this, documentBaseUrl, baseUri, defaultSettings;
 
 		documentBaseUrl = self.documentBaseUrl = editorManager.documentBaseURL;
 		baseUri = editorManager.baseURI;
+		defaultSettings = editorManager.defaultSettings;
 
 		/**
 		 * Name/value collection with editor settings.
@@ -35891,7 +36014,7 @@ define("tinymce/Editor", [
 		 * // Get the value of the theme setting
 		 * tinymce.activeEditor.windowManager.alert("You are using the " + tinymce.activeEditor.settings.theme + " theme");
 		 */
-		self.settings = settings = extend({
+		settings = extend({
 			id: id,
 			theme: 'modern',
 			delta_width: 0,
@@ -35929,11 +36052,16 @@ define("tinymce/Editor", [
 			url_converter: self.convertURL,
 			url_converter_scope: self,
 			ie7_compat: true
-		}, editorManager.defaultSettings, settings);
+		}, defaultSettings, settings);
+
+		// Merge external_plugins
+		if (defaultSettings && defaultSettings.external_plugins && settings.external_plugins) {
+			settings.external_plugins = extend({}, defaultSettings.external_plugins, settings.external_plugins);
+		}
 
+		self.settings = settings;
 		AddOnManager.language = settings.language || 'en';
 		AddOnManager.languageLoad = settings.language_load;
-
 		AddOnManager.baseURL = editorManager.baseURL;
 
 		/**
@@ -38425,16 +38553,20 @@ define("tinymce/EditorManager", [
 
 	function globalEventDelegate(e) {
 		each(EditorManager.editors, function(editor) {
-			editor.fire('ResizeWindow', e);
+			if (e.type === 'scroll') {
+				editor.fire('ScrollWindow', e);
+			} else {
+				editor.fire('ResizeWindow', e);
+			}
 		});
 	}
 
 	function toggleGlobalEvents(editors, state) {
 		if (state !== boundGlobalEvents) {
 			if (state) {
-				$(window).on('resize', globalEventDelegate);
+				$(window).on('resize scroll', globalEventDelegate);
 			} else {
-				$(window).off('resize', globalEventDelegate);
+				$(window).off('resize scroll', globalEventDelegate);
 			}
 
 			boundGlobalEvents = state;
@@ -38502,7 +38634,7 @@ define("tinymce/EditorManager", [
 		 * @property minorVersion
 		 * @type String
 		 */
-		minorVersion: '3.7',
+		minorVersion: '3.8',
 
 		/**
 		 * Release date of TinyMCE build.
@@ -38510,7 +38642,7 @@ define("tinymce/EditorManager", [
 		 * @property releaseDate
 		 * @type String
 		 */
-		releaseDate: '2016-03-02',
+		releaseDate: '2016-03-15',
 
 		/**
 		 * Collection of editor instances.