commit 9d1536e5af810e77c58edfead4c6e5ab0ce0c5e0 Author: Zelong Kuang Date: Tue May 13 19:37:28 2025 +1000 Update diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..cc5457a --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +tt.* +.tests +doc/tags +debug +.repro +foo.* +*.log +data diff --git a/.neoconf.json b/.neoconf.json new file mode 100644 index 0000000..7c48087 --- /dev/null +++ b/.neoconf.json @@ -0,0 +1,15 @@ +{ + "neodev": { + "library": { + "enabled": true, + "plugins": true + } + }, + "neoconf": { + "plugins": { + "lua_ls": { + "enabled": true + } + } + } +} diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..261eeb9 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/LuaSnip/all.lua b/LuaSnip/all.lua new file mode 100644 index 0000000..5cf7e6b --- /dev/null +++ b/LuaSnip/all.lua @@ -0,0 +1,21 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local c = ls.choice_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +return { + s( + "date", + f(function() + return os.date("%D - %H:%M") + end) + ), + s("choicenode", c(1, { t("choice 1"), t("choice 2"), t("choice 3") })), +} +-- test diff --git a/LuaSnip/lua.lua b/LuaSnip/lua.lua new file mode 100644 index 0000000..eb3fcda --- /dev/null +++ b/LuaSnip/lua.lua @@ -0,0 +1,100 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local c = ls.choice_node +local d = ls.dynamic_node +local extras = require("luasnip.extras") +local l = extras.lambda +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin + +return { + s( + "localreq", + fmt('local {} = require("{}")', { + l(l._1:match("[^.]*$"):gsub("[^%a]+", "_"), 1), + i(1, "module"), + }) + ), + s( + { trig = "add", snippetType = "autosnippet" }, + fmta('["<>"] = "<>",', { + i(1), + i(2), + }) + ), + ls.parser.parse_snippet("lm", "local M = {}\n\n$1 \n\nreturn M"), + s( + { trig = "csnip", snippetType = "autosnippet" }, + fmta( + [[ + s( + { trig = "<>", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\<>{"), i(1), t("}") }), sn(nil, { t("\\<>*{"), i(1), t("{") }) }), + { condition = tex.<> } + ), + ]], + { i(1), rep(1), rep(1), c(2, { t("in_text"), t("in_quantikz"), t("in_mathzone") }) } + ), + { condition = line_begin } + ), + s( + { trig = "optsnip", snippetType = "autosnippet" }, + fmta( + [[ + s( + { trig = "<>", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\<>{"), i(1), t("}") }), sn(nil, { t("\\<>["), i(1), t("]{"), i(2), t("}") }) }), + { condition = tex.<> } + ), + ]], + { i(1), rep(1), rep(1), c(2, { t("in_quantikz"), t("in_mathzone") }) } + ), + { condition = line_begin } + ), + s( + { trig = "starsnip", snippetType = "autosnippet" }, + fmta( + [[ + s( + { trig = "<>", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\<>{"), i(1), t("}") }), sn(nil, { t("\\<>*{"), i(1), t("}") }) }), + { condition = tex.<> } + ), + ]], + { i(1), rep(1), rep(1), c(2, { t("in_quantikz"), t("in_mathzone") }) } + ), + { condition = line_begin } + ), + s( + { trig = "fmtasnip", snippetType = "autosnippet" }, + fmta( + [[ + s({ trig = "<>", snippetType = "autosnippet" }, + fmta("\\<>{<<>>}", { + <> + }), + { condition = tex.<> }), + ]], + { i(1), rep(1), i(2, "i(1),"), c(3, { t("in_algo"), t("in_quantikz") }) } + ), + { condition = line_begin } + ), + s( + { trig = "tsnip", snippetType = "autosnippet" }, + fmta( + [[ + s({ trig = "<>", snippetType = "autosnippet" }, { + t("\\<>"), + }, { condition = tex.<> }), + ]], + { i(1), rep(1), c(2, { t("in_mathzone"), t("in_quantikz") }) } + ), + { condition = line_begin } + ), +} diff --git a/LuaSnip/markdown/math.lua b/LuaSnip/markdown/math.lua new file mode 100644 index 0000000..76ecaf0 --- /dev/null +++ b/LuaSnip/markdown/math.lua @@ -0,0 +1,24 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local c = ls.choice_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, i(1, parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end +local tex = require("util.latex") + +return { + -- s({ trig = "ii", snippetType = "autosnippet" }, fmta("$<>$", i(1))), + -- s({ trig = "dd", snippetType = "autosnippet" }, fmta("$$\n<>\n$$", i(1))), +} diff --git a/LuaSnip/markdown/text.lua b/LuaSnip/markdown/text.lua new file mode 100644 index 0000000..c574c74 --- /dev/null +++ b/LuaSnip/markdown/text.lua @@ -0,0 +1,41 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local c = ls.choice_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, i(1, parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + s( + "link", + fmta("[<>](<>)", { i(1), f(function(_, snip) + return snip.env.TM_SELECTED_TEXT[1] or {} + end, {}) }) + ), + s({ trig = ";b", snippetType = "autosnippet" }, fmta("**<>**", i(1))), + s({ trig = ";t", snippetType = "autosnippet" }, fmta("*<>*", i(1))), + s({ trig = "xx", snippetType = "autosnippet" }, fmta("$\\times$", {})), + s( + { trig = ";c", snippetType = "autosnippet" }, + fmta( + [[ + ```<> + <> + ``` + ]], + { i(1), i(0) } + ) + ), +} diff --git a/LuaSnip/python/manim.lua b/LuaSnip/python/manim.lua new file mode 100644 index 0000000..d72a971 --- /dev/null +++ b/LuaSnip/python/manim.lua @@ -0,0 +1,109 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local c = ls.choice_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +return { + s( + { trig = "voo", wordTrig = false, snippetType = "autosnippet" }, + fmta( + [[ + with self.voiceover(text="<>") as tracker: + <> + ]], + { + i(1), + i(0), + } + ) + ), + s( + { trig = "mte", wordTrig = false }, + fmta( + [[ + <>_string = "<>" + <>_tex = MathTex(r"<>", tex_template=myTemplate) + with self.voiceover(text=<>_string) as tracker: + self.play(Write(<>_tex)) + ]], + { + i(1), + i(2), + rep(1), + i(3), + rep(1), + rep(1), + } + ) + ), + s( + { trig = "text", wordTrig = false }, + fmta( + [[ + <>_string = "<>" + <>_text = Text(<>_string) + with self.voiceover(text=<>_string) as tracker: + self.play(Write(<>_text), run_time=tracker.duration) + ]], + { + i(1), + i(2), + rep(1), + rep(1), + rep(1), + rep(1), + } + ) + ), + s( + { trig = "spt", wordTrig = false, snippetType = "autosnippet" }, + fmta( + [[ + self.play(Write(<>), run_time=tracker.duration) + ]], + { + i(0), + } + ) + ), + s( + { trig = "spd", wordTrig = false, snippetType = "autosnippet" }, + fmta( + [[ + self.play(FadeOut(<>)) + ]], + { + i(0), + } + ) + ), + s( + { trig = "spp", wordTrig = false, snippetType = "autosnippet" }, + fmta( + [[ + self.play(<>) + ]], + { + i(0), + } + ) + ), + s( + { trig = "mtex", wordTrig = false, snippetType = "autosnippet" }, + fmta( + [[ + <> = MathTex(r"<>", tex_template=myTemplate) + ]], + { + i(1), + i(0), + } + ) + ), +} diff --git a/LuaSnip/tex/algo.lua b/LuaSnip/tex/algo.lua new file mode 100644 index 0000000..87c1f85 --- /dev/null +++ b/LuaSnip/tex/algo.lua @@ -0,0 +1,139 @@ +-- local ls = require("luasnip") +-- local s = ls.snippet +-- local sn = ls.snippet_node +-- local t = ls.text_node +-- local i = ls.insert_node +-- local f = ls.function_node +-- local d = ls.dynamic_node +-- local fmta = require("luasnip.extras.fmt").fmta +-- local rep = require("luasnip.extras").rep +-- local line_begin = require("luasnip.extras.expand_conditions").line_begin +-- local tex = require("util.latex") +-- local get_visual = function(args, parent) +-- if #parent.snippet.env.SELECT_RAW > 0 then +-- return sn(nil, t(parent.snippet.env.SELECT_RAW)) +-- else -- If SELECT_RAW is empty, return a blank insert node +-- return sn(nil, i(1)) +-- end +-- end +-- +-- return { +-- s( +-- { trig = "bal", snippetType = "autosnippet" }, +-- fmta( +-- [[ +-- \begin{algorithm} +-- \caption{<>} +-- \label{algo:<>} +-- \begin{algorithmic}[1] +-- \Require <> +-- \end{algorithmic} +-- +-- \end{algorithm} +-- ]], +-- { +-- i(1), +-- rep(1), +-- i(0), +-- } +-- ), +-- { condition = line_begin } +-- ), +-- s({ trig = "ss", snippetType = "autosnippet" }, { +-- t("\\State "), +-- }, { condition = tex.in_algo * line_begin }), +-- s({ trig = "sx", snippetType = "autosnippet" }, { +-- t("\\Statex "), +-- }, { condition = tex.in_algo * line_begin }), +-- s({ trig = "return", snippetType = "autosnippet" }, { +-- t("\\Return"), +-- }, { condition = tex.in_algo }), +-- s( +-- { trig = "while", snippetType = "autosnippet" }, +-- fmta( +-- [[ +-- \While{<>} +-- <> +-- \EndWhile +-- ]], +-- { +-- i(1), +-- i(0), +-- } +-- ), +-- { condition = tex.in_algo * line_begin } +-- ), +-- s( +-- { trig = "for", snippetType = "autosnippet" }, +-- fmta( +-- [[ +-- \For{<>} +-- <> +-- \EndFor +-- ]], +-- { +-- i(1), +-- i(0), +-- } +-- ), +-- { condition = tex.in_algo * line_begin } +-- ), +-- s( +-- { trig = "if", snippetType = "autosnippet" }, +-- fmta( +-- [[ +-- \If{<>} +-- <> +-- \EndIf +-- ]], +-- { +-- i(1), +-- i(0), +-- } +-- ), +-- { condition = tex.in_algo * line_begin } +-- ), +-- s( +-- { trig = "elif", snippetType = "autosnippet" }, +-- fmta( +-- [[ +-- \ElsIf{<>} +-- <> +-- ]], +-- { +-- i(1), +-- i(0), +-- } +-- ), +-- { condition = tex.in_algo * line_begin } +-- ), +-- s( +-- { trig = "else", snippetType = "autosnippet" }, +-- fmta( +-- [[ +-- \Else +-- <> +-- ]], +-- { +-- i(0), +-- } +-- ), +-- { condition = tex.in_algo * line_begin } +-- ), +-- s( +-- { trig = "fn", snippetType = "autosnippet" }, +-- fmta( +-- [[ +-- \Function{<>}{<>} +-- <> +-- \EndFunction +-- ]], +-- { +-- i(1), +-- i(2), +-- i(0), +-- } +-- ), +-- { condition = tex.in_algo * line_begin } +-- ), +-- } diff --git a/LuaSnip/tex/completion.lua b/LuaSnip/tex/completion.lua new file mode 100644 index 0000000..ddab1e8 --- /dev/null +++ b/LuaSnip/tex/completion.lua @@ -0,0 +1,309 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin +local tex = require("util.latex") + +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, i(1, parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + -- s( + -- { trig = "(%a);", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + -- fmta("\\hat{<>}", { + -- f(function(_, snip) + -- return snip.captures[1] + -- end), + -- }), + -- { condition = tex.in_mathzone } + -- ), + s( + { trig = "([%a%)%]%}])(%d)", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("<>_<>", { + f(function(_, snip) + return snip.captures[1] + end), + f(function(_, snip) + return snip.captures[2] + end), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "([%a%)%]%}])_(%d)(%d)", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("<>_{<><>}", { + f(function(_, snip) + return snip.captures[1] + end), + f(function(_, snip) + return snip.captures[2] + end), + f(function(_, snip) + return snip.captures[3] + end), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "([%a%)%]%}])(%a)%2", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 100 }, + fmta("<>_<>", { + f(function(_, snip) + return snip.captures[1] + end), + f(function(_, snip) + return snip.captures[2] + end), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "([%a%)%]%}])_(%a)(%a)%3", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("<>_{<><>}", { + f(function(_, snip) + return snip.captures[1] + end), + f(function(_, snip) + return snip.captures[2] + end), + f(function(_, snip) + return snip.captures[3] + end), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "(%d+)/", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 100 }, + fmta("\\frac{<>}{<>}", { + f(function(_, snip) + return snip.captures[1] + end), + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "(%a)/", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 100 }, + fmta("\\frac{<>}{<>}", { + f(function(_, snip) + return snip.captures[1] + end), + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "%((.+)%)/", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("\\frac{<>}{<>}", { + f(function(_, snip) + return snip.captures[1] + end), + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "(\\%a+)/", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\frac{<>}{<>}", { + f(function(_, snip) + return snip.captures[1] + end), + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "(\\%a+%{%a+%})/", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 3000 }, + fmta("\\frac{<>}{<>}", { + f(function(_, snip) + return snip.captures[1] + end), + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "\\%)(%a)", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\) <>", { + f(function(_, snip) + return snip.captures[1] + end), + }) + ), + s( + { trig = "\\](%a)", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\] <>", { + f(function(_, snip) + return snip.captures[1] + end), + }) + ), + s( + { trig = "lim", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("\\lim_{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "lsup", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\limsup_{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "linf", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("\\liminf_{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + -- s( + -- { trig = "sum", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + -- fmta("\\sum\\limits_{<>}^{<>}", { + -- i(1), + -- i(1), + -- }), + -- { condition = tex.in_mathzone } + -- ), + s( + { trig = "sum", snippetType = "autosnippet" }, + c(1, { + sn(nil, { t("\\sum_{"), i(1), t("} ") }), + sn(nil, { t("\\sum_{"), i(1), t("}^{"), i(2), t("} ") }), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "pd", snippetType = "autosnippet" }, + c(1, { + sn(nil, { t("\\prod_{"), i(1), t("} ") }), + sn(nil, { t("\\prod_{"), i(1), t("}^{"), i(2), t("} ") }), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "bot", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\bigotimes_{<>}^{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "bcap", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\bigcap_{<>}^{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "bcup", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\bigcup_{<>}^{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "blor", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\bigvee_{<>}^{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "band", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\bigwedge_{<>}^{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "bscap", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\bigsqcap_{<>}^{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "bscup", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\bigsqcup_{<>}^{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "pt", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("\\int <> \\d P", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "mt", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("\\int <> d\\mu", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "int", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("\\int_{<>}^{<>} <> d <>", { + i(1), + i(2), + i(3), + i(4), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "2int", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\int_{<>}^{<>}\\int_{<>}^{<>} <> \\d <>\\d <>", { + i(1), + i(2), + i(3), + i(4), + i(5), + i(6), + i(7), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "iint", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\iint_{<>}^{<>} <> \\d <>", { + i(1, "-\\infty"), + i(2, "\\infty"), + i(3), + i(4), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "lint", regTrig = true, wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\int_{<>} <> \\d <>", { + i(1, "\\infty"), + i(2), + i(3), + }), + { condition = tex.in_mathzone } + ), +} diff --git a/LuaSnip/tex/derivative.lua b/LuaSnip/tex/derivative.lua new file mode 100644 index 0000000..7f0011e --- /dev/null +++ b/LuaSnip/tex/derivative.lua @@ -0,0 +1,58 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin + +local tex = require("util.latex") + +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, t(parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + -- s( + -- { trig = "pv", snippetType = "autosnippet" }, + -- fmta("\\pdv[order={<>}]{<>}{<>}", { + -- i(0), + -- i(1), + -- i(2), + -- }), + -- { condition = tex.in_mathzone } + -- ), + s( + { trig = "pv", snippetType = "autosnippet" }, + c(1, { + sn(nil, { t("\\pdv{"), i(1), t("}{"), i(2), t("}") }), + sn(nil, { t("\\pdv[order={"), i(3), t("}]{"), i(1), t("}{"), i(2), t("}") }), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "ov", snippetType = "autosnippet" }, + c(1, { + sn(nil, { t("\\odv{"), i(1), t("}{"), i(2), t("}") }), + sn(nil, { t("\\odv[order={"), i(3), t("}]{"), i(1), t("}{"), i(2), t("}") }), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "ov", snippetType = "autosnippet" }, + fmta("\\odv[order={<>}]{<>}{<>}", { + i(0), + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), +} diff --git a/LuaSnip/tex/env.lua b/LuaSnip/tex/env.lua new file mode 100644 index 0000000..69fd91b --- /dev/null +++ b/LuaSnip/tex/env.lua @@ -0,0 +1,435 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin +local tex = require("util.latex") +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, t(parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + s( + { trig = "mk", snippetType = "autosnippet" }, + fmta( + [[ + \(<>\) + ]], + { + i(1), + } + ), + { condition = tex.in_text } + ), + s( + { trig = "dm", snippetType = "autosnippet" }, + fmta( + [[ + \[ + <> + \] + ]], + { + i(1), + } + ), + { condition = tex.in_text } + ), + s( + { trig = "bad", snippetType = "autosnippet" }, + fmta( + [[ + \begin{adjustbox}{width=0.<>\textwidth} + <> + \end{adjustbox} + ]], + { + i(1, "8"), + i(0), + } + ), + { condition = line_begin } + ), + s( + { trig = "bp", snippetType = "autosnippet" }, + fmta( + [[ + \begin{problem}{<>} + <> + \end{problem} + ]], + { + i(1), + i(0), + } + ), + { condition = line_begin } + ), + s( + { trig = "equ", snippetType = "autosnippet" }, + fmta( + [[ + \begin{equation} + <> + \end{equation} + ]], + { + i(0), + } + ), + { condition = line_begin * tex.in_text } + ), + s( + { trig = "bf", snippetType = "autosnippet" }, + fmta( + [[ + \begin{proof} + <> + \end{proof} + ]], + { + i(0), + } + ), + { condition = line_begin * tex.in_text } + ), + s( + { trig = "bep", snippetType = "autosnippet" }, + fmta( + [[ + \begin{problem}[<>] + <> + \end{problem} + ]], + { + i(1), + i(0), + } + ), + { condition = line_begin } + ), + s( + { trig = "bdef", snippetType = "autosnippet" }, + fmta( + [[ + \begin{definition} + <> + \end{definition} + ]], + { + i(0), + } + ), + { condition = line_begin } + ), + s( + { trig = "bth", snippetType = "autosnippet" }, + fmta( + [[ + \begin{theorem} + <> + \end{theorem} + ]], + { + i(0), + } + ), + { condition = line_begin } + ), + s( + { trig = "bex", snippetType = "autosnippet" }, + fmta( + [[ + \begin{example} + <> + \end{example} + ]], + { + i(0), + } + ), + { condition = line_begin } + ), + s( + { trig = "bve", snippetType = "autosnippet" }, + fmta( + [[ + \begin{verbatim} + <> + \end{verbatim} + ]], + { + i(0), + } + ), + { condition = line_begin } + ), + s( + { trig = "bbi", snippetType = "autosnippet" }, + fmta( + [[ + \begin{thebibliography} + <> + \end{thebibliography} + ]], + { + i(0), + } + ), + { condition = line_begin } + ), + s({ trig = "bib", snippetType = "autosnippet" }, { + t("\\bibitem"), + }, { condition = tex.in_bib * line_begin }), + s( + { trig = "bfi", snippetType = "autosnippet" }, + fmta( + [[ + \begin{figure}[htbp] + \centering + \includegraphics[width=0.5\textwidth]{<>} + \caption{<>} + \label{fig:<>} + \end{figure} + ]], + { + i(1), + i(2), + rep(2), + } + ), + { condition = line_begin } + ), + s( + { trig = "beg", snippetType = "autosnippet" }, + fmta( + [[ + \begin{<>}<> + <> + \end{<>} + ]], + { + i(1), + i(2), + i(0), + rep(1), + } + ), + { condition = line_begin } + ), + s( + { trig = "ben", snippetType = "autosnippet" }, + fmta( + [[ + \begin{enumerate}[<>] + \item <> + \end{enumerate} + ]], + { + i(1, "(a)"), + i(0), + } + ), + { condition = line_begin } + ), + s( + { trig = "blst", snippetType = "autosnippet" }, + fmta( + [[ + \begin{lstlisting}[language=<>] + <> + \end{lstlisting} + ]], + { + i(1), + i(0), + } + ), + { condition = tex.in_text * line_begin } + ), + s( + { trig = "box", snippetType = "autosnippet" }, + fmta( + [[ + \begin{framed} + <> + \end{framed} + ]], + { + i(0), + } + ), + { condition = tex.in_text * line_begin } + ), + s( + { trig = "dcase", snippetType = "autosnippet", priority = 2000 }, + fmta( + [[ + \begin{dcases} + <> + \end{dcases} + ]], + { + i(0), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "case", snippetType = "autosnippet" }, + fmta( + [[ + \begin{cases} + <> + \end{cases} + ]], + { + i(0), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "bal", snippetType = "autosnippet" }, + fmta( + [[ + \begin{aligned} + <> + \end{aligned} + ]], + { + i(0), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "bal", snippetType = "autosnippet", priority = 2000 }, + fmta( + [[ + \begin{aligned} + <> + \end{aligned} + ]], + { + d(1, get_visual), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "bit", snippetType = "autosnippet" }, + fmta( + [[ + \begin{itemize} + \item <> + \end{itemize} + ]], + { + i(0), + } + ), + { condition = line_begin } + ), + s({ trig = "im", snippetType = "autosnippet" }, { + t("\\item"), + }, { condition = tex.in_item * line_begin }), + s( + { trig = "bcr", snippetType = "autosnippet" }, + fmta( + [[ + \begin{center} + <> + \end{center} + ]], + { + i(0), + } + ), + { condition = line_begin } + ), + s( + { trig = "btr", snippetType = "autosnippet" }, + fmta( + [[ + \begin{tabular}{<>} + \hline + <> + \hline + \end{tabular} + ]], + { + i(1), + i(2), + } + ), + { condition = line_begin } + ), + s( + { trig = "cha", snippetType = "autosnippet" }, + fmta( + [[ + \chapter{<>} + ]], + { + i(1), + } + ), + { condition = line_begin } + ), + s( + { trig = "par", snippetType = "autosnippet" }, + fmta( + [[ + \paragraph{<>} + ]], + { + i(1), + } + ), + { condition = line_begin } + ), + s( + { trig = "sec", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\section{"), i(1), t("}") }), sn(nil, { t("\\section*{"), i(1), t("}") }) }), + { condition = tex.in_text * line_begin } + ), + s( + { trig = "ssec", snippetType = "autosnippet" }, + fmta( + [[ + \subsection{<>} + ]], + { + i(1), + } + ), + { condition = line_begin } + ), + s( + { trig = "sss", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\subsubsection{"), i(1), t("}") }), sn(nil, { t("\\subsubsection*{"), i(1), t("}") }) }), + { condition = tex.in_text * line_begin } + ), + s( + { trig = "sss", snippetType = "autosnippet" }, + fmta( + [[ + \subsubsection{<>} + ]], + { + i(0), + } + ), + { condition = line_begin * line_begin } + ), +} diff --git a/LuaSnip/tex/font.lua b/LuaSnip/tex/font.lua new file mode 100644 index 0000000..74ca6f5 --- /dev/null +++ b/LuaSnip/tex/font.lua @@ -0,0 +1,145 @@ +local ls = require("luasnip") +local t = ls.text_node +local s = ls.snippet +local sn = ls.snippet_node +local i = ls.insert_node +local d = ls.dynamic_node +local postfix = require("luasnip.extras.postfix").postfix +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, t(parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +local tex = require("util.latex") + +return { + s( + { trig = "msf", snippetType = "autosnippet", priority = 2000 }, + fmta("\\mathsf{<>}", { + d(1, get_visual), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "msf", snippetType = "autosnippet" }, + fmta("\\mathsf{<>}", { + i(0), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "bf", snippetType = "autosnippet" }, + fmta("\\mathbf{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "cal", snippetType = "autosnippet", priority = 2000 }, + fmta("\\mathcal{<>}", { + d(1, get_visual), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "cal", snippetType = "autosnippet" }, + fmta("\\mathcal{<>}", { + i(0), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "scr", snippetType = "autosnippet", priority = 2000 }, + fmta("\\mathscr{<>}", { + d(1, get_visual), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "scr", snippetType = "autosnippet" }, + fmta("\\mathscr{<>}", { + i(0), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "mbb", snippetType = "autosnippet", priority = 2000 }, + fmta("\\mathbb{<>}", { + d(1, get_visual), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "mbb", snippetType = "autosnippet" }, + fmta("\\mathbb{<>}", { + i(0), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "mrm", snippetType = "autosnippet", priority = 2000 }, + fmta("\\mathrm{<>}", { + d(1, get_visual), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "mrm", snippetType = "autosnippet" }, + fmta("\\mathrm{<>}", { + i(0), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "tit", snippetType = "autosnippet", priority = 2000 }, + fmta("\\textit{<>}", { + d(1, get_visual), + }) + ), + s( + { trig = "tit", snippetType = "autosnippet" }, + fmta("\\textit{<>}", { + i(0), + }) + ), + s( + { trig = "ttt", snippetType = "autosnippet" }, + fmta("\\texttt{<>}", { + i(0), + }) + ), + s( + { trig = "tbf", snippetType = "autosnippet", priority = 2000 }, + fmta("\\textbf{<>}", { + d(1, get_visual), + }) + ), + s( + { trig = "tbf", snippetType = "autosnippet" }, + fmta("\\textbf{<>}", { + i(0), + }) + ), + s( + { trig = "qq", snippetType = "autosnippet" }, + fmta("\\text{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "tet", snippetType = "autosnippet" }, + fmta("\\text{<>}", { + i(1), + }) + ), + s({ trig = "CC", snippetType = "autosnippet" }, + t("\\mathbb{C}"), + { condition = tex.in_mathzone() }), +} diff --git a/LuaSnip/tex/greek-letter.lua b/LuaSnip/tex/greek-letter.lua new file mode 100644 index 0000000..56a452b --- /dev/null +++ b/LuaSnip/tex/greek-letter.lua @@ -0,0 +1,172 @@ +local ls = require("luasnip") +local s = ls.snippet +local t = ls.text_node +local tex = require("util.latex") + +return { + s({ trig = "alp", snippetType = "autosnippet", wordTrig = false }, { + t("\\alpha"), + }, { condition = tex.in_mathzone }), + s({ trig = "Alp", snippetType = "autosnippet", wordTrig = false }, { + t("\\Alpha"), + }, { condition = tex.in_mathzone }), + s({ trig = ";a", snippetType = "autosnippet", wordTrig = false }, { + t("\\alpha"), + }, { condition = tex.in_mathzone }), + s({ trig = "beta", snippetType = "autosnippet", wordTrig = false }, { + t("\\beta"), + }, { condition = tex.in_mathzone }), + s({ trig = ";b", snippetType = "autosnippet", wordTrig = false }, { + t("\\beta"), + }, { condition = tex.in_mathzone }), + s({ trig = "Beta", snippetType = "autosnippet", wordTrig = false }, { + t("\\Beta"), + }, { condition = tex.in_mathzone }), + s({ trig = "gam", snippetType = "autosnippet", wordTrig = false }, { + t("\\gamma"), + }, { condition = tex.in_mathzone }), + s({ trig = ";c", snippetType = "autosnippet", wordTrig = false }, { + t("\\gamma"), + }, { condition = tex.in_mathzone }), + s({ trig = "Gam", snippetType = "autosnippet", wordTrig = false }, { + t("\\Gamma"), + }, { condition = tex.in_mathzone }), + s({ trig = "del", snippetType = "autosnippet", wordTrig = false }, { + t("\\delta"), + }, { condition = tex.in_mathzone }), + s({ trig = ";d", snippetType = "autosnippet", wordTrig = false }, { + t("\\delta"), + }, { condition = tex.in_mathzone }), + s({ trig = "Del", snippetType = "autosnippet", wordTrig = false }, { + t("\\Delta"), + }, { condition = tex.in_mathzone }), + s({ trig = "eps", snippetType = "autosnippet", wordTrig = false }, { + t("\\epsilon"), + }, { condition = tex.in_mathzone }), + s({ trig = "vps", snippetType = "autosnippet", wordTrig = false }, { + t("\\varepsilon"), + }, { condition = tex.in_mathzone }), + s({ trig = "Eps", snippetType = "autosnippet", wordTrig = false }, { + t("\\Epsilon"), + }, { condition = tex.in_mathzone }), + s({ trig = "zeta", snippetType = "autosnippet", wordTrig = false }, { + t("\\zeta"), + }, { condition = tex.in_mathzone }), + s({ trig = "Zeta", snippetType = "autosnippet", wordTrig = false }, { + t("\\Zeta"), + }, { condition = tex.in_mathzone }), + s({ trig = "eta", snippetType = "autosnippet", wordTrig = false }, { + t("\\eta"), + }, { condition = tex.in_mathzone }), + s({ trig = "Eta", snippetType = "autosnippet", wordTrig = false }, { + t("\\Eta"), + }, { condition = tex.in_mathzone }), + s({ trig = "the", snippetType = "autosnippet", wordTrig = false }, { + t("\\theta"), + }, { condition = tex.in_mathzone }), + s({ trig = "The", snippetType = "autosnippet", wordTrig = false }, { + t("\\Theta"), + }, { condition = tex.in_mathzone }), + s({ trig = "iot", snippetType = "autosnippet", wordTrig = false }, { + t("\\iota"), + }, { condition = tex.in_mathzone }), + s({ trig = "Iot", snippetType = "autosnippet", wordTrig = false }, { + t("\\Iota"), + }, { condition = tex.in_mathzone }), + s({ trig = "kap", snippetType = "autosnippet", wordTrig = false }, { + t("\\kappa"), + }, { condition = tex.in_mathzone }), + s({ trig = "Kap", snippetType = "autosnippet", wordTrig = false }, { + t("\\Kappa"), + }, { condition = tex.in_mathzone }), + s({ trig = "lam", snippetType = "autosnippet", wordTrig = false }, { + t("\\lambda"), + }, { condition = tex.in_mathzone }), + s({ trig = "Lam", snippetType = "autosnippet", wordTrig = false }, { + t("\\Lambda"), + }, { condition = tex.in_mathzone }), + s({ trig = "mu", snippetType = "autosnippet", wordTrig = false }, { + t("\\mu"), + }, { condition = tex.in_mathzone }), + s({ trig = "Mu", snippetType = "autosnippet", wordTrig = false }, { + t("\\Mu"), + }, { condition = tex.in_mathzone }), + s({ trig = "nu", snippetType = "autosnippet", wordTrig = false }, { + t("\\nu"), + }, { condition = tex.in_mathzone }), + s({ trig = "Nu", snippetType = "autosnippet", wordTrig = false }, { + t("\\Nu"), + }, { condition = tex.in_mathzone }), + -- s({ trig = "xi", snippetType = "autosnippet", wordTrig = false }, { + -- t("\\xi"), + -- }, { condition = tex.in_mathzone }), + -- s({ trig = "Xi", snippetType = "autosnippet", wordTrig = false }, { + -- t("\\Xi"), + -- }, { condition = tex.in_mathzone }), + s({ trig = "omi", snippetType = "autosnippet", wordTrig = false }, { + t("\\omicron"), + }, { condition = tex.in_mathzone }), + s({ trig = "pi", snippetType = "autosnippet", wordTrig = false }, { + t("\\pi"), + }, { condition = tex.in_mathzone }), + s({ trig = "\\pii", snippetType = "autosnippet", wordTrig = false, priority = 2000 }, { + t("p_i"), + }, { condition = tex.in_mathzone }), + s({ trig = "Pi", snippetType = "autosnippet", wordTrig = false }, { + t("\\Pi"), + }, { condition = tex.in_mathzone }), + s({ trig = "rho", snippetType = "autosnippet", wordTrig = false }, { + t("\\rho"), + }, { condition = tex.in_mathzone }), + s({ trig = "Rho", snippetType = "autosnippet", wordTrig = false }, { + t("\\Rho"), + }, { condition = tex.in_mathzone }), + s({ trig = "sig", snippetType = "autosnippet", wordTrig = false }, { + t("\\sigma"), + }, { condition = tex.in_mathzone }), + s({ trig = "Sig", snippetType = "autosnippet", wordTrig = false }, { + t("\\Sigma"), + }, { condition = tex.in_mathzone }), + s({ trig = "tau", snippetType = "autosnippet", wordTrig = false }, { + t("\\tau"), + }, { condition = tex.in_mathzone }), + s({ trig = "Tau", snippetType = "autosnippet", wordTrig = false }, { + t("\\Tau"), + }, { condition = tex.in_mathzone }), + s({ trig = "ups", snippetType = "autosnippet", wordTrig = false }, { + t("\\ups"), + }, { condition = tex.in_mathzone }), + s({ trig = "Ups", snippetType = "autosnippet", wordTrig = false }, { + t("\\Ups"), + }, { condition = tex.in_mathzone }), + s({ trig = "phi", snippetType = "autosnippet", wordTrig = false }, { + t("\\phi"), + }, { condition = tex.in_mathzone }), + s({ trig = "Phi", snippetType = "autosnippet", wordTrig = false }, { + t("\\Phi"), + }, { condition = tex.in_mathzone }), + s({ trig = "vhi", snippetType = "autosnippet", wordTrig = false }, { + t("\\varphi"), + }, { condition = tex.in_mathzone }), + s({ trig = "Vhi", snippetType = "autosnippet", wordTrig = false }, { + t("\\Varphi"), + }, { condition = tex.in_mathzone }), + s({ trig = "chi", snippetType = "autosnippet", wordTrig = false }, { + t("\\chi"), + }, { condition = tex.in_mathzone }), + s({ trig = "Chi", snippetType = "autosnippet", wordTrig = false }, { + t("\\Chi"), + }, { condition = tex.in_mathzone }), + s({ trig = "psi", snippetType = "autosnippet", wordTrig = false }, { + t("\\psi"), + }, { condition = tex.in_mathzone }), + s({ trig = "Psi", snippetType = "autosnippet", wordTrig = false }, { + t("\\Psi"), + }, { condition = tex.in_mathzone }), + s({ trig = "ome", snippetType = "autosnippet", wordTrig = false }, { + t("\\omega"), + }, { condition = tex.in_mathzone }), + s({ trig = "Ome", snippetType = "autosnippet", wordTrig = false }, { + t("\\Omega"), + }, { condition = tex.in_mathzone }), +} diff --git a/LuaSnip/tex/math-commands.lua b/LuaSnip/tex/math-commands.lua new file mode 100644 index 0000000..ee4cd84 --- /dev/null +++ b/LuaSnip/tex/math-commands.lua @@ -0,0 +1,426 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local d = ls.dynamic_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin + +local tex = require("util.latex") + +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, t(parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + s({ trig = "sin", snippetType = "autosnippet" }, { + t("\\sin"), + }, { condition = tex.in_mathzone }), + s({ trig = "asin", snippetType = "autosnippet" }, { + t("\\arcsin"), + }, { condition = tex.in_mathzone }), + s({ trig = "cos", snippetType = "autosnippet" }, { + t("\\cos"), + }, { condition = tex.in_mathzone }), + s({ trig = "acos", snippetType = "autosnippet" }, { + t("\\arccos"), + }, { condition = tex.in_mathzone }), + s({ trig = "tan", snippetType = "autosnippet" }, { + t("\\tan"), + }, { condition = tex.in_mathzone }), + s({ trig = "atan", snippetType = "autosnippet" }, { + t("\\arctan"), + }, { condition = tex.in_mathzone }), + s({ trig = "cot", snippetType = "autosnippet" }, { + t("\\cot"), + }, { condition = tex.in_mathzone }), + s({ trig = "acot", snippetType = "autosnippet" }, { + t("\\arccot"), + }, { condition = tex.in_mathzone }), + s({ trig = "csc", snippetType = "autosnippet" }, { + t("\\csc"), + }, { condition = tex.in_mathzone }), + s({ trig = "acsc", snippetType = "autosnippet" }, { + t("\\arccsc"), + }, { condition = tex.in_mathzone }), + s({ trig = "sec", snippetType = "autosnippet" }, { + t("\\sec"), + }, { condition = tex.in_mathzone }), + s({ trig = "asec", snippetType = "autosnippet" }, { + t("\\arcsec"), + }, { condition = tex.in_mathzone }), + s({ trig = "log", snippetType = "autosnippet" }, { + t("\\log"), + }, { condition = tex.in_mathzone }), + s({ trig = "ln", snippetType = "autosnippet" }, { + t("\\ln"), + }, { condition = tex.in_mathzone }), + s({ trig = "exp", snippetType = "autosnippet" }, { + t("\\exp"), + }, { condition = tex.in_mathzone }), + s({ trig = "grad", snippetType = "autosnippet" }, { + t("\\grad"), + }, { condition = tex.in_mathzone }), + s({ trig = "curl", snippetType = "autosnippet" }, { + t("\\curl"), + }, { condition = tex.in_mathzone }), + s({ trig = "div", snippetType = "autosnippet" }, { + t("\\div"), + }, { condition = tex.in_mathzone }), + s({ trig = "lap", snippetType = "autosnippet" }, { + t("\\laplacian"), + }, { condition = tex.in_mathzone }), + s({ trig = "bbr", snippetType = "autosnippet" }, { + t("\\mathbb{R}"), + }, { condition = tex.in_mathzone }), + s({ trig = "bbq", snippetType = "autosnippet" }, { + t("\\mathbb{Q}"), + }, { condition = tex.in_mathzone }), + s({ trig = "bbh", snippetType = "autosnippet" }, { + t("\\mathbb{H}"), + }, { condition = tex.in_mathzone }), + s({ trig = "bbc", snippetType = "autosnippet" }, { + t("\\mathbb{C}"), + }, { condition = tex.in_mathzone }), + s({ trig = "bbz", snippetType = "autosnippet" }, { + t("\\mathbb{Z}"), + }, { condition = tex.in_mathzone }), + s({ trig = "bbn", snippetType = "autosnippet" }, { + t("\\mathbb{N}"), + }, { condition = tex.in_mathzone }), + s({ trig = "bb1", snippetType = "autosnippet", priority = 2000 }, { + t("\\mathbbm{1}"), + }, { condition = tex.in_mathzone }), + s({ trig = "bbe", snippetType = "autosnippet" }, { + t("\\mathbb{E}"), + }, { condition = tex.in_mathzone }), + s( + { trig = "bb(%w)", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("\\mathbb{<>}", { + f(function(_, snip) + return string.upper(snip.captures[1]) + end), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "(%w)cal", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("\\mathcal{<>}", { + f(function(_, snip) + return string.upper(snip.captures[1]) + end), + }), + { condition = tex.in_mathzone } + ), + s({ trig = "exp", snippetType = "autosnippet" }, { + t("\\exp"), + }, { condition = tex.in_mathzone }), + s({ trig = "cv", snippetType = "autosnippet" }, fmta("\\conv", {}), { condition = tex.in_mathzone }), + s( + { trig = "br", snippetType = "autosnippet" }, + fmta("\\bar{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "bar", snippetType = "autosnippet" }, + fmta("\\overline{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "(%a)bar", wordTrig = false, regTrig = true, snippetType = "autosnippet" }, + fmta("\\overline{<>}", { + f(function(_, snip) + return snip.captures[1] + end), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "ob", snippetType = "autosnippet" }, + fmta("\\overbrace{<>}^{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "ob", snippetType = "autosnippet", priority = 2000 }, + fmta("\\overbrace{<>}^{<>}", { + d(1, get_visual), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "td", snippetType = "autosnippet", priority = 2000 }, + fmta("\\tilde{<>}", { + d(1, get_visual), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "td", snippetType = "autosnippet" }, + fmta("\\ttlde{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "(\\%a+)~", wordTrig = false, regTrig = true, snippetType = "autosnippet" }, + fmta("\\tilde{<>}", { + f(function(_, snip) + return snip.captures[1] + end), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "(%a)~", wordTrig = false, regTrig = true, snippetType = "autosnippet" }, + fmta("\\tilde{<>}", { + f(function(_, snip) + return snip.captures[1] + end), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "dot", snippetType = "autosnippet", priority = 2000 }, + fmta("\\dot{<>}", { + d(1, get_visual), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "dot", snippetType = "autosnippet" }, + fmta("\\dot{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "doo", snippetType = "autosnippet", priority = 2000 }, + fmta("\\ddot{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "vb", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\vb{"), i(1), t("}") }), sn(nil, { t("\\vb*{"), i(1), t("}") }) }), + { condition = tex.in_mathzone } + ), + s( + { trig = "vu", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\vu{"), i(1), t("}") }), sn(nil, { t("\\vu*{"), i(1), t("}") }) }), + { condition = tex.in_mathzone } + ), + s( + { trig = "hat", snippetType = "autosnippet", priority = 2000 }, + fmta("\\hat{<>}", { + d(1, get_visual), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "hat", snippetType = "autosnippet" }, + fmta("\\hat{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "vec", snippetType = "autosnippet", priority = 2000 }, + fmta("\\vec{<>}", { + d(1, get_visual), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = ";v", snippetType = "autosnippet" }, + fmta("\\vec{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "vec", snippetType = "autosnippet" }, + fmta("\\vec{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s({ trig = "rr", snippetType = "autosnippet" }, fmta("\\Range", {}), { condition = tex.in_mathzone }), + s({ trig = "kk", snippetType = "autosnippet" }, fmta("\\ker", {}), { condition = tex.in_mathzone }), + s({ trig = "tr", snippetType = "autosnippet" }, fmta("\\tr", {}), { condition = tex.in_mathzone }), + s({ trig = "span", snippetType = "autosnippet" }, fmta("\\Span", {}), { condition = tex.in_mathzone }), + s({ trig = "aut", snippetType = "autosnippet" }, fmta("\\Aut", {}), { condition = tex.in_mathzone }), + s({ trig = "gal", snippetType = "autosnippet" }, fmta("\\Gal", {}), { condition = tex.in_mathzone }), + s({ trig = "rank", snippetType = "autosnippet" }, fmta("\\rank", {}), { condition = tex.in_mathzone }), + s({ trig = "dim", snippetType = "autosnippet" }, fmta("\\dim", {}), { condition = tex.in_mathzone }), + s({ trig = "det", snippetType = "autosnippet" }, fmta("\\det", {}), { condition = tex.in_mathzone }), + s({ trig = "vol", snippetType = "autosnippet" }, fmta("\\Vol", {}), { condition = tex.in_mathzone }), + s( + { trig = "->", snippetType = "autosnippet" }, + fmta("\\xlongrightarrow{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "<-", snippetType = "autosnippet" }, + fmta("\\xlongleftarrow{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s({ trig = "--", snippetType = "autosnippet" }, fmta("\\longleftrightarrow", {}), { condition = tex.in_mathzone }), + s( + { trig = "gt", snippetType = "autosnippet" }, + fmta("\\gt{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s({ trig = "min", snippetType = "autosnippet" }, fmta("\\min", {}), { condition = tex.in_mathzone }), + s({ trig = "max", snippetType = "autosnippet" }, fmta("\\max", {}), { condition = tex.in_mathzone }), + s( + { trig = "amin", snippetType = "autosnippet" }, + fmta("\\argmin_{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "amax", snippetType = "autosnippet" }, + fmta("\\argmax_{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s({ trig = "sup", snippetType = "autosnippet", priority = 2000 }, fmta("\\sup", {}), { condition = tex.in_mathzone }), + s({ trig = "inf", snippetType = "autosnippet", priority = 2000 }, fmta("\\inf", {}), { condition = tex.in_mathzone }), + s( + { trig = ";r", wordTrig = false, snippetType = "autosnippet" }, + fmta("\\frac{<>}{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = ";r", snippetType = "autosnippet", priority = 2000 }, + fmta("\\frac{<>}{<>}", { + d(1, get_visual), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = ";i", wordTrig = false, snippetType = "autosnippet" }, + fmta("\\langle <>, <> \\rangle", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + + s( + { trig = "binom", snippetType = "autosnippet" }, + fmta("\\binom{<>}{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + -- s({ trig = "dd", snippetType = "autosnippet" }, fmta("\\d ", {}), { condition = tex.in_mathzone }), + s({ trig = "poly", snippetType = "autosnippet" }, fmta("\\poly", {}), { condition = tex.in_mathzone }), + s( + { trig = "sq", wordTrig = false, snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\sqrt{"), i(1), t("}") }), sn(nil, { t("\\sqrt["), i(1), t("]{"), i(2), t("}") }) }), + { condition = tex.in_mathzone } + ), + s( + { trig = "mod", wordTrig = false, snippetType = "autosnippet" }, + fmta("\\mod{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "nmod", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\nmod{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "pmod", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\pmod{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "sgn", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\sgn", {}), + { condition = tex.in_mathzone } + ), + s( + { trig = "SI", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\SI{<>}{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "cond", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\cond(<>)", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "cqty", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\complexqty{<>}{<>}", { + i(1), + i(2), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "gcd", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\gcd", {}), + { condition = tex.in_mathzone } + ), + s( + { trig = "abs", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\abs{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "deg", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("\\degree", {}), + { condition = tex.in_mathzone } + ), + s({ trig = "pr", wordTrig = false, snippetType = "autosnippet" }, fmta("\\Pr", {}), { condition = tex.in_mathzone }), + s({ trig = "sch", snippetType = "autosnippet" }, { + t("\\Sch"), + }, { condition = tex.in_mathzone }), + s({ trig = "\\Pii", snippetType = "autosnippet", priority = 2000 }, { + t("P_i"), + }, { condition = tex.in_mathzone }), +} diff --git a/LuaSnip/tex/matrix.lua b/LuaSnip/tex/matrix.lua new file mode 100644 index 0000000..c10e327 --- /dev/null +++ b/LuaSnip/tex/matrix.lua @@ -0,0 +1,137 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin + +local tex = require("util.latex") + +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, i(1, parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + s( + { trig = "bmat", snippetType = "autosnippet" }, + fmta( + [[ + \begin{bmatrix} + <> + \end{bmatrix} + ]], + { + i(0), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "Bmat", snippetType = "autosnippet" }, + fmta( + [[ + \begin{Bmatrix} + <> + \end{Bmatrix} + ]], + { + i(0), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "pmat", snippetType = "autosnippet" }, + fmta( + [[ + \begin{pmatrix} + <> + \end{pmatrix} + ]], + { + i(0), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "Vmat", snippetType = "autosnippet" }, + fmta( + [[ + \begin{Vmatrix} + <> + \end{Vmatrix} + ]], + { + i(0), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "Bmat", snippetType = "autosnippet" }, + fmta( + [[ + \Bmat{<>} + ]], + { + i(0), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "dmat", snippetType = "autosnippet" }, + fmta( + [[ + \bdiagmat{<>} + ]], + { + i(0), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "vmat", snippetType = "autosnippet" }, + fmta( + [[ + \vmat{<>} + ]], + { + i(0), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "Vmat", snippetType = "autosnippet" }, + fmta( + [[ + \Vmat{<>} + ]], + { + i(0), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "pma(%a)", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("\\pmat<>{<>}", { + f(function(_, snip) + return snip.captures[1] + end), + i(0), + }), + { condition = tex.in_mathzone } + ), +} diff --git a/LuaSnip/tex/physics.lua b/LuaSnip/tex/physics.lua new file mode 100644 index 0000000..bf7f6ff --- /dev/null +++ b/LuaSnip/tex/physics.lua @@ -0,0 +1,305 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin + +local tex = require("util.latex") + +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, t(parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + -- -- s( + -- -- { trig = "qb", snippetType = "autosnippet", priority = 2000 }, + -- -- fmta("\\qty(<>)", { + -- -- d(1, get_visual), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "qb", snippetType = "autosnippet" }, + -- -- fmta("\\qty(<>)", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "qB", snippetType = "autosnippet", priority = 2000 }, + -- -- fmta("\\qty{<>}", { + -- -- d(1, get_visual), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "qB", snippetType = "autosnippet" }, + -- -- fmta("\\qty{<>}", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "qp", snippetType = "autosnippet", priority = 2000 }, + -- -- fmta("\\qty[<>]", { + -- -- d(1, get_visual), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "qp", snippetType = "autosnippet" }, + -- -- fmta("\\qty[<>]", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "mb", snippetType = "autosnippet" }, + -- -- fmta("\\mqty(<>)", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "mB", snippetType = "autosnippet" }, + -- -- fmta("\\mqty{<>}", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "mp", snippetType = "autosnippet" }, + -- -- fmta("\\mqty[<>]", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "im", snippetType = "autosnippet" }, + -- -- fmta("\\imat{<>}", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "xm", snippetType = "autosnippet" }, + -- -- fmta("\\xmat{<>}{<>}{<>}", { + -- -- i(1), + -- -- i(2), + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "zm", snippetType = "autosnippet" }, + -- -- fmta("\\zmat{<>}{<>}", { + -- -- i(1), + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "pmat", snippetType = "autosnippet" }, + -- -- fmta("\\pmat{<>}", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "dm", snippetType = "autosnippet" }, + -- -- fmta("\\dmat{<>}", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "adm", snippetType = "autosnippet" }, + -- -- fmta("\\admat{<>}", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "comm", snippetType = "autosnippet" }, + -- -- fmta("\\comm{<>}{<>}", { + -- -- i(1), + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "acom", snippetType = "autosnippet" }, + -- -- fmta("\\acomm{<>}{<>}", { + -- -- i(1), + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "ket", snippetType = "autosnippet", priority = 2000 }, + -- -- fmta("\\ket{<>}", { + -- -- d(1, get_visual), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "ket", snippetType = "autosnippet" }, + -- -- fmta("\\ket{<>}", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "bra", snippetType = "autosnippet", priority = 2000 }, + -- -- fmta("\\bra{<>}", { + -- -- d(1, get_visual), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "bra", snippetType = "autosnippet" }, + -- -- fmta("\\bra{<>}", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "norm", snippetType = "autosnippet", priority = 2000 }, + -- -- fmta("\\norm{<>}", { + -- -- d(1, get_visual), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "norm", snippetType = "autosnippet" }, + -- -- fmta("\\norm{<>}", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "abs", snippetType = "autosnippet", priority = 2000 }, + -- -- fmta("\\abs{<>}", { + -- -- d(1, get_visual), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "abs", snippetType = "autosnippet" }, + -- -- fmta("\\abs*{<>}", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "vu", snippetType = "autosnippet" }, + -- -- fmta("\\vu{<>}", { + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "bk", snippetType = "autosnippet" }, + -- -- fmta("\\ip{<>}{<>}", { + -- -- i(1), + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "kb", snippetType = "autosnippet" }, + -- -- fmta("\\op{<>}{<>}", { + -- -- i(1), + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- s( + -- { trig = "ev", snippetType = "autosnippet" }, + -- fmta("\\ev{<>}", { + -- i(0), + -- }), + -- { condition = tex.in_mathzone } + -- ), + -- s( + -- { trig = "mev", snippetType = "autosnippet" }, + -- fmta("\\ev{<>}{<>}", { + -- i(1), + -- i(0), + -- }), + -- { condition = tex.in_mathzone } + -- ), + -- s( + -- { trig = "mel", snippetType = "autosnippet" }, + -- fmta("\\mel{<>}{<>}{<>}", { + -- i(1), + -- i(2), + -- i(0), + -- }), + -- { condition = tex.in_mathzone } + -- ), + -- s( + -- { trig = "mdet", snippetType = "autosnippet" }, + -- fmta("\\mdet{<>}", { + -- i(0), + -- }), + -- { condition = tex.in_mathzone } + -- ), + -- s( + -- { trig = "ord", wordTrig = false, snippetType = "autosnippet" }, + -- fmta("\\order{<>}", { + -- i(0), + -- }), + -- { condition = tex.in_mathzone } + -- ), + -- s( + -- { trig = "qif", wordTrig = false, snippetType = "autosnippet" }, + -- fmta("\\qif", {}), + -- { condition = tex.in_mathzone } + -- ), + -- s( + -- { trig = "qq", wordTrig = false, snippetType = "autosnippet" }, + -- fmta("\\qq{<>}", { + -- i(0), + -- }), + -- { condition = tex.in_mathzone } + -- ), + -- s( + -- { trig = "qor", wordTrig = false, snippetType = "autosnippet" }, + -- fmta("\\qor", {}), + -- { condition = tex.in_mathzone } + -- ), + -- s( + -- { trig = "qif", wordTrig = false, snippetType = "autosnippet" }, + -- fmta("\\qif", {}), + -- { condition = tex.in_mathzone } + -- ), + -- -- s( + -- -- { trig = "dv", wordTrig = false, snippetType = "autosnippet" }, + -- -- fmta("\\dv[<>]{<>}{<>}", { + -- -- i(1), + -- -- i(2), + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- -- s( + -- -- { trig = "pv", wordTrig = false, snippetType = "autosnippet" }, + -- -- fmta("\\pdv{<>}{<>}", { + -- -- i(1), + -- -- i(0), + -- -- }), + -- -- { condition = tex.in_mathzone } + -- -- ), + -- s({ trig = "tr", wordTrig = false, snippetType = "autosnippet" }, fmta("\\tr", {}), { condition = tex.in_mathzone }), +} diff --git a/LuaSnip/tex/physics2.lua b/LuaSnip/tex/physics2.lua new file mode 100644 index 0000000..f27a16c --- /dev/null +++ b/LuaSnip/tex/physics2.lua @@ -0,0 +1,104 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin + +local tex = require("util.latex") + +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, t(parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + s( + { trig = "bra", wordTrig = false, snippetType = "autosnippet", priority = 1000 }, + fmta("\\bra{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "ket", wordTrig = false, snippetType = "autosnippet", priority = 1000 }, + fmta("\\ket{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "bk", snippetType = "autosnippet" }, + c(1, { + sn(nil, { t("\\braket{"), i(1), t("}{"), i(2), t("}") }), + sn(nil, { t("\\braket[3]{"), i(1), t("}{"), i(2), t("}{"), i(3), t("}") }), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "ev", snippetType = "autosnippet" }, + fmta("\\braket[1]{<>}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "kb", snippetType = "autosnippet" }, + c(1, { + sn(nil, { t("\\ketbra{"), i(1), t("}{"), i(2), t("}") }), + sn(nil, { t("\\ketbra{"), i(1), t("}["), i(2), t("]{"), i(3), t("}") }), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "pab", wordTrig = false, snippetType = "autosnippet", priority = 1000 }, + fmta("\\ab( <> )", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "Bab", wordTrig = false, snippetType = "autosnippet", priority = 1000 }, + fmta("\\ab\\{ <> \\}", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "bab", wordTrig = false, snippetType = "autosnippet", priority = 1000 }, + fmta("\\ab[ <> ]", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "\\forallb", wordTrig = false, snippetType = "autosnippet", priority = 1000 }, + fmta("\\ab<< <> >>", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "vab", wordTrig = false, snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\ab|"), i(1), t("|") }), sn(nil, { t("\\ab*|"), i(1), t("|") }) }), + { condition = tex.in_mathzone } + ), + s( + { trig = "norm", wordTrig = false, snippetType = "autosnippet", priority = 1000 }, + fmta("\\| <> \\|", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s({ trig = "\\tof", snippetType = "autosnippet" }, { + t("\\Tof"), + }, { condition = tex.in_mathzone }), +} diff --git a/LuaSnip/tex/py.lua b/LuaSnip/tex/py.lua new file mode 100644 index 0000000..5b071b9 --- /dev/null +++ b/LuaSnip/tex/py.lua @@ -0,0 +1,297 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin +local tex = require("util.latex") +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, t(parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + s( + { trig = "sym", wordTrig = false, snippetType = "autosnippet" }, + fmta("sympy <> sympy", { + i(0), + }), + { condition = tex.in_mathzone } + ), + s( + { trig = "sym", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, + fmta("sympy <> sympy", { + d(1, get_visual), + }), + { condition = tex.in_mathzone } + ), + s( -- This one evaluates anything inside the simpy block + { trig = "sympy.*sympys", regTrig = true, desc = "Sympy block evaluator", snippetType = "autosnippet" }, + d(1, function(_, parent) + local to_eval = string.gsub(parent.trigger, "^sympy(.*)sympys", "%1") + to_eval = string.gsub(to_eval, "^%s+(.*)%s+$", "%1") + + local Job = require("plenary.job") + + local sympy_script = string.format( + [[ +from latex2sympy2 import latex2latex +import re +origin = r'%s' +# remove white space +standard = re.sub(r"\\d", "d", origin) +latex = latex2latex(standard) +output = origin + " = " + latex +print(output) + ]], + to_eval + ) + + sympy_script = string.gsub(sympy_script, "^[\t%s]+", "") + local result = "" + + Job:new({ + command = "python3", + args = { + "-c", + sympy_script, + }, + on_exit = function(j) + result = j:result() + end, + }):sync() + + return sn(nil, t(result)) + end) + ), + s( -- This one evaluates anything inside the simpy block + { trig = "sympy.*sympy ", regTrig = true, desc = "Sympy block evaluator", snippetType = "autosnippet" }, + d(1, function(_, parent) + -- Gets the part of the block we actually want, and replaces spaces + -- at the beginning and at the end + local to_eval = string.gsub(parent.trigger, "^sympy(.*)sympy", "%1") + to_eval = string.gsub(to_eval, "^%s+(.*)%s+$", "%1") + local pattern = { "\\ab" } + local repl = { "" } + for i = 1, #pattern do + to_eval = string.gsub(to_eval, pattern[i], repl[i]) + end + + local Job = require("plenary.job") + + local sympy_script = string.format( + [[ +from sympy import * +from latex2sympy2 import latex2sympy, latex2latex +import re +origin = r'%s' +origin = re.sub(r"\\d", "d", origin) +latex = latex2latex(origin) +print(latex) + ]], + to_eval + ) + + sympy_script = string.gsub(sympy_script, "^[\t%s]+", "") + local result = "" + + Job:new({ + command = "python3", + args = { + "-c", + sympy_script, + }, + on_exit = function(j) + result = j:result() + end, + }):sync() + + return sn(nil, t(result)) + end) + ), + s( + { trig = "qcircuit", wordTrig = false }, + fmta("QCircuit <> QCircuit", { + i(1), + }), + { condition = tex.in_text } + ), + s( + { trig = "qcircuit", wordTrig = false, priority = 2000 }, + fmta("QCircuit <> QCircuit", { + d(1, get_visual), + }), + { condition = tex.in_text } + ), + s( -- This one evaluates anything inside the simpy block + { trig = "QCircuit.*QCircuit ", regTrig = true, desc = "QCircuit block evaluator", snippetType = "autosnippet" }, + d(1, function(_, parent) + -- Gets the part of the block we actually want, and replaces spaces + -- at the beginning and at the end + local to_eval = string.gsub(parent.trigger, "^QCircuit(.*)QCircuit ", "%1") + to_eval = string.gsub(to_eval, "^%s+(.*)%s+$", "%1") + + -- Replace lash with rash for to_evil + local pattern = { + "ts", + "I_?(%d)", + "C(%w)", + "dagger", + "\\ket{0}", + "\\ket{1}", + "\\ket{%+}", + "\\ket{%-}", + "\\ket{%+i}", + "\\ket{i}", + "\\ket{%-i}", + "\\bra{0}", + "\\bra{1}", + "\\bra{%+}", + "\\bra{%-}", + "\\bra{%+i}", + "\\bra{i}", + "\\bra{%-i}", + } + local repl = { + "TensorProduct", + "eye(%1)", + "controlled_gate_12(%1)", + ".conjugate().transpose()", + "ket0", + "ket1", + "ketp", + "ketm", + "ketpi", + "ketpi", + "ketmi", + "bra0", + "bra1", + "brap", + "bram", + "brapi", + "brapi", + "brami", + } + for i = 1, #pattern do + to_eval = string.gsub(to_eval, pattern[i], repl[i]) + end + print(to_eval) + + local Job = require("plenary.job") + + local sympy_script = string.format( + [[ +from sympy import * +from sympy.physics.quantum import * +def controlled_gate_12(gate): + return TensorProduct(Matrix([ [1, 0], [0, 0] ]), eye(2))+TensorProduct(Matrix([ [0, 0], [0, 1] ]), gate) +def controlled_gate_21(gate): + return TensorProduct(eye(2), Matrix([ [1, 0], [0, 0] ]))+TensorProduct(gate, Matrix([ [0, 0], [0, 1] ])) +H = Matrix([ [1, 1], [1, -1] ]) / sqrt(2) +X = Matrix([ [0, 1], [1, 0] ]) +Y = Matrix([ [0, -I], [I, 0] ]) +Z = Matrix([ [1, 0], [0, -1] ]) +e1 = Matrix([ [1], [0], [0], [0] ]) +e2 = Matrix([ [0], [1], [0], [0] ]) +e3 = Matrix([ [0], [0], [1], [0] ]) +e4 = Matrix([ [0], [0], [0], [1] ]) +ket0 = Matrix([ [1], [0] ]) +ket1 = Matrix([ [0], [1] ]) +ketp = Matrix([ [1], [1] ]) / sqrt(2) +ketm = Matrix([ [1], [-1] ]) / sqrt(2) +ketpi = Matrix([ [1], [I] ]) / sqrt(2) +ketmi = Matrix([ [1], [-I] ]) / sqrt(2) +bra0 = Matrix([ [1, 0] ]) +bra1 = Matrix([ [0, 1] ]) +brap = Matrix([ [1, 1] ]) / sqrt(2) +bram = Matrix([ [1, -1] ]) / sqrt(2) +brapi = Matrix([ [1, -I] ]) / sqrt(2) +brami = Matrix([ [1, I] ]) / sqrt(2) +out00 = e1*e1.transpose() +out01 = e2*e2.transpose() +out10 = e3*e3.transpose() +out11 = e4*e4.transpose() +%s +output = latex(res) +print(output) + ]], + to_eval + ) + + sympy_script = string.gsub(sympy_script, "^[\t%s]+", "") + local result = "" + + Job:new({ + command = "python3", + args = { + "-c", + sympy_script, + }, + on_exit = function(j) + result = j:result() + end, + }):sync() + + return sn(nil, t(result)) + end) + ), + s( + { trig = "exd", wordTrig = false, snippetType = "autosnippet" }, + fmta("expand <> expand", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s( -- This one evaluates anything inside the simpy block + { trig = "expand.*expand ", regTrig = true, desc = "expand block evaluator", snippetType = "autosnippet" }, + d(1, function(_, parent) + -- Gets the part of the block we actually want, and replaces spaces + -- at the beginning and at the end + local to_eval = string.gsub(parent.trigger, "^expand(.*)expand ", "%1") + to_eval = string.gsub(to_eval, "^%s+(.*)%s+$", "%1") + local pattern = { "\\ab" } + local repl = { "" } + for i = 1, #pattern do + to_eval = string.gsub(to_eval, pattern[i], repl[i]) + end + + local Job = require("plenary.job") + + local sympy_script = string.format( + [[ +from sympy import * +from latex2sympy2 import latex2sympy, latex2latex +x, y = symbols('x y') +theta = symbols('theta') +origin = r'%s' +expand = latex2sympy(origin).expand() +print(latex(expand)) + ]], + to_eval + ) + + sympy_script = string.gsub(sympy_script, "^[\t%s]+", "") + local result = "" + + Job:new({ + command = "python3", + args = { + "-c", + sympy_script, + }, + on_exit = function(j) + result = j:result() + end, + }):sync() + + return sn(nil, t(result)) + end) + ), +} diff --git a/LuaSnip/tex/quantikz.lua b/LuaSnip/tex/quantikz.lua new file mode 100644 index 0000000..3f47412 --- /dev/null +++ b/LuaSnip/tex/quantikz.lua @@ -0,0 +1,301 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local c = ls.choice_node +local d = ls.dynamic_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin + +local tex = require("util.latex") + +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, t(parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + s( + { trig = "bqu", snippetType = "autosnippet" }, + fmta( + [[ + \begin{quantikz} + & <> + \end{quantikz} + ]], + { + i(0), + } + ), + { condition = tex.in_text } + ), + s( + { trig = "cl", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\ctrl{"), i(1), t("}") }), sn(nil, { t("\\ctrl["), i(1), t("]{"), i(2), t("}") }) }), + { condition = tex.in_quantikz } + ), + s( + { trig = "ocl", snippetType = "autosnippet", priority = 2000 }, + c(1, { sn(nil, { t("\\octrl{"), i(1), t("}") }), sn(nil, { t("\\octrl["), i(1), t("]{"), i(2), t("}") }) }), + { condition = tex.in_quantikz } + ), + s( + { trig = "tar", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\targ{"), i(1), t("}") }), sn(nil, { t("\\targX{"), i(1), t("}") }) }), + { condition = tex.in_quantikz } + ), + s( + { trig = "gate", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\gate{"), i(1), t("}") }), sn(nil, { t("\\gate["), i(1), t("]{"), i(2), t("}") }) }), + { condition = tex.in_quantikz } + ), + s( + { trig = "g(%a)", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("\\gate{<>}", { + f(function(_, snip) + return snip.captures[1] + end), + }), + { condition = tex.in_quantikz } + ), + s( + { trig = "wire", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\wire["), i(1), t("]{"), i(2), t("}") }), sn(nil, { t("\\wire{"), i(1), t("}") }) }), + { condition = tex.in_quantikz } + ), + s( + { trig = "mt", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\meter{"), i(1), t("}") }), sn(nil, { t("\\meter["), i(1), t("]{"), i(2), t("}") }) }), + { condition = tex.in_quantikz } + ), + s( + { trig = "phase", snippetType = "autosnippet" }, + fmta("\\phase{<>}", { + i(0), + }), + { condition = tex.in_quantikz } + ), + s( + { trig = "swap", snippetType = "autosnippet" }, + fmta("\\swap{<>}", { + i(0), + }), + { condition = tex.in_quantikz } + ), + s( + { trig = "ls", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\lstick{"), i(1), t("}") }), sn(nil, { t("\\lstick["), i(1), t("]{"), i(2), t("}") }) }), + { condition = tex.in_quantikz } + ), + s( + { trig = "rs", snippetType = "autosnippet" }, + c(1, { sn(nil, { t("\\rstick{"), i(1), t("}") }), sn(nil, { t("\\rstick["), i(1), t("]{"), i(2), t("}") }) }), + { condition = tex.in_quantikz } + ), + s( + { trig = "group", snippetType = "autosnippet" }, + fmta("\\gategroup[<>,steps=<>]{<>}", { + i(1), + i(2), + i(0), + }), + { condition = tex.in_quantikz } + ), + s( + { trig = "slice", snippetType = "autosnippet" }, + fmta("\\slice{<>}", { + i(0), + }), + { condition = tex.in_quantikz } + ), + s( + { trig = "push", snippetType = "autosnippet" }, + fmta("\\push{<>}", { + i(0), + }), + { condition = tex.in_quantikz } + ), + s( + { trig = "ms", snippetType = "autosnippet" }, + c(1, { + sn(nil, { t("\\measure{"), i(1), t("}") }), + sn(nil, { t("\\measuretab{"), i(1), t("}") }), + }), + { condition = tex.in_quantikz } + ), + s( + { trig = "ket", snippetType = "autosnippet" }, + fmta("\\ket{<>}", { + i(0), + }), + { condition = tex.in_quantikz } + ), + s( + { trig = "bra", snippetType = "autosnippet" }, + fmta("\\bra{<>}", { + i(0), + }), + { condition = tex.in_quantikz } + ), + s({ trig = "alp", snippetType = "autosnippet", wordTrig = false }, { + t("\\alpha"), + }, { condition = tex.in_quantikz }), + s({ trig = "Alp", snippetType = "autosnippet", wordTrig = false }, { + t("\\Alpha"), + }, { condition = tex.in_quantikz }), + s({ trig = "beta", snippetType = "autosnippet", wordTrig = false }, { + t("\\beta"), + }, { condition = tex.in_quantikz }), + s({ trig = "Beta", snippetType = "autosnippet", wordTrig = false }, { + t("\\Beta"), + }, { condition = tex.in_quantikz }), + s({ trig = "gam", snippetType = "autosnippet", wordTrig = false }, { + t("\\gamma"), + }, { condition = tex.in_quantikz }), + s({ trig = "Gam", snippetType = "autosnippet", wordTrig = false }, { + t("\\Gamma"), + }, { condition = tex.in_quantikz }), + s({ trig = "del", snippetType = "autosnippet", wordTrig = false }, { + t("\\delta"), + }, { condition = tex.in_quantikz }), + s({ trig = "Del", snippetType = "autosnippet", wordTrig = false }, { + t("\\Delta"), + }, { condition = tex.in_quantikz }), + s({ trig = "eps", snippetType = "autosnippet", wordTrig = false }, { + t("\\epsilon"), + }, { condition = tex.in_quantikz }), + s({ trig = "vps", snippetType = "autosnippet", wordTrig = false }, { + t("\\varepsilon"), + }, { condition = tex.in_quantikz }), + s({ trig = "Eps", snippetType = "autosnippet", wordTrig = false }, { + t("\\Epsilon"), + }, { condition = tex.in_quantikz }), + s({ trig = "zeta", snippetType = "autosnippet", wordTrig = false }, { + t("\\zeta"), + }, { condition = tex.in_quantikz }), + s({ trig = "Zeta", snippetType = "autosnippet", wordTrig = false }, { + t("\\Zeta"), + }, { condition = tex.in_quantikz }), + s({ trig = "eta", snippetType = "autosnippet", wordTrig = false }, { + t("\\eta"), + }, { condition = tex.in_quantikz }), + s({ trig = "Eta", snippetType = "autosnippet", wordTrig = false }, { + t("\\Eta"), + }, { condition = tex.in_quantikz }), + s({ trig = "the", snippetType = "autosnippet", wordTrig = false }, { + t("\\theta"), + }, { condition = tex.in_quantikz }), + s({ trig = "The", snippetType = "autosnippet", wordTrig = false }, { + t("\\Theta"), + }, { condition = tex.in_quantikz }), + s({ trig = "iot", snippetType = "autosnippet", wordTrig = false }, { + t("\\iota"), + }, { condition = tex.in_quantikz }), + s({ trig = "Iot", snippetType = "autosnippet", wordTrig = false }, { + t("\\Iota"), + }, { condition = tex.in_quantikz }), + s({ trig = "kap", snippetType = "autosnippet", wordTrig = false }, { + t("\\kappa"), + }, { condition = tex.in_quantikz }), + s({ trig = "Kap", snippetType = "autosnippet", wordTrig = false }, { + t("\\Kappa"), + }, { condition = tex.in_quantikz }), + s({ trig = "lam", snippetType = "autosnippet", wordTrig = false }, { + t("\\lambda"), + }, { condition = tex.in_quantikz }), + s({ trig = "Lam", snippetType = "autosnippet", wordTrig = false }, { + t("\\Lambda"), + }, { condition = tex.in_quantikz }), + s({ trig = "mu", snippetType = "autosnippet", wordTrig = false }, { + t("\\mu"), + }, { condition = tex.in_quantikz }), + s({ trig = "Mu", snippetType = "autosnippet", wordTrig = false }, { + t("\\Mu"), + }, { condition = tex.in_quantikz }), + s({ trig = "nu", snippetType = "autosnippet", wordTrig = false }, { + t("\\nu"), + }, { condition = tex.in_quantikz }), + s({ trig = "Nu", snippetType = "autosnippet", wordTrig = false }, { + t("\\Nu"), + }, { condition = tex.in_quantikz }), + -- s({ trig = "xi", snippetType = "autosnippet", wordTrig = false }, { + -- t("\\xi"), + -- }, { condition = tex.in_quantikz }), + -- s({ trig = "Xi", snippetType = "autosnippet", wordTrig = false }, { + -- t("\\Xi"), + -- }, { condition = tex.in_quantikz }), + s({ trig = "omi", snippetType = "autosnippet", wordTrig = false }, { + t("\\omicron"), + }, { condition = tex.in_quantikz }), + s({ trig = "pi", snippetType = "autosnippet", wordTrig = false }, { + t("\\pi"), + }, { condition = tex.in_quantikz }), + s({ trig = "\\pii", snippetType = "autosnippet", wordTrig = false, priority = 2000 }, { + t("p_i"), + }, { condition = tex.in_quantikz }), + s({ trig = "Pi", snippetType = "autosnippet", wordTrig = false }, { + t("\\Pi"), + }, { condition = tex.in_quantikz }), + s({ trig = "rho", snippetType = "autosnippet", wordTrig = false }, { + t("\\rho"), + }, { condition = tex.in_quantikz }), + s({ trig = "Rho", snippetType = "autosnippet", wordTrig = false }, { + t("\\Rho"), + }, { condition = tex.in_quantikz }), + s({ trig = "sig", snippetType = "autosnippet", wordTrig = false }, { + t("\\sigma"), + }, { condition = tex.in_quantikz }), + s({ trig = "Sig", snippetType = "autosnippet", wordTrig = false }, { + t("\\Sigma"), + }, { condition = tex.in_quantikz }), + s({ trig = "tau", snippetType = "autosnippet", wordTrig = false }, { + t("\\tau"), + }, { condition = tex.in_quantikz }), + s({ trig = "Tau", snippetType = "autosnippet", wordTrig = false }, { + t("\\Tau"), + }, { condition = tex.in_quantikz }), + s({ trig = "ups", snippetType = "autosnippet", wordTrig = false }, { + t("\\ups"), + }, { condition = tex.in_quantikz }), + s({ trig = "Ups", snippetType = "autosnippet", wordTrig = false }, { + t("\\Ups"), + }, { condition = tex.in_quantikz }), + s({ trig = "phi", snippetType = "autosnippet", wordTrig = false }, { + t("\\phi"), + }, { condition = tex.in_quantikz }), + s({ trig = "Phi", snippetType = "autosnippet", wordTrig = false }, { + t("\\Phi"), + }, { condition = tex.in_quantikz }), + s({ trig = "vhi", snippetType = "autosnippet", wordTrig = false }, { + t("\\varphi"), + }, { condition = tex.in_quantikz }), + s({ trig = "Vhi", snippetType = "autosnippet", wordTrig = false }, { + t("\\Varphi"), + }, { condition = tex.in_quantikz }), + s({ trig = "chi", snippetType = "autosnippet", wordTrig = false }, { + t("\\chi"), + }, { condition = tex.in_quantikz }), + s({ trig = "Chi", snippetType = "autosnippet", wordTrig = false }, { + t("\\Chi"), + }, { condition = tex.in_quantikz }), + s({ trig = "psi", snippetType = "autosnippet", wordTrig = false }, { + t("\\psi"), + }, { condition = tex.in_quantikz }), + s({ trig = "Psi", snippetType = "autosnippet", wordTrig = false }, { + t("\\Psi"), + }, { condition = tex.in_quantikz }), + s({ trig = "ome", snippetType = "autosnippet", wordTrig = false }, { + t("\\omega"), + }, { condition = tex.in_quantikz }), + s({ trig = "Ome", snippetType = "autosnippet", wordTrig = false }, { + t("\\Omega"), + }, { condition = tex.in_quantikz }), +} + diff --git a/LuaSnip/tex/symbol-short.lua b/LuaSnip/tex/symbol-short.lua new file mode 100644 index 0000000..4240d84 --- /dev/null +++ b/LuaSnip/tex/symbol-short.lua @@ -0,0 +1,266 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin + +local tex = require("util.latex") + +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, i(1, parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + s({ trig = "...", wordTrig = false, snippetType = "autosnippet" }, { + t("\\dots"), + }, { condition = tex.in_mathzone }), + s({ trig = "c.", wordTrig = false, snippetType = "autosnippet" }, { + t("\\cdot"), + }, { condition = tex.in_mathzone }), + s({ trig = "\\cdot.", wordTrig = false, snippetType = "autosnippet" }, { + t("\\cdots"), + }, { condition = tex.in_mathzone }), + s({ trig = "v.", wordTrig = false, snippetType = "autosnippet" }, { + t("\\vdot"), + }, { condition = tex.in_mathzone }), + s({ trig = "\\vdot.", wordTrig = false, snippetType = "autosnippet" }, { + t("\\vdots"), + }, { condition = tex.in_mathzone }), + s({ trig = "d.", wordTrig = false, snippetType = "autosnippet" }, { + t("\\ddot"), + }, { condition = tex.in_mathzone }), + s({ trig = "\\ddot.", wordTrig = false, snippetType = "autosnippet" }, { + t("\\ddots"), + }, { condition = tex.in_mathzone }), + s({ trig = "iff", wordTrig = false, snippetType = "autosnippet" }, { + t("\\iff"), + }, { condition = tex.in_mathzone }), + s({ trig = "inn", wordTrig = false, snippetType = "autosnippet" }, { + t("\\in"), + }, { condition = tex.in_mathzone }), + s({ trig = "notin", wordTrig = false, snippetType = "autosnippet" }, { + t("not\\in"), + }, { condition = tex.in_mathzone }), + s({ trig = "aa", wordTrig = false, snippetType = "autosnippet" }, { + t("\\forall"), + }, { condition = tex.in_mathzone }), + s({ trig = "ee", wordTrig = false, snippetType = "autosnippet" }, { + t("\\exists"), + }, { condition = tex.in_mathzone }), + s({ trig = "!=", wordTrig = false, snippetType = "autosnippet" }, { + t("\\neq"), + }, { condition = tex.in_mathzone }), + s({ trig = "==", wordTrig = false, snippetType = "autosnippet" }, { + t("&="), + }, { condition = tex.in_mathzone }), + s({ trig = "\\leq=", wordTrig = false, snippetType = "autosnippet" }, { + t("&\\leq"), + }, { condition = tex.in_mathzone }), + s({ trig = "\\geq=", wordTrig = false, snippetType = "autosnippet" }, { + t("&\\geq"), + }, { condition = tex.in_mathzone }), + s({ trig = "~=", wordTrig = false, snippetType = "autosnippet" }, { + t("\\approx"), + }, { condition = tex.in_mathzone }), + s({ trig = "~~", wordTrig = false, snippetType = "autosnippet" }, { + t("\\sim"), + }, { condition = tex.in_mathzone }), + s({ trig = ">=", wordTrig = false, snippetType = "autosnippet" }, { + t("\\geq"), + }, { condition = tex.in_mathzone }), + s({ trig = "<=", wordTrig = false, snippetType = "autosnippet" }, { + t("\\leq"), + }, { condition = tex.in_mathzone }), + s({ trig = ">>", wordTrig = false, snippetType = "autosnippet" }, { + t("\\gg"), + }, { condition = tex.in_mathzone }), + s({ trig = "<<", wordTrig = false, snippetType = "autosnippet" }, { + t("\\ll"), + }, { condition = tex.in_mathzone }), + s({ trig = "cp", wordTrig = false, snippetType = "autosnippet" }, { + t("\\cp"), + }, { condition = tex.in_mathzone }), + s({ trig = "get", wordTrig = false, snippetType = "autosnippet" }, { + t("\\gets"), + }, { condition = tex.in_mathzone }), + s({ trig = "to", wordTrig = false, snippetType = "autosnippet" }, { + t("\\to"), + }, { condition = tex.in_mathzone }), + s({ trig = "\\>", wordTrig = false, snippetType = "autosnippet", priority = 1001 }, { + t("\\mapsto"), + }, { condition = tex.in_mathzone }), + s({ trig = "\\\\\\", wordTrig = false, snippetType = "autosnippet" }, { + t("\\setminus"), + }, { condition = tex.in_mathzone }), + s({ trig = "||", wordTrig = false, snippetType = "autosnippet" }, { + t("\\mid"), + }, { condition = tex.in_mathzone }), + s({ trig = "mid", wordTrig = false, snippetType = "autosnippet" }, { + t("\\mid"), + }, { condition = tex.in_mathzone }), + s({ trig = "nmid", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, { + t("\\nmid"), + }, { condition = tex.in_mathzone }), + s({ trig = "sr", wordTrig = false, snippetType = "autosnippet" }, { + t("^2"), + }, { condition = tex.in_mathzone }), + s({ trig = "cb", wordTrig = false, snippetType = "autosnippet" }, { + t("^3"), + }, { condition = tex.in_mathzone }), + s({ trig = "inv", wordTrig = false, snippetType = "autosnippet" }, { + t("^{-1}"), + }, { condition = tex.in_mathzone }), + s({ trig = "**", wordTrig = false, snippetType = "autosnippet" }, { + t("^*"), + }, { condition = tex.in_mathzone }), + s({ trig = " ", wordTrig = false, snippetType = "autosnippet" }, { + t("\\,"), + }, { condition = tex.in_mathzone }), + s({ trig = "<>", wordTrig = false, snippetType = "autosnippet" }, { + t("\\diamond"), + }, { condition = tex.in_mathzone }), + s({ trig = "+-", wordTrig = false, snippetType = "autosnippet" }, { + t("\\pm"), + }, { condition = tex.in_mathzone }), + s({ trig = "-+", wordTrig = false, snippetType = "autosnippet" }, { + t("\\mp"), + }, { condition = tex.in_mathzone }), + s({ trig = "rhs", wordTrig = false, snippetType = "autosnippet" }, { + t("\\mathrm{R.H.S}"), + }, { condition = tex.in_mathzone }), + s({ trig = "lhs", wordTrig = false, snippetType = "autosnippet" }, { + t("\\mathrm{L.H.S}"), + }, { condition = tex.in_mathzone }), + s({ trig = "cap", wordTrig = false, snippetType = "autosnippet" }, { + t("\\cap"), + }, { condition = tex.in_mathzone }), + s({ trig = "cup", wordTrig = false, snippetType = "autosnippet" }, { + t("\\cup"), + }, { condition = tex.in_mathzone }), + s({ trig = "sub", wordTrig = false, snippetType = "autosnippet" }, { + t("\\subseteq"), + }, { condition = tex.in_mathzone }), + -- s({ trig = "sup", wordTrig = false, snippetType = "autosnippet" }, { + -- t("\\supseteq"), + -- }, { condition = tex.in_mathzone }), + s({ trig = "oo", wordTrig = false, snippetType = "autosnippet" }, { + t("\\infty"), + }, { condition = tex.in_mathzone }), + s({ trig = "tp", wordTrig = false, snippetType = "autosnippet" }, { + t("^\\top"), + }, { condition = tex.in_mathzone }), + s({ trig = "dr", wordTrig = false, snippetType = "autosnippet" }, { + t("^\\dagger"), + }, { condition = tex.in_mathzone }), + s({ trig = "perp", wordTrig = false, snippetType = "autosnippet" }, { + t("^\\perp"), + }, { condition = tex.in_mathzone }), + s({ trig = "ss", wordTrig = false, snippetType = "autosnippet" }, { + t("\\star"), + }, { condition = tex.in_mathzone }), + s({ trig = "xx", wordTrig = false, snippetType = "autosnippet" }, { + t("\\times"), + }, { condition = tex.in_mathzone }), + s({ trig = "=>", wordTrig = false, snippetType = "autosnippet" }, { + t("\\implies"), + }, { condition = tex.in_mathzone }), + s({ trig = "=<", wordTrig = false, snippetType = "autosnippet" }, { + t("\\impliedby"), + }, { condition = tex.in_mathzone }), + s({ trig = "llr", wordTrig = false, snippetType = "autosnippet" }, { + t("\\longleftrightarrow"), + }, { condition = tex.in_mathzone }), + s({ trig = "up", wordTrig = false, snippetType = "autosnippet" }, { + t("\\uparrow"), + }, { condition = tex.in_mathzone }), + s({ trig = "cir", wordTrig = false, snippetType = "autosnippet" }, { + t("\\circ"), + }, { condition = tex.in_mathzone }), + s({ trig = "iso", wordTrig = false, snippetType = "autosnippet" }, { + t("\\cong"), + }, { condition = tex.in_mathzone }), + s({ trig = "ihbar", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, { + t("i\\hbar"), + }, { condition = tex.in_mathzone }), + s({ trig = "hbar", wordTrig = false, snippetType = "autosnippet" }, { + t("\\hbar"), + }, { condition = tex.in_mathzone }), + s({ trig = "ns", wordTrig = false, snippetType = "autosnippet" }, { + t("\\unlhd"), + }, { condition = tex.in_mathzone }), + s({ trig = "eqv", wordTrig = false, snippetType = "autosnippet" }, { + t("\\equiv"), + }, { condition = tex.in_mathzone }), + s({ trig = "##", wordTrig = false, snippetType = "autosnippet" }, { + t("\\#"), + }, { condition = tex.in_mathzone }), + s({ trig = "ell", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, { + t("\\ell"), + }, { condition = tex.in_mathzone }), + s({ trig = "ot", wordTrig = false, snippetType = "autosnippet" }, { + t("\\otimes"), + }, { condition = tex.in_mathzone }), + s({ trig = "op", wordTrig = false, snippetType = "autosnippet" }, { + t("\\oplus"), + }, { condition = tex.in_mathzone }), + s({ trig = "od", wordTrig = false, snippetType = "autosnippet" }, { + t("\\odot"), + }, { condition = tex.in_mathzone }), + s({ trig = "not", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, { + t("\\not"), + }, { condition = tex.in_mathzone }), + s({ trig = "par", wordTrig = false, snippetType = "autosnippet", priority = 2000 }, { + t("\\partial"), + }, { condition = tex.in_mathzone }), + s({ trig = "land", snippetType = "autosnippet" }, { + t("\\land"), + }, { condition = tex.in_mathzone }), + s({ trig = "lor", snippetType = "autosnippet" }, { + t("\\lor"), + }, { condition = tex.in_mathzone }), + s({ trig = "\\tri", snippetType = "autosnippet" }, { + t("\\triangle"), + }, { condition = tex.in_mathzone }), + s({ trig = "emp", snippetType = "autosnippet", priority = 2000 }, { + t("\\emptyset"), + }, { condition = tex.in_mathzone }), + -- s({ trig = "po", snippetType = "autosnippet" }, { + -- t("\\propto"), + -- }, { condition = tex.in_mathzone }), + s({ trig = "neg", snippetType = "autosnippet" }, { + t("\\neg"), + }, { condition = tex.in_mathzone }), + s({ trig = "nabla", snippetType = "autosnippet" }, { + t("\\nabla"), + }, { condition = tex.in_mathzone }), + s( + { trig = "jo", wordTrig = false, snippetType = "autosnippet" }, + fmta( + [[ + _{<>} + ]], + { i(1) } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "kj", wordTrig = false, snippetType = "autosnippet" }, + fmta( + [[ + ^{<>} + ]], + { i(1) } + ), + { condition = tex.in_mathzone } + ), +} diff --git a/LuaSnip/tex/temporary.lua b/LuaSnip/tex/temporary.lua new file mode 100644 index 0000000..8a4ddaf --- /dev/null +++ b/LuaSnip/tex/temporary.lua @@ -0,0 +1,96 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local i = ls.insert_node +local f = ls.function_node +local d = ls.dynamic_node +local fmt = require("luasnip.extras.fmt").fmt +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin + +local tex = require("util.latex") + +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, i(1, parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + -- s({ trig = "sp", snippetType = "autosnippet" }, fmta("\\hat{\\$}", {}), { condition = tex.in_mathzone }), + -- s({ trig = "T", snippetType = "autosnippet" }, fmta("\\mathcal{T}", {}), { condition = tex.in_mathzone }), + -- s({ trig = "tv", snippetType = "autosnippet" }, fmta("\\mathrm{TV}", {}), { condition = tex.in_mathzone }), + -- s({ trig = "ce", snippetType = "autosnippet" }, fmta("\\mathrm{couple}", {}), { condition = tex.in_mathzone }), + -- s({ trig = "mix", snippetType = "autosnippet" }, fmta("\\mathrm{mix}", {}), { condition = tex.in_mathzone }), + s({ trig = "\\psii", snippetType = "autosnippet", priority = 3000 }, { + t("\\psi_i"), + }, { condition = tex.in_mathzone }), + s({ trig = "FF", snippetType = "autosnippet", priority = 3000 }, { + t("\\mathcal{F}"), + }, { condition = tex.in_mathzone }), + s({ trig = "SS", snippetType = "autosnippet", priority = 3000 }, { + t("\\mathcal{S}"), + }, { condition = tex.in_mathzone }), + s( + { trig = "EE", snippetType = "autosnippet" }, + fmta("\\E_{\\sigma} \\ab[ <> ]", { + i(1), + }), + { condition = tex.in_mathzone } + ), + s({ trig = "\\varphii", snippetType = "autosnippet", priority = 3000 }, { + t("\\varphi_i"), + }, { condition = tex.in_mathzone }), + s({ trig = "cc", snippetType = "autosnippet" }, { + t("^c"), + }, { condition = tex.in_mathzone }), + s({ trig = "--", snippetType = "autosnippet", priority = 2000 }, { + t("^-"), + }, { condition = tex.in_mathzone }), + s({ trig = "\\oplust", snippetType = "autosnippet", priority = 2000 }, { + t("\\OPT"), + }, { condition = tex.in_mathzone }), + s({ trig = "++", snippetType = "autosnippet" }, { + t("^+"), + }, { condition = tex.in_mathzone }), + s({ trig = "ii", snippetType = "autosnippet" }, { + t("\\int"), + }, { condition = tex.in_mathzone }), + s({ trig = "ed", snippetType = "autosnippet" }, { + t("\\ed"), + }, { condition = tex.in_mathzone }), + -- s({ trig = "cas", snippetType = "autosnippet", priority = 2000 }, { + -- t("\\cas"), + -- }, { condition = tex.in_mathzone }), + s({ trig = "lr", snippetType = "autosnippet" }, { + t("\\leftrightarrow"), + }, { condition = tex.in_mathzone }), + s({ trig = "sa", snippetType = "autosnippet" }, { + t("s_A"), + }, { condition = tex.in_mathzone }), + s({ trig = "sb", snippetType = "autosnippet" }, { + t("s_B"), + }, { condition = tex.in_mathzone }), + s( + { trig = "(%a);", regTrig = true, wordTrig = false, snippetType = "autosnippet" }, + fmta("\\hat{<>}", { + f(function(_, snip) + return snip.captures[1] + end), + }), + { condition = tex.in_mathzone } + ), + s({ trig = "\\psi;", snippetType = "autosnippet", priority = 3000 }, { + t("\\tilde{\\psi}"), + }, { condition = tex.in_mathzone }), + s({ trig = "\\varphi;", snippetType = "autosnippet", priority = 3000 }, { + t("\\tilde{\\varphi}"), + }, { condition = tex.in_mathzone }), + s({ trig = "IS", snippetType = "autosnippet", priority = 3000 }, { + t("\\mathcal{IS}"), + }, { condition = tex.in_mathzone }), +} diff --git a/LuaSnip/tex/text.lua b/LuaSnip/tex/text.lua new file mode 100644 index 0000000..023c779 --- /dev/null +++ b/LuaSnip/tex/text.lua @@ -0,0 +1,256 @@ +local ls = require("luasnip") +local c = ls.choice_node +local s = ls.snippet +local t = ls.text_node +local i = ls.insert_node +local fmta = require("luasnip.extras.fmt").fmta +local tex = require("util.latex") +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin + +return { + s( + { trig = "DeclareMathOperator" }, + fmta("\\DeclareMathOperator{\\<>}{<>}", { + i(1), + rep(1), + }), + { condition = tex.in_mathzone } + ), + s({ trig = "dps", snippetType = "autosnippet" }, { + t("\\displaystyle"), + }, { condition = tex.in_mathzone }), + -- s({ trig = "if", snippetType = "autosnippet" }, { + -- t("\\text{\\ if\\ }"), + -- }, { condition = tex.in_mathzone }), + s({ trig = "stt", snippetType = "autosnippet" }, { + t("\\quad\\text{s.t.}\\quad"), + }, { condition = tex.in_mathzone }), + s({ trig = "as", snippetType = "autosnippet" }, { + t("\\text{\\ as\\ }"), + }, { condition = tex.in_mathzone }), + s({ trig = "or", snippetType = "autosnippet" }, { t("\\text{\\ or\\ }") }, { condition = tex.in_mathzone }), + s({ trig = "otherwise", snippetType = "autosnippet" }, { + t("\\text{\\ otherwise\\ }"), + }, { condition = tex.in_mathzone }), + s({ trig = "then", snippetType = "autosnippet" }, { + t("\\text{\\ then\\ }"), + }, { condition = tex.in_mathzone }), + s({ trig = "since", snippetType = "autosnippet" }, { + t("\\text{\\ since\\ }"), + }, { condition = tex.in_mathzone }), + s({ trig = "by", snippetType = "autosnippet" }, { + t("\\text{\\ by\\ }"), + }, { condition = tex.in_mathzone }), + s({ trig = "and", snippetType = "autosnippet" }, { + t("\\text{\\ and\\ }"), + }, { condition = tex.in_mathzone }), + s({ trig = "qd", snippetType = "autosnippet" }, { + t("\\quad"), + }, { condition = tex.in_mathzone }), + s( + { trig = "setc", snippetType = "autosnippet" }, + fmta("\\setcounter{<>}{<>}", { + c(1, { t("exer"), t("theorem") }), + i(2), + }), + { condition = tex.in_text } + ), + s( + { trig = "PP", snippetType = "autosnippet" }, + fmta("\\section*{Problem <>}", { i(1) }), + { condition = tex.in_text } + ), + + -- s({ trig = "label", snippetType = "autosnippet" }, { + -- t("\\label{"), + -- i(0), + -- t("}"), + -- }, { condition = tex.in_text, show_condition = tex.in_text }), + s( + { trig = "href", snippetType = "autosnippet" }, + fmta("\\href{<>}{<>}", { + i(1), + i(2), + }), + { condition = tex.in_text } + ), + + s({ trig = "wlog", snippetType = "autosnippet" }, { + t("without loss of generality"), + }, { condition = tex.in_text }), + s({ trig = "Wlog", snippetType = "autosnippet" }, { + t("Without loss of generality"), + }, { condition = tex.in_text }), + s({ trig = "%%", snippetType = "autosnippet" }, { + t("\\%"), + }, { condition = tex.in_text }), + s({ trig = "&&", snippetType = "autosnippet" }, { + t("\\&"), + }, { condition = tex.in_text }), + s({ trig = "##", snippetType = "autosnippet" }, { + t("\\#"), + }, { condition = tex.in_text }), + s({ trig = "thm", snippetType = "autosnippet" }, { + t("theorem"), + }, { condition = tex.in_text }), + s({ trig = "propp", snippetType = "autosnippet" }, { + t("proposition"), + }, { condition = tex.in_text }), + s({ trig = "deff", snippetType = "autosnippet" }, { + t("definition"), + }, { condition = tex.in_text }), + s({ trig = "exaa", snippetType = "autosnippet" }, { + t("example"), + }, { condition = tex.in_text }), + s({ trig = "iee", snippetType = "autosnippet" }, { + t("i.e."), + }, { condition = tex.in_text }), + s({ trig = "stt", snippetType = "autosnippet" }, { + t("such that"), + }, { condition = tex.in_text }), + s({ trig = "iff", snippetType = "autosnippet" }, { + t("if and only if"), + }, { condition = tex.in_text }), + s({ trig = "iso" }, { + t("isomorphic"), + }, { condition = tex.in_text }), + s({ trig = "iso" }, { + t("isomorphism"), + }, { condition = tex.in_text }), + s({ trig = "homo" }, { + t("homomorphism"), + }, { condition = tex.in_text }), + s({ trig = "homo" }, { + t("homomorphic"), + }, { condition = tex.in_text }), + -- s({ trig = "psp", snippetType = "autosnippet" }, { + -- t("\\(p\\)-subgroup"), + -- }, { condition = tex.in_text }), + -- s({ trig = "pgp", snippetType = "autosnippet" }, { + -- t("\\(p\\)-subgroup"), + -- }, { condition = tex.in_text }), + -- s({ trig = "spsp", snippetType = "autosnippet" }, { + -- t("Sylow \\(p\\)-subgroup"), + -- }, { condition = tex.in_text }), + s({ trig = "=>", snippetType = "autosnippet" }, { + t("\\(\\implies\\)"), + }, { condition = tex.in_text }), + s( + { trig = "homework" }, + fmta( + [[ + \documentclass{article} + \newcommand{\Class}{<>} + \newcommand{\Title}{Homework <>} + \author{Hanyu Yan} + \input{~/Documents/Latex/Package_elegantbook.tex} + \input{~/Documents/Latex/Sample_Homework.tex} + \begin{document} + \maketitle \thispagestyle{empty} + + <> + + \end{document} + ]], + { + c(1, { + t("Numerical Analysis"), + t("Experimental Quantum Information Processing"), + t("Quantum Communication and Cryptography"), + }), + i(2, "number"), + i(0), + } + ), + { condition = tex.in_text * line_begin } + ), + s( + { trig = "note" }, + fmta( + [[ + \documentclass[letterpaper, 12pt]{article} + \input{~/Documents/Latex/note_template.tex} + \begin{document} + \title{<> \\[1em] + \normalsize <>} + \author{\normalsize Fireond} + \date{\normalsize\vspace{-1ex} Last updated: \today} + \maketitle + \tableofcontents\label{sec:contents} + + <> + + \end{document} + ]], + { + i(1, "title"), + i(2, "subtitle"), + i(0), + } + ), + { condition = tex.in_text * line_begin } + ), + s( + { trig = "algo" }, + fmta( + [[ + \documentclass[utf8]{article} + \usepackage{amsmath,amssymb} + \usepackage{graphicx} + \usepackage{fullpage} + \usepackage{setspace} + \usepackage{verbatim} + \usepackage{algorithm} + \usepackage{algpseudocodex} + \algrenewcommand\algorithmicrequire{\textbf{Input:}} + \algrenewcommand\algorithmicensure{\textbf{Output:}} + \input{~/Documents/Latex/Package_elegantbook.tex} + + \onehalfspacing + + \title{\bf\huge Algorithm Design - Assignment <>} + \author{Hanyu Yan\\2022010860\\Class 23} + \date{\today} + + \begin{document} + \maketitle + + <> + + \end{document} + ]], + { i(1), i(0) } + ), + { condition = tex.in_text * line_begin } + ), + s( + { trig = "report" }, + fmta( + [[ + %! TeX program = xelatex + \documentclass{article} + \newcommand{\Class}{<>} + \newcommand{\Title}{<>} + \author{严涵宇} + \usepackage[UTF8]{ctex} + \input{~/Documents/Latex/Package_elegantbook.tex} + \input{~/Documents/Latex/Sample_Homework.tex} + \begin{document} + \maketitle \thispagestyle{empty} + + <> + + \end{document} + ]], + { + c(1, { + t("量子信息实验报告"), + }), + i(2), + i(0), + } + ), + { condition = tex.in_text * line_begin } + ), +} diff --git a/LuaSnip/tex/tikz.lua b/LuaSnip/tex/tikz.lua new file mode 100644 index 0000000..2fedabe --- /dev/null +++ b/LuaSnip/tex/tikz.lua @@ -0,0 +1,178 @@ +local ls = require("luasnip") +local s = ls.snippet +local sn = ls.snippet_node +local t = ls.text_node +local f = ls.function_node +local i = ls.insert_node +local d = ls.dynamic_node +local fmta = require("luasnip.extras.fmt").fmta +local rep = require("luasnip.extras").rep +local line_begin = require("luasnip.extras.expand_conditions").line_begin +local tex = require("util.latex") + +local get_visual = function(args, parent) + if #parent.snippet.env.SELECT_RAW > 0 then + return sn(nil, t(parent.snippet.env.SELECT_RAW)) + else -- If SELECT_RAW is empty, return a blank insert node + return sn(nil, i(1)) + end +end + +return { + s({ trig = "vsp", snippetType = "autosnippet" }, { + t("\\vspace{\\baselineskip}"), + }), + s( + { trig = "bti", snippetType = "autosnippet" }, + fmta( + [[ + \begin{tikzpicture}<> + <> + \end{tikzpicture} + ]], + { + c(1, { t("[overlay,remember picture,>=stealth,nodes={align=left,inner ysep=1pt},<-]"), t("") }), + i(0), + } + ), + { condition = line_begin } + ), + s( + { trig = "tm", snippetType = "autosnippet" }, + fmta( + [[ + \tikzmarknode{<>}{<>} + ]], + { + i(1, "markname"), + i(0), + } + ), + { condition = tex.in_tikz } + ), + s( + { trig = "tm", snippetType = "autosnippet", priority = 2000 }, + fmta( + [[ + \tikzmarknode{<>}{<>} + ]], + { + i(1, "markname"), + d(2, get_visual), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "lu", snippetType = "autosnippet", dscr = "Left up annotate" }, + fmta( + [[ + \path (<>.north) ++ (0,1em) node[anchor=south east,color=<>!67] (<>_node){<>}; + \draw [color=<>!57](<>.north) |- ([xshift=-0.3ex,color=<>]<>_node.south west); + ]], + { + i(1, "markname"), + i(2, "color"), + rep(1), + i(3, "text"), + rep(2), + rep(1), + rep(2), + rep(1), + } + ), + { condition = tex.in_tikz } + ), + s( + { trig = "rd", snippetType = "autosnippet", dscr = "Right down annotate" }, + fmta( + [[ + \path (<>.south) ++ (0,-0.8em) node[anchor=north west,color=<>!67] (<>_node){<>}; + \draw [color=<>!57](<>.south) |- ([xshift=-0.3ex,color=<>]<>_node.south east); + ]], + { + i(1, "markname"), + i(2, "color"), + rep(1), + i(3, "text"), + rep(2), + rep(1), + rep(2), + rep(1), + } + ), + { condition = tex.in_tikz } + ), + s( + { trig = "ld", snippetType = "autosnippet", dscr = "Left down annotate" }, + fmta( + [[ + \path (<>.south) ++ (0,-0.8em) node[anchor=north east,color=<>!67] (<>_node){<>}; + \draw [color=<>!57](<>.south) |- ([xshift=-0.3ex,color=<>]<>_node.south west); + ]], + { + i(1, "markname"), + i(2, "color"), + rep(1), + i(3, "text"), + rep(2), + rep(1), + rep(2), + rep(1), + } + ), + { condition = tex.in_tikz } + ), + s( + { trig = "hl", snippetType = "autosnippet" }, + fmta( + [[ + \hlmath{<>}{<>} + ]], + { + i(1, "red"), + i(2), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "hl", snippetType = "autosnippet", priority = 2000 }, + fmta( + [[ + \hlmath{<>}{<>} + ]], + { + i(1, "red"), + d(2, get_visual), + } + ), + { condition = tex.in_mathzone } + ), + s( + { trig = "hl", snippetType = "autosnippet" }, + fmta( + [[ + \hltext{<>}{<>} + ]], + { + i(1, "red"), + i(2), + } + ), + { condition = tex.in_text } + ), + s( + { trig = "hl", snippetType = "autosnippet", priority = 2000 }, + fmta( + [[ + \hltext{<>}{<>} + ]], + { + i(1, "red"), + d(2, get_visual), + } + ), + { condition = tex.in_text } + ), +} diff --git a/README.md b/README.md new file mode 100644 index 0000000..185280b --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +# 💤 LazyVim + +A starter template for [LazyVim](https://github.com/LazyVim/LazyVim). +Refer to the [documentation](https://lazyvim.github.io/installation) to get started. diff --git a/init.lua b/init.lua new file mode 100644 index 0000000..2514f9e --- /dev/null +++ b/init.lua @@ -0,0 +1,2 @@ +-- bootstrap lazy.nvim, LazyVim and your plugins +require("config.lazy") diff --git a/lazy-lock.json b/lazy-lock.json new file mode 100644 index 0000000..8f60042 --- /dev/null +++ b/lazy-lock.json @@ -0,0 +1,70 @@ +{ + "LazyVim": { "branch": "main", "commit": "25abbf546d564dc484cf903804661ba12de45507" }, + "LuaSnip": { "branch": "master", "commit": "c1851d5c519611dfc451b6582961b2602e0af89b" }, + "SchemaStore.nvim": { "branch": "main", "commit": "df87d16fc4ea7c2c67cfc00b513861738693fe07" }, + "aerial.nvim": { "branch": "master", "commit": "2e00d1d4248f08dddfceacb8d2996e51e13e00f6" }, + "avante.nvim": { "branch": "main", "commit": "f755861d939df35b9d28ca3eb667af798750747f" }, + "blink-cmp-copilot": { "branch": "main", "commit": "439cff78780c033aa23cf061d7315314b347e3c1" }, + "blink.cmp": { "branch": "main", "commit": "4f38ce99a472932d5776337f08f7a8180f1f571a" }, + "bufferline.nvim": { "branch": "main", "commit": "655133c3b4c3e5e05ec549b9f8cc2894ac6f51b3" }, + "catppuccin": { "branch": "main", "commit": "1bf070129c0b6f77cc23f6a2212dcdc868308c52" }, + "chezmoi.nvim": { "branch": "main", "commit": "838378806cac89ded93a4a27be32e98e066c0d2e" }, + "chezmoi.vim": { "branch": "main", "commit": "abf37336437867cbd99ce2f8849b717415391cc3" }, + "clangd_extensions.nvim": { "branch": "main", "commit": "db28f29be928d18cbfb86fbfb9f83f584f658feb" }, + "cmake-tools.nvim": { "branch": "master", "commit": "1ee065c33ca777c0e03cd7c358010202ee70bb88" }, + "code_runner.nvim": { "branch": "main", "commit": "4f694af54ff29834a6e0b2aaf1ed5e8809708c6d" }, + "competitest.nvim": { "branch": "master", "commit": "c9be46ff8f0649987459b21006215bc5be20a95b" }, + "conform.nvim": { "branch": "master", "commit": "374aaf384e2e841607b8e2fe63fa3ad01d111c91" }, + "copilot.lua": { "branch": "master", "commit": "2fe34db04570f6c47db0b752ca421a49b7357c03" }, + "dial.nvim": { "branch": "master", "commit": "2c7e2750372918f072a20f3cf754d845e143d7c9" }, + "flash.nvim": { "branch": "main", "commit": "3c942666f115e2811e959eabbdd361a025db8b63" }, + "friendly-snippets": { "branch": "main", "commit": "efff286dd74c22f731cdec26a70b46e5b203c619" }, + "gitsigns.nvim": { "branch": "main", "commit": "43b0c856ae5f32a195d83f4a27fe21d63e6c966c" }, + "grug-far.nvim": { "branch": "main", "commit": "5ddfc2e9d1967084162c2c77e7036a43029abf78" }, + "inc-rename.nvim": { "branch": "main", "commit": "2eaff20526ff6101337b84f4b0d238c11f47d7f4" }, + "lazy.nvim": { "branch": "main", "commit": "6c3bda4aca61a13a9c63f1c1d1b16b9d3be90d7a" }, + "lazydev.nvim": { "branch": "main", "commit": "2367a6c0a01eb9edb0464731cc0fb61ed9ab9d2c" }, + "lean.nvim": { "branch": "main", "commit": "a9beb8c8d366362063088dad5c348f8848442f47" }, + "lualine.nvim": { "branch": "master", "commit": "15884cee63a8c205334ab13ab1c891cd4d27101a" }, + "markdown-preview.nvim": { "branch": "master", "commit": "a923f5fc5ba36a3b17e289dc35dc17f66d0548ee" }, + "mason-lspconfig.nvim": { "branch": "main", "commit": "1a31f824b9cd5bc6f342fc29e9a53b60d74af245" }, + "mason-nvim-dap.nvim": { "branch": "main", "commit": "4c2cdc69d69fe00c15ae8648f7e954d99e5de3ea" }, + "mason.nvim": { "branch": "main", "commit": "fc98833b6da5de5a9c5b1446ac541577059555be" }, + "mini.ai": { "branch": "main", "commit": "e139eb1101beb0250fea322f8c07a42f0f175688" }, + "mini.hipatterns": { "branch": "main", "commit": "e5083df391171dc9d8172645606f8496d9443374" }, + "mini.icons": { "branch": "main", "commit": "397ed3807e96b59709ef3292f0a3e253d5c1dc0a" }, + "mini.pairs": { "branch": "main", "commit": "69864a2efb36c030877421634487fd90db1e4298" }, + "mini.surround": { "branch": "main", "commit": "5aab42fcdcf31fa010f012771eda5631c077840a" }, + "neo-tree.nvim": { "branch": "main", "commit": "56f383aa157f1ff20a59154907cc5f9fe26e4db9" }, + "neotest": { "branch": "master", "commit": "862afb2a2219d9ca565f67416fb7003cc0f22c4f" }, + "neotest-python": { "branch": "master", "commit": "a2861ab3c9a0bf75a56b11835c2bfc8270f5be7e" }, + "noice.nvim": { "branch": "main", "commit": "0427460c2d7f673ad60eb02b35f5e9926cf67c59" }, + "nui.nvim": { "branch": "main", "commit": "f535005e6ad1016383f24e39559833759453564e" }, + "nvim-conda": { "branch": "main", "commit": "7e63124d98f48a3bb255eaa71d1602db610b9047" }, + "nvim-dap": { "branch": "master", "commit": "8df427aeba0a06c6577dc3ab82de3076964e3b8d" }, + "nvim-dap-python": { "branch": "master", "commit": "261ce649d05bc455a29f9636dc03f8cdaa7e0e2c" }, + "nvim-dap-ui": { "branch": "master", "commit": "73a26abf4941aa27da59820fd6b028ebcdbcf932" }, + "nvim-dap-virtual-text": { "branch": "master", "commit": "df66808cd78b5a97576bbaeee95ed5ca385a9750" }, + "nvim-lint": { "branch": "master", "commit": "9dfb77ef6c5092a19502883c02dc5a02ec648729" }, + "nvim-lspconfig": { "branch": "master", "commit": "61e5109c8cf24807e4ae29813a3a82b31821dd45" }, + "nvim-nio": { "branch": "master", "commit": "21f5324bfac14e22ba26553caf69ec76ae8a7662" }, + "nvim-snippets": { "branch": "main", "commit": "56b4052f71220144689caaa2e5b66222ba5661eb" }, + "nvim-treesitter": { "branch": "master", "commit": "066fd6505377e3fd4aa219e61ce94c2b8bdb0b79" }, + "nvim-treesitter-textobjects": { "branch": "master", "commit": "e10df91b312c86af6d7ea9b0d525a3f5762b5dec" }, + "nvim-ts-autotag": { "branch": "main", "commit": "a1d526af391f6aebb25a8795cbc05351ed3620b5" }, + "overseer.nvim": { "branch": "master", "commit": "72c68aab0358c92f451168b704c411c4a3e3410e" }, + "persistence.nvim": { "branch": "main", "commit": "166a79a55bfa7a4db3e26fc031b4d92af71d0b51" }, + "plenary.nvim": { "branch": "master", "commit": "857c5ac632080dba10aae49dba902ce3abf91b35" }, + "project.nvim": { "branch": "main", "commit": "8c6bad7d22eef1b71144b401c9f74ed01526a4fb" }, + "render-markdown.nvim": { "branch": "main", "commit": "a1b0988f5ab26698afb56b9c2f0525a4de1195c1" }, + "snacks.nvim": { "branch": "main", "commit": "bc0630e43be5699bb94dadc302c0d21615421d93" }, + "todo-comments.nvim": { "branch": "main", "commit": "304a8d204ee787d2544d8bc23cd38d2f929e7cc5" }, + "tokyonight.nvim": { "branch": "main", "commit": "057ef5d260c1931f1dffd0f052c685dcd14100a3" }, + "trouble.nvim": { "branch": "main", "commit": "85bedb7eb7fa331a2ccbecb9202d8abba64d37b3" }, + "ts-comments.nvim": { "branch": "main", "commit": "1bd9d0ba1d8b336c3db50692ffd0955fe1bb9f0c" }, + "vim-startuptime": { "branch": "master", "commit": "b6f0d93f6b8cf6eee0b4c94450198ba2d6a05ff6" }, + "vimtex": { "branch": "master", "commit": "7d16d56c765476f3101b2daa2a09f8ab82df9c5d" }, + "which-key.nvim": { "branch": "main", "commit": "370ec46f710e058c9c1646273e6b225acf47cbed" }, + "yanky.nvim": { "branch": "main", "commit": "04775cc6e10ef038c397c407bc17f00a2f52b378" }, + "yazi.nvim": { "branch": "main", "commit": "82873628a2b78dce48b5bcf8d1d8ed14f0ee985f" } +} diff --git a/lazyvim.json b/lazyvim.json new file mode 100644 index 0000000..8aecc14 --- /dev/null +++ b/lazyvim.json @@ -0,0 +1,36 @@ +{ + "extras": [ + "lazyvim.plugins.extras.ai.copilot", + "lazyvim.plugins.extras.coding.blink", + "lazyvim.plugins.extras.coding.luasnip", + "lazyvim.plugins.extras.coding.mini-surround", + "lazyvim.plugins.extras.coding.nvim-cmp", + "lazyvim.plugins.extras.coding.yanky", + "lazyvim.plugins.extras.dap.core", + "lazyvim.plugins.extras.editor.aerial", + "lazyvim.plugins.extras.editor.dial", + "lazyvim.plugins.extras.editor.inc-rename", + "lazyvim.plugins.extras.editor.overseer", + "lazyvim.plugins.extras.editor.snacks_picker", + "lazyvim.plugins.extras.formatting.black", + "lazyvim.plugins.extras.lang.clangd", + "lazyvim.plugins.extras.lang.json", + "lazyvim.plugins.extras.lang.lean", + "lazyvim.plugins.extras.lang.markdown", + "lazyvim.plugins.extras.lang.python", + "lazyvim.plugins.extras.lang.tex", + "lazyvim.plugins.extras.lang.toml", + "lazyvim.plugins.extras.lang.yaml", + "lazyvim.plugins.extras.test.core", + "lazyvim.plugins.extras.util.chezmoi", + "lazyvim.plugins.extras.util.dot", + "lazyvim.plugins.extras.util.mini-hipatterns", + "lazyvim.plugins.extras.util.project", + "lazyvim.plugins.extras.util.startuptime" + ], + "install_version": 8, + "news": { + "NEWS.md": "10960" + }, + "version": 8 +} \ No newline at end of file diff --git a/lua/config/autocmds.lua b/lua/config/autocmds.lua new file mode 100644 index 0000000..0cc0bb3 --- /dev/null +++ b/lua/config/autocmds.lua @@ -0,0 +1,7 @@ +-- Autocmds are automatically loaded on the VeryLazy event +-- Default autocmds that are always set: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/config/autocmds.lua +-- Add any additional autocmds here + +if vim.g.neovide then + vim.cmd([[ cd $HOME ]]) +end diff --git a/lua/config/keymaps.lua b/lua/config/keymaps.lua new file mode 100644 index 0000000..df7022f --- /dev/null +++ b/lua/config/keymaps.lua @@ -0,0 +1,11 @@ +-- Keymaps are automatically loaded on the VeryLazy event +-- Default keymaps that are always set: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/config/keymaps.lua +-- Add any additional keymaps here + +local map = LazyVim.safe_keymap_set + +map({ "i" }, "jk", "") + +-- movement +map({ "n", "v", "o" }, "H", "^", { desc = "Use 'H' as '^'" }) +map({ "n", "v", "o" }, "L", "$", { desc = "Use 'L' as '$'" }) diff --git a/lua/config/lazy.lua b/lua/config/lazy.lua new file mode 100644 index 0000000..d169d34 --- /dev/null +++ b/lua/config/lazy.lua @@ -0,0 +1,52 @@ +local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim" + +if not (vim.uv or vim.loop).fs_stat(lazypath) then + -- bootstrap lazy.nvim + -- stylua: ignore + vim.fn.system({ "git", "clone", "--filter=blob:none", "https://github.com/folke/lazy.nvim.git", "--branch=stable", lazypath }) +end +vim.opt.rtp:prepend(vim.env.LAZY or lazypath) + +require("lazy").setup({ + spec = { + -- add LazyVim and import its plugins + { "LazyVim/LazyVim", import = "lazyvim.plugins" }, + -- import any extras modules here + -- { import = "lazyvim.plugins.extras.lang.typescript" }, + -- { import = "lazyvim.plugins.extras.lang.json" }, + -- { import = "lazyvim.plugins.extras.ui.mini-animate" }, + -- import/override with your plugins + { import = "plugins" }, + { import = "plugins.ui" }, + { import = "plugins.lang" }, + { import = "plugins.default" }, + }, + + defaults = { + -- By default, only LazyVim plugins will be lazy-loaded. Your custom plugins will load during startup. + -- If you know what you're doing, you can set this to `true` to have all your custom plugins lazy-loaded by default. + lazy = false, + -- It's recommended to leave version=false for now, since a lot the plugin that support versioning, + -- have outdated releases, which may break your Neovim install. + version = false, -- always use the latest git commit + -- version = "*", -- try installing the latest stable for plugins that support semver + }, + + install = { colorscheme = { "tokyonight", "habamax" } }, + checker = { enabled = true }, -- automatically check for plugin updates + performance = { + rtp = { + -- disable some rtp plugins + disabled_plugins = { + "gzip", + -- "matchit", + -- "matchparen", + -- "netrwPlugin", + "tarPlugin", + "tohtml", + "tutor", + "zipPlugin", + }, + }, + }, +}) diff --git a/lua/config/options.lua b/lua/config/options.lua new file mode 100644 index 0000000..41f9a63 --- /dev/null +++ b/lua/config/options.lua @@ -0,0 +1,33 @@ +-- Options are automatically loaded before lazy.nvim startup +-- Default options that are always set: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/config/options.lua +-- Add any additional options here + +vim.opt.timeoutlen = 150 +vim.opt.spell = true +vim.opt.spelllang = { "en", "cjk" } +vim.opt.spelloptions = "camel" +vim.opt.backup = false +vim.g.maplocalleader = "\\" +vim.g.autoformat = false + +vim.g.node_host_prog = "/opt/homebrew/bin/neovim-node-host" +local indent = 2 +-- vim.opt.expandtab = true -- Use spaces instead of tabs +vim.opt.softtabstop = indent -- Number of spaces that a counts for while performing editing operations +vim.opt.tabstop = indent -- Number of spaces tabs count for +vim.opt.shiftwidth = indent -- Size of an indent + +if vim.g.neovide then + vim.o.guifont = "Maple Mono:h16" + vim.g.neovide_scale_factor = 1.0 + vim.g.neovide_floating_corner_radius = 20.0 + vim.g.neovide_line_height = 1.5 + -- vim.g.transparency = 0.8 + -- vim.g.neovide_transparency = 0.9 + -- Allow clipboard copy paste in neovim + vim.g.neovide_input_use_logo = 1 + vim.api.nvim_set_keymap("", "", "+p", { noremap = true, silent = true }) + vim.api.nvim_set_keymap("!", "", "+", { noremap = true, silent = true }) + vim.api.nvim_set_keymap("t", "", "+", { noremap = true, silent = true }) + vim.api.nvim_set_keymap("v", "", "+", { noremap = true, silent = true }) +end diff --git a/lua/plugins/coderunner.lua b/lua/plugins/coderunner.lua new file mode 100644 index 0000000..2b9d139 --- /dev/null +++ b/lua/plugins/coderunner.lua @@ -0,0 +1,67 @@ +return { + { + "CRAG666/code_runner.nvim", + ft = { "lua", "python", "c", "cpp" }, + dependencies = { "nvim-lua/plenary.nvim" }, + keys = { + { "rr", "RunCode", desc = "Run Code" }, + -- { "rf", "RunFile", desc = "Run File" }, + -- { "rp", "RunProject", desc = "Run Project" }, + { "rd", "RunClose", desc = "Run Close" }, + }, + opts = { + -- choose default mode (valid term, tab, float, toggle, buf) + mode = "term", + -- Focus on runner window(only works on toggle, term and tab mode) + focus = false, + -- startinsert (see ':h inserting-ex') + startinsert = false, + term = { + -- Position to open the terminal, this option is ignored if mode is tab + position = "bot", + -- window size, this option is ignored if tab is true + size = 8, + }, + float = { + -- Key that close the code_runner floating window + close_key = "", + -- Window border (see ':h nvim_open_win') + border = "none", + + -- Num from `0 - 1` for measurements + height = 0.8, + width = 0.8, + x = 0.5, + y = 0.5, + + -- Highlight group for floating window/border (see ':h winhl') + border_hl = "FloatBorder", + float_hl = "Normal", + + -- Transparency (see ':h winblend') + blend = 0, + }, + filetype_path = "", -- No default path defined + filetype = { + javascript = "node", + java = "cd $dir && javac $fileName && java $fileNameWithoutExt", + c = "cd $dir && gcc $fileName -o $fileNameWithoutExt && $dir/$fileNameWithoutExt", + cpp = "cd $dir && g++ $fileName -o $fileNameWithoutExt && $dir/$fileNameWithoutExt", + python = "python -u", + sh = "bash", + rust = "cd $dir && rustc $fileName && $dir$fileNameWithoutExt", + }, + project_path = "", -- No default path defined + project = {}, + }, + -- config = { + -- filetype = { + -- python = "python3 -u", + -- }, + -- mode = "term", + -- float = { + -- close_key = "q", + -- }, + -- }, + }, +} diff --git a/lua/plugins/competitest.lua b/lua/plugins/competitest.lua new file mode 100644 index 0000000..41b5d12 --- /dev/null +++ b/lua/plugins/competitest.lua @@ -0,0 +1,28 @@ +return { + { + "xeluxee/competitest.nvim", + dependencies = "MunifTanjim/nui.nvim", + lazy = false, + keys = { + { "rt", "CompetiTest receive testcases", "Receive testcases" }, + { "rp", "CompetiTest receive problem", "Receive problem" }, + { "rc", "CompetiTest receive contest", "Receive contest" }, + { "c", "CompetiTest run", "Run code" }, + }, + config = function() + require("competitest").setup({ + received_problems_path = "$(HOME)/compcode/$(JUDGE)/$(CONTEST)/$(PROBLEM).$(FEXT)c", + received_contests_directory = "$(HOME)/compcode/$(JUDGE)/$(CONTEST)", + template_file = { + cpp = "~/compcode/templates/template.cpp", + }, + compile_command = { + cpp = { exec = "clang++", args = { "$(FNAME)", "-o", "$(FNOEXT)", "-lm" } }, + }, + run_command = { + cpp = { exec = "./$(FNOEXT)" }, + }, + }) + end, + }, +} diff --git a/lua/plugins/default/blink.lua b/lua/plugins/default/blink.lua new file mode 100644 index 0000000..db493a1 --- /dev/null +++ b/lua/plugins/default/blink.lua @@ -0,0 +1,20 @@ +return { + { + "saghen/blink.cmp", + version = "*", + opts = { + -- sources = { + -- compat = { "avante_commands", "avante_mentions", "avante_files" }, + -- }, + keymap = { + [""] = { "select_next", "fallback" }, + [""] = { "select_prev", "fallback" }, + }, + completion = { + menu = { border = "single" }, + documentation = { window = { border = "single" } }, + }, + signature = { window = { border = "single" } }, + }, + }, +} diff --git a/lua/plugins/default/conform.lua b/lua/plugins/default/conform.lua new file mode 100644 index 0000000..c4b4e20 --- /dev/null +++ b/lua/plugins/default/conform.lua @@ -0,0 +1,11 @@ +return { + "stevearc/conform.nvim", + opts = { + formatters_by_ft = { + ["json"] = { "jq" }, + ["jsonc"] = { "jq" }, + ["tex"] = { "latexindent" }, + ["toml"] = { "taplo "}, + } + } +} diff --git a/lua/plugins/default/copilot.lua b/lua/plugins/default/copilot.lua new file mode 100644 index 0000000..38d5d1c --- /dev/null +++ b/lua/plugins/default/copilot.lua @@ -0,0 +1,15 @@ +return { + -- { + -- "zbirenbaum/copilot.lua", + -- opts = { + -- copilot_model = "claude-3.7-sonnet", + -- suggestion = { + -- keymap = { + -- accept = "", + -- next = "", + -- prev = "", + -- }, + -- }, + -- }, + -- }, +} diff --git a/lua/plugins/default/lspconfig.lua b/lua/plugins/default/lspconfig.lua new file mode 100644 index 0000000..982b6fd --- /dev/null +++ b/lua/plugins/default/lspconfig.lua @@ -0,0 +1,24 @@ +return { + { + "neovim/nvim-lspconfig", + optional = true, + opts = { + servers = { + texlab = { + keys = { + { "K", "(vimtex-doc-package)", desc = "Vimtex Docs", silent = true }, + }, + settings = { + texlab = { + inlayHints = { + labelDefinitions = false, + labelReferences = false, + }, + diagnostics = { ignoredPatterns = { "^Overfull", "^Underfull" } }, + }, + }, + }, + }, + }, + }, +} diff --git a/lua/plugins/default/luasnip.lua b/lua/plugins/default/luasnip.lua new file mode 100644 index 0000000..f36981c --- /dev/null +++ b/lua/plugins/default/luasnip.lua @@ -0,0 +1,70 @@ +return { + { + "L3MON4D3/LuaSnip", + config = function() + require("luasnip").config.set_config({ + enable_autosnippets = true, + store_selection_keys = "`", + }) + require("luasnip.loaders.from_lua").load({ paths = "~/.config/nvim/LuaSnip" }) + local auto_expand = require("luasnip").expand_auto + require("luasnip").expand_auto = function(...) + vim.o.undolevels = vim.o.undolevels + auto_expand(...) + end + -- local types = require("luasnip.util.types") + -- require("luasnip").config.setup({ + -- ext_opts = { + -- [types.choiceNode] = { + -- active = { + -- virt_text = { { "●", "GruvboxOrange" } }, + -- }, + -- }, + -- [types.insertNode] = { + -- active = { + -- virt_text = { { "●", "GruvboxBlue" } }, + -- }, + -- }, + -- }, + -- }) + end, + keys = function() + return { + { + "fj", + function() + return require("luasnip").expand_or_locally_jumpable() and "luasnip-jump-next" + -- or ":call searchpair('[([{<|]', '', '[)\\]}>|]', 'W')a" + end, + expr = true, + silent = true, + mode = "i", + }, + { + "fj", + function() + return require("luasnip").jump(1) + end, + mode = "s", + }, + { + "fk", + function() + require("luasnip").jump(-1) + end, + mode = { "i", "s" }, + }, + { + "", + "luasnip-next-choice", + mode = { "i", "s" }, + }, + { + "", + "luasnip-prev-choice", + mode = { "i", "s" }, + }, + } + end, + }, +} diff --git a/lua/plugins/default/neotree.lua b/lua/plugins/default/neotree.lua new file mode 100644 index 0000000..b4e60c7 --- /dev/null +++ b/lua/plugins/default/neotree.lua @@ -0,0 +1,22 @@ +return { + { + "nvim-neo-tree/neo-tree.nvim", + lazy = true, + opts = { + filesystem = { + window = { + mappings = { + ["o"] = "system_open", + }, + }, + commands = { + system_open = function(state) + local node = state.tree:get_node() + local path = node:get_id() + vim.api.nvim_command("silent !open -g " .. path) + end, + }, + }, + }, + }, +} diff --git a/lua/plugins/default/tree-sitter.lua b/lua/plugins/default/tree-sitter.lua new file mode 100644 index 0000000..268563f --- /dev/null +++ b/lua/plugins/default/tree-sitter.lua @@ -0,0 +1,59 @@ +return { + { + "nvim-treesitter/nvim-treesitter", + opts = function() + return { + highlight = { + enable = true, + disable = { "latex" }, + additional_vim_regex_highlighting = { "latex", "markdown" }, + }, + indent = { enable = true, disable = { "python" } }, + context_commentstring = { enable = true, enable_autocmd = false }, + ensure_installed = { + "bash", + "c", + "cpp", + "html", + "json", + "lua", + "luap", + "markdown", + "make", + "markdown_inline", + "scala", + "python", + "query", + "toml", + "regex", + "vim", + "yaml", + }, + incremental_selection = { + enable = true, + keymaps = { + init_selection = "", + node_incremental = "", + scope_incremental = "\\", + node_decremental = "", + }, + }, + } + end, + rainbow = { + enable = true, + -- list of languages you want to disable the plugin for + disable = { "jsx", "cpp" }, + -- Which query to use for finding delimiters + query = "rainbow-parens", + -- Highlight the entire buffer all at once + }, + + keys = function() + return { + { "", desc = "Increment selection" }, + { "", desc = "Decrement selection", mode = "x" }, + } + end, + }, +} diff --git a/lua/plugins/default/treesitter.lua b/lua/plugins/default/treesitter.lua new file mode 100644 index 0000000..abeac3f --- /dev/null +++ b/lua/plugins/default/treesitter.lua @@ -0,0 +1,61 @@ +return { + { + "nvim-treesitter/nvim-treesitter", + opts = function() + return { + highlight = { + enable = true, + disable = { "latex" }, + -- additional_vim_regex_highlighting = { "markdown" }, + }, + -- ignore_install = { "latex" }, + indent = { enable = true, disable = { "python" } }, + context_commentstring = { enable = true, enable_autocmd = false }, + ensure_installed = { + "latex", + "bash", + "c", + "cpp", + "html", + "json", + "lua", + "luap", + "markdown", + "make", + "markdown_inline", + "scala", + "python", + "query", + "toml", + "regex", + "vim", + "yaml", + }, + incremental_selection = { + enable = true, + keymaps = { + init_selection = "", + node_incremental = "", + scope_incremental = "\\", + node_decremental = "", + }, + }, + } + end, + rainbow = { + enable = true, + -- list of languages you want to disable the plugin for + disable = { "jsx", "cpp" }, + -- Which query to use for finding delimiters + query = "rainbow-parens", + -- Highlight the entire buffer all at once + }, + + keys = function() + return { + { "", desc = "Increment selection" }, + { "", desc = "Decrement selection", mode = "x" }, + } + end, + }, +} diff --git a/lua/plugins/disabled.lua b/lua/plugins/disabled.lua new file mode 100644 index 0000000..8da29b9 --- /dev/null +++ b/lua/plugins/disabled.lua @@ -0,0 +1,6 @@ +return { + { + "rafamadriz/friendly-snippets", + enabled = false, + }, +} diff --git a/lua/plugins/lang/avante.lua b/lua/plugins/lang/avante.lua new file mode 100644 index 0000000..7490059 --- /dev/null +++ b/lua/plugins/lang/avante.lua @@ -0,0 +1,89 @@ +return { + { + "yetone/avante.nvim", + event = "VeryLazy", + enabled = false, + version = false, -- Never set this value to "*"! Never! + opts = { + -- add any opts here + -- for example + -- provider = "copilot", + -- copilot = { model = "claude-3.5-sonnet" }, + -- hints = { enabled = false }, + -- file_selector = { + -- provider = "snack", + -- provider_opts = {}, + -- }, + -- openai = { + -- endpoint = "https://api.openai.com/v1", + -- model = "gpt-4o", -- your desired model (or use gpt-4o, etc.) + -- timeout = 30000, -- Timeout in milliseconds, increase this for reasoning models + -- temperature = 0, + -- max_tokens = 8192, -- Increase this to include reasoning tokens (for reasoning models) + -- --reasoning_effort = "medium", -- low|medium|high, only used for reasoning models + -- }, + }, + -- if you want to build from source then do `make BUILD_FROM_SOURCE=true` + build = "make", + -- build = "powershell -ExecutionPolicy Bypass -File Build.ps1 -BuildFromSource false" -- for windows + dependencies = { + "nvim-treesitter/nvim-treesitter", + "stevearc/dressing.nvim", + "nvim-lua/plenary.nvim", + "MunifTanjim/nui.nvim", + --- The below dependencies are optional, + -- "echasnovski/mini.pick", -- for file_selector provider mini.pick + -- "nvim-telescope/telescope.nvim", -- for file_selector provider telescope + -- "hrsh7th/nvim-cmp", -- autocompletion for avante commands and mentions + -- "ibhagwan/fzf-lua", -- for file_selector provider fzf + -- "nvim-tree/nvim-web-devicons", -- or echasnovski/mini.icons + "zbirenbaum/copilot.lua", -- for providers='copilot' + { + -- support for image pasting + "HakonHarnes/img-clip.nvim", + event = "VeryLazy", + opts = { + -- recommended settings + default = { + embed_image_as_base64 = false, + prompt_for_file_name = false, + drag_and_drop = { + insert_mode = true, + }, + -- required for Windows users + use_absolute_path = true, + }, + }, + }, + { + -- Make sure to set this up properly if you have lazy=true + "MeanderingProgrammer/render-markdown.nvim", + opts = { + file_types = { "markdown", "Avante" }, + }, + ft = { "markdown", "Avante" }, + }, + { + "saghen/blink.compat", + lazy = true, + opts = {}, + config = function() + -- monkeypatch cmp.ConfirmBehavior for Avante + require("cmp").ConfirmBehavior = { + Insert = "insert", + Replace = "replace", + } + end, + }, + { + "saghen/blink.cmp", + lazy = true, + opts = { + sources = { + compat = { "avante_commands", "avante_mentions", "avante_files" }, + }, + }, + }, + }, + }, +} diff --git a/lua/plugins/lang/clangd.lua b/lua/plugins/lang/clangd.lua new file mode 100644 index 0000000..bce88ae --- /dev/null +++ b/lua/plugins/lang/clangd.lua @@ -0,0 +1,30 @@ +return { + { + "neovim/nvim-lspconfig", + lazy = true, + ft = { "c", "cpp" }, + opts = { + servers = { + clangd = { + cmd = { + "clangd", + "--background-index", + "--clang-tidy", + "--cross-file-rename", + "--clang-tidy-checks=performance-*,cppcoreguidelines-*,clang-analyzer-*,bugprone-*", + "-j=12", + "--all-scopes-completion", + "--header-insertion=iwyu", + "--query-driver=/usr/bin/clang,/usr/bin/clang++", + "--fallback-style=llvm", + }, + }, + }, + }, + }, + { + "Civitasv/cmake-tools.nvim", + lazy = true, + ft = { "c", "cpp" }, + }, +} diff --git a/lua/plugins/lang/latex.lua b/lua/plugins/lang/latex.lua new file mode 100644 index 0000000..160124a --- /dev/null +++ b/lua/plugins/lang/latex.lua @@ -0,0 +1,43 @@ +return { + { + "lervag/vimtex", + lazy = false, -- lazy-loading will disable inverse search + init = function() + vim.g.vimtex_syntax_conceal_disable = 1 + vim.g.vimtex_mappings_disable = { ["n"] = { "K" } } -- disable `K` as it conflicts with LSP hover + vim.g.vimtex_view_method = "sioyek" + -- vim.g.vimtex_view_general_viewer = "open -a UPDF" + vim.g.vimtex_view_skim_sync = 1 + vim.g.vimtex_compiler_silent = 1 + vim.g.vimtex_compiler_method = "latexmk" + vim.g.vimtex_compiler_latexmk = { + aux_dir = "./aux", + out_dir = "", + callback = 1, + continuous = 1, + executable = "latexmk", + hooks = {}, + options = { + -- "-c", + "-verbose", + "-file-line-error", + "-synctex=1", + "-interaction=nonstopmode", + "--shell-escape", + }, + } + vim.g.vimtex_quickfix_ignore_filters = { + "Underfull", + "Overfull", + "specifier changed to", + "Token not allowed in a PDF string", + "LaTeX Warning: Float too large for page", + "contains only floats", + } + end, + }, + { + "evesdropper/luasnip-latex-snippets.nvim", + enabled = false, + }, +} diff --git a/lua/plugins/lang/markdown.lua b/lua/plugins/lang/markdown.lua new file mode 100644 index 0000000..15ac2d3 --- /dev/null +++ b/lua/plugins/lang/markdown.lua @@ -0,0 +1,13 @@ +return { + { + "mfussenegger/nvim-lint", + opts = { + linters = { + markdownlint = { + -- Disable line length check + args = { "--disable", "MD013", "--" }, + }, + }, + }, + }, +} diff --git a/lua/plugins/lang/python.lua b/lua/plugins/lang/python.lua new file mode 100644 index 0000000..ffdbcc3 --- /dev/null +++ b/lua/plugins/lang/python.lua @@ -0,0 +1,16 @@ +return { + { + "kmontocam/nvim-conda", + ft = "python", + dependencies = { "nvim-lua/plenary.nvim" }, + keys = { + { "cv", "CondaActivate", desc = "Conda environment" }, + }, + }, + { + "nvim-neotest/neotest", + ft = "python", + dependencies = { "nvim-neotest/neotest-python" }, + opts = { adapters = { "neotest-python" } }, + }, +} diff --git a/lua/plugins/leetcode.lua b/lua/plugins/leetcode.lua new file mode 100644 index 0000000..e3ee98a --- /dev/null +++ b/lua/plugins/leetcode.lua @@ -0,0 +1,38 @@ +return { + -- { + -- "kawre/leetcode.nvim", + -- build = ":TSUpdate html", + -- dependencies = { + -- "nvim-telescope/telescope.nvim", + -- "nvim-lua/plenary.nvim", -- required by telescope + -- "MunifTanjim/nui.nvim", + -- + -- -- optional + -- "nvim-treesitter/nvim-treesitter", + -- "rcarriga/nvim-notify", + -- "nvim-tree/nvim-web-devicons", + -- }, + -- lazy = false, + -- keys = { + -- { "kt", "Leet test", desc = "Leet test" }, + -- { "ks", "Leet submit", desc = "Leet submit" }, + -- { "kl", "Leet lang", desc = "Leet lang" }, + -- { "kp", "Leet list", desc = "List problem" }, + -- }, + -- opts = { + -- -- configuration goes here + -- ---@type string + -- arg = "leetcode.nvim", + -- + -- ---@type lc.lang + -- lang = "cpp", + -- ---@type lc.storage + -- storage = { + -- home = vim.fn.stdpath("data") .. "/leetcode", + -- cache = vim.fn.stdpath("cache") .. "/leetcode", + -- }, + -- ---@type boolean + -- logging = false, + -- }, + -- }, +} diff --git a/lua/plugins/mason-workaround.lua b/lua/plugins/mason-workaround.lua new file mode 100644 index 0000000..949039d --- /dev/null +++ b/lua/plugins/mason-workaround.lua @@ -0,0 +1,4 @@ +return { + { "mason-org/mason.nvim", version = "^1.0.0" }, + { "mason-org/mason-lspconfig.nvim", version = "^1.0.0" }, +} diff --git a/lua/plugins/ui/colorscheme.lua b/lua/plugins/ui/colorscheme.lua new file mode 100644 index 0000000..4ce4118 --- /dev/null +++ b/lua/plugins/ui/colorscheme.lua @@ -0,0 +1,19 @@ +return { + -- Lazy + { + "catppuccin/nvim", + name = "catppuccin", + priority = 1000, + opts = { + flavour = "mocha", + -- transparent_background = true, + }, + }, + -- somewhere in your config: + { + "LazyVim/LazyVim", + opts = { + colorscheme = "catppuccin", + }, + }, +} diff --git a/lua/plugins/ui/transparent.lua b/lua/plugins/ui/transparent.lua new file mode 100644 index 0000000..94170f5 --- /dev/null +++ b/lua/plugins/ui/transparent.lua @@ -0,0 +1,21 @@ +return { + -- { + -- "xiyaowong/nvim-transparent", + -- opts = { + -- extra_groups = { + -- "BufferLineTabClose", + -- "BufferlineBufferSelected", + -- "BufferLineFill", + -- "BufferLineBackground", + -- "BufferLineSeparator", + -- "BufferLineIndicatorSelected", + -- }, + -- }, + -- }, + -- { + -- "rcarriga/nvim-notify", + -- opts = { + -- background_colour = "#000000", + -- }, + -- }, +} diff --git a/lua/plugins/yazi.lua b/lua/plugins/yazi.lua new file mode 100644 index 0000000..d63a8d1 --- /dev/null +++ b/lua/plugins/yazi.lua @@ -0,0 +1,31 @@ +---@type LazySpec +return { + { + "mikavilpas/yazi.nvim", + event = "VeryLazy", + keys = { + -- 👇 in this section, choose your own keymappings! + { + -- Open in the current working directory + "fM", + "Yazi cwd", + desc = "Open the file manager in nvim's working directory", + }, + { + -- NOTE: this requires a version of yazi that includes + -- https://github.com/sxyazi/yazi/pull/1305 from 2024-07-18 + "fm", + "Yazi toggle", + desc = "Resume the last yazi session", + }, + }, + ---@type YaziConfig + opts = { + -- if you want to open yazi instead of netrw, see below for more info + open_for_directories = false, + keymaps = { + show_help = "", + }, + }, + }, +} diff --git a/lua/util/empty_evilline.lua b/lua/util/empty_evilline.lua new file mode 100644 index 0000000..e69de29 diff --git a/lua/util/init.lua b/lua/util/init.lua new file mode 100644 index 0000000..5044d6f --- /dev/null +++ b/lua/util/init.lua @@ -0,0 +1,3 @@ +local M = {} + +return M diff --git a/lua/util/latex.lua b/lua/util/latex.lua new file mode 100644 index 0000000..eccbafb --- /dev/null +++ b/lua/util/latex.lua @@ -0,0 +1,104 @@ +local M = {} + +local MATH_NODES = { + displayed_equation = true, + inline_formula = true, + math_environment = true, +} + +local ts_utils = require("nvim-treesitter.ts_utils") + +M.in_env_md = function(env) + local node = ts_utils.get_node_at_cursor() + local bufnr = vim.api.nvim_get_current_buf() + while node do + if node:type() == "generic_environment" then + local begin = node:child(0) + local name = begin:field("name") + if name[1] and vim.treesitter.get_node_text(name[1], bufnr, nil) == "{" .. env .. "}" then + return true + end + end + node = node:parent() + end + return false +end + +M.in_env = function(env) + local pos = vim.fn["vimtex#env#is_inside"](env) + return pos[1] ~= 0 or pos[2] ~= 0 +end + +M.in_mathzone = function() + local ft = vim.bo.filetype + if ft == "tex" then + return vim.api.nvim_eval("vimtex#syntax#in_mathzone()") == 1 + elseif ft == "markdown" then + return M.in_mathzone_md() + end +end + +M.in_text = function() + return not M.in_mathzone() +end + +M.in_item = function() + return M.in_env("itemize") or M.in_env("enumerate") +end +M.in_bib = function() + return M.in_env("thebibliography") +end +M.in_tikz = function() + return M.in_env("tikzpicture") +end +M.in_quantikz = function() + return M.in_env("quantikz") +end +M.in_algo = function() + return M.in_env("algorithmic") +end + +-- For markdown +M.in_mathzone_md = function() + local node = ts_utils.get_node_at_cursor() + while node do + if MATH_NODES[node:type()] then + return true + end + node = node:parent() + end + return false +end +M.in_text_md = function() + return not M.in_mathzone_md() +end + +-- M.clean = function() +-- local current_dir = vim.fn.expand("%:p:h") +-- local file_types = { "aux", "log", "out", "fls", "fdb_latexmk", "bcf", "run.xml", "toc", "DS_Store", "bak*", "dvi" } +-- for _, file_type in ipairs(file_types) do +-- local command = "rm " .. current_dir .. "/*." .. file_type +-- vim.api.nvim_call_function("system", { command }) +-- end +-- end +-- +-- M.format = function() +-- local current_file = vim.fn.expand("%:p") +-- local latexindent = "latexindent -g /dev/null " .. current_file .. " -wd -l ~/Documents/Latex/latexindent.yaml" +-- local build = "pdflatex " .. current_file +-- vim.api.nvim_call_function("system", { build }) +-- vim.cmd("w") +-- M.clean() +-- vim.api.nvim_call_function("system", { latexindent }) +-- vim.cmd("e") +-- vim.cmd("normal! zz") +-- -- vim.cmd("TexlabForward") +-- end +-- +-- M.sympy_calc = function() +-- local selected_text = vim.fn.getreg("v") +-- print(selected_text) +-- vim.api.nvim_out_write(selected_text) +-- end + +return M diff --git a/stylua.toml b/stylua.toml new file mode 100644 index 0000000..5d6c50d --- /dev/null +++ b/stylua.toml @@ -0,0 +1,3 @@ +indent_type = "Spaces" +indent_width = 2 +column_width = 120 \ No newline at end of file