bring back a level of wrapping

[?]

Aug 15, 2022, 5:31 PM

MUJTM6REGQAK3LZTIFWGJRXE2UPCM4HSLXQYSF5ITLXLS6JCVPMQC

Dependencies

[2] MD3W5IRA new fork: rip out drawing support
[3] VJ77YABH more efficient undo/redo
[4] SPSW74Y5 add state arg to Text.keychord_pressed
[5] FZBXBUFF bugfix: search
[6] NDHQN23G done passing left/right margins everywhere
[7] LXTTOB33 extract a couple of files
[8] 5L7K4GBD clicking to the right of a wrapped line
[9] 5FW7YOFT highlight selection while dragging
[10] 2LC3BM2N support other whitespace chars in word movements
[11] MDXGMZU2 disable all debug prints
[12] MXA3RZYK deduce left/right from state where possible
[13] LAW2O3NW extract variable Margin_left
[14] ZPUQSPQP extract a few methods
[15] YT5P6TO6 bugfix: save previous file when dropping a new one on
[16] V3EABA35 skip multiple consecutive whitespace
[17] GJLOKCYK bugfix: clicking past end of screen line
[18] APYPFFS3 call edit rather than App callbacks in tests
[19] UHB4GARJ left/right margin -> left/right coordinates
[20] PX3736DX better error message
[21] XNFTJHC4 split keyboard handling between Text and Drawing
[22] IWYLK45K clicking to the right of a line within line width
[23] MYC7XR5Q bugfix: lines that aren't drawn from the start
[24] WPUHAZUC superfluous line
[25] CPZGQT72 go through and fix similar issues
[26] VG75U7IM bugfix: typing should delete highlighted text
[27] MP2TBKU6 bugfix: crash in Text.up() after return
[28] FYS7TCDW bugfix
[29] 62PZGSUC optimization: moving cursor to next word
[30] 5ZA3BRNY add state arg to a few functions
[31] 7EQLPB3O bugfix: don't delete selection when moving cursor
[32] DHI6IJCN selecting text and deleting selections
[33] AMOPICKV bugfix: check after cursor on same line when searching upwards
[34] LSYLEVBD drop some redundant args when clearing the cache
[35] BPWFKBXT new test: dragging and dropping a file on lines.love
[36] WZFMGVDT switch to line index in a function
[37] FHSZYAZ2 more precise search highlighting
[38] 4J2L6JMR bugfix: deleting a selection spanning pages
[39] SPNMXTYR have file API operate on state object
[40] F65ADDGL add state arg to a few functions
[41] CUIV2LE5 some typos
[42] LNUHQOGH start passing in Editor_state explicitly
[43] CIQN2MDE bugfix: typing a capital letter deletes selection
[44] 2ZYV7D3W handle tab characters
[45] PFT5Y2ZY move
[46] SVJZZDC3 snapshot - no, that's all wrong
[47] S2YQBEYC snapshot: test for a new regression
[48] CNCYMM6A make test initializations a little more obvious
[49] HGC5RGJP switch to line index in a function
[50] HALS7E5U more clearly skip prints before screen top
[51] S2MISTTM add state arg to a few functions
[52] GN3IF4WF bugfix: pasting newlines
[53] 2RXZ3PGO beginning of a new approach to scroll+wrap
[54] ZHLO7K3M add args to some functions
[55] YTSPVDZH first successful pagedown test, first bug found by test
[56] Z5HLXU4P add state arg to a few functions
[57] HTWAM4NZ bugfix: scrolling in left/right movements
[58] EETIR4GX bugfix: skip over drawings when searching
[59] BOFNXP5G clicking now moves the cursor even on long, wrapped lines
[60] O7QH4N4W speeding up copy, attempt 1
[61] HOSPP2AN crisp font rendering
[62] LF7BWEG4 group all editor globals
[63] 4WAFGF4Z selection bugfix
[64] QYIFOHW3 first test!
[65] 4VKEE43Z bugfix
[66] LLAOOMUL bugfix: search upwards
[67] 7PZ4CQFV search: transparently handle drawings everywhere
[68] VHQCNMAR several more modules
[69] 2L5MEZV3 experiment: new edit namespace
[70] QCPXQ2E3 add state arg to a few functions
[71] ILOA5BYF separate data structure for each line's cache data
[72] TGHAJBES use line cache for drawings as well
[73] MTJEVRJR add state arg to a few functions
[74] 73OCE2MC after much struggle, a brute-force undo
[75] MSOQI3A5 bugfix: check before cursor on same line
[76] HIKLULFQ extract a function
[77] KMRJOSLY bugfix: delete selection before pasting
[78] V5MJRFOZ bugfix: down arrow doesn't scroll up unnecessarily
[79] DSLD74DK lots more tests
[*] BULPIBEG beginnings of a module for the text editor
[*] CE4LZV4T drop last couple of manual tests

