X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=editor.coffee;h=b21d9593cfa687a4dbe3c9f88a83cf7295ac3e9b;hb=80153058975905b53418f34498b799922f3def07;hp=ec9f9f9331a7ecdb4384b32f9caec289ba82a5f3;hpb=6a596f32f02d952a0d4f3f2a6a67d76c579790a6;p=peach-html5-editor.git

diff --git a/editor.coffee b/editor.coffee
index ec9f9f9..b21d959 100644
--- a/editor.coffee
+++ b/editor.coffee
@@ -16,7 +16,7 @@
 
 # SETTINGS
 overlay_padding = 10
-breathing_room = 30 # minimum pixels above/below cursor
+breathing_room = 30 # minimum pixels above/below cursor (scrolling)
 
 timeout = (ms, cb) -> return setTimeout cb, ms
 next_frame = (cb) ->
@@ -73,12 +73,8 @@ js_attr_regex = new RegExp '^[oO][nN].'
 # html5 spec says that only these characters are collapsable
 multi_sp_regex = new RegExp '[\u0020\u0009\u000a\u000c\u000d][\u0020\u0009\u000a\u000c\u000d]'
 
-debug_dot_at = (doc, x, y) ->
-	return # disabled
-	el = doc.createElement 'div'
-	el.setAttribute 'style', "position: absolute; left: #{x}px; top: #{y}px; width: 1px; height: 3px; background-color: red"
-	doc.body.appendChild el
-	#console.log(new Error().stack)
+str_has_ws_run = (str) ->
+	return multi_sp_regex.test str
 
 # text nodes don't have getBoundingClientRect(), so use selection api to find
 # it.
@@ -521,163 +517,6 @@ tree_remove_empty_text_nodes = (tree) ->
 				n.parent.children.splice i, 1
 				break
 
