# -*- 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

            (
                .zinit-cd-quiet "$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

            (
                .zinit-cd-quiet "$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]}. Expected one of: git, http, https, ssh, ftp, ftps, rsync."
                    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

    # Authenticate GitHub API requests when a token is available — the anonymous
    # limit of 60 requests/hour/IP is too low for e.g. CI runners. Restricted to
    # api.github.com so the token is never sent to any other host.
    local -a curl_auth wget_auth
    local gh_token=${GITHUB_TOKEN:-$GH_TOKEN}
    if [[ $url == https://api.github.com/* && -n $gh_token ]] {
        curl_auth=( -H "Authorization: Bearer $gh_token" )
        wget_auth=( --header="Authorization: Bearer $gh_token" )
    }

    # 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 --retry 2 --retry-delay 1 "${curl_auth[@]}" --progress-bar -fSL "$url" 2> >(.zinit-single-line >&2) || return 1
            else
                command curl --retry 2 --retry-delay 1 "${curl_auth[@]}" -fsSL "$url" || return 1
            fi
        elif (( ${+commands[wget]} )); then
            command wget --tries=3 "${wget_auth[@]}" ${${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 --retry 2 --retry-delay 1 "${curl_auth[@]}" --progress-bar -fSL "$url" 2> >(.zinit-single-line >&2) || return 1
            else
                command curl --retry 2 --retry-delay 1 "${curl_auth[@]}" -fsSL "$url" || return 1
            fi
        elif type wget 2>/dev/null 1>&2; then
            command wget --tries=3 "${wget_auth[@]}" ${${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
        (
            .zinit-cd-quiet "$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
        ( .zinit-cd-quiet "$directory"
          command svn update
          return $? )
    else
        command svn checkout --non-interactive -q "$url" "$directory"
    fi
    return $?
} # ]]]
# FUNCTION: .zinit-forget-completion [[[
# Implements alternation of Zsh state so that already initialized
# completion stops being visible to Zsh.
#
# $1 - completion function name, e.g. "_cp"; can also be "cp"
.zinit-forget-completion() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt extendedglob typesetsilent warncreateglobal

    local f="$1" quiet="$2"

    typeset -a commands
    commands=( ${(k)_comps[(Re)$f]} )

    [[ "${#commands}" -gt 0 ]] && (( quiet == 0 )) && builtin print -Prn "Forgetting commands completed by \`${ZINIT[col-obj]}$f%f%b': "

    local k
    integer first=1
    for k ( $commands ) {
        unset "_comps[$k]"
        (( quiet )) || builtin print -Prn "${${first:#1}:+, }${ZINIT[col-info]}$k%f%b"
        first=0
    }
    (( quiet || first )) || builtin print

    unfunction -- 2>/dev/null "$f"
} # ]]]
# FUNCTION: .zinit-download-snippet [[[
# Downloads snippet
#   file – with curl, wget, lftp or lynx,
#   directory, with Subversion – when svn-ICE is active.
#
#   Github supports Subversion protocol and allows to clone subdirectories.
#   This is used to provide a layer of support for Oh-My-Zsh and Prezto.
.zinit-download-snippet() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt extendedglob warncreateglobal typesetsilent

    local save_url=$1 url=$2 id_as=$3 local_dir=$4 dirname=$5 filename=$6 update=$7

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

    local -a list arr
    integer retval=0 hook_rc=0
    local teleid_clean=${ICE[teleid]%%\?*}
    [[ $teleid_clean == *://* ]] && \
        local sname=${(M)teleid_clean##*://[^/]##(/[^/]##)(#c0,4)} || \
        local sname=${${teleid_clean:h}:t}/${teleid_clean:t}
    [[ $sname = */trunk* ]] && sname=${${ICE[teleid]%%/trunk*}:t}/${ICE[teleid]:t}
    sname=${sname#./}

    if (( ${+ICE[svn]} )) {
        [[ $url = *(${(~kj.|.)${(Mk)ZINIT_1MAP:#OMZ*}}|robbyrussell*oh-my-zsh|ohmyzsh/ohmyzsh)* ]] && local ZSH=${ZINIT[SNIPPETS_DIR]}
        url=${url/(#s)(#m)(${(~kj.|.)ZINIT_1MAP})/$ZINIT_1MAP[$MATCH]}
    } else {
        url=${url/(#s)(#m)(${(~kj.|.)ZINIT_2MAP})/$ZINIT_2MAP[$MATCH]}
        if [[ $save_url == (${(~kj.|.)${(Mk)ZINIT_1MAP:#OMZ*}})* ]] {
            if [[ $url != *.zsh(|-theme) && $url != */_[^/]## ]] {
                if [[ $save_url == OMZT::* ]] {
                    url+=.zsh-theme
                } else {
                    url+=/${${url#*::}:t}.plugin.zsh
                }
            }
        } elif [[ $save_url = (${(~kj.|.)${(kM)ZINIT_1MAP:#PZT*}})* ]] {
            if [[ $url != *.zsh && $url != */_[^/]## ]] {
                url+=/init.zsh
            }
        }
    }

    # Change the url to point to raw github content if it isn't like that
    if [[ "$url" = *github.com* && ! "$url" = */raw/* && "${+ICE[svn]}" = "0" ]] {
        url="${${url/\/blob\///raw/}/\/tree\///raw/}"
    }

    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 [[ ! -d $local_dir/$dirname ]]; then
        local id_msg_part="{…} (at label{ehi}:{rst} {id-as}$id_as{rst})"
        [[ $update != -u ]] && +zi-log "{nl}{info}Setting up snippet:" \
                                    "{url}$sname{rst}${ICE[id-as]:+$id_msg_part}"
        command mkdir -p "$local_dir"
    fi

    if [[ $update = -u && ${OPTS[opt_-q,--quiet]} != 1 ]]; then
        local id_msg_part="{…} (identified as{ehi}:{rst} {id-as}$id_as{rst})"
        +zi-log "{nl}{info2}Updating snippet: {url}$sname{rst}${ICE[id-as]:+$id_msg_part}"
    fi

    # A flag for the annexes. 0 – no new commits, 1 - run-atpull mode,
    # 2 – full update/there are new commits to download, 3 - full but
    # a forced download (i.e.: the medium doesn't allow to peek update)
    #
    # The below inherits the flag if it's an update call (i.e.: -u given),
    # otherwise it sets it to 2 – a new download is treated like a full
    # update.
    ZINIT[annex-multi-flag:pull-active]=${${${(M)update:#-u}:+${ZINIT[annex-multi-flag:pull-active]}}:-2}

    (
        if [[ $url = (ftp(|s)|http(|s)|scp)://* ]] {
            (
                .zinit-cd-quiet "$local_dir" || return 4

                (( !OPTS[opt_-q,--quiet] )) && +zi-log "{i} Downloading {file}$sname{rst} ${${ICE[svn]+" (with Subversion)"}:-" (with curl, wget, lftp)"}{rst}"

                if (( ${+ICE[svn]} )) {
                    if [[ $update = -u ]] {
                        # Test if update available
                        if ! .zinit-mirror-using-svn "$url" "-t" "$dirname"; then
                            if (( ${+ICE[run-atpull]} || OPTS[opt_-u,--urge] )) {
                                ZINIT[annex-multi-flag:pull-active]=1
                            } else { return 0; } # Will return when no updates so atpull''
                                                 # code below doesn't need any checks.
                                                 # This return 0 statement also sets the
                                                 # pull-active flag outside this subshell.
                        else
                            ZINIT[annex-multi-flag:pull-active]=2
                        fi

                        # Run annexes' atpull hooks (the before atpull-ice ones).
                        # The SVN block.
                        reply=(
                            ${(on)ZINIT_EXTS2[(I)zinit hook:e-\!atpull-pre <->]}
                            ${${(M)ICE[atpull]#\!}:+${(on)ZINIT_EXTS[(I)z-annex hook:\!atpull-<-> <->]}}
                            ${(on)ZINIT_EXTS2[(I)zinit hook:e-\!atpull-post <->]}
                        )
                        for key in "${reply[@]}"; do
                            arr=( "${(Q)${(z@)ZINIT_EXTS[$key]:-$ZINIT_EXTS2[$key]}[@]}" )
                            "${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" "${${key##(zinit|z-annex) hook:}%% <->}" update:svn
                            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

                        if (( ZINIT[annex-multi-flag:pull-active] == 2 )) {
                            # Do the update
                            # The condition is reversed on purpose – to show only
                            # the messages on an actual update
                            if (( OPTS[opt_-q,--quiet] )); then
                                local id_msg_part="{…} (identified as{ehi}: {id-as}$id_as{rst})"
                                +zi-log "{nl}{info2}Updating snippet {url}${sname}{rst}${ICE[id-as]:+$id_msg_part}"
                                +zi-log "Downloading {apo}\`{rst}$sname{apo}\`{rst} (with Subversion){…}"
                            fi
                            .zinit-mirror-using-svn "$url" "-u" "$dirname" || return 4
                        }
                    } else {
                        .zinit-mirror-using-svn "$url" "" "$dirname" || return 4
                    }

                    # Redundant code, just to compile SVN snippet
                    if [[ ${ICE[as]} != command ]]; then
                        if [[ -n ${ICE[pick]} ]]; then
                            list=( ${(M)~ICE[pick]##/*}(DN) $local_dir/$dirname/${~ICE[pick]}(DN) )
                        elif [[ -z ${ICE[pick]} ]]; then
                            list=(
                                $local_dir/$dirname/*.plugin.zsh(DN) $local_dir/$dirname/*.zsh-theme(DN) $local_dir/$dirname/init.zsh(DN)
                                $local_dir/$dirname/*.zsh(DN) $local_dir/$dirname/*.sh(DN) $local_dir/$dirname/.zshrc(DN)
                            )
                        fi

                        if [[ -e ${list[1]} && ${list[1]} != */dev/null && \
                            -z ${ICE[(i)(\!|)(sh|bash|ksh|csh)]} && \
                            ${+ICE[nocompile]} -eq 0
                        ]] {
                            () {
                                builtin emulate -LR zsh -o extendedglob ${=${options[xtrace]:#off}:+-o xtrace}
                                zcompile -U "${list[1]}" &>/dev/null || \
                                    +zi-log "{u-warn}Warning{b-warn}:{rst} couldn't compile {apo}\`{file}${list[1]}{apo}\`{rst}."
                            }
                        }
                    fi

                    return $ZINIT[annex-multi-flag:pull-active]
                } else {
                    command mkdir -p "$local_dir/$dirname"

                    if (( !OPTS[opt_-f,--force] )) {
                        .zinit-get-url-mtime "$url"
                    } else {
                        REPLY=$EPOCHSECONDS
                    }

                    # Returned is: modification time of the remote file.
                    # Thus, EPOCHSECONDS - REPLY is: allowed window for the
                    # local file to be modified in. ms-$secs is: files accessed
                    # within last $secs seconds. Thus, if there's no match, the
                    # local file is out of date.

                    local secs=$(( EPOCHSECONDS - REPLY ))
                    # Guard so that it's positive
                    (( $secs >= 0 )) || secs=0
                    integer skip_dl
                    local -a matched
                    matched=( $local_dir/$dirname/$filename(DNms-$secs) )
                    if (( ${#matched} )) {
                        +zi-log "{info}Already up to date.{rst}"
                        # Empty-update return-short path – it also decides the
                        # pull-active flag after the return from this sub-shell
                        (( ${+ICE[run-atpull]} || OPTS[opt_-u,--urge] )) && skip_dl=1 || return 0
                    }

                    if [[ ! -f $local_dir/$dirname/$filename ]] {
                        ZINIT[annex-multi-flag:pull-active]=2
                    } else {
                        # secs > 1 → the file is outdated, then:
                        #   - if true, then the mode is 2 minus run-atpull-activation,
                        #   - if false, then mode is 3 → a forced download (no remote mtime found).
                        ZINIT[annex-multi-flag:pull-active]=$(( secs > 1 ? (2 - skip_dl) : 3 ))
                    }

                    # Run annexes' atpull hooks (the before atpull-ice ones).
                    # The URL-snippet block.
                    if [[ $update = -u && $ZINIT[annex-multi-flag:pull-active] -ge 1 ]] {
                        reply=(
                            ${(on)ZINIT_EXTS2[(I)zinit hook:e-\!atpull-pre <->]}
                            ${${ICE[atpull]#\!}:+${(on)ZINIT_EXTS[(I)z-annex hook:\!atpull-<-> <->]}}
                            ${(on)ZINIT_EXTS2[(I)zinit hook:e-\!atpull-post <->]}
                        )
                        for key in "${reply[@]}"; do
                            arr=( "${(Q)${(z@)ZINIT_EXTS[$key]:-$ZINIT_EXTS2[$key]}[@]}" )
                            "${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" "${${key##(zinit|z-annex) hook:}%% <->}" update:url
                            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
                    }

                    if (( !skip_dl )) {
                        if { ! .zinit-download-file-stdout "$url" 0 1 >! "$dirname/$filename" } {
                            if { ! .zinit-download-file-stdout "$url" 1 1 >! "$dirname/$filename" } {
                                command rm -f "$dirname/$filename"
                                +zi-log "{u-warn}ERROR{b-warn}:{rst} Download failed."
                                return 4
                            }
                        }
                    }
                    return $ZINIT[annex-multi-flag:pull-active]
                }
            )
            retval=$?

            # Overestimate the pull-level to 2 also in error situations
            # – no hooks will be run anyway because of the error
            ZINIT[annex-multi-flag:pull-active]=$retval

            if [[ $ICE[as] != command && ${+ICE[svn]} -eq 0 ]] {
                local file_path=$local_dir/$dirname/$filename
                if [[ -n ${ICE[pick]} ]]; then
                    list=( ${(M)~ICE[pick]##/*}(DN) $local_dir/$dirname/${~ICE[pick]}(DN) )
                    file_path=${list[1]}
                fi
                if [[ -e $file_path && -z ${ICE[(i)(\!|)(sh|bash|ksh|csh)]} && \
                        $file_path != */dev/null && ${+ICE[nocompile]} -eq 0
                ]] {
                    () {
                        builtin emulate -LR zsh -o extendedglob ${=${options[xtrace]:#off}:+-o xtrace}
                        if ! zcompile -U "$file_path" 2>/dev/null; then
                            builtin print -r "Couldn't compile \`${file_path:t}', it MIGHT be wrongly downloaded"
                            builtin print -r "(snippet URL points to a directory instead of a file?"
                            builtin print -r "to download directory, use preceding: zinit ice svn)."
                            retval=4
                        fi
                    }
                }
            }
        } else { # Local-file snippet branch
            # Local files are (yet…) forcefully copied.
            ZINIT[annex-multi-flag:pull-active]=3 retval=3
            # Run annexes' atpull hooks (the before atpull-ice ones).
            # The local-file snippets block.
            if [[ $update = -u ]] {
                reply=(
                    ${(on)ZINIT_EXTS2[(I)zinit hook:e-\!atpull-pre <->]}
                    ${${(M)ICE[atpull]#\!}:+${(on)ZINIT_EXTS[(I)z-annex hook:\!atpull-<-> <->]}}
                    ${(on)ZINIT_EXTS2[(I)zinit hook:e-\!atpull-post <->]}
                )
                for key in "${reply[@]}"; do
                    arr=( "${(Q)${(z@)ZINIT_EXTS[$key]:-$ZINIT_EXTS2[$key]}[@]}" )
                    "${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" "${${key##(zinit|z-annex) hook:}%% <->}" update:file
                    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
            }

            command mkdir -p "$local_dir/$dirname"
            if [[ ! -e $url ]] {
                (( !OPTS[opt_-q,--quiet] )) && +zi-log "{ehi}ERROR:{error} The source file {file}$url{error} doesn't exist.{rst}"
                retval=4
            }
            if [[ -e $url && ! -f $url && $url != /dev/null ]] {
                (( !OPTS[opt_-q,--quiet] )) && +zi-log "{ehi}ERROR:{error} The source {file}$url{error} isn't a regular file.{rst}"
                retval=4
            }
            if [[ -e $url && ! -r $url && $url != /dev/null ]] {
                (( !OPTS[opt_-q,--quiet] )) && +zi-log "{ehi}ERROR:{error} The source {file}$url{error} isn't" \
                    "accessible (wrong permissions).{rst}"
                retval=4
            }
            if ! (( ${+ICE[link]} )) {
                if (( !OPTS[opt_-q,--quiet] )) && [[ $url != /dev/null ]] {
                    +zi-log "{msg}Copying {file}$filename{msg}{…}{rst}"
                    command cp -vf "$url" "$local_dir/$dirname/$filename" || \
                        { +zi-log "{ehi}ERROR:{error} The file copying has been unsuccessful.{rst}"; retval=4; }
                } else {
                    command cp -f "$url" "$local_dir/$dirname/$filename" &>/dev/null || \
                        { +zi-log "{ehi}ERROR:{error} The copying of {file}$filename{error} has been unsuccessful"\
    "${${(M)OPTS[opt_-q,--quiet]:#1}:+, skip the -q/--quiet option for more information}.{rst}"; retval=4; }
                }
            } else {
                if (( $+commands[realpath] )) {
                    local rpv="$(realpath --version | head -n1 | sed -E 's/realpath (\(.*\))?//g')"
                    if is-at-least 8.23 $rpv; then
                        rel_url="$(realpath --relative-to="$local_dir/$dirname" "$url")" && \
                            { url="$rel_url" }
                    fi
                }
                if (( !OPTS[opt_-q,--quiet] )) && [[ $url != /dev/null ]] {
                    +zi-log "{msg}Linking {file}$filename{msg}{…}{rst}"
                    command ln -svf "$url" "$local_dir/$dirname/$filename" || \
                        { +zi-log "{ehi}ERROR:{error} The file linking has been unsuccessful.{rst}"; retval=4; }
                } else {
                    command ln -sf "$url" "$local_dir/$dirname/$filename" &>/dev/null || \
                        { +zi-log "{ehi}ERROR:{error} The link of {file}$filename{error} has been unsuccessful"\
    "${${(M)OPTS[opt_-q,--quiet]:#1}:+, skip the -q/--quiet option for more information}.{rst}"; retval=4; }
                }
            }
        }

        (( retval == 4 )) && { command rmdir "$local_dir/$dirname" 2>/dev/null; return $retval; }

        if [[ ${${:-$local_dir/$dirname}%%/##} != ${ZINIT[SNIPPETS_DIR]} ]] {
            # Store ices at "clone" and update of snippet, SVN and single-file
            local pfx=$local_dir/$dirname/._zinit
            .zinit-store-ices "$pfx" ICE url_rsvd "" "$save_url" "${+ICE[svn]}"
        } elif [[ -n $id_as ]] {
            +zi-log "{u-warn}Warning{b-warn}:{rst} the snippet {url}$id_as{rst} isn't" \
                "fully downloaded – you should remove it with {apo}\`{cmd}zinit delete $id_as{apo}\`{rst}."
        }

        # Empty update short-path
        if (( ZINIT[annex-multi-flag:pull-active] == 0 )) {
            # Run annexes' atpull hooks (the `always' after atpull-ice ones)
            reply=(
                ${(on)ZINIT_EXTS2[(I)zinit hook:%atpull-pre <->]}
                ${(on)ZINIT_EXTS[(I)z-annex hook:%atpull-<-> <->]}
                ${(on)ZINIT_EXTS2[(I)zinit hook:%atpull-post <->]}
            )
            for key in "${reply[@]}"; do
                arr=( "${(Q)${(z@)ZINIT_EXTS[$key]:-$ZINIT_EXTS2[$key]}[@]}" )
                "${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" "${${key##(zinit|z-annex) hook:}%% <->}" update:0
                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;
        }

        if [[ $update = -u ]] {
            # Run annexes' atpull hooks (the before atpull-ice ones).
            # The block is common to all 3 snippet types.
            reply=(
                ${(on)ZINIT_EXTS2[(I)zinit hook:no-e-\!atpull-pre <->]}
                ${${ICE[atpull]:#\!*}:+${(on)ZINIT_EXTS[(I)z-annex hook:\!atpull-<-> <->]}}
                ${(on)ZINIT_EXTS2[(I)zinit hook:no-e-\!atpull-post <->]}
            )
            for key in "${reply[@]}"; do
                arr=( "${(Q)${(z@)ZINIT_EXTS[$key]:-$ZINIT_EXTS2[$key]}[@]}" )
                "${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" "${${key##(zinit|z-annex) hook:}%% <->}" update
                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
        } else {
            # Run annexes' atclone hooks (the before atclone-ice ones)
            # The block is common to all 3 snippet types.
            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]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" "${${key##(zinit|z-annex) hook:}%% <->}" load
            done

            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]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" "${${key##(zinit|z-annex) hook:}%% <->}" load
            done
        }

        # Run annexes' atpull hooks (the after atpull-ice ones)
        # The block is common to all 3 snippet types.
        if [[ $update = -u ]] {
            if (( ZINIT[annex-multi-flag:pull-active] > 0 )) {
                reply=(
                    ${(on)ZINIT_EXTS2[(I)zinit hook:atpull-pre <->]}
                    ${(on)ZINIT_EXTS[(I)z-annex hook:atpull-<-> <->]}
                    ${(on)ZINIT_EXTS2[(I)zinit hook:atpull-post <->]}
                )
                for key in "${reply[@]}"; do
                    arr=( "${(Q)${(z@)ZINIT_EXTS[$key]:-$ZINIT_EXTS2[$key]}[@]}" )
                    "${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" "${${key##(zinit|z-annex) hook:}%% <->}" update
                    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
            }

            # Run annexes' atpull hooks (the `always' after atpull-ice ones)
            # The block is common to all 3 snippet types.
            reply=(
                ${(on)ZINIT_EXTS2[(I)zinit hook:%atpull-pre <->]}
                ${(on)ZINIT_EXTS[(I)z-annex hook:%atpull-<-> <->]}
                ${(on)ZINIT_EXTS2[(I)zinit hook:%atpull-post <->]}
            )
            for key in "${reply[@]}"; do
                arr=( "${(Q)${(z@)ZINIT_EXTS[$key]:-$ZINIT_EXTS2[$key]}[@]}" )
                "${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" "${${key##(zinit|z-annex) hook:}%% <->}" update:$ZINIT[annex-multi-flag:pull-active]
                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 $?

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

    # After additional executions like atclone'' - install completions (2 - snippets)
    local -A OPTS
    OPTS[opt_-q,--quiet]=1
    [[ (0 = ${+ICE[nocompletions]} && ${ICE[as]} != null && ${+ICE[null]} -eq 0) || 0 != ${+ICE[completions]} ]] && \
        .zinit-install-completions "%" "$local_dir/$dirname" 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 $retval
} # ]]]
# FUNCTION: .zinit-update-snippet [[[
.zinit-update-snippet() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt extendedglob warncreateglobal typesetsilent noshortloops rcquotes

    local -a tmp opts
    local url=$1
    integer correct=0
    [[ -o ksharrays ]] && correct=1
    opts=( -u ) # for zinit-annex-readurl

    # Create a local copy of OPTS, basically
    # for zinit-annex-readurl annex
    local -A ice_opts
    ice_opts=( "${(kv)OPTS[@]}" )
    local -A OPTS
    OPTS=( "${(kv)ice_opts[@]}" )

    ZINIT[annex-multi-flag:pull-active]=0 ZINIT[-r/--reset-opt-hook-has-been-run]=0

    # Remove leading whitespace and trailing /
    url=${${url#${url%%[! $'\t']*}}%/}
    ICE[teleid]=${ICE[teleid]:-$url}
    [[ ${ICE[as]} = null || ${+ICE[null]} -eq 1 || ${+ICE[binary]} -eq 1 ]] && \
        ICE[pick]=${ICE[pick]:-/dev/null}

    local local_dir dirname filename save_url=$url \
        id_as=${ICE[id-as]:-$url}

    .zinit-pack-ice "$id_as" ""

    # Allow things like $OSTYPE in the URL
    eval "url=\"$url\""

    # - case A: called from `update --all', ICE empty, static ice will win
    # - case B: called from `update', ICE packed, so it will win
    tmp=( "${(Q@)${(z@)ZINIT_SICE[$id_as]}}" )
    if (( ${#tmp} > 1 && ${#tmp} % 2 == 0 )) {
        ICE=( "${(kv)ICE[@]}" "${tmp[@]}" )
    } elif [[ -n ${ZINIT_SICE[$id_as]} ]] {
        +zi-log "{error}WARNING:{msg2} Inconsistency #3" \
            "occurred, please report the string: \`{obj}${ZINIT_SICE[$id_as]}{msg2}' to the" \
            "GitHub issues page: {obj}https://github.com/zdharma-continuum/zinit/issues/{msg2}.{rst}"
    }
    id_as=${ICE[id-as]:-$id_as}

    # Oh-My-Zsh, Prezto and manual shorthands
    if (( ${+ICE[svn]} )) {
        [[ $url = *(${(~kj.|.)${(Mk)ZINIT_1MAP:#OMZ*}}|robbyrussell*oh-my-zsh|ohmyzsh/ohmyzsh)* ]] && local ZSH=${ZINIT[SNIPPETS_DIR]}
        url=${url/(#s)(#m)(${(~kj.|.)ZINIT_1MAP})/$ZINIT_1MAP[$MATCH]}
    } else {
        url=${url/(#s)(#m)(${(~kj.|.)ZINIT_2MAP})/$ZINIT_2MAP[$MATCH]}
        if [[ $save_url == (${(~kj.|.)${(Mk)ZINIT_1MAP:#OMZ*}})* ]] {
            if [[ $url != *.zsh(|-theme) && $url != */_[^/]## ]] {
                if [[ $save_url == OMZT::* ]] {
                    url+=.zsh-theme
                } else {
                    url+=/${${url#*::}:t}.plugin.zsh
                }
            }
        } elif [[ $save_url = (${(~kj.|.)${(kM)ZINIT_1MAP:#PZT*}})* ]] {
            if [[ $url != *.zsh ]] {
                url+=/init.zsh
            }
        }
    }

    if { ! .zinit-get-object-path snippet "$id_as" } {
        +zi-log "{msg2}Error: the snippet \`{obj}$id_as{msg2}'" \
                "doesn't exist, aborting the update.{rst}"
            return 1
    }
    filename=$reply[-2] dirname=$reply[-2] local_dir=$reply[-3]

    local -a arr
    local key
    reply=(
        ${(on)ZINIT_EXTS2[(I)zinit hook:preinit-pre <->]}
        ${(on)ZINIT_EXTS[(I)z-annex hook:preinit-<-> <->]}
        ${(on)ZINIT_EXTS2[(I)zinit hook:preinit-post <->]}
    )
    for key in "${reply[@]}"; do
        arr=( "${(Q)${(z@)ZINIT_EXTS[$key]:-$ZINIT_EXTS2[$key]}[@]}" )
        "${arr[5]}" snippet "$save_url" "$id_as" "$local_dir/$dirname" ${${key##(zinit|z-annex) hook:}%% <->} update || \
            return $(( 10 - $? ))
    done

    # Download or copy the file
    [[ $url = *github.com* && $url != */raw/* ]] && url=${url/\/(blob|tree)\///raw/}
    .zinit-download-snippet "$save_url" "$url" "$id_as" "$local_dir" "$dirname" "$filename" "-u"

    return $?
} # ]]]
# FUNCTION: .zinit-single-line [[[
# Display cURL progress bar on a single line
.zinit-single-line() {
    emulate -LR zsh
    setopt extendedglob noshortloops nowarncreateglobal rcquotes typesetsilent
    local IFS= n=$'\n' r=$'\r' zero=$'\0'

    {
      command perl -pe 'BEGIN { $|++; $/ = \1 }; tr/\r\n/\n\0/' \
        || gstdbuf -o0 gtr '\r\n' '\n\0' \
        || stdbuf -o0 tr '\r\n' '\n\0';
      print
    } 2>/dev/null | while read -r line;

    do
      if [[ $line == *$zero* ]]; then
        # cURL doesn't add a newline to progress bars
        # print -nr -- "${r}${(l:COLUMNS:: :):-}${r}${line##*${zero}}"
        print -nr -- "${r}${(l:COLUMNS:: :):-}${r}${line%${zero}}"
      else
        print -nr -- "${r}${(l:COLUMNS:: :):-}${r}${${line//[${r}${n}]/}%\%*}${${(M)line%\%}:+%}"
      fi
    done

    print
} # ]]]
# FUNCTION: .zi::get-architecture [[[
.zi::get-architecture () {
  emulate -L zsh
  setopt extendedglob noshortloops nowarncreateglobal rcquotes
  local _clib="gnu" _cpu="$(uname -m)" _os="$(uname -s)" _sys=""
  case "$_os" in
    (Darwin)
      _sys='(apple|darwin|apple-darwin|dmg|mac((-|)os|)|os(-|64|)x)'
      arch -x86_64 /usr/bin/true 2> /dev/null
      if [[ $? -eq 0 ]] && [[ $_cpu != "arm64" ]]; then
        _os=$_sys*~*((aarch|arm)64)
      fi
      ;;
    (Linux)
      _sys='(musl|gnu)*~^*(unknown|)linux*'
      ;;
    (MINGW* | MSYS* | CYGWIN* | Windows_NT)
      _sys='pc-windows-gnu'
      ;;
    (*)
      +zi-log "{e} {b}gh-r{rst}Unsupported OS: {obj}$_os{rst}"
      ;;
  esac
  case "$_cpu" in
    (aarch64 | arm64)
      _cpu='(arm|aarch)64'
      ;;
    (amd64 | i386 | i486 | i686| i786 | x64 | x86 | x86-64 | x86_64)
      _cpu='(amd64|x86_64|x64)'
      ;;
    (armv6l)
      _os=${_os}eabihf
      ;;
    (armv7l | armv8l)
      _os=${_os}eabihf
      ;;
    (*)
      +zi-log "{e} {b}gh-r{rst}Unsupported CPU: {obj}$_cpu{rst}"
      ;;
  esac
  echo "${_sys};${_cpu};${_os}"
} # ]]]
# FUNCTION: .zinit-get-latest-gh-r-url-part [[[
# Gets version string of latest release of given Github
# package. Connects to Github releases page.
.zinit-get-latest-gh-r-url-part () {
  builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
  setopt extendedglob nowarncreateglobal typesetsilent noshortloops
  REPLY=
  local plugin="$2" urlpart="$3" user="$1"
  local -a bpicks filtered init_list list parts
  parts=(${(@s:;:)$(.zi::get-architecture)})
  if [[ -z $urlpart ]]; then
    local tag_version=${ICE[ver]}
    if [[ -z $tag_version ]]; then
      # Try GitHub API first, fallback to HTML parsing
      local api_url=https://api.github.com/repos/$user/$plugin/releases/latest
      tag_version="$( { .zinit-download-file-stdout $api_url || .zinit-download-file-stdout $api_url 1; } 2>/dev/null | command grep -o '"tag_name"[[:space:]]*:[[:space:]]*"[^"]\+"' | command grep -o '"[^"]*"$' | tr -d '"' )"
      # Fallback to original method if API fails
      if [[ -z $tag_version ]]; then
        local releases_url=https://github.com/$user/$plugin/releases/latest
        tag_version="$( { .zinit-download-file-stdout $releases_url || .zinit-download-file-stdout $releases_url 1; } 2>/dev/null | command grep -m1 -o 'href=./'$user'/'$plugin'/releases/tag/[^"]\+' )"
      fi
      tag_version=${tag_version##*/}
    fi
    local url=https://github.com/$user/$plugin/releases/expanded_assets/$tag_version
  else
    local url=https://$urlpart
  fi
  if [[ "${ICE[bpick]}" == "src" ]]; then
    +zi-log "{dbg} {b}gh-r{rst}: bpick\"src\" detected, targeting source code tarball for tag: {version}$tag_version{rst}"
    # Construct the URL path for the auto-generated source code archive
    reply=( "/$user/$plugin/archive/refs/tags/$tag_version.tar.gz" )
    # Ensure the reply isn't empty if tag_version was somehow missed
    [[ -n "$tag_version" ]] && return 0
    +zi-log "{e} {b}gh-r{rst}: Could not determine tag version, cannot use bpick\"src\"."
    return 1
  fi
  init_list=( ${(@f)"$( { .zinit-download-file-stdout $url || .zinit-download-file-stdout $url 1; } 2>/dev/null | command grep -i -o 'href=./'$user'/'$plugin'/releases/download/[^"]\+')"} )
  init_list=(${(L)init_list[@]#href=?})
  bpicks=(${(s.;.)ICE[bpick]})
  [[ -z $bpicks ]] && bpicks=("")
  local bpick bpick_error=""
  reply=()
  for bpick in "${bpicks[@]}"; do
    list=($init_list)
    if [[ -n $bpick ]]; then
      list=( ${(M)list[@]:#(#i)*/$~bpick} )
      if (( !$#list )); then
        +zi-log "{e} {b}gh-r{rst}: {ice}bpick{rst} ice found no release assets To fix, modify the {ice}bpick{rst} glob pattern {glob}$bpick{rst}"
      fi
    else
      local junk='*((s(ha256|ig|um)|386|asc|md5|txt|vsix)*|(apk|b3|deb|json|pkg|rpm|sh)(#e))|*.pkg.tar.zst|(*.zst~*.tar.zst)';
      # print -l ${${(m@)list:#${~junk}}:t}
      filtered=( ${(m@)list:#(#i)${~junk}} ) && (( $#filtered > 0 )) && list=( ${filtered[@]} )
    fi

    local -a array=( $(print -rm "*(${MACHTYPE}|${VENDOR}|)*~^*(${parts[1]}|${(L)$(uname)})*" $list[@]) )
    (( ${#array} > 0 )) && list=( ${array[@]} )

    for part in "${parts[@]}"; do
      if (( $#list > 1 )); then
        filtered=( ${(M)list[@]:#(#i)*${~part}*} ) && (( $#filtered > 0 )) && list=( ${filtered[@]} )
      else
        break
      fi
    done

    if (( $#list > 1 )) { filtered=( ${list[@]:#(#i)*.(sha[[:digit:]]#|asc)} ) && (( $#filtered > 0 )) && list=( ${filtered[@]} ); }

    if (( !$#list )); then
      +zi-log "{e} {b}gh-r{rst}: No GitHub release assets found for {glob}$tag_version{rst}"
      return 1
    fi
    reply+=( "${list[1]}" )
  done
  [[ -n $reply ]]
} # ]]]
# FUNCTION: ziextract [[[
# If the file is an archive, it is extracted by this function.
# Executable permissions are determined solely by the execute bit already
# stored in the archive — i.e. whatever the package author intended.
# No heuristics (file(1), shebang scanning, etc.) are applied.
#
# $1 - url
# $2 - file
ziextract() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt extendedglob typesetsilent noshortloops # warncreateglobal

    local -aU opt_move opt_move2 opt_norm opt_auto opt_nobkp
    zparseopts -D -E -move=opt_move -move2=opt_move2 -norm=opt_norm \
            -auto=opt_auto -nobkp=opt_nobkp || \
        { +zi-log "{info}[{pre}ziextract{info}]{error} Incorrect options given to" \
                  "\`{pre}ziextract{msg2}' (available are: {meta}--auto{msg2}," \
                  "{meta}--move{msg2}, {meta}--move2{msg2}, {meta}--norm{msg2}," \
                  "{meta}--nobkp{msg2}).{rst}"; return 1; }

    local file="$1" ext="$2"
    integer move=${${${(M)${#opt_move}:#0}:+0}:-1} \
            move2=${${${(M)${#opt_move2}:#0}:+0}:-1} \
            norm=${${${(M)${#opt_norm}:#0}:+0}:-1} \
            auto=${${${(M)${#opt_auto}:#0}:+0}:-1} \
            nobkp=${${${(M)${#opt_nobkp}:#0}:+0}:-1}

    if (( auto )) {
        # First try known file extensions
        local -aU files
        integer ret_val
        files=( (#i)**/*.(zip|rar|7z|tgz|tbz|tbz2|tar.gz|tar.bz2|tar.7z|txz|tar.xz|tar.zst|gz|xz|tar|dmg|exe)~(*/*|.(_backup|git))/*(-.DN) )
        for file ( $files ) {
            ziextract "$file" $opt_move $opt_move2 $opt_norm $opt_nobkp ${${${#files}:#1}:+--nobkp}
            ret_val+=$?
        }
        # Second, try to find the archive via `file' tool
        if (( !${#files} )) {
            local -aU output infiles stage2_processed archives
            infiles=( **/*~(._zinit*|._backup|.git)(|/*)~*/*/*(-.DN) )
            output=( ${(@f)"$(command file -- $infiles 2>&1)"} )
            archives=( ${(M)output[@]:#(#i)(* |(#s))(zip|rar|xz|7-zip|gzip|bzip2|tar|exe|PE32) *} )
            for file ( $archives ) {
                local fname=${(M)file#(${(~j:|:)infiles}): } desc=${file#(${(~j:|:)infiles}): } type
                fname=${fname%%??}
                [[ -z $fname || -n ${stage2_processed[(r)$fname]} ]] && continue
                type=${(L)desc/(#b)(#i)(* |(#s))(zip|rar|xz|7-zip|gzip|bzip2|tar|exe|PE32) */$match[2]}
                if [[ $type = (zip|rar|xz|7-zip|gzip|bzip2|tar|exe|pe32) ]] {
                    (( !OPTS[opt_-q,--quiet] )) && \
                        +zi-log "{info}[{pre}ziextract{info}]{msg2} detected a {meta}$type{rst} archive in the file {file}$fname{rst}."
                    ziextract "$fname" "$type" $opt_move $opt_move2 $opt_norm --norm ${${${#archives}:#1}:+--nobkp}
                    integer iret_val=$?
                    ret_val+=iret_val

                    (( iret_val )) && continue

                    # Support nested tar.(bz2|gz|…) archives
                    local infname=$fname
                    [[ -f $fname.out ]] && fname=$fname.out
                    files=( *.tar(ND) )
                    if [[ -f $fname || -f ${fname:r} ]] {
                        local -aU output2 archives2
                        output2=( ${(@f)"$(command file -- "$fname"(N) "${fname:r}"(N) $files[1](N) 2>&1)"} )
                        archives2=( ${(M)output2[@]:#(#i)(* |(#s))(zip|rar|xz|7-zip|gzip|bzip2|tar|exe|PE32) *} )
                        local file2
                        for file2 ( $archives2 ) {
                            fname=${file2%:*} desc=${file2##*:}
                            local type2=${(L)desc/(#b)(#i)(* |(#s))(zip|rar|xz|7-zip|gzip|bzip2|tar|exe|PE32) */$match[2]}
                            if [[ $type != $type2 && \
                                $type2 = (zip|rar|xz|7-zip|gzip|bzip2|tar)
                            ]] {
                                # TODO: if multiple archives are really in the archive,
                                # this might delete too soon… However, it's unusual case.
                                [[ $fname != $infname && $norm -eq 0 ]] && command rm -f "$infname"
                                (( !OPTS[opt_-q,--quiet] )) && \
                                    +zi-log "{info}[{pre}ziextract{info}]{msg2} detected a {obj}${type2}{rst} archive in the file {file}${fname}{rst}."
                                ziextract "$fname" "$type2" $opt_move $opt_move2 $opt_norm ${${${#archives}:#1}:+--nobkp}
                                ret_val+=$?
                                stage2_processed+=( $fname )
                                if [[ $fname == *.out ]] {
                                    [[ -f $fname ]] && command mv -f "$fname" "${fname%.out}"
                                    stage2_processed+=( ${fname%.out} )
                                }
                            }
                        }
                    }
                }
            }
        }
        return $ret_val
    }

    if [[ -z $file ]] {
        +zi-log "{info}[{pre}ziextract{info}]{error} argument needed (the file to extract) or the {meta}--auto{msg} option."
        return 1
    }
    if [[ ! -e $file ]] {
        +zi-log "{info}[{pre}ziextract{info}]{error} ERROR:{msg} the file \`{meta}${file}{msg}' doesn't exist.{rst}"
        return 1
    }
    if (( !nobkp )) {
        command mkdir -p ._backup
        command rm -rf ._backup/*(DN)
        command mv -f *~(._zinit*|._backup|.git|.svn|.hg|$file)(DN) ._backup 2>/dev/null
    }

    .zinit-extract-wrapper() {
        local file="$1" fun="$2" retval
        (( !OPTS[opt_-q,--quiet] )) && \
            +zi-log "{info}[{pre}ziextract{info}]{rst} Unpacking the files from: \`{obj}$file{msg}'{…}{rst}"
        $fun; retval=$?
        if (( retval == 0 )) {
            local -a files
            files=( *~(._zinit*|._backup|.git|.svn|.hg|$file)(DN) )
            (( ${#files} && !norm )) && command rm -f "$file"
        }
        return $retval
    }

    →zinit-check() { (( ${+commands[$1]} )) || \
        +zi-log "{info}[{pre}ziextract{info}]{error} Error:{msg} No command {data}$1{msg}, it is required to unpack {file}$2{rst}."
    }

    case "${${ext:+.$ext}:-$file}" in
        ((#i)*.zip)
            →zinit-extract() { →zinit-check unzip "$file" || return 1; command unzip -qq -o "$file"; }
            ;;
        ((#i)*.rar)
            →zinit-extract() { →zinit-check unrar "$file" || return 1; command unrar x "$file"; }
            ;;
        ((#i)*.tar.bz2|(#i)*.tbz|(#i)*.tbz2)
            →zinit-extract() { →zinit-check bzip2 "$file" || return 1; command bzip2 -dc "$file" | command tar --no-same-owner -xf -; }
            ;;
        ((#i)*.tar.gz|(#i)*.tgz)
            →zinit-extract() { →zinit-check gzip "$file" || return 1; command gzip -dc "$file" | command tar --no-same-owner -xf -; }
            ;;
        ((#i)*.tar.xz|(#i)*.txz)
            →zinit-extract() { →zinit-check xz "$file" || return 1; command xz -dc "$file" | command tar --no-same-owner -xf -; }
            ;;
        ((#i)*.tar.7z|(#i)*.t7z)
            →zinit-extract() { →zinit-check 7z "$file" || return 1; command 7z x -so "$file" | command tar --no-same-owner -xf -; }
            ;;
        ((#i)*.tar.zst)
            →zinit-extract() { →zinit-check zstd "$file" || return 1; command zstd -dc "$file" | command tar --no-same-owner -xf -; }
            ;;
        ((#i)*.tar)
            →zinit-extract() { →zinit-check tar "$file" || return 1; command tar --no-same-owner -xf "$file"; }
            ;;
        ((#i)*.gz|(#i)*.gzip)
            if [[ $file != (#i)*.gz ]] {
                command mv $file $file.gz
                file=$file.gz
                integer zi_was_renamed=1
            }
            →zinit-extract() {
                →zinit-check gunzip "$file" || return 1
                .zinit-get-mtime-into "$file" 'ZINIT[tmp]'
                command gunzip "$file" |& command grep -E -v '.out$'
                integer ret=$pipestatus[1]
                command touch -t "$(strftime %Y%m%d%H%M.%S $ZINIT[tmp])" "$file"
                return ret
            }
            ;;
        ((#i)*.bz2|(#i)*.bzip2)
            # Rename file if its extension does not match "bz2". bunzip2 refuses
            # to operate on files that are not named correctly.
            # See https://github.com/zdharma-continuum/zinit/issues/105
            if [[ $file != (#i)*.bz2 ]] {
                command mv $file $file.bz2
                file=$file.bz2
            }
            →zinit-extract() { →zinit-check bunzip2 "$file" || return 1
                .zinit-get-mtime-into "$file" 'ZINIT[tmp]'
                command bunzip2 "$file" |& command grep -E -v '.out$'
                integer ret=$pipestatus[1]
                command touch -t "$(strftime %Y%m%d%H%M.%S $ZINIT[tmp])" "$file"
                return ret
            }
            ;;
        ((#i)*.xz)
            if [[ $file != (#i)*.xz ]] {
                command mv $file $file.xz
                file=$file.xz
            }
            →zinit-extract() { →zinit-check xz "$file" || return 1
                .zinit-get-mtime-into "$file" 'ZINIT[tmp]'
                command xz -d "$file"
                integer ret=$?
                command touch -t "$(strftime %Y%m%d%H%M.%S $ZINIT[tmp])" "$file"
                return ret
             }
            ;;
        ((#i)*.7z|(#i)*.7-zip)
            →zinit-extract() { →zinit-check 7z "$file" || return 1; command 7z x "$file" >/dev/null;  }
            ;;
        ((#i)*.dmg)
            →zinit-extract() {
                local prog
                for prog ( hdiutil cp ) { →zinit-check $prog "$file" || return 1; }

                integer retval
                local attached_vol="$( command hdiutil attach "$file" | \
                           command tail -n1 | command cut -f 3 )"

                command cp -Rf ${attached_vol:-${TMPDIR:-/tmp}/acb321GEF}/*(D) .
                retval=$?
                command hdiutil detach $attached_vol

                if (( retval )) {
                    +zi-log "{info}[{pre}ziextract{info}]{error} Error:{msg} problem occurred when attempted to copy the files" \
                            "from the mounted image: \`{obj}${file}{msg}'.{rst}"
                }
                return $retval
            }
            ;;
        ((#i)*.deb)
            →zinit-extract() { →zinit-check dpkg-deb "$file" || return 1; command dpkg-deb -R "$file" .; }
            ;;
        ((#i)*.rpm)
            →zinit-extract() { →zinit-check cpio "$file" || return 1; $ZINIT[BIN_DIR]/share/rpm2cpio.zsh "$file" | command cpio -imd --no-absolute-filenames; }
            ;;
        ((#i)*.exe|(#i)*.pe32)
            →zinit-extract() {
                command chmod a+x -- ./$file
                ./$file /S /D="`cygpath -w $PWD`"
            }
            ;;
    esac

    if [[ $(typeset -f + →zinit-extract) == "→zinit-extract" ]] {
        .zinit-extract-wrapper "$file" →zinit-extract || {
            +zi-log -n "{info}[{pre}ziextract{info}]{error} Error:{msg} extraction of the archive \`{file}${file}{msg}' had problems"
            local -a bfiles
            bfiles=( ._backup/*(DN) )
            if (( ${#bfiles} && !nobkp )) {
                +zi-log -n ", restoring the previous version of the plugin/snippet"
                command mv ._backup/*(DN) . 2>/dev/null
            }
            +zi-log ".{rst}"
            unfunction -- →zinit-extract →zinit-check 2>/dev/null
            return 1
        }
        unfunction -- →zinit-extract →zinit-check
    } else {
        integer warning=1
        # Not an archive and no explicit type claimed — treat as a plain single
        # file (e.g. a bare gh-r release binary). HTTP downloads carry no exec
        # bit, so mark the file executable and let the execs collection below
        # pick it up and report success.
        if [[ -z $ext ]] {
            warning=0
            (( !OPTS[opt_-q,--quiet] )) && \
                +zi-log "{info}[{pre}ziextract{info}]{rst}" \
                    "\`{file}${file}{rst}' is not an archive — keeping it as a plain file."
            command chmod a+x "$file"
        }
    }
    unfunction -- .zinit-extract-wrapper

    # Glob qualifier legend:
    #   (DN-.)  — D=include dotfiles, N=null glob (no error if empty),
    #             -=no symlinks, .=regular files  → all regular files
    #   (DN-*.) — same plus *=has execute bit set → files already marked
    #             executable by the archive extractor
    local -aU execs
    # Collect files that already have the execute bit set in the archive.
    # This is the authoritative signal: if the package author wanted a file
    # executable, they set +x when creating the archive. Any file that lacks
    # +x in the archive (library, documentation, data file, …) should stay
    # non-executable regardless of its content or extension.
    # If a poorly maintained package fails to set permissions correctly,
    # the user can fix it with the atclone/atpull ices — there is no need
    # for zinit to second-guess the archive on every install.
    execs=( **/*~(._zinit(|/*)|.git(|/*)|.svn(|/*)|.hg(|/*)|._backup(|/*))(DN-*.) )

    builtin print -rl -- ${execs[@]} >! ${TMPDIR:-/tmp}/zinit-execs.$$.lst
    if [[ ${#execs} -gt 0 ]] {
        command chmod a+x "${execs[@]}"
        if (( !OPTS[opt_-q,--quiet] )) {
            if (( ${#execs} == 1 )); then
                    +zi-log "{info}[{pre}ziextract{info}]{rst} Successfully extracted and assigned +x chmod to the file: {obj}${execs[1]}{rst}."
            else
                local sep="$ZINIT[col-rst],$ZINIT[col-obj] "
                if (( ${#execs} > 7 )) {
                    +zi-log "{info}[{pre}ziextract{info}]{rst} Successfully" \
                        "extracted and marked executable the appropriate files" \
                        "({obj}${(pj:$sep:)${(@)execs[1,5]:t}},…{rst}) contained" \
                        "in \`{file}$file{rst}'. All the extracted" \
                        "{obj}${#execs}{rst} executables are" \
                        "available in the {msg2}INSTALLED_EXECS{rst}" \
                        "array."
                } else {
                    +zi-log "{info}[{pre}ziextract{info}]{rst} Successfully" \
                        "extracted and marked {obj}${#execs}{rst} executable the appropriate files" \
                        "({obj}${(pj:$sep:)${execs[@]:t}}{rst}) contained" \
                        "in \`{file}$file{rst}'."
                }
            fi
        }
    } elif (( warning )) {
        +zi-log "{info}[{pre}ziextract{info}]{error} Error:{msg} didn't recognize archive type of {obj}${file}{msg} ${ext:+/ {obj2}${ext}{msg} } (no extraction has been done).{rst}"
    }

    if (( move | move2 )) {
        local -a files
        files=( *~(._zinit|.git|._backup|.tmp231ABC)(DN/) )
        if (( ${#files} )) {
            command mkdir -p .tmp231ABC
            command mv -f *~(._zinit|.git|._backup|.tmp231ABC)(D) .tmp231ABC
            if (( !move2 )) {
                command mv -f **/*~(*/*~*/*/*|*/*/*/*|^*/*|._zinit(|/*)|.git(|/*)|._backup(|/*))(DN) .
            } else {
                command mv -f **/*~(*/*~*/*/*/*|*/*/*/*/*|^*/*|._zinit(|/*)|.git(|/*)|._backup(|/*))(DN) .
            }

            command mv .tmp231ABC/$file . &>/dev/null
            command rm -rf .tmp231ABC
        }
        REPLY="${${execs[1]:h}:h}/${execs[1]:t}"
    } else {
        REPLY="${execs[1]}"
    }
    return 0
} # ]]]
# FUNCTION: .zinit-extract [[[
.zinit-extract() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt extendedglob warncreateglobal typesetsilent
    local tpe=$1 extract=$2 local_dir=$3
    (
        builtin cd -q "$local_dir" || \
            { +zi-log "{error}ERROR:{msg2} The path of the $tpe" \
                      "(\`{file}$local_dir{msg2}') isn't accessible.{rst}"
                return 1
            }
        local -aU files
        files=( ${(@)${(@s: :)${extract##(\!-|-\!|\!|-)}}//(#b)(((#s)|([^\\])[\\]([\\][\\])#)|((#s)|([^\\])([\\][\\])#)) /${match[2]:+$match[3]$match[4] }${match[5]:+$match[6]${(l:${#match[7]}/2::\\:):-} }} )
        if [[ ${#files} -eq 0 && -n ${extract##(\!-|-\!|\!|-)} ]] {
                +zi-log "{error}ERROR:{msg2} The files" \
                        "(\`{file}${extract##(\!-|-\!|\!|-)}{msg2}')" \
                        "not found, cannot extract.{rst}"
                return 1
        } else {
            (( !${#files} )) && files=( "" )
        }
        local file
        for file ( "${files[@]}" ) {
            [[ -z $extract ]] && local auto2=--auto
            ziextract ${${(M)extract:#(\!|-)##}:+--auto} \
                $auto2 $file \
                ${${(MS)extract[1,2]##-}:+--norm} \
                ${${(MS)extract[1,2]##\!}:+--move} \
                ${${(MS)extract[1,2]##\!\!}:+--move2} \
                ${${${#files}:#1}:+--nobkp}
        }
    )
} # ]]]
# FUNCTION: .zinit-at-eval [[[
.zinit-at-eval() {
    local atpull="$1" atclone="$2"
    integer retval
    @zinit-substitute atclone atpull

    local cmd="$atpull"
    [[ $atpull == "%atclone" ]] && cmd="$atclone"

    eval "$cmd"
    return "$?"
} # ]]]
# FUNCTION: .zinit-get-cygwin-package [[[
.zinit-get-cygwin-package() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt extendedglob warncreateglobal typesetsilent noshortloops rcquotes

    REPLY=

    local pkg=$1 nl=$'\n'
    integer retry=3

    #
    # Download mirrors.lst
    #

    +zi-log "{info}Downloading{ehi}: {obj}mirrors.lst{info}{…}{rst}"
    local mlst="$(mktemp)"
    while (( retry -- )) {
        if ! .zinit-download-file-stdout https://cygwin.com/mirrors.lst 0 > $mlst; then
            .zinit-download-file-stdout https://cygwin.com/mirrors.lst 1 > $mlst
        fi

        local -a mlist
        mlist=( "${(@f)$(<$mlst)}" )

        local mirror=${${mlist[ RANDOM % (${#mlist} + 1) ]}%%;*}
        [[ -n $mirror ]] && break
    }

    if [[ -z $mirror ]] {
        +zi-log "{error}Couldn't download{error}: {obj}mirrors.lst {error}."
        return 1
    }

    mirror=http://ftp.eq.uc.pt/software/pc/prog/cygwin/

    #
    # Download setup.ini.bz2
    #

    +zi-log "{info2}Selected mirror is{error}: {url}${mirror}{rst}"
    +zi-log "{info}Downloading{ehi}: {file}setup.ini.bz2{info}{…}{rst}"
    local setup="$(mktemp -u)"
    retry=3
    while (( retry -- )) {
        if ! .zinit-download-file-stdout ${mirror}x86_64/setup.bz2 0 1 > $setup.bz2; then
            .zinit-download-file-stdout ${mirror}x86_64/setup.bz2 1 1 > $setup.bz2
        fi

        command bunzip2 "$setup.bz2" 2>/dev/null
        [[ -s $setup ]] && break
        mirror=${${mlist[ RANDOM % (${#mlist} + 1) ]}%%;*}
        +zi-log "{pre}Retrying{error}: {meta}#{obj}$(( 3 - $retry ))/3, {pre}with mirror{error}: {url}${mirror}{rst}"
    }
    local setup_contents="$(command grep -A 26 "@ $pkg\$" "$setup")"
    local urlpart=${${(S)setup_contents/(#b)*@ $pkg${nl}*install: (*)$nl*/$match[1]}%% *}
    if [[ -z $urlpart ]] {
        +zi-log "{error}Couldn't find package{error}: {data2}\`{data}${pkg}{data2}'{error}.{rst}"
        return 2
    }
    local url=$mirror/$urlpart outfile=${TMPDIR:-${TMPDIR:-/tmp}}/${urlpart:t}

    #
    # Download the package
    #

    +zi-log "{nl}{i} Downloading {b}{file}${url:t}{rst}"
    retry=2
    while (( retry -- )) {
        integer retval=0
        if ! .zinit-download-file-stdout $url 0 1 > $outfile; then
            if ! .zinit-download-file-stdout $url 1 1 > $outfile; then
                +zi-log "{error}Couldn't download{error}: {url}${url}{error}."
                retval=1
                mirror=${${mlist[ RANDOM % (${#mlist} + 1) ]}%%;*}
                url=$mirror/$urlpart outfile=${TMPDIR:-${TMPDIR:-/tmp}}/${urlpart:t}
                if (( retry )) {
                    +zi-log "{info2}Retrying, with mirror{error}: {url}${mirror}{info2}{…}{rst}"
                    continue
                }
            fi
        fi
        break
    }
    REPLY=$outfile
} # ]]]
# FUNCTION: zicp [[[
zicp() {
    builtin emulate -LR zsh ${=${options[xtrace]:#off}:+-o xtrace}
    setopt extendedglob warncreateglobal typesetsilent noshortloops rcquotes

    local -a mbegin mend match

    local cmd=cp
    if [[ $1 = (-m|--mv) ]] { cmd=mv; shift; }

    local dir
    if [[ $1 = (-d|--dir)  ]] { dir=$2; shift 2; }

    local arg
    arg=${${(j: :)@}//(#b)(([[:space:]]~ )#(([^[:space:]]| )##)([[:space:]]~ )#(#B)(->|=>|→)(#B)([[:space:]]~ )#(#b)(([^[:space:]]| )##)|(#B)([[:space:]]~ )#(#b)(([^[:space:]]| )##))/${match[3]:+$match[3] $match[6]\;}${match[8]:+$match[8] $match[8]\;}}

    (
        if [[ -n $dir ]] { cd $dir || return 1; }
        local a b var
        integer retval
        for a b ( "${(s: :)${${(@s.;.)${arg%\;}}:-* .}}" ) {
            for var ( a b ) {
                : ${(P)var::=${(P)var//(#b)(((#s)|([^\\])[\\]([\\][\\])#)|((#s)|([^\\])([\\][\\])#)) /${match[2]:+$match[3]$match[4] }${match[5]:+$match[6]${(l:${#match[7]}/2::\\:):-} }}}
            }
            if [[ $a != *\** ]] { a=${a%%/##}"/*" }
            command mkdir -p ${~${(M)b:#/*}:-$ZPFX/$b}
            command $cmd -f ${${(M)cmd:#cp}:+-R} $~a ${~${(M)b:#/*}:-$ZPFX/$b}
            retval+=$?
        }
        return $retval
    )
    return
} # ]]]
# FUNCTION: zimv [[[
zimv() {
    local dir
    if [[ $1 = (-d|--dir) ]] { dir=$2; shift 2; }
    zicp --mv ${dir:+--dir} $dir "$@"
} # ]]]
# FUNCTION: ∞zinit-reset-hook [[[
∞zinit-reset-hook() {
    # File
    if [[ "$1" = plugin ]] {
        local type="$1" user="$2" plugin="$3" id_as="$4" dir="${5#%}" hook="$6"
    } else {
        local type="$1" url="$2" id_as="$3" dir="${4#%}" hook="$5"
    }
    if (( ( OPTS[opt_-r,--reset] && ZINIT[-r/--reset-opt-hook-has-been-run] == 0 ) || \
        ( ${+ICE[reset]} && ZINIT[-r/--reset-opt-hook-has-been-run] == 1 )
    )) {
        if (( ZINIT[-r/--reset-opt-hook-has-been-run] )) {
            local msg_bit="{meta}reset{msg2} ice given{pre}" option=
        } else {
            local msg_bit="{meta2}-r/--reset{msg2} given to \`{meta}update{pre}'" option=1
        }
        if [[ $type == snippet ]] {
            if (( $+ICE[svn] )) {
                if [[ $skip_pull -eq 0 && -d $filename/.svn ]] {
                    (( !OPTS[opt_-q,--quiet] )) && +zi-log "{pre}reset ($msg_bit): {msg2}Resetting the repository ($msg_bit) with command: {rst}svn revert --recursive {…}/{file}$filename/.{rst} {…}"
                    command svn revert --recursive $filename/.
                }
            } else {
                if (( ZINIT[annex-multi-flag:pull-active] >= 2 )) {
                    if (( !OPTS[opt_-q,--quiet] )) {
                        if [[ -f $local_dir/$dirname/$filename ]] {
                            if [[ -n $option || -z $ICE[reset] ]] {
                                +zi-log "{pre}reset ($msg_bit):{msg2} Removing the snippet-file: {file}$filename{msg2} {…}{rst}"
                            } else {
                                +zi-log "{pre}reset ($msg_bit):{msg2} Removing the snippet-file: {file}$filename{msg2}," \
                                    "with the supplied code: {data2}$ICE[reset]{msg2} {…}{rst}"
                            }
                            if (( option )) {
                                command rm -f "$local_dir/$dirname/$filename"
                            } else {
                                eval "${ICE[reset]:-rm -f \"$local_dir/$dirname/$filename\"}"
                            }
                        } else {
                            +zi-log "{pre}reset ($msg_bit):{msg2} The file {file}$filename{msg2} is already deleted {…}{rst}"
                            if [[ -n $ICE[reset] && ! -n $option ]] {
                                +zi-log "{pre}reset ($msg_bit):{msg2} (skipped running the provided reset-code:" \
                                    "{data2}$ICE[reset]{msg2}){rst}"
                            }
                        }
                    }
                } else {
                        [[ -f $local_dir/$dirname/$filename ]] && \
                            +zi-log "{pre}reset ($msg_bit): {msg2}Skipping the removal of {file}$filename{msg2}" \
                                 "as there is no new copy scheduled for download.{rst}" || \
                            +zi-log "{pre}reset ($msg_bit): {msg2}The file {file}$filename{msg2} is already deleted" \
                                "and {ehi}no new download is being scheduled.{rst}"
                }
            }
        } elif [[ $type == plugin ]] {
            if (( is_release && !skip_pull )) {
                if (( option )) {
                    (( !OPTS[opt_-q,--quiet] )) && +zi-log "{pre}reset ($msg_bit): {msg2}running: {rst}rm -rf ${${ZINIT[PLUGINS_DIR]:#[/[:space:]]##}:-${TMPDIR:-/tmp}/xyzabc312}/${${(M)${local_dir##${ZINIT[PLUGINS_DIR]}[/[:space:]]#}:#[^/]*}:-${TMPDIR:-/tmp}/xyzabc312-zinit-protection-triggered}/*"
                    builtin eval command rm -rf ${${ZINIT[PLUGINS_DIR]:#[/[:space:]]##}:-${TMPDIR:-/tmp}/xyzabc312}/"${${(M)${local_dir##${ZINIT[PLUGINS_DIR]}[/[:space:]]#}:#[^/]*}:-${TMPDIR:-/tmp}/xyzabc312-zinit-protection-triggered}"/*(ND)
                } else {
                    (( !OPTS[opt_-q,--quiet] )) && +zi-log "{pre}reset ($msg_bit): {msg2}running: {rst}${ICE[reset]:-rm -rf ${${ZINIT[PLUGINS_DIR]:#[/[:space:]]##}:-${TMPDIR:-/tmp}/xyzabc312}/${${(M)${local_dir##${ZINIT[PLUGINS_DIR]}[/[:space:]]#}:#[^/]*}:-${TMPDIR:-/tmp}/xyzabc312-zinit-protection-triggered}/*}"
                    builtin eval ${ICE[reset]:-command rm -rf ${${ZINIT[PLUGINS_DIR]:#[/[:space:]]##}:-${TMPDIR:-/tmp}/xyzabc312}/"${${(M)${local_dir##${ZINIT[PLUGINS_DIR]}[/[:space:]]#}:#[^/]*}:-${TMPDIR:-/tmp}/xyzabc312-zinit-protection-triggered}"/*(ND)}
                }
            } elif (( !skip_pull )) {
                if (( option )) {
                    +zi-log "{pre}reset ($msg_bit): {msg2}Resetting the repository with command:{rst} git reset --hard HEAD {…}"
                    command git reset --hard HEAD
                } else {
                    +zi-log "{pre}reset ($msg_bit): {msg2}Resetting the repository with command:{rst} ${ICE[reset]:-git reset --hard HEAD} {…}"
                    builtin eval "${ICE[reset]:-git reset --hard HEAD}"
                }
            }
        }
    }

    if (( OPTS[opt_-r,--reset] )) {
        if (( ZINIT[-r/--reset-opt-hook-has-been-run] == 1 )) {
            ZINIT[-r/--reset-opt-hook-has-been-run]=0
        } else {
            ZINIT[-r/--reset-opt-hook-has-been-run]=1
        }
    } else {
        # If theres no -r/--reset, pretend that it already has been served.
        ZINIT[-r/--reset-opt-hook-has-been-run]=1
    }
} # ]]]
# FUNCTION: ∞zinit-configure-base-hook [[[
# A base common implementation of the configure ice
∞zinit-configure-base-hook () {
    emulate -L zsh
    setopt extendedglob
    if [[ "$1" = plugin ]]; then
        local dir="${5#%}" hook="$6" subtype="$7" ex="$8"
    else
        local dir="${4#%}" hook="$5" subtype="$6" ex="$7"
    fi
    local flags configure eflags aflags ice='{b}configure{rst}:'
    configure=${ICE[configure]}
    @zinit-substitute configure
    (( ${+ICE[configure]} )) || return 0
    flags=${(M)configure##[smc0\!\#]##}
    configure=${configure##$flags([[:space:]]##|(#e))}
    eflags=${(SM)flags##[\!]##}
    aflags=${(SM)flags##[smc0]##}
    [[ $eflags == $ex ]] || return 0
    typeset -aU configure_opt=(${(@s; ;)configure})
    configure_opt+=("--prefix=${ZPFX:-${ZINIT[HOME_DIR]}/polaris}")
    local ___oldcd=$PWD ___oldoldpwd=$OLDPWD
    {
        .zinit-cd-quiet "$dir" || return 1
        if [[ -n *(#i)makefile(#qN) ]]; then
            return 0
        elif [[ -z *(#i)configure(#qN) ]]; then
            +zi-log "{m} ${ice} Attempting to generate configure script... "
            local c
            for c in "[[ -e autogen.sh ]] && sh ./autogen.sh" "[[ -n *.a[mc](#qN.) ]] && autoreconf -ifm" "git clean -fxd; aclocal --force; autoconf --force; automake --add-missing --copy --force-missing"; do
                +zi-log -PrD "{dbg} ${ice} {faint}${c}{rst}"
                {
                    eval "${c}" 2> /dev/null >&2
                } always {
                    [[ -n *(#i)configure(#qN) ]] && break
                    (( TRY_BLOCK_ERROR = 0 ))
                }
            done
        fi
        +zi-log "{m} ${ice} Generating Makefile"
        +zi-log "{dbg} ${ice} {faint}./configure $(builtin print -PDn -- ${(Ds; ;)configure_opt[@]//prefix /prefix=}){rst}"
        eval "./configure ${(S)configure_opt[@]//prefix /prefix=}" 2> /dev/null >&2
        if [[ -n *(#i)makefile(#qN) ]]; then
            +zi-log "{m} ${ice} Successfully generated Makefile"
            return 0
        else
            +zi-log "{e} ${ice} Failed project configuration"
            return 1
        fi
    } always {
        .zinit-restore-dir "$___oldcd" "$___oldoldpwd"
    }
} # ]]]
# FUNCTION: ∞zinit-configure-e-hook [[[
∞zinit-configure-e-hook() {
    ∞zinit-configure-base-hook "$@" "!"
} # ]]]
# FUNCTION: ∞zinit-configure-hook [[[
# The non-! version of configure'' ice. Runs in between
# of make'!' and make''. Configure script naturally runs
# before make.
∞zinit-configure-hook() {
    ∞zinit-configure-base-hook "$@" ""
} # ]]]

# FUNCTION: ∞zinit-make-base-hook [[[
# A base common implementation of the make ice
∞zinit-make-base-hook () {
    emulate -L zsh
    setopt extendedglob
    [[ -z $ICE[make] ]] && return 0
    if [[ "$1" = plugin ]]; then
        local dir="${5#%}" hook="$6" subtype="$7" ex="$8"
    else
        local dir="${4#%}" hook="$5" subtype="$6" ex="$7"
    fi
    local make=${ICE[make]} ice='{b}make{rst}:'
    @zinit-substitute make
    (( ${+ICE[make]} )) || return 0
    local eflags=${(M)make##[\!]##}
    make=${make##$eflags}
    [[ $ex == $eflags ]] || return 0
    local make_prefix='prefix'
    if grep -w -- "PREFIX =" ${dir}/[Mm]akefile >/dev/null; then
        make_prefix="PREFIX"
    fi

    local src=($dir/[Cc][Mm]ake*(N.om[1]))
    if (( $#src )); then
      +zi-log "{m} ${ice} Detected Cmake project, using CMAKE_INSTALL_PREFIX={file}\$ZPFX{rst}"
      make_prefix="CMAKE_INSTALL_PREFIX"
    else
      +zi-log -ru2 -- "{dbg} ${dir:t}: No Cmake files found in ${dir}"
    fi
    local prefix="${ZINIT[ZPFX]}"
    if [[ -n OPTS[opt_-q,--quiet] || -n ${ZINIT[DEBUG]:#1} ]]; then
        +zi-log "{dbg} ${ice} setting quiet mode"
        local quiet='2>/dev/null 1>&2'
    fi
    local -i ret=0
    {
        build="make -C ${dir} --jobs 4"
        +zi-log "{m} ${ice} Building..."
        # +zi-log "{m} ${ice} {faint}${(Ds; ;)build} $make_prefix=$(builtin print -Pnf '%s' ${(D)ZINIT[ZPFX]}){rst}"
        +zi-log "{dbg} ${ice} eval ${build} $make_prefix=$prefix 2>/dev/null 1>&2"
        eval "${build} $make_prefix=$prefix" 2>/dev/null 1>&2
        ret=$?
    } always {
        if (( ret )); then
            +zi-log "{w} ${ice} Build returned {num}${ret}{rst}"
        fi
        (( TRY_BLOCK_ERROR = 0 ))
    }
    {
        install="${build} ${make}"
        # +zi-log "{m} ${ice} {faint}${(Ds; ;)build} $make_prefix=$(builtin print -Pnf '%s' ${ZINIT[POLARIS]}) ${make} {rst}"
        +zi-log "{m} ${ice} Installing in ${(D)ZINIT[ZPFX]}"
        +zi-log "{dbg} ${ice} eval ${build} $make_prefix=$prefix ${make} 2>/dev/null 1>&2"
        eval "${(s; ;)install} $make_prefix=$prefix" 2>/dev/null 1>&2
        ret=$?
    } always {
        if (( ret )); then
            +zi-log "{w} ${ice} Install returned {num}${ret}{rst}"
        fi
        (( TRY_BLOCK_ERROR = 0 ))
    }
    return $ret
} # ]]]
# FUNCTION: ∞zinit-make-e-hook [[[
∞zinit-make-e-hook() {
    ∞zinit-make-base-hook "$@" "!"
} # ]]]
# FUNCTION: ∞zinit-make-ee-hook [[[
∞zinit-make-ee-hook() {
    ∞zinit-make-base-hook "$@" "!!"
} # ]]]
# FUNCTION: ∞zinit-make-hook [[[
∞zinit-make-hook() {
    ∞zinit-make-base-hook "$@" ""
} # ]]]

# FUNCTION: __zinit-cmake-base-hook [[[
# A base common implementation of the cmake ice
__zinit-cmake-base-hook () {
    emulate -L zsh
    setopt extended_glob
    (( ${+ICE[cmake]} )) || return 0
    if (( ! ${+commands[cmake]} )); then
        +zi-log "{e} {cmd}cmake{rst} required to use {ice}cmake{rst} ice"
        return 0
    fi
    if [[ "$1" = plugin ]]; then
        local dir="${5#%}" hook="$6" subtype="$7" ex="$8"
    else
        local dir="${4#%}" hook="$5" subtype="$6" ex="$7"
    fi
    (( OPTS[opt_-q,--quiet] || ZINIT[DEBUG] )) && local QUIET='2>/dev/null 1>&2'
    local c ret=0 ice='{b}cmake{rst}:'
    for c in "-S ${dir} -B ${dir}/build -DCMAKE_BUILD_TYPE=Release --install-prefix ${ZINIT[ZPFX]} ${QUIET}" "--build ${dir}/build --parallel $(nproc) ${QUIET}" "--install ${dir}/build ${QUIET}"; do
      +zi-log "{m} ${ice} {faint}cmake ${(Ds; ;)c} {rst}"
        eval "cmake ${c}" 2> /dev/null >&2
        if (( $? )); then
            +zi-log "{e} ${ice} Failure cmake ${c}{rst}"
            ret=$?
        fi
    done
    return $?
} # ]]]
# FUNCTION: +zinit-cmake-hook [[[
+zinit-cmake-hook() {
    __zinit-cmake-base-hook "$@"
} # ]]]

# FUNCTION: ∞zinit-atclone-hook [[[
∞zinit-atclone-hook() {
    [[ "$1" = plugin ]] && \
        local dir="${5#%}" hook="$6" subtype="$7" || \
        local dir="${4#%}" hook="$5" subtype="$6"

    local atclone=${ICE[atclone]}
    @zinit-substitute atclone
    (( ${+ICE[atclone]} )) || return 0

    local rc=0
    [[ -n $atclone ]] && .zinit-countdown atclone && {
        local ___oldcd=$PWD ___oldoldpwd=$OLDPWD

        (( ${+ICE[nocd]} == 0 )) && .zinit-cd-quiet "$dir"

        # Unlike its atpull siblings this evals inline, with no .zinit-at-eval
        # frame to absorb a `return' from the ice body.
        {
            eval "$atclone"
            rc="$?"
        } always {
            .zinit-restore-dir "$___oldcd" "$___oldoldpwd"
        }
    }

    return "$rc"
} # ]]]
# FUNCTION: ∞zinit-extract-hook [[[
∞zinit-extract-hook() {
    [[ "$1" = plugin ]] && \
        local dir="${5#%}" hook="$6" subtype="$7" || \
        local dir="${4#%}" hook="$5" subtype="$6"

    local extract=${ICE[extract]}
    @zinit-substitute extract

    (( ${+ICE[extract]} )) || return 0

    .zinit-extract plugin "$extract" "$dir"
} # ]]]
# FUNCTION: ∞zinit-cp-mv-operation-hook [[[
∞zinit-file-cp-mv-operation() {
    local cmd="$1" # Either "cp" or "mv"
    local ice_key="$cmd"

    [[ -z $ICE[$ice_key] ]] && return 0

    [[ "$2" = plugin ]] && \
      local dir="${6#%}" hook="$7" subtype="$8" || \
      local dir="${5#%}" hook="$6" subtype="$7"

    # Parse and clean up the ICE directive
    local -a pairs
    pairs=( ${(s[;])ICE[$ice_key]} ) # Split on semicolons
    pairs=( "${pairs[@]//((#s)[[:space:]]##|[[:space:]]##(#e))/}" ) # Trim spaces

    local pair retval=0
    for pair in "${pairs[@]}"; do
        if [[ $pair == *("->"|"→")* ]]; then
            local from="${pair%%[[:space:]]#(->|→)*}"
            local to="${pair##*(->|→)[[:space:]]#}"
        else
            local from="${pair%%[[:space:]]##*}"
            local to="${pair##*[[:space:]]##}"
        fi

        @zinit-substitute from to

        local -a cmd_args=("-f")
        local -a afr

        (
            .zinit-cd-quiet "$dir" || return 1
            afr=( ${~from}(DN) ) # Expand glob patterns

            if (( ! ${#afr} )); then
                +zi-log "{warn}Warning: $ice_key ice didn't match any file. [{error}$pair{warn}]" \
                               "{nl}{warn}Available files:{nl}{obj}$(ls -1)"
                retval=1
                continue
            fi
            if (( !OPTS[opt_-q,--quiet] )); then
                cmd_args+=("-v")
            fi

            for file in "${afr[@]}"; do
                command "$cmd" "${cmd_args[@]}" "$file" "$to" || retval=$?
                # Handle .zwc files if they exist
                command "$cmd" "${cmd_args[@]}" "$file.zwc" "$to.zwc" 2>/dev/null
            done
        )
    done

    return $retval
} # ]]]
# FUNCTION: ∞zinit-mv-hook [[[
∞zinit-mv-hook() {
    ∞zinit-file-cp-mv-operation "mv" "$@"
} # ]]]
# FUNCTION: ∞zinit-cp-hook [[[
∞zinit-cp-hook() {
    ∞zinit-file-cp-mv-operation "cp" "$@"
} # ]]]
# FUNCTION: ∞zinit-compile-plugin-hook [[[
∞zinit-compile-plugin-hook () {
    if [[ "$1" = plugin ]]; then
        local dir="${5#%}" hook="$6" subtype="$7"
    else
        local dir="${4#%}" hook="$5" subtype="$6"
    fi
    if ! [[ ( $hook = *\!at(clone|pull)* && ${+ICE[nocompile]} -eq 0 ) || ( $hook = at(clone|pull)* && $ICE[nocompile] = '!' ) ]]; then
        return 0
    fi
    if [[ -z $ICE[(i)(\!|)(sh|bash|ksh|csh)] ]]; then
        () {
            builtin source "${ZINIT[BIN_DIR]}/zinit-autoload.zsh" || return 1
            setopt local_options extended_glob warn_create_global
            local quiet=1
            if [[ $tpe == snippet ]]; then
                .zinit-compile-plugin "%$dir"
            else
                .zinit-compile-plugin "$id_as"
            fi
        }
    fi
} # ]]]
# FUNCTION: ∞zinit-atpull-e-hook [[[
∞zinit-atpull-e-hook() {
    (( ${+ICE[atpull]} )) || return 0
    [[ -n ${ICE[atpull]} ]] || return 0
    # Only process atpull"!cmd"
    [[ $ICE[atpull] == "!"* ]] || return 0

    [[ "$1" = plugin ]] && \
        local dir="${5#%}" hook="$6" subtype="$7" || \
        local dir="${4#%}" hook="$5" subtype="$6"

    local atpull=${ICE[atpull]#\!}
    local rc=0

    .zinit-countdown atpull && {
        local ___oldcd=$PWD ___oldoldpwd=$OLDPWD
        (( ${+ICE[nocd]} == 0 )) && .zinit-cd-quiet "$dir"
        .zinit-at-eval "$atpull" "$ICE[atclone]"
        rc="$?"
        .zinit-restore-dir "$___oldcd" "$___oldoldpwd"
    }

    return "$rc"
} # ]]]
# FUNCTION: ∞zinit-atpull-hook [[[
∞zinit-atpull-hook() {
    (( ${+ICE[atpull]} )) || return 0
    [[ -n ${ICE[atpull]} ]] || return 0
    # Exit early if atpull"!cmd" -> this is done by zinit-atpull-e-hook
    [[ $ICE[atpull] == "!"* ]] && return 0

    [[ "$1" == plugin ]] && \
        local dir="${5#%}" hook="$6" subtype="$7" || \
        local dir="${4#%}" hook="$5" subtype="$6"

    local atpull=${ICE[atpull]}
    local rc=0

    .zinit-countdown atpull && {
        local ___oldcd=$PWD ___oldoldpwd=$OLDPWD
        (( ${+ICE[nocd]} == 0 )) && .zinit-cd-quiet "$dir"
        .zinit-at-eval "$atpull" $ICE[atclone]
        rc="$?"
        .zinit-restore-dir "$___oldcd" "$___oldoldpwd"
    }

    return "$rc"
} # ]]]
# FUNCTION: ∞zinit-ps-on-update-hook [[[
∞zinit-ps-on-update-hook() {
    [[ -z $ICE[ps-on-update] ]] && return 0

    [[ "$1" = plugin ]] && \
        local tpe="$1" dir="${5#%}" hook="$6" subtype="$7" || \
        local tpe="$1" dir="${4#%}" hook="$5" subtype="$6"

    if (( !OPTS[opt_-q,--quiet] )) {
        +zi-log "Running $tpe's provided update code: {info}${ICE[ps-on-update][1,50]}${ICE[ps-on-update][51]:+…}{rst}"
        (
            builtin cd -q "$dir" || return 1
            eval "$ICE[ps-on-update]"
        )
    } else {
        (
            builtin cd -q "$dir" || return 1
            eval "$ICE[ps-on-update]" &> /dev/null
        )
    }
} # ]]]

# vim: ft=zsh sw=2 ts=2 et foldmarker=[[[,]]] foldmethod=marker