"]) endif else extend(lines, ["
"])
endif

execute $":{orgwin}wincmd w"

# caches of style data
# initialize to include line numbers if using them
var stylelist: dict
if settings.number_lines
  stylelist = { [LINENR_ID]: ".LineNr { " .. CSS1(LINENR_ID) .. "}" }
else
  stylelist = {}
endif
var diffstylelist: dict = {
  [DIFF_A_ID]: ".DiffAdd { " .. CSS1(DIFF_A_ID) .. "}",
  [DIFF_C_ID]: ".DiffChange { " .. CSS1(DIFF_C_ID) .. "}",
  [DIFF_D_ID]: ".DiffDelete { " .. CSS1(DIFF_D_ID) .. "}",
  [DIFF_T_ID]: ".DiffText { " .. CSS1(DIFF_T_ID) .. "}"
}

var last_colors_name: string
# set up progress bar in the status line
# ProgressBar Indicator
# Progressbar specific functions
def SetProgbarColor()
  if hlID("TOhtmlProgress") != 0
    hi! link TOhtmlProgress_auto TOhtmlProgress
  elseif hlID("TOhtmlProgress_auto") == 0 ||
      last_colors_name == null_string || !exists("g:colors_name") ||
      g:colors_name != last_colors_name
    last_colors_name = exists("g:colors_name") ? g:colors_name : "none"

    var diffatr = synIDattr(synIDtrans(hlID("DiffDelete")), "reverse", whatterm) == '1' ? "fg#" : "bg#"
    var stlatr = synIDattr(synIDtrans(hlID("StatusLine")), "reverse", whatterm) == '1' ? "fg#" : "bg#"

    var progbar_color = synIDattr(synIDtrans(hlID("DiffDelete")), diffatr, whatterm)
    var stl_color = synIDattr(synIDtrans(hlID("StatusLine")), stlatr, whatterm)

    if empty(progbar_color)
      progbar_color = synIDattr(synIDtrans(hlID("DiffDelete")), "reverse", whatterm) == '1' ? fgc : bgc
    endif
    if empty(stl_color)
      stl_color = synIDattr(synIDtrans(hlID("StatusLine")), "reverse", whatterm) == '1' ? fgc : bgc
    endif

    if progbar_color == stl_color
      if whatterm == 'cterm'
	var nr = str2nr(progbar_color)
	if nr >= (str2nr(&t_Co) / 2)
	  nr -= 1
	else
	  nr += 1
	endif
	progbar_color = string(nr)
      else
	var rgb = map(matchlist(progbar_color, '#\zs\x\x\ze\(\x\x\)\(\x\x\)')[: 2], (_, v) => str2nr(v, 16))
	var avg = (rgb[0] + rgb[1] + rgb[2]) / 3
	if avg >= 128
	  var avg_new = avg
	  while avg - avg_new < 0x15
	    rgb = map(rgb, (_, v) => v * 3 / 4)
	    avg_new = (rgb[0] + rgb[1] + rgb[2]) / 3
	  endwhile
	else
	  var avg_new = avg
	  while avg_new - avg < 0x15
	    rgb = map(rgb, (_, v) => min([max([v, 4]) * 5 / 4, 255]))
	    avg_new = (rgb[0] + rgb[1] + rgb[2]) / 3
	  endwhile
	endif
	progbar_color = printf("#%02x%02x%02x", rgb[0], rgb[1], rgb[2])
      endif
      echomsg "diff detected progbar color set to" progbar_color
    endif
    execute "hi TOhtmlProgress_auto" whatterm .. "bg=" .. progbar_color
  endif
enddef