-# pass a array of nodes (from parser library, ie it should have .el and .text)
-tree_dedup_space = (tree) ->
-	prev = cur = next = null
-	prev_i = cur_i = next_i = 0
-	prev_pos = pos = next_pos = null
-	prev_px = cur_px = next_px = null
-	first = true
-	removed_char = null
-
-	tree_remove_empty_text_nodes(tree)
-
-	iterate = (tree, cb) ->
-		for n in tree
-			if n.type is 'text'
-				i = 0
-				while i < n.text.length # don't foreach, cb might remove chars
-					advance = cb n, i
-					if advance
-						i += 1
-			if n.type is 'tag'
-				block = is_display_block n.el
-				if block
-					cb null
-				if n.children.length > 0
-					iterate n.children, cb
-				if block
-					cb null
-	# remove cur char
-	remove = (undo) ->
-		if undo
-			cur.el.textContent = cur.text = (cur.text.substr 0, cur_i) + removed_char + (cur.text.substr cur_i)
-			if next is cur # in same text node
-				next_i += 1
-			return -1
-		else
-			removed_char = cur.text.charAt(cur_i)
-			cur.el.textContent = cur.text = (cur.text.substr 0, cur_i) + (cur.text.substr cur_i + 1)
-			if next is cur # in same text node
-				if next_i is 0
-					throw "how is this possible?"
-				next_i -= 1
-			return 1
-	replace_with_space = (undo) ->
-		if undo
-			cur.text = (cur.text.substr 0, cur_i) + removed_char + (cur.text.substr cur_i + 1)
-			cur.el.textContent = cur.text
-		else
-			removed_char = cur.text.charAt(cur_i)
-			if removed_char isnt ' '
-				cur.text = (cur.text.substr 0, cur_i) + ' ' + (cur.text.substr cur_i + 1)
-				cur.el.textContent = cur.text
-		return 0
-	# return true if cur was removed from the dom (ie re-use same prev)
-	operate = ->
-		# cur definitately set
-		# prev and/or next might be null, indicating the start/end of a display:block
-		return false unless is_space_code cur.text.charCodeAt cur_i
-		fixers = [remove, replace_with_space]
-		# check for common case: single whitespace surrounded by non-whitespace chars
-		if prev? and next?
-			unless (is_space_code prev.text.charCodeAt prev_i) or (is_space_code next.text.charCodeAt next_i)
-				dbg = cur.text.charCodeAt cur_i
-				if cur.text.charAt(cur_i) is ' ' # perens required
-					# single space can't collapse, doesn't need fixin'
-					return false
-				else
-					# tab, newline, etc, can't collapse, but maybe should be replaced
-					fixers = [replace_with_space]
-		bounds = text_range_bounds cur.el, cur_i, cur_i + 1
-		# consistent cases:
-		# 1. zero rects returned by getClientRects() means collapsed space
-		if bounds is null
-			return remove()
-		# 2. width greater than zero means visible space
-		if bounds.w > 0
-			# has bounds, don't try removing
-			fixers = [replace_with_space]
-		# now the weird edge cases...
-		#
-		# firefox and chromium both report zero width for characters at the end
-		# of a line where the text wraps (automatically, due to word-wrap) to
-		# the next line. These do not appear to be distinguishable from
-		# collapsed spaces via the range/bounds api, so...
-		#
-		# remove it from the dom, and if prev or next moves, put it back.
-		#
-		# this block (try changing it, put it back if something moves) is also
-		# used on collapsable whitespace characters besides space. In this case
-		# the character is replaced with a normal space character instead of
-		# removed
-		if prev? and not prev_px?
-			prev_px = new_cursor_position n: prev, i: prev_i
-		if next? and not next_px?
-			next_px = new_cursor_position n: next, i: next_i
-		#if prev is null and next is null
-		#	parent_px = cur.parent.el.getBoundingClientRect()
-		undo_arg = true # just for readabality
-		removed = 0
-		for fixer in fixers
-			break if removed > 0
-			removed += fixer()
-			need_undo = false
-			if prev?
-				if prev_px?
-					new_prev_px = new_cursor_position n: prev, i: prev_i
-					if new_prev_px?
-						if new_prev_px.x isnt prev_px.x or new_prev_px.y isnt prev_px.y
-							need_undo = true
-					else
-						need_undo = true
-				else
-					console.log "this shouldn't happen, we remove spaces that don't locate"
-			if next? and not need_undo
-				if next_px?
-					new_next_px = new_cursor_position n: next, i: next_i
-					if new_next_px?
-						if new_next_px.x isnt next_px.x or new_next_px.y isnt next_px.y
-							need_undo = true
-					else
-						need_undo = true
-				#else
-				#	console.log "removing space becase space after it is collapsed"
-			if need_undo
-				removed += fixer undo_arg
-		if removed > 0
-			return true
-		else
-			return false
-	# pass null at start/end of display:block
-	queue = (n, i) ->
-		next = n
-		next_i = i
-		next_px = null
-		advance = true
-		if cur?
-			removed = operate()
-			# don't advance (to the next character next time) if we removed a
-			# character from the same text node as ``next``, because doing so
-			# renumbers the indexes in that string
-			if removed and cur is next
-				advance = false
-		else
-			removed = false
-		unless removed
-			prev = cur
-			prev_i = cur_i
-			prev_px = cur_px
-		cur = next
-		cur_i = next_i
-		cur_px = next_px
-		return advance
-	queue null
-	iterate tree, queue
-	queue null
-
-	tree_remove_empty_text_nodes(tree)
-
 class PeachHTML5Editor
 	# Options: (all optional)
 	#   editor_id: "id" attribute for outer-most element created by/for editor
@@ -949,15 +788,22 @@ class PeachHTML5Editor
 				return false
 			when KEY_DELETE
 				return false unless @cursor?
-				return false unless @cursor.i < @cursor.n.text.length
-				@remove_character @cursor.n, @cursor.i
-				@text_cleanup @cursor.n
-				@changed()
-				new_cursor = new_cursor_position n: @cursor.n, i: @cursor.i
+				new_cursor = find_next_cursor_position @tree, n: @cursor.n, i: @cursor.i
+				# try moving cursor right and then running backspace code
+				# TODO replace this hack with a real implementation
 				if new_cursor?
