@shell-shock/plugin-console 0.0.5 → 0.1.1

package/dist/components/console-builtin.mjs

@@ -3,6 +3,7 @@ import { For, Show, code } from "@alloy-js/core";
 import { ElseClause, ElseIfClause, FunctionDeclaration, IfStatement, InterfaceDeclaration, InterfaceMember, TypeDeclaration, VarDeclaration } from "@alloy-js/typescript";
 import { ReflectionKind } from "@powerlines/deepkit/vendor/type";
 import { Spacing } from "@powerlines/plugin-alloy/core/components/spacing";
+import { ClassDeclaration, ClassField, ClassMethod, ClassPropertyGet, ClassPropertySet } from "@powerlines/plugin-alloy/typescript";
 import { BuiltinFile } from "@powerlines/plugin-alloy/typescript/components/builtin-file";
 import { TSDoc, TSDocDefaultValue, TSDocExample, TSDocParam, TSDocRemarks, TSDocReturns } from "@powerlines/plugin-alloy/typescript/components/tsdoc";
 import { IsNotDebug, IsNotVerbose } from "@shell-shock/core/components/helpers";
@@ -1208,6 +1209,144 @@ function ColorsDeclaration() {
 						}
 					})}
                       }
+                    },
+                    spinner: {
+                      icon: {
+                        active: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.icon.active;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.icon.active;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.icon.active;
+						}
+					})},
+                        warning: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.icon.warning;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.icon.warning;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.icon.warning;
+						}
+					})},
+                        error: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.icon.error;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.icon.error;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.icon.error;
+						}
+					})},
+                        success: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.icon.success;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.icon.success;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.icon.success;
+						}
+					})},
+                        info: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.icon.info;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.icon.info;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.icon.info;
+						}
+					})},
+                        help: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.icon.help;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.icon.help;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.icon.help;
+						}
+					})}
+                      },
+                      message: {
+                        active: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.message.active;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.message.active;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.message.active;
+						}
+					})},
+                        warning: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.message.warning;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.message.warning;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.message.warning;
+						}
+					})},
+                        error: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.message.error;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.message.error;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.message.error;
+						}
+					})},
+                        success: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.message.success;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.message.success;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.message.success;
+						}
+					})},
+                        info: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.message.info;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.message.info;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.message.info;
+						}
+					})},
+                        help: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.spinner.message.help;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.spinner.message.help;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.spinner.message.help;
+						}
+					})}
+                      }
                     }
                   },
                   border: {
@@ -2095,6 +2234,558 @@ function LinkFunctionDeclaration() {
 		}
 	})];
 }
