"anyhow",

"arc-swap",

"chrono",

"crossterm",

"fern",

"futures-util",

"helix-core",

"helix-dap",

"helix-loader",

"helix-lsp",

"helix-tui",

"helix-view",

"log",

"once_cell",

"ropey",

"serde",

"serde_json",

"bitflags",

"chardetng",

"clipboard-win",

"crossterm",

"futures-util",

"helix-core",

"helix-dap",

"helix-graphics",

"helix-lsp",

"helix-tui",

"log",

"once_cell",

"serde",

"serde_json",

"slotmap",

chrono = { version = "0.4", default-features = false, features = ["clock"] }

log = "0.4"

# config

toml = "0.5"

serde_json = "1.0"

serde = { version = "1.0", features = ["derive"] }

[target.'cfg(not(windows))'.dependencies] # https://github.com/vorner/signal-hook/issues/100

signal-hook-tokio = { version = "0.3", features = ["futures-v0_3"] }

};

#[cfg(feature = "lsp")]

use helix_lsp::{lsp, util::lsp_pos_to_pos, LspProgressMap};

#[cfg(feature = "lsp")]

use serde_json::json;

keymap::Keymaps,

ui::{self, overlay::overlayed},

};

&helix_loader::runtime_dir(),

));

let theme = config

.theme

.as_ref()

}

fn true_color(&self) -> bool {

}

#[cfg(windows)]

use anyhow::Result;

use helix_core::Position;

#[derive(Default)]

pub struct Args {

Ok(args)

}

}

use helix_view::document::Mode;

use serde::Deserialize;

use std::collections::HashMap;

use std::fmt::Display;

}

}

#[derive(Debug)]

pub enum ConfigLoadError {

BadConfig(TomlError),

#[test]

fn parsing_keymaps_config_file() {

use helix_core::hashmap;

use helix_view::document::Mode;

let sample_keymaps = r#"

[keys.insert]

let default_keys = Config::default().keys;

assert_eq!(default_keys, default());

}

}

pub mod application;

pub mod args;

pub mod config;

pub mod health;

helix-graphics = { version = "0.6", path = "../helix-graphics" }

helix-lsp = { version = "0.6", path = "../helix-lsp", optional = true }

helix-dap = { version = "0.6", path = "../helix-dap", optional = true }

tokio-stream = { version = "0.1", optional = true }

tokio = { version = "1", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot", "sync"], optional = true }

toml = "0.5"

log = "~0.4"

[target.'cfg(not(target_arch = "wasm32"))'.dependencies]

which = "4.2"

use super::{Context, Editor};

use crate::ui::{self, overlay::overlayed, FilePicker, Picker, Popup, Prompt, PromptEvent, Text};

compositor::{self, Compositor},

job::{Callback, Jobs},

};

use serde_json::{to_value, Value};

use tokio_stream::wrappers::UnboundedReceiverStream;

use anyhow::{anyhow, bail};

fn thread_picker(

cx: &mut Context,

let text_style = theme.get("ui.text.focus");

for scope in scopes.iter() {

use tui::text::{Span, Spans};

let response = block_on(debugger.variables(scope.variables_reference));

use super::{align_view, push_jump, Align, Context, Editor};

use helix_core::Selection;

use crate::ui::{self, overlay::overlayed, FileLocation, FilePicker, Popup, PromptEvent};

use std::borrow::Cow;

});

picker.move_down(); // pre-select the first item

vertical: 1,

horizontal: 1,

});

pub use lsp::*;

pub use typed::*;

use helix_core::{

comment, coords_at_pos, find_first_non_whitespace_char, find_root, graphemes,

history::UndoKind,

LineEnding, Position, Range, Rope, RopeGraphemes, RopeSlice, Selection, SmallVec, Tendril,

Transaction,

};

compositor::{self, Component, Compositor},

job::{self, Job, Jobs},

};

};

use futures_util::{FutureExt, StreamExt};

use std::{

borrow::Cow,

pub count: Option<NonZeroUsize>,

pub editor: &'a mut Editor,

pub on_next_key_callback: Option<Box<dyn FnOnce(&mut Context, KeyEvent)>>,

pub jobs: &'a mut Jobs,

}

}

}

/// A MappableCommand is either a static command like "jump_view_up" or a Typable command like

/// :format. It causes a side-effect on the state (usually by creating and applying a transaction).

}

fn suspend(_cx: &mut Context) {

}

