mercury-rails 0.2.0 → 0.2.3

data/spec/javascripts/mercury/toolbar.expander_spec.js.coffee

@@ -10,7 +10,7 @@ describe "Mercury.Toolbar.Expander", ->
   afterEach ->
     @expander = null
     delete(@expander)
-    $(document).unbind('mercury:resize')
+    $(window).unbind('mercury:resize')
 
   describe "constructor", ->
 

data/spec/javascripts/templates/mercury/page_editor.html

@@ -7,9 +7,9 @@
 <meta content="K6JhyfOVKJX8X2ZkiJXSf491fc1fF+k79wzrChHQa0g=" name="csrf-token" />
 
 <div id="page_editor_container"></div>
-<div id="region1" class="mercury-region" data-type="editable"></div>
-<div id="region2" class="mercury-region" data-type="editable"></div>
-<div id="region3" class="mercury-region" data-type="editable">
+<div id="region1" class="custom-region-class" data-type="editable"></div>
+<div id="region2" class="custom-region-class" data-type="editable"></div>
+<div id="region3" class="custom-region-class" data-type="editable">
   <a id="anchor1r" href="#" target="_top">1</a>
   <a id="anchor2r" href="#" target="_blank">2</a>
   <a id="anchor3r" href="#" target="_self">3</a>

data/vendor/assets/javascripts/mercury.js

@@ -23,76 +23,20 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  *= require_self
+ *
+ * Add all requires for the support libraries that integrate nicely with Mercury Editor.
+ * require mercury/support/history
+ *
+ * Require Mercury Editor itself.
  *= require mercury/mercury
