diff --git a/src/htmldiff.coffee b/src/htmldiff.coffee
index dd5c658..46cb5a1 100644
--- a/src/htmldiff.coffee
+++ b/src/htmldiff.coffee
@@ -1,23 +1,121 @@
+###
+ * htmldiff.js is a library that compares HTML content. It creates a diff between two
+ * HTML documents by combining the two documents and wrapping the differences with
+ * <ins> and <del> tags. Here is a high-level overview of how the diff works.
+ *
+ * 1. Tokenize the before and after HTML with html_to_tokens.
+ * 2. Generate a list of operations that convert the before list of tokens to the after
+ *    list of tokens with calculate_operations, which does the following:
+ *      a. Find all the matching blocks of tokens between the before and after lists of
+ *         tokens with find_matching_blocks. This is done by finding the single longest
+ *         matching block with find_match, then recursively finding the next longest
+ *         matching block that precede and follow the longest matching block with
+ *         recursively_find_matching_blocks.
+ *      b. Determine insertions, deletions, and replacements from the matching blocks.
+ *         This is done in calculate_operations.
+ * 3. Render the list of operations by wrapping tokens with <ins> and <del> tags where
+ *    appropriate with render_operations.
+ *
+ * Example usage:
+ *
+ *   htmldiff = require 'htmldiff.js'
+ *
+ *   htmldiff '<p>this is some text</p>', '<p>this is some more text</p>'
+ *   == '<p>this is some <ins>more </ins>text</p>'
+ *
+ *   htmldiff '<p>this is some text</p>', '<p>this is some more text</p>', 'diff-class'
+ *   == '<p>this is some <ins class="diff-class">more </ins>text</p>'
+###
+
 is_end_of_tag = (char)-> char is '>'
 is_start_of_tag = (char)-> char is '<'
 is_whitespace = (char)-> /^\s+$/.test char
 is_tag = (token)-> /^\s*<[^>]+>\s*$/.test token
 isnt_tag = (token)-> not is_tag token
 
+###
+ * Checks if the current word is the beginning of an atomic tag. An atomic tag is one whose
+ * child nodes should not be compared - the entire tag should be treated as one token. This
+ * is useful for tags where it does not make sense to insert <ins> and <del> tags.
+ *
+ * @param {string} word The characters of the current token read so far.
+ *
+ * @return {string|null} The name of the atomic tag if the word will be an atomic tag,
+ *    null otherwise
+###
+is_start_of_atomic_tag = (word)->
+  result = /^<(iframe|object|math|svg|script)/.exec word
+  result = result[1] if result
+  return result
+
+###
+ * Checks if the current word is the end of an atomic tag (i.e. it has all the characters,
+ * except for the end bracket of the closing tag, such as "<iframe></iframe").
+ *
+ * @param {string} word The characters of the current token read so far.
+ * @param {string} tag The ending tag to look for.
+ *
+ * @return {boolean} True if the word is now a complete token (including the end tag),
+ *    false otherwise.
+###
+is_end_of_atomic_tag = (word, tag)->
+  (word.substring word.length - tag.length - 2) is "</#{tag}"
+
+###
+ * Checks if a tag is a void tag.
+ *
+ * @param {string} token The token to check.
+ *
+ * @return {boolean} True if the token is a void tag, false otherwise.
+###
+is_void_tag = (token) ->
+  /^\s*<[^>]+\/>\s*$/.test token
+
+###
+ * Checks if a token can be wrapped inside a tag.
+ *
+ * @param {string} token The token to check.
+ *
+ * @return {boolean} True if the token can be wrapped inside a tag, false otherwise.
+###
+is_wrappable = (token) ->
+  (isnt_tag token) or (is_start_of_atomic_tag token) or (is_void_tag token)
+
+###
+ * A Match stores the information of a matching block. A matching block is a list of
+ * consecutive tokens that appear in both the before and after lists of tokens.
+ *
+ * @param {number} start_in_before The index of the first token in the list of before tokens.
+ * @param {number} start_in_after The index of the first token in the list of after tokens.
+ * @param {number} length The number of consecutive matching tokens in this block.
+###
 class Match
   constructor: (@start_in_before, @start_in_after, @length)->
     @end_in_before = (@start_in_before + @length) - 1
     @end_in_after = (@start_in_after + @length) - 1
 
