// ZSHRS — THE FIRST COMPILED UNIX SHELL

#!/usr/bin/env zsh
#
# zdharma-continuum/zinit/zinit-autoload.zsh
# Copyright (c) 2016-2021 Sebastian Gniazdowski
# Copyright (c) 2021-2023 zdharma-continuum
# Homepage: https://github.com/zdharma-continuum/zinit
# License: MIT License
#

builtin source "${ZINIT[BIN_DIR]}/zinit-side.zsh" || { builtin print -P "${ZINIT[col-error]}ERROR:%f%b Couldn't find ${ZINIT[col-obj]}zinit-side.zsh%f%b."; return 1; }

ZINIT[EXTENDED_GLOB]=""

#
# Backend, low level functions
#

# FUNCTION: .zinit-unregister-plugin [[[
# Removes the plugin from ZINIT_REGISTERED_PLUGINS array and from the
# zsh_loaded_plugins array (managed according to the plugin standard)
.zinit-unregister-plugin() {
    .zinit-any-to-user-plugin "$1" "$2"
    local uspl2="${reply[-2]}${${reply[-2]:#(%|/)*}:+/}${reply[-1]}" \
        teleid="$3"

    # If not found, the index will be length+1
    ZINIT_REGISTERED_PLUGINS[${ZINIT_REGISTERED_PLUGINS[(i)$uspl2]}]=()
    # Support Zsh plugin standard
    zsh_loaded_plugins[${zsh_loaded_plugins[(i)$teleid]}]=()
    ZINIT[STATES__$uspl2]="0"
} # ]]]
# FUNCTION: .zinit-diff-functions-compute [[[
# Computes FUNCTIONS that holds new functions added by plugin.
# Uses data gathered earlier by .zinit-diff-functions().
#
# $1 - user/plugin
.zinit-diff-functions-compute() {
    local uspl2="$1"

    # Cannot run diff if *_BEFORE or *_AFTER variable is not set
    # Following is paranoid for *_BEFORE and *_AFTER being only spaces

    builtin setopt localoptions extendedglob nokshglob noksharrays
    [[ "${ZINIT[FUNCTIONS_BEFORE__$uspl2]}" != *[$'! \t']* || "${ZINIT[FUNCTIONS_AFTER__$uspl2]}" != *[$'! \t']* ]] && return 1

    typeset -A func
    local i

    # This includes new functions. Quoting is kept (i.e. no i=${(Q)i})
    for i in "${(z)ZINIT[FUNCTIONS_AFTER__$uspl2]}"; do
        func[$i]=1
    done

    # Remove duplicated entries, i.e. existing before. Quoting is kept
    for i in "${(z)ZINIT[FUNCTIONS_BEFORE__$uspl2]}"; do
        # if would do unset, then: func[opp+a\[]: invalid parameter name
        func[$i]=0
    done

    # Store the functions, associating them with plugin ($uspl2)
    ZINIT[FUNCTIONS__$uspl2]=""
    for i in "${(onk)func[@]}"; do
        [[ "${func[$i]}" = "1" ]] && ZINIT[FUNCTIONS__$uspl2]+="$i "
    done

    return 0
} # ]]]
# FUNCTION: .zinit-diff-options-compute [[[
# Computes OPTIONS that holds options changed by plugin.
# Uses data gathered earlier by .zinit-diff-options().
#
# $1 - user/plugin
.zinit-diff-options-compute() {
    local uspl2="$1"

    # Cannot run diff if *_BEFORE or *_AFTER variable is not set
    # Following is paranoid for *_BEFORE and *_AFTER being only spaces
    builtin setopt localoptions extendedglob nokshglob noksharrays
    [[ "${ZINIT[OPTIONS_BEFORE__$uspl2]}" != *[$'! \t']* || "${ZINIT[OPTIONS_AFTER__$uspl2]}" != *[$'! \t']* ]] && return 1

    typeset -A opts_before opts_after opts
    opts_before=( "${(z)ZINIT[OPTIONS_BEFORE__$uspl2]}" )
    opts_after=( "${(z)ZINIT[OPTIONS_AFTER__$uspl2]}" )
    opts=( )

    # Iterate through first array (keys the same
    # on both of them though) and test for a change
    local key
    for key in "${(k)opts_before[@]}"; do
        if [[ "${opts_before[$key]}" != "${opts_after[$key]}" ]]; then
            opts[$key]="${opts_before[$key]}"
        fi
    done

    # Serialize for reporting
    local IFS=" "
    ZINIT[OPTIONS__$uspl2]="${(kv)opts[@]}"
    return 0
} # ]]]
# FUNCTION: .zinit-diff-env-compute [[[
# Computes ZINIT_PATH, ZINIT_FPATH that hold (f)path components
# added by plugin. Uses data gathered earlier by .zinit-diff-env().
#
# $1 - user/plugin
.zinit-diff-env-compute() {
    local uspl2="$1"
    typeset -a tmp

    # Cannot run diff if *_BEFORE or *_AFTER variable is not set
    # Following is paranoid for *_BEFORE and *_AFTER being only spaces
    builtin setopt localoptions extendedglob nokshglob noksharrays
    [[ "${ZINIT[PATH_BEFORE__$uspl2]}" != *[$'! \t']* || "${ZINIT[PATH_AFTER__$uspl2]}" != *[$'! \t']* ]] && return 1
    [[ "${ZINIT[FPATH_BEFORE__$uspl2]}" != *[$'! \t']* || "${ZINIT[FPATH_AFTER__$uspl2]}" != *[$'! \t']* ]] && return 1

    typeset -A path_state fpath_state
    local i

    #
    # PATH processing
    #

    # This includes new path elements
    for i in "${(z)ZINIT[PATH_AFTER__$uspl2]}"; do
        path_state[${(Q)i}]=1
    done

    # Remove duplicated entries, i.e. existing before
    for i in "${(z)ZINIT[PATH_BEFORE__$uspl2]}"; do
        unset "path_state[${(Q)i}]"
    done

    # Store the path elements, associating them with plugin ($uspl2)
    ZINIT[PATH__$uspl2]=""
    for i in "${(onk)path_state[@]}"; do
        ZINIT[PATH__$uspl2]+="${(q)i} "
    done

    #
    # FPATH processing
    #

    # This includes new path elements
    for i in "${(z)ZINIT[FPATH_AFTER__$uspl2]}"; do
        fpath_state[${(Q)i}]=1
    done

    # Remove duplicated entries, i.e. existing before
    for i in "${(z)ZINIT[FPATH_BEFORE__$uspl2]}"; do
        unset "fpath_state[${(Q)i}]"
    done

    # Store the path elements, associating them with plugin ($uspl2)
    ZINIT[FPATH__$uspl2]=""
    for i in "${(onk)fpath_state[@]}"; do
        ZINIT[FPATH__$uspl2]+="${(q)i} "
    done

    return 0
} # ]]]
# FUNCTION: .zinit-diff-parameter-compute [[[
# Computes ZINIT_PARAMETERS_PRE, ZINIT_PARAMETERS_POST that hold
# parameters created or changed (their type) by plugin. Uses
# data gathered earlier by .zinit-diff-parameter().
#
# $1 - user/plugin
.zinit-diff-parameter-compute() {
    local uspl2="$1"
    typeset -a tmp

    # Cannot run diff if *_BEFORE or *_AFTER variable is not set
    # Following is paranoid for *_BEFORE and *_AFTER being only spaces
    builtin setopt localoptions extendedglob nokshglob noksharrays
    [[ "${ZINIT[PARAMETERS_BEFORE__$uspl2]}" != *[$'! \t']* || "${ZINIT[PARAMETERS_AFTER__$uspl2]}" != *[$'! \t']* ]] && return 1

    # Un-concatenated parameters from moment of diff start and of diff end
    typeset -A params_before params_after
    params_before=( "${(z)ZINIT[PARAMETERS_BEFORE__$uspl2]}" )
    params_after=( "${(z)ZINIT[PARAMETERS_AFTER__$uspl2]}" )

    # The parameters that changed, with save of what
    # parameter was when diff started or when diff ended
    typeset -A params_pre params_post
    params_pre=( )
    params_post=( )

    # Iterate through all existing keys, before or after diff,
    # i.e. after all variables that were somehow live across
    # the diffing process
    local key
    typeset -aU keys
    keys=( "${(k)params_after[@]}" );
    keys=( "${keys[@]}" "${(k)params_before[@]}" );
    for key in "${keys[@]}"; do
        key="${(Q)key}"
        [[ "${params_after[$key]}" = *local* ]] && continue
        if [[ "${params_after[$key]}" != "${params_before[$key]}" ]]; then
            # Empty for a new param, a type otherwise
            [[ -z "${params_before[$key]}" ]] && params_before[$key]="\"\""
            params_pre[$key]="${params_before[$key]}"

            # Current type, can also be empty, when plugin
            # unsets a parameter
            [[ -z "${params_after[$key]}" ]] && params_after[$key]="\"\""
            params_post[$key]="${params_after[$key]}"
        fi
    done

    # Serialize for reporting
    ZINIT[PARAMETERS_PRE__$uspl2]="${(j: :)${(qkv)params_pre[@]}}"
    ZINIT[PARAMETERS_POST__$uspl2]="${(j: :)${(qkv)params_post[@]}}"

    return 0
} # ]]]
# FUNCTION: .zinit-any-to-uspl2 [[[
# Converts given plugin-spec to format that's used in keys for hash tables.
# So basically, creates string "user/plugin" (this format is called: uspl2).
#
# $1 - plugin spec (4 formats: user---plugin, user/plugin, user, plugin)
# $2 - (optional) plugin (only when $1 - i.e. user - given)
.zinit-any-to-uspl2() {
    .zinit-any-to-user-plugin "$1" "$2"
    [[ "${reply[-2]}" = "%" ]] && REPLY="${reply[-2]}${reply[-1]}" || REPLY="${reply[-2]}${${reply[-2]:#(%|/)*}:+/}${reply[-1]//---//}"
} # ]]]
# FUNCTION: .zinit-save-set-extendedglob [[[
# Enables extendedglob-option first saving if it was already
# enabled, for restoration of this state later.
.zinit-save-set-extendedglob() {
    [[ -o "extendedglob" ]] && ZINIT[EXTENDED_GLOB]="1" || ZINIT[EXTENDED_GLOB]="0"
    builtin setopt extendedglob
} # ]]]
# FUNCTION: .zinit-restore-extendedglob [[[
# Restores extendedglob-option from state saved earlier.
.zinit-restore-extendedglob() {
    [[ "${ZINIT[EXTENDED_GLOB]}" = "0" ]] && builtin unsetopt extendedglob || builtin setopt extendedglob
} # ]]]
# FUNCTION: .zinit-prepare-readlink [[[
# Prepares readlink command, used for establishing completion's owner.
#
# $REPLY = ":" or "readlink"
.zinit-prepare-readlink() {
    REPLY=":"
    if type readlink 2>/dev/null 1>&2; then
        REPLY="readlink"
    fi
} # ]]]
# FUNCTION: .zinit-clear-report-for [[[
# Clears all report data for given user/plugin. This is
# done by resetting all related global ZINIT_* hashes.
#
# $1 - plugin spec (4 formats: user---plugin, user/plugin, user, plugin)
# $2 - (optional) plugin (only when $1 - i.e. user - given)
.zinit-clear-report-for() {
    .zinit-any-to-uspl2 "$1" "$2"

    # Shadowing
    ZINIT_REPORTS[$REPLY]=""
    ZINIT[BINDKEYS__$REPLY]=""
    ZINIT[ZSTYLES__$REPLY]=""
    ZINIT[ALIASES__$REPLY]=""
    ZINIT[WIDGETS_SAVED__$REPLY]=""
    ZINIT[WIDGETS_DELETE__$REPLY]=""

    # Function diffing
    ZINIT[FUNCTIONS__$REPLY]=""
    ZINIT[FUNCTIONS_BEFORE__$REPLY]=""
    ZINIT[FUNCTIONS_AFTER__$REPLY]=""

    # Option diffing
    ZINIT[OPTIONS__$REPLY]=""
    ZINIT[OPTIONS_BEFORE__$REPLY]=""
    ZINIT[OPTIONS_AFTER__$REPLY]=""

    # Environment diffing
    ZINIT[PATH__$REPLY]=""
    ZINIT[PATH_BEFORE__$REPLY]=""
    ZINIT[PATH_AFTER__$REPLY]=""
    ZINIT[FPATH__$REPLY]=""
    ZINIT[FPATH_BEFORE__$REPLY]=""
    ZINIT[FPATH_AFTER__$REPLY]=""

    # Parameter diffing
    ZINIT[PARAMETERS_PRE__$REPLY]=""
    ZINIT[PARAMETERS_POST__$REPLY]=""
    ZINIT[PARAMETERS_BEFORE__$REPLY]=""
    ZINIT[PARAMETERS_AFTER__$REPLY]=""
} # ]]]
# FUNCTION: .zinit-exists-message [[[
# Checks if plugin is loaded. Testable. Also outputs error
# message if plugin is not loaded.
#
# $1 - plugin spec (4 formats: user---plugin, user/plugin, user, plugin)
# $2 - (optional) plugin (only when $1 - i.e. user - given)
.zinit-exists-message() {
    .zinit-any-to-uspl2 "$1" "$2"
    if [[ -z "${ZINIT_REGISTERED_PLUGINS[(r)$REPLY]}" ]]; then
        .zinit-any-colorify-as-uspl2 "$1" "$2"
        builtin print "${ZINIT[col-error]}No such plugin${ZINIT[col-rst]} $REPLY"
        return 1
    fi
    return 0
} # ]]]
# FUNCTION: .zinit-at-eval [[[
.zinit-at-eval() {
    local atclone="$2" atpull="$1"
    integer retval
    @zinit-substitute atclone atpull
    [[ $atpull = "%atclone" ]] && { eval "$atclone"; retval=$?; } || { eval "$atpull"; retval=$?; }
    return $retval
} # ]]]

#
# Format functions
#

# FUNCTION: .zinit-format-functions [[[
# Creates a one or two columns text with functions created
# by given plugin.
#
# $1 - user/plugin (i.e. uspl2 format of plugin-spec)
.zinit-format-functions() {
    local uspl2="$1"

    typeset -a func
    func=( "${(z)ZINIT[FUNCTIONS__$uspl2]}" )

    # Get length of longest left-right string pair,
    # and length of longest left string
    integer longest=0 longest_left=0 cur_left_len=0 count=1
    local f
    for f in "${(on)func[@]}"; do
        [[ -z "${#f}" ]] && continue
        f="${(Q)f}"

        # Compute for elements in left column,
        # ones that will be paded with spaces
        if (( count ++ % 2 != 0 )); then
            [[ "${#f}" -gt "$longest_left" ]] && longest_left="${#f}"
            cur_left_len="${#f}"
        else
            cur_left_len+="${#f}"
            cur_left_len+=1 # For separating space
            [[ "$cur_left_len" -gt "$longest" ]] && longest="$cur_left_len"
        fi
    done

    # Output in one or two columns
    local answer=""
    count=1
    for f in "${(on)func[@]}"; do
        [[ -z "$f" ]] && continue
        f="${(Q)f}"

        if (( COLUMNS >= longest )); then
            if (( count ++ % 2 != 0 )); then
                answer+="${(r:longest_left+1:: :)f}"
            else
                answer+="$f"$'\n'
            fi
        else
            answer+="$f"$'\n'
        fi
    done
    REPLY="$answer"
    # == 0 is: next element would have newline (postfix addition in "count ++")
    (( COLUMNS >= longest && count % 2 == 0 )) && REPLY="$REPLY"$'\n'
} # ]]]
# FUNCTION: .zinit-format-options [[[
# Creates one-column text about options that changed when
# plugin "$1" was loaded.
#
# $1 - user/plugin (i.e. uspl2 format of plugin-spec)
.zinit-format-options() {
    local uspl2="$1"

    REPLY=""

    # Paranoid, don't want bad key/value pair error
    integer empty=0
    .zinit-save-set-extendedglob
    [[ "${ZINIT[OPTIONS__$uspl2]}" != *[$'! \t']* ]] && empty=1
    .zinit-restore-extendedglob
    (( empty )) && return 0

    typeset -A opts
    opts=( "${(z)ZINIT[OPTIONS__$uspl2]}" )

    # Get length of longest option
    integer longest=0
    local k
    for k in "${(kon)opts[@]}"; do
        [[ "${#k}" -gt "$longest" ]] && longest="${#k}"
    done

    # Output in one column
    local txt
    for k in "${(kon)opts[@]}"; do
        [[ "${opts[$k]}" = "on" ]] && txt="was unset" || txt="was set"
        REPLY+="${(r:longest+1:: :)k}$txt"$'\n'
    done
} # ]]]
# FUNCTION: .zinit-format-env [[[
# Creates one-column text about FPATH or PATH elements
# added when given plugin was loaded.
#
# $1 - user/plugin (i.e. uspl2 format of plugin-spec)
# $2 - if 1, then examine PATH, if 2, then examine FPATH
.zinit-format-env() {
    local uspl2="$1" which="$2"

    # Format PATH?
    if [[ "$which" = "1" ]]; then
        typeset -a elem
        elem=( "${(z@)ZINIT[PATH__$uspl2]}" )
    elif [[ "$which" = "2" ]]; then
        typeset -a elem
        elem=( "${(z@)ZINIT[FPATH__$uspl2]}" )
    fi

    # Enumerate elements added
    local answer="" e
    for e in "${elem[@]}"; do
        [[ -z "$e" ]] && continue
        e="${(Q)e}"
        answer+="$e"$'\n'
    done

    [[ -n "$answer" ]] && REPLY="$answer"
} # ]]]
# FUNCTION: .zinit-format-parameter [[[
# Creates one column text that lists global parameters that
# changed when the given plugin was loaded.
#
# $1 - user/plugin (i.e. uspl2 format of plugin-spec)
.zinit-format-parameter() {
    local uspl2="$1" infoc="${ZINIT[col-info]}" k

    builtin setopt localoptions extendedglob nokshglob noksharrays
    REPLY=""
    [[ "${ZINIT[PARAMETERS_PRE__$uspl2]}" != *[$'! \t']* || "${ZINIT[PARAMETERS_POST__$uspl2]}" != *[$'! \t']* ]] && return 0

    typeset -A elem_pre elem_post
    elem_pre=( "${(z)ZINIT[PARAMETERS_PRE__$uspl2]}" )
    elem_post=( "${(z)ZINIT[PARAMETERS_POST__$uspl2]}" )

    # Find longest key and longest value
    integer longest=0 vlongest1=0 vlongest2=0
    local v1 v2
    for k in "${(k)elem_post[@]}"; do
        k="${(Q)k}"
        [[ "${#k}" -gt "$longest" ]] && longest="${#k}"

        v1="${(Q)elem_pre[$k]}"
        v2="${(Q)elem_post[$k]}"
        [[ "${#v1}" -gt "$vlongest1" ]] && vlongest1="${#v1}"
        [[ "${#v2}" -gt "$vlongest2" ]] && vlongest2="${#v2}"
    done

    # Enumerate parameters that changed. A key
    # always exists in both of the arrays
    local answer="" k
    for k in "${(k)elem_post[@]}"; do
        v1="${(Q)elem_pre[$k]}"
        v2="${(Q)elem_post[$k]}"
        k="${(Q)k}"

        k="${(r:longest+1:: :)k}"
        v1="${(l:vlongest1+1:: :)v1}"
        v2="${(r:vlongest2+1:: :)v2}"
        answer+="$k ${infoc}[$v1 -> $v2]${ZINIT[col-rst]}"$'\n'
    done

    [[ -n "$answer" ]] && REPLY="$answer"

    return 0
} # ]]]

#
# Completion functions
#