-					@move_cursor new_cursor
-				else
-					@kill_cursor()
+					# try to detect common case where cursor goes inside an block,
+					# but doesn't pass a character (and advance one more in that case)
+					if new_cursor.n isnt @cursor.n and new_cursor.i is 0
+						if new_cursor.n.type is 'text' and new_cursor.n.text.length > 0
+							if new_cursor.n.parent?
+								unless @is_display_block new_cursor.n.parent
+									# FIXME should test run sibling
+									new_cursor = new_cursor_position n: new_cursor.n, i: new_cursor.i + 1
+				if new_cursor?
+					if new_cursor.n isnt @cursor.n or new_cursor.i isnt @cursor.i
+						@move_cursor new_cursor
+						@on_key_backspace e
 				return false
 			when KEY_ENTER
 				@on_key_enter e
@@ -1050,13 +896,13 @@ class PeachHTML5Editor
 	# that are flowing/wrapping together. n can be the containing block, or any
 	# element inside it.
 	get_text_run: (n) ->
+		ret = []
 		if @is_display_block n
 			block = n
 		else
 			block = @find_block_parent n
-			return unless block?
-		ret = []
-		traverse_tree n.children, (n) =>
+			return ret unless block?
+		traverse_tree block.children, (n) =>
 			if n.type is 'text'
 				ret.push n
 			else if n.type is 'tag'
@@ -1068,135 +914,179 @@ class PeachHTML5Editor
 						ret.push n
 			return false # not done traversing
 		return ret
+	node_is_decendant: (young, old) ->
+		while young? and young != @tree_parent
+			return true if young is old
+			young = young.parent
+		return false
+	# helper for on_key_backspace
+	_merge_left: (state) ->
+		# the node prev to n was not prev to it a moment ago, merge with it if reasonable
+		pi = state.n.parent.children.indexOf(state.n)
+		if pi > 0
+			prev = state.n.parent.children[pi - 1]
+			if prev.type is 'text'
+				state.i = prev.text.length
+				prev.text = prev.el.textContent = prev.text + state.n.text
+				@remove_node state.n
+				state.n = prev
+				state.changed = true
+				state.moved_cursor = true
+		# else # TODO merge possible consecutive matching inline tags at @cursor
+		return state
+	# helper for on_key_backspace
+	# remove n from the dom, also remove its inline parents that are emptied by removing n
+	_backspace_node_helper: (n, run = @get_text_run(n), run_i = run.indexOf(n)) ->
+		block = @find_block_parent n
+		# delete text node
+		@remove_node n
+		# delete any inline parents
+		n = n.parent
+		while n? and n isnt block
+			# bail if the previous node in this run is also inside the same parent
+			if run_i > 0
+				break if @node_is_decendant run[run_i - 1], n
+			# bail if the next node in this run is also inside the same parent
+			if run_i + 1 < run.length
+				break if @node_is_decendant run[run_i + 1], n
+			# move any sibling nodes to parent. These nodes are not in the text run
+			while n.children.length > 0
+				@move_node n.children[0], n.parent, n
+			# remove (now completely empty) inline parent
+			@remove_node n
+			# proceed to outer parent
+			n = n.parent
+		return
 	on_key_backspace: (e) ->