Change contents

replacement in undo.lua at line 60

[3.1017]→[2.1:47](∅→∅)

table.insert(event.lines, State.lines[i])

[3.269]

[3.2296]

local line = State.lines[i]
table.insert(event.lines, {data=line.data})
replacement in text_tests.lua at line 604

[3.13730]→[2.49:154](∅→∅)

check_eq(Editor_state.lines[1], 'abc', 'F - test_cursor_movement_without_shift_resets_selection/data')

[3.13730]

[3.2]

check_eq(Editor_state.lines[1].data, 'abc', 'F - test_cursor_movement_without_shift_resets_selection/data')
replacement in text_tests.lua at line 622

[3.452]→[2.155:231](∅→∅)

check_eq(Editor_state.lines[1], 'xbc', 'F - test_edit_deletes_selection')

[3.452]

[3.2]

check_eq(Editor_state.lines[1].data, 'xbc', 'F - test_edit_deletes_selection')
replacement in text_tests.lua at line 645

[3.14601]→[2.232:328](∅→∅)

check_eq(Editor_state.lines[1], 'Dbc', 'F - test_edit_with_shift_key_deletes_selection/data')

[3.14601]

[3.2]

check_eq(Editor_state.lines[1].data, 'Dbc', 'F - test_edit_with_shift_key_deletes_selection/data')
replacement in text_tests.lua at line 683

[3.451]→[2.329:390](∅→∅)

check_eq(Editor_state.lines[1], 'bc', 'F - test_cut/data')

[3.451]

[3.504]

check_eq(Editor_state.lines[1].data, 'bc', 'F - test_cut/data')
replacement in text_tests.lua at line 704

[3.1068]→[2.391:472](∅→∅)

check_eq(Editor_state.lines[1], 'xyzdef', 'F - test_paste_replaces_selection')

[3.1068]

[3.520]

check_eq(Editor_state.lines[1].data, 'xyzdef', 'F - test_paste_replaces_selection')
replacement in text_tests.lua at line 730

[3.16335]→[2.473:561](∅→∅)

check_eq(Editor_state.lines[1], 'ahi', 'F - test_deleting_selection_may_scroll/data')

[3.16335]

[3.1008]

check_eq(Editor_state.lines[1].data, 'ahi', 'F - test_deleting_selection_may_scroll/data')
replacement in text_tests.lua at line 796

[3.18093]→[2.562:743](∅→∅)

check_eq(Editor_state.lines[1], '', 'F - test_insert_newline_at_start_of_line/data:1')
check_eq(Editor_state.lines[2], 'abc', 'F - test_insert_newline_at_start_of_line/data:2')

[3.18093]

[3.4366]

check_eq(Editor_state.lines[1].data, '', 'F - test_insert_newline_at_start_of_line/data:1')
check_eq(Editor_state.lines[2].data, 'abc', 'F - test_insert_newline_at_start_of_line/data:2')
replacement in text_tests.lua at line 1761

[3.5518]→[2.744:829](∅→∅)

check_eq(Editor_state.lines[1], 'abcdef', "F - test_backspace_past_line_boundary")

[3.5518]

[3.35921]

check_eq(Editor_state.lines[1].data, 'abcdef', "F - test_backspace_past_line_boundary")
replacement in text_tests.lua at line 1778

[3.5572]→[2.830:912](∅→∅)

check_eq(Editor_state.lines[1], 'bc', "F - test_backspace_over_selection/data")

