@oakoliver/lipgloss 1.0.0

package/src/border.ts

@@ -0,0 +1,168 @@
+/**
+ * Border definitions and built-in border styles.
+ */
+
+import { stringWidth } from './ansi.js';
+
+/** Border character set */
+export interface Border {
+  top: string;
+  bottom: string;
+  left: string;
+  right: string;
+  topLeft: string;
+  topRight: string;
+  bottomLeft: string;
+  bottomRight: string;
+  middleLeft: string;
+  middleRight: string;
+  middle: string;
+  middleTop: string;
+  middleBottom: string;
+}
+
+function border(b: Partial<Border>): Border {
+  return {
+    top: '', bottom: '', left: '', right: '',
+    topLeft: '', topRight: '', bottomLeft: '', bottomRight: '',
+    middleLeft: '', middleRight: '', middle: '', middleTop: '', middleBottom: '',
+    ...b,
+  };
+}
+
+/** No border */
+export const noBorder: Border = border({});
+
+/** Standard border with 90-degree corners */
+export function normalBorder(): Border {
+  return border({
+    top: '─', bottom: '─', left: '│', right: '│',
+    topLeft: '┌', topRight: '┐', bottomLeft: '└', bottomRight: '┘',
+    middleLeft: '├', middleRight: '┤', middle: '┼', middleTop: '┬', middleBottom: '┴',
+  });
+}
+
+/** Rounded corners */
+export function roundedBorder(): Border {
+  return border({
+    top: '─', bottom: '─', left: '│', right: '│',
+    topLeft: '╭', topRight: '╮', bottomLeft: '╰', bottomRight: '╯',
+    middleLeft: '├', middleRight: '┤', middle: '┼', middleTop: '┬', middleBottom: '┴',
+  });
+}
+
+/** Full block border */
+export function blockBorder(): Border {
+  return border({
+    top: '█', bottom: '█', left: '█', right: '█',
+    topLeft: '█', topRight: '█', bottomLeft: '█', bottomRight: '█',
+    middleLeft: '█', middleRight: '█', middle: '█', middleTop: '█', middleBottom: '█',
+  });
+}
+
+/** Outer half-block border */
+export function outerHalfBlockBorder(): Border {
+  return border({
+    top: '▀', bottom: '▄', left: '▌', right: '▐',
+    topLeft: '▛', topRight: '▜', bottomLeft: '▙', bottomRight: '▟',
+  });
+}
+
+/** Inner half-block border */
+export function innerHalfBlockBorder(): Border {
+  return border({
+    top: '▄', bottom: '▀', left: '▐', right: '▌',
+    topLeft: '▗', topRight: '▖', bottomLeft: '▝', bottomRight: '▘',
+  });
+}
+
+/** Thick border */
+export function thickBorder(): Border {
+  return border({
+    top: '━', bottom: '━', left: '┃', right: '┃',
+    topLeft: '┏', topRight: '┓', bottomLeft: '┗', bottomRight: '┛',
+    middleLeft: '┣', middleRight: '┫', middle: '╋', middleTop: '┳', middleBottom: '┻',
+  });
+}
+
+/** Double-line border */
+export function doubleBorder(): Border {
+  return border({
+    top: '═', bottom: '═', left: '║', right: '║',
+    topLeft: '╔', topRight: '╗', bottomLeft: '╚', bottomRight: '╝',
+    middleLeft: '╠', middleRight: '╣', middle: '╬', middleTop: '╦', middleBottom: '╩',
+  });
+}
+
+/** Hidden border (spaces) — maintains layout without visible borders */
+export function hiddenBorder(): Border {
+  return border({
+    top: ' ', bottom: ' ', left: ' ', right: ' ',
+    topLeft: ' ', topRight: ' ', bottomLeft: ' ', bottomRight: ' ',
+    middleLeft: ' ', middleRight: ' ', middle: ' ', middleTop: ' ', middleBottom: ' ',
+  });
+}
+
+/** Markdown-style table border */
+export function markdownBorder(): Border {
+  return border({
+    top: '-', bottom: '-', left: '|', right: '|',
+    topLeft: '|', topRight: '|', bottomLeft: '|', bottomRight: '|',
+    middleLeft: '|', middleRight: '|', middle: '|', middleTop: '|', middleBottom: '|',
+  });
+}
+
+/** ASCII border using +, -, | characters */
+export function asciiBorder(): Border {
+  return border({
+    top: '-', bottom: '-', left: '|', right: '|',
+    topLeft: '+', topRight: '+', bottomLeft: '+', bottomRight: '+',
+    middleLeft: '+', middleRight: '+', middle: '+', middleTop: '+', middleBottom: '+',
+  });
+}
+
+/** Get the max rune width of a border edge string */
+export function maxRuneWidth(str: string): number {
+  if (!str) return 0;
+  if (str.length === 1) return stringWidth(str);
+  let width = 0;
+  for (const ch of str) {
+    width = Math.max(width, stringWidth(ch));
+  }
+  return width;
+}
+
+/** Get the width of a border edge (top, bottom, etc.) */
+function getBorderEdgeWidth(...parts: string[]): number {
+  let max = 0;
+  for (const part of parts) {
+    max = Math.max(max, maxRuneWidth(part));
+  }
+  return max;
+}
+
+/** Get the size of the top edge of the border */
+export function getTopSize(b: Border): number {
+  return getBorderEdgeWidth(b.topLeft, b.top, b.topRight);
+}
+
+/** Get the size of the right edge of the border */
+export function getRightSize(b: Border): number {
+  return getBorderEdgeWidth(b.topRight, b.right, b.bottomRight);
+}
+
+/** Get the size of the bottom edge of the border */
+export function getBottomSize(b: Border): number {
+  return getBorderEdgeWidth(b.bottomLeft, b.bottom, b.bottomRight);
+}
+
+/** Get the size of the left edge of the border */
+export function getLeftSize(b: Border): number {
+  return getBorderEdgeWidth(b.topLeft, b.left, b.bottomLeft);
+}
+
+/** Check if a border is the "no border" (all empty strings) */
+export function isNoBorder(b: Border): boolean {
+  return !b.top && !b.bottom && !b.left && !b.right &&
+    !b.topLeft && !b.topRight && !b.bottomLeft && !b.bottomRight;
+}

