gloomberb 0.5.0 → 0.6.0

package/src/utils/html-entities.ts

@@ -0,0 +1,32 @@
+const NAMED_ENTITIES: Record<string, string> = {
+  amp: "&",
+  apos: "'",
+  gt: ">",
+  lt: "<",
+  nbsp: " ",
+  quot: "\"",
+};
+
+function decodeCodePoint(codePoint: number, fallback: string): string {
+  return Number.isInteger(codePoint) && codePoint >= 0 && codePoint <= 0x10ffff
+    ? String.fromCodePoint(codePoint)
+    : fallback;
+}
+
+export function decodeHtmlEntities(value: string): string {
+  return value.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z][a-z0-9]+);?/gi, (match, entity: string) => {
+    const normalized = entity.toLowerCase();
+
+    if (normalized.startsWith("#x")) {
+      const codePoint = Number.parseInt(normalized.slice(2), 16);
+      return decodeCodePoint(codePoint, match);
+    }
+
+    if (normalized.startsWith("#")) {
+      const codePoint = Number.parseInt(normalized.slice(1), 10);
+      return decodeCodePoint(codePoint, match);
+    }
+
+    return NAMED_ENTITIES[normalized] ?? match;
+  });
+}

package/src/utils/http-transport.ts

@@ -0,0 +1,11 @@
+export type HttpFetchTransport = (url: string, init?: RequestInit) => Promise<Response>;
+
+let httpFetchTransport: HttpFetchTransport | null = null;
+
+export function setHttpFetchTransport(transport: HttpFetchTransport | null): void {
+  httpFetchTransport = transport;
+}
+
+export function httpFetch(url: string, init?: RequestInit): Promise<Response> {
+  return (httpFetchTransport ?? globalThis.fetch)(url, init);
+}

package/src/utils/main-thread-monitor.ts

@@ -0,0 +1,127 @@
+import { debugLog } from "./debug-log";
+
+const SAMPLE_INTERVAL_MS = 50;
+const LAG_WARN_MS = 100;
+const LAG_ERROR_MS = 300;
+const LONG_TASK_WARN_MS = 50;
+
+const mainThreadLog = debugLog.createLogger("main-thread");
+
+function now(): number {
+  const perf = (globalThis as { performance?: { now?: () => number } }).performance;
+  return typeof perf?.now === "function" ? perf.now() : Date.now();
+}
+
+function summarizeLongTask(entry: unknown): Record<string, unknown> {
+  const value = entry as {
+    name?: string;
+    duration?: number;
+    startTime?: number;
+    attribution?: Array<Record<string, unknown>>;
+  };
+  return {
+    name: value.name,
+    durationMs: Math.round((value.duration ?? 0) * 10) / 10,
+    startTimeMs: Math.round((value.startTime ?? 0) * 10) / 10,
+    attribution: value.attribution?.map((item) => ({
+      name: item.name,
+      entryType: item.entryType,
+      containerType: item.containerType,
+      containerName: item.containerName,
+      containerId: item.containerId,
+      scriptUrl: item.scriptUrl,
+      lineNumber: item.lineNumber,
+      columnNumber: item.columnNumber,
+    })).slice(0, 3),
+  };
+}
+
+export function startMainThreadMonitor(
+  scope: string,
+  options: { mirrorToConsole?: boolean } = {},
+): () => void {
+  let stopped = false;
+  let lastTick = now();
+  let maxLagMs = 0;
+  let sampleCount = 0;
+
+  mainThreadLog.info("monitor started", {
+    scope,
+    sampleIntervalMs: SAMPLE_INTERVAL_MS,
+    lagWarnMs: LAG_WARN_MS,
+    lagErrorMs: LAG_ERROR_MS,
+  });
+
+  const intervalId = setInterval(() => {
+    const current = now();
+    const elapsedMs = current - lastTick;
+    lastTick = current;
+    sampleCount += 1;
+
+    const lagMs = elapsedMs - SAMPLE_INTERVAL_MS;
+    if (lagMs <= 0) return;
+    maxLagMs = Math.max(maxLagMs, lagMs);
+    if (lagMs < LAG_WARN_MS) return;
+
+    const payload = {
+      scope,
+      lagMs: Math.round(lagMs * 10) / 10,
+      elapsedMs: Math.round(elapsedMs * 10) / 10,
+      sampleIntervalMs: SAMPLE_INTERVAL_MS,
+      sampleCount,
+      maxLagMs: Math.round(maxLagMs * 10) / 10,
+    };
+    if (lagMs >= LAG_ERROR_MS) {
+      mainThreadLog.error("event loop blocked", payload);
+    } else {
+      mainThreadLog.warn("event loop delayed", payload);
+    }
+    if (options.mirrorToConsole) {
+      console.error(
+        `perf main-thread.stall scope=${scope} lag_ms=${payload.lagMs} elapsed_ms=${payload.elapsedMs} sample_interval_ms=${SAMPLE_INTERVAL_MS}`,
+      );
+    }
+  }, SAMPLE_INTERVAL_MS);
+
+  const ObserverCtor = (globalThis as { PerformanceObserver?: unknown }).PerformanceObserver;
+  let observer: { disconnect?: () => void } | null = null;
+  if (typeof ObserverCtor === "function") {
+    try {
+      observer = new (ObserverCtor as new (callback: (list: { getEntries: () => unknown[] }) => void) => {
+        observe: (options: { entryTypes: string[] }) => void;
+        disconnect: () => void;
+      })((list) => {
+        for (const entry of list.getEntries()) {
+          const durationMs = (entry as { duration?: number }).duration ?? 0;
+          if (durationMs < LONG_TASK_WARN_MS) continue;
+          const payload = { scope, ...summarizeLongTask(entry) };
+          if (durationMs >= LAG_ERROR_MS) {
+            mainThreadLog.error("browser long task", payload);
+          } else {
+            mainThreadLog.warn("browser long task", payload);
+          }
+          if (options.mirrorToConsole) {
+            console.error(
+              `perf main-thread.longtask scope=${scope} duration_ms=${Math.round(durationMs * 10) / 10}`,
+            );
+          }
+        }
+      });
+      observer.observe({ entryTypes: ["longtask"] });
+    } catch {
+      observer = null;
+    }
+  }
+
+  return () => {
+    if (stopped) return;
+    stopped = true;
+    clearInterval(intervalId);
+    observer?.disconnect?.();
+    mainThreadLog.info("monitor stopped", {
+      scope,
+      sampleCount,
+      maxLagMs: Math.round(maxLagMs * 10) / 10,
+    });
+  };
+}