+###
+ * Tokenizes a string of HTML.
+ *
+ * @param {string} html The string to tokenize.
+ *
+ * @return {Array.<string>} The list of tokens.
+###
 html_to_tokens = (html)->
   mode = 'char'
   current_word = ''
+  current_atomic_tag = ''
   words = []
 
   for char in html
     switch mode
       when 'tag'
-        if is_end_of_tag char
+        atomic_tag = is_start_of_atomic_tag current_word
+        if atomic_tag
+          mode = 'atomic_tag'
+          current_atomic_tag = atomic_tag
+          current_word += char
+        else if is_end_of_tag char
           current_word += '>'
           words.push current_word
           current_word = ''
@@ -27,6 +125,16 @@ html_to_tokens = (html)->
             mode = 'char'
         else
           current_word += char
+      when 'atomic_tag'
+        if (is_end_of_tag char) \
+        and (is_end_of_atomic_tag current_word, current_atomic_tag)
+          current_word += '>'
+          words.push current_word
+          current_word = ''
+          current_atomic_tag = ''
+          mode = 'char'
+        else
+          current_word += char
       when 'char'
         if is_start_of_tag char
           words.push current_word if current_word
@@ -36,11 +144,19 @@ html_to_tokens = (html)->
           words.push current_word if current_word
           current_word = char
           mode = 'whitespace'
