[nvim] feat: custom (colored) nodes for snippets

.config/nvim/after/ftplugin/c.lua

@@ -20,32 +20,32 @@ local f = ls.function_node
 
 local copy = utils.copy
 
-ls.snippets = {
+ls.add_snippets( "c", {
-    c = {
+    s("main", {
-        s("main", {
+        t({ "int main(int argc, char* argv[])" }),
-            t({ "int main(int argc, char* argv[])" }),
+        t({ "", "{", "\t" }),
-            t({ "", "{", "\t" }),
+        i(0),
+        t({ "", "\treturn 0;"}),
+        t({ "", "}"}),
+    }),
+    s("fn", {
+        -- Simple static text.
+        t("//Parameters: "),
+        -- function, first parameter is the function, second the Placeholders
+        -- whose text it gets as input.
+        f(copy, 2),
+        t({ "", "" }),
+        -- Placeholder/Insert.
+        i(1),
+        t("("),
+        -- Placeholder with initial text.
+        i(2, "int foo"),
+        -- Linebreak
+        t({ ")", "{", "\t" }),
             i(0),
             t({ "", "\treturn 0;"}),
             t({ "", "}"}),
-        }),
+    }),
-		s("fn", {
+}, {
-			-- Simple static text.
+        key = "c"
-			t("//Parameters: "),
+    })
-			-- function, first parameter is the function, second the Placeholders
-			-- whose text it gets as input.
-			f(copy, 2),
-			t({ "", "" }),
-			-- Placeholder/Insert.
-			i(1),
-			t("("),
-			-- Placeholder with initial text.
-			i(2, "int foo"),
-			-- Linebreak
-			t({ ")", "{", "\t" }),
-                i(0),
-                t({ "", "\treturn 0;"}),
-                t({ "", "}"}),
-        }),
-	},
-}

.config/nvim/after/ftplugin/tex.lua

@@ -10,13 +10,13 @@ opt.formatoptions   = "trq1jp"
 opt.tabstop         = 4
 
 --  Caps
-utils.map("i", "AA", "À")
+vim.keymap.set("i", "AA", "À")
-utils.map("i", "CC", "Ç")
+vim.keymap.set("i", "CC", "Ç")
-utils.map("i", "EE", "É")
+vim.keymap.set("i", "EE", "É")
 
 -- Unbreakable spaces
-utils.map("i", "<Space>etc", "\\,etc.")
+vim.keymap.set("i", "<Space>etc", "\\,etc.")
-utils.map("i", "<Space>:", "\\,:")
+vim.keymap.set("i", "<Space>:", "\\,:")
 
 -- Snippets
 local ls = require("luasnip")
@@ -44,86 +44,86 @@ local function rec_ls()
 	)
 end
 