-		return false unless @cursor?
-		if @is_lone_space @cursor.n # false if it's not in a tag
-			if @cursor.i is 1
-				# don't delete the space, because then it would collapse
-				# instead leave a space after the cursor
-				new_cursor = new_cursor_position n: @cursor.n, i: 0
-				if new_cursor?
-					@move_cursor new_cursor
-				else
-					@kill_cursor()
-			else
-				# cursor at the begining of an element that contains only a space
-				parent = @cursor.n.parent
-				new_cursor = find_prev_cursor_position @tree, @cursor
-				if new_cursor?
-					if new_cursor.n is @cursor.n or new_cursor.n is parent
-						new_cursor = null
-				tag = @cursor.n.parent
-				if tag is @tree_parent
-					console.log "top-level text not supported" # FIXME
-					return false
-				for n, i in tag.parent.children
-					if n is tag
-						tag.parent.el.removeChild tag.el
-						tag.parent.children.splice i, 1
-						break
-				@changed()
-				if new_cursor?
-					# re-check, in case it moved or is invalid now
-					new_cursor = new_cursor_position n: new_cursor.n, i: new_cursor.i
+		return unless @cursor?
+		new_cursor = null
+		run = null
+		changed = true
+		if @cursor.i is 0 # cursor is at start of text node
+			run ?= @get_text_run @cursor.n
+			run_i = run.indexOf(@cursor.n)
+			if run_i is 0 # if at start of text run
+				block = @find_block_parent @cursor.n
+				prev_cursor = find_prev_cursor_position @tree, n: @cursor.n, i: 0
+				if prev_cursor is null # if in first text run of document
+					# do nothing (there's nothing text-like to the left of the cursor)
+					return
+				# else merge with prev/outer text run
+				pcb = @find_block_parent prev_cursor.n
+				while block.children.length > 0
+					@move_node block.children[0], pcb
+				@remove_node block
+				# merge possible consecutive text nodes at @cursor
+				merge_state = n: @cursor.n
+				@_merge_left merge_state
+				@text_cleanup merge_state.n
+				new_cursor = new_cursor_position n: merge_state.n, i: merge_state.i
+			else # at start of text node, but not start of text run
+				prev = run[run_i - 1]
+				if prev.type is 'text' # if previous in text run is text
+					if prev.text.length is 1 # if emptying prev (in text run)
+						@_backspace_node_helper prev, run, run_i
+						merge_state = n: @cursor.n, i: @cursor.i
+						@_merge_left merge_state
+						@text_cleanup merge_state.n
+						new_cursor = new_cursor_position n: merge_state.n, i: merge_state.i
+					else # prev in run is text with muliple chars
+						# delete last character in prev
+						prev.text = prev.text.substr(0, prev.text.length - 1)
+						prev.el.textContent = prev.text
+						@text_cleanup @cursor.n
+						new_cursor = new_cursor_position n: @cursor.n, i: @cursor.i
+				else if prev.name is 'br' or prev.name is 'hr'
+					@_backspace_node_helper prev, run, run_i
+					merge_state = n: @cursor.n, i: @cursor.i
+					@_merge_left merge_state
+					@text_cleanup merge_state.n
+					new_cursor = new_cursor_position n: merge_state.n, i: merge_state.i
+				# FIXME implement this:
+				# else # if prev (in run) is inline-block
+					# if that inline-block has text in it
+						# delete last char in prev inlineblock
+						# if that empties it
+							# delete it
+							# merge left
+						# else
+							# move cursor inside
+					# else
+						# delete prev (inline) block
+						# merge left
+					# auto-delete this @cursor.parent(s) if this empties them
+		else # cursor is not at start of text node
+			run ?= @get_text_run @cursor.n
+			if @cursor.n.text.length is 1 # if emptying text node
+				if run.length is 1 # if emptying text run (of text/br/hr/inline-block)
+					# remove inline-parents of @cursor.n
+					block = @find_block_parent @cursor.n
+					changed = false
+					n = @cursor.n.parent
+					# note: this doesn't use _backspace_node_helper because:
+					# 1. we don't want to delete the target node (we're replacing it's contents)
+					# 2. we want to track whether anything was removed
+					# 3. we know already know there's no other text from this run anywhere
+					while n and n isnt block
+						changed = true
+						while n.children.length > 0
+							@move_node n.children[0], n.parent, n
+						@remove_node n
+						n = n.parent
+					# replace @cursor.n with a single (preserved) space
+					if @cursor.n.text != ' '
+						changed = true
+						@cursor.n.text = @cursor.n.el.textContent = ' '
+					if changed
+						@text_cleanup @cursor.n
+					# place the cursor to the left of that space
+					new_cursor = new_cursor_position n: @cursor.n, i: 0
+				else # emptying a text node (but not a whole text run)
+					# figure out where cursor should land
+					block = @find_block_parent @cursor.n
+					new_cursor = find_prev_cursor_position @tree, n: @cursor.n, i: 0
+					ncb = @find_block_parent new_cursor.n
+					if ncb isnt block
+						new_cursor = find_next_cursor_position @tree, n: @cursor.n, i: 1
+					# delete text node and cleanup emptied parents
+					run_i = run.indexOf @cursor.n
+					@_backspace_node_helper @cursor.n, run, run_i
+					# see if new adjacent siblings should merge
+					# TODO make smarter
+					if run_i > 0 and run_i + 1 < run.length
+						if run[run_i - 1].type is 'text' and run[run_i + 1].type is 'text'
+							merge_state = n: run[run_i + 1]
+							@_merge_left merge_state
+							if merge_state.moved_cursor
+								new_cursor = merge_state
+					# update whitespace preservation
+					@text_cleanup(block)
+					# update cursor x/y in case things moved around
 					if new_cursor?