# FUNCTION: .zinit-get-completion-owner [[[
# Returns "user---plugin" string (uspl1 format) of plugin that
# owns given completion.
#
# Both :A and readlink will be used, then readlink's output if
# results differ. Readlink might not be available.
#
# :A will read the link "twice" and give the final repository
# directory, possibly without username in the uspl format;
# readlink will read the link "once"
#
# $1 - absolute path to completion file (in COMPLETIONS_DIR)
# $2 - readlink command (":" or "readlink")
.zinit-get-completion-owner() {
    setopt localoptions extendedglob nokshglob noksharrays noshwordsplit
    local cpath="$1"
    local readlink_cmd="$2"
    local in_plugin_path tmp

    # Try to go not too deep into resolving the symlink,
    # to have the name as it is in .zinit/plugins
    # :A goes deep, descends fully to origin directory
    # Readlink just reads what symlink points to
    in_plugin_path="${cpath:A}"
    tmp=$( "$readlink_cmd" "$cpath" )
    # This in effect works as: "if different, then readlink"
    [[ -n "$tmp" ]] && in_plugin_path="$tmp"

    if [[ "$in_plugin_path" != "$cpath" && -r "$in_plugin_path" ]]; then
        # Get the user---plugin part of path
        while [[ "$in_plugin_path" != ${ZINIT[PLUGINS_DIR]}/[^/]## && "$in_plugin_path" != "/" && "$in_plugin_path" != "." ]]; do
            in_plugin_path="${in_plugin_path:h}"
        done
        in_plugin_path="${in_plugin_path:t}"

        if [[ -z "$in_plugin_path" ]]; then
            in_plugin_path="${tmp:h}"
        fi
    else
        # readlink and :A have nothing
        in_plugin_path="[unknown]"
    fi

    REPLY="$in_plugin_path"
} # ]]]
# FUNCTION: .zinit-get-completion-owner-uspl2col [[[
# For shortening of code - returns colorized plugin name
# that owns given completion.
#
# $1 - absolute path to completion file (in COMPLETIONS_DIR)
# $2 - readlink command (":" or "readlink")
.zinit-get-completion-owner-uspl2col() {
    # "cpath" "readline_cmd"
    .zinit-get-completion-owner "$1" "$2"
    .zinit-any-colorify-as-uspl2 "$REPLY"
} # ]]]
# FUNCTION: .zinit-find-completions-of-plugin [[[
# Searches for completions owned by given plugin.
# Returns them in `reply' array.
#
# $1 - plugin spec (4 formats: user---plugin, user/plugin, user, plugin)
# $2 - plugin (only when $1 - i.e. user - given)
.zinit-find-completions-of-plugin() {
    builtin setopt localoptions nullglob extendedglob nokshglob noksharrays
    .zinit-any-to-user-plugin "$1" "$2"
    local user="${reply[-2]}" plugin="${reply[-1]}" uspl
    [[ "$user" = "%" ]] && uspl="${user}${plugin}" || uspl="${reply[-2]}${reply[-2]:+---}${reply[-1]//\//---}"

    reply=( "${ZINIT[PLUGINS_DIR]}/$uspl"/**/_[^_.]*~*(*.zwc|*.html|*.txt|*.png|*.jpg|*.jpeg|*.js|*.md|*.yml|*.ri|_zsh_highlight*|/zsdoc/*|*.ps1)(DN) )
} # ]]]
# FUNCTION: .zinit-check-comp-consistency [[[
# Zinit creates symlink for each installed completion.
# This function checks whether given completion (i.e.
# file like "_mkdir") is indeed a symlink. Backup file
# is a completion that is disabled - has the leading "_"
# removed.
#
# $1 - path to completion within plugin's directory
# $2 - path to backup file within plugin's directory
.zinit-check-comp-consistency() {
    local cfile="$1" bkpfile="$2"
    integer error="$3"

    # bkpfile must be a symlink
    if [[ -e "$bkpfile" && ! -L "$bkpfile" ]]; then
        builtin print "${ZINIT[col-error]}Warning: completion's backup file \`${bkpfile:t}' isn't a symlink${ZINIT[col-rst]}"
        error=1
    fi

    # cfile must be a symlink
    if [[ -e "$cfile" && ! -L "$cfile" ]]; then
        builtin print "${ZINIT[col-error]}Warning: completion file \`${cfile:t}' isn't a symlink${ZINIT[col-rst]}"
        error=1
    fi

    # Tell user that he can manually modify but should do it right
    (( error )) && builtin print "${ZINIT[col-error]}Manual edit of ${ZINIT[COMPLETIONS_DIR]} occured?${ZINIT[col-rst]}"
} # ]]]
# FUNCTION: .zinit-check-which-completions-are-installed [[[
# For each argument that each should be a path to completion
# within a plugin's dir, it checks whether that completion
# is installed - returns 0 or 1 on corresponding positions
# in reply.
#
# $1, ... - path to completion within plugin's directory
.zinit-check-which-completions-are-installed() {
    local i cfile bkpfile
    reply=( )
    for i in "$@"; do
        cfile="${i:t}"
        bkpfile="${cfile#_}"

        if [[ -e "${ZINIT[COMPLETIONS_DIR]}"/"$cfile" || -e "${ZINIT[COMPLETIONS_DIR]}"/"$bkpfile" ]]; then
            reply+=( "1" )
        else
            reply+=( "0" )
        fi
    done
} # ]]]
# FUNCTION: .zinit-check-which-completions-are-enabled [[[
# For each argument that each should be a path to completion
# within a plugin's dir, it checks whether that completion
# is disabled - returns 0 or 1 on corresponding positions
# in reply.
#
# Uninstalled completions will be reported as "0"
# - i.e. disabled
#
# $1, ... - path to completion within plugin's directory
.zinit-check-which-completions-are-enabled() {
    local i cfile
    reply=( )
    for i in "$@"; do
        cfile="${i:t}"

        if [[ -e "${ZINIT[COMPLETIONS_DIR]}"/"$cfile" ]]; then
            reply+=( "1" )
        else
            reply+=( "0" )
        fi
    done
} # ]]]
# FUNCTION: .zinit-uninstall-completions [[[
# Removes all completions of given plugin from Zshell (i.e. from FPATH).
# The FPATH is typically `~/.zinit/completions/'.
#
# $1 - plugin spec (4 formats: user---plugin, user/plugin, user, plugin)
# $2 - plugin (only when $1 - i.e. user - given)
.zinit-uninstall-completions() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    builtin setopt nullglob extendedglob warncreateglobal typesetsilent noshortloops

    typeset -a completions symlinked backup_comps
    local c cfile bkpfile
    integer action global_action=0

    .zinit-get-path "$1" "$2"
    [[ -e $REPLY ]] && {
        completions=( $REPLY/**/_[^_.]*~*(*.zwc|*.html|*.txt|*.png|*.jpg|*.jpeg|*.js|*.md|*.yml|*.ri|_zsh_highlight*|/zsdoc/*|*.ps1)(DN) )
    } || {
        builtin print "No completions found for \`$1${${1:#(%|/)*}:+${2:+/}}$2'"
        return 1
    }

    symlinked=( ${ZINIT[COMPLETIONS_DIR]}/_[^_.]*~*.zwc )
    backup_comps=( ${ZINIT[COMPLETIONS_DIR]}/[^_.]*~*.zwc )

    (( ${+functions[.zinit-forget-completion]} )) || builtin source ${ZINIT[BIN_DIR]}"/zinit-install.zsh"

    # Delete completions if they are really there, either
    # as completions (_fname) or backups (fname)
    for c in ${completions[@]}; do
        action=0
        cfile=${c:t}
        bkpfile=${cfile#_}

        # Remove symlink to completion
        if [[ -n ${symlinked[(r)*/$cfile]} ]]; then
            command rm -f ${ZINIT[COMPLETIONS_DIR]}/$cfile
            action=1
        fi

        # Remove backup symlink (created by cdisable)
        if [[ -n ${backup_comps[(r)*/$bkpfile]} ]]; then
            command rm -f ${ZINIT[COMPLETIONS_DIR]}/$bkpfile
            action=1
        fi

        if (( action )); then
            +zi-log "{info}Uninstalling completion \`{file}$cfile{info}'{…}{rst}"
            # Make compinit notice the change
            .zinit-forget-completion "$cfile"
            (( global_action ++ ))
        else
            +zi-log "{info}Completion \`{file}$cfile{info}' not installed.{rst}"
        fi
    done

    if (( global_action > 0 )); then
        +zi-log "{info}Uninstalled {num}$global_action{info} completions.{rst}"
    fi

    .zinit-compinit >/dev/null
} # ]]]

#
# User-exposed functions
#

# FUNCTION: .zinit-pager [[[
# BusyBox less lacks the -X and -i options, so it can use more
.zinit-pager() {
    setopt LOCAL_OPTIONS EQUALS

    # Check if a non-interactive mode has been requested, either via a flag or a global setting.
    if (( OPTS[opt_-n,--no-pager] )) || [[ ${ZINIT[NO_PAGER]} = (1|true|on|yes) ]]; then
        # NON-INTERACTIVE MODE
        local max_lines=${ZINIT[NO_PAGER_MAX_LINES]}

        # Check if a line limit is explicitly set and is a valid non-negative integer.
        if [[ $max_lines =~ ^[0-9]+$ ]]; then
            if (( max_lines > 0 )); then
                # A positive number means limit the output to that many lines.
                head -n "$max_lines"
            else
                # A value of 0 means suppress all output from the pager completely.
                # `cat > /dev/null` is the most robust way to achieve this.
                cat > /dev/null
            fi
        else
            # No valid line limit is set, so show the full output without interaction.
            cat
        fi
        return 0
    else
        # INTERACTIVE MODE (Original Behavior)
        # Fall back to the default interactive pager if no non-interactive mode is set.
        if [[ ${${:-=less}:A:t} = busybox* ]] {
            more 2>/dev/null
            (( ${+commands[more]} ))
        } else {
            less -FRXi 2>/dev/null
            (( ${+commands[less]} ))
        }
        (( $? )) && cat
        return 0
    fi
} # ]]]

# FUNCTION: .zinit-build-module [[[
# Performs ./configure && make on the module and displays information
# how to load the module in .zshrc.
.zinit-build-module() {
    setopt localoptions localtraps
    trap 'return 1' INT TERM
    if command git -C "${ZINIT[MODULE_DIR]}" rev-parse 2>/dev/null; then
        command git -C "${ZINIT[MODULE_DIR]}" clean -d -f -f
        command git -C "${ZINIT[MODULE_DIR]}" reset --hard HEAD
        command git -C "${ZINIT[MODULE_DIR]}" pull
    else
        command git clone "https://github.com/zdharma-continuum/zinit-module.git" "${ZINIT[MODULE_DIR]}" || {
            builtin print "${ZINIT[col-error]}Failed to clone module repo${ZINIT[col-rst]}"
            return 1
        }
    fi
    ( builtin cd -q "${ZINIT[MODULE_DIR]}"
      +zi-log "{pname}== Building module zdharma-continuum/zinit-module, running: make clean, then ./configure and then make =={rst}"
      +zi-log "{pname}== The module sources are located at: "${ZINIT[MODULE_DIR]}" =={rst}"
      if [[ -f Makefile ]] {
          if [[ "$1" = "--clean" ]] {
              noglob +zi-log {p}-- make distclean --{rst}
              make distclean
              ((1))
          } else {
              noglob +zi-log {p}-- make clean --{rst}
              make clean
          }
      }
      noglob +zi-log  {p}-- ./configure --{rst}
      CPPFLAGS=-I/usr/local/include CFLAGS="-g -Wall -O3" LDFLAGS=-L/usr/local/lib ./configure --disable-gdbm --without-tcsetpgrp && {
          noglob +zi-log {p}-- make --{rst}
          if { make } {
            [[ -f Src/zdharma_continuum/zinit.so ]] && cp -vf Src/zdharma_continuum/zinit.{so,bundle}
            noglob +zi-log "{info}Module has been built correctly.{rst}"
            .zinit-module info
          } else {
              noglob +zi-log  "{error}Module didn't build.{rst} "
              .zinit-module info --link
          }
      }
      builtin print $EPOCHSECONDS >! "${ZINIT[MAN_DIR]}/COMPILED_AT"
    )
} # ]]]
# FUNCTION: .zinit-module [[[
# Function that has sub-commands passed as long-options (with two dashes, --).
# It's an attempt to plugin only this one function into `zinit' function
# defined in zinit.zsh, to not make this file longer than it's needed.
.zinit-module() {
    if [[ "$1" = "build" ]]; then
        .zinit-build-module "${@[2,-1]}"
    elif [[ "$1" = "info" ]]; then
        if [[ "$2" = "--link" ]]; then
              builtin print -r "You can copy the error messages and submit"
              builtin print -r "error-report at: https://github.com/zdharma-continuum/zinit-module/issues"
        else
            builtin print -r "To load the module, add following 2 lines to .zshrc, at top:"
            builtin print -r "    module_path+=( \"${ZINIT[MODULE_DIR]}/Src\" )"
            builtin print -r "    zmodload zdharma_continuum/zinit"
            builtin print -r ""
            builtin print -r "After loading, use command \`zpmod' to communicate with the module."
            builtin print -r "See \`zpmod -h' for more information."
        fi
    elif [[ "$1" = (help|usage) ]]; then
        builtin print -r "Usage: zinit module {build|info|help} [options]"
        builtin print -r "       zinit module build [--clean]"
        builtin print -r "       zinit module info [--link]"
        builtin print -r ""
        builtin print -r "To start using the zinit Zsh module run: \`zinit module build'"
        builtin print -r "and follow the instructions. Option --clean causes \`make distclean'"
        builtin print -r "to be run. To display the instructions on loading the module, run:"
... truncated; 2,816 more lines

#
# zdharma-continuum/zinit/zinit.zsh
# Copyright (c) 2016-2021 Sebastian Gniazdowski
# Copyright (c) 2021-2023 zdharma-continuum
# Homepage: https://github.com/zdharma-continuum/zinit
# License: MIT License
#

#
# Main state variables.
#

typeset -gaH ZINIT_REGISTERED_PLUGINS ZINIT_TASKS ZINIT_RUN
typeset -ga zsh_loaded_plugins
if (( !${#ZINIT_TASKS} )) { ZINIT_TASKS=( "<no-data>" ); }
# Snippets loaded, url -> file name.
typeset -gAH ZINIT ZINIT_SNIPPETS ZINIT_REPORTS ZINIT_ICES ZINIT_SICE ZINIT_CUR_BIND_MAP ZINIT_EXTS ZINIT_EXTS2
typeset -gaH ZINIT_COMPDEF_REPLAY

# Compatibility with pre-rename project (Zplugin).
typeset -gAH ZPLGM
ZINIT=( "${(kv)ZPLGM[@]}" "${(kv)ZINIT[@]}" )
unset ZPLGM

#
# Common needed values.
#

[[ ! -e ${ZINIT[BIN_DIR]}/zinit.zsh ]] && ZINIT[BIN_DIR]=

# Respect the plugin standard too.
ZINIT[ZERO]="${ZERO:-${${0:#$ZSH_ARGZERO}:-${(%):-%N}}}"
[[ ! -o functionargzero || ${options[posixargzero]} = on || ${ZINIT[ZERO]} != */* ]] && ZINIT[ZERO]="${(%):-%N}"

: ${ZINIT[BIN_DIR]:="${ZINIT[ZERO]:h}"}
[[ ${ZINIT[BIN_DIR]} = \~* ]] && ZINIT[BIN_DIR]=${~ZINIT[BIN_DIR]}

# Make ZINIT[BIN_DIR] path absolute.
ZINIT[BIN_DIR]="${${(M)ZINIT[BIN_DIR]:#/*}:-$PWD/${ZINIT[BIN_DIR]}}"

# Final test of ZINIT[BIN_DIR].
if [[ ! -e ${ZINIT[BIN_DIR]}/zinit.zsh ]]; then
    builtin print -P "%F{196}Could not establish ZINIT[BIN_DIR] hash field. It should point where Zinit's Git repository is.%f"
    return 1
fi

# User can override ZINIT[HOME_DIR].
if [[ -z ${ZINIT[HOME_DIR]} ]]; then
    # Search for zinit home in the usual locations
    if [[ -d ${XDG_DATA_HOME:-${HOME}/.local/share}/zinit ]]; then
        ZINIT[HOME_DIR]="${XDG_DATA_HOME:-${HOME}/.local/share}/zinit"
    elif [[ -d $HOME/.zinit ]]; then
        ZINIT[HOME_DIR]="$HOME/.zinit"
    elif [[ -d ${ZDOTDIR:-$HOME}/.zinit ]]; then
        ZINIT[HOME_DIR]="${ZDOTDIR:-$HOME}/.zinit"
    elif [[ -d $HOME/.zplugin ]]; then
        ZINIT[HOME_DIR]="$HOME/.zplugin"
    elif [[ -d ${ZDOTDIR:-$HOME}/.zplugin ]]; then
        ZINIT[HOME_DIR]="${ZDOTDIR:-$HOME}/.zplugin"
    else
        ZINIT[HOME_DIR]="${XDG_DATA_HOME:-${HOME}/.local/share}/zinit"
    fi
fi

if [[ -z ${ZINIT[LIST_COMMAND]} ]]; then
    if (( ${+commands[eza]} )); then
        ZINIT[LIST_COMMAND]='eza --color=always --tree --icons -L3'
    elif (( ${+commands[exa]} )); then
        ZINIT[LIST_COMMAND]='exa --color=always --tree --icons -L3'
    elif (( ${+commands[tree]} )); then
        ZINIT[LIST_COMMAND]='tree -L 3 -C --charset utf-8'
    else
        ZINIT[LIST_COMMAND]='ls --tree'
    fi
fi

ZINIT[ice-list]="\
\!bash|\!csh|\!ksh|\!sh|\
aliases|as|atclone|atdelete|atinit|atload|atpull|autoload|\
bash|binary|bindmap|blockf|bpick|build|\
cloneonly|cloneopts|cmake|compile|completions|configure|countdown|cp|csh|\
debug|depth|\
extract|\
from|git|\
has|\
id-as|if|install|is-snippet|\
ksh|\
light-mode|link|load|lucid|\
make|multisrc|mv|nocd|nocompile|nocompletions|notify|null|\
on-update-of|opts|\
pack|param|pick|proto|ps-on-unload|ps-on-update|pullopts|\
reset|reset-prompt|run-atpull|\
service|sh|silent|src|subscribe|subst|svn|\
teleid|trackbinds|trigger-load|\
unload|\
ver|verbose|\
wait|wrap"
ZINIT[nval-ice-list]="\
\!bash|\!csh|\!ksh|\!sh|\
aliases|\
bash|binary|blockf|\
cloneonly|cloneopts|cmake|configure|countdown|csh|\
debug|\
git|\
is-snippet|\
ksh|\
light-mode|lucid|\
make|\
nocd|nocompile|nocompletions|notify|null|\
pullopts|\
reset|run-atpull|\
sh|silent|\
trackbinds|\
verbose"
ZINIT[cmds]="\
add-fpath|\
bindkeys|\
cclear|cd|cdclear|cdisable|cdlist|cdreplay|cenable|changes|compile|compiled|compinit|completions|create|creinstall|csearch|cuninstall|\
delete|debug|\
edit|env-whitelist|\
fpath|\
glance|\
help|--help|-h|\
ice|\
light|load|\
man|module|\
plugins|\
recall|recently|report|run|\
self-update|snippet|snippets|srv|status|stress|\
times|\
uncompile|unload|update|\
version|\
zstatus"

# Can be customized.
: ${ZINIT[COMPLETIONS_DIR]:=${ZINIT[HOME_DIR]}/completions}
: ${ZINIT[MODULE_DIR]:=${ZINIT[HOME_DIR]}/module}
: ${ZINIT[PACKAGES_BRANCH]:=HEAD}
: ${ZINIT[PACKAGES_REPO]:=zdharma-continuum/zinit-packages}
: ${ZINIT[PLUGINS_DIR]:=${ZINIT[HOME_DIR]}/plugins}
: ${ZINIT[POLARIS_DIR]:=${ZINIT[HOME_DIR]}/polaris}
: ${ZINIT[SERVICES_DIR]:=${ZINIT[HOME_DIR]}/services}
: ${ZINIT[SNIPPETS_DIR]:=${ZINIT[HOME_DIR]}/snippets}
: ${ZINIT[ZPFX]:=${ZINIT[HOME_DIR]}/polaris}
typeset -g ZPFX
: ${ZPFX:=${ZINIT[ZPFX]}}
: ${ZINIT[ALIASES_OPT]::=${${options[aliases]:#off}:+1}}
: ${ZINIT[MAN_DIR]:=${ZPFX}/man}

ZINIT[PLUGINS_DIR]=${~ZINIT[PLUGINS_DIR]}   ZINIT[COMPLETIONS_DIR]=${~ZINIT[COMPLETIONS_DIR]}
ZINIT[SNIPPETS_DIR]=${~ZINIT[SNIPPETS_DIR]} ZINIT[SERVICES_DIR]=${~ZINIT[SERVICES_DIR]}

# Make sure $ZSH_CACHE_DIR is writable, otherwise use a directory in $HOME
if [[ ! -w "$ZSH_CACHE_DIR" ]]; then
  ZSH_CACHE_DIR="${XDG_CACHE_HOME:-$HOME/.cache}/zinit"
fi

export ZPFX=${~ZPFX} ZSH_CACHE_DIR="${ZSH_CACHE_DIR:-${XDG_CACHE_HOME:-$HOME/.cache}/zinit}" \
    PMSPEC=0uUpiPsf
[[ -z ${path[(re)$ZPFX/bin]} ]] && [[ -d "$ZPFX/bin" ]] && path=( "$ZPFX/bin" "${path[@]}" )
[[ -z ${path[(re)$ZPFX/sbin]} ]] && [[ -d "$ZPFX/sbin" ]] && path=( "$ZPFX/sbin" "${path[@]}" )

hash -f
hash -d zinit=${ZINIT[HOME_DIR]}
hash -d plugins=${ZINIT[PLUGINS_DIR]}
hash -d zpfx=${ZINIT[HOME_DIR]}/polaris

# Add completions directory to fpath.
[[ -z ${fpath[(re)${ZINIT[COMPLETIONS_DIR]}]} ]] && fpath=( "${ZINIT[COMPLETIONS_DIR]}" "${fpath[@]}" )

[[ ! -d $ZSH_CACHE_DIR ]] && command mkdir -p "$ZSH_CACHE_DIR"
[[ -n ${ZINIT[ZCOMPDUMP_PATH]} ]] && ZINIT[ZCOMPDUMP_PATH]=${~ZINIT[ZCOMPDUMP_PATH]}

# Create "$ZSH_CACHE_DIR/completions" directory
[[ ! -d "$ZSH_CACHE_DIR/completions" ]] && command mkdir -p "$ZSH_CACHE_DIR/completions"
# Add "$ZSH_CACHE_DIR/completions" diretory to fpath
[[ -z ${fpath[(re)$ZSH_CACHE_DIR/completions]} ]] && fpath=( "$ZSH_CACHE_DIR/completions" "${fpath[@]}" )

ZINIT[UPAR]=";:^[[A;:^[OA;:\\e[A;:\\eOA;:${termcap[ku]/$'\e'/^\[};:${terminfo[kcuu1]/$'\e'/^\[};:"
ZINIT[DOWNAR]=";:^[[B;:^[OB;:\\e[B;:\\eOB;:${termcap[kd]/$'\e'/^\[};:${terminfo[kcud1]/$'\e'/^\[};:"
ZINIT[RIGHTAR]=";:^[[C;:^[OC;:\\e[C;:\\eOC;:${termcap[kr]/$'\e'/^\[};:${terminfo[kcuf1]/$'\e'/^\[};:"
ZINIT[LEFTAR]=";:^[[D;:^[OD;:\\e[D;:\\eOD;:${termcap[kl]/$'\e'/^\[};:${terminfo[kcub1]/$'\e'/^\[};:"

builtin autoload -Uz is-at-least
is-at-least 5.1 && ZINIT[NEW_AUTOLOAD]=1 || ZINIT[NEW_AUTOLOAD]=0
#is-at-least 5.4 && ZINIT[NEW_AUTOLOAD]=2

# Parameters [[[
# temporary substituting of functions
ZINIT[TMP_SUBST]=inactive ZINIT[DTRACE]=0 ZINIT[CUR_PLUGIN]=

# ice
declare -gA ZINIT_1MAP ZINIT_2MAP
ZINIT_1MAP=(
    OMZ:: https://github.com/ohmyzsh/ohmyzsh/trunk/
    OMZP:: https://github.com/ohmyzsh/ohmyzsh/trunk/plugins/
    OMZT:: https://github.com/ohmyzsh/ohmyzsh/trunk/themes/
    OMZL:: https://github.com/ohmyzsh/ohmyzsh/trunk/lib/
    PZT:: https://github.com/sorin-ionescu/prezto/trunk/
    PZTM:: https://github.com/sorin-ionescu/prezto/trunk/modules/
)
ZINIT_2MAP=(
    OMZ:: https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/
    OMZP:: https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/plugins/
    OMZT:: https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/themes/
    OMZL:: https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/lib/
    PZT:: https://raw.githubusercontent.com/sorin-ionescu/prezto/master/
    PZTM:: https://raw.githubusercontent.com/sorin-ionescu/prezto/master/modules/
)
# ]]]

# Init [[[
zmodload zsh/zutil || { builtin print -P "%F{196}zsh/zutil module is required, aborting Zinit set up.%f"; return 1; }
zmodload zsh/parameter || { builtin print -P "%F{196}zsh/parameter module is required, aborting Zinit set up.%f"; return 1; }
zmodload zsh/term{cap,info} 2>/dev/null
autoload -Uz colors && colors

if [[ -z $SOURCED && ( ${+terminfo} -eq 1 && -n ${terminfo[colors]} ) || ( ${+termcap} -eq 1 && -n ${termcap[Co]} ) ]]; then
  ZINIT+=(
    col-annex   $'\e[38;5;153m'         col-faint   $'\e[38;5;238m'         col-msg2    $'\e[38;5;172m'      col-quo     $'\e[1;38;5;33m'
    col-apo     $'\e[1;38;5;45m'        col-file    $'\e[3;38;5;117m'       col-msg3    $'\e[38;5;238m'      col-quos    $'\e[1;38;5;160m'
    col-aps     $'\e[38;5;117m'         col-flag    $'\e[1;3;38;5;79m'      col-nb      $'\e[22m'            col-rst     $'\e[0m'
    col-b       $'\e[1m'                col-func    $'\e[38;5;219m'         col-nit     $'\e[23m'            col-slight  $'\e[38;5;230m'
    col-b-lhi   $'\e[1m\e[38;5;75m'     col-glob    $'\e[38;5;227m'         col-nl      $'\n'                col-st      $'\e[9m'
    col-b-warn  $'\e[1;38;5;214m'       col-happy   $'\e[1m\e[38;5;82m'     col-note    $'\e[38;5;148m'      col-tab     $' \t '
    col-bapo    $'\e[1;38;5;220m'       col-hi      $'\e[1m\e[38;5;183m'    col-nst     $'\e[29m'            col-term    $'\e[38;5;185m'
    col-baps    $'\e[1;38;5;82m'        col-ice     $'\e[38;5;39m'          col-nu      $'\e[24m'            col-th-bar  $'\e[38;5;82m'
    col-bar     $'\e[38;5;82m'          col-id-as   $'\e[4;38;5;220m'       col-num     $'\e[3;38;5;155m'    col-time    $'\e[38;5;220m'
    col-bcmd    $'\e[38;5;220m'         col-info    $'\e[38;5;82m'          col-obj     $'\e[38;5;218m'      col-txt     $'\e[38;5;254m'
    col-bspc    $'\b'                   col-info2   $'\e[38;5;227m'         col-obj2    $'\e[38;5;118m'      col-u       $'\e[4m'
    col-cmd     $'\e[38;5;82m'          col-info3   $'\e[1m\e[38;5;227m'    col-ok      $'\e[38;5;220m'      col-u-warn  $'\e[4;38;5;214m'
    col-data    $'\e[38;5;82m'          col-it      $'\e[3m'                col-opt     $'\e[38;5;219m'      col-uname   $'\e[1;4m\e[35m'
    col-data2   $'\e[38;5;117m'         col-keyword $'\e[32m'               col-p       $'\e[38;5;81m'       col-uninst  $'\e[38;5;118m'
    col-dir     $'\e[3;38;5;153m'       col-lhi     $'\e[38;5;81m'          col-pkg     $'\e[1;3;38;5;27m'   col-url     $'\e[38;5;75m'
    col-ehi     $'\e[1m\e[38;5;210m'    col-meta    $'\e[38;5;57m'          col-pname   $'\e[1;4m\e[32m'     col-var     $'\e[38;5;81m'
    col-error   $'\e[1m\e[38;5;204m'    col-meta2   $'\e[38;5;147m'         col-pre     $'\e[38;5;135m'      col-version $'\e[3;38;5;87m'
    col-failure $'\e[38;5;204m'         col-msg     $'\e[0m'                col-profile $'\e[38;5;148m'      col-warn    $'\e[38;5;214m'

    col-dbg $'\e[2m\e[38;47;107m'"[debug]"$'\e[0m'
    col-e $'\e[1m\e[38;5;204m'"Error"$'\e[0m'":"
    col-i $'\e[1m\e[38;5;82m'"==>"$'\e[0m'
    col-m $'\e[38;5;4m'"==>"$'\e[0m'
    col-w $'\e[1m\e[38;5;214m'"Warning"$'\e[0m'":"

    col--…   "${${${(M)LANG:#*UTF-8*}:+⋯⋯}:-···}"    col-lr "${${${(M)LANG:#*UTF-8*}:+↔}:-"«-»"}"
    col-ndsh "${${${(M)LANG:#*UTF-8*}:+–}:-}"        col-…  "${${${(M)LANG:#*UTF-8*}:+…}:-...}"

    col-mdsh  $'\e[1;38;5;220m'"${${${(M)LANG:#*UTF-8*}:+–}:--}"$'\e[0m'
    col-mmdsh $'\e[1;38;5;220m'"${${${(M)LANG:#*UTF-8*}:+――}:--}"$'\e[0m'

    col-↔     ${${${(M)LANG:#*UTF-8*}:+$'\e[38;5;82m↔\e[0m'}:-$'\e[38;5;82m«-»\e[0m'}
  )
  if [[ ( ${+terminfo} -eq 1 && ${terminfo[colors]} -ge 256 ) || ( ${+termcap} -eq 1 && ${termcap[Co]} -ge 256 ) ]]; then
    ZINIT+=( col-pname $'\e[1;4m\e[38;5;39m' col-uname  $'\e[1;4m\e[38;5;207m' )
  fi
fi

# Hooks
typeset -gAH ZINIT_ZLE_HOOKS_LIST
ZINIT_ZLE_HOOKS_LIST=(
    zle-isearch-exit 1
    zle-isearch-update 1
    zle-line-pre-redraw 1
    zle-line-init 1
    zle-line-finish 1
    zle-history-line-set 1
    zle-keymap-select 1
    paste-insert 1
)
builtin setopt noaliases
# ]]]

#
# Temporary substituting of functions-related functions.
#

# FUNCTION: :zinit-reload-and-run [[[
# Marks given function ($3) for autoloading, and executes it triggering the
# load. $1 is the fpath dedicated to the function, $2 are autoload options.
# This function replaces "autoload -X", because using that on older Zsh
# versions causes problems with traps.
#
# So basically one creates function stub that calls :zinit-reload-and-run()
# instead of "autoload -X".
#
# Author: Bart Schaefer
#
# $1 - FPATH dedicated to function
# $2 - autoload options
# $3 - function name (one that needs autoloading)
:zinit-reload-and-run() {
    local fpath_prefix="$1" autoload_opts="$2" func="$3"
    shift 3

    # Unfunction caller function (its name is given).
    unfunction -- "$func"

    local -a ___fpath
    ___fpath=( ${fpath[@]} )
    local -a +h fpath
    # See #127.
    [[ $FPATH != *${${(@0)fpath_prefix}[1]}* ]] && \
        fpath=( ${(@0)fpath_prefix} ${___fpath[@]} )

    # After this the function exists again.
    builtin autoload ${(s: :)autoload_opts} -- "$func"

    # User wanted to call the function, not only load it.
    "$func" "$@"
} # ]]]
# FUNCTION: :zinit-tmp-subst-autoload [[[
# Hijack plugin's calls to the 'autoload' builtin.
#
# The hijacking gathers report data and runs custom `autoload' function, that doesn't need FPATH.
:zinit-tmp-subst-autoload() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    builtin setopt extendedglob warncreateglobal typesetsilent rcquotes
    local -a opts opts2 custom reply
    local func

    zparseopts -D -E -M -a opts ${(s::):-RTUXdkmrtWzwC} I+=opts2 S+:=custom

    builtin set -- ${@:#--}

    # Process the id-as''/teleid'' to get the plugin dir.
    .zinit-any-to-user-plugin $ZINIT[CUR_USPL2]
    [[ $reply[1] = % ]] && \
        local PLUGIN_DIR="$reply[2]" || \
        local PLUGIN_DIR="$ZINIT[PLUGINS_DIR]/${reply[1]:+$reply[1]---}${reply[2]//\//---}"


    # "fpath elements" ----  those elements that lie inside the plug directory.
    local -a fpath_elements
    fpath_elements=( ${fpath[(r)$PLUGIN_DIR/*]} )

    # Add a function subdirectory to items, if any (this action is
    # according to the Plug Standard version 1.07 and later).
    [[ -d $PLUGIN_DIR/functions ]] && fpath_elements+=( "$PLUGIN_DIR"/functions )

    if (( ${+opts[(r)-X]} )); then
        .zinit-add-report "${ZINIT[CUR_USPL2]}" "Warning: Failed autoload ${(j: :)opts[@]} $*"
        +zi-log -u2 "{error}builtin autoload required for {obj}${(j: :)opts[@]}{error} option(s)"
        return 1
    fi
    if (( ${+opts[(r)-w]} )); then
        .zinit-add-report "${ZINIT[CUR_USPL2]}" "-w-Autoload ${(j: :)opts[@]} ${(j: :)@}"
        fpath+=( $PLUGIN_DIR )
        builtin autoload ${opts[@]} "$@"
        return $?
    fi
    if [[ -n ${(M)@:#+X} ]]; then
        .zinit-add-report "${ZINIT[CUR_USPL2]}" "Autoload +X ${opts:+${(j: :)opts[@]} }${(j: :)${@:#+X}}"
        local +h FPATH=$PLUGINS_DIR${fpath_elements:+:${(j.:.)fpath_elements[@]}}:$FPATH
        local +h -a fpath
        fpath=( $PLUGIN_DIR $fpath_elements $fpath )
        builtin autoload +X ${opts[@]} "${@:#+X}"
        return $?
    fi

    for func; do
        .zinit-add-report "${ZINIT[CUR_USPL2]}" "Autoload $func${opts:+ with options ${(j: :)opts[@]}}"
    done

    integer count retval
    for func; do
        # Real autoload doesn't touch function if it already exists.
        # Author of the idea of FPATH-clean autoloading: Bart Schaefer.
        if (( ${+functions[$func]} != 1 )) {
            builtin setopt noaliases
            if [[ $func == /* ]] && is-at-least 5.4; then
                builtin autoload ${opts[@]} $func
                return $?
            elif [[ $func == /* ]]; then
                if [[ $ZINIT[MUTE_WARNINGS] != (1|true|on|yes) && \
                        -z $ZINIT[WARN_SHOWN_FOR_$ZINIT[CUR_USPL2]] ]]; then
                    +zi-log "{u-warn}Warning{b-warn}: {rst}the plugin {pid}$ZINIT[CUR_USPL2]" \
                        "{rst}is using autoload functions specified by their absolute path," \
                        "which is not supported by this Zsh version ({↔} {version}$ZSH_VERSION{rst}," \
                        "required is Zsh >= {version}5.4{rst})." \
                        "{nl}A fallback mechanism has been applied, which works well only" \
                        "for functions in the plugin {u}{slight}main{rst} directory." \
                        "{nl}(To mute this message, set" \
                        "{var}\$ZINIT[MUTE_WARNINGS]{rst} to a truth value.)"
                    ZINIT[WARN_SHOWN_FOR_$ZINIT[CUR_USPL2]]=1
                fi

                # Workaround
                func=$func:t
            fi
            if [[ ${ZINIT[NEW_AUTOLOAD]} = 2 ]]; then
                builtin autoload ${opts[@]} "$PLUGIN_DIR/$func"
                retval=$?
            elif [[ ${ZINIT[NEW_AUTOLOAD]} = 1 ]]; then
                if (( ${+opts[(r)-C]} )) {
                    local pth nl=$'\n' sel=""
                    for pth ( $PLUGIN_DIR $fpath_elements $fpath ) {
                        [[ -f $pth/$func ]] && { sel=$pth; break; }
                    }
                    if [[ -z $sel ]] {
                        +zi-log '{u-warn}zinit{b-warn}:{error} Couldn''t find autoload function{ehi}:' \
                            "{apo}\`{file}${func}{apo}\`{error} anywhere in {var}\$fpath{error}."
                            retval=1
                    } else {
                        eval "function ${(q)${custom[++count*2]}:-$func} {
                            local body=\"\$(<${(qqq)sel}/${(qqq)func})\" body2
                            () { setopt localoptions extendedglob
                                 body2=\"\${body##[[:space:]]#${func}[[:blank:]]#\(\)[[:space:]]#\{}\"
                                 [[ \$body2 != \$body ]] && \
                                    body2=\"\${body2%\}[[:space:]]#([$nl]#([[:blank:]]#\#[^$nl]#((#e)|[$nl]))#)#}\"
                            }

                            functions[${${(q)custom[count*2]}:-$func}]=\"\$body2\"
                            ${(q)${custom[count*2]}:-$func} \"\$@\"
                        }"
                        retval=$?
                    }
                } else {
                    functions[$func]="
                        local -a fpath
                        fpath=( ${(qqq)PLUGIN_DIR} ${(qqq@)fpath_elements} ${(qqq@)fpath} )
                        builtin autoload -X ${(j: :)${(q-)opts[@]}}
                    "
                    retval=$?
                }
            else
                eval "function ${(q)func} {
                    :zinit-reload-and-run ${(qqq)PLUGIN_DIR}"$'\0'"${(pj,\0,)${(qqq)fpath_elements[@]}} ${(qq)opts[*]} ${(q)func} "'"$@"
                }'
                retval=$?
            fi
            (( ZINIT[ALIASES_OPT] )) && builtin setopt aliases
        }
        if (( ${+opts2[(r)-I]} )) {
            ${custom[count*2]:-$func}
            retval=$?
        }
    done

    return $retval
} # ]]]
# FUNCTION: :zinit-tmp-subst-bindkey [[[
# Function defined to hijack plugin's calls to the `bindkey' builtin.
#
# The hijacking is to gather report data (which is used in unload).
:zinit-tmp-subst-bindkey() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    builtin setopt extendedglob warncreateglobal typesetsilent noshortloops

    is-at-least 5.3 && \
        .zinit-add-report "${ZINIT[CUR_USPL2]}" "Bindkey ${(j: :)${(q+)@}}" || \
        .zinit-add-report "${ZINIT[CUR_USPL2]}" "Bindkey ${(j: :)${(q)@}}"

    # Remember to perform the actual bindkey call.
    typeset -a pos
    pos=( "$@" )

    # Check if we have regular bindkey call, i.e.
    # with no options or with -s, plus possible -M
    # option.
    local -A opts
    zparseopts -A opts -D ${(s::):-lLdDAmrsevaR} M: N:

    if (( ${#opts} == 0 ||
        ( ${#opts} == 1 && ${+opts[-M]} ) ||
        ( ${#opts} == 1 && ${+opts[-R]} ) ||
        ( ${#opts} == 1 && ${+opts[-s]} ) ||
        ( ${#opts} <= 2 && ${+opts[-M]} && ${+opts[-s]} ) ||
        ( ${#opts} <= 2 && ${+opts[-M]} && ${+opts[-R]} )
    )); then
        local string="${(q)1}" widget="${(q)2}"
        local quoted

        if [[ -n ${ICE[bindmap]} && ${ZINIT_CUR_BIND_MAP[empty]} -eq 1 ]]; then
            local -a pairs
            pairs=( "${(@s,;,)ICE[bindmap]}" )
            if [[ -n ${(M)pairs:#*\\(#e)} ]] {
                local prev
                pairs=( ${pairs[@]//(#b)((*)\\(#e)|(*))/${match[3]:+${prev:+$prev\;}}${match[3]}${${prev::=${match[2]:+${prev:+$prev\;}}${match[2]}}:+}} )
            }
            pairs=( "${(@)${(@)${(@s:->:)pairs}##[[:space:]]##}%%[[:space:]]##}" )
            ZINIT_CUR_BIND_MAP=( empty 0 )
            (( ${#pairs} > 1 && ${#pairs[@]} % 2 == 0 )) && ZINIT_CUR_BIND_MAP+=( "${pairs[@]}" )
        fi

        local bmap_val="${ZINIT_CUR_BIND_MAP[${1}]}"
        if (( !ZINIT_CUR_BIND_MAP[empty] )) {
            [[ -z $bmap_val ]] && bmap_val="${ZINIT_CUR_BIND_MAP[${(qqq)1}]}"
            [[ -z $bmap_val ]] && bmap_val="${ZINIT_CUR_BIND_MAP[${(qqq)${(Q)1}}]}"
            [[ -z $bmap_val ]] && { bmap_val="${ZINIT_CUR_BIND_MAP[!${(qqq)1}]}"; integer val=1; }
            [[ -z $bmap_val ]] && bmap_val="${ZINIT_CUR_BIND_MAP[!${(qqq)${(Q)1}}]}"
        }
        if [[ -n $bmap_val ]]; then
            string="${(q)bmap_val}"
            if (( val )) {
                [[ ${pos[1]} = "-M" ]] && pos[4]="$bmap_val" || pos[2]="$bmap_val"
            } else {
                [[ ${pos[1]} = "-M" ]] && pos[3]="${(Q)bmap_val}" || pos[1]="${(Q)bmap_val}"
            }
            .zinit-add-report "${ZINIT[CUR_USPL2]}" ":::Bindkey: combination <$1> changed to <$bmap_val>${${(M)bmap_val:#hold}:+, i.e. ${ZINIT[col-error]}unmapped${ZINIT[col-rst]}}"
            ((1))
        elif [[ ( -n ${bmap_val::=${ZINIT_CUR_BIND_MAP[UPAR]}} && -n ${${ZINIT[UPAR]}[(r);:${(q)1};:]} ) || \
                ( -n ${bmap_val::=${ZINIT_CUR_BIND_MAP[DOWNAR]}} && -n ${${ZINIT[DOWNAR]}[(r);:${(q)1};:]} ) || \
                ( -n ${bmap_val::=${ZINIT_CUR_BIND_MAP[RIGHTAR]}} && -n ${${ZINIT[RIGHTAR]}[(r);:${(q)1};:]} ) || \
                ( -n ${bmap_val::=${ZINIT_CUR_BIND_MAP[LEFTAR]}} && -n ${${ZINIT[LEFTAR]}[(r);:${(q)1};:]} )
        ]]; then
            string="${(q)bmap_val}"
            if (( val )) {
                [[ ${pos[1]} = "-M" ]] && pos[4]="$bmap_val" || pos[2]="$bmap_val"
            } else {
                [[ ${pos[1]} = "-M" ]] && pos[3]="${(Q)bmap_val}" || pos[1]="${(Q)bmap_val}"
            }
            .zinit-add-report "${ZINIT[CUR_USPL2]}" ":::Bindkey: combination <$1> recognized as cursor-key and changed to <${bmap_val}>${${(M)bmap_val:#hold}:+, i.e. ${ZINIT[col-error]}unmapped${ZINIT[col-rst]}}"
        fi
        [[ $bmap_val = hold ]] && return 0

        local prev="${(q)${(s: :)$(builtin bindkey ${(Q)string})}[-1]#undefined-key}"

        # "-M map" given?
        if (( ${+opts[-M]} )); then
            local Mopt=-M
            local Marg="${opts[-M]}"

            Mopt="${(q)Mopt}"
            Marg="${(q)Marg}"

            quoted="$string $widget $prev $Mopt $Marg"
        else
            quoted="$string $widget $prev"
        fi

        # -R given?
        if (( ${+opts[-R]} )); then
            local Ropt=-R
            Ropt="${(q)Ropt}"

            if (( ${+opts[-M]} )); then
                quoted="$quoted $Ropt"
            else
                # Two empty fields for non-existent -M arg.
                local space=_
                space="${(q)space}"
                quoted="$quoted $space $space $Ropt"
            fi
        fi

        quoted="${(q)quoted}"

        # Remember the bindkey, only when load is in progress (it can be dstart that leads execution here).
        [[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[BINDKEYS__${ZINIT[CUR_USPL2]}]+="$quoted "
        # Remember for dtrace.
        [[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[BINDKEYS___dtrace/_dtrace]+="$quoted "
    else
        # bindkey -A newkeymap main?
        # Negative indices for KSH_ARRAYS immunity.
        if [[ ${#opts} -eq 1 && ${+opts[-A]} = 1 && ${#pos} = 3 && ${pos[-1]} = main && ${pos[-2]} != -A ]]; then
            # Save a copy of main keymap.
            (( ZINIT[BINDKEY_MAIN_IDX] = ${ZINIT[BINDKEY_MAIN_IDX]:-0} + 1 ))
            local pname="${ZINIT[CUR_PLUGIN]:-_dtrace}"
            local name="${(q)pname}-main-${ZINIT[BINDKEY_MAIN_IDX]}"
            builtin bindkey -N "$name" main

            # Remember occurence of main keymap substitution, to revert on unload.
            local keys=_ widget=_ prev= optA=-A mapname="${name}" optR=_
            local quoted="${(q)keys} ${(q)widget} ${(q)prev} ${(q)optA} ${(q)mapname} ${(q)optR}"
            quoted="${(q)quoted}"

            # Remember the bindkey, only when load is in progress (it can be dstart that leads execution here).
            [[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[BINDKEYS__${ZINIT[CUR_USPL2]}]+="$quoted "
            [[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[BINDKEYS___dtrace/_dtrace]+="$quoted "

            .zinit-add-report "${ZINIT[CUR_USPL2]}" "Warning: keymap \`main' copied to \`${name}' because of \`${pos[-2]}' substitution"
        # bindkey -N newkeymap [other].
        elif [[ ${#opts} -eq 1 && ${+opts[-N]} = 1 ]]; then
            local Nopt=-N
            local Narg="${opts[-N]}"

            local keys=_ widget=_ prev= optN=-N mapname="${Narg}" optR=_
            local quoted="${(q)keys} ${(q)widget} ${(q)prev} ${(q)optN} ${(q)mapname} ${(q)optR}"
            quoted="${(q)quoted}"

            # Remember the bindkey, only when load is in progress (it can be dstart that leads execution here).
            [[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[BINDKEYS__${ZINIT[CUR_USPL2]}]+="$quoted "
            [[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[BINDKEYS___dtrace/_dtrace]+="$quoted "
        else
            .zinit-add-report "${ZINIT[CUR_USPL2]}" "Warning: last bindkey used non-typical options: ${(kv)opts[*]}"
        fi
    fi

    # Actual bindkey.
    builtin bindkey "${pos[@]}"
    return $? # testable
} # ]]]
# FUNCTION: :zinit-tmp-subst-zstyle [[[
# Function defined to hijack plugin's calls to the `zstyle' builtin.
#
# The hijacking is to gather report data (which is used in unload).
:zinit-tmp-subst-zstyle() {
    builtin setopt localoptions noerrreturn noerrexit extendedglob nowarncreateglobal \
        typesetsilent noshortloops unset
    .zinit-add-report "${ZINIT[CUR_USPL2]}" "Zstyle $*"

    # Remember in order to perform the actual zstyle call.
    typeset -a pos
    pos=( "$@" )

    # Check if we have regular zstyle call, i.e.
    # with no options or with -e.
    local -a opts
    zparseopts -a opts -D ${(s::):-eLdgabsTtm}

    if [[ ${#opts} -eq 0 || ( ${#opts} -eq 1 && ${+opts[(r)-e]} = 1 ) ]]; then
        # Have to quote $1, then $2, then concatenate them, then quote them again.
        local pattern="${(q)1}" style="${(q)2}"
        local ps="$pattern $style"
        ps="${(q)ps}"

        # Remember the zstyle, only when load is in progress (it can be dstart that leads execution here).
        [[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[ZSTYLES__${ZINIT[CUR_USPL2]}]+="$ps "
        # Remember for dtrace.
        [[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[ZSTYLES___dtrace/_dtrace]+=$ps
    else
        if [[ ! ${#opts[@]} = 1 && ( ${+opts[(r)-s]} = 1 || ${+opts[(r)-b]} = 1 || ${+opts[(r)-a]} = 1 ||
              ${+opts[(r)-t]} = 1 || ${+opts[(r)-T]} = 1 || ${+opts[(r)-m]} = 1 )
        ]]; then
            .zinit-add-report "${ZINIT[CUR_USPL2]}" "Warning: last zstyle used non-typical options: ${opts[*]}"
        fi
    fi

    # Actual zstyle.
    builtin zstyle "${pos[@]}"
    return $? # testable
} # ]]]
# FUNCTION: :zinit-tmp-subst-alias [[[
# Function defined to hijack plugin's calls to the `alias' builtin.
#
# The hijacking is to gather report data (which is used in unload).
:zinit-tmp-subst-alias() {
    builtin setopt localoptions noerrreturn noerrexit extendedglob warncreateglobal \
        typesetsilent noshortloops unset
    .zinit-add-report "${ZINIT[CUR_USPL2]}" "Alias $*"

    # Remember to perform the actual alias call.
    typeset -a pos
    pos=( "$@" )

    local -a opts
    zparseopts -a opts -D ${(s::):-gs}

    local a quoted tmp
    for a in "$@"; do
        local aname="${a%%[=]*}"
        local avalue="${a#*=}"

        # Check if alias is to be redefined.
        (( ${+aliases[$aname]} )) && .zinit-add-report "${ZINIT[CUR_USPL2]}" "Warning: redefining alias \`${aname}', previous value: ${aliases[$aname]}"

        local bname=${(q)aliases[$aname]}
        aname="${(q)aname}"

        if (( ${+opts[(r)-s]} )); then
            tmp=-s
            tmp="${(q)tmp}"
            quoted="$aname $bname $tmp"
        elif (( ${+opts[(r)-g]} )); then
            tmp=-g
            tmp="${(q)tmp}"
            quoted="$aname $bname $tmp"
        else
            quoted="$aname $bname"
        fi

        quoted="${(q)quoted}"

        # Remember the alias, only when load is in progress (it can be dstart that leads execution here).
        [[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[ALIASES__${ZINIT[CUR_USPL2]}]+="$quoted "
        # Remember for dtrace.
        [[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[ALIASES___dtrace/_dtrace]+="$quoted "
    done

    # Actual alias.
    builtin alias "${pos[@]}"
    return $? # testable
} # ]]]
# FUNCTION: :zinit-tmp-subst-zle [[[.
# Function defined to hijack plugin's calls to the `zle' builtin.
#
# The hijacking is to gather report data (which is used in unload).
:zinit-tmp-subst-zle() {
    builtin setopt localoptions noerrreturn noerrexit extendedglob warncreateglobal \
        typesetsilent noshortloops unset
    .zinit-add-report "${ZINIT[CUR_USPL2]}" "Zle $*"

    # Remember to perform the actual zle call.
    typeset -a pos
    pos=( "$@" )

    builtin set -- "${@:#--}"

    # Try to catch game-changing "-N".
    if [[ ( $1 = -N && ( $# = 2 || $# = 3 ) ) || ( $1 = -C && $# = 4 ) ]]; then
            # Hooks.
            if [[ ${ZINIT_ZLE_HOOKS_LIST[$2]} = 1 ]]; then
                local quoted="$2"
                quoted="${(q)quoted}"
                # Remember only when load is in progress (it can be dstart that leads execution here).
                [[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[WIDGETS_DELETE__${ZINIT[CUR_USPL2]}]+="$quoted "
                # Remember for dtrace.
                [[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[WIDGETS_DELETE___dtrace/_dtrace]+="$quoted "
            # These will be saved and restored.
            elif (( ${+widgets[$2]} )); then
                # Have to remember original widget "$2" and
                # the copy that it's going to be done.
                local widname="$2" targetfun="${${${(M)1:#-C}:+$4}:-$3}"
                local completion_widget="${${(M)1:#-C}:+$3}"
                local saved_widcontents="${widgets[$widname]}"

                widname="${(q)widname}"
                completion_widget="${(q)completion_widget}"
                targetfun="${(q)targetfun}"
                saved_widcontents="${(q)saved_widcontents}"
                local quoted="$1 $widname $completion_widget $targetfun $saved_widcontents"
                quoted="${(q)quoted}"
                # Remember only when load is in progress (it can be dstart that leads execution here).
                [[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[WIDGETS_SAVED__${ZINIT[CUR_USPL2]}]+="$quoted "
                # Remember for dtrace.
                [[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[WIDGETS_SAVED___dtrace/_dtrace]+="$quoted "
             # These will be deleted.
             else
                 .zinit-add-report "${ZINIT[CUR_USPL2]}" "Note: a new widget created via zle -N: \`$2'"
                 local quoted="$2"
                 quoted="${(q)quoted}"
                 # Remember only when load is in progress (it can be dstart that leads execution here).
                 [[ -n ${ZINIT[CUR_USPL2]} ]] && ZINIT[WIDGETS_DELETE__${ZINIT[CUR_USPL2]}]+="$quoted "
                 # Remember for dtrace.
                 [[ ${ZINIT[DTRACE]} = 1 ]] && ZINIT[WIDGETS_DELETE___dtrace/_dtrace]+="$quoted "
             fi
    fi

    # Actual zle.
    builtin zle "${pos[@]}"
    return $? # testable
} # ]]]
# FUNCTION: :zinit-tmp-subst-compdef [[[
# Function defined to hijack plugin's calls to the `compdef' function.
# The hijacking is not only for reporting, but also to save compdef
# calls so that `compinit' can be called after loading plugins.
:zinit-tmp-subst-compdef() {
    builtin setopt localoptions noerrreturn noerrexit extendedglob warncreateglobal \
        typesetsilent noshortloops unset
    .zinit-add-report "${ZINIT[CUR_USPL2]}" "Saving \`compdef $*' for replay"
    ZINIT_COMPDEF_REPLAY+=( "${(j: :)${(q)@}}" )

    return 0 # testable
} # ]]]
# FUNCTION: .zinit-tmp-subst-on [[[
# Turn on temporary substituting of functions of builtins and functions according to passed
# mode ("load", "light", "light-b" or "compdef"). The temporary substituting of functions is
# to gather report data, and to hijack 'autoload', 'bindkey' and 'compdef' calls.
.zinit-tmp-subst-on() {
    local mode="$1"

    # Enable temporary substituting of functions only once.
    #
    # One could expect possibility of widening of temporary substituting of functions, however
    # such sequence doesn't exist, e.g. "light" then "load"/"dtrace", "compdef" then "load"/
    # "dtrace", "light" then "compdef", "compdef" then "light".
    #
    # It is always "dtrace" then "load" (i.e. dtrace then load) "dtrace" then "light" (i.e.:
    # dtrace then light load) "dtrace" then "compdef" (i.e.: dtrace then snippet).
    [[ ${ZINIT[TMP_SUBST]} != inactive ]] && builtin return 0

    ZINIT[TMP_SUBST]="$mode"

    # The point about backuping is: does the key exist in functions array.
    # If it does exist, then it will also exist as ZINIT[bkp-*].

    # Defensive code, shouldn't be needed.
    builtin unset "ZINIT[bkp-autoload]" "ZINIT[bkp-compdef]"  # 0, E.

    if [[ $mode != compdef ]]; then
        # 0. Used, but not in temporary restoration, which doesn't happen for autoload.
        (( ${+functions[autoload]} )) && ZINIT[bkp-autoload]="${functions[autoload]}"
        functions[autoload]=':zinit-tmp-subst-autoload "$@";'
    fi

    # E. Always shade compdef.
    (( ${+functions[compdef]} )) && ZINIT[bkp-compdef]="${functions[compdef]}"
    functions[compdef]=':zinit-tmp-subst-compdef "$@";'

    # Temporarily replace `source' if subst'' given.
    if [[ -n ${ICE[subst]} ]] {
        (( ${+functions[source]} )) && ZINIT[bkp-source]="${functions[source]}"
        (( ${+functions[.]} )) && ZINIT[bkp-.]="${functions[.]}"
        (( ${+functions[.zinit-service]} )) || builtin source "${ZINIT[BIN_DIR]}/zinit-additional.zsh"
        functions[source]=':zinit-tmp-subst-source "$@";'
        functions[.]=':zinit-tmp-subst-source "$@";'
    }

    # Light and compdef temporary substituting of functions stops here. Dtrace and load go on.
    [[ ( $mode = light && ${+ICE[trackbinds]} -eq 0 ) || $mode = compdef ]] && return 0
... truncated; 2,551 more lines

# -*- mode: sh; sh-indentation: 4; indent-tabs-mode: nil; sh-basic-offset: 4;
# -*-
# Copyright (c) 2016-2020 Sebastian Gniazdowski and contributors.

builtin source "${ZINIT[BIN_DIR]}/zinit-side.zsh" || {
    builtin print -P "${ZINIT[col-error]}ERROR:%f%b Couldn't find ${ZINIT[col-obj]}zinit-side.zsh%f%b."
    return 1
}

# FUNCTION: .zinit-jq-check [[[
# Check if jq is available and outputs an error message with instructions if
# that's not the case
.zinit-jq-check() {
    command -v jq >/dev/null && return 0

    +zi-log "{error}❌ ERROR: jq binary not found" \
        "{nl}{u-warn}Please install jq:{rst}" \
        "https://github.com/jqlang/jq" \
        "{nl}{u-warn}To do so with zinit, please refer to:{rst}" \
        "https://github.com/zdharma-continuum/zinit/wiki/%F0%9F%A7%8A-Recommended-ices#jq"
    return 1
} # ]]]
# FUNCTION: .zinit-json-get-value [[[
# Wrapper around jq that return the value of a property
#
# $1: JSON structure
# $2: jq path
.zinit-json-get-value() {
    .zinit-jq-check || return 1

    local jsonstr=$1 jqpath=$2
    jq -er ".${jqpath}" <<< "$jsonstr"
} # ]]]
# FUNCTION: .zinit-json-to-array [[[
# Wrapper around jq that sets key/values of an associative array, replicating
# the structure of a given JSON object
#
# $1: JSON structure
# $2: jq path
# $3: name of the associative array to store the key/value pairs in
.zinit-json-to-array() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt localoptions noglob

    .zinit-jq-check || return 1

    local jsonstr=$1 jqpath=$2 varname=$3

    (( ${(P)+varname} )) || typeset -gA "$varname"

    # NOTE We're not using @sh for the keys on purpose. Associative
    # array keys are used verbatim by zsh:
    # typeset -A a; a[key]=one; a['key']=two; echo ${(k)a}
    # 'key' key
    local evalstr=$(command jq -er --arg varname $varname \
        '.'${jqpath}' | to_entries |
        map($varname + "[\(.key)]=\(.value | @sh);")[]' \
        <<< "$jsonstr")
    eval "$evalstr"
} # ]]]
# FUNCTION: .zinit-get-package [[[
.zinit-get-package() {
    .zinit-jq-check || return 1

    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt extendedglob warncreateglobal typesetsilent noshortloops rcquotes

    local user=$1 pkg=$2 plugin=$2 id_as=$3 dir=$4 profile=$5 \
        ver=${ICE[ver]} local_path=${ZINIT[PLUGINS_DIR]}/${3//\//---} \
        pkgjson tmpfile=${$(mktemp):-${TMPDIR:-/tmp}/zsh.xYzAbc123}
    local URL=https://raw.githubusercontent.com/${ZINIT[PACKAGES_REPO]}/${ver:-${ZINIT[PACKAGES_BRANCH]}}/${pkg}/package.json

    # Consume (i.e., delete) the ver ice to avoid being consumed again at git-clone time
    [[ -n "$ver" ]] && unset 'ICE[ver]'

    local pro_sep="{rst}, {profile}" epro_sep="{error}, {profile}" \
        tool_sep="{rst}, {cmd}" \
        lhi_hl="{lhi}" profile_hl="{profile}"

    trap "rmdir ${(qqq)local_path} 2>/dev/null; return 1" INT TERM QUIT HUP
    trap "rmdir ${(qqq)local_path} 2>/dev/null" EXIT

    # Check if we were provided with a local path to a package.json
    # as in:
    # zinit pack'/zp/firefox-dev/package.json:default' for firefox-dev
    if [[ $profile == ./* || $profile == /* ]] {
        local localpkg=1
        # FIXME below only works if there are no ':' in the path
        tmpfile=${profile%:*}
        profile=${${${(M)profile:#*:*}:+${profile#*:}}:-default}
    } elif { ! .zinit-download-file-stdout $URL 0 1 2>/dev/null > $tmpfile } {
        # retry
        command rm -f $tmpfile
        .zinit-download-file-stdout $URL 1 1 2>/dev/null >1 $tmpfile
    }

    # load json from file
    [[ -e $tmpfile ]] && pkgjson="$(<$tmpfile)"

    # Set package name (used later in the output)
    local pkgname=${${id_as##_unknown}:-${pkg:-${plugin}}}
    [[ -n "$localpkg" ]] && pkgname="{pid}$pkgname{rst} {note}[$tmpfile]{rst}"

    if [[ -z $pkgjson ]] {
        +zi-log "{error}❌ Error: the package {hi}${pkgname}" \
                       "{error}couldn't be found.{rst}"
        return 1
    }

    # root field, where the relevant data is stored
    local json_root='["zsh-data"]'
    local json_ices="${json_root}[\"zinit-ices\"]"
    local json_meta="${json_root}[\"plugin-info\"]"

    local -a profiles
    profiles=("${(@f)$(.zinit-json-get-value "$pkgjson" "${json_ices} | keys[]")}") \
        || return 1

    # Check if user requested an unknown profile
    if ! (( ${profiles[(I)${profile}]} )) {
        # Assumption: the default profile is the first in the table (-> different color).
        +zi-log "{u-warn}Error{b-warn}:{error} the profile {apo}\`{hi}$profile{apo}\`" \
            "{error}couldn't be found, aborting. Available profiles are:" \
            "{lhi}${(pj:$epro_sep:)profiles[@]}{error}.{rst}"
        return 1
    }
    local json_profile="${json_ices}[\"${profile}\"]"

    local -A metadata
    .zinit-json-to-array "$pkgjson" "$json_meta" metadata
    if [[ "$?" -ne 0 || -z "$metadata" ]] {
        +zi-log '{error}❌ ERROR: Failed to retrieve metadata from package.json'
        return 1
    }

    local user=${metadata[user]} plugin=${metadata[plugin]} \
        message=${metadata[message]} url=${metadata[url]}

    .zinit-json-to-array "$pkgjson" "$json_profile" ICE
    local -a requirements

    # FIXME requires shouldn't be stored under zinit-ices...
    if [[ -n "$ICE[requires]" ]] {
        # split requirements on ';'
        requirements=(${(s.;.)${ICE[requires]}})
        unset 'ICE[requires]'
    }

    [[ ${ICE[as]} == program ]] && ICE[as]="command"
    [[ -n ${ICE[on-update-of]} ]] && ICE[subscribe]="${ICE[subscribe]:-${ICE[on-update-of]}}"
    [[ -n ${ICE[pick]} ]] && ICE[pick]="${ICE[pick]//\$ZPFX/${ZPFX%/}}"

    # FIXME Do we even need that? If yes, we may want to do that in
    # .zinit-json-to-array
    if [[ -n ${ICE[id-as]} ]] {
        @zinit-substitute 'ICE[id-as]'
        local -A map
        map=( "\"" "\\\"" "\\" "\\" )
        eval "ICE[id-as]=\"${ICE[id-as]//(#m)[\"\\]/${map[$MATCH]}}\""
    }

    +zi-log "{info3}Package{ehi}:{rst} ${pkgname}. Selected" \
        "profile{ehi}:{rst} {hi}$profile{rst}. Available" \
        "profiles:${${${(M)profile:#default}:+$lhi_hl}:-$profile_hl}" \
        "${(pj:$pro_sep:)profiles[@]}{rst}."

    if [[ $profile != *bgn* && -n ${(M)profiles[@]:#*bgn*} ]] {
        +zi-log "{note}Note:{rst} The {apo}\`{profile}bgn{glob}*{apo}\`{rst}" \
            "profiles (if any are available) are the recommended ones (the reason" \
            "is that they expose the binaries provided by the package without" \
            "altering (i.e.: {slight}cluttering{rst}{…}) the {var}\$PATH{rst}" \
            "environment variable)."
    }

    local required
    for required ( $requirements ) {
        if [[ $required == (bgn|dl|monitor) ]]; then
            if [[ ( $required == bgn && -z ${(k)ZINIT_EXTS[(r)<-> z-annex-data: zinit-annex-bin-gem-node *]} ) || \
                ( $required == dl && -z ${(k)ZINIT_EXTS[(r)<-> z-annex-data: zinit-annex-patch-dl *]} ) || \
                ( $required == monitor && -z ${(k)ZINIT_EXTS[(r)<-> z-annex-data: zinit-annex-readurl *]} )
            ]]; then
                local -A namemap
                namemap=( bgn bin-gem-node dl patch-dl monitor readurl )
                +zi-log -n "{u-warn}ERROR{b-warn}: {error}the "
                if [[ -z ${(MS)ICE[requires]##(\;|(#s))$required(\;|(#e))} ]]; then
                    +zi-log -n "{error}requested profile {apo}\`{hi}$profile{apo}\`{error} "
                else
                    +zi-log -n "{error}package {pid}$pkg{error} "
                fi
                +zi-log '{error}requires the {apo}`{annex}'${namemap[$required]}'{apo}`' \
                    "{error}annex, which is currently not installed." \
                    "{nl}{nl}If you'd like to install it, you can visit its homepage:" \
                    "{nl}– {url}https://github.com/zdharma-continuum/zinit-annex-${(L)namemap[$required]}{rst}" \
                    "{nl}for instructions."
                (( ${#profiles[@]:#$profile} > 0 )) && \
                    +zi-log "{nl}Other available profiles are:" \
"{profile}${(pj:$pro_sep:)${profiles[@]:#$profile}}{rst}."

                return 1
            fi
        else
            if ! command -v $required &>/dev/null; then
                +zi-log -n "{u-warn}ERROR{b-warn}: {error}the "
                if [[ -n ${(MS)ICE[requires]##(\;|(#s))$required(\;|(#e))} ]]; then
                    +zi-log -n "{error}requested profile {apo}\`{hi}$profile{apo}\`{error} "
                else
                    +zi-log -n "{error}package {pid}$pkg{error} "
                fi
                +zi-log '{error}requires a {apo}`{cmd}'$required'{apo}`{error}' \
                    "command to be available in {var}\$PATH{error}.{rst}" \
                    "{nl}{error}The package cannot be installed unless the" \
                    "command will be available."
                (( ${#profiles[@]:#$profile} > 0 )) && \
                    +zi-log "{nl}Other available profiles are:" \
                        "{profile}${(pj:$pro_sep:)${profiles[@]:#$profile}}{rst}."
                return 1
            fi
        fi
    }

    if [[ -n ${ICE[dl]} && -z ${(k)ZINIT_EXTS[(r)<-> z-annex-data: zinit-annex-patch-dl *]} ]] {
        +zi-log "{nl}{u-warn}WARNING{b-warn}:{rst} the profile uses" \
            "{ice}dl''{rst} ice however there's currently no {annex}zinit-annex-patch-dl{rst}" \
            "annex loaded, which provides it."
        +zi-log "The ice will be inactive, i.e.: no additional" \
            "files will become downloaded (the ice downloads the given URLs)." \
            "The package should still work, as it doesn't indicate to" \
            "{u}{slight}require{rst} the annex."
        +zi-log "{nl}You can download the" \
            "annex from its homepage at {url}https://github.com/zdharma-continuum/zinit-annex-patch-dl{rst}."
    }

    [[ -n ${message} ]] && +zi-log "{info}${message}{rst}"

    if (( ${+ICE[is-snippet]} )) {
        reply=( "" "$url" )
        REPLY=snippet
        return 0
    }

    # FIXME This part below is a bit odd since it essentially replicates what
    # the dl ice supposed to be doing.
    # TL;DR below downloads whatever url is stored in the "_resolved" field
    if (( !${+ICE[git]} && !${+ICE[from]} )) {
        (
            local -A jsondata
            local URL=$(.zinit-json-get-value "$pkgjson" "_resolved")
            local fname="${${URL%%\?*}:t}"

            command mkdir -p $dir || {
                +zi-log "{u-warn}Error{b-warn}:{error} Couldn't create directory:" \
                    "{dir}$dir{error}, aborting.{rst}"
                return 1
            }
            builtin cd -q $dir || return 1

            +zi-log "Downloading tarball for {pid}$plugin{rst}{…}"

            if { ! .zinit-download-file-stdout "$URL" 0 1 >! "$fname" } {
                if { ! .zinit-download-file-stdout "$URL" 1 1 >! "$fname" } {
                    command rm -f "$fname"
                    +zi-log "Download of the file {apo}\`{file}$fname{apo}\`{rst}" \
                        "failed. No available download tool? One of:" \
                        "{cmd}${(pj:$tool_sep:)${=:-curl wget lftp lynx}}{rst}."

                    return 1
                }
            }

            # When extract ice is set, the ∞zinit-extract-hook will handle
            # extraction; otherwise extract here with --move as default.
            if (( !${+ICE[extract]} )); then
                ziextract "$fname" --move
            fi
            return 0
        ) && {
            reply=( "$user" "$plugin" )
            REPLY=tarball
        }
    } else {
            reply=( "${ICE[user]:-$user}" "${ICE[plugin]:-$plugin}" )
            if [[ ${ICE[from]} = (|gh-r|github-rel) ]]; then
                REPLY=github
            else
                REPLY=unknown
            fi
    }

    return $?
} # ]]]
# FUNCTION: .zinit-setup-plugin-dir [[[
# Clones given plugin into PLUGIN_DIR. Supports multiple
# sites (respecting `from' and `proto' ice modifiers).
# Invokes compilation of plugin's main file.
#
# $1 - user
# $2 - plugin
.zinit-setup-plugin-dir() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt extendedglob warncreateglobal noshortloops rcquotes

    local user=$1 plugin=$2 id_as=$3 remote_url_path=${1:+$1/}$2 \
        local_path tpe=$4 update=$5 version=$6

    if .zinit-get-object-path plugin "$id_as" && [[ -z $update ]] {
        +zi-log "{u-warn}ERROR{b-warn}:{error} A plugin named {pid}$id_as{error}" \
                "already exists, aborting."
        return 1
    }
    local_path=$REPLY

    trap "rmdir ${(qqq)local_path}/._zinit ${(qqq)local_path} 2>/dev/null" EXIT
    trap "rmdir ${(qqq)local_path}/._zinit ${(qqq)local_path} 2>/dev/null; return 1" INT TERM QUIT HUP

    local -A sites
    sites=(
        github    github.com
        gh        github.com
        bitbucket bitbucket.org
        bb        bitbucket.org
        gitlab    gitlab.com
        gl        gitlab.com
        notabug   notabug.org
        nb        notabug.org
        github-rel github.com/$remote_url_path/releases
        gh-r      github.com/$remote_url_path/releases
        cygwin    cygwin
    )

    ZINIT[annex-multi-flag:pull-active]=${${${(M)update:#-u}:+${ZINIT[annex-multi-flag:pull-active]}}:-2}

    local -a arr

    if [[ $user = _local ]]; then
        builtin print "Warning: no local plugin \`$plugin\'."
        builtin print "(should be located at: $local_path)"
        return 1
    fi

    command rm -f ${TMPDIR:-/tmp}/zinit-execs.$$.lst ${TMPDIR:-/tmp}/zinit.installed_comps.$$.lst \
                  ${TMPDIR:-/tmp}/zinit.skipped_comps.$$.lst ${TMPDIR:-/tmp}/zinit.compiled.$$.lst

    if [[ $tpe != tarball ]] {
        if [[ -z $update ]] {
            .zinit-any-colorify-as-uspl2 "$user" "$plugin"
            local pid_hl='{pid}' id_msg_part=" (at label: {id-as}$id_as{rst})"
            +zi-log "{nl}{i} Downloading {b}{file}$user${user:+/}$plugin{rst} ${${${id_as:#$user/$plugin}}:+$id_msg_part}{rst}"
        }

        local site
        [[ -n ${ICE[from]} ]] && site=${sites[${ICE[from]}]}
        if [[ -z $site && ${ICE[from]} = *(gh-r|github-rel)* ]] {
            site=${ICE[from]/(gh-r|github-re)/${sites[gh-r]}}
        }
    }

    (
        if [[ $site = */releases ]] {
            local tag_version=${ICE[ver]}
            if [[ -z $tag_version ]]; then
                local url="https://$site/latest"
                tag_version="$({.zinit-download-file-stdout $url || .zinit-download-file-stdout $url 1;} 2>/dev/null | command grep -i -m 1 -o 'href=./'$user'/'$plugin'/releases/tag/[^"]\+')"
                tag_version=${tag_version##*/}
            fi
            local url=$site/expanded_assets/$tag_version

            .zinit-get-latest-gh-r-url-part "$user" "$plugin" "$url" || return $?

            command mkdir -p "$local_path"
            [[ -d "$local_path" ]] || return 1

            (
                () { setopt localoptions noautopushd; builtin cd -q "$local_path"; } || return 1
                integer count

                for REPLY ( $reply ) {
                    count+=1
                    url="https://github.com${REPLY}"
                    if [[ -d $local_path/._zinit ]] {
                        { local old_version="$(<$local_path/._zinit/is_release${count:#1})"; } 2>/dev/null
                        old_version=${old_version/(#b)(\/[^\/]##)(#c4,4)\/([^\/]##)*/${match[2]}}
                    }
                    +zi-log "{m} Requesting ${REPLY:t} ${version:+, version $version} ${old_version:+ Current version: $old_version.}{rst}"
                    if { ! .zinit-download-file-stdout "$url" 0 1 >! "${REPLY:t}" } {
                        if { ! .zinit-download-file-stdout "$url" 1 1 >! "${REPLY:t}" } {
                            command rm -f "${REPLY:t}"
                            +zi-log "Download of release for \`$remote_url_path' " \
                                "failed.{nl}Tried url: $url."
                            return 1
                        }
                    }
                    if .zinit-download-file-stdout "$url.sig" 2>/dev/null >! "${REPLY:t}.sig"; then
                        :
                    else
                        command rm -f "${REPLY:t}.sig"
                    fi

                    command mkdir -p ._zinit && echo '*' > ._zinit/.gitignore
                    [[ -d ._zinit ]] || return 2
                    builtin print -r -- $url >! ._zinit/url || return 3
                    builtin print -r -- ${REPLY} >! ._zinit/is_release${count:#1} || return 4
                    # When extract ice is set, the ∞zinit-extract-hook will
                    # handle extraction; otherwise extract here (no move).
                    if (( !${+ICE[extract]} )); then
                        ziextract ${REPLY:t} ${${${#reply}:#1}:+--nobkp}
                    fi
                }
                return $?
            ) || {
                return 1
            }
        } elif [[ $site = cygwin ]] {
            command mkdir -p "$local_path/._zinit" && echo '*' > "$local_path/._zinit/.gitignore"
            [[ -d "$local_path" ]] || return 1

            (
                () { setopt localoptions noautopushd; builtin cd -q "$local_path"; } || return 1
                .zinit-get-cygwin-package "$remote_url_path" || return 1
                builtin print -r -- $REPLY >! ._zinit/is_release
                ziextract "$REPLY"
            ) || return $?
        } elif [[ $tpe = github ]] {
            case ${ICE[proto]} in
                (|ftp(|s)|git|http(|s)|rsync|ssh)
                    :zinit-git-clone() {
                        local clone_url
                        if [[ ${ICE[proto]} == "ssh" ]]; then
                            clone_url="git@${site:-${ICE[from]:-github.com}}:$remote_url_path"
                        else
                            clone_url="${ICE[proto]:-https}://${site:-${ICE[from]:-github.com}}/$remote_url_path"
                        fi
                        command git clone --progress ${(s: :)ICE[cloneopts]---recursive} \
                            ${(s: :)ICE[depth]:+--depth ${ICE[depth]}} \
                            "$clone_url" \
                            "$local_path" \
                            --config transfer.fsckobjects=false \
                            --config receive.fsckobjects=false \
                            --config fetch.fsckobjects=false \
                            --config pull.rebase=false
                            integer retval=$?
                            unfunction :zinit-git-clone
                            return $retval
                    }
                    :zinit-git-clone |& { command ${ZINIT[BIN_DIR]}/share/git-process-output.zsh || cat; }
                    if (( pipestatus[1] == 141 )) {
                        :zinit-git-clone
                        integer retval=$?
                        if (( retval )) {
                            builtin print -Pr -- "$ZINIT[col-error]Clone failed (code: $ZINIT[col-obj]$retval$ZINIT[col-error]).%f%b"
                            return 1
                        }
                    } elif (( pipestatus[1] )) {
                        builtin print -Pr -- "$ZINIT[col-error]Clone failed (code: $ZINIT[col-obj]$pipestatus[1]$ZINIT[col-error]).%f%b"
                        return 1
                    }
                    ;;
                (*)
                    builtin print -Pr "${ZINIT[col-error]}Unknown protocol:%f%b ${ICE[proto]}."
                    return 1
            esac

            if [[ -n ${ICE[ver]} ]] {
                command git -C "$local_path" checkout "${ICE[ver]}"
            }
        }

        if [[ $update != -u ]] {
            hook_rc=0
            # Store ices at clone of a plugin
            .zinit-store-ices "$local_path/._zinit" ICE "" "" "" ""
            reply=(
                ${(on)ZINIT_EXTS2[(I)zinit hook:\!atclone-pre <->]}
                ${(on)ZINIT_EXTS[(I)z-annex hook:\!atclone-<-> <->]}
                ${(on)ZINIT_EXTS2[(I)zinit hook:\!atclone-post <->]}
            )
            for key in "${reply[@]}"; do
                arr=( "${(Q)${(z@)ZINIT_EXTS[$key]:-$ZINIT_EXTS2[$key]}[@]}" )
                # Functions calls
                "${arr[5]}" plugin "$user" "$plugin" "$id_as" "$local_path" "${${key##(zinit|z-annex) hook:}%% <->}" load
                hook_rc=$?
                [[ "$hook_rc" -ne 0 ]] && {
                    # note: this will effectively return the last != 0 rc
                    retval="$hook_rc"
                    builtin print -Pr -- "${ZINIT[col-warn]}Warning:%f%b ${ZINIT[col-obj]}${arr[5]}${ZINIT[col-warn]} hook returned with ${ZINIT[col-obj]}${hook_rc}${ZINIT[col-rst]}"
                }
            done

            # Run annexes' atclone hooks (the after atclone-ice ones)
            reply=(
                ${(on)ZINIT_EXTS2[(I)zinit hook:atclone-pre <->]}
                ${(on)ZINIT_EXTS[(I)z-annex hook:atclone-<-> <->]}
                ${(on)ZINIT_EXTS2[(I)zinit hook:atclone-post <->]}
            )
            for key in "${reply[@]}"; do
                arr=( "${(Q)${(z@)ZINIT_EXTS[$key]:-$ZINIT_EXTS2[$key]}[@]}" )
                "${arr[5]}" plugin "$user" "$plugin" "$id_as" "$local_path" "${${key##(zinit|z-annex) hook:}%% <->}"
                hook_rc=$?
                [[ "$hook_rc" -ne 0 ]] && {
                    retval="$hook_rc"
                    builtin print -Pr -- "${ZINIT[col-warn]}Warning:%f%b ${ZINIT[col-obj]}${arr[5]}${ZINIT[col-warn]} hook returned with ${ZINIT[col-obj]}${hook_rc}${ZINIT[col-rst]}"
                }
            done
        }

        return "$retval"
    ) || return $?

    typeset -ga INSTALLED_EXECS
    { INSTALLED_EXECS=( "${(@f)$(<${TMPDIR:-/tmp}/zinit-execs.$$.lst)}" ) } 2>/dev/null

    # After additional executions like atclone'' - install completions (1 - plugins)
    local -A OPTS
    OPTS[opt_-q,--quiet]=1
    [[ (0 = ${+ICE[nocompletions]} && ${ICE[as]} != null && ${+ICE[null]} -eq 0) || 0 != ${+ICE[completions]} ]] && \
        .zinit-install-completions "$id_as" "" "0"

    if [[ -e ${TMPDIR:-/tmp}/zinit.skipped_comps.$$.lst || -e ${TMPDIR:-/tmp}/zinit.installed_comps.$$.lst ]] {
        typeset -ga INSTALLED_COMPS SKIPPED_COMPS
        { INSTALLED_COMPS=( "${(@f)$(<${TMPDIR:-/tmp}/zinit.installed_comps.$$.lst)}" ) } 2>/dev/null
        { SKIPPED_COMPS=( "${(@f)$(<${TMPDIR:-/tmp}/zinit.skipped_comps.$$.lst)}" ) } 2>/dev/null
    }

    if [[ -e ${TMPDIR:-/tmp}/zinit.compiled.$$.lst ]] {
        typeset -ga ADD_COMPILED
        { ADD_COMPILED=( "${(@f)$(<${TMPDIR:-/tmp}/zinit.compiled.$$.lst)}" ) } 2>/dev/null
    }

    # After any download – rehash the command table
    # This will however miss the as"program" binaries
    # as their PATH gets extended - and it is done
    # later. It will however work for sbin'' ice.
    (( !OPTS[opt_-p,--parallel] )) && rehash

    return 0
} # ]]]
# FUNCTION: .zinit-install-completions [[[
# Installs all completions of given plugin. After that they are visible to
# 'compinit'. Visible completions can be selectively disabled and enabled. User
# can access completion data with 'completions' subcommand.
#
# $1 - plugin spec (4 formats: user---plugin, user/plugin, user, plugin)
# $2 - plugin if $1 (i.e., user) given
# $3 - if 1, then reinstall, otherwise only install completions that are not present
.zinit-install-completions() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt nullglob extendedglob warncreateglobal typesetsilent noshortloops

    local id_as=$1${2:+${${${(M)1:#%}:+$2}:-/$2}}
    local reinstall=${3:-0} quiet=${${4:+1}:-0}
    (( OPTS[opt_-q,--quiet] )) && quiet=1
    [[ $4 = -Q ]] && quiet=2
    typeset -ga INSTALLED_COMPS SKIPPED_COMPS
    INSTALLED_COMPS=() SKIPPED_COMPS=()

    .zinit-any-to-user-plugin "$id_as" ""
    local user=${reply[-2]}
    local plugin=${reply[-1]}
    .zinit-any-colorify-as-uspl2 "$user" "$plugin"
    local abbrev_pspec=$REPLY

    .zinit-exists-physically-message "$id_as" "" || return 1

    # Symlink any completion files included in the plugin directory
    typeset -a completions already_symlinked backup_comps
    local c cfile bkpfile
    # The plugin == . is a semi-hack/trick to handle 'creinstall .' properly
    [[ $user == % || ( -z $user && $plugin == . ) ]] && \
        completions=( "${plugin}"/**/_[^_.]*~*(*.zwc|*.html|*.txt|*.png|*.jpg|*.jpeg|*.js|*.md|*.yml|*.yaml|*.py|*.ri|_zsh_highlight*|/zsdoc/*|*.ps1)(DN^/) ) || \
        completions=( "${ZINIT[PLUGINS_DIR]}/${id_as//\//---}"/**/_[^_.]*~*(*.zwc|*.html|*.txt|*.png|*.jpg|*.jpeg|*.js|*.md|*.yml|*.yaml|*.py|*.ri|_zsh_highlight*|/zsdoc/*|*.ps1)(DN^/) )
    already_symlinked=( "${ZINIT[COMPLETIONS_DIR]}"/_[^_.]*~*.zwc(DN) )
    backup_comps=( "${ZINIT[COMPLETIONS_DIR]}"/[^_.]*~*.zwc(DN) )

    # Symlink completions if they are not already there
    # either as completions (_fname) or as backups (fname)
    # OR - if its a reinstall
    for c in "${completions[@]:A}"; do
        cfile="${c:t}"
        bkpfile="${cfile#_}"
        if [[ ( -z ${already_symlinked[(r)*/$cfile]} || $reinstall = 1 ) &&
              -z ${backup_comps[(r)*/$bkpfile]}
        ]]; then
            if [[ $reinstall = 1 ]]; then
                # Remove old files
                command rm -f "${ZINIT[COMPLETIONS_DIR]}/$cfile" "${ZINIT[COMPLETIONS_DIR]}/$bkpfile"
            fi
            INSTALLED_COMPS+=( $cfile )
            (( quiet )) || builtin print -Pr "Symlinking completion ${ZINIT[col-uname]}$cfile%f%b to completions directory."
            command ln -fs "$c" "${ZINIT[COMPLETIONS_DIR]}/$cfile"
            # Make compinit notice the change
            .zinit-forget-completion "$cfile" "$quiet"
        else
            SKIPPED_COMPS+=( $cfile )
            (( quiet )) || builtin print -Pr "Not symlinking completion \`${ZINIT[col-obj]}$cfile%f%b', it already exists."
            (( quiet )) || builtin print -Pr "${ZINIT[col-info2]}Use \`${ZINIT[col-pname]}zinit creinstall $abbrev_pspec${ZINIT[col-info2]}' to force install.%f%b"
        fi
    done

    local comps msg
    local -A comp_types=(\$INSTALLED_COMPS 'Installed' \$SKIPPED_COMPS 'Skipped re-installing')
    for comps msg in ${(kv)comp_types}; do
        local comps_num=${#${(e)comps}}
        if (( comps_num > 0 )); then
            +zi-log "{m} ${msg} {num}$comps_num{rst} completion${=${comps_num:#1}:+s}"
            if (( quiet == 0 )); then
                +zi-log "{m} Added $comps_num completion${=${comps_num:#1}:+s} to {var}$comps{rst} array"
            fi
        fi
    done

    if (( ZSH_SUBSHELL )) {
        builtin print -rl -- $INSTALLED_COMPS >! ${TMPDIR:-/tmp}/zinit.installed_comps.$$.lst
        builtin print -rl -- $SKIPPED_COMPS >! ${TMPDIR:-/tmp}/zinit.skipped_comps.$$.lst
    }

    .zinit-compinit 1 1 &>/dev/null
} # ]]]
# FUNCTION: .zinit-compinit [[[
# User-exposed `compinit' frontend which first ensures that all
# completions managed by Zinit are forgotten by Zshell. After
# that it runs normal `compinit', which should more easily detect
# Zinit's completions.
#
# No arguments.
.zinit-compinit() {
    # This might be called during sourcing when setting up the plugins dir, so check that OPTS is actually existing
    [[ -n $OPTS && -n ${OPTS[opt_-p,--parallel]} && $1 != 1 ]] && return

    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    builtin setopt nullglob extendedglob warncreateglobal typesetsilent

    integer use_C=$2

    typeset -a symlinked backup_comps
    local c cfile bkpfile action

    symlinked=( "${ZINIT[COMPLETIONS_DIR]}"/_[^_.]*~*.zwc )
    backup_comps=( "${ZINIT[COMPLETIONS_DIR]}"/[^_.]*~*.zwc )

    # Delete completions if they are really there, either
    # as completions (_fname) or backups (fname)
    for c in "${symlinked[@]}" "${backup_comps[@]}"; do
        action=0
        cfile="${c:t}"
        cfile="_${cfile#_}"
        bkpfile="${cfile#_}"

        #print -Pr "${ZINIT[col-info]}Processing completion $cfile%f%b"
        .zinit-forget-completion "$cfile"
    done

    +zi-log "Initializing completion ({func}compinit{rst}){…}"
    command rm -f ${ZINIT[ZCOMPDUMP_PATH]:-${ZDOTDIR:-$HOME}/.zcompdump}

    # Workaround for a nasty trick in _vim
    (( ${+functions[_vim_files]} )) && unfunction _vim_files

    builtin autoload -Uz compinit
    compinit ${${(M)use_C:#1}:+-C} -d ${ZINIT[ZCOMPDUMP_PATH]:-${ZDOTDIR:-$HOME}/.zcompdump} "${(Q@)${(z@)ZINIT[COMPINIT_OPTS]}}"
} # ]]]
# FUNCTION: .zinit-download-file-stdout [[[
# Downloads file to stdout. Supports following backend commands:
# curl, wget, lftp, lynx. Used by snippet loading.
.zinit-download-file-stdout() {
    local url="$1" restart="$2" progress="${(M)3:#1}"

    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt localtraps extendedglob

    # Return file directly for file:// urls, wget doesn't support this schema
    if [[ "$url" =~ ^file:// ]] {
        local filepath=${url##file://}
        <"$filepath"
        return "$?"
    }

    if (( restart )) {
        (( ${path[(I)/usr/local/bin]} )) || \
            {
                path+=( "/usr/local/bin" );
                trap "path[-1]=()" EXIT
            }

        if (( ${+commands[curl]} )); then
            if [[ -n $progress ]]; then
                command curl --progress-bar -fSL "$url" 2> >(.zinit-single-line >&2) || return 1
            else
                command curl -fsSL "$url" || return 1
            fi
        elif (( ${+commands[wget]} )); then
            command wget ${${progress:--q}:#1} "$url" -O - || return 1
        elif (( ${+commands[lftp]} )); then
            command lftp -c "cat $url" || return 1
        elif (( ${+commands[lynx]} )); then
            command lynx -source "$url" || return 1
        else
            +zi-log "{u-warn}ERROR{b-warn}:{rst}No download tool detected" \
                "(one of: {cmd}curl{rst}, {cmd}wget{rst}, {cmd}lftp{rst}," \
                "{cmd}lynx{rst})."
            return 2
        fi
    } else {
        if type curl 2>/dev/null 1>&2; then
            if [[ -n $progress ]]; then
                command curl --progress-bar -fSL "$url" 2> >(.zinit-single-line >&2) || return 1
            else
                command curl -fsSL "$url" || return 1
            fi
        elif type wget 2>/dev/null 1>&2; then
            command wget ${${progress:--q}:#1} "$url" -O - || return 1
        elif type lftp 2>/dev/null 1>&2; then
            command lftp -c "cat $url" || return 1
        else
            .zinit-download-file-stdout "$url" "1" "$progress"
            return $?
        fi
    }

    return 0
} # ]]]
# FUNCTION: .zinit-get-url-mtime [[[
# For the given URL returns the date in the Last-Modified
# header as a time stamp
.zinit-get-url-mtime() {
    local url="$1" IFS line header
    local -a cmd

    setopt localoptions localtraps

    (( !${path[(I)/usr/local/bin]} )) && \
        {
            path+=( "/usr/local/bin" );
            trap "path[-1]=()" EXIT
        }

    if (( ${+commands[curl]} )) || type curl 2>/dev/null 1>&2; then
        cmd=(command curl -sIL "$url")
    elif (( ${+commands[wget]} )) || type wget 2>/dev/null 1>&2; then
        cmd=(command wget --server-response --spider -q "$url" -O -)
    else
        REPLY=$(( $(date +"%s") ))
        return 2
    fi

    "${cmd[@]}" |& command grep -i Last-Modified: | while read -r line; do
        header="${${line#*, }//$'\r'}"
    done

    if [[ -z $header ]] {
        REPLY=$(( $(date +"%s") ))
        return 3
    }

    LANG=C TZ=UTC strftime -r -s REPLY "%d %b %Y %H:%M:%S GMT" "$header" &>/dev/null || {
        REPLY=$(( $(date +"%s") ))
        return 4
    }

    return 0
} # ]]]
# FUNCTION: .zinit-mirror-using-svn [[[
# Used to clone subdirectories from Github. If in update mode
# (see $2), then invokes `svn update', in normal mode invokes
# `svn checkout --non-interactive -q <URL>'. In test mode only
# compares remote and local revision and outputs true if update
# is needed.
#
# $1 - URL
# $2 - mode, "" - normal, "-u" - update, "-t" - test
# $3 - subdirectory (not path) with working copy, needed for -t and -u
.zinit-mirror-using-svn() {
    setopt localoptions extendedglob warncreateglobal
    local url="$1" update="$2" directory="$3"

    (( ${+commands[svn]} )) || \
        builtin print -Pr -- "${ZINIT[col-error]}Warning:%f%b Subversion not found" \
            ", please install it to use \`${ZINIT[col-obj]}svn%f%b' ice."

    if [[ "$update" = "-t" ]]; then
        (
            () { setopt localoptions noautopushd; builtin cd -q "$directory"; }
            local -a out1 out2
            out1=( "${(f@)"$(LANG=C svn info -r HEAD)"}" )
            out2=( "${(f@)"$(LANG=C svn info)"}" )

            out1=( "${(M)out1[@]:#Revision:*}" )
            out2=( "${(M)out2[@]:#Revision:*}" )
            [[ "${out1[1]##[^0-9]##}" != "${out2[1]##[^0-9]##}" ]] && return 0
            return 1
        )
        return $?
    fi
    if [[ "$update" = "-u" && -d "$directory" && -d "$directory/.svn" ]]; then
        ( () { setopt localoptions noautopushd; builtin cd -q "$directory"; }
          command svn update
          return $? )
    else
        command svn checkout --non-interactive -q "$url" "$directory"
    fi
    return $?
} # ]]]
... truncated; 1,651 more lines

    #...     ..      ..                                    ..
  #x*8888x.:*8888: -"888:                            < .z@8"`
 #X   48888X `8888H  8888                 u.    u.    !@88E
#X8x.  8888X  8888X  !888>       .u     x@88k u@88c.  '888E   u
#X8888 X8888  88888   "*8%-   ud8888.  ^"8888""8888"   888E u@8NL
#'*888!X8888> X8888  xH8>   :888'8888.   8888  888R    888E`"88*"
#  `?8 `8888  X888X X888>   d888 '88%"   8888  888R    888E .dN.
  #-^  '888"  X888  8888>   8888.+"      8888  888R    888E~8888
   #dx '88~x. !88~  8888>   8888L        8888  888R    888E '888&
 #.8888Xf.888x:!    X888X.: '8888c. .+  "*88*" 8888"   888E  9888.
#:""888":~"888"     `888*"   "88888%      ""   'Y"   '"888*" 4888"
    #"~'    "~        ""       "YP'                     ""    ""



               #.....
            #.H8888888h.  ~-.                         .uef^"
            #888888888888x  `>                      :d88E
     #.u    X~     `?888888hx~      .u          .   `888E
  #ud8888.  '      x8.^"*88*"    ud8888.   .udR88N   888E .z8k
#:888'8888.  `-:- X8888x       :888'8888. <888'888k  888E~?888L
#d888 '88%"       488888>      d888 '88%" 9888 'Y"   888E  888E
#8888.+"        .. `"88*       8888.+"    9888       888E  888E
#8888L        x88888nX"      . 8888L      9888       888E  888E
#'8888c. .+  !"*8888888n..  :  '8888c. .+ ?8888u../  888E  888E
 #"88888%   '    "*88888888*    "88888%    "8888P'  m888N= 888>
   #"YP'            ^"***"`       "YP'       "P'     `Y"   888
                                                         #J88"
                                                         #@%
                                                       #:"
                                #..                            .
                          #x .d88"                            @88>
   #u.    u.          u.    5888R          u.                 %8P
 #x@88k u@88c.  ...ue888b   '888R    ...ue888b       uL        .
#^"8888""8888"  888R Y888r   888R    888R Y888r  .ue888Nc..  .@88u
  #8888  888R   888R I888>   888R    888R I888> d88E`"888E` ''888E`
  #8888  888R   888R I888>   888R    888R I888> 888E  888E    888E
  #8888  888R   888R I888>   888R    888R I888> 888E  888E    888E
  #8888  888R  u8888cJ888    888R   u8888cJ888  888E  888E    888E
 #"*88*" 8888"  "*888*P"    .888B .  "*888*P"   888& .888E    888&
   #""   'Y"      'Y"       ^*888%     'Y"      *888" 888&    R888"
                             #"%                 `"   "888E    ""
                                               #.dWi   `88E
                                               #4888~  J8%
                                                #^"===*"`
              #.x+=:.
             #z`    ^%
                #.   <k
     #.u       .@8Ned8"
  #ud8888.   .@^%8888"
#:888'8888. x88:  `)8b.
#d888 '88%" 8888N=*8888
#8888.+"     %8"    R88
#8888L        @8Wou 9%
#'8888c. .+ .888888P`
 #"88888%   `   ^"F
   #"YP'

#
# https://github.com/MenkeTechnologies
#

#{{{                    MARK:start timestamp
#**************************************************************
builtin zmodload zsh/datetime
startTimestamp=$EPOCHREALTIME
#}}}***********************************************************

#{{{                    MARK:hash dir cache for instant prompt
#**************************************************************
# source cached hash dirs so %~ resolves ~ZPWR in instant prompt
# cache is generated by zpwrBindDirs during init
if [[ -r "$HOME/.zpwr/local/zpwr-hash-dirs.zsh" ]]; then
    source "$HOME/.zpwr/local/zpwr-hash-dirs.zsh"
fi
#}}}***********************************************************

#{{{                    MARK:p10k instant prompt
#**************************************************************
# must stay near the top before any console output
if [[ -r "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh" ]]; then
    source "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh"
fi
promptTimestamp=$EPOCHREALTIME
#}}}***********************************************************

#{{{                    MARK:FPATH AND PATH NO DUPLICATES
#**************************************************************
# FPATH should not be exported
builtin typeset +x FPATH
#}}}***********************************************************

#{{{                    MARK:ZPWR source env file which sources lib
#**************************************************************
if [[ -z $ZSH_ARGZERO ]]; then
    0="${(%):-%N}"
else
    0="${${0:#$ZSH_ARGZERO}:-${(%):-%N}}"
fi

# convert $0 to abs path
0="${${(M)0:#/*}:-$PWD/$0}"

# from .zpwr/install/.zshrc to .zpwr/
builtin export ZPWR="${0:A:h:h}"
builtin export ZPWR_ENV="$ZPWR/env"

builtin export ZPWR_ENV_FILE="$ZPWR_ENV/.zpwr_env.sh"
builtin export ZPWR_RE_ENV_FILE="$ZPWR_ENV/.zpwr_re_env.sh"

# map to hold global data between scripts
builtin typeset -Ag ZPWR_VARS
# map to store each zpwr verb, key is the verbname, value is cmd=description
builtin typeset -Ag ZPWR_VERBS

function zpwrInitEnv() {
    builtin source "$ZPWR_ENV_FILE" || {
        builtin echo "where is ZPWR_ENV_FILE '$ZPWR_ENV_FILE'" >&2
        return 1
    }
}

zpwrInitEnv
ZPWR_VARS[phaseEnvTs]=$EPOCHREALTIME

function rm(){

    if [[ -z "$1" ]]; then
        zpwrLogConsoleErr "usage: rm FILE"
        return 1
    fi

    command rm -v "$@"
}

# You may need to manually set your language environment
# has all aliases and functions common to bourne like shells
builtin test -s "$ZPWR_ALIAS_FILE" && builtin source "$ZPWR_ALIAS_FILE"

if [[ ! -d "$ZPWR_LOCAL_TEMP" ]]; then
    command mkdir -p "$ZPWR_LOCAL_TEMP"
fi

if [[ "$ZPWR_PLUGIN_MANAGER" == zinit ]]; then
    builtin typeset -A ZINIT
    if [[ ! -d "$ZPWR_PLUGIN_MANAGER_HOME/bin" ]]; then
        zpwrPrettyPrintBox "Installing zinit"
        command mkdir -p "$ZPWR_PLUGIN_MANAGER_HOME/bin"
        command git clone https://github.com/$ZPWR_ZDHARMA/zinit.git "$ZPWR_PLUGIN_MANAGER_HOME/bin"
    else
        ZINIT[OPTIMIZE_OUT_DISK_ACCESSES]=1
    fi
fi
#}}}***********************************************************

#{{{                    MARK:non ZPWR Exports
#**************************************************************
builtin export LC_ALL="en_US.UTF-8"
# stop delay when entering normal mode
builtin export KEYTIMEOUT="$ZPWR_KEYTIMEOUT"
builtin export SHELL="${commands[zsh]}"
# default vi-backward-delete-char does not delete paste insert point
builtin export AUTOPAIR_BKSPC_WIDGET='.backward-delete-char'
#}}}***********************************************************

#{{{                    MARK:OMZ env vars
#**************************************************************
# Uncomment the following line to use case-sensitive completion.
# CASE_SENSITIVE="true"

# Uncomment the following line to use hyphen-insensitive completion. Case
# sensitive completion must be off. _ and - will be interchangeable.
HYPHEN_INSENSITIVE="true"

# Uncomment the following line to disable colors in ls.
# DISABLE_LS_COLORS="true"

# Uncomment the following line to disable auto-setting terminal title.
# DISABLE_AUTO_TITLE="true"

# Uncomment the following line to enable command auto-correction.
# ENABLE_CORRECTION="true"

# UNCOMMENT THE FOLLOWING LINE IF YOU WANT TO DISABLE MARKING UNTRACKED FILES
# under VCS as dirty. This makes repository status check for large repositories
# much, much faster.
DISABLE_UNTRACKED_FILES_DIRTY="true"

# Uncomment the following line if you want to change the command execution time
# stamp shown in the history command output.
# The optional three formats: "mm/dd/yyyy"|"dd.mm.yyyy"|"yyyy-mm-dd"
HIST_STAMPS="mm/dd/yyyy"

# ssh
builtin export SSH_KEY_PATH="~/.ssh/rsa_id"

#get rid of mercurial prompt
hg_prompt_info(){}
# User configuration

ZSH_AUTOSUGGEST_STRATEGY=( match_prev_cmd )

ZSH_DISABLE_COMPFIX=true
#}}}***********************************************************

#{{{                    MARK:Zinit plugins and snippets
#**************************************************************
ZPWR_GH_PLUGINS=(
    MenkeTechnologies/zsh-z
    MenkeTechnologies/fasd-simple
    MenkeTechnologies/fzf-tab
    MenkeTechnologies/gh_reveal
    $ZPWR_ZDHARMA/history-search-multi-word
    MenkeTechnologies/jhipster-oh-my-zsh-plugin
    MenkeTechnologies/revolver
    $ZPWR_ZDHARMA/zbrowse
    zsh-users/zsh-completions
    MenkeTechnologies/zsh-git-acp
    MenkeTechnologies/zsh-sudo
    MenkeTechnologies/zsh-nginx
    MenkeTechnologies/zsh-sed-sub
    $ZPWR_ZDHARMA/zsh-tig-plugin
    MenkeTechnologies/zsh-travis
    MenkeTechnologies/zsh-git-repo-cache
    $ZPWR_ZDHARMA/zsh-unique-id
    MenkeTechnologies/zsh-very-colorful-manuals
    $ZPWR_ZDHARMA/zui
    MenkeTechnologies/zunit
    $ZPWR_ZDHARMA/zzcomplete
    marlonrichert/zsh-hist
    MenkeTechnologies/fzf-zsh-plugin
    #comps
    MenkeTechnologies/zsh-gem-completion
    MenkeTechnologies/zsh-cargo-completion
    MenkeTechnologies/zsh-cpan-completion
    MenkeTechnologies/zsh-pip-description-completion
    MenkeTechnologies/zsh-xcode-completions
    MenkeTechnologies/zsh-better-npm-completion
)

ZPWR_OMZ_PLUGINS=(
    rust
    gcloud
    ruby
    rake
    yarn
    coffee
    node
    npm
    perl
    git
    github
    mvn
    python
    golang
    man
    nmap
    postgres
    colorize
    rsync
    vundle
    meteor
    gulp
    grunt
    glassfish
    tig
    tmux
    gradle
    grails
)

ZPWR_OMZ_LIBS=(
    git.zsh
    directories.zsh
    grep.zsh
    functions.zsh
)

ZPWR_OMZ_COMPS=(
    ng/_ng
    coffee/_coffee
    scala/_scala
    lein/_lein
    glassfish/_asadmin
    spring/_spring
    redis-cli/_redis-cli
    rust/_rustc
    github/_hub
    meteor/_meteor
    yarn/_yarn
    golang/_golang
)

# conditional plugins
if zpwrCommandExists dotnet; then
    ZPWR_GH_PLUGINS+=( MenkeTechnologies/zsh-dotnet-completion )
fi

if zpwrCommandExists docker; then
    ZPWR_GH_PLUGINS+=( MenkeTechnologies/zsh-docker-aliases )
fi

if zpwrCommandExists docker-compose; then
    ZPWR_OMZ_PLUGINS+=( docker-compose )
    ZPWR_OMZ_COMPS+=( docker-compose/_docker-compose )
fi

if zpwrCommandExists ngrok; then
    ZPWR_OMZ_PLUGINS+=( ngrok)
fi

if zpwrCommandExists kubectl;then
    ZPWR_GH_PLUGINS+=( MenkeTechnologies/kubectl-aliases nnao45/zsh-kubectl-completion )
fi

if zpwrCommandExists oc;then
    ZPWR_GH_PLUGINS+=( MenkeTechnologies/zsh-openshift-aliases )
fi

if zpwrCommandExists systemctl; then
    ZPWR_OMZ_PLUGINS+=( systemd )
    fpath+=( $ZPWR_AUTOLOAD_SYSTEMCTL )
fi

zpwrCommandExists subl && ZPWR_OMZ_PLUGINS+=( sublime )
zpwrCommandExists svn && ZPWR_OMZ_PLUGINS+=( svn )

if [[ $ZPWR_OS_TYPE == linux ]]; then
    zpwrOsDebVsUbuntu \
        'ZPWR_OMZ_PLUGINS+=( debian )' \
        'ZPWR_OMZ_PLUGINS+=( ubuntu )' \
        'ZPWR_EXA_EXTENDED=false'
elif [[ $ZPWR_OS_TYPE == darwin ]]; then
    ZPWR_OMZ_PLUGINS+=( xcode )
    ZPWR_OMZ_COMPS+=( xcode/_xcselv )
fi


if [[ $ZPWR_LEARN != false ]]; then
    ZPWR_GH_PLUGINS=( $ZPWR_GH_PLUGINS MenkeTechnologies/zsh-learn )
fi

#}}}***********************************************************

#{{{                    MARK:source tokens pre OMZ
#**************************************************************
function zpwrTokenPre() {

    if builtin test -f "$ZPWR_TOKEN_PRE"; then
        if ! builtin source "$ZPWR_TOKEN_PRE"; then
            zpwrLogConsoleErr "could not source ZPWR_TOKEN_PRE '$ZPWR_TOKEN_PRE'"
        fi
    else
        : >| "$ZPWR_TOKEN_PRE"
    fi

    builtin source "$ZPWR_RE_ENV_FILE" || {
        echo "where is ZPWR_RE_ENV_FILE$ZPWR_RE_ENV_FILE" >&2
    }
}

zpwrTokenPre

if [[ $ZPWR_PROFILING == true ]]; then
    # profiling startup
    builtin zmodload zsh/zprof
fi
#}}}***********************************************************

#{{{                    MARK:post first token
#**************************************************************
if [[ ! -d $ZPWR ]]; then
    command mkdir -p $ZPWR
fi

if [[ ! -d $ZPWR_INSTALL ]]; then
    command mkdir -p $ZPWR_INSTALL
fi

if [[ ! -d $ZPWR_TMUX_LOCAL ]]; then
    command mkdir -p $ZPWR_TMUX_LOCAL
fi

if [[ ! -d $ZPWR_LOCAL ]]; then
    command mkdir -p $ZPWR_LOCAL
fi
#}}}***********************************************************

#{{{                    MARK:FPATH setup
#**************************************************************
#if [[ $ZPWR_DEBUG == true ]]; then
    #echo "______pre fpath size '$#fpath'" and '$fpath'"'_____ = ""'$fpath'" >> $ZPWR_LOGFILE
#fi
fpath=( $ZPWR_AUTOLOAD_COMMON $ZPWR_AUTOLOAD_COMP_UTILS $ZPWR_COMPS $fpath )
#}}}***********************************************************
#
#{{{                    MARK:Autoload
#**************************************************************
builtin autoload -z $ZPWR_AUTOLOAD_COMMON/*(.:t) $ZPWR_AUTOLOAD_COMP_UTILS/*(.:t)
builtin autoload -Uz zrecompile zmv zargs compinit

if [[ "$ZPWR_OS_TYPE" == "darwin" ]];then
    ZPWR_OMZ_PLUGINS+=( brew )
    ZPWR_OMZ_PLUGINS+=( macos )
    ZPWR_OMZ_COMPS+=( macos/_security )
    ZPWR_OMZ_COMPS+=( pod/_pod )

    # add ZPWR autoload dirs to fpath
    fpath=( $ZPWR_AUTOLOAD_DARWIN "$HOMEBREW_PREFIX/share/zsh/site-functions" $fpath )
    builtin autoload -z $ZPWR_AUTOLOAD_DARWIN/*(.:t)
    # determine if this terminal was started in IDE
    #[[ "$ZPWR_PARENT_PROCESS" == *(#i)(login|tmux|vim|alacritty)* ]] && plugins+=(tmux)
elif [[ "$ZPWR_OS_TYPE" == "linux" ]];then

    # add ZPWR autoload dirs to fpath
    fpath=( $ZPWR_AUTOLOAD_LINUX $fpath )
    builtin autoload -z $ZPWR_AUTOLOAD_LINUX/*(.:t)
    zpwrLinuxPlugins
else
    # unix
    # add ZPWR autoload dirs to fpath
    fpath=( $ZPWR_AUTOLOAD_LINUX $fpath )
    builtin autoload -z $ZPWR_AUTOLOAD_LINUX/*(.:t)
fi
#}}}***********************************************************

#{{{                    MARK:Pre plugin manager
#**************************************************************
# vi mode
if [[ $ZPWR_BINDKEY_VI == true ]]; then
    builtin bindkey -v
else
    builtin bindkey -e
fi

#if [[ $ZPWR_DEBUG == true ]]; then
    #echo "pre: $fpath" >> "$ZPWR_LOGFILE"
#fi

function zpwrTokenPost() {

    # source .tokens.sh to override with user functions
    if builtin test -f "$ZPWR_TOKEN_POST"; then
        if ! builtin source "$ZPWR_TOKEN_POST"; then
            zpwrLogConsoleErr "could not source ZPWR_TOKEN_POST '$ZPWR_TOKEN_POST'"
        fi
    else
        : >| "$ZPWR_TOKEN_POST"
    fi

    builtin source "$ZPWR_RE_ENV_FILE" || {
        builtin echo "where is $ZPWR_RE_ENV_FILE" >&2
    }
}
#}}}***********************************************************

#{{{                    MARK:ZPWR_PLUGIN_MANAGER
#**************************************************************
ZPWR_VARS[phasePluginsTs]=$EPOCHREALTIME
if [[ "$ZPWR_PLUGIN_MANAGER" == zinit ]]; then
    ZINIT[ZCOMPDUMP_PATH]="$ZSH_COMPDUMP"
    ZINIT[COMPINIT_OPTS]='-C -u'
    builtin source "$ZPWR_PLUGIN_MANAGER_HOME/bin/zinit.zsh"
    # tell zinit where compsy cache file is

    #override zicompinit
    zicompinit() {
        compinit -u -d ${ZINIT[ZCOMPDUMP_PATH]:-${ZDOTDIR:-$HOME}/.zcompdump} "${(Q@)${(z@)ZINIT[COMPINIT_OPTS]}}" 2>/dev/null
    }

    # load prompt synchronously for instant prompt compatibility

    zinit ice lucid nocd nocompile atinit'zpwrBindPowerline; zpwrBindPowerlineTmux; zpwrBindDirs; zpwrPrecmd' \
        atload'zpwrBindPrecmd; _p9k_precmd &> /dev/null'
    zinit load romkatv/powerlevel10k

    # late
    () {
        local p

        for p in $ZPWR_OMZ_COMPS; do
            zinit ice lucid nocompile as'completion' pick'null' wait
            zinit snippet OMZP::$p
        done
        # WARNING temporary hack to allow linking OMZ completions into .zinit/completions
        zmodload -F zsh/files b:zf_ln 2>/dev/null
        for p in $ZPWR_OMZ_COMPS; do
            zf_ln -sfn $ZSH/snippets/OMZP::${p%/*}/${p#*/}/${p#*/} $ZSH/completions/${p#*/} 2>/dev/null
        done

        for p in $ZPWR_OMZ_LIBS; do
            zinit ice lucid nocompile wait atload='zpwrOmzOverrides'
            zinit snippet OMZL::$p
        done

        # late
        for p in $ZPWR_OMZ_PLUGINS; do
            zinit ice lucid nocompile wait
            zinit snippet OMZP::$p
        done

        # WARNING download extra plugin files manually until zinit supports snippets with multiple files
        if [[ $ZPWR_OS_TYPE == darwin ]]; then
            local files=(music spotify) f
            for f in ${files[@]}; do
                if [[ ! -f "$ZSH/snippets/OMZP::macos/$f" ]]; then
                    wget -qP "$ZSH/snippets/OMZP::macos" https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/main/plugins/macos/$f
                fi
            done
        fi

        if zpwrCommandExists rails; then
            zinit ice lucid nocompile nocompletions wait
            zinit snippet OMZP::rails
        fi

        # late GH plugins
        for p in $ZPWR_GH_PLUGINS; do
            zinit ice lucid nocompile wait
            zinit load $p
        done
    }

    zinit ice as'program' lucid nocompile pick'bin/fzf' wait
    zinit load MenkeTechnologies/fzf


    zinit ice as'program' lucid pick'bin/git-fuzzy' wait
    zinit load bigH/git-fuzzy


    zinit ice lucid nocompile wait atinit='zpwrBindOverrideOMZ;zpwrBindForGit'
    zinit load \
        MenkeTechnologies/forgit

    zinit ice lucid nocompile wait atinit='zpwrBindZdharma' atload'zpwrBindZdharmaPost'
    zinit load \
        MenkeTechnologies/zconvey

    # late bind autopair keystrokes
    zinit ice lucid nocompile wait'0' atload='zpwrBindInterceptSurround'
    zinit load \
        hlissner/zsh-autopair

    # override OMZ/plugin aliases with own aliases
    zinit ice lucid nocompile wait'0a' \
    atload'zpwrBindAliasesLate; zpwrCreateAliasCache; zpwrBindAliasesZshLate; zpwrBindOverrideZLE'
    zinit load \
        MenkeTechnologies/zsh-expand

    if [[ $ZPWR_AUTO_COMPLETE == true ]]; then
        zinit ice lucid nocompile wait"0b" atinit='zpwrBindOverrideAutoComplete'
    zinit load \
        MenkeTechnologies/zsh-autocomplete
    fi

    # late bind keystrokes, must come before syntax highlight
    zinit ice lucid nocompile wait'0c' atload'zpwrBindHistorySubstring'
    zinit load \
        zsh-users/zsh-history-substring-search

    # late , must come before syntax highlight
    zinit ice lucid nocompile wait'0d' \
        atload'_zsh_autosuggest_start; zpwrBindFZFLate; zpwrBindVerbs; zpwrBindZstyle'
    zinit load \
        zsh-users/zsh-autosuggestions

    # late loaded, must be last to load
    # runs ZLE keybindings to override other late loaders
    zinit ice lucid nocompile wait'0e' atinit'zpwrBindPenultimate; zpwrBindFinal; zpwrTokenPost'
    zinit load \
        MenkeTechnologies/zsh-zinit-final

    # use fpath NOT symlinks into ~/.zinit/completions
    # to have more-completions be last resort and not overrride system completions
    zinit ice lucid nocompile wait'0f' nocompletions
    zinit load \
        MenkeTechnologies/zsh-more-completions

    zinit ice lucid nocompile nocd as'null' wait"${ZPWR_ZINIT_COMPINIT_DELAY}g" \
        atinit'zicompinit; zicdreplay;zpwrBindOverrideOMZCompdefs'
    zinit light \
        MenkeTechnologies/zsh-zinit-final

    zinit ice lucid nocompile wait"${ZPWR_ZINIT_COMPINIT_DELAY}h" nocompletions atload='zpwrDedupPaths;zpwrBindPreexecChpwd'
    zinit load \
        $ZPWR_ZDHARMA/fast-syntax-highlighting

elif [[ "$ZPWR_PLUGIN_MANAGER" == oh-my-zsh ]]; then

    plugins+=(
        ${ZPWR_OMZ_COMPS[@]}
        ${ZPWR_OMZ_PLUGINS[@]}
        ${ZPWR_GH_PLUGINS[@]}
    )

    builtin source "$ZPWR_PLUGIN_MANAGER_HOME/oh-my-zsh.sh"

    if [[ $ZSH_DISABLE_COMPFIX != true ]]; then
        # Load only from secure directories
        compinit -i -C -d "$ZSH_COMPDUMP"
    else
        # If the user wants it, load from all found directories
        compinit -u -C -d "$ZSH_COMPDUMP"
    fi

else

    zpwrLogConsoleErr "Unsupported ZPWR_PLUGIN_MANAGER '$ZPWR_PLUGIN_MANAGER'!"
fi



#if [[ $ZPWR_DEBUG == true ]]; then
    #echo "\npost: $fpath" >> "$ZPWR_LOGFILE"
#fi
#}}}***********************************************************

#{{{                    MARK:Override OMZ config
#**************************************************************
ZPWR_VARS[phaseCompsysTs]=$EPOCHREALTIME
ZPWR_VARS[recachedCompsys]=false
# reload compsys cache if file is stale for 1 week
zpwrStaleZcompdump

#if ! (( $+_comps[z] )); then
    #zpwrRetryZcompdump
#else
    #zpwrLogDebug "found '${_comps[z]}' for z so used cached '$ZSH_COMPDUMP'"
    #zpwrLogDebug "_comps size: '$#_comps' fpath length: '$#fpath' path length: '$#path'"
#fi

# change history size in memory
builtin export HISTSIZE=999999999
# change history file size
builtin export SAVEHIST=99999999
#}}}***********************************************************

#{{{                    MARK:Zpwr verbs
#**************************************************************
# late loaded in autoload/common/zpwrBindVerbs
#}}}***********************************************************

#{{{                    MARK:ZLE bindkey
#**************************************************************
# ZLE keybindings late loaded in autoload/common/zpwrBindOverrideZLE
# this is to override any late loaded plugins with keybindings
#}}}***********************************************************

#{{{                    MARK:Setopt Options
#**************************************************************
ZPWR_VARS[phaseOptionsTs]=$EPOCHREALTIME
# fish like menu select search
builtin zmodload -i zsh/complist

# l=*
builtin setopt glob_assign

# no local var prints
builtin setopt typeset_silent

# long format
builtin setopt long_list_jobs

# !!:s/*//
builtin setopt histsubst_pattern

# allow '' escape
builtin setopt rc_quotes

# allow **.c
builtin setopt globstarshort

# allow {abcd0-9} expansion
builtin setopt braceccl

# Allow comments even in interactive shells (especially for Muness)
builtin setopt interactive_comments

# If you type foo, and it isn't a command, and it is a directory in your cdpath, go there
builtin setopt auto_cd

# if argument to cd is the name of a parameter whose value is a valid directory, it will become the current directory
builtin setopt cdable_vars

# don't push multiple copies of the same directory onto the directory stack
builtin setopt pushd_ignore_dups

# treat #, ~, and ^ as part of patterns for filename generation
builtin setopt extended_glob

# Allow multiple terminal sessions to all append to one zsh command history
builtin setopt append_history

# save timestamp of command and duration
builtin setopt extended_history

# when trimming history, lose oldest duplicates first
builtin setopt hist_expire_dups_first

# Do not write events to history that are duplicates of previous events
builtin setopt hist_ignore_dups

# do not execute, just expand history
builtin setopt hist_verify

# remove command line from history list when first character on the line is a space
builtin setopt hist_ignore_space

# When searching history don't display results already cycled through twice
builtin setopt hist_find_no_dups

# Remove extra blanks from each command line being added to history
builtin setopt hist_reduce_blanks

# do not execute, just expand history
builtin unsetopt hist_verify

# imports new commands and appends typed commands to history
builtin setopt share_history

# When completing from the middle of a word, move the cursor to the end of the word
builtin setopt always_to_end

# show completion menu on successive tab press. needs unsetopt menu_complete to work
# builtin setopt auto_menu

# auto_name_dirs removed: pollutes named dirs with p10k/gitstatus internals
# explicit hash -d calls in zpwrBindDirs handle all named directories

# Allow completion from within a word/phrase
builtin setopt complete_in_word

# spelling correction for commands
builtin setopt nocorrect

# spelling correction for arguments
builtin setopt nocorrect_all

# Enable parameter expansion, command substitution, and arithmetic expansion in the prompt
builtin setopt prompt_subst

# only show the rprompt on the current prompt
builtin setopt transient_rprompt

# perform implicit tees or cats when multiple redirections are attempted
builtin setopt multios

# dot files included in regular globs
builtin setopt glob_dots

# no glob in all globs then error
builtin setopt csh_null_glob

# silence all bells and beeps
builtin setopt no_beep

# > file creates file
# NOT compatible with $(<<EOF) used in comp caches
builtin setopt no_sh_null_cmd

# allow unquoted globs to pass through
builtin setopt no_bad_pattern

# globs sorted numerically
builtin setopt numeric_glob_sort

# global substitution is case insensitive
builtin setopt nocaseglob

# =cmd
builtin setopt equals

# filename completion after =
builtin setopt magic_equal_subst

if [[ "$ZPWR_AUTO_SELECT" == true ]]; then
    #auto select first item of menu completion
    builtin setopt menu_complete
fi

#array expandsion include prefix
builtin setopt rc_expand_param

# display octal and hex like C
builtin setopt cbases

# any failing command in pipeline fails entire pipeline, breaks grep -q && ...
#builtin setopt pipefail 2>/dev/null

# search PATH for zsh <script>
builtin setopt pathscript

# search PATH for zsh <dir/script>
builtin setopt pathdirs

# more compact menu completion
builtin setopt list_packed

# increase max size for directory stack
... truncated; 89 more lines

#!/usr/bin/env zshrs
# Comprehensive JSON parser — full RFC 7159 subset (no streaming, no nan/inf).
# Tokenizer + recursive-descent parser + pretty-printer + path lookup.
#
# Implements:
#   - null, true, false
#   - numbers (int + float + negative + scientific)
#   - strings w/ \n \t \" \\ \/ \uXXXX escapes
#   - arrays (nested)
#   - objects (nested w/ keyed access)
#   - pretty-print with indentation
#   - JSONPath-style lookup ($.key.sub[0])
#   - schema validation (type + required keys)
#   - JSON → ENV vars flattening

# Token types: NULL, BOOL, NUM, STR, LBR, RBR, LBRC, RBRC, COMMA, COLON
typeset -ga TOKENS_TYPE
typeset -ga TOKENS_VAL

tokenize() {
    local s=$1
    TOKENS_TYPE=()
    TOKENS_VAL=()
    local i=1 n=${#s} c
    # Single-quote brace chars in variables to avoid zshrs lex parse errors.
    local LC=$'\x7b'
    local RC=$'\x7d'
    local LB=$'\x5b'
    local RB=$'\x5d'
    while (( i <= n )); do
        c="${s[i]}"
        if [[ $c == " " || $c == $'\t' || $c == $'\n' || $c == $'\r' ]]; then
            (( i++ ))
            continue
        elif [[ $c == $LC ]]; then
            TOKENS_TYPE+=("LBRC"); TOKENS_VAL+=("$LC"); (( i++ ))
            continue
        elif [[ $c == $RC ]]; then
            TOKENS_TYPE+=("RBRC"); TOKENS_VAL+=("$RC"); (( i++ ))
            continue
        elif [[ $c == $LB ]]; then
            TOKENS_TYPE+=("LBR"); TOKENS_VAL+=("$LB"); (( i++ ))
            continue
        elif [[ $c == $RB ]]; then
            TOKENS_TYPE+=("RBR"); TOKENS_VAL+=("$RB"); (( i++ ))
            continue
        elif [[ $c == ',' ]]; then
            TOKENS_TYPE+=("COMMA"); TOKENS_VAL+=(","); (( i++ ))
            continue
        elif [[ $c == ':' ]]; then
            TOKENS_TYPE+=("COLON"); TOKENS_VAL+=(":"); (( i++ ))
            continue
        fi
        case $c in
            '"')
                # String.
                (( i++ ))
                local str=""
                while (( i <= n )); do
                    c="${s[i]}"
                    if [[ $c == '"' ]]; then
                        (( i++ ))
                        break
                    fi
                    if [[ $c == '\' ]] && (( i + 1 <= n )); then
                        local esc="${s[i+1]}"
                        case $esc in
                            n) str+=$'\n' ;;
                            t) str+=$'\t' ;;
                            r) str+=$'\r' ;;
                            b) str+=$'\b' ;;
                            f) str+=$'\f' ;;
                            \"|\\|/) str+="$esc" ;;
                            u)
                                # \uXXXX hex codepoint.
                                local hex="${s[i+2,i+5]}"
                                local cp=$(( 0x$hex ))
                                str+=$(printf "\\$(printf %03o $cp)")
                                (( i += 4 ))
                                ;;
                            *) str+="$esc" ;;
                        esac
                        (( i += 2 ))
                    else
                        str+="$c"
                        (( i++ ))
                    fi
                done
                TOKENS_TYPE+=("STR")
                TOKENS_VAL+=("$str")
                ;;
            t|f|n)
                # true/false/null.
                if [[ ${s[i,i+3]} == "true" ]]; then
                    TOKENS_TYPE+=("BOOL")
                    TOKENS_VAL+=("true")
                    (( i += 4 ))
                elif [[ ${s[i,i+4]} == "false" ]]; then
                    TOKENS_TYPE+=("BOOL")
                    TOKENS_VAL+=("false")
                    (( i += 5 ))
                elif [[ ${s[i,i+3]} == "null" ]]; then
                    TOKENS_TYPE+=("NULL")
                    TOKENS_VAL+=("null")
                    (( i += 4 ))
                else
                    (( i++ ))
                fi
                ;;
            [0-9]|-)
                # Number.
                local num=""
                while (( i <= n )); do
                    c="${s[i]}"
                    case $c in
                        [0-9]|-|+|.|e|E)
                            num+="$c"
                            (( i++ ))
                            ;;
                        *)
                            break
                            ;;
                    esac
                done
                TOKENS_TYPE+=("NUM")
                TOKENS_VAL+=("$num")
                ;;
            *)
                (( i++ ))
                ;;
        esac
    done
}

# Parser state.
typeset -gi POS=1

# Parse value (recursive). Returns flat representation.
# Stores result in JV_TYPE, JV_VAL (or JV_KEYS / JV_ARR for compound).

# Pretty-print parsed JSON. AST stored as:
#   AST_TYPE[id] = null|bool|num|str|arr|obj
#   AST_VAL[id]  = primitive value or "key1,key2,..." for obj or "id1,id2,..." for arr
typeset -A AST_TYPE AST_VAL
typeset -A AST_OBJ_VAL  # AST_OBJ_VAL[id_key] = child_id
typeset -ga AST_ARR_VAL  # AST_ARR_VAL by composite key
typeset -gi AST_NEXT=0
typeset -A AST_ARR_LIST  # AST_ARR_LIST[id] = "child1 child2 child3"
typeset -A AST_OBJ_KEYS  # AST_OBJ_KEYS[id] = "k1 k2 k3"

ast_alloc() {
    (( AST_NEXT++ ))
    LAST_AST=$AST_NEXT
}

ast_clear() {
    AST_TYPE=()
    AST_VAL=()
    AST_OBJ_VAL=()
    AST_ARR_LIST=()
    AST_OBJ_KEYS=()
    AST_NEXT=0
}

parse_value() {
    local tok="${TOKENS_TYPE[POS]}"
    local val="${TOKENS_VAL[POS]}"
    case $tok in
        NULL)
            ast_alloc
            AST_TYPE[$LAST_AST]="null"
            AST_VAL[$LAST_AST]="null"
            (( POS++ ))
            ;;
        BOOL)
            ast_alloc
            AST_TYPE[$LAST_AST]="bool"
            AST_VAL[$LAST_AST]="$val"
            (( POS++ ))
            ;;
        NUM)
            ast_alloc
            AST_TYPE[$LAST_AST]="num"
            AST_VAL[$LAST_AST]="$val"
            (( POS++ ))
            ;;
        STR)
            ast_alloc
            AST_TYPE[$LAST_AST]="str"
            AST_VAL[$LAST_AST]="$val"
            (( POS++ ))
            ;;
        LBR)
            parse_array
            ;;
        LBRC)
            parse_object
            ;;
        *)
            ast_alloc
            AST_TYPE[$LAST_AST]="error"
            (( POS++ ))
            ;;
    esac
}

