akkartik/pong.love - Change 2QLTVKM6MVC25L44BSHKPZAXOOLK2VAUCGCYRUDRXXNYNSWDIWQAC

resolve conflicts

Created by akkartik on January 22, 2024

2QLTVKM6MVC25L44BSHKPZAXOOLK2VAUCGCYRUDRXXNYNSWDIWQAC

Dependencies

In channels

main

Change contents

File deletion: source.lua, source.lua

BFD:BFD[7.2] → [8.177715:177749]

BFD:BFD[8.177749] → [8.165829:165829]

B:BD[8.169531] → [6.2489:2665]

B:BD[9.51] → [6.2666:2848]

∅:D[6.2848] → [10.2008:2044]

∅:D[6.2665] → [8.169662:169706]

  Editor_state = edit.initialize_state(Margin_top, Margin_left + Line_number_width*font:getWidth('m'), right, font, settings.font_height, math.floor(settings.font_height*1.3))
  Editor_state = edit.initialize_state(Margin_top, Margin_left + Line_number_width*font:getWidth('m'), App.screen.width-Margin_right, font, font_height, math.floor(font_height*1.3))
  Editor_state.filename = 'run.lua'
  Editor_state.filename = settings.filename

File deletion: log_browser.lua, log_browser.lua

BFD:BFD[7.2] → [8.202684:202723]

BFD:BFD[8.202723] → [8.191243:191243]

B:BD[11.1717] → [6.2909:3015]

B:BD[11.1875] → [6.3016:3122]

B:BD[8.197122] → [6.3123:3297]

B:BD[8.197818] → [6.3298:3452]

∅:D[6.3452] → [8.197971:198624]

∅:D[6.3297] → [8.197295:197818]

∅:D[6.3122] → [8.195859:196035]

∅:D[6.3015] → [12.3529:3647]

          love.graphics.line(xleft+50+State.font:getWidth(line.section_name)+2,sectiony, xright,sectiony)
          love.graphics.line(xleft+50+State.font:getWidth(line.section_name)+2,sectiony, xright,sectiony)
      love.graphics.print(line.section_stack[i].name, x+State.font_height+5, App.screen.height-State.font:getWidth(line.section_stack[i].name)-5, --[[vertically]] math.pi/2)
      love.graphics.print(line.section_stack[i].name, x, App.screen.height-State.font:getWidth(line.section_stack[i].name)-5, --[[vertically]] math.pi/2)
    end
  end
  return log_browser.right_margin(State, line)
end
function should_show(line)
  -- Show a line if every single section it's in is expanded.
  for i=1,#line.section_stack do
    local section = line.section_stack[i]
    if not section.expanded then
      return false
    end
  end
  return true
end
function log_browser.left_margin(State, line)
  return State.left + #line.section_stack*Section_border_padding_horizontal
end
function log_browser.right_margin(State, line)
  return State.right - #line.section_stack*Section_border_padding_horizontal
end
function log_browser.update(State, dt)
end
function log_browser.quit(State)
end
    end
  end
  return log_browser.left_margin(State, line)
end
function render_stack_right_margin(State, line_index, line, y)
  App.color(Section_border_color)
  for i=1,#line.section_stack do
    local x = State.right - (i-1)*Section_border_padding_horizontal
    love.graphics.line(x,y, x,y+log_browser.height(State, line_index))
    if y < 30 then
      love.graphics.print(line.section_stack[i].name, x, y+5, --[[vertically]] math.pi/2)
    end
    if y > App.screen.height-log_browser.height(State, line_index) then
        end
      else
        if type(line.data) == 'string' then
          local old_left, old_right = State.left,State.right
          State.left,State.right = xleft,xright
        else assert(line.section_end, "log line has a section name, but it's neither the start nor end of a section")

Deletion in text.lua at line 44 [15.1]

B:BD[13.169] → [13.169:265]

BD:BD[13.169] → [13.169:265]

            Text.draw_cursor(State, State.left+Text.x(screen_line, State.cursor1.pos-pos+1), y)

Resurrecting zombie bytes in text.lua at line 45 [15.1]

∅:∅[16.112] → [13.265:571]

B:B[13.265] → [13.265:571]

BD:B[13.265] → [13.265:571]

          elseif pos + frag_len == State.cursor1.pos then
            -- Show cursor at end of line.
            -- This place also catches end of wrapping screen lines. That doesn't seem worth distinguishing.
            -- It seems useful to see a cursor whether your eye is on the left or right margin.

Resurrecting zombie bytes in text.lua at line 49 [15.1]

B:B[13.571] → [16.113:221]

BD:B[13.571] → [16.113:221]

            Text.draw_cursor(State, State.left+Text.x(State.font, screen_line, State.cursor1.pos-pos+1), y)

Insertion in text.lua at line 50 [15.1]

[16.221]

[16.222]

          end
        end
      end
      -- render fragment
      App.color(Text_color)
      App.screen.print(screen_line, State.left,y)
      y = y + State.line_height
      if y >= App.screen.height then
        break
      end
    end
  end
  return y, final_screen_line_starting_pos
end
function Text.screen_line(line, line_cache, i)
  local pos = line_cache.screen_line_starting_pos[i]
  local offset = Text.offset(line.data, pos)
  if i >= #line_cache.screen_line_starting_pos then
    return line.data:sub(offset)
  end
  local endpos = line_cache.screen_line_starting_pos[i+1]-1
  local end_offset = Text.offset(line.data, endpos)
  return line.data:sub(offset, end_offset)
end
function Text.draw_cursor(State, x, y)
  -- blink every 0.5s
  if math.floor(Cursor_time*2)%2 == 0 then
    App.color(Cursor_color)
    love.graphics.rectangle('fill', x,y, 3,State.line_height)
  end
  State.cursor_x = x
  State.cursor_y = y+State.line_height
end
function Text.populate_screen_line_starting_pos(State, line_index)
  local line = State.lines[line_index]
  local line_cache = State.line_cache[line_index]
  if line_cache.screen_line_starting_pos then
    return
  end
  line_cache.screen_line_starting_pos = {1}
  local x = 0
  local pos = 1
  -- try to wrap at word boundaries
  for frag in line.data:gmatch('%S*%s*') do

Resurrecting zombie bytes in text.lua at line 98 [15.1]

∅:∅[16.271] → [18.1613:1820]

B:B[19.128] → [18.1613:1820]

BD:B[19.128] → [18.1613:1820]

--?     print('-- frag:', frag, pos, x, frag_width, State.width)
    while x + frag_width > State.width do
--?       print('frag:', frag, pos, x, frag_width, State.width)
      if x < 0.8 * State.width then

Resurrecting zombie bytes in text.lua at line 102 [15.1]
B:B[18.1820] → [20.84319:84416]
BD:B[18.1820] → [20.84319:84416]
```
        -- long word; chop it at some letter
        -- We're not going to reimplement TeX here.
```
Deletion in text.lua at line 104 [15.1]
∅:D[20.84416] → [18.1821:1892]
B:BD[21.331] → [18.1821:1892]
BD:BD[21.331] → [18.1821:1892]
```
        local bpos = Text.nearest_pos_less_than(frag, State.width - x)
```
Resurrecting zombie bytes in text.lua at line 104 [15.1]
B:B[21.331] → [16.272:355]
BD:B[21.331] → [16.272:355]
```
        local bpos = Text.nearest_pos_less_than(State.font, frag, State.width - x)
```
Solving an order conflict in text.lua at line 104 [15.1]
[20.84416]
[16.272]
Resurrecting zombie bytes in text.lua at line 114 [15.1]
B:B[18.2074] → [16.356:403]
BD:B[18.2074] → [16.356:403]
```
        frag_width = State.font:getWidth(frag)
```

Deletion in text.lua at line 115 [15.1]

B:BD[22.4502] → [6.7:7]

BD:BD[22.4502] → [6.7:7]

B:BD[23.4196] → [6.8:132]

BD:BD[23.4196] → [6.8:132]

∅:D[24.127] → [23.4197:4427]

B:BD[24.127] → [23.4197:4427]

B:BD[25.2441] → [23.4197:4427]

D:D[24.127] → [23.4197:4427]

BD:BD[25.2441] → [23.4197:4427]

B:BD[23.4427] → [6.134:134]

BD:BD[23.4427] → [6.134:134]

∅:D[6.134] → [16.531:657]

B:BD[26.5703] → [16.531:657]

BD:BD[26.5703] → [16.531:657]

B:BD[22.5568] → [6.135:263]

BD:BD[22.5568] → [6.135:263]

B:BD[22.5714] → [6.265:265]

BD:BD[22.5714] → [6.265:265]

B:BD[25.4338] → [23.4545:4775]

BD:BD[25.4338] → [23.4545:4775]

B:BD[23.4775] → [6.267:267]

BD:BD[23.4775] → [6.267:267]

∅:D[6.267] → [16.775:901]

B:BD[26.7111] → [16.775:901]

BD:BD[26.7111] → [16.775:901]

B:BD[28.538] → [23.5739:5811]

D:D[28.538] → [23.5739:5811]

BD:BD[28.538] → [23.5739:5811]

B:BD[23.5811] → [6.269:269]

BD:BD[23.5811] → [6.269:269]

∅:D[6.269] → [16.902:1180]

B:BD[31.1751] → [16.902:1180]

BD:BD[31.1751] → [16.902:1180]