-						@move_cursor new_cursor
-						return
-				new_cursor = first_cursor_position @tree
-				if new_cursor?
-					@move_cursor new_cursor
-				else
-					@kill_cursor
-				return
-		else if @cursor.i is 0 # start of text chunk
-			# FIXME clean this up: use new code for text runs
-			# FIXME handle backspacing a <br> even if it's near a inline tag boundary
-			# determine if cursor is at start of text run (text formatted inline)
-			block = @find_block_parent @cursor.n
-			return unless block
-			at_block_start = true
-			prev_pos = find_prev_cursor_position @tree, @cursor
-			unless prev_pos?
-				# if the cursor can't go back, then there's probably nowhere we can merge into
-				# TODO consider case of nested blocks. should backspace remove one?
-				return
-			prev_pos_block = @find_block_parent prev_pos.n
-			if prev_pos_block is block
-				# context: there is text before the cursor within the same block.
-				# FIXME clean up this hack for looking for <br> (see above)
-				cursor_text_pi = @cursor.n.parent.children.indexOf @cursor.n
-				if cursor_text_pi > 0
-					prev_node = @cursor.n.parent.children[cursor_text_pi - 1]
-					if prev_node.type is 'tag' and prev_node.name is 'br'
-						@remove_node prev_node
-						@text_cleanup @cursor.n.parent
-						@changed()
-						new_cursor = new_cursor_position n: prev_pos.n, i: prev_pos.i
-						if new_cursor?
-							@move_cursor new_cursor
+						if new_cursor.n.el.parentNode # still in dom after cleanup
+							new_cursor = new_cursor_position n: new_cursor.n, i: new_cursor.i
 						else
-							@kill_cursor
-						return
-				# note: find_prev_cursor_position just crossed a boundary, not a character
-				# prev_pos is within the same block, try deleting there
-				@move_cursor prev_pos
-				# FIXME cleanup: don't call @move_cursor twice if the next line succeeds
-				return @on_key_backspace()
-			# context: backspace pressed at start of a display:block
-			return if block is @tree_parent # top level text
-			parent = block.parent
-			parent_i = parent.children.indexOf block
-			if parent_i is -1
-				throw "BUG #98270918347"
-				return
-			if parent_i is 0
-				# no previous sibling to merge into, so instead move contents into parent
-				dest = parent
-				before = block
-			else
-				# FIXME prev_sib should be the previous in-flow element
-				# ie it should skip comments, hidden things, floating things, etc.
-				prev_sib = parent.children[parent_i - 1]
-				if @is_display_block prev_sib
-					dest = prev_sib
-					before = null # null means append
-				else
-					dest = parent
-					before = block
-			if dest is @tree_parent
-				# don't remove outer-most blocks
-				return
-			while block.children.length > 0
-				n = block.children[block.children.length - 1]
-				@move_node n, dest, before
-				before = n
-			@remove_node block
-			@text_cleanup dest
+							new_cursor = null
+			else # there's a char left of cursor that we can delete without emptying anything
+				# delete character
+				need_text_cleanup = true
+				if @cursor.i > 1 and @cursor.i < @cursor.n.text.length
+					pre = @cursor.n.text.substr(@cursor.i - 2, 3)
+					post = pre.charAt(0) + pre.charAt(2)
+					if str_has_ws_run(pre) is str_has_ws_run(post)
+						need_text_cleanup = false
+				@remove_character(@cursor.n, @cursor.i - 1)
+				# call text_cleanup if whe created/removed a whitespace run
+				if need_text_cleanup
+					@text_cleanup @cursor.n
+				new_cursor = new_cursor_position n: @cursor.n, i: @cursor.i - 1
+		# mark document changed and move the cursor
+		if changed?
 			@changed()
-			new_cursor = new_cursor_position n: prev_pos.n, i: prev_pos.i
-			if new_cursor?
-				@move_cursor new_cursor
-			else
-				@kill_cursor
-			return
+		if new_cursor?
+			@move_cursor new_cursor
 		else