fn add_newline_above(cx: &mut Context) {

fn replay_macro(cx: &mut Context) {

let reg = cx.register.unwrap_or('@');

let keys: Vec<KeyEvent> = if let Some([keys_str]) = cx.editor.registers.read(reg) {

Ok(keys) => keys,

Err(err) => {

cx.editor.set_error(format!("Invalid macro: {}", err));

use super::*;

use ui::completers::{self, Completer};

#[derive(Clone)]

pub mod macros;

pub use crate::commands::MappableCommand;

use arc_swap::{

access::{DynAccess, DynGuard},

ArcSwap,

};

use serde::Deserialize;

use std::{

borrow::Cow,

}

}

#[cfg(test)]

mod tests {

use super::macros::keymap;

use super::*;

use helix_core::hashmap;

#[test]

}

#[test]

fn aliased_modes_are_same_in_default_keymap() {

let keymaps = Keymaps::default().map();

let root = keymaps.get(&Mode::Normal).unwrap().root();

#[macro_use]

pub mod macros;

pub mod backend {

#[cfg(feature = "term")]

pub mod term;

}

pub mod clipboard;

pub mod compositor;

pub mod document;

pub mod editor;

pub use helix_graphics as graphics;

pub mod gutter;

pub mod job;

pub mod handlers {

#[cfg(feature = "dap")]

pub mod dap;

pub struct ViewId;

}

pub enum Align {

Top,

Center,

$crate::current_ref!($editor).1

}};

}

use std::borrow::Cow;

use helix_core::{Change, Transaction};

graphics::Rect,

input::{KeyCode, KeyEvent},

Document, Editor,

ui::{Completion, ProgressSpinners},

};

use helix_core::{

coords_at_pos, encoding,

unicode::width::UnicodeWidthStr,

LineEnding, Position, Range, Selection, Transaction,

};

document::{Mode, SCRATCH_BUFFER_NAME},

editor::{CompleteAction, CursorShapeConfig},

graphics::{CursorKind, Modifier, Rect, Style},

editor.clear_idle_timer(); // don't retrigger

}

if self.completion.is_some()

|| !cx.editor.config().auto_completion

|| doc!(cx.editor).mode != Mode::Insert

fn handle_event(

&mut self,

event: Event,

) -> EventResult {

let mut cx = commands::Context {

editor: context.editor,

// render status msg

if let Some((status_msg, severity)) = &cx.editor.status_msg {

status_msg_width = status_msg.width();

let style = if *severity == Severity::Error {

cx.editor.theme.get("error")

} else {

if let Some((reg, _)) = cx.editor.macro_recording {

let disp = format!("[{}]", reg);

let style = style

.add_modifier(Modifier::BOLD);

cx.surface.set_string(

area.x + area.width.saturating_sub(3),

use tui::text::{Span, Spans, Text};

use std::sync::Arc;

syntax::{self, HighlightEvent, Syntax},

Rope,

};

graphics::{Margin, Rect, Style},

Theme,

};

use crate::{ctrl, key, shift};

Callback, Component, Compositor, Context, Event, EventResult, RenderContext,

};

use tui::widgets::Table;

use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;

use fuzzy_matcher::FuzzyMatcher;

use tui::layout::Constraint;

pub trait Item {

pub use spinner::{ProgressSpinners, Spinner};

pub use text::Text;

use helix_core::regex::Regex;

use helix_core::regex::RegexBuilder;

use std::path::PathBuf;

prompt: std::borrow::Cow<'static, str>,

history_register: Option<char>,

completion_fn: impl FnMut(&Editor, &str) -> Vec<prompt::Completion> + 'static,

) {

let mut prompt = Prompt::new(prompt, history_register, completion_fn, callback_fn);

// Calculate initial completion

prompt,

history_register,

completion_fn,

match event {

PromptEvent::Abort => {

let (view, doc) = current!(cx.editor);

cx.push_layer(Box::new(prompt));

}

use ignore::{types::TypesBuilder, WalkBuilder};

use std::time::Instant;

}

pub mod completers {

use crate::ui::prompt::Completion;

use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;

use fuzzy_matcher::FuzzyMatcher;

use once_cell::sync::Lazy;

use std::borrow::Cow;

use std::cmp::Reverse;

use helix_core::Position;

graphics::{CursorKind, Rect},

Editor,

};

/// Contains a component placed in the center of the parent component

pub struct Overlay<T> {

ctrl, key, shift,

ui::{self, EditorView},

};

use tui::widgets::{Block, BorderType, Borders};

use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;

use crate::ui::{Prompt, PromptEvent};

use helix_core::{movement::Direction, Position};

editor::Action,

graphics::{Color, CursorKind, Margin, Modifier, Rect, Style},

Document, Editor,

use crate::{ctrl, key};

use helix_core::Position;

graphics::{Margin, Rect},

Editor,

};

use crate::{alt, ctrl, key, shift, ui};

use std::{borrow::Cow, ops::RangeFrom};

use tui::widgets::{Block, Borders, Widget};

graphics::{CursorKind, Margin, Rect},

Editor,

};

pub type Completion = (RangeFrom<usize>, Cow<'static, str>);

pub struct Text {

pub(crate) contents: tui::text::Text<'static>,