-        else if /[\w\#@]+/i.test char
+        else if /[\w\d\#@]/.test char
+          # Consider '#' as part of the same word, since it might be part of an HTML escaped
+          # character (e.g. '&#160;').
           current_word += char
-        else
+        else if /&/.test char
+          # Consider '&' as the start of a new word, since it might be the start of an HTML
+          # escaped character (e.g. '&#160;').
           words.push current_word if current_word
           current_word = char
+        else
+          current_word += char
+          words.push current_word
+          current_word = ''
       when 'whitespace'
         if is_start_of_tag char
           words.push current_word if current_word
@@ -57,6 +173,43 @@ html_to_tokens = (html)->
   words.push current_word if current_word
   return words
 
+###
+ * Creates a key that should be used to match tokens. This is useful, for example, if we want
+ * to consider two open tag tokens as equal, even if they don't have the same attributes. We
+ * use a key instead of overwriting the token because we may want to render the original string
+ * without losing the attributes.
+ *
+ * @param {string} token The token to create the key for.
+ *
+ * @return {string} The identifying key that should be used to match before and after tokens.
+###
+get_key_for_token = (token)->
+  # If the token is a tag, return just the tag with no attributes since we do not compare
+  # attributes yet.
+  tag_name = /<([^\s>]+)[\s>]/.exec token
+  return "<#{tag_name[1].toLowerCase()}>" if tag_name
+
+  # If the token is text, collapse adjacent whitespace and replace non-breaking spaces with
+  # regular spaces.
+  return token.replace /(\s+|&nbsp;|&#160;)/g, ' ' if token
+
+  return token
+
+###
+ * Finds the matching block with the most consecutive tokens within the given range in the
+ * before and after lists of tokens.
+ *
+ * @param {Array.<string>} before_tokens The before list of tokens.
+ * @param {Array.<string>} after_tokens The after list of tokens.
+ * @param {Object} index_of_before_locations_in_after_tokens The index that is used to search
+ *      for tokens in the after list.
+ * @param {number} start_in_before The beginning of the range in the list of before tokens.
+ * @param {number} end_in_before The end of the range in the list of before tokens.
+ * @param {number} start_in_after The beginning of the range in the list of after tokens.
+ * @param {number} end_in_after The end of the range in the list of after tokens.
+ *
+ * @return {Match} A Match that describes the best matching block in the given range.
+###
 find_match = (before_tokens, after_tokens,
   index_of_before_locations_in_after_tokens,
   start_in_before, end_in_before,
@@ -70,7 +223,7 @@ find_match = (before_tokens, after_tokens,
 
   for index_in_before in [start_in_before...end_in_before]
     new_match_length_at = {}
-    looking_for = before_tokens[index_in_before]
+    looking_for = get_key_for_token before_tokens[index_in_before]
     locations_in_after =
       index_of_before_locations_in_after_tokens[looking_for]
 
@@ -96,6 +249,23 @@ find_match = (before_tokens, after_tokens,
 
   return match
 
+###
+ * Finds all the matching blocks within the given range in the before and after lists of
+ * tokens. This function is called recursively to find the next best matches that precede
+ * and follow the first best match.
+ *
+ * @param {Array.<string>} before_tokens The before list of tokens.
+ * @param {Array.<string>} after_tokens The after list of tokens.
+ * @param {Object} index_of_before_locations_in_after_tokens The index that is used to search
+ *      for tokens in the after list.
+ * @param {number} start_in_before The beginning of the range in the list of before tokens.
+ * @param {number} end_in_before The end of the range in the list of before tokens.
+ * @param {number} start_in_after The beginning of the range in the list of after tokens.
+ * @param {number} end_in_after The end of the range in the list of after tokens.
+ * @param {Array.<Match>} matching_blocks The list of matching blocks found so far.
+ *
+ * @return {Array.<Match>} The list of matching blocks in this range.
+###
 recursively_find_matching_blocks = (before_tokens, after_tokens,
   index_of_before_locations_in_after_tokens,
   start_in_before, end_in_before,
@@ -128,20 +298,44 @@ recursively_find_matching_blocks = (before_tokens, after_tokens,
 
   return matching_blocks
 
-create_index = (p)->
-  throw new Error 'params must have find_these key' unless p.find_these?
-  throw new Error 'params must have in_these key' unless p.in_these?
+###
+ * Creates an index (A.K.A. hash table) that will be used to match the list of before
+ * tokens with the list of after tokens.
+ *
+ * @param {Object} options An object with the following:
+ *    - {Array.<string>} find_these The list of tokens that will be used to search.
+ *    - {Array.<string>} in_these The list of tokens that will be returned.
+ *
+ * @return {Object} An index that can be used to search for tokens.
+###
+create_index = (options)->
+  throw new Error 'params must have find_these key' unless options.find_these?
+  throw new Error 'params must have in_these key' unless options.in_these?
+
+  queries = options.find_these.map (token)->
+    return get_key_for_token token
+  results = options.in_these.map (token)->
+    return get_key_for_token token
 
   index = {}
-  for token in p.find_these
-    index[token] = []
-    idx = p.in_these.indexOf token
+  for query in queries
+    index[query] = []
+    idx = results.indexOf query
     while idx isnt -1
-      index[token].push idx
-      idx = p.in_these.indexOf token, idx+1
+      index[query].push idx
+      idx = results.indexOf query, idx+1
 
   return index
 
+###
+ * Finds all the matching blocks in the before and after lists of tokens. This function
+ * is a wrapper for the recursive function recursively_find_matching_blocks.
+ *
+ * @param {Array.<string>} before_tokens The before list of tokens.
+ * @param {Array.<string>} after_tokens The after list of tokens.
+ *
+ * @return {Array.<Match>} The list of matching blocks.
+###
 find_matching_blocks = (before_tokens, after_tokens)->
   matching_blocks = []
   index_of_before_locations_in_after_tokens =
@@ -155,6 +349,23 @@ find_matching_blocks = (before_tokens, after_tokens)->
     0, after_tokens.length,
     matching_blocks
 
+###
+ * Gets a list of operations required to transform the before list of tokens into the
+ * after list of tokens. An operation describes whether a particular list of consecutive
+ * tokens are equal, replaced, inserted, or deleted.
+ *
+ * @param {Array.<string>} before_tokens The before list of tokens.
+ * @param {Array.<string>} after_tokens The after list of tokens.
+ *
+ * @return {Array.<Object>} The list of operations to transform the before list of
+ *      tokens into the after list of tokens, where each operation has the following
+ *      keys:
+ *      - {string} action One of {'replace', 'insert', 'delete', 'equal'}.
+ *      - {number} start_in_before The beginning of the range in the list of before tokens.
+ *      - {number} end_in_before The end of the range in the list of before tokens.
+ *      - {number} start_in_after The beginning of the range in the list of after tokens.
+ *      - {number} end_in_after The end of the range in the list of after tokens.
+###
 calculate_operations = (before_tokens, after_tokens)->
   throw new Error 'before_tokens?' unless before_tokens?
   throw new Error 'after_tokens?' unless after_tokens?
@@ -218,6 +429,16 @@ calculate_operations = (before_tokens, after_tokens)->
 
   return post_processed
 
+###
+ * Returns a list of tokens of a particular type starting at a given index.
+ *
+ * @param {number} start The index of first token to test.
+ * @param {Array.<string>} content The list of tokens.
+ * @param {function} predicate A function that returns true if a token is of
+ *      a particular type, false otherwise. It should accept the following
+ *      parameters:
+ *      - {string} The token to test.
+###
 consecutive_where = (start, content, predicate)->
   content = content[start..content.length]
   last_matching_index = undefined
@@ -230,17 +451,27 @@ consecutive_where = (start, content, predicate)->
   return content[0..last_matching_index] if last_matching_index?
   return []
 
-wrap = (tag, content)->
+###
+ * Wraps and concatenates a list of tokens with a tag. Does not wrap tag tokens,
+ * unless they are wrappable (i.e. void and atomic tags).
+ *
+ * @param {sting} tag The tag name of the wrapper tags.
+ * @param {Array.<string>} content The list of tokens to wrap.
+ * @param {string} class_name (Optional) The class name to include in the wrapper tag.
+###
+wrap = (tag, content, class_name)->
   rendering = ''
   position = 0
   length = content.length
 
   loop
     break if position >= length
-    non_tags = consecutive_where position, content, isnt_tag
+    non_tags = consecutive_where position, content, is_wrappable
     position += non_tags.length
     if non_tags.length isnt 0
-      rendering += "<#{tag}>#{non_tags.join ''}</#{tag}>"
+      val = non_tags.join ''
+      attrs = if class_name then " class=\"#{class_name}\"" else ''
+      rendering += "<#{tag}#{attrs}>#{val}</#{tag}>" if val.trim()
 
     break if position >= length
     tags = consecutive_where position, content, is_tag
@@ -249,30 +480,75 @@ wrap = (tag, content)->
 
   return rendering
 
+###
+ * op_map.equal/insert/delete/replace are functions that render an operation into
+ * HTML content.
+ *
+ * @param {Object} op The operation that applies to a prticular list of tokens. Has the
+ *      following keys:
+ *      - {string} action One of {'replace', 'insert', 'delete', 'equal'}.
+ *      - {number} start_in_before The beginning of the range in the list of before tokens.
+ *      - {number} end_in_before The end of the range in the list of before tokens.
+ *      - {number} start_in_after The beginning of the range in the list of after tokens.
+ *      - {number} end_in_after The end of the range in the list of after tokens.
+ * @param {Array.<string>} before_tokens The before list of tokens.
+ * @param {Array.<string>} after_tokens The after list of tokens.
+ * @param {string} class_name (Optional) The class name to include in the wrapper tag.
+ *
+ * @return {string} The rendering of that operation.
+###
 op_map =
-  equal: (op, before_tokens, after_tokens)->
-    before_tokens[op.start_in_before..op.end_in_before].join ''
+  equal: (op, before_tokens, after_tokens, class_name)->
+    after_tokens[op.start_in_after..op.end_in_after].join ''
 
-  insert: (op, before_tokens, after_tokens)->
+  insert: (op, before_tokens, after_tokens, class_name)->
     val = after_tokens[op.start_in_after..op.end_in_after]
-    wrap 'ins', val
+    wrap 'ins', val, class_name
 
-  delete: (op, before_tokens, after_tokens)->
+  delete: (op, before_tokens, after_tokens, class_name)->
     val = before_tokens[op.start_in_before..op.end_in_before]
-    wrap 'del', val
-
-op_map.replace = (op, before_tokens, after_tokens)->
-  (op_map.delete op, before_tokens, after_tokens) +
-  (op_map.insert op, before_tokens, after_tokens)
-
-render_operations = (before_tokens, after_tokens, operations)->
+    wrap 'del', val, class_name
+
+op_map.replace = (op, before_tokens, after_tokens, class_name)->
+  (op_map.delete op, before_tokens, after_tokens, class_name) +
+  (op_map.insert op, before_tokens, after_tokens, class_name)
+
+###
+ * Renders a list of operations into HTML content. The result is the combined version
+ * of the before and after tokens with the differences wrapped in tags.
+ *
+ * @param {Array.<string>} before_tokens The before list of tokens.
+ * @param {Array.<string>} after_tokens The after list of tokens.
+ * @param {Array.<Object>} operations The list of operations to transform the before
+ *      list of tokens into the after list of tokens, where each operation has the
+ *      following keys:
+ *      - {string} action One of {'replace', 'insert', 'delete', 'equal'}.
+ *      - {number} start_in_before The beginning of the range in the list of before tokens.
+ *      - {number} end_in_before The end of the range in the list of before tokens.
+ *      - {number} start_in_after The beginning of the range in the list of after tokens.
+ *      - {number} end_in_after The end of the range in the list of after tokens.
+ * @param {string} class_name (Optional) The class name to include in the wrapper tag.
+ *
+ * @return {string} The rendering of the list of operations.
+###
+render_operations = (before_tokens, after_tokens, operations, class_name)->
   rendering = ''
   for op in operations
-    rendering += op_map[op.action] op, before_tokens, after_tokens
+    rendering += op_map[op.action] op, before_tokens, after_tokens, class_name
 
   return rendering
 
-diff = (before, after)->
+###
+ * Compares two pieces of HTML content and returns the combined content with differences
+ * wrapped in <ins> and <del> tags.
+ *
+ * @param {string} before The HTML content before the changes.
+ * @param {string} after The HTML content after the changes.
+ * @param {string} class_name (Optional) The class attribute to include in <ins> and <del> tags.
+ *
+ * @return {string} The combined HTML content with differences wrapped in <ins> and <del> tags.
+###
+diff = (before, after, class_name)->
   return before if before is after
 
   before = html_to_tokens before
@@ -280,13 +556,13 @@ diff = (before, after)->
 
   ops = calculate_operations before, after
 
-  render_operations before, after, ops
-
+  render_operations before, after, ops, class_name
 
 diff.html_to_tokens = html_to_tokens
 diff.find_matching_blocks = find_matching_blocks
 find_matching_blocks.find_match = find_match
 find_matching_blocks.create_index = create_index
+find_matching_blocks.get_key_for_token = get_key_for_token
 diff.calculate_operations = calculate_operations
 diff.render_operations = render_operations
 
diff --git a/test/diff.spec.coffee b/test/diff.spec.coffee
index 68d0cc9..852ff3d 100644
--- a/test/diff.spec.coffee
+++ b/test/diff.spec.coffee
@@ -9,9 +9,24 @@ describe 'Diff', ->
     it 'should return the text', ->
       (expect @res).equal 'input text'
 
-  xdescribe 'When a letter is added', ->
+  describe 'When a letter is added', ->
     beforeEach ->
       @res = @cut 'input', 'input 2'
 
     it 'should mark the new letter', ->
-      (expect @res).to.equal 'input <ins>2</ins>'
+      (expect @res).to.equal 'input<ins> 2</ins>'
+
+  describe 'Whitespace differences', ->
+    it 'should collapse adjacent whitespace', ->
+      (expect @cut 'Much \n\t    spaces', 'Much spaces').to.equal 'Much spaces'
+
+    it 'should consider non-breaking spaces as equal', ->
+      (expect @cut 'Hello&nbsp;world', 'Hello&#160;world').to.equal 'Hello&#160;world'
+
+    it 'should consider non-breaking spaces and non-adjacent regular spaces as equal', ->
+      (expect @cut 'Hello&nbsp;world', 'Hello world').to.equal 'Hello world'
+
+  describe 'When a class name is specified', ->
+    it 'should include the class in the wrapper tags', ->
+      (expect @cut 'input', 'input 2', 'diff-result').to.equal \
+        'input<ins class="diff-result"> 2</ins>'
diff --git a/test/html_to_tokens.spec.coffee b/test/html_to_tokens.spec.coffee
index ac6c235..15139f5 100644
--- a/test/html_to_tokens.spec.coffee
+++ b/test/html_to_tokens.spec.coffee
@@ -28,3 +28,44 @@ describe 'html_to_tokens', ->
   it 'should identify self closing tags as tokens', ->
     (expect @cut '<p>hello</br>goodbye</p>')
     .eql ['<p>', 'hello', '</br>', 'goodbye', '</p>']
+
+  describe 'when encountering atomic tags', ->
+    it 'should identify an image tag as a single token', ->
+      (expect @cut '<p><img src="1.jpg"><img src="2.jpg"></p>')
+      .eql ['<p>', '<img src="1.jpg">', '<img src="2.jpg">', '</p>']
+
+    it 'should identify an iframe tag as a single token', ->
+      (expect @cut '<p><iframe src="sample.html"></iframe></p>')
+      .eql ['<p>', '<iframe src="sample.html"></iframe>', '</p>']
+
+    it 'should identify an object tag as a single token', ->
+      (expect @cut '<p><object><param name="1" /><param name="2" /></object></p>')
+      .eql ['<p>', '<object><param name="1" /><param name="2" /></object>', '</p>']
+
+    it 'should identify a math tag as a single token', ->
+      (expect @cut '<p><math xmlns="http://www.w3.org/1998/Math/MathML">' +
+        '<mi>&#x03C0;<!-- π --></mi>' +
+        '<mo>&#x2062;<!-- &InvisibleTimes; --></mo>' +
+        '<msup><mi>r</mi><mn>2</mn></msup></math></p>')
+      .eql [
+        '<p>',
+        '<math xmlns="http://www.w3.org/1998/Math/MathML">' +
+            '<mi>&#x03C0;<!-- π --></mi>' +
+            '<mo>&#x2062;<!-- &InvisibleTimes; --></mo>' +
+            '<msup><mi>r</mi><mn>2</mn></msup></math>',
+        '</p>']
+
+    it 'should identify an svg tag as a single token', ->
+      (expect @cut '<p><svg width="100" height="100">' +
+        '<circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />' +
+        '</svg></p>')
+      .eql [
+        '<p>',
+        '<svg width="100" height="100">' +
+          '<circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />' +
+          '</svg>',
+        '</p>']
+
+    it 'should identify a script tag as a single token', ->
+      (expect @cut '<p><script>console.log("hi");</script></p>')
+      .eql ['<p>', '<script>console.log("hi");</script>', '</p>']
diff --git a/test/mocha.opts b/test/mocha.opts
index b0f5199..ab28531 100644
--- a/test/mocha.opts
+++ b/test/mocha.opts
@@ -1,4 +1,4 @@
---compilers coffee:coffee-script
+--compilers coffee:coffee-script/register
 --require test/config.js
 --ui bdd
 --reporter spec
diff --git a/test/render_operations.spec.coffee b/test/render_operations.spec.coffee
index a233315..c7f0394 100644
--- a/test/render_operations.spec.coffee
+++ b/test/render_operations.spec.coffee
@@ -63,3 +63,47 @@ describe 'render_operations', ->
 
       it 'should keep the change inside the <p>', ->
         (expect @res).to.equal '<p><del>this</del><ins>I</ins> is awesome</p>'
+
+  describe 'empty tokens', ->
+    it 'should not be wrapped', ->
+      before = ['text']
+      after = ['text', ' ']
+
+      @res = @cut before, after
+
+      (expect @res).to.equal 'text'
+
+  describe 'tags with attributes', ->
+    it 'should treat attribute changes as equal and output the after tag', ->
+      before = ['<p>', 'this', ' ', 'is', ' ', 'awesome', '</p>']
+      after = ['<p style="margin: 2px;" class="after">', 'this', ' ', 'is', ' ', 'awesome', '</p>']
+
+      @res = @cut before, after
+
+      (expect @res).to.equal '<p style="margin: 2px;" class="after">this is awesome</p>'
+
+    it 'should show changes within tags with different attributes', ->
+      before = ['<p>', 'this', ' ', 'is', ' ', 'awesome', '</p>']
+      after = ['<p style="margin: 2px;" class="after">', 'that', ' ', 'is', ' ', 'awesome', '</p>']
+
+      @res = @cut before, after
+
+      (expect @res).to.equal \
+        '<p style="margin: 2px;" class="after"><del>this</del><ins>that</ins> is awesome</p>'
+
+  describe 'wrappable tags', ->
+    it 'should wrap void tags', ->
+      before = ['old', ' ', 'text']
+      after = ['new', '<br/>', ' ', 'text']
+
+      @res = @cut before, after
+
+      (expect @res).to.equal '<del>old</del><ins>new<br/></ins> text'
+
+    it 'should wrap atomic tags', ->
+      before = ['old', '<iframe src="source.html"></iframe>', ' ', 'text']
+      after = ['new', ' ', 'text']
+
+      @res = @cut before, after
+
+      (expect @res).to.equal '<del>old<iframe src="source.html"></iframe></del><ins>new</ins> text'