[3.5572]

[3.36617]

check_eq(Editor_state.lines[1].data, 'bc', "F - test_backspace_over_selection/data")
replacement in text_tests.lua at line 1797

[3.5626]→[2.913:1003](∅→∅)

check_eq(Editor_state.lines[1], 'bc', "F - test_backspace_over_selection_reverse/data")

[3.5626]

[3.37451]

check_eq(Editor_state.lines[1].data, 'bc', "F - test_backspace_over_selection_reverse/data")
replacement in text_tests.lua at line 1816

[3.5680]→[2.1004:1184](∅→∅)

check_eq(Editor_state.lines[1], 'akl', "F - test_backspace_over_multiple_lines/data:1")
check_eq(Editor_state.lines[2], 'mno', "F - test_backspace_over_multiple_lines/data:2")

[3.5680]

[3.38426]

check_eq(Editor_state.lines[1].data, 'akl', "F - test_backspace_over_multiple_lines/data:1")
check_eq(Editor_state.lines[2].data, 'mno', "F - test_backspace_over_multiple_lines/data:2")
replacement in text_tests.lua at line 1836

[3.5734]→[2.1185:1357](∅→∅)

check_eq(Editor_state.lines[1], 'a', "F - test_backspace_to_start_of_line/data:1")
check_eq(Editor_state.lines[2], 'def', "F - test_backspace_to_start_of_line/data:2")

[3.5734]

[3.39328]

check_eq(Editor_state.lines[1].data, 'a', "F - test_backspace_to_start_of_line/data:1")
check_eq(Editor_state.lines[2].data, 'def', "F - test_backspace_to_start_of_line/data:2")
replacement in text_tests.lua at line 1856

[3.5788]→[2.1358:1530](∅→∅)

check_eq(Editor_state.lines[1], 'abc', "F - test_backspace_to_start_of_line/data:1")
check_eq(Editor_state.lines[2], 'f', "F - test_backspace_to_start_of_line/data:2")

[3.5788]

[3.40232]

check_eq(Editor_state.lines[1].data, 'abc', "F - test_backspace_to_start_of_line/data:1")
check_eq(Editor_state.lines[2].data, 'f', "F - test_backspace_to_start_of_line/data:2")
replacement in text_tests.lua at line 1953

[3.6032]→[2.1531:1617](∅→∅)

check_eq(Editor_state.lines[1], 'xbc', 'F - test_undo_restores_selection/baseline')

[3.6032]

[3.53832]

check_eq(Editor_state.lines[1].data, 'xbc', 'F - test_undo_restores_selection/baseline')
replacement in text.lua at line 53

[3.458]→[2.1682:1827](∅→∅)

if State.lines[State.cursor1.line]:sub(State.cursor1.pos, State.cursor1.pos+utf8.len(State.search_term)-1) == State.search_term then

[3.458]

[3.1429]

if State.lines[State.cursor1.line].data:sub(State.cursor1.pos, State.cursor1.pos+utf8.len(State.search_term)-1) == State.search_term then
replacement in text.lua at line 95

[3.124]→[2.1828:1867](∅→∅)

for frag in line:gmatch('%S*%s*') do

[3.124]

[3.682]

for frag in line.data:gmatch('%S*%s*') do
replacement in text.lua at line 145

[3.79]→[2.1868:2113](∅→∅)

local byte_offset = Text.offset(State.lines[State.cursor1.line], State.cursor1.pos)
State.lines[State.cursor1.line] = string.sub(State.lines[State.cursor1.line], 1, byte_offset-1)..t..string.sub(State.lines[State.cursor1.line], byte_offset)

[3.79]

[3.3]

local byte_offset = Text.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_offset-1)..t..string.sub(State.lines[State.cursor1.line].data, byte_offset)
replacement in text.lua at line 185

[3.1511]→[2.2114:2292](∅→∅)

local byte_start = utf8.offset(State.lines[State.cursor1.line], State.cursor1.pos-1)
local byte_end = utf8.offset(State.lines[State.cursor1.line], State.cursor1.pos)

[3.1511]

[3.2256]

