@optique/core 0.5.0 → 0.6.0-dev.102

package/dist/completion.js

@@ -0,0 +1,510 @@
+import { formatMessage } from "./message.js";
+
+//#region src/completion.ts
+/**
+* The Bash shell completion generator.
+* @since 0.6.0
+*/
+const bash = {
+	name: "bash",
+	generateScript(programName, args = []) {
+		const escapedArgs = args.map((arg) => `'${arg.replace(/'/g, "'\\''")}'`).join(" ");
+		return `
+function _${programName} () {
+  COMPREPLY=()
+  local current="\${COMP_WORDS[COMP_CWORD]}"
+  local prev=("\${COMP_WORDS[@]:1:COMP_CWORD-1}")
+  while IFS= read -r line; do
+    if [[ "$line" == __FILE__:* ]]; then
+      # Parse file completion directive: __FILE__:type:extensions:pattern:hidden
+      IFS=':' read -r _ type extensions pattern hidden <<< "$line"
+
+      # Generate file completions based on type
+      case "$type" in
+        file)
+          # Complete files only
+          if [[ -n "$extensions" ]]; then
+            # Complete with extension filtering
+            local ext_pattern="\${extensions//,/|}"
+            for file in "$current"*; do
+              [[ -e "$file" && "$file" =~ \\.($ext_pattern)$ ]] && COMPREPLY+=("$file")
+            done
+          else
+            # Complete files only, exclude directories
+            while IFS= read -r -d '' item; do
+              [[ -f "$item" ]] && COMPREPLY+=("$item")
+            done < <(compgen -f -z -- "$current")
+          fi
+          ;;
+        directory)
+          # Complete directories only
+          while IFS= read -r -d '' dir; do
+            COMPREPLY+=("$dir/")
+          done < <(compgen -d -z -- "$current")
+          ;;
+        any)
+          # Complete both files and directories
+          if [[ -n "$extensions" ]]; then
+            # Files with extension filtering + directories
+            # Files with extension filtering
+            local ext_pattern="\${extensions//,/|}"
+            for item in "$current"*; do
+              if [[ -d "$item" ]]; then
+                COMPREPLY+=("$item/")
+              elif [[ -f "$item" && "$item" =~ \\.($ext_pattern)$ ]]; then
+                COMPREPLY+=("$item")
+              fi
+            done
+          else
+            # Complete files and directories, add slash to directories
+            while IFS= read -r -d '' item; do
+              if [[ -d "$item" ]]; then
+                COMPREPLY+=("$item/")
+              else
+                COMPREPLY+=("$item")
+              fi
+            done < <(compgen -f -z -- "$current")
+          fi
+          ;;
+      esac
+
+      # Filter out hidden files unless requested
+      if [[ "$hidden" != "1" && "$current" != .* ]]; then
+        local filtered=()
+        for item in "\${COMPREPLY[@]}"; do
+          [[ "$(basename "$item")" != .* ]] && filtered+=("$item")
+        done
+        COMPREPLY=("\${filtered[@]}")
+      fi
+    else
+      # Regular literal completion
+      COMPREPLY+=("$line")
+    fi
+  done < <(${programName} ${escapedArgs} "\${prev[@]}" "$current" 2>/dev/null)
+}
+
+complete -F _${programName} ${programName}
+    `;
+	},
+	*encodeSuggestions(suggestions) {
+		let i = 0;
+		for (const suggestion of suggestions) {
+			if (i > 0) yield "\n";
+			if (suggestion.kind === "literal") yield `${suggestion.text}`;
+			else {
+				const extensions = suggestion.extensions?.join(",") || "";
+				const hidden = suggestion.includeHidden ? "1" : "0";
+				yield `__FILE__:${suggestion.type}:${extensions}:${suggestion.pattern || ""}:${hidden}`;
+			}
+			i++;
+		}
+	}
+};
+/**
+* The Zsh shell completion generator.
+* @since 0.6.0
+*/
+const zsh = {
+	name: "zsh",
+	generateScript(programName, args = []) {
+		const escapedArgs = args.map((arg) => `'${arg.replace(/'/g, "'\\''")}'`).join(" ");
+		return `
+function _${programName.replace(/[^a-zA-Z0-9]/g, "_")} () {
+  local current="\$words[CURRENT]"
+  local -a prev
+  # Extract previous arguments, skipping empty ones
+  prev=()
+  local i
+  for (( i=2; i < CURRENT; i++ )); do
+    if [[ -n "\$words[i]" ]]; then
+      prev+=("\$words[i]")
+    fi
+  done
+
+  # Call the completion function and capture output
+  local output
+  if (( \${#prev[@]} == 0 )); then
+    output=\$(${programName} ${escapedArgs} "\$current" 2>/dev/null)
+  else
+    output=\$(${programName} ${escapedArgs} "\${prev[@]}" "\$current" 2>/dev/null)
+  fi
+
+  # Split output into lines and process each line
+  local -a completions descriptions
+  local line value desc
+  local has_file_completion=0
+
+  while IFS= read -r line; do
+    if [[ -n "\$line" ]]; then
+      # Split by null character - first part is value, second is description
+      value=\${line%%\$'\\0'*}
+      desc=\${line#*\$'\\0'}
+      desc=\${desc%%\$'\\0'*}
+
+      if [[ "\$value" == __FILE__:* ]]; then
+        # Parse file completion directive: __FILE__:type:extensions:pattern:hidden
+        local type extensions pattern hidden
+        IFS=':' read -r _ type extensions pattern hidden <<< "\$value"
+        has_file_completion=1
+
+        # Use zsh's native file completion
+        case "\$type" in
+          file)
+            if [[ -n "\$extensions" ]]; then
+              # Complete files with extension filtering
+              local ext_pattern="*.(\\$\{extensions//,/|\})"
+              _files -g "\\$ext_pattern"
+            else
+              _files -g "*"
+            fi
+            ;;
+          directory)
+            _directories
+            ;;
+          any)
+            if [[ -n "\$extensions" ]]; then
+              # Complete both files and directories, with extension filtering for files
+              local ext_pattern="*.(\\$\{extensions//,/|\})"
+              _files -g "\\$ext_pattern" && _directories
+            else
+              _files
+            fi
+            ;;
+        esac
+
+        # Note: zsh's _files and _directories handle hidden file filtering automatically
+        # based on the completion context and user settings
+      else
+        # Regular literal completion
+        if [[ -n "\$value" ]]; then
+          completions+=("\$value")
+          descriptions+=("\$desc")
+        fi
+      fi
+    fi
+  done <<< "\$output"
+
+  # Add literal completions with descriptions if we have any
+  if (( \${#completions[@]} > 0 )); then
+    # Prepare completion with descriptions for _describe
+    local -a matches
+    local -i i
+    for (( i=1; i <= \${#completions[@]}; i++ )); do
+      if [[ -n "\${descriptions[i]}" ]]; then
+        matches+=("\${completions[i]}:\${descriptions[i]}")
+      else
+        matches+=("\${completions[i]}")
+      fi
+    done
+    _describe 'commands' matches
+  fi
+}
+
+compdef _${programName.replace(/[^a-zA-Z0-9]/g, "_")} ${programName}
+    `;
+	},
+	*encodeSuggestions(suggestions) {
+		for (const suggestion of suggestions) if (suggestion.kind === "literal") {
+			const description = suggestion.description == null ? "" : formatMessage(suggestion.description, { colors: false });
+			yield `${suggestion.text}\0${description}\0`;
+		} else {
+			const extensions = suggestion.extensions?.join(",") || "";
+			const hidden = suggestion.includeHidden ? "1" : "0";
+			const description = suggestion.description == null ? "" : formatMessage(suggestion.description, { colors: false });
+			yield `__FILE__:${suggestion.type}:${extensions}:${suggestion.pattern || ""}:${hidden}\0${description}\0`;
+		}
+	}
+};
+/**
+* The fish shell completion generator.
+* @since 0.6.0
+*/
+const fish = {
+	name: "fish",
+	generateScript(programName, args = []) {
+		const escapedArgs = args.map((arg) => `'${arg.replace(/'/g, "\\'")}'`).join(" ");
+		const functionName = `__${programName.replace(/[^a-zA-Z0-9]/g, "_")}_complete`;
+		return `
+function ${functionName}
+    set -l tokens (commandline -poc)
+    set -l current (commandline -ct)
+
+    # Extract previous arguments (skip the command name)
+    set -l prev
+    set -l count (count $tokens)
+    if test $count -gt 1
+        set prev $tokens[2..$count]
+    end
+
+    # Call completion command and capture output
+${escapedArgs ? `    set -l output (${programName} ${escapedArgs} $prev $current 2>/dev/null)\n` : `    set -l output (${programName} $prev $current 2>/dev/null)\n`}
+    # Process each line of output
+    for line in $output
+        if string match -q '__FILE__:*' -- $line
+            # Parse file completion directive: __FILE__:type:extensions:pattern:hidden
+            set -l parts (string split ':' -- $line)
+            set -l type $parts[2]
+            set -l extensions $parts[3]
+            set -l pattern $parts[4]
+            set -l hidden $parts[5]
+
+            # Generate file completions based on type
+            set -l items
+            switch $type
+                case file
+                    # Complete files only
+                    for item in $current*
+                        if test -f $item
+                            set -a items $item
+                        end
+                    end
+                case directory
+                    # Complete directories only
+                    for item in $current*
+                        if test -d $item
+                            set -a items $item/
+                        end
+                    end
+                case any
+                    # Complete both files and directories
+                    for item in $current*
+                        if test -d $item
+                            set -a items $item/
+                        else if test -f $item
+                            set -a items $item
+                        end
+                    end
+            end
+
+            # Filter by extensions if specified
+            if test -n "$extensions" -a "$type" != directory
+                set -l filtered
+                set -l ext_list (string split ',' -- $extensions)
+                for item in $items
+                    # Skip directories, they don't have extensions
+                    if string match -q '*/' -- $item
+                        set -a filtered $item
+                        continue
+                    end
+                    # Check if file matches any extension
+                    for ext in $ext_list
+                        if string match -q "*.$ext" -- $item
+                            set -a filtered $item
+                            break
+                        end
+                    end
+                end
+                set items $filtered
+            end
+
+            # Filter out hidden files unless requested
+            if test "$hidden" != "1" -a (string sub -l 1 -- $current) != "."
+                set -l filtered
+                for item in $items
+                    set -l basename (basename $item)
+                    if not string match -q '.*' -- $basename
+                        set -a filtered $item
+                    end
+                end
+                set items $filtered
+            end
+
+            # Output file completions
+            for item in $items
+                echo $item
+            end
+        else
+            # Regular literal completion - split by tab
+            set -l parts (string split \\t -- $line)
+            if test (count $parts) -ge 2
+                # value\tdescription format
+                echo $parts[1]\\t$parts[2]
+            else
+                # Just value
+                echo $line
+            end
+        end
+    end
+end
+
+complete -c ${programName} -f -a '(${functionName})'
+    `;
+	},
+	*encodeSuggestions(suggestions) {
+		let i = 0;
+		for (const suggestion of suggestions) {
+			if (i > 0) yield "\n";
+			if (suggestion.kind === "literal") {
+				const description = suggestion.description == null ? "" : formatMessage(suggestion.description, { colors: false });
+				yield `${suggestion.text}\t${description}`;
+			} else {
+				const extensions = suggestion.extensions?.join(",") || "";
+				const hidden = suggestion.includeHidden ? "1" : "0";
+				const description = suggestion.description == null ? "" : formatMessage(suggestion.description, { colors: false });
+				yield `__FILE__:${suggestion.type}:${extensions}:${suggestion.pattern || ""}:${hidden}\t${description}`;
+			}
+			i++;
+		}
+	}
+};
+/**
+* The PowerShell completion generator.
+* @since 0.6.0
+*/
+const pwsh = {
+	name: "pwsh",
+	generateScript(programName, args = []) {
+		const escapedArgs = args.map((arg) => `'${arg.replace(/'/g, "''")}'`).join(", ");
+		return `
+Register-ArgumentCompleter -Native -CommandName ${programName} -ScriptBlock {
+    param(\$wordToComplete, \$commandAst, \$cursorPosition)
+
+    # Extract arguments from AST (handles quoted strings properly)
+    \$arguments = @()
+    \$commandElements = \$commandAst.CommandElements
+
+    # Determine the range of elements to extract
+    # Exclude the last element if it matches wordToComplete (partial input case)
+    \$maxIndex = \$commandElements.Count - 1
+    if (\$commandElements.Count -gt 1) {
+        \$lastElement = \$commandElements[\$commandElements.Count - 1]
+        \$lastText = if (\$lastElement -is [System.Management.Automation.Language.StringConstantExpressionAst]) {
+            \$lastElement.Value
+        } else {
+            \$lastElement.Extent.Text
+        }
+        if (\$lastText -eq \$wordToComplete) {
+            \$maxIndex = \$commandElements.Count - 2
+        }
+    }
+
+    for (\$i = 1; \$i -le \$maxIndex; \$i++) {
+        \$element = \$commandElements[\$i]
+
+        if (\$element -is [System.Management.Automation.Language.StringConstantExpressionAst]) {
+            \$arguments += \$element.Value
+        } else {
+            \$arguments += \$element.Extent.Text
+        }
+    }
+
+    # Build arguments array for completion command
+    \$completionArgs = @()
+${escapedArgs ? `    \$completionArgs += @(${escapedArgs})
+` : ""}    \$completionArgs += \$arguments
+    \$completionArgs += \$wordToComplete
+
+    # Call completion command and capture output
+    try {
+        \$output = & ${programName} \$completionArgs 2>\$null
+        if (-not \$output) { return }
+
+        # Parse tab-separated output and create CompletionResult objects
+        \$output -split "\`n" | ForEach-Object {
+            \$line = \$_.Trim()
+            if (-not \$line) { return }
+
+            if (\$line -match '^__FILE__:') {
+                # Parse file completion directive: __FILE__:type:extensions:pattern:hidden
+                \$parts = \$line -split ':', 5
+                \$type = \$parts[1]
+                \$extensions = \$parts[2]
+                \$pattern = \$parts[3]
+                \$hidden = \$parts[4] -eq '1'
+
+                # Determine current prefix for file matching
+                \$prefix = if (\$wordToComplete) { \$wordToComplete } else { '' }
+
+                # Get file system items based on type
+                \$items = @()
+                switch (\$type) {
+                    'file' {
+                        if (\$extensions) {
+                            # Filter by extensions
+                            \$extList = \$extensions -split ','
+                            \$items = Get-ChildItem -File -Path "\${prefix}*" -ErrorAction SilentlyContinue |
+                                Where-Object {
+                                    \$ext = \$_.Extension
+                                    \$extList | ForEach-Object { if (\$ext -eq ".\$_") { return \$true } }
+                                }
+                        } else {
+                            \$items = Get-ChildItem -File -Path "\${prefix}*" -ErrorAction SilentlyContinue
+                        }
+                    }
+                    'directory' {
+                        \$items = Get-ChildItem -Directory -Path "\${prefix}*" -ErrorAction SilentlyContinue
+                    }
+                    'any' {
+                        if (\$extensions) {
+                            # Get directories and filtered files
+                            \$dirs = Get-ChildItem -Directory -Path "\${prefix}*" -ErrorAction SilentlyContinue
+                            \$extList = \$extensions -split ','
+                            \$files = Get-ChildItem -File -Path "\${prefix}*" -ErrorAction SilentlyContinue |
+                                Where-Object {
+                                    \$ext = \$_.Extension
+                                    \$extList | ForEach-Object { if (\$ext -eq ".\$_") { return \$true } }
+                                }
+                            \$items = \$dirs + \$files
+                        } else {
+                            \$items = Get-ChildItem -Path "\${prefix}*" -ErrorAction SilentlyContinue
+                        }
+                    }
+                }
+
+                # Filter hidden files unless requested
+                if (-not \$hidden) {
+                    \$items = \$items | Where-Object { -not \$_.Attributes.HasFlag([System.IO.FileAttributes]::Hidden) }
+                }
+
+                # Create completion results for files
+                \$items | ForEach-Object {
+                    \$completionText = if (\$_.PSIsContainer) { "\$(\$_.Name)/" } else { \$_.Name }
+                    \$itemType = if (\$_.PSIsContainer) { 'Directory' } else { 'File' }
+                    [System.Management.Automation.CompletionResult]::new(
+                        \$completionText,
+                        \$completionText,
+                        'ParameterValue',
+                        \$itemType
+                    )
+                }
+            } else {
+                # Parse literal completion: text\\tlistItemText\\tdescription
+                \$parts = \$line -split "\`t", 3
+                \$completionText = \$parts[0]
+                \$listItemText = if (\$parts.Length -gt 1 -and \$parts[1]) { \$parts[1] } else { \$completionText }
+                \$toolTip = if (\$parts.Length -gt 2 -and \$parts[2]) { \$parts[2] } else { \$completionText }
+
+                [System.Management.Automation.CompletionResult]::new(
+                    \$completionText,
+                    \$listItemText,
+                    'ParameterValue',
+                    \$toolTip
+                )
+            }
+        }
+    } catch {
+        # Silently ignore errors
+    }
+}
+    `;
+	},
+	*encodeSuggestions(suggestions) {
+		let i = 0;
+		for (const suggestion of suggestions) {
+			if (i > 0) yield "\n";
+			if (suggestion.kind === "literal") {
+				const description = suggestion.description == null ? "" : formatMessage(suggestion.description, { colors: false });
+				yield `${suggestion.text}\t${suggestion.text}\t${description}`;
+			} else {
+				const extensions = suggestion.extensions?.join(",") || "";
+				const hidden = suggestion.includeHidden ? "1" : "0";
+				const description = suggestion.description == null ? "" : formatMessage(suggestion.description, { colors: false });
+				yield `__FILE__:${suggestion.type}:${extensions}:${suggestion.pattern || ""}:${hidden}\t[file]\t${description}`;
+			}
+			i++;
+		}
+	}
+};
+
+//#endregion
+export { bash, fish, pwsh, zsh };

