single file; more tests

.busted

@@ -1,6 +1,5 @@
 return {
   _all = {
-    coverage = false,
     lpath = "lua/?.lua;lua/?/init.lua",
     lua = "nvim -u NONE -i NONE -l",
   },

.luacov

@@ -1,6 +1,6 @@
 return {
   include = {
-    'lua/u/',
+    'lua/u$',
   },
   tick = true,
 }

lua/u/.luarc.json

@@ -1,5 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/LuaLS/vscode-lua/master/setting/schema.json",
-  "diagnostics.globals": ["assert", "vim"],
-  "runtime.version": "LuaJIT"
-}

lua/u/extmark.lua

@@ -1,71 +0,0 @@
-local Pos = require 'u.pos'
-
----@class u.Extmark
----@field bufnr integer
----@field id integer
----@field nsid integer
-local Extmark = {}
-Extmark.__index = Extmark
-
---- @param bufnr integer
---- @param nsid integer
---- @param id integer
-function Extmark.new(bufnr, nsid, id)
-  return setmetatable({
-    bufnr = bufnr,
-    nsid = nsid,
-    id = id,
-  }, Extmark)
-end
-
---- @param range u.Range
---- @param nsid integer
-function Extmark.from_range(range, nsid)
-  local r = range:to_charwise()
-  local stop = r.stop or r.start
-  local end_row = stop.lnum - 1
-  local end_col = stop.col
-  if range.mode == 'V' then
-    end_row = end_row + 1
-    end_col = 0
-  end
-  local id = vim.api.nvim_buf_set_extmark(r.start.bufnr, nsid, r.start.lnum - 1, r.start.col - 1, {
-    right_gravity = false,
-    end_right_gravity = true,
-    end_row = end_row,
-    end_col = end_col,
-  })
-  return Extmark.new(r.start.bufnr, nsid, id)
-end
-
-function Extmark:range()
-  local Range = require 'u.range'
-
-  local raw_extmark =
-    vim.api.nvim_buf_get_extmark_by_id(self.bufnr, self.nsid, self.id, { details = true })
-  local start_row0, start_col0, details = unpack(raw_extmark)
-
-  --- @type u.Pos
-  local start = Pos.from00(self.bufnr, start_row0, start_col0)
-  --- @type u.Pos?
-  local stop = details
-    and details.end_row
-    and details.end_col
-    and Pos.from01(self.bufnr, details.end_row, details.end_col)
-
-  local n_buf_lines = vim.api.nvim_buf_line_count(self.bufnr)
-  if stop and stop.lnum > n_buf_lines then
-    stop.lnum = n_buf_lines
-    stop = stop:eol()
-  end
-  if stop and stop.col == 0 then
-    stop.col = 1
-    stop = stop:next(-1)
-  end
-
-  return Range.new(start, stop, 'v')
-end
-
-function Extmark:delete() vim.api.nvim_buf_del_extmark(self.bufnr, self.nsid, self.id) end
-
-return Extmark

lua/u/opkeymap.lua

@@ -1,39 +0,0 @@
-local Range = require 'u.range'
-
---- @type fun(range: u.Range): nil|(fun():any)
-local __U__OpKeymapOpFunc_rhs = nil
-
---- This is the global utility function used for operatorfunc in opkeymap
---- @param ty 'line'|'char'|'block'
--- selene: allow(unused_variable)
-function _G.__U__OpKeymapOpFunc(ty)
-  if __U__OpKeymapOpFunc_rhs ~= nil then
-    local range = Range.from_op_func(ty)
-    __U__OpKeymapOpFunc_rhs(range)
-  end
-end
-
---- Registers a function that operates on a text-object, triggered by the given prefix (lhs).
---- It works in the following way:
---- 1. An expression-map is set, so that whatever the callback returns is executed by Vim (in this case `g@`)
----    g@: tells vim to way for a motion, and then call operatorfunc.
---- 2. The operatorfunc is set to a lua function that computes the range being operated over, that
----    then calls the original passed callback with said range.
---- @param mode string|string[]
---- @param lhs string
---- @param rhs fun(range: u.Range): nil
---- @diagnostic disable-next-line: undefined-doc-name
---- @param opts? vim.keymap.set.Opts
-local function opkeymap(mode, lhs, rhs, opts)
-  vim.keymap.set(mode, lhs, function()
-    -- We don't need to wrap the operation in a repeat, because expr mappings are
-    -- repeated seamlessly by Vim anyway. In addition, the u.repeat:`.` mapping will
-    -- set IS_REPEATING to true, so that callbacks can check if they should used cached
-    -- values.
-    __U__OpKeymapOpFunc_rhs = rhs
-    vim.o.operatorfunc = 'v:lua.__U__OpKeymapOpFunc'
-    return 'g@'
-  end, vim.tbl_extend('force', opts or {}, { expr = true }))
-end
-
-return opkeymap

lua/u/pos.lua