-ls.snippets = {
+ls.add_snippets("tex", {
-    tex = {
+    -- rec_ls is self-referencing. That makes this snippet 'infinite' eg. have as many
-        -- rec_ls is self-referencing. That makes this snippet 'infinite' eg. have as many
+    -- \item as necessary by utilizing a choiceNode.
-        -- \item as necessary by utilizing a choiceNode.
+    s("ls", {
-        s("ls", {
+        t({ "\\begin{itemize}", "\t\\item " }),
-            t({ "\\begin{itemize}", "\t\\item " }),
+        i(1),
-            i(1),
+        t({ "" }),
-            t({ "" }),
+        d(2, rec_ls, {}),
-            d(2, rec_ls, {}),
+        t({ "", "\\end{itemize}", "" }),
-            t({ "", "\\end{itemize}", "" }),
+    }),
-        }),
+    s("lsl", {
-        s("lsl", {
+        t({ "\\begin{itemize}[label=" }),
-            t({ "\\begin{itemize}[label=" }),
+        i(1),
-            i(1),
+        t( { "]", "\t\\item " }),
-            t( { "]", "\t\\item " }),
+        i(2),
-            i(2),
+        t({ "" }),
-            t({ "" }),
+        d(3, rec_ls, {}),
-            d(3, rec_ls, {}),
+        t({ "", "\\end{itemize}", "" }),
-            t({ "", "\\end{itemize}", "" }),
+    }),
-        }),
+    s("frm", {
-        s("frm", {
+        t({ "\\begin{" }),
-            t({ "\\begin{" }),
+        i(1),
-            i(1),
+        t({ "}[" }),
-            t({ "}[" }),
+        i(2),
-            i(2),
+        t({ "]{" }),
-            t({ "]{" }),
+        f(copy, 1),
-            f(copy, 1),
+        t({ ":" }),
-            t({ ":" }),
+        i(3, "foo"),
-            i(3, "foo"),
+        t({ "}", "\t" }),
-            t({ "}", "\t" }),
+        i(0),
-            i(0),
+        t({ "", "\\end{" }),
-            t({ "", "\\end{" }),
+        f(copy, 1),
-            f(copy, 1),
+        t({ "}", "" }),
-            t({ "}", "" }),
+    }),
-        }),
+    s("env", {
-        s("env", {
+        t({ "\\begin{" }),
-            t({ "\\begin{" }),
+        i(1, "foo"),
-            i(1, "foo"),
+        t({ "}", "\t" }),
-            t({ "}", "\t" }),
+        i(2),
-            i(2),
+        t({ "", "\\end{" }),
-            t({ "", "\\end{" }),
+        f(copy,1),
-            f(copy,1),
+        t({ "}"}),
-            t({ "}"}),
+    }),
-        }),
+    s("tikz", {
-        s("tikz", {
+        t({ "\\begin{center}" }),
-            t({ "\\begin{center}" }),
+        t({ "", "\t\\begin{tikzpicture}[main/.style = {draw,circle}]", "\t\t" }),
-            t({ "", "\t\\begin{tikzpicture}[main/.style = {draw,circle}]", "\t\t" }),
+        i(1),
-            i(1),
+        t({ "", "\t\\end{tikzpicture}", "\\end{center}" }),
-            t({ "", "\t\\end{tikzpicture}", "\\end{center}" }),
+    }),
-        }),
+    s("ra", { t( "\\rightarrow" )}),
-        s("ra", { t( "\\rightarrow" )}),
+    s("Ra", { t("\\Rightarrow" )}),
-        s("Ra", { t("\\Rightarrow" )}),
+    s("la", { t("\\leftarrow" )}),
-        s("la", { t("\\leftarrow" )}),
+    s("La", { t("\\Leftarrow" )}),
-        s("La", { t("\\Leftarrow" )}),
+    s("lra", { t("\\leftrightarrow" )}),
-        s("lra", { t("\\leftrightarrow" )}),
+    s("Lra", { t("\\Leftrightarrow" )}),
-        s("Lra", { t("\\Leftrightarrow" )}),
+    s("bb", {
-        s("bb", {
+        t({ "\\textbf{" }),
-            t({ "\\textbf{" }),
-                i(1),
-                t({ "}"}),
-        }),
-        s("tt", {
-            t({ "\\texttt{" }),
             i(1),
             t({ "}"}),
-        }),
+    }),
-        s("ii", {
+    s("tt", {
-            t({ "\\textit{" }),
+        t({ "\\texttt{" }),
-            i(1),
+        i(1),
-            t({ "}"}),
+        t({ "}"}),
-        }),
+    }),
-        s("uu", {
+    s("ii", {
-            t({ "\\underline{" }),
+        t({ "\\textit{" }),
-            i(1),
+        i(1),
-            t({ "}"}),
+        t({ "}"}),
-        }),
+    }),
-        s("fsc", {
+    s("uu", {
-            t({ "\\textsc{" }),
+        t({ "\\underline{" }),
-            i(1),
+        i(1),
-            t({ "}"}),
+        t({ "}"}),
-        }),
+    }),
-    },
+    s("fsc", {
-}
+        t({ "\\textsc{" }),
+        i(1),
+        t({ "}"}),
+    }),
+}, {
+    key = "tex"
+})

.config/nvim/lua/plugin/cmp.lua

@@ -7,7 +7,7 @@ local cmp = require("cmp")
 local luasnip = require("luasnip")
 local cmp_autopairs = require('nvim-autopairs.completion.cmp')
 
-local check_backspace = function()
+local has_words_before = function()
     local line, col = unpack(vim.api.nvim_win_get_cursor(0))
     return col ~= 0 and
         vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:
@@ -62,9 +62,9 @@ cmp.setup {
         ["<Tab>"] = cmp.mapping(function(fallback)
             if cmp.visible() then
                 cmp.select_next_item()
-            elseif luasnip.expand_or_jumpable() then
+            elseif luasnip.expand_or_locally_jumpable() then
                 luasnip.expand_or_jump()
-            elseif check_backspace() then
+            elseif has_words_before() then
                 cmp.complete()
             else
                 fallback()

.config/nvim/lua/plugin/luasnip.lua

@@ -31,7 +31,26 @@ ls.config.set_config({
 	ext_opts = {
 		[types.choiceNode] = {
 			active = {
-				virt_text = { { "choiceNode", "Comment" } },
+				virt_text = { { "●", "LuaSnipChoice" } },
+			},
+			inactive = {
+				virt_text = { { "●", "LuaSnipInactive" } },
+			},
+		},
+		[types.functionNode] = {
+			active = {
+				virt_text = { { "●", "LuaSnipFunction" } },
+			},
+			inactive = {
+				virt_text = { { "●", "LuaSnipInactive" } },
+			},
+		},
+		[types.insertNode] = {
+			active = {
+				virt_text = { { "●", "LuaSnipInsert" } },
+			},
+			inactive = {
+				virt_text = { { "●", "LuaSnipInactive" } },
 			},
 		},
 	},
@@ -59,270 +78,269 @@ local function date_input(fmt)
 	return sn(nil, i(1, os.date(fmt)))
 end
 
-ls.snippets = {
+-- snippets are added via ls.add_snippets(filetype, snippets[, opts]), where
-	-- When trying to expand a snippet, luasnip first searches the tables for
+-- opts may specify the `type` of the snippets ("snippets" or "autosnippets",
-	-- each filetype specified in 'filetype' followed by 'all'.
+-- for snippets that should expand directly after the trigger is typed).
-	-- If ie. the filetype is 'lua.c'
+--
-	--     - luasnip.lua
+-- opts can also specify a key. By passing an unique key to each add_snippets, it's possible to reload snippets by
-	--     - luasnip.c
+-- re-`:luafile`ing the file in which they are defined (eg. this one).
-	--     - luasnip.all
+ls.add_snippets( "all", {
-	-- are searched in that order.
-	all = {
 		-- trigger is fn.
-		s("fn", {
+    s("fn", {
-			-- Simple static text.
+        -- Simple static text.
-			t("//Parameters: "),
+        t("//Parameters: "),
-			-- function, first parameter is the function, second the Placeholders
+        -- function, first parameter is the function, second the Placeholders
-			-- whose text it gets as input.
+        -- whose text it gets as input.
-			f(copy, 2),
+        f(copy, 2),
-			t({ "", "function " }),
+        t({ "", "function " }),
-			-- Placeholder/Insert.
+        -- Placeholder/Insert.
-			i(1),
+        i(1),
-			t("("),
+        t("("),
-			-- Placeholder with initial text.
+        -- Placeholder with initial text.
-			i(2, "int foo"),
+        i(2, "int foo"),
-			-- Linebreak
+        -- Linebreak
-			t({ ") {", "\t" }),
+        t({ ") {", "\t" }),
-			-- Last Placeholder, exit Point of the snippet. EVERY 'outer' SNIPPET NEEDS Placeholder 0.
+        -- Last Placeholder, exit Point of the snippet. EVERY 'outer' SNIPPET NEEDS Placeholder 0.
-			i(0),
+        i(0),
-			t({ "", "}" }),
+        t({ "", "}" }),
-		}),
+    }),
-		s("class", {
+    s("class", {
-			-- Choice: Switch between two different Nodes, first parameter is its position, second a list of nodes.
+        -- Choice: Switch between two different Nodes, first parameter is its position, second a list of nodes.
-			c(1, {
+        c(1, {
-				t("public "),
+            t("public "),
-				t("private "),
+            t("private "),
-			}),
+        }),
-			t("class "),
+        t("class "),
-			i(2),
+        i(2),
-			t(" "),
+        t(" "),
-			c(3, {
+        c(3, {
-				t("{"),
+            t("{"),
-				-- sn: Nested Snippet. Instead of a trigger, it has a position, just like insert-nodes. !!! These don't expect a 0-node!!!!
+            -- sn: Nested Snippet. Instead of a trigger, it has a position, just like insert-nodes. !!! These don't expect a 0-node!!!!
-				-- Inside Choices, Nodes don't need a position as the choice node is the one being jumped to.
+            -- Inside Choices, Nodes don't need a position as the choice node is the one being jumped to.
-				sn(nil, {
+            sn(nil, {
-					t("extends "),
+                t("extends "),
-					i(1),
+                i(1),
-					t(" {"),
+                t(" {"),
-				}),
+            }),
-				sn(nil, {
+            sn(nil, {
-					t("implements "),
+                t("implements "),
-					i(1),
+                i(1),
-					t(" {"),
+                t(" {"),
-				}),
+            }),
-			}),
+        }),
-			t({ "", "\t" }),
+        t({ "", "\t" }),
-			i(0),
+        i(0),
-			t({ "", "}" }),
+        t({ "", "}" }),
-		}),
+    }),
-		-- Use a dynamic_node to interpolate the output of a
+    -- Use a dynamic_node to interpolate the output of a
-		-- function (see date_input above) into the initial
+    -- function (see date_input above) into the initial
-		-- value of an insert_node.
+    -- value of an insert_node.
-		s("novel", {
+    s("novel", {
-			t("It was a dark and stormy night on "),
+        t("It was a dark and stormy night on "),
-			d(1, date_input, {}, "%A, %B %d of %Y"),
+        d(1, date_input, {}, "%A, %B %d of %Y"),
-			t(" and the clocks were striking thirteen."),
+        t(" and the clocks were striking thirteen."),
-		}),
+    }),
-		-- Parsing snippets: First parameter: Snippet-Trigger, Second: Snippet body.
+    -- Parsing snippets: First parameter: Snippet-Trigger, Second: Snippet body.
-		-- Placeholders are parsed into choices with 1. the placeholder text(as a snippet) and 2. an empty string.
+    -- Placeholders are parsed into choices with 1. the placeholder text(as a snippet) and 2. an empty string.
-		-- This means they are not SELECTed like in other editors/Snippet engines.
+    -- This means they are not SELECTed like in other editors/Snippet engines.
-		ls.parser.parse_snippet(
+    ls.parser.parse_snippet(
-			"lspsyn",
+        "lspsyn",
-			"Wow! This ${1:Stuff} really ${2:works. ${3:Well, a bit.}}"
+        "Wow! This ${1:Stuff} really ${2:works. ${3:Well, a bit.}}"
-		),
+    ),
 
-		-- When wordTrig is set to false, snippets may also expand inside other words.
+    -- When wordTrig is set to false, snippets may also expand inside other words.
-		ls.parser.parse_snippet(
+    ls.parser.parse_snippet(
-			{ trig = "te", wordTrig = false },
+        { trig = "te", wordTrig = false },
-			"${1:cond} ? ${2:true} : ${3:false}"
+        "${1:cond} ? ${2:true} : ${3:false}"
-		),
+    ),
 
-		-- When regTrig is set, trig is treated like a pattern, this snippet will expand after any number.
+    -- When regTrig is set, trig is treated like a pattern, this snippet will expand after any number.
-		ls.parser.parse_snippet({ trig = "%d", regTrig = true }, "A Number!!"),
+    ls.parser.parse_snippet({ trig = "%d", regTrig = true }, "A Number!!"),
-		-- Using the condition, it's possible to allow expansion only in specific cases.
+    -- Using the condition, it's possible to allow expansion only in specific cases.
-		s("cond", {
+    s("cond", {
-			t("will only expand in c-style comments"),
+        t("will only expand in c-style comments"),
-		}, {
+    }, {
-			condition = function(line_to_cursor, matched_trigger, captures)
+        condition = function(line_to_cursor, matched_trigger, captures)
-				-- optional whitespace followed by //
+            -- optional whitespace followed by //
-				return line_to_cursor:match("%s*//")
+            return line_to_cursor:match("%s*//")
-			end,
+        end,
-		}),
+    }),
-		-- there's some built-in conditions in "luasnip.extras.expand_conditions".
+    -- there's some built-in conditions in "luasnip.extras.expand_conditions".
-		s("cond2", {
+    s("cond2", {
-			t("will only expand at the beginning of the line"),
+        t("will only expand at the beginning of the line"),
-		}, {
+    }, {
-			condition = conds.line_begin,
+        condition = conds.line_begin,
-		}),
+    }),
-		-- The last entry of args passed to the user-function is the surrounding snippet.
+    -- The last entry of args passed to the user-function is the surrounding snippet.
-		s(
+    s(
-			{ trig = "a%d", regTrig = true },
+        { trig = "a%d", regTrig = true },
-			f(function(_, snip)
+        f(function(_, snip)
-				return "Triggered with " .. snip.trigger .. "."
+            return "Triggered with " .. snip.trigger .. "."
-			end, {})
+        end, {})
-		),
+    ),
-		-- It's possible to use capture-groups inside regex-triggers.
+    -- It's possible to use capture-groups inside regex-triggers.
-		s(
+    s(
-			{ trig = "b(%d)", regTrig = true },
+        { trig = "b(%d)", regTrig = true },
-			f(function(_, snip)
+        f(function(_, snip)
-				return "Captured Text: " .. snip.captures[1] .. "."
+            return "Captured Text: " .. snip.captures[1] .. "."
-			end, {})
+        end, {})
-		),
+    ),
-		s({ trig = "c(%d+)", regTrig = true }, {
+    s({ trig = "c(%d+)", regTrig = true }, {
-			t("will only expand for even numbers"),
+        t("will only expand for even numbers"),
-		}, {
+    }, {
-			condition = function(line_to_cursor, matched_trigger, captures)
+        condition = function(line_to_cursor, matched_trigger, captures)
-				return tonumber(captures[1]) % 2 == 0
+            return tonumber(captures[1]) % 2 == 0
-			end,
+        end,
-		}),
+    }),
-		-- Use a function to execute any shell command and print its text.
+    -- Use a function to execute any shell command and print its text.
-		s("bash", f(bash, {}, "ls")),
+    s("bash", f(bash, {}, "ls")),
-		-- Short version for applying String transformations using function nodes.
+    -- Short version for applying String transformations using function nodes.
-		s("transform", {
+    s("transform", {
-			i(1, "initial text"),
+        i(1, "initial text"),
-			t({ "", "" }),
+        t({ "", "" }),
-			-- lambda nodes accept an l._1,2,3,4,5, which in turn accept any string transformations.
+        -- lambda nodes accept an l._1,2,3,4,5, which in turn accept any string transformations.
-			-- This list will be applied in order to the first node given in the second argument.
+        -- This list will be applied in order to the first node given in the second argument.
-			l(l._1:match("[^i]*$"):gsub("i", "o"):gsub(" ", "_"):upper(), 1),
+        l(l._1:match("[^i]*$"):gsub("i", "o"):gsub(" ", "_"):upper(), 1),
-		}),
+    }),
-		s("transform2", {
+    s("transform2", {
-			i(1, "initial text"),
+        i(1, "initial text"),
-			t("::"),
+        t("::"),
-			i(2, "replacement for e"),
+        i(2, "replacement for e"),
-			t({ "", "" }),
+        t({ "", "" }),
-			-- Lambdas can also apply transforms USING the text of other nodes:
+        -- Lambdas can also apply transforms USING the text of other nodes:
-			l(l._1:gsub("e", l._2), { 1, 2 }),
+        l(l._1:gsub("e", l._2), { 1, 2 }),
-		}),
+    }),
-		s({ trig = "trafo(%d+)", regTrig = true }, {
+    s({ trig = "trafo(%d+)", regTrig = true }, {
-			-- env-variables and captures can also be used:
+        -- env-variables and captures can also be used:
-			l(l.CAPTURE1:gsub("1", l.TM_FILENAME), {}),
+        l(l.CAPTURE1:gsub("1", l.TM_FILENAME), {}),
-		}),
+    }),
-		-- Set store_selection_keys = "<Tab>" (for example) in your
+    -- Set store_selection_keys = "<Tab>" (for example) in your
-		-- luasnip.config.setup() call to access TM_SELECTED_TEXT. In
+    -- luasnip.config.setup() call to access TM_SELECTED_TEXT. In
-		-- this case, select a URL, hit Tab, then expand this snippet.
+    -- this case, select a URL, hit Tab, then expand this snippet.
-		s("link_url", {
+    s("link_url", {
-			t('<a href="'),
+        t('<a href="'),
-			f(function(_, snip)
+        f(function(_, snip)
-				return snip.env.TM_SELECTED_TEXT[1] or {}
+            return snip.env.TM_SELECTED_TEXT[1] or {}
-			end, {}),
+        end, {}),
-			t('">'),
+        t('">'),
-			i(1),
+        i(1),
-			t("</a>"),
+        t("</a>"),
-			i(0),
+        i(0),
-		}),
+    }),
-		-- Shorthand for repeating the text in a given node.
+    -- Shorthand for repeating the text in a given node.
-		s("repeat", { i(1, "text"), t({ "", "" }), r(1) }),
+    s("repeat", { i(1, "text"), t({ "", "" }), r(1) }),
-		-- Directly insert the ouput from a function evaluated at runtime.
+    -- Directly insert the ouput from a function evaluated at runtime.
-		s("part", p(os.date, "%Y")),
+    s("part", p(os.date, "%Y")),
-		-- use matchNodes to insert text based on a pattern/function/lambda-evaluation.
+    -- use matchNodes to insert text based on a pattern/function/lambda-evaluation.
-		s("mat", {
+    s("mat", {
-			i(1, { "sample_text" }),
+        i(1, { "sample_text" }),
-			t(": "),
+        t(": "),
-			m(1, "%d", "contains a number", "no number :("),
+        m(1, "%d", "contains a number", "no number :("),
-		}),
+    }),
-		-- The inserted text defaults to the first capture group/the entire
+    -- The inserted text defaults to the first capture group/the entire
-		-- match if there are none
+    -- match if there are none
-		s("mat2", {
+    s("mat2", {
-			i(1, { "sample_text" }),
+        i(1, { "sample_text" }),
-			t(": "),
+        t(": "),
-			m(1, "[abc][abc][abc]"),
+        m(1, "[abc][abc][abc]"),
-		}),
+    }),
-		-- It is even possible to apply gsubs' or other transformations
+    -- It is even possible to apply gsubs' or other transformations
-		-- before matching.
+    -- before matching.
-		s("mat3", {
+    s("mat3", {
-			i(1, { "sample_text" }),
+        i(1, { "sample_text" }),
-			t(": "),
+        t(": "),
-			m(
+        m(
-				1,
+            1,
-				l._1:gsub("[123]", ""):match("%d"),
+            l._1:gsub("[123]", ""):match("%d"),
-				"contains a number that isn't 1, 2 or 3!"
+            "contains a number that isn't 1, 2 or 3!"
-			),
+        ),
-		}),
+    }),
-		-- `match` also accepts a function, which in turn accepts a string
+    -- `match` also accepts a function, which in turn accepts a string
-		-- (text in node, \n-concatted) and returns any non-nil value to match.
+    -- (text in node, \n-concatted) and returns any non-nil value to match.
-		-- If that value is a string, it is used for the default-inserted text.
+    -- If that value is a string, it is used for the default-inserted text.
-		s("mat4", {
+    s("mat4", {
-			i(1, { "sample_text" }),
+        i(1, { "sample_text" }),
-			t(": "),
+        t(": "),
-			m(1, function(text)
+        m(1, function(text)
-				return (#text % 2 == 0 and text) or nil
+            return (#text % 2 == 0 and text) or nil
-			end),
+        end),
-		}),
+    }),
-		-- The nonempty-node inserts text depending on whether the arg-node is
+    -- The nonempty-node inserts text depending on whether the arg-node is
-		-- empty.
+    -- empty.
-		s("nempty", {
+    s("nempty", {
-			i(1, "sample_text"),
+        i(1, "sample_text"),
-			n(1, "i(1) is not empty!"),
+        n(1, "i(1) is not empty!"),
-		}),
+    }),
-		-- dynamic lambdas work exactly like regular lambdas, except that they
+    -- dynamic lambdas work exactly like regular lambdas, except that they
-		-- don't return a textNode, but a dynamicNode containing one insertNode.
+    -- don't return a textNode, but a dynamicNode containing one insertNode.
-		-- This makes it easier to dynamically set preset-text for insertNodes.
+    -- This makes it easier to dynamically set preset-text for insertNodes.
-		s("dl1", {
+    s("dl1", {
-			i(1, "sample_text"),
+        i(1, "sample_text"),
-			t({ ":", "" }),
+        t({ ":", "" }),
-			dl(2, l._1, 1),
+        dl(2, l._1, 1),
-		}),
+    }),
-		-- Obviously, it's also possible to apply transformations, just like lambdas.
+    -- Obviously, it's also possible to apply transformations, just like lambdas.
-		s("dl2", {
+    s("dl2", {
-			i(1, "sample_text"),
+        i(1, "sample_text"),
-			i(2, "sample_text_2"),
+        i(2, "sample_text_2"),
-			t({ "", "" }),
+        t({ "", "" }),
-			dl(3, l._1:gsub("\n", " linebreak ") .. l._2, { 1, 2 }),
+        dl(3, l._1:gsub("\n", " linebreak ") .. l._2, { 1, 2 }),
-		}),
+    }),
-		-- Alternative printf-like notation for defining snippets. It uses format
+    -- Alternative printf-like notation for defining snippets. It uses format
-		-- string with placeholders similar to the ones used with Python's .format().
+    -- string with placeholders similar to the ones used with Python's .format().
-		s(
+    s(
-			"fmt1",
+        "fmt1",
-			fmt("To {title} {} {}.", {
+        fmt("To {title} {} {}.", {
-				i(2, "Name"),
+            i(2, "Name"),
-				i(3, "Surname"),
+            i(3, "Surname"),
-				title = c(1, { t("Mr."), t("Ms.") }),
+            title = c(1, { t("Mr."), t("Ms.") }),
-			})
+        })
-		),
+    ),
-		-- To escape delimiters use double them, e.g. `{}` -> `{{}}`.
+    -- To escape delimiters use double them, e.g. `{}` -> `{{}}`.
-		-- Multi-line format strings by default have empty first/last line removed.
+    -- Multi-line format strings by default have empty first/last line removed.
-		-- Indent common to all lines is also removed. Use the third `opts` argument
+    -- Indent common to all lines is also removed. Use the third `opts` argument
-		-- to control this behaviour.
+    -- to control this behaviour.
-		s(
+    s(
-			"fmt2",
+        "fmt2",
-			fmt(
+        fmt(
-				[[
+            [[
-			foo({1}, {3}) {{
+        foo({1}, {3}) {{
-				return {2} * {4}
+            return {2} * {4}
-			}}
+        }}
-			]],
+        ]],
-				{
+            {
-					i(1, "x"),
+                i(1, "x"),
-					r(1),
+                r(1),
-					i(2, "y"),
+                i(2, "y"),
-					r(2),
+                r(2),
-				}
+            }
-			)
+        )
-		),
+    ),
-		-- Empty placeholders are numbered automatically starting from 1 or the last
+    -- Empty placeholders are numbered automatically starting from 1 or the last
-		-- value of a numbered placeholder. Named placeholders do not affect numbering.
+    -- value of a numbered placeholder. Named placeholders do not affect numbering.
-		s(
+    s(
-			"fmt3",
+        "fmt3",
-			fmt("{} {a} {} {1} {}", {
+        fmt("{} {a} {} {1} {}", {
-				t("1"),
+            t("1"),
-				t("2"),
+            t("2"),
-				a = t("A"),
+            a = t("A"),
-			})
+        })
-		),
+    ),
-		-- The delimiters can be changed from the default `{}` to something else.
+    -- The delimiters can be changed from the default `{}` to something else.
-		s(
+    s(
-			"fmt4",
+        "fmt4",
-			fmt("foo() { return []; }", i(1, "x"), { delimiters = "[]" })
+        fmt("foo() { return []; }", i(1, "x"), { delimiters = "[]" })
-		),
+    ),
-		-- `fmta` is a convenient wrapper that uses `<>` instead of `{}`.
+    -- `fmta` is a convenient wrapper that uses `<>` instead of `{}`.
-		s("fmt5", fmta("foo() { return <>; }", i(1, "x"))),
+    s("fmt5", fmta("foo() { return <>; }", i(1, "x"))),
-		-- By default all args must be used. Use strict=false to disable the check
+    -- By default all args must be used. Use strict=false to disable the check
-		s(
+    s(
-			"fmt6",
+        "fmt6",
-			fmt("use {} only", { t("this"), t("not this") }, { strict = false })
+        fmt("use {} only", { t("this"), t("not this") }, { strict = false })
-		),
+    ),
-	},
+}, {
-}
+        key = "all",
+    })
 
 -- autotriggered snippets have to be defined in a separate table, luasnip.autosnippets.
 ls.autosnippets = {

.local/src/astronomy.nvim

@@ -1 +1 @@
-Subproject commit d77e1cfe127418ab00c6d5fb076f89cdf9b49e94
+Subproject commit 9b46e0fa3d2bfca3b376961d822eb5d965da48ed