package/src/color.ts

@@ -0,0 +1,294 @@
+/**
+ * Color types and utilities for terminal styling.
+ */
+
+import type { ColorValue } from './ansi.js';
+
+/**
+ * Represents no color — terminal default.
+ */
+export const NO_COLOR: unique symbol = Symbol('NoColor');
+export type NoColor = typeof NO_COLOR;
+
+/**
+ * RGB color representation.
+ */
+export interface RGBColor {
+  r: number;
+  g: number;
+  b: number;
+}
+
+/**
+ * A color that can be used in styling.
+ * - null/undefined/NO_COLOR = no color (terminal default)
+ * - number 0-15 = ANSI basic color
+ * - number 16-255 = ANSI 256 color
+ * - string "#RRGGBB" or "#RGB" = hex color
+ * - RGBColor = explicit RGB
+ */
+export type Color = string | number | RGBColor | NoColor | null | undefined;
+
+/** ANSI basic color constants (0-15) */
+export const Black = 0;
+export const Red = 1;
+export const Green = 2;
+export const Yellow = 3;
+export const Blue = 4;
+export const Magenta = 5;
+export const Cyan = 6;
+export const White = 7;
+export const BrightBlack = 8;
+export const BrightRed = 9;
+export const BrightGreen = 10;
+export const BrightYellow = 11;
+export const BrightBlue = 12;
+export const BrightMagenta = 13;
+export const BrightCyan = 14;
+export const BrightWhite = 15;
+
+/**
+ * Parse a color specification into an internal ColorValue.
+ * Returns null for "no color".
+ */
+export function parseColor(c: Color): ColorValue | null {
+  if (c === null || c === undefined || c === NO_COLOR) return null;
+
+  if (typeof c === 'number') {
+    if (c < 0) c = -c;
+    if (c < 16) return { type: 'basic', value: c };
+    if (c < 256) return { type: 'ansi256', value: c };
+    // Treat as packed RGB: 0xRRGGBB
+    return {
+      type: 'rgb',
+      value: 0,
+      r: (c >> 16) & 0xff,
+      g: (c >> 8) & 0xff,
+      b: c & 0xff,
+    };
+  }
+
+  if (typeof c === 'string') {
+    if (c.startsWith('#')) {
+      const rgb = parseHex(c);
+      if (!rgb) return null;
+      return { type: 'rgb', value: 0, ...rgb };
+    }
+    // Try parsing as number
+    const n = parseInt(c, 10);
+    if (!isNaN(n)) {
+      return parseColor(n);
+    }
+    return null;
+  }
+
+  // RGBColor object
+  if (typeof c === 'object' && 'r' in c && 'g' in c && 'b' in c) {
+    return { type: 'rgb', value: 0, r: c.r, g: c.g, b: c.b };
+  }
+
+  return null;
+}
+
+/**
+ * Parse a hex color string (#RGB or #RRGGBB) into RGB values.
+ */
+export function parseHex(hex: string): RGBColor | null {
+  if (!hex.startsWith('#')) return null;
+
+  if (hex.length === 7) {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
+    return { r, g, b };
+  }
+
+  if (hex.length === 4) {
+    const r = parseInt(hex[1], 16) * 17;
+    const g = parseInt(hex[2], 16) * 17;
+    const b = parseInt(hex[3], 16) * 17;
+    if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
+    return { r, g, b };
+  }
+
+  return null;
+}
+
+/**
+ * Convert any Color to RGB values (approximation for ANSI colors).
+ */
+export function colorToRGB(c: Color): RGBColor | null {
+  const cv = parseColor(c);
+  if (!cv) return null;
+  if (cv.type === 'rgb') return { r: cv.r!, g: cv.g!, b: cv.b! };
+  if (cv.type === 'ansi256') return ansi256ToRGB(cv.value);
+  if (cv.type === 'basic') return ansi256ToRGB(cv.value);
+  return null;
+}
+
+/** Standard ANSI 16 color palette (approximate RGB values) */
+const ANSI_16_COLORS: RGBColor[] = [
+  { r: 0, g: 0, b: 0 },       // Black
+  { r: 170, g: 0, b: 0 },     // Red
+  { r: 0, g: 170, b: 0 },     // Green
+  { r: 170, g: 85, b: 0 },    // Yellow
+  { r: 0, g: 0, b: 170 },     // Blue
+  { r: 170, g: 0, b: 170 },   // Magenta
+  { r: 0, g: 170, b: 170 },   // Cyan
+  { r: 170, g: 170, b: 170 }, // White
+  { r: 85, g: 85, b: 85 },    // Bright Black
+  { r: 255, g: 85, b: 85 },   // Bright Red
+  { r: 85, g: 255, b: 85 },   // Bright Green
+  { r: 255, g: 255, b: 85 },  // Bright Yellow
+  { r: 85, g: 85, b: 255 },   // Bright Blue
+  { r: 255, g: 85, b: 255 },  // Bright Magenta
+  { r: 85, g: 255, b: 255 },  // Bright Cyan
+  { r: 255, g: 255, b: 255 }, // Bright White
+];
+
+/**
+ * Convert ANSI 256 color index to approximate RGB.
+ */
+export function ansi256ToRGB(index: number): RGBColor {
+  if (index < 16) return ANSI_16_COLORS[index];
+
+  if (index < 232) {
+    // 6x6x6 color cube
+    const i = index - 16;
+    const r = Math.floor(i / 36);
+    const g = Math.floor((i % 36) / 6);
+    const b = i % 6;
+    return {
+      r: r ? r * 40 + 55 : 0,
+      g: g ? g * 40 + 55 : 0,
+      b: b ? b * 40 + 55 : 0,
+    };
+  }
+
+  // Grayscale (232-255)
+  const v = (index - 232) * 10 + 8;
+  return { r: v, g: v, b: v };
+}
+
+/**
+ * Determine if a color is "dark" based on luminance.
+ */
+export function isDarkColor(c: Color): boolean {
+  const rgb = colorToRGB(c);
+  if (!rgb) return true;
+  // HSL lightness approximation
+  const max = Math.max(rgb.r, rgb.g, rgb.b) / 255;
+  const min = Math.min(rgb.r, rgb.g, rgb.b) / 255;
+  const l = (max + min) / 2;
+  return l < 0.5;
+}
+
+/**
+ * LightDark returns a function that picks a color based on background darkness.
+ */
+export function lightDark(isDark: boolean): (light: Color, dark: Color) => Color {
+  return (light: Color, dark: Color) => isDark ? dark : light;
+}
+
+/**
+ * Returns the complementary color (180 degrees on the color wheel).
+ */
+export function complementary(c: Color): Color {
+  const rgb = colorToRGB(c);
+  if (!rgb) return null;
+
+  // Convert to HSV, rotate hue 180 degrees, convert back
+  const { h, s, v } = rgbToHsv(rgb.r, rgb.g, rgb.b);
+  const newH = (h + 180) % 360;
+  const result = hsvToRgb(newH, s, v);
+  return result;
+}
+
+/**
+ * Darken a color by a percentage (0-1).
+ */
+export function darken(c: Color, percent: number): Color {
+  const rgb = colorToRGB(c);
+  if (!rgb) return null;
+  const mult = 1 - clamp(percent, 0, 1);
+  return {
+    r: Math.round(rgb.r * mult),
+    g: Math.round(rgb.g * mult),
+    b: Math.round(rgb.b * mult),
+  };
+}
+
+/**
+ * Lighten a color by a percentage (0-1).
+ */
+export function lighten(c: Color, percent: number): Color {
+  const rgb = colorToRGB(c);
+  if (!rgb) return null;
+  const add = 255 * clamp(percent, 0, 1);
+  return {
+    r: Math.min(255, Math.round(rgb.r + add)),
+    g: Math.min(255, Math.round(rgb.g + add)),
+    b: Math.min(255, Math.round(rgb.b + add)),
+  };
+}
+
+/**
+ * Adjust alpha (0 = transparent, 1 = opaque). Returns an RGBColor
+ * (terminal colors don't truly support alpha, but useful for blending).
+ */
+export function alpha(c: Color, a: number): RGBColor | null {
+  const rgb = colorToRGB(c);
+  if (!rgb) return null;
+  const al = clamp(a, 0, 1);
+  return {
+    r: Math.round(rgb.r * al),
+    g: Math.round(rgb.g * al),
+    b: Math.round(rgb.b * al),
+  };
+}
+
+// ---- Helpers ----
+
+function clamp(v: number, lo: number, hi: number): number {
+  return Math.min(hi, Math.max(lo, v));
+}
+
+function rgbToHsv(r: number, g: number, b: number): { h: number; s: number; v: number } {
+  r /= 255; g /= 255; b /= 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const d = max - min;
+  let h = 0;
+  const s = max === 0 ? 0 : d / max;
+  const v = max;
+
+  if (d !== 0) {
+    if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+    else if (max === g) h = ((b - r) / d + 2) / 6;
+    else h = ((r - g) / d + 4) / 6;
+  }
+
+  return { h: h * 360, s, v };
+}
+
+function hsvToRgb(h: number, s: number, v: number): RGBColor {
+  h = ((h % 360) + 360) % 360;
+  const c = v * s;
+  const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+  const m = v - c;
+  let r = 0, g = 0, b = 0;
+
+  if (h < 60) { r = c; g = x; }
+  else if (h < 120) { r = x; g = c; }
+  else if (h < 180) { g = c; b = x; }
+  else if (h < 240) { g = x; b = c; }
+  else if (h < 300) { r = x; b = c; }
+  else { r = c; b = x; }
+
+  return {
+    r: Math.round((r + m) * 255),
+    g: Math.round((g + m) * 255),
+    b: Math.round((b + m) * 255),
+  };
+}