+ *
+ * Add all requires for plugins that extend or change the behavior of Mercury Editor.
+ * require mercury/plugins/save_as_xml/plugin.js
  */
 window.MercurySetup = {
 
   // # Mercury Configuration
   config: {
-    // ## Hijacking Links & Forms
-    //
-    // Mercury will hijack links and forms that don't have a target set, or the target is set to _self and will set it
-    // to _top.  This is because the target must be set properly for Mercury to not get in the way of some
-    // functionality, like proper page loads on form submissions etc.  Mercury doesn't do this to links or forms that
-    // are within editable regions because it doesn't want to impact the html that's saved.  With that being explained,
-    // you can add classes to links or forms that you don't want this behavior added to.  Let's say you have links that
-    // open a lightbox style window, and you don't want the targets of these to be set to _top.  You can add classes to
-    // this array, and they will be ignored when the hijacking is applied.
-    nonHijackableClasses: [],
-
-
-    // ## Ajax and CSRF Headers
-    //
-    // Some server frameworks require that you provide a specific header for Ajax requests.  The values for these CSRF
-    // tokens are typically stored in the rendered DOM.  By default, Mercury will look for the Rails specific meta tag,
-    // and provide the X-CSRF-Token header on Ajax requests, but you can modify this configuration if the system you're
-    // using doesn't follow the same standard.
-    csrfSelector: 'meta[name="csrf-token"]',
-    csrfHeader: 'X-CSRF-Token',
-
-
-    // ## Pasting (in Chrome/Safari)
-    //
-    // When copying content using webkit, it embeds all the user defined styles (from the css files) into the html
-    // style attributes directly.  When pasting this content into HTML5 contentEditable elements it leaves these
-    // intact.  This can be a desired feature, or an annoyance, so you can enable it or disable it here.  Keep in mind
-    // this will only change the behavior in webkit, as mozilla doesn't do this.
-    cleanStylesOnPaste: true,
-
-
-    // ## Snippet Options and Preview
-    //
-    // When a user drags a snippet onto the page they'll be prompted to enter options for the given snippet.  The server
-    // is expected to respond with a form.  Once the user submits this form, an Ajax request is sent to the server with
-    // the options provided; this preview request is expected to respond with the rendered markup for the snippet.
-    //
-    // Name will be replaced with the snippet name (eg. example)
-    snippets: {
-      method: 'POST',
-      optionsUrl: '/mercury/snippets/:name/options.html',
-      previewUrl: '/mercury/snippets/:name/preview.html'
-      },
-
-
-    // ## Image Uploading
-    //
-    // If you drag images (while pressing shift) from your desktop into regions that support it, it will be uploaded
-    // to the server and inserted into the region.  This configuration allows you to specify if you want to
-    // disable/enable this feature, the accepted mime-types, file size restrictions, and other things related to
-    // uploading.  You can optionally provide a handler function that takes the response from the server and returns an
-    // object: {image: {url: '[your provided url]'}
-    //
-    // **Note:** Image uploading is only supported in some region types.
-    uploading: {
-      enabled: true,
-      allowedMimeTypes: ['image/jpeg', 'image/gif', 'image/png'],
-      maxFileSize: 1235242880,
-      inputName: 'image[image]',
-      url: '/images',
-      handler: false
-      },
-
-
     // ## Toolbars
     //
     // This is where you can customize the toolbars by adding or removing buttons, or changing them and their
@@ -247,17 +191,127 @@ window.MercurySetup = {
       },
 
 
+    // ## Hijacking Links & Forms
+    //
+    // Mercury will hijack links and forms that don't have a target set, or the target is set to _self and will set it
+    // to _top.  This is because the target must be set properly for Mercury to not get in the way of some
+    // functionality, like proper page loads on form submissions etc.  Mercury doesn't do this to links or forms that
+    // are within editable regions because it doesn't want to impact the html that's saved.  With that being explained,
+    // you can add classes to links or forms that you don't want this behavior added to.  Let's say you have links that
+    // open a lightbox style window, and you don't want the targets of these to be set to _top.  You can add classes to
+    // this array, and they will be ignored when the hijacking is applied.
+    nonHijackableClasses: [],
+
+
+    // ## Ajax and CSRF Headers
+    //
+    // Some server frameworks require that you provide a specific header for Ajax requests.  The values for these CSRF
+    // tokens are typically stored in the rendered DOM.  By default, Mercury will look for the Rails specific meta tag,
+    // and provide the X-CSRF-Token header on Ajax requests, but you can modify this configuration if the system you're
+    // using doesn't follow the same standard.
+    csrfSelector: 'meta[name="csrf-token"]',
+    csrfHeader: 'X-CSRF-Token',
+
+
+    // ## Pasting & Sanitizing
+    //
+    // When pasting content into Mercury it may sometimes contain HTML tags and attributes.  This markup is used to
+    // style the content and makes the pasted content look (and behave) the same as the original content.  This can be a
+    // desired feature or an annoyance, so you can enable various sanitizing methods to clean the content when it's
+    // pasted.
+    //
+    // ### Sanitizing options:
+    // - false: no sanitizing is done, the content is pasted the exact same as it was copied by the user
+    // - 'whitelist': content is cleaned using the settings specified in the tag white list (described below)
+    // - 'text': all html is stripped before pasting, leaving only the raw text
+    //
+    // ### Using the whitelist configuration
+    //
+    // The white list allows you to specify tags and attributes that are allowed when pasting content.  Each item in
+    // this object should contain the allowed tag, and an array of attributes that are allowed on that tag.  If the
+    // allowed attributes array is empty, all attributes will be removed.  If a tag is not present in this list, it will
+    // be removed, but without removing any of the text or tags inside it.
+    //
+    // **Note:** Content is *always* sanitized if looks like it's from MS Word or similar editors regardless of this
+    // configuration.
+    pasting: {
+      sanitize: 'whitelist',
+      whitelist: {
+        h1:     [],
+        h2:     [],
+        h3:     [],
+        h4:     [],
+        h5:     [],
+        h6:     [],
+        table:  [],
+        thead:  [],
+        tbody:  [],
+        tfoot:  [],
+        tr:     [],
+        th:     ['colspan', 'rowspan'],
+        td:     ['colspan', 'rowspan'],
+        div:    ['class'],
+        span:   ['class'],
+        b:      [],
+        bold:   [],
+        i:      [],
+        em:     [],
+        u:      [],
+        strike: [],
+        br:     [],
+        p:      [],
+        hr:     [],
+        a:      ['href', 'target', 'title', 'name'],
+        img:    ['src', 'title', 'alt']
+        }
+      },
+
+
+    // ## Snippet Options and Preview
+    //
+    // When a user drags a snippet onto the page they'll be prompted to enter options for the given snippet.  The server
+    // is expected to respond with a form.  Once the user submits this form, an Ajax request is sent to the server with
+    // the options provided; this preview request is expected to respond with the rendered markup for the snippet.
+    //
+    // Name will be replaced with the snippet name (eg. example)
+    snippets: {
+      method: 'POST',
+      optionsUrl: '/mercury/snippets/:name/options.html',
+      previewUrl: '/mercury/snippets/:name/preview.html'
+      },
+
+
+    // ## Image Uploading
+    //
+    // If you drag images (while pressing shift) from your desktop into regions that support it, it will be uploaded
+    // to the server and inserted into the region.  This configuration allows you to specify if you want to
+    // disable/enable this feature, the accepted mime-types, file size restrictions, and other things related to
+    // uploading.  You can optionally provide a handler function that takes the response from the server and returns an
+    // object: {image: {url: '[your provided url]'}
+    //
+    // **Note:** Image uploading is only supported in some region types, and some browsers.
+    uploading: {
+      enabled: true,
+      allowedMimeTypes: ['image/jpeg', 'image/gif', 'image/png'],
+      maxFileSize: 1235242880,
+      inputName: 'image[image]',
+      url: '/images',
+      handler: false
+      },
+
+
     // ## Behaviors
     //
     // Behaviors are used to change the default behaviors of a given region type when a given button is clicked.  For
     // example, you may prefer to add HR tags using an HR wrapped within a div with a classname (for styling).  You
     // can add your own complex behaviors here.
     //
-    // You can see how the behavior matches up directly with the button name.  It's also important to note that the
+    // You can see how the behavior matches up directly with the button names.  It's also important to note that the
     // callback functions are executed within the scope of the given region, so you have access to all it's methods.
+    // Here's some examples to help you get started.
     behaviors: {
-      horizontalRule: function(selection) { selection.replace('<hr/>') },
-      htmlEditor: function() { Mercury.modal('/mercury/modals/htmleditor.html', { title: 'HTML Editor', fullHeight: true, handler: 'htmlEditor' }) }
+      //foreColor: function(selection, options) { selection.wrap('<span style="color:' + options.value.toHex() + '">', true) },
+      htmlEditor: function() { Mercury.modal('/mercury/modals/htmleditor.html', { title: 'HTML Editor', fullHeight: true, handler: 'htmlEditor' }); }
       },
 
 
@@ -271,19 +325,32 @@ window.MercurySetup = {
     // and
     // Mercury.Toolbar.ButtonGroup.contexts
 
+    
+    // ## Region Class
+    //
+    // Mercury identifies editable regions by a region class.  This class has to be added in your HTML in advance, and
+    // is the only real Mercury code/naming exposed in the implementation of Mercury.  To allow this to be as
+    // configurable as possible, you can set the name of the class here.  When switching to preview mode, this
+    // configuration is used to generate a class to indicate that Mercury is in preview mode -- which will be this
+    // class with '-preview' appended (so, mercury-region-preview by default)
+    regionClass: 'mercury-region',
 
+    
     // ## Styles
     //
     // Mercury tries to stay as much out of your code as possible, but because regions appear within your document we
     // need to include a few styles to indicate regions, as well as the different states of them (eg. focused).  These
     // styles are injected into your document, and as simple as they might be, you may want to change them.  You can do
-    // so here.
+    // so here.  {{regionClass}} will be automatically replaced with whatever you have set in the regionClass
+    // configuration directive.
     injectedStyles: '' +
-      '.mercury-region, .mercury-textarea { min-height: 10px; outline: 1px dotted #09F }' +
+      '.{{regionClass}} { min-height: 10px; outline: 1px dotted #09F } ' +
+      '.{{regionClass}}:focus, .{{regionClass}}.focus { outline: none; -webkit-box-shadow: 0 0 10px #09F, 0 0 1px #045; box-shadow: 0 0 10px #09F, 0 0 1px #045 }' +
+      '.{{regionClass}}:after { content: "."; display: block; visibility: hidden; clear: both; height: 0; overflow: hidden; }' +
+      '.{{regionClass}} table, .{{regionClass}} td, .{{regionClass}} th { border: 1px dotted red; }' +
       '.mercury-textarea { box-sizing: border-box; -moz-box-sizing: border-box; -webkit-box-sizing: border-box; resize: vertical; }' +
-      '.mercury-region:focus, .mercury-region.focus, .mercury-textarea.focus { outline: none; -webkit-box-shadow: 0 0 10px #09F, 0 0 1px #045; box-shadow: 0 0 10px #09F, 0 0 1px #045 }' +
-      '.mercury-region:after { content: "."; display: block; visibility: hidden; clear: both; height: 0; overflow: hidden; }' +
-      '.mercury-region table, .mercury-region td, .mercury-region th { border: 1px dotted red; }'
+      '.mercury-textarea { min-height: 10px; outline: 1px dotted #09F }' +
+      '.mercury-textarea:focus, .mercury-textarea.focus { outline: none; -webkit-box-shadow: 0 0 10px #09F, 0 0 1px #045; box-shadow: 0 0 10px #09F, 0 0 1px #045 }'
   },
 
   // ## Silent Mode
@@ -299,4 +366,4 @@ window.MercurySetup = {
 };
 
 if (!window.Mercury) window.Mercury = window.MercurySetup;
-else if (typeof(jQuery) !== 'undefined') jQuery.extend(window.Mercury, window.MercurySetup);
+else if (typeof(jQuery) !== 'undefined') jQuery.extend(window.Mercury, window.MercurySetup);

data/vendor/assets/javascripts/mercury/dependencies/jquery.htmlClean.js

@@ -0,0 +1,527 @@
+/*
+ HTML Clean for jQuery
+ Anthony Johnston
+ http://www.antix.co.uk
+
+ version 1.2.3
+
+ $Revision: 51 $
+
+ requires jQuery http://jquery.com
+
+ Use and distibution http://www.opensource.org/licenses/bsd-license.php
+
+ 2010-04-02 allowedTags/removeTags added (white/black list) thanks to David Wartian (Dwartian)
+ 2010-06-30 replaceStyles added for replacement of bold, italic, super and sub styles on a tag
+ 2010-07-01 notRenderedTags added, where tags are to be removed but their contents are kept
+ */
+(function ($) {
+  $.fn.htmlClean = function (options) {
+    // iterate and html clean each matched element
+    return this.each(function () {
+      if (this.value) {
+        this.value = $.htmlClean(this.value, options);
+      } else {
+        this.innerHTML = $.htmlClean(this.innerHTML, options);
+      }
+    });
+  };
+
+  // clean the passed html
+  $.htmlClean = function (html, options) {
+    options = $.extend({}, $.htmlClean.defaults, options);
+
+    var tagsRE = /<(\/)?(\w+:)?([\w]+)([^>]*)>/gi;
+    var attrsRE = /(\w+)=(".*?"|'.*?'|[^\s>]*)/gi;
+
+    var tagMatch;
+    var root = new Element();
+    var stack = [root];
+    var container = root;
+
+    if (options.bodyOnly) {
+      // check for body tag
+      if (tagMatch = /<body[^>]*>((\n|.)*)<\/body>/i.exec(html)) {
+        html = tagMatch[1];
+      }
+    }
+    html = html.concat("<xxx>"); // ensure last element/text is found
+    var lastIndex;
+
+    while (tagMatch = tagsRE.exec(html)) {
+      var tag = new Tag(tagMatch[3], tagMatch[1], tagMatch[4], options);
+
+      // add the text
+      var text = html.substring(lastIndex, tagMatch.index);
+      if (text.length > 0) {
+        var child = container.children[container.children.length - 1];
+        if (container.children.length > 0 && isText(child = container.children[container.children.length - 1])) {
+          // merge text
+          container.children[container.children.length - 1] = child.concat(text);
+        } else {
+          container.children.push(text);
+        }
+      }
+      lastIndex = tagsRE.lastIndex;
+
+      if (tag.isClosing) {
+        // find matching container
+        if (pop(stack, [tag.name])) {
+          stack.pop();
+          container = stack[stack.length - 1];
+        }
+      } else {
+        // create a new element
+        var element = new Element(tag);
+
+        // add attributes
+        var attrMatch;
+        while (attrMatch = attrsRE.exec(tag.rawAttributes)) {
+          // check style attribute and do replacements
+          if (attrMatch[1].toLowerCase() == "style" && options.replaceStyles) {
+
+            var renderParent = !tag.isInline;
+            for (var i = 0; i < options.replaceStyles.length; i++) {
+              if (options.replaceStyles[i][0].test(attrMatch[2])) {
+
+                if (!renderParent) {
+                  tag.render = false;
+                  renderParent = true;
+                }
+                container.children.push(element); // assumes not replaced
+                stack.push(element);
+                container = element; // assumes replacement is a container
+                // create new tag and element
+                tag = new Tag(options.replaceStyles[i][1], "", "", options);
+                element = new Element(tag);
+              }
+            }
+          }
+
+          if (tag.allowedAttributes != null
+            && (tag.allowedAttributes.length == 0
+            || $.inArray(attrMatch[1], tag.allowedAttributes) > -1)) {
+            element.attributes.push(new Attribute(attrMatch[1], attrMatch[2]));
+          }
+        }
+
+        // add required empty ones
+        $.each(tag.requiredAttributes, function () {
+          var name = this.toString();
+          if (!element.hasAttribute(name)) element.attributes.push(new Attribute(name, ""));
+        });
+
+        // check for replacements
+        for (var repIndex = 0; repIndex < options.replace.length; repIndex++) {
+          for (var tagIndex = 0; tagIndex < options.replace[repIndex][0].length; tagIndex++) {
+            var byName = typeof (options.replace[repIndex][0][tagIndex]) == "string";
+            if ((byName && options.replace[repIndex][0][tagIndex] == tag.name)
+              || (!byName && options.replace[repIndex][0][tagIndex].test(tagMatch))) {
+              // don't render this tag
+              tag.render = false;
+              container.children.push(element);
+              stack.push(element);
+              container = element;
+
+              // render new tag, keep attributes
+              tag = new Tag(options.replace[repIndex][1], tagMatch[1], tagMatch[4], options);
+              element = new Element(tag);
+              element.attributes = container.attributes;
+
+              repIndex = options.replace.length; // break out of both loops
+              break;
+            }
+          }
+        }
+
+        // check container rules
+        var add = true;
+        if (!container.isRoot) {
+          if (container.tag.isInline && !tag.isInline) {
+            add = false;
+          } else if (container.tag.disallowNest && tag.disallowNest
+            && !tag.requiredParent) {
+            add = false;
+          } else if (tag.requiredParent) {
+            if (add = pop(stack, tag.requiredParent)) {
+              container = stack[stack.length - 1];
+            }
+          }
+        }
+
+        if (add) {
+          container.children.push(element);
+
+          if (tag.toProtect) {
+            // skip to closing tag
+            var tagMatch2 = null;
+            while (tagMatch2 = tagsRE.exec(html)) {
+              var tag2 = new Tag(tagMatch2[3], tagMatch2[1], tagMatch2[4], options);
+              if (tag2.isClosing && tag2.name == tag.name) {
+                element.children.push(RegExp.leftContext.substring(lastIndex));
+                lastIndex = tagsRE.lastIndex;
+                break;
+              }
+            }
+          } else {
+            // set as current container element
+            if (!tag.isSelfClosing && !tag.isNonClosing) {
+              stack.push(element);
+              container = element;
+            }
+          }
+        }
+      }
+    }
+
+    // render doc
+    return render(root, options).join("");
+  };
+
+  // defaults
+  $.htmlClean.defaults = {
+    // only clean the body tagbody
+    bodyOnly: true,
+    // only allow tags in this array, (white list), contents still rendered
+    allowedTags: [],
+    // remove tags in this array, (black list), contents still rendered
+    removeTags: ["basefont", "center", "dir", "font", "frame", "frameset", "iframe", "isindex", "menu", "noframes", "s", "strike", "u"],
+    // array of attribute names to remove on all elements in addition to those not in tagAttributes e.g ["width", "height"]
+    removeAttrs: [],
+    // array of [className], [optional array of allowed on elements] e.g. [["class"], ["anotherClass", ["p", "dl"]]]
+    allowedClasses: [],
+    // tags not rendered, contents remain
+    notRenderedTags: [],
+    // format the result
+    format: false,
+    // format indent to start on
+    formatIndent: 0,
+    // tags to replace, and what to replace with, tag name or regex to match the tag and attributes
+    replace: [
+      [
+        ["b", "big"],
+        "strong"
+      ],
+      [
+        ["i"],
+        "em"
+      ]
+    ],
+    // styles to replace with tags, multiple style matches supported, inline tags are replaced by the first match blocks are retained
+    replaceStyles: [
+      [/font-weight:\s*bold/i, "strong"],
+      [/font-style:\s*italic/i, "em"],
+      [/vertical-align:\s*super/i, "sup"],
+      [/vertical-align:\s*sub/i, "sub"]
+    ]
+  };
+
+  function applyFormat(element, options, output, indent) {
+    if (!element.tag.isInline && output.length > 0) {
+      output.push("\n");
+      for (var i = 0; i < indent; i++) output.push("\t");
+    }
+  }
+
+  function render(element, options) {
+    var output = [],
+        empty = element.attributes.length == 0,
+        indent = 0,
+        outputChildren = null;
+
+    // don't render if not in allowedTags or in removeTags
+    var renderTag
+      = element.tag.render
+      && (options.allowedTags.length == 0 || $.inArray(element.tag.name, options.allowedTags) > -1)
+      && (options.removeTags.length == 0 || $.inArray(element.tag.name, options.removeTags) == -1);
+
+    if (!element.isRoot && renderTag) {
+      // render opening tag
+      output.push("<");
+      output.push(element.tag.name);
+      $.each(element.attributes, function () {
+        if ($.inArray(this.name, options.removeAttrs) == -1) {
+          var m = new RegExp(/^(['"]?)(.*?)['"]?$/).exec(this.value);
+          var value = m[2];
+          var valueQuote = m[1] || "'";
+
+          // check for classes allowed
+          if (this.name == "class") {
+            value =
+              $.grep(value.split(" "), function (c) {
+                return $.grep(options.allowedClasses,
+                  function (a) {
+                    return a[0] == c && (a.length == 1 || $.inArray(element.tag.name, a[1]) > -1);
+                  }).length > 0;
+              })
+                .join(" ");
+            valueQuote = "'";
+          }
+
+          if (value != null && (value.length > 0 || $.inArray(this.name, element.tag.requiredAttributes) > -1)) {
+            output.push(" ");
+            output.push(this.name);
+            output.push("=");
+            output.push(valueQuote);
+            output.push(value);
+            output.push(valueQuote);
+          }
+        }
+      });
+    }
+
+    if (element.tag.isSelfClosing) {
+      // self closing
+      if (renderTag) output.push(" />");
+      empty = false;
+    } else if (element.tag.isNonClosing) {
+      empty = false;
+    } else {
+      if (!element.isRoot && renderTag) {
+        // close
+        output.push(">");
+      }
+
+      indent = options.formatIndent++;
+
+      // render children
+      if (element.tag.toProtect) {
+        outputChildren = $.htmlClean.trim(element.children.join("")).replace(/<br>/ig, "\n");
+        output.push(outputChildren);
+        empty = outputChildren.length == 0;
+        options.formatIndent--;
+      } else {
+        outputChildren = [];
+        for (var i = 0; i < element.children.length; i++) {
+          var child = element.children[i];
+          var text = $.htmlClean.trim(textClean(isText(child) ? child : child.childrenToString()));
+          if (isInline(child)) {
+            if (i > 0 && text.length > 0
+              && (startsWithWhitespace(child) || endsWithWhitespace(element.children[i - 1]))) {
+              outputChildren.push(" ");
+            }
+          }
+          if (isText(child)) {
+            if (text.length > 0) {
+              outputChildren.push(text);
+            }
+          } else {
+            // don't allow a break to be the last child
+            if (i != element.children.length - 1 || child.tag.name != "br") {
+              if (options.format) applyFormat(child, options, outputChildren, indent);
+              outputChildren = outputChildren.concat(render(child, options));
+            }
+          }
+        }
+        options.formatIndent--;
+
+        if (outputChildren.length > 0) {
+          if (options.format && outputChildren[0] != "\n") applyFormat(element, options, output, indent);
+          output = output.concat(outputChildren);
+          empty = false;
+        }
+      }
+
+      if (!element.isRoot && renderTag) {
+        // render the closing tag
+        if (options.format) applyFormat(element, options, output, indent - 1);
+        output.push("</");
+        output.push(element.tag.name);
+        output.push(">");
+      }
+    }
+
+    // check for empty tags
+    if (!element.tag.allowEmpty && empty) {
+      return [];
+    }
+
+    return output;
+  }
+
+  // find a matching tag, and pop to it, if not do nothing
+  function pop(stack, tagNameArray, index) {
+    index = index || 1;
+    if ($.inArray(stack[stack.length - index].tag.name, tagNameArray) > -1) {
+      return true;
+    } else if (stack.length - (index + 1) > 0
+      && pop(stack, tagNameArray, index + 1)) {
+      stack.pop();
+      return true;
+    }
+    return false;
+  }
+
+  // Element Object
+  function Element(tag) {
+    if (tag) {
+      this.tag = tag;
+      this.isRoot = false;
+    } else {
+      this.tag = new Tag("root");
+      this.isRoot = true;
+    }
+    this.attributes = [];
+    this.children = [];
+
+    this.hasAttribute = function (name) {
+      for (var i = 0; i < this.attributes.length; i++) {
+        if (this.attributes[i].name == name) return true;
+      }
+      return false;
+    };
+
+    this.childrenToString = function () {
+      return this.children.join("");
+    };
+
+    return this;
+  }
+
+  // Attribute Object
+  function Attribute(name, value) {
+    this.name = name;
+    this.value = value;
+
+    return this;
+  }
+
+  // Tag object
+  function Tag(name, close, rawAttributes, options) {
+    this.name = name.toLowerCase();
+
+    this.isSelfClosing = $.inArray(this.name, tagSelfClosing) > -1;
+    this.isNonClosing = $.inArray(this.name, tagNonClosing) > -1;
+    this.isClosing = (close != undefined && close.length > 0);
+
+    this.isInline = $.inArray(this.name, tagInline) > -1;
+    this.disallowNest = $.inArray(this.name, tagDisallowNest) > -1;
+    this.requiredParent = tagRequiredParent[$.inArray(this.name, tagRequiredParent) + 1];
+    this.allowEmpty = $.inArray(this.name, tagAllowEmpty) > -1;
+
+    this.toProtect = $.inArray(this.name, tagProtect) > -1;
+
+    this.rawAttributes = rawAttributes;
+    this.allowedAttributes = tagAttributes[$.inArray(this.name, tagAttributes) + 1];
+    this.requiredAttributes = tagAttributesRequired[$.inArray(this.name, tagAttributesRequired) + 1];
+
+    this.render = options && $.inArray(this.name, options.notRenderedTags) == -1;
+
+    return this;
+  }
+
+  function startsWithWhitespace(item) {
+    while (isElement(item) && item.children.length > 0) {
+      item = item.children[0]
+    }
+    return isText(item) && item.length > 0 && $.htmlClean.isWhitespace(item.charAt(0));
+  }
+
+  function endsWithWhitespace(item) {
+    while (isElement(item) && item.children.length > 0) {
+      item = item.children[item.children.length - 1]
+    }
+    return isText(item) && item.length > 0 && $.htmlClean.isWhitespace(item.charAt(item.length - 1));
+  }
+
+  function isText(item) {
+    return item.constructor == String;
+  }
+
+  function isInline(item) {
+    return isText(item) || item.tag.isInline;
+  }
+
+  function isElement(item) {
+    return item.constructor == Element;
+  }
+
+  function textClean(text) {
+    return text.replace(/&nbsp;|\n/g, " ").replace(/\s\s+/g, " ");
+  }
+
+  // trim off white space, doesn't use regex
+  $.htmlClean.trim = function (text) {
+    return $.htmlClean.trimStart($.htmlClean.trimEnd(text));
+  };
+  $.htmlClean.trimStart = function (text) {
+    return text.substring($.htmlClean.trimStartIndex(text));
+  };
+  $.htmlClean.trimStartIndex = function (text) {
+    for (var start = 0; start < text.length - 1 && $.htmlClean.isWhitespace(text.charAt(start)); start++);
+    return start;
+  };
+  $.htmlClean.trimEnd = function (text) {
+    return text.substring(0, $.htmlClean.trimEndIndex(text));
+  };
+  $.htmlClean.trimEndIndex = function (text) {
+    for (var end = text.length - 1; end >= 0 && $.htmlClean.isWhitespace(text.charAt(end)); end--);
+    return end + 1;
+  };
+  // checks a char is white space or not
+  $.htmlClean.isWhitespace = function (c) {
+    return $.inArray(c, whitespace) != -1;
+  };
+
+  // tags which are inline
+  var tagInline = [
+    "a", "abbr", "acronym", "address", "b", "big", "br", "button",
+    "caption", "cite", "code", "del", "em", "font",
+    "hr", "i", "input", "img", "ins", "label", "legend", "map", "q",
+    "samp", "select", "small", "span", "strong", "sub", "sup",
+    "tt", "var"];
+  var tagDisallowNest = ["h1", "h2", "h3", "h4", "h5", "h6", "p", "th", "td"];
+  var tagAllowEmpty = ["th", "td"];
+  var tagRequiredParent = [
+    null,
+    "li", ["ul", "ol"],
+    "dt", ["dl"],
+    "dd", ["dl"],
+    "td", ["tr"],
+    "th", ["tr"],
+    "tr", ["table", "thead", "tbody", "tfoot"],
+    "thead", ["table"],
+    "tbody", ["table"],
+    "tfoot", ["table"]
+  ];
+  var tagProtect = ["script", "style", "pre", "code"];
+  // tags which self close e.g. <br />
+  var tagSelfClosing = ["br", "hr", "img", "link", "meta"];
+  // tags which do not close
+  var tagNonClosing = ["!doctype", "?xml"];
+  // attributes allowed on tags
+  var tagAttributes = [
+    ["class"], // default, for all tags not mentioned
+    "?xml", [],
+    "!doctype", [],
+    "a", ["accesskey", "class", "href", "name", "title", "rel", "rev", "type", "tabindex"],
+    "abbr", ["class", "title"],
+    "acronym", ["class", "title"],
+    "blockquote", ["cite", "class"],
+    "button", ["class", "disabled", "name", "type", "value"],
+    "del", ["cite", "class", "datetime"],
+    "form", ["accept", "action", "class", "enctype", "method", "name"],
+    "input", ["accept", "accesskey", "alt", "checked", "class", "disabled", "ismap", "maxlength", "name", "size", "readonly", "src", "tabindex", "type", "usemap", "value"],
+    "img", ["alt", "class", "height", "src", "width"],
+    "ins", ["cite", "class", "datetime"],
+    "label", ["accesskey", "class", "for"],
+    "legend", ["accesskey", "class"],
+    "link", ["href", "rel", "type"],
+    "meta", ["content", "http-equiv", "name", "scheme"],
+    "map", ["name"],
+    "optgroup", ["class", "disabled", "label"],
+    "option", ["class", "disabled", "label", "selected", "value"],
+    "q", ["class", "cite"],
+    "td", ["colspan", "rowspan"],
+    "th", ["colspan", "rowspan"],
+    "script", ["src", "type"],
+    "select", ["class", "disabled", "multiple", "name", "size", "tabindex"],
+    "style", ["type"],
+    "table", ["class", "summary"],
+    "textarea", ["accesskey", "class", "cols", "disabled", "name", "readonly", "rows", "tabindex"]
+  ];
+  var tagAttributesRequired = [[], "img", ["alt"]];
+  // white space chars
+  var whitespace = [" ", " ", "\t", "\n", "\r", "\f"];
+
+})(jQuery);