@shell-shock/preset-script 0.6.3 → 0.6.5

package/dist/components/console-builtin.mjs

@@ -2,7 +2,8 @@ import { useColors, useTheme } from "../contexts/theme.mjs";
 import { IsNotDebug, IsNotVerbose } from "./helpers.mjs";
 import { createComponent, createIntrinsic, memo, mergeProps } from "@alloy-js/core/jsx-runtime";
 import { For, Show, code } from "@alloy-js/core";
-import { ElseClause, FunctionDeclaration, IfStatement, InterfaceDeclaration, InterfaceMember, TypeDeclaration, VarDeclaration } from "@alloy-js/typescript";
+import { ElseClause, ElseIfClause, FunctionDeclaration, IfStatement, InterfaceDeclaration, InterfaceMember, TypeDeclaration, VarDeclaration } from "@alloy-js/typescript";
+import { Spacing } from "@powerlines/plugin-alloy/core/components/spacing";
 import { TSDoc, TSDocDefaultValue, TSDocExample, TSDocParam, TSDocRemarks, TSDocReturns } from "@powerlines/plugin-alloy/typescript/components/tsdoc";
 import { defu as defu$1 } from "defu";
 import { ReflectionKind } from "@powerlines/deepkit/vendor/type";
@@ -10,6 +11,126 @@ import { BuiltinFile } from "@powerlines/plugin-alloy/typescript/components/buil
 import { getIndefiniteArticle } from "@stryke/string-format/vowels";
 
 //#region src/components/console-builtin.tsx