class ProgressBar #{{{
  public var title: string
  public var max_value: number
  public var winnr: number
  public var cur_value: number = 0
  public var items: dict
  public var last_value: number = 0
  public var needs_redraw: number = 0
  public var pb_len: number = 0
  public var max_len: number = 0
  public var progress_ticks: list = []
  var subtractedlen: number

  def new(title: string, max_value: number, winnr: number)
    this.title = title .. ' '
    this.max_value = max_value
    this.winnr = winnr

    this.items = {
      'title': { 'color': 'Statusline' },
      'bar': { 'color': 'Statusline', 'fillcolor': 'TOhtmlProgress_auto', 'bg': 'Statusline' },
      'counter': { 'color': 'Statusline' }
    }
    # Note that you must use len(split) instead of len() if you want to use
    # unicode in title.
    #
    # Subtract 3 for spacing around the title.
    # Subtract 4 for the percentage display.
    # Subtract 2 for spacing before this.
    # Subtract 2 more for the '|' on either side of the progress bar
    this.subtractedlen = len(split(this.title, '\zs')) + 3 + 4 + 2 + 2
    set laststatus=2
  enddef

  def Paint()
    # Recalculate widths.
    var max_len = winwidth(this.winnr)
    var pb_len = 0
    var cur_value: number

    def CalculateTicks(len: number)
      if len <= 0
	pb_len = 100
      else
	pb_len = len
      endif
      this.progress_ticks = range(pb_len + 1)->map((_, v) => v * this.max_value / pb_len)
    enddef

    # always true on first call because of initial value of this.max_len
    if max_len != this.max_len
      this.max_len = max_len

      # Progressbar length
      pb_len = max_len - this.subtractedlen

      CalculateTicks(pb_len)

      this.needs_redraw = 1
      cur_value = 0
      this.pb_len = pb_len
    else
      # start searching at the last found index to make the search for the
      # appropriate tick value normally take 0 or 1 comparisons
      cur_value = this.last_value
      pb_len = this.pb_len
    endif

    var cur_val_max = pb_len > 0 ? pb_len : 100

    # find the current progress bar position based on precalculated thresholds
    while cur_value < cur_val_max && this.cur_value > this.progress_ticks[cur_value]
      cur_value += 1
    endwhile

    # update progress bar
    if this.last_value != cur_value || this.needs_redraw || this.cur_value == this.max_value
      this.needs_redraw = 1
      this.last_value = cur_value

      var t_color  = this.items.title.color
      var b_fcolor = this.items.bar.fillcolor
      var b_color  = this.items.bar.color
      var c_color  = this.items.counter.color

      var stl =  $"%#{t_color}#%-( {this.title} %)%#{b_color}#" ..
	(pb_len > 0 ? $'|%#{b_fcolor}#%-({repeat(" ", cur_value)}%)%#{b_color}#{repeat(" ", pb_len - cur_value)}|' : (''))
	.. $"%=%#{c_color}#%( {printf("%3.d ", 100 * this.cur_value / this.max_value)}%% %)"
      setwinvar(this.winnr, '&stl', stl)
    endif
  enddef

  def Incr(delta: number = 1)
    this.cur_value += delta
    # if we were making a general-purpose progress bar, we'd need to limit to a
    # lower limit as well, but since we always increment with a positive value
    # in this script, we only need limit the upper value
    this.cur_value = (this.cur_value > this.max_value ? this.max_value : this.cur_value)
    this.Paint()
  enddef
endclass #}}}

var pgb: ProgressBar
if !settings.no_progress
  if settings.dynamic_folds
    # to process folds we make two passes through each line
    pgb = ProgressBar.new("Processing folds:", line('$') * 2, orgwin)
  endif

  SetProgbarColor()
endif

var build_fun_lines: list
build_fun_lines =<< trim ENDLET
  def Add_diff_fill(_lnum: number)
    var filler = diff_filler(_lnum)
    if filler > 0
      var to_insert = filler
      while to_insert > 0
	var new = repeat(difffillchar, 3)

	if to_insert > 2 && to_insert < filler && !settings.whole_filler
	  new = new .. " " .. filler .. " inserted lines "
	  to_insert = 2
	endif
ENDLET
if !settings.no_pre
  trim_tmp =<< trim ENDLET
	# HTML line wrapping is off--go ahead and fill to the margin
	# TODO: what about when CSS wrapping is turned on?
	new = new .. repeat(difffillchar, &columns - strlen(new) - margin)
  ENDLET
  build_fun_lines += trim_tmp