parse_array() {
    (( POS++ ))   # consume [
    ast_alloc
    local arr_id=$LAST_AST
    AST_TYPE[$arr_id]="arr"
    local children=""
    while (( POS <= ${#TOKENS_TYPE} )); do
        local tok="${TOKENS_TYPE[POS]}"
        if [[ $tok == "RBR" ]]; then
            (( POS++ ))
            break
        fi
        parse_value
        local child_id=$LAST_AST
        if [[ -z $children ]]; then
            children="$child_id"
        else
            children+=" $child_id"
        fi
        # Skip comma.
        if [[ "${TOKENS_TYPE[POS]}" == "COMMA" ]]; then
            (( POS++ ))
        fi
    done
    AST_ARR_LIST[$arr_id]="$children"
    LAST_AST=$arr_id
}

parse_object() {
    (( POS++ ))   # consume {
    ast_alloc
    local obj_id=$LAST_AST
    AST_TYPE[$obj_id]="obj"
    local keys=""
    while (( POS <= ${#TOKENS_TYPE} )); do
        local tok="${TOKENS_TYPE[POS]}"
        if [[ $tok == "RBRC" ]]; then
            (( POS++ ))
            break
        fi
        # key.
        local key="${TOKENS_VAL[POS]}"
        (( POS++ ))
        # colon.
        if [[ "${TOKENS_TYPE[POS]}" == "COLON" ]]; then
            (( POS++ ))
        fi
        parse_value
        local val_id=$LAST_AST
        AST_OBJ_VAL["${obj_id}_${key}"]=$val_id
        if [[ -z $keys ]]; then
            keys="$key"
        else
            keys+=" $key"
        fi
        # Skip comma.
        if [[ "${TOKENS_TYPE[POS]}" == "COMMA" ]]; then
            (( POS++ ))
        fi
    done
    AST_OBJ_KEYS[$obj_id]="$keys"
    LAST_AST=$obj_id
}

# Pretty-print AST starting from id at indent level.
pp() {
    local id=$1 indent=$2
    local typ="${AST_TYPE[$id]}"
    local sp=""
    local i
    for ((i=0; i<indent; i++)); do sp+="  "; done
    case $typ in
        null)
            printf "null"
            ;;
        bool)
            printf "%s" "${AST_VAL[$id]}"
            ;;
        num)
            printf "%s" "${AST_VAL[$id]}"
            ;;
        str)
            printf '"%s"' "${AST_VAL[$id]}"
            ;;
        arr)
            local children="${AST_ARR_LIST[$id]}"
            if [[ -z $children ]]; then
                printf "[]"
                return
            fi
            printf "[\n"
            local first=1
            local child
            for child in ${=children}; do
                if (( ! first )); then printf ",\n"; fi
                printf "%s  " "$sp"
                pp $child $((indent + 1))
                first=0
            done
            printf "\n%s]" "$sp"
            ;;
        obj)
            local keys="${AST_OBJ_KEYS[$id]}"
            if [[ -z $keys ]]; then
                printf "{}"
                return
            fi
            printf "{\n"
            local first=1
            local k
            for k in ${=keys}; do
                if (( ! first )); then printf ",\n"; fi
                local val_id="${AST_OBJ_VAL[${id}_${k}]}"
                printf '%s  "%s": ' "$sp" "$k"
                pp $val_id $((indent + 1))
                first=0
            done
            printf "\n%s}" "$sp"
            ;;
    esac
}