package/src/utils/perf-marks.ts

@@ -0,0 +1,54 @@
+import { debugLog } from "./debug-log";
+
+const PERF_WARN_MS = 50;
+const PERF_ERROR_MS = 200;
+
+const perfLog = debugLog.createLogger("perf");
+
+function now(): number {
+  return typeof performance !== "undefined" && typeof performance.now === "function"
+    ? performance.now()
+    : Date.now();
+}
+
+function logSlowPerfSample(
+  name: string,
+  durationMs: number,
+  metadata?: Record<string, unknown>,
+): void {
+  const payload = {
+    durationMs: Math.round(durationMs * 10) / 10,
+    ...(metadata ?? {}),
+  };
+  if (durationMs >= PERF_ERROR_MS) {
+    perfLog.error(name, payload);
+  } else if (durationMs >= PERF_WARN_MS) {
+    perfLog.warn(name, payload);
+  }
+}
+
+export function measurePerf<T>(
+  name: string,
+  fn: () => T,
+  metadata?: Record<string, unknown>,
+): T {
+  const start = now();
+  try {
+    return fn();
+  } finally {
+    logSlowPerfSample(name, now() - start, metadata);
+  }
+}
+
+export async function measurePerfAsync<T>(
+  name: string,
+  fn: () => Promise<T>,
+  metadata?: Record<string, unknown>,
+): Promise<T> {
+  const start = now();
+  try {
+    return await fn();
+  } finally {
+    logSlowPerfSample(name, now() - start, metadata);
+  }
+}

package/src/utils/quote-freshness.ts

@@ -1,58 +1,41 @@
 import type { MarketState, Quote } from "../types/financials";
+import { canonicalExchange, EXCHANGE_TIME_ZONES } from "./exchanges";
 
 const US_EXTENDED_HOURS_EXCHANGES = new Set(["NASDAQ", "NYSE", "AMEX", "ARCA", "BATS"]);