+/**
+* A component to generate the `spinner` function in the `shell-shock:console` builtin module.
+*/
+function SpinnerFunctionDeclaration() {
+	const theme = useTheme();
+	return [
+		createComponent(TypeDeclaration, {
+			name: "WriteStream",
+			children: `NodeJS.WriteStream;`
+		}),
+		createComponent(Spacing, {}),
+		createComponent(VarDeclaration, {
+			"const": true,
+			name: "activeHooksPerStream",
+			initializer: "new Set();"
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "SpinnerOptions",
+			doc: "Options for configuring the spinner.",
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "message",
+						optional: true,
+						type: "string",
+						doc: "The message text to display next to the spinner. Defaults to an empty string."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "stream",
+						optional: true,
+						type: "WriteStream",
+						doc: "The output stream to write the spinner to. Defaults to process.stderr."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "spinner",
+						optional: true,
+						type: "ThemeSpinnerResolvedConfig | SpinnerPreset",
+						doc: "The spinner animation to use. Should be an object with a 'frames' property (an array of strings representing each frame of the animation) and an 'interval' property (the time in milliseconds between each frame). If not specified, a default spinner animation will be used."
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(ClassDeclaration, {
+			name: "Spinner",
+			get children() {
+				return [
+					createComponent(ClassField, {
+						name: "frames",
+						isPrivateMember: true,
+						type: "string[]"
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "interval",
+						isPrivateMember: true,
+						type: "number"
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "currentFrame",
+						isPrivateMember: true,
+						type: "number",
+						children: code`-1`
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "timer",
+						isPrivateMember: true,
+						optional: true,
+						type: "NodeJS.Timeout"
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "message",
+						isPrivateMember: true,
+						type: "string",
+						children: code`""`
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "stream",
+						isPrivateMember: true,
+						type: "WriteStream",
+						children: code`process.stderr`
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "lines",
+						isPrivateMember: true,
+						type: "number",
+						children: code`0`
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "exitHandlerBound",
+						isPrivateMember: true,
+						type: "(signal: any) => void",
+						children: code`() => {}`
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "lastSpinnerFrameTime",
+						isPrivateMember: true,
+						type: "number",
+						children: code`0`
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "isSpinning",
+						isPrivateMember: true,
+						type: "boolean",
+						children: code`false`
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "hookedStreams",
+						isPrivateMember: true,
+						type: "Map<WriteStream, { write?: WriteStream[\"write\"]; originalWrite: WriteStream[\"write\"]; hookedWrite: WriteStream[\"write\"] }>",
+						children: code`new Map()`
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "isInternalWrite",
+						isPrivateMember: true,
+						type: "boolean",
+						children: code`false`
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(ClassField, {
+						name: "isDeferringRender",
+						isPrivateMember: true,
+						type: "boolean",
+						children: code`false`
+					}),
+					createComponent(Spacing, {}),
+					memo(() => code`constructor(options: SpinnerOptions = {}) {
+          const spinner = (typeof options.spinner === "string" ? resolveSpinner(options.spinner as SpinnerPreset) : options.spinner) ?? ${JSON.stringify(theme.spinner)};
+          this.#frames = spinner.frames;
+          this.#interval = spinner.interval;
+
+          if (options.message) {
+            this.#message = options.message;
+          }
+          if (options.stream) {
+            this.#stream = options.stream;
+          }
+
+          this.#exitHandlerBound = this.#exitHandler.bind(this);
+        }
+
+        #internalWrite(action: () => unknown) {
+          this.#isInternalWrite = true;
+          try {
+            return action();
+          } finally {
+            this.#isInternalWrite = false;
+          }
+        }
+
+        #stringifyChunk(chunk: string | Uint8Array<ArrayBufferLike> | ArrayBufferLike) {
+          if (chunk === undefined || chunk === null) {
+            return "";
+          }
+
+          if (typeof chunk === "string") {
+            return chunk;
+          }
+
+          if (Buffer.isBuffer(chunk) || ArrayBuffer.isView(chunk)) {
+            return Buffer.from(chunk).toString("utf8");
+          }
+
+          return String(chunk);
+        }
+
+        #withSynchronizedOutput(action: () => unknown) {
+          if (!isInteractive) {
+            return action();
+          }
+
+          try {
+            this.#write("\\u001B[?2026h");
+            return action();
+          } finally {
+            this.#write("\\u001B[?2026l");
+          }
+        }
+
+        #hookStream(stream: WriteStream) {
+          if (!stream || this.#hookedStreams.has(stream) || typeof stream.write !== "function") {
+            return;
+          }
+
+          if (activeHooksPerStream.has(stream)) {
+            return;
+          }
+
+          const originalWrite = stream.write;
+          const hookedWrite = ((...writeArguments: Parameters<WriteStream["write"]>) => this.#hookedWrite(stream, originalWrite, writeArguments)) as WriteStream["write"];
+
+          this.#hookedStreams.set(stream, {originalWrite, hookedWrite});
+          activeHooksPerStream.add(stream);
+          stream.write = hookedWrite;
+        }
+
+        #installHook() {
+          if (!isInteractive || this.#hookedStreams.size > 0) {
+            return;
+          }
+
+          const streamsToHook = new Set([this.#stream]);
+          if (isInteractive && (this.#stream === process.stdout || this.#stream === process.stderr)) {
+            streamsToHook.add(process.stdout);
+            streamsToHook.add(process.stderr);
+          }
+
+          for (const stream of streamsToHook) {
+            this.#hookStream(stream);
+          }
+        }
+
+        #uninstallHook() {
+          for (const [stream, hookInfo] of this.#hookedStreams) {
+            if (stream.write === hookInfo.hookedWrite) {
+              stream.write = hookInfo.originalWrite;
+            }
+
+            activeHooksPerStream.delete(stream);
+          }
+
+          this.#hookedStreams.clear();
+        }
+
+        #hookedWrite(stream: WriteStream, originalWrite: typeof stream.write, writeArguments: Parameters<typeof stream.write>) {
+          const [chunk, callback] = writeArguments;
+
+          if (this.#isInternalWrite || !this.isSpinning) {
+            return originalWrite.call(stream, chunk);
+          }
+
+          if (this.#lines > 0) {
+            this.clear();
+          }
+
+          const chunkString = this.#stringifyChunk(chunk);
+          const chunkTerminatesLine = chunkString.at(-1) === "\\n";
+          const writeResult = originalWrite.call(stream, chunk);
+
+          if (chunkTerminatesLine) {
+            this.#isDeferringRender = false;
+          } else if (chunkString !== "") {
+            this.#isDeferringRender = true;
+          }
+
+          if (this.isSpinning && !this.#isDeferringRender) {
+            this.#render();
+          }
+
+          return writeResult;
+        }
+
+        #stopWithIcon(icon: string, message: string) {
+          return this.stop(\` \${icon}  \${message ?? this.#message}\`);
+        }
+
+        #render() {
+          if (this.#isDeferringRender) {
+            return;
+          }
+
+          if (this.#currentFrame === -1 || Date.now() - this.#lastSpinnerFrameTime >= this.#interval) {
+            this.#currentFrame = ++this.#currentFrame % this.#frames.length;
+            this.#lastSpinnerFrameTime = Date.now();
+          }
+
+          let display = \`\${colors.text.spinner.icon.active(this.#frames[this.#currentFrame])} \${colors.text.spinner.message.active(this.#message)}\`;
+          if (!isInteractive) {
+            display += "\\n";
+          }
+
+          if (isInteractive) {
+            this.#withSynchronizedOutput(() => {
+              this.clear();
+              this.#write(display);
+            });
+          } else {
+            this.#write(display);
+          }
+
+          if (isInteractive) {
+            this.#lines = this.#lineCount(display);
+          }
+        }
+
+        #write(message: string) {
+          this.#internalWrite(() => {
+            this.#stream.write(message);
+          });
+        }
+
+        #lineCount(message: string) {
+          const width = this.#stream.columns ?? 80;
+          const lines = stripVTControlCharacters(message).split("\\n");
+
+          let lineCount = 0;
+          for (const line of lines) {
+            lineCount += Math.max(1, Math.ceil(line.length / width));
+          }
+
+          return lineCount;
+        }
+
+        #hideCursor() {
+          if (isInteractive) {
+            this.#write("\\u001B[?25l");
+          }
+        }
+
+        #showCursor() {
+          if (isInteractive) {
+            this.#write("\\u001B[?25h");
+          }
+        }
+
+        #subscribeToProcessEvents() {
+          process.once("SIGINT", this.#exitHandlerBound);
+          process.once("SIGTERM", this.#exitHandlerBound);
+        }
+
+        #unsubscribeFromProcessEvents() {
+          process.off("SIGINT", this.#exitHandlerBound);
+          process.off("SIGTERM", this.#exitHandlerBound);
+        }
+
+        #exitHandler(signal: any) {
+          if (this.isSpinning) {
+            this.stop();
+          }
+
+          process.exit(signal === "SIGINT" ? 130 : (signal === "SIGTERM" ? 143 : 1));
+        } `),
+					createComponent(ClassPropertyGet, {
+						"public": true,
+						name: "isSpinning",
+						type: "boolean",
+						doc: "Whether the spinner is currently active and spinning.",
+						children: code`return this.#isSpinning;`
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassPropertySet, {
+						"public": true,
+						name: "message",
+						type: "string",
+						doc: "Set the message displayed by the spinner.",
+						children: code`this.#message = value;`
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassPropertyGet, {
+						"public": true,
+						name: "message",
+						type: "string",
+						doc: "Get the message displayed by the spinner.",
+						children: code`return this.#message;`
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						name: "start",
+						doc: "Start the spinner animation.",
+						parameters: [{
+							name: "message",
+							type: "string"
+						}],
+						get children() {
+							return [
+								createComponent(IfStatement, {
+									condition: code`message !== undefined`,
+									children: code`this.#message = message;`
+								}),
+								createComponent(IfStatement, {
+									condition: code`this.isSpinning`,
+									children: code`return this;`
+								}),
+								code`this.#isSpinning = true;
+          this.#hideCursor();
+          this.#installHook();
+          this.#render();
+          this.#subscribeToProcessEvents();
+
+          if (isInteractive) {
+            this.#timer = setInterval(() => {
+              this.#render();
+            }, this.#interval);
+          }
+
+          return this;
+          `
+							];
+						}
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						name: "stop",
+						doc: "Stop the spinner animation.",
+						parameters: [{
+							name: "finalMessage",
+							optional: true,
+							type: "string"
+						}],
+						children: code`if (!this.isSpinning) {
+            return this;
+          }
+
+          const shouldWriteNewline = this.#isDeferringRender;
+          this.#isSpinning = false;
+          if (this.#timer) {
+            clearInterval(this.#timer);
+            this.#timer = undefined;
+          }
+
+          this.#isDeferringRender = false;
+          this.#uninstallHook();
+          this.#showCursor();
+          this.clear();
+          this.#unsubscribeFromProcessEvents();
+
+          if (finalMessage) {
+            const prefix = shouldWriteNewline ? "\\n" : "";
+            this.#stream.write(\`\${prefix}\${finalMessage}\\n\`);
+          }
+
+          return this;
+
+          `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						name: "clear",
+						doc: "Clear the spinner animation.",
+						children: code`if (!isInteractive) {
+            return this;
+          }
+
+          if (this.#lines === 0) {
+            return this;
+          }
+
+          this.#internalWrite(() => {
+            this.#stream.cursorTo(0);
+
+            for (let index = 0; index < this.#lines; index++) {
+              if (index > 0) {
+                this.#stream.moveCursor(0, -1);
+              }
+
+              this.#stream.clearLine(1);
+            }
+          });
+
+          this.#lines = 0;
+          return this; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						name: "success",
+						doc: "Mark the spinner as successful.",
+						parameters: [{
+							name: "message",
+							type: "string"
+						}],
+						get children() {
+							return code`return this.#stopWithIcon(colors.text.spinner.icon.success("${theme.icons.spinner.success}"), colors.text.spinner.message.success(message)); `;
+						}
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						name: "error",
+						doc: "Mark the spinner as failed.",
+						parameters: [{
+							name: "message",
+							type: "string"
+						}],
+						get children() {
+							return code`return this.#stopWithIcon(colors.text.spinner.icon.error("${theme.icons.spinner.error}"), colors.text.spinner.message.error(message)); `;
+						}
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						name: "warning",
+						doc: "Mark the spinner as warning.",
+						parameters: [{
+							name: "message",
+							type: "string"
+						}],
+						get children() {
+							return code`return this.#stopWithIcon(colors.text.spinner.icon.warning("${theme.icons.spinner.warning}"), colors.text.spinner.message.warning(message)); `;
+						}
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						name: "info",
+						doc: "Mark the spinner as informational.",
+						parameters: [{
+							name: "message",
+							type: "string"
+						}],
+						get children() {
+							return code`return this.#stopWithIcon(colors.text.spinner.icon.info("${theme.icons.spinner.info}"), colors.text.spinner.message.info(message)); `;
+						}
+					}),
+					createComponent(Spacing, {}),
+					createComponent(ClassMethod, {
+						name: "help",
+						doc: "Mark the spinner as help.",
+						parameters: [{
+							name: "message",
+							type: "string"
+						}],
+						get children() {
+							return code`return this.#stopWithIcon(colors.text.spinner.icon.help("${theme.icons.spinner.help}"), colors.text.spinner.message.help(message)); `;
+						}
+					}),
+					createComponent(Spacing, {})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "Render a spinner in the console.",
+			get children() {
+				return [createComponent(TSDocParam, {
+					name: "options",
+					children: `Options for configuring the spinner, including the message to display, the output stream to write to, and the spinner animation to use.`
+				}), createComponent(TSDocReturns, { children: `An instance of the Spinner class, which can be used to control the spinner animation (e.g., start, stop, mark as success/error, etc.).` })];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			name: "createSpinner",
+			parameters: [{
+				name: "options",
+				type: "SpinnerOptions",
+				optional: true
+			}],
+			children: code`return new Spinner(options);`
+		})
+	];
+}
 function extractBorderOptionsObject(direction, theme) {
 	return `borderOptions.${direction} === "primary" ? colors.border.app.table.primary("${theme.borderStyles.app.table.primary[direction]}") : borderOptions.${direction} === "secondary" ? colors.border.app.table.secondary("${theme.borderStyles.app.table.secondary[direction]}") : borderOptions.${direction} === "tertiary" ? colors.border.app.table.tertiary("${theme.borderStyles.app.table.tertiary[direction]}") : !borderOptions.${direction} || borderOptions.${direction} === "none" ? "" : borderOptions.${direction}`;
 }
@@ -2796,16 +3487,28 @@ function ConsoleBuiltin(props) {
 		id: "console",
 		description: "A collection of helper utilities to assist in generating content meant for display in the console.",
 		get imports() {
-			return defu(imports, { "@shell-shock/plugin-theme/types/theme": [{
-				name: "ThemeColorsResolvedConfig",
-				type: true
-			}] });
+			return defu(imports, {
+				"@shell-shock/plugin-theme/types/theme": [{
+					name: "ThemeColorsResolvedConfig",
+					type: true
+				}, {
+					name: "ThemeSpinnerResolvedConfig",
+					type: true
+				}],
+				"@shell-shock/plugin-theme/helpers/spinners": [{
+					name: "SpinnerPreset",
+					type: true
+				}, { name: "resolveSpinner" }],
+				"node:buffer": ["WithImplicitCoercion"],
+				"node:util": ["stripVTControlCharacters"]
+			});
 		},
 		get builtinImports() {
 			return defu(builtinImports, {
 				utils: [
 					"hasFlag",
 					"isMinimal",
+					"isInteractive",
 					"isColorSupported",
 					"colorSupportLevels",
 					"isHyperlinkSupported"
@@ -2833,6 +3536,8 @@ function ConsoleBuiltin(props) {
 				createComponent(Spacing, {}),
 				createComponent(DividerFunctionDeclaration, {}),
 				createComponent(Spacing, {}),
+				createComponent(SpinnerFunctionDeclaration, {}),
+				createComponent(Spacing, {}),
 				createComponent(MessageFunctionDeclaration, {
 					type: "help",
 					variant: "help",
@@ -2931,8 +3636,8 @@ function ConsoleBuiltin(props) {
 								get children() {
 									return [createComponent(IfStatement, {
 										condition: code`(err as Error)?.stack`,
-										children: code`message += " \\n\\n" + (err as Error).stack;`
-									}), createComponent(ElseClause, { children: code`message += " \\n\\n" + (new Error(" ")).stack.split("\\n").slice(2).map(line => line.trim()).join("\\n");` })];
+										children: code`message += " \\n\\n" + ((err as Error).stack || "");`
+									}), createComponent(ElseClause, { children: code`message += " \\n\\n" + ((new Error(" ")).stack || "").split("\\n").slice(2).map(line => line.trim()).join("\\n");` })];
 								}
 							})
 						];
@@ -2949,5 +3654,5 @@ function ConsoleBuiltin(props) {
 }
 
 //#endregion
-export { AnsiHelpersDeclarations, ColorsDeclaration, ConsoleBuiltin, DividerFunctionDeclaration, LinkFunctionDeclaration, MessageFunctionDeclaration, StripAnsiFunctionDeclaration, TableFunctionDeclaration, WrapAnsiFunction, WriteLineFunctionDeclaration };
+export { AnsiHelpersDeclarations, ColorsDeclaration, ConsoleBuiltin, DividerFunctionDeclaration, LinkFunctionDeclaration, MessageFunctionDeclaration, SpinnerFunctionDeclaration, StripAnsiFunctionDeclaration, TableFunctionDeclaration, WrapAnsiFunction, WriteLineFunctionDeclaration };
 //# sourceMappingURL=console-builtin.mjs.map