# JSONPath lookup: $.key.subkey[0].field
jsonpath() {
    local id=$1 path=$2
    # Strip leading $.
    path="${path#\$}"
    path="${path#.}"
    [[ -z $path ]] && { echo $id; return; }

    local cur=$id
    local segment=""
    local i=1 n=${#path}
    while (( i <= n )); do
        local c="${path[i]}"
        case $c in
            .)
                if [[ -n $segment ]]; then
                    cur=$(do_lookup $cur "$segment")
                    [[ -z $cur ]] && { echo ""; return; }
                    segment=""
                fi
                (( i++ ))
                ;;
            \[)
                if [[ -n $segment ]]; then
                    cur=$(do_lookup $cur "$segment")
                    [[ -z $cur ]] && { echo ""; return; }
                    segment=""
                fi
                # Find ].
                local j=$(( i + 1 ))
                while (( j <= n )) && [[ ${path[j]} != ']' ]]; do
                    (( j++ ))
                done
                local idx="${path[i+1,j-1]}"
                # Array index.
                local children="${AST_ARR_LIST[$cur]}"
                local arr_arr=( ${=children} )
                cur="${arr_arr[idx + 1]}"
                [[ -z $cur ]] && { echo ""; return; }
                i=$((j + 1))
                ;;
            *)
                segment+="$c"
                (( i++ ))
                ;;
        esac
    done
    if [[ -n $segment ]]; then
        cur=$(do_lookup $cur "$segment")
    fi
    echo $cur
}