local byte_start = utf8.offset(State.lines[State.cursor1.line].data, State.cursor1.pos-1)
local byte_end = utf8.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
replacement in text.lua at line 189

[3.2306]→[2.2293:2453](∅→∅)

State.lines[State.cursor1.line] = string.sub(State.lines[State.cursor1.line], 1, byte_start-1)..string.sub(State.lines[State.cursor1.line], byte_end)

[3.2306]

[3.2442]

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)
replacement in text.lua at line 191

[3.2455]→[2.2454:2559](∅→∅)

State.lines[State.cursor1.line] = string.sub(State.lines[State.cursor1.line], 1, byte_start-1)

[3.2455]

[3.2544]

State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)
replacement in text.lua at line 198

[2.2580]→[2.2580:2761](∅→∅)

State.cursor1.pos = utf8.len(State.lines[State.cursor1.line-1])+1
State.lines[State.cursor1.line-1] = State.lines[State.cursor1.line-1]..State.lines[State.cursor1.line]

[2.2580]

[2.2761]

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
replacement in text.lua at line 225

[3.1869]→[2.2871:2946](∅→∅)

if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line]) then

[3.1869]

[3.1676]

if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then
replacement in text.lua at line 230

[3.8554]→[2.2947:3200](∅→∅)

if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line]) then
local byte_start = utf8.offset(State.lines[State.cursor1.line], State.cursor1.pos)
local byte_end = utf8.offset(State.lines[State.cursor1.line], State.cursor1.pos+1)

[3.8554]

[3.3265]

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)
replacement in text.lua at line 235

[3.3315]→[2.3201:3361](∅→∅)

State.lines[State.cursor1.line] = string.sub(State.lines[State.cursor1.line], 1, byte_start-1)..string.sub(State.lines[State.cursor1.line], byte_end)

[3.3315]

[3.3451]

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)
replacement in text.lua at line 237

[3.3464]→[2.3362:3467](∅→∅)

State.lines[State.cursor1.line] = string.sub(State.lines[State.cursor1.line], 1, byte_start-1)

[3.3464]

[3.3553]

State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)
replacement in text.lua at line 243

[2.3488]→[2.3488:3595](∅→∅)

State.lines[State.cursor1.line] = State.lines[State.cursor1.line]..State.lines[State.cursor1.line+1]

[2.3488]

[3.4335]

State.lines[State.cursor1.line].data = State.lines[State.cursor1.line].data..State.lines[State.cursor1.line+1].data
replacement in text.lua at line 336

[3.2057]→[2.3596:3790](∅→∅)

local byte_offset = Text.offset(State.lines[State.cursor1.line], State.cursor1.pos)
table.insert(State.lines, State.cursor1.line+1, string.sub(State.lines[State.cursor1.line], byte_offset))

[3.2057]

[3.287]

local byte_offset = Text.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
table.insert(State.lines, State.cursor1.line+1, {data=string.sub(State.lines[State.cursor1.line].data, byte_offset)})
replacement in text.lua at line 339

[3.346]→[2.3791:3889](∅→∅)

State.lines[State.cursor1.line] = string.sub(State.lines[State.cursor1.line], 1, byte_offset-1)

[3.346]

[3.184]

State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_offset-1)
replacement in text.lua at line 412

[3.2453]→[2.4882:5094](∅→∅)

local screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line], screen_line_starting_pos)
local s = string.sub(State.lines[State.cursor1.line], screen_line_starting_byte_offset)

[3.2453]

[2.5094]

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)
replacement in text.lua at line 429

[3.2441]→[2.5207:5427](∅→∅)

local new_screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line], new_screen_line_starting_pos)
local s = string.sub(State.lines[State.cursor1.line], new_screen_line_starting_byte_offset)

[3.2441]

[3.1139]

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)
replacement in text.lua at line 444

[2.5568]→[2.5568:5679](∅→∅)

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

[2.5568]

[2.5679]

State.cursor1.pos = Text.nearest_cursor_pos(State.lines[State.cursor1.line].data, State.cursor_x, State.left)
replacement in text.lua at line 463

[3.4338]→[2.5715:5935](∅→∅)