B:BD[32.1530] → [16.1181:1223]

BD:BD[32.1530] → [16.1181:1223]

B:BD[33.25] → [16.1224:1278]

BD:BD[33.25] → [16.1224:1278]

B:BD[34.383] → [16.1279:1326]

BD:BD[34.383] → [16.1279:1326]

B:BD[35.208] → [16.1327:1431]

BD:BD[35.208] → [16.1327:1431]

B:BD[33.48] → [16.1432:1483]

BD:BD[33.48] → [16.1432:1483]

B:BD[36.7300] → [16.1484:1530]

BD:BD[36.7300] → [16.1484:1530]

B:BD[36.7496] → [16.1531:1639]

BD:BD[36.7496] → [16.1531:1639]

B:BD[37.3662] → [16.1640:1676]

BD:BD[37.3662] → [16.1640:1676]

B:BD[37.3817] → [16.1677:1710]

BD:BD[37.3817] → [16.1677:1710]

B:BD[36.7881] → [16.1711:1741]

BD:BD[36.7881] → [16.1711:1741]

B:BD[38.1333] → [16.1742:1775]

BD:BD[38.1333] → [16.1742:1775]

∅:D[18.2074] → [19.175:212]

B:BD[21.1160] → [19.175:212]

D:D[18.2074] → [19.175:212]

BD:BD[21.1160] → [19.175:212]

      State.cursor1.pos = screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, State.cursor_x, State.left) - 1
    local new_screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line].data, new_screen_line_starting_pos)
    local s = string.sub(State.lines[State.cursor1.line].data, new_screen_line_starting_byte_offset)
    State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, State.cursor_x, State.left) - 1
      State.cursor1.pos = Text.nearest_cursor_pos(State.font, State.lines[State.cursor1.line].data, State.cursor_x, State.left)
    local new_screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line].data, new_screen_line_starting_pos)
    local s = string.sub(State.lines[State.cursor1.line].data, new_screen_line_starting_byte_offset)
    State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, State.cursor_x, State.left) - 1
      local s = string.sub(line.data, screen_line_starting_byte_offset)
--?       print('return', mx, Text.nearest_cursor_pos(State.font, s, mx, State.left), '=>', screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, mx, State.left) - 1)
      return screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, mx, State.left) - 1
  return State.font:getWidth(screen_line)
function Text.nearest_cursor_pos(font, line, x, left)
  local max_x = left+Text.x(font, line, len+1)
    local currxmin = left+Text.x(font, line, curr)
    local currxmax = left+Text.x(font, line, curr+1)
function Text.nearest_pos_less_than(font, line, x)
  local max_x = Text.x_after(font, line, len)
    local currxmin = Text.x_after(font, line, curr+1)
    local currxmax = Text.x_after(font, line, curr+2)
function Text.x_after(font, s, pos)
  return font:getWidth(s_before)
function Text.x(font, s, pos)
  return font:getWidth(s_before)
        frag_width = App.width(frag)

Resurrecting zombie bytes in text.lua at line 115 [15.1]
B:B[19.212] → [20.84531:84541]
BD:B[19.212] → [20.84531:84541]
```
      end
```
Solving an order conflict in text.lua at line 115 [15.1]
[16.403]
[20.84531]

Replacement in text.lua at line 406 [15.1]

B:BD[20.97181] → [20.97181:97293]

      State.cursor1.pos = screen_line_starting_pos + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1

[20.97181]

[20.97293]

      State.cursor1.pos = screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, State.cursor_x, State.left) - 1

Replacement in text.lua at line 414 [15.1]

B:BD[20.97743] → [20.97743:97857]

    State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1

[20.97743]

[20.97857]

    State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, State.cursor_x, State.left) - 1

Replacement in text.lua at line 435 [15.1]

B:BD[20.98692] → [20.98692:98808]

      State.cursor1.pos = Text.nearest_cursor_pos(State.lines[State.cursor1.line].data, State.cursor_x, State.left)

[20.98692]

[20.98808]

      State.cursor1.pos = Text.nearest_cursor_pos(State.font, State.lines[State.cursor1.line].data, State.cursor_x, State.left)

Replacement in text.lua at line 454 [15.1]

B:BD[20.100055] → [20.100055:100169]

    State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1

[20.100055]

[20.100169]

    State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, State.cursor_x, State.left) - 1

Replacement in text.lua at line 668 [15.1]

B:BD[20.107898] → [20.107898:108140]

--?       print('return', mx, Text.nearest_cursor_pos(s, mx, State.left), '=>', screen_line_starting_pos + Text.nearest_cursor_pos(s, mx, State.left) - 1)
      return screen_line_starting_pos + Text.nearest_cursor_pos(s, mx, State.left) - 1

[20.107898]

[20.108140]

--?       print('return', mx, Text.nearest_cursor_pos(State.font, s, mx, State.left), '=>', screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, mx, State.left) - 1)
      return screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, mx, State.left) - 1

Replacement in text.lua at line 689 [15.1]
B:BD[20.108787] → [20.108787:108819]
```
  return App.width(screen_line)
```
[20.108787]
[20.108819]
```
  return State.font:getWidth(screen_line)
```
Replacement in text.lua at line 703 [15.1]
B:BD[20.109096] → [20.109096:109144]
```
function Text.nearest_cursor_pos(line, x, left)
```
[20.109096]
[20.109144]
```
function Text.nearest_cursor_pos(font, line, x, left)
```
Replacement in text.lua at line 708 [15.1]
B:BD[20.109211] → [20.109211:109252]
```
  local max_x = left+Text.x(line, len+1)
```
[20.109211]
[20.109252]
```
  local max_x = left+Text.x(font, line, len+1)
```

Replacement in text.lua at line 720 [15.1]

B:BD[20.109551] → [20.109551:109643]

    local currxmin = left+Text.x(line, curr)
    local currxmax = left+Text.x(line, curr+1)

[20.109551]

[20.109643]

    local currxmin = left+Text.x(font, line, curr)
    local currxmax = left+Text.x(font, line, curr+1)

Replacement in text.lua at line 745 [15.1]
B:BD[20.110182] → [20.110182:110227]
```
function Text.nearest_pos_less_than(line, x)
```
[20.110182]
[20.110227]
```
function Text.nearest_pos_less_than(font, line, x)
```
Replacement in text.lua at line 748 [15.1]
B:BD[20.110309] → [20.110309:110349]
```
  local max_x = Text.x_after(line, len)
```
[20.110309]
[20.110349]
```
  local max_x = Text.x_after(font, line, len)
```

Replacement in text.lua at line 755 [15.1]

B:BD[20.110483] → [20.110483:110579]

    local currxmin = Text.x_after(line, curr+1)
    local currxmax = Text.x_after(line, curr+2)

[20.110483]

[20.110579]

    local currxmin = Text.x_after(font, line, curr+1)
    local currxmax = Text.x_after(font, line, curr+2)

Replacement in text.lua at line 773 [15.1]
B:BD[20.110868] → [20.110868:110898]
```
function Text.x_after(s, pos)
```
[20.110868]
[4.4]
```
function Text.x_after(font, s, pos)
```
Replacement in text.lua at line 778 [15.1]
B:BD[20.111023] → [20.111023:111052]
```
  return App.width(s_before)
```
[20.111023]
[20.111052]
```
  return font:getWidth(s_before)
```
Replacement in text.lua at line 781 [15.1]
B:BD[20.111057] → [20.111057:111081]
```
function Text.x(s, pos)
```
[20.111057]
[20.111081]
```
function Text.x(font, s, pos)
```
Replacement in text.lua at line 784 [15.1]
B:BD[20.111156] → [20.111156:111185]
```
  return App.width(s_before)
```
[20.111156]
[20.111185]
```
  return font:getWidth(s_before)
```

Deletion in text.lua at line 957 [15.1]

B:BD[20.115545] → [4.88:88]

B:BD[13.571] → [14.40:172]

∅:D[14.172] → [39.126:229]

B:BD[40.2604] → [39.126:229]

∅:D[39.229] → [18.1049:1142]

∅:D[20.83681] → [18.1049:1142]

B:BD[40.2604] → [18.1049:1142]

B:BD[18.1142] → [20.83682:83696]

B:BD[20.83696] → [41.85:85]

∅:D[41.85] → [42.84:127]

B:BD[43.37] → [42.84:127]

∅:D[42.127] → [18.1206:1441]

B:BD[18.1206] → [18.1206:1441]

B:BD[18.1441] → [20.83697:83703]

∅:D[20.83703] → [18.1442:1597]

B:BD[44.144] → [18.1442:1597]

B:BD[18.1597] → [20.83704:83903]

B:BD[20.83929] → [20.83929:84263]

∅:D[20.84263] → [18.1598:1612]

B:BD[45.443] → [18.1598:1612]

B:BD[18.1612] → [20.84264:84316]

∅:D[20.84316] → [23.1894:1938]

B:BD[46.124] → [23.1894:1938]

B:BD[23.1938] → [20.84318:84318]

BD:BD[23.1938] → [20.84318:84318]

∅:D[20.84318] → [19.89:128]

B:BD[47.747] → [19.89:128]

BD:BD[47.747] → [19.89:128]