@@ -1,303 +0,0 @@
-local MAX_COL = vim.v.maxcol
-
---- @param bufnr number
---- @param lnum number 1-based
-local function line_text(bufnr, lnum)
-  return vim.api.nvim_buf_get_lines(bufnr, lnum - 1, lnum, false)[1]
-end
-
---- @class u.Pos
---- @field bufnr integer buffer number
---- @field lnum integer 1-based line index
---- @field col integer 1-based column index
---- @field off number
-local Pos = {}
-Pos.__index = Pos
-Pos.MAX_COL = MAX_COL
-
-function Pos.__tostring(self)
-  if self.off ~= 0 then
-    return string.format('Pos(%d:%d){bufnr=%d, off=%d}', self.lnum, self.col, self.bufnr, self.off)
-  else
-    return string.format('Pos(%d:%d){bufnr=%d}', self.lnum, self.col, self.bufnr)
-  end
-end
-
---- @param bufnr? number
---- @param lnum number 1-based
---- @param col number 1-based
---- @param off? number
---- @return u.Pos
-function Pos.new(bufnr, lnum, col, off)
-  if bufnr == nil or bufnr == 0 then bufnr = vim.api.nvim_get_current_buf() end
-  if off == nil then off = 0 end
-  --- @type u.Pos
-  return setmetatable({
-    bufnr = bufnr,
-    lnum = lnum,
-    col = col,
-    off = off,
-  }, Pos)
-end
-
---- @param bufnr? number
---- @param lnum0 number 1-based
---- @param col0 number 1-based
---- @param off? number
-function Pos.from00(bufnr, lnum0, col0, off) return Pos.new(bufnr, lnum0 + 1, col0 + 1, off) end
-
---- @param bufnr? number
---- @param lnum0 number 1-based
---- @param col1 number 1-based
---- @param off? number
-function Pos.from01(bufnr, lnum0, col1, off) return Pos.new(bufnr, lnum0 + 1, col1, off) end
-
---- @param bufnr? number
---- @param lnum1 number 1-based
---- @param col0 number 1-based
---- @param off? number
-function Pos.from10(bufnr, lnum1, col0, off) return Pos.new(bufnr, lnum1, col0 + 1, off) end
-
-function Pos.invalid() return Pos.new(0, 0, 0, 0) end
-
-function Pos.__lt(a, b) return a.lnum < b.lnum or (a.lnum == b.lnum and a.col < b.col) end
-function Pos.__le(a, b) return a < b or a == b end
-function Pos.__eq(a, b)
-  return getmetatable(a) == Pos
-    and getmetatable(b) == Pos
-    and a.bufnr == b.bufnr
-    and a.lnum == b.lnum
-    and a.col == b.col
-end
-function Pos.__add(x, y)
-  if type(x) == 'number' then
-    x, y = y, x
-  end
-  if getmetatable(x) ~= Pos or type(y) ~= 'number' then return nil end
-  return x:next(y)
-end
-function Pos.__sub(x, y)
-  if type(x) == 'number' then
-    x, y = y, x
-  end
-  if getmetatable(x) ~= Pos or type(y) ~= 'number' then return nil end
-  return x:next(-y)
-end
-
---- @param bufnr number
---- @param lnum number
-function Pos.from_eol(bufnr, lnum)
-  if bufnr == nil or bufnr == 0 then bufnr = vim.api.nvim_get_current_buf() end
-  local pos = Pos.new(bufnr, lnum, 0)
-  pos.col = pos:line():len()
-  return pos
-end
-
---- @param name string
---- @return u.Pos
-function Pos.from_pos(name)
-  local p = vim.fn.getpos(name)
-  return Pos.new(p[1], p[2], p[3], p[4])
-end
-
-function Pos:is_invalid() return self.lnum == 0 and self.col == 0 and self.off == 0 end
-
-function Pos:clone() return Pos.new(self.bufnr, self.lnum, self.col, self.off) end
-
---- @return boolean
-function Pos:is_col_max() return self.col == MAX_COL end
-
---- Normalize the position to a real position (take into account vim.v.maxcol).
-function Pos:as_real()
-  local maxlen = #line_text(self.bufnr, self.lnum)
-  local col = self.col
-  if col > maxlen then
-    -- We could use utilities in this file to get the given line, but
-    -- since this is a low-level function, we are going to optimize and
-    -- use the API directly:
-    col = maxlen
-  end
-  return Pos.new(self.bufnr, self.lnum, col, self.off)
-end
-
-function Pos:as_vim() return { self.bufnr, self.lnum, self.col, self.off } end
-
-function Pos:eol() return Pos.from_eol(self.bufnr, self.lnum) end
-
---- @param pos string
-function Pos:save_to_pos(pos) vim.fn.setpos(pos, { self.bufnr, self.lnum, self.col, self.off }) end
-
---- @param winnr? integer
-function Pos:save_to_cursor(winnr)
-  vim.api.nvim_win_set_cursor(winnr or 0, { self.lnum, self.col - 1 })
-end
-
---- @param mark string
-function Pos:save_to_mark(mark)
-  local p = self:as_real()
-  vim.api.nvim_buf_set_mark(p.bufnr, mark, p.lnum, p.col - 1, {})
-end
-
---- @return string
-function Pos:char()
-  local line = line_text(self.bufnr, self.lnum)
-  if line == nil then return '' end
-  return line:sub(self.col, self.col)
-end
-
-function Pos:line() return line_text(self.bufnr, self.lnum) end
-
---- @param dir? -1|1
---- @param must? boolean
---- @return u.Pos|nil
-function Pos:next(dir, must)
-  if must == nil then must = false end
-
-  if dir == nil or dir == 1 then
-    -- Next:
-    local num_lines = vim.api.nvim_buf_line_count(self.bufnr)
-    local last_line = line_text(self.bufnr, num_lines)
-    if self.lnum == num_lines and self.col == #last_line then
-      if must then error 'error in Pos:next(): Pos:next() returned nil' end
-      return nil
-    end
-
-    local col = self.col + 1
-    local line = self.lnum
-    local line_max_col = #line_text(self.bufnr, self.lnum)
-    if col > line_max_col then
-      col = 1
-      line = line + 1
-    end
-    return Pos.new(self.bufnr, line, col, self.off)
-  else
-    -- Previous:
-    if self.col == 1 and self.lnum == 1 then
-      if must then error 'error in Pos:next(): Pos:next() returned nil' end
-      return nil
-    end
-
-    local col = self.col - 1
-    local line = self.lnum
-    local prev_line_max_col = #(line_text(self.bufnr, self.lnum - 1) or '')
-    if col < 1 then
-      col = math.max(prev_line_max_col, 1)
-      line = line - 1
-    end
-    return Pos.new(self.bufnr, line, col, self.off)
-  end
-end
-
---- @param dir? -1|1
-function Pos:must_next(dir)
-  local next = self:next(dir, true)
-  if next == nil then error 'unreachable' end
-  return next
-end
-
---- @param dir -1|1
---- @param predicate fun(p: u.Pos): boolean
---- @param test_current? boolean
-function Pos:next_while(dir, predicate, test_current)
-  if test_current and not predicate(self) then return end
-  local curr = self
-  while true do
-    local next = curr:next(dir)
-    if next == nil or not predicate(next) then break end
-    curr = next
-  end
-  return curr
-end
-
---- @param dir -1|1
---- @param predicate string|fun(p: u.Pos): boolean
-function Pos:find_next(dir, predicate)
-  if type(predicate) == 'string' then
-    local s = predicate
-    predicate = function(p) return s == p:char() end
-  end
-
-  --- @type u.Pos|nil
-  local curr = self
-  while curr ~= nil do
-    if predicate(curr) then return curr end
-    curr = curr:next(dir)
-  end
-  return curr
-end
-
---- Finds the matching bracket/paren for the current position.
---- @param max_chars? number|nil
---- @param invocations? u.Pos[]
---- @return u.Pos|nil
-function Pos:find_match(max_chars, invocations)
-  if invocations == nil then invocations = {} end
-  if vim.tbl_contains(invocations, function(p) return self == p end, { predicate = true }) then
-    return nil
-  end
-  table.insert(invocations, self)
-
-  local openers = { '{', '[', '(', '<' }
-  local closers = { '}', ']', ')', '>' }
-  local c = self:char()
-  local is_opener = vim.tbl_contains(openers, c)
-  local is_closer = vim.tbl_contains(closers, c)
-  if not is_opener and not is_closer then return nil end
-
-  local i, _ = vim
-    .iter(is_opener and openers or closers)
-    :enumerate()
-    :find(function(_, c2) return c == c2 end)
-  -- Store the character we will be looking for:
-  local c_match = (is_opener and closers or openers)[i]
-
-  --- @type u.Pos|nil
-  local cur = self
-  --- `adv` is a helper that moves the current position backward or forward,
-  --- depending on whether we are looking for an opener or a closer. It returns
-  --- nil if 1) the watch-dog `max_chars` falls bellow 0, or 2) if we have gone
-  --- beyond the beginning/end of the file.
-  --- @return u.Pos|nil
-  local function adv()
-    if cur == nil then return nil end
-
-    if max_chars ~= nil then
-      max_chars = max_chars - 1
-      if max_chars < 0 then return nil end
-    end
-
-    return cur:next(is_opener and 1 or -1)
-  end
-
-  -- scan until we find `c_match`:
-  cur = adv()
-  while cur ~= nil and cur:char() ~= c_match do
-    cur = adv()
-    if cur == nil then break end
-
-    local c2 = cur:char()
-    if c2 == c_match then break end
-
-    if vim.tbl_contains(openers, c2) or vim.tbl_contains(closers, c2) then
-      cur = cur:find_match(max_chars, invocations)
-      cur = adv() -- move past the match
-    end
-  end
-
-  return cur
-end
-
---- @param lines string|string[]
-function Pos:insert_before(lines)
-  if type(lines) == 'string' then lines = vim.split(lines, '\n') end
-  vim.api.nvim_buf_set_text(
-    self.bufnr,
-    self.lnum - 1,
-    self.col - 1,
-    self.lnum - 1,
-    self.col - 1,
-    lines
-  )
-end
-
-return Pos

lua/u/range.lua