local new_screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line], new_screen_line_starting_pos)
local s = string.sub(State.lines[State.cursor1.line], new_screen_line_starting_byte_offset)

[3.4338]

[3.1606]

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)
replacement in text.lua at line 484

[3.1805]→[2.5936:6004](∅→∅)

State.cursor1.pos = utf8.len(State.lines[State.cursor1.line]) + 1

[3.1805]

[3.1806]

State.cursor1.pos = utf8.len(State.lines[State.cursor1.line].data) + 1
replacement in text.lua at line 498

[3.916]→[2.6005:6088](∅→∅)

if Text.match(State.lines[State.cursor1.line], State.cursor1.pos-1, '%S') then

[3.916]

[3.986]

if Text.match(State.lines[State.cursor1.line].data, State.cursor1.pos-1, '%S') then
replacement in text.lua at line 510

[3.8150]→[2.6089:6172](∅→∅)

if Text.match(State.lines[State.cursor1.line], State.cursor1.pos-1, '%s') then

[3.8150]

[3.5221]

if Text.match(State.lines[State.cursor1.line].data, State.cursor1.pos-1, '%s') then
replacement in text.lua at line 519

[3.1178]→[2.6173:6247](∅→∅)

if State.cursor1.pos > utf8.len(State.lines[State.cursor1.line]) then

[3.1178]

[3.1239]

if State.cursor1.pos > utf8.len(State.lines[State.cursor1.line].data) then
replacement in text.lua at line 522

[3.1259]→[2.6248:6329](∅→∅)

if Text.match(State.lines[State.cursor1.line], State.cursor1.pos, '%S') then

[3.1259]

[3.1327]

if Text.match(State.lines[State.cursor1.line].data, State.cursor1.pos, '%S') then
replacement in text.lua at line 529

[3.148]→[2.6330:6404](∅→∅)

if State.cursor1.pos > utf8.len(State.lines[State.cursor1.line]) then

[3.148]

[3.1447]

if State.cursor1.pos > utf8.len(State.lines[State.cursor1.line].data) then
replacement in text.lua at line 532

[3.1467]→[2.6405:6486](∅→∅)

if Text.match(State.lines[State.cursor1.line], State.cursor1.pos, '%s') then

[3.1467]

[3.5516]

if Text.match(State.lines[State.cursor1.line].data, State.cursor1.pos, '%s') then
replacement in text.lua at line 555

[2.6570]→[2.6570:6640](∅→∅)

State.cursor1.pos = utf8.len(State.lines[State.cursor1.line]) + 1

[2.6570]

[3.6550]

State.cursor1.pos = utf8.len(State.lines[State.cursor1.line].data) + 1
replacement in text.lua at line 572

[3.823]→[2.6641:6714](∅→∅)

if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line]) then

[3.823]

[3.958]

if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then
replacement in text.lua at line 650

[3.6001]→[2.6990:7201](∅→∅)

local screen_line_starting_byte_offset = Text.offset(line, screen_line_starting_pos)
--? print('iter', y, screen_line_index, screen_line_starting_pos, string.sub(line, screen_line_starting_byte_offset))

[3.6001]

[3.4121]

local screen_line_starting_byte_offset = Text.offset(line.data, screen_line_starting_pos)
--? print('iter', y, screen_line_index, screen_line_starting_pos, string.sub(line.data, screen_line_starting_byte_offset))
replacement in text.lua at line 661

[3.538]→[2.7202:7269](∅→∅)

local s = string.sub(line, screen_line_starting_byte_offset)

[3.538]

[3.3151]

local s = string.sub(line.data, screen_line_starting_byte_offset)
replacement in text.lua at line 674

[3.6333]→[2.7270:7322](∅→∅)

local start_offset = Text.offset(line, start_pos)

[3.6333]

[3.1203]

local start_offset = Text.offset(line.data, start_pos)
replacement in text.lua at line 678

[3.6451]→[2.7323:7451](∅→∅)

local past_end_offset = Text.offset(line, past_end_pos)
screen_line = string.sub(line, start_offset, past_end_offset-1)

[3.6451]

[3.1466]

