powerlines 0.47.126 → 0.47.128

package/bin/{shared-D6Uc3liR.mjs → shared-C3VdzOJx.mjs}

@@ -1,4 +1,4 @@
-import{C as e,S as t,a as n,b as r,c as i,d as a,h as o,j as s,l as c,m as l,p as u,x as d}from"./prompts-BnlPjHFR.mjs";const f=`# Define shell completion directives
+import{C as e,P as t,S as n,T as r,a as i,c as a,d as o,h as s,l as c,m as l,p as u,w as d}from"./prompts-DEjU8qNL.mjs";const f=`# Define shell completion directives
 readonly ShellCompDirectiveError=1
 readonly ShellCompDirectiveNoSpace=2
 readonly ShellCompDirectiveNoFileComp=4
@@ -7,14 +7,14 @@ readonly ShellCompDirectiveFilterDirs=16
 readonly ShellCompDirectiveKeepOrder=32
 
 # Function to debug completion
-__cli_debug() {
+__powerlines_debug() {
 if [[ -n \${BASH_COMP_DEBUG_FILE:-} ]]; then
   echo "$*" >> "\${BASH_COMP_DEBUG_FILE}"
 fi
 }
 
 # Function to handle completions
-__cli_complete() {
+__powerlines_complete() {
 local cur prev words cword
 _get_comp_words_by_ref -n "=:" cur prev words cword
 
@@ -97,7 +97,7 @@ COMPREPLY=( $(compgen -W "\${completions[*]}" -- "$cur") )
 }
 
 # Register completion function
-complete -F __cli_complete cli
+complete -F __powerlines_complete powerlines
 `,p=f.split(`
-`).map(f=>f.trim()?f.trim().startsWith(`#`)?`${a(f)}`:s(f).replaceAll(/(?<=\$(\{|\()).*(?=(\}\)))/g,l(`$&`)).replaceAll(/\".*\"/g,i(`$&`)).replaceAll(/(\[|\]|\(|\)|\||<|>|\$\(|\$?\{|\}|\+|=|;|:)/g,n(u(`$&`))).replaceAll(/(readonly|complete)\s+/g,l(`$&`)).replaceAll(/(?<=(readonly|complete)\s+)\w/g,n(o(`$&`))).replaceAll(/local\s+/g,t(`$&`)).replaceAll(/(?<=local\s+)\w/g,n(e(`$&`))).replaceAll(/while\s+/g,i(`$&`)).replaceAll(/(?<=while\s+)\w/g,n(c(`$&`))).replaceAll(/(if|fi|else|elif|then|done)\s+/g,l(`$&`)).replaceAll(/__\w/g,n(d(`$&`))).replaceAll(/(?<=\s)(-\w|--\w[\w-]*)(?=\s|$)/g,n(r(`$&`))):``).join(`
+`).map(f=>f.trim()?f.trim().startsWith(`#`)?`${o(f)}`:t(f).replaceAll(/(?<=\$(\{|\()).*(?=(\}\)))/g,l(`$&`)).replaceAll(/\".*\"/g,a(`$&`)).replaceAll(/(\[|\]|\(|\)|\||<|>|\$\(|\$?\{|\}|\+|=|;|:)/g,i(u(`$&`))).replaceAll(/(readonly|complete)\s+/g,l(`$&`)).replaceAll(/(?<=(readonly|complete)\s+)\w/g,i(s(`$&`))).replaceAll(/local\s+/g,d(`$&`)).replaceAll(/(?<=local\s+)\w/g,i(r(`$&`))).replaceAll(/while\s+/g,a(`$&`)).replaceAll(/(?<=while\s+)\w/g,i(c(`$&`))).replaceAll(/(if|fi|else|elif|then|done)\s+/g,l(`$&`)).replaceAll(/__\w/g,i(e(`$&`))).replaceAll(/(?<=\s)(-\w|--\w[\w-]*)(?=\s|$)/g,i(n(`$&`))):``).join(`
 `);export{p as n,f as t};

package/bin/{shared-BiFPKQIb.mjs → shared-D6KGuDvi.mjs}

@@ -1,25 +1,25 @@
-import{C as e,S as t,a as n,b as r,c as i,d as a,h as o,j as s,l as c,m as l,p as u,x as d}from"./prompts-BnlPjHFR.mjs";const f=`function __cli_debug
+import{C as e,P as t,S as n,T as r,a as i,c as a,d as o,h as s,l as c,m as l,p as u,w as d}from"./prompts-DEjU8qNL.mjs";const f=`function __powerlines_debug
 set -l file "$BASH_COMP_DEBUG_FILE"
 if test -n "$file"
   echo "$argv" >> $file
 end
 end
 
-function __cli_perform_completion
-__cli_debug "Starting __cli_perform_completion"
+function __powerlines_perform_completion
+__powerlines_debug "Starting __powerlines_perform_completion"
 
 # Extract all args except the last one
 set -l args (commandline -opc)
 # Extract the last arg and escape it in case it is a space or wildcard
 set -l lastArg (string escape -- (commandline -ct))
 
-__cli_debug "args: $args"
-__cli_debug "last arg: $lastArg"
+__powerlines_debug "args: $args"
+__powerlines_debug "last arg: $lastArg"
 
 # Build the completion request command
 set -l requestComp "/nix/store/8spcnffxayf4h9v8w075j01bxxgv5c8j-nodejs-slim-26.3.0/bin/node  /home/runner/work/powerlines/powerlines/node_modules/.pnpm/nx@22.7.5_@swc-node+register@1.11.1_@swc+core@1.15.40_@swc+helpers@0.5.23__@swc+types@0_559e3db9ab82faa3b71ca2061041f3f6/node_modules/nx/dist/bin/run-executor.js complete -- (string join ' ' -- (string escape -- $args[2..-1])) $lastArg"
 
-__cli_debug "Calling $requestComp"
+__powerlines_debug "Calling $requestComp"
 set -l results (eval $requestComp 2> /dev/null)
 
 # Some programs may output extra empty lines after the directive.
@@ -42,9 +42,9 @@ set -l directiveLine $results[-1]
 # completions must be prefixed with the flag
 set -l flagPrefix (string match -r -- '-.*=' "$lastArg")
 
-__cli_debug "Comps: $comps"
-__cli_debug "DirectiveLine: $directiveLine"
-__cli_debug "flagPrefix: $flagPrefix"
+__powerlines_debug "Comps: $comps"
+__powerlines_debug "DirectiveLine: $directiveLine"
+__powerlines_debug "flagPrefix: $flagPrefix"
 
 for comp in $comps
   printf "%s%s
@@ -55,83 +55,83 @@ printf "%s
 " "$directiveLine"
 end
 
-# This function limits calls to __cli_perform_completion, by caching the result
-function __cli_perform_completion_once
-__cli_debug "Starting __cli_perform_completion_once"
+# This function limits calls to __powerlines_perform_completion, by caching the result
+function __powerlines_perform_completion_once
+__powerlines_debug "Starting __powerlines_perform_completion_once"
 
-if test -n "$__cli_perform_completion_once_result"
-  __cli_debug "Seems like a valid result already exists, skipping __cli_perform_completion"
+if test -n "$__powerlines_perform_completion_once_result"
+  __powerlines_debug "Seems like a valid result already exists, skipping __powerlines_perform_completion"
   return 0
 end
 
-set --global __cli_perform_completion_once_result (__cli_perform_completion)
-if test -z "$__cli_perform_completion_once_result"
-  __cli_debug "No completions, probably due to a failure"
+set --global __powerlines_perform_completion_once_result (__powerlines_perform_completion)
+if test -z "$__powerlines_perform_completion_once_result"
+  __powerlines_debug "No completions, probably due to a failure"
   return 1
 end
 
-__cli_debug "Performed completions and set __cli_perform_completion_once_result"
+__powerlines_debug "Performed completions and set __powerlines_perform_completion_once_result"
 return 0
 end
 
 # This function is used to clear the cached result after completions are run
-function __cli_clear_perform_completion_once_result
-__cli_debug ""
-__cli_debug "========= clearing previously set __cli_perform_completion_once_result variable =========="
-set --erase __cli_perform_completion_once_result
-__cli_debug "Successfully erased the variable __cli_perform_completion_once_result"
+function __powerlines_clear_perform_completion_once_result
+__powerlines_debug ""
+__powerlines_debug "========= clearing previously set __powerlines_perform_completion_once_result variable =========="
+set --erase __powerlines_perform_completion_once_result
+__powerlines_debug "Successfully erased the variable __powerlines_perform_completion_once_result"
 end
 
-function __cli_requires_order_preservation
-__cli_debug ""
-__cli_debug "========= checking if order preservation is required =========="
+function __powerlines_requires_order_preservation
+__powerlines_debug ""
+__powerlines_debug "========= checking if order preservation is required =========="
 
-__cli_perform_completion_once
-if test -z "$__cli_perform_completion_once_result"
-  __cli_debug "Error determining if order preservation is required"
+__powerlines_perform_completion_once
+if test -z "$__powerlines_perform_completion_once_result"
+  __powerlines_debug "Error determining if order preservation is required"
   return 1
 end
 
-set -l directive (string sub --start 2 $__cli_perform_completion_once_result[-1])
-__cli_debug "Directive is: $directive"
+set -l directive (string sub --start 2 $__powerlines_perform_completion_once_result[-1])
+__powerlines_debug "Directive is: $directive"
 
 set -l shellCompDirectiveKeepOrder 32
 set -l keeporder (math (math --scale 0 $directive / $shellCompDirectiveKeepOrder) % 2)
-__cli_debug "Keeporder is: $keeporder"
+__powerlines_debug "Keeporder is: $keeporder"
 
 if test $keeporder -ne 0
-  __cli_debug "This does require order preservation"
+  __powerlines_debug "This does require order preservation"
   return 0
 end
 
-__cli_debug "This doesn't require order preservation"
+__powerlines_debug "This doesn't require order preservation"
 return 1
 end
 
 # This function does two things:
-# - Obtain the completions and store them in the global __cli_comp_results
+# - Obtain the completions and store them in the global __powerlines_comp_results
 # - Return false if file completion should be performed
-function __cli_prepare_completions
-__cli_debug ""
-__cli_debug "========= starting completion logic =========="
+function __powerlines_prepare_completions
+__powerlines_debug ""
+__powerlines_debug "========= starting completion logic =========="
 
 # Start fresh
-set --erase __cli_comp_results
+set --erase __powerlines_comp_results
 
-__cli_perform_completion_once
-__cli_debug "Completion results: $__cli_perform_completion_once_result"
+__powerlines_perform_completion_once
+__powerlines_debug "Completion results: $__powerlines_perform_completion_once_result"
 
-if test -z "$__cli_perform_completion_once_result"
-  __cli_debug "No completion, probably due to a failure"
+if test -z "$__powerlines_perform_completion_once_result"
+  __powerlines_debug "No completion, probably due to a failure"
   # Might as well do file completion, in case it helps
   return 1
 end
 
-set -l directive (string sub --start 2 $__cli_perform_completion_once_result[-1])
-set --global __cli_comp_results $__cli_perform_completion_once_result[1..-2]
+set -l directive (string sub --start 2 $__powerlines_perform_completion_once_result[-1])
+set --global __powerlines_comp_results $__powerlines_perform_completion_once_result[1..-2]
 
-__cli_debug "Completions are: $__cli_comp_results"
-__cli_debug "Directive is: $directive"
+__powerlines_debug "Completions are: $__powerlines_comp_results"
+__powerlines_debug "Directive is: $directive"
 
 set -l shellCompDirectiveError 1
 set -l shellCompDirectiveNoSpace 2
@@ -144,7 +144,7 @@ end
 
 set -l compErr (math (math --scale 0 $directive / $shellCompDirectiveError) % 2)
 if test $compErr -eq 1
-  __cli_debug "Received error directive: aborting."
+  __powerlines_debug "Received error directive: aborting."
   # Might as well do file completion, in case it helps
   return 1
 end
@@ -152,7 +152,7 @@ end
 set -l filefilter (math (math --scale 0 $directive / $shellCompDirectiveFilterFileExt) % 2)
 set -l dirfilter (math (math --scale 0 $directive / $shellCompDirectiveFilterDirs) % 2)
 if test $filefilter -eq 1; or test $dirfilter -eq 1
-  __cli_debug "File extension filtering or directory filtering not supported"
+  __powerlines_debug "File extension filtering or directory filtering not supported"
   # Do full file completion instead
   return 1
 end
@@ -160,7 +160,7 @@ end
 set -l nospace (math (math --scale 0 $directive / $shellCompDirectiveNoSpace) % 2)
 set -l nofiles (math (math --scale 0 $directive / $shellCompDirectiveNoFileComp) % 2)
 
-__cli_debug "nospace: $nospace, nofiles: $nofiles"
+__powerlines_debug "nospace: $nospace, nofiles: $nofiles"
 
 # If we want to prevent a space, or if file completion is NOT disabled,
 # we need to count the number of valid completions.
@@ -169,22 +169,22 @@ __cli_debug "nospace: $nospace, nofiles: $nofiles"
 # criteria than the prefix.
 if test $nospace -ne 0; or test $nofiles -eq 0
   set -l prefix (commandline -t | string escape --style=regex)
-  __cli_debug "prefix: $prefix"
+  __powerlines_debug "prefix: $prefix"
 
-  set -l completions (string match -r -- "^$prefix.*" $__cli_comp_results)
-  set --global __cli_comp_results $completions
-  __cli_debug "Filtered completions are: $__cli_comp_results"
+  set -l completions (string match -r -- "^$prefix.*" $__powerlines_comp_results)
+  set --global __powerlines_comp_results $completions
+  __powerlines_debug "Filtered completions are: $__powerlines_comp_results"
 
   # Important not to quote the variable for count to work
-  set -l numComps (count $__cli_comp_results)
-  __cli_debug "numComps: $numComps"
+  set -l numComps (count $__powerlines_comp_results)
+  __powerlines_debug "numComps: $numComps"
 
   if test $numComps -eq 1; and test $nospace -ne 0
     # We must first split on 	 to get rid of the descriptions to be
     # able to check what the actual completion will be.
     # We don't need descriptions anyway since there is only a single
     # real completion which the shell will expand immediately.
-    set -l split (string split --max 1 "	" $__cli_comp_results[1])
+    set -l split (string split --max 1 "	" $__powerlines_comp_results[1])
 
     # Fish won't add a space if the completion ends with any
     # of the following characters: @=/:.,
@@ -192,16 +192,16 @@ if test $nospace -ne 0; or test $nofiles -eq 0
     if not string match -r -q "[@=/:.,]" -- "$lastChar"
       # In other cases, to support the "nospace" directive we trick the shell
       # by outputting an extra, longer completion.
-      __cli_debug "Adding second completion to perform nospace directive"
-      set --global __cli_comp_results $split[1] $split[1].
-      __cli_debug "Completions are now: $__cli_comp_results"
+      __powerlines_debug "Adding second completion to perform nospace directive"
+      set --global __powerlines_comp_results $split[1] $split[1].
+      __powerlines_debug "Completions are now: $__powerlines_comp_results"
     end
   end
 
   if test $numComps -eq 0; and test $nofiles -eq 0
     # To be consistent with bash and zsh, we only trigger file
     # completion when there are no other completions
-    __cli_debug "Requesting file completion"
+    __powerlines_debug "Requesting file completion"
     return 1
   end
 end
@@ -213,23 +213,23 @@ end
 # so we can properly delete any completions provided by another script.
 # Only do this if the program can be found, or else fish may print some errors; besides,
 # the existing completions will only be loaded if the program can be found.
-if type -q "cli"
+if type -q "powerlines"
 # The space after the program name is essential to trigger completion for the program
 # and not completion of the program name itself.
 # Also, we use '> /dev/null 2>&1' since '&>' is not supported in older versions of fish.
-complete --do-complete "cli " > /dev/null 2>&1
+complete --do-complete "powerlines " > /dev/null 2>&1
 end
 
 # Remove any pre-existing completions for the program since we will be handling all of them.
-complete -c cli -e
+complete -c powerlines -e
 # This will get called after the two calls below and clear the cached result
-complete -c cli -n '__cli_clear_perform_completion_once_result'
-# The call to __cli_prepare_completions will setup __cli_comp_results
+complete -c powerlines -n '__powerlines_clear_perform_completion_once_result'
+# The call to __powerlines_prepare_completions will setup __powerlines_comp_results
 # which provides the program's completion choices.
 # If this doesn't require order preservation, we don't use the -k flag
-complete -c cli -n 'not __cli_requires_order_preservation && __cli_prepare_completions' -f -a '$__cli_comp_results'
+complete -c powerlines -n 'not __powerlines_requires_order_preservation && __powerlines_prepare_completions' -f -a '$__powerlines_comp_results'
 # Otherwise we use the -k flag
-complete -k -c cli -n '__cli_requires_order_preservation && __cli_prepare_completions' -f -a '$__cli_comp_results'
+complete -k -c powerlines -n '__powerlines_requires_order_preservation && __powerlines_prepare_completions' -f -a '$__powerlines_comp_results'
 `,p=f.split(`
-`).map(f=>f.trim()?f.trim().startsWith(`#`)?`${a(f)}`:s(f).replaceAll(/(?<=\$(\{|\()).*(?=(\}\)))/g,l(`$&`)).replaceAll(/(\"|\').*(\"|\')/g,i(`$&`)).replaceAll(/(\[|\]|\(|\)|\||<|>|\$\(|\$?\{|\}|\+|=|;|:)/g,n(u(`$&`))).replaceAll(/(function|complete)\s+/g,l(`$&`)).replaceAll(/(?<=(function|complete)\s+)\w/g,n(o(`$&`))).replaceAll(/set\s+/g,t(`$&`)).replaceAll(/(?<=set\s+)\w/g,n(e(`$&`))).replaceAll(/while\s+/g,i(`$&`)).replaceAll(/(?<=while\s+)\w/g,n(c(`$&`))).replaceAll(/(if|fi|else|elif|then|done)\s+/g,l(`$&`)).replaceAll(/\s__\w/g,n(d(`$&`))).replaceAll(/(?<=\s)(-\w|--\w[\w-]*)(?=\s|$)/g,n(r(`$&`))):``).join(`
+`).map(f=>f.trim()?f.trim().startsWith(`#`)?`${o(f)}`:t(f).replaceAll(/(?<=\$(\{|\()).*(?=(\}\)))/g,l(`$&`)).replaceAll(/(\"|\').*(\"|\')/g,a(`$&`)).replaceAll(/(\[|\]|\(|\)|\||<|>|\$\(|\$?\{|\}|\+|=|;|:)/g,i(u(`$&`))).replaceAll(/(function|complete)\s+/g,l(`$&`)).replaceAll(/(?<=(function|complete)\s+)\w/g,i(s(`$&`))).replaceAll(/set\s+/g,d(`$&`)).replaceAll(/(?<=set\s+)\w/g,i(r(`$&`))).replaceAll(/while\s+/g,a(`$&`)).replaceAll(/(?<=while\s+)\w/g,i(c(`$&`))).replaceAll(/(if|fi|else|elif|then|done)\s+/g,l(`$&`)).replaceAll(/\s__\w/g,i(e(`$&`))).replaceAll(/(?<=\s)(-\w|--\w[\w-]*)(?=\s|$)/g,i(n(`$&`))):``).join(`
 `);export{p as n,f as t};

package/bin/{shared-CLQvIZ7z.mjs → shared-R0IeF6M6.mjs}

@@ -1,11 +1,11 @@
-import{C as e,S as t,a as n,b as r,c as i,d as a,h as o,j as s,l as c,m as l,p as u,x as d}from"./prompts-BnlPjHFR.mjs";const f=`__cli_debug() {
+import{C as e,P as t,S as n,T as r,a as i,c as a,d as o,h as s,l as c,m as l,p as u,w as d}from"./prompts-DEjU8qNL.mjs";const f=`__powerlines_debug() {
 local file="$BASH_COMP_DEBUG_FILE"
 if [[ -n \${file} ]]; then
   echo "$*" >> "\${file}"
 fi
 }
 
-_cli() {
+_powerlines() {
 local shellCompDirectiveError=1
 local shellCompDirectiveNoSpace=2
 local shellCompDirectiveNoFileComp=4
@@ -16,21 +16,21 @@ local shellCompDirectiveKeepOrder=32
 local lastParam lastChar flagPrefix requestComp out directive comp lastComp noSpace keepOrder
 local -a completions
 
-__cli_debug "
+__powerlines_debug "
 ========= starting completion logic =========="
-__cli_debug "CURRENT: \${CURRENT}, words[*]: \${words[*]}"
+__powerlines_debug "CURRENT: \${CURRENT}, words[*]: \${words[*]}"
 
 # The user could have moved the cursor backwards on the command-line.
 # We need to trigger completion from the $CURRENT location, so we need
 # to truncate the command-line ($words) up to the $CURRENT location.
 # (We cannot use $CURSOR as its value does not work when a command is an alias.)
 words=( "\${=words[1,CURRENT]}" )
-__cli_debug "Truncated words[*]: \${words[*]},"
+__powerlines_debug "Truncated words[*]: \${words[*]},"
 
 lastParam=\${words[-1]}
 lastChar=\${lastParam[-1]}
-__cli_debug "lastParam: \${lastParam}, lastChar: \${lastChar}"
-# For zsh, when completing a flag with an = (e.g., cli -n=<TAB>)
+__powerlines_debug "lastParam: \${lastParam}, lastChar: \${lastChar}"
+# For zsh, when completing a flag with an = (e.g., powerlines -n=<TAB>)
 # completions must be prefixed with the flag
 setopt local_options BASH_REMATCH
 if [[ "\${lastParam}" =~ '-.*=' ]]; then
@@ -43,7 +43,7 @@ local -a args_to_quote=("\${(@)words[2,-1]}")
 if [ "\${lastChar}" = "" ]; then
   # If the last parameter is complete (there is a space following it)
   # We add an extra empty parameter so we can indicate this to the go completion code.
-  __cli_debug "Adding extra empty parameter"
+  __powerlines_debug "Adding extra empty parameter"
   args_to_quote+=("")
 fi
 
@@ -53,11 +53,11 @@ local quoted_args=("\${(@q)args_to_quote}")
 # Join the main command and the quoted arguments into a single string for eval
 requestComp="/nix/store/8spcnffxayf4h9v8w075j01bxxgv5c8j-nodejs-slim-26.3.0/bin/node  /home/runner/work/powerlines/powerlines/node_modules/.pnpm/nx@22.7.5_@swc-node+register@1.11.1_@swc+core@1.15.40_@swc+helpers@0.5.23__@swc+types@0_559e3db9ab82faa3b71ca2061041f3f6/node_modules/nx/dist/bin/run-executor.js complete -- \${quoted_args[*]}"
 
-__cli_debug "About to call: eval \${requestComp}"
+__powerlines_debug "About to call: eval \${requestComp}"
 
 # Use eval to handle any environment variables and such
 out=$(eval \${requestComp} 2>/dev/null)
-__cli_debug "completion output: \${out}"
+__powerlines_debug "completion output: \${out}"
 
 # Extract the directive integer following a : from the last line
 local lastLine
@@ -66,7 +66,7 @@ while IFS='
 lastLine=\${line}
 done < <(printf "%s
 " "\${out[@]}")
-__cli_debug "last line: \${lastLine}"
+__powerlines_debug "last line: \${lastLine}"
 
 if [ "\${lastLine[1]}" = : ]; then
   directive=\${lastLine[2,-1]}
@@ -76,16 +76,16 @@ if [ "\${lastLine[1]}" = : ]; then
   out=\${out[1,-$suffix]}
 else
   # There is no directive specified.  Leave $out as is.
-  __cli_debug "No directive found.  Setting to default"
+  __powerlines_debug "No directive found.  Setting to default"
   directive=0
 fi
 
-__cli_debug "directive: \${directive}"
-__cli_debug "completions: \${out}"
-__cli_debug "flagPrefix: \${flagPrefix}"
+__powerlines_debug "directive: \${directive}"
+__powerlines_debug "completions: \${out}"
+__powerlines_debug "flagPrefix: \${flagPrefix}"
 
 if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then
-  __cli_debug "Completion received error. Ignoring completions."
+  __powerlines_debug "Completion received error. Ignoring completions."
   return
 fi
 
@@ -97,11 +97,11 @@ while IFS='
 ' read -r comp; do
 # Check if this is an activeHelp statement (i.e., prefixed with $activeHelpMarker)
 if [ "\${comp[1,$endIndex]}" = "$activeHelpMarker" ];then
-  __cli_debug "ActiveHelp found: $comp"
+  __powerlines_debug "ActiveHelp found: $comp"
   comp="\${comp[$startIndex,-1]}"
   if [ -n "$comp" ]; then
     compadd -x "\${comp}"
-    __cli_debug "ActiveHelp will need delimiter"
+    __powerlines_debug "ActiveHelp will need delimiter"
     hasActiveHelp=1
   fi
   continue
@@ -117,7 +117,7 @@ if [ -n "$comp" ]; then
   local tab="$(printf '	')"
   comp=\${comp//$tab/:}
 
-  __cli_debug "Adding completion: \${comp}"
+  __powerlines_debug "Adding completion: \${comp}"
   completions+=\${comp}
   lastComp=$comp
 fi
@@ -129,19 +129,19 @@ done < <(printf "%s
 # - file completion will be performed (so there will be choices after the activeHelp)
 if [ $hasActiveHelp -eq 1 ]; then
   if [ \${#completions} -ne 0 ] || [ $((directive & shellCompDirectiveNoFileComp)) -eq 0 ]; then
-    __cli_debug "Adding activeHelp delimiter"
+    __powerlines_debug "Adding activeHelp delimiter"
     compadd -x "--"
     hasActiveHelp=0
   fi
 fi
 
 if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then
-  __cli_debug "Activating nospace."
+  __powerlines_debug "Activating nospace."
   noSpace="-S ''"
 fi
 
 if [ $((directive & shellCompDirectiveKeepOrder)) -ne 0 ]; then
-  __cli_debug "Activating keep order."
+  __powerlines_debug "Activating keep order."
   keepOrder="-V"
 fi
 
@@ -158,17 +158,17 @@ if [ $((directive & shellCompDirectiveFilterFileExt)) -ne 0 ]; then
   done
   filteringCmd+=" \${flagPrefix}"
 
-  __cli_debug "File filtering command: $filteringCmd"
+  __powerlines_debug "File filtering command: $filteringCmd"
   _arguments '*:filename:'"$filteringCmd"
 elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then
   # File completion for directories only
   local subdir
   subdir="\${completions[1]}"
   if [ -n "$subdir" ]; then
-    __cli_debug "Listing directories in $subdir"
+    __powerlines_debug "Listing directories in $subdir"
     pushd "\${subdir}" >/dev/null 2>&1
   else
-    __cli_debug "Listing directories in ."
+    __powerlines_debug "Listing directories in ."
   fi
 
   local result
@@ -179,17 +179,17 @@ elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then
   fi
   return $result
 else
-  __cli_debug "Calling _describe"
+  __powerlines_debug "Calling _describe"
   if eval _describe $keepOrder "completions" completions -Q \${flagPrefix} \${noSpace}; then
-    __cli_debug "_describe found some completions"
+    __powerlines_debug "_describe found some completions"
 
     # Return the success of having called _describe
     return 0
   else
-    __cli_debug "_describe did not find completions."
-    __cli_debug "Checking if we should do file completion."
+    __powerlines_debug "_describe did not find completions."
+    __powerlines_debug "Checking if we should do file completion."
     if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then
-      __cli_debug "deactivating file completion"
+      __powerlines_debug "deactivating file completion"
 
       # Return 0 to indicate completion is finished and prevent zsh from
       # trying other completion algorithms (which could cause hanging).
@@ -197,7 +197,7 @@ else
       return 0
     else
       # Perform file completion
-      __cli_debug "Activating file completion"
+      __powerlines_debug "Activating file completion"
 
       # We must return the result of this command, so it must be the
       # last command, or else we must store its result to return it.
@@ -208,9 +208,9 @@ fi
 }
 
 # don't run the completion function when being sourced or eval-ed
-if [ "\${funcstack[1]}" = "_cli" ]; then
-_cli
+if [ "\${funcstack[1]}" = "_powerlines" ]; then
+_powerlines
 fi
 `,p=f.split(`
-`).map(f=>f.trim()?f.trim().startsWith(`#`)?`${a(f)}`:s(f).replaceAll(/(?<=\$(\{|\()).*(?=(\}\)))/g,l(`$&`)).replaceAll(/\".*\"/g,i(`$&`)).replaceAll(/(\[|\]|\(|\)|\||<|>|\$\(|\$?\{|\}|\+|=|;|:)/g,n(u(`$&`))).replaceAll(/(readonly|complete)\s+/g,l(`$&`)).replaceAll(/(?<=(readonly|complete)\s+)\w/g,n(o(`$&`))).replaceAll(/local\s+/g,t(`$&`)).replaceAll(/(?<=local\s+)\w/g,n(e(`$&`))).replaceAll(/(for|while)\s+/g,i(`$&`)).replaceAll(/(?<=for|while\s+)\w/g,n(c(`$&`))).replaceAll(/(return|if|fi|else|elif|then|done)\s+/g,l(`$&`)).replaceAll(/__\w/g,n(d(`$&`))).replaceAll(/(?<=\s)(-\w|--\w[\w-]*)(?=\s|$)/g,n(r(`$&`))):``).join(`
+`).map(f=>f.trim()?f.trim().startsWith(`#`)?`${o(f)}`:t(f).replaceAll(/(?<=\$(\{|\()).*(?=(\}\)))/g,l(`$&`)).replaceAll(/\".*\"/g,a(`$&`)).replaceAll(/(\[|\]|\(|\)|\||<|>|\$\(|\$?\{|\}|\+|=|;|:)/g,i(u(`$&`))).replaceAll(/(readonly|complete)\s+/g,l(`$&`)).replaceAll(/(?<=(readonly|complete)\s+)\w/g,i(s(`$&`))).replaceAll(/local\s+/g,d(`$&`)).replaceAll(/(?<=local\s+)\w/g,i(r(`$&`))).replaceAll(/(for|while)\s+/g,a(`$&`)).replaceAll(/(?<=for|while\s+)\w/g,i(c(`$&`))).replaceAll(/(return|if|fi|else|elif|then|done)\s+/g,l(`$&`)).replaceAll(/__\w/g,i(e(`$&`))).replaceAll(/(?<=\s)(-\w|--\w[\w-]*)(?=\s|$)/g,i(n(`$&`))):``).join(`
 `);export{p as n,f as t};