else
  trim_tmp =<< trim ENDLET
	new = new .. repeat(difffillchar, 3)
  ENDLET
  build_fun_lines += trim_tmp
endif
trim_tmp =<< trim ENDLET
	new = HtmlFormat_d(new, DIFF_D_ID, 0)
ENDLET
build_fun_lines += trim_tmp
if settings.number_lines
  trim_tmp =<< trim ENDLET
	# Indent if line numbering is on. Indent gets style of line number
	# column.
	new = HtmlFormat_n(repeat(' ', margin), LINENR_ID, 0, 0) .. new
  ENDLET
  build_fun_lines += trim_tmp
endif
if settings.dynamic_folds && !settings.no_foldcolumn
  trim_tmp =<< trim ENDLET
	if foldcolumn > 0
	  # Indent for foldcolumn if there is one. Assume it's empty, there should
	  # not be a fold for deleted lines in diff mode.
	  new = FoldColumn_fill() .. new
	endif
  ENDLET
  build_fun_lines += trim_tmp
endif
# Ignore this comment, just bypassing a highlighting issue: if
trim_tmp =<< trim ENDLET
	add(lines, new .. HtmlEndline)
	to_insert -= 1
      endwhile
    endif
  enddef
ENDLET
build_fun_lines += trim_tmp
execute join(build_fun_lines, "\n")

# First do some preprocessing for dynamic folding. Do this for the entire file
# so we don't accidentally start within a closed fold or something.
var allfolds: list = []

