Support upper case PREFIX in Makefile

The GNU Make manual specifies lower-case "prefix" as the convention [1],
but in reality upper-case PREFIX seems just as common (if not more
common). We can make life a little easier for packagers by supporting

[1]: https://www.gnu.org/software/make/manual/html_node/Directory-Variables.html
Update yaml.v3 dependency

We don't even use YAML in ijq, but this suppresses a "Security Advisory"
on GitHub, so why not.
Support autocompletion of keys after a pipe (|) character
Correctly set dirty flag in WriteTo
Update README links to jqlang

Also adjust the color hash to lower-case, matching the id.
Initialize line counts with a large guess
Use synchronized output
Track dirty state of each pane so that it is only cleared when new data is written

This prevents the text view from clearing immediately when the filter
input changes. Instead, it only clears when output data from the jq
process is first written.
Use a cancellable context to kill processes when filter input changes
Use a condition variable and update doc in place

This works better than a channel since it doesn't implement FIFO
behavior. Whenever the filter input is changed, we claim the lock and
update `doc` with the new filter, set `pending` to true, and signal the
condition variable. The separate goroutine waits for `pending` to be set
to true and makes a copy of whatever the most recent document is before
running jq in a subprocess. This ensures that we always run jq with the
most recent filter.
Process new documents via a channel

Every time the filter input changes, send a new Document object over the
channel. A separate goroutine waits on the channel and runs the jq
process in a separate thread. This keeps the main UI thread completely

This is still not working quite right. When a new document is received
on the channel, we drop any other documents received until the current
jq process finishes. For long running processes, this means we miss
events and if a user types in a filter while a jq process is running
they will never see those updates apply.

What I need to do is use only the most recently received document on the
channel, but I can't figure out how to do this in Go. Channels act like
FIFOs so every item placed in the channel must be used, and there's no
way (that I can find) to have a single element channel that lets you
overwrite whatever is currently in there (like a mailbox).
Do not block event loop when running jq
Update modules
d501e3f0 — Mathew Polzin 2 months ago
chore: run go mod tidy

go version 1.21.7 wasn't happy building the project initially but it was
kind enough to suggest running `go mod tidy` after which things built
and ran beautifully.
Update dependencies

This updates tcell to v2.7.0 which includes a fix for terminfo aliases,
which fixes ijq when using e.g. TERM=ghostty.
Do not recalculate line count in scroll indicator update

Recalculating the line count can be expensive and does not need to be
recalculated everytime the scroll indicator is updated. In particular,
the input view has a fixed line count and so the line count can be
calculated when the input is first read and parsed.

The output view's line count must be updated every time the output text

We do not use tview's GetOriginalLineCount() function as it is quite
expensive (it iterates through all of the grapheme clusters in the text
and looks for line breaks). Instead, we use the basic method of "count
the number of newlines" in the text. I will wait to see if there is any
scenario for which this method is insufficient, but until then it's good
enough (and much faster).