Full Code of sxyazi/yazi for AI

gitextract_ehhv1z_b/

├── .cargo/
│   └── config.toml
├── .envrc
├── .github/
│   ├── DISCUSSION_TEMPLATE/
│   │   └── 1-q-a.yml
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug.yml
│   │   ├── config.yml
│   │   └── feature.yml
│   ├── dependabot.yml
│   ├── pull_request_template.md
│   └── workflows/
│       ├── cachix.yml
│       ├── check.yml
│       ├── draft.yml
│       ├── lock.yml
│       ├── no-response.yml
│       ├── publish.yml
│       ├── test.yml
│       └── validate-form.yml
├── .gitignore
├── .luarc.json
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── Cargo.toml
├── LICENSE
├── LICENSE-ICONS
├── README.md
├── assets/
│   └── yazi.desktop
├── cspell.json
├── flake.nix
├── nix/
│   ├── shell.nix
│   ├── yazi-unwrapped.nix
│   └── yazi.nix
├── rustfmt.toml
├── scripts/
│   ├── build.sh
│   ├── bump.sh
│   ├── icons/
│   │   └── generate.lua
│   └── validate-form/
│       ├── main.js
│       └── package.json
├── snap/
│   └── snapcraft.yaml
├── stylua.toml
├── yazi-actor/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── actor.rs
│       ├── app/
│       │   ├── accept_payload.rs
│       │   ├── bootstrap.rs
│       │   ├── deprecate.rs
│       │   ├── focus.rs
│       │   ├── mod.rs
│       │   ├── mouse.rs
│       │   ├── plugin.rs
│       │   ├── plugin_do.rs
│       │   ├── quit.rs
│       │   ├── reflow.rs
│       │   ├── resize.rs
│       │   ├── resume.rs
│       │   ├── stop.rs
│       │   ├── title.rs
│       │   └── update_progress.rs
│       ├── cmp/
│       │   ├── arrow.rs
│       │   ├── close.rs
│       │   ├── mod.rs
│       │   ├── show.rs
│       │   └── trigger.rs
│       ├── confirm/
│       │   ├── arrow.rs
│       │   ├── close.rs
│       │   ├── mod.rs
│       │   └── show.rs
│       ├── context.rs
│       ├── core/
│       │   ├── mod.rs
│       │   └── preflight.rs
│       ├── help/
│       │   ├── arrow.rs
│       │   ├── escape.rs
│       │   ├── filter.rs
│       │   ├── mod.rs
│       │   └── toggle.rs
│       ├── input/
│       │   ├── close.rs
│       │   ├── complete.rs
│       │   ├── escape.rs
│       │   ├── mod.rs
│       │   └── show.rs
│       ├── lib.rs
│       ├── lives/
│       │   ├── core.rs
│       │   ├── file.rs
│       │   ├── files.rs
│       │   ├── filter.rs
│       │   ├── finder.rs
│       │   ├── folder.rs
│       │   ├── lives.rs
│       │   ├── mod.rs
│       │   ├── mode.rs
│       │   ├── preference.rs
│       │   ├── preview.rs
│       │   ├── ptr.rs
│       │   ├── selected.rs
│       │   ├── tab.rs
│       │   ├── tabs.rs
│       │   ├── task.rs
│       │   ├── tasks.rs
│       │   ├── which.rs
│       │   └── yanked.rs
│       ├── mgr/
│       │   ├── arrow.rs
│       │   ├── back.rs
│       │   ├── bulk_rename.rs
│       │   ├── cd.rs
│       │   ├── close.rs
│       │   ├── copy.rs
│       │   ├── create.rs
│       │   ├── displace.rs
│       │   ├── displace_do.rs
│       │   ├── download.rs
│       │   ├── enter.rs
│       │   ├── escape.rs
│       │   ├── filter.rs
│       │   ├── filter_do.rs
│       │   ├── find.rs
│       │   ├── find_arrow.rs
│       │   ├── find_do.rs
│       │   ├── follow.rs
│       │   ├── forward.rs
│       │   ├── hardlink.rs
│       │   ├── hidden.rs
│       │   ├── hover.rs
│       │   ├── leave.rs
│       │   ├── linemode.rs
│       │   ├── link.rs
│       │   ├── mod.rs
│       │   ├── open.rs
│       │   ├── open_do.rs
│       │   ├── paste.rs
│       │   ├── peek.rs
│       │   ├── quit.rs
│       │   ├── refresh.rs
│       │   ├── remove.rs
│       │   ├── rename.rs
│       │   ├── reveal.rs
│       │   ├── search.rs
│       │   ├── seek.rs
│       │   ├── shell.rs
│       │   ├── sort.rs
│       │   ├── spot.rs
│       │   ├── stash.rs
│       │   ├── suspend.rs
│       │   ├── tab_close.rs
│       │   ├── tab_create.rs
│       │   ├── tab_rename.rs
│       │   ├── tab_swap.rs
│       │   ├── tab_switch.rs
│       │   ├── toggle.rs
│       │   ├── toggle_all.rs
│       │   ├── unyank.rs
│       │   ├── update_files.rs
│       │   ├── update_mimes.rs
│       │   ├── update_paged.rs
│       │   ├── update_peeked.rs
│       │   ├── update_spotted.rs
│       │   ├── update_yanked.rs
│       │   ├── upload.rs
│       │   ├── visual_mode.rs
│       │   ├── watch.rs
│       │   └── yank.rs
│       ├── notify/
│       │   ├── mod.rs
│       │   ├── push.rs
│       │   └── tick.rs
│       ├── pick/
│       │   ├── arrow.rs
│       │   ├── close.rs
│       │   ├── mod.rs
│       │   └── show.rs
│       ├── spot/
│       │   ├── arrow.rs
│       │   ├── close.rs
│       │   ├── copy.rs
│       │   ├── mod.rs
│       │   └── swipe.rs
│       ├── tasks/
│       │   ├── arrow.rs
│       │   ├── cancel.rs
│       │   ├── close.rs
│       │   ├── inspect.rs
│       │   ├── mod.rs
│       │   ├── open_shell_compat.rs
│       │   ├── process_open.rs
│       │   ├── show.rs
│       │   └── update_succeed.rs
│       └── which/
│           ├── activate.rs
│           ├── dismiss.rs
│           └── mod.rs
├── yazi-adapter/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── adapter.rs
│       ├── adapters.rs
│       ├── drivers/
│       │   ├── chafa.rs
│       │   ├── iip.rs
│       │   ├── kgp.rs
│       │   ├── kgp_old.rs
│       │   ├── mod.rs
│       │   ├── sixel.rs
│       │   └── ueberzug.rs
│       ├── icc.rs
│       ├── image.rs
│       ├── info.rs
│       └── lib.rs
├── yazi-binding/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── access.rs
│       ├── calculator.rs
│       ├── cha.rs
│       ├── chan.rs
│       ├── chord_cow.rs
│       ├── color.rs
│       ├── composer.rs
│       ├── elements/
│       │   ├── align.rs
│       │   ├── area.rs
│       │   ├── bar.rs
│       │   ├── border.rs
│       │   ├── cell.rs
│       │   ├── clear.rs
│       │   ├── constraint.rs
│       │   ├── edge.rs
│       │   ├── elements.rs
│       │   ├── gauge.rs
│       │   ├── layout.rs
│       │   ├── line.rs
│       │   ├── list.rs
│       │   ├── mod.rs
│       │   ├── pad.rs
│       │   ├── pos.rs
│       │   ├── rect.rs
│       │   ├── renderable.rs
│       │   ├── row.rs
│       │   ├── span.rs
│       │   ├── table.rs
│       │   ├── text.rs
│       │   └── wrap.rs
│       ├── error.rs
│       ├── fd.rs
│       ├── file.rs
│       ├── handle.rs
│       ├── icon.rs
│       ├── id.rs
│       ├── image.rs
│       ├── input.rs
│       ├── iter.rs
│       ├── layer.rs
│       ├── lib.rs
│       ├── macros.rs
│       ├── mouse.rs
│       ├── path.rs
│       ├── permit.rs
│       ├── range.rs
│       ├── runtime.rs
│       ├── scheme.rs
│       ├── stage.rs
│       ├── style.rs
│       ├── url.rs
│       └── utils.rs
├── yazi-boot/
│   ├── Cargo.toml
│   ├── README.md
│   ├── build.rs
│   └── src/
│       ├── actions/
│       │   ├── actions.rs
│       │   ├── clear_cache.rs
│       │   ├── debug.rs
│       │   ├── mod.rs
│       │   ├── rustc.rs
│       │   ├── triple.rs
│       │   └── version.rs
│       ├── args.rs
│       ├── boot.rs
│       └── lib.rs
├── yazi-build/
│   ├── Cargo.toml
│   ├── README.md
│   ├── build.rs
│   └── src/
│       └── main.rs
├── yazi-cli/
│   ├── Cargo.toml
│   ├── README.md
│   ├── build.rs
│   └── src/
│       ├── args.rs
│       ├── dds/
│       │   ├── draw.rs
│       │   ├── exec.rs
│       │   ├── mod.rs
│       │   └── shot.rs
│       ├── main.rs
│       ├── package/
│       │   ├── add.rs
│       │   ├── delete.rs
│       │   ├── dependency.rs
│       │   ├── deploy.rs
│       │   ├── git.rs
│       │   ├── hash.rs
│       │   ├── install.rs
│       │   ├── mod.rs
│       │   ├── package.rs
│       │   └── upgrade.rs
│       └── shared/
│           ├── mod.rs
│           └── shared.rs
├── yazi-codegen/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       └── lib.rs
├── yazi-config/
│   ├── Cargo.toml
│   ├── README.md
│   ├── preset/
│   │   ├── README.md
│   │   ├── keymap-default.toml
│   │   ├── theme-dark.toml
│   │   ├── theme-light.toml
│   │   ├── vfs-default.toml
│   │   └── yazi-default.toml
│   └── src/
│       ├── icon.rs
│       ├── keymap/
│       │   ├── chord.rs
│       │   ├── cow.rs
│       │   ├── deserializers.rs
│       │   ├── key.rs
│       │   ├── keymap.rs
│       │   ├── mod.rs
│       │   └── rules.rs
│       ├── layout.rs
│       ├── lib.rs
│       ├── mgr/
│       │   ├── mgr.rs
│       │   ├── mod.rs
│       │   ├── mouse.rs
│       │   └── ratio.rs
│       ├── open/
│       │   ├── mod.rs
│       │   ├── open.rs
│       │   └── rule.rs
│       ├── opener/
│       │   ├── mod.rs
│       │   ├── opener.rs
│       │   └── rule.rs
│       ├── pattern.rs
│       ├── platform.rs
│       ├── plugin/
│       │   ├── fetcher.rs
│       │   ├── mod.rs
│       │   ├── plugin.rs
│       │   ├── preloader.rs
│       │   ├── previewer.rs
│       │   └── spotter.rs
│       ├── popup/
│       │   ├── confirm.rs
│       │   ├── input.rs
│       │   ├── mod.rs
│       │   ├── offset.rs
│       │   ├── options.rs
│       │   ├── origin.rs
│       │   ├── pick.rs
│       │   └── position.rs
│       ├── preset.rs
│       ├── preview/
│       │   ├── mod.rs
│       │   ├── preview.rs
│       │   └── wrap.rs
│       ├── priority.rs
│       ├── style.rs
│       ├── tasks/
│       │   ├── mod.rs
│       │   └── tasks.rs
│       ├── theme/
│       │   ├── filetype.rs
│       │   ├── flavor.rs
│       │   ├── icon.rs
│       │   ├── is.rs
│       │   ├── mod.rs
│       │   └── theme.rs
│       ├── utils.rs
│       ├── vfs/
│       │   ├── mod.rs
│       │   ├── service.rs
│       │   ├── services.rs
│       │   └── vfs.rs
│       ├── which/
│       │   ├── mod.rs
│       │   ├── sorting.rs
│       │   └── which.rs
│       └── yazi.rs
├── yazi-core/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── cmp/
│       │   ├── cmp.rs
│       │   └── mod.rs
│       ├── confirm/
│       │   ├── confirm.rs
│       │   └── mod.rs
│       ├── core.rs
│       ├── help/
│       │   ├── help.rs
│       │   └── mod.rs
│       ├── input/
│       │   ├── input.rs
│       │   └── mod.rs
│       ├── lib.rs
│       ├── mgr/
│       │   ├── mgr.rs
│       │   ├── mimetype.rs
│       │   ├── mod.rs
│       │   ├── tabs.rs
│       │   └── yanked.rs
│       ├── notify/
│       │   ├── message.rs
│       │   ├── mod.rs
│       │   └── notify.rs
│       ├── pick/
│       │   ├── mod.rs
│       │   └── pick.rs
│       ├── spot/
│       │   ├── mod.rs
│       │   └── spot.rs
│       ├── tab/
│       │   ├── backstack.rs
│       │   ├── finder.rs
│       │   ├── folder.rs
│       │   ├── history.rs
│       │   ├── mod.rs
│       │   ├── mode.rs
│       │   ├── preference.rs
│       │   ├── preview.rs
│       │   ├── selected.rs
│       │   └── tab.rs
│       ├── tasks/
│       │   ├── file.rs
│       │   ├── mod.rs
│       │   ├── prework.rs
│       │   ├── process.rs
│       │   └── tasks.rs
│       └── which/
│           ├── mod.rs
│           ├── sorter.rs
│           └── which.rs
├── yazi-dds/
│   ├── Cargo.toml
│   ├── README.md
│   ├── build.rs
│   └── src/
│       ├── client.rs
│       ├── ember/
│       │   ├── bulk.rs
│       │   ├── bye.rs
│       │   ├── cd.rs
│       │   ├── custom.rs
│       │   ├── delete.rs
│       │   ├── download.rs
│       │   ├── duplicate.rs
│       │   ├── ember.rs
│       │   ├── hey.rs
│       │   ├── hi.rs
│       │   ├── hover.rs
│       │   ├── load.rs
│       │   ├── mod.rs
│       │   ├── mount.rs
│       │   ├── move.rs
│       │   ├── rename.rs
│       │   ├── tab.rs
│       │   ├── trash.rs
│       │   └── yank.rs
│       ├── lib.rs
│       ├── macros.rs
│       ├── payload.rs
│       ├── pubsub.rs
│       ├── pump.rs
│       ├── sendable.rs
│       ├── server.rs
│       ├── spark/
│       │   ├── kind.rs
│       │   ├── mod.rs
│       │   └── spark.rs
│       ├── state.rs
│       └── stream.rs
├── yazi-emulator/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── brand.rs
│       ├── dimension.rs
│       ├── emulator.rs
│       ├── lib.rs
│       ├── mux.rs
│       └── unknown.rs
├── yazi-ffi/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── cf_dict.rs
│       ├── cf_string.rs
│       ├── disk_arbitration.rs
│       ├── io_kit.rs
│       └── lib.rs
├── yazi-fm/
│   ├── Cargo.toml
│   ├── README.md
│   ├── build.rs
│   └── src/
│       ├── app/
│       │   ├── app.rs
│       │   ├── mod.rs
│       │   └── render.rs
│       ├── cmp/
│       │   ├── cmp.rs
│       │   └── mod.rs
│       ├── confirm/
│       │   ├── body.rs
│       │   ├── buttons.rs
│       │   ├── confirm.rs
│       │   ├── list.rs
│       │   └── mod.rs
│       ├── dispatcher.rs
│       ├── executor.rs
│       ├── help/
│       │   ├── bindings.rs
│       │   ├── help.rs
│       │   └── mod.rs
│       ├── input/
│       │   ├── input.rs
│       │   └── mod.rs
│       ├── logs.rs
│       ├── main.rs
│       ├── mgr/
│       │   ├── mod.rs
│       │   ├── modal.rs
│       │   └── preview.rs
│       ├── notify/
│       │   ├── mod.rs
│       │   └── notify.rs
│       ├── panic.rs
│       ├── pick/
│       │   ├── list.rs
│       │   ├── mod.rs
│       │   └── pick.rs
│       ├── root.rs
│       ├── router.rs
│       ├── signals.rs
│       ├── spot/
│       │   ├── mod.rs
│       │   └── spot.rs
│       ├── tasks/
│       │   ├── list.rs
│       │   ├── mod.rs
│       │   ├── progress.rs
│       │   └── tasks.rs
│       └── which/
│           ├── cand.rs
│           ├── mod.rs
│           └── which.rs
├── yazi-fs/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── cha/
│       │   ├── cha.rs
│       │   ├── kind.rs
│       │   ├── mod.rs
│       │   ├── mode.rs
│       │   └── type.rs
│       ├── cwd.rs
│       ├── error/
│       │   ├── error.rs
│       │   ├── mod.rs
│       │   └── serde.rs
│       ├── file.rs
│       ├── files.rs
│       ├── filter.rs
│       ├── fns.rs
│       ├── hash.rs
│       ├── lib.rs
│       ├── mounts/
│       │   ├── linux.rs
│       │   ├── macos.rs
│       │   ├── mod.rs
│       │   ├── partition.rs
│       │   └── partitions.rs
│       ├── op.rs
│       ├── path/
│       │   ├── clean.rs
│       │   ├── expand.rs
│       │   ├── mod.rs
│       │   ├── path.rs
│       │   ├── percent.rs
│       │   └── relative.rs
│       ├── provider/
│       │   ├── attrs.rs
│       │   ├── capabilities.rs
│       │   ├── local/
│       │   │   ├── absolute.rs
│       │   │   ├── calculator.rs
│       │   │   ├── casefold.rs
│       │   │   ├── copier.rs
│       │   │   ├── dir_entry.rs
│       │   │   ├── gate.rs
│       │   │   ├── identical.rs
│       │   │   ├── local.rs
│       │   │   ├── mod.rs
│       │   │   └── read_dir.rs
│       │   ├── mod.rs
│       │   └── traits.rs
│       ├── scheme.rs
│       ├── sorter.rs
│       ├── sorting.rs
│       ├── splatter.rs
│       ├── stage.rs
│       ├── url.rs
│       └── xdg.rs
├── yazi-macro/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── actor.rs
│       ├── asset.rs
│       ├── context.rs
│       ├── event.rs
│       ├── fmt.rs
│       ├── fs.rs
│       ├── lib.rs
│       ├── log.rs
│       ├── module.rs
│       ├── platform.rs
│       ├── render.rs
│       └── stdio.rs
├── yazi-packing/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       └── lib.rs
├── yazi-parser/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── app/
│       │   ├── deprecate.rs
│       │   ├── mod.rs
│       │   ├── mouse.rs
│       │   ├── plugin.rs
│       │   ├── quit.rs
│       │   ├── reflow.rs
│       │   ├── resume.rs
│       │   ├── stop.rs
│       │   ├── title.rs
│       │   └── update_progress.rs
│       ├── arrow.rs
│       ├── cmp/
│       │   ├── close.rs
│       │   ├── mod.rs
│       │   ├── show.rs
│       │   └── trigger.rs
│       ├── confirm/
│       │   ├── close.rs
│       │   ├── mod.rs
│       │   └── show.rs
│       ├── help/
│       │   ├── mod.rs
│       │   └── toggle.rs
│       ├── input/
│       │   ├── close.rs
│       │   └── mod.rs
│       ├── lib.rs
│       ├── mgr/
│       │   ├── cd.rs
│       │   ├── close.rs
│       │   ├── copy.rs
│       │   ├── create.rs
│       │   ├── displace_do.rs
│       │   ├── download.rs
│       │   ├── escape.rs
│       │   ├── filter.rs
│       │   ├── find.rs
│       │   ├── find_arrow.rs
│       │   ├── find_do.rs
│       │   ├── hardlink.rs
│       │   ├── hidden.rs
│       │   ├── hover.rs
│       │   ├── linemode.rs
│       │   ├── link.rs
│       │   ├── mod.rs
│       │   ├── open.rs
│       │   ├── open_do.rs
│       │   ├── paste.rs
│       │   ├── peek.rs
│       │   ├── remove.rs
│       │   ├── rename.rs
│       │   ├── reveal.rs
│       │   ├── search.rs
│       │   ├── seek.rs
│       │   ├── shell.rs
│       │   ├── sort.rs
│       │   ├── spot.rs
│       │   ├── stash.rs
│       │   ├── tab_close.rs
│       │   ├── tab_create.rs
│       │   ├── tab_rename.rs
│       │   ├── tab_switch.rs
│       │   ├── toggle.rs
│       │   ├── toggle_all.rs
│       │   ├── update_files.rs
│       │   ├── update_mimes.rs
│       │   ├── update_paged.rs
│       │   ├── update_peeked.rs
│       │   ├── update_spotted.rs
│       │   ├── update_yanked.rs
│       │   ├── upload.rs
│       │   ├── visual_mode.rs
│       │   └── yank.rs
│       ├── notify/
│       │   ├── mod.rs
│       │   ├── push.rs
│       │   └── tick.rs
│       ├── pick/
│       │   ├── close.rs
│       │   ├── mod.rs
│       │   └── show.rs
│       ├── spot/
│       │   ├── copy.rs
│       │   └── mod.rs
│       ├── tasks/
│       │   ├── mod.rs
│       │   ├── process_open.rs
│       │   └── update_succeed.rs
│       ├── void.rs
│       └── which/
│           ├── activate.rs
│           └── mod.rs
├── yazi-plugin/
│   ├── Cargo.toml
│   ├── README.md
│   ├── preset/
│   │   ├── compat.lua
│   │   ├── components/
│   │   │   ├── current.lua
│   │   │   ├── entity.lua
│   │   │   ├── header.lua
│   │   │   ├── linemode.lua
│   │   │   ├── marker.lua
│   │   │   ├── modal.lua
│   │   │   ├── parent.lua
│   │   │   ├── preview.lua
│   │   │   ├── progress.lua
│   │   │   ├── rail.lua
│   │   │   ├── root.lua
│   │   │   ├── status.lua
│   │   │   ├── tab.lua
│   │   │   ├── tabs.lua
│   │   │   └── tasks.lua
│   │   ├── plugins/
│   │   │   ├── archive.lua
│   │   │   ├── code.lua
│   │   │   ├── dds.lua
│   │   │   ├── empty.lua
│   │   │   ├── extract.lua
│   │   │   ├── file.lua
│   │   │   ├── folder.lua
│   │   │   ├── font.lua
│   │   │   ├── fzf.lua
│   │   │   ├── image.lua
│   │   │   ├── init.lua
│   │   │   ├── json.lua
│   │   │   ├── magick.lua
│   │   │   ├── mime-dir.lua
│   │   │   ├── mime-local.lua
│   │   │   ├── mime-remote.lua
│   │   │   ├── mime.lua
│   │   │   ├── multi.lua
│   │   │   ├── noop.lua
│   │   │   ├── null.lua
│   │   │   ├── pdf.lua
│   │   │   ├── session.lua
│   │   │   ├── svg.lua
│   │   │   ├── vfs.lua
│   │   │   ├── video.lua
│   │   │   └── zoxide.lua
│   │   ├── setup.lua
│   │   └── ya.lua
│   └── src/
│       ├── elements/
│       │   ├── elements.rs
│       │   └── mod.rs
│       ├── external/
│       │   ├── fd.rs
│       │   ├── highlighter.rs
│       │   ├── mod.rs
│       │   ├── rg.rs
│       │   └── rga.rs
│       ├── fs/
│       │   ├── fs.rs
│       │   ├── mod.rs
│       │   └── op.rs
│       ├── isolate/
│       │   ├── entry.rs
│       │   ├── fetch.rs
│       │   ├── isolate.rs
│       │   ├── mod.rs
│       │   ├── peek.rs
│       │   ├── preload.rs
│       │   ├── seek.rs
│       │   └── spot.rs
│       ├── lib.rs
│       ├── loader/
│       │   ├── chunk.rs
│       │   ├── loader.rs
│       │   ├── mod.rs
│       │   └── require.rs
│       ├── lua.rs
│       ├── process/
│       │   ├── child.rs
│       │   ├── command.rs
│       │   ├── mod.rs
│       │   ├── output.rs
│       │   ├── process.rs
│       │   └── status.rs
│       ├── pubsub/
│       │   ├── mod.rs
│       │   └── pubsub.rs
│       ├── runtime/
│       │   ├── mod.rs
│       │   ├── plugin.rs
│       │   ├── runtime.rs
│       │   └── term.rs
│       ├── theme/
│       │   ├── mod.rs
│       │   └── theme.rs
│       └── utils/
│           ├── app.rs
│           ├── cache.rs
│           ├── call.rs
│           ├── image.rs
│           ├── json.rs
│           ├── layer.rs
│           ├── log.rs
│           ├── mod.rs
│           ├── preview.rs
│           ├── process.rs
│           ├── spot.rs
│           ├── sync.rs
│           ├── target.rs
│           ├── text.rs
│           ├── time.rs
│           ├── user.rs
│           └── utils.rs
├── yazi-proxy/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── app.rs
│       ├── cmp.rs
│       ├── confirm.rs
│       ├── input.rs
│       ├── lib.rs
│       ├── macros.rs
│       ├── mgr.rs
│       ├── notify.rs
│       ├── pick.rs
│       ├── tasks.rs
│       └── which.rs
├── yazi-scheduler/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── fetch/
│       │   ├── fetch.rs
│       │   ├── in.rs
│       │   ├── mod.rs
│       │   ├── out.rs
│       │   └── progress.rs
│       ├── file/
│       │   ├── file.rs
│       │   ├── in.rs
│       │   ├── macros.rs
│       │   ├── mod.rs
│       │   ├── out.rs
│       │   ├── progress.rs
│       │   ├── transaction.rs
│       │   └── traverse.rs
│       ├── hook/
│       │   ├── hook.rs
│       │   ├── in.rs
│       │   ├── macros.rs
│       │   └── mod.rs
│       ├── lib.rs
│       ├── macros.rs
│       ├── ongoing.rs
│       ├── op.rs
│       ├── out.rs
│       ├── plugin/
│       │   ├── in.rs
│       │   ├── macros.rs
│       │   ├── mod.rs
│       │   ├── out.rs
│       │   ├── plugin.rs
│       │   └── progress.rs
│       ├── preload/
│       │   ├── in.rs
│       │   ├── mod.rs
│       │   ├── out.rs
│       │   ├── preload.rs
│       │   └── progress.rs
│       ├── process/
│       │   ├── in.rs
│       │   ├── macros.rs
│       │   ├── mod.rs
│       │   ├── out.rs
│       │   ├── process.rs
│       │   ├── progress.rs
│       │   └── shell.rs
│       ├── progress.rs
│       ├── runner.rs
│       ├── scheduler.rs
│       ├── size/
│       │   ├── in.rs
│       │   ├── mod.rs
│       │   ├── out.rs
│       │   ├── progress.rs
│       │   └── size.rs
│       ├── snap.rs
│       └── task.rs
├── yazi-sftp/
│   ├── Cargo.toml
│   ├── LICENSE
│   ├── README.md
│   └── src/
│       ├── de.rs
│       ├── error.rs
│       ├── fs/
│       │   ├── attrs.rs
│       │   ├── dir_entry.rs
│       │   ├── file.rs
│       │   ├── flags.rs
│       │   ├── mod.rs
│       │   └── read_dir.rs
│       ├── id.rs
│       ├── lib.rs
│       ├── macros.rs
│       ├── operator.rs
│       ├── packet.rs
│       ├── path.rs
│       ├── receiver.rs
│       ├── requests/
│       │   ├── close.rs
│       │   ├── extended.rs
│       │   ├── fstat.rs
│       │   ├── init.rs
│       │   ├── lstat.rs
│       │   ├── mkdir.rs
│       │   ├── mod.rs
│       │   ├── open.rs
│       │   ├── open_dir.rs
│       │   ├── read.rs
│       │   ├── read_dir.rs
│       │   ├── readlink.rs
│       │   ├── realpath.rs
│       │   ├── remove.rs
│       │   ├── rename.rs
│       │   ├── rmdir.rs
│       │   ├── set_stat.rs
│       │   ├── stat.rs
│       │   ├── symlink.rs
│       │   └── write.rs
│       ├── responses/
│       │   ├── attrs.rs
│       │   ├── data.rs
│       │   ├── extended.rs
│       │   ├── handle.rs
│       │   ├── mod.rs
│       │   ├── name.rs
│       │   ├── status.rs
│       │   └── version.rs
│       ├── ser.rs
│       └── session.rs
├── yazi-shared/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── alias.rs
│       ├── bytes.rs
│       ├── chars.rs
│       ├── completion_token.rs
│       ├── condition.rs
│       ├── data/
│       │   ├── any.rs
│       │   ├── data.rs
│       │   ├── de.rs
│       │   ├── key.rs
│       │   └── mod.rs
│       ├── debounce.rs
│       ├── env.rs
│       ├── errors/
│       │   ├── mod.rs
│       │   └── peek.rs
│       ├── event/
│       │   ├── action.rs
│       │   ├── cow.rs
│       │   ├── event.rs
│       │   └── mod.rs
│       ├── id.rs
│       ├── last_value.rs
│       ├── layer.rs
│       ├── lib.rs
│       ├── loc/
│       │   ├── able.rs
│       │   ├── buf.rs
│       │   ├── loc.rs
│       │   └── mod.rs
│       ├── localset.rs
│       ├── natsort.rs
│       ├── os.rs
│       ├── path/
│       │   ├── buf.rs
│       │   ├── component.rs
│       │   ├── components.rs
│       │   ├── conversion.rs
│       │   ├── cow.rs
│       │   ├── display.rs
│       │   ├── error.rs
│       │   ├── kind.rs
│       │   ├── like.rs
│       │   ├── mod.rs
│       │   ├── path.rs
│       │   └── view.rs
│       ├── pool/
│       │   ├── cow.rs
│       │   ├── mod.rs
│       │   ├── pool.rs
│       │   ├── ptr.rs
│       │   ├── symbol.rs
│       │   └── traits.rs
│       ├── predictor.rs
│       ├── ro_cell.rs
│       ├── scheme/
│       │   ├── cow.rs
│       │   ├── encode.rs
│       │   ├── kind.rs
│       │   ├── mod.rs
│       │   ├── ref.rs
│       │   ├── scheme.rs
│       │   └── traits.rs
│       ├── shell/
│       │   ├── error.rs
│       │   ├── mod.rs
│       │   ├── unix.rs
│       │   └── windows.rs
│       ├── source.rs
│       ├── strand/
│       │   ├── buf.rs
│       │   ├── conversion.rs
│       │   ├── cow.rs
│       │   ├── error.rs
│       │   ├── extensions.rs
│       │   ├── kind.rs
│       │   ├── like.rs
│       │   ├── mod.rs
│       │   ├── strand.rs
│       │   └── view.rs
│       ├── sync_cell.rs
│       ├── terminal.rs
│       ├── tests.rs
│       ├── throttle.rs
│       ├── time.rs
│       ├── translit/
│       │   ├── mod.rs
│       │   ├── table.rs
│       │   └── traits.rs
│       ├── url/
│       │   ├── buf.rs
│       │   ├── component.rs
│       │   ├── components.rs
│       │   ├── cov.rs
│       │   ├── cow.rs
│       │   ├── display.rs
│       │   ├── encode.rs
│       │   ├── like.rs
│       │   ├── mod.rs
│       │   ├── traits.rs
│       │   └── url.rs
│       ├── utf8.rs
│       └── wtf8/
│           ├── mod.rs
│           ├── validator.rs
│           └── wtf8.rs
├── yazi-shim/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── crossterm/
│       │   ├── if.rs
│       │   ├── mod.rs
│       │   ├── restore_background.rs
│       │   ├── restore_cursor.rs
│       │   └── set_background.rs
│       ├── lib.rs
│       ├── ratatui/
│       │   ├── mod.rs
│       │   └── paragraph.rs
│       └── twox.rs
├── yazi-term/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── lib.rs
│       ├── option.rs
│       ├── semaphore.rs
│       ├── state.rs
│       └── term.rs
├── yazi-tty/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── handle.rs
│       ├── lib.rs
│       ├── tty.rs
│       └── windows.rs
├── yazi-vfs/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── cha.rs
│       ├── file.rs
│       ├── files.rs
│       ├── fns.rs
│       ├── lib.rs
│       ├── op.rs
│       └── provider/
│           ├── calculator.rs
│           ├── copier.rs
│           ├── dir_entry.rs
│           ├── gate.rs
│           ├── mod.rs
│           ├── provider.rs
│           ├── providers.rs
│           ├── read_dir.rs
│           ├── rw_file.rs
│           └── sftp/
│               ├── absolute.rs
│               ├── conn.rs
│               ├── gate.rs
│               ├── metadata.rs
│               ├── mod.rs
│               ├── read_dir.rs
│               └── sftp.rs
├── yazi-watcher/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── backend.rs
│       ├── lib.rs
│       ├── local/
│       │   ├── linked.rs
│       │   ├── local.rs
│       │   └── mod.rs
│       ├── remote/
│       │   ├── mod.rs
│       │   └── remote.rs
│       ├── reporter.rs
│       ├── watched.rs
│       ├── watchee.rs
│       └── watcher.rs
└── yazi-widgets/
    ├── Cargo.toml
    ├── README.md
    └── src/
        ├── clear.rs
        ├── clipboard.rs
        ├── input/
        │   ├── actor/
        │   │   ├── actor.rs
        │   │   ├── backspace.rs
        │   │   ├── backward.rs
        │   │   ├── casefy.rs
        │   │   ├── complete.rs
        │   │   ├── delete.rs
        │   │   ├── escape.rs
        │   │   ├── forward.rs
        │   │   ├── insert.rs
        │   │   ├── kill.rs
        │   │   ├── mod.rs
        │   │   ├── move.rs
        │   │   ├── paste.rs
        │   │   ├── redo.rs
        │   │   ├── replace.rs
        │   │   ├── type.rs
        │   │   ├── undo.rs
        │   │   ├── visual.rs
        │   │   └── yank.rs
        │   ├── event.rs
        │   ├── input.rs
        │   ├── mod.rs
        │   ├── mode.rs
        │   ├── op.rs
        │   ├── opt.rs
        │   ├── parser/
        │   │   ├── backspace.rs
        │   │   ├── backward.rs
        │   │   ├── casefy.rs
        │   │   ├── complete.rs
        │   │   ├── delete.rs
        │   │   ├── forward.rs
        │   │   ├── insert.rs
        │   │   ├── kill.rs
        │   │   ├── mod.rs
        │   │   ├── move.rs
        │   │   └── paste.rs
        │   ├── separator.rs
        │   ├── snap.rs
        │   ├── snaps.rs
        │   └── widget.rs
        ├── lib.rs
        ├── scrollable.rs
        └── step.rs