B:BD[23.1938] → [6.5:5]

            Text.draw_cursor(State, State.left+Text.x(screen_line, State.cursor1.pos-pos+1), y)
          end
        end
      end
      -- render fragment
      App.color(Text_color)
      App.screen.print(screen_line, State.left,y)
      y = y + State.line_height
      if y >= App.screen.height then
        break
      end
    end
  end
  return y, final_screen_line_starting_pos
end
function Text.screen_line(line, line_cache, i)
  local pos = line_cache.screen_line_starting_pos[i]
  local offset = Text.offset(line.data, pos)
  if i >= #line_cache.screen_line_starting_pos then
    return line.data:sub(offset)
  end
  local endpos = line_cache.screen_line_starting_pos[i+1]-1
  local end_offset = Text.offset(line.data, endpos)
  return line.data:sub(offset, end_offset)
end
function Text.draw_cursor(State, x, y)
  -- blink every 0.5s
  if math.floor(Cursor_time*2)%2 == 0 then
    App.color(Cursor_color)
    love.graphics.rectangle('fill', x,y, 3,State.line_height)
  end
  State.cursor_x = x
  State.cursor_y = y+State.line_height
end
function Text.populate_screen_line_starting_pos(State, line_index)
  local line = State.lines[line_index]
  local line_cache = State.line_cache[line_index]
  if line_cache.screen_line_starting_pos then
    return
  end
  line_cache.screen_line_starting_pos = {1}
  local x = 0
  local pos = 1
  -- try to wrap at word boundaries
  for frag in line.data:gmatch('%S*%s*') do
    local frag_width = App.width(frag)

Solving an order conflict in text.lua at line 957 [15.1]
[20.115545]

Replacement in source_text.lua at line 17 [8.83786]

B:BD[48.153] → [48.153:239]

    love.graphics.print(line_index, State.left-Line_number_width*App.width('m')+10,y)

[48.153]

[48.239]

    love.graphics.print(line_index, State.left-Line_number_width*State.font:getWidth('m')+10,y)

Deletion in source_text.lua at line 27 [8.83786]
B:BD[17.87400] → [49.2062:2062]
B:BD[50.153] → [6.274:370]
BD:BD[50.153] → [6.274:370]
```
    love.graphics.print(line_index, State.left-Line_number_width*State.font:getWidth('m')+10,y)
```
Solving an order conflict in source_text.lua at line 27 [8.83786]
[17.87400]
[51.413]
Deletion in source_text.lua at line 35 [8.83786]
B:BD[51.764] → [51.764:850]
BD:BD[51.764] → [51.764:850]
```
        local lo, hi = Text.clip_wikiword_with_screen_line(line, line_cache, i, s, e)
```
Resurrecting zombie bytes in source_text.lua at line 36 [8.83786]
∅:∅[6.469] → [51.850:869]
B:B[51.850] → [51.850:869]
BD:B[51.850] → [51.850:869]
```
        if lo then
```

Resurrecting zombie bytes in source_text.lua at line 38 [8.83786]

∅:∅[52.93] → [51.969:1233]

∅:∅[53.111] → [51.969:1233]

B:B[53.111] → [51.969:1233]

B:B[51.969] → [51.969:1233]

BD:B[51.969] → [51.969:1233]

            icon = icon.hyperlink_decoration,
            onpress1 = function()
                         if file_exists(filename) then
                           source.switch_to_file(filename)
                         end
                       end,
          })

Deletion in source_text.lua at line 65 [8.83786]

B:BD[54.936] → [54.936:1032]

BD:BD[54.936] → [54.936:1032]

            Text.draw_cursor(State, State.left+Text.x(screen_line, State.cursor1.pos-pos+1), y)

Resurrecting zombie bytes in source_text.lua at line 66 [8.83786]

∅:∅[6.578] → [54.1032:1338]

B:B[54.1032] → [54.1032:1338]

BD:B[54.1032] → [54.1032:1338]

          elseif pos + frag_len == State.cursor1.pos then
            -- Show cursor at end of line.
            -- This place also catches end of wrapping screen lines. That doesn't seem worth distinguishing.
            -- It seems useful to see a cursor whether your eye is on the left or right margin.

Deletion in source_text.lua at line 70 [8.83786]
B:BD[54.1338] → [54.1338:1434]
BD:BD[54.1338] → [54.1338:1434]
```
            Text.draw_cursor(State, State.left+Text.x(screen_line, State.cursor1.pos-pos+1), y)
```
Resurrecting zombie bytes in source_text.lua at line 71 [8.83786]
∅:∅[6.687] → [54.1434:1470]
B:B[54.1434] → [54.1434:1470]
BD:B[54.1434] → [54.1434:1470]
```
          end
        end
      end
```
Deletion in source_text.lua at line 79 [8.83786]
B:BD[14.350] → [14.350:380]
```
        x = x+App.width(frag)
```
Resurrecting zombie bytes in source_text.lua at line 79 [8.83786]
B:B[55.409] → [6.688:728]
BD:B[55.409] → [6.688:728]
```
        x = x+State.font:getWidth(frag)
```
Solving an order conflict in source_text.lua at line 79 [8.83786]
[14.350]
[6.688]
Deletion in source_text.lua at line 123 [8.83786]
B:BD[51.2472] → [51.2472:2511]
BD:BD[51.2472] → [51.2472:2511]
```
    local frag_width = App.width(frag)
```

Resurrecting zombie bytes in source_text.lua at line 124 [8.83786]

∅:∅[6.778] → [51.2511:2815]

B:B[51.2511] → [51.2511:2815]

BD:B[51.2511] → [51.2511:2815]

--?     print('-- frag:', frag, pos, x, frag_width, State.width)
    while x + frag_width > State.width do
--?       print('frag:', frag, pos, x, frag_width, State.width)
      if x < 0.8 * State.width then
        -- long word; chop it at some letter
        -- We're not going to reimplement TeX here.

Deletion in source_text.lua at line 130 [8.83786]
B:BD[51.2815] → [51.2815:2886]
BD:BD[51.2815] → [51.2815:2886]
```
        local bpos = Text.nearest_pos_less_than(frag, State.width - x)
```

Resurrecting zombie bytes in source_text.lua at line 134 [8.83786]

∅:∅[57.200] → [51.2956:3180]

B:B[51.2956] → [51.2956:3180]

BD:B[51.2956] → [51.2956:3180]

        pos = pos + bpos
        local boffset = Text.offset(frag, bpos+1)  -- byte _after_ bpos
        frag = string.sub(frag, boffset)
--?         if bpos > 0 then
--?           print('after chop:', frag)
--?         end

Deletion in source_text.lua at line 140 [8.83786]
B:BD[51.3180] → [51.3180:3217]
BD:BD[51.3180] → [51.3180:3217]
```
        frag_width = App.width(frag)
```
Resurrecting zombie bytes in source_text.lua at line 141 [8.83786]
∅:∅[6.910] → [51.3217:3264]
B:B[51.3217] → [51.3217:3264]
BD:B[51.3217] → [51.3217:3264]
```
      end
--?       print('screen line:', pos)
```

Replacement in source_text.lua at line 175 [8.83786]

B:BD[41.2394] → [41.2394:2466]

function Text.clip_wikiword_with_screen_line(line, line_cache, i, s, e)

[41.2394]

[41.2466]

function Text.clip_wikiword_with_screen_line(font, line, line_cache, i, s, e)

Replacement in source_text.lua at line 197 [8.83786]

B:BD[41.2956] → [59.38:124]

  return App.width(line.data:sub(soff, loff-1)), App.width(line.data:sub(soff, hoff))

[41.2956]

[17.96733]

  return font:getWidth(line.data:sub(soff, loff-1)), font:getWidth(line.data:sub(soff, hoff))

Deletion in source_text.lua at line 274 [8.83786]
B:BD[17.101399] → [60.485:485]
B:BD[51.3993] → [6.911:989]
BD:BD[51.3993] → [6.911:989]
B:BD[51.4555] → [6.990:1084]
BD:BD[51.4555] → [6.990:1084]
BD:BD[51.4555] → [6.990:1084]
```
function Text.clip_wikiword_with_screen_line(font, line, line_cache, i, s, e)
  return font:getWidth(line.data:sub(soff, loff-1)), font:getWidth(line.data:sub(soff, hoff))
```

Resurrecting zombie bytes in source_text.lua at line 274 [8.83786]

B:B[8.110992] → [6.1212:1338]

BD:B[8.110992] → [6.1212:1338]

    State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, State.cursor_x, State.left) - 1

Solving an order conflict in source_text.lua at line 274 [8.83786]
[17.101399]

Insertion in source_text.lua at line 274 [8.83786]

[0.3001]