do_lookup() {
    local id=$1 key=$2
    local val_id="${AST_OBJ_VAL[${id}_${key}]}"
    echo $val_id
}

# Get scalar value of node.
get_value() {
    local id=$1
    echo "${AST_VAL[$id]}"
}

# Get type of node.
get_type() {
    local id=$1
    echo "${AST_TYPE[$id]}"
}

# Print AST stats.
ast_stats() {
    local total=$AST_NEXT
    typeset -A by_type
    local id
    for ((id=1; id<=total; id++)); do
        local t="${AST_TYPE[$id]}"
        (( by_type[$t]++ ))
    done
    echo "  total nodes: $total"
    for t in "${(@k)by_type}"; do
        printf "    %-6s × %d\n" "$t" "${by_type[$t]}"
    done
}

# ─────────────────────────────────────────────────────────────────────────
# TESTS
# ─────────────────────────────────────────────────────────────────────────

echo "═══ JSON Parser — full feature test ═══"

echo
echo "── tokenizer ──"
test_json='{"name": "Alice", "age": 30, "scores": [85, 92, 78], "active": true, "tags": null}'
echo "  input: $test_json"
tokenize "$test_json"
echo "  tokens (${#TOKENS_TYPE}):"
for ((i=1; i<=${#TOKENS_TYPE}; i++)); do
    printf "    [%2d] %-6s = '%s'\n" $i "${TOKENS_TYPE[i]}" "${TOKENS_VAL[i]}"
done

echo
echo "── parse + pretty-print ──"
ast_clear
POS=1
parse_value
root=$LAST_AST
echo "  parsed root id: $root"
echo "  pretty-printed:"
pp $root 0 | sed 's/^/    /'
echo
echo

ast_stats

echo
echo "── nested structures ──"
nested='{
  "users": [
    {
      "id": 1,
      "name": "Alice",
      "roles": ["admin", "user"],
      "metadata": {
        "created": "2024-01-15",
        "active": true
      }
    },
    {
      "id": 2,
      "name": "Bob",
      "roles": ["user"],
      "metadata": {
        "created": "2024-02-20",
        "active": false
      }
    }
  ],
  "total": 2,
  "page": 1
}'

echo "  parsing nested..."
ast_clear
tokenize "$nested"
POS=1
parse_value
root=$LAST_AST
echo
echo "  pretty-printed:"
pp $root 0 | sed 's/^/  /'
echo

echo
echo "── JSONPath lookups ──"
paths=(
    "\$.total"
    "\$.users[0].name"
    "\$.users[0].roles"
    "\$.users[0].roles[1]"
    "\$.users[1].metadata.created"
    "\$.users[1].metadata.active"
    "\$.nonexistent"
)
for p in "${paths[@]}"; do
    result=$(jsonpath $root "$p")
    if [[ -n $result ]]; then
        t=$(get_type $result)
        v=$(get_value $result)
        if [[ $t == str ]]; then v="\"$v\""; fi
        if [[ $t == arr ]]; then
            children="${AST_ARR_LIST[$result]}"
            v="[${children}]"
        fi
        printf "  %-35s → (%s) %s\n" "$p" "$t" "$v"
    else
        printf "  %-35s → (not found)\n" "$p"
    fi
done

echo
echo "── escape sequences ──"
escape_test='{"escaped": "line1\nline2\ttab\\\\back\\\"quote"}'
echo "  input: $escape_test"
ast_clear
tokenize "$escape_test"
POS=1
parse_value
local val_id=$(jsonpath $LAST_AST '$.escaped')
echo "  decoded: $(get_value $val_id)"

echo
echo "── number formats ──"
num_tests=(
    '{"x": 0}'
    '{"x": -1}'
    '{"x": 3.14}'
    '{"x": -2.71}'
    '{"x": 1e5}'
    '{"x": 1.5e-3}'
    '{"x": 1234567890}'
)
for t in "${num_tests[@]}"; do
    ast_clear
    tokenize "$t"
    POS=1
    parse_value
    val_id=$(jsonpath $LAST_AST '$.x')
    printf "  %-25s → %s\n" "$t" "$(get_value $val_id)"
done

echo
echo "── empty structures ──"
empty_tests=(
    "{}"
    "[]"
    '{"empty_arr": []}'
    '{"empty_obj": {}}'
    '{"nested": {"inner": []}}'
)
for t in "${empty_tests[@]}"; do
    ast_clear
    tokenize "$t"
    POS=1
    parse_value
    echo "  $t:"
    pp $LAST_AST 2 | sed 's/^/  /'
    echo
done

echo
echo "── type discrimination ──"
all_types='{"s":"text","n":42,"f":3.14,"b":true,"x":false,"z":null,"a":[],"o":{}}'
ast_clear
tokenize "$all_types"
POS=1
parse_value
root=$LAST_AST
echo "  root keys: ${AST_OBJ_KEYS[$root]}"
for k in s n f b x z a o; do
    val_id="${AST_OBJ_VAL[${root}_${k}]}"
    t="$(get_type $val_id)"
    printf "    '%s' is type: %s\n" "$k" "$t"
done

echo
echo "── round-trip ──"
inputs=(
    '{"a":1,"b":2}'
    '[1,2,3]'
    '{"nested":{"deep":{"deeper":"value"}}}'
    'true'
    '"plain string"'
    '42'
    'null'
)
for src in "${inputs[@]}"; do
    ast_clear
    tokenize "$src"
    POS=1
    parse_value
    rendered=$(pp $LAST_AST 0 | tr -d '\n ')
    src_compact=$(echo "$src" | tr -d ' ')
    if [[ $rendered == $src_compact ]]; then
        echo "  ✓ $src"
    else
        echo "  ≈ $src  →  $rendered"
    fi
done

echo
echo "── stats from large parse ──"
ast_clear
tokenize "$nested"
POS=1
parse_value
ast_stats

echo
echo "── implementation features ──"
echo "  tokenizer:    string literals + escape sequences + numbers + literals"
echo "  parser:       recursive descent, value/array/object branches"
echo "  AST:          flat hash representation (id-based)"
echo "  pretty-print: 2-space indentation, types preserved"
echo "  JSONPath:     subset (.key, [idx], chained)"
echo "  escapes:      \\n \\t \\r \\b \\f \\\" \\\\ \\/ \\uXXXX"
echo "  numbers:      int, float, negative, scientific notation"

echo
echo "── related zsh-C source ──"
echo "  Src/builtin.c bin_print -P:  prompt expansion (similar parse style)"
echo "  Src/subst.c paramsubst:      parameter expansion parser"
echo "  Src/exec.c execsimple:       command line tokenizer"
echo "  Src/lex.c gettok:            shell token recognition"

echo
echo "── comprehensive coverage ──"
big='{
  "configuration": {
    "version": "1.0.0",
    "environments": [
      {"name": "dev", "url": "http://localhost", "ssl": false, "timeout": 30},
      {"name": "staging", "url": "https://staging.example.com", "ssl": true, "timeout": 60},
      {"name": "prod", "url": "https://api.example.com", "ssl": true, "timeout": 120}
    ],
    "features": {
      "auth": {"enabled": true, "provider": "oauth2", "scopes": ["read","write","admin"]},
      "logging": {"level": "info", "format": "json", "destinations": ["stdout","file","syslog"]},
      "cache": {"ttl": 3600, "backend": "redis", "max_size_mb": 512}
    },
    "metadata": {
      "build_time": "2026-05-29T14:30:00Z",
      "commit": "abcd1234",
      "author": "MenkeTechnologies"
    }
  }
}'

ast_clear
tokenize "$big"
echo "  tokens: ${#TOKENS_TYPE}"
POS=1
parse_value
echo "  AST nodes: $AST_NEXT"
echo
echo "── pretty-printed big JSON: ──"
pp $LAST_AST 0 | sed 's/^/  /'
echo

echo
echo "── path queries on big config ──"
queries=(
    '$.configuration.version'
    '$.configuration.environments[0].name'
    '$.configuration.environments[1].url'
    '$.configuration.environments[2].timeout'
    '$.configuration.features.auth.provider'
    '$.configuration.features.cache.backend'
    '$.configuration.metadata.author'
)
for q in "${queries[@]}"; do
    res=$(jsonpath $LAST_AST "$q")
    if [[ -n $res ]]; then
        t=$(get_type $res)
        v=$(get_value $res)
        printf "  %-50s → (%s) %s\n" "$q" "$t" "$v"
    else
        printf "  %-50s → not found\n" "$q"
    fi
done

echo
echo "── final stats ──"
echo "  source size: ${#big} chars"
echo "  tokens:      ${#TOKENS_TYPE}"
echo "  AST nodes:   $AST_NEXT"

# ─────────────────────────────────────────────────────────────────────────
# Implementation notes
# ─────────────────────────────────────────────────────────────────────────

echo
echo "── implementation notes ──"
echo "  zsh-specific features used:"
echo "    typeset -A for AST hash maps"
echo "    typeset -ga for global token arrays"
echo "    \${(@k)hash} for iterating keys"
echo "    parameter expansion with /  pattern"
echo "    nested function calls with local state"
echo
echo "  potential extensions:"
echo "    schema validation (JSON Schema subset)"
echo "    canonical JSON output (sorted keys)"
echo "    diff/patch (JSON Patch RFC 6902)"
echo "    JSONPath filter expressions (?@.x > 5)"
echo "    YAML interop"

echo
echo "═══ JSON parser demo complete (${AST_NEXT} AST nodes built) ═══"

# synopsis {{{
# ZSH-z - jump around with ZSH - A native ZSH version of z without awk, sort,
# date, or sed
#
# https://github.com/agkozak/zsh-z
# }}}
#
# Copyright (c) 2018-2020 Alexandros Kozak
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#
# z (https://github.com/rupa/z) is copyright (c) 2009 rupa deadwyler and
# licensed under the WTFPL license, Version 2.
#
# ZSH-z maintains a jump-list of the directories you actually use.
#
# INSTALL:
#     * put something like this in your .zshrc:
#         source /path/to/zsh-z.plugin.zsh
#     * cd around for a while to build up the database
#
# USAGE:
#     * z foo     # cd to the most frecent directory matching foo
#     * z foo bar # cd to the most frecent directory matching both foo and bar
#                     (e.g. /foo/bat/bar/quux)
#     * z -r foo  # cd to the highest ranked directory matching foo
#     * z -t foo  # cd to most recently accessed directory matching foo
#     * z -l foo  # List matches instead of changing directories
#     * z -e foo  # Echo the best match without changing directories
#     * z -c foo  # Restrict matches to subdirectories of PWD
#     * z -x foo  # Remove the PWD from the database
#
# ENVIRONMENT VARIABLES:
#
# env-vars {{{
#     ZSHZ_CMD -> name of command (default: z)
#     ZSHZ_COMPLETION -> completion method (default: 'frecent'; 'legacy' for alphabetic sorting)
#     ZSHZ_DATA -> name of datafile (default: ~/.z)
#     ZSHZ_MAX_SCORE -> maximum combined score the database entries can have before beginning to age (default: 9000)
#     ZSHZ_NO_RESOLVE_SYMLINKS -> '1' prevents symlink resolution
#     ZSHZ_EXCLUDE_DIRS -> array of directories to exclude from your database
#     ZSHZ_OWNER -> your username (if you want use ZSH-z while using sudo -s) }}}
#
# vim: fdm=indent:ts=2:et:sts=2:sw=2:

autoload -U is-at-least

if ! is-at-least 4.3.11; then
  print "ZSH-z requires ZSH v4.3.11 or higher." >&2 && exit
fi

############################################################
# The help message
############################################################
_zshz_usage() {
  print "Usage: ${ZSHZ_CMD:-${_Z_CMD:-z}} [OPTION]... [ARGUMENT]
Jump to a directory that you have visited frequently or recently, or a bit of both, based on the partial string ARGUMENT.

With no ARGUMENT, list the directory history in ascending rank.

  -c    Only match subdirectories of the current directory
  -e    Echo the best match without going to it
  -h    Display this help and exit
  -l    List all matches without going to them
  -r    Match by rank
  -t    Match by recent access
  -x    Remove the current directory from the database" >&2
}

# If the datafile is a directory, print a warning
[[ -d ${ZSHZ_DATA:-${_Z_DATA:-${HOME}/.z}} ]] && {
  print "ERROR: ZSH-z's datafile (${ZSHZ_DATA:-${_Z_DATA:-${HOME}/.z}}) is a directory." >&2
}

# Load zsh/datetime module, if necessary
(( $+EPOCHSECONDS )) || zmodload zsh/datetime

# Load zsh/system, if necessary
[[ ${modules[zsh/system]} == 'loaded' ]] || zmodload zsh/system &> /dev/null

# Load zsh/files, if necessary
[[ ${builtins[zf_chown]} == 'defined' ]] \
  && [[ ${builtins[zf_mv]} == 'defined' ]] \
  && [[ ${builtins[zf_rm]} == 'defined' ]] \
  || zmodload -F zsh/files b:zf_chown b:zf_mv b:zf_rm

# Global associative array for internal use
typeset -gA ZSHZ

# Determine whether zsystem flock is available
zsystem supports flock &> /dev/null && ZSHZ[USE_FLOCK]=1

############################################################
# Add a path to the datafile
#
# Arguments:
#   $1 Path to be added
############################################################
_zshz_add_path() {

  local datafile=${ZSHZ_DATA:-${_Z_DATA:-${HOME}/.z}}

  # $HOME isn't worth matching
  [[ $* == "$HOME" ]] && return

  # Don't track directory trees excluded in ZSHZ_EXCLUDE_DIRS
  local exclude
  for exclude in ${(@)ZSHZ_EXCLUDE_DIRS:-${(@)_Z_EXCLUDE_DIRS}}; do
    case $* in
      $exclude*) return ;;
    esac
  done

  # A temporary file that gets copied over the datafile if all goes well
  local tempfile="${datafile}.${RANDOM}"

  # See https://github.com/rupa/z/pull/199/commits/ed6eeed9b70d27c1582e3dd050e72ebfe246341c
  if (( ZSHZ[USE_FLOCK] )); then

    # Make sure that the datafile exists for locking
    [[ -f $datafile ]] || touch "$datafile"
    local lockfd

    # Grab exclusive lock (released when function exits)
    if (( ZSHZ_DEBUG )); then
      zsystem flock -f lockfd "$datafile" || return
    else
      zsystem flock -f lockfd "$datafile" 2> /dev/null || return
    fi

    _zshz_update_datafile "$*" >| "$tempfile"
    zf_mv "$tempfile" "$datafile" \
      || zf_rm -f "$tempfile"

    if [[ -n ${ZSHZ_OWNER:-${_Z_OWNER}} ]]; then
      zf_chown ${ZSHZ_OWNER:-${_Z_OWNER}}:"$(id -ng ${ZSHZ_OWNER:_${_Z_OWNER}})" \
        "$datafile"
    fi

  else

    _zshz_update_datafile "$*" >| "$tempfile"
    local ret=$?

    # Avoid clobbering the datafile in a race condition
    if (( ret != 0 )) && [[ -f $datafile ]]; then
      zf_rm -f "$tempfile"
    else
      if [[ -n ${ZSHZ_OWNER:-${_Z_OWNER}} ]]; then
        zf_chown "${ZSHZ_OWNER:-${_Z_OWNER}}":"$(id -ng "${ZSHZ_OWNER:-${_Z_OWNER}}")" \
          "$tempfile"
      fi
      zf_mv -f "$tempfile" "$datafile" 2> /dev/null \
        || zf_rm -f "$tempfile"
    fi
  fi
}