-			# TODO handle case of removing last char
-			# CONTINUE
-			if @is_only_char_in_tag @cursor.n
-				if @is_display_block @cursor.n.parent
-					@cursor.n.el.textContent = @cursor.n.text = ' '
-				else
-					console.log "unimplemented: delete last char in inline" # FIXME
-					return
-			else
-				@remove_character @cursor.n, @cursor.i - 1
-			@text_cleanup @cursor.n
-			@changed()
-			new_cursor = new_cursor_position n: @cursor.n, i: @cursor.i - 1
-			if new_cursor?
-				@move_cursor new_cursor
-			else
-				@kill_cursor()
+			@kill_cursor()
 		return
 	on_page_up_key: (e) ->
 		if @wrap2.scrollTop is 0
@@ -1294,7 +1184,7 @@ class PeachHTML5Editor
 		@tree_parent.el = @idoc.body
 		@clear_dom()
 		instantiate_tree @tree, @tree_parent.el
-		tree_dedup_space @tree
+		@collapse_whitespace @tree
 		@changed()
 	changed: ->
 		@in_el.onchange = null
@@ -1311,28 +1201,6 @@ class PeachHTML5Editor
 		h = parseInt(@idoc.body.scrollHeight, 10)
 		@iframe.style.height = "#{h}px"
 		@wrap2.scrollTop = s
-	# does this node have whitespace that would be collapsed by white-space: normal?
-	# note: this checks direct text children, and does _not_ recurse into child tags
-	# tag is a node with type:"tag"
-	# FIXME use new textrun api
-	has_collapsable_space: (tag) ->
-		for n in tag.children
-			if n.type is 'text'
-				for i in [0...n.text.length]
-					code = n.text.charCodeAt i
-					if code isnt 32 and is_space_code code
-						# tab, return
-						return true
-					# check for double spaces that don't surround insert location
-					continue if i is 0
-					if n.text.substr(i - 1, 2) is '  '
-						return true
-				if n.text.length > 0
-					if is_space_code n.text.charCodeAt 0
-						return true
-					if is_space_code n.text.charCodeAt n.text.length - 1
-						return true
-		return false
 	# true if n is text node with only one caracter, and the only child of a tag
 	is_only_char_in_tag: (n, i) ->
 		return false unless n.type is 'text'
@@ -1407,10 +1275,175 @@ class PeachHTML5Editor
 		else
 			if n.attrs.style?
 				delete n.attrs.style