package/src/index.ts

@@ -0,0 +1,44 @@
+/**
+ * lipgloss — CSS-like terminal styling for JavaScript.
+ * Zero dependencies, multi-runtime (Node.js, Bun, Deno).
+ *
+ * Ported from charmbracelet/lipgloss (Go) by Antonio Oliveira.
+ */
+
+// Style
+export { Style, newStyle, getLines, getFirstRune } from './style.js';
+export type { Position } from './style.js';
+export { Top, Bottom, Center, Left, Right } from './style.js';
+
+// Colors
+export {
+  NO_COLOR, Black, Red, Green, Yellow, Blue, Magenta, Cyan, White,
+  BrightBlack, BrightRed, BrightGreen, BrightYellow, BrightBlue,
+  BrightMagenta, BrightCyan, BrightWhite,
+  parseColor, parseHex, colorToRGB, ansi256ToRGB,
+  isDarkColor, lightDark, complementary, darken, lighten, alpha,
+} from './color.js';
+export type { Color, RGBColor, NoColor } from './color.js';
+
+// Borders
+export {
+  noBorder, normalBorder, roundedBorder, blockBorder,
+  outerHalfBlockBorder, innerHalfBlockBorder, thickBorder,
+  doubleBorder, hiddenBorder, markdownBorder, asciiBorder,
+  maxRuneWidth, getTopSize, getRightSize, getBottomSize, getLeftSize, isNoBorder,
+} from './border.js';
+export type { Border } from './border.js';
+
+// Layout
+export {
+  joinHorizontal, joinVertical,
+  place, placeHorizontal, placeVertical,
+} from './layout.js';
+
+// ANSI utilities
+export {
+  SGR, stringWidth, stripAnsi, truncate, styled,
+  fgColor, fgAnsi256, fgBasic, bgColor, bgAnsi256, bgBasic,
+  ulColor, ulAnsi256, setHyperlink, resetHyperlink,
+} from './ansi.js';
+export type { ColorValue, UnderlineStyle, AnsiStyleOptions } from './ansi.js';

