mini.nvim/lua/mini/jump.lua at main · yilisharcs/mini.nvim

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

--- *mini.jump* Jump to next/previous single character

---

--- Features:

--- - Extend f, F, t, T to work on multiple lines.

---

--- - Repeat jump by pressing f, F, t, T again. It is reset when cursor moved

--- as a result of not jumping or timeout after idle time (duration

--- customizable).

---

--- - Highlight (after customizable delay) all possible target characters and

--- stop it after some (customizable) idle time.

---

--- - Normal, Visual, and Operator-pending (with dot-repeat as in clean Neovim)

--- modes are supported.

---

--- This module follows vim's |'ignorecase'| and |'smartcase'| options. When

--- |'ignorecase'| is set, f, F, t, T will match case-insensitively. When

--- |'smartcase'| is also set, f, F, t, T will only match lowercase

--- characters case-insensitively.

---

--- # Setup ~

---

--- This module needs a setup with `require('mini.jump').setup({})`

--- (replace `{}` with your `config` table). It will create global Lua table

--- `MiniJump` which you can use for scripting or manually (with

--- `:lua MiniJump.*`).

---

--- See |MiniJump.config| for `config` structure and default values.

---

--- You can override runtime config settings locally to buffer inside

--- `vim.b.minijump_config` which should have same structure as

--- `MiniJump.config`. See |mini.nvim-buffer-local-config| for more details.

---

--- To stop module from showing non-error feedback, set `config.silent = true`.

---

--- # Highlight groups ~

--- *MiniJump-hl-groups*

---

--- - `MiniJump` - all possible cursor positions.

---

--- To change any highlight group, set it directly with |nvim_set_hl()|.

---

--- # Disabling ~

---

--- To disable core functionality, set `vim.g.minijump_disable` (globally) or

--- `vim.b.minijump_disable` (for a buffer) to `true`. Considering high number of

--- different scenarios and customization intentions, writing exact rules for

--- disabling module's functionality is left to user. See

--- |mini.nvim-disabling-recipes| for common recipes.

---@tag MiniJump

--- To allow user customization and integration of external tools, certain |User|

--- autocommand events are triggered under common circumstances:

---

--- - `MiniJumpGetTarget` - before asking user for the target. Use |MiniJump.state|

--- for more information about the upcoming jump.

--- - `MiniJumpStart` - after jumping has started.

--- - `MiniJumpJump` - after performing a jump.

--- - `MiniJumpStop` - after jumping is stopped.

---@tag MiniJump-events

---@alias __jump_target string|nil The string to jump to.

---@alias __jump_backward boolean|nil Whether to jump backward.

---@alias __jump_till boolean|nil Whether to jump just before/after the match instead of

--- exactly on target. This includes positioning cursor past the end of

--- previous/current line. Note that with backward jump this might lead to

--- cursor being on target if can't be put past the line.

---@alias __jump_n_times number|nil Number of times to perform consecutive jumps.

-- Module definition ==========================================================

local MiniJump = {}

local H = {}

--- Module setup

---

---@param config table|nil Module config table. See |MiniJump.config|.

---

---@usage >lua

--- require('mini.jump').setup() -- use default config

--- -- OR

--- require('mini.jump').setup({}) -- replace {} with your config table

--- <

MiniJump.setup = function(config)

-- Export module

_G.MiniJump = MiniJump

-- Setup config

config = H.setup_config(config)

-- Apply config

H.apply_config(config)

-- Define behavior

H.create_autocommands()

-- Create default highlighting

H.create_default_hl()

end

--- Defaults ~

---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)