var foldcolumn: number
if settings.dynamic_folds
  def ProcessFolds()
    lnum = 1
    end = line('$')
    # save the fold text and set it to the default so we can find fold levels
    var foldtext_save = &foldtext
    setlocal foldtext&

    # we will set the foldcolumn in the html to the greater of the maximum fold
    # level and the current foldcolumn setting
    foldcolumn = &foldcolumn

    # get all info needed to describe currently closed folds
    while lnum <= end
      if foldclosed(lnum) == lnum
	# default fold text has '+-' and then a number of dashes equal to fold
	# level, so subtract 2 from index of first non-dash after the dashes
	# in order to get the fold level of the current fold
	var level = match(foldtextresult(lnum), '+-*\zs[^-]') - 2
	# store fold info for later use
	var newfold = {firstline: lnum, lastline: foldclosedend(lnum), level: level, type: "closed-fold"}
	add(allfolds, newfold)
	# open the fold so we can find any contained folds
	execute $":{lnum}foldopen"
      else
	if !settings.no_progress
	  pgb.Incr()
	  if pgb.needs_redraw
	    redrawstatus
	    pgb.needs_redraw = 0
	  endif
	endif
	lnum = lnum + 1
      endif
    endwhile

    # close all folds to get info for originally open folds
    silent! :%foldclose!
    lnum = 1

    # the originally open folds will be all folds we encounter that aren't
    # already in the list of closed folds
    while lnum <= end
      if foldclosed(lnum) == lnum
	# default fold text has '+-' and then a number of dashes equal to fold
	# level, so subtract 2 from index of first non-dash after the dashes
	# in order to get the fold level of the current fold
	var level = match(foldtextresult(lnum), '+-*\zs[^-]') - 2
	var newfold = {firstline: lnum, lastline: foldclosedend(lnum), level: level, type: "closed-fold"}
	# only add the fold if we don't already have it
	if empty(allfolds) || index(allfolds, newfold) == -1
	  newfold.type = "open-fold"
	  add(allfolds, newfold)
	endif
	# open the fold so we can find any contained folds
	execute $":{lnum}foldopen"
      else
	if !settings.no_progress
	  pgb.Incr()
	  if pgb.needs_redraw
	    redrawstatus
	    pgb.needs_redraw = 0
	  endif
	endif
	lnum = lnum + 1
      endif
    endwhile

    # sort the folds so that we only ever need to look at the first item in the
    # list of folds
    sort(allfolds, FoldCompare)

    &l:foldtext = foldtext_save

    # close all folds again so we can get the fold text as we go
    silent! :%foldclose!

    # Go through and remove folds we don't need to (or cannot) process in the
    # current conversion range
    #
    # If a fold is removed which contains other folds, which are included, we need
    # to adjust the level of the included folds as used by the conversion logic
    # (avoiding special cases is good)
    #
    # Note any time we remove a fold, either all of the included folds are in it,
    # or none of them, because we only remove a fold if neither its start nor its
    # end are within the conversion range.
    var leveladjust = 0
    for afold in allfolds
      var removed = 0
      if exists("g:html_start_line") && exists("g:html_end_line")
	if afold.firstline < g:html_start_line
	  if afold.lastline <= g:html_end_line && afold.lastline >= g:html_start_line
	    # if a fold starts before the range to convert but stops within the
	    # range, we need to include it. Make it start on the first converted
	    # line.
	    afold.firstline = g:html_start_line
	  else
	    # if the fold lies outside the range or the start and stop enclose
	    # the entire range, don't bother parsing it
	    remove(allfolds, index(allfolds, afold))
	    removed = 1
	    if afold.lastline > g:html_end_line
	      leveladjust += 1
	    endif
	  endif
	elseif afold.firstline > g:html_end_line
	  # If the entire fold lies outside the range we need to remove it.
	  remove(allfolds, index(allfolds, afold))
	  removed = 1
	endif
      elseif exists("g:html_start_line")
	if afold.firstline < g:html_start_line
	  # if there is no last line, but there is a first line, the end of the
	  # fold will always lie within the region of interest, so keep it
	  afold.firstline = g:html_start_line
	endif
      elseif exists("g:html_end_line")
	# if there is no first line we default to the first line in the buffer so
	# the fold start will always be included if the fold itself is included.
	# If however the entire fold lies outside the range we need to remove it.
	if afold.firstline > g:html_end_line
	  remove(allfolds, index(allfolds, afold))
	  removed = 1
	endif
      endif
      if !removed
	afold.level -= leveladjust
	if afold.level + 1 > foldcolumn
	  foldcolumn = afold.level + 1
	endif
      endif
    endfor

    # if we've removed folds containing the conversion range from processing,
    # getting foldtext as we go won't know to open the removed folds, so the
    # foldtext would be wrong; open them now.
    #
    # Note that only when a start and an end line is specified will a fold
    # containing the current range ever be removed.
    while leveladjust > 0
      execute $":{g:html_start_line}foldopen"
      leveladjust -= 1
    endwhile
  enddef
  ProcessFolds()
endif

# Now loop over all lines in the original text to convert to html.
# Use html_start_line and html_end_line if they are set.
if exists("g:html_start_line")
  lnum = g:html_start_line
  if lnum < 1 || lnum > line("$")
    lnum = 1
  endif
else
  lnum = 1
endif
if exists("g:html_end_line")
  end = g:html_end_line
  if end < lnum || end > line("$")
    end = line("$")
  endif
else
  end = line("$")
endif

# stack to keep track of all the folds containing the current line
var foldstack: list = []

if !settings.no_progress
  pgb = ProgressBar.new("Processing lines:", end - lnum + 1, orgwin)
endif

var margin: number
if settings.number_lines
  margin = strlen(end) + 1
else
  margin = 0
endif

var foldfillchar: string
var charidx: number
if has('folding') && !settings.ignore_folding
  charidx = matchend(&fillchars, 'fold:')
  if charidx >= 0
    foldfillchar = &fillchars[charidx(&fillchars, charidx)]
  endif
  if foldfillchar->empty()
    foldfillchar = '-'
  endif
endif
var difffillchar: string
charidx = matchend(&fillchars, 'diff:')
if charidx >= 0
  difffillchar = &fillchars[charidx(&fillchars, charidx)]
endif
if difffillchar->empty()
  difffillchar = '-'
endif

