forked from Mirrors/helix
Merge branch 'master' of github.com:helix-editor/helix
commit
a6e16df9a3
GPG Key ID:
DFFFCC2C7A02DB45
@ -0,0 +1,59 @@
|
||||
## Checklist
|
||||
|
||||
Helix releases are versioned in the Calendar Versioning scheme:
|
||||
`YY.0M(.MICRO)`, for example `22.05` for May of 2022. In these instructions
|
||||
we'll use `<tag>` as a placeholder for the tag being published.
|
||||
|
||||
* Merge the changelog PR
|
||||
* Tag and push
|
||||
* `git tag -s -m "<tag>" -a <tag> && git push`
|
||||
* Make sure to switch to master and pull first
|
||||
* Edit the `VERSION` file and change the date to the next planned release
|
||||
* Releases are planned to happen every two months, so `22.05` would change to `22.07`
|
||||
* Wait for the Release CI to finish
|
||||
* It will automatically turn the git tag into a GitHub release when it uploads artifacts
|
||||
* Edit the new release
|
||||
* Use `<tag>` as the title
|
||||
* Link to the changelog and release notes
|
||||
* Merge the release notes PR
|
||||
* Download the macos and linux binaries and update the `sha256`s in the [homebrew formula]
|
||||
* Use `sha256sum` on the downloaded `.tar.xz` files to determine the hash
|
||||
* Link to the release notes in this-week-in-rust
|
||||
* [Example PR](https://github.com/rust-lang/this-week-in-rust/pull/3300)
|
||||
* Post to reddit
|
||||
* [Example post](https://www.reddit.com/r/rust/comments/uzp5ze/helix_editor_2205_released/)
|
||||
|
||||
[homebrew formula]: https://github.com/helix-editor/homebrew-helix/blob/master/Formula/helix.rb
|
||||
|
||||
## Changelog Curation
|
||||
|
||||
The changelog is currently created manually by reading through commits in the
|
||||
log since the last release. GitHub's compare view is a nice way to approach
|
||||
this. For example when creating the 22.07 release notes, this compare link
|
||||
may be used
|
||||
|
||||
```
|
||||
https://github.com/helix-editor/helix/compare/22.05...master
|
||||
```
|
||||
|
||||
Either side of the triple-dot may be replaced with an exact revision, so if
|
||||
you wish to incrementally compile the changelog, you can tackle a weeks worth
|
||||
or so, record the revision where you stopped, and use that as a starting point
|
||||
next week:
|
||||
|
||||
```
|
||||
https://github.com/helix-editor/helix/compare/7706a4a0d8b67b943c31d0c5f7b00d357b5d838d...master
|
||||
```
|
||||
|
||||
A work-in-progress commit for a changelog might look like
|
||||
[this example](https://github.com/helix-editor/helix/commit/831adfd4c709ca16b248799bfef19698d5175e55).
|
||||
|
||||
Not every PR or commit needs a blurb in the changelog. Each release section
|
||||
tends to have a blurb that links to a GitHub comparison between release
|
||||
versions for convenience:
|
||||
|
||||
> As usual, the following is a summary of each of the changes since the last
|
||||
> release. For the full log, check out the git log.
|
||||
|
||||
Typically, small changes like dependencies or documentation updates, refactors,
|
||||
or meta changes like GitHub Actions work are left out.
|
||||
@ -0,0 +1,133 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use helix_core::syntax;
|
||||
use helix_view::graphics::{Margin, Rect, Style};
|
||||
use tui::buffer::Buffer;
|
||||
use tui::widgets::{BorderType, Paragraph, Widget, Wrap};
|
||||
|
||||
use crate::compositor::{Component, Compositor, Context};
|
||||
|
||||
use crate::ui::Markdown;
|
||||
|
||||
use super::Popup;
|
||||
|
||||
pub struct SignatureHelp {
|
||||
signature: String,
|
||||
signature_doc: Option<String>,
|
||||
/// Part of signature text
|
||||
active_param_range: Option<(usize, usize)>,
|
||||
|
||||
language: String,
|
||||
config_loader: Arc<syntax::Loader>,
|
||||
}
|
||||
|
||||
impl SignatureHelp {
|
||||
pub const ID: &'static str = "signature-help";
|
||||
|
||||
pub fn new(signature: String, language: String, config_loader: Arc<syntax::Loader>) -> Self {
|
||||
Self {
|
||||
signature,
|
||||
signature_doc: None,
|
||||
active_param_range: None,
|
||||
language,
|
||||
config_loader,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn set_signature_doc(&mut self, signature_doc: Option<String>) {
|
||||
self.signature_doc = signature_doc;
|
||||
}
|
||||
|
||||
pub fn set_active_param_range(&mut self, offset: Option<(usize, usize)>) {
|
||||
self.active_param_range = offset;
|
||||
}
|
||||
|
||||
pub fn visible_popup(compositor: &mut Compositor) -> Option<&mut Popup<Self>> {
|
||||
compositor.find_id::<Popup<Self>>(Self::ID)
|
||||
}
|
||||
}
|
||||
|
||||
impl Component for SignatureHelp {
|
||||
fn render(&mut self, area: Rect, surface: &mut Buffer, cx: &mut Context) {
|
||||
let margin = Margin::horizontal(1);
|
||||
|
||||
let active_param_span = self.active_param_range.map(|(start, end)| {
|
||||
vec![(
|
||||
cx.editor.theme.find_scope_index("ui.selection").unwrap(),
|
||||
start..end,
|
||||
)]
|
||||
});
|
||||
|
||||
let sig_text = crate::ui::markdown::highlighted_code_block(
|
||||
self.signature.clone(),
|
||||
&self.language,
|
||||
Some(&cx.editor.theme),
|
||||
Arc::clone(&self.config_loader),
|
||||
active_param_span,
|
||||
);
|
||||
|
||||
let (_, sig_text_height) = crate::ui::text::required_size(&sig_text, area.width);
|
||||
let sig_text_area = area.clip_top(1).with_height(sig_text_height);
|
||||
let sig_text_para = Paragraph::new(sig_text).wrap(Wrap { trim: false });
|
||||
sig_text_para.render(sig_text_area.inner(&margin), surface);
|
||||
|
||||
if self.signature_doc.is_none() {
|
||||
return;
|
||||
}
|
||||
|
||||
let sep_style = Style::default();
|
||||
let borders = BorderType::line_symbols(BorderType::Plain);
|
||||
for x in sig_text_area.left()..sig_text_area.right() {
|
||||
if let Some(cell) = surface.get_mut(x, sig_text_area.bottom()) {
|
||||
cell.set_symbol(borders.horizontal).set_style(sep_style);
|
||||
}
|
||||
}
|
||||
|
||||
let sig_doc = match &self.signature_doc {
|
||||
None => return,
|
||||
Some(doc) => Markdown::new(doc.clone(), Arc::clone(&self.config_loader)),
|
||||
};
|
||||
let sig_doc = sig_doc.parse(Some(&cx.editor.theme));
|
||||
let sig_doc_area = area.clip_top(sig_text_area.height + 2);
|
||||
let sig_doc_para = Paragraph::new(sig_doc)
|
||||
.wrap(Wrap { trim: false })
|
||||
.scroll((cx.scroll.unwrap_or_default() as u16, 0));
|
||||
sig_doc_para.render(sig_doc_area.inner(&margin), surface);
|
||||
}
|
||||
|
||||
fn required_size(&mut self, viewport: (u16, u16)) -> Option<(u16, u16)> {
|
||||
const PADDING: u16 = 2;
|
||||
const SEPARATOR_HEIGHT: u16 = 1;
|
||||
|
||||
if PADDING >= viewport.1 || PADDING >= viewport.0 {
|
||||
return None;
|
||||
}
|
||||
let max_text_width = (viewport.0 - PADDING).min(120);
|
||||
|
||||
let signature_text = crate::ui::markdown::highlighted_code_block(
|
||||
self.signature.clone(),
|
||||
&self.language,
|
||||
None,
|
||||
Arc::clone(&self.config_loader),
|
||||
None,
|
||||
);
|
||||
let (sig_width, sig_height) =
|
||||
crate::ui::text::required_size(&signature_text, max_text_width);
|
||||
|
||||
let (width, height) = match self.signature_doc {
|
||||
Some(ref doc) => {
|
||||
let doc_md = Markdown::new(doc.clone(), Arc::clone(&self.config_loader));
|
||||
let doc_text = doc_md.parse(None);
|
||||
let (doc_width, doc_height) =
|
||||
crate::ui::text::required_size(&doc_text, max_text_width);
|
||||
(
|
||||
sig_width.max(doc_width),
|
||||
sig_height + SEPARATOR_HEIGHT + doc_height,
|
||||
)
|
||||
}
|
||||
None => (sig_width, sig_height),
|
||||
};
|
||||
|
||||
Some((width + PADDING, height + PADDING))
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,336 @@
|
||||
use helix_core::{coords_at_pos, encoding};
|
||||
use helix_view::{
|
||||
document::{Mode, SCRATCH_BUFFER_NAME},
|
||||
graphics::Rect,
|
||||
theme::Style,
|
||||
Document, Editor, View,
|
||||
};
|
||||
|
||||
use crate::ui::ProgressSpinners;
|
||||
|
||||
use helix_view::editor::StatusLineElement as StatusLineElementID;
|
||||
use tui::buffer::Buffer as Surface;
|
||||
use tui::text::{Span, Spans};
|
||||
|
||||
pub struct RenderContext<'a> {
|
||||
pub editor: &'a Editor,
|
||||
pub doc: &'a Document,
|
||||
pub view: &'a View,
|
||||
pub focused: bool,
|
||||
pub spinners: &'a ProgressSpinners,
|
||||
pub parts: RenderBuffer<'a>,
|
||||
}
|
||||
|
||||
impl<'a> RenderContext<'a> {
|
||||
pub fn new(
|
||||
editor: &'a Editor,
|
||||
doc: &'a Document,
|
||||
view: &'a View,
|
||||
focused: bool,
|
||||
spinners: &'a ProgressSpinners,
|
||||
) -> Self {
|
||||
RenderContext {
|
||||
editor,
|
||||
doc,
|
||||
view,
|
||||
focused,
|
||||
spinners,
|
||||
parts: RenderBuffer::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct RenderBuffer<'a> {
|
||||
pub left: Spans<'a>,
|
||||
pub center: Spans<'a>,
|
||||
pub right: Spans<'a>,
|
||||
}
|
||||
|
||||
pub fn render(context: &mut RenderContext, viewport: Rect, surface: &mut Surface) {
|
||||
let base_style = if context.focused {
|
||||
context.editor.theme.get("ui.statusline")
|
||||
} else {
|
||||
context.editor.theme.get("ui.statusline.inactive")
|
||||
};
|
||||
|
||||
surface.set_style(viewport.with_height(1), base_style);
|
||||
|
||||
let write_left = |context: &mut RenderContext, text, style| {
|
||||
append(&mut context.parts.left, text, &base_style, style)
|
||||
};
|
||||
let write_center = |context: &mut RenderContext, text, style| {
|
||||
append(&mut context.parts.center, text, &base_style, style)
|
||||
};
|
||||
let write_right = |context: &mut RenderContext, text, style| {
|
||||
append(&mut context.parts.right, text, &base_style, style)
|
||||
};
|
||||
|
||||
// Left side of the status line.
|
||||
|
||||
let element_ids = &context.editor.config().statusline.left;
|
||||
element_ids
|
||||
.iter()
|
||||
.map(|element_id| get_render_function(*element_id))
|
||||
.for_each(|render| render(context, write_left));
|
||||
|
||||
surface.set_spans(
|
||||
viewport.x,
|
||||
viewport.y,
|
||||
&context.parts.left,
|
||||
context.parts.left.width() as u16,
|
||||
);
|
||||
|
||||
// Right side of the status line.
|
||||
|
||||
let element_ids = &context.editor.config().statusline.right;
|
||||
element_ids
|
||||
.iter()
|
||||
.map(|element_id| get_render_function(*element_id))
|
||||
.for_each(|render| render(context, write_right));
|
||||
|
||||
surface.set_spans(
|
||||
viewport.x
|
||||
+ viewport
|
||||
.width
|
||||
.saturating_sub(context.parts.right.width() as u16),
|
||||
viewport.y,
|
||||
&context.parts.right,
|
||||
context.parts.right.width() as u16,
|
||||
);
|
||||
|
||||
// Center of the status line.
|
||||
|
||||
let element_ids = &context.editor.config().statusline.center;
|
||||
element_ids
|
||||
.iter()
|
||||
.map(|element_id| get_render_function(*element_id))
|
||||
.for_each(|render| render(context, write_center));
|
||||
|
||||
// Width of the empty space between the left and center area and between the center and right area.
|
||||
let spacing = 1u16;
|
||||
|
||||
let edge_width = context.parts.left.width().max(context.parts.right.width()) as u16;
|
||||
let center_max_width = viewport.width.saturating_sub(2 * edge_width + 2 * spacing);
|
||||
let center_width = center_max_width.min(context.parts.center.width() as u16);
|
||||
|
||||
surface.set_spans(
|
||||
viewport.x + viewport.width / 2 - center_width / 2,
|
||||
viewport.y,
|
||||
&context.parts.center,
|
||||
center_width,
|
||||
);
|
||||
}
|
||||
|
||||
fn append(buffer: &mut Spans, text: String, base_style: &Style, style: Option<Style>) {
|
||||
buffer.0.push(Span::styled(
|
||||
text,
|
||||
style.map_or(*base_style, |s| (*base_style).patch(s)),
|
||||
));
|
||||
}
|
||||
|
||||
fn get_render_function<F>(element_id: StatusLineElementID) -> impl Fn(&mut RenderContext, F)
|
||||
where
|
||||
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
|
||||
{
|
||||
match element_id {
|
||||
helix_view::editor::StatusLineElement::Mode => render_mode,
|
||||
helix_view::editor::StatusLineElement::Spinner => render_lsp_spinner,
|
||||
helix_view::editor::StatusLineElement::FileName => render_file_name,
|
||||
helix_view::editor::StatusLineElement::FileEncoding => render_file_encoding,
|
||||
helix_view::editor::StatusLineElement::FileLineEnding => render_file_line_ending,
|
||||
helix_view::editor::StatusLineElement::FileType => render_file_type,
|
||||
helix_view::editor::StatusLineElement::Diagnostics => render_diagnostics,
|
||||
helix_view::editor::StatusLineElement::Selections => render_selections,
|
||||
helix_view::editor::StatusLineElement::Position => render_position,
|
||||
}
|
||||
}
|
||||
|
||||
fn render_mode<F>(context: &mut RenderContext, write: F)
|
||||
where
|
||||
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
|
||||
{
|
||||
let visible = context.focused;
|
||||
|
||||
write(
|
||||
context,
|
||||
format!(
|
||||
" {} ",
|
||||
if visible {
|
||||
match context.doc.mode() {
|
||||
Mode::Insert => "INS",
|
||||
Mode::Select => "SEL",
|
||||
Mode::Normal => "NOR",
|
||||
}
|
||||
} else {
|
||||
// If not focused, explicitly leave an empty space instead of returning None.
|
||||
" "
|
||||
}
|
||||
),
|
||||
if visible && context.editor.config().color_modes {
|
||||
match context.doc.mode() {
|
||||
Mode::Insert => Some(context.editor.theme.get("ui.statusline.insert")),
|
||||
Mode::Select => Some(context.editor.theme.get("ui.statusline.select")),
|
||||
Mode::Normal => Some(context.editor.theme.get("ui.statusline.normal")),
|
||||
}
|
||||
} else {
|
||||
None
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
fn render_lsp_spinner<F>(context: &mut RenderContext, write: F)
|
||||
where
|
||||
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
|
||||
{
|
||||
write(
|
||||
context,
|
||||
context
|
||||
.doc
|
||||
.language_server()
|
||||
.and_then(|srv| {
|
||||
context
|
||||
.spinners
|
||||
.get(srv.id())
|
||||
.and_then(|spinner| spinner.frame())
|
||||
})
|
||||
// Even if there's no spinner; reserve its space to avoid elements frequently shifting.
|
||||
.unwrap_or(" ")
|
||||
.to_string(),
|
||||
None,
|
||||
);
|
||||
}
|
||||
|
||||
fn render_diagnostics<F>(context: &mut RenderContext, write: F)
|
||||
where
|
||||
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
|
||||
{
|
||||
let (warnings, errors) = context
|
||||
.doc
|
||||
.diagnostics()
|
||||
.iter()
|
||||
.fold((0, 0), |mut counts, diag| {
|
||||
use helix_core::diagnostic::Severity;
|
||||
match diag.severity {
|
||||
Some(Severity::Warning) => counts.0 += 1,
|
||||
Some(Severity::Error) | None => counts.1 += 1,
|
||||
_ => {}
|
||||
}
|
||||
counts
|
||||
});
|
||||
|
||||
if warnings > 0 {
|
||||
write(
|
||||
context,
|
||||
"●".to_string(),
|
||||
Some(context.editor.theme.get("warning")),
|
||||
);
|
||||
write(context, format!(" {} ", warnings), None);
|
||||
}
|
||||
|
||||
if errors > 0 {
|
||||
write(
|
||||
context,
|
||||
"●".to_string(),
|
||||
Some(context.editor.theme.get("error")),
|
||||
);
|
||||
write(context, format!(" {} ", errors), None);
|
||||
}
|
||||
}
|
||||
|
||||
fn render_selections<F>(context: &mut RenderContext, write: F)
|
||||
where
|
||||
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
|
||||
{
|
||||
let count = context.doc.selection(context.view.id).len();
|
||||
write(
|
||||
context,
|
||||
format!(" {} sel{} ", count, if count == 1 { "" } else { "s" }),
|
||||
None,
|
||||
);
|
||||
}
|
||||
|
||||
fn render_position<F>(context: &mut RenderContext, write: F)
|
||||
where
|
||||
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
|
||||
{
|
||||
let position = coords_at_pos(
|
||||
context.doc.text().slice(..),
|
||||
context
|
||||
.doc
|
||||
.selection(context.view.id)
|
||||
.primary()
|
||||
.cursor(context.doc.text().slice(..)),
|
||||
);
|
||||
|
||||
write(
|
||||
context,
|
||||
format!(" {}:{} ", position.row + 1, position.col + 1),
|
||||
None,
|
||||
);
|
||||
}
|
||||
|
||||
fn render_file_encoding<F>(context: &mut RenderContext, write: F)
|
||||
where
|
||||
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
|
||||
{
|
||||
let enc = context.doc.encoding();
|
||||
|
||||
if enc != encoding::UTF_8 {
|
||||
write(context, format!(" {} ", enc.name()), None);
|
||||
}
|
||||
}
|
||||
|
||||
fn render_file_line_ending<F>(context: &mut RenderContext, write: F)
|
||||
where
|
||||
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
|
||||
{
|
||||
use helix_core::LineEnding::*;
|
||||
let line_ending = match context.doc.line_ending {
|
||||
Crlf => "CRLF",
|
||||
LF => "LF",
|
||||
#[cfg(feature = "unicode-lines")]
|
||||
VT => "VT", // U+000B -- VerticalTab
|
||||
#[cfg(feature = "unicode-lines")]
|
||||
FF => "FF", // U+000C -- FormFeed
|
||||
#[cfg(feature = "unicode-lines")]
|
||||
CR => "CR", // U+000D -- CarriageReturn
|
||||
#[cfg(feature = "unicode-lines")]
|
||||
Nel => "NEL", // U+0085 -- NextLine
|
||||
#[cfg(feature = "unicode-lines")]
|
||||
LS => "LS", // U+2028 -- Line Separator
|
||||
#[cfg(feature = "unicode-lines")]
|
||||
PS => "PS", // U+2029 -- ParagraphSeparator
|
||||
};
|
||||
|
||||
write(context, format!(" {} ", line_ending), None);
|
||||
}
|
||||
|
||||
fn render_file_type<F>(context: &mut RenderContext, write: F)
|
||||
where
|
||||
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
|
||||
{
|
||||
let file_type = context.doc.language_id().unwrap_or("text");
|
||||
|
||||
write(context, format!(" {} ", file_type), None);
|
||||
}
|
||||
|
||||
fn render_file_name<F>(context: &mut RenderContext, write: F)
|
||||
where
|
||||
F: Fn(&mut RenderContext, String, Option<Style>) + Copy,
|
||||
{
|
||||
let title = {
|
||||
let rel_path = context.doc.relative_path();
|
||||
let path = rel_path
|
||||
.as_ref()
|
||||
.map(|p| p.to_string_lossy())
|
||||
.unwrap_or_else(|| SCRATCH_BUFFER_NAME.into());
|
||||
format!(
|
||||
" {}{} ",
|
||||
path,
|
||||
if context.doc.is_modified() { "[+]" } else { "" }
|
||||
)
|
||||
};
|
||||
|
||||
write(context, title, None);
|
||||
}
|
||||
@ -0,0 +1,86 @@
|
||||
(comment) @comment
|
||||
|
||||
"~" @operator
|
||||
">" @operator
|
||||
"+" @operator
|
||||
"-" @operator
|
||||
"*" @operator
|
||||
"/" @operator
|
||||
"=" @operator
|
||||
"^=" @operator
|
||||
"|=" @operator
|
||||
"~=" @operator
|
||||
"$=" @operator
|
||||
"*=" @operator
|
||||
|
||||
"in" @operator
|
||||
"and" @operator
|
||||
"or" @operator
|
||||
"not" @operator
|
||||
"only" @operator
|
||||
|
||||
"@apply" @constant.builtin
|
||||
"@at-root" @constant.builtin
|
||||
"@charset" @constant.builtin
|
||||
"@debug" @constant.builtin
|
||||
"@each" @keyword.control.repeat
|
||||
"@else" @keyword.control.conditional
|
||||
"@error" @constant.builtin
|
||||
"@extend" @constant.builtin
|
||||
"@for" @keyword.control.repeat
|
||||
"@forward" @keyword.control.import
|
||||
"@function" @function.method
|
||||
"@if" @keyword.control.conditional
|
||||
"@import" @keyword.control.import
|
||||
"@include" @keyword.control.import
|
||||
"@keyframes" @constant.builtin
|
||||
"@media" @constant.builtin
|
||||
"@mixin" @constant.builtin
|
||||
"@namespace" @namespace
|
||||
"@return" @keyword.control.return
|
||||
"@supports" @constant.builtin
|
||||
"@use" @keyword.control.import
|
||||
"@warn" @constant.builtin
|
||||
"@while" @keyword.control.repeat
|
||||
|
||||
((property_name) @variable
|
||||
(match? @variable "^--"))
|
||||
((plain_value) @variable
|
||||
(match? @variable "^--"))
|
||||
|
||||
(tag_name) @tag
|
||||
(universal_selector) @tag
|
||||
(attribute_selector (plain_value) @string)
|
||||
(nesting_selector) @variable.other.member
|
||||
(pseudo_element_selector) @attribute
|
||||
(pseudo_class_selector) @attribute
|
||||
|
||||
(identifier) @variable
|
||||
(class_name) @variable
|
||||
(id_name) @variable
|
||||
(namespace_name) @variable
|
||||
(property_name) @variable.other.member
|
||||
(feature_name) @variable
|
||||
(variable) @variable
|
||||
(variable_name) @variable.other.member
|
||||
(variable_value) @variable.other.member
|
||||
(argument_name) @variable.parameter
|
||||
(selectors) @variable.other.member
|
||||
|
||||
(attribute_name) @attribute
|
||||
|
||||
(function_name) @function
|
||||
|
||||
(to) @keyword
|
||||
(from) @keyword
|
||||
(important) @keyword
|
||||
|
||||
(string_value) @string
|
||||
(color_value) @string.special
|
||||
|
||||
(integer_value) @constant.numeric.integer
|
||||
(float_value) @constant.numeric.float
|
||||
(unit) @type
|
||||
|
||||
"#" @punctuation.delimiter
|
||||
"," @punctuation.delimiter
|
||||
@ -0,0 +1,2 @@
|
||||
((comment) @injection.content
|
||||
(#set! injection.language "comment"))
|
||||
Loading…
Reference in New Issue