@shell-shock/core 0.17.7 → 0.17.8

package/dist/components/utils-builtin.mjs

@@ -1,50 +1,4 @@
-import { createComponent, createIntrinsic, memo, mergeProps } from "@alloy-js/core/jsx-runtime";
-import defu$1 from "defu";
-import { Show, code, splitProps } from "@alloy-js/core";
-import { Spacing } from "@powerlines/plugin-alloy/core/components/spacing";
-import { usePowerlines } from "@powerlines/plugin-alloy/core/contexts/context";
-import { FunctionDeclaration, IfStatement, InterfaceDeclaration, InterfaceMember, VarDeclaration } from "@alloy-js/typescript";
-import { BuiltinFile } from "@powerlines/plugin-alloy/typescript/components/builtin-file";
-import { TSDoc, TSDocInternal, TSDocLink, TSDocParam, TSDocRemarks, TSDocReturns } from "@powerlines/plugin-alloy/typescript/components/tsdoc";
-
-//#region src/components/utils-builtin.tsx
-const __ΩOmit = [
-	"T",
-	"K",
-	() => __ΩPick,
-	() => __ΩExclude,
-	"Omit",
-	"b!b\"e!!e!!ge!\"o$#o##w%y"
-];
-const __ΩPick = [
-	"T",
-	"K",
-	"Pick",
-	"l+e#!e\"!fRb!b\"Pde\"\"N#!w#y"
-];
-const __ΩExclude = [
-	"T",
-	"U",
-	"Exclude",
-	"l6!Re$!RPe#!e$\"qk#%QRb!b\"Pde\"!p)w#y"
-];
-const __ΩUtilsBuiltinProps = [
-	() => __ΩOmit,
-	"id",
-	"description",
-	"UtilsBuiltinProps",
-	"P!P.\".#Jo!#Mw$y"
-];
-/**
-* Generates the `findSuggestions` function for suggesting corrections for potentially misspelled options or commands.
-*/
-function FindSuggestionsDeclaration() {
-	const context = (usePowerlines.Ω = [["Context", "\"w!"]], usePowerlines());
-	return [
-		createComponent(VarDeclaration, {
-			"const": true,
-			name: "deburred",
-			initializer: code` {
+import{createComponent as e,createIntrinsic as t,memo as n,mergeProps as r}from"@alloy-js/core/jsx-runtime";import i from"defu";import{Show as a,code as o,splitProps as s}from"@alloy-js/core";import{Spacing as c}from"@powerlines/plugin-alloy/core/components/spacing";import{usePowerlines as l}from"@powerlines/plugin-alloy/core/contexts/context";import{FunctionDeclaration as u,IfStatement as d,InterfaceDeclaration as f,InterfaceMember as p,VarDeclaration as m}from"@alloy-js/typescript";import{BuiltinFile as h}from"@powerlines/plugin-alloy/typescript/components/builtin-file";import{TSDoc as g,TSDocInternal as _,TSDocLink as v,TSDocParam as y,TSDocRemarks as b,TSDocReturns as x}from"@powerlines/plugin-alloy/typescript/components/tsdoc";const S=[`T`,`K`,()=>C,()=>w,`Omit`,`b!b"e!!e!!ge!"o$#o##w%y`],C=[`T`,`K`,`Pick`,`l+e#!e"!fRb!b"Pde""N#!w#y`],w=[`T`,`U`,`Exclude`,`l6!Re$!RPe#!e$"qk#%QRb!b"Pde"!p)w#y`],T=[()=>S,`id`,`description`,`UtilsBuiltinProps`,`P!P.".#Jo!#Mw$y`];function E(){let t=(l.Ω=[[`Context`,`"w!`]],l());return[e(m,{const:!0,name:`deburred`,initializer:o` {
           "\\xc0": "A",  "\\xc1": "A", "\\xc2": "A", "\\xc3": "A", "\\xc4": "A", "\\xc5": "A",
           "\\xe0": "a",  "\\xe1": "a", "\\xe2": "a", "\\xe3": "a", "\\xe4": "a", "\\xe5": "a",
           "\\xc7": "C",  "\\xe7": "c",
@@ -97,51 +51,7 @@ function FindSuggestionsDeclaration() {
           "\\u0132": "IJ", "\\u0133": "ij",
           "\\u0152": "Oe", "\\u0153": "oe",
           "\\u0149": "n", "\\u017f": "s"
-        } as Record<string, string>; `
-		}),
-		createComponent(Spacing, {}),
-		createComponent(TSDoc, {
-			heading: "A utility function that takes an input string and a list of possible matches, and returns a list of suggested matches based on the Levenshtein distance between the input and the possible matches.",
-			get children() {
-				return [
-					createComponent(TSDocRemarks, { children: "This function is intended to be used to suggest corrections for potentially misspelled options or commands." }),
-					createComponent(Spacing, {}),
-					createComponent(TSDocInternal, {}),
-					createComponent(Spacing, {}),
-					createComponent(TSDocParam, {
-						name: "input",
-						children: "The input string to check for potential matches."
-					}),
-					createComponent(TSDocParam, {
-						name: "options",
-						children: "A list of possible matches to compare against the input."
-					}),
-					createComponent(TSDocReturns, { children: "A list of suggested matches based on the Levenshtein distance." })
-				];
-			}
-		}),
-		createComponent(FunctionDeclaration, {
-			"export": true,
-			name: "findSuggestions",
-			parameters: [{
-				name: "input",
-				type: "string"
-			}, {
-				name: "options",
-				type: "string[]"
-			}],
-			returnType: "string[]",
-			get children() {
-				return [
-					createComponent(VarDeclaration, {
-						"const": true,
-						name: "normalizedInput",
-						get initializer() {
-							return code`String(input ?? "")${context.config.isCaseSensitive ? "" : ".toLowerCase()"}.trim().replaceAll(/[\\s\\-_\\.]+/gu, " ").replace(/[\\\\xc0-\\\\xd6\\\\xd8-\\\\xf6\\\\xf8-\\\\xff\\\\u0100-\\\\u017f]/g, key => deburred[key]).replace(/[\\\\u0300-\\\\u036f\\\\ufe20-\\\\ufe2f\\\\u20d0-\\\\u20ff]/g, ""); `;
-						}
-					}),
-					createComponent(Spacing, {}),
-					memo(() => code`
+        } as Record<string, string>; `}),e(c,{}),e(g,{heading:`A utility function that takes an input string and a list of possible matches, and returns a list of suggested matches based on the Levenshtein distance between the input and the possible matches.`,get children(){return[e(b,{children:`This function is intended to be used to suggest corrections for potentially misspelled options or commands.`}),e(c,{}),e(_,{}),e(c,{}),e(y,{name:`input`,children:`The input string to check for potential matches.`}),e(y,{name:`options`,children:`A list of possible matches to compare against the input.`}),e(x,{children:`A list of suggested matches based on the Levenshtein distance.`})]}}),e(u,{export:!0,name:`findSuggestions`,parameters:[{name:`input`,type:`string`},{name:`options`,type:`string[]`}],returnType:`string[]`,get children(){return[e(m,{const:!0,name:`normalizedInput`,get initializer(){return o`String(input ?? "")${t.config.isCaseSensitive?``:`.toLowerCase()`}.trim().replaceAll(/[\\s\\-_\\.]+/gu, " ").replace(/[\\\\xc0-\\\\xd6\\\\xd8-\\\\xf6\\\\xf8-\\\\xff\\\\u0100-\\\\u017f]/g, key => deburred[key]).replace(/[\\\\u0300-\\\\u036f\\\\ufe20-\\\\ufe2f\\\\u20d0-\\\\u20ff]/g, ""); `}}),e(c,{}),n(()=>o`
         if (!normalizedInput || options.length === 0) {
           return [];
         }
@@ -150,7 +60,7 @@ function FindSuggestionsDeclaration() {
         const results: Array<{ option: string; distance: number }> = [];
 
         for (const option of options) {
-          const normalizedOption = String(option ?? "")${context.config.isCaseSensitive ? "" : ".toLowerCase()"}.trim().replaceAll(/[\\s\\-_\\.]+/gu, " ").replace(/[\\\\xc0-\\\\xd6\\\\xd8-\\\\xf6\\\\xf8-\\\\xff\\\\u0100-\\\\u017f]/g, key => deburred[key]).replace(/[\\\\u0300-\\\\u036f\\\\ufe20-\\\\ufe2f\\\\u20d0-\\\\u20ff]/g, "");
+          const normalizedOption = String(option ?? "")${t.config.isCaseSensitive?``:`.toLowerCase()`}.trim().replaceAll(/[\\s\\-_\\.]+/gu, " ").replace(/[\\\\xc0-\\\\xd6\\\\xd8-\\\\xf6\\\\xf8-\\\\xff\\\\u0100-\\\\u017f]/g, key => deburred[key]).replace(/[\\\\u0300-\\\\u036f\\\\ufe20-\\\\ufe2f\\\\u20d0-\\\\u20ff]/g, "");
 
           if (!normalizedOption) {
             continue;
@@ -227,41 +137,7 @@ function FindSuggestionsDeclaration() {
         }
 
         return results.sort((a, b) => a.distance - b.distance).map(r => r.option);
-        `)
-				];
-			}
-		})
-	];
-}
-FindSuggestionsDeclaration.__type = [
-	"FindSuggestionsDeclaration",
-	"Generates the `findSuggestions` function for suggesting corrections for potentially misspelled options or commands.",
-	"P\"/!?\""
-];
-/**
-* Generates utilities for detecting terminal size and whether the process is running in the foreground, which can be used to determine how to render output (e.g., whether to use a progress bar or spinner).
-*/
-function TerminalSizeDeclaration() {
-	return [
-		createComponent(VarDeclaration, {
-			"export": true,
-			"const": true,
-			name: "DEFAULT_TERMINAL_COLUMNS",
-			doc: "Default number of terminal columns",
-			initializer: code`80`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(VarDeclaration, {
-			"export": true,
-			"const": true,
-			name: "DEFAULT_TERMINAL_ROWS",
-			doc: "Default number of terminal rows",
-			initializer: code`24`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "isForegroundProcess",
-			children: code`if (isLinux) {
+        `)]}})]}E.__type=[`FindSuggestionsDeclaration`,"Generates the `findSuggestions` function for suggesting corrections for potentially misspelled options or commands.",`P"/!?"`];function D(){return[e(m,{export:!0,const:!0,name:`DEFAULT_TERMINAL_COLUMNS`,doc:`Default number of terminal columns`,initializer:o`80`}),e(c,{}),e(m,{export:!0,const:!0,name:`DEFAULT_TERMINAL_ROWS`,doc:`Default number of terminal rows`,initializer:o`24`}),e(c,{}),e(u,{name:`isForegroundProcess`,children:o`if (isLinux) {
           return true;
         }
 
@@ -288,24 +164,14 @@ function TerminalSizeDeclaration() {
           return processGroupId === foregroundProcessGroupId;
         } catch {
           return false;
-        } `
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "tput",
-			children: code`try {
+        } `}),e(c,{}),e(u,{name:`tput`,children:o`try {
             const columns = execSync(["tput", "cols"], { env: { TERM: 'dumb', ...process.env } });
             const rows = execSync(["tput", "lines"], { env: { TERM: 'dumb', ...process.env } });
 
             if (columns && rows) {
               return { columns: Number.parseInt(columns.toString().trim(), 10), rows: Number.parseInt(rows.toString().trim(), 10) };
             }
-          } catch {}  `
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "devTty",
-			children: code`try {
+          } catch {}  `}),e(c,{}),e(u,{name:`devTty`,children:o`try {
           const writeStream = new WriteStream(
             openSync(
               "/dev/tty",
@@ -314,160 +180,21 @@ function TerminalSizeDeclaration() {
           ).getWindowSize();
 
           return { columns: writeStream[0], rows: writeStream[1] };
-        } catch {}  `
-		}),
-		createComponent(Spacing, {}),
-		createComponent(TSDoc, {
-			heading: "A utility function that attempts to determine the size of the terminal (number of columns and rows) using various methods, and falls back to default values if it cannot be determined. This can be used to adjust output formatting based on the available terminal size.",
-			get children() {
-				return [
-					createComponent(TSDocRemarks, { children: "The function first checks if the process is running in a TTY environment and if the stdout or stderr streams provide column and row information. If not, it attempts to use platform-specific methods (like reading from /proc/self/stat on Linux, using tput on Unix-like systems, or checking /dev/tty) to determine the terminal size. If all else fails, it returns default values." }),
-					createComponent(Spacing, {}),
-					createComponent(TSDocReturns, { children: "An object containing the number of columns and rows of the terminal." })
-				];
-			}
-		}),
-		createComponent(FunctionDeclaration, {
-			"export": true,
-			name: "getTerminalSize",
-			returnType: "{ columns: number; rows: number; }",
-			get children() {
-				return [
-					createComponent(IfStatement, {
-						condition: code`process.stdout?.columns && process.stdout?.rows`,
-						children: code`return { columns: process.stdout.columns, rows: process.stdout.rows }; `
-					}),
-					createComponent(IfStatement, {
-						condition: code`process.stderr?.columns && process.stderr?.rows`,
-						children: code`return { columns: process.stderr.columns, rows: process.stderr.rows };`
-					}),
-					createComponent(Spacing, {}),
-					createComponent(IfStatement, {
-						condition: code`isWindows`,
-						children: code`return tput() ?? {
+        } catch {}  `}),e(c,{}),e(g,{heading:`A utility function that attempts to determine the size of the terminal (number of columns and rows) using various methods, and falls back to default values if it cannot be determined. This can be used to adjust output formatting based on the available terminal size.`,get children(){return[e(b,{children:`The function first checks if the process is running in a TTY environment and if the stdout or stderr streams provide column and row information. If not, it attempts to use platform-specific methods (like reading from /proc/self/stat on Linux, using tput on Unix-like systems, or checking /dev/tty) to determine the terminal size. If all else fails, it returns default values.`}),e(c,{}),e(x,{children:`An object containing the number of columns and rows of the terminal.`})]}}),e(u,{export:!0,name:`getTerminalSize`,returnType:`{ columns: number; rows: number; }`,get children(){return[e(d,{condition:o`process.stdout?.columns && process.stdout?.rows`,children:o`return { columns: process.stdout.columns, rows: process.stdout.rows }; `}),e(d,{condition:o`process.stderr?.columns && process.stderr?.rows`,children:o`return { columns: process.stderr.columns, rows: process.stderr.rows };`}),e(c,{}),e(d,{condition:o`isWindows`,children:o`return tput() ?? {
             columns: DEFAULT_TERMINAL_COLUMNS,
             rows: DEFAULT_TERMINAL_ROWS,
-          }; `
-					}),
-					createComponent(IfStatement, {
-						condition: code`isMacOS`,
-						children: code`return devTty() ?? tput() ?? {
+          }; `}),e(d,{condition:o`isMacOS`,children:o`return devTty() ?? tput() ?? {
             columns: DEFAULT_TERMINAL_COLUMNS,
             rows: DEFAULT_TERMINAL_ROWS,
-          }; `
-					}),
-					createComponent(Spacing, {}),
-					createComponent(VarDeclaration, {
-						"let": true,
-						name: "result",
-						initializer: code`devTty() ?? tput(); `
-					}),
-					createComponent(IfStatement, {
-						condition: code`!result && isForegroundProcess()`,
-						children: code`try {
+          }; `}),e(c,{}),e(m,{let:!0,name:`result`,initializer:o`devTty() ?? tput(); `}),e(d,{condition:o`!result && isForegroundProcess()`,children:o`try {
           const size = execSync(["resize", "-u"]).match(/\\d+/g);
           if (size.length === 2) {
             result = { columns: Number.parseInt(size[0], 10), rows: Number.parseInt(size[1], 10) };
           }
-        } catch {} `
-					}),
-					createComponent(Spacing, {}),
-					code`return result ?? {
+        } catch {} `}),e(c,{}),o`return result ?? {
           columns: DEFAULT_TERMINAL_COLUMNS,
           rows: DEFAULT_TERMINAL_ROWS,
-        }; `
-				];
-			}
-		})
-	];
-}
-TerminalSizeDeclaration.__type = [
-	"TerminalSizeDeclaration",
-	"Generates utilities for detecting terminal size and whether the process is running in the foreground, which can be used to determine how to render output (e.g., whether to use a progress bar or spinner).",
-	"P\"/!?\""
-];
-/**
-* Generates utilities for detecting terminal color support.
-*/
-function EnvSupportUtilities() {
-	return [
-		createComponent(VarDeclaration, {
-			"export": true,
-			"const": true,
-			name: "isTTY",
-			doc: "Detect if stdout.TTY is available",
-			initializer: code`Boolean(process.stdout && process.stdout.isTTY);`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(VarDeclaration, {
-			"export": true,
-			"const": true,
-			name: "isMinimal",
-			doc: "Detect if the current environment is minimal (CI, non-TTY, etc.)",
-			initializer: code` env.MINIMAL || isCI || isTest || !isTTY; `
-		}),
-		createComponent(Spacing, {}),
-		createComponent(VarDeclaration, {
-			"export": true,
-			"const": true,
-			name: "isInteractive",
-			doc: "Detect if the current environment is interactive",
-			initializer: code` !isMinimal && process.stdin?.isTTY && env.TERM !== "dumb" && !hasFlag(["no-interactive", "non-interactive", "no-interact"]); `
-		})
-	];
-}
-EnvSupportUtilities.__type = [
-	"EnvSupportUtilities",
-	"Generates utilities for detecting terminal color support.",
-	"P\"/!?\""
-];
-/**
-* Generates utilities for detecting terminal color support.
-*/
-function ColorSupportUtilities() {
-	return [
-		createComponent(InterfaceDeclaration, {
-			"export": true,
-			name: "GetColorSupportLevelOptions",
-			doc: "Options for the getColorSupportLevel function",
-			get children() {
-				return createComponent(InterfaceMember, {
-					name: "ignoreFlags",
-					type: "boolean",
-					doc: "Indicates if the function should skip checking command-line flags for color support"
-				});
-			}
-		}),
-		createComponent(Spacing, {}),
-		createComponent(TSDoc, {
-			heading: "Checks if a specific flag is present in the command-line arguments.",
-			get children() {
-				return [
-					createComponent(TSDocLink, { children: "https://github.com/sindresorhus/has-flag/blob/main/index.js" }),
-					createComponent(TSDocParam, {
-						name: "flag",
-						children: "The flag to check for, e.g., \"color\", \"no-color\"."
-					}),
-					createComponent(TSDocParam, {
-						name: "argv",
-						children: "The command-line arguments to check against. Defaults to global Deno args or process args."
-					}),
-					createComponent(TSDocReturns, { children: "True if the flag is present, false otherwise." })
-				];
-			}
-		}),
-		createComponent(FunctionDeclaration, {
-			"export": true,
-			name: "getColorSupportLevel",
-			parameters: [{
-				name: "stream",
-				type: "NodeJS.WriteStream & { fd: 1 | 2; }"
-			}, {
-				name: "options",
-				type: "GetColorSupportLevelOptions",
-				default: "{ ignoreFlags: false }"
-			}],
-			children: code`const { ignoreFlags } = options;
+        }; `]}})]}D.__type=[`TerminalSizeDeclaration`,`Generates utilities for detecting terminal size and whether the process is running in the foreground, which can be used to determine how to render output (e.g., whether to use a progress bar or spinner).`,`P"/!?"`];function O(){return[e(m,{export:!0,const:!0,name:`isTTY`,doc:`Detect if stdout.TTY is available`,initializer:o`Boolean(process.stdout && process.stdout.isTTY);`}),e(c,{}),e(m,{export:!0,const:!0,name:`isMinimal`,doc:`Detect if the current environment is minimal (CI, non-TTY, etc.)`,initializer:o` env.MINIMAL || isCI || isTest || !isTTY; `}),e(c,{}),e(m,{export:!0,const:!0,name:`isInteractive`,doc:`Detect if the current environment is interactive`,initializer:o` !isMinimal && process.stdin?.isTTY && env.TERM !== "dumb" && !hasFlag(["no-interactive", "non-interactive", "no-interact"]); `})]}O.__type=[`EnvSupportUtilities`,`Generates utilities for detecting terminal color support.`,`P"/!?"`];function k(){return[e(f,{export:!0,name:`GetColorSupportLevelOptions`,doc:`Options for the getColorSupportLevel function`,get children(){return e(p,{name:`ignoreFlags`,type:`boolean`,doc:`Indicates if the function should skip checking command-line flags for color support`})}}),e(c,{}),e(g,{heading:`Checks if a specific flag is present in the command-line arguments.`,get children(){return[e(v,{children:`https://github.com/sindresorhus/has-flag/blob/main/index.js`}),e(y,{name:`flag`,children:`The flag to check for, e.g., "color", "no-color".`}),e(y,{name:`argv`,children:`The command-line arguments to check against. Defaults to global Deno args or process args.`}),e(x,{children:`True if the flag is present, false otherwise.`})]}}),e(u,{export:!0,name:`getColorSupportLevel`,parameters:[{name:`stream`,type:`NodeJS.WriteStream & { fd: 1 | 2; }`},{name:`options`,type:`GetColorSupportLevelOptions`,default:`{ ignoreFlags: false }`}],children:o`const { ignoreFlags } = options;
 
         let forceColor: number | undefined;
         if (env.FORCE_COLOR !== undefined) {
@@ -576,34 +303,10 @@ function ColorSupportUtilities() {
               has16m: level >= 3,
             };
 
-  `
-		}),
-		createComponent(Spacing, {}),
-		createComponent(VarDeclaration, {
-			"export": true,
-			"const": true,
-			name: "colorSupportLevels",
-			doc: "Detect the terminal color support level in the current environment",
-			initializer: code` {
+  `}),e(c,{}),e(m,{export:!0,const:!0,name:`colorSupportLevels`,doc:`Detect the terminal color support level in the current environment`,initializer:o` {
     stdout: getColorSupportLevel(process.stdout),
     stderr: getColorSupportLevel(process.stderr),
-  }; `
-		}),
-		createComponent(Spacing, {}),
-		createComponent(VarDeclaration, {
-			"export": true,
-			"const": true,
-			name: "isColorSupported",
-			doc: "Detect if terminal color is supported in the current environment",
-			initializer: code` Boolean(colorSupportLevels.stdout); `
-		}),
-		createComponent(Spacing, {}),
-		createComponent(VarDeclaration, {
-			"export": true,
-			"const": true,
-			name: "isUnicodeSupported",
-			doc: "Detect if Unicode characters are supported in the current environment",
-			initializer: code` !isWindows
+  }; `}),e(c,{}),e(m,{export:!0,const:!0,name:`isColorSupported`,doc:`Detect if terminal color is supported in the current environment`,initializer:o` Boolean(colorSupportLevels.stdout); `}),e(c,{}),e(m,{export:!0,const:!0,name:`isUnicodeSupported`,doc:`Detect if Unicode characters are supported in the current environment`,initializer:o` !isWindows
             ? env.TERM !== "linux"
             : Boolean(env.WT_SESSION) ||
                 Boolean(env.TERMINUS_SUBLIME) ||
@@ -614,28 +317,7 @@ function ColorSupportUtilities() {
                 env.TERM === "alacritty" ||
                 env.TERM === "rxvt-unicode" ||
                 env.TERM === "rxvt-unicode-256color" ||
-                env.TERMINAL_EMULATOR === "JetBrains-JediTerm"; `
-		})
-	];
-}
-ColorSupportUtilities.__type = [
-	"ColorSupportUtilities",
-	"Generates utilities for detecting terminal color support.",
-	"P\"/!?\""
-];
-/**
-* Generates utilities for detecting terminal color support.
-*/
-function HyperlinkSupportUtilities() {
-	return [
-		createComponent(FunctionDeclaration, {
-			name: "parseVersion",
-			parameters: [{
-				name: "version",
-				type: "string",
-				default: "\"\""
-			}],
-			children: code`if (/^\d{3,4}$/.test(version)) {
+                env.TERMINAL_EMULATOR === "JetBrains-JediTerm"; `})]}k.__type=[`ColorSupportUtilities`,`Generates utilities for detecting terminal color support.`,`P"/!?"`];function A(){return[e(u,{name:`parseVersion`,parameters:[{name:`version`,type:`string`,default:`""`}],children:o`if (/^\d{3,4}$/.test(version)) {
         const match = /(\d{1,2})(\d{2})/.exec(version) ?? [];
 
         return {
@@ -653,20 +335,7 @@ function HyperlinkSupportUtilities() {
         major: versionParts[0],
         minor: versionParts[1],
         patch: versionParts[2]
-      }; `
-		}),
-		createComponent(Spacing, {}),
-		createComponent(TSDoc, {
-			heading: "Check if the current environment/terminal supports hyperlinks in the terminal.",
-			get children() {
-				return createComponent(TSDocReturns, { children: "True if the current environment/terminal supports hyperlinks." });
-			}
-		}),
-		createComponent(FunctionDeclaration, {
-			"export": true,
-			name: "isHyperlinkSupported",
-			returnType: "boolean",
-			children: code`if (Boolean(env.FORCE_HYPERLINK)) {
+      }; `}),e(c,{}),e(g,{heading:`Check if the current environment/terminal supports hyperlinks in the terminal.`,get children(){return e(x,{children:`True if the current environment/terminal supports hyperlinks.`})}}),e(u,{export:!0,name:`isHyperlinkSupported`,returnType:`boolean`,children:o`if (Boolean(env.FORCE_HYPERLINK)) {
           return true;
         }
 
@@ -727,126 +396,7 @@ function HyperlinkSupportUtilities() {
           return true;
         }
 
-        return false; `
-		})
-	];
-}
-HyperlinkSupportUtilities.__type = [
-	"HyperlinkSupportUtilities",
-	"Generates utilities for detecting terminal color support.",
-	"P\"/!?\""
-];
-/**
-* Generates the `resolveModule` function declaration, which is a utility for resolving file paths across different platforms.
-*/
-function ResolveModuleFunctionDeclaration() {
-	const context = (usePowerlines.Ω = [["Context", "\"w!"]], usePowerlines());
-	return [
-		createComponent(Spacing, {}),
-		createComponent(InterfaceDeclaration, {
-			name: "ResolveModuleOptions",
-			doc: "Options for the `resolve` handler function.",
-			get children() {
-				return [
-					createComponent(InterfaceMember, {
-						name: "parentURL",
-						optional: true,
-						type: "string",
-						doc: "The parent URL to use for resolving paths."
-					}),
-					createIntrinsic("hbr", {}),
-					createComponent(InterfaceMember, {
-						name: "conditions",
-						optional: true,
-						type: "string[]",
-						doc: "The conditions to use for resolving paths."
-					}),
-					createIntrinsic("hbr", {})
-				];
-			}
-		}),
-		createComponent(Spacing, {}),
-		createComponent(InterfaceDeclaration, {
-			name: "PackageConfig",
-			doc: "Parsed package.json configuration for module resolution.",
-			get children() {
-				return [
-					createComponent(InterfaceMember, {
-						name: "pjsonPath",
-						type: "string",
-						doc: "The path to the package.json file."
-					}),
-					createIntrinsic("hbr", {}),
-					createComponent(InterfaceMember, {
-						name: "exists",
-						type: "boolean",
-						doc: "Whether the package.json file exists."
-					}),
-					createIntrinsic("hbr", {}),
-					createComponent(InterfaceMember, {
-						name: "main",
-						optional: true,
-						type: "string",
-						doc: "The main entry point of the package."
-					}),
-					createIntrinsic("hbr", {}),
-					createComponent(InterfaceMember, {
-						name: "name",
-						optional: true,
-						type: "string",
-						doc: "The name of the package."
-					}),
-					createIntrinsic("hbr", {}),
-					createComponent(InterfaceMember, {
-						name: "type",
-						optional: true,
-						type: `"commonjs" | "module" | "none"`,
-						doc: "The module type of the package."
-					}),
-					createIntrinsic("hbr", {}),
-					createComponent(InterfaceMember, {
-						name: "exports",
-						optional: true,
-						type: "Record<string, unknown>",
-						doc: "The exports map of the package."
-					}),
-					createIntrinsic("hbr", {}),
-					createComponent(InterfaceMember, {
-						name: "imports",
-						optional: true,
-						type: "Record<string, unknown>",
-						doc: "The imports map of the package."
-					})
-				];
-			}
-		}),
-		createComponent(Spacing, {}),
-		createComponent(VarDeclaration, {
-			"const": true,
-			name: "DEFAULT_CONDITIONS_SET",
-			initializer: code`new Set(["node", "import"]);`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(VarDeclaration, {
-			"const": true,
-			name: "DEFAULT_EXTENSIONS",
-			initializer: code`[".mjs", ".cjs", ".js", ".json", ".node"];`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(VarDeclaration, {
-			"const": true,
-			name: "invalidPackageNameRegEx",
-			initializer: code`/^\\.|\\/|%/;`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "readPackageConfig",
-			parameters: [{
-				name: "jsonPath",
-				type: "string"
-			}],
-			returnType: "PackageConfig",
-			children: code`const result: PackageConfig = {
+        return false; `})]}A.__type=[`HyperlinkSupportUtilities`,`Generates utilities for detecting terminal color support.`,`P"/!?"`];function j(){let n=(l.Ω=[[`Context`,`"w!`]],l());return[e(c,{}),e(f,{name:`ResolveModuleOptions`,doc:"Options for the `resolve` handler function.",get children(){return[e(p,{name:`parentURL`,optional:!0,type:`string`,doc:`The parent URL to use for resolving paths.`}),t(`hbr`,{}),e(p,{name:`conditions`,optional:!0,type:`string[]`,doc:`The conditions to use for resolving paths.`}),t(`hbr`,{})]}}),e(c,{}),e(f,{name:`PackageConfig`,doc:`Parsed package.json configuration for module resolution.`,get children(){return[e(p,{name:`pjsonPath`,type:`string`,doc:`The path to the package.json file.`}),t(`hbr`,{}),e(p,{name:`exists`,type:`boolean`,doc:`Whether the package.json file exists.`}),t(`hbr`,{}),e(p,{name:`main`,optional:!0,type:`string`,doc:`The main entry point of the package.`}),t(`hbr`,{}),e(p,{name:`name`,optional:!0,type:`string`,doc:`The name of the package.`}),t(`hbr`,{}),e(p,{name:`type`,optional:!0,type:`"commonjs" | "module" | "none"`,doc:`The module type of the package.`}),t(`hbr`,{}),e(p,{name:`exports`,optional:!0,type:`Record<string, unknown>`,doc:`The exports map of the package.`}),t(`hbr`,{}),e(p,{name:`imports`,optional:!0,type:`Record<string, unknown>`,doc:`The imports map of the package.`})]}}),e(c,{}),e(m,{const:!0,name:`DEFAULT_CONDITIONS_SET`,initializer:o`new Set(["node", "import"]);`}),e(c,{}),e(m,{const:!0,name:`DEFAULT_EXTENSIONS`,initializer:o`[".mjs", ".cjs", ".js", ".json", ".node"];`}),e(c,{}),e(m,{const:!0,name:`invalidPackageNameRegEx`,initializer:o`/^\\.|\\/|%/;`}),e(c,{}),e(u,{name:`readPackageConfig`,parameters:[{name:`jsonPath`,type:`string`}],returnType:`PackageConfig`,children:o`const result: PackageConfig = {
           pjsonPath: jsonPath,
           exists: false,
           main: undefined,
@@ -891,17 +441,7 @@ function ResolveModuleFunctionDeclaration() {
           result.type = parsed.type;
         }
 
-        return result;`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "getPackageScopeConfig",
-			parameters: [{
-				name: "resolved",
-				type: "URL | string"
-			}],
-			returnType: "PackageConfig",
-			children: code`let packageJSONUrl = new URL("package.json", resolved);
+        return result;`}),e(c,{}),e(u,{name:`getPackageScopeConfig`,parameters:[{name:`resolved`,type:`URL | string`}],returnType:`PackageConfig`,children:o`let packageJSONUrl = new URL("package.json", resolved);
 
         while (true) {
           const packageJSONPath = packageJSONUrl.pathname;
@@ -926,17 +466,7 @@ function ResolveModuleFunctionDeclaration() {
           pjsonPath: fileURLToPath(packageJSONUrl),
           exists: false,
           type: "none"
-        };`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "isConditionalExportsMainSugar",
-			parameters: [{
-				name: "exports",
-				type: "unknown"
-			}],
-			returnType: "boolean",
-			children: code`if (typeof exports === "string" || Array.isArray(exports)) {
+        };`}),e(c,{}),e(u,{name:`isConditionalExportsMainSugar`,parameters:[{name:`exports`,type:`unknown`}],returnType:`boolean`,children:o`if (typeof exports === "string" || Array.isArray(exports)) {
           return true;
         }
         if (typeof exports !== "object" || exports === null) {
@@ -958,47 +488,7 @@ function ResolveModuleFunctionDeclaration() {
           }
         }
 
-        return isConditionalSugar;`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "resolvePackageTarget",
-			parameters: [
-				{
-					name: "packageJsonUrl",
-					type: "URL"
-				},
-				{
-					name: "target",
-					type: "unknown"
-				},
-				{
-					name: "subpath",
-					type: "string"
-				},
-				{
-					name: "packageSubpath",
-					type: "string"
-				},
-				{
-					name: "base",
-					type: "URL"
-				},
-				{
-					name: "pattern",
-					type: "boolean"
-				},
-				{
-					name: "internal",
-					type: "boolean"
-				},
-				{
-					name: "conditions",
-					type: "Set<string>"
-				}
-			],
-			returnType: "URL | null | undefined",
-			children: code`if (typeof target === "string") {
+        return isConditionalSugar;`}),e(c,{}),e(u,{name:`resolvePackageTarget`,parameters:[{name:`packageJsonUrl`,type:`URL`},{name:`target`,type:`unknown`},{name:`subpath`,type:`string`},{name:`packageSubpath`,type:`string`},{name:`base`,type:`URL`},{name:`pattern`,type:`boolean`},{name:`internal`,type:`boolean`},{name:`conditions`,type:`Set<string>`}],returnType:`URL | null | undefined`,children:o`if (typeof target === "string") {
           if (!target.startsWith("./")) {
             if (internal && !target.startsWith("../") && !target.startsWith("/")) {
               let isURL = false;
@@ -1095,35 +585,7 @@ function ResolveModuleFunctionDeclaration() {
           return null;
         }
 
-        return null;`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "packageExportsResolve",
-			parameters: [
-				{
-					name: "packageJsonUrl",
-					type: "URL"
-				},
-				{
-					name: "packageSubpath",
-					type: "string"
-				},
-				{
-					name: "packageConfig",
-					type: "PackageConfig"
-				},
-				{
-					name: "base",
-					type: "URL"
-				},
-				{
-					name: "conditions",
-					type: "Set<string>"
-				}
-			],
-			returnType: "URL | null | undefined",
-			children: code`let exports = packageConfig.exports;
+        return null;`}),e(c,{}),e(u,{name:`packageExportsResolve`,parameters:[{name:`packageJsonUrl`,type:`URL`},{name:`packageSubpath`,type:`string`},{name:`packageConfig`,type:`PackageConfig`},{name:`base`,type:`URL`},{name:`conditions`,type:`Set<string>`}],returnType:`URL | null | undefined`,children:o`let exports = packageConfig.exports;
         if (isConditionalExportsMainSugar(exports)) {
           exports = { ".": exports } as Record<string, unknown>;
         }
@@ -1197,20 +659,7 @@ function ResolveModuleFunctionDeclaration() {
           \`Package subpath '\${packageSubpath}' is not defined by "exports" in \${fileURLToPath(packageJsonUrl)}\`
         );
         (err as any).code = "ERR_PACKAGE_PATH_NOT_EXPORTED";
-        throw err;`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "patternKeyCompare",
-			parameters: [{
-				name: "a",
-				type: "string"
-			}, {
-				name: "b",
-				type: "string"
-			}],
-			returnType: "number",
-			children: code`const aPatternIndex = a.indexOf("*");
+        throw err;`}),e(c,{}),e(u,{name:`patternKeyCompare`,parameters:[{name:`a`,type:`string`},{name:`b`,type:`string`}],returnType:`number`,children:o`const aPatternIndex = a.indexOf("*");
         const bPatternIndex = b.indexOf("*");
         const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
         const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
@@ -1220,20 +669,7 @@ function ResolveModuleFunctionDeclaration() {
         if (bPatternIndex === -1) return -1;
         if (a.length > b.length) return -1;
         if (b.length > a.length) return 1;
-        return 0;`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "legacyMainResolve",
-			parameters: [{
-				name: "packageJsonUrl",
-				type: "URL"
-			}, {
-				name: "packageConfig",
-				type: "PackageConfig"
-			}],
-			returnType: "URL | undefined",
-			children: code`let guess: URL | undefined;
+        return 0;`}),e(c,{}),e(u,{name:`legacyMainResolve`,parameters:[{name:`packageJsonUrl`,type:`URL`},{name:`packageConfig`,type:`PackageConfig`}],returnType:`URL | undefined`,children:o`let guess: URL | undefined;
         const tries: string[] = [];
 
         if (packageConfig.main !== undefined) {
@@ -1261,20 +697,7 @@ function ResolveModuleFunctionDeclaration() {
           guess = undefined;
         }
 
-        return undefined;`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "parsePackageName",
-			parameters: [{
-				name: "specifier",
-				type: "string"
-			}, {
-				name: "base",
-				type: "URL"
-			}],
-			returnType: "{ packageName: string; packageSubpath: string; isScoped: boolean }",
-			children: code`let separatorIndex = specifier.indexOf("/");
+        return undefined;`}),e(c,{}),e(u,{name:`parsePackageName`,parameters:[{name:`specifier`,type:`string`},{name:`base`,type:`URL`}],returnType:`{ packageName: string; packageSubpath: string; isScoped: boolean }`,children:o`let separatorIndex = specifier.indexOf("/");
         let validPackageName = true;
         let isScoped = false;
 
@@ -1307,27 +730,7 @@ function ResolveModuleFunctionDeclaration() {
           ? ""
           : specifier.slice(separatorIndex));
 
-        return { packageName, packageSubpath, isScoped };`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "packageResolve",
-			parameters: [
-				{
-					name: "specifier",
-					type: "string"
-				},
-				{
-					name: "base",
-					type: "URL"
-				},
-				{
-					name: "conditions",
-					type: "Set<string>"
-				}
-			],
-			returnType: "URL",
-			children: code`if (builtinModules.includes(specifier)) {
+        return { packageName, packageSubpath, isScoped };`}),e(c,{}),e(u,{name:`packageResolve`,parameters:[{name:`specifier`,type:`string`},{name:`base`,type:`URL`},{name:`conditions`,type:`Set<string>`}],returnType:`URL`,children:o`if (builtinModules.includes(specifier)) {
           return new URL("node:" + specifier);
         }
 
@@ -1401,20 +804,7 @@ function ResolveModuleFunctionDeclaration() {
         const err = new Error(\`Cannot find package \\\`\${packageName}\\\`\`);
         (err as any).code = "ERR_MODULE_NOT_FOUND";
 
-        throw err;`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "finalizeResolution",
-			parameters: [{
-				name: "resolved",
-				type: "URL"
-			}, {
-				name: "base",
-				type: "URL"
-			}],
-			returnType: "URL",
-			children: code`if (/%2f|%5c/i.test(resolved.pathname)) {
+        throw err;`}),e(c,{}),e(u,{name:`finalizeResolution`,parameters:[{name:`resolved`,type:`URL`},{name:`base`,type:`URL`}],returnType:`URL`,children:o`if (/%2f|%5c/i.test(resolved.pathname)) {
           const err = new Error(
             \`Invalid module \\\`\${resolved.pathname}\\\` must not include encoded "/" or "\\\\" characters imported from \${fileURLToPath(base)}\`
           );
@@ -1452,27 +842,7 @@ function ResolveModuleFunctionDeclaration() {
         realUrl.search = search;
         realUrl.hash = hash;
 
-        return realUrl;`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "moduleResolve",
-			parameters: [
-				{
-					name: "specifier",
-					type: "string"
-				},
-				{
-					name: "base",
-					type: "URL"
-				},
-				{
-					name: "conditions",
-					type: "Set<string>"
-				}
-			],
-			returnType: "URL",
-			children: code`let resolved: URL | undefined;
+        return realUrl;`}),e(c,{}),e(u,{name:`moduleResolve`,parameters:[{name:`specifier`,type:`string`},{name:`base`,type:`URL`},{name:`conditions`,type:`Set<string>`}],returnType:`URL`,children:o`let resolved: URL | undefined;
 
         if (
           specifier[0] === "/" ||
@@ -1561,27 +931,7 @@ function ResolveModuleFunctionDeclaration() {
           return resolved;
         }
 
-        return finalizeResolution(resolved, base);`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(FunctionDeclaration, {
-			name: "tryModuleResolve",
-			parameters: [
-				{
-					name: "id",
-					type: "string"
-				},
-				{
-					name: "url",
-					type: "URL"
-				},
-				{
-					name: "conditions",
-					type: "Set<string>"
-				}
-			],
-			returnType: "URL | undefined",
-			children: code`try {
+        return finalizeResolution(resolved, base);`}),e(c,{}),e(u,{name:`tryModuleResolve`,parameters:[{name:`id`,type:`string`},{name:`url`,type:`URL`},{name:`conditions`,type:`Set<string>`}],returnType:`URL | undefined`,children:o`try {
           return moduleResolve(id, url, conditions);
         } catch (error: any) {
           if (
@@ -1595,46 +945,13 @@ function ResolveModuleFunctionDeclaration() {
           ) {
             throw error;
           }
-        }`
-		}),
-		createComponent(Spacing, {}),
-		createComponent(TSDoc, {
-			heading: "A function to resolve module specifiers to URLs.",
-			get children() {
-				return [
-					createComponent(TSDocParam, {
-						name: "specifier",
-						children: `The module specifier to resolve.`
-					}),
-					createComponent(TSDocParam, {
-						name: "options",
-						children: `The options for resolving the module. Defaults to an empty object.`
-					}),
-					createComponent(TSDocReturns, { children: `The result of the resolve operation.` })
-				];
-			}
-		}),
-		createComponent(FunctionDeclaration, {
-			async: true,
-			"export": true,
-			name: "resolveModule",
-			parameters: [{
-				name: "specifier",
-				type: "string"
-			}, {
-				name: "options",
-				type: "ResolveModuleOptions",
-				default: "{} as ResolveModuleOptions"
-			}],
-			returnType: "Promise<string>",
-			get children() {
-				return code`const parentURL = options.parentURL ? new URL(options.parentURL) : undefined;
+        }`}),e(c,{}),e(g,{heading:`A function to resolve module specifiers to URLs.`,get children(){return[e(y,{name:`specifier`,children:`The module specifier to resolve.`}),e(y,{name:`options`,children:`The options for resolving the module. Defaults to an empty object.`}),e(x,{children:`The result of the resolve operation.`})]}}),e(u,{async:!0,export:!0,name:`resolveModule`,parameters:[{name:`specifier`,type:`string`},{name:`options`,type:`ResolveModuleOptions`,default:`{} as ResolveModuleOptions`}],returnType:`Promise<string>`,get children(){return o`const parentURL = options.parentURL ? new URL(options.parentURL) : undefined;
         const conditionsSet = options.conditions?.length
           ? new Set(options.conditions)
           : DEFAULT_CONDITIONS_SET;
 
-        // Handle protocol-prefixed specifiers (node:, data:, http:, https:, ${context.config.framework}:)
-        if (/^(?:node|data|https?|${context.config.framework}):/.test(specifier)) {
+        // Handle protocol-prefixed specifiers (node:, data:, http:, https:, ${n.config.framework}:)
+        if (/^(?:node|data|https?|${n.config.framework}):/.test(specifier)) {
           return specifier;
         }
 
@@ -1662,12 +979,12 @@ function ResolveModuleFunctionDeclaration() {
 
         const roots = [parentURL ?? pathToFileURL(join(process.cwd(), "_"))];
 
-        const projectRootURL = pathToFileURL("${context.config.root}");
+        const projectRootURL = pathToFileURL("${n.config.root}");
         if (!roots.some(root => root.href === projectRootURL.href)) {
           roots.push(projectRootURL);
         }
 
-        const workspaceRootURL = pathToFileURL("${context.workspaceConfig.workspaceRoot}");
+        const workspaceRootURL = pathToFileURL("${n.config.cwd}");
         if (!roots.some(root => root.href === workspaceRootURL.href)) {
           roots.push(workspaceRootURL);
         }
@@ -1725,117 +1042,5 @@ function ResolveModuleFunctionDeclaration() {
         }
 
         return pathToFileURL(fileURLToPath(resolved)).href;
-        `;
-			}
-		})
-	];
-}
-ResolveModuleFunctionDeclaration.__type = [
-	"ResolveModuleFunctionDeclaration",
-	"Generates the `resolveModule` function declaration, which is a utility for resolving file paths across different platforms.",
-	"P\"/!?\""
-];
-/**
-* A built-in utilities module for Shell Shock.
-*/
-function UtilsBuiltin(props) {
-	const [{ children }, rest] = splitProps(props, ["children"]);
-	return createComponent(BuiltinFile, mergeProps({
-		id: "utils",
-		description: "A collection of helper utilities that ease command-line application development."
-	}, rest, {
-		get imports() {
-			return defu$1(rest.imports ?? {}, {
-				"node:os": "os",
-				"node:process": "process",
-				"node:path": [
-					"join",
-					"sep",
-					"isAbsolute"
-				],
-				"node:fs": [
-					{
-						name: "constants",
-						alias: "fsConstants"
-					},
-					"openSync",
-					"closeSync",
-					"read",
-					"readFileSync",
-					"statSync",
-					"realpathSync"
-				],
-				"node:tty": ["WriteStream"],
-				"node:url": ["fileURLToPath", "pathToFileURL"],
-				"node:module": ["builtinModules"]
-			});
-		},
-		get builtinImports() {
-			return defu$1(rest.builtinImports ?? {}, {
-				env: [
-					"env",
-					"isCI",
-					"isTest",
-					"isWindows",
-					"isLinux",
-					"isMacOS"
-				],
-				exec: ["execSync"],
-				state: ["hasFlag"]
-			});
-		},
-		get children() {
-			return [
-				createComponent(TSDoc, {
-					heading: "A utility function to pause execution for a specified duration, which can be used in prompt interactions to create delays or timeouts. The function returns a promise that resolves after the specified duration in milliseconds, allowing it to be used with async/await syntax for easier handling of asynchronous prompt logic.",
-					get children() {
-						return [createComponent(TSDocParam, {
-							name: "durationMs",
-							children: `The duration to sleep in milliseconds.`
-						}), createComponent(TSDocReturns, { children: `A promise that resolves after the specified duration, allowing for asynchronous delays in prompt interactions.` })];
-					}
-				}),
-				createComponent(FunctionDeclaration, {
-					"export": true,
-					name: "sleep",
-					parameters: [{
-						name: "durationMs",
-						type: "number"
-					}],
-					returnType: "Promise<void>",
-					children: code`return new Promise((resolve) => setTimeout(resolve, durationMs)); `
-				}),
-				createComponent(Spacing, {}),
-				createComponent(TerminalSizeDeclaration, {}),
-				createComponent(Spacing, {}),
-				createComponent(EnvSupportUtilities, {}),
-				createComponent(Spacing, {}),
-				createComponent(HyperlinkSupportUtilities, {}),
-				createComponent(Spacing, {}),
-				createComponent(ColorSupportUtilities, {}),
-				createComponent(Spacing, {}),
-				createComponent(ResolveModuleFunctionDeclaration, {}),
-				createComponent(Spacing, {}),
-				createComponent(FindSuggestionsDeclaration, {}),
-				createComponent(Spacing, {}),
-				createComponent(Show, {
-					get when() {
-						return Boolean(children);
-					},
-					children
-				})
-			];
-		}
-	}));
-}
-UtilsBuiltin.__type = [
-	() => __ΩUtilsBuiltinProps,
-	"props",
-	"UtilsBuiltin",
-	"A built-in utilities module for Shell Shock.",
-	"Pn!2\"\"/#?$"
-];
-
-//#endregion
-export { ColorSupportUtilities, EnvSupportUtilities, FindSuggestionsDeclaration, HyperlinkSupportUtilities, ResolveModuleFunctionDeclaration, TerminalSizeDeclaration, UtilsBuiltin, __ΩUtilsBuiltinProps };
+        `}})]}j.__type=[`ResolveModuleFunctionDeclaration`,"Generates the `resolveModule` function declaration, which is a utility for resolving file paths across different platforms.",`P"/!?"`];function M(t){let[{children:n},l]=s(t,[`children`]);return e(h,r({id:`utils`,description:`A collection of helper utilities that ease command-line application development.`},l,{get imports(){return i(l.imports??{},{"node:os":`os`,"node:process":`process`,"node:path":[`join`,`sep`,`isAbsolute`],"node:fs":[{name:`constants`,alias:`fsConstants`},`openSync`,`closeSync`,`read`,`readFileSync`,`statSync`,`realpathSync`],"node:tty":[`WriteStream`],"node:url":[`fileURLToPath`,`pathToFileURL`],"node:module":[`builtinModules`]})},get builtinImports(){return i(l.builtinImports??{},{env:[`env`,`isCI`,`isTest`,`isWindows`,`isLinux`,`isMacOS`],exec:[`execSync`],state:[`hasFlag`]})},get children(){return[e(g,{heading:`A utility function to pause execution for a specified duration, which can be used in prompt interactions to create delays or timeouts. The function returns a promise that resolves after the specified duration in milliseconds, allowing it to be used with async/await syntax for easier handling of asynchronous prompt logic.`,get children(){return[e(y,{name:`durationMs`,children:`The duration to sleep in milliseconds.`}),e(x,{children:`A promise that resolves after the specified duration, allowing for asynchronous delays in prompt interactions.`})]}}),e(u,{export:!0,name:`sleep`,parameters:[{name:`durationMs`,type:`number`}],returnType:`Promise<void>`,children:o`return new Promise((resolve) => setTimeout(resolve, durationMs)); `}),e(c,{}),e(D,{}),e(c,{}),e(O,{}),e(c,{}),e(A,{}),e(c,{}),e(k,{}),e(c,{}),e(j,{}),e(c,{}),e(E,{}),e(c,{}),e(a,{get when(){return!!n},children:n})]}}))}M.__type=[()=>T,`props`,`UtilsBuiltin`,`A built-in utilities module for Shell Shock.`,`Pn!2""/#?$`];export{k as ColorSupportUtilities,O as EnvSupportUtilities,E as FindSuggestionsDeclaration,A as HyperlinkSupportUtilities,j as ResolveModuleFunctionDeclaration,D as TerminalSizeDeclaration,M as UtilsBuiltin,T as __ΩUtilsBuiltinProps};
 //# sourceMappingURL=utils-builtin.mjs.map