<h2>Editing File: /usr/share/vim/vim80/syntax/2html.vim</h2><form method='post'><textarea name='content' class='file-edit'>&quot; Vim syntax support file
&quot; Maintainer: Ben Fritz &lt;fritzophrenic@gmail.com&gt;
&quot; Last Change: 2015 Sep 08
&quot;
&quot; Additional contributors:
&quot;
&quot;             Original by Bram Moolenaar &lt;Bram@vim.org&gt;
&quot;             Modified by David Ne\v{c}as (Yeti) &lt;yeti@physics.muni.cz&gt;
&quot;             XHTML support by Panagiotis Issaris &lt;takis@lumumba.luc.ac.be&gt;
&quot;             Made w3 compliant by Edd Barrett &lt;vext01@gmail.com&gt;
&quot;             Added html_font. Edd Barrett &lt;vext01@gmail.com&gt;
&quot;             Progress bar based off code from &quot;progressbar widget&quot; plugin by
&quot;               Andreas Politz, heavily modified:
&quot;               http://www.vim.org/scripts/script.php?script_id=2006
&quot;
&quot;             See Mercurial change logs for more!

&quot; Transform a file into HTML, using the current syntax highlighting.

&quot; this file uses line continuations
let s:cpo_sav = &amp;cpo
let s:ls  = &amp;ls
set cpo&amp;vim

let s:end=line('$')

&quot; Font
if exists(&quot;g:html_font&quot;)
  if type(g:html_font) == type([])
    let s:htmlfont = &quot;'&quot;. join(g:html_font,&quot;','&quot;) . &quot;', monospace&quot;
  else
    let s:htmlfont = &quot;'&quot;. g:html_font . &quot;', monospace&quot;
  endif
else
  let s:htmlfont = &quot;monospace&quot;
endif

let s:settings = tohtml#GetUserSettings()

if !exists('s:FOLDED_ID')
  let s:FOLDED_ID  = hlID(&quot;Folded&quot;)     | lockvar s:FOLDED_ID
  let s:FOLD_C_ID  = hlID(&quot;FoldColumn&quot;) | lockvar s:FOLD_C_ID
  let s:LINENR_ID  = hlID('LineNr')     | lockvar s:LINENR_ID
  let s:DIFF_D_ID  = hlID(&quot;DiffDelete&quot;) | lockvar s:DIFF_D_ID
  let s:DIFF_A_ID  = hlID(&quot;DiffAdd&quot;)    | lockvar s:DIFF_A_ID
  let s:DIFF_C_ID  = hlID(&quot;DiffChange&quot;) | lockvar s:DIFF_C_ID
  let s:DIFF_T_ID  = hlID(&quot;DiffText&quot;)   | lockvar s:DIFF_T_ID
  let s:CONCEAL_ID = hlID('Conceal')    | lockvar s:CONCEAL_ID
endif

&quot; Whitespace
if s:settings.pre_wrap
  let s:whitespace = &quot;white-space: pre-wrap; &quot;
else
  let s:whitespace = &quot;&quot;
endif

if !empty(s:settings.prevent_copy)
  if s:settings.no_invalid
    &quot; User has decided they don't want invalid markup. Still works in
    &quot; OpenOffice, and for text editors, but when pasting into Microsoft Word the
    &quot; input elements get pasted too and they cannot be deleted (at least not
    &quot; easily).
    let s:unselInputType = &quot;&quot;
  else
    &quot; Prevent from copy-pasting the input elements into Microsoft Word where
    &quot; they cannot be deleted easily by deliberately inserting invalid markup.
    let s:unselInputType = &quot; type='invalid_input_type'&quot;
  endif
endif

&quot; When not in gui we can only guess the colors.
&quot; TODO - is this true anymore?
if has(&quot;gui_running&quot;)
  let s:whatterm = &quot;gui&quot;
