Обновление gitconfig

git/config

@@ -10,12 +10,19 @@
 [http]
 	sslVerify = false
 
+[column]
+	ui = auto
+
 [commit]
 	gpgsign = true
 	verbose = true
 
 [branch]
 	autosetuprebase = always
+	sort = -committerdate
+
+[tag]
+		sort = version:refname
 
 [help]
 	autocorrect = 1
@@ -38,6 +45,8 @@
 
 [rebase]
 	autoStash = true
+	autoSquash = true
+	updateRefs = true
 
 [pull]
 	rebase = true
@@ -46,41 +55,23 @@
 [fetch]
 	prune = true
 	pruneTags = true
+	all = true
 	output = full
 
+[push]
+	default = simple
+	autoSetupRemote = true
+	followTags = true
+
+[merge]
+	conflictstyle = zdiff3
+
 [core]
 	preloadindex = true
 	excludesFile = ~/.gitignore
 	trustctime = false
 	commitGraph = true
 
-[color]
-	ui = auto
-
-[color "diff"]
-	meta = yellow bold
-	commit = green bold
-	frag = magenta bold
-	old = red bold
-	new = green bold
-	whitespace = red reverse
-
-[color "diff-highlight"]
-	oldNormal = red bold
-	oldHighlight = red bold 52
-	newNormal = green bold
-	newHighlight = green bold 22
-
-[color "branch"]
-	current = yellow reverse
-	local = yellow
-	remote = green
-
-[color "status"]
-	added = yellow
-	changed = green
-	untracked = cyan
-
 [diff]
 	indentHeuristic = true
 	algorithm = histogram
@@ -91,6 +82,7 @@
 
 [rerere]
 	enabled = true
+	autoupdate = true
 
 [pager]
 	color = true
@@ -128,5 +120,34 @@
 
 [include]
 	path = .gitconfig.local
+
 [gpg]
 	format = ssh
+
+[color]
+	ui = auto
+
+[color "diff"]
+	meta = yellow bold
+	commit = green bold
+	frag = magenta bold
+	old = red bold
+	new = green bold
+	whitespace = red reverse
+
+[color "diff-highlight"]
+	oldNormal = red bold
+	oldHighlight = red bold 52
+	newNormal = green bold
+	newHighlight = green bold 22
+
+[color "branch"]
+	current = yellow reverse
+	local = yellow
+	remote = green
+
+[color "status"]
+	added = yellow
+	changed = green
+	untracked = cyan
+

nvim/lua/keymaps.lua

@@ -1,7 +1,7 @@
 local map = vim.api.nvim_set_keymap
 local opts = {noremap = true, silent = true}
 
-vim.g.mapleader = " "
+vim.g.mapleader = "\\"
 
 -- Tree
 map('n', '<C-h>', ':NvimTreeToggle<CR>', opts)

zsh/comp/cobra.zsh-completion