[6.1212]

      if State.lines[State.cursor1.line-1].mode == 'drawing' then
        table.remove(State.lines, State.cursor1.line-1)
        table.remove(State.line_cache, State.cursor1.line-1)
      else
        -- join lines
        State.cursor1.pos = utf8.len(State.lines[State.cursor1.line-1].data)+1
        State.lines[State.cursor1.line-1].data = State.lines[State.cursor1.line-1].data..State.lines[State.cursor1.line].data
        table.remove(State.lines, State.cursor1.line)
        table.remove(State.line_cache, State.cursor1.line)
      end
      State.cursor1.line = State.cursor1.line-1
    end
    if State.screen_top1.line > #State.lines then
      Text.populate_screen_line_starting_pos(State, #State.lines)
      local line_cache = State.line_cache[#State.line_cache]
      State.screen_top1 = {line=#State.lines, pos=line_cache.screen_line_starting_pos[#line_cache.screen_line_starting_pos]}
    elseif Text.lt1(State.cursor1, State.screen_top1) then
      State.screen_top1 = {
        line=State.cursor1.line,
        pos=Text.pos_at_start_of_screen_line(State, State.cursor1),
      }
      Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks
    end
    Text.clear_screen_line_cache(State, State.cursor1.line)
    assert(Text.le1(State.screen_top1, State.cursor1), ('screen_top (line=%d,pos=%d) is below cursor (line=%d,pos=%d)'):format(State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos))
    schedule_save(State)
    record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
  elseif chord == 'delete' then
    if State.selection1.line then
      Text.delete_selection(State, State.left, State.right)
      schedule_save(State)
      return
    end
    local before
    if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then
      before = snapshot(State, State.cursor1.line)
    else
      before = snapshot(State, State.cursor1.line, State.cursor1.line+1)
    end
    if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then
      local byte_start = utf8.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
      local byte_end = utf8.offset(State.lines[State.cursor1.line].data, State.cursor1.pos+1)
      if byte_start then
        if byte_end then
          State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)..string.sub(State.lines[State.cursor1.line].data, byte_end)
        else
          State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)
        end
        -- no change to State.cursor1.pos
      end
    elseif State.cursor1.line < #State.lines then
      if State.lines[State.cursor1.line+1].mode == 'text' then
        -- join lines
        State.lines[State.cursor1.line].data = State.lines[State.cursor1.line].data..State.lines[State.cursor1.line+1].data
      end
      table.remove(State.lines, State.cursor1.line+1)
      table.remove(State.line_cache, State.cursor1.line+1)
    end
    Text.clear_screen_line_cache(State, State.cursor1.line)
    schedule_save(State)
    record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
  --== shortcuts that move the cursor
  elseif chord == 'left' then
    Text.left(State)
    State.selection1 = {}
  elseif chord == 'right' then
    Text.right(State)
    State.selection1 = {}
  elseif chord == 'S-left' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.left(State)
  elseif chord == 'S-right' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.right(State)
  -- C- hotkeys reserved for drawings, so we'll use M-
  elseif chord == 'M-left' then
    Text.word_left(State)
    State.selection1 = {}
  elseif chord == 'M-right' then
    Text.word_right(State)
    State.selection1 = {}
  elseif chord == 'M-S-left' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.word_left(State)
  elseif chord == 'M-S-right' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.word_right(State)
  elseif chord == 'home' then
    Text.start_of_line(State)
    State.selection1 = {}
  elseif chord == 'end' then
    Text.end_of_line(State)
    State.selection1 = {}
  elseif chord == 'S-home' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.start_of_line(State)
  elseif chord == 'S-end' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.end_of_line(State)
  elseif chord == 'up' then
    Text.up(State)
    State.selection1 = {}
  elseif chord == 'down' then
    Text.down(State)
    State.selection1 = {}
  elseif chord == 'S-up' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.up(State)
  elseif chord == 'S-down' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.down(State)
  elseif chord == 'pageup' then
    Text.pageup(State)
    State.selection1 = {}
  elseif chord == 'pagedown' then
    Text.pagedown(State)
    State.selection1 = {}
  elseif chord == 'S-pageup' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.pageup(State)
  elseif chord == 'S-pagedown' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.pagedown(State)
  end
end
function Text.insert_return(State)
  local byte_offset = Text.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
  table.insert(State.lines, State.cursor1.line+1, {mode='text', data=string.sub(State.lines[State.cursor1.line].data, byte_offset)})
  table.insert(State.line_cache, State.cursor1.line+1, {})
  State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_offset-1)
  Text.clear_screen_line_cache(State, State.cursor1.line)
  State.cursor1 = {line=State.cursor1.line+1, pos=1}
end
function Text.pageup(State)
--?   print('pageup')
  -- duplicate some logic from love.draw
  local top2 = Text.to2(State, State.screen_top1)
--?   print(App.screen.height)
  local y = App.screen.height - State.line_height
  while y >= State.top do
--?     print(y, top2.line, top2.screen_line, top2.screen_pos)
    if State.screen_top1.line == 1 and State.screen_top1.pos == 1 then break end
    if State.lines[State.screen_top1.line].mode == 'text' then
      y = y - State.line_height
    elseif State.lines[State.screen_top1.line].mode == 'drawing' then
      y = y - Drawing_padding_height - Drawing.pixels(State.lines[State.screen_top1.line].h, State.width)
    end
    top2 = Text.previous_screen_line(State, top2)
  end
  State.screen_top1 = Text.to1(State, top2)
  State.cursor1 = {line=State.screen_top1.line, pos=State.screen_top1.pos}
  Text.move_cursor_down_to_next_text_line_while_scrolling_again_if_necessary(State)
--?   print(State.cursor1.line, State.cursor1.pos, State.screen_top1.line, State.screen_top1.pos)
--?   print('pageup end')
end
function Text.pagedown(State)
--?   print('pagedown')
  State.screen_top1 = {line=State.screen_bottom1.line, pos=State.screen_bottom1.pos}
--?   print('setting top to', State.screen_top1.line, State.screen_top1.pos)
  State.cursor1 = {line=State.screen_top1.line, pos=State.screen_top1.pos}
  Text.move_cursor_down_to_next_text_line_while_scrolling_again_if_necessary(State)
--?   print('top now', State.screen_top1.line)
  Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks
--?   print('pagedown end')
end
function Text.up(State)
  assert(State.lines[State.cursor1.line].mode == 'text', 'line is not text')
--?   print('up', State.cursor1.line, State.cursor1.pos, State.screen_top1.line, State.screen_top1.pos)
  local screen_line_starting_pos, screen_line_index = Text.pos_at_start_of_screen_line(State, State.cursor1)
  if screen_line_starting_pos == 1 then
--?     print('cursor is at first screen line of its line')
    -- line is done; skip to previous text line
    local new_cursor_line = State.cursor1.line
    while new_cursor_line > 1 do
      new_cursor_line = new_cursor_line-1
      if State.lines[new_cursor_line].mode == 'text' then
--?         print('found previous text line')
        State.cursor1 = {line=new_cursor_line, pos=nil}
        Text.populate_screen_line_starting_pos(State, State.cursor1.line)
        -- previous text line found, pick its final screen line
--?         print('has multiple screen lines')
        local screen_line_starting_pos = State.line_cache[State.cursor1.line].screen_line_starting_pos
--?         print(#screen_line_starting_pos)
        screen_line_starting_pos = screen_line_starting_pos[#screen_line_starting_pos]
        local screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line].data, screen_line_starting_pos)
        local s = string.sub(State.lines[State.cursor1.line].data, screen_line_starting_byte_offset)
        State.cursor1.pos = screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, State.cursor_x, State.left) - 1
        break
      end
    end
  else
    -- move up one screen line in current line
    assert(screen_line_index > 1, 'bumped up against top screen line in line')
    local new_screen_line_starting_pos = State.line_cache[State.cursor1.line].screen_line_starting_pos[screen_line_index-1]
    local new_screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line].data, new_screen_line_starting_pos)
    local s = string.sub(State.lines[State.cursor1.line].data, new_screen_line_starting_byte_offset)

Insertion in source_text.lua at line 495 [8.83786]

[6.1338]

[62.4021]

--?     print('cursor pos is now '..tostring(State.cursor1.pos))
  end
  if Text.lt1(State.cursor1, State.screen_top1) then

Deletion in source_text.lua at line 519 [8.83786]

B:BD[63.7779] → [63.7779:7883]

BD:BD[63.7779] → [63.7779:7883]

          pos = Text.nearest_cursor_pos(State.lines[new_cursor_line].data, State.cursor_x, State.left),

Resurrecting zombie bytes in source_text.lua at line 520 [8.83786]
∅:∅[6.1455] → [63.7883:7954]
B:B[63.7883] → [63.7883:7954]
BD:B[63.7883] → [63.7883:7954]
```
        }
--?         print(State.cursor1.pos)
        break
      end
```

Replacement in source_text.lua at line 541 [8.83786]

B:BD[17.113543] → [17.113543:113657]

    State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1

[17.113543]

[17.113657]

    State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, State.cursor_x, State.left) - 1

Deletion in source_text.lua at line 553 [8.83786]
B:BD[17.115273] → [65.3937:3937]
B:BD[8.116711] → [6.1456:1582]
BD:BD[8.116711] → [6.1456:1582]
```
    State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, State.cursor_x, State.left) - 1
```
Solving an order conflict in source_text.lua at line 553 [8.83786]
[17.115273]
[62.4303]

Replacement in source_text.lua at line 804 [8.83786]

B:BD[65.6303] → [65.6303:6545]

--?       print('return', mx, Text.nearest_cursor_pos(s, mx, State.left), '=>', screen_line_starting_pos + Text.nearest_cursor_pos(s, mx, State.left) - 1)
      return screen_line_starting_pos + Text.nearest_cursor_pos(s, mx, State.left) - 1

[65.6303]

[17.131630]

--?       print('return', mx, Text.nearest_cursor_pos(State.font, s, mx, State.left), '=>', screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, mx, State.left) - 1)
      return screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, mx, State.left) - 1