+function AnsiHelpersDeclarations() {
+	return [
+		createComponent(VarDeclaration, {
+			"const": true,
+			"export": true,
+			name: "beep",
+			doc: "The ASCII Bell character, which can be used to trigger a beep sound in the console.",
+			children: code` "\\u0007"; `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(VarDeclaration, {
+			"const": true,
+			"export": true,
+			name: "cursor",
+			doc: "An object containing ANSI escape codes for controlling the console cursor.",
+			children: code` {
+          to(x, y) {
+            if (!y) {
+              return \`\\x1B[\${x + 1}G\`;
+            }
+
+            return \`\\x1B[\${y + 1};\${x + 1}H\`;
+          },
+          move(x, y) {
+            let ret = '';
+
+            if (x < 0) {
+              ret += \`\\x1B[\${-x}D\`;
+            } else if (x > 0) {
+              ret += \`\\x1B[\${x}C\`;
+            }
+
+            if (y < 0) {
+              ret += \`\\x1B[\${-y}A\`;
+            } else if (y > 0) {
+              ret += \`\\x1B[\${y}B\`;
+            }
+
+            return ret;
+          },
+          up: (count = 1) => \`\\x1B[\${count}A\`,
+          down: (count = 1) => \`\\x1B[\${count}B\`,
+          forward: (count = 1) => \`\\x1B[\${count}C\`,
+          backward: (count = 1) => \`\\x1B[\${count}D\`,
+          nextLine: (count = 1) => "\\x1B[E".repeat(count),
+          prevLine: (count = 1) => "\\x1B[F".repeat(count),
+          left: "\\x1B[G",
+          hide: "\\x1B[?25l",
+          show: "\\x1B[?25h",
+          save: "\\x1B7",
+          restore: "\\x1B8"
+        } `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(VarDeclaration, {
+			"const": true,
+			"export": true,
+			name: "erase",
+			doc: "An object containing ANSI escape codes for erasing parts of the console.",
+			children: code` {
+          screen: "\\x1B[2J",
+          up: (count = 1) => "\\x1B[1J".repeat(count),
+          down: (count = 1) => "\\x1B[J".repeat(count),
+          line: "\\x1B[2K",
+          lineEnd: "\\x1B[K",
+          lineStart: "\\x1B[1K",
+          lines(count) {
+            let lineClear = "";
+            for (let i = 0; i < count; i++) {
+              lineClear += this.line + (i < count - 1 ? cursor.up() : "");
+            }
+
+            if (count) {
+              lineClear += cursor.left;
+            }
+
+            return lineClear;
+          }
+        } `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(VarDeclaration, {
+			"const": true,
+			"export": true,
+			name: "scroll",
+			doc: "An object containing ANSI escape codes for scrolling the console.",
+			children: code` {
+          up: (count = 1) => "\\x1B[S".repeat(count),
+          down: (count = 1) => "\\x1B[T".repeat(count)
+        } `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			name: "clear",
+			doc: "A helper function to clear the console based on a count of lines",
+			parameters: [{
+				name: "current",
+				type: "string",
+				doc: "The current console output to be cleared"
+			}, {
+				name: "consoleWidth",
+				type: "number",
+				doc: "The number of characters per line in the console"
+			}],
+			children: code`if (!consoleWidth) {
+          return erase.line + cursor.to(0);
+        }
+
+        let rows = 0;
+        const lines = current.split(/\\r?\\n/);
+        for (let line of lines) {
+          rows += 1 + Math.floor(Math.max([...stripAnsi(line)].length - 1, 0) / consoleWidth);
+        }
+
+        return erase.lines(rows); `
+		}),
+		createComponent(Spacing, {})
+	];
+}
 /**
 * A component to generate a console message function in a Shell Shock project.
 */
@@ -52,8 +173,7 @@ function ColorsDeclaration() {
 				});
 			}
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createIntrinsic("hbr", {}),
 		code`
       /**
@@ -63,16 +183,14 @@ function ColorsDeclaration() {
       * This type allows for nested theme color definitions, enabling complex theming structures for console applications.
       */
      export type ThemeColors<T> = T extends object ? { [K in keyof T]: ThemeColors<T[K]>; } : ((text: string) => string); `,
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(TypeDeclaration, {
 			"export": true,
 			name: "Colors",
 			doc: "An object containing functions for coloring console applications. Each function corresponds to a terminal color. See {@link AnsiColor} for available colors.",
 			children: code`Record<AnsiColor, (text: string) => string> & ThemeColors<ThemeColorsResolvedConfig>`
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(TSDoc, { heading: "An object containing functions for coloring console applications. Each function corresponds to a terminal color. See {@link Colors} for available colors." }),
 		createComponent(VarDeclaration, {
 			"const": true,
@@ -783,6 +901,302 @@ function ColorsDeclaration() {
 							return colors.ansi16m.theme.text.usage.description;
 						}
 					})}
+                    },
+                    prompt: {
+                      icon: {
+                        active: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.icon.active;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.icon.active;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.icon.active;
+						}
+					})},
+                        warning: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.icon.warning;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.icon.warning;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.icon.warning;
+						}
+					})},
+                        error: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.icon.error;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.icon.error;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.icon.error;
+						}
+					})},
+                        submitted: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.icon.submitted;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.icon.submitted;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.icon.submitted;
+						}
+					})},
+                        cancelled: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.icon.cancelled;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.icon.cancelled;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.icon.cancelled;
+						}
+					})},
+                        disabled: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.icon.disabled;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.icon.disabled;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.icon.disabled;
+						}
+					})}
+                      },
+                      message: {
+                        active: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.message.active;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.message.active;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.message.active;
+						}
+					})},
+                        warning: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.message.warning;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.message.warning;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.message.warning;
+						}
+					})},
+                        error: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.message.error;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.message.error;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.message.error;
+						}
+					})},
+                        submitted: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.message.submitted;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.message.submitted;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.message.submitted;
+						}
+					})},
+                        cancelled: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.message.cancelled;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.message.cancelled;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.message.cancelled;
+						}
+					})},
+                        disabled: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.message.disabled;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.message.disabled;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.message.disabled;
+						}
+					})}
+                      },
+                      input: {
+                        active: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.input.active;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.input.active;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.input.active;
+						}
+					})},
+                        inactive: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.input.inactive;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.input.inactive;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.input.inactive;
+						}
+					})},
+                        warning: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.input.warning;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.input.warning;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.input.warning;
+						}
+					})},
+                        error: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.input.error;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.input.error;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.input.error;
+						}
+					})},
+                        submitted: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.input.submitted;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.input.submitted;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.input.submitted;
+						}
+					})},
+                        cancelled: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.input.cancelled;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.input.cancelled;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.input.cancelled;
+						}
+					})},
+                        disabled: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.input.disabled;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.input.disabled;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.input.disabled;
+						}
+					})}
+                      },
+                      description: {
+                        active: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.description.active;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.description.active;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.description.active;
+						}
+					})},
+                        inactive: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.description.inactive;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.description.inactive;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.description.inactive;
+						}
+					})},
+                        warning: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.description.warning;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.description.warning;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.description.warning;
+						}
+					})},
+                        error: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.description.error;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.description.error;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.description.error;
+						}
+					})},
+                        submitted: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.description.submitted;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.description.submitted;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.description.submitted;
+						}
+					})},
+                        cancelled: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.description.cancelled;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.description.cancelled;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.description.cancelled;
+						}
+					})},
+                        disabled: ${createComponent(ColorFunction, {
+						get ansi16() {
+							return colors.ansi16.theme.text.prompt.description.disabled;
+						},
+						get ansi256() {
+							return colors.ansi256.theme.text.prompt.description.disabled;
+						},
+						get ansi16m() {
+							return colors.ansi16m.theme.text.prompt.description.disabled;
+						}
+					})}
+                      }
                     }
                   },
                   border: {
@@ -1104,6 +1518,102 @@ function ColorsDeclaration() {
 function WriteLineFunctionDeclaration() {
 	const theme = useTheme();
 	return [
+		createComponent(FunctionDeclaration, {
+			name: "adjustIndex",
+			parameters: [{
+				name: "line",
+				type: "string"
+			}, {
+				name: "index",
+				type: "number"
+			}],
+			returnType: "number",
+			children: code`let adjustedIndex = 0;
+
+        const segments = line.match(/\\x1b\\[(\\d|;)+m.*\\x1b\\[(\\d|;)+m/gi);
+        if (segments && segments.length > 0) {
+          segments.reduce((count, matched) => {
+            if (count < index) {
+              const stripped = stripAnsi(matched);
+              if (count + stripped.length < index) {
+                count += stripped.length;
+                adjustedIndex += matched.length;
+              } else {
+                adjustedIndex += index - count + (matched.slice(0, index - count).match(/\\x1b\\[(\\d|;)+m/g)?.join("")?.length ?? 0);
+                count = index;
+              }
+            }
+
+            return count;
+          }, 0);
+        } else {
+          adjustedIndex = index;
+        }
+
+        return adjustedIndex - (line.slice(0, adjustedIndex).match(/\\x1b\\[/g)?.length ?? 0); `
+		}),
+		createComponent(Spacing, {}),
+		createComponent(FunctionDeclaration, {
+			name: "breakLine",
+			parameters: [{
+				name: "line",
+				type: "string"
+			}, {
+				name: "index",
+				type: "number"
+			}],
+			returnType: "[string, string]",
+			children: code`const first = line.slice(0, index);
+        const second = line.slice(index);
+
+        // Match all ANSI escape sequences in the first string
+        const ansiRegex = /[\\x1b\\u009b][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?(?:\\u0007))|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))/g;
+
+        const openCodes: string[] = [];
+        const closeCodes: string[] = [];
+        let match: RegExpExecArray | null;
+
+        while ((match = ansiRegex.exec(first)) !== null) {
+          const code = match[0];
+          // Check if this is a reset/close code (e.g., \\x1b[0m, \\x1b[39m, \\x1b[49m, etc.)
+          if (/\\x1b\\[(?:0|22|23|24|27|28|29|39|49)m/.test(code)) {
+            // A close/reset code cancels the last open code
+            openCodes.pop();
+            closeCodes.pop();
+          } else {
+            openCodes.push(code);
+            // Derive a close code: map SGR open codes to their reset counterparts
+            const sgrMatch = code.match(/\\x1b\\[(\\d+)m/);
+            if (sgrMatch) {
+              const n = parseInt(sgrMatch[1]!, 10);
+              let closeCode: string;
+              if (n >= 30 && n <= 37) closeCode = "\\x1b[39m";
+              else if (n >= 40 && n <= 47) closeCode = "\\x1b[49m";
+              else if (n >= 90 && n <= 97) closeCode = "\\x1b[39m";
+              else if (n >= 100 && n <= 107) closeCode = "\\x1b[49m";
+              else if (n === 1) closeCode = "\\x1b[22m";
+              else if (n === 2) closeCode = "\\x1b[22m";
+              else if (n === 3) closeCode = "\\x1b[23m";
+              else if (n === 4) closeCode = "\\x1b[24m";
+              else if (n === 7) closeCode = "\\x1b[27m";
+              else if (n === 8) closeCode = "\\x1b[28m";
+              else if (n === 9) closeCode = "\\x1b[29m";
+              else closeCode = "\\x1b[0m";
+              closeCodes.push(closeCode);
+            } else {
+              closeCodes.push("\\x1b[0m");
+            }
+          }
+        }
+
+        // Append close codes to the end of "first" (in reverse order)
+        const closeSequence = closeCodes.slice().reverse().join("");
+        // Prepend open codes to the start of "second"
+        const openSequence = openCodes.join("");
+
+        return [first.replace(/^\\s+/, "").replace(/\\s+$/, "") + closeSequence, openSequence + second.replace(/^\\s+/, "").replace(/\\s+$/, "")]; `
+		}),
+		createComponent(Spacing, {}),
 		createComponent(TSDoc, {
 			heading: "Split text into multiple lines based on a maximum length.",
 			get children() {
@@ -1129,23 +1639,24 @@ function WriteLineFunctionDeclaration() {
 				type: "string"
 			}, {
 				name: "maxLength",
-				type: "number"
+				type: "number | SizeToken"
 			}],
 			children: code`
   let line = text;
   let result = [] as string[];
 
-  while (stripAnsi(line).length > maxLength || line.indexOf("\\n") !== -1) {
+  const calculatedMaxLength = isSizeToken(maxLength) ? calculateWidth(maxLength) : maxLength;
+  while (stripAnsi(line).length > calculatedMaxLength || line.indexOf("\\n") !== -1) {
     if (line.indexOf("\\n") !== -1) {
-      result.push(...splitText(line.slice(0, line.indexOf("\\n")).replace(/\\n/, ""), maxLength));
+      result.push(...splitText(line.slice(0, line.indexOf("\\n")).replace(/(\\r)?\\n/, ""), calculatedMaxLength));
       line = line.indexOf("\\n") + 1 < line.length
         ? line.slice(line.indexOf("\\n") + 1)
         : "";
     } else {
-      const index = [" ", "/", "\\\\", ".", ",", "-", ":", "|", "@", "+"].reduce((ret, split) => {
+      const index = [" ", "/", ".", ",", "-", ":", "|", "@", "+"].reduce((ret, split) => {
         let current = ret;
-        while (stripAnsi(line).indexOf(split, current + 1) !== -1 && stripAnsi(line).indexOf(split, current + 1) <= maxLength && (!/.*\\([^)]*$/.test(stripAnsi(line).slice(0, line.indexOf(split, current + 1))) || !/^[^(]*\\).*/.test(stripAnsi(line).slice(line.indexOf(split, current + 1) + 1)) || stripAnsi(line).slice(line.indexOf(split, current + 1) + 1).replace(/^.*\\)/, "").indexOf(split) !== -1)) {
-          current = line.indexOf(split, current + 1);
+        while (stripAnsi(line).indexOf(split, current + 1) !== -1 && stripAnsi(line).indexOf(split, current + 1) <= calculatedMaxLength) {
+          current = line.indexOf(split, adjustIndex(line, current + 1));
         }
 
         return current;
@@ -1154,22 +1665,23 @@ function WriteLineFunctionDeclaration() {
         break;
       }
 
-      result.push(line.slice(0, index));
-      line = line.slice(index + 1);
+      const lines = breakLine(line, index);
+      result.push(lines[0]);
+      line = lines[1];
     }
   }
 
-  while (stripAnsi(line).length > maxLength) {
-    result.push(line.slice(0, maxLength));
-    line = line.slice(maxLength + 1);
+  while (stripAnsi(line).length > calculatedMaxLength) {
+    const lines = breakLine(line, calculatedMaxLength);
+    result.push(lines[0]);
+    line = lines[1];
   }
 
   result.push(line);
   return result;
 `
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(InterfaceDeclaration, {
 			"export": true,
 			name: "WriteLineOptions",
@@ -1223,8 +1735,7 @@ function WriteLineFunctionDeclaration() {
 				];
 			}
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(TSDoc, {
 			heading: "Write a line to the console.",
 			get children() {
@@ -1314,6 +1825,8 @@ function MessageFunctionDeclaration(props) {
         }
 
         ${!theme.labels.message.footer[variant] && timestamp ? `const timestamp = \`\${colors.text.message.footer.${color}(new Date().toLocaleDateString())} \${colors.border.message.outline.${color}("${theme.borderStyles.message.outline[variant].bottom}")} \${colors.text.message.footer.${color}(new Date().toLocaleTimeString())}\`; ` : ""}
+
+        writeLine("");
         writeLine(colors.border.message.outline.${color}("${theme.borderStyles.message.outline[variant].topLeft}") + ${theme.labels.message.header[variant] || theme.icons.message.header[variant] ? `colors.border.message.outline.${color}("${theme.borderStyles.message.outline[variant].top}".repeat(4)) + " " + ${theme.icons.message.header[variant] ? `colors.border.message.outline.${color}("${theme.icons.message.header[variant]}") + " " +` : ""} colors.bold(colors.text.message.header.${color}("${theme.labels.message.header[variant]}")) + " " + colors.border.message.outline.${color}("${theme.borderStyles.message.outline[variant].top}".repeat(Math.max(process.stdout.columns - ${Math.max(theme.padding.app, 0) * 2 + theme.borderStyles.message.outline[variant].topLeft.length + 4 + (theme.icons.message.header[variant] ? 2 + (theme.labels.message.header[variant] ? 0 : 1) : 0) + (theme.labels.message.header[variant] ? theme.labels.message.header[variant].length + 2 : 0) + theme.borderStyles.message.outline[variant].topRight.length}, 0)))` : `colors.border.message.outline.${color}("${theme.borderStyles.message.outline[variant].top}".repeat(Math.max(process.stdout.columns - ${Math.max(theme.padding.app, 0) * 2 + theme.borderStyles.message.outline[variant].topLeft.length + theme.borderStyles.message.outline[variant].topRight.length}, 0)))`} + colors.border.message.outline.${color}("${theme.borderStyles.message.outline[variant].topRight}"), { consoleFn: console.${consoleFnName} });
         splitText(
           message,
@@ -1334,8 +1847,8 @@ function WrapAnsiFunction() {
 		heading: "Applies ANSI escape codes to a string.",
 		get children() {
 			return [
-				createComponent(TSDocRemarks, { children: `Split text by /\\\\u001b[\\[|\\]][0-9;]*m/ and wrap non-ANSI parts with open/closeing tags.` }),
-				createComponent(TSDocExample, { children: `const result = wrapAnsi("Hello\\\\u001b[31mWorld\\\\u001b[0mAgain", "\\\\u001b[36m", "\\\\u001b[39");\nconsole.log(result); // "\\\\u001b[36mHello\\\\u001b[39\\\\u001b[31mWorld\\\\u001b[0m\\\\u001b[36mAgain\\\\u001b[39"` }),
+				createComponent(TSDocRemarks, { children: `Split text by /\\\\x1b[\\[|\\]][0-9;]*m/ and wrap non-ANSI parts with open/closeing tags.` }),
+				createComponent(TSDocExample, { children: `const result = wrapAnsi("Hello\\\\x1b[31mWorld\\\\x1b[0mAgain", "\\\\x1b[36m", "\\\\x1b[39");\nconsole.log(result); // "\\\\x1b[36mHello\\\\x1b[39\\\\x1b[31mWorld\\\\x1b[0m\\\\x1b[36mAgain\\\\x1b[39"` }),
 				createComponent(TSDocParam, {
 					name: "text",
 					children: `The text to apply ANSI codes to.`
@@ -1375,7 +1888,7 @@ function WrapAnsiFunction() {
 
         let last = 0;
         let match: RegExpExecArray | null;
-        while ((match = /\\\\u001b[\\[|\\]][0-9;]*m/g.exec(str)) !== null) {
+        while ((match = /\\\\x1b[\\[|\\]][0-9;]*m/g.exec(str)) !== null) {
           if (match.index > last) tokens.push(str.slice(last, match.index));
           tokens.push(match[0]);
           last = match.index + match[0].length;
@@ -1388,7 +1901,7 @@ function WrapAnsiFunction() {
         let result = "";
         for (let i = 0; i < tokens.length; i++) {
           const seg = tokens[i]!;
-          if (/^\\\\u001b[\\[|\\]][0-9;]*m$/.test(seg)) {
+          if (/^\\\\x1b[\\[|\\]][0-9;]*m$/.test(seg)) {
             result += seg;
             continue;
           }
@@ -1397,7 +1910,7 @@ function WrapAnsiFunction() {
             continue;
           }
 
-          result += i > 0 && /^\\\\u001b[\\[|\\]][0-9;]*m$/.test(tokens[i - 1]!) && i + 1 < tokens.length && /^\\\\u001b[\\[|\\]][0-9;]*m$/.test(tokens[i + 1]!)
+          result += i > 0 && /^\\\\x1b[\\[|\\]][0-9;]*m$/.test(tokens[i - 1]!) && i + 1 < tokens.length && /^\\\\x1b[\\[|\\]][0-9;]*m$/.test(tokens[i + 1]!)
             ? seg
             : \`\${open}\${seg}\${close}\`;
         }
@@ -1414,7 +1927,7 @@ function StripAnsiFunctionDeclaration() {
 		heading: "Removes ANSI escape codes from a string.",
 		get children() {
 			return [
-				createComponent(TSDocExample, { children: `const result = stripAnsi("Hello\\\\u001b[31mWorld\\\\u001b[0mAgain"); // "HelloWorldAgain"` }),
+				createComponent(TSDocExample, { children: `const result = stripAnsi("Hello\\\\x1b[31mWorld\\\\x1b[0mAgain"); // "HelloWorldAgain"` }),
 				createComponent(TSDocParam, {
 					name: "text",
 					children: `The text to strip ANSI codes from.`
@@ -1494,8 +2007,7 @@ function DividerFunctionDeclaration() {
 				];
 			}
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(TSDoc, {
 			heading: "Write a divider line to the console.",
 			get children() {
@@ -1559,7 +2071,7 @@ function LinkFunctionDeclaration() {
 			return [
 				createComponent(IfStatement, {
 					condition: code`isHyperlinkSupported()`,
-					children: code`return \`\\u001b]8;;\${url}\\u0007\${text ?? url}\\u001b]8;;\\u0007\`;`
+					children: code`return \`\\x1b]8;;\${url}\\u0007\${text ?? url}\\x1b]8;;\\u0007\`;`
 				}),
 				createIntrinsic("hbr", {}),
 				createComponent(IfStatement, {
@@ -1587,14 +2099,119 @@ function extractBorderOptionsString(direction, theme) {
 function TableFunctionDeclaration(props) {
 	const theme = useTheme();
 	return [
+		createComponent(TypeDeclaration, {
+			"export": true,
+			name: "SizeToken",
+			doc: "A type representing the width size of an item in the console.",
+			children: code`"full" | "1/1" | "1/2" | "1/3" | "1/4" | "1/5" | "1/6" | "1/12" | "1/24" | "100%" | "50%" | "33.33%" | "25%" | "20%" | "10%" | "5%" | "2.5%"`
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "Determine if a value is a valid size token.",
+			get children() {
+				return [
+					createComponent(TSDocRemarks, { children: `This function checks if the provided value is a valid size token, which can be one of the predefined strings representing common width sizes (e.g., "full", "1/2", "1/3", etc.) or percentage strings (e.g., "50%").` }),
+					createComponent(TSDocParam, {
+						name: "value",
+						children: `The value to check for being a valid size token.`
+					}),
+					createComponent(TSDocReturns, { children: `True if the value is a valid size token, false otherwise.` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			doc: "Determines if the provided value is a valid size token.",
+			name: "isSizeToken",
+			parameters: [{
+				name: "value",
+				type: "any"
+			}],
+			returnType: "value is SizeToken",
+			get children() {
+				return [createComponent(IfStatement, {
+					condition: code`["full", "1/1", "1/2", "1/3", "1/4", "1/5", "1/6", "1/12", "1/24", "100%", "50%", "33.33%", "25%", "20%", "10%", "5%", "2.5%"].includes(value)`,
+					children: code`return true; `
+				}), code`return false; `];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "Calculate the width in characters based on the provided width size.",
+			get children() {
+				return [
+					createComponent(TSDocRemarks, { children: `This function calculates the width in characters based on the provided width size, which can be a predefined string (e.g., "full", "1/2", "1/3", etc.) or a percentage string (e.g., "50%"). The calculation is based on the current width of the console (process.stdout.columns).` }),
+					createComponent(TSDocParam, {
+						name: "size",
+						children: `The width size to calculate. This can be a predefined string (e.g., "full", "1/2", "1/3", etc.) or a percentage string (e.g., "50%").`
+					}),
+					createComponent(TSDocReturns, { children: `The calculated width in characters.` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			name: "calculateWidth",
+			parameters: [{
+				name: "size",
+				type: "SizeToken",
+				optional: false
+			}],
+			returnType: "number",
+			get children() {
+				return [
+					createComponent(IfStatement, {
+						condition: code`["full", "100%", "1/1"]. includes(size)`,
+						children: code`return process.stdout.columns;`
+					}),
+					createComponent(ElseIfClause, {
+						condition: code`["1/2", "50%"].includes(size)`,
+						children: code`return Math.round(process.stdout.columns / 2);`
+					}),
+					createComponent(ElseIfClause, {
+						condition: code`["1/3", "33.33%"].includes(size)`,
+						children: code`return Math.round(process.stdout.columns / 3);`
+					}),
+					createComponent(ElseIfClause, {
+						condition: code`["1/4", "25%"].includes(size)`,
+						children: code`return Math.round(process.stdout.columns / 4);`
+					}),
+					createComponent(ElseIfClause, {
+						condition: code`["1/5", "20%"].includes(size)`,
+						children: code`return Math.round(process.stdout.columns / 5);`
+					}),
+					createComponent(ElseIfClause, {
+						condition: code`["1/6", "10%"].includes(size)`,
+						children: code`return Math.round(process.stdout.columns / 6);`
+					}),
+					createComponent(ElseIfClause, {
+						condition: code`["1/12", "5%"].includes(size)`,
+						children: code`return Math.round(process.stdout.columns / 12);`
+					}),
+					createComponent(ElseIfClause, {
+						condition: code`["1/24", "2.5%"].includes(size)`,
+						children: code`return Math.round(process.stdout.columns / 24);`
+					}),
+					createComponent(ElseClause, { children: code`
+            const match = size.match(/(\\d+(\\.\\d+)?)%/);
+            if (match) {
+              return Math.round((process.stdout.columns * parseFloat(match[1])) / 100);
+            }
+
+            throw new Error(\`Invalid width size: \${size}\`);
+          ` }),
+					createIntrinsic("hbr", {}),
+					createIntrinsic("hbr", {})
+				];
+			}
+		}),
 		createComponent(TypeDeclaration, {
 			"export": true,
 			name: "BorderOption",
 			doc: "The border options applied to table cells.",
 			children: code`"primary" | "secondary" | "tertiary" | "none" | string; `
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(InterfaceDeclaration, {
 			"export": true,
 			name: "TableOutputOptions",
@@ -1669,24 +2286,36 @@ function TableFunctionDeclaration(props) {
 				];
 			}
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(InterfaceDeclaration, {
 			"export": true,
 			name: "TableCellOptions",
 			"extends": "TableOutputOptions",
 			doc: "Options for a specific table cell provided to the {@link table} function.",
 			get children() {
-				return [createComponent(InterfaceMember, {
-					name: "value",
-					optional: true,
-					type: "string",
-					doc: "The actual string value of the table cell."
-				}), createIntrinsic("hbr", {})];
+				return [
+					createComponent(InterfaceMember, {
+						name: "value",
+						optional: true,
+						type: "string",
+						doc: "The actual string value of the table cell."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(TSDoc, {
+						heading: "Width of the table cell.",
+						get children() {
+							return createComponent(TSDocRemarks, { children: `The width of the table cell (where 1 is a single character in the terminal). If not specified, the width will be determined based on the content of the cell and the available space in the console.` });
+						}
+					}),
+					createComponent(InterfaceMember, {
+						name: "maxWidth",
+						type: "number | SizeToken | undefined"
+					}),
+					createIntrinsic("hbr", {})
+				];
 			}
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(InterfaceDeclaration, {
 			"export": true,
 			name: "TableRowOptions",
@@ -1701,8 +2330,7 @@ function TableFunctionDeclaration(props) {
 				}), createIntrinsic("hbr", {})];
 			}
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(InterfaceDeclaration, {
 			"export": true,
 			name: "TableOptions",
@@ -1717,8 +2345,7 @@ function TableFunctionDeclaration(props) {
 				}), createIntrinsic("hbr", {})];
 			}
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(InterfaceDeclaration, {
 			name: "Dimensions",
 			doc: "The height and width for a specific table/cell used internally in the {@link table} function.",
@@ -1739,8 +2366,7 @@ function TableFunctionDeclaration(props) {
 				];
 			}
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(InterfaceDeclaration, {
 			name: "TableCellBorder",
 			doc: "The resolved complete border styles for a table cell.",
@@ -1797,18 +2423,17 @@ function TableFunctionDeclaration(props) {
 				];
 			}
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(TypeDeclaration, {
 			name: "TableCell",
 			doc: "The internal state of a formatted table cell in the {@link table} function.",
-			children: code`Required<Omit<TableCellOptions, "border">> & Dimensions & {
+			children: code`Required<Omit<TableCellOptions, "maxWidth" | "border">> & Dimensions & {
           border: TableCellBorder;
+          maxWidth?: number;
         };
         `
 		}),
-		createIntrinsic("hbr", {}),
-		createIntrinsic("hbr", {}),
+		createComponent(Spacing, {}),
 		createComponent(TSDoc, {
 			heading: "Write a table to the console.",
 			get children() {
@@ -1847,7 +2472,7 @@ function TableFunctionDeclaration(props) {
 					}),
 					createIntrinsic("hbr", {}),
 					memo(() => code`
-        const extractTableCell = (cell: string | TableCellOptions, opts?: TableOutputOptions): TableCell => {
+        const extractTableCell = (cell: string | TableCellOptions, columnIndex: number, rowLength: number, opts?: TableOutputOptions): TableCell => {
           if (typeof cell === "string") {
             const borderOptions = opts?.border || "primary";
 
@@ -1874,7 +2499,7 @@ function TableFunctionDeclaration(props) {
               border.bottomRight = ${extractBorderOptionsString("bottomRight", theme)};
             }
 
-            const padding = Math.max(0, opts?.padding ?? ${theme.padding.table});
+            const padding = Math.max(0, opts?.padding ?? ${theme.padding.table}) * (columnIndex === 0 || columnIndex === rowLength - 1 ? 2 : 1);
             const value = cell ?? "";
             const width = stripAnsi(value).length + padding * 2;
 
@@ -1915,17 +2540,21 @@ function TableFunctionDeclaration(props) {
             const padding = Math.max(0, cell.padding ?? opts?.padding ?? ${theme.padding.table});
             const value = cell.value ?? "";
             const width = stripAnsi(value).length + padding * 2;
+            const maxWidth = cell.maxWidth ? typeof cell.maxWidth === "number" ? cell.maxWidth : calculateWidth(cell.maxWidth) : undefined;
 
             return {
               value,
               height: 1,
               width,
+              maxWidth,
               border,
               padding,
               align: cell.align || opts?.align || "left",
             };
           }
         };
+
+        let colMaxWidths = [] as (number | undefined)[];
     `),
 					createIntrinsic("hbr", {}),
 					createComponent(IfStatement, {
@@ -1933,16 +2562,30 @@ function TableFunctionDeclaration(props) {
 						get children() {
 							return [createComponent(IfStatement, {
 								condition: code`options.every(row => typeof row === "string" || (typeof row === "object" && !Array.isArray(row) && !("values" in row)))`,
-								children: code`cells.push(options.map(cell => extractTableCell(cell as string | TableCellOptions)));`
+								children: code`cells.push(options.map((cell, index) => extractTableCell(cell as string | TableCellOptions, index, options.length)));`
 							}), createComponent(ElseClause, { children: code`
           cells.push(
             ...options.map(row => Array.isArray(row)
-              ? row.reduce((cellRow, cell) => {
-                cellRow.push(extractTableCell(cell));
+              ? row.reduce((cellRow, cell, index) => {
+                if (colMaxWidths.length <= index) {
+                  colMaxWidths.push(undefined);
+                }
+                const newCell = extractTableCell(cell, index, row.length);
+                if (newCell.maxWidth && (!colMaxWidths[index] || newCell.maxWidth < colMaxWidths[index]!)) {
+                  colMaxWidths[index] = newCell.maxWidth;
+                }
+                cellRow.push(newCell);
                 return cellRow;
               }, [] as TableCell[])
-              : (row as TableRowOptions).values?.reduce((cellRow, cell) => {
-                cellRow.push(extractTableCell(cell, row as TableRowOptions));
+              : (row as TableRowOptions).values?.reduce((cellRow, cell, index) => {
+                if (colMaxWidths.length <= index) {
+                  colMaxWidths.push(undefined);
+                }
+                const newCell = extractTableCell(cell, index, (row as TableRowOptions).values?.length ?? 1, row as TableRowOptions);
+                if (newCell.maxWidth && (!colMaxWidths[index] || newCell.maxWidth < colMaxWidths[index]!)) {
+                  colMaxWidths[index] = newCell.maxWidth;
+                }
+                cellRow.push(newCell);
                 return cellRow;
               }, [] as TableCell[]) ?? []
             )
@@ -1953,12 +2596,26 @@ function TableFunctionDeclaration(props) {
 					createComponent(ElseClause, { children: code`
         cells.push(
           ...options.values!.map(row => Array.isArray(row)
-            ? row.reduce((cellRow, cell) => {
-              cellRow.push(extractTableCell(cell));
+            ? row.reduce((cellRow, cell, index) => {
+              if (colMaxWidths.length <= index) {
+                colMaxWidths.push(undefined);
+              }
+              const newCell = extractTableCell(cell, index, row.length);
+              if (newCell.maxWidth && (!colMaxWidths[index] || newCell.maxWidth < colMaxWidths[index]!)) {
+                colMaxWidths[index] = newCell.maxWidth;
+              }
+              cellRow.push(newCell);
               return cellRow;
             }, [] as TableCell[])
-            : (row as TableRowOptions).values?.reduce((cellRow, cell) => {
-              cellRow.push(extractTableCell(cell, options));
+            : (row as TableRowOptions).values?.reduce((cellRow, cell, index) => {
+              if (colMaxWidths.length <= index) {
+                colMaxWidths.push(undefined);
+              }
+              const newCell = extractTableCell(cell, index, (row as TableRowOptions).values?.length ?? 1, options);
+              if (newCell.maxWidth && (!colMaxWidths[index] || newCell.maxWidth < colMaxWidths[index]!)) {
+                colMaxWidths[index] = newCell.maxWidth;
+              }
+              cellRow.push(newCell);
               return cellRow;
             }, [] as TableCell[]) ?? []
           )
@@ -1972,6 +2629,12 @@ if (cells.length === 0) {
   return;
 }
 
+cells.forEach(row => row.forEach((cell, index) => {
+  if (colMaxWidths[index] && cell.maxWidth !== colMaxWidths[index]!) {
+    cell.maxWidth = colMaxWidths[index]!;
+  }
+}));
+
 // Calculate table dimensions
 let colWidths = [] as number[];
 let rowDims = [] as Dimensions[];
@@ -2000,6 +2663,26 @@ do {
   recalculate = false;
   rowDims = calculateRowDimensions();
 
+  if (!recalculate && colWidths.some((colWidth, index) => colMaxWidths[index] && colWidth > colMaxWidths[index]!)) {
+    (colWidths.map((colWidth, index) => colMaxWidths[index] && colWidth > colMaxWidths[index]! ? index : undefined).filter(colWidth => colWidth !== undefined) as number[]).forEach(index => {
+      cells.forEach(row => {
+        const cell = row[index]!;
+        if (colMaxWidths[index] && cell.width > colMaxWidths[index]) {
+          const lines = splitText(
+            cell.value,
+            colMaxWidths[index] - cell.padding * 2,
+          );
+
+          cell.value = lines.join("\\n");
+          cell.height = lines.length;
+          cell.width = Math.max(...lines.map(line => stripAnsi(line).length)) + cell.padding * 2;
+
+          recalculate = true;
+        }
+      });
+    });
+  }
+
   rowDims.forEach((row, rowIndex) => {
     if (!recalculate && row.width > Math.max(process.stdout.columns - ${Math.max(theme.padding.app, 0) * 2}, 0)) {
       const cell = cells[rowIndex]!.reduce((largestCell, cell) => {
@@ -2011,7 +2694,8 @@ do {
 
       const lines = splitText(
         cell.value,
-        Math.max(process.stdout.columns - ${Math.max(theme.padding.app, 0) * 2} - (row.width - (cell.width - cell.padding * 2)), 0)
+        Math.min(Math.max(process.stdout.columns - ${Math.max(theme.padding.app, 0) * 2} - (row.width - (cell.width - cell.padding * 2)), 0),
+        cell.maxWidth ?? Number.POSITIVE_INFINITY)
       );
 
       cell.value = lines.join("\\n");
@@ -2025,9 +2709,9 @@ do {
   if (!recalculate && colWidths.reduce((a, b) => a + b, 0) > Math.max(process.stdout.columns - ${Math.max(theme.padding.app, 0) * 2}, 0)) {
     let colIndex = 0;
     const cell = cells.reduce((ret, row) => {
-      return row.reduce((largest, current, i) => {
+      return row.reduce((largest, current, index) => {
         if (largest.width < current.width) {
-          colIndex = i;
+          colIndex = index;
           return current;
         }
         return largest;
@@ -2036,7 +2720,8 @@ do {
 
     const lines = splitText(
       cell.value,
-      Math.max(process.stdout.columns - ${Math.max(theme.padding.app, 0) * 2} - (colWidths.filter((_, i) => i !== colIndex).reduce((a, b) => a + b, 0)) - cell.padding * 2, 0)
+      Math.min(Math.max(process.stdout.columns - ${Math.max(theme.padding.app, 0) * 2} - (colWidths.filter((_, i) => i !== colIndex).reduce((a, b) => a + b, 0)) - cell.padding * 2, 0),
+      cell.maxWidth ?? Number.POSITIVE_INFINITY)
     );
 
     cell.value = lines.join("\\n");
@@ -2123,48 +2808,41 @@ function ConsoleBuiltin(props) {
 		},
 		get children() {
 			return [
+				createComponent(AnsiHelpersDeclarations, {}),
+				createComponent(Spacing, {}),
 				createComponent(StripAnsiFunctionDeclaration, {}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(WrapAnsiFunction, {}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(ColorsDeclaration, {}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(WriteLineFunctionDeclaration, {}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(LinkFunctionDeclaration, {}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(DividerFunctionDeclaration, {}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(MessageFunctionDeclaration, {
 					type: "help",
 					variant: "help",
 					consoleFnName: "log",
 					description: "help"
 				}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(MessageFunctionDeclaration, {
 					type: "success",
 					variant: "success",
 					consoleFnName: "info",
 					description: "success"
 				}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(MessageFunctionDeclaration, {
 					type: "info",
 					variant: "info",
 					consoleFnName: "info",
 					description: "informational"
 				}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(MessageFunctionDeclaration, {
 					type: "debug",
 					variant: "debug",
@@ -2180,8 +2858,7 @@ function ConsoleBuiltin(props) {
 						});
 					}
 				}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(MessageFunctionDeclaration, {
 					type: "verbose",
 					variant: "info",
@@ -2198,24 +2875,21 @@ function ConsoleBuiltin(props) {
 						});
 					}
 				}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(MessageFunctionDeclaration, {
 					type: "warn",
 					variant: "warning",
 					consoleFnName: "warn",
 					description: "warning"
 				}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(MessageFunctionDeclaration, {
 					type: "danger",
 					variant: "danger",
 					consoleFnName: "error",
 					description: "destructive/danger"
 				}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(MessageFunctionDeclaration, {
 					type: "error",
 					variant: "error",
@@ -2234,8 +2908,7 @@ function ConsoleBuiltin(props) {
 								name: "message",
 								type: "string | undefined"
 							}),
-							createIntrinsic("hbr", {}),
-							createIntrinsic("hbr", {}),
+							createComponent(Spacing, {}),
 							createComponent(IfStatement, {
 								condition: code`(err as Error)?.message`,
 								get children() {
@@ -2249,19 +2922,16 @@ function ConsoleBuiltin(props) {
 						];
 					}
 				}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				createComponent(TableFunctionDeclaration, {}),
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {}),
+				createComponent(Spacing, {}),
 				children,
-				createIntrinsic("hbr", {}),
-				createIntrinsic("hbr", {})
+				createComponent(Spacing, {})
 			];
 		}
 	});
 }
 
 //#endregion
-export { ColorsDeclaration, ConsoleBuiltin, DividerFunctionDeclaration, LinkFunctionDeclaration, MessageFunctionDeclaration, StripAnsiFunctionDeclaration, TableFunctionDeclaration, WrapAnsiFunction, WriteLineFunctionDeclaration };
+export { AnsiHelpersDeclarations, ColorsDeclaration, ConsoleBuiltin, DividerFunctionDeclaration, LinkFunctionDeclaration, MessageFunctionDeclaration, StripAnsiFunctionDeclaration, TableFunctionDeclaration, WrapAnsiFunction, WriteLineFunctionDeclaration };
 //# sourceMappingURL=console-builtin.mjs.map