cleaning up binary blobs

bin/kitty/lib/kitty/shell-integration/bash/kitty.bash

@@ -1,403 +0,0 @@
-#!/bin/bash
-
-if [[ "$-" != *i* ]] ; then builtin return; fi  # check in interactive mode
-if [[ -z "$KITTY_SHELL_INTEGRATION" ]]; then builtin return; fi
-
-# Load the normal bash startup files
-if [[ -n "$KITTY_BASH_INJECT" ]]; then
-    builtin declare kitty_bash_inject="$KITTY_BASH_INJECT"
-    builtin declare ksi_val="$KITTY_SHELL_INTEGRATION"
-    builtin unset KITTY_SHELL_INTEGRATION  # ensure manual sourcing of this file in bashrc does not have any effect
-    builtin unset KITTY_BASH_INJECT ENV
-    if [[ -z "$HOME" ]]; then HOME=~; fi
-    if [[ -z "$KITTY_BASH_ETC_LOCATION" ]]; then KITTY_BASH_ETC_LOCATION="/etc"; fi
-
-    _ksi_sourceable() {
-        [[ -f "$1" && -r "$1" ]] && builtin return 0; builtin return 1;
-    }
-
-    if [[ -n "$ksi_val" && "$ksi_val" != *no-sudo* && -n "$TERMINFO" && ! ( -r "/usr/share/terminfo/x/xterm-kitty" || -r "/usr/share/terminfo/78/xterm-kitty" ) ]]; then
-        # this must be done before sourcing user bashrc otherwise aliasing of sudo does not work
-        sudo() {
-            # Ensure terminfo is available in sudo
-            builtin local is_sudoedit="n"
-            for arg; do
-                if [[ "$arg" == "-e" || $arg == "--edit" ]]; then
-                    is_sudoedit="y"
-                    builtin break;
-                fi
-                [[ "$arg" != -* && "$arg" != *=* ]] && builtin break  # command found
-            done
-            if [[ "$is_sudoedit" == "y" ]]; then
-                builtin command sudo "$@";
-            else
-                builtin command sudo TERMINFO="$TERMINFO" "$@";
-            fi
-        }
-    fi
-
-    if [[ "$kitty_bash_inject" == *"posix"* ]]; then
-        _ksi_sourceable "$KITTY_BASH_POSIX_ENV" && {
-            builtin source "$KITTY_BASH_POSIX_ENV"
-            builtin export ENV="$KITTY_BASH_POSIX_ENV"
-        }
-    else
-        builtin set +o posix
-        builtin shopt -u inherit_errexit 2>/dev/null  # resetting posix does not clear this
-        if [[ -n "$KITTY_BASH_UNEXPORT_HISTFILE" ]]; then
-            builtin export -n HISTFILE
-            builtin unset KITTY_BASH_UNEXPORT_HISTFILE
-        fi
-
-        # See run_startup_files() in shell.c in the Bash source code
-        if builtin shopt -q login_shell; then
-            if [[ "$kitty_bash_inject" != *"no-profile"* ]]; then
-                _ksi_sourceable "$KITTY_BASH_ETC_LOCATION/profile" && builtin source "$KITTY_BASH_ETC_LOCATION/profile"
-                for _ksi_i in "$HOME/.bash_profile" "$HOME/.bash_login" "$HOME/.profile"; do
-                    _ksi_sourceable "$_ksi_i" && { builtin source "$_ksi_i"; break; }
-                done
-            fi
-        else
-            if [[ "$kitty_bash_inject" != *"no-rc"* ]]; then
-                # Linux distros build bash with -DSYS_BASHRC. Unfortunately, there is
-                # no way to probe bash for it and different distros use different files
-                # Arch, Debian, Ubuntu use /etc/bash.bashrc
-                # Fedora uses /etc/bashrc sourced from ~/.bashrc instead of SYS_BASHRC
-                # Void Linux uses /etc/bash/bashrc
-                for _ksi_i in "$KITTY_BASH_ETC_LOCATION/bash.bashrc" "$KITTY_BASH_ETC_LOCATION/bash/bashrc" ; do
-                    _ksi_sourceable "$_ksi_i" && { builtin source "$_ksi_i"; break; }
-                done
-                if [[ -z "$KITTY_BASH_RCFILE" ]]; then KITTY_BASH_RCFILE="$HOME/.bashrc"; fi
-                _ksi_sourceable "$KITTY_BASH_RCFILE" && builtin source "$KITTY_BASH_RCFILE"
-            fi
-        fi
-    fi
-    builtin unset KITTY_BASH_RCFILE KITTY_BASH_POSIX_ENV KITTY_BASH_ETC_LOCATION
-    builtin unset -f _ksi_sourceable
-    builtin export KITTY_SHELL_INTEGRATION="$ksi_val"
-    builtin unset _ksi_i ksi_val kitty_bash_inject
-fi
-
-
-if [ "${BASH_VERSINFO:-0}" -lt 4 ]; then
-    builtin unset KITTY_SHELL_INTEGRATION
-    builtin printf "%s\n" "Bash version ${BASH_VERSION} too old, kitty shell integration disabled" > /dev/stderr
-    builtin return
-fi
-
-if [ -v "_ksi_prompt[sourced]" ]; then
-    # we have already run
-    builtin unset KITTY_SHELL_INTEGRATION
-    builtin return
-fi
-
-# this is defined outside _ksi_main to make it global without using declare -g
-# which is not available on older bash
-builtin declare -A _ksi_prompt
-_ksi_prompt=(
-    [cursor]='y' [title]='y' [mark]='y' [complete]='y' [cwd]='y' [sudo]='y' [ps0]='' [ps0_suffix]='' [ps1]='' [ps1_suffix]='' [ps2]=''
-    [hostname_prefix]='' [sourced]='y' [last_reported_cwd]=''
-)
-
-_ksi_main() {
-    builtin local ifs="$IFS" i
-    IFS=" "
-    for i in ${KITTY_SHELL_INTEGRATION[@]}; do
-        case "$i" in
-            "no-cursor") _ksi_prompt[cursor]='n';;
-            "no-title") _ksi_prompt[title]='n';;
-            "no-prompt-mark") _ksi_prompt[mark]='n';;
-            "no-complete") _ksi_prompt[complete]='n';;
-            "no-cwd") _ksi_prompt[cwd]='n';;
-            "no-sudo") _ksi_prompt[sudo]='n';;
-        esac
-    done
-    IFS="$ifs"
-
-    builtin unset KITTY_SHELL_INTEGRATION
-    if [[ -n "$SSH_KITTEN_KITTY_DIR" ]]; then
-        if [[ ! "$PATH" =~ (^|:)${SSH_KITTEN_KITTY_DIR}(:|$) ]] && [[ -z "$(builtin command -v kitten)" ]]; then
-            builtin export PATH="${PATH}:${SSH_KITTEN_KITTY_DIR}"
-        fi
-        builtin unset SSH_KITTEN_KITTY_DIR
-    fi
-    builtin local krcs="$KITTY_SI_RUN_COMMAND_AT_STARTUP"
-    builtin unset KITTY_SI_RUN_COMMAND_AT_STARTUP
-
-    _ksi_debug_print() {
-        # print a line to STDERR of parent kitty process
-        builtin local b
-        b=$(builtin command base64 <<< "${@}")
-        builtin printf "\eP@kitty-print|%s\e\\" "${b//[[:space:]]}}"
-    }
-
-    _ksi_set_mark() {
-        _ksi_prompt["${1}_mark"]="\[\e]133;k;${1}_kitty\a\]"
-    }
-
-    _ksi_set_mark start
-    _ksi_set_mark end
-    _ksi_set_mark start_secondary
-    _ksi_set_mark end_secondary
-    _ksi_set_mark start_suffix
-    _ksi_set_mark end_suffix
-    builtin unset -f _ksi_set_mark
-    _ksi_prompt[secondary_prompt]="\n${_ksi_prompt[start_secondary_mark]}\[\e]133;A;k=s\a\]${_ksi_prompt[end_secondary_mark]}"
-
-    _ksi_prompt_command() {
-        # we first remove any previously added kitty code from the prompt variables and then add
-        # it back, to ensure we have only a single instance
-        if [[ -n "${_ksi_prompt[ps0]}" ]]; then
-            PS0=${PS0//\\\[\\e\]133;k;start_kitty\\a\\\]*end_kitty\\a\\\]}
-            PS0="${_ksi_prompt[ps0]}$PS0"
-        fi
-        if [[ -n "${_ksi_prompt[ps0_suffix]}" ]]; then
-            PS0=${PS0//\\\[\\e\]133;k;start_suffix_kitty\\a\\\]*end_suffix_kitty\\a\\\]}
-            PS0="${PS0}${_ksi_prompt[ps0_suffix]}"
-        fi
-        # restore PS1 to its pristine state without our additions
-        if [[ -n "${_ksi_prompt[ps1]}" ]]; then
-            PS1=${PS1//\\\[\\e\]133;k;start_kitty\\a\\\]*end_kitty\\a\\\]}
-            PS1=${PS1//\\\[\\e\]133;k;start_secondary_kitty\\a\\\]*end_secondary_kitty\\a\\\]}
-        fi
-        if [[ -n "${_ksi_prompt[ps1_suffix]}" ]]; then
-            PS1=${PS1//\\\[\\e\]133;k;start_suffix_kitty\\a\\\]*end_suffix_kitty\\a\\\]}
-        fi
-        if [[ -n "${_ksi_prompt[ps1]}" ]]; then
-            if [[ "${_ksi_prompt[mark]}" == "y" && ( "${PS1}" == *"\n"* || "${PS1}" == *$'\n'* ) ]]; then
-                builtin local oldval
-                oldval=$(builtin shopt -p extglob)
-                builtin shopt -s extglob
-                # bash does not redraw the leading lines in a multiline prompt so
-                # mark the last line as a secondary prompt. Otherwise on resize the
-                # lines before the last line will be erased by kitty.
-                # the first part removes everything from the last \n onwards
-                # the second part appends a newline with the secondary marking
-                # the third part appends everything after the last newline
-                PS1=${PS1%@('\n'|$'\n')*}${_ksi_prompt[secondary_prompt]}${PS1##*@('\n'|$'\n')}
-                builtin eval "$oldval"
-            fi
-            PS1="${_ksi_prompt[ps1]}$PS1"
-        fi
-        if [[ -n "${_ksi_prompt[ps1_suffix]}" ]]; then
-            PS1="${PS1}${_ksi_prompt[ps1_suffix]}"
-        fi
-        if [[ -n "${_ksi_prompt[ps2]}" ]]; then
-            PS2=${PS2//\\\[\\e\]133;k;start_kitty\\a\\\]*end_kitty\\a\\\]}
-            PS2="${_ksi_prompt[ps2]}$PS2"
-        fi
-
-        if [[ "${_ksi_prompt[cwd]}" == "y" ]]; then
-            # unfortunately bash provides no hooks to detect cwd changes
-            # in particular this means cwd reporting will not happen for a
-            # command like cd /test && cat. PS0 is evaluated before cd is run.
-            if [[ "${_ksi_prompt[last_reported_cwd]}" != "$PWD" ]]; then
-                _ksi_prompt[last_reported_cwd]="$PWD"
-                builtin printf "\e]7;kitty-shell-cwd://%s%s\a" "$HOSTNAME" "$PWD"
-            fi
-        fi
-    }
-
-    if [[ "${_ksi_prompt[cursor]}" == "y" ]]; then
-        _ksi_prompt[ps1_suffix]+="\[\e[5 q\]"  # blinking bar cursor
-        _ksi_prompt[ps0_suffix]+="\[\e[0 q\]"  # blinking default cursor
-    fi
-
-    if [[ "${_ksi_prompt[title]}" == "y" ||  "${_ksi_prompt[mark]}" ]]; then
-        _ksi_get_current_command() {
-            builtin local last_cmd
-            last_cmd=$(HISTTIMEFORMAT= builtin history 1)
-            last_cmd="${last_cmd#*[[:digit:]]*[[:space:]]}"  # remove leading history number
-            last_cmd="${last_cmd#"${last_cmd%%[![:space:]]*}"}"  # remove remaining leading whitespace
-            if [[ "${_ksi_prompt[title]}" == "y" ]]; then
-                builtin printf "\e]2;%s%s\a" "${_ksi_prompt[hostname_prefix]@P}" "${last_cmd//[[:cntrl:]]}" # removes any control characters
-            fi
-            if [[ "${_ksi_prompt[mark]}" == "y" ]]; then
-                builtin printf "\e]133;C;cmdline=%q\a" "$last_cmd"
-            fi
-        }
-        _ksi_prompt[ps0]+='$(_ksi_get_current_command > /dev/tty)';
-    fi
-
-    if [[ "${_ksi_prompt[title]}" == "y" ]]; then
-        if [[ -z "$KITTY_PID" ]]; then
-            if [[ -n "$SSH_TTY" || -n "$SSH2_TTY$KITTY_WINDOW_ID" ]]; then
-                # connected to most SSH servers
-                # or use ssh kitten to connected to some SSH servers that do not set SSH_TTY
-                _ksi_prompt[hostname_prefix]="\h: "
-            elif [[ -n "$(builtin command -v who)" && "$(builtin command who -m 2> /dev/null)" =~ "\([a-fA-F.:0-9]+\)$" ]]; then
-                # the shell integration script is installed manually on the remote system
-                # the environment variables are cleared after sudo
-                # OpenSSH's sshd creates entries in utmp for every login so use those
-                _ksi_prompt[hostname_prefix]="\h: "
-            fi
-        fi
-        # see https://www.gnu.org/software/bash/manual/html_node/Controlling-the-Prompt.html#Controlling-the-Prompt
-        # we use suffix here because some distros add title setting to their bashrc files by default
-        _ksi_prompt[ps1_suffix]+="\[\e]2;${_ksi_prompt[hostname_prefix]}\w\a\]"
-        if [[ "$HISTCONTROL" == *"ignoreboth"* ]] || [[ "$HISTCONTROL" == *"ignorespace"* ]]; then
-            _ksi_debug_print "ignoreboth or ignorespace present in bash HISTCONTROL setting, showing running command will not be robust"
-        fi
-    fi
-
-    if [[ "${_ksi_prompt[mark]}" == "y" ]]; then
-        # this can result in multiple D prompt marks or ones that dont
-        # correspond to a cmd but kitty handles this gracefully, only
-        # taking into account the first D after a C.
-        _ksi_prompt[ps1]+="\[\e]133;D;\$?\a\e]133;A\a\]"
-        _ksi_prompt[ps2]+="\[\e]133;A;k=s\a\]"
-    fi
-
-    builtin alias edit-in-kitty="kitten edit-in-kitty"
-
-
-    if [[ "${_ksi_prompt[complete]}" == "y" ]]; then
-        _ksi_completions() {
-            builtin local src
-            builtin local limit
-            # Send all words up to the word the cursor is currently on
-            builtin let limit=1+$COMP_CWORD
-            src=$(builtin printf "%s\n" "${COMP_WORDS[@]:0:$limit}" | builtin command kitten __complete__ bash)
-            if [[ $? == 0 ]]; then
-                builtin eval "${src}"
-            fi
-        }
-        builtin complete -F _ksi_completions kitty
-        builtin complete -F _ksi_completions edit-in-kitty
-        builtin complete -F _ksi_completions clone-in-kitty
-        builtin complete -F _ksi_completions kitten
-    fi
-
-    # wrap our prompt additions in markers we can use to remove them using
-    # bash's anemic pattern substitution
-    if [[ -n "${_ksi_prompt[ps0]}" ]]; then
-        _ksi_prompt[ps0]="${_ksi_prompt[start_mark]}${_ksi_prompt[ps0]}${_ksi_prompt[end_mark]}"
-    fi
-    if [[ -n "${_ksi_prompt[ps0_suffix]}" ]]; then
-        _ksi_prompt[ps0_suffix]="${_ksi_prompt[start_suffix_mark]}${_ksi_prompt[ps0_suffix]}${_ksi_prompt[end_suffix_mark]}"
-    fi
-    if [[ -n "${_ksi_prompt[ps1]}" ]]; then
-        _ksi_prompt[ps1]="${_ksi_prompt[start_mark]}${_ksi_prompt[ps1]}${_ksi_prompt[end_mark]}"
-    fi
-    if [[ -n "${_ksi_prompt[ps1_suffix]}" ]]; then
-        _ksi_prompt[ps1_suffix]="${_ksi_prompt[start_suffix_mark]}${_ksi_prompt[ps1_suffix]}${_ksi_prompt[end_suffix_mark]}"
-    fi
-    if [[ -n "${_ksi_prompt[ps2]}" ]]; then
-        _ksi_prompt[ps2]="${_ksi_prompt[start_mark]}${_ksi_prompt[ps2]}${_ksi_prompt[end_mark]}"
-    fi
-    # BASH aborts the entire script when doing unset with failglob set, somebody should report this upstream
-    builtin local oldval
-    oldval=$(builtin shopt -p failglob)
-    builtin shopt -u failglob
-    builtin unset _ksi_prompt[start_mark] _ksi_prompt[end_mark] _ksi_prompt[start_suffix_mark] _ksi_prompt[end_suffix_mark] _ksi_prompt[start_secondary_mark] _ksi_prompt[end_secondary_mark]
-    builtin eval "$oldval"
-
-    # install our prompt command, using an array if it is unset or already an array,
-    # otherwise append a string. We check if _ksi_prompt_command exists as some shell
-    # scripts stupidly export PROMPT_COMMAND making it inherited by all programs launched
-    # from the shell
-    builtin local pc
-    pc='builtin declare -F _ksi_prompt_command > /dev/null 2> /dev/null && _ksi_prompt_command'
-    if [[ -z "${PROMPT_COMMAND[*]}" ]]; then
-        PROMPT_COMMAND=([0]="$pc")
-    elif [[ $(builtin declare -p PROMPT_COMMAND 2> /dev/null) =~ 'declare -a PROMPT_COMMAND' ]]; then
-        PROMPT_COMMAND+=("$pc")
-    else
-        builtin local oldval
-        oldval=$(builtin shopt -p extglob)
-        builtin shopt -s extglob
-        PROMPT_COMMAND="${PROMPT_COMMAND%%+([[:space:]])}"
-        PROMPT_COMMAND="${PROMPT_COMMAND%%+(;)}"
-        builtin eval "$oldval"
-        PROMPT_COMMAND+="; $pc"
-    fi
-    if [ -n "${KITTY_IS_CLONE_LAUNCH}" ]; then
-        builtin local orig_conda_env="$CONDA_DEFAULT_ENV"
-        builtin eval "${KITTY_IS_CLONE_LAUNCH}"
-        builtin hash -r 2> /dev/null 1> /dev/null
-        builtin local venv="${VIRTUAL_ENV}/bin/activate"
-        builtin local sourced=""
-        _ksi_s_is_ok() {
-            [[ -z "$sourced" && "$KITTY_CLONE_SOURCE_STRATEGIES" == *",$1,"* ]] && builtin return 0
-            builtin return 1
-        }
-
-        if _ksi_s_is_ok "venv" && [ -n "${VIRTUAL_ENV}" -a -r "$venv" ]; then
-            sourced="y"
-            builtin unset VIRTUAL_ENV
-            builtin source "$venv"
-        fi; if _ksi_s_is_ok "conda" && [ -n "${CONDA_DEFAULT_ENV}" ] && builtin command -v conda >/dev/null 2>/dev/null && [ "${CONDA_DEFAULT_ENV}" != "$orig_conda_env" ]; then
-            sourced="y"
-            conda activate "${CONDA_DEFAULT_ENV}"
-        fi; if _ksi_s_is_ok "env_var" && [[ -n "${KITTY_CLONE_SOURCE_CODE}" ]]; then
-            sourced="y"
-            builtin eval "${KITTY_CLONE_SOURCE_CODE}"
-        fi; if _ksi_s_is_ok "path" && [[ -r "${KITTY_CLONE_SOURCE_PATH}" ]]; then
-            sourced="y"
-            builtin source "${KITTY_CLONE_SOURCE_PATH}"
-        fi
-        builtin unset -f _ksi_s_is_ok
-        # Ensure PATH has no duplicate entries
-        if [ -n "$PATH" ]; then
-            builtin local old_PATH=$PATH:; PATH=
-            while [ -n "$old_PATH" ]; do
-                builtin local x
-                x=${old_PATH%%:*}
-                case $PATH: in
-                    *:"$x":*) ;;
-                    *) PATH=$PATH:$x;;
-                esac
-                old_PATH=${old_PATH#*:}
-            done
-            PATH=${PATH#:}
-        fi
-    fi
-    builtin unset KITTY_IS_CLONE_LAUNCH KITTY_CLONE_SOURCE_STRATEGIES
-    if [[ -n "$krcs" ]]; then builtin
-        builtin printf "\e]2;%s\a" "${krcs//[[:cntrl:]]}" # removes any control characters
-        eval "$krcs";
-    fi
-}
-_ksi_main
-builtin unset -f _ksi_main
-
-case :$SHELLOPTS: in
-  *:posix:*) ;;
-  *)
-
-_ksi_transmit_data() {
-    builtin local data
-    data="${1//[[:space:]]}"
-    builtin local pos=0
-    builtin local chunk_num=0
-    while [ $pos -lt ${#data} ]; do
-        builtin local chunk="${data:$pos:2048}"
-        pos=$(($pos+2048))
-        builtin printf '\eP@kitty-%s|%s:%s\e\\' "${2}" "${chunk_num}" "${chunk}"
-        chunk_num=$(($chunk_num+1))
-    done
-    # save history so it is available in new shell
-    [ "$3" = "save_history" ] && builtin history -a
-    builtin printf '\eP@kitty-%s|\e\\' "${2}"
-}
-
-clone-in-kitty() {
-    builtin local bv="${BASH_VERSINFO[0]}.${BASH_VERSINFO[1]}.${BASH_VERSINFO[2]}"
-    builtin local data="shell=bash,pid=$$,bash_version=$bv,cwd=$(builtin printf "%s" "$PWD" | builtin command base64),envfmt=bash,env=$(builtin export | builtin command base64)"
-    while :; do
-        case "$1" in
-            "") break;;
-            -h|--help)
-                builtin printf "%s\n\n%s\n" "Clone the current bash session into a new kitty window." "For usage instructions see: https://sw.kovidgoyal.net/kitty/shell-integration/#clone-shell"
-                builtin return
-                ;;
-            *) data="$data,a=$(builtin printf "%s" "$1" | builtin command base64)";;
-        esac
-        shift
-    done
-    _ksi_transmit_data "$data" "clone" "save_history"
-}
-
-      ;;
-esac
-