Replacement in source_text.lua at line 825 [8.83786]
B:BD[17.133166] → [20.116413:116445]
```
  return App.width(screen_line)
```
[17.133166]
[17.133375]
```
  return State.font:getWidth(screen_line)
```
Replacement in source_text.lua at line 839 [8.83786]
B:BD[17.133923] → [17.133923:133971]
```
function Text.nearest_cursor_pos(line, x, left)
```
[17.133923]
[17.133971]
```
function Text.nearest_cursor_pos(font, line, x, left)
```
Replacement in source_text.lua at line 844 [8.83786]
B:BD[17.134038] → [17.134038:134079]
```
  local max_x = left+Text.x(line, len+1)
```
[17.134038]
[17.134079]
```
  local max_x = left+Text.x(font, line, len+1)
```

Replacement in source_text.lua at line 856 [8.83786]

B:BD[17.134378] → [17.134378:134470]

    local currxmin = left+Text.x(line, curr)
    local currxmax = left+Text.x(line, curr+1)

[17.134378]

[17.134470]

    local currxmin = left+Text.x(font, line, curr)
    local currxmax = left+Text.x(font, line, curr+1)

Replacement in source_text.lua at line 881 [8.83786]
B:BD[17.135009] → [17.135009:135054]
```
function Text.nearest_pos_less_than(line, x)
```
[17.135009]
[17.135054]
```
function Text.nearest_pos_less_than(font, line, x)
```
Replacement in source_text.lua at line 884 [8.83786]
B:BD[17.135136] → [17.135136:135176]
```
  local max_x = Text.x_after(line, len)
```
[17.135136]
[17.135176]
```
  local max_x = Text.x_after(font, line, len)
```

Replacement in source_text.lua at line 891 [8.83786]

B:BD[17.135310] → [17.135310:135406]

    local currxmin = Text.x_after(line, curr+1)
    local currxmax = Text.x_after(line, curr+2)

[17.135310]

[17.135406]

    local currxmin = Text.x_after(font, line, curr+1)
    local currxmax = Text.x_after(font, line, curr+2)

Replacement in source_text.lua at line 909 [8.83786]
B:BD[17.135695] → [17.135695:135725]
```
function Text.x_after(s, pos)
```
[17.135695]
[4.93]
```
function Text.x_after(font, s, pos)
```
Replacement in source_text.lua at line 914 [8.83786]
B:BD[17.135850] → [20.116446:116475]
```
  return App.width(s_before)
```
[17.135850]
[17.135951]
```
  return font:getWidth(s_before)
```
Replacement in source_text.lua at line 917 [8.83786]
B:BD[17.135956] → [17.135956:135980]
```
function Text.x(s, pos)
```
[17.135956]
[17.135980]
```
function Text.x(font, s, pos)
```
Replacement in source_text.lua at line 920 [8.83786]
B:BD[17.136055] → [20.116476:116505]
```
  return App.width(s_before)
```
[17.136055]
[17.136156]
```
  return font:getWidth(s_before)
```

Deletion in source_text.lua at line 1098 [8.83786]

B:BD[62.7962] → [65.7202:7206]

B:BD[65.7206] → [48.247:247]

B:BD[62.6668] → [6.1583:1861]

BD:BD[62.6668] → [6.1583:1861]

B:BD[8.136039] → [6.1862:1904]

BD:BD[8.136039] → [6.1862:1904]

B:BD[8.137685] → [6.1905:1959]

BD:BD[8.137685] → [6.1905:1959]

B:BD[8.137800] → [6.1960:2007]

BD:BD[8.137800] → [6.1960:2007]

B:BD[8.138140] → [6.2008:2112]

BD:BD[8.138140] → [6.2008:2112]

B:BD[8.138771] → [6.2113:2164]

BD:BD[8.138771] → [6.2113:2164]

B:BD[8.138898] → [6.2165:2211]

BD:BD[8.138898] → [6.2165:2211]

B:BD[8.139072] → [6.2212:2320]

BD:BD[8.139072] → [6.2212:2320]

B:BD[8.139457] → [6.2321:2357]

BD:BD[8.139457] → [6.2321:2357]

B:BD[8.139612] → [6.2358:2391]

BD:BD[8.139612] → [6.2358:2391]

B:BD[8.139718] → [6.2392:2422]

BD:BD[8.139718] → [6.2392:2422]

B:BD[8.139817] → [6.2423:2456]

BD:BD[8.139817] → [6.2423:2456]

∅:D[66.63] → [63.3967:4501]

∅:D[60.485] → [63.3967:4501]

∅:D[65.1890] → [63.3967:4501]

∅:D[41.3038] → [63.3967:4501]

∅:D[67.5467] → [63.3967:4501]

∅:D[68.17096] → [63.3967:4501]

∅:D[17.101399] → [63.3967:4501]

∅:D[20.116412] → [63.3967:4501]

B:BD[8.101828] → [63.3967:4501]

B:BD[63.4501] → [17.101400:101827]

B:BD[17.101827] → [65.1891:2028]

∅:D[65.2028] → [17.102006:102171]

B:BD[17.102006] → [17.102006:102171]

B:BD[17.102171] → [49.2141:2355]

∅:D[49.2355] → [17.102226:102372]

B:BD[17.102226] → [17.102226:102372]

B:BD[17.102372] → [68.17097:17239]

∅:D[68.17239] → [17.102372:102389]

B:BD[17.102372] → [17.102372:102389]

B:BD[17.102389] → [65.2029:2109]

∅:D[65.2109] → [17.102491:102632]

B:BD[17.102491] → [17.102491:102632]

B:BD[17.102632] → [65.2110:2190]

∅:D[65.2190] → [17.102734:103329]

B:BD[17.102734] → [17.102734:103329]

B:BD[17.104141] → [17.104141:104201]

B:BD[17.104201] → [49.2357:2357]

∅:D[65.2192] → [63.4512:4721]

∅:D[49.2357] → [63.4512:4721]

∅:D[68.17241] → [63.4512:4721]

∅:D[17.104201] → [63.4512:4721]

B:BD[8.104958] → [63.4512:4721]

B:BD[63.4848] → [63.4848:4858]

B:BD[63.4858] → [17.104202:104586]

B:BD[17.104586] → [68.17242:17268]

∅:D[68.17268] → [17.104586:104639]

B:BD[17.104586] → [17.104586:104639]

B:BD[17.104639] → [68.17269:17295]

∅:D[68.17295] → [17.104639:104671]

B:BD[17.104639] → [17.104639:104671]

B:BD[17.104671] → [68.17296:17337]

B:BD[68.17337] → [65.2193:2267]

∅:D[65.2267] → [68.17436:17444]

B:BD[68.17436] → [68.17436:17444]

∅:D[68.17444] → [17.104671:104725]

B:BD[17.104671] → [17.104671:104725]

B:BD[17.104725] → [68.17445:17486]

B:BD[68.17486] → [65.2268:2342]

∅:D[65.2342] → [68.17585:17593]

B:BD[68.17585] → [68.17585:17593]

∅:D[68.17593] → [17.104725:104860]

B:BD[17.104725] → [17.104725:104860]

B:BD[17.104860] → [68.17594:17620]

∅:D[68.17620] → [17.104860:104920]

B:BD[17.104860] → [17.104860:104920]

B:BD[17.104920] → [68.17621:17647]

∅:D[68.17647] → [17.104920:104954]

B:BD[17.104920] → [17.104920:104954]

B:BD[17.104954] → [68.17648:17689]

B:BD[68.17689] → [65.2343:2417]

∅:D[65.2417] → [68.17788:17796]

B:BD[68.17788] → [68.17788:17796]

∅:D[68.17796] → [17.104954:105015]

B:BD[17.104954] → [17.104954:105015]

B:BD[17.105015] → [68.17797:17838]

B:BD[68.17838] → [65.2418:2492]

∅:D[65.2492] → [68.17937:17945]

B:BD[68.17937] → [68.17937:17945]

∅:D[68.17945] → [17.105015:105102]

B:BD[17.105015] → [17.105015:105102]

B:BD[17.105102] → [68.17946:17972]

∅:D[68.17972] → [17.105102:105159]

B:BD[17.105102] → [17.105102:105159]

B:BD[17.105159] → [68.17973:17999]

∅:D[68.17999] → [17.105159:105191]

B:BD[17.105159] → [17.105159:105191]

B:BD[17.105191] → [68.18000:18041]

B:BD[68.18041] → [65.2493:2567]

∅:D[65.2567] → [68.18140:18148]

B:BD[68.18140] → [68.18140:18148]

∅:D[68.18148] → [17.105191:105252]

B:BD[17.105191] → [17.105191:105252]

B:BD[17.105252] → [68.18149:18190]

B:BD[68.18190] → [65.2568:2642]

∅:D[65.2642] → [68.18289:18297]

B:BD[68.18289] → [68.18289:18297]

∅:D[68.18297] → [17.105252:105327]

B:BD[17.105252] → [17.105252:105327]

B:BD[17.105327] → [68.18298:18324]

∅:D[68.18324] → [17.105327:105378]

B:BD[17.105327] → [17.105327:105378]

B:BD[17.105378] → [68.18325:18351]

∅:D[68.18351] → [17.105378:105408]

B:BD[17.105378] → [17.105378:105408]

B:BD[17.105408] → [68.18352:18393]

B:BD[68.18393] → [65.2643:2717]

∅:D[65.2717] → [68.18492:18500]

B:BD[68.18492] → [68.18492:18500]

∅:D[68.18500] → [17.105408:105459]