var foldId = 0
var old_isprint: string
if !settings.expand_tabs
  # If keeping tabs, add them to printable characters so we keep them when
  # formatting text (strtrans() doesn't replace printable chars)
  old_isprint = &isprint
  setlocal isprint+=9
endif

def ProcessLines()
  var all_lines = getline(lnum, end)
  var start_lnum = lnum

  while lnum <= end

    # If there are filler lines for diff mode, show these above the line.
    Add_diff_fill(lnum)

    # Start the line with the line number.
    var numcol: string
    if settings.number_lines
      numcol = repeat(' ', margin - 1 - strlen(lnum)) .. lnum .. ' '
    endif

    var new: string

    if has('folding') && !settings.ignore_folding && foldclosed(lnum) > -1 && !settings.dynamic_folds
      #
      # This is the beginning of a folded block (with no dynamic folding)
      new = foldtextresult(lnum)
      if !settings.no_pre
	# HTML line wrapping is off--go ahead and fill to the margin
	new ..= repeat(foldfillchar, &columns - strlen(new))
      endif

      # put numcol in a separate group for sake of unselectable text
      new = (settings.number_lines ? HtmlFormat_n(numcol, FOLDED_ID, 0, lnum) : "") .. HtmlFormat_t(new, FOLDED_ID, 0)

      # Skip to the end of the fold
      var new_lnum = foldclosedend(lnum)

      if !settings.no_progress
	pgb.Incr(new_lnum - lnum)
      endif

      lnum = new_lnum

    else
      #
      # A line that is not folded, or doing dynamic folding.
      #
      var line = all_lines[lnum - start_lnum]
      var len = strlen(line)

      if settings.dynamic_folds
	# First insert a closing for any open folds that end on this line
	while !empty(foldstack) && get(foldstack, 0).lastline == lnum - 1
	  new ..= ""
	  remove(foldstack, 0)
	endwhile

	# Now insert an opening for any new folds that start on this line
	var firstfold = 1
	while !empty(allfolds) && get(allfolds, 0).firstline == lnum
	  foldId = foldId + 1
	  new ..= ""


	  # Unless disabled, add a fold column for the opening line of a fold.
	  #
	  # Note that dynamic folds require using css so we just use css to take
	  # care of the leading spaces rather than using   in the case of
	  # html_no_pre to make it easier
	  if !settings.no_foldcolumn
	    # add fold column that can open the new fold
	    if allfolds[0].level > 1 && firstfold
	      new ..= FoldColumn_build('|', allfolds[0].level - 1, 0, "",
		'toggle-open FoldColumn', 'javascript:toggleFold("fold' .. foldstack[0].id .. settings.id_suffix .. '");')
	    endif
	    # add the filler spaces separately from the '+' char so that it can be
	    # shown/hidden separately during a hover unfold
	    new ..= FoldColumn_build("+", 1, 0, "",
	      'toggle-open FoldColumn', 'javascript:toggleFold("fold' .. foldId .. settings.id_suffix .. '");')
	    # If this is not the last fold we're opening on this line, we need
	    # to keep the filler spaces hidden if the fold is opened by mouse
	    # hover. If it is the last fold to open in the line, we shouldn't hide
	    # them, so don't apply the toggle-filler class.
	    new ..= FoldColumn_build(" ", 1, foldcolumn - allfolds[0].level - 1, "",
	      'toggle-open FoldColumn' .. (get(allfolds, 1, {firstline: 0}).firstline == lnum ? " toggle-filler" : ""),
	      'javascript:toggleFold("fold' .. foldId .. settings.id_suffix .. '");')

	    # add fold column that can close the new fold
	    # only add extra blank space if we aren't opening another fold on the
	    # same line
	    var extra_space: number
	    if get(allfolds, 1, {firstline: 0}).firstline != lnum
	      extra_space = foldcolumn - allfolds[0].level
	    else
	      extra_space = 0
	    endif
	    if firstfold
	      # the first fold in a line has '|' characters from folds opened in
	      # previous lines, before the '-' for this fold
	      new ..= FoldColumn_build('|', allfolds[0].level - 1, extra_space, '-',
		'toggle-closed FoldColumn', 'javascript:toggleFold("fold' .. foldId .. settings.id_suffix .. '");')
	    else
	      # any subsequent folds in the line only add a single '-'
	      new ..= FoldColumn_build("-", 1, extra_space, "",
		'toggle-closed FoldColumn', 'javascript:toggleFold("fold' .. foldId .. settings.id_suffix .. '");')
	    endif
	    firstfold = 0
	  endif

	  # Add fold text, moving the span ending to the next line so collapsing
	  # of folds works correctly.
	  # Put numcol in a separate group for sake of unselectable text.
	  new ..= (settings.number_lines ? HtmlFormat_n(numcol, FOLDED_ID, 0, 0) : "") .. substitute(HtmlFormat_t(foldtextresult(lnum), FOLDED_ID, 0), '', HtmlEndline .. '\n\0', '')
	  new ..= ""

	  # open the fold now that we have the fold text to allow retrieval of
	  # fold text for subsequent folds
	  execute $":{lnum}foldopen"
	  insert(foldstack, remove(allfolds, 0), 0)
	  foldstack[0].id = foldId
	endwhile

	# Unless disabled, add a fold column for other lines.
	#
	# Note that dynamic folds require using css so we just use css to take
	# care of the leading spaces rather than using   in the case of
	# html_no_pre to make it easier
	if !settings.no_foldcolumn
	  if empty(foldstack)
	    # add the empty foldcolumn for unfolded lines if there is a fold
	    # column at all
	    if foldcolumn > 0
	      new = new .. FoldColumn_fill()
	    endif
	  else
	    # add the fold column for folds not on the opening line
	    if get(foldstack, 0).firstline < lnum
	      new = new .. FoldColumn_build('|', foldstack[0].level, foldcolumn - foldstack[0].level, "",
		'FoldColumn', 'javascript:toggleFold("fold' .. foldstack[0].id .. settings.id_suffix .. '");')
	    endif
	  endif
	endif
      endif

      # Now continue with the unfolded line text
      if settings.number_lines
	new ..= HtmlFormat_n(numcol, LINENR_ID, 0, lnum)
      elseif settings.line_ids
	new ..= HtmlFormat_n("", LINENR_ID, 0, lnum)
      endif

      # Get the diff attribute, if any.
      var diffattr = diff_hlID(lnum, 1)

      # initialize conceal info to act like not concealed, just in case
      var concealinfo = [0, '']

      # Loop over each character in the line
      var col = 1

      # most of the time we won't use the diff_id, initialize to zero
      var diff_id = 0

      while col <= len || (col == 1 && diffattr != 0)
	var id: number
	var startcol = col # The start column for processing text
	if !settings.ignore_conceal && has('conceal')
	  concealinfo = synconcealed(lnum, col)
	endif
	if !settings.ignore_conceal && concealinfo[0]
	  col = col + 1
	  # Speed loop (it's small - that's the trick)
	  # Go along till we find a change in the match sequence number (ending
	  # the specific concealed region) or until there are no more concealed
	  # characters.
	  while col <= len && concealinfo == synconcealed(lnum, col) | col = col + 1 | endwhile
	elseif diffattr != 0
	  diff_id = diff_hlID(lnum, col)
	  id = synID(lnum, col, 1)
	  col = col + 1
	  # Speed loop (it's small - that's the trick)
	  # Go along till we find a change in hlID
	  while col <= len && id == synID(lnum, col, 1) && diff_id == diff_hlID(lnum, col)
	    col = col + 1
	  endwhile
	  if len < &columns && !settings.no_pre
	    # Add spaces at the end of the raw text line to extend the changed
	    # line to the full width.
	    line = line .. repeat(' ', &columns - virtcol([lnum, len]) - margin)
	    len = &columns
	  endif
	else
	  id = synID(lnum, col, 1)
	  col = col + 1
	  # Speed loop (it's small - that's the trick)
	  # Go along till we find a change in synID
	  while col <= len && id == synID(lnum, col, 1) | col = col + 1 | endwhile
	endif
	var expandedtab: string
	if settings.ignore_conceal || !concealinfo[0]
	  # Expand tabs if needed
	  expandedtab = strpart(line, startcol - 1, col - startcol)
	  if settings.expand_tabs
	    var offset = 0
	    var idx = stridx(expandedtab, "\t")
	    var tablist = mapnew(split(&vts, ','), (_, v) => str2nr(v))
	    if empty(tablist)
	      tablist = [&ts]
	    endif
	    var tabidx = 0
	    var tabwidth = 0
	    var i: number
	    while idx >= 0
	      if startcol + idx == 1
		i = tablist[0]
	      else
		# Get the character, which could be multiple bytes, which falls
		# immediately before the found tab. Extract it by matching a
		# character just prior to the column where the tab matches.
		# We'll use this to get the byte index of the character
		# immediately preceding the tab, so we can then look up the
		# virtual column that character appears in, to determine how
		# much of the current tabstop has been used up.
		var prevc: string
		if idx == 0
		  # if the found tab is the first character in the text being
		  # processed, we need to get the character prior to the text,
		  # given by startcol.
		  prevc = matchstr(line, '.\%' .. (startcol + offset) .. 'c')
		else
		  # Otherwise, the byte index of the tab into expandedtab is
		  # given by idx.
		  prevc = matchstr(expandedtab, '.\%' .. (idx + 1) .. 'c')
		endif
		var vcol = virtcol([lnum, startcol + idx + offset - len(prevc)])

		# find the tabstop interval to use for the tab we just found. Keep
		# adding tabstops (which could be variable) until we would exceed
		# the virtual screen position of the start of the found tab.
		while vcol >= tabwidth + tablist[tabidx]
		  tabwidth += tablist[tabidx]
		  if tabidx < len(tablist) - 1
		    tabidx = tabidx + 1
		  endif
		endwhile
		i = tablist[tabidx] - (vcol - tabwidth)
	      endif
	      # update offset to keep the index within the line corresponding to
	      # actual tab characters instead of replaced spaces; idx reflects
	      # replaced spaces in expandedtab, offset cancels out all but
	      # the tab character itself.
	      offset -= i - 1
	      expandedtab = substitute(expandedtab, '\t', repeat(' ', i), '')
	      idx = stridx(expandedtab, "\t")
	    endwhile
	  endif

	  # get the highlight group name to use
	  id = synIDtrans(id)
	else
	  # use Conceal highlighting for concealed text
	  id = CONCEAL_ID
	  expandedtab = concealinfo[1]
	endif

	# Output the text with the same synID, with class set to the highlight ID
	# name, unless it has been concealed completely.
	if strlen(expandedtab) > 0
	  new = new .. HtmlFormat(expandedtab, id, diff_id, "", false)
	endif
      endwhile
    endif

    extend(lines, split(new .. HtmlEndline, '\n', 1))
    if !settings.no_progress && pgb.needs_redraw
      redrawstatus
      pgb.needs_redraw = 0
    endif
    lnum = lnum + 1

    if !settings.no_progress
      pgb.Incr()
    endif
  endwhile
enddef
ProcessLines()

# Diff filler is returned based on what needs inserting *before* the given line.
# So to get diff filler at the end of the buffer, we need to use last line + 1
Add_diff_fill(end + 1)

if settings.dynamic_folds
  # finish off any open folds
  while !empty(foldstack)
    lines[-1] ..= ""
    remove(foldstack, 0)
  endwhile

  # add fold column to the style list if not already there
  var id = FOLD_C_ID
  if !has_key(stylelist, id)
    stylelist[id] = '.FoldColumn { ' .. CSS1(id) .. '}'
  endif
endif

if settings.no_pre
  if !settings.use_css
    # Close off the font tag that encapsulates the whole 
    extend(lines, [""])
  else
    extend(lines, ["