akkartik/pong.love - Change 4AC6J55RTWH6FQYHQ64Y3EGF5A27Q2DHJ2XB2LXWZQEYXM53BYLAC

resolve conflicts

Created by akkartik on November 18, 2023

4AC6J55RTWH6FQYHQ64Y3EGF5A27Q2DHJ2XB2LXWZQEYXM53BYLAC

Dependencies

In channels

main

Change contents

File deletion: file.lua, source_file.lua, file.lua

BFD:BFD[7.2] → [8.18212:18244]

BFD:BFD[7.2] → [9.132:171]

BFD:BFD[9.171] → [8.15083:15083]

BFD:BFD[7.2] → [8.18212:18244]

BFD:BFD[8.18244] → [8.15083:15083]

B:BD[8.16243] → [6.8081:8399]

B:BD[10.1296] → [6.8401:8401]

∅:D[6.8399] → [8.18207:18211]

-- for tests
function load_array(a)
  local result = {}
  local next_line = ipairs(a)
  local i,line,drawing = 0, ''
  while true do
    i,line = next_line(a, i)
    if i == nil then break end
    table.insert(result, {data=line})
  end
  if #result == 0 then
    table.insert(result, {data=''})
  end
  return result
end

File deletion: log_browser.lua, log_browser.lua

BFD:BFD[7.2] → [11.202684:202723]

BFD:BFD[11.202723] → [11.191243:191243]

B:BD[12.177] → [6.3379:3528]

B:BD[13.1813] → [6.3529:3647]

∅:D[6.3647] → [11.195458:195713]