package/dist/constructs.cjs

@@ -74,6 +74,33 @@ function or(...args) {
 				success: false
 			};
 		},
+		suggest(context, prefix) {
+			const suggestions = [];
+			if (context.state == null) for (const parser of parsers) {
+				const parserSuggestions = parser.suggest({
+					...context,
+					state: parser.initialState
+				}, prefix);
+				suggestions.push(...parserSuggestions);
+			}
+			else {
+				const [index, parserResult] = context.state;
+				if (parserResult.success) {
+					const parserSuggestions = parsers[index].suggest({
+						...context,
+						state: parserResult.next.state
+					}, prefix);
+					suggestions.push(...parserSuggestions);
+				}
+			}
+			const seen = /* @__PURE__ */ new Set();
+			return suggestions.filter((suggestion) => {
+				const key = suggestion.kind === "literal" ? suggestion.text : `__FILE__:${suggestion.type}:${suggestion.extensions?.join(",")}:${suggestion.pattern}`;
+				if (seen.has(key)) return false;
+				seen.add(key);
+				return true;
+			});
+		},
 		getDocFragments(state, _defaultValue) {
 			let description;
 			let fragments;
@@ -182,6 +209,33 @@ function longestMatch(...args) {
 				success: false
 			};
 		},
+		suggest(context, prefix) {
+			const suggestions = [];
+			if (context.state == null) for (const parser of parsers) {
+				const parserSuggestions = parser.suggest({
+					...context,
+					state: parser.initialState
+				}, prefix);
+				suggestions.push(...parserSuggestions);
+			}
+			else {
+				const [index, parserResult] = context.state;
+				if (parserResult.success) {
+					const parserSuggestions = parsers[index].suggest({
+						...context,
+						state: parserResult.next.state
+					}, prefix);
+					suggestions.push(...parserSuggestions);
+				}
+			}
+			const seen = /* @__PURE__ */ new Set();
+			return suggestions.filter((suggestion) => {
+				const key = suggestion.kind === "literal" ? suggestion.text : `__FILE__:${suggestion.type}:${suggestion.extensions?.join(",")}:${suggestion.pattern}`;
+				if (seen.has(key)) return false;
+				seen.add(key);
+				return true;
+			});
+		},
 		getDocFragments(state, _defaultValue) {
 			let description;
 			let fragments;
@@ -302,6 +356,24 @@ function object(labelOrParsers, maybeParsersOrOptions, maybeOptions) {
 				value: result
 			};
 		},