package/src/layout.ts

@@ -0,0 +1,206 @@
+/**
+ * Layout utilities: JoinHorizontal, JoinVertical, Place, PlaceHorizontal, PlaceVertical.
+ * Ported from charmbracelet/lipgloss join.go and position.go.
+ */
+
+import { stringWidth } from './ansi.js';
+import { getLines } from './style.js';
+import type { Position } from './style.js';
+import { Top, Bottom, Left, Right } from './style.js';
+
+// ---------------------------------------------------------------------------
+// JoinHorizontal
+// ---------------------------------------------------------------------------
+
+/**
+ * Horizontally join multi-line strings along a vertical axis.
+ * `pos` is the vertical alignment: 0 = top, 0.5 = center, 1 = bottom.
+ */
+export function joinHorizontal(pos: Position, ...strs: string[]): string {
+  if (strs.length === 0) return '';
+  if (strs.length === 1) return strs[0];
+
+  const blocks: string[][] = [];
+  const maxWidths: number[] = [];
+  let maxHeight = 0;
+
+  for (let i = 0; i < strs.length; i++) {
+    const { lines, widest } = getLines(strs[i]);
+    blocks.push(lines);
+    maxWidths.push(widest);
+    if (lines.length > maxHeight) maxHeight = lines.length;
+  }
+
+  // Equalize heights
+  for (let i = 0; i < blocks.length; i++) {
+    if (blocks[i].length >= maxHeight) continue;
+    const extra = maxHeight - blocks[i].length;
+    const empties = new Array<string>(extra).fill('');
+
+    const p = Math.min(1, Math.max(0, pos));
+    if (p <= 0) {
+      // Top aligned
+      blocks[i] = [...blocks[i], ...empties];
+    } else if (p >= 1) {
+      // Bottom aligned
+      blocks[i] = [...empties, ...blocks[i]];
+    } else {
+      const split = Math.round(extra * p);
+      const top = extra - split;
+      const bottom = extra - top;
+      blocks[i] = [
+        ...new Array<string>(top).fill(''),
+        ...blocks[i],
+        ...new Array<string>(bottom).fill(''),
+      ];
+    }
+  }
+
+  // Merge
+  const result: string[] = [];
+  for (let row = 0; row < maxHeight; row++) {
+    let line = '';
+    for (let col = 0; col < blocks.length; col++) {
+      const cell = blocks[col][row] || '';
+      line += cell;
+      // Pad to max width
+      const pad = maxWidths[col] - stringWidth(cell);
+      if (pad > 0) line += ' '.repeat(pad);
+    }
+    result.push(line);
+  }
+
+  return result.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// JoinVertical
+// ---------------------------------------------------------------------------
+
+/**
+ * Vertically join multi-line strings along a horizontal axis.
+ * `pos` is the horizontal alignment: 0 = left, 0.5 = center, 1 = right.
+ */
+export function joinVertical(pos: Position, ...strs: string[]): string {
+  if (strs.length === 0) return '';
+  if (strs.length === 1) return strs[0];
+
+  const blocks: string[][] = [];
+  let maxWidth = 0;
+
+  for (const str of strs) {
+    const { lines, widest } = getLines(str);
+    blocks.push(lines);
+    if (widest > maxWidth) maxWidth = widest;
+  }
+
+  const result: string[] = [];
+  for (let i = 0; i < blocks.length; i++) {
+    for (let j = 0; j < blocks[i].length; j++) {
+      const line = blocks[i][j];
+      const gap = maxWidth - stringWidth(line);
+
+      if (gap <= 0) {
+        result.push(line);
+      } else {
+        const p = Math.min(1, Math.max(0, pos));
+        if (p <= 0) {
+          // Left
+          result.push(line + ' '.repeat(gap));
+        } else if (p >= 1) {
+          // Right
+          result.push(' '.repeat(gap) + line);
+        } else {
+          const split = Math.round(gap * p);
+          const left = gap - split;
+          const right = gap - left;
+          result.push(' '.repeat(left) + line + ' '.repeat(right));
+        }
+      }
+    }
+  }
+
+  return result.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Place
+// ---------------------------------------------------------------------------
+
+/**
+ * Place a string in an unstyled box of given width and height.
+ */
+export function place(width: number, height: number, hPos: Position, vPos: Position, str: string): string {
+  return placeVertical(height, vPos, placeHorizontal(width, hPos, str));
+}
+
+/**
+ * Place a string horizontally in an unstyled block of given width.
+ */
+export function placeHorizontal(width: number, pos: Position, str: string): string {
+  const { lines, widest: contentWidth } = getLines(str);
+  const gap = width - contentWidth;
+  if (gap <= 0) return str;
+
+  const result: string[] = [];
+  for (const line of lines) {
+    const short = Math.max(0, contentWidth - stringWidth(line));
+    const totalGap = gap + short;
+    const p = Math.min(1, Math.max(0, pos));
+
+    if (p <= 0) {
+      // Left
+      result.push(line + ' '.repeat(totalGap));
+    } else if (p >= 1) {
+      // Right
+      result.push(' '.repeat(totalGap) + line);
+    } else {
+      const split = Math.round(totalGap * p);
+      const left = totalGap - split;
+      const right = totalGap - left;
+      result.push(' '.repeat(left) + line + ' '.repeat(right));
+    }
+  }
+
+  return result.join('\n');
+}
+
+/**
+ * Place a string vertically in an unstyled block of given height.
+ */
+export function placeVertical(height: number, pos: Position, str: string): string {
+  const contentHeight = str.split('\n').length;
+  const gap = height - contentHeight;
+  if (gap <= 0) return str;
+
+  const { widest: width } = getLines(str);
+  const emptyLine = ' '.repeat(width);
+  const p = Math.min(1, Math.max(0, pos));
+
+  if (p <= 0) {
+    // Top
+    const bottom: string[] = [];
+    for (let i = 0; i < gap; i++) bottom.push(emptyLine);
+    return str + '\n' + bottom.join('\n');
+  } else if (p >= 1) {
+    // Bottom
+    const top: string[] = [];
+    for (let i = 0; i < gap; i++) top.push(emptyLine);
+    return top.join('\n') + '\n' + str;
+  } else {
+    const split = Math.round(gap * p);
+    const topCount = gap - split;
+    const bottomCount = gap - topCount;
+
+    const topLines: string[] = [];
+    for (let i = 0; i < topCount; i++) topLines.push(emptyLine);
+    const bottomLines: string[] = [];
+    for (let i = 0; i < bottomCount; i++) bottomLines.push(emptyLine);
+
+    let result = '';
+    if (topLines.length > 0) result += topLines.join('\n') + '\n';
+    result += str;
+    if (bottomLines.length > 0) result += '\n' + bottomLines.join('\n');
+    return result;
+  }
+}