local past_end_offset = Text.offset(line.data, past_end_pos)
screen_line = string.sub(line.data, start_offset, past_end_offset-1)
replacement in text.lua at line 681

[3.1473]→[2.7452:7498](∅→∅)

screen_line = string.sub(line, start_pos)

[3.1473]

[3.1524]

screen_line = string.sub(line.data, start_pos)
replacement in select.lua at line 56

[3.242]→[2.7501:7635](∅→∅)

local lo_offset = Text.offset(line, lo)
local hi_offset = Text.offset(line, hi)
local pos_offset = Text.offset(line, pos)

[3.242]

[3.391]

local lo_offset = Text.offset(line.data, lo)
local hi_offset = Text.offset(line.data, hi)
local pos_offset = Text.offset(line.data, pos)
replacement in select.lua at line 63

[3.454]→[2.7636:7691](∅→∅)

local before = line:sub(pos_offset, lo_offset-1)

[3.454]

[3.514]

local before = line.data:sub(pos_offset, lo_offset-1)
replacement in select.lua at line 68

[3.706]→[2.7692:7739](∅→∅)

local s = line:sub(lo_offset, hi_offset-1)

[3.706]

[3.758]

local s = line.data:sub(lo_offset, hi_offset-1)
replacement in select.lua at line 139

[3.608]→[2.7859:7975](∅→∅)

local min_offset = Text.offset(State.lines[minl], minp)
local max_offset = Text.offset(State.lines[maxl], maxp)

[3.608]

[3.47487]

local min_offset = Text.offset(State.lines[minl].data, minp)
local max_offset = Text.offset(State.lines[maxl].data, maxp)
replacement in select.lua at line 143

[3.47540]→[2.7976:8074](∅→∅)

State.lines[minl] = State.lines[minl]:sub(1, min_offset-1)..State.lines[minl]:sub(max_offset)

[3.47540]

[3.47635]

State.lines[minl].data = State.lines[minl].data:sub(1, min_offset-1)..State.lines[minl].data:sub(max_offset)
replacement in select.lua at line 147

[3.47674]→[2.8075:8123](∅→∅)

local rhs = State.lines[maxl]:sub(max_offset)

[3.47674]

[3.47721]

local rhs = State.lines[maxl].data:sub(max_offset)
replacement in select.lua at line 152

[3.47780]→[2.8124:8190](∅→∅)

State.lines[minl] = State.lines[minl]:sub(1, min_offset-1)..rhs

[3.47780]

[3.47844]

State.lines[minl].data = State.lines[minl].data:sub(1, min_offset-1)..rhs
replacement in select.lua at line 168

[3.48224]→[2.8191:8307](∅→∅)

local min_offset = Text.offset(State.lines[minl], minp)
local max_offset = Text.offset(State.lines[maxl], maxp)

[3.48224]

[3.48338]

local min_offset = Text.offset(State.lines[minl].data, minp)
local max_offset = Text.offset(State.lines[maxl].data, maxp)
replacement in select.lua at line 171

[3.48361]→[2.8308:8367](∅→∅)

return State.lines[minl]:sub(min_offset, max_offset-1)

[3.48361]

[3.48419]

return State.lines[minl].data:sub(min_offset, max_offset-1)
replacement in select.lua at line 174

[3.48447]→[2.8368:8421](∅→∅)

local result = {State.lines[minl]:sub(min_offset)}

[3.48447]

[3.48503]

local result = {State.lines[minl].data:sub(min_offset)}
replacement in select.lua at line 176

[3.48528]→[2.8422:8463](∅→∅)

table.insert(result, State.lines[i])

[3.48528]

[3.48615]

table.insert(result, State.lines[i].data)
replacement in select.lua at line 178

[3.48621]→[2.8464:8527](∅→∅)

table.insert(result, State.lines[maxl]:sub(1, max_offset-1))

[3.48621]

[3.163]

table.insert(result, State.lines[maxl].data:sub(1, max_offset-1))
replacement in search.lua at line 24

[3.758]→[2.8529:8619](∅→∅)

local pos = find(State.lines[State.cursor1.line], State.search_term, State.cursor1.pos)

[3.758]

[3.101]