B:BD[17.105408] → [17.105408:105459]

B:BD[17.105459] → [68.18501:18542]

B:BD[68.18542] → [65.2718:2792]

∅:D[65.2792] → [68.18641:18649]

B:BD[68.18641] → [68.18641:18649]

∅:D[68.18649] → [17.105459:105535]

B:BD[17.105459] → [17.105459:105535]

B:BD[17.105535] → [68.18650:18676]

∅:D[68.18676] → [17.105535:105594]

B:BD[17.105535] → [17.105535:105594]

B:BD[17.105594] → [68.18677:18703]

∅:D[68.18703] → [17.105594:105628]

B:BD[17.105594] → [17.105594:105628]

B:BD[17.105628] → [68.18704:18745]

B:BD[68.18745] → [65.2793:2867]

∅:D[65.2867] → [68.18844:18852]

B:BD[68.18844] → [68.18844:18852]

∅:D[68.18852] → [17.105628:105687]

B:BD[17.105628] → [17.105628:105687]

B:BD[17.105687] → [68.18853:18894]

B:BD[68.18894] → [65.2868:2942]

∅:D[65.2942] → [68.18993:19001]

B:BD[68.18993] → [68.18993:19001]

∅:D[68.19001] → [17.105687:105758]

B:BD[17.105687] → [17.105687:105758]

B:BD[17.105758] → [65.2944:2944]

B:BD[65.2944] → [65.2945:3447]

∅:D[65.3447] → [17.106342:106658]

B:BD[17.106342] → [17.106342:106658]

B:BD[17.106658] → [65.3449:3449]

∅:D[65.3449] → [62.3441:3522]

B:BD[8.107845] → [62.3441:3522]

∅:D[62.3522] → [63.5040:5319]

∅:D[17.106765] → [63.5040:5319]

B:BD[8.107952] → [63.5040:5319]

B:BD[63.5319] → [17.106766:106866]

B:BD[17.106866] → [65.3450:3525]

∅:D[65.3525] → [17.106970:107178]

B:BD[17.106970] → [17.106970:107178]

end
--?       print('return', mx, Text.nearest_cursor_pos(State.font, s, mx, State.left), '=>', screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, mx, State.left) - 1)
      return screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, mx, State.left) - 1
  return State.font:getWidth(screen_line)
function Text.nearest_cursor_pos(font, line, x, left)
  local max_x = left+Text.x(font, line, len+1)
    local currxmin = left+Text.x(font, line, curr)
    local currxmax = left+Text.x(font, line, curr+1)
function Text.nearest_pos_less_than(font, line, x)
  local max_x = Text.x_after(font, line, len)
    local currxmin = Text.x_after(font, line, curr+1)
    local currxmax = Text.x_after(font, line, curr+2)
function Text.x_after(font, s, pos)
  return font:getWidth(s_before)
function Text.x(font, s, pos)
  return font:getWidth(s_before)
      if State.lines[State.cursor1.line-1].mode == 'drawing' then
        table.remove(State.lines, State.cursor1.line-1)
        table.remove(State.line_cache, State.cursor1.line-1)
      else
        -- join lines
        State.cursor1.pos = utf8.len(State.lines[State.cursor1.line-1].data)+1
        State.lines[State.cursor1.line-1].data = State.lines[State.cursor1.line-1].data..State.lines[State.cursor1.line].data
        table.remove(State.lines, State.cursor1.line)
        table.remove(State.line_cache, State.cursor1.line)
      end
      State.cursor1.line = State.cursor1.line-1
    end
    if State.screen_top1.line > #State.lines then
      Text.populate_screen_line_starting_pos(State, #State.lines)
      local line_cache = State.line_cache[#State.line_cache]
      State.screen_top1 = {line=#State.lines, pos=line_cache.screen_line_starting_pos[#line_cache.screen_line_starting_pos]}
    elseif Text.lt1(State.cursor1, State.screen_top1) then
      State.screen_top1 = {
        line=State.cursor1.line,
        pos=Text.pos_at_start_of_screen_line(State, State.cursor1),
      }
      Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks
    end
    Text.clear_screen_line_cache(State, State.cursor1.line)
    assert(Text.le1(State.screen_top1, State.cursor1), ('screen_top (line=%d,pos=%d) is below cursor (line=%d,pos=%d)'):format(State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos))
    schedule_save(State)
    record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
  elseif chord == 'delete' then
    if State.selection1.line then
      Text.delete_selection(State, State.left, State.right)
      schedule_save(State)
      return
    end
    local before
    if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then
      before = snapshot(State, State.cursor1.line)
    else
      before = snapshot(State, State.cursor1.line, State.cursor1.line+1)
    end
    if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then
      local byte_start = utf8.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
      local byte_end = utf8.offset(State.lines[State.cursor1.line].data, State.cursor1.pos+1)
      if byte_start then
        if byte_end then
          State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)..string.sub(State.lines[State.cursor1.line].data, byte_end)
        else
          State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)
        end
        -- no change to State.cursor1.pos
      end
    elseif State.cursor1.line < #State.lines then
      if State.lines[State.cursor1.line+1].mode == 'text' then
        -- join lines
        State.lines[State.cursor1.line].data = State.lines[State.cursor1.line].data..State.lines[State.cursor1.line+1].data
      end
      table.remove(State.lines, State.cursor1.line+1)
      table.remove(State.line_cache, State.cursor1.line+1)
    end
    Text.clear_screen_line_cache(State, State.cursor1.line)
    schedule_save(State)
    record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
  --== shortcuts that move the cursor
  elseif chord == 'left' then
    Text.left(State)
    State.selection1 = {}
  elseif chord == 'right' then
    Text.right(State)
    State.selection1 = {}
  elseif chord == 'S-left' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.left(State)
  elseif chord == 'S-right' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.right(State)
  -- C- hotkeys reserved for drawings, so we'll use M-
  elseif chord == 'M-left' then
    Text.word_left(State)
    State.selection1 = {}
  elseif chord == 'M-right' then
    Text.word_right(State)
    State.selection1 = {}
  elseif chord == 'M-S-left' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.word_left(State)
  elseif chord == 'M-S-right' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.word_right(State)
  elseif chord == 'home' then
    Text.start_of_line(State)
    State.selection1 = {}
  elseif chord == 'end' then
    Text.end_of_line(State)
    State.selection1 = {}
  elseif chord == 'S-home' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.start_of_line(State)
  elseif chord == 'S-end' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.end_of_line(State)
  elseif chord == 'up' then
    Text.up(State)
    State.selection1 = {}
  elseif chord == 'down' then
    Text.down(State)
    State.selection1 = {}
  elseif chord == 'S-up' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.up(State)
  elseif chord == 'S-down' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.down(State)
  elseif chord == 'pageup' then
    Text.pageup(State)
    State.selection1 = {}
  elseif chord == 'pagedown' then
    Text.pagedown(State)
    State.selection1 = {}
  elseif chord == 'S-pageup' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.pageup(State)
  elseif chord == 'S-pagedown' then
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
    Text.pagedown(State)
  end
end
function Text.insert_return(State)
  local byte_offset = Text.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
  table.insert(State.lines, State.cursor1.line+1, {mode='text', data=string.sub(State.lines[State.cursor1.line].data, byte_offset)})
  table.insert(State.line_cache, State.cursor1.line+1, {})
  State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_offset-1)
  Text.clear_screen_line_cache(State, State.cursor1.line)
  State.cursor1 = {line=State.cursor1.line+1, pos=1}
end
function Text.pageup(State)
--?   print('pageup')
  -- duplicate some logic from love.draw
  local top2 = Text.to2(State, State.screen_top1)
--?   print(App.screen.height)
  local y = App.screen.height - State.line_height
  while y >= State.top do
--?     print(y, top2.line, top2.screen_line, top2.screen_pos)
    if State.screen_top1.line == 1 and State.screen_top1.pos == 1 then break end
    if State.lines[State.screen_top1.line].mode == 'text' then
      y = y - State.line_height
    elseif State.lines[State.screen_top1.line].mode == 'drawing' then
      y = y - Drawing_padding_height - Drawing.pixels(State.lines[State.screen_top1.line].h, State.width)
    end
    top2 = Text.previous_screen_line(State, top2)
  end
  State.screen_top1 = Text.to1(State, top2)
  State.cursor1 = {line=State.screen_top1.line, pos=State.screen_top1.pos}
  Text.move_cursor_down_to_next_text_line_while_scrolling_again_if_necessary(State)
--?   print(State.cursor1.line, State.cursor1.pos, State.screen_top1.line, State.screen_top1.pos)
--?   print('pageup end')

Solving an order conflict in source_text.lua at line 1098 [8.83786]
[62.7962]
[17.107178]

Deletion in source_text.lua at line 1099 [8.83786]

B:BD[17.107182] → [17.107182:107237]

B:BD[17.107237] → [69.9:94]

∅:D[69.94] → [17.107426:107503]

B:BD[17.107426] → [17.107426:107503]

B:BD[17.107503] → [65.3799:3874]

∅:D[65.3874] → [17.107607:107888]

B:BD[17.107607] → [17.107607:107888]

B:BD[17.107888] → [49.2358:2435]

∅:D[49.2435] → [17.108000:108361]

B:BD[17.108000] → [17.108000:108361]

B:BD[17.108361] → [49.2437:2437]

∅:D[49.2437] → [63.5498:5724]