-const EXCHANGE_TIME_ZONES: Record<string, string> = {
-  NASDAQ: "America/New_York",
-  NYSE: "America/New_York",
-  ARCA: "America/New_York",
-  AMEX: "America/New_York",
-  BATS: "America/New_York",
-  FWB: "Europe/Berlin",
-  FWB2: "Europe/Berlin",
-  XETRA: "Europe/Berlin",
-  SWX: "Europe/Zurich",
-  SFB: "Europe/Stockholm",
-  HKEX: "Asia/Hong_Kong",
-  JPX: "Asia/Tokyo",
-  TPEX: "Asia/Taipei",
-  NSE: "Asia/Kolkata",
-  BSE: "Asia/Kolkata",
-  LSE: "Europe/London",
-};
-const EXCHANGE_ALIASES: Record<string, string> = {
-  NMS: "NASDAQ",
-  NGM: "NASDAQ",
-  NCM: "NASDAQ",
-  NAS: "NASDAQ",
-  NYQ: "NYSE",
-  NYS: "NYSE",
-  PCX: "AMEX",
-  ASE: "AMEX",
-  HKG: "HKEX",
-  GER: "XETRA",
-};
+const exchangeLocalDateFormatters = new Map<string, Intl.DateTimeFormat>();
+const usSessionFormatter = new Intl.DateTimeFormat("en-US", {
+  timeZone: "America/New_York",
+  weekday: "short",
+  hour: "2-digit",
+  minute: "2-digit",
+  hourCycle: "h23",
+});
 
 type UsSessionState = Exclude<MarketState, never>;
 