local pos = find(State.lines[State.cursor1.line].data, State.search_term, State.cursor1.pos)
replacement in search.lua at line 31

[3.211]→[2.8620:8672](∅→∅)

pos = find(State.lines[i], State.search_term)

[3.211]

[3.201]

pos = find(State.lines[i].data, State.search_term)
replacement in search.lua at line 42

[3.368]→[2.8673:8725](∅→∅)

pos = find(State.lines[i], State.search_term)

[3.368]

[3.50189]

pos = find(State.lines[i].data, State.search_term)
replacement in search.lua at line 52

[3.833]→[2.8726:8793](∅→∅)

pos = find(State.lines[State.cursor1.line], State.search_term)

[3.833]

[3.427]

pos = find(State.lines[State.cursor1.line].data, State.search_term)
replacement in search.lua at line 72

[3.800]→[2.8794:8887](∅→∅)

local pos = rfind(State.lines[State.cursor1.line], State.search_term, State.cursor1.pos-1)

[3.800]

[3.50856]

local pos = rfind(State.lines[State.cursor1.line].data, State.search_term, State.cursor1.pos-1)
replacement in search.lua at line 79

[3.1238]→[2.8888:8941](∅→∅)

pos = rfind(State.lines[i], State.search_term)

[3.1238]

[3.50998]

pos = rfind(State.lines[i].data, State.search_term)
replacement in search.lua at line 90

[3.1411]→[2.8942:8995](∅→∅)

pos = rfind(State.lines[i], State.search_term)

[3.1411]

[3.51229]

pos = rfind(State.lines[i].data, State.search_term)
replacement in search.lua at line 100

[3.910]→[2.8996:9064](∅→∅)

pos = rfind(State.lines[State.cursor1.line], State.search_term)

[3.910]

[3.983]

pos = rfind(State.lines[State.cursor1.line].data, State.search_term)
replacement in main_tests.lua at line 41

[3.84890]→[2.9066:9279](∅→∅)

check_eq(Editor_state.lines[1], 'abc', 'F - test_drop_file/lines:1')
check_eq(Editor_state.lines[2], 'def', 'F - test_drop_file/lines:2')
check_eq(Editor_state.lines[3], 'ghi', 'F - test_drop_file/lines:3')

[3.84890]

[3.7]

check_eq(Editor_state.lines[1].data, 'abc', 'F - test_drop_file/lines:1')
check_eq(Editor_state.lines[2].data, 'def', 'F - test_drop_file/lines:2')
check_eq(Editor_state.lines[3].data, 'ghi', 'F - test_drop_file/lines:3')
replacement in file.lua at line 15

[3.15620]→[2.9307:9340](∅→∅)

table.insert(result, line)

[3.15620]

[3.15864]

table.insert(result, {data=line})
replacement in file.lua at line 19

[3.15901]→[2.9341:9370](∅→∅)

table.insert(result, '')

[3.15901]

[3.15950]

table.insert(result, {data=''})
replacement in file.lua at line 30

[3.419]→[2.9371:9401](∅→∅)

outfile:write(line, '\n')

[3.419]

[3.16214]

outfile:write(line.data, '\n')
replacement in file.lua at line 43

[3.1566]→[2.9402:9433](∅→∅)

table.insert(result, line)

[3.1566]

[3.1810]

table.insert(result, {data=line})
replacement in file.lua at line 46

[3.1839]→[2.9434:9463](∅→∅)

table.insert(result, '')

[3.1839]

[3.1888]

table.insert(result, {data=''})
replacement in edit.lua at line 21

[3.94338]→[2.9465:9504](∅→∅)

lines = {''}, -- array of strings

[3.94338]

[3.1993]

lines = {{data=''}}, -- array of strings
replacement in edit.lua at line 109

[3.5923]→[2.9791:9916](∅→∅)

--? print('screen bottom: '..tostring(State.screen_bottom1.pos)..' in '..tostring(State.lines[State.screen_bottom1.line]))

[3.5923]

[3.4191]

--? print('screen bottom: '..tostring(State.screen_bottom1.pos)..' in '..tostring(State.lines[State.screen_bottom1.line].data))