∅:D[17.108361] → [63.5498:5724]

B:BD[8.109662] → [63.5498:5724]

B:BD[63.5724] → [70.2260:2316]

∅:D[70.2316] → [63.5785:6431]

B:BD[63.5785] → [63.5785:6431]

B:BD[63.6431] → [63.6431:6545]

BD:BD[63.6431] → [63.6431:6545]

B:BD[63.6431] → [6.1085:1211]

∅:D[6.1211] → [63.6545:6569]

B:BD[63.6545] → [63.6545:6569]

BD:BD[63.6545] → [63.6545:6569]

B:BD[63.6569] → [17.108362:108424]

B:BD[17.108424] → [49.2438:2517]

∅:D[49.2517] → [17.108458:109050]

B:BD[17.108458] → [17.108458:109050]

B:BD[17.109050] → [49.2519:2519]


function Text.pagedown(State)
--?   print('pagedown')
  State.screen_top1 = {line=State.screen_bottom1.line, pos=State.screen_bottom1.pos}
--?   print('setting top to', State.screen_top1.line, State.screen_top1.pos)
  State.cursor1 = {line=State.screen_top1.line, pos=State.screen_top1.pos}
  Text.move_cursor_down_to_next_text_line_while_scrolling_again_if_necessary(State)
--?   print('top now', State.screen_top1.line)
  Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks
--?   print('pagedown end')
end
function Text.up(State)
  assert(State.lines[State.cursor1.line].mode == 'text', 'line is not text')
--?   print('up', State.cursor1.line, State.cursor1.pos, State.screen_top1.line, State.screen_top1.pos)
  local screen_line_starting_pos, screen_line_index = Text.pos_at_start_of_screen_line(State, State.cursor1)
  if screen_line_starting_pos == 1 then
--?     print('cursor is at first screen line of its line')
    -- line is done; skip to previous text line
    local new_cursor_line = State.cursor1.line
    while new_cursor_line > 1 do
      new_cursor_line = new_cursor_line-1
      if State.lines[new_cursor_line].mode == 'text' then
--?         print('found previous text line')
        State.cursor1 = {line=new_cursor_line, pos=nil}
        Text.populate_screen_line_starting_pos(State, State.cursor1.line)
        -- previous text line found, pick its final screen line
--?         print('has multiple screen lines')
        local screen_line_starting_pos = State.line_cache[State.cursor1.line].screen_line_starting_pos
--?         print(#screen_line_starting_pos)
        screen_line_starting_pos = screen_line_starting_pos[#screen_line_starting_pos]
        local screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line].data, screen_line_starting_pos)
        local s = string.sub(State.lines[State.cursor1.line].data, screen_line_starting_byte_offset)
        State.cursor1.pos = screen_line_starting_pos + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1
        State.cursor1.pos = screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, State.cursor_x, State.left) - 1
        break
      end
    end
  else
    -- move up one screen line in current line
    assert(screen_line_index > 1, 'bumped up against top screen line in line')
    local new_screen_line_starting_pos = State.line_cache[State.cursor1.line].screen_line_starting_pos[screen_line_index-1]
    local new_screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line].data, new_screen_line_starting_pos)
    local s = string.sub(State.lines[State.cursor1.line].data, new_screen_line_starting_byte_offset)
    State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1
--?     print('cursor pos is now '..tostring(State.cursor1.pos))
  end
  if Text.lt1(State.cursor1, State.screen_top1) then

Replacement in source_edit.lua at line 97 [8.152503]

B:BD[63.18272] → [72.8:115]

    filename = love.filesystem.getSourceBaseDirectory()..'/lines.txt',  -- '/' should work even on Windows

[63.18272]

[17.147108]

    filename = 'run.lua',

Deletion in source_edit.lua at line 624 [8.152503]
B:BD[17.156934] → [5.224:224]
B:BD[8.155094] → [6.2461:2487]
BD:BD[8.155094] → [6.2461:2487]
```
    filename = 'run.lua',
```
Solving an order conflict in source_edit.lua at line 624 [8.152503]
[17.156934]

Replacement in source.lua at line 124 [74.5]

B:BD[73.194] → [5.286:458]

  Editor_state = edit.initialize_state(Margin_top, Margin_left + Line_number_width*App.width('m'), right, font, settings.font_height, math.floor(settings.font_height*1.3))

[73.194]

[74.4243]

  Editor_state = edit.initialize_state(Margin_top, Margin_left + Line_number_width*font:getWidth('m'), right, font, settings.font_height, math.floor(settings.font_height*1.3))

Replacement in source.lua at line 152 [74.5]

B:BD[75.51] → [5.510:688]

  Editor_state = edit.initialize_state(Margin_top, Margin_left + Line_number_width*App.width('m'), App.screen.width-Margin_right, font, font_height, math.floor(font_height*1.3))

[75.51]

[65.13450]

  Editor_state = edit.initialize_state(Margin_top, Margin_left + Line_number_width*font:getWidth('m'), App.screen.width-Margin_right, font, font_height, math.floor(font_height*1.3))

Deletion in select.lua at line 60 [76.43980]
B:BD[23.6273] → [11.1536:1536]
BD:BD[23.6273] → [11.1536:1536]
∅:D[11.1536] → [19.785:817]
B:BD[77.514] → [19.785:817]
D:D[11.1536] → [19.785:817]
BD:BD[77.514] → [19.785:817]
BD:BD[11.1536] → [19.785:817]
```
      lo_px = App.width(before)
```
Resurrecting zombie bytes in select.lua at line 60 [76.43980]
B:B[19.817] → [20.119068:119076]
BD:B[19.817] → [20.119068:119076]
BD:B[19.817] → [20.119068:119076]
```
    end
```
Insertion in select.lua at line 60 [76.43980]
[23.6273]
[20.119068]
```
      lo_px = State.font:getWidth(before)
```
Deletion in select.lua at line 63 [76.43980]
B:BD[23.6326] → [20.119154:119154]
Resurrecting zombie bytes in select.lua at line 63 [76.43980]
B:B[20.119154] → [20.119155:119186]
BD:B[20.119154] → [20.119155:119186]
B:B[19.897] → [20.119187:119241]
BD:B[19.897] → [20.119187:119241]
B:B[20.119303] → [20.119303:119334]
BD:B[20.119303] → [20.119303:119334]
```
    App.color(Highlight_color)
    App.color(Text_color)
    return lo_px
  end
end
function Text.mouse_pos(State)
```

Replacement in select.lua at line 64 [76.43980]

∅:D[20.119186] → [19.818:897]

B:BD[78.152] → [19.818:897]

BD:BD[78.152] → [19.818:897]

    love.graphics.rectangle('fill', x+lo_px,y, App.width(s),State.line_height)

[20.119186]

[20.119187]

    love.graphics.rectangle('fill', x+lo_px,y, State.font:getWidth(s),State.line_height)

Resurrecting zombie bytes in select.lua at line 74 [76.43980]
∅:∅[79.10117] → [20.119502:119508]
B:B[20.119502] → [20.119502:119508]
BD:B[20.119502] → [20.119502:119508]
B:B[20.119793] → [20.119793:119973]
BD:B[20.119793] → [20.119793:119973]
```
  end
  for line_index,line in ipairs(State.lines) do
    if Text.in_line(State, line_index, x,y) then
      return line_index, Text.to_pos_on_line(State, line_index, x,y)
    end
  end
```

Resurrecting zombie bytes in select.lua at line 81 [76.43980]

∅:∅[79.10214] → [20.119973:121671]

B:B[20.119973] → [20.119973:121671]

BD:B[20.119973] → [20.119973:121671]

end
function Text.cut_selection(State)
  if State.selection1.line == nil then return end
  local result = Text.selection(State)
  Text.delete_selection(State)
  return result
end
function Text.delete_selection(State)
  if State.selection1.line == nil then return end
  local minl,maxl = minmax(State.selection1.line, State.cursor1.line)
  local before = snapshot(State, minl, maxl)
  Text.delete_selection_without_undo(State)
  record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
end
function Text.delete_selection_without_undo(State)
  if State.selection1.line == nil then return end
  -- min,max = sorted(State.selection1,State.cursor1)
  local minl,minp = State.selection1.line,State.selection1.pos
  local maxl,maxp = State.cursor1.line,State.cursor1.pos
  if minl > maxl then
    minl,maxl = maxl,minl
    minp,maxp = maxp,minp
  elseif minl == maxl then
    if minp > maxp then
      minp,maxp = maxp,minp
    end
  end
  -- update State.cursor1 and State.selection1
  State.cursor1.line = minl
  State.cursor1.pos = minp
  if Text.lt1(State.cursor1, State.screen_top1) then
    State.screen_top1.line = State.cursor1.line
    State.screen_top1.pos = Text.pos_at_start_of_screen_line(State, State.cursor1)
  end
  State.selection1 = {}
  -- delete everything between min (inclusive) and max (exclusive)
  Text.clear_screen_line_cache(State, minl)
  local min_offset = Text.offset(State.lines[minl].data, minp)
  local max_offset = Text.offset(State.lines[maxl].data, maxp)
  if minl == maxl then
--?     print('minl == maxl')
    State.lines[minl].data = State.lines[minl].data:sub(1, min_offset-1)..State.lines[minl].data:sub(max_offset)
    return
  end

Resurrecting zombie bytes in select.lua at line 129 [76.43980]