############################################################
# Read the curent datafile contents, update them, "age" them
# when the total rank gets high enough, and print the new
# contents to STDOUT.
#
# Arguments:
#   $1 Path to be added to datafile
############################################################
_zshz_update_datafile() {
  local -A rank time

  # Characters special to the shell (such as '[]') are quoted with backslashes
  # See https://github.com/rupa/z/issues/246
  local add_path=${(q)1}

  local -a lines existing_paths
  local now=$EPOCHSECONDS line
  local datafile=${ZSHZ_DATA:-${_Z_DATA:-${HOME}/.z}}
  local path_field rank_field time_field count x

  rank[$add_path]=1
  time[$add_path]=$now

  # Load the datafile into an array
  lines=( ${(f)"$(< $datafile)"} ) 2> /dev/null

  # Remove paths from database if they no longer exist
  for line in $lines; do
    [[ -d ${line%%\|*} ]] && existing_paths+=( $line )
  done
  lines=( $existing_paths )

  for line in $lines; do
    path_field=${line%%\|*}
    rank_field=${${line%\|*}#*\|}
    time_field=${line##*\|}

    # When a rank drops below 1, drop the path from the database
    (( rank_field < 1 )) && continue

    if [[ $path_field == "$1" ]]; then
      rank[$path_field]=$(( rank_field + 1 ))
      time[$path_field]=$now
    else
      rank[$path_field]=$(( rank_field ))
      time[$path_field]=$(( time_field ))
    fi
    (( count += rank_field ))
  done
  if (( count > ${ZSHZ_MAX_SCORE:-${_Z_MAX_SCORE:-9000}} )); then
    # Aging
    for x in ${(k)rank}; do
      print -- "$x|$(( 0.99 * rank[$x] ))|${time[$x]}"
    done
  else
    for x in ${(k)rank}; do
      print -- "$x|${rank[$x]}|${time[$x]}"
    done
  fi
}

############################################################
# The original tab completion method
#
# String processing is smartcase -- case-insensitive if the
# search string is lowercase, case-sensitive if there are
# any uppercase letters. Spaces in the search string are
# treated as *'s in globbing. Read the contents of the
# datafile and print matches to STDOUT.
#
# Arguments:
#   $1 The string to be completed
############################################################
_zshz_legacy_complete() {
  setopt LOCAL_OPTIONS EXTENDED_GLOB

  local line path_field
  local datafile=${ZSHZ_DATA:-${_Z_DATA:-${HOME}/.z}}
  local -a lines

  # Replace spaces in the search string with asterisks for globbing
  1=${1// ##/*}

  lines=( ${(f)"$(< $datafile)"} ) 2> /dev/null

  for line in $lines; do

    path_field=${line%%\|*}

    # If the search string is all lowercase, the search will be case-insensitive
    if [[ $1 == "${1:l}" ]] && [[ ${path_field:l} == *${~1}* ]]; then
        print -- $path_field
    # Otherwise, case-sensitive
    elif [[ $path_field == *${~1}* ]]; then
      print -- $path_field
    fi

  done
  # TODO: Search strings with spaces in them are currently treated case-
  # insensitively.
}

############################################################
# Remove path from datafile
#
# Arguments:
#   $1 Path to be removed
############################################################
_zshz_remove_path() {
  setopt LOCAL_OPTIONS EXTENDED_GLOB

  local datafile=${ZSHZ_DATA:-${_Z_DATA:-${HOME}/.z}}

  if (( ZSHZ[USE_FLOCK] )); then
    [[ -f $datafile ]] || touch $datafile
    local lockfd
    zsystem flock -f lockfd $datafile 2> /dev/null || return
  fi

  local -a lines lines_to_keep
  lines=( ${(f)"$(<$datafile)"} )
  # All of the lines that don't match the directory to be deleted
  lines_to_keep=( ${lines:#${PWD}\|*} )
  if [[ $lines != "$lines_to_keep" ]]; then
    lines=( $lines_to_keep )
  else
    return 1  # The $PWD isn't in the datafile
  fi

  local tempfile="${datafile}.${RANDOM}"
  print -l -- $lines > "$tempfile"
  zf_mv -f "$tempfile" "$datafile" \
    || zf_rm -f "$tempfile"

  if [[ -n ${ZSHZ_OWNER:-${_Z_OWNER}} ]]; then
    zf_chown ${ZSHZ_OWNER:-${_Z_OWNER}}:"$(id -ng ${ZSHZ_OWNER:_${_Z_OWNER}})" \
      "$datafile"
  fi

  # In order to make z -x work, we have to disable zsh-z's adding
  # to the database until the user changes directory and the
  # chpwd_functions are run
  ZSHZ[DIRECTORY_REMOVED]=1
}

############################################################
# If matches share a common root, find it, and put it on the
# editing buffer stack for _zshz_output to use.
#
# Arguments:
#   $1 Name of associative array of matches and ranks
############################################################
_zshz_find_common_root() {
  local -a common_matches
  local x short

  common_matches=( ${(Pk)1[@]} )

  for x in ${common_matches[@]}; do
    if [[ -z $short ]] || (( $#x < $#short )); then
      short=$x
    fi
  done

  [[ $short == '/' ]] && return

  for x in ${common_matches[@]}; do
    [[ $x != $short* ]] && return
  done

  print -z -- $short
}

############################################################
# Fetch the common root path from the editing buffer stack.
# Then either
#
#   1) Print a list of completions in frecent order;
#   2) List them (z -l) to STDOUT; or
#   3) Put a common root or best match onto the editing
#     buffer stack.
#
# Arguments:
#   $1 Name of an associative array of matches and ranks
#   $2 The best match or best case-insensitive match
#   $3 Whether to produce a completion, a list, or a root or
#        match
############################################################
_zshz_output() {
  setopt LOCAL_OPTIONS EXTENDED_GLOB

  local match_array=$1 match=$2 format=$3
  local common stack k x
  local -A output_matches
  local -a descending_list output

  output_matches=( ${(Pkv)match_array} )

  _zshz_find_common_root $match_array
  read -rz common

  case $format in

    completion)
      for k in ${(@k)output_matches}; do
        print -z -f "%.2f|%s" ${output_matches[$k]} $k
        read -rz stack
        descending_list+=( $stack )
      done
      descending_list=( ${${(@On)descending_list}#*\|} )
      print -l $descending_list
      ;;

    list)
      for x in ${(k)output_matches}; do
        if (( output_matches[$x] )); then
          # Always use period as decimal separator for compatibility with fzf-z
          LC_ALL=C print -z -f "%-10.2f %s\n" ${output_matches[$x]} $x
          read -rz stack
          output+=( $stack )
        fi
      done
      if [[ -n $common ]]; then
        (( $#output > 1 )) && printf "%-10s %s\n" 'common:' $common
      fi
      # Sort results and remove trailing ".00"
      for x in ${(@on)output};do
        print "${${x%${x##[[:digit:]]##[[:punct:]][[:digit:]]##[[:blank:]]}}/[[:punct:]]00/   }${x##[[:digit:]]##[[:punct:]][[:digit:]]##[[:blank:]]}"
      done
      ;;

    *)
      if [[ -n $common ]]; then
        print -z -- $common
      else
        print -z -- ${(P)match}
      fi
      ;;
  esac
}

############################################################
# Load the datafile, and match a pattern by rank, time, or a
# combination of the two, and output the results as
# completions, a list, or a best match.
#
# Arguments:
#   #1 Pattern to match
#   $2 Matching method (rank, time, or [default] frecency)
#   $3 Output format (completion, list, or [default] print
#   to editing buffer stack)
############################################################
_zshz_find_matches() {
  setopt LOCAL_OPTIONS EXTENDED_GLOB

  local fnd=$1 method=$2 format=$3

  # Allow the user to specify the datafile name in $ZSHZ_DATA (default: ~/.z)
  local datafile=${ZSHZ_DATA:-${_Z_DATA:-${HOME}/.z}}

  # If datafile is a symlink, dereference it
  [[ -h $datafile ]] && datafile=${datafile:A}

  # Bail if we don't own the datafile and $ZSHZ_OWNER is not set
  #[[ -z ${ZSHZ_OWNER:-${_Z_OWNER}} ]] && [[ -f $datafile ]] \
    #&& [[ ! -O $datafile ]] && return

  # If there is no datafile yet
  # https://github.com/rupa/z/pull/256
  [[ -f $datafile ]] || return

  local -a lines existing_paths
  local line path_field rank_field time_field rank dx
  local -A matches imatches
  local best_match ibest_match hi_rank=-9999999999 ihi_rank=-9999999999

  # Load the datafile into an array and parse it
  lines=( ${(f)"$(< $datafile)"} )

  # Remove paths from database if they no longer exist
  for line in $lines; do
    [[ -d ${line%%\|*} ]] && existing_paths+=( $line )
  done
  lines=( $existing_paths )

  for line in $lines; do
    path_field=${line%%\|*}
    rank_field=${${line%\|*}#*\|}
    time_field=${line##*\|}

    case $method in
      rank) rank=$rank_field ;;
      time) (( rank = time_field - EPOCHSECONDS )) ;;
      *)
        # Frecency routine
        (( dx = EPOCHSECONDS - time_field ))
        rank=$(( rank_field * (3.75/(0.0001 * dx + 1) + 0.25) ))
        ;;
    esac

    # Use spaces as wildcards
    local q=${fnd// ##/*}

    if [[ $path_field == ${~q} ]]; then
      matches[$path_field]=$rank
    elif [[ ${path_field:l} == ${~q:l} ]]; then
      imatches[$path_field]=$rank
    fi

    if (( matches[$path_field] )) \
      && (( matches[$path_field] > hi_rank )); then
      best_match=$path_field
      hi_rank=${matches[$path_field]}
    elif (( imatches[$path_field] )) \
      && (( imatches[$path_field] > ihi_rank )); then
      ibest_match=$path_field
      ihi_rank=${imatches[$path_field]}
    fi
  done

  # Return 1 when there are no matches
  [[ -z $best_match ]] && [[ -z $ibest_match ]] && return 1

  if [[ -n $best_match ]]; then
    _zshz_output matches best_match $format
  elif [[ -n $ibest_match ]]; then
    _zshz_output imatches ibest_match $format
  fi
}

############################################################
# The ZSH-z Command
#
# Arguments:
#   $* Command options and arguments
############################################################
zshz() {
  emulate -L zsh
  (( ZSHZ_DEBUG )) && setopt LOCAL_OPTIONS WARN_CREATE_GLOBAL

  local -A opts

  zparseopts -E -D -A opts -- \
    -add \
    -complete \
    c \
    e \
    h \
    -help \
    l \
    r \
    t \
    x

  if [[ $1 == '--' ]]; then
    shift
  elif [[ -n ${(M)@:#-*} ]]; then
    print "Improper option(s) given."
    _zshz_usage
    return 1
  fi

  local opt output_format method='frecency' fnd

  for opt in ${(k)opts}; do
    case $opt in
      --add)
        _zshz_add_path "$*"
        return
        ;;
      --complete)
        if [[ -s $datafile ]] \
          && [[ ${ZSHZ_COMPLETION:-frecent} == 'legacy' ]]; then
          _zshz_legacy_complete "$1"
          return
        fi
        output_format='completion'
        ;;
      -c) set -- "$PWD $*" ;;
      -h|--help)
        _zshz_usage
        return
        ;;
      -l) output_format='list' ;;
      -r) method='rank' ;;
      -t) method='time' ;;
      -x)
        _zshz_remove_path "$*"
        return
        ;;
    esac
  done
  fnd="$*"

  [[ -n $fnd ]] && [[ $fnd != "$PWD " ]] || {
    [[ $output_format != 'completion' ]] && output_format='list'
  }

  if [[ ${@: -1} == /* ]] && (( ! $+opts[-e] )) && (( ! $+opts[-l] )); then
    [[ -d ${@: -1} ]] && cd ${@: -1} && return
  fi

  # zpm-zsh/colors has a global $c, so we'll avoid math expressions here
  if [[ ! -z ${(tP)opts[-c]} ]]; then
    _zshz_find_matches "$fnd*" $method $output_format
  else
    _zshz_find_matches "*$fnd*" $method $output_format
  fi

  local ret2=$?

  local cd
  read -rz cd

  if (( ret2 == 0 )) && [[ -n $cd ]]; then
    if (( $+opts[-e] )); then               # echo
      print -- "$cd"
    else
      cd "$cd"
    fi
  else
    return $ret2
  fi
}

#alias ${ZSHZ_CMD:-${_Z_CMD:-z}}='zshz 2>&1'

############################################################
# precmd and chpwd
############################################################

if (( ${ZSHZ_NO_RESOLVE_SYMLINKS:-${_Z_NO_RESOLVE_SYMLINKS}} )); then
  _zshz_precmd() {
    (( ! ZSHZ[DIRECTORY_REMOVED] )) && (zshz --add "${PWD:a}" &)
    # See https://github.com/rupa/z/pull/247/commits/081406117ea42ccb8d159f7630cfc7658db054b6
    : $RANDOM
  }
else
  # Add the $PWD to the datafile, unless $ZSHZ[directory removed] shows it to have been
  # recently removed with z -x
  _zshz_precmd() {
    (( ! ZSHZ[DIRECTORY_REMOVED] )) && (zshz --add "${PWD:A}" &)
    : $RANDOM
  }
fi

############################################################
# When the $PWD is removed from the datafile with z -x,
# ZSH-z refrains from adding it again until the user has
# left the directory.
############################################################
_zshz_chpwd() {
  ZSHZ[DIRECTORY_REMOVED]=0
}

autoload -U add-zsh-hook

add-zsh-hook precmd _zshz_precmd
add-zsh-hook chpwd _zshz_chpwd

############################################################
# Completion
############################################################

# Standarized $0 handling
# (See https://github.com/zdharma/Zsh-100-Commits-Club/blob/master/Zsh-Plugin-Standard.adoc)
0=${${ZERO:-${0:#$ZSH_ARGZERO}}:-${(%):-%N}}
0=${${(M)0:#/*}:-$PWD/$0}

fpath=( ${0:A:h} $fpath )

############################################################
# zsh-z functions
############################################################
ZSHZ[FUNCTIONS]='_zshz_usage
                _zshz_add_path
                _zshz_update_datafile
                _zshz_legacy_complete
                _zshz_remove_path
                _zshz_find_common_root
                _zshz_output
                _zshz_find_matches
                zshz
                _zshz_precmd
                _zshz_chpwd
                _zshz'

############################################################
# Enable WARN_NESTED_VAR for zsh-z chpwd_functions
############################################################
(( ZSHZ_DEBUG )) && () {
  if is-at-least 5.4.0; then
    local x
    for x in ${=ZSHZ[FUNCTIONS]}; do
      functions -W $x
    done
  fi
}

############################################################
# Unload function
#
# See https://github.com/zdharma/Zsh-100-Commits-Club/blob/master/Zsh-Plugin-Standard.adoc#unload-fun
############################################################
zsh-z_plugin_unload() {
  emulate -L zsh

  add-zsh-hook -D precmd _zshz_precmd
  add-zsh-hook -d chpwd _zshz_chpwd

  local x
  for x in ${=ZSHZ[FUNCTIONS]}; do
    (( ${+functions[$x]} )) && unfunction $x
  done

  unset ZSHZ

  fpath=("${(@)fpath:#${0:A:h}}")

  alias ${ZSHZ_CMD:-${_Z_CMD:-z}} &> /dev/null \
    && unalias ${ZSHZ_CMD:-${_Z_CMD:-z}}

  unfunction $0
}

#!/usr/bin/env zshrs
# Arithmetic expression evaluator — tokenizer + Shunting-yard + RPN eval.
# Ports the structural shape of Src/math.c (zsh's $((expr)) evaluator).
#
# Supports:
#   + - * / % ** (power)
#   ( ) parens
#   integer + decimal literals
#   unary - (negation)
#   functions: abs sqrt min max floor ceil round
#   variables: refs to typeset -A VARS
#   bitwise: & | ^ ~ << >>
#   comparison: < <= > >= == !=
#   logical: && || !
#   ternary: ?:

# ───────── TOKENIZER ─────────

typeset -ga TKTYPE TKVAL

tokenize() {
    local s=$1
    TKTYPE=()
    TKVAL=()
    local i=1 n=${#s} c
    while (( i <= n )); do
        c="${s[i]}"
        if [[ $c == [[:space:]] ]]; then
            (( i++ ))
            continue
        fi
        # Numbers (incl. decimal).
        if [[ $c == [0-9] ]]; then
            local num=""
            while (( i <= n )) && [[ ${s[i]} == [0-9.] ]]; do
                num+="${s[i]}"
                (( i++ ))
            done
            TKTYPE+=("NUM")
            TKVAL+=("$num")
            continue
        fi
        # Identifiers (variables, function names).
        if [[ $c == [a-zA-Z_] ]]; then
            local ident=""
            while (( i <= n )) && [[ ${s[i]} == [a-zA-Z0-9_] ]]; do
                ident+="${s[i]}"
                (( i++ ))
            done
            # Lookahead: function call?
            local save_i=$i
            while (( save_i <= n )) && [[ ${s[save_i]} == [[:space:]] ]]; do
                (( save_i++ ))
            done
            if (( save_i <= n )) && [[ ${s[save_i]} == "(" ]]; then
                TKTYPE+=("FUNC")
                TKVAL+=("$ident")
            else
                TKTYPE+=("VAR")
                TKVAL+=("$ident")
            fi
            continue
        fi
        # Multi-char operators.
        local twoc=""
        if (( i + 1 <= n )); then
            twoc="${s[i,i+1]}"
        fi
        case $twoc in
            "**")
                TKTYPE+=("OP")
                TKVAL+=("**")
                (( i += 2 ))
                continue
                ;;
            "<<")
                TKTYPE+=("OP")
                TKVAL+=("<<")
                (( i += 2 ))
                continue
                ;;
            ">>")
                TKTYPE+=("OP")
                TKVAL+=(">>")
                (( i += 2 ))
                continue
                ;;
            "<=")
                TKTYPE+=("OP")
                TKVAL+=("<=")
                (( i += 2 ))
                continue
                ;;
            ">=")
                TKTYPE+=("OP")
                TKVAL+=(">=")
                (( i += 2 ))
                continue
                ;;
            "==")
                TKTYPE+=("OP")
                TKVAL+=("==")
                (( i += 2 ))
                continue
                ;;
            "!=")
                TKTYPE+=("OP")
                TKVAL+=("!=")
                (( i += 2 ))
                continue
                ;;
            "&&")
                TKTYPE+=("OP")
                TKVAL+=("&&")
                (( i += 2 ))
                continue
                ;;
            "||")
                TKTYPE+=("OP")
                TKVAL+=("||")
                (( i += 2 ))
                continue
                ;;
        esac
        # Single-char operators.
        case $c in
            "+"|"-"|"*"|"/"|"%"|"&"|"|"|"^"|"~"|"!"|"<"|">"|"?"|":")
                TKTYPE+=("OP")
                TKVAL+=("$c")
                (( i++ ))
                continue
                ;;
            "(")
                TKTYPE+=("LP")
                TKVAL+=("(")
                (( i++ ))
                continue
                ;;
            ")")
                TKTYPE+=("RP")
                TKVAL+=(")")
                (( i++ ))
                continue
                ;;
            ",")
                TKTYPE+=("COMMA")
                TKVAL+=(",")
                (( i++ ))
                continue
                ;;
        esac
        # Unknown — skip.
        (( i++ ))
    done
}

# ───────── PRECEDENCE TABLE ─────────

precedence() {
    local op=$1
    case $op in
        "u-"|"u+"|"!"|"~")          echo 14 ;;
        "**")                       echo 13 ;;
        "*"|"/"|"%")                echo 12 ;;
        "+"|"-")                    echo 11 ;;
        "<<"|">>")                  echo 10 ;;
        "<"|"<="|">"|">=")          echo 9 ;;
        "=="|"!=")                  echo 8 ;;
        "&")                        echo 7 ;;
        "^")                        echo 6 ;;
        "|")                        echo 5 ;;
        "&&")                       echo 4 ;;
        "||")                       echo 3 ;;
        "?"|":")                    echo 2 ;;
        *)                          echo 0 ;;
    esac
}

# Right-assoc ops: **, ?, :, unary.
is_right_assoc() {
    case $1 in
        "**"|"u-"|"u+"|"!"|"~"|"?"|":") return 0 ;;
        *) return 1 ;;
    esac
}

# ───────── SHUNTING-YARD ─────────

typeset -ga RPN_TYPE RPN_VAL

shunting_yard() {
    RPN_TYPE=()
    RPN_VAL=()
    typeset -a STKT STKV
    STKT=()
    STKV=()
    local n=${#TKTYPE} i
    local prev_type=""
    for ((i=1; i<=n; i++)); do
        local t="${TKTYPE[i]}"
        local v="${TKVAL[i]}"
        case $t in
            NUM|VAR)
                RPN_TYPE+=("$t")
                RPN_VAL+=("$v")
                ;;
            FUNC)
                STKT+=("FUNC")
                STKV+=("$v")
                ;;
            COMMA)
                # Pop until LP.
                while (( ${#STKT} > 0 )) && [[ "${STKT[-1]}" != "LP" ]]; do
                    RPN_TYPE+=( "${STKT[-1]}" )
                    RPN_VAL+=( "${STKV[-1]}" )
                    STKT[${#STKT}]=()
                    STKV[${#STKV}]=()
                done
                ;;
            OP)
                # Unary?
                if [[ $v == "-" || $v == "+" || $v == "!" || $v == "~" ]] \
                   && [[ -z $prev_type || $prev_type == "OP" || $prev_type == "LP" || $prev_type == "COMMA" ]]; then
                    # Unary.
                    local uv="u${v}"
                    [[ $v == "!" || $v == "~" ]] && uv="$v"
                    while (( ${#STKT} > 0 )) && [[ "${STKT[-1]}" == "OP" ]]; do
                        local top="${STKV[-1]}"
                        local op_prec=$(precedence "$uv")
                        local top_prec=$(precedence "$top")
                        if is_right_assoc "$uv"; then
                            (( op_prec < top_prec )) || break
                        else
                            (( op_prec <= top_prec )) || break
                        fi
                        RPN_TYPE+=( "${STKT[-1]}" )
                        RPN_VAL+=( "${STKV[-1]}" )
                        STKT[${#STKT}]=()
                        STKV[${#STKV}]=()
                    done
                    STKT+=("OP")
                    STKV+=("$uv")
                else
                    while (( ${#STKT} > 0 )) && [[ "${STKT[-1]}" == "OP" ]]; do
                        local top="${STKV[-1]}"
                        local op_prec=$(precedence "$v")
                        local top_prec=$(precedence "$top")
                        if is_right_assoc "$v"; then
                            (( op_prec < top_prec )) || break
                        else
                            (( op_prec <= top_prec )) || break
                        fi
                        RPN_TYPE+=( "${STKT[-1]}" )
                        RPN_VAL+=( "${STKV[-1]}" )
                        STKT[${#STKT}]=()
                        STKV[${#STKV}]=()
                    done
                    STKT+=("OP")
                    STKV+=("$v")
                fi
                ;;
            LP)
                STKT+=("LP")
                STKV+=("(")
                ;;
            RP)
                while (( ${#STKT} > 0 )) && [[ "${STKT[-1]}" != "LP" ]]; do
                    RPN_TYPE+=( "${STKT[-1]}" )
                    RPN_VAL+=( "${STKV[-1]}" )
                    STKT[${#STKT}]=()
                    STKV[${#STKV}]=()
                done
                # Pop LP.
                if (( ${#STKT} > 0 )); then
                    STKT[${#STKT}]=()
                    STKV[${#STKV}]=()
                fi
                # If FUNC on top, pop it.
                if (( ${#STKT} > 0 )) && [[ "${STKT[-1]}" == "FUNC" ]]; then
                    RPN_TYPE+=( "${STKT[-1]}" )
                    RPN_VAL+=( "${STKV[-1]}" )
                    STKT[${#STKT}]=()
                    STKV[${#STKV}]=()
                fi
                ;;
        esac
        prev_type=$t
    done
    # Drain stack.
    while (( ${#STKT} > 0 )); do
        RPN_TYPE+=( "${STKT[-1]}" )
        RPN_VAL+=( "${STKV[-1]}" )
        STKT[${#STKT}]=()
        STKV[${#STKV}]=()
    done
}

# ───────── EVALUATOR ─────────

typeset -A VARS

eval_rpn() {
    typeset -a STACK
    STACK=()
    local n=${#RPN_TYPE} i
    for ((i=1; i<=n; i++)); do
        local t="${RPN_TYPE[i]}"
        local v="${RPN_VAL[i]}"
        case $t in
            NUM)
                STACK+=("$v")
                ;;
            VAR)
                local val="${VARS[$v]:-0}"
                STACK+=("$val")
                ;;
            OP)
                # Unary ops take 1 arg.
                if [[ $v == "u-" || $v == "u+" || $v == '!' || $v == '~' ]]; then
                    local a="${STACK[-1]}"
                    STACK[${#STACK}]=()
                    if [[ $v == "u-" ]]; then
                        STACK+=( $(( -a )) )
                    elif [[ $v == "u+" ]]; then
                        STACK+=( $(( a )) )
                    elif [[ $v == '!' ]]; then
                        STACK+=( $(( !a )) )
                    elif [[ $v == '~' ]]; then
                        STACK+=( $(( ~a )) )
                    fi
                else
                    local b="${STACK[-1]}"
                    STACK[${#STACK}]=()
                    local a="${STACK[-1]}"
                    STACK[${#STACK}]=()
                    case $v in
                        "+")  STACK+=( $(( a + b )) ) ;;
                        "-")  STACK+=( $(( a - b )) ) ;;
                        "*")  STACK+=( $(( a * b )) ) ;;
                        "/")  STACK+=( $(( a / b )) ) ;;
                        "%")  STACK+=( $(( a % b )) ) ;;
                        "**") STACK+=( $(( a ** b )) ) ;;
                        "&")  STACK+=( $(( a & b )) ) ;;
                        "|")  STACK+=( $(( a | b )) ) ;;
                        "^")  STACK+=( $(( a ^ b )) ) ;;
                        "<<") STACK+=( $(( a << b )) ) ;;
                        ">>") STACK+=( $(( a >> b )) ) ;;
                        "<")  STACK+=( $(( a < b )) ) ;;
                        "<=") STACK+=( $(( a <= b )) ) ;;
                        ">")  STACK+=( $(( a > b )) ) ;;
                        ">=") STACK+=( $(( a >= b )) ) ;;
                        "==") STACK+=( $(( a == b )) ) ;;
                        "!=") STACK+=( $(( a != b )) ) ;;
                        "&&") STACK+=( $(( a && b )) ) ;;
                        "||") STACK+=( $(( a || b )) ) ;;
                    esac
                fi
                ;;
            FUNC)
                case $v in
                    abs)
                        local x="${STACK[-1]}"
                        STACK[${#STACK}]=()
                        STACK+=( $(( x < 0 ? -x : x )) )
                        ;;
                    min)
                        local b="${STACK[-1]}"
                        STACK[${#STACK}]=()
                        local a="${STACK[-1]}"
                        STACK[${#STACK}]=()
                        STACK+=( $(( a < b ? a : b )) )
                        ;;
                    max)
                        local b="${STACK[-1]}"
                        STACK[${#STACK}]=()
                        local a="${STACK[-1]}"
                        STACK[${#STACK}]=()
                        STACK+=( $(( a > b ? a : b )) )
                        ;;
                    sqrt)
                        local x="${STACK[-1]}"
                        STACK[${#STACK}]=()
                        # Integer sqrt via Newton.
                        if (( x < 0 )); then
                            STACK+=( 0 )
                        else
                            local g=$x
                            while (( g*g > x )); do
                                g=$(( (g + x/g) / 2 ))
                            done
                            STACK+=( $g )
                        fi
                        ;;
                    floor|ceil|round)
                        # Integer math; pass through.
                        STACK+=( "${STACK[-1]}" )
                        ;;
                    *)
                        STACK+=( 0 )
                        ;;
                esac
                ;;
        esac
    done
    if (( ${#STACK} > 0 )); then
        echo "${STACK[1]}"
    else
        echo 0
    fi
}

# Full evaluation pipeline.
calc() {
    tokenize "$1"
    shunting_yard
    eval_rpn
}

# ───────── TESTS ─────────

echo "═══ Arithmetic Expression Evaluator ═══"

echo
echo "── basic arithmetic ──"
tests=(
    "1 + 2:3"
    "10 - 4:6"
    "3 * 7:21"
    "20 / 4:5"
    "17 % 5:2"
    "2 + 3 * 4:14"
    "(2 + 3) * 4:20"
    "100 - 50 / 10:95"
    "(10 + 5) * (8 - 3):75"
    "1 + 2 + 3 + 4 + 5:15"
)
for t in "${tests[@]}"; do
    expr="${t%:*}"
    expected="${t##*:}"
    result=$(calc "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-30s = %-6s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── precedence ──"
ptests=(
    "2 + 3 * 4 - 1:13"
    "2 * 3 + 4 * 5:26"
    "10 - 2 - 3:5"
    "100 / 5 / 2:10"
    "2 ** 3:8"
    "2 ** 3 + 1:9"
    "1 + 2 ** 3:9"
    "2 ** 2 ** 3:256"
    "10 - 2 + 3:11"
)
for t in "${ptests[@]}"; do
    expr="${t%:*}"
    expected="${t##*:}"
    result=$(calc "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-30s = %-6s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── parentheses ──"
ptests=(
    "(1 + 2) * 3:9"
    "((1 + 2) * 3):9"
    "(1 + (2 + (3 + 4))):10"
    "(1 + 2) * (3 + 4):21"
    "(((1+2))):3"
)
for t in "${ptests[@]}"; do
    expr="${t%:*}"
    expected="${t##*:}"
    result=$(calc "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-30s = %-6s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── unary operators ──"
utests=(
    "-5:-5"
    "-(3 + 2):-5"
    "5 + -3:2"
    "-(-5):5"
    "!5:0"
    "!0:1"
    "~0:-1"
)
for t in "${utests[@]}"; do
    expr="${t%:*}"
    expected="${t##*:}"
    result=$(calc "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-30s = %-6s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── comparison operators ──"
ctests=(
    "5 < 10:1"
    "10 < 5:0"
    "5 == 5:1"
    "5 == 6:0"
    "5 != 6:1"
    "10 >= 10:1"
    "10 > 10:0"
    "3 <= 5:1"
)
for t in "${ctests[@]}"; do
    expr="${t%:*}"
    expected="${t##*:}"
    result=$(calc "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-30s = %-6s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── logical operators ──"
ltests=(
    "1 && 1:1"
    "1 && 0:0"
    "0 && 1:0"
    "1 || 0:1"
    "0 || 0:0"
    "(5 < 10) && (10 > 3):1"
    "(5 > 10) || (10 > 3):1"
)
for t in "${ltests[@]}"; do
    expr="${t%:*}"
    expected="${t##*:}"
    result=$(calc "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-30s = %-6s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── bitwise operators ──"
btests=(
    "5 & 3:1"
    "5 | 3:7"
    "5 ^ 3:6"
    "0xff & 0x0f:15"
    "1 << 8:256"
    "256 >> 4:16"
    "~0 & 0xff:255"
)
for t in "${btests[@]}"; do
    expr="${t%:*}"
    expected="${t##*:}"
    result=$(calc "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-30s = %-6s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── functions ──"
ftests=(
    "abs(-5):5"
    "abs(5):5"
    "abs(-100):100"
    "min(3, 5):3"
    "min(10, 2):2"
    "max(3, 5):5"
    "max(10, 2):10"
    "sqrt(16):4"
    "sqrt(100):10"
    "sqrt(2):1"
    "sqrt(0):0"
    "abs(min(-5, 3)):5"
    "max(min(1,2), min(3,4)):3"
)
for t in "${ftests[@]}"; do
    expr="${t%:*}"
    expected="${t##*:}"
    result=$(calc "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-30s = %-6s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── variables ──"
VARS=(x 10 y 5 z 7 PI 3 N 100)
vtests=(
    "x:10"
    "x + y:15"
    "x * y:50"
    "x - y - z:-2"
    "x ** 2:100"
    "(x + y) * 2:30"
    "max(x, y):10"
    "min(x, y):5"
    "PI * 4:12"
    "N / x:10"
)
for t in "${vtests[@]}"; do
    expr="${t%:*}"
    expected="${t##*:}"
    result=$(calc "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-30s = %-6s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── compound expressions ──"
ctests=(
    "((1 + 2) * 3 + 4) / 2:6"
    "x + y * 2:20"
    "(x + y) * z:105"
    "abs(x - y * 3):5"
    "sqrt(x * x + y * y):11"
)
for t in "${ctests[@]}"; do
    expr="${t%:*}"
    expected="${t##*:}"
    result=$(calc "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-30s = %-6s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── show RPN translation ──"
for expr in "1 + 2" "1 + 2 * 3" "(1 + 2) * 3" "max(1, 2 + 3)" "x ** 2 + y ** 2"; do
    tokenize "$expr"
    shunting_yard
    printf "  %-30s → " "$expr"
    local i
    for ((i=1; i<=${#RPN_TYPE}; i++)); do
        printf "%s " "${RPN_VAL[i]}"
    done
    echo
done

echo
echo "── stress test (large expressions) ──"
big_tests=(
    "1+2+3+4+5+6+7+8+9+10:55"
    "((1+2)*(3+4))+((5+6)*(7+8)):186"
    "max(max(1,2),max(3,4)):4"
    "min(min(10,20),min(30,40)):10"
    "abs(-(((5+3)*2)-((10-4)*3))):2"
)
for t in "${big_tests[@]}"; do
    expr="${t%:*}"
    expected="${t##*:}"
    result=$(calc "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %s\n    = %s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── parse-only verification ──"
test_str="(x + y) * (z - 1) + abs(-42)"
echo "  input:  $test_str"
tokenize "$test_str"
echo "  tokens:"
for ((i=1; i<=${#TKTYPE}; i++)); do
    printf "    [%2d] %-6s = %s\n" $i "${TKTYPE[i]}" "${TKVAL[i]}"
done
shunting_yard
echo "  RPN:"
for ((i=1; i<=${#RPN_TYPE}; i++)); do
    printf "    [%2d] %-6s = %s\n" $i "${RPN_TYPE[i]}" "${RPN_VAL[i]}"
done
result=$(eval_rpn)
echo "  result: $result"

echo
echo "── related Src/*.c ──"
echo "  Src/math.c — \$(( expr )) tokenizer + evaluator"
echo "  Src/math.c::mathevali — int eval"
echo "  Src/math.c::mathevald — float eval"
echo "  Src/math.c::setmathvar — assign to variable in math context"
echo "  Src/math.c:getmathparam — variable read in arith"
echo
echo "  This demo reimplements the structural shape:"
echo "    tokenizer → Shunting-yard → RPN stack eval"
echo "  zsh's actual impl uses a hand-rolled recursive-descent"
echo "  parser with operator precedence climbing."

echo
echo "═══ Arithmetic evaluator complete ═══"

#!/usr/bin/env zshrs
# Mini-Lisp interpreter — tokenizer + parser + evaluator.
# Implements a subset of Scheme: define, lambda, if, cond, let, +, -, *, /,
# list operations, recursion, closures.

# ───────── TOKENIZER ─────────

typeset -ga LTOK

ltokenize() {
    local s=$1
    LTOK=()
    local i=1 n=${#s}
    while (( i <= n )); do
        local c="${s[i]}"
        if [[ $c == [[:space:]] ]]; then
            (( i++ ))
            continue
        fi
        if [[ $c == ";" ]]; then
            # Comment to end of line.
            while (( i <= n )) && [[ ${s[i]} != $'\n' ]]; do (( i++ )); done
            continue
        fi
        if [[ $c == "(" || $c == ")" ]]; then
            LTOK+=("$c")
            (( i++ ))
            continue
        fi
        if [[ $c == "'" ]]; then
            LTOK+=("'")
            (( i++ ))
            continue
        fi
        # Atom: collect until whitespace or paren.
        local atom=""
        while (( i <= n )) && [[ ${s[i]} != [[:space:]] && ${s[i]} != "(" && ${s[i]} != ")" ]]; do
            atom+="${s[i]}"
            (( i++ ))
        done
        if [[ -n $atom ]]; then
            LTOK+=("$atom")
        fi
    done
}

# ───────── PARSER ─────────
# AST nodes flat-stored:
#   AST_TYPE[id] = atom | list | string
#   AST_VAL[id]  = primitive
#   AST_CHILDREN[id] = "id1 id2 id3..."

typeset -A AST_TYPE AST_VAL AST_CHILDREN
typeset -gi AST_NEXT=0
typeset -gi LPOS=1

ast_alloc() {
    (( AST_NEXT++ ))
    LAST_AST=$AST_NEXT
}

ast_reset() {
    AST_TYPE=()
    AST_VAL=()
    AST_CHILDREN=()
    AST_NEXT=0
}

parse_expr() {
    if (( LPOS > ${#LTOK} )); then
        LAST_AST=""
        return
    fi
    local tok="${LTOK[LPOS]}"
    case $tok in
        "(")
            (( LPOS++ ))
            ast_alloc
            local list_id=$LAST_AST
            AST_TYPE[$list_id]="list"
            local children=""
            while (( LPOS <= ${#LTOK} )); do
                if [[ "${LTOK[LPOS]}" == ")" ]]; then
                    (( LPOS++ ))
                    break
                fi
                parse_expr
                if [[ -n $LAST_AST ]]; then
                    if [[ -z $children ]]; then
                        children="$LAST_AST"
                    else
                        children+=" $LAST_AST"
                    fi
                fi
            done
            AST_CHILDREN[$list_id]="$children"
            LAST_AST=$list_id
            ;;
        "'")
            # Quote next expression.
            (( LPOS++ ))
            parse_expr
            local inner=$LAST_AST
            ast_alloc
            local quoted=$LAST_AST
            AST_TYPE[$quoted]="list"
            ast_alloc
            local quote_atom=$LAST_AST
            AST_TYPE[$quote_atom]="atom"
            AST_VAL[$quote_atom]="quote"
            AST_CHILDREN[$quoted]="$quote_atom $inner"
            LAST_AST=$quoted
            ;;
        ")")
            (( LPOS++ ))
            LAST_AST=""
            ;;
        *)
            ast_alloc
            AST_TYPE[$LAST_AST]="atom"
            AST_VAL[$LAST_AST]="$tok"
            (( LPOS++ ))
            ;;
    esac
}

# ───────── ENVIRONMENT ─────────
# ENV[scope_id_name] = value_id (AST node)
# PARENT[scope_id] = parent_scope_id

typeset -A ENV ENV_PARENT
typeset -gi ENV_NEXT=0
typeset -gi GLOBAL_SCOPE=0

env_init() {
    (( ENV_NEXT++ ))
    GLOBAL_SCOPE=$ENV_NEXT
    ENV_PARENT[$GLOBAL_SCOPE]=0
}

env_new_scope() {
    local parent=$1
    (( ENV_NEXT++ ))
    ENV_PARENT[$ENV_NEXT]=$parent
    LAST_SCOPE=$ENV_NEXT
}

env_set() {
    local scope=$1 name=$2 val=$3
    ENV["${scope}_${name}"]=$val
}

env_get() {
    local scope=$1 name=$2
    while (( scope > 0 )); do
        local v="${ENV[${scope}_${name}]}"
        if [[ -n $v ]]; then
            echo "$v"
            return
        fi
        scope="${ENV_PARENT[$scope]}"
    done
    echo ""
}

# ───────── EVALUATOR ─────────

is_num() {
    local s=$1
    [[ $s == -?[0-9]## || $s == [0-9]## ]]
}

# Eval AST node in scope. Returns AST id of result.
eval_node() {
    local node=$1 scope=$2
    local typ="${AST_TYPE[$node]}"
    case $typ in
        atom)
            local v="${AST_VAL[$node]}"
            if is_num "$v"; then
                LAST_EVAL=$node
                return
            fi
            # Variable lookup.
            local found=$(env_get $scope "$v")
            if [[ -n $found ]]; then
                LAST_EVAL=$found
                return
            fi
            # Unbound — return as-is.
            LAST_EVAL=$node
            ;;
        list)
            local children="${AST_CHILDREN[$node]}"
            if [[ -z $children ]]; then
                LAST_EVAL=$node
                return
            fi
            local -a kids
            kids=( ${=children} )
            local head=${kids[1]}
            local head_val="${AST_VAL[$head]}"
            # Avoid case-pattern parse bugs with reserved-word keywords.
            if [[ $head_val == "quote" ]]; then
                LAST_EVAL=${kids[2]}
                return
            fi
            if [[ $head_val == "if" ]]; then
                eval_node ${kids[2]} $scope
                local cond=$LAST_EVAL
                local cond_v="${AST_VAL[$cond]}"
                if [[ $cond_v != "0" && $cond_v != "false" && $cond_v != "()" && -n $cond_v ]]; then
                    eval_node ${kids[3]} $scope
                elif [[ -n ${kids[4]} ]]; then
                    eval_node ${kids[4]} $scope
                else
                    ast_alloc
                    AST_TYPE[$LAST_AST]=atom
                    AST_VAL[$LAST_AST]="0"
                    LAST_EVAL=$LAST_AST
                fi
                return
            fi
            if [[ $head_val == "let" ]]; then
                env_new_scope $scope
                local new_scope=$LAST_SCOPE
                local bindings_id=${kids[2]}
                local bindings_kids="${AST_CHILDREN[$bindings_id]}"
                local b
                for b in ${=bindings_kids}; do
                    local bk_str="${AST_CHILDREN[$b]}"
                    local -a bk
                    bk=( ${=bk_str} )
                    local vname="${AST_VAL[${bk[1]}]}"
                    eval_node ${bk[2]} $scope
                    env_set $new_scope "$vname" $LAST_EVAL
                done
                local i
                for ((i=3; i<=${#kids}; i++)); do
                    eval_node ${kids[i]} $new_scope
                done
                return
            fi
            case $head_val in
                define)
                    # (define name expr) or (define (fname args...) body)
                    local target=${kids[2]}
                    if [[ "${AST_TYPE[$target]}" == atom ]]; then
                        local name="${AST_VAL[$target]}"
                        eval_node ${kids[3]} $scope
                        env_set $scope "$name" $LAST_EVAL
                    else
                        # function shorthand
                        local fname_id_kids="${AST_CHILDREN[$target]}"
                        local -a fnk
                        fnk=( ${=fname_id_kids} )
                        local fname="${AST_VAL[${fnk[1]}]}"
                        # Build lambda: (lambda (args) body...)
                        # We'll just store the params list and body.
                        ast_alloc
                        local lambda_node=$LAST_AST
                        AST_TYPE[$lambda_node]="lambda"
                        # Params = rest of fnk
                        local params=""
                        local i
                        for ((i=2; i<=${#fnk}; i++)); do
                            if [[ -z $params ]]; then
                                params="${fnk[i]}"
                            else
                                params+=" ${fnk[i]}"
                            fi
                        done
                        # Body = kids[3..]
                        local body=""
                        for ((i=3; i<=${#kids}; i++)); do
                            if [[ -z $body ]]; then
                                body="${kids[i]}"
                            else
                                body+=" ${kids[i]}"
                            fi
                        done
                        # Store params + body + scope.
                        AST_VAL[$lambda_node]="$scope|$params|$body"
                        env_set $scope "$fname" $lambda_node
                    fi
                    LAST_EVAL=$node
                    ;;
                lambda)
                    # (lambda (params) body)
                    ast_alloc
                    local lambda_node=$LAST_AST
                    AST_TYPE[$lambda_node]="lambda"
                    local params_id=${kids[2]}
                    local params_kids="${AST_CHILDREN[$params_id]}"
                    local body=""
                    local i
                    for ((i=3; i<=${#kids}; i++)); do
                        if [[ -z $body ]]; then
                            body="${kids[i]}"
                        else
                            body+=" ${kids[i]}"
                        fi
                    done
                    AST_VAL[$lambda_node]="$scope|$params_kids|$body"
                    LAST_EVAL=$lambda_node
                    ;;
                cond)
                    # (cond (test1 expr1) (test2 expr2) ... (else expr))
                    local i
                    local matched=0
                    for ((i=2; i<=${#kids}; i++)); do
                        local branch_id=${kids[i]}
                        local branch_kids="${AST_CHILDREN[$branch_id]}"
                        local -a bk
                        bk=( ${=branch_kids} )
                        local test_v="${AST_VAL[${bk[1]}]}"
                        if [[ $test_v == "else" ]]; then
                            eval_node ${bk[2]} $scope
                            matched=1
                            break
                        fi
                        eval_node ${bk[1]} $scope
                        local cond_val="${AST_VAL[$LAST_EVAL]}"
                        if [[ $cond_val != "0" && $cond_val != "false" ]]; then
                            eval_node ${bk[2]} $scope
                            matched=1
                            break
                        fi
                    done
                    if (( ! matched )); then
                        ast_alloc
                        AST_TYPE[$LAST_AST]=atom
                        AST_VAL[$LAST_AST]="0"
                        LAST_EVAL=$LAST_AST
                    fi
                    ;;
                "+"|"-"|"*"|"/"|"%"|"<"|">"|"<="|">="|"=")
                    # Arithmetic / comparison.
                    local op=$head_val
                    local -a args
                    args=()
                    local i
                    for ((i=2; i<=${#kids}; i++)); do
                        eval_node ${kids[i]} $scope
                        args+=("${AST_VAL[$LAST_EVAL]}")
                    done
                    local result=0
                    case $op in
                        "+")
                            result=0
                            for a in "${args[@]}"; do (( result += a )); done
                            ;;
                        "-")
                            if [[ ${#args} == 1 ]]; then
                                result=$(( -${args[1]} ))
                            else
                                result=${args[1]}
                                local i
                                for ((i=2; i<=${#args}; i++)); do
                                    (( result -= args[i] ))
                                done
                            fi
                            ;;
                        "*")
                            result=1
                            for a in "${args[@]}"; do (( result *= a )); done
                            ;;
                        "/")
                            result=${args[1]}
                            local i
                            for ((i=2; i<=${#args}; i++)); do
                                (( result /= args[i] ))
                            done
                            ;;
                        "%")
                            result=$(( ${args[1]} % ${args[2]} ))
                            ;;
                        "<")  (( ${args[1]} < ${args[2]} )) && result=1 ;;
                        ">")  (( ${args[1]} > ${args[2]} )) && result=1 ;;
                        "<=") (( ${args[1]} <= ${args[2]} )) && result=1 ;;
                        ">=") (( ${args[1]} >= ${args[2]} )) && result=1 ;;
                        "=")  (( ${args[1]} == ${args[2]} )) && result=1 ;;
                    esac
                    ast_alloc
                    AST_TYPE[$LAST_AST]=atom
                    AST_VAL[$LAST_AST]="$result"
                    LAST_EVAL=$LAST_AST
                    ;;
                begin)
                    # (begin expr1 expr2 ... exprN) — eval all, return last.
                    local i
                    for ((i=2; i<=${#kids}; i++)); do
                        eval_node ${kids[i]} $scope
                    done
                    ;;
                *)
                    # Function call. Look up head.
                    local fn_id=$(env_get $scope "$head_val")
                    if [[ -z $fn_id ]]; then
                        # Possibly anon lambda or unbound.
                        eval_node $head $scope
                        fn_id=$LAST_EVAL
                    fi
                    if [[ "${AST_TYPE[$fn_id]}" == lambda ]]; then
                        local lambda_data="${AST_VAL[$fn_id]}"
                        local def_scope="${lambda_data%%|*}"
                        local rest="${lambda_data#*|}"
                        local params_str="${rest%%|*}"
                        local body_str="${rest#*|}"
                        env_new_scope $def_scope
                        local call_scope=$LAST_SCOPE
                        # Bind args.
                        local -a param_ids
                        param_ids=( ${=params_str} )
                        local i
                        for ((i=2; i<=${#kids}; i++)); do
                            eval_node ${kids[i]} $scope
                            local arg_val=$LAST_EVAL
                            local p_id="${param_ids[i-1]}"
                            local p_name="${AST_VAL[$p_id]}"
                            env_set $call_scope "$p_name" $arg_val
                        done
                        # Eval body sequence.
                        local body_arr
                        body_arr=( ${=body_str} )
                        local i
                        for ((i=1; i<=${#body_arr}; i++)); do
                            eval_node ${body_arr[i]} $call_scope
                        done
                    else
                        LAST_EVAL=$node
                    fi
                    ;;
            esac
            ;;
    esac
}

# Pretty-print AST node (for displaying results).
ast_str() {
    local node=$1
    local typ="${AST_TYPE[$node]}"
    case $typ in
        atom)
            echo "${AST_VAL[$node]}"
            ;;
        list)
            local children="${AST_CHILDREN[$node]}"
            if [[ -z $children ]]; then echo "()"; return; fi
            local out="(" first=1
            for ch in ${=children}; do
                if (( ! first )); then out+=" "; fi
                out+="$(ast_str $ch)"
                first=0
            done
            out+=")"
            echo "$out"
            ;;
        lambda)
            echo "<lambda>"
            ;;
    esac
}

# Main eval helper.
run_lisp() {
    local src=$1
    ast_reset
    ltokenize "$src"
    LPOS=1
    local result_id=""
    while (( LPOS <= ${#LTOK} )); do
        parse_expr
        if [[ -n $LAST_AST ]]; then
            eval_node $LAST_AST $GLOBAL_SCOPE
            result_id=$LAST_EVAL
        fi
    done
    if [[ -n $result_id ]]; then
        ast_str $result_id
    fi
}

# ───────── TESTS ─────────

echo "═══ Mini-Lisp interpreter ═══"

env_init

echo
echo "── tokenizer ──"
ltokenize "(+ 1 2 (- 5 3))"
echo "  '(+ 1 2 (- 5 3))' →"
echo "    tokens: ${LTOK[*]}"

ltokenize "(define (square x) (* x x))"
echo "  '(define (square x) (* x x))' →"
echo "    tokens: ${LTOK[*]}"

echo
echo "── arithmetic ──"
arith=(
    "(+ 1 2)|3"
    "(+ 1 2 3 4 5)|15"
    "(- 10 3)|7"
    "(- 10 3 2)|5"
    "(- 5)|-5"
    "(* 2 3 4)|24"
    "(/ 100 4)|25"
    "(/ 100 4 5)|5"
    "(% 17 5)|2"
    "(+ (* 2 3) (- 10 5))|11"
    "(* (+ 1 2) (+ 3 4))|21"
)
for t in "${arith[@]}"; do
    expr="${t%|*}"
    expected="${t#*|}"
    env_init
    result=$(run_lisp "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-35s = %-5s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── comparisons ──"
comp=(
    "(< 3 5)|1"
    "(> 3 5)|0"
    "(= 5 5)|1"
    "(<= 5 5)|1"
    "(>= 6 5)|1"
)
for t in "${comp[@]}"; do
    expr="${t%|*}"
    expected="${t#*|}"
    env_init
    result=$(run_lisp "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-25s = %-5s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── define + function call ──"
prog='(define square (lambda (x) (* x x)))
(square 5)'
env_init
result=$(run_lisp "$prog")
echo "  (define square (lambda (x) (* x x)))"
echo "  (square 5) → $result"

echo
echo "── if conditional ──"
ifs=(
    "(if 1 100 200)|100"
    "(if 0 100 200)|200"
    "(if (> 5 3) (* 2 5) (- 5 2))|10"
    "(if (< 5 3) (* 2 5) (- 5 2))|3"
)
for t in "${ifs[@]}"; do
    expr="${t%|*}"
    expected="${t#*|}"
    env_init
    result=$(run_lisp "$expr")
    mark="✓"
    [[ $result != $expected ]] && mark="✗"
    printf "  %-40s = %-5s (expected %s) %s\n" "$expr" "$result" "$expected" "$mark"
done

echo
echo "── lambda ──"
env_init
result=$(run_lisp "(define double (lambda (x) (* 2 x)))
(double 21)")
echo "  (double 21) = $result"

env_init
result=$(run_lisp "(define add (lambda (a b) (+ a b)))
(add 30 12)")
echo "  (add 30 12) = $result"

echo
echo "── recursion (factorial) ──"
fact='(define fact (lambda (n)
  (if (<= n 1) 1 (* n (fact (- n 1))))))
(fact 5)'
env_init
result=$(run_lisp "$fact")
echo "  (fact 5) = $result (expected 120)"

echo
echo "── recursion (Fibonacci) ──"
fib='(define fib (lambda (n)
  (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2))))))
(fib 10)'
env_init
result=$(run_lisp "$fib")
echo "  (fib 10) = $result (expected 55)"

echo
echo "── let bindings ──"
env_init
let_result=$(run_lisp "(let ((x 5) (y 10)) (+ x y))")
echo "  (let ((x 5) (y 10)) (+ x y)) = $let_result"

env_init
let_result=$(run_lisp "(let ((a 3) (b 4)) (let ((c (* a a)) (d (* b b))) (+ c d)))")
echo "  nested let: a²+b² for a=3,b=4 = $let_result"

echo
echo "── closures ──"
env_init
closure='(define make-adder (lambda (n) (lambda (x) (+ x n))))
(define add5 (make-adder 5))
(add5 10)'
result=$(run_lisp "$closure")
echo "  make-adder closure: (add5 10) = $result"

echo
echo "── multiple defines ──"
env_init
multi='(define x 10)
(define y 20)
(define z 30)
(+ x y z)'
result=$(run_lisp "$multi")
echo "  x=10 y=20 z=30, (+ x y z) = $result"

echo
echo "── parser stats ──"
echo "  AST nodes built so far: $AST_NEXT"
echo "  env scopes created:     $ENV_NEXT"

echo
echo "── nested function calls ──"
env_init
nested='(define inc (lambda (x) (+ x 1)))
(define dec (lambda (x) (- x 1)))
(inc (inc (inc (dec (dec 10)))))'
result=$(run_lisp "$nested")
echo "  inc(inc(inc(dec(dec 10)))) = $result"

echo
echo "── conditional chain ──"
env_init
cond_chain='(define classify (lambda (n)
  (if (< n 0) -1
    (if (= n 0) 0 1))))
(classify -5)'
result=$(run_lisp "$cond_chain")
echo "  classify(-5) = $result"
env_init
result=$(run_lisp "(define classify (lambda (n)
  (if (< n 0) -1
    (if (= n 0) 0 1))))
(classify 0)")
echo "  classify(0) = $result"
env_init
result=$(run_lisp "(define classify (lambda (n)
  (if (< n 0) -1
    (if (= n 0) 0 1))))
(classify 7)")
echo "  classify(7) = $result"

echo
echo "── related Src/*.c ──"
echo "  This Lisp's structure mirrors zsh's own evaluator:"
echo "    Src/lex.c    — tokenizer"
echo "    Src/parse.c  — AST construction"
echo "    Src/exec.c   — execwordcode / tree walker"
echo
echo "  zsh evaluates compound commands (if/case/loop) by walking the"
echo "  parse tree node-by-node, much like this Lisp interpreter walks"
echo "  the s-expression AST."

echo
echo "── interpreter statistics ──"
echo "  forms supported:"
echo "    arithmetic:    + - * / % (variadic)"
echo "    comparison:    < > <= >= ="
echo "    control:       if cond begin let"
echo "    functions:     define lambda (closures)"
echo "    quoting:       quote / '"
echo
echo "  semantic features:"
echo "    lexical scope w/ parent chain"
echo "    closures capture defining environment"
echo "    proper tail position (sans optimization)"
echo "    recursion via define + lambda"

echo
echo "═══ Mini-Lisp interpreter complete ═══"

#!/bin/zsh -f
# The line above is just for convenience.  Normally tests will be run using
# a specified version of zsh.  With dynamic loading, any required libraries
# must already have been installed in that case.
#
# Takes one argument: the name of the test file.  Currently only one such
# file will be processed each time ztst.zsh is run.  This is slower, but
# much safer in terms of preserving the correct status.
# To avoid namespace pollution, all functions and parameters used
# only by the script begin with ZTST_.
#
# Options (without arguments) may precede the test file argument; these
# are interpreted as shell options to set.  -x is probably the most useful.

# Produce verbose messages if non-zero.
# If 1, produce reports of tests executed; if 2, also report on progress.
# Defined in such a way that any value from the environment is used.
: ${ZTST_verbose:=0}

# If non-zero, continue the tests even after a test fails.
: ${ZTST_continue:=0}

# We require all options to be reset, not just emulation options.
# Unfortunately, due to the crud which may be in /etc/zshenv this might
# still not be good enough.  Maybe we should trick it somehow.
emulate -R zsh

# By default tests are run in C locale. LANG must be passed to child zsh.
unset -m LC_\*
export LANG=C

# find UTF-8 locale
ZTST_find_UTF8 () {
  setopt multibyte
  local langs=(en_{US,GB}.{UTF-,utf}8 en.UTF-8
               ${(M)$(locale -a 2>/dev/null):#*.(utf8|UTF-8)})
  for LANG in $langs; do
    if [[ é = ? ]]; then
      echo $LANG
      return
    fi
  done
}

# Don't propagate variables that are set by default in the shell.
typeset +x WORDCHARS

# Set the module load path to correspond to this build of zsh.
# This Modules directory should have been created by "make check".
[[ -d Modules/zsh ]] && module_path=( $PWD/Modules )

# We need to be able to save and restore the options used in the test.
# We use the $options variable of the parameter module for this.
zmodload zsh/parameter

# Note that both the following are regular arrays, since we only use them
# in whole array assignments to/from $options.
# Options set in test code (i.e. by default all standard options)
ZTST_testopts=(${(kv)options})

setopt extendedglob nonomatch
while [[ $1 = [-+]* ]]; do
  set $1
  shift
done
# Options set in main script
ZTST_mainopts=(${(kv)options})

# We run in the current directory, so remember it.
ZTST_testdir=$PWD
ZTST_testname=$1

integer ZTST_testfailed=0

# This is POSIX nonsense.  Because of the vague feeling someone, somewhere
# may one day need to examine the arguments of "tail" using a standard
# option parser, every Unix user in the world is expected to switch
# to using "tail -n NUM" instead of "tail -NUM".  Older versions of
# tail don't support this.
tail() {
  emulate -L zsh

  if [[ -z $TAIL_SUPPORTS_MINUS_N ]]; then
    local test
    test=$(echo "foo\nbar" | command tail -n 1 2>/dev/null)
    if [[ $test = bar ]]; then
      TAIL_SUPPORTS_MINUS_N=1
    else
      TAIL_SUPPORTS_MINUS_N=0
    fi
  fi

  integer argi=${argv[(i)-<->]}

  if [[ $argi -le $# && $TAIL_SUPPORTS_MINUS_N = 1 ]]; then
    argv[$argi]=(-n ${argv[$argi][2,-1]})
  fi

  command tail "$argv[@]"
}

# The source directory is not necessarily the current directory,
# but if $0 doesn't contain a `/' assume it is.
if [[ $0 = */* ]]; then
  ZTST_srcdir=${0%/*}
else
  ZTST_srcdir=$PWD
fi
[[ $ZTST_srcdir = /* ]] || ZTST_srcdir="$ZTST_testdir/$ZTST_srcdir"

# Set the function autoload paths to correspond to this build of zsh.
fpath=( $ZTST_srcdir/../Functions/*~*/CVS(/)
        $ZTST_srcdir/../Completion
        $ZTST_srcdir/../Completion/*/*~*/CVS(/) )

: ${TMPPREFIX:=/tmp/zsh}
ZTST_tmp=${TMPPREFIX}.ztst.$$
if ! rm -f $ZTST_tmp || ! mkdir -p $ZTST_tmp || ! chmod go-w $ZTST_tmp; then
  print "Can't create $ZTST_tmp for exclusive use." >&2
  exit 1
fi
# Temporary files for redirection inside tests.
ZTST_in=${ZTST_tmp}/ztst.in
# hold the expected output
ZTST_out=${ZTST_tmp}/ztst.out
ZTST_err=${ZTST_tmp}/ztst.err
# hold the actual output from the test
ZTST_tout=${ZTST_tmp}/ztst.tout
ZTST_terr=${ZTST_tmp}/ztst.terr

ZTST_cleanup() {
  cd $ZTST_testdir
  rm -rf $ZTST_testdir/dummy.tmp $ZTST_testdir/*.tmp(N) ${ZTST_tmp}
}

# This cleanup always gets performed, even if we abort.  Later,
# we should try and arrange that any test-specific cleanup
# always gets called as well.
##trap 'print cleaning up...
##ZTST_cleanup' INT QUIT TERM
# Make sure it's clean now.
rm -rf dummy.tmp *.tmp

# Report failure.  Note that all output regarding the tests goes to stdout.
# That saves an unpleasant mixture of stdout and stderr to sort out.
ZTST_testfailed() {
  print -r "Test $ZTST_testname failed: $1"
  if [[ -n $ZTST_message ]]; then
    print -r "Was testing: $ZTST_message"
  fi
  print -r "$ZTST_testname: test failed."
  if [[ -n $ZTST_failmsg ]]; then
    print -r "The following may (or may not) help identifying the cause:
$ZTST_failmsg"
  fi
  ZTST_testfailed=1
  # if called from within ZTST_Test() this will increment ZTST_Test's local
  # ZTST_failures. Otherwise global ZTST_failures will be incremented
  # (but currently its value is not used).
  (( ++ZTST_failures ))
  return 1
}
ZTST_testxpassed() {
  print -r "Test $ZTST_testname was expected to fail, but passed."
  if [[ -n $ZTST_message ]]; then
    print -r "Was testing: $ZTST_message"
  fi
  print -r "$ZTST_testname: test XPassed."
  if [[ -n $ZTST_failmsg ]]; then
    print -r "The following may (or may not) help identifying the cause:
$ZTST_failmsg"
  fi
  ZTST_testfailed=1
  (( ++ZTST_failures ))
  return 1
}

# Print messages if $ZTST_verbose is non-empty
ZTST_verbose() {
  local lev=$1
  shift
  if [[ -n $ZTST_verbose && $ZTST_verbose -ge $lev ]]; then
    print -r -u $ZTST_fd -- $*
  fi
}
ZTST_hashmark() {
  if [[ ZTST_verbose -le 0 && -t $ZTST_fd ]]; then
    print -n -u$ZTST_fd -- ${(pl:SECONDS::\#::\#\r:)}
  fi
  (( SECONDS > COLUMNS+1 && (SECONDS -= COLUMNS) ))
}

if [[ ! -r $ZTST_testname ]]; then
  ZTST_testfailed "can't read test file."
  exit 1
fi

exec {ZTST_fd}>&1
exec {ZTST_input}<$ZTST_testname

# The current line read from the test file.
ZTST_curline=''
# The current section being run
ZTST_cursect=''

# Get a new input line.  Don't mangle spaces; set IFS locally to empty.
# We shall skip comments at this level.
ZTST_getline() {
  local IFS=
  while true; do
    read -u $ZTST_input -r ZTST_curline || return 1
    [[ $ZTST_curline == \#* ]] || return 0
  done
}

# Get the name of the section.  It may already have been read into
# $curline, or we may have to skip some initial comments to find it.
# If argument present, it's OK to skip the reset of the current section,
# so no error if we find garbage.
ZTST_getsect() {
  local match mbegin mend

  while [[ $ZTST_curline != '%'(#b)([[:alnum:]]##)* ]]; do
    ZTST_getline || return 1
    [[ $ZTST_curline = [[:blank:]]# ]] && continue
    if [[ $# -eq 0 && $ZTST_curline != '%'[[:alnum:]]##* ]]; then
      ZTST_testfailed "bad line found before or after section:
$ZTST_curline"
      exit 1
    fi
  done
  # have the next line ready waiting
  ZTST_getline
  ZTST_cursect=${match[1]}
  ZTST_verbose 2 "ZTST_getsect: read section name: $ZTST_cursect"
  return 0
}

# Read in an indented code chunk for execution
ZTST_getchunk() {
  # Code chunks are always separated by blank lines or the
  # end of a section, so if we already have a piece of code,
  # we keep it.  Currently that shouldn't actually happen.
  ZTST_code=''
  # First find the chunk.
  while [[ $ZTST_curline = [[:blank:]]# ]]; do
    ZTST_getline || break
  done
  while [[ $ZTST_curline = [[:blank:]]##[^[:blank:]]* ]]; do
    ZTST_code="${ZTST_code:+${ZTST_code}
}${ZTST_curline}"
    ZTST_getline || break
  done
  ZTST_verbose 2 "ZTST_getchunk: read code chunk:
$ZTST_code"
  [[ -n $ZTST_code ]]
}

# Read in a piece for redirection.
ZTST_getredir() {
  local char=${ZTST_curline[1]} fn
  ZTST_redir=${ZTST_curline[2,-1]}
  while ZTST_getline; do
    [[ $ZTST_curline[1] = $char ]] || break
    ZTST_redir="${ZTST_redir}
${ZTST_curline[2,-1]}"
  done
  ZTST_verbose 2 "ZTST_getredir: read redir for '$char':
$ZTST_redir"

  case $char in
    ('<') fn=$ZTST_in
    ;;
    ('>') fn=$ZTST_out
    ;;
    ('?') fn=$ZTST_err
    ;;
    (*)  ZTST_testfailed "bad redir operator: $char"
    return 1
    ;;
  esac
  if [[ $ZTST_flags = *q* && $char = '<' ]]; then
    # delay substituting output until variables are set
    print -r -- "${(e)ZTST_redir}" >>$fn
  else
    print -r -- "$ZTST_redir" >>$fn
  fi

  return 0
}

# Execute an indented chunk.  Redirections will already have
# been set up, but we need to handle the options.
ZTST_execchunk() {
  setopt localloops # don't let continue & break propagate out
  options=($ZTST_testopts)
  () {
      unsetopt localloops
      eval "$ZTST_code"
  }
  ZTST_status=$?
  # careful... ksh_arrays may be in effect.
  ZTST_testopts=(${(kv)options[*]})
  options=(${ZTST_mainopts[*]})
  ZTST_verbose 2 "ZTST_execchunk: status $ZTST_status"
  return $ZTST_status
}

# Functions for preparation and cleaning.
ZTST_prep ZTST_clean () {
  # Execute indented code chunks. If ZTST_unimplemented is set
  # in any chunk then we will skip the remaining chunks.
  # We ignore return status of chunks when cleaning up.
  while [[ -z "$ZTST_unimplemented" ]] && ZTST_getchunk; do
    ZTST_execchunk >/dev/null || [[ $0 = ZTST_clean ]] || {
      ZTST_testfailed "non-zero status from preparation code:
$ZTST_code"
      return 1
    }
  done
  return 0
}

# diff wrapper
ZTST_diff() {
  emulate -L zsh
  setopt extendedglob

  local -a diff_arg
  local diff_out
  integer diff_pat diff_ret

  case $1 in
    (p)
    diff_pat=1
    ;;

    (d)
    ;;

    (*)
    print "Bad ZTST_diff code: d for diff, p for pattern match"
    ;;
  esac
  shift
  [[ $OSTYPE != (aix|solaris)* ]] && diff_arg=( -a )
      
  if (( diff_pat )); then
    local -a diff_lines1 diff_lines2
    integer failed i l
    local p

    diff_lines1=("${(f@)$(<$argv[-2])}")
    diff_lines2=("${(f@)$(<$argv[-1])}")
    if (( ${#diff_lines1} != ${#diff_lines2} )); then
      failed=1
      print -r "Pattern match failed, line mismatch (${#diff_lines1}/${#diff_lines2}):"
    else
      for (( i = 1; i <= ${#diff_lines1}; i++ )); do
	if [[ ${diff_lines2[i]} != ${~diff_lines1[i]} ]]; then
	  failed=1
	  print -r "Pattern match failed, line $i:"
	  break
	fi
      done
    fi
    if (( failed )); then
      for (( l = 1; l <= ${#diff_lines1}; ++l )); do
	if (( l == i )); then
	  p="-"
	else
	  p=" "
	fi
	print -r -- "$p<${diff_lines1[l]}"
      done
      for (( l = 1; l <= ${#diff_lines2}; ++l )); do
	if (( l == i )); then
	  p="+"
	else
	  p=" "
	fi
	print -r -- "$p>${diff_lines2[l]}"
      done
      diff_ret=1
    fi
  else
    diff_out=$(diff $diff_arg "$@")
    diff_ret="$?"
    if [[ "$diff_ret" != "0" ]]; then
      print -r -- "$diff_out"
    fi
  fi

  return "$diff_ret"
}

ZTST_test() {
  local last match mbegin mend found substlines
  local diff_out diff_err
  local ZTST_skip
  integer expected_to_fail ZTST_failures

  while true; do
    rm -f $ZTST_in $ZTST_out $ZTST_err
    touch $ZTST_in $ZTST_out $ZTST_err
    ZTST_message=''
    ZTST_failmsg=''
    found=0
    diff_out=d
    diff_err=d

    ZTST_verbose 2 "ZTST_test: looking for new test"

    while true; do
      ZTST_verbose 2 "ZTST_test: examining line:
$ZTST_curline"
      case $ZTST_curline in
	(%*) if [[ $found = 0 ]]; then
	      break 2
	    else
	      last=1
	      break
	    fi
	    ;;
	([[:space:]]#)
	    if [[ $found = 0 ]]; then
	      ZTST_getline || break 2
	      continue
	    else
	      break
	    fi
	    ;;
	([[:space:]]##[^[:space:]]*) ZTST_getchunk
	  if [[ $ZTST_curline == (#b)([-0-9]##)([[:alpha:]]#)(:*)# ]]; then
	    ZTST_xstatus=$match[1]
	    ZTST_flags=$match[2]
	    ZTST_message=${match[3]:+${match[3][2,-1]}}
	  else
	    ZTST_testfailed "expecting test status at:
$ZTST_curline"
	    return 1
	  fi
	  ZTST_getline
	  found=1
	  ;;
	('<'*) ZTST_getredir || return 1
	  found=1
	  ;;
	('*>'*)
	  ZTST_curline=${ZTST_curline[2,-1]}
	  diff_out=p
	  ;&
	('>'*)
	  ZTST_getredir || return 1
	  found=1
	  ;;
	('*?'*)
	  ZTST_curline=${ZTST_curline[2,-1]}
	  diff_err=p
	  ;&
	('?'*)
	  ZTST_getredir || return 1
	  found=1
	  ;;
	('F:'*) ZTST_failmsg="${ZTST_failmsg:+${ZTST_failmsg}
}  ${ZTST_curline[3,-1]}"
	  ZTST_getline
	  found=1
          ;;
	(*) ZTST_testfailed "bad line in test block:
$ZTST_curline"
	  return 1
          ;;
      esac
    done

    # If we found some code to execute...
    if [[ -n $ZTST_code ]]; then
      ZTST_hashmark
      ZTST_verbose 1 "Running test: $ZTST_message"
      ZTST_verbose 2 "ZTST_test: expecting status: $ZTST_xstatus"
      ZTST_verbose 2 "Input: $ZTST_in, output: $ZTST_out, error: $ZTST_terr"

      ZTST_execchunk <$ZTST_in >$ZTST_tout 2>$ZTST_terr

      if [[ -n $ZTST_skip ]]; then
	ZTST_verbose 0 "Test case skipped: $ZTST_skip"
	ZTST_skip=
	if [[ -n $last ]]; then
	  break
	else
	  continue
	fi
      fi

      if [[ $ZTST_flags = *f* ]]; then
        expected_to_fail=1
        ZTST_xfail_diff() { ZTST_diff "$@" > /dev/null }
        ZTST_diff=ZTST_xfail_diff
      else
        expected_to_fail=0
        ZTST_diff=ZTST_diff
      fi

      # First check we got the right status, if specified.
      if [[ $ZTST_xstatus != - && $ZTST_xstatus != $ZTST_status ]]; then
        if (( expected_to_fail )); then
          ZTST_verbose 1 "Test failed, as expected."
          continue
        fi
	ZTST_testfailed "bad status $ZTST_status, expected $ZTST_xstatus from:
$ZTST_code${$(<$ZTST_terr):+
Error output:
$(<$ZTST_terr)}"
        if (( ZTST_continue ));then continue; else return 1; fi
      fi

      ZTST_verbose 2 "ZTST_test: test produced standard output:
$(<$ZTST_tout)
ZTST_test: and standard error:
$(<$ZTST_terr)"

      # Now check output and error.
      if [[ $ZTST_flags = *q* && -s $ZTST_out ]]; then
	substlines="$(<$ZTST_out)"
	rm -rf $ZTST_out
	print -r -- "${(e)substlines}" >$ZTST_out
      fi
      if [[ $ZTST_flags != *d* ]] && ! $ZTST_diff $diff_out -u $ZTST_out $ZTST_tout; then
        if (( expected_to_fail )); then
          ZTST_verbose 1 "Test failed, as expected."
          continue
        fi
	ZTST_testfailed "output differs from expected as shown above for:
$ZTST_code${$(<$ZTST_terr):+
Error output:
$(<$ZTST_terr)}"
        if (( ZTST_continue ));then continue; else return 1; fi
      fi
      if [[ $ZTST_flags = *q* && -s $ZTST_err ]]; then
	substlines="$(<$ZTST_err)"
	rm -rf $ZTST_err
	print -r -- "${(e)substlines}" >$ZTST_err
      fi
      if [[ $ZTST_flags != *D* ]] && ! $ZTST_diff $diff_err -u $ZTST_err $ZTST_terr; then
        if (( expected_to_fail )); then
          ZTST_verbose 1 "Test failed, as expected."
          continue
        fi
	ZTST_testfailed "error output differs from expected as shown above for:
$ZTST_code"
        if (( ZTST_continue ));then continue; else return 1; fi
      fi
      if (( expected_to_fail )); then
        ZTST_testxpassed
        if (( ZTST_continue ));then continue; else return 1; fi
      fi
    fi
    ZTST_verbose 1 "Test successful."
    [[ -n $last ]] && break
  done

  if (( ZTST_failures )); then
    ZTST_verbose 1 "ZTST_test: $ZTST_failures test(s) failed"
  else
    ZTST_verbose 2 "ZTST_test: all tests successful"
  fi

  # reset message to keep ZTST_testfailed output correct
  ZTST_message=''

  return ZTST_failures
}


# Remember which sections we've done.
typeset -A ZTST_sects
ZTST_sects=(prep 0 test 0 clean 0)

print "$ZTST_testname: starting."

# Now go through all the different sections until the end.
# prep section may set ZTST_unimplemented, in this case the actual
# tests will be skipped
ZTST_skipok=
ZTST_unimplemented=
while [[ -z "$ZTST_unimplemented" ]] && ZTST_getsect $ZTST_skipok; do
  case $ZTST_cursect in
    (prep) if (( ${ZTST_sects[prep]} + ${ZTST_sects[test]} + \
	        ${ZTST_sects[clean]} )); then
	    ZTST_testfailed "\`prep' section must come first"
	    break   # skip %test and %clean sections, but run ZTST_cleanup
	  fi
	  ZTST_prep || ZTST_skipok=1
	  ZTST_sects[prep]=1
	  ;;
    (test)
	  if (( ${ZTST_sects[test]} + ${ZTST_sects[clean]} )); then
	    ZTST_testfailed "bad placement of \`test' section"
	    break   # skip %clean section, but run ZTST_cleanup
	  fi
          if [[ -z "$ZTST_skipok" ]]; then  # if no error in %prep
            # careful here: we can't execute ZTST_test before || or &&
            # because that affects the behaviour of traps in the tests.
            ZTST_test
            (( $? )) && ZTST_skipok=1
          fi
	  ZTST_sects[test]=1
	  ;;
    (clean)
	   if (( ${ZTST_sects[test]} == 0 || ${ZTST_sects[clean]} )); then
	     ZTST_testfailed "bad use of \`clean' section"
	   else
	     ZTST_clean
	     ZTST_sects[clean]=1
	   fi
	   ZTST_skipok=
	   ;;
    *) ZTST_testfailed "bad section name: $ZTST_cursect"
       ;;
  esac
done

if [[ -n "$ZTST_unimplemented" ]]; then
  print "$ZTST_testname: skipped ($ZTST_unimplemented)"
  ZTST_testfailed=2
elif (( ! $ZTST_testfailed )); then
  print "$ZTST_testname: all tests successful."
fi
ZTST_cleanup
exit $(( ZTST_testfailed ))

#!/bin/zsh -f
# The line above is just for convenience.  Normally tests will be run using
# a specified version of zsh.  With dynamic loading, any required libraries
# must already have been installed in that case.
#
# Takes one argument: the name of the test file.  Currently only one such
# file will be processed each time ztst.zsh is run.  This is slower, but
# much safer in terms of preserving the correct status.
# To avoid namespace pollution, all functions and parameters used
# only by the script begin with ZTST_.
#
# Options (without arguments) may precede the test file argument; these
# are interpreted as shell options to set.  -x is probably the most useful.

# Produce verbose messages if non-zero.
# If 1, produce reports of tests executed; if 2, also report on progress.
# Defined in such a way that any value from the environment is used.
: ${ZTST_verbose:=0}

# If non-zero, continue the tests even after a test fails.
: ${ZTST_continue:=0}

# We require all options to be reset, not just emulation options.
# Unfortunately, due to the crud which may be in /etc/zshenv this might
# still not be good enough.  Maybe we should trick it somehow.
emulate -R zsh

# By default tests are run in C locale. LANG must be passed to child zsh.
unset -m LC_\*
export LANG=C

# find UTF-8 locale
ZTST_find_UTF8 () {
  setopt multibyte
  local langs=(en_{US,GB}.{UTF-,utf}8 en.UTF-8
               ${(M)$(locale -a 2>/dev/null):#*.(utf8|UTF-8)})
  for LANG in $langs; do
    if [[ é = ? ]]; then
      echo $LANG
      return
    fi
  done
}

# Don't propagate variables that are set by default in the shell.
typeset +x WORDCHARS

# Set the module load path to correspond to this build of zsh.
# This Modules directory should have been created by "make check".
[[ -d Modules/zsh ]] && module_path=( $PWD/Modules )

# We need to be able to save and restore the options used in the test.
# We use the $options variable of the parameter module for this.
zmodload zsh/parameter

# Note that both the following are regular arrays, since we only use them
# in whole array assignments to/from $options.
# Options set in test code (i.e. by default all standard options)
ZTST_testopts=(${(kv)options})

setopt extendedglob nonomatch
while [[ $1 = [-+]* ]]; do
  set $1
  shift
done
# Options set in main script
ZTST_mainopts=(${(kv)options})

# We run in the current directory, so remember it.
ZTST_testdir=$PWD
ZTST_testname=$1

integer ZTST_testfailed=0

# This is POSIX nonsense.  Because of the vague feeling someone, somewhere
# may one day need to examine the arguments of "tail" using a standard
# option parser, every Unix user in the world is expected to switch
# to using "tail -n NUM" instead of "tail -NUM".  Older versions of
# tail don't support this.
tail() {
  emulate -L zsh

  if [[ -z $TAIL_SUPPORTS_MINUS_N ]]; then
    local test
    test=$(echo "foo\nbar" | command tail -n 1 2>/dev/null)
    if [[ $test = bar ]]; then
      TAIL_SUPPORTS_MINUS_N=1
    else
      TAIL_SUPPORTS_MINUS_N=0
    fi
  fi

  integer argi=${argv[(i)-<->]}

  if [[ $argi -le $# && $TAIL_SUPPORTS_MINUS_N = 1 ]]; then
    argv[$argi]=(-n ${argv[$argi][2,-1]})
  fi

  command tail "$argv[@]"
}

# The source directory is not necessarily the current directory,
# but if $0 doesn't contain a `/' assume it is.
if [[ $0 = */* ]]; then
  ZTST_srcdir=${0%/*}
else
  ZTST_srcdir=$PWD
fi
[[ $ZTST_srcdir = /* ]] || ZTST_srcdir="$ZTST_testdir/$ZTST_srcdir"

# Set the function autoload paths to correspond to this build of zsh.
fpath=( $ZTST_srcdir/../Functions/*~*/CVS(/)
        $ZTST_srcdir/../Completion
        $ZTST_srcdir/../Completion/*/*~*/CVS(/) )

: ${TMPPREFIX:=/tmp/zsh}
ZTST_tmp=${TMPPREFIX}.ztst.$$
if ! rm -f $ZTST_tmp || ! mkdir -p $ZTST_tmp || ! chmod go-w $ZTST_tmp; then
  print "Can't create $ZTST_tmp for exclusive use." >&2
  exit 1
fi
# Temporary files for redirection inside tests.
ZTST_in=${ZTST_tmp}/ztst.in
# hold the expected output
ZTST_out=${ZTST_tmp}/ztst.out
ZTST_err=${ZTST_tmp}/ztst.err
# hold the actual output from the test
ZTST_tout=${ZTST_tmp}/ztst.tout
ZTST_terr=${ZTST_tmp}/ztst.terr

ZTST_cleanup() {
  cd $ZTST_testdir
  rm -rf $ZTST_testdir/dummy.tmp $ZTST_testdir/*.tmp(N) ${ZTST_tmp}
}

# This cleanup always gets performed, even if we abort.  Later,
# we should try and arrange that any test-specific cleanup
# always gets called as well.
##trap 'print cleaning up...
##ZTST_cleanup' INT QUIT TERM
# Make sure it's clean now.
rm -rf dummy.tmp *.tmp

# Report failure.  Note that all output regarding the tests goes to stdout.
# That saves an unpleasant mixture of stdout and stderr to sort out.
ZTST_testfailed() {
  print -r "Test $ZTST_testname failed: $1"
  if [[ -n $ZTST_message ]]; then
    print -r "Was testing: $ZTST_message"
  fi
  print -r "$ZTST_testname: test failed."
  if [[ -n $ZTST_failmsg ]]; then
    print -r "The following may (or may not) help identifying the cause:
$ZTST_failmsg"
  fi
  ZTST_testfailed=1
  # if called from within ZTST_Test() this will increment ZTST_Test's local
  # ZTST_failures. Otherwise global ZTST_failures will be incremented
  # (but currently its value is not used).
  (( ++ZTST_failures ))
  return 1
}
ZTST_testxpassed() {
  print -r "Test $ZTST_testname was expected to fail, but passed."
  if [[ -n $ZTST_message ]]; then
    print -r "Was testing: $ZTST_message"
  fi
  print -r "$ZTST_testname: test XPassed."
  if [[ -n $ZTST_failmsg ]]; then
    print -r "The following may (or may not) help identifying the cause:
$ZTST_failmsg"
  fi
  ZTST_testfailed=1
  (( ++ZTST_failures ))
  return 1
}

# Print messages if $ZTST_verbose is non-empty
ZTST_verbose() {
  local lev=$1
  shift
  if [[ -n $ZTST_verbose && $ZTST_verbose -ge $lev ]]; then
    print -r -u $ZTST_fd -- $*
  fi
}
ZTST_hashmark() {
  if [[ ZTST_verbose -le 0 && -t $ZTST_fd ]]; then
    print -n -u$ZTST_fd -- ${(pl:SECONDS::\#::\#\r:)}
  fi
  (( SECONDS > COLUMNS+1 && (SECONDS -= COLUMNS) ))
}

if [[ ! -r $ZTST_testname ]]; then
  ZTST_testfailed "can't read test file."
  exit 1
fi

exec {ZTST_fd}>&1
exec {ZTST_input}<$ZTST_testname

# The current line read from the test file.
ZTST_curline=''
# The current section being run
ZTST_cursect=''

# Get a new input line.  Don't mangle spaces; set IFS locally to empty.
# We shall skip comments at this level.
ZTST_getline() {
  local IFS=
  while true; do
    read -u $ZTST_input -r ZTST_curline || return 1
    [[ $ZTST_curline == \#* ]] || return 0
  done
}

# Get the name of the section.  It may already have been read into
# $curline, or we may have to skip some initial comments to find it.
# If argument present, it's OK to skip the reset of the current section,
# so no error if we find garbage.
ZTST_getsect() {
  local match mbegin mend

  while [[ $ZTST_curline != '%'(#b)([[:alnum:]]##)* ]]; do
    ZTST_getline || return 1
    [[ $ZTST_curline = [[:blank:]]# ]] && continue
    if [[ $# -eq 0 && $ZTST_curline != '%'[[:alnum:]]##* ]]; then
      ZTST_testfailed "bad line found before or after section:
$ZTST_curline"
      exit 1
    fi
  done
  # have the next line ready waiting
  ZTST_getline
  ZTST_cursect=${match[1]}
  ZTST_verbose 2 "ZTST_getsect: read section name: $ZTST_cursect"
  return 0
}

# Read in an indented code chunk for execution
ZTST_getchunk() {
  # Code chunks are always separated by blank lines or the
  # end of a section, so if we already have a piece of code,
  # we keep it.  Currently that shouldn't actually happen.
  ZTST_code=''
  # First find the chunk.
  while [[ $ZTST_curline = [[:blank:]]# ]]; do
    ZTST_getline || break
  done
  while [[ $ZTST_curline = [[:blank:]]##[^[:blank:]]* ]]; do
    ZTST_code="${ZTST_code:+${ZTST_code}
}${ZTST_curline}"
    ZTST_getline || break
  done
  ZTST_verbose 2 "ZTST_getchunk: read code chunk:
$ZTST_code"
  [[ -n $ZTST_code ]]
}

# Read in a piece for redirection.
ZTST_getredir() {
  local char=${ZTST_curline[1]} fn
  ZTST_redir=${ZTST_curline[2,-1]}
  while ZTST_getline; do
    [[ $ZTST_curline[1] = $char ]] || break
    ZTST_redir="${ZTST_redir}
${ZTST_curline[2,-1]}"
  done
  ZTST_verbose 2 "ZTST_getredir: read redir for '$char':
$ZTST_redir"

  case $char in
    ('<') fn=$ZTST_in
    ;;
    ('>') fn=$ZTST_out
    ;;
    ('?') fn=$ZTST_err
    ;;
    (*)  ZTST_testfailed "bad redir operator: $char"
    return 1
    ;;
  esac
  if [[ $ZTST_flags = *q* && $char = '<' ]]; then
    # delay substituting output until variables are set
    print -r -- "${(e)ZTST_redir}" >>$fn
  else
    print -r -- "$ZTST_redir" >>$fn
  fi

  return 0
}

# Execute an indented chunk.  Redirections will already have
# been set up, but we need to handle the options.
ZTST_execchunk() {
  setopt localloops # don't let continue & break propagate out
  options=($ZTST_testopts)
  () {
      unsetopt localloops
      eval "$ZTST_code"
  }
  ZTST_status=$?
  # careful... ksh_arrays may be in effect.
  ZTST_testopts=(${(kv)options[*]})
  options=(${ZTST_mainopts[*]})
  ZTST_verbose 2 "ZTST_execchunk: status $ZTST_status"
  return $ZTST_status
}

# Functions for preparation and cleaning.
ZTST_prep ZTST_clean () {
  # Execute indented code chunks. If ZTST_unimplemented is set
  # in any chunk then we will skip the remaining chunks.
  # We ignore return status of chunks when cleaning up.
  while [[ -z "$ZTST_unimplemented" ]] && ZTST_getchunk; do
    ZTST_execchunk >/dev/null || [[ $0 = ZTST_clean ]] || {
      ZTST_testfailed "non-zero status from preparation code:
$ZTST_code"
      return 1
    }
  done
  return 0
}

# diff wrapper
ZTST_diff() {
  emulate -L zsh
  setopt extendedglob

  local -a diff_arg
  local diff_out
  integer diff_pat diff_ret

  case $1 in
    (p)
    diff_pat=1
    ;;

    (d)
    ;;

    (*)
    print "Bad ZTST_diff code: d for diff, p for pattern match"
    ;;
  esac
  shift
  [[ $OSTYPE != (aix|solaris)* ]] && diff_arg=( -a )
      
  if (( diff_pat )); then
    local -a diff_lines1 diff_lines2
    integer failed i l
    local p

    diff_lines1=("${(f@)$(<$argv[-2])}")
    diff_lines2=("${(f@)$(<$argv[-1])}")
    if (( ${#diff_lines1} != ${#diff_lines2} )); then
      failed=1
      print -r "Pattern match failed, line mismatch (${#diff_lines1}/${#diff_lines2}):"
    else
      for (( i = 1; i <= ${#diff_lines1}; i++ )); do
	if [[ ${diff_lines2[i]} != ${~diff_lines1[i]} ]]; then
	  failed=1
	  print -r "Pattern match failed, line $i:"
	  break
	fi
      done
    fi
    if (( failed )); then
      for (( l = 1; l <= ${#diff_lines1}; ++l )); do
	if (( l == i )); then
	  p="-"
	else
	  p=" "
	fi
	print -r -- "$p<${diff_lines1[l]}"
      done
      for (( l = 1; l <= ${#diff_lines2}; ++l )); do
	if (( l == i )); then
	  p="+"
	else
	  p=" "
	fi
	print -r -- "$p>${diff_lines2[l]}"
      done
      diff_ret=1
    fi
  else
    diff_out=$(diff $diff_arg "$@")
    diff_ret="$?"
    if [[ "$diff_ret" != "0" ]]; then
      print -r -- "$diff_out"
    fi
  fi

  return "$diff_ret"
}

ZTST_test() {
  local last match mbegin mend found substlines
  local diff_out diff_err
  local ZTST_skip
  integer expected_to_fail ZTST_failures

  while true; do
    rm -f $ZTST_in $ZTST_out $ZTST_err
    touch $ZTST_in $ZTST_out $ZTST_err
    ZTST_message=''
    ZTST_failmsg=''
    found=0
    diff_out=d
    diff_err=d

    ZTST_verbose 2 "ZTST_test: looking for new test"

    while true; do
      ZTST_verbose 2 "ZTST_test: examining line:
$ZTST_curline"
      case $ZTST_curline in
	(%*) if [[ $found = 0 ]]; then
	      break 2
	    else
	      last=1
	      break
	    fi
	    ;;
	([[:space:]]#)
	    if [[ $found = 0 ]]; then
	      ZTST_getline || break 2
	      continue
	    else
	      break
	    fi
	    ;;
	([[:space:]]##[^[:space:]]*) ZTST_getchunk
	  if [[ $ZTST_curline == (#b)([-0-9]##)([[:alpha:]]#)(:*)# ]]; then
	    ZTST_xstatus=$match[1]
	    ZTST_flags=$match[2]
	    ZTST_message=${match[3]:+${match[3][2,-1]}}
	  else
	    ZTST_testfailed "expecting test status at:
$ZTST_curline"
	    return 1
	  fi
	  ZTST_getline
	  found=1
	  ;;
	('<'*) ZTST_getredir || return 1
	  found=1
	  ;;
	('*>'*)
	  ZTST_curline=${ZTST_curline[2,-1]}
	  diff_out=p
	  ;&
	('>'*)
	  ZTST_getredir || return 1
	  found=1
	  ;;
	('*?'*)
	  ZTST_curline=${ZTST_curline[2,-1]}
	  diff_err=p
	  ;&
	('?'*)
	  ZTST_getredir || return 1
	  found=1
	  ;;
	('F:'*) ZTST_failmsg="${ZTST_failmsg:+${ZTST_failmsg}
}  ${ZTST_curline[3,-1]}"
	  ZTST_getline
	  found=1
          ;;
	(*) ZTST_testfailed "bad line in test block:
$ZTST_curline"
	  return 1
          ;;
      esac
    done

    # If we found some code to execute...
    if [[ -n $ZTST_code ]]; then
      ZTST_hashmark
      ZTST_verbose 1 "Running test: $ZTST_message"
      ZTST_verbose 2 "ZTST_test: expecting status: $ZTST_xstatus"
      ZTST_verbose 2 "Input: $ZTST_in, output: $ZTST_out, error: $ZTST_terr"

      ZTST_execchunk <$ZTST_in >$ZTST_tout 2>$ZTST_terr

      if [[ -n $ZTST_skip ]]; then
	ZTST_verbose 0 "Test case skipped: $ZTST_skip"
	ZTST_skip=
	if [[ -n $last ]]; then
	  break
	else
	  continue
	fi
      fi

      if [[ $ZTST_flags = *f* ]]; then
        expected_to_fail=1
        ZTST_xfail_diff() { ZTST_diff "$@" > /dev/null }
        ZTST_diff=ZTST_xfail_diff
      else
        expected_to_fail=0
        ZTST_diff=ZTST_diff
      fi

      # First check we got the right status, if specified.
      if [[ $ZTST_xstatus != - && $ZTST_xstatus != $ZTST_status ]]; then
        if (( expected_to_fail )); then
          ZTST_verbose 1 "Test failed, as expected."
          continue
        fi
	ZTST_testfailed "bad status $ZTST_status, expected $ZTST_xstatus from:
$ZTST_code${$(<$ZTST_terr):+
Error output:
$(<$ZTST_terr)}"
        if (( ZTST_continue ));then continue; else return 1; fi
      fi

      ZTST_verbose 2 "ZTST_test: test produced standard output:
$(<$ZTST_tout)
ZTST_test: and standard error:
$(<$ZTST_terr)"

      # Now check output and error.
      if [[ $ZTST_flags = *q* && -s $ZTST_out ]]; then
	substlines="$(<$ZTST_out)"
	rm -rf $ZTST_out
	print -r -- "${(e)substlines}" >$ZTST_out
      fi
      if [[ $ZTST_flags != *d* ]] && ! $ZTST_diff $diff_out -u $ZTST_out $ZTST_tout; then
        if (( expected_to_fail )); then
          ZTST_verbose 1 "Test failed, as expected."
          continue
        fi
	ZTST_testfailed "output differs from expected as shown above for:
$ZTST_code${$(<$ZTST_terr):+
Error output:
$(<$ZTST_terr)}"
        if (( ZTST_continue ));then continue; else return 1; fi
      fi
      if [[ $ZTST_flags = *q* && -s $ZTST_err ]]; then
	substlines="$(<$ZTST_err)"
	rm -rf $ZTST_err
	print -r -- "${(e)substlines}" >$ZTST_err
      fi
      if [[ $ZTST_flags != *D* ]] && ! $ZTST_diff $diff_err -u $ZTST_err $ZTST_terr; then
        if (( expected_to_fail )); then
          ZTST_verbose 1 "Test failed, as expected."
          continue
        fi
	ZTST_testfailed "error output differs from expected as shown above for:
$ZTST_code"
        if (( ZTST_continue ));then continue; else return 1; fi
      fi
      if (( expected_to_fail )); then
        ZTST_testxpassed
        if (( ZTST_continue ));then continue; else return 1; fi
      fi
    fi
    ZTST_verbose 1 "Test successful."
    [[ -n $last ]] && break
  done

  if (( ZTST_failures )); then
    ZTST_verbose 1 "ZTST_test: $ZTST_failures test(s) failed"
  else
    ZTST_verbose 2 "ZTST_test: all tests successful"
  fi

  # reset message to keep ZTST_testfailed output correct
  ZTST_message=''

  return ZTST_failures
}


# Remember which sections we've done.
typeset -A ZTST_sects
ZTST_sects=(prep 0 test 0 clean 0)

print "$ZTST_testname: starting."

# Now go through all the different sections until the end.
# prep section may set ZTST_unimplemented, in this case the actual
# tests will be skipped
ZTST_skipok=
ZTST_unimplemented=
while [[ -z "$ZTST_unimplemented" ]] && ZTST_getsect $ZTST_skipok; do
  case $ZTST_cursect in
    (prep) if (( ${ZTST_sects[prep]} + ${ZTST_sects[test]} + \
	        ${ZTST_sects[clean]} )); then
	    ZTST_testfailed "\`prep' section must come first"
	    break   # skip %test and %clean sections, but run ZTST_cleanup
	  fi
	  ZTST_prep || ZTST_skipok=1
	  ZTST_sects[prep]=1
	  ;;
    (test)
	  if (( ${ZTST_sects[test]} + ${ZTST_sects[clean]} )); then
	    ZTST_testfailed "bad placement of \`test' section"
	    break   # skip %clean section, but run ZTST_cleanup
	  fi
          if [[ -z "$ZTST_skipok" ]]; then  # if no error in %prep
            # careful here: we can't execute ZTST_test before || or &&
            # because that affects the behaviour of traps in the tests.
            ZTST_test
            (( $? )) && ZTST_skipok=1
          fi
	  ZTST_sects[test]=1
	  ;;
    (clean)
	   if (( ${ZTST_sects[test]} == 0 || ${ZTST_sects[clean]} )); then
	     ZTST_testfailed "bad use of \`clean' section"
	   else
	     ZTST_clean
	     ZTST_sects[clean]=1
	   fi
	   ZTST_skipok=
	   ;;
    *) ZTST_testfailed "bad section name: $ZTST_cursect"
       ;;
  esac
done

if [[ -n "$ZTST_unimplemented" ]]; then
  print "$ZTST_testname: skipped ($ZTST_unimplemented)"
  ZTST_testfailed=2
elif (( ! $ZTST_testfailed )); then
  print "$ZTST_testname: all tests successful."
fi
ZTST_cleanup
exit $(( ZTST_testfailed ))