SYMBOL INDEX (5242 symbols across 788 files)

FILE: scripts/validate-form/main.js
  constant LABEL_NAME (line 1) | const LABEL_NAME = "needs info"
  constant RE_VERSION (line 2) | const RE_VERSION = /Yazi\s+Version\s*:\s\d+\.\d+\.\d+\s\(/gm
  constant RE_DEPENDENCIES (line 3) | const RE_DEPENDENCIES = /Dependencies\s+[/a-z]+\s*:\s/gm
  constant RE_CHECKLIST (line 4) | const RE_CHECKLIST = /#{3}\s+Checklist\s+(?:^-\s+\[x]\s+.+?(?:\n|\r\n|$)...
  function bugReportBody (line 6) | function bugReportBody(creator, content, hash) {
  function featureRequestBody (line 25) | function featureRequestBody(creator, content) {
  function nightlyHash (line 45) | async function nightlyHash() {
  function hasLabel (line 59) | async function hasLabel(id, label) {
  function lastLabeledAt (line 72) | async function lastLabeledAt(id) {
  function removedLabelManually (line 88) | async function removedLabelManually(id) {
  function updateLabels (line 104) | async function updateLabels(id, mark, body) {
  function hideOldComments (line 133) | async function hideOldComments(id) {
  function closeOldIssues (line 164) | async function closeOldIssues() {
  function closeUnsupportedIssue (line 197) | async function closeUnsupportedIssue(id) {
  function main (line 216) | async function main() {

FILE: yazi-actor/src/actor.rs
  type Actor (line 7) | pub trait Actor {
    constant NAME (line 10) | const NAME: &str;
    method act (line 12) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data>;
    method hook (line 14) | fn hook(_cx: &Ctx, _opt: &Self::Options) -> Option<SparkKind> { None }

FILE: yazi-actor/src/app/accept_payload.rs
  type AcceptPayload (line 13) | pub struct AcceptPayload;
  type Options (line 16) | type Options = Payload<'static>;
  constant NAME (line 18) | const NAME: &str = "accept_payload";
  method act (line 20) | fn act(cx: &mut Ctx, payload: Payload) -> Result<Data> {

FILE: yazi-actor/src/app/bootstrap.rs
  type Bootstrap (line 10) | pub struct Bootstrap;
  type Options (line 13) | type Options = VoidOpt;
  constant NAME (line 15) | const NAME: &str = "bootstrap";
  method act (line 17) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/app/deprecate.rs
  type Deprecate (line 8) | pub struct Deprecate;
  type Options (line 11) | type Options = DeprecateOpt;
  constant NAME (line 13) | const NAME: &str = "deprecate";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/app/focus.rs
  type Focus (line 9) | pub struct Focus;
  type Options (line 12) | type Options = VoidOpt;
  constant NAME (line 14) | const NAME: &str = "focus";
  method act (line 16) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> { act!(mgr:refres...

FILE: yazi-actor/src/app/mouse.rs
  type Mouse (line 15) | pub struct Mouse;
  type Options (line 18) | type Options = MouseOpt;
  constant NAME (line 20) | const NAME: &str = "mouse";
  method act (line 22) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/app/plugin.rs
  type Plugin (line 10) | pub struct Plugin;
  type Options (line 13) | type Options = PluginOpt;
  constant NAME (line 15) | const NAME: &str = "plugin";
  method act (line 17) | fn act(cx: &mut Ctx, mut opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/app/plugin_do.rs
  type PluginDo (line 15) | pub struct PluginDo;
  type Options (line 18) | type Options = PluginOpt;
  constant NAME (line 20) | const NAME: &str = "plugin_do";
  method act (line 22) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/app/quit.rs
  type Quit (line 10) | pub struct Quit;
    method cwd_to_file (line 35) | async fn cwd_to_file(cx: &Ctx<'_>, no: bool) {
    method selected_to_file (line 42) | async fn selected_to_file(selected: Option<StrandBuf>) {
  type Options (line 13) | type Options = QuitOpt;
  constant NAME (line 15) | const NAME: &str = "quit";
  method act (line 17) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/app/reflow.rs
  type Reflow (line 13) | pub struct Reflow;
  type Options (line 16) | type Options = ReflowOpt;
  constant NAME (line 18) | const NAME: &str = "reflow";
  method act (line 20) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/app/resize.rs
  type Resize (line 9) | pub struct Resize;
  type Options (line 12) | type Options = ReflowOpt;
  constant NAME (line 14) | const NAME: &str = "resize";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/app/resume.rs
  type Resume (line 9) | pub struct Resume;
  type Options (line 12) | type Options = ResumeOpt;
  constant NAME (line 14) | const NAME: &str = "resume";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/app/stop.rs
  type Stop (line 8) | pub struct Stop;
  type Options (line 11) | type Options = StopOpt;
  constant NAME (line 13) | const NAME: &str = "stop";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/app/title.rs
  type Title (line 13) | pub struct Title;
  type Options (line 16) | type Options = TitleOpt;
  constant NAME (line 18) | const NAME: &str = "title";
  method act (line 20) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
  method hook (line 28) | fn hook(cx: &Ctx, _opt: &Self::Options) -> Option<SparkKind> {

FILE: yazi-actor/src/app/update_progress.rs
  type UpdateProgress (line 9) | pub struct UpdateProgress;
  type Options (line 12) | type Options = UpdateProgressOpt;
  constant NAME (line 14) | const NAME: &str = "update_progress";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/cmp/arrow.rs
  type Arrow (line 9) | pub struct Arrow;
  type Options (line 12) | type Options = ArrowOpt;
  constant NAME (line 14) | const NAME: &str = "arrow";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/cmp/close.rs
  type Close (line 11) | pub struct Close;
  type Options (line 14) | type Options = CloseOpt;
  constant NAME (line 16) | const NAME: &str = "close";
  method act (line 18) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/cmp/show.rs
  constant LIMIT (line 10) | const LIMIT: usize = 30;
  type Show (line 12) | pub struct Show;
    method match_candidates (line 45) | fn match_candidates(word: PathDyn, cache: &[CmpItem]) -> Vec<CmpItem> {
  type Options (line 15) | type Options = ShowOpt;
  constant NAME (line 17) | const NAME: &str = "show";
  method act (line 19) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/cmp/trigger.rs
  type Trigger (line 13) | pub struct Trigger;
    method split_url (line 67) | fn split_url(s: &str) -> Option<(UrlBuf, PathBufDyn)> {
  type Options (line 16) | type Options = TriggerOpt;
  constant NAME (line 18) | const NAME: &str = "trigger";
  method act (line 20) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
  function compare (line 104) | fn compare(s: &str, parent: &str, child: &str) {
  function test_split (line 114) | fn test_split() {
  function test_split (line 144) | fn test_split() {

FILE: yazi-actor/src/confirm/arrow.rs
  type Arrow (line 8) | pub struct Arrow;
  type Options (line 11) | type Options = ArrowOpt;
  constant NAME (line 13) | const NAME: &str = "arrow";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/confirm/close.rs
  type Close (line 8) | pub struct Close;
  type Options (line 11) | type Options = CloseOpt;
  constant NAME (line 13) | const NAME: &str = "close";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/confirm/show.rs
  type Show (line 8) | pub struct Show;
  type Options (line 11) | type Options = ShowOpt;
  constant NAME (line 13) | const NAME: &str = "show";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/context.rs
  type Ctx (line 9) | pub struct Ctx<'a> {
  type Target (line 20) | type Target = Core;
  method deref (line 22) | fn deref(&self) -> &Self::Target { self.core }
  method deref_mut (line 26) | fn deref_mut(&mut self) -> &mut Self::Target { self.core }
  function new (line 31) | pub fn new(action: &Action, core: &'a mut Core, term: &'a mut Option<Ter...
  function renew (line 55) | pub fn renew<'b>(cx: &'a mut Ctx<'b>) -> Self {
  function active (line 69) | pub fn active(core: &'a mut Core, term: &'a mut Option<Term>) -> Self {
  function tabs (line 85) | pub fn tabs(&self) -> &Tabs { &self.mgr.tabs }
  function tabs_mut (line 88) | pub fn tabs_mut(&mut self) -> &mut Tabs { &mut self.mgr.tabs }
  function tab (line 91) | pub fn tab(&self) -> &Tab { &self.tabs()[self.tab] }
  function tab_mut (line 94) | pub fn tab_mut(&mut self) -> &mut Tab { &mut self.core.mgr.tabs[self.tab] }
  function cwd (line 97) | pub fn cwd(&self) -> &UrlBuf { self.tab().cwd() }
  function parent (line 100) | pub fn parent(&self) -> Option<&Folder> { self.tab().parent.as_ref() }
  function parent_mut (line 103) | pub fn parent_mut(&mut self) -> Option<&mut Folder> { self.tab_mut().par...
  function current (line 106) | pub fn current(&self) -> &Folder { &self.tab().current }
  function current_mut (line 109) | pub fn current_mut(&mut self) -> &mut Folder { &mut self.tab_mut().curre...
  function hovered (line 112) | pub fn hovered(&self) -> Option<&File> { self.tab().hovered() }
  function hovered_folder (line 115) | pub fn hovered_folder(&self) -> Option<&Folder> { self.tab().hovered_fol...
  function hovered_folder_mut (line 118) | pub fn hovered_folder_mut(&mut self) -> Option<&mut Folder> {
  function tasks (line 123) | pub fn tasks(&self) -> &Tasks { &self.tasks }
  function source (line 126) | pub fn source(&self) -> Source { if self.level != 1 { Source::Ind } else...

FILE: yazi-actor/src/core/preflight.rs
  type Preflight (line 9) | pub struct Preflight;
    method act (line 12) | pub fn act<'a>(cx: &mut Ctx, opt: (SparkKind, Spark<'a>)) -> Result<Sp...

FILE: yazi-actor/src/help/arrow.rs
  type Arrow (line 9) | pub struct Arrow;
  type Options (line 12) | type Options = ArrowOpt;
  constant NAME (line 14) | const NAME: &str = "arrow";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/help/escape.rs
  type Escape (line 8) | pub struct Escape;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "escape";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/help/filter.rs
  type Filter (line 8) | pub struct Filter;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "filter";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/help/toggle.rs
  type Toggle (line 8) | pub struct Toggle;
  type Options (line 11) | type Options = ToggleOpt;
  constant NAME (line 13) | const NAME: &str = "toggle";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/input/close.rs
  type Close (line 9) | pub struct Close;
  type Options (line 12) | type Options = CloseOpt;
  constant NAME (line 14) | const NAME: &str = "close";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/input/complete.rs
  type Complete (line 8) | pub struct Complete;
  type Options (line 11) | type Options = CompleteOpt;
  constant NAME (line 13) | const NAME: &str = "complete";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/input/escape.rs
  type Escape (line 9) | pub struct Escape;
  type Options (line 12) | type Options = VoidOpt;
  constant NAME (line 14) | const NAME: &str = "escape";
  method act (line 16) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/input/show.rs
  type Show (line 10) | pub struct Show;
  type Options (line 13) | type Options = InputOpt;
  constant NAME (line 15) | const NAME: &str = "show";
  method act (line 17) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/lives/core.rs
  type Core (line 8) | pub(super) struct Core {
    method make (line 26) | pub(super) fn make(inner: &yazi_core::Core) -> mlua::Result<AnyUserDat...
  type Target (line 20) | type Target = yazi_core::Core;
  method deref (line 22) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_methods (line 41) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-actor/src/lives/file.rs
  type File (line 11) | pub(super) struct File {
    method as_ref (line 34) | fn as_ref(&self) -> &yazi_fs::File { self }
    method make (line 38) | pub(super) fn make(
    method is_hovered (line 70) | fn is_hovered(&self) -> bool { self.idx == self.folder.cursor }
  type Target (line 28) | type Target = yazi_fs::File;
  method deref (line 30) | fn deref(&self) -> &Self::Target { &self.folder.files[self.idx] }
  method add_fields (line 74) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 86) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-actor/src/lives/files.rs
  type Files (line 8) | pub(super) struct Files {
    method make (line 23) | pub(super) fn make(
  type Target (line 17) | type Target = yazi_fs::Files;
  method deref (line 19) | fn deref(&self) -> &Self::Target { &self.folder.files }
  method add_fields (line 33) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 37) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-actor/src/lives/filter.rs
  type Filter (line 7) | pub(super) struct Filter {
    method make (line 18) | pub(super) fn make(inner: &yazi_fs::Filter) -> mlua::Result<AnyUserDat...
  type Target (line 12) | type Target = yazi_fs::Filter;
  method deref (line 14) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_methods (line 24) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-actor/src/lives/finder.rs
  type Finder (line 7) | pub(super) struct Finder {
    method make (line 18) | pub(super) fn make(inner: &yazi_core::tab::Finder) -> mlua::Result<Any...
  type Target (line 12) | type Target = yazi_core::tab::Finder;
  method deref (line 14) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_methods (line 24) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-actor/src/lives/folder.rs
  type Folder (line 9) | pub(super) struct Folder {
    method make (line 28) | pub(super) fn make(
  type Target (line 22) | type Target = yazi_core::tab::Folder;
  method deref (line 24) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_fields (line 56) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {

FILE: yazi-actor/src/lives/lives.rs
  type Lives (line 16) | pub struct Lives;
    method scope (line 19) | pub fn scope<T, F>(core: &yazi_core::Core, f: F) -> mlua::Result<T>
    method scoped_userdata (line 44) | pub(crate) fn scoped_userdata<T>(data: T) -> mlua::Result<AnyUserData>

FILE: yazi-actor/src/lives/mode.rs
  type Mode (line 7) | pub(super) struct Mode {
    method make (line 18) | pub(super) fn make(inner: &yazi_core::tab::Mode) -> mlua::Result<AnyUs...
  type Target (line 12) | type Target = yazi_core::tab::Mode;
  method deref (line 14) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_fields (line 24) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 30) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-actor/src/lives/preference.rs
  type Preference (line 8) | pub(super) struct Preference {
    method make (line 24) | pub(super) fn make(inner: &yazi_core::tab::Preference) -> mlua::Result...
  type Target (line 18) | type Target = yazi_core::tab::Preference;
  method deref (line 20) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_fields (line 37) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {

FILE: yazi-actor/src/lives/preview.rs
  type Preview (line 9) | pub(super) struct Preview {
    method make (line 22) | pub(super) fn make(tab: &yazi_core::tab::Tab) -> mlua::Result<AnyUserD...
  type Target (line 16) | type Target = yazi_core::tab::Preview;
  method deref (line 18) | fn deref(&self) -> &Self::Target { &self.tab.preview }
  method add_fields (line 28) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {

FILE: yazi-actor/src/lives/ptr.rs
  type PtrCell (line 3) | pub(super) struct PtrCell<T>(pub(super) *const T);
  type Target (line 6) | type Target = T;
  method deref (line 8) | fn deref(&self) -> &Self::Target { unsafe { &*self.0 } }
  function from (line 12) | fn from(value: &T) -> Self { Self(value) }
  method clone (line 16) | fn clone(&self) -> Self { *self }
  method eq (line 22) | fn eq(&self, other: &Self) -> bool { self.0.addr() == other.0.addr() }
  method hash (line 28) | fn hash<H: Hasher>(&self, state: &mut H) { state.write_usize(self.0.addr...
  function as_static (line 33) | pub(super) fn as_static(&self) -> &'static T { unsafe { &*self.0 } }

FILE: yazi-actor/src/lives/selected.rs
  type Selected (line 7) | pub(super) struct Selected;
    method make (line 10) | pub(super) fn make(inner: &yazi_core::tab::Selected) -> mlua::Result<A...

FILE: yazi-actor/src/lives/tab.rs
  type Tab (line 8) | pub(super) struct Tab {
    method make (line 28) | pub(super) fn make(inner: &yazi_core::tab::Tab) -> mlua::Result<AnyUse...
  type Target (line 22) | type Target = yazi_core::tab::Tab;
  method deref (line 24) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_fields (line 45) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 67) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-actor/src/lives/tabs.rs
  type Tabs (line 7) | pub(super) struct Tabs {
    method make (line 18) | pub(super) fn make(inner: &yazi_core::mgr::Tabs) -> mlua::Result<AnyUs...
  type Target (line 12) | type Target = yazi_core::mgr::Tabs;
  method deref (line 14) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_fields (line 24) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 28) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-actor/src/lives/task.rs
  type TaskSnap (line 8) | pub(super) struct TaskSnap {
    method make (line 22) | pub(super) fn make(inner: &yazi_scheduler::TaskSnap) -> mlua::Result<A...
  type Target (line 16) | type Target = yazi_scheduler::TaskSnap;
  method deref (line 18) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_fields (line 28) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {

FILE: yazi-actor/src/lives/tasks.rs
  type Tasks (line 9) | pub(super) struct Tasks {
    method make (line 23) | pub(super) fn make(inner: &yazi_core::tasks::Tasks) -> mlua::Result<An...
  type Target (line 17) | type Target = yazi_core::tasks::Tasks;
  method deref (line 19) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_fields (line 34) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {

FILE: yazi-actor/src/lives/which.rs
  type Which (line 8) | pub(super) struct Which {
    method make (line 22) | pub(super) fn make(inner: &yazi_core::which::Which) -> mlua::Result<An...
  type Target (line 16) | type Target = yazi_core::which::Which;
  method deref (line 18) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_fields (line 28) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {

FILE: yazi-actor/src/lives/yanked.rs
  type Yanked (line 8) | pub(super) struct Yanked {
    method make (line 20) | pub(super) fn make(inner: &yazi_core::mgr::Yanked) -> mlua::Result<Any...
  type Target (line 14) | type Target = yazi_core::mgr::Yanked;
  method deref (line 16) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_fields (line 34) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 38) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-actor/src/mgr/arrow.rs
  type Arrow (line 8) | pub struct Arrow;
  type Options (line 11) | type Options = ArrowOpt;
  constant NAME (line 13) | const NAME: &str = "arrow";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/back.rs
  type Back (line 8) | pub struct Back;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "back";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/bulk_rename.rs
  type BulkRename (line 23) | pub struct BulkRename;
    method r#do (line 89) | async fn r#do(
    method opener (line 160) | fn opener() -> Option<&'static OpenerRule> {
    method replace_url (line 164) | fn replace_url(url: &UrlBuf, take: usize, rep: &StrandBuf) -> Result<U...
    method output_failed (line 168) | async fn output_failed(failed: Vec<(Tuple, Tuple, anyhow::Error)>) -> ...
    method prioritized_paths (line 183) | fn prioritized_paths(old: Vec<Tuple>, new: Vec<Tuple>) -> Vec<(Tuple, ...
  type Options (line 26) | type Options = VoidOpt;
  constant NAME (line 28) | const NAME: &str = "bulk_rename";
  method act (line 30) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {
  type Tuple (line 224) | struct Tuple(usize, StrandBuf);
    method new (line 247) | fn new(index: usize, inner: impl Into<StrandBuf>) -> Self { Self(index...
  type Target (line 227) | type Target = StrandBuf;
  method deref (line 229) | fn deref(&self) -> &Self::Target { &self.1 }
  method eq (line 233) | fn eq(&self, other: &Self) -> bool { self.1 == other.1 }
  method hash (line 239) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) { self.1.hash(state); }
  method as_strand (line 243) | fn as_strand(&self) -> Strand<'_> { self.1.as_strand() }
  function test_sort (line 256) | fn test_sort() {

FILE: yazi-actor/src/mgr/cd.rs
  type Cd (line 18) | pub struct Cd;
    method cd_interactive (line 64) | fn cd_interactive(cx: &Ctx) -> Result<Data> {
  type Options (line 21) | type Options = CdOpt;
  constant NAME (line 23) | const NAME: &str = "cd";
  method act (line 25) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/close.rs
  type Close (line 8) | pub struct Close;
  type Options (line 11) | type Options = CloseOpt;
  constant NAME (line 13) | const NAME: &str = "close";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/copy.rs
  type Copy (line 9) | pub struct Copy;
  type Options (line 12) | type Options = CopyOpt;
  constant NAME (line 14) | const NAME: &str = "copy";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/create.rs
  type Create (line 14) | pub struct Create;
    method r#do (line 49) | async fn r#do(new: UrlBuf, dir: bool) -> Result<()> {
  type Options (line 17) | type Options = CreateOpt;
  constant NAME (line 19) | const NAME: &str = "create";
  method act (line 21) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/displace.rs
  type Displace (line 10) | pub struct Displace;
  type Options (line 13) | type Options = VoidOpt;
  constant NAME (line 15) | const NAME: &str = "displace";
  method act (line 17) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/displace_do.rs
  type DisplaceDo (line 9) | pub struct DisplaceDo;
  type Options (line 12) | type Options = DisplaceDoOpt;
  constant NAME (line 14) | const NAME: &str = "displace_do";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/download.rs
  type Download (line 15) | pub struct Download;
    method prepare (line 75) | async fn prepare(urls: &[UrlCow<'_>]) {
  type Options (line 18) | type Options = DownloadOpt;
  constant NAME (line 20) | const NAME: &str = "download";
  method act (line 22) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/enter.rs
  type Enter (line 8) | pub struct Enter;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "enter";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/escape.rs
  type Escape (line 9) | pub struct Escape;
  type Options (line 12) | type Options = EscapeOpt;
  constant NAME (line 14) | const NAME: &str = "escape";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
  type EscapeFind (line 46) | pub struct EscapeFind;
  type Options (line 49) | type Options = VoidOpt;
  constant NAME (line 51) | const NAME: &str = "escape_find";
  method act (line 53) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {
  type EscapeVisual (line 59) | pub struct EscapeVisual;
  type Options (line 62) | type Options = VoidOpt;
  constant NAME (line 64) | const NAME: &str = "escape_visual";
  method act (line 66) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {
  type EscapeFilter (line 91) | pub struct EscapeFilter;
  type Options (line 94) | type Options = VoidOpt;
  constant NAME (line 96) | const NAME: &str = "escape_filter";
  method act (line 98) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {
  type EscapeSelect (line 110) | pub struct EscapeSelect;
  type Options (line 113) | type Options = VoidOpt;
  constant NAME (line 115) | const NAME: &str = "escape_select";
  method act (line 117) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {
  type EscapeSearch (line 134) | pub struct EscapeSearch;
  type Options (line 137) | type Options = VoidOpt;
  constant NAME (line 139) | const NAME: &str = "escape_search";
  method act (line 141) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/filter.rs
  type Filter (line 15) | pub struct Filter;
  type Options (line 18) | type Options = FilterOpt;
  constant NAME (line 20) | const NAME: &str = "filter";
  method act (line 22) | fn act(_: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/filter_do.rs
  type FilterDo (line 9) | pub struct FilterDo;
  type Options (line 12) | type Options = FilterOpt;
  constant NAME (line 14) | const NAME: &str = "filter_do";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/find.rs
  type Find (line 15) | pub struct Find;
  type Options (line 18) | type Options = FindOpt;
  constant NAME (line 20) | const NAME: &str = "find";
  method act (line 22) | fn act(_: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/find_arrow.rs
  type FindArrow (line 8) | pub struct FindArrow;
  type Options (line 11) | type Options = FindArrowOpt;
  constant NAME (line 13) | const NAME: &str = "find_arrow";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/find_do.rs
  type FindDo (line 9) | pub struct FindDo;
  type Options (line 12) | type Options = FindDoOpt;
  constant NAME (line 14) | const NAME: &str = "find_do";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/follow.rs
  type Follow (line 9) | pub struct Follow;
  type Options (line 12) | type Options = VoidOpt;
  constant NAME (line 14) | const NAME: &str = "follow";
  method act (line 16) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/forward.rs
  type Forward (line 8) | pub struct Forward;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "forward";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/hardlink.rs
  type Hardlink (line 8) | pub struct Hardlink;
  type Options (line 11) | type Options = HardlinkOpt;
  constant NAME (line 13) | const NAME: &str = "hardlink";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/hidden.rs
  type Hidden (line 11) | pub struct Hidden;
  type Options (line 14) | type Options = HiddenOpt;
  constant NAME (line 16) | const NAME: &str = "hidden";
  method act (line 18) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
  method hook (line 55) | fn hook(cx: &Ctx, _: &Self::Options) -> Option<SparkKind> {

FILE: yazi-actor/src/mgr/hover.rs
  type Hover (line 9) | pub struct Hover;
  type Options (line 12) | type Options = HoverOpt;
  constant NAME (line 14) | const NAME: &str = "hover";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/leave.rs
  type Leave (line 8) | pub struct Leave;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "leave";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/linemode.rs
  type Linemode (line 8) | pub struct Linemode;
  type Options (line 11) | type Options = LinemodeOpt;
  constant NAME (line 13) | const NAME: &str = "linemode";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/link.rs
  type Link (line 8) | pub struct Link;
  type Options (line 11) | type Options = LinkOpt;
  constant NAME (line 13) | const NAME: &str = "link";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/open.rs
  type Open (line 12) | pub struct Open;
  type Options (line 15) | type Options = OpenOpt;
  constant NAME (line 17) | const NAME: &str = "open";
  method act (line 19) | fn act(cx: &mut Ctx, mut opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/open_do.rs
  type OpenDo (line 11) | pub struct OpenDo;
    method match_and_open (line 62) | fn match_and_open(cx: &Ctx, cwd: UrlCow<'static>, targets: Vec<(UrlCow...
  type Options (line 14) | type Options = OpenDoOpt;
  constant NAME (line 16) | const NAME: &str = "open_do";
  method act (line 18) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/paste.rs
  type Paste (line 8) | pub struct Paste;
  type Options (line 11) | type Options = PasteOpt;
  constant NAME (line 13) | const NAME: &str = "paste";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/peek.rs
  type Peek (line 8) | pub struct Peek;
  type Options (line 11) | type Options = PeekOpt;
  constant NAME (line 13) | const NAME: &str = "peek";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/quit.rs
  type Quit (line 14) | pub struct Quit;
    method with_selected (line 67) | pub(super) fn with_selected<I>(selected: I)
  type Options (line 17) | type Options = QuitOpt;
  constant NAME (line 19) | const NAME: &str = "quit";
  method act (line 21) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
  method hook (line 61) | fn hook(cx: &Ctx, _opt: &Self::Options) -> Option<SparkKind> {

FILE: yazi-actor/src/mgr/refresh.rs
  type Refresh (line 12) | pub struct Refresh;
    method cwd_changed (line 38) | fn cwd_changed() {
    method trigger_dirs (line 45) | fn trigger_dirs(folders: &[&Folder]) {
  type Options (line 15) | type Options = VoidOpt;
  constant NAME (line 17) | const NAME: &str = "refresh";
  method act (line 19) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/remove.rs
  type Remove (line 10) | pub struct Remove;
  type Options (line 13) | type Options = RemoveOpt;
  constant NAME (line 15) | const NAME: &str = "remove";
  method act (line 17) | fn act(cx: &mut Ctx, mut opt: Self::Options) -> Result<Data> {
  type RemoveDo (line 48) | pub struct RemoveDo;
  type Options (line 51) | type Options = RemoveOpt;
  constant NAME (line 53) | const NAME: &str = "remove_do";
  method act (line 55) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/rename.rs
  type Rename (line 15) | pub struct Rename;
    method r#do (line 68) | async fn r#do(tab: Id, old: UrlBuf, new: UrlBuf) -> Result<()> {
    method empty_url_part (line 100) | fn empty_url_part(url: &UrlBuf, by: &str) -> String {
  type Options (line 18) | type Options = RenameOpt;
  constant NAME (line 20) | const NAME: &str = "rename";
  method act (line 22) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/reveal.rs
  type Reveal (line 9) | pub struct Reveal;
  type Options (line 12) | type Options = RevealOpt;
  constant NAME (line 14) | const NAME: &str = "reveal";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/search.rs
  type Search (line 17) | pub struct Search;
  type Options (line 20) | type Options = SearchOpt;
  constant NAME (line 22) | const NAME: &str = "search";
  method act (line 24) | fn act(cx: &mut Ctx, mut opt: Self::Options) -> Result<Data> {
  type SearchDo (line 43) | pub struct SearchDo;
  type Options (line 46) | type Options = SearchOpt;
  constant NAME (line 48) | const NAME: &str = "search_do";
  method act (line 50) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
  type SearchStop (line 101) | pub struct SearchStop;
  type Options (line 104) | type Options = VoidOpt;
  constant NAME (line 106) | const NAME: &str = "search_stop";
  method act (line 108) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/seek.rs
  type Seek (line 10) | pub struct Seek;
  type Options (line 13) | type Options = SeekOpt;
  constant NAME (line 15) | const NAME: &str = "seek";
  method act (line 17) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/shell.rs
  type Shell (line 13) | pub struct Shell;
  type Options (line 16) | type Options = ShellOpt;
  constant NAME (line 18) | const NAME: &str = "shell";
  method act (line 20) | fn act(cx: &mut Ctx, mut opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/sort.rs
  type Sort (line 11) | pub struct Sort;
  type Options (line 14) | type Options = SortOpt;
  constant NAME (line 16) | const NAME: &str = "sort";
  method act (line 18) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
  method hook (line 62) | fn hook(cx: &Ctx, _: &Self::Options) -> Option<SparkKind> {

FILE: yazi-actor/src/mgr/spot.rs
  type Spot (line 8) | pub struct Spot;
  type Options (line 11) | type Options = SpotOpt;
  constant NAME (line 13) | const NAME: &str = "spot";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/stash.rs
  type Stash (line 9) | pub struct Stash;
  type Options (line 12) | type Options = StashOpt;
  constant NAME (line 14) | const NAME: &str = "stash";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
  method hook (line 24) | fn hook(cx: &Ctx, _opt: &Self::Options) -> Option<SparkKind> {

FILE: yazi-actor/src/mgr/suspend.rs
  type Suspend (line 8) | pub struct Suspend;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "suspend";
  method act (line 15) | fn act(_: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/tab_close.rs
  type TabClose (line 8) | pub struct TabClose;
  type Options (line 11) | type Options = TabCloseOpt;
  constant NAME (line 13) | const NAME: &str = "tab_close";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/tab_create.rs
  constant MAX_TABS (line 10) | const MAX_TABS: usize = 9;
  type TabCreate (line 12) | pub struct TabCreate;
  type Options (line 15) | type Options = TabCreateOpt;
  constant NAME (line 17) | const NAME: &str = "tab_create";
  method act (line 19) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/tab_rename.rs
  type TabRename (line 13) | pub struct TabRename;
  type Options (line 16) | type Options = TabRenameOpt;
  constant NAME (line 18) | const NAME: &str = "tab_rename";
  method act (line 20) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/tab_swap.rs
  type TabSwap (line 9) | pub struct TabSwap;
  type Options (line 12) | type Options = ArrowOpt;
  constant NAME (line 14) | const NAME: &str = "tab_swap";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/tab_switch.rs
  type TabSwitch (line 8) | pub struct TabSwitch;
  type Options (line 11) | type Options = TabSwitchOpt;
  constant NAME (line 13) | const NAME: &str = "tab_switch";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/toggle.rs
  type Toggle (line 9) | pub struct Toggle;
  type Options (line 12) | type Options = ToggleOpt;
  constant NAME (line 14) | const NAME: &str = "toggle";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/toggle_all.rs
  type ToggleAll (line 9) | pub struct ToggleAll;
  type Options (line 12) | type Options = ToggleAllOpt;
  constant NAME (line 14) | const NAME: &str = "toggle_all";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/unyank.rs
  type Unyank (line 8) | pub struct Unyank;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "unyank";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/update_files.rs
  type UpdateFiles (line 11) | pub struct UpdateFiles;
    method update_tab (line 42) | fn update_tab(cx: &mut Ctx, op: FilesOp) -> Result<Data> {
    method update_parent (line 57) | fn update_parent(cx: &mut Ctx, op: FilesOp) -> Result<Data> {
    method update_current (line 74) | fn update_current(cx: &mut Ctx, op: FilesOp) -> Result<Data> {
    method update_hovered (line 88) | fn update_hovered(cx: &mut Ctx, op: FilesOp) -> Result<Data> {
    method update_history (line 98) | fn update_history(cx: &mut Ctx, op: FilesOp) -> Result<Data> {
  type Options (line 14) | type Options = UpdateFilesOpt;
  constant NAME (line 16) | const NAME: &str = "update_files";
  method act (line 18) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/update_mimes.rs
  type UpdateMimes (line 10) | pub struct UpdateMimes;
  type Options (line 13) | type Options = UpdateMimesOpt;
  constant NAME (line 15) | const NAME: &str = "update_mimes";
  method act (line 17) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/update_paged.rs
  type UpdatePaged (line 8) | pub struct UpdatePaged;
  type Options (line 11) | type Options = UpdatePagedOpt;
  constant NAME (line 13) | const NAME: &str = "update_paged";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/update_peeked.rs
  type UpdatePeeked (line 8) | pub struct UpdatePeeked;
  type Options (line 11) | type Options = UpdatePeekedOpt;
  constant NAME (line 13) | const NAME: &str = "update_peeked";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/update_spotted.rs
  type UpdateSpotted (line 8) | pub struct UpdateSpotted;
  type Options (line 11) | type Options = UpdateSpottedOpt;
  constant NAME (line 13) | const NAME: &str = "update_spotted";
  method act (line 15) | fn act(cx: &mut Ctx, mut opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/update_yanked.rs
  type UpdateYanked (line 9) | pub struct UpdateYanked;
  type Options (line 12) | type Options = UpdateYankedOpt<'static>;
  constant NAME (line 14) | const NAME: &str = "update_yanked";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/upload.rs
  type Upload (line 8) | pub struct Upload;
  type Options (line 11) | type Options = UploadOpt;
  constant NAME (line 13) | const NAME: &str = "upload";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/visual_mode.rs
  type VisualMode (line 11) | pub struct VisualMode;
  type Options (line 14) | type Options = VisualModeOpt;
  constant NAME (line 16) | const NAME: &str = "visual_mode";
  method act (line 18) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/watch.rs
  type Watch (line 10) | pub struct Watch;
  type Options (line 13) | type Options = VoidOpt;
  constant NAME (line 15) | const NAME: &str = "watch";
  method act (line 17) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/mgr/yank.rs
  type Yank (line 9) | pub struct Yank;
  type Options (line 12) | type Options = YankOpt;
  constant NAME (line 14) | const NAME: &str = "yank";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/notify/push.rs
  type Push (line 12) | pub struct Push;
  type Options (line 15) | type Options = PushOpt;
  constant NAME (line 17) | const NAME: &str = "push";
  method act (line 19) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {
  method hook (line 32) | fn hook(cx: &Ctx, _: &Self::Options) -> Option<SparkKind> {

FILE: yazi-actor/src/notify/tick.rs
  type Tick (line 14) | pub struct Tick;
  type Options (line 17) | type Options = TickOpt;
  constant NAME (line 19) | const NAME: &str = "tick";
  method act (line 21) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/pick/arrow.rs
  type Arrow (line 9) | pub struct Arrow;
  type Options (line 12) | type Options = ArrowOpt;
  constant NAME (line 14) | const NAME: &str = "arrow";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/pick/close.rs
  type Close (line 8) | pub struct Close;
  type Options (line 11) | type Options = CloseOpt;
  constant NAME (line 13) | const NAME: &str = "close";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/pick/show.rs
  type Show (line 8) | pub struct Show;
  type Options (line 11) | type Options = ShowOpt;
  constant NAME (line 13) | const NAME: &str = "show";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/spot/arrow.rs
  type Arrow (line 8) | pub struct Arrow;
  type Options (line 11) | type Options = ArrowOpt;
  constant NAME (line 13) | const NAME: &str = "arrow";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/spot/close.rs
  type Close (line 8) | pub struct Close;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "close";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/spot/copy.rs
  type Copy (line 9) | pub struct Copy;
  type Options (line 12) | type Options = CopyOpt;
  constant NAME (line 14) | const NAME: &str = "copy";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/spot/swipe.rs
  type Swipe (line 8) | pub struct Swipe;
  type Options (line 11) | type Options = ArrowOpt;
  constant NAME (line 13) | const NAME: &str = "swipe";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/tasks/arrow.rs
  type Arrow (line 9) | pub struct Arrow;
  type Options (line 12) | type Options = ArrowOpt;
  constant NAME (line 14) | const NAME: &str = "arrow";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/tasks/cancel.rs
  type Cancel (line 8) | pub struct Cancel;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "cancel";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/tasks/close.rs
  type Close (line 8) | pub struct Close;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "close";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/tasks/inspect.rs
  type Inspect (line 17) | pub struct Inspect;
  type Options (line 20) | type Options = VoidOpt;
  constant NAME (line 22) | const NAME: &str = "inspect";
  method act (line 24) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/tasks/open_shell_compat.rs
  type OpenShellCompat (line 8) | pub struct OpenShellCompat;
  type Options (line 12) | type Options = ProcessOpenOpt;
  constant NAME (line 14) | const NAME: &str = "open_shell_compat";
  method act (line 16) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/tasks/process_open.rs
  type ProcessOpen (line 8) | pub struct ProcessOpen;
  type Options (line 11) | type Options = ProcessOpenOpt;
  constant NAME (line 13) | const NAME: &str = "process_open";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/tasks/show.rs
  type Show (line 8) | pub struct Show;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "show";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/tasks/update_succeed.rs
  type UpdateSucceed (line 8) | pub struct UpdateSucceed;
  type Options (line 11) | type Options = UpdateSucceedOpt;
  constant NAME (line 13) | const NAME: &str = "update_succeed";
  method act (line 15) | fn act(cx: &mut Ctx, opt: Self::Options) -> Result<Data> {

FILE: yazi-actor/src/which/activate.rs
  type Activate (line 10) | pub struct Activate;
  type Options (line 13) | type Options = ActivateOpt;
  constant NAME (line 15) | const NAME: &str = "activate";
  method act (line 17) | fn act(cx: &mut Ctx, mut opt: Self::Options) -> Result<Data> {
  method hook (line 35) | fn hook(cx: &Ctx, _opt: &Self::Options) -> Option<SparkKind> {

FILE: yazi-actor/src/which/dismiss.rs
  type Dismiss (line 8) | pub struct Dismiss;
  type Options (line 11) | type Options = VoidOpt;
  constant NAME (line 13) | const NAME: &str = "dismiss";
  method act (line 15) | fn act(cx: &mut Ctx, _: Self::Options) -> Result<Data> {

FILE: yazi-adapter/src/adapter.rs
  type Adapter (line 12) | pub enum Adapter {
    method image_show (line 39) | pub async fn image_show<P>(self, path: P, max: Rect) -> Result<Rect>
    method image_hide (line 58) | pub fn image_hide(self) -> Result<()> {
    method image_erase (line 62) | pub fn image_erase(self, area: Rect) -> Result<()> {
    method shown_load (line 74) | pub fn shown_load(self) -> Option<Rect> { SHOWN.get() }
    method shown_store (line 77) | pub(super) fn shown_store(area: Rect) { SHOWN.set(Some(area)); }
    method start (line 79) | pub(super) fn start(self) { drivers::Ueberzug::start(self); }
    method needs_ueberzug (line 82) | pub(super) fn needs_ueberzug(self) -> bool {
    method matches (line 88) | pub fn matches(emulator: &Emulator) -> Self {
  method fmt (line 25) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: yazi-adapter/src/adapters.rs
  type Adapters (line 5) | pub(super) struct Adapters(Vec<Adapter>);
    method from (line 18) | fn from(value: &yazi_emulator::Emulator) -> Self { value.kind.either_i...
    method from (line 22) | fn from(value: yazi_emulator::Brand) -> Self {
    method from (line 52) | fn from(value: yazi_emulator::Unknown) -> Self {
  type Target (line 8) | type Target = Vec<Adapter>;
  method deref (line 10) | fn deref(&self) -> &Self::Target { &self.0 }
  method deref_mut (line 14) | fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 }

FILE: yazi-adapter/src/drivers/chafa.rs
  type Chafa (line 12) | pub(crate) struct Chafa;
    method image_show (line 15) | pub(crate) async fn image_show(path: PathBuf, max: Rect) -> Result<Rec...
    method image_erase (line 71) | pub(crate) fn image_erase(area: Rect) -> Result<()> {

FILE: yazi-adapter/src/drivers/iip.rs
  type Iip (line 13) | pub(crate) struct Iip;
    method image_show (line 16) | pub(crate) async fn image_show(path: PathBuf, max: Rect) -> Result<Rec...
    method image_erase (line 29) | pub(crate) fn image_erase(area: Rect) -> Result<()> {
    method encode (line 40) | async fn encode(img: DynamicImage) -> Result<Vec<u8>> {

FILE: yazi-adapter/src/drivers/kgp.rs
  type Kgp (line 314) | pub(crate) struct Kgp;
    method image_show (line 317) | pub(crate) async fn image_show(path: PathBuf, max: Rect) -> Result<Rec...
    method image_erase (line 333) | pub(crate) fn image_erase(area: Rect) -> Result<()> {
    method encode (line 346) | async fn encode(img: DynamicImage) -> Result<Vec<u8>> {
    method place (line 383) | fn place(area: &Rect) -> Result<Vec<u8>> {
    method image_id (line 401) | fn image_id() -> u32 {

FILE: yazi-adapter/src/drivers/kgp_old.rs
  type KgpOld (line 13) | pub(crate) struct KgpOld;
    method image_show (line 16) | pub(crate) async fn image_show(path: PathBuf, max: Rect) -> Result<Rec...
    method image_erase (line 29) | pub(crate) fn image_erase(_: Rect) -> Result<()> {
    method encode (line 36) | async fn encode(img: DynamicImage) -> Result<Vec<u8>> {

FILE: yazi-adapter/src/drivers/sixel.rs
  type Sixel (line 13) | pub(crate) struct Sixel;
    method image_show (line 21) | pub(crate) async fn image_show(path: PathBuf, max: Rect) -> Result<Rec...
    method image_erase (line 34) | pub(crate) fn image_erase(area: Rect) -> Result<()> {
    method encode (line 45) | async fn encode(img: DynamicImage) -> Result<Vec<u8>> {
    method quantify (line 117) | fn quantify(rgb: &RgbImage, alpha: bool) -> Result<QuantizeOutput<Srgb...
  type QuantizeOutput (line 15) | struct QuantizeOutput<T> {

FILE: yazi-adapter/src/drivers/ueberzug.rs
  type Cmd (line 14) | type Cmd = Option<(PathBuf, Rect)>;
  type Ueberzug (line 18) | pub(crate) struct Ueberzug;
    method start (line 21) | pub(crate) fn start(adapter: Adapter) {
    method image_show (line 46) | pub(crate) async fn image_show(path: PathBuf, max: Rect) -> Result<Rec...
    method image_erase (line 70) | pub(crate) fn image_erase(_: Rect) -> Result<()> {
    method supported_compositor (line 81) | pub(crate) fn supported_compositor() -> bool {
    method create_demon (line 87) | fn create_demon(adapter: Adapter) -> Result<Child> {
    method adjust_rect (line 103) | fn adjust_rect(mut rect: Rect) -> Rect {
    method send_command (line 114) | async fn send_command(adapter: Adapter, child: &mut Child, cmd: Cmd) -...

FILE: yazi-adapter/src/icc.rs
  type Icc (line 5) | pub(super) struct Icc;
    method transform (line 7) | pub(super) fn transform(mut decoder: impl ImageDecoder) -> anyhow::Res...
    method color_type_to_layout (line 49) | fn color_type_to_layout(color_type: ColorType) -> Option<Layout> {
    method requires_transform (line 59) | fn requires_transform(profile: &ColorProfile) -> bool {

FILE: yazi-adapter/src/image.rs
  type Image (line 12) | pub struct Image;
    method precache (line 15) | pub async fn precache(src: PathBuf, cache: &Path) -> Result<()> {
    method downscale (line 43) | pub(super) async fn downscale(path: PathBuf, rect: Rect) -> Result<Dyn...
    method max_pixel (line 66) | pub(super) fn max_pixel(rect: Rect) -> (u16, u16) {
    method pixel_area (line 75) | pub(super) fn pixel_area(size: (u32, u32), rect: Rect) -> Rect {
    method filter (line 86) | fn filter() -> FilterType {
    method decode_from (line 97) | async fn decode_from(path: PathBuf) -> Result<(DynamicImage, Orientati...
    method flip_size (line 121) | fn flip_size(orientation: Orientation, (w, h): (u16, u16)) -> (u32, u3...

FILE: yazi-adapter/src/info.rs
  type ImageFormat (line 5) | pub type ImageFormat = image::ImageFormat;
  type ImageColor (line 6) | pub type ImageColor = image::ColorType;
  type ImageOrientation (line 7) | pub type ImageOrientation = image::metadata::Orientation;
  type ImageInfo (line 10) | pub struct ImageInfo {
    method new (line 19) | pub async fn new(path: PathBuf) -> image::ImageResult<Self> {

FILE: yazi-adapter/src/lib.rs
  function init (line 16) | pub fn init() -> anyhow::Result<()> {

FILE: yazi-binding/src/access.rs
  type Access (line 7) | pub struct Access(yazi_vfs::provider::Gate);
  method add_methods (line 10) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/calculator.rs
  type SizeCalculator (line 5) | pub enum SizeCalculator {
  method add_fields (line 11) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 20) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/cha.rs
  type Cha (line 7) | pub struct Cha(pub yazi_fs::cha::Cha);
    method install (line 16) | pub fn install(lua: &Lua) -> mlua::Result<()> {
  type Target (line 10) | type Target = yazi_fs::cha::Cha;
  method deref (line 12) | fn deref(&self) -> &Self::Target { &self.0 }
  method add_fields (line 53) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 78) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/chan.rs
  type MpscTx (line 7) | pub struct MpscTx<T: FromLua + 'static>(pub tokio::sync::mpsc::Sender<T>);
  type MpscRx (line 8) | pub struct MpscRx<T: IntoLua + 'static>(pub tokio::sync::mpsc::Receiver<...
  method add_methods (line 11) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
  method add_methods (line 22) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
  type MpscUnboundedTx (line 33) | pub struct MpscUnboundedTx<T: FromLua + 'static>(pub tokio::sync::mpsc::...
  type MpscUnboundedRx (line 34) | pub struct MpscUnboundedRx<T: IntoLua + 'static>(pub tokio::sync::mpsc::...
  method add_methods (line 37) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
  method add_methods (line 46) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
  type OneshotTx (line 57) | pub struct OneshotTx<T: FromLua + 'static>(pub Option<tokio::sync::onesh...
  type OneshotRx (line 58) | pub struct OneshotRx<T: IntoLua + 'static>(pub Option<tokio::sync::onesh...
  method add_methods (line 61) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
  method add_methods (line 75) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/chord_cow.rs
  type ChordCow (line 5) | pub struct ChordCow(pub yazi_config::keymap::ChordCow);
    method from (line 8) | fn from(value: yazi_config::keymap::ChordCow) -> Self { Self(value) }
  function from (line 12) | fn from(value: ChordCow) -> Self { value.0 }

FILE: yazi-binding/src/color.rs
  type Color (line 6) | pub struct Color(pub ratatui::style::Color);
  method from_lua (line 9) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {

FILE: yazi-binding/src/composer.rs
  type ComposerGet (line 4) | pub type ComposerGet = fn(&Lua, &[u8]) -> mlua::Result<Value>;
  type ComposerSet (line 5) | pub type ComposerSet = fn(&Lua, &[u8], Value) -> mlua::Result<Value>;
  type Composer (line 7) | pub struct Composer<G, S> {
  function new (line 20) | pub fn new(get: G, set: S) -> Self { Self { get, set, parent: None, cach...
  function with_parent (line 23) | pub fn with_parent(get: G, set: S, p_get: G, p_set: S) -> Self {
  method add_methods (line 33) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/align.rs
  type Align (line 6) | pub struct Align(pub(super) ratatui::layout::Alignment);
    method compose (line 15) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
  type Target (line 9) | type Target = ratatui::layout::Alignment;
  method deref (line 11) | fn deref(&self) -> &Self::Target { &self.0 }
  method from_lua (line 21) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {

FILE: yazi-binding/src/elements/area.rs
  constant EXPECTED (line 7) | const EXPECTED: &str = "expected a Pos or Rect";
  type Area (line 10) | pub enum Area {
    method size (line 20) | pub fn size(self) -> ratatui::layout::Size {
    method inner (line 29) | pub fn inner(self, padding: ratatui::widgets::Padding) -> Self {
    method transform (line 39) | pub fn transform(
    method from (line 51) | fn from(rect: Rect) -> Self { Self::Rect(rect) }
    method from (line 55) | fn from(rect: ratatui::layout::Rect) -> Self { Self::Rect(rect.into()) }
    type Error (line 59) | type Error = mlua::Error;
    method try_from (line 61) | fn try_from(value: AnyUserData) -> Result<Self, Self::Error> {
  method default (line 16) | fn default() -> Self { Self::Rect(Default::default()) }
  method from_lua (line 73) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
  method into_lua (line 82) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {
  method fmt (line 91) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: yazi-binding/src/elements/bar.rs
  type Bar (line 7) | pub struct Bar {
    method compose (line 16) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
  method render (line 27) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method render (line 36) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method add_methods (line 80) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/border.rs
  constant PLAIN (line 8) | const PLAIN: u8 = 0;
  constant ROUNDED (line 9) | const ROUNDED: u8 = 1;
  constant DOUBLE (line 10) | const DOUBLE: u8 = 2;
  constant THICK (line 11) | const THICK: u8 = 3;
  constant QUADRANT_INSIDE (line 12) | const QUADRANT_INSIDE: u8 = 4;
  constant QUADRANT_OUTSIDE (line 13) | const QUADRANT_OUTSIDE: u8 = 5;
  type Border (line 16) | pub struct Border {
    method compose (line 27) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
  method render (line 48) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method render (line 69) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method add_methods (line 78) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/cell.rs
  type Cell (line 6) | pub struct Cell {
  function from (line 11) | fn from(value: Cell) -> Self { Self::new(value.text) }
  method from_lua (line 15) | fn from_lua(value: Value, lua: &Lua) -> mlua::Result<Self> {

FILE: yazi-binding/src/elements/clear.rs
  type Clear (line 7) | pub struct Clear {
    method compose (line 12) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
  method render (line 23) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method render (line 32) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method add_methods (line 41) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/constraint.rs
  type Constraint (line 4) | pub struct Constraint(pub(super) ratatui::layout::Constraint);
    method compose (line 7) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
  function from (line 24) | fn from(value: Constraint) -> Self { value.0 }

FILE: yazi-binding/src/elements/edge.rs
  type Edge (line 7) | pub struct Edge(pub Borders);
    method compose (line 16) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
  type Target (line 10) | type Target = Borders;
  method deref (line 12) | fn deref(&self) -> &Self::Target { &self.0 }
  method from_lua (line 31) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {

FILE: yazi-binding/src/elements/elements.rs
  function compose (line 7) | pub fn compose(p_get: ComposerGet, p_set: ComposerSet) -> Composer<Compo...
  function render_once (line 39) | pub fn render_once<F>(value: Value, buf: &mut ratatui::buffer::Buffer, t...

FILE: yazi-binding/src/elements/gauge.rs
  type Gauge (line 8) | pub struct Gauge {
    method compose (line 18) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
  method render (line 29) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method render (line 47) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method add_methods (line 56) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/layout.rs
  constant HORIZONTAL (line 5) | const HORIZONTAL: bool = true;
  constant VERTICAL (line 6) | const VERTICAL: bool = false;
  type Layout (line 9) | pub struct Layout {
    method compose (line 16) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
  method add_methods (line 27) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/line.rs
  constant EXPECTED (line 11) | const EXPECTED: &str = "expected a string, Span, Line, or a table of them";
  type Line (line 14) | pub struct Line {
    method compose (line 31) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
    type Error (line 55) | type Error = mlua::Error;
    method try_from (line 57) | fn try_from(tb: Table) -> Result<Self, Self::Error> {
  type Target (line 21) | type Target = ratatui::text::Line<'static>;
  method deref (line 23) | fn deref(&self) -> &Self::Target { &self.inner }
  method deref_mut (line 27) | fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner }
  function from (line 80) | fn from(value: Line) -> Self { value.inner }
  method render (line 84) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method render (line 93) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method from_lua (line 102) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
  method add_methods (line 124) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
  function truncate (line 232) | fn truncate(s: &str, max: usize, rtl: bool) -> String {
  function test_truncate (line 246) | fn test_truncate() {
  function test_truncate_rtl (line 260) | fn test_truncate_rtl() {
  function test_truncate_oboe (line 274) | fn test_truncate_oboe() {
  function test_truncate_exact (line 285) | fn test_truncate_exact() {
  function test_truncate_overflow (line 294) | fn test_truncate_overflow() {

FILE: yazi-binding/src/elements/list.rs
  type List (line 8) | pub struct List {
    method compose (line 15) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
  method render (line 28) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method render (line 37) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method add_methods (line 46) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/pad.rs
  type Pad (line 6) | pub struct Pad(ratatui::widgets::Padding);
    method from (line 15) | fn from(pad: ratatui::widgets::Padding) -> Self { Self(pad) }
    method compose (line 19) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
    type Output (line 64) | type Output = Self;
    method add (line 66) | fn add(self, rhs: ratatui::widgets::Padding) -> Self::Output {
    method add_assign (line 77) | fn add_assign(&mut self, rhs: ratatui::widgets::Padding) { *self = *se...
  type Target (line 9) | type Target = ratatui::widgets::Padding;
  method deref (line 11) | fn deref(&self) -> &Self::Target { &self.0 }
  method add_fields (line 55) | fn add_fields<F: mlua::UserDataFields<Self>>(fields: &mut F) {

FILE: yazi-binding/src/elements/pos.rs
  constant EXPECTED (line 7) | const EXPECTED: &str = "expected a Pos";
  type Pos (line 10) | pub struct Pos {
    method from (line 23) | fn from(value: yazi_config::popup::Position) -> Self {
    type Error (line 33) | type Error = mlua::Error;
    method try_from (line 35) | fn try_from(t: Table) -> Result<Self, Self::Error> {
    method compose (line 67) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
    method with_height (line 76) | pub fn with_height(mut self, height: u16) -> Self {
  type Target (line 17) | type Target = yazi_config::popup::Position;
  method deref (line 19) | fn deref(&self) -> &Self::Target { &self.inner }
  function from (line 29) | fn from(value: Pos) -> Self { value.inner }
  method from_lua (line 51) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
  method add_fields (line 83) | fn add_fields<F: mlua::UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 92) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/rect.rs
  type Rect (line 8) | pub struct Rect(pub ratatui::layout::Rect);
    method from (line 17) | fn from(rect: ratatui::layout::Rect) -> Self { Self(rect) }
    method from (line 21) | fn from(size: ratatui::layout::Size) -> Self {
    method compose (line 27) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
    method pad (line 42) | pub(super) fn pad(self, pad: Pad) -> Self {
  type Target (line 11) | type Target = ratatui::layout::Rect;
  method deref (line 13) | fn deref(&self) -> &Self::Target { &self.0 }
  method add_fields (line 54) | fn add_fields<F: mlua::UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 71) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/renderable.rs
  type Renderable (line 10) | pub enum Renderable {
    method area (line 22) | pub fn area(&self) -> Area {
    method with_area (line 35) | pub fn with_area(mut self, area: impl Into<Area>) -> Self {
    method render_with (line 50) | pub fn render_with<T>(self, buf: &mut ratatui::buffer::Buffer, trans: T)
    type Error (line 60) | type Error = mlua::Error;
    method try_from (line 62) | fn try_from(ud: &AnyUserData) -> Result<Self, Self::Error> {
    method from (line 78) | fn from(error: Error) -> Self {
  method render (line 88) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method render (line 106) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method from_lua (line 124) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {

FILE: yazi-binding/src/elements/row.rs
  constant EXPECTED (line 5) | const EXPECTED: &str = "expected a Row";
  type Row (line 8) | pub struct Row {
    method compose (line 17) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
  function from (line 30) | fn from(value: Row) -> Self {
  method from_lua (line 40) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
  method add_methods (line 55) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/span.rs
  constant EXPECTED (line 6) | const EXPECTED: &str = "expected a string or Span";
  type Span (line 8) | pub struct Span(pub(super) ratatui::text::Span<'static>);
    method compose (line 21) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
    method truncate (line 30) | pub(super) fn truncate(&mut self, max: usize) -> usize {
  type Target (line 11) | type Target = ratatui::text::Span<'static>;
  method deref (line 13) | fn deref(&self) -> &Self::Target { &self.0 }
  method deref_mut (line 17) | fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 }
  method from_lua (line 62) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
  method add_methods (line 78) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/table.rs
  type Table (line 9) | pub struct Table {
    method compose (line 33) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
    method selected_cell (line 44) | pub fn selected_cell(&self) -> Option<&ratatui::text::Text<'_>> {
    method len (line 50) | pub fn len(&self) -> usize { self.rows.len() }
    method select (line 52) | pub fn select(&mut self, idx: Option<usize>) {
    method selected (line 58) | pub fn selected(&self) -> Option<usize> {
    type Error (line 64) | type Error = mlua::Error;
    method try_from (line 66) | fn try_from(value: AnyUserData) -> Result<Self, Self::Error> { value.t...
  method render (line 70) | fn render(mut self, rect: ratatui::layout::Rect, buf: &mut ratatui::buff...
  method render (line 99) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method add_methods (line 108) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/text.rs
  constant EXPECTED (line 10) | const EXPECTED: &str = "expected a string, Line, Span, or a table of them";
  type Text (line 13) | pub struct Text {
    method compose (line 23) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
    type Error (line 37) | type Error = mlua::Error;
    method try_from (line 39) | fn try_from(tb: Table) -> Result<Self, Self::Error> {
  function from (line 58) | fn from(value: Text) -> Self { value.inner }
  function from (line 62) | fn from(mut value: Text) -> Self {
  method render (line 78) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method render (line 91) | fn render(self, rect: ratatui::layout::Rect, buf: &mut ratatui::buffer::...
  method from_lua (line 104) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
  method add_methods (line 122) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/elements/wrap.rs
  type Wrap (line 7) | pub struct Wrap(pub(super) Option<ratatui::widgets::Wrap>);
    method compose (line 16) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
    method from (line 26) | fn from(value: ratatui::widgets::Wrap) -> Self { Self(Some(value)) }
    method from (line 30) | fn from(value: PreviewWrap) -> Self {
  type Target (line 10) | type Target = Option<ratatui::widgets::Wrap>;
  method deref (line 12) | fn deref(&self) -> &Self::Target { &self.0 }
  function from (line 22) | fn from(value: Wrap) -> Self { value.0 }
  method from_lua (line 39) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
  method into_lua (line 61) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-binding/src/error.rs
  type Error (line 8) | pub enum Error {
    method install (line 16) | pub fn install(lua: &Lua) -> mlua::Result<()> {
    method custom (line 33) | pub fn custom(msg: impl Into<SStr>) -> Self { Self::Custom(msg.into()) }
    method into_string (line 35) | pub fn into_string(self) -> SStr {
  method fmt (line 46) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method add_fields (line 57) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 74) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/fd.rs
  type Fd (line 6) | pub struct Fd(pub yazi_vfs::provider::RwFile);
  method add_methods (line 9) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/file.rs
  type FileRef (line 7) | pub type FileRef = UserDataRef<File>;
  constant EXPECTED (line 9) | const EXPECTED: &str = "expected a table, File, or fs::File";
  type File (line 12) | pub struct File {
    method new (line 35) | pub fn new(inner: impl Into<yazi_fs::File>) -> Self {
    method install (line 48) | pub fn install(lua: &Lua) -> mlua::Result<()> {
    type Error (line 54) | type Error = mlua::Error;
    method try_from (line 56) | fn try_from(value: Table) -> Result<Self, Self::Error> {
    type Error (line 66) | type Error = mlua::Error;
    method try_from (line 68) | fn try_from(value: AnyUserData) -> Result<Self, Self::Error> {
  type Target (line 25) | type Target = yazi_fs::File;
  method deref (line 27) | fn deref(&self) -> &Self::Target { &self.inner }
  function from (line 31) | fn from(value: File) -> Self { value.inner }
  method from_lua (line 74) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
  method add_fields (line 84) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 88) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/handle.rs
  type Handle (line 4) | pub enum Handle {
  method add_methods (line 9) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/icon.rs
  type Icon (line 7) | pub struct Icon {
    method from (line 21) | fn from(icon: &'static yazi_config::Icon) -> Self {
  type Target (line 15) | type Target = yazi_config::Icon;
  method deref (line 17) | fn deref(&self) -> &Self::Target { self.inner }
  method add_fields (line 27) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {

FILE: yazi-binding/src/id.rs
  type Id (line 6) | pub struct Id(pub yazi_shared::Id);
  type Target (line 9) | type Target = yazi_shared::Id;
  method deref (line 11) | fn deref(&self) -> &Self::Target { &self.0 }
  method from_lua (line 15) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
  method add_fields (line 25) | fn add_fields<F: mlua::UserDataFields<Self>>(fields: &mut F) {

FILE: yazi-binding/src/image.rs
  type ImageInfo (line 5) | pub struct ImageInfo(yazi_adapter::ImageInfo);
    method from (line 14) | fn from(value: yazi_adapter::ImageInfo) -> Self { Self(value) }
  type Target (line 8) | type Target = yazi_adapter::ImageInfo;
  method deref (line 10) | fn deref(&self) -> &Self::Target { &self.0 }
  method add_fields (line 18) | fn add_fields<F: mlua::UserDataFields<Self>>(fields: &mut F) {
  type ImageFormat (line 28) | struct ImageFormat(yazi_adapter::ImageFormat);
  method add_methods (line 31) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {
  type ImageColor (line 58) | struct ImageColor(yazi_adapter::ImageColor);
  method add_methods (line 61) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/input.rs
  type InputRx (line 8) | pub struct InputRx<T: StreamExt<Item = InputEvent>> {
  function new (line 13) | pub fn new(inner: T) -> Self { Self { inner } }
  function consume (line 15) | pub async fn consume(inner: T) -> (Option<String>, u8) {
  function parse (line 20) | fn parse(res: InputEvent) -> (Option<String>, u8) {
  method add_methods (line 31) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/iter.rs
  type Iter (line 3) | pub struct Iter<I: Iterator<Item = T>, T> {
  function new (line 16) | pub fn new(iter: I, len: Option<usize>) -> Self { Self { iter, len, coun...
  function into_iter (line 24) | pub fn into_iter(self, lua: &Lua) -> impl Iterator<Item = mlua::Result<T...
  method add_methods (line 38) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/layer.rs
  type Layer (line 4) | pub struct Layer(yazi_shared::Layer);
    method from (line 7) | fn from(event: yazi_shared::Layer) -> Self { Self(event) }
  method add_methods (line 11) | fn add_methods<M: mlua::UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/mouse.rs
  type MouseEvent (line 7) | pub struct MouseEvent(crossterm::event::MouseEvent);
    method from (line 16) | fn from(event: crossterm::event::MouseEvent) -> Self { Self(event) }
  type Target (line 10) | type Target = crossterm::event::MouseEvent;
  method deref (line 12) | fn deref(&self) -> &Self::Target { &self.0 }
  method add_fields (line 20) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {

FILE: yazi-binding/src/path.rs
  type PathRef (line 9) | pub type PathRef = UserDataRef<Path>;
  type Path (line 12) | pub struct Path {
    method new (line 40) | pub fn new(path: impl Into<PathBufDyn>) -> Self {
    method install (line 51) | pub fn install(lua: &Lua) -> mlua::Result<()> {
    method ends_with (line 63) | fn ends_with(&self, child: Value) -> mlua::Result<bool> {
    method join (line 73) | fn join(&self, other: Value) -> mlua::Result<Self> {
    method starts_with (line 86) | fn starts_with(&self, base: Value) -> mlua::Result<bool> {
    method strip_prefix (line 96) | fn strip_prefix(&self, base: Value) -> mlua::Result<Option<Self>> {
  type Target (line 22) | type Target = PathBufDyn;
  method deref (line 24) | fn deref(&self) -> &Self::Target { &self.inner }
  method from (line 28) | fn from(value: Path) -> Self { value.inner }
  method as_strand (line 32) | fn as_strand(&self) -> Strand<'_> { self.inner.as_strand() }
  method as_strand (line 36) | fn as_strand(&self) -> Strand<'_> { self.inner.as_strand() }
  method add_fields (line 112) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 128) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/permit.rs
  type PermitRef (line 7) | pub type PermitRef = mlua::UserDataRef<Permit>;
  type Permit (line 9) | pub struct Permit {
    method new (line 21) | pub fn new<F>(inner: SemaphorePermit<'static>, f: F) -> Self
    method dropping (line 28) | fn dropping(&mut self) -> impl Future<Output = ()> + 'static {
  type Target (line 15) | type Target = Option<SemaphorePermit<'static>>;
  method deref (line 17) | fn deref(&self) -> &Self::Target { &self.inner }
  method drop (line 44) | fn drop(&mut self) { tokio::spawn(self.dropping()); }
  method add_methods (line 48) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/range.rs
  type Range (line 3) | pub struct Range<T>(std::ops::Range<T>);
  function from (line 6) | fn from(value: std::ops::Range<T>) -> Self { Self(value) }
  method into_lua (line 13) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-binding/src/runtime.rs
  type Runtime (line 8) | pub struct Runtime {
    method new_isolate (line 20) | pub fn new_isolate(id: &str) -> Self {
    method push (line 24) | pub fn push(&mut self, id: &str) { self.frames.push_back(RuntimeFrame ...
    method pop (line 26) | pub fn pop(&mut self) -> Result<RuntimeFrame> {
    method critical_push (line 30) | pub fn critical_push(&mut self, id: &str, blocking: bool) -> bool {
    method critical_pop (line 35) | pub fn critical_pop(&mut self, blocking: bool) -> Result<RuntimeFrame> {
    method current (line 40) | pub fn current(&self) -> Result<&str> {
    method current_owned (line 44) | pub fn current_owned(&self) -> Result<String> { self.current().map(ToO...
    method get_block (line 46) | pub fn get_block(&self, id: &str, calls: usize) -> Option<Function> {
    method put_block (line 50) | pub fn put_block(&mut self, f: &Function) -> Option<usize> {
  type RuntimeFrame (line 15) | pub struct RuntimeFrame {

FILE: yazi-binding/src/scheme.rs
  type Scheme (line 9) | pub struct Scheme {
    method new (line 23) | pub fn new(scheme: impl Into<yazi_shared::scheme::Scheme>) -> Self {
  type Target (line 17) | type Target = yazi_shared::scheme::Scheme;
  method deref (line 19) | fn deref(&self) -> &Self::Target { &self.inner }
  method add_fields (line 29) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {

FILE: yazi-binding/src/stage.rs
  type FolderStage (line 3) | pub struct FolderStage(yazi_fs::FolderStage);
    method new (line 6) | pub fn new(inner: yazi_fs::FolderStage) -> Self { Self(inner) }
  method add_methods (line 10) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/style.rs
  type Style (line 6) | pub struct Style(pub ratatui::style::Style);
    method compose (line 9) | pub fn compose(lua: &Lua) -> mlua::Result<Value> {
    method from (line 20) | fn from(value: yazi_config::Style) -> Self { Self(value.into()) }
  method from_lua (line 24) | fn from_lua(value: Value, _: &Lua) -> mlua::Result<Self> {
  method add_methods (line 34) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/url.rs
  type UrlRef (line 10) | pub type UrlRef = UserDataRef<Url>;
  constant EXPECTED (line 12) | const EXPECTED: &str = "expected a string, Url, or Path";
  type Url (line 15) | pub struct Url {
    type Error (line 59) | type Error = mlua::Error;
    method try_from (line 61) | fn try_from(value: &[u8]) -> mlua::Result<Self> { Ok(Self::new(UrlCow:...
    method new (line 65) | pub fn new(url: impl Into<yazi_shared::url::UrlBuf>) -> Self {
    method install (line 84) | pub fn install(lua: &Lua) -> mlua::Result<()> {
    method ends_with (line 105) | fn ends_with(&self, child: Value) -> mlua::Result<bool> {
    method hash (line 113) | fn hash(&self, long: Option<bool>) -> mlua::Result<String> {
    method join (line 121) | fn join(&self, lua: &Lua, other: Value) -> mlua::Result<Value> {
    method starts_with (line 144) | fn starts_with(&self, base: Value) -> mlua::Result<bool> {
    method strip_prefix (line 152) | fn strip_prefix(&self, base: Value) -> mlua::Result<Option<Path>> {
  type Target (line 33) | type Target = yazi_shared::url::UrlBuf;
  method deref (line 35) | fn deref(&self) -> &Self::Target { &self.inner }
  method as_url (line 39) | fn as_url(&self) -> yazi_shared::url::Url<'_> { self.inner.as_url() }
  method as_url (line 43) | fn as_url(&self) -> yazi_shared::url::Url<'_> { self.inner.as_url() }
  function from (line 47) | fn from(value: Url) -> Self { value.inner }
  function from (line 51) | fn from(value: Url) -> Self { Self(value.inner) }
  function from (line 55) | fn from(value: Url) -> Self { value.inner.into() }
  method add_fields (line 168) | fn add_fields<F: UserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 199) | fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {

FILE: yazi-binding/src/utils.rs
  constant SER_OPT (line 3) | pub const SER_OPT: SerializeOptions =
  function get_metatable (line 6) | pub fn get_metatable(lua: &Lua, value: impl IntoLua) -> mlua::Result<Tab...

FILE: yazi-boot/build.rs
  function main (line 10) | fn main() -> Result<(), Box<dyn Error>> {

FILE: yazi-boot/src/actions/actions.rs
  type Actions (line 3) | pub struct Actions;
    method act (line 6) | pub(crate) fn act(args: &crate::Args) {

FILE: yazi-boot/src/actions/clear_cache.rs
  method clear_cache (line 7) | pub(super) fn clear_cache() {

FILE: yazi-boot/src/actions/debug.rs
  method debug (line 12) | pub(super) fn debug() -> Result<String, std::fmt::Error> {
  method config_state (line 130) | fn config_state(name: &str) -> String {
  method process_output (line 140) | fn process_output(name: impl AsRef<OsStr>, arg: impl AsRef<OsStr>) -> St...
  method file1_output (line 165) | fn file1_output() -> String {

FILE: yazi-boot/src/actions/rustc.rs
  method rustc (line 4) | pub(super) fn rustc() -> String {

FILE: yazi-boot/src/actions/triple.rs
  method triple (line 4) | pub(super) fn triple() -> String {

FILE: yazi-boot/src/actions/version.rs
  method version (line 4) | pub fn version() -> &'static str {

FILE: yazi-boot/src/args.rs
  type Args (line 9) | pub struct Args {

FILE: yazi-boot/src/boot.rs
  type Boot (line 10) | pub struct Boot {
    method parse_entries (line 24) | async fn parse_entries(entries: &[UrlBuf]) -> (Vec<UrlBuf>, Vec<Strand...
    method from (line 54) | fn from(args: &crate::Args) -> Self {

FILE: yazi-boot/src/lib.rs
  function init (line 11) | pub fn init() {
  function init_default (line 18) | pub fn init_default() {

FILE: yazi-build/build.rs
  function main (line 5) | fn main() -> Result<(), Box<dyn Error>> {
  function flash (line 55) | fn flash<R: Read + Send + 'static>(src: R) -> thread::JoinHandle<()> {

FILE: yazi-build/src/main.rs
  function main (line 1) | fn main() {

FILE: yazi-cli/build.rs
  function main (line 10) | fn main() -> Result<(), Box<dyn Error>> {
  function generate (line 24) | fn generate() -> Result<(), Box<dyn Error>> {

FILE: yazi-cli/src/args.rs
  type Args (line 9) | pub(super) struct Args {
  type Command (line 19) | pub(super) enum Command {
  type CommandEmit (line 38) | pub(super) struct CommandEmit {
  type CommandEmitTo (line 47) | pub(super) struct CommandEmitTo {
  type CommandExec (line 58) | pub(super) struct CommandExec {
  type CommandPkg (line 67) | pub(super) enum CommandPkg {
  type CommandPub (line 95) | pub(super) struct CommandPub {
    method receiver (line 112) | pub(super) fn receiver() -> Result<Id> {
  type CommandPubTo (line 122) | pub(super) struct CommandPubTo {
  type CommandSub (line 141) | pub(super) struct CommandSub {

FILE: yazi-cli/src/dds/draw.rs
  method draw (line 14) | pub(crate) async fn draw(kinds: HashSet<&str>) -> Result<()> {

FILE: yazi-cli/src/dds/exec.rs
  method exec (line 13) | pub(crate) async fn exec(cmd: CommandExec) -> anyhow::Result<Data> {
  method ask (line 38) | async fn ask(kind: &str, receiver: Id, body: &str, reply_kind: &str) -> ...

FILE: yazi-cli/src/dds/mod.rs
  type Dds (line 3) | pub(crate) struct Dds;

FILE: yazi-cli/src/dds/shot.rs
  method shot (line 14) | pub(crate) async fn shot(kind: &str, receiver: Id, body: &str) -> Result...
  method ensure_version (line 46) | pub(super) fn ensure_version(version: Option<&str>) -> Result<()> {
  method ensure_ability (line 57) | pub(super) fn ensure_ability(peers: &HashMap<Id, Peer>, kind: &str, rece...

FILE: yazi-cli/src/main.rs
  function main (line 12) | async fn main() -> ExitCode {
  function run (line 32) | async fn run() -> anyhow::Result<()> {

FILE: yazi-cli/src/package/add.rs
  method add (line 7) | pub(super) async fn add(&mut self) -> Result<()> {

FILE: yazi-cli/src/package/delete.rs
  method delete (line 9) | pub(super) async fn delete(&self) -> Result<()> {
  method delete_assets (line 24) | pub(super) async fn delete_assets(&self) -> Result<()> {
  method delete_sources (line 42) | pub(super) async fn delete_sources(&self) -> Result<()> {

FILE: yazi-cli/src/package/dependency.rs
  type Dependency (line 11) | pub(crate) struct Dependency {
    method local (line 25) | pub(super) fn local(&self) -> PathBuf {
    method remote (line 31) | pub(super) fn remote(&self) -> String {
    method target (line 36) | pub(super) fn target(&self) -> PathBuf {
    method identical (line 44) | pub(super) fn identical(&self, other: &Self) -> bool {
    method header (line 48) | pub(super) fn header(&self, s: &str) -> Result<()> {
    method plugin_files (line 69) | pub(super) async fn plugin_files(dir: &Path) -> io::Result<Vec<String>> {
    method flavor_files (line 86) | pub(super) fn flavor_files() -> Vec<String> {
    method deserialize (line 123) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type Err (line 95) | type Err = anyhow::Error;
  method from_str (line 97) | fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
  method serialize (line 146) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: yazi-cli/src/package/deploy.rs
  method deploy (line 11) | pub(super) async fn deploy(&mut self) -> Result<()> {
  method deploy_assets (line 42) | async fn deploy_assets(from: PathBuf, to: PathBuf) -> Result<()> {
  method deploy_sources (line 59) | async fn deploy_sources(from: &Path, to: &Path, is_flavor: bool) -> Resu...

FILE: yazi-cli/src/package/git.rs
  type Git (line 7) | pub(super) struct Git;
    method clone (line 10) | pub(super) async fn clone(url: &str, path: &Path) -> Result<()> {
    method fetch (line 14) | pub(super) async fn fetch(path: &Path) -> Result<()> {
    method checkout (line 18) | pub(super) async fn checkout(path: &Path, rev: &str) -> Result<()> {
    method pull (line 22) | pub(super) async fn pull(path: &Path) -> Result<()> {
    method revision (line 28) | pub(super) async fn revision(path: &Path) -> Result<String> {
    method exec (line 45) | async fn exec(f: impl FnOnce(&mut Command) -> &mut Command) -> Result<...

FILE: yazi-cli/src/package/hash.rs
  method hash (line 9) | pub(crate) async fn hash(&self) -> Result<String> {
  method hash_check (line 45) | pub(super) async fn hash_check(&self) -> Result<()> {

FILE: yazi-cli/src/package/install.rs
  method install (line 7) | pub(super) async fn install(&mut self) -> Result<()> {

FILE: yazi-cli/src/package/mod.rs
  function init (line 6) | pub(super) fn init() -> anyhow::Result<()> {

FILE: yazi-cli/src/package/package.rs
  type Package (line 11) | pub(crate) struct Package {
    method load (line 17) | pub(crate) async fn load() -> Result<Self> {
    method add_many (line 22) | pub(crate) async fn add_many(&mut self, uses: &[String]) -> Result<()> {
    method delete_many (line 31) | pub(crate) async fn delete_many(&mut self, uses: &[String]) -> Result<...
    method install (line 40) | pub(crate) async fn install(&mut self) -> Result<()> {
    method upgrade_many (line 58) | pub(crate) async fn upgrade_many(&mut self, uses: &[String]) -> Result...
    method print (line 78) | pub(crate) fn print(&self) -> Result<()> {
    method add (line 100) | async fn add(&mut self, r#use: &str) -> Result<()> {
    method delete (line 119) | async fn delete(&mut self, r#use: &str) -> Result<()> {
    method save (line 133) | async fn save(&self) -> Result<()> {
    method toml (line 138) | fn toml() -> PathBuf { Xdg::config_dir().join("package.toml") }
    method identical (line 140) | fn identical(&self, other: &Dependency) -> Option<&Dependency> {
    method deserialize (line 146) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method serialize (line 170) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: yazi-cli/src/package/upgrade.rs
  method upgrade (line 6) | pub(super) async fn upgrade(&mut self) -> Result<()> {

FILE: yazi-cli/src/shared/shared.rs
  function must_exists (line 8) | pub async fn must_exists(path: impl AsRef<Path>) -> bool {
  function maybe_exists (line 13) | pub async fn maybe_exists(path: impl AsRef<Path>) -> bool {
  function copy_and_seal (line 20) | pub async fn copy_and_seal(from: &Path, to: &Path) -> io::Result<()> {
  function remove_sealed (line 34) | pub async fn remove_sealed(p: &Path) -> io::Result<()> {

FILE: yazi-codegen/src/lib.rs
  function deserialize_over (line 6) | pub fn deserialize_over(input: TokenStream) -> TokenStream {
  function deserialize_over1 (line 20) | pub fn deserialize_over1(input: TokenStream) -> TokenStream {
  function deserialize_over2 (line 70) | pub fn deserialize_over2(input: TokenStream) -> TokenStream {
  function from_lua (line 112) | pub fn from_lua(input: TokenStream) -> TokenStream {

FILE: yazi-config/src/icon.rs
  type Icon (line 4) | pub struct Icon {

FILE: yazi-config/src/keymap/chord.rs
  type Chord (line 13) | pub struct Chord {
    method on (line 33) | pub fn on(&self) -> String { self.on.iter().map(ToString::to_string).c...
    method run (line 35) | pub fn run(&self) -> String {
    method desc (line 41) | pub fn desc(&self) -> Option<Cow<'_, str>> {
    method desc_or_run (line 45) | pub fn desc_or_run(&self) -> Cow<'_, str> { self.desc().unwrap_or_else...
    method contains (line 47) | pub fn contains(&self, s: &str) -> bool {
    method noop (line 55) | pub(super) fn noop(&self) -> bool {
    method reshape (line 61) | pub(super) fn reshape(mut self, layer: Layer) -> Result<Self> {
  method eq (line 23) | fn eq(&self, other: &Self) -> bool { self.on == other.on }
  method hash (line 29) | fn hash<H: Hasher>(&self, state: &mut H) { self.on.hash(state) }

FILE: yazi-config/src/keymap/cow.rs
  type ChordCow (line 8) | pub enum ChordCow {
    method from (line 14) | fn from(c: Chord) -> Self { Self::Owned(c) }
    method from (line 18) | fn from(c: &'static Chord) -> Self { Self::Borrowed(c) }
    method into_seq (line 40) | pub fn into_seq(self) -> Vec<ActionCow> {
  type Target (line 22) | type Target = Chord;
  method deref (line 24) | fn deref(&self) -> &Self::Target {
  method default (line 33) | fn default() -> Self {

FILE: yazi-config/src/keymap/deserializers.rs
  function deserialize_on (line 9) | pub(super) fn deserialize_on<'de, D>(deserializer: D) -> Result<Vec<Key>...
  function deserialize_run (line 47) | pub(super) fn deserialize_run<'de, D>(deserializer: D) -> Result<Vec<Act...

FILE: yazi-config/src/keymap/key.rs
  type Key (line 7) | pub struct Key {
    method plain (line 17) | pub fn plain(&self) -> Option<char> {
    method from (line 32) | fn from(value: KeyEvent) -> Self {
  method default (line 26) | fn default() -> Self {
  type Err (line 61) | type Err = anyhow::Error;
  method from_str (line 63) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 138) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: yazi-config/src/keymap/keymap.rs
  type Keymap (line 10) | pub struct Keymap {
    method get (line 22) | pub fn get(&self, layer: Layer) -> &[Chord] {
    method read (line 40) | pub(crate) fn read() -> Result<String> {
    method reshape (line 46) | pub(crate) fn reshape(self) -> Result<Self> {

FILE: yazi-config/src/keymap/rules.rs
  type KeymapRules (line 13) | pub struct KeymapRules {
    method reshape (line 28) | pub(crate) fn reshape(self, layer: Layer) -> Result<Self> {
  type Target (line 22) | type Target = Vec<Chord>;
  method deref (line 24) | fn deref(&self) -> &Self::Target { &self.keymap }

FILE: yazi-config/src/layout.rs
  type Layout (line 4) | pub struct Layout {
    method default (line 11) | pub const fn default() -> Self {
    method folder_limit (line 15) | pub const fn folder_limit(self) -> usize { self.current.height as _ }

FILE: yazi-config/src/lib.rs
  function init (line 15) | pub fn init() -> anyhow::Result<()> {
  function try_init (line 23) | fn try_init(merge: bool) -> anyhow::Result<()> {
  function init_flavor (line 37) | pub fn init_flavor(light: bool) -> anyhow::Result<()> {
  function try_init_flavor (line 45) | fn try_init_flavor(light: bool, merge: bool) -> anyhow::Result<()> {
  function wait_for_key (line 62) | fn wait_for_key(e: anyhow::Error) -> anyhow::Result<()> {
  function error_with_input (line 84) | pub(crate) fn error_with_input<T>(

FILE: yazi-config/src/mgr/mgr.rs
  type Mgr (line 10) | pub struct Mgr {
    method reshape (line 30) | pub(crate) fn reshape(self) -> Result<Self> {

FILE: yazi-config/src/mgr/mouse.rs
  method draggable (line 19) | pub const fn draggable(self) -> bool { self.contains(Self::DRAG) }
  type Error (line 23) | type Error = anyhow::Error;
  method try_from (line 25) | fn try_from(value: Vec<String>) -> Result<Self, Self::Error> {
  function from (line 40) | fn from(value: MouseEvents) -> Self {
  method from (line 53) | fn from(value: crossterm::event::MouseEventKind) -> Self {

FILE: yazi-config/src/mgr/ratio.rs
  type MgrRatio (line 6) | pub struct MgrRatio {
    type Error (line 14) | type Error = anyhow::Error;
    method try_from (line 16) | fn try_from(ratio: [u16; 3]) -> Result<Self, Self::Error> {

FILE: yazi-config/src/open/open.rs
  type Open (line 12) | pub struct Open {
    method all (line 27) | pub fn all<'a, 'b, U, M>(&'a self, url: U, mime: M) -> impl Iterator<I...
    method common (line 46) | pub fn common<'a, 'b, U, M>(&'a self, targets: &'b [(U, M)]) -> IndexS...
    method reshape (line 64) | pub(crate) fn reshape(self) -> Result<Self> {
  type Target (line 21) | type Target = Vec<OpenRule>;
  method deref (line 23) | fn deref(&self) -> &Self::Target { &self.rules }

FILE: yazi-config/src/open/rule.rs
  type OpenRule (line 8) | pub struct OpenRule {
    method any_file (line 17) | pub fn any_file(&self) -> bool { self.url.as_ref().is_some_and(|p| p.a...
    method any_dir (line 20) | pub fn any_dir(&self) -> bool { self.url.as_ref().is_some_and(|p| p.an...
    method deserialize (line 24) | fn deserialize<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>

FILE: yazi-config/src/opener/opener.rs
  type Opener (line 14) | pub struct Opener(HashMap<String, Vec<OpenerRule>>);
    method all (line 23) | pub fn all<'a, I>(&self, uses: I) -> impl Iterator<Item = &OpenerRule>
    method first (line 30) | pub fn first<'a, I>(&self, uses: I) -> Option<&OpenerRule>
    method block (line 37) | pub fn block<'a, I>(&self, uses: I) -> Option<&OpenerRule>
    method reshape (line 46) | pub(crate) fn reshape(mut self) -> Result<Self> {
    method deserialize_over_with (line 61) | pub(crate) fn deserialize_over_with<'de>(
  type Target (line 17) | type Target = HashMap<String, Vec<OpenerRule>>;
  method deref (line 19) | fn deref(&self) -> &Self::Target { &self.0 }

FILE: yazi-config/src/opener/rule.rs
  type OpenerRule (line 6) | pub struct OpenerRule {
    method desc (line 20) | pub fn desc(&self) -> String {
    method reshape (line 32) | pub(super) fn reshape(mut self) -> Result<Self> {

FILE: yazi-config/src/pattern.rs
  type Pattern (line 10) | pub struct Pattern {
    method match_url (line 31) | pub fn match_url(&self, url: impl AsUrl, is_dir: bool) -> bool {
    method match_mime (line 58) | pub fn match_mime(&self, mime: impl AsRef<str>) -> bool {
    method any_file (line 63) | pub fn any_file(&self) -> bool { self.is_star && !self.is_dir }
    method any_dir (line 66) | pub fn any_dir(&self) -> bool { self.is_star && self.is_dir }
    type Error (line 106) | type Error = anyhow::Error;
    method try_from (line 108) | fn try_from(s: String) -> Result<Self, Self::Error> { Self::from_str(s...
  method fmt (line 20) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Err (line 70) | type Err = anyhow::Error;
  method from_str (line 72) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type PatternScheme (line 113) | enum PatternScheme {
    method parse (line 126) | fn parse(s: &str) -> Result<(Self, usize)> {
    method matches (line 150) | fn matches(self, kind: SchemeKind) -> bool {
  function matches (line 176) | fn matches(glob: &str, url: &str) -> bool {
  function test_unix (line 182) | fn test_unix() {
  function test_windows (line 216) | fn test_windows() {

FILE: yazi-config/src/platform.rs
  function check_for (line 2) | pub(crate) fn check_for(r#for: Option<&str>) -> bool {

FILE: yazi-config/src/plugin/fetcher.rs
  type Fetcher (line 8) | pub struct Fetcher {
    method matches (line 22) | pub fn matches(&self, file: &File, mime: &str) -> bool {

FILE: yazi-config/src/plugin/mod.rs
  constant MAX_FETCHERS (line 3) | pub const MAX_FETCHERS: u8 = 16;
  constant MAX_PRELOADERS (line 4) | pub const MAX_PRELOADERS: u8 = 16;

FILE: yazi-config/src/plugin/plugin.rs
  type Plugin (line 12) | pub struct Plugin {
    method fetchers (line 39) | pub fn fetchers<'a, 'b: 'a>(
    method mime_fetchers (line 54) | pub fn mime_fetchers(&self, files: Vec<File>) -> impl Iterator<Item = ...
    method spotter (line 70) | pub fn spotter(&self, file: &File, mime: &str) -> Option<&Spotter> {
    method preloaders (line 74) | pub fn preloaders<'a, 'b: 'a>(
    method previewer (line 89) | pub fn previewer(&self, file: &File, mime: &str) -> Option<&Previewer> {
    method reshape (line 96) | pub(crate) fn reshape(mut self) -> Result<Self> {

FILE: yazi-config/src/plugin/preloader.rs
  type Preloader (line 8) | pub struct Preloader {
    method matches (line 23) | pub fn matches(&self, file: &File, mime: &str) -> bool {

FILE: yazi-config/src/plugin/previewer.rs
  type Previewer (line 8) | pub struct Previewer {
    method matches (line 16) | pub fn matches(&self, file: &File, mime: &str) -> bool {
    method any_file (line 22) | pub fn any_file(&self) -> bool { self.url.as_ref().is_some_and(|p| p.a...
    method any_dir (line 25) | pub fn any_dir(&self) -> bool { self.url.as_ref().is_some_and(|p| p.an...

FILE: yazi-config/src/plugin/spotter.rs
  type Spotter (line 8) | pub struct Spotter {
    method matches (line 16) | pub fn matches(&self, file: &File, mime: &str) -> bool {
    method any_file (line 22) | pub fn any_file(&self) -> bool { self.url.as_ref().is_some_and(|p| p.a...
    method any_dir (line 25) | pub fn any_dir(&self) -> bool { self.url.as_ref().is_some_and(|p| p.an...

FILE: yazi-config/src/popup/confirm.rs
  type Confirm (line 8) | pub struct Confirm {
    method border (line 33) | pub const fn border(&self) -> u16 { 2 }
    method trash_position (line 35) | pub const fn trash_position(&self) -> Position {
    method delete_position (line 39) | pub const fn delete_position(&self) -> Position {
    method overwrite_position (line 43) | pub const fn overwrite_position(&self) -> Position {
    method quit_position (line 47) | pub const fn quit_position(&self) -> Position {

FILE: yazi-config/src/popup/input.rs
  type Input (line 7) | pub struct Input {
    method border (line 47) | pub const fn border(&self) -> u16 { 2 }

FILE: yazi-config/src/popup/offset.rs
  type Offset (line 6) | pub struct Offset {
    type Error (line 14) | type Error = anyhow::Error;
    method try_from (line 16) | fn try_from(values: [i16; 4]) -> Result<Self, Self::Error> {
    method line (line 38) | pub fn line() -> Self { Self { x: 0, y: 0, width: u16::MAX, height: 1 } }

FILE: yazi-config/src/popup/options.rs
  type InputCfg (line 8) | pub struct InputCfg {
    method cd (line 34) | pub fn cd(cwd: Url) -> Self {
    method create (line 44) | pub fn create(dir: bool) -> Self {
    method rename (line 52) | pub fn rename() -> Self {
    method filter (line 60) | pub fn filter() -> Self {
    method find (line 69) | pub fn find(prev: bool) -> Self {
    method search (line 78) | pub fn search(name: &str) -> Self {
    method shell (line 86) | pub fn shell(block: bool) -> Self {
    method tab_rename (line 94) | pub fn tab_rename() -> Self {
    method with_value (line 108) | pub fn with_value(mut self, value: impl Into<String>) -> Self {
    method with_cursor (line 114) | pub fn with_cursor(mut self, cursor: Option<usize>) -> Self {
  type PickCfg (line 19) | pub struct PickCfg {
    method max_height (line 193) | fn max_height(len: usize) -> u16 {
    method open (line 197) | pub fn open(items: Vec<String>) -> Self {
  type ConfirmCfg (line 26) | pub struct ConfirmCfg {
    method new (line 121) | fn new(
    method trash (line 135) | pub fn trash(urls: &[yazi_shared::url::UrlBuf]) -> Self {
    method delete (line 144) | pub fn delete(urls: &[yazi_shared::url::UrlBuf]) -> Self {
    method overwrite (line 153) | pub fn overwrite(url: &UrlBuf) -> Self {
    method quit (line 162) | pub fn quit(len: usize, names: Vec<String>) -> Self {
    method replace_number (line 171) | fn replace_number(tpl: &str, n: usize) -> String {
    method truncate_list (line 175) | fn truncate_list<I>(it: I, len: usize, max: usize) -> Option<Text<'sta...

FILE: yazi-config/src/popup/origin.rs
  type Origin (line 7) | pub enum Origin {
  method fmt (line 22) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Err (line 39) | type Err = serde::de::value::Error;
  method from_str (line 41) | fn from_str(s: &str) -> Result<Self, Self::Err> {

FILE: yazi-config/src/popup/pick.rs
  type Pick (line 7) | pub struct Pick {
    method border (line 15) | pub const fn border(&self) -> u16 { 2 }

FILE: yazi-config/src/popup/position.rs
  type Position (line 7) | pub struct Position {
    method new (line 13) | pub const fn new(origin: Origin, offset: Offset) -> Self { Self { orig...
    method rect (line 15) | pub fn rect(&self, WindowSize { columns, rows, .. }: WindowSize) -> Re...
    method sticky (line 45) | pub fn sticky(WindowSize { columns, rows, .. }: WindowSize, base: Rect...

FILE: yazi-config/src/preset.rs
  type Preset (line 3) | pub(crate) struct Preset;
    method yazi (line 6) | pub(super) fn yazi() -> Result<Yazi, toml::de::Error> {
    method keymap (line 10) | pub(super) fn keymap() -> Result<Keymap, toml::de::Error> {
    method theme (line 14) | pub(super) fn theme(light: bool) -> Result<Theme, toml::de::Error> {
    method vfs (line 22) | pub(super) fn vfs() -> Result<Vfs, toml::de::Error> {
    method mix (line 27) | pub(crate) fn mix<E, A, B, C>(a: A, b: B, c: C) -> impl Iterator<Item ...

FILE: yazi-config/src/preview/preview.rs
  type Preview (line 13) | pub struct Preview {
    method tmpfile (line 30) | pub fn tmpfile(&self, prefix: &str) -> PathBuf {
    method indent (line 34) | pub fn indent(&self) -> SStr {
    method reshape (line 47) | pub(crate) fn reshape(mut self) -> Result<Self> {

FILE: yazi-config/src/preview/wrap.rs
  type PreviewWrap (line 5) | pub enum PreviewWrap {
  function from (line 11) | fn from(wrap: PreviewWrap) -> Self {

FILE: yazi-config/src/priority.rs
  type Priority (line 5) | pub enum Priority {

FILE: yazi-config/src/style.rs
  type Style (line 5) | pub struct Style {
    method from (line 21) | fn from(value: ratatui::style::Style) -> Self {
    method derive (line 88) | pub fn derive(self, other: ratatui::style::Style) -> ratatui::style::S...
  function from (line 45) | fn from(value: Style) -> Self {

FILE: yazi-config/src/tasks/tasks.rs
  type Tasks (line 6) | pub struct Tasks {
    method reshape (line 22) | pub(crate) fn reshape(self) -> Result<Self> {

FILE: yazi-config/src/theme/filetype.rs
  type Filetype (line 11) | pub struct Filetype {
  type Target (line 16) | type Target = Vec<FiletypeRule>;
  method deref (line 18) | fn deref(&self) -> &Self::Target { &self.rules }
  type FiletypeRule (line 22) | pub struct FiletypeRule {
    method matches (line 32) | pub fn matches(&self, file: &File, mime: &str) -> bool {

FILE: yazi-config/src/theme/flavor.rs
  type Flavor (line 12) | pub struct Flavor {
    method from_theme (line 20) | pub(crate) fn from_theme(theme: &Spanned<DeTable>, input: &str) -> Res...
    method read (line 28) | pub(crate) fn read(&self, light: bool) -> Result<String> {
    method syntect_path (line 38) | pub(crate) fn syntect_path(&self, light: bool) -> Option<PathBuf> {

FILE: yazi-config/src/theme/icon.rs
  type Icon (line 14) | pub struct Icon {
    method matches (line 47) | pub fn matches(&self, file: &File, hovered: bool) -> Option<&I> {
    method match_by_glob (line 74) | fn match_by_glob(&self, file: &File) -> Option<&I> {
    method match_by_name (line 78) | fn match_by_name(&self, file: &File) -> Option<&I> {
    method match_by_ext (line 91) | fn match_by_ext(&self, file: &File) -> Option<&I> {
    method reshape (line 98) | pub(crate) fn reshape(self) -> Result<Self> {
  type PatIcons (line 121) | pub struct PatIcons(Vec<(Pattern, I)>);
    method deserialize (line 130) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type Target (line 124) | type Target = Vec<(Pattern, I)>;
  method deref (line 126) | fn deref(&self) -> &Self::Target { &self.0 }
  type StrIcons (line 151) | pub struct StrIcons(HashMap<String, I>);
    method deserialize (line 160) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type Target (line 154) | type Target = HashMap<String, I>;
  method deref (line 156) | fn deref(&self) -> &Self::Target { &self.0 }
  type CondIcons (line 181) | pub struct CondIcons(Vec<(Condition, I)>);
    method deserialize (line 190) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type Target (line 184) | type Target = Vec<(Condition, I)>;
  method deref (line 186) | fn deref(&self) -> &Self::Target { &self.0 }

FILE: yazi-config/src/theme/is.rs
  type Is (line 6) | pub enum Is {
    method check (line 22) | pub fn check(&self, cha: &Cha) -> bool {

FILE: yazi-config/src/theme/theme.rs
  type Theme (line 12) | pub struct Theme {
    method read (line 227) | pub(crate) fn read() -> Result<String> {
    method reshape (line 233) | pub(crate) fn reshape(mut self, light: bool) -> Result<Self> {
  type App (line 38) | pub struct App {
    method bg_color (line 251) | pub fn bg_color(&self) -> String { self.overall.bg.map(|c| c.to_string...
  type Mgr (line 43) | pub struct Mgr {
  type Tabs (line 74) | pub struct Tabs {
  type TabsSep (line 83) | pub struct TabsSep {
  type Mode (line 89) | pub struct Mode {
  type Indicator (line 101) | pub struct Indicator {
  type IndicatorPadding (line 109) | pub struct IndicatorPadding {
  type Status (line 115) | pub struct Status {
  type StatusSep (line 134) | pub struct StatusSep {
  type Which (line 140) | pub struct Which {
  type Confirm (line 152) | pub struct Confirm {
  type Spot (line 164) | pub struct Spot {
  type Notify (line 173) | pub struct Notify {
  type Pick (line 184) | pub struct Pick {
  type Input (line 191) | pub struct Input {
  type Cmp (line 199) | pub struct Cmp {
  type Tasks (line 210) | pub struct Tasks {
  type Help (line 217) | pub struct Help {

FILE: yazi-config/src/utils.rs
  function normalize_path (line 6) | pub(crate) fn normalize_path(path: PathBuf) -> Option<PathBuf> {

FILE: yazi-config/src/vfs/service.rs
  type Service (line 9) | pub enum Service {
    method reshape (line 24) | pub(super) fn reshape(&mut self) -> io::Result<()> {
  type Error (line 14) | type Error = &'static str;
  function try_from (line 16) | fn try_from(value: &'static Service) -> Result<Self, Self::Error> {
  type ServiceSftp (line 33) | pub struct ServiceSftp {
    method reshape (line 50) | fn reshape(&mut self) -> io::Result<()> {

FILE: yazi-config/src/vfs/services.rs
  type Services (line 12) | pub struct Services(HashMap<String, Service>);
    method reshape (line 21) | pub(super) fn reshape(mut self) -> Result<Self> {
    method deserialize_over_with (line 35) | pub(super) fn deserialize_over_with<'de>(
  type Target (line 15) | type Target = HashMap<String, Service>;
  method deref (line 17) | fn deref(&self) -> &Self::Target { &self.0 }

FILE: yazi-config/src/vfs/vfs.rs
  type Vfs (line 13) | pub struct Vfs {
    method load (line 18) | pub async fn load() -> io::Result<&'static Self> {
    method service (line 30) | pub async fn service<'a, P>(name: &str) -> io::Result<(&'a str, P)>
    method read (line 43) | fn read() -> Result<String> {
    method reshape (line 49) | fn reshape(self) -> Result<Self> { Ok(Self { services: self.services.r...

FILE: yazi-config/src/which/sorting.rs
  type SortBy (line 5) | pub enum SortBy {

FILE: yazi-config/src/which/which.rs
  type Which (line 7) | pub struct Which {

FILE: yazi-config/src/yazi.rs
  type Yazi (line 9) | pub struct Yazi {
    method read (line 23) | pub(super) fn read() -> Result<String> {
    method reshape (line 29) | pub(super) fn reshape(self) -> Result<Self> {

FILE: yazi-core/src/cmp/cmp.rs
  type Cmp (line 10) | pub struct Cmp {
    method window (line 23) | pub fn window(&self) -> &[CmpItem] {
    method selected (line 28) | pub fn selected(&self) -> Option<&CmpItem> { self.matches.get(self.cur...
    method rel_cursor (line 31) | pub fn rel_cursor(&self) -> usize { self.cursor - self.offset }
  method total (line 35) | fn total(&self) -> usize { self.matches.len() }
  method limit (line 37) | fn limit(&self) -> usize { self.matches.len().min(10) }
  method cursor_mut (line 39) | fn cursor_mut(&mut self) -> &mut usize { &mut self.cursor }
  method offset_mut (line 41) | fn offset_mut(&mut self) -> &mut usize { &mut self.offset }

FILE: yazi-core/src/confirm/confirm.rs
  type Confirm (line 6) | pub struct Confirm {

FILE: yazi-core/src/core.rs
  type Core (line 7) | pub struct Core {
    method make (line 20) | pub fn make() -> Self {
    method cursor (line 34) | pub fn cursor(&self) -> Option<(Position, SetCursorStyle)> {
    method layer (line 48) | pub fn layer(&self) -> Layer {
    method active (line 73) | pub fn active(&self) -> &Tab { self.mgr.active() }
    method active_mut (line 76) | pub fn active_mut(&mut self) -> &mut Tab { self.mgr.active_mut() }
    method current_mut (line 79) | pub fn current_mut(&mut self) -> &mut Folder { self.mgr.current_mut() }
    method parent_mut (line 82) | pub fn parent_mut(&mut self) -> Option<&mut Folder> { self.mgr.parent_...

FILE: yazi-core/src/help/help.rs
  type Help (line 13) | pub struct Help {
    method r#type (line 27) | pub fn r#type(&mut self, key: &Key) -> Result<bool> {
    method filter_apply (line 50) | pub fn filter_apply(&mut self) {
    method keyword (line 67) | pub fn keyword(&self) -> Option<String> {
    method window (line 77) | pub fn window(&self) -> &[&Chord] {
    method cursor (line 83) | pub fn cursor(&self) -> Option<(u16, u16)> {
    method rel_cursor (line 93) | pub fn rel_cursor(&self) -> usize { self.cursor - self.offset }
    method cursor_shape (line 95) | pub fn cursor_shape(&self) -> SetCursorStyle {
  method total (line 105) | fn total(&self) -> usize { self.bindings.len() }
  method limit (line 107) | fn limit(&self) -> usize { Dimension::available().rows.saturating_sub(HE...
  method cursor_mut (line 109) | fn cursor_mut(&mut self) -> &mut usize { &mut self.cursor }
  method offset_mut (line 111) | fn offset_mut(&mut self) -> &mut usize { &mut self.offset }

FILE: yazi-core/src/help/mod.rs
  constant HELP_MARGIN (line 3) | const HELP_MARGIN: u16 = 1;

FILE: yazi-core/src/input/input.rs
  type Input (line 6) | pub struct Input {
  type Target (line 15) | type Target = yazi_widgets::input::Input;
  method deref (line 17) | fn deref(&self) -> &Self::Target { &self.inner }
  method deref_mut (line 21) | fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner }

FILE: yazi-core/src/mgr/mgr.rs
  type Mgr (line 13) | pub struct Mgr {
    method make (line 22) | pub fn make() -> Self {
    method area (line 32) | pub fn area(&self, pos: Position) -> Rect {
    method shutdown (line 40) | pub fn shutdown(&mut self) { self.tabs.iter_mut().for_each(|t| t.shutd...
    method cwd (line 45) | pub fn cwd(&self) -> &UrlBuf { self.active().cwd() }
    method active (line 48) | pub fn active(&self) -> &Tab { self.tabs.active() }
    method active_mut (line 51) | pub fn active_mut(&mut self) -> &mut Tab { self.tabs.active_mut() }
    method current_mut (line 54) | pub fn current_mut(&mut self) -> &mut Folder { &mut self.active_mut()....
    method parent_mut (line 57) | pub fn parent_mut(&mut self) -> Option<&mut Folder> { self.active_mut(...
  method tab (line 61) | fn tab(&self) -> usize { self.tabs.cursor }
  method selected (line 63) | fn selected(&self, tab: usize, mut idx: Option<usize>) -> impl Iterator<...
  method hovered (line 75) | fn hovered(&self, tab: usize) -> Option<Url<'_>> {
  method yanked (line 83) | fn yanked(&self) -> impl Iterator<Item = Url<'_>> { self.yanked.iter().m...

FILE: yazi-core/src/mgr/mimetype.rs
  type Mimetype (line 5) | pub struct Mimetype(HashMap<UrlBufCov, Symbol<str>>);
    method get (line 8) | pub fn get<'a, 'b>(&'a self, url: impl Into<Url<'b>>) -> Option<&'a st...
    method owned (line 12) | pub fn owned<'a>(&self, url: impl Into<Url<'a>>) -> Option<Symbol<str>> {
    method contains (line 16) | pub fn contains<'a>(&self, url: impl Into<Url<'a>>) -> bool {
    method extend (line 20) | pub fn extend(&mut self, iter: impl IntoIterator<Item = (UrlBufCov, Sy...

FILE: yazi-core/src/mgr/tabs.rs
  type Tabs (line 9) | pub struct Tabs {
    method set_idx (line 19) | pub fn set_idx(&mut self, idx: usize) {
    method active (line 32) | pub fn active(&self) -> &Tab { &self[self.cursor] }
    method active_mut (line 35) | pub(super) fn active_mut(&mut self) -> &mut Tab { &mut self.items[self...
    method parent (line 38) | pub fn parent(&self) -> Option<&Folder> { self.active().parent.as_ref() }
    method current (line 41) | pub fn current(&self) -> &Folder { &self.active().current }
    method hovered (line 44) | pub fn hovered(&self) -> Option<&File> { self.current().hovered() }
  method default (line 15) | fn default() -> Self { Self { cursor: 0, items: vec![Default::default()]...
  type Target (line 48) | type Target = Vec<Tab>;
  method deref (line 50) | fn deref(&self) -> &Self::Target { &self.items }
  method deref_mut (line 54) | fn deref_mut(&mut self) -> &mut Self::Target { &mut self.items }

FILE: yazi-core/src/mgr/yanked.rs
  type Yanked (line 10) | pub struct Yanked {
    method new (line 25) | pub fn new(cut: bool, urls: HashSet<UrlBufCov>) -> Self {
    method remove (line 29) | pub fn remove<'a>(&mut self, url: impl Into<Url<'a>>) {
    method clear (line 35) | pub fn clear(&mut self) {
    method contains (line 44) | pub fn contains<'a>(&self, url: impl Into<Url<'a>>) -> bool {
    method contains_in (line 48) | pub fn contains_in(&self, dir: &UrlBuf) -> bool {
    method apply_op (line 57) | pub fn apply_op(&mut self, op: &FilesOp) {
    method catchup_revision (line 72) | pub fn catchup_revision(&mut self, force: bool) -> bool {
  type Target (line 19) | type Target = HashSet<UrlBufCov>;
  method deref (line 21) | fn deref(&self) -> &Self::Target { &self.urls }

FILE: yazi-core/src/notify/message.rs
  type Message (line 8) | pub struct Message {
    method from (line 20) | fn from(opt: PushOpt) -> Self {
    method height (line 40) | pub fn height(&self, width: u16) -> usize {
  method eq (line 50) | fn eq(&self, other: &Self) -> bool {

FILE: yazi-core/src/notify/mod.rs
  constant NOTIFY_BORDER (line 3) | pub const NOTIFY_BORDER: u16 = 2;
  constant NOTIFY_SPACING (line 4) | pub const NOTIFY_SPACING: u16 = 1;

FILE: yazi-core/src/notify/notify.rs
  type Notify (line 9) | pub struct Notify {
    method available (line 15) | pub fn available(area: Rect) -> Rect {
    method limit (line 21) | pub fn limit(&self, area: Rect) -> usize {

FILE: yazi-core/src/pick/pick.rs
  type Pick (line 6) | pub struct Pick {
    method title (line 19) | pub fn title(&self) -> &str { &self.title }
    method window (line 21) | pub fn window(&self) -> impl Iterator<Item = (usize, &str)> {
  method total (line 27) | fn total(&self) -> usize { self.items.len() }
  method limit (line 29) | fn limit(&self) -> usize {
  method cursor_mut (line 33) | fn cursor_mut(&mut self) -> &mut usize { &mut self.cursor }
  method offset_mut (line 35) | fn offset_mut(&mut self) -> &mut usize { &mut self.offset }

FILE: yazi-core/src/spot/spot.rs
  type Spot (line 10) | pub struct Spot {
    method go (line 18) | pub fn go(&mut self, file: File, mime: Symbol<str>) {
    method visible (line 33) | pub fn visible(&self) -> bool { self.lock.is_some() }
    method abort (line 35) | pub fn abort(&mut self) { self.ct.take().map(|ct| ct.cancel()); }
    method reset (line 37) | pub fn reset(&mut self) {
    method same_url (line 42) | pub fn same_url(&self, url: &UrlBuf) -> bool { self.lock.as_ref().is_s...
    method same_file (line 44) | pub fn same_file(&self, file: &File, mime: &str) -> bool {
    method same_lock (line 49) | pub fn same_lock(&self, file: &File, mime: &str) -> bool {

FILE: yazi-core/src/tab/backstack.rs
  type Backstack (line 4) | pub struct Backstack {
    method push (line 10) | pub fn push(&mut self, url: Url) {
    method current (line 36) | pub fn current(&self) -> Option<&UrlBuf> { self.stack.get(self.cursor) }
    method shift_backward (line 38) | pub fn shift_backward(&mut self) -> Option<&UrlBuf> {
    method shift_forward (line 47) | pub fn shift_forward(&mut self) -> Option<&UrlBuf> {
  function test_backstack (line 62) | fn test_backstack() {

FILE: yazi-core/src/tab/finder.rs
  type Finder (line 8) | pub struct Finder {
    method new (line 21) | pub fn new(s: &str, case: FilterCase) -> Result<Self> {
    method prev (line 29) | pub fn prev(&self, files: &Files, cursor: usize, include: bool) -> Opt...
    method next (line 41) | pub fn next(&self, files: &Files, cursor: usize, include: bool) -> Opt...
    method catchup (line 53) | pub fn catchup(&mut self, folder: &Folder) -> bool {
    method matched_idx (line 79) | pub fn matched_idx<T>(&self, folder: &Folder, urn: T) -> Option<u8>
  type FinderLock (line 15) | struct FinderLock {
    method from (line 89) | fn from(value: &Folder) -> Self {
    method eq (line 95) | fn eq(&self, other: &Folder) -> bool {

FILE: yazi-core/src/tab/folder.rs
  type Folder (line 11) | pub struct Folder {
    method from (line 40) | fn from(value: T) -> Self { Self { url: value.into(), ..Default::defau...
    method update (line 44) | pub fn update(&mut self, op: FilesOp) -> bool {
    method update_pub (line 88) | pub fn update_pub(&mut self, tab: Id, op: FilesOp) -> bool {
    method arrow (line 96) | pub fn arrow(&mut self, step: impl Into<Step>) -> bool {
    method hover (line 110) | pub fn hover(&mut self, urn: PathDyn) -> bool {
    method repos (line 119) | pub fn repos(&mut self, urn: Option<PathDyn>) -> bool {
    method sync_page (line 129) | pub fn sync_page(&mut self, force: bool) {
    method squeeze_offset (line 141) | fn squeeze_offset(&mut self) -> bool {
    method hovered (line 160) | pub fn hovered(&self) -> Option<&File> { self.files.get(self.cursor) }
    method hovered_mut (line 163) | pub fn hovered_mut(&mut self) -> Option<&mut File> { self.files.get_mu...
    method paginate (line 165) | pub fn paginate(&self, page: usize) -> &[File] {
  method default (line 25) | fn default() -> Self {
  method total (line 176) | fn total(&self) -> usize { self.files.len() }
  method limit (line 178) | fn limit(&self) -> usize { LAYOUT.get().folder_limit() }
  method scrolloff (line 180) | fn scrolloff(&self) -> usize { (self.limit() / 2).min(YAZI.mgr.scrolloff...
  method cursor_mut (line 182) | fn cursor_mut(&mut self) -> &mut usize { &mut self.cursor }
  method offset_mut (line 184) | fn offset_mut(&mut self) -> &mut usize { &mut self.offset }

FILE: yazi-core/src/tab/history.rs
  type History (line 9) | pub struct History(HashMap<UrlBuf, Folder>);
    method remove_or (line 22) | pub fn remove_or(&mut self, url: impl AsUrl) -> Folder {
  type Target (line 12) | type Target = HashMap<UrlBuf, Folder>;
  method deref (line 14) | fn deref(&self) -> &Self::Target { &self.0 }
  method deref_mut (line 18) | fn deref_mut(&mut self) -> &mut Self::Target { &mut self.0 }

FILE: yazi-core/src/tab/mode.rs
  type Mode (line 4) | pub enum Mode {
    method visual_mut (line 12) | pub fn visual_mut(&mut self) -> Option<(usize, &mut BTreeSet<usize>)> {
    method take_visual (line 20) | pub fn take_visual(&mut self) -> Option<(usize, BTreeSet<usize>)> {
    method is_select (line 30) | pub fn is_select(&self) -> bool { matches!(self, Self::Select(..)) }
    method is_unset (line 32) | pub fn is_unset(&self) -> bool { matches!(self, Self::Unset(..)) }
    method is_visual (line 34) | pub fn is_visual(&self) -> bool { matches!(self, Self::Select(..) | Se...
  method fmt (line 38) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: yazi-core/src/tab/preference.rs
  type Preference (line 5) | pub struct Preference {
  method default (line 21) | fn default() -> Self {
  method from (line 40) | fn from(value: &Preference) -> Self {

FILE: yazi-core/src/tab/preview.rs
  type Preview (line 16) | pub struct Preview {
    method go (line 26) | pub fn go(&mut self, file: File, mime: Symbol<str>, force: bool) {
    method go_folder (line 41) | pub fn go_folder(&mut self, file: File, dir: Option<Cha>, mime: Symbol...
    method abort (line 73) | pub fn abort(&mut self) {
    method reset (line 78) | pub fn reset(&mut self) {
    method reset_image (line 84) | pub fn reset_image(&mut self) {
    method same_url (line 89) | pub fn same_url(&self, url: &UrlBuf) -> bool { matches!(&self.lock, So...
    method same_file (line 91) | pub fn same_file(&self, file: &File, mime: &str) -> bool {
    method same_lock (line 96) | pub fn same_lock(&self, file: &File, mime: &str) -> bool {
    method same_folder (line 100) | pub fn same_folder(&self, url: &UrlBuf) -> bool { self.folder_lock.as_...

FILE: yazi-core/src/tab/selected.rs
  type Selected (line 9) | pub struct Selected {
    method len (line 15) | pub fn len(&self) -> usize { self.inner.len() }
    method is_empty (line 17) | pub fn is_empty(&self) -> bool { self.inner.is_empty() }
    method values (line 19) | pub fn values(&self) -> impl Iterator<Item = &UrlBuf> { self.inner.key...
    method contains (line 21) | pub fn contains<'a>(&self, url: impl Into<Url<'a>>) -> bool {
    method add (line 25) | pub fn add<'a>(&mut self, url: impl Into<Url<'a>>) -> bool { self.add_...
    method add_many (line 27) | pub fn add_many<'a, I, T>(&mut self, urls: I) -> usize
    method add_same (line 41) | fn add_same<'a, I, T>(&mut self, urls: I) -> usize
    method remove (line 74) | pub fn remove<'a>(&mut self, url: impl Into<Url<'a>> + Clone) -> bool {
    method remove_many (line 78) | pub fn remove_many<'a, I, T>(&mut self, urls: I) -> usize
    method remove_same (line 98) | fn remove_same<'a, I, T>(&mut self, urls: I) -> usize
    method clear (line 126) | pub fn clear(&mut self) {
    method apply_op (line 131) | pub fn apply_op(&mut self, op: &FilesOp) {
  function test_insert_non_conflicting (line 149) | fn test_insert_non_conflicting() {
  function test_insert_conflicting_parent (line 158) | fn test_insert_conflicting_parent() {
  function test_insert_conflicting_child (line 166) | fn test_insert_conflicting_child() {
  function test_remove (line 175) | fn test_remove() {
  function insert_many_success (line 187) | fn insert_many_success() {
  function insert_many_with_existing_parent_fails (line 201) | fn insert_many_with_existing_parent_fails() {
  function insert_many_with_existing_child_fails (line 209) | fn insert_many_with_existing_child_fails() {
  function insert_many_empty_urls_list (line 217) | fn insert_many_empty_urls_list() {
  function insert_many_with_parent_as_child_of_another_url (line 224) | fn insert_many_with_parent_as_child_of_another_url() {
  function insert_many_with_direct_parent_fails (line 234) | fn insert_many_with_direct_parent_fails() {
  function insert_many_with_nested_child_fails (line 242) | fn insert_many_with_nested_child_fails() {
  function insert_many_sibling_directories_success (line 251) | fn insert_many_sibling_directories_success() {
  function insert_many_with_grandchild_fails (line 258) | fn insert_many_with_grandchild_fails() {
  function test_insert_many_with_remove (line 266) | fn test_insert_many_with_remove() {

FILE: yazi-core/src/tab/tab.rs
  type Tab (line 14) | pub struct Tab {
    method shutdown (line 55) | pub fn shutdown(&mut self) {
    method cwd (line 64) | pub fn cwd(&self) -> &UrlBuf { &self.current.url }
    method name (line 66) | pub fn name(&self) -> Cow<'_, str> {
    method hovered (line 78) | pub fn hovered(&self) -> Option<&File> { self.current.hovered() }
    method hovered_mut (line 81) | pub fn hovered_mut(&mut self) -> Option<&mut File> { self.current.hove...
    method hovered_rect (line 83) | pub fn hovered_rect(&self) -> Option<Rect> {
    method hovered_rect_based (line 92) | pub fn hovered_rect_based(&self, pos: Position) -> Rect {
    method selected_or_hovered (line 101) | pub fn selected_or_hovered(&self) -> Box<dyn Iterator<Item = &UrlBuf> ...
    method hovered_and_selected (line 109) | pub fn hovered_and_selected(&self) -> Box<dyn Iterator<Item = &UrlBuf>...
    method hovered_folder (line 122) | pub fn hovered_folder(&self) -> Option<&Folder> {
    method hovered_folder_mut (line 127) | pub fn hovered_folder_mut(&mut self) -> Option<&mut Folder> {
  method default (line 32) | fn default() -> Self {

FILE: yazi-core/src/tasks/file.rs
  method file_cut (line 9) | pub fn file_cut(&self, src: &Yanked, dest: &UrlBuf, force: bool) {
  method file_copy (line 23) | pub fn file_copy(&self, src: &Yanked, dest: &UrlBuf, force: bool, follow...
  method file_link (line 37) | pub fn file_link(&self, src: &HashSet<UrlBufCov>, dest: &UrlBuf, relativ...
  method file_hardlink (line 51) | pub fn file_hardlink(&self, src: &HashSet<UrlBufCov>, dest: &UrlBuf, for...
  method file_remove (line 65) | pub fn file_remove(&self, targets: Vec<UrlBuf>, permanently: bool) {

FILE: yazi-core/src/tasks/mod.rs
  constant TASKS_BORDER (line 3) | pub const TASKS_BORDER: u16 = 2;
  constant TASKS_PADDING (line 4) | pub const TASKS_PADDING: u16 = 2;
  constant TASKS_PERCENT (line 5) | pub const TASKS_PERCENT: u16 = 80;

FILE: yazi-core/src/tasks/prework.rs
  method fetch_paged (line 8) | pub fn fetch_paged(&self, paged: &[File], mimetype: &Mimetype) {
  method preload_paged (line 31) | pub fn preload_paged(&self, paged: &[File], mimetype: &Mimetype) {
  method prework_sorted (line 46) | pub fn prework_sorted(&self, targets: &Files) {

FILE: yazi-core/src/tasks/process.rs
  method open_shell_compat (line 10) | pub fn open_shell_compat(&self, mut opt: ProcessOpenOpt) {

FILE: yazi-core/src/tasks/tasks.rs
  type Tasks (line 12) | pub struct Tasks {
    method serve (line 23) | pub fn serve() -> Self {
    method shutdown (line 51) | pub fn shutdown(&self) {
    method limit (line 56) | pub fn limit() -> usize {
    method paginate (line 62) | pub fn paginate(&self) -> Vec<TaskSnap> {
    method ongoing (line 66) | pub fn ongoing(&self) -> &Arc<Mutex<Ongoing>> { &self.scheduler.ongoing }

FILE: yazi-core/src/which/sorter.rs
  type WhichSorter (line 7) | pub struct WhichSorter {
    method sort (line 26) | pub fn sort(&self, items: &mut Vec<ChordCow>) {
  method default (line 15) | fn default() -> Self {

FILE: yazi-core/src/which/which.rs
  type Which (line 6) | pub struct Which {
    method r#type (line 17) | pub fn r#type(&mut self, key: Key) -> bool {
    method dismiss (line 34) | pub fn dismiss(&mut self, chord: Option<ChordCow>) {

FILE: yazi-dds/build.rs
  function main (line 5) | fn main() -> Result<(), Box<dyn Error>> {

FILE: yazi-dds/src/client.rs
  type Client (line 21) | pub struct Client {
    method serve (line 34) | pub(super) fn serve() {
    method push (line 80) | pub(super) fn push<'a>(payload: impl Into<Payload<'a>>) -> Result<()> {
    method able (line 84) | pub(super) fn able(&self, ability: &str) -> bool { self.abilities.cont...
    method connect (line 86) | async fn connect(server: &mut Option<JoinHandle<()>>) -> (ClientReader...
    method reconnect (line 114) | async fn reconnect(server: &mut Option<JoinHandle<()>>) -> (ClientRead...
    method handle_hey (line 121) | fn handle_hey(body: &EmberHey) {
  type Peer (line 28) | pub struct Peer {
    method new (line 132) | pub(super) fn new(abilities: &HashSet<String>) -> Self { Self { abilit...
    method able (line 134) | pub fn able(&self, ability: &str) -> bool { self.abilities.contains(ab...

FILE: yazi-dds/src/ember/bulk.rs
  type EmberBulk (line 9) | pub struct EmberBulk<'a> {
  function borrowed (line 14) | pub fn borrowed<I>(changes: I) -> Ember<'a>
  function owned (line 23) | pub fn owned<'a, I>(changes: I) -> Ember<'static>
  function from (line 35) | fn from(value: EmberBulk<'a>) -> Self { Self::Bulk(value) }
  method into_lua (line 39) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/bye.rs
  type EmberBye (line 7) | pub struct EmberBye;
    method borrowed (line 10) | pub fn borrowed() -> Ember<'static> { Self.into() }
  function from (line 14) | fn from(value: EmberBye) -> Self { Self::Bye(value) }
  method into_lua (line 18) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> { lua.create_table()...

FILE: yazi-dds/src/ember/cd.rs
  type EmberCd (line 10) | pub struct EmberCd<'a> {
  function borrowed (line 18) | pub fn borrowed(tab: Id, url: &'a UrlBuf) -> Ember<'a> {
  function owned (line 24) | pub fn owned(tab: Id, _: &UrlBuf) -> Ember<'static> {
  function from (line 30) | fn from(value: EmberCd<'a>) -> Self { Self::Cd(value) }
  method into_lua (line 34) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/custom.rs
  type EmberCustom (line 9) | pub struct EmberCustom {
    method from_str (line 15) | pub fn from_str(kind: &str, data: &str) -> anyhow::Result<Ember<'stati...
    method from_lua (line 19) | pub fn from_lua(lua: &Lua, kind: &str, data: Value) -> mlua::Result<Em...
  function from (line 25) | fn from(value: EmberCustom) -> Self { Self::Custom(value) }
  method into_lua (line 29) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> { Sendable::data_to_...
  method serialize (line 33) | fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok...

FILE: yazi-dds/src/ember/delete.rs
  type EmberDelete (line 10) | pub struct EmberDelete<'a> {
  function borrowed (line 15) | pub fn borrowed(urls: &'a Vec<UrlBuf>) -> Ember<'a> { Self { urls: Cow::...
  function owned (line 19) | pub fn owned(urls: Vec<UrlBuf>) -> Ember<'static> { Self { urls: Cow::Ow...
  function from (line 23) | fn from(value: EmberDelete<'a>) -> Self { Self::Delete(value) }
  method into_lua (line 27) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/download.rs
  type EmberDownload (line 10) | pub struct EmberDownload<'a> {
  function borrowed (line 15) | pub fn borrowed(urls: &'a Vec<UrlBuf>) -> Ember<'a> { Self { urls: Cow::...
  function owned (line 19) | pub fn owned(urls: Vec<UrlBuf>) -> Ember<'static> { Self { urls: Cow::Ow...
  function from (line 23) | fn from(value: EmberDownload<'a>) -> Self { Self::Download(value) }
  method into_lua (line 27) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/duplicate.rs
  type EmberDuplicate (line 10) | pub struct EmberDuplicate<'a> {
  function borrowed (line 15) | pub fn borrowed(items: &'a Vec<EmberDuplicateItem>) -> Ember<'a> {
  function owned (line 21) | pub fn owned(items: Vec<EmberDuplicateItem>) -> Ember<'static> {
  function from (line 27) | fn from(value: EmberDuplicate<'a>) -> Self { Self::Duplicate(value) }
  method into_lua (line 31) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {
  type EmberDuplicateItem (line 38) | pub struct EmberDuplicateItem {
  method into_lua (line 44) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/ember.rs
  type Ember (line 9) | pub enum Ember<'a> {
  function from_str (line 30) | pub fn from_str(kind: &str, body: &str) -> Result<Self> {
  function from_lua (line 52) | pub fn from_lua(lua: &Lua, kind: &str, value: Value) -> mlua::Result<Sel...
  function validate (line 57) | pub fn validate(kind: &str) -> Result<()> {
  function kind (line 97) | pub fn kind(&self) -> &str {
  function with_receiver (line 119) | pub fn with_receiver(self, receiver: Id) -> Payload<'a> {
  method into_lua (line 125) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/hey.rs
  type EmberHey (line 11) | pub struct EmberHey {
    method owned (line 17) | pub fn owned(peers: HashMap<Id, Peer>) -> Ember<'static> {
  function from (line 23) | fn from(value: EmberHey) -> Self { Self::Hey(value) }
  method into_lua (line 27) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> { lua.create_table()...

FILE: yazi-dds/src/ember/hi.rs
  type EmberHi (line 12) | pub struct EmberHi<'a> {
  function borrowed (line 19) | pub fn borrowed<I>(abilities: I) -> Ember<'a>
  function version (line 30) | pub fn version() -> &'static str {
  function from (line 36) | fn from(value: EmberHi<'a>) -> Self { Self::Hi(value) }
  method into_lua (line 40) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> { lua.create_table()...

FILE: yazi-dds/src/ember/hover.rs
  type EmberHover (line 10) | pub struct EmberHover<'a> {
  function borrowed (line 16) | pub fn borrowed(tab: Id, url: Option<&'a UrlBuf>) -> Ember<'a> {
  function owned (line 22) | pub fn owned(tab: Id, _: Option<&UrlBuf>) -> Ember<'static> { Self { tab...
  function from (line 26) | fn from(value: EmberHover<'a>) -> Self { Self::Hover(value) }
  method into_lua (line 30) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/load.rs
  type EmberLoad (line 11) | pub struct EmberLoad<'a> {
  function borrowed (line 18) | pub fn borrowed(tab: Id, url: &'a UrlBuf, stage: &'a FolderStage) -> Emb...
  function owned (line 24) | pub fn owned(tab: Id, url: &UrlBuf, stage: &FolderStage) -> Ember<'stati...
  function from (line 30) | fn from(value: EmberLoad<'a>) -> Self { Self::Load(value) }
  method into_lua (line 34) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/mount.rs
  type EmberMount (line 7) | pub struct EmberMount;
    method borrowed (line 10) | pub fn borrowed() -> Ember<'static> { Self.into() }
    method owned (line 12) | pub fn owned() -> Ember<'static> { Self::borrowed() }
  function from (line 16) | fn from(value: EmberMount) -> Self { Self::Mount(value) }
  method into_lua (line 20) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Ok(Value::Nil) }

FILE: yazi-dds/src/ember/move.rs
  type EmberMove (line 10) | pub struct EmberMove<'a> {
  function borrowed (line 15) | pub fn borrowed(items: &'a Vec<EmberMoveItem>) -> Ember<'a> {
  function owned (line 21) | pub fn owned(items: Vec<EmberMoveItem>) -> Ember<'static> {
  function from (line 27) | fn from(value: EmberMove<'a>) -> Self { Self::Move(value) }
  method into_lua (line 31) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {
  type EmberMoveItem (line 38) | pub struct EmberMoveItem {
  method into_lua (line 44) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/rename.rs
  type EmberRename (line 10) | pub struct EmberRename<'a> {
  function borrowed (line 17) | pub fn borrowed(tab: Id, from: &'a UrlBuf, to: &'a UrlBuf) -> Ember<'a> {
  function owned (line 23) | pub fn owned(tab: Id, from: &UrlBuf, to: &UrlBuf) -> Ember<'static> {
  function from (line 29) | fn from(value: EmberRename<'a>) -> Self { Self::Rename(value) }
  method into_lua (line 33) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/tab.rs
  type EmberTab (line 8) | pub struct EmberTab {
    method borrowed (line 13) | pub fn borrowed(id: Id) -> Ember<'static> { Self { id }.into() }
    method owned (line 15) | pub fn owned(id: Id) -> Ember<'static> { Self::borrowed(id) }
  function from (line 19) | fn from(value: EmberTab) -> Self { Self::Tab(value) }
  method into_lua (line 23) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/trash.rs
  type EmberTrash (line 10) | pub struct EmberTrash<'a> {
  function borrowed (line 15) | pub fn borrowed(urls: &'a Vec<UrlBuf>) -> Ember<'a> { Self { urls: Cow::...
  function owned (line 19) | pub fn owned(urls: Vec<UrlBuf>) -> Ember<'static> { Self { urls: Cow::Ow...
  function from (line 23) | fn from(value: EmberTrash<'a>) -> Self { Self::Trash(value) }
  method into_lua (line 27) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/ember/yank.rs
  type EmberYank (line 12) | pub struct EmberYank<'a>(UpdateYankedOpt<'a>);
  function borrowed (line 15) | pub fn borrowed(cut: bool, urls: &'a HashSet<UrlBufCov>) -> Ember<'a> {
  function owned (line 21) | pub fn owned(cut: bool, _: &HashSet<UrlBufCov>) -> Ember<'static> {
  function from (line 27) | fn from(value: EmberYank<'a>) -> Self { Self::Yank(value) }
  method into_lua (line 31) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> { self.0.into_lua(lu...

FILE: yazi-dds/src/lib.rs
  function init (line 7) | pub fn init() {
  function serve (line 37) | pub fn serve() {
  function shutdown (line 42) | pub async fn shutdown() { Pump::shutdown().await; }

FILE: yazi-dds/src/payload.rs
  type Payload (line 12) | pub struct Payload<'a> {
  function new (line 19) | pub fn new(body: Ember<'a>) -> Self { Self { receiver: Id(0), sender: *I...
  function flush (line 21) | pub(super) fn flush(&self) -> Result<()> {
  function try_flush (line 26) | pub(super) fn try_flush(&self) -> Result<()> {
  function with_receiver (line 37) | pub(super) fn with_receiver(mut self, receiver: Id) -> Self {
  function with_sender (line 42) | pub(super) fn with_sender(mut self, sender: Id) -> Self {
  function emit (line 49) | pub(super) fn emit(self) {
  type Err (line 55) | type Err = anyhow::Error;
  method from_str (line 57) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  function from (line 75) | fn from(value: Ember<'a>) -> Self { Self::new(value) }
  type Error (line 79) | type Error = ();
  function try_from (line 81) | fn try_from(value: Spark<'a>) -> Result<Self, Self::Error> {
  type Error (line 90) | type Error = anyhow::Error;
  function try_from (line 92) | fn try_from(mut a: ActionCow) -> Result<Self, Self::Error> {
  method fmt (line 98) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method into_lua (line 128) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/pubsub.rs
  type Pubsub (line 84) | pub struct Pubsub;
    method sub (line 87) | pub fn sub(plugin: &str, kind: &str, f: Function) -> bool { sub!(LOCAL...
    method sub_remote (line 89) | pub fn sub_remote(plugin: &str, kind: &str, f: Function) -> bool {
    method unsub (line 93) | pub fn unsub(plugin: &str, kind: &str) -> bool { unsub!(LOCAL)(plugin,...
    method unsub_remote (line 95) | pub fn unsub_remote(plugin: &str, kind: &str) -> bool {
    method r#pub (line 99) | pub fn r#pub(body: Ember<'static>) -> Result<()> {
    method pub_to (line 106) | pub fn pub_to(receiver: Id, body: Ember<'static>) -> Result<()> {
    method pub_inner_hi (line 120) | pub fn pub_inner_hi() -> bool {
    method pub_after_bulk (line 129) | pub fn pub_after_bulk<'a, I>(changes: I) -> Result<()>
    method any_remote_own (line 145) | fn any_remote_own(kind: &str) -> bool {

FILE: yazi-dds/src/pump.rs
  type Pump (line 17) | pub struct Pump;
    method push_duplicate (line 20) | pub fn push_duplicate<U>(from: U, to: U)
    method push_move (line 27) | pub fn push_move<U>(from: U, to: U)
    method push_trash (line 34) | pub fn push_trash<U>(target: U)
    method push_delete (line 41) | pub fn push_delete<U>(target: U)
    method push_download (line 48) | pub fn push_download<U>(target: U)
    method serve (line 55) | pub(super) fn serve() {
    method shutdown (line 104) | pub(super) async fn shutdown() {

FILE: yazi-dds/src/sendable.rs
  type Sendable (line 8) | pub struct Sendable;
    method value_to_data (line 11) | pub fn value_to_data(lua: &Lua, value: Value) -> mlua::Result<Data> {
    method data_to_value (line 71) | pub fn data_to_value(lua: &Lua, data: Data) -> mlua::Result<Value> {
    method data_to_value_ref (line 113) | pub fn data_to_value_ref(lua: &Lua, data: &Data) -> mlua::Result<Value> {
    method table_to_args (line 156) | pub fn table_to_args(lua: &Lua, t: Table) -> mlua::Result<HashMap<Data...
    method args_to_table (line 176) | pub fn args_to_table(lua: &Lua, args: HashMap<DataKey, Data>) -> mlua:...
    method args_to_table_ref (line 189) | pub fn args_to_table_ref(lua: &Lua, args: &HashMap<DataKey, Data>) -> ...
    method list_to_values (line 204) | pub fn list_to_values(lua: &Lua, data: Vec<Data>) -> mlua::Result<Mult...
    method values_to_list (line 208) | pub fn values_to_list(lua: &Lua, values: MultiValue) -> mlua::Result<V...
    method value_to_key (line 214) | fn value_to_key(value: Value) -> mlua::Result<DataKey> {
    method key_to_value (line 248) | fn key_to_value(lua: &Lua, key: DataKey) -> mlua::Result<Value> {
    method key_to_value_ref (line 258) | fn key_to_value_ref(lua: &Lua, key: &DataKey) -> mlua::Result<Value> {

FILE: yazi-dds/src/server.rs
  type Server (line 14) | pub(super) struct Server;
    method make (line 17) | pub(super) async fn make() -> Result<JoinHandle<()>> {
    method handle_hi (line 92) | fn handle_hi(s: String, id: &mut Option<Id>, tx: mpsc::UnboundedSender...
    method handle_hey (line 112) | fn handle_hey(clients: &HashMap<Id, Client>) {
    method handle_bye (line 121) | async fn handle_bye(id: Id, mut rx: UnboundedReceiver<String>, mut wri...

FILE: yazi-dds/src/spark/kind.rs
  type SparkKind (line 4) | pub enum SparkKind {
    method as_ref (line 28) | fn as_ref(&self) -> &str {
  method fmt (line 55) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.w...

FILE: yazi-dds/src/spark/spark.rs
  type Spark (line 6) | pub enum Spark<'a> {
  function from_lua (line 157) | pub fn from_lua(lua: &Lua, kind: SparkKind, value: Value) -> mlua::Resul...
  method into_lua (line 186) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> {

FILE: yazi-dds/src/state.rs
  type State (line 16) | pub struct State {
    method set (line 28) | pub fn set(&self, kind: &str, sender: u64, body: &str) -> bool {
    method load_or_create (line 48) | pub async fn load_or_create(&self) {
    method drain (line 55) | pub async fn drain(&self) -> Result<()> {
    method load (line 81) | async fn load(&self) -> Result<()> {
    method skip (line 105) | async fn skip(&self) -> Result<bool> {
  type Target (line 22) | type Target = RwLock<Option<HashMap<String, String>>>;
  method deref (line 24) | fn deref(&self) -> &Self::Target { &self.inner }

FILE: yazi-dds/src/stream.rs
  type Stream (line 3) | pub struct Stream;
    method connect (line 24) | pub async fn connect() -> std::io::Result<(ClientReader, ClientWriter)> {
    method connect (line 31) | pub async fn connect() -> std::io::Result<(ClientReader, ClientWriter)> {
    method bind (line 38) | pub(super) async fn bind() -> std::io::Result<ServerListener> {
    method bind (line 48) | pub(super) async fn bind() -> std::io::Result<ServerListener> {
    method socket_file (line 53) | fn socket_file() -> std::path::PathBuf {
  type ClientReader (line 8) | pub type ClientReader = Lines<BufReader<ReadHalf<tokio::net::UnixStream>>>;
  type ClientReader (line 10) | pub type ClientReader = Lines<BufReader<ReadHalf<tokio::net::TcpStream>>>;
  type ClientWriter (line 13) | pub(super) type ClientWriter = WriteHalf<tokio::net::UnixStream>;
  type ClientWriter (line 15) | pub(super) type ClientWriter = WriteHalf<tokio::net::TcpStream>;
  type ServerListener (line 18) | pub(super) type ServerListener = tokio::net::UnixListener;
  type ServerListener (line 20) | pub(super) type ServerListener = tokio::net::TcpListener;

FILE: yazi-emulator/src/brand.rs
  type Brand (line 7) | pub enum Brand {
    method from_csi (line 30) | pub(super) fn from_csi(resp: &str) -> Option<Self> {
    method from_env (line 46) | pub fn from_env() -> Option<Self> {
    method env (line 91) | fn env() -> (String, String) {

FILE: yazi-emulator/src/dimension.rs
  type Dimension (line 8) | pub struct Dimension {
    method from (line 16) | fn from(s: WindowSize) -> Self {
    method available (line 28) | pub fn available() -> Self {
    method ratio (line 44) | pub fn ratio(self) -> Option<(f64, f64)> {
    method cell_size (line 52) | pub fn cell_size() -> Option<(f64, f64)> {
  method from (line 22) | fn from(d: Dimension) -> Self {

FILE: yazi-emulator/src/emulator.rs
  type Emulator (line 17) | pub struct Emulator {
    method detect (line 38) | pub fn detect() -> Result<Self> {
    method move_lock (line 82) | pub fn move_lock<F, T>((x, y): (u16, u16), cb: F) -> Result<T>
    method read_until_da1 (line 114) | pub fn read_until_da1() -> String {
    method read_until_dsr (line 135) | pub fn read_until_dsr() -> String {
    method error_to_user (line 150) | async fn error_to_user() {
    method csi_16t (line 169) | fn csi_16t(resp: &str) -> Option<(u16, u16)> {
    method csi_gt_q (line 182) | fn csi_gt_q(resp: &str) -> Option<String> {
    method light_bg (line 187) | fn light_bg(resp: &str) -> Result<bool> {
    method force_16t (line 204) | fn force_16t((w, h): (u16, u16)) -> bool {
  method default (line 26) | fn default() -> Self {

FILE: yazi-emulator/src/mux.rs
  type Mux (line 16) | pub struct Mux;
    method csi (line 19) | pub fn csi(s: &str) -> Cow<'_, str> {
    method tmux_passthrough (line 30) | pub fn tmux_passthrough() {
    method tmux_drain (line 57) | pub fn tmux_drain() -> Result<()> {
    method tmux_sixel_flag (line 65) | pub fn tmux_sixel_flag() -> &'static str {
    method term_program (line 80) | pub(super) fn term_program() -> (Option<String>, Option<String>) {

FILE: yazi-emulator/src/unknown.rs
  type Unknown (line 2) | pub struct Unknown {

FILE: yazi-ffi/src/cf_dict.rs
  type CFDict (line 9) | pub struct CFDict(CFDictionaryRef);
    method take (line 12) | pub fn take(dict: CFDictionaryRef) -> Result<Self> {
    method value (line 19) | pub fn value(&self, key: &str) -> Result<*const c_void> {
    method bool (line 30) | pub fn bool(&self, key: &str) -> Result<bool> {
    method integer (line 36) | pub fn integer(&self, key: &str) -> Result<i64> {
    method os_string (line 42) | pub fn os_string(&self, key: &str) -> Result<OsString> {
    method path_buf (line 46) | pub fn path_buf(&self, key: &str) -> Result<PathBuf> {
  method drop (line 58) | fn drop(&mut self) { unsafe { CFRelease(self.0 as _) } }

FILE: yazi-ffi/src/cf_string.rs
  type CFString (line 7) | pub struct CFString(pub(super) CFStringRef);
    method new (line 10) | pub fn new(s: &str) -> Result<Self> {
    method len (line 27) | pub fn len(&self) -> usize { unsafe { CFStringGetLength(self.0) as _ } }
    method is_empty (line 29) | pub fn is_empty(&self) -> bool { self.len() == 0 }
    method os_string (line 31) | pub fn os_string(&self) -> Result<OsString> {
  type Target (line 51) | type Target = CFStringRef;
  method deref (line 53) | fn deref(&self) -> &Self::Target { &self.0 }
  method drop (line 57) | fn drop(&mut self) { unsafe { CFRelease(self.0 as _) }; }

FILE: yazi-ffi/src/disk_arbitration.rs
  function DASessionCreate (line 7) | pub fn DASessionCreate(allocator: CFAllocatorRef) -> *const c_void;
  function DADiskCreateFromBSDName (line 9) | pub fn DADiskCreateFromBSDName(
  function DADiskCopyDescription (line 15) | pub fn DADiskCopyDescription(disk: *const c_void) -> CFDictionaryRef;
  function DARegisterDiskAppearedCallback (line 17) | pub fn DARegisterDiskAppearedCallback(
  function DARegisterDiskDescriptionChangedCallback (line 24) | pub fn DARegisterDiskDescriptionChangedCallback(
  function DARegisterDiskDisappearedCallback (line 32) | pub fn DARegisterDiskDisappearedCallback(
  function DASessionScheduleWithRunLoop (line 39) | pub fn DASessionScheduleWithRunLoop(

FILE: yazi-ffi/src/io_kit.rs
  function IOServiceGetMatchingServices (line 8) | pub fn IOServiceGetMatchingServices(
  function IOServiceMatching (line 14) | pub fn IOServiceMatching(a: *const c_char) -> CFMutableDictionaryRef;
  function IOIteratorNext (line 16) | pub fn IOIteratorNext(iterator: mach_port_t) -> mach_port_t;
  function IORegistryEntryCreateCFProperty (line 18) | pub fn IORegistryEntryCreateCFProperty(
  function IOObjectRelease (line 25) | pub fn IOObjectRelease(obj: mach_port_t) -> kern_return_t;

FILE: yazi-fm/build.rs
  function main (line 3) | fn main() -> Result<(), Box<dyn Error>> {

FILE: yazi-fm/src/app/app.rs
  type App (line 13) | pub(crate) struct App {
    method serve (line 20) | pub(crate) async fn serve() -> Result<()> {
    method bootstrap (line 69) | fn bootstrap(&mut self) -> anyhow::Result<Data> {

FILE: yazi-fm/src/app/render.rs
  method render (line 18) | pub(crate) fn render(&mut self, partial: bool) -> Result<Data> {
  method render_partially (line 53) | pub(crate) fn render_partially(&mut self) -> Result<Data> {
  method patch (line 79) | fn patch(frame: CompletedFrame) {
  method routine (line 95) | fn routine(push: bool, cursor: Option<(Position, SetCursorStyle)>) {

FILE: yazi-fm/src/cmp/cmp.rs
  type Cmp (line 9) | pub(crate) struct Cmp<'a> {
  function new (line 14) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 18) | fn render(self, rect: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/confirm/body.rs
  type Body (line 5) | pub(crate) struct Body<'a> {
  function new (line 11) | pub(crate) fn new(core: &'a Core, border: bool) -> Self { Self { core, b...
  method render (line 15) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/confirm/buttons.rs
  type Buttons (line 4) | pub(crate) struct Buttons;
  method render (line 7) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/confirm/confirm.rs
  type Confirm (line 5) | pub(crate) struct Confirm<'a> {
  function new (line 10) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 14) | fn render(self, _: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/confirm/list.rs
  type List (line 5) | pub(crate) struct List<'a> {
  function new (line 10) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 14) | fn render(self, mut area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/dispatcher.rs
  type Dispatcher (line 15) | pub(super) struct Dispatcher<'a> {
  function new (line 21) | pub(super) fn new(app: &'a mut App) -> Self { Self { app } }
  function dispatch (line 24) | pub(super) fn dispatch(&mut self, event: Event) {
  function dispatch_call (line 41) | fn dispatch_call(&mut self, action: ActionCow) -> Result<()> {
  function dispatch_seq (line 55) | fn dispatch_seq(&mut self, mut actions: Vec<ActionCow>) -> Result<()> {
  function dispatch_render (line 66) | fn dispatch_render(&mut self, partial: bool) -> Result<()> {
  function dispatch_key (line 76) | fn dispatch_key(&mut self, key: KeyEvent) -> Result<()> {
  function dispatch_mouse (line 82) | fn dispatch_mouse(&mut self, mouse: MouseEvent) -> Result<()> {
  function dispatch_resize (line 88) | fn dispatch_resize(&mut self) -> Result<()> {
  function dispatch_focus (line 94) | fn dispatch_focus(&mut self) -> Result<()> {
  function dispatch_paste (line 100) | fn dispatch_paste(&mut self, str: String) -> Result<()> {

FILE: yazi-fm/src/executor.rs
  type Executor (line 9) | pub(super) struct Executor<'a> {
  function new (line 15) | pub(super) fn new(app: &'a mut App) -> Self { Self { app } }
  function execute (line 17) | pub(super) fn execute(&mut self, action: ActionCow) -> Result<Data> {
  function app (line 33) | fn app(&mut self, mut action: ActionCow) -> Result<Data> {
  function mgr (line 66) | fn mgr(&mut self, action: ActionCow) -> Result<Data> {
  function tasks (line 162) | fn tasks(&mut self, action: ActionCow) -> Result<Data> {
  function spot (line 192) | fn spot(&mut self, action: ActionCow) -> Result<Data> {
  function pick (line 217) | fn pick(&mut self, action: ActionCow) -> Result<Data> {
  function input (line 241) | fn input(&mut self, action: ActionCow) -> Result<Data> {
  function confirm (line 276) | fn confirm(&mut self, action: ActionCow) -> Result<Data> {
  function help (line 294) | fn help(&mut self, action: ActionCow) -> Result<Data> {
  function cmp (line 318) | fn cmp(&mut self, action: ActionCow) -> Result<Data> {
  function which (line 343) | fn which(&mut self, action: ActionCow) -> Result<Data> {
  function notify (line 360) | fn notify(&mut self, action: ActionCow) -> Result<Data> {

FILE: yazi-fm/src/help/bindings.rs
  type Bindings (line 5) | pub(super) struct Bindings<'a> {
  function new (line 10) | pub(super) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 14) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/help/help.rs
  type Help (line 7) | pub(crate) struct Help<'a> {
  function new (line 12) | pub fn new(core: &'a Core) -> Self { Self { core } }
  function tips (line 14) | fn tips() -> String {
  method render (line 23) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/input/input.rs
  type Input (line 5) | pub(crate) struct Input<'a> {
  function new (line 10) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 14) | fn render(self, _: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/logs.rs
  type Logs (line 12) | pub(super) struct Logs;
    method start (line 15) | pub(super) fn start() -> anyhow::Result<()> {

FILE: yazi-fm/src/main.rs
  function main (line 10) | async fn main() -> anyhow::Result<()> {

FILE: yazi-fm/src/mgr/modal.rs
  type Modal (line 8) | pub(crate) struct Modal<'a> {
  function new (line 14) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 18) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/mgr/preview.rs
  type Preview (line 5) | pub(crate) struct Preview<'a> {
  function new (line 11) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 15) | fn render(self, win: ratatui::layout::Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/notify/notify.rs
  type Notify (line 4) | pub(crate) struct Notify<'a> {
  function new (line 9) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  function tiles (line 11) | fn tiles<'m>(area: Rect, messages: impl Iterator<Item = &'m Message> + C...
  method render (line 34) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/panic.rs
  type Panic (line 3) | pub(super) struct Panic;
    method install (line 6) | pub(super) fn install() {

FILE: yazi-fm/src/pick/list.rs
  type List (line 6) | pub(crate) struct List<'a> {
  function new (line 11) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 15) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/pick/pick.rs
  type Pick (line 7) | pub(crate) struct Pick<'a> {
  function new (line 12) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 16) | fn render(self, _: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/root.rs
  type Root (line 10) | pub(super) struct Root<'a> {
  function new (line 15) | pub(super) fn new(core: &'a Core) -> Self { Self { core } }
  function reflow (line 17) | pub(super) fn reflow(area: Rect) -> mlua::Result<Table> {
  method render (line 25) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/router.rs
  type Router (line 9) | pub(super) struct Router<'a> {
  function new (line 14) | pub(super) fn new(app: &'a mut App) -> Self { Self { app } }
  function route (line 16) | pub(super) fn route(&mut self, key: Key) -> Result<bool> {
  function matches (line 38) | fn matches(&mut self, layer: Layer, key: Key) -> bool {

FILE: yazi-fm/src/signals.rs
  type Signals (line 8) | pub(super) struct Signals {
    method start (line 13) | pub(super) fn start() -> Result<Self> {
    method handle_sys (line 21) | fn handle_sys(n: libc::c_int) -> bool {
    method handle_sys (line 50) | fn handle_sys(_: ()) -> bool { unreachable!() }
    method handle_term (line 52) | fn handle_term(event: CrosstermEvent) {
    method spawn (line 67) | fn spawn(mut rx: mpsc::UnboundedReceiver<(bool, CompletionToken)>) -> ...

FILE: yazi-fm/src/spot/spot.rs
  type Spot (line 4) | pub(crate) struct Spot<'a> {
  function new (line 9) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 13) | fn render(self, win: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/tasks/list.rs
  type List (line 8) | pub(crate) struct List<'a> {
  function new (line 14) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 18) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/tasks/progress.rs
  type Progress (line 9) | pub(crate) struct Progress<'a> {
  function new (line 14) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 18) | fn render(self, _: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/tasks/tasks.rs
  type Tasks (line 7) | pub(crate) struct Tasks<'a> {
  function new (line 12) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  function area (line 14) | pub(super) fn area(area: Rect) -> Rect {
  method render (line 32) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/which/cand.rs
  type Cand (line 4) | pub(super) struct Cand<'a> {
  function new (line 10) | pub(super) fn new(cand: &'a Chord, times: usize) -> Self { Self { times,...
  function keys (line 12) | fn keys(&self) -> Vec<String> {
  method render (line 18) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fm/src/which/which.rs
  constant PADDING_X (line 7) | const PADDING_X: u16 = 1;
  constant PADDING_Y (line 8) | const PADDING_Y: u16 = 1;
  type Which (line 10) | pub(crate) struct Which<'a> {
  function new (line 15) | pub(crate) fn new(core: &'a Core) -> Self { Self { core } }
  method render (line 19) | fn render(self, area: Rect, buf: &mut Buffer) {

FILE: yazi-fs/src/cha/cha.rs
  type Cha (line 11) | pub struct Cha {
    method new (line 51) | pub fn new<T>(name: T, meta: Metadata) -> Self
    method from_dummy (line 58) | pub fn from_dummy<U>(_url: U, r#type: Option<ChaType>) -> Self
    method from_bare (line 73) | fn from_bare(m: &Metadata) -> Self {
    method hits (line 115) | pub fn hits(self, c: Self) -> bool {
    method attach (line 125) | pub fn attach(mut self, kind: ChaKind) -> Self {
    method is_link (line 133) | pub fn is_link(self) -> bool {
    method is_orphan (line 138) | pub fn is_orphan(self) -> bool {
    method is_hidden (line 143) | pub const fn is_hidden(self) -> bool {
    method is_dummy (line 151) | pub const fn is_dummy(self) -> bool { self.kind.contains(ChaKind::DUMM...
    method atime_dur (line 153) | pub fn atime_dur(self) -> anyhow::Result<Duration> {
    method btime_dur (line 161) | pub fn btime_dur(self) -> anyhow::Result<Duration> {
    method ctime_dur (line 169) | pub fn ctime_dur(self) -> anyhow::Result<Duration> {
    method mtime_dur (line 177) | pub fn mtime_dur(self) -> anyhow::Result<Duration> {
  type Target (line 26) | type Target = ChaMode;
  method deref (line 28) | fn deref(&self) -> &Self::Target { &self.mode }
  method default (line 32) | fn default() -> Self {

FILE: yazi-fs/src/cha/kind.rs
  method hidden (line 18) | pub(super) fn hidden<T>(_name: T, _meta: &Metadata) -> Self

FILE: yazi-fs/src/cha/mode.rs
  type Target (line 43) | type Target = ChaType;
  method deref (line 46) | fn deref(&self) -> &Self::Target {
  type Error (line 61) | type Error = anyhow::Error;
  method try_from (line 63) | fn try_from(value: u16) -> Result<Self, Self::Error> {
  function from (line 80) | fn from(value: ChaMode) -> Self {
  method permissions (line 91) | pub fn permissions(self, dummy: bool) -> [u8; 10] {
  method from_bare (line 138) | pub(super) fn from_bare(r#type: ChaType) -> Self {
  method is_exec (line 155) | pub const fn is_exec(self) -> bool { self.contains(Self::U_EXEC) }
  method is_sticky (line 158) | pub const fn is_sticky(self) -> bool { self.contains(Self::S_STICKY) }

FILE: yazi-fs/src/cha/type.rs
  type ChaType (line 6) | pub enum ChaType {
    method from (line 18) | fn from(value: ChaMode) -> Self { *value }
    method from (line 22) | fn from(value: FileType) -> Self {
    method is_file (line 61) | pub fn is_file(self) -> bool { self == Self::File }
    method is_dir (line 64) | pub fn is_dir(self) -> bool { self == Self::Dir }
    method is_block (line 67) | pub fn is_block(self) -> bool { self == Self::Block }
    method is_char (line 70) | pub fn is_char(self) -> bool { self == Self::Char }
    method is_sock (line 73) | pub fn is_sock(self) -> bool { self == Self::Sock }
    method is_fifo (line 76) | pub fn is_fifo(self) -> bool { self == Self::FIFO }

FILE: yazi-fs/src/cwd.rs
  type Cwd (line 10) | pub struct Cwd(ArcSwap<UrlBuf>);
    method path (line 31) | pub fn path(&self) -> PathBuf { self.0.load().as_url().unified_path()....
    method set (line 33) | pub fn set(&self, url: &UrlBuf, callback: fn()) -> bool {
    method ensure (line 46) | pub fn ensure(url: Url) -> Cow<Path> {
    method sync_cwd (line 88) | fn sync_cwd(callback: fn()) {
  type Target (line 13) | type Target = ArcSwap<UrlBuf>;
  method deref (line 15) | fn deref(&self) -> &Self::Target { &self.0 }
  method default (line 19) | fn default() -> Self {

FILE: yazi-fs/src/error/error.rs
  type Error (line 8) | pub enum Error {
    method from (line 15) | fn from(err: io::Error) -> Self {
    method from (line 31) | fn from(kind: io::ErrorKind) -> Self { Self::Kind(kind) }
    method fmt (line 35) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method custom (line 45) | pub fn custom(kind: &str, code: Option<i32>, message: &str) -> Result<...
    method kind (line 49) | pub fn kind(&self) -> io::ErrorKind {
    method kind_str (line 57) | pub fn kind_str(&self) -> &'static str { kind_to_str(self.kind()) }
    method raw_os_error (line 59) | pub fn raw_os_error(&self) -> Option<i32> {

FILE: yazi-fs/src/error/serde.rs
  function kind_to_str (line 8) | pub(super) fn kind_to_str(kind: io::ErrorKind) -> &'static str {
  function kind_from_str (line 56) | pub(super) fn kind_from_str(s: &str) -> Result<io::ErrorKind> {
  method serialize (line 105) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method deserialize (line 128) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

FILE: yazi-fs/src/file.rs
  type File (line 8) | pub struct File {
    method from (line 21) | fn from(value: &Self) -> Self { value.clone() }
    method from_dummy (line 26) | pub fn from_dummy(url: impl Into<UrlBuf>, r#type: Option<ChaType>) -> ...
    method chdir (line 33) | pub fn chdir(&self, wd: &Path) -> Self {
    method url_owned (line 41) | pub fn url_owned(&self) -> UrlBuf { self.url.clone() }
    method uri (line 44) | pub fn uri(&self) -> PathDyn<'_> { self.url.uri() }
    method urn (line 47) | pub fn urn(&self) -> PathDyn<'_> { self.url.urn() }
    method name (line 50) | pub fn name(&self) -> Option<Strand<'_>> { self.url.name() }
    method stem (line 53) | pub fn stem(&self) -> Option<Strand<'_>> { self.url.stem() }
  type Target (line 15) | type Target = Cha;
  method deref (line 17) | fn deref(&self) -> &Self::Target { &self.cha }
  method hash (line 57) | fn hash<H: Hasher>(&self, state: &mut H) {

FILE: yazi-fs/src/files.rs
  type Files (line 10) | pub struct Files {
    method new (line 35) | pub fn new(show_hidden: bool) -> Self { Self { show_hidden, ..Default:...
    method update_full (line 37) | pub fn update_full(&mut self, files: Vec<File>) {
    method update_part (line 48) | pub fn update_part(&mut self, files: Vec<File>, ticket: Id) {
    method update_size (line 72) | pub fn update_size(&mut self, mut sizes: HashMap<PathBufDyn, u64>) {
    method update_ioerr (line 87) | pub fn update_ioerr(&mut self) {
    method update_creating (line 93) | pub fn update_creating(&mut self, files: Vec<File>) {
    method update_deleting (line 123) | pub fn update_deleting(&mut self, urns: HashSet<PathBufDyn>) -> Vec<us...
    method update_deleting (line 158) | pub fn update_deleting(&mut self, mut urns: HashSet<PathBufDyn>) -> Ve...
    method update_updating (line 179) | pub fn update_updating(
    method update_upserting (line 224) | pub fn update_upserting(&mut self, files: HashMap<PathBufDyn, File>) {
    method catchup_revision (line 247) | pub fn catchup_revision(&mut self) -> bool {
    method split_files (line 257) | fn split_files(&self, files: impl IntoIterator<Item = File>) -> (Vec<F...
    method position (line 273) | pub fn position(&self, urn: PathDyn) -> Option<usize> { self.iter().po...
    method ticket (line 277) | pub fn ticket(&self) -> Id { self.ticket }
    method sorter (line 281) | pub fn sorter(&self) -> &FilesSorter { &self.sorter }
    method set_sorter (line 283) | pub fn set_sorter(&mut self, sorter: FilesSorter) {
    method filter (line 292) | pub fn filter(&self) -> Option<&Filter> { self.filter.as_ref() }
    method set_filter (line 294) | pub fn set_filter(&mut self, filter: Option<Filter>) -> bool {
    method set_show_hidden (line 319) | pub fn set_show_hidden(&mut self, state: bool) {
  type Target (line 25) | type Target = Vec<File>;
  method deref (line 27) | fn deref(&self) -> &Self::Target { &self.items }
  method deref_mut (line 31) | fn deref_mut(&mut self) -> &mut Self::Target { &mut self.items }

FILE: yazi-fs/src/filter.rs
  type Filter (line 7) | pub struct Filter {
    method new (line 13) | pub fn new(s: &str, case: FilterCase) -> Result<Self> {
    method matches (line 27) | pub fn matches<T>(&self, name: T) -> bool
    method highlighted (line 35) | pub fn highlighted(&self, name: impl AsStrand) -> Option<Vec<Range<usi...
  method eq (line 41) | fn eq(&self, other: &Self) -> bool { self.raw == other.raw }
  method fmt (line 45) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.w...
  type FilterCase (line 49) | pub enum FilterCase {
    method from (line 57) | fn from(a: &Action) -> Self {

FILE: yazi-fs/src/fns.rs
  function ok_or_not_found (line 5) | pub fn ok_or_not_found<T: Default>(result: io::Result<T>) -> io::Result<...
  function max_common_root (line 16) | pub fn max_common_root(urls: &[UrlBuf]) -> usize {
  function test_max_common_root (line 54) | fn test_max_common_root() {

FILE: yazi-fs/src/hash.rs
  type FsHash64 (line 8) | pub trait FsHash64 {
    method hash_u64 (line 9) | fn hash_u64(&self) -> u64;
    method hash_u64 (line 13) | fn hash_u64(&self) -> u64 { foldhash::fast::FixedState::default().hash...
    method hash_u64 (line 17) | fn hash_u64(&self) -> u64 { foldhash::fast::FixedState::default().hash...
  type FsHash128 (line 21) | pub trait FsHash128 {
    method hash_u128 (line 22) | fn hash_u128(&self) -> u128;
    method hash_u128 (line 26) | fn hash_u128(&self) -> u128 {
    method hash_u128 (line 38) | fn hash_u128(&self) -> u128 {

FILE: yazi-fs/src/lib.rs
  function init (line 5) | pub fn init() {

FILE: yazi-fs/src/mounts/linux.rs
  method monitor (line 12) | pub fn monitor<F>(me: &'static Locked, cb: F)
  method partitions (line 62) | fn partitions() -> Result<HashSet<String>> {
  method update (line 77) | async fn update(me: &'static Locked) {
  method all (line 88) | fn all(&self) -> Result<Vec<Partition>> {
  method mounts (line 126) | fn mounts() -> Result<Vec<Partition>> {
  method labels (line 144) | fn labels() -> HashMap<(u64, u64), OsString> {
  method unmangle_octal (line 167) | fn unmangle_octal(s: &str) -> Cow<'_, str> {

FILE: yazi-fs/src/mounts/macos.rs
  method monitor (line 15) | pub fn monitor<F>(me: &'static Locked, cb: F)
  method update (line 74) | fn update<F>(me: &'static Locked, cb: F, rt: &tokio::runtime::Handle)
  method all_partitions (line 95) | fn all_partitions(names: Vec<CString>) -> Result<Vec<Partition>> {
  method all_names (line 131) | fn all_names() -> Result<Vec<CString>> {
  method bsd_name (line 159) | fn bsd_name(service: mach_port_t) -> Result<CString> {

FILE: yazi-fs/src/mounts/mod.rs
  function init (line 9) | pub(super) fn init() { PARTITIONS.init(<_>::default()); }

FILE: yazi-fs/src/mounts/partition.rs
  type Partition (line 4) | pub struct Partition {
    method timeless (line 19) | pub fn timeless(&self) -> bool {
    method soundless (line 26) | pub fn soundless(&self) -> bool {
    method systemic (line 32) | pub fn systemic(&self) -> bool {
    method new (line 51) | pub(super) fn new(name: &std::ffi::OsStr) -> Self {
    method dev_name (line 56) | pub(super) fn dev_name(&self, full: bool) -> Option<&std::ffi::OsStr> {

FILE: yazi-fs/src/mounts/partitions.rs
  type Locked (line 9) | pub(super) type Locked = RwLock<Partitions>;
  type Partitions (line 14) | pub struct Partitions {
    method by_dev (line 30) | pub fn by_dev(&self, dev: u64) -> Option<&Partition> {
    method timeless (line 34) | pub fn timeless(&self, _cha: Cha) -> bool {
    method soundless (line 46) | pub fn soundless(&self, _cha: Cha) -> bool {
  type Target (line 23) | type Target = Vec<Partition>;
  method deref (line 25) | fn deref(&self) -> &Self::Target { &self.inner }

FILE: yazi-fs/src/op.rs
  type FilesOp (line 13) | pub enum FilesOp {
    method cwd (line 28) | pub fn cwd(&self) -> &UrlBuf {
    method emit (line 44) | pub fn emit(self) {
    method prepare (line 48) | pub fn prepare(cwd: &UrlBuf) -> Id {
    method rename (line 54) | pub fn rename(map: HashMap<UrlBuf, File>) {
    method mutate (line 79) | pub fn mutate(ops: Vec<Self>) {
    method chdir (line 101) | pub fn chdir(&self, wd: &Path) -> Self {
    method diff_recoverable (line 124) | pub fn diff_recoverable(&self, contains: impl Fn(&UrlBuf) -> bool) -> ...

FILE: yazi-fs/src/path/clean.rs
  function clean_url (line 3) | pub fn clean_url<'a>(url: impl Into<UrlCow<'a>>) -> UrlBuf {
  function clean_path_impl (line 15) | fn clean_path_impl(path: PathDyn, base: usize, trail: usize) -> (PathBuf...
  function test_clean_url (line 75) | fn test_clean_url() -> anyhow::Result<()> {

FILE: yazi-fs/src/path/expand.rs
  function expand_url (line 6) | pub fn expand_url<'a>(url: impl Into<UrlCow<'a>>) -> UrlCow<'a> { expand...
  function expand_url_impl (line 8) | fn expand_url_impl(url: UrlCow) -> UrlCow {
  function expand_variables (line 50) | fn expand_variables(p: PathCow) -> PathCow {
  function test_expand_url (line 85) | fn test_expand_url() -> Result<()> {

FILE: yazi-fs/src/path/path.rs
  function skip_url (line 3) | pub fn skip_url(url: &UrlBuf, n: usize) -> StrandCow<'_> {

FILE: yazi-fs/src/path/percent.rs
  constant SET (line 7) | const SET: &AsciiSet =
  type PercentEncoding (line 10) | pub trait PercentEncoding<'a> {
    method percent_encode (line 11) | fn percent_encode(self) -> Cow<'a, Path>;
    method percent_decode (line 13) | fn percent_decode<K>(self, kind: K) -> Result<PathCow<'a>>
  function percent_encode (line 19) | fn percent_encode(self) -> Cow<'a, Path> {
  function percent_decode (line 26) | fn percent_decode<K>(self, kind: K) -> Result<PathCow<'a>>

FILE: yazi-fs/src/path/relative.rs
  function path_relative_to (line 4) | pub fn path_relative_to<'a, 'b, P, Q>(from: P, to: Q) -> Result<PathCow<...
  function path_relative_to_impl (line 12) | fn path_relative_to_impl<'a>(from: PathCow<'_>, to: PathCow<'a>) -> Resu...
  function test_path_relative_to (line 55) | fn test_path_relative_to() {

FILE: yazi-fs/src/provider/attrs.rs
  type Attrs (line 6) | pub struct Attrs {
    method from (line 14) | fn from(value: Cha) -> Self {
    method has_times (line 66) | pub fn has_times(self) -> bool {
    method atime_dur (line 70) | pub fn atime_dur(self) -> Option<Duration> { self.atime?.duration_sinc...
    method btime_dur (line 72) | pub fn btime_dur(self) -> Option<Duration> { self.btime?.duration_sinc...
    method mtime_dur (line 74) | pub fn mtime_dur(self) -> Option<Duration> { self.mtime?.duration_sinc...
  type Error (line 20) | type Error = ();
  function try_from (line 22) | fn try_from(value: Attrs) -> Result<Self, Self::Error> {
  type Error (line 53) | type Error = ();
  function try_from (line 55) | fn try_from(value: Attrs) -> Result<Self, Self::Error> {

FILE: yazi-fs/src/provider/capabilities.rs
  type Capabilities (line 2) | pub struct Capabilities {

FILE: yazi-fs/src/provider/local/absolute.rs
  function try_absolute (line 7) | pub fn try_absolute<'a, U>(url: U) -> Option<UrlCow<'a>>
  function try_absolute_impl (line 14) | fn try_absolute_impl<'a>(url: UrlCow<'a>) -> Option<UrlCow<'a>> {

FILE: yazi-fs/src/provider/local/calculator.rs
  type Task (line 8) | type Task = Either<PathBuf, std::fs::ReadDir>;
  type SizeCalculator (line 10) | pub enum SizeCalculator {
    method new (line 16) | pub async fn new(path: &Path) -> io::Result<Self> {
    method cha (line 31) | pub fn cha(&self) -> Cha {
    method total (line 37) | pub async fn total(path: &Path) -> io::Result<u64> {
    method next (line 46) | pub async fn next(&mut self) -> io::Result<Option<u64>> {
    method next_chunk (line 75) | fn next_chunk(buf: &mut VecDeque<Either<PathBuf, std::fs::ReadDir>>) -...

FILE: yazi-fs/src/provider/local/casefold.rs
  function match_name_case (line 3) | pub async fn match_name_case(path: impl AsRef<Path>) -> bool {
  function casefold (line 8) | pub(super) async fn casefold(path: impl AsRef<Path>) -> io::Result<PathB...
  function casefold_impl (line 14) | fn casefold_impl(path: PathBuf) -> io::Result<PathBuf> {
  function casefold_impl (line 44) | fn casefold_impl(path: PathBuf) -> io::Result<PathBuf> {
  function casefold_impl (line 105) | fn casefold_impl(path: PathBuf) -> io::Result<PathBuf> {
  function final_path (line 161) | fn final_path(path: &Path) -> io::Result<PathBuf> {
  function final_path (line 182) | fn final_path(path: &Path) -> io::Result<PathBuf> {
  function try_from_fd (line 248) | fn try_from_fd(fd: std::os::fd::RawFd, needle: &Path) -> Option<PathBuf> {

FILE: yazi-fs/src/provider/local/copier.rs
  function copy_impl (line 7) | pub(super) async fn copy_impl(from: PathBuf, to: PathBuf, attrs: Attrs) ...
  function copy_with_progress_impl (line 51) | pub(super) fn copy_with_progress_impl(

FILE: yazi-fs/src/provider/local/dir_entry.rs
  type DirEntry (line 7) | pub enum DirEntry {
  method file_type (line 13) | async fn file_type(&self) -> io::Result<ChaType> {
  method metadata (line 19) | async fn metadata(&self) -> io::Result<Cha> {
  method name (line 27) | fn name(&self) -> StrandCow<'_> {
  method path (line 33) | fn path(&self) -> PathBufDyn {
  method url (line 39) | fn url(&self) -> UrlBuf {

FILE: yazi-fs/src/provider/local/gate.rs
  type Gate (line 8) | pub struct Gate(tokio::fs::OpenOptions);
  type File (line 11) | type File = tokio::fs::File;
  method append (line 13) | fn append(&mut self, append: bool) -> &mut Self {
  method attrs (line 18) | fn attrs(&mut self, _attrs: Attrs) -> &mut Self {
  method create (line 26) | fn create(&mut self, create: bool) -> &mut Self {
  method create_new (line 31) | fn create_new(&mut self, create_new: bool) -> &mut Self {
  method open (line 36) | async fn open<U>(&self, url: U) -> io::Result<Self::File>
  method read (line 48) | fn read(&mut self, read: bool) -> &mut Self {
  method truncate (line 53) | fn truncate(&mut self, truncate: bool) -> &mut Self {
  method write (line 58) | fn write(&mut self, write: bool) -> &mut Self {

FILE: yazi-fs/src/provider/local/identical.rs
  function identical (line 4) | pub async fn identical<P, Q>(a: P, b: Q) -> io::Result<bool>
  function identical_impl (line 14) | fn identical_impl(a: PathBuf, b: PathBuf) -> io::Result<bool> {
  function identical_impl (line 26) | fn identical_impl(a: PathBuf, b: PathBuf) -> io::Result<bool> {

FILE: yazi-fs/src/provider/local/local.rs
  type Local (line 9) | pub struct Local<'a> {
  type File (line 15) | type File = tokio::fs::File;
  type Gate (line 16) | type Gate = super::Gate;
  type Me (line 17) | type Me<'b> = Local<'b>;
  type ReadDir (line 18) | type ReadDir = super::ReadDir;
  type UrlCow (line 19) | type UrlCow = UrlCow<'a>;
  method absolute (line 21) | async fn absolute(&self) -> io::Result<Self::UrlCow> {
  method canonicalize (line 27) | async fn canonicalize(&self) -> io::Result<UrlBuf> {
  method capabilities (line 32) | fn capabilities(&self) -> Capabilities { Capabilities { symlink: true } }
  method casefold (line 34) | async fn casefold(&self) -> io::Result<UrlBuf> {
  method copy (line 39) | async fn copy<P>(&self, to: P, attrs: Attrs) -> io::Result<u64>
  method copy_with_progress (line 48) | fn copy_with_progress<P, A>(&self, to: P, attrs: A) -> io::Result<mpsc::...
  method create_dir (line 59) | async fn create_dir(&self) -> io::Result<()> { tokio::fs::create_dir(sel...
  method create_dir_all (line 62) | async fn create_dir_all(&self) -> io::Result<()> { tokio::fs::create_dir...
  method hard_link (line 65) | async fn hard_link<P>(&self, to: P) -> io::Result<()>
  method metadata (line 75) | async fn metadata(&self) -> io::Result<Cha> {
  method new (line 80) | async fn new<'b>(url: Url<'b>) -> io::Result<Self::Me<'b>> {
  method read_dir (line 90) | async fn read_dir(self) -> io::Result<Self::ReadDir> {
  method read_link (line 105) | async fn read_link(&self) -> io::Result<PathBufDyn> {
  method remove_dir (line 110) | async fn remove_dir(&self) -> io::Result<()> { tokio::fs::remove_dir(sel...
  method remove_dir_all (line 113) | async fn remove_dir_all(&self) -> io::Result<()> { tokio::fs::remove_dir...
  method remove_file (line 116) | async fn remove_file(&self) -> io::Result<()> { tokio::fs::remove_file(s...
  method rename (line 119) | async fn rename<P>(&self, to: P) -> io::Result<()>
  method symlink (line 129) | async fn symlink<S, F>(&self, original: S, _is_dir: F) -> io::Result<()>
  method symlink_dir (line 148) | async fn symlink_dir<S>(&self, original: S) -> io::Result<()>
  method symlink_file (line 165) | async fn symlink_file<S>(&self, original: S) -> io::Result<()>
  method symlink_metadata (line 182) | async fn symlink_metadata(&self) -> io::Result<Cha> {
  method trash (line 189) | async fn trash(&self) -> io::Result<()> {
  method url (line 212) | fn url(&self) -> Url<'_> { self.url }
  method write (line 215) | async fn write<C>(&self, contents: C) -> io::Result<()>
  function read (line 225) | pub async fn read(&self) -> io::Result<Vec<u8>> { tokio::fs::read(self.p...
  function read_to_string (line 228) | pub async fn read_to_string(&self) -> io::Result<String> {
  function regular (line 233) | pub fn regular<P>(path: &'a P) -> Self

FILE: yazi-fs/src/provider/local/read_dir.rs
  type ReadDir (line 7) | pub enum ReadDir {
  type Entry (line 13) | type Entry = super::DirEntry;
  method next (line 15) | async fn next(&mut self) -> io::Result<Option<Self::Entry>> {

FILE: yazi-fs/src/provider/traits.rs
  type Provider (line 9) | pub trait Provider: Sized {
    method absolute (line 16) | fn absolute(&self) -> impl Future<Output = io::Result<Self::UrlCow>>;
    method canonicalize (line 18) | fn canonicalize(&self) -> impl Future<Output = io::Result<UrlBuf>>;
    method capabilities (line 20) | fn capabilities(&self) -> Capabilities;
    method casefold (line 22) | fn casefold(&self) -> impl Future<Output = io::Result<UrlBuf>>;
    method copy (line 24) | fn copy<P>(&self, to: P, attrs: Attrs) -> impl Future<Output = io::Res...
    method copy_with_progress (line 28) | fn copy_with_progress<P, A>(
    method create (line 37) | fn create(&self) -> impl Future<Output = io::Result<Self::File>> {
    method create_dir (line 41) | fn create_dir(&self) -> impl Future<Output = io::Result<()>>;
    method create_dir_all (line 43) | fn create_dir_all(&self) -> impl Future<Output = io::Result<()>> {
    method create_new (line 79) | fn create_new(&self) -> impl Future<Output = io::Result<Self::File>> {
    method gate (line 83) | fn gate(&self) -> Self::Gate { Self::Gate::default() }
    method hard_link (line 85) | fn hard_link<P>(&self, to: P) -> impl Future<Output = io::Result<()>>
    method metadata (line 89) | fn metadata(&self) -> impl Future<Output = io::Result<Cha>>;
    method new (line 91) | fn new<'a>(url: Url<'a>) -> impl Future<Output = io::Result<Self::Me<'...
    method open (line 93) | fn open(&self) -> impl Future<Output = io::Result<Self::File>> {
    method read_dir (line 97) | fn read_dir(self) -> impl Future<Output = io::Result<Self::ReadDir>>;
    method read_link (line 99) | fn read_link(&self) -> impl Future<Output = io::Result<PathBufDyn>>;
    method remove_dir (line 101) | fn remove_dir(&self) -> impl Future<Output = io::Result<()>>;
    method remove_dir_all (line 103) | fn remove_dir_all(&self) -> impl Future<Output = io::Result<()>> {
    method remove_dir_clean (line 133) | fn remove_dir_clean(&self) -> impl Future<Output = io::Result<()>> {
    method remove_file (line 160) | fn remove_file(&self) -> impl Future<Output = io::Result<()>>;
    method rename (line 162) | fn rename<P>(&self, to: P) -> impl Future<Output = io::Result<()>>
    method symlink (line 166) | fn symlink<S, F>(&self, original: S, _is_dir: F) -> impl Future<Output...
    method symlink_dir (line 171) | fn symlink_dir<S>(&self, original: S) -> impl Future<Output = io::Resu...
    method symlink_file (line 178) | fn symlink_file<S>(&self, original: S) -> impl Future<Output = io::Res...
    method symlink_metadata (line 185) | fn symlink_metadata(&self) -> impl Future<Output = io::Result<Cha>>;
    method trash (line 187) | fn trash(&self) -> impl Future<Output = io::Result<()>>;
    method url (line 189) | fn url(&self) -> Url<'_>;
    method write (line 191) | fn write<C>(&self, contents: C) -> impl Future<Output = io::Result<()>>
  type DirReader (line 200) | pub trait DirReader {
    method next (line 204) | fn next(&mut self) -> impl Future<Output = io::Result<Option<Self::Ent...
  type FileHolder (line 208) | pub trait FileHolder {
    method file_type (line 210) | fn file_type(&self) -> impl Future<Output = io::Result<ChaType>>;
    method metadata (line 213) | fn metadata(&self) -> impl Future<Output = io::Result<Cha>>;
    method name (line 216) | fn name(&self) -> StrandCow<'_>;
    method path (line 219) | fn path(&self) -> PathBufDyn;
    method url (line 222) | fn url(&self) -> UrlBuf;
  type FileBuilder (line 226) | pub trait FileBuilder: Sized + Default {
    method append (line 229) | fn append(&mut self, append: bool) -> &mut Self;
    method attrs (line 231) | fn attrs(&mut self, attrs: Attrs) -> &mut Self;
    method create (line 233) | fn create(&mut self, create: bool) -> &mut Self;
    method create_new (line 235) | fn create_new(&mut self, create_new: bool) -> &mut Self;
    method open (line 237) | fn open<U>(&self, url: U) -> impl Future<Output = io::Result<Self::File>>
    method read (line 241) | fn read(&mut self, read: bool) -> &mut Self;
    method truncate (line 243) | fn truncate(&mut self, truncate: bool) -> &mut Self;
    method write (line 245) | fn write(&mut self, write: bool) -> &mut Self;

FILE: yazi-fs/src/scheme.rs
  type FsScheme (line 7) | pub trait FsScheme {
    method cache (line 8) | fn cache(&self) -> Option<PathBuf>;
    method cache (line 12) | fn cache(&self) -> Option<PathBuf> {
    method cache (line 26) | fn cache(&self) -> Option<PathBuf> { self.as_scheme().cache() }

FILE: yazi-fs/src/sorter.rs
  type FilesSorter (line 10) | pub struct FilesSorter {
    method sort (line 20) | pub(super) fn sort(&self, items: &mut [File], sizes: &HashMap<PathBufD...
    method sort_alphabetically (line 85) | fn sort_alphabetically(&self, a: &File, b: &File) -> Ordering {
    method sort_naturally (line 94) | fn sort_naturally(&self, a: &File, b: &File) -> Ordering {
    method fallback (line 109) | fn fallback(&self, a: &File, b: &File, ord: Ordering) -> Ordering {
    method cmp (line 124) | fn cmp<T: Ord>(&self, a: T, b: T) -> Ordering { if self.reverse { b.cm...
    method cmp_insensitive (line 127) | fn cmp_insensitive(&self, a: &[u8], b: &[u8]) -> Ordering {

FILE: yazi-fs/src/sorting.rs
  type SortBy (line 8) | pub enum SortBy {
  type Err (line 21) | type Err = serde::de::value::Error;
  method from_str (line 23) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 29) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type SortFallback (line 46) | pub enum SortFallback {
  type Err (line 53) | type Err = serde::de::value::Error;
  method from_str (line 55) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 61) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: yazi-fs/src/splatter.rs
  type Iter (line 12) | type Iter<'a> = Peekable<std::iter::Copied<std::slice::Iter<'a, u8>>>;
  type Iter (line 14) | type Iter<'a> = Peekable<std::os::windows::ffi::EncodeWide<'a>>;
  type Buf (line 17) | type Buf = Vec<u8>;
  type Buf (line 19) | type Buf = Vec<u16>;
  type Splatter (line 22) | pub struct Splatter<T> {
  type Splatable (line 27) | pub trait Splatable {
    method tab (line 28) | fn tab(&self) -> usize;
    method selected (line 30) | fn selected(&self, tab: usize, idx: Option<usize>) -> impl Iterator<It...
    method hovered (line 32) | fn hovered(&self, tab: usize) -> Option<Url<'_>>;
    method yanked (line 34) | fn yanked(&self) -> impl Iterator<Item = Url<'_>>;
    method tab (line 252) | fn tab(&self) -> usize { 0 }
    method selected (line 254) | fn selected(&self, tab: usize, idx: Option<usize>) -> impl Iterator<It...
    method hovered (line 264) | fn hovered(&self, tab: usize) -> Option<Url<'_>> {
    method yanked (line 268) | fn yanked(&self) -> impl Iterator<Item = Url<'_>> { iter::empty() }
    method tab (line 278) | fn tab(&self) -> usize { self.0 }
    method selected (line 280) | fn selected(&self, tab: usize, mut idx: Option<usize>) -> impl Iterato...
    method hovered (line 293) | fn hovered(&self, tab: usize) -> Option<Url<'_>> {
    method yanked (line 303) | fn yanked(&self) -> impl Iterator<Item = Url<'_>> {
  function b2c (line 38) | fn b2c(b: u8) -> Option<char> { Some(b as char) }
  function b2c (line 40) | fn b2c(b: u16) -> Option<char> { char::from_u32(b as u32) }
  function cue (line 42) | fn cue(buf: &mut Buf, s: impl AsRef<OsStr>) {
  function new (line 53) | pub fn new(src: T) -> Self { Self { tab: src.tab() + 1, src } }
  function splat (line 55) | pub fn splat(mut self, cmd: impl AsRef<OsStr>) -> OsString {
  function visit (line 76) | fn visit(&mut self, it: &mut Iter, buf: &mut Buf) {
  function visit_selected (line 91) | fn visit_selected(&mut self, it: &mut Iter, buf: &mut Buf) {
  function visit_hovered (line 112) | fn visit_hovered(&mut self, it: &mut Iter, buf: &mut Buf) {
  function visit_dirname (line 124) | fn visit_dirname(&mut self, it: &mut Iter, buf: &mut Buf) {
  function visit_tab (line 145) | fn visit_tab(&mut self, it: &mut Iter, buf: &mut Buf) {
  function visit_digit (line 157) | fn visit_digit(&mut self, it: &mut Iter, buf: &mut Buf) {
  function visit_yanked (line 178) | fn visit_yanked(&mut self, it: &mut Iter, buf: &mut Buf) {
  function visit_escape (line 195) | fn visit_escape(&mut self, it: &mut Iter, buf: &mut Buf) { buf.push(it.n...
  function visit_unknown (line 197) | fn visit_unknown(&mut self, it: &mut Iter, buf: &mut Buf) {
  function consume_digit (line 204) | fn consume_digit(&mut self, it: &mut Iter) -> Option<usize> {
  function spread (line 220) | pub fn spread(cmd: impl AsRef<OsStr>) -> bool {
  type Source (line 275) | struct Source(usize);
  function test_unix (line 310) | fn test_unix() {

FILE: yazi-fs/src/stage.rs
  type FolderStage (line 6) | pub enum FolderStage {
    method is_loading (line 14) | pub fn is_loading(&self) -> bool { *self == Self::Loading }

FILE: yazi-fs/src/url.rs
  type FsUrl (line 7) | pub trait FsUrl<'a> {
    method cache (line 8) | fn cache(&self) -> Option<PathBuf>;
    method cache_lock (line 10) | fn cache_lock(&self) -> Option<PathBuf>;
    method unified_path (line 12) | fn unified_path(self) -> Cow<'a, Path>;
    method unified_path_str (line 14) | fn unified_path_str(self) -> Cow<'a, OsStr>
  function cache (line 26) | fn cache(&self) -> Option<PathBuf> {
  function cache_lock (line 41) | fn cache_lock(&self) -> Option<PathBuf> {
  function unified_path (line 49) | fn unified_path(self) -> Cow<'a, Path> {
  method cache (line 60) | fn cache(&self) -> Option<PathBuf> { self.as_url().cache() }
  method cache_lock (line 62) | fn cache_lock(&self) -> Option<PathBuf> { self.as_url().cache_lock() }
  method unified_path (line 64) | fn unified_path(self) -> Cow<'static, Path> {
  function cache (line 75) | fn cache(&self) -> Option<PathBuf> { self.as_url().cache() }
  function cache_lock (line 77) | fn cache_lock(&self) -> Option<PathBuf> { self.as_url().cache_lock() }
  function unified_path (line 79) | fn unified_path(self) -> Cow<'a, Path> {

FILE: yazi-fs/src/xdg.rs
  type Xdg (line 3) | pub struct Xdg;
    method config_dir (line 6) | pub fn config_dir() -> PathBuf {
    method state_dir (line 30) | pub fn state_dir() -> PathBuf {
    method cache_dir (line 46) | pub fn cache_dir() -> &'static PathBuf {

FILE: yazi-parser/src/app/deprecate.rs
  type DeprecateOpt (line 6) | pub struct DeprecateOpt {
    type Error (line 11) | type Error = anyhow::Error;
    method try_from (line 13) | fn try_from(mut a: ActionCow) -> Result<Self, Self::Error> {
  method from_lua (line 23) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 27) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/app/mouse.rs
  type MouseOpt (line 5) | pub struct MouseOpt {
    method from (line 10) | fn from(event: MouseEvent) -> Self { Self { event } }
  method from_lua (line 14) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 18) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/app/plugin.rs
  type PluginOpt (line 11) | pub struct PluginOpt {
    type Error (line 19) | type Error = anyhow::Error;
    method try_from (line 21) | fn try_from(mut a: ActionCow) -> Result<Self, Self::Error> {
    method new_callback (line 51) | pub fn new_callback(id: impl Into<SStr>, f: impl PluginCallback) -> Se...
    method normalize_id (line 60) | fn normalize_id(s: SStr) -> SStr {
  method from_lua (line 43) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 47) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...
  type PluginMode (line 74) | pub enum PluginMode {
    method auto_then (line 90) | pub fn auto_then(self, sync: bool) -> Self {
  type Err (line 82) | type Err = serde::de::value::Error;
  method from_str (line 84) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type PluginCallback (line 99) | pub trait PluginCallback:
  method clone (line 110) | fn clone(&self) -> Self { dyn_clone::clone_box(&**self) }
  function fmt (line 114) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: yazi-parser/src/app/quit.rs
  type QuitOpt (line 7) | pub struct QuitOpt {
    type Error (line 15) | type Error = anyhow::Error;
    method try_from (line 17) | fn try_from(mut a: ActionCow) -> Result<Self, Self::Error> {
  method from_lua (line 31) | fn from_lua(value: Value, lua: &Lua) -> mlua::Result<Self> { lua.from_va...
  method into_lua (line 35) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> { lua.to_value_with(...

FILE: yazi-parser/src/app/reflow.rs
  type ReflowOpt (line 5) | pub struct ReflowOpt {
    method from (line 10) | fn from(f: fn(Rect) -> mlua::Result<Table>) -> Self { Self { reflow: f...
  method from_lua (line 14) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 18) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/app/resume.rs
  type ResumeOpt (line 7) | pub struct ResumeOpt {
  method from_lua (line 14) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 18) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/app/stop.rs
  type StopOpt (line 6) | pub struct StopOpt {
  method from_lua (line 12) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 16) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/app/title.rs
  type TitleOpt (line 7) | pub struct TitleOpt {
  method from_lua (line 12) | fn from_lua(value: Value, lua: &Lua) -> mlua::Result<Self> { lua.from_va...
  method into_lua (line 16) | fn into_lua(self, lua: &Lua) -> mlua::Result<Value> { lua.to_value_with(...

FILE: yazi-parser/src/app/update_progress.rs
  type UpdateProgressOpt (line 8) | pub struct UpdateProgressOpt {
    type Error (line 13) | type Error = anyhow::Error;
    method try_from (line 15) | fn try_from(mut a: ActionCow) -> Result<Self, Self::Error> {
  method from_lua (line 25) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 29) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...
  type TaskSummary (line 34) | pub struct TaskSummary {

FILE: yazi-parser/src/arrow.rs
  type ArrowOpt (line 7) | pub struct ArrowOpt {
    type Error (line 12) | type Error = anyhow::Error;
    method try_from (line 14) | fn try_from(a: ActionCow) -> Result<Self, Self::Error> {
    method from (line 24) | fn from(n: isize) -> Self { Self { step: n.into() } }
  method into_lua (line 28) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/cmp/close.rs
  type CloseOpt (line 5) | pub struct CloseOpt {
    method from (line 10) | fn from(a: ActionCow) -> Self { Self { submit: a.bool("submit") } }
    method from (line 14) | fn from(submit: bool) -> Self { Self { submit } }
  method from_lua (line 18) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 22) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/cmp/show.rs
  type ShowOpt (line 6) | pub struct ShowOpt {
    type Error (line 14) | type Error = anyhow::Error;
    method try_from (line 16) | fn try_from(mut a: ActionCow) -> Result<Self, Self::Error> {
  method from_lua (line 26) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 30) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...
  type CmpItem (line 35) | pub struct CmpItem {

FILE: yazi-parser/src/cmp/trigger.rs
  type TriggerOpt (line 5) | pub struct TriggerOpt {
    method from (line 11) | fn from(mut a: ActionCow) -> Self {
  method from_lua (line 17) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 21) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/confirm/close.rs
  type CloseOpt (line 5) | pub struct CloseOpt {
    method from (line 10) | fn from(a: ActionCow) -> Self { Self { submit: a.bool("submit") } }
    method from (line 14) | fn from(submit: bool) -> Self { Self { submit } }
  method from_lua (line 18) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 22) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/confirm/show.rs
  type ShowOpt (line 7) | pub struct ShowOpt {
    type Error (line 13) | type Error = anyhow::Error;
    method try_from (line 15) | fn try_from(mut a: ActionCow) -> Result<Self, Self::Error> {
    method from (line 29) | fn from(value: Box<Self>) -> Self { *value }
  method from_lua (line 33) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 37) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/help/toggle.rs
  type ToggleOpt (line 5) | pub struct ToggleOpt {
    type Error (line 10) | type Error = anyhow::Error;
    method try_from (line 12) | fn try_from(a: ActionCow) -> Result<Self, Self::Error> { Ok(Self { lay...
    method from (line 16) | fn from(layer: Layer) -> Self { Self { layer } }
  method from_lua (line 20) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 24) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/input/close.rs
  type CloseOpt (line 5) | pub struct CloseOpt {
    method from (line 10) | fn from(a: ActionCow) -> Self { Self { submit: a.bool("submit") } }
    method from (line 14) | fn from(submit: bool) -> Self { Self { submit } }
  method from_lua (line 18) | fn from_lua(_: Value, _: &Lua) -> mlua::Result<Self> { Err("unsupported"...
  method into_lua (line 22) | fn into_lua(self, _: &Lua) -> mlua::Result<Value> { Err("unsupported".in...

FILE: yazi-parser/src/mgr/cd.rs
  type CdOpt (line 8) | pub struct CdOpt {
    method from (line 15) | fn from(mut a: ActionCow) -> Self {
    method from (line 37) | fn from((target, source): (UrlBuf, CdSo

[
  {
    "path": ".cargo/config.toml",
    "chars": 580,
    "preview": "[env]\nMACOSX_DEPLOYMENT_TARGET  = \"10.12\"\nJEMALLOC_SYS_WITH_LG_PAGE = \"16\"\n\n# environment variable for tikv-jemalloc-sys"
  },
  {
    "path": ".envrc",
    "chars": 9,
    "preview": "use flake"
  },
  {
    "path": ".github/DISCUSSION_TEMPLATE/1-q-a.yml",
    "chars": 1588,
    "preview": "body:\n  - type: dropdown\n    id: os\n    attributes:\n      label: What system are you running Yazi on?\n      options:\n   "
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug.yml",
    "chars": 2349,
    "preview": "name: 🐞 Bug Report\ndescription: Create a report to help us improve\nlabels: [bug]\nassignees: []\nbody:\n  - type: dropdown\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/config.yml",
    "chars": 710,
    "preview": "blank_issues_enabled: false\ncontact_links:\n  - name: 🚧 Build Issues\n    url: https://github.com/sxyazi/yazi/discussions/"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature.yml",
    "chars": 1706,
    "preview": "name: 💡 Feature Request\ndescription: Suggest an idea for this project\nlabels: [feature]\nassignees: []\nbody:\n  - type: te"
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 305,
    "preview": "version: 2\nupdates:\n  - package-ecosystem: \"github-actions\"\n    directory: \"/\"\n    schedule:\n      interval: \"weekly\"\n  "
  },
  {
    "path": ".github/pull_request_template.md",
    "chars": 663,
    "preview": "## Which issue does this PR resolve?\n\n<!--\nFor any fixes and enhancements, we usually require an associated issue to be "
  },
  {
    "path": ".github/workflows/cachix.yml",
    "chars": 559,
    "preview": "name: Cachix\n\non:\n  push:\n    branches: [main]\n\npermissions:\n  contents: read\n\njobs:\n  publish:\n    name: Publish Flake\n"
  },
  {
    "path": ".github/workflows/check.yml",
    "chars": 1227,
    "preview": "name: Check\n\non:\n  push:\n    branches: [main]\n  pull_request:\n    branches: [main]\n\nenv:\n  SCCACHE_GHA_ENABLED: true\n  R"
  },
  {
    "path": ".github/workflows/draft.yml",
    "chars": 7665,
    "preview": "name: Draft\n\non:\n  push:\n    branches: [main]\n    tags: [\"v[0-9]+.[0-9]+.[0-9]+\"]\n  workflow_dispatch:\n\nenv:\n  SCCACHE_G"
  },
  {
    "path": ".github/workflows/lock.yml",
    "chars": 867,
    "preview": "name: Lock Threads\n\non:\n  schedule:\n    - cron: \"5 3 * * *\"\n  workflow_dispatch:\n\nconcurrency:\n  group: lock\n\njobs:\n  lo"
  },
  {
    "path": ".github/workflows/no-response.yml",
    "chars": 363,
    "preview": "name: No Response\n\non:\n  issue_comment:\n    types: [created]\n  schedule:\n    - cron: \"10 * * * *\"\n\njobs:\n  no-response:\n"
  },
  {
    "path": ".github/workflows/publish.yml",
    "chars": 898,
    "preview": "name: Publish\n\non:\n  release:\n    types: [published]\n\npermissions:\n  contents: read\n\njobs:\n  winget:\n    runs-on: ubuntu"
  },
  {
    "path": ".github/workflows/test.yml",
    "chars": 677,
    "preview": "name: Test\n\non:\n  push:\n    branches: [main]\n  pull_request:\n    branches: [main]\n\nenv:\n  SCCACHE_GHA_ENABLED: true\n  RU"
  },
  {
    "path": ".github/workflows/validate-form.yml",
    "chars": 729,
    "preview": "name: Validate Form\n\non:\n  issues:\n    types: [opened, edited]\n  schedule:\n    - cron: \"20 * * * *\"\n\njobs:\n  check-versi"
  },
  {
    "path": ".gitignore",
    "chars": 102,
    "preview": "target/\nyazi-*/completions\nnode_modules/\n\n.DS_Store\n\nresult\nresult-*\n.direnv\n\n.idea/\n.vscode/\n\n*.snap\n"
  },
  {
    "path": ".luarc.json",
    "chars": 278,
    "preview": "{\n\t\"$schema\": \"https://raw.githubusercontent.com/LuaLS/vscode-lua/master/setting/schema.json\",\n\t\"runtime.version\": \"Lua "
  },
  {
    "path": "CHANGELOG.md",
    "chars": 80694,
    "preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 3389,
    "preview": "# Code of Conduct\n\n## Goal\n\nOur goal is to create a welcoming and safe space where anyone can contribute and seek help f"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 5331,
    "preview": "# Contributing to Yazi\n\nThank you for your interest in contributing to Yazi! We welcome contributions in the form of bug"
  },
  {
    "path": "Cargo.toml",
    "chars": 3345,
    "preview": "[workspace]\nresolver        = \"3\"\nmembers         = [ \"yazi-*\" ]\ndefault-members = [ \"yazi-fm\", \"yazi-cli\" ]\n\n[workspace"
  },
  {
    "path": "LICENSE",
    "chars": 1065,
    "preview": "MIT License\n\nCopyright (c) 2023 - sxyazi\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\no"
  },
  {
    "path": "LICENSE-ICONS",
    "chars": 1066,
    "preview": "MIT License\n\nCopyright (c) 2023 nvim-tree\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\n"
  },
  {
    "path": "README.md",
    "chars": 7164,
    "preview": "<div align=\"center\">\n\t<sup>Special thanks to:</sup><br>\n\n|<a href=\"https://go.warp.dev/yazi\" target=\"_blank\"><img alt=\"W"
  },
  {
    "path": "assets/yazi.desktop",
    "chars": 310,
    "preview": "[Desktop Entry]\nName=Yazi File Manager\nIcon=yazi\nComment=Blazing fast terminal file manager written in Rust, based on as"
  },
  {
    "path": "cspell.json",
    "chars": 2222,
    "preview": "{\"version\":\"0.2\",\"flagWords\":[],\"words\":[\"Punct\",\"KEYMAP\",\"splitn\",\"crossterm\",\"YAZI\",\"peekable\",\"ratatui\",\"syntect\",\"pb"
  },
  {
    "path": "flake.nix",
    "chars": 1889,
    "preview": "{\n  inputs = {\n    nixpkgs.url = \"github:NixOS/nixpkgs/nixpkgs-unstable\";\n    flake-utils.url = \"github:numtide/flake-ut"
  },
  {
    "path": "nix/shell.nix",
    "chars": 364,
    "preview": "{\n  mkShell,\n  yazi,\n  toolchain,\n  nodePackages,\n  yazi-unwrapped,\n}:\n\nmkShell {\n  packages = yazi.passthru.runtimePath"
  },
  {
    "path": "nix/yazi-unwrapped.nix",
    "chars": 2079,
    "preview": "{\n  rustPlatform,\n  version ? \"git\",\n  rev ? \"unknown\",\n  date ? \"19700101\",\n  lib,\n\n  installShellFiles,\n  fetchFromGit"
  },
  {
    "path": "nix/yazi.nix",
    "chars": 2207,
    "preview": "{\n  lib,\n  formats,\n  runCommand,\n  makeWrapper,\n\n  runtimeDeps ? (ps: ps),\n\n  # deps\n  file,\n  yazi-unwrapped,\n\n  # def"
  },
  {
    "path": "rustfmt.toml",
    "chars": 1156,
    "preview": "color                        = \"Never\"\ncondense_wildcard_suffixes   = true\nedition                      = \"2024\"\nenum_di"
  },
  {
    "path": "scripts/build.sh",
    "chars": 1065,
    "preview": "#!/usr/bin/env bash\nset -euo pipefail\n\nexport ARTIFACT_NAME=\"yazi-$1\"\nexport YAZI_GEN_COMPLETIONS=1\n\n# Build the target\n"
  },
  {
    "path": "scripts/bump.sh",
    "chars": 860,
    "preview": "#!/usr/bin/env bash\nset -euo pipefail\n\nSCRIPT_DIR=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\ncd \"$SCRIPT_DIR/..\"\n\ne"
  },
  {
    "path": "scripts/icons/generate.lua",
    "chars": 1699,
    "preview": "local dark = {\n\ticons_by_filename = require(\"default.icons_by_filename\"),\n\ticons_by_file_extension = require(\"default.ic"
  },
  {
    "path": "scripts/validate-form/main.js",
    "chars": 7730,
    "preview": "const LABEL_NAME = \"needs info\"\nconst RE_VERSION = /Yazi\\s+Version\\s*:\\s\\d+\\.\\d+\\.\\d+\\s\\(/gm\nconst RE_DEPENDENCIES = /De"
  },
  {
    "path": "scripts/validate-form/package.json",
    "chars": 224,
    "preview": "{\n\t\"name\": \"validate-form\",\n\t\"version\": \"1.0.0\",\n\t\"scripts\": {\n\t\t\"test\": \"echo \\\"Error: no test specified\\\" && exit 1\"\n\t"
  },
  {
    "path": "snap/snapcraft.yaml",
    "chars": 6426,
    "preview": "name: yazi\nbase: core24\nadopt-info: yazi\nsummary: Blazing fast terminal file manager written in Rust, based on async I/O"
  },
  {
    "path": "stylua.toml",
    "chars": 185,
    "preview": "syntax                    = \"Lua54\"\nindent_width              = 2\ncall_parentheses          = \"NoSingleTable\"\ncollapse_s"
  },
  {
    "path": "yazi-actor/Cargo.toml",
    "chars": 2223,
    "preview": "[package]\nname                   = \"yazi-actor\"\ndescription            = \"Yazi actor model\"\nversion.workspace      = tru"
  },
  {
    "path": "yazi-actor/README.md",
    "chars": 196,
    "preview": "# yazi-actor\n\nThis crate is part of [Yazi][source], and it is not supposed to be used outside, as there are no guarantee"
  },
  {
    "path": "yazi-actor/src/actor.rs",
    "chars": 287,
    "preview": "use anyhow::Result;\nuse yazi_dds::spark::SparkKind;\nuse yazi_shared::data::Data;\n\nuse crate::Ctx;\n\npub trait Actor {\n\tty"
  },
  {
    "path": "yazi-actor/src/app/accept_payload.rs",
    "chars": 1050,
    "preview": "use anyhow::Result;\nuse mlua::IntoLua;\nuse tracing::error;\nuse yazi_actor::lives::Lives;\nuse yazi_binding::runtime_scope"
  },
  {
    "path": "yazi-actor/src/app/bootstrap.rs",
    "chars": 737,
    "preview": "use anyhow::Result;\nuse yazi_actor::Ctx;\nuse yazi_boot::BOOT;\nuse yazi_macro::{act, succ};\nuse yazi_parser::{VoidOpt, mg"
  },
  {
    "path": "yazi-actor/src/app/deprecate.rs",
    "chars": 540,
    "preview": "use anyhow::Result;\nuse yazi_macro::act;\nuse yazi_parser::{app::DeprecateOpt, notify::{PushLevel, PushOpt}};\nuse yazi_sh"
  },
  {
    "path": "yazi-actor/src/app/focus.rs",
    "chars": 319,
    "preview": "use anyhow::Result;\nuse yazi_actor::Ctx;\nuse yazi_macro::act;\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\n\nus"
  },
  {
    "path": "yazi-actor/src/app/mod.rs",
    "chars": 157,
    "preview": "yazi_macro::mod_flat!(\n\taccept_payload\n\tbootstrap\n\tdeprecate\n\tfocus\n\tmouse\n\tplugin\n\tplugin_do\n\tquit\n\treflow\n\tresize\n\tres"
  },
  {
    "path": "yazi-actor/src/app/mouse.rs",
    "chars": 1702,
    "preview": "use anyhow::Result;\nuse crossterm::event::MouseEventKind;\nuse mlua::{ObjectLike, Table};\nuse tracing::error;\nuse yazi_ac"
  },
  {
    "path": "yazi-actor/src/app/plugin.rs",
    "chars": 936,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, succ};\nuse yazi_parser::app::{PluginMode, PluginOpt};\nuse yazi_plugin::loader:"
  },
  {
    "path": "yazi-actor/src/app/plugin_do.rs",
    "chars": 1556,
    "preview": "use anyhow::Result;\nuse mlua::ObjectLike;\nuse scopeguard::defer;\nuse tracing::{error, warn};\nuse yazi_binding::runtime_m"
  },
  {
    "path": "yazi-actor/src/app/quit.rs",
    "chars": 1108,
    "preview": "use anyhow::Result;\nuse yazi_boot::ARGS;\nuse yazi_fs::provider::{Provider, local::Local};\nuse yazi_parser::app::QuitOpt;"
  },
  {
    "path": "yazi-actor/src/app/reflow.rs",
    "chars": 1384,
    "preview": "use anyhow::Result;\nuse mlua::Value;\nuse ratatui::layout::Position;\nuse tracing::error;\nuse yazi_actor::lives::Lives;\nus"
  },
  {
    "path": "yazi-actor/src/app/resize.rs",
    "chars": 469,
    "preview": "use anyhow::Result;\nuse yazi_actor::Ctx;\nuse yazi_macro::act;\nuse yazi_parser::app::ReflowOpt;\nuse yazi_shared::data::Da"
  },
  {
    "path": "yazi-actor/src/app/resume.rs",
    "chars": 685,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::app::ResumeOpt;\nuse yazi_shared::data::Data;\nu"
  },
  {
    "path": "yazi-actor/src/app/stop.rs",
    "chars": 577,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::app::StopOpt;\nuse yazi_shared::data::Data;\n\nuse crate::{Actor"
  },
  {
    "path": "yazi-actor/src/app/title.rs",
    "chars": 819,
    "preview": "use anyhow::Result;\nuse crossterm::{execute, terminal::SetTitle};\nuse yazi_actor::Ctx;\nuse yazi_dds::spark::SparkKind;\nu"
  },
  {
    "path": "yazi-actor/src/app/update_progress.rs",
    "chars": 902,
    "preview": "use anyhow::Result;\nuse yazi_actor::Ctx;\nuse yazi_macro::{act, render, render_partial, succ};\nuse yazi_parser::app::Upda"
  },
  {
    "path": "yazi-actor/src/cmp/arrow.rs",
    "chars": 372,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::ArrowOpt;\nuse yazi_shared::data::Data;\nuse yazi_wid"
  },
  {
    "path": "yazi-actor/src/cmp/close.rs",
    "chars": 735,
    "preview": "use std::mem;\n\nuse anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::cmp::CloseOpt;\nuse yazi_shared:"
  },
  {
    "path": "yazi-actor/src/cmp/mod.rs",
    "chars": 49,
    "preview": "yazi_macro::mod_flat!(arrow close show trigger);\n"
  },
  {
    "path": "yazi-actor/src/cmp/show.rs",
    "chars": 1862,
    "preview": "use std::{mem, ops::ControlFlow};\n\nuse anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::cmp::{CmpItem, S"
  },
  {
    "path": "yazi-actor/src/cmp/trigger.rs",
    "chars": 4495,
    "preview": "use std::{io, mem};\n\nuse anyhow::Result;\nuse yazi_fs::{path::clean_url, provider::{DirReader, FileHolder}};\nuse yazi_mac"
  },
  {
    "path": "yazi-actor/src/confirm/arrow.rs",
    "chars": 579,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::ArrowOpt;\nuse yazi_shared::data::Data;\n\nuse crate::"
  },
  {
    "path": "yazi-actor/src/confirm/close.rs",
    "chars": 399,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::confirm::CloseOpt;\nuse yazi_shared::data::Data;\n\nus"
  },
  {
    "path": "yazi-actor/src/confirm/mod.rs",
    "chars": 41,
    "preview": "yazi_macro::mod_flat!(arrow close show);\n"
  },
  {
    "path": "yazi-actor/src/confirm/show.rs",
    "chars": 604,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::confirm::ShowOpt;\nuse yazi_shared::data::Data;"
  },
  {
    "path": "yazi-actor/src/context.rs",
    "chars": 2799,
    "preview": "use std::ops::{Deref, DerefMut};\n\nuse anyhow::{Result, anyhow};\nuse yazi_core::{Core, mgr::Tabs, tab::{Folder, Tab}, tas"
  },
  {
    "path": "yazi-actor/src/core/mod.rs",
    "chars": 34,
    "preview": "yazi_macro::mod_flat!(preflight);\n"
  },
  {
    "path": "yazi-actor/src/core/preflight.rs",
    "chars": 1071,
    "preview": "use anyhow::Result;\nuse mlua::{ErrorContext, ExternalError, IntoLua, Value};\nuse yazi_binding::runtime_scope;\nuse yazi_d"
  },
  {
    "path": "yazi-actor/src/help/arrow.rs",
    "chars": 373,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::ArrowOpt;\nuse yazi_shared::data::Data;\nuse yazi_wid"
  },
  {
    "path": "yazi-actor/src/help/escape.rs",
    "chars": 519,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\n\nuse cra"
  },
  {
    "path": "yazi-actor/src/help/filter.rs",
    "chars": 414,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\n\nuse crate::{"
  },
  {
    "path": "yazi-actor/src/help/mod.rs",
    "chars": 51,
    "preview": "yazi_macro::mod_flat!(arrow escape filter toggle);\n"
  },
  {
    "path": "yazi-actor/src/help/toggle.rs",
    "chars": 536,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::help::ToggleOpt;\nuse yazi_shared::data::Data;\n\nuse "
  },
  {
    "path": "yazi-actor/src/input/close.rs",
    "chars": 652,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::input::CloseOpt;\nuse yazi_shared::data::Data;\n"
  },
  {
    "path": "yazi-actor/src/input/complete.rs",
    "chars": 464,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, succ};\nuse yazi_shared::data::Data;\nuse yazi_widgets::input::parser::CompleteO"
  },
  {
    "path": "yazi-actor/src/input/escape.rs",
    "chars": 671,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\nuse yazi"
  },
  {
    "path": "yazi-actor/src/input/mod.rs",
    "chars": 51,
    "preview": "yazi_macro::mod_flat!(close complete escape show);\n"
  },
  {
    "path": "yazi-actor/src/input/show.rs",
    "chars": 573,
    "preview": "use std::ops::DerefMut;\n\nuse anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_shared::data::Data;\nuse yazi_"
  },
  {
    "path": "yazi-actor/src/lib.rs",
    "chars": 167,
    "preview": "extern crate self as yazi_actor;\n\nyazi_macro::mod_pub!(app cmp confirm core help input lives mgr notify pick spot tasks "
  },
  {
    "path": "yazi-actor/src/lives/core.rs",
    "chars": 1667,
    "preview": "use std::ops::Deref;\n\nuse mlua::{AnyUserData, IntoLua, MetaMethod, UserData, Value};\nuse paste::paste;\n\nuse super::{Live"
  },
  {
    "path": "yazi-actor/src/lives/file.rs",
    "chars": 4930,
    "preview": "use std::{ops::Deref, ptr};\n\nuse mlua::{AnyUserData, IntoLua, UserData, UserDataFields, UserDataMethods, Value};\nuse yaz"
  },
  {
    "path": "yazi-actor/src/lives/files.rs",
    "chars": 1299,
    "preview": "use std::ops::{Deref, Range};\n\nuse mlua::{AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMethods, Value};\nus"
  },
  {
    "path": "yazi-actor/src/lives/filter.rs",
    "chars": 616,
    "preview": "use std::ops::Deref;\n\nuse mlua::{AnyUserData, MetaMethod, UserData, UserDataMethods};\n\nuse super::{Lives, PtrCell};\n\npub"
  },
  {
    "path": "yazi-actor/src/lives/finder.rs",
    "chars": 644,
    "preview": "use std::ops::Deref;\n\nuse mlua::{AnyUserData, MetaMethod, UserData, UserDataMethods};\n\nuse super::{Lives, PtrCell};\n\npub"
  },
  {
    "path": "yazi-actor/src/lives/folder.rs",
    "chars": 1790,
    "preview": "use std::ops::{Deref, Range};\n\nuse mlua::{AnyUserData, UserData, UserDataFields, Value};\nuse yazi_binding::{FolderStage,"
  },
  {
    "path": "yazi-actor/src/lives/lives.rs",
    "chars": 1238,
    "preview": "use std::cell::RefCell;\n\nuse hashbrown::HashMap;\nuse mlua::{AnyUserData, UserData};\nuse scopeguard::defer;\nuse tracing::"
  },
  {
    "path": "yazi-actor/src/lives/mod.rs",
    "chars": 137,
    "preview": "yazi_macro::mod_flat!(core file files filter finder folder lives mode preference preview ptr selected tab tabs task task"
  },
  {
    "path": "yazi-actor/src/lives/mode.rs",
    "chars": 915,
    "preview": "use std::ops::Deref;\n\nuse mlua::{AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMethods};\n\nuse super::{Lives"
  },
  {
    "path": "yazi-actor/src/lives/preference.rs",
    "chars": 1485,
    "preview": "use std::ops::Deref;\n\nuse mlua::{AnyUserData, UserData, UserDataFields, Value};\nuse yazi_binding::cached_field;\n\nuse sup"
  },
  {
    "path": "yazi-actor/src/lives/preview.rs",
    "chars": 967,
    "preview": "use std::ops::Deref;\n\nuse mlua::{AnyUserData, UserData, UserDataFields, Value};\nuse yazi_binding::cached_field;\nuse yazi"
  },
  {
    "path": "yazi-actor/src/lives/ptr.rs",
    "chars": 748,
    "preview": "use std::{hash::{Hash, Hasher}, ops::Deref};\n\npub(super) struct PtrCell<T>(pub(super) *const T);\n\nimpl<T> Deref for PtrC"
  },
  {
    "path": "yazi-actor/src/lives/selected.rs",
    "chars": 401,
    "preview": "use mlua::AnyUserData;\n\nuse super::Lives;\nuse crate::lives::PtrCell;\n\n#[derive(Clone, Copy)]\npub(super) struct Selected;"
  },
  {
    "path": "yazi-actor/src/lives/tab.rs",
    "chars": 2046,
    "preview": "use std::{borrow::Cow, ops::Deref};\n\nuse mlua::{AnyUserData, UserData, UserDataFields, UserDataMethods, Value};\nuse yazi"
  },
  {
    "path": "yazi-actor/src/lives/tabs.rs",
    "chars": 931,
    "preview": "use std::ops::Deref;\n\nuse mlua::{AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMethods};\n\nuse super::{Lives"
  },
  {
    "path": "yazi-actor/src/lives/task.rs",
    "chars": 1205,
    "preview": "use std::ops::Deref;\n\nuse mlua::{AnyUserData, LuaSerdeExt, UserData, UserDataFields, Value};\nuse yazi_binding::{SER_OPT,"
  },
  {
    "path": "yazi-actor/src/lives/tasks.rs",
    "chars": 1082,
    "preview": "use std::ops::Deref;\n\nuse mlua::{AnyUserData, LuaSerdeExt, UserData, UserDataFields, Value};\nuse yazi_binding::{SER_OPT,"
  },
  {
    "path": "yazi-actor/src/lives/which.rs",
    "chars": 1093,
    "preview": "use std::ops::Deref;\n\nuse mlua::{AnyUserData, UserData, UserDataFields, Value};\nuse yazi_binding::cached_field;\n\nuse sup"
  },
  {
    "path": "yazi-actor/src/lives/yanked.rs",
    "chars": 1189,
    "preview": "use std::ops::Deref;\n\nuse mlua::{AnyUserData, MetaMethod, MultiValue, ObjectLike, UserData, UserDataFields, UserDataMeth"
  },
  {
    "path": "yazi-actor/src/mgr/arrow.rs",
    "chars": 648,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::ArrowOpt;\nuse yazi_shared::data::Data;\n\nuse cr"
  },
  {
    "path": "yazi-actor/src/mgr/back.rs",
    "chars": 434,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, succ};\nuse yazi_parser::{VoidOpt, mgr::CdSource};\nuse yazi_shared::data::Data;"
  },
  {
    "path": "yazi-actor/src/mgr/bulk_rename.rs",
    "chars": 8137,
    "preview": "use std::{hash::Hash, io::{Read, Write}, ops::Deref, path::Path};\n\nuse anyhow::{Result, anyhow};\nuse crossterm::{execute"
  },
  {
    "path": "yazi-actor/src/mgr/cd.rs",
    "chars": 2475,
    "preview": "use std::{mem, time::Duration};\n\nuse anyhow::Result;\nuse tokio::pin;\nuse tokio_stream::{StreamExt, wrappers::UnboundedRe"
  },
  {
    "path": "yazi-actor/src/mgr/close.rs",
    "chars": 409,
    "preview": "use anyhow::Result;\nuse yazi_macro::act;\nuse yazi_parser::mgr::CloseOpt;\nuse yazi_shared::data::Data;\n\nuse crate::{Actor"
  },
  {
    "path": "yazi-actor/src/mgr/copy.rs",
    "chars": 1495,
    "preview": "use anyhow::{Result, bail};\nuse yazi_macro::{act, succ};\nuse yazi_parser::mgr::CopyOpt;\nuse yazi_shared::{data::Data, st"
  },
  {
    "path": "yazi-actor/src/mgr/create.rs",
    "chars": 2074,
    "preview": "use anyhow::{Result, bail};\nuse yazi_config::popup::{ConfirmCfg, InputCfg};\nuse yazi_fs::{File, FilesOp};\nuse yazi_macro"
  },
  {
    "path": "yazi-actor/src/mgr/displace.rs",
    "chars": 662,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::{VoidOpt, mgr::DisplaceDoOpt};\nuse yazi_proxy::MgrProxy;\nuse "
  },
  {
    "path": "yazi-actor/src/mgr/displace_do.rs",
    "chars": 831,
    "preview": "use anyhow::{Result, bail};\nuse yazi_fs::FilesOp;\nuse yazi_macro::{act, succ};\nuse yazi_parser::mgr::{CdSource, Displace"
  },
  {
    "path": "yazi-actor/src/mgr/download.rs",
    "chars": 2047,
    "preview": "use std::{mem, time::{Duration, Instant}};\n\nuse anyhow::Result;\nuse futures::{StreamExt, stream::FuturesUnordered};\nuse "
  },
  {
    "path": "yazi-actor/src/mgr/enter.rs",
    "chars": 521,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, succ};\nuse yazi_parser::{VoidOpt, mgr::CdSource};\nuse yazi_shared::{data::Data"
  },
  {
    "path": "yazi-actor/src/mgr/escape.rs",
    "chars": 3100,
    "preview": "use anyhow::{Result, bail};\nuse yazi_macro::{act, render, render_and, succ};\nuse yazi_parser::{VoidOpt, mgr::EscapeOpt};"
  },
  {
    "path": "yazi-actor/src/mgr/filter.rs",
    "chars": 976,
    "preview": "use std::time::Duration;\n\nuse anyhow::Result;\nuse tokio::pin;\nuse tokio_stream::{StreamExt, wrappers::UnboundedReceiverS"
  },
  {
    "path": "yazi-actor/src/mgr/filter_do.rs",
    "chars": 776,
    "preview": "use anyhow::Result;\nuse yazi_fs::Filter;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::mgr::FilterOpt;\nuse yazi_"
  },
  {
    "path": "yazi-actor/src/mgr/find.rs",
    "chars": 915,
    "preview": "use std::time::Duration;\n\nuse anyhow::Result;\nuse tokio::pin;\nuse tokio_stream::{StreamExt, wrappers::UnboundedReceiverS"
  },
  {
    "path": "yazi-actor/src/mgr/find_arrow.rs",
    "chars": 704,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::mgr::FindArrowOpt;\nuse yazi_shared::data::Data"
  },
  {
    "path": "yazi-actor/src/mgr/find_do.rs",
    "chars": 846,
    "preview": "use anyhow::Result;\nuse yazi_core::tab::Finder;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::mgr::FindDoOpt;\nus"
  },
  {
    "path": "yazi-actor/src/mgr/follow.rs",
    "chars": 643,
    "preview": "use anyhow::Result;\nuse yazi_fs::path::clean_url;\nuse yazi_macro::{act, succ};\nuse yazi_parser::{VoidOpt, mgr::CdSource}"
  },
  {
    "path": "yazi-actor/src/mgr/forward.rs",
    "chars": 444,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, succ};\nuse yazi_parser::{VoidOpt, mgr::CdSource};\nuse yazi_shared::data::Data;"
  },
  {
    "path": "yazi-actor/src/mgr/hardlink.rs",
    "chars": 489,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::mgr::HardlinkOpt;\nuse yazi_shared::data::Data;\n\nuse crate::{A"
  },
  {
    "path": "yazi-actor/src/mgr/hidden.rs",
    "chars": 1449,
    "preview": "use anyhow::Result;\nuse yazi_core::tab::Folder;\nuse yazi_dds::spark::SparkKind;\nuse yazi_fs::FolderStage;\nuse yazi_macro"
  },
  {
    "path": "yazi-actor/src/mgr/hover.rs",
    "chars": 1010,
    "preview": "use anyhow::Result;\nuse yazi_dds::Pubsub;\nuse yazi_macro::{err, render, succ, tab};\nuse yazi_parser::mgr::HoverOpt;\nuse "
  },
  {
    "path": "yazi-actor/src/mgr/leave.rs",
    "chars": 596,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, succ};\nuse yazi_parser::{VoidOpt, mgr::CdSource};\nuse yazi_shared::{data::Data"
  },
  {
    "path": "yazi-actor/src/mgr/linemode.rs",
    "chars": 457,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::mgr::LinemodeOpt;\nuse yazi_shared::data::Data;\n\nuse"
  },
  {
    "path": "yazi-actor/src/mgr/link.rs",
    "chars": 467,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::mgr::LinkOpt;\nuse yazi_shared::data::Data;\n\nuse crate::{Actor"
  },
  {
    "path": "yazi-actor/src/mgr/mod.rs",
    "chars": 559,
    "preview": "yazi_macro::mod_flat!(\n\tarrow\n\tback\n\tbulk_rename\n\tcd\n\tclose\n\tcopy\n\tcreate\n\tdisplace\n\tdisplace_do\n\tdownload\n\tenter\n\tescap"
  },
  {
    "path": "yazi-actor/src/mgr/open.rs",
    "chars": 1786,
    "preview": "use anyhow::Result;\nuse yazi_boot::ARGS;\nuse yazi_fs::File;\nuse yazi_macro::{act, succ};\nuse yazi_parser::mgr::{OpenDoOp"
  },
  {
    "path": "yazi-actor/src/mgr/open_do.rs",
    "chars": 2080,
    "preview": "use anyhow::Result;\nuse hashbrown::HashMap;\nuse yazi_config::{YAZI, popup::PickCfg};\nuse yazi_macro::succ;\nuse yazi_pars"
  },
  {
    "path": "yazi-actor/src/mgr/paste.rs",
    "chars": 667,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, succ};\nuse yazi_parser::mgr::PasteOpt;\nuse yazi_shared::data::Data;\n\nuse crate"
  },
  {
    "path": "yazi-actor/src/mgr/peek.rs",
    "chars": 1373,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::mgr::PeekOpt;\nuse yazi_shared::data::Data;\n\nuse crate::{Actor"
  },
  {
    "path": "yazi-actor/src/mgr/quit.rs",
    "chars": 1698,
    "preview": "use std::time::Duration;\n\nuse anyhow::Result;\nuse tokio::{select, time};\nuse yazi_config::popup::ConfirmCfg;\nuse yazi_dd"
  },
  {
    "path": "yazi-actor/src/mgr/refresh.rs",
    "chars": 1465,
    "preview": "use anyhow::Result;\nuse yazi_core::tab::Folder;\nuse yazi_fs::{CWD, Files, FilesOp, cha::Cha};\nuse yazi_macro::{act, succ"
  },
  {
    "path": "yazi-actor/src/mgr/remove.rs",
    "chars": 1419,
    "preview": "use anyhow::Result;\nuse yazi_config::popup::ConfirmCfg;\nuse yazi_macro::{act, succ};\nuse yazi_parser::mgr::RemoveOpt;\nus"
  },
  {
    "path": "yazi-actor/src/mgr/rename.rs",
    "chars": 3306,
    "preview": "use anyhow::Result;\nuse yazi_config::popup::{ConfirmCfg, InputCfg};\nuse yazi_dds::Pubsub;\nuse yazi_fs::{File, FilesOp};\n"
  },
  {
    "path": "yazi-actor/src/mgr/reveal.rs",
    "chars": 1047,
    "preview": "use anyhow::Result;\nuse yazi_fs::{File, FilesOp};\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::mgr::RevealOpt;\n"
  },
  {
    "path": "yazi-actor/src/mgr/search.rs",
    "chars": 3035,
    "preview": "use std::{borrow::Cow, time::Duration};\n\nuse anyhow::Result;\nuse tokio::pin;\nuse tokio_stream::{StreamExt, wrappers::Unb"
  },
  {
    "path": "yazi-actor/src/mgr/seek.rs",
    "chars": 723,
    "preview": "use anyhow::Result;\nuse yazi_config::YAZI;\nuse yazi_macro::succ;\nuse yazi_parser::mgr::SeekOpt;\nuse yazi_plugin::isolate"
  },
  {
    "path": "yazi-actor/src/mgr/shell.rs",
    "chars": 1270,
    "preview": "use std::borrow::Cow;\n\nuse anyhow::Result;\nuse yazi_config::popup::InputCfg;\nuse yazi_macro::{act, succ};\nuse yazi_parse"
  },
  {
    "path": "yazi-actor/src/mgr/sort.rs",
    "chars": 1879,
    "preview": "use anyhow::Result;\nuse yazi_core::tab::Folder;\nuse yazi_dds::spark::SparkKind;\nuse yazi_fs::{FilesSorter, FolderStage};"
  },
  {
    "path": "yazi-actor/src/mgr/spot.rs",
    "chars": 868,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, succ};\nuse yazi_parser::mgr::SpotOpt;\nuse yazi_shared::{data::Data, pool::Inte"
  },
  {
    "path": "yazi-actor/src/mgr/stash.rs",
    "chars": 689,
    "preview": "use anyhow::Result;\nuse yazi_dds::spark::SparkKind;\nuse yazi_macro::succ;\nuse yazi_parser::mgr::StashOpt;\nuse yazi_share"
  },
  {
    "path": "yazi-actor/src/mgr/suspend.rs",
    "chars": 407,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\n\nuse crate::{Actor, Ctx"
  },
  {
    "path": "yazi-actor/src/mgr/tab_close.rs",
    "chars": 741,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::mgr::TabCloseOpt;\nuse yazi_shared::data::Data;"
  },
  {
    "path": "yazi-actor/src/mgr/tab_create.rs",
    "chars": 1467,
    "preview": "use anyhow::Result;\nuse yazi_core::tab::Tab;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::mgr::{CdSource, TabCr"
  },
  {
    "path": "yazi-actor/src/mgr/tab_rename.rs",
    "chars": 941,
    "preview": "use std::borrow::Cow;\n\nuse anyhow::Result;\nuse yazi_config::popup::InputCfg;\nuse yazi_macro::{act, render, succ};\nuse ya"
  },
  {
    "path": "yazi-actor/src/mgr/tab_swap.rs",
    "chars": 585,
    "preview": "use anyhow::Result;\nuse yazi_dds::Pubsub;\nuse yazi_macro::{err, render, succ};\nuse yazi_parser::ArrowOpt;\nuse yazi_share"
  },
  {
    "path": "yazi-actor/src/mgr/tab_switch.rs",
    "chars": 729,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::mgr::TabSwitchOpt;\nuse yazi_shared::data::Data"
  },
  {
    "path": "yazi-actor/src/mgr/toggle.rs",
    "chars": 859,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render_and, succ};\nuse yazi_parser::mgr::ToggleOpt;\nuse yazi_proxy::NotifyProxy;\nus"
  },
  {
    "path": "yazi-actor/src/mgr/toggle_all.rs",
    "chars": 1394,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::mgr::ToggleAllOpt;\nuse yazi_proxy::NotifyProxy;\nuse"
  },
  {
    "path": "yazi-actor/src/mgr/unyank.rs",
    "chars": 533,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\n\nuse cra"
  },
  {
    "path": "yazi-actor/src/mgr/update_files.rs",
    "chars": 2851,
    "preview": "use anyhow::Result;\nuse yazi_core::tab::Folder;\nuse yazi_fs::FilesOp;\nuse yazi_macro::{act, render, succ};\nuse yazi_pars"
  },
  {
    "path": "yazi-actor/src/mgr/update_mimes.rs",
    "chars": 1367,
    "preview": "use anyhow::Result;\nuse hashbrown::HashMap;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::mgr::UpdateMimesOpt;\nu"
  },
  {
    "path": "yazi-actor/src/mgr/update_paged.rs",
    "chars": 623,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::mgr::UpdatePagedOpt;\nuse yazi_shared::data::Data;\n\nuse crate:"
  },
  {
    "path": "yazi-actor/src/mgr/update_peeked.rs",
    "chars": 553,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::mgr::UpdatePeekedOpt;\nuse yazi_shared::data::Data;\n"
  },
  {
    "path": "yazi-actor/src/mgr/update_spotted.rs",
    "chars": 824,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::mgr::UpdateSpottedOpt;\nuse yazi_shared::data::Data;"
  },
  {
    "path": "yazi-actor/src/mgr/update_yanked.rs",
    "chars": 532,
    "preview": "use anyhow::Result;\nuse yazi_core::mgr::Yanked;\nuse yazi_macro::{render, succ};\nuse yazi_parser::mgr::UpdateYankedOpt;\nu"
  },
  {
    "path": "yazi-actor/src/mgr/upload.rs",
    "chars": 391,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::mgr::UploadOpt;\nuse yazi_shared::data::Data;\n\nuse crate::{Act"
  },
  {
    "path": "yazi-actor/src/mgr/visual_mode.rs",
    "chars": 613,
    "preview": "use std::collections::BTreeSet;\n\nuse anyhow::Result;\nuse yazi_core::tab::Mode;\nuse yazi_macro::{render, succ};\nuse yazi_"
  },
  {
    "path": "yazi-actor/src/mgr/watch.rs",
    "chars": 532,
    "preview": "use std::iter;\n\nuse anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\n\nuse cr"
  },
  {
    "path": "yazi-actor/src/mgr/yank.rs",
    "chars": 566,
    "preview": "use anyhow::Result;\nuse yazi_core::mgr::Yanked;\nuse yazi_macro::{act, render};\nuse yazi_parser::mgr::YankOpt;\nuse yazi_s"
  },
  {
    "path": "yazi-actor/src/notify/mod.rs",
    "chars": 34,
    "preview": "yazi_macro::mod_flat!(push tick);\n"
  },
  {
    "path": "yazi-actor/src/notify/push.rs",
    "chars": 840,
    "preview": "use std::time::Instant;\n\nuse anyhow::Result;\nuse yazi_core::notify::Message;\nuse yazi_dds::spark::SparkKind;\nuse yazi_ma"
  },
  {
    "path": "yazi-actor/src/notify/tick.rs",
    "chars": 1589,
    "preview": "use std::time::Duration;\n\nuse anyhow::Result;\nuse ratatui::layout::Rect;\nuse yazi_core::notify::Notify;\nuse yazi_emulato"
  },
  {
    "path": "yazi-actor/src/pick/arrow.rs",
    "chars": 373,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::ArrowOpt;\nuse yazi_shared::data::Data;\nuse yazi_wid"
  },
  {
    "path": "yazi-actor/src/pick/close.rs",
    "chars": 529,
    "preview": "use anyhow::Result;\nuse yazi_macro::{render, succ};\nuse yazi_parser::pick::CloseOpt;\nuse yazi_shared::data::Data;\n\nuse c"
  },
  {
    "path": "yazi-actor/src/pick/mod.rs",
    "chars": 41,
    "preview": "yazi_macro::mod_flat!(arrow close show);\n"
  },
  {
    "path": "yazi-actor/src/pick/show.rs",
    "chars": 530,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::pick::ShowOpt;\nuse yazi_shared::data::Data;\n\nu"
  },
  {
    "path": "yazi-actor/src/spot/arrow.rs",
    "chars": 667,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::ArrowOpt;\nuse yazi_shared::data::Data;\n\nuse cr"
  },
  {
    "path": "yazi-actor/src/spot/close.rs",
    "chars": 321,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\n\nuse crate::{Actor, Ctx"
  },
  {
    "path": "yazi-actor/src/spot/copy.rs",
    "chars": 722,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::spot::CopyOpt;\nuse yazi_shared::data::Data;\nuse yazi_widgets:"
  },
  {
    "path": "yazi-actor/src/spot/mod.rs",
    "chars": 47,
    "preview": "yazi_macro::mod_flat!(arrow close copy swipe);\n"
  },
  {
    "path": "yazi-actor/src/spot/swipe.rs",
    "chars": 338,
    "preview": "use anyhow::Result;\nuse yazi_macro::act;\nuse yazi_parser::ArrowOpt;\nuse yazi_shared::data::Data;\n\nuse crate::{Actor, Ctx"
  },
  {
    "path": "yazi-actor/src/tasks/arrow.rs",
    "chars": 504,
    "preview": "use anyhow::Result;\nuse yazi_core::tasks::Tasks;\nuse yazi_macro::{render, succ};\nuse yazi_parser::ArrowOpt;\nuse yazi_sha"
  },
  {
    "path": "yazi-actor/src/tasks/cancel.rs",
    "chars": 547,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\n\nuse cra"
  },
  {
    "path": "yazi-actor/src/tasks/close.rs",
    "chars": 468,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\n\nuse cra"
  },
  {
    "path": "yazi-actor/src/tasks/inspect.rs",
    "chars": 2068,
    "preview": "use std::io::Write;\n\nuse anyhow::Result;\nuse crossterm::{execute, terminal::{disable_raw_mode, enable_raw_mode}};\nuse sc"
  },
  {
    "path": "yazi-actor/src/tasks/mod.rs",
    "chars": 102,
    "preview": "yazi_macro::mod_flat!(arrow cancel close open_shell_compat inspect process_open show update_succeed);\n"
  },
  {
    "path": "yazi-actor/src/tasks/open_shell_compat.rs",
    "chars": 398,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::tasks::ProcessOpenOpt;\nuse yazi_shared::data::Data;\n\nuse crat"
  },
  {
    "path": "yazi-actor/src/tasks/process_open.rs",
    "chars": 374,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::tasks::ProcessOpenOpt;\nuse yazi_shared::data::Data;\n\nuse crat"
  },
  {
    "path": "yazi-actor/src/tasks/show.rs",
    "chars": 469,
    "preview": "use anyhow::Result;\nuse yazi_macro::{act, render, succ};\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\n\nuse cra"
  },
  {
    "path": "yazi-actor/src/tasks/update_succeed.rs",
    "chars": 383,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::tasks::UpdateSucceedOpt;\nuse yazi_shared::data::Data;\n\nuse cr"
  },
  {
    "path": "yazi-actor/src/which/activate.rs",
    "chars": 885,
    "preview": "use anyhow::Result;\nuse yazi_core::which::WhichSorter;\nuse yazi_dds::spark::SparkKind;\nuse yazi_macro::{render, succ};\nu"
  },
  {
    "path": "yazi-actor/src/which/dismiss.rs",
    "chars": 324,
    "preview": "use anyhow::Result;\nuse yazi_macro::succ;\nuse yazi_parser::VoidOpt;\nuse yazi_shared::data::Data;\n\nuse crate::{Actor, Ctx"
  },
  {
    "path": "yazi-actor/src/which/mod.rs",
    "chars": 41,
    "preview": "yazi_macro::mod_flat!(activate dismiss);\n"
  },
  {
    "path": "yazi-adapter/Cargo.toml",
    "chars": 1450,
    "preview": "[package]\nname                   = \"yazi-adapter\"\ndescription            = \"Yazi image adapter\"\nversion.workspace      ="
  },
  {
    "path": "yazi-adapter/README.md",
    "chars": 198,
    "preview": "# yazi-adapter\n\nThis crate is part of [Yazi][source], and it is not supposed to be used outside, as there are no guarant"
  },
  {
    "path": "yazi-adapter/src/adapter.rs",
    "chars": 3253,
    "preview": "use std::{env, fmt::Display, path::PathBuf};\n\nuse anyhow::Result;\nuse ratatui::layout::Rect;\nuse tracing::warn;\nuse yazi"
  },
  {
    "path": "yazi-adapter/src/adapters.rs",
    "chars": 1566,
    "preview": "use std::ops::{Deref, DerefMut};\n\nuse crate::Adapter;\n\npub(super) struct Adapters(Vec<Adapter>);\n\nimpl Deref for Adapter"
  },
  {
    "path": "yazi-adapter/src/drivers/chafa.rs",
    "chars": 1910,
    "preview": "use std::{io::Write, path::PathBuf, process::Stdio};\n\nuse ansi_to_tui::IntoText;\nuse anyhow::{Result, anyhow, bail};\nuse"
  },
  {
    "path": "yazi-adapter/src/drivers/iip.rs",
    "chars": 1873,
    "preview": "use std::{fmt::Write, io::Write as ioWrite, path::PathBuf};\n\nuse anyhow::Result;\nuse base64::{Engine, engine::{Config, g"
  },
  {
    "path": "yazi-adapter/src/drivers/kgp.rs",
    "chars": 6970,
    "preview": "use core::str;\nuse std::{io::Write, path::PathBuf};\n\nuse anyhow::Result;\nuse base64::{Engine, engine::general_purpose};\n"
  },
  {
    "path": "yazi-adapter/src/drivers/kgp_old.rs",
    "chars": 1945,
    "preview": "use core::str;\nuse std::{io::Write, path::PathBuf};\n\nuse anyhow::Result;\nuse base64::{Engine, engine::general_purpose};\n"
  },
  {
    "path": "yazi-adapter/src/drivers/mod.rs",
    "chars": 61,
    "preview": "yazi_macro::mod_flat!(chafa iip kgp kgp_old sixel ueberzug);\n"
  },
  {
    "path": "yazi-adapter/src/drivers/sixel.rs",
    "chars": 3218,
    "preview": "use std::{io::Write, path::PathBuf};\n\nuse anyhow::{Result, bail};\nuse crossterm::{cursor::MoveTo, queue};\nuse image::{Dy"
  },
  {
    "path": "yazi-adapter/src/drivers/ueberzug.rs",
    "chars": 3946,
    "preview": "use std::{path::PathBuf, process::Stdio};\n\nuse anyhow::{Result, bail};\nuse image::ImageReader;\nuse ratatui::layout::Rect"
  },
  {
    "path": "yazi-adapter/src/icc.rs",
    "chars": 2462,
    "preview": "use anyhow::Context;\nuse image::{ColorType, DynamicImage, GrayAlphaImage, GrayImage, ImageDecoder, RgbImage, RgbaImage, "
  },
  {
    "path": "yazi-adapter/src/image.rs",
    "chars": 3903,
    "preview": "use std::path::{Path, PathBuf};\n\nuse anyhow::Result;\nuse image::{DynamicImage, ImageDecoder, ImageError, ImageReader, Li"
  },
  {
    "path": "yazi-adapter/src/info.rs",
    "chars": 1074,
    "preview": "use std::path::PathBuf;\n\nuse image::{ImageDecoder, ImageError};\n\npub type ImageFormat = image::ImageFormat;\npub type Ima"
  },
  {
    "path": "yazi-adapter/src/lib.rs",
    "chars": 1007,
    "preview": "yazi_macro::mod_pub!(drivers);\n\nyazi_macro::mod_flat!(adapter adapters icc image info);\n\nuse yazi_emulator::{Brand, CLOS"
  },
  {
    "path": "yazi-binding/Cargo.toml",
    "chars": 1554,
    "preview": "[package]\nname                   = \"yazi-binding\"\ndescription            = \"Yazi Lua bindings\"\nversion.workspace      = "
  },
  {
    "path": "yazi-binding/README.md",
    "chars": 198,
    "preview": "# yazi-binding\n\nThis crate is part of [Yazi][source], and it is not supposed to be used outside, as there are no guarant"
  }
]

// ... and 864 more files (download for full content)