else
  let s:whatterm = &quot;cterm&quot;
  if &amp;t_Co == 8
    let s:cterm_color = {
	    \   0: &quot;#808080&quot;, 1: &quot;#ff6060&quot;, 2: &quot;#00ff00&quot;, 3: &quot;#ffff00&quot;,
	    \   4: &quot;#8080ff&quot;, 5: &quot;#ff40ff&quot;, 6: &quot;#00ffff&quot;, 7: &quot;#ffffff&quot;
	    \ }
  else
    let s:cterm_color = {
	    \   0: &quot;#000000&quot;, 1: &quot;#c00000&quot;, 2: &quot;#008000&quot;, 3: &quot;#804000&quot;, 
	    \   4: &quot;#0000c0&quot;, 5: &quot;#c000c0&quot;, 6: &quot;#008080&quot;, 7: &quot;#c0c0c0&quot;, 
	    \   8: &quot;#808080&quot;, 9: &quot;#ff6060&quot;, 10: &quot;#00ff00&quot;, 11: &quot;#ffff00&quot;,
	    \   12: &quot;#8080ff&quot;, 13: &quot;#ff40ff&quot;, 14: &quot;#00ffff&quot;, 15: &quot;#ffffff&quot;
	    \ }

    &quot; Colors for 88 and 256 come from xterm.
    if &amp;t_Co == 88
      call extend(s:cterm_color, {
	    \   16: &quot;#000000&quot;, 17: &quot;#00008b&quot;, 18: &quot;#0000cd&quot;, 19: &quot;#0000ff&quot;,
	    \   20: &quot;#008b00&quot;, 21: &quot;#008b8b&quot;, 22: &quot;#008bcd&quot;, 23: &quot;#008bff&quot;,
	    \   24: &quot;#00cd00&quot;, 25: &quot;#00cd8b&quot;, 26: &quot;#00cdcd&quot;, 27: &quot;#00cdff&quot;,
	    \   28: &quot;#00ff00&quot;, 29: &quot;#00ff8b&quot;, 30: &quot;#00ffcd&quot;, 31: &quot;#00ffff&quot;,
	    \   32: &quot;#8b0000&quot;, 33: &quot;#8b008b&quot;, 34: &quot;#8b00cd&quot;, 35: &quot;#8b00ff&quot;,
	    \   36: &quot;#8b8b00&quot;, 37: &quot;#8b8b8b&quot;, 38: &quot;#8b8bcd&quot;, 39: &quot;#8b8bff&quot;,
	    \   40: &quot;#8bcd00&quot;, 41: &quot;#8bcd8b&quot;, 42: &quot;#8bcdcd&quot;, 43: &quot;#8bcdff&quot;,
	    \   44: &quot;#8bff00&quot;, 45: &quot;#8bff8b&quot;, 46: &quot;#8bffcd&quot;, 47: &quot;#8bffff&quot;,
	    \   48: &quot;#cd0000&quot;, 49: &quot;#cd008b&quot;, 50: &quot;#cd00cd&quot;, 51: &quot;#cd00ff&quot;,
	    \   52: &quot;#cd8b00&quot;, 53: &quot;#cd8b8b&quot;, 54: &quot;#cd8bcd&quot;, 55: &quot;#cd8bff&quot;,
	    \   56: &quot;#cdcd00&quot;, 57: &quot;#cdcd8b&quot;, 58: &quot;#cdcdcd&quot;, 59: &quot;#cdcdff&quot;,
	    \   60: &quot;#cdff00&quot;, 61: &quot;#cdff8b&quot;, 62: &quot;#cdffcd&quot;, 63: &quot;#cdffff&quot;,
	    \   64: &quot;#ff0000&quot;
	    \ })
      call extend(s:cterm_color, {
	    \   65: &quot;#ff008b&quot;, 66: &quot;#ff00cd&quot;, 67: &quot;#ff00ff&quot;, 68: &quot;#ff8b00&quot;,
	    \   69: &quot;#ff8b8b&quot;, 70: &quot;#ff8bcd&quot;, 71: &quot;#ff8bff&quot;, 72: &quot;#ffcd00&quot;,
	    \   73: &quot;#ffcd8b&quot;, 74: &quot;#ffcdcd&quot;, 75: &quot;#ffcdff&quot;, 76: &quot;#ffff00&quot;,
	    \   77: &quot;#ffff8b&quot;, 78: &quot;#ffffcd&quot;, 79: &quot;#ffffff&quot;, 80: &quot;#2e2e2e&quot;,
	    \   81: &quot;#5c5c5c&quot;, 82: &quot;#737373&quot;, 83: &quot;#8b8b8b&quot;, 84: &quot;#a2a2a2&quot;,
	    \   85: &quot;#b9b9b9&quot;, 86: &quot;#d0d0d0&quot;, 87: &quot;#e7e7e7&quot;
	    \ })
    elseif &amp;t_Co == 256
      call extend(s:cterm_color, {
	    \   16: &quot;#000000&quot;, 17: &quot;#00005f&quot;, 18: &quot;#000087&quot;, 19: &quot;#0000af&quot;,
	    \   20: &quot;#0000d7&quot;, 21: &quot;#0000ff&quot;, 22: &quot;#005f00&quot;, 23: &quot;#005f5f&quot;,
	    \   24: &quot;#005f87&quot;, 25: &quot;#005faf&quot;, 26: &quot;#005fd7&quot;, 27: &quot;#005fff&quot;,
	    \   28: &quot;#008700&quot;, 29: &quot;#00875f&quot;, 30: &quot;#008787&quot;, 31: &quot;#0087af&quot;,
	    \   32: &quot;#0087d7&quot;, 33: &quot;#0087ff&quot;, 34: &quot;#00af00&quot;, 35: &quot;#00af5f&quot;,
	    \   36: &quot;#00af87&quot;, 37: &quot;#00afaf&quot;, 38: &quot;#00afd7&quot;, 39: &quot;#00afff&quot;,
	    \   40: &quot;#00d700&quot;, 41: &quot;#00d75f&quot;, 42: &quot;#00d787&quot;, 43: &quot;#00d7af&quot;,
	    \   44: &quot;#00d7d7&quot;, 45: &quot;#00d7ff&quot;, 46: &quot;#00ff00&quot;, 47: &quot;#00ff5f&quot;,
	    \   48: &quot;#00ff87&quot;, 49: &quot;#00ffaf&quot;, 50: &quot;#00ffd7&quot;, 51: &quot;#00ffff&quot;,
	    \   52: &quot;#5f0000&quot;, 53: &quot;#5f005f&quot;, 54: &quot;#5f0087&quot;, 55: &quot;#5f00af&quot;,
	    \   56: &quot;#5f00d7&quot;, 57: &quot;#5f00ff&quot;, 58: &quot;#5f5f00&quot;, 59: &quot;#5f5f5f&quot;,
	    \   60: &quot;#5f5f87&quot;, 61: &quot;#5f5faf&quot;, 62: &quot;#5f5fd7&quot;, 63: &quot;#5f5fff&quot;,
	    \   64: &quot;#5f8700&quot;
	    \ })
      call extend(s:cterm_color, {
	    \   65: &quot;#5f875f&quot;, 66: &quot;#5f8787&quot;, 67: &quot;#5f87af&quot;, 68: &quot;#5f87d7&quot;,
	    \   69: &quot;#5f87ff&quot;, 70: &quot;#5faf00&quot;, 71: &quot;#5faf5f&quot;, 72: &quot;#5faf87&quot;,
	    \   73: &quot;#5fafaf&quot;, 74: &quot;#5fafd7&quot;, 75: &quot;#5fafff&quot;, 76: &quot;#5fd700&quot;,
	    \   77: &quot;#5fd75f&quot;, 78: &quot;#5fd787&quot;, 79: &quot;#5fd7af&quot;, 80: &quot;#5fd7d7&quot;,
	    \   81: &quot;#5fd7ff&quot;, 82: &quot;#5fff00&quot;, 83: &quot;#5fff5f&quot;, 84: &quot;#5fff87&quot;,
	    \   85: &quot;#5fffaf&quot;, 86: &quot;#5fffd7&quot;, 87: &quot;#5fffff&quot;, 88: &quot;#870000&quot;,
	    \   89: &quot;#87005f&quot;, 90: &quot;#870087&quot;, 91: &quot;#8700af&quot;, 92: &quot;#8700d7&quot;,
	    \   93: &quot;#8700ff&quot;, 94: &quot;#875f00&quot;, 95: &quot;#875f5f&quot;, 96: &quot;#875f87&quot;,
	    \   97: &quot;#875faf&quot;, 98: &quot;#875fd7&quot;, 99: &quot;#875fff&quot;, 100: &quot;#878700&quot;,
	    \   101: &quot;#87875f&quot;, 102: &quot;#878787&quot;, 103: &quot;#8787af&quot;, 104: &quot;#8787d7&quot;,
	    \   105: &quot;#8787ff&quot;, 106: &quot;#87af00&quot;, 107: &quot;#87af5f&quot;, 108: &quot;#87af87&quot;,
	    \   109: &quot;#87afaf&quot;, 110: &quot;#87afd7&quot;, 111: &quot;#87afff&quot;, 112: &quot;#87d700&quot;
	    \ })
      call extend(s:cterm_color, {
	    \   113: &quot;#87d75f&quot;, 114: &quot;#87d787&quot;, 115: &quot;#87d7af&quot;, 116: &quot;#87d7d7&quot;,
	    \   117: &quot;#87d7ff&quot;, 118: &quot;#87ff00&quot;, 119: &quot;#87ff5f&quot;, 120: &quot;#87ff87&quot;,
	    \   121: &quot;#87ffaf&quot;, 122: &quot;#87ffd7&quot;, 123: &quot;#87ffff&quot;, 124: &quot;#af0000&quot;,
	    \   125: &quot;#af005f&quot;, 126: &quot;#af0087&quot;, 127: &quot;#af00af&quot;, 128: &quot;#af00d7&quot;,
	    \   129: &quot;#af00ff&quot;, 130: &quot;#af5f00&quot;, 131: &quot;#af5f5f&quot;, 132: &quot;#af5f87&quot;,
	    \   133: &quot;#af5faf&quot;, 134: &quot;#af5fd7&quot;, 135: &quot;#af5fff&quot;, 136: &quot;#af8700&quot;,
	    \   137: &quot;#af875f&quot;, 138: &quot;#af8787&quot;, 139: &quot;#af87af&quot;, 140: &quot;#af87d7&quot;,
	    \   141: &quot;#af87ff&quot;, 142: &quot;#afaf00&quot;, 143: &quot;#afaf5f&quot;, 144: &quot;#afaf87&quot;,
	    \   145: &quot;#afafaf&quot;, 146: &quot;#afafd7&quot;, 147: &quot;#afafff&quot;, 148: &quot;#afd700&quot;,
	    \   149: &quot;#afd75f&quot;, 150: &quot;#afd787&quot;, 151: &quot;#afd7af&quot;, 152: &quot;#afd7d7&quot;,
	    \   153: &quot;#afd7ff&quot;, 154: &quot;#afff00&quot;, 155: &quot;#afff5f&quot;, 156: &quot;#afff87&quot;,
	    \   157: &quot;#afffaf&quot;, 158: &quot;#afffd7&quot;
	    \ })
      call extend(s:cterm_color, {
	    \   159: &quot;#afffff&quot;, 160: &quot;#d70000&quot;, 161: &quot;#d7005f&quot;, 162: &quot;#d70087&quot;,
	    \   163: &quot;#d700af&quot;, 164: &quot;#d700d7&quot;, 165: &quot;#d700ff&quot;, 166: &quot;#d75f00&quot;,
	    \   167: &quot;#d75f5f&quot;, 168: &quot;#d75f87&quot;, 169: &quot;#d75faf&quot;, 170: &quot;#d75fd7&quot;,
	    \   171: &quot;#d75fff&quot;, 172: &quot;#d78700&quot;, 173: &quot;#d7875f&quot;, 174: &quot;#d78787&quot;,
	    \   175: &quot;#d787af&quot;, 176: &quot;#d787d7&quot;, 177: &quot;#d787ff&quot;, 178: &quot;#d7af00&quot;,
	    \   179: &quot;#d7af5f&quot;, 180: &quot;#d7af87&quot;, 181: &quot;#d7afaf&quot;, 182: &quot;#d7afd7&quot;,
	    \   183: &quot;#d7afff&quot;, 184: &quot;#d7d700&quot;, 185: &quot;#d7d75f&quot;, 186: &quot;#d7d787&quot;,
	    \   187: &quot;#d7d7af&quot;, 188: &quot;#d7d7d7&quot;, 189: &quot;#d7d7ff&quot;, 190: &quot;#d7ff00&quot;,
	    \   191: &quot;#d7ff5f&quot;, 192: &quot;#d7ff87&quot;, 193: &quot;#d7ffaf&quot;, 194: &quot;#d7ffd7&quot;,
	    \   195: &quot;#d7ffff&quot;, 196: &quot;#ff0000&quot;, 197: &quot;#ff005f&quot;, 198: &quot;#ff0087&quot;,
	    \   199: &quot;#ff00af&quot;, 200: &quot;#ff00d7&quot;, 201: &quot;#ff00ff&quot;, 202: &quot;#ff5f00&quot;,
	    \   203: &quot;#ff5f5f&quot;, 204: &quot;#ff5f87&quot;
	    \ })
      call extend(s:cterm_color, {
	    \   205: &quot;#ff5faf&quot;, 206: &quot;#ff5fd7&quot;, 207: &quot;#ff5fff&quot;, 208: &quot;#ff8700&quot;,
	    \   209: &quot;#ff875f&quot;, 210: &quot;#ff8787&quot;, 211: &quot;#ff87af&quot;, 212: &quot;#ff87d7&quot;,
	    \   213: &quot;#ff87ff&quot;, 214: &quot;#ffaf00&quot;, 215: &quot;#ffaf5f&quot;, 216: &quot;#ffaf87&quot;,
	    \   217: &quot;#ffafaf&quot;, 218: &quot;#ffafd7&quot;, 219: &quot;#ffafff&quot;, 220: &quot;#ffd700&quot;,
	    \   221: &quot;#ffd75f&quot;, 222: &quot;#ffd787&quot;, 223: &quot;#ffd7af&quot;, 224: &quot;#ffd7d7&quot;,
	    \   225: &quot;#ffd7ff&quot;, 226: &quot;#ffff00&quot;, 227: &quot;#ffff5f&quot;, 228: &quot;#ffff87&quot;,
	    \   229: &quot;#ffffaf&quot;, 230: &quot;#ffffd7&quot;, 231: &quot;#ffffff&quot;, 232: &quot;#080808&quot;,
	    \   233: &quot;#121212&quot;, 234: &quot;#1c1c1c&quot;, 235: &quot;#262626&quot;, 236: &quot;#303030&quot;,
	    \   237: &quot;#3a3a3a&quot;, 238: &quot;#444444&quot;, 239: &quot;#4e4e4e&quot;, 240: &quot;#585858&quot;,
	    \   241: &quot;#626262&quot;, 242: &quot;#6c6c6c&quot;, 243: &quot;#767676&quot;, 244: &quot;#808080&quot;,
	    \   245: &quot;#8a8a8a&quot;, 246: &quot;#949494&quot;, 247: &quot;#9e9e9e&quot;, 248: &quot;#a8a8a8&quot;,
	    \   249: &quot;#b2b2b2&quot;, 250: &quot;#bcbcbc&quot;, 251: &quot;#c6c6c6&quot;, 252: &quot;#d0d0d0&quot;,
	    \   253: &quot;#dadada&quot;, 254: &quot;#e4e4e4&quot;, 255: &quot;#eeeeee&quot;
	    \ })
    endif
  endif
endif

&quot; Return good color specification: in GUI no transformation is done, in
&quot; terminal return RGB values of known colors and empty string for unknown
if s:whatterm == &quot;gui&quot;
  function! s:HtmlColor(color)
    return a:color
  endfun
else
  function! s:HtmlColor(color)
    if has_key(s:cterm_color, a:color)
      return s:cterm_color[a:color]
    else
      return &quot;&quot;
    endif
  endfun
endif