@@ -1,658 +0,0 @@
-local Extmark = require 'u.extmark'
-local Pos = require 'u.pos'
-
-local ESC = vim.api.nvim_replace_termcodes('<Esc>', true, false, true)
-local NS = vim.api.nvim_create_namespace 'u.range'
-
---- @class u.Range
---- @field start u.Pos
---- @field stop u.Pos|nil
---- @field mode 'v'|'V'
-local Range = {}
-Range.__index = Range
-function Range.__tostring(self)
-  --- @param p u.Pos
-  local function posstr(p)
-    if p == nil then
-      return 'nil'
-    elseif p.off ~= 0 then
-      return string.format('Pos(%d:%d){off=%d}', p.lnum, p.col, p.off)
-    else
-      return string.format('Pos(%d:%d)', p.lnum, p.col)
-    end
-  end
-
-  local _1 = posstr(self.start)
-  local _2 = posstr(self.stop)
-  return string.format(
-    'Range{bufnr=%d, mode=%s, start=%s, stop=%s}',
-    self.start.bufnr,
-    self.mode,
-    _1,
-    _2
-  )
-end
-
---------------------------------------------------------------------------------
--- Range constructors:
---------------------------------------------------------------------------------
-
---- @param start u.Pos
---- @param stop u.Pos|nil
---- @param mode? 'v'|'V'
---- @return u.Range
-function Range.new(start, stop, mode)
-  if stop ~= nil and stop < start then
-    start, stop = stop, start
-  end
-
-  local r = { start = start, stop = stop, mode = mode or 'v' }
-
-  setmetatable(r, Range)
-  return r
-end
-
---- @param ranges (u.Range|nil)[]
-function Range.smallest(ranges)
-  --- @type u.Range[]
-  ranges = vim.iter(ranges):filter(function(r) return r ~= nil and not r:is_empty() end):totable()
-  if #ranges == 0 then return nil end
-
-  -- find smallest match
-  local smallest = ranges[1]
-  for _, r in ipairs(ranges) do
-    local start, stop = r.start, r.stop
-    if start > smallest.start and stop < smallest.stop then smallest = r end
-  end
-  return smallest
-end
-
---- @param lpos string
---- @param rpos string
---- @return u.Range
-function Range.from_marks(lpos, rpos)
-  local start = Pos.from_pos(lpos)
-  local stop = Pos.from_pos(rpos)
-
-  --- @type 'v'|'V'
-  local mode
-  if stop:is_col_max() then
-    mode = 'V'
-  else
-    mode = 'v'
-  end
-
-  return Range.new(start, stop, mode)
-end
-
---- @param bufnr? number
-function Range.from_buf_text(bufnr)
-  if bufnr == nil or bufnr == 0 then bufnr = vim.api.nvim_get_current_buf() end
-  local num_lines = vim.api.nvim_buf_line_count(bufnr)
-
-  local start = Pos.new(bufnr, 1, 1)
-  local stop = Pos.new(bufnr, num_lines, Pos.MAX_COL)
-  return Range.new(start, stop, 'V')
-end
-
---- @param bufnr? number
---- @param line number 1-based line index
-function Range.from_line(bufnr, line) return Range.from_lines(bufnr, line, line) end
-
---- @param bufnr? number
---- @param start_line number based line index
---- @param stop_line number based line index
-function Range.from_lines(bufnr, start_line, stop_line)
-  if bufnr == nil or bufnr == 0 then bufnr = vim.api.nvim_get_current_buf() end
-  if stop_line < 0 then
-    local num_lines = vim.api.nvim_buf_line_count(bufnr)
-    stop_line = num_lines + stop_line + 1
-  end
-  return Range.new(Pos.new(bufnr, start_line, 1), Pos.new(bufnr, stop_line, Pos.MAX_COL), 'V')
-end
-
---- @param motion string
---- @param opts? { bufnr?: number, contains_cursor?: boolean, pos?: u.Pos, user_defined?: boolean }
---- @return u.Range|nil
-function Range.from_motion(motion, opts)
-  -- Options handling:
-  opts = opts or {}
-  if opts.bufnr == nil or opts.bufnr == 0 then opts.bufnr = vim.api.nvim_get_current_buf() end
-  if opts.contains_cursor == nil then opts.contains_cursor = false end
-  if opts.user_defined == nil then opts.user_defined = false end
-
-  -- Extract some information from the motion:
-  --- @type 'a'|'i', string
-  local scope, motion_rest = motion:sub(1, 1), motion:sub(2)
-  local is_txtobj = scope == 'a' or scope == 'i'
-  local is_quote_txtobj = is_txtobj and vim.tbl_contains({ "'", '"', '`' }, motion_rest)
-
-  -- Capture the original state of the buffer for restoration later.
-  local original_state = {
-    winview = vim.fn.winsaveview(),
-    regquote = vim.fn.getreg '"',
-    cursor = vim.fn.getpos '.',
-    pos_lbrack = vim.fn.getpos "'[",
-    pos_rbrack = vim.fn.getpos "']",
-    opfunc = vim.go.operatorfunc,
-    prev_captured_range = _G.Range__from_motion_opfunc_captured_range,
-    prev_mode = vim.fn.mode(),
-    vinf = Range.from_vtext(),
-  }
-  --- @type u.Range|nil
-  _G.Range__from_motion_opfunc_captured_range = nil
-
-  vim.api.nvim_buf_call(opts.bufnr, function()
-    if opts.pos ~= nil then opts.pos:save_to_pos '.' end
-
-    _G.Range__from_motion_opfunc = function(ty)
-      _G.Range__from_motion_opfunc_captured_range = Range.from_op_func(ty)
-    end
-    local old_eventignore = vim.o.eventignore
-    vim.o.eventignore = 'all'
-    vim.go.operatorfunc = 'v:lua.Range__from_motion_opfunc'
-    vim.cmd {
-      cmd = 'normal',
-      bang = not opts.user_defined,
-      args = { ESC .. 'g@' .. motion },
-      mods = { silent = true },
-    }
-    vim.o.eventignore = old_eventignore
-  end)
-  local captured_range = _G.Range__from_motion_opfunc_captured_range
-
-  -- Restore original state:
-  vim.fn.winrestview(original_state.winview)
-  vim.fn.setreg('"', original_state.regquote)
-  vim.fn.setpos('.', original_state.cursor)
-  vim.fn.setpos("'[", original_state.pos_lbrack)
-  vim.fn.setpos("']", original_state.pos_rbrack)
-  if original_state.prev_mode ~= 'n' then original_state.vinf:set_visual_selection() end
-  vim.go.operatorfunc = original_state.opfunc
-  _G.Range__from_motion_opfunc_captured_range = original_state.prev_captured_range
-
-  if not captured_range then return nil end
-
-  -- Fixup the bounds:
-  if
-    -- I have no idea why, but when yanking `i"`, the stop-mark is
-    -- placed on the ending quote. For other text-objects, the stop-
-    -- mark is placed before the closing character.
-    (is_quote_txtobj and scope == 'i' and captured_range.stop:char() == motion_rest)
-    -- *Sigh*, this also sometimes happens for `it` as well.
-    or (motion == 'it' and captured_range.stop:char() == '<')
-  then
-    captured_range.stop = captured_range.stop:next(-1) or captured_range.stop
-  end
-  if is_quote_txtobj and scope == 'a' then
-    captured_range.start = captured_range.start:find_next(1, motion_rest) or captured_range.start
-    captured_range.stop = captured_range.stop:find_next(-1, motion_rest) or captured_range.stop
-  end
-
-  if
-    opts.contains_cursor and not captured_range:contains(Pos.new(unpack(original_state.cursor)))
-  then
-    return nil
-  end
-
-  return captured_range
-end
-
---- @param opts? { contains_cursor?: boolean }
-function Range.from_tsquery_caps(bufnr, query, opts)
-  opts = opts or { contains_cursor = true }
-
-  local ranges = Range.from_buf_text(bufnr):tsquery(query)
-  if not ranges then return end
-  if not opts.contains_cursor then return ranges end
-
-  local cursor = Pos.from_pos '.'
-  return vim.tbl_map(function(cap_ranges)
-    return vim
-      .iter(cap_ranges)
-      :filter(
-        --- @param r u.Range
-        function(r) return r:contains(cursor) end
-      )
-      :totable()
-  end, ranges)
-end
-
---- Get range information from the currently selected visual text.
---- Note: from within a command mapping or an opfunc, use other specialized
---- utilities, such as:
---- * Range.from_cmd_args
---- * Range.from_op_func
-function Range.from_vtext()
-  local r = Range.from_marks('v', '.')
-  if vim.fn.mode() == 'V' then r = r:to_linewise() end
-  return r
-end
-
---- Get range information from the current text range being operated on
---- as defined by an operator-pending function. Infers line-wise vs. char-wise
---- based on the type, as given by the operator-pending function.
---- @param type 'line'|'char'|'block'
-function Range.from_op_func(type)
-  if type == 'block' then error 'block motions not supported' end
-
-  local range = Range.from_marks("'[", "']")
-  if type == 'line' then range = range:to_linewise() end
-  return range
-end
-
---- Get range information from command arguments.
---- @param args unknown
---- @return u.Range|nil
-function Range.from_cmd_args(args)
-  if args.range == 0 then return nil end
-
-  local bufnr = vim.api.nvim_get_current_buf()
-  if args.range == 1 then
-    return Range.new(Pos.new(bufnr, args.line1, 1), Pos.new(bufnr, args.line1, Pos.MAX_COL), 'V')
-  end
-
-  local is_visual = vim.fn.histget('cmd', -1):sub(1, 5) == [['<,'>]]
-  --- @type 'v'|'V'
-  local mode = is_visual and vim.fn.visualmode() or 'V'
-
-  if is_visual then
-    return Range.new(Pos.from_pos "'<", Pos.from_pos "'>", mode)
-  else
-    return Range.new(Pos.new(bufnr, args.line1, 1), Pos.new(bufnr, args.line2, Pos.MAX_COL), mode)
-  end
-end
-
-function Range.find_nearest_brackets()
-  return Range.smallest {
-    Range.from_motion('a<', { contains_cursor = true }),
-    Range.from_motion('a[', { contains_cursor = true }),
-    Range.from_motion('a(', { contains_cursor = true }),
-    Range.from_motion('a{', { contains_cursor = true }),
-  }
-end
-
-function Range.find_nearest_quotes()
-  return Range.smallest {
-    Range.from_motion([[a']], { contains_cursor = true }),
-    Range.from_motion([[a"]], { contains_cursor = true }),
-    Range.from_motion([[a`]], { contains_cursor = true }),
-  }
-end
-
---------------------------------------------------------------------------------
--- Structural utilities:
---------------------------------------------------------------------------------
-
-function Range:clone()
-  return Range.new(self.start:clone(), self.stop ~= nil and self.stop:clone() or nil, self.mode)
-end
-
-function Range:is_empty() return self.stop == nil end
-
-function Range:to_linewise()
-  local r = self:clone()
-
-  r.mode = 'V'
-  r.start.col = 1
-  if r.stop ~= nil then r.stop.col = Pos.MAX_COL end
-
-  return r
-end
-
-function Range:to_charwise()
-  local r = self:clone()
-  r.mode = 'v'
-  if r.stop:is_col_max() then r.stop = r.stop:as_real() end
-  return r
-end
-
---- @param x u.Pos | u.Range
-function Range:contains(x)
-  if getmetatable(x) == Pos then
-    return not self:is_empty() and x >= self.start and x <= self.stop
-  elseif getmetatable(x) == Range then
-    return self:contains(x.start) and self:contains(x.stop)
-  end
-  return false
-end
-
---- @param other u.Range
---- @return u.Range|nil, u.Range|nil
-function Range:difference(other)
-  local outer, inner = self, other
-  if not outer:contains(inner) then
-    outer, inner = inner, outer
-  end
-  if not outer:contains(inner) then return nil, nil end
-
-  local left
-  if outer.start ~= inner.start then
-    local stop = inner.start:clone() - 1
-    left = Range.new(outer.start, stop)
-  else
-    left = Range.new(outer.start) -- empty range
-  end
-
-  local right
-  if inner.stop ~= outer.stop then
-    local start = inner.stop:clone() + 1
-    right = Range.new(start, outer.stop)
-  else
-    right = Range.new(inner.stop) -- empty range
-  end
-
-  return left, right
-end
-
---- @param left string
---- @param right string
-function Range:save_to_pos(left, right)
-  self.start:save_to_pos(left);
-  (self:is_empty() and self.start or self.stop):save_to_pos(right)
-end
-
---- @param left string
---- @param right string
-function Range:save_to_marks(left, right)
-  self.start:save_to_mark(left);
-  (self:is_empty() and self.start or self.stop):save_to_mark(right)
-end
-
-function Range:save_to_extmark() return Extmark.from_range(self, NS) end
-
-function Range:set_visual_selection()
-  if self:is_empty() then return end
-  if vim.api.nvim_get_current_buf() ~= self.start.bufnr then
-    error 'Range:set_visual_selection() called on a buffer other than the current buffer'
-  end
-
-  local curr_mode = vim.fn.mode()
-  if curr_mode ~= self.mode then vim.cmd.normal { args = { self.mode }, bang = true } end
-
-  self.start:save_to_pos '.'
-  vim.cmd.normal { args = { 'o' }, bang = true }
-  self.stop:save_to_pos '.'
-end
-
---------------------------------------------------------------------------------
--- Text access/manipulation utilities:
---------------------------------------------------------------------------------
-
---- @param query string
-function Range:tsquery(query)
-  local bufnr = self.start.bufnr
-
-  local lang = vim.treesitter.language.get_lang(vim.bo[bufnr].filetype)
-  if lang == nil then return end
-  local parser = vim.treesitter.get_parser(bufnr, lang)
-  if parser == nil then return end
-  local tree = parser:parse()[1]
-  if tree == nil then return end
-
-  local root = tree:root()
-  local q = vim.treesitter.query.parse(lang, query)
-  --- @type table<string, u.Range[]>
-  local ranges = {}
-  for id, match, _meta in
-    q:iter_captures(root, bufnr, self.start.lnum - 1, (self.stop or self.start).lnum)
-  do
-    local start_row0, start_col0, stop_row0, stop_col0 = match:range()
-    local range = Range.new(
-      Pos.new(bufnr, start_row0 + 1, start_col0 + 1),
-      Pos.new(bufnr, stop_row0 + 1, stop_col0),
-      'v'
-    )
-    if range.stop.lnum > vim.api.nvim_buf_line_count(bufnr) then
-      range.stop = range.stop:must_next(-1)
-    end
-
-    local capture_name = q.captures[id]
-    if not ranges[capture_name] then ranges[capture_name] = {} end
-    if self:contains(range) then table.insert(ranges[capture_name], range) end
-  end
-
-  return ranges
-end
-
-function Range:length()
-  if self:is_empty() then return 0 end
-
-  local line_positions =
-    vim.fn.getregionpos(self.start:as_real():as_vim(), self.stop:as_real():as_vim(), { type = 'v' })
-
-  local len = 0
-  for linenr, line in ipairs(line_positions) do
-    if linenr > 1 then len = len + 1 end -- each newline is counted as a char
-    local line_start_col = line[1][3]
-    local line_stop_col = line[2][3]
-    local line_len = line_stop_col - line_start_col + 1
-    len = len + line_len
-  end
-  return len
-end
-
-function Range:line_count()
-  if self:is_empty() then return 0 end
-  return self.stop.lnum - self.start.lnum + 1
-end
-
-function Range:trim_start()
-  if self:is_empty() then return end
-
-  local r = self:clone()
-  while r.start:char():match '%s' do
-    local next = r.start:next(1)
-    if next == nil then break end
-    r.start = next
-  end
-  return r
-end
-
-function Range:trim_stop()
-  if self:is_empty() then return end
-
-  local r = self:clone()
-  while r.stop:char():match '%s' do
-    local next = r.stop:next(-1)
-    if next == nil then break end
-    r.stop = next
-  end
-  return r
-end
-
---- @param i number 1-based
---- @param j? number 1-based
-function Range:sub(i, j)
-  local line_positions =
-    vim.fn.getregionpos(self.start:as_real():as_vim(), self.stop:as_real():as_vim(), { type = 'v' })
-
-  --- @param idx number 1-based
-  --- @return u.Pos|nil
-  local function get_pos(idx)
-    if idx < 0 then return get_pos(self:length() + idx + 1) end
-
-    -- find the position of the first line that contains the i-th character:
-    local curr_len = 0
-    for linenr, line in ipairs(line_positions) do
-      if linenr > 1 then curr_len = curr_len + 1 end -- each newline is counted as a char
-      local line_start_col = line[1][3]
-      local line_stop_col = line[2][3]
-      local line_len = line_stop_col - line_start_col + 1
-
-      if curr_len + line_len >= idx then
-        return Pos.new(self.start.bufnr, line[1][2], line_start_col + (idx - curr_len) - 1)
-      end
-      curr_len = curr_len + line_len
-    end
-  end
-
-  local start = get_pos(i)
-  if not start then
-    -- start is inalid, so return an empty range:
-    return Range.new(self.start, nil, self.mode)
-  end
-
-  local stop
-  if j then stop = get_pos(j) end
-  if not stop then
-    -- stop is inalid, so return an empty range:
-    return Range.new(start, nil, self.mode)
-  end
-  return Range.new(start, stop, 'v')
-end
-
---- @return string[]
-function Range:lines()
-  if self:is_empty() then return {} end
-  return vim.fn.getregion(self.start:as_vim(), self.stop:as_vim(), { type = self.mode })
-end
-
---- @return string
-function Range:text() return vim.fn.join(self:lines(), '\n') end
-
---- @param l number
--- luacheck: ignore
---- @return { line: string, idx0: { start: number, stop: number }, lnum: number, range: fun():u.Range, text: fun():string }|nil
-function Range:line(l)
-  if l < 0 then l = self:line_count() + l + 1 end
-  if l > self:line_count() then return end
-
-  local line_indices =
-    vim.fn.getregionpos(self.start:as_vim(), self.stop:as_vim(), { type = self.mode })
-  local line_bounds = line_indices[l]
-
-  local start = Pos.new(unpack(line_bounds[1]))
-  local stop = Pos.new(unpack(line_bounds[2]))
-  return Range.new(start, stop)
-end
-
---- @param replacement nil|string|string[]
-function Range:replace(replacement)
-  if replacement == nil then replacement = {} end
-  if type(replacement) == 'string' then replacement = vim.fn.split(replacement, '\n') end
-
-  local bufnr = self.start.bufnr
-  local replace_type = (self:is_empty() and 'insert') or (self.mode == 'v' and 'region') or 'lines'
-
-  local function update_stop_non_linewise()
-    local new_last_line_num = self.start.lnum + #replacement - 1
-    local new_last_col = #(replacement[#replacement] or '')
-    if new_last_line_num == self.start.lnum then
-      new_last_col = new_last_col + self.start.col - 1
-    end
-    self.stop = Pos.new(bufnr, new_last_line_num, new_last_col)
-  end
-  local function update_stop_linewise()
-    if #replacement == 0 then
-      self.stop = nil
-    else
-      local new_last_line_num = self.start.lnum - 1 + #replacement - 1
-      self.stop = Pos.new(bufnr, new_last_line_num + 1, Pos.MAX_COL, self.stop.off)
-    end
-    self.mode = 'v'
-  end
-
-  if replace_type == 'insert' then
-    -- To insert text at a given `(row, column)` location, use `start_row =
-    -- end_row = row` and `start_col = end_col = col`.
-    vim.api.nvim_buf_set_text(
-      bufnr,
-      self.start.lnum - 1,
-      self.start.col - 1,
-      self.start.lnum - 1,
-      self.start.col - 1,
-      replacement
-    )
-    update_stop_non_linewise()
-  elseif replace_type == 'region' then
-    -- Fixup the bounds:
-    local max_col = #self.stop:line()
-
-    -- Indexing is zero-based. Row indices are end-inclusive, and column indices
-    -- are end-exclusive.
-    vim.api.nvim_buf_set_text(
-      bufnr,
-      self.start.lnum - 1,
-      self.start.col - 1,
-      self.stop.lnum - 1,
-      math.min(self.stop.col, max_col),
-      replacement
-    )
-    update_stop_non_linewise()
-  elseif replace_type == 'lines' then
-    -- Indexing is zero-based, end-exclusive.
-    vim.api.nvim_buf_set_lines(bufnr, self.start.lnum - 1, self.stop.lnum, true, replacement)
-    update_stop_linewise()
-  else
-    error 'unreachable'
-  end
-end
-
---- @param amount number
-function Range:shrink(amount)
-  local start = self.start
-  local stop = self.stop
-  if stop == nil then return self:clone() end
-
-  for _ = 1, amount do
-    local next_start = start:next(1)
-    local next_stop = stop:next(-1)
-    if next_start == nil or next_stop == nil then return end
-    start = next_start
-    stop = next_stop
-    if next_start > next_stop then break end
-  end
-  if start > stop then stop = nil end
-  return Range.new(start, stop, self.mode)
-end
-
---- @param amount number
-function Range:must_shrink(amount)
-  local shrunk = self:shrink(amount)
-  if shrunk == nil or shrunk:is_empty() then
-    error 'error in Range:must_shrink: Range:shrink() returned nil'
-  end
-  return shrunk
-end
-
---- @param group string
---- @param opts? { timeout?: number, priority?: number, on_macro?: boolean }
-function Range:highlight(group, opts)
-  if self:is_empty() then return end
-
-  opts = opts or { on_macro = false }
-  if opts.on_macro == nil then opts.on_macro = false end
-
-  local in_macro = vim.fn.reg_executing() ~= ''
-  if not opts.on_macro and in_macro then return { clear = function() end } end
-
-  local ns = vim.api.nvim_create_namespace ''
-
-  local winview = vim.fn.winsaveview()
-  vim.hl.range(
-    self.start.bufnr,
-    ns,
-    group,
-    { self.start.lnum - 1, self.start.col - 1 },
-    { self.stop.lnum - 1, self.stop.col - 1 },
-    {
-      inclusive = true,
-      priority = opts.priority,
-      timeout = opts.timeout,
-      regtype = self.mode,
-    }
-  )
-  if not in_macro then vim.fn.winrestview(winview) end
-  vim.cmd.redraw()
-
-  return {
-    ns = ns,
-    clear = function()
-      vim.api.nvim_buf_clear_namespace(self.start.bufnr, ns, self.start.lnum - 1, self.stop.lnum)
-      vim.cmd.redraw()
-    end,
-  }
-end
-
-return Range

lua/u/repeat.lua

@@ -1,40 +0,0 @@
-local M = {}
-
-local IS_REPEATING = false
---- @type function|nil
-local REPEAT_ACTION = nil
-
-local function is_repeatable_last_mutator() return vim.b.changedtick <= (vim.b.my_changedtick or 0) end
-
---- @param f fun()
-function M.run_repeatable(f)
-  REPEAT_ACTION = f
-  ---@diagnostic disable-next-line: need-check-nil
-  REPEAT_ACTION()
-  vim.b.my_changedtick = vim.b.changedtick
-end
-
-function M.is_repeating() return IS_REPEATING end
-
-function M.setup()
-  vim.keymap.set('n', '.', function()
-    IS_REPEATING = true
-    for _ = 1, vim.v.count1 do
-      if is_repeatable_last_mutator() and type(REPEAT_ACTION) == 'function' then
-        M.run_repeatable(REPEAT_ACTION)
-      else
-        vim.cmd { cmd = 'normal', args = { '.' }, bang = true }
-      end
-    end
-    IS_REPEATING = false
-  end)
-  vim.keymap.set('n', 'u', function()
-    local was_repeatable_last_mutator = is_repeatable_last_mutator()
-    for _ = 1, vim.v.count1 do
-      vim.cmd { cmd = 'normal', args = { 'u' }, bang = true }
-    end
-    if was_repeatable_last_mutator then vim.b.my_changedtick = vim.b.changedtick end
-  end)
-end
-
-return M

lua/u/txtobj.lua

@@ -1,45 +0,0 @@
-local Range = require 'u.range'
-
-local M = {}
-
-local ESC = vim.api.nvim_replace_termcodes('<Esc>', true, false, true)
-
---- @param key_seq string
---- @param fn fun(key_seq: string):u.Range|nil
---- @param opts? { buffer: number|nil }
-function M.define(key_seq, fn, opts)
-  if opts ~= nil and opts.buffer == 0 then opts.buffer = vim.api.nvim_get_current_buf() end
-
-  local function handle_visual()
-    local range = fn(key_seq)
-    if range == nil or range:is_empty() then
-      vim.cmd.normal(ESC)
-      return
-    end
-    range:set_visual_selection()
-  end
-  vim.keymap.set({ 'x' }, key_seq, handle_visual, opts and { buffer = opts.buffer } or nil)
-
-  local function handle_normal()
-    local range = fn(key_seq)
-    if range == nil then return end
-
-    if not range:is_empty() then
-      range:set_visual_selection()
-    else
-      local original_eventignore = vim.go.eventignore
-      vim.go.eventignore = 'all'
-
-      -- insert a single space, so we can select it:
-      local p = range.start
-      p:insert_before ' '
-      vim.go.eventignore = original_eventignore
-
-      -- select the space:
-      Range.new(p, p, 'v'):set_visual_selection()
-    end
-  end
-  vim.keymap.set({ 'o' }, key_seq, handle_normal, opts and { buffer = opts.buffer } or nil)
-end
-
-return M

lua/u/utils.lua

@@ -1,126 +0,0 @@
-local M = {}
-
---
--- Types
---
-
---- @class u.utils.QfItem
---- @field col number
---- @field filename string
---- @field kind string
---- @field lnum number
---- @field text string
-
---- @class u.utils.RawCmdArgs
---- @field args string
---- @field bang boolean
---- @field count number
---- @field fargs string[]
---- @field line1 number
---- @field line2 number
---- @field mods string
---- @field name string
---- @field range 0|1|2
---- @field reg string
---- @field smods any
-
---- @class u.utils.CmdArgs: u.utils.RawCmdArgs
---- @field info u.Range|nil
-
---- @class u.utils.UcmdArgs
---- @field nargs? 0|1|'*'|'?'|'+'
---- @field range? boolean|'%'|number
---- @field count? boolean|number
---- @field addr? string
---- @field completion? string
---- @field force? boolean
---- @field preview? fun(opts: u.utils.UcmdArgs, ns: integer, buf: integer):0|1|2
-
---- Creates a user command with enhanced argument processing.
---- Automatically computes range information and attaches it as `args.info`.
----
---- @param name string The command name (without the leading colon)
---- @param cmd string | fun(args: u.utils.CmdArgs): any Command implementation
---- @param opts? u.utils.UcmdArgs Command options (nargs, range, etc.)
----
---- @usage
---- ```lua
---- -- Create a command that works with visual selections:
---- utils.ucmd('MyCmd', function(args)
----   -- Print the visually selected text:
----   vim.print(args.info:text())
----   -- Or get the selection as an array of lines:
----   vim.print(args.info:lines())
---- end, { nargs = '*', range = true })
----
---- -- Create a command that processes the current line:
---- utils.ucmd('ProcessLine', function(args)
----   local line_text = args.info:text()
----   -- Process the line...
---- end, { range = '%' })
----
---- -- Create a command with arguments:
---- utils.ucmd('SearchReplace', function(args)
----   local pattern, replacement = args.fargs[1], args.fargs[2]
----   local text = args.info:text()
----   -- Perform search and replace...
---- end, { nargs = 2, range = true })
---- ```
--- luacheck: ignore
-function M.ucmd(name, cmd, opts)
-  local Range = require 'u.range'
-
-  opts = opts or {}
-  local cmd2 = cmd
-  if type(cmd) == 'function' then
-    cmd2 = function(args)
-      args.info = Range.from_cmd_args(args)
-      return cmd(args)
-    end
-  end
-  vim.api.nvim_create_user_command(name, cmd2, opts or {} --[[@as any]])
-end
-
---- Creates command arguments for delegating from one command to another.
---- Preserves all relevant context (range, modifiers, bang, etc.) when
---- implementing a derived command in terms of a base command.
----
---- @param current_args vim.api.keyset.create_user_command.command_args|u.utils.RawCmdArgs The arguments from the current command
---- @return vim.api.keyset.cmd Arguments suitable for vim.cmd() calls
----
---- @usage
---- ```lua
---- -- Implement :MyEdit in terms of :edit, preserving all context:
---- utils.ucmd('MyEdit', function(args)
----   local delegated_args = utils.create_delegated_cmd_args(args)
----   -- Add custom logic here...
----   vim.cmd.edit(delegated_args)
---- end, { nargs = '*', range = true, bang = true })
----
---- -- Implement :MySubstitute that delegates to :substitute:
---- utils.ucmd('MySubstitute', function(args)
----   -- Pre-process arguments
----   local pattern = preprocess_pattern(args.fargs[1])
----
----   local delegated_args = utils.create_delegated_cmd_args(args)
----   delegated_args.args = { pattern, args.fargs[2] }
----
----   vim.cmd.substitute(delegated_args)
---- end, { nargs = 2, range = true, bang = true })
---- ```
-function M.create_delegated_cmd_args(current_args)
-  --- @type vim.api.keyset.cmd
-  local args = {
-    range = current_args.range == 1 and { current_args.line1 }
-      or current_args.range == 2 and { current_args.line1, current_args.line2 }
-      or nil,
-    count = (current_args.count ~= -1 and current_args.range == 0) and current_args.count or nil,
-    reg = current_args.reg ~= '' and current_args.reg or nil,
-    bang = current_args.bang or nil,
-    args = #current_args.fargs > 0 and current_args.fargs or nil,
-    mods = current_args.smods,
-  }
-  return args
-end
-
-return M

mise.toml

@@ -79,12 +79,12 @@ arg "<version>" help="The version of Neovim to test with"
 run = 'mise test:version:no-prep $usage_version'
 
 [tasks."test"]
-run = 'mise test:version 0.11.5'
+run = 'mise test:version 0.12.0'
 
 [tasks."test:all"]
 depends = ["test:prepare"]
 run = '''
-VERSIONS="0.11.5 nightly"
+VERSIONS="0.11.5 0.12.0 nightly"
 for v in $VERSIONS; do
   mise test:version:no-prep $v
 done

spec/pos_spec.lua

@@ -1,70 +0,0 @@
---- @diagnostic disable: undefined-field, need-check-nil
-local Pos = require 'u.pos'
-local withbuf = loadfile './spec/withbuf.lua'()
-
-describe('Pos', function()
-  it('get a char from a given position', function()
-    withbuf({ 'asdf', 'bleh', 'a', '', 'goo' }, function()
-      assert.are.same('a', Pos.new(nil, 1, 1):char())
-      assert.are.same('d', Pos.new(nil, 1, 3):char())
-      assert.are.same('f', Pos.new(nil, 1, 4):char())
-      assert.are.same('a', Pos.new(nil, 3, 1):char())
-      assert.are.same('', Pos.new(nil, 4, 1):char())
-      assert.are.same('o', Pos.new(nil, 5, 3):char())
-    end)
-  end)
-
-  it('comparison operators', function()
-    local a = Pos.new(0, 0, 0, 0)
-    local b = Pos.new(0, 1, 0, 0)
-    assert.are.same(a == a, true)
-    assert.are.same(a < b, true)
-  end)
-
-  it('get the next position', function()
-    withbuf({ 'asdf', 'bleh', 'a', '', 'goo' }, function()
-      -- line 1: a => s
-      assert.are.same(Pos.new(nil, 1, 2), Pos.new(nil, 1, 1):next())
-      -- line 1: d => f
-      assert.are.same(Pos.new(nil, 1, 4), Pos.new(nil, 1, 3):next())
-      -- line 1 => 2
-      assert.are.same(Pos.new(nil, 2, 1), Pos.new(nil, 1, 4):next())
-      -- line 3 => 4
-      assert.are.same(Pos.new(nil, 4, 1), Pos.new(nil, 3, 1):next())
-      -- line 4 => 5
-      assert.are.same(Pos.new(nil, 5, 1), Pos.new(nil, 4, 1):next())
-      -- end returns nil
-      assert.are.same(nil, Pos.new(nil, 5, 3):next())
-    end)
-  end)
-
-  it('get the previous position', function()
-    withbuf({ 'asdf', 'bleh', 'a', '', 'goo' }, function()
-      -- line 1: s => a
-      assert.are.same(Pos.new(nil, 1, 1), Pos.new(nil, 1, 2):next(-1))
-      -- line 1: f => d
-      assert.are.same(Pos.new(nil, 1, 3), Pos.new(nil, 1, 4):next(-1))
-      -- line 2 => 1
-      assert.are.same(Pos.new(nil, 1, 4), Pos.new(nil, 2, 1):next(-1))
-      -- line 4 => 3
-      assert.are.same(Pos.new(nil, 3, 1), Pos.new(nil, 4, 1):next(-1))
-      -- line 5 => 4
-      assert.are.same(Pos.new(nil, 4, 1), Pos.new(nil, 5, 1):next(-1))
-      -- beginning returns nil
-      assert.are.same(nil, Pos.new(nil, 1, 1):next(-1))
-    end)
-  end)
-
-  it('find matching brackets', function()
-    withbuf({ 'asdf ({} def <[{}]>) ;lkj' }, function()
-      -- outer parens are matched:
-      assert.are.same(Pos.new(nil, 1, 20), Pos.new(nil, 1, 6):find_match())
-      -- outer parens are matched (backward):
-      assert.are.same(Pos.new(nil, 1, 6), Pos.new(nil, 1, 20):find_match())
-      -- no potential match returns nil
-      assert.are.same(nil, Pos.new(nil, 1, 1):find_match())
-      -- watchdog expires before an otherwise valid match is found:
-      assert.are.same(nil, Pos.new(nil, 1, 6):find_match(2))
-    end)
-  end)
-end)

spec/u_spec.lua

@@ -1,7 +1,84 @@
+require 'luacov'
+
 --- @diagnostic disable: undefined-field, need-check-nil
-local Pos = require 'u.pos'
+local Pos = require 'u'.Pos
-local Range = require 'u.range'
+local Range = require 'u'.Range
-local withbuf = loadfile './spec/withbuf.lua'()
+local function withbuf(lines, f)
+  vim.go.swapfile = false
+
+  vim.cmd.new()
+  vim.api.nvim_buf_set_lines(0, 0, -1, false, lines)
+  local ok, result = pcall(f)
+  vim.cmd.bdelete { bang = true }
+  if not ok then error(result) end
+end
+
+describe('Pos', function()
+  it('get a char from a given position', function()
+    withbuf({ 'asdf', 'bleh', 'a', '', 'goo' }, function()
+      assert.are.same('a', Pos.new(nil, 1, 1):char())
+      assert.are.same('d', Pos.new(nil, 1, 3):char())
+      assert.are.same('f', Pos.new(nil, 1, 4):char())
+      assert.are.same('a', Pos.new(nil, 3, 1):char())
+      assert.are.same('', Pos.new(nil, 4, 1):char())
+      assert.are.same('o', Pos.new(nil, 5, 3):char())
+    end)
+  end)
+
+  it('comparison operators', function()
+    local a = Pos.new(0, 0, 0, 0)
+    local b = Pos.new(0, 1, 0, 0)
+    assert.are.same(a == a, true)
+    assert.are.same(a < b, true)
+  end)
+
+  it('get the next position', function()
+    withbuf({ 'asdf', 'bleh', 'a', '', 'goo' }, function()
+      -- line 1: a => s
+      assert.are.same(Pos.new(nil, 1, 2), Pos.new(nil, 1, 1):next())
+      -- line 1: d => f
+      assert.are.same(Pos.new(nil, 1, 4), Pos.new(nil, 1, 3):next())
+      -- line 1 => 2
+      assert.are.same(Pos.new(nil, 2, 1), Pos.new(nil, 1, 4):next())
+      -- line 3 => 4
+      assert.are.same(Pos.new(nil, 4, 1), Pos.new(nil, 3, 1):next())
+      -- line 4 => 5
+      assert.are.same(Pos.new(nil, 5, 1), Pos.new(nil, 4, 1):next())
+      -- end returns nil
+      assert.are.same(nil, Pos.new(nil, 5, 3):next())
+    end)
+  end)
+
+  it('get the previous position', function()
+    withbuf({ 'asdf', 'bleh', 'a', '', 'goo' }, function()
+      -- line 1: s => a
+      assert.are.same(Pos.new(nil, 1, 1), Pos.new(nil, 1, 2):next(-1))
+      -- line 1: f => d
+      assert.are.same(Pos.new(nil, 1, 3), Pos.new(nil, 1, 4):next(-1))
+      -- line 2 => 1
+      assert.are.same(Pos.new(nil, 1, 4), Pos.new(nil, 2, 1):next(-1))
+      -- line 4 => 3
+      assert.are.same(Pos.new(nil, 3, 1), Pos.new(nil, 4, 1):next(-1))
+      -- line 5 => 4
+      assert.are.same(Pos.new(nil, 4, 1), Pos.new(nil, 5, 1):next(-1))
+      -- beginning returns nil
+      assert.are.same(nil, Pos.new(nil, 1, 1):next(-1))
+    end)
+  end)
+
+  it('find matching brackets', function()
+    withbuf({ 'asdf ({} def <[{}]>) ;lkj' }, function()
+      -- outer parens are matched:
+      assert.are.same(Pos.new(nil, 1, 20), Pos.new(nil, 1, 6):find_match())
+      -- outer parens are matched (backward):
+      assert.are.same(Pos.new(nil, 1, 6), Pos.new(nil, 1, 20):find_match())
+      -- no potential match returns nil
+      assert.are.same(nil, Pos.new(nil, 1, 1):find_match())
+      -- watchdog expires before an otherwise valid match is found:
+      assert.are.same(nil, Pos.new(nil, 1, 6):find_match(2))
+    end)
+  end)
+end)
 
 describe('Range', function()
   it('get text in buffer', function()
@@ -239,6 +316,78 @@ describe('Range', function()
     end)
   end)
 
+  it('text object: it (inside HTML tag)', function()
+    withbuf({ '<div><span>text</span></div>' }, function()
+      vim.cmd.setfiletype 'html'
+      vim.fn.setpos('.', { 0, 1, 12, 0 }) -- inside 'text'
+      local range = Range.from_motion('it')
+      assert.is_not_nil(range)
+      assert.are.same('text', range:text())
+    end)
+  end)
+
+  it('from_motion with contains_cursor returns nil when cursor outside range', function()
+    withbuf({ 'foo "quoted" bar' }, function()
+      vim.fn.setpos('.', { 0, 1, 2, 0 }) -- cursor at 'foo', not in quotes
+      local range = Range.from_motion('a"', { contains_cursor = true })
+      assert.is_nil(range)
+    end)
+  end)
+
+  it('from_motion with pos option', function()
+    withbuf({ 'the quick brown fox' }, function()
+      vim.fn.setpos('.', { 0, 1, 1, 0 }) -- cursor at start
+      local pos = Pos.new(nil, 1, 5) -- position at 'quick'
+      local range = Range.from_motion('aw', { pos = pos })
+      assert.are.same('quick ', range:text())
+    end)
+  end)
+
+  it('from_motion with simple motion (non-text-object)', function()
+    withbuf({ 'hello world' }, function()
+      vim.fn.setpos('.', { 0, 1, 1, 0 })
+      local range = Range.from_motion('w')
+      assert.is_not_nil(range)
+    end)
+  end)
+
+  it('from_motion with bufnr option', function()
+    local buf1 = vim.api.nvim_create_buf(false, true)
+    vim.api.nvim_buf_set_lines(buf1, 0, -1, false, { 'buffer one', 'more text' })
+    
+    local buf2 = vim.api.nvim_create_buf(false, true)
+    vim.api.nvim_buf_set_lines(buf2, 0, -1, false, { 'buffer two' })
+    vim.api.nvim_set_current_buf(buf2)
+    
+    vim.fn.setpos('.', { buf1, 1, 1, 0 })
+    local range = Range.from_motion('aw', { bufnr = buf1 })
+    assert.is_not_nil(range)
+    assert.are.same(buf1, range.start.bufnr)
+    
+    vim.api.nvim_buf_delete(buf1, { force = true })
+    vim.api.nvim_buf_delete(buf2, { force = true })
+  end)
+
+  it('from_motion restores visual selection when started in visual mode', function()
+    withbuf({ 'the quick brown fox' }, function()
+      -- Enter visual mode first
+      vim.fn.setpos('.', { 0, 1, 1, 0 })
+      vim.cmd.normal 'vll' -- select 'the' (3 chars)
+      
+      -- Record initial visual marks
+      local initial_v = vim.fn.getpos('v')
+      
+      -- Call from_motion (should save and restore visual selection)
+      local range = Range.from_motion('aw')
+      assert.is_not_nil(range)
+      
+      -- Check we're back in visual mode with selection restored
+      -- Note: The exact behavior depends on implementation
+      local mode = vim.fn.mode()
+      assert.is_true(mode == 'v' or mode == 'V' or mode == '\22')
+    end)
+  end)
+
   it('from_tsquery_caps', function()
     withbuf({
       '-- a comment',
@@ -900,3 +1049,473 @@ describe('Range', function()
     vim.api.nvim_buf_delete(right_bufnr, { force = true })
   end)
 end)
+
+--------------------------------------------------------------------------------
+-- Additional coverage tests
+--------------------------------------------------------------------------------
+
+describe('Pos additional coverage', function()
+  it('__tostring', function()
+    withbuf({ 'test' }, function()
+      local bufnr = vim.api.nvim_get_current_buf()
+      local p = Pos.new(bufnr, 1, 1, 0)
+      local s = tostring(p)
+      assert.is_true(s:find('Pos%(1:1%)') ~= nil)
+      assert.is_true(s:find('bufnr=' .. bufnr) ~= nil)
+      
+      local p2 = Pos.new(bufnr, 1, 1, 5)
+      s = tostring(p2)
+      assert.is_true(s:find('Pos%(1:1%)') ~= nil)
+      assert.is_true(s:find('off=5') ~= nil)
+    end)
+  end)
+
+  it('from_eol', function()
+    withbuf({ 'hello world' }, function()
+      local eol = Pos.from_eol(nil, 1)
+      assert.are.same(11, eol.col)
+      assert.are.same('hello world', eol:line())
+    end)
+  end)
+
+  it(':eol', function()
+    withbuf({ 'hello world' }, function()
+      local p = Pos.new(nil, 1, 1)
+      local eol = p:eol()
+      assert.are.same(11, eol.col)
+    end)
+  end)
+
+  it('save_to_cursor', function()
+    withbuf({ 'line one', 'line two' }, function()
+      local p = Pos.new(nil, 2, 5)
+      p:save_to_cursor()
+      assert.are.same({ 2, 4 }, vim.api.nvim_win_get_cursor(0))
+    end)
+  end)
+
+  it('save_to_mark', function()
+    withbuf({ 'line one', 'line two' }, function()
+      local b = vim.api.nvim_get_current_buf()
+      local p = Pos.new(b, 2, 5)
+      p:save_to_mark('a')
+      local mark = vim.api.nvim_buf_get_mark(b, 'a')
+      assert.are.same({ 2, 4 }, mark)
+    end)
+  end)
+
+  it('must_next', function()
+    withbuf({ 'abc' }, function()
+      local p = Pos.new(nil, 1, 1)
+      local next = p:must_next(1)
+      assert.are.same(Pos.new(nil, 1, 2), next)
+      
+      assert.has.error(function()
+        Pos.new(nil, 1, 3):must_next(1)
+      end, 'error in Pos:next(): Pos:next() returned nil')
+    end)
+  end)
+
+  it('next_while', function()
+    withbuf({ 'aaabbb' }, function()
+      local p = Pos.new(nil, 1, 1)
+      local result = p:next_while(1, function(pos) return pos:char() == 'a' end)
+      assert.are.same(Pos.new(nil, 1, 3), result)
+      
+      result = p:next_while(1, function(pos) return pos:char() == 'a' end, true)
+      assert.are.same(Pos.new(nil, 1, 3), result)
+      
+      result = p:next_while(1, function() return false end, true)
+      assert.are.same(nil, result)
+    end)
+  end)
+
+  it('insert_before', function()
+    withbuf({ 'world' }, function()
+      local p = Pos.new(nil, 1, 1)
+      p:insert_before('hello ')
+      assert.are.same({ 'hello world' }, vim.api.nvim_buf_get_lines(0, 0, -1, false))
+    end)
+  end)
+
+  it('is_invalid', function()
+    local invalid = Pos.invalid()
+    assert.is_true(invalid:is_invalid())
+    
+    withbuf({ 'test' }, function()
+      local valid = Pos.new(nil, 1, 1)
+      assert.is_false(valid:is_invalid())
+    end)
+  end)
+
+  it('__add with number first', function()
+    withbuf({ 'abc' }, function()
+      local p = Pos.new(nil, 1, 1)
+      local result = 1 + p
+      assert.are.same(Pos.new(nil, 1, 2), result)
+    end)
+  end)
+
+  it('__sub with number first', function()
+    withbuf({ 'abc' }, function()
+      local p = Pos.new(nil, 1, 2)
+      local result = 1 - p
+      assert.are.same(Pos.new(nil, 1, 1), result)
+    end)
+  end)
+
+  it('find_next returns nil at end', function()
+    withbuf({ 'abc' }, function()
+      local p = Pos.new(nil, 1, 3)
+      local result = p:find_next(1, 'z')
+      assert.are.same(nil, result)
+    end)
+  end)
+
+  it('find_match with nested brackets', function()
+    withbuf({ '(abc)' }, function()
+      local p = Pos.new(nil, 1, 1) -- '('
+      local match = p:find_match()
+      assert.are.same(Pos.new(nil, 1, 5), match) -- ')'
+    end)
+    
+    withbuf({ '{abc}' }, function()
+      local p = Pos.new(nil, 1, 1) -- '{'
+      local match = p:find_match()
+      assert.are.same(Pos.new(nil, 1, 5), match) -- '}'
+    end)
+    
+    withbuf({ '(a{b}c)' }, function()
+      -- Test nested: ( at pos 1, { at pos 3
+      local p = Pos.new(nil, 1, 3) -- '{'
+      local match = p:find_match()
+      assert.are.same(Pos.new(nil, 1, 5), match) -- '}'
+    end)
+  end)
+
+  it('from10', function()
+    withbuf({ 'test' }, function()
+      local p = Pos.from10(nil, 1, 0)
+      assert.are.same(1, p.lnum)
+      assert.are.same(1, p.col)
+      
+      p = Pos.from10(nil, 2, 5, 10)
+      assert.are.same(2, p.lnum)
+      assert.are.same(6, p.col)
+      assert.are.same(10, p.off)
+    end)
+  end)
+
+  it('as_real with col beyond line length', function()
+    withbuf({ 'ab' }, function()
+      local p = Pos.new(nil, 1, 100)
+      local real = p:as_real()
+      assert.are.same(2, real.col)
+    end)
+  end)
+
+  it('find_next returns nil when not found', function()
+    withbuf({ 'abc' }, function()
+      local p = Pos.new(nil, 1, 1)
+      local result = p:find_next(1, 'z')
+      assert.is_nil(result)
+    end)
+  end)
+end)
+
+describe('Range additional coverage', function()
+  it('__tostring with nil stop', function()
+    withbuf({ 'test' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1), nil, 'v')
+      local s = tostring(r)
+      assert.is_true(s:find('stop=nil') ~= nil)
+    end)
+  end)
+
+  it('__tostring with off != 0', function()
+    withbuf({ 'test' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1, 5), Pos.new(nil, 1, 4, 3), 'v')
+      local s = tostring(r)
+      assert.is_true(s:find('off=5') ~= nil)
+    end)
+  end)
+
+  it('__tostring', function()
+    withbuf({ 'test' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 4), 'v')
+      local s = tostring(r)
+      assert.are.same('v', r.mode)
+      assert.is_true(s:find('Range{') == 1)
+    end)
+  end)
+
+  it('from_lines with negative stop_line', function()
+    withbuf({ 'a', 'b', 'c', 'd', 'e' }, function()
+      local r = Range.from_lines(nil, 1, -1)
+      assert.are.same(5, r.stop.lnum)
+      
+      r = Range.from_lines(nil, 1, -2)
+      assert.are.same(4, r.stop.lnum)
+    end)
+  end)
+
+  it('save_to_pos', function()
+    withbuf({ 'hello world' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 5), 'v')
+      r:save_to_pos("'[", "']")
+      local start = Pos.from_pos("'[")
+      local stop = Pos.from_pos("']")
+      assert.are.same(1, start.col)
+      assert.are.same(5, stop.col)
+    end)
+  end)
+
+  it('save_to_marks', function()
+    withbuf({ 'hello world' }, function()
+      local b = vim.api.nvim_get_current_buf()
+      local r = Range.new(Pos.new(b, 1, 1), Pos.new(b, 1, 5), 'v')
+      r:save_to_marks('m', 'n')
+      local m = vim.api.nvim_buf_get_mark(b, 'm')
+      local n = vim.api.nvim_buf_get_mark(b, 'n')
+      assert.are.same({ 1, 0 }, m)
+      assert.are.same({ 1, 4 }, n)
+    end)
+  end)
+
+  it('new swaps start and stop when needed', function()
+    withbuf({ 'test' }, function()
+      local r = Range.new(Pos.new(nil, 1, 4), Pos.new(nil, 1, 1), 'v')
+      assert.are.same(1, r.start.col)
+      assert.are.same(4, r.stop.col)
+    end)
+  end)
+
+  it('from_marks with MAX_COL', function()
+    withbuf({ 'test' }, function()
+      local start = Pos.new(nil, 1, 1)
+      local stop = Pos.new(nil, 1, Pos.MAX_COL)
+      start:save_to_pos("'[")
+      stop:save_to_pos("']")
+      local r = Range.from_marks("'[", "']")
+      assert.are.same('V', r.mode)
+    end)
+  end)
+
+  it('contains returns false for non-Pos/Range', function()
+    withbuf({ 'test' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 4), 'v')
+      assert.is_false(r:contains('string'))
+      assert.is_false(r:contains(123))
+    end)
+  end)
+
+  it('sub with invalid stop', function()
+    withbuf({ 'abcdef' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 6), 'v')
+      local sub = r:sub(1, 100)
+      assert.is_true(sub:is_empty())
+    end)
+  end)
+
+  it('line with negative index', function()
+    withbuf({ 'a', 'b', 'c' }, function()
+      local r = Range.from_lines(nil, 1, 3)
+      local l = r:line(-1)
+      assert.are.same('c', l:text())
+      
+      l = r:line(-2)
+      assert.are.same('b', l:text())
+    end)
+  end)
+
+  it('line returns nil for out of bounds', function()
+    withbuf({ 'a', 'b' }, function()
+      local r = Range.from_lines(nil, 1, 2)
+      assert.is_nil(r:line(10))
+    end)
+  end)
+
+  it('trim_start returns range with start=stop when all whitespace', function()
+    withbuf({ '   ' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 3), 'v')
+      local trimmed = r:trim_start()
+      assert.is_not.same(nil, trimmed)
+      assert.are.same(trimmed.start, trimmed.stop)
+    end)
+  end)
+
+  it('trim_stop returns range with start=stop when all whitespace', function()
+    withbuf({ '   ' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 3), 'v')
+      local trimmed = r:trim_stop()
+      assert.is_not.same(nil, trimmed)
+      assert.are.same(trimmed.start, trimmed.stop)
+    end)
+  end)
+
+  it('smallest returns nil for empty input', function()
+    assert.are.same(nil, Range.smallest {})
+    assert.are.same(nil, Range.smallest { nil })
+  end)
+end)
+
+describe('Extmark additional coverage', function()
+  it('delete', function()
+    withbuf({ 'test' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 4), 'v')
+      local ext = r:save_to_extmark()
+      ext:delete()
+      -- Should not error
+    end)
+  end)
+end)
+
+describe('utils', function()
+  local u = require 'u'
+  
+  it('create_delegated_cmd_args', function()
+    local args = {
+      range = 2,
+      line1 = 1,
+      line2 = 5,
+      count = -1,
+      reg = '',
+      bang = true,
+      fargs = { 'arg1', 'arg2' },
+      smods = { silent = true },
+    }
+    local delegated = u.create_delegated_cmd_args(args)
+    assert.are.same({ 1, 5 }, delegated.range)
+    assert.are.same(nil, delegated.count)
+    assert.are.same(nil, delegated.reg)
+    assert.are.same(true, delegated.bang)
+    assert.are.same({ 'arg1', 'arg2' }, delegated.args)
+    
+    -- Test range = 1
+    args = { range = 1, line1 = 3, line2 = 3, count = -1, reg = '', bang = false, fargs = {}, smods = {} }
+    delegated = u.create_delegated_cmd_args(args)
+    assert.are.same({ 3 }, delegated.range)
+    
+    -- Test range = 0 with count
+    args = { range = 0, line1 = 1, line2 = 1, count = 5, reg = '"', bang = false, fargs = {}, smods = {} }
+    delegated = u.create_delegated_cmd_args(args)
+    assert.are.same(nil, delegated.range)
+    assert.are.same(5, delegated.count)
+    assert.are.same('"', delegated.reg)
+  end)
+
+  it('ucmd with string command', function()
+    u.ucmd('TestUcmdString', 'echo "test"', {})
+    local cmds = vim.api.nvim_get_commands { builtin = false }
+    assert.is_not.same(nil, cmds.TestUcmdString)
+    vim.api.nvim_del_user_command 'TestUcmdString'
+  end)
+
+  it('ucmd with function command', function()
+    local called = false
+    u.ucmd('TestUcmdFunc', function(args)
+      called = true
+      assert.is_not.same(nil, args)
+    end, { range = true })
+    
+    local cmds = vim.api.nvim_get_commands { builtin = false }
+    assert.is_not.same(nil, cmds.TestUcmdFunc)
+    
+    vim.cmd.TestUcmdFunc()
+    assert.is_true(called)
+    
+    vim.api.nvim_del_user_command 'TestUcmdFunc'
+  end)
+end)
+
+describe('repeat_', function()
+  local u = require 'u'
+  
+  it('is_repeating returns false by default', function()
+    assert.is_false(u.repeat_.is_repeating())
+  end)
+
+  it('run_repeatable executes the function', function()
+    local called = false
+    u.repeat_.run_repeatable(function()
+      called = true
+    end)
+    assert.is_true(called)
+  end)
+
+  it('setup creates keymaps', function()
+    u.repeat_.setup()
+    local maps = vim.api.nvim_get_keymap 'n'
+    local dot_map = vim.iter(maps):find(function(m) return m.lhs == '.' end)
+    local u_map = vim.iter(maps):find(function(m) return m.lhs == 'u' end)
+    assert.is_not.same(nil, dot_map)
+    assert.is_not.same(nil, u_map)
+  end)
+end)
+
+describe('define_txtobj', function()
+  local u = require 'u'
+  
+  it('defines text object keymaps', function()
+    u.define_txtobj('aX', function()
+      return Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 5), 'v')
+    end)
+    
+    local xmaps = vim.api.nvim_get_keymap 'x'
+    local omaps = vim.api.nvim_get_keymap 'o'
+    
+    local xmap = vim.iter(xmaps):find(function(m) return m.lhs == 'aX' end)
+    local omap_found = vim.iter(omaps):find(function(m) return m.lhs == 'aX' end)
+    
+    assert.is_not.same(nil, xmap)
+    assert.is_not.same(nil, omap_found)
+  end)
+
+  it('defines buffer-local text object keymaps', function()
+    withbuf({ 'test' }, function()
+      local bufnr = vim.api.nvim_get_current_buf()
+      u.define_txtobj('aY', function()
+        return Range.new(Pos.new(bufnr, 1, 1), Pos.new(bufnr, 1, 4), 'v')
+      end, { buffer = bufnr })
+      
+      local xmaps = vim.api.nvim_buf_get_keymap(bufnr, 'x')
+      local omaps = vim.api.nvim_buf_get_keymap(bufnr, 'o')
+      
+      local xmap = vim.iter(xmaps):find(function(m) return m.lhs == 'aY' end)
+      local omap_found = vim.iter(omaps):find(function(m) return m.lhs == 'aY' end)
+      
+      assert.is_not.same(nil, xmap)
+      assert.is_not.same(nil, omap_found)
+    end)
+  end)
+end)
+
+describe('Range highlight', function()
+  it('highlight creates highlight and returns clear function', function()
+    withbuf({ 'hello world' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 5), 'v')
+      local hl = r:highlight('Search', { timeout = 100 })
+      assert.is_not.same(nil, hl)
+      assert.is_not.same(nil, hl.ns)
+      assert.is_not.same(nil, hl.clear)
+      hl.clear()
+    end)
+  end)
+
+  it('highlight returns nil for empty range', function()
+    withbuf({ 'test' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1), nil, 'v')
+      local hl = r:highlight('Search')
+      assert.is_nil(hl)
+    end)
+  end)
+
+  it('highlight with priority option', function()
+    withbuf({ 'hello world' }, function()
+      local r = Range.new(Pos.new(nil, 1, 1), Pos.new(nil, 1, 5), 'v')
+      local hl = r:highlight('Search', { priority = 100 })
+      assert.is_not.same(nil, hl)
+      hl.clear()
+    end)
+  end)
+end)

spec/withbuf.lua

@@ -1,11 +0,0 @@
-require 'luacov'
-local function withbuf(lines, f)
-  vim.go.swapfile = false
-
-  vim.cmd.new()
-  vim.api.nvim_buf_set_lines(0, 0, -1, false, lines)
-  local ok, result = pcall(f)
-  vim.cmd.bdelete { bang = true }
-  if not ok then error(result) end
-end
-return withbuf