+	# remove whitespace that would be trimmed
+	# replace whitespace that would collapse with a single space
+	# FIXME remove whitespace from after <br> (but not before)
+	# FIXME rewrite to
+	#     check computed white-space prop on txt parents
+	#     batch replace txt node contents (ie don't loop for each char)
+	collapse_whitespace: (tree = @tree) ->
+		prev = cur = next = null
+		prev_i = cur_i = next_i = 0
+		prev_pos = pos = next_pos = null
+		prev_px = cur_px = next_px = null
+		first = true
+		removed_char = null
+
+		tree_remove_empty_text_nodes(tree)
+
+		iterate = (tree, cb) ->
+			for n in tree
+				if n.type is 'text'
+					i = 0
+					while i < n.text.length # don't foreach, cb might remove chars
+						advance = cb n, i
+						if advance
+							i += 1
+				if n.type is 'tag'
+					block = is_display_block n.el
+					if block
+						cb null
+					if n.children.length > 0
+						iterate n.children, cb
+					if block
+						cb null
+		# remove cur char
+		remove = (undo) ->
+			if undo
+				cur.el.textContent = cur.text = (cur.text.substr 0, cur_i) + removed_char + (cur.text.substr cur_i)
+				if next is cur # in same text node
+					next_i += 1
+				return -1
+			else
+				removed_char = cur.text.charAt(cur_i)
+				cur.el.textContent = cur.text = (cur.text.substr 0, cur_i) + (cur.text.substr cur_i + 1)
+				if next is cur # in same text node
+					if next_i is 0
+						throw "how is this possible?"
+					next_i -= 1
+				return 1
+		replace_with_space = (undo) ->
+			if undo
+				cur.text = (cur.text.substr 0, cur_i) + removed_char + (cur.text.substr cur_i + 1)
+				cur.el.textContent = cur.text
+			else
+				removed_char = cur.text.charAt(cur_i)
+				if removed_char isnt ' '
+					cur.text = (cur.text.substr 0, cur_i) + ' ' + (cur.text.substr cur_i + 1)
+					cur.el.textContent = cur.text
+			return 0
+		# return true if cur was removed from the dom (ie re-use same prev)
+		operate = ->
+			# cur definitately set
+			# prev and/or next might be null, indicating the start/end of a display:block
+			return false unless is_space_code cur.text.charCodeAt cur_i
+			fixers = [remove, replace_with_space]
+			# check for common case: single whitespace surrounded by non-whitespace chars
+			if prev? and next?
+				unless (is_space_code prev.text.charCodeAt prev_i) or (is_space_code next.text.charCodeAt next_i)
+					dbg = cur.text.charCodeAt cur_i
+					if cur.text.charAt(cur_i) is ' ' # perens required
+						# single space can't collapse, doesn't need fixin'
+						return false
+					else
+						# tab, newline, etc, can't collapse, but maybe should be replaced
+						fixers = [replace_with_space]
+			bounds = text_range_bounds cur.el, cur_i, cur_i + 1
+			# consistent cases:
+			# 1. zero rects returned by getClientRects() means collapsed space
+			if bounds is null
+				return remove()
+			# 2. width greater than zero means visible space
+			if bounds.w > 0
+				# has bounds, don't try removing
+				fixers = [replace_with_space]
+			# now the weird edge cases...
+			#
+			# firefox and chromium both report zero width for characters at the end
+			# of a line where the text wraps (automatically, due to word-wrap) to
+			# the next line. These do not appear to be distinguishable from
+			# collapsed spaces via the range/bounds api, so...
+			#
+			# remove it from the dom, and if prev or next moves, put it back.
+			#
+			# this block (try changing it, put it back if something moves) is also
+			# used on collapsable whitespace characters besides space. In this case
+			# the character is replaced with a normal space character instead of
+			# removed
+			if prev? and not prev_px?
+				prev_px = new_cursor_position n: prev, i: prev_i
+			if next? and not next_px?
+				next_px = new_cursor_position n: next, i: next_i
+			#if prev is null and next is null
+			#	parent_px = cur.parent.el.getBoundingClientRect()
+			undo_arg = true # just for readabality
+			removed = 0
+			for fixer in fixers
+				break if removed > 0
+				removed += fixer()
+				need_undo = false
+				if prev?
+					if prev_px?
+						new_prev_px = new_cursor_position n: prev, i: prev_i
+						if new_prev_px?
+							if new_prev_px.x isnt prev_px.x or new_prev_px.y isnt prev_px.y
+								need_undo = true
+						else
+							need_undo = true
+					else
+						console.log "this shouldn't happen, we remove spaces that don't locate"
+				if next? and not need_undo
+					if next_px?
+						new_next_px = new_cursor_position n: next, i: next_i
+						if new_next_px?
+							if new_next_px.x isnt next_px.x or new_next_px.y isnt next_px.y
+								need_undo = true
+						else
+							need_undo = true
+					#else
+					#	console.log "removing space becase space after it is collapsed"
+				if need_undo
+					removed += fixer undo_arg
+			if removed > 0
+				return true
+			else
+				return false
+		# pass null at start/end of display:block
+		queue = (n, i) ->
+			next = n
+			next_i = i
+			next_px = null
+			advance = true
+			if cur?
+				removed = operate()
+				# don't advance (to the next character next time) if we removed a
+				# character from the same text node as ``next``, because doing so
+				# renumbers the indexes in that string
+				if removed and cur is next
+					advance = false
+			else
+				removed = false
+			unless removed
+				prev = cur
+				prev_i = cur_i
+				prev_px = cur_px
+			cur = next
+			cur_i = next_i
+			cur_px = next_px
+			return advance
+		queue null
+		iterate tree, queue
+		queue null
+
+		tree_remove_empty_text_nodes(tree)
+		return
 	# call this after you insert or remove inline nodes. It will:
 	#    merge consecutive text nodes
 	#    remove empty text nodes
 	#    adjust white-space property
+	# note: this assumes that all whitespace in text nodes should be displayed
+	# (ie not collapse or be trimmed) and will change the white-space property
+	# as needed to achieve this.
 	text_cleanup: (n) ->
 		if @is_display_block n
 			block = n