1 // 4.1.10 (2015-05-05)

     2 

     3 /**

     4  * Compiled inline version. (Library mode)

     5  */

     6 

     7 /*jshint smarttabs:true, undef:true, latedef:true, curly:true, bitwise:true, camelcase:true */

     8 /*globals $code */

     9 

    10 (function(exports, undefined) {

    11 	"use strict";

    12 

    13 	var modules = {};

    14 

    15 	function require(ids, callback) {

    16 		var module, defs = [];

    17 

    18 		for (var i = 0; i < ids.length; ++i) {

    19 			module = modules[ids[i]] || resolve(ids[i]);

    20 			if (!module) {

    21 				throw 'module definition dependecy not found: ' + ids[i];

    22 			}

    23 

    24 			defs.push(module);

    25 		}

    26 

    27 		callback.apply(null, defs);

    28 	}

    29 

    30 	function define(id, dependencies, definition) {

    31 		if (typeof id !== 'string') {

    32 			throw 'invalid module definition, module id must be defined and be a string';

    33 		}

    34 

    35 		if (dependencies === undefined) {

    36 			throw 'invalid module definition, dependencies must be specified';

    37 		}

    38 

    39 		if (definition === undefined) {

    40 			throw 'invalid module definition, definition function must be specified';

    41 		}

    42 

    43 		require(dependencies, function() {

    44 			modules[id] = definition.apply(null, arguments);

    45 		});

    46 	}

    47 

    48 	function defined(id) {

    49 		return !!modules[id];

    50 	}

    51 

    52 	function resolve(id) {

    53 		var target = exports;

    54 		var fragments = id.split(/[.\/]/);

    55 

    56 		for (var fi = 0; fi < fragments.length; ++fi) {

    57 			if (!target[fragments[fi]]) {

    58 				return;

    59 			}

    60 

    61 			target = target[fragments[fi]];

    62 		}

    63 

    64 		return target;

    65 	}

    66 

    67 	function expose(ids) {

    68 		for (var i = 0; i < ids.length; i++) {

    69 			var target = exports;

    70 			var id = ids[i];

    71 			var fragments = id.split(/[.\/]/);

    72 

    73 			for (var fi = 0; fi < fragments.length - 1; ++fi) {

    74 				if (target[fragments[fi]] === undefined) {

    75 					target[fragments[fi]] = {};

    76 				}

    77 

    78 				target = target[fragments[fi]];

    79 			}

    80 

    81 			target[fragments[fragments.length - 1]] = modules[id];

    82 		}

    83 	}

    84 

    85 // Included from: js/tinymce/classes/dom/EventUtils.js

    86 

    87 /**

    88  * EventUtils.js

    89  *

    90  * Copyright, Moxiecode Systems AB

    91  * Released under LGPL License.

    92  *

    93  * License: http://www.tinymce.com/license

    94  * Contributing: http://www.tinymce.com/contributing

    95  */

    96 

    97 /*jshint loopfunc:true*/

    98 /*eslint no-loop-func:0 */

    99 

   100 /**

   101  * This class wraps the browsers native event logic with more convenient methods.

   102  *

   103  * @class tinymce.dom.EventUtils

   104  */

   105 define("tinymce/dom/EventUtils", [], function() {

   106 	"use strict";

   107 

   108 	var eventExpandoPrefix = "mce-data-";

   109 	var mouseEventRe = /^(?:mouse|contextmenu)|click/;

   110 	var deprecated = {keyLocation: 1, layerX: 1, layerY: 1, returnValue: 1};

   111 

   112 	/**

   113 	 * Binds a native event to a callback on the speified target.

   114 	 */

   115 	function addEvent(target, name, callback, capture) {

   116 		if (target.addEventListener) {

   117 			target.addEventListener(name, callback, capture || false);

   118 		} else if (target.attachEvent) {

   119 			target.attachEvent('on' + name, callback);

   120 		}

   121 	}

   122 

   123 	/**

   124 	 * Unbinds a native event callback on the specified target.

   125 	 */

   126 	function removeEvent(target, name, callback, capture) {

   127 		if (target.removeEventListener) {

   128 			target.removeEventListener(name, callback, capture || false);

   129 		} else if (target.detachEvent) {

   130 			target.detachEvent('on' + name, callback);

   131 		}

   132 	}

   133 

   134 	/**

   135 	 * Normalizes a native event object or just adds the event specific methods on a custom event.

   136 	 */

   137 	function fix(originalEvent, data) {

   138 		var name, event = data || {}, undef;

   139 

   140 		// Dummy function that gets replaced on the delegation state functions

   141 		function returnFalse() {

   142 			return false;

   143 		}

   144 

   145 		// Dummy function that gets replaced on the delegation state functions

   146 		function returnTrue() {

   147 			return true;

   148 		}

   149 

   150 		// Copy all properties from the original event

   151 		for (name in originalEvent) {

   152 			// layerX/layerY is deprecated in Chrome and produces a warning

   153 			if (!deprecated[name]) {

   154 				event[name] = originalEvent[name];

   155 			}

   156 		}

   157 

   158 		// Normalize target IE uses srcElement

   159 		if (!event.target) {

   160 			event.target = event.srcElement || document;

   161 		}

   162 

   163 		// Calculate pageX/Y if missing and clientX/Y available

   164 		if (originalEvent && mouseEventRe.test(originalEvent.type) && originalEvent.pageX === undef && originalEvent.clientX !== undef) {

   165 			var eventDoc = event.target.ownerDocument || document;

   166 			var doc = eventDoc.documentElement;

   167 			var body = eventDoc.body;

   168 

   169 			event.pageX = originalEvent.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) -

   170 				(doc && doc.clientLeft || body && body.clientLeft || 0);

   171 

   172 			event.pageY = originalEvent.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) -

   173 				(doc && doc.clientTop || body && body.clientTop || 0);

   174 		}

   175 

   176 		// Add preventDefault method

   177 		event.preventDefault = function() {

   178 			event.isDefaultPrevented = returnTrue;

   179 

   180 			// Execute preventDefault on the original event object

   181 			if (originalEvent) {

   182 				if (originalEvent.preventDefault) {

   183 					originalEvent.preventDefault();

   184 				} else {

   185 					originalEvent.returnValue = false; // IE

   186 				}

   187 			}

   188 		};

   189 

   190 		// Add stopPropagation

   191 		event.stopPropagation = function() {

   192 			event.isPropagationStopped = returnTrue;

   193 

   194 			// Execute stopPropagation on the original event object

   195 			if (originalEvent) {

   196 				if (originalEvent.stopPropagation) {

   197 					originalEvent.stopPropagation();

   198 				} else {

   199 					originalEvent.cancelBubble = true; // IE

   200 				}

   201 			}

   202 		};

   203 

   204 		// Add stopImmediatePropagation

   205 		event.stopImmediatePropagation = function() {

   206 			event.isImmediatePropagationStopped = returnTrue;

   207 			event.stopPropagation();

   208 		};

   209 

   210 		// Add event delegation states

   211 		if (!event.isDefaultPrevented) {

   212 			event.isDefaultPrevented = returnFalse;

   213 			event.isPropagationStopped = returnFalse;

   214 			event.isImmediatePropagationStopped = returnFalse;

   215 		}

   216 

   217 		return event;

   218 	}

   219 

   220 	/**

   221 	 * Bind a DOMContentLoaded event across browsers and executes the callback once the page DOM is initialized.

   222 	 * It will also set/check the domLoaded state of the event_utils instance so ready isn't called multiple times.

   223 	 */

   224 	function bindOnReady(win, callback, eventUtils) {

   225 		var doc = win.document, event = {type: 'ready'};

   226 

   227 		if (eventUtils.domLoaded) {

   228 			callback(event);

   229 			return;

   230 		}

   231 

   232 		// Gets called when the DOM is ready

   233 		function readyHandler() {

   234 			if (!eventUtils.domLoaded) {

   235 				eventUtils.domLoaded = true;

   236 				callback(event);

   237 			}

   238 		}

   239 

   240 		function waitForDomLoaded() {

   241 			// Check complete or interactive state if there is a body

   242 			// element on some iframes IE 8 will produce a null body

   243 			if (doc.readyState === "complete" || (doc.readyState === "interactive" && doc.body)) {

   244 				removeEvent(doc, "readystatechange", waitForDomLoaded);

   245 				readyHandler();

   246 			}

   247 		}

   248 

   249 		function tryScroll() {

   250 			try {

   251 				// If IE is used, use the trick by Diego Perini licensed under MIT by request to the author.

   252 				// http://javascript.nwbox.com/IEContentLoaded/

   253 				doc.documentElement.doScroll("left");

   254 			} catch (ex) {

   255 				setTimeout(tryScroll, 0);

   256 				return;

   257 			}

   258 

   259 			readyHandler();

   260 		}

   261 

   262 		// Use W3C method

   263 		if (doc.addEventListener) {

   264 			if (doc.readyState === "complete") {

   265 				readyHandler();

   266 			} else {

   267 				addEvent(win, 'DOMContentLoaded', readyHandler);

   268 			}

   269 		} else {

   270 			// Use IE method

   271 			addEvent(doc, "readystatechange", waitForDomLoaded);

   272 

   273 			// Wait until we can scroll, when we can the DOM is initialized

   274 			if (doc.documentElement.doScroll && win.self === win.top) {

   275 				tryScroll();

   276 			}

   277 		}

   278 

   279 		// Fallback if any of the above methods should fail for some odd reason

   280 		addEvent(win, 'load', readyHandler);

   281 	}

   282 

   283 	/**

   284 	 * This class enables you to bind/unbind native events to elements and normalize it's behavior across browsers.

   285 	 */

   286 	function EventUtils() {

   287 		var self = this, events = {}, count, expando, hasFocusIn, hasMouseEnterLeave, mouseEnterLeave;

   288 

   289 		expando = eventExpandoPrefix + (+new Date()).toString(32);

   290 		hasMouseEnterLeave = "onmouseenter" in document.documentElement;

   291 		hasFocusIn = "onfocusin" in document.documentElement;

   292 		mouseEnterLeave = {mouseenter: 'mouseover', mouseleave: 'mouseout'};

   293 		count = 1;

   294 

   295 		// State if the DOMContentLoaded was executed or not

   296 		self.domLoaded = false;

   297 		self.events = events;

   298 

   299 		/**

   300 		 * Executes all event handler callbacks for a specific event.

   301 		 *

   302 		 * @private

   303 		 * @param {Event} evt Event object.

   304 		 * @param {String} id Expando id value to look for.

   305 		 */

   306 		function executeHandlers(evt, id) {

   307 			var callbackList, i, l, callback, container = events[id];

   308 

   309 			callbackList = container && container[evt.type];

   310 			if (callbackList) {

   311 				for (i = 0, l = callbackList.length; i < l; i++) {

   312 					callback = callbackList[i];

   313 

   314 					// Check if callback exists might be removed if a unbind is called inside the callback

   315 					if (callback && callback.func.call(callback.scope, evt) === false) {

   316 						evt.preventDefault();

   317 					}

   318 

   319 					// Should we stop propagation to immediate listeners

   320 					if (evt.isImmediatePropagationStopped()) {

   321 						return;

   322 					}

   323 				}

   324 			}

   325 		}

   326 

   327 		/**

   328 		 * Binds a callback to an event on the specified target.

   329 		 *

   330 		 * @method bind

   331 		 * @param {Object} target Target node/window or custom object.

   332 		 * @param {String} names Name of the event to bind.

   333 		 * @param {function} callback Callback function to execute when the event occurs.

   334 		 * @param {Object} scope Scope to call the callback function on, defaults to target.

   335 		 * @return {function} Callback function that got bound.

   336 		 */

   337 		self.bind = function(target, names, callback, scope) {

   338 			var id, callbackList, i, name, fakeName, nativeHandler, capture, win = window;

   339 

   340 			// Native event handler function patches the event and executes the callbacks for the expando

   341 			function defaultNativeHandler(evt) {

   342 				executeHandlers(fix(evt || win.event), id);

   343 			}

   344 

   345 			// Don't bind to text nodes or comments

   346 			if (!target || target.nodeType === 3 || target.nodeType === 8) {

   347 				return;

   348 			}

   349 

   350 			// Create or get events id for the target

   351 			if (!target[expando]) {

   352 				id = count++;

   353 				target[expando] = id;

   354 				events[id] = {};

   355 			} else {

   356 				id = target[expando];

   357 			}

   358 

   359 			// Setup the specified scope or use the target as a default

   360 			scope = scope || target;

   361 

   362 			// Split names and bind each event, enables you to bind multiple events with one call

   363 			names = names.split(' ');

   364 			i = names.length;

   365 			while (i--) {

   366 				name = names[i];

   367 				nativeHandler = defaultNativeHandler;

   368 				fakeName = capture = false;

   369 

   370 				// Use ready instead of DOMContentLoaded

   371 				if (name === "DOMContentLoaded") {

   372 					name = "ready";

   373 				}

   374 

   375 				// DOM is already ready

   376 				if (self.domLoaded && name === "ready" && target.readyState == 'complete') {

   377 					callback.call(scope, fix({type: name}));

   378 					continue;

   379 				}

   380 

   381 				// Handle mouseenter/mouseleaver

   382 				if (!hasMouseEnterLeave) {

   383 					fakeName = mouseEnterLeave[name];

   384 

   385 					if (fakeName) {

   386 						nativeHandler = function(evt) {

   387 							var current, related;

   388 

   389 							current = evt.currentTarget;

   390 							related = evt.relatedTarget;

   391 

   392 							// Check if related is inside the current target if it's not then the event should

   393 							// be ignored since it's a mouseover/mouseout inside the element

   394 							if (related && current.contains) {

   395 								// Use contains for performance

   396 								related = current.contains(related);

   397 							} else {

   398 								while (related && related !== current) {

   399 									related = related.parentNode;

   400 								}

   401 							}

   402 

   403 							// Fire fake event

   404 							if (!related) {

   405 								evt = fix(evt || win.event);

   406 								evt.type = evt.type === 'mouseout' ? 'mouseleave' : 'mouseenter';

   407 								evt.target = current;

   408 								executeHandlers(evt, id);

   409 							}

   410 						};

   411 					}

   412 				}

   413 

   414 				// Fake bubbeling of focusin/focusout

   415 				if (!hasFocusIn && (name === "focusin" || name === "focusout")) {

   416 					capture = true;

   417 					fakeName = name === "focusin" ? "focus" : "blur";

   418 					nativeHandler = function(evt) {

   419 						evt = fix(evt || win.event);

   420 						evt.type = evt.type === 'focus' ? 'focusin' : 'focusout';

   421 						executeHandlers(evt, id);

   422 					};

   423 				}

   424 

   425 				// Setup callback list and bind native event

   426 				callbackList = events[id][name];

   427 				if (!callbackList) {

   428 					events[id][name] = callbackList = [{func: callback, scope: scope}];

   429 					callbackList.fakeName = fakeName;

   430 					callbackList.capture = capture;

   431 					//callbackList.callback = callback;

   432 

   433 					// Add the nativeHandler to the callback list so that we can later unbind it

   434 					callbackList.nativeHandler = nativeHandler;

   435 

   436 					// Check if the target has native events support

   437 

   438 					if (name === "ready") {

   439 						bindOnReady(target, nativeHandler, self);

   440 					} else {

   441 						addEvent(target, fakeName || name, nativeHandler, capture);

   442 					}

   443 				} else {

   444 					if (name === "ready" && self.domLoaded) {

   445 						callback({type: name});

   446 					} else {

   447 						// If it already has an native handler then just push the callback

   448 						callbackList.push({func: callback, scope: scope});

   449 					}

   450 				}

   451 			}

   452 

   453 			target = callbackList = 0; // Clean memory for IE

   454 

   455 			return callback;

   456 		};

   457 

   458 		/**

   459 		 * Unbinds the specified event by name, name and callback or all events on the target.

   460 		 *

   461 		 * @method unbind

   462 		 * @param {Object} target Target node/window or custom object.

   463 		 * @param {String} names Optional event name to unbind.

   464 		 * @param {function} callback Optional callback function to unbind.

   465 		 * @return {EventUtils} Event utils instance.

   466 		 */

   467 		self.unbind = function(target, names, callback) {

   468 			var id, callbackList, i, ci, name, eventMap;

   469 

   470 			// Don't bind to text nodes or comments

   471 			if (!target || target.nodeType === 3 || target.nodeType === 8) {

   472 				return self;

   473 			}

   474 

   475 			// Unbind event or events if the target has the expando

   476 			id = target[expando];

   477 			if (id) {

   478 				eventMap = events[id];

   479 

   480 				// Specific callback

   481 				if (names) {

   482 					names = names.split(' ');

   483 					i = names.length;

   484 					while (i--) {

   485 						name = names[i];

   486 						callbackList = eventMap[name];

   487 

   488 						// Unbind the event if it exists in the map

   489 						if (callbackList) {

   490 							// Remove specified callback

   491 							if (callback) {

   492 								ci = callbackList.length;

   493 								while (ci--) {

   494 									if (callbackList[ci].func === callback) {

   495 										var nativeHandler = callbackList.nativeHandler;

   496 										var fakeName = callbackList.fakeName, capture = callbackList.capture;

   497 

   498 										// Clone callbackList since unbind inside a callback would otherwise break the handlers loop

   499 										callbackList = callbackList.slice(0, ci).concat(callbackList.slice(ci + 1));

   500 										callbackList.nativeHandler = nativeHandler;

   501 										callbackList.fakeName = fakeName;

   502 										callbackList.capture = capture;

   503 

   504 										eventMap[name] = callbackList;

   505 									}

   506 								}

   507 							}

   508 

   509 							// Remove all callbacks if there isn't a specified callback or there is no callbacks left

   510 							if (!callback || callbackList.length === 0) {

   511 								delete eventMap[name];

   512 								removeEvent(target, callbackList.fakeName || name, callbackList.nativeHandler, callbackList.capture);

   513 							}

   514 						}

   515 					}

   516 				} else {

   517 					// All events for a specific element

   518 					for (name in eventMap) {

   519 						callbackList = eventMap[name];

   520 						removeEvent(target, callbackList.fakeName || name, callbackList.nativeHandler, callbackList.capture);

   521 					}

   522 

   523 					eventMap = {};

   524 				}

   525 

   526 				// Check if object is empty, if it isn't then we won't remove the expando map

   527 				for (name in eventMap) {

   528 					return self;

   529 				}

   530 

   531 				// Delete event object

   532 				delete events[id];

   533 

   534 				// Remove expando from target

   535 				try {

   536 					// IE will fail here since it can't delete properties from window

   537 					delete target[expando];

   538 				} catch (ex) {

   539 					// IE will set it to null

   540 					target[expando] = null;

   541 				}

   542 			}

   543 

   544 			return self;

   545 		};

   546 

   547 		/**

   548 		 * Fires the specified event on the specified target.

   549 		 *

   550 		 * @method fire

   551 		 * @param {Object} target Target node/window or custom object.

   552 		 * @param {String} name Event name to fire.

   553 		 * @param {Object} args Optional arguments to send to the observers.

   554 		 * @return {EventUtils} Event utils instance.

   555 		 */

   556 		self.fire = function(target, name, args) {

   557 			var id;

   558 

   559 			// Don't bind to text nodes or comments

   560 			if (!target || target.nodeType === 3 || target.nodeType === 8) {

   561 				return self;

   562 			}

   563 

   564 			// Build event object by patching the args

   565 			args = fix(null, args);

   566 			args.type = name;

   567 			args.target = target;

   568 

   569 			do {

   570 				// Found an expando that means there is listeners to execute

   571 				id = target[expando];

   572 				if (id) {

   573 					executeHandlers(args, id);

   574 				}

   575 

   576 				// Walk up the DOM

   577 				target = target.parentNode || target.ownerDocument || target.defaultView || target.parentWindow;

   578 			} while (target && !args.isPropagationStopped());

   579 

   580 			return self;

   581 		};

   582 

   583 		/**

   584 		 * Removes all bound event listeners for the specified target. This will also remove any bound

   585 		 * listeners to child nodes within that target.

   586 		 *

   587 		 * @method clean

   588 		 * @param {Object} target Target node/window object.

   589 		 * @return {EventUtils} Event utils instance.

   590 		 */

   591 		self.clean = function(target) {

   592 			var i, children, unbind = self.unbind;

   593 

   594 			// Don't bind to text nodes or comments

   595 			if (!target || target.nodeType === 3 || target.nodeType === 8) {

   596 				return self;

   597 			}

   598 

   599 			// Unbind any element on the specificed target

   600 			if (target[expando]) {

   601 				unbind(target);

   602 			}

   603 

   604 			// Target doesn't have getElementsByTagName it's probably a window object then use it's document to find the children

   605 			if (!target.getElementsByTagName) {

   606 				target = target.document;

   607 			}

   608 

   609 			// Remove events from each child element

   610 			if (target && target.getElementsByTagName) {

   611 				unbind(target);

   612 

   613 				children = target.getElementsByTagName('*');

   614 				i = children.length;

   615 				while (i--) {

   616 					target = children[i];

   617 

   618 					if (target[expando]) {

   619 						unbind(target);

   620 					}

   621 				}

   622 			}

   623 

   624 			return self;

   625 		};

   626 

   627 		/**

   628 		 * Destroys the event object. Call this on IE to remove memory leaks.

   629 		 */

   630 		self.destroy = function() {

   631 			events = {};

   632 		};

   633 

   634 		// Legacy function for canceling events

   635 		self.cancel = function(e) {

   636 			if (e) {

   637 				e.preventDefault();

   638 				e.stopImmediatePropagation();

   639 			}

   640 

   641 			return false;

   642 		};

   643 	}

   644 

   645 	EventUtils.Event = new EventUtils();

   646 	EventUtils.Event.bind(window, 'ready', function() {});

   647 

   648 	return EventUtils;

   649 });

   650 

   651 // Included from: js/tinymce/classes/dom/Sizzle.jQuery.js

   652 

   653 /**

   654  * Sizzle.jQuery.js

   655  *

   656  * Copyright, Moxiecode Systems AB

   657  * Released under LGPL License.

   658  *

   659  * License: http://www.tinymce.com/license

   660  * Contributing: http://www.tinymce.com/contributing

   661  */

   662 

   663 /*global jQuery:true */

   664 

   665 /*

   666  * Fake Sizzle using jQuery.

   667  */

   668 define("tinymce/dom/Sizzle", [], function() {

   669 	// Detect if jQuery is loaded

   670 	if (!window.jQuery) {

   671 		throw new Error("Load jQuery first");

   672 	}

   673 

   674 	return jQuery.find;

   675 });

   676 

   677 // Included from: js/tinymce/classes/Env.js

   678 

   679 /**

   680  * Env.js

   681  *

   682  * Copyright, Moxiecode Systems AB

   683  * Released under LGPL License.

   684  *

   685  * License: http://www.tinymce.com/license

   686  * Contributing: http://www.tinymce.com/contributing

   687  */

   688 

   689 /**

   690  * This class contains various environment constants like browser versions etc.

   691  * Normally you don't want to sniff specific browser versions but sometimes you have

   692  * to when it's impossible to feature detect. So use this with care.

   693  *

   694  * @class tinymce.Env

   695  * @static

   696  */

   697 define("tinymce/Env", [], function() {

   698 	var nav = navigator, userAgent = nav.userAgent;

   699 	var opera, webkit, ie, ie11, ie12, gecko, mac, iDevice, android;

   700 

   701 	opera = window.opera && window.opera.buildNumber;

   702 	android = /Android/.test(userAgent);

   703 	webkit = /WebKit/.test(userAgent);

   704 	ie = !webkit && !opera && (/MSIE/gi).test(userAgent) && (/Explorer/gi).test(nav.appName);

   705 	ie = ie && /MSIE (\w+)\./.exec(userAgent)[1];

   706 	ie11 = userAgent.indexOf('Trident/') != -1 && (userAgent.indexOf('rv:') != -1 || nav.appName.indexOf('Netscape') != -1) ? 11 : false;

   707 	ie12 = (document.msElementsFromPoint && !ie && !ie11) ? 12 : false;

   708 	ie = ie || ie11 || ie12;

   709 	gecko = !webkit && !ie11 && /Gecko/.test(userAgent);

   710 	mac = userAgent.indexOf('Mac') != -1;

   711 	iDevice = /(iPad|iPhone)/.test(userAgent);

   712 

   713 	if (ie12) {

   714 		webkit = false;

   715 	}

   716 

   717 	// Is a iPad/iPhone and not on iOS5 sniff the WebKit version since older iOS WebKit versions

   718 	// says it has contentEditable support but there is no visible caret.

   719 	var contentEditable = !iDevice || userAgent.match(/AppleWebKit\/(\d*)/)[1] >= 534;

   720 

   721 	return {

   722 		/**

   723 		 * Constant that is true if the browser is Opera.

   724 		 *

   725 		 * @property opera

   726 		 * @type Boolean

   727 		 * @final

   728 		 */

   729 		opera: opera,

   730 

   731 		/**

   732 		 * Constant that is true if the browser is WebKit (Safari/Chrome).

   733 		 *

   734 		 * @property webKit

   735 		 * @type Boolean

   736 		 * @final

   737 		 */

   738 		webkit: webkit,

   739 

   740 		/**

   741 		 * Constant that is more than zero if the browser is IE.

   742 		 *

   743 		 * @property ie

   744 		 * @type Boolean

   745 		 * @final

   746 		 */

   747 		ie: ie,

   748 

   749 		/**

   750 		 * Constant that is true if the browser is Gecko.

   751 		 *

   752 		 * @property gecko

   753 		 * @type Boolean

   754 		 * @final

   755 		 */

   756 		gecko: gecko,

   757 

   758 		/**

   759 		 * Constant that is true if the os is Mac OS.

   760 		 *

   761 		 * @property mac

   762 		 * @type Boolean

   763 		 * @final

   764 		 */

   765 		mac: mac,

   766 

   767 		/**

   768 		 * Constant that is true if the os is iOS.

   769 		 *

   770 		 * @property iOS

   771 		 * @type Boolean

   772 		 * @final

   773 		 */

   774 		iOS: iDevice,

   775 

   776 		/**

   777 		 * Constant that is true if the os is android.

   778 		 *

   779 		 * @property android

   780 		 * @type Boolean

   781 		 * @final

   782 		 */

   783 		android: android,

   784 

   785 		/**

   786 		 * Constant that is true if the browser supports editing.

   787 		 *

   788 		 * @property contentEditable

   789 		 * @type Boolean

   790 		 * @final

   791 		 */

   792 		contentEditable: contentEditable,

   793 

   794 		/**

   795 		 * Transparent image data url.

   796 		 *

   797 		 * @property transparentSrc

   798 		 * @type Boolean

   799 		 * @final

   800 		 */

   801 		transparentSrc: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",

   802 

   803 		/**

   804 		 * Returns true/false if the browser can or can't place the caret after a inline block like an image.

   805 		 *

   806 		 * @property noCaretAfter

   807 		 * @type Boolean

   808 		 * @final

   809 		 */

   810 		caretAfter: ie != 8,

   811 

   812 		/**

   813 		 * Constant that is true if the browser supports native DOM Ranges. IE 9+.

   814 		 *

   815 		 * @property range

   816 		 * @type Boolean

   817 		 */

   818 		range: window.getSelection && "Range" in window,

   819 

   820 		/**

   821 		 * Returns the IE document mode for non IE browsers this will fake IE 10.

   822 		 *

   823 		 * @property documentMode

   824 		 * @type Number

   825 		 */

   826 		documentMode: ie && !ie12 ? (document.documentMode || 7) : 10

   827 	};

   828 });

   829 

   830 // Included from: js/tinymce/classes/util/Tools.js

   831 

   832 /**

   833  * Tools.js

   834  *

   835  * Copyright, Moxiecode Systems AB

   836  * Released under LGPL License.

   837  *

   838  * License: http://www.tinymce.com/license

   839  * Contributing: http://www.tinymce.com/contributing

   840  */

   841 

   842 /**

   843  * This class contains various utlity functions. These are also exposed

   844  * directly on the tinymce namespace.

   845  *

   846  * @class tinymce.util.Tools

   847  */

   848 define("tinymce/util/Tools", [

   849 	"tinymce/Env"

   850 ], function(Env) {

   851 	/**

   852 	 * Removes whitespace from the beginning and end of a string.

   853 	 *

   854 	 * @method trim

   855 	 * @param {String} s String to remove whitespace from.

   856 	 * @return {String} New string with removed whitespace.

   857 	 */

   858 	var whiteSpaceRegExp = /^\s*|\s*$/g;

   859 

   860 	function trim(str) {

   861 		return (str === null || str === undefined) ? '' : ("" + str).replace(whiteSpaceRegExp, '');

   862 	}

   863 

   864 	/**

   865 	 * Returns true/false if the object is an array or not.

   866 	 *

   867 	 * @method isArray

   868 	 * @param {Object} obj Object to check.

   869 	 * @return {boolean} true/false state if the object is an array or not.

   870 	 */

   871 	var isArray = Array.isArray || function(obj) {

   872 		return Object.prototype.toString.call(obj) === "[object Array]";

   873 	};

   874 

   875 	/**

   876 	 * Checks if a object is of a specific type for example an array.

   877 	 *

   878 	 * @method is

   879 	 * @param {Object} obj Object to check type of.

   880 	 * @param {string} type Optional type to check for.

   881 	 * @return {Boolean} true/false if the object is of the specified type.

   882 	 */

   883 	function is(obj, type) {

   884 		if (!type) {

   885 			return obj !== undefined;

   886 		}

   887 

   888 		if (type == 'array' && isArray(obj)) {

   889 			return true;

   890 		}

   891 

   892 		return typeof obj == type;

   893 	}

   894 

   895 	/**

   896 	 * Converts the specified object into a real JavaScript array.

   897 	 *

   898 	 * @method toArray

   899 	 * @param {Object} obj Object to convert into array.

   900 	 * @return {Array} Array object based in input.

   901 	 */

   902 	function toArray(obj) {

   903 		var array = obj, i, l;

   904 

   905 		if (!isArray(obj)) {

   906 			array = [];

   907 			for (i = 0, l = obj.length; i < l; i++) {

   908 				array[i] = obj[i];

   909 			}

   910 		}

   911 

   912 		return array;

   913 	}

   914 

   915 	/**

   916 	 * Makes a name/object map out of an array with names.

   917 	 *

   918 	 * @method makeMap

   919 	 * @param {Array/String} items Items to make map out of.

   920 	 * @param {String} delim Optional delimiter to split string by.

   921 	 * @param {Object} map Optional map to add items to.

   922 	 * @return {Object} Name/value map of items.

   923 	 */

   924 	function makeMap(items, delim, map) {

   925 		var i;

   926 

   927 		items = items || [];

   928 		delim = delim || ',';

   929 

   930 		if (typeof items == "string") {

   931 			items = items.split(delim);

   932 		}

   933 

   934 		map = map || {};

   935 

   936 		i = items.length;

   937 		while (i--) {

   938 			map[items[i]] = {};

   939 		}

   940 

   941 		return map;

   942 	}

   943 

   944 	/**

   945 	 * Performs an iteration of all items in a collection such as an object or array. This method will execure the

   946 	 * callback function for each item in the collection, if the callback returns false the iteration will terminate.

   947 	 * The callback has the following format: cb(value, key_or_index).

   948 	 *

   949 	 * @method each

   950 	 * @param {Object} o Collection to iterate.

   951 	 * @param {function} cb Callback function to execute for each item.

   952 	 * @param {Object} s Optional scope to execute the callback in.

   953 	 * @example

   954 	 * // Iterate an array

   955 	 * tinymce.each([1,2,3], function(v, i) {

   956 	 *     console.debug("Value: " + v + ", Index: " + i);

   957 	 * });

   958 	 *

   959 	 * // Iterate an object

   960 	 * tinymce.each({a: 1, b: 2, c: 3], function(v, k) {

   961 	 *     console.debug("Value: " + v + ", Key: " + k);

   962 	 * });

   963 	 */

   964 	function each(o, cb, s) {

   965 		var n, l;

   966 

   967 		if (!o) {

   968 			return 0;

   969 		}

   970 

   971 		s = s || o;

   972 

   973 		if (o.length !== undefined) {

   974 			// Indexed arrays, needed for Safari

   975 			for (n = 0, l = o.length; n < l; n++) {

   976 				if (cb.call(s, o[n], n, o) === false) {

   977 					return 0;

   978 				}

   979 			}

   980 		} else {

   981 			// Hashtables

   982 			for (n in o) {

   983 				if (o.hasOwnProperty(n)) {

   984 					if (cb.call(s, o[n], n, o) === false) {

   985 						return 0;

   986 					}

   987 				}

   988 			}

   989 		}

   990 

   991 		return 1;

   992 	}

   993 

   994 	/**

   995 	 * Creates a new array by the return value of each iteration function call. This enables you to convert

   996 	 * one array list into another.

   997 	 *

   998 	 * @method map

   999 	 * @param {Array} array Array of items to iterate.

  1000 	 * @param {function} callback Function to call for each item. It's return value will be the new value.

  1001 	 * @return {Array} Array with new values based on function return values.

  1002 	 */

  1003 	function map(array, callback) {

  1004 		var out = [];

  1005 

  1006 		each(array, function(item) {

  1007 			out.push(callback(item));

  1008 		});

  1009 

  1010 		return out;

  1011 	}

  1012 

  1013 	/**

  1014 	 * Filters out items from the input array by calling the specified function for each item.

  1015 	 * If the function returns false the item will be excluded if it returns true it will be included.

  1016 	 *

  1017 	 * @method grep

  1018 	 * @param {Array} a Array of items to loop though.

  1019 	 * @param {function} f Function to call for each item. Include/exclude depends on it's return value.

  1020 	 * @return {Array} New array with values imported and filtered based in input.

  1021 	 * @example

  1022 	 * // Filter out some items, this will return an array with 4 and 5

  1023 	 * var items = tinymce.grep([1,2,3,4,5], function(v) {return v > 3;});

  1024 	 */

  1025 	function grep(a, f) {

  1026 		var o = [];

  1027 

  1028 		each(a, function(v) {

  1029 			if (!f || f(v)) {

  1030 				o.push(v);

  1031 			}

  1032 		});

  1033 

  1034 		return o;

  1035 	}

  1036 

  1037 	/**

  1038 	 * Creates a class, subclass or static singleton.

  1039 	 * More details on this method can be found in the Wiki.

  1040 	 *

  1041 	 * @method create

  1042 	 * @param {String} s Class name, inheritage and prefix.

  1043 	 * @param {Object} p Collection of methods to add to the class.

  1044 	 * @param {Object} root Optional root object defaults to the global window object.

  1045 	 * @example

  1046 	 * // Creates a basic class

  1047 	 * tinymce.create('tinymce.somepackage.SomeClass', {

  1048 	 *     SomeClass: function() {

  1049 	 *         // Class constructor

  1050 	 *     },

  1051 	 *

  1052 	 *     method: function() {

  1053 	 *         // Some method

  1054 	 *     }

  1055 	 * });

  1056 	 *

  1057 	 * // Creates a basic subclass class

  1058 	 * tinymce.create('tinymce.somepackage.SomeSubClass:tinymce.somepackage.SomeClass', {

  1059 	 *     SomeSubClass: function() {

  1060 	 *         // Class constructor

  1061 	 *         this.parent(); // Call parent constructor

  1062 	 *     },

  1063 	 *

  1064 	 *     method: function() {

  1065 	 *         // Some method

  1066 	 *         this.parent(); // Call parent method

  1067 	 *     },

  1068 	 *

  1069 	 *     'static': {

  1070 	 *         staticMethod: function() {

  1071 	 *             // Static method

  1072 	 *         }

  1073 	 *     }

  1074 	 * });

  1075 	 *

  1076 	 * // Creates a singleton/static class

  1077 	 * tinymce.create('static tinymce.somepackage.SomeSingletonClass', {

  1078 	 *     method: function() {

  1079 	 *         // Some method

  1080 	 *     }

  1081 	 * });

  1082 	 */

  1083 	function create(s, p, root) {

  1084 		var self = this, sp, ns, cn, scn, c, de = 0;

  1085 

  1086 		// Parse : <prefix> <class>:<super class>

  1087 		s = /^((static) )?([\w.]+)(:([\w.]+))?/.exec(s);

  1088 		cn = s[3].match(/(^|\.)(\w+)$/i)[2]; // Class name

  1089 

  1090 		// Create namespace for new class

  1091 		ns = self.createNS(s[3].replace(/\.\w+$/, ''), root);

  1092 

  1093 		// Class already exists

  1094 		if (ns[cn]) {

  1095 			return;

  1096 		}

  1097 

  1098 		// Make pure static class

  1099 		if (s[2] == 'static') {

  1100 			ns[cn] = p;

  1101 

  1102 			if (this.onCreate) {

  1103 				this.onCreate(s[2], s[3], ns[cn]);

  1104 			}

  1105 

  1106 			return;

  1107 		}

  1108 

  1109 		// Create default constructor

  1110 		if (!p[cn]) {

  1111 			p[cn] = function() {};

  1112 			de = 1;

  1113 		}

  1114 

  1115 		// Add constructor and methods

  1116 		ns[cn] = p[cn];

  1117 		self.extend(ns[cn].prototype, p);

  1118 

  1119 		// Extend

  1120 		if (s[5]) {

  1121 			sp = self.resolve(s[5]).prototype;

  1122 			scn = s[5].match(/\.(\w+)$/i)[1]; // Class name

  1123 

  1124 			// Extend constructor

  1125 			c = ns[cn];

  1126 			if (de) {

  1127 				// Add passthrough constructor

  1128 				ns[cn] = function() {

  1129 					return sp[scn].apply(this, arguments);

  1130 				};

  1131 			} else {

  1132 				// Add inherit constructor

  1133 				ns[cn] = function() {

  1134 					this.parent = sp[scn];

  1135 					return c.apply(this, arguments);