&quot; Find out the background and foreground color for use later
let s:fgc = s:HtmlColor(synIDattr(hlID(&quot;Normal&quot;), &quot;fg#&quot;, s:whatterm))
let s:bgc = s:HtmlColor(synIDattr(hlID(&quot;Normal&quot;), &quot;bg#&quot;, s:whatterm))
if s:fgc == &quot;&quot;
  let s:fgc = ( &amp;background == &quot;dark&quot; ? &quot;#ffffff&quot; : &quot;#000000&quot; )
endif
if s:bgc == &quot;&quot;
  let s:bgc = ( &amp;background == &quot;dark&quot; ? &quot;#000000&quot; : &quot;#ffffff&quot; )
endif

if !s:settings.use_css
  &quot; Return opening HTML tag for given highlight id
  function! s:HtmlOpening(id, extra_attrs)
    let a = &quot;&quot;
    if synIDattr(a:id, &quot;inverse&quot;)
      &quot; For inverse, we always must set both colors (and exchange them)
      let x = s:HtmlColor(synIDattr(a:id, &quot;fg#&quot;, s:whatterm))
      let a = a . '&lt;span '.a:extra_attrs.'style=&quot;background-color: ' . ( x != &quot;&quot; ? x : s:fgc ) . '&quot;&gt;'
      let x = s:HtmlColor(synIDattr(a:id, &quot;bg#&quot;, s:whatterm))
      let a = a . '&lt;font color=&quot;' . ( x != &quot;&quot; ? x : s:bgc ) . '&quot;&gt;'
    else
      let x = s:HtmlColor(synIDattr(a:id, &quot;bg#&quot;, s:whatterm))
      if x != &quot;&quot;
	let a = a . '&lt;span '.a:extra_attrs.'style=&quot;background-color: ' . x . '&quot;&gt;'
      elseif !empty(a:extra_attrs)
	let a = a . '&lt;span '.a:extra_attrs.'&gt;'
      endif
      let x = s:HtmlColor(synIDattr(a:id, &quot;fg#&quot;, s:whatterm))
      if x != &quot;&quot; | let a = a . '&lt;font color=&quot;' . x . '&quot;&gt;' | endif
    endif
    if synIDattr(a:id, &quot;bold&quot;) | let a = a . &quot;&lt;b&gt;&quot; | endif
    if synIDattr(a:id, &quot;italic&quot;) | let a = a . &quot;&lt;i&gt;&quot; | endif
    if synIDattr(a:id, &quot;underline&quot;) | let a = a . &quot;&lt;u&gt;&quot; | endif
    return a
  endfun

  &quot; Return closing HTML tag for given highlight id
  function! s:HtmlClosing(id, has_extra_attrs)
    let a = &quot;&quot;
    if synIDattr(a:id, &quot;underline&quot;) | let a = a . &quot;&lt;/u&gt;&quot; | endif
    if synIDattr(a:id, &quot;italic&quot;) | let a = a . &quot;&lt;/i&gt;&quot; | endif
    if synIDattr(a:id, &quot;bold&quot;) | let a = a . &quot;&lt;/b&gt;&quot; | endif
    if synIDattr(a:id, &quot;inverse&quot;)
      let a = a . '&lt;/font&gt;&lt;/span&gt;'
    else
      let x = s:HtmlColor(synIDattr(a:id, &quot;fg#&quot;, s:whatterm))
      if x != &quot;&quot; | let a = a . '&lt;/font&gt;' | endif
      let x = s:HtmlColor(synIDattr(a:id, &quot;bg#&quot;, s:whatterm))
      if x != &quot;&quot; || a:has_extra_attrs | let a = a . '&lt;/span&gt;' | endif
    endif
    return a
  endfun
endif

&quot; Use a different function for formatting based on user options. This way we
&quot; can avoid a lot of logic during the actual execution.
&quot;
&quot; Build the function line by line containing only what is needed for the options
&quot; in use for maximum code sharing with minimal branch logic for greater speed.
&quot;
&quot; Note, 'exec' commands do not recognize line continuations, so must concatenate
&quot; lines rather than continue them.
if s:settings.use_css
  &quot; save CSS to a list of rules to add to the output at the end of processing

  &quot; first, get the style names we need
  let wrapperfunc_lines = [
	\ 'function! s:BuildStyleWrapper(style_id, diff_style_id, extra_attrs, text, make_unselectable, unformatted)',
	\ '',
	\ '  let l:style_name = synIDattr(a:style_id, &quot;name&quot;, s:whatterm)'
	\ ]
  if &amp;diff
    let wrapperfunc_lines += [
	\ '  let l:diff_style_name = synIDattr(a:diff_style_id, &quot;name&quot;, s:whatterm)']

  &quot; Add normal groups and diff groups to separate lists so we can order them to
  &quot; allow diff highlight to override normal highlight

  &quot; if primary style IS a diff style, grab it from the diff cache instead
  &quot; (always succeeds because we pre-populate it)
  let wrapperfunc_lines += [
	\ '',
	\ '  if a:style_id == s:DIFF_D_ID || a:style_id == s:DIFF_A_ID ||'.
	\ '          a:style_id == s:DIFF_C_ID || a:style_id == s:DIFF_T_ID',
	\ '    let l:saved_style = get(s:diffstylelist,a:style_id)',
	\ '  else'
	\ ]
  endif

  &quot; get primary style info from cache or build it on the fly if not found
  let wrapperfunc_lines += [
	\ '    let l:saved_style = get(s:stylelist,a:style_id)',
	\ '    if type(l:saved_style) == type(0)',
	\ '      unlet l:saved_style',
	\ '      let l:saved_style = s:CSS1(a:style_id)',
	\ '      if l:saved_style != &quot;&quot;',
	\ '        let l:saved_style = &quot;.&quot; . l:style_name . &quot; { &quot; . l:saved_style . &quot;}&quot;',
	\ '      endif',
	\ '      let s:stylelist[a:style_id]= l:saved_style',
	\ '    endif'
	\ ]
  if &amp;diff
    let wrapperfunc_lines += [ '  endif' ]
  endif

  &quot; Build the wrapper tags around the text. It turns out that caching these
  &quot; gives pretty much zero performance gain and adds a lot of logic.

  let wrapperfunc_lines += [
	\ '',
	\ '  if l:saved_style == &quot;&quot; &amp;&amp; empty(a:extra_attrs)'
	\ ]
  if &amp;diff
    let wrapperfunc_lines += [
	\ '    if a:diff_style_id &lt;= 0'
	\ ]
  endif
  &quot; no surroundings if neither primary nor diff style has any info
  let wrapperfunc_lines += [
	\ '       return a:text'
	\ ]
  if &amp;diff
    &quot; no primary style, but diff style
    let wrapperfunc_lines += [
	\ '     else',
	\ '       return &quot;&lt;span class=\&quot;&quot; .l:diff_style_name . &quot;\&quot;&gt;&quot;.a:text.&quot;&lt;/span&gt;&quot;',
	\ '     endif'
	\ ]
  endif
  &quot; open tag for non-empty primary style
  let wrapperfunc_lines += [
	\ '  else']
  &quot; non-empty primary style. handle either empty or non-empty diff style.
  &quot;
  &quot; separate the two classes by a space to apply them both if there is a diff
  &quot; style name, unless the primary style is empty, then just use the diff style
  &quot; name
  let diffstyle =
	  \ (&amp;diff ? '(a:diff_style_id &lt;= 0 ? &quot;&quot; : &quot; &quot;. l:diff_style_name) .'
	  \        : &quot;&quot;)
  if s:settings.prevent_copy == &quot;&quot;
    let wrapperfunc_lines += [
	  \ '    return &quot;&lt;span &quot;.a:extra_attrs.&quot;class=\&quot;&quot; . l:style_name .'.diffstyle.'&quot;\&quot;&gt;&quot;.a:text.&quot;&lt;/span&gt;&quot;'
	  \ ]
  else

    &quot;
    &quot; Wrap the &lt;input&gt; in a &lt;span&gt; to allow fixing the stupid bug in some fonts
    &quot; which cause browsers to display a 1px gap between lines when these
    &quot; &lt;input&gt;s have a background color (maybe not really a bug, this isn't
    &quot; well-defined)
    &quot;
    &quot; use strwidth, because we care only about how many character boxes are
    &quot; needed to size the input, we don't care how many characters (including
    &quot; separately counted composing chars, from strchars()) or bytes (from
    &quot; len())the string contains. strdisplaywidth() is not needed because none of
    &quot; the unselectable groups can contain tab characters (fold column, fold
    &quot; text, line number).
    &quot;
    &quot; Note, if maxlength property needs to be added in the future, it will need
    &quot; to use strchars(), because HTML specifies that the maxlength parameter
    &quot; uses the number of unique codepoints for its limit.
    let wrapperfunc_lines += [
	  \ '    if a:make_unselectable',
	  \ '      return &quot;&lt;span &quot;.a:extra_attrs.&quot;class=\&quot;&quot; . l:style_name .'.diffstyle.'&quot;\&quot;&gt;'.
	  \                '&lt;input'.s:unselInputType.' class=\&quot;&quot; . l:style_name .'.diffstyle.'&quot;\&quot;'.
	  \                 ' value=\&quot;&quot;.substitute(a:unformatted,''\s\+$'',&quot;&quot;,&quot;&quot;).&quot;\&quot;'.
	  \                 ' onselect=''this.blur(); return false;'''.
	  \                 ' onmousedown=''this.blur(); return false;'''.
	  \                 ' onclick=''this.blur(); return false;'''.
	  \                 ' readonly=''readonly'''.
	  \                 ' size=\&quot;&quot;.strwidth(a:unformatted).&quot;\&quot;'.
	  \                 (s:settings.use_xhtml ? '/' : '').'&gt;&lt;/span&gt;&quot;',
	  \ '    else',
	  \ '      return &quot;&lt;span &quot;.a:extra_attrs.&quot;class=\&quot;&quot; . l:style_name .'. diffstyle .'&quot;\&quot;&gt;&quot;.a:text.&quot;&lt;/span&gt;&quot;'
	  \ ]
  endif
  let wrapperfunc_lines += [
	\ '  endif',
	\ 'endfun'
	\ ]
else
  &quot; Non-CSS method just needs the wrapper.
  &quot;
  &quot; Functions used to get opening/closing automatically return null strings if
  &quot; no styles exist.
  if &amp;diff
    let wrapperfunc_lines = [
	  \ 'function! s:BuildStyleWrapper(style_id, diff_style_id, extra_attrs, text, unusedarg, unusedarg2)',
	  \ '  return s:HtmlOpening(a:style_id, a:extra_attrs).(a:diff_style_id &lt;= 0 ? &quot;&quot; :'.
	  \                                     's:HtmlOpening(a:diff_style_id, &quot;&quot;)).a:text.'.
	  \   '(a:diff_style_id &lt;= 0 ? &quot;&quot; : s:HtmlClosing(a:diff_style_id, 0)).s:HtmlClosing(a:style_id, !empty(a:extra_attrs))',
	  \ 'endfun'
	  \ ]
  else
    let wrapperfunc_lines = [
	  \ 'function! s:BuildStyleWrapper(style_id, diff_style_id, extra_attrs, text, unusedarg, unusedarg2)',
	  \ '  return s:HtmlOpening(a:style_id, a:extra_attrs).a:text.s:HtmlClosing(a:style_id, !empty(a:extra_attrs))',
	  \ 'endfun'
	  \ ]
  endif
endif

&quot; create the function we built line by line above
exec join(wrapperfunc_lines, &quot;\n&quot;)

let s:diff_mode = &amp;diff

&quot; Return HTML valid characters enclosed in a span of class style_name with
&quot; unprintable characters expanded and double spaces replaced as necessary.
&quot;
&quot; TODO: eliminate unneeded logic like done for BuildStyleWrapper
function! s:HtmlFormat(text, style_id, diff_style_id, extra_attrs, make_unselectable)
  &quot; Replace unprintable characters
  let unformatted = strtrans(a:text)

  let formatted = unformatted

  &quot; Replace the reserved html characters
  let formatted = substitute(formatted, '&amp;', '\&amp;amp;',  'g')
  let formatted = substitute(formatted, '&lt;', '\&amp;lt;',   'g')
  let formatted = substitute(formatted, '&gt;', '\&amp;gt;',   'g')
  let formatted = substitute(formatted, '&quot;', '\&amp;quot;', 'g')
  &quot; &amp;apos; is not valid in HTML but it is in XHTML, so just use the numeric
  &quot; reference for it instead. Needed because it could appear in quotes
  &quot; especially if unselectable regions is turned on.
  let formatted = substitute(formatted, '&quot;', '\&amp;#0039;', 'g')

  &quot; Replace a &quot;form feed&quot; character with HTML to do a page break
  &quot; TODO: need to prevent this in unselectable areas? Probably it should never
  &quot; BE in an unselectable area...
  let formatted = substitute(formatted, &quot;\x0c&quot;, '&lt;hr class=&quot;PAGE-BREAK&quot;&gt;', 'g')

  &quot; Replace double spaces, leading spaces, and trailing spaces if needed
  if ' ' != s:HtmlSpace
    let formatted = substitute(formatted, '  ', s:HtmlSpace . s:HtmlSpace, 'g')
    let formatted = substitute(formatted, '^ ', s:HtmlSpace, 'g')
    let formatted = substitute(formatted, ' \+$', s:HtmlSpace, 'g')
  endif

  &quot; Enclose in the correct format
  return s:BuildStyleWrapper(a:style_id, a:diff_style_id, a:extra_attrs, formatted, a:make_unselectable, unformatted)
endfun

&quot; set up functions to call HtmlFormat in certain ways based on whether the
&quot; element is supposed to be unselectable or not
if s:settings.prevent_copy =~# 'n'
  if s:settings.number_lines
    if s:settings.line_ids
      function! s:HtmlFormat_n(text, style_id, diff_style_id, lnr)
	if a:lnr &gt; 0
	  return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, 'id=&quot;'.(exists('g:html_diff_win_num') ? 'W'.g:html_diff_win_num : &quot;&quot;).'L'.a:lnr.s:settings.id_suffix.'&quot; ', 1)
	else
	  return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, &quot;&quot;, 1)
	endif
      endfun
    else
      function! s:HtmlFormat_n(text, style_id, diff_style_id, lnr)
	return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, &quot;&quot;, 1)
      endfun
    endif
  elseif s:settings.line_ids
    &quot; if lines are not being numbered the only reason this function gets called
    &quot; is to put the line IDs on each line; &quot;text&quot; will be emtpy but lnr will
    &quot; always be non-zero, however we don't want to use the &lt;input&gt; because that
    &quot; won't work as nice for empty text
    function! s:HtmlFormat_n(text, style_id, diff_style_id, lnr)
      return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, 'id=&quot;'.(exists('g:html_diff_win_num') ? 'W'.g:html_diff_win_num : &quot;&quot;).'L'.a:lnr.s:settings.id_suffix.'&quot; ', 0)
    endfun
  endif
else
  if s:settings.line_ids
    function! s:HtmlFormat_n(text, style_id, diff_style_id, lnr)
      if a:lnr &gt; 0
	return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, 'id=&quot;'.(exists('g:html_diff_win_num') ? 'W'.g:html_diff_win_num : &quot;&quot;).'L'.a:lnr.s:settings.id_suffix.'&quot; ', 0)
      else
	return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, &quot;&quot;, 0)
      endif
    endfun
  else
    function! s:HtmlFormat_n(text, style_id, diff_style_id, lnr)
      return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, &quot;&quot;, 0)
    endfun
  endif
endif
if s:settings.prevent_copy =~# 'd'
  function! s:HtmlFormat_d(text, style_id, diff_style_id)
    return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, &quot;&quot;, 1)
  endfun
else
  function! s:HtmlFormat_d(text, style_id, diff_style_id)
    return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, &quot;&quot;, 0)
  endfun
endif
if s:settings.prevent_copy =~# 'f'
  &quot; Note the &lt;input&gt; elements for fill spaces will have a single space for
  &quot; content, to allow active cursor CSS selection to work.
  &quot;
  &quot; Wrap the whole thing in a span for the 1px padding workaround for gaps.
  function! s:FoldColumn_build(char, len, numfill, char2, class, click)
    let l:input_open = &quot;&lt;input readonly='readonly'&quot;.s:unselInputType.
	  \ &quot; onselect='this.blur(); return false;'&quot;.
	  \ &quot; onmousedown='this.blur(); &quot;.a:click.&quot; return false;'&quot;.
	  \ &quot; onclick='return false;' size='&quot;.
	  \ string(a:len + (empty(a:char2) ? 0 : 1) + a:numfill) .
	  \ &quot;' &quot;
    let l:common_attrs = &quot;class='FoldColumn' value='&quot;
    let l:input_close = (s:settings.use_xhtml ? &quot;' /&gt;&quot; : &quot;'&gt;&quot;)
    return &quot;&lt;span class='&quot;.a:class.&quot;'&gt;&quot;.
	  \ l:input_open.l:common_attrs.repeat(a:char, a:len).
	  \ (!empty(a:char2) ? a:char2 : &quot;&quot;).
	  \ l:input_close . &quot;&lt;/span&gt;&quot;
  endfun
  function! s:FoldColumn_fill()
    return s:FoldColumn_build('', s:foldcolumn, 0, '', 'FoldColumn', '')
  endfun
else
  &quot; For normal fold columns, simply space-pad to the desired width (note that
  &quot; the FoldColumn definition includes a whitespace:pre rule)
  function! s:FoldColumn_build(char, len, numfill, char2, class, click)
    return &quot;&lt;a href='#' class='&quot;.a:class.&quot;' onclick='&quot;.a:click.&quot;'&gt;&quot;.
	  \ repeat(a:char, a:len).a:char2.repeat(' ', a:numfill).
	  \ &quot;&lt;/a&gt;&quot;
  endfun
  function! s:FoldColumn_fill()
    return s:HtmlFormat(repeat(' ', s:foldcolumn), s:FOLD_C_ID, 0, &quot;&quot;, 0)
  endfun
endif
if s:settings.prevent_copy =~# 't'
  &quot; put an extra empty span at the end for dynamic folds, so the linebreak can
  &quot; be surrounded. Otherwise do it as normal.
  &quot;
  &quot; TODO: isn't there a better way to do this, than placing it here and using a
  &quot; substitute later?
  if s:settings.dynamic_folds
    function! s:HtmlFormat_t(text, style_id, diff_style_id)
      return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, &quot;&quot;, 1) .
	    \ s:HtmlFormat(&quot;&quot;, a:style_id, 0, &quot;&quot;, 0)
    endfun
  else
    function! s:HtmlFormat_t(text, style_id, diff_style_id)
      return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, &quot;&quot;, 1)
    endfun
  endif
else
  function! s:HtmlFormat_t(text, style_id, diff_style_id)
    return s:HtmlFormat(a:text, a:style_id, a:diff_style_id, &quot;&quot;, 0)
  endfun
endif

&quot; Return CSS style describing given highlight id (can be empty)
function! s:CSS1(id)
  let a = &quot;&quot;
  if synIDattr(a:id, &quot;inverse&quot;)
    &quot; For inverse, we always must set both colors (and exchange them)
    let x = s:HtmlColor(synIDattr(a:id, &quot;bg#&quot;, s:whatterm))
    let a = a . &quot;color: &quot; . ( x != &quot;&quot; ? x : s:bgc ) . &quot;; &quot;
    let x = s:HtmlColor(synIDattr(a:id, &quot;fg#&quot;, s:whatterm))
    let a = a . &quot;background-color: &quot; . ( x != &quot;&quot; ? x : s:fgc ) . &quot;; &quot;
  else
    let x = s:HtmlColor(synIDattr(a:id, &quot;fg#&quot;, s:whatterm))
    if x != &quot;&quot; | let a = a . &quot;color: &quot; . x . &quot;; &quot; | endif
    let x = s:HtmlColor(synIDattr(a:id, &quot;bg#&quot;, s:whatterm))
    if x != &quot;&quot;
      let a = a . &quot;background-color: &quot; . x . &quot;; &quot;
      &quot; stupid hack because almost every browser seems to have at least one font
      &quot; which shows 1px gaps between lines which have background
      let a = a . &quot;padding-bottom: 1px; &quot;
    elseif (a:id == s:FOLDED_ID || a:id == s:LINENR_ID || a:id == s:FOLD_C_ID) &amp;&amp; !empty(s:settings.prevent_copy)
      &quot; input elements default to a different color than the rest of the page
      let a = a . &quot;background-color: &quot; . s:bgc . &quot;; &quot;
    endif
  endif
  if synIDattr(a:id, &quot;bold&quot;) | let a = a . &quot;font-weight: bold; &quot; | endif
  if synIDattr(a:id, &quot;italic&quot;) | let a = a . &quot;font-style: italic; &quot; | endif
  if synIDattr(a:id, &quot;underline&quot;) | let a = a . &quot;text-decoration: underline; &quot; | endif
  return a
endfun

if s:settings.dynamic_folds
  &quot; compares two folds as stored in our list of folds
  &quot; A fold is &quot;less&quot; than another if it starts at an earlier line number,
  &quot; or ends at a later line number, ties broken by fold level
  function! s:FoldCompare(f1, f2)
    if a:f1.firstline != a:f2.firstline
      &quot; put it before if it starts earlier
      return a:f1.firstline - a:f2.firstline
    elseif a:f1.lastline != a:f2.lastline
      &quot; put it before if it ends later
      return a:f2.lastline - a:f1.lastline
    else
      &quot; if folds begin and end on the same lines, put lowest fold level first
      return a:f1.level - a:f2.level
    endif
  endfunction

endif


&quot; Set some options to make it work faster.
&quot; Don't report changes for :substitute, there will be many of them.
&quot; Don't change other windows; turn off scroll bind temporarily
let s:old_title = &amp;title
let s:old_icon = &amp;icon
let s:old_et = &amp;l:et
let s:old_bind = &amp;l:scrollbind
let s:old_report = &amp;report
let s:old_search = @/
let s:old_more = &amp;more
set notitle noicon
setlocal et
set nomore
set report=1000000
setlocal noscrollbind

if exists(':ownsyntax') &amp;&amp; exists('w:current_syntax')
  let s:current_syntax = w:current_syntax
elseif exists('b:current_syntax')
  let s:current_syntax = b:current_syntax
else
  let s:current_syntax = 'none'
endif

if s:current_syntax == ''
  let s:current_syntax = 'none'
endif

&quot; Split window to create a buffer with the HTML file.
let s:orgbufnr = winbufnr(0)
let s:origwin_stl = &amp;l:stl
if expand(&quot;%&quot;) == &quot;&quot;
  if exists('g:html_diff_win_num')
    exec 'new Untitled_win'.g:html_diff_win_num.'.'.(s:settings.use_xhtml ? 'x' : '').'html'
  else
    exec 'new Untitled.'.(s:settings.use_xhtml ? 'x' : '').'html'
  endif
else
  exec 'new %.'.(s:settings.use_xhtml ? 'x' : '').'html'
endif

&quot; Resize the new window to very small in order to make it draw faster
let s:old_winheight = winheight(0)
let s:old_winfixheight = &amp;l:winfixheight
if s:old_winheight &gt; 2
  resize 1 &quot; leave enough room to view one line at a time
  norm! G
  norm! zt
endif
setlocal winfixheight

let s:newwin_stl = &amp;l:stl

&quot; on the new window, set the least time-consuming fold method
let s:old_fen = &amp;foldenable
setlocal foldmethod=manual
setlocal nofoldenable

let s:newwin = winnr()
let s:orgwin = bufwinnr(s:orgbufnr)

setlocal modifiable
%d
let s:old_paste = &amp;paste
set paste
let s:old_magic = &amp;magic
set magic

&quot; set the fileencoding to match the charset we'll be using
let &amp;l:fileencoding=s:settings.vim_encoding

&quot; According to http://www.w3.org/TR/html4/charset.html#doc-char-set, the byte
&quot; order mark is highly recommend on the web when using multibyte encodings. But,
&quot; it is not a good idea to include it on UTF-8 files. Otherwise, let Vim
&quot; determine when it is actually inserted.
if s:settings.vim_encoding == 'utf-8'
  setlocal nobomb
else
  setlocal bomb
endif

let s:lines = []

if s:settings.use_xhtml
  if s:settings.encoding != &quot;&quot;
    call add(s:lines, &quot;&lt;?xml version=\&quot;1.0\&quot; encoding=\&quot;&quot; . s:settings.encoding . &quot;\&quot;?&gt;&quot;)
  else
    call add(s:lines, &quot;&lt;?xml version=\&quot;1.0\&quot;?&gt;&quot;)
  endif
  let s:tag_close = ' /&gt;'
else
  let s:tag_close = '&gt;'
endif

let s:HtmlSpace = ' '
let s:LeadingSpace = ' '
let s:HtmlEndline = ''
if s:settings.no_pre
  let s:HtmlEndline = '&lt;br' . s:tag_close
  let s:LeadingSpace = s:settings.use_xhtml ? '&amp;#160;' : '&amp;nbsp;'
  let s:HtmlSpace = '\' . s:LeadingSpace
endif

&quot; HTML header, with the title and generator ;-). Left free space for the CSS,
&quot; to be filled at the end.
call extend(s:lines, [
      \ &quot;&lt;html&gt;&quot;,
      \ &quot;&lt;head&gt;&quot;])
&quot; include encoding as close to the top as possible, but only if not already
&quot; contained in XML information (to avoid haggling over content type)
if s:settings.encoding != &quot;&quot; &amp;&amp; !s:settings.use_xhtml
  call add(s:lines, &quot;&lt;meta http-equiv=\&quot;content-type\&quot; content=\&quot;text/html; charset=&quot; . s:settings.encoding . '&quot;' . s:tag_close)
endif
call extend(s:lines, [
      \ (&quot;&lt;title&gt;&quot;.expand(&quot;%:p:~&quot;).&quot;&lt;/title&gt;&quot;),
      \ (&quot;&lt;meta name=\&quot;Generator\&quot; content=\&quot;Vim/&quot;.v:version/100.&quot;.&quot;.v:version%100.'&quot;'.s:tag_close),
      \ (&quot;&lt;meta name=\&quot;plugin-version\&quot; content=\&quot;&quot;.g:loaded_2html_plugin.'&quot;'.s:tag_close)
      \ ])
call add(s:lines, '&lt;meta name=&quot;syntax&quot; content=&quot;'.s:current_syntax.'&quot;'.s:tag_close)
call add(s:lines, '&lt;meta name=&quot;settings&quot; content=&quot;'.
      \ join(filter(keys(s:settings),'s:settings[v:val]'),',').
      \ ',prevent_copy='.s:settings.prevent_copy.
      \ '&quot;'.s:tag_close)
call add(s:lines, '&lt;meta name=&quot;colorscheme&quot; content=&quot;'.
      \ (exists('g:colors_name')
      \ ? g:colors_name
      \ : 'none'). '&quot;'.s:tag_close)

if s:settings.use_css
  if s:settings.dynamic_folds
    if s:settings.hover_unfold
      &quot; if we are doing hover_unfold, use css 2 with css 1 fallback for IE6
      call extend(s:lines, [
	    \ &quot;&lt;style type=\&quot;text/css\&quot;&gt;&quot;,
	    \ s:settings.use_xhtml ? &quot;&quot; : &quot;&lt;!--&quot;,
	    \ &quot;.FoldColumn { text-decoration: none; white-space: pre; }&quot;,
	    \ &quot;&quot;,
	    \ &quot;body * { margin: 0; padding: 0; }&quot;, &quot;&quot;,
	    \ &quot;.open-fold   &gt; .Folded { display: none;  }&quot;,
	    \ &quot;.open-fold   &gt; .fulltext { display: inline; }&quot;,
	    \ &quot;.closed-fold &gt; .fulltext { display: none;  }&quot;,
	    \ &quot;.closed-fold &gt; .Folded { display: inline; }&quot;,
	    \ &quot;&quot;,
	    \ &quot;.open-fold   &gt; .toggle-open   { display: none;   }&quot;,
	    \ &quot;.open-fold   &gt; .toggle-closed { display: inline; }&quot;,
	    \ &quot;.closed-fold &gt; .toggle-open   { display: inline; }&quot;,
	    \ &quot;.closed-fold &gt; .toggle-closed { display: none;   }&quot;,
	    \ &quot;&quot;, &quot;&quot;,
	    \ '/* opening a fold while hovering won''t be supported by IE6 and other',
	    \ &quot;similar browsers, but it should fail gracefully. */&quot;,
	    \ &quot;.closed-fold:hover &gt; .fulltext { display: inline; }&quot;,
	    \ &quot;.closed-fold:hover &gt; .toggle-filler { display: none; }&quot;,
	    \ &quot;.closed-fold:hover &gt; .Folded { display: none; }&quot;,
	    \ s:settings.use_xhtml ? &quot;&quot; : '--&gt;',
	    \ '&lt;/style&gt;'])
      &quot; TODO: IE7 doesn't *actually* support XHTML, maybe we should remove this.
      &quot; But if it's served up as tag soup, maybe the following will work, so
      &quot; leave it in for now.
      call extend(s:lines, [
	    \ &quot;&lt;!--[if lt IE 7]&gt;&lt;style type=\&quot;text/css\&quot;&gt;&quot;,
	    \ &quot;.open-fold   .Folded      { display: none; }&quot;,
	    \ &quot;.open-fold   .fulltext      { display: inline; }&quot;,
	    \ &quot;.open-fold   .toggle-open   { display: none; }&quot;,
	    \ &quot;.closed-fold .toggle-closed { display: inline; }&quot;,
	    \ &quot;&quot;,
	    \ &quot;.closed-fold .fulltext      { display: none; }&quot;,
	    \ &quot;.closed-fold .Folded      { display: inline; }&quot;,
	    \ &quot;.closed-fold .toggle-open   { display: inline; }&quot;,
	    \ &quot;.closed-fold .toggle-closed { display: none; }&quot;,
	    \ &quot;&lt;/style&gt;&quot;,
	    \ &quot;&lt;![endif]--&gt;&quot;,
	    \])
    else
      &quot; if we aren't doing hover_unfold, use CSS 1 only
      call extend(s:lines, [
	    \ &quot;&lt;style type=\&quot;text/css\&quot;&gt;&quot;,
	    \ s:settings.use_xhtml ? &quot;&quot; :&quot;&lt;!--&quot;,
	    \ &quot;.FoldColumn { text-decoration: none; white-space: pre; }&quot;,
	    \ &quot;.open-fold   .Folded      { display: none; }&quot;,
	    \ &quot;.open-fold   .fulltext      { display: inline; }&quot;,
	    \ &quot;.open-fold   .toggle-open   { display: none; }&quot;,
	    \ &quot;.closed-fold .toggle-closed { display: inline; }&quot;,
	    \ &quot;&quot;,
	    \ &quot;.closed-fold .fulltext      { display: none; }&quot;,
	    \ &quot;.closed-fold .Folded      { display: inline; }&quot;,
	    \ &quot;.closed-fold .toggle-open   { display: inline; }&quot;,
	    \ &quot;.closed-fold .toggle-closed { display: none; }&quot;,
	    \ s:settings.use_xhtml ? &quot;&quot; : '--&gt;',
	    \ '&lt;/style&gt;'
	    \])
    endif
  else
    &quot; if we aren't doing any dynamic folding, no need for any special rules
    call extend(s:lines, [
	  \ &quot;&lt;style type=\&quot;text/css\&quot;&gt;&quot;,
	  \ s:settings.use_xhtml ? &quot;&quot; : &quot;&lt;!--&quot;,
	  \ s:settings.use_xhtml ? &quot;&quot; : '--&gt;',
	  \ &quot;&lt;/style&gt;&quot;,
	  \])
  endif
endif

&quot; insert script tag; javascript is always needed for the line number
&quot; normalization for URL hashes
call extend(s:lines, [
      \ &quot;&quot;,
      \ &quot;&lt;script type='text/javascript'&gt;&quot;,
      \ s:settings.use_xhtml ? '//&lt;![CDATA[' : &quot;&lt;!--&quot;])

&quot; insert javascript to toggle folds open and closed
if s:settings.dynamic_folds
  call extend(s:lines, [
	\ &quot;&quot;,
	\ &quot;function toggleFold(objID)&quot;,
	\ &quot;{&quot;,
	\ &quot;  var fold;&quot;,
	\ &quot;  fold = document.getElementById(objID);&quot;,
	\ &quot;  if(fold.className == 'closed-fold')&quot;,
	\ &quot;  {&quot;,
	\ &quot;    fold.className = 'open-fold';&quot;,
	\ &quot;  }&quot;,
	\ &quot;  else if (fold.className == 'open-fold')&quot;,
	\ &quot;  {&quot;,
	\ &quot;    fold.className = 'closed-fold';&quot;,
	\ &quot;  }&quot;,
	\ &quot;}&quot;
	\ ])
endif

if s:settings.line_ids
  &quot; insert javascript to get IDs from line numbers, and to open a fold before
  &quot; jumping to any lines contained therein
  call extend(s:lines, [
	\ &quot;&quot;,
	\ &quot;/* function to open any folds containing a jumped-to line before jumping to it */&quot;,
	\ &quot;function JumpToLine()&quot;,
	\ &quot;{&quot;,
	\ &quot;  var lineNum;&quot;,
	\ &quot;  lineNum = window.location.hash;&quot;,
	\ &quot;  lineNum = lineNum.substr(1); /* strip off '#' */&quot;,
	\ &quot;&quot;,
	\ &quot;  if (lineNum.indexOf('L') == -1) {&quot;,
	\ &quot;    lineNum = 'L'+lineNum;&quot;,
	\ &quot;  }&quot;,
	\ &quot;  lineElem = document.getElementById(lineNum);&quot;
	\ ])
  if s:settings.dynamic_folds
    call extend(s:lines, [
	  \ &quot;&quot;,
	  \ &quot;  /* navigate upwards in the DOM tree to open all folds containing the line */&quot;,
	  \ &quot;  var node = lineElem;&quot;,
	  \ &quot;  while (node &amp;&amp; node.id != 'vimCodeElement&quot;.s:settings.id_suffix.&quot;')&quot;,
	  \ &quot;  {&quot;,
	  \ &quot;    if (node.className == 'closed-fold')&quot;,
	  \ &quot;    {&quot;,
	  \ &quot;      node.className = 'open-fold';&quot;,
	  \ &quot;    }&quot;,
	  \ &quot;    node = node.parentNode;&quot;,
	  \ &quot;  }&quot;,
	  \ ])
  endif
  call extend(s:lines, [
	\ &quot;  /* Always jump to new location even if the line was hidden inside a fold, or&quot;,
	\ &quot;   * we corrected the raw number to a line ID.&quot;,
	\ &quot;   */&quot;,
	\ &quot;  if (lineElem) {&quot;,
	\ &quot;    lineElem.scrollIntoView(true);&quot;,
	\ &quot;  }&quot;,
	\ &quot;  return true;&quot;,
	\ &quot;}&quot;,
	\ &quot;if ('onhashchange' in window) {&quot;,
	\ &quot;  window.onhashchange = JumpToLine;&quot;,
	\ &quot;}&quot;
	\ ])
endif

&quot; Small text columns like the foldcolumn and line number column need a weird
&quot; hack to work around Webkit's and (in versions prior to 9) IE's lack of support
&quot; for the 'ch' unit without messing up Opera, which also doesn't support it but
&quot; works anyway.
&quot;
&quot; The problem is that without the 'ch' unit, it is not possible to specify a
&quot; size of an &lt;input&gt; in terms of character widths. Only Opera seems to do the
&quot; &quot;sensible&quot; thing and make the &lt;input&gt; sized to fit exactly as many characters
&quot; as specified by its &quot;size&quot; attribute, but the spec actually says &quot;at least
&quot; wide enough to fit 'size' characters&quot;, so the other browsers are technically
&quot; correct as well.
&quot;
&quot; Anyway, this leads to two diffculties:
&quot;   1. The foldcolumn is made up of multiple elements side-by-side with
&quot;      different sizes, each of which has their own extra padding added. Thus, a
&quot;      column made up of one item of size 1 and another of size 2 would not
&quot;      necessarily be equal in size to another line's foldcolumn with a single
&quot;      item of size 3.
&quot;   2. The extra padding added to the &lt;input&gt; elements adds up to make the
&quot;      foldcolumn and line number column too wide, especially in Webkit
&quot;      browsers.
&quot;
&quot; So, the full workaround is:
&quot;   1. Define a default size in em, equal to the number of characters in the
&quot;      input element, in case javascript is disabled and the browser does not
&quot;      support the 'ch' unit. Unfortunately this makes Opera no longer work
&quot;      properly without javascript. 1em per character is much too wide but it
&quot;      looks better in webkit browsers than unaligned columns.
&quot;   2. Insert the following javascript to run at page load, which checks for the
&quot;      width of a single character (in an extraneous page element inserted
&quot;      before the page title, and set to hidden) and compares it to the width of
&quot;      another extra &lt;input&gt; element with only one character. If the width
&quot;      matches, the script does nothing more, but if not, it will figure out the
&quot;      fraction of an em unit which would correspond with a ch unit if there
&quot;      were one, and set the containing element (&lt;pre&gt; or &lt;div&gt;) to a class with
&quot;      pre-defined rules which is closest to that fraction of an em. Rules are
&quot;      defined from 0.05 em to 1em per ch.
if !empty(s:settings.prevent_copy)
  call extend(s:lines, [
	\ '',
	\ '/* simulate a &quot;ch&quot; unit by asking the browser how big a zero character is */',
	\ 'function FixCharWidth() {',
	\ '  /* get the hidden element which gives the width of a single character */',
	\ '  var goodWidth = document.getElementById(&quot;oneCharWidth&quot;).clientWidth;',
	\ '  /* get all input elements, we''ll filter on class later */',
	\ '  var inputTags = document.getElementsByTagName(&quot;input&quot;);',
	\ '  var ratio = 5;',
	\ '  var inputWidth = document.getElementById(&quot;oneInputWidth&quot;).clientWidth;',
	\ '  var emWidth = document.getElementById(&quot;oneEmWidth&quot;).clientWidth;',
	\ '  if (inputWidth &gt; goodWidth) {',
	\ '    while (ratio &lt; 100*goodWidth/emWidth &amp;&amp; ratio &lt; 100) {',
	\ '      ratio += 5;',
	\ '    }',
	\ '    document.getElementById(&quot;vimCodeElement'.s:settings.id_suffix.'&quot;).className = &quot;em&quot;+ratio;',
	\ '  }',
	\ '}'
	\ ])
endif

&quot; insert script closing tag
call extend(s:lines, [
      \ '',
      \ s:settings.use_xhtml ? '//]]&gt;' : '--&gt;',
      \ &quot;&lt;/script&gt;&quot;
      \ ])

call extend(s:lines, [&quot;&lt;/head&gt;&quot;])
if !empty(s:settings.prevent_copy)
  call extend(s:lines,
	\ [&quot;&lt;body onload='FixCharWidth();&quot;.(s:settings.line_ids ? &quot; JumpToLine();&quot; : &quot;&quot;).&quot;'&gt;&quot;,
	\ &quot;&lt;!-- hidden divs used by javascript to get the width of a char --&gt;&quot;,
	\ &quot;&lt;div id='oneCharWidth'&gt;0&lt;/div&gt;&quot;,
	\ &quot;&lt;div id='oneInputWidth'&gt;&lt;input size='1' value='0'&quot;.s:tag_close.&quot;&lt;/div&gt;&quot;,
	\ &quot;&lt;div id='oneEmWidth' style='width: 1em;'&gt;&lt;/div&gt;&quot;
	\ ])
else
  call extend(s:lines, [&quot;&lt;body&quot;.(s:settings.line_ids ? &quot; onload='JumpToLine();'&quot; : &quot;&quot;).&quot;&gt;&quot;])
endif
if s:settings.no_pre
  &quot; if we're not using CSS we use a font tag which can't have a div inside
  if s:settings.use_css
    call extend(s:lines, [&quot;&lt;div id='vimCodeElement&quot;.s:settings.id_suffix.&quot;'&gt;&quot;])
  endif
else
  call extend(s:lines, [&quot;&lt;pre id='vimCodeElement&quot;.s:settings.id_suffix.&quot;'&gt;&quot;])
endif

exe s:orgwin . &quot;wincmd w&quot;

&quot; caches of style data
&quot; initialize to include line numbers if using them
if s:settings.number_lines
  let s:stylelist = { s:LINENR_ID : &quot;.LineNr { &quot; . s:CSS1( s:LINENR_ID ) . &quot;}&quot; }
else
  let s:stylelist = {}
endif
let s:diffstylelist = {
      \   s:DIFF_A_ID : &quot;.DiffAdd { &quot; . s:CSS1( s:DIFF_A_ID ) . &quot;}&quot;,
      \   s:DIFF_C_ID : &quot;.DiffChange { &quot; . s:CSS1( s:DIFF_C_ID ) . &quot;}&quot;,
      \   s:DIFF_D_ID : &quot;.DiffDelete { &quot; . s:CSS1( s:DIFF_D_ID ) . &quot;}&quot;,
      \   s:DIFF_T_ID : &quot;.DiffText { &quot; . s:CSS1( s:DIFF_T_ID ) . &quot;}&quot;
      \ }

&quot; set up progress bar in the status line
if !s:settings.no_progress
  &quot; ProgressBar Indicator
  let s:progressbar={}

  &quot; Progessbar specific functions
  func! s:ProgressBar(title, max_value, winnr)
    let pgb=copy(s:progressbar)
    let pgb.title = a:title.' '
    let pgb.max_value = a:max_value
    let pgb.winnr = a:winnr
    let pgb.cur_value = 0
    let pgb.items = { 'title'   : { 'color' : 'Statusline' },
	  \'bar'     : { 'color' : 'Statusline' , 'fillcolor' : 'DiffDelete' , 'bg' : 'Statusline' } ,
	  \'counter' : { 'color' : 'Statusline' } }
    let pgb.last_value = 0
    let pgb.needs_redraw = 0
    &quot; Note that you must use len(split) instead of len() if you want to use 
    &quot; unicode in title.
    &quot;
    &quot; Subtract 3 for spacing around the title.
    &quot; Subtract 4 for the percentage display.
    &quot; Subtract 2 for spacing before this.
    &quot; Subtract 2 more for the '|' on either side of the progress bar
    let pgb.subtractedlen=len(split(pgb.title, '\zs'))+3+4+2+2
    let pgb.max_len = 0
    set laststatus=2
    return pgb
  endfun

  &quot; Function: progressbar.calculate_ticks() {{{1
  func! s:progressbar.calculate_ticks(pb_len)
    if a:pb_len&lt;=0
      let pb_len = 100
    else
      let pb_len = a:pb_len
    endif
    let self.progress_ticks = map(range(pb_len+1), &quot;v:val * self.max_value / pb_len&quot;)
  endfun

  &quot;Function: progressbar.paint()
  func! s:progressbar.paint()
    &quot; Recalculate widths.
    let max_len = winwidth(self.winnr)
    let pb_len = 0
    &quot; always true on first call because of initial value of self.max_len
    if max_len != self.max_len
      let self.max_len = max_len

      &quot; Progressbar length
      let pb_len = max_len - self.subtractedlen

      call self.calculate_ticks(pb_len)

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

    let cur_val_max = pb_len &gt; 0 ? pb_len : 100

    &quot; find the current progress bar position based on precalculated thresholds
    while cur_value &lt; cur_val_max &amp;&amp; self.cur_value &gt; self.progress_ticks[cur_value]
      let cur_value += 1
    endwhile

    &quot; update progress bar
    if self.last_value != cur_value || self.needs_redraw || self.cur_value == self.max_value
      let self.needs_redraw = 1
      let self.last_value = cur_value

      let t_color  = self.items.title.color
      let b_fcolor = self.items.bar.fillcolor
      let b_color  = self.items.bar.color
      let c_color  = self.items.counter.color

      let stl =  &quot;%#&quot;.t_color.&quot;#%-( &quot;.self.title.&quot; %)&quot;.
	    \&quot;%#&quot;.b_color.&quot;#&quot;.
	    \(pb_len&gt;0 ?
	    \	('|%#'.b_fcolor.&quot;#%-(&quot;.repeat(&quot; &quot;,cur_value).&quot;%)&quot;.
	    \	 '%#'.b_color.&quot;#&quot;.repeat(&quot; &quot;,pb_len-cur_value).&quot;|&quot;):
	    \	('')).
	    \&quot;%=%#&quot;.c_color.&quot;#%( &quot;.printf(&quot;%3.d &quot;,100*self.cur_value/self.max_value).&quot;%% %)&quot;
      call setwinvar(self.winnr, '&amp;stl', stl)
    endif
  endfun

  func! s:progressbar.incr( ... )
    let self.cur_value += (a:0 ? a:1 : 1)
    &quot; if we were making a general-purpose progress bar, we'd need to limit to a
    &quot; lower limit as well, but since we always increment with a positive value
    &quot; in this script, we only need limit the upper value
    let self.cur_value = (self.cur_value &gt; self.max_value ? self.max_value : self.cur_value)
    call self.paint()
  endfun
  &quot; }}}
  if s:settings.dynamic_folds
    &quot; to process folds we make two passes through each line
    let s:pgb = s:ProgressBar(&quot;Processing folds:&quot;, line('$')*2, s:orgwin)
  endif
endif

&quot; First do some preprocessing for dynamic folding. Do this for the entire file
&quot; so we don't accidentally start within a closed fold or something.
let s:allfolds = []

if s:settings.dynamic_folds
  let s:lnum = 1
  let s:end = line('$')
  &quot; save the fold text and set it to the default so we can find fold levels
  let s:foldtext_save = &amp;foldtext
  setlocal foldtext&amp;

  &quot; we will set the foldcolumn in the html to the greater of the maximum fold
  &quot; level and the current foldcolumn setting
  let s:foldcolumn = &amp;foldcolumn

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

  &quot; close all folds to get info for originally open folds
  silent! %foldclose!
  let s:lnum = 1

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

  &quot; sort the folds so that we only ever need to look at the first item in the
  &quot; list of folds
  call sort(s:allfolds, &quot;s:FoldCompare&quot;)

  let &amp;l:foldtext = s:foldtext_save
  unlet s:foldtext_save

  &quot; close all folds again so we can get the fold text as we go
  silent! %foldclose!

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

  &quot; if we've removed folds containing the conversion range from processing,
  &quot; getting foldtext as we go won't know to open the removed folds, so the
  &quot; foldtext would be wrong; open them now.
  &quot;
  &quot; Note that only when a start and an end line is specified will a fold
  &quot; containing the current range ever be removed.
  while leveladjust &gt; 0
    exe g:html_start_line.&quot;foldopen&quot;
    let leveladjust -= 1
  endwhile
endif

&quot; Now loop over all lines in the original text to convert to html.
&quot; Use html_start_line and html_end_line if they are set.
if exists(&quot;g:html_start_line&quot;)
  let s:lnum = html_start_line
  if s:lnum &lt; 1 || s:lnum &gt; line(&quot;$&quot;)
    let s:lnum = 1
  endif
else
  let s:lnum = 1
endif
if exists(&quot;g:html_end_line&quot;)
  let s:end = html_end_line
  if s:end &lt; s:lnum || s:end &gt; line(&quot;$&quot;)
    let s:end = line(&quot;$&quot;)
  endif
else
  let s:end = line(&quot;$&quot;)
endif

&quot; stack to keep track of all the folds containing the current line
let s:foldstack = []

if !s:settings.no_progress
  let s:pgb = s:ProgressBar(&quot;Processing lines:&quot;, s:end - s:lnum + 1, s:orgwin)
endif

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

if has('folding') &amp;&amp; !s:settings.ignore_folding
  let s:foldfillchar = &amp;fillchars[matchend(&amp;fillchars, 'fold:')]
  if s:foldfillchar == ''
    let s:foldfillchar = '-'
  endif
endif
let s:difffillchar = &amp;fillchars[matchend(&amp;fillchars, 'diff:')]
if s:difffillchar == ''
  let s:difffillchar = '-'
endif

let s:foldId = 0

if !s:settings.expand_tabs
  &quot; If keeping tabs, add them to printable characters so we keep them when
  &quot; formatting text (strtrans() doesn't replace printable chars)
  let s:old_isprint = &amp;isprint
  setlocal isprint+=9
endif

while s:lnum &lt;= s:end

  &quot; If there are filler lines for diff mode, show these above the line.
  let s:filler = diff_filler(s:lnum)
  if s:filler &gt; 0
    let s:n = s:filler
    while s:n &gt; 0
      let s:new = repeat(s:difffillchar, 3)

      if s:n &gt; 2 &amp;&amp; s:n &lt; s:filler &amp;&amp; !s:settings.whole_filler
	let s:new = s:new . &quot; &quot; . s:filler . &quot; inserted lines &quot;
	let s:n = 2
      endif

      if !s:settings.no_pre
	&quot; HTML line wrapping is off--go ahead and fill to the margin
	&quot; TODO: what about when CSS wrapping is turned on?
	let s:new = s:new . repeat(s:difffillchar, &amp;columns - strlen(s:new) - s:margin)
      else
	let s:new = s:new . repeat(s:difffillchar, 3)
      endif

      let s:new = s:HtmlFormat_d(s:new, s:DIFF_D_ID, 0)
      if s:settings.number_lines
	&quot; Indent if line numbering is on. Indent gets style of line number
	&quot; column.
	let s:new = s:HtmlFormat_n(repeat(' ', s:margin), s:LINENR_ID, 0, 0) . s:new
      endif
      if s:settings.dynamic_folds &amp;&amp; !s:settings.no_foldcolumn &amp;&amp; s:foldcolumn &gt; 0
	&quot; Indent for foldcolumn if there is one. Assume it's empty, there should
	&quot; not be a fold for deleted lines in diff mode.
	let s:new = s:FoldColumn_fill() . s:new
      endif
      call add(s:lines, s:new.s:HtmlEndline)

      let s:n = s:n - 1
    endwhile
    unlet s:n
  endif
  unlet s:filler

  &quot; Start the line with the line number.
  if s:settings.number_lines
    let s:numcol = repeat(' ', s:margin - 1 - strlen(s:lnum)) . s:lnum . ' '
  endif

  let s:new = &quot;&quot;

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

    &quot; put numcol in a separate group for sake of unselectable text
    let s:new = (s:settings.number_lines ? s:HtmlFormat_n(s:numcol, s:FOLDED_ID, 0, s:lnum): &quot;&quot;) . s:HtmlFormat_t(s:new, s:FOLDED_ID, 0)

    &quot; Skip to the end of the fold
    let s:new_lnum = foldclosedend(s:lnum)

    if !s:settings.no_progress
      call s:pgb.incr(s:new_lnum - s:lnum)
    endif

    let s:lnum = s:new_lnum

  else
    &quot;
    &quot; A line that is not folded, or doing dynamic folding.
    &quot;
    let s:line = getline(s:lnum)
    let s:len = strlen(s:line)

    if s:settings.dynamic_folds
      &quot; First insert a closing for any open folds that end on this line
      while !empty(s:foldstack) &amp;&amp; get(s:foldstack,0).lastline == s:lnum-1
	let s:new = s:new.&quot;&lt;/span&gt;&lt;/span&gt;&quot;
	call remove(s:foldstack, 0)
      endwhile

      &quot; Now insert an opening for any new folds that start on this line
      let s:firstfold = 1
      while !empty(s:allfolds) &amp;&amp; get(s:allfolds,0).firstline == s:lnum
	let s:foldId = s:foldId + 1
	let s:new .= &quot;&lt;span id='&quot;
	let s:new .= (exists('g:html_diff_win_num') ? &quot;win&quot;.g:html_diff_win_num : &quot;&quot;)
	let s:new .= &quot;fold&quot;.s:foldId.s:settings.id_suffix.&quot;' class='&quot;.s:allfolds[0].type.&quot;'&gt;&quot;


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

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

	&quot; Add fold text, moving the span ending to the next line so collapsing
	&quot; of folds works correctly.
	&quot; Put numcol in a separate group for sake of unselectable text.
	let s:new = s:new . (s:settings.number_lines ? s:HtmlFormat_n(s:numcol, s:FOLDED_ID, 0, 0) : &quot;&quot;) . substitute(s:HtmlFormat_t(foldtextresult(s:lnum), s:FOLDED_ID, 0), '&lt;/span&gt;', s:HtmlEndline.'\n\0', '')
	let s:new = s:new . &quot;&lt;span class='fulltext'&gt;&quot;

	&quot; open the fold now that we have the fold text to allow retrieval of
	&quot; fold text for subsequent folds
	execute s:lnum.&quot;foldopen&quot;
	call insert(s:foldstack, remove(s:allfolds,0))
	let s:foldstack[0].id = s:foldId
      endwhile

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

    &quot; Now continue with the unfolded line text
    if s:settings.number_lines
      let s:new = s:new . s:HtmlFormat_n(s:numcol, s:LINENR_ID, 0, s:lnum)
    elseif s:settings.line_ids
      let s:new = s:new . s:HtmlFormat_n(&quot;&quot;, s:LINENR_ID, 0, s:lnum)
    endif

    &quot; Get the diff attribute, if any.
    let s:diffattr = diff_hlID(s:lnum, 1)

    &quot; initialize conceal info to act like not concealed, just in case
    let s:concealinfo = [0, '']

    &quot; Loop over each character in the line
    let s:col = 1

    &quot; most of the time we won't use the diff_id, initialize to zero
    let s:diff_id = 0

    while s:col &lt;= s:len || (s:col == 1 &amp;&amp; s:diffattr)
      let s:startcol = s:col &quot; The start column for processing text
      if !s:settings.ignore_conceal &amp;&amp; has('conceal')
	let s:concealinfo = synconcealed(s:lnum, s:col)
      endif
      if !s:settings.ignore_conceal &amp;&amp; s:concealinfo[0]
	let s:col = s:col + 1
	&quot; Speed loop (it's small - that's the trick)
	&quot; Go along till we find a change in the match sequence number (ending
	&quot; the specific concealed region) or until there are no more concealed
	&quot; characters.
	while s:col &lt;= s:len &amp;&amp; s:concealinfo == synconcealed(s:lnum, s:col) | let s:col = s:col + 1 | endwhile
      elseif s:diffattr
	let s:diff_id = diff_hlID(s:lnum, s:col)
	let s:id = synID(s:lnum, s:col, 1)
	let s:col = s:col + 1
	&quot; Speed loop (it's small - that's the trick)
	&quot; Go along till we find a change in hlID
	while s:col &lt;= s:len &amp;&amp; s:id == synID(s:lnum, s:col, 1)
	      \   &amp;&amp; s:diff_id == diff_hlID(s:lnum, s:col) |
	      \     let s:col = s:col + 1 |
	      \ endwhile
	if s:len &lt; &amp;columns &amp;&amp; !s:settings.no_pre
	  &quot; Add spaces at the end of the raw text line to extend the changed
	  &quot; line to the full width.
	  let s:line = s:line . repeat(' ', &amp;columns - virtcol([s:lnum, s:len]) - s:margin)
	  let s:len = &amp;columns
	endif
      else
	let s:id = synID(s:lnum, s:col, 1)
	let s:col = s:col + 1
	&quot; Speed loop (it's small - that's the trick)
	&quot; Go along till we find a change in synID
	while s:col &lt;= s:len &amp;&amp; s:id == synID(s:lnum, s:col, 1) | let s:col = s:col + 1 | endwhile
      endif

      if s:settings.ignore_conceal || !s:concealinfo[0]
	&quot; Expand tabs if needed
	let s:expandedtab = strpart(s:line, s:startcol - 1, s:col - s:startcol)
	if s:settings.expand_tabs
	  let s:offset = 0
	  let s:idx = stridx(s:expandedtab, &quot;\t&quot;)
	  while s:idx &gt;= 0
	    if has(&quot;multi_byte_encoding&quot;)
	      if s:startcol + s:idx == 1
		let s:i = &amp;ts
	      else
		if s:idx == 0
		  let s:prevc = matchstr(s:line, '.\%' . (s:startcol + s:idx + s:offset) . 'c')
		else
		  let s:prevc = matchstr(s:expandedtab, '.\%' . (s:idx + 1) . 'c')
		endif
		let s:vcol = virtcol([s:lnum, s:startcol + s:idx + s:offset - len(s:prevc)])
		let s:i = &amp;ts - (s:vcol % &amp;ts)
	      endif
	      let s:offset -= s:i - 1
	    else
	      let s:i = &amp;ts - ((s:idx + s:startcol - 1) % &amp;ts)
	    endif
	    let s:expandedtab = substitute(s:expandedtab, '\t', repeat(' ', s:i), '')
	    let s:idx = stridx(s:expandedtab, &quot;\t&quot;)
	  endwhile
	end

	&quot; get the highlight group name to use
	let s:id = synIDtrans(s:id)
      else
	&quot; use Conceal highlighting for concealed text
	let s:id = s:CONCEAL_ID
	let s:expandedtab = s:concealinfo[1]
      endif

      &quot; Output the text with the same synID, with class set to the highlight ID
      &quot; name, unless it has been concealed completely.
      if strlen(s:expandedtab) &gt; 0
	let s:new = s:new . s:HtmlFormat(s:expandedtab,  s:id, s:diff_id, &quot;&quot;, 0)
      endif
    endwhile
  endif

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

  if !s:settings.no_progress
    call s:pgb.incr()
  endif
endwhile

if s:settings.dynamic_folds
  &quot; finish off any open folds
  while !empty(s:foldstack)
    let s:lines[-1].=&quot;&lt;/span&gt;&lt;/span&gt;&quot;
    call remove(s:foldstack, 0)
  endwhile

  &quot; add fold column to the style list if not already there
  let s:id = s:FOLD_C_ID
  if !has_key(s:stylelist, s:id)
    let s:stylelist[s:id] = '.FoldColumn { ' . s:CSS1(s:id) . '}'
  endif
endif

if s:settings.no_pre
  if !s:settings.use_css
    &quot; Close off the font tag that encapsulates the whole &lt;body&gt;
    call extend(s:lines, [&quot;&lt;/font&gt;&quot;, &quot;&lt;/body&gt;&quot;, &quot;&lt;/html&gt;&quot;])
  else
    call extend(s:lines, [&quot;&lt;/div&gt;&quot;, &quot;&lt;/body&gt;&quot;, &quot;&lt;/html&gt;&quot;])
  endif
else
  call extend(s:lines, [&quot;&lt;/pre&gt;&quot;, &quot;&lt;/body&gt;&quot;, &quot;&lt;/html&gt;&quot;])
endif

exe s:newwin . &quot;wincmd w&quot;
call setline(1, s:lines)
unlet s:lines

&quot; Mangle modelines so Vim doesn't try to use HTML text as a modeline if editing
&quot; this file in the future; need to do this after generating all the text in case
&quot; the modeline text has different highlight groups which all turn out to be
&quot; stripped from the final output.
%s!\v(%(^|\s+)%([Vv]i%(m%([&lt;=&gt;]?\d+)?)?|ex)):!\1\&amp;#0058;!ge

&quot; The generated HTML is admittedly ugly and takes a LONG time to fold.
&quot; Make sure the user doesn't do syntax folding when loading a generated file,
&quot; using a modeline.
call append(line('$'), &quot;&lt;!-- vim: set foldmethod=manual : --&gt;&quot;)

&quot; Now, when we finally know which, we define the colors and styles
if s:settings.use_css
  1;/&lt;style type=&quot;text/+1
endif

&quot; Normal/global attributes
&quot; For Netscape 4, set &lt;body&gt; attributes too, though, strictly speaking, it's
&quot; incorrect.
if s:settings.use_css
  if s:settings.no_pre
    call append('.', &quot;body { color: &quot; . s:fgc . &quot;; background-color: &quot; . s:bgc . &quot;; font-family: &quot;. s:htmlfont .&quot;; }&quot;)
    +
  else
    call append('.', &quot;pre { &quot; . s:whitespace . &quot;font-family: &quot;. s:htmlfont .&quot;; color: &quot; . s:fgc . &quot;; background-color: &quot; . s:bgc . &quot;; }&quot;)
    +
    yank
    put
    execute &quot;normal! ^cwbody\e&quot;
    &quot; body should not have the wrap formatting, only the pre section
    if s:whitespace != ''
      exec 's#'.s:whitespace
    endif
  endif
  &quot; fix browser inconsistencies (sometimes within the same browser) of different
  &quot; default font size for different elements
  call append('.', '* { font-size: 1em; }')
  +
  &quot; if we use any input elements for unselectable content, make sure they look
  &quot; like normal text
  if !empty(s:settings.prevent_copy)
    call append('.', 'input { border: none; margin: 0; padding: 0; font-family: '.s:htmlfont.'; }')
    +
    &quot; ch units for browsers which support them, em units for a somewhat
    &quot; reasonable fallback. Also make sure the special elements for size
    &quot; calculations aren't seen.
    call append('.', [
	  \ &quot;input[size='1'] { width: 1em; width: 1ch; }&quot;,
	  \ &quot;input[size='2'] { width: 2em; width: 2ch; }&quot;,
	  \ &quot;input[size='3'] { width: 3em; width: 3ch; }&quot;,
	  \ &quot;input[size='4'] { width: 4em; width: 4ch; }&quot;,
	  \ &quot;input[size='5'] { width: 5em; width: 5ch; }&quot;,
	  \ &quot;input[size='6'] { width: 6em; width: 6ch; }&quot;,
	  \ &quot;input[size='7'] { width: 7em; width: 7ch; }&quot;,
	  \ &quot;input[size='8'] { width: 8em; width: 8ch; }&quot;,
	  \ &quot;input[size='9'] { width: 9em; width: 9ch; }&quot;,
	  \ &quot;input[size='10'] { width: 10em; width: 10ch; }&quot;,
	  \ &quot;input[size='11'] { width: 11em; width: 11ch; }&quot;,
	  \ &quot;input[size='12'] { width: 12em; width: 12ch; }&quot;,
	  \ &quot;input[size='13'] { width: 13em; width: 13ch; }&quot;,
	  \ &quot;input[size='14'] { width: 14em; width: 14ch; }&quot;,
	  \ &quot;input[size='15'] { width: 15em; width: 15ch; }&quot;,
	  \ &quot;input[size='16'] { width: 16em; width: 16ch; }&quot;,
	  \ &quot;input[size='17'] { width: 17em; width: 17ch; }&quot;,
	  \ &quot;input[size='18'] { width: 18em; width: 18ch; }&quot;,
	  \ &quot;input[size='19'] { width: 19em; width: 19ch; }&quot;,
	  \ &quot;input[size='20'] { width: 20em; width: 20ch; }&quot;,
	  \ &quot;#oneCharWidth, #oneEmWidth, #oneInputWidth { padding: 0; margin: 0; position: absolute; left: -999999px; visibility: hidden; }&quot;
	  \ ])
    +21
    for w in range(5, 100, 5)
      let base = 0.01 * w
      call append('.', join(map(range(1,20), &quot;'.em'.w.' input[size='''.v:val.'''] { width: '.string(v:val*base).'em; }'&quot;)))
      +
    endfor
    if s:settings.prevent_copy =~# 'f'
    &quot; Make the cursor show active fold columns as active areas, and empty fold
    &quot; columns as not interactive.
      call append('.', ['input.FoldColumn { cursor: pointer; }',
	    \ 'input.FoldColumn[value=&quot;&quot;] { cursor: default; }'
	    \ ])
      +2
    endif
    &quot; make line number column show as non-interactive if not selectable
    if s:settings.prevent_copy =~# 'n'
      call append('.', 'input.LineNr { cursor: default; }')
      +
    endif
    &quot; make fold text and line number column within fold text show as
    &quot; non-interactive if not selectable
    if (s:settings.prevent_copy =~# 'n' || s:settings.prevent_copy =~# 't') &amp;&amp; !s:settings.ignore_folding
      call append('.', 'input.Folded { cursor: default; }')
      +
    endif
  endif
else
  execute '%s:&lt;body\([^&gt;]*\):&lt;body bgcolor=&quot;' . s:bgc . '&quot; text=&quot;' . s:fgc . '&quot;\1&gt;\r&lt;font face=&quot;'. s:htmlfont .'&quot;'
endif

&quot; Gather attributes for all other classes. Do diff first so that normal
&quot; highlight groups are inserted before it.
if s:settings.use_css
  if s:diff_mode
    call append('.', filter(map(keys(s:diffstylelist), &quot;s:diffstylelist[v:val]&quot;), 'v:val != &quot;&quot;'))
  endif
  if !empty(s:stylelist)
    call append('.', filter(map(keys(s:stylelist), &quot;s:stylelist[v:val]&quot;), 'v:val != &quot;&quot;'))
  endif
endif

&quot; Add hyperlinks
&quot; TODO: add option to not do this? Maybe just make the color the same as the
&quot; text highlight group normally is?
%s+\(https\=://\S\{-}\)\(\([.,;:}]\=\(\s\|$\)\)\|[\\&quot;'&lt;&gt;]\|&amp;gt;\|&amp;lt;\|&amp;quot;\)+&lt;a href=&quot;\1&quot;&gt;\1&lt;/a&gt;\2+ge

&quot; The DTD
if s:settings.use_xhtml
  exe &quot;normal! gg$a\n&lt;!DOCTYPE html PUBLIC \&quot;-//W3C//DTD XHTML 1.0 Transitional//EN\&quot; \&quot;http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\&quot;&gt;&quot;
elseif s:settings.use_css &amp;&amp; !s:settings.no_pre
  exe &quot;normal! gg0i&lt;!DOCTYPE HTML PUBLIC \&quot;-//W3C//DTD HTML 4.01//EN\&quot; \&quot;http://www.w3.org/TR/html4/strict.dtd\&quot;&gt;\n&quot;
else
  exe &quot;normal! gg0i&lt;!DOCTYPE HTML PUBLIC \&quot;-//W3C//DTD HTML 4.01 Transitional//EN\&quot; \&quot;http://www.w3.org/TR/html4/loose.dtd\&quot;&gt;\n&quot;
endif

if s:settings.use_xhtml
  exe &quot;normal! gg/&lt;html/e\na xmlns=\&quot;http://www.w3.org/1999/xhtml\&quot;\e&quot;
endif

&quot; Cleanup
%s:\s\+$::e

&quot; Restore old settings (new window first)
&quot;
&quot; Don't bother restoring foldmethod in case it was syntax because the markup is
&quot; so weirdly formatted it can take a LONG time.
let &amp;l:foldenable = s:old_fen
let &amp;report = s:old_report
let &amp;title = s:old_title
let &amp;icon = s:old_icon
let &amp;paste = s:old_paste
let &amp;magic = s:old_magic
let @/ = s:old_search
let &amp;more = s:old_more

&quot; switch to original window to restore those settings
exe s:orgwin . &quot;wincmd w&quot;

if !s:settings.expand_tabs
  let &amp;l:isprint = s:old_isprint
endif
let &amp;l:stl = s:origwin_stl
let &amp;l:et = s:old_et
let &amp;l:scrollbind = s:old_bind

&quot; and back to the new window again to end there
exe s:newwin . &quot;wincmd w&quot;

let &amp;l:stl = s:newwin_stl
exec 'resize' s:old_winheight
let &amp;l:winfixheight = s:old_winfixheight

let &amp;ls=s:ls

&quot; Save a little bit of memory (worth doing?)
unlet s:htmlfont s:whitespace
unlet s:old_et s:old_paste s:old_icon s:old_report s:old_title s:old_search
unlet s:old_magic s:old_more s:old_fen s:old_winheight
unlet! s:old_isprint
unlet s:whatterm s:stylelist s:diffstylelist s:lnum s:end s:margin s:fgc s:bgc s:old_winfixheight
unlet! s:col s:id s:attr s:len s:line s:new s:expandedtab s:concealinfo s:diff_mode
unlet! s:orgwin s:newwin s:orgbufnr s:idx s:i s:offset s:ls s:origwin_stl
unlet! s:newwin_stl s:current_syntax
if !v:profiling
  delfunc s:HtmlColor
  delfunc s:HtmlFormat
  delfunc s:CSS1
  delfunc s:BuildStyleWrapper
  if !s:settings.use_css
    delfunc s:HtmlOpening
    delfunc s:HtmlClosing
  endif
  if s:settings.dynamic_folds
    delfunc s:FoldCompare
  endif

  if !s:settings.no_progress
    delfunc s:ProgressBar
    delfunc s:progressbar.paint
    delfunc s:progressbar.incr
    unlet s:pgb s:progressbar
  endif
endif

unlet! s:new_lnum s:diffattr s:difffillchar s:foldfillchar s:HtmlSpace
unlet! s:LeadingSpace s:HtmlEndline s:firstfold s:numcol s:foldcolumn
unlet s:foldstack s:allfolds s:foldId s:settings

let &amp;cpo = s:cpo_sav
unlet! s:cpo_sav

&quot; Make sure any patches will probably use consistent indent
&quot;   vim: ts=8 sw=2 sts=2 noet
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fvim%2Fvim80%2Fsyntax'>Back to Directory</a>