View difference between Paste ID: pT4bd6yL and 7QarNwLL

 -- Musiclo music player made by timuzkas
 -- licensed under Creative Commons CC0
 -- Simple, sleek player for YT.
 -- //
 -- //
 -- Backend code from @terreng on github, using MIT license
 -- Frontend code by timuzkas, using MIT license
 -- Transliterator by timuzkas, using MIT license
 -- PrimeUI by JackMacWindows, using CC0 license
 
 local expect = require "cc.expect".expect
 -- PrimeUI by JackMacWindows
 -- Public domain/CC0
 
 -- Initialization code
 local PrimeUI = {}
 do
     local coros = {}
     local restoreCursor
 
     --- Adds a task to run in the main loop.
     ---@param func function The function to run, usually an `os.pullEvent` loop
     function PrimeUI.addTask(func)
         expect(1, func, "function")
         local t = {coro = coroutine.create(func)}
         coros[#coros+1] = t
         _, t.filter = coroutine.resume(t.coro)
     end
 
     --- Sends the provided arguments to the run loop, where they will be returned.
     ---@param ... any The parameters to send
     function PrimeUI.resolve(...)
         coroutine.yield(coros, ...)
     end
 
     --- Clears the screen and resets all components. Do not use any previously
     --- created components after calling this function.
     function PrimeUI.clear()
         -- Reset the screen.
         term.setCursorPos(1, 1)
         term.setCursorBlink(false)
         term.setBackgroundColor(colors.black)
         term.setTextColor(colors.white)
         term.clear()
         -- Reset the task list and cursor restore function.
         coros = {}
         restoreCursor = nil
     end
 
     --- Sets or clears the window that holds where the cursor should be.
     ---@param win window|nil The window to set as the active window
     function PrimeUI.setCursorWindow(win)
         expect(1, win, "table", "nil")
         restoreCursor = win and win.restoreCursor
     end
 
     --- Gets the absolute position of a coordinate relative to a window.
     ---@param win window The window to check
     ---@param x number The relative X position of the point
     ---@param y number The relative Y position of the point
     ---@return number x The absolute X position of the window
     ---@return number y The absolute Y position of the window
     function PrimeUI.getWindowPos(win, x, y)
         if win == term then return x, y end
         while win ~= term.native() and win ~= term.current() do
             if not win.getPosition then return x, y end
             local wx, wy = win.getPosition()
             x, y = x + wx - 1, y + wy - 1
             _, win = debug.getupvalue(select(2, debug.getupvalue(win.isColor, 1)), 1) -- gets the parent window through an upvalue
         end
         return x, y
     end
 
     --- Runs the main loop, returning information on an action.
     ---@return any ... The result of the coroutine that exited
     function PrimeUI.run()
         while true do
             -- Restore the cursor and wait for the next event.
             if restoreCursor then restoreCursor() end
             local ev = table.pack(os.pullEvent())
             -- Run all coroutines.
             for _, v in ipairs(coros) do
                 if v.filter == nil or v.filter == ev[1] then
                     -- Resume the coroutine, passing the current event.
                     local res = table.pack(coroutine.resume(v.coro, table.unpack(ev, 1, ev.n)))
                     -- If the call failed, bail out. Coroutines should never exit.
                     if not res[1] then error(res[2], 2) end
                     -- If the coroutine resolved, return its values.
                     if res[2] == coros then return table.unpack(res, 3, res.n) end
                     -- Set the next event filter.
                     v.filter = res[2]
                 end
             end
         end
     end
 end
 
 --- Draws a thin border around a screen region.
 ---@param win window The window to draw on
 ---@param x number The X coordinate of the inside of the box
 ---@param y number The Y coordinate of the inside of the box
 ---@param width number The width of the inner box
 ---@param height number The height of the inner box
 ---@param fgColor color|nil The color of the border (defaults to white)
 ---@param bgColor color|nil The color of the background (defaults to black)
 function PrimeUI.borderBox(win, x, y, width, height, fgColor, bgColor)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, width, "number")
     expect(5, height, "number")
     fgColor = expect(6, fgColor, "number", "nil") or colors.white
     bgColor = expect(7, bgColor, "number", "nil") or colors.black
     -- Draw the top-left corner & top border.
     win.setBackgroundColor(bgColor)
     win.setTextColor(fgColor)
     win.setCursorPos(x - 1, y - 1)
     win.write("\x9C" .. ("\x8C"):rep(width))
     -- Draw the top-right corner.
     win.setBackgroundColor(fgColor)
     win.setTextColor(bgColor)
     win.write("\x93")
     -- Draw the right border.
     for i = 1, height do
         win.setCursorPos(win.getCursorPos() - 1, y + i - 1)
         win.write("\x95")
     end
     -- Draw the left border.
     win.setBackgroundColor(bgColor)
     win.setTextColor(fgColor)
     for i = 1, height do
         win.setCursorPos(x - 1, y + i - 1)
         win.write("\x95")
     end
     -- Draw the bottom border and corners.
     win.setCursorPos(x - 1, y + height)
     win.write("\x8D" .. ("\x8C"):rep(width) .. "\x8E")
 end
 
 --- Creates a clickable button on screen with text.
 ---@param win window The window to draw on
 ---@param x number The X position of the button
 ---@param y number The Y position of the button
 ---@param text string The text to draw on the button
 ---@param action function|string A function to call when clicked, or a string to send with a `run` event
 ---@param fgColor color|nil The color of the button text (defaults to white)
 ---@param bgColor color|nil The color of the button (defaults to light gray)
 ---@param clickedColor color|nil The color of the button when clicked (defaults to gray)
 ---@param periphName string|nil The name of the monitor peripheral, or nil (set if you're using a monitor - events will be filtered to that monitor)
 function PrimeUI.button(win, x, y, text, action, fgColor, bgColor, clickedColor, periphName)
     expect(1, win, "table")
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, text, "string")
     expect(5, action, "function", "string")
     fgColor = expect(6, fgColor, "number", "nil") or colors.white
     bgColor = expect(7, bgColor, "number", "nil") or colors.gray
     clickedColor = expect(8, clickedColor, "number", "nil") or colors.lightGray
     periphName = expect(9, periphName, "string", "nil")
     -- Draw the initial button.
     win.setCursorPos(x, y)
     win.setBackgroundColor(bgColor)
     win.setTextColor(fgColor)
     win.write(" " .. text .. " ")
     -- Get the screen position and add a click handler.
     PrimeUI.addTask(function()
         local buttonDown = false
         while true do
             local event, button, clickX, clickY = os.pullEvent()
             local screenX, screenY = PrimeUI.getWindowPos(win, x, y)
             if event == "mouse_click" and periphName == nil and button == 1 and clickX >= screenX and clickX < screenX + #text + 2 and clickY == screenY then
                 -- Initiate a click action (but don't trigger until mouse up).
                 buttonDown = true
                 -- Redraw the button with the clicked background color.
                 win.setCursorPos(x, y)
                 win.setBackgroundColor(clickedColor)
                 win.setTextColor(fgColor)
                 win.write(" " .. text .. " ")
             elseif (event == "monitor_touch" and periphName == button and clickX >= screenX and clickX < screenX + #text + 2 and clickY == screenY)
                 or (event == "mouse_up" and button == 1 and buttonDown) then
                 -- Finish a click event.
                 if clickX >= screenX and clickX < screenX + #text + 2 and clickY == screenY then
                     -- Trigger the action.
                     if type(action) == "string" then
                         PrimeUI.resolve("button", action)
                     else
                         action()
                     end
                 end
                 -- Redraw the original button state.
                 win.setCursorPos(x, y)
                 win.setBackgroundColor(bgColor)
                 win.setTextColor(fgColor)
                 win.write(" " .. text .. " ")
             end
         end
     end)
 end
 
 --- Draws a line of text, centering it inside a box horizontally.
 ---@param win window The window to draw on
 ---@param x number The X position of the left side of the box
 ---@param y number The Y position of the box
 ---@param width number The width of the box to draw in
 ---@param text string The text to draw
 ---@param fgColor color|nil The color of the text (defaults to white)
 ---@param bgColor color|nil The color of the background (defaults to black)
 function PrimeUI.centerLabel(win, x, y, width, text, fgColor, bgColor)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, width, "number")
     expect(5, text, "string")
     fgColor = expect(6, fgColor, "number", "nil") or colors.white
     bgColor = expect(7, bgColor, "number", "nil") or colors.black
     assert(#text <= width, "string is too long")
     win.setCursorPos(x + math.floor((width - #text) / 2), y)
     win.setTextColor(fgColor)
     win.setBackgroundColor(bgColor)
     win.write(text)
 end
 
 --- Creates a list of entries with toggleable check boxes.
 ---@param win window The window to draw on
 ---@param x number The X coordinate of the inside of the box
 ---@param y number The Y coordinate of the inside of the box
 ---@param width number The width of the inner box
 ---@param height number The height of the inner box
 ---@param selections table<string,string|boolean> A list of entries to show, where the value is whether the item is pre-selected (or `"R"` for required/forced selected)
 ---@param action function|string|nil A function or `run` event that's called when a selection is made
 ---@param fgColor color|nil The color of the text (defaults to white)
 ---@param bgColor color|nil The color of the background (defaults to black)
 function PrimeUI.checkSelectionBox(win, x, y, width, height, selections, action, fgColor, bgColor)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, width, "number")
     expect(5, height, "number")
     expect(6, selections, "table")
     expect(7, action, "function", "string", "nil")
     fgColor = expect(8, fgColor, "number", "nil") or colors.white
     bgColor = expect(9, bgColor, "number", "nil") or colors.black
     -- Calculate how many selections there are.
     local nsel = 0
     for _ in pairs(selections) do nsel = nsel + 1 end
     -- Create the outer display box.
     local outer = window.create(win, x, y, width, height)
     outer.setBackgroundColor(bgColor)
     outer.clear()
     -- Create the inner scroll box.
     local inner = window.create(outer, 1, 1, width - 1, nsel)
     inner.setBackgroundColor(bgColor)
     inner.setTextColor(fgColor)
     inner.clear()
     -- Draw each line in the window.
     local lines = {}
     local nl, selected = 1, 1
     for k, v in pairs(selections) do
         inner.setCursorPos(1, nl)
         inner.write((v and (v == "R" and "[-] " or "[\xD7] ") or "[ ] ") .. k)
         lines[nl] = {k, not not v}
         nl = nl + 1
     end
     -- Draw a scroll arrow if there is scrolling.
     if nsel > height then
         outer.setCursorPos(width, height)
         outer.setBackgroundColor(bgColor)
         outer.setTextColor(fgColor)
         outer.write("\31")
     end
     -- Set cursor blink status.
     inner.setCursorPos(2, selected)
     inner.setCursorBlink(true)
     PrimeUI.setCursorWindow(inner)
     -- Get screen coordinates & add run task.
     local screenX, screenY = PrimeUI.getWindowPos(win, x, y)
     PrimeUI.addTask(function()
         local scrollPos = 1
         while true do
             -- Wait for an event.
             local ev = table.pack(os.pullEvent())
             -- Look for a scroll event or a selection event.
             local dir
             if ev[1] == "key" then
                 if ev[2] == keys.up then dir = -1
                 elseif ev[2] == keys.down then dir = 1
                 elseif ev[2] == keys.space and selections[lines[selected][1]] ~= "R" then
                     -- (Un)select the item.
                     lines[selected][2] = not lines[selected][2]
                     inner.setCursorPos(2, selected)
                     inner.write(lines[selected][2] and "\xD7" or " ")
                     -- Call the action if passed; otherwise, set the original table.
                     if type(action) == "string" then PrimeUI.resolve("checkSelectionBox", action, lines[selected][1], lines[selected][2])
                     elseif action then action(lines[selected][1], lines[selected][2])
                     else selections[lines[selected][1]] = lines[selected][2] end
                     -- Redraw all lines in case of changes.
                     for i, v in ipairs(lines) do
                         local vv = selections[v[1]] == "R" and "R" or v[2]
                         inner.setCursorPos(2, i)
                         inner.write((vv and (vv == "R" and "-" or "\xD7") or " "))
                     end
                     inner.setCursorPos(2, selected)
                 end
             elseif ev[1] == "mouse_scroll" and ev[3] >= screenX and ev[3] < screenX + width and ev[4] >= screenY and ev[4] < screenY + height then
                 dir = ev[2]
             end
             -- Scroll the screen if required.
             if dir and (selected + dir >= 1 and selected + dir <= nsel) then
                 selected = selected + dir
                 if selected - scrollPos < 0 or selected - scrollPos >= height then
                     scrollPos = scrollPos + dir
                     inner.reposition(1, 2 - scrollPos)
                 end
                 inner.setCursorPos(2, selected)
             end
             -- Redraw scroll arrows and reset cursor.
             outer.setCursorPos(width, 1)
             outer.write(scrollPos > 1 and "\30" or " ")
             outer.setCursorPos(width, height)
             outer.write(scrollPos < nsel - height + 1 and "\31" or " ")
             inner.restoreCursor()
         end
     end)
 end
 
 --- Creates a clickable region on screen without any content.
 ---@param win window The window to draw on
 ---@param x number The X position of the button
 ---@param y number The Y position of the button
 ---@param width number The width of the inner box
 ---@param height number The height of the inner box
 ---@param action function|string A function to call when clicked, or a string to send with a `run` event
 ---@param periphName string|nil The name of the monitor peripheral, or nil (set if you're using a monitor - events will be filtered to that monitor)
 function PrimeUI.clickRegion(win, x, y, width, height, action, periphName)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, width, "number")
     expect(5, height, "number")
     expect(6, action, "function", "string")
     expect(7, periphName, "string", "nil")
     PrimeUI.addTask(function()
         -- Get the screen position and add a click handler.
         local screenX, screenY = PrimeUI.getWindowPos(win, x, y)
         local buttonDown = false
         while true do
             local event, button, clickX, clickY = os.pullEvent()
             if (event == "monitor_touch" and periphName == button)
                 or (event == "mouse_click" and button == 1 and periphName == nil) then
                 -- Finish a click event.
                 if clickX >= screenX and clickX < screenX + width
                     and clickY >= screenY and clickY < screenY + height then
                     -- Trigger the action.
                     if type(action) == "string" then
                         PrimeUI.resolve("clickRegion", action)
                     else
                         action()
                     end
                 end
             end
         end
     end)
 end
 
 --- Draws a NFT-formatted image to the screen.
 ---@param win window The window to draw on
 ---@param x number The X position of the top left corner of the image
 ---@param y number The Y position of the top left corner of the image
 ---@param data string|table The path to the image to load, or the image data itself
 function PrimeUI.drawNFT(win, x, y, data)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, data, "string", "table")
     -- Load the image file if a string was passed using nft.load.
     if type(data) == "string" then
         data = assert(nft.load("data/example.nft"), "File is not a valid NFT file")
     end
     nft.draw(data, x, y , win)
 end
 
 --- Draws a block of text inside a window with word wrapping, optionally resizing the window to fit.
 ---@param win window The window to draw in
 ---@param text string The text to draw
 ---@param resizeToFit boolean|nil Whether to resize the window to fit the text (defaults to false). This is useful for scroll boxes.
 ---@param fgColor color|nil The color of the text (defaults to white)
 ---@param bgColor color|nil The color of the background (defaults to black)
 ---@return number lines The total number of lines drawn
 function PrimeUI.drawText(win, text, resizeToFit, fgColor, bgColor)
     expect(1, win, "table")
     expect(2, text, "string")
     expect(3, resizeToFit, "boolean", "nil")
     fgColor = expect(4, fgColor, "number", "nil") or colors.white
     bgColor = expect(5, bgColor, "number", "nil") or colors.black
     -- Set colors.
     win.setBackgroundColor(bgColor)
     win.setTextColor(fgColor)
     -- Redirect to the window to use print on it.
     local old = term.redirect(win)
     -- Draw the text using print().
     local lines = print(text)
     -- Redirect back to the original terminal.
     term.redirect(old)
     -- Resize the window if desired.
     if resizeToFit then
         -- Get original parameters.
         local x, y = win.getPosition()
         local w = win.getSize()
         -- Resize the window.
         win.reposition(x, y, w, lines)
     end
     return lines
 end
 
 --- Draws a horizontal line at a position with the specified width.
 ---@param win window The window to draw on
 ---@param x number The X position of the left side of the line
 ---@param y number The Y position of the line
 ---@param width number The width/length of the line
 ---@param fgColor color|nil The color of the line (defaults to white)
 ---@param bgColor color|nil The color of the background (defaults to black)
 function PrimeUI.horizontalLine(win, x, y, width, fgColor, bgColor)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, width, "number")
     fgColor = expect(5, fgColor, "number", "nil") or colors.white
     bgColor = expect(6, bgColor, "number", "nil") or colors.black
     -- Use drawing characters to draw a thin line.
     win.setCursorPos(x, y)
     win.setTextColor(fgColor)
     win.setBackgroundColor(bgColor)
     win.write(("\x8C"):rep(width))
 end
 
 --- Creates a text input box.
 ---@param win window The window to draw on
 ---@param x number The X position of the left side of the box
 ---@param y number The Y position of the box
 ---@param width number The width/length of the box
 ---@param action function|string A function or `run` event to call when the enter key is pressed
 ---@param fgColor color|nil The color of the text (defaults to white)
 ---@param bgColor color|nil The color of the background (defaults to black)
 ---@param replacement string|nil A character to replace typed characters with
 ---@param history string[]|nil A list of previous entries to provide
 ---@param completion function|nil A function to call to provide completion
 ---@param default string|nil A string to return if the box is empty
 function PrimeUI.inputBox(win, x, y, width, action, fgColor, bgColor, replacement, history, completion, default)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, width, "number")
     expect(5, action, "function", "string")
     fgColor = expect(6, fgColor, "number", "nil") or colors.white
     bgColor = expect(7, bgColor, "number", "nil") or colors.black
     expect(8, replacement, "string", "nil")
     expect(9, history, "table", "nil")
     expect(10, completion, "function", "nil")
     expect(11, default, "string", "nil")
     -- Create a window to draw the input in.
     local box = window.create(win, x, y, width, 1)
     box.setTextColor(fgColor)
     box.setBackgroundColor(bgColor)
     box.clear()
     -- Call read() in a new coroutine.
     PrimeUI.addTask(function()
         -- We need a child coroutine to be able to redirect back to the window.
         local coro = coroutine.create(read)
         -- Run the function for the first time, redirecting to the window.
         local old = term.redirect(box)
         local ok, res = coroutine.resume(coro, replacement, history, completion, default)
         term.redirect(old)
         -- Run the coroutine until it finishes.
         while coroutine.status(coro) ~= "dead" do
             -- Get the next event.
             local ev = table.pack(os.pullEvent())
             -- Redirect and resume.
             old = term.redirect(box)
             ok, res = coroutine.resume(coro, table.unpack(ev, 1, ev.n))
             term.redirect(old)
             -- Pass any errors along.
             if not ok then error(res) end
         end
         -- Send the result to the receiver.
         if type(action) == "string" then PrimeUI.resolve("inputBox", action, res)
         else action(res) end
         -- Spin forever, because tasks cannot exit.
         while true do os.pullEvent() end
     end)
 end
 
 --- Runs a function or action repeatedly after a specified time period until canceled.
 --- If a function is passed as an action, it may return a number to change the
 --- period, or `false` to stop it.
 ---@param time number The amount of time to wait for each time, in seconds
 ---@param action function|string The function to call when the timer completes, or a `run` event to send
 ---@return function cancel A function to cancel the timer
 function PrimeUI.interval(time, action)
     expect(1, time, "number")
     expect(2, action, "function", "string")
     -- Start the timer.
     local timer = os.startTimer(time)
     -- Add a task to wait for the timer.
     PrimeUI.addTask(function()
         while true do
             -- Wait for a timer event.
             local _, tm = os.pullEvent("timer")
             if tm == timer then
                 -- Fire the timer action.
                 local res
                 if type(action) == "string" then PrimeUI.resolve("timeout", action)
                 else res = action() end
                 -- Check the return value and adjust time accordingly.
                 if type(res) == "number" then time = res end
                 -- Set a new timer if not canceled.
                 if res ~= false then timer = os.startTimer(time) end
             end
         end
     end)
     -- Return a function to cancel the timer.
     return function() os.cancelTimer(timer) end
 end
 
 --- Adds an action to trigger when a key is pressed.
 ---@param key key The key to trigger on, from `keys.*`
 ---@param action function|string A function to call when clicked, or a string to use as a key for a `run` return event
 function PrimeUI.keyAction(key, action)
     expect(1, key, "number")
     expect(2, action, "function", "string")
     PrimeUI.addTask(function()
         while true do
             local _, param1 = os.pullEvent("key") -- wait for key
             if param1 == key then
                 if type(action) == "string" then PrimeUI.resolve("keyAction", action)
                 else action() end
             end
         end
     end)
 end
 
 --- Draws a line of text at a position.
 ---@param win window The window to draw on
 ---@param x number The X position of the left side of the text
 ---@param y number The Y position of the text
 ---@param text string The text to draw
 ---@param fgColor color|nil The color of the text (defaults to white)
 ---@param bgColor color|nil The color of the background (defaults to black)
 function PrimeUI.label(win, x, y, text, fgColor, bgColor)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, text, "string")
     fgColor = expect(5, fgColor, "number", "nil") or colors.white
     bgColor = expect(6, bgColor, "number", "nil") or colors.black
     win.setCursorPos(x, y)
     win.setTextColor(fgColor)
     win.setBackgroundColor(bgColor)
     win.write(text)
 end
 
 --- Creates a progress bar, which can be updated by calling the returned function.
 ---@param win window The window to draw on
 ---@param x number The X position of the left side of the bar
 ---@param y number The Y position of the bar
 ---@param width number The width of the bar
 ---@param fgColor color|nil The color of the activated part of the bar (defaults to white)
 ---@param bgColor color|nil The color of the inactive part of the bar (defaults to black)
 ---@param useShade boolean|nil Whether to use shaded areas for the inactive part (defaults to false)
 ---@return function redraw A function to call to update the progress of the bar, taking a number from 0.0 to 1.0
 function PrimeUI.progressBar(win, x, y, width, fgColor, bgColor, useShade)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, width, "number")
     fgColor = expect(5, fgColor, "number", "nil") or colors.white
     bgColor = expect(6, bgColor, "number", "nil") or colors.black
     expect(7, useShade, "boolean", "nil")
     local function redraw(progress)
         expect(1, progress, "number")
         if progress < 0 or progress > 1 then error("bad argument #1 (value out of range)", 2) end
         -- Draw the active part of the bar.
         win.setCursorPos(x, y)
         win.setBackgroundColor(bgColor)
         win.setBackgroundColor(fgColor)
         win.write((" "):rep(math.floor(progress * width)))
         -- Draw the inactive part of the bar, using shade if desired.
         win.setBackgroundColor(bgColor)
         win.setTextColor(fgColor)
         win.write((useShade and "\x7F" or " "):rep(width - math.floor(progress * width)))
     end
     redraw(0)
     return redraw
 end
 
 --- Creates a scrollable window, which allows drawing large content in a small area.
 ---@param win window The parent window of the scroll box
 ---@param x number The X position of the box
 ---@param y number The Y position of the box
 ---@param width number The width of the box
 ---@param height number The height of the outer box
 ---@param innerHeight number The height of the inner scroll area
 ---@param allowArrowKeys boolean|nil Whether to allow arrow keys to scroll the box (defaults to true)
 ---@param showScrollIndicators boolean|nil Whether to show arrow indicators on the right side when scrolling is available, which reduces the inner width by 1 (defaults to false)
 ---@param fgColor number|nil The color of scroll indicators (defaults to white)
 ---@param bgColor color|nil The color of the background (defaults to black)
 ---@return window inner The inner window to draw inside
 ---@return fun(pos:number) scroll A function to manually set the scroll position of the window
 function PrimeUI.scrollBox(win, x, y, width, height, innerHeight, allowArrowKeys, showScrollIndicators, fgColor, bgColor)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, width, "number")
     expect(5, height, "number")
     expect(6, innerHeight, "number")
     expect(7, allowArrowKeys, "boolean", "nil")
     expect(8, showScrollIndicators, "boolean", "nil")
     fgColor = expect(9, fgColor, "number", "nil") or colors.white
     bgColor = expect(10, bgColor, "number", "nil") or colors.black
     if allowArrowKeys == nil then allowArrowKeys = true end
     -- Create the outer container box.
     local outer = window.create(win == term and term.current() or win, x, y, width, height)
     outer.setBackgroundColor(bgColor)
     outer.clear()
     -- Create the inner scrolling box.
     local inner = window.create(outer, 1, 1, width - (showScrollIndicators and 1 or 0), innerHeight)
     inner.setBackgroundColor(bgColor)
     inner.clear()
     -- Draw scroll indicators if desired.
     if showScrollIndicators then
         outer.setBackgroundColor(bgColor)
         outer.setTextColor(fgColor)
         outer.setCursorPos(width, height)
         outer.write(innerHeight > height and "\31" or " ")
     end
     -- Get the absolute position of the window.
     x, y = PrimeUI.getWindowPos(win, x, y)
     -- Add the scroll handler.
     local scrollPos = 1
 
     -- Store the original event filter function
     local originalEventFilter = PrimeUI.eventFilter
 
     -- Replace the event filter to adjust mouse coordinates for buttons inside the scroll box
     PrimeUI.eventFilter = function(event, ...)
         if event == "mouse_click" or event == "mouse_up" or event == "mouse_drag" then
             local _, mouseX, mouseY = ...
 
             -- Check if the click is within the scroll box boundaries
             if mouseX >= x and mouseX < x + width and mouseY >= y and mouseY < y + height then
                 -- Adjust the Y coordinate based on scroll position
                 local adjustedY = mouseY + scrollPos - 1
 
                 -- Call the original event filter with adjusted coordinates
                 return originalEventFilter(event, _, mouseX, adjustedY, select(4, ...))
             end
         end
 
         -- For other events, use the original filter
         return originalEventFilter(event, ...)
     end
 
     PrimeUI.addTask(function()
         while true do
             -- Wait for next event.
             local ev = table.pack(os.pullEvent())
             -- Update inner height in case it changed.
             innerHeight = select(2, inner.getSize())
             -- Check for scroll events and set direction.
             local dir
             if ev[1] == "key" and allowArrowKeys then
                 if ev[2] == keys.up then dir = -1
                 elseif ev[2] == keys.down then dir = 1 end
             elseif ev[1] == "mouse_scroll" and ev[3] >= x and ev[3] < x + width and ev[4] >= y and ev[4] < y + height then
                 dir = ev[2]
             end
             -- If there's a scroll event, move the window vertically.
             if dir and (scrollPos + dir >= 1 and scrollPos + dir <= innerHeight - height) then
                 scrollPos = scrollPos + dir
                 inner.reposition(1, 2 - scrollPos)
             end
             -- Redraw scroll indicators if desired.
             if showScrollIndicators then
                 outer.setBackgroundColor(bgColor)
                 outer.setTextColor(fgColor)
                 outer.setCursorPos(width, 1)
                 outer.write(scrollPos > 1 and "\30" or " ")
                 outer.setCursorPos(width, height)
                 outer.write(scrollPos < innerHeight - height and "\31" or " ")
             end
         end
     end)
 
     -- Make a function to allow external scrolling.
     local function scroll(pos)
         expect(1, pos, "number")
         pos = math.floor(pos)
         expect.range(pos, 1, innerHeight - height)
         -- Scroll the window.
         scrollPos = pos
         inner.reposition(1, 2 - scrollPos)
         -- Redraw scroll indicators if desired.
         if showScrollIndicators then
             outer.setBackgroundColor(bgColor)
             outer.setTextColor(fgColor)
             outer.setCursorPos(width, 1)
             outer.write(scrollPos > 1 and "\30" or " ")
             outer.setCursorPos(width, height)
             outer.write(scrollPos < innerHeight - height and "\31" or " ")
         end
     end
 
     -- Add a cleanup task to restore the original event filter when the scroll box is destroyed
     PrimeUI.addTask(function()
         while true do
             local event = os.pullEvent("term_resize")
             -- Check if the outer window still exists
             if not outer.isColor then
                 -- Restore the original event filter
                 PrimeUI.eventFilter = originalEventFilter
                 return
             end
         end
     end)
 
     return inner, scroll
 end
 
 --- Creates a list of entries that can each be selected.
 ---@param win window The window to draw on
 ---@param x number The X coordinate of the inside of the box
 ---@param y number The Y coordinate of the inside of the box
 ---@param width number The width of the inner box
 ---@param height number The height of the inner box
 ---@param entries string[] A list of entries to show, where the value is whether the item is pre-selected (or `"R"` for required/forced selected)
 ---@param action function|string A function or `run` event that's called when a selection is made
 ---@param selectChangeAction function|string|nil A function or `run` event that's called when the current selection is changed
 ---@param fgColor color|nil The color of the text (defaults to white)
 ---@param bgColor color|nil The color of the background (defaults to black)
 function PrimeUI.selectionBox(win, x, y, width, height, entries, action, selectChangeAction, fgColor, bgColor)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, width, "number")
     expect(5, height, "number")
     expect(6, entries, "table")
     expect(7, action, "function", "string")
     expect(8, selectChangeAction, "function", "string", "nil")
     fgColor = expect(9, fgColor, "number", "nil") or colors.white
     bgColor = expect(10, bgColor, "number", "nil") or colors.black
     -- Check that all entries are strings.
     if #entries == 0 then error("bad argument #6 (table must not be empty)", 2) end
     for i, v in ipairs(entries) do
         if type(v) ~= "string" then error("bad item " .. i .. " in entries table (expected string, got " .. type(v), 2) end
     end
     -- Create container window.
     local entrywin = window.create(win, x, y, width, height)
     local selection, scroll = 1, 1
     -- Create a function to redraw the entries on screen.
     local function drawEntries()
         -- Clear and set invisible for performance.
         entrywin.setVisible(false)
         entrywin.setBackgroundColor(bgColor)
         entrywin.clear()
         -- Draw each entry in the scrolled region.
         for i = scroll, scroll + height - 1 do
             -- Get the entry; stop if there's no more.
             local e = entries[i]
             if not e then break end
             -- Set the colors: invert if selected.
             entrywin.setCursorPos(2, i - scroll + 1)
             if i == selection then
                 entrywin.setBackgroundColor(fgColor)
                 entrywin.setTextColor(bgColor)
             else
                 entrywin.setBackgroundColor(bgColor)
                 entrywin.setTextColor(fgColor)
             end
             -- Draw the selection.
             entrywin.clearLine()
             entrywin.write(#e > width - 1 and e:sub(1, width - 4) .. "..." or e)
         end
         -- Draw scroll arrows.
         entrywin.setBackgroundColor(bgColor)
         entrywin.setTextColor(fgColor)
         entrywin.setCursorPos(width, 1)
         entrywin.write("\30")
         entrywin.setCursorPos(width, height)
         entrywin.write("\31")
         -- Send updates to the screen.
         entrywin.setVisible(true)
     end
     -- Draw first screen.
     drawEntries()
     -- Add a task for selection keys.
     PrimeUI.addTask(function()
         while true do
             local event, key, cx, cy = os.pullEvent()
             if event == "key" then
                 if key == keys.down and selection < #entries then
                     -- Move selection down.
                     selection = selection + 1
                     if selection > scroll + height - 1 then scroll = scroll + 1 end
                     -- Send action if necessary.
                     if type(selectChangeAction) == "string" then PrimeUI.resolve("selectionBox", selectChangeAction, selection)
                     elseif selectChangeAction then selectChangeAction(selection) end
                     -- Redraw screen.
                     drawEntries()
                 elseif key == keys.up and selection > 1 then
                     -- Move selection up.
                     selection = selection - 1
                     if selection < scroll then scroll = scroll - 1 end
                     -- Send action if necessary.
                     if type(selectChangeAction) == "string" then PrimeUI.resolve("selectionBox", selectChangeAction, selection)
                     elseif selectChangeAction then selectChangeAction(selection) end
                     -- Redraw screen.
                     drawEntries()
                 elseif key == keys.enter then
                     -- Select the entry: send the action.
                     if type(action) == "string" then PrimeUI.resolve("selectionBox", action, entries[selection])
                     else action(entries[selection]) end
                 end
             elseif event == "mouse_click" and key == 1 then
                 -- Handle clicking the scroll arrows.
                 local wx, wy = PrimeUI.getWindowPos(entrywin, 1, 1)
                 if cx == wx + width - 1 then
                     if cy == wy and selection > 1 then
                         -- Move selection up.
                         selection = selection - 1
                         if selection < scroll then scroll = scroll - 1 end
                         -- Send action if necessary.
                         if type(selectChangeAction) == "string" then PrimeUI.resolve("selectionBox", selectChangeAction, selection)
                         elseif selectChangeAction then selectChangeAction(selection) end
                         -- Redraw screen.
                         drawEntries()
                     elseif cy == wy + height - 1 and selection < #entries then
                         -- Move selection down.
                         selection = selection + 1
                         if selection > scroll + height - 1 then scroll = scroll + 1 end
                         -- Send action if necessary.
                         if type(selectChangeAction) == "string" then PrimeUI.resolve("selectionBox", selectChangeAction, selection)
                         elseif selectChangeAction then selectChangeAction(selection) end
                         -- Redraw screen.
                         drawEntries()
                     end
                 elseif cx >= wx and cx < wx + width - 1 and cy >= wy and cy < wy + height then
                     local sel = scroll + (cy - wy)
                     if sel == selection then
                         -- Select the entry: send the action.
                         if type(action) == "string" then PrimeUI.resolve("selectionBox", action, entries[selection])
                         else action(entries[selection]) end
                     else
                         selection = sel
                         -- Send action if necessary.
                         if type(selectChangeAction) == "string" then PrimeUI.resolve("selectionBox", selectChangeAction, selection)
                         elseif selectChangeAction then selectChangeAction(selection) end
                         -- Redraw screen.
                         drawEntries()
                     end
                 end
             elseif event == "mouse_scroll" then
                 -- Handle mouse scrolling.
                 local wx, wy = PrimeUI.getWindowPos(entrywin, 1, 1)
                 if cx >= wx and cx < wx + width and cy >= wy and cy < wy + height then
                     if key < 0 and selection > 1 then
                         -- Move selection up.
                         selection = selection - 1
                         if selection < scroll then scroll = scroll - 1 end
                         -- Send action if necessary.
                         if type(selectChangeAction) == "string" then PrimeUI.resolve("selectionBox", selectChangeAction, selection)
                         elseif selectChangeAction then selectChangeAction(selection) end
                         -- Redraw screen.
                         drawEntries()
                     elseif key > 0 and selection < #entries then
                         -- Move selection down.
                         selection = selection + 1
                         if selection > scroll + height - 1 then scroll = scroll + 1 end
                         -- Send action if necessary.
                         if type(selectChangeAction) == "string" then PrimeUI.resolve("selectionBox", selectChangeAction, selection)
                         elseif selectChangeAction then selectChangeAction(selection) end
                         -- Redraw screen.
                         drawEntries()
                     end
                 end
             end
         end
     end)
 end
 
 --- Creates a text box that wraps text and can have its text modified later.
 ---@param win window The parent window of the text box
 ---@param x number The X position of the box
 ---@param y number The Y position of the box
 ---@param width number The width of the box
 ---@param height number The height of the box
 ---@param text string The initial text to draw
 ---@param fgColor color|nil The color of the text (defaults to white)
 ---@param bgColor color|nil The color of the background (defaults to black)
 ---@return function redraw A function to redraw the window with new contents
 function PrimeUI.textBox(win, x, y, width, height, text, fgColor, bgColor)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, width, "number")
     expect(5, height, "number")
     expect(6, text, "string")
     fgColor = expect(7, fgColor, "number", "nil") or colors.white
     bgColor = expect(8, bgColor, "number", "nil") or colors.black
     -- Create the box window.
     local box = window.create(win, x, y, width, height)
     -- Override box.getSize to make print not scroll.
     function box.getSize()
         return width, math.huge
     end
     -- Define a function to redraw with.
     local function redraw(_text)
         expect(1, _text, "string")
         -- Set window parameters.
         box.setBackgroundColor(bgColor)
         box.setTextColor(fgColor)
         box.clear()
         box.setCursorPos(1, 1)
         -- Redirect and draw with `print`.
         local old = term.redirect(box)
         print(_text)
         term.redirect(old)
     end
     redraw(text)
     return redraw
 end
 
 --- Creates a clickable, toggleable button on screen with text.
 ---@param win window The window to draw on
 ---@param x number The X position of the button
 ---@param y number The Y position of the button
 ---@param textOn string The text to draw on the button when on
 ---@param textOff string The text to draw on the button when off (must be the same length as textOn)
 ---@param action function|string A function to call when clicked, or a string to send with a `run` event
 ---@param fgColor color|nil The color of the button text (defaults to white)
 ---@param bgColor color|nil The color of the button (defaults to light gray)
 ---@param clickedColor color|nil The color of the button when clicked (defaults to gray)
 ---@param periphName string|nil The name of the monitor peripheral, or nil (set if you're using a monitor - events will be filtered to that monitor)
 function PrimeUI.toggleButton(win, x, y, textOn, textOff, action, fgColor, bgColor, clickedColor, periphName)
     expect(1, win, "table")
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, textOn, "string")
     expect(5, textOff, "string")
     if #textOn ~= #textOff then error("On and off text must be the same length", 2) end
     expect(6, action, "function", "string")
     fgColor = expect(7, fgColor, "number", "nil") or colors.white
     bgColor = expect(8, bgColor, "number", "nil") or colors.gray
     clickedColor = expect(9, clickedColor, "number", "nil") or colors.lightGray
     periphName = expect(10, periphName, "string", "nil")
     -- Draw the initial button.
     win.setCursorPos(x, y)
     win.setBackgroundColor(bgColor)
     win.setTextColor(fgColor)
     win.write(" " .. textOff .. " ")
     local state = false
     -- Get the screen position and add a click handler.
     PrimeUI.addTask(function()
         local screenX, screenY = PrimeUI.getWindowPos(win, x, y)
         local buttonDown = false
         while true do
             local event, button, clickX, clickY = os.pullEvent()
             if event == "mouse_click" and periphName == nil and button == 1 and clickX >= screenX and clickX < screenX + #textOn + 2 and clickY == screenY then
                 -- Initiate a click action (but don't trigger until mouse up).
                 buttonDown = true
                 -- Redraw the button with the clicked background color.
                 win.setCursorPos(x, y)
                 win.setBackgroundColor(clickedColor)
                 win.setTextColor(fgColor)
                 win.write(" " .. (state and textOn or textOff) .. " ")
             elseif (event == "monitor_touch" and periphName == button and clickX >= screenX and clickX < screenX + #textOn + 2 and clickY == screenY)
                 or (event == "mouse_up" and button == 1 and buttonDown) then
                 -- Finish a click event.
                 state = not state
                 if clickX >= screenX and clickX < screenX + #textOn + 2 and clickY == screenY then
                     -- Trigger the action.
                     if type(action) == "string" then
                         PrimeUI.resolve("toggleButton", action, state)
                     else
                         action(state)
                     end
                 end
                 -- Redraw the original button state.
                 win.setCursorPos(x, y)
                 win.setBackgroundColor(bgColor)
                 win.setTextColor(fgColor)
                 win.write(" " .. (state and textOn or textOff) .. " ")
             end
         end
     end)
 end
 
 --- Draws a vertical line at a position with the specified height.
 ---@param win window The window to draw on
 ---@param x number The X position of the line
 ---@param y number The Y position of the top of the line
 ---@param height number The height of the line
 ---@param right boolean|nil Whether to align the line to the right instead of the left (defaults to false)
 ---@param fgColor color|nil The color of the line (defaults to white)
 ---@param bgColor color|nil The color of the background (defaults to black)
 function PrimeUI.verticalLine(win, x, y, height, right, fgColor, bgColor)
     expect(1, win, "table")
     expect(2, x, "number")
     expect(3, y, "number")
     expect(4, height, "number")
     right = expect(5, right, "boolean", "nil") or false
     fgColor = expect(6, fgColor, "number", "nil") or colors.white
     bgColor = expect(7, bgColor, "number", "nil") or colors.black
     -- Use drawing characters to draw a thin line.
     win.setTextColor(right and bgColor or fgColor)
     win.setBackgroundColor(right and fgColor or bgColor)
     for j = 1, height do
         win.setCursorPos(x, y + j - 1)
         win.write("\x95")
     end
 end
 -- local ui = require "primeui"
 ui = PrimeUI
 
 -- Transliterator | made by timuzkas
 local Transliteration = {}
 Transliteration.__index = Transliteration
 
 local cyrillicAlphabet = {
   {"А", "а", "A", "a"}, {"Б", "б", "B", "b"}, {"В", "в", "V", "v"}, {"Г", "г", "G", "g"}, {"Д", "д", "D", "d"},
   {"Е", "е", "E", "e"}, {"Ё", "ё", "YO", "yo"}, {"Ж", "ж", "ZH", "zh"}, {"З", "з", "Z", "z"}, {"И", "и", "I", "i"},
   {"Й", "й", "Y", "y"}, {"К", "к", "K", "k"}, {"Л", "л", "L", "l"}, {"М", "м", "M", "m"}, {"Н", "н", "N", "n"},
   {"О", "о", "O", "o"}, {"П", "п", "P", "p"}, {"Р", "р", "R", "r"}, {"С", "с", "S", "s"}, {"Т", "т", "T", "t"},
   {"У", "у", "U", "u"}, {"Ф", "ф", "F", "f"}, {"Х", "х", "KH", "kh"}, {"Ц", "ц", "TS", "ts"}, {"Ч", "ч", "CH", "ch"},
   {"Ш", "ш", "SH", "sh"}, {"Щ", "щ", "SHCH", "shch"}, {"Ъ", "ъ", "", ""}, {"Ы", "ы", "Y", "y"}, {"Ь", "ь", "", ""},
   {"Э", "э", "E", "e"}, {"Ю", "ю", "YU", "yu"}, {"Я", "я", "YA", "ya"}
 }
 
 function Transliteration.new()
   local self = setmetatable({}, Transliteration)
   self.cyrillicToLatin = {}
   self.latinToCyrillic = {}
   self.isSetup = false
   return self
 end
 
 function Transliteration:setup()
   if self.isSetup then return end
   for _, pair in ipairs(cyrillicAlphabet) do
     self.cyrillicToLatin[utf8.codepoint(pair[1])] = pair[3]
     self.cyrillicToLatin[utf8.codepoint(pair[2])] = pair[4]
     if pair[3] ~= "" then
       if not self.latinToCyrillic[pair[3]] then
         self.latinToCyrillic[pair[3]] = {}
       end
       table.insert(self.latinToCyrillic[pair[3]], pair[1])
       table.insert(self.latinToCyrillic[pair[3]], pair[2])
     end
     if pair[4] ~= "" then
       if not self.latinToCyrillic[pair[4]] then
         self.latinToCyrillic[pair[4]] = {}
       end
       table.insert(self.latinToCyrillic[pair[4]], pair[1])
       table.insert(self.latinToCyrillic[pair[4]], pair[2])
     end
   end
   self.isSetup = true
 end
 
 function Transliteration:translate(str)
   if not self.isSetup then self:setup() end
   local result = ""
 
   local chars = {}
   for char in str:gmatch(utf8.charpattern) do
     table.insert(chars, char)
   end
 
   for _, char in ipairs(chars) do
     local codepoint = utf8.codepoint(char)
     local latin = self.cyrillicToLatin[codepoint]
     if latin then
       result = result .. latin
     else
       result = result .. char
     end
   end
 
   return result
 end
 
 -- stripped for size reasons
 
 local function box(terminal, x, y, width, height, color, cornerStyle)
     cornerStyle = cornerStyle or "square"
     terminal.setBackgroundColor(color)
 
     if cornerStyle == "square" then
         for i = y, y + height - 1 do
             terminal.setCursorPos(x, i)
             terminal.write(string.rep(" ", width))
         end
     elseif cornerStyle == "round" then
         terminal.setCursorPos(x + 1, y)
         terminal.write(string.rep(" ", width - 2))
 
         for i = y + 1, y + height - 2 do
             terminal.setCursorPos(x, i)
             terminal.write(string.rep(" ", width))
         end
 
         terminal.setCursorPos(x + 1, y + height - 1)
         terminal.write(string.rep(" ", width - 2))
     end
 end
 ui.box = box
 
 local api_base_url = "https://ipod-2to6magyna-uc.a.run.app/"
 
 local width, height = term.getSize()
 
 
 local last_search_url = nil
 local search_results = nil
-local search_error = nil
+
 local queue = {}
 local now_playing = nil
 local looping = false
 
 local playing_id = nil
 local last_download_url = nil
 local playing_status = 0
 
 local player_handle = nil
 local start = nil
 local pcm = nil
 local size = nil
 local decoder = nil
 local needs_next_chunk = 0
 local buffer
 
 local speakers = { peripheral.find("speaker") }
 
 if #speakers == 0 then
     error("No speakers attached. You need to connect a speaker to this computer. If this is an Advanced Noisy Pocket Computer, then this is a bug, and you should try restarting your Minecraft game.", 0)
 end
 
 local speaker = speakers[1]
 
 os.startTimer(1)
 
 -- ui helper functions
 local function playSong(song)
     now_playing = song
     playing = true
     playing_id = nil
 end
 
 local function stopPlayback()
     playing = false
     speaker.stop()
     playing_id = nil
 end
 
 local function togglePlayPause()
     if playing then
         stopPlayback()
     else
         if now_playing or #queue > 0 then
             playSong(now_playing or queue[1])
         end
     end
 end
 
 local function skipSong()
     if #queue > 0 then
         now_playing = queue[1]
         table.remove(queue, 1)
         playing_id = nil
     else
         now_playing = nil
         playing = false
     end
 end
 
 local function toggleLoop()
     looping = not looping
 end
 
 local function addToQueue(song, position)
     if position then
         table.insert(queue, position, song)
     else
         table.insert(queue, song)
     end
 end
 
 local function removeFromQueue(position)
     if position and position <= #queue then
         table.remove(queue, position)
     end
 end
 
 local function clearQueue()
     queue = {}
 end
 
 local function searchMusic(query)
     last_search = query
     last_search_url = api_base_url .. "?search=" .. textutils.urlEncode(query)
     http.request(last_search_url)
     search_results = nil
-    search_error = nil
+    search_error = false
-    ui.searchDone = false
+
 
 -- not used, tho may need later
 local function handleAudioStream(response)
     player_handle = response
     start = response.read(4)
     size = 16 * 1024 - 4
     playing_status = 1
     decoder = require "cc.audio.dfpwm".make_decoder()
 end
 
 -- custom pallete based on spotify one.
 local original_palette = {}
 local function initCustomPallete()
     for i=1, 16 do
         original_palette[i] = term.getPaletteColor(i)
     end
 
     term.setPaletteColor(colors.green, 0x1ED760)
     term.setPaletteColor(colors.lightGray, 0xb3b3b3)
     term.setPaletteColor(colors.gray, 0x212121)
     term.setPaletteColor(colors.purple, 0x457e59)
     term.setPaletteColor(colors.magenta, 0x62d089)
     term.setPaletteColor(colors.brown, 0x2e2e2e)
 end
 
 -- truncation and transliteration for text
 local function fixString(str, limit)
     if not str then return "" end
     --local transliterator = Transliteration.new()
     --str = transliterator.translate(transliterator, str)
-    local transliterator = Transliteration.new()
+
-    str = transliterator.translate(transliterator, str)
+
         return str
     end
 
     return string.sub(str, 1, limit - 3) .. "..."
 end
 
 
 -- UI LOOP
 
 ui.page = 1
 
 local function redrawScreen()
     -- init custom palette
     initCustomPallete()
 
 
     while true do
         ui.clear()
         ui.borderBox(term.current(), 3, 2, width-4, 1, colors.gray)
 
         local isSmallScreen = width <= 30
 
 
         if now_playing then
             if playing then
                 if isSmallScreen then
                     ui.button(term.current(), 4, 2, "S", "stop", colors.white, colors.red, colors.orange)
                 else
                     ui.button(term.current(), 4, 2, "Stop", "stop", colors.white, colors.red, colors.orange)
                 end
             else
                 ui.button(term.current(), 4, 2, "\16", "pause", colors.white, colors.green, colors.lightGray)
                 ui.button(term.current(), 8, 2, "R", "clear", colors.white, colors.red, colors.orange)
             end
             if not isSmallScreen then
                 ui.label(term.current(), 12, 2, fixString(now_playing.name, 20), colors.white)
                 ui.label(term.current(), 12+string.len(fixString(now_playing.name, 20))+1, 2, "| "..fixString(now_playing.artist, 14), colors.lightGray)
             else
                 ui.label(term.current(), 8, 2, fixString(now_playing.name, 16), colors.white)
             end
         else
             ui.label(term.current(), 4, 2, "Musiclo", colors.green)
             if not isSmallScreen then
                 ui.label(term.current(), 4+string.len("Musiclo")+2, 2, "| CC:T music player made easy", colors.lightGray)
             else
                 ui.label(term.current(), 4+string.len("Musiclo")+1, 2, "| CC:T player", colors.lightGray)
             end
         end
 
 
         local titleTruncateLimit = 41
         local artistTruncateLimit = 26
 
         if isSmallScreen then
             titleTruncateLimit = 19
             artistTruncateLimit = 15
         end
 
 
 
         if ui.page == 1 then
             ui.borderBox(term.current(), 3, 5, width-4, height-6, colors.gray)
 
             ui.button(term.current(), width-9, 4, "Search", "page.2", colors.white, colors.magenta, colors.purple)
             ui.keyAction(keys.enter, "page.2")
 
             ui.label(term.current(), 4, 4, "Queue", colors.white)
 
             ui.keyAction(keys.space, "pause")
 
             if looping then
                 ui.button(term.current(), 4, height-1, "Loop", "loop", colors.white, colors.magenta, colors.purple)
             else
                 ui.button(term.current(), 4, height-1, "Loop", "loop", colors.white, colors.gray, colors.lightGray)
             end
 
             if #queue > 0 then
                 ui.button(term.current(), 11, height-1, "Skip", "skip", colors.white, colors.gray, colors.lightGray)
                 if isSmallScreen then
                     ui.button(term.current(), 18, height-1, "Clr", "clear.q", colors.white, colors.red, colors.orange)
                 else
                 ui.button(term.current(), 18, height-1, "Clear queue", "clear.q", colors.white, colors.red, colors.orange)
                 end
             end
             ui.label(term.current(), 4, 6, "Now playing", colors.white)
 
             local scroller = ui.scrollBox(term.current(), 3, 5, width-4, height-6, 9000, true, true)
 
             y = 2
             if #queue > 0 then
                 for i, song in ipairs(queue) do
                     ui.box(scroller, 1, y, width-5, 5, colors.brown)
                     ui.label(scroller, 2, y+1, fixString(song.name, titleTruncateLimit), colors.white, colors.brown)
                     ui.label(scroller, 2, y+2, fixString(song.artist, artistTruncateLimit), colors.lightGray, colors.brown)
                     if isSmallScreen then y = y + 1 end
                     ui.button(scroller, width-20, y+2, "Play", "play."..i, colors.white, colors.magenta, colors.purple)
                     local songInQueue = false
-                    ui.button(scroller, width-20, y+2, "Play", "queue.play."..i, colors.white, colors.magenta, colors.purple)
+
-                    ui.button(scroller, width-13, y+2, "Remove", "queue.rem."..i, colors.white, colors.red, colors.orange)
+
                             songInQueue = true
                             break
                         end
                     end
                     if songInQueue then
                         ui.button(scroller, width-13, y+2, "Remove", "rem."..i, colors.white, colors.red, colors.orange)
                     else
                         ui.button(scroller, width-13, y+2, "Add", "add."..i, colors.white, colors.gray, colors.lightGray)
                     end
                     y = y + 6
                 end
             else
                 ui.centerLabel(scroller, 1, 5,width-4, "No songs in queue",  colors.lightGray)
                 ui.button(scroller, ((width-4-3)/2-(string.len("Add song")/2))+1, 7 ,"Add song", "page.2", colors.white, colors.gray, colors.lightGray)
             end
         elseif ui.page == 2 then
             ui.borderBox(term.current(), 3, 5, width-4, height-6, colors.gray)
 
             ui.button(term.current(), width-10, 4, "Go back","page.1", colors.white, colors.gray, colors.lightGray)
             ui.label(term.current(), 4, 4, "Search", colors.white)
 
             ui.label(term.current(), 4, 6, "Search on Youtube...", colors.lightGray)
 
             ui.horizontalLine(term.current(), 3, 8, width-4, colors.gray)
 
             local scroller = ui.scrollBox(term.current(), 3, 9, width-4, height-10, 9000, true, true)
 
             y = 2
             if search_results then
                 for i, song in ipairs(search_results) do
                     ui.box(scroller, 1, y, width-6, 5, colors.brown)
                     ui.label(scroller, 2, y+1, fixString(song.name, titleTruncateLimit), colors.white, colors.brown)
                     ui.label(scroller, 2, y+2, fixString(song.artist, artistTruncateLimit), colors.lightGray, colors.brown)
                     if isSmallScreen then y = y + 1 end
                     ui.button(scroller, width-21, y+2, "Play", "play."..i, colors.white, colors.magenta, colors.purple)
                     local songInQueue = false
                     for _, queuedSong in ipairs(queue) do
                         if queuedSong.id == song.id then
                             songInQueue = true
                             break
-            elseif search_error then
+
-                ui.centerLabel(scroller, 1, 3, width-4, search_error, colors.red)
+
                     if songInQueue then
                         ui.button(scroller, width-14, y+2, "Remove", "rem."..i, colors.white, colors.red, colors.orange)
                     else
                         ui.button(scroller, width-14, y+2, "Add", "add."..i, colors.white, colors.gray, colors.lightGray)
                     end
                     y = y + 6
                 end
             end
 
             ui.inputBox(term.current(), 4, 7, width-7, "search", colors.white, colors.gray)
         end
 
 
         local object, callback, text = ui.run()
         term.clear()
         term.setCursorPos(1, 1)
 
-            elseif callback:sub(1, 11) == "queue.play." then
+
-                local index = tonumber(callback:sub(12))
+
-                if index and queue[index] then
+
-                    playSong(queue[index])
+
                 ui.page = 2
-            elseif callback:sub(1, 10) == "queue.rem." then
+
-                local index = tonumber(callback:sub(11))
+
-                if index and queue[index] then
+
                 local index = tonumber(callback:sub(6))
                 if index and search_results[index] then
                     playSong(search_results[index])
                     ui.page = 1
                 end
             elseif callback:sub(1, 3) == "add" then
                 local index = tonumber(callback:sub(5))
                 if index and search_results[index] then
                     addToQueue(search_results[index])
                 end
             elseif callback:sub(1, 4) == "rem" then
                 local index = tonumber(callback:sub(6))
                 if index and search_results[index] then
                     removeFromQueue(index)
                 end
             elseif callback == "stop" then
                 stopPlayback()
             elseif callback == "pause" then
                 togglePlayPause()
             elseif callback == "loop" then
                 toggleLoop()
             elseif callback == "skip" then
                 skipSong()
             elseif callback == "clear.q" then
                 clearQueue()
             elseif callback == "clear" then
                 playing = false
                 now_playing = nil
                 playing_id = nil
             end
         elseif object == "keyAction" then
             if callback == "page.2" then
                 ui.page = 2
             elseif callback == "page.1" then
                 ui.page = 1
             end
         elseif object == "inputBox" and callback == "search" then
             if text ~= "" then
                 searchMusic(text)
                 term.clear()
                 local sx, sy = term.getSize()
                 term.setTextColor(colors.lightGray)
                 term.setCursorPos(sx/2 - #"Fetching..."/2, sy/2)
                 term.write("Fetching...")
                 ui.searchDone = false
                 repeat
                     sleep(0.1)
                 until ui.searchDone == true
                 ui.searchDone = false
             end
         elseif object == "rerender" then
             print("rerender")
         else
             term.clear()
             term.setCursorPos(1, 1)
             error("["..(object or "No object").."] "..(callback or "No callback").." "..(text or "No text").." not handled! Exiting",0)
         end
     end
 end
 
 local function audioLoop()
     while true do
         -- AUDIO
         sleep(0.1)
         if playing and now_playing then
             if playing_id ~= now_playing.id then
                 playing_id = now_playing.id
                 last_download_url = api_base_url .. "?v=2&id=" .. textutils.urlEncode(playing_id)
                 playing_status = 0
                 needs_next_chunk = 1
 
                 http.request({url = last_download_url, binary = true})
 				is_loading = true
 
             end
             if playing_status == 1 and needs_next_chunk == 3 then
                 needs_next_chunk = 1
                 for _, speaker in ipairs(speakers) do
                     while not speaker.playAudio(buffer) do
                         needs_next_chunk = 2
                         break
                     end
                 end
             end
             if playing_status == 1 and needs_next_chunk == 1 then
 
                 while true do
                     local chunk = player_handle.read(size)
                     if not chunk then
                         if looping then
                             playing_id = nil
                         else
                             if #queue > 0 then
                                 now_playing = queue[1]
                                 table.remove(queue, 1)
                                 playing_id = nil
                             else
                                 now_playing = nil
                                 playing = false
                                 playing_id = nil
                                 is_loading = false
                                 is_error = false
                             end
                         end
 
 
                         player_handle.close()
                         needs_next_chunk = 0
                         break
                     else
                         if start then
                             chunk, start = start .. chunk, nil
                             size = size + 4
                         end
 
                         buffer = decoder(chunk)
                         for _, speaker in ipairs(speakers) do
                             while not speaker.playAudio(buffer) do
                                 needs_next_chunk = 2
                                 break
                             end
                         end
                         if needs_next_chunk == 2 then
                             break
                         end
                     end
                 end
 
             end
         end
     end
 end
 
 -- Events
 local function eventLoop()
     while true do
         local event, param1, param2 = os.pullEvent()
 
         if event == "timer" then
             os.startTimer(1)
         end
 
         if event == "speaker_audio_empty" then
             if needs_next_chunk == 2 then
                 needs_next_chunk = 3
             end
         end
 
         if event == "http_success" then
             local url = param1
             local handle = param2
             if url == last_search_url then
                 search_results = textutils.unserialiseJSON(handle.readAll())
                 table.remove(search_results, 1)
                 ui.searchDone = true
             end
             if url == last_download_url then
                 player_handle = handle
                 start = handle.read(4)
                 size = 16 * 1024 - 4
                 if start == "RIFF" then
                     error("WAV not supported!")
                 end
                 playing_status = 1
                 decoder = require "cc.audio.dfpwm".make_decoder()
             end
         end
 
         if event == "http_failure" then
             local url = param1
 
             if url == last_search_url then
                 search_error = true
             end
-                search_error = "Search failed. Try again."
+
                 if #queue > 0 then
                     now_playing = queue[1]
                     table.remove(queue, 1)
                     playing_id = nil
                 else
                     now_playing = nil
                     playing = false
                     playing_id = nil
                 end
             end
         end
     end
 end
 
 parallel.waitForAny(audioLoop, eventLoop, redrawScreen)
 
 -- cleanup
 for  i=1, 16 do
     term.setPaletteColor(i, original_palette[i])
 end
 term.setCursorBlink(false)
 term.clear()
 term.setCursorPos(1, 1)