-function normalizeExchange(exchange?: string): string {
-  const normalized = (exchange ?? "").trim().toUpperCase();
-  return EXCHANGE_ALIASES[normalized] ?? normalized;
+function isUsExtendedHoursExchange(exchange?: string): boolean {
+  return US_EXTENDED_HOURS_EXCHANGES.has(canonicalExchange(exchange));
 }
 
-function isUsExtendedHoursExchange(exchange?: string): boolean {
-  return US_EXTENDED_HOURS_EXCHANGES.has(normalizeExchange(exchange));
+function getExchangeLocalDateFormatter(timeZone: string): Intl.DateTimeFormat {
+  let formatter = exchangeLocalDateFormatters.get(timeZone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-CA", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+    });
+    exchangeLocalDateFormatters.set(timeZone, formatter);
+  }
+  return formatter;
 }
 
 function exchangeLocalDate(exchange: string, timestampMs: number): string | null {
-  const timeZone = EXCHANGE_TIME_ZONES[normalizeExchange(exchange)];
+  const timeZone = EXCHANGE_TIME_ZONES[canonicalExchange(exchange)];
   if (!timeZone) return null;
 
-  const parts = new Intl.DateTimeFormat("en-CA", {
-    timeZone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-  }).formatToParts(new Date(timestampMs));
+  const parts = getExchangeLocalDateFormatter(timeZone).formatToParts(new Date(timestampMs));
   const year = parts.find((part) => part.type === "year")?.value;
   const month = parts.find((part) => part.type === "month")?.value;
   const day = parts.find((part) => part.type === "day")?.value;
@@ -61,13 +44,7 @@ function exchangeLocalDate(exchange: string, timestampMs: number): string | null
 }
 
 function usSessionState(timestampMs: number): UsSessionState {
-  const parts = new Intl.DateTimeFormat("en-US", {
-    timeZone: "America/New_York",
-    weekday: "short",
-    hour: "2-digit",
-    minute: "2-digit",
-    hourCycle: "h23",
-  }).formatToParts(new Date(timestampMs));
+  const parts = usSessionFormatter.formatToParts(new Date(timestampMs));
 
   const weekday = parts.find((part) => part.type === "weekday")?.value ?? "";
   if (weekday === "Sat" || weekday === "Sun") return "CLOSED";
@@ -97,7 +74,7 @@ export function isQuoteStaleForCurrentSession(quote: Quote | null | undefined, n
   if (!quote) return false;
   if (isQuoteMissingActiveSessionPrice(quote)) return true;
 
-  const exchange = normalizeExchange(quote.listingExchangeName || quote.exchangeName);
+  const exchange = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
   if (!exchange || !Number.isFinite(quote.lastUpdated)) return false;
 
   const quoteDate = exchangeLocalDate(exchange, quote.lastUpdated);

package/src/utils/quote-resolution.test.ts

@@ -40,7 +40,7 @@ describe("quote-resolution", () => {
       yahoo: {
         symbol: "AMD",
         providerId: "yahoo",
-        dataSource: "yahoo",
+        dataSource: "delayed",
         price: 99.7,
         currency: "USD",
         change: 0.7,
@@ -88,7 +88,7 @@ describe("quote-resolution", () => {
       yahoo: {
         symbol: "ELF",
         providerId: "yahoo",
-        dataSource: "yahoo",
+        dataSource: "delayed",
         price: 87.5,
         currency: "USD",
         change: 0,
@@ -127,7 +127,7 @@ describe("quote-resolution", () => {
       yahoo: {
         symbol: "AMD",
         providerId: "yahoo",
-        dataSource: "yahoo",
+        dataSource: "delayed",
         price: 221.53,
         currency: "USD",
         change: 1.35,
@@ -195,7 +195,7 @@ describe("quote-resolution", () => {
       yahoo: {
         symbol: "HY9H",
         providerId: "yahoo",
-        dataSource: "yahoo",
+        dataSource: "delayed",
         price: 598,
         currency: "EUR",
         change: 6,
@@ -220,7 +220,7 @@ describe("quote-resolution", () => {
       yahoo: {
         symbol: "HY9H",
         providerId: "yahoo",
-        dataSource: "yahoo",
+        dataSource: "delayed",
         price: 598,
         currency: "EUR",
         change: 6,

package/src/utils/quote-resolution.ts

@@ -96,7 +96,6 @@ function sessionConfidenceRank(confidence?: SessionConfidence): number {
 
 function inferQuoteProviderId(quote: Quote | QuoteContribution): string {
   if (quote.providerId?.trim()) return quote.providerId;
-  if (quote.dataSource === "yahoo") return "yahoo";
   return "quote";
 }
 

package/src/utils/quote-time.ts

@@ -27,11 +27,7 @@ export function formatQuoteAgeWithSource(
   const age = formatQuoteAge(quote.lastUpdated, now);
   if (age === "—") return age;
 
-  const prefix = quote.dataSource === "delayed"
-    ? "◷"
-    : quote.dataSource === "yahoo"
-      ? "◌"
-      : "";
+  const prefix = quote.dataSource === "delayed" ? "◷" : "";
   return prefix ? `${prefix}${age}` : age;
 }
 

package/src/utils/sec.test.ts

@@ -20,10 +20,6 @@ function makeTicker(overrides: Partial<TickerRecord["metadata"]>): TickerRecord
 }
 
 describe("isUsEquityTicker", () => {
-  test("accepts plain US stocks", () => {
-    expect(isUsEquityTicker(makeTicker({ assetCategory: "STK" }))).toBe(true);
-  });
-
   test("accepts SMART-routed US stocks with a primary exchange", () => {
     expect(isUsEquityTicker(makeTicker({
       exchange: "SMART",
@@ -39,14 +35,6 @@ describe("isUsEquityTicker", () => {
     }))).toBe(true);
   });
 
-  test("rejects non-US listings", () => {
-    expect(isUsEquityTicker(makeTicker({
-      exchange: "HKEX",
-      currency: "HKD",
-      assetCategory: "STK",
-    }))).toBe(false);
-  });
-
   test("rejects non-equity instruments", () => {
     expect(isUsEquityTicker(makeTicker({
       assetCategory: "OPT",

package/src/utils/selection-clipboard.ts

@@ -1,7 +1,15 @@
-import type { CliRenderer, KeyEvent } from "@opentui/core";
+import { type NativeRendererHost as CliRenderer } from "../ui";
+import { type KeyEventLike as KeyEvent } from "../react/input";
+
+function isDarwinWithBunSpawnSync(): boolean {
+  return typeof process !== "undefined"
+    && process.platform === "darwin"
+    && typeof Bun !== "undefined"
+    && typeof Bun.spawnSync === "function";
+}
 
 function readTextFromSystemClipboard(): string | null {
-  if (process.platform !== "darwin") {
+  if (!isDarwinWithBunSpawnSync()) {
     return null;
   }
 
@@ -20,7 +28,7 @@ function readTextFromSystemClipboard(): string | null {
 }
 
 function copyTextToSystemClipboard(text: string): boolean {
-  if (text.length === 0 || process.platform !== "darwin") {
+  if (text.length === 0 || !isDarwinWithBunSpawnSync()) {
     return false;
   }
 
@@ -44,13 +52,13 @@ export function copySelectionText(
     return false;
   }
 
-  return renderer.copyToClipboardOSC52(text) || copyTextToSystemClipboard(text);
+  return renderer.copyToClipboardOSC52?.(text) === true || copyTextToSystemClipboard(text);
 }
 
 export function copyActiveSelection(
   renderer: Pick<CliRenderer, "getSelection" | "copyToClipboardOSC52">,
 ): boolean {
-  const text = renderer.getSelection()?.getSelectedText() ?? "";
+  const text = renderer.getSelection?.()?.getSelectedText() ?? "";
   return copySelectionText(renderer, text);
 }
 
@@ -80,7 +88,7 @@ export function pasteSystemClipboard(
   renderer: Pick<CliRenderer, "keyInput">,
 ): boolean {
   const text = readTextFromSystemClipboard();
-  if (!text) {
+  if (!text || !renderer.keyInput?.processPaste) {
     return false;
   }
   renderer.keyInput.processPaste(new TextEncoder().encode(text));

package/src/utils/shortcut-labels.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test";
+import { formatPlatformShortcutLabel, formatPrimaryShortcut, getShortcutDisplayMode } from "./shortcut-labels";
+
+describe("shortcut labels", () => {
+  test("renders command-or-control shortcuts for the active platform", () => {
+    expect(formatPlatformShortcutLabel("Cmd/Ctrl+Shift+D", "darwin")).toBe("Cmd+Shift+D");
+    expect(formatPlatformShortcutLabel("Cmd/Ctrl+Shift+D", "linux")).toBe("Ctrl+Shift+D");
+    expect(formatPlatformShortcutLabel("CmdOrCtrl+W", "win32")).toBe("Ctrl+W");
+    expect(formatPrimaryShortcut(["Shift", "G"], "darwin")).toBe("Cmd+Shift+G");
+    expect(formatPrimaryShortcut(",", "linux")).toBe("Ctrl+,");
+  });
+
+  test("renders terminal shortcuts with control even on macOS", () => {
+    const mode = getShortcutDisplayMode("opentui");
+
+    expect(formatPrimaryShortcut("W", "darwin", mode)).toBe("Ctrl+W");
+    expect(formatPlatformShortcutLabel("CmdOrCtrl+,", "darwin", mode)).toBe("Ctrl+,");
+    expect(getShortcutDisplayMode("desktop-web")).toBe("platform");
+  });
+});

package/src/utils/shortcut-labels.ts

@@ -0,0 +1,67 @@
+export type ShortcutPlatform = "darwin" | "win32" | "linux" | "unknown";
+export type ShortcutDisplayMode = "platform" | "terminal";
+
+function platformFromProcess(): ShortcutPlatform | null {
+  const platform = (globalThis as { process?: { platform?: string } }).process?.platform;
+  if (platform === "darwin" || platform === "win32" || platform === "linux") return platform;
+  return null;
+}
+
+function platformFromNavigator(): ShortcutPlatform | null {
+  const navigatorLike = (globalThis as {
+    navigator?: {
+      platform?: string;
+      userAgent?: string;
+      userAgentData?: { platform?: string };
+    };
+  }).navigator;
+  const raw = [
+    navigatorLike?.userAgentData?.platform,
+    navigatorLike?.platform,
+    navigatorLike?.userAgent,
+  ].filter(Boolean).join(" ").toLowerCase();
+
+  if (!raw) return null;
+  if (/(mac|iphone|ipad|ipod)/.test(raw)) return "darwin";
+  if (/win/.test(raw)) return "win32";
+  if (/(linux|x11)/.test(raw)) return "linux";
+  return null;
+}
+
+export function detectShortcutPlatform(): ShortcutPlatform {
+  return platformFromProcess() ?? platformFromNavigator() ?? "unknown";
+}
+
+export function isMacShortcutPlatform(platform: ShortcutPlatform = detectShortcutPlatform()): boolean {
+  return platform === "darwin";
+}
+
+export function getShortcutDisplayMode(uiKind: "opentui" | "desktop-web" | undefined): ShortcutDisplayMode {
+  return uiKind === "opentui" ? "terminal" : "platform";
+}
+
+export function getPrimaryShortcutModifier(
+  platform: ShortcutPlatform = detectShortcutPlatform(),
+  mode: ShortcutDisplayMode = "platform",
+): "Cmd" | "Ctrl" {
+  if (mode === "terminal") return "Ctrl";
+  return isMacShortcutPlatform(platform) ? "Cmd" : "Ctrl";
+}
+
+export function formatPrimaryShortcut(
+  keys: string | readonly string[],
+  platform: ShortcutPlatform = detectShortcutPlatform(),
+  mode: ShortcutDisplayMode = "platform",
+): string {
+  const keyParts = typeof keys === "string" ? [keys] : keys;
+  return [getPrimaryShortcutModifier(platform, mode), ...keyParts].join("+");
+}
+
+export function formatPlatformShortcutLabel(
+  label: string,
+  platform: ShortcutPlatform = detectShortcutPlatform(),
+  mode: ShortcutDisplayMode = "platform",
+): string {
+  const primaryModifier = getPrimaryShortcutModifier(platform, mode);
+  return label.replace(/Cmd\/Ctrl|CmdOrCtrl/g, primaryModifier);
+}

package/src/utils/slugify.ts

@@ -1,3 +1,4 @@
+
 export function slugifyName(name: string, fallbackPrefix: string): string {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || `${fallbackPrefix}-${Date.now()}`;
 }

package/src/utils/terminal-input-reset.ts

@@ -1,3 +1,4 @@
+
 export const TERMINAL_MOUSE_RESET_SEQUENCE = "\x1B[?1016l\x1B[?1006l\x1B[?1005l\x1B[?1015l\x1B[?1003l\x1B[?1002l\x1B[?1000l";
 
 interface TerminalResetStdin {

package/src/utils/text-wrap.ts

@@ -0,0 +1,82 @@
+export function truncateWithEllipsis(text: string, width: number): string {
+  if (width <= 0) return "";
+  if (text.length <= width) return text;
+  if (width <= 3) return text.slice(0, width);
+  return `${text.slice(0, width - 3)}...`;
+}
+
+export function wrapTextLines(
+  text: string,
+  width: number,
+  maxLines = Number.MAX_SAFE_INTEGER,
+): string[] {
+  if (width <= 0) return [];
+
+  const paragraphs = text
+    .split(/\r?\n/)
+    .map((paragraph) => paragraph.replace(/\s+/g, " ").trim());
+  const lines: string[] = [];
+
+  const pushLine = (line: string) => {
+    if (lines.length >= maxLines) return;
+    lines.push(line);
+  };
+
+  for (
+    let paragraphIndex = 0;
+    paragraphIndex < paragraphs.length;
+    paragraphIndex += 1
+  ) {
+    const paragraph = paragraphs[paragraphIndex]!;
+    if (!paragraph) {
+      pushLine("");
+      continue;
+    }
+
+    let current = "";
+    for (const rawWord of paragraph.split(" ")) {
+      let word = rawWord;
+      while (word.length > width) {
+        const available = current ? width - current.length - 1 : width;
+        if (available <= 0) {
+          pushLine(current);
+          current = "";
+          continue;
+        }
+        if (word.length <= available) break;
+        const piece = word.slice(0, available);
+        word = word.slice(available);
+        pushLine(current ? `${current} ${piece}` : piece);
+        current = "";
+      }
+
+      if (!current) {
+        current = word;
+        continue;
+      }
+
+      if (current.length + 1 + word.length <= width) {
+        current = `${current} ${word}`;
+      } else {
+        pushLine(current);
+        current = word;
+      }
+    }
+
+    if (current) pushLine(current);
+    if (paragraphIndex < paragraphs.length - 1) pushLine("");
+    if (lines.length >= maxLines) break;
+  }
+
+  if (
+    lines.length === maxLines &&
+    paragraphs.join(" ").length > lines.join(" ").length
+  ) {
+    lines[maxLines - 1] = truncateWithEllipsis(
+      lines[maxLines - 1] ?? "",
+      width,
+    );
+  }
+
+  return lines;
+}