+		suggest(context, prefix) {
+			const suggestions = [];
+			for (const [field, parser] of parserPairs) {
+				const fieldState = context.state && typeof context.state === "object" && field in context.state ? context.state[field] : parser.initialState;
+				const fieldSuggestions = parser.suggest({
+					...context,
+					state: fieldState
+				}, prefix);
+				suggestions.push(...fieldSuggestions);
+			}
+			const seen = /* @__PURE__ */ new Set();
+			return suggestions.filter((suggestion) => {
+				const key = suggestion.kind === "literal" ? suggestion.text : `__FILE__:${suggestion.type}:${suggestion.extensions?.join(",")}:${suggestion.pattern}`;
+				if (seen.has(key)) return false;
+				seen.add(key);
+				return true;
+			});
+		},
 		getDocFragments(state, defaultValue) {
 			const fragments = parserPairs.flatMap(([field, p]) => {
 				const fieldState = state.kind === "unavailable" ? { kind: "unavailable" } : {
@@ -412,6 +484,25 @@ function tuple(labelOrParsers, maybeParsers) {
 				value: result
 			};
 		},
+		suggest(context, prefix) {
+			const suggestions = [];
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				const parserState = context.state && Array.isArray(context.state) ? context.state[i] : parser.initialState;
+				const parserSuggestions = parser.suggest({
+					...context,
+					state: parserState
+				}, prefix);
+				suggestions.push(...parserSuggestions);
+			}
+			const seen = /* @__PURE__ */ new Set();
+			return suggestions.filter((suggestion) => {
+				const key = suggestion.kind === "literal" ? suggestion.text : `__FILE__:${suggestion.type}:${suggestion.extensions?.join(",")}:${suggestion.pattern}`;
+				if (seen.has(key)) return false;
+				seen.add(key);
+				return true;
+			});
+		},
 		getDocFragments(state, defaultValue) {
 			const fragments = parsers.flatMap((p, i) => {
 				const indexState = state.kind === "unavailable" ? { kind: "unavailable" } : {
@@ -523,6 +614,35 @@ function merge(...args) {
 				value: object$1
 			};
 		},
+		suggest(context, prefix) {
+			const suggestions = [];
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				let parserState;
+				if (parser.initialState === void 0) {
+					const key = `__parser_${i}`;
+					if (context.state && typeof context.state === "object" && key in context.state) parserState = context.state[key];
+					else parserState = void 0;
+				} else if (parser.initialState && typeof parser.initialState === "object") if (context.state && typeof context.state === "object") {
+					const extractedState = {};
+					for (const field in parser.initialState) extractedState[field] = field in context.state ? context.state[field] : parser.initialState[field];
+					parserState = extractedState;
+				} else parserState = parser.initialState;
+				else parserState = parser.initialState;
+				const parserSuggestions = parser.suggest({
+					...context,
+					state: parserState
+				}, prefix);
+				suggestions.push(...parserSuggestions);
+			}
+			const seen = /* @__PURE__ */ new Set();
+			return suggestions.filter((suggestion) => {
+				const key = suggestion.kind === "literal" ? suggestion.text : `__FILE__:${suggestion.type}:${suggestion.extensions?.join(",")}:${suggestion.pattern}`;
+				if (seen.has(key)) return false;
+				seen.add(key);
+				return true;
+			});
+		},
 		getDocFragments(state, _defaultValue) {
 			const fragments = parsers.flatMap((p) => {
 				const parserState = p.initialState === void 0 ? { kind: "unavailable" } : state.kind === "unavailable" ? { kind: "unavailable" } : {
@@ -641,6 +761,25 @@ function concat(...parsers) {
 				value: results
 			};
 		},
+		suggest(context, prefix) {
+			const suggestions = [];
+			for (let i = 0; i < parsers.length; i++) {
+				const parser = parsers[i];
+				const parserState = context.state && Array.isArray(context.state) ? context.state[i] : parser.initialState;
+				const parserSuggestions = parser.suggest({
+					...context,
+					state: parserState
+				}, prefix);
+				suggestions.push(...parserSuggestions);
+			}
+			const seen = /* @__PURE__ */ new Set();
+			return suggestions.filter((suggestion) => {
+				const key = suggestion.kind === "literal" ? suggestion.text : `__FILE__:${suggestion.type}:${suggestion.extensions?.join(",")}:${suggestion.pattern}`;
+				if (seen.has(key)) return false;
+				seen.add(key);
+				return true;
+			});
+		},
 		getDocFragments(state, _defaultValue) {
 			const fragments = parsers.flatMap((p, index) => {
 				const indexState = state.kind === "unavailable" ? { kind: "unavailable" } : {
@@ -719,6 +858,7 @@ function group(label, parser) {
 		initialState: parser.initialState,
 		parse: (context) => parser.parse(context),
 		complete: (state) => parser.complete(state),
+		suggest: (context, prefix) => parser.suggest(context, prefix),
 		getDocFragments: (state, defaultValue) => {
 			const { description, fragments } = parser.getDocFragments(state, defaultValue);
 			const allEntries = [];