Set HttpOnly flag also for session cookie

Aleksander Machniak

2012-07-24 0afe27901189a5416dc696eef32e2bc2e5fe3844

 program/js/tiny_mce/plugins/lists/editor_plugin_src.js

@@ -1,781 +1,952 @@
/**
 * editor_plugin_src.js
 *
 * Copyright 2011, Moxiecode Systems AB
 * Released under LGPL License.
 *
 * License: http://tinymce.moxiecode.com/license
 * Contributing: http://tinymce.moxiecode.com/contributing
 */

(function() {
   var each = tinymce.each, Event = tinymce.dom.Event, bookmark;

   // Skips text nodes that only contain whitespace since they aren't semantically important.
   function skipWhitespaceNodes(e, next) {
      while (e && (e.nodeType === 8 || (e.nodeType === 3 && /^[ \t\n\r]*$/.test(e.nodeValue)))) {
         e = next(e);
      }
      return e;
   }

   function skipWhitespaceNodesBackwards(e) {
      return skipWhitespaceNodes(e, function(e) {
         return e.previousSibling;
      });
   }

   function skipWhitespaceNodesForwards(e) {
      return skipWhitespaceNodes(e, function(e) {
         return e.nextSibling;
      });
   }

   function hasParentInList(ed, e, list) {
      return ed.dom.getParent(e, function(p) {
         return tinymce.inArray(list, p) !== -1;
      });
   }

   function isList(e) {
      return e && (e.tagName === 'OL' || e.tagName === 'UL');
   }

   function splitNestedLists(element, dom) {
      var tmp, nested, wrapItem;
      tmp = skipWhitespaceNodesBackwards(element.lastChild);
      while (isList(tmp)) {
         nested = tmp;
         tmp = skipWhitespaceNodesBackwards(nested.previousSibling);
      }
      if (nested) {
         wrapItem = dom.create('li', { style: 'list-style-type: none;'});
         dom.split(element, nested);
         dom.insertAfter(wrapItem, nested);
         wrapItem.appendChild(nested);
         wrapItem.appendChild(nested);
         element = wrapItem.previousSibling;
      }
      return element;
   }

   function attemptMergeWithAdjacent(e, allowDifferentListStyles, mergeParagraphs) {
      e = attemptMergeWithPrevious(e, allowDifferentListStyles, mergeParagraphs);
      return attemptMergeWithNext(e, allowDifferentListStyles, mergeParagraphs);
   }

   function attemptMergeWithPrevious(e, allowDifferentListStyles, mergeParagraphs) {
      var prev = skipWhitespaceNodesBackwards(e.previousSibling);
      if (prev) {
         return attemptMerge(prev, e, allowDifferentListStyles ? prev : false, mergeParagraphs);
      } else {
         return e;
      }
   }

   function attemptMergeWithNext(e, allowDifferentListStyles, mergeParagraphs) {
      var next = skipWhitespaceNodesForwards(e.nextSibling);
      if (next) {
         return attemptMerge(e, next, allowDifferentListStyles ? next : false, mergeParagraphs);
      } else {
         return e;
      }
   }

   function attemptMerge(e1, e2, differentStylesMasterElement, mergeParagraphs) {
      if (canMerge(e1, e2, !!differentStylesMasterElement, mergeParagraphs)) {
         return merge(e1, e2, differentStylesMasterElement);
      } else if (e1 && e1.tagName === 'LI' && isList(e2)) {
         // Fix invalidly nested lists.
         e1.appendChild(e2);
      }
      return e2;
   }

   function canMerge(e1, e2, allowDifferentListStyles, mergeParagraphs) {
      if (!e1 || !e2) {
         return false;
      } else if (e1.tagName === 'LI' && e2.tagName === 'LI') {
         return e2.style.listStyleType === 'none' || containsOnlyAList(e2);
      } else if (isList(e1)) {
         return (e1.tagName === e2.tagName && (allowDifferentListStyles || e1.style.listStyleType === e2.style.listStyleType)) || isListForIndent(e2);
      } else if (mergeParagraphs && e1.tagName === 'P' && e2.tagName === 'P') {
         return true;
      } else {
         return false;
      }
   }

   function isListForIndent(e) {
      var firstLI = skipWhitespaceNodesForwards(e.firstChild), lastLI = skipWhitespaceNodesBackwards(e.lastChild);
      return firstLI && lastLI && isList(e) && firstLI === lastLI && (isList(firstLI) || firstLI.style.listStyleType === 'none' || containsOnlyAList(firstLI));
   }

   function containsOnlyAList(e) {
      var firstChild = skipWhitespaceNodesForwards(e.firstChild), lastChild = skipWhitespaceNodesBackwards(e.lastChild);
      return firstChild && lastChild && firstChild === lastChild && isList(firstChild);
   }

   function merge(e1, e2, masterElement) {
      var lastOriginal = skipWhitespaceNodesBackwards(e1.lastChild), firstNew = skipWhitespaceNodesForwards(e2.firstChild);
      if (e1.tagName === 'P') {
         e1.appendChild(e1.ownerDocument.createElement('br'));
      }
      while (e2.firstChild) {
         e1.appendChild(e2.firstChild);
      }
      if (masterElement) {
         e1.style.listStyleType = masterElement.style.listStyleType;
      }
      e2.parentNode.removeChild(e2);
      attemptMerge(lastOriginal, firstNew, false);
      return e1;
   }

   function findItemToOperateOn(e, dom) {
      var item;
      if (!dom.is(e, 'li,ol,ul')) {
         item = dom.getParent(e, 'li');
         if (item) {
            e = item;
         }
      }
      return e;
   }

   tinymce.create('tinymce.plugins.Lists', {
      init: function(ed, url) {
         var LIST_TABBING = 0;
         var LIST_EMPTY_ITEM = 1;
         var LIST_ESCAPE = 2;
         var LIST_UNKNOWN = 3;
         var state = LIST_UNKNOWN;

         function isTabInList(e) {
            return e.keyCode === 9 && (ed.queryCommandState('InsertUnorderedList') || ed.queryCommandState('InsertOrderedList'));
         }

         function isOnLastListItem() {
            var li = getLi();
            var grandParent = li.parentNode.parentNode;
            var isLastItem = li.parentNode.lastChild === li;
            return isLastItem && !isNestedList(grandParent) && isEmptyListItem(li);
         }

         function isNestedList(grandParent) {
            if (isList(grandParent)) {
               return grandParent.parentNode && grandParent.parentNode.tagName === 'LI';
            } else {
               return  grandParent.tagName === 'LI';
            }
         }

         function isInEmptyListItem() {
            return ed.selection.isCollapsed() && isEmptyListItem(getLi());
         }

         function getLi() {
            var n = ed.selection.getStart();
            // Get start will return BR if the LI only contains a BR or an empty element as we use these to fix caret position
            return ((n.tagName == 'BR' || n.tagName == '') && n.parentNode.tagName == 'LI') ? n.parentNode : n;
         }

         function isEmptyListItem(li) {
            var numChildren = li.childNodes.length;
            if (li.tagName === 'LI') {
               return numChildren == 0 ? true : numChildren == 1 && (li.firstChild.tagName == '' || isEmptyWebKitLi(li) || isEmptyIE9Li(li));
            }
            return false;
         }

         function isEmptyWebKitLi(li) {
            // Check for empty LI or a LI with just a child that is a BR since Gecko and WebKit uses BR elements to place the caret
            return tinymce.isWebKit && li.firstChild.nodeName == 'BR';
         }

         function isEmptyIE9Li(li) {
            // only consider this to be last item if there is no list item content or that content is nbsp or space since IE9 creates these
            var lis = tinymce.grep(li.parentNode.childNodes, function(n) {return n.nodeName == 'LI'});
            var isLastLi = li == lis[lis.length - 1];
            var child = li.firstChild;
            return tinymce.isIE9 && isLastLi && (child.nodeValue == String.fromCharCode(160) || child.nodeValue == String.fromCharCode(32));
         }

         function isEnter(e) {
            return e.keyCode === 13;
         }

         function getListKeyState(e) {
            if (isTabInList(e)) {
               return LIST_TABBING;
            } else if (isEnter(e) && isOnLastListItem()) {
               return LIST_ESCAPE;
            } else if (isEnter(e) && isInEmptyListItem()) {
               return LIST_EMPTY_ITEM;
            } else {
               return LIST_UNKNOWN;
            }
         }

         function cancelEnterAndTab(_, e) {
            if (state == LIST_TABBING || state == LIST_EMPTY_ITEM) {
               return Event.cancel(e);
            }
         }

         function imageJoiningListItem(ed, e) {
            var prevSibling;

            if (!tinymce.isGecko)
               return;

            var n = ed.selection.getStart();
            if (e.keyCode != 8 || n.tagName !== 'IMG')
               return;

            function lastLI(node) {
               var child = node.firstChild;
               var li = null;
               do {
                  if (!child)
                     break;

                  if (child.tagName === 'LI')
                     li = child;
               } while (child = child.nextSibling);

               return li;
            }

            function addChildren(parentNode, destination) {
               while (parentNode.childNodes.length > 0)
                  destination.appendChild(parentNode.childNodes[0]);
            }

            // Check if there is a previous sibling
            prevSibling = n.parentNode.previousSibling;
            if (!prevSibling)
               return;

            var ul;
            if (prevSibling.tagName === 'UL' || prevSibling.tagName === 'OL')
               ul = prevSibling;
            else if (prevSibling.previousSibling && (prevSibling.previousSibling.tagName === 'UL' || prevSibling.previousSibling.tagName === 'OL'))
               ul = prevSibling.previousSibling;
            else
               return;

            var li = lastLI(ul);

            // move the caret to the end of the list item
            var rng = ed.dom.createRng();
            rng.setStart(li, 1);
            rng.setEnd(li, 1);
            ed.selection.setRng(rng);
            ed.selection.collapse(true);

            // save a bookmark at the end of the list item
            var bookmark = ed.selection.getBookmark();

            // copy the image an its text to the list item
            var clone = n.parentNode.cloneNode(true);
            if (clone.tagName === 'P' || clone.tagName === 'DIV')
               addChildren(clone, li);
            else
               li.appendChild(clone);

            // remove the old copy of the image
            n.parentNode.parentNode.removeChild(n.parentNode);

            // move the caret where we saved the bookmark
            ed.selection.moveToBookmark(bookmark);
         }

         // fix the cursor position to ensure it is correct in IE
         function setCursorPositionToOriginalLi(li) {
            var list = ed.dom.getParent(li, 'ol,ul');
            if (list != null) {
               var lastLi = list.lastChild;
               lastLi.appendChild(ed.getDoc().createElement(''));
               ed.selection.setCursorLocation(lastLi, 0);
            }
         }

         this.ed = ed;
         ed.addCommand('Indent', this.indent, this);
         ed.addCommand('Outdent', this.outdent, this);
         ed.addCommand('InsertUnorderedList', function() {
            this.applyList('UL', 'OL');
         }, this);
         ed.addCommand('InsertOrderedList', function() {
            this.applyList('OL', 'UL');
         }, this);

         ed.onInit.add(function() {
            ed.editorCommands.addCommands({
               'outdent': function() {
                  var sel = ed.selection, dom = ed.dom;

                  function hasStyleIndent(n) {
                     n = dom.getParent(n, dom.isBlock);
                     return n && (parseInt(ed.dom.getStyle(n, 'margin-left') || 0, 10) + parseInt(ed.dom.getStyle(n, 'padding-left') || 0, 10)) > 0;
                  }

                  return hasStyleIndent(sel.getStart()) || hasStyleIndent(sel.getEnd()) || ed.queryCommandState('InsertOrderedList') || ed.queryCommandState('InsertUnorderedList');
               }
            }, 'state');
         });

         ed.onKeyUp.add(function(ed, e) {
            if (state == LIST_TABBING) {
               ed.execCommand(e.shiftKey ? 'Outdent' : 'Indent', true, null);
               state = LIST_UNKNOWN;
               return Event.cancel(e);
            } else if (state == LIST_EMPTY_ITEM) {
               var li = getLi();
               var shouldOutdent =  ed.settings.list_outdent_on_enter === true || e.shiftKey;
               ed.execCommand(shouldOutdent ? 'Outdent' : 'Indent', true, null);
               if (tinymce.isIE) {
                  setCursorPositionToOriginalLi(li);
               }
               return Event.cancel(e);
            } else if (state == LIST_ESCAPE) {
               if (tinymce.isIE8) {
                  // append a zero sized nbsp so that caret is positioned correctly in IE8 after escaping and applying formatting.
                  // if there is no text then applying formatting for e.g a H1 to the P tag immediately following list after
                  // escaping from it will cause the caret to be positioned on the last li instead of staying the in P tag.
                  var n = ed.getDoc().createTextNode('\uFEFF');
                  ed.selection.getNode().appendChild(n);
               } else if (tinymce.isIE9) {
                  // IE9 does not escape the list so we use outdent to do this and cancel the default behaviour
                  ed.execCommand('Outdent');
                  return Event.cancel(e);
               }
            }
         });
         ed.onKeyDown.add(function(_, e) { state = getListKeyState(e); });
         ed.onKeyDown.add(cancelEnterAndTab);
         ed.onKeyDown.add(imageJoiningListItem);
         ed.onKeyPress.add(cancelEnterAndTab);
      },

      applyList: function(targetListType, oppositeListType) {
         var t = this, ed = t.ed, dom = ed.dom, applied = [], hasSameType = false, hasOppositeType = false, hasNonList = false, actions,
               selectedBlocks = ed.selection.getSelectedBlocks();

         function cleanupBr(e) {
            if (e && e.tagName === 'BR') {
               dom.remove(e);
            }
         }

         function makeList(element) {
            var list = dom.create(targetListType), li;

            function adjustIndentForNewList(element) {
               // If there's a margin-left, outdent one level to account for the extra list margin.
               if (element.style.marginLeft || element.style.paddingLeft) {
                  t.adjustPaddingFunction(false)(element);
               }
            }

            if (element.tagName === 'LI') {
               // No change required.
            } else if (element.tagName === 'P' || element.tagName === 'DIV' || element.tagName === 'BODY') {
               processBrs(element, function(startSection, br, previousBR) {
                  doWrapList(startSection, br, element.tagName === 'BODY' ? null : startSection.parentNode);
                  li = startSection.parentNode;
                  adjustIndentForNewList(li);
                  cleanupBr(br);
               });
               if (element.tagName === 'P' || selectedBlocks.length > 1) {
                  dom.split(li.parentNode.parentNode, li.parentNode);
               }
               attemptMergeWithAdjacent(li.parentNode, true);
               return;
            } else {
               // Put the list around the element.
               li = dom.create('li');
               dom.insertAfter(li, element);
               li.appendChild(element);
               adjustIndentForNewList(element);
               element = li;
            }
            dom.insertAfter(list, element);
            list.appendChild(element);
            attemptMergeWithAdjacent(list, true);
            applied.push(element);
         }

         function doWrapList(start, end, template) {
            var li, n = start, tmp, i;
            while (!dom.isBlock(start.parentNode) && start.parentNode !== dom.getRoot()) {
               start = dom.split(start.parentNode, start.previousSibling);
               start = start.nextSibling;
               n = start;
            }
            if (template) {
               li = template.cloneNode(true);
               start.parentNode.insertBefore(li, start);
               while (li.firstChild) dom.remove(li.firstChild);
               li = dom.rename(li, 'li');
            } else {
               li = dom.create('li');
               start.parentNode.insertBefore(li, start);
            }
            while (n && n != end) {
               tmp = n.nextSibling;
               li.appendChild(n);
               n = tmp;
            }
            if (li.childNodes.length === 0) {
               li.innerHTML = '<br _mce_bogus="1" />';
            }
            makeList(li);
         }

         function processBrs(element, callback) {
            var startSection, previousBR, END_TO_START = 3, START_TO_END = 1,
                  breakElements = 'br,ul,ol,p,div,h1,h2,h3,h4,h5,h6,table,blockquote,address,pre,form,center,dl';

            function isAnyPartSelected(start, end) {
               var r = dom.createRng(), sel;
               bookmark.keep = true;
               ed.selection.moveToBookmark(bookmark);
               bookmark.keep = false;
               sel = ed.selection.getRng(true);
               if (!end) {
                  end = start.parentNode.lastChild;
               }
               r.setStartBefore(start);
               r.setEndAfter(end);
               return !(r.compareBoundaryPoints(END_TO_START, sel) > 0 || r.compareBoundaryPoints(START_TO_END, sel) <= 0);
            }

            function nextLeaf(br) {
               if (br.nextSibling)
                  return br.nextSibling;
               if (!dom.isBlock(br.parentNode) && br.parentNode !== dom.getRoot())
                  return nextLeaf(br.parentNode);
            }

            // Split on BRs within the range and process those.
            startSection = element.firstChild;
            // First mark the BRs that have any part of the previous section selected.
            var trailingContentSelected = false;
            each(dom.select(breakElements, element), function(br) {
               var b;
               if (br.hasAttribute && br.hasAttribute('_mce_bogus')) {
                  return true; // Skip the bogus Brs that are put in to appease Firefox and Safari.
               }
               if (isAnyPartSelected(startSection, br)) {
                  dom.addClass(br, '_mce_tagged_br');
                  startSection = nextLeaf(br);
               }
            });
            trailingContentSelected = (startSection && isAnyPartSelected(startSection, undefined));
            startSection = element.firstChild;
            each(dom.select(breakElements, element), function(br) {
               // Got a section from start to br.
               var tmp = nextLeaf(br);
               if (br.hasAttribute && br.hasAttribute('_mce_bogus')) {
                  return true; // Skip the bogus Brs that are put in to appease Firefox and Safari.
               }
               if (dom.hasClass(br, '_mce_tagged_br')) {
                  callback(startSection, br, previousBR);
                  previousBR = null;
               } else {
                  previousBR = br;
               }
               startSection = tmp;
            });
            if (trailingContentSelected) {
               callback(startSection, undefined, previousBR);
            }
         }

         function wrapList(element) {
            processBrs(element, function(startSection, br, previousBR) {
               // Need to indent this part
               doWrapList(startSection, br);
               cleanupBr(br);
               cleanupBr(previousBR);
            });
         }

         function changeList(element) {
            if (tinymce.inArray(applied, element) !== -1) {
               return;
            }
            if (element.parentNode.tagName === oppositeListType) {
               dom.split(element.parentNode, element);
               makeList(element);
               attemptMergeWithNext(element.parentNode, false);
            }
            applied.push(element);
         }

         function convertListItemToParagraph(element) {
            var child, nextChild, mergedElement, splitLast;
            if (tinymce.inArray(applied, element) !== -1) {
               return;
            }
            element = splitNestedLists(element, dom);
            while (dom.is(element.parentNode, 'ol,ul,li')) {
               dom.split(element.parentNode, element);
            }
            // Push the original element we have from the selection, not the renamed one.
            applied.push(element);
            element = dom.rename(element, 'p');
            mergedElement = attemptMergeWithAdjacent(element, false, ed.settings.force_br_newlines);
            if (mergedElement === element) {
               // Now split out any block elements that can't be contained within a P.
               // Manually iterate to ensure we handle modifications correctly (doesn't work with tinymce.each)
               child = element.firstChild;
               while (child) {
                  if (dom.isBlock(child)) {
                     child = dom.split(child.parentNode, child);
                     splitLast = true;
                     nextChild = child.nextSibling && child.nextSibling.firstChild;
                  } else {
                     nextChild = child.nextSibling;
                     if (splitLast && child.tagName === 'BR') {
                        dom.remove(child);
                     }
                     splitLast = false;
                  }
                  child = nextChild;
               }
            }
         }

         each(selectedBlocks, function(e) {
            e = findItemToOperateOn(e, dom);
            if (e.tagName === oppositeListType || (e.tagName === 'LI' && e.parentNode.tagName === oppositeListType)) {
               hasOppositeType = true;
            } else if (e.tagName === targetListType || (e.tagName === 'LI' && e.parentNode.tagName === targetListType)) {
               hasSameType = true;
            } else {
               hasNonList = true;
            }
         });

         if (hasNonList || hasOppositeType || selectedBlocks.length === 0) {
            actions = {
               'LI': changeList,
               'H1': makeList,
               'H2': makeList,
               'H3': makeList,
               'H4': makeList,
               'H5': makeList,
               'H6': makeList,
               'P': makeList,
               'BODY': makeList,
               'DIV': selectedBlocks.length > 1 ? makeList : wrapList,
               defaultAction: wrapList
            };
         } else {
            actions = {
               defaultAction: convertListItemToParagraph
            };
         }
         this.process(actions);
      },

      indent: function() {
         var ed = this.ed, dom = ed.dom, indented = [];

         function createWrapItem(element) {
            var wrapItem = dom.create('li', { style: 'list-style-type: none;'});
            dom.insertAfter(wrapItem, element);
            return wrapItem;
         }

         function createWrapList(element) {
            var wrapItem = createWrapItem(element),
                  list = dom.getParent(element, 'ol,ul'),
                  listType = list.tagName,
                  listStyle = dom.getStyle(list, 'list-style-type'),
                  attrs = {},
                  wrapList;
            if (listStyle !== '') {
               attrs.style = 'list-style-type: ' + listStyle + ';';
            }
            wrapList = dom.create(listType, attrs);
            wrapItem.appendChild(wrapList);
            return wrapList;
         }

         function indentLI(element) {
            if (!hasParentInList(ed, element, indented)) {
               element = splitNestedLists(element, dom);
               var wrapList = createWrapList(element);
               wrapList.appendChild(element);
               attemptMergeWithAdjacent(wrapList.parentNode, false);
               attemptMergeWithAdjacent(wrapList, false);
               indented.push(element);
            }
         }

         this.process({
            'LI': indentLI,
            defaultAction: this.adjustPaddingFunction(true)
         });

      },

      outdent: function() {
         var t = this, ed = t.ed, dom = ed.dom, outdented = [];

         function outdentLI(element) {
            var listElement, targetParent, align;
            if (!hasParentInList(ed, element, outdented)) {
               if (dom.getStyle(element, 'margin-left') !== '' || dom.getStyle(element, 'padding-left') !== '') {
                  return t.adjustPaddingFunction(false)(element);
               }
               align = dom.getStyle(element, 'text-align', true);
               if (align === 'center' || align === 'right') {
                  dom.setStyle(element, 'text-align', 'left');
                  return;
               }
               element = splitNestedLists(element, dom);
               listElement = element.parentNode;
               targetParent = element.parentNode.parentNode;
               if (targetParent.tagName === 'P') {
                  dom.split(targetParent, element.parentNode);
               } else {
                  dom.split(listElement, element);
                  if (targetParent.tagName === 'LI') {
                     // Nested list, need to split the LI and go back out to the OL/UL element.
                     dom.split(targetParent, element);
                  } else if (!dom.is(targetParent, 'ol,ul')) {
                     dom.rename(element, 'p');
                  }
               }
               outdented.push(element);
            }
         }

         this.process({
            'LI': outdentLI,
            defaultAction: this.adjustPaddingFunction(false)
         });

         each(outdented, attemptMergeWithAdjacent);
      },

      process: function(actions) {
         var t = this, sel = t.ed.selection, dom = t.ed.dom, selectedBlocks, r;

         function processElement(element) {
            dom.removeClass(element, '_mce_act_on');
            if (!element || element.nodeType !== 1) {
               return;
            }
            element = findItemToOperateOn(element, dom);
            var action = actions[element.tagName];
            if (!action) {
               action = actions.defaultAction;
            }
            action(element);
         }

         function recurse(element) {
            t.splitSafeEach(element.childNodes, processElement);
         }

         function brAtEdgeOfSelection(container, offset) {
            return offset >= 0 && container.hasChildNodes() && offset < container.childNodes.length &&
                  container.childNodes[offset].tagName === 'BR';
         }

         selectedBlocks = sel.getSelectedBlocks();
         if (selectedBlocks.length === 0) {
            selectedBlocks = [ dom.getRoot() ];
         }

         r = sel.getRng(true);
         if (!r.collapsed) {
            if (brAtEdgeOfSelection(r.endContainer, r.endOffset - 1)) {
               r.setEnd(r.endContainer, r.endOffset - 1);
               sel.setRng(r);
            }
            if (brAtEdgeOfSelection(r.startContainer, r.startOffset)) {
               r.setStart(r.startContainer, r.startOffset + 1);
               sel.setRng(r);
            }
         }


         if (tinymce.isIE8) {
            // append a zero sized nbsp so that caret is restored correctly using bookmark
            var s = t.ed.selection.getNode();
            if (s.tagName === 'LI' && !(s.parentNode.lastChild === s)) {
               var i = t.ed.getDoc().createTextNode('\uFEFF');
               s.appendChild(i);
            }
         }

         bookmark = sel.getBookmark();
         actions.OL = actions.UL = recurse;
         t.splitSafeEach(selectedBlocks, processElement);
         sel.moveToBookmark(bookmark);
         bookmark = null;
         // Avoids table or image handles being left behind in Firefox.
         t.ed.execCommand('mceRepaint');
      },

      splitSafeEach: function(elements, f) {
         if (tinymce.isGecko && (/Firefox\/[12]\.[0-9]/.test(navigator.userAgent) ||
               /Firefox\/3\.[0-4]/.test(navigator.userAgent))) {
            this.classBasedEach(elements, f);
         } else {
            each(elements, f);
         }
      },

      classBasedEach: function(elements, f) {
         var dom = this.ed.dom, nodes, element;
         // Mark nodes
         each(elements, function(element) {
            dom.addClass(element, '_mce_act_on');
         });
         nodes = dom.select('._mce_act_on');
         while (nodes.length > 0) {
            element = nodes.shift();
            dom.removeClass(element, '_mce_act_on');
            f(element);
            nodes = dom.select('._mce_act_on');
         }
      },

      adjustPaddingFunction: function(isIndent) {
         var indentAmount, indentUnits, ed = this.ed;
         indentAmount = ed.settings.indentation;
         indentUnits = /[a-z%]+/i.exec(indentAmount);
         indentAmount = parseInt(indentAmount, 10);
         return function(element) {
            var currentIndent, newIndentAmount;
            currentIndent = parseInt(ed.dom.getStyle(element, 'margin-left') || 0, 10) + parseInt(ed.dom.getStyle(element, 'padding-left') || 0, 10);
            if (isIndent) {
               newIndentAmount = currentIndent + indentAmount;
            } else {
               newIndentAmount = currentIndent - indentAmount;
            }
            ed.dom.setStyle(element, 'padding-left', '');
            ed.dom.setStyle(element, 'margin-left', newIndentAmount > 0 ? newIndentAmount + indentUnits : '');
         };
      },

      getInfo: function() {
         return {
            longname : 'Lists',
            author : 'Moxiecode Systems AB',
            authorurl : 'http://tinymce.moxiecode.com',
            infourl : 'http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/lists',
            version : tinymce.majorVersion + "." + tinymce.minorVersion
         };
      }
   });
   tinymce.PluginManager.add("lists", tinymce.plugins.Lists);
}());
/**

 * editor_plugin_src.js

 *

 * Copyright 2011, Moxiecode Systems AB

 * Released under LGPL License.

 *

 * License: http://tinymce.moxiecode.com/license

 * Contributing: http://tinymce.moxiecode.com/contributing

 */