∅:∅[49.4123] → [20.121693:122571]

B:B[20.121693] → [20.121693:122571]

BD:B[20.121693] → [20.121693:122571]

  local rhs = State.lines[maxl].data:sub(max_offset)
  for i=maxl,minl+1,-1 do
    table.remove(State.lines, i)
    table.remove(State.line_cache, i)
  end
  State.lines[minl].data = State.lines[minl].data:sub(1, min_offset-1)..rhs
end
function Text.selection(State)
  if State.selection1.line == nil then return end
  -- min,max = sorted(State.selection1,State.cursor1)
  local minl,minp = State.selection1.line,State.selection1.pos
  local maxl,maxp = State.cursor1.line,State.cursor1.pos
  if minl > maxl then
    minl,maxl = maxl,minl
    minp,maxp = maxp,minp
  elseif minl == maxl then
    if minp > maxp then
      minp,maxp = maxp,minp
    end
  end
  local min_offset = Text.offset(State.lines[minl].data, minp)
  local max_offset = Text.offset(State.lines[maxl].data, maxp)
  if minl == maxl then
    return State.lines[minl].data:sub(min_offset, max_offset-1)
  end

Resurrecting zombie bytes in select.lua at line 156 [76.43980]

∅:∅[49.4192] → [20.122593:122836]

B:B[20.122593] → [20.122593:122836]

BD:B[20.122593] → [20.122593:122836]

  local result = {State.lines[minl].data:sub(min_offset)}
  for i=minl+1,maxl-1 do
    table.insert(result, State.lines[i].data)
  end
  table.insert(result, State.lines[maxl].data:sub(1, max_offset-1))
  return table.concat(result, '\n')
end

Deletion in select.lua at line 163 [76.43980]
B:BD[23.6273] → [6.2851:2851]
BD:BD[23.6273] → [6.2851:2851]
∅:D[6.2851] → [16.4462:4504]
B:BD[77.514] → [16.4462:4504]
BD:BD[77.514] → [16.4462:4504]
B:BD[78.152] → [16.4505:4594]
BD:BD[78.152] → [16.4505:4594]
```
      lo_px = State.font:getWidth(before)
    love.graphics.rectangle('fill', x+lo_px,y, State.font:getWidth(s),State.line_height)
```
Solving an order conflict in select.lua at line 163 [76.43980]
[20.122836]
Insertion in main.lua at line 322 [82.2]
[81.874]
[2.1902]
```
  if Disable_all_quit_handlers then return end
```
Deletion in main.lua at line 339 [82.2]
B:BD[81.1309] → [2.1950:1950]
B:BD[8.190711] → [6.2859:2859]
BD:BD[8.190711] → [6.2859:2859]
B:BD[8.190738] → [6.2860:2907]
BD:BD[8.190738] → [6.2860:2907]
BD:BD[8.190738] → [6.2860:2907]
```
  if Disable_all_quit_handlers then return end
```
Solving an order conflict in main.lua at line 339 [82.2]
[81.1309]
[84.1196]

Replacement in log_browser.lua at line 97 [85.5]

B:BD[20.129126] → [20.129126:129222]

          love.graphics.line(xleft+50+App.width(line.section_name)+2,sectiony, xright,sectiony)

[20.129126]

[49.4350]

          love.graphics.line(xleft+50+State.font:getWidth(line.section_name)+2,sectiony, xright,sectiony)

Replacement in log_browser.lua at line 104 [85.5]

B:BD[20.129284] → [20.129284:129380]

          love.graphics.line(xleft+50+App.width(line.section_name)+2,sectiony, xright,sectiony)

[20.129284]

[86.1668]

          love.graphics.line(xleft+50+State.font:getWidth(line.section_name)+2,sectiony, xright,sectiony)

Replacement in log_browser.lua at line 140 [85.5]

B:BD[74.17253] → [20.129381:129545]

      love.graphics.print(line.section_stack[i].name, x+State.font_height+5, App.screen.height-App.width(line.section_stack[i].name)-5, --[[vertically]] math.pi/2)

[74.17253]

[87.3893]

      love.graphics.print(line.section_stack[i].name, x+State.font_height+5, App.screen.height-State.font:getWidth(line.section_stack[i].name)-5, --[[vertically]] math.pi/2)

Replacement in log_browser.lua at line 155 [85.5]

B:BD[74.17445] → [20.129546:129690]

      love.graphics.print(line.section_stack[i].name, x, App.screen.height-App.width(line.section_stack[i].name)-5, --[[vertically]] math.pi/2)

[74.17445]

[87.4575]

      love.graphics.print(line.section_stack[i].name, x, App.screen.height-State.font:getWidth(line.section_stack[i].name)-5, --[[vertically]] math.pi/2)

Deletion in help.lua at line 147 [88.6622]
B:BD[11.9454] → [6.3567:3567]
BD:BD[11.9454] → [6.3567:3567]

resolve conflicts

Dependencies

In channels

Change contents

File deletion: source.lua, source.lua

File deletion: log_browser.lua, log_browser.lua

Deletion in text.lua at line 44 [15.1]

Resurrecting zombie bytes in text.lua at line 45 [15.1]

Resurrecting zombie bytes in text.lua at line 49 [15.1]

Insertion in text.lua at line 50 [15.1]

Resurrecting zombie bytes in text.lua at line 98 [15.1]

Resurrecting zombie bytes in text.lua at line 102 [15.1]

Deletion in text.lua at line 104 [15.1]

Resurrecting zombie bytes in text.lua at line 104 [15.1]

Solving an order conflict in text.lua at line 104 [15.1]

Resurrecting zombie bytes in text.lua at line 114 [15.1]

Deletion in text.lua at line 115 [15.1]

Resurrecting zombie bytes in text.lua at line 115 [15.1]

Solving an order conflict in text.lua at line 115 [15.1]

Replacement in text.lua at line 406 [15.1]

Replacement in text.lua at line 414 [15.1]

Replacement in text.lua at line 435 [15.1]

Replacement in text.lua at line 454 [15.1]

Replacement in text.lua at line 668 [15.1]

Replacement in text.lua at line 689 [15.1]

Replacement in text.lua at line 703 [15.1]

Replacement in text.lua at line 708 [15.1]

Replacement in text.lua at line 720 [15.1]

Replacement in text.lua at line 745 [15.1]

Replacement in text.lua at line 748 [15.1]

Replacement in text.lua at line 755 [15.1]

Replacement in text.lua at line 773 [15.1]

Replacement in text.lua at line 778 [15.1]

Replacement in text.lua at line 781 [15.1]

Replacement in text.lua at line 784 [15.1]

Deletion in text.lua at line 957 [15.1]

Solving an order conflict in text.lua at line 957 [15.1]

Replacement in source_text.lua at line 17 [8.83786]

Deletion in source_text.lua at line 27 [8.83786]

Solving an order conflict in source_text.lua at line 27 [8.83786]

Deletion in source_text.lua at line 35 [8.83786]

Resurrecting zombie bytes in source_text.lua at line 36 [8.83786]

Resurrecting zombie bytes in source_text.lua at line 38 [8.83786]

Deletion in source_text.lua at line 65 [8.83786]

Resurrecting zombie bytes in source_text.lua at line 66 [8.83786]

Deletion in source_text.lua at line 70 [8.83786]

Resurrecting zombie bytes in source_text.lua at line 71 [8.83786]

Deletion in source_text.lua at line 79 [8.83786]

Resurrecting zombie bytes in source_text.lua at line 79 [8.83786]

Solving an order conflict in source_text.lua at line 79 [8.83786]

Deletion in source_text.lua at line 123 [8.83786]

Resurrecting zombie bytes in source_text.lua at line 124 [8.83786]

Deletion in source_text.lua at line 130 [8.83786]

Resurrecting zombie bytes in source_text.lua at line 134 [8.83786]

Deletion in source_text.lua at line 140 [8.83786]

Resurrecting zombie bytes in source_text.lua at line 141 [8.83786]

Replacement in source_text.lua at line 175 [8.83786]

Replacement in source_text.lua at line 197 [8.83786]

Deletion in source_text.lua at line 274 [8.83786]

Resurrecting zombie bytes in source_text.lua at line 274 [8.83786]

Solving an order conflict in source_text.lua at line 274 [8.83786]

Insertion in source_text.lua at line 274 [8.83786]

Insertion in source_text.lua at line 495 [8.83786]

Deletion in source_text.lua at line 519 [8.83786]

Resurrecting zombie bytes in source_text.lua at line 520 [8.83786]

Replacement in source_text.lua at line 541 [8.83786]

Deletion in source_text.lua at line 553 [8.83786]

Solving an order conflict in source_text.lua at line 553 [8.83786]

Replacement in source_text.lua at line 804 [8.83786]

Replacement in source_text.lua at line 825 [8.83786]

Replacement in source_text.lua at line 839 [8.83786]

Replacement in source_text.lua at line 844 [8.83786]

Replacement in source_text.lua at line 856 [8.83786]

Replacement in source_text.lua at line 881 [8.83786]

Replacement in source_text.lua at line 884 [8.83786]

Replacement in source_text.lua at line 891 [8.83786]

Replacement in source_text.lua at line 909 [8.83786]

Replacement in source_text.lua at line 914 [8.83786]

Replacement in source_text.lua at line 917 [8.83786]

Replacement in source_text.lua at line 920 [8.83786]