feat: moved from git submodules to curl and git

1 files changed, 2057 insertions, 0 deletions

diff --git a/zsh/antigen.zsh b/zsh/antigen.zsh
new file mode 100644
index 0000000..e813207
--- /dev/null
+++ b/zsh/antigen.zsh
@@ -0,0 +1,2057 @@
+######################################################################
+# This file was autogenerated by `make`. Do not edit it directly!
+######################################################################
+# Antigen: A simple plugin manager for zsh
+ # Authors: Shrikant Sharat Kandula
+ #          and Contributors <https://github.com/zsh-users/antigen/contributors>
+ # Homepage: http://antigen.sharats.me
+ # License: MIT License <mitl.sharats.me>
+zmodload zsh/parameter
+autoload -U is-at-least
+
+# While boot.zsh is part of the ext/cache functionallity it may be disabled
+# with ANTIGEN_CACHE flag, and it's always compiled with antigen.zsh
+if [[ $ANTIGEN_CACHE != false ]]; then
+  ANTIGEN_CACHE="${ANTIGEN_CACHE:-${ADOTDIR:-$HOME/.antigen}/init.zsh}"
+  ANTIGEN_RSRC="${ANTIGEN_RSRC:-${ADOTDIR:-$HOME/.antigen}/.resources}"
+
+  # It may not be necessary to check ANTIGEN_AUTO_CONFIG.
+  if [[ $ANTIGEN_AUTO_CONFIG != false && -f $ANTIGEN_RSRC ]]; then
+    # Check the list of files for configuration changes (uses -nt comp)
+    ANTIGEN_CHECK_FILES=$(cat $ANTIGEN_RSRC 2> /dev/null)
+    ANTIGEN_CHECK_FILES=(${(@f)ANTIGEN_CHECK_FILES})
+
+    for config in $ANTIGEN_CHECK_FILES; do
+      if [[ "$config" -nt "$config.zwc" ]]; then
+        # Flag configuration file as newer
+        { zcompile "$config" } &!
+        # Kill cache file in order to force full loading (see a few lines below)
+        [[ -f "$ANTIGEN_CACHE" ]] && rm -f "$ANTIGEN_CACHE"
+      fi
+    done
+  fi
+
+  # If there is a cache file do load from it
+  if [[ -f $ANTIGEN_CACHE && ! $_ANTIGEN_CACHE_LOADED == true ]]; then
+    # Wrap antigen in order to defer cache source until `antigen-apply`
+    antigen() {
+      if [[ $1 == "apply" ]]; then
+        source "$ANTIGEN_CACHE"
+      # Handle `antigen-init` command properly
+      elif [[ $1 == "init" ]]; then
+        source "$2"
+      fi
+    }
+    # Do not continue loading antigen as cache bundle takes care of it.
+    return 0
+  fi
+fi
+[[ -z "$_ANTIGEN_INSTALL_DIR" ]] && _ANTIGEN_INSTALL_DIR=${0:A:h}
+
+# Each line in this string has the following entries separated by a space
+# character.
+# <repo-url>, <plugin-location>, <bundle-type>, <has-local-clone>
+[[ $_ANTIGEN_CACHE_LOADED != true ]] && typeset -aU _ANTIGEN_BUNDLE_RECORD
+
+# Do not load anything if git is not available.
+if (( ! $+commands[git] )); then
+    echo 'Antigen: Please install git to use Antigen.' >&2
+    return 1
+fi
+
+# Used to defer compinit/compdef
+typeset -a __deferred_compdefs
+compdef () { __deferred_compdefs=($__deferred_compdefs "$*") }
+
+# A syntax sugar to avoid the `-` when calling antigen commands. With this
+# function, you can write `antigen-bundle` as `antigen bundle` and so on.
+antigen () {
+  local cmd="$1"
+  if [[ -z "$cmd" ]]; then
+    echo 'Antigen: Please give a command to run.' >&2
+    return 1
+  fi
+  shift
+
+  if (( $+functions[antigen-$cmd] )); then
+      "antigen-$cmd" "$@"
+      return $?
+  else
+      echo "Antigen: Unknown command: $cmd" >&2
+      return 1
+  fi
+}
+# Returns the bundle's git revision
+#
+# Usage
+#   -antigen-bundle-rev bundle-name [is_local_clone]
+#
+# Returns
+#   Bundle rev-parse output (branch name or short ref name)
+-antigen-bundle-rev () {
+  local bundle=$1
+  local is_local_clone=$2
+
+  local bundle_path=$bundle
+  # Get bunde path inside $ADOTDIR if bundle was effectively cloned
+  if [[ "$is_local_clone" == "true" ]]; then
+    bundle_path=$(-antigen-get-clone-dir $bundle)
+  fi
+
+  local ref
+  ref=$(git --git-dir="$bundle_path/.git" rev-parse --abbrev-ref '@' 2>/dev/null)
+
+  # Avoid 'HEAD' when in detached mode
+  if [[ $ref == "HEAD" ]]; then
+    ref=$(git --git-dir="$bundle_path/.git" describe --tags --exact-match 2>/dev/null \
+	    || git --git-dir="$bundle_path/.git" rev-parse --short '@' 2>/dev/null || "-")
+  fi
+  echo $ref
+}
+# Usage:
+#   -antigen-bundle-short-name "https://github.com/user/repo.git[|*]" "[branch/name]"
+# Returns:
+#   user/repo@branch/name
+-antigen-bundle-short-name () {
+  local bundle_name="${1%|*}"
+  local bundle_branch="$2"
+  local match mbegin mend MATCH MBEGIN MEND
+
+  [[ "$bundle_name" =~ '.*/(.*/.*).*$' ]] && bundle_name=$match[1]
+  bundle_name="${bundle_name%.git*}"
+
+  if [[ -n $bundle_branch ]]; then
+    bundle_name="$bundle_name@$bundle_branch"
+  fi
+
+  echo $bundle_name
+}
+# Echo the bundle specs as in the record. The first line is not echoed since it
+# is a blank line.
+-antigen-echo-record () {
+  echo ${(j:\n:)_ANTIGEN_BUNDLE_RECORD}
+}
+# Filters _ANTIGEN_BUNDLE_RECORD for $1
+#
+# Usage
+#   -antigen-find-bundle example/bundle
+#
+# Returns
+#   String if bundle is found
+-antigen-find-bundle () {
+  echo $(-antigen-find-record $1 | cut -d' ' -f1)
+}
+
+# Filters _ANTIGEN_BUNDLE_RECORD for $1
+#
+# Usage
+#   -antigen-find-record example/bundle
+#
+# Returns
+#   String if record is found
+-antigen-find-record () {
+  local bundle=$1
+  
+  if [[ $# -eq 0 ]]; then
+    return 1
+  fi
+
+  local record=${bundle/\|/\\\|}
+  echo "${_ANTIGEN_BUNDLE_RECORD[(r)*$record*]}"
+}
+# Returns bundle names from _ANTIGEN_BUNDLE_RECORD
+#
+# Usage
+#   -antigen-get-bundles [--short|--simple|--long]
+#
+# Returns
+#   List of bundles installed
+-antigen-get-bundles () {
+  local mode revision url bundle_name bundle_entry loc no_local_clone
+  local record bundle make_local_clone
+  mode=${1:-"--short"}
+
+  for record in $_ANTIGEN_BUNDLE_RECORD; do
+    bundle=(${(@s/ /)record})
+    url=$bundle[1]
+    loc=$bundle[2]
+    make_local_clone=$bundle[4]
+
+    bundle_name=$(-antigen-bundle-short-name $url)
+
+    case "$mode" in
+        --short)
+          # Only check revision for bundle with a requested branch
+          if [[ $url == *\|* ]]; then
+            revision=$(-antigen-bundle-rev $url $make_local_clone)
+          else
+            revision="master"
+          fi
+
+          if [[ $loc != '/' ]]; then
+            bundle_name="$bundle_name ~ $loc"
+          fi
+          echo "$bundle_name @ $revision"
+        ;;
+        --simple)
+          echo "$bundle_name"
+        ;;
+        --long)
+          echo "$record"
+        ;;
+     esac
+  done
+}
+# Usage:
+#  -antigen-get-clone-dir "https://github.com/zsh-users/zsh-syntax-highlighting.git[|feature/branch]"
+# Returns:
+#  $ANTIGEN_BUNDLES/zsh-users/zsh-syntax-highlighting[-feature-branch]
+-antigen-get-clone-dir () {
+  local bundle="$1"
+  local url="${bundle%|*}"
+  local branch match mbegin mend MATCH MBEGIN MEND
+  [[ "$bundle" =~ "\|" ]] && branch="${bundle#*|}"
+
+  # Takes a repo url and mangles it, giving the path that this url will be
+  # cloned to. Doesn't actually clone anything.
+  local clone_dir="$ANTIGEN_BUNDLES"
+
+  url=$(-antigen-bundle-short-name $url)
+
+  # Suffix with branch/tag name
+  [[ -n "$branch" ]] && url="$url-${branch//\//-}"
+  url=${url//\*/x}
+
+  echo "$clone_dir/$url"
+}
+# Returns bundles flagged as make_local_clone
+#
+# Usage
+#    -antigen-cloned-bundles
+#
+# Returns
+#    Bundle metadata
+-antigen-get-cloned-bundles() {
+  -antigen-echo-record |
+      awk '$4 == "true" {print $1}' |
+      sort -u
+}
+# Returns a list of themes from a default library (omz)
+#
+# Usage
+#   -antigen-get-themes
+#
+# Returns
+#   List of themes by name
+-antigen-get-themes () {
+  local library='robbyrussell/oh-my-zsh'
+  local bundle=$(-antigen-find-bundle $library)
+
+  if [[ -n "$bundle" ]]; then
+    local dir=$(-antigen-get-clone-dir $ANTIGEN_DEFAULT_REPO_URL)
+    echo $(ls $dir/themes/ | grep '.zsh-theme$' | sed 's/.zsh-theme//')
+  fi
+
+  return 0
+}
+
+# This function check ZSH_EVAL_CONTEXT to determine if running in interactive shell. 
+#
+# Usage
+#   -antigen-interactive-mode
+#
+# Returns
+#   Either true or false depending if we are running in interactive mode
+-antigen-interactive-mode () {
+  WARN "-antigen-interactive-mode: $ZSH_EVAL_CONTEXT \$_ANTIGEN_INTERACTIVE = $_ANTIGEN_INTERACTIVE"
+  if [[ $_ANTIGEN_INTERACTIVE != "" ]]; then
+    [[ $_ANTIGEN_INTERACTIVE == true ]];
+    return
+  fi
+
+  [[ "$ZSH_EVAL_CONTEXT" == toplevel* || "$ZSH_EVAL_CONTEXT" == cmdarg* ]];
+}
+# Parses and retrieves a remote branch given a branch name.
+#
+# If the branch name contains '*' it will retrieve remote branches
+# and try to match against tags and heads, returning the latest matching.
+#
+# Usage
+#     -antigen-parse-branch https://github.com/user/repo.git x.y.z
+#
+# Returns
+#     Branch name
+-antigen-parse-branch () {
+  local url="$1" branch="$2" branches
+  
+  local match mbegin mend MATCH MBEGIN MEND
+
+  if [[ "$branch" =~ '\*' ]]; then
+    branches=$(git ls-remote --tags -q "$url" "$branch"|cut -d'/' -f3|sort -n|tail -1)
+    # There is no --refs flag in git 1.8 and below, this way we
+    # emulate this flag -- also git 1.8 ref order is undefined.
+    branch=${${branches#*/*/}%^*} # Why you are like this?
+  fi
+
+  echo $branch
+}
+-antigen-update-repos () {
+  local repo bundle url target
+  local log=/tmp/antigen-v2-migrate.log
+
+  echo "It seems you have bundles cloned with Antigen v1.x."
+  echo "We'll try to convert directory structure to v2."
+  echo
+
+  echo -n "Moving bundles to '\$ADOTDIR/bundles'... "
+
+  # Migrate old repos -> bundles
+  local errors=0
+  for repo in $ADOTDIR/repos/*; do
+    bundle=${repo/$ADOTDIR\/repos\//}
+    bundle=${bundle//-SLASH-/\/}
+    bundle=${bundle//-COLON-/\:}
+    bundle=${bundle//-STAR-/\*}
+    url=${bundle//-PIPE-/\|}
+    target=$(-antigen-get-clone-dir $url)
+    mkdir -p "${target:A:h}"
+    echo " ---> ${repo/$ADOTDIR\/} -> ${target/$ADOTDIR\/}" | tee > $log
+    mv "$repo" "$target" &> $log
+    if [[ $? != 0 ]]; then
+      echo "Failed to migrate '$repo'!."
+      errors+=1
+    fi
+  done
+
+  if [[ $errors == 0 ]]; then
+    echo "Done."
+  else
+    echo "An error ocurred!"
+  fi
+  echo
+
+  if [[ "$(ls -A $ADOTDIR/repos | wc -l | xargs)" == 0 ]]; then
+    echo "You can safely remove \$ADOTDIR/repos."
+  else
+    echo "Some bundles couldn't be migrated. See \$ADOTDIR/repos."
+  fi
+
+  echo
+  if [[ $errors == 0 ]]; then
+    echo "Bundles migrated successfuly."
+    rm $log
+  else
+    echo "Some errors occured. Review migration log in '$log'."
+  fi
+  antigen-reset
+}
+# Ensure that a clone exists for the given repo url and branch. If the first
+# argument is `update` and if a clone already exists for the given repo
+# and branch, it is pull-ed, i.e., updated.
+#
+# This function expects three arguments in order:
+# - 'url=<url>'
+# - 'update=true|false'
+# - 'verbose=true|false'
+#
+# Returns true|false Whether cloning/pulling was succesful
+-antigen-ensure-repo () {
+  # Argument defaults. Previously using ${1:?"missing url argument"} format
+  # but it seems to mess up with cram
+  if (( $# < 1 )); then
+    echo "Antigen: Missing url argument."
+    return 1
+  fi
+
+  # The url. No sane default for this, so just empty.
+  local url=$1
+  # Check if we have to update.
+  local update=${2:-false}
+  # Verbose output.
+  local verbose=${3:-false}
+
+  shift $#
+
+  # Get the clone's directory as per the given repo url and branch.
+  local clone_dir=$(-antigen-get-clone-dir $url)
+  if [[ -d "$clone_dir" && $update == false ]]; then
+    return true
+  fi
+
+  # A temporary function wrapping the `git` command with repeated arguments.
+  --plugin-git () {
+    (\cd -q "$clone_dir" && eval ${ANTIGEN_CLONE_ENV} git --git-dir="$clone_dir/.git" --no-pager "$@" &>>! $ANTIGEN_LOG)
+  }
+
+  local success=false
+
+  # If its a specific branch that we want, checkout that branch.
+  local branch="master" # TODO FIX THIS
+  if [[ $url == *\|* ]]; then
+    branch="$(-antigen-parse-branch ${url%|*} ${url#*|})"
+  fi
+
+  if [[ ! -d $clone_dir ]]; then
+    eval ${ANTIGEN_CLONE_ENV} git clone ${=ANTIGEN_CLONE_OPTS} --branch "$branch" -- "${url%|*}" "$clone_dir" &>> $ANTIGEN_LOG
+    success=$?
+  elif $update; then
+    # Save current revision.
+    local old_rev="$(--plugin-git rev-parse HEAD)"
+    # Pull changes if update requested.
+    --plugin-git checkout "$branch"
+    --plugin-git pull origin "$branch"
+    success=$?
+
+    # Update submodules.
+    --plugin-git submodule update ${=ANTIGEN_SUBMODULE_OPTS}
+    # Get the new revision.
+    local new_rev="$(--plugin-git rev-parse HEAD)"
+  fi
+
+  if [[ -n $old_rev && $old_rev != $new_rev ]]; then
+    echo Updated from $old_rev[0,7] to $new_rev[0,7].
+    if $verbose; then
+      --plugin-git log --oneline --reverse --no-merges --stat '@{1}..'
+    fi
+  fi
+
+  # Remove the temporary git wrapper function.
+  unfunction -- --plugin-git
+
+  return $success
+}
+# Helper function: Same as `$1=$2`, but will only happen if the name
+# specified by `$1` is not already set.
+-antigen-set-default () {
+  local arg_name="$1"
+  local arg_value="$2"
+  eval "test -z \"\$$arg_name\" && typeset -g $arg_name='$arg_value'"
+}
+
+-antigen-env-setup () {
+  typeset -gU fpath path
+
+  # Pre-startup initializations.
+  -antigen-set-default ANTIGEN_OMZ_REPO_URL \
+    https://github.com/robbyrussell/oh-my-zsh.git
+  -antigen-set-default ANTIGEN_PREZTO_REPO_URL \
+    https://github.com/sorin-ionescu/prezto.git
+  -antigen-set-default ANTIGEN_DEFAULT_REPO_URL $ANTIGEN_OMZ_REPO_URL
+
+  # Default Antigen directory.
+  -antigen-set-default ADOTDIR $HOME/.antigen
+  [[ ! -d $ADOTDIR ]] && mkdir -p $ADOTDIR
+
+  # Defaults bundles directory.
+  -antigen-set-default ANTIGEN_BUNDLES $ADOTDIR/bundles
+
+  # If there is no bundles directory, create it.
+  if [[ ! -d $ANTIGEN_BUNDLES ]]; then
+    mkdir -p $ANTIGEN_BUNDLES
+    # Check for v1 repos directory, transform it to v2 format.
+    [[ -d $ADOTDIR/repos ]] && -antigen-update-repos
+  fi
+
+  -antigen-set-default ANTIGEN_COMPDUMP "${ADOTDIR:-$HOME}/.zcompdump"
+  -antigen-set-default ANTIGEN_LOG /dev/null
+
+  # CLONE_OPTS uses ${=CLONE_OPTS} expansion so don't use spaces
+  # for arguments that can be passed as `--key=value`.
+  -antigen-set-default ANTIGEN_CLONE_ENV "GIT_TERMINAL_PROMPT=0"
+  -antigen-set-default ANTIGEN_CLONE_OPTS "--single-branch --recursive --depth=1"
+  -antigen-set-default ANTIGEN_SUBMODULE_OPTS "--recursive --depth=1"
+
+  # Complain when a bundle is already installed.
+  -antigen-set-default _ANTIGEN_WARN_DUPLICATES true
+
+  # Compatibility with oh-my-zsh themes.
+  -antigen-set-default _ANTIGEN_THEME_COMPAT true
+  
+  # Add default built-in extensions to load at start up
+  -antigen-set-default _ANTIGEN_BUILTIN_EXTENSIONS 'lock parallel defer cache'
+
+  # Setup antigen's own completion.
+  if -antigen-interactive-mode; then
+    TRACE "Gonna create compdump file @ env-setup" COMPDUMP
+    autoload -Uz compinit
+    compinit -d "$ANTIGEN_COMPDUMP"
+    compdef _antigen antigen
+  else
+    (( $+functions[antigen-ext-init] )) && antigen-ext-init
+  fi
+}
+# Load a given bundle by sourcing it.
+#
+# The function also modifies fpath to add the bundle path.
+#
+# Usage
+#   -antigen-load "bundle-url" ["location"] ["make_local_clone"] ["btype"]
+#
+# Returns
+#   Integer. 0 if success 1 if an error ocurred.
+-antigen-load () {
+  local bundle list
+  typeset -A bundle; bundle=($@)
+
+  typeset -Ua list; list=()
+  local location="${bundle[dir]}/${bundle[loc]}"
+
+  # Prioritize location when given.
+  if [[ -f "${location}" ]]; then
+    list=(${location})
+  else
+    # Directory locations must be suffixed with slash
+    location="$location/"
+
+    # Prioritize theme with antigen-theme
+    if [[ ${bundle[btype]} == "theme" ]]; then
+      list=(${location}*.zsh-theme(N[1]))
+    fi
+
+    # Common frameworks
+    if [[ $#list == 0 ]]; then
+      # dot-plugin, init and functions support (omz, prezto)
+      # Support prezto function loading. See https://github.com/zsh-users/antigen/pull/428
+      list=(${location}*.plugin.zsh(N[1]) ${location}init.zsh(N[1]) ${location}/functions(N[1]))
+    fi
+
+    # Default to zsh and sh
+    if [[ $#list == 0 ]]; then
+      list=(${location}*.zsh(N) ${location}*.sh(N))
+    fi
+  fi
+
+  -antigen-load-env ${(kv)bundle}
+
+  # If there is any sourceable try to load it
+  if ! -antigen-load-source "${list[@]}" && [[ ! -d ${location} ]]; then
+    return 1
+  fi
+
+  return 0
+}
+
+-antigen-load-env () {
+  typeset -A bundle; bundle=($@)
+  local location=${bundle[dir]}/${bundle[loc]}
+
+  # Load to path if there is no sourceable
+  if [[ -d ${location} ]]; then
+    PATH="$PATH:${location:A}"
+    fpath+=("${location:A}")
+    return
+  fi
+
+  PATH="$PATH:${location:A:h}"
+  fpath+=("${location:A:h}")
+}
+
+-antigen-load-source () {
+  typeset -a list
+  list=($@)
+  local src match mbegin mend MATCH MBEGIN MEND
+
+  # Return error when we're given an empty list
+  if [[ $#list == 0 ]]; then
+    return 1
+  fi
+  
+  # Using a for rather than `source $list` as we need to check for zsh-themes
+  # In order to create antigen-compat file. This is only needed for interactive-mode
+  # theme switching, for static loading (cache) there is no need.
+  for src in $list; do
+    if [[ $_ANTIGEN_THEME_COMPAT == true  && -f "$src" && "$src" == *.zsh-theme* ]]; then
+      local compat="${src:A}.antigen-compat"
+      echo "# Generated by Antigen. Do not edit!" >! "$compat"
+      cat $src | sed -Ee '/\{$/,/^\}/!{
+             s/^local //
+         }' >>! "$compat"
+      src="$compat"
+    fi
+
+    if ! source "$src" 2>/dev/null; then
+      return 1
+    fi
+  done
+}
+# Usage:
+#   -antigen-parse-args output_assoc_arr <args...>
+-antigen-parse-args () {
+  local argkey key value index=0 args
+  local match mbegin mend MATCH MBEGIN MEND
+
+  local var=$1
+  shift
+
+  # Bundle spec arguments' default values.
+  #setopt XTRACE VERBOSE
+  builtin typeset -A args
+  args[url]="$ANTIGEN_DEFAULT_REPO_URL"
+  #unsetopt XTRACE VERBOSE
+  args[loc]=/
+  args[make_local_clone]=true
+  args[btype]=plugin
+  #args[branch]= # commented out as it may cause assoc array kv mismatch
+
+  while [[ $# -gt 0 ]]; do
+    argkey="${1%\=*}"
+    key="${argkey//--/}"
+    value="${1#*=}"
+
+    case "$argkey" in
+      --url|--loc|--branch|--btype)
+        if [[ "$value" == "$argkey" ]]; then
+          printf "Required argument for '%s' not provided.\n" $key >&2
+        else
+          args[$key]="$value"
+        fi
+      ;;
+      --no-local-clone)
+        args[make_local_clone]=false
+      ;;
+      --*)
+        printf "Unknown argument '%s'.\n" $key >&2
+      ;;
+      *)
+        value=$key
+        case $index in
+          0)
+            key=url
+            local domain=""
+            local url_path=$value
+            # Full url with protocol or ssh github url (github.com:org/repo)
+            if [[ "$value" =~ "://" || "$value" =~ ":" ]]; then
+              if [[ "$value" =~ [@.][^/:]+[:]?[0-9]*[:/]?(.*)@?$ ]]; then
+                url_path=$match[1]
+                domain=${value/$url_path/}
+              fi
+            fi
+
+            if [[ "$url_path" =~ '@' ]]; then
+              args[branch]="${url_path#*@}"
+              value="$domain${url_path%@*}"
+            else
+              value="$domain$url_path"
+            fi
+          ;;
+          1) key=loc ;;
+        esac
+        let index+=1
+        args[$key]="$value"
+      ;;
+    esac
+
+    shift
+  done
+  
+  # Check if url is just the plugin name. Super short syntax.
+  if [[ "${args[url]}" != */* ]]; then
+    case "$ANTIGEN_DEFAULT_REPO_URL" in
+      "$ANTIGEN_OMZ_REPO_URL")
+        args[loc]="plugins/${args[url]}"
+      ;;
+      "$ANTIGEN_PREZTO_REPO_URL")
+        args[loc]="modules/${args[url]}"
+      ;;
+      *)
+        args[loc]="${args[url]}"
+      ;;
+    esac
+    args[url]="$ANTIGEN_DEFAULT_REPO_URL"
+  fi
+
+  # Resolve the url.
+  # Expand short github url syntax: `username/reponame`.
+  local url="${args[url]}"
+  if [[ $url != git://* &&
+          $url != https://* &&
+          $url != http://* &&
+          $url != ssh://* &&
+          $url != /* &&
+          $url != *github.com:*/*
+          ]]; then
+    url="https://github.com/${url%.git}.git"
+  fi
+  args[url]="$url"
+
+  # Ignore local clone if url given is not a git directory
+  if [[ ${args[url]} == /* && ! -d ${args[url]}/.git ]]; then
+    args[make_local_clone]=false
+  fi
+
+  # Add the branch information to the url if we need to create a local clone.
+  # Format url in bundle-metadata format: url[|branch]
+  if [[ ! -z "${args[branch]}" && ${args[make_local_clone]} == true ]]; then
+    args[url]="${args[url]}|${args[branch]}"
+  fi
+
+  # Add the theme extension to `loc`, if this is a theme, but only
+  # if it's especified, ie, --loc=theme-name, in case when it's not
+  # specified antige-load-list will look for *.zsh-theme files
+  if [[ ${args[btype]} == "theme" &&
+      ${args[loc]} != "/" && ${args[loc]} != *.zsh-theme ]]; then
+      args[loc]="${args[loc]}.zsh-theme"
+  fi
+
+  local name="${args[url]%|*}"
+  local branch="${args[branch]}"
+
+  # Extract bundle name.
+  if [[ "$name" =~ '.*/(.*/.*).*$' ]]; then
+    name="${match[1]}"
+  fi
+  name="${name%.git*}"
+
+  # Format bundle name with optional branch.
+  if [[ -n "${branch}" ]]; then
+    args[name]="${name}@${branch}"
+  else
+    args[name]="${name}"
+  fi
+
+  # Format bundle path.
+  if [[ ${args[make_local_clone]} == true ]]; then
+    local bpath="$name"
+    # Suffix with branch/tag name
+    if [[ -n "$branch" ]]; then
+      # bpath is in the form of repo/name@version => repo/name-version
+      # Replace / with - in bundle branch.
+      local bbranch=${branch//\//-}
+      # If branch/tag is semver-like do replace * by x.
+      bbranch=${bbranch//\*/x}
+      bpath="${name}-${bbranch}"
+    fi
+
+    bpath="$ANTIGEN_BUNDLES/$bpath"
+    args[dir]="${(qq)bpath}"
+  else
+    # if it's local then path is just the "url" argument, loc remains the same
+    args[dir]=${args[url]}
+  fi
+  
+  # Escape url and branch (may contain semver-like and pipe characters)
+  args[url]="${(qq)args[url]}"
+  if [[ -n "${args[branch]}" ]]; then
+    args[branch]="${(qq)args[branch]}"
+  fi
+  
+  # Escape bundle name (may contain semver-like characters)
+  args[name]="${(qq)args[name]}"
+
+  eval "${var}=(${(kv)args})"
+
+  return 0
+}
+# Updates revert-info data with git hash.
+#
+# This does process only cloned bundles.
+#
+# Usage
+#    -antigen-revert-info
+#
+# Returns
+#    Nothing. Generates/updates $ADOTDIR/revert-info.
+-antigen-revert-info() {
+  local url
+  # Update your bundles, i.e., `git pull` in all the plugin repos.
+  date >! $ADOTDIR/revert-info
+
+  -antigen-get-cloned-bundles | while read url; do
+    local clone_dir="$(-antigen-get-clone-dir "$url")"
+    if [[ -d "$clone_dir" ]]; then
+      (echo -n "$clone_dir:"
+        \cd -q "$clone_dir"
+        git rev-parse HEAD) >> $ADOTDIR/revert-info
+    fi
+  done
+}
+-antigen-use-oh-my-zsh () {
+  typeset -g ZSH ZSH_CACHE_DIR
+  ANTIGEN_DEFAULT_REPO_URL=$ANTIGEN_OMZ_REPO_URL
+  if [[ -z "$ZSH" ]]; then
+    ZSH="$(-antigen-get-clone-dir "$ANTIGEN_DEFAULT_REPO_URL")"
+  fi
+  if [[ -z "$ZSH_CACHE_DIR" ]]; then
+    ZSH_CACHE_DIR="$ZSH/cache/"
+  fi
+  antigen-bundle --loc=lib
+}
+-antigen-use-prezto () {
+  ANTIGEN_DEFAULT_REPO_URL=$ANTIGEN_PREZTO_REPO_URL
+  antigen-bundle "$ANTIGEN_PREZTO_REPO_URL"
+}
+# Initialize completion
+antigen-apply () {
+  LOG "Called antigen-apply"
+
+  # Load the compinit module. This will readefine the `compdef` function to
+  # the one that actually initializes completions.
+  TRACE "Gonna create compdump file @ apply" COMPDUMP
+  autoload -Uz compinit
+  compinit -d "$ANTIGEN_COMPDUMP"
+
+  # Apply all `compinit`s that have been deferred.
+  local cdef
+  for cdef in "${__deferred_compdefs[@]}"; do
+    compdef "$cdef"
+  done
+
+  { zcompile "$ANTIGEN_COMPDUMP" } &!
+
+  unset __deferred_compdefs
+}
+# Syntaxes
+#   antigen-bundle <url> [<loc>=/]
+# Keyword only arguments:
+#   branch - The branch of the repo to use for this bundle.
+antigen-bundle () {
+  TRACE "Called antigen-bundle with $@" BUNDLE
+  if [[ -z "$1" ]]; then
+    printf "Antigen: Must provide a bundle url or name.\n" >&2
+    return 1
+  fi
+
+  builtin typeset -A bundle; -antigen-parse-args 'bundle' ${=@}
+  if [[ -z ${bundle[btype]} ]]; then
+    bundle[btype]=bundle
+  fi
+
+  local record="${bundle[url]} ${bundle[loc]} ${bundle[btype]} ${bundle[make_local_clone]}"
+  if [[ $_ANTIGEN_WARN_DUPLICATES == true && ! ${_ANTIGEN_BUNDLE_RECORD[(I)$record]} == 0 ]]; then
+    printf "Seems %s is already installed!\n" ${bundle[name]}
+    return 1
+  fi
+ 
+  # Clone bundle if we haven't done do already.
+  if [[ ! -d "${bundle[dir]}" ]]; then
+    if ! -antigen-bundle-install ${(kv)bundle}; then
+      return 1
+    fi
+  fi
+
+  # Load the plugin.
+  if ! -antigen-load ${(kv)bundle}; then
+    TRACE "-antigen-load failed to load ${bundle[name]}" BUNDLE
+    printf "Antigen: Failed to load %s.\n" ${bundle[btype]} >&2
+    return 1
+  fi
+  
+  # Only add it to the record if it could be installed and loaded.
+  _ANTIGEN_BUNDLE_RECORD+=("$record")
+}
+
+#
+# Usage:
+#   -antigen-bundle-install <record>
+# Returns:
+#   1 if it fails to install bundle
+-antigen-bundle-install () {
+  typeset -A bundle; bundle=($@)
+
+  # Ensure a clone exists for this repo, if needed.
+  # Get the clone's directory as per the given repo url and branch.
+  local bpath="${bundle[dir]}"
+  # Clone if it doesn't already exist.
+  local start=$(date +'%s')
+
+  printf "Installing %s... " "${bundle[name]}"
+
+  if ! -antigen-ensure-repo "${bundle[url]}"; then
+    # Return immediately if there is an error cloning
+    TRACE "-antigen-bundle-instal failed to clone ${bundle[url]}" BUNDLE
+    printf "Error! Activate logging and try again.\n" >&2
+    return 1
+  fi
+
+  local took=$(( $(date +'%s') - $start ))
+  printf "Done. Took %ds.\n" $took
+}
+antigen-bundles () {
+  # Bulk add many bundles at one go. Empty lines and lines starting with a `#`
+  # are ignored. Everything else is given to `antigen-bundle` as is, no
+  # quoting rules applied.
+  local line
+  setopt localoptions no_extended_glob # See https://github.com/zsh-users/antigen/issues/456
+  grep '^[[:space:]]*[^[:space:]#]' | while read line; do
+    antigen-bundle ${=line%#*}
+  done
+}
+# Cleanup unused repositories.
+antigen-cleanup () {
+  local force=false
+  if [[ $1 == --force ]]; then
+    force=true
+  fi
+
+  if [[ ! -d "$ANTIGEN_BUNDLES" || -z "$(\ls -A "$ANTIGEN_BUNDLES")" ]]; then
+    echo "You don't have any bundles."
+    return 0
+  fi
+
+  # Find directores in ANTIGEN_BUNDLES, that are not in the bundles record.
+  typeset -a unused_clones clones
+
+  local url record clone
+  for record in $(-antigen-get-cloned-bundles); do
+    url=${record% /*}
+    clones+=("$(-antigen-get-clone-dir $url)")
+  done
+
+  for clone in $ANTIGEN_BUNDLES/*/*(/); do
+    if [[ $clones[(I)$clone] == 0 ]]; then
+      unused_clones+=($clone)
+    fi
+  done
+
+  if [[ -z $unused_clones ]]; then
+    echo "You don't have any unidentified bundles."
+    return 0
+  fi
+
+  echo 'You have clones for the following repos, but are not used.'
+  echo "\n${(j:\n:)unused_clones}"
+
+  if $force || (echo -n '\nDelete them all? [y/N] '; read -q); then
+    echo
+    echo
+    for clone in $unused_clones; do
+      echo -n "Deleting clone \"$clone\"..."
+      \rm -rf "$clone"
+
+      echo ' done.'
+    done
+  else
+    echo
+    echo "Nothing deleted."
+  fi
+}
+antigen-help () {
+  antigen-version
+
+  cat <<EOF
+
+Antigen is a plugin management system for zsh. It makes it easy to grab awesome
+shell scripts and utilities, put up on Github.
+
+Usage: antigen <command> [args]
+
+Commands:
+  apply        Must be called in the zshrc after all calls to 'antigen bundle'.
+  bundle       Install and load a plugin.
+  cache-gen    Generate Antigen's cache with currently loaded bundles.
+  cleanup      Remove clones of repos not used by any loaded plugins.
+  init         Use caching to quickly load bundles.
+  list         List currently loaded plugins.
+  purge        Remove a bundle from the filesystem.
+  reset        Clean the generated cache.
+  restore      Restore plugin state from a snapshot file.
+  revert       Revert plugins to their state prior to the last time 'antigen
+               update' was run.
+  selfupdate   Update antigen.
+  snapshot     Create a snapshot of all active plugin repos and save it to a
+               snapshot file.
+  update       Update plugins.
+  use          Load a supported zsh pre-packaged framework.
+
+For further details and complete documentation, visit the project's page at
+'http://antigen.sharats.me'.
+EOF
+}
+# Antigen command to load antigen configuration
+#
+# This method is slighlty more performing than using various antigen-* methods.
+#
+# Usage
+#   Referencing an antigen configuration file:
+#
+#       antigen-init "/path/to/antigenrc"
+#
+#   or using HEREDOCS:
+#
+#       antigen-init <<EOBUNDLES
+#           antigen use oh-my-zsh
+#
+#           antigen bundle zsh/bundle
+#           antigen bundle zsh/example
+#
+#           antigen theme zsh/theme
+#
+#           antigen apply
+#       EOBUNDLES
+#
+# Returns
+#   Nothing
+antigen-init () {
+  local src="$1" line
+
+  # If we're given an argument it should be a path to a file
+  if [[ -n "$src" ]]; then
+    if [[ -f "$src" ]]; then
+      source "$src"
+      return
+    else
+      printf "Antigen: invalid argument provided.\n" >&2
+      return 1
+    fi
+  fi
+
+  # Otherwise we expect it to be a heredoc
+  grep '^[[:space:]]*[^[:space:]#]' | while read -r line; do
+    eval $line
+  done
+}
+# List instaled bundles either in long (record), short or simple format.
+#
+# Usage
+#    antigen-list [--short|--long|--simple]
+#
+# Returns
+#    List of bundles
+antigen-list () {
+  local format=$1
+
+  # List all currently installed bundles.
+  if [[ -z $_ANTIGEN_BUNDLE_RECORD ]]; then
+    echo "You don't have any bundles." >&2
+    return 1
+  fi
+
+  -antigen-get-bundles $format
+}
+# Remove a bundle from filesystem
+#
+# Usage
+#   antigen-purge example/bundle [--force]
+#
+# Returns
+#   Nothing. Removes bundle from filesystem.
+antigen-purge () {
+  local bundle=$1
+  local force=$2
+
+  if [[ $# -eq 0  ]]; then
+    echo "Antigen: Missing argument." >&2
+    return 1
+  fi
+
+  if -antigen-purge-bundle $bundle $force; then
+    antigen-reset
+  else
+    return $?
+  fi
+
+  return 0
+}
+
+# Remove a bundle from filesystem
+#
+# Usage
+#   antigen-purge example/bundle [--force]
+#
+# Returns
+#   Nothing. Removes bundle from filesystem.
+-antigen-purge-bundle () {
+  local bundle=$1
+  local force=$2
+  local clone_dir=""
+
+  local record=""
+  local url=""
+  local make_local_clone=""
+
+  if [[ $# -eq 0  ]]; then
+    echo "Antigen: Missing argument." >&2
+    return 1
+  fi
+
+  # local keyword doesn't work on zsh <= 5.0.0
+  record=$(-antigen-find-record $bundle)
+
+  if [[ ! -n "$record" ]]; then
+    echo "Bundle not found in record. Try 'antigen bundle $bundle' first." >&2
+    return 1
+  fi
+
+  url="$(echo "$record" | cut -d' ' -f1)"
+  make_local_clone=$(echo "$record" | cut -d' ' -f4)
+
+  if [[ $make_local_clone == "false" ]]; then
+    echo "Bundle has no local clone. Will not be removed." >&2
+    return 1
+  fi
+
+  clone_dir=$(-antigen-get-clone-dir "$url")
+  if [[ $force == "--force" ]] || read -q "?Remove '$clone_dir'? (y/n) "; then
+    # Need empty line after read -q
+    [[ ! -n $force ]] && echo "" || echo "Removing '$clone_dir'.";
+    rm -rf "$clone_dir"
+    return $?
+  fi
+
+  return 1
+}
+# Removes cache payload and metadata if available
+#
+# Usage
+#   antigen-reset
+#
+# Returns
+#   Nothing
+antigen-reset () {
+  [[ -f "$ANTIGEN_CACHE" ]] && rm -f "$ANTIGEN_CACHE" "$ANTIGEN_CACHE.zwc" 1> /dev/null
+  [[ -f "$ANTIGEN_RSRC" ]] && rm -f "$ANTIGEN_RSRC" 1> /dev/null
+  [[ -f "$ANTIGEN_COMPDUMP" ]] && rm -f "$ANTIGEN_COMPDUMP" "$ANTIGEN_COMPDUMP.zwc" 1> /dev/null
+  [[ -f "$ANTIGEN_LOCK" ]] && rm -f "$ANTIGEN_LOCK" 1> /dev/null
+  echo 'Done. Please open a new shell to see the changes.'
+}
+antigen-restore () {
+  local line
+  if [[ $# == 0 ]]; then
+    echo 'Please provide a snapshot file to restore from.' >&2
+    return 1
+  fi
+
+  local snapshot_file="$1"
+
+  # TODO: Before doing anything with the snapshot file, verify its checksum.
+  # If it fails, notify this to the user and confirm if restore should
+  # proceed.
+
+  echo -n "Restoring from $snapshot_file..."
+
+  sed -n '1!p' "$snapshot_file" |
+    while read line; do
+      local version_hash="${line%% *}"
+      local url="${line##* }"
+      local clone_dir="$(-antigen-get-clone-dir "$url")"
+
+      if [[ ! -d $clone_dir ]]; then
+          git clone "$url" "$clone_dir" &> /dev/null
+      fi
+
+      (\cd -q "$clone_dir" && git checkout $version_hash) &> /dev/null
+    done
+
+  echo ' done.'
+  echo 'Please open a new shell to get the restored changes.'
+}
+# Reads $ADORDIR/revert-info and restores bundles' revision
+antigen-revert () {
+  local line
+  if [[ -f $ADOTDIR/revert-info ]]; then
+    cat $ADOTDIR/revert-info | sed -n '1!p' | while read line; do
+      local dir="$(echo "$line" | cut -d: -f1)"
+      git --git-dir="$dir/.git" --work-tree="$dir" \
+        checkout "$(echo "$line" | cut -d: -f2)" 2> /dev/null
+    done
+
+    echo "Reverted to state before running -update on $(
+            cat $ADOTDIR/revert-info | sed -n '1p')."
+
+  else
+    echo 'No revert information available. Cannot revert.' >&2
+    return 1
+  fi
+}
+# Update (with `git pull`) antigen itself.
+# TODO: Once update is finished, show a summary of the new commits, as a kind of
+# "what's new" message.
+antigen-selfupdate () {
+  (\cd -q $_ANTIGEN_INSTALL_DIR
+   if [[ ! ( -d .git || -f .git ) ]]; then
+     echo "Your copy of antigen doesn't appear to be a git clone. " \
+       "The 'selfupdate' command cannot work in this case."
+     return 1
+   fi
+   local head="$(git rev-parse --abbrev-ref HEAD)"
+   if [[ $head == "HEAD" ]]; then
+     # If current head is detached HEAD, checkout to master branch.
+     git checkout master
+   fi
+   git pull
+
+   # TODO Should be transparently hooked by zcache
+   antigen-reset &>> /dev/null
+  )
+}
+antigen-snapshot () {
+  local snapshot_file="${1:-antigen-shapshot}"
+  local urls url dir version_hash snapshot_content
+  local -a bundles
+
+  # The snapshot content lines are pairs of repo-url and git version hash, in
+  # the form:
+  #   <version-hash> <repo-url>
+  urls=$(-antigen-echo-record | awk '$4 == "true" {print $1}' | sort -u)
+  for url in ${(f)urls}; do
+    dir="$(-antigen-get-clone-dir "$url")"
+    version_hash="$(\cd -q "$dir" && git rev-parse HEAD)"
+    bundles+=("$version_hash $url");
+  done
+  snapshot_content=${(j:\n:)bundles}
+
+  {
+    # The first line in the snapshot file is for metadata, in the form:
+    #   key='value'; key='value'; key='value';
+    # Where `key`s are valid shell variable names.
+
+    # Snapshot version. Has no relation to antigen version. If the snapshot
+    # file format changes, this number can be incremented.
+    echo -n "version='1';"
+
+    # Snapshot creation date+time.
+    echo -n " created_on='$(date)';"
+
+    # Add a checksum with the md5 checksum of all the snapshot lines.
+    chksum() { (md5sum; test $? = 127 && md5) 2>/dev/null | cut -d' ' -f1 }
+    local checksum="$(echo "$snapshot_content" | chksum)"
+    unset -f chksum;
+    echo -n " checksum='${checksum%% *}';"
+
+    # A newline after the metadata and then the snapshot lines.
+    echo "\n$snapshot_content"
+
+  } > "$snapshot_file"
+}
+# Loads a given theme.
+#
+# Shares the same syntax as antigen-bundle command.
+#
+# Usage
+#   antigen-theme zsh/theme[.zsh-theme]
+#
+# Returns
+#   0 if everything was succesfully
+antigen-theme () {
+  local name=$1 result=0 record
+  local match mbegin mend MATCH MBEGIN MEND
+
+  if [[ -z "$1" ]]; then
+    printf "Antigen: Must provide a theme url or name.\n" >&2
+    return 1
+  fi
+
+  -antigen-theme-reset-hooks
+
+  record=$(-antigen-find-record "theme")
+  if [[ "$1" != */* && "$1" != --* ]]; then
+    # The first argument is just a name of the plugin, to be picked up from
+    # the default repo.
+    antigen-bundle --loc=themes/$name --btype=theme
+
+  else
+    antigen-bundle "$@" --btype=theme
+
+  fi
+  result=$?
+
+  # Remove a theme from the record if the following conditions apply:
+  #   - there was no error in bundling the given theme
+  #   - there is a theme registered
+  #   - registered theme is not the same as the current one
+  if [[ $result == 0 && -n $record ]]; then
+    # http://zsh-workers.zsh.narkive.com/QwfCWpW8/what-s-wrong-with-this-expression
+    if [[ "$record" =~ "$@" ]]; then
+      return $result
+    else
+      _ANTIGEN_BUNDLE_RECORD[$_ANTIGEN_BUNDLE_RECORD[(I)$record]]=()
+    fi
+  fi
+
+  return $result
+}
+
+-antigen-theme-reset-hooks () {
+  # This is only needed on interactive mode
+  autoload -U add-zsh-hook is-at-least
+  local hook
+
+  # Clear out prompts
+  PROMPT=""
+  if [[ -n $RPROMPT ]]; then
+    RPROMPT=""
+  fi
+
+  for hook in chpwd precmd preexec periodic; do
+    add-zsh-hook -D "${hook}" "prompt_*"
+    # common in omz themes
+    add-zsh-hook -D "${hook}" "*_${hook}"
+    add-zsh-hook -d "${hook}" "vcs_info"
+  done
+}
+# Updates the bundles or a single bundle.
+#
+# Usage
+#    antigen-update [example/bundle]
+#
+# Returns
+#    Nothing. Performs a `git pull`.
+antigen-update () {
+  local bundle=$1 url
+
+  # Clear log
+  :> $ANTIGEN_LOG
+
+  # Update revert-info data
+  -antigen-revert-info
+
+  # If no argument is given we update all bundles
+  if [[ $# -eq 0  ]]; then
+    # Here we're ignoring all non cloned bundles (ie, --no-local-clone)
+    -antigen-get-cloned-bundles | while read url; do
+      -antigen-update-bundle $url
+    done
+    # TODO next minor version
+    # antigen-reset
+  else
+    if -antigen-update-bundle $bundle; then
+      # TODO next minor version
+      # antigen-reset
+    else
+      return $?
+    fi
+  fi
+}
+
+# Updates a bundle performing a `git pull`.
+#
+# Usage
+#    -antigen-update-bundle example/bundle
+#
+# Returns
+#    Nothing. Performs a `git pull`.
+-antigen-update-bundle () {
+  local bundle="$1"
+  local record=""
+  local url=""
+  local make_local_clone=""
+  local start=$(date +'%s')
+    
+  if [[ $# -eq 0 ]]; then
+    printf "Antigen: Missing argument.\n" >&2
+    return 1
+  fi
+
+  record=$(-antigen-find-record $bundle)
+  if [[ ! -n "$record" ]]; then
+    printf "Bundle not found in record. Try 'antigen bundle %s' first.\n" $bundle >&2
+    return 1
+  fi
+
+  url="$(echo "$record" | cut -d' ' -f1)"
+  make_local_clone=$(echo "$record" | cut -d' ' -f4)
+  
+  local branch="master"
+  if [[ $url == *\|* ]]; then
+    branch="$(-antigen-parse-branch ${url%|*} ${url#*|})"
+  fi
+
+  printf "Updating %s... " $(-antigen-bundle-short-name "$url" "$branch")
+  
+  if [[ $make_local_clone == "false" ]]; then
+    printf "Bundle has no local clone. Will not be updated.\n" >&2
+    return 1
+  fi
+
+  # update=true verbose=false
+  if ! -antigen-ensure-repo "$url" true false; then
+    printf "Error! Activate logging and try again.\n" >&2
+    return 1
+  fi
+  
+  local took=$(( $(date +'%s') - $start ))
+  printf "Done. Took %ds.\n" $took
+}
+antigen-use () {
+  if [[ $1 == oh-my-zsh ]]; then
+    -antigen-use-oh-my-zsh
+  elif [[ $1 == prezto ]]; then
+    -antigen-use-prezto
+  elif [[ $1 != "" ]]; then
+    ANTIGEN_DEFAULT_REPO_URL=$1
+    antigen-bundle $@
+  else
+    echo 'Usage: antigen-use <library-name|url>' >&2
+    echo 'Where <library-name> is any one of the following:' >&2
+    echo ' * oh-my-zsh' >&2
+    echo ' * prezto' >&2
+    echo '<url> is the full url.' >&2
+    return 1
+  fi
+}
+antigen-version () {
+  local version="v2.2.2"
+  local extensions revision=""
+  if [[ -d $_ANTIGEN_INSTALL_DIR/.git ]]; then
+    revision=" ($(git --git-dir=$_ANTIGEN_INSTALL_DIR/.git rev-parse --short '@'))"
+  fi
+
+  printf "Antigen %s%s\n" $version $revision
+  if (( $+functions[antigen-ext] )); then
+    typeset -a extensions; extensions=($(antigen-ext-list))
+    if [[ $#extensions -gt 0 ]]; then
+      printf "Extensions loaded: %s\n" ${(j:, :)extensions}
+    fi
+  fi
+}
+typeset -Ag _ANTIGEN_HOOKS; _ANTIGEN_HOOKS=()
+typeset -Ag _ANTIGEN_HOOKS_META; _ANTIGEN_HOOKS_META=()
+typeset -g _ANTIGEN_HOOK_PREFIX="-antigen-hook-"
+typeset -g _ANTIGEN_EXTENSIONS; _ANTIGEN_EXTENSIONS=()
+
+# -antigen-add-hook antigen-apply antigen-apply-hook replace
+#   - Replaces hooked function with hook, do not call hooked function
+#   - Return -1 to stop calling further hooks
+# -antigen-add-hook antigen-apply antigen-apply-hook pre (pre-call)
+#   - By default it will call hooked function
+# -antigen-add-hook antigen-pply antigen-apply-hook post (post-call)
+#   - Calls antigen-apply and then calls hook function
+# Usage:
+#  -antigen-add-hook antigen-apply antigen-apply-hook ["replace"|"pre"|"post"] ["once"|"repeat"]
+antigen-add-hook () {
+  local target="$1" hook="$2" type="$3" mode="${4:-repeat}"
+  
+  if (( ! $+functions[$target] )); then
+    printf "Antigen: Function %s doesn't exist.\n" $target
+    return 1
+  fi
+
+  if (( ! $+functions[$hook] )); then
+    printf "Antigen: Function %s doesn't exist.\n" $hook
+    return 1
+  fi
+
+  if [[ "${_ANTIGEN_HOOKS[$target]}" == "" ]]; then
+    _ANTIGEN_HOOKS[$target]="${hook}"
+  else
+    _ANTIGEN_HOOKS[$target]="${_ANTIGEN_HOOKS[$target]}:${hook}"
+  fi
+
+  _ANTIGEN_HOOKS_META[$hook]="target $target type $type mode $mode called 0"
+  
+  # Do shadow for this function if there is none already
+  local hook_function="${_ANTIGEN_HOOK_PREFIX}$target"
+  if (( ! $+functions[$hook_function] )); then
+    # Preserve hooked function
+    eval "function ${_ANTIGEN_HOOK_PREFIX}$(functions -- $target)"
+
+    # Create hook, call hook-handler to further process hook functions
+    eval "function $target () {
+      noglob -antigen-hook-handler $target \$@
+      return \$?
+    }"
+  fi
+  
+  return 0
+}
+
+# Private function to handle multiple hooks in a central point.
+-antigen-hook-handler () {
+  local target="$1" args hook called
+  local hooks meta
+  shift
+  typeset -a args; args=(${@})
+
+  typeset -a pre_hooks replace_hooks post_hooks;
+  typeset -a hooks; hooks=(${(s|:|)_ANTIGEN_HOOKS[$target]})
+  
+  typeset -A meta;
+  for hook in $hooks; do
+    meta=(${(s: :)_ANTIGEN_HOOKS_META[$hook]})
+    if [[ ${meta[mode]} == "once" && ${meta[called]} == 1 ]]; then
+      WARN "Ignoring hook due to mode ${meta[mode]}: $hook"
+      continue
+    fi
+
+    let called=${meta[called]}+1
+    meta[called]=$called
+    _ANTIGEN_HOOKS_META[$hook]="${(kv)meta}"
+    WARN "Updated meta: "${(kv)meta}
+
+    case "${meta[type]}" in
+      "pre")
+      pre_hooks+=($hook)
+      ;;
+      "replace")
+      replace_hooks+=($hook)
+      ;;
+      "post")
+      post_hooks+=($hook)
+      ;;
+    esac
+  done
+
+  WARN "Processing hooks: ${hooks}"
+
+  for hook in $pre_hooks; do
+    WARN "Pre hook:" $hook $args
+    noglob $hook $args
+    [[ $? == -1 ]] && WARN "$hook shortcircuited" && return $ret
+  done
+
+  # A replace hook will return inmediately
+  local replace_hook=0 ret=0
+  for hook in $replace_hooks; do
+    replace_hook=1
+    # Should not be needed if `antigen-remove-hook` removed unneeded hooks.
+    if (( $+functions[$hook] )); then
+      WARN "Replace hook:" $hook $args
+      noglob $hook $args
+      [[ $? == -1 ]] && WARN "$hook shortcircuited" && return $ret
+    fi
+  done
+  
+  if [[ $replace_hook == 0 ]]; then
+    WARN "${_ANTIGEN_HOOK_PREFIX}$target $args"
+    noglob ${_ANTIGEN_HOOK_PREFIX}$target $args
+    ret=$?
+  else
+    WARN "Replaced hooked function."
+  fi
+
+  for hook in $post_hooks; do
+    WARN "Post hook:" $hook $args
+    noglob $hook $args
+    [[ $? == -1 ]] && WARN "$hook shortcircuited" && return $ret
+  done
+  
+  LOG "Return from hook ${target} with ${ret}"
+
+  return $ret
+}
+
+# Usage:
+#  -antigen-remove-hook antigen-apply-hook
+antigen-remove-hook () {
+  local hook="$1"
+  typeset -A meta; meta=(${(s: :)_ANTIGEN_HOOKS_META[$hook]})
+  local target="${meta[target]}"
+  local -a hooks; hooks=(${(s|:|)_ANTIGEN_HOOKS[$target]})
+
+  # Remove registered hook
+  if [[ $#hooks > 0 ]]; then
+    hooks[$hooks[(I)$hook]]=()
+  fi
+  _ANTIGEN_HOOKS[${target}]="${(j|:|)hooks}"
+  
+  if [[ $#hooks == 0 ]]; then
+    # Destroy base hook
+    eval "function $(functions -- ${_ANTIGEN_HOOK_PREFIX}$target | sed s/${_ANTIGEN_HOOK_PREFIX}//)"
+    if (( $+functions[${_ANTIGEN_HOOK_PREFIX}$target] )); then
+      unfunction -- "${_ANTIGEN_HOOK_PREFIX}$target"
+    fi
+  fi
+
+  unfunction -- $hook 2> /dev/null
+}
+
+# Remove all defined hooks.
+-antigen-reset-hooks () {
+  local target
+
+  for target in ${(k)_ANTIGEN_HOOKS}; do
+    # Release all hooked functions
+    eval "function $(functions -- ${_ANTIGEN_HOOK_PREFIX}$target | sed s/${_ANTIGEN_HOOK_PREFIX}//)"
+    unfunction -- "${_ANTIGEN_HOOK_PREFIX}$target" 2> /dev/null
+  done
+  
+  _ANTIGEN_HOOKS=()
+  _ANTIGEN_HOOKS_META=()
+  _ANTIGEN_EXTENSIONS=()
+}
+
+# Initializes an extension
+# Usage:
+#  antigen-ext ext-name
+antigen-ext () {
+  local ext=$1
+  local func="-antigen-$ext-init"
+  if (( $+functions[$func] && $_ANTIGEN_EXTENSIONS[(I)$ext] == 0 )); then
+    eval $func
+    local ret=$?
+    WARN "$func return code was $ret"
+    if (( $ret == 0 )); then 
+      LOG "LOADED EXTENSION $ext" EXT
+      -antigen-$ext-execute && _ANTIGEN_EXTENSIONS+=($ext)
+    else
+      WARN "IGNORING EXTENSION $func" EXT
+      return 1
+    fi
+    
+  else
+    printf "Antigen: No extension defined or already loaded: %s\n" $func >&2
+    return 1
+  fi
+}
+
+# List installed extensions
+# Usage:
+#   antigen ext-list
+antigen-ext-list () {
+  echo $_ANTIGEN_EXTENSIONS
+}
+
+# Initializes built-in extensions
+# Usage:
+#   antigen-ext-init
+antigen-ext-init () {
+  # Initialize extensions. unless in interactive mode.
+  local ext
+  for ext in ${(s/ /)_ANTIGEN_BUILTIN_EXTENSIONS}; do
+    # Check if extension is loaded before intializing it
+    (( $+functions[-antigen-$ext-init] )) && antigen-ext $ext
+  done
+}
+# Initialize defer lib
+-antigen-defer-init () {
+  typeset -ga _DEFERRED_BUNDLE; _DEFERRED_BUNDLE=()
+  if -antigen-interactive-mode; then
+    return 1
+  fi
+}
+
+-antigen-defer-execute () {
+  # Hooks antigen-bundle in order to defer its execution.
+  antigen-bundle-defer () {
+    _DEFERRED_BUNDLE+=("${(j: :)${@}}")
+    return -1 # Stop right there
+  }
+  antigen-add-hook antigen-bundle antigen-bundle-defer replace
+  
+  # Hooks antigen-apply in order to release hooked functions
+  antigen-apply-defer () {
+    WARN "Defer pre-apply" DEFER PRE-APPLY
+    antigen-remove-hook antigen-bundle-defer
+
+    # Process all deferred bundles.
+    local bundle
+    for bundle in ${_DEFERRED_BUNDLE[@]}; do
+      LOG "Processing deferred bundle: ${bundle}" DEFER
+      antigen-bundle $bundle
+    done
+
+    unset _DEFERRED_BUNDLE
+  }
+  antigen-add-hook antigen-apply antigen-apply-defer pre once
+}
+# Initialize lock lib
+-antigen-lock-init () {
+  # Default lock path.
+  -antigen-set-default ANTIGEN_LOCK $ADOTDIR/.lock
+  typeset -g _ANTIGEN_LOCK_PROCESS=false
+  
+  # Use env variable to determine if we should load this extension
+  -antigen-set-default ANTIGEN_MUTEX true
+  # Set ANTIGEN_MUTEX to false to avoid loading this extension
+  if [[ $ANTIGEN_MUTEX == true ]]; then
+    return 0;
+  fi
+  
+  # Do not use mutex
+  return 1;
+}
+
+-antigen-lock-execute () {
+  # Hook antigen command in order to check/create a lock file.
+  # This hook is only run once then releases itself.
+  antigen-lock () {
+    LOG "antigen-lock called"
+    # If there is a lock set up then we won't process anything.
+    if [[ -f $ANTIGEN_LOCK ]]; then
+      # Set up flag do the message is not repeated for each antigen-* command
+      [[ $_ANTIGEN_LOCK_PROCESS == false ]] && printf "Antigen: Another process in running.\n"
+      _ANTIGEN_LOCK_PROCESS=true
+      # Do not further process hooks. For this hook to properly work it
+      # should be registered first.
+      return -1
+    fi
+
+    WARN "Creating antigen-lock file at $ANTIGEN_LOCK"
+    touch $ANTIGEN_LOCK
+  }
+  antigen-add-hook antigen antigen-lock pre once
+
+  # Hook antigen-apply in order to release .lock file.
+  antigen-apply-lock () {
+    WARN "Freeing antigen-lock file at $ANTIGEN_LOCK"
+    unset _ANTIGEN_LOCK_PROCESS
+    rm -f $ANTIGEN_LOCK &> /dev/null
+  }
+  antigen-add-hook antigen-apply antigen-apply-lock post once
+}
+# Initialize parallel lib
+-antigen-parallel-init () {
+  WARN "Init parallel extension" PARALLEL
+  typeset -ga _PARALLEL_BUNDLE; _PARALLEL_BUNDLE=()
+  if -antigen-interactive-mode; then
+    return 1
+  fi
+}
+
+-antigen-parallel-execute() {
+  WARN "Exec parallel extension" PARALLEL
+  # Install bundles in parallel
+  antigen-bundle-parallel-execute () {
+    WARN "Parallel antigen-bundle-parallel-execute" PARALLEL
+    typeset -a pids; pids=()
+    local args pid
+
+    WARN "Gonna install in parallel ${#_PARALLEL_BUNDLE} bundles." PARALLEL
+    # Do ensure-repo in parallel
+    WARN "${_PARALLEL_BUNDLE}" PARALLEL
+    typeset -Ua repositories # Used to keep track of cloned repositories to avoid
+                             # trying to clone it multiple times.
+    for args in ${_PARALLEL_BUNDLE}; do
+      typeset -A bundle; -antigen-parse-args 'bundle' ${=args}
+
+      if [[ ! -d ${bundle[dir]} && $repositories[(I)${bundle[url]}] == 0 ]]; then
+        WARN "Install in parallel ${bundle[name]}." PARALLEL
+        echo "Installing ${bundle[name]}!..."
+        # $bundle[url]'s format is "url|branch" as to create "$ANTIGEN_BUNDLES/bundle/name-branch",
+        # this way you may require multiple branches from the same repository.
+        -antigen-ensure-repo "${bundle[url]}" > /dev/null &!
+        pids+=($!)
+      else
+        WARN "Bundle ${bundle[name]} already cloned locally." PARALLEL
+      fi
+      
+      repositories+=(${bundle[url]})
+    done
+
+    # Wait for all background processes to end
+    while [[ $#pids > 0 ]]; do
+      for pid in $pids; do
+        # `ps` may diplay an error message such "Signal 18 (CONT) caught by ps
+        # (procps-ng version 3.3.9).", see https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=732410
+        if [[ $(ps -o pid= -p $pid 2>/dev/null) == "" ]]; then
+          pids[$pids[(I)$pid]]=()
+        fi
+      done
+      sleep .5
+    done
+
+    builtin local bundle &> /dev/null
+    for bundle in ${_PARALLEL_BUNDLE[@]}; do
+      antigen-bundle $bundle
+    done
+    
+
+    WARN "Parallel install done" PARALLEL
+  }
+
+  # Hooks antigen-apply in order to release hooked functions
+  antigen-apply-parallel () {
+    WARN "Parallel pre-apply" PARALLEL PRE-APPLY
+    #antigen-remove-hook antigen-pre-apply-parallel
+    # Hooks antigen-bundle in order to parallel its execution.
+    antigen-bundle-parallel () {
+      TRACE "antigen-bundle-parallel: $@" PARALLEL
+      _PARALLEL_BUNDLE+=("${(j: :)${@}}")
+    }
+    antigen-add-hook antigen-bundle antigen-bundle-parallel replace
+  }
+  antigen-add-hook antigen-apply antigen-apply-parallel pre once
+  
+  antigen-apply-parallel-execute () {
+      WARN "Parallel replace-apply" PARALLEL REPLACE-APPLY
+      antigen-remove-hook antigen-bundle-parallel
+      # Process all parallel bundles.
+      antigen-bundle-parallel-execute
+
+      unset _PARALLEL_BUNDLE
+      antigen-remove-hook antigen-apply-parallel-execute
+      antigen-apply
+  }
+  antigen-add-hook antigen-apply antigen-apply-parallel-execute replace once
+}
+typeset -ga _ZCACHE_BUNDLE_SOURCE _ZCACHE_CAPTURE_BUNDLE
+typeset -g _ZCACHE_CAPTURE_PREFIX
+
+# Generates cache from listed bundles.
+#
+# Iterates over _ANTIGEN_BUNDLE_RECORD and join all needed sources into one,
+# if this is done through -antigen-load-list.
+# Result is stored in ANTIGEN_CACHE.
+#
+# _ANTIGEN_BUNDLE_RECORD and fpath is stored in cache.
+#
+# Usage
+#   -zcache-generate-cache
+#
+# Returns
+#   Nothing. Generates ANTIGEN_CACHE
+-antigen-cache-generate () {
+  local -aU _fpath _PATH _sources
+  local record
+
+  LOG "Gonna generate cache for $_ZCACHE_BUNDLE_SOURCE"
+  for record in $_ZCACHE_BUNDLE_SOURCE; do
+    record=${record:A}
+    # LOG "Caching $record"
+    if [[ -f $record ]]; then
+      # Adding $'\n' as a suffix as j:\n: doesn't work inside a heredoc.
+      if [[ $_ANTIGEN_THEME_COMPAT == true && "$record" == *.zsh-theme* ]]; then
+        local compat="${record:A}.antigen-compat"
+        echo "# Generated by Antigen. Do not edit!" >! "$compat"
+        cat $record | sed -Ee '/\{$/,/^\}/!{
+             s/^local //
+         }' >>! "$compat"
+        record="$compat"
+      fi
+      _sources+=("source '${record}';"$'\n')
+    elif [[ -d $record ]]; then
+      _PATH+=("${record}")
+      _fpath+=("${record}")
+    fi
+  done
+
+cat > $ANTIGEN_CACHE <<EOC
+#-- START ZCACHE GENERATED FILE
+#-- GENERATED: $(date)
+#-- ANTIGEN v2.2.2
+$(functions -- _antigen)
+antigen () {
+  local MATCH MBEGIN MEND
+  [[ "\$ZSH_EVAL_CONTEXT" =~ "toplevel:*" || "\$ZSH_EVAL_CONTEXT" =~ "cmdarg:*" ]] && source "$_ANTIGEN_INSTALL_DIR/antigen.zsh" && eval antigen \$@;
+  return 0;
+}
+typeset -gaU fpath path
+fpath+=(${_fpath[@]}) path+=(${_PATH[@]})
+_antigen_compinit () {
+  autoload -Uz compinit; compinit -d "$ANTIGEN_COMPDUMP"; compdef _antigen antigen
+  add-zsh-hook -D precmd _antigen_compinit
+}
+autoload -Uz add-zsh-hook; add-zsh-hook precmd _antigen_compinit
+compdef () {}
+
+if [[ -n "$ZSH" ]]; then
+  ZSH="$ZSH"; ZSH_CACHE_DIR="$ZSH_CACHE_DIR"
+fi
+#--- BUNDLES BEGIN
+${(j::)_sources}
+#--- BUNDLES END
+typeset -gaU _ANTIGEN_BUNDLE_RECORD; _ANTIGEN_BUNDLE_RECORD=($(print ${(qq)_ANTIGEN_BUNDLE_RECORD}))
+typeset -g _ANTIGEN_CACHE_LOADED; _ANTIGEN_CACHE_LOADED=true
+typeset -ga _ZCACHE_BUNDLE_SOURCE; _ZCACHE_BUNDLE_SOURCE=($(print ${(qq)_ZCACHE_BUNDLE_SOURCE}))
+typeset -g _ANTIGEN_CACHE_VERSION; _ANTIGEN_CACHE_VERSION='v2.2.2'
+
+#-- END ZCACHE GENERATED FILE
+EOC
+
+  { zcompile "$ANTIGEN_CACHE" } &!
+
+  # Compile config files, if any
+  LOG "CHECK_FILES $ANTIGEN_CHECK_FILES"
+  [[ $ANTIGEN_AUTO_CONFIG == true && -n $ANTIGEN_CHECK_FILES ]] && {
+    echo ${(j:\n:)ANTIGEN_CHECK_FILES} >! "$ANTIGEN_RSRC"
+    for rsrc in $ANTIGEN_CHECK_FILES; do
+      zcompile $rsrc
+    done
+  } &!
+
+  return true
+}
+
+# Initializes caching mechanism.
+#
+# Hooks `antigen-bundle` and `antigen-apply` in order to defer bundle install
+# and load. All bundles are loaded from generated cache rather than dynamically
+# as these are bundled.
+#
+# Usage
+#  -antigen-cache-init
+# Returns
+#  Nothing
+-antigen-cache-init () {
+  if -antigen-interactive-mode; then
+    return 1
+  fi
+
+  _ZCACHE_CAPTURE_PREFIX=${_ZCACHE_CAPTURE_PREFIX:-"--zcache-"}
+  _ZCACHE_BUNDLE_SOURCE=(); _ZCACHE_CAPTURE_BUNDLE=()
+
+  # Cache auto config files to check for changes (.zshrc, .antigenrc etc)
+  -antigen-set-default ANTIGEN_AUTO_CONFIG true
+  
+  # Default cache path.
+  -antigen-set-default ANTIGEN_CACHE $ADOTDIR/init.zsh
+  -antigen-set-default ANTIGEN_RSRC $ADOTDIR/.resources
+  if [[ $ANTIGEN_CACHE == false ]]; then
+    return 1
+  fi
+  
+  return 0
+}
+
+-antigen-cache-execute () {
+  # Main function. Deferred antigen-apply.
+  antigen-apply-cached () {
+    # TRACE "APPLYING CACHE" EXT
+    # Auto determine check_files
+    # There always should be 5 steps from original source as the correct way is to use
+    # `antigen` wrapper not `antigen-apply` directly and it's called by an extension.
+    LOG "TRACE: ${funcfiletrace}"
+    if [[ $ANTIGEN_AUTO_CONFIG == true && $#ANTIGEN_CHECK_FILES -eq 0 ]]; then
+      ANTIGEN_CHECK_FILES+=(~/.zshrc)
+      if [[ $#funcfiletrace -ge 6 ]]; then
+        ANTIGEN_CHECK_FILES+=("${${funcfiletrace[6]%:*}##* }")
+      fi
+    fi
+
+    # Generate and compile cache
+    -antigen-cache-generate
+    [[ -f "$ANTIGEN_CACHE" ]] && source "$ANTIGEN_CACHE";
+
+    # Commented out in order to have a working `cache-gen` command
+    #unset _ZCACHE_BUNDLE_SOURCE
+    unset _ZCACHE_CAPTURE_BUNDLE _ZCACHE_CAPTURE_FUNCTIONS
+
+    # Release all hooked functions
+    antigen-remove-hook -antigen-load-env-cached
+    antigen-remove-hook -antigen-load-source-cached
+    antigen-remove-hook antigen-bundle-cached
+  }
+  
+  antigen-add-hook antigen-apply antigen-apply-cached post once
+  
+  # Defer antigen-bundle.
+  antigen-bundle-cached () {
+    _ZCACHE_CAPTURE_BUNDLE+=("${(j: :)${@}}")
+  }
+  antigen-add-hook antigen-bundle antigen-bundle-cached pre
+  
+  # Defer loading.
+  -antigen-load-env-cached () {
+    local bundle
+    typeset -A bundle; bundle=($@)
+    local location=${bundle[dir]}/${bundle[loc]}
+    
+    # Load to path if there is no sourceable
+    if [[ ${bundle[loc]} == "/" ]]; then
+      _ZCACHE_BUNDLE_SOURCE+=("${location}")
+      return
+    fi
+
+    _ZCACHE_BUNDLE_SOURCE+=("${location}")
+  }
+  antigen-add-hook -antigen-load-env -antigen-load-env-cached replace
+  
+  # Defer sourcing.
+  -antigen-load-source-cached () {
+    _ZCACHE_BUNDLE_SOURCE+=($@)
+  }
+  antigen-add-hook -antigen-load-source -antigen-load-source-cached replace
+  
+  return 0
+}
+
+# Generate static-cache file at $ANTIGEN_CACHE using currently loaded
+# bundles from $_ANTIGEN_BUNDLE_RECORD
+#
+# Usage
+#   antigen-cache-gen
+#
+# Returns
+#   Nothing
+antigen-cache-gen () {
+  -antigen-cache-generate
+}
+#compdef _antigen
+# Setup antigen's autocompletion
+_antigen () {
+  local -a _1st_arguments
+  _1st_arguments=(
+    'apply:Load all bundle completions'
+    'bundle:Install and load the given plugin'
+    'bundles:Bulk define bundles'
+    'cleanup:Clean up the clones of repos which are not used by any bundles currently loaded'
+    'cache-gen:Generate cache'
+    'init:Load Antigen configuration from file'
+    'list:List out the currently loaded bundles'
+    'purge:Remove a cloned bundle from filesystem'
+    'reset:Clears cache'
+    'restore:Restore the bundles state as specified in the snapshot'
+    'revert:Revert the state of all bundles to how they were before the last antigen update'
+    'selfupdate:Update antigen itself'
+    'snapshot:Create a snapshot of all the active clones'
+    'theme:Switch the prompt theme'
+    'update:Update all bundles'
+    'use:Load any (supported) zsh pre-packaged framework'
+  );
+
+  _1st_arguments+=(
+    'help:Show this message'
+    'version:Display Antigen version'
+  )
+
+  __bundle() {
+    _arguments \
+      '--loc[Path to the location <path-to/location>]' \
+      '--url[Path to the repository <github-account/repository>]' \
+      '--branch[Git branch name]' \
+      '--no-local-clone[Do not create a clone]'
+  }
+  __list() {
+    _arguments \
+      '--simple[Show only bundle name]' \
+      '--short[Show only bundle name and branch]' \
+      '--long[Show bundle records]'
+  }
+
+
+  __cleanup() {
+    _arguments \
+      '--force[Do not ask for confirmation]'
+  }
+
+  _arguments '*:: :->command'
+
+  if (( CURRENT == 1 )); then
+    _describe -t commands "antigen command" _1st_arguments
+    return
+  fi
+
+  local -a _command_args
+  case "$words[1]" in
+    bundle)
+      __bundle
+      ;;
+    use)
+      compadd "$@" "oh-my-zsh" "prezto"
+      ;;
+    cleanup)
+      __cleanup
+      ;;
+    (update|purge)
+      compadd $(type -f \-antigen-get-bundles &> /dev/null || antigen &> /dev/null; -antigen-get-bundles --simple 2> /dev/null)
+      ;;
+    theme)
+      compadd $(type -f \-antigen-get-themes &> /dev/null || antigen &> /dev/null; -antigen-get-themes 2> /dev/null)
+      ;;
+    list)
+      __list
+    ;;
+  esac
+}
+zmodload zsh/datetime
+ANTIGEN_DEBUG_LOG=${ANTIGEN_DEBUG_LOG:-${ADOTDIR:-$HOME/.antigen}/debug.log}
+LOG () {
+  local PREFIX="[LOG][${EPOCHREALTIME}]"
+  echo "${PREFIX} ${funcfiletrace[1]}\n${PREFIX} $@" >> $ANTIGEN_DEBUG_LOG
+}
+
+ERR () {
+  local PREFIX="[ERR][${EPOCHREALTIME}]"
+  echo "${PREFIX} ${funcfiletrace[1]}\n${PREFIX} $@" >> $ANTIGEN_DEBUG_LOG
+}
+
+WARN () {
+  local PREFIX="[WRN][${EPOCHREALTIME}]"
+  echo "${PREFIX} ${funcfiletrace[1]}\n${PREFIX} $@" >> $ANTIGEN_DEBUG_LOG
+}
+
+TRACE () {
+  local PREFIX="[TRA][${EPOCHREALTIME}]"
+  echo "${PREFIX} ${funcfiletrace[1]}\n${PREFIX} $@\n${PREFIX} ${(j:\n:)funcstack}" >> $ANTIGEN_DEBUG_LOG
+}
+-antigen-env-setup