(function() {

   var each = tinymce.each, Event = tinymce.dom.Event, bookmark;



   // Skips text nodes that only contain whitespace since they aren't semantically important.

   function skipWhitespaceNodes(e, next) {

      while (e && (e.nodeType === 8 || (e.nodeType === 3 && /^[ \t\n\r]*$/.test(e.nodeValue)))) {

         e = next(e);

      }

      return e;

   }



   function skipWhitespaceNodesBackwards(e) {

      return skipWhitespaceNodes(e, function(e) {

         return e.previousSibling;

      });

   }



   function skipWhitespaceNodesForwards(e) {

      return skipWhitespaceNodes(e, function(e) {

         return e.nextSibling;

      });

   }



   function hasParentInList(ed, e, list) {

      return ed.dom.getParent(e, function(p) {

         return tinymce.inArray(list, p) !== -1;

      });

   }



   function isList(e) {

      return e && (e.tagName === 'OL' || e.tagName === 'UL');

   }



   function splitNestedLists(element, dom) {

      var tmp, nested, wrapItem;

      tmp = skipWhitespaceNodesBackwards(element.lastChild);

      while (isList(tmp)) {

         nested = tmp;

         tmp = skipWhitespaceNodesBackwards(nested.previousSibling);

      }

      if (nested) {

         wrapItem = dom.create('li', { style: 'list-style-type: none;'});

         dom.split(element, nested);

         dom.insertAfter(wrapItem, nested);

         wrapItem.appendChild(nested);

         wrapItem.appendChild(nested);

         element = wrapItem.previousSibling;

      }

      return element;

   }



   function attemptMergeWithAdjacent(e, allowDifferentListStyles, mergeParagraphs) {

      e = attemptMergeWithPrevious(e, allowDifferentListStyles, mergeParagraphs);

      return attemptMergeWithNext(e, allowDifferentListStyles, mergeParagraphs);

   }



   function attemptMergeWithPrevious(e, allowDifferentListStyles, mergeParagraphs) {

      var prev = skipWhitespaceNodesBackwards(e.previousSibling);

      if (prev) {

         return attemptMerge(prev, e, allowDifferentListStyles ? prev : false, mergeParagraphs);

      } else {

         return e;

      }

   }



   function attemptMergeWithNext(e, allowDifferentListStyles, mergeParagraphs) {

      var next = skipWhitespaceNodesForwards(e.nextSibling);

      if (next) {

         return attemptMerge(e, next, allowDifferentListStyles ? next : false, mergeParagraphs);

      } else {

         return e;

      }

   }



   function attemptMerge(e1, e2, differentStylesMasterElement, mergeParagraphs) {

      if (canMerge(e1, e2, !!differentStylesMasterElement, mergeParagraphs)) {

         return merge(e1, e2, differentStylesMasterElement);

      } else if (e1 && e1.tagName === 'LI' && isList(e2)) {

         // Fix invalidly nested lists.

         e1.appendChild(e2);

      }

      return e2;

   }



   function canMerge(e1, e2, allowDifferentListStyles, mergeParagraphs) {

      if (!e1 || !e2) {

         return false;

      } else if (e1.tagName === 'LI' && e2.tagName === 'LI') {

         return e2.style.listStyleType === 'none' || containsOnlyAList(e2);

      } else if (isList(e1)) {

         return (e1.tagName === e2.tagName && (allowDifferentListStyles || e1.style.listStyleType === e2.style.listStyleType)) || isListForIndent(e2);

      } else return mergeParagraphs && e1.tagName === 'P' && e2.tagName === 'P';

   }



   function isListForIndent(e) {

      var firstLI = skipWhitespaceNodesForwards(e.firstChild), lastLI = skipWhitespaceNodesBackwards(e.lastChild);

      return firstLI && lastLI && isList(e) && firstLI === lastLI && (isList(firstLI) || firstLI.style.listStyleType === 'none' || containsOnlyAList(firstLI));

   }



   function containsOnlyAList(e) {

      var firstChild = skipWhitespaceNodesForwards(e.firstChild), lastChild = skipWhitespaceNodesBackwards(e.lastChild);

      return firstChild && lastChild && firstChild === lastChild && isList(firstChild);

   }



   function merge(e1, e2, masterElement) {

      var lastOriginal = skipWhitespaceNodesBackwards(e1.lastChild), firstNew = skipWhitespaceNodesForwards(e2.firstChild);

      if (e1.tagName === 'P') {

         e1.appendChild(e1.ownerDocument.createElement('br'));

      }

      while (e2.firstChild) {

         e1.appendChild(e2.firstChild);

      }

      if (masterElement) {

         e1.style.listStyleType = masterElement.style.listStyleType;

      }

      e2.parentNode.removeChild(e2);

      attemptMerge(lastOriginal, firstNew, false);

      return e1;

   }



   function findItemToOperateOn(e, dom) {

      var item;

      if (!dom.is(e, 'li,ol,ul')) {

         item = dom.getParent(e, 'li');

         if (item) {

            e = item;

         }

      }

      return e;

   }



   tinymce.create('tinymce.plugins.Lists', {

      init: function(ed) {

         var LIST_TABBING = 'TABBING';

         var LIST_EMPTY_ITEM = 'EMPTY';

         var LIST_ESCAPE = 'ESCAPE';

         var LIST_PARAGRAPH = 'PARAGRAPH';

         var LIST_UNKNOWN = 'UNKNOWN';

         var state = LIST_UNKNOWN;



         function isTabInList(e) {

            // Don't indent on Ctrl+Tab or Alt+Tab

            return e.keyCode === tinymce.VK.TAB && !(e.altKey || e.ctrlKey) &&

               (ed.queryCommandState('InsertUnorderedList') || ed.queryCommandState('InsertOrderedList'));

         }



         function isOnLastListItem() {

            var li = getLi();

            var grandParent = li.parentNode.parentNode;

            var isLastItem = li.parentNode.lastChild === li;

            return isLastItem && !isNestedList(grandParent) && isEmptyListItem(li);

         }



         function isNestedList(grandParent) {

            if (isList(grandParent)) {

               return grandParent.parentNode && grandParent.parentNode.tagName === 'LI';

            } else {

               return  grandParent.tagName === 'LI';

            }

         }



         function isInEmptyListItem() {

            return ed.selection.isCollapsed() && isEmptyListItem(getLi());

         }



         function getLi() {

            var n = ed.selection.getStart();

            // Get start will return BR if the LI only contains a BR or an empty element as we use these to fix caret position

            return ((n.tagName == 'BR' || n.tagName == '') && n.parentNode.tagName == 'LI') ? n.parentNode : n;

         }



         function isEmptyListItem(li) {

            var numChildren = li.childNodes.length;

            if (li.tagName === 'LI') {

               return numChildren == 0 ? true : numChildren == 1 && (li.firstChild.tagName == '' || li.firstChild.tagName == 'BR' || isEmptyIE9Li(li));

            }

            return false;

         }



         function isEmptyIE9Li(li) {

            // only consider this to be last item if there is no list item content or that content is nbsp or space since IE9 creates these

            var lis = tinymce.grep(li.parentNode.childNodes, function(n) {return n.tagName == 'LI'});

            var isLastLi = li == lis[lis.length - 1];

            var child = li.firstChild;

            return tinymce.isIE9 && isLastLi && (child.nodeValue == String.fromCharCode(160) || child.nodeValue == String.fromCharCode(32));

         }



         function isEnter(e) {

            return e.keyCode === tinymce.VK.ENTER;

         }



         function isEnterWithoutShift(e) {

            return isEnter(e) && !e.shiftKey;

         }



         function getListKeyState(e) {

            if (isTabInList(e)) {

               return LIST_TABBING;

            } else if (isEnterWithoutShift(e) && isOnLastListItem()) {

               // Returns LIST_UNKNOWN since breaking out of lists is handled by the EnterKey.js logic now

               //return LIST_ESCAPE;

               return LIST_UNKNOWN;

            } else if (isEnterWithoutShift(e) && isInEmptyListItem()) {

               return LIST_EMPTY_ITEM;

            } else {

               return LIST_UNKNOWN;

            }

         }



         function cancelDefaultEvents(ed, e) {

            // list escape is done manually using outdent as it does not create paragraphs correctly in td's

            if (state == LIST_TABBING || state == LIST_EMPTY_ITEM || tinymce.isGecko && state == LIST_ESCAPE) {

               Event.cancel(e);

            }

         }



         function isCursorAtEndOfContainer() {

            var range = ed.selection.getRng(true);

            var startContainer = range.startContainer;

            if (startContainer.nodeType == 3) {

               var value = startContainer.nodeValue;

               if (tinymce.isIE9 && value.length > 1 && value.charCodeAt(value.length-1) == 32) {

                  // IE9 places a space on the end of the text in some cases so ignore last char

                  return (range.endOffset == value.length-1);

               } else {

                  return (range.endOffset == value.length);

               }

            } else if (startContainer.nodeType == 1) {

               return range.endOffset == startContainer.childNodes.length;

            }

            return false;

         }



         /*

             If we are at the end of a list item surrounded with an element, pressing enter should create a

             new list item instead without splitting the element e.g. don't want to create new P or H1 tag

           */

         function isEndOfListItem() {

            var node = ed.selection.getNode();

            var validElements = 'h1,h2,h3,h4,h5,h6,p,div';

            var isLastParagraphOfLi = ed.dom.is(node, validElements) && node.parentNode.tagName === 'LI' && node.parentNode.lastChild === node;

            return ed.selection.isCollapsed() && isLastParagraphOfLi && isCursorAtEndOfContainer();

         }



         // Creates a new list item after the current selection's list item parent

         function createNewLi(ed, e) {

            if (isEnterWithoutShift(e) && isEndOfListItem()) {

               var node = ed.selection.getNode();

               var li = ed.dom.create("li");

               var parentLi = ed.dom.getParent(node, 'li');

               ed.dom.insertAfter(li, parentLi);



               // Move caret to new list element.

               if (tinymce.isIE6 || tinymce.isIE7 || tinyMCE.isIE8) {

                  // Removed this line since it would create an odd <&nbsp;> tag and placing the caret inside an empty LI is handled and should be handled by the selection logic

                  //li.appendChild(ed.dom.create("&nbsp;")); // IE needs an element within the bullet point

                  ed.selection.setCursorLocation(li, 1);

               } else {

                  ed.selection.setCursorLocation(li, 0);

               }

               e.preventDefault();

            }

         }



         function imageJoiningListItem(ed, e) {

            var prevSibling;



            if (!tinymce.isGecko)

               return;



            var n = ed.selection.getStart();

            if (e.keyCode != tinymce.VK.BACKSPACE || n.tagName !== 'IMG')

               return;



            function lastLI(node) {

               var child = node.firstChild;

               var li = null;

               do {

                  if (!child)

                     break;



                  if (child.tagName === 'LI')

                     li = child;

               } while (child = child.nextSibling);



               return li;

            }



            function addChildren(parentNode, destination) {

               while (parentNode.childNodes.length > 0)

                  destination.appendChild(parentNode.childNodes[0]);

            }



            // Check if there is a previous sibling

            prevSibling = n.parentNode.previousSibling;

            if (!prevSibling)

               return;



            var ul;

            if (prevSibling.tagName === 'UL' || prevSibling.tagName === 'OL')

               ul = prevSibling;

            else if (prevSibling.previousSibling && (prevSibling.previousSibling.tagName === 'UL' || prevSibling.previousSibling.tagName === 'OL'))

               ul = prevSibling.previousSibling;

            else

               return;



            var li = lastLI(ul);



            // move the caret to the end of the list item

            var rng = ed.dom.createRng();

            rng.setStart(li, 1);

            rng.setEnd(li, 1);

            ed.selection.setRng(rng);

            ed.selection.collapse(true);



            // save a bookmark at the end of the list item

            var bookmark = ed.selection.getBookmark();



            // copy the image an its text to the list item

            var clone = n.parentNode.cloneNode(true);

            if (clone.tagName === 'P' || clone.tagName === 'DIV')

               addChildren(clone, li);

            else

               li.appendChild(clone);



            // remove the old copy of the image

            n.parentNode.parentNode.removeChild(n.parentNode);



            // move the caret where we saved the bookmark

            ed.selection.moveToBookmark(bookmark);

         }



         // fix the cursor position to ensure it is correct in IE

         function setCursorPositionToOriginalLi(li) {

            var list = ed.dom.getParent(li, 'ol,ul');

            if (list != null) {

               var lastLi = list.lastChild;

               // Removed this line since IE9 would report an DOM character error and placing the caret inside an empty LI is handled and should be handled by the selection logic

               //lastLi.appendChild(ed.getDoc().createElement(''));

               ed.selection.setCursorLocation(lastLi, 0);

            }

         }



         this.ed = ed;

         ed.addCommand('Indent', this.indent, this);

         ed.addCommand('Outdent', this.outdent, this);

         ed.addCommand('InsertUnorderedList', function() {

            this.applyList('UL', 'OL');

         }, this);

         ed.addCommand('InsertOrderedList', function() {

            this.applyList('OL', 'UL');

         }, this);



         ed.onInit.add(function() {

            ed.editorCommands.addCommands({

               'outdent': function() {

                  var sel = ed.selection, dom = ed.dom;



                  function hasStyleIndent(n) {

                     n = dom.getParent(n, dom.isBlock);

                     return n && (parseInt(ed.dom.getStyle(n, 'margin-left') || 0, 10) + parseInt(ed.dom.getStyle(n, 'padding-left') || 0, 10)) > 0;

                  }



                  return hasStyleIndent(sel.getStart()) || hasStyleIndent(sel.getEnd()) || ed.queryCommandState('InsertOrderedList') || ed.queryCommandState('InsertUnorderedList');

               }

            }, 'state');

         });



         ed.onKeyUp.add(function(ed, e) {

            if (state == LIST_TABBING) {

               ed.execCommand(e.shiftKey ? 'Outdent' : 'Indent', true, null);

               state = LIST_UNKNOWN;

               return Event.cancel(e);

            } else if (state == LIST_EMPTY_ITEM) {

               var li = getLi();

               var shouldOutdent =  ed.settings.list_outdent_on_enter === true || e.shiftKey;

               ed.execCommand(shouldOutdent ? 'Outdent' : 'Indent', true, null);

               if (tinymce.isIE) {

                  setCursorPositionToOriginalLi(li);

               }



               return Event.cancel(e);

            } else if (state == LIST_ESCAPE) {

               if (tinymce.isIE6 || tinymce.isIE7 || tinymce.isIE8) {

                  // append a zero sized nbsp so that caret is positioned correctly in IE after escaping and applying formatting.

                  // if there is no text then applying formatting for e.g a H1 to the P tag immediately following list after

                  // escaping from it will cause the caret to be positioned on the last li instead of staying the in P tag.

                  var n = ed.getDoc().createTextNode('\uFEFF');

                  ed.selection.getNode().appendChild(n);

               } else if (tinymce.isIE9 || tinymce.isGecko) {

                  // IE9 does not escape the list so we use outdent to do this and cancel the default behaviour

                  // Gecko does not create a paragraph outdenting inside a TD so default behaviour is cancelled and we outdent ourselves

                  ed.execCommand('Outdent');

                  return Event.cancel(e);

               }

            }

         });



         function fixListItem(parent, reference) {

            // a zero-sized non-breaking space is placed in the empty list item so that the nested list is

            // displayed on the below line instead of next to it

            var n = ed.getDoc().createTextNode('\uFEFF');

            parent.insertBefore(n, reference);

            ed.selection.setCursorLocation(n, 0);

            // repaint to remove rendering artifact. only visible when creating new list

            ed.execCommand('mceRepaint');

         }



         function fixIndentedListItemForGecko(ed, e) {

            if (isEnter(e)) {

               var li = getLi();

               if (li) {

                  var parent = li.parentNode;

                  var grandParent = parent && parent.parentNode;

                  if (grandParent && grandParent.nodeName == 'LI' && grandParent.firstChild == parent && li == parent.firstChild) {

                     fixListItem(grandParent, parent);

                  }

               }

            }

         }



         function fixIndentedListItemForIE8(ed, e) {

            if (isEnter(e)) {

               var li = getLi();

               if (ed.dom.select('ul li', li).length === 1) {

                  var list = li.firstChild;

                  fixListItem(li, list);

               }

            }

         }



         function fixDeletingFirstCharOfList(ed, e) {

            function listElements(list, li) {

               var elements = [];

               var walker = new tinymce.dom.TreeWalker(li, list);

               for (var node = walker.current(); node; node = walker.next()) {

                  if (ed.dom.is(node, 'ol,ul,li')) {

                     elements.push(node);

                  }

               }

               return elements;

            }



            if (e.keyCode == tinymce.VK.BACKSPACE) {

               var li = getLi();

               if (li) {

                  var list = ed.dom.getParent(li, 'ol,ul');

                  if (list && list.firstChild === li) {

                     var elements = listElements(list, li);

                     ed.execCommand("Outdent", false, elements);

                     ed.undoManager.add();

                     return Event.cancel(e);

                  }

               }

            }

         }



         function fixDeletingEmptyLiInWebkit(ed, e) {

            var li = getLi();

            if (e.keyCode === tinymce.VK.BACKSPACE && ed.dom.is(li, 'li') && li.parentNode.firstChild!==li) {

               if (ed.dom.select('ul,ol', li).length === 1) {

                  var prevLi = li.previousSibling;

                  ed.dom.remove(ed.dom.select('br', li));

                  ed.dom.remove(li, true);

                  var textNodes = tinymce.grep(prevLi.childNodes, function(n){ return n.nodeType === 3 });

                  if (textNodes.length === 1) {

                     var textNode = textNodes[0]

                     ed.selection.setCursorLocation(textNode, textNode.length);

                  }

                  ed.undoManager.add();

                  return Event.cancel(e);

               }

            }

         }



         ed.onKeyDown.add(function(_, e) { state = getListKeyState(e); });

         ed.onKeyDown.add(cancelDefaultEvents);

         ed.onKeyDown.add(imageJoiningListItem);

         ed.onKeyDown.add(createNewLi);



         if (tinymce.isGecko) {

            ed.onKeyUp.add(fixIndentedListItemForGecko);

         }

         if (tinymce.isIE8) {

            ed.onKeyUp.add(fixIndentedListItemForIE8);

         }

         if (tinymce.isGecko || tinymce.isWebKit) {

            ed.onKeyDown.add(fixDeletingFirstCharOfList);

         }

         if (tinymce.isWebKit) {

            ed.onKeyDown.add(fixDeletingEmptyLiInWebkit);

         }

      },



      applyList: function(targetListType, oppositeListType) {

         var t = this, ed = t.ed, dom = ed.dom, applied = [], hasSameType = false, hasOppositeType = false, hasNonList = false, actions,

               selectedBlocks = ed.selection.getSelectedBlocks();



         function cleanupBr(e) {

            if (e && e.tagName === 'BR') {

               dom.remove(e);

            }

         }



         function makeList(element) {

            var list = dom.create(targetListType), li;



            function adjustIndentForNewList(element) {

               // If there's a margin-left, outdent one level to account for the extra list margin.

               if (element.style.marginLeft || element.style.paddingLeft) {

                  t.adjustPaddingFunction(false)(element);

               }

            }



            if (element.tagName === 'LI') {

               // No change required.

            } else if (element.tagName === 'P' || element.tagName === 'DIV' || element.tagName === 'BODY') {

               processBrs(element, function(startSection, br) {

                  doWrapList(startSection, br, element.tagName === 'BODY' ? null : startSection.parentNode);

                  li = startSection.parentNode;

                  adjustIndentForNewList(li);

                  cleanupBr(br);

               });

               if (li) {

                  if (li.tagName === 'LI' && (element.tagName === 'P' || selectedBlocks.length > 1)) {

                     dom.split(li.parentNode.parentNode, li.parentNode);

                  }

                  attemptMergeWithAdjacent(li.parentNode, true);

               }

               return;

            } else {

               // Put the list around the element.

               li = dom.create('li');

               dom.insertAfter(li, element);

               li.appendChild(element);

               adjustIndentForNewList(element);

               element = li;

            }

            dom.insertAfter(list, element);

            list.appendChild(element);

            attemptMergeWithAdjacent(list, true);

            applied.push(element);

         }



         function doWrapList(start, end, template) {

            var li, n = start, tmp;

            while (!dom.isBlock(start.parentNode) && start.parentNode !== dom.getRoot()) {

               start = dom.split(start.parentNode, start.previousSibling);

               start = start.nextSibling;

               n = start;

            }

            if (template) {

               li = template.cloneNode(true);

               start.parentNode.insertBefore(li, start);

               while (li.firstChild) dom.remove(li.firstChild);

               li = dom.rename(li, 'li');

            } else {

               li = dom.create('li');

               start.parentNode.insertBefore(li, start);

            }

            while (n && n != end) {

               tmp = n.nextSibling;

               li.appendChild(n);

               n = tmp;

            }

            if (li.childNodes.length === 0) {

               li.innerHTML = '<br _mce_bogus="1" />';

            }

            makeList(li);

         }



         function processBrs(element, callback) {

            var startSection, previousBR, END_TO_START = 3, START_TO_END = 1,

                  breakElements = 'br,ul,ol,p,div,h1,h2,h3,h4,h5,h6,table,blockquote,address,pre,form,center,dl';



            function isAnyPartSelected(start, end) {

               var r = dom.createRng(), sel;

               bookmark.keep = true;

               ed.selection.moveToBookmark(bookmark);

               bookmark.keep = false;

               sel = ed.selection.getRng(true);

               if (!end) {

                  end = start.parentNode.lastChild;

               }

               r.setStartBefore(start);

               r.setEndAfter(end);

               return !(r.compareBoundaryPoints(END_TO_START, sel) > 0 || r.compareBoundaryPoints(START_TO_END, sel) <= 0);

            }



            function nextLeaf(br) {

               if (br.nextSibling)

                  return br.nextSibling;

               if (!dom.isBlock(br.parentNode) && br.parentNode !== dom.getRoot())

                  return nextLeaf(br.parentNode);

            }



            // Split on BRs within the range and process those.

            startSection = element.firstChild;

            // First mark the BRs that have any part of the previous section selected.

            var trailingContentSelected = false;

            each(dom.select(breakElements, element), function(br) {

               if (br.hasAttribute && br.hasAttribute('_mce_bogus')) {

                  return true; // Skip the bogus Brs that are put in to appease Firefox and Safari.

               }

               if (isAnyPartSelected(startSection, br)) {

                  dom.addClass(br, '_mce_tagged_br');

                  startSection = nextLeaf(br);

               }

            });

            trailingContentSelected = (startSection && isAnyPartSelected(startSection, undefined));

            startSection = element.firstChild;

            each(dom.select(breakElements, element), function(br) {

               // Got a section from start to br.

               var tmp = nextLeaf(br);

               if (br.hasAttribute && br.hasAttribute('_mce_bogus')) {

                  return true; // Skip the bogus Brs that are put in to appease Firefox and Safari.

               }

               if (dom.hasClass(br, '_mce_tagged_br')) {

                  callback(startSection, br, previousBR);

                  previousBR = null;

               } else {

                  previousBR = br;

               }

               startSection = tmp;

            });

            if (trailingContentSelected) {

               callback(startSection, undefined, previousBR);

            }

         }



         function wrapList(element) {

            processBrs(element, function(startSection, br, previousBR) {

               // Need to indent this part

               doWrapList(startSection, br);

               cleanupBr(br);

               cleanupBr(previousBR);

            });

         }



         function changeList(element) {

            if (tinymce.inArray(applied, element) !== -1) {

               return;

            }

            if (element.parentNode.tagName === oppositeListType) {

               dom.split(element.parentNode, element);

               makeList(element);

               attemptMergeWithNext(element.parentNode, false);

            }

            applied.push(element);

         }



         function convertListItemToParagraph(element) {

            var child, nextChild, mergedElement, splitLast;

            if (tinymce.inArray(applied, element) !== -1) {

               return;

            }

            element = splitNestedLists(element, dom);

            while (dom.is(element.parentNode, 'ol,ul,li')) {

               dom.split(element.parentNode, element);

            }

            // Push the original element we have from the selection, not the renamed one.

            applied.push(element);

            element = dom.rename(element, 'p');

            mergedElement = attemptMergeWithAdjacent(element, false, ed.settings.force_br_newlines);

            if (mergedElement === element) {

               // Now split out any block elements that can't be contained within a P.

               // Manually iterate to ensure we handle modifications correctly (doesn't work with tinymce.each)

               child = element.firstChild;

               while (child) {

                  if (dom.isBlock(child)) {

                     child = dom.split(child.parentNode, child);

                     splitLast = true;

                     nextChild = child.nextSibling && child.nextSibling.firstChild;

                  } else {

                     nextChild = child.nextSibling;

                     if (splitLast && child.tagName === 'BR') {

                        dom.remove(child);

                     }

                     splitLast = false;

                  }

                  child = nextChild;

               }

            }

         }



         each(selectedBlocks, function(e) {

            e = findItemToOperateOn(e, dom);

            if (e.tagName === oppositeListType || (e.tagName === 'LI' && e.parentNode.tagName === oppositeListType)) {

               hasOppositeType = true;

            } else if (e.tagName === targetListType || (e.tagName === 'LI' && e.parentNode.tagName === targetListType)) {

               hasSameType = true;

            } else {

               hasNonList = true;

            }

         });



         if (hasNonList &&!hasSameType || hasOppositeType || selectedBlocks.length === 0) {

            actions = {

               'LI': changeList,

               'H1': makeList,

               'H2': makeList,

               'H3': makeList,

               'H4': makeList,

               'H5': makeList,

               'H6': makeList,

               'P': makeList,

               'BODY': makeList,

               'DIV': selectedBlocks.length > 1 ? makeList : wrapList,

               defaultAction: wrapList,

               elements: this.selectedBlocks()

            };

         } else {

            actions = {

               defaultAction: convertListItemToParagraph,

               elements: this.selectedBlocks(),

               processEvenIfEmpty: true

            };

         }

         this.process(actions);

      },



      indent: function() {

         var ed = this.ed, dom = ed.dom, indented = [];



         function createWrapItem(element) {

            var wrapItem = dom.create('li', { style: 'list-style-type: none;'});

            dom.insertAfter(wrapItem, element);

            return wrapItem;

         }



         function createWrapList(element) {

            var wrapItem = createWrapItem(element),

                  list = dom.getParent(element, 'ol,ul'),

                  listType = list.tagName,

                  listStyle = dom.getStyle(list, 'list-style-type'),

                  attrs = {},

                  wrapList;

            if (listStyle !== '') {

               attrs.style = 'list-style-type: ' + listStyle + ';';

            }

            wrapList = dom.create(listType, attrs);

            wrapItem.appendChild(wrapList);

            return wrapList;

         }



         function indentLI(element) {

            if (!hasParentInList(ed, element, indented)) {

               element = splitNestedLists(element, dom);

               var wrapList = createWrapList(element);

               wrapList.appendChild(element);

               attemptMergeWithAdjacent(wrapList.parentNode, false);

               attemptMergeWithAdjacent(wrapList, false);

               indented.push(element);

            }

         }



         this.process({

            'LI': indentLI,

            defaultAction: this.adjustPaddingFunction(true),

            elements: this.selectedBlocks()

         });



      },



      outdent: function(ui, elements) {

         var t = this, ed = t.ed, dom = ed.dom, outdented = [];



         function outdentLI(element) {

            var listElement, targetParent, align;

            if (!hasParentInList(ed, element, outdented)) {

               if (dom.getStyle(element, 'margin-left') !== '' || dom.getStyle(element, 'padding-left') !== '') {

                  return t.adjustPaddingFunction(false)(element);

               }

               align = dom.getStyle(element, 'text-align', true);

               if (align === 'center' || align === 'right') {

                  dom.setStyle(element, 'text-align', 'left');

                  return;

               }

               element = splitNestedLists(element, dom);

               listElement = element.parentNode;

               targetParent = element.parentNode.parentNode;

               if (targetParent.tagName === 'P') {

                  dom.split(targetParent, element.parentNode);

               } else {

                  dom.split(listElement, element);

                  if (targetParent.tagName === 'LI') {

                     // Nested list, need to split the LI and go back out to the OL/UL element.

                     dom.split(targetParent, element);

                  } else if (!dom.is(targetParent, 'ol,ul')) {

                     dom.rename(element, 'p');

                  }

               }

               outdented.push(element);

            }

         }



         var listElements = elements && tinymce.is(elements, 'array') ? elements : this.selectedBlocks();

         this.process({

            'LI': outdentLI,

            defaultAction: this.adjustPaddingFunction(false),

            elements: listElements

         });



         each(outdented, attemptMergeWithAdjacent);

      },



      process: function(actions) {

         var t = this, sel = t.ed.selection, dom = t.ed.dom, selectedBlocks, r;



         function isEmptyElement(element) {

            var excludeBrsAndBookmarks = tinymce.grep(element.childNodes, function(n) {

               return !(n.nodeName === 'BR' || n.nodeName === 'SPAN' && dom.getAttrib(n, 'data-mce-type') == 'bookmark'

                     || n.nodeType == 3 && (n.nodeValue == String.fromCharCode(160) || n.nodeValue == ''));

            });

            return excludeBrsAndBookmarks.length === 0;

         }



         function processElement(element) {

            dom.removeClass(element, '_mce_act_on');

            if (!element || element.nodeType !== 1 || ! actions.processEvenIfEmpty && selectedBlocks.length > 1 && isEmptyElement(element)) {

               return;

            }

            element = findItemToOperateOn(element, dom);

            var action = actions[element.tagName];

            if (!action) {

               action = actions.defaultAction;

            }

            action(element);

         }



         function recurse(element) {

            t.splitSafeEach(element.childNodes, processElement);

         }



         function brAtEdgeOfSelection(container, offset) {

            return offset >= 0 && container.hasChildNodes() && offset < container.childNodes.length &&

                  container.childNodes[offset].tagName === 'BR';

         }



         function isInTable() {

            var n = sel.getNode();

            var p = dom.getParent(n, 'td');

            return p !== null;

         }



         selectedBlocks = actions.elements;



         r = sel.getRng(true);

         if (!r.collapsed) {

            if (brAtEdgeOfSelection(r.endContainer, r.endOffset - 1)) {

               r.setEnd(r.endContainer, r.endOffset - 1);

               sel.setRng(r);

            }

            if (brAtEdgeOfSelection(r.startContainer, r.startOffset)) {

               r.setStart(r.startContainer, r.startOffset + 1);

               sel.setRng(r);

            }

         }





         if (tinymce.isIE8) {

            // append a zero sized nbsp so that caret is restored correctly using bookmark

            var s = t.ed.selection.getNode();

            if (s.tagName === 'LI' && !(s.parentNode.lastChild === s)) {

               var i = t.ed.getDoc().createTextNode('\uFEFF');

               s.appendChild(i);

            }

         }



         bookmark = sel.getBookmark();

         actions.OL = actions.UL = recurse;

         t.splitSafeEach(selectedBlocks, processElement);

         sel.moveToBookmark(bookmark);

         bookmark = null;



         // we avoid doing repaint in a table as this will move the caret out of the table in Firefox 3.6

         if (!isInTable()) {

            // Avoids table or image handles being left behind in Firefox.

            t.ed.execCommand('mceRepaint');

         }

      },



      splitSafeEach: function(elements, f) {

         if (tinymce.isGecko && (/Firefox\/[12]\.[0-9]/.test(navigator.userAgent) ||

               /Firefox\/3\.[0-4]/.test(navigator.userAgent))) {

            this.classBasedEach(elements, f);

         } else {

            each(elements, f);

         }

      },



      classBasedEach: function(elements, f) {

         var dom = this.ed.dom, nodes, element;

         // Mark nodes

         each(elements, function(element) {

            dom.addClass(element, '_mce_act_on');

         });

         nodes = dom.select('._mce_act_on');

         while (nodes.length > 0) {

            element = nodes.shift();

            dom.removeClass(element, '_mce_act_on');

            f(element);

            nodes = dom.select('._mce_act_on');

         }

      },



      adjustPaddingFunction: function(isIndent) {

         var indentAmount, indentUnits, ed = this.ed;

         indentAmount = ed.settings.indentation;

         indentUnits = /[a-z%]+/i.exec(indentAmount);

         indentAmount = parseInt(indentAmount, 10);

         return function(element) {

            var currentIndent, newIndentAmount;

            currentIndent = parseInt(ed.dom.getStyle(element, 'margin-left') || 0, 10) + parseInt(ed.dom.getStyle(element, 'padding-left') || 0, 10);

            if (isIndent) {

               newIndentAmount = currentIndent + indentAmount;

            } else {

               newIndentAmount = currentIndent - indentAmount;

            }

            ed.dom.setStyle(element, 'padding-left', '');

            ed.dom.setStyle(element, 'margin-left', newIndentAmount > 0 ? newIndentAmount + indentUnits : '');

         };

      },



      selectedBlocks: function() {

         var ed = this.ed

         var selectedBlocks = ed.selection.getSelectedBlocks();

         return selectedBlocks.length == 0 ? [ ed.dom.getRoot() ] : selectedBlocks;

      },



      getInfo: function() {

         return {

            longname : 'Lists',

            author : 'Moxiecode Systems AB',

            authorurl : 'http://tinymce.moxiecode.com',

            infourl : 'http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/lists',

            version : tinymce.majorVersion + "." + tinymce.minorVersion

         };

      }

   });

   tinymce.PluginManager.add("lists", tinymce.plugins.Lists);

}());