MiniJump.config = {

-- Module mappings. Use `''` (empty string) to disable one.

mappings = {

forward = 'f',

backward = 'F',

forward_till = 't',

backward_till = 'T',

repeat_jump = ';',

-- Delay values (in ms) for different functionalities. Set any of them to

-- a very big number (like 10^7) to virtually disable.

delay = {

-- Delay between jump and highlighting all possible jumps

highlight = 250,

-- Delay between jump and automatic stop if idle (no jump is done)

idle_stop = 10000000,

-- Whether to disable showing non-error feedback

-- This also affects (purely informational) helper messages shown after

-- idle time if user input is required.

silent = false,

}

--minidoc_afterlines_end

-- Module data ================================================================

--- Data about jumping state

---

--- It stores various information used in this module. All elements, except

--- `jumping`, is about the latest jump. They are used as default values for

--- similar arguments.

---

---@usage This can be used to define mappings which depend on state; either as

--- a standalone mapping or part of |MiniKeymap.map_multistep()|. For example: >lua

---

--- -- Stop jumping after pressing `<Esc>`

--- local jump_stop = function()

--- if not MiniJump.state.jumping then return '<Esc>' end

--- MiniJump.stop_jumping()

--- end

--- local opts = { expr = true, desc = 'Stop jumping' }

--- vim.keymap.set({ 'n', 'x', 'o' }, '<Esc>', jump_stop, opts)

--- <

---@class JumpingState

---

---@field target __jump_target

---@field backward __jump_backward

---@field till __jump_till

---@field n_times __jump_n_times

---@field mode string Mode of latest jump (output of |mode()| with non-zero argument).

---@field jumping boolean Whether module is currently in "jumping mode": usage of

--- |MiniJump.smart_jump()| and all mappings won't require target.

---@text

--- Initial values:

---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)

MiniJump.state = {

target = nil,

backward = false,

till = false,

n_times = 1,

mode = nil,

jumping = false,

}

--minidoc_afterlines_end

-- Module functionality =======================================================

--- Jump to target

---

--- Takes a string and jumps to its first occurrence in desired direction.

---

--- All default values are taken from |MiniJump.state| to emulate latest jump.

---

---@param target __jump_target

---@param backward __jump_backward

---@param till __jump_till

---@param n_times __jump_n_times

MiniJump.jump = function(target, backward, till, n_times)

if H.is_disabled() then return end

-- Dot-repeat should not change the state, so save it to later restore

local expr_mode, is_dot_repeat = MiniJump._expr_mode, MiniJump._expr_mode ~= nil and not MiniJump._is_expr_init

MiniJump._expr_mode, MiniJump._is_expr_init = nil, nil

local state_snapshot = is_dot_repeat and vim.deepcopy(MiniJump.state) or nil

-- Cache inputs for future use

H.update_state(target, backward, till, n_times)

if MiniJump.state.target == nil then return H.message('Can not jump because there is no recent `target`.') end

-- Construct search and highlight pattern data

local pattern, hl_pattern, flags = H.make_search_data()

-- Delay highlighting after stopping previous one

-- Update highlighting immediately if any highlighting is already present

local config = H.get_config()

H.timers.highlight:stop()

local hl = vim.schedule_wrap(function() H.highlight(hl_pattern) end)

H.timers.highlight:start(H.is_highlighting() and 0 or config.delay.highlight, 0, hl)

-- Start idle timer after stopping previous one

H.timers.idle_stop:stop()

H.timers.idle_stop:start(config.delay.idle_stop, 0, vim.schedule_wrap(function() MiniJump.stop_jumping() end))

-- Force charwise selection in Operator-pending expression mapping

if expr_mode ~= nil then vim.cmd('normal! ' .. expr_mode) end

-- Make jump(s)

H.cache.n_cursor_moved = 0

local was_jumping = MiniJump.state.jumping

MiniJump.state.jumping = true

if not was_jumping then H.trigger_event('MiniJumpStart') end

H.trigger_event('MiniJumpJump')

local has_jumped = false

for _ = 1, MiniJump.state.n_times do

local row = vim.fn.search(pattern, flags)

has_jumped = has_jumped or row > 0

end

-- Open enough folds to show jump

if has_jumped then vim.cmd('normal! zv') end

-- Track cursor position to account for movement not caught by `CursorMoved`

H.cache.latest_cursor = H.get_cursor_data()

-- Restore the state if needed. The jumping state is applied if there was jump

-- or if it is possible to jump in other direction (i.e. target is present).

MiniJump.state = is_dot_repeat and state_snapshot or MiniJump.state

local search_pattern = '\\V' .. vim.fn.escape(MiniJump.state.target, '\\')

MiniJump.state.jumping = has_jumped or vim.fn.search(search_pattern, 'wn') ~= 0

-- Nothing else to do if there was a jump

if has_jumped then return end

-- Ensure to stop jumping on next non-jump movement

if MiniJump.state.jumping then H.cache.n_cursor_moved = H.cache.n_cursor_moved + 1 end

-- When in Operator-pending mapping, disable selection to prevent a character

-- from being consumed (due to selection of a cursor cell)

if expr_mode ~= nil then vim.cmd('normal! ' .. expr_mode) end

end

--- Make smart jump

---

--- If the last movement was a jump, perform another jump with the same target.

--- Otherwise, wait for a target input (via |getcharstr()|). Respects |v:count|.

---

--- All default values are taken from |MiniJump.state| to emulate latest jump.

---

---@param backward __jump_backward

---@param till __jump_till

MiniJump.smart_jump = function(backward, till)

if H.is_disabled() then return end

-- Jumping should stop after mode change (use `mode(1)` to track 'omap' case)

-- or if cursor has moved after latest jump

local has_changed_mode = MiniJump.state.mode ~= vim.fn.mode(1)

local has_changed_cursor = not vim.deep_equal(H.cache.latest_cursor, H.get_cursor_data())

if has_changed_mode or has_changed_cursor then MiniJump.stop_jumping() end

H.update_state(nil, backward, till, vim.v.count1)

-- Ask for target only when needed

local target

if not MiniJump.state.jumping or MiniJump.state.target == nil then

target = H.get_target()

-- Stop if user supplied invalid target

if target == nil then return end

end

H.update_state(target)

MiniJump.jump()

end

--- Stop jumping

---

--- Removes highlights (if any) and forces the next smart jump to prompt for

--- the target. Automatically called on appropriate Neovim |events|.

MiniJump.stop_jumping = function()

H.timers.highlight:stop()

H.timers.idle_stop:stop()

local was_jumping = MiniJump.state.jumping

MiniJump.state.jumping = false

H.cache.n_cursor_moved = 0

H.cache.latest_cursor = nil

H.cache.msg_shown = false

H.unhighlight()

-- Trigger relevant event only if there was jumping

if was_jumping then H.trigger_event('MiniJumpStop') end

end

-- Helper data ================================================================

-- Module default config

H.default_config = vim.deepcopy(MiniJump.config)

-- Cache for various operations

H.cache = {

-- Counter of number of CursorMoved events

n_cursor_moved = 0,

-- Latest cursor position data

latest_cursor = nil,

-- Whether helper message was shown

msg_shown = false,

}

-- Timers for different delay-related functionalities

H.timers = { highlight = vim.loop.new_timer(), idle_stop = vim.loop.new_timer() }

-- Information about last match highlighting (stored *per window*):

-- - Key: windows' unique buffer identifiers.

-- - Value: table with:

-- - `id` field for match id (from `vim.fn.matchadd()`).

-- - `pattern` field for highlighted pattern.

H.window_matches = {}

-- Helper functionality =======================================================

-- Settings -------------------------------------------------------------------

H.setup_config = function(config)

H.check_type('config', config, 'table', true)

config = vim.tbl_deep_extend('force', vim.deepcopy(H.default_config), config or {})

H.check_type('delay', config.delay, 'table')

H.check_type('delay.highlight', config.delay.highlight, 'number')

H.check_type('delay.idle_stop', config.delay.idle_stop, 'number')

H.check_type('mappings', config.mappings, 'table')

H.check_type('mappings.forward', config.mappings.forward, 'string')

H.check_type('mappings.backward', config.mappings.backward, 'string')

H.check_type('mappings.forward_till', config.mappings.forward_till, 'string')

H.check_type('mappings.backward_till', config.mappings.backward_till, 'string')

H.check_type('mappings.repeat_jump', config.mappings.repeat_jump, 'string')

H.check_type('silent', config.silent, 'boolean')

return config

end

--stylua: ignore

H.apply_config = function(config)

MiniJump.config = config

H.map('n', config.mappings.forward, '<Cmd>lua MiniJump.smart_jump(false, false)<CR>', { desc = 'Jump forward' })

H.map('n', config.mappings.backward, '<Cmd>lua MiniJump.smart_jump(true, false)<CR>', { desc = 'Jump backward' })

H.map('n', config.mappings.forward_till, '<Cmd>lua MiniJump.smart_jump(false, true)<CR>', { desc = 'Jump forward till' })

H.map('n', config.mappings.backward_till, '<Cmd>lua MiniJump.smart_jump(true, true)<CR>', { desc = 'Jump backward till' })

H.map('n', config.mappings.repeat_jump, '<Cmd>lua MiniJump.jump()<CR>', { desc = 'Repeat jump' })

H.map('x', config.mappings.forward, '<Cmd>lua MiniJump.smart_jump(false, false)<CR>', { desc = 'Jump forward' })

H.map('x', config.mappings.backward, '<Cmd>lua MiniJump.smart_jump(true, false)<CR>', { desc = 'Jump backward' })

H.map('x', config.mappings.forward_till, '<Cmd>lua MiniJump.smart_jump(false, true)<CR>', { desc = 'Jump forward till' })

H.map('x', config.mappings.backward_till, '<Cmd>lua MiniJump.smart_jump(true, true)<CR>', { desc = 'Jump backward till' })

H.map('x', config.mappings.repeat_jump, '<Cmd>lua MiniJump.jump()<CR>', { desc = 'Repeat jump' })

H.map('o', config.mappings.forward, H.make_expr_jump(false, false), { expr = true, desc = 'Jump forward' })

H.map('o', config.mappings.backward, H.make_expr_jump(true, false), { expr = true, desc = 'Jump backward' })

H.map('o', config.mappings.forward_till, H.make_expr_jump(false, true), { expr = true, desc = 'Jump forward till' })

H.map('o', config.mappings.backward_till, H.make_expr_jump(true, true), { expr = true, desc = 'Jump backward till' })

H.map('o', config.mappings.repeat_jump, H.make_expr_jump(), { expr = true, desc = 'Repeat jump' })

end

H.create_autocommands = function()

local gr = vim.api.nvim_create_augroup('MiniJump', {})

local au = function(event, pattern, callback, desc)

vim.api.nvim_create_autocmd(event, { group = gr, pattern = pattern, callback = callback, desc = desc })

end

au('CursorMoved', '*', H.on_cursormoved, 'On CursorMoved')

-- Check current buffer not immediately to allow "temporary buffer switch"

au({ 'BufLeave', 'InsertEnter' }, '*', vim.schedule_wrap(H.stop_if_curbuf), 'Stop jumping')

au('ColorScheme', '*', H.create_default_hl, 'Ensure colors')

end

H.create_default_hl = function() vim.api.nvim_set_hl(0, 'MiniJump', { default = true, link = 'SpellRare' }) end

H.is_disabled = function() return vim.g.minijump_disable == true or vim.b.minijump_disable == true end

H.get_config = function(config)

return vim.tbl_deep_extend('force', MiniJump.config, vim.b.minijump_config or {}, config or {})

end

-- Mappings -------------------------------------------------------------------

H.make_expr_jump = function(backward, till)

return function()

if H.is_disabled() then return '' end

local count = vim.v.count1

H.update_state(nil, backward, till, count)

-- Ask for `target` for non-repeating jump as this will be used only in

-- operator-pending mode. Dot-repeat is supported via expression-mapping.

local isnt_repeat_jump = backward ~= nil and till ~= nil

local target = isnt_repeat_jump and H.get_target() or nil

if isnt_repeat_jump and target == nil then return '<Esc>' end

H.update_state(target)

-- Set a flag to distinguish first call from dot-repeat

MiniJump._is_expr_init = true

-- Take into account forced Operator-pending modes ('nov', 'noV', 'no<C-V>')

local vis_mode = vim.fn.mode(1):match('^no(.+)$') or 'v'

-- Encode state in expression for dot-repeat. Important to use `target=nil`

-- for `repeat_jump` case to have it using latest jumping state during

-- dot-repeat also (as does `nvim --clean`).

local jump_cmd = string.format('MiniJump.jump(%s,%s,%s,%s)', vim.inspect(target), backward, till, count)

local expr_mode_cmd = 'MiniJump._expr_mode = ' .. vim.inspect(vis_mode)

return string.format('<Cmd>lua %s; %s<CR>', expr_mode_cmd, jump_cmd)

end

-- Autocommands ---------------------------------------------------------------

H.on_cursormoved = function()

-- Check if jumping to avoid unnecessary actions on every CursorMoved

if MiniJump.state.jumping then

H.cache.n_cursor_moved = H.cache.n_cursor_moved + 1

-- Stop jumping only if `CursorMoved` was not a result of smart jump

if H.cache.n_cursor_moved > 1 then MiniJump.stop_jumping() end

end

H.stop_if_curbuf = function(ev)

if ev.buf == vim.api.nvim_get_current_buf() then MiniJump.stop_jumping() end

end

-- Pattern matching -----------------------------------------------------------

H.make_search_data = function()

local target = vim.fn.escape(MiniJump.state.target, [[\]])

local backward, till = MiniJump.state.backward, MiniJump.state.till

local flags = backward and 'Wb' or 'W'

local pattern, hl_pattern

if till then

-- General logic: moving pattern should match just before/after target,

-- while highlight pattern should match target for every "movable" place.

-- Also allow checking for "just before/after" across lines by accepting

-- `\n` as possible match.

if backward then

-- NOTE: use `\@<=` instead of `\zs` because it behaves better in case of

-- consecutive matches (like `xxxx` for target `x`)

pattern = target .. [[\@<=\_.]]

hl_pattern = target .. [[\ze\_.]]

else

pattern = [[\_.\ze]] .. target

hl_pattern = [[\_.\@<=]] .. target

end

else

local is_visual = vim.tbl_contains({ 'v', 'V', '\22' }, vim.fn.mode())

local is_exclusive = vim.o.selection == 'exclusive'

if not backward and is_visual and is_exclusive then

-- Still select target in case of exclusive visual selection

pattern = target .. [[\zs\_.]]

hl_pattern = target .. [[\ze\_.]]

else

pattern = target

hl_pattern = target

end

-- Enable 'very nomagic' mode and possibly case-insensitivity

local ignore_case = vim.o.ignorecase and (not vim.o.smartcase or target == target:lower())

local prefix = ignore_case and [[\V\c]] or [[\V]]

pattern, hl_pattern = prefix .. pattern, prefix .. hl_pattern

return pattern, hl_pattern, flags

end

-- Highlighting ---------------------------------------------------------------

H.highlight = function(pattern)

if H.is_highlighting(pattern) or not MiniJump.state.jumping then return end

-- Stop highlighting possible previous pattern. Needed to adjust highlighting

-- when inside jumping but a different kind one. Example: first jump with

-- `till = false` and then, without jumping stop, jump to same character with

-- `till = true`. If this character is first on line, highlighting should change

H.unhighlight()

-- Never highlight in Insert mode

if vim.fn.mode() == 'i' then return end

local match_id = vim.fn.matchadd('MiniJump', pattern)

H.window_matches[vim.api.nvim_get_current_win()] = { id = match_id, pattern = pattern }

end

H.unhighlight = function()

-- Remove highlighting from all windows as jumping is intended to work only

-- in current window. This will work also from other (usually popup) window.

for win_id, match_info in pairs(H.window_matches) do

if vim.api.nvim_win_is_valid(win_id) then

-- Use `pcall` because there is an error if match id is not present. It

-- can happen if something else called `clearmatches`.

pcall(vim.fn.matchdelete, match_info.id, win_id)

H.window_matches[win_id] = nil

end

---@param pattern string|nil Highlight pattern to check for. If `nil`, checks for

--- any highlighting registered in current window.

---@private

H.is_highlighting = function(pattern)

local win_id = vim.api.nvim_get_current_win()

local match_info = H.window_matches[win_id]

if match_info == nil then return false end

return pattern == nil or match_info.pattern == pattern

end

-- Utilities ------------------------------------------------------------------

H.error = function(msg) error('(mini.jump) ' .. msg, 0) end

H.check_type = function(name, val, ref, allow_nil)

if type(val) == ref or (ref == 'callable' and vim.is_callable(val)) or (allow_nil and val == nil) then return end

H.error(string.format('`%s` should be %s, not %s', name, ref, type(val)))

end

H.echo = function(msg, is_important)

if H.get_config().silent then return end

-- Construct message chunks

msg = type(msg) == 'string' and { { msg } } or msg

table.insert(msg, 1, { '(mini.jump) ', 'WarningMsg' })

-- Avoid hit-enter-prompt

local chunks = msg

if not is_important then

chunks = {}

local max_width = vim.o.columns * math.max(vim.o.cmdheight - 1, 0) + vim.v.echospace

local tot_width = 0

for _, ch in ipairs(msg) do

local new_ch = { vim.fn.strcharpart(ch[1], 0, max_width - tot_width), ch[2] }

table.insert(chunks, new_ch)

tot_width = tot_width + vim.fn.strdisplaywidth(new_ch[1])

if tot_width >= max_width then break end

end

-- Echo. Force redraw to ensure that it is effective (`:h echo-redraw`)

vim.cmd([[echo '' | redraw]])

vim.api.nvim_echo(chunks, is_important, {})

end

H.unecho = function()

if H.cache.msg_shown then vim.cmd([[echo '' | redraw]]) end

end

H.message = function(msg) H.echo(msg, true) end

H.trigger_event = function(event_name, data) vim.api.nvim_exec_autocmds('User', { pattern = event_name, data = data }) end

H.update_state = function(target, backward, till, n_times)

MiniJump.state.mode = vim.fn.mode(1)

-- Don't use `? and <1> or <2>` because it doesn't work when `<1>` is `false`

if target ~= nil then MiniJump.state.target = target end

if backward ~= nil then MiniJump.state.backward = backward end

if till ~= nil then MiniJump.state.till = till end

if n_times ~= nil then MiniJump.state.n_times = n_times end

end

H.get_cursor_data = function() return { vim.api.nvim_get_current_win(), vim.api.nvim_win_get_cursor(0) } end

H.get_target = function()

local needs_reminder = true

vim.defer_fn(function()

if not needs_reminder then return end

H.echo('Reminder to press a target single character ')

H.cache.msg_shown = true

end, 1000)

H.trigger_event('MiniJumpGetTarget')

local ok, char = pcall(vim.fn.getcharstr)

needs_reminder = false

H.unecho()

-- Terminate if couldn't get input (like with <C-c>) or on `<Esc>`

if not ok or char == '' or char == '\3' or char == '\27' then return nil end

return char

end

H.map = function(mode, lhs, rhs, opts)

if lhs == '' then return end

opts = vim.tbl_deep_extend('force', { silent = true }, opts or {})

vim.keymap.set(mode, lhs, rhs, opts)

end

return MiniJump

FilesExpand file tree

jump.lua

Latest commit

History

jump.lua

File metadata and controls