@@ -0,0 +1,177 @@
+#compdef _cobra-cli cobra-cli
+
+# zsh completion for cobra-cli                            -*- shell-script -*-
+
+__cobra-cli_debug()
+{
+    local file="$BASH_COMP_DEBUG_FILE"
+    if [[ -n ${file} ]]; then
+        echo "$*" >> "${file}"
+    fi
+}
+
+_cobra-cli()
+{
+    local shellCompDirectiveError=1
+    local shellCompDirectiveNoSpace=2
+    local shellCompDirectiveNoFileComp=4
+    local shellCompDirectiveFilterFileExt=8
+    local shellCompDirectiveFilterDirs=16
+
+    local lastParam lastChar flagPrefix requestComp out directive comp lastComp noSpace
+    local -a completions
+
+    __cobra-cli_debug "\n========= starting completion logic =========="
+    __cobra-cli_debug "CURRENT: ${CURRENT}, words[*]: ${words[*]}"
+
+    # The user could have moved the cursor backwards on the command-line.
+    # We need to trigger completion from the $CURRENT location, so we need
+    # to truncate the command-line ($words) up to the $CURRENT location.
+    # (We cannot use $CURSOR as its value does not work when a command is an alias.)
+    words=("${=words[1,CURRENT]}")
+    __cobra-cli_debug "Truncated words[*]: ${words[*]},"
+
+    lastParam=${words[-1]}
+    lastChar=${lastParam[-1]}
+    __cobra-cli_debug "lastParam: ${lastParam}, lastChar: ${lastChar}"
+
+    # For zsh, when completing a flag with an = (e.g., cobra-cli -n=<TAB>)
+    # completions must be prefixed with the flag
+    setopt local_options BASH_REMATCH
+    if [[ "${lastParam}" =~ '-.*=' ]]; then
+        # We are dealing with a flag with an =
+        flagPrefix="-P ${BASH_REMATCH}"
+    fi
+
+    # Prepare the command to obtain completions
+    requestComp="${words[1]} __complete ${words[2,-1]}"
+    if [ "${lastChar}" = "" ]; then
+        # If the last parameter is complete (there is a space following it)
+        # We add an extra empty parameter so we can indicate this to the go completion code.
+        __cobra-cli_debug "Adding extra empty parameter"
+        requestComp="${requestComp} \"\""
+    fi
+
+    __cobra-cli_debug "About to call: eval ${requestComp}"
+
+    # Use eval to handle any environment variables and such
+    out=$(eval ${requestComp} 2>/dev/null)
+    __cobra-cli_debug "completion output: ${out}"
+
+    # Extract the directive integer following a : from the last line
+    local lastLine
+    while IFS='\n' read -r line; do
+        lastLine=${line}
+    done < <(printf "%s\n" "${out[@]}")
+    __cobra-cli_debug "last line: ${lastLine}"
+
+    if [ "${lastLine[1]}" = : ]; then
+        directive=${lastLine[2,-1]}
+        # Remove the directive including the : and the newline
+        local suffix
+        (( suffix=${#lastLine}+2))
+        out=${out[1,-$suffix]}
+    else
+        # There is no directive specified.  Leave $out as is.
+        __cobra-cli_debug "No directive found.  Setting do default"
+        directive=0
+    fi
+
+    __cobra-cli_debug "directive: ${directive}"
+    __cobra-cli_debug "completions: ${out}"
+    __cobra-cli_debug "flagPrefix: ${flagPrefix}"
+
+    if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
+        __cobra-cli_debug "Completion received error. Ignoring completions."
+        return
+    fi
+
+    while IFS='\n' read -r comp; do
+        if [ -n "$comp" ]; then
+            # If requested, completions are returned with a description.
+            # The description is preceded by a TAB character.
+            # For zsh's _describe, we need to use a : instead of a TAB.
+            # We first need to escape any : as part of the completion itself.
+            comp=${comp//:/\\:}
+
+            local tab=$(printf '\t')
+            comp=${comp//$tab/:}
+
+            __cobra-cli_debug "Adding completion: ${comp}"
+            completions+=${comp}
+            lastComp=$comp
+        fi
+    done < <(printf "%s\n" "${out[@]}")
+
+    if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
+        __cobra-cli_debug "Activating nospace."
+        noSpace="-S ''"
+    fi
+
+    if [ $((directive & shellCompDirectiveFilterFileExt)) -ne 0 ]; then
+        # File extension filtering
+        local filteringCmd
+        filteringCmd='_files'
+        for filter in ${completions[@]}; do
+            if [ ${filter[1]} != '*' ]; then
+                # zsh requires a glob pattern to do file filtering
+                filter="\*.$filter"
+            fi
+            filteringCmd+=" -g $filter"
+        done
+        filteringCmd+=" ${flagPrefix}"
+
+        __cobra-cli_debug "File filtering command: $filteringCmd"
+        _arguments '*:filename:'"$filteringCmd"
+    elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then
+        # File completion for directories only
+        local subdir
+        subdir="${completions[1]}"
+        if [ -n "$subdir" ]; then
+            __cobra-cli_debug "Listing directories in $subdir"
+            pushd "${subdir}" >/dev/null 2>&1
+        else
+            __cobra-cli_debug "Listing directories in ."
+        fi
+
+        local result
+        _arguments '*:dirname:_files -/'" ${flagPrefix}"
+        result=$?
+        if [ -n "$subdir" ]; then
+            popd >/dev/null 2>&1
+        fi
+        return $result
+    else
+        __cobra-cli_debug "Calling _describe"
+        if eval _describe "completions" completions $flagPrefix $noSpace; then
+            __cobra-cli_debug "_describe found some completions"
+
+            # Return the success of having called _describe
+            return 0
+        else
+            __cobra-cli_debug "_describe did not find completions."
+            __cobra-cli_debug "Checking if we should do file completion."
+            if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
+                __cobra-cli_debug "deactivating file completion"
+
+                # We must return an error code here to let zsh know that there were no
+                # completions found by _describe; this is what will trigger other
+                # matching algorithms to attempt to find completions.
+                # For example zsh can match letters in the middle of words.
+                return 1
+            else
+                # Perform file completion
+                __cobra-cli_debug "Activating file completion"
+
+                # We must return the result of this command, so it must be the
+                # last command, or else we must store its result to return it.
+                _arguments '*:filename:_files'" ${flagPrefix}"
+            fi
+        fi
+    fi
+}
+
+# don't run the completion function when being source-ed or eval-ed
+if [ "$funcstack[1]" = "_cobra-cli" ]; then
+    _cobra-cli
+fi

zsh/comp/goldwarden.zsh-completion

@@ -0,0 +1,212 @@
+#compdef goldwarden
+compdef _goldwarden goldwarden
+
+# zsh completion for goldwarden                           -*- shell-script -*-
+
+__goldwarden_debug()
+{
+    local file="$BASH_COMP_DEBUG_FILE"
+    if [[ -n ${file} ]]; then
+        echo "$*" >> "${file}"
+    fi
+}
+
+_goldwarden()
+{
+    local shellCompDirectiveError=1
+    local shellCompDirectiveNoSpace=2
+    local shellCompDirectiveNoFileComp=4
+    local shellCompDirectiveFilterFileExt=8
+    local shellCompDirectiveFilterDirs=16
+    local shellCompDirectiveKeepOrder=32
+
+    local lastParam lastChar flagPrefix requestComp out directive comp lastComp noSpace keepOrder
+    local -a completions
+
+    __goldwarden_debug "\n========= starting completion logic =========="
+    __goldwarden_debug "CURRENT: ${CURRENT}, words[*]: ${words[*]}"
+
+    # The user could have moved the cursor backwards on the command-line.
+    # We need to trigger completion from the $CURRENT location, so we need
+    # to truncate the command-line ($words) up to the $CURRENT location.
+    # (We cannot use $CURSOR as its value does not work when a command is an alias.)
+    words=("${=words[1,CURRENT]}")
+    __goldwarden_debug "Truncated words[*]: ${words[*]},"
+
+    lastParam=${words[-1]}
+    lastChar=${lastParam[-1]}
+    __goldwarden_debug "lastParam: ${lastParam}, lastChar: ${lastChar}"
+
+    # For zsh, when completing a flag with an = (e.g., goldwarden -n=<TAB>)
+    # completions must be prefixed with the flag
+    setopt local_options BASH_REMATCH
+    if [[ "${lastParam}" =~ '-.*=' ]]; then
+        # We are dealing with a flag with an =
+        flagPrefix="-P ${BASH_REMATCH}"
+    fi
+
+    # Prepare the command to obtain completions
+    requestComp="${words[1]} __complete ${words[2,-1]}"
+    if [ "${lastChar}" = "" ]; then
+        # If the last parameter is complete (there is a space following it)
+        # We add an extra empty parameter so we can indicate this to the go completion code.
+        __goldwarden_debug "Adding extra empty parameter"
+        requestComp="${requestComp} \"\""
+    fi
+
+    __goldwarden_debug "About to call: eval ${requestComp}"
+
+    # Use eval to handle any environment variables and such
+    out=$(eval ${requestComp} 2>/dev/null)
+    __goldwarden_debug "completion output: ${out}"
+
+    # Extract the directive integer following a : from the last line
+    local lastLine
+    while IFS='\n' read -r line; do
+        lastLine=${line}
+    done < <(printf "%s\n" "${out[@]}")
+    __goldwarden_debug "last line: ${lastLine}"
+
+    if [ "${lastLine[1]}" = : ]; then
+        directive=${lastLine[2,-1]}
+        # Remove the directive including the : and the newline
+        local suffix
+        (( suffix=${#lastLine}+2))
+        out=${out[1,-$suffix]}
+    else
+        # There is no directive specified.  Leave $out as is.
+        __goldwarden_debug "No directive found.  Setting do default"
+        directive=0
+    fi
+
+    __goldwarden_debug "directive: ${directive}"
+    __goldwarden_debug "completions: ${out}"
+    __goldwarden_debug "flagPrefix: ${flagPrefix}"
+
+    if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
+        __goldwarden_debug "Completion received error. Ignoring completions."
+        return
+    fi
+
+    local activeHelpMarker="_activeHelp_ "
+    local endIndex=${#activeHelpMarker}
+    local startIndex=$((${#activeHelpMarker}+1))
+    local hasActiveHelp=0
+    while IFS='\n' read -r comp; do
+        # Check if this is an activeHelp statement (i.e., prefixed with $activeHelpMarker)
+        if [ "${comp[1,$endIndex]}" = "$activeHelpMarker" ];then
+            __goldwarden_debug "ActiveHelp found: $comp"
+            comp="${comp[$startIndex,-1]}"
+            if [ -n "$comp" ]; then
+                compadd -x "${comp}"
+                __goldwarden_debug "ActiveHelp will need delimiter"
+                hasActiveHelp=1
+            fi
+
+            continue
+        fi
+
+        if [ -n "$comp" ]; then
+            # If requested, completions are returned with a description.
+            # The description is preceded by a TAB character.
+            # For zsh's _describe, we need to use a : instead of a TAB.
+            # We first need to escape any : as part of the completion itself.
+            comp=${comp//:/\\:}
+
+            local tab="$(printf '\t')"
+            comp=${comp//$tab/:}
+
+            __goldwarden_debug "Adding completion: ${comp}"
+            completions+=${comp}
+            lastComp=$comp
+        fi
+    done < <(printf "%s\n" "${out[@]}")
+
+    # Add a delimiter after the activeHelp statements, but only if:
+    # - there are completions following the activeHelp statements, or
+    # - file completion will be performed (so there will be choices after the activeHelp)
+    if [ $hasActiveHelp -eq 1 ]; then
+        if [ ${#completions} -ne 0 ] || [ $((directive & shellCompDirectiveNoFileComp)) -eq 0 ]; then
+            __goldwarden_debug "Adding activeHelp delimiter"
+            compadd -x "--"
+            hasActiveHelp=0
+        fi
+    fi
+
+    if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
+        __goldwarden_debug "Activating nospace."
+        noSpace="-S ''"
+    fi
+
+    if [ $((directive & shellCompDirectiveKeepOrder)) -ne 0 ]; then
+        __goldwarden_debug "Activating keep order."
+        keepOrder="-V"
+    fi
+
+    if [ $((directive & shellCompDirectiveFilterFileExt)) -ne 0 ]; then
+        # File extension filtering
+        local filteringCmd
+        filteringCmd='_files'
+        for filter in ${completions[@]}; do
+            if [ ${filter[1]} != '*' ]; then
+                # zsh requires a glob pattern to do file filtering
+                filter="\*.$filter"
+            fi
+            filteringCmd+=" -g $filter"
+        done
+        filteringCmd+=" ${flagPrefix}"
+
+        __goldwarden_debug "File filtering command: $filteringCmd"
+        _arguments '*:filename:'"$filteringCmd"
+    elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then
+        # File completion for directories only
+        local subdir
+        subdir="${completions[1]}"
+        if [ -n "$subdir" ]; then
+            __goldwarden_debug "Listing directories in $subdir"
+            pushd "${subdir}" >/dev/null 2>&1
+        else
+            __goldwarden_debug "Listing directories in ."
+        fi
+
+        local result
+        _arguments '*:dirname:_files -/'" ${flagPrefix}"
+        result=$?
+        if [ -n "$subdir" ]; then
+            popd >/dev/null 2>&1
+        fi
+        return $result
+    else
+        __goldwarden_debug "Calling _describe"
+        if eval _describe $keepOrder "completions" completions $flagPrefix $noSpace; then
+            __goldwarden_debug "_describe found some completions"
+
+            # Return the success of having called _describe
+            return 0
+        else
+            __goldwarden_debug "_describe did not find completions."
+            __goldwarden_debug "Checking if we should do file completion."
+            if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
+                __goldwarden_debug "deactivating file completion"
+
+                # We must return an error code here to let zsh know that there were no
+                # completions found by _describe; this is what will trigger other
+                # matching algorithms to attempt to find completions.
+                # For example zsh can match letters in the middle of words.
+                return 1
+            else
+                # Perform file completion
+                __goldwarden_debug "Activating file completion"
+
+                # We must return the result of this command, so it must be the
+                # last command, or else we must store its result to return it.
+                _arguments '*:filename:_files'" ${flagPrefix}"
+            fi
+        fi
+    fi
+}
+
+# don't run the completion function when being source-ed or eval-ed
+if [ "$funcstack[1]" = "_goldwarden" ]; then
+    _goldwarden
+fi

zsh/comp/hugo.zsh-completion

@@ -0,0 +1,212 @@
+#compdef hugo
+compdef _hugo hugo
+
+# zsh completion for hugo                                 -*- shell-script -*-
+
+__hugo_debug()
+{
+    local file="$BASH_COMP_DEBUG_FILE"
+    if [[ -n ${file} ]]; then
+        echo "$*" >> "${file}"
+    fi
+}
+
+_hugo()
+{
+    local shellCompDirectiveError=1
+    local shellCompDirectiveNoSpace=2
+    local shellCompDirectiveNoFileComp=4
+    local shellCompDirectiveFilterFileExt=8
+    local shellCompDirectiveFilterDirs=16
+    local shellCompDirectiveKeepOrder=32
+
+    local lastParam lastChar flagPrefix requestComp out directive comp lastComp noSpace keepOrder
+    local -a completions
+
+    __hugo_debug "\n========= starting completion logic =========="
+    __hugo_debug "CURRENT: ${CURRENT}, words[*]: ${words[*]}"
+
+    # The user could have moved the cursor backwards on the command-line.
+    # We need to trigger completion from the $CURRENT location, so we need
+    # to truncate the command-line ($words) up to the $CURRENT location.
+    # (We cannot use $CURSOR as its value does not work when a command is an alias.)
+    words=("${=words[1,CURRENT]}")
+    __hugo_debug "Truncated words[*]: ${words[*]},"
+
+    lastParam=${words[-1]}
+    lastChar=${lastParam[-1]}
+    __hugo_debug "lastParam: ${lastParam}, lastChar: ${lastChar}"
+
+    # For zsh, when completing a flag with an = (e.g., hugo -n=<TAB>)
+    # completions must be prefixed with the flag
+    setopt local_options BASH_REMATCH
+    if [[ "${lastParam}" =~ '-.*=' ]]; then
+        # We are dealing with a flag with an =
+        flagPrefix="-P ${BASH_REMATCH}"
+    fi
+
+    # Prepare the command to obtain completions
+    requestComp="${words[1]} __complete ${words[2,-1]}"
+    if [ "${lastChar}" = "" ]; then
+        # If the last parameter is complete (there is a space following it)
+        # We add an extra empty parameter so we can indicate this to the go completion code.
+        __hugo_debug "Adding extra empty parameter"
+        requestComp="${requestComp} \"\""
+    fi
+
+    __hugo_debug "About to call: eval ${requestComp}"
+
+    # Use eval to handle any environment variables and such
+    out=$(eval ${requestComp} 2>/dev/null)
+    __hugo_debug "completion output: ${out}"
+
+    # Extract the directive integer following a : from the last line
+    local lastLine
+    while IFS='\n' read -r line; do
+        lastLine=${line}
+    done < <(printf "%s\n" "${out[@]}")
+    __hugo_debug "last line: ${lastLine}"
+
+    if [ "${lastLine[1]}" = : ]; then
+        directive=${lastLine[2,-1]}
+        # Remove the directive including the : and the newline
+        local suffix
+        (( suffix=${#lastLine}+2))
+        out=${out[1,-$suffix]}
+    else
+        # There is no directive specified.  Leave $out as is.
+        __hugo_debug "No directive found.  Setting do default"
+        directive=0
+    fi
+
+    __hugo_debug "directive: ${directive}"
+    __hugo_debug "completions: ${out}"
+    __hugo_debug "flagPrefix: ${flagPrefix}"
+
+    if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
+        __hugo_debug "Completion received error. Ignoring completions."
+        return
+    fi
+
+    local activeHelpMarker="_activeHelp_ "
+    local endIndex=${#activeHelpMarker}
+    local startIndex=$((${#activeHelpMarker}+1))
+    local hasActiveHelp=0
+    while IFS='\n' read -r comp; do
+        # Check if this is an activeHelp statement (i.e., prefixed with $activeHelpMarker)
+        if [ "${comp[1,$endIndex]}" = "$activeHelpMarker" ];then
+            __hugo_debug "ActiveHelp found: $comp"
+            comp="${comp[$startIndex,-1]}"
+            if [ -n "$comp" ]; then
+                compadd -x "${comp}"
+                __hugo_debug "ActiveHelp will need delimiter"
+                hasActiveHelp=1
+            fi
+
+            continue
+        fi
+
+        if [ -n "$comp" ]; then
+            # If requested, completions are returned with a description.
+            # The description is preceded by a TAB character.
+            # For zsh's _describe, we need to use a : instead of a TAB.
+            # We first need to escape any : as part of the completion itself.
+            comp=${comp//:/\\:}
+
+            local tab="$(printf '\t')"
+            comp=${comp//$tab/:}
+
+            __hugo_debug "Adding completion: ${comp}"
+            completions+=${comp}
+            lastComp=$comp
+        fi
+    done < <(printf "%s\n" "${out[@]}")
+
+    # Add a delimiter after the activeHelp statements, but only if:
+    # - there are completions following the activeHelp statements, or
+    # - file completion will be performed (so there will be choices after the activeHelp)
+    if [ $hasActiveHelp -eq 1 ]; then
+        if [ ${#completions} -ne 0 ] || [ $((directive & shellCompDirectiveNoFileComp)) -eq 0 ]; then
+            __hugo_debug "Adding activeHelp delimiter"
+            compadd -x "--"
+            hasActiveHelp=0
+        fi
+    fi
+
+    if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
+        __hugo_debug "Activating nospace."
+        noSpace="-S ''"
+    fi
+
+    if [ $((directive & shellCompDirectiveKeepOrder)) -ne 0 ]; then
+        __hugo_debug "Activating keep order."
+        keepOrder="-V"
+    fi
+
+    if [ $((directive & shellCompDirectiveFilterFileExt)) -ne 0 ]; then
+        # File extension filtering
+        local filteringCmd
+        filteringCmd='_files'
+        for filter in ${completions[@]}; do
+            if [ ${filter[1]} != '*' ]; then
+                # zsh requires a glob pattern to do file filtering
+                filter="\*.$filter"
+            fi
+            filteringCmd+=" -g $filter"
+        done
+        filteringCmd+=" ${flagPrefix}"
+
+        __hugo_debug "File filtering command: $filteringCmd"
+        _arguments '*:filename:'"$filteringCmd"
+    elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then
+        # File completion for directories only
+        local subdir
+        subdir="${completions[1]}"
+        if [ -n "$subdir" ]; then
+            __hugo_debug "Listing directories in $subdir"
+            pushd "${subdir}" >/dev/null 2>&1
+        else
+            __hugo_debug "Listing directories in ."
+        fi
+
+        local result
+        _arguments '*:dirname:_files -/'" ${flagPrefix}"
+        result=$?
+        if [ -n "$subdir" ]; then
+            popd >/dev/null 2>&1
+        fi
+        return $result
+    else
+        __hugo_debug "Calling _describe"
+        if eval _describe $keepOrder "completions" completions $flagPrefix $noSpace; then
+            __hugo_debug "_describe found some completions"
+
+            # Return the success of having called _describe
+            return 0
+        else
+            __hugo_debug "_describe did not find completions."
+            __hugo_debug "Checking if we should do file completion."
+            if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
+                __hugo_debug "deactivating file completion"
+
+                # We must return an error code here to let zsh know that there were no
+                # completions found by _describe; this is what will trigger other
+                # matching algorithms to attempt to find completions.
+                # For example zsh can match letters in the middle of words.
+                return 1
+            else
+                # Perform file completion
+                __hugo_debug "Activating file completion"
+
+                # We must return the result of this command, so it must be the
+                # last command, or else we must store its result to return it.
+                _arguments '*:filename:_files'" ${flagPrefix}"
+            fi
+        fi
+    fi
+}
+
+# don't run the completion function when being source-ed or eval-ed
+if [ "$funcstack[1]" = "_hugo" ]; then
+    _hugo
+fi

zsh/comp/pass.zsh-completion

@@ -0,0 +1,144 @@
+#compdef pass
+#autoload
+
+# Copyright (C) 2012 - 2014:
+#    Johan Venant <jvenant@invicem.pro>
+#    Brian Mattern <rephorm@rephorm.com>
+#    Jason A. Donenfeld <Jason@zx2c4.com>.
+# All Rights Reserved.
+# This file is licensed under the GPLv2+. Please see COPYING for more information.
+
+
+# If you use multiple repositories, you can configure completion like this:
+#
+# compdef _pass workpass
+# zstyle ':completion::complete:workpass::' prefix "$HOME/work/pass"
+# workpass() {
+#   PASSWORD_STORE_DIR=$HOME/work/pass pass $@
+# }
+
+
+_pass () {
+	local cmd
+	if (( CURRENT > 2)); then
+		cmd=${words[2]}
+		# Set the context for the subcommand.
+		curcontext="${curcontext%:*:*}:pass-$cmd"
+		# Narrow the range of words we are looking at to exclude `pass'
+		(( CURRENT-- ))
+		shift words
+		# Run the completion for the subcommand
+		case "${cmd}" in
+			init)
+				_arguments : \
+					"-p[gpg-id will only be applied to this subfolder]" \
+					"--path[gpg-id will only be applied to this subfolder]"
+				_pass_complete_keys
+				;;
+			ls|list|edit)
+				_pass_complete_entries_with_subdirs
+				;;
+			insert)
+				_arguments : \
+					"-e[echo password to console]" \
+					"--echo[echo password to console]" \
+					"-m[multiline]" \
+					"--multiline[multiline]"
+				_pass_complete_entries_with_subdirs
+				;;
+			generate)
+				_arguments : \
+					"-n[don't include symbols in password]" \
+					"--no-symbols[don't include symbols in password]" \
+					"-c[copy password to the clipboard]" \
+					"--clip[copy password to the clipboard]" \
+					"-f[force overwrite]" \
+					"--force[force overwrite]" \
+					"-i[replace first line]" \
+					"--in-place[replace first line]"
+				_pass_complete_entries_with_subdirs
+				;;
+			cp|copy|mv|rename)
+				_arguments : \
+					"-f[force rename]" \
+					"--force[force rename]"
+					_pass_complete_entries_with_subdirs
+				;;
+			rm)
+				_arguments : \
+					"-f[force deletion]" \
+					"--force[force deletion]" \
+					"-r[recursively delete]" \
+					"--recursive[recursively delete]"
+					_pass_complete_entries_with_subdirs
+				;;
+			git)
+				local -a subcommands
+				subcommands=(
+					"init:Initialize git repository"
+					"push:Push to remote repository"
+					"pull:Pull from remote repository"
+					"config:Show git config"
+					"log:Show git log"
+					"reflog:Show git reflog"
+				)
+				_describe -t commands 'pass git' subcommands
+				;;
+			show|*)
+				_pass_cmd_show
+				;;
+		esac
+	else
+		local -a subcommands
+		subcommands=(
+			"init:Initialize new password storage"
+			"ls:List passwords"
+			"find:Find password files or directories based on pattern"
+			"grep:Search inside decrypted password files for matching pattern"
+			"show:Decrypt and print a password"
+			"insert:Insert a new password"
+			"generate:Generate a new password using pwgen"
+			"edit:Edit a password with \$EDITOR"
+			"mv:Rename the password"
+			"cp:Copy the password"
+			"rm:Remove the password"
+			"git:Call git on the password store"
+			"version:Output version information"
+			"help:Output help message"
+		)
+		_describe -t commands 'pass' subcommands
+		_arguments : \
+			"--version[Output version information]" \
+			"--help[Output help message]"
+		_pass_cmd_show
+	fi
+}
+
+_pass_cmd_show () {
+	_arguments : \
+		"-c[put it on the clipboard]" \
+		"--clip[put it on the clipboard]"
+	_pass_complete_entries
+}
+_pass_complete_entries_helper () {
+	local IFS=$'\n'
+	local prefix
+	zstyle -s ":completion:${curcontext}:" prefix prefix || prefix="${PASSWORD_STORE_DIR:-$HOME/.password-store}"
+	_values -C 'passwords' ${$(find -L "$prefix" \( -name .git -o -name .gpg-id \) -prune -o $@ -print 2>/dev/null | sed -e "s#${prefix}/\{0,1\}##" -e 's#\.gpg##' -e 's#\\#\\\\#g' -e 's#:#\\:#g' | sort):-""}
+}
+
+_pass_complete_entries_with_subdirs () {
+	_pass_complete_entries_helper
+}
+
+_pass_complete_entries () {
+	_pass_complete_entries_helper -type f
+}
+
+_pass_complete_keys () {
+	local IFS=$'\n'
+	# Extract names and email addresses from gpg --list-keys
+	_values 'gpg keys' $(gpg2 --list-secret-keys --with-colons | cut -d : -f 10 | sort -u | sed '/^$/d')
+}
+
+_pass

zsh/comp/vgo.zsh-completion

@@ -0,0 +1,212 @@
+#compdef vgo
+compdef _vgo vgo
+
+# zsh completion for vgo                                  -*- shell-script -*-
+
+__vgo_debug()
+{
+    local file="$BASH_COMP_DEBUG_FILE"
+    if [[ -n ${file} ]]; then
+        echo "$*" >> "${file}"
+    fi
+}
+
+_vgo()
+{
+    local shellCompDirectiveError=1
+    local shellCompDirectiveNoSpace=2
+    local shellCompDirectiveNoFileComp=4
+    local shellCompDirectiveFilterFileExt=8
+    local shellCompDirectiveFilterDirs=16
+    local shellCompDirectiveKeepOrder=32
+
+    local lastParam lastChar flagPrefix requestComp out directive comp lastComp noSpace keepOrder
+    local -a completions
+
+    __vgo_debug "\n========= starting completion logic =========="
+    __vgo_debug "CURRENT: ${CURRENT}, words[*]: ${words[*]}"
+
+    # The user could have moved the cursor backwards on the command-line.
+    # We need to trigger completion from the $CURRENT location, so we need
+    # to truncate the command-line ($words) up to the $CURRENT location.
+    # (We cannot use $CURSOR as its value does not work when a command is an alias.)
+    words=("${=words[1,CURRENT]}")
+    __vgo_debug "Truncated words[*]: ${words[*]},"
+
+    lastParam=${words[-1]}
+    lastChar=${lastParam[-1]}
+    __vgo_debug "lastParam: ${lastParam}, lastChar: ${lastChar}"
+
+    # For zsh, when completing a flag with an = (e.g., vgo -n=<TAB>)
+    # completions must be prefixed with the flag
+    setopt local_options BASH_REMATCH
+    if [[ "${lastParam}" =~ '-.*=' ]]; then
+        # We are dealing with a flag with an =
+        flagPrefix="-P ${BASH_REMATCH}"
+    fi
+
+    # Prepare the command to obtain completions
+    requestComp="${words[1]} __complete ${words[2,-1]}"
+    if [ "${lastChar}" = "" ]; then
+        # If the last parameter is complete (there is a space following it)
+        # We add an extra empty parameter so we can indicate this to the go completion code.
+        __vgo_debug "Adding extra empty parameter"
+        requestComp="${requestComp} \"\""
+    fi
+
+    __vgo_debug "About to call: eval ${requestComp}"
+
+    # Use eval to handle any environment variables and such
+    out=$(eval ${requestComp} 2>/dev/null)
+    __vgo_debug "completion output: ${out}"
+
+    # Extract the directive integer following a : from the last line
+    local lastLine
+    while IFS='\n' read -r line; do
+        lastLine=${line}
+    done < <(printf "%s\n" "${out[@]}")
+    __vgo_debug "last line: ${lastLine}"
+
+    if [ "${lastLine[1]}" = : ]; then
+        directive=${lastLine[2,-1]}
+        # Remove the directive including the : and the newline
+        local suffix
+        (( suffix=${#lastLine}+2))
+        out=${out[1,-$suffix]}
+    else
+        # There is no directive specified.  Leave $out as is.
+        __vgo_debug "No directive found.  Setting do default"
+        directive=0
+    fi
+
+    __vgo_debug "directive: ${directive}"
+    __vgo_debug "completions: ${out}"
+    __vgo_debug "flagPrefix: ${flagPrefix}"
+
+    if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
+        __vgo_debug "Completion received error. Ignoring completions."
+        return
+    fi
+
+    local activeHelpMarker="_activeHelp_ "
+    local endIndex=${#activeHelpMarker}
+    local startIndex=$((${#activeHelpMarker}+1))
+    local hasActiveHelp=0
+    while IFS='\n' read -r comp; do
+        # Check if this is an activeHelp statement (i.e., prefixed with $activeHelpMarker)
+        if [ "${comp[1,$endIndex]}" = "$activeHelpMarker" ];then
+            __vgo_debug "ActiveHelp found: $comp"
+            comp="${comp[$startIndex,-1]}"
+            if [ -n "$comp" ]; then
+                compadd -x "${comp}"
+                __vgo_debug "ActiveHelp will need delimiter"
+                hasActiveHelp=1
+            fi
+
+            continue
+        fi
+
+        if [ -n "$comp" ]; then
+            # If requested, completions are returned with a description.
+            # The description is preceded by a TAB character.
+            # For zsh's _describe, we need to use a : instead of a TAB.
+            # We first need to escape any : as part of the completion itself.
+            comp=${comp//:/\\:}
+
+            local tab="$(printf '\t')"
+            comp=${comp//$tab/:}
+
+            __vgo_debug "Adding completion: ${comp}"
+            completions+=${comp}
+            lastComp=$comp
+        fi
+    done < <(printf "%s\n" "${out[@]}")
+
+    # Add a delimiter after the activeHelp statements, but only if:
+    # - there are completions following the activeHelp statements, or
+    # - file completion will be performed (so there will be choices after the activeHelp)
+    if [ $hasActiveHelp -eq 1 ]; then
+        if [ ${#completions} -ne 0 ] || [ $((directive & shellCompDirectiveNoFileComp)) -eq 0 ]; then
+            __vgo_debug "Adding activeHelp delimiter"
+            compadd -x "--"
+            hasActiveHelp=0
+        fi
+    fi
+
+    if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
+        __vgo_debug "Activating nospace."
+        noSpace="-S ''"
+    fi
+
+    if [ $((directive & shellCompDirectiveKeepOrder)) -ne 0 ]; then
+        __vgo_debug "Activating keep order."
+        keepOrder="-V"
+    fi
+
+    if [ $((directive & shellCompDirectiveFilterFileExt)) -ne 0 ]; then
+        # File extension filtering
+        local filteringCmd
+        filteringCmd='_files'
+        for filter in ${completions[@]}; do
+            if [ ${filter[1]} != '*' ]; then
+                # zsh requires a glob pattern to do file filtering
+                filter="\*.$filter"
+            fi
+            filteringCmd+=" -g $filter"
+        done
+        filteringCmd+=" ${flagPrefix}"
+
+        __vgo_debug "File filtering command: $filteringCmd"
+        _arguments '*:filename:'"$filteringCmd"
+    elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then
+        # File completion for directories only
+        local subdir
+        subdir="${completions[1]}"
+        if [ -n "$subdir" ]; then
+            __vgo_debug "Listing directories in $subdir"
+            pushd "${subdir}" >/dev/null 2>&1
+        else
+            __vgo_debug "Listing directories in ."
+        fi
+
+        local result
+        _arguments '*:dirname:_files -/'" ${flagPrefix}"
+        result=$?
+        if [ -n "$subdir" ]; then
+            popd >/dev/null 2>&1
+        fi
+        return $result
+    else
+        __vgo_debug "Calling _describe"
+        if eval _describe $keepOrder "completions" completions $flagPrefix $noSpace; then
+            __vgo_debug "_describe found some completions"
+
+            # Return the success of having called _describe
+            return 0
+        else
+            __vgo_debug "_describe did not find completions."
+            __vgo_debug "Checking if we should do file completion."
+            if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
+                __vgo_debug "deactivating file completion"
+
+                # We must return an error code here to let zsh know that there were no
+                # completions found by _describe; this is what will trigger other
+                # matching algorithms to attempt to find completions.
+                # For example zsh can match letters in the middle of words.
+                return 1
+            else
+                # Perform file completion
+                __vgo_debug "Activating file completion"
+
+                # We must return the result of this command, so it must be the
+                # last command, or else we must store its result to return it.
+                _arguments '*:filename:_files'" ${flagPrefix}"
+            fi
+        fi
+    fi
+}
+
+# don't run the completion function when being source-ed or eval-ed
+if [ "$funcstack[1]" = "_vgo" ]; then
+    _vgo
+fi

zsh/zshrc

@@ -1,13 +1,13 @@
 source ~/.config/zsh/antigen.zsh
 
 if command -v git >/dev/null && [ ! -d ~/.config/zsh/powerlevel10k ]; then
-  echo "info: installing p10k"
+	echo "info: installing p10k"
-  git clone --depth 1 --single-branch https://github.com/romkatv/powerlevel10k.git ~/.config/zsh/powerlevel10k
+	git clone --depth 1 --single-branch https://github.com/romkatv/powerlevel10k.git ~/.config/zsh/powerlevel10k
 fi
 source ~/.config/zsh/powerlevel10k/powerlevel10k.zsh-theme
 
 if [[ -r "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh" ]]; then
-  source "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh"
+	source "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh"
 fi
 
 source ~/.config/zsh/powerlevel10k/powerlevel10k.zsh-theme
@@ -23,16 +23,18 @@ antigen apply
 
 # Exports
 
-# export GOROOT=$HOME/work/go
+#export GOPROXY=https://proxy.neonxp.ru
-export GOPATH=$HOME/go
-export GOPROXY=https://proxy.neonxp.ru
 export EDITOR="nvim"
 #export DOCKER_HOST=unix://$XDG_RUNTIME_DIR/docker.sock
-export PATH=$PATH:$GOPATH/bin
+export PATH=$PATH:~/.local/bin:~/go/bin
+export GOBIN=~/go/bin
 export GPG_TTY=$(tty)
 export LS_OPTIONS='--color=auto'
 eval "$(dircolors -b)"
 
+fpath+="~/.config/zsh/comp"
+
+
 # Aliases
 alias ls='ls $LS_OPTIONS -F'
 alias l='ls $LS_OPTIONS -F'
@@ -40,19 +42,19 @@ alias j="sudo journalctl"
 alias s='sudo'
 alias sctl="sudo systemctl"
 alias ll="ls -AFhl"
-alias cp="cp -i"                                                # Confirm before overwriting something
+alias cp="cp -i"																								# Confirm before overwriting something
 alias gitpush="git add . && git commit --amend --no-edit && git push -f"
 alias k="kubectl"
 alias yu="ssh-add -e /usr/lib/x86_64-linux-gnu/libykcs11.so; ssh-add -s /usr/lib/x86_64-linux-gnu/libykcs11.so"
 alias m="micro"
 alias n="nvim"
-alias cp="cp -i"                          # confirm before overwriting something
+alias cp="cp -i"													# confirm before overwriting something
-alias df="df -h"                          # human-readable sizes
+alias df="df -h"													# human-readable sizes
-alias free="free -m"                      # show sizes in MB
+alias free="free -m"											# show sizes in MB
 alias np="nano -w PKGBUILD"
 alias gitu='git add . && git commit && git push'
 alias g=git
-
+alias nsh='wl-paste | curl -d @- https://nixshare.ru/upload 2>/dev/null | wl-copy'
 
 [[ ! -f `which exa` ]] || alias ls="exa" && alias ll="exa -l"
 
@@ -60,27 +62,27 @@ alias g=git
 function tk() { mkdir -p $1; cd $1; }
 
 function alert() {
-  notify-send --expire-time=30000 $1 $2 && nohup play ~/.local/share/alarm.wav &
+	notify-send --expire-time=30000 $1 $2 && nohup play ~/.local/share/alarm.wav &
 }
 
 ## Options section
-setopt correct                                                  # Auto correct mistakes
+setopt correct																									# Auto correct mistakes
-setopt extendedglob                                             # Extended globbing. Allows using regular expressions with *
+setopt extendedglob																						 # Extended globbing. Allows using regular expressions with *
-setopt nocaseglob                                               # Case insensitive globbing
+setopt nocaseglob																							 # Case insensitive globbing
-setopt rcexpandparam                                            # Array expension with parameters
+setopt rcexpandparam																						# Array expension with parameters
-setopt nocheckjobs                                              # Don"t warn about running processes when exiting
+setopt nocheckjobs																							# Don"t warn about running processes when exiting
-setopt numericglobsort                                          # Sort filenames numerically when it makes sense
+setopt numericglobsort																					# Sort filenames numerically when it makes sense
-setopt nobeep                                                   # No beep
+setopt nobeep																									 # No beep
-setopt appendhistory                                            # Immediately append history instead of overwriting
+setopt appendhistory																						# Immediately append history instead of overwriting
-setopt histignorealldups                                        # If a new command is a duplicate, remove the older one
+setopt histignorealldups																				# If a new command is a duplicate, remove the older one
-setopt autocd                                                   # if only directory path is entered, cd there.
+setopt autocd																									 # if only directory path is entered, cd there.
-setopt inc_append_history                                       # save commands are added to the history immediately, otherwise only when shell exits.
+setopt inc_append_history																			 # save commands are added to the history immediately, otherwise only when shell exits.
-setopt histignorespace                                          # Don"t save commands that start with space
+setopt histignorespace																					# Don"t save commands that start with space
 
 zstyle ':completion:*' matcher-list 'm:{[:lower:][:upper:]}={[:upper:][:lower:]}' # Case insensitive tab completion
-zstyle ':completion:*' list-colors "${(s.:.)LS_COLORS}"         # Colored completion (different colors for dirs/files/etc)
+zstyle ':completion:*' list-colors "${(s.:.)LS_COLORS}"				 # Colored completion (different colors for dirs/files/etc)
-zstyle ':completion:*' rehash true                              # automatically find new executables in path
+zstyle ':completion:*' rehash true															# automatically find new executables in path
-zstyle ':completion:*' menu select                              # Highlight menu selection
+zstyle ':completion:*' menu select															# Highlight menu selection
 # Speed up completions
 zstyle ':completion:*' accept-exact '*(N)'
 zstyle ':completion:*' use-cache on
@@ -89,11 +91,11 @@ zstyle ':completion:*' cache-path ~/.zsh/cache
 zstyle ":completion:*:processes" command "ps -ax"
 zstyle ":completion:*:*:kill:*:processes" list-colors "=(#b) #([0-9]#)*=0=01;32"
 zstyle ":completion:*:*:kill:*" menu yes select
-zstyle ":completion:*:kill:*"   force-list always
+zstyle ":completion:*:kill:*"	 force-list always
 
 zstyle ":completion:*:processes-names" command "ps -e -o comm="
 zstyle ":completion:*:*:killall:*" menu yes select
-zstyle ":completion:*:killall:*"   force-list always
+zstyle ":completion:*:killall:*"	 force-list always
 
 HISTFILE=~/.zsh_history
 HISTSIZE=100000
@@ -131,56 +133,56 @@ bindkey "^[[A" history-substring-search-up
 bindkey "^[[B" history-substring-search-down
 
 bindkey -e
-bindkey "^[[7~" beginning-of-line                               # Home key
+bindkey "^[[7~" beginning-of-line															 # Home key
-bindkey "^[[H" beginning-of-line                                # Home key
+bindkey "^[[H" beginning-of-line																# Home key
 if [[ "${terminfo[khome]}" != "" ]]; then
-  bindkey "${terminfo[khome]}" beginning-of-line                # [Home] - Go to beginning of line
+	bindkey "${terminfo[khome]}" beginning-of-line								# [Home] - Go to beginning of line
 fi
-bindkey "^[[8~" end-of-line                                     # End key
+bindkey "^[[8~" end-of-line																		 # End key
-bindkey "^[[F" end-of-line                                     # End key
+bindkey "^[[F" end-of-line																		 # End key
 if [[ "${terminfo[kend]}" != "" ]]; then
-  bindkey "${terminfo[kend]}" end-of-line                       # [End] - Go to end of line
+	bindkey "${terminfo[kend]}" end-of-line											 # [End] - Go to end of line
 fi
-bindkey "^[[2~" overwrite-mode                                  # Insert key
+bindkey "^[[2~" overwrite-mode																	# Insert key
-bindkey "^[[3~" delete-char                                     # Delete key
+bindkey "^[[3~" delete-char																		 # Delete key
-bindkey "^[[C"  forward-char                                    # Right key
+bindkey "^[[C"	forward-char																		# Right key
-bindkey "^[[D"  backward-char                                   # Left key
+bindkey "^[[D"	backward-char																	 # Left key
-bindkey "^[[5~" history-beginning-search-backward               # Page up key
+bindkey "^[[5~" history-beginning-search-backward							 # Page up key
-bindkey "^[[6~" history-beginning-search-forward                # Page down key
+bindkey "^[[6~" history-beginning-search-forward								# Page down key
 
 # Navigate words with ctrl+arrow keys
-bindkey "^[Oc" forward-word                                     #
+bindkey "^[Oc" forward-word																		 #
-bindkey "^[Od" backward-word                                    #
+bindkey "^[Od" backward-word																		#
-bindkey "^[[1;5D" backward-word                                 #
+bindkey "^[[1;5D" backward-word																 #
-bindkey "^[[1;5C" forward-word                                  #
+bindkey "^[[1;5C" forward-word																	#
-bindkey "^H" backward-kill-word                                 # delete previous word with ctrl+backspace
+bindkey "^H" backward-kill-word																 # delete previous word with ctrl+backspace
-bindkey "^[[Z" undo                                             # Shift+tab undo last action
+bindkey "^[[Z" undo																						 # Shift+tab undo last action
 
 # ctrl + space accept suggestion
 bindkey "^ " autosuggest-accept
 
 dotenv() {
-    if [ $# -eq 0 ]; then
+	 if [ $# -eq 0 ]; then
-        [ -f .env.gpg ] && set -- .env.gpg "$@"
+			 [ -f .env.gpg ] && set -- .env.gpg "$@"
-        [ -f .env     ] && set -- .env     "$@"
+			 [ -f .env		 ] && set -- .env		 "$@"
-    fi
+	 fi
 
-    set -a
+	 set -a
-    while [ $# -gt 0 ]; do
+	 while [ $# -gt 0 ]; do
-        echo "dotenv: Loading $1"
+			 echo "dotenv: Loading $1"
-        case "$1" in
+			 case "$1" in
-        *.gpg)
+			 *.gpg)
-            eval "$(gpg --quiet --decrypt --yes "$1")"
+					 eval "$(gpg --quiet --decrypt --yes "$1")"
-            ;;
+					 ;;
-        */*)
+			 */*)
-            . "$1"
+					 . "$1"
-            ;;
+					 ;;
-        *)
+			 *)
-            . "./$1"
+					 . "./$1"
-        esac
+			 esac
-        shift
+			 shift
-    done
+	 done
-    set +a
+	 set +a
 }
 
 # Set terminal window and tab/icon title
@@ -191,33 +193,33 @@ dotenv() {
 # Fully supports screen and probably most modern xterm and rxvt
 # (In screen, only short_tab_title is used)
 function title {
-  emulate -L zsh
+	emulate -L zsh
-  setopt prompt_subst
+	setopt prompt_subst
 
-  [[ "$EMACS" == *term* ]] && return
+	[[ "$EMACS" == *term* ]] && return
 
-  # if $2 is unset use $1 as default
+	# if $2 is unset use $1 as default
-  # if it is set and empty, leave it as is
+	# if it is set and empty, leave it as is
-  : ${2=$1}
+	: ${2=$1}
 
-  case "$TERM" in
+	case "$TERM" in
-    xterm*|putty*|rxvt*|konsole*|ansi|mlterm*|alacritty|kitty|wezterm|st*)
+	 xterm*|putty*|rxvt*|konsole*|ansi|mlterm*|alacritty|kitty|wezterm|st*)
-      print -Pn "\e]2;${2:q}\a" # set window name
+		 print -Pn "\e]2;${2:q}\a" # set window name
-      print -Pn "\e]1;${1:q}\a" # set tab name
+		 print -Pn "\e]1;${1:q}\a" # set tab name
-      ;;
+		 ;;
-    screen*|tmux*)
+	 screen*|tmux*)
-      print -Pn "\ek${1:q}\e\\" # set screen hardstatus
+		 print -Pn "\ek${1:q}\e\\" # set screen hardstatus
-      ;;
+		 ;;
-    *)
+	 *)
-    # Try to use terminfo to set the title
+	 # Try to use terminfo to set the title
-    # If the feature is available set title
+	 # If the feature is available set title
-    if [[ -n "$terminfo[fsl]" ]] && [[ -n "$terminfo[tsl]" ]]; then
+	 if [[ -n "$terminfo[fsl]" ]] && [[ -n "$terminfo[tsl]" ]]; then
-      echoti tsl
+		 echoti tsl
-      print -Pn "$1"
+		 print -Pn "$1"
-      echoti fsl
+		 echoti fsl
-    fi
+	 fi
-      ;;
+		 ;;
-  esac
+	esac
 }
 
 ZSH_THEME_TERM_TAB_TITLE_IDLE="%15<..<%~%<<" #15 char left truncated PWD
@@ -225,58 +227,58 @@ ZSH_THEME_TERM_TITLE_IDLE="%n@%m:%~"
 
 # Runs before showing the prompt
 function mzc_termsupport_precmd {
-  [[ "${DISABLE_AUTO_TITLE:-}" == true ]] && return
+	[[ "${DISABLE_AUTO_TITLE:-}" == true ]] && return
-  title $ZSH_THEME_TERM_TAB_TITLE_IDLE $ZSH_THEME_TERM_TITLE_IDLE
+	title $ZSH_THEME_TERM_TAB_TITLE_IDLE $ZSH_THEME_TERM_TITLE_IDLE
 }
 
 # Runs before executing the command
 function mzc_termsupport_preexec {
-  [[ "${DISABLE_AUTO_TITLE:-}" == true ]] && return
+	[[ "${DISABLE_AUTO_TITLE:-}" == true ]] && return
 
-  emulate -L zsh
+	emulate -L zsh
 
-  # split command into array of arguments
+	# split command into array of arguments
-  local -a cmdargs
+	local -a cmdargs
-  cmdargs=("${(z)2}")
+	cmdargs=("${(z)2}")
-  # if running fg, extract the command from the job description
+	# if running fg, extract the command from the job description
-  if [[ "${cmdargs[1]}" = fg ]]; then
+	if [[ "${cmdargs[1]}" = fg ]]; then
-    # get the job id from the first argument passed to the fg command
+	 # get the job id from the first argument passed to the fg command
-    local job_id jobspec="${cmdargs[2]#%}"
+	 local job_id jobspec="${cmdargs[2]#%}"
-    # logic based on jobs arguments:
+	 # logic based on jobs arguments:
-    # http://zsh.sourceforge.net/Doc/Release/Jobs-_0026-Signals.html#Jobs
+	 # http://zsh.sourceforge.net/Doc/Release/Jobs-_0026-Signals.html#Jobs
-    # https://www.zsh.org/mla/users/2007/msg00704.html
+	 # https://www.zsh.org/mla/users/2007/msg00704.html
-    case "$jobspec" in
+	 case "$jobspec" in
-      <->) # %number argument:
+		 <->) # %number argument:
-        # use the same <number> passed as an argument
+			 # use the same <number> passed as an argument
-        job_id=${jobspec} ;;
+			 job_id=${jobspec} ;;
-      ""|%|+) # empty, %% or %+ argument:
+		 ""|%|+) # empty, %% or %+ argument:
-        # use the current job, which appears with a + in $jobstates:
+			 # use the current job, which appears with a + in $jobstates:
-        # suspended:+:5071=suspended (tty output)
+			 # suspended:+:5071=suspended (tty output)
-        job_id=${(k)jobstates[(r)*:+:*]} ;;
+			 job_id=${(k)jobstates[(r)*:+:*]} ;;
-      -) # %- argument:
+		 -) # %- argument:
-        # use the previous job, which appears with a - in $jobstates:
+			 # use the previous job, which appears with a - in $jobstates:
-        # suspended:-:6493=suspended (signal)
+			 # suspended:-:6493=suspended (signal)
-        job_id=${(k)jobstates[(r)*:-:*]} ;;
+			 job_id=${(k)jobstates[(r)*:-:*]} ;;
-      [?]*) # %?string argument:
+		 [?]*) # %?string argument:
-        # use $jobtexts to match for a job whose command *contains* <string>
+			 # use $jobtexts to match for a job whose command *contains* <string>
-        job_id=${(k)jobtexts[(r)*${(Q)jobspec}*]} ;;
+			 job_id=${(k)jobtexts[(r)*${(Q)jobspec}*]} ;;
-      *) # %string argument:
+		 *) # %string argument:
-        # use $jobtexts to match for a job whose command *starts with* <string>
+			 # use $jobtexts to match for a job whose command *starts with* <string>
-        job_id=${(k)jobtexts[(r)${(Q)jobspec}*]} ;;
+			 job_id=${(k)jobtexts[(r)${(Q)jobspec}*]} ;;
-    esac
+	 esac
 
-    # override preexec function arguments with job command
+	 # override preexec function arguments with job command
-    if [[ -n "${jobtexts[$job_id]}" ]]; then
+	 if [[ -n "${jobtexts[$job_id]}" ]]; then
-      1="${jobtexts[$job_id]}"
+		 1="${jobtexts[$job_id]}"
-      2="${jobtexts[$job_id]}"
+		 2="${jobtexts[$job_id]}"
-    fi
+	 fi
-  fi
+	fi
 
-  # cmd name only, or if this is sudo or ssh, the next cmd
+	# cmd name only, or if this is sudo or ssh, the next cmd
-  local CMD=${1[(wr)^(*=*|sudo|ssh|mosh|rake|-*)]:gs/%/%%}
+	local CMD=${1[(wr)^(*=*|sudo|ssh|mosh|rake|-*)]:gs/%/%%}
-  local LINE="${2:gs/%/%%}"
+	local LINE="${2:gs/%/%%}"
 
-  title '$CMD' '%100>...>$LINE%<<'
+	title '$CMD' '%100>...>$LINE%<<'
 }
 
 # URL-encode a string
@@ -296,60 +298,60 @@ function mzc_termsupport_preexec {
 # Returns nonzero if encoding failed.
 #
 # Usage:
-#  zsh_urlencode [-r] [-m] [-P] <string> [<string> ...]
+#	zsh_urlencode [-r] [-m] [-P] <string> [<string> ...]
 #
-#    -r causes reserved characters (;/?:@&=+$,) to be escaped
+#		-r causes reserved characters (;/?:@&=+$,) to be escaped
 #
-#    -m causes "mark" characters (_.!~*''()-) to be escaped
+#		-m causes "mark" characters (_.!~*''()-) to be escaped
 #
-#    -P causes spaces to be encoded as '%20' instead of '+'
+#		-P causes spaces to be encoded as '%20' instead of '+'
 function zsh_urlencode() {
-  emulate -L zsh
+	emulate -L zsh
-  local -a opts
+	local -a opts
-  zparseopts -D -E -a opts r m P
+	zparseopts -D -E -a opts r m P
 
-  local in_str="$@"
+	local in_str="$@"
-  local url_str=""
+	local url_str=""
-  local spaces_as_plus
+	local spaces_as_plus
-  if [[ -z $opts[(r)-P] ]]; then spaces_as_plus=1; fi
+	if [[ -z $opts[(r)-P] ]]; then spaces_as_plus=1; fi
-  local str="$in_str"
+	local str="$in_str"
 
-  # URLs must use UTF-8 encoding; convert str to UTF-8 if required
+	# URLs must use UTF-8 encoding; convert str to UTF-8 if required
-  local encoding=$langinfo[CODESET]
+	local encoding=$langinfo[CODESET]
 
 
-  # Use LC_CTYPE=C to process text byte-by-byte
+	# Use LC_CTYPE=C to process text byte-by-byte
-  local i byte ord LC_ALL=C
+	local i byte ord LC_ALL=C
-  export LC_ALL
+	export LC_ALL
-  local reserved=';/?:@&=+$,'
+	local reserved=';/?:@&=+$,'
-  local mark='_.!~*''()-'
+	local mark='_.!~*''()-'
-  local dont_escape="[A-Za-z0-9"
+	local dont_escape="[A-Za-z0-9"
-  if [[ -z $opts[(r)-r] ]]; then
+	if [[ -z $opts[(r)-r] ]]; then
-    dont_escape+=$reserved
+	 dont_escape+=$reserved
-  fi
+	fi
-  # $mark must be last because of the "-"
+	# $mark must be last because of the "-"
-  if [[ -z $opts[(r)-m] ]]; then
+	if [[ -z $opts[(r)-m] ]]; then
-    dont_escape+=$mark
+	 dont_escape+=$mark
-  fi
+	fi
-  dont_escape+="]"
+	dont_escape+="]"
 
-  # Implemented to use a single printf call and avoid subshells in the loop,
+	# Implemented to use a single printf call and avoid subshells in the loop,
-  # for performance
+	# for performance
-  local url_str=""
+	local url_str=""
-  for (( i = 1; i <= ${#str}; ++i )); do
+	for (( i = 1; i <= ${#str}; ++i )); do
-    byte="$str[i]"
+	 byte="$str[i]"
-    if [[ "$byte" =~ "$dont_escape" ]]; then
+	 if [[ "$byte" =~ "$dont_escape" ]]; then
-      url_str+="$byte"
+		 url_str+="$byte"
-    else
+	 else
-      if [[ "$byte" == " " && -n $spaces_as_plus ]]; then
+		 if [[ "$byte" == " " && -n $spaces_as_plus ]]; then
-        url_str+="+"
+			 url_str+="+"
-      else
+		 else
-        ord=$(( [##16] #byte ))
+			 ord=$(( [##16] #byte ))
-        url_str+="%$ord"
+			 url_str+="%$ord"
-      fi
+		 fi
-    fi
+	 fi
-  done
+	done
-  echo -E "$url_str"
+	echo -E "$url_str"
 }
 
 # Emits the control sequence to notify many terminal emulators
@@ -358,17 +360,17 @@ function zsh_urlencode() {
 # Identifies the directory using a file: URI scheme, including
 # the host name to disambiguate local vs. remote paths.
 function mzc_termsupport_cwd {
-  # Percent-encode the host and path names.
+	# Percent-encode the host and path names.
-  local URL_HOST URL_PATH
+	local URL_HOST URL_PATH
-  URL_HOST="$(zsh_urlencode -P $HOST)" || return 1
+	URL_HOST="$(zsh_urlencode -P $HOST)" || return 1
-  URL_PATH="$(zsh_urlencode -P $PWD)" || return 1
+	URL_PATH="$(zsh_urlencode -P $PWD)" || return 1
 
-  # common control sequence (OSC 7) to set current host and path
+	# common control sequence (OSC 7) to set current host and path
-  printf "\e]7;%s\a" "file://${URL_HOST}${URL_PATH}"
+	printf "\e]7;%s\a" "file://${URL_HOST}${URL_PATH}"
 }
 
 if [ -f env.sh ]; then
-  source ./env.sh
+	source ./env.sh
 fi
 
 [[ ! -f ~/.zshrc.local ]] || source ~/.zshrc.local