@visulima/tui 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/measure-text-DItZYotK.js

@@ -0,0 +1,1189 @@
+import { isFullwidthCodePoint, getStringWidth } from '@visulima/string';
+import { t as tokenizeAnsi } from './ansi-tokenizer-LHq2LUWA.js';
+
+class DataLimitedLruMap {
+  map;
+  maxDataSize;
+  maxKeys;
+  currentDataSize = 0;
+  constructor(maxKeys, maxDataSize) {
+    this.map = /* @__PURE__ */ new Map();
+    this.maxKeys = maxKeys;
+    this.maxDataSize = maxDataSize;
+  }
+  get size() {
+    return this.map.size;
+  }
+  clear() {
+    this.map.clear();
+    this.currentDataSize = 0;
+  }
+  get(key) {
+    if (!this.map.has(key)) {
+      return void 0;
+    }
+    const value = this.map.get(key);
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    const size = key.length;
+    if (size > this.maxDataSize) {
+      return;
+    }
+    const hasKey = this.map.has(key);
+    if (hasKey) {
+      this.map.delete(key);
+      this.currentDataSize -= size;
+    }
+    while (this.currentDataSize + size > this.maxDataSize && this.map.size > 0) {
+      const lruKey = this.map.keys().next().value;
+      if (lruKey === void 0) {
+        break;
+      }
+      this.map.delete(lruKey);
+      this.currentDataSize -= lruKey.length;
+    }
+    while (this.map.size >= this.maxKeys) {
+      const lruKey = this.map.keys().next().value;
+      if (lruKey === void 0) {
+        break;
+      }
+      this.map.delete(lruKey);
+      this.currentDataSize -= lruKey.length;
+    }
+    this.map.set(key, value);
+    this.currentDataSize += size;
+  }
+}
+
+const BOLD_MASK = 1;
+const DIM_MASK = 1 << 1;
+const ITALIC_MASK = 1 << 2;
+const UNDERLINE_MASK = 1 << 3;
+const STRIKETHROUGH_MASK = 1 << 4;
+const INVERSE_MASK = 1 << 5;
+const HIDDEN_MASK = 1 << 6;
+const FULL_WIDTH_MASK = 1 << 7;
+
+const OFFSET_MASK = 1073741823;
+const FULL_WIDTH_FLAG = 1073741824;
+class StyledLine {
+  length = 0;
+  static emptyCache = /* @__PURE__ */ new Map();
+  text;
+  charData;
+  spans;
+  _cachedTrimmedLength;
+  static empty(length) {
+    if (length <= 0) {
+      return new StyledLine();
+    }
+    const cached = StyledLine.emptyCache.get(length);
+    if (cached) {
+      return cached.clone();
+    }
+    const line = new StyledLine();
+    line.length = length;
+    line.text = " ".repeat(length);
+    line.charData = Array.from({ length });
+    for (let i = 0; i < length; i++) {
+      line.charData[i] = i;
+    }
+    line.spans = [{ formatFlags: 0, length }];
+    line._cachedTrimmedLength = 0;
+    Object.freeze(line.spans[0]);
+    Object.freeze(line.spans);
+    Object.freeze(line);
+    StyledLine.emptyCache.set(length, line);
+    return line.clone();
+  }
+  getValue(index) {
+    if (this.text === void 0 || index < 0 || index >= this.length) {
+      return "";
+    }
+    const start = this.charData[index] & OFFSET_MASK;
+    const end = index + 1 < this.length ? this.charData[index + 1] & OFFSET_MASK : this.text.length;
+    return this.text.slice(start, end);
+  }
+  /**
+   * Get the raw text for a range of characters as a single string slice.
+   * Much faster than calling getValue() per character.
+   */
+  getTextRange(start, end) {
+    if (this.text === void 0 || start < 0 || end > this.length || start >= end) {
+      return "";
+    }
+    const textStart = this.charData[start] & OFFSET_MASK;
+    const textEnd = end < this.length ? this.charData[end] & OFFSET_MASK : this.text.length;
+    return this.text.slice(textStart, textEnd);
+  }
+  getSpan(index) {
+    if (this.spans === void 0 || index < 0 || index >= this.length) {
+      return void 0;
+    }
+    let current = 0;
+    for (const span of this.spans) {
+      if (index < current + span.length) {
+        return span;
+      }
+      current += span.length;
+    }
+    return void 0;
+  }
+  getFullWidth(index) {
+    if (this.charData === void 0 || index < 0 || index >= this.length) {
+      return false;
+    }
+    return (this.charData[index] & FULL_WIDTH_FLAG) !== 0;
+  }
+  hasStyles(index) {
+    const span = this.getSpan(index);
+    if (!span) {
+      return false;
+    }
+    return (span.formatFlags & ~FULL_WIDTH_MASK) !== 0 || span.fgColor !== void 0 || span.bgColor !== void 0 || span.link !== void 0;
+  }
+  getFormatFlags(index) {
+    let flags = this.getSpan(index)?.formatFlags ?? 0;
+    if (this.getFullWidth(index)) {
+      flags |= FULL_WIDTH_MASK;
+    }
+    return flags;
+  }
+  getFgColor(index) {
+    return this.getSpan(index)?.fgColor;
+  }
+  getBgColor(index) {
+    return this.getSpan(index)?.bgColor;
+  }
+  getLink(index) {
+    return this.getSpan(index)?.link;
+  }
+  setInverted(index, inverted) {
+    this._cachedTrimmedLength = void 0;
+    this.updateSpanAt(index, (span) => {
+      if (inverted) {
+        span.formatFlags |= INVERSE_MASK;
+      } else {
+        span.formatFlags &= ~INVERSE_MASK;
+      }
+    });
+  }
+  setBackgroundColor(index, color) {
+    this._cachedTrimmedLength = void 0;
+    this.updateSpanAt(index, (span) => {
+      span.bgColor = color;
+    });
+  }
+  setForegroundColor(index, color) {
+    this._cachedTrimmedLength = void 0;
+    this.updateSpanAt(index, (span) => {
+      span.fgColor = color;
+    });
+  }
+  setChar(index, value, formatFlags, fgColor, bgColor, link) {
+    if (index < 0 || index >= this.length) {
+      return;
+    }
+    this._cachedTrimmedLength = void 0;
+    this.ensureInitialized();
+    const isFullWidth = (formatFlags & FULL_WIDTH_MASK) !== 0;
+    const cleanFormatFlags = formatFlags & ~FULL_WIDTH_MASK;
+    const start = this.charData[index] & OFFSET_MASK;
+    const end = index + 1 < this.length ? this.charData[index + 1] & OFFSET_MASK : this.text.length;
+    const oldLength = end - start;
+    const newLength = value.length;
+    this.text = this.text.slice(0, start) + value + this.text.slice(end);
+    if (oldLength !== newLength) {
+      const diff = newLength - oldLength;
+      for (let i = index + 1; i < this.length; i++) {
+        const data = this.charData[i];
+        const oldOffset = data & OFFSET_MASK;
+        const fw = data & FULL_WIDTH_FLAG;
+        this.charData[i] = oldOffset + diff | fw;
+      }
+    }
+    this.charData[index] = start | (isFullWidth ? FULL_WIDTH_FLAG : 0);
+    this.splitSpansAt(index);
+    this.splitSpansAt(index + 1);
+    let current = 0;
+    for (let i = 0; i < this.spans.length; i++) {
+      const span = this.spans[i];
+      if (current === index && span.length === 1) {
+        this.spans[i] = {
+          bgColor,
+          fgColor,
+          formatFlags: cleanFormatFlags,
+          length: 1,
+          link
+        };
+        break;
+      }
+      current += span.length;
+    }
+    this.mergeSpans();
+  }
+  /**
+   * Optimized setChar for same-length single-byte replacement.
+   * Skips string rebuild and offset adjustment when old and new values
+   * have the same byte length (the common case for ASCII overwrites on empty lines).
+   */
+  setCharFast(index, value, formatFlags, fgColor, bgColor, link) {
+    if (index < 0 || index >= this.length) {
+      return;
+    }
+    this._cachedTrimmedLength = void 0;
+    this.ensureInitialized();
+    const isFullWidth = (formatFlags & FULL_WIDTH_MASK) !== 0;
+    const cleanFormatFlags = formatFlags & ~FULL_WIDTH_MASK;
+    const start = this.charData[index] & OFFSET_MASK;
+    const end = index + 1 < this.length ? this.charData[index + 1] & OFFSET_MASK : this.text.length;
+    const oldLength = end - start;
+    if (value.length === oldLength) {
+      if (value !== this.text.slice(start, end)) {
+        this.text = this.text.slice(0, start) + value + this.text.slice(end);
+      }
+      this.charData[index] = start | (isFullWidth ? FULL_WIDTH_FLAG : 0);
+    } else {
+      this.text = this.text.slice(0, start) + value + this.text.slice(end);
+      if (oldLength !== value.length) {
+        const diff = value.length - oldLength;
+        for (let i = index + 1; i < this.length; i++) {
+          const data = this.charData[i];
+          this.charData[i] = (data & OFFSET_MASK) + diff | data & FULL_WIDTH_FLAG;
+        }
+      }
+      this.charData[index] = start | (isFullWidth ? FULL_WIDTH_FLAG : 0);
+    }
+    const existingSpan = this.getSpan(index);
+    if (existingSpan?.formatFlags === cleanFormatFlags && existingSpan.fgColor === fgColor && existingSpan.bgColor === bgColor && existingSpan.link === link) {
+      return;
+    }
+    this.splitSpansAt(index);
+    this.splitSpansAt(index + 1);
+    let current = 0;
+    for (let i = 0; i < this.spans.length; i++) {
+      const span = this.spans[i];
+      if (current === index && span.length === 1) {
+        this.spans[i] = {
+          bgColor,
+          fgColor,
+          formatFlags: cleanFormatFlags,
+          length: 1,
+          link
+        };
+        break;
+      }
+      current += span.length;
+    }
+    this.mergeSpans();
+  }
+  /**
+   * Overwrite a range of this line with content from a source StyledLine.
+   * More efficient than calling setChar() per character because it does
+   * a single span split + rebuild instead of per-character span manipulation.
+   * @param destinationStart — start index in this line
+   * @param source — the StyledLine to copy from
+   * @param srcStart — start index in source (default 0)
+   * @param count — number of characters to copy (default: source.length)
+   */
+  writeFrom(destinationStart, source, srcStart = 0, count) {
+    const n = count ?? source.length - srcStart;
+    if (n <= 0 || destinationStart >= this.length) {
+      return;
+    }
+    this._cachedTrimmedLength = void 0;
+    this.ensureInitialized();
+    const actualCount = Math.min(n, this.length - destinationStart, source.length - srcStart);
+    const destinationTextStart = this.charData[destinationStart] & OFFSET_MASK;
+    const destinationTextEnd = destinationStart + actualCount < this.length ? this.charData[destinationStart + actualCount] & OFFSET_MASK : this.text.length;
+    let newSegment = "";
+    for (let i = 0; i < actualCount; i++) {
+      newSegment += source.getValue(srcStart + i);
+    }
+    const oldSegLength = destinationTextEnd - destinationTextStart;
+    const diff = newSegment.length - oldSegLength;
+    this.text = this.text.slice(0, destinationTextStart) + newSegment + this.text.slice(destinationTextEnd);
+    let offset = destinationTextStart;
+    for (let i = 0; i < actualCount; i++) {
+      const srcFullWidth = source.getFullWidth(srcStart + i);
+      this.charData[destinationStart + i] = offset | (srcFullWidth ? FULL_WIDTH_FLAG : 0);
+      offset += source.getValue(srcStart + i).length;
+    }
+    if (diff !== 0) {
+      for (let i = destinationStart + actualCount; i < this.length; i++) {
+        const data = this.charData[i];
+        this.charData[i] = (data & OFFSET_MASK) + diff | data & FULL_WIDTH_FLAG;
+      }
+    }
+    this.splitSpansAt(destinationStart);
+    this.splitSpansAt(destinationStart + actualCount);
+    const newSpans = [];
+    let srcSpanStart = 0;
+    for (const span of source.getSpans()) {
+      const spanEnd = srcSpanStart + span.length;
+      const overlapStart = Math.max(srcStart, srcSpanStart);
+      const overlapEnd = Math.min(srcStart + actualCount, spanEnd);
+      if (overlapStart < overlapEnd) {
+        newSpans.push({ ...span, length: overlapEnd - overlapStart });
+      }
+      srcSpanStart = spanEnd;
+      if (srcSpanStart >= srcStart + actualCount) {
+        break;
+      }
+    }
+    let destinationSpanIndex = 0;
+    let destinationSpanOffset = 0;
+    for (let i = 0; i < this.spans.length; i++) {
+      if (destinationSpanOffset === destinationStart) {
+        destinationSpanIndex = i;
+        break;
+      }
+      destinationSpanOffset += this.spans[i].length;
+    }
+    let removeCount = 0;
+    let covered = 0;
+    for (let i = destinationSpanIndex; i < this.spans.length && covered < actualCount; i++) {
+      covered += this.spans[i].length;
+      removeCount++;
+    }
+    this.spans.splice(destinationSpanIndex, removeCount, ...newSpans);
+    this.mergeSpans();
+  }
+  pushChar(value, formatFlags, fgColor, bgColor, link) {
+    this._cachedTrimmedLength = void 0;
+    this.ensureInitialized();
+    const isFullWidth = (formatFlags & FULL_WIDTH_MASK) !== 0;
+    const cleanFormatFlags = formatFlags & ~FULL_WIDTH_MASK;
+    const offset = this.text.length;
+    this.text = (this.text ?? "") + value;
+    this.charData.push(offset | (isFullWidth ? FULL_WIDTH_FLAG : 0));
+    const lastSpan = this.spans.at(-1);
+    if (lastSpan?.formatFlags === cleanFormatFlags && lastSpan.fgColor === fgColor && lastSpan.bgColor === bgColor && lastSpan.link === link) {
+      lastSpan.length++;
+    } else {
+      this.spans.push({
+        bgColor,
+        fgColor,
+        formatFlags: cleanFormatFlags,
+        length: 1,
+        link
+      });
+    }
+    this.length++;
+  }
+  clone() {
+    if (this.charData === void 0) {
+      return new StyledLine();
+    }
+    const result = new StyledLine();
+    result.length = this.length;
+    result.text = this.text;
+    result.charData = [...this.charData];
+    result.spans = this.spans.map((span) => {
+      return {
+        ...span
+      };
+    });
+    result._cachedTrimmedLength = this._cachedTrimmedLength;
+    return result;
+  }
+  slice(start, end) {
+    if (this.charData === void 0) {
+      return new StyledLine();
+    }
+    const actualStart = Math.max(0, start);
+    const actualEnd = end === void 0 ? this.length : Math.min(this.length, end);
+    if (actualStart >= actualEnd) {
+      return new StyledLine();
+    }
+    if (actualStart === 0 && actualEnd === this.length) {
+      return this.clone();
+    }
+    const result = new StyledLine();
+    result.length = actualEnd - actualStart;
+    result.charData = Array.from({ length: result.length });
+    const textStart = this.charData[actualStart] & OFFSET_MASK;
+    const textEnd = actualEnd < this.length ? this.charData[actualEnd] & OFFSET_MASK : this.text.length;
+    result.text = this.text.slice(textStart, textEnd);
+    for (let i = 0; i < result.length; i++) {
+      const oldData = this.charData[actualStart + i];
+      const oldOffset = oldData & OFFSET_MASK;
+      const fw = oldData & FULL_WIDTH_FLAG;
+      result.charData[i] = oldOffset - textStart | fw;
+    }
+    const newSpans = [];
+    let current = 0;
+    for (const span of this.spans) {
+      const spanStart = current;
+      const spanEnd = current + span.length;
+      const intersectStart = Math.max(actualStart, spanStart);
+      const intersectEnd = Math.min(actualEnd, spanEnd);
+      if (intersectStart < intersectEnd) {
+        newSpans.push({
+          ...span,
+          length: intersectEnd - intersectStart
+        });
+      }
+      current += span.length;
+      if (current >= actualEnd) {
+        break;
+      }
+    }
+    result.spans = newSpans;
+    result.mergeSpans();
+    return result;
+  }
+  combine(...others) {
+    if (others.length === 0) {
+      return this.clone();
+    }
+    const allLines = [this, ...others].filter((l) => l.length > 0);
+    if (allLines.length === 0) {
+      return new StyledLine();
+    }
+    if (allLines.length === 1) {
+      return allLines[0].clone();
+    }
+    let totalChars = 0;
+    for (const line of allLines) {
+      totalChars += line.length;
+    }
+    const result = new StyledLine();
+    result.length = totalChars;
+    result.text = allLines.map((l) => l.getText()).join("");
+    result.charData = Array.from({ length: totalChars });
+    let currentChar = 0;
+    let currentOffset = 0;
+    for (const line of allLines) {
+      const lineCharData = line.charData;
+      const lineText = line.getText();
+      if (lineCharData) {
+        for (let i = 0; i < line.length; i++) {
+          const data = lineCharData[i];
+          const lineOffset = data & OFFSET_MASK;
+          const fw = data & FULL_WIDTH_FLAG;
+          result.charData[currentChar + i] = currentOffset + lineOffset | fw;
+        }
+      } else {
+        for (let i = 0; i < line.length; i++) {
+          result.charData[currentChar + i] = currentOffset + i;
+        }
+      }
+      currentChar += line.length;
+      currentOffset += lineText.length;
+    }
+    result.spans = allLines.flatMap((l) => l.getSpans().map((s) => {
+      return {
+        ...s
+      };
+    }));
+    result.mergeSpans();
+    return result;
+  }
+  getTrimmedLength() {
+    if (this._cachedTrimmedLength !== void 0) {
+      return this._cachedTrimmedLength;
+    }
+    if (this.length === 0) {
+      this._cachedTrimmedLength = 0;
+      return 0;
+    }
+    if (this.text === void 0 || this.charData === void 0) {
+      this._cachedTrimmedLength = 0;
+      return 0;
+    }
+    let currentIndex = this.length - 1;
+    if (this.spans) {
+      for (let s = this.spans.length - 1; s >= 0; s--) {
+        const span = this.spans[s];
+        const hasStylesOnSpan = (span.formatFlags & ~FULL_WIDTH_MASK) !== 0 || span.fgColor !== void 0 || span.bgColor !== void 0 || span.link !== void 0;
+        if (hasStylesOnSpan) {
+          this._cachedTrimmedLength = currentIndex + 1;
+          return this._cachedTrimmedLength;
+        }
+        for (let i = 0; i < span.length; i++) {
+          const charStart = this.charData[currentIndex] & OFFSET_MASK;
+          const charEnd = currentIndex + 1 < this.length ? this.charData[currentIndex + 1] & OFFSET_MASK : this.text.length;
+          if (charEnd - charStart !== 1 || this.text[charStart] !== " ") {
+            this._cachedTrimmedLength = currentIndex + 1;
+            return this._cachedTrimmedLength;
+          }
+          currentIndex--;
+        }
+      }
+    }
+    this._cachedTrimmedLength = 0;
+    return 0;
+  }
+  trimEnd() {
+    const trimmedLength = this.getTrimmedLength();
+    if (trimmedLength === this.length) {
+      return this;
+    }
+    if (trimmedLength === 0) {
+      return new StyledLine();
+    }
+    return this.slice(0, trimmedLength);
+  }
+  equals(other) {
+    if (this.length !== other.length) {
+      return false;
+    }
+    if (this.length === 0) {
+      return true;
+    }
+    if (this.getText() !== other.getText()) {
+      return false;
+    }
+    const s1 = this.getSpans();
+    const s2 = other.getSpans();
+    if (s1.length !== s2.length) {
+      return false;
+    }
+    for (const [i, element] of s1.entries()) {
+      const sp1 = element;
+      const sp2 = s2[i];
+      if (sp1.length !== sp2.length || sp1.formatFlags !== sp2.formatFlags || sp1.fgColor !== sp2.fgColor || sp1.bgColor !== sp2.bgColor || sp1.link !== sp2.link) {
+        return false;
+      }
+    }
+    const thisCharData = this.charData;
+    const otherCharData = other.charData;
+    if (thisCharData && otherCharData) {
+      for (let i = 0; i < this.length; i++) {
+        if (thisCharData[i] !== otherCharData[i]) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  getText() {
+    return this.text ?? "";
+  }
+  getSpans() {
+    return this.spans ?? [];
+  }
+  getValues() {
+    return Array.from({ length: this.length }, (_, i) => this.getValue(i));
+  }
+  *[Symbol.iterator]() {
+    if (this.length === 0) {
+      return;
+    }
+    let currentSpanIndex = 0;
+    let currentSpanPos = 0;
+    const spans = this.getSpans();
+    for (let i = 0; i < this.length; i++) {
+      const span = spans[currentSpanIndex];
+      const flags = span ? span.formatFlags : 0;
+      const isFullWidth = this.getFullWidth(i);
+      yield {
+        bgColor: span?.bgColor,
+        fgColor: span?.fgColor,
+        formatFlags: flags | (isFullWidth ? FULL_WIDTH_MASK : 0),
+        fullWidth: isFullWidth,
+        hasStyles: (flags & ~FULL_WIDTH_MASK) !== 0 || span?.fgColor !== void 0 || span?.bgColor !== void 0 || span?.link !== void 0,
+        link: span?.link,
+        value: this.getValue(i)
+      };
+      if (span) {
+        currentSpanPos++;
+        if (currentSpanPos >= span.length) {
+          currentSpanIndex++;
+          currentSpanPos = 0;
+        }
+      }
+    }
+  }
+  /**
+   * Split the span at `index` into a single-char span, apply the updater,
+   * then merge adjacent spans. Shared by setInverted/setBackgroundColor/setForegroundColor.
+   */
+  updateSpanAt(index, updater) {
+    if (index < 0 || index >= this.length) {
+      return;
+    }
+    this.ensureInitialized();
+    this.splitSpansAt(index);
+    this.splitSpansAt(index + 1);
+    let current = 0;
+    for (const span of this.spans) {
+      if (current === index && span.length === 1) {
+        updater(span);
+        break;
+      }
+      current += span.length;
+    }
+    this.mergeSpans();
+  }
+  /**
+   * Grow the line to at least `minWidth` columns, filling new cells with
+   * empty strings (zero-width placeholders). This matches the behavior of
+   * sparse JS arrays in the original ink Output where out-of-bounds writes
+   * created gaps that produced no visible output.
+   */
+  ensureWidth(minWidth) {
+    if (minWidth <= this.length) {
+      return;
+    }
+    this.ensureInitialized();
+    const oldLength = this.length;
+    const extraCount = minWidth - oldLength;
+    const oldTextLength = this.text.length;
+    for (let i = 0; i < extraCount; i++) {
+      this.charData.push(oldTextLength);
+    }
+    this.length = minWidth;
+    const lastSpan = this.spans.at(-1);
+    if (lastSpan?.formatFlags === 0 && lastSpan.fgColor === void 0 && lastSpan.bgColor === void 0 && lastSpan.link === void 0) {
+      lastSpan.length += extraCount;
+    } else {
+      this.spans.push({ formatFlags: 0, length: extraCount });
+    }
+  }
+  ensureInitialized() {
+    if (this.charData === void 0) {
+      this.text = "";
+      this.charData = Array.from({ length: this.length });
+      this.spans = this.length > 0 ? [{ formatFlags: 0, length: this.length }] : [];
+      if (this.length > 0 && this.text.length === 0) {
+        this.text = " ".repeat(this.length);
+        for (let i = 0; i < this.length; i++) {
+          this.charData[i] = i;
+        }
+      }
+    }
+  }
+  splitSpansAt(index) {
+    if (this.spans === void 0 || index <= 0 || index >= this.length) {
+      return;
+    }
+    let current = 0;
+    for (let i = 0; i < this.spans.length; i++) {
+      const span = this.spans[i];
+      if (index > current && index < current + span.length) {
+        const leftLength = index - current;
+        const rightLength = span.length - leftLength;
+        this.spans.splice(i, 1, { ...span, length: leftLength }, { ...span, length: rightLength });
+        return;
+      }
+      current += span.length;
+    }
+  }
+  mergeSpans() {
+    if (this.spans === void 0) {
+      return;
+    }
+    const newSpans = [];
+    for (const span of this.spans) {
+      if (span.length === 0) {
+        continue;
+      }
+      const last = newSpans.at(-1);
+      if (last?.formatFlags === span.formatFlags && last.fgColor === span.fgColor && last.bgColor === span.bgColor && last.link === span.link) {
+        last.length += span.length;
+      } else {
+        newSpans.push({ ...span });
+      }
+    }
+    this.spans = newSpans;
+  }
+}
+
+const NAMED_COLORS = {
+  black: 0,
+  blue: 4,
+  cyan: 6,
+  gray: 8,
+  green: 2,
+  grey: 8,
+  magenta: 5,
+  red: 1,
+  white: 7,
+  yellow: 3
+};
+const BRIGHT_COLORS = {
+  blackBright: 8,
+  blueBright: 12,
+  cyanBright: 14,
+  greenBright: 10,
+  magentaBright: 13,
+  redBright: 9,
+  whiteBright: 15,
+  yellowBright: 11
+};
+const ansi256Regex = /^ansi256\(\s?(\d+)\s?\)$/;
+const rgbRegex = /^rgb\(\s?(\d+),\s?(\d+),\s?(\d+)\s?\)$/;
+const colorToAnsi256 = (color) => {
+  const named = NAMED_COLORS[color];
+  if (named !== void 0) {
+    return named;
+  }
+  const bright = BRIGHT_COLORS[color];
+  if (bright !== void 0) {
+    return bright;
+  }
+  const ansi256Match = ansi256Regex.exec(color);
+  if (ansi256Match) {
+    return Number(ansi256Match[1]) & 255;
+  }
+  if (color.startsWith("#") && color.length === 7) {
+    const r = Number.parseInt(color.slice(1, 3), 16);
+    const g = Number.parseInt(color.slice(3, 5), 16);
+    const b = Number.parseInt(color.slice(5, 7), 16);
+    return 16 + 36 * Math.round(r / 51) + 6 * Math.round(g / 51) + Math.round(b / 51);
+  }
+  const rgbMatch = rgbRegex.exec(color);
+  if (rgbMatch) {
+    return 16 + 36 * Math.round(Number(rgbMatch[1]) / 51) + 6 * Math.round(Number(rgbMatch[2]) / 51) + Math.round(Number(rgbMatch[3]) / 51);
+  }
+  return 255;
+};
+const colorToSgrParams = (color, isFg) => {
+  const base = isFg ? 30 : 40;
+  const named = NAMED_COLORS[color];
+  if (named !== void 0) {
+    return [base + named];
+  }
+  const bright = BRIGHT_COLORS[color];
+  if (bright !== void 0) {
+    return [base + 60 + (bright - 8)];
+  }
+  if (color.startsWith("#") && color.length === 7) {
+    const r = Number.parseInt(color.slice(1, 3), 16);
+    const g = Number.parseInt(color.slice(3, 5), 16);
+    const b = Number.parseInt(color.slice(5, 7), 16);
+    return [isFg ? 38 : 48, 2, r, g, b];
+  }
+  const ansi256Match = ansi256Regex.exec(color);
+  if (ansi256Match) {
+    return [isFg ? 38 : 48, 5, Number(ansi256Match[1])];
+  }
+  const rgbMatch = rgbRegex.exec(color);
+  if (rgbMatch) {
+    return [isFg ? 38 : 48, 2, Number(rgbMatch[1]), Number(rgbMatch[2]), Number(rgbMatch[3])];
+  }
+  return [];
+};
+const ansi256ToColorName = (index) => {
+  const standardNames = ["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"];
+  if (index >= 0 && index <= 7) {
+    return standardNames[index];
+  }
+  return `ansi256(${index})`;
+};
+
+const createSgrState = () => {
+  return {
+    bgColor: void 0,
+    fgColor: void 0,
+    formatFlags: 0,
+    link: void 0
+  };
+};
+const applySgrParams = (state, parameterString) => {
+  if (parameterString.length === 0) {
+    return createSgrState();
+  }
+  const normalizedParams = parameterString.includes(":") ? parameterString.replaceAll(":", ";") : parameterString;
+  const params = normalizedParams.split(";").filter((s) => s.length > 0).map(Number);
+  let { bgColor, fgColor, formatFlags, link } = state;
+  let index = 0;
+  while (index < params.length) {
+    const code = params[index];
+    switch (code) {
+      case 0: {
+        formatFlags = 0;
+        fgColor = void 0;
+        bgColor = void 0;
+        link = void 0;
+        break;
+      }
+      case 1: {
+        formatFlags |= BOLD_MASK;
+        break;
+      }
+      case 2: {
+        formatFlags |= DIM_MASK;
+        break;
+      }
+      case 3: {
+        formatFlags |= ITALIC_MASK;
+        break;
+      }
+      case 4: {
+        formatFlags |= UNDERLINE_MASK;
+        break;
+      }
+      case 7: {
+        formatFlags |= INVERSE_MASK;
+        break;
+      }
+      case 8: {
+        formatFlags |= HIDDEN_MASK;
+        break;
+      }
+      case 9: {
+        formatFlags |= STRIKETHROUGH_MASK;
+        break;
+      }
+      // Reset individual attributes
+      case 22: {
+        formatFlags &= -4;
+        break;
+      }
+      case 23: {
+        formatFlags &= ~ITALIC_MASK;
+        break;
+      }
+      case 24: {
+        formatFlags &= ~UNDERLINE_MASK;
+        break;
+      }
+      case 27: {
+        formatFlags &= ~INVERSE_MASK;
+        break;
+      }
+      case 28: {
+        formatFlags &= ~HIDDEN_MASK;
+        break;
+      }
+      case 29: {
+        formatFlags &= ~STRIKETHROUGH_MASK;
+        break;
+      }
+      // Standard foreground colors (30-37)
+      case 30:
+      case 31:
+      case 32:
+      case 33:
+      case 34:
+      case 35:
+      case 36:
+      case 37: {
+        fgColor = ansi256ToColorName(code - 30);
+        break;
+      }
+      // Extended foreground: 256-color or RGB
+      case 38: {
+        if (params[index + 1] === 5 && params[index + 2] !== void 0) {
+          fgColor = ansi256ToColorName(params[index + 2]);
+          index += 2;
+        } else if (params[index + 1] === 2 && index + 4 < params.length) {
+          fgColor = `rgb(${params[index + 2]}, ${params[index + 3]}, ${params[index + 4]})`;
+          index += 4;
+        }
+        break;
+      }
+      // Default foreground
+      case 39: {
+        fgColor = void 0;
+        break;
+      }
+      // Standard background colors (40-47)
+      case 40:
+      case 41:
+      case 42:
+      case 43:
+      case 44:
+      case 45:
+      case 46:
+      case 47: {
+        bgColor = ansi256ToColorName(code - 40);
+        break;
+      }
+      // Extended background: 256-color or RGB
+      case 48: {
+        if (params[index + 1] === 5 && params[index + 2] !== void 0) {
+          bgColor = ansi256ToColorName(params[index + 2]);
+          index += 2;
+        } else if (params[index + 1] === 2 && index + 4 < params.length) {
+          bgColor = `rgb(${params[index + 2]}, ${params[index + 3]}, ${params[index + 4]})`;
+          index += 4;
+        }
+        break;
+      }
+      // Default background
+      case 49: {
+        bgColor = void 0;
+        break;
+      }
+      // Bright foreground (90-97)
+      case 90:
+      case 91:
+      case 92:
+      case 93:
+      case 94:
+      case 95:
+      case 96:
+      case 97: {
+        fgColor = `ansi256(${code - 90 + 8})`;
+        break;
+      }
+      // Bright background (100-107)
+      case 100:
+      case 101:
+      case 102:
+      case 103:
+      case 104:
+      case 105:
+      case 106:
+      case 107: {
+        bgColor = `ansi256(${code - 100 + 8})`;
+        break;
+      }
+    }
+    index++;
+  }
+  return { bgColor, fgColor, formatFlags, link };
+};
+const REGIONAL_INDICATOR_START = 127462;
+const REGIONAL_INDICATOR_END = 127487;
+const SKIN_TONE_START = 127995;
+const SKIN_TONE_END = 127999;
+const ZWJ = 8205;
+const TAGS_BLOCK_START = 917504;
+const TAGS_BLOCK_END = 917631;
+const unicodeMarkRegex = new RegExp("\\p{Mark}", "u");
+const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+const isFullwidthGrapheme = (grapheme, codePoint) => {
+  if (isFullwidthCodePoint(codePoint)) {
+    return true;
+  }
+  if (grapheme.includes("️")) {
+    return true;
+  }
+  if (codePoint >= REGIONAL_INDICATOR_START && codePoint <= REGIONAL_INDICATOR_END) {
+    return true;
+  }
+  return false;
+};
+const oscHyperlinkRegex = /(?:\u001B\]|\u009D)8;([^;]*);(.*?)(?:\u001B\\|\u0007|\u009C)/;
+const parseOscHyperlink = (oscValue) => {
+  const match = oscHyperlinkRegex.exec(oscValue);
+  if (!match?.[2]) {
+    return void 0;
+  }
+  if (match[2].length === 0) {
+    return void 0;
+  }
+  const usesST = oscValue.endsWith("\x1B\\");
+  return usesST ? `ST:${match[2]}` : match[2];
+};
+const processTextToken = (text, line, state) => {
+  const segments = graphemeSegmenter.segment(text);
+  const graphemes = [];
+  for (const { segment } of segments) {
+    graphemes.push(segment);
+  }
+  for (let i = 0; i < graphemes.length; i++) {
+    let value = graphemes[i];
+    if (value === "	") {
+      for (let s = 0; s < 4; s++) {
+        line.pushChar(" ", state.formatFlags, state.fgColor, state.bgColor, state.link);
+      }
+      continue;
+    }
+    if (value === "\b") {
+      continue;
+    }
+    const firstCodePoint = value.codePointAt(0);
+    if (!firstCodePoint) {
+      continue;
+    }
+    if (firstCodePoint >= REGIONAL_INDICATOR_START && firstCodePoint <= REGIONAL_INDICATOR_END && i + 1 < graphemes.length) {
+      const nextGrapheme = graphemes[i + 1];
+      const nextCodePoint = nextGrapheme.codePointAt(0);
+      if (nextCodePoint && nextCodePoint >= REGIONAL_INDICATOR_START && nextCodePoint <= REGIONAL_INDICATOR_END) {
+        value += nextGrapheme;
+        i++;
+      }
+    } else {
+      while (i + 1 < graphemes.length) {
+        const nextGrapheme = graphemes[i + 1];
+        const nextCodePoint = nextGrapheme.codePointAt(0);
+        if (!nextCodePoint) {
+          break;
+        }
+        const firstCharIsUnicodeMark = unicodeMarkRegex.test(String.fromCodePoint(nextCodePoint));
+        const isSkinToneModifier = nextCodePoint >= SKIN_TONE_START && nextCodePoint <= SKIN_TONE_END;
+        const isZeroWidthJoiner = nextCodePoint === ZWJ;
+        const isTagsBlock = nextCodePoint >= TAGS_BLOCK_START && nextCodePoint <= TAGS_BLOCK_END;
+        if (!firstCharIsUnicodeMark && !isSkinToneModifier && !isZeroWidthJoiner && !isTagsBlock) {
+          break;
+        }
+        value += nextGrapheme;
+        i++;
+        if (isZeroWidthJoiner && i + 1 < graphemes.length) {
+          value += graphemes[i + 1];
+          i++;
+        }
+      }
+    }
+    const fw = isFullwidthGrapheme(value, firstCodePoint);
+    const flags = fw ? state.formatFlags | FULL_WIDTH_MASK : state.formatFlags;
+    line.pushChar(value, flags, state.fgColor, state.bgColor, state.link);
+  }
+};
+const textToStyledLine = (text) => {
+  if (text.length === 0) {
+    return new StyledLine();
+  }
+  const tokens = tokenizeAnsi(text);
+  const line = new StyledLine();
+  let sgrState = createSgrState();
+  for (const token of tokens) {
+    switch (token.type) {
+      case "csi": {
+        if (token.finalCharacter === "m") {
+          sgrState = applySgrParams(sgrState, token.parameterString);
+        }
+        break;
+      }
+      case "osc": {
+        const link = parseOscHyperlink(token.value);
+        if (link !== void 0) {
+          sgrState = { ...sgrState, link };
+        } else if (token.value.includes("8;")) {
+          sgrState = { ...sgrState, link: void 0 };
+        }
+        break;
+      }
+      case "text": {
+        processTextToken(token.value, line, sgrState);
+        break;
+      }
+    }
+  }
+  return line;
+};
+const asciiPrintableRegex = /^[\u0020-\u007E]*$/;
+const plainTextToStyledLine = (text) => {
+  if (text.length === 0) {
+    return new StyledLine();
+  }
+  const line = new StyledLine();
+  if (asciiPrintableRegex.test(text)) {
+    for (const element of text) {
+      line.pushChar(element, 0);
+    }
+    return line;
+  }
+  processTextToken(text, line, createSgrState());
+  return line;
+};
+
+const cache = new DataLimitedLruMap(1e4, 1e6);
+const widthCache = /* @__PURE__ */ new Map();
+const styledLineCache = new DataLimitedLruMap(1e4, 1e6);
+let styledLineCacheEnabled = true;
+let currentStringWidth = getStringWidth;
+const setEnableStyledLineCache = (enabled) => {
+  styledLineCacheEnabled = enabled;
+  if (!enabled) {
+    styledLineCache.clear();
+  }
+};
+const clearStyledLineCache = () => {
+  styledLineCache.clear();
+};
+const setStringWidthFunction = (function_) => {
+  currentStringWidth = function_;
+  clearStringWidthCache();
+};
+const clearStringWidthCache = () => {
+  cache.clear();
+  widthCache.clear();
+  styledLineCache.clear();
+};
+const inkCharacterWidth = (text) => {
+  const cached = widthCache.get(text);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let calculatedWidth;
+  try {
+    calculatedWidth = currentStringWidth(text);
+  } catch {
+    calculatedWidth = 1;
+  }
+  widthCache.set(text, calculatedWidth);
+  return calculatedWidth;
+};
+const safeGetStringWidth = (text) => {
+  try {
+    return currentStringWidth(text);
+  } catch {
+    return 1;
+  }
+};
+const measureText = (text) => {
+  if (text.length === 0) {
+    return {
+      height: 0,
+      width: 0
+    };
+  }
+  const cachedDimensions = cache.get(text);
+  if (cachedDimensions) {
+    return cachedDimensions;
+  }
+  const lines = text.split("\n");
+  const width = Math.max(...lines.map((line) => safeGetStringWidth(line)));
+  const height = lines.length;
+  const dimensions = { height, width };
+  cache.set(text, dimensions);
+  return dimensions;
+};
+const toStyledLine = (text) => {
+  if (styledLineCacheEnabled) {
+    const cached = styledLineCache.get(text);
+    if (cached !== void 0) {
+      return cached;
+    }
+  }
+  const line = textToStyledLine(text);
+  if (styledLineCacheEnabled) {
+    styledLineCache.set(text, line);
+  }
+  return line;
+};
+const styledLineWidth = (line) => {
+  let length = 0;
+  for (let i = 0; i < line.length; i++) {
+    length += inkCharacterWidth(line.getValue(i));
+  }
+  return length;
+};
+const splitStyledLineByNewline = (line) => {
+  if (line.length === 0) {
+    return [new StyledLine()];
+  }
+  const lines = [];
+  let start = 0;
+  for (let i = 0; i < line.length; i++) {
+    if (line.getValue(i) === "\n") {
+      lines.push(i > start ? line.slice(start, i) : new StyledLine());
+      start = i + 1;
+    }
+  }
+  lines.push(start < line.length ? line.slice(start) : new StyledLine());
+  return lines;
+};
+const measureStyledLine = (line) => {
+  if (line.length === 0) {
+    return { height: 0, width: 0 };
+  }
+  const lines = splitStyledLineByNewline(line);
+  let maxWidth = 0;
+  for (const l of lines) {
+    maxWidth = Math.max(maxWidth, styledLineWidth(l));
+  }
+  return { height: lines.length, width: maxWidth };
+};
+
+export { BOLD_MASK as B, DIM_MASK as D, FULL_WIDTH_MASK as F, HIDDEN_MASK as H, ITALIC_MASK as I, StyledLine as S, UNDERLINE_MASK as U, clearStyledLineCache as a, setStringWidthFunction as b, clearStringWidthCache as c, styledLineWidth as d, INVERSE_MASK as e, STRIKETHROUGH_MASK as f, colorToSgrParams as g, colorToAnsi256 as h, inkCharacterWidth as i, textToStyledLine as j, measureStyledLine as k, splitStyledLineByNewline as l, measureText as m, plainTextToStyledLine as p, setEnableStyledLineCache as s, toStyledLine as t };