∅:D[6.3528] → [11.194325:194910]

  assert(#State.lines == #State.line_cache, ('line_cache is out of date; %d elements when it should be %d'):format(#State.line_cache, #State.lines))
        else assert(line.section_end, "log line has a section name, but it's neither the start nor end of a section")
          local sectiony = y+State.line_height-Section_border_padding_vertical
          love.graphics.line(xleft,y, xleft,sectiony)
          love.graphics.line(xright,y, xright,sectiony)
          love.graphics.line(xleft,sectiony, xleft+50-2,sectiony)
  local mouse_line_index = log_browser.line_index(State, App.mouse_x(), App.mouse_y())
  local y = State.top
  for line_index = State.screen_top1.line,#State.lines do
    App.color(Text_color)
    local line = State.lines[line_index]
    if y + State.line_height > App.screen.height then break end
    local height = State.line_height
    if should_show(line) then
      local xleft = render_stack_left_margin(State, line_index, line, y)
      local xright = render_stack_right_margin(State, line_index, line, y)
      if line.section_name then
        App.color(Section_border_color)

File deletion: commands.lua, commands.lua

BFD:BFD[7.2] → [11.207182:207218]

BFD:BFD[11.207218] → [11.203826:203826]

B:BD[14.3209] → [6.9584:9630]

∅:D[6.9630] → [14.3225:3524]

  assert(index, 'file missing from manifest')
  table.remove(File_navigation.all_candidates, index)
  table.insert(File_navigation.all_candidates, 1, s)
end
function reset_file_navigator()
  Show_file_navigator = false
  File_navigation.index = 1
  File_navigation.filter = ''
  File_navigation.candidates = File_navigation.all_candidates
end

Replacement in undo.lua at line 39 [16.1]
B:BD[15.1379] → [15.1379:1391]
```
  assert(s)
```
[15.1379]
[15.1391]
```
  assert(s, 'failed to snapshot operation for undo history')
```

Replacement in undo.lua at line 43 [16.1]

B:BD[15.1426] → [15.1426:1453]

  assert(#State.lines > 0)

[15.1426]

[15.1453]

  assert(#State.lines > 0, 'failed to snapshot operation for undo history')

Deletion in undo.lua at line 61 [16.1]
B:BD[17.122] → [18.0:61]
BD:BD[17.122] → [18.0:61]
B:BD[17.218] → [18.62:138]
BD:BD[17.218] → [18.62:138]
```
  assert(s, 'failed to snapshot operation for undo history')
  assert(#State.lines > 0, 'failed to snapshot operation for undo history')
```
Solving an order conflict in undo.lua at line 61 [16.1]
[15.2009]
[13.3]

Replacement in undo.lua at line 74 [16.1]

B:BD[15.2331] → [15.2331:2374]

  assert(from.start_line == to.start_line)

[15.2331]

[15.2374]

  assert(from.start_line == to.start_line, 'failed to patch undo operation')

Replacement in undo.lua at line 78 [16.1]

B:BD[15.2451] → [15.2451:2502]

  assert(#to.lines == to.end_line-to.start_line+1)

[15.2451]

[15.2502]

  assert(#to.lines == to.end_line-to.start_line+1, 'failed to patch undo operation')

Replacement in undo.lua at line 85 [16.1]

B:BD[15.2642] → [15.2642:2685]

  assert(from.start_line == to.start_line)

[15.2642]

[15.2685]

  assert(from.start_line == to.start_line, 'failed to patch undo operation')

Replacement in undo.lua at line 89 [16.1]

B:BD[15.2767] → [15.2767:2818]

  assert(#to.lines == to.end_line-to.start_line+1)

[15.2767]

[15.2818]

  assert(#to.lines == to.end_line-to.start_line+1, 'failed to patch undo operation')

Deletion in undo.lua at line 111 [16.1]

B:BD[17.591] → [18.204:281]

BD:BD[17.591] → [18.204:281]

B:BD[17.711] → [18.282:367]

BD:BD[17.711] → [18.282:367]

B:BD[20.51] → [18.368:445]

BD:BD[20.51] → [18.368:445]

B:BD[20.176] → [18.446:531]

BD:BD[20.176] → [18.446:531]

B:BD[13.102] → [6.2:2]

BD:BD[13.102] → [6.2:2]

  assert(from.start_line == to.start_line, 'failed to patch undo operation')
  assert(#to.lines == to.end_line-to.start_line+1, 'failed to patch undo operation')
  assert(from.start_line == to.start_line, 'failed to patch undo operation')
  assert(#to.lines == to.end_line-to.start_line+1, 'failed to patch undo operation')

Solving an order conflict in undo.lua at line 111 [16.1]
[15.3386]
Deletion in text.lua at line 15 [23.1]
B:BD[21.63] → [22.162:214]
BD:BD[21.63] → [22.162:214]
```
  assert(#line_cache.screen_line_starting_pos >= 1)
```
Resurrecting zombie bytes in text.lua at line 16 [23.1]
∅:∅[18.623] → [22.214:319]
B:B[22.214] → [22.214:319]
BD:B[22.214] → [22.214:319]
```
  for i=1,#line_cache.screen_line_starting_pos do
    local pos = line_cache.screen_line_starting_pos[i]
```
Deletion in text.lua at line 120 [23.1]
B:BD[24.122] → [18.702:916]
BD:BD[24.122] → [18.702:916]
B:BD[25.1858] → [6.6:85]
BD:BD[25.1858] → [6.6:85]
∅:D[6.85] → [26.3:127]
B:BD[25.1956] → [26.3:127]
BD:BD[25.1956] → [26.3:127]
B:BD[27.4427] → [6.87:87]
BD:BD[27.4427] → [6.87:87]
B:BD[28.6132] → [18.1153:1202]
BD:BD[28.6132] → [18.1153:1202]
B:BD[29.1135] → [6.88:157]
BD:BD[29.1135] → [6.88:157]
∅:D[6.157] → [27.4939:5027]
B:BD[28.8150] → [27.4939:5027]
BD:BD[28.8150] → [27.4939:5027]
B:BD[27.5027] → [6.159:159]
BD:BD[27.5027] → [6.159:159]
B:BD[30.1079] → [18.1273:1383]
BD:BD[30.1079] → [18.1273:1383]
B:BD[23.464] → [18.1540:1593]
BD:BD[23.464] → [18.1540:1593]
B:BD[31.1764] → [18.1594:1647]
BD:BD[31.1764] → [18.1594:1647]
B:BD[27.5516] → [6.161:161]
BD:BD[27.5516] → [6.161:161]
B:BD[33.1078] → [18.1933:2000]
BD:BD[33.1078] → [18.1933:2000]
B:BD[34.1307] → [18.2001:2050]
BD:BD[34.1307] → [18.2001:2050]
B:BD[23.1164] → [18.2051:2099]
BD:BD[23.1164] → [18.2051:2099]
B:BD[35.7860] → [18.2100:2148]
BD:BD[35.7860] → [18.2100:2148]
B:BD[36.8167] → [18.2149:2230]
BD:BD[36.8167] → [18.2149:2230]
B:BD[37.1124] → [18.2231:2317]
BD:BD[37.1124] → [18.2231:2317]
B:BD[38.6974] → [6.165:165]
BD:BD[38.6974] → [6.165:165]
B:BD[39.442] → [6.167:167]
BD:BD[39.442] → [6.167:167]
```
    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))
    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]
  assert(State.cursor1.pos, 'cursor has no pos')
    assert(State.cursor1.pos > 1, 'bumped up against start of line')
    if Text.match(State.lines[State.cursor1.line].data, State.cursor1.pos-1, '%s') then
  assert(end_offset > start_offset, ('end_offset %d not > start_offset %d'):format(end_offset, start_offset))
  assert(false, ('invalid pos %d'):format(loc1.pos))
  assert(false, ('invalid pos %d'):format(loc1.pos))
  assert(my >= line_cache.starty, 'failed to map y pixel to line')
  assert(false, 'failed to map y pixel to line')
  assert(false, 'failed to map x pixel to pos')
  assert(false, 'failed to map x pixel to pos')
  assert(result.screen_pos, 'failed to convert schema-1 coordinate to schema-2')
  assert(result, "Text.offset returned nil; this is likely a failure to handle utf8")
```

Replacement in text.lua at line 208 [23.1]

B:BD[15.89180] → [15.89180:89235]

    assert(Text.le1(State.screen_top1, State.cursor1))

[15.89180]

[15.89235]

    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))

Replacement in text.lua at line 401 [23.1]

B:BD[15.97355] → [15.97355:97389]

    assert(screen_line_index > 1)

[15.97355]

[15.97389]

    assert(screen_line_index > 1, 'bumped up against top screen line in line')

Replacement in text.lua at line 419 [23.1]
B:BD[15.98401] → [40.3:31]
```
  assert(State.cursor1.pos)
```
[15.98401]
[15.98401]
```
  assert(State.cursor1.pos, 'cursor has no pos')
```

Replacement in text.lua at line 487 [23.1]

B:BD[15.101422] → [15.101422:101456]

    assert(State.cursor1.pos > 1)

[15.101422]

[15.101456]

    assert(State.cursor1.pos > 1, 'bumped up against start of line')

Deletion in text.lua at line 521 [23.1]
B:BD[15.102339] → [15.102339:102362]
```
  assert(start_offset)
```

Replacement in text.lua at line 522 [23.1]

B:BD[15.102405] → [15.102405:102441]

  assert(end_offset > start_offset)

[15.102405]

[15.102441]

  assert(end_offset > start_offset, ('end_offset %d not > start_offset %d'):format(end_offset, start_offset))

Replacement in text.lua at line 569 [23.1]
B:BD[32.3781] → [32.3781:3797]
```
  assert(false)
```
[32.3781]
[32.3797]
```
  assert(false, ('invalid pos %d'):format(loc1.pos))
```
Replacement in text.lua at line 583 [23.1]
B:BD[15.103871] → [15.103871:103887]
```
  assert(false)
```
[15.103871]
[15.103887]
```
  assert(false, ('invalid pos %d'):format(loc1.pos))
```

Replacement in text.lua at line 641 [23.1]

B:BD[15.106628] → [15.106628:106662]

  assert(my >= line_cache.starty)

[15.106628]

[15.106662]

  assert(my >= line_cache.starty, 'failed to map y pixel to line')

Replacement in text.lua at line 664 [23.1]
B:BD[15.108168] → [15.108168:108184]
```
  assert(false)
```
[15.108168]
[15.108184]
```
  assert(false, 'failed to map y pixel to line')
```
Replacement in text.lua at line 730 [23.1]
B:BD[15.110023] → [15.110023:110039]
```
  assert(false)
```
[15.110023]
[15.110039]
```
  assert(false, 'failed to map x pixel to pos')
```
Replacement in text.lua at line 761 [23.1]
B:BD[15.110847] → [15.110847:110863]
```
  assert(false)
```
[15.110847]
[15.110863]
```
  assert(false, 'failed to map x pixel to pos')
```

Replacement in text.lua at line 789 [23.1]

B:BD[15.111602] → [15.111602:111630]

  assert(result.screen_pos)

[15.111602]

[15.111630]

  assert(result.screen_pos, 'failed to convert schema-1 coordinate to schema-2')

Replacement in text.lua at line 831 [23.1]

B:BD[15.112432] → [15.112432:112449]

  assert(result)

[15.112432]

[15.112449]

  assert(result, "Text.offset returned nil; this is likely a failure to handle utf8")

Deletion in text.lua at line 942 [23.1]
B:BD[15.115545] → [32.4246:4246]
Replacement in source_undo.lua at line 39 [11.68]
B:BD[19.1380] → [19.1380:1392]
```
  assert(s)
```
[19.1380]
[19.1392]
```
  assert(s, 'failed to snapshot operation for undo history')
```

Replacement in source_undo.lua at line 43 [11.68]

B:BD[19.1427] → [19.1427:1454]

  assert(#State.lines > 0)

[19.1427]

[19.1454]

  assert(#State.lines > 0, 'failed to snapshot operation for undo history')

Deletion in source_undo.lua at line 53 [11.68]
B:BD[11.1447] → [6.170:231]
BD:BD[11.1447] → [6.170:231]
B:BD[11.1494] → [6.232:308]
BD:BD[11.1494] → [6.232:308]
```
  assert(s, 'failed to snapshot operation for undo history')
  assert(#State.lines > 0, 'failed to snapshot operation for undo history')
```
Solving an order conflict in source_undo.lua at line 53 [11.68]
[19.1783]
[41.13]
Deletion in source_undo.lua at line 68 [11.68]
B:BD[41.759] → [41.759:802]
BD:BD[41.759] → [41.759:802]
```
      print(line.mode)
      assert(false)
```
Resurrecting zombie bytes in source_undo.lua at line 69 [11.68]
∅:∅[6.373] → [41.802:810]
B:B[41.802] → [41.802:810]
BD:B[41.802] → [41.802:810]
```
    end
```

Replacement in source_undo.lua at line 82 [11.68]

B:BD[19.2333] → [19.2333:2376]

  assert(from.start_line == to.start_line)

[19.2333]

[19.2376]

  assert(from.start_line == to.start_line, 'failed to patch undo operation')

Replacement in source_undo.lua at line 86 [11.68]

B:BD[19.2453] → [19.2453:2504]

  assert(#to.lines == to.end_line-to.start_line+1)

[19.2453]

[19.2504]

  assert(#to.lines == to.end_line-to.start_line+1, 'failed to patch undo operation')

Replacement in source_undo.lua at line 93 [11.68]

B:BD[19.2644] → [19.2644:2687]

  assert(from.start_line == to.start_line)

[19.2644]

[19.2687]

  assert(from.start_line == to.start_line, 'failed to patch undo operation')

Replacement in source_undo.lua at line 97 [11.68]

B:BD[19.2769] → [19.2769:2820]

  assert(#to.lines == to.end_line-to.start_line+1)

[19.2769]

[19.2820]

  assert(#to.lines == to.end_line-to.start_line+1, 'failed to patch undo operation')

Deletion in source_undo.lua at line 119 [11.68]

B:BD[11.2464] → [6.374:451]

BD:BD[11.2464] → [6.374:451]

B:BD[11.2584] → [6.452:537]

BD:BD[11.2584] → [6.452:537]

B:BD[11.2775] → [6.538:615]

BD:BD[11.2775] → [6.538:615]

B:BD[11.2900] → [6.616:701]

BD:BD[11.2900] → [6.616:701]

  assert(from.start_line == to.start_line, 'failed to patch undo operation')
  assert(#to.lines == to.end_line-to.start_line+1, 'failed to patch undo operation')
  assert(from.start_line == to.start_line, 'failed to patch undo operation')
  assert(#to.lines == to.end_line-to.start_line+1, 'failed to patch undo operation')

Solving an order conflict in source_undo.lua at line 119 [11.68]
[19.3388]

Replacement in source_text.lua at line 20 [11.83786]

B:BD[19.87062] → [42.362:414]

  assert(#line_cache.screen_line_starting_pos >= 1)

[19.87062]

[42.414]

  assert(#line_cache.screen_line_starting_pos >= 1, 'line cache missing screen line info')

Deletion in source_text.lua at line 27 [11.83786]
B:BD[19.87400] → [42.521:521]
B:BD[11.87493] → [6.704:795]
BD:BD[11.87493] → [6.704:795]
BD:BD[11.87493] → [6.704:795]
```
  assert(#line_cache.screen_line_starting_pos >= 1, 'line cache missing screen line info')
```
Solving an order conflict in source_text.lua at line 27 [11.83786]
[19.87400]
[43.413]

Replacement in source_text.lua at line 212 [11.83786]

B:BD[19.97469] → [44.4:61]

  assert(State.lines[State.cursor1.line].mode == 'text')

[19.97469]

[45.1488]

  assert(State.lines[State.cursor1.line].mode == 'text', 'line is not text')

Replacement in source_text.lua at line 289 [11.83786]

B:BD[19.102171] → [19.102171:102226]

    assert(Text.le1(State.screen_top1, State.cursor1))

[19.102171]

[19.102226]

    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))

Deletion in source_text.lua at line 316 [11.83786]

B:BD[19.104201] → [45.2192:2192]

B:BD[11.97898] → [6.796:873]

BD:BD[11.97898] → [6.796:873]

B:BD[11.102919] → [6.874:1088]

BD:BD[11.102919] → [6.874:1088]

  assert(State.lines[State.cursor1.line].mode == 'text', 'line is not text')
    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))

Solving an order conflict in source_text.lua at line 316 [11.83786]
[19.104201]
[41.4512]
Resurrecting zombie bytes in source_text.lua at line 446 [11.83786]
∅:∅[46.94] → [19.107426:107503]
B:B[19.107426] → [19.107426:107503]
BD:B[19.107426] → [19.107426:107503]
```
--?   print('setting top to', State.screen_top1.line, State.screen_top1.pos)
```

Resurrecting zombie bytes in source_text.lua at line 448 [11.83786]

∅:∅[45.3874] → [19.107607:107888]

B:B[19.107607] → [19.107607:107888]

BD:B[19.107607] → [19.107607:107888]

  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)

Replacement in source_text.lua at line 455 [11.83786]
B:BD[19.107888] → [46.96:96]
BD:BD[19.107888] → [46.96:96]
∅:D[46.96] → [41.5440:5497]
∅:D[45.3876] → [41.5440:5497]
∅:D[19.107888] → [41.5440:5497]
B:BD[11.109190] → [41.5440:5497]
BD:BD[11.109190] → [41.5440:5497]
```
  assert(State.lines[State.cursor1.line].mode == 'text')
```
[19.107888]
[19.108000]
```
  assert(State.lines[State.cursor1.line].mode == 'text', 'line is not text')
```
Deletion in source_text.lua at line 461 [11.83786]
B:BD[11.109190] → [6.1089:1166]
BD:BD[11.109190] → [6.1089:1166]
```
  assert(State.lines[State.cursor1.line].mode == 'text', 'line is not text')
```
Solving an order conflict in source_text.lua at line 461 [11.83786]
[19.108361]
[41.5498]

Replacement in source_text.lua at line 481 [11.83786]

B:BD[19.108424] → [19.108424:108458]

    assert(screen_line_index > 1)

[19.108424]

[19.108458]

    assert(screen_line_index > 1, 'bumped up against top screen line in line')

Deletion in source_text.lua at line 489 [11.83786]
B:BD[19.109050] → [45.3878:3878]
B:BD[11.110604] → [6.1167:1246]
BD:BD[11.110604] → [6.1167:1246]
```
    assert(screen_line_index > 1, 'bumped up against top screen line in line')
```
Solving an order conflict in source_text.lua at line 489 [11.83786]
[19.109050]
[48.4021]
Resurrecting zombie bytes in source_text.lua at line 494 [11.83786]
B:B[19.111717] → [19.111717:111728]
BD:B[19.111717] → [19.111717:111728]
B:B[19.111959] → [19.111959:111985]
BD:B[19.111959] → [19.111959:111985]
```
  end
end
function Text.down(State)
```
Deletion in source_text.lua at line 498 [11.83786]
∅:D[19.111985] → [41.7470:7527]
B:BD[11.114899] → [41.7470:7527]
BD:BD[11.114899] → [41.7470:7527]
```
  assert(State.lines[State.cursor1.line].mode == 'text')
```
Resurrecting zombie bytes in source_text.lua at line 498 [11.83786]
B:B[11.114899] → [6.1247:1324]
BD:B[11.114899] → [6.1247:1324]
```
  assert(State.lines[State.cursor1.line].mode == 'text', 'line is not text')
```
Solving an order conflict in source_text.lua at line 498 [11.83786]
[19.111985]
[6.1247]

Resurrecting zombie bytes in source_text.lua at line 499 [11.83786]

B:B[41.7527] → [19.111986:112145]

BD:B[41.7527] → [19.111986:112145]

--?   print('down', State.cursor1.line, State.cursor1.pos, State.screen_top1.line, State.screen_top1.pos, State.screen_bottom1.line, State.screen_bottom1.pos)

Deletion in source_text.lua at line 500 [11.83786]
B:BD[19.112145] → [40.125:153]
```
  assert(State.cursor1.pos)
```
Resurrecting zombie bytes in source_text.lua at line 500 [11.83786]
∅:∅[40.153] → [19.112145:112296]
B:B[19.112145] → [19.112145:112296]
BD:B[19.112145] → [19.112145:112296]
```
  if Text.cursor_at_final_screen_line(State) then
    -- line is done, skip to next text line
--?     print('cursor at final screen line of its line')
```
Insertion in source_text.lua at line 500 [11.83786]
[19.112145]
[19.112145]
```
  assert(State.cursor1.pos, 'cursor has no pos')
```
Deletion in source_text.lua at line 545 [11.83786]
B:BD[11.115058] → [6.1325:1374]
BD:BD[11.115058] → [6.1325:1374]
```
  assert(State.cursor1.pos, 'cursor has no pos')
```
Solving an order conflict in source_text.lua at line 545 [11.83786]
[48.4327]
[45.3938]
Deletion in source_text.lua at line 558 [11.83786]
B:BD[19.115791] → [45.4149:4149]
B:BD[11.120443] → [6.1375:1444]
BD:BD[11.120443] → [6.1375:1444]
```
    assert(State.cursor1.pos > 1, 'bumped up against start of line')
```
Solving an order conflict in source_text.lua at line 558 [11.83786]
[19.115791]
[48.4575]
Replacement in source_text.lua at line 574 [11.83786]
B:BD[19.117204] → [19.117204:117238]
```
    assert(State.cursor1.pos > 1)
```
[19.117204]
[19.117238]
```
    assert(State.cursor1.pos > 1, 'bumped up against start of line')
```
Deletion in source_text.lua at line 608 [11.83786]
B:BD[19.119364] → [19.119364:119387]
```
  assert(start_offset)
```

Replacement in source_text.lua at line 609 [11.83786]

B:BD[19.119430] → [19.119430:119466]

  assert(end_offset > start_offset)

[19.119430]

[19.119466]

  assert(end_offset > start_offset, ('end_offset %d not > start_offset %d'):format(end_offset, start_offset))

Replacement in source_text.lua at line 615 [11.83786]

B:BD[19.119571] → [45.4332:4389]

  assert(State.lines[State.cursor1.line].mode == 'text')

[19.119571]

[19.119688]

  assert(State.lines[State.cursor1.line].mode == 'text', 'line is not text')

Deletion in source_text.lua at line 630 [11.83786]

B:BD[11.122669] → [6.1445:1555]

BD:BD[11.122669] → [6.1445:1555]

B:BD[11.122810] → [6.1556:1633]

BD:BD[11.122810] → [6.1556:1633]

  assert(end_offset > start_offset, ('end_offset %d not > start_offset %d'):format(end_offset, start_offset))
  assert(State.lines[State.cursor1.line].mode == 'text', 'line is not text')

Resurrecting zombie bytes in source_text.lua at line 630 [11.83786]
B:B[41.8417] → [19.119772:119831]
BD:B[41.8417] → [19.119772:119831]
```
  end
  if Text.lt1(State.cursor1, State.screen_top1) then
```
Solving an order conflict in source_text.lua at line 630 [11.83786]
[41.8417]
[19.119772]
Resurrecting zombie bytes in source_text.lua at line 637 [11.83786]
∅:∅[45.4614] → [19.119979:119990]
B:B[19.119979] → [19.119979:119990]
BD:B[19.119979] → [19.119979:119990]
B:B[19.120458] → [19.120458:120664]
BD:B[19.120458] → [19.120458:120664]
```
  end
end
function Text.right(State)
  Text.right_without_scroll(State)
  if Text.cursor_out_of_screen(State) then
    Text.snap_cursor_to_bottom_of_screen(State)
  end
end
function Text.right_without_scroll(State)
```
Deletion in source_text.lua at line 648 [11.83786]
B:BD[19.120664] → [45.4616:4616]
BD:BD[19.120664] → [45.4616:4616]
∅:D[45.4616] → [41.8418:8475]
∅:D[19.120664] → [41.8418:8475]
B:BD[11.124061] → [41.8418:8475]
BD:BD[11.124061] → [41.8418:8475]
```
  assert(State.lines[State.cursor1.line].mode == 'text')
```
Resurrecting zombie bytes in source_text.lua at line 648 [11.83786]
B:B[11.124061] → [6.1634:1711]
BD:B[11.124061] → [6.1634:1711]
```
  assert(State.lines[State.cursor1.line].mode == 'text', 'line is not text')
```
Solving an order conflict in source_text.lua at line 648 [11.83786]
[19.120664]
[6.1634]
Replacement in source_text.lua at line 673 [11.83786]
B:BD[19.122060] → [19.122060:122076]
```
  assert(false)
```
[19.122060]
[19.123082]
```
  assert(false, ('invalid pos %d'):format(loc1.pos))
```
Deletion in source_text.lua at line 676 [11.83786]
B:BD[19.123087] → [32.8024:8024]
B:BD[11.125663] → [6.1712:1765]
BD:BD[11.125663] → [6.1712:1765]
```
  assert(false, ('invalid pos %d'):format(loc1.pos))
```
Solving an order conflict in source_text.lua at line 676 [11.83786]
[19.123087]
[49.3775]
Deletion in source_text.lua at line 687 [11.83786]
B:BD[49.4230] → [49.4230:4246]
BD:BD[49.4230] → [49.4230:4246]
```
  assert(false)
```
Resurrecting zombie bytes in source_text.lua at line 688 [11.83786]
∅:∅[6.1819] → [49.4246:4251]
B:B[49.4246] → [49.4246:4251]
BD:B[49.4246] → [49.4246:4251]
```
end
```
Deletion in source_text.lua at line 712 [11.83786]
B:BD[41.9509] → [41.9509:9558]
BD:BD[41.9509] → [41.9509:9558]
```
    assert(State.cursor1.line == #State.lines+1)
```

Resurrecting zombie bytes in source_text.lua at line 713 [11.83786]

∅:∅[6.1928] → [41.9558:9780]

B:B[41.9558] → [41.9558:9780]

BD:B[41.9558] → [41.9558:9780]

    table.insert(State.lines, {mode='text', data=''})
    table.insert(State.line_cache, {})
  end
--?   print(y, App.screen.height, App.screen.height-State.line_height)
  if y > App.screen.height - State.line_height then

Deletion in source_text.lua at line 744 [11.83786]
B:BD[41.9972] → [41.9972:10057]
BD:BD[41.9972] → [41.9972:10057]
```
      assert(top2.line > 1)
      assert(State.lines[top2.line-1].mode == 'drawing')
```

Resurrecting zombie bytes in source_text.lua at line 746 [11.83786]

∅:∅[6.2104] → [41.10057:10377]

B:B[41.10057] → [41.10057:10377]

BD:B[41.10057] → [41.10057:10377]

      -- We currently can't draw partial drawings, so either skip it entirely
      -- or not at all.
      local h = Drawing_padding_height + Drawing.pixels(State.lines[top2.line-1].h, State.width)
      if y - h < State.top then
        break
      end
--?       print('skipping drawing of height', h)
      y = y - h

Replacement in source_text.lua at line 777 [11.83786]
B:BD[19.127186] → [19.127186:127220]
```
  assert(my >= line_cache.starty)
```
[19.127186]
[19.127220]
```
  assert(my >= line_cache.starty, 'failed to map y pixel to line')
```
Replacement in source_text.lua at line 800 [11.83786]
B:BD[19.131658] → [19.131658:131674]
```
  assert(false)
```
[19.131658]
[19.131674]
```
  assert(false, 'failed to map y pixel to line')
```
Replacement in source_text.lua at line 866 [11.83786]
B:BD[19.134850] → [19.134850:134866]
```
  assert(false)
```
[19.134850]
[19.134866]
```
  assert(false, 'failed to map x pixel to pos')
```
Replacement in source_text.lua at line 897 [11.83786]
B:BD[19.135674] → [19.135674:135690]
```
  assert(false)
```
[19.135674]
[19.135690]
```
  assert(false, 'failed to map x pixel to pos')
```
Deletion in source_text.lua at line 914 [11.83786]
B:BD[19.136192] → [15.116507:116507]
B:BD[11.130948] → [6.2105:2172]
BD:BD[11.130948] → [6.2105:2172]
B:BD[11.135420] → [6.2173:2222]
BD:BD[11.135420] → [6.2173:2222]
B:BD[11.138612] → [6.2223:2271]
BD:BD[11.138612] → [6.2223:2271]
B:BD[11.139436] → [6.2272:2320]
BD:BD[11.139436] → [6.2272:2320]
```
  assert(my >= line_cache.starty, 'failed to map y pixel to line')
  assert(false, 'failed to map y pixel to line')
  assert(false, 'failed to map x pixel to pos')
  assert(false, 'failed to map x pixel to pos')
```
Solving an order conflict in source_text.lua at line 914 [11.83786]
[19.136192]
[41.10378]
Replacement in source_text.lua at line 928 [11.83786]
B:BD[19.136712] → [19.136712:136740]
```
  assert(result.screen_pos)
```
[19.136712]
[19.137393]
```
  assert(result.screen_pos, 'failed to convert schema-1 coordinate to schema-2')
```
Replacement in source_text.lua at line 970 [11.83786]
B:BD[19.138626] → [19.138626:138643]
```
  assert(result)
```
[19.138626]
[19.138643]
```
  assert(result, "Text.offset returned nil; this is likely a failure to handle utf8")
```
Deletion in source_text.lua at line 1059 [11.83786]
B:BD[19.143322] → [45.7201:7201]
B:BD[11.140472] → [6.2321:2402]
BD:BD[11.140472] → [6.2321:2402]
```
  assert(result.screen_pos, 'failed to convert schema-1 coordinate to schema-2')
```
Solving an order conflict in source_text.lua at line 1059 [11.83786]
[19.143322]
[48.7004]
Deletion in source_text.lua at line 1060 [11.83786]
B:BD[11.142386] → [6.2403:2489]
BD:BD[11.142386] → [6.2403:2489]
```
  assert(result, "Text.offset returned nil; this is likely a failure to handle utf8")
```
Deletion in source_file.lua at line 66 [11.150304]
B:BD[41.11419] → [41.11419:11436]
BD:BD[41.11419] → [41.11419:11436]
```
    assert(line)
```

Resurrecting zombie bytes in source_file.lua at line 67 [11.150304]

∅:∅[6.2543] → [41.11436:12752]

B:B[41.11436] → [41.11436:12752]

BD:B[41.11436] → [41.11436:12752]

    if line == '```' then break end
    local shape = json.decode(line)
    if shape.mode == 'freehand' then
      -- no changes needed
    elseif shape.mode == 'line' or shape.mode == 'manhattan' then
      local name = shape.p1.name
      shape.p1 = Drawing.find_or_insert_point(drawing.points, shape.p1.x, shape.p1.y, --[[large width to minimize overlap]] 1600)
      drawing.points[shape.p1].name = name
      name = shape.p2.name
      shape.p2 = Drawing.find_or_insert_point(drawing.points, shape.p2.x, shape.p2.y, --[[large width to minimize overlap]] 1600)
      drawing.points[shape.p2].name = name
    elseif shape.mode == 'polygon' or shape.mode == 'rectangle' or shape.mode == 'square' then
      for i,p in ipairs(shape.vertices) do
        local name = p.name
        shape.vertices[i] = Drawing.find_or_insert_point(drawing.points, p.x,p.y, --[[large width to minimize overlap]] 1600)
        drawing.points[shape.vertices[i]].name = name
      end
    elseif shape.mode == 'circle' or shape.mode == 'arc' then
      local name = shape.center.name
      shape.center = Drawing.find_or_insert_point(drawing.points, shape.center.x,shape.center.y, --[[large width to minimize overlap]] 1600)
      drawing.points[shape.center].name = name
    elseif shape.mode == 'deleted' then
      -- ignore
    else

Deletion in source_file.lua at line 91 [11.150304]
B:BD[41.12752] → [41.12752:12796]
BD:BD[41.12752] → [41.12752:12796]
```
      print(shape.mode)
      assert(false)
```

Resurrecting zombie bytes in source_file.lua at line 92 [11.150304]

∅:∅[6.2612] → [41.12796:13023]

B:B[41.12796] → [41.12796:13023]

BD:B[41.12796] → [41.12796:13023]

    end
    table.insert(drawing.shapes, shape)
  end
  return drawing
end
function store_drawing(outfile, drawing)
  outfile:write('```lines\n')
  for _,shape in ipairs(drawing.shapes) do
    if shape.mode == 'freehand' then

Resurrecting zombie bytes in source_file.lua at line 104 [11.150304]

∅:∅[50.76] → [41.13069:13243]

B:B[41.13069] → [41.13069:13243]

BD:B[41.13069] → [41.13069:13243]

    elseif shape.mode == 'line' or shape.mode == 'manhattan' then
      local line = json.encode({mode=shape.mode, p1=drawing.points[shape.p1], p2=drawing.points[shape.p2]})

Resurrecting zombie bytes in source_file.lua at line 108 [11.150304]

∅:∅[50.129] → [41.13275:13562]

B:B[41.13275] → [41.13275:13562]

BD:B[41.13275] → [41.13275:13562]

    elseif shape.mode == 'polygon' or shape.mode == 'rectangle' or shape.mode == 'square' then
      local obj = {mode=shape.mode, vertices={}}
      for _,p in ipairs(shape.vertices) do
        table.insert(obj.vertices, drawing.points[p])
      end
      local line = json.encode(obj)

Resurrecting zombie bytes in source_file.lua at line 116 [11.150304]
∅:∅[50.182] → [41.13594:13633]
B:B[41.13594] → [41.13594:13633]
BD:B[41.13594] → [41.13594:13633]
```
    elseif shape.mode == 'circle' then
```
Resurrecting zombie bytes in source_file.lua at line 119 [11.150304]
∅:∅[50.319] → [41.13749:13785]
B:B[41.13749] → [41.13749:13785]
BD:B[41.13749] → [41.13749:13785]
```
    elseif shape.mode == 'arc' then
```
Resurrecting zombie bytes in source_file.lua at line 122 [11.150304]
∅:∅[50.514] → [41.13959:14024]
B:B[41.13959] → [41.13959:14024]
BD:B[41.13959] → [41.13959:14024]
```
    elseif shape.mode == 'deleted' then
      -- ignore
    else
```
Deletion in source_file.lua at line 125 [11.150304]
B:BD[41.14024] → [41.14024:14068]
BD:BD[41.14024] → [41.14024:14068]
```
      print(shape.mode)
      assert(false)
```
Resurrecting zombie bytes in source_file.lua at line 126 [11.150304]
∅:∅[6.2681] → [41.14068:14107]
B:B[41.14068] → [41.14068:14107]
BD:B[41.14068] → [41.14068:14107]
```
    end
  end
  outfile:write('```\n')
```
Deletion in source_file.lua at line 163 [11.150304]
B:BD[41.14919] → [41.14919:14933]
BD:BD[41.14919] → [41.14919:14933]
```
    assert(i)
```

Resurrecting zombie bytes in source_file.lua at line 164 [11.150304]

∅:∅[6.2730] → [41.14933:16266]

B:B[41.14933] → [41.14933:16266]

BD:B[41.14933] → [41.14933:16266]

--?     print(i)
    if line == '```' then break end
    local shape = json.decode(line)
    if shape.mode == 'freehand' then
      -- no changes needed
    elseif shape.mode == 'line' or shape.mode == 'manhattan' then
      local name = shape.p1.name
      shape.p1 = Drawing.find_or_insert_point(drawing.points, shape.p1.x, shape.p1.y, --[[large width to minimize overlap]] 1600)
      drawing.points[shape.p1].name = name
      name = shape.p2.name
      shape.p2 = Drawing.find_or_insert_point(drawing.points, shape.p2.x, shape.p2.y, --[[large width to minimize overlap]] 1600)
      drawing.points[shape.p2].name = name
    elseif shape.mode == 'polygon' or shape.mode == 'rectangle' or shape.mode == 'square' then
      for i,p in ipairs(shape.vertices) do
        local name = p.name
        shape.vertices[i] = Drawing.find_or_insert_point(drawing.points, p.x,p.y, --[[large width to minimize overlap]] 1600)
        drawing.points[shape.vertices[i]].name = name
      end
    elseif shape.mode == 'circle' or shape.mode == 'arc' then
      local name = shape.center.name
      shape.center = Drawing.find_or_insert_point(drawing.points, shape.center.x,shape.center.y, --[[large width to minimize overlap]] 1600)
      drawing.points[shape.center].name = name
    elseif shape.mode == 'deleted' then
      -- ignore
    else

Deletion in source_file.lua at line 189 [11.150304]
B:BD[41.16266] → [41.16266:16310]
BD:BD[41.16266] → [41.16266:16310]
```
      print(shape.mode)
      assert(false)
```
Resurrecting zombie bytes in source_file.lua at line 190 [11.150304]
∅:∅[6.2799] → [41.16310:16388]
B:B[41.16310] → [41.16310:16388]
BD:B[41.16310] → [41.16310:16388]
```
    end
    table.insert(drawing.shapes, shape)
  end
  return i, drawing
end
```

Replacement in source_edit.lua at line 161 [11.152503]

B:BD[19.147442] → [52.4074:4248]

∅:D[52.4248] → [19.147486:147543]

B:BD[19.147486] → [19.147486:147543]

B:BD[19.147543] → [45.7280:7376]

∅:D[45.7376] → [19.147683:147707]

B:BD[19.147683] → [19.147683:147707]

  if #State.lines ~= #State.line_cache then
    print(('line_cache is out of date; %d when it should be %d'):format(#State.line_cache, #State.lines))
    assert(false)
  end
  if not Text.le1(State.screen_top1, State.cursor1) then
    print(State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos)
    assert(false)
  end

[19.147442]

[19.147707]

  assert(#State.lines == #State.line_cache, ('line_cache is out of date; %d elements when it should be %d'):format(#State.line_cache, #State.lines))
  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))

Deletion in source_edit.lua at line 171 [11.152503]

B:BD[45.7423] → [32.8493:8493]

B:BD[11.155492] → [6.2801:3162]

BD:BD[11.155492] → [6.2801:3162]

  assert(#State.lines == #State.line_cache, ('line_cache is out of date; %d elements when it should be %d'):format(#State.line_cache, #State.lines))
  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))

Solving an order conflict in source_edit.lua at line 171 [11.152503]
[45.7423]
[19.147898]
Deletion in source_edit.lua at line 206 [11.152503]
B:BD[41.20018] → [41.20018:20061]
BD:BD[41.20018] → [41.20018:20061]
```
      print(line.mode)
      assert(false)
```
Resurrecting zombie bytes in source_edit.lua at line 206 [11.152503]
B:B[41.20061] → [19.148081:148095]
BD:B[41.20061] → [19.148081:148095]
```
    end
  end
```
Insertion in source_edit.lua at line 206 [11.152503]
[41.20018]
[19.148081]
```
      assert(false, ('unknown line mode %s'):format(line.mode))
```
Resurrecting zombie bytes in source_edit.lua at line 210 [11.152503]
∅:∅[32.8538] → [19.148095:148198]
B:B[19.148095] → [19.148095:148198]
BD:B[19.148095] → [19.148095:148198]
```
  if State.search_term then
    Text.draw_search_bar(State)
  end
end
function edit.update(State, dt)
```
Deletion in source_edit.lua at line 624 [11.152503]
B:BD[19.156934] → [3.2802:2802]
B:BD[41.20018] → [6.3163:3227]
BD:BD[41.20018] → [6.3163:3227]
```
      assert(false, ('unknown line mode %s'):format(line.mode))
```
Solving an order conflict in source_edit.lua at line 624 [11.152503]
[19.156934]

Replacement in select.lua at line 36 [53.43980]

B:BD[15.118346] → [15.118346:118377]

    assert(maxl == line_index)

[15.118346]

[15.118377]

    assert(maxl == line_index, ('maxl %d not equal to line_index %d'):format(maxl, line_index))

Replacement in select.lua at line 39 [53.43980]

B:BD[15.118417] → [15.118417:118448]

    assert(minl == line_index)

[15.118417]

[15.118448]

    assert(minl == line_index, ('minl %d not equal to line_index %d'):format(minl, line_index))

Replacement in select.lua at line 42 [53.43980]

B:BD[15.118476] → [15.118476:118524]

    assert(minl == maxl and minl == line_index)

[15.118476]

[15.118524]

    assert(minl == maxl and minl == line_index, ('minl %d, maxl %d and line_index %d are not all equal'):format(minl, maxl, line_index))

Deletion in select.lua at line 59 [53.43980]
B:BD[53.45604] → [18.5840:5936]
BD:BD[53.45604] → [18.5840:5936]
B:BD[53.45675] → [18.5937:6033]
BD:BD[53.45675] → [18.5937:6033]
B:BD[53.45734] → [18.6034:6171]
BD:BD[53.45734] → [18.6034:6171]
B:BD[55.4078] → [31.1796:1839]
BD:BD[55.4078] → [31.1796:1839]
B:BD[53.47652] → [6.3230:3298]
BD:BD[53.47652] → [6.3230:3298]
∅:D[6.3298] → [27.6568:6621]
B:BD[53.47674] → [27.6568:6621]
BD:BD[53.47674] → [27.6568:6621]
B:BD[27.6621] → [6.3300:3300]
BD:BD[27.6621] → [6.3300:3300]
B:BD[53.48425] → [6.3301:3369]
BD:BD[53.48425] → [6.3301:3369]
∅:D[6.3369] → [27.6891:6949]
B:BD[53.48447] → [27.6891:6949]
BD:BD[53.48447] → [27.6891:6949]
B:BD[27.6949] → [6.3371:3371]
BD:BD[27.6949] → [6.3371:3371]
```
    assert(maxl == line_index, ('maxl %d not equal to line_index %d'):format(maxl, line_index))
    assert(minl == line_index, ('minl %d not equal to line_index %d'):format(minl, line_index))
    assert(minl == maxl and minl == line_index, ('minl %d, maxl %d and line_index %d are not all equal'):format(minl, maxl, line_index))
  local x,y = App.mouse_x(), App.mouse_y()
  assert(minl < maxl, ('minl %d not < maxl %d'):format(minl, maxl))
  local rhs = State.lines[maxl].data:sub(max_offset)
  assert(minl < maxl, ('minl %d not < maxl %d'):format(minl, maxl))
  local result = {State.lines[minl].data:sub(min_offset)}
```
Solving an order conflict in select.lua at line 59 [53.43980]
[15.119067]
[27.6213]
Replacement in select.lua at line 128 [53.43980]
B:BD[15.121671] → [15.121671:121693]
```
  assert(minl < maxl)
```
[15.121671]
[15.121693]
```
  assert(minl < maxl, ('minl %d not < maxl %d'):format(minl, maxl))
```
Replacement in select.lua at line 155 [53.43980]
B:BD[15.122571] → [15.122571:122593]
```
  assert(minl < maxl)
```
[15.122571]
[15.122593]
```
  assert(minl < maxl, ('minl %d not < maxl %d'):format(minl, maxl))
```
Deletion in select.lua at line 163 [53.43980]
B:BD[15.122836] → [32.10216:10216]

Replacement in log_browser.lua at line 78 [57.5]

∅:D[40.297] → [56.632:676]

∅:D[58.16947] → [56.632:676]

B:BD[56.632] → [56.632:676]

  assert(#State.lines == #State.line_cache)

[40.297]

[58.16948]

  assert(#State.lines == #State.line_cache, ('line_cache is out of date; %d elements when it should be %d'):format(#State.line_cache, #State.lines))

Replacement in log_browser.lua at line 98 [57.5]

∅:D[59.370] → [60.986:1024]

∅:D[15.129222] → [60.986:1024]

B:BD[60.986] → [60.986:1024]

        else assert(line.section_end)

[15.129222]

[59.371]

        else assert(line.section_end, "log line has a section name, but it's neither the start nor end of a section")

Deletion in edit.lua at line 103 [63.413]

B:BD[61.108] → [61.108:459]

BD:BD[61.108] → [61.108:459]

  if #State.lines ~= #State.line_cache then
    print(('line_cache is out of date; %d when it should be %d'):format(#State.line_cache, #State.lines))
    assert(false)
  end
  if not Text.le1(State.screen_top1, State.cursor1) then
    print(State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos)
    assert(false)
  end

Resurrecting zombie bytes in edit.lua at line 105 [63.413]

∅:∅[6.8764] → [61.459:3203]

B:B[61.459] → [61.459:3203]

BD:B[61.459] → [61.459:3203]

  State.cursor_x = nil
  State.cursor_y = nil
  local y = State.top
  local screen_bottom1 = {line=nil, pos=nil}
--?   print('== draw')
  for line_index = State.screen_top1.line,#State.lines do
    local line = State.lines[line_index]
--?     print('draw:', y, line_index, line)
    if y + State.line_height > App.screen.height then break end
    screen_bottom1.line = line_index
--?     print('text.draw', y, line_index)
    local startpos = 1
    if line_index == State.screen_top1.line then
      startpos = State.screen_top1.pos
    end
    y, screen_bottom1.pos = Text.draw(State, line_index, y, startpos)
--?     print('=> y', y)
  end
  State.screen_bottom1 = screen_bottom1
  if State.search_term then
    Text.draw_search_bar(State)
  end
  return y
end
function edit.update(State, dt)
  if State.next_save and State.next_save < Current_time then
    save_to_disk(State)
    State.next_save = nil
  end
end
function schedule_save(State)
  if State.next_save == nil then
    State.next_save = Current_time + 3  -- short enough that you're likely to still remember what you did
  end
end
function edit.quit(State)
  -- make sure to save before quitting
  if State.next_save then
    save_to_disk(State)
    -- give some time for the OS to flush everything to disk
    love.timer.sleep(0.1)
  end
end
function edit.mouse_press(State, x,y, mouse_button)
  if State.search_term then return end
--?   print_and_log(('edit.mouse_press: cursor at %d,%d'):format(State.cursor1.line, State.cursor1.pos))
  if y < State.top then
    State.old_cursor1 = State.cursor1
    State.old_selection1 = State.selection1
    State.mousepress_shift = App.shift_down()
    State.selection1 = {
        line=State.screen_top1.line,
        pos=State.screen_top1.pos,
    }
    return
  end
  for line_index,line in ipairs(State.lines) do
    if Text.in_line(State, line_index, x,y) then
      -- delicate dance between cursor, selection and old cursor/selection
      -- scenarios:
      --  regular press+release: sets cursor, clears selection
      --  shift press+release:
      --    sets selection to old cursor if not set otherwise leaves it untouched
      --    sets cursor
      --  press and hold to start a selection: sets selection on press, cursor on release
      --  press and hold, then press shift: ignore shift
      --    i.e. mouse_release should never look at shift state
--?       print_and_log(('edit.mouse_press: in line %d'):format(line_index))
      State.old_cursor1 = State.cursor1
      State.old_selection1 = State.selection1
      State.mousepress_shift = App.shift_down()
      State.selection1 = {
          line=line_index,
          pos=Text.to_pos_on_line(State, line_index, x, y),
      }
      return
    end
  end

Resurrecting zombie bytes in edit.lua at line 190 [63.413]

∅:∅[64.1928] → [61.3252:3727]

B:B[61.3252] → [61.3252:3727]

BD:B[61.3252] → [61.3252:3727]

  State.old_cursor1 = State.cursor1
  State.old_selection1 = State.selection1
  State.mousepress_shift = App.shift_down()
  State.selection1 = {
      line=State.screen_bottom1.line,
      pos=Text.pos_at_end_of_screen_line(State, State.screen_bottom1),
  }
end
function edit.mouse_release(State, x,y, mouse_button)
  if State.search_term then return end
--?   print_and_log(('edit.mouse_release(%d,%d): cursor at %d,%d'):format(x,y, State.cursor1.line, State.cursor1.pos))

Resurrecting zombie bytes in edit.lua at line 207 [63.413]

∅:∅[64.2084] → [61.3727:4134]

B:B[61.3727] → [61.3727:4134]

BD:B[61.3727] → [61.3727:4134]

  for line_index,line in ipairs(State.lines) do
    if Text.in_line(State, line_index, x,y) then
--?       print_and_log(('edit.mouse_release: in line %d'):format(line_index))
      State.cursor1 = {
          line=line_index,
          pos=Text.to_pos_on_line(State, line_index, x, y),
      }
--?       print_and_log(('edit.mouse_release: cursor now %d,%d'):format(State.cursor1.line, State.cursor1.pos))

Resurrecting zombie bytes in edit.lua at line 217 [63.413]
∅:∅[64.2137] → [61.4530:4544]
B:B[61.4530] → [61.4530:4544]
BD:B[61.4530] → [61.4530:4544]
```
    end
  end
```

Resurrecting zombie bytes in edit.lua at line 223 [63.413]

∅:∅[64.2360] → [61.4544:4742]

B:B[61.4544] → [61.4544:4742]

BD:B[61.4544] → [61.4544:4742]

--?   print_and_log(('edit.mouse_release: finally selection %s,%s cursor %d,%d'):format(tostring(State.selection1.line), tostring(State.selection1.pos), State.cursor1.line, State.cursor1.pos))
end

Resurrecting zombie bytes in edit.lua at line 240 [63.413]

∅:∅[64.2748] → [61.4742:12430]

B:B[61.4742] → [61.4742:12430]

BD:B[61.4742] → [61.4742:12430]

function edit.mouse_wheel_move(State, dx,dy)
  if dy > 0 then
    State.cursor1 = {line=State.screen_top1.line, pos=State.screen_top1.pos}
    for i=1,math.floor(dy) do
      Text.up(State)
    end
  elseif dy < 0 then
    State.cursor1 = {line=State.screen_bottom1.line, pos=State.screen_bottom1.pos}
    for i=1,math.floor(-dy) do
      Text.down(State)
    end
  end
end
function edit.text_input(State, t)
--?   print('text input', t)
  if State.search_term then
    State.search_term = State.search_term..t
    Text.search_next(State)
  else
    for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
    Text.text_input(State, t)
  end
  schedule_save(State)
end
function edit.keychord_press(State, chord, key)
  if State.selection1.line and
      -- printable character created using shift key => delete selection
      -- (we're not creating any ctrl-shift- or alt-shift- combinations using regular/printable keys)
      (not App.shift_down() or utf8.len(key) == 1) and
      chord ~= 'C-a' and chord ~= 'C-c' and chord ~= 'C-x' and chord ~= 'backspace' and chord ~= 'delete' and chord ~= 'C-z' and chord ~= 'C-y' and not App.is_cursor_movement(chord) then
    Text.delete_selection(State, State.left, State.right)
  end
  if State.search_term then
    for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
    if chord == 'escape' then
      State.search_term = nil
      State.cursor1 = State.search_backup.cursor
      State.screen_top1 = State.search_backup.screen_top
      State.search_backup = nil
      Text.redraw_all(State)  -- if we're scrolling, reclaim all fragments to avoid memory leaks
    elseif chord == 'return' then
      State.search_term = nil
      State.search_backup = nil
    elseif chord == 'backspace' then
      local len = utf8.len(State.search_term)
      local byte_offset = Text.offset(State.search_term, len)
      State.search_term = string.sub(State.search_term, 1, byte_offset-1)
    elseif chord == 'down' then
      State.cursor1.pos = State.cursor1.pos+1
      Text.search_next(State)
    elseif chord == 'up' then
      Text.search_previous(State)
    end
    return
  elseif chord == 'C-f' then
    State.search_term = ''
    State.search_backup = {
      cursor={line=State.cursor1.line, pos=State.cursor1.pos},
      screen_top={line=State.screen_top1.line, pos=State.screen_top1.pos},
    }
  -- zoom
  elseif chord == 'C-=' then
    edit.update_font_settings(State, State.font_height+2)
    Text.redraw_all(State)
  elseif chord == 'C--' then
    if State.font_height > 2 then
      edit.update_font_settings(State, State.font_height-2)
      Text.redraw_all(State)
    end
  elseif chord == 'C-0' then
    edit.update_font_settings(State, 20)
    Text.redraw_all(State)
  -- undo
  elseif chord == 'C-z' then
    for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
    local event = undo_event(State)
    if event then
      local src = event.before
      State.screen_top1 = deepcopy(src.screen_top)
      State.cursor1 = deepcopy(src.cursor)
      State.selection1 = deepcopy(src.selection)
      patch(State.lines, event.after, event.before)
      patch_placeholders(State.line_cache, event.after, event.before)
      -- if we're scrolling, reclaim all fragments to avoid memory leaks
      Text.redraw_all(State)
      schedule_save(State)
    end
  elseif chord == 'C-y' then
    for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
    local event = redo_event(State)
    if event then
      local src = event.after
      State.screen_top1 = deepcopy(src.screen_top)
      State.cursor1 = deepcopy(src.cursor)
      State.selection1 = deepcopy(src.selection)
      patch(State.lines, event.before, event.after)
      -- if we're scrolling, reclaim all fragments to avoid memory leaks
      Text.redraw_all(State)
      schedule_save(State)
    end
  -- clipboard
  elseif chord == 'C-a' then
    State.selection1 = {line=1, pos=1}
    State.cursor1 = {line=#State.lines, pos=utf8.len(State.lines[#State.lines].data)+1}
  elseif chord == 'C-c' then
    local s = Text.selection(State)
    if s then
      App.set_clipboard(s)
    end
  elseif chord == 'C-x' then
    for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
    local s = Text.cut_selection(State, State.left, State.right)
    if s then
      App.set_clipboard(s)
    end
    schedule_save(State)
  elseif chord == 'C-v' then
    for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
    -- We don't have a good sense of when to scroll, so we'll be conservative
    -- and sometimes scroll when we didn't quite need to.
    local before_line = State.cursor1.line
    local before = snapshot(State, before_line)
    local clipboard_data = App.get_clipboard()
    for _,code in utf8.codes(clipboard_data) do
      local c = utf8.char(code)
      if c == '\n' then
        Text.insert_return(State)
      else
        Text.insert_at_cursor(State, c)
      end
    end
    if Text.cursor_out_of_screen(State) then
      Text.snap_cursor_to_bottom_of_screen(State, State.left, State.right)
    end
    schedule_save(State)
    record_undo_event(State, {before=before, after=snapshot(State, before_line, State.cursor1.line)})
  -- dispatch to text
  else
    for _,line_cache in ipairs(State.line_cache) do line_cache.starty = nil end  -- just in case we scroll
    Text.keychord_press(State, chord)
  end
end
function edit.key_release(State, key, scancode)
end
function edit.update_font_settings(State, font_height)
  State.font_height = font_height
  love.graphics.setFont(love.graphics.newFont(State.font_height))
  State.line_height = math.floor(font_height*1.3)
end
--== some methods for tests
-- Insulate tests from some key globals so I don't have to change the vast
-- majority of tests when they're modified for the real app.
Test_margin_left = 25
Test_margin_right = 0
function edit.initialize_test_state()
  -- if you change these values, tests will start failing
  return edit.initialize_state(
      15,  -- top margin
      Test_margin_left,
      App.screen.width - Test_margin_right,
      14,  -- font height assuming default LÖVE font
      15)  -- line height
end
-- all text_input events are also keypresses
-- TODO: handle chords of multiple keys
function edit.run_after_text_input(State, t)
  edit.keychord_press(State, t)
  edit.text_input(State, t)
  edit.key_release(State, t)
  App.screen.contents = {}
  edit.update(State, 0)
  edit.draw(State)
end
-- not all keys are text_input
function edit.run_after_keychord(State, chord)
  edit.keychord_press(State, chord)
  edit.key_release(State, chord)
  App.screen.contents = {}
  edit.update(State, 0)
  edit.draw(State)
end
function edit.run_after_mouse_click(State, x,y, mouse_button)
  App.fake_mouse_press(x,y, mouse_button)
  edit.mouse_press(State, x,y, mouse_button)
  App.fake_mouse_release(x,y, mouse_button)
  edit.mouse_release(State, x,y, mouse_button)
  App.screen.contents = {}
  edit.update(State, 0)
  edit.draw(State)
end
function edit.run_after_mouse_press(State, x,y, mouse_button)
  App.fake_mouse_press(x,y, mouse_button)
  edit.mouse_press(State, x,y, mouse_button)
  App.screen.contents = {}
  edit.update(State, 0)
  edit.draw(State)
end
function edit.run_after_mouse_release(State, x,y, mouse_button)
  App.fake_mouse_release(x,y, mouse_button)
  edit.mouse_release(State, x,y, mouse_button)
  App.screen.contents = {}
  edit.update(State, 0)
  edit.draw(State)
end

Replacement in commands.lua at line 139 [66.459]
B:BD[65.2168] → [65.2168:2184]
```
  assert(index)
```
[65.2168]
[65.2184]
```
  assert(index, 'file missing from manifest')
```

resolve conflicts

Dependencies

In channels

Change contents

File deletion: file.lua, source_file.lua, file.lua

File deletion: log_browser.lua, log_browser.lua

File deletion: commands.lua, commands.lua

Replacement in undo.lua at line 39 [16.1]

Replacement in undo.lua at line 43 [16.1]

Deletion in undo.lua at line 61 [16.1]

Solving an order conflict in undo.lua at line 61 [16.1]

Replacement in undo.lua at line 74 [16.1]

Replacement in undo.lua at line 78 [16.1]

Replacement in undo.lua at line 85 [16.1]

Replacement in undo.lua at line 89 [16.1]

Deletion in undo.lua at line 111 [16.1]

Solving an order conflict in undo.lua at line 111 [16.1]

Deletion in text.lua at line 15 [23.1]

Resurrecting zombie bytes in text.lua at line 16 [23.1]

Deletion in text.lua at line 120 [23.1]

Replacement in text.lua at line 208 [23.1]

Replacement in text.lua at line 401 [23.1]

Replacement in text.lua at line 419 [23.1]

Replacement in text.lua at line 487 [23.1]

Deletion in text.lua at line 521 [23.1]

Replacement in text.lua at line 522 [23.1]

Replacement in text.lua at line 569 [23.1]

Replacement in text.lua at line 583 [23.1]

Replacement in text.lua at line 641 [23.1]

Replacement in text.lua at line 664 [23.1]

Replacement in text.lua at line 730 [23.1]

Replacement in text.lua at line 761 [23.1]

Replacement in text.lua at line 789 [23.1]

Replacement in text.lua at line 831 [23.1]

Deletion in text.lua at line 942 [23.1]

Replacement in source_undo.lua at line 39 [11.68]

Replacement in source_undo.lua at line 43 [11.68]

Deletion in source_undo.lua at line 53 [11.68]

Solving an order conflict in source_undo.lua at line 53 [11.68]

Deletion in source_undo.lua at line 68 [11.68]

Resurrecting zombie bytes in source_undo.lua at line 69 [11.68]

Replacement in source_undo.lua at line 82 [11.68]

Replacement in source_undo.lua at line 86 [11.68]

Replacement in source_undo.lua at line 93 [11.68]

Replacement in source_undo.lua at line 97 [11.68]

Deletion in source_undo.lua at line 119 [11.68]

Solving an order conflict in source_undo.lua at line 119 [11.68]

Replacement in source_text.lua at line 20 [11.83786]

Deletion in source_text.lua at line 27 [11.83786]

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

Replacement in source_text.lua at line 212 [11.83786]

Replacement in source_text.lua at line 289 [11.83786]

Deletion in source_text.lua at line 316 [11.83786]

Solving an order conflict in source_text.lua at line 316 [11.83786]

Resurrecting zombie bytes in source_text.lua at line 446 [11.83786]

Resurrecting zombie bytes in source_text.lua at line 448 [11.83786]

Replacement in source_text.lua at line 455 [11.83786]

Deletion in source_text.lua at line 461 [11.83786]

Solving an order conflict in source_text.lua at line 461 [11.83786]

Replacement in source_text.lua at line 481 [11.83786]

Deletion in source_text.lua at line 489 [11.83786]

Solving an order conflict in source_text.lua at line 489 [11.83786]

Resurrecting zombie bytes in source_text.lua at line 494 [11.83786]

Deletion in source_text.lua at line 498 [11.83786]

Resurrecting zombie bytes in source_text.lua at line 498 [11.83786]

Solving an order conflict in source_text.lua at line 498 [11.83786]

Resurrecting zombie bytes in source_text.lua at line 499 [11.83786]

Deletion in source_text.lua at line 500 [11.83786]

Resurrecting zombie bytes in source_text.lua at line 500 [11.83786]

Insertion in source_text.lua at line 500 [11.83786]

Deletion in source_text.lua at line 545 [11.83786]

Solving an order conflict in source_text.lua at line 545 [11.83786]

Deletion in source_text.lua at line 558 [11.83786]

Solving an order conflict in source_text.lua at line 558 [11.83786]

Replacement in source_text.lua at line 574 [11.83786]

Deletion in source_text.lua at line 608 [11.83786]

Replacement in source_text.lua at line 609 [11.83786]

Replacement in source_text.lua at line 615 [11.83786]

Deletion in source_text.lua at line 630 [11.83786]

Resurrecting zombie bytes in source_text.lua at line 630 [11.83786]